2) Evaluate deconv-GAN-512-40X.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluate deconv GAN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import re\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import skimage\n",
    "import skimage.io\n",
    "import time\n",
    "\n",
    "import torch\n",
    "from torch.utils.data import DataLoader"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1) Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# he NLST\n",
    "he_nlst_folder = \"../data/he/\"\n",
    "he_nlst = [_ for _ in os.listdir(he_nlst_folder) if _.endswith(\".png\")]\n",
    "\n",
    "# he MDACC\n",
    "he_mdacc_folder = \"../data/HE_unlabeled/\"\n",
    "he_mdacc = [_ for _ in os.listdir(he_mdacc_folder) if _.endswith(\".png\")]\n",
    "\n",
    "# ihc (ori)\n",
    "ihc_ori = []\n",
    "for folder in [\"CD8\", \"CD3\", \"CD68\", \"PD-L1\"]:\n",
    "    ihc_ori.extend([os.path.join(\"../data\", folder, \"ori\", _) for _ in os.listdir(os.path.join(\"../data\", folder, \"ori\"))\n",
    "                   if _.endswith(\".png\")])\n",
    "np.random.seed(1243)\n",
    "ihc_ori = np.random.choice(ihc_ori, len(he_nlst), replace=False)\n",
    "\n",
    "# ihc (h channel)\n",
    "ihc_h_folder = \"../data/IHC_H_channel/\"\n",
    "ihc_h = [_ for _ in os.listdir(ihc_h_folder) if _.endswith(\".png\")]\n",
    "\n",
    "# Create image dict\n",
    "he_nlst.sort()\n",
    "he_mdacc.sort()\n",
    "ihc_ori.sort()\n",
    "ihc_h.sort()\n",
    "\n",
    "image_dict = dict()\n",
    "slides_he = []\n",
    "slides_ihc = []\n",
    "for index in he_nlst:\n",
    "    _dict = dict()\n",
    "    _dict['image'] = skimage.io.imread(os.path.join(he_nlst_folder, index))\n",
    "    _dict['target'] = None\n",
    "    _dict['image_path'] = os.path.join(he_nlst_folder, index)\n",
    "    if index[0] == \"N\":\n",
    "        _dict['magnitude'] = 20\n",
    "    else:\n",
    "        _dict['magnitude'] = 40\n",
    "    _dict['type'] = \"he\"\n",
    "    image_dict[index] = _dict\n",
    "    slides_he.append(index.split(\"_\")[0])\n",
    "'''\n",
    "for index in he_mdacc:\n",
    "    _dict = dict()\n",
    "    _dict['image'] = skimage.io.imread(os.path.join(he_mdacc_folder, index))\n",
    "    _dict['target'] = None\n",
    "    _dict['image_path'] = os.path.join(he_mdacc_folder, index)\n",
    "    _dict['magnitude'] = 20\n",
    "    _dict['type'] = \"he\"\n",
    "    image_dict[index] = _dict\n",
    "    slides_he.append(index.split(\"_\")[0])\n",
    "'''\n",
    "for index in ihc_ori:\n",
    "    _dict = dict()\n",
    "    _dict['image'] = skimage.io.imread(index)\n",
    "    _dict['target'] = None\n",
    "    _dict['image_path'] = index\n",
    "    _dict['magnitude'] = 20\n",
    "    _dict['type'] = \"ihc\"\n",
    "    image_dict[index] = _dict\n",
    "    slides_ihc.append(index.split(\"/\")[-1].split(\"_\")[0])\n",
    "for index in ihc_h:\n",
    "    _dict = dict()\n",
    "    _dict['image'] = skimage.io.imread(os.path.join(ihc_h_folder, index))\n",
    "    _dict['target'] = None\n",
    "    _dict['image_path'] = os.path.join(ihc_h_folder, index)\n",
    "    _dict['magnitude'] = 20\n",
    "    _dict['type'] = \"ihc\"\n",
    "    image_dict[index] = _dict\n",
    "    slides_ihc.append(index.split(\"_\")[0])\n",
    "\n",
    "slides_he = list(set(slides_he))\n",
    "slides_ihc = list(set(slides_ihc))\n",
    "slides_he.sort()\n",
    "slides_ihc.sort()\n",
    "\n",
    "# Split train, val, test\n",
    "he_indexes = []\n",
    "he_indexes.extend(he_nlst)\n",
    "'''he_indexes.extend(he_mdacc)'''\n",
    "np.random.seed(81020)\n",
    "slides_he_train = np.random.choice(slides_he, int(len(slides_he)*0.85), replace=False)\n",
    "slides_he_rest = [_ for _ in slides_he if _ not in slides_he_train]\n",
    "np.random.seed(81020)\n",
    "slides_he_val = np.random.choice(slides_he_rest, int(len(slides_he_rest)*0.5), replace=False)\n",
    "slides_he_test = [_ for _ in slides_he_rest if _ not in slides_he_val]\n",
    "he_indexes_train = [_ for _ in he_indexes if _.split(\"_\")[0] in slides_he_train]\n",
    "he_indexes_val = [_ for _ in he_indexes if _.split(\"_\")[0] in slides_he_val]\n",
    "he_indexes_test = [_ for _ in he_indexes if _.split(\"_\")[0] in slides_he_test]\n",
    "np.random.seed(81020)\n",
    "slides_ihc_train = np.random.choice(slides_ihc, int(len(slides_ihc)*0.85), replace=False)\n",
    "slides_ihc_rest = [_ for _ in slides_ihc if _ not in slides_ihc_train]\n",
    "np.random.seed(81020)\n",
    "slides_ihc_val = np.random.choice(slides_ihc_rest, int(len(slides_ihc_rest)*0.5), replace=False)\n",
    "slides_ihc_test = [_ for _ in slides_ihc_rest if _ not in slides_ihc_val]\n",
    "ihc_ori_indexes_train = [_ for _ in ihc_ori if _.split(\"/\")[-1].split(\"_\")[0] in slides_ihc_train]\n",
    "ihc_ori_indexes_val = [_ for _ in ihc_ori if _.split(\"/\")[-1].split(\"_\")[0] in slides_ihc_val]\n",
    "ihc_ori_indexes_test = [_ for _ in ihc_ori if _.split(\"/\")[-1].split(\"_\")[0] in slides_ihc_test]\n",
    "ihc_h_indexes_train = [_ for _ in ihc_h if _.split(\"_\")[0] in slides_ihc_train]\n",
    "ihc_h_indexes_val = [_ for _ in ihc_h if _.split(\"_\")[0] in slides_ihc_val]\n",
    "ihc_h_indexes_test = [_ for _ in ihc_h if _.split(\"_\")[0] in slides_ihc_test]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['10878_2_10.png', '10878_2_8.png', '10878_2_9.png', '11460_1_10.png', '11460_1_2.png', '11460_1_3.png', '11460_1_4.png', '11460_1_5.png', '11460_1_6.png', '11460_1_7.png', '11460_1_8.png', '11460_1_9.png', '11460_2_1.png', '11460_2_10.png', '11460_2_2.png', '11460_2_3.png', '11460_2_4.png', '11460_2_5.png', '11460_2_6.png', '11460_2_7.png', '11460_2_8.png', '11460_2_9.png', '9529_1_1.png', '9529_1_2.png', '9529_1_3.png', '9529_1_4.png', 'NLSI0000078_2_10.png', 'NLSI0000078_2_6.png', 'NLSI0000078_2_7.png', 'NLSI0000078_2_8.png', 'NLSI0000078_2_9.png', 'NLSI0000165_1_1.png']\n"
     ]
    }
   ],
   "source": [
    "print(he_indexes_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# he_indexes_train: 368\n",
      "# he_indexes_val: 43\n",
      "# he_indexes_test: 32\n",
      "\n",
      "# ihc_ori_indexes_train: 360\n",
      "# ihc_ori_indexes_val: 43\n",
      "# ihc_ori_indexes_test: 40\n",
      "\n",
      "# ihc_indexes_train: 500\n",
      "# ihc_indexes_val: 40\n",
      "# ihc_indexes_test: 60\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print('# he_indexes_train: {}\\n# he_indexes_val: {}\\n# he_indexes_test: {}\\n'.format(len(he_indexes_train), \n",
    "                                                                                     len(he_indexes_val), \n",
    "                                                                                     len(he_indexes_test)))\n",
    "print('# ihc_ori_indexes_train: {}\\n# ihc_ori_indexes_val: {}\\n# ihc_ori_indexes_test: {}\\n'.format(len(ihc_ori_indexes_train), \n",
    "                                                                                     len(ihc_ori_indexes_val), \n",
    "                                                                                     len(ihc_ori_indexes_test)))\n",
    "print('# ihc_indexes_train: {}\\n# ihc_indexes_val: {}\\n# ihc_indexes_test: {}\\n'.format(len(ihc_h_indexes_train), \n",
    "                                                                                     len(ihc_h_indexes_val), \n",
    "                                                                                     len(ihc_h_indexes_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define stain_OD_norm\n",
    "stain_OD = [[0.644211, 0.716556, 0.266844],  # Hematoxylin\n",
    "            [0.092789, 0.964111, 0.283111],  # Eosin\n",
    "            [0.268000, 0.570000, 0.776000],  # DAB\n",
    "            [0.000000, 0.70711, 0.70711],  # Bg-r\n",
    "            [0.70711, 0.000000, 0.70711],  # Bg-g\n",
    "            [0.70711, 0.70711, 0.000000],  # Bg-b\n",
    "           ]\n",
    "stain_OD_norm = []\n",
    "for r in stain_OD:\n",
    "    stain_OD_norm.append(r/np.linalg.norm(r))\n",
    "stain_OD_norm = torch.tensor(np.asarray(stain_OD_norm))\n",
    "IMAGE_SHAPE = 512"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2) Create and check data loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.patches import Circle, Wedge, Polygon, Rectangle\n",
    "import numpy as np\n",
    "import math\n",
    "import skimage\n",
    "import skimage.transform\n",
    "\n",
    "import torch\n",
    "import torch.utils\n",
    "import torch.utils.data\n",
    "\n",
    "from utils_image import rgba2rgb, split_masks, Crop, binary_mask_to_polygon\n",
    "from segmentation_functions import channel_deconvolution\n",
    "\n",
    "def normalize(image, inverse=False):\n",
    "    if not inverse:\n",
    "        image = image/255.\n",
    "    else:\n",
    "        image = np.clip(image*255, 0, 255).astype(np.uint8)\n",
    "    return image\n",
    "\n",
    "def augmentor(image, label=None, stain=None):\n",
    "    \"\"\"Do image shape and color augmentation.\n",
    "    \n",
    "    Args:\n",
    "        image: [h, w, c], float\n",
    "    \"\"\"\n",
    "    n_channels = image.shape[2]\n",
    "    \n",
    "    if stain is not None:\n",
    "        stain = stain/255.\n",
    "    \n",
    "    # Shape augmentation\n",
    "    if np.random.uniform(0, 1) < 0.8:\n",
    "        # Projective transform\n",
    "        scale = np.random.uniform(0.9, 1.1)\n",
    "        aspect_ratio = np.random.uniform(0.9, 1.1)\n",
    "        rotation = np.random.uniform(-0.1, 0.1)\n",
    "        translationX = np.random.uniform(-10, 10)\n",
    "        translationY = np.random.uniform(-10, 10)\n",
    "        g = np.random.uniform(-0.001, 0.001)\n",
    "        h = np.random.uniform(-0.001, 0.001)\n",
    "\n",
    "        matrix = np.array([[math.cos(rotation) * scale * aspect_ratio, -math.sin(rotation), translationX],\n",
    "                          [math.sin(rotation), math.cos(rotation) * scale / aspect_ratio, translationY],\n",
    "                          [g, h, 1]])\n",
    "        tform = skimage.transform.ProjectiveTransform(matrix=matrix)\n",
    "        image_aug = np.zeros_like(image, dtype=np.float)\n",
    "        for ch in range(n_channels):\n",
    "            image_aug[..., ch] = skimage.transform.warp(image[..., ch], tform, preserve_range=True)\n",
    "        \n",
    "        image = image_aug\n",
    "        \n",
    "        if label is not None:\n",
    "            label_aug = np.zeros_like(label, dtype=np.int)\n",
    "            label_aug = skimage.transform.warp(label, tform, preserve_range=True, order=0)\n",
    "            label = label_aug\n",
    "            \n",
    "        if stain is not None:\n",
    "            stain_aug = np.zeros_like(stain, dtype=np.float)\n",
    "            for ch in range(n_channels):\n",
    "                stain_aug[..., ch] = skimage.transform.warp(stain[..., ch], tform, preserve_range=True)\n",
    "            stain = stain_aug\n",
    "            \n",
    "    if np.random.uniform(0, 1) < 0.5:\n",
    "        # Do 50% vertical flipping\n",
    "        image = image[::-1, :, :]\n",
    "        \n",
    "        if label is not None:\n",
    "            label = label[::-1, :]\n",
    "            \n",
    "        if stain is not None:\n",
    "            stain = stain[::-1, :]\n",
    "    if np.random.uniform(0, 1) < 0.5:\n",
    "        # Do 50% horizontal flipping\n",
    "        image = image[:, ::-1, :]\n",
    "        \n",
    "        if label is not None:\n",
    "            label = label[:, ::-1]\n",
    "            \n",
    "        if stain is not None:\n",
    "            stain = stain[:, ::-1]\n",
    "\n",
    "    # Color augmentation\n",
    "    # 1) add a global shifting for all channels\n",
    "    image = image + np.random.randn(1)[0] * 0.01\n",
    "\n",
    "    # 2) add a shifting & variance for each channel\n",
    "    for ch in range(n_channels):\n",
    "        image[:, :, ch] = image[:, :, ch] * np.clip(np.random.randn(1)[0] * 0.01 + 1, 0.95, 1.05) + np.random.randn(1)[0] * 0.01\n",
    "        \n",
    "    return image, label\n",
    "\n",
    "class Dataset(torch.utils.data.Dataset):\n",
    "    __initialized = False\n",
    "    def __init__(self, indexes_A, indexes_B, image_dict,\n",
    "                 augmentation=False, crop_size=256, crop_position=\"random\"):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            indexes: index used for image_dict\n",
    "            indexes_A: IHC + HE\n",
    "            indexes_B: IHC H channel\n",
    "        \"\"\"\n",
    "        self.indexes_A = indexes_A\n",
    "        self.indexes_B = indexes_B\n",
    "        self.length_B = len(indexes_B)\n",
    "        self.image_dict = image_dict\n",
    "        self.augmentation = augmentation\n",
    "        self.crop_size = crop_size\n",
    "        self.crop_position = crop_position\n",
    "        self.__initialized = True\n",
    "\n",
    "    def __len__(self):\n",
    "        \"\"\"Denotes the number of samples\"\"\"\n",
    "        return len(self.indexes_A)\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        \"\"\"Generate one batch of data.\n",
    "        \n",
    "        Returns:\n",
    "            idx: indexes of samples (long)\n",
    "        \"\"\"\n",
    "        # Generate indexes of the batch\n",
    "        data_index_A = self.indexes_A[index]\n",
    "        np.random.seed()\n",
    "        idx_B = np.random.choice(np.arange(self.length_B))\n",
    "        data_index_B = self.indexes_B[idx_B]\n",
    "        \n",
    "        # Generate data\n",
    "        image_A, _ = self.__data_generation(data_index_A, index)\n",
    "        image_B, _ = self.__data_generation(data_index_B, idx_B, h_channel=True)\n",
    "        \n",
    "        '''\n",
    "        data = dict()\n",
    "        data['A'] = image_A\n",
    "        data['B'] = image_B\n",
    "        data['A_paths'] = self.image_dict[data_index_A]['image_path']\n",
    "        data['B_paths'] = self.image_dict[data_index_B]['image_path']\n",
    "        data['target_B'] = target_B\n",
    "        data['stain_A'] = stain_A\n",
    "        '''\n",
    "\n",
    "        return image_A, image_B, self.image_dict[data_index_A]['type']\n",
    "    \n",
    "    def __data_generation(self, index, idx=0, h_channel=False):\n",
    "        \"\"\"Generates image containing batch_size samples.\n",
    "        \n",
    "        Args:\n",
    "            h_channel: if True, return deconvoluted single channel image\n",
    "        \n",
    "        Returns:\n",
    "            image: [b, ch, h, w]\n",
    "        \"\"\"\n",
    "        image = rgba2rgb(self.image_dict[index]['image'])\n",
    "        target = self.image_dict[index]['target']\n",
    "        image_path = self.image_dict[index]['image_path']\n",
    "        \n",
    "        # Process target\n",
    "        if target is not None:\n",
    "            target = normal_cell_to_stroma(rgba2rgb(target))\n",
    "            objects = split_masks(target, val_to_label=self.val_to_label, dtype='float')\n",
    "            target = np.transpose(np.array([x['mask'] for x in objects]), (1, 2, 0))\n",
    "            labels = [x['label'] for x in objects]\n",
    "        \n",
    "        # Augmentation\n",
    "        if h_channel:\n",
    "            _, image, _, _ = channel_deconvolution(image, \"HDB\", to_normalize=False)\n",
    "            image = np.clip(image, 0, None)\n",
    "            image = image[..., np.newaxis]\n",
    "        elif self.augmentation:\n",
    "            image, target = augmentor(image/255., target)\n",
    "        else:\n",
    "            image = image/255.\n",
    "            \n",
    "        # Resize\n",
    "        if self.image_dict[index]['magnitude'] == 20:\n",
    "            image = skimage.transform.rescale(image, 2, preserve_range=True, multichannel=True, order=1)\n",
    "            if target is not None:\n",
    "                target = skimage.transform.rescale(target, 2, preserve_range=True, multichannel=True, order=0)\n",
    "                \n",
    "        # Random crop\n",
    "        image, target = Crop(size=(self.crop_size, self.crop_size), pos=self.crop_position)([image, target])\n",
    "        \n",
    "        # Filter small objects & create target for MaskRCNN\n",
    "        if target is not None:\n",
    "            non_zeros = [(target[..., i], labels[i]) for i in range(len(labels)) if np.sum(target[..., i]) > 10]\n",
    "            if len(non_zeros):\n",
    "                target, labels = zip(*non_zeros)\n",
    "            else:\n",
    "                target = [np.ones((self.crop_size, self.crop_size))]\n",
    "                labels = [0]\n",
    "            target = objects_to_tensor_targets(target, labels, idx)\n",
    "        \n",
    "        image = torch.tensor(np.transpose(image, (2, 0, 1)).astype(float))\n",
    "        \n",
    "        return image, target\n",
    "    \n",
    "    def display(self, indices=None):\n",
    "        if indices is None:\n",
    "            indices = range(len(self))\n",
    "        elif isinstance(indices, int):\n",
    "            indices = np.random.choice(len(self), indices)\n",
    "        for i in indices:\n",
    "            data = self[i]\n",
    "            image = data['B']\n",
    "            targets = data['target_B']\n",
    "            image = image.permute(1, 2, 0).numpy()\n",
    "            if targets is not None:\n",
    "                bboxes = targets['boxes'].numpy()\n",
    "                labels = targets['labels'].numpy()\n",
    "                masks = targets['masks'].numpy()\n",
    "            \n",
    "            fig, ax = plt.subplots(1, 2, figsize=(6 * 2, 6))\n",
    "            ax[0].imshow(np.array(np.clip(image * 255, 0, 255), dtype=np.uint8))\n",
    "            ax[1].imshow(np.array(np.clip(image * 255, 0, 255), dtype=np.uint8))\n",
    "            if targets is not None:\n",
    "                color = self.label_to_val\n",
    "                for i, (mask, bbox, label) in enumerate(zip(masks, bboxes, labels)):\n",
    "                    c = tuple([1.0*_/255 for _ in color[label]]) if label else (0, 0, 0)\n",
    "                    polygon = binary_mask_to_polygon(mask)\n",
    "                    for verts in polygon:\n",
    "                        p = Polygon(np.array(verts[:, ::-1]), facecolor=\"none\", edgecolor=c)\n",
    "                        ax[1].add_patch(p)\n",
    "                    y1, x1, y2, x2 = bbox\n",
    "                    b = Rectangle((y1, x1), (y2-y1), (x2-x1), linewidth=2,\n",
    "                                  alpha=0.5, linestyle=\"solid\", edgecolor=c, facecolor=\"none\")\n",
    "                    ax[1].add_patch(b)\n",
    "\n",
    "            plt.show()\n",
    "            \n",
    "# def collate_fn(batch):\n",
    "#     return list(batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQYAAAD8CAYAAACVSwr3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsvUmsZkl2HvaduMM/vDGzKmvq7uomKVGy6Um0IFmADcgQbNiGAe4IywvThoDe2HtxZ8Arbg0YMNwLwdLCtrQRpAXhAQIErmTQECADJGRLoprqoaoyszLzDf90hwgvzjkRJ+69//CyssxHIAOV9d77/3vjxo2Ic853xqAQAt639+19e99sc3/UA3jf3rf37fG194zhfXvf3rdRe88Y3rf37X0btfeM4X173963UXvPGN639+19G7X3jOF9e9/et1H71hgDEf0HRPT/ENE/JaLf/Lae8769b+/bu2/0bcQxEFEB4P8F8O8B+CmA3wXwl0MIv//OH/a+vW/v2ztv3xZi+HMA/mkI4Q9CCA2A/wXAr31Lz3rf3rf37R238lvq9zsAfmL+/imAP7/v4g8++DB8/vn3QQQAtOeqAAU3+pPI/tx3X7p/f7P37ruO9nyX33sQgJFePRxr0P/Gt0y+1mAsD7p3f9s79MEX434f8iDb2QMHeLAv205Zz4c8fzDXZO88bd+FkP4dWu/8UbKfAqZfidKPIA8J5vt4m1z3+7//j16GEJ4dGTCAb48xHG1E9EMAPwSA733vc/zO7/yf8jlARKOJ6DqPvg/wPiD4ABBQVQWKgkCO4uV2YvSDgOGHJ41w4rM9fRDxogTE8QUAzpEhIpJ3A8hR6i7wBthL3KOhvAVTkfHtGzogm3b67dJY5fHjmXl7pkzTHR6+ey8/GFCMpRB7+0CwxNuPzbPeawgy7j35X5B90LU+/g4AwQc0ux5dF9D3Pu4RmuDedk26jq8l2UsEQtv28D7ItQRXEBAAHwK80EjfB4QQQABcQSAi/Gt/5sM/3DNzo/ZtMYafAfie+fu78llsIYQfAfgRAPzqr/6bcen0F9VxvOeX5QnShSE4x4SnxLdPUr8dU9B79kue7HmBF4GZAn9EIyVNNwmBzO46bWQqE06XsIkn5M+JEgtjohxioiGdxD6mRjKgxdQOv6EyRRBN9xkG4xp2NyG9R3Yzyt8sXj94kVw6h4hEifLxWeFDRFGY8R5gprC+b+FDIl6C7GUfInMhUMaMtB+S/U2OUPaOBSEUcQQ0LeD7gF4+d45Qlg5EzAQg9KB0Qz1N7MfD7dtiDL8L4E8S0S+AGcJ/AuA/PXSDTjDAL9/1PMl9H+LEkCMUOnmOiW8InTLpOYAPQ3myr02RbbA3T0JrQuEInlSCB4F2lF3HUsR2QvyPwpFxTUuwg++g47B36GY3/QZDfYfGsFerGf49oOJTAH8+UlLaHI8r+2Jfx2kQpH8qgzR9TnZBOSRQYnVCWN4DvvPoOo+29Wgbn1Ciee++D+g7FhggghOi9eY654CiIFQ1I98h+m1bj922x2bdYr1qsVm32Gw6vHq5RtN06DuWQkXhsFhWqKoCVS3/BE2/hUwB8C0xhhBCR0T/FYD/DUAB4K+FEH5v7/X5vZGz+l4ICRCEIPAcECrju4+R1KHnjb6g8UcA0gTv0yYcf+cCSw4KtPc5SWIcHI158NRA9/01+HzwTjmBkSGfoWg+8twDBgyly72qkeltJL11TUWiHodUYXQJGWYbJT5E4voQIX5U9USi86Mp9Rr0PQJ8z1cwwQtTaD2aXR/3q76DCjkv+pmT4QSzf+w8OEdRvfQ999u1Hnd3DVb3DVZ3De7vGqxXDTbrFq++VsbQx/eYzUvUsxLzeYX5osLZWY3ZvERVFWl8D2jfmo0hhPDbAH77AXcghIQQfEgkT6IyODfWyUKIe1x6wQmbaU+zsHLf92FwQRQuJJtCEQHiYoSMnmia5vYNZNROYwondTW68AimipL4AFMwvxAG724vGKETyi+OaIdydYHStXsNvRSE2ClBhgD4wJK+75hQqtqhKByKMh+rMg5vmEjf+bg/+5776Htv7BViX/CICIzAKKGsHIgI3nsE2b8ERr2ROYWAtgvYblrc3uxwf9fgxVf3uL9rsFo12Kwb7LYd2qbH/f0WbdOj63oZQ4ArCHVdYr6ocX4+x9X1AufncyzParRtj2bX7V2zqfZHZnwctqgGBLs9CXAQ3SnpaukG/XUonqY37ikqxEljnYTcZtTKLAaDHTG1ybHtG+UDGcJbNQM9p7/FoTff2+VobYboJO8lZz2imimCiD3w/60gyAy99nUEhfYd26v63qMT5lAUnvVzZ55o7EX6e9d6ViN8YgghBFYziPcpCoqoQPckGw1F9Q1mlSOyoGgsbHYdbm92ePl8hdevNvjiZ7dYrxpsNy12uxZdx+ik6zx87+G9R9+zKkMdBD04NHWHru3Rtj1W9zus1y3Wq92hVRq1x8EYdDKDLq7ZNcbQGK/VSw50SEOYfEI7emXIhdo0SglpA0cGMWYIp48q6/yPpllVZIiqjnAFEiYQJavtkMaIygKyzMkQPxjoRYPnq+cHhpEoPPd92lMheKzuOxCAonQoSorGbChaMI9Qjxj/424cUfQWFKVD4ZKNoOs8WvEoeB8ExKQBq7oRENDsWCVZr1q8ebXBy+crfP1yhRfP79A2XUQH3gc4R6hnVXwWAHjv4QqHuiowX9RYntW4uFqgrgvc3zW4vdng5mZ9aKFG7XEwBpjNQUrSCs0VKUTMnu7Zp8gCAIXIoU+zQSQ2kv7Kv8625UBZDmZ4Ifa1R20I+bMe0qbG9fYtvdG+98542gkDHisah1jg+Dva98ch7cYw4OjulsGEwBK2U8ZAQ09XAHU+MoWiGLiYXbI/WDcnURJWEclSmi9yPCzvgT74qFZIr4ALcYzrVYvVqsXtmy2+fslM4fWrNVb3O0EEnm0VjlDVJZ48XWKxqFDPSjYwAihLh6ouMJuVmC0qLJc1QgBWqwbbTYO7282eNZhuj4YxaOMJptGGDAjZAiTDELcovUhVSgPpD/CPwZNxiEGQ/WLYQvYj27DDexKaOU0FmnrO0WbmKGem+S9ECeGkL2j8rtKfV2h/YMSTQ1RaDftvjgR9aBqUQUeBIa/pEeNbdG69Z8m9vm+NbUAs+aVDVTtWLbqAtmFdnRx7l5x6CXxiGNytqAVgm0LfB0EkIUNFKs35Gna1U8fMwTlCQS4aQ9+82uLrFyt89eUdXn+9xv39Drumw3xesSuycpjNKyyXFc4v5vilX/4Q10/mODuvMZsVICLM5gXK0iUXvgPWqw6+73F7s8Lr1wfmdKI9OsZwsA2ltmnDjRx/PYkpjHqCZRBh/PHhHk4HKA9qR28ZPvdESGLndD/Kke8DuzeHl0wZAq2tRYnehzC5hmTvkUmf5B/KEERYBCH+rvVomh4A69n67L732Gy6GHCkAUEusJQtHFAWgcclhKrooO9DNCYHTxKXQKLisGGy73JXpROXoyvYRQkQyuBE/wdc4WLcje8D+hBQzwrMFxVm4lHofRBDInsZFssKy/Ma5+cznF/U+M7nl1gsK4ld4MlSlyfPIc9PPSvwyWcX2KxbFO5hgQx/vBiDtLQJ98FUAyX1l6nvT2wn84QH6wancZCTeMgJXR0RxA8Yfj7vh8LAYwxBBvenuYheqo/Yx3zUW2ANiZ24+ECAcyF6f1iiJ3edK8CIIAuOIxSBPWF9l+ISvBf06QHvFCkFoE/jsQgoRrbK2IlyVaTvPLq2Z/tD06Nt2A6xXrfoRJ2pZyWPrXD44NkSyyUzhvlC/s1LnF/UKCvHkySxMmq+4Nf0UOh0/XSB737/Wq4/vT0OxmBh975NJosyjo+zm3TIEPa1I2Rg4ccoim7QzSm9T9HB/tsPd643Trz2oTZ5yUHdaH9HrJrxAIaqSWIASXLZR7DgcnKLUduMXQCGuLLuxXrfdQHNtmOk0PloDCxK8RAAKRw5BJSVk7BgRgkK55NRmFFBjDwJiejZIJ7iUjS6US3lRUGmP1UTmRmRYXbBIwYprVYt7m932GxaNLsOzjl4H9A2Peq6xNl5jfOLGX7wS9dYLCpD1Dxe9pDI3BE/u3cBPQwTFBqYLyp8+t0LnF/UD1rmx8EYDrWpDZK+ykxnD0Pnp8rIRIFD3qWQMPtSLuDgxjDySEz3fHrLaJkefv/wqZOjU4MNDa+SFyMz76IaTKoHhilQ9qH8qkxAOgwe6L2PbkKNJdBHe4HuXeex23aJCIRAK3Ix7i0SNiR0nljvt9GFXt2O+mp7JEryliF2ri5rN2BiXsLjAQLJ2HsAza7DV1/c4c3rDW7ebHB7s8Vm3aBtPaqqiPkOVVVgsWTbQV0XHNFYO3aV9slVqobUqDJJnIV1sxIBVV1gsSgxmz2M1B8HY9CdBUzbCSA66iEJGQ4R2j7WEnfm/nHp/XFjhMG4BpeG9DMxh4lBDwlG75kYwiH2dbKaM+hx1KeZvJB+yXrnO1PQGb8eofchZ1h6e2CEZyMPd5suEbvZ2BpE1Ox6NI0XFx27GRESRNeHOCcGxKpAWbmoX+eS3r4fiYdCbAkBaHa9hCyz61GTjdKkJyOseiCCo+hQ0DGFALSignhJeKprh95Dgos8Xr9a4//6Bz/Bz376Cq9f3WGzadC1PccxSIIN5zwUqOsKV9dL3Nxs8Ol3rvDBh2e4uJphPi+jITSOFWwX6TpRlYjgShm7oAkfOJjrIe1xMAbbJmj1JGs13lZ6Hvn6xE6FB0x2PYzOPN4OSfThJw9/a70rCwuw0CdjEuZPZXZI76NQeTi0GPYtFxDYSHh7u4PvTfCQDT6KkYYhJcxpv5RgMxWE+bxAUbhEsIFzC+IsGWIGNNvQ2ASIJMJWmJ4QuCssEk3XhywjVlCST5OjiVsWPTCiIJQlxTyGonAg5+CcgysYUQaN9u09Gs8h133f4w/+yXPsdqwyVbXDfF6aJaKkqjlCEQwikhdQZqvv+5D2+BjDkCnsoyZLtNMI0LR93+6HILH7B8znobkPCKP4nNGzCUdcqw9b3GNNmYMN4UW0Hkw80a6N0hd480dqUm3DqgJC/NtNj9Vda/JhGM5r8JANCFPCLowLjgPdnIT/FuwSDIj9xWE6kZxOrAbRWJjqG5DAEH3/qLr0+Xsqg0sQxDAFjMOyNeEq2jAkunF5VuGjT87Rti2KgvDmzQrrdSPqjIc3sx3ABH1/t8XdDf+7v1ugKlnl8H2Jsi5QVS5Gbaq6VJTJ6xF8gHcWAZ3eHgdjMCyasg+TpBqpGEPpPElNJ0rTgUi3HP/t5PGexwyHRLJB7VNFGoR98OMbt7wvqzZkgmXw8iOcEtKipFoB9ntC23LcQNuwirDZdNhuuijNfM9BRz4AZZkkoBouC2EAyWBoUIOJUNR/ReGyLEUAEs6sjCZHdUUBBIdovAQQdXhrPB3ZiQxCsBNELmVRJq8HxxSU9Rx/+lc+wgcfLvHzn97gx3/wNV48v8N6xUFMzgVhZo6jGOsSy7M5qqpE13KsQ7PrURSEi8sZFmcVzs9rkCNUql5o5CY4GjKAja1vU77xUTAGC0cjQsgkpxFPY1KKvx96/X3fWQn4EPob9jep+kA3YtLRs+uHxJh9vz87c6rp+x9+hdNfcHI+raqApIo4JR5K0rtrPe7vOLCokyxELlTikWoXpKI25CSkWAhfA4xmc7YhJLUAQpiIVE6UIHtRuBhhGC33iMI+Gib1M55/w4j1h5VIwfxtmIKinFRDIRGoJVRXEOoZ4ZNPz3F2VmOxrOAKh7OzGm/erHF/t5X3YMbADK7A+fkcRVlgt+vw8sU93Es2bl5cznB+OcOTpwtcXnKg09k59+mcfXcOoVaU9JD2KBgDoDRv9LgIq80b6eJMU9JpEY6DC2KZLoWLBkeO+goTnw8FvhCIRZ822M/stZF6n0ncY+8RWyLhb8IUcsS8j81adpVLd33n3gO7bY/VfYvnX65QiNleoS1v1BCXkcSIVgpBs8R3KAUma0QfSKzynUcXpXoivlCAsxiFENSCz25DHXmI2btsPA2ZBwTgAKQ0IwmS98i3p9pCgJQlqWiFf1eInwoKlQtWAep5geVZjU8/u8Srr9e4fbMdGGQJvg/Y7XoUjrBeNVivd9isd9hsGtSzEldXCzz7+ALPPr7ARx9f4NnHZ6jECKtoiYhrNYQhHZ3QHgljEF3M/Jl0O/4ok4bRYGTEgN5orzM6IaXbppvlNwEwiXAxmWc0uXtgQ0TjIkFPZVrvUm3RkSjTG8NJikxLLhmMRBmkSkkg+ASznUNcs6bpo82g2TFT2G5aJjolJtn4s1nBz1NJqxK1TmX6HCW1QbMPAX4HVxAWdRUrFimReg+0O0426sR1N6zuxWHQSRL0xpOg6KXv5X0NSuXAIxmf7imdN2WKpIzKqDvy7l6YT1FypaXLqxnOz2t89t1L7LacBanvp/3uth3+xT9/g1dfb/Dm9Rq+D2gaj92ux/OvbvAvfEBZOlw/PcPn3/8Af+Hf+UVcP1lEhgQwkqtnbIuw2aOntEfCGI5Ly8nXGm32XOLrnWR7HQjDY8SYCHriypHijUmmdvCed9xydSJxOzLjsgZdEmmeK26WQ06oQHp1kGjBKMm5rmHb9ui7EMODiZiJE7GfnqI+TtFQWIi6YNUSfoR9I4pVj9johsw96TsPHwhFoMgYAB6fvqvaJ4h7i3EHQVKqSUKnY7wGqSpQRDSg6k826TI51jZh5wkAgicESnUYayrgHGGBMo+JATPY+7vGxEUwmqlnJdq2w27XoO88tpsWN2+2uHmzRVkVmM9LlFURU8E1orL44+qVyNbfTFD01Z5sQJliDkCk1JxyMk8BR7+lq9NQLNHk34+eEZlDrnfsARcHezvUJqZquul0CBHaz3PNTNlnyC6wPCPq+XG+UjpyL5F7bdtHwvEifYuCVYWi5DJmmkeQ1aMUyO4F4sd82gGxEUnGovdwMAY3IjhXou5DHBN0fNtOxsv+fvZ2CPQngwI80FW2+AoSYqgLFCWPSt2sykzsHFnkECMk86XgS30ynBIAqAGXUp7DB8+WKEvHVZnmFZZnW2zXLYrCoZH6DJwX4vDq5RoEwvXTBc7OCcWMvTZdFwDyKB9ogHw0jAHAgDvkLbMMP0BnGhFg5MxTGPp4mbgpfkPKELRXlRDH7n3L9k362Qdk9IuIrwZMQaU85LOgUUJAjEPoWg1RVljumdk6h4I0gCcPzlE1xUtQgFr17XonW4YZaFb0RPV8h6JAZFShDyAX0PcuG2fvA9ADZZHS+UkkrM0p0LlSRuLIWFg0mczRuEwEJXUrBEqMRi8Iqv6EOM8uGObnCKUjnF/UHNFZcfzDbFZgtWpBjhIDls6bxmO1apnxOoPOHG/44P+YIoZI6mppnpT60giDmoonckPd/MQLNn3fHhE/1RcSIY1UlDC87o+iGaUiYKQWjAZlYQilnwSRgpT0Zd2QRUFodhqUk2L1bR3EngKKQqIRY+xBepQGDDniFGP1xat9wfcaZ8AJWEo80RMCQAIBeMjEfXnHBUfnixIIDKt3nsuh9QHcF4RRyL6wHhBb1bn0QIeUvBXtFoUgMZkvbyqZFy7lTQQzv8HaKGTMwcAUjQtRu4tmRhYFxbmJz5Y5ImIVZ71qZb0DFsuKE67KgVfnhPaIGAMGur8NCKI9om6aetO9+11+VvpYyXi00egX892Q8jBSXabbSRfFaw8N1WgFYxOI5VYETCY5YkJdUmlNTJg8X1qPgF2Ru10v5cQ4/bmTKEQNvtGRs5rBD7f1NRykzgGl4CbAhCJ7iuPQ4CX1NkSGpwMmArkAto9KLQUhfN+HVLiXOBsx+OSpMNPD15nybgGI9Uj1fuuV4S0Xko1C6jZo0RZCYtAyzCjRYzAUUuQiv6NDNSswX5ToOk6E0uCuqixADhI81kUG0UsRGj2Lhcd0YNNMtEfCGCRjLcJF+TRO4rQUD/v+iBIvxEUGKCc//ZyIF98wCJvFGRce9uapsYR8mJbCLL/YiyCOMYcBPrLPj1Id+QTqdSPVK5gxJUOZReojBqFr4wjOA13w2G473N80uL9v0bY9dtsOm3WL+9sGIOCz717i4rJGPSuilhhEUjsaByIRENGBMgjOh3BRvSA7MKjKoxNvbUTJpqKIQkura9MArN6UdXfqFSk4zNhRqvWo8Q+akKUGw+g10UkNPD/OJ+Pr8FpyJDaSpL4SIIw2oG17rNetJJYx6qhnpVR+dqZfHm8juSVaiEaDrLabLrotH9IeBWNIwSoDay7M72Hw4Ql9WmSs0jyQWqQHbbThbPKTjC3rb/946NA1I3E8ff/ULXuGOgn9903VJPtJdGVcs/s6YFvCZsNMYLvtxTre4fXXa7x5zZmDZVXg40/PMV9w/YC+9/AiZS2sVWJRNMN7IX3vfYAjcPKS3RujcVL8265TlNQTCMk5AgRmayamqkzRc0FOCrCmsOnIBkKuEkARjGEEpKHeybfKDE76YUbBI+59EC/DDne3O9zf7VCWzMxiBKjES5SOVQx1gVa1i94hSTiNXp6uC4/mwJmHtyl3ipVeYfTx6FJgsGn0/gHR6G6JSEJWadhv9szpRIe9Y7LIJPYzZAo0+PwgajhE7qbrYOgqEk8YXWtIM+GjQ4/XvgKSB6LhasXbbYfbmy2++uIWX79cYbVqsDyrAXBW32xeoOsoooJYzcnYIQ5B3RFCCgNoPAGSRuhteF1AOo6g4EVS+ZR5QRynT3vfS2n4NA8ISKdEARk6SPUg5cHB1nHQMbJ9QxOfdDzRPemE6CuH2axEVbt4hkQpBWzLwqGoZD57CTNXZiVj6Rr/EJkK4JEwhmRx3r9BptD8ZBvAZmscjIsdO5LFk90TRKTkpoKAEPKnZgVG7G9W4ho6niRpK9mHaGXwnna80aMymIjsT8NoQhh/PJ7DxBxCdqV8axGJfO0lM9E5h/u7HV4+v8NPf/oKr16u0HUeH4TzlP1o5polc4h9WNdinEZKxOmiO9E+WxEdpTnP/M6Dd8iQYPo9N8il6Myk0iYEWxQOwaUZVKNi33uoBqEqSKwRafZ08IS+78UQGaKw8iFwhemCvTd6DsX1k7nkf6Qwb8290IrWw0AqHX+uXgG+TpWtT22PgjEASYocileIBjBApMwRPhhg0ECixLRvFL7mgNTmFzKDD9lnsXuyRCbhwmT+mjBGxu07xLwnNh3fPrPqwfk72LMMaIhuTL98ZKAXw5a4KHuP11+v8fyrO7x8foebN2s453B+PotuS5XOANB3aQPnuRLCuDXxSO0JhlkMh8VGZspfLL8gRwxTc0JmETI+kRilGjAjshKq9gXgeooIxgZQ2ePhguxD73WPJxRLAbH4LDMUCQEPVYZALJOytqTs1SOqC+ZvzRp9GGZ4JIzBkJfMWHpJZN9FVBjh2P5e8+/ZU6HCKW4aJNPPlDaT+kmLr89nxjOBHLK/A3LPqDVy0t49O0QNp7aDiOsQI1IpEycWUU9W2NwFDsndbju0cqDJbtvhyy9u8eUXN7i9WWO7bVDXFbqePRVtJycliQm/60Rq+lSAFQDKIqUPqxV/6n30NYaYLS7EMc/QUO0QW1IEYub9bbyLZk7Gw2MEYXhP2V7ScSS1QFASESoqUIakTgUgogKLXtRdSZk6YtSSHECJqp3QDEUDB9805X061h4FY1B3EFtP2UUzfJeRUAgBbjBJ+ieX4c8XUm+0hiCFW3Hx/Ni/HB84wvb5ePYSMZm9qp1Oo1xZ+NRbNgdH0FGY2MyIEm7iYYP7ElMM0fCWxs/Gt5fP13j1coP1irMm+Ti1LX72k1d4+fwO9/dbdC27zTbrBrdvtri/bVg/NiHPcIAHoQA4elDjIjyXp6dgw5aDSF3Dfh1AfiwxR3oZ7V+XDFhMoLp0QdL/ub/UKSGM1BG9VRmYJnUBKe4gMulgIyeN2me6zLxiU4OH2VIhrWPWldDVQ9qjYAyAcLwAqZST3tBuUL7Q3pSkXBSIwmkJMIVBERNk2LJrOgp6QeqWAPFehKhfK4SMa0T59dmgJj7N+t7/telj+oJjKGk0QUhzMFDVJweXYgHzZ7Vtj5cv1nj51QrrVQvn2EV2e7tF3wdzngHf3/ce93c73L7Zop6VODurUM2cSENx06mvXyzz0a6g/QiMJpfDaI2D2D9nGVufbHsZxqHbRCWw6la+P/izfM+mD1QmReJVohdEkUd9AXsq+wyYP7LXHY3/LaHnI2IM8m69F0LnCc1P+aF4cQiIZbnUopxCY9NMeKkHoKcTzxclytJAvKD6b070ypasRwPIiSsTxwaBxA+mVoQIFE5ZLXtNSP+fWvgT26FLM/sNkM0PwNl+P//JDV4+X2G37VDPSoQAbNasOiyWM+x2DQCgKDhu4c2rDZ6f1SDnQLTEmaskhZqEyfKiO7iUuqz6toQrs6EuMQ2AEczxvT7CmN+oWc+S3QPOmXWxtGolt27TKeGWARwSQWe/5H1FmOgwDi6/fkLKHX65ifZoGAPAG7HvdZMmDgsYTisTaWPN06ZhOKoJKd5zSvDdzQ7rdYfgAy6uZpjNy2zbsJXXwESFjDquQxtLDT3ZwiFJi6lb9xkzjrUh3znw9UP7s0bWqeF5Dw5out9ht+2wkIpJAPhwlHmN5XKOqi5RVyXOzucI0MNg+phQZeF9NKJaplBSPPcBoqOTgfCRpw4Ydk4wwxeYQhDHUcXxllDteI8IkY8YuUZ+5t2om1lD/bM3GAidyS0Vv7GTM7731PZoGEM0cgHRkMICOb1Ucs1IOK5UxlUdUOszuIJn2fce61WLL7+4x83rHeq6gA/A+XlI2XWFgzMVTocx5boxp9x+uZTYx8WN6nDy+lD2Y/gcJuIx9aq6M2q6X47wN4WoegaDGsgAoKq44lBZOjQC96uKD1JdrRrMZhUuLpdwjnB2NsPZ+QzXTxa4vJpjec7Rj1q/MULwYBk7cqaRiVqMApRsslf+ovaF9zXKfpoDA9P07eMx8TMazGdas9Q75USpfGJPcQ61e2ZYZ3LNTBg/5euu8TaaC6ReyoeKokfDGNg4MnDJyN8BGhyi8FYTchDr/Km/XM8w7D271V59vcbv/aMv8NUXd/ju969xdlF1BpUdAAAgAElEQVTh4rKOacDOEWfZaUy+WNCzfWl+poUKObx005I20xoeuDpxj1L+6cEtv28j2704IUWsKqFMIer4IMwXJa6u57i4nMORw/KMT1VeLCt89vkVurbHdtOi7xj6l5XDJ59xZaHL6xmrcJXjUuct+/Lt6dBa7SgmRyGNeRS7YYh2UmGYgtvZZAznilJfse9DnCF9NXQPk/n/SDhYvmXvMY8YpsYDA6E0QiBpf2TjH/YxNf4D7VEwhmT1TVyYRsSQb2W7mZR5hz6gbfkwEo4bD7h9s8XrVyu8eb3Gx5+ec7IMRBXpTQy8S8eaFwUwjKtIdqGQ0bkK86ntYxmHveAtFYm9HZzSXzggRXUzU7qY/2fEuHOE+aLCxeUcRcEHoZydVbi4mmG5rNB1Hps1H9nuA7vgrq7nWJ5XmGn1I+3acCllRKli02jgcfS56nyAA+aXHp+fyQu+4Srtx/snUOmeC8ME8Jtkjjk3OBbuM9UeBWNgZMBvqFFwCoGGhBnvUKgbJPHGs499fc8VbThBJuDFVyvc3myx3TZgKc+ut77vI5wFsbGrLF0MQbXprYORxudH3fCUV9xHlyNCmFIRpPLPoQdNElSicS53oCqa+B4GVm/9S7P0NHsQ4LlenlX44MMlzi96zGYFzs5rXD2ZYbEo0bbMGLrWcz2BknB+OYvnPwCqPqQherE4a3RjdJMOEE6IxoU97zp86YPtmJpxpE2pGiOJPtbdBnLuwPDyfKFpbWUK9dg+zI8pH+gJ7RsxBiL6MYA7cOX+LoTwZ4noKYC/CeAHAH4M4NdDCEcO4dZUVYXraTp0Mw1LqARQilMXQ2Tb9NhuOrx8vsZ61WC36/DVl7d49fU9Nms+WryRQ0Vj2q6FrSH1VRj/XhboYxebcnY90nfjHtyzKCOFFgBNRPNBmYM8RLs20GXSWBolxgReGI7LPFLfU5mu93zOwXxR4urJAr0cgLJYVri8rDFblOg7j7ououuyKF1CCo7iLifizL8Yf4Pk288Ry4F2iLYn7t17uaXft+QVKQZ1D4a31+4xOmfBSQfuT/3o1emPsQAdjuphsOFdIIZ/N4Tw0vz9mwD+Xgjht4joN+Xvv3qogxBSiTAAUVqpSyuIxIsHqQoBK2MYtjev1nj5YoWbNxu8eH6DFy9u0Hc9HyS6btG1PeaLErWcDxhtClBoKzonJWNkPCVJUrRJxpYFTKl7T5hKpNt9CVhKHUAugY5s0ihJhdAsjUeprBJXdorT+BDT9tkj4pA80Em9ha7zmMlJzMGzJ6eWNGY9+KQoXQq9JUiuhM5PesEy2nNgmPMgyHsAEGLhX2ASVQ3vGX4+wWtPu/fIdftg+kiVSVrZpD6QhTAcUwHI7NOsj3TjW2gPWfs2VIlfA/AX5fe/DuDv4whjUNqy4caJOB3sCcP2he3G14QbPZmn7z02mwabTRuhMYDITJyUzKpnRUq7jdlzCYn0IjG7zkvSTIglwTW5hZzWKGRLiAUK1tU22cyG2C8tkkTV4J54PNpgHocxMolB2ajOhIaGzb4DBD1pZSY9NRqQAq5lei/n5HCTwjxH1pFICTsfsr1OCWLkrMuIyMKz8fsP5yLOw8R1h4DcsTYmunDke4zHO0RoY759uNG+Odpz+QO6Br45YwgA/ndikfg/hBB+BODjEMIX8v2XAD6eupGIfgjghwDw3e9+D23jQQSucGsCjmJIaee5BBeQDvMokNWyU5fYL/9Lz/DhszN89eU5vn5xgZs3TwAAv/BLH+H6yRL1rOTjvpzGuytz0fl2HOff8CEpW6k9wCcptZxKLEUzuDx3gYvLOp5anEJfx8sxtGJnf8oCj9aY0uGwUbpSiDp6Su5JdQY1eEgj6jS7TuGnzm3cUwaCxn7leVXNnp++T1mB+lMrNVnVzEJdtcU4neCIqswcABL0lRjz0DORzwciKjJ3IN/+Ibs0Pkd/eyBnmHaLHrvJjBfIqksbO3tSkq0uZXj36GmKTveNkehteV5s35Qx/NshhJ8R0UcA/g8i+sf2yxBCEKYxasJEfgQAv/Iv/xvhi5/dwxWEq2sOQKprOTyk5Qo6weeoAhD9VMp0gWQjO8KTp3PM5gXOL2t88ukF1usGIQBPP1ji/GIGIq4pEEtrl2qMAyD2js2amcB202O9anB/13DNgS9vQUAs1b08q3F2PsP3vn+F84sai7OKx04DJmAhhNnQlnfk+iFlUiWdzZgQku4Mi7hSXghF1SaAjYHD52lvSrRcei3ZbhKz4Zv6PpgEn8QEHNFobRD7RKoRYW1HZl5Gm3jQz5RAtGwkm7ODd6WrjAlpf9sr+o/co/0e6H/EaDJGlY99L9gcwefpi4++50T7RowhhPAz+fmciP42gD8H4Csi+jSE8AURfQrg+bF+tpsW/+QfP8fybAb3C9dAAJyrUBS57SFl3g3cWjqPskEXZxXqGbvUmmvO8gshxAIXMVAqKPEaEB/Y4NY2PXbbnkuV3TV483qD16/W+PLntwg+oCiZMZydzXBxNcfV9Rxl6VDXBUJlksCMdNUNoFI/XRLiiUjpndgIqYE9Q6OsZTzOAfCi0ggxZjzGNK1XmPRUGAnDD4v2CKJ8v9rrhceRrkmGFCjyQPOS6YfZxOM9O5B2OpTxq7x1y5DDcATh4J/HOzbd0uDjATRLjWgiLWL4xhOTqX9NGi/fjiFoe2vGQERnAFwI4U5+//cB/DcA/i6A3wDwW/Lz7xzra7Xa4R/+7h/i08+e4PrJAmXF5xWiLmINQN2MzhnprpstaPUdq2oUxo7AJyVVtbohOSoyI07S+AZEnbrvOZx3t+1wf7vD7c0W61XDKk8ZywEDQIqd6Ll8+rB8GU8a9uXFjFtghqEMbxhkFQKnMxMI3unzXEIJA5WFqy0jpjo7UjuLy7YgEaGqEtkw9CeEoLqIYQqkAVHJWIz0YwiOMsNsekdk94AG5LqXMoe6yNQ1/Gb7mEq0/R7mDSd9kzE+Mv0qU7PrORpliEl7cQKOtJxlGMvMqfvrSPsmiOFjAH9b4GMJ4H8KIfyvRPS7AP4WEf0VAH8I4NePdbTbdfj5z15jeTaPMfXR8wBdQH5jixaUGbDXInfJcbZfgaIIMWlK9X8AaFvdo5RvkMCMqPdcWLNpOKJvtdphfb9Ds2ujcVOrCLFtIxk+tWXGeOTrlbkaA8GLxpXcs1bi2F0nn6iuLsaA4MF9BDMnQCTiEFh94nli5y9/H+SfIWoleCDWyLQnKUfAY9DDECGk6ko8udYoelAwIl03nLO9bfKid4Uvjj1Y1i2i1gOX7xnSO6LlNCT78y3bWzOGEMIfAPjXJz7/GsBfelBfUs2nrksszyvMF6VEyokRzWy6WNJLftczE/P8CkTd1zmCq4tkWCTWocuSokGOC46SKtsIYNTQth67XYftls9i3O069N6DRA/3PqCq2F13cTnD+UVtzjhM8Ho0NqsOqXR1JBV+B/UMMcFcVGqbzwIUFegpSSyZs7BjeXYQqeT7gG3XgUgOgjFWw1iQxKCConQSgJYkX2YjgVFP4rgS8ZARzyNVcPThsTYE6geg9oFeApAFjh1mJ/vHx0x0ut+EImQuRg8ZwqS9I82fZ/54m2Ish9qjiHysZyV++U99il/65Wf44MMllmdV1JMJAJl6dzCfa36EWuK1RWLQSkDGSut7LsDZdyGiCJW2BRF84O9ev9zgxVf3ePHiHq+/XuPmzRqr1Q67bSsJRCWqmqP/nn10jusncyzOymyc8UyEocCXZs9M5ANW5QvKN5rdDuopqGdaG10Yo5x3kB32ggAUxIVPDB0FINo0ND6j79K4nJzDoN/r2Y9lmZca1nB09BpOntSEVA4vb1bNSC9q5mQ4R6M/BoxgZLofU8hhcj7GRo4xK8P4Bj1M0f++gIqcJ4bsN5r4fHjPVGjHeO5Ob4+CMcxmFX7wSx/io0/OsyPCgCR1E4y1eFW5MJIiB5HIOv+qHsh1euZgjFugJACdnEug9fq850Nad1LKrNOa/c6hnpe4vFrgyQdLPPlgEeMhrBEuEp0eyW7OJkjjT4TK75feMbr64suw2kDGfRkUVTmC83L2o+FEWpk59jFAHxrDYeNEEjrjdGs9eSmeAqU2BdNi/UX5PaoYBlmoSWbkTLNLekCtmGp2LscBQe8CoO9Tar4FVWUPajhF1Rgs7biDB7ZHwRgWywp/+lc+wuXVHEA6oZfknwYUjdoelqi6twoYhXDRcAct9AIEMW46RwhixKtnBc4vatyd1xwZWSRKKQqH2bzC1eUCn3x2he989woffXKO2byQ4iJpDFyLgJO6djs+pUmrCgNI+RmVk2xPJ8xMobcQVymqh7yVHoCS6/SMrPg4FQfvfTQ0kg9RfckFLUWPR5y36OkgyXkA+pKidygyaolqjIZIUJxbYi4LBw3jFqXCogRdsn10Z67JN/1QNRneM8Dz49sOtH2SetjZKT3saccoXPWOAQo56bnvkFc9CsZQz0pGCyVv62g4sxftVyHj1xHCGSzHUjWkz024ndovNKuSTLXey6sZttsWm/UZvPdwjgOoCMDZ+RwffHiGz75ziY8+Ocf1kwWICF3r05HwHYcSs/Gyx27Xodn1ojKE6Lko5QTo2azEYlmhKB1KOaOw0NRwz0pkMnBROmrNKhqEyMT0SDcV01mp8Rx0sSFSay+aIBytgam2i67z0atDkiKtxB0yhRoDbBsy+o8oSReFLOMzi2gIfcwc9iy+/XaoZZzEHMaqwEm0fEJ7GH6ZGuxQWXmLQZzYHgVj0IM1nNEi4iSKuyxBUooSVfeO8lbrBVDGEvQe7UufSUDQCErZ6LF+PwGX1zM4B8xmJS6v53j51QKr+wZF6XB5Ncf1kzmefLDE5fUci2WJtlEPRhcjJVerFl3To2n5cBZ1Z7ZNn6olg3X3xaLC0w+XWCwrLJdsgJ0vShAV8E6JB+mn12kI8d3V68LgysGpqxdkIjLzubeqDx/vjpgb0cvp1a0wPACoBKlU4CAujZLUMeiI1Eah65QeKGqdfi8cgpzykpD1Ed8vG7URG1NayUEhMoQR+efmkVNPm2wHyHVqiA9oljns72Xyud9Qi3o0jKGeMVrI9HDdc54r0ZBTSKqbwkALo8tC7lUi0o96MTzG1O7AngetM9h3htMEVnGqusCTpwt8/v1rkZiE2UwSsMQDAQBvXu1wf9vw0WL3DVb3/LvvfdStHfFpTJtNi7bREuzq9gQWP2GvxmzGEZWXEjj1nc8vYnAWBa6k3LU+c9Eq2uGksFTfwHuK/UdbjbxjOs2Z7S1979F2KX1aa2V2LceBzOYlSjFM9l2InhllGoxKkmuTyBmmk9Z6jCUsKpD/R3oYqD9R7ZEydFNIwbYMSk5dkF8YNZ9B28dOhj0cbjT510GGMhHzMTWmBwzipPYoGIMBwyOJFqVPdt0ES9/bZ7pE4x1UxUCQtOI+wPXDU334OmVaVV0AIYje7aQ0HEMc7/V0YT5roW34pxIUgOglyUfIz/M9H9zi+x22W4eqKrDdsurRtj0ur2d8y7yMY7T2EojlLXjKMlT5J+IYNeCI5P24LoXaPCSEWs58UKK3p0WxAZUZKsdxjHehjsuL50cR2FQRFjL/TwbinMNPuTUPnccRFzv7hcxnp3GKd0RfGKOd8QOGBte3UU2GqOabahaPgjEEsPWbEKJHIQX6WChpXz8IHB10to/bh5gzCCI5/ZcCOrCU1NOGnJYYQwpHjitHhihNQFHf+3Q0WEhjJyfGvcFY9SizMiSJ6gPHH5AQ4G7XxRJ1V9fz+C5VXaAUw1+gxFxsngR7W0JECCGQIBNAU1c0eKtr2dBb1Yx+KqmLSa6PUaDOUST0rvMoOxf74RgIl+JEkHI02tajgoPTI9gEMUXQTjCMCzEYiszncVkV+lECirKsZo3tDVbEKhLUTgmHSOedM4VjHQ7f9aj2MB7/FNP9JszhUTAGgCV5IKAQP6+uYyxaQohvPxIIh/rFYH6Jl4scEN3uU4qlIlgxsFn7BZCCqoKgDi1OolWgyorzJjTgCBApHpi4yQG9I/R9Qh1BAq2cYwNf3wc02w6r+wZn5zVm81K8AQEFEsJJqtX45TXGQedXdfvdrouqDznCfF7G2gpF6YAQ4jmKIRKszH9IqEtVhyn7AqMMiMDmCVUDrZ1LBPbgqAoZT6SSZ7qCA7XsmY2683VdhqX/TsPd44/30/DD2AWNfnngzUf39jFF5JQr9rfHwxhEEfcBMZ+ACVOloeG+hqPGeQ+GvoEUR2I+nISzml1pEANfC/MzQXQeqyncIkRSVnyqc9uUXLtB3icdxZaKuJSlQ9cX6DqW2ESq73uUJdsYyqqIyKYVfb/vBJl4ILhElPqG0eGix6NJVau+Z4pTJ4LvA7brDi9frPHTP3zD9gNJI5/NSzz7+FzO33CoKz4kpqxY5VDiVFVKg6GiqhKSnUgJvuv4jxC4BH3XeHQDlLXbdqzWAJHJqlG6rgvUc05aq2d8tmM0pCZN6oGNbz4dO4xEzGmPOH0ob3dvRv7TysTboIdHwxi05eHDKWDoKCQbQMypdSQHuIGlAkhHh+khJ9PTyJ/HEnRAqiBFnIwUQol+KRGVUsjF934U4FTVJsgqBHQdnwfZtT2ccwLrXXQxzqTOhFZQVuOeSk+N29DGKCF5FBDY1QoCG3KlPub97Q7Pv7pH2/ao65L/zfiwmKvrOS6vZqhnJcoSKEIRw9H5cNuAYUa9VaWCzAujK/7XtT3ubhq0bR8jPXV+7m53HECmSKUsYnm42bzkupLnFRaLCrNFicWiQFSjZH32JSnp+k0AcOxnDkMj6bfcpoTcQzuY/DtMfnusPRrGYIumEEzhDxiofGy2DFSO9QoMRykcgBjpp9F8EOhuEAWRhEwbD4mMQUuXkWOYbUOgqzrEOhBt02O9ajmWQYyIWgWqECk4W5RYLhkdIATW+TtBBkjMZbHkSstVzVmnKjHjeZsyN+ru1We3LdtO6rrAbF5wbEXnsd30WN03uL3d4fWrNbbbNuZJeO/x5c9v8Oyjc3z/F5/io4/PsTyvUFUFmqbH+r7BbtuhaXoAjH4+eLbEbF6hKlOFJ3WfOjF89D2/1/1dI3knPCfNrsNu23EB36aH9zzmqmLGMJ+z63axrHB2XuPicobLqxk++uQs5aU41TbHzGGoZmV5ESFtmogu7eUZZ9hHWrlB4CQCzGhWxmu8L5mQ+8Yc6W10mUfEGLgFOZcAURIqo7DHigOIRH24NzPXstIWcjoHFCWfdWCZAskuCdkG4/tB4v4LRsVRuwVBXHRJP57Pk5GvlbgAhu4sCVmv53Dqs4uan+v1UelgF1CSePboOCIyRjuK6kc9KyLML0qKRV271nO26H2DzarBdttgs26S16Hvsdu18N5jeVZFplLXBbabDq+/3uDV12u8frXCdsN5I//qn/kMzz46A53VqF2BoH4DVQkdUJLDfMFnWK5XDe5vd7i52WC76cSw2UviWg8AaDt2IzdNh92uZKYhTNk5wvWTmTAFl9ml1Gi8l6BG34X8u/i76iiH95i9KWMmh55vnh3XUf4XbyeYUukTtx55zDdtj4YxsIDn2eBwZTFwAXAegIYlE2JegcYHxMk0xDL5DEeA0X9DPMRGL+AEy6G/X8cHkoQtn9sqNNSY5BlFAQBOVImAqi44GrL3MT6grNhAqQfmlKVDVQ/StpGkRvZKAWgan8URcDZlnuhUFGw4dGLI1AQydlOmpKuu7dE0LZqmQ9d12GwaBHicnVVYLCtcPZljvijR9x7rFRet+frFCvd3O3R9j6cfLhF8wAfPznB+UQuS4jeIHhowE16eV1jcV7i73aHvAppdFxEeJ3P5mPJOjlB1LoZiF6VDWRWoqhZN41HVPgtDH+bRDIT5xIZI10xp6Md18/yukfZ61CwxeIIBO6cS/NvYD05pj4YxgAgFAZ0ghQiRHUuAvXN8kj4WIhLQGpI+8OZTV6Urco+IWuOT3swPKgqH4IL2Ci0iowxG60kU4j0IBRvqgueqTlzmniMgNSBIRB0bCbXKckhFaNvGo54XqGrOqfAhYH3PhNw0Hp0YGLVKVV0XmV0iBAmIkskiYSBzqX0J4ufsdi12u50MiKtCL89rfPTJOc4vamYwwoxI9JbdtsWP/9nX2G46iW24wMVVjdmsTMjGJIgtzyp88GyJIKoTwCdphxBADbAFu1J7sFHWUQVfStGcjqNGdztNaitEpWLUl/I3hvq1qUBtmcXAYpntsdG+st9O7TjZEyEhu337NT6fcjVZDdw2IC5ee6CdfLbJA9rjYQwB0U1lqzojJAlvdbApBBjnfM/6kRjD1JrtQxCdP0n9qGMO1BkbuaeSkJkFDZ6BaB8IgXVeRR+6F4vCMzF4pNiDkBdsDeDCKr3mKPQORR/giQlzu+2wXrVYrxps1i12Ww6zLgoOyDo7qzBfVKhnzChUkpeVw2JR4vyixvVTPluy61i377oObeuw2zVYrx1u3nC6+XrVoG16FCWhKgs5xLZCs+vQtB3ubncoqxXmiwpF4VBWhLJwKOvCqH68gHVd4OKiRt95bDec631/xwfl+pLrWyBw/AYCz0HbdMnj0Xt0fY+72zNOPCsIVWaApdGGSKp82hCkqPGgVB+S2z7yG7OQ7I99OsB4qDFobepskb3tW4ANj4Yx6MZRl6FC9wj7Q5qsTJczbTQ/CWNG287oHEhi42Oy8ksfcn5ERC8+1W/Q5CEteRCAaGeI+R5RRxy4SEnP6SyiyxNgpGELvACQo/LYMFoI0uk7tuK3TY/tusXdzQ6vX21wd7vFZt1gtdpy7sWyxsXFHJfXCzx5usAPfvEJqlmBRV2grlltKUuHly+uUVYlV86uShSlQ/eql5TzDut1i9WqwXbb4eyMi9Fst/Mo3eq6xHbLjOPFl/cgEGbzij0c81IXNyZ1uYJQSfbqhx8t5ZyKgN22g3N8Jqafl9Fz0bQ9F8rZdXD3O9zVBZbLGk+eLjgqdV6gnpVwBPHkIBYI1kOJfBhXhvAAq5V2Kw1UULuXxtvNcPo9Vx3VJDJJH+IQbBbsqe1d84ZHwxjYpddPfkeU4hsIdv1oMCNjpTKCAJXwCuGclnlzIHA9xF7qQBKxKhEj8CSGwgHiX5f9oGdfegn9FWNYECTSyPswxKU0nkrUjMlNlTwh5PREpzIFDInxspIzHvre4/5uh9dfcyGZ25s1AoCyLHB5tcAnn/ZAIFxdb7HZdLHcfVkW+OjTc/yFy88l4avB6q7B3d0Or17eAwAWixrXTxb4+LNLPHm64CPnllxli8AMs6pKFIVD1/VsN5Dw6fu7Bn/iT32Aes5xB65AVGl0/B8+W+L8vMbV9Ry/939/hTevN9huWEXqe1a3HBG7K5c1zs5qnJ2nn85RtNnM5gUMyBQ1hOAJ6Hd9nM+sELBl2lO0GMa/pr2naPEwBQdgHMkYkUxOysnAPX5+PoiDj3wn7dEwBoWJUboLB4joIBK2EpiJtosTOR2XbmGa/uQknOTWDBBvAAK0ConVVV2MpuFsz6je2BbVECmmIvdb12sAovE03kZW1SAoc4jnTRame5JM0JJzKqq6iIFJTctSl12DPdqmS6nf244TxiSlu64LOY2rRFUVWJ7VuL7mytjPPjoHALmm4rL4iwpV5bBYshpyfllju+3gww5uI+HOgVWc1682cM7hw4+WuLjisy01bDq+syNUGpvhCM8+WqIsKR4tyOpNQFkWwghmOL+Y4eycT9jWMnquoCyRK60zy+vocjYqoq4EiX3Hqp5+uK4GEU7vrOEXY7kdLR0Zo8mxwlFaN+ji/we+8HgYAyBBMw7xvEM1viijYIjPiUy23LIFECP9DmAoC4KX2dW4/77jv9nfTmIjC1HaZMjEMUPwwjwicwmIimoWaEQc50AQ9YNSpaTea9RfMAPVCExAN7QmLTmXxqPGNY0KXCwqXD9ZxGCru9stvPcx32K9brBeNWi2PXzoREcPMXDq+ukixkjM5xwvcP2Uk7b4UB8Xk8bUwzFfVPjw2RIhsOHwDogekqbpcHuzQd97XD9diLt5jrkwlqIE15dAQm1l6fALf+IpPtm0kjzWyaHEHs6xm3M+LzFfpHgORUyayMYH37AO0XVS+1LVnVkR0YJy4Hg+BiUE4b1yBgzQHKChtCmuZbjJjoH5QZJYtvJxm+4l+oyNWH148Ou7UiceBWMIAVKrIKCUWbcTxLSXWLfaI47FMWQcQzvSn4bZjKVJuki9EvpNPKXJfIa4yfJHK1JIGZHCHITgNfKR0U+I9oRo8DS1HIOmM8tGLkuH2ZylNwAp6uLQNB3W653o7Py83a7FmzebSLydxIqUpUPXea4BcZbqQCwFpmdTSZH/oa65JkXbetzecK6F8sS+99jI+716ueYwZonkVCagyWdKmM4Rnj5bMtKReI+27eMBN1Xl4pECmQ3K7B8O+2bWrnYYTaOvKoeg76PrNKAgXSdraLbNGgSnJfyY4O1eOHZN9pn+L+dA8Y4sVV1/pXTLu2AOj4MxiPEpBKCqyxjTH5kBwC/tNN6fADfB1aXFJBsMpjUJc47SI7sRckmhNo0QIx1FugAmKUr6M+HJ8VlD7EdJRdCYghR9KaXlRMeIYeGUyt1HL4ixgSyWJR8uO9PIQCZsrgWxRbPrQM6hbXp8+fNbDjMWBuKIuJ5l02FWsypxflHj8nqOsnJ83oRx8VrmWhQOi7MK57saFxc1yrIAURfHHjzQNh3u73a4vdlFlaWuC1DNiMHD5I+AibeuHWiByLx8CJEZDtdTl0xJBSGga9N+sCpoJ0yDyKGM66TqR0hlBA1ziPvFrGFy99JJAXZpLzwU/of8JU/t9R1ChkfBGDi/P6QkJtqjww/a3nkzmkYYXW+llWFA9mbZtDGZS+INiIjjDByLT0s4UcKG8ZDiZvapTBqAGHCVqUqibli1QRmX4igSKVgUnFcxX3gslmUsLKPZmIuPk0oAACAASURBVJsVl7zf7ZhI5/NKMjRZbeqaHs19j7J02Gw4zDkE4OKiBqFMh/YO9qAeSjNfVji7mIn9gNUOJ7kYIfB5IZt1i82a1YNuUWKOMunXaSkk/DvNYxmjHHWNED1DahPS+0NgLwPnWsi8UgyQRt/6WKsihHTyd9+nxdI11uQtRm38nCHEt0cYpM/GAv5kQJv3dPymeMk0y3kX/OFRMAYiYLFkiVKWbNXXA2zJnCytrrwsTiGkxYv9IdfbMq4v1n2V2LbIqXPpnr4LQAGTD6FjdShlHDDPULVAVY9YXYmUuBnedhLyq3H+Q+iq91o9mBmXi5Z1lWxlqWqHE4nLLtB6VuLsvMZ61XLo8ZsNVvdNQiJgyL/eNHKyFuH+rsDqfofNpuVox+sZluc1ZkURB+aVkOX581mBp1Ihm/M3KoR5Gd9JmcN61WB1x+Hfy/MqMgatNq3Rnr1xLYagcyzhSeY63hfJaxR8Olw3GZgDIOdgdJ1HaPnapvASVCZFcuR7Db2/vJ5xWrwYkDVtHaQF8RW9jIlyj+o/+Cvsv0L63QOEjdciN6hm3Q56D+NHndQeBWMoCoez8yoSfQgEZ+C0Ekn0ViijjwxfIIJOVghRkth1UHenwn7nA1wR0OzYGNj5nOsrE0kHtvDJzzxOigxJS8TrgNRG0HUs+ssiRObCNRtC3OTW86GLTUV6HlR1GkgJzdhsGx+rPXVtj9ubHbbbLgZA3d9usbpvYq7BdtuhqjifoZWkLScGhF1JcpBvywa/ZdptASmBzBplLONWo7GqW0WR1LW25bHq4T72MGJ7yhUi29D5j8uX7XYlVv2sKB0qJFThQwD1QVLTCwAhrhtRkvqasarZr1ywd0xlce8RYkWqUdujM+RIgiZRZYCg3KG8p8E1kakmJmjveAseMNkeBWPgRKEiSrQwwebiwijHDkMvMPKNA+Sc16gPJFIoFAQXSEJuEW0aEboK0SPWM6CYmEQuMR8NgNIxKD/SQ196OCZ6QSQ2vl/fLdhDYZCksq56xheQVJJe8y86LdgqTE+MekXBaGI2L+P86vF6AJIaIIadvuNQ5bb18TyJ0To4RXLsQaoqSQgTA6H25X1AKdJXTxf3fYCrLCPIJd8+aRkJJ+ORSXgQ8Vi8EAx53Sacu6LSXp9rg8ucA9TVzZ/72K9W81IepAjwUMvXdppTHD45an//6tuw101s82/cHgVjiJLZqArWMGV55dRLWxuBnaQB75VrlfMniFrVBUp5nlUzLKxH4HMnutajA7KxMsxMAyBwpGLnyJz4hJgzMDyhCjASQJiXEjbR4J1I9V8fKyzNFyWqmpnPbM6ZiE3TY7PpsDqrsFm3XO+g9/Cdzwri6viB5CZm46iPxBNAcFDJrm7MVLGKE6w4Y1QDqEAU60twRShEqWznQNdvaEgmpHEN12/8twqUJE0R3d3MEDS4rYg2LEYH7KnhBxali3IHygyy2hdWQE2PJ3uH4fBPFO2Tezx+lzqZ2t96bdbHoUHuaY+CMRxviu2Rl+2Tz/bOUAIX+bXxe55mVqNT/kPvUoSeIgdCgPeElAtL0ZswPPkqxhlowhGSeqGb03pIAMOwIAxHpHKsKyEbW5lRWVEM5S71TEkA83mBruPxL7cdFosSm3WLqi7QNj4Wq+2lenWyn6TKTBwZmVyDagcgRT2U1gMELJc1xxtIoNVM4gY0H6QoKCZ3FVriPp5/MUxvPyQt83WNn0+sfRyiB7a7Dk3TsSoUJT9hs+HPOHOT8zjqWcGRroYJiAYRGcbeRsNv9+gVD6TT8eUUf+xLoHo4K8jbo2AMqutBobuRnMq5AdE+zS6IhGRWJBgdIiDBQUAOr7VSeCCxNQCmLPlvDpRJMQdK+DpOJfYYxVcofJdirxUJ3JdCqqacmT5zlAkoc+EG7tEkaZnQ5osyejnUPhEArtAUkNSMjm0JN2922G068VL0KTS5ZoleyLiLwuHphwssz2oszkrUVZHmVoyDWstRM0Q/+94lEAKqGddt4BL2lOo4Eqss9azAxWUdUU/f+7hGcS7IqGfWzqTrrXsi20Fqn0l7xQcgeLa//PifvcFXX9zh5vUGux3XfyhKduNqfsbF5QxX1wt87wdXWCxLroGh3gkElgeUIlqn0IPuxvEGH3xDYxk13I/Z5+aLMHz7A8zh4JiOtEfBGIABIx28xwg+wnDwwdFrCELQAhGdC+w/dwC6pN8zIeWKR6a7klZESgZRINVN5Mt4Rbias0p0vjbZSWQskbEYCG2eNWpGn1bmpvOgkZuT8NsR169wLN6Lgk/2DgFo5iUaUTPUkLhYloPAIZbupdR6TAfK2EEnYl8uOaIRSEZdfS0bjmwZMs9KOtMiqVYynwFxvuI5FJaqzFiyjEmj2lFgeBkCuIbEqw1evlhhdb/FruEIUACYzStcXi3RSOr6B8+WUoU7GVLTcqjEGoH1NCkDJDhiCuO3mGYK9r4wuGais3edev1oGMP+FsZ/Rc5gOHc0xOSIIuYhkEUesmmz7vOA1WhwIobP+4KpoH15PhQH8rvzyR8eCTuThlOvOGQa8QHxfbTxKVYGZQinJFA8dZq9MFo4Bqhqh1lXcum4wDYdPchG616C8nBhfb8hUwNYvShdOiwIMKdt9wG+TyHkGrTUNimISyMTy1KZb5rPhBrzdbO/6PsP1TKrkqkac3ZRY71u0DQdttsW63WDrvOYNz2IJCakKjjeoqtQhyJjSD5o1S5xHOscZzMSRnNkhzxiBpN/7PlsdMPgOe+YOfwxYAx5s4sVUUM0JqRNYoulqlQnSkQZPQ7a754FTVLOuCdhNq+0EBCrI/HzfYrnLwkFCEErKHlzIO1gc1nNIgbxhOQyVeL3hnigp19DkYU8Tw24QQysVTHI0UiqSxFtJYY5xeuUMu0Lp2m3U2dPmuIALi+xIh6uyyM7EQDHMfAoS17NrBiw7VsFNYTB2ujEbLwU8x2c40SwTz47x8XlDM8+PsfzL+/x4qs7PP/qDq++XknhHA7A6qWitRrCNYcmAPCdh3pIAaCghDzjOHMAurcNGdyxNuIRIjVGezaRwTduj4oxPOilJiaeCXaAzg30BwG+zyvlJEYj5B9pwITshuQkyhBtHLBypQSfGSkEFPIMzSIsQPAuJMJmxJv7xvdtKnuNYWwUSLoKCH16p8QAUyXsfMJC3OyZng9FNPmKjDZ0MJdQ+lIL4Gidy148IQTEMnQBoo5U7LFwVDLSse+qa6S/y7P0kcmonLhUZA7SSVE6XF3PJV274jL5s1LOSmVEN5tVUnC3zN2o0ifZx4D3QhQOo8Xiz6Ix2fDWoyhhoqepz2h4wQEm9LbtKGMgor8G4D8G8DyE8K/IZ08B/E0APwDwYwC/HkJ4Tbyr/lsA/xGANYD/PITwD08aiXJe1fXJfLhnhtJGkVRohOj6DCHAeTm9WgJtIN9HaZPe0QwiVZHWRKb4HdmsywSzrdQqSorIJR3xJgVKKk4TLuGiT9/C9KHE5nfkF7XEGwZzEvV5o6JEg6sQkpMP0v02MhMyN0liT018Foyl4wsJZgdAoju5BNt63aJrBDGI6tK1LHn1OZUwhqpyKMhlezwooVvjRMaZxxmqhHSPopmqKlLkrGSVLpYVLq7mcliQ42jRs5pL4hVpbTVxaipxKzIty8/JID1QTsR2m2WzrOgzf4aZ+agn0OA+AmV9vwu0AJyGGP5HAP8dgL9hPvtNAH8vhPBbRPSb8vdfBfAfAviT8u/PA/jv5efxZt448zYMvtNNnX4Ew8kTCgiBk2ecD6gI8CC0bYj6tZ5u5Ao3sRgCIYkJM0jMPAUARYqe46dylaCu06AYJiBXUITtXRsQWj5FWs/CVBeZfbHokcg2IGXMx6L7oUTTgjLW20FBYbXR4wNgSynHz2TnWdSgNpHJNTIbXcvQtU2P7baXkvA7c5AMZfMTo0XF+PjZ55e4uKzF5qGTy14AyPGatm4FmQxNZQkUv0sxCH0PbLetqAwcuEXO4eJihqcfLFnF0sNzHGFxVqU0c6RkOmY0usf0JDJE+w1RyjCNTe1Oul4Z1U6L+TDsZA8z0S8zFPcOkcNRxhBC+B0i+sHg418D8Bfl978O4O+DGcOvAfgbgdn4PyCiayL6NITwxbHnTHLKAV8ISIukv48WAxYa8xfeazVkH/VHFZdqMY9SNCO8HMKmRwVDTIgSJYbZqhQhwBZeiZ6SwkcbiEJXzdlwAIJLXghrlGPBEtKcJMQMZmYDBgCNvTB9mLnVwJ/4LgPYbD0L+TpZa70aFjnkudkxU9ht++ga7XufCDfOFdDJWRO+D3jzagPvAy4uA+bzUly+ADRqVNADrwdl70CwY0+BcDpGRW56kvd206HrPJZnNeaLUlACC4hKXK1xzoxeavdaNHyKGzPQhM5v5sjA4IjQ4qDNPhot1MSfe+nf9vMN29vaGD42xP4lgI/l9+8A+Im57qfy2cmMYWL/xi8phBjgJAjb5MhbLpGCjwK0HBoXFdHgo2R8pGxT7QNjlhD1XnX5FRKByN+l+yNkNpIMALo2oCxZLSkKyiA4HzDroO5RJVCF/vqaI7sT6dFucp9HKiojsQ0aiAVDpN4Lc5iCswEjpmBRio6n6zyaHRd31bwN/afM2Dk5KbzQQSQDbNd7vHq5QbPrOW7kaobFskJdjKG1laj2XUBmnjzgKV4gRM+wo2l6bDctvDCmdFYFYoJaXEfdYxigOCTpz6oaqxx6kDDiWmfShFEn2ZRtTcqirO997WFqwjfjEt/Y+BhCCDQ8q+yERkQ/BPBDAPje9z5H2m0hbn4g3wiZK1I2RMYo5Bu10oMC4KXkuQQXwSmxcbhy33kQFVHKJn09J8r4TDOutMApPoKz8VJQktaEVE6fkEnaIFriXfvVEvTZPMv/MmlIyjxsZufgs5hU5OGgalC+afazw/F3SoQkExYC51e0rSAEYQw7cwKXHuhjT6lCnOdUI7KXwCMnDKQsKJa1Ux2Jsp1gXcoUEZmW0qcumP3Dql2zY+YFaHEgKRBUWvtRfh+HzlNEj9lu1z1DyTydhMihmc1W9uhaKIPeA0reeXtbxvCVqghE9CmA5/L5zwB8z1z3Xfls1EIIPwLwIwD41V/9s4kbDCBs0udS5KFu7sLaB3S3CYoIwu5FK4w6arRwh+RajDYB89zeEHXsXp+PPNafIxQNuA4hRjzyIS8+GjF1I3cdJONQyq1LaXdr+IwqkeP+0+ZDzM60dgDN8dDNpZ+rMS6eeA2hMxXepCVxdf7TXNvojpSNqH2wHUZL3HcdJ3Q1TR8JkI+d4zVwzmEm0ZK6Fpqz0XV8QtbdjYuxBxqVSfK+hUh1BEl2ioSra8Bj1xO/kmuaGVMvdobdtgNA6JoeXV2gbftYC1PnNIn5gEDJo8PMIRFz/C3ycmUiikYT2rDoK0z8QrI5SGghQ2vxfye0MLj4LZiJO37JZPu7AH5Dfv8NAH/HfP6fEbd/C8DNKfaF2OILWKaQpIr9lzMPncTky08JP4YhUOT/UaLafIj4dEEtikbTRqZswVRSkSIdw+tDCKzzFylGIEoiSqXgd7seu53PUn1tnQh7ynbiTWmTJvSAqJLovcoUrCqiDETTtgfDlrFH4AbLsHVt+N1J9320M/RdYhAqtZlJevmujx4LNQTGk6d6tk+sV3x83vqeC7x0JunLGwQEw1yU6bUtR3Vy/z6eEq5cMjIQMX52wtB6qREZg97i4lJkOPqucT8YUaDMFHZfqP1K+hgmYo22vhU8abMeaROLN9HiHnlAO8Vd+T+DDY0fEtFPAfzXAH4LwN8ior8C4A8B/Lpc/ttgV+U/Bbsr/4tTBtH3XioYOzmgNMFdR4RQAKSWabmHI+cgakMiUNW1ZfRCWFwoNJjyzAGaRi2l2rwyEV6YogDUOKkbSWGzbp9YI0JgLITxaCWgepaYSdd7Iz0JPTz6HlIkxCN4z+cjZJvHqgX6RvzOIaIhccki5R/YvaL3qbvSI3kDyBGC9xEFWW2O7zHwAsxUtIAVZXPlokTuJFXbOcJ8XqIsXITsdkzeBwSR6loc14MLu9zdEojW2O16uIKicbDrENe6niUjYd8xU7m/b2Oos6acq/qiXqPlWYUQ+OBf9SZ1rUdXMZMqjNeJRNrHXB4d/JQkp4Rc4ncuGbcTiqNkv4igInmTDPDkUgCKHuSzSVVCXdqAIELLpN5O9zjFK/GX93z1lyauDQD+y4cOou8D7u9azOeFuPL0G+KgF6biNDtIGzZKS10wIpAWHdJeKCUfxTqL6QnYybkDGqkYE6/MBtE7nLNQ3SyA9XMHTlO2Vm1HnAXZ91zfshM1Q++PJ05JpKSjVDkqJUsZaRSDgSxKyTeCRmqqtANxvcXgkrtNCSbOeCR2ivkCNmEMgZmLE4SmdpLCEcpCDuANXIwlIjqkcamxNZ27ycdxKcortGK3MNKu9ZzrQmaAyEOvu5aRV/AheXuKVPWrbdgwutl08QRwDQUnpKI6rRh/NfZlqD7a2bZ7S5FoZKCBma8DJ6fphUr8quIp2hnGSMS19MkFbz/XcneZzSmSRO5FirEOD2yPIvLR9wG7TcebS5J30sQn9xtvTOO7BbIV04CYeLyXkbQghvORYJEWVY2DvRjJqMBEhaWkfuRIAsm4ZkrDRf1Zh+iAIjIXYsLSdzIbCqBYEKYQg6ZGDUaJYVAMAImzSM+GIeS+l1DwUgRLSMfe6aGycZwu5RZUUsClMHPsVDIaqAxIIdd5gUVbxvdjdOTiXHfi0VebgRpnySGmPus7FyWf89mJqqUuRHIEJ6SgSWTqzem6dBaok2pS8YR0JEZCwqBjtSnHbD5Xn/hdY7q5oSsVCokQdfuNYmPjmnZdQgh6n1agcqbAsc0ROdbiOPZ8aRlZOLVT0x4FYwA4JTkW8tAIQCUCuUoZhOHXeS/ycYxVkA8tI3CFE26biEFLncXCHoYZWcu56u8qUfW0qhhWbLPxJDgnQxXCcOZUyQlKUilJGRIoEkhKbALIFI7R95CRst5t3rE3RkiVqM4ld2rfeey2nQlC2nLQFwhlyUzh+skcs1kR05NjGrkeEGOnPQDzRRlTt8vSge7aSPw8F1ohK+WwFLJOXNAmxJRv/anVmrfrLkr2OBYHDh4y/wiIae82y5OQxl7VRbSvaEFYawhVVMnjSGpI1mgYgJYbONVNriig77kiVtcyI3am4G1alwKA2mUMQ1KULFwgMhXd+ZE2LEqk7C9M/n68PQ7GIIujcCv7Sr7PlOwj7ziMYY/SNUDStA08i9DMIgNFCip5Tcl3ORQn2iMgkF360tBfgOJPjZoMYn+oa4obPEAJxJnaCHKIyiDpyBpJHSUmEI2NQaoRBWT3+RD4NGrRxTneIEUndi1Xhy4KrpngPVdjqio955IPeVlKVKCWt1OiUBWgqgvUXcC8CxGSN6WLLkitBA6xuxCxnaMInMJdyrWq5ytz6DtFBABpfTyzhs4RqHSpxL+gQ63nqGPzHlKDktGFSu2i4CItVVXEsUZEQOlZSoz5Xsv3nTIkFSS7bYe7Wz54uGl6lGJH03FXVREL0BbKDGRfFYrK9gh8q77oXqbRFUG/elB7FIzBOUJdO5QlRR3fmIf5/wK71HgX4ubfwyt0kYgnxxHQqcIWcp09PkkJ2ax2VB90E8ZiLCkJBwESJ5HuHZ8zoTYJsSE4o3p4yPkQRXZs/W7Xoe9CqngkujcAMcYlFyGrBp6DiOT4OrZVMHHdvtlhdd/K2ZCMVvo+oJGQZUUk6xXXL6gqPu2pnvExdctlhafPFmxQFLeeJkuVpYOXMQPAfFGgnjnM2iJGQ/IReXwEnpdsS/Vc6Prq2DXBSU/BiiqbqG0eyI4a0PWPodvSn5ZxYwLkPmezInkfVHVzjJZqMXICqrYm9KhS3tq/0t855WqU7WbNiOzlizVub3bYrBpWpXQdidfx81+4xpOnC1xezTCrXNav7iFlwhR5gUFuFF/l/+Pu3UJu27b0oK/1Mca8/be19rVOJadSgSTi5cGKooIvAZ8UIfgS9MEkGiwfIiLkwZgXhRDIg0YCQqAkogXeAgoGCYgKIoJRYggYE9Rgqqhzap+z99prrf86b2P05kO79NbHGPO/7FMl/7bDWv+cY47RR7+29rVLby20zNbvnIDzdHkVhKHrEt58slK5HGI90I5W5xJ0E4JM3lXdQ9jIZh6qnoFCLD33YMW4ydDLcWg370HhsRKppi1Ks8rlWetuuxgrsHA0t5TAzgYA+92Ar/7uLW5v9pI6bj+4HuDicuXh80XLfsD24YBhyPj8ywtszhY+AOb7f1C349QQzs4W+IXffeWh+AGJu7jf9fjpV/e4vdlht+2Lf4ZyT4PCtqCvPw4AhOu2bcJyISHbPvtwhk8+XePyzRKb807e0cIJVGZBU13bKCIYBMqrN6dF0DKlYFzsJoq4LsG4fWtnWsiJBxE0mEpBBQwzOYZJ10XQdYJ6KuSV7WBXET8MKQjBQziiXhN5qaOIb5FIAcB+1+M3fu0G3767x/tvt7j+uMP93R73d3tRlg6SyVvWTuNzKWc2lsVHJecKwdTu7jXqrZjZ6a327PIqCIMsgKQUX4gCAxpOSx1MUJQoRb4iZM7VOnCRLMBpC8jq4xgWpNEaERvYk5oSIlGKsCJ8C7qFueKmLgKOR4Hz1x93+I1f+4jrjztsH46e0wAAzi92ShiA/jhguz1i+3DEkDPyAGzOFwJXUWzx1q9lkgjNC83t2LRJPRLVVXl79PDtzAibL7nHYMGiesK0BzgLh+97ySi9WDTolpIQ1xbr8agiTR8dncQn4XjUaFG6AdebDm1nJx5NpBInr2gmtPksvgoFOhNQiQrVWgLKWQq75qJBgomHTABlqWwS7BUEi8pCYR2ZoGvWHuYQfSqLd2nfZ9zdHPDTn9zim5/e4eOHrQSI2ZdYm2K+HWBRwLN6X/a9Jl5ylAB3SqvMoFT0X7HwDEWg+aX5ZHkVhEF8EkrIbjMdOPHXz8V2jrAxppOm2eeL/J8LMUB4ZjCPyiCXmhXQZF2RIhimVZa2hMUa0YmRJSVsUVF3PAz48H6Lr350i//7//zGTx1avkoA2D4cNVqULha1/1MivH9/jxtNWAsIOpCck5IS/vxigcurpRxAUqVV32c8PBxxd3fEYT8AYNcRNArT5fCThXtT7rxswKwxGVW5dzwO2D70uL87YLVucX4uCWYB8e0wj8eHuwNubva4u9nj23cP7r/QtkKw3rxd4/xigc1Zh/W6RbNulaAlR3smG1QAfWaBmyKaGbUSMp14QCsisBKP6U5yEUN1NTbPrJ6W4ydsk/a9xJd8uDvi/bcP+NGvf8Q3X9/i5maH43EAWOI+ABYbQwLurlcLLFedRNaG5uOAii6mzObSVycQFK/PFaNoM/LFM8qrIAwAivxE0SIQKCNDOWV9jzyMguBtI4efjKsW7l+WXHmvM8tqDCnBA6EA7PEN5hVC4QIXYjIMjPu7A7756T2++vENvv3mvtowQMn1YF6ERaxhtE2D7cMeTduAILkqzy+WWCxbbM46nJ8LcVgsW38fkcQ+sNOOx17EA4sCbYliJaM0FYsLyH0QwISgy3Tz4V6zUfd9RsoknorqsXh7s8fHDzvcXO/w7pt7sCr6JPdEh6HP2D4ccH6xxMXlAjkvRbRYNXWUqlTiYhhKnIiHTuRjngiDjVP9fCEyqpSj8qMrDq2zo7ktImmYbYIH+t3tetzdHvDx/Q7vvr7Hu2/u8fHjFtuHA3LOaFLCctm5MxgALJcNzi9XOL9YuO4mkZlcSRXWXLXBLG5zBKpu78is/0L54lUQBlMgusIuwNl4mKmCllrkVkJgNPXk6oqw+uV9o+PGVWOEyFpa9aY1sxEDOUDL8B/Xq85XkVgzBMp//LDDVz++wdc/vdM22D2CCrbbA3bbA4ZhUGWguAKDGW3XYLnosFotsDlbYrXu8OlnG1y+WWGz6dC2DThLvIeHdNRNn/xY86CnCE0WtnR23aJBVv1ICSlP5dBXIk8CK16AopPo1ZX5qO7G336zxYdvH/Dh/VZ0Jw+ihb+73emGA5qmwWIpafKurxM2mwWurlbYfzaIyXhRAqSI4lFGsz9mn/OomI56JZMHTdSw9YQKXeocUVgzjgBl0m2Ngcqx95h/Y447m/PU3e0BHz/s8O27e7z7+h53tzsd8+R6FVEImwgl0ak/+XQjKOpygeWq8Zykfow/MDC3OqH0y1ddELlMBIli0EvLqyAMRCVHpMDXwsEplY1sC8D3PZHKpkW0MPNdEUP0HxWlFxA859THvyg75bnjUdyXF0hITQnRHImS0xVtkCw4riiUhW5//26L22tRPn35gyscDj36o9i3d/sjDofeOV7btuonIRmePv/8Emdnkkvy7GyBs/MlPv38DAQ5iPVwf/TjzctVi9Vagp8CwH5fzg1YghhxPRcXZiMUq02nuSAydg9HTzgDQDkYKlPq4ZDBNwdsH3r8X3/rG3z77h7393scD0OB3izEpT8OuLnZAZCxvrhaYbGoc1wKgSU35RnS8/iLqT4E5m7FYQ1FV3irxOrxSsn+yaEszsUXRF1oAgIp75kT1u3dqRGLxmbT4XCxxNBn/PB3vQ3h80WXst4s3GIk+UU7XF6t8PmXZ5I0qDPfiZLYOPbPCJxLE4qwKmWkfjGPS/d/+b4ihv6YJWoOT38zRx2zRlRKqhH0D7uyfIVt+MLaC8W14B8mfcpLawpd6rOzHN44FDGuvJIEypJGAVIO3LaNxBxcdUiJcEgJRL0szM3SFWBtZ/kZWqzWHT777ALrswXW6w6rVYvFSs5UmEnTTjG6M415ATay0fsho+8H5Nw453QCOUQuVEOxyhGnkYxTm7MOq3Wnzl2yqawNh32PftAzL7AAODqWuXg+rtcdzs+XOL8Q68Zy2ficWl5LW/DFahAmM66RiNYCOvTbfGOj2mkxFHwJ+CP6I9OrcA51Bu3rEQAAIABJREFUx5dafWwIrHGFcFLP0eWqcYclW2sWYq7T3BvLlRATS3AsBBV+3sH8XCpUHJCpk8GAZsoSNyW1EpQXUoZXQRhyZtzfCwRebzp1oCnehn2f0R+EcLStnNNvmhQ4U3BpZa6oLFA2fOURCThUs4Vo1wYU8cVPN+oMNw5lrF5dWL5Y9Ddb6GqbXywarDYdjpqqPfmCT1gsJBP01Zs1uk78Bixzk6GGri0OOETkMRCOh4zDbtC8CFn8KRjuWtwfM4ajZKDqjwOyKgxTEtQg5xEG9H4qcQBDHK7MZ8PC0b15u8LF1RJn5wusN6rPyNnFAFGaSqhUOVimFop+UMtDg4uLFa7erPHmkzXefLLC1dVSExoXOT8SqNTIGQwyxOAMvGx/xXKFqQR5j6GwOng6+nQqkTcPertu/YiiBcL0mnqCCO5tKflBG5ydteg/XeHLH5z5A9lE4szFXTtk+mo78rU8aM4KGQ/d2KY/o0IOarGCPEmwIzAOIzMSO55TXgVhAMRV1w/BNMUcZya3w35AM1DYqDJgfszYI/HUEIJA4u3oRKMMvCyKEukp6jM4syRIzbUqM2eJ8+deZwHO+kLisljNN3+1bnFxsQQYHigEUGqfJUjsZiPc2BSJSSczs6XC0++DnXMQRaAdNRazpvRPnJPEpNi00g7zU+j7jJQkmpU4PElAlb4fXCma1FuwU2/E1arF5dUSF1dLydS0aJSrdvjk041o3gl4uDsIOlEX9+OxBxjqJLXEm7drXL0VZ56Ly6XGWGzU2lJKcXwquoUhyG3JoTKm+V9GczIpEVnYxguMRY54w9ejoQsOj5vewa1ZCutjjo1KbNVj7u6noQwmiivjphaEUNbrGBBXIrD2BzkShTlU/XR5FYRBlFNiOrv+uNfFnHywzbU0NYT+IFzQ3GctDVt/zKAErFatZ0YSLs5uBguOcQVNMFSwFJ8Im0DzsUqJC0UG/OzBVAscyYfJfnKt7UTR9OaTNdo24frjDodG2t8exfEmJcLl1QqbMzE9Wgq1wyGj30kgETllScXicOg9SlKvCsucGelI4n7bCWyXI9AdABE16EHMl8ysZlMuGyI4IXVd0nDrElX5/EKQwlJjMjLLhvjhL15hc9Zhc9bh3df3eP/tPQ4PR0cpi0WLy8s13nyywSefn+HNG9XEb9oq76aLezlsGIPJo/G2cyR2BkOIckSOcKpQmIVDyEqJnVCg9jBYFK7xycbRtg0owuc/1OkblQNxS41vdleUIgoFVld4hQHU0YIzMbi8k1x9YpHFrdWnEmc9Vl4JYZDDJJkZ/c7Cqg+gJASDWRc0EfomY8gNuo6xpDKJw5BBmTxMFzAmrOVbGUD4InGYqQKnnXr0zWIQNBxmiiXKeL5A9XvbJqzXLfjtyuMIbLcSlPSwl41JiXB2scTFxQLnl6Jv2D4cAUi4NHEFFqGXGerxKGjB8jZIcBhTUIlMuzkT2/n93UqCoOpx5gMG8CDiiJvqCHpuoMVi2YhOY926bmGteRnETRmAytSffbEpbtIDY7s94rDvcTjIwu0WDS4uV3j7diM5Hi4WWK07dG3jyLA4GEUOR+WEaA0ocDgMzuVd8ajc3UVKDtKdo41CHIrooehR15EHbWGAqzSFtl7DQgp1FuczuYkMORKpziUu+rIO/X8q6yfeVO3pirnN7/YxqPgu5VUQhpQkh6Kkc2/wcHfE9ce9BO1Uc1F0kV0sG9e+L1dyOq07NM55ej0zQACQivhh3NCUgkCZ5JQISQ83EQF5VwJ5MAONBsLIDJCeRozu1ykFGGoOVYo6mpZwdiFIAAD2P3+Om2ux+d/eSIj1nIHPv9jg8mqJs4uFEoYeD/dHEBVzYtY4ldttj+32iF6dZwTOJvFruFzgs8/P8PaTFa7erNAuxOX8+sMON9d73NzssXvoMVCJsei6kFWLt29XWBlRWDVYrkXfsVg1IS6iLMDUEK7eLLFcCfG4uBQdxLtv7vHumzsQCBeXS/zgd17hs8/O8OXPnWG5Et2JjRmYQOH8iLUnZ1biqb4QC1Fq9seMn/zmHY5HyfYlYpogECAQbxYrRh7KXJvMToPpKuDoZ8iM437Q4+AqvgwSyDaFXW3iQNQ/GIFyHYg5vFDh2BUhUqZeSUCGdF7C3k26qETeUkVBNC+DDK+CMADQs/aSxp1ZONnQD7i5OeC4HzTxqsZFhFDLw2FwnUTbEnI4xARmnzwiIxKAcVzDebY4gEJ8FiinKUUBmZGyuF0WYiGa+tTAU5mZvMuq0a7CshEDKlsuVy0uSXNJrhpZ/IdBoXrnwWpYrQib8wUOOzkTIboA0TMUFlZQ1+WbFd68XfmZhvWmdXfztktYrkUUeLg/atbrwY//iqZcj12vxKTWdUlt61RQU4TXmXzTnl1IJuvlqsFnn2/w05+sARDW6w5vP12rTqFkgUp24AVxAZf6Telp+iNKJCdED+KFedgPOu/sKeyN6JPeH+sUqVHazKZBhBAOO15v6zC6ucsaMLNtOccxy7DJnolKg7HcCWfrY8dEF0HsvnD7SRgQxBZTNNTuTS/VMLwmwqD/NY0s0M2mw/Ew4O72oPIzo21FeUgQrf5BDw91aAonMJ8Hk98ClTaYHTW21fsB1290XcJAXAVSsd8tPHlOGjacAzfStT43h9ZHgeKty/H7tSgR12edcFO1uLQdsGRgs+nkSK6uxGHIntnKfDPMevHm7QpXb0TTv1w1HkPBRJimMdNjJx6MNoZ60Gi5bHF+0Wmuy1QdVgIiRC/eoHaScanvWCwbnJ+LuMCQcxHrjZhal8vWx9G4sm1iCpsqOvJY5C1DSrfX4nLd92IREbPsIEpamg6+TLlaj4JMQMokBojoMJiuI2z8KD5EK43L+Cc2XUQHALv3bOmjfp5RAsyJAnPiqxNT/w8+J9O7XlZeDWGIG7ZpCKt1i+NRcgraQSAigHrCAaIB3+9E78DZAmyoRYPLMd0MkU/NrMRZrs0tHgAuC4oJrgRMLUolUWHbookRkK1EAlGuFdzIgJ84bNpOoh8dWj/8ZPcZvF9vWlj8BwAaL6HFYil+HY2aQ9ebDm/eriRugqZ+6/usilC4jb1pEtZnXcnMRHU8hMUiedCUuGFz4IIcFntUHpr+oW0TOtXQm4NPo6bmwRBAGCtREBakZSjB0FA/SNCWm+s93n3zgOtrUVKvGViuGvRHjcRN5Uh15LyOS7jUCTL91DTobtLGkR6mklOeSQ+flTvH3H1SwniV2stPZXNPfx8zJO1WuVxRhimzm77l+eX1EIaAqwyaigefRDvabfuyCHugJ1GiWWwDQipn5hMBwePLgr1SsrDytQLRxzczLDxP42JIKnZon5US5TmTOSXBOTqRVJMTVfVHG7QQoBLboW1yMWPZ/cotV6sm2L6T9lne57oB1btszjsslYsyStg02wxNI31qFCUMPfvxahOJUlPq9wXp/5W2jYs4+AApNWhbdtNdVNZxBoY8lHD6+hypZcgWt4sT+rAdCLu92eP2eo/DoUfXhqPUc2vKLjrXH20SXRtGGKj+KbTNjoNHBhED8MyMxXjXzpUgUvhgzBCIONQTouBVnWhI9aLnl1dDGFzm90kUSHp5uUQeGNcfd26+tOCdlknIQ4szg7P62SeSYJq6qcWyk4ti0BceyjFdBsopKfKFjgwMpqXWCE6WrIZVl8Eo5/Ldtm2a9JEcmblMpDtJJaqnzjibQvNOZejVqsXZQUyHpj8x4tJ0EokotclhsiGXpA5HBsmNK1ucx6YtLuMxjoRrxQ2m+8YI0xa7WXYUiFHFTADkOHk15YauKqJDoEZl+iQm6UFdv+/vDjgcBjRJ9E2Se7KIVK6Mg1oFeGZb6H0Skas+gGWqBVFUG/EuRL+uhk5vyFM7eHQ58JpR4Ymm4HR1M22Y0KVHCNRMeWWEoR6kphFl2Xm/wNXblS52dvOe+fwb10xq2hwG49rkobKY5cCL6wNSHZwDqBVfZp0AkSohs8u4TUquJDIYbAqqEgwkELkg/9Xw0e7jahNPOIQiCePyvGlxiaW3uYLNWucwAIkFAbGe7ry7O+D2eo/rDzvc38sG48w4O1/gyx9c4NPPN3jzdoXVugmVwfU6NpaxzOUgM0RkBMLyZ1x/2OE3f3QrilFNQ0dNjFhUR0AGyPNNbPWg0vZBzpSs1mJStdiYoggWfYjntKjOYthcid8CEjtRMrpkc+pibemEIwpXZlONMKoxeQlzjvfOILLnVDW75SOBfkFzrLwewmBl1ItExR5v8qcdK2496k+h7BJeDdUkOiszYkHF5FROXEa5l5yr6Ng6EUnhN/Prd/k/EG7PkB2UdEUhVTppRMFMqfXqgFMTq8OUch7enstC9n6w/DXAMvSM6497fHy/xYf3W7x/94C72726UQ84O19K8pec0S0SFsuVK9e8ReRSVrw6Xdg2DkbouIh04OJqLG0tImQlEnif6zR/5ZWqRFUlcWth/8PwkiFBJbxTjk+lbaFIBiu9Y4DH+DQRTrJhoVARqj7OllPi2PzNKAM+KnPv8OpGS2eMUl9aXg9hGMtMurCapmi5jxrX0DaHy8Vh03JCpUiSymQxdW0TAobahFGlPLMHZDGTm5OahoBF45NbIYIKA+iRbt3N4/P0sg8Kt2GOKKPmXvaohbvzzFRcm818CI3jWQAazXR9OA748O0W33x9j/fv7nGtcQKGzBop6oDDQQLHnJ0tcHG5RCuR4ULr4wG3mdU9gTk1+lpvWlBagxmefo5I2kqpBLF12jmqMMaDtBRzTZPEn2XVFjM2lGA3hERy7kV8EWKkJtJxZQ1tp3OVWRPrcplnHdeVHoxKugbG8D8SJYBOEwpfKhwuxPU3RWWY3Dn9pYovMXnZy8srIQzKgkfdNhNRh4TNuSghzckHQDlUpSY5gU3sLrAxGpC9hnXGXX4Or3ZYTiKfGm+0XZwSYdGJwiuHDV3u4WrCx8quorxEuBZFGFsgvswgRCqGSkclOriS0Css9Vj7LFDM3c1e4fgB+71sLvGLyOiPjMWixedfnOHLH5wjrZoCQxVx8QlOdmrFso8zqVs2iUjocHzS5PpZFspkYqHoQYqlxERId9Iaz3mCzKPqD3yutS+ma2Eu2dDev9uKVyUK0klNwtXbFQDx0+goKXqqN3FFpMfjA4zErkA8nil7PAo2qGZPTz/weHklhCFQWtu4+t0W0WbTSii2XMvk1aEU6How/YCukKx1cobnMkxOVNSCQAhmq5A8NrTDFnhKhBZxM5dMy9XhH4UlRL42PTmNXSv+/fI36jzkHqdmIAgXHG+kiD4MUcDGRn80AiCwOqFtGzlhSVA5vsfN9Rbf/PQev/v39Oi65Fp4S+Dj6c9KtwHETRB2ergNWYPtMqrcFDHGho2vPcTMYCoEkJJEjU4WT4LIiYC93ywHRuDjAEXCmQENysqeEep4zPj4YYdf/38+YPtwFMKk871ctQCrjiEBKbVIqUGU/MjGZpbaFQJblswoQc2YNoTmR6ZRV1R1sZqFsYj00vJqCMNsP3TSRdHYoDUtsy6cSKGjC3Ik5j6oChUNcTRs5+5TlTRXYCtGZsOiLbBIRiDlRqZDsMAapJyBgskvFTEh22KiUp/LxCpLZ6Bc4+A/YBwxbLxqDF2eL+2yblgSW3PYqmJaMNAPA7YPEq9wuz1ic9YiuQlY6wsimg1rIcCoWKIAKKruZQ6h8GHnXIyYTrmmW47UM3O5bLBatjiuhnB2Ba6DMEbhooDMZo0KdZxKHg7RWd3fHvD+mwf85Ktbib1J0HwULTabDm8/2eBsP0gC3MnYMzyUWhBLfQmNuzdGWHOAwfjB3MY4dc0ZhCHGMD/PAyVeXglhiBBcS2DZgfn7ZALiBk1k5ku42ZJ0B2Yd2SjOWcgsi3yc1bWW1HOvWyQkkhwX0QPOW8pRh6GEKpdQYybfOpoxdAA5qWkL0cSKpiU0ipQsCpPrPKJ+Ig5L5KxqSpW2yThWeotUCE/fS7j547FXU6uOp9672x7x4x99xLffPGClZx9Mpnazr44Bm1gDdsRmHNsRlt5cWQVUFHD9iSI5UNUtuZ+FcKUFYZNaJFppnosWu13vx+Uti5kzDXsZFyU1oHvWRER918P9Ee++vsdPvrrFb/7GNX7y1TUyM7q2wWrV4eyckFddJf6k0NYUIoxJlGwhUl1nIm5ZL4ZCvC6MSiBeGKOeaiFMr3s8IUNqETClOv7lc8orIQwzxaC3LfBgkRCvOEszL+HWPaQbGwScDp6dJ2haFLjK0FDoJRFM2dRFbuSZCZGDKVyQDVHId2ibJDzmi4vhzjzaz0RydmJ8PwDVrUg6+T4446QmIVFxYNJOCkGxjaeiRbeQXA9HJQ7DkNG2jZ8NSEmjMe2OuLvdY7vtsVKPS1eaKiLLgya5GSwFnrQlJgWOiEeb5RagCL/jvZGI8qDoyzcgoVs2WLNsPBNJzLmrcwJW6obqHWpirvOUJEbmzfUOX/3mDX7y4xt8eH+P/e4Ia8Ri0fqhPdvklSBPpT4YUuTiXp2ybEhDJyIq2ljYAIwQbiQOca3VS2J6geu/ftRjhCKeW14NYZhFVlz+FAuAXRMZkTTvwfGYPULOmDbawJvMH19qcLu2VOhz+qVwsrDSvV5yzEYjokA2yYV+FNRiq4BKXRNua/1mgChjoATmwunF+lGgfmyTwWdWrrtatSXgqnP8ksNAjj9LEJfbG0mOcnm1KIQRxS9g0PG2MHKAcOW+a+psYtZvErdtIBAH31Tj8deHknF8cmLf6PmQ1ZpdP2LnWrquJLEB4IFW7P0VGtH37DWy8/XHHW5u9tjvxbu20TlK6h9h/jKRy/uI+7V6/eSBkRtGiidtVWlMTdGlFbGyrBMbnkeljfENoxudTuR6TT+3vArC4LJU6BTZdQSlnLumWhDXkqLNUphvzmxTxh0OlxkpbBpwWUAc21Ja5tzDOUIlOGoxtmTPk2rUQ4nzaB6VcaFVJtPwClv8qSE0mTWRTPb4FLGp0paayDHrse+zBc4vlri9XUomauW8A+eAZIQ43F7vcHu9x2dfnFVyKqP4XPR9xnGvafQy6+G3Aa0mkgn0UnNiAuiSHmHGyVXvHqEBrcml4kZu8SYpkWdItxR0RrgGjXIFQEOnqU7H51mOdG+3Rwlnx0JsLMS75O1sS9aswPU5LBa3brERdwLlEPre+koQfUcqk5v1gKzotODer6f2/KREVGCMR8W0Ov3fcyqry6sgDJNiXDbqBwCMXXItek9mi+cowxotFFYICJy8/O7BNAJ68GawbgeiGQ8/44g6+C5PeBdOFrJFYoufi8zr3N5FqRLgQywiIkK5488ISdnnOspU8ojEd7d77LYHj4Jt7YGNDxEeHg64u5M4EUOfNc7ktB/mgHQ8DBhSRs4N2j57+HNAFnvXWQIf9kNskShSHHeuXuCw3NPda/zKnEVfAVVmZgY690DlejzInZedWg5Z4ow+3B012U6GHOATi43k3pC4EW1rf8vBstBEXxsmImQiF3mFGHiQsBHBK0pTX2NPbWJdO3NzURjqyJv2GdWOy+sgDCMuWf6aLwAqSm3y6mrVYrVSaHvIrvX2wr6/RNOf2cN4xbh+VudYdKjq8bmcbvmKy9vERc5Sdcz6ksFDuT/K4NVzSnyKSFE45kEjQ0d5kzMja4xLouSOPW8/ldgIKw0y+/7be+x2Et3Z4jMSAV3XYvtwxPWHHT58u9Vj2AuB6hDuJqHzWofxDw+9Rz3qj6wHswhdm9CG7GE2zw6jyZR5RSEZw/p7jMqjRKJ+uD9i+9B7AB8LrLpat7i4WuLnfv5MU/wRgORrx9ALq4TSD4IWvv7JHd59c4/tw0GiaR8GdAvp13LdYXMucSnffLLCZ5+vNfJUq0fRda4yVwFXGolJr+MAABld05Tcp2ENxHUvvCAwwvEyM3EjrAv/HpFMiJ2ZEnw/nIr2dKq8CsJQwacxgbDNCrisCeO2yv2bBh470CwO9pBzcsC16WPyGfZVTdFRw8YJSYgzTbHxMzfW+7foBgwmz4kFj2DK1EiGcIuinbMSwEDsSoBV+b457/DpFxsNI7fAt+8e8NWPrt2/wcZXuC5cROs1W5XD3iZh2cgJ2OWywWLVSng5zV05aIJb6YMd8rI8lWOCGUQq8ul2q9FuK0fD9/see4+GzZ6cF5Bj1zkzPv1sjaTcetB2MMwqYWOimcR3vY5bOVgHkjB061WHs80C55r+7+xsgeW66GjmdEC1rog0SnYISafcyZWLgdjb93FIJx+TuXUV1lO0QpUxDe17tmxSypOEgYj+AwD/NICvmfkf0Gv/FoB/CcA3etufYua/or/9GwD+GIABwL/KzP/NcxszpoizxeQ1qheUUfDB7eK22cKsMav/vPUNxSGmrj6qFiq0wqG6upnzDRaKPpqZigqWCidgZHYyCxds2gRKSrD66IshJaWyuFKTsFqVPAiS4KTF/e0e9/cHz1NJibDZSMo0SwlfzICyeBMBUPk+JRYoP5QI1GZ2TYnQdEnjThR35PEijpDXvvcD43DI2D4ccTjIRrZIV30v14+9+BVYXordtpdIWkrkzDvV4j8w4L4sx2NGIrjYsFiIZWq1lEjdJSeohNpbqmVCTvjOQPm4pshOs0bnNcssFcYzHvJiwKxVVs8cUZgVIiaEdrpkZtjao+U5iOE/BPDvAfjV0fV/l5n/7bpB9PcB+GcB/P0Afh7Af0dEv4+ZBzy3RG45/Qh3swUAnfwob3OcISPCYeXZx4IMascdH0SfGS7XR3u7niWe+VThxKqUyat7Z22Ue0YzHOoxrX8C0LUJhIzDPvsBM9Oi24a0RdioeW+1brFet9jvjri+lszbpk/47ItzvP10g835Al3XVGZGZs19kMuSFd8NjcPQJWAlzRTNvulGEjzGY+yxiRUgY56u3DzsJWP2btdjvx2w2/eePfvh4ejZvPZ7iT9xf3fww1VkXpCDiJqNHrLKXHRSi2WL9WbhEbH6w4DVpivJgi+WOL+UWJ2WFCYyo2rWAhA19+2sZ1VyZtDAVX89ErWiMIoWKv9L0/1gjNHHT8Rt9usB0Tg6wYvLk4SBmf9HIvrFZ9b3BwH8Z8y8B/B3iejvAPhHAPzPz3r6RAcqJj2akKgpNjGhMk1xuTurgFsIQ9lAQFm0mYGGgahxfNHY8vgDFUE3lPG+H0/grO15vHhMyZdFASe6AgJI4H+rUN4sJ01LAMTu33UNHh6OuLhe4eH+4CLDZ1+c4/Jyic1ZJw5f5sJsCoI4IVTgMwC0SDWiiwvaFilVjwMozkfur6JZuB/uj2492D4cxQoySNCW/ihixXrT+fHs/W4AL+FJi+Jcy3hZJOwGV29W4vK8bLzutpVQ/44YzhfYbCwydi1GFEQ6nSNz+DJTZQ75SypRwsYmmKpd1wUHEKfXAaaIq6wPsyS9nDL8LDqGf4WI/jCAvwbgTzDzBwC/A8BfDff8SK9NChH9MoBfBoAf/vAXnk/VzG8fcPMhJVUqBrmKmTXxRrk3IxypVaIgLropUGCdNCCcM2ZHEvNAEk9QDoOIU3Tw0jL39kjYBnX+ylkGqdFThuJHIJuFIYpB2rT4HT+8xGdfDBJaXrNknZ1LglVJsmrp08iRVyGoBQZHYlBzNPhGkLbaPdHuX6eFy6ojOB6zhtmXAC031zvc3+81NL0cApNwdYKAmCVX5zBI4Fs5CyOnME2YMEaQEuHLfI6LqyUe7g5iobg/4HjIWK1F4Xp21mkejQaW2NizQxmgVGsC2w4FwhorKNWjg4Uj5iNJckpMI2B9crnU68KqjWLwS8p3JQx/AcCf1vf/aQD/DoB/8SUVMPOvAPgVAPilX/qHpk2vYMLMT0UcQ+VlCLjyLIZkM2jbdDVVBosnn7u7RsUR20JKDteqhEmE+a0+7s2sRniMReXDjCQ1JSGjBcSQlOqWtNY9JTOw2/Y4HiUmpDXF+p8awuZ8gfWGwW8KFzNLhpkdXX+j48g2yEqkLdXbeA6KgowroJEChzMLjSgZBxEf7o64vt5rWvmtEAg1od7d7nB/twMAnJ0tcfXJOT7//Bxv3q5d7DFFZ9Mq0Tc/E02aK3oWCbUfrR8WA9N+7zpxkRdLgwx8sUAFlBknSMWqrmnQdlwxGtKNznpq1BTFnq6wEbZTUEU97TZ+FBaFg47M42bUCsjfBh3DpDDzT0sD6N8H8F/r1x8D+GG49XfqtUfLyywpgWLMQm11ZFFiQWDPbGRcLdr4TZsf25EHxn4/gGBBYUPdbrRW7h2gsodkcYT5oo5ZtdNrce1FMSnek0js+KsWx0aUgOZGbZaLyJHIku6qfsWSxvrmVRm9cgOm0BaGZzwSyKufg8RULdXA/YBwfkBRzm4nVofdtsfD/QH3dwfXL5gjWyJ4bs+mSbi8Wkka+U/W2Gw6RwmWF1I2UND+G1HUebNTuMZZzTEKCOMEQ6hRt1X65ps0QCR37U4lKHFUWtsYJZ5bJhz+L5c4XPd1F8cziCYEwI5+mvv3S9fidyIMRPQDZv5Kv/4zAP6mfv7LAP4TIvpzEOXj7wXwvz6v0he8f6Ski3WQUvCoHeZwr2uDDeaBJ6HZD3tJlZcS4fyikzyStogovEwqCG0n//+kbHiScJ/4IU52eOWEU0EWs0Uz6oaEY59x2FtsQ0M/YUETF8Vi6IEHvgnjIr9Jrk+q7jYxYYSLR7qIiG7s/IYkvRVufX97xH7XSyKdhyP2u5Jk93gc/GzH+UWD84slVqsOF1dLfP7lOd6+XePsfOFnNaxPxpEbUkvKCGkV5i9bvm1FgerbcMKxw06238bnYfS+iWM+lTkUwqBtjJw9rEsbw4hCeaYuu54Hdj0NJUm+HNHhb7kfAxH9pwD+AIDPiOhHAP5NAH+AiP5BaRZ+DcC/LP3g/4OI/hKAvwWgB/DHn2uRGBHA6vq48Ojv5IfSdjNOILNA66yDT5F9JZws9ozJ1TaLj0I0PFELAAAgAElEQVT9mXa/DMg9XplxOF82BumpBKTNGtOQM6Mn1a2MNX9WX1yL9peDByGVXyuoG6hWYZjl9IZtrmpuFVr3fZZM3QcRH+5u9+KnoIl6+34Ih4+E87WLxiH++cUS5xcLXF2tcHYuSXpadYu2MG9jE2JUNBeRoIyLuapXB9zCLcUBKbLqMIA1gIz/CRHSwbT2MORcxqNrg6tqSnPDeOcgRlhYANE3kwcteml5jlXin5u5/Bcfuf/PAPgzL2/KlDiMmbO8INw0M6JFCRQ4Q0NAFl1C1lF2OEmAJIo12JWwXBHevF2qvC2tMjjobtlP7fRRm5/zyMkHH7nXfTZ0w5o5zYjEYiFc9LgfnNk5GtBo15EzMdsx7tJa1780SlAZbh4G1LtuRFycsJDiu4Bzh0FCqN3fiaVhtxtwfydWkRwdtgieZ4MANG2DhSbWuXwjVpPFsnEPyHi60wgQUOKBznm2lk1mLsRG+AkTP3ger0892m+K1VSO2rsC26ZQJyWuaUMrkS9FIsA6v9Gq4HXrFFn4exMZ4ty6ZQQz4Q6fKK/C8zGuqori1j9V5TFEHn0VbEsahS5MVuFeWCW2sVIiLNetJyOp3mm3n6JilWjxdKmqiXh7UumJ52nqMBSrk41VvEGNc1ogW4mHUIgfEOV/+Z6I3ZvPmuOWn9DOaH7zKM2BjhqTNr3C8Shi22Hfa25O9uessraVbFh2xNqyZW02HdbrrvhZKFx2PwP1DbD5rNYDlTZW7dbGl/sozABj7KgWT5wCSke4oBEHJTMos34jAjKoz+5UIiMZaiG5LxcCEfOMGO8qdXPtq/OM8koIAzDeBFT9ogtPf/MNzqNH7WswE0XNnUdeCpS9LBJ4JiMCXOlm0YYo1FsoOuI68cLPQAgRoo+XzUQ/MaOwoBQ2XCAkxZvOCAGpyY6q9st5EQDIktGZS9yAnI2YBldl7RhXnnnFf9+iT3mTw39EFp27ELGkvgTDOntb+j6j7wcMlMFIaBiSFTscYDLLy/pMku4uFuqRSHVQXxcpnlC+mWjAcQwrVq/3xb7Z/DMXpR9Dzr4g65hLXtOoDI9jw54XtRx4qipHGV/XjejlPJSAPoRihTFkEBmF61uGx1bjtLwiwgBMthIVoqBfa9ltrFCZm/vIfW3TO0lVc2Y2jgCfhISa8tZfHu9BARXGkWYeHF8KlGRCVE497k0qsZ7iAq/uD0q38fDZ+ywakWWFii9zc2SoPxK3aC93QqDJZppUwrkdjxKuyVL05dy6udBbFwgKM0oOzaagBjv92C0adG35zfsUN6JSTyfA9d6D+SaUwpVZ2k8q6uPGYFJKbrGaQ20iDpmFTMySRkRLWHyEeUQIeS8NZ4IiW/jabPzIfuGO1t7qDAYVRe8JUHmyvCLCMG35rCvRKVb8jH1bTb5DtRJTkaFxFIg92UjcPJM2OHJQmHmiAeMmn1QQB9A0183H+lfjrUfeob/ZYSnmwmllMRFOMthA9aKptsr5QDUaM2sAAOeQADxfiFy3E5lD2NjshKhRoiBHohMWnWTlWqgysrH8Is14g48aXY2QdTKImXbFUIQ5yDF7wBPxIo0mb6rq8n7amjKipKkIbONaJjBmQ6cjRKEfCGFpRcbliJGqt1fE2vuCxxfPTHklhOGF5Gyy057T72BmGynbTj/BzjkNMIxfHZVXE+JgK+4RYlZxL/uqH6rJnm/gtMoCcapKOfYfReY2Z5shiCCeoi5wOOeaycK0182w+ykBja5aiwvJOfsmsdiM5khmka7kGHUkxNlPJprsnDTxi53qFOcj3ST274nFMNYn1OJcnADYwAXRTK5Hpy+3DnFVq49FfC9FopCLeRG5NgNzeXVpBtt8lToNhXn9vlqsbfxipaOVV0IYtESOOSH9I69A13ZjtHtqrlFBPJJd4vqEasOY8irC7kjFS44ECoRlRCaqZ4zaY2ZSx32e8J1AHOYKjz9ETq7fKxoxZpQEdwkH11YGryk0yuJbUng+dpmAYhJURVif2b1PbdxtLMqReY1VwHBdgYz/AOoLaTSi0KgoYc5MxdpAVVvGVHW6msYzpZ9CDAfEOau4cLBgjMY2ilMRKdlfjwSuh6iionKurWVN1u23dVreP8+Y0qOc5XR5JYRhBAFHo+ADi7IAZYPCU9qzL4rRlPvkiqnNjr/6RlAO6aYeW9yjSY2LjsnYcIGOPrk10a6JA4yOcbh3OmsV55i9MPpsjSAY+arGyypxbz1tcAmcW7iPjUsJmQ85Yk0h328kmBwiH6MsZD/cZpGkjYOmMjD2TNuKAvGwH6rw8pGYpiQuzt1CUtKVBMI2yOzEy8hj3JyFcPCEmZTxsolUZaF6zqYcdTjskcNSY2kG5Jl5YlNElcqXJrO3tPF+lEXHoR4jDEU3VtobQwha92K/qDVd0MuowyshDEDNnZ+6g/ym5B/LIqEyJ/WuRPFXsEXHoR47cFPMcly3h8OCZ+Ofek8WVmjZp+I8GzF3yKnfgTKRTiPGnP3EoEz1JYVj+gIJj0XTXLS9G5o1qJqaZBUKZ+PStrZNFTfOHOCwzQNLyD2wRe229soGiaHRHKKzbPylBqw9vyxxPC2JbUqEdiFnPparFqt165YWtg2nYkpUkjwlWlRjapsQBE7lwBSrUtYQpokDRLrxkv2GoviLE8VCYDKTUUq3Klk28FRt/JkGU+lRzR/GyZHibwC7NeLUrpovr4YwPNpssq0290QNeSOTUKBQvij7JjsCaxtcJzWruTIe8nFKrbvtlE6CRjuVR+2lyYdRVwJReNkU1tzFiUMZnpmXFQLhh2+MWRq3RCEKdpy9RNAatTea20xUc/m2iGWu5DPiGJ5jJS6iZBTFosVRUJqrFgkRJWIkalKCP6WsMyPlhOrUPQX5OPrw8VTEaRYAC+aqa8SeYGh+kwqSKFNKcrUJ3qqOFsKae4yaze2EWVHVCP7j1c2WV0MYnlV83iMnKr89OQC+WUq+AaP+zJLGjY7kfg7Ri8zqFoVcZA8zlFp/87Txvj4C95ohAjz5MO1+BSUryKkPxo07fpjLgmcCkDVBCooZ18xhIDOHKdphyZrNjfkklA1p0Y5tXqJt3jT5rgtgYFBlpI0dkWx+mB+JmyUlwrVllrKTk63Gn8wsodN8KpTwj2YDULHJ6YJt5vFA2ZwEFuzD6eKX/G7JjXK2/CYENyBmIOu4wsZV60uW/CW8tvKPCes5tmkyl/5bmScjvBGJEVCJxs8tr54wTPozoYyM8eSePMA0qi/qKlzvoIvaQ5O3qTaD6WIpGYhqTho3hFPrcXPjx6ozNNejuUerRf6cYkTFlGYl4W4hCk4EHXiU3zOLA1LKhWDWjSy5O2NkopQKXHaZP3BaRyraPvdeVGLSImFAVtRA1SYzWdwQHwGqF5gjDmEcjNCP75ujqWHe44ATSvzIlAmck4tL5XxN8PUY0R93SqtQQiESY7oQp9nPbTmjpIppRkQWvSFfUl41Yag4pHbWf6nOIsPHY4wmT0H/+A73DsuEIWvMQrZcCfI3QunlqpHgH0pM+r5GDWTtNSIW2mRoY0oOwkMIfalKsa3Xz8VbAlUClPOXu0kbl4jADdBqABlX5iVycxpX7SxOSKYIdJMjObbwB+SeVPnt294yLz0EfY0HUCH5zJkxhIC0ttHalgBq0LUERPSGkpErjottwjHnNM5uQ+PPzNCKMQF20ZOB4Th4f20T2oONEkRfBCy+C4M5NsHyZBSL2M9U4jrjshRcXHlBeT2EIaz22UnSTo9of9hLujQrLe3JHVgVUYgBQPKJywMDnNHrUeWuS+gHxk+/usPD3RFtl/DZFxucnXdIifxMRUokuStj1wLMdqLumFYaVjhZoSSuIxxxMgU684ghKEdOrwUCEgvnaYUwONxXNGDpAJE17BqZ/E/q8VcWcs8ZxKoIbsoG6bqmkqFNbHDiyGWOcnARTgAaPRDVdgnLKot4EUvMz8RcuiMTiXXDxyrCk7BZbPMYUeYyV5GuxyhTzEJcoQFznfhV3JnckQkwRy0N4MvlPX2fnXCZK7fTk9Aea2uMFWQXC7CJviHwU6zf00NUoZzC0aHMQb0xFx0PwwSSlT2pz6mtXHMl5KaIBx59WRfcdtuDHySj0n63wHLZYn3WSXo246IYTagxcP3vtILpBMsaE8m5Ts7VMHtvQBOnIK78LItfsSt1Es2oCX3MrOa8hCqhSvRnsLoo9Nv1GpD62Vhw5AwmbhhhiT2YgYK17K7z5eNs5lOGiSw1uihILW7a8hO5xcG1B1SCvZT4FfKI6V2E2EnNTaOmcZQQ/U6AGaDMQlhTquIyVNx+hIhm15ASOaKS0/X7TxiAmkzP7JO5L674Gd89FjlGrwEXedD895umc0pvIdHtnvOLBfa7HrfXe/zkx3do2oSLyyV+8fe8wXLZKbVXgqKLnUdNmMjnjiBi09XkaYtw1PBqnkN14/HxPRZhpss4AWBYOwj1icEENInQqD6lBKyRlqUsXFPVgxGwwMUvBD+AgOKcgbO5GpdDVu4dGBZ1PBUandGsXgtO4ugyA2asiBuRoD4I0RVZ9RWZw/j6eMk8EEFQXSa/34hCo85ZRoBsUv20qPZXXjkXQl82cOISIEcIs01k4YCTZ1EXCr+UaNT/fyAMp8qYOPL8z48OwdyPygWIROHYqCmz7zOGzMCR1XQGrFYtLi6XyLkkdr273ePm4x6cgfWm9UxRrAusNueN21vcYauUcQ6Ny8L15kaMO1fiZh8NShQ/ZBnT5D7m+HxAFYxiaQH8XElqCNVBpFiX8VcOP8yNhaESxf2m48hqOTErjyklHbVQ2PhgD1LiCKPqf3Asct8DoYZOuLjA/DLgUh/7RjfCpbEoQratCv7DEAi7KIJR7AodYneasz5TZg/CW+YKo/9j38qX8tUS/KgH5AvKKyEMj6z0xzbAd3mNDRwX6FliBjj2dE7QNnKDOes0DeHq7QrrjRCIu5s9bq73+M0f3eLy6oDPvzzD+eUCbUMO4aZEIXgLhn1vpzwtBJt7tfmmijh/OjYTBSiNb5+ipygP2+i4/sI/lFtc1tf/K4QwN9zxO9e2/bqNQVSIfiY6FpllYxGXOUqs1iGSscvMaEAgD/U+RWsRIRXGHvBMQDM1ly2uzJkLkmFOIBLRE6mgrfGcizKV0WC6nEu8iOREEb2EHLT1msMJ4KBXngy4vdbWVtuJTuN7LkqElR4X/QuJw2PI4TTnRoUcACUODaFhO28sv3UtAdxg3/aiQQfw8dsddlvx0jvsV1ifdWhSqtCCebihNdOWmQ1RlGWx4TQehMeLmwCfUfwVcwOh8N4+1wgCYQGeaJM1mwwBjMShiijMKUmN4BQRz7wbHaYDxW5nbRy0eY1tDM2rMN4UBERntQocMHwdxOkwQhCD2EZ0kGMOUaCYKhOQk5jEJSw+g1OA+KiDE7MqNzM03kKKCKqslfIem3PyeYlrQLJ1lyC3zy2vgjAYXgAAU0tNFst3QA4jHivXRjunMuVQgZdmTpLDOiWt+DAwjrsBd7dHvPv6Aftdj/W6w831Dl//9A6/8esfsVy1+PyLM3zxc+domuTp2hYL8eg7v+xUJkXJ8QhUmv5yue7BeIPZRTfGVJSPqttkw3ERRVDQUq0YjFWV3VEFMIqfR4TCDaQeYZpc1VNozxje2OM1wqIEj+Vouh5mOBozZS8gmyoP4hCVgvnV+6IN8H4yh2sFMXn7wmY9HgbX6yTN39l1pAl8ihhoR8Q7JVZmrRogZtdh23vf3B/Exi+IMTwwjkclGigIJk4JbN4MYSL0I/S1UVHvJeVVEIZpUeLwFDGY2/mP3Tpa2IUeTDB3JadV0DYLvN2cdfj5H164RtmOE9/f7vFwf8BhJ3kUl6tWMlslwmIpfv5tR/o3VdxCuy7/qY4ionny32dK3OhsfwOECBuCZp4Luq3yPAKdmYGt1RDFmxxhULh95CQ+6rP309tTYliauzQlAnERz4ozkN0n87DfZxDE1Nl1Cd2yEfdvrdelGbJ2mNKS0GgbhJAUIpWahBQwvLsrpKLTMA/IpPWaeXPQUP7MNTqw9h+PuRJbStQprQMl4IqEuKMK1VbTElBMocSEMUN8qrwOwhCo+exvp0SK5xCFQA0KfNVCYfGeROz6bMTRJE4py7UkU+XMuL1Z4u5uDwbj/k6IQ7dosDlbiHuvBhc5HgbxiThmLNetJEtVZeX4/acm3ds7busscUBl4o+PA6iybY3l8cfH5ZHyBDF/zMNigneooBkjjMXJSyC5nZmyGJ3HQ/a6UiIsqB7LuWP1/h6Qu4uLZ6vFjwCqWPFmHfGGWxLdjKwu9VHxzIygLK1RWczSZfXnTCBDRHEsYIQj4kBFufaZS91W38vIwmshDLMliBRj4jC99YliGzrcO7NZJveHuguUY6fGeQCaBui6hNW6xXIpGaIlG7MQiYuLFS4uV1hvFp4JGgC26xab8wUurxZYU4e2q7kZEBYKoyYKM83079ZmQj1uVg/gMrfBTKAkeo3HqKsqH3vXifGsY2E8QRBGGNlRAiEceCtJjAuVZ4/yLYgu+o5of1Dyi9iYJCqxHeVS6HDgumbiBOBc3JIUeQTmISojRS+wXLU+b5SARkU0s1xwtoNWcA9RSz5seTTAhGYl8SoSUzX+U2JST0cc14KMnl9eHWE4BQpOihVzXG622MRz/DZzT1yc8RJP7jKbeCbG4TBIqvbdEQ/3O9xcb/HwcMD93Q7b7QZn50ssl0I8+j5jve/ADEUMDShJnkUgQP7AQaqxqK4+s4w2S8mvWGIrmkxcIg7bPXLD+H1zCExbXulpSp+mIoN9nJ0P3UnCZQVWep6JihIVQWVi6TH073EsefIKMNRkXAiQBXr1I+oUvBrNx0C/D1xC4u92vVqzkq+RQojJh8nnkA0FKMpAMFlSIEARBYTBGn+veB+Vi48R5bny6gjDqcJA5ZUXrz+3zxT+f/Sm+B6uf0hkyXOLO+vhkPHtNw949/Ud3r+7w4cP97i7fQBAuLtd4PZmi/VGsidtNgsAIjcvlg32+wGL5SD+E83IIuJnOLQho/7PSRNzPUYQJ2TRlUjDCO/hXOIQpuBEZO2J4c1OjWI5mVEyLZdj69P7HSk8IgOPGZ4r1kZvNbf2xjhynmrjKxk8vt/kLgTnKo3yBYjEVU7cBvGGCDnJWG63R3x4v0OTCBeXS1eW2vjZeRS4pQUjr8RcCAkbgpTel8hSOutjAoHS1igmGVr4fhOGyeKpL7yIQ46rGlcL+EJgh2nGmU3eLptRqLroFtoOmqK9x8ePO3zz0zv8jb/2Y3z9kxt8++0tbm8esN8f0TQJx+OA3e6Atn1AahqsVh0OhwGXV2t8enMmORU+P8ObT1ZIzaJadAY1Z8WIUwNC9Yg5lFTK4JC1DcpNLseIiYChz8gEOTGoGu+gXvEN4e8I7Ym4Yhq23WB+gPXVHBs5mekmiXehjUWjYd0q4seMlORcix8Eg6GgMCqBOBhCoEicGHM7zYtEhi4OTykBq7Uok88vFhMubtHBFovGUUch+oz9bpBM48cyh20bQ9fBoZYDGK89EOqIHBRil5Ot30fCUEGeceGZG59X3VzhehXL/WpLm+wzXyAIZj3ysOjDkPFwd8C7n97h3de3uL7eYr87uhktpeTKyb7PQC8saLc9YrXqcDwOmpk6l1iACJsvrkuap/mOGqh8n+2zRZbSupOePR4GBudcOBcrQeJoAqvRw/jljyIXbTdrQ4ou4Wm8o633TxL3Ub0stQG+IQgSiRmG/AlAVl1C0VcVs27djUm/rPaEkPU8bFKtwwhdaoBl02C5bMAsjMMIQIlXaa7ONRITz1E9dcnsbt8peD7W7bJnybsy7kMc55eRBCmvgzAAJ4jCuDirn16eW7QYLT9fxCM5k/3n0YcRuCCEZDVC7XfbI95/e4/b2x0O+yOYGU2jadNSsTZkDU4yaNZpy6jUWcIUDYiKXA7oRBmTYlipmT4+WdgkcanYFrgllj0eB0l86ys2avzFbTsZeghcuuZYEZ4X8Y8Rbp+O7OPNDsQxJTkqnrJ4lVIubtK2wdwVPTNAyRGXiBqEZIFdfNOw5DK1fiplYYXvMgeWE9PgvY1naaP73wTiYbDfvVz1rIcPnxLKTkPmDcPgUcTspOUsMwjiJkjN+o7GSr3WtmzU8gXl9RCGE2V++cxRglBesmGsxplxo9ECKNep2vD7vWZkzln1ZeQb2jiw4famSVivO1xerXD5Zomz8wWWqxZJHaEKOjA5chze9pFOF9Y82z8nigxk3RR5yGJn79mjFlsw1koJJl1BhkQhmpdbbcGaExXNcujvWjxwrR5zNxQCTdpiYxXvtVusdTxaG0x17kgRrcRUaMhDiEqNmpwmhk0ZiabFrGAu/g3V8wGNpobQIKHpZYRL+22NBUsLoSYYwRwaLpWQfQRQftleAF4ZYTjF+F+ypuLzp5+ra50QBdtjXJQ+VaX6gIQZE2/GJmnoc9luyEOZ4JwlbVnXNVhvFnj76Rk+//Icn395jqurpbhPNyXxi4VWM8gQlUlV831z8uS3qtWRySsqMe13fyzHfr3jAS5HXQsz9DCORI2eSwEv30NbA6Gyj7W2fDz25uk3nT0TaZomabCT4CnIQM5DEfWIPFBwjptkhA79/TqWRHCRzm600HZmJQ3NN9o9GQKLWyHtHp2LgYwp67CnJGnrlytgGCiIoqTHpnMV76NbJEU3hSjEeBURMQgKrFPkPae8CsLg6/DETqZHvs1efQSlVuGw/DaebCT2FVDkWHs0Z5mgzabDF1+e4/f9vV9i+9Dj/bf3uLnZYr8XLZIkXRVxYbNZ4urNGm8/2eD3/D2f4c0nK5xfLLBatZJ4FqgmP1oFPL5D7F9coRitzDF4oODHhBID4HiQI+X2TgrvNW7snI3god2fDBVmG96ISvxpRLn90JhdmkVuinWUqDQd4WzR6f0i8gx6ErbQUDKqpmcUMoySkdZpma58Y9n5lUYIX0lfqL8HZFKIFFAfYydvl7khGy8Z+tg+fV7jVuRBiZG3R+oYhoze2y9z0ORAwLiMC81sIvO4nDC4J8qrIAxKq8EzsROcW0aoVD0ZLo4X6wyzrx56xliNmXWR1cWH/+x8gS9+7hy/8Lvf4uxigQ/vF9g9HMEANmfqu7BqcXa+xJs3a1y9XeOzL840IWtyCg+oiRCEcbwBm+847QxLp1e30ZRh8j9PTfcRXFDRjttmjx57CEQh0YgoPIcDzYAZb4bBeyp/J4Rvbn6Us1tMC7aUghZ/MzwaOanBayf2tpEEnvhJViOKiYBMEIg0gulG7nyOYu+caBdi5gguKEHtZmZxlIsBVSxsvxG78SEwS77s/I+iqzVVdZdnvpeEQQpFrKdXJlQgbJDJ0nwEKby4lDVUX7aFBvGf35x1aLsE5s9x/fEC7799wMPdAcOQsd6I/mC5bLHedDi/WGBz1uHiaoFWQ4KZrVti/6UqrVnpVA3NHdqHnIgOb6sNVsx/cZEIpxOZNw15svDFx6HUV2IfUNlMcZwqolSXCGF95AzOq12PmIGkOSts0ylqK9soinV6OhFlwwvUL5TBkJHlpKjbJ41OzmWpbry9OygaDX4VeV7a07QFzZWsW9DDVeT9QZ5y7oh0YiIaGwCJdVnWnA1l1EVZODkjDEa4Ssby03PzWHlVhEEKzX+Nm57DXaPfbVE9izjMUZgZOGKU2Kl+4HZtl9AuEr78wTkuLpe4vFpiu+0x9BnLVYtF11SJUhZLMWkR0SQ1uS2lKJNW6DD89c2j6MWT8IZu2Q+uDLT3eN0EolQ4q0PYqTmtZEsaiSkzw/bYcGMkuJkp0RpYcVjvw7SuiXxtiEAbLahCxyQI93ZCMUEQwVi0iS8jH9ipb4UtHAdW7lBliXWagCTYJ9K5uiIVhh3pLn2yEgPyJoJbYGySi4dqUbTaGNp7jLblCcN5vDxJGIjohwB+FcCXOhq/wsx/nog+AfCfA/hFAL8G4A8x8weSWfjzAP4pAA8A/igz//UnWzImAHPlMUQwRhNzxEGvnaIDse7IgSNYnPGqBQESObolrNaNH9FumuIDX3JUkKdDpyTnLNjaFWzlZtYqXAChc5AQ7JOmF/YdCafB7bk+Ozc1Nsvwo8Rejy8yKs+PUMZTxeqx5ld1cKmjbO5CKJ1uBIJRKfPCYSd5RoPWNsnHz1ycTVufM0AjwmzoojquXRGFmmCaj0oORMFMvm1nRF7v43oeCQCa4gGJIcR+9DUq82bh4CyvRkqpirztKNEIH8c2SjVNWRHPKs9BDD2AP8HMf52ILgD8b0T03wL4owD+e2b+s0T0JwH8SQD/OoB/EsDv1X//KIC/oH9/tnKCc8zdE/Zy/fPoGof/Z4fNF3JNZSINs4lvW/HMWywbb+cUdpc3SizCYuu2mh0xhECqk45zcTcu9ZWdVPW/MCs4tx6hB7vdoHsMlBrt4aUpXH8M7TzlTmMjSH4XVy8fE5vRkM2NQl2Igp4EnheEksV6LGjB9QTjYc3l+LYlmJljAkawiUS5N/SiILSDVHYYimKqvIAUaqYjlgjOjExCCCriY1xf+9M0SUO+6Wox5MHhbyguYjw2djPlScLAzF8B+Eo/3xLR3wbwOwD8QQB/QG/7jwD8DxDC8AcB/CrLqv2rRPSGiH6g9Tzyome0dm6fjNchnbg+em4OHFZ1cLk/EhD5XSpPo3dR2CTmLovxViEgjWCLcWs/VxAmklCQBACPNzgXmzClcgS5zroTPA5ruhBgp70wbAgq94C5CkAbF28cJcQNzzW3LV/YCSpIxvH+7ihOVrqxlkux1pgYZCJNqsa3tL9txRwcCUwGiyUhcNDquPJojVBIqOvnUwKhjcpN+2Hoxbpz7LOIhgQ5QJXZF0g5pZkD9A+bG9OToSKOUMUk/DnoOlCUJB6rMhARbdiYVajzmeVFOgYi+kUAvwTgfwHwZdjsP4GIGoAQjfFBJRIAACAASURBVN8Ij/1Irz1OGE6+VP/OEQPbvE8QgZPlMQLznFLh4nKN5+5BRACjJoQH/EANA8zimdK0mscBBRJ7fgOrnhicxbLjyXbDRpy0C9M2RdjtT47gqd0HWLRrC1pCpT/e/lFPg6Y+wlwG8O7rB9xc77HbHbFYNPjsizNcXC6x3pQl6hwSgB16qrgvFWVrJOz2u1i+6j5w9V8IET9SZI7nzsyXroPhJO/m6I0pWHMYxCV+vx0kV4bm4GxaeeZ4lNwPQ6/KUs3fEcGYmC7hPg0Wf1KILFUBYlyHxHA363jS9Tnl2YSBiM4B/BcA/jVmvqm0zcxMLzSUEtEvA/hlAPjhD3/hJY+W9+Lx/Txu0HfZ+0+93xoxX/e8vZ9PfYgEgsvZBWF7mq/RZFqTj4MuomyasDnCK6rxGLU5ttM97fQZ2ySRyxsOolgBR5pdY7KxdtyRir6j7zP2+x73dwccly0u9gM2Q4ngZJwxoi0jFLHtJqb4u0NbDanYvDj8NmKFImrUopN+ICPOoV9JdBkNZ52fQPT0sZiGoEVCTjZ/2ccgohnSjOAWStBM2IBs8ONhUEuGRjZvCIvUFOuUzRtKbMn8QsjwLMJARB2EKPzHzPxf6uWfmohARD8A8LVe/zGAH4bHf6deqwoz/wqAXwGA3//7/+HTrX4hBKra/cjj7jfx1LsmiCVqHMKGDvJyFCmqOubexdVHuZ3sDD5rzkgW9ACDpSVQaDwOHLmLN23Up8Dc/V3+bt0QMdtSqMotE7GOsm9mXmQTYARFb7NTozlwsfOLBTiz+0vYycISCFYCqQ5U3KIdZscmmPhmO6Rq09SyIv215gcPwYDprc82H9Z/gnLpRECbAIxDtBVnspwlHHyrQVnsmm3spmlK+yB9PuwHR5Btm1xXMKg3pEgrjJQaPXRViGBBTY8KzSfLk0YMtTL8RQB/m5n/XPjpLwP4I/r5jwD4r8L1P0xS/jEA10/qF75L4ROfRyUy0ulvj/06V0shNeNXOnLlmUfCW3wDKuyc8wy0f26GYi5RggbbtOVdEZbXbxvVO/ppVrRxYhCIwqRPFVosR5z9XzC1ReSBQrRK2DP5t950uHyzxNUnK1xercQjVK0KkXhVZsoRDCqbMgxM6HBUtPoZiPJ0fNIH1bsauEyFhPRwVWPp+1QvEAmC+SbYCcvoVyGWkOQZ0LquQbeQI9cxOLDFh+Bc1kbTkIuZRijDYFQ6kZei5ecghn8cwD8P4H8nor+h1/4UgD8L4C8R0R8D8OsA/pD+9lcgpsq/AzFX/gsvbNPTheuPz9raz5ErJugAZWeMd9W4khniNNsuW9Az16vXUTjNhzyR/atHnQtT6Kes5GqtBNg6rcTuN0cigufStK8jV+ix/qE0r+aaDCDl+Ix8zqEty1WDtiUsli2YxYzbLZLL9ymV56IillNwPY4Q3zykqj6iIB2vzESaggRPEoMixRTUYGiIAEDay1lEh5LURol8k8oGtrlIKBaogGaahrBct2iOcsgtho9vF5IT1I9nW51xPgJRYMDNr88tz7FK/E9lOCfln5i5nwH88Re1Aqi5Uvz+yK0vKrEHgds+ff88MTglHYxfc+LD9P2ObQNn1ettWxacJ1a1TcWWuUgITtRKO1qh+qSh2fLFCmLEp3BMP73n+oRRG1Fgu7tPj0coiA5gCZ8evxfdQLHPt23CchXqh3hhjk8lSt+lEnMPHhe3wiDAa4u7ETa7N500fVwTxKV4D3MZzzAorN+JxP+jaaVNh/2Aw85iN0r9XQKGISE1QNsUBeX4ZdakJhHSIiG3SbxRdewkrgNqgsyo/DRM2eonyV5YXp/n4zM68Qza8cJXUfVtnijUlGsOqVTfTzXukUbPmpUYesiIwYlg+8BRcty4hqypbguR1SGb2CxxpdFmyRh1xpjYaFO6pyEKUXBFYBiI2JeqXzNU1fddsFxMRAOEmWIZCPlM3s+54iRv3IbAICYIwG6z90T0MVoWrDBMxkpjRgRC7MFkewa17AFYqqhSVYtlIB1dkZodw/dpH3nSRUN5LzVVAq+RMFh5Cvn8LFRhRAcmFyeDP/+yE3M0e9/T7TUoH57jAsXHt/pBK3sUcXGXjWLc1j0pGZWm3/sRNmLFlUODzKMzigMm78Z3RXGp3Hd6pEwJp5RLnxubSIvicGp1eexY8WlqUZEbO1mJekyn954ozCGztiWkUUKsykKiEpV71PzSDBR0NPAIHULXQ2WmDvMZ5AdTzD55EvZEeb2E4alCAUF+h47bY3UVNfutFsPkXY+QBVYm9ohOYDpZ03spvitsRIs1UBEE0wnYNbcgUJFjEXMmhMM4QTyaAeUBstZEIbYzwn2pyDbbbKXfqZTxKFmkbBbYQL2Pi8GW8swMXw4H0KrBLEM+IlDx4WIBkJvjlFqglpaTKIwhzlmVBekU+0cRYaKoY4zAXKfd0z1kFzMi72JpZaV5fnlVhKFCeicm49HvLym6TqrlQvUNYY08ozHlZl9Qo+tzX6e1zOykwNlhijiFmsadoyWj/LWNEhaGulPnDPTHPApZZtySK85lpxZdMXki3Znfp91INNpswAgFlGsVRwy/YXR/1B3E4YlnY0bTGOjqPHGID/hrdVPFDFDeZhcbtO1j2U1/a5pi9GsHCaxr2ceKuMVhLGL4enhELZnP+uStmZQz9Mh4QDUMVUbrcW6f1xeUV0MYxptv/P1noQEny28BN3uuOHHqwfr50zVVhMT/qyG1nb0Yc3BmTaaqn8GoIGpRTpqIEXaYLnwjPkAJn+YcyU4gRu42Gpg5lFH1j8tGi7fapmeIZ6fdWxGYydCFjcrlqxMHJ16PTf5I1KraLFcek90LURaTqzk+2cE6fcOon/K9ZNoqcxMD6FhEJlemWs+qfqKsjTGTekZ5NYThqTLDKAp3+VkqprI+JovX/6pP3Bz8Z6raUKGeUWVxQ81yt1BDveFt0gMJUYVYZgYPNBmbHMSFvs/Y73o/h2ABaBeaHs8XXRa329xL7EoeygL3rMtiG/UAIrLg7R5byOV0Yh7MhVv6ageACrKytTvvdg3Az2gMge/H8yORGMZn2W62cZxMTJmEOA91W0jHugR1NfMwg0uQ4LAryZ8DGlLnJYT1FdpTEVlMS9Y5AWcZx0ES7JqbNRE0ZGBXIZRaQYzp4n6ifG8Iw7jQ6O9vRWXjeIDV73PjGiD19OepIs6rebTRclfFBWlmUfviIiSPzmwLWh6IDkREhK4TB5uuayo4W14tBLBpaMKV4/ugh7XEQqJJXQhoWMQSq9hEaIIGkEVEAIUwmJkNKBs+bkLj3vGQWTJIP7MQXrQFRmNsJzH9oFounpqLZYNEJVsUGOgHTYHXFHFACMUYMpXNWr17Zm0ZoTweMo6HQc5SHOVvf8y4u9njcBhwOAxou4SLyyV++LuusGybUeU1onhJ+d4RhinV//+gCH77bs8SNN9BIQ6P3KqvG1GqufZUBGQctVKQjFskkvgING05tuu+CxxyP07CiAVC43+mbcrxGQJS0udOjVnonse3GN0adQ6mF5HXm/yDGaIwwv4VTDtdypoimFuzeXOa2GX9TKr1lfEqaQoBI2o1frRj3N4ulxEwaVscLmbxhdhue0192GO/G7Df9/j4fovd9ojdrkfbJrx5u8LVmxUusZTDWeoxCi6KypeW7xVh+G0nCqPJilM890p+5Nvzfhm9PG4YoOyauPArLz+Rgwy6OmJw0cOCvCa0LZwTR5fczADn7Gcj3HRYDUBIM6fPcS7c1e7Nyj1zsvsDxxq1K3JLSyJj9xJQa9MdpUudhmbkXut92HP+Je7CJ0e/EkH8PIpeM5EMgG488oliCKqQ1B8BRXobqHoRc5hj7auJX2Z6HAbGfj9gt+3x8HDE7qHHdnvE9uGID++3eLg/4OF+DyLg7naPt59uwJnx5tOVIkKAmdAPw6wY/lT5XhEGAL8FRGE8Qr990OP5Yt0TWmOlB2PGGB6f0A8nMlTgfyWe6G0eL3HIZcMFpBK3XYH2Um8igDSOfNGuU9UbRzIVhw93hHa6IpPLacdZ1KEKUgET07iXJxWThZGfLqQaJRVvoiuxEYtkyX/Kn0KgoniDQBxMUcQhEIu/MliSILk7ADhh2N4f8XB/wN3dAXc3e3z77g677RHbhwNSI8F7b6/32Gw6rNZyxqTVyOPlFO4jfZ4p3xvCMF7Uzykc/o8faz5yapXQ7Me6jtMcaX5xPm1PnpyHoNHrZ6iNX6nMkkVWtWIJcDi03mR3ryLFawKDYzxBW+OpTbB4p/EkpjTDEEnIwjTX8VHfRH1vzL6Y7PSr31PrPhxOTK2oI8QTiZFz0SjOMIsHcbKU9IaoTJGrylSSXA2ZocFkChIz3Y0F1PUxQIjT4HqIqUQxDBKf4f7uiPfvHnDzcYfrjztcf9zi44cHfPwgWc9SSlguW1ysVjg7W4AB7HY9bq736PuMbtGU0IIN0EyjDD9aXj1h+K7iQ7Vxp7TBP89WK1hW76FK1J8Qm9nvqGf8OxIFU2bZZq12hHUtcsOC2IOYHXj+I5zSczv4Rlcxwbk3FfgPVElZKn2A9SOKDs+ZO0XmlNQKkS183cytVX1hFmfudR+JOcIRqoixPM2syJw1t6j8EJPolnUg8N9POHqEpfGWN3GFwpjYveUMzOEw4OHuiOvrPd59fe8E4f2397i+fsDD3R6LZYez8yXefrLB27dnuHq7xuXlEpuzBdaKGlpVMJuI9FIV2ashDBVMxSOb9tmF5/6cuusRAjRzjuAZJSKcCbc8AWnjGAABhmbM0YTyZa55zOBAFGZ+Ds0xPwW1BCSU3AVuj6+RwITVzfTpJFKYeZSUMhgR4orEzVdQ7ihK2Fg/VV/G8ljdDjuHYFVYzAftsN4XkFAg9Ba6DVDxqnpDoZpjNAe1GPU9uxXkeMh4eOhxe73Hu6/vcP1xi+uPD7i+3mK7PSBnxnq9wPn5ChcXa1xcyjH188slzs47rDctlsvGT3K63ub7ShiAQtmBMcR8aU3PIwrTBryg7qeqMsowI4bMVkMAPGy7OiONFIJO+cezfJLq8fTe0L7q6HFoKBGAZPEVAwwfEzp9LsZw8OtUuGNszuliEINLG2AEyqv1rmaNmOI6lPJoUepFCKDEgeZgg23UgFDEDKwJeBJ5suHMAOUScNb8DJizW39SQy5yOXF0OCZIizWy0tCL6GDN7HsxUW4fjvj23R0+vL/H/d0ex35A2ySszlf45NNzbM4WaNvG42NeXErOksVCfFPGRPnZe0DLKyEMXCYRgK2EmuL/9r39ZVU/wsX0Z1dEpdIT7yGffrxoxQkUvdWM4z2npRPGaBsufA0vrGIkUvVTBXetb3JfgaggaMomrrj4s+DrmHCrqt64vyOT8H4CChHiqlF41LxrTaTqifom9u5JdalYTHpVRmbPgK1EUTe4nVo134eaCMqXHNoth6skhmNU3IIlCc1h3+Ph/oDt9oghM5aLTpMWrfHpZ2dYrTosli3OL5c4vxARQpACjYiRjNELM9S9FsKAWXw8gfnfsb4ntvLMM9/hjbqJIlDwlOcMgMe+BjOPx/aSnolAHdnYHGseLZNVPxWwJ2SYyhcKI8bxZv+rJwm54AzXh1B12ymp6XS7Q5tKWLfSRvO/GHsRlo6M6htdc0/FmRc7nfE+kecV7XsNwsoZKTW6uVWsIDlNaVGcQIThOI2+ymHyojK17cpmTnu5rx9Eudm2DRaLFheXIjZcXC7xyaeS4nCz6XB+ucSbtysslsl1Ci6C/gwb6FUQhuhlN2udqv/zcsrIx0+QgulTLxm5uXppug9DzaziQUlTNq+IrJLX2oBwndOz6tm4m+F7pXQDEA8/jUdR/pRdFIe6bMDRBCmKid6NQhS4xA0YtTV2OW5sDjvYGV0qD5vYwxYVGTHZChUkEbs1IhwTVFIUBFV7UqgPQGVp6I85kBAhAt2irV+gDUmkEZpDPouCdkq/7KBZHhh9Lw5Nh0NGIsIPf+Et1psOZ+cLXF6tcHa+wGLZ4vJq4SKD/GvQjJQbY4L+vdYxTHbXE+W56Ojx++ZHrFrEj9Y0RxTiYhPk4z4CYZLGysbx+/2n8SaN7Rs3/8QC4GqlUF3/WGQYbZZI6OKdThSsz6HScZXVwwyMd7K7O4fnTCSZ6jpDXgYKlZ4YSyFWE5gwXyi03YhFgruRcy4ihiX5FZofWkcSWIWBko0aQoz8fEVom2TjFgeqPEggl/Wmw5c/uMDF5RLnF6JYtFwbm/MObUvBKWo0luOxxsmhOVleBWEglecAvLAHM1hx5o7Hn5ou+fGiLlz86TZEohBdhc30xoXFopLxY2uqNT6iBvzIpovXR22tXjvHQsYLKyIORQSnus/hnScJll8mdUoaNTEqyvTdgnR0jKhGCaYQNQ5eEVGazmrlJUmTH2fFENYNTwQsFgnMqdyq7RiG7KZGgDTsmqWeq8UJSlQS4CiKtOPvfa+p7omwXrdoGsLVmxXOzsX8aAff5BBciR0ZAZzbTp5Aa88pr4IwADNQ8JESUdvJWf1OJeyeuTJiTCVpky26ekZENpbdMnYkipUWBeAc2Z9pw+wXrpt+AknQ5McZThsQytxQjG8f+3nMEa4Ys2B8WnVOJCzJVHTRS2oNuf9Eo6rhjQtqtETka92LCUIMyA+wDFUykTlAwOj4BJKgt2zJdBN53kmrjTSGgrV36DMOhyzh4Ae52LaN6BaWCat1i8WiKegEKGchqIgnVafrPzXxfmZ5JYRBe+nlpRs7zvwsr5287dQvvuime66uT/fTrLHAblbZkse/zd2LMol1B55BMnUnVhtytEkat8mjeCk+bj+cqyZw5plxDly8jMuoXdW9XD3vokPcaInAOXsatkTi+dgkFB+LUTfGQxAYtH8+OScc2sShTQyYt2N/zK50NP8E89IcIJmlLWZCdHo6HiRPhOkeJFdGxuEwSJSngAabRKpHaOTQWxV4p4zxZH2Ne+drES8qr4QwnJiwZz5TvuHENynzBIGeuiE0bAQZqjb8v+2dS6wk51WAv1NV/bqPGceel3EcYiOjyGzCyIoiJcoSiDeGXViQSESERSJAgoWTbCxlBSJBIKFIjoiUICBCAoSFQJAgJDYkkESOH4mMHWIBlmNPYs/cua/uehwW/7Oqq/p237me7hF1pKuuW1X//5/6H+c/5/zn0dJic9d0iq05pqSl3jkqMV+mtuCk/k4zdmkbvWDBvS5YVE9tQMTtlC2FoSZK+CLxt9gucQupsunlVTDOSkDTyvckBZuKT6dbazwOEThHK/2urNELUZAbzDGkz96FYWyyrJETwzph+VwTGnwv3HEnCkQRs7NBSuY4hYaBVIyrRveasOqacrAhhEH97toO4fM6uN7aW03+Y76uhZiYt7T9fme5BiKxDUCY+NH5vy0UduC4nvpxnFJfNHPGSC2rtbZINARybYOluExp9nVEkhv1eja3MRCujNPSO78IEbwy0TWSJGZnPjzIzeIhCjqLjYQUKQB9HW2oC8HkGycFhB1aJYxNrIvxyj1sNjBr3mgMmUyZwooALiEMYpIJSuJOGkxeShdLwSecsW2nmREX3OlFcJFPGA6T+jd5ghBYBY2+sW2Sth7rLgEbQhgWQTdRaEIH0WzUdSug3dX4Hbt7wegCS0Tz3LRRkyaCBBCt/0a6+ZM/fI6gxO21vXsixBNR6gTQX7sF1yBSGv/GVVjiU5XGZ2B6XHJ4kHuWPLVeW8brsbJ2A4nXzMf+CrHHostg7TcONd6ZZan1frVUwVk8irX+rFTJpyX5rEJRG/DGxD1wEaqMv0RwVJseFeR5xWxqRYXKlEsS47JdVoYqSiKMRibAirPXSDLxx49epGkZk2XWuj/5WnHqbwxhaO78zaulOuEskIgW4qrtxAq2mt7AXpiJGfOwzYYiK8QuHJYd5CVks3g510ivJyIB12BpGJXtYF2bV020TFUNxOwMNkd3lf+rNIRPS6ynU6VKUlmDS1FEg++CKmCdnlxgleEo9c98jocoUlSMvTN1Tqy589G0YH9/xus/vMnQWx8OzXFkLApYYu3EjjyvmB6bqEvmtAGfvi7WSRgiZIiFJGpFJPF4xUfCzYSSi46748Ff/F47bARh6Mb5FKTOwynLtciY4b4ZodoGGDMRMV1w4xJRBo35cW/+K/5pU3fRhprULqLrrgKd39K4Z9uP55+fnAHdOZjXl9QqjRSdEVqN/12JSvEsd1WZ8/zRKDOu11Y08ZxAKsEYyYtopt0iN7v08VEBAufOj3D5JPO8RMTs0ts7A+/X4L4zcWJHIsyOCq69fsh/v/wmzz/zCu988CJvf8ddTLYykmRgQkd412zTSUackBABChMSLk2FwSg132nT2Lt2S0sg4vFxcSaCHBp1eDReEk2peWodKMKdbeA0B7eZKLQKafV6vcMOeE11m8JqvqoG9zPHQbQ3ueqXRPzIySD1S5+noOU1jU4R4qKdiV46xIdA2fD9GNv1e5sANfezLPELLCTZkeAT4MYjelcx0Y9uXD8mn5kYicaLsWI6LQAYTzIuX9lhsm2sCAc+rLt4PMrSeDseHxUc7OdREFYbzUkjw6boe+PYFIkNGZ9aAlS45MQ+JJzYHJSRjYarzxND341EGTZ95zbpQW1ERLpFxgWwcYThlsWBU8HixQkxw133h4jDjfkBilluaand7VAtu+2qRMHt5q6+LvxPfmB33SSIFbE9v0Bt4czJO9LsF3weRfctPghMKIJLnuNCpSWpkFRipAHvhxDFFUiipC1JVD4RskFKWVQUhcn1uH9zxvU3jjjYnzLLXezEHK2UbJDw0LsucenyDhcubbN7fsTI7uixBnJr21ggvmt6hYuXd5lMBkYpup8jAqNxZjOSS/hQa8Tk/Cac3cHU5rJ0NhppaoLdeMLhOmVuIde5Gk+gvXY3sJCtc6aL3VsAG0EYYvoX7jg4+Yu6yy4D2nLV/pav2a+AIP/WDZhi/k/bv2aJjXbh3Qghje91QSsXA22nQcF8O8p+nQTWPX4HDRGVHU5+50vqdTr2OhgvmbrVBlEVDBFIKwkp3awLsfuIJDEOSzUZzlpCpgkQpaNXhaOjnJdevMaN64cmnkFZ+a778bUDLlza5d77znPpyg73XNji4pVtsjTxu/5kK+O++89x6fJO0A2oYf/dYk5ETIg7y0aWlg90gWBdtuo8L43OY5iQDaO094MkcP2NCeJPcNx9182BZSWeH7V5SjwnV4ONIAxtpMHAW00UFtW1ACKhezkMGyz4ymjeinDRUoWtxmNmJ6TZpJtHpYHyxRPXEQ4f7kydk5MJpe7SsTldi6vXn/dbbsARDycCePQcB5FE8R60QtUSKrfBRivB2RM4haBXLtrFWeRlWCgC+/tT0iz1pwtlUbG9M7RxEx1nkpANhNHYHPmGkG0uCUy9j2OiGif1UTW2DcY+IWEwNNeOuKgfA/Xike8LXTwDmjQ/TE/1/68KG0IYTgdnI3Z0baXdELPv8yMWsHJcoQtmUm92Weyb1McNttQMc2q4nFS1xKiK5xp8LAHL5dQiNlVG2R8nxHWEwe2ITheQVnXnnpijieMoSKKIzS5VWr2CuiM7EbCLpnQnFaX64CiDQeKVhO6EwTkjmTwMlY/qPJ4MGE8GlJU5IVCU1J4EzGZGF+G4gHsubJEkEybbmQmoKmb8JBHSVFFN6sTTdbsjfDaBrfm1/ZE6T8zUEgNjg+FEq1r4fcClCFw0fu5CGreC0VODKNyJosTZwOnIRE0ya9CIuGubdgPx7qa15t0WprVScfj1JqqnY/ai6uZkgfk2PNQ3I7N4E0Nkqgrj4l0xp/9wk141EIGydAq6skYY/FGgz/cY9AJp5pRtXgowcSeqsLDi7Fau7aJQChvjQKtgNyCB+npFXRLpIZJUGA4zxpOhDwGvqtYhSyjyksODmcfzjR8f2bBohjgZOwn8c3FxHxtcgVvgZVl5+wjXD2lq4jqYAK2N2JCBVahtLPFGsvT8aFCBU0oRwEYThlN0zAp11pZ6baU0L+dXsQ+vHlXnE7gQdsW5bERN8m7rWJ1niQqDYz7rdKdJHGTuSyw77PJWGjuBqqwoiqhMdO6eFyVFlBUpn5XMZhWzaSAMcTSiJDWGOm5RDIcJW9sDEmv953QBaSLW5dh4GaoSnIa86K7+GLOsTBg1BhbxLCG1xGcwTICM463MpOCzVoSTyZA0SSiK0kZNCtGTiqJkepxzsJ/wo2sHke7EnF4MBgmiLfEfNDB+QX9iQ8wLZFHyFx/XwZWLVm092lIk3i07BaR5Y4XyHbChhGFVonA6bmHRxrqwyjakFJDFUZoWteMW83zpmOB061SaMibU5W+3O8fbsDOy8S7N4LX8Lo5AVVVeXNi/OWM2LZlNS/LCEITjI5MIJc5PYdj4YCmYZQnjyYDt7QFX7tvl3PkRk60MYzGRBB1A4XZ0SEpQm19zPMm89eLxUcHRYcHRQUE2SBgOU4ajlNHY/IFZpINhyoWLW4gI+3sztraGniAUhfmG69cPvd6hsOHUXnt1n8ODnIP9Gfdc3OLi5W12doembiVYolqOqeZaby/TRBCrSwi6ikiXgFPAmnvu1KWpaKyLn83gPi0TNCJYK4uXDTiRMIjI/cCXgcu2mSdV9Q9F5Ang14Br9tVPqerf2zKfBD4KlMBvqOo/Lo/SW8EpLG5tVbKy1A5/NgqQFaqsizzd+EU7VXy3i++0M9VlR4rld2edaEKsV14DP5sV5DPzW1XmWK6weoidvZlXuI3GKYOBkmaJo6u1vJlVpd6TEYLybjotOT7OkamQD1PyPIuSwYjf8ceTAXfdpVy8vG0sEG3shNms5OhwRp6b48t8VgKmvXxWmmNNmxout1yKF23UEE3XF865Syzn5cSN4MMRdCBBEelmUMvsax2G5fVRdVJC7RR1FViGYyiA31bVb4vILvAtEfmqffYHqvr78csi8jDwPbXTHAAACdxJREFUIeBngJ8AviYiP62q5Yq4LQRpuVqlVA3aqEOsKmgWtcY+YS0FVrDuTNwYFW38tjTZjXdzyDtKWTbBabLnvjgWf6I8CZ6DsPoTsfKupJhMT25SRyKDW7A+12OpIflqGeVy15Cl+ebNKYrZoXd2h4wnA4aKzZ5kZG9HhMrCOFHF4okjDk58mc1KhjNHpOxpgo2/aAjPmDR7mzFMsmLQ0WHOzb0peV6xf/OYg/2ZFTHUEzgnRrl+iRc3hXnP6VbSVGxCl8TrD7wuwQ5dbfQ8cQhDq7ToBKRFmG2hI6aK9tkTxOXVSMOJhEFVXwVetdc3ReR7wH0LijwGfEVVp8APROQl4D3Av62C2KIdeRmisGDptLbVGlehjT+PWpDmem08X5YbWYif+tbcRTTRFn9Zm04hfijRN9jcMkHjLjajtG0wlpO9SBzbKliZPZj72sxLltWu1Cz046PCn++D4w4yRmO7mCTEQdRKvLuyYpPAELJx5z7ykVJVhrMYDFIGIxCxHoqjhLsvbIElNs5UenvHKCP3bgy5cf3IRGMuKiOaDFNGo4zBIK1ZdsaEwtt52PtOZxKHfHPEtXXTiHUKbdyasERk52gWdLzbaZl6AqykYxCRdwI/C3wDeB/wCRH5MPBNDFfxJoZofD0q9r+0EBIR+RjwMYD773+HvXvydF/mM5vvLMP6dxKHZRqLKm9tp6vxSGbtRKqzzfaH6mdJ/cBLa7MnsDCxs07MCQgSzH2d7OzO4MvU6gHUOwDFYJSGiU0vJ76OmDg4gyiXgi5JhCpL0Cpo7QfDlNFEqQ4LY45cFJHCVCJiVHlZfzRSv2NLYcI+GfdlcwwynqRsbQ/YPW/sFW7uTbnx5hF7e1MO9meIJOzsDtk9P2Jre2CiRGvQJbhTBBEbcyERstTqE2w2ca9P8EroGhUIQ9gxvLVxjoctDC0nT7pGPSvK5UsTBhHZAf4K+C1V3RORzwOfsU1+Bvgs8KvL1qeqTwJPAly9+oiehPn8+jkbIf7EWro4+EYlK+tDHKtfXzutFZ3uS+tUru6kNX9O7vSS2pzIUdlEoiCoVlmplTP6sVGNEhuPQIXSZ4tRz4lUkdjhjjv9iUZeUeRaM3MG7G6cGE9L8MFSVbH+C0bnMT020mpsOCQAQ5fD0dzLBjCyJxY7u0POnR9xc2/mxYvxOOOcJQwuJkIIqBJSy6dZMFJyIowz1fZDAMvvTB7hBkTlu+bCnBTSVscKsBRhEJEBhij8mar+NYCqvhY9/wLwd/bfV4D7o+Jvt/cWgLZc2brnsTkR32UXqeeUWyrQRc/b6mph7zvZODfIjcfzOTIjHDQ8WLTn1OdiFHm5Cs8Nw2GvIlycsswZBhHVBTZeQCJkmVANhKIUHw1ZRBiOMl93WSqHh7ldoEEzn2Upk62M7Z0huy6t2iQDEY6PCm7uTTk8CArBnXNDhqPUOjqlfiFeurLFbFZxdJhzfFT4dPF5XlpnqYzxJGM0yrx5dKrBvForZTIxodkvXdn2+orjw4LKEkFDTIxNQ1kqpVVEqhoC6U5Dav2vipYE1+kOkaFzjkb0XOL/hRp316yhk2DoiXtuKyxzKiHAnwDfU9XPRffvtfoHgF8CnrPXTwF/LiKfwygfHwL+fXXUmh+7LMk7jTxwUturllxiJLp2BvAiqC58pq3PHNuhTn/gxArHDbgi4jgEqwOo6mfx7h3A75ImpbpZ3GlqbBNGY7Pwirz07xRF5U8hzEkASGJ28tEoZTzOGI8ztrbM4s2GqbGJmJbs3Zhy481jjg5zyrJiNM7IBiaz82SSMdkyMRG2tgdkWcL2ztBYFA7MaUVZVGZxRyHUJtuZieGgwdzYhXIvy2B5KBjxJbZsNNeGg1FrrYiGU4dw0kDUZ/ODq4R3WqW6qEittMzfrSk0m001pl78HavAMhzD+4BfAZ4VkaftvU8Bvywi77aovAz8ukXgeRH5S+C7mBONj590IuHncwS3KOqvFRaasy6D5KKPaXs29674XcbRybZ54SNKqVsAWtth1L7jApdKgolBKEa2Rk3GpMEg8UeYRW58EvLcKPLyPAQ6TTMxvgiWMMQh0cHoC44OcvauH7O3d8xsWnjz4eEwZTIZsGU5jYuXt30dQ7uYx5OMfBb8IZydhp9gti+c35HbeeO+MQFYqCliVdWcdHhFbIgJ0SZGek7Qs2fU+rRdZ3AC1N5RP8Tuod8oOubOqlaQclrvq7MEEbkGHAA/WjcuS8AF7gw84c7Btcfz7KEN159U1YvLFN4IwgAgIt9U1UfWjcdJcKfgCXcOrj2eZw+3imty8is99NDD/zfoCUMPPfQwB5tEGJ5cNwJLwp2CJ9w5uPZ4nj3cEq4bo2PooYceNgc2iWPooYceNgTWThhE5BdE5AUReUlEHl83Pk0QkZdF5FkReVpEvmnv3S0iXxWRF+3v29aA1xdF5HUReS6614qXGPgj28fPiMjVDcD1CRF5xfbr0yLyaPTskxbXF0Tk528jnveLyL+IyHdF5HkR+U17f6P6dQGeZ9ensWHL7f4DUuD7wIPAEPgO8PA6cWrB8WXgQuPe7wGP2+vHgd9dA14fAK4Cz52EF/Ao8A8Y85f3At/YAFyfAH6n5d2H7TwYAQ/Y+ZHeJjzvBa7a613gPy0+G9WvC/A8sz5dN8fwHuAlVf0vVZ0BX8G4bW86PAZ8yV5/CfjF242Aqv4r8EbjdhdejwFfVgNfB+4SkXtvD6aduHaBd9tX1R8Azm3/LQdVfVVVv22vbwIuxMBG9esCPLtg5T5dN2G4D/if6P9WF+01gwL/JCLfsq7iAJc1+In8EBPdahOgC69N7edPWBb8i5E4thG4NkIMbGy/NvCEM+rTdROGOwHer6pXgQ8CHxeRD8QP1fBqG3e0s6l4RfB54KeAd2MCAX12vegEaIYYiJ9tUr+24HlmfbpuwnAKF+3bC6r6iv19HfgbDAv2mmMZ7e/r68OwBl14bVw/q+prqlqqagV8gcDarhXXthADbGC/doVCOKs+XTdh+A/gIRF5QESGmFiRT60ZJw8isi0mziUisg38HMa9/CngI/a1jwB/ux4M56ALr6eAD1st+nuBGxFrvBZoyOJNt/0PichIRB7gFtz2T4FTa4gBNqxfu/A80z69HVrUEzSsj2K0qt8HPr1ufBq4PYjR5n4HeN7hB9wD/DPwIvA14O414PYXGHYxx8iMH+3CC6M1/2Pbx88Cj2wArn9qcXnGTtx7o/c/bXF9AfjgbcTz/Rgx4Rngafv36Kb16wI8z6xPe8vHHnroYQ7WLUr00EMPGwg9Yeihhx7moCcMPfTQwxz0hKGHHnqYg54w9NBDD3PQE4YeeuhhDnrC0EMPPcxBTxh66KGHOfg/7e2S4OJxY4oAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('ihc', 'he')\n"
     ]
    }
   ],
   "source": [
    "# Generator\n",
    "train_set = Dataset(he_indexes_train+ihc_h_indexes_train, ihc_ori_indexes_train, image_dict, augmentation=True)\n",
    "train_loader = torch.utils.data.DataLoader(train_set, batch_size=2, shuffle=True, num_workers=1, \n",
    "                                          )  # collate_fn=collate_fn)\n",
    "for image, real_h, stain_type in train_loader:\n",
    "    plt.imshow(normalize(np.transpose(image[0].numpy(), (1, 2, 0)), inverse=True))\n",
    "    plt.show()\n",
    "    plt.imshow(real_h[0].numpy()[0])\n",
    "    plt.colorbar()\n",
    "    plt.show()\n",
    "    print(stain_type)\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3) Create model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "######## Activations ########\n",
    "\n",
    "class MishFunction(torch.autograd.Function):\n",
    "    @staticmethod\n",
    "    def forward(ctx, x):\n",
    "        ctx.save_for_backward(x)\n",
    "        return x * torch.tanh(F.softplus(x))   # x * tanh(ln(1 + exp(x)))\n",
    "\n",
    "    @staticmethod\n",
    "    def backward(ctx, grad_output):\n",
    "        x = ctx.saved_variables[0]\n",
    "        sigmoid = torch.sigmoid(x)\n",
    "        tanh_sp = torch.tanh(F.softplus(x)) \n",
    "        return grad_output * (tanh_sp + x * sigmoid * (1 - tanh_sp * tanh_sp))\n",
    "\n",
    "class Mish(nn.Module):\n",
    "    def forward(self, x):\n",
    "        return MishFunction.apply(x)\n",
    "    \n",
    "######## Blocks ########\n",
    "    \n",
    "class ResidualBlock(nn.Module):\n",
    "    def __init__(self, channels, activation=nn.PReLU()):\n",
    "        super(ResidualBlock, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)\n",
    "        self.bn1 = nn.BatchNorm2d(channels)\n",
    "        self.activation = activation\n",
    "        self.conv2 = nn.Conv2d(channels, channels, kernel_size=3, padding=1)\n",
    "        self.bn2 = nn.BatchNorm2d(channels)\n",
    "\n",
    "    def forward(self, x):\n",
    "        residual = self.conv1(x)\n",
    "        residual = self.bn1(residual)\n",
    "        residual = self.activation(residual)\n",
    "        residual = self.conv2(residual)\n",
    "        residual = self.bn2(residual)\n",
    "\n",
    "        return self.activation(x + residual)\n",
    "    \n",
    "######## Encoder ########\n",
    "    \n",
    "class ODEncoder(nn.Module):\n",
    "    def __init__(self, activation=nn.PReLU()):\n",
    "        '''\n",
    "        Args:\n",
    "            activation: nn.PReLU(), nn.ReLU(), nn.LeakyReLU(0.2), Mish()\n",
    "        '''\n",
    "        super(ODEncoder, self).__init__()\n",
    "        self.block1 = nn.Sequential(\n",
    "            nn.Conv2d(3, 64, kernel_size=9, padding=4),\n",
    "            activation\n",
    "        )\n",
    "        self.block2 = ResidualBlock(64, activation)\n",
    "        self.block3 = ResidualBlock(64, activation)\n",
    "        self.block4 = ResidualBlock(64, activation)\n",
    "        self.block5 = ResidualBlock(64, activation)\n",
    "        self.block6 = ResidualBlock(64, activation)\n",
    "        self.block7 = nn.Sequential(\n",
    "            nn.Conv2d(64, 6, kernel_size=3, padding=1),\n",
    "            nn.BatchNorm2d(6)\n",
    "        )\n",
    "        \n",
    "        self.block8 = nn.Sequential(\n",
    "            nn.Conv2d(64, 32, kernel_size=3, padding=1),\n",
    "            nn.Conv2d(32, 32, kernel_size=3, padding=1),\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
    "            nn.BatchNorm2d(32),\n",
    "            activation,\n",
    "            nn.Conv2d(32, 32, kernel_size=3, padding=1),\n",
    "            nn.Conv2d(32, 32, kernel_size=3, padding=1),\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
    "            nn.BatchNorm2d(32),\n",
    "            activation,\n",
    "            nn.Conv2d(32, 32, kernel_size=3, padding=1),\n",
    "            nn.Conv2d(32, 32, kernel_size=3, padding=1),\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
    "            nn.BatchNorm2d(32),\n",
    "            activation,\n",
    "            nn.Conv2d(32, 32, kernel_size=3, padding=1),\n",
    "            nn.Conv2d(32, 32, kernel_size=3, padding=1),\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
    "            nn.BatchNorm2d(32),\n",
    "            activation,\n",
    "            nn.AdaptiveMaxPool2d((1, 1))\n",
    "        )\n",
    "        self.block9 = nn.Sequential(\n",
    "            nn.Linear(32, 3*3),\n",
    "            activation\n",
    "        )\n",
    "        self.block10 = nn.Sequential(\n",
    "            nn.Linear(32, 2), \n",
    "            activation\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        block1 = self.block1(x)\n",
    "        block2 = self.block2(block1)\n",
    "        block3 = self.block3(block2)\n",
    "        block4 = self.block4(block3)\n",
    "        block5 = self.block5(block4)\n",
    "        block6 = self.block6(block5)\n",
    "        block7 = self.block7(block1 + block6)\n",
    "        \n",
    "        block8 = self.block8(block1)\n",
    "        block8 = block8.view(-1, 32)\n",
    "        block9 = self.block9(block8)\n",
    "        block9 = block9.view(-1, 3, 3)\n",
    "        block9 = torch.sqrt(F.softmax(block9, -1))\n",
    "        block10 = self.block10(block8)\n",
    "\n",
    "        return nn.ReLU()(block7), block9, block10\n",
    "    \n",
    "def reconstruct(ODs, stain_OD_norm, device):\n",
    "    '''Reconstruct image from different stains\n",
    "    \n",
    "    Args:\n",
    "        ODs: [B, n_stains, H, W]\n",
    "        stain_OD_norm: [n_stains, 3 (R, G, B)] or [B, n_stains, 3 (R, G, B)]\n",
    "    '''\n",
    "    if not isinstance(ODs, torch.Tensor):\n",
    "        ODs = torch.tensor(ODs).float()\n",
    "    if not isinstance(stain_OD_norm, torch.Tensor):\n",
    "        stain_OD_norm = torch.tensor(stain_OD_norm)\n",
    "    if len(ODs.size()) != 4:\n",
    "        raise Exception(\"ODs should be of shape [B, n_stains, H, W]\")\n",
    "    if len(stain_OD_norm.size()) == 2:\n",
    "        # If the batch of images have the same stain_OD_norm\n",
    "        ODs = ODs.permute(0, 2, 3, 1)\n",
    "        ODs = ODs.to(device)\n",
    "        stain_OD_norm = stain_OD_norm.to(device)\n",
    "        stain_OD_norm = stain_OD_norm.float()\n",
    "        reconstructed = torch.matmul(ODs, stain_OD_norm)\n",
    "        reconstructed = torch.exp(torch.neg(reconstructed.permute(0, 3, 1, 2)))\n",
    "    elif len(stain_OD_norm.size()) == 3:\n",
    "        # If the batch of images have different stain_OD_norms\n",
    "        size = ODs.size()\n",
    "        ODs = ODs.view(size[0], size[1], size[2] * size[3])\n",
    "        ODs = ODs.permute(0, 2, 1)\n",
    "        ODs = ODs.to(device)\n",
    "        stain_OD_norm = stain_OD_norm.to(device)\n",
    "        stain_OD_norm = stain_OD_norm.float()\n",
    "        reconstructed = torch.bmm(ODs, stain_OD_norm)  #[B, H*W, 3]\n",
    "        reconstructed = torch.exp(torch.neg(reconstructed.permute(0, 2, 1)))\n",
    "        reconstructed = reconstructed.view(size[0], 3, size[2], size[3])\n",
    "    return reconstructed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Losses\n",
    "import torch\n",
    "from torch import nn\n",
    "from torchvision.models.vgg import vgg16\n",
    "from torchvision.transforms import Normalize\n",
    "\n",
    "class ReconstructionLoss(nn.Module):\n",
    "    def __init__(self, weight=None):\n",
    "        super(ReconstructionLoss, self).__init__()\n",
    "        vgg = vgg16(pretrained=True)\n",
    "        loss_network = nn.Sequential(*list(vgg.features)[:31]).eval()\n",
    "        for param in loss_network.parameters():\n",
    "            param.requires_grad = False\n",
    "        self.loss_network = loss_network\n",
    "        self.mse_loss = nn.MSELoss()\n",
    "        self.mean=[0.485, 0.456, 0.406]\n",
    "        self.std=[0.229, 0.224, 0.225]\n",
    "        if weight is None:\n",
    "            self.weight_image_loss = 10\n",
    "            self.weight_perceptual_loss = 1\n",
    "            self.weight_bg_penalty = 0.1\n",
    "            self.weight_stain_penalty = 0.1\n",
    "            self.weight_h_sparsity = 0.1\n",
    "            self.weight_e_penalty = 0.1\n",
    "            self.weight_cov_penalty = 1\n",
    "        else:\n",
    "            self.weight_image_loss = weight[0]\n",
    "            self.weight_perceptual_loss = weight[1]\n",
    "            self.weight_bg_penalty = weight[2]\n",
    "            self.weight_stain_penalty = weight[3]\n",
    "            self.weight_h_sparsity = weight[4]\n",
    "            if len(weight) > 5:\n",
    "                self.weight_e_penalty = weight[5]\n",
    "            else:\n",
    "                self.weight_e_penalty = 0\n",
    "            if len(weight) > 6:\n",
    "                self.weight_cov_penalty = weight[6]\n",
    "            else:\n",
    "                self.weight_cov_penalty = 0\n",
    "        \n",
    "    def forward(self, recon_images_exact, recon_images_valid, target_images, ODs, stain_types):\n",
    "        '''\n",
    "        Args:\n",
    "            recon_images: in shape [b, c, h, w]. exact: use all channels; valid: use valid channels\n",
    "        '''\n",
    "        # Image Loss\n",
    "        image_loss = self.mse_loss(recon_images_exact, target_images)\n",
    "        \n",
    "        # Perceptual Loss\n",
    "        recon_images_n = recon_images_valid.clone()\n",
    "        target_images_n = target_images.clone()\n",
    "        for ch in range(3):\n",
    "            recon_images_n[:, ch, ...] = (recon_images_valid[:, ch, ...] - self.mean[ch])/self.std[ch]\n",
    "            target_images_n[:, ch, ...] = (target_images[:, ch, ...] - self.mean[ch])/self.std[ch]\n",
    "        perceptual_loss = self.mse_loss(self.loss_network(recon_images_n), \n",
    "                                        self.loss_network(target_images_n))\n",
    "        # Background penalty\n",
    "        for i, stain_type in enumerate(stain_types):\n",
    "            if i != 0:\n",
    "                if stain_type == \"he\":\n",
    "                    bg_penalty += torch.mean(ODs[i, [2, 3, 4, 5], ...])\n",
    "                elif stain_type == \"ihc\":\n",
    "                    bg_penalty += torch.mean(ODs[i, [1, 3, 4, 5], ...])\n",
    "            else:\n",
    "                if stain_type == \"he\":\n",
    "                    bg_penalty = torch.mean(ODs[i, [2, 3, 4, 5], ...])\n",
    "                elif stain_type == \"ihc\":\n",
    "                    bg_penalty = torch.mean(ODs[i, [1, 3, 4, 5], ...])\n",
    "        bg_penalty = torch.div(bg_penalty, i + 1)\n",
    "                    \n",
    "        # Stain penalty\n",
    "        for i, stain_type in enumerate(stain_types):\n",
    "            if i != 0:\n",
    "                if stain_type == \"he\":\n",
    "                    stain_penalty += torch.mean(ODs[i, [0, 1], ...])\n",
    "                elif stain_type == \"ihc\":\n",
    "                    stain_penalty += torch.mean(ODs[i, [0, 2], ...])\n",
    "            else:\n",
    "                if stain_type == \"he\":\n",
    "                    stain_penalty = torch.mean(ODs[i, [0, 1], ...])\n",
    "                elif stain_type == \"ihc\":\n",
    "                    stain_penalty = torch.mean(ODs[i, [0, 2], ...])\n",
    "        stain_penalty = torch.div(stain_penalty, i + 1)\n",
    "        \n",
    "        # H sparsity\n",
    "        h_sparsity = torch.sum(ODs[:, 0, ...]).float()/ODs.size()[0]/ODs.size()[2]/ODs.size()[3]\n",
    "        \n",
    "        # E penalty\n",
    "        j = 0\n",
    "        for i, stain_type in enumerate(stain_types):\n",
    "            if j != 0:\n",
    "                if stain_type == \"he\":\n",
    "                    e_penalty += torch.mean(ODs[i, [1], ...])\n",
    "            else:\n",
    "                if stain_type == \"he\":\n",
    "                    e_penalty = torch.mean(ODs[i, [1], ...])\n",
    "                    j += 1\n",
    "        e_penalty = torch.div(e_penalty, i + 1)\n",
    "        \n",
    "        # Covariance penalty\n",
    "        cov_penalty = torch.mean(ODs[:, 0, ...] * ODs[:, 1, ...]) - torch.mean(ODs[:, 0, ...]) * torch.mean(ODs[:, 1, ...])\n",
    "        \n",
    "        self.image_loss = self.weight_image_loss * image_loss\n",
    "        self.perceptual_loss = self.weight_perceptual_loss * perceptual_loss\n",
    "        self.bg_penalty = self.weight_bg_penalty * bg_penalty\n",
    "        self.stain_penalty = self.weight_stain_penalty * stain_penalty\n",
    "        self.h_sparsity = self.weight_h_sparsity * h_sparsity\n",
    "        self.e_penalty = self.weight_e_penalty * e_penalty\n",
    "        self.cov_penalty = self.weight_cov_penalty * cov_penalty\n",
    "        \n",
    "        return self.image_loss + self.perceptual_loss + self.bg_penalty + self.stain_penalty + self.h_sparsity + self.e_penalty \\\n",
    "                 + self.cov_penalty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "# self-defined functions\n",
    "from util.image_pool import ImagePool\n",
    "import networks\n",
    "\n",
    "class DeconvGAN():\n",
    "    def __init__(self, is_train=True, device=\"0\", activation=Mish(), weight=[10, 1, 0.1, 0, 0, 0, 0], \n",
    "                lr=0.0002, beta1=0.5, save_dir=\"./models/\", n_epochs=500, n_epochs_decay=100):\n",
    "        self.is_train = is_train\n",
    "        self.device = device\n",
    "        self.save_dir = save_dir  # which folder to save models\n",
    "        self.n_epochs = n_epochs\n",
    "        self.n_epochs_decay = n_epochs_decay\n",
    "        \n",
    "        if self.is_train:\n",
    "            self.model_names = ['G', 'D']\n",
    "        else:\n",
    "            self.model_names = ['G']\n",
    "\n",
    "        # define networks \n",
    "        self.netG = ODEncoder(activation=activation)\n",
    "        self.netG = self.netG.to(self.device)\n",
    "\n",
    "        if self.is_train:  # define discriminators\n",
    "            '''    Parameters:\n",
    "            input_nc (int)     -- the number of channels in input images\n",
    "            ndf (int)          -- the number of filters in the first conv layer\n",
    "            netD (str)         -- the architecture's name: basic | n_layers | pixel\n",
    "            n_layers_D (int)   -- the number of conv layers in the discriminator; effective when netD=='n_layers'\n",
    "            norm (str)         -- the type of normalization layers used in the network.\n",
    "            init_type (str)    -- the name of the initialization method.\n",
    "            init_gain (float)  -- scaling factor for normal, xavier and orthogonal.\n",
    "            gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2'''\n",
    "            self.netD = networks.define_D(input_nc=1, ndf=64, netD=\"basic\", n_layers_D=3,\n",
    "                                          norm=\"instance\", init_type=\"normal\", init_gain=0.02, gpu_ids=[device])\n",
    "            \n",
    "        self.criterionRec = ReconstructionLoss(weight=weight).to(self.device)\n",
    "        \n",
    "        if self.is_train:\n",
    "            self.fake_pool = ImagePool(50)\n",
    "            # define loss functions\n",
    "            self.criterionGAN = networks.GANLoss(\"lsgan\").to(self.device)  # define GAN loss.\n",
    "            # initialize optimizers\n",
    "            self.optimizers = []\n",
    "            self.optimizer_G = torch.optim.Adam(self.netG.parameters(), lr=lr, betas=(beta1, 0.999))\n",
    "            self.optimizer_D = torch.optim.Adam(self.netD.parameters(), lr=lr, betas=(beta1, 0.999))\n",
    "            self.optimizers.append(self.optimizer_G)\n",
    "            self.optimizers.append(self.optimizer_D)\n",
    "            self.schedulers = [networks.get_scheduler(optimizer, lr_policy=\"linear\", \n",
    "                                                      n_epochs=n_epochs, n_epochs_decay=n_epochs_decay) for optimizer in self.optimizers]\n",
    "\n",
    "    def set_input(self, data):\n",
    "        \"\"\"Unpack input data from the dataloader and perform necessary pre-processing steps.\n",
    "        Parameters:\n",
    "            input (dict): include the data itself and its metadata information.\n",
    "        \"\"\"\n",
    "        self.images = data[0].float().to(self.device)\n",
    "        self.real_hs = data[1].float().to(self.device)\n",
    "        self.stain_types = data[2]\n",
    "\n",
    "    def forward(self, val=False):\n",
    "        \"\"\"Run forward pass; called by both functions <optimize_parameters> and <test>.\"\"\"\n",
    "        if val:\n",
    "            self.netG.eval()\n",
    "        else:\n",
    "            self.netG.train()\n",
    "        self.ODs, self.stain_OD_norm_preds, self.params_lt = self.netG(self.images)\n",
    "        self.fake_hs = torch.log(self.ODs[:, 0:1, ...] + 1) * self.params_lt[:, 0, None, None, None] + \\\n",
    "                                 self.params_lt[:, 1, None, None, None]\n",
    "        \n",
    "        # Add rgb to ODs\n",
    "        rgb_ODs = torch.stack([torch.tensor([[0, 0.70711, 0.70711], \n",
    "                                             [0.70711, 0, 0.70711], \n",
    "                                             [0.70711, 0.70711, 0]]) for _ in range(self.ODs.size()[0])], 0)\n",
    "        self.stain_OD_norm_preds = torch.cat([self.stain_OD_norm_preds, rgb_ODs.to(self.device)], 1)\n",
    "        \n",
    "        self.recon_images_exact = reconstruct(self.ODs, self.stain_OD_norm_preds, self.device)\n",
    "        self.recon_images_valid = torch.zeros_like(self.recon_images_exact).to(self.device)\n",
    "        for i, stain_type in enumerate(self.stain_types):\n",
    "            if stain_type == \"he\":\n",
    "                self.recon_images_valid[i:i+1, ...] = reconstruct(self.ODs[i:i+1, 0:2, ...], \n",
    "                                                             self.stain_OD_norm_preds[i:i+1, 0:2, ...], self.device)\n",
    "            if stain_type == \"ihc\":\n",
    "                self.recon_images_valid[i:i+1, ...] = reconstruct(self.ODs[i:i+1, [0, 2], ...], \n",
    "                                                             self.stain_OD_norm_preds[i:i+1, [0, 2], ...], self.device)\n",
    "        self.loss_rec = self.criterionRec(self.recon_images_exact, self.recon_images_valid, self.images, self.ODs, self.stain_types)\n",
    "        self.image_loss = self.criterionRec.image_loss\n",
    "        self.perceptual_loss = self.criterionRec.perceptual_loss\n",
    "        self.bg_penalty = self.criterionRec.bg_penalty\n",
    "        self.stain_penalty = self.criterionRec.stain_penalty\n",
    "        self.h_sparsity = self.criterionRec.h_sparsity\n",
    "        self.e_penalty = self.criterionRec.e_penalty\n",
    "        self.cov_penalty = self.criterionRec.cov_penalty\n",
    "\n",
    "    def backward_D_basic(self, netD, real, fake, val=False):\n",
    "        \"\"\"Calculate GAN loss for the discriminator\n",
    "        Parameters:\n",
    "            netD (network)      -- the discriminator D\n",
    "            real (tensor array) -- real images\n",
    "            fake (tensor array) -- images generated by a generator\n",
    "        Return the discriminator loss.\n",
    "        We also call loss_D.backward() to calculate the gradients.\n",
    "        \"\"\"\n",
    "        # Real\n",
    "        pred_real = netD(real)\n",
    "        loss_D_real = self.criterionGAN(pred_real, True)\n",
    "        # Fake\n",
    "        pred_fake = netD(fake.detach())\n",
    "        loss_D_fake = self.criterionGAN(pred_fake, False)\n",
    "        # Combined loss and calculate gradients\n",
    "        loss_D = (loss_D_real + loss_D_fake) * 0.5\n",
    "        if not val:\n",
    "            loss_D.backward()\n",
    "        return loss_D\n",
    "\n",
    "    def backward_D(self, val=False):\n",
    "        \"\"\"Calculate GAN loss for discriminator D_A\"\"\"\n",
    "        fake_hs = self.fake_pool.query(self.fake_hs)\n",
    "        self.loss_D = self.backward_D_basic(self.netD, self.real_hs, fake_hs, val=val)\n",
    "\n",
    "    def backward_G(self, val=False):\n",
    "        \"\"\"Calculate the loss for generator G\"\"\"\n",
    "\n",
    "        # GAN loss\n",
    "        self.loss_gan = self.criterionGAN(self.netD(self.fake_hs), True)\n",
    "        # combined loss and calculate gradients\n",
    "        self.loss_G = self.loss_gan + self.loss_rec\n",
    "        \n",
    "        if not val:\n",
    "            self.loss_G.backward()\n",
    "            \n",
    "    def set_requires_grad(self, nets, requires_grad=False):\n",
    "        \"\"\"Set requies_grad=Fasle for all the networks to avoid unnecessary computations\n",
    "        Parameters:\n",
    "            nets (network list)   -- a list of networks\n",
    "            requires_grad (bool)  -- whether the networks require gradients or not\n",
    "        \"\"\"\n",
    "        if not isinstance(nets, list):\n",
    "            nets = [nets]\n",
    "        for net in nets:\n",
    "            if net is not None:\n",
    "                for param in net.parameters():\n",
    "                    param.requires_grad = requires_grad\n",
    "\n",
    "    def optimize_parameters(self):\n",
    "        \"\"\"Calculate losses, gradients, and update network weights; called in every training iteration\"\"\"\n",
    "        # forward\n",
    "        self.forward()      # compute fake images and reconstruction images.\n",
    "        # G\n",
    "        self.set_requires_grad([self.netD], False)  # Ds require no gradients when optimizing Gs\n",
    "        self.optimizer_G.zero_grad()  # set G_A and G_B's gradients to zero\n",
    "        self.backward_G()             # calculate gradients for G_A and G_B\n",
    "        self.optimizer_G.step()       # update G_A and G_B's weights\n",
    "        # D\n",
    "        self.set_requires_grad([self.netD], True)\n",
    "        self.optimizer_D.zero_grad()   # set D_A and D_B's gradients to zero\n",
    "        self.backward_D()      # calculate gradients for D_A\n",
    "        self.optimizer_D.step()  # update D_A and D_B's weights\n",
    "        \n",
    "    def forward_wo_optimize_parameters(self):\n",
    "        \"\"\"Calculate losses in validation set, run within torch.no_grad()\"\"\"\n",
    "        # forward\n",
    "        self.forward(val=True)\n",
    "        self.backward_G(val=True)\n",
    "        self.backward_D(val=True) \n",
    "        \n",
    "    def save_networks(self, epoch):\n",
    "        \"\"\"Save all the networks to the disk.\n",
    "        Parameters:\n",
    "            epoch (int) -- current epoch; used in the file name '%s_net_%s.pth' % (epoch, name)\n",
    "        \"\"\"\n",
    "        for name in self.model_names:\n",
    "            if isinstance(name, str):\n",
    "                save_filename = '%s_net_%s.pth' % (epoch, name)\n",
    "                save_path = os.path.join(self.save_dir, save_filename)\n",
    "                net = getattr(self, 'net' + name)\n",
    "\n",
    "                if isinstance(net, torch.nn.DataParallel):\n",
    "                    torch.save(net.module.state_dict(), save_path)\n",
    "                else:\n",
    "                    torch.save(net.state_dict(), save_path)\n",
    "\n",
    "    def load_networks(self, epoch):\n",
    "        \"\"\"Load all the networks from the disk.\n",
    "        Parameters:\n",
    "            epoch (int) -- current epoch; used in the file name '%s_net_%s.pth' % (epoch, name)\n",
    "        \"\"\"\n",
    "        for name in self.model_names:\n",
    "            if isinstance(name, str):\n",
    "                load_filename = '%s_net_%s.pth' % (epoch, name)\n",
    "                load_path = os.path.join(self.save_dir, load_filename)\n",
    "                net = getattr(self, 'net' + name)\n",
    "                if isinstance(net, torch.nn.DataParallel):\n",
    "                    net = net.module\n",
    "                print('loading the model from %s' % load_path)\n",
    "                # if you are using PyTorch newer than 0.4 (e.g., built from\n",
    "                # GitHub source), you can remove str() on self.device\n",
    "                state_dict = torch.load(load_path, map_location=str(self.device))\n",
    "                if hasattr(state_dict, '_metadata'):\n",
    "                    del state_dict._metadata\n",
    "\n",
    "                # patch InstanceNorm checkpoints prior to 0.4\n",
    "                # for key in list(state_dict.keys()):  # need to copy keys here because we mutate in loop\n",
    "                #     self.__patch_instance_norm_state_dict(state_dict, net, key.split('.'))\n",
    "                net.load_state_dict(state_dict)\n",
    "                \n",
    "    def update_learning_rate(self):\n",
    "        \"\"\"Update learning rates for all the networks; called at the end of every epoch\"\"\"\n",
    "        old_lr = self.optimizers[0].param_groups[0]['lr']\n",
    "        for scheduler in self.schedulers:\n",
    "            scheduler.step()\n",
    "\n",
    "        lr = self.optimizers[0].param_groups[0]['lr']\n",
    "        print('learning rate %.7f -> %.7f' % (old_lr, lr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loading the model from ./models/deconv-GAN-512-40X-9/599_net_G.pth\n"
     ]
    }
   ],
   "source": [
    "# Create model dir\n",
    "model_dir = \"./models/deconv-GAN-512-40X-9\"\n",
    "if not os.path.exists(model_dir):\n",
    "    os.mkdir(model_dir)\n",
    "\n",
    "model = DeconvGAN(is_train=False, device=torch.device(\"cuda:0\"), save_dir=model_dir, weight=[200, 1, 10, 0, 0.1, 0.2, 0.2])\n",
    "\n",
    "# Load model\n",
    "model.load_networks(599)  #"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4) Evaluate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_stain_OD_norm_gt(df, image_name, bg=(0.754000, 0.077000, 0.652000)):\n",
    "    OD_h = df.loc[df['image name'] == image_name, (\"hR\", \"hG\", \"hB\")].values\n",
    "    OD_e = df.loc[df['image name'] == image_name, (\"eR\", \"eG\", \"eB\")].values\n",
    "    OD_h = -np.log(OD_h / 255 + 0.0001)\n",
    "    OD_h = (OD_h.T/np.linalg.norm(OD_h, axis=1).T).T\n",
    "    OD_h = np.mean(OD_h, axis=0)\n",
    "    OD_h /= np.linalg.norm(OD_h)\n",
    "    OD_e = -np.log(OD_e / 255 + 0.0001)\n",
    "    OD_e = (OD_e.T/np.linalg.norm(OD_e, axis=1).T).T\n",
    "    OD_e = np.mean(OD_e, axis=0)\n",
    "    OD_e /= np.linalg.norm(OD_e)\n",
    "    OD_norm = np.asarray((OD_h, OD_e, bg))\n",
    "    return torch.tensor(OD_norm)\n",
    "\n",
    "def preprocess(image, image_size):\n",
    "    if image.size()[2] < image_size:\n",
    "        image_temp = torch.zeros(image.size()[0], image.size()[1], image_size, image_size)\n",
    "        start = int((image_size - image.size()[2])/2)\n",
    "        image_temp[:, :, start:start + image.size()[2], start:start + image.size()[2]] = image\n",
    "        image = image_temp.contiguous()\n",
    "    return image\n",
    "\n",
    "def postprocess(image, origin_size):\n",
    "    if image.size()[2] > origin_size:\n",
    "        start = -int((origin_size - image.size()[2])/2)\n",
    "        image_temp = image[:, :, start:start + origin_size, start:start + origin_size]\n",
    "        image = image_temp.contiguous()\n",
    "    return image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define stain_OD_norm for HE deconv\n",
    "stain_OD_deconv = [[0.644211, 0.716556, 0.266844],  # Hematoxylin\n",
    "                   [0.092789, 0.964111, 0.283111],  # Eosin\n",
    "                   [0.754000, 0.077000, 0.652000]  # Bg\n",
    "                  ]\n",
    "stain_OD_norm_deconv = []\n",
    "for r in stain_OD_deconv:\n",
    "    stain_OD_norm_deconv.append(r/np.linalg.norm(r))\n",
    "stain_OD_norm_deconv = torch.tensor(np.asarray(stain_OD_norm_deconv))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>image name</th>\n",
       "      <th>hR</th>\n",
       "      <th>hG</th>\n",
       "      <th>hB</th>\n",
       "      <th>eR</th>\n",
       "      <th>eG</th>\n",
       "      <th>eB</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10878_2_10.png</td>\n",
       "      <td>31</td>\n",
       "      <td>11</td>\n",
       "      <td>41</td>\n",
       "      <td>110</td>\n",
       "      <td>42</td>\n",
       "      <td>75</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10878_2_10.png</td>\n",
       "      <td>31</td>\n",
       "      <td>14</td>\n",
       "      <td>19</td>\n",
       "      <td>137</td>\n",
       "      <td>54</td>\n",
       "      <td>91</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10878_2_10.png</td>\n",
       "      <td>22</td>\n",
       "      <td>10</td>\n",
       "      <td>38</td>\n",
       "      <td>189</td>\n",
       "      <td>113</td>\n",
       "      <td>143</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>10878_2_10.png</td>\n",
       "      <td>30</td>\n",
       "      <td>8</td>\n",
       "      <td>35</td>\n",
       "      <td>225</td>\n",
       "      <td>116</td>\n",
       "      <td>143</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>10878_2_10.png</td>\n",
       "      <td>17</td>\n",
       "      <td>12</td>\n",
       "      <td>42</td>\n",
       "      <td>220</td>\n",
       "      <td>124</td>\n",
       "      <td>163</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>10878_2_8.png</td>\n",
       "      <td>72</td>\n",
       "      <td>33</td>\n",
       "      <td>89</td>\n",
       "      <td>249</td>\n",
       "      <td>131</td>\n",
       "      <td>170</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>10878_2_8.png</td>\n",
       "      <td>83</td>\n",
       "      <td>29</td>\n",
       "      <td>80</td>\n",
       "      <td>251</td>\n",
       "      <td>112</td>\n",
       "      <td>141</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>10878_2_8.png</td>\n",
       "      <td>34</td>\n",
       "      <td>20</td>\n",
       "      <td>59</td>\n",
       "      <td>219</td>\n",
       "      <td>137</td>\n",
       "      <td>158</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>10878_2_8.png</td>\n",
       "      <td>65</td>\n",
       "      <td>27</td>\n",
       "      <td>75</td>\n",
       "      <td>168</td>\n",
       "      <td>61</td>\n",
       "      <td>112</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>10878_2_8.png</td>\n",
       "      <td>78</td>\n",
       "      <td>36</td>\n",
       "      <td>99</td>\n",
       "      <td>226</td>\n",
       "      <td>115</td>\n",
       "      <td>150</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>10878_2_9.png</td>\n",
       "      <td>75</td>\n",
       "      <td>39</td>\n",
       "      <td>95</td>\n",
       "      <td>250</td>\n",
       "      <td>154</td>\n",
       "      <td>182</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>10878_2_9.png</td>\n",
       "      <td>35</td>\n",
       "      <td>15</td>\n",
       "      <td>46</td>\n",
       "      <td>199</td>\n",
       "      <td>107</td>\n",
       "      <td>145</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>10878_2_9.png</td>\n",
       "      <td>89</td>\n",
       "      <td>54</td>\n",
       "      <td>112</td>\n",
       "      <td>208</td>\n",
       "      <td>98</td>\n",
       "      <td>127</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>10878_2_9.png</td>\n",
       "      <td>71</td>\n",
       "      <td>37</td>\n",
       "      <td>88</td>\n",
       "      <td>181</td>\n",
       "      <td>88</td>\n",
       "      <td>121</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>10878_2_9.png</td>\n",
       "      <td>66</td>\n",
       "      <td>28</td>\n",
       "      <td>87</td>\n",
       "      <td>164</td>\n",
       "      <td>67</td>\n",
       "      <td>96</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>11460_1_10.png</td>\n",
       "      <td>60</td>\n",
       "      <td>26</td>\n",
       "      <td>71</td>\n",
       "      <td>218</td>\n",
       "      <td>138</td>\n",
       "      <td>148</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>11460_1_10.png</td>\n",
       "      <td>57</td>\n",
       "      <td>27</td>\n",
       "      <td>67</td>\n",
       "      <td>227</td>\n",
       "      <td>153</td>\n",
       "      <td>189</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>11460_1_10.png</td>\n",
       "      <td>96</td>\n",
       "      <td>53</td>\n",
       "      <td>91</td>\n",
       "      <td>204</td>\n",
       "      <td>151</td>\n",
       "      <td>152</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>11460_1_10.png</td>\n",
       "      <td>51</td>\n",
       "      <td>36</td>\n",
       "      <td>84</td>\n",
       "      <td>217</td>\n",
       "      <td>132</td>\n",
       "      <td>155</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>11460_1_10.png</td>\n",
       "      <td>71</td>\n",
       "      <td>44</td>\n",
       "      <td>90</td>\n",
       "      <td>218</td>\n",
       "      <td>126</td>\n",
       "      <td>130</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>11460_1_2.png</td>\n",
       "      <td>91</td>\n",
       "      <td>63</td>\n",
       "      <td>105</td>\n",
       "      <td>224</td>\n",
       "      <td>161</td>\n",
       "      <td>176</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>11460_1_2.png</td>\n",
       "      <td>100</td>\n",
       "      <td>65</td>\n",
       "      <td>116</td>\n",
       "      <td>227</td>\n",
       "      <td>166</td>\n",
       "      <td>192</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>11460_1_2.png</td>\n",
       "      <td>53</td>\n",
       "      <td>31</td>\n",
       "      <td>87</td>\n",
       "      <td>224</td>\n",
       "      <td>162</td>\n",
       "      <td>183</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>11460_1_2.png</td>\n",
       "      <td>84</td>\n",
       "      <td>44</td>\n",
       "      <td>85</td>\n",
       "      <td>206</td>\n",
       "      <td>133</td>\n",
       "      <td>170</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>11460_1_2.png</td>\n",
       "      <td>116</td>\n",
       "      <td>61</td>\n",
       "      <td>111</td>\n",
       "      <td>252</td>\n",
       "      <td>206</td>\n",
       "      <td>216</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>11460_1_3.png</td>\n",
       "      <td>59</td>\n",
       "      <td>28</td>\n",
       "      <td>66</td>\n",
       "      <td>229</td>\n",
       "      <td>140</td>\n",
       "      <td>169</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>11460_1_3.png</td>\n",
       "      <td>121</td>\n",
       "      <td>77</td>\n",
       "      <td>127</td>\n",
       "      <td>232</td>\n",
       "      <td>172</td>\n",
       "      <td>193</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>11460_1_3.png</td>\n",
       "      <td>103</td>\n",
       "      <td>59</td>\n",
       "      <td>106</td>\n",
       "      <td>210</td>\n",
       "      <td>143</td>\n",
       "      <td>167</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>11460_1_3.png</td>\n",
       "      <td>111</td>\n",
       "      <td>73</td>\n",
       "      <td>112</td>\n",
       "      <td>235</td>\n",
       "      <td>164</td>\n",
       "      <td>188</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>11460_1_3.png</td>\n",
       "      <td>50</td>\n",
       "      <td>28</td>\n",
       "      <td>74</td>\n",
       "      <td>239</td>\n",
       "      <td>188</td>\n",
       "      <td>209</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>130</th>\n",
       "      <td>NLSI0000078_2_10.png</td>\n",
       "      <td>102</td>\n",
       "      <td>103</td>\n",
       "      <td>147</td>\n",
       "      <td>159</td>\n",
       "      <td>133</td>\n",
       "      <td>169</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>131</th>\n",
       "      <td>NLSI0000078_2_10.png</td>\n",
       "      <td>95</td>\n",
       "      <td>93</td>\n",
       "      <td>140</td>\n",
       "      <td>142</td>\n",
       "      <td>127</td>\n",
       "      <td>160</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>132</th>\n",
       "      <td>NLSI0000078_2_10.png</td>\n",
       "      <td>130</td>\n",
       "      <td>124</td>\n",
       "      <td>162</td>\n",
       "      <td>117</td>\n",
       "      <td>93</td>\n",
       "      <td>128</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>133</th>\n",
       "      <td>NLSI0000078_2_10.png</td>\n",
       "      <td>81</td>\n",
       "      <td>80</td>\n",
       "      <td>130</td>\n",
       "      <td>165</td>\n",
       "      <td>144</td>\n",
       "      <td>175</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>134</th>\n",
       "      <td>NLSI0000078_2_10.png</td>\n",
       "      <td>89</td>\n",
       "      <td>88</td>\n",
       "      <td>140</td>\n",
       "      <td>139</td>\n",
       "      <td>116</td>\n",
       "      <td>155</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>135</th>\n",
       "      <td>NLSI0000078_2_6.png</td>\n",
       "      <td>98</td>\n",
       "      <td>91</td>\n",
       "      <td>133</td>\n",
       "      <td>176</td>\n",
       "      <td>163</td>\n",
       "      <td>190</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>136</th>\n",
       "      <td>NLSI0000078_2_6.png</td>\n",
       "      <td>108</td>\n",
       "      <td>97</td>\n",
       "      <td>146</td>\n",
       "      <td>184</td>\n",
       "      <td>168</td>\n",
       "      <td>196</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>137</th>\n",
       "      <td>NLSI0000078_2_6.png</td>\n",
       "      <td>96</td>\n",
       "      <td>94</td>\n",
       "      <td>146</td>\n",
       "      <td>154</td>\n",
       "      <td>133</td>\n",
       "      <td>168</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>138</th>\n",
       "      <td>NLSI0000078_2_6.png</td>\n",
       "      <td>68</td>\n",
       "      <td>68</td>\n",
       "      <td>119</td>\n",
       "      <td>157</td>\n",
       "      <td>128</td>\n",
       "      <td>160</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>139</th>\n",
       "      <td>NLSI0000078_2_6.png</td>\n",
       "      <td>57</td>\n",
       "      <td>53</td>\n",
       "      <td>96</td>\n",
       "      <td>197</td>\n",
       "      <td>163</td>\n",
       "      <td>190</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>140</th>\n",
       "      <td>NLSI0000078_2_7.png</td>\n",
       "      <td>89</td>\n",
       "      <td>82</td>\n",
       "      <td>131</td>\n",
       "      <td>165</td>\n",
       "      <td>147</td>\n",
       "      <td>177</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>141</th>\n",
       "      <td>NLSI0000078_2_7.png</td>\n",
       "      <td>90</td>\n",
       "      <td>80</td>\n",
       "      <td>139</td>\n",
       "      <td>164</td>\n",
       "      <td>139</td>\n",
       "      <td>174</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>142</th>\n",
       "      <td>NLSI0000078_2_7.png</td>\n",
       "      <td>73</td>\n",
       "      <td>73</td>\n",
       "      <td>124</td>\n",
       "      <td>155</td>\n",
       "      <td>130</td>\n",
       "      <td>163</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>143</th>\n",
       "      <td>NLSI0000078_2_7.png</td>\n",
       "      <td>81</td>\n",
       "      <td>84</td>\n",
       "      <td>131</td>\n",
       "      <td>162</td>\n",
       "      <td>140</td>\n",
       "      <td>172</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>144</th>\n",
       "      <td>NLSI0000078_2_7.png</td>\n",
       "      <td>82</td>\n",
       "      <td>80</td>\n",
       "      <td>130</td>\n",
       "      <td>175</td>\n",
       "      <td>151</td>\n",
       "      <td>185</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>145</th>\n",
       "      <td>NLSI0000078_2_8.png</td>\n",
       "      <td>77</td>\n",
       "      <td>77</td>\n",
       "      <td>127</td>\n",
       "      <td>149</td>\n",
       "      <td>132</td>\n",
       "      <td>163</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>146</th>\n",
       "      <td>NLSI0000078_2_8.png</td>\n",
       "      <td>103</td>\n",
       "      <td>102</td>\n",
       "      <td>150</td>\n",
       "      <td>128</td>\n",
       "      <td>98</td>\n",
       "      <td>135</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>147</th>\n",
       "      <td>NLSI0000078_2_8.png</td>\n",
       "      <td>104</td>\n",
       "      <td>99</td>\n",
       "      <td>141</td>\n",
       "      <td>152</td>\n",
       "      <td>132</td>\n",
       "      <td>164</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>148</th>\n",
       "      <td>NLSI0000078_2_8.png</td>\n",
       "      <td>81</td>\n",
       "      <td>82</td>\n",
       "      <td>144</td>\n",
       "      <td>167</td>\n",
       "      <td>146</td>\n",
       "      <td>176</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149</th>\n",
       "      <td>NLSI0000078_2_8.png</td>\n",
       "      <td>71</td>\n",
       "      <td>72</td>\n",
       "      <td>121</td>\n",
       "      <td>120</td>\n",
       "      <td>95</td>\n",
       "      <td>129</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>150</th>\n",
       "      <td>NLSI0000078_2_9.png</td>\n",
       "      <td>138</td>\n",
       "      <td>139</td>\n",
       "      <td>178</td>\n",
       "      <td>145</td>\n",
       "      <td>110</td>\n",
       "      <td>153</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>151</th>\n",
       "      <td>NLSI0000078_2_9.png</td>\n",
       "      <td>111</td>\n",
       "      <td>108</td>\n",
       "      <td>156</td>\n",
       "      <td>131</td>\n",
       "      <td>106</td>\n",
       "      <td>144</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>152</th>\n",
       "      <td>NLSI0000078_2_9.png</td>\n",
       "      <td>104</td>\n",
       "      <td>101</td>\n",
       "      <td>149</td>\n",
       "      <td>131</td>\n",
       "      <td>96</td>\n",
       "      <td>124</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>153</th>\n",
       "      <td>NLSI0000078_2_9.png</td>\n",
       "      <td>94</td>\n",
       "      <td>95</td>\n",
       "      <td>144</td>\n",
       "      <td>157</td>\n",
       "      <td>134</td>\n",
       "      <td>160</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>154</th>\n",
       "      <td>NLSI0000078_2_9.png</td>\n",
       "      <td>67</td>\n",
       "      <td>70</td>\n",
       "      <td>111</td>\n",
       "      <td>159</td>\n",
       "      <td>133</td>\n",
       "      <td>167</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>155</th>\n",
       "      <td>NLSI0000165_1_1.png</td>\n",
       "      <td>60</td>\n",
       "      <td>44</td>\n",
       "      <td>100</td>\n",
       "      <td>157</td>\n",
       "      <td>92</td>\n",
       "      <td>124</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>156</th>\n",
       "      <td>NLSI0000165_1_1.png</td>\n",
       "      <td>115</td>\n",
       "      <td>105</td>\n",
       "      <td>150</td>\n",
       "      <td>168</td>\n",
       "      <td>106</td>\n",
       "      <td>128</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>157</th>\n",
       "      <td>NLSI0000165_1_1.png</td>\n",
       "      <td>114</td>\n",
       "      <td>106</td>\n",
       "      <td>142</td>\n",
       "      <td>153</td>\n",
       "      <td>84</td>\n",
       "      <td>116</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>158</th>\n",
       "      <td>NLSI0000165_1_1.png</td>\n",
       "      <td>60</td>\n",
       "      <td>56</td>\n",
       "      <td>98</td>\n",
       "      <td>167</td>\n",
       "      <td>91</td>\n",
       "      <td>122</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>159</th>\n",
       "      <td>NLSI0000165_1_1.png</td>\n",
       "      <td>81</td>\n",
       "      <td>67</td>\n",
       "      <td>116</td>\n",
       "      <td>173</td>\n",
       "      <td>113</td>\n",
       "      <td>144</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>160 rows × 7 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "               image name   hR   hG   hB   eR   eG   eB\n",
       "0          10878_2_10.png   31   11   41  110   42   75\n",
       "1          10878_2_10.png   31   14   19  137   54   91\n",
       "2          10878_2_10.png   22   10   38  189  113  143\n",
       "3          10878_2_10.png   30    8   35  225  116  143\n",
       "4          10878_2_10.png   17   12   42  220  124  163\n",
       "5           10878_2_8.png   72   33   89  249  131  170\n",
       "6           10878_2_8.png   83   29   80  251  112  141\n",
       "7           10878_2_8.png   34   20   59  219  137  158\n",
       "8           10878_2_8.png   65   27   75  168   61  112\n",
       "9           10878_2_8.png   78   36   99  226  115  150\n",
       "10          10878_2_9.png   75   39   95  250  154  182\n",
       "11          10878_2_9.png   35   15   46  199  107  145\n",
       "12          10878_2_9.png   89   54  112  208   98  127\n",
       "13          10878_2_9.png   71   37   88  181   88  121\n",
       "14          10878_2_9.png   66   28   87  164   67   96\n",
       "15         11460_1_10.png   60   26   71  218  138  148\n",
       "16         11460_1_10.png   57   27   67  227  153  189\n",
       "17         11460_1_10.png   96   53   91  204  151  152\n",
       "18         11460_1_10.png   51   36   84  217  132  155\n",
       "19         11460_1_10.png   71   44   90  218  126  130\n",
       "20          11460_1_2.png   91   63  105  224  161  176\n",
       "21          11460_1_2.png  100   65  116  227  166  192\n",
       "22          11460_1_2.png   53   31   87  224  162  183\n",
       "23          11460_1_2.png   84   44   85  206  133  170\n",
       "24          11460_1_2.png  116   61  111  252  206  216\n",
       "25          11460_1_3.png   59   28   66  229  140  169\n",
       "26          11460_1_3.png  121   77  127  232  172  193\n",
       "27          11460_1_3.png  103   59  106  210  143  167\n",
       "28          11460_1_3.png  111   73  112  235  164  188\n",
       "29          11460_1_3.png   50   28   74  239  188  209\n",
       "..                    ...  ...  ...  ...  ...  ...  ...\n",
       "130  NLSI0000078_2_10.png  102  103  147  159  133  169\n",
       "131  NLSI0000078_2_10.png   95   93  140  142  127  160\n",
       "132  NLSI0000078_2_10.png  130  124  162  117   93  128\n",
       "133  NLSI0000078_2_10.png   81   80  130  165  144  175\n",
       "134  NLSI0000078_2_10.png   89   88  140  139  116  155\n",
       "135   NLSI0000078_2_6.png   98   91  133  176  163  190\n",
       "136   NLSI0000078_2_6.png  108   97  146  184  168  196\n",
       "137   NLSI0000078_2_6.png   96   94  146  154  133  168\n",
       "138   NLSI0000078_2_6.png   68   68  119  157  128  160\n",
       "139   NLSI0000078_2_6.png   57   53   96  197  163  190\n",
       "140   NLSI0000078_2_7.png   89   82  131  165  147  177\n",
       "141   NLSI0000078_2_7.png   90   80  139  164  139  174\n",
       "142   NLSI0000078_2_7.png   73   73  124  155  130  163\n",
       "143   NLSI0000078_2_7.png   81   84  131  162  140  172\n",
       "144   NLSI0000078_2_7.png   82   80  130  175  151  185\n",
       "145   NLSI0000078_2_8.png   77   77  127  149  132  163\n",
       "146   NLSI0000078_2_8.png  103  102  150  128   98  135\n",
       "147   NLSI0000078_2_8.png  104   99  141  152  132  164\n",
       "148   NLSI0000078_2_8.png   81   82  144  167  146  176\n",
       "149   NLSI0000078_2_8.png   71   72  121  120   95  129\n",
       "150   NLSI0000078_2_9.png  138  139  178  145  110  153\n",
       "151   NLSI0000078_2_9.png  111  108  156  131  106  144\n",
       "152   NLSI0000078_2_9.png  104  101  149  131   96  124\n",
       "153   NLSI0000078_2_9.png   94   95  144  157  134  160\n",
       "154   NLSI0000078_2_9.png   67   70  111  159  133  167\n",
       "155   NLSI0000165_1_1.png   60   44  100  157   92  124\n",
       "156   NLSI0000165_1_1.png  115  105  150  168  106  128\n",
       "157   NLSI0000165_1_1.png  114  106  142  153   84  116\n",
       "158   NLSI0000165_1_1.png   60   56   98  167   91  122\n",
       "159   NLSI0000165_1_1.png   81   67  116  173  113  144\n",
       "\n",
       "[160 rows x 7 columns]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_set = Dataset(he_indexes_test, ihc_h_indexes_test, image_dict, augmentation=False, crop_size=IMAGE_SHAPE, \n",
    "                  crop_position=\"center\")\n",
    "test_loader = torch.utils.data.DataLoader(test_set, batch_size=1, shuffle=False, num_workers=10)\n",
    "\n",
    "stain_OD_gt_df = pd.read_csv(\"../data/he_color_sampler_eosin.csv\")\n",
    "stain_OD_gt_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.netG.eval()\n",
    "device = model.device\n",
    "\n",
    "pred_OD_matrixs = []\n",
    "gt_OD_matrixs = []\n",
    "pred_ODs = []\n",
    "gt_ODs = []\n",
    "\n",
    "\n",
    "for idx, (images, _, _) in enumerate(test_loader):\n",
    "    # if idx % 5 != 0:\n",
    "    #     continue\n",
    "    print(idx)\n",
    "    image_name = he_indexes_test[idx]\n",
    "    batch_size = images.size(0)\n",
    "    origin_size = images.size(2)\n",
    "    images_norm = preprocess(images, IMAGE_SHAPE).float().to(device)\n",
    "    \n",
    "    # =================== forward =====================\n",
    "    with torch.no_grad():\n",
    "        ODs, stain_OD_norm_pred, params_lt = model.netG(images_norm)\n",
    "        ODs = postprocess(ODs.cpu(), origin_size).to(device)\n",
    "        # Linear transformation\n",
    "        # ODs[:, 0:1, ...] = ODs[:, 0:1, ...] * params_lt[:, 0, None, None, None] + params_lt[:, 1, None, None, None]\n",
    "        # Add rgb to ODs\n",
    "        rgb_ODs = torch.stack([torch.tensor([[0, 0.70711, 0.70711], \n",
    "                                             [0.70711, 0, 0.70711], \n",
    "                                             [0.70711, 0.70711, 0]]) for _ in range(ODs.size()[0])], 0)\n",
    "        stain_OD_norm_pred = torch.cat([stain_OD_norm_pred, rgb_ODs.to(device)], 1)\n",
    "    print(stain_OD_norm_pred)\n",
    "    print(params_lt)\n",
    "    recon_images = reconstruct(ODs[:, 0:2, ...], stain_OD_norm_pred[:, 0:2, ...], device)\n",
    "    recon_images_h = reconstruct(ODs[:, 0:1, ...], stain_OD_norm_pred[:, 0:1, ...], device)\n",
    "    recon_images_e = reconstruct(ODs[:, 1:2, ...], stain_OD_norm_pred[:, 1:2, ...], device)\n",
    "    recon_images_b = reconstruct(ODs[:, 2:6, ...], stain_OD_norm_pred[:, 2:6, ...], device)\n",
    "\n",
    "    ori_image = np.transpose(np.array(images.detach().cpu().numpy()*255, dtype=np.uint8), (0, 2, 3, 1))[0]\n",
    "    # _, ch1, ch2, ch3 = channel_deconvolution(ori_image, \"HEB\", to_normalize=False)\n",
    "    stain_OD_norm_deconv = get_stain_OD_norm_gt(stain_OD_gt_df, image_name, bg=(0.754000, 0.077000, 0.652000))\n",
    "    print(stain_OD_norm_deconv)\n",
    "    _, ch1, ch2, ch3 = channel_deconvolution(ori_image, \"costom\", to_normalize=False, \n",
    "                                             channels=(\"H\", \"E\", \"B\"), \n",
    "                                             stain_OD=stain_OD_norm_deconv.numpy())\n",
    "    _temp = np.array([[ch1, ch2, ch3]])\n",
    "    recon_images_deconv = reconstruct(_temp[:, 0:2, ...], stain_OD_norm_deconv[0:2], device)\n",
    "    recon_images_deconv_h = reconstruct(_temp[:, 0:1, ...], stain_OD_norm_deconv[0:1], device)\n",
    "    recon_images_deconv_e = reconstruct(_temp[:, 1:2, ...], stain_OD_norm_deconv[1:2], device)\n",
    "    recon_images_deconv_b = reconstruct(_temp[:, 2:3, ...], stain_OD_norm_deconv[2:3], device)\n",
    "    \n",
    "    # Save res\n",
    "    pred_OD_matrixs.append(stain_OD_norm_pred)\n",
    "    gt_OD_matrixs.append(stain_OD_norm_deconv)\n",
    "    pred_ODs.append(ODs)\n",
    "    gt_ODs.append(_temp)\n",
    "    \n",
    "    plt.figure(figsize=(20, 5))\n",
    "    plt.subplot(141)\n",
    "    plt.imshow(np.transpose(np.array(images.cpu().numpy()*255, dtype=np.uint8), (0, 2, 3, 1))[0])\n",
    "    plt.title(\"Original Image\")\n",
    "    plt.subplot(142)\n",
    "    plt.imshow(np.transpose(np.array(reconstruct(ODs, stain_OD_norm_pred, device).detach().cpu().numpy()*255, \n",
    "                                     dtype=np.uint8), (0, 2, 3, 1))[0])\n",
    "    plt.title(\"Reconstructed Image (All)\")\n",
    "    plt.subplot(143)\n",
    "    plt.imshow(np.transpose(np.array(reconstruct(ODs, stain_OD_norm, device).detach().cpu().numpy()*255, \n",
    "                                     dtype=np.uint8), (0, 2, 3, 1))[0])\n",
    "    plt.title(\"Normalized Image\")\n",
    "    plt.subplot(144)\n",
    "    plt.imshow(np.transpose(np.array(np.clip(reconstruct(torch.log(ODs[:, 0:1, ...] + 1) * params_lt[:, 0, None, None, None] + \\\n",
    "                                                           params_lt[:, 1, None, None, None], \n",
    "                                                [[0.644211, 0.716556, 0.266844]], device).detach().cpu().numpy()*255, 0, 255),\n",
    "                                                 # stain_OD_norm_deconv[0:1], device).detach().cpu().numpy()*255, 0, 255), \n",
    "                                     dtype=np.uint8), (0, 2, 3, 1))[0])\n",
    "    plt.title(\"Fake IHC H channel\")\n",
    "    plt.show()\n",
    "    \n",
    "    plt.figure(figsize=(20, 5))\n",
    "    plt.subplot(141)\n",
    "    plt.imshow(np.transpose(np.array(recon_images.detach().cpu().numpy()*255, dtype=np.uint8), (0, 2, 3, 1))[0])\n",
    "    plt.title(\"Reconstructed\")\n",
    "    plt.subplot(142)\n",
    "    plt.imshow(np.transpose(np.array(recon_images_h.detach().cpu().numpy()*255, dtype=np.uint8), (0, 2, 3, 1))[0])\n",
    "    plt.title(\"Hematoxylin\")\n",
    "    plt.subplot(143)\n",
    "    plt.imshow(np.transpose(np.array(recon_images_e.detach().cpu().numpy()*255, dtype=np.uint8), (0, 2, 3, 1))[0])\n",
    "    plt.title(\"Eosin\")\n",
    "    plt.subplot(144)\n",
    "    plt.imshow(np.transpose(np.array(recon_images_b.detach().cpu().numpy()*255, dtype=np.uint8), (0, 2, 3, 1))[0])\n",
    "    plt.title(\"Background\")\n",
    "    plt.show()\n",
    "    \n",
    "    plt.figure(figsize=(20, 5))\n",
    "    plt.subplot(141)\n",
    "    plt.imshow(np.transpose(np.array(np.clip(recon_images_deconv.detach().cpu().numpy()*255, 0, 255), dtype=np.uint8), (0, 2, 3, 1))[0])\n",
    "    plt.title(\"Reconstructed\")\n",
    "    plt.subplot(142)\n",
    "    plt.imshow(np.transpose(np.array(np.clip(recon_images_deconv_h.detach().cpu().numpy()*255, 0, 255), dtype=np.uint8), (0, 2, 3, 1))[0])\n",
    "    plt.title(\"Hematoxylin\")\n",
    "    plt.subplot(143)\n",
    "    plt.imshow(np.transpose(np.array(np.clip(recon_images_deconv_e.detach().cpu().numpy()*255, 0, 255), dtype=np.uint8), (0, 2, 3, 1))[0])\n",
    "    plt.title(\"Eosin\")\n",
    "    plt.subplot(144)\n",
    "    plt.imshow(np.transpose(np.array(np.clip(recon_images_deconv_b.detach().cpu().numpy()*255, 0, 255), dtype=np.uint8), (0, 2, 3, 1))[0])\n",
    "    plt.title(\"Background\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1) Evaluate OD matrixs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Diff from gt_H:  0.0932950185022243\n",
      "Diff from gt_E:  0.08389769790304183\n",
      "Average diff:  0.08859635820263306\n"
     ]
    }
   ],
   "source": [
    "diff_h = []\n",
    "diff_e = []\n",
    "diff_all = []\n",
    "for pred_OD_matrix, gt_OD_matrix in zip(pred_OD_matrixs, gt_OD_matrixs):\n",
    "    pred_OD_matrix = pred_OD_matrix[0, 0:3, :].cpu().numpy()\n",
    "    gt_OD_matrix = gt_OD_matrix.cpu().numpy()\n",
    "    diff_h.append(np.sqrt(np.sum((pred_OD_matrix[0] - gt_OD_matrix[0]) ** 2)))\n",
    "    diff_e.append(np.sqrt(np.sum((pred_OD_matrix[1] - gt_OD_matrix[1]) ** 2)))\n",
    "    diff_all.append((np.sqrt(np.sum((pred_OD_matrix[0] - gt_OD_matrix[0]) ** 2)) + \\\n",
    "                     np.sqrt(np.sum((pred_OD_matrix[1] - gt_OD_matrix[1]) ** 2)))/2)\n",
    "print(\"Diff from gt_H: \", np.average(diff_h))\n",
    "print(\"Diff from gt_E: \", np.average(diff_e))\n",
    "print(\"Average diff: \", np.average(diff_all))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SE from gt_H:  0.03339800604302196\n",
      "SE from gt_E:  0.0485568776922818\n",
      "SE from gt_ave:  0.03678468507075416\n"
     ]
    }
   ],
   "source": [
    "print(\"SE from gt_H: \", np.std(diff_h, ddof=1))\n",
    "print(\"SE from gt_E: \", np.std(diff_e, ddof=1))\n",
    "print(\"SE from gt_ave: \", np.std(diff_all, ddof=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2) Evaluate nuclei signal-gt correlation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home2/swan15/.conda/envs/mask_rcnn_2/lib/python3.6/site-packages/ipykernel/__main__.py:15: DeprecationWarning: `imsave` is deprecated!\n",
      "`imsave` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n",
      "Use ``imageio.imwrite`` instead.\n"
     ]
    }
   ],
   "source": [
    "# Create and save gt mask\n",
    "'''\n",
    "from skimage.filters import threshold_otsu\n",
    "from skimage.morphology import remove_small_objects, remove_small_holes\n",
    "from scipy import misc\n",
    "for i in range(len(gt_ODs)):\n",
    "    image_name = he_indexes_test[i]\n",
    "    OD_h = gt_ODs[i][0, 0, ...]\n",
    "    OD_h = OD_h > threshold_otsu(OD_h)\n",
    "    OD_h = remove_small_objects(OD_h, 100)\n",
    "    OD_h = remove_small_holes(OD_h, 20)\n",
    "    OD_h_c = np.zeros((OD_h.shape[0], OD_h.shape[1], 4), dtype=np.uint8)\n",
    "    OD_h_c[..., 1] = OD_h * 255\n",
    "    OD_h_c[..., 3] = OD_h * 255\n",
    "    misc.imsave(os.path.join(\"../data/he_test_nuclei_mask/\", image_name), OD_h_c)\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8879350291368918\n",
      "0.37191762085271013\n"
     ]
    }
   ],
   "source": [
    "i = 22\n",
    "image_name = he_indexes_test[i]\n",
    "nuclei_gt = skimage.io.imread(os.path.join(\"../data/he_test_nuclei_mask/\", image_name))[..., 1] > 200\n",
    "OD_h = pred_ODs[i].cpu().numpy()[0, 0, ...]\n",
    "\n",
    "from sklearn.metrics import roc_auc_score\n",
    "print(roc_auc_score(nuclei_gt, OD_h))\n",
    "\n",
    "from sklearn.metrics import roc_curve\n",
    "fpr, tpr, thresholds = roc_curve(nuclei_gt.astype(int).reshape(-1), OD_h.reshape(-1))\n",
    "\n",
    "OD_h = np.array(OD_h > threshold_otsu(OD_h), dtype=int)\n",
    "\n",
    "from sklearn.metrics import confusion_matrix\n",
    "cm = confusion_matrix(OD_h.reshape(-1), nuclei_gt.reshape(-1))\n",
    "print(cm[1, 1]/(np.sum(cm) - cm[0, 0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_auc_score, roc_curve\n",
    "\n",
    "auc_scores = []\n",
    "fprs = []\n",
    "tprs = []\n",
    "nuclei_gts = []\n",
    "OD_hs = []\n",
    "\n",
    "for i in range(len(he_indexes_test)):\n",
    "    image_name = he_indexes_test[i]\n",
    "    nuclei_gt = rgba2rgb(skimage.io.imread(os.path.join(\"../data/he_test_nuclei_mask/\", image_name)))[..., 1] == 255\n",
    "    nuclei_gt = nuclei_gt.astype(int).reshape(-1)\n",
    "    OD_h = pred_ODs[i].cpu().numpy()[0, 0, ...].reshape(-1)\n",
    "    \n",
    "    fpr, tpr, thresholds = roc_curve(nuclei_gt, OD_h)\n",
    "    fprs.append(fpr)\n",
    "    tprs.append(tpr)\n",
    "    auc_scores.append(roc_auc_score(nuclei_gt, OD_h))\n",
    "    nuclei_gts.append(nuclei_gt)\n",
    "    OD_hs.append(OD_h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9775468682945145\n",
      "0.013891569035615246\n",
      "0.9644344602205737\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(np.average(auc_scores))\n",
    "print(np.std(auc_scores, ddof=1))\n",
    "print(roc_auc_score(np.concatenate(nuclei_gts).reshape(-1), np.concatenate(OD_hs).reshape(-1)))\n",
    "\n",
    "# Plot\n",
    "plt.figure(figsize=(6, 6))\n",
    "for i in range(len(he_indexes_test)):\n",
    "    if i == 0:\n",
    "        plt.plot(fprs[i], tprs[i], color='orange', alpha=0.4, label='Individual image patch')\n",
    "    else:\n",
    "        plt.plot(fprs[i], tprs[i], color='orange', alpha=0.4)\n",
    "fpr, tpr, thresholds = roc_curve(np.concatenate(nuclei_gts).reshape(-1), np.concatenate(OD_hs).reshape(-1))\n",
    "plt.plot(fpr, tpr, color='blue', label='Overall')\n",
    "plt.xlim(0, 1)\n",
    "plt.ylim(0, 1)\n",
    "plt.xlabel(\"FPR\")\n",
    "plt.ylabel(\"TPR\")\n",
    "plt.legend()\n",
    "\n",
    "torch.save([fpr, tpr], \"../outputs/2_roc_curve_evaluate_deconv_GAN_512_40X_9.pt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manual OD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9563889315667233\n",
      "0.0332210058567219\n",
      "0.9485071753428138\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAF3CAYAAAC7cgzXAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsvXeYZGd9JvqeUDl0dY6T84xGmhGDRkIZgVAiGIMxNutwsfHaOIC9gcfe9bV3bd+1H99rr73XkcVgs76sMQIEkhCggHIYZWly7Okcqrty1Unf/eP9Tp3qnu6enlHPaGr0vc9Tz6lw6tSpE3759/40IQQUFBQUFBQWg/5274CCgoKCwqUNpSgUFBQUFJaEUhQKCgoKCktCKQoFBQUFhSWhFIWCgoKCwpJQikJBQUFBYUlcMEWhadqXNE2b0DTtjUU+1zRN+wtN045qmvaapmlXX6h9UVBQUFA4f1xIj+LLAO5Y4vM7AWySj88A+OsLuC8KCgoKCueJC6YohBCPA8guscqHAfyjIJ4FkNE0rfdC7Y+CgoKCwvnh7cxR9AM43fB6SL6noKCgoHAJwXy7d2A50DTtM2B4ColE4l1bt269yHsgAOECnsMHPPmex/eFx/eEBwghn4vgPQj5WtKl1J83vsYS7zUsReN7mLfOAvu9jL+2rPWWDUUJo/DOg+fpcIUOz9PhCfnwdHjCCD4TOjzPgOsFzz3hf89/f+4S0Jb1+4buwtAduXRhNrw2DQem7mJwenJKCNF5Pv/v7VQUwwBWNbwekO+dASHE3wH4OwDYs2eP2Ldv31v/deEBdhEoDwKFY0DpJOAUAWuWS7sIWFkALuDZgFMBNK1BObiAVwsEreeCCsSTz31F4gGaALwGZdIo/IUALwbB7Z8BjQ9N49f8dfzn/tf95/DkUjtze8Jp2OZ8RaTNe+6BDue8bdS36e+zLv+H/31NfkULlCW0hv8tgtf+f9dc+X35Xl15iYZj1LivaHjtH4DGt5c6lo3/Qzvjq8EbjUt5LDWNx0QDAmdcAzQj+AwCgMHjomvB96HLbejBev73NKNhPaPht+T6mh68hhHsj67P3Q//d4G5++nvhxCYa8AAgVEjgnPi2bxWhADgBsaQcAC3Jk99w3aE1XBqXMB1G7btYsFzWf99/33/eeOyEWLuU23+23O/K4RAzY6gYsVQsaLyEUPZisv3+Lxc4+dVe+7n9WUtLteLo1RL8LkVR6kaPK/Z0QX2d3HomotktIhEtIxEpIxUrIhEpIJkrIJUrIRkrIZUvIpE3EYqIZBICCQTDlpaQ0inBFqSJaRiZaRDo0iZ40gaI9BFAXA9wK3wXjJjQLgXaHsX0P9hoOtGaGbo1DntaAPeTkVxH4Bf1TTtawD2AsgJIUZX9BeEAJwSYOeB8hAw+xpQOEKlYM3ws7rwBHgDykOim4AWAjwr+Ni1eIF7Fm8mCH6/fhPLbRgh8Kb1b1wN0COAHgL0MGCEudRCc9cxIv6OU7G4JdRvLs/i9zVdKh89+B4gb+Jqw03uNXg//mY9QDd4L+kGAkXgyW2H5HtSKHj+DS+9KX8bni3/qpBCwZH3uyt/WypN4XL7vqDxlQoQCHJNA2DKvxFCIJQb/p8vXDWD+63Jc2OYPM66fxwNnjfo8vgawTHTQoAR5Xe0sDwXMbk0g/PQeE7q3/cP4DzFWRf8mHv+69dSo6KQ6wshBXzjuvJ53Qixg+PsVAGvyvPvn1+30vB+jcLbq/F9tybPnRWcD88JzktdYftKWQpqb55AbxTedRtCa/h8vnL2GpRlw/GBDs/TUHXiqEoBXbFiqNoRVCxfkMtlLYpyLYqKHUPVCvNhU8jX7DCqdhg1+R4FebRB6MfmCPiqHYUQ5xdZj4SqiIWrSETKiEdqiEVqiEeqSMQttLVVkIznEY+5iMc9LmMCsaiHZMJDIqkhHteQSBpIJHXEEyEkUgYSCQ3xhIlUvIJIKg1ND/F+18OA3hnIBf/adsuAPQtUxoHKMJA7QNlVnaTccstU0NABLQKYGSDVCSQ3A+3vAjI7gcQaeT+8dVwwRaFp2v8H4BYAHZqmDQH4P0FJACHE3wB4AMBdAI4CKAP4+RX5YbfKA5o/DBSPAvmjgDXFAyxc3vihDJBYC5hpIJQCQml+t5alcLZmgNoUPQu3BgpKKfz87+tRLkMJwEwAehwIpwAjTuFhJuRJB5euBdgzPMGeFOqNgtWTwl0Py/vRA/Q2ABq3JezgxvYcbsfJA1ahQeiGgFCcF2C4hfuomYAZlVa2HggLt8bf8iz+Z8+i8HGKUnmGAc3mxei5geDSAPihOOFKazhEq1WTVq1uSuFryhshSiGth4FIK/9TuI1Wj5kAjARgyOcAz4mZ5LE0Y4AZB8yU3MYlGi31HAprzz9eUlj7nmltkt6qNQtUp3gt2AXAKfDGd0ry+3aDkPcteXntzRHmPhqNFNQVlxAabMeU1nAKVTsG1zPhaQZc15DPTbieCdcz4IkQXBGCizDKtSQqdgzlWgylWhzlahRlK4ZyLcLntRjKtTAqtQgqtbB8hPiwIqhaIVRqEVTtMCq1KCwnfN6HVddcRMNVREM1RENVREIWoqEq4pEqYuEaUokautvyiEVqiIVtvh9zEIt4iEUcxGIuohGBeByIJwRiUR2xuI54Qkc8riEWDyOWDCOWMBCN6YjFNOimbzgYPBfhtgbDThogoXTwnhE9t2tTCBm1yAFOGSiPANUxoDxMI7YyQvngFOV1YUnDJczfMKJAci0Q6+N9ntrER3JdcA+tMC7YXSeE+ORZPhcAPruiP1oZA4a+Bcy+CZRP8UDrEQqcgR8D0luAaDcPfPkUb9rCISB/AKiMBt6DcKWwbQXiq4FIOxDr58OMgBarKW/yCuqehQ+nAtQmeJM7JSmUzeDC8hz5OiEt2pA00qQ1D52C05A3mJXj9uycvGhMfie+GmhJAZFOINpDoep7InYOqE1Lj0oKI1EDbHnhCekR+SEJr8b98i1pTaOC0eLcB98jMiIU/OEMbxYzKfc1SgEfbuW64TYp8GPB580A/1i4FZ5Hz+KxrE5LYZ/l8bTzUgHMAnZWWvOVQND7Xqfv3fl5rDp85a6jaidQqKZRqCZRrLUgX0kjX2lBrtyKfJXPC9UUCpUkitUkitU4ipUoCpU4StUIytUwH7UwapaJmh1CzTLO26JeDLrmIh6pIBauyGUVsXCFgjs8i/YMP4uFqw1CvSbXqyIariEWriEWsRENW4hHLUTDLoV8TEc85iGWMBCLeojFDURjIZiREK+nulERp2ER8u8dMzB4QmlAb+H9Fm4N7i09NNej998zpEd5ISAEjTkrRzlRk8ZC6SQNBWua96edk0ajf334IUoTMFsCZRDK8D5PrAGinZRJkU7+zwXDrCuLS9Q8Ow/UpoHjXwFGHwAiXUBiPdB5HdB2De/J4jGGnwqHgezLPFFWLhDwkU6ekPR2IL0ZiHYB8ChYbbmemwf8aIxmyJOX4HO3zH1wa/zcSPI7oZYgTKWFuDQiZ16gkS5azkacF4lX5e9Wxvk6sQ7oXgeE26WyqVFQVaQ1kj8Q5Fe8WkMMGAjCM6YM3cQbFJfJUIghPREjIj2tNBBK8j/61n+kiwqiHiJrAgghhX5JLssU8k6Bwt/K0jOrzQDVcena53jeRU2Ge/zwmghCN/W8iYaaG0e22I6Zcjtmyq3IFtswU27FTKkds5U2zJbbMFtuxWw5g9liErPFOPLFCPKlMPLFECzLOOvf0DSBZNxCKlFDImYjFbeQjNfQ0VpFIjKNRKSEWKiMiFlFJFRFxKAAT0SLiIfKiJhlGJoFHQ4MzYKhu9A1TyY8HeiQyU/NQTxSRTxaRixcQyJSka9riIRsaLrG6wYGDRkjTEvX9/4M+TDj0kiL0pgIpQBdGhdGQl6HIXqYvvDWfEFuNrw2531uNoT73mb4hqCdoyypjALVUV5DtSl6k26F15NTlt9xAddmeNqIUj7E+insQ61ApE0qPBOIdNAAjPVSPpmJi6IUFsLloyhGHmQOItIJbPwM0L6XwnPiMd70+TeB4nEKc83gRd2yFWjZQU9DM2QyOyvDAjPBto2E1OargPgqXrDVUQrx4mG6jFYOgAhcQyMhbxYZdzdTvAjCrRS+Zpw3kJmU+QJQgOUOAPlDVBSuRWWjmxRWE08ClSFatH682o+DGzEqp3AnL0LNDGKg9eRnROZHIrwIQ2lefKEWWinhNu7XpQ4hk3Z2UYbyLCpoO8+btDrKG9XKSstfWnV2TnoJVcB1QK3vJ3BdWE4YU8VOZEudmCyuw3SxA9liK6YKHciWOjBd7MR0sQ0zxTRmCgnMFuOYyUVQriwt6JMJB60tNbQka2hNlTHQlUPL+ipS8SpakmWkExWk42Ukw7NIRfNoiTUsY3m0RGcQN3PQNf+asBtyZGLusjH34CfFNYMJzsbcj5C5tHreLEoPN5QEzDbAGOA9Ekrz+gineQ2bCS798GDdQveXDQaIb5g0K1yLeYLaND2C6ji9glqW15dngcn7Gq8vz2447qb00A165qFw4JGbycAbD2coEyLSAIz3yZB26tJRiLhcFIVrUWCEWoLk5eD/BiqTDC0Vj/KkmUmg6xag8z0M21iTPPkVWWwV7QZadlKYmkl6FaEM6tVOpUEqpJlXeAG5VXkTZRgfjA8EOQ8zvbAyWAjVKWD8ESq6msyl1HJUXJChEAhabaEW7meopeGGTfD/uxUZM5UeSyhNBeLvo5kIFMQldBHOgSuteD9hVw+dFZg7qkwwDOcU6AXUpngunLJ04R00VvSUKjGMznRhbLYXY/mtGM91YyLPx2S+A5P5NkzMZjCebcFMfvHwWCwGtLd7aG910ZaxsbnPQms6h0yyiPbkDFoTM2hN5tCayKMtnUNbfBqZeBYtsVmYKDHX49akkpJep2vxtZ+DAORzeW78yiJPA+zG4giDXqCfPK4LamkYGBGpBCJ8hBIMY4Qz0kP0rwd5bZophlQ1GY4xpCdwocIylwKEoNFgTQLlUcqA8pA0FnP0Mv3rqfE7fmgWmlQUJvNz4QyfQwR5As2UMiAhj3OcXnmsm5GBSHtzGGa4XBSFU6BwsGYZn59+Xia0j/DGS64Fem4HIj2ANcHktjVFTZ5cTwEfX7XwjZE/BIw9QoVTy/LmjPVSoaS30QKIdNJbWK7wdW2gcBQY+yEw8xLDYXaRN6hmcBnKAPFeKoXkZv6mX31UG6eHUVc+Lv9DrJf/KdwqE3CX4Ol1q/yvTlGGgGRVmjVDJWnng1CRNSMTwDNBdY+wAddCtaZheKoHI7O9GJnZhuFsP0ZnezE624vhbDdGs+0Ync4gXzxT+GuaQHu7hs5OoLMT2LEBeG830N0NdHZ46MiU0J7KoSM9i/b4GNpjJxAVYzJcKcNWTrGhIMENchNuTb4nAAdAviE3IWRJq19KrIfpeWoIrH6/EMBXBn6SVGtIsJpJGbduZejGN0zCrXzfTHFpxGUcvomt+nOBX+nnWUGY0ZqigefKUG359NxQZCP0MI9XpIsetl8B6RcqCFk95tlU8P7nRiw41kaM3lekM/AWQnLZxOfhEpQk5wG7wIuhdBxAiCEaJ08lsPongVBMlpYN0pNIrgfi/QtXCAjBpHj2RWDqSVoZegiIrwG6bgZad0ulssyT7rkUMPmjQHYfkD/IR22KSk0zqQxadwGpjQyFJdYEZZLVCV7UlcFgm5EuCodYL5NdZuLSUQqeEyiB6kSQDLZy/L++t+BXdNglvl+bqXsGrlXDyHQbTk70Y2h6HYayN+DU5AAGp/pxerIHQ1NdmMq1nPHTkYhAb6+G/n5g5wbg9l6gtxfo6wN6evjo7gY6OjSYhqAnVzwBFA8CxZPM91TGpSIoA6UyUHSD/+X3hJxR9y8FvGbQQtR0AH5ZrvwMJuq9D8ILhL4my30Nv4pOWvh+yCfaIePWrcHSuIwtfUBWjdmBErbzUvjLUJBTDLwxp9zgBchKIuHK0KwFniNZJGImZfgnCqS3UpgbcR5zPcrrsDrG+9+aCbx015Keu0yk+0UuYRkiCmV4jmN9TeMhnCsuEenyFuEUgdJpCvVwBoh1Af33AOlNzEtUdQrg1t2Muy4EISjAxx9lCMgpMUzT/yGg5/2yrHMZ8GwmtXL7gekX6DnUxmiJ+iWmeojlud23AD3v4+9ohqxUmgJmXw1c3lALL/CW7bxAY71vfwWRU5F13jIc5BRo+demgv327OAm1szAM7CmIewiprMhHB/pxImxXpwc24zj4wM4NrYGx8ZWY2iyE44799JsSbtYvVpg1WYd19ymY2AAWLWKSqCvD+jvBzIZLcj1CY+/XxkD8vupEEqDwJFh4I1xKQikMJnToNdQdeIXAACyAkwqAyDIARmynNlvqNSMICGryV4VMyZDP7J6JZzhOY90yOoVPxz49iQqLziEx2NtzcpKoFla99bMmaXAcxrrZM+SIwW2cCm0602c8lqr97yEaUQZMSDRL4tNOuhtCVsWgMzQgKlOsAKpsQwV0oMzYiwzT6yhERfrC0LK4YwsOLlMz9UiuHwURf4Al5ndwOqP0zooHgdSm4G2PbQaFoLnsiJq4kdUEJ5D76H3DqB15/Is9eoUv5t9kfmL6jj3xU9qJzYA7Z3yAkwx0Z65Uiav36RiqLvBOj2WWC+T7G9nhZHTcFNXx/jczs+N23p2Q49JmL0YlWEIK4fpSRcHj8Vw9FQbToxvwJGRVTg8sh5HR1cjV0rN+amOthrWr9dw3S0m1qzVsXYtsGYNlcGqVUA6Pc+DEyKoXCodB6aOAyePMbRQm6SH4vp9MI0egIZ6s52ZDKp2YMgGPl0qDg/120PIpKTf7GfIeL4mG/tCaVmo4D9ag+KASBeFTjPDs2Wfjx1Y8v57nmz2s4tBH4hblUUG0iuY32ntuVLpiqDYwvcifMXg2QiaVUOyaiosw2oZbjfWGxhSRqzBe53lPZg/AljPSAPGlfeY1lChFeXzxFogsZo5yXq4qOXSzeO9Dbg8FIUlSxuhAR3XMuwUXwV0XCeTTAvAc4HcGyyVnXmZgj2xBhj4CK33symI2hQw9Twf+TeoLDTQimm9isqpZScTVxOPM/wUks0x1gxw+l8DazuxllZLpE16FxfxAhVCVnZkubTzMmcwK5PoEmaSwjWUCW7oygSs0gxOHLVx5LiJI6fasf/UKhw4fTMODG1AthAce133sLqvjM2bPFx7m4kNm11s2Ghg7Vpg3ToglVpAIQoRhBUHD5NupTJGj60yyvizU0G9GdG3LI0w2ADZRYHglyXXqTA8wBPBe0AQAvKrhIxIQzI4KcNAPUCsh+co3Cqt1bMUKlyKqPeKVGWeqBh0dztlWtsA6h3hy4EucyHCRZ1eRjNkWbms1NIMegl6lEoCCLZvhAEjI8tppWL1Q3B+lRA0GgHFE1QIOVkSbufm5rHg8Zz7ieT4KioaP9xkJuYmmJVCOCsuD0VRGeUFYsZpFbZfC7Reufj6pdPA5JOMSZdPMyHd834gc9XSN72V4/emnqMn4MhwUrSXoa6OvWydD2d4E049C0w/xws53s/3svtkXqKLeYnkhovrNXg2lWp5iAKhMVwEBDdlrLfB9S/Bq0xh8EQFb+wP483Dabx2dACvHrsOh4bXwHGDmHl7Swk7Ns3ixz+Yx9btVWy9qhObthhYs0ZHOLyIV+eUgOI0k/r5A1QMlRFZ0SST28L3XCBLkBOM18dkiMGIANAaKosaLFrhBqEknyYBImgE9EuZI+2yKqWHIYdwaxCbvhThOUFPiHADpekndOu0Hz7Nh3xvDm1NAzRTWttxAAKIrKKidKs8vv426gld34OoAV5lbj+hDyNGheoneutdzGF6XEZU5gp12Tc0QmOgNgFYh+W9XQmug0bvxC8GCKVYdRjt4X0V65WeQRt/8x0WJroQuDwURXlY9htIq7dlx8Lr2fmgF6GWpYXTejWFfKRt4e+4NQr8qWfpgVgzvBFjPQwfdd8CZK6gkPFRnQJGvksaET3EbTsleg7JdTIZfpEOvZWTjWQTXFpZ1BN8kQ5pZXXwprMLQG0SVvYk3ni1gpdejeLVg+14+ch2vHZiAwqVQNCv7prAlVsm8aG73sDWKzLYdGUvNm2LoqMjAWARGgHPZnlr/gAVbfE4UDolu1Mrc5sEdZPnMtwu48IxeeOHKbhq0wwt2UWWNvrdz35Zp58c9jvGfUEVaZMCpYfnLJSkQrhA1AfLQj1cUwtyP/UKGymUhR14ANCC7vHFoIeDklkjysZQ/z0/D+OHbTST17Ut8zZWluuUTi/uVejRgFol1iu9BI3H1EgECkB4sodFsgNUJ3juqhP0BipDDTmIebxrfkOaEQGSu3g+Y900DqI90jA8f3oQheWj+RWFawU8Toa0ChfyCgpHgYknZMWJyYsuvQnovH7h5HDxJDD2A2DqGVmxU6PAat8DZHZROSTWzhX4ngsM/iurpew8u7wzO5gnSa67OHXpdj5I7NcmKXiAINHXuluW/oWA2hSc/DDefOo4nnshjH2vt+Glg6vw2okbYTvc12SsjKs2DuJnP/QqrtghcMXVbdixpx+Zrk5A61piP0r0EGZeA4pHGC6ojfN9n6pAD1OIR3slPYOkTfE5dvzYty0pTMqDQde5ZlI4GeGggTHSLkNFKVqW0Z6GcmFZOnoxzoHnUjjWBbugUIQWdPA7JbludeltabKDeQ7tRDjIdxlR2ckrBbMennv9+8SYjqwus4uyByXHgovG8KJmBFa/W2XFVb3sMypzMjIcBy8oB270XgpH5f+WnFZWNsgP+CWrfq+BFuI9pUcZ9o10shAl1ieviSahfXkHoPkVhVNgrBoisA4b4blMMs++QotUMyhAMzuArhvnreuwB2P0ISa4fcbS1EYmltPb2M09/zeEB8y+AQx+HSidYPntmp9iaGmxKquVgl9lVT5N5eZKAWSmGe6KdgMRn99qEFODQ3jmyWN45sU0nn5lAPsO3YxSlaGV1mQOV28+jt/85A+wexfwruu7sP6KVdDjm5eO49p5oHiKuZ7cmzwG1ckgVKCHGSaKr6cwD3cA4aS0NouBdWnnqOTcqsw7SGZePc7zEGmbWzpqJmSYqCuoIvJj2hcy7uzZFPZ+nN+npXcKQRnwYjAkR5FP1xJKBk2RfrOc1pC8XShs4ucRXNlkaMuu4Hp3cENewI/ZN0ILUWnG+oLf8MM0fumyn6sqnpS5BXvxY2HnZQLapzuR4SGfEdVIkoIm2k3vIypzO763oHDJo/kVhVuRcXYBGKm5yevqFJvanDwrj7waXd35OQwhgJEHqCCsLEsZ+z8IZN4FTD4CpLbQ81goXORawOlvAJNP8KYd+HFg1UcuXFzUcyW52CCVgx9K0gzWdsd6aJ1pBlA6jeEjQ/jRoyfwo2da8cRLq3Dg1F4AgGk42LXhKP6Pux/DtbumsPe6GNbv3gwtuQ4I7Vp6/yvTQPZ5YOZFNiRWRmUXOWhtRtoZ0ktuZtOgEaESKJ+mgCscCGZ/1NlWbcBnyjUiQLh7bke5maDnkFwTdLVG2i+chyC8gPjPmmGo0m8OXMgLMGQXfrxPKrMWGgl6NPAElhsm8SlKKlNBpZlbDnpqzhD8Bup9Gm4VddoYn1+s3rktPQ3hyIq2GVmVNA+aGdC7JNdS7ptx1D0ip8iqMqcMwJXnSZJARqQXEkoH1BQqT9D0aH5FYReDjulwihcswPj3+KO8QXrvoDCbPUYB1qgkKuNknJ18Aoj2ARs+DXTeSKUw9SwADWi/ZvGcwul7GaJKbQJW/wSQ2rDy/9Fz5IClowwpCYf7FesF2q6mpRbtBZwCxk+M4If3v4JHHo/gR/vW4NgwpwGm40Vcv+MN/JsPPI7r3zWNPdelEO+7AkjunZtfmQ+3Rqty6mnmaPJHqJghKcZDrQyxtWwDWmSuximwwbFwBMi9zGNs51DnwhGSNtkPaUTTAeFgKM0cTrShs9WU9esrndex/f6PSQTU7cXAQm4UyD5RYnJt4NH4YS4jfm6VT44MP1lBk2E9PASvobvbHx6kBcLekMRwfk7FKfJzpyhDcjjT+hdyvonwG/tagKhMKBtR1IdGNXYg++SJnh2EL+vQeX5S63ks/HzP5Uz58Q5H8ysKtxLcLJEOCpTicdJuRDqA3tspsGZfpWfQvmfu96efpxDO7AQ2/3oQKvJsNuAl1y8ePjr9bWD0QW530y8vXop7PhAeLXB/+p5weGOnt0jK815AD8MtDuO5h8fwnfuG8fXvrcOxoe0AgNZUHjftfAOf/cj9uPmaMVx1lQ6j82ogtZd0H4s17TllYHY/MP0Mw2mlE0GcXY8ynNX2LuY62vYwjFA+zfDeyAN8XhmWoQjZzayZsulM9i5EG0pMk2tleKwjOH8rFTaqewWzQWOgU5YJ4/yZSVojRm8g2tNA2NZ27rkNv9fArdLytqZ5TKwcf7cyBPZrNMyb8OeY1IdYhYM6/3p4xgXcAurJbD0SfJbcKXMUkaC7e/6MBD9fYWWlosryXvG9QYD7ZcaDZLRfRqrp8lhkVI/BOxDNryicEssC/WEiThkYf5jCp/cO3pjTzwGxAaDrprnftWQ4RAux56JRIeT2U5BkFimzHf8RcPrrQHIjsOU3SLz2ViE8KoX8ETKgehaVQ2ojE+fxAUDTUZyewQ++9jq+/R0D9/9oA6ZyAzB0F3u3HcSP3/gkPn7bq7h6tw09tYb7n7yHcfyF3H/PZRhr8kfA1AtMQDsFfmbKZsHMFbL09yomGCtjwORTwIl/YC17ZZjWeX2Whs+QmaCXFpXcOX6na70buWVlQhKu7Li18/QOnHLQeNXoFficPD45m1/+Gmk/v25bO89jUR6WikDyVTklGQ6d12msGdKD6qJn4NPI1JPFcrqe7z0IV7KIytJePSLXjy68rz45pluV80vyAa+WNcsQbCNMOcsks1OGmlIrq6gVLhs0v6LwG8P8io3JJ3nR997OG23s+xQCndefeXMVjvCGinQwUT3/s1CGAm4+cvuBE/9Ey3P7f3zrCetalgK6cFS6+TqFSMuOunKYnczjvi8dxjfu1fH9p9eiau1BayqPO/e+gg/d9CY+cMMpZDqT9DbSdzAEFl2kKsmaYaNJTIu0AAAgAElEQVThxOPsKK9OBFZtci3Dc9230HvR5XS+/H7g1NdYBVY4EhD6+YyloRYK3Gi3TDD3MF6f3CA7aFML78u5wHPmhmwaPYU50JiviQ8EBImhlvMvpRRCCt9JnqPCEYbjHMlq69PIG5JK2kwxDKdHeB79ITO+R/VWBLHwqIQqwwyn2oWlS2V1qbQj7fSOfU6icKtKJCssG82vKPz4smFS4CaqQP/dFF5D36Iw6/0AwwfzUTzG2K1v8frwaSs6rjvzOzOvA4f/gtvf+lvnryScihzVepihCeikEUhtrpMOlnJl3Pe3h/G1fzHwvSfXwrK3YlXnOD7zwR/iw7cewk17szDjMr6fupueR7TnTIXolJjbyL5KOvPicVqXWoiCved2VoC17WGeRwjmFUYeAKb3AbOvS1qSvCwakAIvsZZKIdYbzOqI9koa5WVyYy0GK8fj4pQlLUdWKlF/5rYhY+1dQGR7QLvwVggShUfF4/NCVUeCyXZ+Uxt/nP81vYWeanwgIIhbKQHsSgbU6jj/v89H1Bgm8ulCjCjqs0bqg4MSsmxW5Q0U3jqaX1FUJ2RyN0JB0nE9b6Dxh2l5dVxPAbzQ9yqjFCrprXM/Kx7jMrl+7vvlIeDkVxmr3/p5VvScK+w8MPMqm84AWpod19MDMKLwXA+PPTCOL38xh288tA7l6lb0d0zisz/2PXzi9gO4Zk8Fmhlh5U9CTuNLrJlrpXqOnL07Ro9h5iUKG7sow0mrqRi6buZzTTKalgaB6WfplWX3sTnOLcvEcxyIraaFHO8Pmgd9BtvFuLTOBuHJUaNTctiQ9BgaLWQjxvBLZmcQujJT5xYq8lzJXmtR4dWmqRDKp4OqJr8DHAj+s5nmMYr10fOMD7Cay1yhRi/PCcggrRnZlDY5N0xkxCV/lGwyC2W4T5dqx7jCZYfLQFGMoc7aGW6lled3/foNbwuhKGv94wO0xBtROBY0gfkoDTLcZM8Cqz/Bio9zQS1LoV04ytd+pZCsOBofKuJLf3UUf/eVNpwc6UU6nsKn3v8YfvruA7hhbw66LiRp2SpWWKW3zhXOnk2hlz/M/184GnDvGzEgtR3ouAbovIHWP0DhWR0nBfrkU1QSxeNSOYR4PBNbGUJKbeFvxgeoKM43lORPB7OyfF4ZQT2P4J/D+GrJo5Tgfz5XgSiEHEg1KmcTT8kwjewNsAvyP8q8ll/NZMTkXI9+2QDWtjIWuR+6amRO9XtHGnsuNAN1Guv0Fv7/cGbxEKKCwkVCcysKz5UehRxBGmmnaz71LMMQndcv/t3iCXoiiTVzBVFtmsogszN4rzwEDN9PYdN1C+P3y0UtS4u+eJxWccs22YhHJfTUDyfw13+Zx788sBa2sxG37noZf/SZf8FH7ikjlooAMAHDVw5b5goNz2XFVvEY8yb5w1I5SN6r9BaW9nbeSGHvozLO/oeJx+k5FE+QDkOAQ1dSVwOZrTIRvl4K7vZzT/b68fTqhJztPRGUWvqho5YdAd32+SZS/RGo9qyciy5LeP05xb53YMSYXG8bYD9GfI1MZK+Ad+Cz2doFqYxyDUn17Jn9CpEOyUnUIvM7nZc31bhCU6O5FYVbbphVHQJCbYzBazrQd/fiN10ty2SgGT+z76EgO7KT6/i6PAKMfp8ljS3bgO5blyfMnBIpx3NvcnstVzAHYIQhBPC9e8fxJ3/s4LHn+6FpHfi1j96PX/npw9hyRYrra8lAkKY2B8JMCFk2ezRQEKVB/p6ZoOJr9z2HNcExsIuSUuMVVmzl9pPbRwj+TmYXWW/b99ILi/aeOyuq8CSnVAPDq8/fYyZlp7jMYfgjZs95+3Imts9hVRmRvE+SOE7TguRt5qqg5NbnCQqlz+03F4Nbk7xFMoTpd2r70MyAZqNlR8BU6s9DVrkDhSZCkyuKCi02aEzmCYuWZNu7l46Zl04wQRlfzVh7I4pHKdCMKBXK6EMUStFeCvpYz9L75JRkDuIgrcj0dvZuGFEIAdz71XH8wR8CrxzsxkDHOP70V76CX/zUJNLdPYCbYsNUfA2Fdax/nqA/ItlVZYipNs6kerSH+9Z1A3MWPjyX1Tm5A8DEo0D2Jdmw51KIpa8Aum+kx5FYxfj/uVr0nguUT1FxVUYDYRnKUMFFu2XIbIFigiW3awdDZnyKktqkJJeTY0j9clMzKaur+ukpxHpXnq7dtaiUrKykOvdDZpL+IrkumDwYSq6cQlJQuARwGSgKmfQzonwe7aJlvBSKJymIkuvnVqhUJyiE2vawKmnkgYASIT4AtL978W3aBeYgcjJJndrIrmkpMF56Ygi//usunnplDTYPDOIffvtv8FOf1BBOJAE3TSWX2cFwjx//F4JhofxBhq7yR4P+ClOW/Hbfxv1qtM5tOchpel8wsc+t0MqNr+LMjv67A+bY8+kfKBxhCKs6Rq/BkN5MYjUF9rlU/vieQt06z1Ig23mGk3xmWE1j/D61RXonnXI28QqXejoVmduYDmad2LngcyPBY5dcLykrFIOpwuWNJlcU1YCFEzoAwbj8UpakUya1tREPwks+8odRL30cfySo+DET7MtYaLtujWR4s6/xdVrmIKSwnxicxO98fhD/85u70ZHO4e+/8CX8/C/EYUT6gkR8x3tkz4IMR3g2Q2C514HSMENMtTEABgVT27uB3vfPzTv4IanZ14FRyXpbHZF5h1aGlNZ8EmjbdXavaCHUprn90qDcb4mWHUHPwnIVjvDYpFY6QQ/HygXxfZ+eBKBlHu0LyA395UpW+7g1ORFNzkpuZNwFWOEW62GOKNLJ5ypspPAOQ3MrCp/HHuDglHAr49JLoXic4aloFy3gRpSHKIizLzKHEemildt105nCSQjG+bP7GG5JbZ7jQdilAv7HH7yC3//L3ShVr8LnPvEwfvd3TWRaV3MfrCo9l8zOQPDYRZmUPsBy0dJJ/r4eBtI7qBza3j3XgnXKTExPPUsCxNzrfE8PM7S06seA1R9bfN7GUqg2NJj5RHihDPMZ6c3nRlniOdIrOihLUuVUPV1OQQu3S34nuYx2UzBHu1aO40l4chbCmJzRMTm3WS/UInsi2gJKEeUtKCg0uaLwieY0MEeRufLsCdjyaQr25Ia5fEfVKdauG13sQk6s47qxPpZONsKaYUK4NsHPO64LiPU8Fw999Ul87j+vw8HBG/GBa17Bn/1xEdu2RynQSxqVWetVwe9bOXJR5Q7I0slJKjNNoyLpu5vrN3o01Ul6MeOPAhNP0zqHRyHXcwe5pzLzus3PBqcU0FH4Q2ugMZTklxGfzZr3q3+sWZnMlpVZhWMUzp4tB9W3AJntzBH5jXPRrsU5qM4HfvlvbUpOThsN+iTMlFRMkjb+fMpwFRTeIWhuRVGdRn1eshFnCGcp+I1omknB14jSCTkg3qFAdGSdfdfNwTquxaqh2ddosXfdMid5PHHwFfzbX9bxzcduxoa+Edz3xadwzwcBrXgUyNuMa7ddHfRn1LLcXuEI8yN2XlYigXO7++9haKcxpFMe4ijW0R8C2edk1RcYRuu/C1j3M+dWd+9WmQcpHpMJWvC/+eGkxOqzC2+nwnBe6RSVjD+wx56lBQ9NNjbuoMKLdgUU1CuZcPY5liqjwThNH2aa5zXWR2/lfBsEFRTegWhuRWFNAa4LaILxeuMssePyIC3xSBvzEI0oSos3cwWTlOOPsMTUTyyXTrEpzSmSCLDzPYEALQ3igX98Dj/327cjX4rhjz57P37zd/oQqZ0C8kXSPHQ00Hk7ZbLW5g8xDOJIemvhMsfRdyeVSqMQLZ6k9zDyAJA7RK/ICHF/V/040PO+uTmLpSAEFWbxRMBMa6bo6SQ3LK9nQggez9wB6aW53CenxKWZ5DHuvIkhvvjAuVc+nfV/eFRuxZOS5kKGkTSDIayWHXLsqVIMCgpvBc2tKMojABzJWTRw1tXJcVSS07Y6gvetWY7sNKJA+3X0GMwkhbXwgnnZZhLo/zDr8QHAteAMPoD/9Lsh/PFXP44rN0/gkT/5Jq7YWmQSOpQB+u4JBLhbY7J59jU5Ac6SpZ4lKp/uW2T4rOG0VKeA0/8KDH9XNgnKvoeWPUDPe5k/WYiiZD6EF5SZ5g8zrKRH5PS+7XOPx1LwbCq43JtymE+Bx0W45L0Kt8oO7r7z68U4G+wilVt5mErWq/H8x3qpGMItDJVdrJnkCgrvADT33VQ6TQGlJ4HUuqXXFYLrQztTsBaOMGTS/8GgF6PrViqQ8UeYN2jZwcl4vuArncbk81/Fx37zx/D4K1vxmZ8v4M9/5cuIeScA410sQfXDRp5NtlY/0eyW2Qldm2EVTfsdQNe82d1OBRj8GnDinxlu0kMUgC3bgbbd5GpKrDu75W/nmSBvnDsQX7MwR9Ri8BzuQ3lQFgP4BH0avTPNAJJbJEle38rTVNeyTKqXTjKcBYBNketl5/iAUgwKChcQzX13lQe5NKIMLyyFmuT8CSXPVBTDD3Ib3e9lF3a4jQJ46FuM1/fcHiS07SIw9jDefOoV3PObn8VYthX/9MVZfGrP/83Gs74PskfBjFM5zb7BKiqnBEDQqyiPcj+6bqYX0chc69qcmnfiK5L2I8zSzJYd5Jdq3c3y26UEo+fK5ryDMk6vUYC3Xs1O9OWUdwpPdn8fl4SCcr6DAK32aA8FdMu2lbfgG72fyoicqKfzP6S3MKR1PlVcCgoK54XmVRSeHcyLNmJnFxzVMTZR+bTQPvKH2Y3de3vA4BnpoCcR7WHs34xT+M6+Cox+Dw8+FMUnfvcLSCQNPH7fG3h3/4NAfggY+CjnZQMUdFPPykqfGpVGbYqJ3vQmdkNnrgisb+EBI98Djv4tqTY0k7QfLdu5v5krqCSWojUvDwU5A+Ew9NW+V1YrLWOwkhBypvURWZo7xfCeIaem+Qnu1AYK65XuZ6iMyLzJKRYp+LmG9mupLN/q3A8FBYXzQvMqCluOdNR0Tl0LLzH3GZDdtSWgc/1ci3r6OXoPnTcD4z+kFd6yXfIeXcPtV8ZYDjv7Kr7y7R349H/9JHZut3DfX38bqzrHgUqJCqX/gzJR/Zwc7iNHtMJlriHaxXnd7dcGyVXhsYP64J8Bs6/wvZYrGV4KtTAf0nXL4orQytHqn329Ie+wiVVQ8yu7Fj2WeWD2TSootyL326XiSG8hLUZiLZXDSnVA+4qzdCqg5wDowSXX04OL9anmNgWFSwDNqygqw3LmsQbocbKeLoXCcYZHGsNOQtACj3YDhYPAxGMs4ey/m0LWs+kVzLwClAbx9/fdjF/6/Ttw2w1TuPcvvotUJgaYq7nd7vcyxDT7WtBhbMQZU9dNKoiumwLh7TfsHf17YOJHVDDpHUCPJB0MpcgRld52Zh5CeEHzml/SGukEEjtlA98yTqvwqMxy+0nFYc/weGoGQ29GjEqi7eqV7W2wZqkYcgdkvkGjAm17lyQM7FGjOBUULjE0r6IoHGGSFRo9CmOJsIRdIJ2F33nrwyd3iw2wsijcCmz6Jcbgq1MMP1VGAGsWX334dvzS79+KO24axr1/9Qiife9maGrom1xOPs6wlfCY8NZiDDlFOhg2ar8msI7LQ8CJ/wUM30evKNoPrP0UEG2nsJ5fftv4P0qnJPPrLKuNWq9mYnq5JHR2gd8vHJET5Kr8zXALEOoLPJH46pXLO9hFhveKJwLPIdw+Z2CTgoLCpYvmVRSlQdTZO0OppRVFZZRCPL1tLu3E1LOMxYfbaUWv+1kKzNk3yZUkFdEDz1+Ln/vCLbj12hHc+8WXEV39Ya53+luM4Xs2f1+PBvO7hcN1um8NqEKcEjD2KHD8H1hiGkoCqz7O/XIL7GXouG4eh5NH5ZA/RAVT775+3/KqnnyUR1jiWzzBkI9wGeaJtMuk9HaGllbKmrdmud/FYzIZDSrN9mupjFZihraCgsJFQXMqCqcUWKb1oTRLWKWVUZaGprcE79WywOD/plBPbwxmQI89Qus33A5Ys3jh9Q58/Ndvw5VbsvjW17KIrrqHwnn6RWD0QYZLQhk5wazE7ekGkJQJazNGhZN7Axj8OjDyIC341t3Aun8DODkqsZYrWFLbKKjLI8DU0/Q6jBgrnzI7lu89uDWGp/KHZOd3jiGvcJqhqvSWYJLaSsC1mOfwPR6AfFlt72beYaUb7hQUFC4KmlNRFE9Q2AoRDKpZKumZexPQY0HYyc4Dp75GAdy2h8I91geMfJfvJdYB5SGcOuni7s/che6OKh64H0it3hkkn49+UdJSbKOw9xzuixEl/bdP7VE4xmqmkQdoYYcywJbP0XOYehqAAHrvDMaTAgx7TT5BZWjESSWeXLd8a9+tyqFJ+xt6HnQ21cX6mMdIrF25aWqVMSqj4jF6UpEOdrXHVynPQUHhMkBzKorKCMtVhR96WoLF1LPpURgxCkmnxLGmVi5gCbVmmBzWwwyNzLyE8sw0PvjZn4PlhPDgg0DP2g4qmNEfsHHOiHAugj3DfdD0oJw2lGRyevIprj/xKPe162Zg27/jdyYe5e/33h54CMLj0KPsPpbHtu05s1N7KTgVVj/l3pRzIsD9jK+iRd+yY/kd2Gf9LclaWzhMT0ULsQw3tSXoXFdQULgs0JyKwikCZkTG2U0gsoSiqIxRkLVspzA//U2WgEY7WUpaGaaATm5kldHYIxDFk/il//qT2H+sDd+5D9iyI0ShOPkU13UdALpMWhsABJDZze9Do7CefJbJ8PwBKqONv8Ty2aknqZSSG1kF5SuB0mlg+lkqrcQ6frbcUlSnBEy/IMkFJ/n/Im0ML2V2UkGsVGK6Msb/VzoFwGPorXUXFZEqZVVQuCzRnIrCtWjR1pPZrYuv67OyJtbRk3ArQO9dwKE/p2ciHGDVRxneGf42kHsTX/7eB/DV+7bh939P4M47waT37GvsQK6OA+WTQMsuWeEUplBPbWR1z8RjQPZVKgl7lh7BVX/IEMzwfXyvfW8wha+W5fYrQwyhdd925hzvpY7DzMv0QiojbFKLdFJot13NfVqJ5LTnyDkZB4PcQ3o7lZDKOygoXPZoTkUhHNkUJmjVh5dQFKWTAAwZWjKB3g8wvzHzKmP5mSuA/g8x0Zx9AUenr8av/uFtuPVW4Hd+2wFGHyE1R3o7Y/3jj7KcNpxmyKjvDlZSFY+zomn6OUkwGGIV1eZfoZcwdB/3p+8u2aPhkEE29yY9m/a9TGgvh0RPeBTcU89L9lcXiHWRw6n1quVzOJ0Nnk0KktnXWM0VyjB8lli7sqNHFRQULmk0r6JwpKLQjIC+eyEUjssZDxbQ8wEK9UN/yZLNtt0sXx36JjD5ONzYJvzs7/00wmEd//gPNRjj36NH0n4dew5GHpDzs/vZGNZ7OwAdGH8MyL7E7u3qGD/f8QX2TuQPAZNPMkfSdzct8Nx+ru+WqYDa9yy/l6B4giGw/EGGnOKr2MXcfu3yacbPBqdCT6VwmEo1vprhpfMZoaqgoND0aE5F4fmhJzCJulhljWsB2edpgXffxtDO0H0ku4vKEE3hODD+MJDahP/nW5/G089G8E9frmFAfBOoFknaVzgqK4imKZjTW9mJbc8yWV04QmVgF2lxb/8PVF5Tz5OWI9bP9b0af786xp6JvrupVJaDyjh7O2ZfYzVUrJ+VRW17Vi5BbRfo4eQOMIwVX80yXpWcVlB4R6M5FQUgB/0IhpNCi8TJx77P2H3vHVxn+LtULOFW2QSmAWMPAclNOGn+W/zeH2Xw4Q9a+OmbvsGwVN9dFJzFk5KiXHCoUOcNrKQafYhKYupZAB6w/meA9T9PL2f8UfZjpLexXDZ/kIJeM9hfkd66vPJUu8gk9/Q+oDrK/o6uW9m5vVIWvpUj/UjxGF8n15NS41xmYisoKFy2aEJFIeRCjkDVIwuzmOb2M0RjJph0HX2IlUDpHcDYD+mVZJ+nwN7yG/j1j6WgaQJ/+R++BQ0uqcVnXmYHuCMJCPs/xDkQuYPAxOMU3oX99A62/Ra9FuEyRFUdDRrNRr7HZHVsAOi+eZlMrh7DU9PPkuE2lAJa97ApL71pZQ5lLQvMvMRwlmZQqbXuUtPgFBQU5qAJFYWEXQYpxiMLx/dnX6dXYKZoKac20bOYeSmYj92yA9j2BXznoRS+8x3gT/7jC1g14ABdt7F6yZajNWtTVCg9H6CnkH2FiejKMBPIO/4zkNlKxTX+CENL3e/ld09/g4nlxkqns8Ga5SyM3AF6TpmdrKyaPx71fOHZVHK51wHorMzK7FxZ2nAFBYXLBs2nKIT0KDybS30BQkCnwt6J8giXqU0MGekhehaVMSaA1/wEaiKFz3/OxfZNeXzuF07SKxh/mGR5ZpKlteFWUmeM/5D5iuw+9iu0XgVs/Ty9BoAssKWTtPzLQ0wGR7qCJryz/jePXtDpe1kpldpEJtv2a1aGOM9zgfx+WfFVZi9Hx3VqzoOCgsKSaD5F4YeevCqXZuJMIVodZ7imPMTy1767WXY69SxLWI0w0PEeILkRf/anVRw7HsX3v/ISQn03UEm4VSoVt8xSU3+UqJWjp2LnSAe+7meDyXdTz1IxpLdz6eRpqfszLc6G3CFg6F7mMsLtwJpP0ItYKR6m4nGGsqwsm+R6bye9t4KCgsJZ0JyKwvNYIgtI1tZ5Nf25NykYQ0n2TegGheTYw7Taw+1AaiOy+Rj+2x/ruOe9p/H+j++gR+Ba5Fdy8hwYNHw/+yhCLfQm3DLQcxuw+hOBkvDnUMTXcDyrWwX67lleuapbJe/U+GN83fVeTslbqUa28gjDZLUJAPq5NfQpKCgooBkVhRAAXEmjAeYo5lcPFY5LcjoqBPYt7JMhKgHEeoF4P/7sD04hV9iOP/q/IiTos/MNSuJm5jZmXmK3c/4It9nzfgpynzp85jUqikg3ey4ggP57lmetz77OuRSVEXof639m5az8xkl7RoKVWqnNKzvbWkFB4R2B5pQans2qJ2gk1puPyhCreIwYhX9+P6393AGGrCJdyI2exn//0vX46IfL2Nn3LFCZIB2HWwI6b2Ln9ODX6UH4U+R6bmPOwFcSuf2sStJCVBJmnJ+frazUrQEn/5n5CCMMrP85Nv6tFJtr4Ri37VkcbNS6SykIBQWF80YTSg/RoChw5mwGt8qGNE0P5kDEV7OsdPDrZGX1avjyv25EoRTGb376DfZE6CF2b3feRGVy+pssjTXiQDjBnEb/nYGSyMsmOyH4vbhsqjtb5VBpCDj5jyyxbd0FrP3plWtocy1ZTnuQXlDXzYvP2lZQUFBYJppQUUDOovDk0KJ5iezKKAWmVQBMl9TivbezV6A8AjhlCD2Gv/n6HuzdU8b12/bRIxAOR3O6Zcb0sy/R8k9tpEDv/UCgJCqjLJ91LVrq8dX8jbNZ7RNPMR/hVckku+rHVs7SL50Cpp6TTLk75ejVZfBGKSgoKJwFTagoBBWFJ0NPsXkJ4+Jx5hisGSCxmr0Tuslkc3kQMBN47OSncPBwGF/+42eoDHRBQj6nwIE/M6+xcqplB5DZxbBQch2370hiwNokSfIS61j+upRQFh7Hpo58Fwh3ABt/EWi9cmUOh1OhZ1M6AZhplgE3zgVXUFBQeIu4oIpC07Q7APx3AAaALwoh/tu8z1cD+AqAjFznC0KIB5bcqAAVhV8mO786KH+I4R0jRqvdCPP9ySeYr2jdhT/7H7vQkrLwE+9/VQ7c2SSHBr3O+H7hCENarbtJ1+2PUHWr7LrOHWAeomU7S1iXKn91beDIXzGZntoMbPrlleNmyh8KZnu37ibtxkrNvFZQUFCQuGCKQtM0A8D/C+D9AIYAvKBp2n1CiP0Nq/0nAP8ihPhrTdO2A3gAwNqltywosIXHhHXjLIpalgyuukmr2i8DtfIc7BNKIx+5Ad+5P4SfvPMAYjGPuQW3CpQPMzRVGWI4K7WZfErte+TPCmD0+2xWCyUpmLtvWXpXazPAgT9leW3Xe4F1nwoU11uBXQw6wKO9pBVRvEwKCgoXCBfSo7gGwFEhxHEA0DTtawA+DKBRUQgAfja6BcDIsrbsVuTQoFDgUTgVWvtOAYj2A6EEEJVJ4twbpMIIZ3DvDzYCAH75J15gmazwgOoQm+lKx+VYVR3ouiFQEgA7rrMv8jfbr6UnsRSKJ4GDf06G2fU/z4qplUDxBDDxBACPCfaWHStXLaWgoKCwAC6kougHcLrh9RCAvfPW+T0A39c07dcAJAC87+ybFVQK/iyKcIahl5EHSN4XbiOdtxEPrOzpfQxX6VF87btr0NVWxI03uAzT1CYBGGzSS6wLqMT7PzT3Z4fvZ5nsqo/Rgl9KOGdfBI7+Pb2QLZ8H2pbJ8bQUnAqT7IVDpAXpuklVNCkoKFwUvN0B7U8C+LIQYgDAXQD+SdPODLJrmvYZTdP2aZq2b2ZmhgllIRWFmWYPgzUNpLYBGuglRDqCGc6zrwJCYHI2hR8+tx6f/vhhaGaM5HvhTs6xjnTzO/CoDBqT07Ovs3mtdRcT10vlAaaeB478LcNX2/79yiiJ8ghw+l+pJNLbmXtRSkJBQeEi4UJ6FMMAVjW8HpDvNeLTAO4AACHEM5qmRQF0AJhoXEkI8XcA/g4A9uzeLsjzJGdRGGGWhALsrfBcsBpKzmpwq6yE8hx8+Xu3wXUN/MRHK6yMSqwBBr8BGCmgZQs9hpbtQMvm4MerU3KdGLDmk0tXN00+DRz7IsNX2/49EO89tyM2H26NuZX8AVKI9N219DQ/BQUFhQuAC6koXgCwSdO0daCC+EkAPzVvnUEAtwH4sqZp2wBEAUwuuVUB9i8A9Bj0sByLChLeeRY9jZicHFc8wfyDV8O9T78XXR01XLVLA7IVYPgBABrQfjW9kFgvy239Jj47z5CWNcvE9WJWvBDA6A+BwX9mo9u2f/fWqTjKQ0zMu2Uqr/ZrAg9JQUFB4SLigikKIYSjadqvAngILH39khDiTU3T/guAfUKI+wD8FoC/1zTt89VoAgMAACAASURBVKAK+DkhfB7xRbfMZLYGKgk9zLkRRoK9D8Ij/5M/YnTiSaA2helCBs8e2I7P/YYHrXyKQ4ngAd23A14ZyFzFEFVcOkF2kYrEKZP8r2XHIrvjAUPfBobvo3La+ltApHXhdZcDzyHvVP4gvYjej3Bsq4KCgsLbhAvaRyF7Ih6Y997vNjzfD+D6c9+wB4aewrSynSJLVmdeYWhINzlNDuD8CbeIb7zwiwCAO99f4cQ5K8tBRF6ZpbBuhev7JbXjD9OaT61nxVNyAcZVIUj1Mfxd9mJs/uxbY331K7esaZIEtr1bdVcrKCi87Xi7k9nnAdlHAdBz0EO0/o0E8w6ey3xCpBWo5UjFoYXx+KFbYBgC79v4z5wX0b6XJbSRDlYQVcaYGDcTbGSrjpMfys4B0Z4zBw8JAQx/h93WqQ3A5l95a0qiOgkMfZO/13sHf1spCQUFhUsATagoAMBjoEqPAtBkjsKjRa4ZLJHVQxwE5Jbghbpx7xN78cmPFaGPfIOCP72RJa4976dwdvIcB1rLknk12sOHNUO+p/kYeZCT6BLrgc2/9tYa3vKHGboSkqI8sfr8t6WgoKCwwmg+richGMfXwBJUtwzAA+wSl8JlQrk8Aow9AkDDS6evQaUaxs1bHqQ30nkrE9XdtwGhFENWAJPZ4w8zpNXzPuYJACCxdu4+jD1GwR5fA2z9HLdxXv/FIwVH7k0m0btvXbmJdgoKCgorhOZTFADLYAXYVGfLiienQAUCjeGk8UfYPGfG8cir7PO7a9d32VQHh/0Ifj6ieJxT73L76UH0vI904aWTbG5rpA6ffAoY+Q49iI2/cP5Kwq1x4l5liISEHdcqniYFBYVLEk0omQTLYzVQgDsFvm0X6C2YUcb73bIcl2rgG0/cgO1rB9HXK/9ufBXQIZvE7TxQm5K5if1UIMn1VEC1qYA1FgCyL1O46yE25SUa20TOAXae+Y3KMOdfdL5HKQkFBYVLFs0pnfx52WYi6KFwSlzaec57aN0DWFOw3DjeOLEGV20akd3aYaDvjqAnoXCUCfDSKSDcCnRcx/dLJ7n0w075Q6QXt/NA541kaj0fVMbYwGfnSQnesvX8tqOgoKBwkdCEikIE0+380JMeYULas+kFtFzB/IVTwouH16Nci+GjH3FI/pfZMbcZrnCEQlvTSPbnVxqVTlJxhFso3McfYxNc5ioS/J0PEV/pFDByPz2h1R9TcyMUFBSaAk2oKBDQdJgJhp5CKfZF1KaoPPo+QMZYu4gfvX41AOCm3UeoUHrvCrZTyzLp7VWB1JYglORWOcUusVZ2Zz/EPEZqEyfZzZ+qtxzkDpKmPNxKrqb5I1wVFBQULlE0n6IQACBDT0acoSc9RlpvtwKkN1OQTz0H2AU8cfB6bFs/ga74UQr6xrxC/pBkY+2eRyk+yB+Kr2blVPkUEO8ja+z5zLeefgGYfJxVVf0fOvtcbQUFBYVLCM2nKCAaPAoZeioPA3aWr1OS0G/mZXge8PThPbj+qpO04JPr2KTnY+IxJpH7bp9bllo8AZhJlq0WDrPTu2UHkLniHHfVI1/TzMtAeivQe+fKzchWUFBQuEhoTqkl3KCPQthMSMMgN1JE8iKVTuCNoSsxW0zjxmtmWP4a7Qm2UR6mIui4jlVOPjyHJavQWQXlVinku24+x30UwMTjVDSZXUDHNW/xTysoKCi8PWhCRSEk15PGedcAE9m6SW8h2gGUTgNOCU8euhYAcONtrQBOzU1iD0sKqv4Pzt18+TTLazWdYa5YL5PX58LcKgS9lcIRVkedb4WUgoKCwiWA5gs9CQFKcI2VR8JjnkK49DAiXWRfdWp46tC16G3PYu1myebqs7BWJ4DCAdJvzKfLyB8GikcBzWSSvH3vuc+AmHqGSiKzSykJBQWFpkfzKQpI5liAPRGeJedTSNbYaDcw/SIgLDx1aC+uf9cUNGuC3kdI8jFlXwSsAtA5j7hWeMDUsyQYNOJMXGd2ntvuZV9ixVXmShVuUlBQuCzQfIqi0aMwpKLwavQAoDO8NPs6hqd7cGpyFd5znctQUqSDHkjpNDmcop2ccNeIyihQHmTYSTfZWHcu/RK5/UB2H6ur2uePB1dQUFBoTjSfoqh7FBofnsuyWN0AzBiVR/4gnj7yHgDA9dcb7K/w8xPZFwDXYcjJH27kY/Y1cj0ZCaBt97kNDMofASafZElt183n15CnoKCgcAmi+RSFEIAnZLLZ5dKtglVPGY49tbJ45uh1iIYt7L5SsspGO5mbqE0B4TTXnU/oN/ks8x2ZHUDr7uXvU/EEk9fRHtKWK94mBQWFywhNKNE8udTI+eRaXOoy+Tz1PCAcPH/s3bh66xBChhxyFOmStOEGZ1bMp8+wZoHs88xx9N6+fGFfGiRRYLSL3E1q2JCCgsJlhuZTFH6OQjPI7eSWKZw9h30UU8/AdYCnDu7F7m0THGakRzmhrjwsG+u8M8NOo3I8at/dy69yqozze5EO2Ux3DiW0CgoKCk2C5lMU9YonqSicIgCdKYtwKzD7Ko6Oc87EhrUWw03RbnI2OQXUcxuxvmCTng0MfpOjUAc+urzdsPPA6IP8Tt+dzI0oKCgoXIZoPkUhZDJbgCEnp8zXepjd18WTePXUlQCAW24ocMRprFfyNwHQBLu3G6k8pp5htVPP+wBzGQLfKQGjD/F53x1zt6WgoKBwmaH5FIXvUWgGK4ucEiufjAgQaQWsabw6eCUM3cX2TXJGRbQbqIxIEsEyX/twq8DQ/cxvLIemw3OA0R9wUFLP7W9tVraCgoJCE6D5FIWQyWzdAIQmw0ke8wNmC2AX8OrgVdi2ZgiRsA1AZw6hMsIchnDmlr0WjpAdNtK5vC7qqaeB2gTQeQMZZRUUFBQuczSfoqh7FDoAj/kF/7VdADwLr53agas2DVMphFvkUCOLXggwl/Mpf4i9E5krAeMsyejCUVZOZa4knbmCgoLCOwDNqyhgSLpxSRCoh4H8AcwUkjg9PYArt0xSiYQy7Lj2v6tHg6FBdiGgEU+dRfBbM2SDjfYC7YqaQ0FB4Z2D5lMUfjJb0wG40lOIUFHMvILXB3cAAHZumZUeRStQHWe3tV2Y600UTwDFU5w90bpr8d90q2Sb1UNA962qoU5BQeEdheaVeFqIHoNnA7rGHEPhMA6MbAUA7NhcoED3FUW4hRVQjf0TxWNAbRKIrzqzr6IRk0+RJqT3DvZjKCgoKLyD0HyKQvh9FCbg1liFJDSGkypjODK2EdFwDQO9Ftcz4zLhLfMTEelROGVg9g1WTqU2L94HUTxBhdJ29blxPykoKChcJmg+RdGYzHbL7J+DYHmrNY3DY5uxsX8UuiGpOly74Xt60HVdOklvQg9zzOlCcGvA+KOsmloqNKWgoKBwGaO5FYVwJJGs9CicIo6MbcTmVaMckRpuBawpru9ZQKQtmFldPMkEdawfSAws9ENkgxWOpBtvwkOloKCgsAJoQunnh54igF3kaz0EuDYc28WxsbXYtGqSMyoiHWSLNdNUCn6jneeyLBbgOrEF+iEKx2TIaY8KOSkoKLyj0XyKQjR0ZgsBNtuZQGUcg5N9sN0wNq+ZBqDRo6hNc0SqsJnwBoDqGB8AkNp4Jpmfa3HSXbj93OjGFRQUFC5DNJ+iqIeeTEDUWC6rhYHKMA6PkAxw02qpHPQYE9l+2CjSwWV5iJ6GHgESa8/8icknmf/oOscJdwoKCgqXIZpPUdQ9Co3JZiGkRzGCI2MbAQCb185Ioj65rvDogfi8TIUjLKuNdpw5l6I8AhSPAultc3suFBQUFN6haD5F4UMPsRFOePQMapM4PLoRqXgJXW1lehSuHFokHIaRNJ304MUTVC7R3jOVwcwrJA/suPbi/ycFBQWFSxBNqCh8Cg9ddmXr9B6saRwZ24TNA8PQzAgJAO0Zdm3bhYaw0zBgTQdhp8ZqJqcCVIbZV+FXRykoKCi8w9GkisKfcOdQ0JtxwMrh8NhGbBoY5efhDBPZpkxk+5VLpdOkJg+lOKeiEcVj/G5600X+TwoKCgqXLppQUUjoBkNK0AA9ilrFxqnJ1di8agwQriyJzaL+FyMdDFMVDlLJhFqAWM/cbeYPcr1w68X+NwoKCgqXLJpPUfjJbH/CnRxtenysH54wsKl/lN3WRpgKQ5OjT0MZVjpVxlgxFWqZm58oD1OxpLdf/P+koKCgcAmj+RRFHRoVAQDYZRwZWQcA2LxmiorCc4L1Qml6IJVRJrP1EENRRjTYXOEwl6kNF+8vKCgoKDQBmlBR+OWxkMpAA+wZHJalsZtWS0Xh1sCEtx2EkiqS2sOMA+G2hk0KlsVGu89svlNQUFB4h6MJFYWE0Bh60k3AyuHI2AZ0pLNoTVclpXihzv+EkN8/cZRhJyM+N5FdHgLc0uLkgAoKCgrvYDSpotAAzQsa6ewZHB9fh/W9owA8UonXZAksPEkOmONcCoD5icb5E+XTXCbWXOw/oqCgoHDJowkVhQw9+bOyjTBgz+L5Y3uwpnuSYaRwhh6C3wsRaWPpq50HzBS/43sZQvCzxFoVdlJQUFBYAE2oKCSE71GE4Nk15CstiEUdJq2hBetAl3Ozx8jfZMQ40c7ncCqd4PS6pEpiKygoKCyEJlUUsuJJA6CbmMjGAQAb+ic5ItWvhvJnZmsaq5rMBBv0fLpxACge53IhckAFBQUFhWZVFILKQHBq3akJNs7t3nRC9k849BycckA1bs9KYsA0EJWNdp5NRZHaLD0RBQUFBYX5aD5FIQRkbawMLWk4NcHBQ2t6JiRZYIWd2W6Jo08rw4CVJ+24EQ/oPIonuFRJbAUFBYVF0XyKwoc/tEgIDE5SUazunGSy2s4FHkK4TeYnKoAZ42s/aV0e5FIpCgUFBYVF0byKwvcoPAenp/uRihXQkswDelTmKORfC7cCpVMslRWiYRyqw7BTepuah62goKCwBJpXQgoXgAY4RZyeHsCqznHWOvmeRL0zuwZUJ+hNmImA38nvqfDpxxUUFBQUFkQTKwq/n6KMoWwfBjqmmKz2+Zt0k4qhNs1QFCQdeX0uxWm+l9r4duy9goKCQtOgeRUFBMte7TwGp1ZhVdckOZ6gM5Ft50kjXpvi/IlwO9f3x6GWBknjoZrsFBQUFJZEkyoKrV4aW6tpGM/1YKAzS6Gv/f/t3X+U3HV97/Hn+zszu5PNJptfBpWgiSUx5BdJCDEx59oNgUqRE2hBIgfPFfTqsRx60qunigFSpdaDlqrXgsfGmkNpq0mQRnMtrW0KKco1YpCIJPwKGGExQH7tJpvN7s7svO8fn+/+SMjOziY7M/vdvB7n5OzO7He/89kvy7z28+v9tTCh3XUszE+0vRLmIKIolPawKJTzyDVr74SISAkSeL/P+A53dEGU4nf7xwIwpq4z/rL3zlOk6sMS2MxYwHqHnY48Fz6OPq+SDRcRSaTk9igKOSDilf1hFdPcd/0W8HD/7J4SHrnQc0hlw/PdQdH+WhimyoytRuNFRBIluUHhYQ/Fq4fC5rkpk/aFJbDdd7SDMDeROwrpcXHpjreEZbEd+8NubBERGVBZg8LMLjez58xsj5nd2s8x15nZbjPbZWbfLe3MHt7wLcVrh8Ny17dNbA73moCQE6lRcPx3IVDSWSAKcxbHXw1La7XJTkSkJGWbozCzFHAvcBnQBPzCzLa4++4+x0wHPgcsc/fDZjb51Gc7WTxPYca+w5OpzbQzbnQLROeEooCFXJjQ7jgQehKeDxvtLAp3uSPqrfckIiJFlbNHsRjY4+4vuXsnsAG46qRjPg7c6+6HAdz9jdJP71Bw9jWfw9vGv4FRCKueMmPCcFOqLpTuqBkXeh+18a1PW1+Kb3mqIoAiIqUoZ1CcC7zS53FT/FxfM4AZZvaYmW03s8tPdSIz+4SZ7TCzHfEzYXVTVwevNZ/DW8cdCMNNlg4rnfKtQCF8jLLxxHUcGPljvXspRERkQNWezE4D04FG4Hrg22b2pndxd1/n7ovcfVF4Jp6sJs9rLefw1vEHgVSYyE5lgEIYfsq3hlCIUuFj+2uAQ/20CvxoIiIjQzmD4lWg70aFKfFzfTUBW9w95+6/AZ4nBMcA4vIdXe283jKZc8YfAqJ41VM8pFTogK72cH9sCEFx7LfhuL43LhIRkaLKGRS/AKab2TQzqwE+BGw56ZgfEHoTmNkkwlDUSwOfOvQo8l1w4OgkzhnfDOahtlN3DajOI717KiwVJrfbXg17KVS2Q0SkZGULCnfPA7cAPwaeATa5+y4zu9PMVsaH/Rg4aGa7gUeAP3f3gyW+Aq8dmoB7xFsnHIwLAtbEXypAxxvxrU8JvYpCvPlulFY7iYgMRllLeLj7Q8BDJz23ts/nDnwq/jeYMwOw71BYTZvNdIWJ7KgGCHe9I3cE0vWE/RPd8xNAncp2iIgMRrUns8+A81pzKMnxjsmvA93FAI8DDl1tUPvW8DEzDlpfDGGi/RMiIoOS0KAIJTwOt4ZaTe8859UQAjUNYQ+FF8Iy2NpxgIceRWdL6GFo/4SIyKAkNCiC15tDnadzxu4PE9Sp0WFJbCFPmMSOR9YyY6HzoIadREROQ4KDwnjjyCRqM+3Uj2oLd7SL0oRhp2Oh1lP3fotCIdR3ypZYIURERHokNCgc3DlwZAKTxhwKBWO7727nHmo8pUcBhTDclDsUvk1BISIyaAkNCsAKHGydwKSxh+IKsaPC813HoSsfNt95V5jIbt8fSnlkxlS3zSIiCZTcoCg4B49OYEJ9c1xWvC5Uic0fAwph93XuSJjI7tiv3oSIyGlKcFDkOXRsAhPqj4THqWx8M6MCFNrDxLXnw6a7zkPhpkUiIjJoCQ0Kh0IXh4+NY+LY5nAPiigT6jsVcuG+E91lOrwQPtaqRyEicjqSGRRmOAUOtU5gfP3ReMVTNiyN7VnxFCt0hI/qUYiInJZkBoXD8Y4acl01jK8/EvZLZBog1wr54yEovBBWQuVbw47tVLbarRYRSaRkBgVwuDWUDx83+kjYbZ2qDb0H7wqhUMjFK57e0ES2iMgZSGZQGDQfC0ExfkxreCKVDfef8C6omQT5o6FnkW+FWg07iYicrmQGBdDcFuo8jRvdFu5sZ5neoKidEIoBEk9kq0chInLakhsUcY9iXP1RsJowod11PARFuj4cVMgBFm5WJCIipyWhQWG0HAu7rBvqjsYT1YUQFFFNWB4LoYdRMyGuASUiIqcjoUEBzW2hR9FQfyRe5eQhGFK1cU8iCru0tSxWROSMJD4oxtU1Q7oOKMRLY7OAh16E57TRTkTkDCU2KI4cH0Mm1Uk23RGCoqsjlO5Ij4ZCZ7iHNoSJbREROW2DDgozi8zshnI0pmQegqKh7khcEHAMdDaHTXY1E8Jd7gq5cGymoapNFRFJun6DwszGmtnnzOweM/sDC/4UeAm4rnJNPFXjoKWtgbF1R+nZQ5FvBQpxMBRCmXEIcxYiInLaii0H+kfgMPAz4H8Bawh/v1/t7jsr0Lb+uXPk+Ni4R2FhZ3b3HoooC125UDk2+7aqNlNEZCQoFhTvcve5AGb298A+4B3u3l6RlhVlHDk+hjHZViAVlsR2Hg7LYlMZ6AIKXVCjYScRkTNVbI4i1/2Ju3cBTcMjJACco+3dcxRRKArY2QypesAJ+ZfX/ISIyBAo1qO40MyOEIabAEb1eezuPrbsreuX09LWwAVTXgzDTt1VYmsmdjcvHFYzrnpNFBEZIfoNCndPVbIhg9M9R3G096ZF+WMwemqYpyi0h+dqxle7oSIiiddvUJhZFvgkcD7wFLDe3fOVathAjhwfy5hRrXExwI7ech35tjAUBeE+FCIickaKzVH8A7AI+DVwBfA3FWlRCTrzaTrztYwd1RomrymEf1Em7Mb2rjAMZTbQqUREZADF5ihm9Vn19B3g8co0aWBHj4fqsGNGxb0HzwNpqJ0Yhp280FtBVkREzkipq56GzZATQHNbmKTu8lSYzM4fA/NQvgNCjyKjoBARGQrFehTz41VOEJYSDZtVT8c6QiBMmfh62IGdOxKGnaJMKN1hBpkqLsoSERlBigXFr9x9QcVaMgit7d1DT8fCTuxcfNtTCqF3kRmriWwRkSFSbOjJK9aKQeruUdSPaguVY/PHQlAUCmF+wiLdh0JEZIgU61FMNrNP9fdFd/9qGdpTku6gGJ1th2hyGHqqnQh0haCIanrnK0RE5IwUC4oUUE/vzuxho62jDoBRNfHGuq7joUfR1aH5CRGRIVYsKPa5+50Va8kgtHWGoBidPQ5RFJbHZsaFwHBXUIiIDKFicxTDrifRrbtHMbrmGHgKCvkw1OSFEBppBYWIyFApFhQrKtaKQeruUdRl2+PFunFQFDrCjYpSNdVtoIjICNJvULj7oUo2ZDC6g6I2E+8J9EK4y11Xe1guW6sVTyIiQ2XQ98weDo53jmJUTRuWioed8NCTyLWGjxntoRARGSoJDorjYYVTV1tY+YRBlA57KFTnSURkyCQ2KLKZdrBUWBIb1YZNd10dISQskT+WiMiwlMh31PZclrqa40AqVItNZUM4FDp770UhIiJDIpFB0TP0hIWeRFQbKsZGGd3+VERkiCU7KKJMWBob1YRJbUtB9pxqN09EZERJZlDkRoXyHVjoSXTvoYgyWvEkIjLEkhkUfSezvSvUefJc6Fmk6qrdPBGRESWRQfHSG+8iWxMXAPRCmKPo6ox3ZY+qdvNEREaURAbF2FFHOHh0Qm+PIl0XVjxFGZUXFxEZYokMinxXmvPf+tKJQ0+FTkjVh013IiIyZBIZFO25bJijwIFCqO8EkNGObBGRoZbYoKjNdNLT/FRNmKvQsJOIyJBLbFBkMx2A99mJ7QoKEZEySGRQdOZrQ4/CHSwTl+4wBYWISBkkLijcw433QlDkwuR14XhYIptSUIiIDLXEBUWhOyjSneEJL4SeRVSjyWwRkTIoa1CY2eVm9pyZ7TGzW4scd42ZuZktGuic7qHJ2ZrOeLNdtrcgoIaeRESGXNmCwsxSwL3AHwKzgOvNbNYpjhsDrAZ+Xsp5u3sUISjyYcVTV0dcvkNBISIy1MrZo1gM7HH3l9y9E9gAXHWK4/4S+DLQXspJu3sUtTWdcU+iJhQETI0KoSEiIkOqnEFxLvBKn8dN8XM9zGwhcJ67/2uxE5nZJ8xsh5nt6J2jyAHx3EShE2omDG3rRUQEqOJktplFwFeBTw90rLuvc/dF4V/co8h0EoIiE3oWKi8uIlIW5QyKV4Hz+jyeEj/XbQwwB9hmZnuBJcCWgSa0T1j1VCiEHgVoIltEpEzKGRS/AKab2TQzqwE+BGzp/qK7t7j7JHef6u5Tge3ASnffUeykvfsoOiCKws5s165sEZFyKVtQuHseuAX4MfAMsMndd5nZnWa28vTPGy+PzbQDUdiRndLSWBGRcilrTW53fwh46KTn1vZzbGMp5+weeqpJd4BFYS+FKShERMolcTuzne7lsblQZdxSugWqiEgZJS8ounsUUSdEFgdFRrdAFREpk8QFReGEooDhcwWFiEj5JC4oenoU6VyYyMZC6Y4oVd2GiYiMUAkMitDkTCYX37SooKqxIiJllLygoLtH0RnmJ7wL0goKEZFySV5QeN+gSIebF2UaqtwqEZGRK3lBEfco0tYZNtq5Q1oT2SIi5ZK8oPDwMYr6PshWrT0iIiNdAoPCSKdyYcFTVBvumZ2qrXazRERGrOQFBUY6yocHRpinSKlHISJSLokLCtxIp/KElIjCZrtIPQoRkXJJXFD09CjivXbqUYiIlFfygqK7R+EGHvcoNEchIlI2yQsKCEFhFpY+RRmtehIRKaPkBYUbmVQuPLB0PPSkHoWISLkkLyh65igshESUDTcwEhGRskjeO2zPqidCQKggoIhIWSUuKHr3UVgICt0CVUSkrJIXFN09CotvWqTKsSIiZZW8oKB71VMqPNLQk4hIWSUvKLx76CkK/7Q0VkSkrJIZFN1DT2ZaGisiUmbJC4qeyexUvCtbPQoRkXJKXFD0LI81V0FAEZEKSFxQ9PYoIohq1KMQESmz5AWFQyadAy/ENy5Sj0JEpJySFxR9S3hENZrMFhEps+QFRd8bF1mkoScRkTJLXFDQ06OIQyKqqXaDRERGtMQFRe8+ighSo1Q5VkSkzBL3LttTwoMIUioIKCJSbskLCjfSUVdcObau2s0RERnxkhcU9JnMVolxEZGyS15QeJ/JbAWFiEjZJS4ooM8d7jRHISJSdokLip4eRZTRZjsRkQpIXlBgoYSHpUNYiIhIWSUvKJzQo0jVQpSudnNEREa8xAVFzxxFVBt6FSIiUlYJDIq4RxHVKChERCogmUGRiiezNUchIlJ2yQ2KVFZBISJSAckMiiivVU8iIhWSzKBIdYWQ0ByFiEjZJTMoonxYGqvlsSIiZZfMoOiezFaPQkSk7BIZFJmU5ihERColkUGR7g4K9ShERMoumUERdYXlsWbVboqIyIiXzKBI5XV3OxGRCkloUHRBNKrazRAROSskNCjykFJQiIhUQjKDIopLeIiISNklMyhSXZBWUIiIVEJygyKlyWwRkUooa1CY2eVm9pyZ7TGzW0/x9U+Z2W4ze8rM/svM3lnKecOqJ81RiIhUQtmCwsxSwL3AHwKzgOvNbNZJhz0JLHL3ecD3ga+Ucu50qgssNZTNFRGRfpSzR7EY2OPuL7l7J7ABuKrvAe7+iLu3xQ+3A1NKOXE66gJT+Q4RkUooZ1CcC7zS53FT/Fx/Pgb8WyknTqUKqhwrIlIhw+Ld1sw+DCwCfr+fr38C+ER4dBGplKvOk4hIhZSzR/EqcF6fx1Pi505gZpcCtwEr3b3jVCdy93XuvsjdFwFEhnoUIiIVUs6g+AUw3cymmVkN8CFgS98DzGwB8HeEkHij1BNHEepRiIhUSNmCwt3zwC3Aj4FngE3uvsvM7jSzlfFhfw3UAw+Y2U4z29LPSALgIQAAEL5JREFU6U6QigoKChGRCinru627PwQ8dNJza/t8funpnDeKXMtjRUQqJJE7s1MpIFJQiIhUQiKDQnMUIiKVk9CgMA09iYhUSCKDIpVWUIiIVEoigyJCG+5ERColmUGRjjSZLSJSIYkMilRKQ08iIpWSyKCIrEBCmy4ikjiJfLe1dI1qPYmIVEgigyIKO+6q3QwRkbNCIt9toyjSHIWISIUkMyhSKbBENl1EJHES+W4bpSMwq3YzRETOCskMCk1ki4hUTDKDIpOpdhNERM4ayQyKSEEhIlIpiQwKy9RUuwkiImeNZAaFehQiIhWTyKAgVVvtFoiInDUSGBSu8h0iIhWUuKAwANceChGRSklcUGBAZmy1WyEictZI4BjOm+9ul8vlaGpqor29vUptkpEom80yZcoUMtq3I2e5xAWFwZsms5uamhgzZgxTp07FVNpDhoC7c/DgQZqampg2bVq1myNSVckbegKwE//Ca29vZ+LEiQoJGTJmxsSJE9VLFSGRQeGQfvPyWIWEDDX9TokECQwKIMpWuwVvUl9fP6jjt23bxpVXXgnAli1buOuuu4oev3btWrZu3Vr0PKdj6tSpHDhw4E3PX3HFFTQ3N5/2eatl586dPPTQQwMeN9j/XiJns+TNURgjbh/FypUrWblyZdFj7rzzzgq1JijlzXY42rlzJzt27OCKK66odlNERoyE9ihGVbsF/dq2bRuNjY1ce+21zJw5kxtuuAF3B+Df//3fmTlzJgsXLuRf/uVfer7nvvvu45ZbbqGlpYV3vvOdFAoFAI4dO8Z5551HLpfjxhtv5Pvf/37R83z+85/n7rvv7nk8Z84c9u7dC8DVV1/NRRddxOzZs1m3bt2AP0d3T2Pv3r3MnDmTG2+8kRkzZnDDDTewdetWli1bxvTp03n88ccBePzxx1m6dCkLFizgve99L8899xwAbW1tXHfddcyaNYs/+qM/4j3veQ87duwA4D/+4z9YunQpCxcu5IMf/CCtra1vakdjYyOrV69m/vz5zJkzp+jrdXZ2snbtWjZu3Mj8+fPZuHEjra2t3HTTTcydO5d58+bx4IMP9pz7tttu48ILL2TJkiW8/vrrA14TkbNVAv80d0gVWa64//9Bx8GhfcnaifCW95Z8+JNPPsmuXbt4+9vfzrJly3jsscdYtGgRH//4x3n44Yc5//zzWbVq1Zu+r6Ghgfnz5/Pf//3fLF++nB/96Ee8//3vP2F5Znt7+4DnOZX169czYcIEjh8/zsUXX8w111zDxIkTS/rePXv28MADD7B+/Xouvvhivvvd7/LTn/6ULVu28KUvfYkf/OAHzJw5k5/85Cek02m2bt3KmjVrePDBB/nmN7/J+PHj2b17N08//TTz588H4MCBA3zxi19k69atjB49mi9/+ct89atfZe3atW96/ba2Nnbu3Mmjjz7KRz/6UZ5++ul+X+/OO+9kx44d3HPPPQB89rOfpaGhgV//+tcAHD58GAghvGTJEv7qr/6Kz3zmM3z729/m9ttvL+l6iJxtEhgUQHr49igAFi9ezJQpUwCYP38+e/fupb6+nmnTpjF9+nQAPvzhD5/yL/tVq1axceNGli9fzoYNG7j55ptP+Pqzzz5b0nlO9o1vfIPNmzcD8Morr/DCCy+UHBTTpk1j7ty5AMyePZsVK1ZgZsydO7enx9LS0sJHPvIRXnjhBcyMXC4HwE9/+lNWr14NhB7OvHnzANi+fTu7d+9m2bJlAHR2drJ06dJTvv71118PwPve9z6OHDlCc3MzR48ePeXrnWzr1q1s2LCh5/H48eMBqKmp6Znbueiii/jP//zPkq6FyNkomUFhRcqMD+Iv/3Kpre1dlZVKpcjn8yV/78qVK1mzZg2HDh3iiSee4JJLLin5e9PpdM+wFdCztHPbtm1s3bqVn/3sZ9TV1dHY2DioZZ99f54oinoeR1HU87PdcccdLF++nM2bN7N3714aGxuLntPdueyyy/je97434OufvPrIzAb9eifLZDI95x3sfyORs03i5igMIIFlxmfOnMnevXt58cUXAfp9g6yvr+fiiy9m9erVXHnllaRSqZLPM3XqVH75y18C8Mtf/pLf/OY3QPhrf/z48dTV1fHss8+yffv2If/5WlpaOPfcc4Ew59Jt2bJlbNq0CYDdu3f3DAEtWbKExx57jD179gBhKOj5558/5bk3btwIhN5JQ0MDDQ0N/b7emDFjOHr0aM/jyy67jHvvvbfncffQk4iULnFBASQyKLLZLOvWreMDH/gACxcuZPLkyf0eu2rVKv7pn/7plPMPxc5zzTXXcOjQIWbPns0999zDjBkzALj88svJ5/NccMEF3HrrrSxZsmTIf77PfOYzfO5zn2PBggUn/HV+8803s3//fmbNmsXtt9/O7NmzaWho4C1veQv33Xcf119/PfPmzWPp0qU8++yzpzx3NptlwYIFfPKTn+Q73/lO0ddbvnw5u3fv7pnMvv322zl8+DBz5szhwgsv5JFHHhnyn11kpLPuFTlJkUld6LnXvwOTFvU898wzz3DBBRdUsVXSn66uLnK5HNlslhdffJFLL72U5557jpqa0u5S2NjYyN13382iRYsGPrgM9LslI4WZPeHup/U/UvLmKAyIdCvUpGhra2P58uXkcjncnW9+85slh4SIDA/JCwqAKJkjZmejMWPG9OybOB3btm0busaIyGlJ5jtusVVPIiIypBIXFEld9SQiklSJCwpAQSEiUkEJDAoHSw18mIiIDIkEBgXDtnpsU1MTV111FdOnT+f3fu/3WL16NZ2dnWV9ze5y2Xv37mXOnDllfS0ROTslMyhs+DXb3fnjP/5jrr76al544QWef/55Wltbue22287ovCotISLVNvzecQdgMCyD4uGHHyabzXLTTTcBoX7Q1772NdavX8/ixYvZtWtXz7GNjY3s2LGDY8eO8dGPfpTFixezYMECfvjDHwKhJMXKlSu55JJLWLFiBa2traxYsYKFCxcyd+7cnuNERCpheI7hDKj/oPizP4OdO4f21ebPh69/vfgxu3bt4qKLLjrhubFjx/KOd7yDD3zgA2zatIkvfOEL7Nu3j3379rFo0SLWrFnDJZdcwvr162lubmbx4sVceumlQKjV9NRTTzFhwgTy+TybN29m7NixHDhwgCVLlrBy5UrdqlNEKmL4/Wk+EGNY9iiKaWxs7Lnp0KZNm7j22muBcOOeu+66i/nz5/dUdH355ZeBUMxuwoQJQBjWWrNmDfPmzePSSy/l1Vdf1Y12RKRiEtij8KJBMdBf/uUya9asnjDoduTIEV5++WUuvvhiJk6cyFNPPcXGjRv51re+BYQAePDBB3n3u999wvf9/Oc/Z/To0T2P//mf/5n9+/fzxBNPkMlkmDp16qDKhIuInIlk/WneY/g1e8WKFbS1tXH//fcDoRjepz/9aW688Ubq6upYtWoVX/nKV2hpaem5ec/73/9+/vZv/7bnVqlPPvnkKc/d0tLC5MmTyWQyPPLII/z2t7+tzA8lIsJwfMctxTAcejIzNm/ezAMPPMD06dOZMWMG2WyWL33pSwBce+21bNiwgeuuu67ne+644w5yuRzz5s1j9uzZ3HHHHac89w033MCOHTuYO3cu999/PzNnzqzIzyQiAgksM57NzPX2jidP2EuhUtBSLvrdkpHiTMqMD78/zUsxDHsUIiIjVQLfcYtPZouIyNDSO66IiBSVvKDoZ49Z0uZaZPjT75RIkLygOIVsNsvBgwf1P7YMGXfn4MGDZLPZajdFpOoSt+HuVB2KKVOm0NTUxP79+yveHhm5stksU6ZMqXYzRKqurEFhZpcD/wdIAX/v7ned9PVa4H7gIuAgsMrd9w72dTKZDNOmTTvzBouIyJuUbejJzFLAvcAfArOA681s1kmHfQw47O7nA18DvjzwmTW8JCJSSeWco1gM7HH3l9y9E9gAXHXSMVcB/xB//n1ghakkqojIsFLOoDgXeKXP46b4uVMe4+55oAWYWMY2iYjIICViMtvMPgF8In7YYWZPV7M9w8gk4EC1GzFM6Fr00rXopWvR690DH3Jq5QyKV4Hz+jyeEj93qmOazCwNNBAmtU/g7uuAdQBmtuN065WMNLoWvXQteula9NK16GVmO073e8s59PQLYLqZTTOzGuBDwJaTjtkCfCT+/FrgYddmCBGRYaVsPQp3z5vZLcCPCctj17v7LjO7E9jh7luA7wD/aGZ7gEOEMBERkWGkrHMU7v4Q8NBJz63t83k78MFBnnbdEDRtpNC16KVr0UvXopeuRa/TvhaJux+FiIhU1oio9SQiIuUzbIPCzC43s+fMbI+Z3XqKr9ea2cb46z83s6mVb2VllHAtPmVmu83sKTP7LzN7ZzXaWQkDXYs+x11jZm5mI3bFSynXwsyui383dpnZdyvdxkop4f+Rd5jZI2b2ZPz/yRXVaGe5mdl6M3ujvy0EFnwjvk5PmdnCkk7s7sPuH2Hy+0XgXUAN8Ctg1knH3Ax8K/78Q8DGare7itdiOVAXf/4nZ/O1iI8bAzwKbAcWVbvdVfy9mA48CYyPH0+udrureC3WAX8Sfz4L2FvtdpfpWrwPWAg83c/XrwD+jVBfdQnw81LOO1x7FCr/0WvAa+Huj7h7W/xwO2HPykhUyu8FwF8S6oa1V7JxFVbKtfg4cK+7HwZw9zcq3MZKKeVaODA2/rwB+F0F21cx7v4oYQVpf64C7vdgOzDOzN420HmHa1Co/EevUq5FXx8j/MUwEg14LeKu9Hnu/q+VbFgVlPJ7MQOYYWaPmdn2uJrzSFTKtfg88GEzayKsxPzTyjRt2Bns+wmQkBIeUhoz+zCwCPj9arelGswsAr4K3FjlpgwXacLwUyOhl/momc119+aqtqo6rgfuc/e/MbOlhP1bc9y9UO2GJcFw7VEMpvwHxcp/jAClXAvM7FLgNmClu3dUqG2VNtC1GAPMAbaZ2V7CGOyWETqhXcrvRROwxd1z7v4b4HlCcIw0pVyLjwGbANz9Z0CWUAfqbFPS+8nJhmtQqPxHrwGvhZktAP6OEBIjdRwaBrgW7t7i7pPcfaq7TyXM16x099OucTOMlfL/yA8IvQnMbBJhKOqlSjayQkq5Fi8DKwDM7AJCUJyNt8TcAvzPePXTEqDF3fcN9E3DcujJVf6jR4nX4q+BeuCBeD7/ZXdfWbVGl0mJ1+KsUOK1+DHwB2a2G+gC/tzdR1yvu8Rr8Wng22b2vwkT2zeOxD8szex7hD8OJsXzMX8BZADc/VuE+ZkrgD1AG3BTSecdgddKRESG0HAdehIRkWFCQSEiIkUpKEREpCgFhYiIFKWgEBGRohQUIiUysy4z29nn31QzazSzlvjxM2b2F/GxfZ9/1szurnb7RU7XsNxHITJMHXf3+X2fiMvb/8TdrzSz0cBOM/u/8Ze7nx8FPGlmm939sco2WeTMqUchMkTc/RjwBHD+Sc8fB3ZSQvE1keFIQSFSulF9hp02n/xFM5tIqC+166TnxxNqLD1amWaKDC0NPYmU7k1DT7H/YWZPAgXgrrh8RGP8/K8IIfF1d3+tgm0VGTIKCpEz9xN3v7K/581sGrDdzDa5+85KN07kTGnoSaTM4hLfdwGfrXZbRE6HgkKkMr4FvC9eJSWSKKoeKyIiRalHISIiRSkoRESkKAWFiIgUpaAQEZGiFBQiIlKUgkJERIpSUIiISFEKChERKer/A2+HX0rUmsvLAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import roc_auc_score, roc_curve\n",
    "\n",
    "auc_scores = []\n",
    "fprs = []\n",
    "tprs = []\n",
    "nuclei_gts = []\n",
    "OD_h_gts = []\n",
    "\n",
    "for i in range(len(he_indexes_test)):\n",
    "    image_name = he_indexes_test[i]\n",
    "    nuclei_gt = rgba2rgb(skimage.io.imread(os.path.join(\"../data/he_test_nuclei_mask/\", image_name)))[..., 1] ==255\n",
    "    nuclei_gt = nuclei_gt.astype(int).reshape(-1)\n",
    "    OD_h = gt_ODs[i][0, 0, ...].reshape(-1)\n",
    "    \n",
    "    fpr, tpr, thresholds = roc_curve(nuclei_gt, OD_h)\n",
    "    fprs.append(fpr)\n",
    "    tprs.append(tpr)\n",
    "    auc_scores.append(roc_auc_score(nuclei_gt, OD_h))\n",
    "    nuclei_gts.append(nuclei_gt)\n",
    "    OD_h_gts.append(OD_h)\n",
    "    \n",
    "print(np.average(auc_scores))\n",
    "print(np.std(auc_scores, ddof=1))\n",
    "print(roc_auc_score(np.concatenate(nuclei_gts).reshape(-1), np.concatenate(OD_h_gts).reshape(-1)))\n",
    "\n",
    "# Plot\n",
    "plt.figure(figsize=(6, 6))\n",
    "for i in range(len(he_indexes_test)):\n",
    "    if i == 0:\n",
    "        plt.plot(fprs[i], tprs[i], color='orange', alpha=0.4, label='Individual image patch')\n",
    "    else:\n",
    "        plt.plot(fprs[i], tprs[i], color='orange', alpha=0.4)\n",
    "fpr, tpr, thresholds = roc_curve(np.concatenate(nuclei_gts).reshape(-1), np.concatenate(OD_h_gts).reshape(-1))\n",
    "plt.plot(fpr, tpr, color='blue', label='Overall')\n",
    "plt.xlim(0, 1)\n",
    "plt.ylim(0, 1)\n",
    "plt.xlabel(\"FPR\")\n",
    "plt.ylabel(\"TPR\")\n",
    "plt.legend()\n",
    "\n",
    "torch.save([fpr, tpr], \"../outputs/2_roc_curve_evaluate_gt.pt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Session Info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "absl-py==0.7.0\r\n",
      "altair==3.2.0\r\n",
      "argh==0.26.2\r\n",
      "astor==0.7.1\r\n",
      "astropy==3.2.1\r\n",
      "atomicwrites==1.3.0\r\n",
      "attrs==19.1.0\r\n",
      "autograd==1.2\r\n",
      "backcall==0.1.0\r\n",
      "base58==1.0.3\r\n",
      "bleach==1.5.0\r\n",
      "blinker==1.4\r\n",
      "boto3==1.10.15\r\n",
      "botocore==1.13.15\r\n",
      "Bottleneck==1.2.1\r\n",
      "cachetools==4.1.0\r\n",
      "certifi==2019.3.9\r\n",
      "chardet==3.0.4\r\n",
      "Click==7.0\r\n",
      "cvxopt==1.2.3\r\n",
      "cvxpy==1.0.24\r\n",
      "cycler==0.10.0\r\n",
      "Cython==0.29.15\r\n",
      "decorator==4.4.0\r\n",
      "defusedxml==0.5.0\r\n",
      "dill==0.2.9\r\n",
      "docutils==0.15.2\r\n",
      "ecos==2.0.7.post1\r\n",
      "entrypoints==0.3\r\n",
      "enum-compat==0.0.3\r\n",
      "environment-kernels==1.1.1\r\n",
      "FITS-tools==0.2\r\n",
      "future==0.17.1\r\n",
      "gast==0.2.2\r\n",
      "google-auth==1.14.3\r\n",
      "google-auth-oauthlib==0.4.1\r\n",
      "google-pasta==0.2.0\r\n",
      "grpcio==1.29.0\r\n",
      "h5py==2.10.0\r\n",
      "html5lib==0.9999999\r\n",
      "idna==2.8\r\n",
      "image-registration==0.2.4\r\n",
      "imageio==2.6.1\r\n",
      "importlib-metadata==0.23\r\n",
      "ipykernel==5.1.0\r\n",
      "ipython==7.4.0\r\n",
      "ipython-genutils==0.2.0\r\n",
      "ipywidgets==7.4.2\r\n",
      "isodate==0.6.0\r\n",
      "jedi==0.13.3\r\n",
      "Jinja2==2.10.1\r\n",
      "jmespath==0.9.4\r\n",
      "jsonschema==3.0.1\r\n",
      "jupyter==1.0.0\r\n",
      "jupyter-client==5.2.4\r\n",
      "jupyter-console==6.0.0\r\n",
      "jupyter-core==4.4.0\r\n",
      "Keras==2.3.1\r\n",
      "Keras-Applications==1.0.8\r\n",
      "Keras-Preprocessing==1.1.0\r\n",
      "kiwisolver==1.0.1\r\n",
      "lifelines==0.21.3\r\n",
      "lightgbm==2.3.1\r\n",
      "Markdown==3.0.1\r\n",
      "MarkupSafe==1.1.1\r\n",
      "matplotlib==3.0.3\r\n",
      "mistune==0.8.4\r\n",
      "mkl-fft==1.0.10\r\n",
      "mkl-random==1.0.2\r\n",
      "mock==2.0.0\r\n",
      "more-itertools==7.2.0\r\n",
      "mttkinter==0.6.1\r\n",
      "multiprocess==0.70.7\r\n",
      "nbconvert==5.4.1\r\n",
      "nbformat==4.4.0\r\n",
      "networkx==2.2\r\n",
      "notebook==5.7.8\r\n",
      "numexpr==2.6.9\r\n",
      "numpy==1.17.2\r\n",
      "oauthlib==3.1.0\r\n",
      "opencv-python==3.2.0.7\r\n",
      "openslide-python==1.1.1\r\n",
      "osqp==0.5.0\r\n",
      "packaging==19.2\r\n",
      "pandas==0.23.4\r\n",
      "pandocfilters==1.4.2\r\n",
      "parso==0.4.0\r\n",
      "pathtools==0.1.2\r\n",
      "patsy==0.5.1\r\n",
      "pbr==5.1.3\r\n",
      "pexpect==4.7.0\r\n",
      "pickleshare==0.7.5\r\n",
      "Pillow==6.2.1\r\n",
      "pluggy==0.13.0\r\n",
      "plyfile==0.7\r\n",
      "pma-python==2.0.0.118\r\n",
      "prometheus-client==0.6.0\r\n",
      "prompt-toolkit==2.0.9\r\n",
      "protobuf==3.6.1\r\n",
      "ptyprocess==0.6.0\r\n",
      "py==1.8.0\r\n",
      "pyasn1==0.4.8\r\n",
      "pyasn1-modules==0.2.8\r\n",
      "pycocotools==2.0.0\r\n",
      "pydicom==1.4.2\r\n",
      "Pygments==2.3.1\r\n",
      "pyparsing==2.4.0\r\n",
      "pyrsistent==0.14.11\r\n",
      "pytest==5.1.2\r\n",
      "python-dateutil==2.8.0\r\n",
      "pytz==2018.9\r\n",
      "PyWavelets==1.0.2\r\n",
      "PyYAML==5.1.2\r\n",
      "pyzmq==18.0.1\r\n",
      "qtconsole==4.4.3\r\n",
      "rdflib==4.2.2\r\n",
      "requests==2.22.0\r\n",
      "requests-oauthlib==1.3.0\r\n",
      "requests-toolbelt==0.9.1\r\n",
      "rsa==4.0\r\n",
      "s3transfer==0.2.1\r\n",
      "scikit-image==0.15.0\r\n",
      "scikit-learn==0.20.3\r\n",
      "scikit-survival==0.8\r\n",
      "scipy==1.2.1\r\n",
      "scs==2.1.0\r\n",
      "seaborn==0.9.0\r\n",
      "Send2Trash==1.5.0\r\n",
      "Shapely==1.7.0\r\n",
      "simplejson==3.16.0\r\n",
      "six==1.12.0\r\n",
      "statsmodels==0.10.1\r\n",
      "streamlit==0.50.2\r\n",
      "tensorboard==1.14.0\r\n",
      "tensorflow==1.14.0\r\n",
      "tensorflow-estimator==1.14.0\r\n",
      "termcolor==1.1.0\r\n",
      "terminado==0.8.2\r\n",
      "testpath==0.4.2\r\n",
      "toml==0.10.0\r\n",
      "toolz==0.10.0\r\n",
      "torch==1.4.0\r\n",
      "torch-cluster==1.2.4\r\n",
      "torch-geometric==1.0.3\r\n",
      "torch-scatter==1.1.2\r\n",
      "torch-sparse==0.2.4\r\n",
      "torch-vision==0.1.6.dev0\r\n",
      "torchvision==0.5.0\r\n",
      "tornado==5.1.1\r\n",
      "tqdm==4.36.1\r\n",
      "traitlets==4.3.2\r\n",
      "tzlocal==2.0.0\r\n",
      "urllib3==1.25.7\r\n",
      "validators==0.14.0\r\n",
      "watchdog==0.9.0\r\n",
      "wcwidth==0.1.7\r\n",
      "webencodings==0.5.1\r\n",
      "Werkzeug==0.14.1\r\n",
      "widgetsnbextension==3.4.2\r\n",
      "wrapt==1.12.1\r\n",
      "xgboost==1.0.2\r\n",
      "zipp==0.6.0\r\n"
     ]
    }
   ],
   "source": [
    "!pip freeze"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Environment (conda_mask_rcnn_2)",
   "language": "python",
   "name": "conda_mask_rcnn_2"
  },
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}