data_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2aff2acff8314d89b965c1df0d719ae9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=1, bar_style='info', max=1), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "import nibabel as nib\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "tqdm().pandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = '../../../../user/data/decathlon/Task07_Pancreas'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "ids = [x for x in os.listdir(os.path.join(path, 'imagesTr')) if x.endswith('.gz') and not x.startswith('._panc')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(len(img.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "for name_ids in ids:\n",
    "    i = os.path.join(path,'imagesTr',name_ids)\n",
    "    img = nib.load(i).get_fdata()\n",
    "    if (len(img.shape)!=3):\n",
    "        print(\"FUUUUUCK\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_density = []\n",
    "for name_ids in ids:\n",
    "    i = os.path.join(path,'labelsTr',name_ids)\n",
    "    img = nib.load(i).get_fdata()\n",
    "    for ch in range(img.shape[2]):\n",
    "        list_of_density.append((img[:,:,ch] != 0).sum()/(img[:,:,ch] > -1).sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "281\n"
     ]
    }
   ],
   "source": [
    "density_no_zeros = 0\n",
    "for name_ids in ids:\n",
    "    i = os.path.join(path,'labelsTr',name_ids)\n",
    "    img = nib.load(i).get_fdata()\n",
    "    non_zerooo = (len(img[img > 0]))\n",
    "    number_of_all_elements = (img.shape[0]*img.shape[1]*img.shape[2])\n",
    "    if (non_zerooo != number_of_all_elements):\n",
    "        density_no_zeros += 1\n",
    "print(density_no_zeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_density_cancer = []\n",
    "list_of_density_organ = []\n",
    "for name_ids in ids:\n",
    "    i = os.path.join(path,'labelsTr',name_ids)\n",
    "    img = nib.load(i).get_fdata()\n",
    "    for ch in range(img.shape[2]):\n",
    "        list_of_density_cancer.append((img[:,:,ch] == 2).sum()/(img[:,:,ch] > -1).sum())\n",
    "        list_of_density_organ.append((img[:,:,ch] == 1).sum()/(img[:,:,ch] > -1).sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.003000981891347895\n"
     ]
    }
   ],
   "source": [
    "print(sum(list_of_density_cancer)/np.count_nonzero(list_of_density_cancer))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.005766103393610275\n"
     ]
    }
   ],
   "source": [
    "print(sum(list_of_density_organ)/np.count_nonzero(list_of_density_organ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6712451813316367\n"
     ]
    }
   ],
   "source": [
    "print((len(list_of_density_organ) - np.count_nonzero(list_of_density_organ))/len(list_of_density_organ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36760\n",
      "23330816\n"
     ]
    }
   ],
   "source": [
    "print(len(img[img > 0]))\n",
    "print(img.shape[0]*img.shape[1]*img.shape[2])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26719\n"
     ]
    }
   ],
   "source": [
    "print(len(list_of_density))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0021805809823654426\n"
     ]
    }
   ],
   "source": [
    "print(sum(list_of_density)/len(list_of_density))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "281\n"
     ]
    }
   ],
   "source": [
    "print(len(ids))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_tr_1 = os.path.join(path,'imagesTr',ids[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "../../../../user/data/decathlon/Task07_Pancreas/imagesTr/pancreas_316.nii.gz\n"
     ]
    }
   ],
   "source": [
    "print(path_tr_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_lb_1 = os.path.join(path,'labelsTr',ids[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = nib.load(path_tr_1).get_fdata()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " ...\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "print(img[:,:,45])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1.])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(img[:,:,45])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "754\n"
     ]
    }
   ],
   "source": [
    "print((img[:,:,45] != 0).sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "262144\n"
     ]
    }
   ],
   "source": [
    "print((img[:,:,45] > -1).sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.00287628173828125\n"
     ]
    }
   ],
   "source": [
    "print((img[:,:,45] != 0).sum()/(img[:,:,45] > -1).sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = nib.load(path_lb_1).get_fdata()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fcf9d9de080>"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def get_rectangular(img, margin=5):\n",
    "    x, y = np.where(img)\n",
    "    x_min = min(x)\n",
    "    x_max = max(x)\n",
    "    y_min = min(y)\n",
    "    y_max = max(y)\n",
    "    return img[x_min-margin:x_max+1+margin, y_min-margin:y_max+1+margin]\n",
    "# plt.figure(figsize=(20, 20))\n",
    "rect = get_rectangular(img[:,:,45])\n",
    "plt.imshow(rect)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import nibabel as nib\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "from glob import glob\n",
    "\n",
    "\n",
    "def get_path(data_path='datasets/'):\n",
    "    '''return all paths'''\n",
    "    tasks = [x for x in os.listdir(data_path) if x.startswith('Task')]\n",
    "    path = []\n",
    "    for task in tasks:\n",
    "        # Paths\n",
    "        path_tr = data_path + task + '/imagesTr'\n",
    "        path_tr_label = data_path + task + '/labelsTr'\n",
    "        imglist_tr = glob(path_tr + '/*.gz')\n",
    "        imglist_tr_label = glob(path_tr_label + '/*.gz')\n",
    "\n",
    "        for i in range(len(imglist_tr)):\n",
    "            path.append([imglist_tr[i], imglist_tr_label[i]])\n",
    "    return path\n",
    "\n",
    "\n",
    "\n",
    "def get_list(path):\n",
    "    '''return all samples in list: [[train_sample],sample_mask]]'''\n",
    "    res_list = []\n",
    "    if isinstance (path[0], str):\n",
    "        train_path, label_path = path\n",
    "        img = nib.load(train_path).get_fdata()\n",
    "        img_label = nib.load(label_path).get_fdata()\n",
    "        if (len(img.shape) != 3):\n",
    "        #    for ch in range(img.shape[2]):\n",
    "            for i in range(img.shape[3]):\n",
    "                res_list.append([img[:, :, :, i] , img_label])\n",
    "        else:\n",
    " #           for ch in range(img.shape[2]):\n",
    "            res_list.append([img, img_label])\n",
    "    else:\n",
    "        for train_path, label_path in path:\n",
    "            img = nib.load(train_path).get_fdata()\n",
    "            img_label = nib.load(label_path).get_fdata()\n",
    "            if (len(img.shape) != 3):\n",
    "#                for ch in range(img.shape[2]):\n",
    "                for i in range(img.shape[3]):\n",
    "                    res_list.append([img[:, :, :, i] , img_label])\n",
    "            else:\n",
    "           #     for ch in range(img.shape[2]):\n",
    "                res_list.append([img, img_label])\n",
    "    return res_list\n",
    "\n",
    "#    for i, el in enumerate(res_list):            \n",
    "#        channel = np.random.randint(el[0].shape[2])\n",
    "#        res_list[i] = [el[0][:, :, channel], el[1][:, :, channel]]\n",
    "#    res = []\n",
    "#    for i, el in enumerate(res_list):     \n",
    "#        for i in range(el[0].shape[2]):\n",
    "#            res.append([el[0], el[1], i])\n",
    "#    return res\n",
    "#    return res_list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = \"../../../../raid/data/decathlon\"\n",
    "folds = \"./Task07_Pancreas/folds.csv\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "#from load_function import get_path, get_list\n",
    "import cv2\n",
    "import os\n",
    "import torch\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from pathlib import Path\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from src.youtrain.factory import DataFactory\n",
    "from src.transforms import test_transform, mix_transform\n",
    "from tqdm import tqdm\n",
    "from albumentations.torch import ToTensor\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from torch.utils.data import Sampler\n",
    "import gc\n",
    "import json\n",
    "\n",
    "class BaseDataset(Dataset):\n",
    "    def __init__(self, path, transform):\n",
    "        self.ids = get_path(path + '/')\n",
    "        self.transform = transform\n",
    "#        print(len(self.ids))\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.ids)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        raise NotImplementedError\n",
    "\n",
    "\n",
    "class TrainDataset(BaseDataset):\n",
    "    def __init__(self, path, folds, transform):\n",
    "        super().__init__(path, transform)\n",
    "        self.folds = folds\n",
    "        self.ids = [el for el in self.ids if el[0].split('/')[-1] in folds.ImageId.values]\n",
    "\n",
    "    def get_rectangular(self, img):\n",
    "        if not img.sum():\n",
    "            return 0, 32, 0, 32\n",
    "        x, y = np.where(img)\n",
    "        x_min = min(x)\n",
    "        x_max = max(x)\n",
    "        y_min = min(y)\n",
    "        y_max = max(y)\n",
    "        return x_min, x_max, y_min, y_max\n",
    "\n",
    "    def crop(self, img, crop_boundaries, margin=5):\n",
    "        x_min, x_max, y_min, y_max = crop_boundaries\n",
    "        return img[min(0, x_min - margin):max(x_max + 1 + margin, img.shape[0]),\n",
    "                   min(0, y_min - margin):max(y_max + 1 + margin, img.shape[0])]\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        name = self.folds.iloc[index].ImageId\n",
    "        slice = self.folds.iloc[index].ch_number\n",
    "        name = [el for el in self.ids if el[0].split('/')[-1] in name][0]\n",
    "\n",
    "        gl = get_list(name)\n",
    "        image = gl[0][0]\n",
    "        mask = gl[0][1]\n",
    "        image = image[:, :, slice]\n",
    "        mask = mask[:, :, slice]\n",
    "        pancreats_mask = (mask > 0).astype(int)\n",
    "        cancer_mask = (mask == 2).astype(int)\n",
    "        crop_boundaries = self.get_rectangular(pancreats_mask)\n",
    "        image = self.crop(image, crop_boundaries)\n",
    "        mask = self.crop(cancer_mask, crop_boundaries)\n",
    "\n",
    "        # mask = mask[:,:,slice]\n",
    "        # ch1 = (mask == 0).astype(int)\n",
    "        # ch2 = (mask == 1).astype(int)\n",
    "        # ch3 = (mask == 2).astype(int)\n",
    "        # mask = np.stack([ch1, ch2, ch3]).transpose(1, 2, 0)\n",
    "        # print(image.shape, mask.shape)\n",
    "        return self.transform(image=image.reshape(image.shape[0], image.shape[1], 1),\n",
    "                              mask=mask)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.folds)\n",
    "\n",
    "class TestDataset(BaseDataset):\n",
    "    def __init__(self, image_dir, ids, transform):\n",
    "        super().__init__(image_dir, ids, transform)\n",
    "        self.transform = transform\n",
    "        self.ids = ids\n",
    "        self.image_dir = image_dir\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        name = self.ids[index]\n",
    "        image = cv2.imread(os.path.join(self.image_dir, name))\n",
    "        return self.transform(image=image)['image']\n",
    "\n",
    "\n",
    "class TaskDataFactory(DataFactory):\n",
    "    def __init__(self, params, paths, **kwargs):\n",
    "        super().__init__(params, paths, **kwargs)\n",
    "        self.fold = kwargs['fold']\n",
    "        self._folds = None\n",
    "\n",
    "    @property\n",
    "    def data_path(self):\n",
    "        return Path(self.paths['path'])\n",
    "\n",
    "    def make_transform(self, stage, is_train=False):\n",
    "        if is_train:\n",
    "            if stage['augmentation'] == 'mix_transform':\n",
    "                transform = mix_transform(**self.params['augmentation_params'])\n",
    "            else:\n",
    "                raise KeyError('augmentation does not found')\n",
    "        else:\n",
    "            transform = test_transform(**self.params['augmentation_params'])\n",
    "        return transform\n",
    "\n",
    "    def make_dataset(self, stage, is_train):\n",
    "        transform = self.make_transform(stage, is_train)\n",
    "        folds = self.train_ids if is_train else self.val_ids\n",
    "#        print(self.data_path)\n",
    "        return TrainDataset(\n",
    "            path=str(self.data_path),\n",
    "#            mask_dir=self.data_path / self.paths['train_masks'],\n",
    "            folds=folds,\n",
    "            transform=transform)\n",
    "\n",
    "    def make_loader(self, stage, is_train=False):\n",
    "        dataset = self.make_dataset(stage, is_train)\n",
    "        return DataLoader(\n",
    "            dataset=dataset,\n",
    "            batch_size=self.params['batch_size'],\n",
    "            shuffle=is_train,\n",
    "            drop_last=is_train,\n",
    "            num_workers=self.params['num_workers'],\n",
    "            pin_memory=torch.cuda.is_available(),\n",
    "        )\n",
    "    \n",
    "    @property\n",
    "    def folds(self):\n",
    "        if self._folds is None:\n",
    "            self._folds = pd.read_csv(self.data_path / self.paths['folds'])\n",
    "        return self._folds\n",
    "\n",
    "    @property\n",
    "    def train_ids(self):\n",
    "        return self.folds.loc[self.folds['fold'] != self.fold]\n",
    "\n",
    "    @property\n",
    "    def val_ids(self):\n",
    "        return self.folds.loc[self.folds['fold'] == self.fold]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "ab = TaskDataFactory(path,folds, fold = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'TaskDataFactory' object does not support indexing",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-110-e5b8256364dc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mab\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'TaskDataFactory' object does not support indexing"
     ]
    }
   ],
   "source": [
    "bc = ab.make_dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(246, 277, 272, 308)"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_rectangular(img[:,:,45])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        ...,\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        ...,\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        ...,\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.]],\n",
       "\n",
       "       ...,\n",
       "\n",
       "       [[0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        ...,\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        ...,\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        ...,\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.],\n",
       "        [0., 0., 0., ..., 0., 0., 0.]]])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img[250:, ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1024., -1023., -1022., ...,  1127.,  1138.,  1195.])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(img[:,:,45])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fcfa30c0128>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(img[:,:,45])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['pancreas_316.nii.gz', 'pancreas_355.nii.gz', 'pancreas_246.nii.gz', 'pancreas_409.nii.gz', 'pancreas_040.nii.gz', 'pancreas_380.nii.gz', 'pancreas_399.nii.gz', 'pancreas_278.nii.gz', 'pancreas_289.nii.gz', 'pancreas_225.nii.gz', 'pancreas_066.nii.gz', 'pancreas_181.nii.gz', 'pancreas_267.nii.gz', 'pancreas_310.nii.gz', 'pancreas_344.nii.gz', 'pancreas_419.nii.gz', 'pancreas_129.nii.gz', 'pancreas_166.nii.gz', 'pancreas_401.nii.gz', 'pancreas_001.nii.gz', 'pancreas_087.nii.gz', 'pancreas_413.nii.gz', 'pancreas_421.nii.gz', 'pancreas_416.nii.gz', 'pancreas_318.nii.gz', 'pancreas_309.nii.gz', 'pancreas_159.nii.gz', 'pancreas_084.nii.gz', 'pancreas_106.nii.gz', 'pancreas_256.nii.gz', 'pancreas_298.nii.gz', 'pancreas_209.nii.gz', 'pancreas_204.nii.gz', 'pancreas_015.nii.gz', 'pancreas_389.nii.gz', 'pancreas_312.nii.gz', 'pancreas_010.nii.gz', 'pancreas_052.nii.gz', 'pancreas_342.nii.gz', 'pancreas_180.nii.gz', 'pancreas_200.nii.gz', 'pancreas_170.nii.gz', 'pancreas_339.nii.gz', 'pancreas_124.nii.gz', 'pancreas_157.nii.gz', 'pancreas_361.nii.gz', 'pancreas_303.nii.gz', 'pancreas_277.nii.gz', 'pancreas_158.nii.gz', 'pancreas_286.nii.gz', 'pancreas_293.nii.gz', 'pancreas_308.nii.gz', 'pancreas_230.nii.gz', 'pancreas_334.nii.gz', 'pancreas_300.nii.gz', 'pancreas_207.nii.gz', 'pancreas_029.nii.gz', 'pancreas_283.nii.gz', 'pancreas_210.nii.gz', 'pancreas_018.nii.gz', 'pancreas_089.nii.gz', 'pancreas_365.nii.gz', 'pancreas_326.nii.gz', 'pancreas_229.nii.gz', 'pancreas_329.nii.gz', 'pancreas_130.nii.gz', 'pancreas_140.nii.gz', 'pancreas_357.nii.gz', 'pancreas_126.nii.gz', 'pancreas_301.nii.gz', 'pancreas_382.nii.gz', 'pancreas_127.nii.gz', 'pancreas_296.nii.gz', 'pancreas_354.nii.gz', 'pancreas_064.nii.gz', 'pancreas_268.nii.gz', 'pancreas_092.nii.gz', 'pancreas_231.nii.gz', 'pancreas_105.nii.gz', 'pancreas_103.nii.gz', 'pancreas_348.nii.gz', 'pancreas_366.nii.gz', 'pancreas_104.nii.gz', 'pancreas_242.nii.gz', 'pancreas_155.nii.gz', 'pancreas_061.nii.gz', 'pancreas_075.nii.gz', 'pancreas_096.nii.gz', 'pancreas_211.nii.gz', 'pancreas_193.nii.gz', 'pancreas_259.nii.gz', 'pancreas_255.nii.gz', 'pancreas_175.nii.gz', 'pancreas_274.nii.gz', 'pancreas_125.nii.gz', 'pancreas_275.nii.gz', 'pancreas_369.nii.gz', 'pancreas_083.nii.gz', 'pancreas_387.nii.gz', 'pancreas_201.nii.gz', 'pancreas_215.nii.gz', 'pancreas_212.nii.gz', 'pancreas_405.nii.gz', 'pancreas_219.nii.gz', 'pancreas_048.nii.gz', 'pancreas_081.nii.gz', 'pancreas_265.nii.gz', 'pancreas_372.nii.gz', 'pancreas_358.nii.gz', 'pancreas_375.nii.gz', 'pancreas_392.nii.gz', 'pancreas_388.nii.gz', 'pancreas_400.nii.gz', 'pancreas_043.nii.gz', 'pancreas_120.nii.gz', 'pancreas_025.nii.gz', 'pancreas_228.nii.gz', 'pancreas_411.nii.gz', 'pancreas_398.nii.gz', 'pancreas_035.nii.gz', 'pancreas_234.nii.gz', 'pancreas_395.nii.gz', 'pancreas_297.nii.gz', 'pancreas_313.nii.gz', 'pancreas_379.nii.gz', 'pancreas_376.nii.gz', 'pancreas_042.nii.gz', 'pancreas_012.nii.gz', 'pancreas_391.nii.gz', 'pancreas_393.nii.gz', 'pancreas_305.nii.gz', 'pancreas_374.nii.gz', 'pancreas_004.nii.gz', 'pancreas_021.nii.gz', 'pancreas_414.nii.gz', 'pancreas_078.nii.gz', 'pancreas_367.nii.gz', 'pancreas_122.nii.gz', 'pancreas_279.nii.gz', 'pancreas_019.nii.gz', 'pancreas_295.nii.gz', 'pancreas_270.nii.gz', 'pancreas_032.nii.gz', 'pancreas_247.nii.gz', 'pancreas_386.nii.gz', 'pancreas_199.nii.gz', 'pancreas_243.nii.gz', 'pancreas_045.nii.gz', 'pancreas_024.nii.gz', 'pancreas_315.nii.gz', 'pancreas_239.nii.gz', 'pancreas_253.nii.gz', 'pancreas_077.nii.gz', 'pancreas_194.nii.gz', 'pancreas_172.nii.gz', 'pancreas_222.nii.gz', 'pancreas_093.nii.gz', 'pancreas_113.nii.gz', 'pancreas_005.nii.gz', 'pancreas_088.nii.gz', 'pancreas_276.nii.gz', 'pancreas_173.nii.gz', 'pancreas_050.nii.gz', 'pancreas_336.nii.gz', 'pancreas_235.nii.gz', 'pancreas_098.nii.gz', 'pancreas_224.nii.gz', 'pancreas_285.nii.gz', 'pancreas_114.nii.gz', 'pancreas_377.nii.gz', 'pancreas_069.nii.gz', 'pancreas_244.nii.gz', 'pancreas_086.nii.gz', 'pancreas_046.nii.gz', 'pancreas_290.nii.gz', 'pancreas_049.nii.gz', 'pancreas_360.nii.gz', 'pancreas_343.nii.gz', 'pancreas_412.nii.gz', 'pancreas_261.nii.gz', 'pancreas_037.nii.gz', 'pancreas_214.nii.gz', 'pancreas_119.nii.gz', 'pancreas_266.nii.gz', 'pancreas_258.nii.gz', 'pancreas_186.nii.gz', 'pancreas_378.nii.gz', 'pancreas_333.nii.gz', 'pancreas_325.nii.gz', 'pancreas_135.nii.gz', 'pancreas_148.nii.gz', 'pancreas_328.nii.gz', 'pancreas_415.nii.gz', 'pancreas_350.nii.gz', 'pancreas_101.nii.gz', 'pancreas_236.nii.gz', 'pancreas_320.nii.gz', 'pancreas_292.nii.gz', 'pancreas_346.nii.gz', 'pancreas_323.nii.gz', 'pancreas_191.nii.gz', 'pancreas_269.nii.gz', 'pancreas_364.nii.gz', 'pancreas_056.nii.gz', 'pancreas_321.nii.gz', 'pancreas_404.nii.gz', 'pancreas_218.nii.gz', 'pancreas_241.nii.gz', 'pancreas_111.nii.gz', 'pancreas_280.nii.gz', 'pancreas_006.nii.gz', 'pancreas_254.nii.gz', 'pancreas_109.nii.gz', 'pancreas_362.nii.gz', 'pancreas_356.nii.gz', 'pancreas_074.nii.gz', 'pancreas_299.nii.gz', 'pancreas_294.nii.gz', 'pancreas_110.nii.gz', 'pancreas_183.nii.gz', 'pancreas_227.nii.gz', 'pancreas_196.nii.gz', 'pancreas_203.nii.gz', 'pancreas_137.nii.gz', 'pancreas_149.nii.gz', 'pancreas_402.nii.gz', 'pancreas_051.nii.gz', 'pancreas_179.nii.gz', 'pancreas_028.nii.gz', 'pancreas_138.nii.gz', 'pancreas_169.nii.gz', 'pancreas_165.nii.gz', 'pancreas_041.nii.gz', 'pancreas_100.nii.gz', 'pancreas_345.nii.gz', 'pancreas_055.nii.gz', 'pancreas_304.nii.gz', 'pancreas_327.nii.gz', 'pancreas_071.nii.gz', 'pancreas_197.nii.gz', 'pancreas_099.nii.gz', 'pancreas_330.nii.gz', 'pancreas_406.nii.gz', 'pancreas_091.nii.gz', 'pancreas_198.nii.gz', 'pancreas_117.nii.gz', 'pancreas_351.nii.gz', 'pancreas_182.nii.gz', 'pancreas_410.nii.gz', 'pancreas_102.nii.gz', 'pancreas_385.nii.gz', 'pancreas_067.nii.gz', 'pancreas_160.nii.gz', 'pancreas_287.nii.gz', 'pancreas_226.nii.gz', 'pancreas_302.nii.gz', 'pancreas_178.nii.gz', 'pancreas_262.nii.gz', 'pancreas_058.nii.gz', 'pancreas_291.nii.gz', 'pancreas_213.nii.gz', 'pancreas_070.nii.gz', 'pancreas_311.nii.gz', 'pancreas_187.nii.gz', 'pancreas_145.nii.gz', 'pancreas_217.nii.gz', 'pancreas_284.nii.gz', 'pancreas_331.nii.gz', 'pancreas_080.nii.gz', 'pancreas_370.nii.gz', 'pancreas_249.nii.gz', 'pancreas_147.nii.gz', 'pancreas_264.nii.gz', 'pancreas_095.nii.gz', 'pancreas_107.nii.gz', 'pancreas_016.nii.gz', 'pancreas_167.nii.gz', 'pancreas_094.nii.gz', 'pancreas_418.nii.gz', 'pancreas_131.nii.gz', 'pancreas_347.nii.gz']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Paths\n",
    "path_tr = path+'/imagesTr'\n",
    "path_tr_label = path+'/labelsTr'\n",
    "imglist_tr = glob(path_tr+'/*.gz')\n",
    "imglist_tr_label = glob(path_tr_label+'/*.gz')\n",
    "imglist_ts = glob(path_ts+'/*.gz')\n",
    "print('num_train = {}, num_test = {}'.format(len(imglist_tr), len(imglist_ts)))\n",
    "print('Image dimensions:')\n",
    "print('Train:')\n",
    "\n",
    "# Dimensions\n",
    "for img_name in imglist_tr[:5]:\n",
    "    img = nib.load(img_name)\n",
    "    print(img.shape)\n",
    "print('Test:')\n",
    "for img_name in imglist_ts[:5]:\n",
    "    img = nib.load(img_name)\n",
    "    print(img.shape)\n",
    "# Find number of sub labels\n",
    "\n",
    "# Images\n",
    "for i in range(3):\n",
    "    img = nib.load(imglist_tr[0]).get_fdata()\n",
    "    label = nib.load(imglist_tr_label[0]).get_fdata()\n",
    "    print('Image Min-Max values: Image={},{} and label={},{}'.format(img.max(), img.min(), label.max(), label.min()))\n",
    "    print('Number of subclasses = ', int(label.max())+1)\n",
    "    print('third dimension i = {}' .format(i))\n",
    "    if task=='Task05_Prostate':\n",
    "        ax = plt.subplot('131')\n",
    "        ax.imshow(img[:,:,i*5+5,0], cmap='gray')\n",
    "        ax.set_title('Image channel 1')\n",
    "        ax = plt.subplot('132')\n",
    "        ax.imshow(img[:,:,i*5+5,1], cmap='gray')\n",
    "        ax.set_title('Image channel 2')\n",
    "        ax = plt.subplot('133')\n",
    "        ax.imshow(label[:,:,i*5+5], cmap='gray')\n",
    "        ax.set_title('Segmentation Mask')\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "folds = ['pancreas_100.nii.gz']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds = TrainDataset('../', folds, pre_transform(256))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f299f22cf98>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQYAAAD8CAYAAACVSwr3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzsvVnMbNl1Hvatvc9QVf/836Hv7ZFNcWqKlIgmRVnW4CSyKVlKIjmAHSsPcYIEAgIFCJC86C2vefaLAT0YkV8SBAEMG4qCwBFsOEEgxFKiMbREiiKbzR5u3+mfajjn7L3ysIa962/KpLrvZd/L/jdwb/1Vdc6pU6fOXnutb33rW8TMuBpX42pcjXqED/oErsbVuBpP3rgyDFfjalyNd40rw3A1rsbVeNe4MgxX42pcjXeNK8NwNa7G1XjXuDIMV+NqXI13jcdiGIjoZ4noT4joq0T0q4/jM67G1bgaj2/Qo+YxEFEE8KcA/gaA1wH8KwC/xMz/3yP9oKtxNa7GYxuPw2P4IoCvMvPXmHkA8D8C+IXH8DlX42pcjcc0msdwzOcAfLN6/jqAH/037dBRzzPsPIZTuRrf9SD9j1n/3npDX5f3iQhsr9Wb6VMKAZzz1mtX44MfZ3hwl5lvfDfbPg7DQN/mtXfdHkT0ywB+GQBmWOBH6acfw6lcjcsj7O2BiIAYwdMkL6YETgnIDASSic8MHuX90LXImw3CYoF8cYGwWMj2KQEAOCWE+Rx5uQQ1cksxT0CIoBjB0whQAAUCKIBTAsUIcC7ncDUe+/jf+X/+xne77eMwDK8DeKF6/jyANy5vxMy/BuDXAGCfjq/WlccwqO2AIHaaiIAQwOsNGADFAIQA6nsgBhBaMQwAeBhk4gI++f3vEMHjBGobZH1ESkDOQNB9KLhRkAMywAk035FtOYtRyCzbtQ14sxGPxLa/Gh/oeBwYw78C8HEiepmIOgB/F8A/fQyfczWqIUYg+mPY2wM4g7oOPE5gZlnNA7mx4JTAmw14vUFercux5nOEg32ExQKIETTrZbIDYggADSuyTH4K4JTdEPAohoXHQTwLnfB5tQYn8RI4MyiQeBG6DXUdqGnlOxAhzGagtnMv5Gp878Yjv+LMPBHRfwngfwMQAfxDZv7jR/05VwOy2qcE6nvk1VomY0oIXauTLQBZJ2xm8DDIY0qgrpWQwVb9YZAJOwxiDKYJyBmh78VQ6HZ8sRLDYsePUSY3IJ6AfhYAUNOIAWhaIJB4BWZYOIOaHsxcvJKUisGojUzT+LHE27jyKB73eCymmJl/E8BvPo5jf9hHWCw89qcYHSugtkHY39cJ18gKHgjIDNolYLWWEKFrgQGgrkNeLn1fzgwMg0z2lNyI5GmJ2DYCOu7sIMQIjBPQtYjTBB5GDR0IQHT8AoAYjQjwOCHEFhwieBgQZjPkzQYI8lmynRoUHsEJCnaKl8KZFZMYHedwLOMKo3gs48pHewpGvHYMHkbk83MAAE8jQt/LhFrMZXUfJ/DFBUCEPE0OJNoqHLpWMIWuAy0WoFkv+0EmLkWN9QdZoQV8HARTuFiCmZEfnogh4AxsokxOIoSDPSBlOdmUxPuwVT0lOa6GGjxlcJJVPy+Xgkuw7EsxSuiz2bg3ZECnvVYbAlbMwzwl5AoPuRrva1wZhid0UN/Lah+DPM5maHZ3wOOI2PeAxd3ThHx+IROwaYorX+EIoIA8jDJBl0uZcAf7oPlMJttmo/tlDTM6j/sBWZWp6wCWMAQAiBg8jLL9NHkmIywWoIN90GYjn3t2Jtu3jRsgAOVcgS1DQERA0xSAc70puAYEGAVJdgM8gRrJelDTivekGQ8eh+/J7/T9Oq4MwxM2qGnczQ+LBQCAVyu56UMoLvTFhU9iaiRD4CnDGGQy22TrOp/Qhg3weiOrfyDE4yM55nojEzpGNTSt7MO5hC+WQdDUo+MXYPA0Its5dS0QA8Lenkx8O+9x2gp3EARkZPU48jACWY2ceRvqxcgJBPEMuGRBzGOgtgHGBLQNqO2ujMP7GFeG4QkYza1nwJvBeQB5tdY0YpQJnBIoTP6c2kZAxa4D9R2obRH2doHFHPHoANxEhNUGPO8RhlE+hBkYRnDO4OVKsYAEThn5wUM59maDcHTk5xV2d8BTEiOQGayxfYakP/N6/W7MgwJ4GPw1AAgHe+DVWowFCQgpoYVkMxjiiYRZL/hFjP6ZDnJCPAvnUFR4hOEPdboVFNzjoaa9MhJ/yXFlGD7AEWYzjeVHXekjeBgLEDfKpA7zGfLFBeLREXCwi3y4g/Uzc6yPIqYZYdwjMAG5AzjIYxiA1ANhBDjKcwCIAxBXQBwY3TmjfzChPRsRlyPiW/cAALxcIV8sxVOh4K48NY2Ajou5hDInp6DZDPzwBNS17oEgoRClUgav1uJlAAh7u+Cuk2OHIAYrM5BTwTdSLuQpzURQI/hCXq3KRFcOBIwwZYMCQtdukbRAVabjCrD8juPKMHwAI+ztCXfA4v6LZcnlWxgwnyPs7mD4gVu495k5ph3C5phBCaBMQAaIIY9ZDEIcACYgbPRzBiCOYiBs5AaYjgGAcBEJNHXg2CH3DPABOAKUgDARwgboToHZg4z2ImPxrSXC6Qp8cgas1+K9EIG6FmF/z7MMnDIwSeaCLHW5uyN4yMVSMhPzmYCnKQnPwkIeNw56wjyW9CSReAxmZLpWDE+NKxhnwkBSAGDaMhye+rwCK//CcWUYvocjHh0hn52JqxsIxJI1yClJliGI+xtvP4O7P/kslrcIqQOmHUZzDrRn4hmEBOQohoEJAAFhEgMBUkNBEPoaAzSJ55A7OQ9SY5IhhgMjkDKV142wGID1NWB9IyA3BHp1Hxz20J0+g/4+Y/fNCbM3lwiv30G6/6CkKkNwXASZC/DYNqC9XQkpAPBqLZN9b1czFpNnHihq+DCyvxb6XjyqppFMhYKhDmi2nV9rnkYPbQAUjAUaekBB1Ka58iC+zbgyDN+D0bz8ksT3Z+cIuzuCIRCBo+T9eZpAsx780rO4/0OHuHiWMO4yiBlxRWjOZdKGEUjd9rFDEiPAQUIGDvKcshgEQIwGN8UgsBoMcNmXdHEFq7GAvr4BQEBuCCEBqSWkGXD2EeDs5QbAPuLqALN7jJ07Gbt/dopw9wTT+blMZF3dOSVJs2ZJV4bDA9DeLni5Qrr3QIzGfKaUaVbORQfqezEa5nnEICzOriuYgvIcjAzlw+oyAhViVJUetfO6Mg7vHleG4TGOzc//CHZ+71sAJK5lZvBq4+8TEcLhAVavfhb3P9ViOGSEgUAJaNUY5KZM2tTp3xXxj9VbSJ1su1XlyGIsbDsAQFSPo5FHP5dUGRcun2PGxo5BGUAGmkkOGDfAtAA2x4T1jYg7rx4COATwEhZvEhZ3Eg5+7x3E+w+RT8+RNxvBCDQUCTtzkPEgMiOvBNCEGUwiZ2MiBMEYuso6WgZDsxSe0ZnNJJxARZCqR9bQrWk13SnGISwWwq/4kI8rw/CYRvORF5EuEtBEcAxeaMSbDcKOlJiH68f41r//Apa3GWFiNBfkE5sYXqdKvO3ie7gQdHPS7XUimxdBZgAmAFENRyrH9WNVhiS1sh9QQhPfNAG5ep9DORdK8vntQG5I1teA5a2A+5++hfb8Fg7+PGH/d98APzgRD2IckC8gtRgAwv4eYt+B12shYIUFWHkQAJDXG/FCNM0JzhI+sOIMTStGBMq9qGtCcnCgkjN7gZlnMAAhh61W7/EX//4aV4bhEQ9qO9CsR95doL2/lFUpc9EvIAK1DTavfgx3f7jH+jqLd5BkUlMuq3YYAVThAcztnwCEyjjUXsJUtg/jthdRT3gPJyB/hyxPw1TCi6DAJWU1Nk05hr2XjV6QgDQDmhUAA0M3ADEhjMC4C9z5fMDdz7yA2d0XcO3La3T/758hnZyCkmAQab1B2N2RjAczsNmAdndAwyiufmYtwhJCk9WIhFkvdG5UoYGmOYVNKRWhyEqzzuKBCKeCQZHcsIBzwSU+xCnOK8PwiIZVIiJnhP09XLy4h50v3wEA8N375b3PfhLf+PljTAtGGIH2lCS9OAFIZcKagSBWoDEV9z51koGgDExz2c9W+zAJyEhTCRds8oZRVnx7bis+h/LZuZEJnRts1d46dqGeiXkK8qYef6gwC93G0qTNCuC1fNfNEfCtvzZD+plPY/424fjLI+a/8zXks/MtN56aRsrBuxYYBjG4F0vBHpR3QTEWdqSRt7Rwi9pGPADFFjzjo16GnLTUm5hjJGCmehxN4zjFhy2DcWUYHsGIhwfKPwgyR7oW07zMKh4G0N4ehr/6g3jncz24Aboz8syCueGGBxg2EEbIBFT3PxtISLqSJ12p221PgwkILCu8TWiOcLCRUHADkLyWY/l8Nyz63LIgHNQm5GJUiLcBUXvPDFywDIldK4NYRoAmwvoa440fbzD/xCdx/Q/X6P/0LaS37xQK9vkFaGcBms+FQxED8sUKnA1ZJYS2rzwEveZa8k1N65kLxzem0b03LxrLDMtUmJ4EKJRtQ/xQGYcr+fj3OUh5/TwMgJYHrz96HTvfWoFjQH7nHsLhAZY/8hG88VM9xl2N1RULSC0AlhX6cnZAsgEocX6oDAbL/iGVbEPQbIIbGktjKmYRUsErzKgga/gQL2UtoJ8b5BxzW577YD1n82bMiKEYA/tOjo9YJkRDneaC0F4QVjcYr32px2u/9BGEH/gIoJ5AHkYhSGm1J+3uinegJd5kIYEJwABiLBaLoh7FuVC4uxZgRpjN5CtamlS1IZw+npMbBfMwqK8IId/n48pjeI8jzGZyE1npcYxC6rl5HWHKiA+WoIsV8OKzeOeL13HyMaBZFg/BDIFNbEB4BUBZ/bOu8jZoqoDCXFz7LV4DgDiVDEZ9jK3j6eScdtm5EVtZiIWe31SFBgByy6CRCr7hxoTADSN35AaJCbII15mN6hxIcRRugO6UkBsxQF/9T24gDDdx9K8zDn/jj4VIFYPUh5ydSZGWFo+ValAqRiKzeBScC1ipqc28XJaMhxmOSnlKjteq0ZHQw1iWsg19KCjWV4bhPYwwE9YeM6sQiioY7ezg/JPXsPsHb8qG8xnu/MR1nL8AxI0i5EEncQUAekqxWlVRg4f2cigr8tZrheAnBgWynYGFYQKSuv5gYNxhsNZH5ca4ACSZi5ZBk0xyGmWSm2cAQF6z8wyyf5gIU8PKmmSwHjNMAqqGDcm2VQbD064W6jQlm9KeSmbj3g8T1kefxa3/8z7w598S+TgAWK2Bvkc4PACfnCKv16C2Qx6ELm3kKEAn9lT0JxGkKMte80Iwy1AAzn3IG9WqNKakYRjT+H1fpHUVSvwlR9hT6i+gOoeinRh25hhevqmTmoDNgDd/5jbOXgLCQAIWGp6guxuGECyFWHsHFWhYMxuZSgqSKre87Lh9DJvU3AguMS0Y0y7763FDoImQO/EcaCJf7S00CVV4YN+BIMemSRWjCeDISqwihEkwlNwAac5Is/Jv2mXkTryD1BaQNbXl88IkBmL5HOPr/8Ex7v+tz2gVpQrIcgapvoRVobpR0N8nD+PW+wC8atRYkhQIPI2lEKxp9bVSGGaqUvZcLkYhSX0/jiuP4bscloZEzvJPCTdSKJSw+fzHQJmx+7uvId84xJ2feQ7L2xJDG1EpDKXAyTIAMO4AC3I/zSXkmOZw0hFQsIZmBUyzSwQlqlZ0fS13kMluXknwTcV7MRJThqDwMCBRrE2YCLkqwvIsSYYI9pWsnuybgJjIgVKYAJN9thkw9RKmGRei1QTwQJJqjVXIlJQGHoDTlwmn//VncPSvM47+j9eQ790Ht61Ul/Y9sF5LHYaVam82UqRWlYv7im+aElaurfoTnAtT0jMS4yCU7GHwsMRDCQMvge87YPLKY/guRtjbE8quchBsRTI6MwBsDht0dy6ApsHdzx/h/AVhLwIlZPAWDRq724S2+D71QkeeZu8OGcwFn2Z6DMs4GMdBR26ETzDNWTIJChjmjr3oKrdGYChYBk3kXAkEMV7mobhXQhIuOAVbQwlu2Cd/7rFFyQ4KcoahhDWwlhN6XSSFykhzFpyhAmLNmMSNPN79YcI3/+5HEJ654RWYNOtBfYcwn5Xfqe+9SA2ctyXncvLwoa64tG3ZshRKoDLVbMMbxPh0hYFZaUN8v4wrw/AdRpjNvPJRinbEhTSxEupahJvXsXhzDUwJ6ZlDnHwciCsqSDwUP6iyBE5WMiDdqwl18kAmDIftY4SkLn61n2UduAHGvRLjc8PIMwUXlcLM6qWAigtPufAiLFMBVClM5S5QVnfaz7/kP4nF4OSWQdW55xaCIzTqkfTbBscMSO7kmLVxMADVQ5sB6E4kxfnaf/gCplc/Ad4MUrClpdqeZVAjntcbx4NE/HaQSW0eRM1nsIIsxR3YhHNVsMak5ACIx2CGSd+vi7ie9nFlGP6CEff3XS/BlJZ5vXEJtbBYCNIdI975qWfR3LtAOpjjGz+3j2ZFPrnr9J9NhhyVpLQpK35WwwGU9yhpQVNVu5Ba8Qjs2OZZjPsSv9uqbtiBFVJxYP+7HjmKAfFjTgoUKjfCjU7L4KgGByU8oCRGkJWbTRmgsXrfmJihGCJ7ROWhEJshURxih5F7FhxiVqVltY4kN8A3fm6OO//RZ4DjQyE7HeyDFnMJAWolaW+MI8pRFEMBIIFSjGWiMBV+4I1xshZucZHJd+ASJSwB0feF93BlGP6CwcylF4PHoq0g1Ca1nhKmT72I/iyDZy3e+rE95xnUZCUHHQFfXevYvc4qAMpebKs0ZFVObft6KpKAcZeRerm5bVXPLYuHMuqKnhQzGGQbUpeeo2QNDKisJ3ONcYSRgEz+mU6vNpZmK5gBTeSeDVB5PFmMEwd278JwB66/+0DOmUg9XB9iq6pUPZj2jHDxHPD1v/MM1j/5aVCrHIXdnUp1WsEQ8w4UwESMrpIF4zCoETDjUNdaGNPS32u7wpFgoWkDxZA87ePKMFwaze1b3sbNKvUQgpRFm6qy3ViLBS6em2HntQs8+MwBVrcYcY2tSZZjwRMoq2uN7fjaSUdOZKhOSEOO1Km7XlcVG5LPmhIEBEPQmN+xDfU2nB/RMHIPWakVLHR8oQ5xdAUXApZYODtHwwjME/BaDNLvWGEqnm1hciyDkk66OtxSzyEOcs6kn2vfOXclvDCj2iwlo/Ktf7vF8PJN0HyumEMvZd7zOVwYV1OOIo2nXoLVUAAy6atWevL+4DUUtWR9zao0ToSTrjpp+vM0ew5XWYlq8I9/DvyHXxOEGoA1XJFMBPuNQTNBqVc/9Sl0p7I03v9BQnsqq3PS2gfPHBg5qIEj7japmnXJThjTMaTK46hASCaZNNNCjj/u8LYRahhxQ8g6Iy97KUZOigMpfiAcBDbPYSiT0yopbQWnRMX1V+MQNwRkATqthsL4E1ul4VG4EWZsOLB4NgwgMEDCmwgjbZWZcwC4l1AHBLQnVAxXKgYirghxBXzj52cIw4u49dsTdv74LcSmAa/XImefGWE+K011AKkxMdn8cXJCU52NIO2ZwRupsaAIaZpjHggFgFNprKOGAoATr57GBjlXHoOO8UtfQPP2yVZLNVSItZNfmIFR6vcvbjbo767wzqt7TmCqsQWgrPYcCxfBVu9gsbiBebboxzKpbaK6nmOr+5GCfcpPEI9E6y9QxfK68jLUzW/Z52wYzX8HEASbyJ1mHjQl6d+l9jwAp3VLBoMQrNxajVA9PMOgoCglKpwIMxCZqu+qYdBQrk02HKSGDnpsZWTaE7mIb/5Yg+Urt0CLGcLBPhAjws5CGKqWngRgqUseJyCQNMHRYSrVPAoVewt0VFDS5eGIEGa9ZCx0AaG2K5gFVSf5lIwrjwHA+Nc/j/VRg9mDE189kDPQtqVfQ52ibFuE40PsvjFic32O8xeB7kTjYI3/LSXpE1l5C1vaCrY6BiBfokeb92A1DU5BngSMc2ZiLMaoTodyENGX3KlnMOoETLo6T7La544dPzDjYXJwMPwhqzcRy/lRBkIn3y3NSjpx3OeCn3iJNpWqTJQV3+pF2MhRg3o6ypjkADQrwjRjwUjcYBRMxDEOBXGbpZR4v/HjDY6uP4dr/9dbCHu7yA9P1OMLWyBjUC0IrjIShhFwZhd8CV2LvF5vbwsAQTCovFptVW1ulXEjuhfytIwPvWG495//GOb3M47+7zdF8WccJVRQ98/qIQCI+9i1oNjgzk8/j/2vD3jjJzvEFZyP4ClAxla60gwEuOAONZBHNlnMeEwlZk+d7BcHzfm3Vaxv3gbU4PQlXEi9HaviU2Q4B4KgnsFU0ZHPK/KTHZ/L364HGYvhM8ORW6B7SFs1FNNCjQyJyz8tWBZQTXdyIg9pBJORMMNCCg6M7oSEPdmVdCeALXDUUp8cBXfgADz4JPDwE7fxkX+yg3B0AH7jbcGLgKIpOdSsR8MQJESgCFeByoPWVFhPCzLlp7YoUQcCj8p/0GbClsXgaRTP4SkJKz7UocTqF78IDsDenzwE31MxU5SbhQft1qxsR3M7N597GfN7Cfdf6Uv1oMbVXuZsV1bBuFgtFjZB/W/db2vFN5NdhQQc1X0OFWMwcqEkNwAy6SrOW8xIASTZ8UAxQqIpGdfyr1mSZzzsPGpDYBwLC22mOSMthJiU5kJueldtRy7/4iDFUs05Ia5IPImsHsWkxx+psDdboU6nuRgLC2mmBft1cYJUVz7bPqtZiUf12s8eYHj+EOH6MazegnZ2JMTY31NgeZRM1CR9LYTIJlwI6QGq2pFac0Ex4F0synFy4NJCT2FLWlxYQpInfXxoDUP8+Edx75UGzQrIX/16+fHa1tvFE5HQoNvS95E//VFc3G7R3x9Fks0mklGOdQKXNJ+mFw39N8+imkDuTVQhiG1vuXtfnS1NCDUYk4i0mrGJG5lIBbAAnJzEpAAmoT0j9PcCulMSmflVWYHrTAmALTVqDlpzsZPBrVCoOQDDPmOaMaY9xuZaxrjLGPfYqdzGmLSwKG4EE2jPxFDUcnXODJVTxzRXCvUEtBdiOMZ9LgDtpGlYW4ypXKtG2aff/Os9Xvs7L4CeuyVG/uwctL8HzHqEg32E3V1vEows/Sje1VKvylhI4VZTUppaT+GitUp6yuu1/E1ByHImR/eEjw+lYYhHR8gHC2yOGfuvrbeLbICi4myNT8xo5Ix7n9nFzpsj7v7QvIB3Ve4fKP0dgDLZXMi1mgCmpwDovga+NQVfMHpw6uT5tMvuutdMxbhRz6UDwCVG54Y9FIhrnZBqDNygVKQjL6OmCiyFvDfuMcZ9IR7RREgdO5CYe9kwN0JKmna4uPmh/KvrNlzTMss59Q9JdC/NGyDfxDGXac4ekqU5+/5meDzsMUxGvZy4JGyuMR58/gbo9k1RqG4iuGuRrx+Abt8s2adWSFBGWmKVhONxKJyWvpdQweTjjOAEuLEAAITSPi9bM6GnYHwoDQOaBief2EVcA93X70rMGIQtxyohRrNeGXKj93IM14+x++aE4aDB8rYwCR0sRJlo7kJzWf0cIFTuQR1y+EqnK3MYUSouFb23yQA1BqkTNz8OBFa5NscfNHNglOXcM8Igq20YCn/AwgTDROx1UoOVLyFQ01woz0lBQI6QbEYrn2NpRaExW3qzZBisorLGKuKAavbL9+xOCM0ZgUYqAKUZF6VKW2bGQrCta1Y5TLWgbXtCuP8Zwt0fvwVezEBTApoITBm86EEvPic4QUqi9tS1heNg/TZVTo6HQTyE0cRnpUQbgEvlG74Quta3t22fdK/hQ2UY4vVraG49A0B4Bzd+L4MfnACA3ATjKDiD9j5w5mNKoL1dvP2l50GZ8fYXAsIopdQ1UOdegJYrG5kJqFxp3uY2uDFQ3kB7Ua2sFkooMcrrDWZyr4epxNt23DCQayxAeQ9hEPygLqW287UMhEnFWQalpjAjl4nGjdKt1UDRSCVLAKA5D2jPZNVvLmirLNwo2SYuGwalfwvY78AisVDB+4eE7iGBNBQjqDFQryQM0FLuYoxrTAa2PZXnzTnh5GPAN/72LXATQRcrEDOYCOlwgfCRFxAWi62OVxSjC8xKxebgryHEYhSM8ahEKTMUFk44iK3cCAlPnsxU5ofKMIjIxgTkhHE/Y+ebIjzKKUsz1RBKp2cip0NT02D49PPoThn3P6V1/BVN97LwSq2c7PJsXKXmLJVZibJa+i3NdEVVo1JCBNbnVAqvNOVoEy43inlUnIMwCLBYGxnPfuRiaHLLrvpsGIcbkSATtbkgNxKyHcGEVoxHkebKuoyMaSGCMGnB23L4uZqsVFroWXYnqzfD9rlLMWxJK0QNiJSycPLwxLwvE6wxT6NcL8U31oRph/HOTzwD7jvQyTnCMCGerMCzFrh5TX6XuoYCECasde62e0kzEPboug1Ks66b4NTNcHicnEz1JI4n86wew4jX5ccGM+hgH81FQPPaHWmZblabyI2D/OgaWuzt4uQjPfa/doHls9L/wYVTQrkBfaWqsws6aYweDejqZ54DZB8zMg5aagpxWtg2hDRj5CjVk7nRv5VkZMupAZK2D02i4eCeR6UhaSCpGIsqG9CUbbk67zCpd6DnbPUPDq7mclw7F6vDMODRQpiQ1CDU2bvLYRgB4w4wHIqRsQrR3HLJ1Gj4kubs3oFVipaUZ/ldbL+4JJx+DHjw+RvCZGRGXvSgizXQRMEhrJlvWxrtuuxb25R+mxZeaA/OelDbSZXmVDW/sc5Y1mj3CfQavqNhIKJ/SER3iOiPqteOieifEdFX9PFIXyci+vtE9FUi+gMievVxnvx3O9wo6BieO8LxH7F0Q1opaWVSjyHnUo2n/RbvfOklHH5lhbe/uIe4olI2bKlKmzhjSScas9HDBuMbGMBoaUBjC1q4oPdIastkmuZA6pWZqDTlGqy0YSu9VUE25+QTzI9fraxW02DewZaeZB1KKJcizRj9Q/LvQtAVO2iaEShiKyzpwmYp5xG0f2aNKXBAKTgj+c5xlPBoc8QYDxi5YyzeIlz7IzHIqRdClnsWnV0nKRIDikGrQdWaSg3I54SBcP/ThG/+reeAYUR8cAb0HbAZQJsRYW8XCAQrxmIFJpH1TKsCAAAgAElEQVRZul2pgIuzHIEtBajaINTKT7UH4tWaT1ga87vxGP57AD976bVfBfBbzPxxAL+lzwHgbwL4uP77ZQD/4NGc5nsf8cYNEWk1l61pcPryDHtfX8P0/AxplmazwVOWYWcOms/RnWdMOw1Wz7D3STBtBU+Z1anGapXyng51H8mKswDAJ6eHDbEcWyY0F1qyfnYcxIOQikUUsg/BmYN1zG3egXk3lkat+12aC+4ZBD038zIs3IkrSTPGtXIS1urOQ0Kd9pTQ35du2XZNWCdxjtq3IhbjVHsJuZHMCyDYQ3+f8NxvvIXj3/gyXvpfTnH8h+TvhSSfmXtjlFWG0jy1Coh0oFJ/g2YpXtD6JuPilRvg1VoEfPsOiEEa8BIBlaybaDKQGAPm0uLOFavlBrGem/4Tq6EA4OlLL/3WNOhW380PeHxHw8DM/xLA/Usv/wKAX9e/fx3AL1av/yOW8dsADono9qM62fc0zChsNkJSIcLpRwndN++J9VZSS6ikwZ3YBGDzyWex86017n5WfP06u2ApRaDCFxRkDJVbbtqOW0ClknM8zGiL6+v1BhVeYexHYjgYV8fWFopY+XWzKqFB3MCbzbj3oFhCzcNw76biYORKG8KUnF2FSY1gs5QS6PaMpBMVCzBoHkKNKVjNh18PLhkGsJSQ19jMtT8ewW+9A2RGfOsBrv3RhTT6VTBVfwqlfhdsxoyila+714YK24kSZrUnhHc+JzgSmEHnS2BKwJRAe3viQZouwzB4bQVvNlv0aMMTWFPcPIocnHEXZPIXQwKglG+jYBpPwnivGMMzzPwmAOjjTX39OQDfrLZ7XV971yCiXyai3yGi3xmx+XabvO8Rr18DYpB/Gi+m529gc5zAy7VLhCPnLdqzawC+9CzOXujx8OMLqQFQrURAQwVVHuK694MOr55cAVC3t24wS5dSmFYnsbV6B+VEGKhW11Yo+BfGIgoDCLDmIUUo+EVSLQabkHaOPlEh2zQrbAm6SJu54p5frgPJFWBZg33cCD4yLbbxEzuHOmtQpOkFqBRmp2Qe5q+feVNbPj1DWE/InbAt23OLZ/RYirkY5dvOP6m+gxmIoCxLw0/s81/7Uo9040BChyYC4wjkJBkKPQfquoI9mFegQCQpy9Enfd9LYZYVa1Xl3a7x4IVWAcjpiQkpHjX4+O1QlG9rBpn515j5C8z8hRaPvpFHc+sZkftiln9aNbl8boG41K9tBBX7oZXfTk0Dms9x8soBDr62wvmLhb57OQUZhmqSG4apq5NRl12GzTIRhiNYXr8CMeUAVWxvKso1eKjhhU0q4x4YKBcmKi68rs6W6qzrHuqY24xVvgSCTjMNbTTsMKCRWPtk1CGJue5BW+cBTqSqPSZjV9p3tmuaFqofGcs1Onnl0GP5vFxiOug95LFwybpmicdQdCn9NzKb75L523iKHSNuCO+8uod8sAuYGrV24LaSaljnbP2bp9F7U3jNBCmArbRoJzzlpJiFYliV+vQWFvEEGIf3ahjethBBH+/o668DeKHa7nkAb7z303tvI147VjCR5CITAW0HalucvtRg93XaCiN4GIXHABQtwBvHmHpCWI6YdnhLSr2ejI4DxO1JZsNYeTYR7TVjPTar4l3U+XbXNajc5TrFFwZdLbNMTtMziGuJ7bdIQQFelLVFI66VpvTcPUVJ5bl5LFYUZSdkk2vaKd/ZJrkxM50VWoOAVIDZHIFalCWsAuKafMLe+yxh+PzHgBAQDvbBQcBOO9/2rFhjA0w58HatiV5b835qZayagh0G4Pwl4N4XjgRjaFsVYVGOgnIVWPUdRMiCHXBETg4oemFWJf1mwrII0dOZvo2WZ/M0Ku36g81UvFfD8E8B/D39++8B+CfV6/+xZif+CoATCzm+58MKViqZLT7ax+nHEq7/vrQ6tzACRJW1F7Dp/hdv4OhPLnD38/uIy/IjOYagLr43gEVZAX01tscaONSRWmx1hjJwrvYmaLK6B3iK0BSec8dags3aFJfQnpPf/C6LphMsruX41pXaQb9kIQE7VlHXZNQ+oJWAG0C5OZIeEbHqHG+YAlA0LadFuV5bPTAMM9FrEFek+pPynTnKBP/Gz/b45q98Frh+jOGgEexiVVLGcV2sJ1NJg5r3Y9/BwE8Dd2v6t2E+zQXh4SeBt770nLQcjJf0IwEYWFg3yHWh2KqoirrOBWVdXdqwiqoBrxkDatrSIu8D5jd8RxiUiP4HAP8WgOtE9DqA/xbAfwfgfyKi/wzAawD+tm7+mwB+DsBXASwB/KeP4Zz/jSMeHUmMGAOoieC1eg6RMB4vQInQ3l8KAj3rQVm4CmiF+Yi2BaeMHAk0ZZy/CC/68RoGLiw9i5+D6iRkyMTy5q3mJRjpCNtxtRsOAxOrieNNYAyINEWlRtKD3AjIaOGFxe/mIdjnMuR8cyuuqzV9kROAFGJVOhJWPenVlHrOsExCBIYDOXCttZAbSMerIOczzQsA6doSur+DmCiTM27EC0ozqabkyM7i3BwBr/+7N7G+wQU7sZLvEehOAkb9TobDcGDklkpFaJXerZWyjPAV1TtqzwhnLzNuHu+BlksBFAFY81tqVdGp771XBYgRZr2oUgPSq0N7UeRhlHvR1J2Uv+BdtM07sG5Yta7kB6Th8B0NAzP/0l/w1k9/m20ZwK+835N6ryMeHqhBaLQHwAjqVU9hs8HF8zN0JwF0/wRoGwkhmkY1+gicAmg2A+3McfC1NVa3FiIdtgbGRYmHrasUUFZH8xriBsX9N5eXyiplmYG4gZcKx6GswjLZCx8Cmu0QoJPBUXkUkNdzlBXTDFFcy4TcisF19Z92GLnN4HkWIxUABAatInhDzqqsF0gjDCU919QLmzFH0V6oq0pzC2U7Sjm3pUVb5THU4Zat1kbFTr0Chb2GUEm9hgYO+g4HLNwMDZOatWAgIamDqBiO6VpyBCgU3kNNPttKC18O4Uiu6TtfPMQzp0tQ20ozm9VKiE2DyL6ZSjgAkLa+cwBRQ488qGAsYqneDOTScFviLoZJxAhOgJGgPggNhw/WX3mEIx4dAVXKkZpGUpW+QcTJRwMO/ySLDLy6iY41rIXqymdneOevPYfmbIO7n22KopG5x0PBCmrmIiCrtE18T1GibA9U6L2uoGYsTD/BUoMWl9vxa1DRKdJ6QzdLDRVa7WDF8Mkz7siEWv7AID0mdhOgVGYpmQzgeUI6mDAcZhFSqc7DwgtutC5hwaARmN+R1T2M8v7mmDHuZyFXsYRAJgU/7rEDf/V1AKrQJDKGQyE0Sbl0QH8vwNKM3Kgmg147K6Zq1ihNaZbk523kLW6K92Mp5brCsy4kMwDTqldPPwq8+bPPCq/BWI7DgDCfex0FrKdlJeMWutbDDRdtmUqRimU4BBhXo3CpXNtb431AYOT3jWEAZ+EqpAweR/ES2g48jkDKoLbFcMjY+/oKaBppVLLeyA+bs6s2hRvXwREYj2ZbGQj/mFClu0J5zcIHzwKEso2HB1Sl/dST8Jb2G3KjUje3NdCRg0xMQ+294hIaxqjuo1GDASEKjfsZ02ECIku4QgwEPXCAvD7KF0m7WfCKsRgYc6+Nc2EAJ8cSLk27LJWXfXZjVVee+iquMb5dB8NY2HgcHaNZEpAJ3Qlw/Y8m9PeC61DmyJ4ebc+B2X0uWAnbhC6iL+ZZ2f6hCq8M2/FMkP5d15S0p4TzF4CTLzwLms+0J4WWUatmh5GfPAWpxVJF/7F12fmaHWkgJAAPKUx1WsDLwY3DBzG+LwxDPDwA2g5oGuEs1COzGAKW1ag5Wbkn4aKgOni1wvnnnsXOWxNOX+xVD7FaXZrqhqZtrMBk12yyOzpvXkWFKZhhAcoKFUe4poOVZYuxkdWdNQMBAGRNaBJ5b0c/j7XE/OM+Y7w+Ie9P7hnAaPn2L5EYBnOxI2PaS5h29XNSEbK1kKQ9JW+C47hKlH3Nu7KQSPpfMtJcTtwUmWzyGQ/EshWk+hbztwn9Q8awG7ayC2khXsjOG4zDr0xY3MlYvMlo1sD6hhilMEnRVRwUlDROiJal13L1dVGbgZJeDAc9pwTc/5S0CkDbeB9Lv7eqiRu6spKExUIASjUilhL3XhTAlkw9GRGq2seBc87y/vdwPDkczPc44rVj+XE2G2A+k0kfojxGiLEAgMN9LN4IwDsP5Pk4Ap3SWrUJSXzxeayuRdz4l2/i7mefBVAMQ13/sEVB1lFXV7r8enUTshJxalafpT1t0luMnA0oZFntjEdg+o251ZtfacEGgtoqPe4LAQjEwBCAhoGRwF0GNkGWg5Hk9U0AuizhhRqM9e0R8TyCOJQUbIRrOZg687gnoUKeM0hVsrlVA5EFjzCwNLfiDUxz3mp+26wKPmNEquVzGevrImSLkEs16AjM3yLsvDVh57f/DEgZexCDTrMe3/gvfrASyCnXaZpLQ55mEoNR9/qo9S5qqrqFgw2LTuWDv/o8Dv/F10BRWLI8TZJN6DogB53wSnbKLG3zrGwfkFAkkDTOzezHEJ2HtogBAYVJqTwHanqv6uQ6PH6M4+n3GEJUTyECJtjJWVw8LbHGOGC8uYfFWywg4zSJZJsOTgm83uDBj9zCzpsjeNY58cgUlLbcUBRD4eg2lZUyx4pMc6mWwl7zNFkNhllVY9RKwaoOArCbXXpHmGdg5cn2S6aZYQLsNz4ygJkCji2LEZgnhGVEWAVQw2IkdFCfkRYZ407JXNj3nXTV3txMChySZkSkQ7b1nyBVo84doz0lkZDT1VyyDnqdNLXouglcMBRiMTSltkMMyvxN6VWZl0uP1/PFCi/+rw8rXQoUJelcvoONZIzPS0CrnYtlUkByzg8/HpBevgXaWQBBwoJgKk6ANLYBgIqfEGazkq6s+k0AQN5sSg8LzXaY3qSXY2sDm7xef8+Vn55qwxCvHcvkN5fLiCgAvEV5iEDf4/TlGQ6+snStBaexqoRX2N0BAMz//IHgFOYlcMlGuHRYnXXIJf1mNQJAMSS2orv+QS77AvDiISsJnhbF5Y1askyAeBsTVHQFZbJW5xMmlVRrBYugdRQ8oWEgEahXjwEApiDb9QweQ/EsAoM3AvpN1yYBHOdFrYoSST3DpIapZyCTxvEalmQgzzIQgOYseK9Jw09kFVfQtdOuWMRKyirHZgLiWUDcSG0EJeDG7y8Rv/ZGoa4rq5ViAP7063jxH9/xjuCWgo1rQrMi99TsunPlHQDY4p2krhgYM/iv/zu7yNcOS3/MaXKA8XLJtamLWwhh96IVW5k34bhD28jzcSphRcWeLAcmfC/GU20YoJVuSFmMwjSVoikjiOQECgFnLxGah0u5kUyMpe/B6w2YGasf/RgO/+AeaLUBmuhZBXNjLUSo04A2nEQ0FKEVc0uNi++Cqrr9u2ojgoJk2qHahFlYXWiGgI+mfHz5PDiWm56DTFCuQ4REMuHtvlLZdhoJNARQJgkvrIO1lm6nma7ycxVy6ctKbhwDSlB5NzVUthInAUPHXS6cAT3fNJfvKLUa7CQlEXvJ6h2Q4zFxJfjFtNOAl6sC+uW8LfF/5x52X+dvm1J2LUlscygMLPbiN320WpIwiVGe5owHP3wIEXbtHQuQ7EEomFUVCgjFvi3CsQosms6oZy6ISv3EqCXbmpUIs1kxOt8j4tNTaxji0ZFcJCUzARBJ8L6Ha/+bdFbTYNxj0OkFvLY+JeE8zHqE68dYH0epqGsbjEdzd8HNld/KRFSZAwPlTHjERVor5NvTYIwtI1HLwptXkRScC4OmSa1kuWd0pwFxVbwSq8VIHaTEWc+JW5bQgbhM0sgg9QRAAA0EmiXJJEyEsCLQVLGxmICJvHckJQUWUXk7+ppkAqhclywTXGThRZNy3C29MFIPl5BvTwU8bS6qbEIi1ZXUDIxOYm6A89stwv5eAf2s7f187g2Hd9+YvPZDzhNOrqprWAzTqLkMXgWqGRNjSIr3QXjwKVEOJ01JcpKVPW82srp7ZeWE0IlBMBq1qz4RIa83ZfJ3nfAdLHxQqXoLH7IKwchFKD00H+d4ag2DxF8lDsM0SZ9Cs6zmPTBjfP6arMabjaw0WjjFG2k3dvcnnsXR795F3p2D572sSiSaB0AxBqhuHi9GMkpxRW+2uH9rVeKyXy39ZsDXsMeuK9CsCl8haLep9jQgWOq806pNReFrpD31jLDR0CDpqtsl0DqAlfuADCE5nTWIyyDHUK8Iky6dTQa6jLzIkg3o5R8rJTssA7Ku7PXnO5VawwyOAvxZUdW0o41/8/b14QhXiA4bUgC39LsAJLQ6e5kwvnxLGv+Y4hYApCTFTjGif3vpRsoqPYFijLcGFRzIai1y5VXUVbHthfxep194DrSzI23vplHwhvm86Cyo0cqbja/+xk+Q2p3gHoQRpoTs1JRtgK2eFfB6iiuP4S8c8ejIjQEoFCKTZSO0aMrwhtWtmdQ7MAPaSAbq/nFKctMyI6wHcFTkfcaeHrR0obHirFLRXVXzAkIhL7leg3odUQub6ga2NamGWwBZALy4NJqxxO7NBflN6enQatGwDElQDCLPsqT+okzMvG7A9lqf5FfXPpYApHPVioRhmCGrv3IbEMXNtw7aVmUKyAROs6zkI7jxMz6BTXC7RuJRkdcweJGV9q0EgP6BAJXNhZCVag8sbKS/xOkPzKXlfdfCmgEBAKkac1huSlfxWH43M1RbwjUacvh3qoyVsSrdy1CW6cOPReQbgjX4qr7eOAfBcARqWnnUFKSlKsNMqNQuDqQT3ozI5WEhCY+D39OP22t4Kg2Dx5cxiteQkhiCjTAa3VtoGqBpcP5sxOyuhBSm0yftxKShiNc1TEkQ50hyZcxlNlfWiDTmmupKZ4i631SaCvNUp96ETt+N5UYrRoS9wpAbdom2uCa05zKpUg/nOtQeiTEBt7pARZbVv8vCVwh63GUDmimiGQQ49B4OSb/37iTvAUASOTWjONdZFhqpTOqsoUTPbtA866IZFkC/pxrI1KuLrter5iyEDRVDeyldvLoekJ9R4DklYa6auKreEyZsa0YhzdhB3WmXq1L1cnxg+/s16/L7+ULAokF5/tE9B7GlD0V0ANHa3zmz1ioxSXCIvFoVTIS5hA2V11CXZPtj25Uiq8c8njrDEI+O5A9DZ5kLFbrv5WZpO09X0mKO8xcYR1+ReglrYe/VlABCYtRo77AfXcTURu0VWA8HAA5YOeCoq3pcAybSWndfsnqBupnLcCiTSdxrKrjGQN6PwTo/m0qRp/s6iKKTrtg1kw9BshFyovKcFxN4IqDNoCEgz7KApqr8RAPJ+0yOTQCVIpS6AGmRBSDV45rrTxtyLoMXWEGAVZGuI1dwhnoRUVOLZkhDEg8qDLTd/7OT3hirmzIx5ecvWQmhLI948LljySZolei0U8RjLVU6abMa+80MdKw5DbXiFVB+tzAS7n42YnrxJuL1YzEQCiDmYRThWC7iP2ViN0BFc3YJegouQV/fl4ZBACjNb8aS4nycXsNTZxgACPBkIQOReAo2zHNQfgPPOgHuHip/OCWPSy12iwPAfSOuKTM2B0UPoM4+AGIUmjVgBUwACuGpzgxoes5Gnfqsc+Sm5yhhBm8RpwzU9NVSCVBRjYV5G14o5SEPgcYgq7ixGwExPlGNhSouh40QeDgKQ5Fb8TQokeAUgBs3ZzRqmGAaEDWhyXAZy7qEURrHxHXYEs219KcJ6AIogjAk9R+G63iJtK7wlIB7r0Sc/I1PiWCrApC83gA//AkBCFkMZm7F/S+6FBIWEYSgZeFMasvnuBdB5Xew0JCDHDf1jPuf2RXKvd5Hkv6+pMqk2ICRmAyTqIdrRtYaDeZF5OQhCnIq2xl9+jGNp4r5GK8diyFI1WxlFmMwDoXo1LWwctbpcAGOjPbeBQrqm0G7O+DzC4SdBfqHE2jKADO467A+rlZZlJDBVjUvIc4FrCKdPEBZhYyf79oMuvqYfqOt+EF1FawHROqUxKTVhpYRya1MqNSWCVTXa4C1bfw+gyq3HImcwMRjWQvCWtiBiLbyw9OV3GRlTAafYAQIR6Er7efSPCMugxKq2M9RvAGRfOfIiEtSyTXtZt0VY2MxvIGg5qxwZECZk4BepyBeBwi4/0rE/U9/Eos3GfP7GcNOwMNXpJiqLlf3NGpWhy5ph6sKQCYU0NgwjbpFIACnugf1HC5uE26k7KFEOr8AeCxhQdMIOakvmIIXVwFwOnSjHoBRpHkE5wDk7XoK4TmormSlG/k42JBPl8dgngLguWJxyYIYBTMYptWfMs5fmqN7EEEn54JHWBuxs3NQjNh86ll07wiTjjYjNse99Ie0m5bggq6u2FR7Byx1DmGEV06adoOBi1tpMC0oct1DgussxA25xFiaMzbXJd1oSktxU1a1mhPhsmmKfbQn0T0CMARniDo7suAINATJggBAKq3rwARaTP66XGNoabTyLFTCnTTr4Wlcw05MkDXJ6hwmBVU3womwyWaGM/VcQq7qHndjoZ7EtJAQzQDJMMo1WV8jnL4UcfEsoT0hp4979siuYUABQ9WIlwY58O/qpLS2eIxWBGb7t+ckxWOvvCjuvaYmQ9+7NmQexu0el8pzcIDRKivNKAACMFZ6DICGIsq/EfFY4UZYT83HMZ4aw+DYQh1XMZc0pY1pEmo0BaBrsboWMLsHsdibQVOWQZDstsHZ8z3CZnRAc3W9cVKSuZNRvQSXWtMbzsFFndxO7w3lX9BCJMckLCwYysQw3r4pNpn7257KZNoCFuuYl8vx7NhAhbQr9VlCh6AVlnoDzpOEDQ2D2ywTwxD4TRTqdJYwwTMntlobZXkqf4eRgGRiK6wFU0qGitIcZ309Y3NcVTra/IjlWtodmTtJX1oz39xCwpV5KQmXnSW02hxq2XZbn6tOZi1t91QxQ1iftO0RcNDy9UvpZq+BUSDTvLZmSTj96FzCmZSFIq2YR+ltOSHMZ+qpVhqPFgZwLgYiczEGl0BGk4Xjaay6ZjdqSKqY9RGNp8YwbI2a9hwD0PfCSTAXjbOEFgDW14DFHe1DqSIu1DTSO2KxwLBPko0gQt5fYHMQ0FQt3ZwRpyQYK3VmW/lRbiJ/zyZr7aoaVsDFEJibC9Z27UFu5NxpGXOr/IZK7aiuELSshonH2Mpu+X8QQOeNZh9Q8IZQZSwg++VZFp7DLMFozQJQKj25AbjTlKde5tyJR8MRSDtCgc7W4LZa7SlJClJWZnYg1YHSUMDApE1vpcS8fG/rCWqS9mkuxWLDAWN9Q/pXhlFwg7p3RG0cvBS7Ye+olVsxxhY+GDBaU+KBYoSDYjlWDXv2YkC+fgTcvAY6PizsR8UYqG2QtanRVrWkch62huEJWUDGGnMwcNLJVFl4OVYK/qjH02MYovUK1CwEkaarsmYbZsVyWgk2gM0zCYu3BrXiAhRJS7GAi8/cxu6bwoDkNmI8mmH5LJeiJS6r8VZokLa1FwDAMwZN2cdETOJQgMO6WlO0D8hb3g0HWeLgqFTivYw0E9bguM+uN2kxswmY2goJY+hNQiEOKz25MWgQLW4/LSPQZNB5BLdZwgEAaDVGMdASQvKiBIy7GWGlpKZBPAViK20WwxMvgipekd9ZTNK3AQDmbwfM3gnOxzAwsj1VEduxXPO4krDKPCWrf7C4f9IQwJmdypI0DMhCOEpQQhV5GlgOVCa+VYvWXkxt2Oth5dkAvDbl/qsiHsvzvmQKKk/AxV4BDwMAFB1INRImR193wvbiqsqIbPWk0CKtRz2eCsNgxVIi3srClbcLFWiLzIQQxVuo5LC6N08BZiHATCIPj6bBxe0G87fWABG4CVjd6LYq8IACRAFwwHHrxlNmnWUIPOU2lRXIXFZvQmMpRy7Hnxbihtdua1B9AjM41hzWjNJW/r2FNJDV9J/VF9BICOsgmIN5C5qGZK205FY9AQPq5kno0TrxHRcJMvmtjiPPss8dO1c5F3YD1p6SF6GlvsTvdXeouhmNSdOZ8YgDStMa/a7NGm6QzXiEiRyMdaNZkZOszHvaYa9SdX0Lfc/S0F6xWhkvF3DR38x1KwfC8hnBAMZrO6DdHYSDfXiXM7tHjcfQGodm8FSlpDbHkqqsw41Ki6Eux7b3LUPxqMOJp8IwAJALqOIVFINMfrOs5jkwS6pSPQpqWy0SUt3/CpyktpVJdDEAwwhKjPPbQg823UZjO9rNkRs4a897NlSxp8m0ufFo4JJrQLm5zXUNm2JIcl81qIW433UmhGNRZjJZODumAXZho0ZDjVazVAbhqpRDIxO4zyrcIqEAbQJ4lpUODbDKvWEM8GpStQC508KrDIR1UMDUDBg7eNqeE9rTgO6kMCWdgdhUxtao0VRSlzRJ1aUrO5nRVbzG+np6zYO6/s1Kw7EohVtWIWmgYdjItZBrJR6Ey94bkGwNfirjZQbdDTGV8w+jqGWvXjxAc7ZBvrYv92lQTsM4yWJmgKMKvlLfe2hgXoQ1ynVav76PSl1aTkQ9kUDKihwK5foRjSfeMMSjoy0RC2MzAihcBnsts6YqGWAG78xFN3Cc3OMgIgkrDveEZjwJCMmRsLrFZeVTd92wBDMEBuwBgBcNGeBooGXcXtGtO5KpIbncOcTojHuaBUEVCytCn+aliMly+LZauXfD5bPTrBg2QIxDGIH2YUA4k2wFTcHDCrRZqjCzfIYrOm0C2ocRk2kyQHAQq7fgKM9zK9wFU1/qHgY0F2KQDDQUynmJ080zqa8ToEaB5Tub3oRnEyzNq0a0tYa9rXAS2jPhYwBwOf1xTys7FZuoy+UdPLXfQYFS4zNscVCqDFINLtu1j2vC3R/qQG/dA40JUIPg/Sw1tWiT3qTd3BBYSlIBy63hdOnBdRuo69woANBFrxznUYwn3jDUgzdD8Q5qGbd8KcZSDkNe9JjdVTWdQG7JeZqwfm4f/UkS1eXTC+Su2Vp96+rIWk8BKKtGTdM1wziv1NwAACAASURBVGHehbm7Vo4NjVm3qvhYVzOLZ/W4NQ7RrJRJWAGY5pXYZ3oBFGy1hdOMQbI6hlFW8dnbjXAJRnWJnOVIQltOYjiak4j2VG7S3DG4Y4yHGWEtK21zXqUp9dyt1wNHYHMtgxUoNWNaC7EAkqZc38zepXpr0lGZfC79loFhn3117x7I+dEIbI5E6SnNs8rJMboTcqPkwLGHGuJBCXeidK8ybop9rgvz6PeoBYC9hmMUwV1azEEPz6QX6s7CBVqcr9A2To82YVkAW6QoL5xS4NGOUYOM3sxGSVCOOVw2Ku9jPNGGIe7vyx+tdh+ezVxLASlrfMalPsIelcM+Hs8we6C/bNOAz4XkRF2Lca9Bf28AbSYgBGyu9e4tbFXb2c1pnCq9wQyEdGXogNIglguJyVcWA8rMLTc3ueci9AKd/KodSUBZyXWVNu+irva0G3yaA9lW3VkJbcRjYQ9p4jJ4COHgaWBPZ/Z3oiP8UpHICGuSDEUSzMJWdDc+2tPCjFJcq1KTTiTjYuRWjjstAMoKOg7bBjOpUrUbCg3pTOSlrlVpzst3iAMhXgQRszkn7L2Wcf332TUy2nMNaxQjAClF2q5vKBiIGwQLfTQkMXamj8p4pOv74PXay6+tetKzBimVCsrKC/aGM1WptdOhK66Dq0bb81SxInWfR+U1PNGGwUlMxk2w5hvzmXgAo1RJIrN4Auu1yMK3wny8uN1i53UFF5eiCyj9IzIungmIqxF0vgTvznH2/Le5oFTSkDU92oVexyLMYrX9lwVcuBH3FIqQmwudVIfQG81CQLvcwmnSlo4sxKgKVUeZTDIR4fyI1Mpze7SqS+NF9PcC2vu6dJIYHhoCmocN5q+1auREyDXPhNloUm3TXkKYVO+xk4nVnGl5tGZXVi8PmOYi6dasCgho5zruZ6leBdwr8Tg+Av1duS0dx9ERBjGkw7WEcV/2j2vhO3QnUpbeaCVoswKu/fPXcPSP/7CAoZaGrYy49ZxAViPdFAMFFK/QFbgYpYbCwiMSQ3jysR3QfI54dAja2XFy05bIik3mKsXoHgPKhK+pz7avMyrr1nZapOUVnY/Ia3iyKdHWw6/OQACq7UgCMqYkhqNrvZcEr1ZA32PYJTRnG7goZ0pAFqyBA4E2Ceg75J0em2NyvQMHlirl57o1m4FUkkkop+ukqCCvp5m69iY1pje6tZ2r8+QhAawrISDVicjkRVoBCguEgt7bY1xLIVZzQVskISdjoayw5vHEQMBJAE6Dp/nCRjIIGOATT6oeWT0drZFwj4p9FTamIAjo3mqVFVlQfjQSOsg1oa1Uq9dhaOwfBiol2TrxHB8AEIYgmENf9ZXQcw2Kr6xuMM5ffR6L1w5KhkEzQQx4ZoVy4WlAsYU6E+HA6Kbs75wSS1sm+W3OXgw4jgF8vpZ704WGpUYizOcy6e1+pgAglZRlEG6FNcQVNafS6xKAexGh70UkpilZjS269fscT7bHYFyFaSp4gpGaAO8j4WHCMMLASAoBmyMCrUcBH00gVtlou28l0EYyEmmn3aK7OiptRl1X+bqxrW1fay5uAZA6EYYDFTlpWZq5WN1DU/YD9PgKhmWTSctVOAC9iavtm1Vxz23lsxoEAyoNua/BMgtnmqWIoMQVeSNZT6tW+IFXII5akBRZpdYI3UPylvcGmjba+MU+O0zCxZCsgYCV3uWbShjFjZREW0bIMhLe/BbF+zHMwIVUqEzY5ly8m7d+NOIb/96RA8RyceUfKauzUJ7VA9Hf2DMpl7xEq3Gpww4T6Rl3GenmoQjGtCVLYFRp6nuE+Qxhf7es/sZx4Fz6TwyDEKUqbgMUxDRyVN5sikEAtjyLRzGeWMMQrx3DuQgpifVt20J3NiWcXimks97/xjQB8xk21zPo5MyBR1YjQvMZ4kbTm0QY9ltpZqKT2m8iqia+rfA6acBwbYS6m5GtZOOuMPcI2Kp8nDRub8/JAUnJobPf5GYgxG3VJS7ICp0bLqGGVXAaYNkUD8bxDpQsRVzDi75sEnm6NZT9AHmfkqQkKYkHQ5nAkFAkDMD8HfEeRusGbpiHXqvN9Yz1zYzl7Yy4kcKptJMlzDijAkSqtxAGgEaRezdANc0Y62ss7fX6ElLZ8QA4bmDufVQsZFow2vPi/vt7gIcUJeVMW5kID+/0GltZ9mWeS526JAYefmKn6Dku5n7/cspASsgXK6kCrXgHtd6Cg5Cq6sSbzVa5tTErzaBcbkrzqLITT6xhAADvDdhpyep6XWELSVb/TVHR5XF0i8l9izyTiY++F66CeiDUtoirDMoMNBHDXii6i7r6GOjFJBO97kTtIYCBXtZSYBJ59dSXxipQFztZSzkvwGK/MW0Cdycqua4S8bISqatrIq2ojBcXMpNlR7bKxA11V4NmLezNeHk9gJ5Do3hEjsJFaC7kixIDzYXE8P0DcmNmjEGEgsUAcg2mXUb3IKB7GDC7K3yIsAHaB1GMgnE/dJ9xn90DS3tZMBilhU/7SYzeGl7ZOe5lYYqieEeAxvvK5yAGlrfYM0MGYpJ+53pI6fu2/kOdeTBCmxHX7D6wz7TrfvFcAB3slXux0mVwHGEYgRC8SvJdhKUKhKS2c8FYV6MeBykzV0BS7n0TAq0k4t7HeCINQ7x+Tf6weMkyEE0jGYq2U12FCO8fYf0lVAMy7c1k5coZWK3lou8sxBrvLtCcCzuStdCqRqXN1TfMoFnKzeQ3jXoQXtwD2W7cL+CVVwmqN2DU4qS6jmYcDFAMQxFFNUQf0GzDQmjIYgRUgq1a0QDNSMRys1qGwLpxm0KSnXOzKhwJ+QJmwOQaxDW8i/TsHUL/gLYqI+WcZRsDEImlh2XuJZVodGTL2CQFJOOKSv1JI8eJazE4zQWBSRvZNMVwpJ0sE3xdUq/9veAG0YBDK0ePK5HIC5NQsg1nCKNca6uWTX3Be0xlyheFKitlr3l9i11WA6X1M4c9xvDCNfFsAeEctB3C4UHxgJWkR6oT6ZwEBRI9I1GHBQY+5iTGoqJeS/ajolGbHsn7GE8m+Gg8ha2mtEGxhuhhhDSTmcr7Q1ku87xRDUPxOghAPr+QcKNrlRyjDDVrBQd412UkX6CLm22FUJZhCHDeAF+q0uOWfYKHUcVBtCFLXdJLWSoIm1VJ01nXJ++gvQxb+8hqvA0yufwclQpNA/F8X+NoaL2BswDHEuub10QWNkFTkFmO2yyLUO1wKJNRFJskxLBQa1pUYckoBqN7KO5/e17wA1GPkm2mHVY1adGtzD3QnEY1ahmpj/I7reXcrK9mmskXN+zHa0ms4xXKb5lVy8JSxfZ96hSkdx+nslA0Wvdix7ewycOPyoNc3+jQKFmJFnNZRyyNaR5tykAaS8m1dsk2lSfvYWkqUCZTb4A7NJwIjfIaSrqK2g4UA/L6vddQPJEegxsF6wUYK77CeAmM7Fp45+Dqtc1RK7wEAx0hFxfDiOlwrm5+BrcRk/Sa8XSfYw2VK269BYws42g7yU1kKzyrOlAYRSuRVKrNwD0LFURXoYBfQqHWY5B6KNqMlRvp6eBZBb1xLevAEWhV8Ug4AoLsW0p03LPPMwyjuL5bSlMlWtkqznKAU8VjprkSk1oTV5UwaTwQ7MCrIrkY0/a8GJRpBqeHGwHJwMq4ER5FcxpBQ0DazVLcFbSYbFe+i2Uj7FrV3bM9xFvBvQHKakjsPZW8L5qUJSSoiVUmpmOel1d7jtW2lbdJDFw8EyRcSMKCzGfnyOfnhXcQI5Az6v4TtuLzZiNhgZL2qC+FWd5zouYvWBu7iuh0uevVexlPnGGI169paEDFY7AaB+YSXihwKDsFGA3ajMPyekT3kHxf1pbjzIzUR1BSjAFKchnLqu/uIW//8HVn5VqSPDcsKbBGJntuueADllmw5rAqbiLpyPJ5AFyK3b0GTemBqWJDcjFYBN9+mimiH+BGodQ3aKjRmfss38nLtCtvxMA0O2/TS8y9xOrL2xIqWPm1kIkC5m8Fv0bC7ygUY24A5GIkhuOMzREjKRaxuZ4xHLDXdoRRQorZOwE0kNRsaINcbhmb4+zfwX6zMJhxhX/vrVJpFJwAEEMURnnPalZMj9JrW9SAukBOZTgdxK3IVkaPXt2Q3hPp5FSO03USMmjYYPcq2cKn+IHwFhqYZCFPk3u8hinIAbdBR6nArEIXC03eRzjxxBkGCRUMW0gy0b3rkMZdZgjqzlP2WsrANGHcJXQn7MClSMWL3NbqRiscBmZQkotr4cFWjlonSaiMr7mP1vQl9+xX0VlzY4W4k3oT6oHY6mpCqeLWWhPa4jUAcNUgp1u36gl06oZrBiLNRaTEOlaVdKtZBtl33OWtAqHLUnVmZCwUsBUxTHCOhGRiqiBbjcvqmQwmWdXbSv7dBGgcu2kZ3f0g8fhx0ipHMWSr2wnrm0lUlaIYov5+AG2CXNNJvtPlVGdtSE1X07wJl7ZXI+qYRSeGIIzkhWBuEC20Ul6Ga2BwuR4emlSsVfM6ci/06ND3osWQM8LOHFZh6VmGUVrYUdeVzIJhCVadac1qQtGErAlOTqG2Uu5h2AIx3+v4joaBiF4gon9ORF8moj8mov9KXz8mon9GRF/RxyN9nYjo7xPRV4noD4jo1b/UGZmVBJT+LO6SA40q2OoEp6aRLEXKGlZISmfcA7ozdhBIegKKLFZIDG7FncvztrjlbOkwPRcuN2BNRvJT1QIjv4EM/DNwztxpk0IfUCTUNN0oiLoShwjSGNZSaVTCF5cra4pxyW1VvanYAuGStyO4qhun4bDSm9AJ06zLd/MVdQ0Vvi09H+IGRdYtAzSRt44zTsC76NgB2r1b8/x9WYH7dyLiWrgQzYV4Ht1DaZdnRVj18NSikakAgNip23b+7tUFOS/7TMvMkGZzjIptx7RQqvbi/JgacjjDtfJKnEJtmEQGaD4r3axbKa+WVnqm5iOhBI+T6oNEr5QsHxxci8HqLDyzUXsJys/x0m4Tin0fnIbvZs8JwH/DzK8A+CsAfoWIPg3gVwH8FjN/HMBv6XMA+JsAPq7/fhnAP/hLnZHSm0HqcmnhkxdKDUpYMvIToBhDdr4DmgbDPmP2IHlo4Y1E+w7jIiCcr9QDKVbVUpbmRgMW98LDCQCuIuTPq6YottJ55aX8CUBViWwls/dStbITnKPgRkk/w0hM5q5CP2N9rRQVBZVh81V6JBdW9cnMWgOhbrfJztlnWscok0JrzuX5uCsp2LgUfoBPpFg8LrlgmrKt5OxIQ4vcQztgyzWw0IGyeCTtmZzvtGCkOVyHIliNRtVNu2ZD2oQ0Q0q6orvaUtW+z9KWl0Fk56YwPJyoDUK5SbaNqHEnrLs5IM+nW4ceAqSHJ8hnZ+CUEK9fF6k3K6yy8KFqJGMrvkxuU4suHgVrF3cPTQDHHmw/q+p8r+M7GgZmfpOZ/x/9+wzAlwE8B+AXAPy6bvbrAH5R//4FAP+IZfw2gEMiuv1dn1HXbgu75qRUZi6FJ33//1P3brG2bdl1UOtjzDnXWnufc/Z937r3VpWrbJddftvY8hMEcRwlEEWgyEYBhdjIkHwgJITCT75AygfwQcRvhFFiiBJCErATkGwEjuXEuBxjG7secb1wXPd97zln77Mf6zHnGJ2P3lsfY517Td1zq4JOTeno7L3W2usx1xx99N56a63b/RRTMYAAttCT8QHGB13gSGLEEnjdu5qAWlFOmAfiyEewOLNRxY1DurZUeCb4QgofQd99UC1LABA8/bB285fgIpXiQFj1FF19EbksWGBZAutzKgTrZBmLEY/8du/XMyiJtvca79szFQqcYgwbW3OCJlGW1toUtddLbhtXJ3sIDWLSYkpQAy0tozG1o+EIeSuBGxzV677TMnsqbmUfcx+y6TUigAqQ3O2pz1T6rgOJT2aocyxSe3i3Z5AxKzmNUoGdCQaPxpBsr9WrLxlwTGQl2D2zNmCwAw91XqDX15CTE9vsenPibigNgNaNyGZ2fJxJSASQI3cnH4/HeRVfiUfDI+UaIvIRAN8D4BMAnlfV1wALHgCe84e9BOBL3Z+97Le9t4OCKQDv0EoQS/CuhKxdhECk1yXZOg7QQZF3CzgmXUttrDEFpBRgGlHGFLwAqQgZNBdM6koCwP4vK1/wXfcicxxbINvcSSUWKnf6vEeQe8oKoICH9vExEFa9z+6pM6dBqVjHwnAGe36yI8vKsAZR2znLSh8aQtPSYe7ccfFrt7v65zVmI8LS7HBWIzPizpt9AneZNFqHAJoz0qRx7vp/QkAyt6lPHOYbuMoE5G0KkJGzLPm35C8cSbS1/Z9mOerChJ8Fac3s8KDDCqQL9qmVl1F2PFRiMvCQJAYA+ycS0q3TIxGVJB9me33tQ2r0WJbd0aQjmFQ1t2kSnWppAcD5C+qqzd77kWXM+z3eM49BRG4B+LsA/iNVfSB/uJXUu92h73iQyJ+HlRpYwyh5+dlnW4ZA9lYPLi4LIAOgC3BwmmlOlmVsd1FS1Nsnhs6fXwdgKaLGQV+v7CLxcqSOyUe3+cW8tE/QlxOaDb0uGwsKAEBardGTNQaucKcBupQW9lhNsGluziWw4QYSZ4gy4OZIbP159UxiOhfsn9K4aJmhqPMUkkrTfdSu7Og6IPzH12JffznRsLAXbfyCYesmq/7tco6lAIAollMLQHkvQFKMFwnThWVT44WgruTIzyAA0GRvP++tq2I4gE/Adnp42dhszLRLmO6nY/xEEa1llgAo9hqzt6A1K+DmviR4RRfIOSjDDTDfgXMiNMhWESRZuvBaIJBZ/GuT9p6MPwJsn02QW6fIHLrs3o3im5i4sRBZjUfGKxRJ0f1cBLrU5gd5lFl0GJq3LftSwtiVj966fE8Zg4iMsKDwN1T17/nNb7BE8P/f9NtfBvCh7s8/CODVh59TVf+qqn6fqn7fCHraJSsJViuEnJpdilLbiHtO/yXfgYHEHaPryQgVjbIiCCGeMZQVgJWxJ+skIUDqEfu4ELowF5Lc0TMBIBh0dA2KFuHgWTJxgtSet78wZRELYou3MB0UoDcEuQckJ5WNRu0MUV+ciBIksA4PZvR3EO9MoNvp7AP6gvAZE8W7LJoAHRS75wv2T7g/pC9G8hvqaKl9WddA8sfLhGEHHM7aewCaLJwYSLRFfXHzYNdAqrdKh4Zh9JRvliLJOxUB0HZ1vyZtWhaBgYKeadj7bucqHeSIPk59Rfh7avssvcy+p3WT68ISU1cjtFTUq2uUiweW3nuLUtUCRSxaKiPdxCUG1RBjoIkLQct+gA05DBx1V0ubT/E+Acj30pUQAD8D4DOq+l91d/08gJ/0n38SwM91t/857078IIALlhxf7lAucgKNTuAAYFmBezfGguecSuINqqaWXGWT5m69nzc25yaU4i05ha4maBLUrEfDZmO3Z7Do8AemxWWtcX9oDhgEuIN5q6zHLkL3i7ZAqakYL81B2cxbWs2bbwSFtmUjrC2ZNMBF4hskU1HtF2h7td0yzT5sdmiLlnyDWCDeFixrxeEpmz1RJ41J2Ongo+kWXygslXxBadJYLHyN7BsfhUw0sYn33YG9YXqyNu8HBmAGoWByepDOewnbuxawEAFsvJRmzecLmSKyEMT1GRy6oImW4fA77gf+9ObADBwsOcoKWJ4/g6zX4dRUr66ttDgcfNbm2OjNznIUSq7HCbrfmyqT7k1sdR6aLqIfmstMASnH37xfB+n3Ukr8CIB/B8Dvishv+21/CcB/DuBvi8hPA/gDAD/h9/2vAP41AJ8HcAPg333P70ZSW/C98WVBwxFYanDStYupAAvnsppQNubiE9lEVWAcIJJsqG2CBZNxwPaZdhVwdyYphouM7kNEqynUWU4VsrcdnyklAT9bKG2+gnUbGqrO1iMvdB2AqgpN2rII10/oYAsziFKDPTcDUB0sjX+YxltHRYFE+k0spKzUzWbtRuIEaUZQknWAzZ3Yp3BOKmtFOanNKVoU1UfrAU6Z3qXjAFu8DPHSRP29skvSz+ZgFlAnYP9sAbIGVrN+y1Iw1v7RliwtSB5fS24OK4hZocO2BeIjlqNnGwRd6c0g6IIIy5auUxTfY59dEqtaKQ53RgydUWu0F51Tgxh+62YrZDgOIziJSotLq91TxEbXFc+6Umf35uPs3OMh1s77PL5sYFDVfwS8K24AAH/0XR6vAP6DR34jH/ogMM8ttaIm4ogBWdp8yodnWA6DpVC7HQ63shGQCMbkDN3uzD5+R12y70TZugIEmfqLIM2AroDKC5hodLE0dLhKWE5rWJdDfTfPllnknXRsSmn5WW0paFkrsEiIjUh5thdCAKLDdbNKo5cDsQwdgLpEhh5BKh38NbkjrhTYd8FpEWdqeqCbzFFq2MInUI2W9SzWUZjvmM18XVugqgn2+2Rdh4TW6SgTd05b2MupZzjd4o8BMv55mGXMt33WRTVr++mNIc5J3jfQFLBABrQFGi3ZlWJw4xmWHMF8JKjplwJ3/LwXHM40bu+DADeLwDRq+zlapX5tMKtbThMwTtByZfX/NNlE7N0Oqbs2DWtoO37b5b10kASZBvdrkBiaVPd76GJrIK3XEUTCv6HTZjzq8f7+6p/HsSxOW1bnLuTjDgVbkqXiiApNXIITr4cB+zPreev+AHpEymZt/PVh8K1AoUM6qh1jTBpaSjrc+O/ZwDky4sgsTLNRoAOpdglw0J617WwAWstTvWMw287NFhuDCf0egFaDx27ZQbmazJiEMykYXADbwbmLsRywlNuxhtzmVCwbVy6W5gK1uu/Eq1F9nqezNQ8dC3LwMXQ0lyltly0b9VkXXgZNNseynNbmYsXODrMBP2QWYBGMd4fY+SFeu/vnW9zzohec8RwM2xbse/IZOy4MsOHhqIjBQLwGigOJ0XlgIO4wmj5Q82ejWgv2dyxDlSRBZqoHAwRlszbMq5dcdxOse9aiuOW8lQgjIAnVgUkZRmNY7vfHg27nJTKP90ONfnwCA9DwBAC941JkCswQOENC1X6eD0f8hzoJxksrKzAvZg+/21tNN422OHMCRFCmrgNA4LDrKpRI3REdC3IGwqNB22LQDtSibRjr4+A6iC8ot26jjXmd7HnhZQa5/0yBeeEJxUDEI0YESMfFLvBWpkMaycuTsuEEakT9HhTv1BY2GZeDI/RgQOC5kUavRrWFnJ3HEAuxr9m1pf0cRU/NR38wsOWtYDpPpnfp8YguMA5XFnyJKbAsO5xZKzk/BEbGsBsPsAEmp5Yljg8kMrXs3Rqga1ujPQ/QnqPHPdgpOtwWQF1C7dd27OZbU1v206gCIwDasBlnRJp82/0bvNvA7KLudt7iHJtHg2MOsZYe8Xh8AkMwHLVlCcQHiC0wUDCj4EEt+n4P5BQXtm639rfu8W+p1mI7cKnQ7FG5touNct7eJjwuzB5kSohFHDW2cyDEabEEI4etRHqvA3dWCUIT22HiANmwtZ1aANRNhVQrI7LfFmBo9x4IYMYYuoJoq7K8qC4FXza2umL3y7Zbthaq7caUGK/u2ayI8crHxnmgC/2AZw2ptFZqE2xptHTFLdut3JDW/dH2JutgLcp8sPJqOUGwTANTkCYtn+4nrO41nUNY7j1E3CJYyBYsOxM8mDkkD15lhSaSIiA6teyhhGy+ZTBBjfbgtpwAevvk2MaNDF3gqP3YT7yWcYjMINiM89JcnDjpupv4zp8poorX8sc/6vH4BAbiCIxuNGfhMS+N+Vi7zkWPQbgBp8mQ1U7YdHxSJHn/dxxs2AzBJnQpO9tSbI15xyIwBg8OAUpGG9O7EP5aFkCMHszpyjKLm8xqPCZ4E7PZnvM1iZqXtdXwddB3pLH9fAQGjMKpVt4xCFKOZyacTMXMqJ++xIGzqAjpd+zGi4GQoep07CVvE+qo2D9pMx3mM40yKR2klVZj86RQATgQt8dKzOPCPquxO2uMqufuTuNaZm9W3nQBwMuBwHf881PafnhCsaxbm5FlChWT/XffdyiCrVqbFwQfQ7yhLznsOY25GK1EuwjjemX6L941Y9fhaPxcf/32jtJuGCs+jzX+ts9OgPfVmXg8AsPJxkgfnCoFtMyA7s5ep4WGov+wyVO2G9M/LBtgvLZ0KsxdnFSiSzEizbxAU7N06+W0wXZzkKpnQobCzo1R81aAelybtmEv7ES050eCT4uSQPaZZdSV4vBkRc3mYFRW1rKcnyjWZhyP+/wkXcUF7rtVlBDh7uyMyNqQdyER6E5tn1va8ww3VjYsp9rmZhQDQVd3U2gc0tzcpqbzZHMefAEdzuqRp0Q62GKmPRvLFSpQ51Mb5Jt3JuFeTu1xw7XEZ+7HAPYmLCy9+DrkcAQhSiwLWp0LNq8J9s8ZO4mBie8jFQtMzA6DqYnuNeW4Q0EKdTBlPWMsazVOjXYLtbN708tLW/jd9Rk28A+1GoPV2Fm/hQM1B9Lw9iSRbcTfPiLO8HgEBqiBj0e8bzHsgINkJLWygoAjHweYyatTpOtKkQ+GQYRhBt1wasGyEaNUzwU9I5Daev4PIAbKRP3oOxLiwm0peVir+64uiwUNdXASYqapBOry1j5rHTVYd6G+ZKq+qpB1weGF2Q1JmuHJcGMLbXE5tXYXa1m3Wj4W0tJIUHWlMRCWo/N6ERlgQeTk1WQ8BF8MdXRvyNlnVqo9bjpP1vWAnZv1WxITsNJOgGrdjOql1LBt3z4DWyzQaqUCAEwPrBccngpdFgC44GrdgMvAdRiQPHMoa/u+DmeK8UaxeSW34NFpN2pXVhGAZtDsSWH2Wgj+B8vIHkC1gNiG2/YLPa1WQEqWTZTWgqelm+EIo2EKbj8PwOj9nbIyjk5zESpN2te/DzHV4xEYPDsIlRmBRtZJ3eLGYW6lwzAguhi8fRjazidiTLNenQYg7xWaEqTWRhHWVpP2k6i440af2xcNbdF07DKFatcML5KorUs/+NWf24VMgC0yJO9IZAQIbZhDfgAAIABJREFUmHcCSQo9JKSp4PBMcU8Cu2CXtV38w5UcX5CJZYbhH+RkLKcWeDizQopg/abRjElCItErH3wXfmijObr4Y0dtxjO9Qcwzv6NNJwE/d8xW5mNtSd6ZunJ8kJCKBZq0t64Qd2OglQU8hmsbatMHcilNVwKxbGm+Y+P18lZw+po9uNKgl1jR0gBkZgJBguJH6HQZpgvhifHz15UnaRYsJ0PMqAxwkDwcb12G4YrLr+ElRHQZHCcIDMJbnyw30tSeN9iTjsNpKYE7PMrxeAQGui8BoNFKYA0rmx5llOfcSgztyomeC74s3ma0k6PbnaVtLrnGMFiaOJvgKi12QTMNDAkvEXdp/+eoayV2XmYJpuoz6nAPWNl9etzadPaczbxkm1HDKr5vva1+f4Xh1oy6HTCe7THfsfKCtXWAorD3WCaNmp6BB4BrIiT4FZygzedYTu39lxVC7hzllf/MITRm82ZZx7CTwCgaicKeb7yu+MCv+nMQCC3mON2zHvlZ+fN4acBj4BnMELoF27ocaDyEQwuIeY/omNB3UwczxDn/hiHwoRBIke/BzHFxgLHLVogv9HyWaHdr+xzFW9ZlUtSVZbpH7cfBfEOUc1CAcFzSZW4SagKKnGFJPwbOnvD7K41nHY+ITgaxi34a1ns8Ho/AAADJdeadNh2AiaMAAx/pn9DNlThqcQJAIgVWoXsfNw5YynaYrXOhiA4H23Qh4y3HC6Kfbk0PAcp/A0cgDrp0mQHPrJcYUiSmVhN8s/67BimGmQMUzhuwrODO7RtAgHk7QrMt7DogvA7zVgIYzDsJS3kGslh0vM3xieWkuURz0lK/OxJgZaoNIAxfjKAkmG/VKJ8IXhIAPdxK2D4lTpKCZ0IS7tI8am6pPzUXAex2AB8/w5EbNlo5wI4D53PkLQLUtO6HtUFEzbAmhdy9ey9jAxJZXhBf6enTQT7ruhm9BJv4y7JOnh2kNvV6ma0rtsyQaUIi1wG2uB8eNWftzoYX6Hxoxi79TAm3og9w0n/v/SDf6/HYBIYj/rekaDMCcMv4PleudqK8PQkgeAwyjg5AsbtRgFqNgupzK9MC+2KmAZt79Vg557s/a/zQMng5UToJMS3O6YkQbU3AsQttNGvXY4TYJ3YaCxJ5K40/AE+lfUHee/MObj97hbwq4R2QD8D8ZA27tljoK8X+mWITn93Xob+4o1wBsH47NaRdLS2vU2NXDjd2LuYz6xDQPp4BwCY+IcxVYsKTL4rLDyfMd+QIbJzO7WQzJY90fwL2z5ToQKgThYKR6gzJ4D10nZEUgRVRvgFoHR/HeXTw8/Mk8PX/4zk++A+3WN33vyWGMbb3xYAR5cO74AxxST7UsSKVvawMz4qdfpmNkHR1bYu1FNSdTaCKxdttjCGvXq0Q3ISU29Ts3sKNQiz//+EBuI9yPB6BIZl5poxjc4BmJ2I0qnMIp0hsStmG2/LY7oD9Hro/eI2tx89Nmat46r4egaIYbsx3sPiUaHYcWFtqF4/62tZ2UnGgU+Jv2QkoG43swbIKCbUlM5MgS/lzU5ikoyH0DALD2yPW44LNyR71ydlunwAUcQBSw8egnFQgK+rZgno224JwV2rAFzD8syWmvD5e3i3n59vWcqTvYyMmuSjJF82wY+sT0dIVxxzyztL5sgLGB+mo1Vh9IE/PeBx2gvEiha07gc5Uuk6KB1nAXu/wRMVyal2oo0Xrhw0IdpzFz48mw1N0SLj38TWuPmTBovgk6yOGKlrJF+CjdiWF3x8BhO1Ov18WwbISG3LktX/abCCbTcyaRN9doISaACRxNUnGZHR1cAQOV0/GFGwKqmo5GkbzfjKG9yKi+ud/KICl2HAY6s17STXQBthqtzpj5L0AmzWOPCLoCk2xCrycqLalW0fCzGCPjESdZCS8GPsdCmhyXO5MtFOD6/fVyoO0tLaViGkNbAfTMB6lsSnExswvp+5pUCSmWeW94RL3L07xwWfvY78bgRcWzBcrYFWwPF3xAx/9fXzXnZdRNOF/efXbcO/yFMucUQ4Z+ak9RBSSFIfzFdJ1bjZvpaHuBNpMQs7OBVB8VD3PQyrtuqzZsgxmLWn2IAGgbIDNW4rpErh5ToJeXlbEYyrSIQGe6azOBUnEAtKpRsDhYgRaah/KTt+m51uK1T0PWEz/c1u847WRupI//nCmeP2Hz1BWwOYtm3nR0+GD1ehYATEHllA0oAVaicP/yZfgxaIJ1i27uraZk7s9sm9odGWSYWjzJLpyI3Z83sYMGkBPmDIOxByZgiI3izfSoh9RM/F4BAYAEIGkBC1sy1ToYW4W29udZw9qGcV8aJ0MMds2DccnB9VyBnZ7yMYdej2CpgXQMUNXI5ZbOSYa9338YBOiffHVR9VFeUGwzRe7ZjT6MVPKEQaAnfggWDEJNR2fIY2inA6C+YmCD3zdXSwloypwfn6Kejnim194E89vLjGlgg/fuo+fePrX8XS+xqwZP/UbP4Vf+41vxnAjmM8KhsuM4ozJZZUtvT8IcLZg+tA19m+eAAosd4B0k9xeDqH4JN+AhiWRQUmrqXtVZN6LS8Q9y1jsttM3FoxXC2peA2Ldg/nUF5GrIcukKLcrtpNYaTMD8EyB7MKeTk7Z9nymGK9tQnne2mNieM1ipU7fQowxdl6mbJ8jv6LrYICBEcd2bqm7FsiY5LkoLSBo8g3D8Yai4ixR1qoV+ewOyv2Lxmkg25elAZWVBBAf0kxQRdzd2P6O8oFagDQ81Kp8tFLisQoMupQjxaRs1oYz5AxMKWSqKLDMop9dGdOwk/ME1MVTG+cveIRdrXy3VOBgEbiX4RJ87L0BWVcvGw26LTrmH48+sPS9dgDBdgxloANZMaNS7P58mfH27z4HfWmHssvImwU/9r2fwh978pP41PaDOM0HJKn45O5D+NHTz+C/fuOPYH++BqaKUhNExcoJZQbgQWpS4JCwu1wh3TnYBvL6Kha91OZkTQ8DWRDTn0Or0aXtNEax8XOGNwxuFosDkPYVabtgvn3cudAETA+sZFme8As2u/z7ID7DE0Fo6jsePN/jA8tUVjuJsq+O7fF8f5oQPpKARGZEp60CxfTAgkj2YMLSIcoT8joYrFgq1PY99u1UdNcTAOj1DbQq0umJeS44DhDXMvBOA9dupH3oKNzlKQxgXZVJgRZmK7mDZl316G/RltaXPR6fwEBLeE6dIrsxhFS1lRgcT7f43wCN4YiKtE8QzqBwVlhz4c0QVWApxmMotmtQg18nhMSX6zoWuAOLHN9G/CG79TuNSNARZvpBKOqU3LQIxF2jBN3FDwBJbeLzpWVK6UTxZ575NbyYL3Ga9vgbVz+E127u4JeuPobfe+l5fO78WXuPbEcCRqiiK9WgyFcJ5Y7l+PnuiLrJqFOFjE61HhHBJG9NE1F8N93dNsxE1FuzyZmFA4Au/c47JxE5MWk5Vdz/+Aqbt0ZnejL9b0DfsBWUW+InwU5uWalL2v3id3IRFy0USLXhD42zgiatdryjrOzn5bS6TsP1FTcJH/k7b0FXI774E2eYT63M4YSs0G50303vx9ALrzTb5RrqWg8oDaMSyOkJZG8ivnp1jdBA0KT40LoMUQ6UgndkB0C7jyW1j6gzC3lbG/Rm6IfhQh5NL/H4BAagYQZ0zCUxyRWSKPBvAQY+orT7uufQUaGeQah6hGUmtaKFcIXMFbJo7JqpALJvFzuptjQMjfrRH8vbTJeAANOsz+6Tk7xPngqQdoBuunp9aWVHfyGWNfC93/ZF/Hsv/ArullsAgGezAriHX/vCR5FfXUEHxS++/e34jm/6El7PT0IOguWpGekBZ3Z6mbJLPvUbSNfZwFF6HZwU5DcyypPVHp84bLc5UNc18+QGpC7X2QxZR8GwY9dAMF1YvW6MQcXlRxSXHwVWb7d0PM3APBpgONwYK7Ku7H3qaDs5p1aVlX/dpVu03mXIOzvHxW+XBSjZ/Rp4zmf//lySbm/Auif7F+/g7e9cYTmpWO0kQM/xStpH9cDHTCG8O6W9D4KRzBLBjDK1oKa1tnKBRKTJBzMXdHoIbzN2HAb+bhlACv1EGLPw8A4HAC+vWWK8vyX+eAWGlC0T4A7vLUZkHzJDQJImLexaAC2TSF7oc1zdApNcj4M5RatC6dC7GiFVj2rKKCsIeJE2vG47p8AxgxvfOTssIrkGQrs6ok9NDa2XmDx1ZD7rJJzhRvCvPvNJfHr3Ej5z/QI+ff95/MkXP4Ufu/1J6DZbew4C2SV86ksvAHMyi/VdDrEWigGDy6ZCRSF7c7VabhXIbASjfD5g/3Q18dZWcLhjHZbDUyaGopciMvyituxNJ0U9CPREoYMEt4GGLmWtGK5SdGai5PJddbhK0OyA5cFOuGb1KVYJw/74vNnnRRDPAIS5DO3t2d0IXsZsICONbgmsyuw8DwD0gCQ1urIz4Ytd/TWrB5x+zmdfRnZxvW0U3TWExSZO6XZrGcHUFnHffYi033GG4C+8w/dxbvbxHiwCmNTW5pIkQX56VIzh8WhXAi01okaCpcO8GI5AIsdqZQHA24/hAckhHDkBRaBj6tItZ59NI/Tq2lNMi+Jp0ait++GoTEPLGjFjgBeSAXISKSMH1uadtIDC3U3a7fRoABA6CtajdWz8gcNZxU1d4bXDGS7mNV5/6wx/8wvfi9syYzgfgApMF4LxPEGXhLQzbEEHjXapKDA/s1h2s7OvebldfGeuBlDeqtBnDtbyVI6g96+D9velA79c0o0KlNMavgZBmHLRU97539QOh1jagiGrcTkxzGa8snrfLN8QpjV95sYFyiPvEYNmY7YH2mJUMaOZ1n6Wo+9k/YW38MKvXmK8SMhbe/xwJY3UJAAt+pjF9b4OPSbVruEWWCjzBmDgtwjqfg+OnKNTGbOD6DC4P6lMk92+WoXMup9dGROqendpfk+0kusG3j6qJ8PjkzH0rcZxskg5G4Ygwg+WjmnQ/QfuBnVYPVyMcgq0NqWTTO78/gH1dAM5zEj7EnhBSa1EyDu0yUkj50wKlrUi7NLUF4EA6qBi7eZABLKdLJPo1Xk6aDNiLWaxNt92FuUze1yUDX7l9W/A3fNbqJcjfvCbPov/8vU/HlOyraYW6C5Hejw+yJjPil2gpwXDvQFlUy2bULd0S4DMycRMFUCVaA8ON2Y9X069fCgCnSowC4TeZQB0UyG7ZL4J24zx0lL6YWsLg1yJOjjeUSSMThh46mBtRLYkT15LR+AtVa0B7qUuOIiDhO4SReC0r/ENr/DnWY7PfR0AnUZcffjEyhi36AcQnYsgTOnxd6kJsZ2qGN7Rt1OlI1mF5ma3Q7p9K4bUSm7Xq2Q0wVQpNuaAsy0BYKkRAAgyBp4AGA8CpWUaOA4CRqzSeL33ejw+GUPPzKoFoaQMFWX3VnN2d2gHYXr7N88SymaAiBi3gSmYB4fV69c2uxKAVA2Tk3DmcWwBQDDh8o0gb9sOaHx+MesyX+DqC9QutpZuzrdqGLTUqbXDqFA00xGXX3/kGn/2O38d//sb34yr3QopG2HpxfU5fuUffZsbubbUeHiQoesKnartwHOCrgxILKe2UtIhQYfqhCxC7EC+ztBdBsfqaXLwsAIYGkFLPNXXrBaEZrN7gxiwF6QhgbdiLdgxENTRanT+HLM2p2ZpR/yBZrfRnuwAxr5VyrIiJOYsAToOwnJq54o6DR6agFf/+PN44wdScA7oURkU8nKMVaTSulN8r1Lb5+pp9KGbYKDL2ezi3TMhrmUatDhmQLozuQk8Am8g9uDEJhmGYAxH+eE0aP5dZAu1W1/v4Xg8AoOqM8DsAweoQrEUbd5o6VZKs47vZ094H9d2IQmTlnpzA6QUqrZ0s0PdDMCQIdVnMzg4duSpABxddJpslyPpqLiMmAYfHKNOXUQMt51ZR7eLDmr1+HJLw0D2pe95Df/Wt/xf+OU3PoZ/9urT2F5PmLcjTp65wc/+4x8JncV8W7F7zlZA2gPD/QHjvcFG0m8F6TJDthn5yqBzMy8xvkLaJsBt4OpJtUA22WeBdzFkEeCQoKel7YYsKTy7EWcSAgiJNOA7+cGCpA4EWK0cM+qyYjmxf6ZLcN+JZKQoKxH4ot0/HmRP+iUStvLavrN0MGfq4p+LzlHxHjeKJz834yN/f4fx0u4btg1DkIoANeMSlda6JQWb3Il4jF9Dje5tpaqwlGUbcZljVw815GplwYGWbSwDXEXJjgWDic6HsHSzF/fMgoQmPo4b7iP6MTw+pQRwNHzD2paGMSBJ4zMQeOScCR4sFZxVVjuMIVRqpI0+uIS+9KTdtm9SZimICcjitbMpDxXjhVutDdzFJBaELf7uIvV0lG0zhT3fcmIah2Xji/Gs4D/+4V/EKs34B29+Jz7/1jP42Zd/CACQ1wu0Ck7u7HDzYI187Sw4ljtFsHu+mBCIvgi8BmZBhVm9s7Yuo6KuARVF2nufdBFgUuiqoizmHjXcCA5ra3eiZNtBOXQ3K2SfoScFsk+2+LMES7IOx+Pw+vFvywnCG6L683PArT3YWqUcT0/KNUlKjcrcnpPt1SgjhraojTfR7Pv5XXDRvvbDA/J2NKD0Wnx4btsYwmTHsz5NgBwQHcRej9HL9nkbSXNsfUs2MtMRNbnLBMy8dWi7PduSJD65caxWNRyiiA+mcaRWq5UlXQAJKcH7OB6fwNCbtPTTpVwdiT5ooDZNBU/usljdtSzgPAcAlol0E4ElWRZSRyNM6ZgiuvOC1MEugpA2L21XTLMFBMp7j8DIAhSHs5lGy2zZ97JxQdOHd3jx6Qt8w9nbeGF1gaeGK/w3f/Av4pW7Z/Z27zsukDL0kLATII3VdrTsJKt9c5JevZ0w31HMH5gxvjFifqIA3k2Qg2UJ5Y7t/NrV0ToAOlYzgtlm5K2j9clxBQCoxrdAgn8IsTKlCFAEeZtCEyCeIZcMZKb/7PL4Lr9/2soZwhU6tnKFNGbAgVgVSxBJVBKEJJwDZINIpPC2JMsLoI5sF9v5ohamTuqzNew7H667wOKdEwDNCds/C2d60HPjiCnryRPLUAaYtAiGfW3eo1Q9kqTU6Rl4bUuyc6992dBzFQCzkU+5dTmSQGs6AidBy/n3aSH/+AQGRjaO1lqtvNOwNKIT7yc4SZbkYW7ejmqzEcoqwdiUM1DNvSn1HQ0AupmQ9gvyTsJghHJmpp55bzx7TYi6GkCoKlnjLid+n1+k2eXcwWwbFHVVsZkWfOlLT+Plzz8HOQh+5Ac/jevDBBHgcHdtTRZecYMi5YKzWzvcu7UySXXnEnXySsZyAsxPLUgPBiy3a1zYMttMzpoA2WZb0KsKuc6oG0XaCpImjM9sUd6+BQiiXSmHZPMiNrVJzP09ycHaleoBBY7eEz+h2xNnddDwdtk0d6rWCvbfXZ8yryqmewnlzMqQkXM1c/s+AgDtrvW0WKxaHABdTuxFuIuzw0QzHKlGrsqHRruOEtLBRj5vT/1mBtQTtfpOSZ9dWCBzrGmzgV7fxAKNxe+7P4HGEFZROFUV0X4EoIt14YTmx2lo3IWcQeBRpsmek3jG17RWIiU7CQQbZ58JwaEz/JAsMVK2oKFqmYWqlxm2O5aVHD23TJOBQEFJBeRmD12PRtJxMREJMlTz0VTF6vRmoCqCGAAbY+pZ6/rk61q9g7HYoNa8E+zmW3jq6+/hZrfCi09e4BtO3gYAvLJ6Ag9O17h77xb0erAd/yZj3q2xbA748He8hld+48V4DfbwrTfvg3lnAUZAbpzXUMQ4DL6lyU1G2qeQQddVtXjMVquDr9n1E5rFrjUo0k2CuuMz1FqgPRsxZnWSZzC1Mos4QegwANNyFHF/RtNZ1Emx+0DxQFtR1oKTV72cSYYbMO3nIFwuzuTePqz9l1MFqjk29U5ZlH2HTb62xd8rK+ukUNdz8LtlQA6Tl9yVFN7afFjyPV5XYOVj6La7JnbK2QIElZEAgBxTp4IbQ0YkABl8LdAeftaOJt2CTdgVcCoVuxqPgD8+HuAjBMbxHtuYrvW6gYwBoHSLvRYLErULCJ5BTBeC+UQ8nRqB2bOGw8G6FClbRgFAimUYHBSznCDG0HH3CMyBX1YHdJWV7Qw2/4EIuYGSZMTZ4wztH7aCi3/6NPDJ2/jSr7+E//4X/mX89hsvoargX3nxc/hPv//n8UPf+TlI8vFsm4LzN2/jbNrh3/9Tv4jBlY6kJddJMTyzBcQWOl9fipUB+Tobqr4zXKGc+g7jF/D+1dPAP0zCrJjuWxCb7mcMDxKGi2x+DZfJn9MnT3sb0mZEqC+abirX0jIxvp86WQBg+RE2c1WAaqVKdBFUwmuibNwY96zicMdk0pwbAbRFqcnMbVClsVNr614Qb2BZwGDIoEDLfL62v40jj4ajMXm+psPPIbf3Yt+Tc3FWTeXYlI+Dj6vrVqwkm2fpxD2Sn9LkXQd3Y3pYO6Gcpu1gZhuHl9+V6/DljscjYxA4ADMH1qBYWlcCHeionjnQNp5sSD42TaGoo8GsnJ6YUpOeDrV4PSiAqnlASqtPS99COxhaHqc1+XXjYJXAU3+1HY0XBC+OOsBaf4Dt6LONTmN7Mm0Fh995Aq8vT+LvPvsB/J8f+yj+8sf+ZzyY1/jsa88h5YrDzYRPvvICnl5dY/Mv3MXNbz2NsjKGZDrYUN75ZIFkRR4qyr2VdQ0ERmmGLcx8nWwY71hRYYHCtBI2gzJfJYBKRNbLHLoyS7ONq4L5rLozlSP4xcqlZYPO3FWDc6E+pLd1OdBKjQEG9GbDMfJNOhoenA5Wzo3ubWms0SY+k2rfWV25h8XG/SdmCw7LiJipwe827Ob5ndO/UdtzHtnJMWvgz14u9NLwyBj5vcOfY8jQW5vWmnQZdd3vW6Do5lNCK3RvDF/iDHW/N9IT2O4koA5Ee3NcRVkS7UsSqL4mMwZFKyFcNXnk40h+AvUTdIlerVpnQgxTwHxwQY8Y7lCrza3MyWy8JQHzgv1ZNt/HecHmrsYO0O8E3K1YThBMoxlH3pngKO9MLTheCrKzCGlVVicPCsUWgfrUqLyzMXqh4FwphsuE1z7zHP7++XfjL37oF/DjH/8tfPsLryFPBfWQ8ZtvfBB/7hs+gfnrt8Zs9IlLLz55gTRWpKxY9hm6KTgCx1JbmHahKuTpPTAoljvm9jSeJ4zX9hloxbacqLX9VhozMwB7LoJzdbIMbdiJfyZ/ycUAvvHCGI5lhcgigoZcW2kBtVZq2tuK00EBF2xZu7Nzx76ylq29jn/9xb6f5VaNobmVHBMHSAkmxmIGywaEVJplBKeZP6yeBFpQsCdAO9fEmJgxVWA836M8cwdyvbMNrzd47eZJyDD6EFvPBhxH0GWJ8iO8G/uWp68JXXwgDYMEnZzo6fCIGcPjERiglu5LagFhnFomQPozSU3LYv/2e2tP+kBbPn7YmUIPVc29aRpdljobkptsNB2qgQX5UGNniNLB01CSlwDYDuoXVt6brwLLiMV/LidWh9PIdLixYGHP5fXw3uvcuZUhpFjnveDv/ZPvw+20w4/c/iy+7c5r+NPf8tv4Ix//Pbx0doF/6eSzOLm1jxq3rBR/8gOfxMnpHikXYEnGQUjaWJbu8FRuF8ize6AIxmmB3GQrNbzLwUynjs1zknoGDsI1LKLr+niNng72uehryVJKnPBVJzXQMmujC0vbbetGo4QgW1L8nNTs52rdlJ203AcQTlflxDQa1VmliSQyN+ENAxdt3yWNZaNEkJYx9XRnYhGUcpMaDXQtyS7ghPR7v0DmAn3ldXvMNLWMlw5ObtsGrTb2fjK+gwyjUaI9gERXgjZxtbEkyZEIBrDPslRmzY/oEv14lBIQb+fU1l0o5ZjdSL+FnsvAQJKIjmdgWdo495x8NmA1cBMAVKGl2iK9dQI5zMjbCkgOyXWYq6wNpVemwskXmVufV6cD0PGJ7UleRBwqs5xqS03V+/MOdg43ElOpyPzLVwl/6Yt/Gj//8f8J3zF9Ak+lAZd1wUnKuKgFf+ojn8Tf+oMfttNxELwx38Gf/cZ/gp/97PdjFg0wEgmmXpyA8uRi3IgiJkv/1G2MPveRzL3lli284cZo0mWy36kVKSIBeDZswPETbeClDhp1eIinCoxiPbjNnfNB0uJl1SygFmW4ERyeaBkKh+jUyd/jHsDgVO5zATsj9F6AZyKmjm07vwBHVvTosgXLfrRhCbmVi312EV0KaYGiL71Cfp2tTJPtARjI4N3bBucAopZirNLwYmhuzjFwZi6ghPpo8C0dnLykCEyB/AcSmtS4DNpn4O/heDwCQ6S8xyCioXUsQIFwYSpL4zcwU+CRE6brijp45CzVyCWAy189S9gBuh4gpWC8WiDL2N6LOFmpWm98vq0RHGjBznIhuety/K338k14o2HXXlbu8jQoajYqdXLFnsmHFQoER+Lzv/tB/LHl38SfeOHT+NbNK/i5u9+Dj5++jhfG+/jN+x+C3l4gVxnzLeCf3TyF/+TD/xjf/l1fwn/4q/82dEmQdYEeEmrJWL94jVubPS6uNpjvbbB+y6d8Jxtdr77gw6QkI3wjSPAKO7pBDcqZzcNSR0VdoblTX0tMtw7rOHYjFCiDHu2sZeVzLw+CsjZ6tVxZScEAW7NicKs3djek3+Vh2YpMAP0sbGF75qFtwfclQVmhlUdOnKqTW81rKycBHI8X6DUfrtmIbpV3aKRY61S2e+h2i3J5aZtSLT4RzTAELYjdPwbTMGhMkwXTzg2augq2KsMUNmzgfKMk0LlaIQSIHUvzyx2PR2BwgCbwgmk001bOl+h9HqO0KK1bMQyN6FQVw01F7dqVR155yequ9XlBOR2R710BasDWfMcupJo1pkMDaD1wgoZFIsUGEO5OdGDWDNohGNKeAI6Qx2KCo3Qgl7/V9NUH13L2xKu/+zz+2m9+AMupmc/88vpb8bFvfQWff/VZYJeMkDUqPvF7X4+fmn+BtnEqAAAgAElEQVQcf/FDv4D/9kf+Gv7m3R/AxbzB69d38GC3wp31Hn/w2ecxXiSsbywoVXGwDr7LscZ2pF/voNHC4QvEPQwhQIUGWYk1P0HYVAQlVwzXPp1Kvac/t1pfM6yTVlm2+blQmBHuqGacM9iiLb7oFs/imJ2Qc9CTkcrGRGHUVCwbN9NJDQztAeK+pDFLfy8zDmhGLR3XgfhIAMwdZZ6+HocTxXhj10e5d95EUuNgg2X61N8l1lzkdlG5Aew4QMTbkzXZ3x9sylRwf4LzUCO7gDj46ASnr81S4mYL0KLNywNNGeHklBOarVtpQYBlxWEGJkR9NV4cUIcNsF4Bl1dHc//qdgctBZvXbnD1dacYzjeQpdpk5Q1CPt1fPKkIysjBql3AYa25tyDCcfQMGH2bM3gGXJBcYL5wos7dVMtAxLCJ5VQhTx6QpwJ95QRf+K0PYtjb+LflVDGcJ6RDxue/9FH8heEvBAUbsOfOW8HNAqzoSekTrIi8V1KC122nlWqj4eZTJ+iwRvfFwwxIJw1QMJiesExomq0DMt9utGwzmbVAmPatrRltYMdv6sr8KukulQ9GnDqcIUo78hfqqcYgXpNv23nRUcNZi2VF3rX3yrSfZUBZGUhsnQ6Folnlh8S6A03DRo7fMTpOhe9vm7dqc4gGfDOTWNDkHzB74PXP9mKaxja2MWdTXnLidW54Q7N662TYJEapAqhGjnqE4zEBH9FEVLRvo8ISQNi+kfHF25PjEiQ4+axLUWvJMTtgICEfXYYB6fway8ZqQKnqQ0KkrSoASA0XUNCeTJuu3+6K0iItDiKCOIOVI3axiFui+20+2CQWh+8+6cYMVdJeMD9VoLcXqArm10+cP+EtN7H3M9+u3kazHXy5XcOxKYcfovsrnlbDDQi45fY/d/9y4u7UPqwl0HkfzkvvBPXPVCYbulvWbnDb2eEDdk6b7NkXKs1sfNZDtPvYKi0SQ26GrRyd0+oCMJ4D0rv53RGjGB+keC9pRkymChcupvy1lRe9wM1o4C0ohJjLuw79SD/eRtUlV9Xq3OjQURq4FqLPHigalJyPWowAUA9zZAIEE9l1YIYR2ETnBcnnimG274MS/WX/QkTWIvLrIvJ/i8inROQ/89s/KiKfEJHPicj/ICKT377y3z/v93/kvb4ZdZWlsRzFRsr1JCYGjWm0Dzwf7P7kJ2C1AoYBaecU0yED4+DqSrG0bByM07DdY9kI6u01ZC7IWxqGNhJMLJpA9xGDYlmzwkGoWOAVMWqOA1bzAcGlj5ICaCks+Dfe7nNQL18l5HsDhpdXzck4ue/B0BYsYAu2rK3lOVyZypIZQp3U2ZK2m9YBPcvZFhjaDlgdPJzODYhkh0Nq4wGwNbm6m5AOKVygeE74vOkgMcSXuzQABxslFhtnX8boPH+tELj5oifWwWlbPO9lrc52RGf9b21Uuxa8c+QBJcBRAob+3ZG7wfY0gBjXx5YkW5w98enoOxU778NNMfPhd5npEKPjuvYlsYKj6VR0cmIGTZOW2ukuVqvwa/AbHXQviJbmIx7vJZTsAfyoqn4XgO8G8CdE5AcB/BcA/oqqfgzAfQA/7Y//aQD3VfUbAfwVf9x7OiQozWoCp73XUuxIEIPgAFtJXm6UVmYASOdXSPuE8tQpdLdHWhnxg/8AQJfFdgpP26crDRpreAZoqz3z3gE2F7MFY84JTQSxpCJmVLLfL4t4OixHFxzgbc3BFkreAyz6Q1HorU2wbUgHL4J6vrOWtafKQPTvUU3CbM9lAGreUiXq789p3rRnK5tqwWRloCJ8Bx62Ps7PF6KUNlVq9VbC+m1pPJCCo+GvdmL8nC3dQhK1IOhgJkVOafZSxTsDgT17GWADgjSyLCojAYSTFGAdjLLSCFSJA4AUzXsDOFJ4RmnTfUc9vsDPEmpWRYi8+s5EOgCr1y+PtAzEzCijjhLDF3K0IA8H1Jubxj1gwGAAcPZuPO9sLUnd70NdSfk2BVWPenzZv1A7rvzX0f8pgB8F8Hf89r8O4N/wn/91/x1+/x+Vo0kwf9g7IdLnGUBOLVugDwMnVz8MpDiDMXAI+M6+ypBbp/b4lIzTwJJlv8d4DdTNYBnDzC+h09h3NTDR7+wTkyONJebpk5M500CqsRLLRmM3W060SZHFL2axBcyWIOnCZdUYf2QI6qBR31bvHIT+P7cRbIFZ5IYHGGkIIHYiVRogpwjNR75J/tzOG3CwcNiaOU06WHpPH4OwbWOJ7IsoSoo+GBQ3ft3b/5Sm10mDZ8DuBTsgQGsJWmvXgmiiolPdCaqTSAPOPykIyzxmgFTJ9plNrwDtMyk+Pz8XQdoejOxxij6zGG4Ecr2FbnetPGDJ0HESyGuQcYrsQYYmDTBav/s4HA5HwSIuf2JtbGsuc2t79iPsHuF4T6FERLKI/DaANwH8bwC+AOBcVYlbvwzgJf/5JQBfAgC//wLA0+/ynH9eRH5DRH5jxh7Ll162O8LuOkV6FcIRwJWW7Auj3Q5YIJEE7PZWf58O0JutvV5O0O3OqKXrFbRU5ANLFOtk9ENVWJOSxsvpTVD/0guipw8gLsw6ANXbYLwomdZS+BRoeGoXlSyWthOc48IZfIfv2XUUBWn251hp1PxkCgZqvyIS72l2lwYD3Xtx5NBey147yiJB0I+nS7FUHXY/ST4RDMSyl/BGYOuyOj6Q7JwOVwn5JkUmRByhuCOUdM8LWBDNO5snsbovGC4tQA9uD5dmy4YARHcicA3POphtHc6cienPT9PbwFNYIg4NfwgfR23vLTJKfv6geQOjb6XqOEF4L3L3JhFpXiztZ8bAEgBAmsYj9WWoM7uRc0dSayBwBxnGloE8IocBeI+BQVWLqn43gA8C+H4A3/JuD/P/3y086TtuUP2rqvp9qvp9I+xb0nludRLQmI/tjywrYOlA3/xuSI0FFbt4bp4bYmYlgGMr7VIwXRXzZQBM7NKliHQczjsJELKyz5/MODWChy8i7u6WSnc7E3gBIhZ5L9XWwbgS820NyfdwbezFsJbbupWcMLX39indmHIbiLPc8jTcJ2OjItp3cAAve1nAbCGmRHPXBgJ4DQ6DdK05xmWWDOJ6hdFmSu6fqgh6uTMVrR1qz01/iuSDX6rzGeSQ7HcGVX8fZQ3snlbMdxT7p+xc1aktcO7oBjRa6QPPZpg9RRAGMN+pRquOjMuBY234DbMhHpRx94Nv6cvB7wCw+8++MNt0tGUO2rNd44e24cF3dAfEKZyKLgMFhP1jOeW670YQlByHo/Kkf65HPR6p+FDVcwD/EMAPAnhCRLjSPgjgVf/5ZQAfAgC//wzAvffy/DKORnMmZZRDbFNXPuTUSgfSpHkb2ZCw3WW+xeJSog6jVl3nBbIoNAnkZoe8L43xxnoRaFoJ35XKygJH7ncoLzeSE5gMl/D0lrRZd3jqe+fiQJllDxo7kCwSkVSzBYuy1rYYM0fYW+9/OdEA7Yx9ybajhGUb+/10tV7Y5qutywA6Q3tAyDdWbuRdlzp3pULvixkYi1u5qZdWbBn2WoVI4ZNGOZR2dFESL8eshcpzTrv9vG9ZVFkrysYGAM93jlmLedsyO+IRUfJ4oOQif9i8lUpMul/3g216qjQ7HDEBfLH3hwRM5+ZsTsdmIzXNMFJTOcoc2FXQw+FIL/GwKzR1E32A4JyJfrblu5Ubj3q8l67EsyLyhP+8AfBjAD4D4JcA/Lg/7CcB/Jz//PP+O/z+/0O1Zyj94YeqNhEVba2qumGL/0wh1DBYQKBugseyQLdbrO9V7J/w26oahpEzUA2vkGmEZkE6lHhM7yIUNae3w6Id1e0OeY+jdBZAWKATmITjAwTViFlEq9CVfwE+erlAnn/oGIrhAUx1rTThlu+3+Ti6nuPP14w+vPsViBN/CBTaQpAYNz84OYdtud5an14GxDLY69cE3Hx4sQznMkWQQ2oSdPFhNwwQaZEoQWyg8DHoaD4ZGu3iOtqOLk6W4uKto9r0aw+YZfPOTIs4Ubh8o5U6xAsiEwCCLh2ZgGMvcQ0w2HL9if1NmRTD+Y1diw40BpORPIUucxBn8VJ5GWU0J1aNg+EHPjull1hHO5PiKmYSnEPxPsoI4L0RnF4A8NdFxCta/G1V/Qci8mkAf0tE/jKA3wLwM/74nwHw34nI52GZwp95r2+mvPEm8vPPNUYjrdtI8wSsRQm08XQ5mcU2Y880AsuC9f2Ct28x6xBgdwDG0UBI73KM1wuQDeVNh+VIZhtgIBcNdzku6AFYVl02sQDLpKiDKwMrcQhti5tlhy+mOsIYhPQ/dISeLbrgN5CQU6V5GWgLYia9RoB1nCpF3kDU6y5rRvZhNCeGsRCLABDmJExZAljz8XtHLU5mPouVQofnZ6PwdotsuAHqlEIAReYoF6d9Hi8luNATgGTDZ2hmy2B6lG1pq+3hFnTq77lsanQhGBjUPScZkIcrE8Ip2ndoGJF9Z3nXSkF7DRzRpNmNCNIUuvNz7wL15qZpHoAjmzUZJzN/dUPj0Dj0jkvc8TtLOMDLg+zMyVqgdNeijgJATHN7n8eXDQyq+jsAvuddbv8iDG94+PYdgJ943++IH4ylAudHkAJNBDZLS8c4hWoQK0VWK4yXM8qpdzjmJQBHPRziOWRRSKnQaTRT2AqjQ6MxABkUYtyZG5SaQ3TbLYYrMVuBEeGFEGl9V4+TAfgwoFkTXB0osRjTQWzuou/kxTsOdVKMl/44p25L9XjgNXuQghaEqxGAmMVQR1NJRlpcWAqh9fFhtf141QIVF89y4q3OAW1gLdOq7NO+xMoATqeKDs+mIm2TvbdJzeaf8usAG0l79k4GxwR6J0jH1q0g7lNZRuwBFAlnp+VEW5vYMxeWRQQqNQPF+RZkXAINUKQp7dH1kHEEOAII/KmfYxILvRZAC2ImRMotIygA6f+cMmVfTIqAQTyiHmZAO/8G0qr7bIOTsd9nxvBIGMP/rwep0J2TbvzPD9uTN2afVuVgY77c+Y5raZXOC1B9lp+jujIXcMallBJAI4Dmu4C2Y4fLMFFu370AHLHvooOgvkt5m5GEGqujJepre313ZnrI6hxA4yDsbTGngxy/VvauhC8us6fzINIReWLh7yV8CuLga9Zu11PrBiwb+6cJAfZNl04zPrjX4rXb1h8EOlaMl03PIMVbjc6pkG4uBXUn6iQsHV3R6f4Omhw/6RWMpZVCIZX3RcrhuUHT7tiNoW1ww5me/WiBwyXlHoB6QxYOn2FQKB3BKZSzYkF3dc7L03f4nA0YXK2ibCCDUZIE/4BtSmJhAAJD4PPVwwxOy+a1HB4OvK5zstbm4RFUUw8dj2dgIGeBQhHxmomDZkiNBqIjoexWAMB8QLra2a55mL3FmcCBHXRyyvev8eAjZiEnuwPGB8fpKoBoSwKIIac0YVFPo2n8WbPt5NyVWPcnBxNplFI9sAxbicXJXW/ZaEe7tgvLlIvSTE2kdUBiIWRtF+fKd9ouo5Hib4sb8yxhaGsn0P7Le8H0oFnC038isgju+rktOL7/zZsJpy9nnPz+iLQgmJCi9hnWb6fQi4RWwl97PE/WwrxMGK+ky5zkeAJ5QmRg8bu/Fy5UANGaFOeVJOdL2MJ227eR5YVncF0bEql1aeBfRevqIIhlgGMP/lgdgKc/vYNeXyNq/mE4ItfZE3aWbq6GDD/I1SqIflpKSKq5EbIlCVh50rdCtZRwhno/xCYej4eIqj9oD3+YEWYWdIYGmos0GWDTiBh1z87EMADzYjvr6Ql0t7OSAbAvw0sSOb/Esn4ecr0FphEnb1XcvCitLem1bHDuO+6CTtx97O3a/eIj0YDkeIC1wyzAmW05cVgnMS2t/o2dhyBi9Y6AKz4jjDtGUTauNPSMpqw15kbq4PJhByuri4pqtvShunV7mmnS4sErWRnQqxVNdwEsp1ZWMFDS2CSGwEzMTBDOzNkDHkHC6UIg56YwxbW0dqIHy16hmg52e4i2GLTRlQyw12XblNTpskYDPDv+SVkhAFaoDSauI0JAxVKFgChxIZYlPHqPhuRlStlYwBvv3jSLtZxtMAyBw/0eab02Pk1n9AqgaSVo68a/oZW8u0BbsKjOVdDuOQyAbLbzAt13SPQjHI9fYADsQ2Ug7NyGwbCDXkgFIPwZyHc4zKaXqAWYZ4wPBHqyhl48sG4E/Dk9tcOyYHWpjmEoVhcFooPtDAf7wslmC2NYthNXakGZO7K2hWl1r7adtZudQEzA0lxKkJ3leKKWASQD88ZLX4STy4hhvgSL4xtNuOO7r7dDlSUKQVMmBallCsHXmLSlz9UWblkheA6aYNeb0457c1wrb+zUstaPYOGvy9qcNT7ZicYObbss0M4lywX6NcoMZA+0ufO/KGs7H0qQ0Hf3stF3LGwqP6mxQEIzfoVjSwRea/d+uq4L/wfs78nQhHM1ykqxfkuQLrcoHFffi6dSdYajt833e7D1zjYlgGbrVgqgrqXoSH49l4HroJGnHLdIHmDe5/HYBYby1lvemUCbQlW10aEjkxAPHKWRoJJYRrFaQecZJ68r6ukaiTwHwFqixQfe5ownPvEKdt/0Aaw/8wpWb+2Qt7ePgCQAQdIZboD5tKX96dBaYFxY8y0bK199oIndaa8dlurdENaaESPjB+dFaLKfDbCzWn05tectzh6E+LAUprsCUJQks9jp8R20Zo2hurGrLsZgJAEmuzXb4QkHCSFtJNvStfr8vHCP2j2t6HkAzcUJwdNgu9cYmRIZGLR1Ox5mOkIfyjoKIoAlz6zEW6r0TOCOPtxIYEGcX3k0qFZaNqSDZQ060JYOfj6knVe+pYd+5206Njziyc/Oxrbt6v4mq7YFrgdrxcfkKUEzYHHdRLilk6/gJrDBXWBLsiq0IIbXBm7xiB6PDx+PJ8bQGbYg54Y37Ped2rIt9mhVsq46GJFkfVGxPLGKWstGftXgM4gI6r1zXL00QWuFlIrpAuHDyFZf+CH6xU1LNgANfOoAKPH0mHoJwIKC8fvliBsB+A6fzEqNJB+ZEe02q239uQQOyLWUW4AA5OhVEDgFvPsBxLBd7n511d7rcCU4PFVxeG5BPlhQKCtnMw7d5/NdkkxNpSMT7JwwaEK97ia6P/M1yVhshK3ABqTbpX0n7jUIBP543oGWEZAIxQEzXMCD4xXkd7BkYZeEw4aifIC9/sPdB3uxdu6iPentUkrrT7543+ZH+DWqpYRvY5CYpqlZtVE74WCj9gGDykq/dkOJ6de6Hhp9uqdJvx9jloePxzMw5OTZgCL05DGTz8uLZbGfH8YWSJVeFoxXBYc7RoRSVSeKsB/m5I95tnr3zi0AwPquNqPP2IntT2LAS2kXEcelsaVlwFZHIXb/g7BCc+9I4ypo84d0k9W68vmOk7tC7f0iTBqOS8N18pRcAwsZr8Tcmm98KI4zIllusLQIfQdjaXHPgwWok423Z/dl+8KC/TMFdQTmO63LMd8yU5O02HuBUCWq0VrtpdGs22OydYd72HfhtzPQeWky7BAKRnY3OBYwSEZDa1tyChZxi7xtGcD0QOJz22M9yPZU6BHWFSmt1On1MFFSdqBkP4xm8yYgPkvySBvBdqMv3ljQHThIB2h2HFCLTU4DjkoFCqTUwck0jUG5Dsakm8B+JcdjGRjK23ePb+CcSkqrh6GVEwwQPi8CgAWTccL6lUs8+DrnoU+jpW8iLWsQAVLCE5/f4/rjz0DmgpO3nFbquwXFQ6FM1La79Z4MvYyX05rF2wCBohNj8OdLbmBiEm37g5Bmq/fT3T8g7QWUYddJg0cA+KL0nWu89m5AVowPuowDCA9H/j5cu7fB1nbZ8TybwYlP40qHhOl+Nsn41lLt5VRBo9NI+8k+dAailTOI1w4/hdk349QCRZ0sU4oUnbFibnhGsBFrwzBqRuz0y8YC1+FM34EJ8bsxspWpQoetM0rdfyN8FtSzKz+vvWUbv99efBZtaViW+exvXUMfXJlkemngI4AYb29txtH+kdQEgPqfyAzoCwlECcGf2wT4bNwc+pd0Ri1f6fFYBgYArUyoJTKA8HukaKpvZ9LMZRgMZ9AK7A+NFj0vUG2pXH+svvgWtk9nyH7BeHGwBVNbWypSWO3QaW1eCX0NblmBP3FFTGqiryFv12S3K2DWaZ0OgvMiuUtyZzUasQYIpzDyzrBti6dMBghOFykWXibQ5yn3dGEj8+ZbtsPPtzQ8DNJs3hFpAcaLZLuw2u8Lrd4qgpvBxaQ+6ZrlBmnb5F/UwW9DC6B10HCLZuci9dmMB5xMXICnz3kLfVdkvHDH6hM9egw5HHw++96YNclRNkACFMueGDtI/CS6TzjKKhjohvOtAYqAtyhbZtADig/v6loV6eTkSH0ZgcWFUfGPvgyc3O5U635WxdFkq/d5PLaBobx9F40GvbRuBKMotRPuhxcTqZauX3xxhcOTFTjZWCdCxBiQ+30zmwVQ751jdVGh44B0WHDyhnHtwxtwOd59AjU/NCSeABg9BtgdMLlvawkK0CS8PquBXQpKswF7jr4O1n4TqK1FmQ7udOQXMUsbWYD1XcHm9WSDcHYWDKYLOU6vZ2A+q6ijxvCc4s7H6YAodWI6F6nafmh8IH/fi5nNakbMdlhcDEXswT4DgtxkDE4LAGwzkhsgFTEfs5DBqcDhyWqBabESglnMeMEt3YPqiucJR+1MqjlNnKZHHIbgrjjWwWAY7Ed+7i7zGS8FeOv+O2jPHP5yNLC2ehmRjNErScxljANivITmzIg411Ut8wh3aKdS06iFzOD3Jk36/zwe28AAoGkkYtZE9UCQWmlB+3hyHYbBMoLFaNAQoN45AdWZ9XprAqroDQMoBadfuoaOGWk7Y33Pvv2HXYiC4IN2O3ULROT7g1bz5CjQlt3+0BeTg2zMCvi8Za2NMu23h4ZC9EgQROQeaIuHqT3f93CDI0UkiUvLLY0BL0z5y7pTNLK+78BHAMZEXCQUnVEe0BV6Ug+a1rVgCdITktIB4cQsanNDh+t2eiiJDvGWn39NwOhEKCRzlS5rjclZdu69C+HEqHCTFmcteoYii9UD1UFcdoa4KVA9CTRORpSXBFknxa2XtY1XfFgd6fMgALhXgmNhAGS16qzknYfg7ktHQKOLpmS1chDdyge6QgXA6RnLV3o83oGBix9wLKH7mRoKcUR3nJrAKllJobu9IdAno5UZ44B0ujHPx2kCag2qdH7tHuan1tBpwPrubKi597+5iKiu6005DICTSP3t9YHwD3RrNwOo2mi3aKwD6LEHAN65MDyAAKIUUqLRREj+NHWygEBKMLoFbA+yxdgTdMIAVQA5pHBaZhsWaFLnfngMP3PetSnSxEyquz+nGZjOLVNZ3TUPyvHS6c0suwRIHozKyp937z97VsCSjcYvOrTX53ucb2tkc+o8k+VEo2wCjlutoY9I3eknftB9b8F9YHkk7XvvPUGpwDz7wk3zFiWA2HUVeF0e0ZeThNQ6MIflOEOwdufceA5UaYaB7GB8CY6vew9mae/leLwDA2BZQqk48mMgNRoAHDdALUZu8jambndALdi8mXDxjSf20K1riHM25ds0mdIyJejNFlcvTZCbPfLNHEhz9P7ZpQBa2szamD+TOUfEutsNWYtHz991A1ysmTyDAe6ODEf2JSjaPZCniZ6NiOcJ3YALm4BWChhtG4G0EzMRBVb3U2gvVCwg7J+sESj4eccHRs1eNuZOzbQ8LYLpvmB1zwLMeNW1Lb28Mf6CeAnBnbft7sstjQnUoT9JDXNYTtTnTSC+m90zFWmPkKgrEOk9zxc/Q3xP2oIMP78AkdXluS36/vsOwhhv9/uWjeL2/wMMn6MdCY40Et2N5gHi7krhrOS0Z5B7kLLpHzoadMixvUQgDZpO0fRosBf96izpxzowlLfvIoxg3U/fygnvQNCdiQAk3W5KtTKiKtZvK7bPimEM3QxL8dTNVJcFut+jjEA9O4FUxbCTIx1BX+MTIe972TGz4NDSf5ugbL8vZOMR4HICzXKr7SjRr/fFW6fmEcFRdmXdUneOkg9WHhcSmYY4bq0BFhzy3na65FkIiVicqgQA6jyDuM130JoNzJzOE6b7PvvBwdLqWQunNgVbtMt4llNtCD+9IciKJD06tfcenpFi3o6LZzHRleECpSGN+zlAm+ozcBsv+TS1LkvNCACYAjIGFqBhSnzPPUhMMPSpT12BHiKx+D0okIjU6xu4ycloOz/t4eP6cvETuxZGeBpDdcmyhIdMU2t1sjP3FR6PdWAAAKi6jbyfVA6fIfjYmWYCOM4uSsHmXsX+CYWkhAB3UmqEEj5Xzrj9yoLl1MhUq3uesqPV1oE3cPfw/4etlxRutU5gCkCk2+MDBxB9F0WyC3y4ttfgqDbOnFRBzF+I8W4bDWs0Lgo+f/Tz/TXoNAW0sudojoQvgtoNyAlzWwF0qjEhiwvA0mgjDA3XFvjms6bJGLYIJiNrc3ZMaHdH74ja7eZ0iO4FX/YZW7BjCbC610xeZO6+I8dpjPilMUC47xpUZlylAaPiHZTgktSWTQVJS1o21rMsywhs3hQMb16Et2hcth1PQcRGFwT2sN/H783J+bjzcLTzE38Aohthl7x9dj0c3vk3X+Hx2AeGcvcedLdri12Sz5V4KDpSXJW7jzSNuPX5C8xnFfrE7aCpBmjjikujUs/YfOEuHnzdCmm34OyLS/ALuDv0CkPuNv3cQvOAdDNWAma+a1r2gOjzh106QUvPQvJOWv0/ePkhisOTNbIR7qIAjtySw2Ksm7nQ6xCC3dcFuvA+hC+YyV2p7g7Q3DwWl1MN96Q6AbvnTE4+PrBOSj44zjEz4LRzM950C89T93xAuF3RZ4IZSpRLjunU0VD/OnnXglgO0LgIHmB0UFQOv2GnCHbeD0/WyMSOpPFdSVbWiCyGt8Xvc/981hp98ZfuQ88vDM9CW7g9R4E0fHjrmkYAACAASURBVNSGD+i8RMciiE8cItPPoqBjGdAs4LwMCUByMv2FEmP7KhyPfWAA0CKhB4OIziwpVNuQW3IbSgFKRboyXGF+zpiNkTFs1ojBNjnbl/eWEavqesDq7j7oz9HKYgrfXZhR+/tFZheQHJUZsjR5tBSb3hTZR1//FgJzGv1+mpUw9dUEn/nQqMgx7AQIvn+QgkjlLgbuhXw4cBCJgbFSu+xnJ1i/blFFYQucRCRNNlOC3ogEJfOhBYT+HLELECCfB46y0jY/Irfn6Wt6Ar9G8mrpPD8y/6ZvAY/nxt5cTrwFutEYHjzftjfQOz3TFIYBvTiIGbJ1Zg4kajGzUkBefRvNGAVh5RbZKdBs3z0gMHD8YbTmvqwIA+Ou82ABJTd/yP0e0dr/Kh1fE4Gh3L+PmDZVipUWnMxDb0ieTJ4g+kJud1i9nbF7agpUGIBFeGc+cnSdHmasLivKyQRRxequxBwCAI1B2CUqTCsjDQ7EuomFwkGJF7unuwrb3QWs35k2S4yXs4zFygskjcAD9V48Wt3LoKUDATl7TfIEALvoWXtzwjP5GMY9sPdI5+jpXHDyuvEfkFrpUtYIDIbvXbNnDmuESpQLjIFxOWFdgtBLBN25m+cR1Gi+P28f9u+798RgFyPN7fwwmyirVkLYnAyN6Vx9sO/1F8BxFsbbVZgBKk5fRpiikFMTpUCvVSAd2je2GCvnOzzdoenJEPcFH6JJtmPcfc6GPeTs9nBfHWyBx9dEYIhDq3UjSm2OTXSJptya07GdAanbLW7/geLex62TIeMAzI7wpu7EA5BpxO1/eh83H5iQtjPOfn8BpcO2s7SL52j3IG6AtsOkxTCCaHfFZ2BZYhhBT+FNThmWxcDKslKkPcwwdjDpNRcLnZiC1JSAvoXJ1JwcBA7spfZj/6Ri+6EZ67dSAyqn1hoF7DkPZ4qbD2jwEAC7P29tpyULkKQvjpULi3XW+b7DDjfW5iQXgLt1tCI57Qr2HNm5F2VkMLBMiZ6cee/alIJoMS8nGtJzDuNpbMz2/FHaRbC2m3tiW2/IwqNOJs76wC+/DZ1nG5RMtq0HBe76vc07JCGt1zGqXlar5lretSnTem3ZBQfHdM/Bjob9wvZNn8J+dY6vncCwLG00HXEEukSrNkUmxVS1hNvTyRsLDk96VuFA4zss41RRr7fA3XPszxLksGDz2jaMT4CWgpfJ0+axBQoAsQMBXSbhu1g8x9jZuVXYlOlqFy9ZetRl2Kg7hKkK4PclDe0EufykTlfvOsRO2KlC6dh0/aGKuq6QbW6p8oQYpRdkoGy1/XhtASh527HnL0TXg7hCJ7Puz4XmTmexE/sMswRpK0RNvnnOt2yRz6f2/qQakYmW+Cr23vIebsEvwRANgdtefFZHE1AxAPF8pkMz4GWpEwa4U/uOo21dLVt44vMF+vLr5ic6DqGI1HmBHg5IJ9YiD1u2oEIvjR6937cOREiwU5i4UC0crtCrFcLFiTJt4CuWWL/b8TUTGMr9+5YVMDqydQkg2JGpW+xON0UtWL9+YwDXZu1ty8myhnk2cZUfMlrpYWaiFelQcPK6NtclZsG8iBjktaHsoSx0q/PhRqKrAKDJsFmjFi4of4wCNrkaMQaOXY7llpUf8XeThqQY8DkKZOcR/BuPL2ru4MN1wuaN1AmODLeYXTPB3Zk6EQaH4UbC74DnwlyWugzBM4gIjooGXjLrWCRKhNV994Yo7XyMl61DwOA73Lgv5kGwOm8uU3z/LNXCkarLxuJK78qCYDRuu/OMljERdwiRlQeNvBWcffJe0OrVrdTEByenzQZ1u43S9ciKrR8W4ySlIEJ1O38MpAV8ItUUm1hiprH4NOyvchkBfA0FBgCWHbCU6AlP88EyBq2tnclDBPm1t+1C84nZBtYks31z5iOziHJ1jdsv740leXGNJ39vH4w6AMGI60ecAW3xHfW5iWwvRvqJQCKtBLGdUoOLYP88O/AL0tqBGqk7B9kQ1e/fV6S94uCbp+Zk7P2/7X1rjKTpVd5zvltdunum57IzO95Z7yVriRAgibG4xAkiEKLgIMgPiIiQQiJLSEl+EPEDbEWKlH8hP4ITKQohAYlIAQwkyJc4xja2uRhYs7bX1/Wy6/XuzM790rfqqvpu78mPc3nf6hl7x96Z6e7dOlKrq6u/qvqq6nvPe85znvOcrCZUG8JBKGbxXFlzfhOZCaXszky6UyveYRWEvIUrOmWNRFHFHC7xZvMdwJIWOSmMIb0JjeT71iaea7XE0gnP+ZMowkfZazplNG9L3Qzz8GpRkTgLe219r3Zsbv0gxgGx73Rv+qBVqHaV8fBHpggvnJNjm0ZCf+jO3fcI89rZiLeMkjPgMXEUALxHwgVdbZBMRtJBmcyjZJuzchfLk3vtUDmGfmMjekeimEqUVeynAOR20KhBeebDGwQ+siqevSqF7DSvtflEZeVDQDYaorqwBdb27GKnBrVRgtz7DexC1wvVAD8fk9YACBG8IqURlzs6oxJIBrhImc1aqqlTodgUndeW6X6ocxgq4Ub0o+gMDHC0hVTsxsc7acqGvLLgDv0QksJk0SGZgzCAEyQLAoiL1W5HfEJnQg4Vf2jlfYKgU8LJF55J6pOVToFYcVH9CkBayAXsk4O6lUSyzq4JddByIHm0Zr0fPhoPUlWxpihYWVnVuZ0oxgkmYpUbrSr1I/nsii+fQzYagsYjLxva7u7cBJsWZeIqoV+MGqxcqVoLRnu26MEYjU6hrqqFuRHOdrwH0QJwyBwDgCRd0Csy6ar0JiuT0uLg/IaVSwHt6SOe03HTCtFEadHe/55lwLWbaB8YA4GRbc+8WYeTcNR3FyuxGSioiHooZAe1UNzIMQB0QKuqOemuWUwyJfBkupBkoeUNYIw+CrKobK4EACnhJaU329nKCXyXt1kRUh2QxzVH4vxHR/ahAKQCeAbM2SIxAZtuhVGvC8ehG8El2LzLM4NEQYordKvs06MKpUtba3tKL/amJWVQdkMDB1VHsyanlxvhKG1PL6ais5A6tHwu3adS3SCfvF3ukqcm3jULxPREHYU5LPtO114CeDaX62c6i2AiJBW1tmdWjVLXfRwMpIpQxUExABYkAPbKwJt2g1zverwOqxWadNL8cpft0DmG/to1iRQslUg/HO+4ZAdurKfi6Jc2sfnEUKjSAEDSqeZ14kzrzvoFbD028OrF6adqSR+G+lCOTUvekJM4C8tzASwAhIYhFDNZ0OVuxCskHI8j6HoVaLFFay3KWQdUG9lCzps2cNmO3q5ABUol/2/XZJGZJBuSndfQfGjfgwyGRVywCqqa4xMFKxnNlylPIAwYgw1KKhdS6rWqi+kx9COhMueNPk7Ljs1RRn0i+G7dDaVByoVrkHSQKv3ZKh3W+5FrKsOlBkkWLRibEUn6ZoAjx+/F3qOxN1OHNT/BGF0jnP7IBdDZM8Djb0So6wgmJteOlx+tj0G5CeIcOl3c5FJvAFzv0cwxhpTz0LXy0zaxl+Ie2aFzDAAiJdrEW0zs1ZxE0tYKAOCAbGOCycPKEuuDE53Czg6cAamS3dw0coGurYD6gHK7wegqxRFwAIy2DESAzRiSon4kOb6RdSyXJVZBWd2RBOnXi14XtSHomUYL5lzyucyosLKbdxCq4+EsipqYI7JcvV1l3/XTSgYonr9pJ9gkpvZI8DJerqmN8SIAeMNW1sJLsyKjzs6+tDB+L0/ASUQmv0/Sf1HskmMMWSfKTNZQFhJHYM1YVjVwfgTg3JCsocihUEeS2eecOG/HGLrofFyYRZ82r4EHnp7rtReAr55fuCS57bwnwq4l4xlw17pTcDpzQm0GJDXIrHU6ITylkm0+3j5LWrLvkR1Kx9BvbMgNU3PqlbtgJR4rYQJwZmTboj0agKqU3FDJUdnaGlIuOutwmvG1Dv2JVSAEcE5Ye7mP3Y0aKdgiW1AW0gpCipjfTknIAD+zUIiyEpMqGwe5sPOZIPDFrupBapNQSMa/c+JQUmFVYxw2x6IwrEQnsZMzbRCzEp5JppXbmTd/SR+CPHb9WUiqULA0L+kbM03HrCZPC7znQCMb260NFO2HEm1UG7TgpFwoJSiOEOLitvulnCh5fzmh2DmZwx2Hv3YCLlpVx0uYSZq4d36Evf7aS8DgpZtSabh4xRum7JoxwRRSENuUlgC4zqPdduegaYGXKRsdOKOqTWwNgnodG+4A4J6mEcAhdQwA4ESmtDfCSpR5BioVgGwlqmCW2v/8r5wCT2cRV5iJ1LejwmUBIsLKF69g64kxuCyQ39zF6kvTqA6kIb4PKNGw3ByBlSwjWo7YpZhUDdKuP85kF5X3puKrWbxouzHDxrdTB6c3G7jpjMBMnjdr9TkQnZQtMAcrzUHY+9FW8PZIEOBQIwTbOU36Pa/Zx9ylgKvtwtYqXcySGRZaxZDSp6Rllop0YwEtOeOFuRVZH1W2U8dmsvnUCVZgBKuFSMZAUnPSwlUTunoLbyyzz9v6OlIavFWfQsE49UfXEK7dQH/5KrjtEObzxR0/cEwhtERpak4eAexRbnZhlqQSAWBBtcmjBEjZ8nbPcy/s0DqGfnPL+yEcV1CBTOQ5uG4kNRiP9Lgegw3C7hm9epSnjrKUH8CltMJsDt6ZyI5SlaCdXWTbM6xcZNlN9YIDEHsTdNeNZKME8NP+A1cO0jTBZM4t1QAQa+gd0BwJztoz1qOQgeD1dbuQva9iT2RiVQwgVk2sAzRdDJ7CZOIAXFGqYAHvdHcOFePmtxO6VV4UhNX3LqP69DsaMspd8t3ZHFFvU8JDTI9EXwL+HoOOjisnMRXwqoY6XeMpuGMrImXb2r/93NRhLURvHM/7Ft6HgqKhYowvE2gydeqzVxAUx7Kqw8KsSFN2Vj0FTxESYVdzJF59MHk2vT49lVBx2GBsynscLQCH2DEAgA+iMQCx6+DCsbmCjwCsQ+3k51tsPZGBzpwSZ1GWkipoI4sgxiz893mNY5+9ia1vOw5eGYEmUxx9cZ5Mo4o7i11MJv3VD8QZdCvy8kamsTDZW3iVJOX4hJY+Cxub1kdlZkPvjT7sfAmtQuSq7Gz6h2ZesUjO2RxHKNmvgJSslem0J85jJQCIr9sr4m85O7VxQVfbgoGEEo4XVKrMbJGMLzpLy5KGM+t+XFCNosXPzZvCmggUSqrCHrn1Q/3MAKdRZ3VsbvP/JaI27sy1CtONGIObhDd84ALCxmbsxFV1JuuOhE6hTsuRC7Jse6TiEbTLNzCy0cj/Z+XKtPRpTX4A7npr9dezQ+0Y+u3tiCdYH8WCzHaQyEHl5gfXZ6AA1A+vA2UhIFKWJRp7WQzjmIEr19GOCTagpticI59FSrCH8An5yUpw3iugt61BiLp4IfY6P8LBRU0t8vkidmH1fcMAPAIwzoKBoH1MWTy/t8WmObvn6Qb82YKr4C3csLSEkuOhC27EXhJ0J5KUDD2VsT6DPkYlvVKM+6GmDyNp6bbntyE+Nksyn5NL11EAmnXBNdyphNjRWcwBV6HS78M+T2eVZtERyxuSv53FmXSHWkTywNM1eDJFmNtE6kK0FJRaz00jxDmzPS3XVppcIDjZTMquFSWxpDMzRgqtk5zS/90r3sJeO9SOwc3Unaw+rA1UXooEgL5HfnOCaguo10UPcqHnHVAtyBI+c6LtsPpyAy4LAZRmDcaXOI5k31OJsB3QnICH/LrwbNHZQna2n4a1CzlvI+F1ytbrVoKoHlk1Ql8jVWtKy3e2GK2UZ+dgzV++Y1u1oYgTmbwNWY/1zkY7f3MyScrkobqlNanjDDEykh1cSE7lRHEEdUDSoBX5CGm/R7VJvvi9/VqjKONQ2DmXO5nI42uaJLMk9ONNHJnjLUkaYUN1jrwADP/ysizmUvpvwmwuwiuq2GS9DSmTMRUaFuyhiroJprmgHZMGfPvYOZtmrfyHNLW41yXK1A69Y+hv3JTdvyhkgZuyk+EMRoACwFvbWLnUI68Z/Xc8oeixxdIUowWtTDAzhp98Dte++xj46CpoVuPEF+ciplLBa+SmY0Dp4kYEuBxJT0puICya7ozWxJTXkfIclGdgk7HbVXbiUihVJSlPMA3NydM5kbYTZq00G0F321xLek5vVqdg8u+x+1CeJ6+lQhLFYaIYq2AGUCBRjrdoyBuzdPGVE5kF4Y5N2aEGBJa78fP1j0jTjluG4CKmMtSJTH43VuHdXN6bS7appambfU8eoamzP/3B8whb2+DpTCKDwQBUFl49sOoDKIuTpBJNR+uf8IqXzZxQp3JLo1TaU2Ht1Zq6iNNg3C+7Y8dARDkRfYaI3q9/P0ZETxLRc0T0biKq9P6B/v28/v/Re3Pq0fobUkYCIL85wIfPpE1XRBje6NCuZJi+YQgaCKcBJt6izDVkCkzqFzrcDKgfFKGXfN5hdIXRHIlfkoiYACmYZTsnKC52wxUMgLQQtlCNWt/5jNCjE6aKCTkIGQYik267tgGdLlZr99vbthBaQ/9+xFpNSDwTxTSIAjnNWHoyNFVQ8DA2FEWnY4Bis8YOxlpJ1q8wSnZ402rUNMvCe2sTTz8bQO5PZeGtVLmQbpFUarJW8QWjNStwa5+vgZhplGWYiwGYnUYLPNnVa6SP5DdLVRPAe6ElOuEc2KRrOZy9fGl8B2+m2kNsSuXdTPPxfgCOqX0jEcPPAngm+fsXAfwSM78JwAaAt+v9bwewwcxPAPglPe7em31wqZJN28AUnUjByOr6LppVQjdUx6HCsOYEwmwOIzqBCGE2x9FPXsDOwxV4bQyqWxz9aie7dIL+AxHdTysTtlAK7T40/oJVD7LkOAu7jdxjXH65wA0xlIXVJxGLLQLnWWjYbuQpE6C1gbqmv+iLIsRzloG58JTIiErCxOSF4bT2ekHTFWt4SjsXrZvRGJ32/PY+TSLNWrDTyoGXSzsbuxef06jbfYLRmLOx4TjWF+FpnH3eRXQoKfEq6+RcBjcJJ//0KlAUCDsTPVDBbOttSLAsxx0MF8jI9RlCEwfRciP3LXAaKPMht85w3KMybW3a99PuyDEQ0VkA/xDA/9C/CcAPAPhdPeTXAfwjvf1j+jf0/z9IC+jMvbH+xk1NI3rttOQ48DaXGX/ggOzaJigAw80e4eRR0EjJTkZyspBN04lsNES4cRPHP7+NzW8/Dmp7DC/vYuXlCIpZHd3VkFKCjC18y59NXs34AYCHz9YXYczAvEkWXB4rARQEvOvGccHZgs/nyrhUyxptYGqlBLmAY+ju6iIxuTkyze9tASU7KqBVEo7Pb44ln0XZ+LQT0sle7eICb9bZOzM9+skjTgBEZ2sNaeZQ8nls/bZoKFTSA8Kl6T4g4hT6/I7nqAP3Rja2gTeEsx+4CVy+hrC9HQVXulaqD9rb4EQlGyhrE6jSOZMAfIycpQTW9g9EDMFSDSu5h4Rsx3xXtRzv1O40YngXgJ+H+3+cALDJzLYEXgbwkN5+CMB5AND/b+nxC0ZEP0NETxHRUy3uzvQc6b5knS+hC9xwB0DnCbYYX+tR7PaYnx5LWTMEz/mywSCKuITgIVz24iWdh5iD2h5rFzoZyDqM4Wg6iyJlRZriUhpN+DlXSXVASTuhEGCyG8YF5RUDwsLi9sGvGgbbIjIHxYVgEP2AnfuQiqh4+RDw2RbdOIrgejRg31uIlQinOCcYhAc21lCVcBMskggVoz4mfRAyiJfcgSJ9L4jKUxYdBR1OgwDvYo3H6hTuVrELHcxjQ3icIarfS5akbkExlQc+04IuXQWtqHdV7ImKUsraKsziGo8+q7IUApLxF2xKu1XM7Cvre48cUoASgKcQLtqyj/aKjoGIfgTAVWb+VHr3bQ7lO/hfvIP5V5j5Lcz8lhKD2zzkm7N+YyOWMIsCPmsC0KiBMbo8BQA0R4sIIKnMW6hrjxaQRdQ4THax/swOeCCly8G1+cIIu73yX+k7N+0CM+cw6C6WK3joIiKO3sttYyFKCTSOu+tH7FGA60pCXi9UCjjW8rwWNaQhNEiwAWs86iuJBIgFlMx6jegJjlNY6ZRJdte8hgOCC6PkoCBk4hiAWErNazk3zsTxtUdYBtJy/FzEkbDrUFrjk72WpRzWyJWOy3PWaAL8WvUI9p4QHU4/EsLW+NMvAVmOsLUdAUIA3kbdNjJxyklKle/8oWkX0gARblEiFLCAHYheQ7PIYkwdRRI57IfdScTwVgA/SkQvAvgtSArxLgDrRGSZ5FkANornZQAPA4D+/yiAm3fxnF/ZrNJQ18JtMK+toGR+fRuzUxXyJgBrK2DmOM9SdRgACLW167xOnX3lZWx86xFQ3SLfbTC8QZ5KWO+B4wTd4s7s1OU8hszG/jOOgU9xTheRhtbFjBzMNH6AcSS6lTg1uh8ojbe0BQ7nUWQNMLwmUm1ZQ66ZUMxkVoSBgVkjzVRBh71yrmSlWtKSYkKOXxj92zQizBxAnavzMQC2EidlgCCAKCG3FSnaoZSOyzCQnbwfSZm4H3JkKrZAPxKwsB8mKZClHgP26MbuTyMk+w76SqKgR963BdQ1+hs3VWxFSorOM+g6x56MjWit1dbfkOl1xFoutzmTBjb6ezaVMSC2arciD5/yF/bLXtExMPM7mfksMz8K4CcBfJSZfwrAxwD8uB720wDeo7ffq39D//9R5vtYZwFkglVg0HCooKPkd+gDqCzBuzPMjxHK7R71G4+rM2CdgVk6oclByDz3Mmi1G1C/8ThQN1g7FxAq0SQA0jIhfD4CAO9jsNuuQ5CAjQs5NZKUJNltiQEE2+rij2gYaEmzUYdj/ImUX4DYhi0My7jzBosWQlzU5STzPDxUuqOTAHSWBjgzUQFOe492u13jiDNoOTOduSGfTRzSa0rS5uw4kypKXwHtanBw099PJdJ76euXE/KUw96raUqkQ3gyZZG2a4xTn2mRXbzmJWvKc4T5PE6Q7nsHAbPxGGCW/xugqIKuoa5h1PxQ1y7hloKWC30RKVchiRD2A1dI7dXwGH4BwM8R0fMQDOFX9f5fBXBC7/85AO94daf4zVm/sQGuG3DdxOnC1jTFwXeN+lgBlJGHjraVFKIso3CL0qRDXWPtizcwfbACiLByoXYpeMufLQJwXUgl0hTTJDzW/3ut34hRRo5LcAjj/BeT2PpMgdwJ2MLqq8gfsIqGM/l0d7fX60Zw8ZhIsCKvhthzdGOpIJhyksmmh1ycg2ErUYlKP/wESzFxFCCmEUDM662cmGIU9jqcs5dibWGHkl3S35yHjwdUAlmo2HEW+zztuc2JWXWoXWOUE8L4uRvgyS7CbO5YQTYeq0oSezoAyoStqFoeaftz2j+RjVTuLU1H1Bak4a3yUFWxtHmfS5O3s+KVD4nGzB8H8HG9/QKA77rNMXMAP3EXzu1VW7+xgfz0KR8eiq7xPG79+UacAgBuWmTjsWtBGlVa/hc9NxEBV66hnBxH/fAxVDdnOP6lAa7/dfKS4d7eB68aaMnPhUEQL1ir26clTK+t6+MthbD2ZNJR9cjYQbZ+wD61yWnBrTgM63i0VCd9bYtgurENnCG0qwFZJ0SurBZSlJCG4P0S5Q75uQPwNm4jXbn8nZZO2SoOaTmT4v0pOGhVEiN4Gbkpa2Swbj9idQC00P9hDs+6MNPP28BY+266MaPaIpz94E3w5WvCfM1ISoyl6HIgXdSKH2SDAcJ87iChS6wlPQ1c16qdQFE1TI9lRM2FiCewVyEOgh165uMrmjkFLVtSWQJ9wODyLubrGYppQGYItKUQzHHkmJWnikLAS8qw+vQF7LyxAk1mGF+phfiji8JC2qyPDU2GG9hOlYqrADGNWNAFUBailf5SjMKenwup/zuwqSlLN46Toz2sT5xCMYVHHBbZ9AOODskRRwEGbdCMMSuRRBgu3zaWkN76SBYqNOp43Fnqrm2zIVJdBCCWTGWiF8Wog9UpDKNTcE6EReO6jg3DsH4Vpui4vATKhNOfnCO7tokwmUjaaWF+kkIgsM+blPJjWOAWGJHJeAxGSDLcYEG+TcfKISzOm7ifdOc7sde8YxBWpF4tRSFzMKsS2cY2ACBvAvqHTkoOSCQYgxKiyKoaAGg0FICyrhG2tlHuSlSRbzdYPSehvO161mHpizvZ/WMnYAIi6k5pZUomdQaGqFuKsYf7YBLs0kuh3iXYSHn242KXIZxhmJKRAC1VanUiVCzip1UUhbU+j7xWVSRVqGqOsLY0kzsNYq0yDKKj7CutlhTxc+oHiiesCicjVCq2OoMTs0LBSsxS7YZhfF8WAdjnx5nCLgkomkYt9j0AkkKcfqrD4CtXwbMZqKpEqk2l4E2JyTeGwQBhOr1FpBVA1GHUXggqq8hyTKUGAQckqawWKxhFeWCiBeB14BgAiE4kc1SUhnju1Ysd2tUc8wfHoPWj8mXPJZ1gm1RF2vwynQHMoNEQ3DRY/7OX0Tx0FNm0xrFnp55zp4Kv1mFZTuMCTNmRhhEUuzFsTluM7bg+GfRqOIVpIQbVhrTOSyM7cSaoviglx/CaCQtOzKsX8ziXIvP+CXKGoTdeVexpSadRBAMIuQjXZrqjS/OSXvgaHfRVfH0RhGGPFLqVIDm/Ts8uZjIWr9zJUEzIsRmXpQukEvfyXNYP4WI2Gpks4B8axbRrQnle+bOvIFy7jn57Am47kVYrK3DbJNWF2D+Traz4NWWEJQASIdjEKGVApmIrqSCLl8ftb+283G+wca+9LhwDoJGD6ULqRKrxS1uYH8uBADSPCAfLQCNAMQXz4spnsBSDt3cweagCNS3ybZGYtxZqAAuMQW97hjAafYHqptIPY1RArCBiwvJzbr8+p7cJp9FnkjJQII9I2lUVf92zGcWUAZGRGcQ55LX8ltyffFaEgYIWptuOnXUSaVBHMkMioUFzLmBnN46qVKJArTiAj54nD/vbNY4ajhR5Ey68q44pa0g+kgBNozhODqOYxtlnSr3iCpuEU5+4hWqL8AAAH91JREFUATDHygEgzVHQXV1nPAh4qE1OeqxzEfJchsHoICR3JMZwVJaj/ea2idqQFm3YaMUDZq8bx+CWEWg4FI+9vYtQAtVWg3q9lEih7xF2py4nz23nClDWSGP/yzogHBkjm86x9pIi9goi+kCahLiUN3Bik4XcQMy7ATgHwlWPrDph4BzHxxnxyVMMLV+69mMOdxjWiem8g+RaFDBxEd+wKMKHthg2oAvY6dl6XvmMXLI96+R1RZlJnFM/lDShXYtOwVq9AXkeayc34LE5KpOxLCqKjlZxjCLeL5FX5roWFi3ECAsOzJ79yCZw8QrC1raH//KEQnGW0nYEE8N8fosCk2ECToizXgogtk+bIwD8urFeCdNc8BGJB8xeV46hv34D/Y2b0o4NgNsWa+da1CcGWPnqNvDYQ1KhUDAyzOvIg7BqBeC6DceevISNbz8KMOPkZycoJ5TMRtQFYypDulh9QSYVCOMapGU+Z+0BsF6EVP05VyXlVCAlbZjiMs6MAJJcXmdBWgRj7dLeDNWpjkQjeIItaIkqlCxE7O9RtCslUqAuApL2Xrsxu3Py9uqgaY7iMcbITEuJKRnM0jDOpYRpJmVM9sjH5ePTQoJ2dBqG8cjvXARduCZ6HDpQ1jscXfErxF1f1ZmEsJRIvCflRgcUU9PmKoskACxULeR1+ECUJm9nryvH4KadlkSE4aUJdk/loGmN2UNryI6sOiWaSgkpwZG1xsppQGDw5rYswtEA2W6N0ZVIy3VxlDzBDxzRj7uzlTllehMcVEtFROwxe+vyACKzz3JqK9eptkEaYbCWNH3h6PN6JUXBQcMUshYY3JD4PpRSNrSKhVQczFHExWsL050VRwdiGhBALFuKI2DvF7FIS0BHLOAt1gZuI/pEmCWmNSa0YlUbE24xabw3/EkL3tkFT6cxGrSPwkL+pN9vYUHr9OlUWi2OsRf+gkcKfR/1FNSZ+PSppOX6INvr0jH012/AZN+yyRzzBwgYVAgDAh0ROXmEEDvhiJANBi45T1Ul7dkcsP7sBLuPr4NmNcbXQuTpF3CKMAU439+4/KRNQKYWHQYxmnC2YrrTWrktsZDr0JpWo2w7Jou7qguodoAJrrZrvIBhePhvZdYmEoAAeY1yIgIt/rx7xGtTcVzXalTMwJxCOiMj7TORtnP2qEnOl6JTsEpMSJ5TX4uhgrK1zOJMy8LG/GQCTn6ux+hLl6Rjsmk9z/fdu4/TqB1UNGWmPQIq3ixlzU46fRqIDsY7LfcQnJz3cIAqELez16VjANQ55BkwmyNrgO1vWcdgo8X8sZMuJW+afoBECgB0YI2iz31A9tWLCJU4kpXzu9I/0S3m/QsyaZzsglm8eK0D08BG1xlIGJXeDJSE5CLdRp5CkKLy+Uw4AKGUxRMGstiETSiAZOwxQJx8lUWy1YKYiaYqebMotGrKzKblYFEIEOd9OuXbKN5ZjBi4AFhLkl52TbAEeyxn1jmZOLug0nBt/Jw8YlHn060wHv/dTax94qvg7R1d5HLZZ8MonAIg4giWLmS5KzPZ2HkqSsEV1HlY9cIdgfY77AUUXW8h9Ac2fUjtdesYAHEOvDvFkXM9dh/MUZ27ifpYIZLzgANGVAqfgUz+zVKLtgXP5lj56kTKUPMOw+vC8/e6uTkCiovdFrzLv2dJhJDgDFb/tzDbZzT0STSiz235v4OOpDyIkCxyLWsact9X7LoOlOzGrCBgqjcRNSZJpe/Z5eStstGPIvgYh9ggqkwF8kjBhFkEi6CIHbBWVCx6Km22Jnm0wWSEK1qgjqczQqUEyjj+RUZ2fQthc0t4CEY+0gXvTkBl/tLIYGEYrWmKGv5gOgyqQL5XicnKni4cu1en4YDb69oxAEC/vY0jz2yiXQNAhLxh9GdOahlJvugw2YVPBMpimmGycNnLV7H5nadB8xrHntmR49Lc3hB8XXzpYBRXJVbkfAGg1KjDmI++WHLlSVTRuWSNTr/WXdoATwE/eUE63RxMMZVwfX4yqAJzdAamguRq04i7fLkr/IKskwULLQeWkwzUaS9GEx2YRQ4m4w5Y96aeWyeOwliLknqxTvimGDUkfI1qK3MVaLCUge3zMpzi0fdNceyDz8oGYJ2LRjAy3UUlsflQ4z0LONMKFgBxBJY66DEGXvpjzJHYY+o6ViAOYFnya9nr3jEAQP/FZzG6yghrI4zPTzA/M/bdgFQh2hqriEjuTyIJns/RD0gcy5VNZK2Mpzc6M4AFkI+SSNJ7F/LFkqGZpRlATE8sIrA5EQ789dpQZGSoEAG7MEjQfI7PHYfWsEu6N0fYnZeNkjNSk52Hjauz0XCwcL8XYlIxI5/qXUwjQ9Nbs3X3z2txCMKaZGWGSoWD9fV97BzEyeRzWvgMjecR1LH1Q8bDH95Bee6aU5oXKg9JaZG7TuZKJuG9T5SCcBtch1H5ClGjIY9ir/bc2R6OgimDHXBMYa8tHYPa8V/7M8weWkW2tYturPnjYCDddoMBeF4Luclq21MRe6FCpOjXXpxj9vhxoOuwep5d9CSVY4vTjfaE9xx3eJOL9z4HimGy06FTANN0H6ARwpSifFmuPAF1RjavwQFQXdAAPCw3rEPGxgmtuRvZwk3wAS9hilhtuS0piignWaQhzMl+oIAnJY7QCEh27kmlhlSolhCjK+lQJVTbEVMwZ2uO01qtz/xph+yFC+C69mFCAHwEve/oJrha16rSpOXFukY2GjkD0kDEhSnq2usgfRJlnAWh/RQAhK9QlIcqUjD7hrorX+s2+MBfgN/0OEaXa2SrKwiTXQ8xrcHGw09rkWUGDQcov3wekx96E0bra3jgT65ifuK0tEKbniFH55Ar+u71+Szm4QB8VgUlO2HqKIwj4VqHA6FV+zyJpIXZdBv9OdRp5ErHJgDBnlN3bXmeSE5yHoIuXp92lW6C6twMSJRhsxQJXRbBGPai1QZC4hCsUpNWLfR1rTXbn4vj5wSWno1Tnw448tlroJ1dsLJcqap893Nh1ozALYNyiQ6sjTpoR6RNPAdJp2U2GspGYMNkVKTFCU8KTAqzrY9isfuk13g3bBkx7LH+uReQ/cnT6B8UijRVlWANBkolw2kASBQRAtC0OPrlHUwfWwe2dnDiS60MY+nixWupgjdF2YWf8PithAnAsQLrDkwXvZnNoPCeiEFCRMp07ZoTsggFUN0DXkxdCJFSDDjDMKvjDp2WIo0CHiqtemjqkqlGJTKWxqwM3kMhT6jPZdFDxkBQpqS+D9eubLX3YQ+vw3pK+oGIyq6eB4587DnQZBq7aCmTFCHPZYGvjGFNTaRlyDCvY6dkkl4AcPAx7O7K//PFdmmqqjg4JhFiMdWmw2xLx/A1rDkxFDzBcs++F8ajljI5IUGZdkN+6TrqozloNMT4hU2EgtGuxovYpNwWVI9oMVz28p7xC2wuZGapweJzpI1XWSeLGCwphdf/OT6HsSO9MqAkIeNIeFu1PTSXRR87NNnFWr2/wyKRhJdgAiyiZKXVClOqJjgQSQGxAQwxLTCil2k+pHJ2aRrSDxnHP88488GLwkEZDsCjATCoQOOR/GjfAs9miheRS/m5oEpdx2nSSTRAZSU/KgabDQbRgTSN909Ym/X9mER9P2zpGL6GlR/5lMzGBHzhk9a9ue+RDQdRxKVtwU2DsDvFsU9dQ/fgOmh7F2/441bUlVRJ2iMBXVA2Vs12Yr8vxGpAKCLmkAq8+HRscy5Jw5BVMsod0Wg0p1LYLMgyPs53bI4OxnL8vJZdH5rHh5L9+RzANKdmkIq+H8dNGF5qFPoySc9IF8urJpnP+n7yuWAJxZScm5Cl6ROi9uPjv7mBE3/0MjjP0K+vgocVaKaIb5EDTRvVuUgYqwCcoGZYETKJKpzNWJTeXp2WKUOj1QWNELLx2IfPAoiiQIfclo7hFSzs7MB7JdoYx1NV+kWGPAeNRpJS3NjA7PQQGFQYvbiJ1XOIWgmIF7cPfC10GE3iALxkSaJhYCCjvDAWgLo0D7f83EBPYlVk0vQknU0JAwBV7MXSA3lOjnJqeuoCNkZlKDv3BfAT8TniHE12bMBG7rlwTcJ0hHI5THna3ou3bCcVGy4kGnnwyRrZZAoeD0F9QDZvQPNGHEIf4BPFADjHwFIJmxFhFOcg4b8JwFozlU+ESidYZ7lPnQqzWdRSOOTpQ2pLx3AH5jlmKdtjNhoKxpBJiZKbVuiz2oU52GzRPHwMtD3Bic9NUU5EiiyvI6sxNYscUqDRHERvMx+VkQhEx2HgpcvN70kBDLE3nQWjX3OuvkOjA+oVNNTF6zs84L0I3sCVpAyeSvTJT1I6pQBQS967YSrYKS3aAMd8LpTr3KZfUXwec342uEfKkdsYPXsFaDvQ7gxc5BIpmI5GRuAbGxItGMGoaxfUlADEykIirsJ9L99n2gBlUYKrOPVOfz5o6kt3w5aO4Q4tTKcePYTdGVzApWkXLyAA5WdfQF9mwKBC+eIVnP3Qlnf4AXBR1IWJVUnvhNX6rSRpaL4dYySptBPTnYSlCLT43NWOLLys0aG0mpr4HIYg3IB2LSAklGczzlnSCqsqKIhpGIlTu0t5LAOxt0MxAWjkk89loG21qc7AJlHb+SS6jEB0KKFkHHkx4In/fgHZS1ckhdvdBQ/1A2s7mUweArrzF71caBR2MCPMZvG7svEApWl/JvqeWnWyKoTxE7hp4iSpun7NpA57bekYvkELu7uCNTADQXYQu4gASPTQB4yeu4ruwXXw2gqyi9ewdk4ubCPzGF/BH5fgD2k50o7xKdb5IkCZDrpxxiLHxcpKYrLQvphKaF5MdT6Edn1ae7i8WHQw8sSQakMdgUDW44zX4BiAMiFTx2IEp2JOKHfkeex9mIK1pVf2GSx85hUQKsZDf9jg+O8/h3DtBqiQdmd+9CGgKkET6ZikpgVvT8RZW39LnguWQORAJACfE7EwGcqARS03yhPE2RIyKObg9zq8Wls6hm/CHHewC6cs40yKEIAQwFvbmD049OE3p/7wKlYuiHSZ7ehpYxUQU4x0dmMqxGJVCQuvFyIHTiIMLYH6NGqOjsTKgSYxV+7Izp1PhZyUz2hhqrUBkk7WKiI2AcB7HCTN0PJmHxd9MZVowJiQJn+XgonOx0jSKLN+AFALnPp0j+FTzwues7qCsL0DPnsa2eUbwNUbsrgDgye7Un1IgEbKM6E2A7Hc2PfCeExJS4D0N6jzyIZDBx/9OMMqXkN4wu1sSXD6Js1wByoKyU37XhyDjbYDsPrMTUwfP4aVeYNw6Soe/FCH0Xc+iKtvzrwMZ7t7uSsMQwfaVB0pbyOXAZDjsSdtsEpAqHROZQUfBmPTqg24k76EBKdIFn0xFWyhTHQp7TXNIYDkOfsRAJYIALDIhjyC8MpEou9AfYI1djGScS2FpFpjPRtnPlFj+KWXZfcPjLC5JSXGxx5GdvmG9Kt0nfzu58JLsHFyWj7kLngEQIOBlx1t0LEzGxOA0sfUV1WcTl0WPqvytW7LiOFVmuWYcmH2Wq0IQqE+fxFhQOCRDCfhGxs4+uQFjK6StDxba3UvA2zTDkrvoiwijgBEADC2IycRgi4wH5mXPgZwXMGblTipDiBGKXuPBxJw0cRua6keuESdOY02PtaGzqYzLXz6FMXXdeKU4hTdKmN4DXjoj2YYfPp5cC8RWKhrZKMhaP0oso1thN0peDpFmM3ltgqhIGliAuB/mwM31SWjM1saQXnuUYRzH5qo3PR6cQrA0jHcFQvTqVOmudcLspRcdPzyFNNHjwKV9PGHzS284eObGF0R5wAgtl0n8dst6H6yeI1A1A9iJOGPtSgkLTVaepFgFraru5YiJcfr49NuR/9tPRr94mvZWDwjZBnewYkT8/NLnys5h34oFYczn+jwhvedQ/XsRYAykeNjRn78mJSF6wb91esIk4kOdtH+BJ3pYMNbXF8hsGMDqXqSVxQS6rLjBya+4tHEaw9g/Hq2TCXukoX5HJjPpeylff10ZBXh888h+zvfBipL5A+cRNjYBL14AQ9duYnmiTN46YeHKGYUtROSRqneCEIW4dKig3BVpKCOIQBZ0pjVDyS1SNmCjjUo6cnIUaHUokOOOB4z6eVYiByUzGQRis2L8HZvdRip0AtxxEZSUpZM5WaMLxOOP1Nj8PImcO0m+h1tX1cuAbcdukuXZUdvuyiykpEzUrlpvOToeo5VFcVaIekAXMxVFnw2HiPM6whGproJr3Es4WvZMmK4y8ZtI07CBuECGJ7fQjhxBNxKHT3szsCzGarnL+H0U0FSiRVl5KmrThdwCsZZWmHlvLxGbEyiuNO73HrCP0gH7Zr4i43Uyxr5nSfTqVLKMxCjBG9eAiJowMkxSKoiaTpjjqIQp9etyMi7U58JOPOhyxh87kXg6nUJ87s9MutlIT0NNuZNKwlOMqNMdvVEJ0FeLC5ycx4WJUivQ4VgU8eM3AS8ZsuQd2pLx3CPrN/YAAABuc5fRLcuvRciNCtciDDZxZEnz+PMn84xvEHx20gWs/EWfOBtgg8A0QGYiIr9LwUV5cAIRNrfAGKfA5L0I130FB1Uyqi0KMOcj6Ui5pQc+wgJSUkbrkzh6uTnGI+85zrW/vgF4PoGwuYW+q1tUXBWARXrX7DPzcP7VDRF/2dTpWM1IrZXyxCYJt6fSaesHG8eMNNU5PUZJaS2TCXuoblzGI/RHClREQFVCczmUharSoSNTVRP7+LssyNs/a1HcPNbcpnAvE0OyHEBV1p26TKjRidUZqdG9xEfsEVvk6CMXZnXOux2Jos1azUSSEfqaQXC28FT5qU5Cyu9JtOz076JUALtKHqxE1/osXJugvzqlqg1N610qLpkO2SRh+wWVWYHFjNamB0JmNcM4I6lzNi1oLxEaHqgT6TfLeVIp1RrenJYW6TvhS0dw32wMJ1i+L5PAo89Auxq0452bmajIcLuDNR2OPrn5zG+9ABu/rUxtp7QadIEwQ50Zw4lQHMgDBEl4nW35r0dj0k86IvaAD+tZJjT2dupydDnTaoezrQ0p1MASHs4ksjCBsZkHWF0lbD+QovR+R3QJSEnhZRvoI4AgAqpdlGhO7BUekzFOYiOAreNOABmEHJnJHJdS6MTs/62ikOGULcSTZjQr8myvY6qDXdqS8dwH6376ksAIDMQMwIRIczmEgrXAWF7B+ULPU6fK5D94BsxeViUlIoJOaaQNYDNpwzJAs3nMSW2cqBPr1bz5ivGQr9DSl22xwNwURcbYut4BSfcgxAxD1b1p75i5A1h/Vlg7fwcg3M3gbZDuLkBtmlfsxmy0UgqOmWlFYVkcAsHoEccLJxloBDAoQc3wQFDcFBlJtbj5EOhUtSaABVN6bo4HEaxCoR+oaq5tGhLx7APFpuyROhDauUiH9ftTpGtjHHy//4lHhgO0Z9ex5XvPYrdswLUpdoFjilYuJ9UE6yL0hqPrD9jQZshxEgCQHQCNQB1Or1FJiHeBwgZiwugHarO4zYwvhJw9Pkp8u05aGMbqErwdO4Sa0GrNtw2Hr4jy91JcuiBciCL1kbRA0pE0tmRSlDipvHWd247Ty0oC4I/AFquMVS0iGKwy5ThFW3pGPbRZLahSojVMjINrQ7ObVug65DN5zizPUNzdh07ZwfYehOjS3QOAGFNWluyMxyTkN+wCMcB7PVp8T7vj0hZj3ZsARFsARByBgXC6Aow2Gasf3kH2W4N2t71rlNO6ck2tMUak8pKoqU+mQjNrE5D1ZMcHMl1t6+AskI2GKDXQTAp5wCZybFlELq6YRYEpzIvI4Q7tqVjOAhmcnF17TwI7jpgDnA/A83mKC9cxolPFTh5fB3h6Apmb1jF7GSB+QnSadLsqkxGXxZ1pFh5CDZcRhe4dT32Q/boIVP5d6koSH9DtQUMtgNWLzQoNmtkkxloVssAl1zwAqwflTB/NgeNhgjbE48MjEewMGiFhZSUNiV5BQKQiAHQprQe0GPCVAYOG4nJUgl3CpZa6P8Pw3CXg2h35BiI6EUAOxD4t2PmtxDRcQDvBvAogBcB/GNm3iAZ/vefALwNwBTAP2PmT9/9U39tmkQRipRzElLnOTAYgDe3QFs7GL3QYWX9KHh1BBChOzrC/NQA0wdydGMSIdpBUrlIlachXZZcqIjslFBOxDmNbgbkNaPY7VFMGuQTiQSsm5S7Hug6bV8OoKpEtiIDenheI8xrkXRMNApkLFuQtCFo81Jde3nRcYUsA3whx+qBkZXssej7xXQEAJil47KHH7u0b96+kYjh7zLz9eTvdwD4A2b+90T0Dv37FwD8MIA36c93A/iv+ntp34ClSDmtrYlG4XyOsLPjeTr6HjQbAczIX6qxurqC1cCgVRF+6I+vIptKPh2GFZATQpUja3pksxZcZKBZA+QZaGcqzUjTmWADdeMqVQwoMajzoa82cyNbW0XYmchI+UJ2fNdLrAqPgnyyU1YInmBvTpW3oa/hlk5vCh0sB/DHZknZ0QbGLLGDu2avJpX4MQDfr7d/HcDHIY7hxwD8T5Zm+D8nonUiOsPMl17Nib6eLRg9GLHmbmAbz+bITh4XVWQA/eYmsrqWkPtSAc4yIASRw9+ZIC9UsKRpQKORSJNVFaA7cZjNQV2HMJ0iXz+KfmtbBFBV37Df2kZWlaJ1OJuh39h0Z0G5Kidp/wIV5hiKhfu566Qy0/extwSIA2DzxfKjVBhoIR2R6U/ZMlW4R3anzEcG8CEi+hQR/Yzed9oWu/4+pfc/BOB88tiX9b4FI6KfIaKniOipFss68p0a17WAaG0T52hO57JAylIWIDM4sE9RsslZ0GYgTndoA/GUJ0Bl4RThMJsDAGg0QnZkDcgz6W4cSirAfRBiUEId9sEtQFy0Nt6PSF4vcKQ9J4NfjF9gEYREDeRpic+dtMcu04V7ZnfqGN7KzG+GpAn/ioi+7+scS7e57xbSOTP/CjO/hZnfUmJwm4cs7ZWM2wZhOkV/7Zo6iCmy1RWIWIwufs3BeTq77VBV7zD03F2lzpQPkI3HoGNHNYcvQFWFfnuieEMrzUzavRia1gFEVv1LKkX+jjRS8V4GmyIeeEERScqWLFFKRjE9WUYG99XuKJVg5ov6+yoR/R6A7wJwxVIEIjoD4Koe/jKAh5OHnwVw8S6e89JuY/2Nm7fcZ70C3DTAeBznJuQ5QtsJgzDRJAg6RIeQRymzqpLqQ9dJhaCRXgLu89jWDGglpb21QzHtZQDi1CYmLUVqX0QKQIYeYb6MBvbTXjFiIKIVIlqz2wD+PoAvAHgvgJ/Ww34awHv09nsB/FMS+x4AW0t8YX/MQm8wo9/YkK5PigxDIpLdviyAPqkOAABlvmuHzS302xNJMYwnAMSUoe/j+DedvZANBw5Cyrl0HoXABsFaStN1Drb6nIel7avdScRwGsDvKcBUAPgNZv4gEf0FgN8morcDOAfgJ/T4D0BKlc9DypX//K6f9dK+aXPWJWJ4zm2DfDwScHFnB9loRRZungsvwUBEk0srEr6BzVtI+AR+nN2vVGR/XXUCy/Tg4BrxAeg5J6IdAM/u93ncoZ0EcP0Vj9p/OyznCRyecz0s5wnc/lwfYeYH7uTBB4X5+Cwzv2W/T+JOjIieOgzneljOEzg853pYzhN49ee6FGpZ2tKWdostHcPSlra0W+ygOIZf2e8T+AbssJzrYTlP4PCc62E5T+BVnuuBAB+XtrSlHSw7KBHD0pa2tANk++4YiOgfENGzRPS8dmnu57n8GhFdJaIvJPcdJ6IPE9Fz+vuY3k9E9J/1vD9HRG++z+f6MBF9jIieIaIvEtHPHsTzJaIhEX2SiD6r5/nv9P7HiOhJPc93E1Gl9w/07+f1/4/ej/NMzjcnos8Q0fsP+Hm+SESfJ6Kniegpve/ufffMvG8/ELGwrwB4HEAF4LMAvnUfz+f7ALwZwBeS+/4DgHfo7XcA+EW9/TYA/w/SG/I9AJ68z+d6BsCb9fYagL8E8K0H7Xz19Vb1dgngSX393wbwk3r/LwP4F3r7XwL4Zb39kwDefZ8/158D8BsA3q9/H9TzfBHAyT333bXv/r69ka/x5r4XwO8nf78TwDv3+Zwe3eMYngVwRm+fgXAuAOC/Afgntztun877PQB+6CCfL4AxgE9D9DmuAyj2XgcAfh/A9+rtQo+j+3R+ZwH8AYAfAPB+XUgH7jz1NW/nGO7ad7/fqcQdtWjvs72q9vL7YRrG/k3IbnzgzlfD86chjXYfhkSJm8xsnOj0XPw89f9bAE7cj/ME8C4APw+fmYUTB/Q8gXsghZDafjMf76hF+4DagTh3IloF8L8B/Gtm3jbRlNsdepv77sv5MnMP4G8Q0TqA3wPwV7/OuezLeRLRjwC4ysyfIqLvv4Nz2e/v/63MfJGITgH4MBF9+esc+w2f635HDIehRfuKtpXjoLWXE1EJcQr/i5n/j959YM+XmTchSl/fA2CdiGxjSs/Fz1P/fxTArT3ld9/eCuBHSfRNfwuSTrzrAJ4ngEUpBIizdSkEPadX9d3vt2P4CwBvUuS3goA4793nc9prB7K9nCQ0+FUAzzDzfzyo50tED2ikACIaAfh7AJ4B8DEAP/41ztPO/8cBfJQ1Mb6XxszvZOazzPwo5Dr8KDP/1EE7T+A+SSHcT/Dpa4Aob4Mg6l8B8G/2+Vx+E8AlAC3Ey74dkjf+AYDn9PdxPZYA/Bc9788DeMt9Pte/DQkHPwfgaf1520E7XwDfAeAzep5fAPBv9f7HAXwS0p7/OwAGev9Q/35e///4PlwH349YlThw56nn9Fn9+aKtm7v53S+Zj0tb2tJusf1OJZa2tKUdQFs6hqUtbWm32NIxLG1pS7vFlo5haUtb2i22dAxLW9rSbrGlY1ja0pZ2iy0dw9KWtrRbbOkYlra0pd1i/x+FGgrbjsgP8gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(ds[0]['image'].squeeze())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f299f21ea20>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(ds[0]['mask'].squeeze())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "...."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}