diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..26ded4a --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +weights/ \ No newline at end of file diff --git a/README.md b/README.md index 63e1ca5..1147d2e 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,12 @@ **OmniParser** is a comprehensive method for parsing user interface screenshots into structured and easy-to-understand elements, which significantly enhances the ability of GPT-4V to generate actions that can be accurately grounded in the corresponding regions of the interface. +## Install +```python +conda create -n "omni" python==3.12 +pip install -r requirements.txt +``` + ## Examples: We put together a few simple examples in the demo.ipynb. diff --git a/__pycache__/utils.cpython-312.pyc b/__pycache__/utils.cpython-312.pyc new file mode 100644 index 0000000..395a981 Binary files /dev/null and b/__pycache__/utils.cpython-312.pyc differ diff --git a/__pycache__/utils.cpython-39.pyc b/__pycache__/utils.cpython-39.pyc new file mode 100644 index 0000000..0de1a1d Binary files /dev/null and b/__pycache__/utils.cpython-39.pyc differ diff --git a/demo.ipynb b/demo.ipynb index 780a7ab..3dc633e 100644 --- a/demo.ipynb +++ b/demo.ipynb @@ -2,48 +2,402 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/yadonglu/anaconda3/envs/pilot/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n", - "/home/yadonglu/anaconda3/envs/pilot/lib/python3.9/site-packages/transformers/utils/generic.py:485: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n", - " _torch_pytree._register_pytree_node(\n" - ] - } - ], - "source": [ - "from utils import get_som_labeled_img, check_ocr_box, get_caption_model_processor, get_dino_model, get_yolo_model\n", - "import torch\n", - "from ultralytics import YOLO\n", - "from PIL import Image\n", - "device = 'cpu'\n", - "\n", - "# dino_model = get_dino_model(load_hf_model=True, device=device)\n", - "som_model = get_yolo_model(model_path='finetuned_icon_detect.pt')\n", - "\n", - "# caption_model_processor = get_caption_model_processor(\"Salesforce/blip2-opt-2.7b\", device=device)\n", - "# caption_model_processor['model'].to(torch.float32)\n", - "# som_model.to(device)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 21, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(device(type='cpu'), ultralytics.models.yolo.model.YOLO)" + "YOLO(\n", + " (model): DetectionModel(\n", + " (model): Sequential(\n", + " (0): Conv(\n", + " (conv): Conv2d(3, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(16, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (1): Conv(\n", + " (conv): Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(32, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (2): C2f(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(32, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(32, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(48, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(32, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): ModuleList(\n", + " (0): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(16, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(16, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (3): Conv(\n", + " (conv): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (4): C2f(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): ModuleList(\n", + " (0-1): 2 x Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(32, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(32, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (5): Conv(\n", + " (conv): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(128, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (6): C2f(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(128, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(128, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): ModuleList(\n", + " (0-1): 2 x Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (7): Conv(\n", + " (conv): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(256, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (8): C2f(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(256, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(384, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(256, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): ModuleList(\n", + " (0): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(128, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(128, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (9): SPPF(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(128, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(256, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): MaxPool2d(kernel_size=5, stride=1, padding=2, dilation=1, ceil_mode=False)\n", + " )\n", + " (10): Upsample(scale_factor=2.0, mode='nearest')\n", + " (11): Concat()\n", + " (12): C2f(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(384, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(128, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(128, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): ModuleList(\n", + " (0): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (13): Upsample(scale_factor=2.0, mode='nearest')\n", + " (14): Concat()\n", + " (15): C2f(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(96, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): ModuleList(\n", + " (0): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(32, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(32, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (16): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (17): Concat()\n", + " (18): C2f(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(128, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(128, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): ModuleList(\n", + " (0): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (19): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(128, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (20): Concat()\n", + " (21): C2f(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(384, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(256, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(384, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(256, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (m): ModuleList(\n", + " (0): Bottleneck(\n", + " (cv1): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(128, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (cv2): Conv(\n", + " (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(128, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (22): Detect(\n", + " (cv2): ModuleList(\n", + " (0): Sequential(\n", + " (0): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (1): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (2): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (1): Sequential(\n", + " (0): Conv(\n", + " (conv): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (1): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (2): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (2): Sequential(\n", + " (0): Conv(\n", + " (conv): Conv2d(256, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (1): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (2): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " )\n", + " (cv3): ModuleList(\n", + " (0): Sequential(\n", + " (0): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (1): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (2): Conv2d(64, 1, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (1): Sequential(\n", + " (0): Conv(\n", + " (conv): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (1): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (2): Conv2d(64, 1, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (2): Sequential(\n", + " (0): Conv(\n", + " (conv): Conv2d(256, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (1): Conv(\n", + " (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn): BatchNorm2d(64, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)\n", + " (act): SiLU(inplace=True)\n", + " )\n", + " (2): Conv2d(64, 1, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " )\n", + " (dfl): DFL(\n", + " (conv): Conv2d(16, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + ")" ] }, - "execution_count": 21, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from utils import get_som_labeled_img, check_ocr_box, get_caption_model_processor, get_yolo_model\n", + "import torch\n", + "from ultralytics import YOLO\n", + "from PIL import Image\n", + "device = 'cuda'\n", + "\n", + "# dino_model = get_dino_model(load_hf_model=True, device=device)\n", + "som_model = get_yolo_model(model_path='omniparser/weights/best.pt')\n", + "\n", + "# caption_model_processor = get_caption_model_processor(\"Salesforce/blip2-opt-2.7b\", device=device)\n", + "# caption_model_processor['model'].to(torch.float32)\n", + "som_model.to(device)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(device(type='cuda', index=0), ultralytics.models.yolo.model.YOLO)" + ] + }, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -54,7 +408,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -62,9 +416,8 @@ "output_type": "stream", "text": [ "\n", - "image 1/1 /home/yadonglu/sandbox/screenparsing_collab/screenparsing/omniparser/examples/pc_1.png: 800x1280 210 icons, 69.9ms\n", - "Speed: 7.7ms preprocess, 69.9ms inference, 1.7ms postprocess per image at shape (1, 3, 800, 1280)\n", - "boxes cpu\n" + "image 1/1 /home/yadonglu/sandbox/OmniParser/imgs/pc_1.png: 800x1280 211 icons, 51.2ms\n", + "Speed: 3.7ms preprocess, 51.2ms inference, 160.7ms postprocess per image at shape (1, 3, 800, 1280)\n" ] } ], @@ -250,22 +603,22 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 3, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7YAAAJTCAYAAAA8BIodAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9d3hV152o/a69Tz9HvfeCCkj03psxYIx7iXt6TybJzNyZTDKZ3LlT8k0ymdSZTJrtuBv3btPB9I4AIdRQ711Hp++9vj+2EGAESCBsbJ/3eXjQ2WWttfv6dSGllIQJEyZMmDBhwoQJEyZMmDAfU5SPegBhwoQJEyZMmDBhwoQJEybM1RAWbMOECRMmTJgwYcKECRMmzMeasGAbJkyYMGHChAkTJkyYMGE+1oQF2zBhwoQJEyZMmDBhwoQJ87EmLNiGCRMmTJgwYcKECRMmTJiPNWHBNkyYMGHChAkTJkyYMGHCfKwJC7ZhwoQJEyZMmDBhwoQJE+ZjTViwDRMmTJgwYcKECRMmTJgwH2vCgm2YMGHChAkTJkyYMGHChPlYYxrphh29A9dyHB85SmMfjj8eRGg6WFSwmWAgAJoEhxmsJpAYy4IagVlp+G8df9X9SgkVLQr9XoHRwaUxqVCUpmE+58pJqdFQ8QI+bxsCcXY58pw2xdBSkzmCzMIHUFXbJfs62XaARw/8Ky5rFGbVDEBID9Hn68GkmHBZo/AGB/CFvADcVPAgK/LuPa8Nc/97OFv/GUyxIMyDQwhAqBtMMSAsIIMQ6gKp40n8PwSi7hraX+uFhq85sKUopH0JTNHgLoHGRyHhFohdDooFevdC/e/ANkEj5T+8CPWypzJMmDBhwpzD5b9AHx3i8puEuQZcz/dEmE8G19uzPdb3/PVyfEqwGdVXOuLtNdt4dHPaFfU14Ba8v9VBa2stO3c+wYC7m8lTbqKo6AZ6eprZtetJdE1jwYKHiY3LJDUtxLSZfsQlTlZ8lGtEfY9YsL0slScR+3cYfwsxeGecc3sIYUhxg8i5SyEnf8y6v1pEUENt6EUkOFE+NxOR6EQebUZ/rgSxdgJKYTxEWNFfLUW+WYaSFzcm/UoJj26xcKRGITka5uRDex8cqAJdh4mZkJsEh05DbRtE2uF3X/YQ6zrnXEqd1vqNREWlk5l/CyAQQlBf/R61lW+gKGYKJ3+eprqt9HaVY7UnkJ53z2UFW29wgG5fG1+Z930SXCmYFEMw/enWv+GeyV8hN24C3Z52fvX+D6npLqfX13lBG4rWi6p3IrL+C0zxoFhB98Hpv4bcXwESgp1Q+QXw16KELmwDAfFrjHPV8jxkfA26tkLne+Crh8xvg/sYoI/8nGvaebfjeagqKB8zXwYpL348YLxYxUd8TKLXi3VXFegj+2wEM2LxFZ99qQpAVbjkiy/Mh4tHg+0dJkLDXFJVwKK4EK6x+8qECRMmzKcaTUpaQiH0YcQvASSazFjCH8kPDSkZ8dxTD4Gn0YTUxnYMJqfEnqJddm5kdm/G1fh1MCdC1AoItkLfDpB+sGYZywJ10LsNZAB36q/xx37uisel6xovv/QjevtaSU+fxOOPf43vffcNXnnlx0ipoygqmzcPcNfd/3bFfQzHmE05xMHdqP/veyjjCjHfcg96Qy3Bd16BQADT0lWoU2cR2vAm2tH9ICXaT36PHE6w1SXCGxxeZSJA2k3XTuoQAmVVAYQ09FdPQIILdB359GH0eVkoa8cjDzWOebdSQpRD8M+fAW8AEiPhj5sMwfabq6G+A26aBn/zBMiLSi+S7s4yNM2Pqlopmv51dD0IQFr2DRRO+izdnSfp7Sof1dj6/D38dMvfoCgqqwvvZVx8EVG2OKLtcfzz+q/xlbk/YFHuTdQcvES7gRYofxBQIfXbhoArVEPI7XgB+vdDoPkSJwgGTkH8TeDIA0JGk8FOsKWB6gLXJOjeObJjkhL+/AcrlRXGfWSxQDB4VjC87Y4gCxeHRtbYdUR5mYX2VhVNC+Lx9GCxOrFaHABkZIXIzg1+pONT2/px/mkH4papkBptLPQH4eVDEOeCBXlwohH2nYaQzvaCqTwzLw9/EDx+SIiU/MPtPqzmj/IoPh5c/D0xtvQHFf5QY8WjCaTU6d37JubYFBz5M7GpMClSw6mO8Ksf5rrherPSjcyf6Rr1HRYSwlxH9Ooa/9DeRE9vL+5jx5CahiUuDseE8VgUlf9ITCXbbPmoh/mpYaDORF+pGQl4/W40PYTLHoVAIAF/0IvVbEMg0DVByC1QTIyZGVfqhrI/ZaUHS+Tl35JCjYb8p4ydTHHQ8Qy0PQH5T4LWA9YMqP1H6H6Tq33rCiGIiEjg9On9CARmkwV/YIDTpw8QH59FTGw6M2beOebv2DHVpYukVBz/8wxaaQnmZatRcvLR609j/fL30PbtwPHLxxj45gPoJ45evI1+P67/2IHwBCHKCg4LdAxAUAOTivuv56GnRo7lsM+iCsiOQWTHIDKikCfbkTowEESkRoDNhJifhXzp+Jh3nZcMabGwvxKO10FpPXxtJfR6DAvupuMw4AOn9eJtDPTXM9BfT3L6AnyedprrthMRlUPBxIfxeTuQ+ugFGyl1enyduCyRzMpcwuP7fk5p2yFOth7CaYkkwZXMqWMll2lFh2CboSWKXALVfwWWVND9YMuHuLuhzgKdLw67tzBB9Fzo3g49uyH1s+CaDN1bofVl8JyG7L+GlnUjP66WZkHNaZVx4+CLX4CnnoJjx4x1fX0fP6EWwOsRtDT38/Qz36G6ah8REQk89NCvycicQoLvOpmcSaDLbVhtU6Jg2XioaofPLYCDNfC1peCwwsZSJmcL8u5WKWuCHz0H3oA+UmPvpxopJVJKggE/mha6phKBL6CCtCMl+GpLqfvdt0i67Ts48meClPg8Hrzax/N5CvPpRgiB2WJFNZnCwm2Y6wYJBKSk+Z13aHn8CWxZmTgKCkgdl4u02j40pWYYA90n8Hcr7D25gd+/8U/4gx7uWfItbl3wRUpr9vG/r/+I79z1nxRkTAXA5NBJXu5FjJH05WtV6dhrRWojVP/ZC8CWCceWQswqSPoSeCsMgba3Avr3gvvgmIxN00L09bXhdMURERFPe3s17e2n8fn6KShcRE9PM2++8W98/RvPM5Ypn8ZUsFWychF2B75/+3vMN92B+e6H0etrCG1bj+9n/4TzufWYps0hcAnBFl0i+nwoGdGoX54FFhV5sh39zweQWtCIeb1WCAEWFf3tU8idtajfXwKF8VDegf7kEUR1F+Lm8cg3To5514lRhtA64IelxYYQmxQNtkHr1MOL4XC1sf5SKIqZnMI7qal4DYDJs7+HyWRHCJXs/NvxuFsIBEYfLz0nazn9vh5K2w4R1AKoVpWvz/8R71e/y6HG90fWSOwd4KsCz1Hj/9KbDNNrxj9C3F3Q+fLw+6lgjjME24FSCPVAxGSIWQRNT4A5BvSAEao7GsxmuO02yMsD26W9sj82NDQco7W1kq9+7Wlef/1f2bP3OTIyp3zUwzpLSIONJw1t5deWGn/bLdDRD7/dDN9cDjOyYFMpVS0QG4TNxwzDbpiRIaXE6+7HYbdic4wsJuVKCfgVhBDo3n4an/hHhFBQrHbAEAwiXQ5i7GGLbZiPH7qu09ffj7TaMZktYeE2zHWDBALNzQhVRXU6cRQXIdSRJxaRQcOucKUEKlS8h68skYmwSSLXhFCjRvZdED0+1Bb3FfUlhUDPiER3mAm6fUhtZH22H6ymafvI5vn+LgVPs6Ck5FUWFyzGlZZFUAvg9ffz/JbfUNV0nEDonJOtgGqTKGPkeaZY5Oisv/4aCPVB9k8Mw5IwgyUN1EjQ+g1DU7AFWv901WPz+fqpqTnEAw/+F7m5c/j5f66mubkMpzOamTPvoqPjNK+88n8JBDzA2M1VxlSw1StOone04fjtUyjpWegdbYQ2vIntb/8vav54TEWTCWgjcC5XFJTVBeg7apG7alH/ZhGMi4XyjrEc7oVoOtT1IFIjIS8OVIHIi0OsHY/+ailifKJhPQ6N/URN1w2X49+9Bw8thunjjGXvHYE3DsLvvwo5SYY191LEJk7GYo2iuf59pNRpa9pLj/Uk6TmrkHoIIRRG6wNhNztZVXgPLx79E0EtQLwzmb9d8lPcgT721m3GZYmiZ5j42vMwxULC/YaLgwxB4iPgnAptj4JrNgyUMFyggvQLdK+g9WVIugfiVhmycPvrkHgH5P7QEGqbHoNQL5hGEeceDMLvfgfR0ZeOT/04kZM7i7/69ssEQz46O2qYN++Bj3pIw5McBdOz4J9fNzKi3T0D/vUOKEyGHRXGJtGAGVZNhffHXpf0iURKiRYKYVYFUZGR13wybpEgdY3WV36Br/Y45rg03KW7cE1ehj1rPBaL5ROjNArz6UJKiaIodPX0YQq7doa5npASS3IK0cuWYI6Lp/HXv8EcF0vsjJkj2n1gl4muPxj3tGIzIsO0QXuH4gBLPAQ7QPMM7iDAFGVsI4Oge4QRTRZ1/sRJSvCGBJ5BRbTDBHazPBv7qUOoXWA93EBCVi0owvCU1PTzp38KnMl9qjb1obQOGNuOFl0SmJ/BwMOT2fyF39F1vB57fASO+Eg87b14O/sRQuBMiUExqfQ3diJDOoFeD4rVhC324sKW1HX0nl4kZkKqg6wuhca+Ep479Qp3L/kGDmsEf3f/f/ODP957XlLXj5xgBzT+BCIWgCkRpNfIe+Mtg9ofGoamyMXQ+uhVdSMBmy2CvPx5vLDu+zgcMQQCXqZNu4X+vnb+/KfPo2khFi36PHZ7JKGQxOMR2G0S5SqTv46pYCvd/QSe/D0iKQXTzAUw0I92aC/+x/8HERGJkpOPrD99+YYsKqREIDdVQpsb2TGAyIxGVlwjwVZKRL+RAVl/pRTlromIJTno644hS1ogxo5y/xRoH0B/5ihoErW6C9uLJ0bWvioIzM9ET3ReNPPNsTrjRviX+yA9Dv682fDC/swCmJkHbh+UN118/FLqgCA5fQF1lW8RDPQDUHHiaYRQsDuSqKl8g76eaqz2hBGcEkmvvwsAlyWSyo4THG3eA0BBwmQibTE4LRF8fd6P2FL1Bq8e/8uw4xKhduNvU6wRpO7eb/zufg9cMyHz32DgCLL518OOo3+9Cd0NPbskfYeNDMiax3i51v0vqA5DTta9g92k6qOS2/1+Q4HwScFksiIUleef+zuKim5g6tS116elYWUxlDRAUw/YzfDiAXDZIMIGDd0gYW8FPP1n+OUXjGei3/tRD/rjgaZrmD7M7Ge6ZkwOCmfjqTyEL+TH31AOWVefNT5MmI8KIQSqqqLpY5zp5WPGRxnfHOZiSJyTJxK7eiWq00nvrl14yiuInTFjZHv7QetSMCdAxpcMgbX2vwzPuJy/AWsKBFrh9L8b/5tiIPf/QMuzhuccQMStAWI+HzDak9A0oLCjwczJdpUurzByx1gl4+M1lmYGSY/QkQOCpu/aUWr6scgeY16dFgkNvejPHoUuL1hUlEemo++ogTJj/hiYn4F/Re5oTxG2dSdQOj1GWExHH9FZ8az63VdRTApaIMS7X/09ceNTmfcPdyIUwbG/bGXvz15HajqTvric6f9wx/D3vhbC/cKLeF57nVDWaupz1rDt53/H5PQ55C//Br995fusmvUgLnvkoDHpOkKxQ9KXQXODNQ0af2q4H6d8HQqeBns+1P2IEWfEGgYpobnRhBAWHnzwVzQ1luIPDJCclE90TCqfue+nNDWdxGSykpJSiKIodLTD+1sdjMsPkJcfvKokoWMj2J5JyWqxYLnzQXBFoETH4v3x9xCZOVgf/ip6Txd6dQWhoyPw3dZ08AbBrA5qdBTo91+7t6sE68YqMCn4gwEGHn2fyKgoTEIxXKHfKkOaFMMNWpeQ5MLk1zAduJikCR6Ph0AgQEREBEqPH9Htw/v5aRds19glaOgSdPbD95+GSZnQ2AUnGw2lVXWr4aZ8pMbw1oxzyQsUV11tB/D01YAQnCp5DF0LIj5Q7+bovp8TCnpwRo0jJnEmymX8IIJ6gHfLn8ZudqEIE68ff4poWzwSqO4o4983fXdIC9Xj7SDaFse01CXnN6IPYOt6FKlEo2shaHkUTCnGOs0Ptf8MwoQIdYAMMZD63wSdC89rQnMLzCmS5P/nHaoWNBy6B5p/YMecrI8q+68QZ/99Eujra+OJv3wDkMycdTceTy+RkZcIzP4wOWMWj7LDzGz4xQbjeXLZ4NapRuY0iwneNyy2kXaYkm14L/d5r5+U+dc9g6f5w1BoSECYLCTf/48gofGxv8eaMo6oubcigTafwCSu7sVtN0GM+ZPzjIb5mCENRe91qSAM86lEahrNf3oUdB1bViaBpiacEycCAh0jc/KlOCOyOAuNcEvvoL0pZqkxlyr7NmR+yyin2LoOUh8GRz7nZ/NVDWuvJmFfq4nNpwbo0QVuxYS0G9P2PgR7ekyU+VVuyg4wN0Ib+pCLGWmQG4t86TjiromI6WnIjZWIZbmI5bmIw01DU349yoaWE3P+OZASXdeHYoqFECiKcvY5lRLpNBvJaAdJnJKNUGDXv77I/B/dQ9q8AoruW8j2f3oOd1M3q3//VU489T79DZ0oZhXTMEltpJQEqhrwv/YyiseDKiQx0SnER6fiDQxQ2VCC3erCbDrj5SEHS29+xOgBzO5NoLuNPDcR88BfD/27DE1H2T0QMRd8FeA+DIDFvQV/9ANGotdR0ter4orQmTbDBGLyOWsCGNJN8eBvzfgnoaLcQl+PClxd7NnYCLY+L2L9qzDgxvO9L6DkT0C2NaPXVAKCga/ci4iNQy8vRfb3QUExxCVevL2QjizvQFmZj4x3IpJc6DXdYzLUixLU6ct2srHIQ05WAXn5+fT19QGQkBCPw+EcXXNdXezcsZOIyGjmbfAggsNrfWs6FLp7JcVNpVirfXQfU3EqgjMOJXqtTldIkm1RUfLGkxqvEGk//yEJ+DrRpSAx9zukZ05ASp2uzk66OjsRiiAhIQmXy8rJ/f9CfMpCcid+5fIHICVBzc+s5BUsjrkHXdfRQiEys7KJiDw/ede6Y7/hQMNmUiKyzlsu0BHSz5HWOextuhGL5UJ3Ll1KiiLfY172QQKRNyNNw5RRUiVqnLzks6W5gRG6LwQC4BtMpiQllJZC5zme1IcOqvT1Xl+TmHF5GjNmaRdNCC4lBEOC2tpDdHXVoygqzz37N0ybfhurV/8NXZ0qp05+uO50EZE6KakhQyCREsv2CsONv98HP3kbWnqNDdv64Icvo01Mo74DevqcEOkgsTiGFZPhv9+F1h5wWgXP7LBgGuMaxbEunVVTQljCZWkAI7awvb2dpqYmIiMjyczMxGy+UKskJWxtU/BqIISCRJJ01/9BMVkQgF+HvzuqXrVAmmiFX0wLkWK/unbChAlzZZx5hK+D6fmnnppggKBqIuO7f0XXho3o7gGy/9//xVlcRAjJf3W1Y72M2+6EvihWkEzPTsPrLXImIIyqE54KCLYblSgc+RCzxKg64akclG8UhiRjKeFkr4kNzVZMshebohEc/D5bTIZwG9DAYhNsa7NgCwZJHhyDrO9FiXcgHpwKLgt6Qy/kxqLckAct7kuWBZRSUldbywvPP0dPdxcIQXR0NHffex9Z2dkXVUJ1nmwkMjOBFb/+IqpZxdvlxhbrovVgNd5ON3pIJyonkf4GY0L4QW8Fn9dLCMGrBxq5IRAYWu6wuUiMTuNE9V5KI1S+c9d/4rJHoekhpoxbSLRrbMqDXg1CejF7dhNwLiHoXGQstGWCbcH5GzrGgWM1Zs8uTJ7dCH0AeQWCLYDFIklJC41oDiAl1NaMTeDx2Ezl/D5E5UmCi1eiR9mh/hRECJRpRdijo7HYbEiTGV/eHfD842j/+HOYuWDYppQuLyKoId8sg1smIIoS0Z87Ck2GkGl/4QTSMXb1PrTMKPwrxgHQ09vNtLnz6Ojo4Of//Ss6OgzX54SEBNauXcusWbNQRxigH5uayJo7b2Hzxk20d7YTn3xxX31F6qyOHyDK20vR5wqIzIgYWtd0oIWWLe14PT5esecihG1Y05WuS3yBKCKix1NZWUEgEEPehClomkZ9XS1ScaGooxds7FYHuVkFVFWW09/VTzAxhD3OEPJ7e3vo6uxEvcxtlJiUQX+FxgO33oFfC9A50E1KZCICQXd3Fwff+D3zskc9tCvm+DGV6iqF2Fgd1QRbthoPVcKgrqWpUaGp8fpxH/F6BSaTiZ8VeomOHv5l39ur0NmuMnPmSqZPXzKkITSpZhTVEOQbGz48yU0LGa5I0dEaDqcECaaqdqrtQXZNTCAubRwIQcA7QOvJQ9zZEMRqzuaHeatojFGIsEtUQL6qE9IgYVCXsv3k2B5DSIMejyA9VjIt59PtcgjGhKGkpISenh6ysrLo7e1ly5YtLFmyBKv1wo9beb8g1Q5fzA0Z8x0ZjUAglCs7l1JKvF4vDodRpur0gODpGoWugCDFHp5WhwkT5tPNLu8AFiFYVTABUTABkKN2Z4k5M4+VRrmYM39r/Qx5xikWY16U9BmwJBoerOlfN0LBeo2oNNwhwYFuM04bWEMKBWYfNZqVPt2EUAxbnN0MUgW/FGxtNXNLyBirmJSErOtFbqhArMxHzMlA5MaCywJmFXHbBGSvD6q7zhu7lJKW5mY2rH+XSZMno0sdVVUJBUNseO9dbr71VlJSUi+YJgshKLp/IRWv7WPn/3uRRf9yHwW3zUYLhFDMJhSTAlIS6Ds/5umMcBsMBHj1pXUI1UTxtMWYiosJlZSgNO3F2f4C1midKVOm8+3//ltMqgmEkTDq+wv/1vBuFD4G6kwEej7auWXQuRBv4t8Dg99bj4fe3l4kEqvFSkxsLIqiQPsvUH2lY9avz+dDEQKzxUjEZ1RuCKBLiW2ME3GM6Syxq/wQXbGRKBYrSInu7kOEAmTPnkNSdASi24MHjDq0F3kQLTuNYNNQvIPA+5WGlU8CubEACE/QKAU0DMFQkGAgiM1mRRlB9LFwBzAfbSE43XCPzcrK4mh/P08++SR+/9ksZk1NTTzxxBPYbDamTJkypA3SNI1gMIjJZEJVVQKBAJ2dncTGxtLV1UVycjJLlywl+N67lx2L2WrCrJtwxNuJOEcItsfYsNjMBEKXN83rUqeqsgJd15lQNHFICI+IjOTIwV0Ez9EwjRShKHR2tONyRZCYmHSe9srliqCpoYHW1pZLtmF32HE6nCQmJtI20Mmv9/yKNfnLuGXCClRVRfmQYxBCQTCZ4W+/72ZgoBxd10nPyCDCFXH5nS+DpmsoQrlAYxjSNFRVoa21lbj4eOPFdxEk0NnRQWdnB5mZWezeGcmL6yyXjAU+83EaX9xLd3cFJpOJzKxsbFaJ4foxOqSU1NScxuv1kpSUTGxc3Hkfiu7uLqxW25AAcgZN1xBCobXFzIkS6wVJufSMDDpWzaFz8JpLKVEm5cBj25ECAppgUbHGl2/w4/V6aWioR+o6GZlZ2O1Xb7KrKD9FckoqVqsVv99Ply+Kv3/GzkUcKj51DAwM0NrayooVxrMppaS0tJTq6momTJgw7D7RFsnS+CCH9u+jqamJqKgoli1bhsk0+s+L1+tl86HNrLjpJhRF4WAXPF17tUcVJkyYsSBsuf3okUCSycS3IqOxqkYpqlAohOkDZalCoRC9PT3Excdf0Ea/08R5GWsGd+s/BmmfA18tRC8yYmqbSkFYIOs7Rnxt/zlFTVr8KjF2iLPqBDxdpNtVzBrsPFJJU005OTMXkZKdhdkksKlg8glj6i9AJLiQdT3IYy2I8YmIKBtyfQXSYUZZVQB1veC+MHVzd1cXr7z0IjfdfDPr332XFStXIYTg3bffZPWatbz60ovc98BDxMbGXrCvFggSmRlH/MQMHPERdJY1ophVpn9zNZ7WXjR/iL669mFOumTfnl0U5OcRFxvHoSO7SPjGX7HttV3clBdB1IK5mHaVowQFUTmAog0bOhXoUT5ywfYMUkqCwQCHDx+irLQUicTv81NUXMzS5TeMeX/1dXXsfH87997/AA6HA6/Xy7pnn2Hh4sXk5ReMaV9jmzwqGMQUHUf2136I5hugY8ubNB/cRVVHL8nRESgDvZdPP6tLtGQXjV+dxFPPPMEjn/sCrogIYz8hQEoqKsqJio42BC0pEUBPbw/vvv0Wdpud+QunkZCQYMR/CTGk0JKDbUhdoigC84EmHI8dGnpLh0IhNm7ceJ5Qewafz8fGjRspLi7GbDbj9XrZtm0biqLg9/tZtGgRZWVlmEwmampqMJvNJCUlYbFaUO22EYkWUoKnw4vJfvayeLt9Iz7/7a2tmC1xjMsvwO/3YbPZURQFs9mM3eGg7xzB9kyty3NfhMO5bwSDAbo6O5g8ZRrd3V3o50hXiqKQm5eHXjM6qcCvBWhxt19RUo7du3Zy9PDhod9z5s1j2vSRJUw4FwEEg/1s3/o2xRMnsn/vFj7/xS9hGnS5PKNROnNOzo3jGO7vM783rt/AxEmTSU5JGVqnaRpvv/UyN99yG8FgH1ZrLGazROo6QlEuaF/TNEpP7ENKyfFje0hI+NKIj6u5qY6SkvdJTk6h5Oh+7r3vbFbkc6/v0LGdeSY+cKyhUIh3336VyVOmsm3Leh7+3OeIjIwaascfGMBsESiq7bz2t2zYSFFxMYpyvlv6uducmyFQCIGims5LsGBSJUFvD6+9sI7MrCx0XSc6wkpsVPZFr8mZazHc+nP7qq8pIyrCwv5dJTQ3NTF5wd1A9ojP7ycdn89HdHS0obHFOGfx8fGcPn3ppH+dHR00Nzdz2223oeuGBr2rq4v6+nrS09OJjY2lsbGRzs5OMjMzcblcNDY2EgwGycrKorW1la6uLlJTU/H7/VRUGMoZGZ3LiGMMwoQJE+ZTwvGSYwgtREpqGpUV5SxcvOS8b2F/fx9bN2/iznvuveC7qEsdhOHX5anTkQikEPTsA0uqJHqpoGszdO+QSL9ACknnJoG71EigC8a02ed3ExMKIjUdYR1A0wQV2zdw+qn/JT9Opf7wC0z/4X+SnJqEyaSAScUk7CBB31aN8sBUlB8sQ/pDRmLWE63GfCQ9Cn13HbRdWJry4IH9HDl8CCl1Duzfjz9gzNcPHzyILiUlR46QX1DIjStXnb+jEBz8zTtM/+ZqpnxpBe3H6zn423cwO23M/M4a4orS2fr9p/D3es7bTUpJY0M97a3NPHD/A5jNZoSAXQd2svCRtUTFui7Ie3Ol0Tdn4oY/yHmxw2NEMBjkj//7vyiKoWkIaSHi4+I5fuwYi5YsHdO+AMbl5dHZ2cHzzz7NbbffyWuvvsyEomJyx+WNeV9j7psoVBOaz0OgvQVLXCJIid/jxdPXj+7xXL6BQcorTpGbn09ZeRl5+fmUHD3K5ClTOXRgP6fKThIREcHU6TM4WXoCRShMnDQZFMGKm27C4XCwedNGmpubmD5jJp0dHRQVT+TE8WOEtBAdbe1MmTaNieJ8C53X66Wl8+LWx+bmZnw+H2azmfLyctLT0ykuLqaxsZH9+/cPTeLq6+sZN27cqM+dM9pJ2ZOViHOeEl3TiU+Pxe2+9LlTVZW0jEwsNhuNDQ2oikJ2Ti6KxYKUOn6/7wILSldHO3aHA5/Xi81uxzmMxdLn9eGIdqGaTMTFn59NWQiBxWIlPiGRupZLZ4gOaSG8Xi8mTeGvZ32R8QnjECHw+UaX6nbq1Gnk5eVjdzjweAaGhK0rJSU1lSXLlnP6dDVHjhzmxPFj5OXl09nZSW9vD5OnTMXpdLJ71y4yMjIYl5/P9q1bEAhuue12Nm1YjwT6entZddMaNm/aSH19PUuXLWfP7p3oms7kqdPYvHEj0dExaJpGSmoqmzduoL2tDZvdzuo1a3jlpZewWa0IIbjj7nu4cdVqent6eOmFdYxGPy4l5OUXMHPmLJ55+km2bdlMQ309iqoya/ZsWpqbycnNZc/u3SxeupSTJ07g9/tpbWkhJzeXcXn5vPvOWyQnpxARGcnCxUtoa22l9PgJqqoq0EIas+fOw+v1IJJT2Lxxo5FBu7eH1TfdzJZNG6irrWHZ8i8CV+5esnfPbmbOnkPxxIn4/X7MZjP79+6hrKyM6Oholt1wAy+/8AIWqxWHw8HqNTezcf17dHZ0UDB+PMnJKWzetIHMrGyCwSDNTU3MmjUbALPZTEREBHpyMhGRV2+l/yThdDrp7OwkEAhgtVqRUlJfX0/8MFr/c4mKjkZKyb59+5g+fTr9/f1s27aNoqIitm3bxqpVq/D7/ZhMJjZu3MgNN9zA+vXrWbp0KaWlpXR0dJCTk0MwGKSjowNd1zl8+DD2IieQ/uEcfJgwYUZE2HL70VM4YTzrnnyS0hPHmb9wEa+/8jIAN6xcxaYN6/H7fIRCIQ4dPEB1ZSVWm43xE4rYvXMHsldlyfduorL8FB3t7fQ19hL//TsokRqzj5cyyzsV5yQXR5rXs/yGFWzetJEbF64iZqmKDAg6fmlF6jpacymmgX5sJvB5BzALSbCxlJWFCayYlk1JUy9a9Q5s5kJUkxlT0IqiFxEaH48vNwiHGzB2DsG4aMiNNg6uxwOFsZAbjWVbzXnHvWjJUmpOn2bu/Pm4XBHcsHIlQghcThez5szBarVeIJgJk8rCX36OoNsHAgKKgqM4jUX/YxgNhBAgYMo/3E6xdw3bv/nnoX19Ph/bt27irjvuxGKxIKUkPj6e3s52zL4eVCVizOpFHj1ymPe3bT3vuVIVlTvuvpvU1FHUshwBwUAAVVX56je+CYDX4+GxP//prBFwjFEUhTlz5xHw+/mnH/4D9953P3PmzrsmSfmuSdCdanfQX3qYvqN70TSNturTVPe2Ye0fIH4E50vTNA4fOkhW/jgO7NtLekYGnR0dBINBent6KJwwgczMLPbv3cOtt9/JkcOH8Pl9TJk6jZdfXMfSZctRFAV3fz9dnZ3U19eh6zpms5mdO7aTlZ1DZUUFE5Omn9evoipYLlGvzmKxDLn3+nw+UlNTAYiIMCbH2dnZTJkyBbPZzKRJkwyrxyUC4D9IVGIEUYkXmWifl4D5wgT8qqpSOL4Im+P8pFxS16mrrcVucxD4QIxcdGwsbc1N2Ox2HM6LxAAP1vIDhv7/IOplSouYzGYsVjuP/eVx41AaG4mJjcVut6NrOtOzsoFh3D+GIRgM8vKLLzBn3nz27d3NQw9/dkT7XYyTJ07g7u8nOzuHQCBASkoqsXFx7N+3l+KJk9ixfRvFEyfhsNuZOGkyb7z2KrFxcXR0tHPixHFa21r5zH0P8P72bfT29jJ5ylTmL1yIoii4XBEcPLCfufMXUDxpEvMXLuKVl16guamR3t4e7n/oYd59+00qysvp7enm3q99gycffxS3242uabz79lssXX4D1VXnP/j9/f2cLD1BVFQ0BYWFF7wYdu14n8qKcvILCqmprubBRz7Lvj17qKmpoaGuDp/fT2NDPSeOHSMYDHLo4AFmzZnL7l07iYtPwGQysXzFjfzy5z/jyb88hsvpory8jFWr12Cz2Xhh3XPkjssjOjqGttZW7rnvPnbt2EFPTw+Tp0xj7rz5mM2jTTZw/v3c399P8aQ42tpaeWndOnJyczl65DCz587j4P79TJw0iYGBAe578CH+/IffU11VyfFjJUyfMZOd77/PipUrcTpdLFy0mN07dyAEHNi/j4TERIQQLFi0GIC6zrGL1/8kYLVaURSFd955h9zcXCP2RkqmTp16yf1sVhu33norx48f580332TChAl0dHRQU1ODx+Ohv7+f+vp6AoEA3d3daJpGYmIieXl5vP322yxcuJDo6Gg8Hg+JiYkUFBTQ29tLrdv94Rx4mDBhRk1YwP3osNsdjJ9QREN9HRERkdjsdo4eOUxCYiIpKankjMtl43vvUXr8OJ954EHWv/M2NaerSU1LI2lGMuVNB+mK6uCer9zPk48/Sm+Bl3o9xIT2VtQ8H7ZoG/2HmrBMCNJ/tAlrUQiTWSB9IKxG/fL2ykp6Q2akrhEXCd0+jcS4JOL6GjFrCjMnFbPfmUhLn4bJrGIK6aRLCBUl4Lsj+vIH6QthPnh+9RGr1co9993PE4/9mbT0DKoqKpAYIXdbN2/m4c99/oJ8EEII4iZljui8Bt0+TDZjXqDrOu9v28KMadNJSEggGAyyd+9ejp84wa133E1ScsqYlsOaPGWqYaT7ACPN7TNqzmSoPqc0iGoyXZMKFFJKfD4vVZWVzJg1m6rKSmbNmYPNZh9z4XbMBduQu4+2t9fRc2D72YWD0v9IL357WxsxE2IZP34CnR0ddHV20dfXS83panx+H3EmM52dnZhMZurqaunq6sQVEYHZbCY5OYVjJUdpb28nLj4e1aSSkprG8ePHuOcz91N2spRZs+fgdLqg8fwROewOJuRMoP394YWsCRMmDAU5p6enc/jwYRRFoby8nKysLBobG4dcQYZcQkZjbdMl1UdqscZYhs6b5tbJmpwx4jbOb0+ntraG/r4+8gvyOdx4vguoqppITssYGutwWG02Btz9Q+6FHyQUCtF5bkrhYTCbzNz9mfuHfr/1+qtMnzmLlEENlKPDA537R3RMEZGRrLppDa++/BL33n8/9g/EeI6W/MJC7rjrbqxWK/v27CYlNRVVVbE7HCQlJ5OVnU16egblp07xwrrnsFltg5lis8jOyaGqsgKH04nNZiMUCqEoCqFgkPe3bWP23Lk0NjYM9aVphuu1oigEA0GCwQDBYAiz2UxMTCxWqxWTyYzHM8CG997lhhUrSUxKpKry/DFbLMZ9brMPbxGdNXsOi5cuw+/zUVVRQTAYIBDwExUVRafDQUNdHRMnTebQwYPcevvtnDhxnPi4eFavWYvFaiE1NQ1VVUlKSube+x7AZrPx3DNP4/P5EEIYrjiDfTldLpxO1+DxB41jCwYZJokuAAGfh1AogGlQ8JVS0tNai8/dy7m7ZOfksGvHDtasXcucefOor6vDYrEQHR3NjStXERUVTWxcHBaLBUVVkBLsdjsJiYmsXrMGIQSpqWk0NzVSV1fL1GnTOXrkrAv7kPdCuITHELquc+TIEaKiopg/fz49PT2kpqYSeyaZxCXwej14B9wUFhZSWVmJyWQiOTmZuXPnomkafX196LrOzJkzaWxsBM5+rB0OB62trdhsNgKBwHnvzzBhwlz/fFqe1OtNgE9OSSYYDHCs5Ch2ux2bzYbFYqW1tQVFVQiFQqiqQn1dHe6BAdJjYtB1fahChd/vp76ulp7ubs74vumaTmtrixEWpWvUnK6mu9uoSnKuEKeoKlpMJk2VFTTu38bU6UWIxBy0xAy81QeJtCuUqtG06JFYfDaUkBlLwEzKlZdHNcYgBFFRUdx597386ff/S2y8kf+jq7OLL331a0RFRZ0Ns7pKqiorCPl9TJ8+ne7uLl559VWampv5yte/jXXQw24sURTlst/aMUOAFtLwer0IYZQoFUKw5uZbUK8gP8bl8Hm9PPfs00woLmb2nLns27uH5555mvseeGhM8qecy5iO3pqZR48JanZuHVrml4IomwqKiqV4Fpy6fCYQp8vJ8uXziEtKxL7CjpSSWbPm4PV4mDt3PvHxCZSfKuPGlasoO1lKfn4hGRmZlJQcIS4ujgkTiigtNVxjMzOzsNpspKemkRAfz+Ily2hvayWxOBE433/f7/dz48obqa2rpbb2/HFmZ2dz0003Dd3IqampRna2lhays7PJysoiIiICp9NJYWEhTqcTKSWtra3Q0UFkzKXd6aRuTPJd6Q4W/GAOQkDIr7H9n3aP4MwP056U1NXVMuB2M76oGDFMlO9IJo8WqwWny0VzUyNp6RkXxGk21NUSCFwYkzxcXyNZNpJ2srKz+dZ3vouqqlf1YjGbzWRnZw8pK84ISkbMSsWgBXAWp6urKT1xnOnTZ5CRmcXWLZvp6e6moLCQzKxsVFUhKTmZqKgoJk6axKGDBymaOJED+/cTERFJZGQk+fkFHNy/n/SMTFJS08jIzOTFdc+TmppGXn4+XV1G5r+s7Gy0kIZnwMPmjRtwuVyYLXcBZzWQVquNzKzhY1hdLhdOVxoWixWz2cLkqVN56YUXiIuLZ/6CRTidLjo7OigcP57+/n5ycvOYMnUaJSVHGT+hiMSkJBITkxBCITs3d0ibdsYdSQjBihtX093dhdPpJDMzC0VRSEhMIjIqmuKJkzh86CAzZ41jWFfk3g66d24kc+oSFFWlv7MVcWofkTbX0AdTSpg8ZRoDAx7WPfc8iqKweOlSsrJzOH6shNTUNPILx5OWnoFEkJMzjoysLArGF1FytIRJkycTn5AAKMQnJGEyWSg/VU5GRhaR0dFYrfYhR4pr4HHzseSMUOv3+5k9ezaqqhL5gbJeF0NKCOk6h48cwev1UVRczLi8PPrdA2x//31SU1MpLCyk7FQ5R44eJTMrC4vFasShI5g5azZ79+6lqvo0U6YMxqcD0TGxOIIuCBttw4QJcx0wlta5sSAxMWlIsVx2spQlS5dTOGEC5jJD+bxw8RKioqM5dbKU2XPmEBMbi9/nx2a3ERUVTeH48TQ1NBIRETnoYQiTpkyhs6kJVTVxw40raWps5IYbb7zAsKEIhazsHHZv2cDkeBVTdy1dwsXh8lYiWzpZOTeebVu3UpFqIyJ3MlaLwBESTLpKwRaMeWBaejp33/sZfvOrXyAEfOs73yM1LW3MhM2BATfHtm7ikYcf4dixEt55912mzZxNd0/vYJztx1udY7XaSEpO5rE//9FYIGHq9OlkZmVdk2NraGhg4sTJzJg1C0VRmD1nLqqi0thQf30nj4pctIbc+ctofOrXBGtPgdQxCUFCdBTOpbfhTM2HV168dCNCEO1RifhLOVKUkzO4OHdog2agmRSAraWD0VddQBc3AuCHzYdZMrR9BQCG03A7U84s3nkcpc9vWGwGr2FTczNVJfCVr3yFvXv3Ul5eDkBhYSGLFy8mOjp66IILIUhPTyc9/azAmpKSMvT/GaF246bNrLpEBlwAoQi623rxOCPQdYkeMp58PaQjB3/LC1yaxQV/65ofLeRDImmsr8PtdpNfMB5FaGgh/xXN4nVdIzUzjbLSE/QN9JCWnoHVajUy1tbVEtI0EpOTaGg+edE2TJ492Nv/a+j3xOhSEnxHsbcbE2fzwM5RjUkIcUUZVz+I2exi+oyF+AeTIWRmFgKGkuHGlbedt21B4dCdwz33nnV/njt3GboGEyYYbu1JSZCXNwmAKVPmDm23eMnq89qbO285c+dxXjsBPyxYaNzFX/jSt4fWbdo4MndZKaGrMwezOZu9u84sXUpB/lIAjhwCmIXVAjXVkJKcw8F94LTfQkE+6CGoqQLI5sBesFtvZt+QXiWH3JwvA9BYbyypcYPVksOh/QDzaBkMA8/MmEl97dnsh0Pjc1kZ32/hBzu9qPu2gBDooSCqsGHRQvQ6rQgddleYqOt0AavAaiSAOHHmeMwLOdEBG14HWMkbzwDyDja9BnAHmOD4SeDM7XgEEF826g60Df4rPzsmX0AQ0rgg+cOnjZaWFoLB4JBQO1JUATUDgh+WRyHibgJggw84CojZkIIxEywD4m8a2u/lSkDM4fHDAFEQsxKAt5oBNYMnDgOMpz84mPxvDI4xTJgwYa6W68n9OjIqisgow9Y6b8HCoeUfTKgZPxh6c96+kVHs2bWTxsZ6Jk6eTLXFAqEAefkFOAvHD22XmTm8Eh1gXHIMN8/LxObVeG5zLT315Wx/723mZTh4Y4+VvYer6T1UQ8T0m3EUzmNycip2s4LxQb46hBAUT5rEw5/9HADFEyeNqUBmsViJjXfxwgvrsDsjcLoiOXLoIEuXr/jwrKrXEFVVueueey9Yfq0E9rz8/PPaVxSFmbNnX5O+xkawFQqYzShP/g8Jrz9LvM+D1ts1JEgJixW1th0CAeNtcAlBL7AkCzEQgNAYqHUug2Y3E5idjh5ruLNmahEE32tD372XtclJ6A4jWZLaqMJzpxjNiLSQRkdFOcti4ojy+QldZDsB6KrK/rwp7KrpBiWGl//dcPuQUuL15WCqMKHJcTQNWMkZJleSopgIhTwc3fHXCDEYA+z1YrFaOXSmHquU+L3tKMoIYwqFwKxY2FH7Fsda96BrhsuC+YQFi9mMPxAgFApitzsYCPYSbYu/4IGQio2gaymW/ncx+cuGlk9PAoLAOR7MAedipOIcfiyaQOsW6Jcow6t7YKQXSDVBMAg//YmNa+BxMeZ4BkA1yUsKX5FROtm5QTwD18cL12SSpKYFsNsGP/8CBr60EPOMLKMU2DnbakDApBCak8u99UG2nzR9aJMGp1VSmBqkMPXTXe8nOTmZ5OTkUX2whYA70nW8moJ2jS6YyySZHSfJcV4P08gwYcKEMfiorLcCaNNC/E93x1UrZPXxBeiFeTSrKlW+kSd3PYPFYmbG4luo2vcCp05t51TZVkI+L/squzlS04LZZEFVfXi2PEmOr5271/wYy5tjI9gC5+XLGFOBTEDLtjKiOlLpb2wkJjubWBR06aKzcj87uDB0rutEPdEFqWM3hmuJ1C+uLB4ygI3t3T1WXpsjYWym9RGR6D/4GeLgkJnoggINQ6cqLQuKpnAxtKxoPF+fNSbDGg3BeRlYNlUxTlqhD0J9Z6t8XamInafEQy/osXYCs4d3RS5I0ZmapdHtiYQiw4J53usl6eyfsQKWTQxdcEPGpywkp+hLhIL9lxyPolpJybllRGM3KxYemf53HGzcxkhu8MkpC7CqH/CTFxbcKT9HJP3LZfeXigOUCxMOKU4INgsav32ZWFoJuheUEYTcTpqk8cDDAXp7Pj52oLx8ncioi18HkwkmFI++Xu21Zui9JQR6UiT+1cWX3H5JUYglRRdTA4W5VlypBro4UvJvk669UuBj7vUVJkyYTyAfhXA73+6kKhCgMnj5ELARM1h68QaHC9soXrZCCFRbDHETbmNc4TEaa+vx6CYUFSwWExaTis3pZPb8hXz5r75FenwUDZdv9kI0HQLDf2cuJaCJUSRvPYNqM5N33wJq3jhI74kmnAg6j1w+hNIWF0HevfOuc/ciBVv30yPyklSDdYDCdX5AwyLkCPM6d/ReWE/qE4WUXDOzAxg+e8O8MKQ0ntmR9mxSLjfJ+2RZNrQ+GNhtMiy8l0FYwbkgNCLhNkyYTyJSSqO0l9SIjY392McBhQnzURIMBmlp68AVFf2JcD8Mc234MGddUsqLegCOhEt9EVRAucw3Q/dB4185cMwMEfvls8r0YMDP8ZIS9u3cTl1NFaoiyMjKZc7CJYwvnoTFakV3Q8M3HESuCRJz/wgmdf4QEf9vG6LXh4wcbaUFULp8hApiGfjuvFHFG0ldHwoJHFV/JvW8cp0fpOuohYE6E2mrPYzUefJyeJpU2nbYSLnRizXmEmOWGrauRzG7N4y47aBrOb7YL4MYXVZmKeHQfhvd3QpJySNXfLe2qMTE6Eyf5RtWzomPukj1lg/wMXDE/JAQAkwf/iRQCDCNaSbv6y29wdWhRkLkqrAFL0yYkaIIBb/fi67r16Swe5gwn3TO6Pt9Ph9CCWfoDnNpPsxZlxCCq5WJrupuFoCQDOw0Eag9V9ljI4VF3MYiOBNV1ga8DF1GiV2kBnqvMAyBI8Gi4r1vIqZjbVc81uDc9FEfsFAUVMu1UWTpAUFfhXm0suJFCfYqI7v5hIov9kv4Yr80ug6u8N2XkhbCM2Cmu2vk59FqkaSkXf18P2yx/UTyyRFsw4QJM3KklOi6Tl9PNyYFLBeruxQmTJhLokuJ1+fH7orEZrOFhdswl+XjMPO62rtY6uDeaMK948rsYopNEvNIAEv6x+FsjS3uKhPtO6xIfSRXQaI6AdPlz5M5QpK0yIdqu37OqZSD1V5GsY/ASNl0sVftSC22YcH2E8n1c3OHCRPmw0VKSSgUwuv1EAqGGOErPkyYa8bV3oEfukgpQFUUrDb7UL3KsGAb5nJ8HN60Y3EXj8Un5dP4OHU/Z6b7eQsoAmsyIMDfDOhgjgNzjPFbcwOKJOmHPmzFl3flFSoI0/V/TkN+HwNtzSN+UKyRUdiiY4d+h12RP9V8styRP4im+dFC3hFvbzI5UNRLpFT+sJESofcYfjkjQahIJfq6e2uF/D40/8gTWJgdTpSPQxrqTwAmk4mIiMiwUBvmuuFK78SP6q13riAbFmrDjITrfeY1VnfxaB8HKUGGDAveSFEs192U56qRfgF+QdI9kHg7IKD1JfBWQtbfAhJCfVD1Ywh2gqKCaruK/iToA4w8CbUCiuvanfeemkre/7e/R1FV4nLzkZpGZ00VFoeTpPETEaoKUtLf1kxndSX5a+5i0gOjdJ3mGgi2AUI0iDbkMLmEBQoZMhHzGHSrSZ2GkBvtIk9KqsmFTbl2k2gpJW69Fe0iWY0cShwWcW2yGLkDvfR4O4ZdZzXZiHekDn6Ix+YV6/Hvxhc6PsKtFSJtazGpSZff9Appb9hCZclvATCZHQihEgwYGaEFAqs9hoC/D103fPULpn6PxIwbrtl4Ro30EllzD2qg2niDmBMh2GEIusIEtsGqzb7TIINo1nH0Zr8Own7pdj9kKt95mYq3XgLA4opAahpBrwfFZCYqLR3FZEYPBeltrEfqOnO/90/Ej5/0EY/6HKRE6etBBEeYTVoItOg4GEWd1xGjhaC+xvh/JNgckJox7BfoqibkUqK09iEukoHygs1NCnpyJFxBYh1fl5vTr+1HasO8w88d96BwHp2fQuqSolH3E+aj5cxX6GrnSp+wOW6YTygflnArPDpKxwgSMA0io03IyGvw7RohnYeseBqN/nvcHThtEZhNViSSzt4WgiE/STEZKIqKYoLk5V7MrutZTXBlmCIh4Rbo3g6BTvA3giMfurdB+xtQ+F/gGAe9nZdv67Jo0PYTG4FqBVMUmOMh2G4IzwiwJBpTTn+Lsa0aK0n9qRdxkcqbV40uQUpmPfwV0qbOQgio3rGZhsP7yV+2CiEEsTl5dFSUselnP0ZqV1ZxYcwlv2bRwf32f8Ir/ei1XrTKAdSJESjJVpzYedH7b6TJhKvup18P8LXm92ipOI3WOCjkKQrmokyssVH8IWUVE63xV93PxdAJsc39MzoC1bRVeehu9BGXaSchx45QBItcf02OZeHlG7oC9tS9x6MH/xW7yUFefDE93k4ae2vQ0RmfMIN/XPqnwXq2Y1NKvM/3Cl0DvwNUYl1rCIQacfsOIYSNhMh7cViL6ex/lX7vbsCEzTzpmgq2muYn6O/G4Uphyuzv4fV0cGTPfwCQmrmEiTO/zcEd/0Jn2xEAdP16K4MjEVonitYFCfdB+j/AqfvAcxIyfmQsA+hYB3X/jK7FcD3qgUM+H/6+HmKycljwtb+m4fB+jqx7gqi0TGbe/wWc8QlYnC7e/tH36DxdiR4a+Uf4w8L53itYTp8CBMQnQl8vBHxnN4hPAo8bPANIq52eL3wXPTJ67AfS14P6hVuhqx1hNqPk5KNXlSO1EGreeJTsPECiHT+C3tKInDYH/U+vXrIm+BUR0on46XpM1e2GcJkVB009EAgZWSUzYiE+Aipaoc+LlhBB7y/vRTpHn7HS09LDnn94Bs0XJCo7gfSFEzj5/E4iMuKZ8c3VqBbj2DrLGjnyhw2Mu3tuWLD9GDIWX6GwUBvm48TYzLwujfmYh8ifNBs/IlVwqtAcMDpPtxr/2oNw2gsaDDwSh+/O2Eu2eS3RgwLNJzhS+T6/ePF7PLLy+9ww/S7e2fcMT6z/KZoW4saZn+Hzq3+AxWa+Hqc8Y4IpxhAooxcYLsQdb0PLOkBC7A2gecFTOXb96f0CS6xC7j+CsBhZrav/BVwTIeVBQEDnemj6C2DSx8TN/FI4YmLJmrOAjf/xT1idLuZ/5bscf+NFNvz7D7C6Ilj1Tz/l+JsvooeuPInUmAu2EomfIAMH2xn4ylGETQWLwPXCTEwJJuQY3a0S8Gsh+nYew3+gAjSdwLEaov7+HiLXzP5QXPA0gpzY2swb/1JFVLKF3tYAd/+kgHFzY5Cj8bkYJbrUsKgW/mbpf5AamYVJMfP0od+wseIVQtpwQtxY6BAFKTFfIzvh/1Hf+VPcvkMkR32e5OjP0+vdTUHyHznZeA+eQMVV9jNyomMLsDuTCAT6AFBVCwkpMzGZ7B+PmZDqhMhFZ4vvKnZwFEHVN8CcAOk/gMaff7RjHAFJhROxRcWgDroZ9zbVs+mnP2bJd/4BX18vPfU1H+0AL4HQQghNg6mzYPUd8NpzUHrUWBkZBfd9AXZtgX07kKZrmJ1bAgEfQlGwffsHmG/7DO67lkJ7K/Yf/gfCbkf29eD3+5G1VRC4dsoaEdQQmoQ7psKD8+AfX4YTTbAgD76xDHxBaOuHf34NEbz6GrYx+cnc+sx3MdksVLy+H80fpKeqBaEo5N8+G2u0k6N/3Hj1BxbmI+XcV/IndM46Zpx7fj4On7Iww3NNBVwdCEhEmgX+OgMCEv6xGgoc8ONs6AhCvBn+2AybuhHXvtz4ZdF0jUMV23F7+9Clhtc/wPNbfs1DK/6W9IRx/MuTX+DmuY+QnpzzUQ/1miHMhvBa9U9gTYe0L0Hbq4agmXgH1P3acEMeywffngsDZdD4KOT/O0TNgbgVUP87w1kw5weGgH2FBtKRI8A/4MbT1UnhDWtQrVbMDidCKEhdJ2PmPLw9XbSeHKmH6PBcs8JsgRebEHEWzGuTsD6cjnCNvVuwUBWcDy4j9udfxvXQcsx5qdgWFY95P5eivz2AahYUr4wHCQOdH45VKid2PNkxBfzg7c/zZulT3FhwJ6ZLFsYSXN2TIunzvE+X+22kDCIwEeNcQWP3bznd+jd4A6eIsM++ivZHT1PddqpOrhtSYmian+MHfkNfT/WHOo4rRuuDmv8D/jrjt+6Gis9B/z6IvR16NoLW/1GOcESUbXiTqu0bz368pQQkoYCftKkzSZ407SMc3QgQAuxO8HnOBgGpJlixFmJiYaSuymOB1QYmE/i9oGtgtSESk5FaCL2pAb3uQ7q3VQXsFvD4DfchRcDqiVDbCdtOweaTEBwb5Z2nvY/D/7sef58XqUvcjV0c+p/3KH1uJya7hYO/fhstEC759UlipF+jq/1qfRIIKwE+/lzT+zjCBJ7B9LMSiDIZpSvf7wWfbgi31wmqovLZVX/P1LxFAJhUM5HOWKqajnOq/jD9nm58Ac9HPMprS6DVcAeOv9kQLv0NEDkDsv8O+o8YrsqmmLPbS3n1ybq6t0DtLw0BV3GArx7UCPBUgLfWiIKzJF9dHyNCQtDr4cDTf8LscBKRmIKvr5eQ34fZ7qBgxRpOvvvaVXv3XZsgVE2iVQ6gV3sIObvRm/2YbkyAzJFltBoNQlGQWgjPa7uxr52NcH24cYgRCRbcnQH2PN2Ezx3CGWf5UL5EnQOtSCSrx99DUdJ07GYnYsRTBbiSQQ74S/AHa4xWhAmzKRFN60ESQtP7sZhSRt3m1SEvsIzrI03IdL0gNc67FlKHzB8Zfzf8fzBMrPp1h5SDwo/x0xEbT9DrYdNPf8yyv/4RKROn0nj4wEc7xkuh67BnG2Tnnl02dRZkZENjHUREguVDSj7W04X/v/8D0+wFxm8B2v4daOUnUcdPxP5vv2Xgc7de+3EEQvDcPpieafw2q5AaDVazIfDOELC7aky68vd4aNhRxqTPLjtvecEds+mtbqX1yOkx6SfM9cenXWi9GNd7EqIwV8ZIrquuaXR3ddLb03NJz8OYJogEKPPAm51wa5yxojcEFgVujzeE3ME43M6OdprK20c9ZrPZTFx8PE5XxAU5G6SUBPw+Otrb8XovndBT6c9FiBgUoQ61YzZZ+eJNP+Lxd/+d/WUbsZis2K1OdF2ntuY0WEeenPJ6QQhBdHQ00bFxqOfk45BBCLUIw57xU0Ow9TVC++sQNRvcJ8CaAtYkCHZBqBu6n7KgvqcTc18AS5Y8p60A3rIjBFrqLy316gqhvjVILR5nAaR9ARr+AJ5y0AOgmA13aCRoAyB9Xvq2vI6wXpky3xSTgGPSLBTbxfMLKapK/rLV6KEgUtdpPLyfoM9L9tzF6MEgzccOX1Hf543jqlsYjkHNkfWz6di+l0v/yj1o+3ogM27su5KS4Ml6tJZubEsnf6jZC6UOR99oY+ZdKdzw7Sze+kkVJW+3kTs76pr33epu5KmDv2FhzmqibLG0uZvQ5GisGlfnGKbLAN5ABXZLPqoSicWUSkf/K6Nu52oRQpwn0Ish3ei5yWf4ULPDju4eFAxJhIodMv4Z4m6Fhv8w3JL7d53d9KPIcDvSYxkshyEUhRkPfAGT1UZTySHixxVwetc2ztxjH3aW3hFfi3PHZbHCxKmGMBsTZ8Te9nRDeek1GePw4xn8X9MIPP842rFDKOMKcf7ldURM3Ic36T3TkSKMv5/aDQdq4LcPGvG37dfGo8Aa7aTogUXs+PHz6GPg7hwmzMeNsHD7yeRSXyRd16ksO0l8XAxZ6amXbMfa7AO6LlyxJBoO9cN/1sG9iXBjDGztJiY6CkvG6I1Luq7T0NCAMzKaxOSU876pngE3tdWV5GRnY46/dPxuR7Mdbw8MGSSkRCI5WL6FzKRCUuNzaWyvIjYiCUUIUlOSMDk/nu/+np4eKk+dJH98EcpgYsVQh2BgnwmSvKguG93bjfNoTQFfg5FE6gyKFSKmQX+vB+19G6YEM3FfMIRNqet0vfxnOl/4A/LcfCDDIU2YtClETIwn54fQdxCQoNgMS3HSZwwBWvdDoAU0dy9tf/g3oO/yBzncjayaiFx2K0lf+ycUy/l5N6SUdFWVoQWDHH3pabLnLaa9oozq9zeBlPS1NHLgqT8RGqy0oVqsqFdoULg2gq1JYF6RgP+xOvSOANKjoU6MACCERmiY3NMCgYIYodXxHDQdzyu7sN04DSXaSOUlAQ1J6CriXFUuX7dOCIhKsVK9r5c9zzTRcKyfyWsSQIBERx+VoDnUqnEmLtO3w+xkZeFdVHeWkRSRxr76rehSRyLRZAipj+6TeFaLdv5+UsrzlukyhJRBQKet91nGJf2CWNetQIg+7y5AEtKaCISuzGVSVWJRRNRFj19KDZ/77Bugt6uCYGCAs4KTRv3p9/C4m4a2aah6iY7mnVc0ntEgFJWM/M8QGXvpBDdKsBVFdxs/ZADanzL8U4TdiLsdOAYxNxlvmoEjKMEmIhq+BHx4GQ2lGokn4fvoloxh12vBIJ72lqHfLaUlxn2v6xx7bR1FN91O2rTZHHnxKWr37QApKX3xSawb3viwDoHkyTPJXnYTYkQZe8WgEC8g4IfnHjOyH992H5yugBNHwGQxrLujDUQRYpRZg8+ORUlOw/GrvxB89zWU3Hz08lJkZzskpkAodAXKDmEc1ygUFghhxNUerIG1Uwwrbr8PmnvBpICmQ2i4zMYYAvHF+pLyvNdNyHtWS5yxeALe9l6a9pYPLQu6ffSdbruwG1XBmRaLol6zyJowYT4SwhbtTxcD7n6cDhsFBQWXV8rG9DAk2J67aXsA5kfB7QkwPQKqvaBDhMNFRPwVJPVUISEhgb379pOQlHzeuFqbmyiaMIG4uLhLjlcLQPfgZ1MIhYUT15KVVIhAsHDSWl5+//coQuFbd/x/WM12pC7wlCVwyei66xQhIGV8Ej5fCR7PAC6XIfsgAR0SHw6RdfvI2qqv7KXmrzTQz1pA9YE+eje8dHmhFoA4IApzInirwRwN8Suh/R1o+D0k3mlkSq77zWDtXGJQtf+Ci1R7GRwBuvIkkj0XvqC0EO6d7xF7++exZuadt0rqGg17tuNMTMaelsXJw4eMz39KJtYUGBjczjV+Mp7KUorueYTcFWtHcIwXMqaCrURSqpwmSAjr5zMQiRb0UwM4H5+KUujCi4+/sv4CCxferakynv/r/yKxhnPFZakK9DCgB0EIbEsmYZmSO/RgaUj+uWMndnFlT4UQsNY1js9EjEe5yMPar7fikz0s/nIGsRl2uuq8LHgkjYmr4hFCcNj7FKW+10bdt1OJZ57zm9hF9LDrQ3qQ6q4TDAT6eerQb5iRtpCXjz3K+9VvA1DTXcaPNjw4qj4tqpUHp/4thQnT+KCrckhvxe3fPLRtU9dvkRgCe49nEyca78SiJuENnCKoGW4ujd1fBnFlk0yHZQ4ZMc8iLpJvPBQcoLV+PTZHClZHIhIY8HQRFT9laJue7los9mQs9rNBAwH/MJrNsURK3L2VKIqZiJgJl3zJW/vfRGhdBO2zjVzr/SfAkm+sbHn2rCAgJViNmHElNBa530eIDGLqf4uQdSK++K8Pu4m3q52mg7uJSM3EGhlFMGi8CM+U8yl/fzNCCKSuEztu/GC7En9P94dyCJ7ONrory0ibuwSLc3gtteLuQ+kdHI/UYc92aB8UnPyDH40926C3BzQNofuIfPExpDI6BUMoOY2BFbcaluCLICpKwWO82qW7D9+v/w3Z3Ylsbcbzg29iXrCc0N7tBN98EbweKDuO+tCq0RecUxT0z/8VcuVtw+6rtvQhugdjnEK64Y7c0GW8Dp7YDUsKINYJT+6BrgEUk0LUP76GVIYZh6LgvXs6gXm5F/QlpaTq5b1DsbM9Va28/cX/IThgnPe6rSdo3leJ5j+rHKx95zANmy5MKqFYVBb8/BHG3TV3dOciTJgwYa4jPB4vVuuFli6fz4eUEpvNZnhGSeDkObGolV54ud2IXHqnCwZ0yLXBpm7Y1mO8v19ph+09oxuQAG6OQ70lDr/fd4HHldvtxuFwnDffkVISDAbRNA2bzSjCOtAucLeBIw4Ui+DW1DuHOpiROpXps/7H+HVGuYxR+W6k1e+uJ7xdEPKDmqng8/rOCraDRES6EIq4rPeaEAK7036B7ChDIXTfJeKQhRhSeAu5GGQaXVsO07XtrOL4jM2v5lfnbD7UUfSlxyULUXQ7mrpn2PV6MIAMXMyFXBJXUEzUDbdxbNN6cnJyz1sbCgWpKD1BptWG2RmB2XFl4atjbrF917SXaOlivmkS+lod1oKiKAz0uLE7HHi9HuwOB+o5k8Nu0c9GdT8PKDcyV584on62eupQEayJGIdYM27I3K/ruiGMXoVL8jFfO6/0V3BXRAGWi1jJWoLH8Mk+ipOWMekR81X3CeCX/dQF91KorSFNGT7hjifo5mDjVnJiiog0JVDRWgYIZqevvCL1rq5rHGzayr6GDYOC7RkGXy56F8FQHXHO72IzT0HTjSdCGXQ7PUOEDYZznHL392O3O1BNlxcG3L73cPs3o0svChcppCUNN5aU3FvJyL9vaKyKooz+9Evo6+/D5XKddRcJhfD5fLhco3ugpK5xeNu3RpYNW2roaix9Wc+jK9FIKYf6/yButxurzYrZNHoljc/nQyKx20YXdy5CHcRUzuOSVb0HMxpMuPth0ucuQT9zXygK/f39uFwu3O5+XK6Is+dWC+EZ8BAZeXHllZQSXdcRQqDrOj6fd/BajO7ilr3yNNUb3+JSznxqSwNqVwf+vCJCgy4vSmbuhUoJVxSkZY2qf4D+vj4iQgFsxw/hm7MELS7xotuKzW+ByYy25m50oRAUoK68DRDoQPDUoBv07CXn7efxDGA2mzGbR+KyIxG7tyJeewZ95W3DbmE+1oDS58U7PxdhMwMCZmahS4kWDBHs6sHhD0J+AuQnMnz+VmOZ5XA91s2nDMF2GLpK6ogtTmfKd29GSokYFI6lLo1r8IHL4O7vx+FwnmeZ1XxB9v14Hd2ljXDXCE7Bh8RYu5CGLXdhwnwaGBRIhCH49PX1sWHDBoLBICaTCU3TWLx4MSmxSYitPZBtoz9No6e3F1NIJf6GeMzmwblC9aBydvbIjEXnEggEKCsrYyI5KG92wprYSzoHnRHSpJS43W5efPFFAFJTUwkGg8wafwNCcZC5SOKhjUAggMsVQVR01DnhY1fHmYorZ7w+AwE/p06dYuLEiYhhDC2hUJC2trahuYvD4SA2Nvaqx1L5HuihS+WyMdb5fD7eeuutCwRcTdO48cYbiYsbfeimMJmJX7aWzm1vowf8GF5+HkLq1zFF+VAdLjR3H6rDhRACf0vDaHtA1R7n8t6Dl/4C2hwOlixbzvRp0zGpCiAQArxeL/9TffW5O65JuZ9cmcbnjizh5XXriIqOZs7c+bS2tLBg4SLee+ctblx1EwmJZyd5JUole9QTo5oMSCDB5OCR/iQ2v/UOX/vmtxFC8Lvf/prVN68lLy//io/hXzt2U+K/XJC9xCzszLZ/ibde2MCam9cSETH6F4iUklNlZaSmpRJ0dNAcPMLlp0WSWak3Ure+D1U1XIgLi4pYfsONmEyju6S+kIe/e+eOy2qPHNYF9LYX8+if/kBUdDQmk5mlS5dTNHHiOYLAhW7M29e/xrwFC4iNuHzt4pDWfJ51+FLs2bWTl15vpLu7m+zsHO69/36ioqJHtO8ZNF1j4/oNrFx9E02NjSSnJON2uzleUsLK1TeNKlZWiiuZyiocPnyEwwcP8rkvfum8RANgnL9dO3dRPHESaenpI2pR13WOlRxlQlExZWWn0DWN6TNnjW5YYnQWyb179nDwwD50Xefuz9zHO2++yb333c+G9eu56ea1OJ2GkqKzrZM3X3+NL375q8OeW5/Px2uvvERrSyuxcXEsXbacnTu2c+99D4w+dn4E2wsJqCpl44r58xtvERkZSUJCIvfcdz+Wq0wWJXWdP/3x99wzfgLj2ppHsIOEpBQ233AXew4dwmKxMGPmLJYsW34Jt3zJ7s2byM7JJSd3eOFxaFsAXUf98h2XfL1ICdJu5vVxPpInZ1FUPJFgIMBzzzzF9Okz6ezqZMnSZRdv4Ay6JPKHr3K5d5kjOZrY5YVs3PAed9/9GQDeeuN1ZsycRUrq2RgzKSVPP/EXblq+lrj4s/XJA/1eDv/09cuP52POeQr1MGHCfOIJBAK8+eabLFq0CF3XCQQCREVF8c4773D76luJRsLcKN6I287p06cxm81ERUXx5S9/+aKK8pHi7e3ltV8/T5EsRqkbWYbap556imPHjuH3++nt7WXGjBm8/vrr5Ofnkx03GcgiGPTz01/+lPz8fOrr67n33nuZMmXKZdseCQcPHMRisTB58mQAdKnT09tjRPYMczo8Xg9bt21l165dZGZmMnfuXBYvXnxV9ik5ihe13+9HSsmaNWvOW7579256enpGJ9gKgTOvmKipc3HkjMccHUfLa08hB3UbEcXTSLp1Gb6GGvztTWheD0JR8bfWjbwPAHn1kf+hUIjyspM01tdy7Ngxbr31NhLirl6hcC7XJsYWGBgYYNLkKdxy2x0IIaiursLpchEMhpBS4vV6OVZyFLPZjJx6EevcCPB4PNTW1gwJZrW1NXg9HoLBICeOH6O7q4sJxcXExcVz6OABXC4X/X19ZOXkcKrsJAUFhaSkptHc3MSpkyfJzslBRoz8wkkJLc1NBENByk6eJBgM4BkYYOr0Gfh8Xk4cO0ZMbCwFheM5VXaSnp5uJk2eit/vo72tjc7ODta/+w7Tps9kxoqRC+O6rqPrOl//5rcJBoM8/dQTREfHkJKSQn9/P6qqoqoqTY2NjMvLNwRgRRAdHUNF+SmKiidSWVFOSsbIMxn7fD6ysrJ58JHP0dLSzGN/+iPJqamYVJXjx0uIi4unoHA8jY0NnK6uoqCwkKLiYlxOF16Ph6NHj2CxWLBareTl5VNdXYXb7cZms1FUPDJL/RnmzV8ItoWsf/dtPv+lL1FZUcnpqmqSkpNoaWnB4/EwecpUQNLY0EBXVxeJiYnkjsuj5vRpGhrqKZ44iUmTJw9N3CdOmszCxYspKDRcZ+vr6zhdVUVySip5+fnU19fh8/poa21h4qTJOF0ujh8rIRQKMXXq6F/Ouq5x8MABerq7aG9rIzEpifJTZQQCAfw+H1OmTaegcDxR0dGD97WXrs4O8goKqKqsJCkpieycXKqrKo3rnJ+PQPCXxx7ltjvuJL+gAFVR0XWdivJyWluaGZeXR2paOhXlpwiFQvT29DB12nQ0XeN4SQlOl4tJE0Z+T/h9fjbt2MY3vv0dHA47iqISDAZQVIVJk6dgtVjo6+vjWMlRgoEAgcH6qzWnq6mvr2f8+AnEJyQghKCqsoKenh6+9s1vEQqF6Onuxt3vZu+e3URGRDK+qAi3282JYyWYzRYmTp5MbU0NWdnZ9PX24vN5SU5OoaamZlTXwefzkZOby733PcBvfvkLmpuasNltlJeVkZmdTWZmFl1dXZwsPUFMTAz5BYWcPHGC/v4+ioonEhUVRXn5KTwDHnLz8mhqbKC3p4fent5RJ8vq7e1hxcpV5I4bx3//6pfMnT+f+rp6WltaKJo4kbbWFrJzcjGZTFSUnyJ3XB7RMTEEg0GOHyshGAxSVFRMfX0dheMnUF1VSXxCIlLXGRhwkznCcaRlZLJj504mFBXT0FCPz+cjPSODqOhopNSprqqiuamJCcXFdHZ0kJmZRb+7n4GBAVJT06ipqmLmCI89FArS0nxW+G9ra8Xv9+HxeDh29Ah2u4OiiRMJhoKGC3NlJbqu0dLSQn7muFGd3w+Lq0vNNzxh4TZMmE8PFRUVZGVlUV1dzfe//338fj/f/e53mT9/PocPH2YZRqiVruusXr2avLw8fvKTnzAwMMD69etpa2tj8eLF5Ofn895771FfX8/cuXOx2+1s374dVVW5+eab0TSNHTt2IKVk9uzZbNy4EUVR8Pl8cPHomQvYtm0bPp+P++67jwMHDvDGG29w9913I4QgKiqKNox3WGRkJJ/73OcoKSnh4MGDtLa20tnZSV5eHv39/ZSVlVFcXMysWbN488036enp4fbbb6ehoYG9e/eSmprKqlWreOONN9A0jZ6eHtauXcvLL7+MlJKIiAhycnIQQjAwMIDP5+P1118nFArh9/v5zGc+g8vlIioqigcffJCBgQEWLFhASkoKTzzxBIFAgLVr1xIKhVi/fj0Ad999NxUVFdTW1tLS0sKkSZOoqqrC6XRy2223sWXLFk6fPs3y5ctRKBzxObNYLEOK/zN80BX9UqjOCFRnBLbUTJy54+nes5m29S+TcvsjOAsm4i4xtouYMIW+I3toW/8ySJ3YhauIKJqGM7eQgepTdO/aQOJN92KJTaT3yG7c5cdIuvk+hKLStXsTsfNXoFistG98jWDtYOdCYE1OJ9DejGK1odjsBLsun3W7/FQZaQVT+OpXvkpZWRnr17/H6pWrsNttdHd3ExoD//Nrmm2jpbmZk6Un6OvtZcf2bfT3GZm2pNR59eUX6e3p4VTZSfbvHd5Xe6Q0NTby5OOP8sTjj9LU2IiUkldeeoG3Xn+NlpZm/uPf/pW21lZ+88v/4uCB/Tz1xOP87re/5tTJk/zqFz+npbmJX/7nT+nt7eG3v/olTU2Nl+/0A+iazrrnnqa9vZ2yk6Xs3LGdl19YRygUQgjBwf37OLB/H8FAkFdeeoHK8nJef/VloqNicLkiSEhIwDRad1NhpM6OjIpi4aLFlJ44zu5du9i9cwd2u4P+/n6sNivPPfMUbW2tbN28idPV1Tz6x9/T1dXJxvXvjfo4hVAwmUykpaWTk5NDVWUFzzz9BIqisnXzJkpPHOf5Z54mMjKKUCjEju3b6e3t5aUXX6C3p4f29jaef/YZ+vv7eeKxR5FS8u47b1NXWzO6cSgCRVUGXUwELz7/HK2tLUhpaIS6u7p45803aG1p5dmnn8JqsfL8s89Qc7qaV156keioaILBIFs2bULTNJxOF/EJCfT39bN39y4aGup5+cUXiIqOZtOG9ZwsPcHO7dvZv3cPgUCAdc89y55dOykvK8Nmsw25s4yG1tZWFCFYuHgJB/bvIxQK8exTT9HT3c2RI4c5uH8f+/buprOjnZ3bt3PkkPER+O2vfonJZOK5Z57G3d9vXGerleeefhqT2YTD4SAhIYHTVVWUnyrj8KGD7Hx/O5FRUTz/7DO0t7Xx6ssvUVdbS11tLZs2rufN116jv78fRVFHlY/IYrWQX1DIC889S3tb25DVWeqSLZs2MuAZ4Okn/4KuaXR0dODzeqmrreGtN9/AZrPx/LNPD8XnpqWn09/Xz3vvvI2maSCgqqoSk6ry6isv0dBQz1N/eRxdSlpamnn9lZc5euQwVZWVbNuymTdee5Xa2hqOHT0y6mvR0d7O0cOHsVjMqKrKc888jcPh5NWXXqSxoYEnHvszFosFXZe8+/ZbVFVVYrFYeeLxR+nr7+epJ/7CgGeAkiOH2bt7NxarlabG0br5GJbJutoaDh04QFZOLlWVlWzZvBGTSWXdc89QcuQIJ0tP0FBfx749ezh86CAtzU1s3riBmtOnaW9rY+OG99iw/j16urt5/tlnOHhgP3v37Kaj7WzipYsJSGeW5+Tm0t3dhbu/n4MHDjBz1hxaWlo4cvgglRUVbFz/HmazhXXPPsORw4eoqCjn/W1bef2Vl6mvq+XI4cOjCs2oq63huWee4rlnnqbs5El0Xeeldc/j8XgoOXqEI4cPDW373jtvc6zkKKqq8sTjjxG8ypp31xoxzL8rJZwlN0yYTwfd3d0kJyezZcsWOjs7cbvdrF+/nri4OHr7eoe20zSNt956i9/+9rcsXbqUPXv24PV6WbFiBa+88go7duygs7OThx56iOTkZF588UVuvfVW5syZw7PPPktPTw8nT55k1apVvPjiiyxdupT58+cPfZdHw759+6iqquKdd96huLgYKSUul4uWlrOJJj0eD4cOHWLbtm0UFhZSUlJCSkoKTqeTgwcPcsstt7B9+3YOHTpEfX09d9xxB7qu88Ybb7BmzRpqa2spLy9n3759zJ49m8TERA4fPsz06dNZunQpmZmG+jYUCnHy5ElCoRD79u1j2bJlKIrCkSNHLhi3lJKXXnqJ7OxsJk6cyOuvv05ERAQLFizA6/Vy6NAhamtrCYVCLF26lHXr1rFmzRqqqqooLy9n165d3H777aSP0LNurLDEJxNZPIP4ZbdgiogiZu5y8v72/8Pf2kh/6dmyOR1b38JZOImsL/8dlgQjAZgMBWl581niFq1CsTvpP3EId3kJiTfdg2p3EjV9AR1b3iB+yRr8rQ30HT9A0s33c+4XLGrqXFLu/gIZj3wHa9LIjt3d30daWjpWq5X09HTcbjdvv/suP/vZT1n3wgvk5Y9cMXAxrplgKzGsD02NjXi85wc6BwJBSo4eobGhnq6uTlrPuemvBLvDTs64ceSOG4fDYUfXdY4cPsSd99zL3ffeh8lsormpEVdEBLfefifTZsykoGA8t915F91dXZw6VUZzczO1NTV4PAO0NDddvtNhiI2NY+68+cyeO5+W5hbG5eVTUnIEv9/P4cOH6Onu5vTpajra29GlZNr0mRRPmkRsbCwZWVmj0tSci5QSv9+P3W5HVVXmLVhIQmIip8pOcrK0lO7uLtLS0mlva+NU2UkmTZnKkUOHSExKwmy58rRzwVAIv89HZUUFlRXluN1u+np7SUlJ4fChg6iq4RAQCARoa21hybLlzJ+/cMhlODsnl5mzZlNUVExb64XZTkdDZFQUCxYtRkrJsZKjNNTX0dllJFyaOHES02fOJCUllUAwSHR0NCUlRzEPum1bbTZiY2PJzMwcugYVp04xZeo0Jk+Zytz58yk/dQqT2czc+QuYO28+AwNuklNSaW1tobWlBUUdfcbivbt34/EM0Nbayu5dOwkEAsQnxDNn3jxmz55L8zn3oclsZtacOcyZO4/snBxmzppNUlIyfX29lJ08e50dDifR0dFkZmUPnf8Tx4+xZNlypkydxri8fOrqaomIiGTe/AXMnb+A1tZWcsflcfJkKR7PwKjcfhVF4e57P8PCxYt56om/UFVZed56d7+bQCDA/IWLmL9wIXa7wxhrVxdlpaX09PTgH0zUFBUVzTe+/VdYrVb+8Lv/we/zU1BYyIxZs8kdl8fpqipAMm/+ApbdsIKGhgYKx0/gxPFjeL1ezBYLJ44fZ3zRpbNSX4CEvr4+9u3bQ0ZmFr29PTQ3NnKy9ARut5vS0hMkJiUza/YcioqLOV1dxQ033sisOXOw2x10d3WRmJjEvHnzOX26mqXLb2D6jJmMu5JwCAltrW3s2b2LGTNncuL4cXp7eigvP0V3VzdTp0/n0MGDHDl8mFlz5gzFYh06eID29jaam5voaO8gKyubI4cPkZ6eQVNDA01NjWR/IFHDpQQum9XKuHF5lBw5TGN9PYXjx58ZHsePHaO7p4dTp8ro7u4mv6CQ0uPHDe8Lu50Tx44xfsKEUR12QmISi5csY8nSZWRkZODz+Tl+rIS62lp6errP+0bYbDbmLVjInLnzAPB6LpFI4zplLIXdMGHCfPKIjo6mra2NBQsWEB0djcPhYPny5XR1dRFxTkIiRVGYMWMGcXFxWCwWampqqKmpYevWrSQnJ1NTU8OUKVOIjIxEURRsNhtJSUnk5OQwMDCApmkUFhZit9sHvfKySEtLG3WeETDmoh0dHQSDQSIiIoiPj78gY3IgEKC1tZU1a9YMWZALCwvp7OykqamJ9957j+joaHJzc8nMzOSPf/wjlZWVNDU1sWHDBsCorZuQkEB6ejoZGRn09/djNpuxWCwXhHQBpKWlkZycTHp6Or29vResl1Jy+vRpjh49SklJCQkJCWzYsIFdu3ahaRqBQABVVcnLyyMlJYW8vDwSExNJTk7G4XCwZMkSHn30UcrLKxip+lFVVaqrq9m5cyfr1q3jmWee4dlnn+XYsWOjkgWEyUzv4V00rvsTzS8/Ttu7LxLobAX9bI6UQGcrNf/9L/SV7CP9wW+BEAxUnCDQ0YIe8OMcN4HkWx/EEp8MilE1wddYS6CjBVtGDq7CKUROmoW/9Ryjn5S0b3gFbaCf7r1bcJ8cWf3ZvPxCNmzYwFtvvcmjj/6Z8UUTKZ40mdj4BB763BdYsHAxV/tFvGauyAKYUFTMytU3XeCOp6oqyckpzF+4mOjoaCojmnmBE1fcV0xMLAsXLUEIwVtvvI4Qgvj4BI6VHEVRFAL+ADFxcaiKgslkxKQa1j6BRBIZGUVUdDQLFi5i2Q0reC6mg0pGP1lSVMVIqiSMB2XKtGlk5+byxGOPkl9QSFxcHNNmzEDqkqqqSqw24+a12ewMuN045OgEW13X8Xo9tLW2sGP7Nu64624OHTyAxWKhqbGRvr4+br3tdv5QW4Pd4cDpclFzuprVa27m8Uf/xIMPf3bUxxgKBXG73VSUn6Kvt5fxE4pI2bOLG1asRFEUIqMiKZo4kRPHj/Hu228hhBh60bS3teLxeHC7jdqXZ+KBjcn5lZdmAjCbTaiqysED+xmXl4/L5RryBDCdSaYgQFVU7rrnXnbv2sm2rZvPLMZmt+F2DxAVZcRJx8bFcfTwYQZmzaa+ro7k5BQaGuoxmYyHXgKJSYk89NnP89if/kDh+IJRjTfgD3DqVBmLV9yF1WrldHUVVZWVqKrJsEKL87PmnTmPQggsg4mChCJobGhkwO3m5ltupe73v0NRBCazGY9nYCiZQmxsHFVVlSQlJ9He1saUqdNQFGUo4ZaUksIJE8jIzORPf/hfigu/wKUr0p3F7/dTXVVJRmYWefkFF1gpLVYLfp+P7q4u6uvq8Pt9xMXHk5OTy003ryUQDAxlDexob8fn8zFz9hwOHtiPz+cdSpolhMBqszEwMEBnZwc93d1ERUWRO24cr73yEtNnzATg8KGDrLhxJfXlR0d+MQSMy8vnns/cx+9++2uSk1NITU9n1Zo1hIIhQlqI0uPH6OvrQ+o6doeD2poaMjKzjERjERFYLBaEohAZGUV9XS3RMTG0tDTD5NEJeEIRzJ47l9S0NJ596knGTygiL7+AJUuXEQqFiImN5Z2338Ld389NN6+lorwcECQlJzNl6jSysrJRTSY6O9r58x//wP0PPsSO7dswmc2XTNp14SkRzJw1i//9798yZdp0HI6z5QbiExIIhULcsOJGgsEgrogI3nz9NaZMnYrZbGH/vr0sXXYDUDPi/ux2O6lpaQA4XS7MZhNJKSksWrIEp8uFyxXBuueeAYx7rqmhcTBJiMQ2yuRo1ysjiV4KC8Bhwnw6yM/P56WXXmLJkiU8++yzBAIBEhMTeeedd7j5hpvg6VbA+DYmJyezaNEi/vM//5NZs2YZyuT581FVFbfbzebNm1FVFbPZTCAQYOfOnfT09JCXl4fJZMydLBYLERERvP/++/j9fnp6ei6XIPc8Fi1ahMPh4MSJEyxcuJApU6ZQX1+P3W5n/MLZtA3mBIqOjuamm27CZrMNJc5UFIXs7Gzi4+OZM2cOoVAIk8lEQUEBbW1tuN1uMjIymDp1KgDp6elDwvKZ/+Pi4igrK2PmzJlERJyfifjypTsFkydPHuozJiaGZ599ljlz5rB3796hudiZds6NYfb5fMTGxjJhwgROnDjOnLiRhaW5XC7Wrl3Ln//8Z774xS8OWZqBswnARoDu99K5/Z2h330l+4hffst528QtugkpmlAtdqNkIZw3v7TEJ6P5vAR7u4fqz0rNCBvtP3EIYTLjPnmYYF8vcMPQflIL0frmsyMeK0BrawsZS6aRmJhEKBTi6OGDrL31Du5/6LNYLBa8g/LB1XDNBNuYmFiEPHszZWfnYLVaycrJxulyctsdd7Jl00YsViupN1+56TkyKorJU6YO3WiTp0wlJiaGhz/3eV556UXeeuN1Hnj4EVJT05g2YyYmk4mcnFzMZjM2q42ZM2dTWDietbfcxtatm0lLS0dZkjbi/oUQ5BcUYrFaGTcuH0VViYiMJCMzk3179tDYUM/yFTdSPHEib7/5Bm++9hozZ88mNi6OYCCAEIK58+ez4/3tLEqaOmIbuqooxMbE8vSTfyHCFcEtt91OZlY2rS0tuFwRREZF4XK62LZ1C8UTJ2EyqUyfMdOIh8vKZvyEIrKzc0Z1rl2uCHp6e3jy8UdJTErmkc9/gejoGFasXM07b79JVFQUy25YwYZ33yUQDLB02XJqa2twulzcevsdvPfuO0RFRuFwOLBYLOTkGhlok1NSLkiJPhIcDgc544w2zsQRT58xg3ffeZu4uHjyCwpxuVykDU6YjdTikjdffw2EYPkNKzhx/Bgms5k5c+fz/ratLFy8mIzMTIonTqK1pYV1zz5DWno6M2bNAgEOpxOTqlJQUEhtjeEyWlA4nsTEJNpHkcwtEPAzffoM5sydhxCCiIhImhobGJeXh6IoREdHk5aega7rOBxO0jMycDidmM1mMrOzh44nOyeHykrDDdS4zmbmz1/I1k2bmFBcjMlkYvrMWbzz1hu88PxzTJw0iYzMTHLHjcNkNuNwOMnJyeXo4UNUVVWxaPFS7HbHpQd/DoqicLy0lI3r15OUnMyMWbMJBAKYTCZyx40jIiKSlatv4tVXXiIhIZHCCUVMnjKVluZmXnv1ZQoKCklKGowVkjobN7xHMBhkybLlJCYlkZllZCPOyMwkNS2NNWtv4Y1XX8XhNN4hLpeLyZOnMGnyZOTgeXU4RxezH+GKICsrC4vFwtpbb6em5jRTpkzjjVdfJTklhRtXrWbu/AW8uO45srNzuP2Ou3jv3Xc4fOggN65aTXRUFOPy8hBCcMOKG3n9tVdpbm6mqHjiULmDkZKWlk5MTCzJySlMnzmLmJhYKivKef3VV5g4eTIJiYnMnTsff8CPxWIhNS2NyMhI1t5yG+++/Ralx4+zeOky0tMzmFBUxLhxefT19mK2WEadUCQ1NY2C8eOZt2CBcY9GRpCamsbESZN55603ee3VVygqLmb2nLlMnjKVSZOnoJpMDAwMjErbb7Vaycs/a93OycklKjqaW2+7g61bNmO32Vm95mays3OxWK1YLGZOlZ3k6NHD3HzLbRx/5alRHdf1TFhwDRMmDBjvxTVr1rBx40Y0TUNRFILBIMuWLSMmNgZoBY/GvFkziHJEE+Gz8dCqz2C320izJFB/qJqioiIKMiZinSZoPFrL5MmT+dpdX+TQoYPEu6JYuWgZXo8HR85UlE6NL9zyEPv37yc1Np6HV9+Hsn3k433kkUd46KGH2LlzJ3V1dXg8HubOncvUqVMJdFhpk0DQzE033Ib0mxms9MaC2cuwqZFER9u4/eZ7qTxVSWZGJtJvpr6qhcnjZzBt+nTGj5tMSUkJcbGxKCErNyxaje5TSU3IxmWJISU1FXd3gN52L1YRgQhZWbZgFYpmY9mClYQ8gvzsYnRNI+A+O+55M5eQGJ3ImhV57D+wn4bqNhJnpHPvHQ9x/Ngxli5YSUJCAlpIw+lyYsbJ4nkrCA7A7GkLiXHFcOzYMSKssSydv5L2AyM7X0IIkpKS+Na3vkVaWtroE2QCUtOImDQLyzn1iRWLDc07cM5WAvfJJiImZqD7gtQ/9iyKzQ6KAnoSbW9tw1NbgdZnQw85aF73JqE+Gx2b9hvr395O1LT5WOOn4W8+iBF4PZIausNTWFDAikc+i6qqSCk5WnKUXTu3c8ttd15+5xEi5Aizm3T0Dlx2G4nkr6y/4KRSwz2h5UNpty9Hi+jkedMm/uT7B+aNsNzPzzr38Za7mvsjx2O6wpqpF2OLp46A1Hkq9WYsF8kQW+Z7m32eP1Fsux2zGBuLgUfvosz/NjdG/Jg08/Rht+nzd/M3b60lJ7aICQmjzHY7DJoe5O3yJ1macwePTP/7C9b7gic43b6E9NgncVlXX7BeiMvX4wKorCg3sqGdKkPXdW6/88LaHF0Dv6XD/UvGJezFpMYP0woE/b3s2/Awrqh8ohOmXv4APySk1Gmqfo3ohKlMmPWjS76k7O2/wN7+M3xx30AqIxciRzkiLpwmXy79jLFe6APYO/+bgcR/xBf/rWG3dLc0svHvv0rKjHlEZV46I+9HQfuJw/Q11HHjf/4Ri3N4pYml/AQRLz2Ob8YC9CtQrIwEta0Fa/kxer7415cs96P8+98h3n4R/cGvwrCx9iNNHXSJ7aREeflJZE4B+v88P2wMrO2tYzj/uAPv7VORjisPU0CCbX0poZw4+n+4Ztg6tuvv/QV6SGPFU98eVTzu00/8hdU3rSEuIYGQ28drK/6FvHvmMfNH11G9nzBhwoQZJa0tLSh6kPHjxw/Nrc4kW5VSYrfbDU+rgIRvV0C5B6zXMFWOT4dpLvSfjWPL+1uZOHXGea6+JYcPMnf2rPM8es6MVwgxVHfX3Qqn3sDIUPwJ197pIYjOBm/KMcx2I3cLQLBJ0PBNB7k/gLgVg6XtPmAJ/iDtjZ2UfVEl8UYHcV8yEm+Gujuo+fataH3doCioducFJ1UP+JEBP0K/GVX7DYYgenVekWdxIMUbaOp3hp9qmMxk/fRZbHnF549JC7H1x98lJi2DJX/9o6HlgUCARx97jM888DCqyYS3s531/+fLTHrwy+TecPN5bcRHjUxhPuYW2/naJEqUSp40vTuq/cbrWWTKpMtvOMgMWxKbPLW80H9qtEMcETe7xqFeYiIZZ8rDpSRQ4d84pv3GqtlEKqkXXW8zOZiUPI/jrXuo6T45Jn3aTA4mJM68zFaS4RzlRpr11WIxU3O6ipTUFKZMnTpsWyOJTVBNdmISZ9LddgB3b8WI+v6wEEIlJnHGZbcLOmZiMyVg7f7LhzCqK0M3JROyX/xYLBFRxI+fRHvpUdpLR+H2+yGSNHkmquXiFtNQfCJaQjKWk9d2/MGMXPTLFBqXsxYiNr2J8uyfrulYUBTk/IuX6wnlJaAlurBuHIN3iyIITs246GrVaqZ5RxmvLPrxqJoN9fWy5XflhsZX1/E0d6Nar5nzUZgwYcJ8KDgcdvq7z4bBCSEQQlyQORcL8A+ZcPzyBqerZqoLDQ2r1XaBAOZyReDz+bDb7ee5Bp8r6AI4E2DcjRD8+KVDGD0CItMkZdX68B5be96H7ppBIV8ZrLE3OPdVBjMuDC5zujXs2trzmzeZEDYH9HWDrqMNXNx1V4qNaOq3gbFU3OtI8f5F1ypmC8Jy8bDKvtYWTm0/W9ZTSsm0lASaD+5CIPC7+9CvMiHkmFpsATR03HgZbf5GMybsWEds5dWlxK356dq3FW/91Rf0PRdX4RRSpsy/pCVYSkkQL1JqF93mSlCECRMXvkDOJaj58Yeu3BXggwghcJhdwxax9gVLOd2xBIs6DlUZfcHo0RDSGtDlALkJuy9qsQXQtQCaNnbHP3YITGbnsOfxPKRE6H2MnQbtWqAilYiLqlellOjBANpg+Z7rEdVqQ71UrIqUEAwgtLF9hi/oxmQyrLCXUlXrOrj7zn7grhkCXBFwsWRnUiK8QdDG4N4UIB0Ww+Xpgm4k3ScaqHxhN1K/umM22c1M+MJyHMnRV9XOJwkpdXRt5M+mUFQU5Sos9B8iRub7oVCxK0JV4XIl30VXCKXryktP6BYFX7LlPKuGqoBp9HkGw3xK0HWdU6XHSUlKvCBO9KNC13WampqwOSNITE45b27q7u+nvqaK3JycoZwpYYxklO2dXeQVThgKARqy2Gb9ibiUozBzHoyfBBUnYf8OSEiGJTeCwwVlx2H3NrSAwokjP8S6JnbIYit1nc51v6PrxT8iA/6P8jAvRDURuWQtSd/4v0OxumeQus7hP/+K2u0bLt+M1cbc7/6IxInTzls+UovtmAu2HyZS12h68c/0lx4eSpRztQgEMfNuIHHlXVfk8/5xpjrg562BvsFfEiTo+Oj3vYGuD6MVkhIpjYQ3ABY9xP/P3nnHx1Gde/97ZmZ706pXy5KbbMsdd0wHmx4ghB5KQnpuenLT7w0h5Ka+IYU0CBAILUDAdEw3YGxwL3JX79JKq+07M+f9Y6S1ZUm23IAEfnwWeXfKOTNz5pyn/p6P7n0NTzq+b5dsF8bYrFH3wW0/iWzPpxDiw0nyQ3yID/EhjgTR8F62rPoBUurYbJaBKp0KgwSbI4BmcyGlSTLehWka5JedRuXUG4+oLcOALZtVEv22xgNJsAZW0YHfXC6YWm0MZ+8YFUwTfvcbB7t3qiCs8yUT/YquAK/XUlp7e0GaIBTw+8CU0NdndWTxEp2PXXFwxd91bxfuByxmfYodkJbQkbIMVOUOKHXC9pj1m0eFaV5L694YhbhBnc/Ft5dMAIdCvF/+/NiiFGdNP/o6jf+uSJvQp49ernKpEtcHzBBg6DpdXZ2Eew+/DvrxgKZp5Obl4fX5h8jEUkqSiTgd7e1W3dsPYdXtzcoiOyd3UNi2EYH2nzopSf2N7MUGnHkevP4SzF9i/Z04BWw22FUDpy6DO36H0dxBTf138N6QhWfhPgO8mU4R3/oO6daGd8EYPnpowTzc0+ejuIbnOdETCeKjqHWraDbcufmIAxaJdy0Ued+LJ9+D+yso+ugnKToOZx7IbRj1/oBuiKO6BzZVvqf5B616mqejYaSu0/PqqyQbmym46gpQlmKEw7TefQ/B00/FPXkyqdZWWv5yO3pXF3mXfhT/4kX4UiZf2Xw6Ba0xZKNFqZ6aX0p05khhzsPfLCsK49h4Mw0DTHP0N1XT3ttn8J8NieRwLIwqgvfWi9TRoRCPjW5ACAFFxSaa9v5ZaD7EBxOtyRjRSCNlY09n0rRrQQh2br6HloZXmXfy/2Cz+zCNFOtW/R/d7RtJJbqPqBY3QDIp+OsfHYRCgvnzoagIduyAjRuhqgqmT7f2W7cetm2F0jKTW34ew24/svfENKGzQ9DcrDBlCnzqU3D77bBpE8ydC5/8JNjt8PTT8PDDcPbZcNFF1rryt7/B669DTw+Hvl7DROjAbC98rQxe7oG/tMBsD3y1DMI6aArcVAvXF0K50wol3BaFXzagpyQzxyqcMEXhe/dB2oC++Cja/Q/G1rDKzTvcmHqaZPNOpGngLJmIUG0kmndgxMII1YZrzBSEzcElRUk+VvL+jQo6HhCKQm5ePrl5I3MyvBcYSSa2O5yUlI0Z5oh/H/SZKVqNI4+TVoWgXPMPSV/c/10Xbsj/bhzXch2CudATgs3rYNJUKC6FtmY46UwoKIZkEiJhFLsk//txZIlncISKquGaNh/XtPlH3OfjiZHmOMVux1M4Mjnv/oaTo3EsHrFiOzDApWmiqgK7po2uXsF/KNp6Bd97wEYyba1tDhvE++djRUDADUkdYv1yvccBbgeE45BMW0LxNy/QmVr63i16Dl21anq+tZq6H9+Cu6qKgquuQOo6jb+5la4nnsJdNQn3pEk0//42pGHgnTWLhl/+igmVlVBcjPq5hYhnd8MDGwHQFAWX/b3zvj71lMryx63pxuO17nMkss/IZeuPEE2lrOH7+S+mmTr1AzqIjzMS6a3s7bgOVfGh9BOuSXTSegea6kcRHusXoxtTJsj2fJSirO8eUVtvdsJrmdLIA89zn+9IStk/cQ6QOFjunkzpAAd8vBLu+7uN1W+pFBTAuHHQ2gp791ql3qomgc8H27ZZgrLLBb/6f0kKCt5/42f1Lni5v6LawHoxKK2nHwNRwRfNgwnHwWJomta7NlrYbCNHTX+IkdGBgWr3UjX9BnZsvhvTTFM1/QbCod04Xbm0NLxGb/cOwiErjceap4/MiCRMa0wtXSq46CLYvBkuuAB+8Qu48ELr+bW2gqc/7U4RApddw24/smszTescNhssXQolJdY4sdvhssvgiSegoQH+67+svlx8MbzwwuBxp47iem0DA8+pQHsaDKzp4tQgrAjB/e3ww7Ewzw+9BtxUBxNccFk+2BXyA3DdqbCnZ7/1RlWP+D7/J0DVFMIpk+b7bqH75XtBKAROOJv887/Arh9ehOoNorh8jPnMb3CWVmGKD/b9+hDvDl7qa+BbrRYFtNndh4wlUUv70+GkRN/TilqUjXA7kKk06c11yFgS2/SxKH4PQdXJo+UXkqMegkjWDppdwLaNMGMOfObrkBWE1SthTIXlrW2qg3lLIL8QGupwB1RMxwfjHdANg7RuIBRlPxnt8HFEGsf+Sq3P7cDp2LdCfdDCdwcQikFTN+gGnDsHTq+Gb/8DEim44TQ4cwZE4vCrJ8CmwZfPBZcdWnvg5oehrdfKc/IdolLJermLn5j3WM8gZVrlgWz97npTWix2dgU06zl8TJzCpcrIZDH7w2lY2p13xnRKPv9Zel9bCVjJ6kU33EC6oxOhqpixGLGdOyn/7rdxT5xI6MUXSezdC/mFyF1dg/LzNE3F7j54zvDxRDIOTY1w8slw1VWWkPXgg/Dss1bq33XXWQLRH/9o7S/koZ/BhzhCxCWG2URF/u9wO6Yg0FAVL9ubP05+4Gp8rgXYtXwaun5GU/evEUoXPs+RMY43tMBTHRKZTtL1wt/RfNlkLb4EMxGl/bH/R7TmLbIWXED2GdcS37WW9if/gOYNkn/hl7AXVFDhFXzaacmxBQXwox9Zymt+PvzhD5Ywff75VrijrsMPfmD9dTud78vx09wDz22Cc2fDqdUQTcKDb0BZLiztL7unKLD8bXh2PZw2HbxuiWnoyFF7mASqzXbQd72pCV5bKTGMNG1tuwAoKBiPomi0te0kkehDCIWC/PE4XT6mTxdMObxSwB8CsNtsJKWJlDqazY1p6jicQRzuHNKpCHZHgAlTr8TtLWTruj9j09Qjftc0xRo7hmGFAA/8VVXIzbVCg10uWLfOUoAVRcHrduE4vLLtGRiGde50Gm67DXL6qR98Puvf69dDezskEjBzpvXOnn22pRDfeae1r03T8HkOIf7Y+re/EYYKl8U+qwooc8CmiLXWtqcgzwa/bYQsDS7MhWe7IW7iLoC3G8DhsfJqdRMcdhs+zwdDSB0OrjjIdJRk8y7GfPb3mMkYTXd+m8DcczGScdyT5uOZOBdbTgkSaxx/kO/Xh3h3YE/ZSEuD9O4Wem9+ALUgQNbN1wEQe/QN+v70FFn/czWOhVVE/vo08RXrER4HSsBD8GefQPfZ8bic+GyHmEOltCaDdBo2r4dwDyw+DTrbYfxkePkZ2LMDps6CYC6ioQ6PywFHODf/O2FAr0zrOuFIPMNAcyS6wxG70kzDwNuv1P6nK7OHouTeH0VBOGcW+Put02Pz4bRp8L8PwQmVcM1JUNdpeXPvegm+eA6ML7QU29GgW4Z50XiH5NNtJG/dC24V13cmoE7zkfjlblKPt6FN9+O6uQqRZ+cE9fBrBKteL/aCfQzVQgjsRYUorn4vm24gUymEzQaKYim78bi1crcdfXHlo8WBz8vthssvh7fegu5uS8ARAmbPtjwLL754sLN9iGMJQ0bZ1foFhNDI8V5Arv9SIsl1RNo3ke+/jOLs/6Krb/kxa6/r+Ttouvv75J71CbIWX0zXC3cTfudZck67hvbHb0U43LQ9/Auy5p9HqqORpr99m7Hf+DsW7aQFr9caO/fcA9/8JkycaHl/brvN8kTdfDNkZUFn5zHrdgYHm3tMafLwxr/SEm7I7LN/qJjST2ImkWxrlRSUePnE6V/kkbfcVORZBrf/9wR0ha3okc8thegBaVKrbv8dLRvX4vAHrD5ISMWjpONxVJsNu8dLMtKHqetoDidnfe8WfPmFI16PaUI8bvDoI//LmjX/BOCEEy5h6bKv8uADN9HcvI329t18/OO/Z8HCKzE+uOmIB8Vo1qR0KkrNhtuZNP16bHY/ppmmr2cPb774NWKRVkrKT6Vq5o1s33T3MemTqlqfggJLflMUy4DY2mopl5/8pBWifCyRTu/zhuq69VFVq+0BstFYDL73PaiutjzIr79+FA0a0lJm/ZplVPaqsCdhff9yGWyIwOP7JoKqEvAF4Gvnw88fP6pLfc9xOHLQwaA43JT/15+RpkH9bz+Nb9YZqC4v7rHTcBRV0v3i3zH6uim84nu8l5Wdj9X1/qf041DYf+15P/T1SO6bjCVRcv3WBCKwnDS6gZLlRagiE9IU+O+PIewaoe/fjeyLWS/5aGEYlgA6aSq4PNDVDhvXgtNl5daefBbEopaCK03YsxO6Dp2XOgSKiiyvBLvjffE8DoWBPto0jYDXTXc4guivdXu4/T9sxXbfYAHXB0CpBYjHLTKkAynMh0NDJ/zkURgoqViRD119UNNoLbJnzoCVNXD5Yvj2xZaHt+EwBWKzLUn8O9twfHYssiVB/Ps1OD43ltS/WnH/uIrEX+tJ/rkO53cnHO6ljgqK14O9qIjoxk0ITUPv7cU5duxxaetwIaWkp6eHQCCQGZvBIBQWwhlnWILPQw9BXh5ce60VqmZ5EY6OZfNDjBJSossQinCR4/sIrT1/wTAjgIrTXomqeMkPXEl9503HpLmsxZeQ6myyvI6mSXTbGwRPupycpZ8ktmcD4XeewYiFCZ54KfG6LbTcdxNmPAqBfYptTY0lkM+eDWVlltenttYKf/zc56xcwtbWQ7OsHglM0yQcDhMMBodsk9Lkld1Psqe7hnOqLqe6cC6v7nmK1/Y+xcySxVxcfT2qotEcruWpbTeD3Utv/EbOn+PG67Q8s3UdUNsBp0+D+k4rZHl/RDvacGfnMvfazyCEwOH10bhuNe/cezvzPvs1ssrKad++lZV/+AWY5qho+lOpOG1tu7n2uj8SDrfzxPKbOefcb3LtdX/k8cd/jG27g6nVZx6jO/ifiXA4jNvtxnYQ1m8hBP7gBBr3PofLU4jHW0wgeyLjJl/Gjo13Ulh2ItG+Jkzz6EorgKVMLlwIjz5qfb76VVi0yPKebtpkGX4uv9wyEh0vLo5o1IoIWLoUGhutSJx16+DMM2HGDMsg1dVlyZWHjYGsBQm81QcfL4BiO0x0w/Iu+O8xUOmC+gSclQ3PdtMcgodWwuknwP1vQPrf3EgzmjE3OljrcusDNyNNg6LLv4sQCmWf+x32/HLsOaV0v3QvBZd+CzhCt/4xgJSS3t5esrKy3lM5t6enB7/fP4iI6P2IAdlruLXqvUAikcA0zaGlkkaCENimjcW1bA6JF/tLAGoq7o+eSHJ1f1lRVcH76XOQyTS9N92Hc/EUlBz/6DvV0miFG6dT8Pc/W6Es0YhloXv9RVi/xhIkopF9uROP3T/68+8PwyQ6bwm28y7BcaThMe8BhBBWpKdNJaWbGVbpw8ERiWKmaaKK94dVZn/sb6E5llYuXR/9iiSB1H67J9L9a6KwqP5N0xIin1oLj62BL50LS6bAvSOXhRqKpIlMmqiTvZguFeOBZvSV3WhzstDOzMPeniL1SAvoEkY5F0op0fe3uDkc2AZivPphCwZRXC6EppF/+WU03fpb2h94iMCiRTjKx4DRn824v+SSNqEvdXip16oA98FDGg+GZDI5yHpos1kK7c03W6Fq11wDEybA2LGWNX/KFMvbdt99R9TchzgC+F2LURQXoejzCOFAEQ5q279LJLGekuwv09j1y6NuQwiBLasALZCHHmoDJEasD8XuBCEQdgeamo1/5mns+enlmIkIijuAGEaAmDLFClv/4x8tpVbT4MorLYH91lutdel4KLZSSpLJgxFuCZZNupTTJlzIizsf59oTvkJXrI267h08XfMAV87+Anu7t6ObOh6blfu/YhMUB2FCMTjt1ut6wVx4ZNXguWsATevX0LFrO5rdwalf/wH1a95k/ClnYXd7WP/g3fiLSlE0DXOUybMOh5dPfPIOTFPnjjs+ydTqs3A6fRiGpWCFw+289urfOOfcbx7BHXv/wDRNpJQZgXSAfGWgNuXRIJVKDV8jsb8dR6oHKQ1CnZuprLoUXY+zZd1txCKt5OTPYNL064lGmtn89q1IU6erfQPrV/0cAEXRqJh0Mb5A+aj7YxiW8WfpUisXfepUeOQRuPRSS7F0u2HnTmhpsYyK4TCDcmxFP5vxaGSYeNxSYq1rtZTnzk5rjr/7buu9HDPGMkDt2AF//jOce66VSnD77dZ+W7fC9u2Wsjvso4gbFuPxAF7rtTy0AK/2WOtauRP583qidSn0TXGoTVlhhm4b2DQ6pcY7e0B1wd42a218ZQu09Rz6GlUFLpxrRXy9X5BOp0dNfDUw1mOxKFJaTgFLQBWYqRjN9/wPodcfpvCSbxDbtY50VyOdz/2N3KWfoPvl+3BPOAGh2pAMbwh5N0TPQ8+9Bz/WlBCOp0mbEq9Dw2VTjui9P9I+jAZSSnoSBh67gl1VaI2k2NYe56SxflTl/dXXw4Wu64dN1Hbg8xFCDJFdZSpN3x+eAE3F++lzrJd1tEjELaX20o9DUelh9e2wYBhw/99Id3WgHOdyhscDQghsqkoipb97iu3hMgaPBF3X2bt3D9FIhPKxFUdtGUun0ySTSbxeL6lUCl3XR2+tOYYQmf/B3nbI8Vl5bbMrYFcr+PrD5e0aIA/vvQBQSpw4ri4l+pmNEDMRAc1igFH621XYxwIzSqSl5OFQF0r/4dlzZpM1rRplQMhXVcq/8mVQVU7Z0kvAXoVx408wkylsOdmIdWEcaRPnpggytk86lu80YnypfbgmR4ZLQ/3iIph8bFb17m7rM3Wq5b3t7YV//tNizVyyxGLxfPHF9xVr+n80hHBQFLyRtp67MMww2Z5zKc7+Ao1dPyfLfSrJdC1SHgcmTEXFVTGd6I41+E9YRqJ2M9mnXoWpp/BMXky05k303k4U++B8lqlT4TvfsRTaceMswXjWLDjvPCvU8tRTLXKaZNLalj4KB5iiHB5ZkhBQmjWOnZ1beG7HPzll/HmMy5nCxpa3qDQmUxIYy86OTWiKhqpaZHX/Wm1Fknz9AivPf3KJ9c4f6K0dgJFOEw91UXbCQox0isZ1q6k88VRyxk1kVm4+obo9hzXfWIodPPavH6GpNs4991tEoyFMU+fSS39CVlYRmzY+w7KzvwrvMSv20aCnp4dQKMS4ceOQUtLd3U1nZyfjxo07zjUfJcqexzCExsa6jazdsBKhKGi52QjVSf3Lt0FaR8sOIuw2cBbRFY+yZ/cLAASSnYQSYcbO/2+KbTZshxAstmyxPKH/+IflIc3NhX/9y1JkV66EyZOtfNctW6y/TU0Wk/H+S72qWqHKS5ce+ureeQf27JH4fBEUxeQFq9sEAtY8//vfW+c2TSvvdiDiYiA0ORCAhgYvf/ubyk9+MoKS1K1bYcUn+KDUgUTS2toGBZCfn4+qKNCQRG6O8puZFdT1emH/dKJT8zCEIK0IVtbAmH4emu4IvLH94NcngdaQ9a5+75J3R4k7lhgY64899i9iMcs44HK5uOCCC6mN5SL1NEgTb9UCIlteQ2vcRv4F/4UR7SWy6RUCJywj56wbQAieb4Ed+2U3BWzwuYmQP7xN532D7mianz+7m3WNEQwJXrvgk4vLOGdaPsoRKIxHit6EzrM7e4Z1LFTluvA6VH7zRgvVBW4+PjOPe9d30hVLE4rrXDg5+4iU29EgvnU1yd2bjmxwS4lj7GRc0xYd+471n384YVD2e636bn2c+PNrcV+wkPiz7+A+Zy4EXaSlSVqaaBzCcCkE5ORnFFspJanONsIbVmEmh5ZMkoYOCFSPl8CsRdiCuYfWk3Td8uj8G0Ny5AzyR67YiiNnrBpQite+8zbJZIK8/AJeeflFzjjjLDxeq07RkZxbVVWam5sZP348zc3NFOyXJ3o8ISWEovs4k2JJWLXDovdv6oa7XoHz5kBPFP6ywmJIvnIJfOYsS/F9Zp11jg21MKdy5ALuGdIuCTgUXN+egL66B7MzhbY4SOKnuzA29ZF+oRNtZsAikJKjy30wgc60zskOJ0tiMesYzWbFSvdjt83GQxKu3ZmgqroEcoehTT3KWy7jaeRj25B7uhFHqdgahmWl7+uzPG0f+YilfNx2G9TVWfs4HFb+V0uL9f2pp2Dt2qNq9kMMAyEkM+e1g0uiCjfx1B66I08AEE68RSB5KmW53yWRrqW243tI0oTjb7Kn7euH3ZYEOiPLgDMAUF1epJ4CBDmnXUXd//sku354Lva8cvyzz6L1oZ/St+ElhKJScuMvQdWIG/BWO9RpIPLh6e2gdVqRQ3a7xbq6vD8V2O22BPNEwiKROpr1ZMYMS+gfLWOslJKXdz3OV07+Kb++4EFKAmN5dvtDCBTWN7/J/zz7ab568i1U5kymtquBWBJ++XHLmPbqVogkYP4EePztfSzuw0G12Zm87EK2P/8keiKO5nCy44Wn2fjwvSz94c8onj6LxrWrR9XnZDLKIw9/n/Xrn+Ccc79Jff0GWlu2s3rNQyxZcj1r33mUCRNPRFEGPJ2juxfvBQ62TJmmOSjap6enh2QySV9f33EN14uaBm3JKA3+yTxadB3JhkaE3Y5jTBlC00i3tGJEIzjKylCc+xlxBCimzmXbbmFHTycv7t7JjfkFXJ2bd9D2tm+33u9LLzUzhFBjx8KJJ0JdXS2apjF5cjmzZg1/vGFY4csbN45OsdV1sNsl3/52lIKCw/dGtLS08Oc/F5FOj1x2IoNzc5BnBmlra2PP7jSKohCcVYjUNNQdSVjZy0nzNeZeduBLfyAT++hhGPC5vw4fPQHvv1zGA6HrOg899CDz5s1nypQpANTUbOMfDz7Im1NvpCDoZ/43f7bvxRbC+lR/1fptP7Z6gIQBIEmZ8EaHYHY2XHAcnV1Hi5RuctMTOwkZdhZNHYsQgkRK5zcvN5Dl1lg8Pvtde24dUZ093XHOHj84B1QoAkPC7W+38bm5eaxtifGrN5pJGybfXFzAPRu7eWxb93FTbmNrX8Ixfjpa9sh8DCPB6O0i+vYLx0yx1aXJ2mhr5ru9eixqbmDf5K4oeK48Fa2iABSBNr4It8dqW0atAtq9RpKr9yyn2OblZ2WnUmwfXb1VKSWJxr00P/w3AvNPxVEydtD2dKiL5ntuxVVaiVAUut9YQeV//S+2QPYxufb3NY7CgXrkZuPDbE9KiRFqQKbjbN3bRENHH6lUimVnn4umaaRSKZ577hnsmsopcybhsGuogVIUx+g9rko/RXRjYyPd3d2Ul48+lOpo8dCb1nswJheSRpKHV6cp6C8mvLkeahplxqnRG4M/P7+PSdKugdeW4N7XnCybKRgzghxhGAZPvvY0LASEIPH7WoRPw/2TKtSpPtIrOol+coPl0f3hRACebHiZvU3bUVWVGdNnMMVVySKqUUZScHt7CdfUUFRUPPh306SxoQ5mnwB5HsQFU+gOdZNMJikuLh72XKOFYRjE43E8Hg+iN4HxzLFhGOnqsjxpwSB0dEj+/GcDIRRMUzLQ5bY26zPwfdcu6/MhjhUEUpqEwwJb7u+YONWOIrJpCd2BKnJQVSvcvbn7Twg0JIZlkVXHo+tROnofO5ymAAinA7zU8VkUTBQhKDjjGqSUKArYyiZR9aMnMCIhtEA+itNN+Sd+hh5qQXF40Pw5IARdSfjvDaDPsZTWrTEo6INTui2PFFjMqwNYuHDfvxOJBDab7bBzomprYcUKuOKKfUyvo0FvIsTT2x4glo5w6fQb6Yq28+mF3+G57f+kO9aOKa2Q2GgSvncfZLste1VXxHK0/uUFK/9PCKsM2WnVVqjy/iiYXI3D56d+9etI06Rrz07yJkymYPI0bE4Xib7wIfsppRWCqutJDFNn7NjZbN3yAoFAIaef8XniiTBbNj/PzFkXsGTJ9YBg9x7oOA6kXEcLgeW9LysbndMhHo9jGAZFRUV0dXUd17y9hCnpNnQibQaljmIKS/u5FgacAb5i8AFp65PSDdLxCNctKgVTJ7TbSZnbw0abxu5hPAjDweWCCy808fms71ZUl8GqVXXYVZgzKTVESBFCoAaK0aWdV61KG5j766lCyRg3DoQQguxsL3l5hy/4pNNRTHN06UUSaGtrY+fOnVRVVbF9+3Zqamro6Ohgvn8aXixWaIcmSSQShMNh7HY7Xq+X3t5ecgcmi8OArgyU4LI8n+l0GofDgcPhQFVVwuEwWVlZhEIh8vLy3nfKbXt7G3a7nerq6kzfpkyZypp1G2hubWVp9Ri+MUnn5ZdfJplMUllRiaqplJaW4nYPL++9+eabaNklfKuv/HCD0d51NIbibGtPsLi6ICNnuRwaU8oLeGRtK4vGZ7+rlFgFXhtT8gdHISmKwsu1EfqSOnkejYsnZ/HA5m6a+tJoiuDCqixueqWFibkuqgsOzS1zuBCKimNMFb3P3I1MDK4fK02DnGu+Tde9Pxt6n2x2si74FIltozOijgZxU+f5cC3VjiATmzdjK8pDlPhItdaRyp3N3qZWZP4YZERCRIcTThh8gl6gN057rI0dk3LZlNsxesU2laR1+T/I/8jHcRSXD3qXpZR0vfAYrrJxOAosI1yyrZHedW+Qc/K577v3/rjgXVdsDxemQffjX0XzKbR35TPr3P8mGMxG0zSEEEyaVMW4ceN55blH6X3jx9jCrfiWfA/XpNNH3YQQgrKyMl555RVmzZr1rj34lkgbO7vSBLNsnLrkZTpiHXTFe5icOz6zz/T8KtzdKu3tbUOOdzqcvFqjsKJpIcZBnqOhmKyd1YKmqHhurMB9eRnYBMKlggm+/5mMjOjWd4cCEcm2QBPbAk0APGCsJtcIskL9FaWMbIVXFAWbzUZnp8XElpubh2EOtYwPGBCKi4sty1N/sr7D4cAwDOx2O6lUCpvNRjqdJpVK4Xa7MwKOoiikUina29t57rnnuOaaazJctOl0GruURCIRnE7nERFWmKZlOLjxRjj5ZJ1IpA9VteK/389eoP8UiP6YfNM0+NOfHKhaEq/jJMZm32HtcKyfgQCBoDkGsYY8Li1+k/PGLmIoAUlW/2cADmDskNNt22aFNX7jG/BYAswc+Mo8KwX8YOjsjODz+XA4Dk+xffTRfeVIRgNTmpjSxGlzc8bEi1CEwrb29WxuXc28Mafw3TN+i5SSt+pfYk93DQG3l++fA54RvMH3vgY1TfCNC60QZT2VIhmJAOAMBNn61KOkotb3LU8+zKyPXUvV0vPZ+Mh9tG3bjHqI8FrDgF27IS8vyNe++v+Q/QNA9IduTZ/+3/tyUPcTadLHISr9aNHTa3noS0sPrdgOhGbabDZSqRSpVIpkMjkoR1bXdYQQKIpCOp3GdoiySaNBOmrgC6sUHaJURCyZJtUX4xR/ANNI86Kq4rHZ8B8VWY1k05pf0t2wCmGkeGl7L6axT7kVQqCodkSgCFQnc6cIvF43rz4DejqKBIrHnMTU2Z87ij4cHSTQ2dFBTU0LU6dOxeFwUFhYSEdHB5FIhI5kBwPiq2maNDY2kp+fjxAC0zSJx+PoupUjNvDbQM71QDrX/jnYhmH0P3Mrp0hKy8tfUFCQkZMURSEWi+H3+zOklgPHAsd0/BwpUqk0LtfQMedyuUj15+Gnkkm2btnC+eefTyAQIJlMYtM0UklLhlBVFbvdjmmaxGIxGhsayNF87yFH8ugRTRqoqjqor0II3A6N9h7dGljvgwvZ1Z3g6Z1hNEXwvZOLuaw6m0e2hbj51RZMBB+Zks3E3OMX8y2lxIyGybnhh4N4LbruvBkzGUcAOTf8YN8BpknnHf9rMQUfBywJh/hMRw3eslz0nlbCG57DPkHBcGTTlncKq95ZP6wHUUpJTk4OrzRs4V/jTEYr2Egp6du2DntByRClFgDTJLL5bez7hR7bsnIIb1xD9olLQdU+GMrtEeDdU2wBxeHAPX0+th1Odu3cMax1LhxL4Zm7DFG7EuThhxkNPOgjSTg+UgScfnJcJjYpOLG4moZ4M7W9jZxZOTczxoOuLFw5dirKB3s3pZS8vvJVBKOw7AowvArzmiopuj1JYeEwocAHwa7x3aw8rZEUB08CHFtRyZw5J7Bzh5UMNGHiJHRd58XW1hGPiUQiLF++nJaWFhYsWMD27du55ppruPfee1m8eDHPP/88LpcLr9dLRUUFqqpSUVHBv/71L4qKilizZg2LFy+mqmgsAM88+yzZOT2sXr2aG2644ahC92w2ECKJ0ylQlA812ncXElBQFGsxUoSGEC5LcTlOc7LNpiKEQp4jTJV/sOJhmibNzc3k5ubidDoPSugTs4HaBhUO8OnQu99rM9wCd6hFZqDtnJycYQW/w8X65jfZ3bUN3Uzz7aeuxaV56Iq2kTQS3Pb6j8h2FyCRdMZaSUYWM23cBKaWOXCNYCPKPsDI3LF9Ky2b1+HJzadz93akKfEW7pu/Nj3+IACR1hamnn8JJbPm4g4e3NUsJZSPEcyda1HMmhn3y/73U2a+j0y0tP+xw8PKZRv+mVjPHAYiCg58nFZ05MhryMqVVorDaKFpGtnZ2aRSKbxeL+l0epBiG4vF6Orqwu12k06nKSkZRZjsUUARkOtWqQhqBB0OVOk44nymkRAJ16MnG/BnjWPa3O+xY9NddLS+jaLYGDPuHIrGnMSaV76PrseYWr2UidOvAynZtv7PNNe/TCA4/pBtHG8oqppRSsEyQKiqyvz580muD2X2s5g8NZLJJDk5Oei6Tl9fnyW8myZlZWW0tLSQTCYJBoNEo9FMqHowGMQ0TSKRCIZhUFwyhv1zyxVFQVEU+vr6sI+Qo5BIJGhtbcXv9xOLxRgzZsxxvS8HQ15eHq2trfT29hIIWCGw4XCYluZmCqack9lv4J45HA5ee+01Fi9ezB133JG5V5/61KdYvnw56XSaTZs2sazi37+g9XstfUgpSegSlw0+NjWbTW0xHt8ewq4qfPekIi6eHEQ3oTdpcnplAPvhEsAcLhQVxelGqPtUEbEfr4twuDPzvzTN0bHLHSFSjatxjasCJJovSOD0jxDb9BbuyVdTPn4SecVjGO4JplJpHnnkYcTh9k1Keta+Qc4ZFw27xqV7u0m2NWImYpjxWObak60N1N52M77JM/FOmoaztPJDBfcAvKuKLQCqi2nzzqMvMnyIU0FhEU5nM0lWHvappZTU19czadIkGhsb37UwHbfmwmuHSF+Mru0tlE4tIpqOMS5QPkQAPpB2W0p52EQiDsPGkgmzcDrsoxaQY9Eo5XOmsZJ7R7X//v0eTZx7PB4nnU4Tj8fp7u5G13W2bNmCw+Fg69atnHbaaUyaNIlbb72V7OxsvF4vpmkSjUaZPn06DQ0NVFVVQa81LhbMn8/f33qLiy++mKysrFH1+WAwDOOYEJ59iMOHpTzu/wPH1WItD2LRjUQirFmzhilTpjBx4kTS6TS1tbXk5uYSDAZHMV/su5bm5mZ8Ph89PT0UFxcf8j2OxWKsWbOGqqoqqqqqjnpuCsU7kabJJYWfZ+60hbS3d2SiLAbQlWrhycidpMKfZn7hkhGV2uFgGpYX8fRv/Qhf2Vg2b9o8JHLDYehs/N1PyJs4mYqFJ4/63Ba5j2Tr1i0Zgpmh+wimTJmC1zs0rEvXDTZv3jwiC6eiKFRXVw87P5qmSV1dHV6vl9zcXBoaGmg9wGiXl5dHZWXlsOc+3GlECEFhYSHd3d20t7db89wB8Pl8pNNpIpEIpaWlx3XdctsEi0ptGG3bqXl1PTX99/8dl4vq6inooyjZNFooio3xUy4nO28qqs16Ft5AOeMmfwyhaCDA7ggwacb1NNe9hJ6Oo9mOL+Gjw+EY1bopgOzsbKZMCbBt27aMZ3HmzJkYhkE6RwDWuBFCMGbMGLq6uqirq6OoqAi3201paSl79uzJMLQOKLBSSgoKChBC0NTURDKZzBg14vEYYCmEhmHQ09OD2+3OeHyHg9vtJicnh+7u7vdUqQXrXuh6mr/97Q7mzJkDCDZu3MCSJSexPrnvXe7q6mLt2rXMmDGDeDyOaZrYbDYuvfRS7rrrLmpra4nH49xwww3cd9997wcn5781pJS8Xh/hsZoePj8/n7FZDn50mpWs/PDWEA5N8PVFhVw6NcjDW0Pcta6DG+bko72LZFfvJRR3LrGanZjRl/GfdCF6RzNa/gKc0y9BChWXa/iQ7FQqZa39h+mH08MhjEQce97wDqrYzs0ICYGZC+he9RL551+F6t73/piJGM2P3EXRBVfjrph4eI3/h+PdV2wBn9+HP2tkD6WMhFBceQjb6L0asj9sta+vj1mzZpFIJGhra6OgoOBd895ainUdaqnlCVr7ztt0dloJYvF4DKfTNYzAYoWpDQ6NHEVbpkkgEODkU04bsm1/L8eAR2rVm28Q0rsOeV5NVdm7fTvdXV1EIpZLora2FilN9GFow3t7e2lra2PNmjX4/X7GjRuHEILZs2fzwAMPcP3119Pc3MzOnTtxuVwoioLX62X37t0IIYjFYqiqSjQaJRaL4e6vqZCXl8dXrvlKJozrQ3yIo4WUkqamJiZMmEBrayvjxo2js7OT7Oxsent78Xq9I3pE+s9ATc12Aj4vJSUlBINB9u7dS2Fh4SHzaQfaHj9+PO3t7UyYMOGYMONqqo0l089gUmk1tsqhWuuOjo08/ejfj6IFgeZw4A1kseDEE4ds7WtrYdORnlkIqqurj+hYVVWZMWPGER3b2dlJZ2cnvb29eDwexowZc0yUgT1d29jRse9uRCIRIpEIe+UGAKLRKOFwmFo2AjC79ETyvZYH3MoZzSY7+/iSgrhtgtPKBO+88CA+r5dly87ORMP09vawatXrRDo6COQOVb4PBtM0aG1tpa/PWiMGSqWYZpqNa36N3bkv4iYc2s07r/+YmQu+CRKc7jw83mLGTvgIhpFk69rbjt0FHwBVVQkEArjdo3v3RChNbiqLKYFx1DfUM7N6GvYOiUTBmXAiAWc4jWxJEvOkM4YuwzAy4cNgPXuwDBjWfbFCbE3TxG63I6XE6/Xi9/tx71fJwW63U1hYiKIodHR0DNdFq59CEAgEMh7S92rNjMWi3H//fZxyymlUVFSwc6fFl3HNNR/HH8yBVfv6VV5ezkUXXQTAqlWrAPB4PKiqiqqqaJpGT08PDQ0N1NfXkz9h2rt/Qf8hkFKysj7CyvoIZ40P8Ld1nVw3M5eK4D7l9h8buwH48oICBNCXGnAGfDDkL8+MS/GEuklsvwsj3EWqS2eddxo7/3r7kH0TiYRV170/7S4U6gbP6PUMCUR31+AaO3HYMghSSqLbNzL2s98h3rCXvGWX4p+1aEgOrlA1+rat+1CxPQDviWI7HBoa6lm58nVUVbFi6M1xULsHVln0tXl5eZx55lkjTtixWIz6+nocDiukStM0uru7UVWV/Px3rxhcQX4BAX+A9lCIadNnZHJfXnn5RRYsXDSsx/bll16A6JG0JoYo7QkD3qyPUteTxK4J5pV4GZ9tP+RCJzApEdtwJpvwBEPogLO/7vQAzcaYIidjRZp0IEE4buLyt9PSuYLHnlrB1KlTaahNEwxOZNy4cWRnZ+Pz+aioqKC8vJyVK1eybt06Lr74YvLy8uju7iYcDnPSSSeRk5PD5MmTaW1tpTJnX6jj+70g+Yf494JhGLS3tzN37lzC4TA9PT0UFhYihCBnFGxNyUSSxt4GupwOioqKcLlcVFVVjcr4Ypom7e3tzJo1i1gsliF+Odp620IIgsHgQXLqjoFQIkfu39EI0AMhnt3d3WRnZ2fCLffu3ZvZPm7cONzuoZbygXYTiQTJZBK/309vby/19fWA5bGdMGHCsIXpc3JyMsc4nU5aWloyBsgBZGdnU1p6eNSrb9at4Pa3fsZJlecwKX8GqLA9+jb3vPIqc8tOoSpvOmt7VrK5Zg0g+cnZd2YU2/2v6XhBAPNKbKx/+WEmTZzE3LlzB60fubl5nH32ubz69MOEekKkC9PgGF2OXSqVYs2aNThsUZC6RfyUDCEAQ08ckFYkMfR9+aGq6sAwUqx66VsEssczfupVNDe8emwuej8MyAS7d+/GNGeOrqzWn5oRT3WTU2Anpy2A+M0u631wKuDXQJdMv78OXtCI3ZKD7pIUFhbidDrx+60FdGAtTCaTCCHIysqit7c3872goADDMDJ52AMh8EIwiGTM7XajaRpZWVkZBX1/vJcG4HAYYjGT51espKhoJmVj5mAYgspKy4FhGNDRAVlxcKjQ02OntHQ2bf2UI8Wl0xFOL1NmzSVmCCZOn01WQQmLTzuLV1a9zdTZ8/DnFiJ7D9KJDzEi4rrkXzU9LBsf4O8bujh3YoA713dy/azcjOdWSvjXth7aojrjsp18YUEhtuMcimz0dtJ9/68GpX2kmnaDEKRb6wjdt189eykxuody1BwrSD1JbNODOMeUEd+xE/+yn7PIXcj8YRw6q1evRlUV5sw5gXQ6zb333kNn+vAGZ3TnZnxzTxr2vTUTMcxYBGdpJZ2vPEXuOZcP2U8IgeJ0IYfhv/mg432j2NbX15Ofnz+sBT+VSrF8+eOceeZZIx5vmmZGwBzImbPb7RnF8t2CoqqMzx5Lsb8Qm82GpmkZggi73T5E0Bro97FAKCn5/VutTMpxcFK5h96EzsNbOqnK8zDGNZy3eB80UlwhvkvMtw3h0/A55xFNrMOQVpiaXSumWCtgUmoj4Rk2GkPnYHPmcuo5cbr7nkA3e5l9yjcpCF5KMpnkpdeeYtaJVcToBFXh1NNORhH7htu55547qP1ly5YBIHvifIh/X0gpSafTmXFvGMYREX8dTnupVOqAd3349rq6unA6nTgcDkpKSqirqyMnJ2fUAmFPby8l40roC/cSDocJBoOjNr6EQiFsNhsul4vi4mKampoIBALs3r2bwsLC/nD7IykNYrBu3Tp8c7JJJBJE+smeBtAYbhwSviilpLe3N5PjmUgk+oXkoe1LaRIKhchKpWhsHOZc0aGJprqu09vbSzAYpKenB5/PN+wYkFJSV1dHd3c3qVQKj8eDx+MZFAI8nGIK1rzZ2dlJIpGgubmZqqoqvF7voGNHGneqquLxeHA4HCiKQk5OTkYJGcD+3vQB8qdAIEA8Hu9/5iMwhQpB2kxhmgbLqi6jK9qGXXNx3QlfYVPrGr5+8v9xy4tfYnvHxuGPP44IuhRsob3YNG2IUrtf9xFCsG3bNhrcDUzoL9dyKLhcbi666GK0pmcxQq9iL6rgzfWSju7MmUc8Nh7rIJXsJRAchy9QQTrVhzwCfo2DQdM0WlpaaG5uprJyHIZhjq4slwkEVIRDWEVU65KQlhY5o09FCFDTElJQkJcPgX3jZn/FFqCoaF/IYTgcJicnJxMhYrPZMtUF9lXYEwQCWRmOAE+/J3fgnTgWKTrHClu3wvYdAinPYO26TezY2UR2dgmGYbBnz2o6O2uZNGkJ01xZrF+/nB8mLbni6afrmD7jHELuqfwqbSLFTFgpgWmwAWAqMq8aKRTMWogblmL8fkQymaSnpwc4eKShbuhEeyPHlRn9QLg0wefm5nH3hi7OmRDg4a0hLpkS5G/rOrl+Zi5jgw5uOr2Ums4EOS6NsiwHLu04G9pUlbxP/RgzNTgt0Xf6x9CyC8j7zE+RxuC0CN9ZVx63e5asXwOil/iebjwLv4oSLB9COzkAh8OOqqq43W6SyeRhy/BST5MKdWDPG76iSKKpDkd+MTKdxEgmsQ0T4SqlJNnWhC1wGCUUPiB43yi2AMFg1rC1Z5PJ5CHD9rxeL2VlZRkFcuzYsSQSicxi8O5B4lKduFTnu5vTKQT3b+rktAofC0s9/S+/g8l5Ln6zqp2KinF4PD0HOYFEYKIqDspzf0hh1g1sblhGJLEOt30yE4r+gmGG2dJwAU77GCrzf0ZffDW6EaI3+jK6GWJt+BFaIhvorIsRScYorQyyo+mv2BQ3VxX9loDt8MiuPsS/J2KxWIYheySl5lgiHLZKzSSTSau8hji4EvX666+j6zrRaJTq6uoRlacDoSgKDoeDtNNJXV3dqAWTgdz/SCTC22+/DUBJSQk7d+7E7XZnvIxWOsLhL9p2ux1FUQaREQ3AnR5eAbPZbJl2D05UJLA77JkUggPntLQxNB9TURTi8XjGkHAwAXyghMkA87lhGJmwzf23D+mVEDidzkxenqZpmWe6//aRBA6Px5NZU1Kp1JA8X5fLNeR+7tmzB0VRDhq2LKXJm7UrGJczxcqf7K1l0dgzeW7Hwzy44U985aSfMr1o/nui2JYGNHat3ciCBQsOKYiNHzce1zCe8mhfE3W7nxzkJVB1mDoedm0BpacGM7YbNdZINGaRK0kp6e7cQiK2L5RWT8fobF2LKXUSsU62vPN7KqsuJZ2OsOntWzGNFOl0BNNIo6hHN38MKLVtbW1UVVWxc+dOdP0QxFTZGhQ5oDkJcROSaas2liYsxTZhQuTIle/8/PxjkorwfoHEes6rV/+T++/7OsvO/ipnnfVlVq/+J48/9iOysopZ8fzvufqaW9m9cxWpVIzWtp0kEn1MmLgEb18Xc575BWAiFAWhKJj9NaAD59+Au79mqc8GJ717AXiHhc7OTp5++ikWnnPZsLKfaUo0RdDV1cWTTyznE5/45LvWNyEElUEHH5+Rw90burh4spVH+9EpQf62n+e2tS/FjEI3btvxT9+Tpkno/l/tV7vYghnrI/fGm+j++y0I5wFzkKETvPyrx6U/6bZNyGQcx8TLsJUfmxq5I0GmklZUi32o7CGlJLpjI74ps4jt3YGjaMyw4coAiYY95J18zrDbPsj4j5lZhRCDSEbsdvsh8uX+s5DQJV2xNCcUDy7+7dQUzqj0saU7hbv00AK8QJDSm0jrbYOs5rHkZmxaIRKJTc1HVXw4bKWk9DZMaVH4p9MpXnlgJ2/e0wwCJp2czdnfqMSlGBh3vo0RG0X+WMqAePqDktbxH4eBXK+Bkg3DEf8c6/ZycnLo6uoiGAxaSuow5WESiQR9fX2cfPLJGW/yxo0baWtro6ysbFQKqsvlIhJtBqC9vd0qSTWKOSaVShEOh1myZEmm9NW2bdvIysoiGAxmcjEPN88eLO/jtGnT8Hq9mXu/P3pE27AhTAPENgPXNeL1CzI5b8OldPQxlKhLURSKi4sJh8P4fL6DhjEXFRXh8/nweDyZUib7e50DgcCwhhEhRCaU2O/343K5iEajmWMHQj6Hg5SSjo4OAoEAXq+XZDI5xNM9cP6Bf2dnZ2Oz2UZVekwiWbn3GfyOINfN/SoJPUZNxwZMadKX7CXfWzKonNHxRDSRpidqEWz5bHYae3vJzR251NsAsrOzh9RglVJSs+F2anc+jsO1z0ug6DC2BJpqAT0ORhwRt1y1rv469A07HyGeEtjsOWg2DRDsrvknDmcQXTfYvm0TDXU78flMTNPA4cymrfENekM7CeaOzms8HDRNo7W1ldbWVqqqqmhpacHtdhMMBkkfjCPLpoBTgSo33FQBMRPcCvxgL6yNwBgHfKYEvrUb0pJwHH7/KMRHXR1l5LXYlNDQBWX/bo4YCXa7i8KiiaiKhmnqvPP2wyxd9lUWLLic3/zmIrq6Grjq6v+Hrqf561+vZ8rkU/F4sqG7icK2LUhTp2rpBeRUTuCNP/0aaZqc6g8xacJ7fXGHhtvtJhwOk++1oWEQT+q4HFomirCuo5eTyv10d3UdE1b8w8WAcnvNjBz+3q/cPlbTw/WzcvnNm2386LQSdnXFOXN81rvToX6FNvdTNw8q99N5+/8g0ykUb4DcG2/at79p0vHn7x5xbdNDQWhOdO80GrUpVB9nT3rG8DFcO4ZBon4P+aecS9sT9+OdvXjYNVSmkuihThz5w3t9P8j4j1FsP+gwJDhUMSyDXZZTJWlI3FaFjYPClHFae+4g13dx5rdYahsd4X9SnG3VFNSNblp7/ko4/iZFWZ+iLOdb7Gn/GpGuFGse7OSsr4wlWObiH/+1lYVXl+AqciLbo8jwKAk7phQgpn/o3f13xUDe58C/j3fkgqIoGSF8JCWqo6OD3NzcQUpceXk5u3fvHjULrdfrYfr06SjAunXr6OzszIQPHgydnZ34/f4MScz27duJRCKkUikikQher0VG9fbbh7+YDtTPzB5XgM1mG1KyRTd0hnvphRAZ4epQ1z7g3UsPowmMlOqhKAqBQOCg5x4IVXc6nRiGkQlb398jOpJXS0qZqf1qs9nQdR2HwzGqY3t6eohGo+i6jqZpBIPBIQaBAz2aQoiMkn6w4VzgLWFG8UJe3v0Eb9atYO6Yk9nbvZ0iXxl21UmBt5h1Ta9navgeT0ws8OIJqijC8mJ7VFd//w9d1seU0iqvcQB0PUEgeyJLlt6GoljC6IMPwnMr4He/B7X2CYzul7CXjht0nFBdPL/Rx4Sq6VSMrRi0rbGxla99TXLyKWP40jXWb51t63ljxZcxzSNnaNY0jc7Ozkyoem9vL319fZSWltHe3k4weIh3VwBnZsPLPfDnZrixGM7KhnURSyBVyBhgDRMauyF6jGzp5bmwbNaxOde7BaEozJx5Ptu3vwYI9HSSzs46soOl2O1ufN5c2tt2AYL6+nV0ddYxe85HEEL0Vy0wyR47jjlX3kD79i3vfW2cw4Tf78ftdhFqbeALp4zhFyvqKMrNwmnXaA9FyHNJLjuhgkcf+DsLFy4a1ZozHIxdNaSXP2R9yZxD7rtfQmSUP1dcZ8rURTD9tP5NgnH7KbefmJ3L2pYYC8u874qXdigEQlUHl/sZuCYhQFH3EaEK89BFw48CsbKz2B3JobZmB9UzZh+3dgAUhxNMg9jOLTjLKvZdl5REd25BUQSRmg2Et64l9/wrhz1HsqUBe04+ivPdN5K83/GhYnuMISXD1gOUkkxNu8G/y6MwQO07n0NVSOiSjqhOvmcfG6OUkndaYowJOAgfIwVDotMZfphIch1OWznZ3nMRqLiDNvyFDna+HsJfECMe1jFSJjhU1K8vQdUOQ1l9H1LM18YUHmxyWOuHNK2PogESaeiZ/YSiglBYlJ1mSY4+0ulGBZn5bzCi9XZizZbnSEqJVRZ23zM3pYGiqIj+Op0DZVoURUURCprHJDg1MWSdEBwbEpJ3m8jkUO0VFhYOynEDyM3Nxev1YpAmqoc5UJJKKOAMQlwIdOnHkIKI3otTdTNt2rRRK+x5eXnk5eVl+pmXl0ckEiEWi5GTk0N5efkR59mbpkldfR3ji6roDoXo6hrMfN4U3Y0cod7rqJ6R3EfQtGXLliHzl00fxj0+yvNLKampqSEeHz6vXgjB5MmTh00nMU2TrVu3kkoN376iKEyZMmVYz4jD4SAcDuPxeLDZbDQ1NdHWNpiUJDc3l4qKwQrYoZR0KcGuObl81mc5fcJHyHHn88ruJ3mn8TW+fNJPmJQ3A78ryF9X/x8AvYluOqOtBF15qMqxTxycVOThhtPHZYQmKSV7s4O0trZQWTlu2GMspVfS2dFBh72DiQfkHgMIoWKze1CUfvFBQFoHTbOIoISiYtMO0PBUO0I4UFU3NvvgKA5Vc5NKS6T0Yus/TNNcHGnYzoCxo7Ozk9raWqZMmUI8HqexsZFZs2bR0tJCOj1KDTSUhjk+S8Gd4IK1ffvKle3XvSw3/OZ6YOjtOmKoynGV4487NJuD7Owy+vo60PUU8XgveXkVmKbOq6/czrx5l+L1WgZJVbPh8PmZd+1nCNXvxTSMfgXtPb6I4ZBIQGLonKUCZy9axL/uv5drr72eP5xTyAvbOgnh4PwFeSwZF2DlKytQFIVJkyYdcfPGjq0kfvFDtLMuwH7eR0EIjE3rSN5+K+r0Odg/ejVmazOpe/6Mp7uT6u/8FNhXPWN/5fY3q9o4cYyPi6cEj5/IFU3CmlrL+tMP+y4TxV6Po94OL22H/cij1JZjW097f5i6QbSth/1texGZxtRN2po62bGr3SIxbLTWUdVpx5k93PojEULuV4Lr8Aaq0GwUXXQtHSseo+vFfxHZtgHV40NoGnq4B8VmJ7Z3B64JU1EODMfGmsv7Nq3BXz3nw6ohw+C4K7Y9uk5zOoU0DXrdRbhND0oiCcrgwdugaTgUhQpdJ/hvmnuiKAqRvj6ef+6ZIdt6QiFefumFoQKsBMM0DhmaFjaSbE92ktB0+hSDBrfJztZdrHmsCYCsrCD5JdO4ddseLpkSpMTuIai4eKc5xkt7+/jZ0mxeOBrm9v0WGa/zBMpzv08ouoKA+yRaev6EREezKZzxhXJe+1sj7TtDONwKDk+/wKYIxPEu9n3Q7oujngC6UoLnOmykultpuf9mki27yDntGrRgAa0P/NTKOzMNfNNPoejKH5DvUI9ase0jzjcdf6JHRMGQyJiBcKmcET6HJXtOJZGK8c9X/0BJbiWnzryYvngPdz7zE3Y0rOe02R/l/IXX89Rb9/DM6nvRDZ3p4xbxmfNvoicLHvHVYWCiuJwgFLyKwjeyc/CJYy9kv5tz73Dv0nAhw4qi4Ha7qY2t4fGOH2GkTTpr42gOhWCJA9MvmPaFNHduilPj+BGqL5s7m77HwuBVzAtcNur+2DSbFWKftMZCYVYuFOskEknKi8oQKQOJgaaDExBJkAN8GoZhbTcl4gDJQxEKukzxr5Y/8vKLDwzroYynoxiYwJG9e9I02fXC04R31SCwhLdB54/0YaTTJJshsnXwNtUFzrEjP3shBFOnTj2ifimKwvTp04/oWJfLxfTp0zMlRcrKyigrKzuicw0glo6wqu4FGnr28O2nPs7Y4ER64t3s6dqGbqb54bOfotBXRn1oF22RRgB+89p3satOPr3wu5wz+fKjav9ASBS62tbz8tM3DvrdrvdQ885DNO8cSQOTRHrr2NvsJl1wZN5SPdSOsA+OyRV2L9I8/nwXiqJgGAYbNmygubmZCRMmEIvF2Lt3LzNmzOhn4h6FENqRgq40PNQOIR3KHbAiZH0AWlPwzw7QJQgTYY+jEWXoG3IUOH7y/T4oThDHWt6yTLGKojFj5rk888wv2br1BXp726ioPIHm5m00Nm7moov/N7Mm+wqLqLz8eopnzCHW3YXd42HOVZ/gnX8MLbXynmPN6/D8csjOAX+W9VuoG6J9jCks5lO5XuzLHyCro43x0qR+8ZnsaG/kz8+uo7CwkCuuuPLo86slmPV70VevxPGpr2Ls2YkoKML10z+gv/Ey6qz5aPV7SP/r/mEPH1Buf3xaKV67gqocx8iqzgjctBzyvHD6FFAVPJ4Z8OA2/Kedgajvf6eaQvD8Vpy5RyczHQzh+k7uWfJ9hCrIm1qGUBT6zBTRrwRIrQljW2mQjiT4+4+/jZEyEFOzUC4bWs88HA4jhGDt2neQUlps5ofRDwE4CssovfoLIE26X3uOzpefwFm2r61EUy3+6fOHZ02OR0k07KZw2UeP4C785+O4a5BvRPq4qakBIxwmXFeC0hrCN3sXituF3t1NZMNGbHl5uKomIVQVLRrh/EDWqM8vpSQej2deSk3TsNsPXd7mWEMIaA072ZR/MSIyzA42IDbM7/0HbznA03Ig1kbbuK52OdHKHvbEulkvDbQZJaAkMUMRjNp30ORaRHEO9zcJpsYqKe0dQ67bRkWZyr179mKf2DeiYhtNbiKtW14LUybY2/Fd4qndme2R+FrqjZtRhJO++Cp2dnwfMzmG7bsfozf2KlJC2Gmw9cVO7C6FYJkTT44NT46lUEjkQULgjl7pPBTsdnvGM5ToVkhH+wX94ZT9/X4TgKtARx3Qi6Sk7eFfkOqowz/zDMIbXqToiu9TdOUPkKZOyz3/g+oNDrJAAhAxEMnRLxwyoIIm0DFYp+yiPdZF/AfbSb/ShTY7wJSPzkYiefjV27jzmVu44rQvc+rMi3j0tT+xq2kTZ8+/hr8//zMqCiczt+oMvK4sbnvsu5TmVqIqGr0Nu3n459eRSsXJOuVkij51I0GnE6O/i7J+L9RsPPjNyXwHps1BFA1fHmXQsz0GBoZDQuzXr1HAxCCa6OOZX+yh5qUuEHDi9aVMWBzkH1/aipGW+K8KMXZxgKQZwZD7eQmtUIzBJxz4bcC72dCL8cvXLCFYFWBXyYtbSoOpboWAExI6J3WkmWkTeH/vwrAJSOgQTpCFhG+dAuXBQc3MKVnC2VOuoDfezUjwO7Mp9S/g+ZbpGa+iJdxDayv9eYZW/8N9kNYFDQ0ShwZ96VK03EnUrnqb+rfexuEAPURG4FY9gAK2RAmh2yew61FQ3ZBosE7pngSTbxvK5aXrYHE1Hc04ONpjHRgGWA7fwz+XfkAEdjTVR11oB0snfZTpRfMGbTNME2WYca+bOve8cys17RuOqWIrEawpOoezQiuxH5APnF+QRSQSYU9tAxMmTEA5gJTENE06w0HGTDj3iJR9e+kszHjPUGuG6jymvAmGAevWadTWDn73NE2jvr4ew8jCZsvj+ed7kLKdCRNmsnq1VQowFPISjx+CkGp9BNpTMNcPnWnrAzDTiwRMw8DQ49iCvQitA675b9ilvC8jjQ6KrLMgcNqh9wO0iADfUKKaRBK69xNfTlpyA/b+3OoFC67A78+nq6ueZWd/nYKCMUR6G7ni4u9QWJDfv0xKiIfZ/cZzNK9fTcHkaoqmzqTurZXDhsO/5zB0SCVh8nSYOAUKiuHtN6FmE+LSj+MKdUFvCP51P8RjvPbKS+SdfAZXXHElxcXFx6iMocTcthE5Yw4irwAZj6FOmIxSWII2ZyHGzm3oa9446BmEEASc7yLFtKpaYQgLKxHRFGxosL5LCbPLYUI+vFiDsNkRikq6rYGuv/4wc7hEYvR0HqSBQ0OaJslwjIJZFcz72gUExuYTVQx+2/4ElVdNY9GNk5FSsuEvK1j/5+dB0xEyOfREPitHvqt/m9DT7GhvAhEcuu8I2BdyreKftZD2FY+ClAhFQUoTM5nAPW7y0GuQkp63XsZXNR3FNQI7/wccx12xNaUknUiw+3s/JN3ZgZlM4ps9m+LPfJo9//1tzGQKvSdE2Te+TuDExZiHaTVKpVKsXLkykyOVTCaZPn36u06Fv3QmtIQEezuOjMHR5S/grElQEBh+u0SS1nXM7hSyPIZZ2IvurgMBMm0gp6bQbQ0Ihw0ErDZWshYVV3/eREI30YSJFxf2Ycqh9MZew5QpTPXT7OyChW4Hm1ZH6YtY5TwUIZk6ZxMe2xlMqLqVJ7r+lw3bXmDjUx1I02K5GHOCj9kXuln7WDuKAnMuLkSzC3SZ5MmOn6CJoV4zTdg5MXgDhY4jD805FFpbobbWTiSSsoT7Wgdmh8L6XSvZsPt18rNKOXnGhaiqxqsbHqe1u44FU5YysWym5SWb1Id0GTSkVcxUkuj2t0h1NpJqqyN32Y3Yc0ux55cT27UWaaTJPvVKhKLQ1QU1MWthdv8rgn1twjLoq/3eb10ODmvrX8OlDSKfCmIUaIQ1iT4FUk+2kX69G+cXKtA39GL2pBEIzlt4LV3hVhShYJgGm/auYuncKzl7/tW8s+Mltta9zczxS3hj81OEIu00de7FMHWMSATP9On4xxTTeufd5F5yMUZhCbt2SbzSJOvp5yl84Bbsl12H8Fihg2Z7K6knHkJbfBrqhMkY2zahv/wsMpWk9St/JnzSUOvhQIRCImEtBGm9m764xQx8PAzEQhFEkk4k89ClSmIUclHSUOhqhK0vR7nsV7PorI3x5j3NePP95I7P4ZxvVfJOaB/xWWcn7GgHkBRufRp/+3aw2xmQ3P3xmGWRH4ir7FGgyQN2G+LsiYjJ+Zi/fA0A5ZpZiJnFyL4knr+sxjPFi3rtbIilkXUhzD+vRtVNSA+9EL8rm55x51IT6UAm0gwMJuG0IVQVmbaYXA3DRxIHDzU0UFlShFuxYZiwciX09UmSySh79qyhzT6JlKOIO+54gx01L4KUTBp/GZOWLMLrE5x5Iuz8AqTaQfXC+G9BfC80/E7BO85NxTch2Qq7/wcwDyhdiqXr2O2wew/U1Q+5nHcFETXOumANphjd4CtM5DCpr3zI77oORYVD959WNI9lky7DNM1M7mBNTQ1+v58xY8YMCuU2MXh8y9+P+FpGggDqs6p5MGcGedrQuT6VSlHvqae8vHyI58gwDGrVWkpKSmnQdQ6Xs8eWMxZbzvXD96vxX6RSSRKJweU9rHDy0YsiRUUSt9vkr3+1hHJVVfttSda9FWJfCLmUY1AUwZNPDgxGBchH01TGjz9IJIkEwwa7Loij5+4zUiqKQkFBAY2NjWBEmHD3LlwdFTD1MtDeh0rYwdD7MrT+AboehrxrrBALIwLtd4F7BgROtPaLboDuJ3DapiGKlg45TTQC3SEYWw5er2Ba9WS6d/QQGGui2J3MnnUuugG7dkH1VEjXrERd8XcqZvRQOns+ib4wGx++h9YdWwFJsi9MOpGgY+c2kJL61a8T6z644f9ACKEwdtFJBIpHRwx42DBNeOkZCHXBWefDurcsBdcwoLsTdm6zlF8shvH5Zy099v0QAv255cQlOP/rO6Tuux1Mk+Tf/4Tt3EtwXPc5Ej/5NropMYZZP4aDMZpohiNFbSes3AEXzIS3N0FDN9z5OngcMGsMPLgGUjr2ympw+8j//M+GGDaEomImYkcdot64soZnP/tnPvLQ16h5/C3klDD3u3bxcGQXQhXIiyTpM+diCjDU0TUm501Bs9lwK4evA2heP97xU4k31WLPLSDV1YajuBzF6cLYP+zdNInUrCe2fQPln/zGh2HII+Bdifk1U2kcJcWUfeOr9L21ms7HHie6eTPJ+gayTjsVW14u7vH76PeHy0MdCVJKfD4fU6ZY5RX6+vpob2+np6cnU/zc4XAc1wEgBJw6FZYMNa4cFhRhGbBGRMrEuEfH/pFJ6HVtJF7fivPMWcT/uRI114/R3ovzjFnYZ49jaaCC0/37CWQq1PckCTUHyJucPWzEVEJ3c/uW65hXOobWlItFi/pIdrXQ2dkBIo3T/jVamzspGNtGW7qZE+acwuIT9suX6r/Fi6YN/j4SpDSpT6ynJvrycVFsHQ7IyoK//x3uvVdBSh8AF88Gn7qeH919PfOqTuel9Y/Q1LkHp93NM6vvYVLZbJ5cdRe//vyTFGZXctvvfLT0QnoMmGf3YcTCZJ98Oe4JJ9B013fxz1mGo7CCzmf/Staii9ACFnvsSy85WPVGP/ulEUCY+92TAUV2OIdoEuStAgTofoW+PwiMdb2Yu6PEb9mJOsOP8GmIPkHAk4vPldV/PyXJVBybakcg0FQbiVQUw9Q5Z/41FATL+NVDX+GiEz+FlJLOxx9HFxLXuEq0QIBoRHDL//kREY1l3S4+qWngctMw1sftF7hIpL0Y552COm8Rwu5AJrPQX+jDDHWy1buZ1o4Ew0EIcLunkmVm0WQ+TVP4IwdsVw5JaOM2dZyjIL0B6DFKEHI19zct5qn2Q++fltPoSd5F0XeSbHI40StNAp9NsafQgecTsLJXIaZnk+/cAsATy+G3T1vH/nd5C6fNA04/x/LS22zYa3dbmk95pXXxLUl4fTUU+RBzS/eFFI/LRkzOx/j5q4jF5SjnTEI29yHDSeT6FuSGZiuEeQQvkAQ2xTp49Z+PEf3HyxZ/SCKF65y5OOZNpO8PT2DGU/g/uowS+zz2rC3lC+v3ncs0B5zLLkxtMQKVEtXghed/h56MUlAwnpQJ2L0oDgWHx1owTAWKLwF/FSR3gCpBsUGyud9YMcJ0rSiwaCG0j+KZHC/sNqPcnHiLRHsXseVvQdrAdf581OJsMEwSL25ALcjCNr0CIQTLtCqutA9VbAEKC4dXjHbu3ElLSwu5ubkZUrNEIkEoFGLXrl3ouk48HmfewrnH5qKkBDNiKSVAlpR83G+wIRaG4bi9VMiu8AOhoeGuAmaO9QNhCoXgYq8LUi3WNm1kml7ThFCIgzINq2o+//zni9hsrw36PZWSKMrFIxw1FJMnw003dbFzZy2mKfsNBgZbtmwhKytIMJiFaUoikQgOh4Pi4iJ27dqdkSPcbjdVVVWUlNgOmiJhGAZ2m4eCkn0lCNPpNM3NzSiKQiKRtvLX7aVQfrPFpNyPgbbeTcHzsNus/RZEVlshFaobfCeCvQi6HrWUXNUPuZdB5wPQ/eRBTyUETJgAFpeeYOuODrT2HgAqzijFUG3U1YGR6GPHMw8hzDg1Tz3ArhX/wjR0TD2NO2gZD/vaWuhb8RTuLOt7y6b1NG9ax/BJJsMjEQnTvn0LZ373J6M84ggwMIFGo9b8v2kdNNRCZzucdra1Bmx855ikQR0IkZuP/apPkfrHXzG2rAdAJuKYne3oK1egjpuEUl4JQuH1hgjr13Qc/IQDl8TwBKTHDK1huPsNuGwuvLELNjbCgkqIJGGzlVaXqquh7861I55CmgaOcUeWhrLvJBYjc8/uNuZcdQrX/d/duCZPAw1sbgctq3dR89AbFMyqYOanzxr1abM1Jwu8h89SLBSFokuup+2pB4jX7kCmUshknJZ7fz9kX3t2HmXXfHHY3NsPYeHwFdsDSBNGA9XnpewbXyPV1kbHI4+S99FLSHd2ke4JoYe66X39Dez5+WSfew6vvvoKLc0tg443TXPUpXtaWlqseHchqKmpwefzMW/ePNzD1OQ7lhACbMc5qkM47biXnY7ZFiX2v0/jWFCFUp9L6oEO1OwERkcPzlwH6thSZjlmc23WYMFJz5I80tTF1rYEs4qH5jsJIXCoVr5FwoT76+DaqnKSyQSGGUdk8oMlilCYanyUbW82Y7fZWbBgAQX5Q2sQD4eBWpUun527mz/F8UomysqCW27ZX5C2Bq65F3Zv0DBNA8M0SKZi2DQbJbmVfO1jt5KfVcKXfnc2sUQfmib40pcAN2xLwa/b7diyi1C9QUuBNXRkOkGisYb47nUUXfadzCJ2+umCCy7ob/of7fBW2HIYXJgLlS64qxWuK4TnuqEuAV8shbtboSUFXyqDYge9muBTPugN62gn5+D+6WSiN24k/Uw7HDC3q6rGhJLpbNjzOlMr5rG3ZSsTS2fys/u/wFWnfwVN1VAVFVXVEDaNok/cgFKQS9Pv/0B8924Kq2fyve8LfFLgfxLkHztI/uZm7vzmJO6SE6lsiKHkCxRlD0gVFB2zUiD1LJTSbgoCO4d9Dh30UHfai/xaB5u2BLM5gSh0IPoLwMuoiYzqKPn977gEszWJCNoQTmvMfdk8mevMecOe/0BIqaJk2dkZGV1OX286xA7nKuI2nd6WJMnuNPSkKZ2US8eeGA0b+phxbi7jcl8FJGedBWNPso6teBOo2wP33QGqBhdeZgk3NZst92RhCcw619q5LoR5x9uWRxYQY7KQbRFo6EFudSGumAE9cUjoiAIPymfmY/y/16G+56D9d540DXv1WMxogt4f34c2voi+Pz6Ffd4ktOIceu94HMf/TSXfN57/G3MaPsWOYcJbb0nefPNZXnvtb6iqjSlTTmPJoov5S6iJnp4WYrEQFRVzBxsWBfhPgJyzoW892LKtT3QbdL8EwZNH7qcQ1jv5LgfTDIIeB7FZp/eWB0FVEA4bvT++j+AvPknssVX03fYk3uvOwDbd8voF/DBx5LK1wyKdTjNhwgT8fj+appFOpwkEAiiKwuTJlvVz69atg0m9el+ByJpRt+GKxlDjjv76hhK6l0NsM2At6lf1f44amcg/AQWfZLjF3+OB3l74whcOlUu/sP8zGFJaCvFoK4MJIaiuzqO6el/ZIikl5eUqDQ0NJJNtKIpCWZlFAGaz2Zg+fWipudHoGi63i6ysLKSUpFIpmpubyc7OJh6P43YErVrH/XxS8ViM3t5e7HY7fr+fnp6eDGnckWCANby7uxtd1/H7/Xg8niFK0gA7eDQaRVEUTNPE4/GMPuQ11Qhtf7OU2Mg7oHdD6CmwFVk5uH1vMZo12pSS3oSB32F50Atn59Kzt4/Qrl78kywDjzRN9GSSyedfSpMzQDqVYvKkSVau/UEeyCsvv8y06dPJzh5FyUApWXHL90gnRsr9OgawO8AfgHVroKsTLr8OXn4Wlj8IkT5rW8V42LSWKVOOvFzVsDANZDqNOmcBnmUXgs1O+plHST/+INrcxXjuWg5SEv/R18E0OMUd5ayc0Sm2AGzvYLRZrkpBMSI3/9CKu6bAGVNgQz08sxnOnmYxrrlscM50+OfblhEXcEyYgeOzF46+v4cJoQiyJxYTbuhk+TW3cvmKH7Bs6UkE0wU8cvHPyV04kfO+dRH3vvA0YzH4SH9N8uMN1eOj+NLR1zb+0Fs7Mkav2A7cwyMMAUh3dlJ/8y1knXoqOeeeQ9cTT+IaN57yH3yflj/9hd6Vr5N9ztmcfPLJXBAYGqc+2oc4wDrqdrtpaWnB7/ezatUqFi9ebNW47Idpmui6nqkrqWnaETOTgrUIRUkQY3iv1WiQhRf7gQlpB7bTFyf884exVZXh/tgSIn9bgX1WJVk/vJrYQ68Rf34trvOG9wRoiuCj1SNb3VUzxVdme1heb7B4jI+0IWlJSbJ8PlJJSB1gyWtpaUFVVMrLy3nooYf43Oc+R19fH3a7HZfLRSKRIJFI4Pf7MQyDSCSC3++ntraWF154gSuvGT0Bz5FACCgrsz77Y2+fZKueQBEK3eE2DENHN3ROnXUxyXScn9//BeZVnU5F0WSLcb4E+jyQ6AMRcpD/ka/Qcu8P6X7pXnLOvB5HyUS6nr+TwPzzseWUZNrJyYfZk/rX62cSIK2wblwumOmEtBsCcTjbDnsMWKjAwzEgDpNNGA9dEmy6QJ3oxdvs4ARzCcnyEkrd+8Lt/J5shFAQCM5fdD23/OMzfPOPFzGuZBpLpp/Ppr1v8u2/XoYQgktP+Ty5gWKioTju8rHIvCwrvCcWw6bB9CrI1iC5EQYCYHSbQklzgvsuW4X/9Itwfv1rGFs2oFbPJP7bb5B++lHcv7kR+4XD5wneKh/mFtu9JDAJ391K/Je78T04B3WqD7M5QezbNZAy8fx9FqgC/fkOYt/aiuumKuwXWPGeqm0SQeWMUT/7cw+jfO6eWD331/2Bf/60hqwSJz1bIhRVeSjoyuelm2rIH+dGKcwhOcULkzwUl8CcLKy5cDtQn7Ks9OWVlqKxaR3Eo9aDX3QK7NnRb90XoO8nICZ0yxsrhBWentSRK3YjH90KSR3lmycjqguQ9b0H7b/idyN8LtLPr0PJz8I2vhijoxfX6TNR8gJE7nmRZM9u5EQPs8YZZGuWM6F9O7zRtZ5402ucdPInWbvy15T7NRafeC3BYAnhcBv/+tf/UjluPoFAP6mFAv65INPgnWLxziTqoeXe0d/v9xoymkCvbSPw3csRLjuhr/8Vs7sP56LJpLc3IrRjY6E0TZN4PI7L5cI0TdLpdKYm8BB0PwHNv8Byp14IqWaIrLK2abmW0tFxDwgVSv8bb6B/nkm3Q+NPwQgT8VWTdB0dCdZI8PauRwk9Tio9G93spTvyBKKfR2DOQrhBt3ItjxSaCosWQ1f/FBmO13KgsCGlxNDj6PrwLNrBLDtZgcqMIUYRAtPoIzl8RSrAYnHWbEOVxQMxEFKek5NDIpFAURTGjBmLomwAwDSsslsD5b9M0ySRSGSe+UBYummambJcVs67zISDDyioA/tLKWloaMDn8+H3+2lvbyc/Px+n04mqqpnItqampswaq2kaTqcTIQS6riOlRFEUFEXJlMjSNKtqwqAr1ruh6edQ8nUInged/4C+N6yw5LIfWIaXg0BKyVM7erAF0lw3y1LmTV2iR3WU3KHFfU0haOns4vzzz+eBBx5g/JSpaKqaUeCTySSmaZJKpfD7/fTGEwi7A2x2YrEYPp8PTdOIxWKk02n8fj+JRKJ/fx+Kpg0bBSSlpLu7m0AggK7rJJPJIaW+RoX8QvjYtRaRVNlYaGuFWfMgmAM7tkLlRHjxaQTg8/oOP+9mhPEoU0lSD94FvSFin78StXwcMpnArNsD6RSxr96AUlaBDHUiO9oAQepvvyN1122Hf42HhESdMRfvvU+D13fwXYWAJRPgo3MgnoJkGrY2w7QS696s25ebIpIGhI7AKCGAgMsKDToIVIeN0//fdfTubaevqRtXto8dj7xF4awKxp87h9ypZaQiccy0PnCZx45YayCiSUqrYPXRnGq4PolBfz6weFdCkfXubvZ+9/ukWlpwTZxI1/In8VRPoe2ee6m7+RZim7dQeMN1IARSUTCHWfiPJDoiK8siyojH4/T09FBQsM+jaJomDQ0N1qTZ2ztsyY2YTPCgfJkeLQyA03CMqOCbQrLcfINdNB5+RwEQfEycwo+UG1BHYKU1++L0/Ph+0ptrcZ19AvHH30LN8ZF4fi2R258l9c4ubJNKQFUwpEnCHNnuZkdFOWDyjMViaOFarp04G79dIdetUei1MbZ8GqaZYFPjUK+3YRgkk0mCwSAvvfQS9fX19PX1cckll/Dwww+Tl5fH4sWLeeaZZ3A6nTidTnw+Hxs3bmRJwyI4/kSZw2LtjleoLK7mlhsf4oW1D/Hwq7dx6cmf4/anfowQgs995Kdoqp20hJ9uhka7NQbtqiBv7lKypy5EppOo/hyEolC89DqAjBfSlPBcC1wxFvKcWOPGp4JbgXvboT0NH82D3zbBx/LhjCCkTIhYUlgnvTxmvkgPEWIigf2KEj4tr+X81y5HP1kHIUhhkRidfdLHAUhraYpLxvGzLz5GLBEh4MnBrjn51sf/Qk+kA011EPBkI4XCmKwKxjyzg9fqXsK/eBGeqVMxgLhpMGhasNlRKiYg0mG0eAr3SWdj/PM+0r/6X9Tv/gz3kmXElz+C3VRGNMqosn88xwz09b2gS2T/2DP2xpBtSfCq1g02JPo7PciUHPKOGTI9qhqcAL16K7Xxt0dVL7QrXYfmUJh3eTGbnuqg4oQA8y4roqM2zpgZPqSE3at60BwKhZM8dKcbMGQadf/7pCgwbwlseNtSagFy82FMJay4D2Qpg+PQQdaGUC6ailg4BjG/DLm3G+Vj05FdUdjVhSjwYq7oYzTWRJlIEXvsTTwfW4Jw9nu+hchE2IwkuGuandLSaZx77rcIhRrZvv1VqqpOYfz4BcRjvSx//MfEYqF9B5jQ9GdovgMKPgaaH1ofYNgSKEiQqX0cWu8pxD4SK+F341g4mfDP/2mtOck0qApqaS5qQdYxa1LXdVpbW9E0LaNUBINB/MOU0Ml0svAzUH4TNP3SUmy1bJhwF/jmQs+zkGq1ch6FE/wnWp9+xutmcwttxs7DCNgcPSbKNM5UK73xBHrKxramKxH75SmPqT76Nlqj1gcg2etCyjIiiXXkMAMAPR3hzRe+Tqir5ugb64fHW0zZuLMzhkGw+Cz8TVlkk0t74/OENQeJRJz6uiaikZMpKh7LmDFjUNmnYAtFYLfb6evrIy8vD8MwCIctuUHXdcrKymhrayORSJCVlUU0Gs14ZAOBAIZhEI/HM/va7XbS6TRCCHJycjKKbk9PD4ZhUFpaSnt7Ow6Hg0gkkvHSglU3Oz8/nz179uD1eonH44wdO5bm5ubMPLCPGEyB4DmQ2AEd/7CMKp4ZgAndj0P73ZB9kZVUf5D3WAKtkTRfPzEHU0JOVZCumhA2l0ZwQoD0MMaFAS+4x+OhoaGBV155BSEEixYtYuvWrRnD+ECUg5SS1157jbq6OjweD7NmzWLFihUEg0FmzJjByy+/jN1up7r64IPxzTffJBKJ0N3dzcKFC5k1a9ahB8oADB3aW6GlEV54CsZNgrYWeOdNQMDsBVaUzotPwab11jErnoBVBzcMZODxwjmXwEgEqrqOuWcntnMvwX7VjcPv8y4h/eTDpJ97HJlMIEZSbKWE13daJX9+8SxMKbKMv9uaLeU1pcOvn4PEfjkMq3bD1X85/A6pCnzhNFg6/POXUtJV00QqHOPV793H5MtPxFOYxbOf/TPNq3cSbe2h7KQpJHtjPP/FO0hHkzSs3MaDZ//48PsyAvK8SU6u0Hnpq3fSdayKXu8Hu9/FyT+5iuyKI48U+U/A6BXbIzAu6FKyMR5D2O1knXwSRqR/1RLgrKig8qe30LdmDbnnnoN37gkA3NHRzkPDEAXkajZ+UFJKgW10gyEcDuP3+yksLKR9mKQuVVUpLS2lqamJ0tLSYenXI8T5ifl3OiKdpO5swKiNYT+/ALXaT+LXe5BhS3FUSpw4v1qJ8GhcJc5guhi+RuDB8LD5Km/IzeiYqAckwBpS8la0BTQVx7yJ2Cb2x/ALgevMWaiFQdK7WnBfshjniVZIz91dW3iyZ/cwLVnHXZE9mU/mzRii3EYifTTX11KQm8PsfA1FWBPCSI9/7969bNmyhcsuu4z77ruP0tJSQqEQra2t2Gw2PB4PPT09bN++nSlTptDQ0MAVV1xBS0sL4yeM543mw75VR4UBI9eE0hk8/Opt/Oju62ho38mUsXO54+mbeeLNO5lXdTq/e/RbXHn6VyktqkKXgq9MhrmZKCgBHGjldQz69loH3L4LkvsLA3N8cE0BPN4FJ2fBthjM8ELcgJo0xEzosCb4P5vL+Y35JAE8OLCTX5BPafUkamO13LHkDqtY+QEwMQkRIbvjLPzRyfjUlgP2SAF9eFIaV2wqZfbnv0Y6/+NWuR9Foc8weDwU4jP7hZSrVdVoC06CjifANNHXr8Fx9adRx1SgTj+BxJ9+OXprtF/DfXMVfVv63TJCoC3OxvHlSpJ/67fYagLnN8Zj1EQOMDtKXun+E7vDa4iG0vSX7sXhVXF4VKQJ6YSJ3W0J+XEzTNKIYFdGZzlRhUblvABV84socVajCAXK4LQT99tJQETvYHfsTaJGCL+63+JRWAJ5BfD0o5lrY85C5K4aZGeEzMVEUpjvNIEhoaEX8/GtiJMroDOKfHwbssCHsmwiVGZjPrsDNrQeMmZSSklqjRUGbp87CaEqqHkBEq9tRivLQ6Z01JLhIzWmVp/J66//nVt/cxGhUBOXfPTHPPPMr3h95d3oepKS0mkUFFgUQrGdoPdZ3lqZhu4XQbFb/waIbIZUG5m1Il4LW95b2SsDzQtjvwUUW0qIY/EUtDF56E1dpN7ZieI/9qkqdrud8vJy+vr6hg0hHQoJvS9A1+x9N9WIQMtvwf5ji43LjEDHvZZim30+tPwOjB4AbGoeM8Y8iqoGhpz2aHVdx55vIVJNZHvmEZWdzBr7T6te93FCd1sNb229ibSxTxZIJfvo6thMSfkpZOcdvSbd11vLrq33E+7ZzYSpV+PxFSOlSe3Ox/HvySJfuw6f30dt7VN0tq1HUR0UzbzAUmpVdVD+shCCsrIyQqEQdXV1FBcX4/V6KS0tZffu3ei6jq7rmKaZUWoLCgoQQtDU1EQikcDtdpNKpUgkEpnUqwO9MgOeX7CM86qq4vP5CAaDmZrOA95gm81GSUkJtbW1xGKxjEwUi8Us7+7ASQOnwJgfQbIOHGOh7a8w5ibIuwpsuRB+2Yog0A5epDfLqWJXFR7d1s24IjczZ1nhx3tDSZpCcdLG4Hesq6uLp59+mrFjx7Jx40b6+vpwOp1s374dXdc544wz8Pv93HXXXRQWFqLrOqFQCCklO3bsIJFIcOGFF1JaWsry5cvp7u4mOzubmm3bGCkpSgjB0qVLefTRR5k6dSozZsw4xCg5AJEIbN1gzfXJBGzdCEhr/gdobrA+SJhQdXjnTqcsw2hVNcyaf9BdlbIKbKcMJfJ6N2Fs3wzPjWLHTU1QEoRL5uybh+bvizgbGOEH+owOa8oyTPjHW1ae7giKLcCWe17F5nHiKcii4RWLM8PmdlB+SjWJUJSdj78NSLyFWXjPmX04PRgVBtL5hKKgHGZk0KHui5HS2bX8bUoWTGTel4ayl3+QcGQe21EulHHT5M1IHzPy85n42c9ak61m20eeUlQMC4fm3ByIXsNgRW8PuxKJUSu2A2EpI9ULE8KysFZUVGS+DwsJyd/Xkn6mHe3UXKKf34znrpmoU33IlIn+Uifp2hjOL1uheuMb8pjRUcAJJ5xALBZjz549VFdXH1Ko2Sz3skHuGnZbWhqs6K3F1ZMgWFCEu8LN4sWL8Pn6rWQTF43ijuzDa32NPNazk+tzp6Ec4B3WbBp79+6hs6ODeCKOEAKnwwkijbs0jFVpcx/mzZvHxIkTeeCBB8jOzmby5MnMmTOH8ePH4/P5eOGFF1BVleLiYubOnYumabhcLnp7e4lEhquLdHyRjkGkVXDCxFP52acfpbZ1GwFvDlPK51LbWkN1hbWgONwaRWNy0TygCyh0QuUhom32x/a+/b7EDItAqCYGQQ0mu2F1GJ7qAr8G5+dYoai/bYS4aSlQu7oYW1nII+pNOLDGfJtwY9oE/8j95rDvXyMdXGB8m3iihxKH4JdjxqAOM+70GNRvU7ixtIyvT7ZK9KSkyRdr9xI1DUjESb/wFADG3l3oLz8L/eVGU3f/EWPdapSSMpK334qxeZ11X59bju28SxEHyYUXQiAPCL0QQgwqsSqEQI4w3/fpHbz54jqe/fVepAnxcJoJi4Nc+IMJbHiynfXL27nqt1NwByzX3Hj3IpbmfmPE/uyD5In2m6lLvIPfVsBHCn6EJhzD7rk58gwvdf8eKxHYzDBfUlAE61dDxPLSoNnA5YbXViB7CkEYYE+Bw4Nc1wzF1mCSu7qQe0KWiz+Wtmrdeq3wADGnBDmriHA4TLBo6OBLSYOEtIxr+t5W3BcvRris++/9xFn0/elpZErHe+WpKLmDlZ3OTohGBSUl1fzXlx6loX4jhUWTKCiYQGXlPPbufRtNszNu3IL+UEgIr7F07PyPMKiEj/+A9d97DLx3xwq6rpOK6ERecdK3HmSxZaRLrd9N8tXNSNPEfdFihNua14RdA/vRBzL19fWhqiper5dkMonNZsPhcNDb25vxVA2LeA0k96OMlinoWwXmASku/sUWuU9oX810IWy4HFX0dBusXr0al8vFggULeOWVV1i2bNmR52RJCUoAKUKoSgBFxHA7pmCa8PrrrzNv3jxcLteRnXsExGwjp/TkF8+ntOIcenp60HUdr9c7xHAgpcwYFAZCv6WUtLe3k5eXh6IotDWtYtfWB5BSEgnX4XBmUVq5lIY9z5KdOxUpDZCSOSf+D68+8ylSyT48Hm+mbJwwo7hMiQJIUxKJRXC5XHR3d2eUzsz1xGIIIfB6vaRSKUzTzHhaB1KkvF4vgUAgwwdi6y/V1NnZicvlor29nYKCAtra2ohEIkQiEbxeL4qikEwOjQMfaH8gvNnhcJCVlUUgENjXN6FB54OWUqsGoe12a/zVfx88s8Hohb7V4BqPyViUEQQ/AbRF0ty3sZPyLAe/X9XKFxYUEnRqPLatmxMK/ZlScgMoLy/n6quv5rbbbiM7O5vy8nKqqqooKCjgqaeeYvv27djtdvLy8hBCEA6H2bNnD6effjqtra1kZWWxefPmjFGgrKyMWbNmEQwG2fLXzSMa4zVN49JLL83cm8ODBCmRi04lPWs+EtBUFUVVM6HlijLSXToEQl3w65tGbSiWUtLY2Mj69evJzc1l/vz5o0qnk1Kyd+9e/H4/TqcTh8NBY2MjXq93UE54e3s7sViMwkIrHcjpHBpSPmrk+zAvmsUbq95k+vTpg6JWNm3cCJCpS75l82Z0XWfmzJmAFRW4adMmpk2bNnLeeFKHJzceshvSlORNLWP+76/i7bXvYLPZmDx5MuPGjRtxLKRSKbbX1FA9bdrR57Xu2Ql//Q3jvngy0d4IbrebJUuWHJRDKBqJ0tDQgG7ouF0uKscNdpzFY3FUTcUIJ7l9+lcHczd8QHH4K7g84O8o9j/BZqfv3vvw9U/cl19+eWbS3h+RSIRdu3ZlCqkPYGcizsvh4fPMBpiQt2zZgtPpzOSdDOQyHexFH+0g1U7MxnZOPsKpkvpnM8Jnw3FtGTKqk3q0FecXKqxQSmDHjh1sf+x1ioqK0DSNlStXUl1dnbGSejwekskkTqczk3+VSCRgFPp6oDHMr6ZfSDqdpmtDF5deuoxIxFpM1f78lIF6rS6XKxPa5PV6SafTJJNJvF4vX298iZrEgbUvBXanjsdzH8Xj84dp3SAU70PTiq1VTEJOoR+fmU+wwMP8k2bj9/vZvr0Gv/STVorYvncTFZNKmD//BPJKA9Ts3cjUKVPx5jiYNL2Cpo5apP3djVNMRSEZhqLpGhVLprM/A9MU5iPN+bRuhKwKGLMQ9kSg562jbLQ2AZuiMN4FzSmLHEoCk/u9iev6Ffxcu/UxJaQlKirZ+HEJB1JCCMtJkCMCwzrxojKRCadThSBL09CG2TGlWo/QragE+2eApGmi9u8qY1GMje9gW/YR1EWnICp2IHI7cX3vZ2gJE02z2ETNWfNRzrsU+cpzGOvesizYoyF5M2HQBCL3+wz3HUil2zBNgwmLg5RO85FOGDzw9RqqTskh3J7i7YdbiXanBx2jChsuJTDiez6Q92iz2VDE/lPhKFksmxussg5Ol/UXkG4PelpHs2mIFU9YlmTFhshOolxZaYWqDVt7TmL+7FUwJWJGUcb4Z+o6qU4bwjP0vr4SbqAm3k2W5iT7unP6Q4/7+z1/GoUzJ6MbBhG75OO506h252VKEXSHLPlp9iyBZhsLjN3vzCX9H6tEh90Op5wMLbtAC0DZ5/tr2L7LkFJimmYmX3CAbXRAoBz4N+wrMxWPpwk3xomvdlp1n7t3kMbEd8NSXGfMQtg01NLczP32XnayZVRAUOkIUOUcmZNgJBQUFNDR0UEymURVVVpaWnA6nYwbN45oNIphGOTn52OzH1lpOIQdCj4BHXeDER60yTQM7r//fpYsWYLD4cAwDBoaGohEIhnlOpm0Su74fD4Mw8AwDFKpFD6fL0NCJITA7XaTTqeJxWJ4DX0IkX5jYyMPPPAANpuNhQsXkkgkMAyjv/yORFVV0uk0Ukq8Xm9mu6IombzjSCSSqT2vKEpmPTsYBnJP3W43Xq+XtrY28vLy8Hg8GfIkIUSGRHIgDFxRlEzNe13XM2kKppmiueFVxow7Fz0dRU/HiCc7iLrC1Le8hG/mdEy7Sjptsm7ralTNCt1RSDBT9OJ0R5BmL70Ji+Qpq8CHtCXxBayXJNeTjbcG9M4UQknjdTiJJ+JIegFJQXY2hmEnFOpGaDaUiXaYoA3yAkciEQoLC3G73RQXF9Pb20tOTk5GMQmHw3g8HjRNQ1VVNE3LEC1lZ2fjcrkoKioiGo1mQpYBcIyBKU+N6oWOdXbjG66cAta0c/3sPOr0CLu7E3TFdGp7kkTdBrOLvcwt8tKy36F2u50FMxdgt9u5+OKL6evro6Ojg9bWVioqKnC5XJkc4QsuuIDm5maKioo46aSTCIfDLF26lOrqalatWkVdXR0LFizA6XTS3NxMaUnJsH3c19ejD9UP9/Xx25//nOzsbHRd57zzzssYH6ZPn56Zh0OhEM3NzRY51n7YtWsXHo+HoqKiI+5DKpXigQce4Nxzz83MdwPvttfrzfDIpFIpvF4vQojM++bz+bDb7Tz00EMsWLCA3Nxc7HY7iUQCh8OR+asoCi+++CIul4u5c+fidruRUpI+GP35COjs7OTBBx8kEomwdOnSzPvf2tqK3W7P8LC0tbUNilQYCMeXUhKPx0mlUrjd7kyOtWmaeO3OwzIm7Nq1C5/PR1lZGU8++SRnnHEGU6dOzdwfp9OZiZ5wuVxk96cDJBIJdF1HVdVMusBAOL2qqiSTycz9HojSGDAqWRdj1TXfuHEjE89clpkfU6kU8Xh80HnS6TROpxOb3UZWMIudO3dm3olIJJKZR5948gkqKyupGjP+4Bf9AcK7U+7HNMnJyeGGG27gL3/5C9u3b6exsZHCwkKqqqp4++23M0QBTz31FF/84hcxDINdu3ZZ+RK5IwsXdrudk046KSPYbN26lfr6+owFJB6PEwqFjpydUIB2Sg4ylCb26Y3YP1KEWuWxXu6Xuiw25FNyMpOloiicsXQpjz/+OOeffz4A9fX1PPHEEwghmDNnDhs2bOCSSy7hV7/6FV/60pd48sknMa82R+UFVxQFIQQ+n49HH32USCRCIpHg7LPPZt26dZx33nnceeednH/++Tz88MMUFhayaNEili9fjt1up7KyEjlMccIs9ylIxxwak9toDG1juAARQxYTLvomL3WUsqPvHHC+gFtJwS7Ai6WwTLCINPc0r7BkZaGzp+tuCJoQhFd4BFqt/fYCCb0Pu3iXacsFBCvBVywzhpCMkGwIOndY65KiWVwtI9lwBgRt2Pdcht+x/+/nSpAzvdZY7RekpWn9e9CRKQkbh/cYgsQ0TOuY41BGYH+oC5agXvs5Ql2/RAQMbNd+hq1vb6a6uhqXy0VDQwPpdJricC/mnh2HPJ8NDewKvhsq0ArsCEMBFJRxWWgfE9iwZcL7PBeNQa3yoRgaCIPWjnvI7ZyGFlDw5trY/kofmkNh4pIgdpfKJTdP4sFvjj73Ttd1Nm3aRE9PjyVcBI4k1yJteW2vvhFKxwKQTqd45eVXmDV7Njk5OZb2+H9vQk8rzFuE8AwvQMr+8gOHk/MRM9PYENwsqslThxkvTtgjI/zA2MzZWZUs8R1ILKSjKLWoyvDsOtbCORbTsKGqg6endDpNbW3tkNJsA9A0jbFjxw5rYU8mk9TV1Y1IyDEQwnugUVJKSW1tLaWlpdTW1jJmzJiMwNDa2pop/ba/l+FAbE90M82Vx1cq5iJGICuNmmm+1/gaH8uezI15hxmqCOTl5WXWm4FrdLlceDyeQZ6KlD4C25KZAvOAbUaUTJKjayLY8i0m5AMghEJeXh47duzgrLPOQtM09u7dy/Lly2lpaeGzn/0sL7zwAo2NjYwZY9E9NzQ0IISgtLSUwsJC1qxZQyqV4vzzz+f555/H6XSypKCBsUX7jQAJa9as4fLLL2ft2rXMnTuX3/3udwSDQWw2G52dnZx44ons2rWL5uZmLrroIh577DGKioqor6/nxhtvZMWKFcTjcfbu3cvZZ59Nc3Mz4XCYRCLBecumDbm2AehpHaFYxoEBxbW7u5tQKERpaSkdHR243e5MvmtraytARijv6ekhFoth2+9yTCPNtvV/YUL11Uyovpqde+7lje+vJx6Msr7jm/QW9OLJcdKs/gOEQiKsIxTYeg2YqefofCOFkZaomiB3rAvVrnBe3vcIiNlkxVzwvRrydQlTPVBp4N2QgtoEosAO8/rQ2lIUro1CWsLZgtA3Pf+fvfuOk6O+D///mtlerveqa+q9IQmQkAABEtim2diYmjgxOE5cfk7iuMTJN47tOA4xbnEvGDCYamMMGERRAdR7v5Ou9763t33m98feru5O13t5Px8ckvZ2Z2ZnZ2bn/SnvN61+BTCCLXwseXTADWADZzj4d3XFF+mJVmxdd3ORcyJyrEX+jImJuTTK69IRA6olnP14MGo/jZYK6LrC2ZMGrNY4kvwhrlEc2Kvs1PpCeIMa/mLw+UE3qLQnp9LkjCGlqJBSvw/SUrGnpTKnKNwT1QK02m0sWL6cjKQkrKpCYX4eAOu6pqxFXLPx0lyRDevCWfO71zQeL6FQiNzcXO655x6qq6t55plnuO+++4iPj8fn87F//36CwSBNTU0cOnSIT33qU9TU1NDU1MTKlSt59tlnSUhI4K677uL06dN4PB7WzytiOHdCBoOB2NhYLly4wObNm+no6OCJJ57AbDaTkZFBcnIyu3btwmazMXfuXJxOJ0eOHKGwsBCDwUBCQgJHjx5F13WysrKIj4/n2LFj3HfffTz++OOsXr2a1tZWjh07hqZpFBcXc91119Ha2kp7ezvrh7GtOnDo0CE+9KEPcfToUbZs2cLLL79MW1sbJSUlbNmyhZdeeomWlhYuXLjApk2berz+zTff5MYbb+QnP/kJ+fn5BAIBtm7dyvPPP09WVhYfuHEbw+pPVhTS08Lxh8Vi4b333qO5uZmzZ8/i8Xi4/fbbeeGFF0hISODqq69m9+7dbN68meeff564uDhKSkq4++67ee6550hLSyM2NpZNmzbx3HPPYTQaWbJkCe3t7Zw4cYKbbrqJpUsvXc9UVeWWD9yCMifcS9zc3MyTTz4ZTYC2fft2fvWrX1FYWEhjYyO33XYbBw4ciAb3r732GtXV1XR0dLBhwwaOHj1KXV0deSnZw9kDM9qEBLYQbq3ZuXMnPp8v+mUUaW06evQo119/PT6fL3pD8vzzz7Nx40aeeuopbv7kJ/tdrqIoPYZILFiwIDpUKCInJ2eAhB2D01sDdH7uJGquDduXisLDRr0avl+VY34gBxw9b97y8vIIhUK8/344q+X777+Py+XCbrdTXFyM1Wpl3759JCQk8P7775OYmIiqdgx6T6vrGkeOHKG+vp5PfOITPProoyxbtozKykqampqihe87OzujvRqpqamUlJRQU1NDTk4OJ0+eRC+8vOCu07qaQ6GdvFAZoG3fy7iOvYUpKYuk6+4FFJp2PIa/qQrbUo24tZkYDJ+hoC1AoLUeT2c7qamFXV9wOtXVp0lKzMFqi8Fk66TomrdRTX238BkVM/MdW4b/oYyB6upqDh06FE1qtWbNGiymoQ+pa2lp4dChQzidTpYtWzakklJen5dz586xbNkydF3n6LGjLFq0qEfG7oEOhOaWFl5/fR+KGm4kiSQWGSpN03C53IRbIgZ5nR5+j62tbZAMqqISHx9PbW0teXl51NTURBN7DCaZOH5t+BdibHY67z7N2er7Sah/lMTEDfgtfgKrAjgauwV9V3X92QBtoWfRvP9DqyPc6h30a+x7uoY1d6ZjtocziBotQ89oHgwGOXbsWDTRyMmTJwk5B0idOhibA2LC15f6ykpiMrOoamsnaU4eXWPVRr7sQaiKQmFKJlnGfgJmfzNK/Ym+X6uqJCUlYe5n1ISiKFRUGND62DWR1/YXnA7U0GMwGEhOTu73tZGssH0JhULU1dXR2NgY3UYI9160tbVRVFTUb7AdkWy0szU2r9/ft4V8WFRDOBfWMBuOyprPcaBi5+W/8BK+Y+8mqAXoDHSN1rDNhfitXc89D+j4HIvwBkqJsa0kUPNfGCxZ6OYUOnwnofQBHNZcfAENLdRCTFeeQEVVuOOOOzh8+DA///nPuffee0lLS+Ouu+7iRz/6UbT3T9d1zpw5Q0FBAVdffTWFhYX84Ac/4NSpU9hsNtxuNxcuXIhOHQn3/l16Ax5PJ++99x4LFizg5MmT0V6Wj3/847z44ovcfPPNOBwOTp48SUdHB+Xl5RgMBm677TZefPFFSktLaWxs5KGHHuKVV17B5XKxe/duli5dSmVlJS0t/Wd31qHHcM3IZ9R97qmmaYRCoeh3YiRZUlNTE42NjRQWFtJUF66bmZy+Cpstharyt2hrOU9y2kpcGfV0JOp4/AF2/eo8p95o5K9+uQx7fCcNJZ388T+KmbMqjuv/YQ5NDa288O/naKvx0dka5MGfLyVnWQyhjn3gbQSXEfQ4WB8HD2dBuQ/lpkT4djn8Yy64gpBmhhcb4YVG8Ffz7DmNX1WFpzfpQR/eijPYcheDwUCwtR7PxWNY0vMxpxegKgr/u+AQa2Mvz00yIG/p8J7fj9gYmD8PWtsgFAKrwcCiFAfoEGM2EmMOf2bZ2ZBWZOO1v/0szbqOUnIef21d+PqdEI/r8BE0b9cwb7udJxvryDxznDufexx1mBno2muryVy+ekzeX38URUFVVdLT0zGbzVRWVlJVVcXevXtJSkoiKysrOg3L6XTS2dlJeXk5LS0tpKenk5GRwYEDB6itrcVut7PjzTe5haHPLTUYDNx33328//77/OIXv2Dt2rWUlpYyd+5cTp48yfr161m1ahXLli3jd7/7HRs2bIgmHisrK4vet1x33XWcPXsWp9NJKBTi2LFjxMXFRUdVrly5ktjYWBITEzl06BAul4ubb74Zzh4c8r4KBgLs3LmTnDm5lJSUcPbsWWpqanjooYfYsWMHfr+fyspKHnroId555x1CoRB79uyhrq6OjRs34vF40DSNrKws7r77bh555BEgfK5nZGT0OQJ0qCIjPN58800yMjJoaWmhqqoq2nAQExODx+Ph6NGjbN68mblz5/Ld736XYDDI/Pnz2b59Oz/84Q85fPgwjY2NpKSkcOLECVJTU7n++uv7TGbWvSvj1KlTLFu2jI0bN/KLX/yC+vp6MjMz+ehHP8pjjz1GbW1t9DoWCAQ4f/48Dz30EPX19bz22musWLGCRYsWYXdIXduICaljGxETE8N9993Hs88+S15eHiaTifz8fBobG3njjTe48cYbSUhIAKCuro6zZ8+SlZU1pMymEXa7fWxr1gZ0PF89i/+lOoyr4uh44Ai2r86DgAadIUw3pFx286MoCjfccAPf/va3iY2NZe7cuYRCIRYtWhRtQX766ae5//77+fnPf87DDz/MW5T3swGXqKqBG2+8kc7OTv7yl7+QmprKsmXLWL58OZmZmezYsYPi4mIaGhqwWq1s27aNF198kWXLlpGVlcWGDRuw2+38SC27bNmKoqDpVtounOTC//0zCZvuou29v9DZ3IqiqHScehfn0k1U/PizmJJziClaQyig88xTX8PrcfHwp55EUQzU1pzm0f+9k49//FGWL78ZCxZWxt42pBGqEy0yDHXdunW8/vrrNDY2kpUx9HIZCQkJOBwOFi9ePOQ5ZpHkIRGRRCJDFTlnTGYTnZ2dJCYmDuvmOxQKceFCCQaG1hNVXl5OTEYMfn8dHjxkZmZy4sSJaI+U0+lkKFU+TBhZQC4JSgwuWvD5OsgxJTMnK49Tp05RX9/Auk0L++zhq2mJ5aLXj9sOuk+n7FA7na1BFmweXlAPl4Jai8VCRkYG586dIzc3l0ajEYY/uqoHTdOoqamJ3uz7/X7MQ8wJMHIKBoN62X6LzO+M84RQ6vveR6oabqgIBjuiQUHv16v9pKM3GAwkJiaGy5y53QSDPTOwDzYFJDJctb9lDyQjI4NAIEBWVla0Qaiuro7U1FQsFkuP86svoVCQCxcuEAqFsFgsZGZmhucwdU3liM0aWj3u7qxGO+mxObxw4te8eOI3Q36doijkxOdD2t901Ym9pKXt15TUfoa81NuItV2Jpnuoav4uja6DKNSSl/L31Lc/SbCzhdVdI5J1TePihQukpaVFh6ja7fZoyZe6ujrq6upYs2YN+/bti46MipQ9sVqtpKWlkZKSQm5uLvn5+bz//vscOnSIzRsuJXw5dfo0a9asYfv27RQVFbF3715iYmIwmUyYzWacTicHDx4kIyMj2tAQKVMTmSLU2dnJxYsXKS4uZunSpaSlpUW/z5KS+5mDDJhMRnSDgcbGRux2e3QockNDAx0dHbjd7ug9gMFgiA7zC7/WhKqqtLa2RpdnMFhYtOphChZ+GIslgdNHf0rRqo9TZvo9HTVuKo+7CHi06Cj/imMuOpoChALh95WUY+Vjjyzk+a+ew2QxkD7PHg68y/8NfK1QWwD6L+DqeHCFoDkAu1oh3RxOIve1UlgXG8618KcmaHuTUL2KX/sSuq7TsusFqh77MvP/6x3QdS7+18fQggE0XycF//QE9vwlaGVfBeObQz7uuo6WcGPKICUGB2Mywdq+Kwxepj0EoQYT/kAAzeWi+Ktfwz5/Hmn3fpzq518g5Hbjr29A83Sy4Jc/R7daSV2wZNiBbdqiZczfessI3s3w6LpOS0tLtHQkhDtxbrjhhmgZoaSkJJqbmzlx4gTp6el0dHQQHx9Pamoqp06doqamhqSkJBakpUDfpeD7FAwGuXjxInl5eezfvx+TyURmZiZXXHEFFouF5uZmzGZztDRUTk4OiqLw4osvRnsQDQYD9fX10Skeq1ev5tlnn+Xhhx/G5QonCjEajdEh1i+99BIJCQkkJyfT/xl6ufLycvI+kMeH7/oIxcXF7Nu3D4/HQ0lJCefPn6eoqAifzxf9d0FBAatXryYUCvWYfxqZbhD5+7Zt23juueeYn1/IsMZk6joNDQ2cP3+eV199lW3bttHW1sbChQtZs2YNBQUFJCUlsWPHDo4fPw6E73XOnj2Loii0tbVFtyHyXRYfH092djZr1qwhLi6OEydORKd3dKdpGjveeJ15198Urodtt3PkyBFyc3OjUwWqqqooLS2lqampxyiLyLXz/Pnz1NTUkJ6ejt/vp76+ntykzOHsgRltQurYKopCVlYWq1evjg7frK6uxu/309jYiNvtxu/3Y7Vaqa2tpb29PVpYPTMzc1StMaNhwsgG0xKK/j4J7XYvRoMBDAqGolgUk4r+i3UocVZQwKP7OMR5AoVGzjnqaLFp5N+3gvr6evQVsZzdc5wjFRe5MudKLPMsxN6cQ01RJwkfyKM8t41aes95vVze3CJMibHk5mVT42phedI6jp8+TVZWFnMSYlh25RUcKTnLVTdeR5vmZ//p4yzdsJbVa9bAIRuHz59m7dq1+PX+e6cMthhQFLwVp/E3VxMbl4KiqARaavGWnex6jhPQ2bfv9xw5/BJLl4XLJfh8bp599iu4O5oxm23jOkx2rLS1tXHgwAHMZnN46OgwROZQ2GwT9159Xi+6rjNnzpxoS+NgIvPsIiMiQqEQqq7T2NREvD+238QFXq+XtrY2jDlGvF4vFY0VLCsKJ0K7cOEC6enpPRO2AAG/v0edxv6St3Xftvb2dmw2WzhJUkICoVAoWjYqMzOTntO6FDpbAmz4eCbWGGN0xWa7gXkbEzGa+w+oQqEQR44cQdM08vLyOHfuHKmpqeTl53GorudzI/OITCZT9Jo12Htxu934fD4sFgsOh4O6ujpysvtuKIn0KBmNxvB6Bll2f3Rdo66uDkXpOdfSarXidA5ezDeSUKd38hmz2dw1F2/w46uhoeGyUTJGo5HCXkkuIgKBANXV1QMORR4oi3BVVRXt7e3RG6/I+4jUMB/snFANBrKys0APfzcZjcZwA2rXMjqVntsVqS+qqmr0mOi9jhhLHN/c/htaOhsHXPdl26Kq5MQXdg1D77VM61pyU/4VXQ/Q4T2ErgeIsa0nxrYOt9uNpqmkxt2DwX4zqusRrEEfSttOmi6corq6mquWFDAnrph1C9zQ9iZXLvJQmFJOS24DntqX2bQ8Ab/vNG3t7dScCXLn9VdiMBrZs/svNLYbmZt6JWVH95Og+li9tOcwIEE6pwAAy99JREFUN5vNxtatW4mPj2fdunWcOHGCwsJCVFVl6dKlxMXFsXHjRnbv3k1+fj5FRUUkJiZiMBhYtmwZKSkp3HbbbZw4cQKz2RzNvXHo0KFoT1d/XG0XSU5Lpq7qFMFgAHdnJwayMOhQWnwCo9FAe0sNfp+PdsWJEnJz/vQJYmJjCQWDWB0O6mvaIBTOOB7wd3Du+G+wOdLodNfh97UTbClGSw2SkG3lln8p5HefPx1d/8pb0+hoCuDpqooQmRZiNKlc3N9K8butLLw2CfIfAfMCiCV8p5VuAosSzqFwdxq82xbOhO/TwsFukgnMSrj8TloGepmOr/o8NU99HQUVxWii/cCrhNxtxF99BwZHPMbEjPBxU/AoxLv63F8DsswJD0UepeHnYNKp+91TuI8fx7l8GaaUFPK//h/oWojyb3wLS24uxqQkYu0ONn76n/rMFTGZIt+Bjz/+OM3NzWzfvh1VVTGZTCxdupQnn3yS1NRUVq1aRUlJCZmZmXR0dFBdXU1iYiIpKSm8++67XHHFFTQ2NmK1WsnMzBxWn5GiKFRXV9Pa2sott9zC3Llz0TSNCxcusHLlSubMmRMd0XjVVVfhcrkoLy/njjvuwGQyER8fz5YtWzh9+nQ0kMvLy6OjoyNa3SI2NpbY2Fj27NlDKBQiOTmZFStWDClJVXeOkIHtaYtJKGljWSCOoMdBam4Bxx/7M8uSk5nTaWd+3hqO/PYVFicnk+uyYD0RnkKg6zrrTenEnmtmRSgB5WAZm515aPsucO7dd9maPpfE0g7wDL1luqCggP0HD9DR0cGtt95KTk4OCQkJvPfee4RCIUwmEyUlJRQUFLBq1SoSExOZP38+O3fujNaNTktLw263YzAY2Lx5MytWrCAQCFBWVsa6detYuHBhdJ57d6qqkJGRwcGDB0lKSmL9+vUEg0GOHDnCLbfcgt1uJyEhgRMnTrBt2zZycnKieQrMZjO5ubnRhsSrr76atrY2Dh48OKJ5zzPVhAxFvqjrrLluC39sDQ9lSvjQB3G73SzZsplzFgteu410u50DNhtz7r2HMxYLKXfcTkeHi7qYWM61t12WUW8ixOPkV4Yv4spxQQ49Wk70Zg8Yg9BVSaieFh4IfZMDxhMc9J2AKsIJobLh2cZ3YH74eW93noROoAD+WP8ezav9/J/xbXQdblY2YODyC0bQr0CDk9NBhY+dfP/SLxraINkCvkZ4ryvvugPADSffD2fg1dthf1dLbpIZLhylPeRjSbqjj28jnWBbIygqBmcCRkc8gaYaFFXF4IjDEJMIqkqwrZFQWgHv7nmcxUu24vW6aG2t4d13H8fVXk96+jxaWqrw+704HBZGXWtiHBmNRpKSknC5XFRXV1OQV8hQt9ftdkd7ISaK0Wjk1OnTNDY1smbNmkGDrUitxMj8jYsXL4YL3Gsa/q65jv0FILV1tWTflE1ychlmjzncslsQHvpz7Ngx5s2b1+sGX6eurg6z2Yzb7SYlJaWPOV09NTU14XA4SEpKoqqqivj4eHRdjyaHOH36NIVdeTeuiLuLApeP9Td5CIWCJMYmYbNZcVVDQxV85CtgskNLawvHQ89dth+ampqora3F5/Ph8XjIzs6OZkXvb9sgPCc0Pj6e+Pj4AfdzdXU1gUCAU6dO4ff7qaio6DeRSTAYpLy8nISEBFpbW8mbM2fA/dQfVVUpKCwk13z5VItwQN7/hTMSWA60D/R+UuBHEjZBOLtpX/oLMC0WC/Pnz+93nQO9FiA9Pb3PnAmKokQ/24FoIY2a6ppob0BmZiY1NTXRHltnRs9lezweGhoacDgc+P1+srMvn8ukKArJjnSSHX3P7R0Jh3UpDmvfc00btAZiY2PDPdaBZvSaP5LqPoFy7mNcGcelamTFsNwInIKVFqACruu2iboNiO/6hGt/BMD2vK5fln+XLWndn3s3KCo+bzM24zlczcW4utpjU+LDf5aev4ARaKgOD39fMh+gjaDnALE2KCu+gFmBtkZwtbWxZJ6TyouHUIIWQt4Eli8CqKSusuyy7LBGkw2HM53zJx7n/InHL20XUNtPZbvB2B1prNv8TRwxPc/T1kA1B6oPo+hBFMOlYzGc16DnV2d7vQ+zzcBd/7OQ5758lgv7Wlm4JQmshWBfBTYPKGfD82d3tMIfG+H7TjCr4brmFjUc1DYEwKeHaxebMtA87VT9+l+w5S7CU3Eaf0MF3sqz+Juq8Fw4gqfiDI55azHHJYN1bnh2yXSgg2vffppe+hMxa9cQbG0l5HJhiInBV3qRzrNnyXzok1O6YTyuuZ6/W7sCXdeImZOBpaWOUDBIlkXBbIIlRbmoikJMfRWfvmIFVjXI8pWLUVUVo9GERQ2ysDCHuGAn8xfPJRgMEtdcF66TO0RGo5Hrrruux2NXXHFFn89dvTo8LLv3d31iYmJ0rn3Eli3hqWHdr7E333wzx48fx+fzDXn6UVROIunvGeHRd4FwYcRwLZQKwltT3fUTSWEY+Xc4a6cCrADgHOE1HyP8Lkv5EABl8ExZ+InZlweSfZmTl0d+YUGPx5KTk6N5cQBuvPFSOaVly5ZFEwK2tLQwf/58kpOTo/sost+7zw1OS+t75I+CwtJFi1iae+l794rVq2B1uLxAbW0d6akpfPDmSyV7Fs7rmRjnA9u3Rf9uTU5i+4030NnoQlVBQafP+UOzyLgGthZFYbHdzr4OF4cBemc29nvB3dXK2O6H9tbw3z3dhpK1hG8u080mMsdxPKve1In26rlwa2ovZr8PFAU9MqwwqKG/VwauS70cycBzXIk2xC7tnf5czgeTqMvTaV/kQEEhT0nnlxh6fGnqOlRVqWh7byJljNJ4WxWYd20QdYFC7ySH7nP7sGbNI/fT/0fb+3+g5qn/BBTSP/JF4q+8jQvf+DDus3txzLsCs9nOubO78HpdPPP7L9LQcBGXq5HW1mr+8If/IDEhmzVrJ2f+7FA5HA7mzZtHU1MTLS0tPZPDDkDXddra2qLDjYbKaDTi8/lob28fck9gd/Hx8SzYdC27d++Kzs0Y6PXV1dUUFxejKArBYJCOjg6UoAVn1xDS6vPF4R7MuZdnFEtLTcOcnU0oFMJqtbJ8ebilNjMzMzrEpkf2QpTosM74+PhBewx1wuUKIsMHOzo6mD9/Pj6fj9LS0mhvZkSGZSG59kyqqqqwWCykJIV75xp1oAGKLGBxQLWrmvP665fW05VFMLLMhISE8CiHrhbtvnoOFUUhLS2NqqoqHA7HoJ9zKBSioaGB9evXRzO+vv/++7g73H0mBDGZTGRkZETnvqsGAyNJdxKZE1Wn993rUqK40cx9XzeCwSCHDx/DaOz7ZspgMBLwL6WvlO0+n48TJ05cNoQ5wmw2s3Tp0j6PTY/Hw4kTJ/rtsbVarSxZsqTfBqPOzs7onKPuIr2vg1FVJdqAEhnaFR8fHy3R0vtziGSVb29vjw7nm1KMCdRl3UVDYx0Ls57CYBh+PonBv1kUsBaRFPgztZXvcnz/d0ewoX3LToaK82eo6LVFBpuP6nadS+XY47EV/QjFM7xe8e4sJliYBZFDy2yJw+HM6mM6UbcGZl2/bAeFExTp6Bq89eNyOlsCzL0qkcpjLrY83BUoeLRwoNIZgqAO77TBR1NhpRO8Wrjc2+ey4StzIMsSnl8bvJQa3lN2Am/ZKXQ9hL+hksqffh5LRgExy68l/x8fp/SRB2g/+Boxi4ZX7m+y6aEgLW/sQA+G6Dh6DHQdc0YG6ffdQ+MLfyDu6qsxpY4w2ed4s1ghew7q6eMk9/qVkUs31AndHo/v+rN3cqNICNbjbHXGQsrgjWO634vW1jLo88ZSssXEXdtvwuTtRPN2Qh/X4MsoCjx4NVy3cMhljEZMVSFv8FF3raX1vPOlJ4Z9HQ8EAtSWlWMwqMTl5PDO/ieGvYmxWhsr9BDqs4/3W0EiKRjkOpcLfjC81jprUOPDN6nYW96F/zsJ9bVQMHAD8kw1roGtWVX5WlYOrn5ufoa1LEUhbpg9Y5HeqmAwiMViGfhAbvWg/+EUBDUwKCjbF6CfqoOLLZg35KKsz0Gvd6O/dAZaPWBQUO9eAWmXbt6HM7P35HNJvHrICccgqwm2bIGnn4bMTLj33vAx73LBz38OLS0KRUVG7r57BEN++vCHP0DTRROadukLPvLd7Zh3BY1//jEl/3ErweZa4lbdCIpC7TP/RdOOxwg0lONY8GUMRhN/87e/5uKe33Pq1A7uve+H6LpGMOjnJz+5h2u3PMy8+RuBcFvBMKfIAFzWMj7WIuni3377bUwmE/PmzRvS63Rdp7GxkZKSkmhJjIHqkHVnNptZsGABZ8+eRVVVFi9ePKweX5/Ph7urdEcknf9AN/OZmZn4fL7oc+rq6nA1e1Gaw0OUchYtIScnB38/Xzrnz5/Hk9+JbtexdZXT8vv9KIrCmTNnKCoq6tE2oqpqtAdvsC+OSO/aVVddhcFg4OjRozQ2NkaH6KalpUXnskREsrcOZfkRfr8/miE1JSWFpKQkjEZjj549rY9r1FDWpQN+nw+/x8OcOXPQdZ3Ozk4gPNzJHwhgCWmXFcmIlFPpr7d8qAwGA8sXLe+zxxbA2lmPWtx3xmqT0ciqVasYqDzh2+9cKtXbncViifYCDFekdMRIBYPBPut2AkPKr6ADgWAQvWu4fGTYeWT4vNorkFcUhYSEhGj+hylHUfCrRtrUDs62P4qijGMDcEyI7CtU0Ed2YfYGYvnj/v/B4w83FKlKV2UvHQxq+AcgEArh8h2h7MXldHjDzwt3yaR1/Yxg27vW928fgRsGSDGg6zptwRq0rhTttlgTq+9Ix2S9FOzmrogl6NdQVYWr785l7++qKX6njU33zWHZ9amoIQPKtyvgrDMcrPp1eLUJyryQZoJj7nAP7X+UwVJHeCjysa4G/TOd0BTEMe8K5v/PbgLNNZR+5z7mfPbn+GovUvnTz1L1qy/SeeEISdffD4S/Y4ND+I5VuvbBeHyvRu63Bkr+BqAYjWR//rNkffrvqH3sMXR/gLS7P4qvuhrXoUMUfPtbKF1DXXUgNISASCFcDn3cG50sVrj3IfANPCpkxAxGcAzQIKwoKDY7/qd/TeDPL4zPNvQjkp4wMuBdd3egxsWHA8qB2Ewwf+xGsoxG0S1rqDtSytln3x/8yf0IAsUHakf0WpNJwbTWSZzHSzijYH8MdDS2D/D7fpaflI59aX44wW32HFi0ckTbOd2N+1Bkm6piG+Z4/NHoXoIlFApx+PBh2tvbWbdu3ZAzIysrMlE/shTt/zrR/SHUj69Ae/UcyuosuGU++uNHwheY5RkEc2K4ePEiPp+P+fPnc/ToUZYsWUJzc3N4zoSiEAgE2Lt3L1deeeWluQm7wn9YLPBXfwV5efD889DaCjt3wrZtEB8P/q4Z+omJcM01OlVVlTQ2NlJQUEBNTQ0pKSl4PB4yMjKik9j37t3LkiVL+u0x27sXLl7s+Vi9F/Y3KTgWrKfoP17FV1OC0RGHNXcRoJC4+W6CHS0kpheSkjgHQ0Ah1hrL4sXXk542F6s10oOncdNN/x85OctQVSMej8Lrrw//i9RggFUroZ/RHGMiMzMzOvQkklxFDw1tQxMTE9m4cWM0Ec5QVVZW0tzcHE16U1lZic/nC88lHQK3u5OGM2dISEggLS1t0PnnkfntFRUVWCwW5syZgzcxREOVSlxcPFlZXXMZ+7h56OzspLOzk0AgPJfYE/SgKuEhupqm4fF46OjoiI56jKxvqLSQRkFBQdf+U8jPz8fn85GcnBytVzdv3jxQumfU6Dand4gNwKWlpdTU1ET/XVbWK3maAq0pbdAr/9fQ3ovOqVOnaKsJz0koKenZyqrosLi9nb5Coh7zk0fYmh0KaRw8dZwKevbY2m12CosK6dSD/ffGdZ2v588XXzZ812q1UlQ0F6WPqRHdt13XdUpKSi5L2BRpKOqr0cXr9VJcXNxv9mKr1crcuXP73f8JCQn9DguPHLMDURWVlOSe/S3J3f7dFro8aB5u5vFQKHTZZxrpHR6Pm++kmFto69xJIDT+vTiGUcTNuq6wvyyZdk8iigJ3Xw3tHvjzIXjoBlhdEG4EfWI3HCsJXxMf2grr54VrWAYCgWgCmd7lzoLBIG63u9/RFe0e+PKT0DCE+8XjrlcwYCTdMp9QUog59/Y8VtPWQ4tWQbp5Lvfs24aepcH9CeEybl3DsxPXpMCiflqNCntdbPKssCoGavxof26m4oIPJdGJMSYJ1Wwj4+5/xZySiyW9gJyHvo/71B5yH/4BMcs2o6PwndPgGMLdnMMI/99CKBp4hsiI+P1+fve7J7njjjv7nYJyweelU9Mw2O3oNp3EG29AD4VQLRYMdjuZn/xbLN2mb1zwefnbiyWD3j84VQNfyMgkzzKsoi/DpyhgtTJga+B4stqwffOHBPe8NTnr78Ww8gqU+Cna4NeLoigsvmcj8+5YN6JcQdOBoiooNvOlG+6Wie3VnyomrNzPRIgUcD5w4ABGY7jAuc1mw2QyDT34SHGg3rkE2rwQDEGLh9BP9sHZBpR5yRDo2bPzxhtv0NzcTHJyMtnZ2Rw+fJh58+bR0REu46BpGj6fj/fff5/169dHtxPCX8zbtsGcOeDxhL/Q29qgogKKiuD0aeh+X1hcXMyrr77CokWLcDqdFBcXYzAYCAaDpKWlRYdVHjx4kIKCAhwORzTbXWRblGiSkp7fFC1+qPXqXBF7juTENpjvJFxUNJwRTktTede1gTkdDq7tgJwcMCYpMCePnuN3FQoLb4j+fSTCw6+htGzsA1sFQIfqg2Cyheuo9l63v2OQZXQFsyOZW5uSknJZz89wkqPFx8exdN06VDXc4zqUJA4Wi4WiokvFu/0OaFTC9Q0HeguJKhgtRqwBPyYFHK1N2HQL2Uq4BqfVqJDs68TfPrKLp7/RgqcllQunIueUA3DgAlTy0QEf4HZohGKhbBcY+hj84XMNfKR1b+zqk8LIh0npOvH1VVg6+rlb1sHsM47LldaiGvApGv/iP3pZ+GkIGbCdPUBAD6GjY1Yu/6D9fnh/r4Lfl33Z/lFUldpahYZGGKw9MCsr67IhyQM1+JjN5gHn9Q4U/CmKEi2Z0Zf09PQBz0sFOOFp4FNlf+n3OQFdozXoRRnh9cvtdrN37140TYuO5NB1PVpeKjY2dsyDW7t5MUtyLq9r25dI4G0ymfB3JXsbr56uYDCIonYl3vIHcAfMGLu6ZZfPgQc2w+/fA5MBVuXDiQooqYUT3YoEZCVBdmwbLaEWHAkOHA4jzc3NpKam9hgp4/eHaGhwkZXV9wHb6gajQQF0QiEtWhIPLs/iraORYi7gjpT/Yt/e/eEgOjx7jfb2Nrw+D95Fr2C1xpJel4fiMMCmgugNZbRRY7j79YgL7ZVmqjthRSFk2gBskP+hS8/JuQ5uvq6/JfQroMHOenivYXwCW13XOX78OC6Xi/vvf6DPjLC7XC4U4Ma4+PAolivWXfplfAIUhr+ntK5EbkPZez5dZ6ernQPujvEPbCeZoigY11yJcc3Ihp/3TooYuQ7MFoqqYnbM7GNkKtE1DX2EUyi1YGjEr53UwLa+vp5AIEBqairFxcXMnz9/2NnWIiJlJ86ePUtnZyfp6emoqkpLS8uQa4xiNqDeswIcZtB0lKvz0KtdcLwW5aZ5EG9D/+WBHi8JBALYbDauvvrq6DqCwSDnz58nKSmJ5557DlVVaWtro7m5mT/+8Y8EAgEuXryJhQvzuftuKC8P13jbvh1efhkqK+Hf/x3+4R9gzRrYsSO8rlAohKIoLF++nOTk5Gjq8bNnz5KTk8NLL72E2+2muLiYQCDAs88+S1NTEwsXLiQzM5M33nijK/tnP9XSdIg7e5qUzstLD2mKAWNOHuDAZIR1a0FRPLzzzju0tLRw7bXXdk2W7/urqLW1FZvNRmVlJXa7nYyMjH4/hmAQXv7z4B/XSFjiIGkueNvA309VEHsyJBb1/bsR04GXm7AeHEJ3R0iH/L4z3KlquAzLuI64MhpR4hLw/fg7WH7xPdR/LETbnITrzvUEPZcCGBvQAeD3Y1iwhAGj5G4UVBQFXEmfxxWKhx4JinonK9LBVI+iGwh0qn3m1lBUSF4YThzVnaaH8OudpOckk5TW/xxZHZ3aDidtQ8/bERYbj5KUSn7lhQGWDVrnfPT4ZChpRTf1X4pG7/Cj2IZ+Sd4SM4f/l3U1rX30MHaXbnKw0t6zhSgrE6qrwedVAHtfeeTo7ASnE/qYfh0VaTwcjkgpoeGKDA23Wq39BmLBYLDfRgwF+FjSIn7RcJSawMCtV+ucmVwXO7KEXk6nkxUrVnDkyBFiYy9lHff5fOzdu5e8vDwKCwvHNOlceH8MbXmtra08/fTTbN26lddff53777+/KwP22Dt69DAXL14kNzeX8vJyrrvpDkAhwQmf3AqVzRDSwGYGpzUc3K6fC2nx8Isd4d/BpazX8fHx0fnsoVAIVVXJzs6OlriD8IiASF3d9PR02tra8Hq9KJZEIBZdD8/tjyRuS0xM7Od4VKirrcduc0RHEIRCIfbt20d6WgLVvksFT3TA3eGmrb0tmuW5tbWV1NTUEe+7O3J0VhnD90hWq5W4uDgqKytJTk6mvb0dk8nUlQX88tfquh4uN2Y2R8+VVj8cGrz4wqjk5+ezatUqHnvs19x//4OX9dzq6CQbTXwxPZOThw5x/vx5lixZwvLlPceGv/7666xevbrPrLJwKRlgYmIizaEQB9wdU6oTTtd1Ll68SFJSEqqqUl9fT0FBwZSYn//yyy+TkpJCY2MjaWlpbNiwYbI3ScxQh3/8F0789h0AVKMRXdfQuy7qBpMRo92M3+VF7/rOVgwqiqqiBYKEQhrOglQ2ff+vMZiHF6pOamCr6zq//e1viYmJIScnZ9BMmf0to7m5mcbGRrxeL1lZWaSnp3PmzJloL2ZfLYf9Lq+4GRo6UdZmg1EFqxFlaxHKhly0n+yF1p7j4m+66SZ27drFj3/8Y+69917gUiKZd999l3Xr1jFnzhx+9KMfsWvXLrxeLzExMZw/f478/HzeeCPcI5KTE76J/NjH4MCBcI+lz9czVpg3bx7BYIDHH3+ca665Jvp4XV0dFy5cwGAwcP/99/PII49QVlbGsWPHWLt2Le+88w6bNm3C2DWn7vTp/npD4KorryJ0Vsdk6nlodPqC4XJH3e4Z3333XXw+Hxs3bsRqtRIKhaLDbGNiYggGg9F///73v2fVqlXk5eVhsVgIhUI0NTVF0853dIRraWqaRmxsAhAeHltbW0dycjI+nw+fz9fvF91QGS2Qt5nBh6L02kWazrAyc/foAMwwwzIHHBmkK7i7+zVAJ4RGSA+F56GhhuccoaH0sS3aiNIPXU6Jjcfx46cInQ2XdzItOoKSUoXtPx7FHur7kmFYshJsQ5tlbjPPJyf5y3hiTg/+ZAAKibFtIGNRav8t+N3mjSmAUbFw0bOfX1f99ZDW0Nk1hFPTg7iCdRj6mafoCXWb85uYDA9/AQIDVPTTdfjtadhdTujr7wy8EboO1xcNeaCDw2DiwZRlQ3tyL7GxcN21Q+uoHu+57kM1lCB64ORRCtvjCrgprv/e4u7UEfbYKopCYmIiycnJhEIhEhISoj14KSkpdHZ20traSkJCQrQh1+/3o6rhesSRklHjdROcmJjI+vXr+eUvf8mDDz44tnXfe1mxYgUlJSW88847PPTQQ4QUBYMK910DRenQ2gnXL4XKJvjKU1DdDPMy4St3wAt7Lw0bjgw9Ly8vJzU1ldjYWDIyMqivr8ftduN2u6NTjRoaGqKjl5qbm/H5fOHGQEv4fSqKQnp6OqWlpdFa5H0JhYKUlpYyf96C6PLq6+tRVZWkpCTshkv7TdM0qmuqo3PydV2PfmcZjUZUVY02upjN5uhQ9e69+n6/HzUQ7HHUud1uMjMzUVUVl8sVPUY6OjrIz8+PridSn1fTNAKBAKqqUlpaSm5uLmazmUAgQEg3AQZ0dDweL1arNVp/eqx67RRFYfXqNYDCb37za+6//4Guhtiex3JNTQ3vvfceH/7wh6P7tq2tjWAwSGJiIo2NjQSDQfx+Py0tLcTFxWGxWKIl6EwmEz/72c944IEHMHVNI2hsaCAYG4/X6yUQCEz6nPiOjg6effZZVFXl2muvndRt6W7r1q387Gc/Izk5mZtvvnmyN0fMYO0VjVS/fx57aiwb//2j1B66wNGfvUFMdhLXP/ogifMyKfnzIXZ/7WkUo4G1n7kZc6yNd/7lCXRNJ+gLjGia1qQGtqmpqdx7772cOXOGa665ZsS9ta2trdGMlZGaonPnzqW4uDiaEXVIFzl/CP2l0+gKqE4z+r4KsBlR71oG7gDqQ+vQj9agP3si+pLOzk7WrVtHZ2cnZ86cuWyRkXmIgUAAg8FAXFwcCxYsYOnSLI4ehZISyM0Nz6d95hm48074/OchEID6+nCQG+H1esjNzWXbtm3s2rWrR6+noih4vV48Hg8ejwdFUXA4HGRlZZGXl0d+fj6xsbE89thjhEJfoK9MpxDuVUhPSWbF8p6TzvcdOoyn3tujUyA3N5c//OEPFBQUkJGRweuvv059fT3Nzc189KMf5dVXX8VsNhMfH09JSQkWi4WWlhYyMjI4c+YMPp+P5uZmNm3axJ49e4iPj6e8vJyPfORjwBx04MCBA7S0tNDU1MTWrVtHHdiG9xVDDh4iiTZ+eA4evzj48yNa/F2vBUg0wXeKumW8HJzB+D7lHOTO0L+idA2K/Kh+HxasfCH0sz6zb/sI4MFHDCr1gQC/bKjr8+bc5FWZpyWxp6ODpvrw3MoQOs3BcG+soigYFq/AsHhFeB+EfCi6C/MH78KsjH4Yj0G1MSf5K6NeTn+czhg2Gx+ixLOnq1zNYHRKPQeo8Z2mNVjFb6sfor8DJEQQuxqHAVP4wHAOPKZPAdRPrIMbFwweRSoK5MZNSKt+tBFgmKvS/OA+Deo0Gc0VCBjRmmzoXb3xiqJgGOfyY5qmUVJSQn19PQsWLODkyZPExcX1+IIuLy9n48aN0UDd7/dTV1eHxWJBVdUBR7SMlqIorFy5kkWLFo1rAA3hhoY777wzOuSx1a2g6bD7DFysh6sWAF2Jo+6+Gn7zNiTHhGcBBbuNbg8Gg9Fe1dbWViC8n+Pj46muriY+Pj56/xDJjm21WqP3A01NTbS1NQDpgILZbKaoqGjAYe+tra3MNZsxmUzR5GKlpaVdtcCDBLRLDVqKomC1mGlpaSE1NRVN02hvb0dRFPx+P7m5udTX1+P1eomLi8Ptdkd7gJ1OJ6FQKBzY1nWS1u04CQQCNDY2YrfbcbvddHZ24nK5wkkE3W7a29sxGAwEAgEyM8MZ481mczQ5nsvlwu12h4ee2uKA8PWqsbERg8FAZ2cnmZmZYzocVVEU1qxZA+jR4LZ3z21cXByapnH69Gmuuuoqzp8/zxtvvIHBYIgmpQsEwo34drudtrY2brvtNp5++mlSUlJITEzk4sWLnDt3jkVd9ecPHjxIzP6DNDQ0cNNNN01qYKsoCkuXLo0O9125cuWU6K2N3Bf+3d/9XVfpoRk1G1FMRQosvucaij6wBldVMyiw8uEbCLh9vPrJn3D9ow9S9uYJDBYTSx/cQu2BklGPvpiwo7pT99IczafWTaaZ+ZnLqKWlRy9aPE6cyuBD3BRFiRaVjgz9itScjI2NjQ7hGZTTjHLlnOjYJ72kCWLDX/r+V06DqmA0msJFoBemwtkGAE6ePMnRo0dJTEzkmmuuiQ4bys/PZ/ny5Tz//PNUVFSwePFirrnmGv70pz9x4sQJ5s/PILGzFb3GhSE/k337DGzYALW18MYb4azIdXWwfDkcOxbexPr6Bl599RUsFgtbt26lubkZp9NJUVERhYWFnDt3jhdffJHCwkLmzpvHqboK/rR3J6tWraKuxMO7779L4eolnD7txeP0URMAQ9c+bwga0Luy5xiNJiy9kiP0dQEsKirivvvu4w9/+ANtbW3s3r2bjIwMWltbOXv2LIFAgPvuuy9ckqWxkauvvprS0lK8Xi81NTU8/PDDVFdX8+abb2IwGNi2bRuHDh2ivLwCCJdiuemmm3jppZdYsGABixYtGvxzHGNZNvirQiju49AdSJoNFsZCamQ3WlR65fcZ0D36DTRpLvxcGpJsVczEtSSy8e0b+z3xb0Il0TMfb8BKf/2IIU2BIBztdHOwpTX6uF1VWTNQRsZpIsYZQwwxpFsHGEPbja7rrIj5IGXew6AP3uudYMrBbhj6TZPiMMOCfspXRNKRdw96Q922QdNRNL3nY5etQImkjR1X5jQItsHZzw/nVTraEPZplKJ0NcaM1fsxASYUA5h71+cYJx0dHTQ3NxMbG9s1AiWWtLQ0/H4/Ho8Hs9l8WSu0w+EgOTkZt9tNenr6uN8EK4oSHbo73nrnI9B12NstH5yuw67T4SHI37g7nMbiN++Ee3MjPB5POGkdLZgcxwmGOjhX5iM1LY2OQBVOQzpNHQodQRcOh4Pq2joURWFO9tUEPHkEg0Fi4y4dAENJ+ufz+Tl//jxlpZem5mRkZGCz2aiuqcYbe2n0lqIoZOfk0NbWRllZGVlZWTidTrKysigpKSEQCBAIBKJZ0yPlxBRFobKyEq/Xi81m6xqTc4nJZCI5ORmDwYDRaIzWXXe73djtdioqKqI1ytva2nA6naSkpKDrOi6Xi8TERILBIIFAAIvJBOgoEK3dnJaWNuypBIOJ9CJ7vT46Ojr4/ve/xz/8w2d6DPd2Op188pOf5O233+bpp5/GYDDQ2tqK1WrlYldmy7a2No4cOcLixYupqanh8OHDLF68mC1bthAIBDhx4gRXXHEF7q5z5brrr8e8aw8bN25kwYIFY/qe+hXqhGDf5acUYNmC8PeE4u8qZmWIB+Pwy3H1x9/pxt8x9JsTa1w8Rot1yFUcxkwgcKm051BYrEMeASamOB0O/+hVrHF20HVUo4G0lfmc/O1Oqt47S92RUtJW5bPvf17C7LBQePPqUSf3mrDA9jV9P5/TfhD+h6ajlXpQs61gVNEqPWiVXtRMC2quDVSFr6uf4B5l65CWbTAYWLRoEcFgMPrFUVFRQUFBAYWFhUPrCU51on6m7wn5Plf4hDR3tTrqR2rQvvEW2hvFbEiMZUNquKwNfyljC6nwlzI2kQQ7KnkwrlvB7B2VfNy2Ivz3mBb0rLPoWiuGL9wCjv6/ZP/lX8JDk3fvnkNMzEMA7N4NMIdTpwDSeP55Bbg9mnn9D68F+On8EG0FTn7HObTWDlisoybU4Y15gkBKPXt2WjBmJIZvJgNJ2PUP9b0B/SgvL6e1tZW0tDSam5vJzs5m/vz52O128vPz2b9/PydPnsRms2E0GikvL4+WclEUhSNHjlBZWUlubi5lZWXRIVt6txtho9HIrbfeCkxAKv8+mA3wYMHgz+vPSDd5Hjn8UP1sj8da50GNRyGnbZTDmhQwZMHnlqdhiEvt/vCEZjCfKhRFwWlMZrFzaNebMfd/b8HJcIF6jGo4iO26sBtMKgmaFp4CEJl+bDWFa3tEEtmtzYMHrhr38cLJ28FeBNow5iK3e1v41pufwxPoxGayo6AS0Pz4g+GgQO1KaqXp4fcyL2UZD1/51TE/11ULOIZWzWvUYmJiuOKK8HXf4/FQW3upNESkvFBviqIQGxs7LomlphKrGT52NXi6poVHYsuPbICq5nDm4kAQMuLhjnXwh/3gD4LREkNaZgxuXy2nqz5BjHUliUnb8Qc7MMe+R0nDX4ixriXBuRW3/wJe04toWidNnZ8hJ+l/gXCgrA+jTJHVasVgNESHOCuKgsViQdd1vF4vCXMuNW5FhtIaDAY0TYvWRI6IjKKy2WzRIcltbW1omhadM+50OrHEWlAUb4/lRnqLe1NVNdpwHxcXh8lkor6+HqvVGm2I9ng8xMTE4HK5aGpqAjKBcFCf1ZV9eCyPt1AoxMsv/4m0tHT27NnNpk3XkJAQf9nz2tvbqSgujuZXWbhwIYqiMG/ePLKysnjnnXewWq1kZWWxatUqDAYDDoeDHTt2kJ6eTlxcHMFgkJqaGmJzcoDwvcLtt98+5u9pQG1vwbmPgzkDrF03Ct4S8NcCOorqAFMy+MoBHXL/HTI/O2arP/fGn9n3mx8Tk5aJIzncoNFafpGA10NSfhEGs4WAx0NzaTF6KMSWf/w38jdsGrP1D1nFRfjN/4VLGSWnAgq0NEJbazhDakp6eEpPU0O4cXnTDXC9DJOeKYLeACF/142DTniebbdTVAuE0PxBAp4BpnUNw4QFtgGCuOgMD8043EbHxw/hfHI1+EK4/+YYOA3oriCOR5dgvC6ZAH0nz+mP0Whk8eLFHD16FL/fz9y5c8nLyxvy8OahXAijz8mMhfxE9H0Vo+4yV1ZkgMXY7z2prsPateHyPH/842DbeOn3IYtOQ2YAX7wf3Reg9RtPoCbFEPvpD9L23RfwHzgHioLzwRuw3bwWkxbADqgGlYsXSmjtlXW0rqkZg+1ShOfxQCBgprikhrjYFFauWonP6+XgwYPhGwBrIh/84Ec5deoUc+fO5corr+fMmbPMmZNPTGwst96ay+HDh0lMzGb58uUkJeWgaVZycxegaQonTnZ7V5N8ozcZq+/rPcfnQ3zeWK5Evey9uYINvNv6GCEtiNY1qfiCoxS3pZnXWh/BrBl6vCbLuoQlzm0DrmZow4FnsYuNcLQCMuPhk9fAi4fhSDnMTUX51LWYY63wxyPw8jG4bRVsXwpNbvjBDihtgtRxSHHaB9UMziXDe43f7af81EGWpK/hb9Z9kaAW5GzDUb6/+18xGcx8dMXDdPjaefroTwCdhCwTMSsmpAN63HQ/dxVFob29vUfW6MiQ0t7n+GRf5yaCzQwPbhnac6tb4C9H4Yevwi/fDO+bzAS46yqF9Pi/xmLKxe07gaKYsJvnsyDzt7R2vk1KzEcwGVKpavkurxyGt06EX6vp4cB5qHlIEhLiWbBgPufPFofL+ACuDheNTY3MnVtIc69eL13T8Qa8ZGdnY7FYokNhU1NTsdvt0QoFZrOZ5uZmFEWJ5pgIhULhQLdbo257AAK2BEqbOzEajeEhyxYjjX4VPSaF5qARc0o2Va4ObDYbTqsDLSaZijYvsXFxGBIyqHEH0HUIaWbUuLgeWRjG43grKSkhNjaWqqoqVq1aRWdnJ5s2bepZlknXadF1ipua0HWd6z/yYWJjY/EcPMSFlhYSCwvJX7UKQ3Iy1915J2fOnGFO3hwy8/JYeOWVHCkrY/XqVWzYvp3ipiZy09OJJE+d8HNID0LIDdlfAvtSCLVA/WNQ/xtAgfRPQfxWOH0zaF7QBk70N1yhQIBQIMCVf/sZjDYbAY+HY889QcDrYfPnvkJ7bTWdzY3s+b//wdfpRgsON0PiGNE08HnhplshrxA63XDsEOzfDTd+EAoXhOvhvv4SHD0AweHd/4vpQwuFqDlQQtEH1tBW1kj6qgJOP7Xn0hPG4BSe8AH2emuAzq+cQW8LolhUQuc6QNOx/u0cvN+/SOiCG+N1wx8zFmlNXbJkCV6vl8TExPG7yKU6MPy/64eXTag/ZgOKaYDyFArceivceOPwKpJ0aPDBCqgK6HS+tBfvu6dw3H4VwfJ6fO+dJvG7n8R/pITOF97Fdv0KMISXfzSURurS22jutbJQloKh3orJAwE3vPYXgAwgg/oGeO01ACtwHa4OqH4ZIBvI5uixyFJSae4RL4efW1kFMJeTpyLLDGdGnujRMlPdcOYGj5RXc3HS9ReOvFrFu49VgQLeh/MI3JXFv9l2Q0hHUS9thsNwjERt94DLrNQbUKMzhUWfjCrcvS7c+/rG6fCkw/uvgtPV4d7chzeHu5w+tAJ+8CasyYN7N8B/vjy52z1E+YkLaPU08X75mxytfp9AyM91c2/lhvl3svvia8zUwoJWq5XNmzdf1ksbCWpE/9Li4J9uhfOXSlBjt4CqGrGYcrGbF2BQ4/H4ztGpn6Ky+X+pa3uMuRk/xmQMj0TJSYbru+VXc1jghp4JePukoNIYKOVMymMEE4I9Dk+PAm1GI43+C+RZ1gKgKgqJiQk9WkEjSakiPb7dayW3trYSFxcXHRJqMBhISUmBOBdBGlAV+P5ZBaPaX06JSGOWvesnIrbrB3rPfdEBbwic43TYGQwGPvzhj7Bu3Tqef/45Tp8+zfXX9xwFE2MwUBvw86naKsjtqlfb0hT+SU4AEvhJXdfolaquIeAFXdnJL5wHixHycvh5U0M434fThl52Aa+m4VTHLsv4sChGsORAoB46T4JrP6BD7NWQ8SnwnAG9jzp1Y8RosWBLSKS9upLm0hKayy6Qvmg5uqbRUV9L1ZED+Aep7T0hFBUSEsHthroqKCuBhGRYsBQOvQ9eLzTWT/ZWijGihTR83eaTtFyoC/fU6nD0ZzvY8u172PLteyn58yEqd4fzE3XWtVJ3+CKjvR+Y0MBWD2h4H7mAoiiomVa0Rj9KlhWtyY/n6+fQXUEMeSMfVx+ZGD9epQu6rwfrxN2UGAzhjMnDoYfCvR6B0xW4n34HyxXz0Tw+MBlQTEZ8e04SOF+D3uFB13RS7bA4Hva2GOnvsDAb4PYVsCAUnjIxnlQVcrLHdx2ifxf2tWKNNVK4Pp74LAvHazxUnnWTtyaO9jo/rgY/OctjcKgmEhi4xzBBiWGzspIYZM5Mv4Ia/PhtiLUBOtjNkJ0Av30PLjTAx9bBNfOh3gX7S6HTD/9w/YReh0ZKURRirfHE2hJZP+c6rim8ma+//ml2nH8Rm8lB5gjL6kwHiqJM/Hy2GcKgwk0rwj8R7Z1wtFyjru23BEMtGFQ7eSnfpN37PjWtPyY55nYcliWUN/w/AFbMCQ9pHq6VsbeiEQoPke/nLinPtIZVztsuPdB7rvwA0lLTuqoM9Hq+DgYFPj0fyvKGv92DsRlg08grEA3IaDRy1VVXoSgKt956W7TxpnsHw4cTk0k3mQmMtG54P+yqysaYsZu7OiyKATznIVAHpnQo+gkU/y3M+U9oexvM2WBMDP9+PFavGmi+WExz2QWSC+dx1UOfp2TnG9SdPkFLRSkrPnwPWihI8dv91+6eEKoKTY3g94Xn0N5xD+x5E2LioGhheJiy13OpQUNMa+3ljZz+/btYExwYrWYqdp4CwJmRALrOO//yJKrZQMgbwJYYDnAaTlbQdLaa6//3QUJGBc1hRjUMf3rchAa2WpmHwB9r0TtDaHU+Oj9zAiXVgvnmNGzfWoj3P8/j+101xutShlqSTwxA1zQ8L+1Fa/fgP1yCHtIwJMTg/Osb8Ly8D62lAyXOgWI0kGiBRxcO3CGoAA7j9B4mKAanh3Ta6/xUn+qgsdRDxtF2CtfF0/lqI7f/bAkXDrbx+ncvcstvlrMqdQHbbP88pOXOhqGWo9Lp7164s9dNcq8EUpGb6OnQ0anrPHvsF/zu8I/wBb385/ZfsTr7av50+kl8Qc9kb52YZlTFgoKRDu8BwIhOCJOaRKLzFrITP8/5mofxBIpHvHxFUci0LCYzZfHgT9ZBUYvhmBs+O/R19tsc5Qqi6LAyUWFlzpAXNyV0v75bLH1nSowxGNgeP7lleMacHoSa74PnNJjSYMk7kP5JsBSAZU44qM1/BIo/MS6rD/q8HPzdr2gpv0hy4Xy2funrHHmmhnd/9l08Lc3YExJJX7yc4rdfH5f1D5muwd5d0FALVht86p8gJQ3aWuC3P4Zlq2HF2nDvrZj2tECQkC/A1u//NXM/dMXgLwD2/++fOParN1l87zUEzQptHZ0oUz2wVfPtxLy6Ht0douOeQ9i/uZDgW40E3mzC/8c6giddGFfEghq+X9NG2aqnMLtvphVVJeZTN+N8cCudz+8h1OTCfvuVtH37WcxL8vAdLsFyxTzoGgptMeiYexVIne37cDZSDApbP5OHxWFA1+HXnzgevoEzdGUTNSkEfRp6V2+DHB/jwOOHyhbYOBfibBBnh6f2h+fgLs+B9QXh+bW+qT8XyWgwc/+az3Km/ggXm88RZ02kxdM02Zslpi2V1Li7SY//a0DH67+A0ZjI3PQf4QtUkZX4aVrdS6ht+wUh3Y0/WDPoErszqDGoimOI1zUd7kqFPzaOTSOT3QyrYyB/mtTTGqFwGRwfAf8warsPgQKYrfGo6gTe2ppSYe5j0PwCmFIg0ABV34Gqb4NzHWT+PVz8AmhdjXiXZYkfXaHwuMwcrvvnf+fMX/5EStF8WivKKNx0HfHZcyjf/y5ZK9Zy5Jnf0tUa2iM558gpw//et9nhw/fBuVNgMoV7bk+fgEXLYdNWyMmH8gvh+bgwvLl3MDWKrYvLmBzWaI/soM+1jc3opgk5+0O6xhm9HMWgoGRY0QMa1n/Ix7AsFsPiGJQEM6H9rZhuSMFyT3j86c+0l3hZeW/E6zRi4LPqh9nAEFpdZ6AKXzsdmh81xo7utGHdtBSt04eaHIfjzqvxvn0M68Yl2D+0HkVRKPW1cf+Fl1F7XRw+FF/ERxIXXva4mLn8nhB7f1fNsptTscUa0TSdzIVOjrxUT0NpJ6UH2kgusGO2ybCKUQuEwNsVnOqEE0m1uMPz9x9/Dz65OTyf9oVD8P4FyI4PB7ftHvi/ty8fyjjFdAbc+INeDlbu4tYl92NSLey++CoHK3cB0Oiuw6Bc6r+q76ji2aM/G9VNitlgYUvRB4izjr7mtZg6dF2j0fUCIa2Ns9X34bSuRkenw7MfRTFwvvbvUDGgAx5/MaBT1/Y4je3PD2s9TttqFmU9g9EwhDKBigLrY8M/Y2kaft9qWpDykj/j97b23H69K51797ek69RVv09zw4kx3gqFeUvvY8Gyvxr/Blddg84T4K+C0n+GxJsh6ILiv4ZIeR/X+1BjuDQMue4X0Laj53ISPwjpD4dbjodBCwZpqbhIS/kFDvz2Z2SuWENLRSnnXn8ZXdeZd902EuYUcPjp33Bhz1sAHHzyl5z+84ujfOOQtfIKlt9xN+ogJbOA8OdfWwUdLnj5OVi8AkJB+P1vwo8/+9twb+3xg3Bob/j5R/ZDRenQNsZghK23QE7eKN6RmEkmJLB14+EFfReFZFKoZIIZ+Hi3J3yOS6UsxuBapKGzXz/Dk9obbDDMzsD2lbaLeLUQm2NyMCgqrM+79Msb8mDrjeG/D7C/z3qb+XnDMW5NmIdVkULeM52u64T0IEazgsVp4IWvnkNRYO7VCaz9cAatNT6e/IdTGMwqH/hKEYoazqJc4T1KlmVJtHSLGIbjVeGfGGt4UuHLR8PBarw9PJ/2638KB763r4J/uC48D6C8KTwn99aV4WXkTN0A7k+nnsAT6ORI9XucrjuMqhjwBj1YTTasJhvnGo5zvvE48bYkADr87fzuyI9GvD5d1+nwteHytnLvms+M1dsQU4JGu+c9nNZVpMc9GH002fmBy54Zb79mRGto97xHU8efCGptQwtsYVoGoeNB04KcPfYr/P4O5i+5D6PJjsfTwLnjvyExZRnZ+VvDWcJbSig+/TS6FiQzdzNpWRvGbBtKTj9NY+0hWPZXY7bMfmleaHgyPNxYNUFr11Bfa374J/q8Tkjop3KA5yxUPwqp94NheNntve1tlL67k7isXIJ+HxX730XXdRLziwBoulhMc2kJuq6TvXJoQ0GHor2miuMvPsXCmz6INXYI50goFA5YY+PBbIHi0+HH4xLCPwAXzoVjgLyi4W2MrsHFc3B4rwS200BlZSXBYJA5c+agKAqapnH8+HGKiorGNDfShEUrOjp3qNfwT8rHaGtro7Gpkfi4eGpqaohPiMdkMpOWeimrQWlpKXHxcSQMcz5GfX093pCPT6Q+isbwhlzU1tbS1tYW/XdaWhrx8fHDWsZUoaOTYrLxo9ytdNQ3EwgEcDgdtLe78Ho8zJ8/H4PBQHNzMx1uN7k5l0/o+WrVLt7tqJqErReT5Uj7H9CUIFs/XcDV98xBUVScSSZUg8KtX16IuyWAyapijTWi6xqV3mM8U/tP3Jb6H+Tbx+7Lc9bwBUCF4NdvxZvhuFS/1mgM17c8WgFf+wNsXgALMyZ3W0eg09/BnIQi/r8rHsHb6SMlJYWYbkleFC61adLP37s/1tfjLS0ttLa1kpeXjzfYyef/+BE6A2M7xHEy6LqOx+PpUcPUZrP1qI86G1lNRYTcH8Tv95OQkEBCQsKQeufa29tpbGykoKD/wuRqq42mjj+N5eZOK2NxzCUkLyQ1ax1VpTtwu6rQNQ2/t4X2lhIKF36YgN8dfW5i6jJSsrbR0NCAzWYjMzMTRVFoaGiIlsWaP38+iqJQVlZGUlJSNMv05duuUVOxc+Rvfth0QCMQewsdyf9GfEICgUCAzk438XHxAIS0EGfOnGHhwoWoSh9zBcu/Ao1PjXj9uq6z+JY7mHfjB6mpqcZkNJGRkTFoY0tTUxMej4fMzEwAzpw+zYKFC6PlMS9evEhyUhIOp/OykplHn3uCo889ybDG3us6zFuEfue9tLS0YLfZsFovDbc/e+4cOTk52G023G431dXVzJ07N7wtpaUkJiYS19fnHgzA9745/GHLYlJYLBaeeOIJ7rjjDgoKCnjzzTe5ePEiCxcuHNP1THg33IULF3j77bfJz8/Hn+7n3Xff5dZbb8VqteLxeAgEAthsNk6dOkV2djYmowmn04nf748WG9d1nY6ODhwOB7qu4/f7MZvN+Hw+iouLCRCEEWT+e/zxx0lKSsJmswGwevXqaRvYRuzdu4+2mnoyMjKIjY2lvLyclStXoigKbrebsrIympqayEhPx+Px4HQ6CQaDeL3ey0pUiJmvI9RE49kga9QHWLRoESkpKbjdbowmExaLBW+Kh2AwhMPp4C9/+Qs5c5M5YvslHq19sjd9GlNo03w0uQPRVkuLUcUaZwvXJ5nmDKqRHa+8TcGcQt57ex8PPPBAuKGt2/XbZDLh9XqxWa2YzWbcbje6rmM2mwmFQmiahtFoxOfzEdP1fRAMBjEYDHjbA5SerSA/s4hYW/yMGTmg63q4gTcu3CsSybA82wNbTdP43VO/Y82aNezYsYOrr76agoICgsEgJpMJj8eDw+EgGAxisVjw+XyYzWZ0XcfpdEbvM8xmMxaLpcexNtvpuk5ZWVk0eIxkNh7OMWd3pGN3pJOdfwPtLcXUVb9Pa/NZYuLysNpT8HmaegQie/bsweVysWjRItLT0+ns7KSkpCQa1B44cACDwUBOTg4GgwG3200wGMTZVSqio6MDo9GI1To510qvz8vvn3mGT3ziExw9ehSPx8Pq1asJhUI4HA7i4xMAhQ53OKC32+24XC6sVivmMSmCp/PSSy9ht9tJTU0lLT0dd0cHJpMpel3VNI2YmBi8Xi+BQACLxYKu6zz//PNcc801xCck4PV6sdvt+Hw+HA4H/kCAPz/zDNu2bYt+L3Vv8BgJTdN4+umnmT9/Plu2bEHTNDo6Oti/fz/x8fHouk5NbS2Hjxxh7rx5AMTExGA0GnF3dkY/d03TcLvdxFitkmd2GklOTub+++/nN7/5DVlZWXR2dnLfffeNeem7oQe2YxTkRALZxMREQqEQu3bt4ty5c6iqys6dO5k3bx5tbW3ExcXx/vvv895777FhwwYOHTqEw+HAZDIxb948jhw5gslkIjk5mX379rFs2TIaGxupr69n9fo1I9o2s9nMjTfeyJkzZ9i4cSOnT5/G6/WOyfueLCajEb/fz6JFi6ivr0fTNHbs2MHKlSs5ePAgLpeL/Px8nn/+efx+PxkZGVRUVJCSkoJnngw/no2CXrAYkkky5XFm3zmqq6tpb29n/fr1/OlPfyI9PZ2ioiIqTrSgBxS0ldIAMno6iYnhIcWxsbFomhYO9CZ5q8aK2WRm9erVVFZWcvLkSc6fP4/VaiU2NpZDhw5xzTXXUFpaSkdHB9dddx1vvvkmuq6TlJTEuXPnmDNnDikpKVy4cIGlS5dy4sQJYmJiaGxsZNWqVRw7doyamhpWr1s52W91TJnNZhITE/F4PCQkJNDW1ib1b4HY2Bg2bdrE0qVLeeWVV9i3bx8ej4dly5Zx8eJFbDYbXq+Xq666imeeeYatW7dSVlaGoihUVFSQmJiIy+Xiuuuu4+2330bXddLS0li7cbLf2eQzmUyXHXPDCfrra/az9+0v0dFexor1/8Scog9w9tivqK/Zz7F9/8uCZQ9SVfYmHe3hsi66rpOSkkJaWhpnz55l//79NDc3M3/+fN544w0CgQChUIiKigpyc3N55ZVXyMnJITc3l2AwSHNzM+fPn+fBBx8Ypz0yMKfDicPhoLa2llOnTrF48WJ+//vfoygKCxcu5MyZMyxfvpyjR49SWFgYzmlSWorP5+PeTYH+M2QPmYLBYIiu78SJExw7dozOzk5WrFjB7t27sdlsbNy4kffee4+cnBwyMzOpqKjgwIEDJCcnU1paislk4qabbuL111+P3lvv3bsXVVXJysrCYrGM+tpTU1PDnDlzqKqqIhAI8MYbb+B2uzl9+jRLlizh0KFD6LqOxWIh0FVT8uDBgyQnJ0c/9+zsbBoaGjCZTGy+6iqSRr3/xERRFIW0tDTuv/9+du3axZ133onFYhnz+fDDz6McLUMxspvZSCt778cCgQDx8fF86EMfwmQy4ff72bRpE5s3b2bv3r2kpKRw2223UVdXR2VlZfTi4Pf7ueGGG2hra2Pbtm3hOmqjaAOzWCy0tbXxzDPPsGPHDjqnQmHrUVi9ejXr1q3jqaeeor093Kvm8Xg4ceIE1113Hddccw0ul4tjx46hqirBYJD4+Hi8Xu9lQ1DE7KDrOg0N9TQ0NHD27FluvfVWFi1axIULFygoKODGG2+ktraWefPmccUVV8z6HqSxZLFYKC8vp7W1lY6O6T+cNsLV4eLPf/4za9asweVyAeHhboFAgJtuuinao1ZRUcHRo0e5+uqr2bJlC6FQCKfTyQc+8AFaW1vRNI2ysjJUVWXr1q0sXLiQuro6Vq5cybXXXkt5+cyrgWgymWhvb6ehoYGGhgYZSdNNKBTCaAw3wN5+++14PJ7osNXExETee+897HY7x44dIzMzE5/Ph8lkYvv27SiKwuHDh3scayJs5MecQlxCEaGQF4+7Dp+3FUdMJvOW3AtAY+1BQMdguNS7qus6dXV1tLS0cOLECW688UY2bgy3MPh8PubOncvatWuj9yfZ2dls376d8vJyLly4wG233cbcuXMJhcYi2+/wKYrCsmXL2LVrF4qiUFNTw6ZNm6KdJB6Ph6NHj0bvT999912CwSCqqhIIjk1W+5tvvpmUlBR+97vfsWfPHnw+H0ajkc7OTpYvX86GDRuorq4mNjYWv99PKBTCbDYzb948Vq1ahc/no7CwkD179mCxWDAYDKSmprJw4UJuvPFGzp8/z/nz5wccxj8YHdi3bx8XL17k3LlzXLhwgYqKCm677TYWLFjA2bNnWbNmDTfccANGo5GDBw+yd+/eaC9zdnY2N998M5WVlSQlJeHxeDCMoBSMmFyR4Ha8gloYQWCro9PgrqKq/SJlLeeH9FPZegG1tQN3Sz3JBXH88omf8c4773DixIloS5OiKNTW1vL2229HhxDt37+fffv2sXz5cqqqqti5cyfx8fFcuHCB2NhYVFXFYDBgNptJS0tj586dHDx4cMQ7KiEhAaPRyMqVK6mtrWXXrl0jWs5UcvrMGcrKyoDwTUBkn6Wnp/Puu++yb98+HA4HWVlZZGdnk5+fT1paGvX19TS3tEzy1ovJoBpUli5fwqKlC0lOTeSNN//CueIzZGSloRhBV0LoSgiLzcTxk8dGPTxJgMFgwGAwYLFYcDqdVFRUTPYmjan4uHg+/OEPs2rVKs6fP09cXByqqqKqKiaTifPnz+NwOKLXpn379kVvAM1mM4FAgPLycmJiYqLTKPbs2UNxcTHp6ekYjUZUVZ1xpadMJhOKopCUlERjY+O0b2gdK+3tLnbt2sXLL7/MlVdeiclkQlVVzp07F703mD9/PufOnePKK6+kurqapKQkVFWNHitGo7HHsSaB7aWhx5FjrqmpaZjHnI7FmsCqK7/Mxpv+j9j4AipKXiU1cx1X3/B91m3+FnXVe6O9tUD0s/B6vaSkpLBr1y72798fLi1nMGC32zl37hyBQCC6fZH7mJiYGN566y3OnDkzFnlHR2zu3LkcPnyYRYsWkZuby/vvv8/7779PXl5edBj1rl27OHHiBEVFRSQnJzNv3jws5rEYPq2zb98+2traCAQCFBYWkpCQwNy5c3E6ndHvFl3XyczMpLS0lM7OTlRVxWw2c+bMmej5sn//fpYuXRp9jdfrpa2tDYPBgKqq0eHfI+Hz+WhqauKee+7h3nvv5ejRo1itVt566y1KSkpIS0vj0KFD7NmzB13XWbduHVdddVU0RjAajSiKgqqqxMfH4/P5qKySHDDTUSTmG/T7eoTf58MeaxrUAnzv/S9Q0XYeVTGQE19ATXs5/pAfAKc5hlhbIjXtZdHRyzaTnaXOFN5t/R57dYXNRXfizIknJT2DzdnXY7FY8Pv9OM/FE5+fzIL1SwiFQtETKiMjg+S5GbS2tLDoqmV4PeGTbe4VC7FZbRhNJtLmZ1FZWclC6zLsMXZCDP9L6mMf+xi6rrNz505SUlK48847p3WyDk3Xic9Ox2A2csPi+TidTjJ9PhYEg8TFxVFdVYXZbMbhdLI0dAUtzc3EZaYRsBrZkrONi3oppZ66yX4bwxa5+RXDZ1CMJM1VOWT+AWeq7QRWBKisrMSZ5eR43G7cdjevBV6jY1EHVquVusZa7GioMtNlFHTiDFZQLbTVNhPscJFmi8MRMkCnf7I3bkzccsst2O12AO666y7a29u54oorwvPMzGbmzJlDfX09a9euJTExkcTERM6ePUtsbCzXX389sbGxfOxjHyMQCOB0OnnhhRfIz89nw4YNOJ1OfD4fFouFmAQnL/zle5P8bseGoijk5OSgaRrt7e3ExMREgw6HwxHtqZxtVFXlrrvuwu/3s2rVKmJjY6M/H/3oR3G5XKxfv56EhAQefvhh4uPjyc7OJi4ujoSEBDRNw26388EPfhCHw0Fqaipnz57tmsvcNuj6Z7rux5zT6Ywec3a7fcBjTlFUElOX4XZVUnLqKcyWODpcFSiqgYvnXiAmLg8tFMDVdpGElCU01x8D4Morr6Surg6r1crChQuprq7GYrGE53n6/cTFxZGamorT6cRqtVJUVERsbCzbt2/HYDBQUVFBamoqdod9TPeDoijExAwhU7HmxWr08Pm/f4CExHDnSHK8iqZpZGRksHh+BvHx8VRXV2M2G5h3w3qqqqqIj4tHHcL1fbD7maDXR0F2Fk3NzSz94Aew2axUVVZht9txOp2EQiEMRiPpiQm0tLZy683biI2NIxgMsHzRAjpcHWzfej02g8rfPHA/KcnJxNpWYLPauPXm7ZgViLVaKCoqwtfhIujre3reYPvLiM7tN91ErMmIMzOdBMs67HY7dfX1LL3vXhITEynKzEBVVWx2G4on3KCycfUqjEYjc7MyiTUZ2b5lM36/n7SrriQrLbWPusBhkXnEs9lUiF8CHV48zUMbfRbwXDofAsHgiO/jR/TNGND8hPQQH1h0D3eteIh/fe1vOFN/hFRnFn9/9f/DYrDypVceIKgFUFC4Y9lfszH/Jj7/x7vwhjp5Pm4Pj83pKpoeabCy6nju8vBL++FLK4pkf9aA2K4fgJiun96iiX11WnCxhgXDel+Ri/YHPnB5+YDpxq6aqA24+UjVn1FRoJHwT0RD158een6Xl176qyvkZ4EtaVJbQocrctMnRmZ9/MdxGBLRI1MNLJCzYOmlJ0TOu66G2/x4sKtx5NlGNq991rMYQdNRvvQ8GFXigfjuvw+EwKiCafo2HPhDPjyGNqpdXT0/Cqhx4MOFT3NB132SMQGCdHKmqpK3d7+N0Wjk+tXX4zG2UdXeBlbACi69GUe6CVMieIxteLxdFzAvePEQ1MZmeN9ki7RoR+a4dRdpJJiddHJyM7r9K0B8ghPQiE9wdv0dQCM5JR6ApORwAq64+Mh3Q4iExBiam5o5dvwQRqORVauX4fKfnbB3MRWN5phTVRNrrv43hjJNze9r5/UXPgy6RmyMg9iYS0Ncc3O6rdcRzjKQk50ZfchmNQM6cXExnDx5kpMnT7Bs2RLi4mLQdQ1ljJLHqao68L2EooLqgPrfoDQ9TxpAdfhX0XfQAMkA5ZAbeawaCgBagZALrAUMVHexv21QVANGi4WDv/slpuefHOK7GplOj4cWq5WDikLA68EaF4/Sa6qaoih99+gqgNmC8fQxki6eB8AApHT9uvvg5uw+1h0pKBTZCz3m1OpAZ0e4Nm4vkgyOHpmnJ5pqMmKwmNjx//2Gd748tOMz0OHFkZGAhk5HpwfTCEc0jLjJ16iasJtj8AQ60bRw76jTEoc/6MVkMEdbSpZkrOVDi++lvqMaTQ8/b7Uyj4Xq9ssXOvJRDpdvHwZuVWZvJoi7kxZhVQ14tdENr7o6JhvzDMkyKgamKAoZloVkWMY29boYwNJs+Odt0Ozu/zkZ8ZCXPGGbNJYSbMlUtJbw8PO3MOwi5SF46eUBatr2OQpNJxAKROviiplFUYy0ul/nSOnY1T4tWBX+81z9NwmEmlAwoIwg/chsd6l3ZfDzXFFUFMVA8emnqSzdMar1JtugswHe+tMP6WgvJzVj7aiWN2SKFQp/BG1vjW45sRvDAfIwWePi2fz5r9BYPPGNManzF2F2DLHurmqAD90F506NT1keoxFWTNBnLoYsNjeZm3/1dzSdHt5w8fQrCmkPeNA0fcR5foYd2EYuWb6gh6eP/B/LM9dFf3eh6RR/OPkYH13xMACJ9lT+Zt2/cLR6L9lxeSTZ06hxlbNam8e9gYnpFfXim5D1TDU2FD4eO7we6/74/DNjOKQQU9J18wd/TijACGZXTLpbF/0VeXELCenBCVunSTWzMutKvL7Zee2fydJjvkid/gQjTV45GKMRYpxr0UIJeDU5fsaLrpuZu+yT1FfvG9Pl2mMKyZ9368Tds5iXQ8ry0S9nhNubsngFKX30Vk6EYe3jpFTYMIIanMMh1/spJ+fGZeTcuGxoT9bB4/XS0taG2+PD7rCP/1DkYS9egWUZ60i0p5BkTyXBnswnN3yZ/3rr87S2uyitmEKTvqfTWNux0OOeoNebn4b7QtPCmbrV8cyQN1FTNSZj/8/uaShinGUZl0z4OmtrWwmP9RMTY6IuInMx82/jugZfB5R1TL/cEtOOeTnJeX0HhUPPwXy5dh+0T6X7ywH0fp9D+fqXr+vZp6/jor/jYBrewgNd70cPD5+2W63RZGEjCW6HHNj2vxOVHpmrFC5tyO6Lr3KochdFyUu4f+3n+e6uL+EJuDGajFgdk1Chsa83MV2PgmllfHayoiioqIRCIXRdw2iU+o5CCDG55NZbjN5gR9FUunUbiyN+OO9HzrDZY6DjYjqdI0OhKOqYVDgY+lDkrnXUuSto9zYD4QzJvz/6U2q6pW4vby3muWO/QNNC6Oi0+1opbjzJU4d/RLs3XD5mV/lLnGwY2yEoYvbJjMnngdVfwmK2oWs6xlEWDxezkNwhCDHG5KQSY28kvZsTZbRH/Ejei5xlM99Y9eBPpXOlP71LAI0msFX0IebDbmwPp2t+5ezj/PbQt1mdvQWzYSxqcAkxfC2eRk7X7+c/tj5JXtwCdF3HaJIseGKE5C5BiHEiJ5eY2UZzhI8m6JAza2Yb6rExnONgqge5AwW0yXFDyzA87ORROjpWk4O/XvNV4m3TM1OnmP6O177HmfoDhEfCR1p4+nrmVD+NJ8BMadITQkwzOnJxETNd9yN8JMHmSHts5cyauYYT1I70OJipx8/srPAuZqD+vk7k8h99+wN94860yRrDNZR9JIQYpt4XDjnBxMw2nEQ//T1/qOuRs2lmGs4xMZpbl+6vmUm3eCMq9xP5EVPIRGcvmHS9a+YNdzbCtHqzk2+2tA9IgCvEOOrZtyVX5PE1k4YozjQj3d/y1TTzRT7j4Qa4ozk2RrLOqWpU5X6kLXaGuewuY7oc4pFTerR5BafL+x2h0QZts2lIswS4QoyLS6dUz5NstrSdTVWy/8fPeCeHGs/Pbbp/BU7EMT1e+2i4JX1GOyQ+8rrpfh0Y06HIw+oz03W0YAA9GBz4eWLkRroTJymoVVQV1WSGEdauEkM0nkHbTAt+ZbyXEGOm71Pp0kk2E26qppLhXupnUq/NdDRR83PF9DaUDOGjHaI8nY+rMQ1sIwmWBwxKdJ2Qz0vjzldo3vMawZYmdF0by80Q05KCanPgnL+M1G13YcvIGYfgdrAoZaaVvB7EZPVKTrfdLL23QozawKePBLfjaSQB7lT5DKZC+oeJyHo83HVMlc9nqpuIMlGT3f490Huc7G2bDGMS2Oq6TqipDs/uV3Dc+BEUm6Pf52p+H+WPPUrTW39EtTkwxSehqoax2AwxzQVdrTS+/jyuE/sp+Pw3sWcXTEJw25fpdFkYwf4ai/Ers4EEuEKMIwlux9t0ucmdDts4meTcGLnxaiiZSufWbB95MSaBbaixFvefHidYVYrj+jv6fZ6u67Qe30/zOy/jnLuUuZ/8Z2Ky8ySwFYCOz9VO2Z+eovqFX1Pz4mMUfOpfUQxqr+eNxak6lS5BY22Ul7TZeiUcjpl8+Mwis3CW/aQaWvuZnFzjTfbw0EzVfSTXqPE1VT/3keh+NzhV5mxPhDEJbA2JqcTc/Wnafv6tQZ/bdmwfaBr5d32C1AVLgUGGLotZQdd1LHYHcz/8IC1738Z95ghBdzvm2PjezxyjNc70r3fp8xi2WZdZfBim86kyXmMBxYgNfPWd6dfmyTdTL1PT2VQ96qfqdomhi9wNToVh/ROhd3fYiCgGA4phaDFyyNWKYjIRkzUn/FoJagXh40BRFCzOWKxJKWheD3qo78RiY7jWcV7+ZNO7/YgJMVN3+XSu8dbPZ6H0/pnO73Eaumz/9/iRD2M2m6yykmN9+R7u9g/2/Mk6I+RsnP5mS1ALYxTYDosebjtQVFWCWtG3CT0uZssxONMirWlgJu7y2XCHMxve47QhH4QYf1OpLXIopVyEEP0b06zIQky8qfJ1NB1cVqhYdDceyaFm6kTO6ZZIazIq3osxIh/ERJpq3xKTXZ1upMZy301Gz7WYXWbSrcrYBbaqAect96BY7WO2SCH6p/fx98u/knVdJxgIMLRL9Wy4nE/XS9Ukm6yxadPNVD+FRrv/p/r7m9Fk50+E2ZZRdape2ic7S4acbbNHX41H43HsqaoB1Tj+/aljtgZFVTHNmTtWixNimHpfhvXwf5qGQQ8R4+y/BJUQQgghhBBi7Om6TnObC8t0CmyFmJp0TCYTNpttsjdECCGEEEKIWUXTNBRXx4Ssa+KTRwkx4WRQjRBCCCGEEDOZBLZi5potk4SEEEIIIYSYoibqllwCWyGEEEIIIYQQ05oEtkIIIYQQQgghpjUJbIUQQgghhBBCjIuJynYjga0QQgghhBBCiGlNAlsxLUleKCGEEEIIIUSE1LEVU5bC4AGsBLhCCCGEEEIICWzFtKcQHrvfV5A7lOBYCCGEEEIIMb3JUGQhhBBCCCGEENOaBLZCCCGEEEIIIaY1CWyFEEIIIYQQQkxrEtgKIYQQQgghhJjWJLAVQgghhBBCCDGtSWArhBBCCCGEEGJak8BWCCGEEEIIIcS0JoGtEEIIIYQQQohpTQJbIYQQQgghhBDTmgS2QgghhBBCCCGmNeOQn6kP8pgy6m0RQgghhBBCCCGGbeiBbURfAW7vxyXIFUIIIYQQQggxQYYf2HZR+gtwoe/gV4JdIYQQQgghhBDjYMhzbJVuP90fE0IIIYQQQgghJtOIe2wjuge3A3Xiog/2BCGEEEIIIYQQYviGEdgOlj2q7x7cnlNvJbIVQgghhBBCCDG2RtFjO7Qgdcg9ukJcpns3vwx8F0IIIYQQQvRN6tgKIYQQQgghhJjWJLAV04RM0hZCCCGEEEL0TQJbMc1IcCuEEEIIIYToSQJbMQ1JcCuEEEIIIYS4RAJbIYQQQgghhBDTmgS2QgghhBBCCCGmNQlshRBCCCGEEEJMaxLYCiGEEEIIIYSY1iSwFUIIIYQQQggxrUlgK6Y5qW8rhBBCCCHEbCeBrZhBJMAVQgghhBBiNpLAVswwEtwKIYQQQggx20hgK2YIvZ+/CyGEEEIIIWY6CWzFDCXBrRBCCCGEELOFBLZiBpPgVgghhBBCiNlAAlshhBBCCCGEENOaBLZCCCGEEEIIIaY1CWzFDCfDkYUQQgghhJhMOuN/Vy6BrZi6JuIMEEIIIYQQQkwInfG7xTeOwzKFGFsS3AohhBBCCCEGIIGtEEIIIYQQQogJ1bvvShnl8iSwFVNa7wNc7/UXpftYBunZFUIIIYQQYlob6S29BLZiWlF6/Rl9XIJaIYQQQgghZi0JbMWM0Wfvrt7HL4QQQgghhBBThsLoB19KVmQxYylITCuEEEIIIcRsIIGtEEIIIYQQQohJMxazCiWwFUIIIYQQQggxrUlgK4QQQgghhBBiHHUvZTI+JHmUEEIIIYQQQogpZPhBsAS2QgghhBBCCCEmUH+B68hTv0pgK4QQQgghhBBifEVrcXYzhiVMJLAVQgghhBBCCDHxLuu47XpA6e/3/ZPkUUIIIYQQQgghxsdI8kaNIM+UBLZCCCGEEEIIIaaWYQa3EtgKIYQQQgghhJjWJLAVQgghhBBCCDGtSWArhBBCCCGEEGJaG3FgO4aZmYUQQgghhBBCiBEbcrmfvgLZ7o+NIHGVEEIIIYQQQggxamNWx7Z34CuBrhCzj67r1NTUYLFYLvudoijo+vCuDP29Zqwel3XLuidy3aFQCIPBMKnbIOuWdcu6Zd2zfd0ANpsNu90+rOWJqW/MAtveFC4PbhVAMZpACxFwu9B1HUWRQc3iEi0UIuTzgqrKsTEN6bqOpmk4nc7LfjfQl1XktUN5fLBlDfdxWbese6LWrWkaqqpOyLr6Wsds2Meyblm3rFvWPdiygsEgbrdbAtsZaBiBrd7rz95/v1xfvbi2OXNp2fUKdbtfJ65gAapx3GJrMd3oOq1njtFZfgFTejaqVS4405HJZOqzx1YIIYQQYrKpqorH45nszRDjYMKjysS1m2jY8Qcq/vA4ntpK4uYtQR1gaJaYHXTA01BL/a7XCPm9pF9/O0aLdbI3SwghhBBCCDENDCOwVXr9OXyKAvbUDOZ88l+o+O33qH/vLep3vTbi5YkZRlVR45JI+cgnSb3q+sneGjFCw50DI4QQQgghxGhNyjjgxPlLsf/z/+AqPU+gvWWW3gjL/NHeVIsVR04BjtQMVJljK4QQQgghhBiiUQa2w8+FHAlWrDGxWJeuHt3qp72e+282hvf9kaBWCCGEEEKMNV3XZ2mn2sw3xj22Q69sK4HLJZE9pXT7vxBCCCGEEEKIoRnHochDD3JnM9kzYqaRRishhBBCTFWKosi9ygw1ruV+xMD6qLg1CVshhBBCCCGEENPbKHpsJagdOxLQCiGEEEIIIcRIjSKwlWBs7PRuJJB9K6YvScgghBBCCCEm2qSU+xGD6SswkGBXCCGEEEKI0ZAG+Mky/vtdhiJPor5C1fHfqxP5uUkwLoQQQgghphYJbifaxOxv6bGdYgYLBfVu/5/6hrKdEvzONJJpUAghhBBTlWRFnrkksJ2y+j7h+jsNp0uoK4QQQgghhBBjTQLbaSYcwPYOb6dzWDvYtkuLmhBCCCGEEGJgEthOWXqvfw0U4E3ObN2JMVPex+wh81aEEEIIIcREk8B2WpLAQfaBEEIIIYQQIkIC22lHArrL6b3+FEIIIYQQ4nK6rsvoshlKAtspT+n2/zA5FbsbbG/oyDxdIYQQQggRIVmRZyYJbKe87oGbAih9hGm6BLtiypAvCyGEEEJMVXKfMnNJYDut9A5y+/uX9OoKIYQQQgghZg8JbKetgUPXmZwneXikVW6iybwVIYQQQgjRwwTcHg49sO1rY2bj/es0jpOkV1cIIYQQQggxoSYo6Bh+j+1sj4b6ev/TNNidiM2e/MNFkkcJIYQQQogwyYo89YzVpyFDkcfCYJ/GLI6rpJdYCCGEEEII0ZexjA0ksJ0IExHNTZPgub/NHM0umiZvfdaQbINCCCGEmKoURZF7lSlgPMIjCWzFpBirg1kuS0IIIYQQQkxtE9HPp07AOoToYSwPbL3Xn2LyybwVIYQQQggx0SSwnSlmcSwxi9+6EEIIIYQQU9pE3avLUOSZZKCjZgqN2R1oU0Zy4E+htyaEEEIIIaYwyYo8c0lgK6aUSJA61MuNBLVCCCGEEELMBKNrcJDAdrYb6warCY40pb1t6pFMg0IIIYSYqiQr8lQ0Nnf0EtiKsTUJw6H1QVYrhBBCCCGEmArG765dAtvZovsxNFmNVOMU9EqbmxBCCCGEEFPd+HZFSWA7G02D7s2hBqtKr79Pg7c240lCBiGEEEII0dP43x9KYCumhgGOdR2GFOlKOCWEEEIIIcTsJIGtmFBjHXxKMCuEEEIIIYZKyv3MXBLYiqllBBNmJXmUEEIIIYQYCsmKPHNJYCsmVH+XEf2yvwxzAWLKkC8LIYQQQggx0SSwFVPCYKHQQIGv0v13ElMJIYQQQggx60hgK6aUIQ8p7nqiEhmHLGORpwyZtyKEEEIIISaaBLZieurqmdWV8N+HmjlZCCGEEEIIMfMMI7DtqxdmvHtmJFIRg7tsmLIcNkIIIYQQog+SFXnmGkGPrd7rz/EkkyZnm4E+bb2vf+jdhiP3+UQhhBBCCCHETCdDkYHhRUISaE+Wvva8fBpTj2RFFkIIIcRUJeV+JskEdDxNg8B2KHtBDk7RD+m9FUIIIYQQYsabBoHtWJIoR4jxJvNWhBBCCCHERJshge1EZg0ayU279CiPRH97WvamEEIIIYQQojt1+C9Rev0pxMSS/kAhhBBCCDESkhV55priWZGHq/s2TaXAW+rQCCGEEEIIIcR4mSFDkcVMJM0A05NkGhRCCCHEVCVZkWeuGRzYTsUeZTEcw/0E5RIlhBBCCCHE1DcekdoMDmynIp2xC79keHNv0pQhhBBCCCHE7CSB7YQbavg1lgHr9KwFPPW2SAyFJGQQQgghhBDDN7p7SAlsp6yhfrDjkTBrehbamdpbJ4QQQgghJptkRZ4cE7HHhx7Y9t4avY/H+iMRxyRTGPjDkg9ICCGEEEIIMX1NTI/tVGgUmRWx21jNu+0rEJ4VO1CMAck0KIQQQoipSrIiT4bh9IiOnDruaxBCCCGEEEIIIcbR7AlsJ6ahYIro641Ky5QQQgghhBBiZpp9yaPGY17wWATMYx53jnajBpuXK0TfJCGDEEIIIYSYaLOnx3a45N58UunMsk52IYQQQgghxIjNvh7b4ZjIqGqs8j6NauVCCCGEEELMXFLuZ+aSwHaqGe55NmGB8MTWdpIZwUIIIYQQYqxJVuSZSwLb6W7KBcJS3Hi2ky8LIYQQQggx0SSwFZNER4JbIYQQQgghZoEJGP0tge1sM6V6eCd1YrEYJzJvRQghhBBCTDQJbMXIdY9fJDYVQgghhBBC9DZBfR4S2IqB9XUgjmEQq/e7kt6rlMhZCCGEEEKMjmRFnrkksBXD119Prd71K+XyX41+lX0PW9Z7PEOXAFgIIYQQQohZSAJbMTr95YAaIPi9zJj2AMu83ckmWZGFEEIIMVVJuZ/JMv6JYyWwFaPXLVhVuv17sEEefR7ag76o5xP6Pz0k67IQQgghhBCTT+/1J4zHfboEtmL8DRasDneag37pRZH/d3sICM/J1Ye9YDEWZN6KEEIIIYQY2NgHuRLYikkzovAn+iKlx/97nw4S1AohhBBCCDEdjM19uwS2YliGc9gpw3z+SFzqsZVAVgghhBBCDEyyIs9cEtiKQY301J/IS4bS38rkuiWEEEIIIcSMp072BggxMt0yVA0UvEr+qAknmQaFEEIIMVVJVuSZSwJbMSiFqR0fDhzbSpetEEIIIYQQM90whiL3FSBMVNAwlcMqMaVJXCuEEEIIIcSMN016bCU6Ga7BRugKMV4kIYMQQgghhJhokjxqGouEDwP1Z+uD/L77coQQQgghhJjJJCvyzDVNemxlKHJvcjoKIYQQQgghRNg06bEdShgnwW93sjfEZJFMg0IIIYSYqiQr8sw1TQLbMTaUMbxT3FhuevdlSU+wEEIIIYQQYroZemA7mUmRLzONI9IBjHZ3jnavSFArhBBCCCGEmI6G32Or9/pzNujrvY5BbD3Wu3C4y5uZzQNisklChtlHD4VgOJ+7wSDDwIQQQojZZAJuD6fpUOSB9swwbpYm6v57lIHxeA4VlhBECDFavkf/k8Cbr6A4HGC2gKahu9pRLBaw2MIXMU1D72gHgxH7I7/EkFc42ZsthBBCiAkz/l1w0zSwHY6xCN2GuGOHuSpliC8Zr+BTglohxFgIlZagXTyP/Se/R01IQvd04vnqP2C85Q5MV24BRQWHA8+/fpbgrh3g7ZzsTRZCCDFLSbmfmWsGBrZjd6AOuKRevxzpoLr+XienmxBiOlESklAzsgm89HtCp48TOn8a7fvfwv+L76POX4L1H/8foVPHJnszhRBCzHKSFXmqG/lnMwMD25EZeiA5vNJD/T5bKhiJGUq+LGYnJS4eFDAsWYHp5jtQ4uLxP/5T9JYmLH/zWQIvP4teXQkWy2RvqhBCCCFmIHWyN2Ay6d1+xuqZw3/2EBc0lB8hhJgkobMn6bj7JtwP3or3x9/BdNvdYLag5s/FsHoD/uefQC5UQgghhOjf6DpHZnVgO1IKl+92HaVbfDnFok4JisUEknkrs5Pxmhuw/tN/oC5ajnHZGvT6GtB1zB+5n+CuN9Cryid7E4UQQggxpY0uUJGhyEMUCWT7370jvZkf7HWDtFwMvmFCCDFu9GAAOtoJHT+E6abbsH/zh2iV5Xj/59/AoILVhv/XP7pUDigUxP/kL1BS0yd1u4UQojvFasN0xz2oCUmTvSlCiBGaNYHtaGO+sY0Zx2Jpeh+LGmb3ffe0zL03SaZJCiGGIHT6OIF3/oJiteH9ry+jWCzofj8EAyhxCfh+/D+gaShpGdHX+F/6/SRusRBC9KLp6M2N6AE/1of/cbK3RowzyYo8c83YwHZqHq4j2apxfCdTcycJIaYTvw9CIeyP/hrDmisne2uEEGL4Otpx3boJOt2TvSVCiFGYUYHt1IzTIt2iQ926oVa3HUxfyxhGN2x/myA9uWIQkhV5dlKcsajxiZO9GUIIMWy6agBV0s7MFlLuZ+YacmDbV5wzNQPJqWa4e2k0e1U+ESGEEEIIIcTUMhFRyoh7bCWEmqX6/OD1rp5caf0SkhVZDF/vY0Za0oUQQggxXDNqKLLoT/ebxFEOUb6MBDFCiOHRNA232015eTlnz56lqqoKl8sFQGxsLFlZWcydO5c5c+bgdDqHHOhqmkZJSQl+vx8As9lMfn4+RmPfX3WaplFZWUldXR2ZmZlkZGSgTuBwRF3XKS8vp6OjAwBVVSksLMRsNk/YNojR0TSNsrIyOjs7gcGPuZEsv7S0FI/HE11+QUEBBoNhTJY/FLqu09jYSFlZGfHx8eTl5Y3Z+9N1naqqKtra2oBwo1ZeXh52u31Mli+EmF0ksJ0VxmM4dK8bzZHGt9IxI8SsEQqFOH36NE888QQvv/wyFy9exOPxEAqFejzPYDBgt9spKipi27Zt3H333SxYsGDQm/nOzk5uv/12iouLASgqKuKdd94hMfHyub+6rvP888/z2c9+loaGBjIyMvjhD3/I9u3bJ6zHOBQK8fd///e8/vrrACQkJLB3715ycnImZP1i9AKBAH/zN3/Dnj17ACgsLGTnzp19HnMj4ff7eeCBB9i/fz8A8+bNY/fu3cTExIzJ8ofi8OHD3HfffRQXF+N0OvniF7/I5z73uTEJrjVN42tf+xpPPvkkABaLhddff521a9eOetlC9EeyIk+OifhmlZnys5rC5b25wz3RFS5fzjD0V4d55LWZxSSTLwvRl9bWVr72ta+xZcsWvvWtb3H8+HE6OjouC2ohHPC5XC4OHz7MN77xDTZv3sxXv/pVmpqaBl2Pz+fD6/VGf/rj9Xr57ne/S1VVFX6/n7KyMh599FECgcCo3udw+f3+6LZ6PB40TZvQ9YvR637M+Xy+Mb8G9j6mJ/Iaq+s6v/rVrzh58iQ+n4+mpia+973v0dDQMGbrCAQCPc4B+Q4RQoyU9NjOWoMNT+7vuZNIvuumhbEaoiZmBl3XcbvdfOMb3+CRRx7pM5A1Go2YzWYURSEQCESHEkc0NjbyX//1X3R0dPCNb3wDp9M5pHUP1POqaVp0eGeE2+2eNYFlf8GDzG+e2fr63Af7zCPDrCN8Pt9l5+holj/S5woxGtKAMjPJHeisNdITeooEwXI9mrL6ClzE7OVyufjCF77AL3/5yx7HRlxcHNdccw1bt25l0aJFJCQkYDQaaWlp4cyZM7z22mvs2LEjOvdO0zR+9KMfEQqF+O///u9Rz8Gz2Wzcdttt0Z4om83GXXfdNWvmt7a1tfHkk09Ge7Vzc3O5/fbbJbCY4SorK3nuueeiDTgrVqxgy5Yt/X7uiqLwwQ9+kOeee462tjaMRiPbtm0jPT39sufqus6hQ4d45513oq+9+eabmTdv3rC2UY5BMRHkOJuZJLAVAxhOr25vkxgAS9A7qeTLQkQEAgH+8z//s0dQq6oqW7Zs4etf/zqrVq3CZDJddsxs3LiRBx98kMOHD/O1r32Nv/zlL2iaRigU4qc//Slz5szhC1/4Qp+Jnnovq7/jUVVVvvCFL7By5UqKi4tZtGgR11xzzYQmj5pMDQ0NfPnLX6a1tRWAa6+9lttuu21yN0qMu+LiYr7whS9Ez8dPfepTbN68ecDr9s0338wrr7zC/v37ycjI4IYbbsBkMvX53LfffpsvfOEL0X9nZWUNO7AVYrxJHdvJMaXL/YiZbDQB7UhfMwYkoBViytB1nT//+c/84Ac/6BHU3nvvvTzyyCMkJCQM2EtkMplYu3Ytv/vd7/j85z/Pr3/9a3RdJxgM8p3vfIdt27axZMmSUd2cWK1Wtm/fHl2nEMM1G5LQGI1GNmzYwIYNGyZ7U4QQ09REXSVnR9O0GKbRZGwazRDnURz2M/u+Qohpp7W1lW984xs95uddf/31PPLIIyQmJg4pkFQUhfj4eL71rW+xatWq6OMNDQ385je/GXQ+31DXIUGtGI3ZMi97osj5KMTMM1FntQS2YoKNNhNzH8+XoHZKmem9F2Jwuq7z0ksvcfDgwehjSUlJfP3rXychIWHYy0tJSeGzn/1sj/Iir776arT27WTRdR1N0wgGgwSDQUKh0Kw8/rvvh0AgQDAYRNO0CdsXkV7T7usfi8+ir+X29b5GGthO9n6bikYa1Mq+FGLqU/SR/wyVDEUWE2ygo3OgLzT5chJiuvD7/Tz11FM9kkXdeuutrFy5ckQ3roqisGnTJlJSUqitrQWgrKyM0tJSli9fPqJt1HWdI0eOsHv37uhjN9xwA/Pnzx/0dT6fj+PHj/P2229z/PhxGhoaCIVCxMfHU1hYyPr169mwYQMpKSlj2vuk6zrFxcW8/vrr+P1+gsEgFouFu+++m6SkpEFf++KLL1JWVgaEe719Pl/09xUVFXzve9/rsb2qqvKRj3yk30RBoVCI8+fPs2PHDvbv309FRQVerxe73U5ubi5r167l2muvpbCwEIPBMOY9cZqmUVFRwa5duzhw4AAlJSW4XC4MBgNxcXEUFBRwxRVXcM0115Camjrk9eu6jsvlYvfu3bz++uucPn0al8sVra184403cu211xITEzOioci6rtPW1sauXbt4/fXXOXv2LB0dHdjtdubPn89NN93E5s2bcTgcI9ktPfh8Pp566ilaWlqA8Bzb7tt79OhRHn300R77xm6387GPfSxaK7e8vJyXXnopGsAvWrSIa6+9FkVRaGho6HGu79q1q8f6X3nlFaqrq3s8lp2dze233z7q+eyRY7C4uJi33nqLgwcPUl1djdvtxm63k5eXx/r169myZQvZ2dmzZv68GJw0eEwCPfq/cTW9A9vx2D8yAmaKGfqHrEvwK8SUUF5ezt69e6P/tlgsfPzjH+/R4zpcqampbN26lbNnz6LrOqqq9tljO5zg6e233+bzn/989HVPPvnkgIFtKBRiz549fPOb32TXrl243e4+n2cwGCgoKODhhx/mE5/4BE6nc9RBna7r1NTU8OCDD/Luu++i6zpms5mvfe1rxMXFDen1P/3pT3n11Vf7/P358+ej+yLCYrGwYcOGywJbXdcpLy/nm9/8Js888wwtLS193ij++te/JjExkdtuu40vfelL5OXljUlwq+s69fX1fOc73+GJJ56gtra23xtVg8FAfn4+//iP/8h9992H1WodcNmaprFz506++tWvsnfv3svqGr/xxhv8/Oc/Z8OGDfz3f/83S5cuHVaPbSgU4q233uJLX/oShw8fJhgMXrb8n/70p2zcuJH//u//ZtGiRUNedl98Ph/f/va3OXXqVJ+/37NnD3v27OnxWHp6Otu3b48GtpFjI1Li56GHHuLaa68FoLq6mi9+8YuXlQSK+PWvf33ZY1u2bOHWW2/tN9AcyjGi6zoVFRV861vf4umnn+73GPzJT35CVlYWn/jEJ/jMZz5DXFycDHUWgAS3E2443a6jMPTAtvf2jHJK5LQXee9yfRxDQz2ghr7TZ/MhOlnkpkEcPnw4mm0XYM6cOSxfvnxUx4bFYuFnP/tZjyCid2bW0Sx/sJucYDDIz372M7785S9He796rzeyjEhP5j/+4z/y3nvv8YMf/GBUvbeRHr5Pf/rT0aBWVVU+8YlP8LnPfW5Ca0dHSro8+OCDHD9+vMfvFEXBYDBEhwHruk5TUxM///nP2bNnDz/5yU+4+uqrR/05VVZWcu+997Jz584en5vVasVqtaLrOp2dnQQCgWiP3t///d9TXV3NV77ylX73l/b/t3fn8U3UifvAn5mmdymllLuA3KfAIiwgh4oLokUOBURwwUVRvABvcUUFUdfji/0tIoIiigqIsoqACggqIvd9yn0fhbbQu2mO+f1RMzRpjkkySWaS570vtzSdfObIJJlnPpfVimXLlmHs2LG4fPlypX0TBEFu7vr7779j6NChmDt3ruJga7Va8fXXX+Oxxx5Dbm6uy/JNJhPWrl2LYcOGYd68eao0qfZ3+YqPOf5djfK9ff6ePXtw//33Y9euXfLjgiAgJiYGUVFRMJvNKCsrk8+XqVOnYtu2bZg9ezbq1KnD76kIx7EVQkAKzvHWd41toDEVueTvZD4Vn+/dqe5qaedbxI8touCyBZ+KF/tt27ZVVKvojiAIiI2NVbSc2iRJwoIFC/Dss8/KtbSiKKJ169a4++670bp1axgMBpw+fRo//vgjfvvtNxiNRlgsFnzzzTeoWrUq3n//fUXb74zRaMTUqVOxdOlSSJIEQRAwaNAgvPHGG4iPj1dcTq9eveTXoaCgAKtXr5ZrJGvWrFlp2pfo6GikpqbaHYdTp05h9OjR2L9/v/x4w4YNMWzYMHTu3BnJycnIy8vDtm3b8L///Q/Hjh0DABw8eBCjR4/GsmXL0Lp1a59fp7KyMkyePFmeKxUon1LmgQcewO233466devCarXi6NGj+Oyzz/D111/DaDSirKwM7733Hm655Rb06tWr0volScLBgwfxxBNP2IXaunXrYujQoejSpQvi4+Nx7tw5rFmzBqtXr8aZM2fwyCOPuKytdCx/x44dePLJJ+1CbYMGDTBkyBB07twZsbGxOHPmDFatWoVffvkFx44dw7hx41y2DFDCNu9su3btAACXLl3Cr7/+KofLpk2b4oYbbrB7TkpKiuJ5olNSUjBkyBC5NvfQoUN2YfPGG29E/fr17Z7TunVrn5sF24JqxVAbFRWFLl26YNSoUWjfvj3i4+NRUFCADRs2YN68eTh06BCsVitWrFiBp59+GnPnzvV7Hmwi8pbWamw1UWUbhJjCMOuRL71k/TustlKdnXP2jwkO/+LLSRRcVqtVDjM2rVq10m3/NkmScPjwYUyePFkOGNHR0ZgwYQKef/55VK9e3a7G9uGHH8ZXX32FJ598ElevXoUkSfjyyy8xfPhw3HrrrV6v32w247///S9mzpwp3yzo1q0bZsyYgeTkZMXlCIKAF154QQ40R48eRZcuXeSa9bZt2+LLL7+s9DpVDIBmsxlTp061C7W33norPvzwQzRp0sRu2aFDh+Kxxx7DxIkT5UB+4sQJvPDCC/jqq698DhY7d+7EkiVL5N+bN2+ORYsWoX379nbbft1116Fnz55o1qwZpkyZAqvVivz8fMydOxc9evSo1CzebDbjzTffxJkzZ+TH/v73v+Pjjz9GmzZt7MoeO3Ys1qxZg4kTJ+Lw4cOKtttoNOKNN96Q+4gD5TcaZs+ejebNm8vl286hlStXYuLEiS6bECsVHx+Pd955R/79119/xbp16+Q+sX379q3Ut9qbmw4NGjSwa248ffp0u2A7YcIEDBkyxO457sr3VJNmsVjw5ptvYvfu3QDKg/v48ePx8ssvIzk52e653bt3x7333ovHHnsMy5YtgyRJWLJkCTIyMjBy5EjW2BGFIR+uNMIhKkgO/wWgyACsIpR83RVfxzy2/8/2P/cE+f8Fxc8h9bHfSmQzmUx2F+9A+cWvXkmShPfffx+nT5+WH7v33nsxdepUpKWlVQoE8fHx+Oc//4lJkybJYaWkpARfffWV3WBaSlitVixZsgSvvfaaXCPWokULfPTRR143p7QFBlEUIYpipec6/t3Zctu3b7cLlU2bNnUaam3lNWjQAB988IHdVE2rV6/Gzz//7NPnhCRJ+Pnnn1FYWAigvKbuhRdeQIcOHZzeOImNjcW4cePQpEkT+bGNGzciLy+v0rIHDhzAihUr5N9r1KiBDz74AG3btq1UdkxMDPr164cvvviiUm2kq+3euXMnVq9eLT9Wr149zJw5Ey1atLAr39Yy4c4778T8+fNRp04dj+W74/iaOr5Ojq+3bRml55bjOaV2+Y4OHjyIxYsXy+dPnz59MGXKFKd9ZwVBQHp6OqZPn47rrrsOQPnn0+zZsxXVshOR/ujzFrpfVL7o9me6VxXDr1oZ2ttcLjj851iWO84m/lG6jc4aM1cMwd6XSkRqsFqtdheNoihWqkkJJLXXc/HiRXz//ffy7zVq1MCzzz7rdhCiqKgojBgxAnXr1pUf27ZtG0pLSxWvV5IkrFu3DhMmTJCDXJ06dfDxxx+jVatWqu+np/IkScLixYuRn58vL//oo486DbUVy6xduzaeeeYZuV+r0WjE559/7nXIt21DxRrMlJQUp82KK0pLS5Ob4QJAdnZ2pT7SkiThxx9/tOsXPmTIEHTo0MHtvnXq1AlTp06t1NfbmeXLl8uvIwCMHDnSbZNsQRBw4403YtKkSX4NuuasXHe/a5kkSVi6dClycnIAlN+4mDBhgtvRowVBQOPGjXHPPffIj+3cuROHDh0K+PYSUfDpKNj68+GrgarTAFcS+7IJamRrX8qqGGh9Wb7yT9bMEmmFJEly7SJQfmGp5MJfq3bs2GE3XUmPHj3QokULj4GgRo0a6NmzJ1q1aoWWLVsiOTlZcV9JW4B76KGHkJWVBQBITk5GZmYmunfvHpAw4qnMoqIi/PLLL/Lvqamp6N+/v8fnCYKAW265BfXq1ZMf27hxIy5duuT1NkqSJE+H069fP9xxxx12fYBdrb9WrVry72azudLrYBvt2iYmJgaDBw/22HxeEAQMGDDAY62tyWTChg0b5N/j4uIwcOBAj+WLooghQ4bY3SDxl2NtqRaCrdKwXVZWhrVr18q/X3fddejcubPHfRBFEbfeeqt8c6W4uBjbt29n66II5ss0XaQPOhk8yt9Qq0Z5apUTOHqYBdaXGloly2rrlSCKXKIo2g2S5Bh09USSJGzfvl2ekkUQBNx0002KRiGOiYnB3Llz7WomlfYrPX/+PMaOHYsjR44AKA9C06ZNw9133x2wIOKp3PPnz8tz4AJAkyZNkJ6erqhsW61pxTl0Dx8+7HVgE0URL730knxBamsG64nj+ehYW1xYWCgfa6A8tCutFY+NjUVMTIzbZfLz83H8+HH595o1a6JZs2YeywbKzyNfBx3TI3fHPDc31+51at68ueJ+5unp6UhMTEReXh4kSWKNLWnipg6pTyfBNtSxzLtGsu4pmZ9N4eoUFBfqI+dI6fYIqFw7S/rAL4vIJoqiXdNAq9UqzzEZjHNDzXVYrVa7QCKKoqLaWtt2eDNisU1eXh5efvllbNy4EUB5s+bHH38cDz/8sKpNUh152qesrCy7prSNGjXyGOhsRFFEq1atsGzZMgDlNW8VQ7I321jxGNgCbllZGQoKCnDlyhVkZ2cjNzcX+fn5yM/PR1FREbZs2eK23Pz8fLuRimvUqIFq1ap5vX2u5Obm2vXrrVOnjjxHbLDp+fP58uXLds3IDx06hIceekjRPhUWFtp1BcjKygraZxJpD1/38KWTYKsWb09kNesUFSzta4KT3Dxdp+9dbwIwEWmHwWCwa3YKwKcQowWSJCE7O1v+3WAwoHr16gFbn9lsxuTJk7F8+XL5scGDB+Pll18OeHNuTxd6OTk5djWdtWrV8mqka8dBkBznifWGJEkoKSnB9u3b8eOPP2Ljxo04ceIErly5AqPRCJPJ5HZuWccmiCUlJXb9wlNTU1WdG7igoECeVgko7xscyub5WruoV9oUOT8/H0ajUf798OHDikeldsTBo4jCU4QFWzXq/nxtTFv+XKVj+yrmqTjJ+yL1iLW62sF+K5FNFEU0bdrU7rF9+/bBYrH4FRZs51XF88vZ6KpqXrRLkmRXy2MwGALaLNRqteLSpUt2oSw3NxelpaVISkoK2HoBz8etpKTE7neltbW2sh1rrx3LU8pqtWLTpk2YMmUK1q1bV2lALoPBgMTERLmJcHR0NK5cuSIPeuXs86msrMzu8ZiYGFXPI8egrXb53tB6qHWnYqi1PdfXVgx6nX6MiNyLsGDrL3+/EEJwwa+k4622vue8wghFpC2CIKBz584wGAxy39T9+/cjJyfHbhAfb1mtVkydOhW7d++WB/4YM2YMBg0apNKWV+Y48JUkSW5rAv0VExOD6dOnY8KECdi6dSsA4JdffsFTTz2FWbNmqR5uvRlEyDHIejOqsSRJdjWWzspTWs63336LcePGyTXpgiCgTp066NWrF7p3747WrVujVq1aSElJQXx8PARBwFNPPWU316pjuHUMRxaLRdUbdI7T7ATyHPJEa8EWUL5NsbGxdssOGTIEjz32mKIBzBxVnH+aiMIHg61X/P+i8+Zj1O+1OQ4lTEQUBO3bt0daWpo8n+25c+ewadMmDBgwwOeLyZKSEnz33XfYs2cPgPIwMnbsWNW22RlBEOwGpzGZTHb9TAOhXr16+OijjzB48GCcOHECkiRh4cKFaNy4MV566SXVmrC6msfWFcd5Qr3tN22bosXGlz6sZ8+exfPPPy+H2ujoaDz44IN45pln0KBBA0RFRVXaHkmSPIbo2NhYu+NaWFioaviMi4uzC8+FhYWwWCysNfRScnIyYmJi5JskycnJ6NmzJ48jeY2jIocvfhr4KDBT5ggO5fhZspKnearRVXm+XSIKf3Xr1kWvXr3k381mM+bPn+/z6MiSJOHEiRM4ffq0/FhycjJatGhRaVk1a2FEUUSDBg3k381mM06ePKn4gqigoACXLl2S/7PVYHvSrl07zJo1S57KxmKx4J133sGnn36qWuDy9jjVrl3bblTnkydPKt4fSZLs+kJGRUXZHVelZaxYscJuMK9Ro0bh//7v/9C4cWMYDAa3c8I6llVRUlISqlatKv9++fJln5tKO5OammrXFFvt8r3h6QZGKCjdnurVq9u9TsePH1d8DhJRZGCw9YGSSxolc8a6z4n+JkiFa/I3oauZ8CksaO2iiYIvKioKI0eOtOuPunLlSqxdu9anu+SSJGHJkiW4evWq/FibNm0qzR/qeNGuxh35du3ayWVKkoQNGzYoKleSJEyZMgWdOnVCp06dcNNNN+HEiROK1ikIAvr06YO3335bDkQlJSWYNGkSVq9ercp+OTtW7sqtW7eu3QBQR48etRtYy52CggLs3r1b/j0lJaVSP2xPJEnC5s2b5W2Mj4/HAw88oGjkaU81esnJyXZTD12+fNnuJoqn7fL0eqSkpNgdu3PnzuHChQuKy1ez9thTyPeX47FWsu1Kz8Pq1avbnTeHDx9WPB9ybm4uXn75ZTz99NN46qmnMHv27JA2CafQ0uINHlIHg60XlFaA+vY1YXum//W+AU+VDK9E5IYgCLj11ltx8803y48VFRVh0qRJcvNapSRJwv79+zFnzhz5MVEUcc899yAuLq7SeisGHaPRWGnAGW/3o0uXLnLNKQCsXr1a0Yi+paWl2Lp1K86cOYMzZ86goKDAbhokT0RRxKhRo/Dcc8/Jg27l5ORg3Lhx2LNnj9+BJDY21q55bHFxsdsL/apVq6JLly7y7xcvXsS6des8bockSdi5cyeOHTsmP9a+fXvFc+BWLKdiiElISEDt2rU9Pq+srExuEu9KbGwsbrjhBvn3oqIirFmzRtG+bdy4EWfPnnW7XEJCAjp06CD/np+fj99++01R+X/88YfiEKxEbGys3SBuhYWFqoZbxxsNSpruV3yO2Wx2OWJxbGws+vTpI/9+8eJFRa8TAJw+fRrTp0/H9OnT8d5773mcAoqI9ElxsHXMMt7USPrzXzCFdlv8WYOSuO0YnIOwp1p7gSko2G+FgPKL+cmTJyMtLU1+bPfu3Rg9ejQOHz6suNbz2LFjGDdunN3Ffdu2bTF06NBKd9wdp+PJzc3FxYsX/TonGzdujN69e8u/Hz9+HJ988onbwZMkScK2bduwc+dO+bHmzZt7PVVQdHQ0nn32WYwYMULe15MnT+Lhhx/G2bNn/dqvhIQEu7lUz507J48c7Iwoihg2bJjcX9VsNmPmzJm4evWqy+2QJAlFRUX4f//v/8mjF0dFReGee+7xaXTpin1ljUaj3dywztZtMpkwa9Ys/PDDD27LFQQBGRkZcj9bSZIwf/58tzcwbOfm008/jaKiIo/l9+/fXw6UkiRh3rx5Ho/d/v378cILL6jabDklJcXu2B87dqzSwF6+EgQBNWrUsLthcujQIbfnqSAIdoPKmc1mHDlyxOlzBEHAwIED7Zroz5w5E9nZ2W7XIUkSfv31VzkwC4KA9u3bs8aOKOgCnwgjosY20HHOFhtt6woMxw9gb7dcjVrgAKRRhl6isCQIArp164bJkyfbXUivX78eGRkZmDt3Li5dulRpBFpb08ucnBwsWLAAGRkZ2LBhg/z35ORkvPbaa6hZs2aldRoMBrRq1Ur+vaioCF9//XWl6Vy8YTAYMH78eKSkpAAob1r51ltv4csvv4TJZKpUriRJOHjwIJ588kkUFBQAKA+FQ4YM8Wkk4ISEBLz77rt2NVWbN2/G+PHj3QZRTxITE9GoUSP591OnTuGnn35yOSKwIAi45ZZb7GrhN2zYgFdffRUFBQVOj0NRURHeeOMNu3l5O3TogLvuusvrUOE4jVRRURG+/fZbp30sJUlCTk4OXnzxRbz44osea+0FQcCNN96Ijh07yo/t3bvX5b5ZrVbs2LED9913H/bu3etx2wVBQO/evdGmTRv5sa1bt+KNN95AcXFxpfItFgu2bNmCkSNH4s8///RYvjdq1KhhV9O9a9cubNy4EVarVZWbkk2aNLGrgV2xYgXOnDnjsmxBENC6dWs5DEuShMWLF7sM/a1atcLQoUPl37dt24bnnntOHszMka3FwH//+1/57zVq1EDfvn0ZbInCUFiMihzqDBSc9fu6Fl8aR6tRe6zyF0aoX2Qi8pooinj44YdRWFiIadOmyTVPtlrYt956C127dkWbNm2QlpYGURSRm5uL/fv3Y9OmTTh69KhdcElKSsK0adOQkZHh9KJUEATcdttteP/992E0GiFJEqZPn449e/agQ4cOSE1NxZgxY+wGoPFEEAR07doV48ePx+uvvw6LxYK8vDw88sgjWLNmDYYOHYomTZogKioK2dnZWLNmDT755BOcPHlSLqN79+4YPny4TxfSgiAgLS0NM2fOxODBg7Fv3z4AwPfff4+XX34Zb731VqUm2UpER0ejb9++cr/nsrIyPPHEE/jxxx/RrFkziKIoT6lkazackJCAadOmYd++fTh//jysVitmzpyJgwcP4uGHH0bbtm2RmJiIwsJC7N+/H5988glWrVolv4apqal48803va65tsnIyMAHH3wgh8HMzEwkJCRg2LBhSE1NhdVqRVZWFn777TfMmTMHu3btkm92HDx40G3ZycnJeO655/DPf/5TLn/OnDk4efIkHnzwQTRr1gwAcOHCBfz0009YsGABsrKyULt2bZhMpkqjPjtKTU3FM888gwcffBBGoxEWiwWZmZk4fPgwHnjgATRp0gRWqxVnz57FDz/8gEWLFiE7Oxvp6ekwmUzIysry6Zg5SkpKws033ywfj/z8fIwYMQIZGRnygF6xsbF4+OGHvXqf2DRp0gRt2rTB5s2bAQAHDhzAHXfcgb59+yI1NRUWiwUNGjTA6NGj5f64nTt3Ru3atXHu3DkA5f3x+/fvjx49eiA5ORn33XcfGjZsCKC8xn/SpElYv3499u/fL9euHz9+HOPHj0fnzp2RnJwsnwurV69GZmam3L9dFEU88MAD8utJkYmjIocvn4NtoO5zuSqXp5+3KjY9DoYArcdVsTwhiHQhNjYWzz77LBo1aoRJkybh1KlTAMprpY4ePYqjR48qKqd+/fp4/fXXce+991aad7Si7t27IyMjA99++y0kSUJpaSmWL1+O5cuXo27duhg2bJjXF+wGgwHPPPMMLl68iHnz5sFkMqG4uBjz58/Hl19+icTERAiCgNLS0kq1gx06dMCHH37o0/Q2NoIgoEmTJpg7dy6GDBmCM2fOwGq14sMPP8R1112H8ePHuz0mrowcORKLFy/G9u3bAZRP4fPll1/Kf4+NjcXtt98uB1tBENCpUyfMmTMHY8eOxYULF2CxWLB69WqsXbsWSUlJiI6ORllZGYqKiuyaa6elpWHGjBm49dZbfQ743bp1w7Bhw/DZZ59BkiTk5+dj0qRJeOedd5CamgqTyYQrV64gPz8fkiShSpUqePHFF2EwGPDss896LL9///54/PHHMX36dJjNZlgsFvz4449YtWqVXAtZWloqB3XbPs2aNQtr1671WP7QoUOxY8cOzJgxA2azGWazGd9//z1WrFiBhIQESJKEkpIS+bjVqVMHc+bMweuvv65asBUEAY899hh++OEH+b144cIFfPzxx/IytWrVwogRI3wKtklJSXj66afxr3/9C0VFRXKT6v3798vL3HzzzfjnP/8pB9v09HQ8+uijePXVV2EymWC1WrFhwwZs2LABUVFR6NmzpxxsBUFAgwYN8PHHH+P+++/HoUOHYLVasW7dOmzYsAEpKSmoUqUKzGYz8vLy7GrcRVHEgAED8Oyzz/r0fiEi7VPcFFmAfZNbx8fU+s8mVK1SXW2P/gTjqPnSHNqL57hbxNmLw2bMmsDmXeQoOjoaw4cPx8qVK/HQQw+hZs2ais4TW23lAw88gJUrV2LkyJF2A984Ex8fjxkzZmDUqFF2fUj9lZSUhPfeew/vvfcemjRpIm+/xWJBfn4+8vLy7EJtlSpVMHLkSCxZsgStWrXy+30hCAI6d+6MzMxMOXCUlZXh1VdfxdKlS72ufRAEAXXr1sXnn3+OW2+9VXGfV0EQcPvtt2PJkiW45ZZb5H6ptprs7Oxs5Ofny+EsJiYGN910E7799lsMGzbMrzlHY2Nj8fbbb2PYsGF2/WFzcnJw5MgRnDx5Enl5eYiKikLnzp2xaNEiPPPMM4pGTrZt6yuvvIIpU6bY1SpbLBYUFhaisLAQZrMZgiDg+uuvx8KFCzFo0CC7EY89lf/aa6/h3//+t92NDovFgoKCArv5bW+44QYsWrQIffr0UfU8tjX9/eyzz/D3v/9dtXmRK5Y/ePBg/Pe//0Xjxo0Vvd6iKGLixIl4+eWXUatWLY/vFdugbsuXL8fw4cPl19dsNiM7OxsnTpzAmTNn5BscQPlNiOeeew5z586VuxVQ5OKoyOFLcY2t5PDT8d9646qBrp73KXiC2bQ5dEUTkXoEQUDz5s3xwQcf4Pnnn8fatWuxbt06/Pnnn7h8+bLcdDgmJgY1atRAy5Yt0bNnT/Tu3RuNGjVCVFSU4jBsq+maMGECNm/ejCNHjqCwsBBVqlSxm4u1bdu2eOCBB+TfGzdu7LbchIQEPProoxg0aBBWrFiBlStX4tChQ/IFdHx8POrXr4/u3btjwIABaNeuHaKjo11utyiK6Nevn11T36SkJLfbMHDgQHzwwQd2NYS7du3yKQAJgoCWLVti6dKl2LFjB7Zs2YIzZ86gqKgIVqsVBoPBbvCvitvdtWtXfP/991i3bh2WLVuGXbt2yXP1RkdHo3bt2ujQoYPcpNRWq+2vtLQ0fPLJJxg2bBgWLlyIPXv2oLCwEKIoIiUlBddffz0GDhyI2267DVWrVpUHCnrwwQfl88vZPtkkJCTg+eefR0ZGBr744gusW7cOFy9ehNlsRlxcHJo2bYo777wTQ4cOlft59+3bV24OXrNmTZdNwwVBQGJiIiZPnow777wTn3/+Of744w9kZWXBYrEgPj4ezZs3x8CBA3HXXXchLS0NkiTh7rvvRr169QCUzyfsbxgVBAG9evXCypUrsWXLFuzYsQPnz5+Xm2AnJyfbjeBdt25djBkzRq6p7t69u9vyDQYD/vWvf6Ffv37YsGED9u7dK7/HAaBly5aVAm9CQgImTZqE4cOHY+PGjTh48CCuXLkCi8XidPRrWyuGTz/9FJs2bcLSpUuxZcsWnDt3DmVlZfKxbtiwIW666SYMHjwYLVq0YE0tUZgTJIW3eXNyrgAAfjjyJb45MBvTb/sWKXG+9ZMhKueu/6/7C6C9WZvwxu+P4rXe89GoaktYrZLTL3urZEG0IYp3aIPEarXi8uXLdqNcUngzb9+IwrtvQdKiVTB07eXVc61WK8rKylBSUiL3v42NjUVCQgJiYmI0fREqSRIsFguMRiNKSkpgtVoRFxeHuLg4t2FW61wNHOWO7XUsKyuDyWRCTEwMYmJiEB0d7VcNrafttFgsKC4uRlFREQwGAxISEhAXFwdRFFU5/larFUajEcXFxTCZTIiLi0NCQoJqr6+t/KKiIjk4JyYmwmAwBP388eV111r5ZWVlKC4uhtFolG9ExcbGKnq9pPw85P+jPWLvuR9xT7+q2naRNplMJuTl5bm9yUXqsVqtOH/hIgw+DKBoU7uGstcqLAaPIj3yNKiVBFUag7NGN+g4IAMpJYqiHAb96YMaCoIgwGAwwGAweDU/rdb5EjYqvo7BYjv+ycnJSE5ODsg6RFFEfHy84qbMWivfG4EO0sEoPzY21qdppIgofOgj2Kp6nSz9lZf0eTc9fCh5URmQiIiIiIh0LwiX9doItqrvqNLQ5GO4DdCMNuQvBmEiIiIico3T/YQv5cHW2ahRmjkngjzVDGkIh0ImCjnJCuPCT2D6/edQbwkRkfeMRkh5V0O9FRQkHBU5fHlRYyvZ/YCk8TDhbkJcDW82kd7xyyKyiPUbwdC5O8wbfw31phAR+UysWRtRXg6AR0Taoo2myIGgOLz6knIFZU/l9T0RhTmxZm0kfvEDYDKFelOIiHwnCkCC6+m2iEj7wjfYKsKq20CreIRDk/P5Ggcb+61EHiEuHogL/ciuREREFLkCM8EcERgpiYiIiIgoOCK8xtZX7iJbhXpJb5JdGDVbVrrbEXp4iIiIiChEOCpy+GKwVZ2SN4qTmOZHV1898nZ3+fFDRERERKRXgb+aZ7DVMx8ztFqrUlK04zJqndKann0qwnFUZCIiItIqTvcTCsG5Smew1QTHF1tbbzZvT8VAhVln62CYJSIiIiIiBtuQCGIcU9gd2Jene7NMqHDa4uBjvxUiIiIiCjYGW83yM5EGQDBqYpVidCIiIiIiIhsGW03yJbZ5eo5QeQnJTUQW7H54tSaKXIIgoKysDBcvXgRwrfZWkiS7Pi3ePm57zPa4bV0VH7c95us6uG6uOyDrliRI+aUQrFaUlhoRFxf719+Fv54nQZIAQfhrPVEiUCWuvLVJOOy/ztctCAKsVqvdc5xtl9rba3ueq8e5bq6b6/Z93VarFYmJiaDww2CrO77VmzpfyrshobQYaLXVG5kEQUD9+vVDvRlE2lFmBqYuBM5fBRpUB6KjgFITcCYXMIhAvWrly527Wr5s3RRgxgggLjqEG01ERKQ/DLa65TlmSm5+81ia9lpCO6XFsB3pKtaAEEU8CUCBsTzU/rs/kF0AXCoAMlcDo24EbrgOsFqB/eeBd1cCBaXlz+P7iIiIyCsMtrqjfpTzukTPrZ6JiKiimlUAkxk4egnYfgowWYBWdYANR8trars3A+L4lUxEROEpGPGA36I65cu8shX/7nruV1ep1cvTUSc1vkREQWGVgJPZ5TWyD/Ysf+zsFaB/e0CSgF1ngFIzUDW0m0lERKRXOg622p77VW2+1NO6OiK+1fl6UU3rz9hX4f0yhj1JkpCdne3VABHOylAyqIQaj3PdXHfA1200I8VUhpjdZ4CtJ4G8YiAxFshoBzSsDry4pLz2dvKdQMPqMBUW48qlS5DiosNj/7lurpvr5ro1tm4ASEhIQFJSktMySL9CEGzZK9Ib3h6t0B5dhbW97jZSqrw46YckSTCZTKhZs2aoN4VIG4xmREVHAwPblQ8MtfEY0D4d+OUQUD8VaF0XMFvlZQ2GaKSmVgfiOXgUEVEgmM1mFBYWMtiGIS+CrbM0EsoYxfQDXDsKErQaapUu6+T19KW9NYWcKIowGHTcGIRITVkFQJER+G5HebPjvzUAvtoKrP0TOHwR6NW8fKCo99cC565AiDXA8NpyQOSHHalJAG5uAfRtw3OLIp6tFpfCjw9Xn657ZwaXP+vXz4e6py0N9augnBdbWukDRz+vFxGRnfVHgSvF5TWz206Vf5xJEtC6Tvm0P6sPlC8nSUCHv6bKKikL2eZSmDp7BTibWx5uOZUUEYUpVqvolH4CLaBsaxXukeNiFauq2YyZiLTGagWqxAGv3wWkJIR6ayhSzVgDbD4e6q0gIgoo5cFWSUtkTYcK/zdOzfGN9BVMtUJy+k9Xi1BouBrQgShiCUL5fw5NQB2bwyl97xiNRpjNZiQkJPD9FgYkSUJhYSHi4uIQHR2g2lSeJkQyNkUOX6LPz9TdOSH5+F9gtoC84eyoKWwSzwNORBpjtVpx/PhxLFy4ENOmTcOrr76KL774AidPnoTVapWXkyQJO3fuxOLFi1FSUiI/99VXX0WfPn2QlZXl1XoPHjyIBQsWID8/X9X9CZZLly5h/vz5OH36tNvlrFYr1qxZg59++gkWiyXg23Xq1Cl8/vnnuHz5sk/PP3nyJHr27InMzEy3F9wWiwWrVq3C6tWr7c4TIvIew2148j3YOrv7F5q8GGC+BuJrO6q7XdYVx9l5dXuiEVEEMBqNyMzMRK9evTBx4kR8++23WL58OZ5//nnceOON+M9//iOHWAD47rvv8NRTTyEvLw9Aea1u/fr10bx5c69r91avXo3HHnsMly5dUvycXbt2Ydq0abh48aJX6wqEY8eOYezYsdi5c6fb5SwWCzIzM/Gf//wnKMF2+/bteOihh3Ds2DG3y0mShC+//BJz5syB2WyWH4+Pj0eLFi1Qt25d+bFTp07htddew6FDh+THLBYL3nnnHUyfPp3BlsgPgiCwtUtI+JenlIigGlv/CfClNU/YJHwiRXgXlMg5q9WKGTNm4KWXXkKfPn2wfv16/PHHH1i/fj3Wr1+PAQMG4LXXXsPcuXNdvo8EQcAjjzyCTz75BKmpqZX+LkkSrFarau/DvXv34u2333YZhiuuT+k6bct62k7bMkr2x9f9Vvt4eSpz8eLFmDdvnl2wrVWrFhYsWIARI0bIF9unT5/GW2+9hSNHjvi0Xn4OE1EkCt3gURE0U5D71UmQ2PnFD7xJQETaJwHYunUr3nvvPXTt2hWZmZmoWrWq/PfGjRvjnXfewcGDBzFz5kyMHDkSKSkplcuRJKxatQoHDhzAI488gri4OADl8zJu3boVy5cvx/nz59GgQQP0798fHTt2RFRUlPNtkiScPn0aCxYsQJcuXXDLLbfIwcpsNmP+/PlYvnw5jEYjZs2ahdq1a2P48OFo0aIFJEnC8ePH8d1332H//v1ITk5Gnz590Lt3b8THx7s8DmazGZs2bcL333+PS5cuITU1Fb169UK/fv3kfQGA0tJS/PDDD1i7di3MZjP69euHatWqOd2HI0eO4Ouvv8bRo0fRpEkT3HvvvR5fj7KyMvz8889Yu3YtcnNzcd1112HQoEFo27YtRFGE2WzG559/jri4ONxzzz0QxfJ6AJPJhHnz5qF69eoYPHiw/LitzJUrV2LFihUwGo3o2rUrhg0bhsTERFy6dAlz5szBoUOHUFRUhGnTpiEtLQ1jx46FxWLB7Nmz0aVLF/To0QNLly7FsmXLUFZWhgULFmDbtm3o168fOnbs6PJ1PHDgAJYsWYITJ04gOTkZd955J2666abA9dklItIg32ts9Sx03Wx92CAiItI7i8WMd955B1lZWXjkkUeQnJxcaZmkpCS8+eabmDhxotu5oFeuXInMzEyUlpb+VbYFH330EQYMGIBNmzYhISEBv/76K+644w588803TmvvbKF25MiRWLlyJVq2bFnp74cPH8bRo0dhNpuxd+9ebNu2DXl5eZAkCZs3b8btt9+OhQsXIi4uDmfPnsWYMWPw1FNPoaioyOl2S5KETz/9FIMGDcL+/fvRsGFDXLx4EaNGjcJ7770nN68tKyvDq6++ijFjxuDYsWOwWq2YNm0apk+fbrcvtj7IGRkZ+Pzzz2EwGLB582bcd999bvvhWq1WfPjhhxg1ahQuX76MevXq4ffff8ftt9+O9evXQ5IkWCwWfPrpp1i0aJHdOs1mMz766CMsWbLE7nGr1YrMzEy89NJLMJlMyMrKwvjx4/H888+jrKwMJSUl2LFjB65evYq8vDxs3boVe/fuhcViQX5+Pt59912sW7cOQHmf2wMHDsBiseDPP//E1q1b3daY//bbb7j99tuxZs0apKenIysrCyNHjsSMGTPYZJmIIgqn+/HAXbQU3P5R+ToED+shIiJ9KykpwcGDB5GYmIjrr7/eaf8uQRDQrVs3dOvWDYIgKG5OeujQIbz88ssYOXIk3nzzTcTFxSEvLw9DhgzBW2+9hTvuuANVqlSxe05OTg6eeOIJFBcXY+HChXb9OwHAYDDg9ddfR8uWLTF+/HjMmDED119/PaKiolBcXIzJkycjLS0N3333HWrUqAGr1YqvvvoK48aNQ9euXTFq1KhK+1hYWIj3338fN998s1wbajQa8dBDD2HevHl4+OGHkZqaik2bNmHmzJl44okn8MorryAmJgZZWVm4//777frMlpWV4ZVXXoHFYsGKFSvQrFkzmM1mLFq0COPGjUPnzp1dvhafffYZ+vTpg7lz5yIqKgp5eXno27cv5s6dix49eig67hWVlZWhuLgYy5YtQ61atWA2m+UwPnr0aHTq1AmLFy/GXXfdhaysLCxZsgTx8fEQRdFuMC9RFDFhwgT87W9/Q0ZGBl555RVkZGTItciOSktLMXXqVLRp0wYLFy5E1apVYbFYMG3aNLz77rsYMGAAmjZt6vX+EBHpUWTW2HrLy8pUdbtEh7w6mcgrHJCBqDKTyQSj0YgqVao4ra218XZQE0mS8Msvv8BoNGL06NGIj4+HIAioWrUqJk6ciI4dO8o1uzb5+fl49NFHceDAAXzyySdo3ry50+2IioqSmzFHRUXBYDBAEAQcOXIEmzdvxsiRI1GjRg152UGDBqFFixZYvHix00GbRFHEiBEjMGHCBMTFxUGSJMTExKBNmzbIz89HQUEBJEnC2rVrER0djfvuuw+xsbEQBAG1atXCxIkT7ZpVZ2VlYevWrbjzzjvRtGlTCIKA6OhoDBkyBJ06dXJ5zERRREJCAvbt24dt27ahpKQEVapUQWZmJsaOHevTZ1hMTAyefvpp1KpVS94OWxPmtWvXysdQEASIogiDwSD/7mz7bH+zHfeKTZ4rOn78OHbt2oV7770XycnJkCQJoihi6NChKCkpwebNm73eF6Jwx37o4Ys1th44jrkLN78r+mPAr/kdV8yQQUQUarawYjKZYDKZVC378OHDSEpKQnp6uvyYIAjIyMhARkaG3bImkwlTpkzBH3/8ga+//hrt27f3OsidOnUKJpMJzZs3t3tuXFwcGjRogGPHjqG0tBRJSUl2z0tISMCjjz6KrVu3YsqUKThz5gxyc3Oxf/9++SJTkiScPXsWVatWtatFtoX1iuvLzc1FYWEhWrVqZRf8DAYDkpOTUVBQ4HT74+Li8NJLL+Hxxx/HbbfdhubNm6N79+6455570LVrV5+CrSiKqFKlit1za9asieTkZFy4cMHr8pQ6ffo0CgoKMGvWLCxdulR+vLS0FMXFxT5PQUQU7ngTPjyxxlYBb+tGfRs92VeswSVt4V1QosoSEhLQoEED5OXl4fTp0y77vW7fvh2fffYZrl69qqhcSZJgNpvl4FyRrfa34gWcKIpo0qQJysrKsGXLFp+mw7E1iXXWDzg6OhpGo9Fp3868vDw88MADuP/++1FYWIhbbrkFjz/+OG699Va7bbRYLBBF0WUtpY1txGR3/ZGdEQQBffv2xe+//46PPvoIbdq0wffff4877rgDs2fPVq1falRUFGJiYgL6mWh77W+++Wbccccd8n933XUXPvjgA/Tp0ydg6ybSK4ba8BXEGltfPtj1eeL5VJNro/ouq9QRmIiIfGZrWrt582YsWrQI3bp1qxTILBYL3nzzTWzduhW33Xab3ajJrgiCgPT0dLl2ruIUQHv27MHatWvlJsNAedh68MEHkZiYiLfeegtpaWm4//77XY6c7OwCMD09HaIo4uzZs5AkyW4k5aysLKSnp9uNcGzz22+/YdmyZViwYAEGDhwoP75t2za79dWrVw/FxcXIz8+3a7bt2Mc0NTUVVapUwfnz5+22wxb2XSkqKsLWrVvRunVrDB06FEOHDsX58+fxr3/9C3PmzMGoUaMQExMDQRBgNpsrDVjljLOmjTk5Obhy5Qpq165tt39KKF2uQYMGiI+PR7t27TB8+HD5eUajEZs3b67Ut5qIKJx5UWPrrEZQU0MLB5yAYNfG/iVghzX8XzMiIi0QIGD48OG466678Pnnn+Ozzz6D0WiUA1FZWRm+/vpr/Pzzzxg4cKAcRKOjo1FaWorS0lKnoUoQBPTs2RMWiwX/+9//5CBmsVgwb948ZGZmVqqVjYmJwaRJk3DXXXfhxRdfxKpVq1wGturVq8NisSA7O1ve1iZNmuC6667D0qVLUVJSIj++ZcsW7N27F7fddpvTaWays7MhiiIaNmwoP5aVlYW1a9fK6xcEAT169EBeXh5++OEHeV7WoqIiLFiwwG5fatWqhVatWmHFihXIycmR53HdsmWLXVh2th0jRozAggUL5EBcp04dtGnTBqWlpTCbzTAYDKhevTpOnz6NwsJCOSyvWrUKR48erVSmyWTCTz/9BJPJJB//b775BmVlZXbNm2vXro2rV6/aHTdnUlJSIIoisrKy5OVsfXfz8/NhsVjk16J58+ZYuHAhiouL5WV3796NQYMGYf369S6PAxFRuPGxxjZygo9ae6l45GNNHdagVy8TEYWtmJgYvPnmm8jJycHEiRPx1VdfoV27doiJicHOnTuxYcMGdOnSBc8995zcDLdjx44wGo2YOHEiHnroIfTr169SuV26dMG4cePw7rvv4tSpU/jb3/6Gbdu24X//+x8mTpyImjVrVnpOQkKCPP3QuHHj8M0336BTp06Vagrbtm2LWrVq4cUXX0Tv3r0xevRoNG/eHFOnTsWjjz6KMWPG4B//+Afy8vIwa9YstG3bFvfff7/TGscuXbogKSkJL774Iu6//35kZ2dj8eLFMJlMdsv36NEDvXr1wr///W+cP38eKSkp+PHHH3H58uVKfXoff/xxjBkzBqNHj8add96Jw4cPY/Xq1UhISHD5OtSpUwf9+/fHO++8g8LCQrRp0waHDh3CokWLMGLECCQnJ0MURQwYMADjxo3DmDFj0LJlSxw9ehRHjhxxGtpFUcS3336LU6dOoXPnzjhy5Ag+++wzDBkyBN26dZOX6927N7744gs88cQTaNeuHR577DGn29igQQO0bt0a7777Lg4dOoTBgweja9eu6Ny5M9577z2MHz8eEyZMQKtWrfDSSy/hoYcewtixY5GRkYGrV69i3rx5aNq0KXr37u3yOBARBUuwEoPGB4/yNuUF/rD5mjsDllc1lz2VDl4lKVjGcVkGaT1g3xUi5wRBQO3atbFgwQIsX74cy5cvx4YNG2C1WlG7dm1Mnz4dd999t90gSf/4xz8wa9YsLF++HOfPnwcAtGnTBnl5eXLAio6OxiuvvIJmzZph8eLF2LFjB2rUqIHMzEwMHTpUDsmNGjVCv379kJiYCKC8VnD27NmYPHkyFi9ejDZt2lQKhOnp6fj0008xf/58HDhwAHl5eRAEAYMGDULVqlUxa9YsfPzxx4iNjcWIESPwyCOPoHr16k73v3Xr1pg/fz5mzpyJzMxMpKen44UXXoAkSVi0aBHi4+MBAImJiZg7dy6mT5+OlStXIi4uDv3790evXr3w9ttvy017BUHAwIEDMW/ePHz00UeYN28eWrZsidmzZ+PXX39FYWGh08+jmJgYvP3222jRogVWrlyJ5cuXIy0tDS+++CJGjRolN8seMmQIsrKysGLFCqxduxYdO3bElClT8MUXX6BatWpy2XXq1MGgQYPwzDPPYPHixViwYAFEUcSTTz6Jxx9/XG6WLQgCBgwYgMzMTKxatQqHDh2C2WxGXFwc+vbtazc6dZUqVfDRRx9h9uzZOHTokDwI1JNPPon4+Hhs2bIFV69ehSAI6N+/PxYtWoSZM2fi/fffR3R0NHr37o1x48ahVq1aXp2jRJGAoyKHRjCuDgVJ4SubczkbAPDD0YX45sAcTO/7DVLinH95hY5vh0zyemgo14/o9m0SsLPNVrC3fX2dLX9tub1Zm/Hm+scw9ZZP0ahqS0iSBIOh8l10q9WK6GgDqlVL8WKbyVdWqxWXL1/mxRSRzcLNwILNwPwHgWrXQqPtq9fWHNk2rY2zIObua7ri8rbmsiaTCbGxsRBFsdLfHZ/nWLaS9Vd8rtVqRVlZGURRRExMjMsyKpZle05MTEylAaIct6u0tNSubHf7bTab5eOodJ8sFou8Lc6m35EkCSaTCRaLxWm/Ycf5hm3NygVBcHk8vHk93a2r4vIeX4v//gxsOg588i8grvJ3JVEkKSsrQ15entzlgwLLarXiwoULTlu7KOWs5ZEzfjRF1ppQxEvJxdp0WGMVsOmJlLwWSpZREpB9KZfUxrugRBUIAIqMwIe/ALHRdg8DQOWo5LwIpauK/us/peUoKdvVMgKAKADxCsrw9jm2dSop29N+uyvfAPcXQgKAGDd/r1iW7d+eXlNvXk+lz/V4XHefUbhWovDn7XzhpB8ab4rsDd8vpt2d2k4mZPB5PeQPpbMIezXbMBFRYHVsCDStCew/H+otoUgmAOjTGoh2Pvo1EVE4CKNg6z//I5A3tYo6uVPkvkWwxjDEEpHGNKsFvD+SH08UetEi4GFuYCIiPWOwVVWgrly8GWiJiIg0QxCAGH7VEhERBRq/bStQOoSROnR8+z5g/XF9ITn8pFBjvxUiIiLSKo6KHL4YbHXH29GFQ4wz9RARERERUYAx2HoQ3FpctYSoStXdgWFraiIiIiIKMY6KHL4YbMOKt5E7RGlTcrM6BmDdY/MeIiIiIgo2BlsfCNBDra0zGtpqJaMtOy7DoEtEREREpD9BqPhgsPWRPpsou6OBqlJPB9BTU2f25yUiIiIiikgMtj7Sd4j1RGcDVAH2myW5+DcFBfutEBEREdE1wbkgZ7AlL1XsIKukPXGASbCvrSUiIiIicoHT/YRIECKCF8HWcb5QraQJtY+SsrDmLtoFWuj7+Cod/tgZ1uYRERERUWhwVOTwFQY1tqGIeNfWKVT4f/dLqrv20IdbXynZan8/bPR5ZMIF74ISERERUbCFQbANhsBeqLvqHhq5fO3jy6NHRERERKQ5QbhMZ7BVhfNXSvKh5tFVE2dnJem31tYfzvbYn6bRREREREQUMFJwOiMy2AaQkuDp77RBrk4SxrmKeDSIiIiIiEIiSF2aGWwDyts6W99edW/HJmbMo0DigAxERESkVRwVOXwpD7aOgyI7/jsYwv56ufyAKttNZUvxbUtERERERCGlrel+SKvKzxOp0iNEocC7oERERKRVnO4nRDh41F947jmh7OwQnARexg4iIiIiIgqKIIUP34NtMNORGqMpRRRGVyIiIiIiihz6qLH1RqAzna6Ds5JJhIiIiIiIiFTCUZF1xNthiTVD6V0ApTsTvOCstGQhoFtBzrDfChEREWkVR0UOEQ4epYSrEzNAR08KXNHB4v3ct/6++dUPvLYSPZXEjy0iIiIiovCn0WCrRhwJYAL1dfMCkbJU2kWllc7e7YKrpT2Vot7rpvN7ELrEu6BERESkVRwVOUS0NSqys63R+gVsCEedClar3CB3mw1ODannnXK1HY6Pa/0MJSIiIiIKa9odFVly+BkulOyPH6kxWIdLaRtdB2rlYV9qeQWPy7i7qSJBgATpr59KSiMiIiIiomAK/PW5Rpsia1WAw6+aNDQAcsVVu4uonpZTxvGZDLlERERERCHDUZH1SqPhVyNB111TYcnFcoym+sJ+K0RERKRVHBU5fDHYhoRGw69G8UgQEREREemToN0+thQ2NFCLy9BKRERERMHCUZFDIxhHXAzCOsgnAb61obR4yYtlicDpfoiIiIioAq31sRWc/AzWDDaRy5v5Xl31UPVhdbyJRUREREREOsKmyLrmKvi6elxhYnU1dDEDLxEREREReSOS+9gGIj+xFhioXCXrZS0vwy0pwH4rRERERCTTWlNkvfPmeEZmCFa415KbI8k8Q0REREQaxul+NEbF/BAxwVaJyDnF/dlTN8+V/yTY/SAiIiIi0gKOihwC7qKHigHMi2DrquOlmkJ3kkVOqA0Gye4HAMDjB4gKg1+RJvAuKBEREREFmx81toG4ePW2TAYg3XAMO0Klf1Rc2MljSl9rhioiIiIiokij86bIaoUYBuSgkyr8Q9HhV/JaB6NVARERERERaY3Og61aJA/Z6tpfGZMCwN1oy44HXHD8g1ThPyIiIiIiikQMtopcC03O85fAWOUvpV1sJYefpDkckIGIiIi0iqMihy8GW1U4r/Gt/JbhBb8izmppXX3+SHBfacvPLSIiIiKisMdgG0CVY6ynlOVd8I2YzBYxOxoeeBeUiIiItIrT/YQvBltN8S74Ku2WSkREREREFCpKehp6Ws4TBltdcRdZBSf/YsglIiIiIiLtUqv+XFSpHNKoiG9oEfEHgIiIiIgo/LHGNmy4rpsVHNJdRNXiRtTOagP7rRAREZFWcVTk8MVgGxHs37yOPXX51iYiIiIiIj1jsI14ko99cl3N6KtkjRTOeBeUiIiItIqjIocvBluyo/xtrmwgK2eT0gou/qKE4OEnERERERFFHi+CreTw0/HfgcLIoj/uzotrfxMq/L/rZzguT0REREREZM/nGtvg9cxUsh5GHv0qf30Fp79do+wVrlw7TERERERE4U9xsHUWEYIRG5TFZ6XNYtXYAoalQPJUf3tNxRYE5f9VbgDNvp6hwH4rREREpFUcFVkLAnP8Nd/H1v/BiNQOpq7Wxot5LbnW95YfXERERERE4U7zwVYJ7yJlxaDj+ZnKY5GzJRl2iYiIiIi0gqMih6+wCLa+C3RtngSGW4o0bN5DRERERDa+jZ7j/fVkhAdbz3yb47Uipc9iACYiIiIionAU+IoPBlsvOEZP1ksRERERERG5E5zUxGDrB2d1rAy7RERERERE1wSjbSqDrcq8f9H8e5kZpElrOCADERERaRWn+wmF4FwbMtiGnH9vLHedsfmWJSIiIiK6hqMihwKbIpNPrp049m9ZwcVS3pbLDwJyj3dBiYiIiCjYGGwjhv38va7iqfNIIjn8m+GWiIiIiIi0g8E2IrmuURM8LuHsr74EXWdrYGAmIiIiIiLvKQ+2znJIIFscMuOElHfz96oVUtUMu5LDTyIiIiIiClfe19gGKy+4Kp+BN+gE+NMn17Ekb0tlza7ecEAGIiIi0iqOihy+vAi2wa6ydUHVnMMLcKV8C7eO1DpfXJXDDykiIiIiokjkRx9bDYUIn2t3le4DAzAQmKOgobOIVMK7oERERKRVnO4nBIJ0uBUHW8HJz8gJOvYjCpN6/K8Jlir8R0REREREmhKky3TNjYrs3TQ0HgSkny77fKrN33CrTjNpIiIiIiLSK80F26BQPfCqMf1NZPM1nPJIExERERFpmNaaIssc2yQHiao1uQGnxlZFXmRzF249HY3IO1raxX4rREREpFUcFTl8KQ+2zq5VNXD96rgJATtNlRSs6vGIzFrgyNhLIiIiIqIIEal9bP0V0v6Wnlaset/egKxItyJzr4mIiIhIKY6KHBrBOOJhF2yBADVbViMxB60SlqM4U+iweQ8RERERyTTbx1bHnB1Try7B1a4ODsoAy5HZpJmIiIiIiCJHRAVbZ/Q1KBURERERERE5ivhg64rLek3bH1wkX78DccArWFmDS4HFfitERESkVRwVOXwx2PoqpKNUqUmtnWCYISIiIiIiJ4IQFRhs/eFkriGPr5kXL6rXkTOkGdXdyhl6I4UgCDAajbhw4YLdqIMV7466erzi39w9bnuekse5bq5bS+uOi4tDaWlpULfB9jMU+19x3WazGVFRUXZ/s3F8juPjvjxHrce5bq6b6w6/dVutVsTGxoLCD4OtWgIwEJTfg135SvV94SjNkaR+/fqh3gQiIiIiijAMtjrjNhZW+KOkdgJWrWtuIPv4SiqXR95yvCtKRERERBQMDLaB5CpcBuHaXxACEG4rUq1WV42gK7n4N0MWEREREVHoBb7dKYOtWjyMlmwnSIHXm03SDl8Ts7Pn6WvPiYiIiIjINwy2avMnTardt/Wv5woKt8XvGOipAFWaL3tbCMMtEREREVG4Y7ANFLWmA1KjdlfhtgR0BiPVaqMDMEoXEREREREFUOCv1xlsAymQbYEDlECdzGCkURWGiYek4e0kIiIiIop07GMbHtzdoNB4InO56W72qdKgVQG4QeNYpKD1A0lERERERAHDYBtqrkKflnKal8FUELS1+UREREREFN4YbLWqYpgMdUoM8fSwSlcd0D7CRERERESkWQy2eqClkKtQqHKwY7jlsFJEREREROGPwVZvmNQ84iEiIiIiIoosYqg3gIiIiIiIiMgfDLZERERERESkawy2REREREREpGsMtkRERERERKRrDLZERERERESkawy2REREREREpGsMtkRERERERKRrDLZEREREREQUEEKQ1mMI0nqIiIiIiIgoAgUj3LLGloiIiIiIiHSNwZaIiIiIiIh0jcGWiIiIiIiIdI3BloiIiIiIiHSNwZaIiIiIiIh0jcGWiIiIiIiIdI3BloiIiIiIiHSNwZaIiIiIiIh0jcGWiIiIiIiIdI3BloiIiIiIiHSNwZaIiIiIiIh0jcGWiIiIiIiIdI3BloiIiIiIiHSNwZaIiIiIiIh0jcGWiIiIiIiIdI3BloiIiIiIiHSNwZaIiIiIiIh0jcGWiIiIiIiIdI3BloiIiIiIiHSNwZaIiIiIiIh0jcGWiIiIiIiIdI3BloiIiIiIiHSNwZaIiIiIiIh0jcGWiIiIiIiIdI3BloiIiIiIiHSNwZaIiIiIiIh0jcGWiIiIiIiIdI3BloiIiIiIiHSNwZaIiIiIiIh0jcGWiIiIiIiIdI3BloiIiIiIiHSNwZaIiIiIiIh0jcGWiIiIiIiIdI3BloiIiIiIiHSNwZaIiIiIiIh0jcGWiIiIiIiIdI3BloiIiIiIiHSNwZaIiIiIiIh0jcGWiIiIiIiIdI3BloiIiIiIiHTNEOoNIFKNpPAxIiIiIiIKKwy2pC2+BFHJx+cREREREVFYYLCl0PM1zBIREREREYHBlkIhSKGU2ZeIiIiIKDIw2FJghShdSqFcORERERERBRWDLakjZBlSqvCvyhvh7DEiIiIiIgovDLbkPxWzoy81rZLb+Cr4tT1EREREROSfYFQ1MdiSd3w8K9WuObUvTwCbHRMRERERaU/5VXrgK5sYbMk5L3Oi68UDFTgFh5+O/w70+omIiIiISCsYbIPKFrI02jzWiwzoedFABkqNHj8iIiIiIgoJBtuA0EktocLN1N7euNoi7W0pEREREREFHoNtUPlT06hiba+H/Od7PAxmsJQcfnpajoiIiIiIwhWDreapPuRwsNbmwDGQq7kmhlciIiIiokjGYBsQavUBDXxgU3cN3ux3xWXZH5eIiIiIiHzHYKtJzoKejwFNcvpPDQjG1nAaICIiIiKiSMBgq3m+B1ptRrpAbFXFAMsaWiIiIiKiSMNgG1SOoU6NwaT++k3yt7xACXS89jSPLRERERERhTsGW81zbEssOD6qQcFqZkxERERERMRgG2SOfT5dBECfmxEreVa4BEJn0/1U/He47CcREREREXnCYKsqH2sqJbe/qrMOzXAWOP3dJ70fEyIiIiIi8geDrWJ+hiepwo9gzXTjFTX7/3qznkBxVqNLREREREThSCfB1ttwonYoU7Z+l0s5/sHpgoFIu/4OThWI2lUiIiIiIiJ1eRFsnQWaYNXyqcmP3qt+Zzp34dWXwpUcbzbzJSIiIiKi8KaTGlv1psVxuoRX2U0r4d1xICo1yoNDmQy1RERERESkfV4EW2eBTishz9G1QKad0Kp2SFSzhlfysTxn5YYiDDuGfM5tS0REREQUSVRuiuyhhEojJwWTN+v1N5xpNUwFKnRqrWaXtc5ERERERJFEcbCV3P1Lc9nB22CphdpUvVC7CbQatLY9REREREQUTF73sb02iYrewoTetlcrHPve8jgSEREREZG2KA+2cp4Rrv2slHG02gSXlHF8/fzte2srk2GYiIiIiIgCx/tRkd1W3Dl7kGHXOWejEAd6XaEoP1j752o9PP+IiIiIiMKdD9P96KlJqha20Vmw8qcmVAsjN3vahmCGdQZXIiIiIqJI532w9TpPBDtcai3oqDWNjhrlqbF+V4L9Oiu9waKFmxtERERERBRIPtTYkvq0UAMKBHc0aWf9eX3F8EpEREREFMlU7mPrj0DUtGolMLoT7FpZf46zbbuUlhHIvreCw7/Zx5aIiIiIKFKFoMY21EFDq015tVCuUpKTbQjWNrlbb6ibbhMRERERUSj4EWw9BZlQh69QUnvftXos1dyuwOyjAKCkuBgMuEREkSmyPv21er0QDFp5pbV4k13tbVLzPFPr2Ohvekl/j6KzaiYtkiTAarUGZV1eBFtno0bp4XAGQiinzwkl7QdZwP5jTRAERIsSzKUlmj2qanD8KA/nfdUdvhhEAaOvy9hgiOQPHC2dDWqOI6IWNbuHqX2eqXF8gjmNZmD4OmSrHt718THRQVmP76Mi65aSHfB1pF3dH5zwIwgQhfLXJZxfHc4grSN8YYgUUXJ5yreTo0g9Ilqsu6oYtLSyba62I9S1t5Fba6uEs9skSo66Vs66YFIebEPVpTLgwu8NEEhanH3XRo2Jf7R6Wvty3L0d6ouIKND4jas2fsKXU6PSQm3efAsHa9tcRSJ/miqrEdwrPl/NwUXD4xPHVas8b697I+HTQnmwdTw64XGueCG8Twetvpxa3S498eYYBuIs11tzGSJSTunnC9/7SvFIuTun/Ds6oapZVBL8AlGT6oq/9X16ujLTf/NkZ3zdm0ho3ef7dD9hI7xeUq2+PIG6+FF79imtHr9QCVQtt6dyw+td+Zew3CkKB3puzaI/PJL+ULMuT50SAn3VoKXaXhvH5r6BGjBVzf0KzybKagi3Wl3f+9jqfc81LpLffpG876HmS4Mib14vbxo2eUutgK3GKIXelBeRIZ90zZ+uEeGP71gtU/8mu7Jmr4Grha5Ygi/fxr6uPRjnudpNikMVbrV4c8I17WyJb3yvsdX7nodAuN0VCQReMIWeXo9nILfbn4sSSclCGsPm4+FJr+9t7eG7Qg1aPh996zXq23mh3g3WcGg67Ipatbha7X8bnCbTkVBv7cc8ttrmSy2ImmOyKSk73E8uIj3y9n2peHkf06K/d/o93ZcPRI07L/tDI1Q3d/SNZ6tawu0cUWsCHDVv2KsXeCvWUunpPaBmANRi/9vABu/KJWo16PtOcbANt2DGCwAiCpoAfSgE47NGjXWoe5GmPi1sH7831KCVMyry8PwN7eexb7XLen7VnAUyf5tVa+14BHu7wiPk+lxjq99dJiIKsGCPL6JAMDfB10ki1BjESM391MDLRjKGVgo+vVzq+9acOVzeU2rtR6QFXHfHTb/nRtg2RSYiChl2qFdMa5cQpEV8A2md3uv/XNHzPmmhJYo+afV2hla3S1sYbImIAo1BVzX8Og83fDNoHd9z4SWQIzSrOfCgvw2M1RFptbj6x2BLREREDtxdTga6wXd4h10tjDrOy2FyRs13o1o1xtr4hNBqbSkDriMGWyIitWmwjy3pmdo9kStyVV4oT1ptXMr6wtsZGTyNScuPDgo1tZs0K313u4tsoa3N1eJnEQOuDYMthSVTcRkKTudA6Zs8rloSEmolB3ajKHKw6TGpKpBjU1Oo8ZUhPXIXeNWaNo9fnd4K197uyjHYUljKPXAOK4a9j6S61VCrQyMIgoDcIxeQc/As4msko2a7hsg9dB4FZ3MBSGj74M3oMnlgqDebiCgAtH6hEzmXr1p/JYj8FcyR6XkP2RmtNpsODgZbCkuSVYLVZEHnCf1Rr1sLFJzLwfEfd8JcWoaMeY9DNERBNIj4adwcXNh8BFazJdSbTEQEfV2a6WlbAyPyLhuJtEsbA05pSeSFXAZbCguSBJjMZvlta7ZYIIgCkuunQZIklOWXIOfPc2jUtwOMecX4btj/oc9/H0CLwX/HhS1HYJUkmMzmkO4DkTawKZM9XiKRa3ynEAWfkh6l/OSOTAy2pDtOP8gEQBBF+YNMFAUIgoCsXSdwdsOfMMTHoM+MB7F9xg+o2qAGOjzUB7VvaIzTv+7/6+kCRFEM1i6Q3oX9N6YAdQYg0hp/716H/QtPXtLLmU8UTpQMuMZP68jEYEsuueq7oIXxKiWHnwKAqArBVBBEQBBw/KdduLT7JAxxMWg17Ebkn83B7rk/I71HK4iGKBSczwUkQBCgKNhq9YPSm4urYO6D47QW3t5d9eYc9KUcT2W5Ks8jpcOcutsQTZ1snjZGj5f3vh5gTb0wEUePZxoRaY8aozrz20B7GGw1Ti93nkJ9seFs/dGJsbh1+mhc3ncagABTkREWowkt7u6KM78fRGqzOjj9y77y5//VJzfciVEiJFGbZ5OScyiYy3i7rN1RdTfEo5vDb/d+9zQPSMiF+l2vBk0f4IgSDmcTEemHpu8lk898CrYSJBSbihAtxqi9PeRAS1/2WuqCXmoudvk3SZJweedJlOYWYuUjc9D4jhsgWSzY8n/fI+/EJWx6eylq/a0R1jz9GS5sPQYAOPbtdlzcfCxYmx8aAtD8nq5ofX9PCCEIt6E+ZwJN0f79tZDTaW4rVEfbMq3koXmE+q+i9mbU9O7uuG/9g/VyAxEI//cREVEo+NIakeFYe7wOtjFRsSgyFWLy7w9BBPskUmiYrCaIggiDUPkUlixWnFi+C0n1U5HSsjZyT5wDAKR1qI+0DvUBAJcOnkR0SiyaDekc1O0OpYtbj+Pwok1oed+NiIphY41QchtOhArLuFtQqvBDwbepsi9c+2pi+9VfC41qfHkHpjmX62putWvy1T4GRESkLc6+Udx1iWLQDT3FV7e2F+vG9H+gzGpEsakoQJtEpEzNxLqon9zY6aeLJAE1b7gOvTJHQpIkXLp0GQWFhYiLi0VqtWo4dPgIWrVqib379qFTx452/WuNRiP27T+Av3VoX6nfrfRXFZog+P5xlV9QgHPnzqFlixZyOZezs1GQX4DGjRt5XZ4kSYq2Z91TC5Cz76zX5VMIKEx9vjep9rX9haDgGdf+6s1aKv+98uWDsi0NTg8of2p5GWiJiPTB1TeKq89+T4GXYTewvK62iY9Owu1N7gnEthD5xGJx3TfWYrVi3e/rcenyZVRPTYXBEIXWrVphz759aNumNdKqV6/0HGNZGXbv3YsO7dtV+tvFi1m4cvUqWrdq6fP2FhYW4vCRo2jZooX8WE5OLs5fuOB1sLVYLNi0ZSs6d7oBMdHRPm8TaYC3fWpV+3ZU+2vWVY2v6zjn/C+2A+LN5YO7ZXg5QUREvlPjG4W1uoHF9ogU1k6fOo0rV65i6F2DERUVBQC4cuUqgPJQePVqHtAQuHDxIg4c/BOJiQlo9VfgNJvN2LFrF5o3a4aqyckoM5nw2++/IzsnB1FRUUivVxe79+xFaWkpmjVtivT0enLNaXFxMfbs24fi4hJ0aHc9qlWrhpOnTuH4iZMwREVBkiRIkoRDh4/g3PnzsFgsMBii5O02m83YvnMnYqJjkHvlCm7o+DdUTU7G6TNncOToMSQlJqJ9u3Y4dfo01v7yK0pKStD9xm44c/oMTp05g0bXXYcmjRvh3PnzOHz4CGrVqinXNpMOBPybLhSBT8l41e7+7qpBmLdlqovvKiKiyOOqT66zbyZ3oz9oYaaRcMJOshTWTpw6hSaNGzmdyqesrAy7du9BTk4uVq1eg2ZNmqBBenkfXKvFit/X/4GS4hIkJSYCAAxRUWjYoAHqp6ejbp3a+OGnlYiNi0WzZk2x6uc1KCy61jy/qKgIqdWqoVpKCn75bR0uZ2dj/R8b0KplCxQWFcFkNuPU6TPYvWcP2rRqhdzcXFgtVvn5ZrMZ6//YAIPBgKTERPy27necP3+hvIwWLVBaWorf//gDdWrXQmq1amjbujVOnz6NPw8fRuuWLbFu/XpcvpyNn1auQrOmTVEtpVqAjzSpQnLyn08Eh/+0ynE71djeQJRJRETknruvb2++jfy+DIjgrz0GWwprgiDAaDS6WULCpcuXUK9eXdSvn466detAEEWcv3gBx0+eRNcuf5drekVRRGJiIhISEhAVFYXikhK0b9cO6fXqIS2tOvKu5pWXKEmwWK04fuIk/jx0GPn5BcjKykL9+vVRt04dtL/+ekQbDDh//jxaNG+G2rVrod31bSE4hO/kKlXQonkzNG7cCPkFBTh/4QKaNmmCevXqomPHv+HSpUuIjY1FTGwMUlKq4tTpM7iYlYUNmzbBbDbDbDGjYcOGWL9hI4pLXI8iTWpSO5zBx284xye4Cnta/ebTy3YSUSA5u9fHVhKkF67OXW+/2bx+D/izMp1jsKUw4PiOFeSfzZs2xZ59+5Cdk4PS0lJk5+RU6pObmJiIq1evosxkQqnRCEhArZq1kJSUhP0HDto14Y2ONsBsNiPKYIAgCLh65QpKjUYUFhYiMSlRXm79HxvRoH46Ot3wN4iiiLi4OOTm5sJoNOLipSyYzWbEx8fjcnYOysrKcOFiFiSrFfYq7JMEVKmShMvZ2TCZTLhw4SKqVq2KqKgoRIkizGYLqlZNRpPGjTDgzv64e9Ag1EirgR7db0T3G7vhl9/WwVqpfFKf47eJGuXYyqo4XDIRUeRyFXjd/UekBY7npT99dRWd32pdlugEgy2FtXr16qF7t2748aeV+Pp/32L37r2IMhiQVr06oqKikJaWhnp166J27dr49rul+OXX3wABqFunNgZk3IETJ08i69Ilubz0evWQnZ2DY8eO4+ZePfHz2l+w9PtlaNO6NVKqVpWXa96sKXbu3oNDh4+gRlp1NGzQAAkJCfh26TJcvpyNtOrV0aplCxQVFWHpsuUoLS1F1QrPF0URNWqkQRAERBsMqF49FU0aN0ZCfDyWfLcU+w8cQI8bb4TBYEDTJk2w5pdf0KJ5cxQWFmHp98uwa88eGI1G/LxmLTZt3oyOHTo4bY5NgaZ2TakACL7e6yUiilwMwqRF/oRbx3I8LuDsfnmYhV1BUjiiTE7WhUBvC5FPLBYLrBIQ/dfgS1azBcsH/z8UX8pHna5Nyx/7a7AmUSgPBrYpcmyPSQCsVisEQbB73CpJ5e/7CtPpVFzOarVCAhDlOC1QheUA/LUOCVbrtfWJf62n4nQ9duupsG3XtrO8DEEQyvcFgAQJklWCKIqQJKn8eaIAAQKskhWSVB6Us7YeR0xSHAYsf4rz2PrEm8GKnM10p7RnjbPiBMD2Ue1xaidXH+lh9u1FREHHwOd/Wxy1yiLyxKfzy91IVyGUWrO2ouV4dUth4tq7UIgS0eyeLvjz8w3IPXg+hNukLTFV4tD8nq4QK4y+7D+NfgIGlZqXJi7K8uoQ81KJiNQX6Z/0NmreOvS3to4TmpE7Po24rPM3OmtsSfcsFiuskiTX2AKAZJUgWfzpUxpOXxH2oV8QA71vFcvX4yekzl57nW0uUaTS46ch+c/Xb0Q/2vh4XQ5FLr2cH6yx1Ty1TqVw+apU43hcK0MQhUqjDPtOb8dYrWnDfWW7B6200ZXejm8I6P1eAZGG8S1FweKsk4orSmrblJTnU60daUsArwHC7fxgsA0Zd2emN4PCBJ7Stfj3RlBjX3h5Uk7t4+DulfV2XXyNfML2ZkReC7dPG7Xf+uF2fLTKXdNltb5BlQXma2vkSAw6U7HNurMXKQhhVy8YbEk1oXojSA4/Se0vJ3c1r3r/GtTh9nP0EYoQ/Ey3p//joa2b9qGm5l4qK8tVayrX5fDrRUPUGj45zDHYao43Z21gmnaG5itF3abIkU1Ssd+NP4NDOVuD8/LUrJCMuMpNFeanC/cp7iLunCDSJKWfNOx7EVjKrx3D/btBd1y9IEGoxdULxcE2Qo8PAE9v6MC/3b079qF8pfjRpw3BeR18HwRD2Zeqf02lbFMhuY7m3tYd6OXsDrf+MoDnc03NXuWhPlaB+gQP9X4RXeNN1ZPjcpF8NRporm8osLJQY5RcmEToW4c1topE6ts5Uvc7Mij/jPP/PFC2rmvrcdcLSNkX7LVPfVfr9vWLWo3e8UrKdFpWkO/KBqKmUyvfrVrZDnItQq/LIoSvn8CRWJsbimn1Kh9nhludi5BaXcXT/RARERERERFpkVrzoRARERERERGFBIMtERERERER6RqDLREREREREekagy0RERERERHpGoMtERERERER6RqDLREREREREekagy0RERERERHpGoMtERERERER6RqDLREREREREena/wc1TdDpi03TzwAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -510,6 +863,15 @@ "generated_text" ] }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import cv2" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/imgs/logo.png b/imgs/logo.png index 11dd2c0..4fa33a4 100644 Binary files a/imgs/logo.png and b/imgs/logo.png differ diff --git a/requirement.txt b/requirement.txt index b447efb..17ee966 100644 --- a/requirement.txt +++ b/requirement.txt @@ -1,14 +1,15 @@ -torch==2.2.2 -easyocr==1.7.1 -torchvision==0.17.2 +torch +easyocr +torchvision supervision==0.18.0 openai==1.3.5 -transformers==4.40.2 +transformers ultralytics==8.1.24 azure-identity numpy -opencv-python==4.8.1.78 -opencv-python-headless==4.8.0.74 -supervision==0.18.0 -gradio==4.40.0 +opencv-python +opencv-python-headless +gradio +dill +accelerate diff --git a/util/__pycache__/__init__.cpython-39.pyc b/util/__pycache__/__init__.cpython-39.pyc index b576813..9cb17e3 100644 Binary files a/util/__pycache__/__init__.cpython-39.pyc and b/util/__pycache__/__init__.cpython-39.pyc differ diff --git a/util/__pycache__/box_annotator.cpython-39.pyc b/util/__pycache__/box_annotator.cpython-39.pyc index ea1949b..c091943 100644 Binary files a/util/__pycache__/box_annotator.cpython-39.pyc and b/util/__pycache__/box_annotator.cpython-39.pyc differ diff --git a/utils.py b/utils.py index 8184e26..40fb079 100755 --- a/utils.py +++ b/utils.py @@ -74,11 +74,10 @@ def get_caption_model_processor(model_name="Salesforce/blip2-opt-2.7b", device=N return {'model': model.to(device), 'processor': processor} -def get_yolo_model(): +def get_yolo_model(model_path): from ultralytics import YOLO # Load the model. - # model = YOLO('/home/yadonglu/sandbox/data/yolo/runs/detect/yolov8n_v8_xcyc/weights/best.pt') - model = YOLO('/home/yadonglu/sandbox/data/yolo/runs/detect/yolov8n_v8_seq_xcyc_b32_n4_office_ep20/weights/best.pt') + model = YOLO(model_path) return model