DeepLearning_Group7.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9cb9d8a4-9cec-4168-be8c-7689693b1846",
   "metadata": {},
   "source": [
    "## Het U-net "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "267c1510-0710-45f8-9545-388cc0f2eb54",
   "metadata": {},
   "source": [
    "**The installations of necessary packages on the virtual machine.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "204833ec-0b01-4e16-b27d-2b3b021aea82",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install nibabel\n",
    "# !pip install medpy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ab2abca-6305-4dae-b82e-7c46370c003c",
   "metadata": {},
   "source": [
    "**The necessary imports of the packages that are used during the program.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "ad3b1525-2161-47f5-87c2-755e8ba13c49",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import glob\n",
    "import monai\n",
    "from PIL import Image\n",
    "import torch\n",
    "import nibabel as nib\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "import numpy as np\n",
    "from skimage.restoration import denoise_tv_chambolle\n",
    "from skimage.segmentation import active_contour, find_boundaries, flood_fill\n",
    "from scipy.ndimage import binary_fill_holes, binary_closing\n",
    "from torchvision.utils import save_image"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33d1eee9-3ccb-40f6-a987-1310c8f226a0",
   "metadata": {},
   "source": [
    "**The definition of the location of the database of ACDC and verification of the datapath location.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ecc87eba-7eab-451f-b2a3-e9ca34449438",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Congrats! You selected the correct folder :)\n"
     ]
    }
   ],
   "source": [
    "data_path = \"./preprocessed_ROI_TV005_v3/\"\n",
    "if not os.path.exists(data_path):\n",
    "    print(\"Please update your data path to an existing folder.\")\n",
    "elif not set([\"training\", \"testing\"]).issubset(set(os.listdir(data_path))):\n",
    "    print(\"Please update your data path to the correct folder (should contain training and testing folders).\")\n",
    "else:\n",
    "    print(\"Congrats! You selected the correct folder :)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78d2764d-fadf-48cc-b468-d7f706206c87",
   "metadata": {},
   "source": [
    "**A modification of the build dictonary function of the tutorials to make sure the ACDC database can be allocated on the right place.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "a1f31258-e559-4be6-a500-4d5385c3773b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 50/50 [00:01<00:00, 48.23it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1076\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# print(img.header.structarr['pixdim'])\n",
    "\n",
    "def build_dict_ACDC(data_path, mode='training', heart_mode='Off'):\n",
    "    \"\"\"\n",
    "    This functioprintn returns a list of dictionaries, each dictionary containing the keys 'img' and 'mask' \n",
    "    that returns the path to the corresponding image.\n",
    "    \n",
    "    Args:\n",
    "        data_path (str): path to the root folder of the data set.\n",
    "        mode (str): subset used. Must correspond to 'training', 'val' or 'testing'.\n",
    "        ----heart_mode-----\n",
    "        Off: 1 dictionary of ED and ES together\n",
    "        On: 2 separate ED and ES dictionaries\n",
    "        secret: 1 dictionary of secret test set\n",
    "        \n",
    "    Returns:\n",
    "        (List[Dict[str, str]]) list of the dictionaries containing the paths of X-ray images and masks.\n",
    "    \"\"\"\n",
    "    # test if mode is correct\n",
    "    if mode not in [\"training\", \"val\", \"testing\", \"secret\"]:\n",
    "        raise ValueError(f\"Please choose a mode in ['training', 'val', 'testing', 'secret']. Current mode is {mode}.\")\n",
    "    \n",
    "    # define empty dictionary\n",
    "    dicts = []\n",
    "    dicts2 = []\n",
    "    paths_mri = []\n",
    "    iBegin = 1\n",
    "    iEnd = 101\n",
    "    \n",
    "    if (mode=='testing'):\n",
    "        iBegin = 101\n",
    "        iEnd = 151\n",
    "        \n",
    "    if (mode=='secret'):\n",
    "        iBegin = 151\n",
    "        iEnd = 176\n",
    "        \n",
    "    for i in tqdm(range(iBegin,iEnd)):\n",
    "    # list all .png files in directory, including the path\n",
    "        paths_mri.append(glob.glob(os.path.join(data_path, mode, 'patient{:03}'.format(i), '*[!gt].png')))\n",
    "        \n",
    "        # make a corresponding list for all the mask files\n",
    "        for mri_path in paths_mri[0]:\n",
    "            if (heart_mode=='secret'):\n",
    "                dicts.append({'img': mri_path})\n",
    "            mask_path = os.path.join(mri_path[0:-4]+'_gt'+ '.png')\n",
    "            \n",
    "            if os.path.exists(mask_path):\n",
    "                if (heart_mode=='Off'):\n",
    "                    dicts.append({'img': mri_path, 'mask': mask_path})\n",
    "                else:\n",
    "                    if 'ED' in mri_path:\n",
    "                        dicts.append({'img': mri_path, 'mask': mask_path})\n",
    "                    else:\n",
    "                        dicts2.append({'img': mri_path, 'mask': mask_path})\n",
    "            paths_mri.clear()\n",
    "    if (heart_mode=='Off' or heart_mode=='secret'):\n",
    "        return sorted(dicts, key=lambda d: d['img'])\n",
    "    else:\n",
    "        return sorted(dicts, key=lambda d: d['img']), sorted(dicts2, key=lambda d: d['img'])\n",
    "\n",
    "dicts = build_dict_ACDC(data_path, mode='testing', heart_mode=\"Off\")\n",
    "print(f'{len(dicts)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "861472bf-f951-46d1-a486-5265e6546909",
   "metadata": {},
   "source": [
    "**A modification of the LoadTranform function to make sure that only the image data is used in the DL model.**\n",
    "\n",
    "Some things are commented out for adaptation purposes later in the project"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "1fcae8ff-968a-4441-89c8-3fbe83fc504a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LoadMriData(monai.transforms.Transform):\n",
    "    \"\"\"\n",
    "    This custom Monai transform loads the data from the rib segmentation dataset.\n",
    "    Defining a custom transform is simple; just overwrite the __init__ function and __call__ function.\n",
    "    \"\"\"\n",
    "    def __init__(self, keys=None):\n",
    "        pass\n",
    "\n",
    "    def __call__(self, sample):\n",
    "        image = Image.open(sample['img']).convert('L') # import as grayscale image\n",
    "        # image = nib.load(sample['img']).get_fdata()\n",
    "        image = np.array(image, dtype=np.uint8)\n",
    "        mask = Image.open(sample['mask']).convert('L') # import as grayscale image\n",
    "        \n",
    "        # mask = nib.load(sample['mask']).get_fdata()\n",
    "        mask = np.array(mask, dtype=np.uint8)\n",
    "        \n",
    "        # mask has value 255, 170 and 85 on the different classes, put them to multi-binary\n",
    "        # mask[np.logical_and(mask>170,mask<255)]=1\n",
    "        # mask[np.logical_and(mask>0,mask<85)]=2\n",
    "        # mask[np.logical_and(mask>85,mask<170)]=3\n",
    "        \n",
    "        mask[np.where(mask==255)] = 1\n",
    "        mask[np.where(mask==85)] = 2\n",
    "        mask[np.where(mask==170)] = 3\n",
    "        # mask[np.where(mask>0 & mask <255)] = 0.5\n",
    "        return {'img': image, 'mask': mask, 'img_meta_dict': {'affine': np.eye(2)},\n",
    "                'mask_meta_dict': {'affine': np.eye(2)}}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba7cba7f-cf8d-47c3-b63a-4ee60285097f",
   "metadata": {},
   "source": [
    "**A function, modified from tutorials, to visualize the images together with their masks.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f088f962-89a4-4c3d-872f-d37a36ebf0ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def visualize_mri_sample(sample, title=None):\n",
    "# Visualize the x-ray and overlay the mask, using the dictionary as input\n",
    "    image = np.squeeze(sample['img'])\n",
    "    mask = np.squeeze(sample['mask'])\n",
    "    \n",
    "    plt.figure(figsize=[10,7])\n",
    "\n",
    "    mask1 = np.where(mask==1,1,0)\n",
    "    mask2 = np.where(mask==2,1,0)\n",
    "    mask3= np.where(mask==3,1,0)\n",
    "    overlay_mask1 = np.ma.masked_where(mask1 == 0, mask1 == 1)\n",
    "    overlay_mask2 = np.ma.masked_where(mask2 == 0, mask2 == 1)\n",
    "    overlay_mask3 = np.ma.masked_where(mask3 == 0, mask3 == 1)\n",
    "    plt.imshow(image, 'gray')\n",
    "    plt.imshow(overlay_mask1, 'Reds', alpha = 0.7, clim=[0,1], interpolation='nearest')\n",
    "    plt.imshow(overlay_mask2, 'Blues', alpha = 0.7, clim=[0,1], interpolation='nearest')\n",
    "    plt.imshow(overlay_mask3, 'Purples', alpha = 0.7, clim=[0,1], interpolation='nearest')\n",
    "\n",
    "    if title is not None:\n",
    "        plt.title(title)\n",
    "    plt.show()\n",
    "    \n",
    "    plt.figure(figsize=[10,7])\n",
    "    plt.imshow(image, 'gray')\n",
    "    if title is not None:\n",
    "        plt.title(f'{title} without masks')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "176daea7-e580-497d-a2ab-55b4e8e54980",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jovyan/.local/lib/python3.8/site-packages/monai/utils/deprecate_utils.py:107: FutureWarning: <class 'monai.transforms.utility.array.AddChannel'>: Class `AddChannel` has been deprecated since version 0.8. please use MetaTensor data type and monai.transforms.EnsureChannelFirst instead.\n",
      "  warn_deprecated(obj, msg, warning_category)\n"
     ]
    }
   ],
   "source": [
    "# RandScaleIntensityd(keys=\"image\", factors=0.1, prob=1.0),\n",
    "# RandShiftIntensityd(keys=\"image\", offsets=0.1, prob=1.0),\n",
    "\n",
    "basic_transform = monai.transforms.Compose([LoadMriData(),\n",
    "                                                monai.transforms.AddChanneld(keys=['img', 'mask']),\n",
    "                                                monai.transforms.ScaleIntensityd(keys=['img'],minv=0, maxv=1),\n",
    "                                                monai.transforms.RandFlipd(keys=['img', 'mask'], prob=1/2, spatial_axis=1),\n",
    "                                                ])\n",
    "\n",
    "\n",
    "composed_transform = monai.transforms.Compose([LoadMriData(),\n",
    "                                               monai.transforms.AddChanneld(keys=['img', 'mask']),\n",
    "                                               monai.transforms.NormalizeIntensityd(keys='img'),\n",
    "                                               monai.transforms.RandFlipd(keys=['img', 'mask'], prob=1/2, spatial_axis=1),\n",
    "                                               monai.transforms.RandRotated(keys=['img', 'mask'], prob=1/2, range_x=np.pi/6, mode=['bilinear','nearest']),\n",
    "                                               monai.transforms.RandScaleIntensityd(keys='img', factors=0.1, prob=1.0),\n",
    "                                               monai.transforms.RandShiftIntensityd(keys='img', offsets=0.1, prob=1.0),\n",
    "                                                ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "cf2179a8-c816-4c1c-8e14-b393c68d77e9",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def from_compose_to_list(transform_compose):\n",
    "    \"\"\"\n",
    "    Transform an object monai.transforms.Compose in a list fully describing the transform.\n",
    "    /!\\ Random seed is not saved, then reproducibility is not enabled.\n",
    "    \"\"\"\n",
    "    from copy import deepcopy\n",
    "        \n",
    "    if not isinstance(transform_compose, monai.transforms.Compose):\n",
    "        raise TypeError(\"transform_compose should be a monai.transforms.Compose object.\")\n",
    "    \n",
    "    output_list = list()\n",
    "    for transform in transform_compose.transforms:\n",
    "        kwargs = deepcopy(vars(transform))\n",
    "        \n",
    "        # Remove attributes which are not arguments\n",
    "        args = list(transform.__init__.__code__.co_varnames[1: transform.__init__.__code__.co_argcount])\n",
    "        for key, obj in vars(transform).items():\n",
    "            if key not in args:\n",
    "                del kwargs[key]\n",
    "\n",
    "        output_list.append({\"class\": transform.__class__, \"kwargs\": kwargs})\n",
    "    return output_list\n",
    "\n",
    "def from_list_to_compose(transform_list):\n",
    "    \"\"\"\n",
    "    Transform a list in the corresponding monai.transforms.Compose object.\n",
    "    \"\"\"\n",
    "    \n",
    "    if not isinstance(transform_list, list):\n",
    "        raise TypeError(\"transform_list should be a list.\")\n",
    "    \n",
    "    pre_compose_list = list()\n",
    "    \n",
    "    for transform_dict in transform_list:\n",
    "        if not isinstance(transform_dict, dict) or 'class' not in transform_dict or 'kwargs' not in transform_dict:\n",
    "            raise TypeError(\"transform_list should only contains dicts with keys ['class', 'kwargs']\")\n",
    "        \n",
    "        try:\n",
    "            transform = transform_dict['class'](**transform_dict['kwargs'])\n",
    "        except TypeError: # Classes have been converted to str after saving\n",
    "            transform = eval(transform_dict['class'].replace(\"__main__.\", \"\"))(**transform_dict['kwargs'])\n",
    "            \n",
    "        pre_compose_list.append(transform)\n",
    "        \n",
    "    return monai.transforms.Compose(pre_compose_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef7f4933-cb87-4c47-bfb7-a250d9f7e18c",
   "metadata": {},
   "source": [
    "**Testing the function whether they perform as intended.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3446979f-bf25-4fc6-80ca-4e67d08bf768",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:00<00:00, 891.73it/s]\n",
      "Loading dataset: 100%|██████████| 1902/1902 [00:08<00:00, 228.59it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 93.04it/s] \n",
      "Loading dataset: 100%|██████████| 1076/1076 [00:04<00:00, 224.45it/s]\n"
     ]
    }
   ],
   "source": [
    "data_path = \"./preprocessed_ROI_v3/\"\n",
    "train_dict_list = build_dict_ACDC(data_path)\n",
    "train_dataset = monai.data.CacheDataset(train_dict_list, transform=composed_transform)\n",
    "\n",
    "val_dict_list = build_dict_ACDC(data_path, mode='testing')\n",
    "val_dataset = monai.data.CacheDataset(val_dict_list, transform=test_transform)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "8268b041-e8d5-4392-a0f1-a348f407213c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlQAAAJdCAYAAAD0l+nhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9eZhtV1km/p35nKq6VXfMvQRICIOAAUFBQiABCZEQEQUCEgUJGAZbA43RRxukhaASGUQaBGlaGpChVUSxRYYOIA0tgxAERFABg5pALpnurVvDmc/vj/t7d73nq7X2PJ5a7/PUc+rss/faa6+9hne937e+VZvNZjNxcHBwcHBwcHCIjXrRGXBwcHBwcHBwqDocoXJwcHBwcHBwSAhHqBwcHBwcHBwcEsIRKgcHBwcHBweHhHCEysHBwcHBwcEhIRyhcnBwcHBwcHBICEeoHBwcHBwcHBwSwhEqBwcHBwcHB4eEcITKwcHBwcHBwSEhHKFycMgRz3zmM+Vud7tb0dlwiIiXvexlUqvVIp176623ZpyrxYIrN4eqwxEqBwcRqdVqof4+8YlPFJ1VK7797W9LrVaT17zmNUVnJXN8+tOflgsuuECWlpbk2LFj8oIXvEA2NjZyzcMrXvEKef/735/rPYPwta99TV72spfJt7/97aKz4uCw59AsOgMODmXAO9/5zrnvf/RHfyTXXXfdruP3ve99E93nf/yP/yHT6TRRGnsdX/rSl+TRj3603Pe+95XXvva1cuONN8prXvMa+cY3viEf+tCHMrnnS17yEvkv/+W/zB17xSteIU9+8pPlCU94Qib3jIOvfe1rcs0118iP/MiPOCXUwSFnOELl4CAiT3/60+e+f/azn5Xrrrtu13GNra0tWVpaCn2fVqsVK38OO3jxi18sBw4ckE984hOyuroqIiJ3u9vd5DnPeY78n//zf+Qxj3lM6vdsNpvSbLru0sHBwQ5n8nNwCIkf+ZEfkfvd735y/fXXyyMe8QhZWlqSF7/4xSIi8pd/+ZfyuMc9Ts4880zpdDpyj3vcQ37zN39TJpPJXBrah4rNdG95y1vkHve4h3Q6HfnhH/5h+fznP584z29/+9ulVqvJ//t//09e8IIXyJEjR2T//v3yvOc9T4bDoZw4cUKe8YxnyIEDB+TAgQPyq7/6qzKbzebSeM1rXiMPe9jD5NChQ9Lr9eRBD3qQ/Nmf/dmue21vb8sLXvACOXz4sOzbt09+4id+Qm666Sap1Wryspe9bO7cm266SX7u535Ojh49Kp1OR84991z5n//zfwY+z/r6ukd0QaZERJ7xjGfIysqK/Omf/qn12tlsJocPH5arr77aOzadTmX//v3SaDTkxIkT3vFXvvKV0mw2PTOi9qGq1Wqyubkp73jHOzxz8DOf+cy5+504cUKe+cxnyv79+2VtbU2e9axnydbW1tw54/FYfvM3f9N773e7293kxS9+sQwGg7nzTGUocppI4r5vf/vb5SlPeYqIiDzqUY8KZaZ+5jOfKSsrK/Lv//7v8uM//uOysrIid77zneWNb3yjiIj8wz/8g1x00UWyvLwsZ599trznPe+Zu/7222+XX/mVX5H73//+srKyIqurq3LppZfKl7/85V33esMb3iDnnnuuLC0tyYEDB+TBD37wrvQ0/u3f/k3uec97yv3udz85fvy4iIh84xvfkMsuu0yOHTsm3W5X7nKXu8jll18uJ0+e9E3LwSFruCmXg0ME3HbbbXLppZfK5ZdfLk9/+tPl6NGjInJ6MFtZWZGrr75aVlZW5OMf/7j8xm/8hqyvr8urX/3qwHTf8573yKlTp+R5z3ue1Go1edWrXiVPetKT5F//9V9TUbWe//zny7Fjx+Saa66Rz372s/KWt7xF9u/fL5/+9KflrLPOkle84hXywQ9+UF796lfL/e53P3nGM57hXfvf/tt/k5/4iZ+Qpz3taTIcDuWP//iP5SlPeYp84AMfkMc97nHeec985jPlT//0T+Vnf/Zn5aEPfaj83//7f+d+B44fPy4PfehDpVaryVVXXSVHjhyRD33oQ3LllVfK+vq6vPCFL7Q+xz/8wz/IeDyWBz/4wXPH2+22PPCBD5S///u/t15bq9Xk4Q9/uHzyk5/0jn3lK1+RkydPSr1el7/927/18vupT31KfvAHf1BWVlaMab3zne+UZz/72fKQhzxEnvvc54qIyD3ucY+5c37qp35KzjnnHLn22mvli1/8ovzhH/6hnHHGGfLKV77SO+fZz362vOMd75AnP/nJ8su//Mvyuc99Tq699lr5+te/Ln/xF39hfRYTHvGIR8gLXvACef3rXy8vfvGLPfN0kJl6MpnIpZdeKo94xCPkVa96lbz73e+Wq666SpaXl+XXf/3X5WlPe5o86UlPkje/+c3yjGc8Q84//3w555xzRETkX//1X+X973+/POUpT5FzzjlHjh8/Lv/9v/93eeQjHylf+9rX5MwzzxSR06buF7zgBfLkJz9Z/vN//s/S7/flK1/5inzuc5+Tn/mZnzHm61vf+pZcdNFFcvDgQbnuuuvk8OHDMhwO5ZJLLpHBYODV6Ztuukk+8IEPyIkTJ2RtbS1SmTk4pIqZg4PDLvziL/7iTDePRz7ykTMRmb35zW/edf7W1tauY8973vNmS0tLs36/7x274oorZmeffbb3/YYbbpiJyOzQoUOz22+/3Tv+l3/5lzMRmf3VX/1V6DwjrVe/+tXesbe97W0zEZldcskls+l06h0///zzZ7VabfbzP//z3rHxeDy7y13uMnvkIx/p+2zD4XB2v/vdb3bRRRd5x66//vqZiMxe+MIXzp37zGc+cyYis5e+9KXesSuvvHJ2pzvdaXbrrbfOnXv55ZfP1tbWjGUJvPe9752JyOyTn/zkrt+e8pSnzI4dO2a9djabzV796lfPGo3GbH19fTabzWavf/3rZ2efffbsIQ95yOzXfu3XZrPZbDaZTGb79++f/dIv/ZJ33Utf+tJd9WF5eXl2xRVX7LoHzv25n/u5ueNPfOITZ4cOHfK+f+lLX5qJyOzZz3723Hm/8iu/MhOR2cc//nHvmC5D4Oyzz57LA8rnb/7mb3zLAbjiiitmIjJ7xSte4R274447Zr1eb1ar1WZ//Md/7B3/p3/6p1356Pf7s8lkMpfmDTfcMOt0OrOXv/zl3rGf/MmfnJ177rm+eUG53XLLLbOvf/3rszPPPHP2wz/8w3Pt4u///u9nIjJ773vfG+r5HBzyhDP5OThEQKfTkWc961m7jvd6Pe//U6dOya233ioXXnihbG1tyT/90z8FpvvUpz5VDhw44H2/8MILReS0ApAGrrzyyjmT1XnnnSez2UyuvPJK71ij0ZAHP/jBu+7Jz3bHHXfIyZMn5cILL5QvfvGL3vEPf/jDIiLyC7/wC3PXPv/5z5/7PpvN5H3ve588/vGPl9lsJrfeeqv3d8kll8jJkyfn0tXY3t4WkdPvQaPb7Xq/23DhhRfKZDKRT3/60yJyWom68MIL5cILL5RPfepTIiLy1a9+VU6cOOG9g7j4+Z//+V33vu2222R9fV1ERD74wQ+KiMyZIEVEfvmXf1lERP76r/860f2j4NnPfrb3//79++Xe9763LC8vy0/91E95x+9973vL/v375+pHp9ORev30MDKZTOS2226TlZUVufe97z33Hvfv3y833nhjKDP2V7/6VXnkIx8pd7vb3eSjH/3oXLuAAvWRj3xkl/nUwaFoOELl4BABd77znaXdbu86/o//+I/yxCc+UdbW1mR1dVWOHDniObSH8e0466yz5r5jELnjjjtSyPXu9DEw3fWud911XN/zAx/4gDz0oQ+VbrcrBw8elCNHjsgf/MEfzD3Xv/3bv0m9XvdMQcA973nPue+33HKLnDhxQt7ylrfIkSNH5v5AVL/3ve9ZnwPkTvsYiYj0+/058mfCD/3QD8nS0pJHnkCoHvGIR8gXvvAF6ff73m8XXHCBb1pBCHqnKDNdRseOHZP9+/fLv/3bvyW6f1h0u105cuTI3LG1tTW5y13usiv2lq4f0+lUfu/3fk/uda97SafTkcOHD8uRI0c8Uyrwa7/2a7KysiIPechD5F73upf84i/+ovzt3/6tMT+Pf/zjZd++ffKRj3xkzk9OROScc86Rq6++Wv7wD/9QDh8+LJdccom88Y1vdP5TDqWAI1QODhFgGrBPnDghj3zkI+XLX/6yvPzlL5e/+qu/kuuuu87zlQkTJqHRaBiPz5SDeFzY0jcd53t+6lOfkp/4iZ+Qbrcrb3rTm+SDH/ygXHfddfIzP/MzsfKGsnj6058u1113nfHv4Q9/uPX6O93pTiIi8t3vfnfXb9/97nc9nx0bWq2WnHfeefLJT35SvvnNb8rNN98sF154oVxwwQUyGo3kc5/7nHzqU5+S+9znPrtIRlSEfadhA4aaoBc9xEGUuiEyn/9XvOIVcvXVV8sjHvEIede73iUf+chH5LrrrpNzzz13rt7f9773lX/+53+WP/7jP5YLLrhA3ve+98kFF1wgL33pS3elf9lll8m3vvUtefe73228/+/+7u/KV77yFXnxi1/sLYQ499xz5cYbb4zy2A4OqcM5pTs4JMQnPvEJue222+TP//zP5RGPeIR3/IYbbigwV+ngfe97n3S7XfnIRz4yZ2Z729veNnfe2WefLdPpVG644Qa5173u5R3/5je/OXfekSNHZN++fTKZTOTiiy+OnJ/73e9+0mw25Qtf+MKcOWo4HMqXvvSluWM2XHjhhfLKV75SPvrRj8rhw4flPve5j9RqNTn33HPlU5/6lHzqU5+SH//xHw9MJwkREtkps2984xtzjuPHjx+XEydOyNlnn+0dO3DgwNwqRJHTz6yJZdI8RcWf/dmfyaMe9Sh561vfOnf8xIkTcvjw4bljy8vL8tSnPlWe+tSnynA4lCc96Uny27/92/KiF71Iut2ud96rX/1qaTab8gu/8Auyb98+o9P6/e9/f7n//e8vL3nJS+TTn/60PPzhD5c3v/nN8lu/9VvZPKiDQwg4hcrBISEwk+eZ+3A4lDe96U1FZSk1NBoNqdVqc0rIt7/97V0Rwi+55BIRkV3P/IY3vGFXepdddpm8733vk69+9au77nfLLbf45mdtbU0uvvhiede73iWnTp3yjr/zne+UjY0NL2yAHy688EIZDAbyute9Ti644AKPhFx44YXyzne+U77zne+E8p9aXl7eRXKi4Md+7MdEROR1r3vd3PHXvva1IiJzKyTvcY97zK1OFBF5y1veskuhWl5eFhFJlK8oaDQauxS39773vXLTTTfNHbvtttvmvrfbbfn+7/9+mc1mMhqN5n6r1Wrylre8RZ785CfLFVdcIf/7f/9v77f19XUZj8dz59///veXer1uNAM7OOQJp1A5OCTEwx72MDlw4IBcccUV8oIXvEBqtZq8853vTM1cVyQe97jHyWtf+1p57GMfKz/zMz8j3/ve9+SNb3yj3POe95SvfOUr3nkPetCD5LLLLpPXve51ctttt3lhE/7lX/5FROaVk9/5nd+Rv/mbv5HzzjtPnvOc58j3f//3y+233y5f/OIX5aMf/ajcfvvtvnn67d/+bXnYwx4mj3zkI+W5z32u3HjjjfK7v/u78pjHPEYe+9jHBj7T+eefL81mU/75n//ZC3kgcjrswB/8wR+IiIQiVA960IPkox/9qLz2ta+VM888U8455xw577zzAq8DHvCAB8gVV1whb3nLWzyz8d/93d/JO97xDnnCE54gj3rUo7xzn/3sZ8vP//zPy2WXXSY/+qM/Kl/+8pflIx/5yC4V6IEPfKA0Gg155StfKSdPnpROpyMXXXSRnHHGGaHzFQU//uM/Li9/+cvlWc96ljzsYQ+Tf/iHf5B3v/vdcve7333uvMc85jFy7NgxefjDHy5Hjx6Vr3/96/L7v//78rjHPU727du3K916vS7vete75AlPeIL81E/9lHzwgx+Uiy66SD7+8Y/LVVddJU95ylPk+77v+2Q8Hss73/lOj6g7OBQJR6gcHBLi0KFD8oEPfEB++Zd/WV7ykpfIgQMH5OlPf7o8+tGP9pSbquKiiy6St771rfI7v/M78sIXvlDOOecceeUrXynf/va35wiVyOnteo4dOyb/63/9L/mLv/gLufjii+VP/uRP5N73vvecSefo0aPyd3/3d/Lyl79c/vzP/1ze9KY3yaFDh+Tcc8+di9Fkww/90A/JRz/6Ufm1X/s1+aVf+iXZt2+fXHnllXLttdeGeqbl5WX5wR/8Qfn85z8/53gOEnXXu951ztxmw2tf+1p57nOfKy95yUtke3tbrrjiikiESkTkD//wD+Xud7+7vP3tb5e/+Iu/kGPHjsmLXvSiXb5Fz3nOc+SGG26Qt771rfLhD39YLrzwQrnuuuvk0Y9+9Nx5x44dkze/+c1y7bXXypVXXimTyUT+5m/+JjNC9eIXv1g2NzflPe95j/zJn/yJ/NAP/ZD89V//9a5tep73vOfJu9/9bnnta18rGxsbcpe73EVe8IIXyEte8hJr2q1WS/7sz/5MLr30UvnJn/xJ+ehHPyoPeMAD5JJLLpG/+qu/kptuukmWlpbkAQ94gHzoQx+Shz70oZk8o4NDWNRmizCNdnBwKCW+9KUvyQ/+4A/Ku971Lnna055WdHYcHBwcMoPzoXJwcEgFphhQr3vd66Rer8856zs4ODgsIpzJz8Gh5BgOh4F+RWtra4ExmLLGq171Krn++uvlUY96lDSbTfnQhz4kH/rQh+S5z33urnhXDg4ODosGZ/JzcCg5PvGJT8w5KJvwtre9bdfmvHnjuuuuk2uuuUa+9rWvycbGhpx11lnysz/7s/Lrv/7r0my6uZuDg8NiwxEqB4eS44477pDrr7/e95xzzz3XC3rp4ODg4JA/CiVUb3zjG+XVr3613HzzzfKABzxA3vCGN8hDHvKQorLj4ODg4ODg4BALhTml/8mf/IlcffXV8tKXvlS++MUvesth/fbxcnBwcHBwcHAoIwpTqM477zz54R/+Yfn93/99ETm9x9dd73pXef7zn78rhonGdDqV73znO7Jv377ct1pwcHBwcHBwWHzMZjM5deqUnHnmmVKvB+tPhXiKDodDuf766+VFL3qRd6xer8vFF18sn/nMZ3adPxgM5rYVuOmmm+T7v//7c8mrg4ODg4ODw97Ff/zHf8hd7nKXwPMKMfndeuutMplM5OjRo3PHjx49KjfffPOu86+99lpZW1vz/hyZcnBwcHBwcMgDpu2RTKhEYM8XvehFcvLkSe/vP/7jP4rOkoODg4ODg8MeQFjXokJMfocPH5ZGoyHHjx+fO378+HE5duzYrvM7nY50Op28sufg4ODg4ODgEAmFKFTtdlse9KAHycc+9jHv2HQ6lY997GNy/vnnF5ElBwcHBwcHB4fYKCx88dVXXy1XXHGFPPjBD5aHPOQh8rrXvU42NzflWc96VlFZcnBwcHBwcHCIhcII1VOf+lS55ZZb5Dd+4zfk5ptvlgc+8IHy4Q9/eJejuoODg4ODg4ND2VHJrWfW19dlbW2t6Gw4ODg4ODg4LDhOnjwpq6urgedVYpWfg4ODg4ODg0OZ4QiVg4ODg4ODg0NCOELl4ODg4ODg4JAQjlA5ODg4ODg4OCSEI1QODg4ODg4ODgnhCJWDg4ODg4ODQ0I4QuXg4ODg4ODgkBCOUDk4ODg4ODg4JIQjVA4ODg4ODg4OCeEIlYODg4ODg4NDQjhC5eDg4ODg4OCQEI5QOTg4ODg4ODgkhCNUDg4ODg4ODg4J4QiVg4ODg4ODg0NCOELl4ODg4ODg4JAQjlA5ODg4ODg4OCSEI1QODg4ODg4ODgnhCJWDg4ODg4ODQ0I4QuXg4ODg4ODgkBCOUDk4ODg4ODg4JIQjVA4ODg4ODg4OCeEIlYODg4ODg4NDQjhC5eDg4ODg4OCQEI5QOTg4ODg4ODgkhCNUDg4ODg4ODg4J4QiVg4ODg4ODg0NCOELl4ODg4ODg4JAQjlA5ODg4ODg4OCSEI1QODg4ODg4ODgnhCJWDg4ODg4ODQ0I4QuXg4ODg4ODgkBCOUDk4ODg4ODg4JIQjVA4ODg4ODg4OCdEsOgNJUavVis6Cg4ODg4ODw4JhNptFOr/ShGppaWlPEqq9+MxZwpWng4ODg4PGbDaTjY2N0OdXmlA1m809ORjuxWfOEq48HRwcHBw09pRCVVW4ATw6XJktNtz7dXBwqDococoZbuBwcHDQcP2Cg0P54BSqjOE6vmhw5VUs9lL55/2sce5nuqZWq3nHg9LUvyd95qzLLMxz2X6L+qz1evRF69PpNPI1QJTBNurAXARMecwj32Uum6j1wxEqh8ywlwZzh70FJkFRruFPnZYpzajf4+Qn6+tBdMISJ30dn6fPNZ0TBXow5wE0aKCPQgSSELe8oJ8nD6ITt1zyImGOUGWIvUYQ9trziizWM/MArv+v1+vSaDS8c9FB8Sf+/M5JG0XMVvN853yvsKpUmLSyOD+N6+OQKdM1/L8fiUr6jJx20GBqu5eJmOg867TjqGtREeZ5OO9hyrIodUnnrSwqV6UJVZxZokM47MVyXaRnNpEoEKl6vS7NZlOazZ3mjw5pOp16RAr/43dNsrKa0VadVKVhwspSmcoaQaqRH4nS55iIVF4qXaPR8FWw/NLUxESnkweBioOs61VQOVRByfNDpQmVQzSUuRNOgjI9V1gfmFqt5ilE9Xrd6luDT5tJSMNGRvR1zWZT6vW614HxvSaTydwgMJvNQs3GTQNHHJTpfWaFJKpKFZQp27VxFKms8hY1PZPSJGImAZyOqf3odpJlnce9bCQuTxIT1EdwnxQ1XUZRipUjVHsEizpIVeW5tGJUr9el1Wp5apHfQANVCX9+QGdkU5FMpgY+dzqdSqPRkMlk4uXVBFwTxkwQpXOryvtkpOFInpZjdtS8pQmum2HzrclUWNOeX5ph8icSXm1Kmm4QiSi6zsclMSLBeTc9dxD5qbJq5QjVHkDRDdYPZchbXuYe/AZFyqY4QbnS54cBOkc9Qw6bZ1yPT9NMOsyxKL87zBPUsiBKXuKYsPzIVByEyQPuYVObgCDVCWnoNDkfnEZU0p0HuE2GVd6ioqi2X5Ri5QhVhVGmzjcOqpb/sB1/EKmC0qTPazQa3u8m80fYQUvPOLlT85v96XtGUZvizsKrRLSyUofKSKaioOzKlKkumwZcG8GwEYugfIRta1nD1jazMr+Z7sOwmTtteTER1Dh5yKOvcYTKIRUUORikce+0fDaCTDdh/KBM10VVAOIoVbifX0eqSVcWPlRlRFXJTtYog3N10tAJQdeF9T3SxEC3h7QIShwEqWum3xyiwxGqEqMqnfgikKm0O2HTOWEUINN1cQctk9N5GH8FnV/d+frNOKNK7WVTrrIk51Vpz3EQVZlKM80w1yY5X09K/Ex7fL52Rg8yM6aJtNScLBzZbX1RWKUqjTxkBUeoHBIh7UGi7OnFvb/JhKeRBYmIMyuGSuWwd5FHu0nDdyoozlXaMN3HNtAHKVZZIqjdB/VBQcpVkWpbXORR/o5QFYSiB/ogFJG/LO+ZVtpxZsl+nZepkcMpPK08a/Nfnqvu4twzjfvmiSwdjovwryqKTNlIfBg/rKj+TGERxjmdoVUobXbPalA3pZm2omMyYSZJO65SxfePM1nMklQ5QuWQKYqcOeadB9M9/WZ6WROpvLDIvlNFwS/2VxmQhoKZhjKVNcIM2kEmvqhhFOIgrTTDOJDbyFsRilXZlDJHqDJCWTvDRZvpZp2HONebrjH5JXF0ck2kMLNNW6XKCkEdelTfqiogS787Ef+AkGVoWyLRfafCmPnSUJuCzolSfqaI6Qw28ZkWadhIVRIkie+UtlLF6RehVKV1vzTgCJVDJRDF+btIhMkDm/r0+SYiBcKVF/w6Ghdv6jTKUNeKQJl86/KeHIZdJQvYTPp55ieN+zCC/MHKphjlDUeoYqKMHWqevg95Ik8ylebqIIZfHBhEKOdjIiKTySRUdPSwqNfrXgR0Dd0JcnBPv2fQCDv7q6JilVXdCANbEMk075EkrSBlyg9Rfaf0b0n8sMKkH1TWNl8injSlpQ7Z8siw1RVTfhlR9yn0I1Vh09Npm/KbpaKUNhyhioEykqlFQdl8obJEFF+qtFSqMDPbuArVImPR6l6RKAsJzAJ+QXUXBWFIVZ7IgqzGhSNUBpStkWpkmb8in70IMpWlH0xY85+O/dRoNHbtycdbwqQJ3QmxWhZlr7Oks8qyKFZp1LM821CePlWmAJphlSmb75RflPWgNMPAlmaU8go6V9d1vwE+7F6cSRBWxTQpV2Hvr0mVLT1GGQhP1nCEyiFXhO2cqo6ovlT4zp9sdkvTQd0vPzbVzGFvI414T35kKkk6ZYFNrfHLb9naWdJQCHsdC02oytrwwmLRlKiyvY84+UnrGbRjukmpqtfr3vHZbOZtmiwSfzBisqaP8b1MJC9O5x/X/yGonOMOREW2qTj3Dus7FfV4lHyFjfcUZ0+/JOf6+U6loUzFgamMggJs2mI7aaTlk6R/B6IqVmHrZFT4EdOyEVCNhSVUZRu8y4SymvUW6Z5hYCJVIvPBAOFLNZlMvM467vOYOkcdvkH/xp/6/yJRhc61TIgb1yqsMuVHBLJof2Ec0aMijXRs/lOmMqhC/S1q1V5VSVWlCVUeZpA8UDb/oKrdMy+EfbYoZWAjVSLiqUUw/Y3H47lVQ2F8WPx8pPQKQxzDSsC4qpQJWazUKUtdKyIfefhO2eqYVqLSImpBddnmhxUGeb0j0/6ZcbeBAbRvFhDF38mUnum8NFXoKL5laeanSFSaUC0CyjIopI1FU8GyIFOAKRggjmPA0h1Lo9GQWq3mmQGDzAxahdJkKi0T317DorZfE5nyIzZpOozrfNjumRbCmgujpBeGVIX1s8wTZSMxUfJThtV+jlDljCIH+6rfsyhkSaY0bMEAtaO6Ph/QA5DNZ4rjUZnIVVRiFbbjy0KpyhtR33MWvlU2RFGuTOdofykbocmT6GR5jyyAiY72i0waSRxIS7EKq1Tt9WCdUeAIlUNslKWDKwNJTYtM6fRAaNiPCqSKO1Tta2VL30acYF7k41FVqrLNbrNAVczzcXymtCplU6mimPnirhoLQ6aS+jxFVaailqfJBBbH7OWXZlZIaq7bq3CEKmOUYbCvyr3KgjIOmrojZf8qkWgDnc13yha+IQtwPqtCwoog2UFI05dKpxGGTEXZMy8qAYqjTJWpv4JShUmOTX2Oky6jLD5Ki6A+J4UjVA6BKEsnlUc+ykimGKxYcbraZyNoINOKlP7Ms1OsgrJVljYQBVHIFitCJofxKGTKRoSyLsM4qpnfdUnzq019TKribv+StmIVte2VQakqM3FzhCoDpN1xOEWq2mQqDoIGQz9fK+64RcS6f59JldL/+x0zIS45qgKp2qswDf6mY1xXy9SW/JAVmdJpmUiVSDakoAykh1FmApQ2HKFKGVUmU0Xes4g8ZGEmSQNhlQU/EhQ2X1E7uTQd1E3Xxc1XWihD3c8KScyD2rcq6NwskVbcqbhkKuz9tWocJv0kGxdngUUkQ1k+iyNUKSKtjiSvTn2RB4+9jqI7wKSKUxGKVdqqRJ73i+OEngXKkIcksOU/yp6DfA0TobihE2zX6jR0e1nkvfRMfUMZns8RqpRQNTJV9D2LvHdZlalFQxqkyg9Zpl22dMPApkDp46bVpGVC2huAh4Wff1hcVU/vxYntpAAd1sTvPgjFYDo/jMN7kvAHaa76S2qSzGuiFceX1BGqFFB2MlXGTtPBoSiUqT0UnRcMxNPp1AsSi7AcZVG98kCWz6kJBBMfmxk1SMmykaMymM33MhyhioEsGl9VfIaqmIe8TTkOO8jSB6NM76JMebEhSKmaTCZefDMOIMv/g3yJlGsPvSQwKVNZTJJNwT5N5yEffsF9oXhhwYlJlTQpVknVoTTacxlMcyak0Uc5QrXAqOKqG4dyw63GSwdla4+sVCFvJlJVtnwnRZLnibvwI6zpTatNaHtsRoy6T+Citt2wJC3r53eEygeLoho5H6ni0ly0AUgkHqlatNVCeQzEadzLhKB3wGE2OCJ/o9HwTIMgX0WqS2mXS5RniXJvP6UoCKb4cppUhb2nvn9ZlSIgbF8R9Bw2pS/M/ZwP1R6GqXEt4oDukD8WjRAVBR4Yo5yfB0yhN7TfD8xMJlIVN3RHVZCURKfVdtjvyhZjjs8DFtEnLksyFQeOUBHyrGyLVrHL8DxlUqYczKi6CSJPZSovBL0DDFrwsarVajIej+eip4NU8ScG8DI8N5MJdroXCecaUdQz+MWlYsKbN+LcN6lZzrT9Vph0bKQqTN/jFKo9hLIoUmXoMB0cyoyoylQZ4KdYMWEyhRjQjutleG4Tqaoq4pjsyhDSIymikrIkZCoO9iShWgSfojJ0UCKLUZZZpF2W95MV0jIBllWx2ssrQ/1WAwLY8Bdg4qRXtuE4+2OxuhV11WCS8rSRKjZfZvW+0g5pUAQhjJPvsNcEKVM2MmWK6+VHnKI8g1OoAlC1zi0ITpFKH4v+fEmQtS/Voq0irKIyZYOfP4rJfKZVLIQMgHN7UepVkC/RIvoaFQW886TQaQQpT1n7StlQaUJVFvt8GCyKMrWoilSe93DwR56qVR5qRJ5I875R9v4zxT1iFYvJ03g83nUMpIv7dNP3qPkKglaltCnQ9QfzyMJnCxHJgxQoE4H3O6cIVJpQ7WXsNQd6R6Yc0kaZ61TRoRXiwM+84rcCUDu3g9A0m6eHpyzCNJjMmmUowzIjiKyEXVGnzwkiU3oLmDj3yQuOUGWMLJQpR6bKe48ylFeeyCOcQpXKtEp5DYs0FCFNWLi+sA8VRwHH/1C0QKxwrknNigO+P0eJh+KWtj9d0QTAj5z4XRNGndLnme5lM9+FVZ2KLj8/OEJVMVSJXFQlD2V43qohDyJVZeSlTOWJpOQiyK+FfzcRJb3JcL1e36VeRc0fk0VN5vYKqQpzrokkmcoE52lVia/nc/zyVHQZxYEjVBkhi1Vie4VM5YG0n3MvrwoTKe9qvaxRxXdVBYDE6IFcE6rxeOyRqiSqFeorx9oq83Y7cXyZ+Bnx3UYWWU2azWbGAKLab46Jl5/aVJTDeB5whKrEyLshL7rDeRH3iosq5FHEnM9F6BijIosJ1F6DbRBG2fBGwDrsAv4HuWo2m96Kwij3xH1Y+QpKoyj4kRO/a/S1NnPsdDr1zK3T6dSoUpVldV1Z4AhVyqhqx7pXOvQyK1OLhEU1CRalHDvMwxRgVGRe2dIrClm9CsJsNtvlAB81Db+0tcIUdW+/6XQqk8lEJpPJrrSCHLyhOpnapiZNrGbxcb//F63NR4EjVCmiSo7NRQ8CRdy/6Gd2cACq1FcUDT/fGt4g2I9AQXHS5kFcxwoMx85iJ3WbaTHqs2gSEsfvazwee4TKVD4mx2+QI/2spk++Lmre9jIcoUoJVVWmisCiPKtTu8wIsxS97B2v37tYlPe0KGBfHnZgF9khVkwmtJ8Vn6/NjBzGgQkVnxOHEGmfJO2rZWsf7NME8mgiQyZCpX2c0lCXyt6O84YjVCmgCrPNogeBRVOkii7PqqMMK51syOLdOvKdLWyEQBOLOOVmusYU/NOWtsmcF3ZjX/09jNN3UFoO2cERqoRwylQwHJkqR9p5I0id8nvWrAaBKOVbhYlSnliE50irXrGDvA06srspH1FW62lFKcyzZNWOHEkzwxGqBKhCh7toZKbo+xf9bHsFWShYWb075/NYHcSpU3HroR/pSlq3HaEpJxyhigmnTJUTVSRTe60uhHnetIMpRrm3wzxcmSXDIpGfRXqWLOAIVQyk2cEsgm9F0R1ulRWCostukRCmLE3+LmFj51S5nsVBmfKSFItCBIp8jkUpwyzhCFWBWKQOqygsyiDn6sI80nIe9juPP21+XWH8vfS5cX93cHCoNhyhCoEqDHZ55rEM5VF1klOGMlwEcDkGlSkvl+dl8TpeEX43LY/322bDthJLB1MsO7FapLpZ9rIOC6dMVQPhwrNGwMte9jKvg8Lffe5zH+/3fr8vv/iLvyiHDh2SlZUVueyyy+T48eNpZ6O0iBsQzmEx4epDMHR/wn/8u+lcxBHizXSbzaY0m01pt9vSbrel1WpJu92WTqcjnU5Hut2u99fr9eY+u92udDodabfb3v+tVstLA+kg3Var5d0Pf41GY1e+TM/l4OCQL3jSE2fyk4lCde6558pHP/rRnZs0d27zS7/0S/LXf/3X8t73vlfW1tbkqquukic96Unyt3/7t1lkJRGqoFDsFWVqUZ7TDZb+0OUTVnUCearVTu/jVqvVdkXHBplpNBrSarWkXq97n81m0yNcIvNKlcjujWV56w9TtGmoUjgP+6IhyjWCM+J6Pp//bAEY08Qi1slFUVUW5Tn2CjIhVM1mU44dO7br+MmTJ+Wtb32rvOc975GLLrpIRETe9ra3yX3ve1/57Gc/Kw996EOzyE4pEMU04bD42Kt1IAxBsn23XQsyBSKlSRJ/gky12+05YtVutz3SJSK7NsRlc54mU5pU8X5r0+lURqORR6T0d5AtEC7+v1Y7HeEbpkaOCO7g4JAcQYFQS6FQfeMb35AzzzxTut2unH/++XLttdfKWWedJddff72MRiO5+OKLvXPvc5/7yFlnnSWf+cxnSkOoqrLyLutB2SlS1bpH2RGGLJlW4UFhEpnfCgSKVKvVkkajIb1eT5rNpnS7XY8swcQHQtVsNj1THJ/TarXmCJUOyshqkUlJ0kqUSZliAobj2EIEn6PRyPucTCYe+dL3x/+mvdwcqo8yvNMy5KFqSJ1QnXfeefL2t79d7n3ve8t3v/tdueaaa+TCCy+Ur371q3LzzTdLu92W/fv3z11z9OhRufnmm61pDgYDGQwG3vf19fW0s50Lqmjmc0gXVX93acdfsxEpJk0gTtqEh//hp7Rv3z5ptVoesYIKBeWq3W7P+U/B/IdjbPLTYRVAYkzEShMkkCFNqPDHpj8QKSZTg8FAGo3G3F5tMDVyGrg/K1gODg7ByMqMnjqhuvTSS73/f+AHfkDOO+88Ofvss+VP//RPpdfrxUrz2muvlWuuuSatLO5C1Qe5tLBXFKk877lIdSvqs5jO1yvneMNZNs+xcgTCxA7eIEP1el06nY40Gg1ZXl72zHlMkpgssUO4vr9pFaDNP0qbALXypD9ZTWJTHxOq4XAoo9FIhsOh9Pt97zcmcvg+Go1kOp3KcDicU7mQH86rg4NDPsg8bML+/fvl+77v++Sb3/ym/OiP/qgMh0M5ceLEnEp1/Phxo88V8KIXvUiuvvpq7/v6+rrc9a53TSV/VRrwnLN0NVH2sk0jf37+Tfy/DlcAggPSAzKE1XNYdYdVdY1GQzqdztw1OL60tLRLfeJ7MJGK+8ymzXeZZGnnc9t39sNiQoW/ZrM556fFhIqJVKPRkMlkIv1+XxqNhgyHQ8/3Cs/pSJWDw25k0S4yJ1QbGxvyrW99S372Z39WHvSgB0mr1ZKPfexjctlll4mIyD//8z/Lv//7v8v5559vTQPLmdPGIvsglR2LqkgVca+iYfJ70uQJf/BV6na7HnECKWq1Wt4nhx/odDoeUdIhENgJHb+zSRDqk85fWqjX63PqFfI2m82k1Wrt8p0y+VINh0PvczAYyGg0ksFgsMukCIf2yWTiEarBYCDj8Vg6nc6c2RCKFV+r1bZFRNWfrer5LzPyKNvUCdWv/MqvyOMf/3g5++yz5Tvf+Y689KUvlUajIT/90z8ta2trcuWVV8rVV18tBw8elNXVVXn+858v559/fu4O6VUYXBfVJLVXyEZZnjNr3z0/PyhtygORWl1dlVar5ZnplpeXpd1uS6/X2xXjyUSU+D6aQGUJU/pB99RxbbQzO8jPYDDwzH4w6TGRYmVqMBjIZDKRVqsl0+lU+v2+538FYsW+WLgP8rOIWNTnckgXWdaT1AnVjTfeKD/90z8tt912mxw5ckQuuOAC+exnPytHjhwREZHf+73fk3q9LpdddpkMBgO55JJL5E1velPa2TAirwGuLANpmbBX/LPK9u7TNOdp0sJ+R6b/G42GZ8Lr9XrSarVkaWlpjkjBXMeO5LwSz6Q42fJTZpjIJlQj/A/iCcd2JlRQsVqtlkwmE++8ZrMp4/FY6vW69x0mQ/yGP5gHNbFyRMRhkZFn/a7NKtia1tfXZW1tTQ4cOBC6My1iUE17RVQa2IuKVBXffdL7p5mWXnnHgTLZ/KZ9lZrNpiwvL0u325UDBw5Iu92eW4nHZjptzvMz2dnIVdrPnzW0cqV9pvCdVw5qU99wOJTxeOwpVP1+33Nsh4qFczgkAytWcGKvOio4lO1CmZ6hTHlJgiQTh+l0KsePH5eTJ0/K6upq4PkLs5dflTpSh2xRtCJVtbqoiQr+1+EKEH6AA2TqOE+8aq7dbsvS0pK0223PxNfr9eauBQkzESOT+lS1sg0CPw98rxDAU5tOJ5OJ1Ot1L+gnCBFiZw2HQxERr0xh7oMyBYIFR3UoY0hHxKlWDg5JsDCEapHglKlq3bMIpG3KM+0th4EZ6tHS0pI0Go251XYwz3E8KFzLJj4oUhyB3ETabCY8kxpVdQQ9z2w288iS9qUCOWq323OmP/ahgpoFnyz81m63PTULJI3Ni3x/BweH8Kg8oSpT56pXOTksLqr6rrX/kzbZMZGC4tTtdn0JFW/5wmY/08o8zoP+35bXKIC6U0X4qZ3a3ApiykFL8RtUKZAsJrv4zlvbNBoNa0R3keqoVlDeHByKQuUJVRlRhlV9e0UdcveMlgYPxCA8ti1asCIPDuMw1+E4CJfN74kdym2BM7PAIpAqbfYT2SHBUJJQ9tPp1FOqTEFF2f+K/ay2t7dlMpl4n9pPC995f8KyExZHqhyKhCNUKaOqHbmDP6rmK2XyRTIF0OR97bRvFMx0WpmC6oRVeOw4blv5Fwd6M2C/dDSJ4kG1zO8pKljl43Lm54eyhG1poERpQs3ncpBQ+GuBvFUtnpUjVQ5FwRGqEqCqylSRA9WiP2dSldMUgRxxoHSwTE2oQLaYQPGeeLiPST3Bb/w9DBA2wO+ZTCSJyZZNmaqyYsUwLRpgMoVPECO9ByFvW8NO6tvb27uULERf5xWE8MOCOZCJiyMwDg6OUKWCsnTWZcnHIqEKvlJ6kBWRXWoTzHQciVzveYfzQaD4048kMRFKokjBjKVhUqhMipRJmSjrO0sLun5CleLYVlxWMN01Go25aO2oL6xUwR+rXq/LcDj03j/8r9jPCnDEyqGsyEO5dISqQFRNmdorilQV7snmHhGZU6KYQMH/CYE0EX2cFSf2gWLfKPwehSRFLTOtOsHkZDJpmfbRs91PHw9jNiwKeuPlMOeCMOnnQVmhXuAcHGPVCn5XvV5vbp/A0Wi0S8mCOtXv971PqFe8JY7Op4NDmZA1qXKEKiUsOtko40CUF7J+9qjpM9HgGFHYG48jj8P/CRsHw9RncibX28SY1KI0n0MDSopWqrRJy3QN/kc+TIpVmetwlE7edK5WqvyUOlatWF3Ecaz648/RaDQX36pWq81Fc+d350IvOJQJJpeBrOAIVUWx6CSqLOpQ0YOwybmcFSSY6ODvtLy87ClSrFBh2TyHLzCtvGPH5ajQKpAmM6YOja/hfPgpVXye6dNWjmE61Dzft1am/PLH+wBGGRigZAEoS6RVq50OdyGy46iO8zl8AkdsR7yr4XAo29vbMhwOZXNz0/sO/6siQy9U1TG9TPkuU16qAkeoEqIsA38V71FGlKlsTUSHwxro0AbYIw+ESoc4YEVKp8/3yaIMtMrktyoPeTEpVfx7kLN5kGKlESbNtBGGTJmuMW0XE3XwY1Mgp8FmQ3xiD8FWqyXj8dhb0ABCNpvNvI2aYTrklYJFqFZVJQRlyneZ8lIFOEKVAEk63rjXZtXZF02gFpWYRgWTGqgyIEQIcYBVethcGERKm/ZMflDaNGS6f1LYOmAepPFdkyoM7vgNCodWq1hpsRFD0/3DEDA/+KlhYcsurFrDRItX65mu59/5nLj79HH5sikQ9+h2uzKZTGRlZWUuQvvm5qaMRiPZ2tryvvOeg/jUz+fgkDX83AbSgiNUCRFnACobmSoai25ajKJIsV8LfFVgrut2u9LpdDwTnyZUOtSBKQ5UEWXNHVaQ/4/tdxADDhWgVxdqFcrmW5UFopariRT5EVEOrKmvsf3FIVP6OXQZMrGCSY/VqVarJaPRSJrNpoxGI8/XCmkhT1gp6PfcDg5pI0syJeIIVWWQ9kBYNDnb64oUEx3emoVVJY4d1el0pNfr7SJSUKI6nY5nmgEpC+NblAZ4eT4QZNrjwVSb8jQB5D8s82d/KpPJUv+WFCaTJKevn0ufy+fwM5uIEN/TRpKgQnG8KRwLo3zFBZc1v1s4sMM0uLy8PBfjamNjQwaDgZw6dUr6/b4Mh0MZDodzz5CFv5UzWSXHopdhmsTeEaoKoExEIA3sdUVKkwQoUZ1OZxeRghmPCRUUKt4rjzclLgImUmVCmE5LEywTedKKFV8LMhnV58ovL3E7W50PE3liIqTvZzqP/9fECr+ljSATJ1SrZrM5l59ut+v5XA0GA+9cvCNTgNCojvdh8r7IhCAPLGoZpq2SOkIVA3n6Ti2CMrVX7ukHE4nC1i0gRRxIkx3Ol5aWPBKFsAe4Nk6sqKygo52bFCsM9ra8mkxO2k9KK1FMrvi++lxT+iYCY/rU+fMrc5uJVatMJpUK0E7cJkUK3/0IlM5/muqPCabI7VhcMB6PpdPpSL/fl+3t7bkI7OPxWMbjsbeSkGNbpbHlzaISAof0ENSWw8ARqpjIw3eq6AFyEVBGRUrHjOp2u3OKFL4vLS1Jq9WaU6YQlBNKVNnqiGlw1yTLpB7x73zcZNbDJ+9rx9eC2OlyN5Epk0qkn4EJnTal+pW//o3Ndfypn9uURxALbB/D+/X53TcqoUpjsshpQLHiVYLD4VD6/b5n+sMWOHBYh4P71taWp2xBzUpqrqwKqUpbOXHwR9gJXhAcoSop0hoo94o6VBSx8GuIGPTZP4q3dIHahE8mVKxQwV8K12siUXbwoB/GLCgiRhKlj3OkcCgh+J3/x31t+dK+SThmyk8YJTCIHJlIjZ9ZECEItGnPdJ8wdcKkAmYNEFHEvMLEAgoVK1LD4VBGo5Hnh4UVg4htBSUra7XNYR5VIqRFwRGqEqIqA2UZkXXZhR2weCsXDsKpiROUKTia4zh/x3V5PF/WiOrfo4mQTa3iTyacJhKkTW3aoVurZPxnMmn6+T3ZBv0gMx3ypE1e2mRqM2X6fbepm1nWLZQfTNWIXaWfkYOHwqF9fX1dRqORnDp1yiNWtVrNU+uiDPRVU37Klt+y5adscIQqAtKQw7O8R5ZpFZF+We9tgh5wTUSKfaOYOPV6PY9Y6RhSUKXK9rxRYFJigjpkkwqlf9MwRX63nW9Sgfi4vpcma/p8k7O5n1IFmMx+mkCxic8vb/qYfm69ubEmitpMmiVM5BcqLvsGwmmdQzAgJANMhYhrJeIGeodi4QhVRETtaKKcXyUyVUZk8cxBaWrfGpAgBOBEME4oTiBMrVbLC8LJwTh5UKkyTL47NuLhB7/y187nfL6NROnv2sRnU440keLrobDYfLCC8q9NjkykTA7sQc9p8x/DuSDoXGe53mVF4E3KH/Krz5vNZtLr9WQ6ncry8rKMx2Pp9XoyGo3k5MmT0u/3ZWNjw4txxcFCw0A/X9mJWNmUobLlpyxwhGoBkRWZKpsiVXR+TIoUfJ1AqPDH31mZ0ooUOz3bSFUWy+LjwM8XyOQTJGJ2yNbnR72vzd8qTDpaUTLln1cvamUKalLY6OQmdUqbG/2iopsUKv5fE3wbqWJFCiqoJlRa7dJp439bXkx1IIwTPRM/EfHMhNheCRs1j8fjOZ+8sHG4HByygiNUC4A8iMVeUbzCKFJsIgEJ4rhQ+ETgTUQ3hzLFUc1NA5iIfXWWyO4Nb/OCzQ/I5H+klRz9BxNW0D3CqEo2hSpoYDURKL9n0udoAuRHqDRpYzJmI1P6XqbyAGwmNE2GTEoVPjmWGX/qRRVazdLmQtOzh40thffGRA9ptNttmU6n0mw2ZTgcSr1el62tLanVanN7CPqVk999dZ4dguGUqnk4QhUCe4VMlAllVKREzKY9XrHHRIq3i2GTH3yqeDDie/AsXX/Po+OykRrTJxMDPqb/t6k4trRthNFEcGzmviASYlOmNMkx5TGMDxVgMiuays1ErnT+/d5/WBWJJwUmAsX1kgk/+/RhIjGbzXadi/pqKte4QL5ERNrttoiIdDodmUwmMhgMvGO6TJPcz5EEh6hwhCokshzM46ZdxjxV5d5h76FNewjCCTMdzHZsvgOhgnmPfad0ME7OiyYIeXXoJgJl+zMRCRxjx2mbImVSgGxkzJY303ERs8pgMy2aFCMTibENzjxw63T0s+hy0d9NipfOr+277dn1Mb3yUWRHocLvmmCBNOETkwfEUcMEgoPUYjUqyI9NiYwDEL2lpSVvc2asFsQzoHyj+lSZUEbVqqyKUFnzlTccoXIoFH7EpmhSx3+8UTE+bYoUPmHmw6BjU6TC5EUk/c4qjPLkN+CblCnbdVqVsRGZIN+qsGqN6Xl0+jZSZSJTQaTTL11TQM+g69I06cJEHETgQYJQ1+E7NplMvL36ms3mXJgDvs5Ur9Ous6xUIVgo2uF4PPYUMpy71wd4h3zhCFWBiEoYFk2RyvOecRQpJkE6qjn8oKBM6SCcMPVhRs95sOUlD6XKj0RoB2tWlfwUK/4MSgsBGaEgaJIRNv9hTYI2ksRp6XKxnWcjWialypRHv3vkBSY9WCGnlSyTjxX7S+mFFxysFgouK1asfpkQtX6zUgWCh2Oz2UwGg8Euv7Y02lCZFKuyKkJlzVdecITKB853Kh9kXc5xyJTJ3MFO5yBLHO0cxItDJujNe4tCGCKF/21hAPxWpbEZS6eniZX+5HyFeQ7bIGkiPPgeRG6AKCQoSGWypanPTRNBdd2UFyZZiPuE/EHlgcoF0tJsNr13ClUIn+xbhfR5Q+SweQ16TrRP9ktkgqU3XnZwyBqOUFmQVsNPA1ncvyyKVFFlqx102awHMsQd9dLSkjQaDe8TwTgxS9ar/Pxm5HkCgz5vqqvJjt5wF+oRHxfZrcwwKdJpaTLFhCpoVaAp/3xO0Ao4v1V2+v+oKpFpcM5jwA5bl3Rewlyny4BDRIBk4ThPOljFxR8mFry9Eh/HJAM+WshjlLaCOgFChbaI4zBPIpK6Ju5poQyKVRnyYMJeJbKOUAUgq0GxDINtESiD2dJGpjhKM4gUO5mzzxSHR+BPmEOKBpMLJksm8sPfRcxmOROxQVqcpiZQtnuZ1B3bc+jBUH8PQ8psZVMU8lItoTJFgY1godx4hSDeLSYjWqkS2TEdssM6FC60vyj55PfJbRcBdBFNfTqdeuQqrEm56igTkcnSl66scIQqQwT5ysS9Ps28ZIGi1S99f+27ZJphs/mAncmhPLESBV8q/jSZNPKENulhEMEsfTgc7iJUTLSY9OhPm0+VJlSsPpmu4Wtt5jmbac32W9TyiYqs3qeNtNjAZCYq4pAqBpv6kJ4mtyBN2CJGrwxkpYpXwYIEsbO533NoZRP3ArnDgpF6vS7D4XDXxsq6PqaJsvgPlYlUAWXMUxZwhMqANDrRpGQqTSzaPaOkzSoUgJky77fHy8E5CKdWqDAwsM+GDoOQBfw6I01QTGQHQQ/9CJUfKTJ9D1KobM7bYQmVTVmqAsqmQKdBqjRAsmq1nf0BQWr4E/5XzWbTqzeY1CAdjl/l9wz45PwgHaz6m0wm0u12vXyJiHdvXFsW8pMVykhg9oJi5QiVQhl8p5LeN+98F6l+afMdHzNFfOYZrSZUbM5D2INer+f5TsE3hD/9IkQnhSYZJjOeye+JSQ6UqfF4bCQ+PMiY0jApVlC99HEmXX6EKYyZL8yxRQLKJEulKm3YlCv4XSHkgojIcDiURqMhg8FAms2mDAYDbxcB9j/USpWpPEzqXq1Wm5vsdLtdGY/Hsr29LaPRSPr9vvfJitVoNPI1B8apd2Uha2UkVUCZ85YEjlBZUIYOqwrQJCat9ML+biJUNgKlIz7DNABShb320MmDULGPFJsy8qwjNjKlyQ+UKL9PbRY0qVr4zooVfzddi3yGMdtVBTq/Uf18Fr0f0UoRv3+tSoLUQyFG3dGO7zgGQhamT2AzI9rnaDSSVqsl4/FY2u22t10NJg7Ij34O5BdpV63OMsqsClW9bE1whOr/Rx7KVFSykFa6aaAo1Uu/F/6u1SHbKiQQJ5AgzGRNUZ9h3uN4UrhWRAL9PJLApkjpkASIBD2ZTGQ0GhnNb4gxhN81oTIRI/zGzuisXPmZ8/C77ZkcwiFLpSqp2S8IUKz4fiIyR5hwnsgOoZlMJtJut2U2m3mhR+ALFWXChnbPK3RRz3u9nkynUxkMBjKZTOaUqtFoJKPRSCaTiQyHQ699MeFihK3TZVGqyoxFI1WOUCkURaaqgrSfI4wDOX8GkSj8D7JUq9V2bRfDpgH+hEIFIgVyFcZhNm2YyBX7Q2EAwKc2x2kTH/tQ6eNs8rP5QrFZhAeZKvs5xUFUIlM2pSoPUsVgkyD7NJnUUiZDHN09jH8V0tfnaHMkJhggVnBa397eluFw6JkI8TviWXFaVYWt/Ip+Lts7qyIcoSoBonZwZXH4TuM+NgXKpkSZVCgR8RQndMBYtadXGLGvFCtUHPkZK4+CIjynDa30aBWJZ86YScMHxESo2EfERKj8THgmJ3KTCc8hHKISmbBKVdWAckCdHA6HIiJzxIlXzQLsxB6lHHX/gr3/oIxAxWIFC75Wg8HAa288SdFtzOaDVRWzYdnzVyU4QlUwyjJzZWSRp6hKlIjZhOcXXFD/D9IEx3LepJj9ofCpiZZf/rPqgJi4aBLEqpQmVNo8h2s1odKffE0U4lRkBxzk1G5DmuQkrsmNUca2nzaYGJoWVwAgOyI7K/LQjnlVXtwFIOxfiXuIiHS7XRHZmbwMh0PPFDgcDr22BvI3Ho89ooUtbobDYSApKbsKU4Q/qA1lLys/7HlClYfvVJh7Z3F+UWmGuR86Rk2g+DeR3Q7mpv3FmEAxQYIixYSqXq97nzhPK1p64DWVURqzOm2O0CoTCBTID5MozJy1TxTIF/tScRo6wKZJkdL5s+W7atA+PlVAkFJVNpNiWLBKhPqK0AtwREdd1ZOtNJ9Zuw5g8QkUbW47UKhApECshsPhLv9Ek9kdea9q+3EIxp4nVEDevlNl7QDTypeNhNiIlB4wdMgD/aljR2nTHe+zh+CbIFa8GoiJWtR999IiVdrPCR00kyEQKe07pQkVK1PwFeHOPY75rugBIK4iFZRWGuQqiepUVTKUBvRqQJAZEZmLHQV1ihUuHItbbqb3zq4DIjvKlV6xyG2JHdtBtPj4cDj0VC2e0ITJd9FtLktE9eWqkmLlCFWJkWZH65dW1h26SZUyqVEmXylTyAN2XuXtXti5nD9BqPAdabEKlrevFBMpVpOYUPHMF+SJCZXJN4pX9WnCZVOiyows85qFYpW10/cig5VahEyAXxXqONouzk+7rHkfQ5Hdfdd0OvX6pG63632fTqfed27HaLPcHrVibIrjhuerCpKYvhcJjlDtAWRFpsJca1KlWAnSxAq/6Wjm6EhNK/I0uWKFik18WIZtmt3GLQdthggCd5ysRPF3mBS0uY6XcmvCZFOubAQqTH6L7vjyIH6mVWlJEXWg3wtKlZ/pEiQCRAp1n1f3YdJjUnjClluUd6vP5RWHmLxpsIKmF4ho3yusKtzc3JTpdCr9fn+uD9BplhUm39e0EFaxCjo/T+xZQlWk71QYJHG8TDPNJNBkShMpm+mPCRSb9uA4zkE4NaEymQBZkUqTTEUByA06WFaeQKg4Fg6TJG32MylSfNzmF1WGDicsqqSimZC2ehKkppVdGQtDZliJghokcnpSxepUEQQ0TP6RXyaCTAgbjYa3cTPCMXQ6HRmNRtLr9by2b1o8AsIpsttcWhS4L03zXcR9pjRcMJJizxIqoGyO6Hn7cmWRhjbhsb+SjVBpEx9iR8HRHESq1+t54Q2wz54mUOxszubCIsFmOPhasDIFfyfuVNmsx8RKk7EgRSpqJ1NEp1QWApWmYuVIVTjAPwpECnWaJ1SNRmPu3YC0AEU8t74n/K+QL72iEABB0n6T2i9rPB57cbKgbrH5kEkb3zdLaAKlyyDIdSKJy0GY5ytavdpzhKrsylQU2By/i4SetWgyZfKT4nPZOdzkYM6O5lCnONSBdjBP4ryaBliV4jhS2v/J5ISuyRP/8bFFUKQWFVUlOUWA6zCIAitWZVFmgmAiGSagf8Lz8upGvUVOrXY6KGqj0ZjrH0TM4U78EKXstBqoLQo45qca2oinvgf7rWmymOQZTHnIqv7sOUIF7BVlKg6i5kU7bpqIlA7Wp8mONvEh5MHS0pI0m01ZWlqai2Cu99bTZr04zxEHQQ0TA8JwONylQPGnDtapzXvsQ6XjSMX1kSoDyqJM2RAUtiAMwpKqvUy+UM8BrVjPZrNdgXbRzwB5lV3c/hFgdQ2/IeBor9ebM+HzykFEcOf4WLoP0OTKNtHSJMYGnU/db+N6WzphFvsgf/wu9epKU56SQBPzqP5aNuwZQrUoylQR/j9B4MYmsiNxs8nNTzXi83jfPd6UGP5S+NSBOfMmUkFAA2VFiU142mmV/aL4uw7Aqf2kqkym9hLSIlVVjKVlgukZ2ewH5WY8Hs8tUBHZcRAHMShDe48KJokcBoKfi32n+L2z6wT6A30+zKhMVkwkhY9raJMq+mh8R97Zv0uDCZW+DytStvyZfuNrbQhqIzaCqfPoCFUAytb4ouQnj7yHuYcmLrwyz+S7xB0AN0i+FmY7RDOHrxQUql6v55n8mKCViUQxQI6gTLECxRGWeVUfH7eZ/ILk/SRkKk8iVnZlSiNPpSpMXpLmQ6Q8bYbVFBAK1H0M2hhUeXsa+Fmi3xEpzzNFAZ5RZIe4IFq8iHjPByd2jkkHtYoXqIDcsEkQn1zW+pgpX9rigDLXZjsmVLa0eZKJ73yO/gyTR1Oe+dMPmriayidqP7WnCFUVGxuQNnFImg7PqJg4sS8TN0jtGK5/46CcrEz5OZ2X8X1yQzT5O5kimtuinLMalTWZcsgHWSsqVVJsOJ9MErGiD3UfEyiQLIQ/0cpLlcGkCt9BHFEe/BuDiSgTAlwDAsMKmE0BwjG+F0+SYUHQhAqxuDhPNiLH5kKocwx81/n2g8ms6ufLZjKJmkynUbGnCFWZUAWfKpuDIZv2eNaCeE9BlRlAR8lO5isrK3PRzRFLClHOdVDOsoEjlGMGyb5T+pOVqn6/P+c/gZlnVKfTOMhrUKqaMqVRJqWqqPSjIEo5aVLFz8EEQ0S8OFCstuWlUuWl8PGEk8tG+zNpVYpJCggp55vT0nVFKzwcSJl92sJC+2uxqwPeMRMnvsZmKvQrL5SJtpLoCb4pj5wf/A+VLyz2BKEqS+cSB3HznvYzsyKlK63e8iWsegS5nn2ksIpPy/llJ1M8G+MYUabwBiZlimdI/PsikSmHHfiRnjQG7DKRqigwqU7oa3gghgkMfUSV/an8AMLE/a/I/FY5MIOin0R/wn5ODPa/0uRMu2LwPqcmS0MQNInTvp8cDZ+j4iMPJgXLBtOKcr1y3ESqtErFi4CcD5VCGRoY56FMypTfvbjSaT8oTaDg39Rut42VFZ+mTrLb7Uq73ZZ9+/Z5vlLsnM42+zKRKX4WqEpQpngfL6zM0av3+FP7VAWt4KsiFuU5gKKVqjTunyWS5EuTKrQHkZ2+iAN98iCfp09lXOIbdgJjO4/9yqDwi+z4TKE82MFfm/mQDqep+1cQkbB9r98EQee5Xq97hIX7OV5woP83lQPuy2OU3lkDk349QefrMT5pBW04HPo+s8bCEyqRYklV1gpT2umbOibN+PXGxHAUR+UFtNSLY2gAersY/JnuVyYyZQIrU7xFDEc7t/3pVX+8asdhsZFUqariqr8w7Vg/F5SDer0uo9FIRMRrO+hH9EqtMvcXQQhDuphIiMzHd2J1CuVgUoBwLl/D/2uiFTRu2H5jUsWEDu9Zn6PTNdVxzhNbS7gsWGHjxU+mcYUJlYjMrTANi4UjVFVrREnym4R0+c3oTKs7mP2jA8OKPPadAliRwmyTO7pa7XQ09F6v50U959V7IFZldkAX2VnNB/MeK1Q6mKdJmeIVTbwqJy8ylYe5zxHDbGEjVUWYwILIXZT86IF/PB7PKeWDwUBEZE5tsPnJmNJLC0nbkN8iE16B5ucoDVMfSCeIC46bSJOGVnz0/zaEeadMmPBsqJ8cFZ/7PibJfn2IXuCET9OYxbtr8LmcRy73Pa1Q5Sn3poko+Y1LomzfwxIprpyokFqZ0rZ5bjQ2hYrjSnGD1nGryghWk/T2MEGqFPtP8bYxjkztPej3oOt7EqUqT1IVlkzFyQ8PrFiwAYLFA2QVFTsT9Ao57dwNMOFhsonfcDwskF7YdxV17NKTalaH8KmPAUGkSn+y+Y+tIfDTtZk0OS8g7WFRaUJVdjMQI4jgxEnD9ruf+iQyH2wNREjLx5pEgQAh/gsrU5BF9f14ywjOI9+LA3SyIqU7h7JAmzGZFPFeW/p/Jlp6E2QMEotGpvYCshjA45KgIklVHm2Vfarq9bqn8GofKlN/ViXoyZVNmQpSrdD36j7YBk1y2I+N04lLovAdCho705ueRec5TP+oVSc27+nA0Ey08Lym9KLAEaoCEZf9B9mrNbHRzof41GqUyE6F5N/ZoY+Db5qc0HFfvWpDn8Oxp1iJKtM+fDag4Ws/KF7JZyNRep8+Xs3nyFQ1kRepKqtSlSdp4QkIfKl4EoZ+xaR4VAGmCZuNbAQRKpHwpCrLMtLKD/r5KAqU6XlNz4Nxgz95rNGf8Nu1qXlR+8pKE6oqIknFDTLb2aRfTU40mfIjVpBMtR2ar+V72yo5NxYOrcB/ZVvJp8EdnI5ZEiZwp/apSpNMlZEk7SVzXxWUqiwQ5j5pt2eUC3wO4efC6od2F+A8lGWFpA6EiWPcv3Cfw9doZZv7GQ0bMde/5933+k38Gdr8ycdNriSmsUmPL6bxxqRGRS0PR6gKQFjlKex3P2LkR57wu4hZmWK5FKY+fNoan20mxP5RmDVoosd5Lxux4tmRiSTxd61OsQlQn5OUTJWRSInsLTIFJH3msMpSEqUqTURNP632jHYI30N2wq7Vap6PDCtVaechbWjyxGTJj0xpdwFTfxDWEpJ12YQVBEzQqpTN5xSkiC0etvFRj5Om+hy1jjtClQOiVlRbRdPphFGacJ7JaU9kZ8NRXm5qckbHctOwgd1sZEt/atWsjNBkSkTmOjMdoFMTLP2bdkJfNOxFMpUGoprrghQsnV6a5q+i1R2Azee82o/9c3hgZeStVOl2YfKVYuXbpsigX9EKuY1QAdzvar+mvOA3poUdV7QJ0+SIz2OLiaza8pUUjlBljCjkQ1cGvpYVHnya/I40YeL0OC3tBG7zZeJQBnHIFCq+SZLl/GilqizQtnsmVtqMx2qUVqr0dyZneT5L1nBkKhls5acHfR4s8iZVZSFTKKvhcOjlCeSiVqt5IQT09iMixfYxJiWKCZSO24dPfb5pVXHYNh72+dO0FHD/H1dk0P8HAfWdy83kv5UWHKHKCMyi/SqQJhJatdHnsJLDHYWWNvU9+NparbZLkdKkSXdCcRQkv+fXpEo/cxlgcwLVUrupszNJ8fhtUeHIVDGISqryQl6khVUb9GFY7t5qteaCRxbhSoB2gT4BihpPzNAvsAKOZ+NPk88U+1ulQRSyIJ1JyFRSmEyk2pzK/yfJnyNUGcJmzzYRKCYUWmXyM+vZbL8M7RdVq9U8E57eowm+BzpfcSuZ6TpbjKkiG52GzVavTX2muFN+yhWuXTQs4jOVCdo8FTRwmsxbRU1Wsm7L7FOFdjkajaTb7YqIGLevirocPimm06m3HRUC/7IfmDbx6ferfzN953slhckHVySZ+0oR9Q9lgbqB5+FxDuelkT9HqDJGEIHSBEnEvCqPP01qVNjKgOtMCpQ+ngWxMTmcl4VEATYyZTP/mX4X2e1nxZ3gIhGQRXoWB3+USUHWYBWYQ5mI7ChVIrKrj0vbl4rb+Gw28+LRDYfDuX09tc8UX4vnMT2jzQ8oLmzm5LT65DL07dpdQ0eVr9frqZjDHaHKCSbiJLI7PIEfkbKtfgsyxzH50oqUVqyydA5H2ian9zI0OpHdS3FNxClMFHRWpngbmiKc0LO8pyNT+cI2+GtzRZoO6ECZyZTIbqUKZdVsNmU6nUqr1ZJut+sFeIzryuAHVo22t7dlOBzKqVOnZGtrS0ajkbcBukmpDuNQzjBNvOMqQbaJvsnVxJYfU37LstgIlgMQWu06I5KOqdMRqozBRErETI7Y8ZtftK6U/KKTNBrtT5CXqY3vwcTSdN8sBoQg2GaEJmndpFjZfKZMdvpFgCNT5UYRbUik+EUl7FOFWFVQhHhXB6xeRn8YV6nSqhKC+G5vb8tgMJB+vy/D4dAjVHxN2DZkUpFYcUNaUfJuIxCm/jjOOy26HjBYheLV1qgDIjvuNknajSNUGYLJgw45oH2W/HyhTMfDvnCTIqTzpc2HfvcViT6Q8sxJk0je/NhEqqI+bxyYVtTgUzuUamdzkzKFzlxvPcNkrOpYhGcQSVe9y3MAiTP46wE4ayQtjySKGNrn9va2NJtNGY/H0mw2ZTgcettmQbFCxOw45cLtAO399ttvl+3tbTl16pT0+/1UzHSma9Fvjsdjr3/lRUB+5a/dRUxmvjiKjU3hKgPYt7VWq80FQoViyWQqTt4docoYWhUSmQ86xkTL1oHErZS260zH/RSwWi3cXlB++dDqVBkbHMNPTfJzVNd/OB9Ii4gUqXQ5MuXAKFsb5qXyIBw4jg2UsXSe41WJ7N7VgcF9olal4HQ+Go2k3+/PqVJhEKcM2ckaeQAp8EtT9+1pkSlGWft2lA3MfnrREI/FXJZh4QhVxuDNF/EdMiP8mfxmYmnM8myM20T2TNfg/6gmK61MsVJn2u07b/gpU9rUZ1vhZ9pyxrSybxEG76oSqbzKXt8njzptW/2X5r3juhcUDe3sDZNbvV6Xfr8vjUZDer2eNJtN7xO7QbA/qe35mUgNBgO55ZZbpN/vy/b2ttcHRMkrEKXs2MzHCriftYNJk4k4+fk9hclbGd69DWgvINxQrVqtloxGo1171Ubt8xyhyhhcsbXZDRJzURXQNNCYZi9JZylhfLfKApM8H2Zln45tUpZ4U4tA5BziIy2CFXR9mdowQ5vZWY0CaeJgj1qN54ml7hPY0Xk0Gsn29rb0+33PhypJnqOSKs4v+iNtwvRTpkznxEESc1me4HAKTDBbrZanaDYaDe//sHCEKifwajo4wYlkX/FMsrAN2scJn5A+sYImTCXTvlo4ph3wtf+UbaaWxuxfpxHGWTxohR+rUBwRXZOvqqNK6lRZyrsIxSoIaTgtZ400VhNqUsJmQEx8oCI1Gg0ZjUaebxXUCajoTEyYSMFP8uTJkzIej2VzczPyABw2/1GuM13L79LmcmFSpqIQ6bJNjv2grQ+sXrIVKazJFnCEKidok1cRwKyFnao5f/jEHzvL4/wwDca0eq/M6pQmPSbyoFf38af2lzIRqbwH+TTvVyUy5WBHEtNdGdppVJhIFcAKElZ7wVmZ6zsmUZwGm/ShTMEhPc12l/UqzSyUKf1/maFJFd4/6gOvygwLR6gyBCpWo9GQTqczt3lnEoRptFCk2DmzVtvZ3wrKlXacBuFrt9vSarV2dUj1et2LpQKwXZrvzyRSK1J+vl1+z2lSssLCRHCC1Cnb6j79h04WDZN9rTh9P6fXMqIKeS2LIhWELPybgmC6V5Czss05OYvFFUUBfSMUpe3tbU+pqtfrnkKFvorVaagWOIaQDGWASXXS/9vOiUKKdN9dZeKt/RB5vHQKVcnAJjQ29eUNVljQOZrIBPLabDaN+dW+AdqhWytd/L9WpfwUKvZnMEn3ScDPrX0sbOfzddqHSodWwLl+q4WqMCBVIY8O0RCVTOn2irbAg09VwX0fb1vDflUi4n2Hb1TaSlRaMLlZALY+N02zbhXJFMNUlx2hKhHgM9XtdnNTpvS5rFKJnFag0CnA/MeNClGEbWZJ7YPA9zLZ5nUj10qVKX32+bKRKhOC1CtNovzIlIk06RV+rEaZ9vGr8uq+Mg+UVS3TsgKrkE3x4HS/xWo0O3inVV/S6CfjAu1bT3jwHf5TZax/um/lFXz8aVMfo/hK8fcqK1NZwBGqjNFut6XdbheaBz9TF6s1rE4FNRDbSjZewuunUPmlr5f9mkhVXERVpjSx0sdM5sAsHdLz6MzLTKYc4sE2geHB1rSMXk9ksBpORHaRDn0sTh6LgvavKtsqXb++T7tP2MLe2JSppP2qI1M7cISqAjANonE6Lp558XYFTAJEzA0Eq9cQrI4VGH0+EwuGbrxhTXmsVIWB6TwTqfRzPtf+Iuy4qBUpjj9l8ptySAeLUqZF+FIBrE5g4hTWp1EfN5mumRRF6aPSJlN7aZDHO+RdJ0R2xwEE4sSZClKoHE7DEaqSIwmJ0JWdne+030+QeWoymchgMJDBYCDD4dBIwGBa1OQorGOsjZz5XWM7N0gdCkOmtK8VkyomUzoelS39PLAopENjUZ8rD9hMeUyookCnY1r9C3NgmHZQpDJVdXBMQ721mXa3iEqYbb87EmWHI1QlRdgVNX4DjYmgoPNDmrxU2E9ZgVMmR/7WqyPwP+RyvbrN5jAJMhKFMCVBXAd0v5AJvF+fSeVyiA9XjuERNJHRRCrJ4MhKiGmlbxhS5chUfMBEq7cu0ztw+ClSQFyS5TAPR6hKDN0R6YElzkBTq9U8EiWyQ6gQe8PPoRsRgTXxYlLGfhhaXdKdvcnRHMc0WUsyqAbNkm3O6tonikmVDvCp1asqkoAy+k5VsRzLANOiEHzX4VDSuo+uP9px3SE9MJnieIEgzCI7bh1Fkamo772M/U9UOEKVA0A0wqowfuaotPNlcqy2naujgGuAVJnCCIRFWs7nSaEVQiZSmmSxCTAsqhI6oQg4EpU+tJqRJpg4mZQqIK/3Wob+I02YnMk5SLSO9cfnpZ2HsGW7V0m0I1QZg8lFFFLFn0ngR3zYPAeFyuZoPplMpN/vW4kDrmG1C7FcbMTBRsz4/iazokZcYhJkLmUndCZOUOmYSMVZ1VeWWD5F35/hyFR60Gb2TqeTGdkwkSocFwn2j0wrD4sGTaZYhQKhYjIVxYwb9byg8219dNj3HkTCytRP2eAIVY6wkSq/VWdZgFUwVl3YXMWEhk1cQSQE14hIKLJhKosiO0ZTPk3PYHJIj0qoHBzShGkwhcNyGD+aNO5vq/9RVuk6nAa/L95blZ3QTaEuikAQmfIj1jbo+lIFVd8RqhzAcZU0qdIDdNbQpizsto2VeyBB7GM1Go1kNBrtMgnaCBII22g08pbzsuMklwFfI7K749VKVVrPbjqufadMPlNardIqlg5B4RAOrrziwTSYslLRbDY9H5sswe3WNvDFHUjD3HvRoH3gQJ5arZZxg/mioO8dFF4hzLvy66fjhuXIC45QZQwepE1mLFaKisgb8sXEgHdMt/kHhVGqtCO3aTXfdDotbLPoMPBb7edUKYcywKZMBe1KkCXKPvCVGUymbD5TRb3XNJBGnsOsIC0CjlDlAK3IADxIx0GSmQnyArKE/A0GA28WBD8ovX9VGAIxm808VQuzZI6HwkQE+2cBfqv/4jxj2OP8u1apWJVC6AhWFR2pigdXbvEQRpnSy+mzBpt1dF79FCt9fhVJQlrAs0NVxGer1dpFpMpUTkHKlO08v7T8FjboccHkplEEHKHKCWz2A5KQKVuaSdLSJi4+HsdRHqZDP2XHZlMvyrdK+4GZ8svH+VwHhzxhGnj0/0WYg0z+Ujofrs3Mw2TiY1NfmclUWERdKajBbjK2z6LhCFXG0D5LaSMpqdI+UVBiUEERsDJObCWoX4PBYK7D4E90GqZZqvalinr/uA1M+7WZIqOH8SdzsMOVVzLw4MSDLAZivQ1JmZH16r+yg82zUBYRK0yrjGmSqSTqvw1JlKkk9whSrvIi8HszWISDFdpfiIlEnLRMsa44EKa+J1+r04p67zj51QqU/s5Eyi9ul4NDVuDBVZv+shp800bRztRlgfaX4iCdWZKpOEja1yXNP67Xf/jN9Jk3nEKVIfQAXNbODajVap6PEPKKDZHZUT0qxuOx9Pv9uU50PB7PxagyzTCC7ORpQRM5Xr3HW+04RSo5XLklAxZw4FNvL1J1h2WR7Nt7WcC+blCk4GvK7zfr92gbn7SFAMfKVq/Y7Ke/m8YTkewUK0eoFgBp+lKBBIL9a+fruPkzBcnkSs7PUAQB9SNMevHAonf0DuWETalgk19ZBruwpKgswW3zBsivyVdK+1MVDROxKhtM/rZBpCoLOEKVA0wvNm2kRaomk4kMh8NdClWSiggihU4DS15F5mfceAbbTCkvp3Q2VfIxzktRpCpooIoyu99rg1hVoSOeM3HS34s2eaSJRVWqeP89rN4DsSqSFEcpZ+SRQwCVpc6ZHNY1tN9uWn2hI1Q5IQ+pNA1SxepRrVbzTF5JAEKinbtBrmBSK5JI2WDqZNLu4PfqLN0hPPSiDvyvyZU+p2g4pWo32FcKGxkXTaaC4OeKUUaEWQ2YBWF3hGpBkFYnCr8hIM0ODmoXZtqz2cybrelYXabGmnVD1g75RatRiwRXhtGgzXs6+K0mU1lselwWLIpSxcoU1HqR/ImJrRzZrcEGbV7WO4AwyloftemPn0Mj6rgaeRT+5Cc/KY9//OPlzDPPlFqtJu9///vnfp/NZvIbv/Ebcqc73Ul6vZ5cfPHF8o1vfGPunNtvv12e9rSnyerqquzfv1+uvPJK2djYiJqVyiDrWVeaM1JWkmwbISdJezwez20ubApBgHPL0IGWIQ8Oi4UgJUKTqSAzXxn9buJikVf/QZHioKtleFd6EqknlnzcttWWyO5Vz2XuO3W521YQRn0/kWvu5uamPOABD5A3vvGNxt9f9apXyetf/3p585vfLJ/73OdkeXlZLrnkEun3+945T3va0+Qf//Ef5brrrpMPfOAD8slPflKe+9znRs1KJWCqYGUhCyboRpV22uPx2FOqsEcgorAXXSZamRIxL8c1raQyNdAsEdTYy9ZZO4SDXrXHSoYpsKONQJXh3aeNstTpqMAqvrxjg6E/wyR2MBjM/fX7/V1/+pzhcCjD4XDuGv5uOo5rcN+y7HGaR7lHNvldeumlcumllxp/m81m8rrXvU5e8pKXyE/+5E+KiMgf/dEfydGjR+X973+/XH755fL1r39dPvzhD8vnP/95efCDHywiIm94wxvkx37sx+Q1r3mNnHnmmQkep/yogv05K6BBsekPTpmaxOlVG/pYFvmyQfuo6NmL36AWpQPJwo8kj5UtNjgiFQ3aBMShEHDcj7iXOYq2zT/ShkXyqWITX55kSitKiP+nXRm4jE3vxZRnXTc5ZhZPBNj5uwwhF7LuD1P1obrhhhvk5ptvlosvvtg7tra2Juedd5585jOfkcsvv1w+85nPyP79+z0yJSJy8cUXS71el8997nPyxCc+Mc0slQa2rWdEykeugipc0vxi1lSv12U0GkmtVvMc4fOEbTkwOgYOH8GDHDoG9gXDb/V63du2Jw8sin/JXodWO01BHfX5fNzPTKbPNQ2kftcuAqkpAjYTLUM7SvN1pjFD9y0mqwe/X1aGbP1SkJnORIRM8QOZUGFVNy9AMpmvbZ9ZoVJhE26++WYRETl69Ojc8aNHj3q/3XzzzXLGGWfMZ6LZlIMHD3rnaEBWBNbX19PMdm4oOtZSWTCdTj0iNRqNpNFoWAlVnuXEBIkJEzoPPzu7vi5vglOkEuUQDrY6zIOmjUwFKVO29JNE2WZTY1hSFZbghz2vykoVuwb4LRrQpGo2m809N5e/yd9Ju2mYzs3yGfUn95v8CYLFfSZfW3UyJVKRVX7XXnutXHPNNUVnY08gjPkrDZKDGRMIFRQrzGzyhI2MaMKEzkD/7pdmnkTH7znyJluO3IWDaTVfFGUKbcV0Htddk7lJqwy2gZcHeL/z8kLZVVlWpngCbXJj0DCtLOZ9VG2kSb/DvP2VbOZDqFUmdUqbCfl/kWSTgaLqRqqE6tixYyIicvz4cbnTne7kHT9+/Lg88IEP9M753ve+N3fdeDyW22+/3bte40UvepFcffXV3vf19XW5613vmmbWMwMqdlmVKF1Zg2Y0afoBQKliQgWilcdKH90xa9WJj/FsE39aprc1/KiEJsmsvAykqqwDXVEIUqbYD4UnEzZlym8Q4vPgx6K3MwH06iw9MLOpCPUH5CotUqXzbas7pnuWXZXVKxa5n9HPop/PZMoT8Se9+v88iK/pOZAHvNvRaDT3u+4rse0Oq3naFyvKmGMipXkhVUJ1zjnnyLFjx+RjH/uYR6DW19flc5/7nPyn//SfRETk/PPPlxMnTsj1118vD3rQg0RE5OMf/7hMp1M577zzjOl2Oh3pdDppZtXBAO5U8yKACJ8wHo+l2WzOqTpFklAeqHQnYDL3aRNMkZ1/2EHKoTjYHNCDrrGRe1t6vKUJq1nc1m2KB5yZcT4TqyIUK9NEI8t2FSVt3f5tkyudHs6x7WkaxmRXxvZtUshqtXlfWZTTaDSaU1HZRIhxQIeZCGor+t55lVFkQrWxsSHf/OY3ve833HCDfOlLX5KDBw/KWWedJS984Qvlt37rt+Re97qXnHPOOfJf/+t/lTPPPFOe8IQniIjIfe97X3nsYx8rz3nOc+TNb36zjEYjueqqq+Tyyy9f+BV+aSNtFYcbr+4QuOHbTHJRpXg4LCJ8AtvYi/Ix08oUkya97xaUtLT9SwD9ftMeuKrsn1JF6PeJ71hO7wfUPcQwgurEgSKRpp+qCmhFits+2iXCmYBYoa5rAgYfSEZcs1yY9q7bXBakivuBsP5gyBu/T5NCFSWvUdpmGYiVKb+2fGlixf2siMxty8OrBv2sAUH3zBqRCdUXvvAFedSjHuV9hynuiiuukLe//e3yq7/6q7K5uSnPfe5z5cSJE3LBBRfIhz/8Yel2u9417373u+Wqq66SRz/60VKv1+Wyyy6T17/+9Sk8jkMa0KtLtGKUtnqETps77iKhHcy58bIvVZSVVmVA2U0kewV6ALb9blKbsFUJCBITK62W6g13NYE2qSEgS0ygoBqANLGKjLSgJuSpVmVxL5PS7Kf48m9pButM09xfFPwIJI8pXIdQx6BcgVxNp1OvjuPcJONQZqrmrExvICTW19dlbW1NDh06VOpBrF6vy9rammcjxjFGkgaY5Nm1+sTqi86Pdg7k2S+npWelYatWs9mU5eVl6Xa7cuTIEWk2m9Jut3eRlrByb1SYZurYwxCB6QaDgUwmE9ne3jZ+4ncEKg2K7aLvnwRRTQL6e9oDUwW7lExga0fsM8V1nK/jgaNWq0m73ZZ6/fRmuqxQdTqdOeLkZw4UmY9m7feeZrOZjEYj73M8Hht3N8AAqOMcZUmstL9QlLZmgy5v0/1sYQdAWFut1tyxJEiiTOXpQ2XLS5z3oPt3VmVRvqj7tlWTpraUBKPRSP7yL/9STp48Kaurq4HnV2KVn0N+MJnawqhGmqBFbVDcWaOTzHu1H0M3RK1UmT6zInxBCJqtl23mupehVSetBPOnNjHD9IG6ZjKFmM5lR2HUFZPyohUsVg9MKq3JPM/7gOYBPB/nUyTagK7fCf4XkblyQn+k0+Z3WMQEP655NW1oMhWV0Om2AJcK+NdiHBqPx0brgb4nWxrygiNUFUQWvlOm736kSgdr4/OjzlKm06kMh8O51X6tVquwDgLPBP8QkZ1BxOSvwh2xHnTC3o8R57mDnITzIFVFd+hlQZDCa1OmcA47kWtFCoSp0+l4s3ecy0Sq1Wp5igm/e/aN0iSE6zXOhUKl1VcQJ0yCkCbSwsouEK8wsPVrpgUe+jv3PUyCwvo/sSlVk0cN2yBdZmtJVkhKohi4Fn0vjjGBn0wmc+Y+fl96LOL08iJVjlA5iMh8zBCe0QL8m1ajTJUVx8MMsugE/TZLzhpBedUzIr/ZT9GKUFb+JQ7x4adgmtRO9pvSflCm35iEsXLF99K+T/if67Su5zDh6eu0eoXfoCRwsN4w9TEpGeHn1L44QffVhDLoGj+yVSTy7nfSJFMME4HWqqqu2+xrpccn5DEPUuUI1R6DX6XSToIme7TJ/GdyetV+SX5gp3QsoUUHncfsggcWPmZSqjCT5RktqwOYudsaddj8RIFThsoB23vTs2fTbyLzjuZQoDRpgiKlP7EiCooWkwTUVZGdyYt2Muf8a4KB1bdIiyc/UKxwHN+Hw+GcH5Z2hI+CoFXFDKTPzxwGUdtc1mQq7qSIn0ObcJPA1pfnMXHDWIK6xZNZKLfcf/Okw/SbSHZuGY5QFYQ87bpxocmTjXTo2S130GE7UK1SFaVQ6TzrGbtJqdIzp7wVoqIVMQc7ojjJ6jqkBwbbb6xOsRM611O+B7dX7dRtUrVwnXbONg1W+A4SxqZy7XOVBH7kNWvkpUyF7UdMvm9p9gcmMpVn/6Z9+nhiz32vqT9m8HVZKVaOUO0RxK08Jju0tl/rSMwcTwqzijANEDPaen0nxlPeToUiOw2Tv/PMF8+FTxwXkbnYVHkSK92J+t1bK2ZpzmT3Imz1k8mQ/h+/83nNZtP70+drRQr/s4mP4x9pcsX/h1VxWFWCQsCBeDEBwnd2eufr2efK5t9UhQmmSPFmPm2WFdmtMHLwzCTEiq0MjKL6CZ0fTLy5LKDOsrmZj+sxJW3FyhGqAlHGTsRGYGz+U3p1EQZ2dKxwIAwD7qD18u4iykrPePCceD7ty8JqATtW5pnfsKTKIT9olUnEvLKM25NJCdW+UkzUTD5TfE/9vwlcf1DHMYhxHCBcz+0C3zGQcb/A969SnSyaPDE0+cb/ttWaVSnjKGB1idVSnizgu67v7MwOZKFYOUKVMXRHmhRRG3nQvbkzZEIURKo4Hghi5HDeWJodDAbeMU0ydCc/HA5FZCeMAmbieUIPSqwMiMicgobZ+Wg0mhuQoMppB9m4JMv0PqKmZZvRpkX80k6v7AijTOE8bbLT5+mQCKh38InqdDpzRMpGvDRRg/Ll9wy6Der3yD6RIE3aZwrx2tAmRMT4yWa/Mg/6WZIp/a787m2qQwyQBH4/ePdQ0cOC223Z2zC7o7AFRAf85IkurtEmc23yZkQtB0eoKoQ8ZkzsR+Q3k+VBgDt6LaXCURuN21RB+TpWqCaTiRc+IQ+VigcS0yDDgyEGKTRgLFFnBcFk6oxDqsIoCjY4c16x0IqC6X8TkdKqlF6552eq4H5Cq1Y2cJp8DJ/cBvHHJj0sLMExqFkgUBwAVPcROG7KPyPNOly0+sTv3nRcl5HfhIoJFZd13AlcmckUE0bt44tnt9V5XW9xjM83LbqKAkeoKoK0lakwsJEYKDa9Xs/r6E15hJTK/lSIT8MqCXce7JPBs4oigMbGqx/xPO122yNNmKWzORDPaIoenSYx1J1mmE7UpFRxvh35CkYYdUp37CZlCmlpsgTlF21Mm9tMaZmUVb/860Fdhw1gswpPskDyNFmyrYRFfcKkCm2cTTdhXAOi9ANlrMN4pza1yfR8+jxWDU2EV/c1YVAlZQrQCx64frLfry4HXYe5fzf1f1HrkSNUFUARZAowkSoQKizt5uP6PJCPer0u/X5/TrUxXYvOYDwez+0PlmfUdJNShTxyI2TTHzupw4GXB50sO6owpCqILGWdx0VCUPvSKoOI2QdGRKyqE0gUTH2mWTcTKa18mfJgAqet76EHWq7LuAcr2lzHcD4mFTpEg8g8UUsTnBfkpwxotVq7+kwbdJkEtWdNpuOgKu2fn9mmVPF5NvLPhN5kkYgDR6hyRFj5XV8TBWHT9ztPVzJGs9mUpaWlXXvt2cDmQFRwxJvC7zpPWO1Xq9Wk2+3OOSJyB5wmcfSDHgBns5nnU4XGDALIjbtWq81FjMasvCwdvFOqosOvzmmTHs63kSF2LMc5zWbTG3gRW0rflzt9WzpsnjblnycHvLEyA4SIZ/FaaWXTPpOuZrPp+VrVajVvP1NMqFhJSTqIBcFvMsYrGbNCq9XyVm+m0T8zWIXhcizapJk1/J5PT4S14zmIlTaV6h0weMwKC0eocgJ3qlEaSxTkQTAajYb0er05J+0w1+gZQZBSAud0VqqKIlLayZF/x6DHpj80XoAjwMdppAzToBfneqdURUMYpYdNfXyN33GtSmHbmG63a1y5p8HnaPLmZ1rC/er1ukd2NMHG//pPRHZNHECSNLECIWOzH/v+sGqQFKZ3oKEd7fkZswIIchJo8x63U23ayqt/LAL8Xv38avX71D56PDnAhIRNhmzWjgJHqEoKW4eQZ2PRRAKzWazuiwp03iLzZgGAzRcgKDCdaaf3IqBNONwI8Vz6+fAHsqU78aAGqwdIbuRpDQKmMtUDYdT09hIp02Y2EXNYBH1cK0StVkva7bbnn8cRz/lafU+0D06T25LpviBu3LYAk7OzacDW9+fYccgDh1EQkTmVNq16wsRO/9kmIMinnuikWW/DEOI48Cs3/d6DsJfaKcCTAX5+Uz2Kutm3I1QZI0pjClJ8iiQTIEP4iyMp1+t1abfbIjK/mk9kvnNGRYbpDwM7y7N5Qg9qPBPXx0TmnXt5IOOBSQ8qJuJiGiA5LcRWiTPDD6tU7VVSlaSOmdQiPq5NdPCXarfb0u12vTaGc7R/nMhunyzbalsG7sehGEz55Ppkq7NaKWBShnaKVbogLfV6fY5QRV3W7wdTmTNZ5byKzK9MRD/Dx9MAB2otI+I+ZxEuAUlNmH6KlV//6QhVRZE1mUp6fbPZlOXlZel2u7HTYJ8j3oOJ86g7P6z44+WwRZAqBucBg5l2doQPCZssmURqMmV6/zp4ox6wRHYC2aVlNsHzAUkGl6qTqjiwKRKm98sKFU9WoAD7ma74d46eblLKuA7hXn7kiycL/P5QZ/Gn361Wrjgdnmywmpamz55Wpkx+ZDY1lttjGnWWlbsi+6q91v6KhiNUOcHUcYVp7GndOym63a4cOnTI6uwaFhgARHbYv63Rw5dqOp1Kp9OZ29KmyE5KZLdSpf1R2NlWRLxNYnm1Ew8gJv8w3oCZf+MAibzNhM4fp2tDkE9WWkS+7B173Ofkd6PVEdM9WFHilXz4g+8USJItThHugfpmc3jme2llyma213VRb2WiCRAradweWFHGdaj/MOejHSQl7twncJgJ2zPy5I4nJ2msPOQ6kNXq5LQmPVVAUnUqTzhClQNss1NG0QTBBu6Q06zY7HdhM3mBmGCFHNQYHQ23KHDHi2fhAWU6nXqKgDYJcvgIpAXo7Xxs4FgsaYHTS2r22yuw1UMeWFm90aQKqhQ+NTkzTcS0GqPvyb9B8fJTsoKeS5MWfhabfxXnFefwStikEyNTH2rKp9/1WnVLq67n0TcFEb8qEq0oY0zR/b8JjlDljCycFIEs0m02m55fR1pglcsWURy/w5l7OBx6g1Decan8oAcOJnraURiKG2bB+rlBpNgkwwoI+6bgOHw/0kQWpKpsSlXStqJVQ/yv0+XBms10IFII3rm0tOR994PeesbPbAcSBWWK/bJsZI0VJZ4ccJ2zLShBubAjO5v92Gey1Wp529UkgSZR3HaCrkM5wURfq+04ISeprzZzYx5AuccJ0RL1mbOYzIVF0vZrsgikAUeockAZTFRxgU7ZFg09CXh2rZ1v8TuATkKvnitLuTKZYhUNA5kmQrwiilcewXzDHbI2sbDphAfGNMmKiVQ5mBGkUGloZ3Qm3n7Q6pJpcsb1j52iTcqUzUTIpIrJoIjMHeN8aB8+rfbgu/5Ls/3GVb1MSl9SlKVfyhpcZmHIVRZlbJrchL02bThClSG40wvqPMraAFutliwvLwfOnOMAM0q9igi/4ZN9qTA4oEzLQKq4YWPTWAxCzWZTxuOxdLtd6fV6Mp3ubCSLTw6pEEQqQSzxHfcNylvcmXbapr68laq86oZf++a6zGa+Xq8n3W5XOp2Ob1w3JiDwq7OZ4GA2RGBQDr/gR6REzJtm6xWtAPsfmYJz4n56VSBvT9NsNr0AvknA/WvctGyDsl96traaVbiEILAyWIQpMKi/KAuZyhKOUDlYYZq52VakxQH7MPD9+P58X14hB3+lsjQkkd3mBww43LmyuY8dY/Ebq28i5k1jtTrlYEYe5RN0D24r2ncqrD+TiTDYTItQp/Q9wuQ16Pl0O/Uzm+B3m59SGj5UZUWRzxXVzJc28jBzRiG9Ya5PE45QZYygl1fWDoWdWbNUE9AAtVLFqNVqnoozGAxERKTX62VmB48DbfITEW/rDRCrZrM5N4NknygQRcTE4eP8KbLj94HnDtOBJlGGsihfnWYaq6rygImcaDXC5oQOsgP1iNVW271AivTmyAyQtFqt5q0W5PhHYcsnDDmE4or7sRpiyh+b/jiKOpsiNfmKg6ThDuLGWjMd4wUAeYL7EJNfalgwWS4z4qiAWfcVjlDlhDIM+jaYGj7PbFlKRicaN10b0PHqZcsmkxebyMpUrrojYgWKjzO54d+hUImYNz3V5hVGHh1gFibAKiOKOsXKjF5w4Jc+k7Ggc7UylWbb0AoY+zAyaTJdZ0qHywPH06jDSfqEtNqQyRybJ9JQqcpKqpKUax7vwxGqHGDqDMtEBGyAn8/W1pa0Wi0ZDAa+zrO6o9TO1bZ7iOx2SreVD1bJcRDEIlbTBIFt/OxHomP04HcOLIhjHBx0Mpl4fmRMdKN2nLZyLbrzrEJ7AEymaX7fNtM1EylNlDURZ6UjyBxYq9Wk3W57qwSjbMIb9JwM1F9WYvWCCZsSqk1/mvglqX884dN+hUHlwNclUXVwT/7LGtpnisPLmMozahmXjVRxu4q6yjuv/sURqoxR5oEiiOigE+RglH5mBxzHqjZ0llH8roJUEFbJeKVcmcsZ4MFGD7hYms6mIjaT+JV9Gp1e2TrPssJEMoLO4eNh1QuenASdowlKloM550vXSSjMNuhr0lLReFVi1DqMviYpmQKKUqayarua+BcF06TFD2Em51nAEaocYJqtlh2z2c6Gvoh1xHvUMXRF56jhHKGZt9QwIch8ILLjuD0YDLxONGibjjwRZqDk/3kw4PzPZjOPmOJc+FJxhOk0TXCOVNkRp25p8xagFx6YSFrQggsmUtgHMO4em2Gew5Q/kZ0FEqYFJiLmQThNQsXp8+SPy8cEXinLbgRxt3CCSpiXOqXBPpdJ/clsKKp/4BWifvXGtEo8bzhCtQcRpsGj4XAwPttGkUgPnzA5YCUeI6gjDdMQ0AGORiPP0bvM0ASROyY9APE5PKPnlVEi8wNJms/vSFV4pL0MnNuG3wSBiRomKXk7QpvUNltd1tfpWFZxoc17PKD6EVLUb23uS7IfJt5X3gGHmZxnRaQYfkQ5y/vxZD3M2FGUr6cjVDmhKsoUgzsewKS2sWyO89nUB2KFWTSiN+sZpMmh2wbEcOJVR2WJnm6CiVSJzJsrtFKF8/GMmlBl1Wk4UmWGiQD4mSL0/+xgzn9RJhdamcLef3nUfSZMIPtM+v3qjP6dCUCaZjKkOR6PvUkd512TDyjevNAlKsK+zzShydMitVfdptj30OYbZ5ugZtlPmuAIVclhm3HaKknWM9QwDZfldE0WuBPVK51sjqy2e0wmE49YVcGXyvQ8NvMpf/crq6w6DEeq5hG1Xul2aFJzNOGymQh1HliZ0uEH8oBfvsNeJ5I+CTCtkOWBltsKn5vEIV0T5LzIFMAkkB3Us0aW7xJpQ43ija5tKqh+zzjGi3zygCNUOaDMg3wSBDUikyLDHRf7ZGkpOeyAPplMZDAYlNaXKklHo1dGATyzzrrz5DzsRYJlq0tRFlmwSdzmH6WVEyxIENmtDNVqu/d7LKKPQX5MdVSfl3Xd4UHUz/SjVR2O3RQHeBdpqmxhkEfbzwuaQDFJ5eNBaq5WSk0ha7KGI1QFII0BvwykwQZdsdk3gQkT72NmM28EAYSqVjsd1DArxCVIYQYTv7RNq6lwbhKfjzBY1IlAUrDZIUoZcRgEPYkwDZD6OyuVekuZsCpRGtAqm/b7svkLMtIkBJo0hVUkWNGJkxc8b94Koch8+ZWBXCWZQLJ5j5V4rldh6rcmVVwP8lKpHKFyyAQ8U2SfKvg2oNJjJRuiOmsENQTEZ2o0Gp4vVdgYNGWHSb7W/2eNojvqoqDrUJi6FJXQ8ICOECA6xIhpQOHBu8g6rk2Yps+i6o/2qdF5se3KEBZMbvNUp0y+U9r3tAwEKwhclzHJYLNpXLMywO3XZvbNAo5Q5Qi/VTthUPZGoqFJFZv78CxYqWcjVCL+pGo0GsloNJJ6vS7dbnfO9JcGdDp5DBSaiAIcwM80YGSJqtW9NMEz6LDn+b0XrUjpT50e31vP2ouCJng4hjza2mseg71e/Wf7PUleQKjy3E9Um4X98lYUwt6bLRTtdnuuHtnaQdhJjYiZUGH8yVKtcoSqYFRdRQmCqXFAqWo0Gt6+dSBUpjALYTo9hFHQ5xflW6LNniLBS3nDmEf2MrHJG0F+QQwevNFp63PYXyfpO61iPTD5L+XxHGkqU4w83S5MPnZ8vApbQqE9wESqo+UHmfPi3AvQ7TGsb1XUeuIIVQGwqR422NSIqnWqeqYgsuPUyfF0NMI0pul0Z+PkTqeT2Kch6FqbUhVkYghzXz9SldcghHtWoaPOAtzBm1bshYWeFeuNsLUZN4pqUqRpJ+69bYQgj+dIq+1ATWEftqxgqh/8W1XGADbpdbvduZhdtpAyYeBHanmxBAgU7zyhw/1ETd8ER6gyhg56ueiKVBC0PRs+VVCq4i4/ZtULabbbbe9eRSJrUoJYX1mBifBegF8nGrUu2UJdhFGo9OCJNmO6nn/Pur7r/EZ1AOeBLEtCwP5oadXdIsyt+n3zs5SZVKGMbOEPuG1kYYbzI2rcTvzauyNUJUQcB1dGWAWrKkB+dbwq0wqmsM+G7Vgmk4nnk8XB4LLqAG1KVRozb5P/lFaNopRRElStjsVF2A7Urz6ZzAuAjQyZ6g+ULB7AuQ7AfI785GnqtilNQedBpYNSZ9vINy2kaeID8ljRx+TJZrI0+VQCpvzluVCAHc55CzL8ZlLyw5DfqGoxVDBuM0iHJyJh7xcER6gyhiZRRaslZQGTqlqt5n2CGOkZTFBaSKPZbMpwOPTSFlm8srcFjUyzozSllWeAvEWEVhn0QGhSrLTypMkYDxI8OGStVGmljP+CVuWaAmlWhbDnqVD5TcjCTNjybq9MVjgEAvtKZXG/sDDF1Eu733SEKgdkNaDb0qtK54R8Yo9AfMJBne3sQWngExs5j8djT6WCT5VIdqTK5BeX5XswEc607uln4tsLpCrpgGlySgfRgHkW6hITK1akEEZBDwJamYIqy4EQ8QxpQ6tqOv8mxUoTLexugD9WqNKoV1m1OVOd4OCracNmDuVyN6lT6Bf84i9loVThvu1227MQmGKuhblvmNW0tjE17DNlpdY5QpUTFkUdSRuYSaPRQ1XiXeyjmDzRaUPtwu95+JbkCZ4NZkFwFp00hUWUWbWtjvHAazP1mY5jwDRdq+/JhI2Rdp3nfJlIkyl/mjCyya8qkz9GFHIQByblyWRajbtqOA1okzarUvynz02aH04rTt3OekLoCFXG0Ow8TdmT/SdEdq8GrEpnxRW83+/POS/2er1Qq2nYhIiOe3Nz01tBiNlTXqQqSI6PA14pg/8XiSQWibTapSZVrEpBTWKFCt/1wgJ26DXVI56A8O8ctVurA3HriiZ7UJlms51NhZkcmfx7xuPxLnVqNBp5Jv4wbSWL/ixsmZgcmPn50mqHJpKp/aa0udSU1zDEIUmeuU9l816Qz2qUe2rlzc8NRI99tuNB5yWFI1QZIuvBbtHML3p5uciOj5WftG6aGSMNNrEUoVRlQaqSztL8UBUSniayIlP6uPZx0koUO8qG8UmyXZ+VUmVSovxUKk2wQB550lNVZNVObOna6kOYfKQ5TphW7MH5PEw8Kd1GdNuwfYqkU4dtZDMtNc8RqoyRpW/DbDa/X5GJhVdlgEQ+x+PxLgWm1WpJp9MxRlP3M5tsb2/LaDSai8YLv6qyKDt+s3P9XCgTrJiZzXbiqsC8mTQvew1Zmch4dR4PDlB4cA7CfQDaXIb3rUkSm300ccF5vDyd+6Gwz2hSpjQpgkLFChzXR/hJ9ft9GY1GMhgMZDgceuoUzjcN+GWoj2EJclLYnpVXR/JEM6yqh3wmIVXohxuNxlwMKe6j45aDH2myqUm2dBh+1hp9rzTrmSNUFUaYxlIlUgVwx8GddZgGZiIhk8lkzjRRJVOZ7d1ps05W99lLSHMmbAKvyBOxq1SsrprUHw1cy7Nv1HuQMTxXnGfj/Nn+TPnEc7A6BRJlcmSvEkyqeNrQSpRJ/QuDpGMAyJT+i9NeTMTHlr8s++isrDuOUOWENCuHNvmwUqGXUfM5ZYaeQaDDHQwGXqDOZrMp7Xbb6FfCM3/u0OFLpfeNwn2ybLRRy9z0TKxANBoNL64LZv48YIpk5z/HdSjtYImLCq6HKD8QC5GdVa0mP6darebtUYlJE9Jk9QvnspLBaULxrdfr0mq15lbO2uq+HrjH47E3IQEhYoVKK1P4nE6n0u/3ZTqdespUv9+fS89UT8veVwFZKFUAv08uV9w3CJpca7++IPCErdlsSq/XyzQ6fFL/Plt6pkm4Hmu0ipwEjlBVDKaKF6YiVIFUATxb55AKGDh4cLGZ+/jYaDSS6XTqDVCY/VdFpWKwOTSp3B4WVao7UZB2XBw/oF5yHWbCrI/p75yGTtf0HXUCaYjMbxocps6wgqRNfppIsUmKzwXpYoWYyVQV6xUTKO5rsjD/6fcfFdolJIr5T7sYZBF6JklaUUyeJpjKJmlf5whVxrANeFkx/Kr7VHH+8Bzj8VgGg8GcozqcIU1SuDajQMHb2tryNlCeTCae2mV6R1Hs90me1W+Grjs9kCioVCgHqBB5KFWLgqRkStcPJkB6NgwSxUoVf+dVf1yX2fSNbZXYFIj7M1kD9IpBTCSQBsw4Wu3mZwMhghrKsaPYdMd/rGRNp1MZDocymUxkOBzu8plix/Sq1NMg5/+k0H0Zk9SoYAKFvPM4oe+JawD4rmYRlDMthOnn9Linr+F2m9SU6whVhRBUqdEhmwbXKpEqkd1mO1R6rC4RmW/8ejDiPxwbDAYynU6l0+mIiMztdJ4nojRa0zmmSMRVVNuKQpTBweQMbivrsAOsSYWy1V0mW0yeptOpZ/o2DSq4FoCZj/sIEbO5EemwCqW3i0HYBD7GJsDhcOiZqtiHkf2nqkamANN7SwOmiVTS9Lmu6nhmAN+P64XJRaJMiDJpNI172izKpCruOOkIVc7IulKyz0XVfVyYBKIjHg6HMp1OvVVu+J0HIb3iDR0g/LEajYa3Pc10OvWi+iIt/oyb56DGqM/Tg6p29BURT50CseQVkTZkqVRVyZcqSYDOKKQqCCBIIEmsGoEg2VQKkR2lCtfola+2rV1AgliZ0nUHz6hN6iBTHDtK+1LBrK59qPiTVa0sN/NOE7Z3zXUC/6fRtzPJ1A7/aUGTBd02Wq2WF18qD5eCNBBWqTJB92McoidquTtCVQLElVN1BdFs22b+q4pKJTJvfoBPlZ5R6Zk7rmPCBTIGRQdb0+B37hCz6kBMJIo/AZvPDOezKHXNhLKT9zjtKyypikKu+Fw2+bHaxPWYzYO86pXzY8qnVoI0MEhqcx/+dHBG9ovSihOIFCtSmlixUsXPUrU+COB3yOph0ntohTHL8vHLL7brKkPfEgZRxja/NmuKdRi1X3OEKieYXmCQk1+cBsWkir9XGWgA7E+Ajlrb900zOv4+nU49fyxWuUTmTYBM1ESCSVbYd2VTpHQaJnUKgyj70oRF0AwuDMn2S6Os9SxL3w9Tx2xaVWW6TvtQ6VhR8HniwVtkJ04b6qe+H/soaRJmywuAdLgdMKmDyjQejz0CBULFpAvnIj9ZKS1lQBrPw22dCXXeZcV78FUZYUlVFqh2yVUUmkilNRMwkSib+a9qTssYODCg4Bhm99oRmD8BDDAw/TWbTe96KASI+BuWSIXJd1hlis+3qVMgVVnI8WHrhK1DKhupysORVr8jfQzftcMryJCIzBFkvFd8Z0VKRObqv2nFKk8cNLFisEkQn0iXo2Bzukyo2AzI99AEChMf7TdVZZj6BrTXJK4CXEZFlFXVlCmNpEpVGmOhI1Q5gImOiUSZKnBaprkqmfeCwAMRq3BsqggiLTyQDQYDERFvh3ROH4OKzaxmK1OtMun/TbN0HgRt5wBagYz6bsPWh7irBosmVVmSqLBO52HOZyUCSpRJfWTSg8kR3gE7Ges6alM5TD46+n2hfmkTCAiUJlJMAJhA6cmBrW1UGVx+fttj+V3P5aVVxTzKiRe5mMzBDuHhCFXGQMWMGhAtCoM2DXYm/ynbuVUCkx4oSnDU1c9mekYeyPr9vmf64xVTvNVHHKXKNniYBhYgDAkx5SGOc69p8DUhrtN5UaQqD0UqiCShbrJJjoPussqolSGQKhxjPyr8prep4d+0L5VfXWOHcV6WDxXYlCbHoMKiDtxDm/zY9IjjnO9FgFYaozqnM5HiFZX4LS+wqc+RqWRwhCoHxDXPRPXb0SQMnbLN7FdFsJrDfibsb6JVGBspQgc2Ho/nVkDh3On09GpCTiNKPrm8s+wg8+x8uY6VaWBMSqaKGES4HPkPhISj4GOgRT+iJ0umus3vR9dFrSLx77zKz0SomKwxYWKVxaZMLSK0mc6PVHGZ6JhceYPJe5VW9JUZjlBlCAzQYaRg3QhNNvQwlV2fs+ikSmS3X0nYwRUDRL/f945hEJvNZnN7VoXtbPQgYvKhCvNsYcD3Yh+rpNBKn1aqwpAq/Q6yqHdpKVJJB5E4Kqa+Xpt8cFz7XuE+mETgO7cBP7CZTm//on2q9PPoCOmc1mg08vKo6/8i9Dk2sKoUREyYLPPiGvxmSz8rYDsuvTefQ3w4QpUxbJXUr/NjM6Ftlonzwja4sikKSaEHARG7308Q0MnB4ZZn5hwfiBHGdBpU3qZn0NfZTIdlQVH1Kg/zXpoIo1hgwAU55qjoXB/ZHMgmSG1C5GO4F5MgrU7ZVC+8X94+RqtR/Cx8P9PzLiqYnJrqJ5ezyb8tL/Dkk027jlAlhyNUBUJXYDbViezufNC5cifo5w+jTX+cdp5Oj1lBD0SA9lcL8mtAsFB2DIZjOg9o/KfNITyYsAnAL+8i/lGR9XfttM75SgIbOQzrbxeGVNkIkIkEVBnsV6Pfja0estKKNKAo4zqkq/dU47roVxdYGdFBOIP88Jh46cChbN7T5cDPxscWDUw4RcRT68JelydqtZoXtFOHx9grhCpT1S+zlB2MsA0cXKH9KjbPShdZSo8CHsTYkVzEvJ+h6XpeCi6yI9+jk9Txrtj3hdO3DSxJ1CXbNUV2gGktbnD1eB6sUonsxJVip3SeMPCWMrZFBOyzw2QIdTuI/OvVZ/wXVqFdVDLFKPszMkFfRDJVhvJ3hCpH2KRVrX4A2veKVSleAaR/02lzJ21SIcpQEZOCZ9G2rTVsvmxwaEckdQT81Kt3eGmxiLnstAkHx/jTD6bZPvJgSkOH4khCUIKUqrir/oJQlDqV9iCiVcsoYBKFuqcXXdTrdU81ZVM0qw7ajMPKEpRYhD7Adz8/P60A28x7prJwKA+gbjYaDa8OhZnAVxFh/dGyqKOOUOWEIGWKyRQGfn2NVl/8/IdsKAOpSjogBy1bZ5KpfVBs4IGDgyXybBz35vuYTK6m54tbvqb0TApcUVgUQl4maAVaK1M8OUK/wfs68ievEmSzH5vreNWezgcQxj9K/+bqRbmgTcX4v+oIUy+DyFRaddURqhxgmg1oIsWdIP5vtVreMZEduR0zS16lY/JZYHAsnEUGygPlxqa+oNWWiL/DA43I6cCferVmkKoS1LBt74H9YvSKL5P6hedCQMg0OoaoSpX2JXOYh27zQcE+tVmfj/Emydxv+PkNctufzWa7gnOGIUBh3yuntQh+mosErif4vhcQ5I7hd13UuusIVY4wVWATmYJ9m5e0iszHgcGMVWT3UmXTPYro1LIibzpd0wDFZpM4ShWvsNLxYrg8TQqV3/eo0LMvTYoXyQdir0LXS02q+DjAvn04V2SevKE/4frCfYiejKXVRzgCVT6YXEGqjijKVBwyFQeOUGUM7Telv7O/T71el3a7Lb1ez7N1Q6kS2VGotra2ZDgcejNNdJAidpMTN6CkvjZhUKQSps2iPOAEXYeVT1r1g/+ByO7tX0T8iZVp1h4FPPBxutqnC0pEVvGosromb+Q1mPB9eNLkd57JnMxlCZ8qNuWZ0vFTIYImYGnAqVPpII32pOvFIpApP5iU/Cj9YRKfTkeocoBtdqCVKfxh8MYSaRArDganzS/4PQ+yFIS87+2nWEXpiHgwY38TDlfBylfYNMPmw+aXhett/i5QNHlwLboOOJxGnM6Z64CproX1ZQo7cC76ALvXwWNMlWGq6zblyaTm5wFHqHIC+0+wSsVmvVarJe12W7rdrrTbbVlZWfEIlciOUtHpdLz9tMbjsfT7fRkOh7K1teWZqHRFYt8cdnaNsxecH8owiGsTH1ZE2aBn8/wMiCkzGAw8oquVhyBEadgm8yz7zvD32ez0XoY62CPumRZ0mkzmtampzIpE1sRB1wvt3xQUDy1t2HzgbOclyZseyEz3d4iPJGox/i+iDmYBUx3Tn0nGIb42ajqOUOUEU+XmSg4TH/5arZb0er05QsUqyWg08jYGBobDodV3wpQfVmTSQBnIFBDFb0rEbhphhQomV3Z2D7pPnLI1mQ+1KsGkuMiZp1PC5mFbdMK/OTgUgaqa+0x+pCYCn7QfCjtW+MERqoyhV/ZonykmUfV6XTqdjqyurnqfvAu4yI4/z2g08irTxsaGbG9vi4h4yhWrFgzMUBZRmdJgsgPVTgfn9HPqZhKF8kaMKjS+LAgF8tJsNucCMGJ7HOSNlQUocDAHp+lLpfMV1nwZ9tysEbWTTNqpsgLNwRTTvk9UpKFEBaWPfqUM730REaZd6ck7B/GsIkw+UWmRKNO9kpSTI1QZQ0ut2vTHq/pAsLrdrnS7XVlaWpJGoyHtdnuOUGGAZx+sZrMpW1tbsrGx4flSiZgVBD1jTlOlqhJMZMrkrwITGxNRmxks7bxxR6hNf9z49fvOilQ5REcYBbHq/i0O5UVVVVKtQqXtF2Ub85KMhY5QZQyTzxQPlCaH9OXlZVlaWpKDBw9Kq9WSbrfrDZCTyUS63a5n8qvX67K0tCSDwcCLfnzq1Km5/bpMvi5pDbRlH6yhSplIUxTHclaJOJ0sOyqoa9hbkGf/OsI1R83OwjeOwc+qSVsQ0cyDuJdp0IiSl7wGvjQnAc5fqhjEqVdlahc2cD0yrW4u+3jjCFWGYP8oXo1ncmzWCtXy8rLs379fWq2WLC0tSa22E7W71WrJeDz2An/2ej3p9/uysbEh6+vrMh6PZXNz09f8w+aIRYcpxAETSz/gPK1QcXwrkXTs76Z7ayKO52HfOU3a8xzcnBJmR9z2VYWBj+FIlUPaYMtAleAIVcbQphtTXCqcpwnVgQMHpN1uS7vdFhGZMz2BUDUaDel0OjIYDOTAgQOyvr4uk8lENjY2vFWAIjtKAiPJQFjlwZPJpFZbTEDjHo/HXpwqdvzPmphiUQJWg9qWBnMQWI4DlBXZibOwIQvFKi0CkjQdTaqn06lxdWmU+2RZt7RSlbWPlUO+4DGmKgqVyLwyVTU4QpUD9PJpEfNKPw6bsLKyIocPH/Y2PWXHaqzu63Q6nslvNBrJ+vq6rK+vy3A4lBMnToiISL/f3zWY8iC7V/2oonQw7GyLYKpaeTQRNFM6cTo13If3a0N62H6IVxrCRJg3qYpzj0WrdyC4aTjlV9mR2KEc4Il8VWAK+5MmsuxvHKHKGGEqtFYaOp2Opz5pEjabzaTX63nECqrWeDyW1dVVOXTokGxvb8vS0pKnZvkNWnulw+Yy9Jux+TU2JlaIAwUiw+EL0iZVOB+hNXToBoaJKAc9V1IkJUWLXgfzUDEdHBi6v9NuJmXDopiNHaHKGH5KiDY3IQDl0tKS9Ho9aTabxiWvnU5nztkag/yRI0e8QJ+33nqrTCYTT6nS/lMi887ZZdkqIuj+SToFvRDAZu7zM/2Nx+M5osrKIwhuEMKQKp0OCHS73Z7bo5ChTZnYMDkPpL3YoergSRLKhPfeFFl8IulQLDAhD9svFY04Zr4oE9Q8xjZHqDKGadWOJlkgUzDrYNDWafB33l0evy8vL8uhQ4fkxIkTsra2JoPBYNcy+qSo4mDJnQkPZkFKkt9xvC+8p0ajIePxeFfnZbtHVKVKxy3D/o7w6dL1S6+8y8txPE9lLC2kSWzwLuDvyKsv/d65zd+qClg0s23VoRdDOeKeHxyhygHa8ZwBMgV2PhwOva1kAFuD0IP3GWecIQcPHpTJZCInT56UyWQi//7v/y4iMrfkXqOIBhe3A05iuuRBy7TKT/sdme4NcjoajXalwc7jYX20opQ9O53jWg7ngE4U/yNvecWlYtNk1VbnhEGUMBsob73tEZMqk1N4nm0xjXvpNJxCWSy4T+p0OpVyRvdDkCtGWeAIVU7gis3/Y5AHoUIsKSgPJjBB48aCgbzX68na2posLy9Lu92eG0irFNMjC/CgZZq9hel8TGXI4RTwyY7itvRNg2jQwA2FajqdesRb3x8hM7RalXeIgzIrVXkNNGjjcXypymQeDNs2cG4Z3/leQFrx8bJ0v1hUOEKVM0wzBlYU+v2+nDx5Unq93pxyxQ3EZhOHgnHw4EG5+93v7jmni8ic+U9kZ2kq0swaWXeuOn1+JlZo+Dx2JMc1WjHU6bLJj1UfpDebzeZ833TnhndpK3M/x3ZWOlitGg6Hu8y6cF6HqqZXnjklIXtwu51MJnMLCkR2K1N6MUHezuxBvp5hzOSubhUHNvVFUcmD4Ne3Zo2qkXJHqHJCmMqNDmk0Gnl+VHE6JsSywmrBVqvlrQTcKzNHk/KjCZJ+J34Rv233YMIiMh8rDIMi0ka6SYksOzljkMZ+j1ox83MW1+bOLFEmpSrvASGMKc92TlErBE2qqslMDujguQ7FIU11qgzttUpwhKokwIA2Go1kY2NDNjc3pd/ve/GpojSOVqsl+/btk9XVVVlbW5NGoyGj0UiGw6Fsbm4a1ZqsUGSD1P4qUAKRJzh5A/gdPlJhSAYGkuFw6KXdaDTmwl5o059e7SUSfSsJrhfsoI7n0MoUfmNlkpGXqrBXCL3I/ObcIvn7SNkQZOZmVVWbxf2U1TQXvzhER1oWhyLJVBnaRxI4QpUjwjpOj8djGY1GnlLFIRLCyrgcgmE6ncr29rbU63XZ3t6O1VCqKuHrQYyJpJ7JwZfNL86T7R6awCANqFX8DtMYYDnPUKjwnT9t4RVw/yKQ96BbRCfN7zbMCj5THrUSpOtxGghSohbFqdkhGoKU+SzqxCKQcUeoMkQUAgSMx2PZ2NiQU6dOye233y6TyUT27dvnqRJh0tre3pZbb71VarWafN/3fZ9sbm7K8ePHZX19Xfr9vvT7/Tmn9ywcSbNoGHFXKDLZgSmVt3CxvSMQoTBqHq/+g0KE+4BM4U/7N7BvVRQTD5/X7XY9EzHeLZNx5FGH5LClh/PjQDvC286pSucZ9n34mez0QgZTaA0TgeF6o9NFvQ6bL1N/pO8VRo3yQ9g8OWQD1Iu0VCoTsiRTVSfvjlDlhLAVBYMewid0u10Zj8eRHA0nk4mMRiOp1+uyuroqrVZLBoOBzGYzabfbcxvrZoG8yFRUsElCm75Mg1jULURYqYIypdNG+mkQCk4fZj9WqmB+hKNw2VZgmepxFspLEmTtv6QJDJMr/mPTNE+EwpruNZmyTSDSKrcy1C+H6MjLFcSEsvRLSeAIVYbQHV9YU93W1pacOnVKbrnlFhkMBtJqtWRpaUmOHj3qbZTsBzil93o9OXr0qAwGA7nTne4kx48fl+PHj8vJkydlMBh4S+41sUhSqZM2iKjX2863qQUiOyEF2GGcz+dtGqD2hJ11s88STD0cI4pXaDKxSjKQscM77jUcDr18sA9VlIUOYciEKa0kdSBNollGmBQg+NnxJ/5ardacQoW+BCs7h8Ohp4jq+2gC5ef/pPMWF1UfEKsMKMOaaId9r/zubG4JZW5bZYAjVBkjagfDCtXW1pbU63U5deqUTKdTOXz4cKg04LDcbrdlaWnJ20h5NBrJ0tKS5+xuaxxxB7UydaYm3ymQHSxh505Hr3hj81zUIJWsVPF3kZ2y1ebWpP5U7DsFZQrPi+dIkziXFWVVprT6pO/F9Q3EG/HG+P3BlNxsNudWk4rM16EwilSaREqkun6WiwCb2huVTJkUKlNf6oiVGZUmVFGUn6KAgTXsthLT6dSLRXXjjTd6BGh1dVWOHTsm3W7X+swwY3W7XTnjjDO8Ge50OpXl5WWZTCZypzvdSRqNhtx2222eabDI8styUDeZ9NjPCP/rmZwevETEN9Cq7d5MrNinCGmyf43JjyrOe0HesQJwMpl42xnB9Jfmij72zzL9Fuc+ZW7PJuj8mszHJtMeVoIirAn/gUix7yTqEn7juqxjjZnyxdBkKkmZa/8wh/yh/fN03+P3fvlamxlZk/WskKbZuQhUmlBVAVEJw2Qy8cw2MM1hYAoa1LnDxYCKjrjT6XihFLa3tz3TEzrmPJ+xCDBp4vAJJlMJPvWAxumEvR+TJRAaDDqmQI/cccWZLCCvIFbwvTEN7HnABXncga5TIE/tdtsjUXwM1zDQxhF3DOpVFKRJpgBbOA6H/BFF9TYp5bb3yH2ZgxkLQaii+NHkDTgos1NpGEwmEzl16pT0+32vE93a2pKVlZXATtQk989mM1laWpKzzjpLOp2OfPOb3/RMi1pByQNFNEqeiSEkxXg89hy6RXarC+1224sxFXfQ4PvyKru04xRxwE9WqOr1uoxGIxERb1sjflbXQWYD+OJp/7l2uy2NRkO63a5Hntrt9pzpz0R2UD9AxmDaFylWGdImbodiAWUdk2WeVOn6hE+tyNtQdQUpa1SaUPmx6bK8dBCqOErV1taW5+vTaDSk3+/LaDSSbre763xt3jLFsOl0OnL06FGZzWayvLwsW1tbXtBPPi+qClM1oNOAGghzCWb9AK+wQpnGHTRYoeJta0z+VEnqLg/gMB+Ox+M5NYyfJYt3aOq0y44sVvPpd4H/oSBjJ4NutztH6v3S059FKY8aTqEqB7SLARak+PnLmcx8JncJ028O86g0oQqCzZyT5/0RpJNnoGGBwbDf78vGxobceOONMhqN5JxzzpGVlRVvtsCDvF/n2m635ejRo1Kr1eTw4cMyHo9lfX3dU2pwz6xRZIPELAwdDeJGmfIF0xnIVlpb9+C9IhyGqbOLu+UI6gScluFvg02yOXJ7mvAjm4ts9jP5LDERbzQa0ul0pF6vS6fT8VbgYtEIv/+o9+X6WRShwgDuFCr7+FJEf8ehW9DetXuBzh+TYk2u2H2E+8As6l2VCdvCEqqiyRTygEGbHf7C5AWqCRrD5uam3HjjjTIYDOTo0aOytLS0ayl10Ey11WrJGWecIbVaTQ4dOiT9fl+OHz8+ZwbKGmVpLExo/IJ36hVYScsJHRsTYU1y0jD98Sfv+ZeW31zcPJVt0E2iTNlWzrGJj32kYOLr9Xpzjudx7833Khror8rSvsuEvP2O0H+wryir0lzneLJjUss19EKaLPLud/+yY2EJlQlZsmobsIVM3M6GI3DfcccdUqvV5OTJk9LpdLwOOo7jcq/Xk6WlJWm329JqtXJRqMrSSLjD4dV+ttVaUBv4WNxnMREqjoeVBLrThCIlsuMAD98bm49OEiyyEqVhqiscOwoEqtFoSK/Xk3q97rVXKFdJV9ZxWUdJS8dfizs4Qu0tS7vOG0WbWf2Ad6pX/Wl1icmU6RPn8f9RVq1HzXPVlc49Q6iKIFOz2cxzaIYfS5xBczKZyHA4lOPHj8v29rbccsst0m63ZW1tzeu0o1Twer0uKysrsrq6Kt1uV7a3t+dMX2GeKwrK1uEiPyCRvB0NoH2p2LEzyUycHT/Zt0lkt5O6H/zqMe9JiDqH+0AN43qY5QxaE1Bd//PuPNPwlbIpUyBLvV7PC8aL72z6Swo2s6WRVlxSxaaiKg+Ciwq8H/Q3tnrLsIU/YWtIVmPoIiickVv3Jz/5SXn84x8vZ555ptRqNXn/+98/9/szn/nMuVVmtVpNHvvYx86dc/vtt8vTnvY0WV1dlf3798uVV14pGxsbiR4kCvyc2dO+DxQqmNX8zEtBaSHY5y233CI33XST3HrrrXLixAkv4nnYdBBhGWQP8XDiEr4qAuWAP55pm9QHdi5O2qHwgMgxhDhPSQdNvUSfo2+bSBWuKfOsuwww1Q2Y9brdriwtLcny8rIsLS1Jr9fz/KU4rlRcsPNw3MUuaWMRBsE4qGI74fqjybAfKebfTWmkmbeqE/PICtXm5qY84AEPkJ/7uZ+TJz3pScZzHvvYx8rb3vY273un05n7/WlPe5p897vfleuuu05Go5E861nPkuc+97nynve8J2p2IiNLhm261/b2tozHY+n1ersG5qhpbW5uynA4lH/5l3+Rm2++Wc455xw5ePCgnHXWWbK0tBQqDQTz3NzclK2tLW+VUb/f92zuWgZeVCCuF0hvmPAJcE5PEkIB5YvVN+yczuVvmhUG1Rstz0N9gJM6VBQd0JWVpDQUq7Cm0awUq7QnBrZyZzK1vLws3W5X9u3bJ41GY9dCFDxbnPLlAYeJOEhV3m1Vk/9F7ysYccaPpK4CaUDfO4oSrhc+setCGhNM1Omq16PIhOrSSy+VSy+91PecTqcjx44dM/729a9/XT784Q/L5z//eXnwgx8sIiJveMMb5Md+7MfkNa95jZx55plRsxQZeaxUANDpsXN6mOi1GiBD9XpdNjc3RURka2tLlpeXQztKj0Yjuf322+W2227z/GsQeX1ra8sjWzr/iwzTwGDzpeK91pKqA3ifqId8f3RU+D/uKjD9HQoknoN9rmzXV7GDy0NlRdm1223p9XrS6/VkZWVF2u22dDodT/HV7yGoPZnKm0k46p1tRVYUaAfjsJNN7bxcxToSF1VUptIE3jdcJJKOoWmar8uATHyoPvGJT8gZZ5whBw4ckIsuukh+67d+Sw4dOiQiIp/5zGdk//79HpkSEbn44oulXq/L5z73OXniE5+4K73BYCCDwcD7vr6+njiP3HlkpVox68b+eb1eT9rtduT7wUw3Go3k+PHj0ul05PDhw9Lr9bx7+KU5m81kY2NDvvzlL8upU6ekVqvJvn37ZDqdevGtoJYgPlPSSl72RoKGDJNsp9PxJVUwj2KRQFwlh+V2qFO8ZyBW4bFiFeQjp/OrV4BCLcGejhzY1OTcnNa70/mKqlgVhaD2CaVv3759cuDAAVlaWpK1tbW5oKrarBK08EObUtgHxmaaSapQRSFVnC9tml5ULAKBSjrxwycc0nnCx64FcdIGOVuUOpQ6oXrsYx8rT3rSk+Scc86Rb33rW/LiF79YLr30UvnMZz4jjUZDbr75ZjnjjDPmM9FsysGDB+Xmm282pnnttdfKNddck3ZWcyNVHHcIlYedj8PeF9eB/AwGA48M2YiAyGllamtrS06dOuWdixVHIiK9Xk+2trakVqtJv9/3drDfC9CmFL+YPiZfqqSdlfYd4PcYJ22baZD9qLDKDMfDpBc2L3thpR9W9CHCebfb9WJMcdnyYORXzia1x1QvNXlJqlABcZUqXOuwN6DHS54Q4rewrgm2Ol11pE6oLr/8cu//+9///vIDP/ADco973EM+8YlPyKMf/ehYab7oRS+Sq6++2vu+vr4ud73rXRPnVSR7UoUK0+/3ZTweeyt/ut1uLGY/nU490+Htt98u9XpdzjnnHOsqwtlsJidPnpSvf/3rMhwOpVarebNpEITJZCIHDhyQEydOeIoN7rMXgC14sHAAA6YGTDwo6yTqAF/HkdtFZI5cQZ2y1U3tB6VjUCG9drstk8lEer2eTKdTGQwGnl8YrwrU6cZ5Nj9SVRZTYtx2juu63a6srKzI/v375dChQ17kc06XJ0x+Kzi16sTvH23Qz2E4DbObzp9fenvBbyorZSqqYpsEUdMOcz7qIeol+hyMZXrRi6kc0dewMrUodSnzsAl3v/vd5fDhw/LNb35THv3oR8uxY8fke9/73tw54/FYbr/9dqvfVafT2eXYniayJFU8aMKkxnK5SPTGyyRtc3NTtre3pd/vewEDgfF4LIPBQLa2tmR7e9sbWLGEG5V/Njvt8I6YOYijAyVskWYQJmgfJr/GjU4iC+JtMvmwUhFm/0YdCRnqCD454CR3ekEdWlmIUBnA5YgVfH4rZP3qi1Yo9W9h2l5a7XPR27lDeuB+gBdbcD/BJkGGVqYWqU/JnFDdeOONctttt8md7nQnERE5//zz5cSJE3L99dfLgx70IBER+fjHPy7T6VTOO++8rLNjRdakCn5Ow+FQBoOBF7cmToA0VMRbbrlF1tfX5c53vrMsLS3JsWPH5IwzzvDs0rfccov867/+q2fCa7fbcvjwYel2u7J//36PfE2nUzl8+LBsbW3JbbfdJtvb2yIi3sbJUTvaqjUQOOPjz888AwLKZZfEqRLvCiqGyHxAUXxqU4xWpjhOFkOfhy1o2FTs59uTxoo/zodtEpF1nUnannlhQq1W87aOgbnPRpr8Jk02pYf7i7JiURWqvegzFeV8U10V2QlAza4ivIdlUPtYFEQmVBsbG/LNb37T+37DDTfIl770JTl48KAcPHhQrrnmGrnsssvk2LFj8q1vfUt+9Vd/Ve55z3vKJZdcIiIi973vfeWxj32sPOc5z5E3v/nNMhqN5KqrrpLLL788lxV+fsjKjwpps3Mqvsd1woWT+nQ6lVOnTsmJEye8YJ2o1Nvb23Lq1CkRkbk4OZ1OR5aXl71tV0R2Btvl5WVP6eKBfZFnr/xuwpAjJjVp1Rftv6V9aPzyEiYf7P9likfl937DTDTK3DGm2aZh1mBfOj/TfRhfEtOxsOqUX7mHfSdxFHIHB4Y2FTO54naC3xYVkQnVF77wBXnUox7lfYdv0xVXXCF/8Ad/IF/5ylfkHe94h5w4cULOPPNMecxjHiO/+Zu/OWeye/e73y1XXXWVPPrRj5Z6vS6XXXaZvP71r0/hccoLdI7D4VD6/b5nJhART6WKWtEQ3fxb3/qWnDhxQv7jP/5Djh496s2eh8OhzGYzWV1dlXvd617ecahjfD9EdD569Kjcdtttsrm5KSdPnpzL+6KCI5cPh0NptVq+MVbYl4rNolEHGiYqiBHF+29h0Abx1gTcFGw0zOq02ez0ogSTrxzykhS2+FI202FailXWnbWebes64vccJpOIPpfJfRiEfe9pY9FIVVGDfBqm9CTqeJrg9EwWHw7VkoXbRBkQmVD9yI/8iO+L+MhHPhKYxsGDB3MJ4lkmoLNETCo45WGAi1O50PGur6/POZV2u11vuwv4RbGJzwQoFUtLS148nUWt9CbAQRLvyO+dsCNmGuodz+5gYjP5U+nB0+SfYAOrjewDhE+Ymfzet586VQYfq7zIlJ+vFD7DtmldXknMx3HrYhC51eeGcVzfa9DBWx3MdTvO6vYqYc/s5RcWPKiJpPvSZ7OZDAYDmc1m3g70UIs4onLUe25tbXlqw+bmphw9elTufOc7y9ramtz5znf2NmcNgwMHDsiZZ54pN910k3S7XRGRhXdOx7uGE3+73Z5TqExqC8gpPsNETw8yl3HsL5iVRGRX3WBCZ0tbky/Uayha3W53jkDCN4xXLqb5vk3RwvnZNYrubPX9UW6IM8XBUXE+vyMmHogxZpugaOfcKEQlyORoQ1QSxf8vkv9UGvVMq8Zx2k2cCUlZlKko99Ptf9Em7Y5QGZCVLxU7AGOJPg9gce+LtBACYd++fSJyenUklnSHIVQYaPft2yfdblfa7fauLUoWEUxooByaBg2TyqOJTdJ8YBbHmzXzljjIhx7MTfk0kSpOE+8XBBKDQVRHdJuP1aIMuiLz7579qPh3PUjowYP/T9MXLarZz+a35TeoL9K7TBMmMpvH5LNq7yOIVC0KHKGyICulCv4po9FIBoOB5zcjInNyaNR7IowC9ulDJGw8S1jAYX1paUm63a4XpyisX03VGjoDjv4IwoqB0wQMpqxQxfWh4vvjOEJsoOxhvsXvNmd0Hvj5ux7UW62WR+Dgt4XVjqbOLw7CELMymAoZpsGxVqt5oSYQVgTbzWDzYxGZqyusNoGscjBVPx+9OPnl9+73zoKc2E35CaNIle09BiGN/lzvycrPHvQeTJMwvSjFhqooU373x4Rj0ZQqR6h8kJXZD4MYnMp1KP+4wLJ/kII4gyE2e223257jPJuY4nbWVQB80lip0uoQgA4RpjIumzjlgHqBjgZpIl/wtwP8yJRfJ8VEEKZnmP9AsvC+9XMFQd9LT0qqCJQhCBWUPezZB/WXlUomIKYYPWn1JyZVLOlAHEadqvL7TBNBynSYALdhzweqXvZ6srZoPlWOUOUMXu1Xr5/eGw6zXL28FIha0TY2NuQ73/mO9Ho9bwWXaaNWztMdd9wh29vbctNNN8ltt90mGxsbXl6azWboDZirDJhk8ceExtZ5suqQloM60kBnw4sXTJ2P/l+rV1qtYt8s7uCgiDHRTwM867Y575rIWB6wtQkoU9hSZmlpSVqtliwtLUm73Zb9+/fL6urq3N6cIDQcX4qJFlQqbVJO6q+m37nJdBu1PG3nc3pVHNzTUqb80uNjvIEw/2aq70zCTeS4iuVtgiZV2hJUZWLlCFXOQOc5HA5F5PQWFjAvtdtt75wkitX29rYcP35cjhw5IqPRKDB46Gx2enuaEydOyPe+9z259dZbveCeMHuh4sM0tIiA4zA2hw6aXWozTlLwYMVKFcfI8oNJBWGzhFYxmGhx+AQ2YcEcKBLd/Fc1MxADZQWlFkQKcdz27dsna2trnnIFmN4dq30i8w76SQcQ22CURDENQ6b2KvwWD0X5zv2F3qXBNDFbtDLn5+FQMSLVVqocoQqJNF82OlooISA9Jgk0jk8VNkNGpPSVlRU544wzvEY8mUxkY2PD87caDodehPRbbrlFTp065flOYcDQ9m4uk0UC3ot+JzZo9QFpJCkbdpIHgTU5yvupVMiTVi90vvBuEZdKRKTf73vP3mg05szHSZUUfr6gc7OuXzazS71el+XlZWm1WrK2tuYFvMUn/AyxjRPXDzaZMrHC/1ABcS8+P62QB2mWW1y/wLL1DUn7bd2W/O6h219QfljZFEmuWGqU7V0ANl9NtIm0TeR5wBGqEMiCOWOAHA6HMhqNvIFN3yeOUjUajWR9fV2OHz8u//RP/yQHDx4UkR2z32AwkJtuukm2trbku9/9rgwGA2/FIRzb0fHDZ2Q2m805ujPK2mCjAuY1DHxhNj/GYAg1B+pdkoEN90QaSBdpmwZRW2duip2kFSp+dtQPhOEAmUJe4gz8cQfZtAbnKG0H/lKrq6vS7Xbl0KFDHoFqtVqysrIi3W7Xm2zgGq0u6uNQGLn8cCzpwBGXVAWdsyjtOg1Aqcf/IubywXlB5EuD2xarxYv+DrTpW2THxcJvJXNZ4QhVgUBlQrBPDOA6nk1UpQod9sbGhnz3u9+VjY0NGY/HnsP5eDyWEydO7PKVYXKAc5E3kD+kv4gxqVDWHHw1rJrCjslp+pdgtoq6oZ3TdT60eU/PrHnAn81mc3sTInwCth7CwgncPy1TLxO8MtWjZrPpKU/79+/3Qoh0Oh3Phwo+VaawCXrig3qgfSN5sGB/pyiwDeZ68heX2C/KQB6lXPm96EmtKR1bv6xV4SzyGhZlfo/c9rVlRi/miBujMW84QlUQ0IkimCScgbmz1o01rG8VBr877rhDTp06Je12W7797W9Lq9WS5eVlT6kydRyYhXW7XS/gKM4bDodSq9W8QJ+L6EvFJDdIoeKGDhKaJvHgGRsTbhMJ0QSKP02mB3Ra2r8OzwPyzNvTIA9pBC+Monjl0Yk2Gg0vbhs2GgehwsIROJ/boE31/IlJCJRfPHucoJx8P5sZ2K9sg3yk9hq4j8NKThMZ4vLGH5evac+6MO+W+3NOI2k/Uub3qeslu1Zo3z9W/ZK0lzzgCFVEpO1LBTUEoQ40O2cE3VM3IDY/DQYDT32YTqdzK5N4poVOGL4zwHQ69RzVOfJzmRttXKCjZDOYDbrsuBNNq2zYKd1m7rMpU6YZN85jNQ1xrlqtljegTCYTGQ6HMhgMpF6ve3tDpmGCi0qqsgQ/N4cM4T9eJWuqD36THX5HtvcRFto8YnsfWq3K27xXhr4hTBljQoFJrG2yyWkyoeKJr363Yd/xXlamTMdNq9x5Nwe24pQNjlBFQFRfpjAYjUaysbEhIuLFA+IgjiLRNk/mhqRnsN1u13uGTqczdw90BjgXZr7t7W3Z3t72zH+bm5syGAy8Sr6IYBOXNm+aZq0iOwE+tS9VWvmBOmTKj0mR4vhhNkLFzp88Q8YzYIPt6XQqg8FABoOBlx90bnGJUBlIFTpl+Eb1ej3PR4r/wu40IOJvauPBGzPyOOTbpJSY0uBFKKb8ZD3oFkWqgvpJVpCgfGCBQZh0y6yQiFSTTNnO0f2C9lEs27twhCoitE9T0hcK1QEr/nSIAr6X7Z5Bs1VWOLTjtJZScT3ygTQHg4F0Oh0vPlPZKnLa4DIL0wnwKr+0GzorZn6hHDSBCppp41Mv68e9sFCi1WrJdDr1TJocSykJykSqdNmZHGKDlEqGNsOZiC23L1Yf/cx0uq3ra/meZRhYy5IPkflVd0Em8SKQRjmVpaxNiNO22RSIum5yhykLHKEqGPBPaTab0u/3ReT09i+sHmhWrmdSPOjb/Cng/4R7YACDA7JtQBgOh9Lr9TwTYKPRkJMnT0q9Xvec2svciOOAQyeAQJr8jUTmV9WJ7IQhYPKTtHzY3w5KFe7NBKBer3vmOj1IaMKMNPX2GVDBeMDB++92u54ymYbpD89QFKnC8yM0CMoQKh38GW0dts30ZzoPaWsHdExyeMJjSzPIh6es4OfNsq8IGljxvvGOy0SmALzTOKFXytwPJ6mnvCoWZEqvBCyLeugIVQyk6UeF9OBLxQMmOl/ch4Ms8nE/9YIrIIgCVrCxEqafh5UqveUGVoOxulHmxhwVrBxEeTY9401zdh7U0dpUKdvqGFajkG/upPg4Ewz4+aXZcelyyoNU6YEUz6TLN0jhMx0PUou0+mmqZybznI1Mmcx+ebXHqKs181KsbAojr8Yto8kobl+6SP1vEDABQx+FiVgZ3qUjVAUDHSqCcc5mp/dXg08OCIuNhesOyqQ0QV0ZDody6tQpGY/Hsrq66tu54TeoMr1eT1ZXV2U6ncrKyorUajXZ3NycC/q4SI0aBHc0Gs0pfSLmxQIcfoDVBjR8vj4uoGayKqjNthw00lZfdN5ZAWVnfBAs7PEH5bTf73vPlxX5yZJU6XAHPOnQExMTOTKVKxMZ03GUM8z7cPbHYhFNioLUKBP5Mn0yQUybbHH/EeV96faU5P4aOiSFTYkqw+CrwZOmKNeUGWm3Ye5LtbptM63nCUeoEkJ3oEnS4QCOPBBzpx9EoGzA4AeSADMjD5w6Pwx0TjCPsIlkERHXpMJmhbRJARMd0321fwiOB+UX4DqmByWTaSzt50troI1yL4DftyY4Ya7XnbsGp88LHjRhikKmgkiVLR9pIi/FyQ8mv0E237IKX3YUXZZVgq7zbC2xKfNR04/6PhyhSgFJSRUGylrtdKynfr8/F6GczTEmU4AfeJDFuePxWO644w4ZDAaytLQkIrJr1R/nC4oIgj/u27dPRMRzVl4ksFKjV9eJiNGPiq+DPxpHXE+rjBDGAGkysdEDiC1/tmNaqUL+a7WdFaHLy8vSaDRkc3PTezY2F6YNPQjGvYdpGTaO80q4yWTixYTT9+KB2uY7pcmFVor6/b4MBgPZ2tryotFzwFYmdLao+DptfR988vVZKFOcHptdoryjuASa21q9XvcUfT91gsshzz4rapmEVajKTryyLmNT+tpFJo6PlZ7EmHYG8YMjVAlgMwHFTQsdKa/24/skGVB0+v1+X+r1ujeA6BVqppkzBhQoFTq8Q9Wh3yObgMJ0YHp2zDPmNDpAk++NvndY6PO1DxUGSJh9scoPcZmwNUZa4ME1K6XKZPLR5jk9oPF5/GeCTaHizhkEXStUOI//cMwPfspUFmTKhrikCtdGAYefqNXmg3EyedYEM0ke4yCOKqbfv0M46AmGycITNh3u96PWE0eoSgR0uv1+X2azHV8qNiGJRO+AuGLAD2c2m8n6+roMh0MvQnS32/Xi8KCCwjwInw8sm+etSrCMXqT8M6cw0B2xzSxqAt4V/I5EJLWymc1mc4sK0HH4DfImRcV2LgYozPT4s17f2TD41KlTnuKCGVxejuRpwESSUE78/hDQE+oHX2tKk80NPDBitSh8pvQ+kbzSL8yqWRMB0ybBINNfGjC5H7C5RWT3JNBmnuPfTGXN70yrDjbXA+1bI7JTHvB5tCFJXdb51/eypW16l/xbFVCUxcJ2X+0vGQYsYDiFqqLgl8j755lmrXEBUxQGeChMnU5HWq2Wt98fq1UcPoA3yg0yMS0KTKYVP5hUqrTIhkk1DJOXsIQKv3EkfB6sWq2WiMicQlmvp7sFkVaqktT5MGZO/Ynnx1/YFWE2ZY0JE5vP+Ty8U5t/nL6P/ixytV9Q29dkgtuEqZ2YCJP+jEKsmVRpE6XNNJgUfvXOln5e72svgMsw7+17HKFKCWmY/9A5Yq88KEntdntX2nHuw5UDe7SdOnVKtra2ZDgcSqvVkltvvVU6nY4XHgGSOmbVg8FAhsOhTCYTabVanrN72gNr3rB1rnqhQNj3jO1M2B8m7dV+ID6mAUZH1w/Kr2mw4hWDIjsxthBBnR3TWZlI21E9Tnn5DWqsRsFctLS0JN1uVw4dOiTLy8uyb98+L/5WmAFcqyFszoPCy/54TIyj+M0w+dLHTKbGqGUUFbre4PlRbihnXfYmJSqM2dr0rEFlZ6pD+j66XUeZBJl2svAja7ZdBkzP5ghWteAIVQpIg0xxWjyj5YbN5hvbDCsojwy+BxyMNzc3pdPpSK/Xk263K51Ox1sur1co6Y6zqghSHuIqhHq1X1LFBWATEfLIMClTUd4Pr/bTphkd9DIrBM3oo6ZjOs7+N81mUzqdjiwvL3vkCopclHtxuSH/TMr1Sj6cE0WZ0tdladYLA10/arWat10PPk1mujDkiYEy4nIsA6JOWvzyHaYuOJQXjlCVEJixwvFX++BEJVVBMjPuhQGh3+/L9va2Z9rhThHnsh8P8pTWIJgHwnR+2jkRHXkYIsFxqZrNpsxms8j2eJHdK6lgth0Oh55yiPPClnuYZ2fFCefrPQqxQEEP8mmtzgub36jAyrBOpyMrKyuytLQkR44ckaWlJTl69Kh0Oh0vDlycvJpMfqhLTIT14gK/dqoXSKRBpKJOBDkEgc0Xin3Q2HwnYg8ya4M+j1dkRkFYU33Yc5GXqMoa3wdpmFSqKPlwKBccoSoZmOSweiSysyRfnx/HF8DU6YuIdy+sAkQnCWIlIp55j009aTkM54GwM0mR+ZV1UX03eJCByVAkfGep3xEGa71ijDfb9XsW03fb+bzaz0SoOFQDntX2XEl8yLIgU6jLnU5HlpaWZGVlRQ4dOiRLS0ty8ODBxMobv2cm4iZTThApYjWLCVjeKgbeMSZXeg9QkZ2yxXlpv7uwSlDSe+B92OotE0OTGqxhe79sHq6ywu+wA0eoUkbavlQiMkeoGKaBLKlZSTv0sTqD/EC9gfM8jpUVcfPGBIV9laK8YwwyUaKK2wZbvG+8i+Fw6CmL7OOVxuwW5jD4wHCnr81/Wnko6+yaF2EsLS3J2tqanHHGGbK8vCwHDhyQdrud28Qgiq8QlK28iRTyCH9AlJ8mEkys+PcskKR+c55sPlXaZGt6jqDf/e7NE5RF8pVyZsrTcIQqRZjMM3HBhEoTK9xDIw6ZCjIHitiX/aOjz7IDLQNYHUDHoVUM2/PD9AcftbD3E9lt2mCTB5zSsek10rfNduO8H473w/5aTKiazaa3iILjvui6koXDelQgv51OR/bt2yf79++XY8eOecpU2nXYNGiz6dzvOk2kigpLUqvVvAUqthW9bOora1w67pP9yjBI0Y3T15V9ouGQHhyhKim0EzgGSx4wTZ1XnEEhTAdjUk3YSZTPL1PHEbfz00qFdiSOkh6bTkVkl/nHdA+TjwyTGZj7eEWoyE5oA5NyFDXfIjuDJQf91Eveyw4O+9DtdmV1dVUOHTok+/fvl5WVFW81a1rQ6lKc65jAp6U6+t1XZLdJDQTU7z1zfcgacVcR+5GpPMyIftD+dA7VhiNUJQY6EIRPYIUKfky8ZFebh0wwqUx+MClt3AkwuUp7NVtUJO0U+XptHrANbmF8kjg4pF+56HvoQVmbGhqNhgwGAxHZ2QaIY0UlVQ5BmjRJQ7qsSoQ1Z6btsB4GyG+73Zbl5WU5ePCg3OUud5Hl5WXZv39/JsqUiVCZ3oc247GPXBG+UgAc92HqMxEqTa7zQFxyGaZPKopUcf/iUG04QpUhkpj9uEMGkeJgiyLiG4coKG3T/0HncwevlZSiO4QwZi7Ts9pMGPo3G8mxpcG/oR7YojP7reDiMmcyw35UIuJFZscn/O3SMMdqk44pGCPOK9NydgCkttvtyvLysvfX6XQyJ1O6rdm+sxptI9N5Qa/gi3tOmvBT/KIuejDluSwuC45UVRuOUGUA7XiYhFRNp1MvkCbiQWFwFtntr6XJlU3SNpEkv3zo73xdkQE9kyowtuPa2ZaXveM7E6QgUsXO6YzZbOYpkKYAoCbyqwda+FHB/Dcejz1ipZd3xykjkDMEcjVFEWf1zXQfG8nK0rcKacMHCE7ohw8fzsRnSmS3v51+bv6NSRQWeHD9KErlRf8ShkzloUzpyYYtT2ECfCbpi7NE2SYhDvHgCFVGSEKkOA2TXwUP7NyhYaBn6JVpGnHJlP497w4hrnNoEAGyEVKR3c+a9B1rNUoH6jSVNb9jbAskIjIYDDyT33Q69fZj5JV6ScCO6Dpcgg7aWCaw2RIBa9P2mQJM6pRJbdJxzUwbJQMwpedhrtLv0y/dPN+3bhecBz6WJDxHXiibj6lDunCEquRg5YLDJ/DKK5HdgeaAtIPgmcx+PBD4+Tj4xXSJCp5F+3Wkmqz4DQLaP4hJCNJAeWIbliCiYisLmHJ1umzitQHnQtloNBoyGo08BQnL/zudzpySmdR5GAob9n1stVpegFEE+LSBFVsTslKqarWadLtdL0wCtpZJG1zPOCo6hxeBAjUej2U4HBq3o2Gwr2JQO0ljAieyW53FMSAvB3TArz8RyW8FXdT7+PmwOlK1uHCEKgckNftphUo7gEO1QGeXVueq8yGy2xxVxIyQCQ8PAKw+IW/av0fDNlBp/xCT2qDVK1uZ28w/nK7p/6AyYOdl3Lvf78tsdjravYh4carYhBO1bnC5cvwpXgXGg3DZVAKYLTm/aYLbgkl1NJn5TIsPROyEMqhMTSpWHAUXn2VQHE2qLVAUKQlz3yDzv9/1ZWw/DuHhCFWG4IEuCclBAxsOhzKdTj2fFnxisAwzk40KE5HCJx/z6wSi/BaUf14Cb9trDQMUK3uadOn78gCCwZdVHTwjCAwrWCZ/E9wHW/TAgdy0qS2b8GyEykYGYfqF+W8ymUi/35dareYpVHC+xvco9ZAJAgI8djodEdkhbwgwykqb30BoOs7PZHveINjMtc1mc27FWppEQStTrFBBlYIahT9s3VS2PelE5sN8FEWomIj6oWykKqi8oqhcTsWqJhyhyhhpqUU2pSorRYoRRKbyhm0Jt4jMqXYip/Ont3fAMUCbNPDJ52g1AenZVu7xuVi5heP6nnzclJafasHPzT5VWP03HA49R3UOpRBHpdIKFYinHoCLVjbygq1NmpzO9fEwhDkKTBOTqP1C0Ll5OqDrY2WDJjxRyzkuKXMoNxyhqhAwMMNfRfs4pKlSsZKjlRQ9+NvIVZxBAtcEBRI0/a6dr1k+B+EwdYTasZqDGTIJY4WK0zbN6DFwQonAu2PfFO1/5Vd+tkEFChVvbYNVf+122wsXgOCfS0tLXtTroHrCCyC4vkHxWlpaknq97ilv/Lxcvn75tyFJHbYRO01uk4DJMojTcDiU2WzmlQF8pLQypYlVloQhLKkyOaQHpcufaU0atTLFZWMjIGmWX9iJgen5bXVd95Nc1to1AX2YaTWwQzCKLidHqCoCbnhMcLhRciTuNLaA8DPpBZn5ioCpAwTJgLJi6ghtK9ZMA7Lu9HmA1sSWfWr0AgKcF2Xw8vud7ykic6v/arWaDAYDaTQaHsliYmdLU/v3cP7hiI4/9mnDOWWrH/wukqi6XA9AqnivPdO7Z5NgHmCyH6SkmOq56TzTZC1NBd6vbPIaKMOqrNoywOebJm16EmY6h90LHKKhLGXmCFUOQMOLO5vTMxzMcrlzY9WDFYsk99LKlP7U1+D/NAaNIKXKBhNJYbOYyeTCBEqHBNCzzvF47A1SMKXZfE6YkKAz5ajiqBeYkbKvFt9Tw2ZihC8VAFKNMAH9ft9Tkbrdrlc2pkGS1RxNPlutltTrdVlaWpJWq+WRN6gzUK1QD3Et5z2uchUVeFeTyUQGg4H0+/25gLhR65dJeWTViQmWjUgV2fmbCBBPMpiU84SNrzGRBSb1UcyNur+JA5N5Pwrihv3wO1//hnLCpI77b5Qb8iJSvFtFVJRxAlUEHKHKCWnM5JjgcEem1SqRnUaaRKnSjTrIt6EsDd9GqEAITA6vmkQFKVT4LrIz8AQNzngXqAtRTCxhwOWPQX4wGMhsNvMc1bvdrjSbTS9elR8JtHWQvDAAn/jjff+0j5fI7rheeczI8SwcusD07GHTYaKENLWiZ1KximgfUXyr+H1oU5QNpsliWFKlJ4p8TCNMPTEpQUEwhYbICjZ3A93f5JGXLOBIlSNUlQIPDFAD0BB1XKqoSpVNmTKZfPh8/X/aCKtUaXOd/s2UpimNoGt4NoyBFSYwv3yCxCCfk8lEms2mt/qvVqt5Sg/SN/0fBJwL0rC1teVFUN/e3vbIFYhFt9v11Cq8a784WFzfOp2ONJtN2bdv35zpGSEb2BSmwWorDzRx6pLtfaM+jMdjGQwGsr29LSdOnJB6vS4rKysiYt5gXIPftfaP4jbC7YaVKV13mGzEUUbSgC5nECGuP6aJCZNkfmdJnyUMkUqbVMVVppKAy8lk8kM/zv03oyyTVgczHKGqGFg5QFBHPaM0zRjDKlUmdSJImSoDtNkuK5hm1fq4afk+TGUip8kVh0gICorJiDIDhEkSJGo6nXoO5d1u1/Onspl8bAONdvxvtVpeeu12e27Tbq1yoGxAtNgEklW9AhEaDAZzIR7YVGWDiSRxgE4uO64DTKj0wInPIoiUSbFicD+i/bC0WQ/n87V4rjgKoA1RVcwwpCpPZcoE0+SN+y5W+apk+ssLWZZFErHAEaoKQQ/mGCi0AsUzYPyGmY7uQHVjjaJM8fl5wc9MlkfnyM8KpQnEwETmer2eLC8vS7vdlm636w044/FYtra2pN/vy2AwkHq9Lv1+36pS6XuHzSvePdKGL9VoNJKtrS1ZWVmRlZUVL8YUl2+Qsoln7fV60mg0PIKBdKbTqRe+QXdSqGOInaX9kOLApFQhH6PRSLa3t+XkyZPS6/XmfOFM1/KkhZUp5Jf9ovQkhMkUR8PnPJXNrKPfD5RK+PzpfOt2oM2FIMppkyqTiRq/m85nM7v+veh3wC4IKC+0KU1i2ccyiZrrkC0coaog9KxZqwr4n/1Z+Dft12JSpQA//4aqNmj9/HGhy8+EVqslKysr0m63ZWlpyTsfZrV6vS7r6+teh5l2Jw+TL4gNwifgNwz87XbbC/yJrWvCmFlBxOr1uqcAgShpJYPLiQkJE5u0yDnnHWXAKx61KqZ9u/CHfOJ5QKy0GgXoNmmrG0UP5oB+B6wu4flBqmx13OS/mSaZAmxkKuz5YX/LE2wGRrmj7elyZTMsE9gyIa2+1YY0nzeLsnOEKkfoRpDE3wCzYBGZm0WiA2T/Ke7ctAxuM11pglW0MmVD0dK9DTCB7d+/X/bv3y/NZtOLMM4DVbvdlo2NDWk0GnLq1Clv0GakRfxAJji6OupRt9uVlZUVz7E8ClD3ut3uXHR69o/S5IJ9/rT/n82HK2y7sdUJlC0TYfZD5HuwggZCxQSUI95zenwPdoAHQEL16seygU1/TPZtqqVWrOLeMyps5WdSpMoIlKmeULHajWfh1cGmyVzZyFWZkVVZOUKVM5KSKU5H+1KJ7Gxgy9vRAH6zTJ2/KilTccsybaWKAYKyuroqq6uruzZbRgfaaDQ85QohCNDBppE3Ux5BWDQpgNkBflZhweEZQDYQzFKrNbifNmcgTzDT2Db1jkumQGJBjED0cF9NqJA/NkmCUPHvWolicx8/F/LGvkVlXxVlIlRYfJE2siRTZYfJ71X31fy7NgNqZPH8UdXBtJWqJM+UZ31whKrCYJ8NlultKpjJYdqWpg1hTDNJKnBUclQ2nxQEukQYAURdhxoF4F00Gg1vlVy73fa2j8nKSRtpYqBnoofBstfrzZmHw5YtnrHT6XjPypHTWSkDAUGQUZgZud5qc1oUMsWkhcM8QDnk8tCmExAtVqhYzbOZ2/HOcI5e4ajVh7LVXZHdEz7tTxW1TkS5Z5rwy19ZCRf7VPEx/bueADmndTvyLhNHqCoMln95pm3yneJrbKTKZv7T38PMOtKccep0Ndkoy4CEGTwIBVbRIawCTH4ip58Dv6+urkq9Xpdut+spVEgvLmwmD5NShcEfnfny8nKke+NcqKIcOJSd0k0+H7q+4jyuz1F9ZTg/jFar5S0QYJjqOW9qrU19mkyZVCs+j9W4rEhJUrAvlek3EFx+ljSQJ5kqM+Gw1WEAdZnVwqAJR5YTW63oZoWw6Zfl3TpCVSDimv9Ms0j9u3ZA5/PjECI/MpWloyDnWXf2ZZzlI09QfrRzt/aTaLVa0uv1PD+m4XDoXWcze6UBVqpGo5E0Gg3p9/tzztu8MjRoxs8+HyCPs9lOQFHTs+A6EFFtosY5NvOzHtj5f84z/sfCAISv0GkwIWJFikMksH+U9g3T/lcmp3RWGcpUb/3ApiY2WcZJw2E3/HygtNWBzcbazyorVdshPByhKghp+FJxB679OJC2aRVPkvvYfrN9B/xInHa+5DxynvGc2rSjO5eigLxibzveZBkzTPZDwfn79u2TRqMhKysrMplM5NSpU56pKcq9o/yuSQqbDTY3N2U6nXrBL/38kvSzY9Vfr9cTEdkV+4k7fZwvctr/CsdRZtoJF78HOXTrOFko816vJ2tra17e2GyCZwCBwkbG2uTHPlV6IORPpAWwnwzKE2pVlsQ5DbDZD3XaIR34kSmASZWIzG2dlAbZTYIgpapKq/7SgCNUCwA2M/AglVbaIsFkKiuVSncm/HsapDQt2MyQWkXTqgQISKvVkk6n44UuQFynrB2XmUQMh0NptVqyvb0ttVrNC4GgHeqDAAKJZ0MaIvaOlWfePGAgj6gH0+nUC0aq66YmfqwWwuzabrfnYiTxO2MzHgfvnE6nXlnwyj0/5cxPLdDkvwz1F2DTq+13v7ZuChTq4A+TkmmDVqr4mPOpKh6OUFUYPKBwoEJe/aEHMt3hBZlybAOgjUzFGfyD1Cste+ul6GWByVzJ6pnNBLi0tOQpVZPJRJaWluaUkij3jJpXVo14j7vhcCjLy8ueE3dYnx88L4gUVpyyGdFm2gABE5mPocbKKwdq1Iolg4ksnOW73a4sLy97eROROXWICRO2loEiNRgM5oKPchkGlbF+TlaoyqhO2co0jFmpKmbMMkCrmCLh+k+eMGgLBPeTYdSvsiJO20oKU9lHHWccoSoBkiotPOBgjzj+TTuliwTHivGrsGmSqTCwdRJhVi3mBfaj4T+GTaES2fE76na7XiwokII8ltejcweJGAwGnk8V7wcZpo6icweJxKpHEfH2LQxSb9jPjNMV2XGSBlmyERcms0xo2UyhlU9uR1qp4k2Qcb7pvkHwe/6ygOubDs5qqotljQcHlLG8dV8WVK/82kzQ8TI+/yLCEaqKgzs4XqnFK3NEdgZu7ZiuO0I/Ex//rv/PasDnfPLzICBjEt8wIKmdn5VB/vNbjajzPpvNvNV+t95665zfDgejBNLqILVShWPj8ViWlpZkNBrJ8vKyzGYzb+ucMGQbZAfb0oCkDYdD66bJ+K7VMCZyIGrsi+T33kDosKISKxH1PVnxwh+2q4E/lTbzmRBk4tXPW5WBDs8wmUzmnPpF5kNTmIhw0cjKNSEONCnl1aO2iRjAbU/XLW3q04o+X5tFGRTtS5UEaebJEaqCkVSdQhrcUNkUYqvoJmLl1/H7fc+rkXBZBRG/vKAVMlY3bAMwd4T82Wq1vHALTADwLvN4VuR/PB7LcDiUZrMpw+FQ6vW6t0dfWLA61Gq1PJNdmMUNfmlqAm3rrE2LF/DdBt2G9LsMMnexo7seAE3PWvQAnxS2FaxlRNFlrfssvZiIz7FBT2i4PejAsfpdVEEZrToqT6iSqhOLAh4AROajorOyEzYGFWAjU3kTGe0sC+VGx9xKgqikhQdsDMTYgBg+OKbtR0zktdFoyPLystTrddm/f7/Uaqc3MeZVbnjuLMDlOhgMRETkxIkTMhgMPF8qlHVYJ3VN6JvNpvT7fWk0GrK1tTUXJJPzgWe2DQB6wGBly3SuzoefCoDfRqORF+0d6lSQomQiFFpp43uwMlFFmJQpBzP0hFdvsI1zwkCTc24P3Behv2Rn9TDvKUl9DFKqkiLNdLPoSytPqEQWh1TFfQ4efFjN4E+bqY8RVqEqShUyOSmzVJ4GseLr/XxFAF1mrGqYgjtqkxOnw+apTqfjrf5DcMw8AYd4dihH0NGwZAodOFbYMQHmzp+hCVaYWXXUNhOUHpM6/f7CdOgmdUqrUkE+M2WFrd9YhP43K/BkBXWIg8EmgUmxEpmfHEZ9N07Jio+FIFQijlSJ7JaSRcwNixUrnOM3YzfdoyiANIFI1et1GY1GXnycuKTKVOZBpNOklEDN2N7e9hzNkT/k33Z9t9v1FKpmsylbW1ves7IfT5bA+x6Px7K5uSmj0UhuvfVW6fV60ul0pNfryerqqogEB/wEQCJrtdMrGRGXCp8iO4ONdvxO65mYgAflGQoVVvj5mW81dPgHfsesftn8yMoMNuFGWaSwV4F3C/LEqlSa7dg2QeM6x20gjUlKlvU26zaRZR+6MIRKJP6qmzIgDV8qpKMbDgiUDkEAaHOaRtEkSoMd7qMoBzbYytzvXdj8FFBWIEBs8gsyX0HJ6XQ63vYt/X7f2xMw7/cAx//BYCD1+ukI6th8O8wmuezbBGULvlT4ztvfZKnY6IHF7zyA61eQ35dWgE1hH/C7ydxTZVSlj80brESa1M6sYfLTLDuqNMEwYaEIlQmLolwFQZsUICvzrNKk3uiBIMt8hUHYd8WzPwz8vMoxjEoV5Khsy7vfzBzlPhwOZXNzU7rdrmxubkq9XpfhcOhFBMd7Aer1uhd0cm1tTTqdjvT7fWm3297gu7m5ucvvKEtfBcysEbkdkdw7nY7naG4y/9lmwFj112w2ZTAYzMV2AvmMogaFBYeD4HhtyKt+Zk2ATW1Lg4+D7Jvqljb3VbVvgi+dww64T0Jd4rqcN5Hi77gvK6hl9pWqKhaeUImYZ5KLDDRcJksgAZpsZNmxZ93YeMDjjiuso3qQycLU6YSVwmGmg1lLm3lMgy3y2+l0pFY7HfATShVUqjzrLwYF+E6xQhWkUulOXOR0PUSUcyhuUKnCKkhxn8PkE2Uj0Ta1LCh/QQpb2czncVHVfGcNXb90vS4SJp9F5yuVPvYEoWJUQbGKS3I0wRCRudkIfI6CVvwx0nb4jXq97f5sTuGVM7b36+dMrolVGgQcpqzt7W05deqU1Ov1uXhOIjuxwXilVL1e9zbwPXTokPR6PS8YJvzFQM7yAp7l1KlTMh6PZWVlZY6k23ypdIfN7wDPiM2TYRplZSwtQAFDLCy9WIP9q3ilLF9vGxjjmCmrPIhpgonPsvepURFWJdX+SVo9LvJd21wMtF9tFkrVXlWw9hyhEim3YpWGYoRGDUVK+3OEWfEX9755wuSfILIT4NTW0ZskcX0s6bNgUEbE8W6368V10uoZr8zBd8R/ajQasm/fPun3+7KxsTF3fV5KAQhVv9/3PrFqj7eKMUGXK2+GLCLSarXmTNNAmnWJFQNWCU0Kp828F0aZioMqDzh6BfGiwI8Uad9TEZkzERdNojRMeTeRnzLlucrYk4SKsWizKyYYGKSwnxoP5CandEZZZhhBihWv3OJVUzBJYbWV7RnDOqQHlYMpHZjLtra2pNVqyebmpoicVmdms5kXKFPnA2QQKs7BgwelVjsd26rf78vm5uYcOQiTv7hA+5hOp15crJMnT8p4PPbIHRQ35N1WHpxPvBtEUh8MBh7pyeo54Nc2m+1s+Mx7XWrfKb9+IYwyxb8FObWXHazimTavFinf5DQK0G/yyk7TOzYp2SYiFTRp1wp52vAjd1qlwrEslCqNoIlgWcaduNjzhEpkMToEhmlWzcTR9Lwm36qqlIdWqEBQEPeIZ9FhnimuWmVKezQaSb/f95zMm82m55Ok34OOgQXfqdXVVZnNZrK+vi7r6+symUxkY2NDRCQX0x/KdzAYyGQy8Zzjl5aWvNV6KOewYEIFB3eUCzrdtDpVpDMej73AouxYz8/IbSbIxy5M/myDRxjlqyzQIVjwh0HYjzCU/dkATMaibDMUBba2YfJrSgpthjTdL4yJPivkqa7nDUeoSoy4RE+bMkwVmLfHAPgcHUYhaUP3a6hR0tZ5hs8NFCp2OIYDtW0lWhQE+QrYMJlMZDAYeL5U0+lUer2e52wuIruczRHgE0rA6uqqF2Uce6mBqGXld6SBujQej70o5+vr63O+VHCcD0OstAP+8vKyR4Jxn7Q7XaiFUC05FAUGEyh/QQpbkPnPL+9VIlMMrgPoP/AeeYFCFSZirGSzMpVFnCgR+7ZIfn181H6R/w8iU3h3tnPKirITdUeoCGVSqjgvcdUiblQ6nEAQWUpTsQqq/FHT1mobBmJTOlhVZpLY/e5pCohqew6/dHhFHFQlEKvV1VWp1WrS6XTmroHaw0Sw1+t5QTBrtZoXimF7e3vX5qdhEfV8Dt8wHA6l0+l4BA+kkFfv2cD1qtPpeGRR5LR/VlZO91CoOCYWBhZMINiMaiOGQeUWFNLCz1RUZqBc0N5wzBaGouxAOA0OqZElbJNXEfOimbATWhNB5/R1OkyqbPmsSp0sGxyhWmBwh82+MPgU2VGqRMz+SVk5CpvyqhHUifDzQKHCMnz4TcHXR2TecZpJlfZfwnfeAysoP0FAbKrt7W2PWG1vb8tsNvP8iKDu6O1pQDrW1tbmVKJ2uy3b29ueb1UUM1mSd8krGEXEiy0FQuVXpxiaWImIR9Yw2KVZ5zD4c3mBvDKB1qbjMAijTOnzq0SmGFoVRltE3S2ju4A2g0EBta3szBt6gZBJiTeVqc1vywRNpvDOdB5wrh+KJmNlVaocoTKgirMtG7gTYV8dU4XkRovPMPGcskJQx4zfMVDy/3huOOWL7AQj9CNTetUS3wPXxAFMf6yora2tyWw2k7W1tbnAnvo+IIT1et0jL7PZTDqdjqyvr3ukCs/o18kk7YBgFoNSNRqNvBV7rLZFWfWHUBHtdttLE5tMp5FnYDqdzu2LiLhYOr94R/gDOQ8iQDZlSn8PUrDKDiYgKB82IyVR1bMC3h1vDZX1gg5THkzwU64YafTD+p0wAUrLt2kvK1yOUFUEccxi/L+pk2elyq+x2hpZHkQr7HMz8WO/MX5GOCDzYCmyQzBNzutcdia/hKjPMh6PZTAYSKfT8QJlQkULIvLNZlO63a6srKzIwYMHZTQaze37Nx6PvZhVWXdo0+nUM0HC2R5b5cxmO5tAh11WD2LT6XTmttzBPdLOO0w9JvOHnqnblCrbNTaY1ISqDjxoC6PRaK4PAani/RuLIlasSkGJGg6Hu9p0VZB2mBuT+S8sqQrbx8Tti8JOpsqmVDlC5YMyKFUmf6Eo14rsBPfUhENkXokS8Q+AWRT8fAn4HdmegTcnxu/atGdSqwAmZkkJFcIPNBoNz6kb8amCOoV2uy3tdlvq9bp0Oh3pdDqyvb0tt99+u2xsbEi/37c6c6fR4eg0hsOhjMdjOXnypEfkRET27dsnrVbLK8MgUlWr1bxtbJaXl0VE5nxa0jLHsEoxm+1Ea7cNImgzpgEsyFfF73taBL0osGkUaiu2f8J7h9qad3R/Br/rwWAwp1CWZQAWKWacMZn/gLKQqirCEaoKIC35nH2p0kg7qNHZ7PNJZlh+vgT6uTQR0uZLnkGzWoXfOL9pvAN9D+0Qa3o/JmAD5V6vJ/v27ZPhcOitGIRfU5phB2zAO4UyhiCmnU7HI7FR93vDs+EPKkia5ANpsYJhKnNT/Ujj3osAPXlB2+JVc3hWHVIja+LA7d20P2RZ30HeZlITqQryrUoLUUibSHilKsy5WcIRqhAog1KVFOjweGZt8ncwqTxJCJep4ST1y7K9D60aIOwAnpGDEbLvh1ZQTH4G8KOKY4Li9BH7qFarydbWloiIbG1tSb1e98IjBKHdbnvqCsyHJ06ckFOnTnmr5LBqLgtoUxeUMc57u92Wbrfr+VcFAe+h1+vNmfrq9frcxslp5Z9X89nyI2JetBFWidLfyzqQJwGTFN6oHGQaK0DZPzBr8CRlMBjM/Vb2d1AkqdLf0/at0sgq3SIVsWK8jR1iI05F4Q6d/QdYxbA5zpquqwo43+xH4fcsts4sSScHssDxpXg1DzZR1hGa/VCv1+eUql6vN7eJcl5bgkDtwSA2HA69P6huYTtNLqdWqyXtdtt7Hr3yMS+ATJsmAFEGg6q1naiAAoS2xSvosgiUacuDXr0nUr3+K+98miaQGjbTd1KETTOqSlyU+OEUqggoUqmK60ulCRMrVTCH2Vbm2JSkKM9v60TDdq5+DU53PFpB4OXvIC4iO87p2r8j6LnidCjoiDqdjqytrXn3gJoznU696Of79+8XkdNb04SZzbfbbVldXZXpdCpHjx6Vbrcr6+vrsrW15RGaLE1/SBeDFwJ+4vkQTT0KwcN5y8vLnjqEMAdp+b9oksSDrWlwYTLHhEGXg8YiK1M2MInRfUqr1fIIchbgcBjwv9sLZZ+GIuNnMstDrcoCRShVTqGqENKqHHGVKn1tHjO/NBov+8zw7DXPjgGDuCneFPyE8Md7EgYB6bDfERzX8wx3AQdgqFSDwcBT3aI6laOceAA2LRxIgrC+GUFEMOx74vOqpJbEBbc3JqFhwk/EuRfqGccvW/QyZug66ueyEbYNRZls5gXt1xjUJ+Sdb6dQxUAVfaqYPGF2HtbBWzuUc0cVRzWLCk18giJY68ESvlPYi45Xd4nI3HYpWTwDz+54HzmY/rCFzK233uptnNztdqXb7RqVKjax4dn27dsntVpNjhw5Ir1eT7a2tmR7e3suZlBWwPNBEWOT5urqqudL5UdO9AwYq/7gC8NR4aE0xh0wYS4NChWCOo32wvHN/KAnJ3tpYGfwakA4qSOmV1rkGAomFNkyKFN5jAum8mNFZjab31pG94l+7VD36XyNKd2kZZ21A3yecIRqD0HPkoNm3qbftRlQN0ATykA8tUKFToGVqiAzWxqN3eQMD/+u4XDoESycC/MkA7Nw3si12WxKq9WSbrfrOYhrVSfrQQblyyoVVvvhtzCmTK5fcGjGcnzdyccFyoVVVm3WC0ucopyjzdGLDl6YwgpVWmQK9+C09zK0U3kSE53JQT1uumHbbNz8FumIznCEKgGyVGWC7hlVJWOfKe0/wr5UnGYcUpUHghQrW9lgUIdJAMu8sWoOM2g9+wPhidPQNWnDCiiTZH3q1CnZ3NyUjY2NOdMgky/t9wPzIEjVoUOHpNvtyq233irNZnNXyIEsOx1Wqra2tqTVaskdd9wh4/FYVlZWIjvL1+t1LxzEZDLx4l1xtPOoYMd31Hv9Oz8LH8dvfmYrPq4nMHsV7CzOoTSSrvRFUFHUibKUsanupIUwpm+tVJnyEmbyq/3gbKQqLJnJg1Qh30XBEaqEKJJUJblON7gwEjDDRKoAE5ExIe9yQ+NHY+X9yJAfJi9AGr5ifK0pTAMGCBHxlp7jPDY5aWKl08GGxaxUpRlyIMxzYgCFSoV4UlHKD8/XaDQ8harVaiUyX6KsbGZu/tTHo8J23V5RpjTYhyqsUumXFj6L8IcsGmH6TSZCSe4TRKriphmEMGQ77gQ3SzhClQKKIFVxwTK59qPSsaqC7O7at6oomGJn2QBzGUxrWI0Gfx34//BKJJCpJI0RhInTNRFPEDytJuLdQOUx1TmsJpzNZnLw4EFpt9uysbExpxzhPlkCZr9+vy8nT56UWq3m+XM1Go1Igylm5AgPkYbJjwdkvFeTcsYkwEa49PmaeJdFNSkaMLPDBy4uoWIShfhnRW9sHIQ0xoc4izK0vysjSjpxiZPt2rTMc347HJjunQfpdoQqJVSRVPGnJlVRwdeFlbyDGlXa5cnmTZEdU4SIzK0MSisyur639iEJUkq4Y2B/Kx60tUKF1XG9Xk+m06m0221PKcoLeEaQKlPgz7CAKofn4s2j0yJVfp0/l7efUhmkYu4lBcUG+C9ysNS46SCtLPZ6zAJ+Cr7f+ayqFjW+mFxMwr4/WzvNmlRp5NX+HKGqKEwSbNTr9SeTKpHd27AE3SsuGfPLY5Tn0vnWnRgrNdqPAxG5RcTz80iTVMHpvNVqhe5I+B2zehh0faPRkLW1NWm327K2tuYpAyA2SDtLQEno9/uyvb0tp06dktFoJN1u13uWKHUFDvdQ+fAcUfMkMj8gwwdN5wXH4ZsDwm1L00+ZcmRqHlr1i+IHinfCez1WDXH6lbwn7NrlIWlaWZKqrBDHzcMRqgojLpnySy9pWiYzYBLZOQ3JGumwaQdmNZEdgoVBnlWktDoyNlXge9jroqJWq3nBQZeWljwSgufj7XiyBEx/g8FAtre3PdLKPmBhgS170thsl9VCk7mIB/wwsZOcMhUeWumLQqbwiVWkVUbYZ6+S5cMPfqQqKspMwhyhShFVqPx6Rq1X+6WhVAFBilVW5eXnU8Wr7bSjNMvrWZBVxMnBIB42aCTKSStoNtRqNS/W1r59+0Tk9H6Bs9nM82XKo1OCSRW+VOPxWJaXl6Xb7cry8rJ3Xhhy1Wg0pNfrSb/f99TDMM9hU5WYSNXrdRmNRnNmFShUKHNeTYk0TGY+p0z5w0Q+yzxAZokqjBd++Yua97QmcWHS0RYYv3Nsx+IsdnCEKmWkPRBnBTZ/aEf0NBt6GFLlhyD/qzj51MHuWKkSES+EQtz0bfdkQhVVncM7gXOv3zsCoRIRj7icOHHCM5WwqStLgJCMRiM5deqUTKdT2d7eFhGRXq8XSaXiaPAIDhnm/ibomGQiO9sQ6ZWr+NNKlZ/PlCNS4VEFMhXFXyhu2mUfLzSyXuUXJh0Rf79HEXtbtJH6pG3XEaoFQZKGGSS/BylVQfdN27cqLGxKFStwUH6g+ID08Iq/pIAShUEZZi8ucz+fBZgK/7/2zjZGruq848+sd2Z2/bJ2jFmvHYJrSBrq2qEtdRwL1UHFskFWFQof0gQ1pIpA0HUVArWQURsSKsUVlVqpFaVfKuiHJG2RQlFdiupgbEQwpLggXtxaMXLqtPXaCsS79u7OzO7O6Qfyv37m2XPuPfd17uw+P2k0L/fOueece+85//M8zzmXz5RCcG+1Wu0QUPg/joXYo8HBwWCGI0SEzyguDUh3dnaWpqenqVKp0KVLl6jdbtOyZcuCIHofsC/W53K5LaNGnUhLNqAQ065Vm6WACrNMKW4gWpMKiKLrPM4xsrY4Ia009aVcRl47Ujz5tB1RqKDKiSJHHlmJqbTpRIkqiY9YsXWGcbaH7Ys8LVmypCM4Ge6fer1uXak8DrIxRFwRn7EXVQ8QQgBCr1ar0eDgYCA0+HEgwur1OlUqlcD112g0gsU+i7RSTU5OUrvd+SDoOIHpWDICK8JDUPHr1rcstv35WmQ+/7Whlqlo0goqomTBwj5p5pVOkll9IIuYwbIRd6ZgElxiiQ+kbL9J4i7JoYJqkWKLmXJ9BlEWn7iCrCjLlW32n7QI8ZubB07zYG5buaSFxSbwkBa3VEHM2KyD/LzIUZUUYdzKg+NAxPC0Yamq1+vUarU6Vq8uQlRBSE5NTVGlUgkerwMLm+s6kEH8KC8scmEuhDi/+zbyaolKR9i9FIXNqtALJLFclV1EuQay3b4/bJZjed3YfuPbwr5HoYIqZ8rsI7fF6PD8Zm3CthHVQLoeKyOJK+p4OnxdKogTbIf1p16vW/MT1jlIlx7+C3edtIpIUSU/c3chEQWP3MAyApgJh315ozEwMEB9fX00NTUVuAwxU6oI1x/WDJqYmKDZ2dkgpgqzEX3ENeqzVqtRu90Oyp0kLsN3Udpe7cTLCgYp3W4Pi+7441jSuRWvDPUUd2DiW7dxy+Yz2JHhDPw7v5dtwkktVMo8snLb2SxYIGy9J9DthsCGy8Imyw0LEmKp8F++YjkaO/4KA2467urD8ZKUw3auYP2SLkbkGY9xGRgYCFaJL8pKhXzyR9Lw1el9HkzN3bL8ETxRI82osoWJORVT2cGXJklC3sK/jBQxqI1DN8+BzWIvZ93isy1OVIqpPMqggqogirBUJb35cLG5Zvu50nV1RGEXatz8uTq0qAcih9W3Ld8oo1x0EPvDzYTRNXezIT9h4gqChotQedPL/7nS4iu8c2tVX19f8C4FCmKsli1bFggZrGRexAKJKO/09HTwoOPZ2VkaGhqiSqUSWNDC/ttqtQLrHl62a81HQPn85pNWmTq7MsNd57brMwwe45JW4JZFjEX1B3zglrRdz6KuwtJwbcvb/SdjntA+8DZVXis2YZUHKqgWGDbXXZz/ShHlI6qAnHIOytrphDVUuDkxowwixrakgoyRcgkq1+ic3+yu/LhivvAfWHq4a1HmpVKpBEHdeHFhVkRng4au2WxSf39/4LKEG0/CTfWYgYn8wlXo04Crpal7JBVSHFwDRVlTu4nN+pwkDf6e5P82S7oUM90ibD24oqxRNlRQFUxZY6qkmAI+ogqEWax8Ry1xAto50v0Y1SBxi5xre6VSoWazGSxXACsVn1UHAVOr1eY9+FjmAWlISxWOZYulQtmkS5KviYT/IDYK+cHx+H8xcxHlarc/fMisbdZL1iC/iKGamZmhFStW0NzcHNXrdeuz/lCmRqNBU1NTNDMzE9QX9uduy7R5j/t/uX/Z7utug+sP9wfuH596knEwuBaSdOZlFWFh7RWP6UySZpIy4x6S1nPkJw5FWKr4YNdlkSIqTgDGcmYfOHCAtm7dSitWrKDh4WG67bbb6OTJkx37NBoNGh0dpSuuuIKWL19Od9xxB507d65jnzNnztCePXto6dKlNDw8TPv27evZ5zKVkTgdi+3ms332vUnR2Wdhno9D2Joirjy7AhRt/+MrZctjcVcfH4nLl7RicetLVB5c7kQurvAZjYxLePGHDcMVU2QALGb84dVqtYL1seQokzeasjPl9V0Wytpxdwt+jpLM7uPXQxaCuRfIooxJhIRsj3ib0m2LFPJH1Nlu2/Inr5Ui8x7LQnX06FEaHR2lrVu30uzsLD388MO0a9cuOnHiRLAi89e+9jX6l3/5F3r66adp5cqVtHfvXrr99tvpBz/4ARF92DHt2bOHRkZG6JVXXqGzZ8/Sl770JapWq/Stb30r+xKWlDJZqrgFKsoNZrNg+R4jjKjRjM9xpPsxK9M5f/wIXGawAOEdnbrNUsU/w1XFLVRoGLC2kgxe5xYsbHc1Gogx4nFesuw8Zml2djaw/MSd0ZIUY0wQu/Wzn/2MWq0WDQ4OEhEFliqUGwHsWOUd5YTVAxMHZH3hOHHylGX5OGW4x4sG1zAEO6xTvnAriUtQ+6bTi+CeL+paQn3nYdiI650I2w/bYJGSz3TslpACsQTV888/3/H9qaeeouHhYTp+/Djt2LGDxsfH6W//9m/pO9/5Dv3mb/4mERE9+eST9Eu/9Ev06quv0mc+8xn6t3/7Nzpx4gR9//vfp7Vr19Kv/Mqv0J/8yZ/QQw89RN/4xjeoVqtlVzrFW0j4ig+5zccNaCOuVSGuILK59KJErO0Y+I1bf7BaOQSLDEiXK8pLMSN/c1kBbSNy/j+biRuuP+QNz/STrgOIFsRScaGSdyeExhuxXxBMrVYrEJs2q5u0tEk3Kf/cqx3pQoGfD35/xF3MV1pMFut5TTog7EXC7l9pPeN0W0wRxXT5ScbHx4mIaPXq1UREdPz4cZqZmaGdO3cG+1x33XV09dVX07Fjx4iI6NixY7RlyxZau3ZtsM/u3btpYmKC3n33Xetxms0mTUxMdLwWCkU0EHFH6rZGLMyFlkVjJ49lSy9sm42wNUdc+9jS5RakZrNJzWYzmP6P/eX6OtytVqvVqFarBc+iq9VqHTFYOAZiROAGm5mZmReEjRgUWMVkneC88ef22eqrv7+fBgcHaXBwkJYuXRpYhopy/yGvFy9epPHxcfrggw/o/fffp4mJCbp06RJNTU3R9PR0ILZsa3ahg+ZWEOla9clHEQJysQgBPhsWrzjXFL8Pcc9xF/ZCrUdXeydjG31fcSjKrccHQbaX3FeCcsGSZgtM7zaJBVW73ab777+fbrzxRtq8eTMREY2NjVGtVqNVq1Z17Lt27VoaGxsL9uFiCtuxzcaBAwdo5cqVwetjH/tY0myXkrwuhCQXme9/XPv4Hk/GWrlu6LR147rpwkSVC97I80Bobt0BPHaExy1FxZOE5UHGDIVZ2oioQ0zJuuXPxYMQQZrdiKVqNBrUaDSo2WwGQlLWM+BWDhm7lvaxJkpybJZaV4fJsXWIMvavDJ1lNylC9JcNW7yoHDwCbpnqZrxX4ll+o6Oj9M4779DLL7+cZX6s7N+/nx544IHg+8TExIIUVd3uCKQVynWTRbkG05TFNlPQ5fYKc4eFpYn8ReVTug0xm8SYD2OA5ubmOixPxsxfdDJOB8/LY/sPrFRhC2HyhgUuNcyi4+VFg1StVoPn/E1PTwdCJm+3GdJGXNTExESwiOrMzExgcYLlzpUGyiSXpbDN/Ok2vtdrL+AST9iG79wtThTvuXZhFqmo67MMlv+szq9r9nTc/Lj2L1PguQ0uoHBPy4FyWUgkqPbu3UsHDx6kl156ia666qrg95GREWq1WnThwoUOK9W5c+doZGQk2OeHP/xhR3qYBYh9JOiwFjplEFUcn/yEiSpQhjLFEVX8NymquGuO6MPgSKyHxOEdTFbl5+khjssFbyzxHWWBOCSiYPV0zPgrslHlYqnValGlUgnWp+Lrfbn+i3d06ljoE+eZu0RdK6or8XE9KUBaT3G9yvXR4iBndXI0Vi49Lgt2GQlz+5Yl/7GucGMM7d27l5555hk6fPgwbdy4sWP7DTfcQNVqlV544YXgt5MnT9KZM2do+/btRES0fft2evvtt+n8+fPBPocOHaKhoSHatGlTmrIoIcRR8lE+eflblA87jU/f5Qa0HTOqjGE3nY/bDwLAmMsxSo1Gg6anp+fNQotD3PgHiAcpEOULIzrMlGs0GkHwN18ks16v08DAAC1dupQGBgYKX0oBK6hPTk7S1NQUTU1NBQ9wtrlqZcA66gQdOndjyiUrykSviQGIbwhwvNuW38DL5k62CSPXZAvbfmFW3zwtFnHvU9s9mSZvrvTitoOAT/YoMxjAZlGHeRPLQjU6Okrf+c536Nlnn6UVK1YEMU8rV66kwcFBWrlyJX3lK1+hBx54gFavXk1DQ0P0B3/wB7R9+3b6zGc+Q0REu3btok2bNtHv/u7v0mOPPUZjY2P0R3/0RzQ6OroorFDdABegr7ndNfKL839XHuKmlzVh5vOwbTZ3GX/WH19HKc4Nz4UCkV+duDomW1pw3+HhyUTzZ1gilqpWqwXlQfp5N16oV7hSW61W0ElH1YkU3HJWGRfJRcaGxaFsVukw+MSLMHFqs1olmdVrS3chkOSc22Ytu9L2zQMEVVnhZbHFg5ZRWMUSVE888QQREd10000dvz/55JP05S9/mYiI/uIv/oL6+vrojjvuoGazSbt376a//uu/DvZdsmQJHTx4kO677z7avn07LVu2jO666y569NFH05VkgZB3A5tEXLn+60rLtwy++9ncaTIdW76ALbhRuvHiuP14Rw4B0mg0iIg6nvXnu8qxa3QZVjc+rliZDsrALQncjM4X++TrYuXZcCFtHpvGZ+zx9Yt4gyqvCdt55JYMLHfB3ba8bpKU0dea6JNOmcVCtVq1LkzrApYp+biZJGWEq1aeV6LwGKssyDttn/hTWzuUNp9lt/JwXBZpOXgsC7EElU/mBwYG6PHHH6fHH3/cuc+GDRvoueeei3PoRUVeDSzvYH1GOrIzjZMn3/9FiZ+8CBNVtt9s+8NKRXQ5BmhwcDBRQx9H6PruZ1unhejyg2qxD8QMd5kV+eQC5AsPQO7r6wuWl5ALoIZZAeU5Q0wVt4JlFUsVxxIQJxCbqHyWGLj6ouAxfhBgvo+Z8YVbvvKMmymio04iqmz7Jjlu2YSIDT6AsuW5jGXQZ/mVlG6OWl2WG5f4ieoMsi6Ly2IVlb8oSxX/LQouAog+XCvNGBMEVcNtFVeEyroKc3fJ//HP2M4bI1ikbNYavgo1hMiSJUsCKxUvsw++nZ08d7Ozs0G8FwLveVpcAEblxxZzMzs7G5Sb11OexL3+y2KxqlarHRYmFzb3HncNRlk55UDPZpWSx+Ofs+5Yi+yoo44l2+KsBgO9IKpkO9YL9LSgCrsgytAgpaUsoorj42qKiqEqk8WKiyqf42E/ufYUFvlsNpu0ZMkSqtfroZ1CWNpReeENok1M8c+w6ED48U6Pr0jOlxiAyw+WhriBq0kbP2NMENg/PT0dpIVrSgqhqONISxVIY6lK2gnFtUDFtVjmAdy/UeA6gasP1imfuDXb/R5Vdu7CztotXRaRwfNhG+DKuvG9TspSPh9clim5T5noaUG1GMhTVCVJW44m8TlOunlZrHxjq6KOzZcXsP0u848FKok+FFb9/f3UbDYDN4lrDR4uzrjoQUckO6QwE7jLMsWfGs+FCdFloSFnVPKZcnm7/mzLWaA++XR7bikJa2Rd7ltsQzq8k4J4LKqzKYsFKi3cEsUfdWS7duMgRQN3T8t9sqTMYiPsesd2n3YN+5a5rBzZxpWdBSuofCq/Vxq1rEerUhTFtRj55MfHDSjT9T1+nkTVhy1AnYgC4YHgdEwvx6jdJaZsggYWFCkQ4a6zrcfC04GQsn33KT93+eG4PnFhSUeLXFThWM1ms8M6ZXu4rk8nw7/L+sQzD/v6+jpcgUXgK6q6ZanycXsvWbKEBgYGOgRVFL71K2PnZHvSy26+NPB2w+b6DGtr41h3ywIfPBYtCJMcZ8EKKiU9thvUNvqPEj1FjcijYqtcozmX5cmV73a73eFG4jc8llLA8/j6+vqC4GpbvXAxBdeaXPEbecfSDDzmCWlw1x5/TxKDwGNieL3lKThsQhWPnoH1L8naWLyj4WXi5eDns8gp2b1mqeKWTf7yKUPYtRNmQY4630WK4CLwLYur3K42G+8Lqa7KyKIWVFE3eNnoxmg1K7Hkk46NqP18rEmu/PiKKttxENjNBY8xJrCs8ID0gYGBeQtx4pgQDBAPEFTcPYXvEFRSgOGhzVxIcXdiHHBcBNbDioMy8zrh5cgCfg7kw09x7LidOEC94vzi3PHj8fe8p+TzfNny69qvqHs/7JzWajVaunRph9iRdWW7/sLuK9t9zWdp4vz5xNUsBqSlKuw6kuei7Napbp/bNMdf1IJK+ZAkI2XpNsTnpOnlBRdVcfLpO9sPcGsTxBFWJJ+ZmemwkmB/dN4QQfjOLQFwRRF1rhiMY/FnW/HOJ02jya05Mt+uDjAruMjhZUQAMs+PzFNUmWznG8dC8D0/dt5llZTpvuHw6xGu17DVyjm2+Ke4x45znnuVNNeYjzs06QCrm3RbWCVBBZWFOFaQbpDVaNXmvos6JnD56sNGnHHTyyodW+CzrdwuK5ULbp1CZ4xZalNTU0F6WMdnYGAg2F+6CdvtdsfjVpA3bi2BWOPlxnvWKx4jbgmf+azAIkUV6gRiCs/46+vrC6yAUedL7oPvUjxBwErLWNGxVchjku15MjAwQMuWLbO64Xj9cKsJr+ukwf/8v1xYZ0EZOu0s81CG8mRNUSIwi7pTQbXIiSOqbP8LM92XSYjGcf/x//gE2+L/6PghsHg8VaVSCQQAF3DcqmWzNHFLDQ8mLaqRkZaqvBdUBLZAddStjHNK4v7jHb7ssImo44HX0uK3EDutMOB25gvChiHFlBRVfJ84xI2fW6wstuuzTKig8qCsFquiLFU2y5OPZSCNxcp3P9f2KEuVaz/sE2WFkVYtdMiwODUajcBVhXWd+OM48F8sEQABxkUTBBVcfd2C1xnyV4Q7jIsYzKKEqOIrcfvOMAPSUgWxy8sCgcvfky5ymoRuWqI4lcqHq/8PDg6GiimZT15P3BooBXmYe4rDRT0/D71MHtdQWJq96u6DVbIXUEGlEFH8+A25f1k6ABBmdfJdCd23LDLuBx01j6fCCwHVNsuTTUzhlTfSZSMtjdw6UJSViudH1pGcVo98+uIaEMjH1dhcq0XHVnUTWO3iilaZhqzPrPKm2Okl8eRL0e1OElRQJaBsFqu4YijpMThxY6+6EUPlI6psLkrpbiKavzinLBcXVRhNzc3N0dTUVDCqhjUFC37C+iHjhJA2j50qCn58vPOyY7FPlIlvzyOfvP75LMi5ublgVW7uqnNZSmzwbVwsSouKMSaYYSkfh9MtS1URA5hqtUq1Wi21mCKa/2BuH2Hqurf5kw3wey+J217KazfgFmS5CC/fXsY4OhVUGVCEoCkiD0nTkG5ATtH1YrOc+Vqq0tYhX88IAgqCqVqtBrP9+DIEcgkEKWjyFlPSMmX7LC1TMhZG7p9nXlG3XNAhUD2La41b4ngMG38mHRe82G8hwoVqVukBm7UhjjDCeeoFq0XR9Ep92K4t2zXBBVbZUUGVEbYOqBt5yOLYYaNil4XGN02QVwyVzKf8D/89zFIlY6lkWq56gBUDn2F9IqLAdYLZfjwf6LhlZ90teIfF133C8gK2NaLy7Nxkuqhn/uw4+TBq2YHHORb2565ciGHuxpUTCcLwvcbD/ltE24I4v2q1SvV63et5flHIfHNLFbb7zAIMs0YuZnpN1PP7kZ9H+dxNPlPatvZfHtZx18DSBxVUOdBNi1XaY0c13GEWIJvYydti5Sqv7+9RMVVJ6pPPDkSQOlZOh6VKWkKIsl/6IIw4jQYXVrAO8WUUioTHqXHXqnRBp7nOZKPN0+YxcFz8pnE7lcHCzXGJ6SzTB3yxTt865DF9Zaq3btPtQVhcoixPYec5r7i8tKigyoluWqyKsFQBfmEnSVuS1CJl28d1DqJEFbZzF56MpYpjqcJMvunp6cDtlzbQtwi4VYqv1cQX2ISowSy8vEUWF1P8QdSI6wpbST3ONSpHyoDHAiGejM9CslmqfBr8NNarrKlWq8FK+VkLKpulisjvwcd8Nq3saMvWsSp2uHXRNZCV558/FB2kHcTI9LJCBVUBdGMEmrelSh7Hdrw8LFZp4rx8YquyOh5RZ0D13NxcIKbkStNFj7R5jFYU0tXHBSTKB1EBS0PeoopbhuB6465HKVSTxgHZXIZoyPHAa37cohcBzQusiG57XFKWoH6lqAqrQ7l6PzrmXplWr0Rbpvh+fEDr+79uooKqIHpRVPmmGyaqkqTFiWORktttv7vyx8VPWBniWqq46MB3WFHgNnPFE2RF3A7elQeb1YYvDZHFqNEH3vG2221qNpuBxQ9iVa5PlbZeubCU5xgzEJE3CLws6qHI2CmiD8uH2X15HjPKUhU2+OLuSKL5kzfKKmjLmq8i4JYpX3ct34/fy3L2M7d2pRnI2dq2uOmpoCqQxSKqQBL3XdRx0mKL+SrCUlWpVIJOd2ZmhoioI5i7iGsjaYPO8yUbQlhrIBRRxiLg9drX10etVouMMUFwuu/z5uKCtLFYKxfPEJe9bKmCqCrKJW2zVIXVHZ9tiv2TxGIpxRLXIo92kQtn21MbynTOVVAVTC+KqqhYqrTl8QmE5/gKtbDfwyxVtjWn5P4uS5Urn3yGCkQHfy5dlm6/rBoWV35k/cIyxM3yaYmqT6L5lio8RxHuSSLKZIaaDd6gywafL4eRFWmswL7AzYcYqiLaKV4m2Q74uP7wmZ+DMnSsNsrS6eeJaxCT9FqyWajwG9pSfp9lYalK818VVF2gGwHraWKPiJLl01codcMnHmapkrP0ksSR2BpObsEgomDl9Lwa2azTtblp0NihzlDGLPC9TyDkZmZmAmtVrVbriFXLw9rCYzy4CMCxsu5A8xRV3E0aFtifB7xMPseUdY0OsBdmuS10UcXPYdSAzBfbQq58W6Uyf6HYpHGc8j9xz5UKqi5TpMUqL/dZVg29r0swqVCLE5jO0+Cz/aIsVWHHw2/8uXR4z8KSwusvz0ZbNph8en1SS5tPfl37yFgKuFRhAazVarmuXYQ0cY1AUHH3Z1j54jT8ebgx+bpTPBi9GwOdONhcf1zMl1G4lDFPabDFRuG7C9/rSoYW4B3nnFv9sR3udjkQDrvHbOck6XlSQVUCirRYZW0VsokqEOV6k3lybc+SuKJKuv1c+7ssWTINPprmHa5rIdG45N1g80aTxzPA7Zcmhios765t/JwgngKuP97Y5j1jjT8DEOI4rxiPLAdGuOZsVr1egC/AiqcT8GU9yiRgypSXLOBiKk+LJh+wEF1263KrOL/XbLNtXRYrlychbHsYKqhKRjdirHyJK8ZcZYkqo6sxjCvE4lqq+O+4SbMQVbb9+CvuTduNhlkKKdQDArPhvoSwiBJWWZcBeeFT6GGpgpjq7+/PNTYIdSRnb7riepK6JLKaxIDzCKtU3qIzirTxT3LGbJnjqfIgj1XDbekTxQ8wj0NYenItMqLL5eXLpszNzXVYK7nospFVnamgKiFFxBYlyoUg3gAAKddJREFUEUdJ8hQmqkDU9iTHjZsvl6hyLezpypNNVPG648eB6ODpx8l/0cgHEfN88Flv8hERkixN7LJuZTwNd68ODAwEnW6eogrXjOzgsjpn/Lrkx40Dt+zgAciY2ddNUUV0WQi56sv2O4+n4teCy0reDfLMS5Hl5O69Iq8V20AF7Q0mxSCOEgM8WCuJokVTFqJKBZUSGymuoiw3vhapuMf13e6bL1s5fF2CHNusE1de5eeyYbNM4cXdfdge9biSvMvNRRVfxR1rRaGBzWv2HxE5O5us3X5IMy78PPJgdJ/4l7zgbpy4SNcuEXWUp1futazIamFd2/Wbp2UqKi+uY/JJIFxE86cqAPkd+2WFCqoSU0RsUdZuvDSiKiwfaa12rtF8XFEVFoQeZbHieZBuv25bBVzAJWRbhFTug7K4HpacVcdmE6zyfBFRsMBmo9EI4qqIKLDI5NUhyIVF+TIOPH9p4IH4PuWwBQ8j7g0uv6I7SQAxFfb4nih4+VD/iKXhrnVXm1qk0CqT1SwKOZmjG+0U2h8Jv1alGxztEQZRWF5BTgiyoTFUSqEktThlFR+WRWxVmKjixIlZiRtb5VqrSHb2aUbvSbFZpqL256IrzBqTZUfiEqzIL59Ojcf/cKGX9XIKMlCfj4i5YMgbec6kZYHnz3Z/ZHWvRiHde2njnnAdwuUKFyZ3/WRxnLITx0oVJVaKslzK9OUgwAW/VvlMW2mxgqUa/8njcUUqqHqIPGOrsk7bJ3bKdry025Pmz1dUybgYn0VAeRq8DLjBZeM+ODjY4ZKCEMB7FmLFRyBFWaYAtslnwKXtsHw7BLmfPDa3VMFSgWUCshZUUqjwmK5ms5n58/4Qr8Zn6yEPtnPGXSc24Q6RH2ZtzgIe18Itm2kGDvzexP3DrV/GXJ4ByuMXiRaOpYqnGdf1JwdRtnSLxDeezxZ+wIWVMSawVLVarY7HRIGsBqwqqJTEuGKp+PaiRrk8H7btPhYz6e6Trr60lqow0BniOWp4fAoRBVaVZrMZdDxZdsq2vOAd+YpTBtuIthvWAH5d8Cn1aFz5WjZ5XKdcaPJ6jGMdCdsvTp5l/BvvPG0dexHniws4l0suCVxIcIHALRfcHYi8dIs87+UwUeWaYCOvq26IKTlQDcPm7ufnnQ9m+bXPZwRnhQqqHiTP2KosYpXiiKq0sVOuWCffdFyi0CWq5AKfLkuVDb6vHKFXKhVavnw51et1+shHPkK1Wi34HwTA5OQkTU9PU7PZpEaj0ZH/OA2ybV+biIorNKTbz9ZZheUzK5emjLFC/crHVKCOMcMNZUgLRsrowHldcPcfrq+k5cZ1GGah4+eDCzyeV+C6lqNcLnHzDIuRr2UqSdyOy8LC1y0i+nCwwi1YtvwWQdaiiqcXZamyiWu+rWiq1WomsVrcUos64FYrXINZooJKSQQXIlEiKm9Lla+oipueTVT5ph9HmOKG7+/vp3q9Tv39/UEHj+2zs7NUq9WCacFJ6eZIvBvH5pZFPuuHz/wj8ncvxIF3UjjHvgMMX7gwJ5o/IsfxufXQZY3g17uPRdZXzPPOnS++yEUVt065Ovc0cHcgYqu4W0ze790gb1Hl2ifs/0XBLUpxBbxtMCy3ycFeXmXraUGV1cXXDRWeJXlYrOIKk7Tuv16xVMlgZpulKqre+KgIj/uo1Wq0evVqWrZs2bzYHjl6N8bQ9PS016Kgru3owGx5TWOdlJYRX/IMuOfigMfO8Acoo5PNYzkFdN61Wi0Qc5VKpWPmYRzCLClybTNeHh+XLOpITi6Q+0IIoQzcwsPdmzwNY0wwIEBMIC8/RC1fiDWPWWXIH6wV8l7j+S2aPEWVbVuZ+j5YptLmyeb+4+ebiILZrbxNyIKeFlRKvviIqjCh021LFSfJcX0sVbYyhfn0baDzQOyUbTVvPsU9i06Gd6CucqRJN05jXcTsRW61gbsNbkCblSJruMiAyIGgiBM8LK9r2/8g/PGOz7ycYWniNwTzw3XCt0FE8ckSHMQqyceFICgYL5lnHmfGH3ycl/VQLmlhs3AULazyEFW9QFox5Wr7+TZurc3DUqWCirKbGVUW4ribfNLKstxRQieL7WlccnEtVWGz/3zysWTJElq2bBktX748EFMu0BgkGVmGXeMuV0cS91NcQVXkUhDS/Tc7O0utVouIqMP1l/XMPwCRgYc1o95lbJeLKDHFLZkItseEBmn5IZr/qBIIPN9AXX48W/7lPcD3t10ryGer1aIlS5YEq13X6/WgrvKwWCEP/LN0U/IyFEERQk7en92yWBV1TC7wETfJJ6cAPtiM2z6poFIiyduylDU2H3qaMoRZqsJiTaKOiQ6nWq0mNndn1fBKq1qaQGmiaItCkUJKHpcHJnMRwa0jeVmpuGCDkOLWI4nr3NrElNyfu9S4QEH5+DUMixRfBNHHpexT5jB4zAw+49i4rxBPmJfQ5Xnh9RpmlS6CxWCpKjpPuAfxyBrp/rbdR3FQQRWDMF90GcmyY0hq+Yn6X5Q1zWd7VPpheUlrqSKaL6qkBcvmSuLrBsllElzMzMzQ5ORkYFUBLner7bPrN954cysc73hdIolbOGxxNHmR1LKMJRS4ywnxTfxBwXnd10hbzmaqVC4vAppUSLmEKlyblUqFms2mdR9YjWxWJOQvLlH3p7T0og648EMs2MDAgPV5kmmIuoa4tSoLK27Z6bXBc1xwncFK22q1gvMqr/ckqKDKgDJfhFnEEvG0kgifvOsnjmgrwlKFY7n+x6elc3dMVBl4MK8sU1TZfcuGz+hYfTsuuUSCqyzdskxJ0Gnz4Gqiy8//ytMaImOpkI+0jXlSsZU3YTEtQA5AICxxLtAJ5n1uXNjajiIsVtJyYtuWFbZ2bSHCrykZG5gWFVQZ4TPSWQiksVTx71H7xz1unEagCEsV/mNzCdqECh8hyUa70WhQq9WiqakpajabwSwxGUxty39Ygx8W9xJl2eP/50HGWQgDkFc6vFzouFutVlDX6LjzClxF2vzxGDyvELMy37b95O98O3/PgiIs3jIIHXFgXAAPDAx07BMH6daLIzJt95ZMo0h3YN4ULazSHi/KKs/hsYR8tq28HjSGSgklSrj4ppFUGKUhrajKKm9pRJXP8WU5ms0mTU1N0dTUVLAQoatx59+TNO5c7PFGxra+EbaVWUy50uZCplKpUKvVona7TbVajdrt9rx1wEBW1zUXbJhNh1guni+XaOKuOVv5+HuWZHl/h7kTednkMhMI6s+KuK4e171XhMXKdvw8ybM9zwuf+ueWTl02oQdZaGZUX3HjslQBl0UobHsWlipfi5Tr97Siin+fmZkJOgueHixTly5dounp6XnTzPGSK2FD5MCVJUdu0j3H4XmVozY+jZ2I5gUvh6Vb1Mg9CShDu93uEFbGfBgQbYvzyQLUMX/uHNHlZR1s9RlVj3mKqTyx1Su/1vjsP1gT06yozc+5vH7jwvNgE2dxBBuvg6h2Lu059hUeeZLF/RTn/nCRlTtcBVWBFOEH9yVKuPimUYRFyJWuK+207sU4+Ygrqog6p5MbYwILjzwn09PTNDU1RZcuXQoeNYO08H+MtAYHB4Pf5ubmaGpqyro+ELcihTU+fB0juMXkIo222WBx3Is2ihIC8rygjHiAMXcrcddclqKKj5L5+eQiGOfBt0y9JqQ4tjaJi8pWqxVM4iBKtro9d1PD5RtXTMljysFilAswrB+Q73K7/H8W5xvl96nLbngefNMoAyqoukyvW66y8nsXETsV5/h5WarwOzqL2dlZmp6eJiKin/3sZ1Sr1YL9Jicng/gRG7VajQYHB4NFQQHcRjMzM4HFhc8eC2t8eDmwlAAEk2vk7eog8hTSWSA7KZwPostxFXyFZe72zPq+RZAsz5d8XAqPlytLcH8RSIsprmm+BhwstVHp4JE3fHKHa3AZ9/zyySacOOfLlYYtrbguRpelGkiLoK+1rFtkKSazQgVVCcjCWpRVHpJaqpL+1zf9JJawMlqqcDy4dWZnZ2liYoJarVYQeOtyj3IqlQrV63VavXp1sI4VjgcXYl9fH01OTgadRpKGAyIDecWxXfUQt5FL0hlkBU8Tljb83mw2g1Xp+WKreYgqPtOov79/Xn3z9ap8F91Mguv68LFcRJ2fNO0KEc2LLeNWQ1z/YVYWDAqwUnuj0ZhXl3JNLJlvl2VKCuA820EISFwjSe4317IYgFsG+Ur3cp8yUBbLFFBBpRRCty1RUSSxVPnmV3bA/B2jZoggWEPC0q7X6zQ4OEiDg4M0MDBAfX19HYKKiIJVgPFb0oaHu/KihGm3yCr2hVvm4BKSq4rjcx6WKp4uZhry4+BaCXNzJyWsDsO2uRYk5duJsnPrQFQaY6yPu+HHJOp8GPPs7Cw1m80OVx/R/Nl6XBjxF4eLKZslJ8u2iuczznl2WaS4ZTlMhPLj5TlolpbiqGN0u70JQwVVCXFdMEWMCtKMRJKKD9/90lqqQFxLVpz8yMYvTFShc8Roub+/n6rVarCAoQRpDQ0N0cjISLC/BI/r4EHlSRtiPlq1PUrE9l/ZkLv2881DXsjOBMfs6+ujRqMRuPn4Q5QBFztZAcsLJhi02+1gAVJcL3jJPCepr6hZgrbfXXXGy2A7RhbiE9cSn5zRbDYDoVmv14NZmtxVDbf63NxcsL+rvBBsPN9y0oec9emyXGUFFzZJ2iiURT6MmgsrlyWOWwXxnyT58M2rb7p5W6yTHkcFlVII0t9fVktV2HGJ3GLRJ18uqwZ/nhTSkserVCo0MDAQWKfgjrIdE418FvUk8+qqB1ecVRqKiBOScSPogPCOzpuvTZVl/drgnTRf+BXb+IKkSdw+ROFiypWenPWJ/EWVhf8nab1Jkc6FPrdUSSsTxJbvsh7yfpZxa64lNPJuk5LESvFrmX/m++Azyiutoigv2igfi3UairKE8zrJEhVUPUQ3LFdJRiRpRzF5WaryIkxU2dwKXFS12+1gZhmm6iOWCqATveKKK2jt2rXWUTEH28MetBynceJB9ETzO9EsxJT8bzeCrnmHiUe1IOaGd65EFAhaWJGyhlurkD4PppZLaBD5n1MfMeVb/1HuPn5P8M7a12IddgycD5wr/sgg6XqLY8mTogHPQOSxUlH3YLfgeefPqYwjHuTyLkSXJ03w88cFV9o88/vL5mKV5UsLr5ewY6iFSsmFLEYk0h3GSROjlCVZicGw/Mm4GD5a4u4cNCwDAwNUrVapXq+HiiRO1o09r5cyzzDzaQDDzq2cUcbFJDoofs6KEO2VSoX6+/vJGNPxjLuo+CVfpNjI6vxKqxSvL5/7Oyof8lzhf9y6l0WbhfPPXWSgG9ZyovDYNdQdv1ZlHdn+I62J/FiAz0bl/5MCNi68XvNw50m42MwSFVQLgChxksdx4oww09xkYcfzEWVJf0/TWcZxAxJ1LuTIGxY8qHd4eJhWrVrlLaZQBh4QnKSRcjVwrnrDtrBjyW1ZduJxXCJRogr7zczMBBYqvowEOhEucPIA55E/zy5LfK1SrvMWBeoN9QN3pUvw884/6hi4Z2Al5O/9/f0dx0kbu8UHEkV0+D5IVzwfmIVZplzuP9v55zMf5XceW8atqWEWJn482W7gOuFtly3cICm8jmDttc14VAuV0kERI+e0goPjIz6KsgZEHdOVD/m7j6ji+8jGpVKpBNPBa7Ua1et17zzjPS9LUhzhUsRxskzb5prF/nLEzzvsvK9P7gpJY51yWSp8xVRcASxjjiBK5Taej7iWCqQLK17aAZELLliKfkCzrS5cgxdXvclz5xJbPH1bjCGuP3meeN3Iuo8SRtyyyK2/WbUBXEzZLHhZHUcF1QIlqsPI4xhRwsEnvTSxUVGWJ5nPsP3DXBNJRJU8Nu+weQMC9w7WmFq2bBkNDg5ay2s7PkamrVar43E2RWJzN8g8xDG1F5l/fk0gj5VKpWNdKh5Lhe3oZPLoxF3EFVa2GV7yd3lMXwHlyievQ460fKSBx73xxyPxmXlp4eJDzvq0WQ15x53FsSXcYmQTyfL4sMrgne/jc1zXpAKeD3y3WbNs36U1i383Jnr5mKh82+oC7zMzM8GD5lVQKT2HTVTIbXmNLJOQ1GIWZani23kMiOwEsLZUtVr1civxRgNBy66gyyLwbah9/5M1UR0dnyUG4csftYOJA1Is5nH92kbRWQllH8tUVPxN2O9Rx7UJnjj1x60o0lIlrYhp4HXBB0I8dkgOwmwxXlnkAceT4p4Pylxtk0tw+eKKr+LngOcvzF0IIJz4TMI4kxfCyoh3HhPJ28isB5w9LaiiRm/KfHytSmnSjkrT1xIFfC1OcbdHWaqiiLKIyYYuTFTxvMLFJ/MXlg+sTzQ9PU3NZpMuXrxoXQ3aVQYbSRuzdrsdPJ9QNsAyPz4dtHQ7hBG3g3C5H6SY4OepVqt1rAmF0TTv0IgokVvIVu52ux1YHBuNxrwHXic5hq0ztXVA8ncbcetcziLzuc7C9kHHiw4ZVgfekeOV1uJRqVSC9PkacFI48HduheaDJ19cA02UCfc/RJxc/JWLCJ6fLHCVRcYa8t+lRRf7cesiYrLCxCEvi0v8yxfuVzwjlc+WlWnLzz70tKAKoyyWDsWO7fzkKfbSkMW1FCaqbOXm29AQ2xoX3lDAjN1sNjtcfkXBLWS2kZ+toYrbSXNhk6RsYXmypSndSWiAeQfNrRDcQhD3upGdBD7Pzs4GyzcgSL6oR9DI85TF9eRrHeTY6tI2KJGuKW7tCLNWRYUR8O/ynnSlw601PB88n75EDf6WLFkSCEqsaQdsIiPvdoGfBzmABHCVyjrjQstmnXdZnuQ2/M7LzAd8rVYrsj2Iy4IVVET5uhDK0tmnxVVHaconTdNh+/kcJ8qClHS7y5Jky19YXrOyVKHDbDQa1NfXR/V6nYz58Plj6BDQwcL6w99hoeLvroYzy3sDacGMjhcfEfPH4PD3qDRlRy5HnLZ9fcvm25ja3BZwU+DdFq8Tx0KF68H2nXcGvKOU7mHf47ksUNKCUaQY54RZPWxwt590GeEFIcwXSLWl7RJztvxJUSstk1xY87RsdSvjDV11IAdV/D6AkLLd90nv96T/swko5BHbsX4Yzg0EqjEmqEN+HnlaXCjZBmq28nMLFY/xdJUxiSVvQQsqpftEiaYkQiVPkoqquOnbLFQQJNzSxBseNJZ4JhkXVq1Wq+M97mJ+aeEdhWyseMNky49LCMlOX4oK26g0rajKijjXic3y6PouBR0C5eMslhlmgZKirUy4OmcAYcWtQLxDJprfpnB3Ibcocfi1K9O2/YdbKaPcVXjnrid+TUbdv1K0cRFpO26eRgYfZOycrXwoD8QxrFQuqxPHNUiS17ePmLKlF4UKqoSkVe5lJ0vLVRpRxbfLPMV1GZbFUiWBAIIYunDhAtVqNWo0GlStVjvcF2hE+KhOjmxtIzdXHYVhqxfbdzRQEHmNRoMajca8EaEtT7bRpWtblCWq250FJ474ttVL2LVCdNk6gseuNJtN7+Br33risS5ZzpaLS1RdyLxJt5+t044SWK588/OKusc2PkvNlWcpvJBetVrtsN7GFT9hglyK5DCRFiUwoo7ru7+0KNry1W63rQOGOAMnOeiC5VyGJIS1Q3FQQaXEIqmVhl+kYQ2Wax/fDicrwkRVHscxxgSCanJyklqtVjBVP6yBzhObkLWJKh6Ezi1s3FIWJoLiNuK9Qpr8R/1XWpGazWbH97AOPcz6xb/Lx62UlTBhxTtsYBNZcdYTQ7wSn5WG/9kWpJTYtklLUxLLskvM8XuvW25cmRci+zpX0hWIek26hAKOibLzpx2E7WvLrw8qqAomzaijLNjKECevWYmTpCIs7PcsRFRU+vKdqNPSBOsTGsc0jYnMk0vY8oYcgc+wMvGG2NbY8PVtuNvSx6qk5ENYPfvcFzIuiT+A2PZf129JBVmc/W3xOq7p/HwWGUfOjAvLFxdPcBfahJsrnz7YLPJh8Ps0rnWLp2H7TBQ/ri0K2f7xY/DZfviOOo7bz3CrHx/4yZhMfE6LCiolE+KKj6j9u2WxsomqPNK3iSpYHdC4o0HI2jrgShMjOEzNHx8f71gaQDbWWTdGC50y1JHtvovjApTfXdYu6UKTU+CjXGI2l5Drf7Yy8WucixN5r7ng9wdPix9Lxl+FPc3AxwVo2+a7jlUaMeVynfscN2n7ZLN+y3ODxwcRzRdZEpfbl8d08sGiLWbNVm9qoVpAJG3oukXWoirJ8W34WKbk97CGO67Iko1GmKiCpYc31H19fYkfdYEGdnJysqMhsY1G0SDDXQcXpE1I2cqmLGzCOpywewnfwwSVzaoFK1mYCAvrzG0uvyhBx/8b9h0uqUqlEky/T2JF4elLl1yYi07es1w08Jl+vm4+X4uUK+9xCbPoof5srj/X+XbNmuTWc1iobA85J1JBpfycrIVJGuK6A30tTXEtVny/KIFk++7qGMLy6INNTAE+qrItipn0eHNzc3Tx4sVAVPHGF/vgXUXTwier85nknvCxavF3bt2S8UnSLRmWP+wfR/Tw+0G6E3nazWazw0IUt33AcWz3Ydi+OKZ0ueM3XgdhYiHMIhX3WvEtu82yJfOD88Xr1XdhX+7i48IK7R9fWkIFldJTlEHwuYSejztBbkvaaEZtRweBQPSw4EnOzMwMTU9PBw0HTxMNyeTkJM3MzFinDKt4UorC1WnZLL++Vi5uzQXYT3bciMfB71Lg2e45m/DgLnnEGrZaLSL6cCV9H4syF0WwHCP2kK8vh2Pinf+PW6eQJtoAiAleNlse4gzcwtqHsMGrjahZmoDHUIXli5cF9SYFFbdOSWugK904qKBaIPie+G4Jmyjzblb7yf3jWK7yrkPeMLusVJXK5UdbYHXuqHy1Wi366U9/2rH6L29so8zaipKWONeVz742F6Dc7rJoyZgtGQOFfW3LQchBCX6zWXH4oq6zs7M0MDAQDIikoHINzLhwwmQOPPUA79iPz5jl0/5tacvj2sSDHHzZkL9HiS+fmDeOTfTK+kY7iTgq/sgdLihtL7mQZ9w4MxVUikLxg97DfneNnuPGi0WBNI0xQQODJQhqtdq8/dG4YYkFzLDjI7U4jYeilAV+/4ZZtYjs9ySsSFxgEV2e8MH/IwPQpVBxvSPGh4iCpxlUq1WanJwMHqvCsQ0KpeUEj4vigyq+n8yfbWajxMfi5ourPfGNTbPhslDJepZi2dbOyXriAkrWn29546CCapGRpnPNw7qVZ2efR9pZ1YGrkbYdK0y88caCpxMW9Gv7rihlIQtrapzrPcqa7cqX3P/8+fPz3JJRx3eJRZ/fsqAMgy0f70PcmDfbtrjpufISRk8LKsyyUPKn2/Xc7ePngY+oIooX1O/6jwoqpVco60Ao6n7l68dlfWzFj6zDNhaVoJqamtKLVVEURVGUzFlUgoqoHCZLRVEURVEWN+V9QJOiKIqiKEqPoIJKURRFURQlJSqoFEVRFEVRUqKCSlEURVEUJSUqqBRFURRFUVKigkpRFEVRFCUlKqgURVEURVFSooJKURRFURQlJSqoFEVRFEVRUqKCSlEURVEUJSUqqBRFURRFUVKigkpRFEVRFCUlKqgURVEURVFSooJKURRFURQlJSqoFEVRFEVRUqKCSlEURVEUJSUqqBRFURRFUVKigkpRFEVRFCUlKqgURVEURVFSooJKURRFURQlJSqoFEVRFEVRUqKCSlEURVEUJSUqqBRFURRFUVKigkpRFEVRFCUlsQTVgQMHaOvWrbRixQoaHh6m2267jU6ePNmxz0033USVSqXjde+993bsc+bMGdqzZw8tXbqUhoeHad++fTQ7O5u+NIqiKIqiKF2gP87OR48epdHRUdq6dSvNzs7Sww8/TLt27aITJ07QsmXLgv3uvvtuevTRR4PvS5cuDT7Pzc3Rnj17aGRkhF555RU6e/YsfelLX6JqtUrf+ta3MiiSoiiKoihKwZgUnD9/3hCROXr0aPDbZz/7WfPVr37V+Z/nnnvO9PX1mbGxseC3J554wgwNDZlms+l13PHxcUNE+tKXvvSlL33pS1+5vsbHx720SaoYqvHxcSIiWr16dcfv3/72t2nNmjW0efNm2r9/P01NTQXbjh07Rlu2bKG1a9cGv+3evZsmJibo3XffTZMdRVEURVGUrhDL5cdpt9t0//3304033kibN28Ofv/iF79IGzZsoPXr19Nbb71FDz30EJ08eZK+973vERHR2NhYh5giouD72NiY9VjNZpOazWbwfWJiImm2FUVRFEVRMiexoBodHaV33nmHXn755Y7f77nnnuDzli1baN26dXTzzTfTe++9R9dee22iYx04cIC++c1vJs2qoiiKoihKriRy+e3du5cOHjxIL774Il111VWh+27bto2IiE6dOkVERCMjI3Tu3LmOffB9ZGTEmsb+/ftpfHw8eP3kJz9Jkm1FURRFUZRciCWojDG0d+9eeuaZZ+jw4cO0cePGyP+8+eabRES0bt06IiLavn07vf3223T+/Plgn0OHDtHQ0BBt2rTJmka9XqehoaGOl6IoiqIoSmnwCl3/Offdd59ZuXKlOXLkiDl79mzwmpqaMsYYc+rUKfPoo4+a119/3Zw+fdo8++yz5pprrjE7duwI0pidnTWbN282u3btMm+++aZ5/vnnzZVXXmn279/vnQ+d5acvfelLX/rSl76KePnO8oslqFwHe/LJJ40xxpw5c8bs2LHDrF692tTrdfPxj3/c7Nu3b15mfvzjH5tbb73VDA4OmjVr1pgHH3zQzMzMeOdDBZW+9KUvfelLX/oq4uUrqCo/F0o9xcTEBK1cubLb2VAURVEUZYEzPj7uFWqkz/JTFEVRFEVJiQoqRVEURVGUlKigUhRFURRFSYkKKkVRFEVRlJT0pKDqwTh6RVEURVF6EF/N0ZOC6uLFi93OgqIoiqIoiwBfzdGTyya02206efIkbdq0iX7yk5/oyuklZWJigj72sY/pOSo5ep7Kj56j8qPnqDeIc56MMXTx4kVav3499fVF258SPxy5m/T19dFHP/pRIiJ9FE0PoOeoN9DzVH70HJUfPUe9ge95irPmZU+6/BRFURRFUcqECipFURRFUZSU9Kygqtfr9Mgjj1C9Xu92VhQHeo56Az1P5UfPUfnRc9Qb5HmeejIoXVEURVEUpUz0rIVKURRFURSlLKigUhRFURRFSYkKKkVRFEVRlJSooFIURVEURUlJzwqqxx9/nH7hF36BBgYGaNu2bfTDH/6w21latHzjG9+gSqXS8bruuuuC7Y1Gg0ZHR+mKK66g5cuX0x133EHnzp3rYo4XPi+99BL91m/9Fq1fv54qlQr90z/9U8d2Ywx9/etfp3Xr1tHg4CDt3LmTfvSjH3Xs88EHH9Cdd95JQ0NDtGrVKvrKV75Cly5dKrAUC5uoc/TlL3953n11yy23dOyj5yhfDhw4QFu3bqUVK1bQ8PAw3XbbbXTy5MmOfXzatzNnztCePXto6dKlNDw8TPv27aPZ2dkii7Jg8TlHN91007x76d577+3YJ4tz1JOC6h/+4R/ogQceoEceeYT+4z/+g66//nravXs3nT9/vttZW7T88i//Mp09ezZ4vfzyy8G2r33ta/TP//zP9PTTT9PRo0fp//7v/+j222/vYm4XPpOTk3T99dfT448/bt3+2GOP0V/+5V/S3/zN39Brr71Gy5Yto927d1Oj0Qj2ufPOO+ndd9+lQ4cO0cGDB+mll16ie+65p6giLHiizhER0S233NJxX333u9/t2K7nKF+OHj1Ko6Oj9Oqrr9KhQ4doZmaGdu3aRZOTk8E+Ue3b3Nwc7dmzh1qtFr3yyiv0d3/3d/TUU0/R17/+9W4UacHhc46IiO6+++6Oe+mxxx4LtmV2jkwP8ulPf9qMjo4G3+fm5sz69evNgQMHupirxcsjjzxirr/+euu2CxcumGq1ap5++ungt//8z/80RGSOHTtWUA4XN0RknnnmmeB7u902IyMj5s/+7M+C3y5cuGDq9br57ne/a4wx5sSJE4aIzL//+78H+/zrv/6rqVQq5n//938Ly/tiQZ4jY4y56667zOc+9znnf/QcFc/58+cNEZmjR48aY/zat+eee8709fWZsbGxYJ8nnnjCDA0NmWazWWwBFgHyHBljzGc/+1nz1a9+1fmfrM5Rz1moWq0WHT9+nHbu3Bn81tfXRzt37qRjx451MWeLmx/96Ee0fv16uuaaa+jOO++kM2fOEBHR8ePHaWZmpuN8XXfddXT11Vfr+eoSp0+fprGxsY5zsnLlStq2bVtwTo4dO0arVq2iX//1Xw/22blzJ/X19dFrr71WeJ4XK0eOHKHh4WH65Cc/Sffddx+9//77wTY9R8UzPj5ORESrV68mIr/27dixY7RlyxZau3ZtsM/u3btpYmKC3n333QJzvziQ5wh8+9vfpjVr1tDmzZtp//79NDU1FWzL6hz13MORf/rTn9Lc3FxHwYmI1q5dS//1X//VpVwtbrZt20ZPPfUUffKTn6SzZ8/SN7/5TfqN3/gNeuedd2hsbIxqtRqtWrWq4z9r166lsbGx7mR4kYN6t91D2DY2NkbDw8Md2/v7+2n16tV63grilltuodtvv502btxI7733Hj388MN066230rFjx2jJkiV6jgqm3W7T/fffTzfeeCNt3ryZiMirfRsbG7Pea9imZIftHBERffGLX6QNGzbQ+vXr6a233qKHHnqITp48Sd/73veIKLtz1HOCSikft956a/D5U5/6FG3bto02bNhA//iP/0iDg4NdzJmi9C6/8zu/E3zesmULfepTn6Jrr72Wjhw5QjfffHMXc7Y4GR0dpXfeeacjPlQpF65zxOMKt2zZQuvWraObb76Z3nvvPbr22mszO37PufzWrFlDS5YsmTeL4ty5czQyMtKlXCmcVatW0S/+4i/SqVOnaGRkhFqtFl24cKFjHz1f3QP1HnYPjYyMzJvkMTs7Sx988IGety5xzTXX0Jo1a+jUqVNEpOeoSPbu3UsHDx6kF198ka666qrgd5/2bWRkxHqvYZuSDa5zZGPbtm1ERB33UhbnqOcEVa1WoxtuuIFeeOGF4Ld2u00vvPACbd++vYs5U8ClS5fovffeo3Xr1tENN9xA1Wq143ydPHmSzpw5o+erS2zcuJFGRkY6zsnExAS99tprwTnZvn07XbhwgY4fPx7sc/jwYWq320FjpBTL//zP/9D7779P69atIyI9R0VgjKG9e/fSM888Q4cPH6aNGzd2bPdp37Zv305vv/12h/g9dOgQDQ0N0aZNm4opyAIm6hzZePPNN4mIOu6lTM5RgiD6rvP3f//3pl6vm6eeesqcOHHC3HPPPWbVqlUdEfpKcTz44IPmyJEj5vTp0+YHP/iB2blzp1mzZo05f/68McaYe++911x99dXm8OHD5vXXXzfbt28327dv73KuFzYXL140b7zxhnnjjTcMEZk///M/N2+88Yb57//+b2OMMX/6p39qVq1aZZ599lnz1ltvmc997nNm48aNZnp6OkjjlltuMb/6q79qXnvtNfPyyy+bT3ziE+YLX/hCt4q04Ag7RxcvXjR/+Id/aI4dO2ZOnz5tvv/975tf+7VfM5/4xCdMo9EI0tBzlC/33XefWblypTly5Ig5e/Zs8Jqamgr2iWrfZmdnzebNm82uXbvMm2++aZ5//nlz5ZVXmv3793ejSAuOqHN06tQp8+ijj5rXX3/dnD592jz77LPmmmuuMTt27AjSyOoc9aSgMsaYv/qrvzJXX321qdVq5tOf/rR59dVXu52lRcvnP/95s27dOlOr1cxHP/pR8/nPf96cOnUq2D49PW1+//d/33zkIx8xS5cuNb/9279tzp4928UcL3xefPFFQ0TzXnfddZcx5sOlE/74j//YrF271tTrdXPzzTebkydPdqTx/vvvmy984Qtm+fLlZmhoyPze7/2euXjxYhdKszAJO0dTU1Nm165d5sorrzTVatVs2LDB3H333fMGjXqO8sV2fojIPPnkk8E+Pu3bj3/8Y3PrrbeawcFBs2bNGvPggw+amZmZgkuzMIk6R2fOnDE7duwwq1evNvV63Xz84x83+/btM+Pj4x3pZHGOKj/PkKIoiqIoipKQnouhUhRFURRFKRsqqBRFURRFUVKigkpRFEVRFCUlKqgURVEURVFSooJKURRFURQlJSqoFEVRFEVRUqKCSlEURVEUJSUqqBRFURRFUVKigkpRFEVRFCUlKqgURVEURVFSooJKURRFURQlJSqoFEVRFEVRUvL/Y3shmxlbZkYAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "NameError",
     "evalue": "name 'val_dataset' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[62], line 7\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28mprint\u001b[39m(np\u001b[38;5;241m.\u001b[39munique(image[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmask\u001b[39m\u001b[38;5;124m'\u001b[39m]))\n\u001b[1;32m      5\u001b[0m visualize_mri_sample(image, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mTrain_Image \u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mstr\u001b[39m(i))\n\u001b[0;32m----> 7\u001b[0m index \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mrandint(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;28mlen\u001b[39m(\u001b[43mval_dataset\u001b[49m))\n\u001b[1;32m      8\u001b[0m image \u001b[38;5;241m=\u001b[39m val_dataset[index]\n\u001b[1;32m      9\u001b[0m \u001b[38;5;28mprint\u001b[39m(np\u001b[38;5;241m.\u001b[39munique(image[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmask\u001b[39m\u001b[38;5;124m'\u001b[39m]))\n",
      "\u001b[0;31mNameError\u001b[0m: name 'val_dataset' is not defined"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    index = np.random.randint(0, len(test_set))\n",
    "    image = test_set[index]\n",
    "    print(np.unique(image['mask']))\n",
    "    visualize_mri_sample(image, \"Train_Image \" + str(i))\n",
    "    \n",
    "    index = np.random.randint(0, len(val_dataset))\n",
    "    image = val_dataset[index]\n",
    "    print(np.unique(image['mask']))\n",
    "    visualize_mri_sample(image, \"Val_Image \" + str(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3a1e3fd-290a-4de5-ab58-4a44e610cd16",
   "metadata": {},
   "source": [
    "**Create a dataloader for the corresponding data.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "076fac0b-ab36-47cb-9054-243330ee4630",
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import DataLoader\n",
    "\n",
    "train_dataloader = DataLoader(train_dataset, batch_size=1, shuffle=False)\n",
    "val_dataloader = DataLoader(val_dataset, batch_size=16, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1c87256-6710-4a59-ba79-30b9df4cfad0",
   "metadata": {},
   "source": [
    "**Visualization of preprocessing impact on 'broken' masks**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "91ee608c-6f50-4225-ac5c-ed7d6b47462d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# longMasks = []\n",
    "# for batch in tqdm(train_dataloader):\n",
    "#     masks = batch['mask']\n",
    "#     for mask in masks:\n",
    "#         if len(np.unique(mask)) > 4:\n",
    "#             mask=mask[0]\n",
    "#             print(np.unique(mask))\n",
    "#             mask[np.logical_and(mask>170,mask<255)]=1\n",
    "#             mask[np.logical_and(mask>3,mask<85)]=2\n",
    "#             mask[np.logical_and(mask>85,mask<170)]=3\n",
    "#             print(np.unique(mask))\n",
    "#             longMasks.append(mask)\n",
    "# print(longMasks[0].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "958bf831-5c0a-44e2-a0f1-acecba10c20d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# print(type(longMasks[0]))\n",
    "# for mask in longMasks:\n",
    "#     plt.imshow(mask)\n",
    "#     plt.show()\n",
    "#     print(f'       ^^ {np.unique(mask)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "145e609e-d2ec-4061-9b87-fb9bf2622798",
   "metadata": {},
   "source": [
    "**The selection of the correct and availble GPUs on the virtual machine.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5c4e731f-4b12-4cf4-9f92-fb687ec4a55d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean(lst):\n",
    "    return sum(lst) / len(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d0f99157-9073-421f-942b-10b081778f0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The used device is cuda:4\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda:4\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f'The used device is {device}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42b7a58f-e2c0-4666-bba8-320616d7f235",
   "metadata": {},
   "source": [
    "**Definition of the basic U-net model based on the tutorial.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "bab17942-5359-411f-aea8-e4612f257611",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Things to tweak: Kernel size, channels, amt of layers (6 layers only made it worse),\n",
    "# learning rate, strides (5*2 with 6layers was worse), num res units, batch size, transforms\n",
    "\n",
    "model = monai.networks.nets.UNet(\n",
    "    spatial_dims=2,\n",
    "    in_channels=1,\n",
    "    out_channels=4,\n",
    "    channels=(8, 16, 32, 64, 128),\n",
    "    strides=(2, 2, 2, 2),\n",
    "    num_res_units=2,\n",
    ").to(device)\n",
    "\n",
    "loss_function =  monai.losses.DiceLoss(softmax=True, batch=True, to_onehot_y=True)\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c75e4dac-f50f-4305-852d-1850eb5ef845",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/150 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best val loss: 0.1006772369146347\n",
      "Best val loss: 0.09917136281728745\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|▏         | 2/150 [01:34<1:56:18, 47.15s/it]"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "import wandb\n",
    "import datetime\n",
    "# now = datetime.datetime.now() # current date and time\n",
    "# nu = now.strftime('%c')\n",
    "\n",
    "# run = wandb.init(\n",
    "#     project='ACDC_Segmentation',\n",
    "#     name='BasicTrans_SimpleModel_AllData_',\n",
    "#     config={\n",
    "#         'loss function': str(loss_function),\n",
    "#         'lr': optimizer.param_groups[0][\"lr\"],\n",
    "#         'transform': from_compose_to_list(composed_transform),\n",
    "#         'batch_size': train_dataloader.batch_size,\n",
    "#         'model': model,\n",
    "#     }\n",
    "# )\n",
    "# # Do not hesitate to enrich this list of settings to be able to correctly keep track of your experiments!\n",
    "# # For example you should add information on your model...\n",
    "\n",
    "# run_id = run.id # We remember here the run ID to be able to write the evaluation metrics\n",
    "\n",
    "def wandb_masks(mask_output, mask_gt):\n",
    "    \"\"\" Function that generates a mask dictionary in format that W&B requires \"\"\"\n",
    "\n",
    "    # Apply sigmoid to model ouput and round to nearest integer (0 or 1)\n",
    "    # sigmoid = torch.nn.Sigmoid()\n",
    "    # mask_output = sigmoid(mask_output)\n",
    "    # mask_output = torch.round(mask_output)\n",
    "\n",
    "    # Transform masks to numpy arrays on CPU\n",
    "    # Note: .squeeze() removes all dimensions with a size of 1 (here, it makes the tensors 2-dimensional)\n",
    "    # Note: .detach() removes a tensor from the computational graph to prevent gradient computation for it\n",
    "    mask_output = mask_output.squeeze()\n",
    "    mask_gt = mask_gt.squeeze().detach().cpu().numpy()\n",
    "\n",
    "    # Create mask dictionary with class label and insert masks\n",
    "    class_labels = {1: 'left-ventricle', 2: 'right-ventricle', 3: 'myocardium'}\n",
    "    masks = {\n",
    "        'predictions': {'mask_data': mask_output, 'class_labels': class_labels},\n",
    "        'ground truth': {'mask_data': mask_gt, 'class_labels': class_labels}\n",
    "    }\n",
    "    return masks\n",
    "\n",
    "def log_to_wandb(epoch, train_loss, val_loss, batch_data, outputs):\n",
    "    \"\"\" Function that logs ongoing training variables to W&B \"\"\"\n",
    "\n",
    "    # Create list of images that have segmentation masks for model output and ground truth\n",
    "    log_imgs = [wandb.Image(img, masks=wandb_masks(mask_output, mask_gt)) for img, mask_output,\n",
    "                mask_gt in zip(batch_data['img'], outputs, batch_data['mask'])]\n",
    "\n",
    "    # Send epoch, losses and images to W&B\n",
    "    wandb.log({'epoch': epoch, 'train_loss': train_loss, 'val_loss': val_loss, 'results': log_imgs})\n",
    "\n",
    "# ⌨️ WRITE YOUR TRAINING LOOP HERE\n",
    "from tqdm import tqdm\n",
    "\n",
    "def train_medmnist(model, train_dataloader, val_dataloader, optimizer, epochs, device, val_freq=1):\n",
    "    train_loss = []\n",
    "    val_loss = []\n",
    "    best_dice = -1\n",
    "    best_loss = 10\n",
    "    \n",
    "    for epoch in tqdm(range(epochs)):\n",
    "        model.train()\n",
    "        steps = 0\n",
    "        epoch_loss = 0\n",
    "\n",
    "        for batch in train_dataloader:\n",
    "            optimizer.zero_grad()\n",
    "            images = batch['img'].float().to(device)\n",
    "            labels = batch['mask'].float().to(device)\n",
    "            output = model(images)\n",
    "            loss = loss_function(output, labels)\n",
    "            epoch_loss += loss.item()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            steps += 1\n",
    "            train_ep_loss = epoch_loss/steps\n",
    "        train_loss.append(epoch_loss/steps)\n",
    "\n",
    "        # validation loop\n",
    "        if epoch % val_freq == 0:\n",
    "            steps = 0\n",
    "            val_epoch_loss = 0\n",
    "            model.eval()\n",
    "            for batch in val_dataloader:\n",
    "                optimizer.zero_grad()\n",
    "                images = batch['img'].float().to(device)\n",
    "                labels = batch['mask'].float().to(device)\n",
    "                output = model(images)\n",
    "                loss = loss_function(output, labels)\n",
    "                val_epoch_loss += loss.item()\n",
    "                steps += 1\n",
    "                val_ep_loss = val_epoch_loss/steps\n",
    "\n",
    "                # ---------- OLD DICE SCORE -----------\n",
    "                # Run images through inferer and transform for Dice score calculation\n",
    "                # batch_dices = []\n",
    "                # inferer = monai.inferers.SimpleInferer()\n",
    "                # discrete_transform = monai.transforms.AsDiscrete(argmax = True)\n",
    "                # Softmax = torch.nn.Softmax()\n",
    "                # diceImages = batch['img'].float().to(device)\n",
    "\n",
    "#                 for image in diceImages:\n",
    "#                     with torch.no_grad():\n",
    "#                         output = discrete_transform(Softmax(model(image).cpu())).squeeze()\n",
    "#                     dice_mask = np.argmax(output, axis=0)\n",
    "\n",
    "#                     print(f'dicemask: {np.unique(dice_mask)}, gtmask: {np.unique(labels[i])}')\n",
    "\n",
    "#                     #Calculate mean Dice score for validation batch\n",
    "#                     dice = metrics(labels[i], dice_mask)\n",
    "#                     print(dice)\n",
    "#                     batch_dices.append(dice)\n",
    "#                 mean_dice = mean(batch_dices)\n",
    "\n",
    "                # Save the network if its Dice score is better than the current best\n",
    "                if val_ep_loss < best_loss:\n",
    "                    best_loss = val_ep_loss\n",
    "                    print(f'Best val loss: {best_loss}')\n",
    "                    torch.save(model.state_dict(), r'ACDC_Best_ROI.pt')\n",
    "\n",
    "            val_loss.append(val_ep_loss)\n",
    "        # log_to_wandb(epoch, train_ep_loss, val_ep_loss, batch, output)\n",
    "\n",
    "    return train_loss, val_loss, model\n",
    "\n",
    "val_freq = 5\n",
    "n_epochs = 150\n",
    "\n",
    "train_loss, val_loss, model = train_medmnist(model, train_dataloader, val_dataloader, optimizer, n_epochs, device, val_freq)\n",
    "\n",
    "torch.save(model.state_dict(), r'ACDC_Last_ROI.pt')\n",
    "# run.finish()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "65dd6127-459b-481c-8784-38e8802e6c66",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'train_loss' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[10], line 4\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# Plot training and validation loss\u001b[39;00m\n\u001b[1;32m      3\u001b[0m plt\u001b[38;5;241m.\u001b[39mfigure()\n\u001b[0;32m----> 4\u001b[0m plt\u001b[38;5;241m.\u001b[39mplot(\u001b[43mtrain_loss\u001b[49m, label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mTraining loss\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m      5\u001b[0m plt\u001b[38;5;241m.\u001b[39mplot(np\u001b[38;5;241m.\u001b[39mlinspace(\u001b[38;5;241m0\u001b[39m, n_epochs, \u001b[38;5;28mint\u001b[39m(n_epochs\u001b[38;5;241m/\u001b[39mval_freq)), val_loss, label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mValidation loss\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m      6\u001b[0m plt\u001b[38;5;241m.\u001b[39mxlabel(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mEpoch\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'train_loss' is not defined"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot training and validation loss\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(train_loss, label='Training loss')\n",
    "plt.plot(np.linspace(0, n_epochs, int(n_epochs/val_freq)), val_loss, label='Validation loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "fe09f90d-d611-4158-bfad-d4123d2c8acf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Congrats! You selected the correct folder :)\n"
     ]
    }
   ],
   "source": [
    "data_path = \"./preprocessed/\"\n",
    "if not os.path.exists(data_path):\n",
    "    print(\"Please update your data path to an existing folder.\")\n",
    "elif not set([\"training\", \"testing\"]).issubset(set(os.listdir(data_path))):\n",
    "    print(\"Please update your data path to the correct folder (should contain training and testing folders).\")\n",
    "else:\n",
    "    print(\"Congrats! You selected the correct folder :)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "4ba278ee-1bb6-4d18-81e9-20a060bda03f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 50/50 [00:00<00:00, 262.12it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1076\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading dataset: 100%|██████████| 1076/1076 [00:14<00:00, 76.26it/s]\n"
     ]
    }
   ],
   "source": [
    "test_dict = build_dict_ACDC(data_path, mode='testing')\n",
    "print(len(test_dict))\n",
    "test_transform = monai.transforms.Compose([\n",
    "                                           LoadMriData(),\n",
    "                                           monai.transforms.AddChanneld(keys=['img', 'mask']),\n",
    "                                           monai.transforms.NormalizeIntensityd(keys=['img']),\n",
    "                                           # monai.transforms.Zoomd(keys=['img', 'mask'], zoom=0.25, keep_size=False, mode=['bilinear', 'nearest']),\n",
    "                                           # monai.transforms.Resized(keys = ['img','mask'],spatial_size=(1024,1024), mode=['bilinear','nearest'])\n",
    "                                            ])\n",
    "test_set = monai.data.CacheDataset(test_dict, transform=test_transform)\n",
    "test_loader = monai.data.DataLoader(test_set, batch_size=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "e52735dd-3970-426d-b902-12696300d7a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ROI model loaded\n",
      "Segmentation model loaded\n"
     ]
    }
   ],
   "source": [
    "roiModel = monai.networks.nets.UNet(\n",
    "    kernel_size=21,\n",
    "    up_kernel_size=21,\n",
    "    spatial_dims=2,\n",
    "    in_channels=1,\n",
    "    out_channels=1,\n",
    "    channels=(8, 16, 32, 64, 128),\n",
    "    strides=(2, 2, 2, 2),\n",
    "    num_res_units=2,\n",
    ").to(device)\n",
    "\n",
    "roiModel.load_state_dict(torch.load(\"trainedUNetROI_Final.pt\"))\n",
    "roiModel.eval()\n",
    "print(\"ROI model loaded\")\n",
    "\n",
    "model = monai.networks.nets.UNet(\n",
    "    spatial_dims=2,\n",
    "    in_channels=1,\n",
    "    out_channels=4,\n",
    "    channels=(8, 16, 32, 64, 128),\n",
    "    strides=(2, 2, 2, 2),\n",
    "    num_res_units=2,\n",
    ").to(device)\n",
    "\n",
    "model.load_state_dict(torch.load(\"ACDC_Best_NewTrans.pt\"))\n",
    "model.eval()\n",
    "print(\"Segmentation model loaded\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "51451a1a-b277-40fd-abea-3898b05ef5ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "from skimage.measure import regionprops, label\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "## function for finding the largest connected component and it's centre\n",
    "## make ROI around centre of size:\n",
    "\n",
    "# According to Gray’s Anatomy, the heart length, width, and thickness are 12 cm, 8.5 cm, and 6 cm, respectively, doi: 10.15171/jcvtr.2016.25\n",
    "target_resolution = (1.36719, 1.36719)\n",
    "\n",
    "def get_ROI(image):\n",
    "    # Give as an input an image (in the form of a dictionary with labels 'img'and 'mask) \n",
    "    # and outputs an ROI centred around the centre of mass of the heart. \n",
    "    # Second input is the resolutoin (mm/pixel) of the input image.\n",
    "    \n",
    "    # split input into image and mask\n",
    "    im = image['img']\n",
    "    mask = image['mask']\n",
    "    \n",
    "    # find target size of ROI, based on pixel size (mm/pixel) and maximum expected size of heart (doi: 10.15171/jcvtr.2016.25)\n",
    "    nr = int(128/2) # number of rows/2\n",
    "    nc = int(128/2) # number of columns/2\n",
    "\n",
    "    if len(np.unique(mask))==1:                                            # if there is no heart in the image, just use the central part of the image as an ROI\n",
    "        labels = label(mask,background=1)                                  # find all connected components\n",
    "        largestCC = labels == np.argmax(np.bincount(labels.flat)[1:])+1    # largest connected components\n",
    "        mask = largestCC*1                                                 # True --> 1, False --> 0     \n",
    "        properties = regionprops(mask.astype(int))                         # Geometrical properties of image\n",
    "        com = np.round(properties[0].centroid).astype(int)                 # Centre of mass = centre of image in this specific case\n",
    "        com_r = com[0]                                                     # row index\n",
    "        com_c = com[1]                                                     # column index\n",
    "        ROI_mask = mask[(com_r-nr):(com_r+nr),(com_c-nc):(com_c+nc)]     # ROI mask\n",
    "        ROI_mask = 0*ROI_mask\n",
    "        im = im.squeeze()\n",
    "        ROI = im[(com_r-nr):(com_r+nr),(com_c-nc):(com_c+nc)]            # ROI of grey scale image\n",
    "        \n",
    "    else:                                                                  # if heart is present\n",
    "        # Find Largest connected component:\n",
    "        labels = label(mask)                                               # find all connected components\n",
    "        largestCC = labels == np.argmax(np.bincount(labels.flat)[1:])+1    # largest connected components\n",
    "        largestCC = largestCC*1                                            # True --> 1, False --> 0\n",
    "        properties = regionprops(largestCC)                                # Geometrical properties of largest connected component\n",
    "        com = np.round(properties[0].centroid).astype(int)                 # Centre of mass\n",
    "        com_r = com[0]                                                     # row index\n",
    "        com_c = com[1]                                                     # column index\n",
    "        ROI_mask = largestCC[(com_r-nr):(com_r+nr),(com_c-nc):(com_c+nc)]\n",
    "        im = im.squeeze()\n",
    "        ROI = im[(com_r-nr):(com_r+nr),(com_c-nc):(com_c+nc)]    \n",
    "    # plt.figure()\n",
    "    # plt.imshow(np.squeeze(ROI),'gray')\n",
    "    # overlay_mask = np.ma.masked_where(ROI_mask==0, ROI_mask)\n",
    "    # plt.imshow(overlay_mask, 'Reds', alpha = 0.5, clim=[0,1], interpolation='nearest')\n",
    "    # plt.scatter(x=nc, y=nr, c='g', s=40)\n",
    "    # plt.figure()\n",
    "    \n",
    "    return ROI, com_r, com_c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "a59bd4a9-affa-46dc-871f-eccd6deeadf9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from medpy.metric.binary import hd, dc\n",
    "def metrics(img_gt, img_pred, voxel_size):\n",
    "    \"\"\"\n",
    "    Function to compute the metrics between two segmentation maps given as input.\n",
    "    ----------\n",
    "    \n",
    "    Abbreviations:\n",
    "    ----------\n",
    "    LV: left ventricle\n",
    "    RV: right ventricle\n",
    "    MYO: myocardium\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    img_gt: np.array\n",
    "    Array of the ground truth segmentation map.  (LV --> class 3, RV --> class 1, myocardium --> class 2)\n",
    "\n",
    "    img_pred: np.array\n",
    "    Array of the predicted segmentation map.\n",
    "\n",
    "    voxel_size: list, tuple or np.array\n",
    "    The size of a voxel of the images used to compute the volumes (in mm).\n",
    "    \n",
    "    For example: for voxels of size 2mm by  1mm by 8mm, use voxel_size = np.array([2 1 8])\n",
    "\n",
    "    Return\n",
    "    ------\n",
    "    A list of metrics in this order, [Dice LV, Volume LV, Err LV(ml),\n",
    "    Dice RV, Volume RV, Err RV(ml), Dice MYO, Volume MYO, Err MYO(ml)]\n",
    "    \"\"\"\n",
    "\n",
    "    if img_gt.ndim != img_pred.ndim:\n",
    "        raise ValueError(\"The arrays 'img_gt' and 'img_pred' should have the \"\n",
    "                         \"same dimension, {} against {}\".format(img_gt.ndim,\n",
    "                                                                img_pred.ndim))\n",
    "\n",
    "    lv = 0\n",
    "    rv = 0\n",
    "    myo = 0\n",
    "    dices = []\n",
    "    hds = []\n",
    "    voxel_size = float(voxel_size)\n",
    "    \n",
    "    # Loop on each classes of the input images\n",
    "    for c in [3, 1, 2]:\n",
    "        # Copy the gt image to not alterate the input\n",
    "        gt_c_i = np.copy(img_gt)\n",
    "        gt_c_i[gt_c_i != c] = 0\n",
    "\n",
    "        # Copy the pred image to not alterate the input\n",
    "        pred_c_i = np.copy(img_pred)\n",
    "        pred_c_i[pred_c_i != c] = 0\n",
    "\n",
    "        # Clip the value to compute the volumes\n",
    "        gt_c_i = np.clip(gt_c_i, 0, 1)\n",
    "        pred_c_i = np.clip(pred_c_i, 0, 1)\n",
    "        \n",
    "        # Compute the Dice\n",
    "        dice = dc(pred_c_i, gt_c_i)\n",
    "        \n",
    "        # Save the dice score per class\n",
    "        if c==3:\n",
    "            lv = dice\n",
    "        elif c==1:\n",
    "            rv = dice\n",
    "        elif c==2:\n",
    "            myo = dice\n",
    "\n",
    "        # Append to this list to calculate mean dice\n",
    "        dices.append(dice)\n",
    "\n",
    "        # Compute Hausdorff Distance\n",
    "        hausdorf = hd(pred_c_i, gt_c_i)\n",
    "        hds.append(hausdorf)\n",
    "\n",
    "        # Compute volume\n",
    "        volpred = pred_c_i.sum() * np.prod(voxel_size) / 1000.\n",
    "        volgt = gt_c_i.sum() * np.prod(voxel_size) / 1000.\n",
    "        \n",
    "    return mean(dices), lv, rv, myo, hausdorf, volpred, volpred-volgt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "1c0b65bd-706a-4703-a4d8-2b8fd28fda8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluation(img, mask, seg, model, visual=False):\n",
    "    \"\"\"\n",
    "    Given a model, calculate the dice score of a sample image and ground truth pair.\n",
    "    Model will be used to create a predicted mask, dice score is calculated between this and ground truth.\n",
    "    \n",
    "    If visual=True:\n",
    "    Allow the visual inspection of one sample by plotting the X-ray image, the ground truth (green)\n",
    "    and the segmentation map produced by the network (red).\n",
    "    \n",
    "    Args:\n",
    "        sample (Dict[str, torch.Tensor]): sample composed of an X-ray ('img') and a mask ('mask').\n",
    "        model (torch.nn.Module): trained model to evaluate.\n",
    "        visual (Boolean): True if you want to see the predicted masks visualized -> will take much longer\n",
    "    \"\"\"\n",
    "    \n",
    "    # infer output of network\n",
    "    model.eval()\n",
    "    inferer = monai.inferers.SimpleInferer()\n",
    "    Softmax = torch.nn.Softmax()\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        output = Softmax(inferer(sample['img'].float().to(device), network=model).cpu()).squeeze().detach().numpy()\n",
    "    classes = np.argmax(output, axis=0)  # find class with highest probabillity per pixel\n",
    "    \n",
    "    if visual:\n",
    "        # print(f'For image below, dice = {dice}')\n",
    "        fig, ax = plt.subplots(1,3, figsize = [12, 10])\n",
    "\n",
    "        # mask = ground truth segmentation\n",
    "        mask = np.squeeze(mask)\n",
    "        \n",
    "        # create mask for background\n",
    "        overlay_mask1 = np.ma.masked_where(mask!=1, mask)\n",
    "        overlay_mask2 = np.ma.masked_where(mask!=2 ,mask)\n",
    "        overlay_mask3 = np.ma.masked_where(mask!=3, mask)\n",
    "\n",
    "        # Plot MRI image\n",
    "        ax[0].imshow(img.squeeze(), 'gray')\n",
    "        ax[0].set_title('Grey scale MRI')\n",
    "\n",
    "        # Plot ground truth\n",
    "        ax[1].imshow(img.squeeze(), 'gray')\n",
    "        ax[1].imshow(overlay_mask1, 'Reds', alpha = 0.7, clim=[0,1], interpolation='nearest')\n",
    "        ax[1].imshow(overlay_mask2, 'Blues', alpha = 0.7, clim=[0,1], interpolation='nearest')\n",
    "        ax[1].imshow(overlay_mask3, 'Greens', alpha = 0.7, clim=[0,1], interpolation='nearest')\n",
    "        ax[1].set_title('Ground truth')\n",
    "\n",
    "        mask = np.squeeze(seg) # rename (because code for ground truth was copied, and there I named them 'mask' instead of 'classes')\n",
    "        # select the different components (= value 1, 2 or 3 for myo, LV and RV)\n",
    "        \n",
    "        # create mask for background\n",
    "        overlay_mask1 = np.ma.masked_where(mask!=1, mask)\n",
    "        overlay_mask2 = np.ma.masked_where(mask!=2 ,mask)\n",
    "        overlay_mask3 = np.ma.masked_where(mask!=3, mask)\n",
    "\n",
    "        ax[2].imshow(img.squeeze(), 'gray')\n",
    "        ax[2].imshow(overlay_mask1, 'Reds', alpha = 0.7, clim=[0,1], interpolation='nearest')\n",
    "        ax[2].imshow(overlay_mask2, 'Blues', alpha = 0.7, clim=[0,1], interpolation='nearest')\n",
    "        ax[2].imshow(overlay_mask3, 'Greens', alpha = 0.7, clim=[0,1], interpolation='nearest')\n",
    "        ax[2].set_title('Prediction')\n",
    "        plt.show()\n",
    "    \n",
    "    return classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "f327ce12-0994-4ed6-a1f2-301a9b2e0415",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ac_mask(mask, img):\n",
    "    '''\n",
    "    This function applied an active contour model to the segmentation mask.\n",
    "    It outputs a segmentation mask with 3 classes.\n",
    "    mask_path: datapath to the mask\n",
    "    image_path: datapath to the image corresponding to the mask\n",
    "    '''\n",
    "    # mask = Image.open(mask_path).convert('L')\n",
    "    mask = np.array(mask, dtype=np.uint8)\n",
    "    \n",
    "    # img = Image.open(img_path).convert('L')\n",
    "    print(np.unique(img))\n",
    "    img = np.array(img, dtype=np.uint8)\n",
    "    print(np.unique(img))\n",
    "    # print(img.shape)\n",
    "    # plt.imshow(img)\n",
    "    # plt.show()\n",
    "    \n",
    "    nx, ny = mask.shape\n",
    "    \n",
    "    # Find boundaries of each mask\n",
    "    init = mask*find_boundaries(mask, mode='inner')\n",
    "    init_1 = init*(init == 1)\n",
    "    init_2 = init*(init == 2)\n",
    "    init_3 = init*(init == 3)\n",
    "    \n",
    "    # Mask 1\n",
    "    # Find coordinates of boundary\n",
    "    indeces1 = np.where(init_1 == 1)\n",
    "    xy_coords1 = np.column_stack(indeces1)\n",
    "    \n",
    "    # Apply AC\n",
    "    snake1 = active_contour(img,\n",
    "                       xy_coords1, alpha=0.015, beta=10, gamma=0.000001, w_line=-1)\n",
    "    \n",
    "    new_mask1 = np.zeros((nx, ny))\n",
    "    \n",
    "    # Build new boundary from snake coordinates\n",
    "    for i, j in snake1:\n",
    "        new_mask1[int(i), int(j)] = 1\n",
    "    \n",
    "    # Fill the mask\n",
    "    new_mask1 = binary_fill_holes(new_mask1)\n",
    "    \n",
    "    # Mask 2\n",
    "    # Find coordinates of boundary\n",
    "    indeces2 = np.where(init_2 == 2)\n",
    "    xy_coords2 = np.column_stack(indeces2)\n",
    "    \n",
    "    # Apply AC\n",
    "    snake2 = active_contour(img,\n",
    "                       xy_coords2, alpha=0.015, beta=10, gamma=0.000001, w_line=-1)\n",
    "    \n",
    "    new_mask2 = np.zeros((nx, ny))\n",
    "    \n",
    "    # Build new boundary from snake coordinates\n",
    "    for i, j in snake2:\n",
    "        new_mask2[int(i), int(j)] = 1\n",
    "    \n",
    "    # Fill the mask\n",
    "    new_mask2 = binary_closing(new_mask2, structure=np.ones((10,10)))\n",
    "    \n",
    "    # Set to right class\n",
    "    new_mask2 = new_mask2*2\n",
    "    \n",
    "    # Mask 3\n",
    "    # Find coordinates of boundary\n",
    "    indeces3 = np.where(init_3 == 3)\n",
    "    xy_coords3 = np.column_stack(indeces3)\n",
    "    \n",
    "    # Apply AC\n",
    "    snake3 = active_contour(img,\n",
    "                       xy_coords3, alpha=0.015, beta=10, gamma=0.0000001, w_line=-1)\n",
    "    \n",
    "    new_mask3 = np.zeros((nx, ny))\n",
    "    \n",
    "    # Build new boundary from snake coordinates\n",
    "    for i, j in snake3:\n",
    "        new_mask3[int(i), int(j)] = 1\n",
    "\n",
    "    # Fill the mask\n",
    "    new_mask3 = binary_fill_holes(new_mask3)\n",
    "    \n",
    "    # Set to right class\n",
    "    new_mask3 = new_mask3*3\n",
    "    \n",
    "    # Combine mask 1 and 2\n",
    "    new_mask = new_mask1+new_mask2\n",
    "    \n",
    "    # If they overlap, choose mask 2\n",
    "    new_mask[new_mask == 3] = 2\n",
    "    \n",
    "    # Add mask 3\n",
    "    new_mask = new_mask+new_mask3\n",
    "    \n",
    "    # If they overlap, choose mask 3\n",
    "    new_mask[new_mask > 3] = 3\n",
    "    \n",
    "    return new_mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "7c36bf38-7aed-4a29-8c67-94f76fe4e774",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/1076 [00:00<?, ?it/s]/home/jovyan/.local/lib/python3.8/site-packages/monai/utils/deprecate_utils.py:107: FutureWarning: <class 'monai.transforms.utility.array.AddChannel'>: Class `AddChannel` has been deprecated since version 0.8. please use MetaTensor data type and monai.transforms.EnsureChannelFirst instead.\n",
      "  warn_deprecated(obj, msg, warning_category)\n",
      "/tmp/ipykernel_58923/77099441.py:38: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "  output = Softmax(inferer(torch.from_numpy(np.resize(addchannel(ROI), (1,1,128,128))).float().to(device), network=model).cpu()).squeeze().detach().numpy()\n",
      "  2%|▏         | 21/1076 [00:03<07:11,  2.45it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8790449982415464\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  4%|▎         | 38/1076 [00:06<04:18,  4.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9168177740238773\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|▌         | 55/1076 [00:09<06:47,  2.51it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8323531695065546\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  7%|▋         | 73/1076 [00:14<06:12,  2.70it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8192209693969827\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  9%|▉         | 95/1076 [00:17<03:00,  5.43it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8816436445904473\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 10%|█         | 111/1076 [00:19<04:49,  3.33it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6661732814264707\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 12%|█▏        | 130/1076 [00:27<05:37,  2.80it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7616812317345846\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 14%|█▍        | 149/1076 [00:30<07:12,  2.14it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7726233417274062\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 16%|█▌        | 167/1076 [00:36<03:45,  4.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8031042573701009\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 17%|█▋        | 184/1076 [00:38<03:43,  4.00it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8450410865978452\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 18%|█▊        | 196/1076 [00:40<02:51,  5.12it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8488731437702356\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|█▉        | 215/1076 [00:43<06:13,  2.30it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8122402364908491\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 22%|██▏       | 236/1076 [00:48<03:58,  3.53it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7772944824851545\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 24%|██▍       | 258/1076 [00:51<03:55,  3.48it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6221441295640573\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 26%|██▌       | 278/1076 [00:56<06:57,  1.91it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8980528826221877\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 28%|██▊       | 298/1076 [00:59<03:45,  3.45it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8943480148313424\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 30%|██▉       | 319/1076 [01:02<02:39,  4.75it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6575907320770944\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 31%|███       | 335/1076 [01:05<03:22,  3.66it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8657772379130355\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 34%|███▍      | 369/1076 [01:14<06:39,  1.77it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8650797010949285\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 36%|███▌      | 387/1076 [01:21<07:56,  1.45it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7453139139210317\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 38%|███▊      | 404/1076 [01:25<03:59,  2.81it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8002075832584307\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 39%|███▉      | 422/1076 [01:28<02:48,  3.88it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.82114059706031\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 41%|████      | 437/1076 [01:31<05:04,  2.10it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8807582929033851\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 45%|████▍     | 481/1076 [01:46<05:30,  1.80it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8241122546391345\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 48%|████▊     | 513/1076 [01:55<06:00,  1.56it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8342546454134953\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 51%|█████     | 545/1076 [02:09<06:34,  1.35it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7927731641749581\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 54%|█████▍    | 584/1076 [02:23<03:51,  2.13it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8465921600709153\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 56%|█████▌    | 602/1076 [02:26<02:00,  3.92it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8816781756088009\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 59%|█████▉    | 636/1076 [02:31<02:56,  2.50it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8028716328613381\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 61%|██████    | 656/1076 [02:34<01:30,  4.64it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8170601694486342\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 63%|██████▎   | 677/1076 [02:37<01:13,  5.40it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7690151001392055\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 65%|██████▍   | 696/1076 [02:40<01:17,  4.92it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8057716022901839\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 67%|██████▋   | 716/1076 [02:43<02:03,  2.93it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6732092150440487\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 69%|██████▊   | 738/1076 [02:47<01:43,  3.28it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9082340320551664\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 70%|███████   | 758/1076 [02:51<01:29,  3.56it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6777617972154992\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 72%|███████▏  | 779/1076 [02:54<01:06,  4.47it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8366901698689663\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 74%|███████▍  | 797/1076 [02:56<00:47,  5.87it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8125197524649419\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 76%|███████▌  | 815/1076 [03:02<01:29,  2.91it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8529650270206931\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 79%|███████▊  | 847/1076 [03:08<01:02,  3.69it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9022208692660821\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 82%|████████▏ | 886/1076 [03:15<01:15,  2.53it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6726665989811292\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 84%|████████▍ | 906/1076 [03:19<00:53,  3.21it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8716906496498055\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 86%|████████▌ | 922/1076 [03:22<00:44,  3.44it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8371770039200946\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 88%|████████▊ | 942/1076 [03:24<00:35,  3.80it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8553013768328487\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 89%|████████▉ | 958/1076 [03:27<00:23,  5.12it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8775072126008668\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 91%|█████████ | 978/1076 [03:30<00:25,  3.81it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.771052763619041\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 93%|█████████▎| 996/1076 [03:33<00:24,  3.26it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8572939913226589\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 95%|█████████▌| 1025/1076 [03:38<00:25,  1.98it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7848901653094619\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 97%|█████████▋| 1042/1076 [03:42<00:11,  3.09it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8781954416557435\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 99%|█████████▉| 1063/1076 [03:46<00:03,  3.44it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8737005405023307\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1076/1076 [03:48<00:00,  4.70it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total mean Dice: 0.8159944941751818, mean Dice LV: 0.8814097259744874, mean Dice RV: 0.7939229587241872, mean Dice Myo: 0.7726507978268703, mean Hausdorff: 12.673261127478662, mean Volume error: -60.07330929568075\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "dices = []\n",
    "lvs = []\n",
    "rvs = []\n",
    "myos = []\n",
    "hds = []\n",
    "volpreds = []\n",
    "volerrors = []\n",
    "best_dice = 0\n",
    "worst_dice = 10\n",
    "current_patient = ''\n",
    "initialize = False\n",
    "\n",
    "for i, sample in enumerate(tqdm(test_loader)):\n",
    "    # Get ROI\n",
    "    inferer = monai.inferers.SimpleInferer()\n",
    "    discrete_transform = monai.transforms.AsDiscrete(threshold=0.5)\n",
    "    addchannel = monai.transforms.AddChannel()\n",
    "    norm = monai.transforms.NormalizeIntensity()\n",
    "    Sigmoid = torch.nn.Sigmoid()\n",
    "    \n",
    "    # Denoise an image\n",
    "    inputImage = denoise_tv_chambolle(sample['img'].cpu().detach().numpy(), eps=1e-6, weight=0.1, max_num_iter=1000)\n",
    "    inputImage = torch.from_numpy(inputImage)\n",
    "    \n",
    "    # Use this instead of 2 lines above if data is already denoised\n",
    "    # inputImage = sample['img']\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        roiOutput = discrete_transform(Sigmoid(inferer(inputImage.float().to(device), network=roiModel).cpu())).squeeze().detach().numpy()\n",
    "    \n",
    "    roiDict = {'img': sample['img'], 'mask': roiOutput}\n",
    "    nr = nc = int(128/2)\n",
    "    ROI, com_r, com_c = get_ROI(roiDict)\n",
    "    \n",
    "    # Get segmentation on ROI\n",
    "    Softmax = torch.nn.Softmax()\n",
    "    with torch.no_grad():\n",
    "        output = Softmax(inferer(torch.from_numpy(np.resize(addchannel(ROI), (1,1,128,128))).float().to(device), network=model).cpu()).squeeze().detach().numpy()\n",
    "\n",
    "    seg = np.argmax(output, axis=0)\n",
    "    img = sample['img'].squeeze()[(com_r-nr):(com_r+nr),(com_c-nc):(com_c+nc)]\n",
    "    mask = sample['mask'].squeeze()[(com_r-nr):(com_r+nr),(com_c-nc):(com_c+nc)]\n",
    "    \n",
    "    # evaluation(img, mask, seg, model, visual=True)\n",
    "    \n",
    "    # Place segmented ROI back in full image size\n",
    "    finalseg = np.zeros((256,256))\n",
    "    finalseg[(com_r-nr):(com_r+nr),(com_c-nc):(com_c+nc)] = seg\n",
    "    seg = finalseg\n",
    "    \n",
    "    # ---- ROI done ----\n",
    "    \n",
    "    # Initialize empty masks once\n",
    "    mask = sample['mask'].squeeze().numpy()\n",
    "    \n",
    "    # Get voxel_size and patient from file names\n",
    "    voxel_size = test_dict[i]['mask'].split('_')[-2]\n",
    "    \n",
    "    # Do 0 + (i*1) to the split index, where 'i' is amount of underscores in folder name\n",
    "    patient = test_dict[i]['img'].split('_')[0][-10:]\n",
    "    \n",
    "    # Make image with correct dimensions for AC model\n",
    "    acImg = sample['img'].squeeze()\n",
    "    \n",
    "    # If first patients, initialize (3D) arrays\n",
    "    if ('patient101' in patient or 'patient001' in patient) and not initialize:\n",
    "        best_seg = np.zeros(mask.shape)\n",
    "        worst_seg = np.zeros(mask.shape)\n",
    "        threedmask = mask.reshape(mask.shape[0], mask.shape[1], 1)\n",
    "        threedsample = acImg.reshape(acImg.shape[0], acImg.shape[1], 1)\n",
    "        \n",
    "        # plt.imshow(sample['img'].squeeze())\n",
    "        # plt.title('sample')\n",
    "        # plt.show()\n",
    "        # seg = ac_mask(seg, acImg)\n",
    "        \n",
    "        threedseg = seg.reshape(seg.shape[0], seg.shape[1], 1)\n",
    "        current_patient = patient\n",
    "        initialize = True\n",
    "    # If patient is new, but not the first patient\n",
    "    elif patient not in current_patient:\n",
    "        # ----- Calculate all metrics on 3D-mask -----\n",
    "        \n",
    "        # Hacky fix for classes being mixed up with a certain model\n",
    "        threedseg[threedseg==1]=4\n",
    "        threedseg[threedseg==2]=5\n",
    "        threedseg[threedseg==3]=6\n",
    "        threedseg[threedseg==4]=3\n",
    "        threedseg[threedseg==5]=1\n",
    "        threedseg[threedseg==6]=2\n",
    "        \n",
    "        dice, lv, rv, myo, haus, volpred, volerror = metrics(threedmask, threedseg, voxel_size)\n",
    "        print(dice)\n",
    "        lvs.append(lv)\n",
    "        rvs.append(rv)\n",
    "        myos.append(myo)\n",
    "        volpreds.append(volpred)\n",
    "        volerrors.append(volerror)\n",
    "        \n",
    "        if dice > best_dice:\n",
    "            best_seg = threedseg[:,:,5]\n",
    "            best_dice = dice\n",
    "            \n",
    "            best = Image.fromarray(best_seg.astype('uint8'))\n",
    "            best.save(\"BestSegmentation_seg.png\")\n",
    "            \n",
    "            save_image(torch.from_numpy(threedsample[:,:,5])*255, 'BestSegmentation_img.png', normalize=True)\n",
    "            \n",
    "            save_image(torch.from_numpy(threedmask[:,:,5]).double(), 'BestSegmentation_mask.png', normalize=False)\n",
    "        elif dice < worst_dice:\n",
    "            worst_seg = threedseg[:,:,5]\n",
    "            worst_dice = dice\n",
    "            \n",
    "            worst = Image.fromarray(worst_seg.astype('uint8'))\n",
    "            worst.save(\"WorstSegmentation_seg.png\", format='PNG')\n",
    "            \n",
    "            save_image(torch.from_numpy(threedsample[:,:,5])*255, 'WorstSegmentation_img.png', normalize=True)\n",
    "            \n",
    "            save_image(torch.from_numpy(threedmask[:,:,5]).double(), 'WorstSegmentation_mask.png', normalize=False)\n",
    "        dices.append(dice)\n",
    "        hds.append(haus)\n",
    "        \n",
    "        # Reset 3D arrays\n",
    "        threedsample = acImg.reshape(acImg.shape[0], acImg.shape[1], 1)\n",
    "        threedmask = mask.reshape(mask.shape[0], mask.shape[1], 1)\n",
    "        threedseg = seg.reshape(seg.shape[0], seg.shape[1], 1)\n",
    "        current_patient = patient\n",
    "    # If same patient, add current mask to the 3D mask\n",
    "    elif patient in current_patient:\n",
    "        # Make mask&seg fit 3D shape\n",
    "        mask = mask.reshape(mask.shape[0], mask.shape[1], 1)\n",
    "        \n",
    "        # plt.imshow(sample['img'].squeeze())\n",
    "        # plt.title('sample')\n",
    "        # plt.show()\n",
    "        # seg = ac_mask(seg, acImg)\n",
    "        sample = acImg.reshape(acImg.shape[0], acImg.shape[1], 1)\n",
    "        seg = seg.reshape(seg.shape[0], seg.shape[1], 1)\n",
    "        \n",
    "        # Concatenate in 3rd dimension\n",
    "        threedsample = np.concatenate((threedsample, sample), 2)\n",
    "        threedmask = np.concatenate((threedmask, mask), 2)\n",
    "        threedseg = np.concatenate((threedseg, seg), 2)\n",
    "\n",
    "meanlv = mean(lvs)\n",
    "meanrv = mean(rvs)\n",
    "meanmyo = mean(myos)\n",
    "meandice = mean(dices)\n",
    "meanhd = mean(hds)\n",
    "meanvolpred = mean(volpreds)\n",
    "meanvolerror = mean(volerrors)\n",
    "\n",
    "print(f'Total mean Dice: {meandice}, mean Dice LV: {meanlv}, mean Dice RV: {meanrv}, mean Dice Myo: {meanmyo}, mean Hausdorff: {meanhd}, mean Volume error: {meanvolerror}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "747fa7b7-de22-45d6-a3ee-8804619ce930",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lets see the results...\n"
     ]
    }
   ],
   "source": [
    "print('Lets see the results...')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6d9f3ea-0f05-4764-ab2b-c25a3c31d495",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}