diff --git a/BE2_GAN_and_cGAN.ipynb b/BE2_GAN_and_cGAN.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..1b0fe738c51ab42cdf28e1488031b92269340e3f
--- /dev/null
+++ b/BE2_GAN_and_cGAN.ipynb
@@ -0,0 +1,1659 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "UGwKsKS4GMTN"
+   },
+   "source": [
+    "<h1 ><big><center>MSO 3.4 - Deep Structured Learning</center></big></h1>\n",
+    "\n",
+    "<h2><big><center> BE 2 - GANs and cGAN </center></big></h2>\n",
+    "\n",
+    "<h5><big><center>Adapted from <i>Projet d'Option</i> of : Mhamed Jabri, Martin Chauvin, Ahmed Sahraoui, Zakariae Moustaïne and Taoufik Bouchikhi\n",
+    "\n",
+    "\n",
+    "<p align=\"center\">\n",
+    "<img height=300px src=\"https://cdn-images-1.medium.com/max/1080/0*tJRy5Chmk4XymxwN.png\"/></p>\n",
+    "<p align=\"center\"></p>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "16aVF81lJuiP"
+   },
+   "source": [
+    "The aim of this assignment is to discover GANs, understand how they are implemented and then explore one specific architecture of GANs that allows us to perform image to image translation (which corresponds to the picture that you can see above this text ! )\n",
+    "\n",
+    "Before starting the exploration of the world of GANs, here's  what students should do and send back for this assignement : \n",
+    "* In the \"tutorial\" parts of this assignement that focus on explaining new concepts, you'll find <font color='red'>**questions**</font>  that aim to test your understanding of those concepts. \n",
+    "* In some of the code cells, you'll have to complete the code and you'll find a \"TO DO\" explaining what you should implement."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "M-WNKvhOP1ED"
+   },
+   "source": [
+    "# Part1: DC-GAN"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "y_r8nMTGQI9a"
+   },
+   "source": [
+    "In this part, we aim to learn and understand the basic concepts of **Generative Adversarial Networks** through a DCGAN and generate new celebrities from the learned network after showing it real celebrities. For this purpose, please study the tutorial here: https://pytorch.org/tutorials/beginner/dcgan_faces_tutorial.html\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "jiHCy4_UUBFb"
+   },
+   "source": [
+    "##Work to do\n",
+    "Now we want to generate handwritten digits using the MNIST dataset. It is available within torvision package (https://pytorch.org/vision/stable/generated/torchvision.datasets.MNIST.html#torchvision.datasets.MNIST)\n",
+    "\n",
+    "Please re-train the DCGAN and display some automatically generated handwritten digits.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "sIL7UvYAZx6L"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Random Seed:  999\n",
+      "Generator(\n",
+      "  (main): Sequential(\n",
+      "    (0): ConvTranspose2d(100, 512, kernel_size=(4, 4), stride=(1, 1), bias=False)\n",
+      "    (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+      "    (2): ReLU(inplace=True)\n",
+      "    (3): ConvTranspose2d(512, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
+      "    (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+      "    (5): ReLU(inplace=True)\n",
+      "    (6): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
+      "    (7): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+      "    (8): ReLU(inplace=True)\n",
+      "    (9): ConvTranspose2d(128, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
+      "    (10): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+      "    (11): ReLU(inplace=True)\n",
+      "    (12): ConvTranspose2d(64, 1, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
+      "    (13): Tanh()\n",
+      "  )\n",
+      ")\n",
+      "Discriminator(\n",
+      "  (main): Sequential(\n",
+      "    (0): Conv2d(1, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
+      "    (1): LeakyReLU(negative_slope=0.2, inplace=True)\n",
+      "    (2): Conv2d(64, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
+      "    (3): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+      "    (4): LeakyReLU(negative_slope=0.2, inplace=True)\n",
+      "    (5): Conv2d(128, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
+      "    (6): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+      "    (7): LeakyReLU(negative_slope=0.2, inplace=True)\n",
+      "    (8): Conv2d(256, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
+      "    (9): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+      "    (10): LeakyReLU(negative_slope=0.2, inplace=True)\n",
+      "    (11): Conv2d(512, 1, kernel_size=(4, 4), stride=(1, 1), bias=False)\n",
+      "    (12): Sigmoid()\n",
+      "  )\n",
+      ")\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcEAAAHRCAYAAAASbQJzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOy9aWxj6Znv9zsU90UURUqUqH3fSiWpqlSqtbdb3V2eTLmn20bGdzCwL5AZXOQmQD5cOAgQ3HGQXHgQBLjBxBcziJ2ZGMgsuHHcvnaPu+223e2ucnWVate+lzZKFCWKm0hRoiSefFC9r6Xaq0tbdZ0fIHSrSIrnkOe8z/ts/0dRVRUNDQ0NDY2XEd1+H4CGhoaGhsZ+oRlBDQ0NDY2XFs0IamhoaGi8tGhGUENDQ0PjpUUzghoaGhoaLy2aEdTQ0NDQeGnRjKCGxhYURclSFCWhKErpTj5XQ0PjYKJofYIaLzKKoiS2/GoFVoGNe7//a1VV/2Hvj+r5URTl3wPFqqr+q/0+Fg2NLzP6/T4ADY3nQVVVu/h/RVEmgD9TVfXXj3q+oih6VVXX9+LYNDQ0Dj5aOFTjS42iKP9eUZT/pCjKPymKsgT8qaIoJxVFuaooSlRRlICiKP+HoiiGe8/XK4qiKopSfu/3v7/3+EeKoiwpinJFUZSKZ33uvce/oijKsKIoMUVRvqcoymVFUf7VU5yDeJ//WlGUsXt/+zuKotTcO4/4vfMT5+BWFOVDRVEWFEWJKIrygaIoRVv+XpWiKL+793c+VhTlbxRF+eGWx09v+XzuKIryypbH/itFUSbuvfauoijfeI6vR0Nj39GMoMbLwLvAPwJO4D8B68B/B3iA08B54F8/5vV/Avw7IBeYAv6XZ32uoij5wP8LfPve+44Dx5/xPN4EWu8d8/8I/DXwDaAMaAP+y3vP0wE/AErvPbYG/NWWv/NPwGXADfx74E/FA4qilAA/A75z7xz+B+D9e4Y1G/gPwJuqqjruHUf3M56DhsaBQjOCGi8Dv1NV9QNVVTOqqqZUVb2uqmqnqqrrqqreBb4PvPqY1/9/qqreUFV1DfgHNg3Rsz73D4E7qqr+9N5j/zsQesbz+F9VVV1SVbUbGAB+oarqhKqqEeCXbBpCVFVdUFX1J/fONQ58V5yfoiiVQAvwP6mqmlZV9SLw8y3v8U3gZ6qq/vLe5/ULoIvNjQKAChxSFMWsqmpAVdX+ZzwHDY0DhWYENV4Gprf+oihKvaIoP1cUZU5RlDjwP7PpnT2KuS3/vwzYH/XExzzXt/U41M2KNP9THPtWglv+P/WQ3+0AiqLYFEX5vxRFmbp3fp/w+/PzAYuqqqa2vHbr51MG/Mt7odCooihR4ATgu2dQ/yXw3wBziqL8s6Iotc94DhoaBwrNCGq8DNxfAv1/Ar1Ataqq2cBfAMouH0MAKBa/KIqiAEWPfvpz8d8DFcDxe+f3xn3H4VYUxbzl30q2/P808H+rqpqz5cemqur/BqCq6keqqp4DCoFRNj9LDY0XFs0IaryMOIAYkFQUpYHH5wN3in8GjiiKckFRFD2bOcm8XXovB5teaERRFDebRh4AVVXHgB7gO4qiGBVFOQP8F1te+/8A7yqK8ua9PkizoiivK4riUxSl8N7xW4E0kOT37SgaGi8kmhHUeBn5t8C3gCU2PZn/tNtvqKpqEPhjNgtLFoEq4DabfY07zX9gswhoEfgc+Oi+x/8l8Mq9x7/D5vmv3jvOCTYLif4dsMBmcc+/ZXOtyGKzsCdw77WngP92F45fQ2PP0JrlNTT2AUVRsoBZ4Ouqql7a52P5MZtFO4+retXQ+FKieYIaGnuEoijnFUVxKopiYtPTWgeu7cNxHFcUpUJRFJ2iKH/AZuXqT/f6ODQ0DgKaYoyGxt5xhs22CSPQB/yRqqq7EQ59Ej7gx2z2AfqBP7/XdqGh8dKhhUM1NDQ0NF5atHCohoaGhsZLi2YENTQ0NDReWh6bE1QURYuVamhoaGi80Kiq+kgxDM0T1NDQ0NB4adGMoIaGhobGS4tmBDU0NDQ0Xlo0I6ihoaGh8dKiGUENDQ0NjZcWzQhqaGhoaLy0aEZQQ0NDQ+OlRdMO1XhmDAYDNpsNo9GIXq+XP/ejqiqZTIaNjQ2SySSJRIK1tbV9OGKNLwMGgwG73Y7VagXAZrNht9vZ2NggkUgQjUZJp9Osrq6STqf3+Wh3BkVRUBQFvV7PxsYGGxtPP75RURSsVitmsxmDwYBer0en07GxscHS0hLxeHwXj3w7er0eg8GA0+nEbDZjNpsxGo3y3LKysoDNNWN2dpZYLEY6nd6T71EzghpPjbghHQ4H5eXl5Obm4nA4sNvt2Gy2B56fyWRYXV1lZWWFsbExRkdHiUaj+3DkGl8G7HY7NTU1lJaWAlBZWUl1dTXLy8uMjo5y69YtwuEwi4uLhMPhZzIYBxFFUcjKypLGf3l5meXlZZ5G71lRFAwGA4WFhRQUFOB0OnE4HBiNRlKpFP39/QwMDJDJZHb9PHQ6HTabDYfDQUtLC4WFhXi9XlwuF3q9HofDgdlsBmB9fZ2f/exn9PT0sLi4yOLi4q4f35fKCJpMJsxmMzrdZpR3rz0Pg8FAVlYWWVlZ6HQ6+V9hPFRVlRfw+vo6a2trrKysPNVFvZ+Im9FsNmMymfD5fDQ3N5Ofn4/b7cblcuF0Oh94nfAAk8kkRqORpaUllpeXvzS7dI29Q6/X43K5qK+v5/DhwwC0tLRw5MgRYrEYt2/fZmNjg0AgwOzsLCaTiXg8TjqdZm1t7YUxiDqdTq4jRqMRk8mExWLB4/EQjUaJRCKsrq6SSqXIZDIPXTvEa+12O9XV1VRXV+PxeHC5XOh0OiKRCOFwmMHBwV09D71ej8ViwWw24/F4cLvdtLe3U1FRQWlpKfn5+eh0OrKzs7HZbGQyGdLpNIODg8zOzrK8vCzXzd3kS2MEDQYD77zzDn/0R3+Ey+VCURS++93vcvHixT15b5PJRHt7O2VlZRQUFFBYWEhZWRm5ubm4XC7MZjPLy8skk0k2Njbo7+/nxo0bfPDBB8zNze36MT4P+fn5FBQUcPr0aU6cOEFtbS1tbW3A773Dx6GqKkNDQ/T39/OXf/mX9PX1sbGxsSe7UI0vB01NTZw8eZL33nuP119/HUBuMF0uF6WlpVy4cEFuNFVV5Yc//CHXrl2js7OT/v7+fT6DJyM8t5MnT1JWVkZJSQnFxcX4fD4aGxuZmJhgfHycrq4u/uEf/oFgMEgkEtn2N7Kzs8nPz6euro7XXnuNr33ta+Tl5WEwGAD4zW9+w+3bt5/qvn0eiouLaWho4Fvf+hZNTU24XC7cbjcGg4Hl5WWi0SjBYJDx8XFGRkZIp9MyZTI6OrqnDsyBM4JZWVkUFBSwtLREIpF4qoXSaDRSV1dHdXU1paWlbGxsEAwGSaVSu3acJpMJl8uFy+WiqKiIoqIiWlpa8Hg82O127HY7mUyGlZUVFhYWUFWVtbU1jEYjVquV0tJSDAYDvb29xONx1tbWDly+zGw2Y7fbOXv2LLW1tdTX11NfX4/X65U31f0kEglisRgrKytkZWXhdDrJycnB4/FQW1tLbW0t8XiccDi8L6FRu90ud6eqqrKwsMD6+voTPQWr1Up2djZms3nbAhKLxYjFYqyvr+/F4T8XRqORkpISKisrKS8vl+cxOjrKwsICCwsLRCIRVlZW9vtQH+C1117jxIkTlJaWPjT/LCIwW2lubsZoNJKTk0NZWRlzc3OMjY3JjehBwGg04vP5KCkpoaSkhPz8fJqamvB4POTm5pKTk0NOTo70psR1t7CwwNzcHAsLC8RiMZaWlggEAhQWFnLkyBFaW1tpamrCbrejKAqLi4uEQiE6Ozvp7u5mZmZmxzehiqLg8XjIy8vj0KFDtLa2UlRUBMDY2Bg3b94kHA5LZyAWizE/P8/c3BwbGxsydRIKhUgmk08d+n1eDpwRNBgMlJaWMjs7K13+J2EymWhubqaqqoqioiICgQDz8/MkEoldOUadTofZbMbn81FTUyPDMrW1tZhMJjKZDJlMhuHhYaLRKIlEglQqhaqqFBYWYrFY8Pl8lJeX88knn8gb86AZQavVitfr5dVXX+XYsWPk5eXh8XgwGo2PfE0ikWB6eppIJILRaKS8vJzs7GxcLhc2m43a2loWFxfZ2NjYFyPodDrl5iWTybC0tMTKysoTF0W73Y7P5yM3NxedTidD7pOTk6RSqRfCCJpMJurq6njrrbd4/fXXycrKQlEUPvroI/r7++nt7ZUL0UHj9ddf58SJEzgcjqd+zaFDh/B6vZSWllJbW0t3dzfhcJjV1dUDYwRNJhM1NTWcOXOGY8eOkZubi8/nw2QyyWISvV6Poijk5OTI3JrRaCQQCBAIBPD7/fj9fpaXlykuLqajo4OTJ0/i9XoxmUysra0RCATo7+/nd7/7Hf39/U/tYDwLiqJQUFBAc3Mz7e3tnDx5EpfLRTQapaenh2vXrjE4OEgqlZKb/nQ6LVNCYt0U4eu9+o4OjBEUsXC3282JEyfkDRmLxR7p0Ym4d2FhIR0dHVRUVOBwOJicnCQYDJJMJnf8OLOysnA4HLz66quUlJRQWlpKaWkpDoeDhYUFuYisrq7S19dHJBKRCy1AXV0dqqrKsKnT6cRoNB6YhUfs5nJycigvL6eiooKWlhaqq6uxWCxYLJZtYZT19XWZ95uYmMDv9zM5OUksFsNut2MwGCgrK8NoNMoch1h89wqxabFarZw5c0bmRzY2NnC73YRCIRYXF+XuU1TTibyuxWKRBRk5OTnbjt/n8+F2u5mbm2N6evqpvMq9RFEU3G43eXl5+Hw+Tp8+zZEjR6ivr5fnEQwGZa4oEAgQDof3+7AfQFx7D/MCH4XT6cRgMGA0GnE4HFitVsbGxojH46yuru7i0T4ZcW3l5eVx9OhRWlpapOfmdDplLiyTybC+vk4oFJL5TUBuLj0eD/n5+fh8PgwGA5WVlTQ0NFBWVobNZmN5eZlwOMzo6Ch37txhbGyMhYWFXUlF6HQ6GYqtqKjA4/EwPj7O0NAQt2/fpquri7t377K6uirP7SDUQxwYIygMms/n480338RgMMh496OMoN1up6SkhMbGRl555RVcLhdZWVkkk0nm5uZYXl7e0WMUCee8vDz+9E//FJvNhsViIZVKMT09TW9vL/Pz86ysrJBKpZiampK7HuEpCI/PaDTi9XrJysqSpcsHAb1eT0VFBYcOHaKhoYGGhgaqq6ux2WxyR7qVdDpNMBhkenqa999/X3rhy8vLFBYWUlRUREdHh1y8lpeXWVpa2vOCpdzcXAoKCvj617+Ox+PBarWiqiqtra2MjY0xNjYmd9Zut1vutkW4qqWlhYKCAhwOx7Zw6N27d6mtrWVgYIAPPviA5eXlA2MEFUVBp9NRWVlJR0cHtbW1nDx5ksLCwm2hw7q6OlZXVxkdHcVms+1JMcKzMj8/z/z8/BMjEfdjNBrJzc3FYrGQm5tLf38/Q0NDD+TS9hq9Xo/JZKK8vJxTp05RVVWFy+XalmYQXlEqlZIby1gsRm5uLlVVVbjdbux2O/n5+VRXV1NcXIzb7aaiogK73Y5eryccDjM+Pk5fXx+3b9+WUZjdwuVyUVlZidvtZm1tjcuXL3PlyhX8fj+zs7PSCz9I19e+G0GLxYLNZqOuro4TJ05w5MgROjo6mJiYwGKxPBDnF/h8Pg4dOsTp06dpa2ujuLiYoaEhPvnkE65du8bVq1eJxWI7eqw2m43CwkIaGxtpa2vj1q1bXLx4kcnJSQKBAGNjYywtLbGxscH6+vq2yk+9Xo/dbsfhcFBVVUV2djaRSIS5ubkDk4cxmUx4vV7Onz/PW2+9RWlpKbm5udJgiOqtmZkZ+vr6WFtbY2lpiWAwSCAQ4P3335f9PaqqEgqFOHHiBIuLi7I/qKioiIqKCmKxGDMzM7t6PiL/WlJSwpkzZzh9+jTnzp3DarXK66qxsZFwOEw4HJa5FdFbJTYootjgYZ5IZWUlx48fZ2JiAqfTSU9PD/39/TLJv580NDRQW1vL6dOnOXv2LGVlZSiKwtWrV7l165as2HvrrbdobGwkHo9jMpkYGRk5MIZc8NFHHxGJRDh79iytra0PfU4wGNx2z5eWlsq8tt1uJy8vj29+85u0tbVx+/Ztbt++zdDQEJOTk3t1GgByY1JXV8epU6c4ffo0FosFo9GIqqpMT08zOTkpfwKBgNxQLy8v43A4KCwsBDY3eF6vl/z8fC5cuIDb7ZYV8isrK1y/fp1PPvmE3t5exsbGdvWa1Ol05OXlUV9fTzKZ5OLFi3zwwQdyrTho15Rg342gzWbD7XZTV1fHmTNnOH78uGwMXVlZeWQ5vdfrpbKykubmZnkDj4yMcOnSJXp7e/H7/TvubRiNRplTisfj9PT08POf/xy/3//EaiaDwUBOTg6VlZU0NjaSlZVFNBolFAqxtLS075WSiqJgMplwu93U1NTQ2NhITk4OwDYDuLq6yszMDFevXpU3pWi8jUajMswkKvfS6TSJREI2x4rQzejo6K6fk8VikZWDra2tvPrqq1itVnQ6ndycWCwWiouLKS4ufuhnIp6nqupDQ7gOh0OWeM/NzbG2tibDq8vLy/vyvQoPsLy8nGPHjtHU1ERFRQUul4vR0VGuXbvGj370I6qqqqioqODkyZNkZ2dTUVFBMpmUDdUHiaGhIXJzczl06NAjnxONRmXBRyaTwePxyOiF+GlsbKSxsZHKykp0Oh3xeHzPjaCiKOTn59PY2EhNTc229qJMJsPc3Bzd3d3cuXOHrq4uxsfHH+m5ms1mamtrqaur42tf+5rMmabTaVKpFBMTE3R3dzM1NbUr6aH7ERG9UCjEyMgIc3NzB2KD/zj2zQjqdDqcTift7e00NTXR3NwsK9auXr3KyMgIoVDokSHN06dPy8bLdDrNxx9/TG9vL319fbv2wadSKQKBAIqi8P7773P79m1CodBjCytECDU/P58jR47Q1NREdnY2U1NT3L59m0AgsO+hAbPZTHZ2NsXFxZw8eZKGhgZMJpN8XBg4UaI9MjLCtWvXpKKDyINuLQ6xWq0cOnSIkpIS6QWKvFMoFNrVyl2AvLw8mSeura2loaFBhvpSqZQsDHA4HDJvtBVVVWV+L5PJyObjR0UmTCYT1dXVbGxsUFBQQCAQ4OrVq4yPj+94ROJRCK/H6XTidrtpbGyU5fGJRIL5+Xl+9rOfcefOHeLxOBsbG/J7MRgMZGdnk5eXR05ODolE4kD1sObn55OXl4fFYnnkc6LRKNPT08zMzMg+s6KiIhwOh/zJzs4GICcnh/r6eiKRCFevXt2r05CYzWacTuc2kYn19XUWFha4ffs2nZ2dDA8PEwwGH7qWZWVlYTKZyMnJoaSkRBblCVZWVrh79y6jo6MsLi6SSqX2dGOTk5NDdXU1OTk5ux7xeV72zQhmZWWRk5PDsWPHeOONN6ioqMDpdLK6usrVq1cZHh6Wu+mHcerUKRoaGnC5XMRiMf75n/+ZmZkZ/H7/rn3hy8vLrK6uEolEZJl/OBxmfX39kYuFKKzIz8+nra2NQ4cOkZ2dTTgc5saNGwfGCObl5VFbW8upU6eor6/fdkPFYjH8fj/Xrl3j8uXLTE1NMTIysq0nS8ijCYQRFMUkotBEeL97YQTPnDlDS0uL3G3b7XZ0Oh2pVIqFhQXW1takmoXBYNjm6QkjKIoRhLTTo4yg2Wymurqa/Px8Dh8+zOTkJMvLy0QikT01gm63m7KyMunNizxTIpFgeHiYH//4x8zNzRGLxaQR3Br2FUZwY2NjWy57v8nPzyc/P19Kpj2MSCTC1NQUt27d4saNGxiNRurr62Xfrs/n22YE6+rqdrxu4GlQFAWz2UxOTg52u13++/r6OvPz89y5c4fOzk5mZmYeWWiVlZWF1WrF5XJRXFxMXV3dto1cKpVifHx82zq6l+uMy+WipqYGl8u1Z+/5RdlzI6jT6TCZTGRnZ1NeXk5NTQ3FxcVkZ2ezvr7O4uIiExMTshpKfHHidQUFBRQUFFBZWYnNZiMSiTAxMcHY2BixWIxkMrlrISixMC4vL8sk7+NCoG63G6/XS1lZGfX19dTV1REOhxkZGeH27duMjY3tujF4EgUFBbIQprW1ldraWlkBurS0RDQa5Xe/+x3Dw8P09fUxNDREOBx+aGjF4XDg8Xjk32xvb6ekpAS9Xk88HicSiTA6Osr09PSu6BbqdDrZV3X48GHa2tqoqKggLy9Phthv3LjB9PQ009PTGAwGzp8/j8FgwGq1yrLtmzdvMj8/z+rqqkzki+vPaDRiMBhwuVzY7XZpQOx2O8XFxbKMHZBesNFoZH19fddDozk5OdTU1MhrrbS0FJ1ORygUYmhoiMHBQaanp2WfnMPhoKysDJPJxPLyMtPT0wwMDLC8vMza2tqBCNGLhvH29nbq6uoeu6harVacTieqqhKLxejq6iIWi1FUVER5eTk6nU72rVksFgoLC4lEIng8Hhna3wtDIaQHCwsLyc3Nlf+eyWRIpVLE4/FtFeUPw2azUVJSQl1dHXV1dVRVVWEwGGQtQigUYmpqimAwKKsx94KVlRVisZjMcT6qn/ggsadG0Gw2U1JSQmFhIeXl5Rw5coT29nZycnJYXFxkdHSUwcFBbt68KZuYxetyc3MpKiri3LlzvP766+Tn5zM9PU1nZyc3b95kfHx8z84jk8k8dHcvyp6tVitWq5V/8S/+BQ0NDTQ3N+Pz+VhZWeEnP/kJFy9eZGpqSrZU7CcdHR2yYKS5uXlb5ePU1BSdnZ1873vfkyov4mYSeSfxXJ1Ox7Fjx+jo6OCVV16hvr6esrIyWSTU3d3N559/zq9+9SsmJyd35aa0WCwcO3aMU6dO0d7ezrlz5wBkAU8kEuEv//IvGRkZwe/3U1RURHNzs4xKJBIJwuEw3/3ud/n8889ZXV19wBMSUlD19fUUFxdjMplk/92f//mfY7FYyM7OxmAwUF9fz61bt5ibm2NpaWlXNzxGo5HGxka+8pWvcPToUYqLi5mfn2d0dJSLFy/ym9/8RkYdXC4Xubm5HD16lFdeeQWn08nY2Biffvopv/71rwkEAvtqAEUbksvl4qtf/SoXLlzgxIkTD9Wnhc2FN5FIsL6+jsPhwGQyoSgKn3zyCVarlfz8fCoqKlhYWJC9nqJYxmQy8d5779HV1UV3d/eebEoVRcHpdFJSUoLH43ng8a2Siw/7HqxWK83NzVJAoLKyksrKSgD5nXd1dXHp0iXZtrMXiHzmnTt3KCwslC1SYgO63xGvR7GnRtDlcnHq1Cmp7lJcXIzFYiEWizE0NMTly5e5c+eOjOeLMIDdbqeqqorm5maampqoqqpiZGSEnp4eqYBwEBAehegdfPvtt8nNzcVoNDIzM8PY2BidnZ1MTEzIKsr9RgjrmkymbW0aqqqSSCSYmZmR+aOtBlBc3KLXTK/X09zcTH19PSUlJeTm5qKqqtQ5nJyc5Pbt20Sj0V27GQwGAyUlJRw9epSysjL5PqKNY3x8nNHRUbk73tjYIBaLyZ3y2tqaFCl+VEO1KNiampoiHA7LEGk6nSYUCuHxeGSfoVCmMRqNu94Ck52dTUlJCUVFRbjdbrKysuju7uaTTz5heHhYqhZVVFRQU1NDbW0thw8fxul0ykIYYUz2e7GyWCxUVFRQX19PU1OT7DN9FNFolNHRUTo7O5mammJqakpGaNLpNIuLi6iqypUrV2hubub48eMy3O9wOHj33XeluMVeGEFVVVlaWmJ2dlaGNOH3KaK8vDw5pSWdTj9gCD0eDx0dHbS2tlJXVyf7CtfX1wkGg9y8eZOrV68yMTGxp3lAocA0NDREJpOhvLwcs9mMxWI50JM99sQICq8hLy+P48eP09zcTE1NjTSA4oO7du0aN27ceMDLEm0FbW1tVFdX4/V6+fDDD+nq6qKvr29PvcCHIRbCvLw8cnNzqampobq6moaGBjKZDIFAgNHRUW7evClVKw5K9Z0I8T2sgT2VShEOh1FVFZvNJpVShLcrXisKKw4fPkxNTQ0FBQVkZ2fLvJLIjc3MzKAoCjabTSpC7GQFr16vx+v1Sq1CUSUoVGx6e3uZnp6WZeJra2vSOxAeazqdljle8ZlszXcKYxkMBgkGg/K97Xa7FAgQxyIEx3ezD1QIFefl5VFRUYHP58PpdJLJZGS1tAitOZ1OmpqaOHLkCG1tbfh8Ptn3KKp/9zs8rygK2dnZVFdX09HRQX19PYWFhdvCauI7EN/L3NwcfX193Lhxg5mZGQKBgLyu1tfXpReuqip9fX1Slgw2varXXnuNnp4ebDab3PDtJsIIBgKBbeFQUSzo9Xpxu91Eo1GWlpZktEgUcBUVFdHW1iajLeJvxmIxpqam6Orq4saNG/Le3StEW9TQ0JCsg3A6neTl5RGLxYhGowdm3dvKrhtBsehZrVbKy8tpamqisLAQq9WKoijMzMxw586dh1Z1iukFQvtPqJYIBfRgMCh72/ajAkkYBKGN+frrr28rtf/ss8+IRqMEAgFZtLObOcsvQiAQYGFhYdvnLoyHqBhsaWlhfX0di8UijZ/b7cbpdMrvMSsri5aWlm0VfGLzYzAYKC8v59VXX6WgoIB4PE4oFCIcDuP3+3fs89DpdBiNRmw2GyaTSSoOiYXh888/37YbTSaT9PT04PF4qK6ultdqbm4ubrdbNssnk0mi0ehD82TiGhCFP2IjoaqqrCzdLWWMrKwsbDYb2dnZNDc3c+TIEbxeL3q9nmQyyerqKplMBrfbTXZ2NlVVVbzzzjsUFhZSWFgow7Z7qd7zJMxmM+Xl5VJ6q6io6IG8UiaTYWZmhlgsRjweZ2BggKtXrzIwMMDS0tJDW45ECiMajT4QHhQ5Op/Px+rqKgsLC7t6jqqqkkqliEQi2/r2srKysNvtVFZWykkZd+/eZWFhQeZHKyoqOHz4MJWVlTL/KX6uXLnC9evXuXv3LtFodM9bEzKZjPS6nU4nPp+P+vp6zGYz/f39DA4OEolEDtT6B7tsBIuLi/F6vdIzOnToEE1NTSwtLXH37l38fr/06Px+P4uLi6yurqIoCj6fD4LvfYYAACAASURBVJ/PR2FhIa+99hrt7e3U1tYSCoW4e/cuBQUFsuowEonwgx/8YNdFqE0mk2x4FwUXeXl5uN1uqeJgMpnw+/1MT0/zi1/8gtnZWUKhEPF4fNsopYNCIpFgeXn5oXmDoqIizp49y/Hjx6UBFEbQ5XJJQelHIXoPRb6wtraWhYUF4vE4CwsLBINB/vqv/5pwOPxU+p1PQlEU2adkMplkAYgoSlFVVRZgCS/v17/+NRaLRX6PLpeLr33ta3R0dEhPN5lMyjxiPB5HURQsFou8Hux2O3V1dTIMKQqKhArNbinkCCWckpISTp48yenTp+W8uJWVFcrLy/nKV75CYWEhpaWlVFZWcvbsWVlx+Lhq1/3C6/XyzjvvcPbsWU6ePLntMTFpIBQK8YMf/IDFxUWi0Sh+v5+7d+8SCoUe+XeFEQyHww98FzqdDp/Px7Fjx9Dr9btuBAEWFxcZGxsjPz9/23E4HA46Ojrwer20trbS29vL5OQk6XSa48eP097eLrVQDQYDmUyGeDxOPB7nhz/8If39/QSDwT0dmHv/eQlVmlQqxR/8wR/Q0NBAfX09ExMT3L59+5HRBtFzvNe1ErtqBMvKymhububYsWO0t7eTl5cnZ34NDw9z8+ZNfvWrX8kSXnFxKopCUVER7e3tNDc389Zbb0nZrnQ6TTQa5fz582RlZaGqKpOTk/zjP/6jzCPu1k5DtBIUFxdz7tw5qqurqampwWQyoaoq3d3dUjQ7EolIiTSRM3tcK8V+IYzZ1pyL8GhEWDOTyTwwI/FR0+S3sjV3KMQCCgoKWF9fZ3V1lWQyyU9+8hNZir/ToRKTyYTH45FtEWazmbGxMdLpNEajUYZDRb5WhLTffvttOQVD5Mv6+vq4desW8/Pz6PV6Ka0mvEYRwhLe5/T0tMw/ChWhnUZ8vlarVVbjidDm+vo6jY2NVFdXS+1Qh8MhHxPSfVu914OA0+mkpaUFr9f7wGPpdFrKgP34xz+WwuUrKyvP5fVsrdacnp5+nsN/KlRVZXl5mcXFRZaWlh54XOQE3W43JSUlzM3NEQ6HOXz4sGyxEsU/a2trxGIxZmdnGRoawu/3H4jcWygUoqurS0YnRIGg3W5/pGrNwsICfr9/Wwh4L9h1I3jkyBGp0GCxWAiFQqyurkoPROQARC5FDFlsbW3l2LFjstBiY2ODdDotw1Xl5eXSKK6srOyJ/qbITVZXV8sKM7HwCFkgRVGkJ3Lo0CGZjxAi0/Pz8ySTSSmyvd8xciGaPDExgcPhICcnRybazWbzYz29rZ6tWEiFMjwg1VkAqdKy9e+tra1x/PhxbDabLN54nlYC0Wc1ODgohYWF8S0vL8dgMEhPyGQysbKywuzsLOXl5bK1wWg0ykKF+/sGFUWRxTBiKobT6ZRh4eXlZSkoMD09LTUqd6s6T4Sbtw5yhs18pJCLE1PJbTYbq6urDA4OyrCu6L17FlHq3SI7Oxun00ltbS3l5eUPDGmOx+PMzs7S19fHnTt3mJyc3NF7RxQybe2P3S1UVSUejzM1NcXo6Ch3794lNzdXnrMophI9xgUFBcRiMUpLS8nLy5OC+/F4nMXFRdn+srCwsO85XUEqlZL3YlZWFl6vF6/XS0VFhVwnRW53bW0NVVXxeDwUFRVhMpmYnZ2VXuVuC23v6tVfUlJCa2vrAzeaKDMXs7O2Vh6KUUoieS/CBVvFq0WOUQjM7hUul4uGhgaampqkOkUkEkFRFNlLVlxcLHNJVVVV0sNZXl4mGAxy69Yt/H4/CwsLhEKhfTeCIyMjcgEQ3sPDpsTfj2iQB7ZtPlZXV+WIJKE5ulURX6ivCG/y3Llz2Gw2ksmk3Cx80V1gOp1mbGyMzz77jPr6ehwOBxaLBYPBQF5eHlarlffeew/YvM7W1taYnZ2lrKyMsrIyucN+GB6Ph+bmZlZWVmTuUa/Xy8kYmUyGu3fvcuXKFS5fvixlox62099tRB9jJpPZNvYpFArx2WefAZvfWUtLCzk5OQfCCAoZsdbWVgoKCh7YfIkF9dNPP+Xy5csHLq/0LKiqKkc6Wa1Wrl27RktLi+w7FTl2m80mZ3Km02mpbqQoitxwDQ4OcuPGDa5fv77vWrVbEVGvGzdu4Pf7KSsrk+u6EKfY2NiQPZGqqlJSUoLD4aCoqIi7d+9y69YtEonErjsLO3r1ix4zMYC0qqqKyspKOT4HNg2gzWbD4/GwsbHxgAyS0WiksrKS2tpaqqqq5PBT+L36islkIpFIyN6vycnJPWlGFuEnAL/f/8DjRUVF0qMQRSViEUqn05jNZuLxuPS4rFYr09PT+7p7i0QistLxUTJ1wssV1XjpdFqGr0VPl81mIxwOEwqFmJubA5BVpcJLEqOKRBWc3W6ntbVVig9sFSH4IqTTaSYmJrhy5Qqrq6tUVFSQm5srj09IZ4nvUeh8OhwO6f0+Kpogcn8PQ1EUGZITxT6i6EEYot24NkXxjciVJZNJWY0qpqmkUinZ9D88PExnZydWq1U29+/3Jkzgdrvl0OWtmzARKhfjeG7cuMGdO3d2/P3FtIa9CsOJVpyRkRFu3LiByWTCYrFIbWKR396aphDrqwinTk5O0t3dza1bt7h58+aB+S7h98Ii4+PjMpy7uLhIRUWFvP82NjZYWloiFovJtcLtdtPW1obX65XtLZFIRLb47AY7agTNZjM2m42zZ8/yjW98g/Pnzz+wcIhG3ba2tieelPCwhIFbW1sjEokQDof55S9/yZ07d7h+/fqetUh0d3c/c0+i0OV0uVx4vV7effddvv71r5PJZAiHw3zve9/j2rVrcqHaSxRFobq6mmPHjvHKK69Iz3urFFomk2FqakpejKIn6/Lly8TjcVwuF2+++SanT5/mr/7qrxgeHpb9Sa+88gpnzpzhzJkzdHd3c/36dTo7O7Hb7bz99tucO3eOo0eP8vrrr1NVVcXVq1f5yU9+wm9/+9svdD6rq6v09PTIAZ7BYJCOjg4aGxvxer0yLybOXWhtbq3gFAUjW0WXH3ediudYLBZaW1vx+XxcuHCBu3fv8otf/IK+vj7Za7nTEl1ra2syXHTp0iVZOeh2u0mn03z66afcvHmT6elpZmdnmZ2dJRgM0traSltb24FqYC4oKKClpYW6ujr5b5lMhtnZWaanp/n2t7/NwMDAc72HiD7cnwMV73Pz5k1GRkae6z2elZmZGf7u7/6OX/ziF9TV1XHhwgW+8Y1vPLS3dKuIeyQS4datW/zyl79kYWHhQBnArYhwZ29vL729vXz44YePfG5paSn19fX8xV/8Be+++y6tra1cuHCB3/72t/zd3/0dyWRyV/KdO2oEt+5KhVfxqN3z4xAlxMvLyywsLDA4OCi9j/n5eUKhEAMDA7JM+iAjZNZE/PvixYtMT09TVFSEz+fjrbfeora2VirGP0ylZKfZ2rZy/vx5mpqaqK2txe12Y7FYiEQicsxTIBBgYGCASCQivblQKMT4+LjUUb106RKzs7P09/dv8ybFxGvxI4oOsrOzZTGJ8JJFWGSnNgLxeJy+vj45Pf7o0aPk5eU98DwxGmpmZkb2Lra0tOB2uwGeaCS2Pi68Yvh9uLWurk72wA4ODu7IuQkymQwrKytEo1GGh4f5z//5P9PZ2Sn7MEdHR6VXKioIDyo2m01uVARb++me97oQqj5tbW0PTKff2ry+uLj4XO/zrGwV1ygrK5MVxk8qVjKbzfh8Pqqrq8lkMoRCoQOzofmiLC0tMTU1RSAQkNJrlZWVhEIhGhoaGB0dZX5+fsffd0eNoPDWlpaW5GL4uC/mUY+pqkoymWRxcZHBwUE+/PBDEomErIKam5uTw2r3Mif4RRCT11OpFNFolFgsxs2bNzl16hRvvvkmb731FslkEr1ez+joqKze201EvsHj8XD+/HmqqqpkcYdOpyMYDMoRLEKMOB6Py89bbHZEQ3koFJJ6m+JxnU7H7OwsMzMzUqtzamoKvV6Pw+GQRlCorYj+rp3a6cViMXp6emSVbmFhIS0tLQ88L51OMzU1xY0bN6QWrFC82crTLDBbQ8N5eXmyJ/L69esyp7WTCCMoKm2FHqpYQIX4tzDuYmrGVrZ6vPuJ3W6noKBgm4zYViP4vNeF2WyWerKPM4LhcPi53udZEf3Twgjm5uY+VcWu2WymsLCQqqoqQqHQgRx/9ayITfDs7CyxWAyn00lBQQHLy8s0NDQQCoVeDCMoxoH09PRI9ZetN5ooaV5fX8dut1NUVITT6USv10sB2f7+ftlcPj4+Tk9Pj/QMhZfyIiHCbEKmK5lMMjw8jMvloqqqSvYYnjx5ktHRUfr6+nb1eETeVoRoRWO4TqdjfX2du3fvcu3aNfr6+hgcHGR2dpZUKiXDhlsRORsxekewsbFBIpFgamoKm83GxMQE4XCY8vJyKT4tilA2Nja2iVXvBKKtw+12U1BQ8MDImnQ6TSwWo7OzU4ZqRNHOxMSE9JRNJhORSITx8XHi8fgDHokIdTscDvLy8qSWqGieF9qVjxsB9DyI0PXThtNNJhM+n0+GiPV6vfTw9zIndj9CVGFrkY6qqszNzdHT0/OFZ+E5HA45aujYsWMUFBRsy7Otrq7S398vr/G9MiRioHFVVRWvvfaaFJ4X0ZEnIVSbntSr+yIh0l5b58iKXOnjBqw/LztuBDOZDGNjY4yPj+P3+6murt7WlJvJZFhdXUWv11NfX8/bb78tjeP8/Dzj4+P87d/+LZOTk0xMTDwwp+5FZ319nfX1damSY7Va5fiiY8eO8cEHHzA8PLyrPYV6vR6PxyNV+c1ms2wmnpiY4Ec/+hEff/yxbFp90sIgzul+EokEXV1d9Pf3YzAYMBgMMh/l8/lk76SYMj87O7tjFW56vZ6amhrOnz/PmTNn8Pl8wKbR9vv9jI2N0d3dzd/8zd8QjUaJRqNSEMDtdtPX1yfHCg0NDfHRRx9x9+7dBzZglZWV1NTUUF5ezpkzZ6iurqaysnJbYYPD4Xis9uVe4nA4OHr0KO+995402OPj4zIMJRQ/9hMh4RaPx+nu7uZnP/vZM218xedeWVlJU1MTr732GidPniQ/P/+B/sNIJMJ//I//8bkM7dMgeoWF4ERHRwcdHR20tLRw7tw56SSIYpFUKiUl/AByc3Pl9yXaYkROW7RpfRkQ9kGsO1trE16IwhiBOPCJiQmi0ei2cIvo2RJjlHJzc1lZWWFsbIxr167R3d1NX1+fdI1fdBf/UYjQsdDZO3LkCHV1dVJ9fbeSwLC5i8zNzaWsrExWaa2urhIIBLh48SJXr14lHA4/VLz3WRDnuLGxIbUttxaqiNxvMBhkYGBAyirtBFarFZ/PR3FxsfxMRZh9cHBQFlYJlSJVVeX5fv755wwMDEhPMBwOS9Hz+z0lv99PIpGQGzbYVEoSFZoHDXEviqplRVGIxWJSfeUglNmLAritcw+fBSFi8M1vfpPGxkZ5DTxsFmEqlaKzs5NQKLSrqRWDwYDNZqOsrIy8vDzq6+ulzu7WAqx0Oi0HA4fDYRKJBDqdjuPHj+PxeKT4w8uAiHIIjeEXygjC70MZolweNhff2tpaDh06RGVlpWxgFgK4n332GTdu3NgT2aLn5UlVg0+D8Jr1ej21tbWywVv0Be2mEXS5XPLzFyo8U1NTXLt2jd7e3i98bmJhFZOvhTEoLy+npaWF1tZWysvLMRqNbGxsEAqFmJ6ellWlO9UuIvpQRbhXGKRkMsn4+DiXLl2iq6tr22uER9vb2/vIv7u1x1Gn08nZbYlEQlY9C1k2EXZ9lCzdfnH/GCwhJxaLxQ5Es7VIi4jjedprUSjnFBcXU1JSwoULF6itrX3oc0VeOxKJ0N/fv5OHvw1xL2RnZ8u+aJ/PR0NDA5WVleTn58vvQfTNjYyMMDg4yPz8PEtLS5jNZmpqarDZbPvupe8mW+8tURy0dbrJbm1S9rRL1uPxcPLkSdrb2zl06BBOp5OBgQGuX79OV1cXExMTuxqS2ClEef1OTN6ORqNSWkso4vh8Ppmn2Q2EPFhNTQ1Go5FQKERfXx83b958rkn3BoMBs9ksh5vW19eTl5dHfn4+JSUllJSUSBUXMd3h4sWLdHV1ySG2O+X5Czkxg8EgbyhRALF1TNezYjKZyMnJwev1Yjab5dTy7OxsSktLqaurk32xYrBpb2/vgd7YxWKxAzPaCzZD2WK6vRj19DS0tbVx6NAhiouLKS4ufqC4aStC7OL+jdBOY7fbcTqd1NTU0NraKuener1e8vPzt+WqRX7y448/ZmpqikwmI/sGxXSQL7MXaLFYZG5diDiIsWW9vb27Vguy50bwxIkTUg4tHo/T39/PL3/5S4aHhw/MTvRJCGFo4Ll7raLRqBSVTqfTslhodnZ2pw73AcToHaF7GolEpDbm87yvkOhyu90UFxfz2muvUVdXJ9VbRHhRNPsmEgk+++wz+vr6dlw012g0Sj1NsXAIuarnNYIinOV0OmlsbKS5uRmPx4PT6dymOhMKhWTf4uPEnfcbMY1hvwc8C4Tijdlsxul0PnVY+ciRI3z1q1+VRvBRQ3hh874bHBzcdSNos9koKCiQGsinTp3aptm6NZcnjKDo/fN4PDQ1Ncl2CLGh+7JiNpvxeDzSCIr84PT0tGx32g121QiKUEBBQQEFBQWcPXtWNtAnk0muXr3KRx99xMDAgGz6fRHIzc3l3/ybf8OVK1f4/PPPn8tjq62tpampiYqKCjnhQOir7hZra2tMT09z/fp1zp49S0VFBV//+tdpa2vjs88+45/+6Z+2CfGK2PzWm1bMyxPDXMvKyjh79iylpaWUlJRIbc2tMwcVRWFubo6JiQkuX77M559/zsWLF6XQ+E4SiUQYGxtjenqa4uJiWZBw+PBhqqqq+Na3viVzgaJyVwzd3Sp1ptPpKCkpoampSQ7JNRgMskBhq75qPB4nEokwMTFBb28vP/rRjxgaGnpgRNhB49KlS1y5cmXbfMS9Zn5+nu7ubhRFoa6uTm40L1y4QHV1NX//939PIpGQ4W1Ahru9Xi8FBQVUVFRsm2b+sGKR3t5eKdxw5coVhoaGdvW8XnvtNb75zW/S1NS0bfTYVlZXV+VkFbfbzbe//W2qqqrIy8uTSkVms3lb7lBUXg8MDBAMBl+YtfNRKIpCaWmpLC6zWCwsLCywsLCw67ZhV42gEBeur6+XKuKqqsoZdr29vUxNTR24GXtPQq/XU1xcTGVlJYuLiwQCASKRyDMtdGKDUFNTQ0tLC4WFhdL9j0Qiu2oExQTqgYEBjh8/jsPhwOPxyArR+fl55ubmpGESoTKbzYbFYpGVbmJskZhP19raui3MIwQCVlZWSKVSpFIp7ty5w8jICLdu3aKvr+8LFT48DaLQZ3R0FLfbLY9RTLoWTdmi8mxjYwO73U52drbc1IhFp7CwkIqKCikCLsLgYoioEIMXxSWLi4sMDw8zODhIIBA4EMUmj0NIru1nz20oFGJ4eJjs7GypGqPT6cjPz0en03HmzBmWl5fxeDzk5OQAm5tRUSzi8Xge6P8DZEuW6NO9du2arMyempqSOre7hd1ux+fzyZ7YhxlmsRZszWcKUff7w/mweT8ODQ0xPDzM+Pg4kUjkwOQKt0oTisrvJ62LLpcLl8tFXV0djY2NcrM8Pj4uxeh3k101gl6vl/Lyck6fPs2pU6fweDwsLCwwOjrK0NCQDL8dlDDM0yImXVRVVWEwGBgYGKC7u/uZjKAwIocPH+b06dMUFxej0+nkYroXnuDt27f54z/+Y5xOJ0ajEY/HQ1tbG3l5ebIvEGB8fJxEIiGnDgjjIIbJitYCj8ezTYk/k8mQTCaJx+PMz88TDAb5+c9/ztjYGDMzMwSDwV2r/l1dXWVqaoo7d+6gKAqtra1SgPj+vIo4F4/Hg9ls3pbnFT2VsNnyIc5HqOKIVh6hbxgOh2WRSTAYPNAe4EFifn6erq4uHA4H58+fl/8uxny9/fbbrK+vywkLsBk+M5lMj512IsYvBQIB2eoiRlzttgGE3w9dflwYU+gpi3tJjHYSrQ9br9eNjQ2CwSCXL1/m5s2bDAwMkEgkDoQRVBSF/Px82SK0srLCwMDAE6vMi4qKaGhooL29nZaWFlZWVpienpYqWrvtre+KERSLSkVFBa2trRw5coSjR4+STqf53e9+R1dXF11dXYyMjBx42bOHIUqZ8/PzcbvdbGxsMD09/VTSRaI03el04vF4aGhokOEfUaq+20UKoidTyKE5nU5Zwm232ykrK9v2/OHhYeLxuPSmhEd0/4/wkMQQWTHqZXFxUYofXLlyhampqV3XSt3Y2GB+fp7+/n5UVZVFO+Xl5TKsKQQaxKQPMftRhDq3Kq/Mz88TDoelWIPw7kZGRhgeHiYUChEOh4lGo/syOeJFR4wEys3NJRAI4HA4ZBjQbDZL7+9ZCAaDckadUEC6fv06c3Nze7bxFmpIQtxcCPBvRafTyR7Ah3mzmUxmmwD94OAgt27dkqH2g4IoGHQ6nVgsFtkCZbVa5aDnreujENKuq6ujvb2dpqYmiouL6e3tpaenh9u3b3P79u1dV/HZFSMoJLn+5E/+hHfeeUeWk/f09PD973+fgYEBpqamduOt94SlpSV++tOf8sYbb/DGG29gs9mIRqNyEdxqGLai0+nk3LBXXnmF8+fP8+qrr6LX6+Wu59KlS7uu8bi+vs7c3BwLCwt8/PHHHD58mLKyMjnySuRThBGoqqqSrxU5tNXVVZaXl6W6w+rqKhMTE1LaaGpqit/85jeyEX1rCHGvEAa4p6eHX/3qV1ImrqmpiebmZqlUL7zUoaEhBgYGyMnJwW63ywG1QkEnGo1Kub4va//qfiHyP9PT0ySTSd577z3+8A//UG4aH1YVef99Jhqqxc93vvMdrl69yszMzL4VJvX19fGjH/2IY8eO0dbWJqcoAA8NjcKD55VMJrl8+TKdnZ1cu3aNiYkJxsbG9uwcnhbR8jUzM0NzczPHjx/nnXfewWQyMTg4yODg4DaP0Gw24/V6efPNN2lubiaVSjE3N8f3v/99Pv300z0bKrArRlBMYDeZTDK8Fw6H5Sy9g54jeRLpdJrR0VG8Xi9Op5NMJsPx48exWCwEg0HpMWzNdYrhmIcPHyY/P5+KigqKioro6elhfn6evr4++vr69uziFsfV2dlJIBCQFVlGo5H8/HxcLpcc7Hn/zZpOp5mbm5NaiyLfFw6HSSaTJBIJIpEIoVCIlZUVaTT2K2Qj5jmGQiE536y7uxu73S7l3RKJhDSGW0O6qqpK71yoF71I+esXjdXVVUZGRrh06RLpdJqioiIKCwspKSl5YNZjMpmUmrNC+3NpaUmKsd+5c2ffB80Gg0Fu375NJBJhdHSUw4cP43K55GbzYSQSCeLxuBy+vbS0RF9fH5OTk0xOTu5JGPeLsr6+zurqKn6/X0ZVvF6vFARxuVwPDH9eX1+nq6uLYDAoNYb3YpCAYFeMoMViwev1YjKZSCaTcvhjd3c3MzMzL0QbxOMQw1udTicmk4mmpiaOHz9OeXk5k5OTjI+PMzExQTAYlF+k2+2mpaWFr3zlKxQVFcm8xk9/+lNu3rzJ0NAQIyMje/bZCI/u6tWr9PX1ySo0o9FIfX39tkq7+/MZyWSS/v5++vv7mZqakoUhW2cOivLmrcN39wuRm0ylUty4cQO9Xi9zg1tlmUSz/P0Cxuvr61Kx4iDkXr7MrKysMDIywvr6OrOzsxw5coQjR47I9WQriURCTjoJBAKyz1WMjVpcXNx3r31ubo5oNMrIyAhOp5OZmRmqqqowGo2y4vNhrxHeqxhfNjMzI2dWHuQohEgt+P1+gsEgNpuN+vp6mpqaaGpqorKyUq59YuZgd3c3g4ODjIyMyIruvawT2TUjWFBQIOXQ+vr6uHPnDqOjowdOPeOLkkql8Pv9GAwGGRoUYbSysjJycnK2LbAmk4nCwkI2NjZkX2AoFKKzs1PG9nerUvJxLC4ukkgkpN6iwWBgZWWFQCCAxWKRoeytiAbWyclJFhYWtgneHlSE0d/pmX4vGuvr60QiEfx+P263G5fLtd+HtA0hbTc7OyunYCwuLuL3+x8QIRezRcXP8PCwHN4aDocPhLEQ+p/pdJpEIkF3dzehUEhq6T7MCIrh1EJsP5lMbkuzHHREfcDa2hrj4+NsbGzISNHo6Kj0gMXGU6hFzczMMDc3t+eCKbtmBAsLC0kmkwQCAbq6urhx44bU53sRvsgnIaq0xKiXoaEhTp06RXFxMV6vl+rqakpKSgBkziyVSskBq+Pj44yMjNDT00M0Gt23HZ4Q6r1fS3JkZGTbcNn7z11Mxv4y67t+GRE50LGxMVRVfWghxn4jtEOXl5cJh8P09fXx6aefPhCRENKC4ieRSMh77SBdk0IQXCz4U1NTj8xzwu/PS+TRX+QQvNBAHR0dxWazYTabt4lXCBWnrVNM9ny4+BOmZn8ha+VyuSgpKcFgMMic4OLi4oG6MHcS0SpQXFwsK6OEdJjQv1tbWyOVSrG4uEgqlSIejxONRl8ImTiNLw+iGMHn83H27FlOnz7Nr371KwYGBhgaGsLv9+/3IWpo7Diqqj5yzMaueIIv4sy/50EojoyOju73oWhoPJaVlRUmJyeZmZnBarVis9lQFEX2qWlovGzsqXaohobGwUDIxMFmgYloZdHQeNnYlXCohobGwWerGslBqOLV0NgtHhcO1YyghoaGhsaXmscZwS/vcCoNDQ0NDY0noBlBDQ0NDY2XFs0IamhoaGi8tGhGUENDQ0PjpUUzghoaGhoaLy2aEdTQ0NDQeGnRjKCGhoaGxkuLZgQ1NDQ0NF5aNNk0jSfS2NiIx+ORw0pVVSU7O5v8/HzMZjPxeJxYLMb09DSpVOrAzzzT0NA4uIiRbmazGYvFQk5ODiaTSQ7xFjMLdwrNCGo8EpPJhM1m48/+7M/o6OhgamqK6elpBPbsxwAAIABJREFUNjY2KC8vp6WlBY/Hw/j4OOPj43z88cfMzMwQCATkTDQxCkZj/1EUBbPZjM1mw2KxkEqlSKVSLC8vv3DjzRRFwWq1YrVa5Xy6RCIhN2Bfdgk4RVHIysrCZDKRm5tLbm4uqqqysrJCIpGQU+n3eizR82A2m7FarVRUVODxeCgsLMTr9VJbW4vBYODDDz+ks7OTcDhMLBbbsffVjKDGI3G5XJSXl1NVVUVZWRm5ublUV1dLT9Dj8WCxWCgtLcXpdGIwGJiZmcHv9zM1NcVnn31GIpFgaWlpv09Fg82RX3l5eZSXl1NSUsL09DR+vx+/33/ghyLfj8FgwOv1Ul5ejs1mA2B0dJRAICAX/xfNsD8LWVlZ2Gw28vLy6OjooL29nUwmQyAQYHR0lPHxcQKBAMFgcL8P9akR682ZM2coKiqSRjA3N5e5uTkKCgrweDysrKxoRlBjb8jOzqaiooLi4mIKCgooLCx86CRsi8VCfn4+LpeLYDCI3+9nZGRETotOJBJf6gXpRcFsNksPvq6ujpycHLKyspifnz+wRtBoNGIymeTAZ/i9R1tVVUVzczMul0v+uxjSKjZfX1aP0Gg0kpubS0VFBR0dHVy4cIH19XXGx8fJzc3FZDKxvr7O/Pz8gb/3srKy5Aatvr6ekydPUlFRQX5+Ph6PB4BkMonT6cTpdLKwsLCj768ZQY1HotfrZbjpYRPmtyLCU3l5eZhMJrKzs0kmk3z66afMzs5qOcIDgNfr5atf/SplZWX4fD45T7C/v59EIrHfh/cAOp2OyspK6urqcDgccuKFoigYjUaqq6upq6sjOzsb2Ny0VVdXyyHely5d2lGP4SDhcrlobm7m6NGj1NTU4HA4gM1pIEajEafTycrKCsPDwwd2gyNwuVx4PB5qa2upqamhtLQUr9eLzWZDp9MRiUSYmppicXGRZDLJ2trajr7/vhtBsbjq9XqMRiN2u51jx46xsrIiwxqhUIjFxUXi8fh+H+5jsdvt2Gw2XC4Xbreb8vJyzGYzWVlZ24yIqqpEo1FCoRB37txhcXFxn4/84RgMBqxWKwaDYZsBXFlZYXl5GZ1OJ3foOp1OLqper5eqqirKy8uxWq2kUin8fj9zc3OsrKzs4xm9nBgMBkwmEw0NDXzrW9/CbDZjNBrJyckhNzeX999/f9/DZiIfVFBQQHt7O7C5CWtububw4cPk5ORs8wSzsrJwuVzS64HNAq5oNEosFiMajaLX6xkYGCAYDH4pZiVmZWVhMBhwuVy88cYbnDt3jpMnT+JyueTn43K5qKqqwufzMT09zW9/+1vW19cPpEdsNBrJy8vjzTffpLW1VYbpa2pqMJvNLCwsMD4+Tk9PD++//z5TU1PMzc3tuB04EEZQr9djMpmw2+34fD7effddYrGY/Onv7yeTycjKxIOKqJisra2ltraW119/nZycHIxGozSEsGkEx8fH6evrY3Z2lkgkciAv0kexsrJCKBTCYDCQlZWFXq9Hr9dLgw+bu3ibzUZVVRWnTp3i1q1bxGIxzQjuA8Izz8nJkR7VQbuPrFbr/8/edTY3dp3nB7333giCYAEJFrBt0e6KK8my5MSKLTuJEyfxTD4lM/mU7/kLmczkH3g8k5kktieyZTmxrLLatbSNnWABSBAk0XvvJR92zjGx0krbSGAlPDMYjZbt3HvPPW973ueFWq3GzMwM/uEf/gHAgz2kUCigUCiooSMg5waHw6H/JpPJqBNWq9Vw4cIFsFgsNBqNr4UR5HA4EAgEMJlMmJ+fx+joKIxGI83UnAaTyaTv5ZdlcLoJPp8Pi8WCa9eu4aWXXqLPmcfjoVarIRgMwu124/bt27h58yaq1Sqq1epzzyp11QhyuVwYjUZotVqoVCooFAoYjUa4XK6OvL5AIECr1UKlUkGxWOy51A2TyQSLxYLT6cTY2BiGhoZgt9vhdDohlUqpsTgNkUgEPp+PW7duIZvNIpfL9dx1lUolRKNRbGxsdHhfqVQK0WgUHA6Hfvh8Pq5evQqBQECjQw6HA5lMBpPJBJ/P13FgvUgg6Tc2mw2BQACRSESdGx6PR6+5Xq/TNpJMJoN4PN4Tzo1cLofNZoPVagWHw0G73e659LRYLIbJZMLQ0BAmJiYAgO4hDocDJpOJRqNBD8JSqUR/9rQTLRQK0W630W63odFooFAowOfzu3VZzwVMJhMSiQQ6nQ5arRbj4+OYnJyEwWCAQCD4wp/hcDhQqVSQy+XI5XI99byJAyORSGCxWGC322E2m+mzC4fDiEQiWF1dxcrKCjY3N5FIJM5sPV0zgiR9NjMzg7m5OQwMDFBjODAwgHq9Tj8SiQT1eh2lUgknJycoFos95cmyWCwIBAJcvnwZV69epZRliURCPbF2u90RCSoUCoyNjWFychKZTAbHx8c9d12ZTAZerxe/+93vKPkAAHK5HJLJZEcEKBKJMDU1BRaLRSNfANRA8ng8SmV/0cBisSAWiyEWi6FWqzE4OAiHwwGpVAqVSgWVSgU+n498Po/Dw0P4fD643W6kUil6IHcTOp0OMzMzcDgcXV3Hl0EqlcJiscBkMnUYrdOEmHq9jlQqRZ0wcl9JCWJgYICm7slBezoD86KCzWZDq9XC6XRSR3tsbAwymeyRP8Pj8SjDMhQK9VRdkDiTCoUCJpMJKpWq42zY3d3F5uYmVlZWsLKycqYGEOiCESSHplgshl6vx9zcHK5cuUJ7Q0iB9zRYLBYSiQSy2SwajQbi8XhPpdVI7czhcGBhYYGG9M1mk9Y2K5UKarUaLeoKhUJIJBI4HA7Knkwmk6hWqz2zYQuFAoLBIGq1Wkc6qlQqIZfL0VQo8cIPDg5QLpchlUohFAqpQSRR72mH4EUAOUTlcjkGBwehUqlgMplgt9vhcrmgUCig0Wig0+kgEAiQzWaxt7cHnU4HJpMJr9eLTCbTtV4twrrT6/UYHx/H0NBQV9bxOCC1LBKtAg+cxVKphHK5jEajgXw+T/tQDw8P6T5SqVSwWCwd5wepU582oi8KyNrJOSmTyTA9PQ2Xy4Xp6WkMDg7CaDTS72+1Wmi1Wh0Gn8vlQq/XQ6fT9VwGRiAQwGAwYGhoCDabDQqFomPtXq8Xd+7cgdvtxu7u7plnU87VCDIYDJjNZly6dAmLi4uYmZnB5cuXKQW63W7TB0q8OQaDAYPBgLfeeguzs7P45S9/iVKphL29vefOEnpaCIVCaLVayGQy8Hg8MBgMNBoNBAIB7Ozs4O7du1hfX6f9OwCwtLSE73//+/jud7+L119/Hb/61a8gk8lwcHCAnZ2dLl/RA5Bm6lgs9pXfy2Aw8M///M8YHR3F+Pg4nE4n/vRP/xRSqRQmkwlqtRpisZjWaHoZTCYTAoEAOp0OBoMBL730Ev72b/8WZrOZet8kwiMHcaPRgFgsxvz8PGZnZzE3NwcWi4Xf/va3ODg46Mp1kENwcXERS0tLsNlsHe9ZL2FiYgJ/8Rd/AYfDQc+AarWKmzdv4pNPPkE0GkU2m0UoFEI0GoXf7wfwYN+NjY3h2rVrsFgs0Ol03b2Qp8Tp804qlUIikWB2dhavvvoqFhcXcfHiRfq9p58fcQ5yuRz0ej24XC7NsjkcDoyOjuKzzz5DsVhEs9nsugPKYDAwMTGBv/qrv8LS0hJN8QIPIv1ms4kPP/wQP//5z89tTedqBNVqNS5fvoyLFy/C5XJ1FHXr9TpqtRry+TzcbjfUajVUKhUkEgnEYjEt7ms0GpjNZvh8vp4xguVyGfF4HKurq5TGDQDLy8s4Pj6G3+9HIBBAIpGga85mswgEAiiVSpDJZC+kx3oa7XYbsVgMrVaLsvPGx8cRi8UQi8WQTqdRLpd77vA9DR6PR3vpDAYDhoeHMTw8jMHBQajVavB4PLRaLVr7K5fLKBQKKBQK4HK5sFgsEAqF4HK5Hf1t3QCLxYLVasXU1BTsdjskEglYLFZPpGcfhXa7TUksRHDh3r17WF1dRSqVQqVSoTVX4EEdUSqV0jYKpVJJf1er1aLyWr16vcCD5ySRSCAUCiEWi6HVauFwOCCTyWCz2TAxMQGDwdDxM9VqFel0GvV6HcViEUdHRzg6OsLw8DD0ej2MRiPEYnGXrujLodFoYDQaYTAYoNFoIBKJUKvV0Gg0cHJygv39fRwfH5/rms7NCDIYDKjValy6dAkXLlzA5OQkOBwONYKNRgPFYhGxWAyffPIJRkZGMDo6Cr1eD6lUCj6fT1VKTCZTT9WXSqUSqtUqVlZWUCwWqSf73nvvIZlM0q+f1rzLZrMIBoMolUpQKpXUCL7IhjAajSKZTOLw8BDJZBKvvfYaUqkU0uk0MpkMSqVSzxtBuVyO6elpjI2NYXZ2FtPT0+Dz+ZRV2Ww2UavVkEwmaW0qEonQmiEh0ZC2hIcJUecBwgwcHBzE4uIi7HY7jcIfjmB7BSS6aTQaSKVS2NzcxL179+B2u7G1tYVCoYBWq9UhiSYSiWAwGGCz2eBwOGjd+vTv6nUJNTabDblcDpVKBb1ej8nJSbz88su0/UOlUtE+SIJqtYpIJIJSqYR0Oo2VlRWsra0hGo3C6XRSg9qLOG0EtVotmEwmisUiSqUSvF4vfv/73389jaBarYZarYbL5cLU1BRMJhOVOiqVSigUCgiFQvD5fPD7/fD7/bSucrpRm8fjwWKxYGFhAR988AGq1Srq9XrXNznxYPf396kRbLfbCAQCj0xDEKJPo9GgChhSqfSRbK8XAeTQqdfrVL8wFoshGAwiHo/3TK3zNEi/mVwuh8VigcViweXLl2G1WjE0NAS1Wo12u02jW9K2U6lUwGAwEAqFsLe3h1arhUwmQ1/uRCKBYDCIcrl87tckFAphNBopiUKn09EotlwuU7ZlLyGTyeDw8BDpdBp37tzB3t4e9vb2EAwGkcvlPldXJWlDg8EAg8EAlUoFLpdLa+vJZBJutxsHBwc93TDP5/MxNDREG8UHBwcxMjICkUgEoVBImcennclIJAK3201r8wcHBzg4OIBWq4Ver6cON9mv5IzsluNDzjdCHpyenoZGowGbzabnpNfrpU7PecssnrkRZDKZMBqNmJqawuLiIpxOZ4eXks/nEQqFsLa2hlu3bsHj8UAkEqFarUIgEHQwxbhcLmw2GyQSCTQaDbLZLIrFYs8crkdHRx2stS/Lw5OIotls0hy+UqmkzsGLClLUJynuRCKBg4ODnpXm4nA4MBqNGBsbw8TEBCYmJjA5OQm5XE6jp1qthnA4jIODAwQCAUSjUajValgsFkSjUXg8HsRiMayurmJwcBBmsxmFQgFer7crbS8SiQSjo6OYmprC8PAwRCIROBwO6vU68vk8FdDuJcTjcbjdbtRqNfz85z+nLVLlcvkLyx4kjUjqniTd22q1EI1GaS1+f3+/51qPTkMgEGBkZATXrl3D/Pw8hEIhZDIZJWWx2Ww0Gg26z7xeLw4PD7G8vIxKpUJT8sViEclkEoVCgbLq4/E4EokEarVaVwMF0uKhVqvxyiuvYHx8nDqX7XYbBwcH+P3vf4/t7W3s7++fO+nxTI0gadBdWlrCW2+9RT1rAKjVakgkEnj33Xdx8+ZN5HI5CIVCuFwuvPnmm7BarbBYLB0vK2nABtCT1GcSJTwO1Go1JicnoVAoaPP50dFRz6rHPC4GBwcxNTUFl8uFiYkJhEIhlMvlrr+IXwSZTIbvfOc7uHjxIi5evEjr0GKxGOVyGV6vFwcHB/D7/fSAViqVmJiYwKVLl6BUKqFQKGA2m3H//n389Kc/xe7uLoRCIVqtFmU2nhdICtZms+G1117DhQsXoFKpEAqFcHJyQhvGScTRS1hfX6dMZEJ6eRR4PB6++93v4sKFC7hw4QIGBwdpSaFareLu3bv4j//4D6yvr3clEv8ykJYAUn8eHR3F22+/jbGxMQwMDAB4wMpOpVLY39/H6uoq9vf3EQwGaX09n88jmUx+Lro7/Z41m02USiWUSqWu9whKJBK89dZb+MEPfoDFxUWIxWJwOByk02msrq7iZz/7GZ0OUS6Xz329Z2oEZTIZDAYDBgcHMTo6Cq1WS3P1xWIRkUgEu7u72N7ehkgkwvDwMGZnZ3H9+nXanHza0LXbbdTrdVQqFdTr9Z6VA/oqkFSO2WwGn8+nhe5gMPjCK1uoVCpMTk5ibm4Oer2eMma7URt7FIj8lEajwcLCAubm5jAzM0NrZoVCAfF4HHt7e1heXobX68Xx8TG0Wi1MJhNGRkbgdDrB4XCoTiOJ+p/EEXreEAgEUCqVMJvNsFqtkEqlaDabiMVi2NnZQSaToW0eBL3iSJL+v8cBh8Oh7QJOpxMqlYp+jaSuj4+Pe2qMECntmM1m2Gw2iEQieuYNDw/TXuh6vY5oNIpYLIaNjQ189NFHWFtbo602j5tNIYIIvUAM4vF4GB4exquvvgoul0uNdy6Xw97eHra2thCNRrv2vM7ECJIans1mw/T0NKxWKxViJlFPKBTCxsYGSqUSFhYWYDKZ4HQ6MTw8TGsWD7+gRDWGpEGr1eoLZwSJ1BPR2SQOQSqVol7eiwyxWEzrNOTFJ43yvVKHUiqVsFgsmJiYwIULF2AymcBisVAoFJDL5XD//n0cHh5id3cXHo8H9XodDocDLpcLk5OTsFqtn9OD7QUYjUYaHQ0MDNAWl/39fdy9exe1Wg3Xr1+n6ybpNnIt3T4sHxcsFgsjIyPQ6XTgcrmf+5rVasW1a9eQTCaRTqe7tMpOEDm369evY3p6GjweD1wuF2q1GiKRiBq/QCCAO3fuIBAI4ODgAPv7+8hms08sF9ZoNKgSVS+ckacJWdVqFfl8HuFwGOFwGPl8vqvR6pkZQRaLBbvdjoWFhQ4jmMvlaAR4//59VKtVXLlyBU6nE3a7HVqt9pFRAxkamc1mKePyRQMxCoTB1Wg0kMvlqBHsJRGAp4FIJILRaITRaASTyaQpuodFuLsJlUoFp9OJCxcu0P4rBoOBYrGIcDiM3//+99jc3KSi32azGW+++SZeffVVjI+Pdyji9BLMZjOuXbuGS5cuQafTUYdzf38fd+7cAYfDwfXr1wH8sXZLnJMXyQiy2WyMjIxAq9V+TlOUyWTSmXQffvhhzxhBsViMwcFBLC0t4erVq2CxWLSZv1arUabxxsYG3n33XRwcHCCVSj21eMZpI9jtdCjBaSOYTCY7jGA3DfWZGEE+nw+FQoFr167h+9//Pu2ZAh5sBmLs5ufnO7yhrzpcms0m0uk0jo6OepJk8TiYnp7GwsICLl26BKfTiY2NDSwvL2N3d7dn+h6fBkwmE6+++iouXbqEwcFBSKVSmob73e9+h0Kh0DPPzOFw4K//+q9x8eJFVCoVKs+0traGtbU1lMtlyOVyXL16lbbqEDk8gUAABoOBdDqNfD6P999/H++99x7cbndXr0kgEMBqtVJlmFarhQ8++ACffPIJNjc3cXJyAp1ORw8iBoMBi8UCvV4Pq9WKaDSKUqnU004Yl8uFRCLBwMAAJBJJx4QW4EGLTjwex69+9Sv893//N4LBYJdXDMzNzeHy5ctwuVxwOp2YnJyEUCika45EInj33Xfx8ccf4+7duyiVSshkMpQ097Tg8/kwm80wGo3w+XxdCxh+8pOf4MqVK5idnaWN/IlEAisrK7h79y42NzeRy+W66oCdaSRIpMHIvwF/nIhMxJW5XC7dzCTdGQgE6PeLxWKqAtFsNpHL5RAOh3tCdYR40CS1+XBq5oswPj6O2dlZWK1WcLlcnJycwOPxIJlMvjCeOICOKI9EtUajEQKBAKVSCYlEArFYDKlUCrlcrmcMPBkOrNVqIZfLkc/naXaByWRS0WWdTkfrNRaLBRqNBhwOB41GA+VyGW63G36/H8vLy9jb20MkEjn3ayHSWkKhECaTCePj41CpVB11QDKppFwuf25/nRZAf5hoRqJEErEQ2TtC2xcKhTS9Xa/XEYlEEA6Hz/R6+Xw+jEYjRkZGqCgBYSFXKhXs7Oxgf38f29vbCAaDXT8jSA1wenoaU1NTsFqtEIlEaLfbSKVSyGQyNErf2tqC3+9/qlYG8gyHh4cxMDAAsVhMRR0ajUZXzpXTJK3R0VGo1eqOocd+vx97e3uIx+NdP/fOjBhzWgLtdC2IHJ6EhEAmMJBCbi6Xw507dwA8MJxWq5UaQdKLdXR01BOH6mmCxcDAwJcK2hIQSS25XI5Wq4XDw0N4PB4kEomub4YnAYfDgUgkovU1o9EIjUYDAAiHwyiXy0gkEj1F9GEwGHA4HDCbzR2sYyLo63A4MDk5CZvNRpmfCoUCIpGIijNUq1XE43HcuHEDt2/fxtHREb3e8wabzYZSqaTSaJcvX4ZKpaLtGZubm7RN40nfF+Kcnq5dkZYEokpCnL58Po8bN26cuREkWSSXywWpVEolCsle+/TTT2lbRLdLJaSv2WQyweFw0NYu4MHZSMYEbWxs4ObNm0gkEk9lAInEn1gsxuXLlzExMQGlUolarYZMJoNMJtOVVCOfz4dSqYRer4dWq4VQKKRfy+Vy2N/fh9vt7okZsWdiBFutFmq1GtLpNKLRKB02S7zN02ov9Xod5XIZxWIRmUwG4XAY9+7dg1wuh0wmg1KppCmcer2OTCbTdS+PqLoTlZCBgQHY7faOSQuPwuTkJOx2O0qlEoLBIJVU+yJPvddAiBQMBoNucDIKxWq1UrWUUqmEYrEIn8/XMU6IfJ147+ddq2AwGNDpdJDL5VRUmPSb6XQ6KBQKaLXajt6608aP6Kh6vV7cvXsXN2/eRKVS6Yq3zefzIZPJ6BDSubk52O12sNlshMNheDweeDweRKNRev/J+JqHMxZ6vR6Dg4MdLR2EvSgUCsHj8WAwGCCTyWA2m2EymWC1WmmJg6gEnSV4PB6USiVsNhvGx8c7ZldWKhXE43FsbW3h7t27ZzJ9/ElBRhnZbDYMDAxAo9F0RK0nJydYW1vD6uoqvF7vU/8dJpNJRQPGx8cxODgIgUCASCTS1ZqgUCiETqeDXq+nZQQAtCaYTqcpG5j0QnYLZ2IEiWLI5uYmHRk0OjpK1Q8ICJ05mUzS8TP7+/vweDy4ePEibDYbTCYTNYDlchmZTAbRaLRrN43FYkEqleLNN9+EyWSC0Wikc7sepwHZZDKBx+PRVNrR0RFVjullkIZXiUQCDoeDkZERTE9PY3R0lKYXyZy3YrGIYDCImzdv0hQPiZqJEhBRvzhvEJUhYrQ4HA59JmQkFCFxnd6rqVQKR0dH2Nvbw9raGnZ3dyljrxvOC3FASKvA6Ogoms0motEoFWF/eJ6hRCLByMhIh8YmALz++utwOp2Uog+ATkIhrUpKpZKWNyQSCaRSKXUQTvfvnuX1kt5ho9HYkbotl8u0HpjP57uuIkXELyYnJzE9PQ2xWEz3CJk1ScoggUDgmf4Wm82mcmukHYnMXsxkMl1jXpLaLdEHJfXAVqtFo0SiiUqUbbr1zM7ECDYaDTQaDfzv//4vNjY2MDU1hcnJSVgsFlitVupVp9NpuN1uBINBmhbMZDKYmZmhM9C0Wi0d6eP1eqkUUjc8PblcTtMb//RP/0Sbqwnj1efzodlsYnBwkI4IeVRbQDwex9raGgKBQE+TEZhMJr3OmZkZTE1N0YnxdrsdBoOBps3IdI9AIEBT1na7HRMTExAKhRAKhZiYmEC5XMYHH3yAmzdvnuu1tNttbG9v01Ydu92OoaEhiEQiqNVqWtslhzuDwaAp63fffRcbGxvY3d2F3+/vSg0Q+GOt7s0338TCwgKV2xIKhfB4PLhx4waWl5exs7MDmUyGgYEBys5dXFyEw+H43J5888036QF0WleUXH+z2exwCkiPVzweRzgcPlPRY+Kc/PjHP4bL5cLo6CgGBwc71kaMSiQSQbFY/Nz9IhE9Eek/DdKzS9pGyPizp+1BJpkuqVSKhYUFXLx4EUKhEI1GA7VaDR988AGWl5exvr6O1dXVp+4pJdelVCoxOTmJ119/nfaFVioVJJNJxGKxrrVIDAwM4LXXXsPw8HAHEQgALBYLvvOd72B8fBztdhs3btzArVu3uqbsc6bN8kQzMpFIwOv1YmxsDC+99BJyuRzS6TSOj49x584dRKNR5PN51Go1iEQiWrch0VU8HkcwGMTu7i5CoVDXHqxUKsXw8DBcLhccDgc9LGKxGDY3N/Hxxx+jWq1iaWkJcrkcUqm0Z3rjngakXqvRaGCz2XDx4kW89tprkEqlUCgUNEog18hisWiaN5VKYXZ2looAk9Tx5OQklVLrhhH0+/2oVquIxWKw2Wx49dVXodFo6IcQQAiazSYODw/x0UcfYWdnB5FIpKtOC5nROD09jQsXLkCtVlO1lFgshuXlZaysrKBarWJkZARDQ0MQi8UQCAQYGxv7wtlyD2cwTjdaE8NRq9U6hkKHw2EcHR1hdXWVjgk7C/B4PMhkMiwtLWFmZobOpiSi+2R9j+qjI6QePp+PUqnUkQUAHtxPmUxGSzVEcYV8nhSnW09IGYi0QZRKJdy/fx/vvvsu1QJ9WmeeXBeRIzMYDLSFrFwuI5/Po1qtdq3EQjKACoWiYw3tdhtqtRqLi4vUCEYiEdy7d+/raQRPKyBUq1XqYZVKJeTzedocSoblAg/Ce7vdDrVaTUNoUl8i0krdSh2KRCKYTCbYbDbweDy6kWOxGEqlEkwmE7hcLgwGA2XPNRoNmibMZrO0tiGVSjE2Nga9Xo98Pt8xYaJb4HA4lAxCrlcmk2FmZgYDAwOYnp6mDNAvOjgPDg6QTqchFoupE0MYtGSIMrkv3eoZJD1ZZGCrXC7H+Pg47dkkLyxJsQUCAdy/fx9erxfxeBzFYrGrtVty6JlMJmi12o7IVaPRYHZ2lj4/q9UKvV4PgUAAHo8HnU5HGXqEuNZsNuHxeOh1kU+tVkOlUqH79mHDn0gkaOrV5/M91348wiwnxCu1Wk1ruWRQMAA6SogYN1JJUnWeAAAgAElEQVSDOw0i3iCTyRCNRhEKhToIKEKhEFeuXKEMy1wuR4chE/WfJ4nWyH2tVqsIhUIIBALQ6XQolUoIhUKUSEVUr55mL5GxXXa7HaOjo5ienobBYEAymUQ8Hoff76dM2W6xQ8nwdCKSfXpeIo/Ho9Mx2u02pqam8Morr8Dr9SIUClFJuHNb63n8EVKoLhQKtL2BGIdCodBx+HM4HNhsNqhUKrrZC4UC9vf3sbKy0tVWAjIR2WKxoN1uI51Ow+fz0Yd24cIFGAwGqNVqmgotl8vIZrOIxWI4PDyETCbDxMQEFAoF5ubm8MEHHyAUCvWExh+fz8fAwABGR0fBYDCg0WhgMplw4cIFKoFGRKUfRqvVwvr6Omq1GrRaLQwGA9hsNuLxOGKxGBQKBYRCIb0f3WTvkUnlxWIRHA4HYrEYIyMj9HAkjfNutxu3b9/G5uYmnQjRbfKSTCbD0NAQtFotJBIJPWQAUAYiMWgkajrd5nDa0JEo6s6dOwiFQh2OGBFmzmQyNK12GsRIEvHm51meIGk+wizU6XQQi8Wfk1EkyiPFYhGNRgMmk+lz9U61Wk2dTdI+cXq8kkKhwF/+5V/SKQfRaBR/+MMfEAqFEAwGcXBw8ER9bCSKJtqze3t7EIvFdO5fKBSiZ97T7iU+nw+Hw4GXX36Zvpt6vR7r6+tYX1/HrVu3sLGxgWQy2TWC0Gmj9/D/k+wR2Y8zMzPg8Xi4e/cu/vCHP3zh1JCzxLkYQWL0SqXSIwWiic6o0+nEpUuXIBaLweVyUa/XkUwmEQwGcXx8/NTe0/MA8ZzJ+CONRgMul0vrB6SuRK73vffeg8/nw8HBAY6PjxGLxSAWi6lk18zMDL71rW9Br9djZWUF6+vrXTGEpCducnISi4uLmJubA4PBgEAgoPWyh5U5HgZpPyBGJZfL4Z133oHX64XH46EDdo1GI6LRaFeVPMjz4fP5GB8fpxO4CXOS9G19/PHHVNy9V+TsJiYm8IMf/AB2u/1zz4TMoANAI13SA5nJZOikEvJ1Mubqv/7rv+D1ejsipNOOKolazgMSiQQXLlzA4uIi5ufnaWZCr9d/rrQgFArBYrHA4/EwMDCA119/HQA60rZ8Ph9yuRxCoRDZbBbpdLqj7snj8TA6Okp7IsvlMkZGRii56z//8z/pufO4IPrIRO2F1FB9Ph9isdhT30u5XA65XI75+Xn84z/+IwYHB6nkH5vNRiAQwN7eHjY3N7G7u/tUf+N54bSz9XA69HSHQLvdpi0ko6OjmJubw7/9279hY2Pj3NbaM5NpRSIRrFYrRkdHKZ0YAG28JgzKbnri1WoViUQC4XAYuVwODAajoy2iXq/TCerlchn37t3D7u4udnd3aRsEl8vF7u4uyuUyNBoNLBYL2Gw2UqkUfD4fyuXyuUdJYrGY6rzOzMzA5XI98e9gMBiw2+1gMpl0rlskEsHx8TEODg5oraRWq9ExOd0ESdFOTk5icHCQ7rlWq4Xd3V2srq5id3cXJycnXV3nw1CpVNRgn0aj0UClUqG1LEIYKRaLVJBZrVbD4XAA+KORTCQS8Pv9ODo66sblfA58Ph82mw1TU1PUGSbtVQ+DMFilUunnRMHJszyN00Lbj4JQKMTQ0BCAB+nlTz755Inr+kQsRCwWd0TrJPp7Gok6Uqowm82YmJjA3NwcBAIBuFxuBxmGqM30Cr7ICJK9SghXJAonJDWj0Yjt7e2nrss+KXrGCMpkMtjtdjidzo5ams/nw40bN3B0dNR1RfRkMomVlRUUCgWw2WxwuVxatwQAv9+PZDJJveeVlRVEo1EkEgmagiNtIScnJ9ja2sK1a9cwPDyMRCKBSqVC8/nneZ3EmyZC14+Dh19kkusnBwBJrZ6cnKDZbCISidBn2mg0uhoJEjULjUaDsbExqNVqMJlMmv4jMmrdYoB+GUhj/+mDudVqIR6PY3t7m9ayCoUC3Yvk35xOJ958880urv6rQfrryDxHQvl/EnTzjCD7XyAQYGBgAFarlRJYbDYbjEYjAoFARzvK4/w+pVKJ4eFhTE9Pw+Fw0DR3s9lEPB5HPB6nTnevCVSQ/5JPJBLB5uYmEokEDAYDpqenoVarIRAIKMlHp9OdWwamZ4ygVCqldHpiBMvlMnw+Hz7++GNEIpGuq6Enk0kq+cNkMiEWi2lKBgA+/fRTHB4eolqt0noFMdyn00zVahWBQABbW1t49dVXYbfbUS6XaVpjd3f3XF9kJpP5xEbwi3A6PUeM4MbGBhqNBiKRCEKhECqVCrhc7mOPzTkLkCkeWq0WDocDMpkMDAaD1qxXVlawurra9RrtF4HD4XQ0igMPDv14PI47d+7QuhPpmyPN2eVyGaVSqYsrfzxwuVxqBCUSSc+Irj8uTjuBFosFAwMDYDAYkEgkGBoagl6vp4PCHyezRVKHSqWSDiQYHR2lDicRCvB4PLh7925Ptlw9XBuMRqP45JNPsL+/j5mZGRiNRigUCjpEnfQdt1otFAqFMz8Lu24ESShM1AXI0N1yuUwnK5BIqtsgSji5XA5bW1u0h4l4qkdHR0ilUrSe8mWeXjabhd/vh8fjoU3ac3NzqNVqWFtbQzKZ/FzP01njWQ4coodIokoy0sbpdCIejyMUCiEcDiOdToPBYHT1QDYajZiZmcHCwgJEIhEdZbW3twe3241oNNrV2vOXgYygIeSdeDyOaDSKo6Mj3L9/n0rV5fN56oSRvUhY1SQ1F4lEsLW1de777MtAmrwjkQiOjo7opAXScF6pVB6rXPA8pmLE43Fks9kn+j3k3hIN5EAgAK1WCz6fD7VajatXr0IikaBSqdB67cnJSQcpiTjRQqEQarUaWq0WLpcL4+PjGBkZgUajoeSbZDKJra0tfPbZZ3TqRLeDhYdxuu+03W6jXC4jHo/D6/WiWq1iamqK9rMCwMzMDGq1GjY3NwHgzMsnXTeCBoMBw8PDmJ+fx9jYGIxGIxqNBk5OTrC5uYnl5WXEYrFuLxPAHzd4oVDA3bt3n+l3pdNppNNpvPvuuwgEArh69SquXLkChUKBYDCIW7duwev19sRB/LCiPempIhR6ov4Si8WoNBqLxUKj0YBEIsHY2BgYDAYVP+9mhEWmrv/whz/E1NQU2u023G43JSatrq7i+Pi4J+77F2Fvbw//8z//Ay6Xi0Qigb29PXg8HnqofhXI4ZnL5bC2toZ33nmnq1H5wygUCrh37x4ikQjW1tZoo7/NZkOr1UIkEnkkue40nocRLBaL2NjYeKL9elre8caNGxgZGcHVq1dhNpuh0WjwN3/zN3j77bepU0IyD6QXE3igrZnNZmn0Nzg4SKcwkCHcXq8Xfr8fu7u7uHHjBj766KOu19lPg3QD1Go12ptKnkepVEIkEoHb7Ybb7cb09DQuX74MqVQKAHjjjTfgcrnw3nvvodVqwe/3P5O03Fehq0aQwWBApVJheHgYg4ODNP3RbDYRCoWwtrZ25pqE3Ybf76dq8w6HAyKRCGNjY9je3qYyQ90+kB8esUMUIJLJJAKBAHZ2duDxeCCVSmlfGTGchGrebWkk4EHad3FxEU6nkyrdEBGGP/zhDzg6OkIymexpCTu/349SqQQmk0nrfU/SXtNsNmmPLiHMdFtn8zRIa8rR0RGV2yKN/o1GA4FAANFo9FzWUq/XEY/Hn8ppIyWPjY0NOiPVYDDQvk7STygUCiGXyzvaNkqlEkqlEvh8fockI0mB53I5rK+vY2VlBZubm7QE00sgUWqlUqFG8Msck9NZKFJDlUgktC58luiaESR5ciKIa7VaIZFI0Gq1kEwmcXx8jJ2dnTOTY+oVkBfa5/Ph8PAQWq0WQ0NDMBgMkMvlHaLGZwXSvkI8UNIcTAgkkUikY8oFUfAPh8M4ODjAvXv3sLKygqGhIartWiwW6dSPbhfqTyvtE6UKMtrl4OAAe3t72Nraogal207HlyGZTD5WJPQonI4EyaeX0mf1eh2hUIj+P5lFSgQ1SDN1r6PZbCKZTOLg4IA6+ER84rSAORFvPw0SFRKmNYPBQCaToangQCCAlZUV3Lt3D263G+VyuaccGeBBuefw8BCJRAJcLpdK1zEYDGrciXYoUdYihpBEvOTzRSpHzxNdM4JcLhdDQ0O4dOkSXC4XnYNVrVaxsbEBj8dDPfOvMyqVSsdcMZfLRScZkBaDsx4OWiwWEQgEIJVK6QR4EqUbDAYqjUW8VSLVlUgkEAqF4PF4EAqFUCwWUa1WafM0qeF0GwKBADabDXa7HYuLi3QoayqVwieffAKPx0Mb+HvJIPQBGpUTpZcXgdxDQAQ1jo+P6Tuj1Wq/UmifSOOR97BUKuHOnTu0xhiPx7G5uUlFNnrNAAIPxql9+umncDqdVJqOjJojsmlkvNLY2Bh4PF4HgfBRfYZngXM3gmTqvMViwRtvvIG33367gzEVjUbxzjvvYH19HUdHRz1BiDlLEBmv5eVlHB8fI5FI4Ic//CGWlpZgtVrx/vvvI5FInGm6I51OY319HcfHx1hdXaXyWmS0EDEUpG9HIpFAJpPRmmAmk6Ei4r0EsVgMlUqFoaEhvPTSS7h48SIWFxfRbDaRzWbhdrvxzjvv0CnxvRwBPg9kMhksLy8jmUzSVGgvp36BP5LRzisF+rxxdHSEYrGIw8NDrK2tYWlpCRaLBSqVCiqVCgKBgLY5pFIpOlO1UCggn8/TKTuffvopgsEglVwjuqC9umdPTk4Qi8XQbDYxNDRE05sAaPsOybrcvHmTCtuTPspKpYK9vT06DeUs0RUjaDAY4HA4MD4+DqPR2BHu1mo1HB4e0g3xTQBJG1YqFTpgd3h4GGq1Gl6vFzwe70zHw5DxQtlsFoFAgLZJkJYNEuERZLNZhMNhWq/s1edEBBicTicmJycxNTUFNptNDXYgEEAqleoJObTzACHDEAH7p6139fH4IA4WEY1vt9uU5UlSgPV6HcfHx/D5fKjVarTuGQ6HEQqFkEgkKOucZFh6fb8StuvNmzdx584dKsYPgIqzn55zSch2BER/9VHC6M8T524ESZ6biDA/POCTULfz+fw3JjVFGGWtVguBQAB+vx82mw0ymQxSqZSmRs7y75ON+ThqE2S6QK9DoVDA4XDA5XJhcHAQcrkc2WwWBwcHlAnai/WUs0Imk8Ht27dpzyARMOjj7HC6rapWq2FjYwOZTIZyHsRiMZrNJo6Pj6muMjF65ENmJL5oaLfbPcVYfRS6UhN8WFz1NJrNJhKJBCVWfFNAPKNoNIr9/X1cuHABMpmMTgB40ZqGuw1S05yYmMDs7Cy0Wi0l8+zs7OCjjz7C+vp6V8fNnDfS6TRu3bpFewd7tZ70dQQR/9jd3cXx8TFtDCcpQMLAJpPXCTmmVqv1HZUzxrkbwWaziWKxSCnzREGkVquhUCggFArR2YLflMOJgHhOqVQKtVqNjo15OFXQx1eDKBANDQ3BbDaDw+GgVqthZ2eH9icdHh5+oxytSqXSc1qo3xQQzcxnZff28fxx7kYwn89jb28PiUQCAoGATiePRqNYXV3FysoKLZh+04wgAMqoTKVSkEgkyGazPate0suYmZnBj370I0xOTkIkEiEejyMSieBf//VfcXx83PP9gH300cf54NyNIBkzks/nsba2hp/+9Kd0BhpprP4meecPo9FoYG9vD7/85S8hl8uxvb39uZmLfXw1Tk8HJ4LdhLGWy+X6acA++ugDQJdqgkS1Yn19HW63myoJnNfojF5Gs9mE1+uFz+ej6jl9A/jkIOOECOkonU7THquHB8T20Ucf31x0VTaNMKf66ETfGXh2RCIR/N///R+2trbA5/MRCARwcnLSE837ffTRR++A8WW1JgaD0S9E9fFCgkgzkXl0pMH4tPxbH3308c1Au91+JLOwbwT76KOPPvr4WuPLjOCTjWzuo48++uijj68R+kawjz766KOPbyz6RrCPPvroo49vLLo+Wb6PPvro41lAJBiZzAc+fZ9d3ceToG8E++ijjxcSZOizXC6HRqOBwWAAm82Gz+eDz+d7oWYP9tE99I1gH3308UKCy+VCJBLBaDTC6XRiamoKfD4fH3/8MSKRyDdmRFYfz4a+Eeyjjz5eKDCZTJjNZpjNZgwMDMBsNsNoNEIoFNLJGF/HdChJ+SqVSoyPj0Mmk4HH4yGVSiGZTGJnZ+eFEh8RCAQwmUwYHR2FSCSi6eyDgwPE43Fks1lkMpkzX0ffCPbRRx8vFNhsNp0T6XK5oFKpwGQysb29jaOjIyQSia+l6DwZcm2xWPD222/DarVCLpdjZ2cHu7u78Pv9L5QRlEgkmJ2dxZ//+Z9Dr9fT4eq//vWvsba2hv39fWSz2TN/jn0j2EcfffQ8OBwODAYDpqenMTk5iT/5kz+hQ7lDoRDW19fx3nvvwe/3I5vNfq3qgQKBAJcuXYLL5cLMzAzMZjPGx8chlUrBZDKhUCigUqnw85//HNlsttvL/VIwmUyoVCoMDAxgcnIS3/72t/HGG29AKBTSSDCfz0MikaDZbMLn872Yk+WZTCbYbDbYbHbHHDw2m02npD88H48wuk5PLScTz6vV6lks85lBrpEU6E8PweyP6emjj+cHuVwOq9WK+fl5vPTSS5ifn0c8Hkc4HMbR0RE2NjbgdrsRj8e7vdTnBgaDARaLRSOmpaUlvPzyy5BKpXTUHKl7vijzRnk8HtRqNcbGxjA9PQ273Q6JRNIR7clkMmi1WohEonO5rudmBMngVwaDAYlEApVKBb1eD6FQSL9HqVRiZGQEHA4HbHbnny6Xy8jlcshmswiFQmg0GqjX60gkEtjb20Or1eqp9AaDwYBGo4FOp8PQ0BDsdjtlpUUiEUQikZ5abx99vIggQ6WvX7+OqakpuFwuWK1WpNNpeL1ebG5uwu12w+PxoFgsdnu5zxUCgQBKpRI2mw2vvfYabDYbeDweANDgIJVKYXt7G7du3Xohrl+j0WBkZASLi4tYWFiAwWDo9pKerxFkMplgsViQy+UYHBzE5OQk5HI5/R6bzYZvfetbEAgE4PP5HT+fTqcRDAYRCoWwtraGarWKarUKr9eLg4ODnsvxEyM4Pj6Oq1ev4pVXXsGNGzdw69YtNJtNRKPRnlpvH328iGCxWODxeFhaWsL8/DwsFgvUajW8Xi/29/dx+/Zt7OzsIBgMfq1SoMADI6jX6+FwOPCtb30LTCaTpgybzSYdvr29vY0PP/zwhbh+jUYDu92OhYUFLC4ugsVidXtJz2YEJRIJLBYLbDYb/v7v/x5qtRoKhQJCoRBcLpcq+BMQSjMJcUkoz+fzodFoIJfL4XA4cPnyZRruJ5NJvPzyy/jNb36Dmzdv9kwjLIvFwuLiIv7u7/4OdrsdSqUSZrMZw8PDCIfDYDKZPbHOPvp4UcFkMjE0NISxsTFcu3YNdrsdrVYL0WgU//Iv/wK/349AIIB8Pv+1Kj9IpVIoFAq4XC5cv34dCwsLlDTSbrdRqVSwt7eHzc1NbGxs4O7duzg6OurZeyAUCjE3N4f5+Xn88Ic/hMlkgkqlouWy4+NjnJycYHt7m15TOp1GPB4/l1mqz2QEuVwuZDIZjEYjJicnIZFIIBAIUKvVkMvlvpTe2mg0kEql0Gq1IJfLwePxwGAwwOVyodfrqREVCoUYGRmBwWCATCZDqVRCuVx+lmU/FzAYDAiFQqhUKkgkErDZbORyOSSTSRSLxa9dFMhgMCASiSAUCiEQCCCVSjvqoTweD/F4HBwOhxIWAKBQKKBUKiGVSiGdTr8Q3uqLCEKdVygU4PP5aLfbyOfz9H2pVCo9e0h+Eci+slgsmJqagkwmQ71eRzQahc/nw+7uLpLJJHK5HOUQfB3A4/EwNDSE0dFRTE9PY3x8HBaLBQBoYJBKpbC2tkZTweFwuGdZoRwOBxKJBFarFTMzMxgaGoJcLgeHw0Gj0UCxWITb7Ybb7cbu7i5luZI9ex7n6DMZQVK0VSgUUKvVaLVaKBaLCIVC8Hq9iEQij/zZWq2G4+Nj1Go1WCwWiMViMJlMSCQSXL9+HXK5nB6yCoUCGo0GWq0WiUSiJ4zgFyEYDMLj8XwtZ9ax2WyoVCqYTCbo9XqMjIyAz+dDLBZDrVZDJpNheXkZYrEYOp2OFrtDoRCCwSC2trawvr6OSqXSj5DPAFwuF4ODg5ienoZGo0Gj0YDP50MwGEQsFkM8Hu+ZLMpXgcVigc/nQy6Xw2azYX5+HjweD4lEAltbW1hdXUUsFkOpVHqhDPtXgcViQSwWw+VyYWlpCQ6HA3q9HgqFAsAfiYKRSAQ3b96Ex+OB3+9HLpfr2fNGIBBALpfDYrFgYmICEokEHA4HTCYTpVIJ4XAYn376KT799FOEQiFkMhnk83k0m81ziQKBZzSC7XYb9Xod9XodzWYTuVwOiUQCHo8Hq6urODo6euTPVqtVHB4eotFowGazQaFQQCAQQKfT4aWXXurY3IRtSm4eg8HoyYeeTCYRDAaRz+efen1MJhMcDoemjFutVtfqoYToRCKM4eFh2O12mEwmTE5OQigUQiqVQqfTQalUgsPhQCwWw2AwQKFQgMPh4Pj4GEdHR2g2mwiHw0gkEj3rtb5oYDAYNAqXy+WYmprChQsXYDKZ0Gg0oFar6f0/Pj5GMplEIpFAs9nsaWPIZrMhl8thMplgs9kwNjaGarWKYDAIt9uN5eVlZLPZnr6GJwGDwQCHw4FQKITFYsHc3BwuXrwIi8UCLpcLNpuNdruNQqGAQqEAn8+HlZUVBINBJBKJbi//SyEUCiGXy6HT6TAwMAA+n0/rgOSZrq+vY3V1tWvG/JmMYLFYxOHhIdrtNra2tpBIJBAMBrG/v0+L1Y9Cs9lEJpMBi8VCMBhEq9WCwWCAUCiERqOBQCAAk8lEoVDAyckJgsEgIpFIT6caSYvHszBZeTweVCoVrQGUy2Wk02nUarVzv242mw0ej4dr167B4XBQdQ65XA6tVtuRsmaz2dBoNACAUqkEBoMBg8EAjUYDPp+PYDCIw8ND+Hy+vhF8TiClA71ej6GhISwtLWF0dBQqlQqtVgsajQa5XA4nJyc4OTnBwcEB3n//fRSLxZ7NpgAP3gGz2Yzp6WlYrVbIZDLs7+/D7XZje3sbHo/na2MAgQfPUalUwmAw4PLly1hcXIRaraZOP/CgfHRycoK9vT0sLy8jHA6/EGxQoVAIhUIBsVgMPp/fwRGpVCrw+/04Pj5GtVrt2rn+TEawVCrh6OgI0WgU//7v/45cLodUKkU/X/aQGAwGxGIxZmZmMDo6CpvNBqvVioGBAahUKhSLRcTjcWxtbeEXv/gF1tbWEIvFnmW5zx3lchnJZBIymQxsNhsGgwHDw8NotVpIJpOP/VBZLBbUajU0Gg2sVitcLhc4HA5KpRI8Hg8+/fRTJJPJc0kPMJlMSKVSiEQimM1m2Gw2/OQnP6GpDLFYjHq9jlQqhVwuh3A4jEKhgGKxiJWVFRSLRVQqFYjFYrzyyiu0faRYLILFYsHtdqNcLkMgEEAgECCbzaLRaKDZbD71S8BiscDhcGjEKpfLoVQqIZPJUCwW6aFfrVZRKBSQz+eRy+XQbDYhl8vB5/PB5/ORzWaRzWY7jDSDwQCfz4dKpYJYLKY10Xq93vHiknuSTqeRy+Wey7P4KkilUiwuLuLKlSvQaDQQi8Xwer3Y2toCk8mE0WiEWq2G2WzG0tISgsEgBAIBtra2qMRWL/bgymQyzM3N4Tvf+Q7MZjO4XC7ee+893Lt3Dx6PB4FAoNtLfK6QSCQYHh6Gy+XCa6+9hvn5eZrxAkD7Ae/du4df/OIX2Nvb67mz8GGQUsnrr7+Oubk5TE9PQygUotlsIhaLwefzYXNzEx988AH29/e7ug+fuUWCsJU+/PBDtFoteqB91YF9ugn05ZdfxvDwMDQaDWQyGQ394/E4dnd3cefOHaTT6Wdd6nMF2ZjpdBqFQgFSqRQGgwF2ux2JRAJMJvOxjRabzYZOp4PD4YDT6cTLL78MFotFU1crKytP9PueFkSbkKjyT05OYn5+HuPj49Dr9ZSiXSqVEAqFEAgEEAqFEIvFEIvF8OGHH6JYLKJWq0GpVILH44HFYsFqtUKlUmFsbAwymQwcDgcymQwKhQK1Wo0WwJ/m+khbDp/Ph9FohM1mw+DgIGw2GywWC6LRKOLxOO1BJT2cwWAQ1WoVJpMJcrkcMpkMgUAA7Xa7w3ljMBiQyWQYHh6GTqeDSqWCTCZDtVrtSN+USiXs7++j1WqdmxEkEdPU1BSazSbW19dx7949hMNhcDgczM3NYWxsjH4kEgmuXLmCSqWCk5MTFIvFntPZJClejUaDwcFB8Hg8lMtlarjP696eJ0gkqNfrIZVKP9c2QMpOkUgEW1tbCIfDXVrp40MgEECtVuPChQu4cuUKFAoFWCwWarUaIpEI7ty5g9u3b2N3d/fcCDCPwnPpEyRMtK8CIb5IpVKoVCoMDw/j4sWLGB0dhV6vh1gsBpvNxvHxMbxeLzweD1ZWVpBKpXrOYyWGOhqNQqvV0hSuRCL5XA/ko8BgMGAymaDT6agkkkwmQyQSQSqVQjAYxMHBAcrl8pkeVKTmStiuCwsLsFqtGB4extjYGORyOZhMJrLZLHK5HILBID777DNqADOZDNLpNMLhMK1fSqVSqNVq2hJDDKzT6YRSqYTRaIRer0cgEMDBwQH29vaQTCYfe81CoRAikYiO0CFNuHq9HjqdDjqdDhqNBhqNBtlsFsViEaVSCel0Gul0mupL6nQ6iEQiiEQiJBIJxGIxVCoV+ncIK9ZkMkGhUEAqlUIoFFJmG3l5q9UqNBoN6vU6Tk5Onvsz+iKQdNLdu3dRqVSws7ODnZ0dpFIp2rebTCaRyWRQKBToPUokEqhUKtjf38f+/n5PMXb5fD4sFgutM6dSKUQiEUSj0c9F6V8HiMVijI+PY3JyEk6nEzqdjn6t0WjQfulMJoNcLkedzF1U0VsAACAASURBVF4Gg8GAWq3GxMQEhoaGoNFoaJN/rVZDOp3G4eEhvF4v0uk0TftyuVzw+Xw0m82OYIo4yI1G40yM5blqh7LZbKjVathsNgwPD2N2dhaXL1+mtG42m41KpQKPx4O7d+/i9u3b8Pv9PckoJIY/EonAbDajVqtRWjdRz/kyEEmkkZERTExMYH5+HgsLC4hEInj//ffhdrvh8/loBHOWUSCLxYJAIKDR2iuvvAKHwwGNRgOlUgmBQIBGo4FYLIbDw0O43W789re/pRFWrVZDvV5HpVIBi8UCl8uFQqGgv4PBYKBer6NcLmN2dhZzc3MYHBzEwMAAotEoPvroIySTyScygjKZDHq9nqqIDA0NYWhoiKY2+Xw+lWiq1+tUyq5er9M0YLvdBo/HA4fDoV5qpVL53L1ms9m07YN8L6n/kpey1WpBr9fj+PgYt2/ffq7P51HI5/NYWVnByckJarUaTVHXajUwGAxUq1WqYBQKhTA9PY1XX30VtVqNOpzhcLinRg6JRCIMDQ3BYDBAIpFQhzidTqNarfbcOfCsUCgUmJ2dxfz8PFwuF6RSKf1arVZDNptFoVCgjlyvXz/JFul0OszMzMBkMlFdULInM5kMgsEgTk5O0Gw2IRAIwGazIZVKoVQqUa1WafmCPHPyvp4FG/hcjKBKpaIH7FtvvQWLxQKz2UzrYKdz3yQdolAoKJuIw+EgnU4jk8mgWq32hCdE+nV8Ph9MJhPGx8dpSkMikXylEVQoFNDr9fjxj3+MhYUFujnW1tbw61//GuFw+FzEcEUiEQYHBzE7O4vJyUk4HA4sLi7SFhUGg4GtrS0cHBzg3r17uH//PsLhMA4PDykr+DSIaMDc3BxcLhclOBGCzNjYGGWRikQiiMViuN1u6ik+Lq5cuYLvfe97MJvNkEql4HK5KJfLtEYdiURweHjYsbdYLBbeeOMNmjIlakanxRuKxSISiQTy+TwSiQRNw+dyOVrvI2lENpuNixcv4urVqzAYDKhUKpDJZM/6SB4b1WoVx8fHCAQCX0jGIuSXeDyO9fV1bG9vQ6PRwGg04q233gKXy0Wr1cLvfve7nkkzqtVqXL9+HUNDQ+DxeCiVSggEAiiVSudGmT8PECdtamoK3//+92G1WqHX68FgMFAoFJDL5bC1tYWbN29id3cX5XIZPp8PhUKh20t/JEimx+l04tKlS3jppZdgMpnAZrPRaDRQq9Xws5/9DKFQCAaDAT/60Y8gl8up2IhQKASPx/tcJFitVnF0dESJdfv7+/D7/c/NITgTI0hSX8R7JnO/XC4Xrl27Bo1GQ3tfHgaLxYJKpcLg4CCYTCYSiQRlF0ajUeRyOeTzedRqtWdmYj4rSBN4LpdDpVKBSCSCUqmkKbMvovySCFChUMBms8HpdGJ4eBhbW1vweDzY3d1FMBg8c/YeeUY6nY4W5efm5mCz2aDRaNBut1GtVlGpVLC7u4vNzU0sLy/j/v37KJfLX9igzGAwIJVKYbFYKKuPeIBisRhisRgAqEdXqVQQi8WQzWafuOGZpNNFIhGKxSJSqRQCgQD8fj/8fj8tvJ8Gm82G2WwGn8+HTqej6yCfdDqNVCqF4+NjpFIphEIhWn9JJpMIh8NIJpOUns/n8yESiWhvXjfwOLXUfD6PfD4PPp8Pn89He26NRiMGBgae2AE5SwgEAhiNRkgkEgCgPINeiVSfBwgfQqlUwmq1wmazQSKRUJWpdDqNUCgEt9uNzz77DMvLy9SInI6ESJmBCPkDf2yoJwbkPCNHLpdLWzwmJiZgNpvB4/HomhqNBvx+P22LI4GQ0+mERqOhjPiHQbKD29vbkMlkaLVayGQySKVSz2XdZ2IE+Xw+ZDIZXC4XHX5pMplgsVigVCq/sGZGvHFCtedwONBoNCgWixgdHUUymUQ8HkcgEMDJyQmOj48pm68bdG/yIA4PD2G32xGLxWiEQRTS792711FfAh5EXhKJBOPj47h27Rp0Oh3K5TL29/dx48YNeDyeM0/7ELUbgUCA733vexgfH8fIyAgsFgskEgllVB4dHcHr9eKDDz6A3++nZJJHHbpCoRAGgwFTU1OYnJx8ZFq4VqshkUggHo/jt7/9LVZXV5+Y+LSzs4N3330XAGiqiAzhJCzNh+89m82mDePkoIjH4wgGgwgEAvS/hH5OWKTAA4eHqN9UKhWoVCqo1WrI5XIIBIJHvsC9BJJW6uWIiqTmHxbY/7qAy+VCIBDQNP7s7CxEIhE4HA4VG9nc3MTdu3exsbFB2wceFjogNTSBQACtVgudTgcWi4VKpYJyuYx8Pk/fg/MACV6MRiPsdjv0ej0954njz+Vy8e1vfxutVovW18l5+GUaomw2G1qtlg5nEIvFUCqVeOedd54LV+TMjKBGo8HVq1fhcrlgMplgNBohEom+lDRCmkY1Gg3UajX1/mq1GgqFApLJJNxuN7a2tsBmsxEIBOhD7wbS6TSKxSJOTk4Qi8UwMzMDiUSCsbExRCIRbGxsfKERJMLbS0tL0Ol0SKVSODg4wMcff4xMJnPm6V4SpSuVSvzZn/0ZRkdHIRaLIRAI0G63EYvFkEgksLm5iQ8//BAffvgh0un0V0bdQqEQJpMJU1NTcDqdHT1Bp1Gr1RCLxeDxePCb3/wG4XD4iV/Wvb09KsN2Wqru4c9psNnsjjpeo9FAPB7H5uYmVlZW4PF4sLe3h0QiQT1u8r2nf1+73YbRaIRWq8X/s/ddsY1m59kPKfZeRVKiWCSRoqg+mqaZ2dk6W+xdZ71r2IkRxAgQIICRq+QiFwF8GSC5zUUCBEkAI4FjJ3a8C28be8s0TVGvVCFFSuydFHvVfzH/OZZmZtc7GkmkbD6AsGUKvo/fx/Oe875PkUqltGXf7CCtpWZ2WSFF8DR8nocBl8uFWCzGwMAAvvGNb8BsNkMkEoHBYKBarSKfz2NxcREfffQRJS09aT1gMpngcrmQSCTo6elBf38/2trakMvlkEwmEQqFaHfjJEBkXp2dnY8VQfLrbW1tePXVVwHgAFnud42OSBFUq9WUoKZWq/Hxxx83XxHUaDTQ6XQwm83o6enBmTNnaPqxSCSi1Oz9Eop8Po98Pk/ZieT4TD40sVhMdwEMBgMWiwUCgQAqlQqhUAherxc+n4+aa59k26RWq9HhdSgUQqFQgEQigV6vx9jYGL744gsEAgHK6GIymTAYDBgeHobVaoVUKqXi342NDWQymWNnwRLdW09PD4aGhqDT6ShJgmw2ZmZm4HA46LXlcrnHTg9kd0daMVwuF2+88QbGx8dhNpsPpIc8ikqlgng8Do/HQ+dvT7swk9lIuVymM7rfhVqthpmZGezu7mJnZwcCgQCbm5vY3t6Gx+OhDMSvEu6Sxcdms+H8+fPo7e2FQCBAJpOBw+FoKgcPQhCSSCSQSqUwmUzo6uqCVCqlTkA9PT24dOkSXSyJ5KlQKCCfz1MJxUn6vh5Vhhwh25G1g7T4G5lIo9FoYDQaYTQaodPpIJPJ6LWVy2VqKhGPx1EoFOj3gowaJBIJxGIxTCYTtFotdDoddDodOjo6wGQyaQEUCASIx+Nf6dp1lOByubDb7fT94vP5TzzdPbq52T+zT6fTiMfjdC0ltYGM0gh7VKVSwWAwfOkm+2lxpEWwt7cXL774Is6cOYP+/n6IxWLk83nKKvR6vZiZmaEvIgA6h2Gz2VAqlRAKhQBAmXharRbj4+OURKHRaGC1WnHt2jVks1nEYjG4XC6Uy2UEAgEEAoETI86QFoXH48HNmzfpUNhoNMJkMiEcDsPj8SAUCiGbzYLFYuHFF1/ExMQEOjo6oFAoMDU1hZmZGSSTSSgUCrS3t0MgENAeOmFIAb89jZTL5UOHh8rlcnR0dODVV1/FH/3RH0Gn06FQKCAcDiMYDMLn8+HnP/85pqen6azu0QWDy+Wis7OTShOEQiEkEgn+6q/+Ckqlks6Ca7Ua3e0R5PN5RKNRrKys4NatWwiFQod6XqRl+zTY29vDhx9+CB6PR2dOT/s5isViGAwGvPnmm3jttddo625jYwM/+clPsLy8/FR/31FCIBBAJBJBLBZDLBaju7ubtqg6Ojqg0WioRKWtrQ0mkwkikQh9fX30GRDWM5GSkIXY7XYjEolQ1h5pGe9/P48CtVqNFt+nAYPBgFwup3IXgUAAo9EIoVBIN9TVapXqRpPJJG2jn4T8irxz165dw7lz5+g6wefzKRnL6/Xi1q1b9HtRKpVo21Or1WJ4eBiDg4Po7OzE2NgYzGbzY3l8RKq0tLSEbDaLtbW1Y70/kgxkNBrxve99Dz09PdBoNAfmzPs7M+FwmBZ20plIpVLI5/PU1Wh5eZnWhUQigTfffBNdXV1URaDRaJ6YSXtYHGkRJL6XTCaTGviSmAyv14tQKITNzc0DA1vyJSI7bLJTICJokUiExcVFSq7p6+uDzWajbKL29na0tbXhW9/6Fm7fvo1UKoVqtXqiA+F4PE6TrcnJVa1W4/XXX0csFqPuOUQSYTAY6BzAarVS8bhYLKbU/3q9Th1pyACY0PITicShi2B7ezt6enrQ1dUFnU6HWq0Gv9+P6elpLC8vY2dnB0tLS9jd3f1SQgIxOThz5gwsFgtdeLVaLdra2lCr1VAoFOhGZn8RzGQyiEajCAQC8Hg8DZlPVSqVQ7MhhUIhdTiSSCSoVCrIZDLwer1YWFh4KpnHUYKc7AwGA+3EjI2NQalUUk0lMTMmiS0CgQAKhYKe2slCtV9GQr6rsViM7tTj8Ti++OIL6l1JmHxHgUqlgnQ6jfb29qf6c0wmE3q9HiaTCR0dHdDpdNTliMPh0DXJ7XZje3sbTqcT6+vr8Pl8J5JGTzYl58+fp7IwDodDWeaLi4uYn5/H3NwcTYUg3RahUAi73Y6LFy/iypUrUKlU1MHo0e8nmctns1l0dHRAIBAcqyGCUChEV1cX+vv7MTQ0RMX+j14XYXw6HA66eS2VSojH41hdXUU0GqVrXSKRQLFYpEoAonMViUQHiDZHhSMtgiTkMRAIAAB92ba2tuByueji/XVvgJwi3G43zGYzLBYLcrkcqtUqBgYGqI0Vl8vF5cuXEYlEsLKyQvVeJ1UId3d3USgUsLS0BIFAAKvVCj6fD4vFApPJdKAdSloFwMOZVHt7O23ZcLlcKBQKdHV1oVarUes48pnVajVUKhUEAgE8ePDgUNfa2dkJi8VCe+tkF0qYaH6/nzIiCfOMy+WCxWKBw+FQBtjZs2cxMTEBm81Gd96lUgnpdJpGZHV1dVEhPnnmRF7h8/kQDocbons6jEM9sWZTKpXo6emBTqcDh8OhrNTNzU3s7Oyc+LyNfL4SiQQ2mw0WiwVWqxUWiwUDAwMQi8XgcrnUt7Fer6NYLFIafiaToe1w8oza2togEAgoYYHFYsFoNKJarSIWiyEejyOTyUCpVNKUimKxiFQq9czGDqVSCbFYDJ2dnQBAo7m+rPXFZDIpK3t0dJQSvMhmgLTlyOxJq9XSd5/L5YLD4dB593G+iwKBAHq9nj4bAmI9ubi4iPv378PpdNINGmllt7e3Y3x8nMqORCIRyuUyyuUytVOs1+vUjUkikdD7lMlkyGazx3ZvfD6fjsC6urpo63k/CCErn89jYWGBtt6LxSLC4TBmZ2epXpUUbLIekpY2AdmkHaXX6JEWQZ/Ph8nJSayvr0MsFtOdYyqVol+Qp7nwvb091Ot1ZDIZ7OzsIJPJwO/3Y3Z2Fu+++y794KVSKWWfGo1Gyvo7KcIMaV1OTU0hHo/D5/MhHo9jeHgYQqGQsrjIgkWSN0hbmNimkd8nkUhQr9epu45OpzvQHn0WSrvJZMLg4CBlkwEPFx7iorJ/7sPhcCjZhZhmt7e3w2g04rnnnoNer6cn2r29PUSjUbhcLqytraGtrQ3vvvsuXVxJEV9cXMT09DTcbjfy+fypob4TNx2z2Yzu7m4IBAJqlXbv3j3Mzs6eOJWfkEhEIhGGh4fxzW9+k0bv8Pl8KqLX6XT0WRWLRWxvb9M5qMfjoael/ddOFiCRSASpVErjzvh8Prq6uvDaa68hGo1Sy7xIJIL79+9ja2vrmYydSVEwmUxUWkPyRR8FSZbp7u7GpUuX8PLLLx9wAEqlUgiHwyiXy6jX61AoFBCLxejp6aHfK7PZDKfTiUKhcKymASR7lWyACaLRKO7evYu5uTlK9iKQSqWwWq2w2+145ZVXqOSgWq3S2RmJlMrlcrhy5QoNNSeWejqdDuFw+NgyF0mCiVKpfGIBBB5uOtPpNCKRCO7evUsj9ojrEmmz7//+EC9mo9GIvr4+asNYrVappWZTFsFgMHjkvnbEyzGXy9FcOgDQ6/V090NsuEjL9KSlE2SBX1hYgNPppCQCMo9RKpXUCaJYLNKXdv88ggy9H8X+VhVxZXmWRcZoNFJ7JrK7Ji09YipNiqxEIoFMJoPFYqHU556eHphMJvT399PrIqeLUCiE9fV13Lt3D3w+H2+//TbdgZICvrS0hKmpKXi93seYs80MkUhEvUnNZjN4PB6y2SycTidu3boFh8Nx4qdaFotF2+9jY2O4du0aNSlOJBJYW1uj/rNKpRI8Hg+5XA4ejwdTU1NYWFjA7OwspFLpY0WGzHlVKhW0Wi1qtRr0ej0UCgXNlSwWi3TztLW1hUgkQolgh0Uul8POzg52d3cpJV6n04HH4z0WoUacfLq7u/HKK6/gtddeA4/Ho620mZkZRKNROtsm2YTt7e20I2IwGPCf//mfAHCsHpakCD7Kjo/FYlQOsbW1Rf8/CUnu7+/HxYsX8fzzz9PNZD6fRzgcxvr6OpxOJz1kWCwW2q3hcrnQ6XTQarXHKjchxiYqlepLCU0kMcjr9eLevXu0U/hlYDKZ4PF40Ov1GBkZQV9fH+RyOZhMJpVChUKh5hbLnwR++ctfIhqNUvNklUoFjUaDwcFBurs4CceVR5HL5XDnzh08ePAA77//Pq5evYrvfve7OHfuHGq1Gt577z188skncLlciEQiT7Vg7E8sOCzMZjNGRkbovAF4SGj6wQ9+gHfffRddXV0wm81gsVhU50f+nbTGkskkPvzwQywvL8PpdNLQVi6Xi5GREbz66quw2+1QKBRUFP/555/j+vXr+MUvftGwNuhhweFwcPbsWbz99ts4e/YstFotlpeXMTU1hfv372NhYeFE5kr70dPTA5vNhpdffhlXr14Fi8XCrVu38OGHH9KEiPPnz2N0dJSyrXd3d3H9+nV88MEHuH79OorFImUkPrqA7aewk1ZwW1sbZScS7W9/fz8MBsOBdtyzIJVKYWpqCsPDw8hkMpRx/u1vfxtTU1NYX1+n3qw9PT0YHR3FpUuXYLVaEYvFEA6H8cknn+D69etUc0u+NzweDy+88AKuXLmCoaEhWCwW9PX14S//8i9x48YN3Lhx42t5IB8ldnd34Xa7D8you7u7YbPZMDExgZdeeglDQ0PY29ujxe7WrVv4h3/4B6RSKRSLRRqnRboCxGFrdXUV6+vrx0qMUavVOHv2LK5evfrEXy8Wi4jH45icnMRHH330lWsy6TxcvXqVOledO3cOQqEQlUoF2WwW6+vr+N///V+8//77R+ZydCJFcL+zAWFpPWvriLQdXS4X1RUSYg6ZsTUKpN25f/Egs7yVlRVsbGzA7/dTOv5JwuPxYHFxkRpNEwd70m4lhtT7he67u7vIZrMIBoMIhUKIxWKYn5+H2+1GMBhEJpNBPp/HSy+9ROeg7e3tVBKzs7OD6elprKysUOLSaQB5n0wmE8bHx6m9U71eh9vtpkSifD5/4kW9t7cXg4ODMJvNUKlU2N7ehsPhoBsMpVIJq9VKW0lEm/ngwQPqSXsYSRHRoRF95u7uLg1N9ng8z9x9qdVq1LIuEAjQeKzh4WHs7e1RotX29jaVfXR2dkIkEtGsvbm5OSoz2D/7zeVy9B3W6/WoVCr0pCmRSI6Mcv80IF2k/c+B+G7a7XZa3CqVCvXtffDgAWVZEsPxsbEx2jXKZDL0VJ5KpY6FfEZE7qTTRdjWBGTGurm5ia2tLayurmJra+uJG3gis+rq6kJvby8uX75MvYBlMhnK5TKcTie8Xi9WV1exubmJWCx2uk6CZBZG/PLIovEsur5MJoNAIIDNzU3I5XKcP3/+iK/62aHT6dDe3k4z+La2trC8vEwL4HH16b8KCwsL4PP5OH/+PFQqFU16FgqF1FCaLAbk2SSTSfh8Pty7dw/3799HIpGgUTz7adwk1NVgMEAqlSKbzWJlZQU3b97E2toaNjY2Tk0LlBg38Pl89Pf349KlSzCbzdQOz+VyYXFxEZFIpCEJJ319fRgZGUFHRwdYLBa2t7exvLyMYrGI9vZ2es12ux0MBgPFYhFutxt37txBMBg89MJI7ApJfqLf7wePx6M6r6MIei0Wi4hGo/B4PDTKamRkBAKBgHYvdnZ2IJPJYDQaqRHHwsIC3nvvPUQiESSTycfukZDNiAcs2agSpnkjN877odVqMTY2BrvdDrlcDgaDgXK5jPX1dXz00UdU9kBMSUZGRvD6669DqVRSgTxxPzou830yJ94vXdiPer2OSqWCxcVFzMzMYH5+Hl6v94lrHuFC9Pb24vnnn8fzzz9P1002m03ZswsLC1hZWTny/METKYIk5JS8bNvb2zR257CnAiKDIKbbzQTSQurr64PJZIJEIqHuJIFAoCEnQILNzU3K/iO2X+SEzmQyaduBSFcKhQLW19exs7NDM8CIFyWDwaDssK6uLqphIpmQpOhPTU0hEAggGo02tWXXfnA4HKhUKuh0OgwMDNDEduJ3Shiuh9G0HQU6OjqoPytx5+dwOLBYLNDpdLDZbOjs7ASXy0UgEIDX68Xs7Cy2traeaSNCNq+VSoV6th41CoUCvF4vFhcXAYCSYxgMBiWvbG5uwmAwUL0tl8tFJBKB0+n8ShcpkmZC5B9k1t6o95LYiZHiTvI8iSMRcXHK5XLw+XxYWlpCMBiEQCCgvr99fX3o7++HQCBAJBKhEWyBQODYyD4CgQBqtZpqux9tg1erVRQKBRqHR2wuyUabMPvZbDZUKhUNWB8dHUVvby9EIhFd3+PxOJaWlrC4uIj19XXq3XtUOPYiyOFwcPHiRbz66quwWq1gMBj47//+b3z00UfI5XKHckUneVUDAwN47bXXcPnyZQC/JWk00lSbyCCkUin+/M//HGazGQwGgxqAH1d74utiYWEB6+vrWF9fx+3btzEwMEB9/AhzjSQTENd2l8tFT+/kcxWLxZDJZLBarfjGN75Bny9ZVFwuF/7pn/4JKysrWFlZOVUzQD6fD71ej1deeQUvvvgirFYrOjs7Ua1W4fV68cknn+DevXtIJpMNe8+ICwybzUatVkNPTw9++MMfYmBgACqVCtVqFTMzM1R8fePGDUQikVPxHFKpFD777DM8ePAAzz33HK5cuYK3334bHR0dUKvVmJiYwMjICLRaLfR6PZU7EENqIvR/9J0lHQ9i39jW1oZCoYDJyUl4PJ5jNdn4Mss6YntGEkzEYjFluBJ9Y7lchtvtpjmQMpmMznuHhoZomz6fz2NjYwMffvgh7ty5Q9vUxwHCxSCWgY+2kokpxtzcHB48eEDn0kQvee7cOdjtduh0Osq2Ju80Ce4mBMK7d+/iF7/4BXWXOmocaxEkGjOpVEqtz5xOJ8LhMLLZ7KF20KR/bLfbYbVa0d7eTlt5xEKrkfmD5EETO7JSqYRIJIK1tTW4XK4j38UcBtVqFaFQiEpJ9r/MwMNFKJ1OU9cGYuBLFhMulwur1Uoz0Ox2O53JkgijpaUlOBwORKPRht/v1wUhgpB5DElmV6lUSKVSCIVCtB1DdrWNwtbWFjQaDUwmE/R6PTQaDZ3dJhIJBINB3Lhxg85kTkMWHUG9XqcWfg6HgwYWEzcSqVRKHakkEgktaBMTExAKhdjZ2cHOzg4WFxepJR+DwYBMJsP4+DjGx8dhsVgglUpRLpfhcrkoi/a4QFivj3p5tre348qVKxAIBJDL5ZDJZOju7qYbHKLtzGaz6O7uxjvvvAM2m42+vj5KTlIoFGAymZicnMTs7CzW1taoo89xIZvNwu/3H+hs7W+JcjgciEQiGAwG9PT0UF3jxYsXqezDZDLRNA02m01NxEmoODFZmZ2dpXmSx4ETKYISiQRqtRrVahVOpxOhUOhQD4jMaTgcDux2OywWC9RqNU363l8EG3XaYjKZVIMkFAppFhZZPJsht43YR0UiETgcDgAH/Rp/lxE1l8tFX18f3njjDVy6dAl8Pp/OVMju7/79+3A4HKem/Qn8dnY9NjaG8+fPY2hoCFarFW1tbdje3obL5cLq6mpTPMetrS3q9kKKA5vNpp6si4uL+Pjjj+F2u2no8WkB2dCWy2W6eTQYDKhWqxCJRNShZL8ujcFg4OLFixgdHcXy8jJWVlYomYu4rxiNRhpg29HRAZFIhGAwCKfTecA0/TiQzWbh8XgeK4IkaIDJZEIkEkEul1MdI9mUErJQd3c3hoeHqTsTn8+n0hEGg4HJyUnMzc3B4XAgFAod6zMnmu1gMIjd3d0nFkGxWEzJLiSV5ZVXXoHNZqOJ8/sNtIlTEXGTmp+fx8LCAnZ2dpBKpY7tXo61CAqFQho5QwyvPR7PU0sXCJ1fIBBQ1tDExAR6e3shl8up9ZfH46FWSI1KliCD9u7ubuoosrm5iaWlJYTD4YZc05NAitvTnA6Iw4bVasXExASMRiN1GwFAvVLX1tbgdDobalR8GCgUCmg0GgwPD6O/v59a8iWTSczNzWFqagqLi4sIBAINP1W5XC7UajXEYjE4HA60tbXRU2AoFILP56NOLo+yD08TyOx/cXGRmjpsb2+jq6uLamuJ3SKZren1ejAYDGrBVi6Xsbe3B7VaDbvdDqVSSU8cLpcL0Wj02E/KpVIJiUQCGxsbWFxchEqlom5RarUaQ0NDUKlUbD1goAAAIABJREFUEAqF6OzsPFBQCEOZz+fTwkfMN8gJ0+v1Ymlpia6vxz3nLJVK2N3dRSQSgcfjQUdHB0ZGRuivE7LcmTNnKMOzVCphYGCABo8TFj9h0wcCAWxvb+PmzZv0no67AALHXARFIhEtgCqVCsFgEB6P56n7uuQEKBaLYbfbcfXqVVy6dIlmE1arVezs7MDlcsHhcFALnkaAxWJBpVLRIphOp+mLf1KxJscBImAlWYgkNZoI6/f29ugmZ319HW63+9QtvEqlEna7nQp0yb3F43HMzMzg5s2b2NzcbAqnG0J8WFpaglgsBp/Pp6LkbDZLrdFOixzlq1Cv17G0tERTY9bW1nDlyhV0dXVBr9dDJpNRMhqLxYJWq4VMJqMyCFIQSMuRy+XS4NrNzU3E4/Fjd/shBdzhcECpVNJZPI/Hg0KhoDaLxAVovysUh8NBb28vlS3tN7lIp9NYXFzErVu3sLi4iHg8jmKxeOzPnbCEw+Ew3G43tFrtgSJIiHbj4+Ow2+2Uq0G8a/cTacrlMgqFAjweDyYnJ/Hhhx8iEAhQ04Pj7mIcezuUyCK4XC6MRiOef/55TE5OUoPm37VbUSqVuHr1KoaGhtDf3w+TyQSTyQSlUkkpzx6PBz/60Y/g9/tp8GsjQL54Z8+exRtvvAG/30/bZ4FA4NQuSGTOefnyZVy6dAkjIyOw2Ww0KYLY4/3oRz+C0+mk2sHTAA6Hg+7ubhopdPnyZQwODgIANjY2sLW1hcnJSfzsZz87USu+34VsNktTVJhMJl0Yf99S2AmSySSVRc3MzOCLL76gxu06nQ4mkwnDw8NQqVTUQFuv19M1IpPJIB6PY25uDul0mkpcTkq2Q0zlP/74Yzx48ABGo5Hq+773ve9BIBB8afwY8dF0u91wu90IBAJYXl5GIpFALBajszkiCzmJ5090xV6vF59//jlisRgmJiYgEAiolIWYuu8H8QYlEXSrq6v44IMP6JgsGo0eOlnmsDjWIkio1KTYSSQSDA0NIZlM0i8xma3sf3Dk5Mdms6HX66l57MDAAHWsKBQK1BtwdXUV8/PzdI7QKBCzW41GA61Wiy+++IJqdU5ba3A/CLmJzFRMJhOdRRAneI/Hg+npaUowOC33KhAIYDAYMDY2hqGhIXoCJPc0MzODhYUF+Hy+hrdAnwQitj5Ns9fDgvhGEu9IcvrTaDTUhk+j0dCoJKlUSv0pM5kMgsEgVldXkUwm4Xa7sbq6+jstvI4a4XAYsViMWs2VSiUMDw/TNicAymAl4weSgBEIBDA/P4+trS1MT09TX2bSamwE8vk8AoEAuFwuVlZWoFQqD/iXcjgcMBgM+o4SXW2lUqH8gVu3bmFjY6MhphPAMRfBcrlMqa75fJ5qQQQCAXp7e7G9vY2NjY3HFk0Gg0E1KAaDgbbeiMchkRw4nU4sLCxgaWnpgO6nUVCpVHRWAYDqWgiV/rQUhkchlUqh0+nQ2dlJzbQJiCHzzMwMCoVCw5/B04C0ri0WC86ePQuTyQSBQIBCoYBoNAqHw4G7d+9ie3u7KQvgHzrIM0mn03C73SgWi9Twm8wK95NsSPEkiReNIDeRayas1bm5Ofz7v//7gXw8m80Gu90OvV5P8zorlQq2t7cxOTlJY+n26x0bBaIr9nq9+PGPfwyDwUD1myRvlMlkIpvNIpfL4ebNm4jFYtjd3aUBwKR716h140SKIDnxkXmSwWDAyMgI5ufn6QPev8gwmUyYTCYYjUaaxE7sx0ia+87ODubn5/Gb3/wGCwsLDT0BEpBWDMn5Wl5exvr6OlKp1KkpDE+CUqlEV1cXOjs7aUYZOYFkMhm43W7MzMwcqwHxcaCtrY1S78+cOUO1kiRg2OFw4P79+03xbrXwZJCUGZLpeBpQr9fpwSCZTGJ9ff0A0/XFF1+kZB6y7mWzWbjdbty/f//EfWq/CqTdnMvl8JOf/AT9/f2w2Wz0h7jykKzADz/8EB6PB9FotGlGJoyvWrQYDMYzrWjEL5QMsEdHR/Gnf/qnVPRKhtYAHnN+IYbNJKCRJNRfv36dmuOSPLTjjEB5Grz66qvU9WB0dBTf/va34XK5GirefxbI5XJoNBr83d/9HZ577jnaimYwGHA4HLhx4wbu3r2LlZUVrK+vN8287OtCpVLhT/7kT3Dt2jW8+uqrAB623P76r/8aN27coNl5LbRwkiApEEQTTbSCpHA281pCyEnkhzjhECZ6Pp8/EKp+Utjb2/tSW7FjPQkS9xBiZMtkMvHpp5/SnCuSSkwYW2Q3VK/XaWQGiVCKRCLwer2Ynp7G+vo6zQlrxllbvV6nusXTPKshTDSxWAy5XE6zAfP5PHZ2duBwOKgm6bQVQOChM4zRaIRCoUBbWxtSqRSi0Sh2dnYQCoVOjc9pC79faDS34VlAZn+NmlEeBifiHZrL5VCpVJDP51EoFKDT6WjP+IUXXqADVAA0MyydTiMQCCAUCmFqagqbm5vU2SEWi1EXk9as5vhAWp6kGBJGGJnBEDeS01gAie9pd3c3NSlOJpM0Guo0Oay00EILh8eJFEESnUSKYCAQwM7ODjo6OsDn85FOp6lnHDkJBgIBGnsyPT0Np9MJn8/XkKP010UqlUIgEIBAIACAU7UbehLIxmV9ff1A4G8sFsPS0hK2t7ePXch6HCARVxKJBAaDgSauE+o50Y210EILv/848VBdIhotFotIJBJIp9O4desWbYcCB9Pks9kswuEwjQRp1gIIANvb20in03A6nZDL5Q0J9T1KkGf1/vvv48GDB/T/FwoFbG9vIxKJNPDqDg8OhwOhUEhTIoCHOrStrS3MzMycysLeQgstHA7HSoxpoYVmBEngttls+Ju/+RuEw2GEw2FMT0/j/v37TWVv10ILLTw7GkaMaaGFZkS1WkWpVEI0GsWtW7fg9/vh9XqpI34LLbTwh4NWEWzhDw71ep22eufm5pBIJGh8VGsW2EILf1hotUNb+IME0bAKhUJK3CI/LbTQwu8Xvqod2iqCLbTQQgst/F7jq4og8yQvpIUWWmihhRaaCa0i2EILLbTQwh8sWkWwhRZaaKGFP1i0imALLbTQQgt/sGhJJFpooYUngslkQiQSQSaTobu7GzKZjCYcqFQqpNNpOBwOuFwu6vDUQguPgsfjob+/H3a7HclkEpFIBH6/n9oTNtoFrFUEW2ihhcdAUtvFYjG6urpw5coVGAwGiMVi6rbj9Xrx3nvvIZPJIBqNtopgC08Ej8fD6Ogo3n77bWxtbcHhcKBWqyGbzdKIpUaiVQRbaKGFAxAKhVAqlVCpVDCbzbBarTh37hzUajWNO2MymTQ2p9k9fVtoLEg0XjQaRV9fH8RiMbhcLhQKBVwuFzweT0Ovr1UEW2ihBQoGgwGpVIre3l7YbDbY7XbY7XZYrVZwOBzqrEOs5uLxOI1Ka6GFJ6FSqcDn82Fubg4XL16EXq9He3s7tFot9vb2sL293dBM2FYRbKGFFgA8bIHyeDycOXOGznB6e3thMpnAZrORyWRoDFo0GoXX64XP50Mulzu1IbAtHC/2dw1KpRINsC4UCggGgzR2rpFoFcEWWtgHBoMBiUQCJpOJQqHwB5EuT4ofyVf853/+Z4hEInA4HBQKBcRiMfz85z/HysoKFhcXsby83JTzPzLHJP/k8/loa2ujv14ul5HL5VCtVht68ngSyDWz2WwwmUxq4Ver1ZruWp8GUqkUGo0GZ86cwYsvvggOh4NAIID5+Xk8ePAAOzs7Db+/VhFsoYX/D8J8fOuttyASiTA1NYWFhQXU6/Xf65mXTCaDVqtFf38/BgYGIBKJUC6Xacbi/Pw8vvjiCwSDQYTD4aY99UmlUkgkEvrP8+fPQyaToa2tDZVKBR6PB7dv34bf70ehUGj05VKw2WyIRCJIpVKYzWYIBAKEQiFEo1Habj5tYDAYaGtrw/DwMOx2O86ePYu+vj4kEgm4XC4sLS1hcXER0Wi00ZfaKoIttEBAwnbffPNNqNVqFAoFrKysNAWN+zghlUrR3d2NS5cu4eLFixCJRAiFQgiHw5ifn8f777+P+/fvo1KpYG9vr+E79y+DVCqFTqeDXq9HR0cH/uzP/gx6vZ6eaCcnJ+H1ehGLxZquCEokEuj1epw7dw4qlQrLy8tYX19HoVA4lUWQyWSCxWJhZGQEly9fhs1mg9Vqxfz8PFwuFxYWFrC8vNwUs+RWEWzhyEBOUnw+HwKBACqViv47g/HQv3Z7exu7u7soFAr0p1lQrVZRLpchEAggl8uhVCqhVCqRyWSwu7vb6Ms7cqhUKqhUKly7dg0WiwU2mw0KhQJTU1NwuVzY3NzEysoKfD4fyuVyw4sfj8eDXC6HQqHA6OgoEokEIpEIAEAsFmN4eBgdHR1QKBSQy+Vob2+HSCRCW1sbWCwWuru7ce3aNZjNZmxtbcHtdiMSiTS8yLBYLEgkEmg0GnR2dsJut6O9vR3t7e3gcrlgMpmnLuiZMIytVissFgtkMhlqtRqWlpawtraGWCyGcrncFJvLVhF8AthsNoRCIYRCIbhcLgQCAdra2sDlciEUCsFisZDP58HhcMBms1GpVFAsFsFisWjrheyaCfb29lCpVOjsZW9vD6VSCfF4HNlsFul0+lQFupJTE4/Ho7MMq9VKC4dKpUJvby9kMhlkMhktgtPT01QoG4vFcPv2beRyOZRKpYZ/IcrlMmq1GthsNuRyObq6umCz2eDxeH5viiCXy4VYLIZMJsPZs2dx9uxZvPPOOxAIBIjFYvB6vfjXf/1XOJ1OuFwuZDKZhhc/4GGh0Gg0OH/+PMbHx/GDH/wA29vb2NjYAIPBQHt7O4aGhqBUKpHP51EoFGgrlMFggMvlYmBgAEajEblcDqurq7hz5w7m5+cxOTmJfD6PXC7XkHtls9n0FNvV1YWrV6+CyWRiaWkJSqUSYrEYH3zwwYlf12HA5/PB5/Nhs9kwNjaGF154Ab29vfD5fJiamsJPf/pTOJ1OxGIx1Gq1Rl8ugFYRfCJ4PB46Ojqg1+uhVCrR2dkJDocDpVIJnU4HkUiEcDgMkUgEkUiEbDaLeDwOPp8PHo+HTCaDTCZz4O+sVCrIZDLQaDQwGo2o1+vIZDKYm5vD9vY21tfXkclkGl4Ivi6EQiE6OzvR3t5OT3uvvfYa1Go1ZDIZhEIhJBIJuFwuOBwOLYJisZierJLJJE10TyaTDSeh1Ot17O3t0UxBciJshrnFUYDBYEAsFqO7uxu9vb24cOECLly4AIFAgGg0iunpaczOzmJmZgapVAqFQqEpCiDwsHjL5XKYzWYMDg5CJBLBZDJBoVAAAN1cMhgMpFIp+Hw+9PX1QSKR0EJIfl9bWxssFgsEAgHMZjPC4TACgQBKpVJD2nPknSuVSiiVSiiXy7SjolarodPpTvyaDgtyoh0YGMDFixfR3t6OUqmEzc1N3L17F1tbW4jH4yiVSo2+VIqmL4IsFgtcLpf+NyEpHOeHyOVyoVQqYTKZYDKZ0N/fDx6Ph/b2dnR1dUEikcDv90MikUAikWB3dxeRSARCoRB8Pp+e6vYvIJVKBel0Gh0dHbBYLKjVakin0zTYNZVKYWNj49ju6Vmwn23H4/HA5XJhMBhgNpuh0+kgEAggEolw9epVyOVyiEQisNls1Ot1uvgQqFQq1Ot15PN5ZDIZ/OY3v4FUKkUgEEAikUAmk2loi3S/gwWHw6EsydMOBoMBPp8Pg8GAgYEBjIyMYGBgAGazGdFoFGtra5iensbdu3fhdrubpviRVqbRaITVaoXVakVPTw99D6VSKRXrF4tFpNNpuFwuOBwOcLlcaDQa+r1ksVhgs9lgs9l0U6tQKPDee+8hm80iFAo15B6r1SpyuRwSiQTC4TBSqRQUCgX4fD46OjpgNBrBZDKbeh4LPFyrVSoVrFYr7HY7BgYG6HrodrsxNTWFUCjUVCMQoMmLINm5dnV1AXhYAMvlMorFIgKBwLGlgDOZTHC5XIhEInR2dsJms9FixefzwWQyIZfLweFwwGQy6Y6NzWbTlqhQKKQvLIPBQK1Wg1qthlgspr+H3Fs+n8fq6upjBaNZQFpoJpMJ3d3d0Gq1GBwchFwuh0QiAZvNpg4QZKe9t7eHYrEIJpN54L7IqZBsbN566y34fD4EAgE4nU7Mzc1hc3OzUbf6ewmyiVGr1bh69SqGhoYwMDAAHo+HZDKJjz76CA6HAw6HA36/v6kWWsKa/OY3v4mBgQH09/dDpVKBwWCgUCjQTVOhUIDf70cikcDy8jKWlpaQTqdhNpthNBrR2dkJqVQKqVQK4OFnQt5bFotFnXAagWKxiFAohHq9DqFQiKGhIQwPD0MsFsNsNiOXy4HP56NSqTQtMxcA3RyfOXMGVqsVCoUC6XQagUAAfr8f29vbTUGEeRRNUwSJqJLJfBhsQfQ+ZLgK/NZ+J5PJIBKJHFsRZDAY9ASqUqlgNBoPtFQA0CJXLpfBYDAOFD3SF99fBIGHpwwGg4G9vT0wmUwIhULo9XqUSiXI5XK0tbUd2z09C0QiEdrb2zE4OIhz587BZrPhwoULdHEFQO+L/JTLZaTTafoc97dD9+/GX3vtNYTDYTozCIVCTVMEyamwmYrCYUAISzqdDpcuXcLAwAAsFgt8Ph98Ph9+/etfY3V1FalUCtlsttGXS8FkMiEWi6HT6fDaa6/BbrdDJBLR7xqx4komk9jd3cXS0hL8fj/m5+exuLiIbDYLu92OfD5P38P9RZBsdkkhbBTK5TKi0Sh2d3fBZDJx6dIl9PT0QKvVwmg0olKpQCgUUmeeZnwfmUwmBAIBDAYDxsbG0NPTA7lcjp2dHfqe+f3+plzfGl4EyUI6ODiIV155BYODgxAKhdBqtdBoNHTeBPx2UarX67h06RJcLtexXFMkEsFnn32GyclJ/M///A8uXLgAk8kEs9kMk8kEoVCI2dlZzM/PY3Z2ls6zvs6gt6+vDxaLBZcuXcILL7wAg8EAgUCApaUlDAwMIBQKIRAIHMt9PS3kcjm0Wi1+9KMf4cqVK+DxeODxeGCxWCiXy4jH48hkMrQdtbe3B5/PB6fTiY2NDXz66afgcrng8Xi0CP7whz/EmTNnoNVq0d7ejmKxCJ/Ph5mZGczOzlK2X6ORz+exubmJmzdvnlpSjEajgVKpxEsvvYRr166ht7cXOp0OiUQC09PTeO+99/DLX/4SHo8HlUqlaebRpLsiFovxwgsv4Nq1axgeHqatz2w2C6/Xi+vXr+NXv/oVtra2kM/nkc/nUavVUK1WUalUcPv2bSwvL2NychI2mw1vvPEGvvOd71BBOvBwhvX9738fv/jFL+B2uxs6ly6VSlhdXcXc3ByVSnA4HCgUCnzzm9/E0tISlpeXGz473w+yfiuVSnz/+9/HlStXcPbsWXC5XJTLZfz0pz/FF198Aa/X21QbrP1oaBFkMBhU1zM2NoaRkRHYbDbKyNzfxydMTLIL2u8EcdQgJxniLLGysoJ4PA6/34/NzU3weDw4nU44nU54PB5qG/V1FhGRSAQej4d4PE7/DCkizXLqICcHo9GIwcFB9PT0QK1WA3j42UQiEczPzyMUCiGZTB4ogrFYDH6/n7Y4ybMjP21tbRAIBPRZLiwsYGlpCQsLC3A6nU3DkCVzZ8JcPU1gMBjgcDh0LnPu3Dn09vZCoVAgFAphbW0Nq6urWFpaQigUarr7Y7PZUCqV6OjoQHd3N7q7u7G3t4dwOAy/30//OT8/D4/Hg0gkglKp9NgmlJDRQqEQuFwuwuEwCoUCPRUCoAu4QCCg/6+RqNVqj21IWCxWU13jfjAYDKpzPH/+PEwmEwQCAZLJJNxuN9bX1+H1epFKpb50feTxeJRvQDbZj4J8LqVSCdlsFvl8/sjuoaFFkMlkwmw24/LlyxgdHYXdboderweDwUA+n8fu7i729vYgFoshlUoPEBROon9fr9dRKBTgdrsRDAbpQ2Iymchms8jlcshms08lpi4Wi0gmk8hms7THv18z1ww9cz6fD6lUCqvVisuXL6OjowNMJpNer9PpxHvvvQev14toNHqgCO6/H7KRKJVKEIlElOGnVCrB5/NRr9cxOTmJxcVFrKyswO/3H+nL/SwgjD0imzhNICSmsbExvP7669Dr9dBqtSiXy1hfX8ft27dx+/btpiQpAA83YRqNBn19feju7obBYECpVML29jbu37+PpaUlRKNR7OzsIBaLPbEAEhDnGw6Hg2g0inw+TzfXAOhYYj+DudnQ1tYGqVQKPp/fdNdIZqtSqRQTExOUFBeJRDA7O4uNjQ1Eo9GvnGWKRCKoVCooFAq6NjwKsiFNJpNHvk6ceBEk8zYejweVSoXx8XGcPXuW7iByuRyCwSASiQQSiQSYTCa6urqonVCxWPzKl/6oUa1Wj1TDR5wUyIyR7GxIUW2GXTnRyBEBtUQioU7wfr8f09PTdH5HToJfdoIlm4NarUYZimQjUalUsLa2ho2NDbpbbAaQU/lpiwkiTEqZTAa9Xo/h4WEMDQ1RwXU8HsfU1BTm5+exurqKcrncFJuuRyEQCKDX62G322EwGCCXyxGJRBCNRrG+vo4HDx5gd3eXfme+ai0grNFMJvOlM7VHyVvNBhaLBZ1OR+UezQSyjnd1daGzsxP5fB6JRAIejwcrKysIBoNfWrAIgdBsNqOrqwtarRZarRZCofCx3/toEfT5fPB6vVQT+iz14MSLoEQigU6nQ29vL9544w2888474HA48Pl8uHv3Lubm5vBv//ZvVHCu0Wjw3e9+F9/61rcgl8uxubmJjY2Nhrs8HBY6nQ6jo6Po7u6GSCRCKpVCOBymP82wKA0NDeHatWu0Pc1gMOD3+/HjH/8Y//Ef/0EXn6dp37LZbAgEArBYLOzt7dHT4traWlN5OZKNST6fp5ut01AEGQwG1Go1Ojs7MTo6imvXruHatWsQiUTw+XzY3t7GnTt38I//+I9NbcrMZrNhMBjw3HPP4Z133oFYLAaPx0M6nUYwGITT6YTD4Xjqv5ec7B8tgrVaDcFgELu7u0174hcIBHjxxRfhcrnw+eefN/pyDkCv1+PFF1/ExMQE6vU6HA4HNSC4efPmYzN+slHjcDhQq9U4c+YM3nrrLRqvpFQqHyuCxIeUHBxId+nv//7vMT8/j6WlpWdy1DnRIsjlcmE2m3Hu3DmMjY1hcHAQxWIRwWAQKysruHv3LhYWFg4sPkKhEB0dHRCJRCiVStja2sLNmzebpm32tODxeFRM3tbW1nRfPNIeIk4VLBYLu7u7iMViSKVStDg87fxSLpejt7cXUqkULBarKQsL+XLm83l6r81EGPkqcLlcWK1WXLx4EaOjo7BarajVakgmk1hfX8f9+/cxNzfX1AUQeLjgm0wmtLe3U7MFJpMJr9cLr9f7mAnF10WtVkMsFkMkEoFaraYtt1KpBIfDgXA43JTMxWYFIcQIhUKo1WpoNBrs7e1hd3cXfr8fsVjsiQQepVIJrVYLs9mM7u5u9PX1ob+/HyKRiG6KH+2Gkfa4SqWiCS8cDgfDw8PIZrPw+XxIJpOHlo+ceBHs7u7GlStX8MILL0AikSAcDmN7exuLi4uYnJzE8vLygcIgEAjQ2dkJoVCIUqkEl8uFGzdu/F4UQcKybBaQHRfp0RMNIGlFpdNp5PP5Q12zXC5HT08PLYLNuOCw2WzweDwUCgXqmNKM1/kkkCL40ksvYXR0lFLqk8kk1tbWcOPGDayvrzd1AQQezqP3F0Hg4XtJsgsPyzCsVquIRqOPzacII7NVBJ8OZBYoFoufWAQJWelRqFQq2Gw2TExMYGRkBEajERqNBuVyGWtra1hbW3vMtEAoFKK/v5+mbRD52sjICCKRCBYXF+H3+5uzCJL5l16vh9FohFarxZUrV2CxWMDj8ZBKpahVExl2kwJItGRarRYGgwFMJhOxWAzxeBzxeLzpTlBfF2KxGFqtFgqFgmZrERPfZligiAxlP9mFtDCIa8XXBZkB8vn8A4bAtVoNuVwO8XickoGa4bTV1tZGnUiIEUKzg3zHjEYjhoaGoNPpwOPxUK1WsbCwgJWVFUxPT8Pn8z12iiLylc7OTmpeUK/XkU6nkclkkE6nT7wwkMWVCNgJksnkM1nrEcbsfnkE8PCU0d/fj0Ag0FCt4GmDSqWiZt9kbptOpxEKheB2uxEOh5/4rPr7+zE4OAir1QqtVotqtYrbt2/D5XJhe3sb29vbj/EvuFwuPB4PZmdnKVeB6BD7+/vx0ksvQS6X48MPPzzUGnqsT52YTvf19eG5555DT08PxsbG6GkgGo3iwYMHuH37NnZ2dg7s8ohZNSmChUIBkUgE8Xgc6XS6KRbNw0AkEh0ogolEAqFQqCmMionQnWitSOuMtAkfNQz4XWAymRCJRFAoFLQIcjgc1Go1ZDIZxGIxerJs9L0Dv7XoI4Ww2UgIj4Kc3EmHZXh4GGq1GiwWC5lMBjMzM7h+/Tp8Ph9CodBj3RM+nw+ZTIaRkRF66qrVavB4PPD5fA05CZM226PvWTKZRCKRODRxbL8wfv/fzePxMDIyAofDATab/UzX/ocEtVqNoaEhDA4OwmAwQCqVIhgMIhgMwuVyfSm/wW63U9mVXC5HMBjEr3/9a3z++ee0hfroO0eeHYfDQVdXF77xjW9AKBTCYrGgv78fQqEQMpkMn3zyyaGyP4+1CHZ1dcFoNOLll1/Gm2++CR6PB7fbjc8++wzr6+twuVx48OABksnkgZebw+FgZGQE586dw4ULF5DNZnH9+nXcuHEDa2trp7IVSmzSuru7YbFYoNVqwWKxsLy8jJs3b8Lj8TS8EJBFlc/nQyQSUSq5UCiEVCo94OH6ZRAIBBCLxVAoFBgZGUFPTw96enqo0YBEIkEsFsOtW7fw6aefIhwOI5/PN8WmRiwW09Z7szMGgYdhuGfOnMGZM2dw7tw5DAwMYG9vD8vLy/j000/xX//mc3x8AAAgAElEQVT1X/B4PFTvShw99Ho93cX39/fDaDRS+RFpad27dw+3bt2iVmrJZPJE7kmn0+Gtt95CZ2cn9vb2kM/nkc1msb29jUAgcOh2KIvFglarPXDqBYBcLodPPvkE6+vrTcHMPi0gYx0y2iFyp42NjcfW87a2NshkMsjlcrz00kuwWq2QSCSIRqP4+OOP8bOf/QzBYPBrbbhSqRS4XC7S6TT+9m//Fp2dnVCr1ajX62CxWIciFh5rEeRwODSGqFqtIplMYmFhgQYqBgKBx/q/xFeys7MTIyMjMBgMiMfjcDqdWFhYQCqVanixOAzYbDYUCgX1D2Uymcjn89RTr5nuq1AoIJFIQK1WU32mSCSCRqOB2WxGIpFANps90F4iFlcSiQRyuRxqtRpnz56lYmeVSkWt4YrFIqLRKDweD4rFYlMUQOBh94HknhFSTLOCw+FALpfDYrHg/PnzsFgsYDKZiEQi9Lvi8/lQrVapwblcLsfQ0BCMRiM1hrfZbOBwOAcs/sxmM3Z3dxEMBpFOp2kr8rjvh8vlUtIEcYkqlUq0NUu0tYcBg8Ggouz9J/x6vU7zLZvl+1etVqkU7NG2cLOiUqnQdezRURUZi5B1QSaTgcVioVQqwe/3IxQKfe2OA6kjgUAAtVoNLBYLLBaLZpYe5rM61iJIhqRzc3OoVqvIZrO4f/8+gsEgIpHIE5leDAYDEokEnZ2dsFqtkMvllAKbSCSayjLoacDj8agehs1mI51Ow+/3w+1201ZVo7+EhEa+sbGBzz77DPl8HgKBADqdDkqlEhcuXACbzcb8/Dzm5uag0+mgUqlo7MvY2Bh1xCF/juwWiTyCnEq4XC5lejULSGhrIpGgKRfNCpVKBYPBAIvFgoGBAchkMpoEPzMzg+3tbbBYLCgUCpjNZvT09MBoNOLs2bM0/UQqlaJer8PlclGJCpvNxtjYGIRCIdrb26FQKL5WB+BZoVQqodfracQRaU2Wy2UavXUUGxOyUJLFUiAQ4NKlS9R4uxmQy+UQDoeh0WjAYrGoSL4ZiyHhEJTLZQQCgS8tgmTUQLgFh70XMts9SvecYy2C+30lQ6EQYrEYFhcXv5Km3dbWBoVCgc7OTvT29qJSqcDr9SIYDDaNmPow4PF4MBqN0Ov1YLPZiEajcLvd2N7ebqq8OrIoptNpCAQC2i6Ty+XUfkssFiOZTNJfI+3St99++4DbA4PBoKc8Mm8sFos0XaLZHDB4PB4UCgWSySRisVhTe4aq1WoYjUb09vair68P1WqV+k7Ozc0hEAiAz+dDpVJhYGAA58+fR39/P86fP496vY5qtUr9Njc3N+l3i8/n48yZMxAIBFAoFJDJZCcyK1MoFDQmibxDZHElpvlHrSUlp8OxsTHMzc01zUyQFMF4PA6pVEpPxc0KEhDu9/u/lK9Bgrcf3YQ8LcipTyQSUdN+QuQ7LI61CJZKJezt7SEajaJQKNDZz1cVQLlcjjfffBM9PT2o1WrY2trCnTt3msZU+rAgnpnETLpUKmF3d7cp5xCVSoU+r3w+j2q1SpmTMpkMY2Nj4HA4aG9vh1wup2SSR9l1tVqNiuKz2SwymQwWFhaom8Tm5mZT0dJlMhmMRiNSqRSCwWDTGv4CgNVqxeDgINRqNf2Ora2tweVy0cVzfHycsvcMBgP4fD7u37+PeDyOWCxGnZDcbjcqlQp4PB6USiX++I//GLlcDqFQCNFotCnf0aMAMW24f/8+dnZ2mkauRNIx4vE4nY02K2q1GkqlEorFIlwuFxKJxGMFqVar0U1WIBCg8VhPA2K2QYxWhoeHwWazkUqlEIlEsLm5eWgN7LEWwXK5jHK5/LUWE5lMBp1Oh4GBAfzFX/wFYrEY5ufncePGDfzqV786tZKI/d56Go2GPvxEIoHNzc2mMYwmaGtrQ2dnJywWC4xGI5U0kJdQIBDg8uXLuHz5MoDfnvDq9Tr8fj+dZZC5H5knxeNxRKNR3LlzB6FQCLlcrukITiS264MPPsDa2hoSiUSjL+kxEEP5l156CVeuXIFcLkc2m8X8/Dzu3buHfD6Pnp4eWK1WfPvb30Z/fz+i0SiCwSAWFhbwq1/9Cn6/n7qkkGBntVpNCQuFQgE+nw9zc3M0YukkQRayer2ObDb7TE5KxOCZbEDJPJCcHuLxON57772mIsZkMhkqnSJjkmYN1CXffWIvWSgUHjsJ1ut1Km377LPPkEwm0dfXBwAwmUwYHh5GJBKhLPF0Oo1yuUzZvGSU1NPTA5vNhvHxcYyMjMDn82F1dRXT09NYXFx8Kg/n/Wi4MIYcixUKBQYGBjA+Pg6xWIzV1VVqlkvmSKcRpKcvFotpll69Xkcmk0EwGGwq+zeyYAwODuLll19GX18fdDrdV0oFiKSCiF0TiQTS6TTi8ThWVlboQkvMxqPR6NeOnTppkDZNoVCgySDNBkJS6uzshE6nQ61WQzqdxs7ODgqFAqWf9/X1oaurC5VKBRsbG5icnMTa2hru3buHQqGAYrFI9Zl8Ph86nQ7j4+OYmJhAsVikqSlf5vxxEiALot/vP3SBImxnsVgMoVBIW3L1eh2VSoUa2jcTMeY0gbi3kHFPIBB4osyBYHl5mb7DOp0O/f39uHz5MlZWVpDJZOg4plqtQigUQi6XQ6FQYGJiAuPj47DZbFCr1ZBIJHjw4AGmp6cxOTmJzc3NQxPsvlYRFAgENBHgqEEqvV6vx8DAAAYGBpDJZLCzs4PFxUVsbW2d6peTw+FAKpVCpVLRPLRkMolIJPKlgtKTBomukkgkUCgUGB8fp5l/pPder9dpkSA6v/0mxoT0tL8ILi8v07YqMWtu9mdJvAmbNT2Cy+VCKpVSanoymUQqlUImk4FYLIbNZsPg4CD0ej0qlQoCgQBWV1cxMzODjY0N+P1++hz5fD4kEgnsdjvsdjuVtKytrcHtdlPyWjOzZH8XiMRHLpdDIpFQE4R8Po9YLEajmLLZbNOwlMnJ6jT41hLSC5/Px9DQEDgcDmX0EnvF/XA6nZQJnM/nIZPJcO7cOYhEImqGLpFIkEwmoVKp6M+5c+cwPDwMvV5Pk0FmZ2exuLiIzc1NBIPBQ9/D1yqC7e3tSCaTx9K6Iw4qZMbR3d2NtbU1bG5uwul0PpMxajOAy+VCqVRCo9FAJpMhm80iGAxiZ2cH4XC44acNJpNJZ2G9vb2wWq24cuUKOjo6aMQMOe0RIXO5XIbH44HD4cDW1hYikQhisRgNJSXt0EQigWq1ekB438Kzgc/nU8ZmvV6n1mhsNptqUPV6PbhcLhwOB1ZWVrCwsICtrS3EYjEAvyUpaDQa6HQ6fOc736FJ5hwOBx9//DEWFhaQTCYb6ubDYDAglUof0/Y9DcgogjBd+Xw+mEwmkskkVlZWMDs7i2Aw+MxJBEeJ/RKJZrmmLwPZUAmFQkxMTNAw3UAggFgs9hiZKRAIoFqtIpFIwOv14rnnnsPo6ChMJhMqlQpqtRqGhoawu7tLtYVisRgGgwEqlQr1eh2BQIAawu/s7DyzecrXKoLHlXPH4XBw4cIFvPzyyxgcHITJZEK1WsW//Mu/wOl0Ymtrq2n69IeFwWDAt771LVy9ehUmkwl+vx8PHjzA8vLyU+ljjhoMBgNMJhMjIyMYGRnBhQsXqO0Wg8GAz+ejhc/r9aJUKtETw97eHvx+P7744gtMTk5SO7tm/8L+LhA6PrENa/QG5UkgJ0HCZCTP0Waz0QxILpeLQCCA3/zmN/j0008pG9dms2FsbAxyuRxyuZzuso1GI3Z3dzE1NQWHw4H/+7//o6f8Rj5Tsri2t7cfirlJIpkmJiZw4cIFDAwMUJlOMBjE9PQ07ty5g3g8fgxXf3iEQiFMT09DIpFgZGSk0ZfzRORyOUQiEYRCIUQiEYjFYrz++uuw2+14/vnnEQ6HaX5jpVKhKTnZbBYMBgO5XA4+nw9OpxMjIyM4e/Ys3XCPj4+jVCrR8ONYLIaVlRU62yZm6nfv3kWxWHzmzfXXKoKRSOTId/FE79HT04OrV6/CaDSiUqnA6XTi1q1bdCd02qFWqzE+Po4rV66AwWBgfX0d4XD4mVzPjwLEc7Kvrw9jY2O4ePEijU1aWlqCw+FAuVwGi8XC/Pw88vk8eDwebDYb2traqLNILBb7nZlupwXlcpnqA5tdLA/81k5KLBZDqVRCoVBQ4+x4PA632w2Xy0VT2m02G9599110dHRAp9NRf16Hw4HNzU1cv34dN2/eRCKR+L04tZOsO4vFguHhYWi1Wjq/LhQK2N3dbUrZVSKRQCqVQk9PT9MylMncmLBYNRoNTCYTFAoFBgcHkc1msbu7Sz9rh8OB1dXVA/7QXC4XqVQKfr8fOp2OnvYlEgnNgSyXy4hEItRlzOPxIJPJIJPJHEkBBL5mETzKLwTZuRK3eIvFAqlUimw2C6fTifn5+VPl3v9VIGQYIh/Y29tDMpmEx+NBKBRqWJFnMplULD0xMUH993Z3d6mMYXZ2lv6+9vZ22rZmMpnU95M4eJz2AkjeSTIXJfq0ZpzHVCoV5HI5VKtVGnsF/Hb2RQKrNRoNXn75ZXR2dlL/Vo1GQ1ulZCYWi8Vw9+5drK+vY3NzE9ls9veiAAKARqOhYa9arRZisRj/j70ziY3suu7+v8ZX8zzPxXkmm90tsSe1ZFuKbFmOYSc2ECDZOPssA2QVZONVkoUXDpBFECALJ4gTGJ8guzVErVaLrR44z0VWFVkka57ngVX1LRr3muxmz2RVsfV+ANESq4p8j++9e+4553/OqVaryGazSCQS1FvpREgPzE69FkSMxePxUCqVEAgEcP36dUilUshkMtoqrdlsUi2AUqmk4hfgjw3rTSYTFQw2Gg3a7YhEI3Z2drCwsIBwOIxEIoFKpULL706CtkyWJyMxenp6aPF1KBTC/Pw87ty50zENlV8VlUpFZ/IRiXMqlaJdYtoliuHxeDTXcvnyZZhMJipjDgaDmJ2dxTfffAOxWAyr1YoPPvgAfX19sFgsNJRBxAQvK0vuJMiUDIlEApVKRafed+I9eJwRJE0HSPhIJBLBbDbjgw8+wDvvvENzgEKhEEKhELlcjnZIWVxcxI0bN2ioqhNDwC+LyWSiRtBgMIDP59PayHg8TkN5LC8OKYcgm3q73Q6VSgWLxQKr1QqFQgGZTAahUIhGowGZTEbTXQSy+SSqXdKx6u7du7h79y5Ns5DB40Rc9zJNsp9Gy40gGatjt9sxNDREZwp6PB6srq6eiZlnz0t3dzccDgdkMhlqtRp1/YkX1U5vl0ibSU/PQqGAcrlMB1j29/dDIpHAZDLB5XLBarVCLBajUqkgFAphc3MTyWTytfEEyeRqMvC3U+9BIulfW1uDRCKBVCqFVCqlU1cON0EnfV/JRiWTyWBnZ4eGsTY2NrC+vg6fz9exYTcip5fL5RCLxajVas/93MjlciiVSkilUohEIgAPNxHFYhGFQgGFQuG1SLm0AyJ4I3XghUIB09PTMJlMMJlMUKvVUCqVMJvNR7pISaVSauyI+pU0ZCDXdm5uDvPz80in08hkMtTzOy1aagT5fD66u7tx/fp1XLp0Cb29vUgmk/j444+p3HVvb6+Vh3QqEBXln//5n+PcuXOw2WzIZDL4+uuvcfv27Y4ojSBhCgB0TBIRIQwMDAD4Y2E2KWwPBAJIpVL4v//7P/zud79DPp8/84vI4V6ExMvt5FA88WR+9atf0UbYLpcLOp0Obreb7r4BwOfzIRAIoFAo0JDV73//exr27nQ4HA7UajXEYjH6+/uRzWYRjUaf2cybeBg2mw0WiwUymYwWdRMV897eXkfV6J5VSE/ofD6PX//613TtI63NLl26BKvVSt/vdrtpnTTpRrW3t4dIJEJDnB6Pp6WNKlpqBKVSKXp6ejA8PIyhoSFwuVxsbGxgbm4OGxsbHdc95WXgcDh0h+5yuWA2myGRSJDNZmkSud2eEwmHOhwO2qWezHDjcrlUPEDyYmScjt/vp2ILcgOfdXg8HhQKBZ3DR3IOnQ5ptEDqAMlsQLKhAUB30rVaDbVajRrQsxLyJDVoIpEIcrkcMpnsuaZZCAQCMAyDwcFB9Pf3Q61W07FMHo8Ht2/fxsLCQsepQl8HSDkVaYixvLyMnZ0d+vrq6irtNUpCm7lc7oi4rtWdpFpqBGUyGW1909vbC7/fj/X1dczPz2N/f7+Vh3JqENGPSqWCw+GgneCJCCGVSrXdCJKxR0aj8YhHSCDNlYlCl0won5+fx+Li4pnPAR6G/C0sFgv4fP5js9A6FSI5f10gntqj9xYZlaNWq6FSqRCLxWjj5CchEomgVCrpOiMWi2lNpcfjwZ07d7C1tdVxbfse5SSaQ7caon0gIcz19fV2H9IzaYkRJB0CnE4nRkZGwOfzsb29jQcPHmBpaalj8xEvCyk/EAgEVKzQSZBOIgsLC/h//+//PdbMNp1OI51OU0O4sbFBRQSdmit7Wcj8SqKsbGdx+LcZMjkhFouhWq3SHC3h/PnzNFJRLpePFbQQ0d3Y2BimpqZgt9vBMAy4XC6q1SpCoRC2t7eRTqfPRCF6JpOB1+ulI8lYTodTN4IcDgc6nQ5ms5nK8dfX17GysoL79+/jzp07r0VYjUBGQbndbpoQLpfLJ17b8irUajX4/X4EAgEEAgGaQyLkcjnk83nqCb7ORoHkBOVyOcrlMra3t1+7TdlZIB6Po1KpQKFQIBAIQKvVQq1W09ffffdd9Pf30+bgv/nNb1AsFungWalUiq6uLpjNZvzwhz/Ehx9+CKPRiEKhQO/zO3fu4KuvvkIwGDzxsUynQSqVopEXo9GIQCDQ8bWrZ5GWGEGSfzIYDMhkMpidncUXX3xxpHDydYHH40Gr1aK7uxsCgQC1Wo1K0pPJ5LFd1tsBUUCGQqHHPNXDrc464VhPGxJ2SqVSVOnG0lpI02XSUpCEQAkMw8BsNuPNN9+EwWDAF198gXg8joODA4jFYhiNRrz11lsYHBzE8PAw7XmbzWaxtraGBw8eYG5u7pWacbca0uQ7lUphfn4e6+vrZ+bYzxItCYeSMEahUIDX68XGxgY8Hk/H1mK9ClwuFzKZjAotiByYy+VCq9VCq9W2tV3aYZrN5rd+wSe5olgshlwuh3Q6fSa8hNeNer2Oer2OaDSK+/fvIx6PP5bzJLPrnpTLI6KMUCiEg4MDCAQCBINBzMzMYH5+HltbW2dCFUsolUqIRqNoNBpYXFxELBbriHXjdePUjWCz2UQul6PCl0AggN3d3Y7tyPGqkLyESCSicmGGYWAwGHDp0iUsLy/j5s2bbMitQzg4OEA0GqWjhSqVyplRT76OJBIJfPTRR7TRxGEOKw/D4TBtel0qlRCJRHDz5k0sLi5CIpHQRtmHhwOfNfV5Op3G2toaxGIx4vE4isXiaxc56wRaZgTD4TByuRx4PB7C4fBrfTFJeI2ILEhJQl9fH5xO52M5OJb2QcKgzyO9Zzl9stkspqenX+gzpJzndbuGpKCf5XRpSTiUqA3JAN3XLQR6mHK5jPn5eYRCIXR1dcHtdkOtVqNYLOKrr77C9PR0x0uzWVhYWL4ttLRO8HU2fgRS/AkAN27cgE6no0OJNzc32bg+CwsLSwfBeZph4nA4r7/VOgVID0qtVktrBRuNBorFIu2Fx8LCwsLSGprNJudJr7FGkIWFhYXlteZpRrCzWpmwsLCwsLC0ENYIsrCwsLB8a2GNIAsLCwvLtxbWCLKwsLCwfGthjSALCwsLy7cW1giysLCwsHxraWmxPAtLKxEIBJBIJJDL5bR5uU6nQ7VaRbFYRLFYRCwWQyKRQDweb/fhsrCwtAHWCLK8tohEIuh0OjidTgwPD2NoaAgjIyPI5XKIRqOIRqNYWFjA0tISksnka9nQnYWF5el0rBEkXVeUSiVsNhudeUcGvp7VJtwMw4BhGIjFYkgkEsRiMXaixCmgUqkwPDwMu90Ot9uN4eFh+pXP56kRFIlEkMlkkMlkCAaDCIfDKJfL7T58llOEw+FALBZDoVBALpdDpVIhm80ik8mgWCwim822+xBZWkjHdowhC9PY2Bh++tOfgmEYNBoNbG5uYnNzE7///e/PZId1o9EIvV4Pm80Gu92OW7duYWNjo92H9doxOTmJv/zLv4TNZoPZbKbhUK1Wi2q1ilKpdCQcmkgk8Mknn+Djjz9GKBRq9+GznBIcDgc8Hg82mw3Dw8Po6+vD5OQklpeXsbKyAr/fj5WVlXYfJssJ87SOMR3pCXK5XLjdbgwNDeHKlSv4i7/4CwgEAlQqFczMzECr1eLmzZtnygjy+XzI5XK89957uHLlCmw2G7RaLdLpNJ1nxw5zPTkUCgWMRiNEIhHK5TL29/fpTEupVAqlUgmFQoGJiQn6GYlEgkajgd/97ndIJpPtOvS2wuFwIJPJwOPxwOPx6OQXAHRAdL1eR7FYPJPhY4vFAqfTicnJSVy7dg2jo6Ow2+2QSCRIp9NsbvhbSMcaQYPBgMHBQbjdbjAMQx9GoVBIB2aeJUhod2JiAu+++y5UKhWazSb0ej2USiWazSZrBE+QfD4Pr9cLAEcWcgDQ6/WwWCyw2WywWq30+waDARMTE/jyyy+/1UZQKpVCKBRCIBAcec6azSYqlQoqlQrK5fKZNIJ6vR7Dw8OYmJjAyMgIuru7USwWUalUUCgU2Ob230I6zggKBAJ0d3ejr68PAwMDsFgsdBGr1+tIpVLY3d1FrVZr85G+GFwuFyKRCDweD7VaDQcHB+Dz+eBwOPSL5eSIRqO4e/fusa+RPJDNZgOHw4HRaITBYIBcLofZbIZIJGrx0Z4OJP/M5/PB5/PRaDRQrVYhEokgFovB5/MhEAhgs9nAMAyAh5s1h8MBkUgEhmEeM4LJZBLJZBI3btw4UxsFPp8Ps9mMqakpnD9/Ht3d3WAYBrFYDN988w1mZmbg8/mQSCTafagsLabjjKBQKMTAwAD6+/sxMDAAk8lEX6vX60gmk9je3j5zRpDD4VCPtlgsQiwWQywWt/uwXlsikQju3Llz7Gs8Ho8u/mazGWNjY9Dr9ZBKpTSE+jpAxB9isRgikQi1Wg25XA4ajQZarZbeg5cuXYJSqQTw0Fj09/dT4dajRjAQCGB3dxfffPPNmTKCQqEQbrcbly9fxvj4OI3EhMNh/P73v4fH44HP56OzQFm+PXScEdTr9fj7v/97aDQaqNVqCAQC+lqz2US1WkWhUDhzoRgOhwMulwuxWAy5XI5qtYpwOAyfz4dwOHzmjHqnQ8J2T6NYLOL27dtQKpUYGxuD0WiEUqnE5OQk8vk84vH4mVropVIpFAoFuru7MTU1hampKYjFYgiFQgiFQprLk8vlR/J+ZO4l8MecIJfLfSwn2Gg0IBKJIJfL27KBEwgE9BzPnTuHYDCI3d1dZLNZVCqVY9XiPB4PYrEYBoMBQ0NDGB0dhdPpRL1eRywWQyAQwMcff4xCoYBCoXAmFefHwePxIJfL0dfXB6vVCq1WC41GAw6Hg0wmg5mZGczOznbU+QqFQkgkEjgcDropAwCz2YyLFy/CarVCrVYDeOgQ3bhxA6urq1hcXEQsFnvp39txRpBhGIyOjqLZbL5Wk+i5XC69yGKxGMlkEn6/H5FIpGNzgQKBAAzDQK1WUy/2SbnYZrOJXC6HcrmMcrlMQ76dTLVaRSgUQi6XQ7PZpOFDs9kMo9GIUql0powgwzBQqVRwuVy4cOECrl+/DqFQSI0d2UQyDAOhUIhGo4F6vU6fMxKWf3TjSQZCl8tlxGIxRKPRlm/aeDweZDIZLBYLrFYrzp8/D4lEgnw+j0qlQgU7jyIUCqFWq2E2m2EymSCXy8HhcFAoFBAOhxEIBBCPx1Gv18/UxppcUx6PR79Hwt5CoRBSqRQ6nQ6Tk5NwOBxUlV6v1xGJRBAKhTA3N9fy4yb3nkgkovcZ2aSJxWJIpVL09fVBpVLRz9jtdly/fh1OpxM6nQ7AQyOYz+dxcHAAv9//ehnB1xU+nw+1Wg21Wg2RSIRIJIKvv/6aKhY7EZI3e+edd2C1WmkO6bj8ZaPRwNzcHAKBALa3txGLxZBKpdpw1M9PtVpFMBikRpCg0+lgNptf6cFqB8QIarVaqFQqSCQS6s1xuVw0m01aItBsNmnXnHq9Tg0gn8+HVqs9koevVqvwer0IBoNYX1/H+vp6yzcHcrkcdrsdFy9exNjYGIaGhlCv17G7u4tMJoNKpYJqtfrY56RSKdxuN0ZHR9HT0wORSIRisYjt7W1MT0/jwYMHRzYCZwEejwepVAqZTHbEI1er1dBoNNDr9TCZTDCbzRgYGIBKpYJUKoVEIqE1kFKptC06BHJsDocDWq0WAGAymWAwGCASieim5XBKQqFQwGKxQCKR0O9xOByMjo5iZ2cHUqn0lY6p44zgcReGeIX1ev3M7dgIfD4fKpWKelWxWAx3795FJBJp96E9Blk0dTodBgcH8eMf/xgjIyNgGAYikejYa1Sv1/G73/0Os7Oz4HA41HtoNBp08SU/G/jjNW2nt1ir1RAOh5HP548sglqtFgaD4ZUfrlYjFArpPaZUKh8LWZLrQAxbJpNBMpnEwcEBveYMw1BvCXgYVi4Wi/B4PFhdXcXs7CwePHjQ8g2OQqGA0+nEG2+8gbfeegsmk4l6M/v7+0c8IgKHw4FcLkdXVxfGx8fR3d0NoVCITCaD7e1t3L17F3fu3Dlz6wlZS3Q6HQ0PAoDVaoXNZkN3dze6urrgcDhgt9vpBqjZbGJ/fx+5XO6Jz/FpwuVyYTabMTg4iImJCTidTgBAX18f3aA8D2RN6enpgcVieeXQfMcYwcMu/KMXp1gsIhKJwO/3w+PxwO/3n7kcGqkTlEqlHV/e4XK5aJ3m2NgYrFYrVRk+CQ6Hg56eHojFYjgcDtqPM5lMIpVK0dAqub6pVArJZBKffvopK0s/IQ5vFI/zbMrlMvx+P/b39xEKhRCNRp+NwtcAACAASURBVBGLxVCr1cDlcqkRHBwcpM9guVxGLpfD4uIidnd3sbu7i0Kh0HLPqb+/H0NDQ7Db7VTUUqlUkMvlUCgUjl0P7HY7BgYGMDo6itHRUZhMJiSTSWxubsLj8SASiaBYLLb0PF4FEv40mUy4fv06XC4XzGYzfV2pVNJIgEajgVKppLnOVCqFVCpFVbArKystywfyeDyq8fjxj3+Mrq4uWCwWasB1Ot1T15bDVKtVpFIpJBIJLC4u4s6dO69c29l2I0jk2uSGHR8fP/J6o9FAOBzGnTt3qJR5fX39zOzeeDweGIaBVquF0+mEwWCg4ahOQyQSwWg04s/+7M9w5coVdHd3w2azQaFQHHnfccdOwhMjIyP0PZVKBeFwGJFIBAzDQCKRwGq1gsPhIBwOY3d3FysrK4hEIk8UNrA8H2KxGE6nEyMjI+jv7z/iIRBSqRQ+++wz3L9/HzMzM0gkEkgmk/TvzuVyIRAI4Ha76UaNeILJZLItmxWBQACBQIA/+ZM/wYULF9DV1QWdTod8Po9Go0HzgYfXA/KZH/zgB7hw4QLeeOMNDA8PAwA++eQT/OEPf8DMzAy8Xu+ZaFkoFosxOTkJjUYDlUoFk8mEN954Aw6H44h6vlQqUUFYKBSC1+ulqYlwOIxwOIx79+4hEok89jc7TSQSCaampvDWW2/hF7/4BRQKBQ4ODlAoFBCPxxGLxVAul4948yRKVKvVkM/nEYlEUC6Xkc1mEQ6HEQwG8cUXXyAWiyGdTr/S8bXdCEqlUuj1egwODuLq1auYmJigrjv5Q6TTaezv78Pv9yOVSnWkAXkSQqEQCoUCOp0OWq32Mdl5JyGVSjE0NIRLly5hdHQUarX6hUMNh714oVAIg8EAhUJBd7Ek5KHX6yEQCGA0GlEul5FKpVgj+JKQsN/w8DCuXbuGkZERKiA4DOmcEw6HEYvFUCqVjiyEjUYDtVrtSJ6aiGfaFXkh4VmHwwGr1UpD1OReUigUkEqlR3KC5DMTExMYHR2FVqula0Ymk0EgEEAoFOpYQdqjyGQyfPjhh7DZbLDZbDg4OEAmk0E8Hj9S0hGLxZDJZJBOp5FIJBCNRrG5uYlcLkeFTclkErVaraVrKMMw6O/vx/vvvw+pVIp6vY5SqUQb2GcyGdjtdlqrCoC+p1gsYm9vDzMzM4jH40in07S7ViwWQ6VSeeV7s+1GkBQou1wu9Pf3o6en58jrmUwG6+vr8Hq9VA59lpBIJDCbzXA6ndDr9eBwOHTH1inerFgshlKphMvlwtjYGPr7+2EymY506jlMpVKhO/HD58Dn82nekM/n0wT+o7m1ZrMJiUQCDocDtVqNWCx25q5rp0DELHq9HgMDA+jr64PD4Tg2R0ZELw6Hg15Dch1rtRqKxSJdeEjepV2QBvoWiwUulws2mw0ajQYikQj1ep16ONVq9cixcjgcKBQKmM1mGsmQy+U4ODhAIpGA1+vF3t4eUqlUx4fhGYaBTCaD0+nE1NQUFbvs7Oxgbm7uMUUseY5IuDASiWB3d7ftaw0pw+np6QGHw0E0GsXOzg48Hg8WFhaQzWYRDAYhFArpZw4bwf39fdy/fx+JROJUPPe2GkGygzWbzTCbzVCr1Y8tmMFgEDdv3sTKygrC4TBKpdKZ8gTlcjl6enowPDwMo9FI8xjZbLZj8pparRZjY2MYHx/H+fPnYTAYnqgCBR5uTLa2tlCtVo8IW2QyGfR6PYxGI2Qy2VN/J1EjMgzzWHsulueDlDOIRCK6iVQqlY/V9xHUajXeeecdjI2NIZFI0H6qtVoNmUwGOzs7CAaDiEajNBTVjmeN5CalUilGR0dx7do1WK1WiMVi8Hg8lMtlfPbZZ1QUk8vl6LPE4XCg1WrR19cHvV4PmUwGoVCIcrmMpaUlKkYrl8sdH3lQKpXo7u7G2NgYuru7IRAIUK/Xsbe3h08++eQxL6hUKqFardIypWKxSDcJnUKhUMDm5iY+/fRTPHjwANFoFNVqFSsrK481Zjg4OMDBwQHy+fyphuPbZgQ5HA4kEgnGx8fxwQcfYHh4GGaz+bHwWzgcxq1btxCPx5HJZNp0tC+PXC6H2+1Gf38/9Ho9Njc3MTMzg7t373ZEDZpOp8P4+Dj+9E//FJcvX4Zer4dGoznynuXlZezt7dG8QiwWg9/vR7VaPbKQSKVSaLVaOiXje9/7HpVtH5bcZzIZbGxsYG1tDVtbW4jH423ZlQuFQjidTqhUqjPXts5iscBkMqGvrw+9vb0YHR3FhQsXaKH7ccjlcly8eJGGOEkLNJKficViiMVi8Pl88Pl88Hg8CIfDSKfTLROQcDgcKJVK9PX10RTJtWvXYDQa0Ww2kU6nsbe3h3//939HLBaji2Oz2YTBYIBOp8Nbb72Ft99+G3a7HUKhEIVCAaFQCNPT05ienkY6ne7oGladTgeDwYBz587RJt9kgs7Ozg6mp6fx5ZdftjSvd1L4/X7Mzs7i888/f2Jbw1bTViPIMAwcDgcmJiaOJOMPc3BwgHK53NE37dPgcrm0vo7H41FZ99bWVkck5UkhcVdXF9xu97Eqra2tLTx48ACrq6tYWlpCPp9HNpt9TIUoEAhoK67e3l709fWBy+VCrVZTI9NoNJDNZrG0tITPPvsMXq+3bbkZhmFgsViOlAScFUiD+WvXruHy5ctHOoI8C6IE1ev1NHdIcvC1Wg1erxfT09Pgcrmo1+vUq2gFpGNNd3c3zp8/D7fbTQ17qVRCOp1GKBSC3+9HqVTCwcEBvQe1Wi26urrQ19eH4eFhSCQS6kmQcVn5fL7jPUC1Wo2enh6MjY3h4sWL6Ovrw+rqKlZXVzE/P4/l5eVjayLPAoc3Lp1C28OhpD3TcTkMwlkKfx5GKBRCJpNReTCfz0cqlUIoFEIymeyIG3loaAi9vb30+A5vRFKpFCKRCO7fv4/5+Xns7u7SG5jsvg/TaDTA4/HoBAJSa0fqBpvNJubm5rC+vo65uTl4PJ62hoSFQuGxRpCICjp5VBfZgBBh2eHiZ9Ll5XkWe5JTJJ/l8XgwGAwYGRmBQCCA3W6H1+vF7du3EQ6HT/WcgIfRhMHBQQwMDNDewRKJBMVikW4gZ2dnqSr08D2oVCrp7Ei5XA7gj5qChYUF7OzsPPaZToLkM0dHR3Hp0iVMTExQNXmj0UA6nUYgEEA0Gm33ob40VqsVVqsVGo0GYrG4IzpLtV0Y8zpDVGpEGSoQCJBOp2mIqRNygiMjI+jr64NarX4sl5RIJLCysoJ79+5heXmZCiee1NKu0WjQPBVpcUWKchuNBg4ODvDgwQPcu3cPq6ur8Pl8bX0AhEIhzGbzY0YwHo8jFAp1tBEk+VjS1u7wJpL8rZ+V0yObULIRJd9Tq9UYHByEzWZDb28v1tbWaI/b00Ymk2F4eJiKfEhXlEQigd3dXdy7dw83b9489txI+YBarYZEIkGz2UQqlcLKygru3LnT9vvtWfB4PNrH9u2330ZXVxc9j2aziWw2i93d3TM989DlcmF7exs6nY5ubtp9TdoaDiU1gscN7yQ1TIFA4EwksY9DLpdDrVZDpVJBLBYjn88fybF0wjmZzWYYDAaIxeLHQmnpdBpbW1sIBAJIJBLPdbwCgYCOKjqcnyKS7sXFRSwvLyMYDLbNyBAxiclkwuDgIAwGw2NGMBKJdLwRJKo/LpeLRqOBXC6HfD6PTCZDFYJPW2BImN7pdEKpVEImk0EikdDOM3K5nOYOT3uyBlEV2+12mh7RaDS024nf78f6+jq2traws7NzJBdGUg4Oh4NqCxiGQbFYRDwex/b2NjweDzKZDBiGoarmTnj+gD8KgZRKJYaGhjA+Pg6n0wmNRkP7vRIvt7u7G/V6/UyNfDo4OEAsFsPGxgYGBwdp+7tKpYLNzU1sbGy09Vq0zQgKhUI4HA50d3c/tgDX63UsLCzg5s2bmJmZ6QgByctw8eJFnDt3Di6XC3w+Hx6PB3Nzc4hGox1To0T69TUaDZTLZTpctFar0Wuwv7//XDepVCqF3W7HyMgIxsfHIRQKaWhubW0NX375JW7cuIFAINCCM3syWq0Wbrcbly5dwk9/+lP6fVJ/tLGxAY/H08YjfDa5XA6RSATb29tYX19HtVrF1tYWPB4PFR2trKw8NffCMAzEYjF++MMfYnBwkIbGBwYGqIdICs9JI+7TKp0gC/zVq1fxs5/9DDweD1wuF+VyGYVCAR999BHm5+fh8/lQq9WOqI+VSiWMRiN++MMf4sMPP6Se0+rqKjweD3Z3d5FOp6HVamGxWJDJZOhXuVw+8XN5UZRKJXp6ejA6OooPPvgA77//PhWQkZZ2/f39EAqF6O/vx6effoqVlZV2H/ZzUygUcPPmTcRiMfzd3/0d3G43/uZv/gY/+9nP8F//9V/41a9+hVAo1LbIWNuMoEAggMPhgNvthkgkOvJgHS6W79T4/fPw9ttvY3JyEnq9/shU7k46p6WlJRoKIx1elpeXEY/HsbKygkAg8FzhCg6HA7fbjYmJCUxNTWFkZORIbqpQKCCRSHREHlQikdBBuochrfletQNFKygUCggGg5ienkY2m6UTMUKhECKRCOLx+DOv28HBAUqlEubm5pBKpahh6O/vp+8hdWpmsxkymezU7mHSINtsNtPIELl/iAqSYRiYTKbHyqjsdjuGh4fhdruPrBvEE+7p6YFarYbdbkej0cDW1ha8Xi98Pl9HGEGVSoXJyUlcv34d3d3dVMiTTqeRy+XA4/Fw7do1Gknq9Mb0j1Kr1RAMBlGtVjE7O4tSqQSHwwG5XI7z589jfHwcqVTq22cEhUIhbDYbnWJ9+KEiTbLParNswtWrVzE4OAg+n494PI5yuYxqtdpRRnB5eRkCgQAKhYJ6QTdu3KBTtp9XTs7hcNDd3Y3R0VFMTU2hp6eHqg0rlQoNh3aCKkwsFkOn0z3WVSUSiWBxcfFMGMFSqYRQKIRyuYz19XXUajWk02nk8/nnXkxIn1FSg5vNZlEqlfDzn/8cXC4XHA6Hevcmk4l6X6dxD8tkMjrCioTQD2+iuFzusY0XgIcNmK9evQqn03nkuLLZLG20TBpo53I5CIVClEqlluQ4CST/+mgD+WazCYVCgaGhIVy5cgVSqRSJRILWbMZiMTAMg6tXr9IylnaVihHvHPhjE+vncVTq9Totr5qdnaVjsWw2G8bGxjA2Nob79++3bU5sy43g4QJfoVD4WB6qVqthb28PPp8PGxsbHT1q6FmQ86tUKkilUggGg8/M07SanZ0dAA/DawqFAvv7+/B4PEgmkygUCs+96ychG4fDAYVCAT6fj2KxCL/fD5/Ph5mZGWxtbXXEzvtJRKNRzM/PnwkjCIAOySU5rlfJnZdKJezt7YFhGPh8Puh0Olp4T0Y0kYjGaSxWxWIRsVjsMdEHCalfvXoV6XT62HtRr9fDbrcfmYMIAL29vTAYDKjVatRTnp2dxeLiIrxeb0u6FJFwsk6ng81mg1qtRqPRQDKZRDqdpt7exsYGbt26BS6Xi2AwiJ2dHZRKJfB4PNokWyQSQa1WP7MRxWmg1WoxODgIp9OJWq2GaDSKRCJB89BkLNezuH//Ph1Y3dvbC7vdju7ubly+fBkbGxtt6QrWciNIJPRisfjYriQHBwfY39+Hz+fD2tpaR44ael7I+ZXLZaTTaWoEOyUhDzw0golEAj6fj46ZIX08H22L9jS4XC4GBgbgdDppr9BCoQCPx4Pbt29jaWkJXq+3o41gJBI5U0aw0WigUCgcUey+rIdWKpWwv7+ParUKv98P4GHYmOQDVSoVDAYDCoXCqXT3KRQKdGElI5/IhpnP5+Pq1atPnI5BBsk+agT7+vpQLBaRyWQQjUYxNzeHL7/8Eh6Pp2XqbIFAQL3pN954Ay6XC7VaDTs7O9je3sb29jYikQg2NjZo1MTn8yEQCEAkEsFms1GFtVgsprMBW41Wq8Xly5dx5coVFAoFrKyswO/3Y29vj1635zGCDx48QCgUQjAYRCQSwXe+8x309PTg8uXL4HK5SKfTr7cRFIlEGBkZwaVLl3Dx4kX09/fTBZNQKBTwhz/8AfPz8wiHw0caxJ4FSL9D0ubpcLE8qcfqpMJsEkbLZrN01tyLLKRisRg2mw1OpxMXLlygjbFjsRg+//xzfPbZZ/jkk0+Qy+U6puVdd3c3PvzwQ0xNTaFUKmFlZQXLy8u4efMmgsEg3nvvPdhstmM/G41GsbS0RA1Fq3A6nbBarQAehtJ4PB5tLP3osZZKJcTjcdy6dQsej+e5NzKkUTbp+3r4XiW9PE+rvd3u7i7tRJRKpSCTyWjIzGKxUPUoUa0eZwiIVxWNRmlz5kgkgkgkgnA4jGg0StXmrQq7vfnmm3jvvffA5XLh9XqRSCTQ1dWFgYEBaLVa3L59G7/85S8xNzdHJ70rlUpotVqMj4/j+vXrGB4ehs/nw/T0NG7duoXV1dWWHPthFAoFBgcH8c4776Ber+P69et0zBaZS7m8vIxkMol4PI58Pk+bXJNpEcRQ+v1+ej26urrw/e9/HxqNBgcHB1hfX2959K+lRlAgEMBsNqO/vx9jY2PHzpGqVqtYW1tDKBTqOBHJ88Dn86HRaOB2uyEQCFCpVGhX92Kx2JFiHzKH7kUgykHS3YJ062cYBrVaDYlEgnbGicViHeX9SiQSGAwGGAyGIypdo9FIhT1PM4IymQwMwxwZxlsul09Ftk7CkaT/LNkw8vl8SCQS2Gw2mM1mep8Vi0XqNTzvjDYAtN7QbrfTOjtSekEGJGez2VN7JongZnd3F3fv3qVGcH9/HxaLhTaeINdtdHSU5tjq9ToODg6wu7tL+6Hu7+9TJXYikUAqlaJ1rq1Eq9ViYGAAlUqFlhoRYZbD4cDAwAAGBweRz+dRLpfB5/Pphmd0dBRDQ0OwWq1YWFig6t9QKNTSczgMKedQqVQAHq7X5N6QyWRHOvOQzRgR+sRisSP3jsvloqU5PB4PKpXqSBPtVtFSIygUCqHT6WA0GmEymY4d01OpVLC0tIRMJtMRxeQvChkg6XQ6IRAIkM1m4fV6sbKyQsNNnWYEXwYyIsput+PcuXO4fv065HI5nUawv7+PmzdvIhwOd7S4iXRFkUgk6OrqwpUrV6gS8jhKpRKtY9va2qLGPRQK4euvvz7x42MYBnq9HhcvXsS1a9fAMAztsETChTwej9ZhBQIBxGIx5HK5Fxo7plAoMDIygomJCTp5gTRsrlQqiMfjCAaDtF3eaVEqlbC5uUnDsB6Phy6SCoWCTpUgJQNcLhe1Wg25XA7z8/NYXFzE/v4+9vb26LgkMrWlHeuJWCyGRqNBo9GA2WzG4uIiwuEwNBoNhoaG4HA48NOf/hS5XA7lchkikYjOCSTrZKPRwNzcHDY3NxEMBtsijKlWq0in04hEIlCpVLS/MI/Ho7XefX19tMyIdIIh/02+f/h+VCgU6Ovro9dRJBI9tXPYadFSI0iGy+r1emi12mPfczgncdbgcDjU0LtcLggEAlrwv7m5iXA43LbO/CeNSCSCVquFy+XCyMgI3njjDUgkEuqNRCIRGt7pZPh8PoxGI4xG4wt9jkzMICInv9+Pzc1Nmksl3fxf1WAQIzg2NoapqSmapyObDVIUXyqVsLu7i/X1dYTDYVQqFaqOfBIcDoeGVe12O8bHx3Hp0qUjg5+JYCUUCtH5bae5qalUKk8Mh6lUKjidTprPI+HZSqWCRCKBpaUl3LlzB5FIBNFolEZeOgGxWAyj0UiHhJNGDGazGe+++y71BMngaa1WSw383t4e5ufnsbW1hWg02haFdblcRigUwubmJoxGI+r1Og2bk5ys1Wo9ooB9Xg4ODmhdajtoqREkRaEqleqJJ9xJ+bIXxWAwwOVyYWpqCh988AHkcjn8fj+d6xWPx8+kd3scVqsV7777Lq5cuYKhoSE6fZ4M7jyrDQ6elytXruDSpUv0/5vNJv7hH/4B+/v7tL3Xf/7nf9JRPy8LqSEjf2OyU/7kk08wMzODr7/+Gvfu3cPBwcFjs/WeBDF+ZFrBL3/5S4yMjECpVEIqlYLH49G2a1999RX+7d/+DR999FFby1sEAgEdLUTCwiRnGQgEcOPGDXz55ZcIh8PQ6XTo6urCgwcP2j555ssvv8Te3h4uXLiA69ev45/+6Z/A5/MhlUppyPnw0F8AdISQx+PBzMwMHjx4gN/+9rdtTaV4PB784z/+I/75n/+ZlkP19fWhp6cHXV1dcLlcGB8fp2HsF/HovF4vtra22iZKa4kR1Gq10Gq1mJiYwNDQEG0H9LpBJsgrFAp6g5Oi307MBb4sIpEIFosFDocDdrsdSqUSwMMyi52dHdy7dw8zMzNtPsons7e3h6+++grpdJrWppH8IFEpptNpRKNRxONxGI1GKkoheSnS0usw5DWiUqxUKtjb28P29jZ8Ph+CweALHyvxBBUKxZENIhEklEolmhN7ktcpFArBMAyEQiGkUilkMhkUCgV6enrQ3d0Nt9sNpVJJw1HVahU7Ozvw+/24e/cuAoFA2zdvBoOB5p4nJyePiHSI503ypE+bhdlqstksAoEAJBIJFfOQdopqtZreK2SAbCaTwf7+PgqFAvb29rC5uQmv19sRKQVSVwo8nAbB4XCQzWaxt7eHlZUVLC4uQiQS0RmhQqGQ5peJOJBEyyQSCXg8HorFIu7evYvV1VWsrKy8nkaQjGwZGBjAuXPnMDw8/Fhx/GHOsqGQy+W0gz2Zyt4pD+NJIhaLYTab4XQ6YbfbIZPJ0Gw2kclk4PP5cOfOnY4Ohe7u7uKLL77A9vY2Lly4gLGxMej1ehQKBYTDYSwuLmJ7exsLCwtYXV3FxMQELl++DOCheGZ8fPyxmYvAw9AqqePS6/UwGAzY29vD3Nwc7ZrxojAMQ2v2DhdaF4tFOhaIz+c/NexKhAxSqZTmmsxmM86fP4/JyUk4HA6alyGdjbxeL27evInZ2VkEg8G2L8Imkwk9PT2YmJjAhQsXjhg6UlAvFAohl8tpbWEnrCUkzNloNFCr1VCv12EwGI4oyJvNJpLJJGKxGHZ2djA7O0sFJp06R5WkPchEeIFAQPPVRJgllUrR19cHrVYLiUQCiURCJ2XodDoIhUKqIp+bmzu1yfHP4tSNIIfDgUajoS6zSqXqmBv0pCE3AhErENUlCW+0eyE5KZRKJVwuF4xGIxQKBd3NZrNZxGIxOoC3U0mn07QhQK1WQzKZRDgcRiaToQKT/f19OukCAPU6dDodEokEQqEQRCIR3fkS+b5IJKKdTYji7eDgAIFAgPb6fBHIPD8iqCILP1FZkzx7tVpFoVCg91ulUqH1uKSJu1wuh8FgoHn5wcFB2rawWCxSFeX+/j7u3buHubk5+Hy+ltdtHYdKpYJWq4VOp3tsA0KatnM4HNrgoVAodERTCvLsx+Nxqqgmf3+DwQCGYegGMplM0vsuk8mgUCigWCy23Qs/DnJeT6oNJN5ePp+nY5NIvaNUKoVGo6GaidXVVezu7rYt3N4SI6hSqeBwOKDX60/713UMxACSAtizPBj4UXQ6HXp6eqDVao94ENlsFtlslsqjO5VisYhoNIpsNotUKoWFhQWo1Wp6ndLpNAqFAjKZDBqNBoLBIH1ARSIR7t27h76+Ptp6jQyn7e/vh06nA8MwAP5YitHV1YWxsTHkcjkEAoEX2gyVy2U6eYQ8PxwOB2NjY7BarbTLSrVaRT6fp/9mMhkoFAq6UVEoFLTYmhhvpVJ5ZAOzvLyM5eVlLC0tYXt7Gzs7O0in0x1xLckxH5drOiw6CYVCVGTRCS36CKVSCdFoFNVqlW6aRCIR+Hw+nRRRqVSo2ImMyjqra8bBwQEN6UajUSqgAUBDpVwuF9VqFdFotK2G/tSNYLPZRD6fRyQSOTOdOF4WlUoFnU5HB5x+9NFHePDgAe7cuQOPx9PRo3meBZfLhVwuh1wux7lz5zA1NQW9Xk893kqlgo8//hizs7OIRqMd/fDWajUqq4/FYs98P2lvdZilpSWaXyOeX09PD0ZGRjAyMgK32w2r1Uo/Wy6XXyr6EYlE8Ic//AESiQQTExNwuVxwOp00nEZagpFwGxHIlEoliEQiWupAmjUcFr0UCgXs7u7if/7nf7CxsUE7lYTDYVSr1Y4o5yG5zLfeegsXLlyAxWIB8NBDjsViiEaj2NjYwMrKCkKhUEd4rcdxcHCAXC535pp/vCykvvQsCORaYgTT6TR2dnbgdDpRr9cfG5t0WNHWia7/8yIWi2k+EHjYJ29mZgYej+e5FttOhjQw1uv1sFgsMBgMdMZcvV5HtVrF4uIifD7fmTb2z8txC9r6+jri8TgNEUmlUtoHkhRyv6hRyeVytPUc8bCJyIKMN5JIJACerawmDc1JzRaZ2fm///u/WFtbQ7FY7Li2dgKBABKJBP39/ejp6YFCoaDnEY/HsbW1hbW1Nayurp656QosnUFLjGAsFsPq6irkcjmWl5dhNptpHsPr9WJnZ4cunC8jHugUSDiDjAva3NyE3+9vS7L3pOFwOGAY5sjgVVLHlE6naS4wmUx2VBiqlZTLZXi9XhwcHGBvbw/T09O0b+XOzg5CodBLeVbNZhN7e3toNBrIZDLY2dmhik6VSgWVSkXz0U+jVqshEonQkUvJZJLmADs1XE9GKZE8J8n5bW5uYmlpCQsLC/D5fPQcWFhelJYZwVQqBYFAgKWlJQgEAmg0GlSrVWxsbOD27duIRqMA0LHhjOfhsBFsNpvweDzY2dnpyMXlRSFGkPRtfHRCBvF0kslkR7VIayWlUok2Fb5//z5VbZLw46tEOfb29qiwZn5+Ht3d3TAajXC5XHA4HJBKpbRW80kUi0Wsrq5ieXkZa2trSKfTSCaTdHhru0Ofx0Fk+YfrIOv1Oubn53H37l1MT08jEonQ11lYXhTOMzpKnOhTIRKJ6FwysViMRqOBVCqFbDZLF4h6vX5mzuWHywAAIABJREFUPSdiIBQKBZRKJZaWll6L3SlpWXXt2jVcuXIFk5OTuHTpEnK5HHw+H27cuIHPPvsM9+/fP9Ph7LMAl8sFj8eDSCSiI8kOt1J7GqQHKPl6Wm1hp0Dm8LndbojFYlp3S2Yn5nK512KTyXK6NJvNJ+YKWtoxplwuv7BE/CxB8kSdXB7wMpC6N7vdjr6+PhgMBjrLLpVKYW9vDx6Ph12MWgARHHxbNhtEZb21tdXuQ2F5TWnbZHmWswPp1tHb24vBwUFoNBraWJl4FZ0yJomFhYXlRWhPx1KWM4VGo4HVaoXD4YDL5aLNz4lXQvI0LCwsLGcN1giyPBePtoAjnUosFgssFgvMZnPbusCzsLCwvCzsqsXyTAqFAlKpFHK5HFW/EsHC4a/XsU8qCwvL6w2bE2R5Jrlcjkrpi8UieDwe6vU64vE4HWAaDAbZkCgLC8uZg/UEWZ7JwcEByuUybctFcoCPCmNYWFhYzhotrRNkYWFhYWFpNU+rE2Q9QRYWFhaWby2sEWRhYWFh+dbCGkEWFhYWlm8trBFkYWFhYfnWwhpBFhYWFpZvLWydIAvLa4JWq4XJZIJGo4FUKqU1nKVSCZVKhe3tysJyDKwRZGF5TTCbzbh06RIGBgZgNBrx9ddf4//+7/+QSCToYFoWFpajnIgR5PP5GB0dRSaTQSqVQrFYRK1WQ6PROIkfz9IhkFZpQqEQCoUCDMOAz+fT1zQaDR3zU6vVUCqVUC6XqSfCeiOnB5fLhclkwujoKCYnJ2EymVCtVpHNZrG5uQmfz4dMJvOtGcHEwvK8nIgRFIvF+Ou//mssLy/j/v372N3dRSaTeS0GyrL8EYFAAIFAAK1Wi8HBQej1ejrNnMvl4uLFi6hWq8hkMsjlctjf30cwGMTe3h7i8Tji8Tg7/fuUYBgGBoMBbrcbbrcbEokE4+PjkMlkuH37NiqVChqNBpLJZLsPlYWlozgRI8gwDN59913IZDLk83kcHBygVqt9q4zgsxpIkykMYrEYDMM8deICaUt2cHCAarWKarWKZrPZci+KHDPDMBAKhZBKpZBKpbDZbDh//jzsdjsdq8TlcvHee++hUqkgkUgglUrB4/HA4/FAKpVCIBCgVCqhVqt1pDfI4XDA5/PB4/EgkUjA4/GOTM4g14P0RyXebqPR6IjzEYlEMBgMsNlsMJvNAICenh5YLBYkk0msra0hkUiwRpCF5RFOxAiWSiX85je/wdDQEP72b/8Wc3Nz+Nd//VfcunXrJH58x6NQKKDRaCAWi5/4HoFAAKVSib/6q7/CD37wAyiVymPfx+FwkEwmsbOzg7W1NXz99df49NNPkc/nUalUUK1WWxZmVigU0Ol0ePfdd9HX14fh4WEMDQ1BKpVCIpEcMRLNZhObm5sQi8UwGo1wuVwYHx9HIpFAIpHA9PQ0bt26hRs3biCVSrXk+J8HDocDiUQCkUhEhwb/4he/QE9PDxiGAcMwAAC/34/V1VVEo1HU63XcuXMHi4uLiMfjSKVSbfVwuVwu7HY7BgcHqWcOAJVKhU7+IL1fWVhYjnIiRpDL5UKhUNAviUQCgUBwEj+6o+Dz+RCJRGAY5ogRc7vdGBwchE6ne6JXQDyMoaEhyOVyurg+CofDgUKhgMViAYfDoR6Ux+NBJBJBMpk8VQ+bw+HAaDRCr9fD5XKhq6sLb7zxBsxmM8xmM2QyGTgcDmKxGDKZDDKZDLLZLDKZDNbW1iCRSKDVaqHX6zEyMgI+nw+dToe+vj5Uq1XMzs4im812hAdFDJ/dbofVaoXdbofD4YDFYoFMJqPhXwDQ6XTo6emB0WhEo9GAQCCAw+HA1tYWPB4PotEoIpFIy8+Bx+NBKBTCYrHA6XRCIpHQ13Z3d7G2tgaPx4N4PI5isdjy43teuFwueDwefU40Gg3UajVkMhkkEslTIyeVSgWFQgHb29tIpVLUS2c5G6hUKiiVSggEAnC5XDAMA5FIBLPZDKPReOTa1+t12rR/dXUV6XQamUwGlUrlpX//iRhBIopQKpWQSqVgGAY8Hu8kfnRHIRAIIJfLoVKp4HQ66fcnJyfxzjvvwOVyPXVh5/P5UCqVEAqFT30fwzA032a321EsFtFsNlGv11EoFE7dCFqtVoyOjmJ8fBwTExPo7e2FSCSCQCAAn89HsVjE3t4eAoEAtre3EQgEEAgEsLq6ColEAp1Oh66uLiiVSlgsFlitVvT29kIul+O///u/sbOz0xFhUYlEgnPnzmFsbAxjY2PQ6/VQq9XQ6XQQCoXgcrn0GIkQqF6vo9lswmg0Ip1O4969exAIBODxeC03giSEKxKJYLVa4XK5jhjB7e1tTE9PY3V1FbFYrKONIDHmQqEQer0efX196O7uhsFggMFgoAKs48hms4jFYvj8889Rq9VQLBZRr9dZYd4ZQaPR0Dw2n8+HQqGAWq3GuXPncO7cuSO2pFqtIh6PIxqN4re//S22trao6O5lOREjyOPxYLPZoNFoaL7rpAasCgQCiMXiIzmYVt7cXC4XSqUScrkcGo2Gekn9/f30PUNDQ+jr64PFYnnqwn44dPg0yI6YYRgoFAq43W4EAgFks1kkEgkUCoVTkbvzeDxIpVL09vbiwoUL9LxUKhUqlQpCoRAikQhSqRTW19cRDAap+CUYDGJ3dxcMwyAajaJcLiMYDEKlUkEgENAwnVQqpUN427VIiUQiyGQyOJ1OvPnmm+jv70d/fz9kMhnEYvERxSvhsFcIAEKhEFqtFqFQCF6vF8FgsOXnweFwqPFQqVTQarVgGIbmlKPRKHw+HyKRCDUMnQoJvZMIgsvlgsPhgFarhVarfeqmOp/PI5lMolqtwmq1IhKJIBqNIp/Po1wu03/POiKRCGKxmG40pVIpxGIxfZ78fj+NznTy+XK5XPD5fEilUuj1erz55pt0A8fn8yEWiyGXyzEyMoKBgYHHjGAqlYLJZMLW1hbq9TqNSr0sJ2IEhUIh3nzzTYhEohMTcJDwiMPhwNjYGMLhMGKxGJLJJFKpVEu8CA6HA6lUisuXL+PixYtwu90wGo0wGo0YHh4+8j4Oh3Nqx9TV1QU+nw+GYZDJZFAqlU5F4CAUCmE0GjE1NYX3338farUaXC4Xa2tr8Pv9uHXrFm7evIlYLIZwOHzsz6hUKkilUohGo4+F4EgItN0T6C0WC8bGxvDGG2/gF7/4BV1ECMSLOCxOqtfrEAqF4PP5NEwtEomg0+lgMpmg1+shEonoJq0Vm7XDnqBaraYipWq1ilwuh+3tbaytrSGVSr3STvm0IM+4wWDAuXPnMDk5iYmJCXz44Yf0PeTZetrfktxP3/3ud1Eul7G2tob19XV4vV5sb29jfn4eHo+nLeKyl4Gcs1AopHlppVJJw/YOhwPXrl2D0+mExWKhHvS//Mu/4JtvvsH09DS8Xm+7T4NC7lM+nw+5XA65XA61Wo2enh585zvfwQcffACFQgE+nw8ul0tL7EQiEQAcSZ3weDzo9Xro9Xr85Cc/AcMw8Hq9CIVCL318J1Ysf1gkcRKLnEgkglQqxeDgIH70ox/B6/XC6/VieXkZ6XS6ZUZQIBDAarVifHwcLpeLKiRbiVqtBo/Hg8/ng0qlemI+8VWp1+vI5/Pw+/1YXFyknv2NGzewuLiInZ0dhMPhp4bVRCIRlEolXC4XJiYmYDabweFwkM/nEQqFkM1mqVFpFyKRiHoYx0UtSG0jyXVGo1GUSiWYzWbI5XLweDxoNBr64MpkMmi1WlgsFvpZ8m87ILWaxWIRuVwO5XK540KDJPcjl8vxox/9CL29vTQ/+7KQDYHdbodEIoFCoYBIJEI4HMbe3h5VWnc6AoEAQqEQOp0OVquVqrG1Wi00Gg1UKhXsdjtNrRBPyWQyQafTUePRCXC5XAgEApr3m5ychMFgoOc2ODgIuVxO84EAaP0xj8ejaSAS+SIG9Wk54hflxIwg2fme1C6fhAJ7e3vx/e9/H8vLy1AqlUilUlhbW2vJQ03+4GazGcPDw3C5XKf+O49DpVJBpVLBbDZDoVBAKBSeyu8hOUe/30/Da1KpFB9//DHu3bv3zM/zeDzI5XJarzY6OkrD47lcDsFgELlcru2dS4jnpNFojjxMxPsjxi8cDiMcDmNzcxPZbBaDg4M0P8XhcCASiWie12AwwOl00kR9Op1uiREk3tTh567RaKBaraJQKCCfzx9Z+InRPxyab4dIiYT7NRoNfvCDH8BiscBkMj11g3nYkzt8DgSycFqtVlitVkgkEjQaDXg8HigUCroB61RIMwqJREJLkcbGxjA8PIyf/OQnNBRKPGPyNyB/B4PBAK1W2xFG8HB5lUQigcFggNVqxdtvvw273U4NIdGRkHuw2WzSyEy9XkelUkGtVqORDB6PB7FYfKLneCJG8ODgAF6vFwaDASqV6iR+JMrlMtLpNPL5PBiGobJ7tVrd9nDa60qj0UClUsHW1hbK5TIkEgmEQuFzhRo4HA7Onz+P7u5u9PT0YGBggAqAKpUKgsEglpaWkM1mW3AmLwbZwG1vb8Pn82F9fR2pVAqpVArJZBLxeBylUgm7u7uQy+Xgcrl49913IRaLIZPJ0NfXB71eD61Wi3A4jFAohOXl5VOvySMiErfbDZ1OR79fLpcRDodp2oAsrmKxmNZ2ajQaVCoVlEolbGxsIJfLoVqttmyDQsRfbrcbDocDarX6marySqWCdDqNYrEIk8lEhVpPWg9UKhVcLhempqbA5/OxsLCAhYWF0zqlF4KEB0l+jBgLk8mEkZERqNVqmM1m2Gw2WK1WCAQCZLNZRCIRuski11GpVEKhUNAwfjtDvofDt0TwQqIkRHCnUqkgk8moiJKUfqXTaSQSCZRKJTQaDZRKJZRKJcRiMezu7gJ4KKK5cOECJiYmTuyYT8QI1ut1eL1eWnN1EhehXC5T6TMxguVyGSqVijWCpwQxWF6vFzs7O9RreB5VIekYMzExgfHxcdjtdggEAhqCCoVCWFpaeqUE9mlAPKF6vQ6/348vvvgCX331FZLJJPL5PBUhNZvNI2EYo9GI/v5+aDQamEwm8Hg8DAwMwOfzYWtrC4VCAbOzs6d67MQIdnd303wgcNQINhoN6i3KZDIMDg6ip6cHbrcb2WwW6XQa6XSaLqCtNoJOpxNOp/O5BHWVSgWRSASJRIKWKD2azz2MWq2m71EqlSgUCh1lBMVi8REBnE6nw/j4ON5//32YTCZaIiIWi9FsNpHL5bC3t0cV2b29veju7gYAyOVy1Ot1ql5uF4fzl11dXbh8+TI15DabjZ4zuW48Hg/5fB75fB7BYBCbm5tIJpOo1+vU2Hu9Xty/fx/AQ30EwzAYGho6sfM8ESMoEAjw5ptvUhn5SRgp4hrX63UaIy6VSrROrRWQ+ke1Wn0kZv0oxJN4VAjyH//xH/D7/QiHw0in08d+9uc//zkuXLgAm80Gm812RAlFLvKtW7cwPT2NmZkZzM3NvVIS+Hk4LDkm4iC5XA6n0wmXywW73Q6TyYRIJIJSqQSNRkPDWkqlEiKRCLVaDdPT05ifn8fCwgI2NjawubmJfD5/qsf+PAgEgiO5XdLdaHNzE59//jlWV1ef2A2Gz+dDIpFgZmYGhUIBV69exbVr12AwGMAwDKRSKVWunSZCoRAmkwnXr1/Hj370I5jNZurZ+Xw+fPnll/B4PBAIBBgbG8OFCxcwMjKC733vezScRDrgDAwMYHZ2Fjdv3myZkdBoNJiamsJ3v/td2qHnUcjGZGdnB7/+9a+xvb1Nw2NSqRQ9PT3o7u6G1WqlOV6BQECfJYZhoNVqj9y7XV1d8Hg88Pv92Nvba3kHnffeew/nz59HV1cXuru7qSKSz+fT+1ImkwEAQqEQ5ufn4fP58ODBA0QiEUQiERQKBdhsNqhUKoyNjUEoFILD4eCbb77BwsICEolES8+JhHDPnTuHixcv4vz587BardDr9dDpdGAYBgKB4DEtQ6lUQigUwscff4z5+Xns7u7SlMnhXGC1WoXJZMLk5CTOnz9P0yyBQACRSOSVRV8nViyvVqupOvQkIUq3w6271Go1otHoqecFBQIBTKb/z96XxTZ6nWc/3Pd9X0RJFEWJ2qXZNzu2Y6cB0k6CJkiBXBQoutwUve9Fb3Jd9KK9K9CbFmkLozES239iT2OPx/ZsGWk02kWJEklx3/d9+y+m55jSSOMZj0hJDh9g4GRGy/eRH897zvs+ix4mk+m5ZJRGo4FarQan07mPKv/w4UNKUT/qBHTlyhXYbLZ97ayDyOfziEajSCQSlDnVSRCJBtFE9vX1QaFQYGBgAP39/ejr64NOp0MkEkG5XIZCoYBCoYDFYkGtVqNtm4cPH2J5eRlLS0uIx+NIp9OngqAhEAho4Qa+Og2Wy+VD6eXkJEHaTmSnS9p3ZFNGFgOFQkE3A51y+GGxWODz+fQ0JRKJaOuIyFa4XC4GBwcxPj6Oubk5jI+Pw2azPfOzRkdHUSqVqMdrKBTqymdLKpVCpVI9d1NbLpeRSqWwtraGnZ2dfSedZDKJRCIBg8EAtVoNrVZLZ2YajYaSRgQCATgcDmw2GyYmJqiTTiwW6+g9toMYAMzNzeHSpUvo6+uj3RKy0FcqFRSLRQQCAdp+JyzXhYUFOm/mcDgYGhqCWCym5KxarQa32w2fz4dCodC1+yLEF6lUisuXL2NmZgYzMzNQq9WQSCTP8BdIV6XVaiGTycDlcuHRo0dYWVlBNBpFOp1GpVIBi8WiBCGpVIqpqSmcO3cOY2NjYDKZ2N3dxcbGBn2tXgXHRowhN3bcNOR8Pg+/3w+dTgcWiwWVSoWhoSGk0+mOa2HIsXtychIikejI+6pWq8jn8/j0008xPz9P/35jY4NKGo7Cwdet/XeQ/y0SiejQmyy8nRzw83g8CAQC2O12TE9P4+LFi1CpVLQIEBcPrVaLer1OXXRYLBbVpm1sbOD999+nxtmlUunU6NQkEgksFgssFssLPbdcLhc2mw2Tk5Po7++HSqXCwMAApFIpDAYDfTaIbo/H41HiTaccfsjiQzRVHA4HoVCItmPj8TgGBgYwMjKC2dlZTE9Pw2QyHfqz1Go1BgcHMTs7CwD48MMPO54C87znvv1ryH0STRyZHwGgbbNAIACBQAC1Wk2fT5vNRjWpwNOOhkQigUajgVKppI5A3YJOp8PFixdx/fp1qn0rl8tU6J9IJKj0aHt7G7lcDplMBolEgv6XmKDL5XI4HA709fVBqVSi1WqhWCzC5XJ1vQiSTYZWq8UPfvADKl8gbc+DKJfLqNfraDabiEQiWFhYwPz8/L4NPjk1yuVyKBQKWK1WfPe738Xo6CikUil2d3exu7uLzz77DF6v95V5BsdSBFutFkqlEh3yHicymQy8Xi8EAgFlLA4NDWF5ebnjRZDL5WJgYABDQ0PPXSQJHX1+fh4fffTRS/0Ownyq1WpoNBr75iLtbiVGoxE+nw9isRhcLrejRVAsFkOr1WJ8fBw3btzA22+//cyOnczR2nV/RONDCuH8/Pw+0+nTArJgqtVqOoAnEWCHXSuZpV27dg1jY2N00E9a/+2vC5lzCAQCiESijhGByO8hUiIAyOVy2Nvbg9frRTqdxvj4OK5cuQKHw0Ede8iMliw2hN1qsVhQqVTAZrPxv//7v2i1Wh1nUrYzU48qghwOB0KhEEajkYri0+k06vU6crkccrkc/Xrynk5OTiKXy0GtVu+TbQmFQmg0Gkrg6xTL+jAQprvVaoVGo0E8Hqcib7fbTdNWdnd3sbi4+FwWtVwux+joKLX3SyaT1G84Go125X7ISU0sFlMCzLVr1772+8jIqFarweVyYXFxEU6nc9/XKBQKyOVySqYhz7HJZEKhUMC9e/dw584d/P73v0ehUHjl5/TYDLTfffddTE5OYmxs7Fhndi6XC7/85S/x05/+FNevX4fdbkez2cStW7f2fQDOKhYXF6kbDplfkJkAweTkJGWMpVIpZLPZjs7W3n77bfzpn/4pRkZGYDQaIZVKn3lPs9kswuEwcrkcuFwuOBwO7HY7LBYLtFotLBYLNjc36SzwNLRBCbLZLLxeL/R6PWQyGd59913813/9F/x+/zOLCIfDweuvv46//du/xcDAACVmHfaMNxoN5HI5pFIp7O7uwuPxdFUOUigUKCFGIBDg+vXr+PGPfww+n09lKvPz8/jyyy+xsLCAmZkZzM7O4vXXX4fdbofNZsOFCxfw7//+74hGox3NH6zX68jn888lSrFYLFitVlitVszOzmJjYwO/+c1vcPv2bTx69OiZwjk0NES9ed1uN3Q63T5DceBpsoZKpQKXy6Wn5m7A7Xbj3XffhdfrhU6nw8bGBvW+JDOwF+2k2Ww23Lx5ExKJBMlkEr/+9a/x/vvvd9W2z+FwYGZmBhMTE3A4HJSg83X4+c9/jqWlJYRCIaRSqX2bTrKx+5u/+Ru89dZbVOpCpC8AEIvF4HK58OWXXyKbzR5L1/HYjm3tXn1EQPwyJxYishaJRPt2aDKZDDqdjprottNuiRD4tJ00XgbhcJgaaxeLxUP1L6SlczDep1MgRBHi70lSyYvFIp07raysIBQK0RkFl8vFD3/4QygUCmqHdOXKFbRaLcTjcRQKhVMTqsvlcqlzBTHCvnLlCnZ3d+F2u2m7F3j6LM/MzEChUDw3Aotk9W1ublLHkk4y9QiTs1wuo1Ao0FOdUCiERCJBuVymFnDkmqvVKsLhMHw+H1wuF5rNJlKpFDXfFovF4PF4mJ2dpbOoTCbTkXuo1WpIp9OIRCJfazVITnEGgwHnzp2DUCjE8PDwM983MjKCvr4+avZ+2EmP+P/qdDrY7XZEIhFsb28f+/0dRKVSoZFWxGaQdB9edKOkVquhUqlgtVqpZCIWi1EP326ahhPHF2Jw0M5OBr4iC66vryMUCiGfzyOXy2Fzc5Na2pHrZbFY1DNUJpPBarVS4s9hRMvj1rYeb+8SX7UwyAfqRYsgaXkc3L2JRCKYTCaIxWLq1EF60PF4nNKCzyrC4TBarRai0SiKxSIkEslJX9K+CB6SDUmKXyKRwPr6Oj788EMEAgGk02k6B7Pb7RgeHobFYoFarcb169eRSCSwubm5r5ieNMi8QS6Xo9FowGazgc1mQ6fTQSwWY2BgYF9Oos1moy73R6HRaCAej2NxcRGffvopdnd3Oz5TI0Uwn8/TWbFYLIZMJkO1Wn1mASFFMBgM0papy+XChQsXwOPxYDQaIRAIMDc3h0qlgnA4jHw+3xELOOIBSZ7/rwOHw4FWq8X58+cxPDyMeDy+TzgPgM4EBQIBBALBkUWQwWBAq9XCbrcjkUh0pQiSsGmn0wk2m00Z2C/6ujKZTGi1WnrqYrFYyGQy2Nvbg8/ng9/v7+pnS6lUYmhoCENDQ9DpdM/ow8nz+fjxY8zPzyMUCiEQCGB3d/cZch+Ri6jValgsFgwMDMBgMDxXA3qcOLaZIBGxNptNqFQqzMzMUP1HqVSiA+1qtUorP3FGAJ7uLIxGI5RKJS0ErVYLfD4fg4ODkMvlVPDL5XJx9epViMVibG9vIxgMnkoR9oug3eD365zvFQoFRkZGkE6n4fV6O3ZN4XAYq6urqFQqiMfj4HK5KBQKlOSyvb2N1dVVauZNfA5XV1fB4/GgVqshFospVd1kMtEIlNNQBAnZghQ1wiQkHQyz2QyZTEZPIWq1+shBP3GXSaVSePToERYXF7GxsXGkJOa4QApgMplEKBSiqSMWiwUMBoPG0LQvIoRxGIvF6Cwlk8lgbW2NyibMZjMmJycpGYPJZCKZTB472aJSqSAWi8Hj8WBrawsqlQoKheLIOR357Gu1WiiVSmi1Wvpv5B6JuQPRoB22gLbbeA0ODiKTyeDJkyf0fezUxqXVar1SxJNIJMLg4CAuXLgAu92OQqGAnZ0dLC4uYm9vD4VCoWtdFsKClsvlR0bnFQoFpFIp7OzsYHd3l578tFotyuUybQErlUoYjUZ6CCJRZs/LZj1uHJtYPhgM0oG10WjEd7/7XUpHJlRmIs4lUgeDwQCTyUQXUfJBbH9B27MKAVCh5c2bN2E2m3H79m3U6/UzWwRfBiaTCdeuXQOHw8HHH3/csd/j8Xiok4hOpwPwdAFNp9N0JhmLxVCpVNBoNMBgMFCtVrG8vAyFQoGhoSGo1WpKROjv70ehUEAsFjt17vYkOYOYFZvNZgiFQiqJIfZoR+lEo9Eotra24HK58Lvf/Q4ejwexWKzjpBLSno5Go3C73WCz2TRY12QyoVQqwWg07rvmQqGA3d1dWqCJLdXKygp4PB5Npnc4HMjlcigUCmCxWFhfX+9IEYxEIuDxeLh79y7Gx8cxPj7+XLIKsTEkEp72vwe+WhueNzIgRvcSiQR9fX2o1Wo4f/48nE4nisXiqTQaZ7FYkMvlsNvtuHbtGkwmExKJBFZWVvDll1/C6/V2tRvGZrOp/OSo8UAmk8HOzg4CgQAKhcK+5J1EIgGfz4dWq4WZmRmcO3eOajr1ev2+DU43cCxFsFqt4rPPPkO1WkW5XMbY2BgGBgbgcDgAPP3wkXTrYrFIZ0gSiQSlUgnBYBCRSARerxeZTIYKzsnORqFQoL+/HxaLhVJw5+bmUK/X4XK5OjbcbjabKBQKKBQK4PP5R8a5HPTwexmQHRVZiMkM57BdncFg+Fpd1XEgGo0iFotha2uLWp8RLeRhO1nS+vjyyy+hUCgwPT1N3SHMZjNmZ2eRz+fh8XhOnMykUqkglUppW4ycMAQCwTMkioNsWKJt8vl8+OKLL+DxeCirLxaLwev1ds0cvNlsIp1OY2FhAaVSCd///vcxPj4OiURC25cHF6lKpULb7uRnNJtN3L9/n8pY4vE4bt68SQORWSwW1Q4e50mDZFLGYjFEo1Ho9Xro9Xp6Qpuensb4+DiEQiHV/pH3C8C+jXL7+/QiUWbtumaZTIbbt2/TSKLTBBKTZTZ5Wj+nAAAgAElEQVSb8fOf/5xGfu3u7uLf/u3f8OjRI2xsbHQ1m5PL5cJisWB8fJzqhw/TUBMZ0k9/+lMUi0VqoM1gMOiGutVqUfJLe5juYQoDouvc2NhAJBI51vnnsZ0EPR4PZDIZfWDbHTkIDVsmk+0z2W61WnC73djc3MTW1hZ2d3cRCoWecXEwm824cOECGo0G2Gw2ndd0OrKGSD+KxSItUIfhVcgqIpGIvm5f54VIFqVOtwoIQ61cLr/UyS2RSNDWWbVapc+ASqWiM92TBAl/JgLjFwVJZSBEkp2dHfzmN7/Bo0eP6ObuJNivZMZHfFsPFooXRSqVgtfrxcrKCjgcDn7wgx/Q1iPJrSOGxseFdm/IdDqNlZUVAE83hZcvXwbwdNMH4GsL1MsWQQA0foi8f6ehTX8QRB9pMpnw05/+lK51fr8fn3/+OUKhUNeDklksFvU1lcvldL0/CDJzP8ycoR0vkrHabDaRyWTg9/vhdrufYZW+Ko6NGFOr1RAMBvH48WPEYjGsrq5SRw6y067Vas+cBKLRKCKRCGKxGOLxOHK53DPicgaDQXfwSqUSNpsNPp+POiR0ShtTq9VoDAtxnTgMr2IQMDo6iqmpKQwNDUEmk4HH4x1JlS4UCshkMh23TXsVtMsPxsbGTvpyKEj+3x//8R/j4sWL9Nk8CuR0S8JpNzc3kU6nEQgEsL29jd3dXZRKpa7uwg+CGJ4Xi8VXbr+SeSHRNhIiCpnrCoXCrpzia7Ua/H4/fv/736Ner+P8+fO4cOHCC238COfgMOYgaWuTzgYBj8fD5OQkstksPB7Picd8AaAWaiaTCXa7HTMzM2g2m9QJaHl5mYrnuw2yJu7s7MDhcNCTeieNBzweDz7++GPs7u5iZ2cHbrf7dBbBer2OUCiEeDyOlZUV2jNmMBh0V1AqlZ4JYyWMQbLgHEYrbzQaEIvFEIvFVLhOaMGdFIiSewoEAujr6zsy5uVVnHJGR0epdRphIJJTxcGfRzL5zkoRHB8ff6VW8XGByWTSOfQPfvADDA4OUqeNo94zIkGoVCrw+Xy4c+cO9vb2sLe3h0AgAL/ff6IFkFxjtVo9liJI2pOk5UukSSTIVSQSda0IBgIB1Ot1BAIBCIVCTE5OvlB0DjHcbzdyICBrEYfD2ff3XC4XExMT8Hg8EAgEKBQKJ14EiUEA6YBdvHiR8i7m5+exsrJC3XK6DbIm7uzsIBKJQK1W0/HWN8GLrAterxcffPABtaB8GVbti+BYJRJHzYxisRjYbDZtK70s4vE48vk8YrEYhoeH0Wg0MDU1hWg0ColE0rFWBoPBoKfY454XyOVyaLVazMzMYGxsDBqN5rkm3QDgdDrx/vvv48GDB8d6LccJwlosl8sds9J7UZABvslkwptvvonXX38dMzMz1LT4KPzP//wP1tbW4PV6sbe3h1QqhVAotI/hfNILJfDVzLrRaODBgwf49NNPMTExcSSxQCgUor+/H5lMBoFAYN+/EXIZj8dDuVymLWO9Xo9z587h888/f2YD2ykUCgXs7e0hkUjgtdde+9o1o1AoIJ1O4z/+4z9w9+5dmv7R/h4JhUJMT0/j5s2bVAIjFArB5/Nx8eJFmhqytraGxcXFTt/ikWAymZidncWVK1cwOzuLyclJGAwGbGxs4Le//S3ee+89BAKBrmoCD6Jer+PRo0eoVCq4ePEirl69Si3NvikOrg+VSgVut5uawc/Pz1Ot8XHj2HWCh+FVtXwk7JUElbZaLchkMqhUKuoF2Ak3eDIXI/lWxwFCzdfr9bDb7VQU+rydbj6fR7FYhM/nw+7uLs3W6iTI6YlIUg7bsRHCTPvskBBMJBIJpYWfVNtQIBBAo9FgeHgY4+PjmJ2dpQXweTvQZDIJn8+H9fV1bG5untpEcvL6VyoV7O3tYX19HUqlEnw+n7b+2iEQCNDf349oNIpgMEi1auR9IT+vfdNCwl1VKhVYLFbX8uraN1Pk83fUBpFcbzKZpMkQqVSKrhUAqJm5w+Gg8USEEUyYohMTEygWiydWBEnL1mKxYGJiAiMjI9DpdGAymVhYWMDm5ib29vZOBRM+mUzC6XRCIBBAJpOh1Wo9I5g/DDqdjqYCHfV+5vN5pFIpbG1t4cmTJ9ja2kI+n+/YYacrRfA40d5ek0gkGBgYwPDwMB4+fHjsv6tWq9F26HHtQMRiMfX+u3DhAtVAtqcRHEQkEoHH44HL5UIsFut4YjnRcapUKurQf/DkRBZMYtVFWtJqtZq20Np9OU+izSSXy2mCwvDwMDQazQud6Amhh8lkUhnIaQV5H4LBIJaWlqDRaGj+5sG5p0Qiwfj4OA0vjcViiMViz11cxGIx+vr66M99Fa3by4JsQtPpNAwGw5HvHTEJMBgMGBgYoC3P9pDgWq0Gn8+Hra0tauZA9MhMJhN9fX0AcKJ5lywWCzKZDP39/bDZbDAYDOBwOIjH43j//fexvb19aiQcuVyOMpBJ5NWLSBveeecdSrY6jFXaarUQCoXg8XiwsLCAu3fvUiOATpHPzlQRJGSFSqUCLpdLrZT6+/s7UgQbjQZdLJ53EiDpAUT8TwyK20Go+CaTiZJG5ubmqBvO8xCPx7G5uQm3292xVAJyHyQWRSgUwmKxwGazwWQyPXOqIDOzXC6H3d1d6k5C0hn0ej1arRYKhQJljHazmDCZTKjVajgcDszOztLNBvCVxR85RZHTORFZKxQKqFQqWghPk+/pYSBZlmtrazCZTDTCRqFQ7NtYiUQijIyMIJlM0tktk8nc58EokUj26e1IIoZYLAabzaa60G6d6kmMmM1mO5J8QT57fX19sNvtlGZPzOmBryQle3t7NC6LPI8MBoO6nmxtbXXlvo66D2JmbrFYIJfLaZDuZ599ti9B46RBmL0k6s7lckGv1x/59eSzNTc3RwvgwSJI8gPdbjdWVlbw5MkTKgHq5GfwTBVBUpR2dnaONVn4VcHlciEWi6nThtvthtvt3nd9MpkMc3NzuHHjBmQyGQYGBmCxWF5ooEyE5slksqN5gsQx5NKlSzAajTAajdDr9VAqlc/IG4h/X6VSQSqVogLs/v5+mnVGZlaxWAzZbLarRZCQqEZGRjA0NERTxgHQwhyPx7Gzs4O+vj6YzeZ9MTyNRgOpVIq6/XdrHvZNQaz3njx5QtMlTCYT+Hw+LVpsNhtGoxHnz5+HVqtFIpFAIpHA8vIyisUiPf0TDR0x3Q6FQkgkEnQW2q3PXbPZRDgcxvLyMqampqif60GQgj06OgqxWIxgMIhQKASXy0W7JuVy+cgCR0T4ALqaLHEQJCpOq9WCy+UikUhgbW0NCwsLtGifljWPgJihkBP7YSAOM2KxGK1Wi5KUDiKXyyEej1ODd7fbfewkmMNwpopgtVrF3t4eHj16BKvV2pXfSRh4xPqNw+E8UxBInt4Pf/hDzM3NUQF/+6KvVqtx+fJlXLp0ic7bjtIekoBNsljfvXuXOkMkk8lj7Y2TsE+9Xg+r1YqpqSl873vfg9FopGSmaDRKzcpLpRI4HA6USiW1TRKJRPv0QuSDSsKQJRIJXVS7BaPRiGvXruH8+fMYHR2l1+bz+bC9vY21tTVsbW1hcXER58+fx/nz5zEyMoLR0VHY7XZIpVKk02mk02msra2d+iIIAH6/H4lEAh6PB36/n+ZhkvkXod0bjUZcunSJsrIXFxepiYVQKKTzPwaDgVAohNu3b2N9fb3rbj+NRgMrKyuIx+M0HFir1e7b0ABfGcxPTk5ifHycmjVHIhF6ciqVStjY2ACTyYTdbodKpaIbhGaziVAoBL/f37VUiXYQ7a9er8fFixdht9upk8+vf/1r3L1799S0QQ+CzJWPSrMXCoWQyWQwm82UtCUSifad6ovFIorFIpaWlvDw4UP893//N3Z3d7t1C2erCBLxOhFLdpp2TwbuRItVLpePzExkMpmwWq0wGAyYmpp6RsRK/AqlUikNCz3M35AU3Vwuh2g0CqfTiYWFBTidTqTT6WM/BYrFYvT39+P8+fOYmpqiRYDL5SKXyyGdTmNpaQmBQACJRAKpVApCoRB2ux2Dg4M0Zb5dPkLuic1mQ6vVYmRkBOFwGJubm8d67c+DRCKBXq/f5zbSbDbh9XqxsbGB+fl5OJ1OeL1eyGQySCQSyOVyWK1WKjgn2sLjzsjsFEgm5d7eHur1OmZmZqDX66FQKCgR4aDFGIfDweTkJM2yJHE25OvS6TScTmdXY3oISAJJLpfD48eP6az64KzzYJ4jsb2TSqX0FNFsNmG32wE8febJ+0qeC4/Hg3v37lHRfjfB4XAgk8noRlQmkyGdTsPv98Pj8XSFCNcpiEQi6HQ6zM3N4Xvf+x79TB6084vH49ja2sLdu3e7vuE8G5/u/0Oj0aAPR61Wo7ungYEBaDQauqMg88JX9QIkw/VAIIDl5WXU63WYTCZqqExAPoTkRHQUyBvffrw/2N7I5XJwOp3w+XzY29uD2+3Gzs4OUqlUR+YBer0eNpsN4+PjmJychE6nQzab3UecWF1dRTgcRiaTQSaToQJZqVQKlUq1rzCTjQPJ1mtPku5mK4cUsnaNYqvVQjAYpCfber0OgUBAn6uDobqkIJw2O62jQF73fD6PQCCAxcVFSCQS2Gw2DA0NQSqV7kuWIP89mAAAgNoFEk1kN9PK20GYuSsrK3QTnM1mYbVa6em2/T0i7TZiOdYOcoJsfw4bjQay2Sz8fj/W19ext7fXvZv7P5A5PCEzlctlKgyPRqMn9tofBzQaDaxWK4aGhmCz2SAUCmknjawVsVgM29vbcLlc8Hq9HSf+HcSZK4JkJlir1SCTyTAyMgIGg4E7d+4gFAqhWq1CLBbDaDRSGvg3BfnQbW5ugslkIpVK4dy5c9/YuuxFikAikcDdu3exuLgIl8uFXC6HcDjcMXrwwMAAzQUzm81gsVh48uQJnjx5QoNVQ6EQSqUSyuUynQtls1lUKpV9BY7Mngh5iczSSORSN62pqtUqCoXCPmkGYZ7l83m6gVIoFJBKpdSs4aC28aQ0jq8CktixsLCAVCqFGzdu0GzBwxh5hyGVSlFXpmg0euKEjLW1NXpNTqcTf/Znf0ZnuMTX95vY8hFHIBIvFYvFOnD1zwc5CRIyVjQaxerqKu3+nLXnrx2ErGQwGCCRSJ7ZUNbrdfj9fiwtLXU0v/J5OHNFkMQIkbacXq+nrCOfz0eNWi0WC4rF4pG96hdFvV6Hz+ejg2kisCVzE9JCAl7cPq39a4iGjjAW3W43Hj58iPn5eXg8nle69heBSqWCTqeDTqeDWq1GqVSiZrXJZJLOANlsNqWUc7lcavpNND8AqHsJaaOSD/Lu7i5isVhXBb4HT4CNRoMavPN4PJhMJupNSRwvToO/6XGA6DOJq4dAIIBSqUShUIDRaASPxzuSAMJgMCCTyZBKpWgr7ri9Gr8J/H4/DeH1+/1wOBzU27S9vQk8bcOTjLrDTvHkeajX6ygUCvB6vfD7/TQkutvgcrk0QYHP5yMSicDpdMLtdp+44fyrgMFg0BavVqulM1gCslnzer1YW1uDx+NBPp/v+nWeuSIYjUYRjUbxm9/8BnNzcxgdHcXY2Bj++Z//mb7ApVIJhUIBf/3Xf42dnZ1X/r3JZBLJZBKRSARra2twOBz4+7//e6jVamob9KLzyfZU5FarRYtdKpVCMpnE48eP8dFHH73yNb8o2qnOrVYLAoEAN2/exJ/8yZ88Y3l2mFExuZ9qtUrzze7fv4+lpSXcvXu3a/dxEESGIpfLUa1WaZwX2ZXa7XZqnQY8e29n9RTYjmw2i2w2i1/84hf4z//8TwiFQthsNjgcDgwPDx/6PUKhED/72c/gcrnw6NEjrK+vd8SI4mVRr9cpUWlnZweff/45LBYLhoaGoNfrqe6PyWTCaDTCZDLhwoUL+3IhSUEkHaVgMAi3241f/epXNPH9JKK+FAoFZmZm8Nprr4HL5eLzzz/Hw4cP4Xa7T7085yhwOBzweDyMjo5idnaWHlbakcvlsLS0hP/3//4fPvvssxMr+GeqCLbjiy++QCKRQDgchtVqhcViobs7v9+P3d3dYz9JkZDZnZ0d3L59GxMTE5iYmIBMJqNhnl+HQqFAqcCRSAT37t2D3++nWYvdHoJvbW2Bx+OBxWIhFotBLBZDJBLRzDVCGjlKIpHP56m92NLSEtxuN7a2tp6x5eo28vk84vE4dDodzQwk7Vpi5p5Kpej/b29vl8tlOhMjiRhnGaSQV6tVamoQj8cP/VoOh4N8Pk/diYLB4KmdSWWzWWprJxKJ6ElDqVRCqVTSsF61Wk2TTEqlEkKhEJVRBINBbGxsfK1pQKfA4/Gg1+thNpthNBqRyWSQz+ePNAI/KyCkKyL5IJ+/dpRKJbhcLuzu7p7oZ+xMF8FAIECLCYvFQqVSQblcxtLSEu7fv3/sQ24yEyuXy7h9+zZYLBZMJtPX2gC1g4h/nU4nVlZW8MUXXyASiSCfz9OHv5vY3t6m5INIJAKdTgetVotWqwWdTgeLxQKRSPRMESSxLtlsFmtra7h//z7u3r2LRCKBTCbT9eH2QRDGWaVSAYvFglgsptmNpMgVi8V9tlrkQ1oul+n78W0ogsBXJK9oNIpkMont7e1Dv47BYODRo0eo1WrU9OE0xgwBT4sgCf5tJ0GRTY1CoYBer8fIyAhsNhv0ej0SiQSePHkCj8dD9Y+JRILKRboNUgRJe75QKNAU9rNaAAFQFr1SqYRWqz1UG1gsFrG9vQ23290rgt8E+XwewWCQUvnJg1OtVuF2u2lS9HGCzBKKxSJcLheUSiV9o4kn5dflmcXjcSQSCXi9Xmxvb1MvQFLAu41isYhIJAIOh4NMJkMTP1qtFhQKBbRaLb3Pg/18kq+3traGtbU1+Hw+SqA56TZOpVJBLpdDrVbb1w5js9lU2xQOh/HkyRPI5fJ97iqpVAqRSAQrKyvY29s7UgR8FvEii/1JzGW+CchG7OCsmWxicrkcstksisUiYrEYFAoFstksnZVmMhkUCoUT+dwRCIVC6HQ6SKVSsFgsZLNZxOPxEzXIPg6QEO5EIoFIJAKJRELlYblcDslkEhsbG/D7/dRs/6RwZosg8LSlE4/HMT8/j/fee69rv7dWq8HpdCIQCODWrVv0FPgiJ0HivUiE5ye9y240GlQKcZLu+ceNVCqFlZUViMXiZ8gOxDtzY2MD//Iv/wKhUAiBQECLIJHWlMvlUytS7uFokEJPNMVut/ukL+lIyGQyWK1WSCQSykRfXV09MxuRo0CyYxcXFyEWi+FwODA+Po5AIIDNzU08evQIjx8/xvr6+olvmM90ETxpEEufl8nMI7tXQsnvoTPIZDK4e/cu3G73Mw4jlUoFpVKJBpM2Go197Vvy3pz0BqWHPwy0p4GQjf1ZPwkSzgAhKZL27srKChYXFzE/P39qSFe9IvgK6Kajfg8vh0KhgNXVVayurn7t1/bewx5OEqQA5vN5JBKJUxGVdBwgAc2RSATRaBSRSASLi4t4/PgxlpeXT8SY4DD0imAPPfTQwwmiXC4jHA4jm80ilUqd9OUcKzY3N5HP5+F0OnHnzh08fvwYgUDgRCOrDqJXBHvooYceThCEpAXgW1cEt7a24HK5KDGtXq/TVulpAeNr2Ixnl6PbQw899HDKQXxDiQSJaFN7OF60Wq0jCRu9IthDDz300MO3Gs8rgmfDHr+HHnrooYceOoBeEeyhhx566OEPFr0i2EMPPfTQwx8sekWwhx566KGHP1j0JBI99PAtB7H0I84kPfTQw1foFcEeeviWgsfjgcfjoa+vD/39/ahUKpifn+95ovbQQxt6RbCHHr6l4PP5kEgkcDgcuHbtGrLZLFwuF1KpVK8I9tDD/6FXBHvo4VsGFosFHo+HH//4x/jud7+L/v5+WCwWbG1t4aOPPkK9Xv/W+FP20MOr4tQUQQaDARaLBYFAAJvNhlQqhVQq1Wvd9NA18Pl8CIVCiMVicLlc8Hg8cLlcFAoF5HI5tFot1Gq1E8+g+zpwuVwolUqMjIxgZmYGUqkUQqEQLBaL5kD20EM3wOfzweVy6ecJANhsNrhcLphMJqrVKhKJBPL5/Ik9l6emCLLZbPD5fJhMJvzVX/0VHj9+jPn5eYTDYeqr10MPnYRKpYLFYoHNZoNCoYBGo4FSqYTH48Hm5iZarRaSySTcbjdCodBJX+6REAqFsFgs6O/vh1qtRr1ep0HBiURiX2xUDz10EiqVCkqlEiqVCiqVCgwGA2KxGEqlEhwOB8lkEvfv38f29vaJHXZOTRHkcrmQyWTo7+/Hj370I/D5fGQyGdTr9V4RPMUgJ3gWiwUul7svW5HD4aDZbFJWYqPRQLlc3sdQPIlEaRaLBTabDRaLBQ6HQ6/farVifHwcMzMz0Ol0sFgsMBgMWFlZgUQiQavVQigUQr1eRzqdprmDp+1kRYpgX18fZDIZIpEIwuEw/H4/7a70cHpAzKUZDAbNGz2r4HA4+/5YrVYYjUYYjUYYDAYwmUzI5XIYDAbweDyEQiEkk0mk02n6bHabwXxqiqBYLMbAwABGRkYgFArR19eHmZkZVKvVF8qE66G7IB9cPp8PpVIJhUKBoaEhWlT4fD4MBgNNaCcP+dLSEtLpNHWS7/aCzOVyIZfLoVaroVAoMDg4CLlcTj+YBoMBJpMJYrEYcrkcIpEIg4OD4HA4aLVaiEajUKlUYLFYCAaDyGazyOVypyqAl7z2crkczWYToVAIi4uLWFlZQalUOlXX+ocOBoMBgUBAW/DZbPbMzmsZDAaMRiMsFgv9Y7VaIZFIIJFIIJVKAQACgQASiQQsFgtqtRr5fB4mkwmrq6tYWVlBLBbr6nWfmiIok8ngcDgwMzMDkUgEq9UKNpuNXC6HX//61yd9eX/Q4PF4+05McrkcAwMDkEqlUKlU6Ovrg9lsxvDwMLhcLp3tms1mlMtllEolJJNJJBIJLCwsIBwOI5VKIR6P45NPPkG1Wu3avUilUszMzODGjRsYGRnB8PAwFAoFbc+w2Wy6KyeQSCSw2WwAnrr8X7hwAWNjY/B4PFhdXcXy8jLC4TASiUTX7uMwqFQqGI1GnDt3DleuXIFWq0WlUsH6+jo++OADrK6ufmtaoQwGA3w+ny6ocrkcVqsVCoUCLBYLTCYT5XIZxWIR6XQa6XQayWQSwWAQ5XL5RDoQh0GlUuHcuXNQqVRgs9lYXl7GkydPTvqyXhoymQw/+9nPMDg4iMHBQVitVgwMDAD4Khkjn8+j1WqhXC4jkUiAwWBAq9Xij/7oj/DWW2/h3r17+Oijj/Dxxx93NVLq1BRBJpMJDocDLpcL4OmMkCy+PZwsBAIBhEIhHXBbrVa89tpr0Ol0MBgM0Ol00Gq1EAgEtICQUyKPx4NEIoFCoUB/fz8lPbndbrhcLnzxxRddLYJ8Ph8WiwWXLl3C1NQUhEIh2Gw2OBzOvlbu877fYDDg+vXrmJqaglwuR6VSQbPZPPEiqNFoMDc3h/Pnz2NwcBBsNhuVSgWpVAp+v7/rO+xOgsFgQCgUQqVSwWw2Y3BwEO+88w6sViu4XC44HA5SqRRisRg8Hg/cbje2t7eRTqdRq9VOzWlYrVbj0qVLkEqlZ3r0o1Qq8Xd/93cQCAR0cyIQCOD1ehEOhxGJRBCJRNBsNpHJZBAOh8FkMjE1NYU33ngDOp0Odrsd0WgU8/Pzf7hFkM1mg81mo9VqoVgsIh6Pn9nWQCdAigt5rTr9YebxeBAKhZienoZerwefzwefz4fZbMbc3BzUajVUKhXkcjmkUumhu2uSk8bn88FgMKBQKCCRSBCLxdBoNDq6I+dyuRCJRODz+bTQTUxMwOFwwGKxQKvV7vv6arWKarWKZDKJVqsFqVQKiURCX3NyPwKBADqdDkqlEvF4HLlcDhwOBx6P50QXWJlMhoGBAVitVkpCaDabqFarKJVKZ55lTebPHA4HZrMZFosFAwMDMJvNMJvNmJqaQl9fH51HZTIZJJNJKJVKaLVa6HQ6NBoNuN1uJJNJ5HK5E3tNOBwOeDweTCYT7HY78vk8IpHIqSnOLwvS2qxUKsjn8wgGg0in09ja2kI8HkcikUAsFkOr1UIul0MsFqNs7EuXLsFgMEAikUCpVFIWabdwaoog8LQQslgsysLb3d09szujTqD9tCwQCJDP5zv6oRGLxTAYDHj77bfhcDggFArp/EKj0VBHkpd9aEmS9ubmZkeH4CKRCGazGTqdDgKBACKRCNevX4fD4YBCoXjm68vlMjKZDJaXl1Gv12Gz2WC1WsHhcGgRJCBtU6vVCh6PBz6fjzt37pzofFAkEkGv18NgMEAkEj33RHsWwWQywePxIJVKcfHiRUxMTGBychI6nQ4ikQharZa+V61WC3w+HyqVCnw+H3q9HqOjoxAKhZifn8fGxgY8Hs+JFUGRSESJgCaTCYuLi9jZ2UEymTyR63lV1Ot12m1IJBJwuVzY3NyE2+1GuVymUjciMyqXy5DJZDCbzchkMidKBjo1RVAul9OZYKvVQiaTgc/n+1a1cF4UDAYDbDYbQqEQWq0WDocDKpUKGo0GGo0GYrEYlUoFt27dwq1bt4590RWJRBCJRLh69SrefvttfP/734dGo6Ezs3bU63V6ai+VSvSBr9VqAEBZoQaDAWazGXw+HxwOBwqFAmaz+ZniclxgsVgYGhrCO++8g7m5OUilUkilUlgsFgiFQgiFQjSbTaTTaWxubsLpdGJvbw9+vx9bW1tgMBiw2+2w2Wzo7+/H+fPnoVQqafuUzJ2MRiN0Oh3kcjn9XqfTiWQy2dVnVyQSwWKxYHBwECaTCUKhEPfv38f8/Dzu37+PTCbTtWvpBAjRYnx8HCMjI7h69SolZNVqNaRSKdy6dQvhcBj1eh3NZhMikQhSqRRarRZarRZqtRo3b97EhQsXsLq6igcPHmB5eRkLCwtdvRcWi4Xh4cpLoVkAACAASURBVGGcO3cO58+fBwBsbm7i008/PbOdr1gshn/4h39APp9HPp9HPB5HJBJBsVg88nsajQaSySRKpVKvCAJPTx0mkwkDAwNoNpuo1+uoVCpnvoXzMiDzKHK6UigUGBgYwOXLl9HX14e+vj5YLBZIJBJEo1Hs7u7ik08+OfYiKBQKoVarYbfbce3aNVgsFgDYZ8DcarXQarVQrVYp6SCTySCXyyGbzaJarYLBYKDRaKBer4PBYECj0dAiqNVqMTQ09ExRPS6wWCxotVqMjY3h4sWLtAi2gyyea2tr+PTTT+FyueDxeJBKpcDlcuH3++F0Oqlkon3WSdq8hCyk0+lw5coVcLlcVKtVtFqtrhdBhUIBqVQKPp8P4OnC+rvf/Q4ejweFQqFr19IJGI1GjI+P48aNGzh37hyGhoZQKpVQKBQQi8Xg8/nwxRdfYHNzE5VKBbVaDWq1GjqdDsPDw7DZbGi1WhgdHaUnR7K+dLMIkg2uwWDA+Pg4PQkRCctZRaFQwAcffPDS39c+gyfrS7dJS6emCLaj0WggkUhgZ2fnD6IdymAw6OlLq9VicnKSztvIDK1arcLv9yORSKDRaGB9fR2rq6sdaScajUZMTk5iaGgIYrEYAKjgmvhOptNpyrwjg2/ipFIqlcDhcGC322nx4fF4YDKZdGYQi8UQDAY71g4lrSaNRgOJRHJoy7ZQKGBhYQGrq6vY2tpCLBZDqVRCq9WiWkAi5eBwOOjr64PVasXo6CisVisthMDT+anVaqUnEAaDga2trY7c20EwmUy6qSBEnXA4DKfTCZ/PR8kgZxFCoRAikQhvvfUWfSalUik8Hg92d3exvb2NUCiEeDyOlZUVRKNR2n3IZDKIRqMIh8Pwer1oNBqw2WzgcrmQSCSwWCyIRqNdvR9CIhsdHYXD4QCXy8Xy8vKxtkHJ2ITM4SuVCur1Our1+qlhxQJP56KET8BisRCPx7G6uop4PN7V6zh1RZDsBpLJJHZ2dk61M8dxgcVi0TnbxMQEfvjDH2JwcBAajQatVgtbW1vY3d1FNBpFoVBAPB7HnTt3EI/HO1YEZ2dnYbPZIBKJADzdmMTjcXg8HmQyGezt7SEejyMcDsPj8cDv91NSSK1Wo8Wbx+NBLBbvK4LkHoLBYMfaIDKZDBaLhbaPD2u75vN5LCwsYGVlBVtbW6hUKnQnSopgLpdDJBJBNBpFX18fZmdnIRAIMDAwsK8I8vl8qonSarUIBAIdua/DwGQyodfr9xVB4nLj8/koe/WsgWwO1Wo13nzzTUxMTEAgEAAA1tfXcf/+fdy5cwd7e3vI5/P75rGtVmsfiUyr1cJgMOCdd96hxuIWi6XrMzidToeRkRGMjIzA4XAgFArB6XQeGxuS3DOPx4NcLgeTyUQ2m6Utx9MUpcVms6FQKCCTycBkMpFIJLC6utp1lvWpK4IAaJutWCx+a9uhZIc7MDAAlUoFnU5HJQdCoRCZTAbpdBqZTAYrKyvw+/3IZrMoFotIpVIIBoN00HzcyGazCIVC0Ol0UKvVkEqlYDAY4HK5EAqFCAQCWFlZQTweRywWo8NwsgARFqjVaoXFYoHZbKY6vK2tLWxtbWF1dRVOp7NjJBJiIk3md+0gp7tsNoulpSX4fL5D5xLEvaNWqyEcDtMWLzED6OvrowxSYvsnlUpRrVahUqkgFAppYe0kGAwG1WzyeDx6Oo/FYmeyAJJNoVQqhc1mw9DQEMxmM0QiEYrFIpLJJD755BOsrKxgZ2cHiUTia19nPp+/Tx9IHI66xUQkz83AwAAmJyeh0WhQq9UQiUReuQgSQmFfXx/kcjnVvRJTh2w2S9cTv9+PXC6HYrF4Yi1ysrEhHZV0Oo1gMIilpSWEw+E/XMeYdpDTRLVaPVU7l5cFWRyBryQgYrEYfD4fRqMR/f39uHr1KvR6PWVeJpNJzM/Pw+VyYWdnB4FAAD6fr6uMw83NTUSjUbjdbgQCAfzkJz+hLEuxWIxgMIiNjQ3s7e3t20nz+XwoFAqo1WrMzMzgRz/6ESQSCcRiMd2Fvv/++7h37x5cLhe8Xm/H7oGcrMl8rB2lUgm5XA7b29u4devWC/28XC6HXC4Hr9eLTz75BBsbG/jOd76D6elpTE9PU5G2SCRCq9WCzWbD8PAwPTl3CsSeTqVSQa/Xg8fjIZfLYWtrC4FA4NBNEpltEklSO4uUbEBPyg6OtHYnJiYwPj6Oc+fOYW5uDnK5HD6fD+vr61hZWcE//uM/fqPPRLsW9Os0occJMme/ceMG3njjDSQSCdy7dw/37t3D/fv3X/q1ZrPZlKlNSHPXrl2j3AGtVgs+n496vY58Po9MJoNUKoWNjQ34/X4sLy9jaWmp6++xSCTC2NgYXn/9dVy4cAHDw8N4+PAhfvnLX8LlcnW9PQ2cwiLY/iE8Tf3rlwWDwUBfXx+EQiElu0gkEvT399OTn16vR6VSwe7uLhKJBOLxOFKpFHZ2dugpMJ/Pd30jUCgU0Gg0sLOzAy6XizfffBN9fX20pTk4OIipqSkUCgWk02l6vyqVCqOjo5icnMTU1BRkMhkYDAZKpRJKpRKKxSKCwSCdH3YSer0eY2Njh0ohiI4pGAx+458fCASwtLREnUqI7RWHw4FQKKSbnGg02rEiSAogSbtgsVhgMBh04SPzzcO+h8vlQiwWP9MqbjabiMfjlDTS7UWSy+Wir68Pk5OTuHLlCjUBD4VC2Nrawr179zA/P/+NPxOE0NX+pxuQSCSwWq3UM9Pn8+HBgwdYW1uj/rovA+LINDg4iLGxMdoqJvZ+oVAI2WwW4XAYxWKRdkZGR0cxODiIbDaLlZWVrr+/hKg0MzOD8fFxAIDf74fP50MikeiqcQbBiRdBcpQn+p5ms0lFrGetCJIdNmF32u12SiwhPfrR0VFoNBrI5XLIZDI8ePAA29vbcDqdcDqd1GPzJEFkDj6fD81mE7FYDLVaDSwWi/q6TkxMYG9vjzIgiWZuamoK165dg8PhgEgkoicoUuQDgQCVU3QSKpUKg4ODEAqFz/xbtVqlTFYWi/WNFqFIJAIGg4GhoSGq1yTtVwaDAYPBgP7+fmxublKnjOMGk8mkLWqBQEC1i41G48hRApPJpFZjREDe7srUaDSo20oymez6oiQUCjE8PIyJiQnMzs5S38n79+9jaWkJDx8+xMLCwku9X6QV2W6HR0wEOj1uIWsC8dZVqVRotVrw+/14+PAh/H7/N7oXpVKJoaEhTE1N4dy5czh37hxcLhc1CEgmk/D5fHC5XCiXy1CpVDCZTJibm4NIJML8/HzH5EmHgWy8hoeH4XA4MDY2hsHBQfj9fkSjUUSjUeRyua5dTztOvAgSSy3SEqzX63C5XB0jfXQSfD4fYrEYVqsVQ0NDuHr1KhgMBtLpNKrVKvh8PlKpFKLRKHUn2dzcpOy20+bwXyqVEI/H4ff7EQwGaeGWSCQYGRlBJBKhTEgmk4l33nkHAwMD9LRbr9cRjUaxt7cHp9OJzc1NuFwu5PP5ji+uz2t3icVimM1mRKNRKBQKFIvF5+qZDgPJFyRZaNVqlZKIyKLX398PnU6HWCyGQqFw7PfMYrEgk8mg1+uhVqtpZuDzwOPxYDAYMDAwAIfDAYfDQckmwNNRxMbGBhYXFzE/P9/1IqjRaPDWW29hdHQUcrmcspLv3buHxcXFl2YUk00pcQ4ihbBQKCAQCMDj8XTuZgCaT9nf34/R0VE0m03s7u4iFAohnU6/1GaQuB4pFApa+EZHR8FisbCysoJbt25R9jZhbpNZfaFQAJvNpl2JWq3WtUMGh8Oh0V43b96Ew+GAXq/vyu9+EZx4EVQqlRgeHqaGzLVaDU6nE7FY7MxYCPH5fOpGYrVaYTab0dfXh3g8jmQyiUgkQtuGhEhC4kOy2eypLfbFYhHlchm//e1vEYlEKKtNpVLh8uXLMBqN1AiXyWTi6tWrlGjQaDQQDoexsLCAO3fuYHV1Fevr610VAx8175FKpRCLxWg0GvjOd76D3d3dfc4WL7I4ELd/p9OJx48fAwAuX75Mf69Go8H09DR8Ph9qtRo8Hk/H5D5kYSfSE5/Pd6gLh1AoxMzMDK5cuYJLly7BbrfDbrfvm5s2Gg14vV7cunULXC4XGxsbiEajyOfzHbl2ArVaDa1Wixs3buDmzZs0dHV1dRWrq6v41a9+Bbfb/VI0fx6PR7WiExMTmJqaoiSnlZUVfPLJJ3j48GFH78tsNmNiYgIXLlzAhQsXsLKygi+//JLO3V9008vhcNDf308Nqi9cuEBlBVtbW9je3sbt27epSXU7CKltaGgILpcLtVqNdnk6BYVCAZ1Oh76+PiiVSkxOTmJiYgJvvfUW7Y5Vq1XIZDK8/vrrkEgkdEO5ubmJeDyOfD7fFfLOiRdBwqrj8Xhfu4s9rSDOLm+++SYmJyfpYvrhhx9SNhbZ8VWrVdRqNSonOK0FkKDZbNL4I5KhR9pVxE2lPT+QgMhcvF4vVldXEQgETg3TlxQNiUSC6elpAE+LWiqVemnvz1gsho2NDchkMloEga9OaSRLrRPC+Xq9jkwmQyOeQqEQEokEPB4P1Ti2QywWY2JiAufOnaOmzcSwnqBdczg9PY1ms0m1nZ2EVqvF9PQ0xsfHwefz0Wq1UKlU4Ha78eWXX9ITzcucXgQCAUwmEy5fvowbN26gr68PpVIJwWCQ2nptb2938K6eFneHw4HBwUGIRCK4XC48ePAAmUzmpU7ZXC4X/f39uHDhAoaGhqBUKvHw4UM8efKEzreLxeKhBZA862azGZFIBF6vF8FgsKMnQZVKhYmJCVy7do12HgYHB/d1HYhE4q233sLFixcRi8UQDofx3nvvYW1tjc4zO31iPfEieFi//iyA9OUVCgW1qzIajWCxWIjFYnC73XQXTcSqZxXlcpm2/Mj8jJgUA1+duIh7TCaTQSKRwPz8PNbW1qi8oxuvQfuM+bDnqVKp0K8RiUSYmpoCh8OhC9TOzg41934RFItFerJvB9kUtM/rOgEiDCeBxZlMBplMZh8phrBA9Xo9ZeRptVqUSiXari6Xy2g2m2AwGFAqlWg2mxgYGKAevp0GIRhZLBZKziHygc3NTRQKhRdeDEnb0GazYXx8HA6HA8PDw5BIJLQ173Q64ff7O24nR2Z3Op2OFuB2a7cXgUAgwNWrVzE9PQ2HwwGJRIJgMIidnR2sr6/T9/wgiD5SqVRSu0BiMJBIJI71JEhGAETmZbPZ4HA4MDs7C5VKBbFYDBaLRZ818rwRX1er1QqNRgOtVotwOAyVSgWXywWXy4VkMtlRAf2JF8GzCi6Xi8HBQUxPT2N0dBR2ux2NRgObm5tYXFzE48ePqU7rtJ/2vg5SqRRqtRoajQY6ne4Z+zHgKeuuVCrB7/djc3MTOzs7uH37Nk0z75bchWi/eDzeMzNBkk5C3DQEAgEmJyeh1WoxMjKCu3fvolarIZ1Ov/C11ut16pnabZA2F+mkMJlM1Ov1Z15rYlgwMDCAK1euQKPRgMlkIpVKwefz4YMPPqCFn8ViYW5uDgqFAlqtFiaTic46OwmpVAqTyUQzED0eD5aXl7GxsUFbyi8KQvy5ePEipqamaM4gh8NBJBLB0tIS1tfX92lbOwVS3GUyGTweDyWZvUwBkkql+MlPfkKLRDQaxePHj6lG8rATJdGyjo6OYmxsDHK5HK1WCz6fD16v99iJaWw2GxaLBa+99hquXbsGo9EImUwGtVoNFotFGdlOpxPxeBzxeBzVahVqtRqvvfYa9fPVarV44403MDY2hqWlJWg0GmxsbPSK4GkDecMnJiZw+fJljI6OYmhoCJ9//jm2t7extraGJ0+enAjd9zhBopSGhoYwPDyM/v5+aLVaSCSSQ7++VqshGo1iY2MDT548wYMHD2jrtxsgpy+BQAAul/vMSbDVaiEYDNI4JD6fD7lcDqFQCJPJRI1/PR4P9f/8utNHo9GgLe6DIKL8b8I+fRGQLgqRZpATH5FKkO6KWq2mz6vNZqPs0b29PSwvL+P27dv0dMJms9FoNHD+/HlYrVYYjUYolUqwWKyObmKIxlQmk6FWqyEWi2FnZwd+vx/JZPKFfrdEIqHWgzqdDufOnYPdbofRaIRAIEClUkEgEIDT6YTH40E2m+14q00oFFLzeeKr+6KvI0mLMZvNuH79OpWtEHuxYDD4zMyMPA8ikQgqlYqmVNTrdSQSCQSDwY645JB8R7PZjJmZGSpNqlaryOfz8Pv98Pv9WFpaQiQSQTgcRrlchsFggFQqRbPZhFQqpR0LrVZLZR0MBgMbGxv7jPmPEydeBLstWj0OGAwG/NM//RMGBwcxMDBA7cCePHmCL7/8EtFoFDwer6sMrOMEWTynp6fx5ptv4i/+4i8wNDRE//2weyJ2TalUigqaX5Zx+apoj9ppD/glaDQa+Nd//Ve6qEqlUiowNpvNOH/+PKamphCPx/HgwYNvxBolIHpXMtzv1ImDFLtGowGRSEQlG0+ePKG2dT/5yU/wl3/5l7DZbCgUCnC73dja2sKHH36IDz74YJ8kh8lk4s6dO7BYLFR873K5sLGx0VErOGKXSArEQUE/iUdqf/YOit5/9KMf4fXXX8fExATGxsbo/Il0KZaWlnDr1i3Mz893TZTdvra96BpHPkt2ux03btzAxYsXodFo8L//+7/4+OOPsbq6us/0uz3I2mAwwG63Y3R0FFNTUwgGg7h16xa8Xi9isVjHZAiVSgUPHjxAs9lEIBCg5Bcizg8EAkeaN7z77rsAns5PTSYT/vzP/xxzc3OwWCy4du0aLl68iFarhfv372N7e/vY19QTL4JEP3fYkP60gRjTktw2AHQHXS6XMT4+DoVCQRmg77333pmLsGGz2RgcHITZbMbs7Czm5uYgk8noqabRaKBSqdB2CpmtCQQC8Hg8aDQaDA8PI5PJdJx+fhDNZhOlUokGptbr9X1kHeCr5AjiT5jNZiGXyyGXy2katt/vR6lUeuFd52GbuHq9jlgshu3tbbhcLsoOPk6Q+yUGC16vF2azmVrdtc8hyfVVKhWatp5MJo8szu2n2G4YV5DnhSTFE59WMr8Nh8PU+aRYLEImk0EsFkMikUAul0OlUuH69etUh0vuvdFo0PeczJg6rVFtxzcR5QuFQiquHx8fh9VqxeLiIjV6j0QidO4tEAhohqRWq4VQKASfzweXy8XOzg5tJ6fT6Y4T05rNJoLBIBYWFihLPBKJUE3u170GpVIJsVgMn332GYLBIN566y2YzWZotVrMzMwgFoshm80il8sdK2v0xIsgaYNIpdJnFqzTBnI8F4vF0Ov11KORSAlIe5QUwU8++QS5XO7MeDeSnbfNZsP58+cxMzOD6elpOk8grb9CoUCLCJlFkdR5UgRTqRR+97vfdfX6ycyPEHkOs/4iC6LX60Umk8Hm5iZdaDUaDQwGw5FMu8NwWCeDvFaxWAxbW1vY2dnpSBuHFMF6vY7t7W14vV4MDg5CrVZDIpHQtmj79bUXQZJIchjaNz2daue2I5VKwePx0NMncVtis9ngcrnUUmtvbw/1eh0ajYYu/haLBTabDZcvX6bfT4pgs9lEuVxGOp2mxKduF8GXbYmTlu7AwAAtgr/4xS9oEcxms3TmR3JYp6am4HA4UK/XEY/HEQqFsL29jYWFBTo37PQ6RMYNsViMPm+EAf8iv5sYPNy+fRtOpxMmkwlvvPEGdDodZmZm4Ha7Kav1W1UESe9aoVCc+pMgyTlMpVL46KOPKCuL9KpHRkZgMBigUCgwODgIrVZLTa/PwnxQIBDQANm5uTlYrVaoVCoAoLOIeDwOn8+Hzc1NAKDmAFarFYODgzSN3mQyQSKRoFKpdPXeSQEieYtEuA+AzseIlymxcyOo1WoolUqHaq0OQqPRQKlUwuFwYHx8HMPDw/uuIZ/PI5FIUPejToEkdRMThnK5DIFAQP0j2wkFlUqFuohsbGwgEok8cxIknQCpVEojs0jEVCdBTmqEzEFYtWazGVwuF2azGclkEqFQCKlUis4qSWYgOQmJRKJ9bfBcLoednR2sra1he3ubWgJ2C7lcDoFAACKRCM1m84VYwjqdDrOzsxgfH4dOpwOLxaLFTygUQqlU/v/2vvQ3rvO++sy+7xuHs3PfKWqXtURylBh13CQFgiJJURhFWxT51i/50KLf+hcUKAokCOAESBGkQdw2MeLEdirLsVZKpEiK2yycGQ5n3/d95v2g93k81GbZJmeG8j2AAdsixTu89z6/7Zzzw9jYGBQKBRQKBTQaDeRyOXZ3d5HL5fatjyLi+W6NZb4IB4Bsb8nn88hkMlSzS1jWZBfpQTvd9DwIyuVy2Gw2DA4OPtXiqp9ACAUejwc/+MEP9s0wgEcPr91ux1/91V/h+9//Pqanp9FoNJ4wmu43kNaKxWLBn//5n+PNN9/E4OAgTUoikQhlpC0vL2N1dRV/+tOfADxiv5G26Q9/+EPIZDKMjY2BxWLh3LlzVIjebYas2+3GRx99hKtXr+4LgqdPn0axWKSrqTrxLKp5Jwj55tKlS7hw4QKmpqYwOTlJfwbZOrGzs4PV1dWutMPJAl8i73A4HLhy5QoymQyWlpag1+vB5/ORSCTw3nvv4YMPPsDHH3+87+8gB41Wq8X3vvc9ali9srKCtbW1Q2nndmJvbw/hcBgbGxvw+/2YmprC1NQUdDod7HY7ZmZmqPMJ2dLB5/MpO5a0sjvnb+Rdffvtt/Hee+8hGo12PRn1+/24fv06bDYbFAoFHA4HAoEA3cD+eIXE5/Nx/PhxfPe738X09DSUSiVdWm0wGGCz2WC1WnH27FkIBAI0m03a5iUs31KpdGT3Rz4LjUYDpVLpUNymeh4EjyqeJtwlu/JIhUEMivu9zUvmsoODgzCZTFAqleBwOLSVQ4gUi4uLuHPnzr7gUalU4PP50Gg0kEqloFaraWJz4cIFAKBC+V63hVksFp2Zfd4VOjweDwqFAhMTEzhz5gwMBgMUCgU1Libz4VAo1NWN7sQqq1argc/nw2Qy4fz583Qjg0QiQSwWg8fjeao3LRGWj46O4sSJE4hGo3RxbTc8Hcmzkc/nKfORUOTJLkDSBqvX69QXlrTgzWYzjEbjPu1qMplEOBympIxuE7WAR2b08XgcAwMD0Ol0WFhYQKVSgcvlgsfj2SetYbPZkMlk0Gg0lNRE/HqvXLlCpT/NZhOrq6uIxWJ09EL+vVwuH3lJ1tNQqVSodvSg72PPg2AnxbzVah0Z15hnHegsFosO44lpbL8zX4VCIfR6PSwWC0wmE8RiMW0XFotFbG1tYWVlBcvLy1hbW9v3klWrVYRCIWSzWUSjUYhEImi1WhiNRtrH5/F4n1kb9UVB2qJkFkPmYqRtplAoIBKJXqjNx2KxKENRJpPBaDRicnISMzMzEAqFdPZG2uXlchnhcJgSbLoBkimTA0Kj0eD48eMYHByETqeDWCxGpVJBOBxGqVSiDERiqE3c/WdnZzE+Po5kMgmv19u1IAh8MuP0er3wer20fa3VaikLu1QqUdIRIWQ5HA7weDwqRQBAXXSCwSD15u0FCoUCwuEwLBYLuFwuJiYm0Gw2wWazkc/n97XeuVwu3TxPZrpknOBwOGjlS/Z5bm5uYmdnB5VKpW/cmL4IiORHJBJBqVRCKBSCxWKhXq9TA47D6Kj1PAgSEeXg4CC0Wm1XhLmHBYvFgsnJSQwODkIikdCN5P1kiv00KBQKjI2NYWZmhjpblEoluN1urK+vU9H70zbBd1Y/a2trYLFYtDXF5/Np8CBBqFuzCULgIfNaDodDmawWiwXHjx9Hq9V6Ie/Izt2EJpMJs7OzmJiYoP6WnZsJiMVYOp2mNmzdQueKKGLbxmazIZVK95kvE+9UmUwGuVyOY8eOwWQywWKxwGq1olqtIhqNwul0wufzHbpl2rPQSYBoNBr0QCTBkrRByazMbrdTy7V2uw2fz0ct5HqFdDoNp9NJ27Zzc3M4ffo0VCoV7Hb7E8uchUIh7HY7ZDIZCoUCgsEg/H4/3n33XZq0EM/aRCKBSqVypN2oOiEWi6FQKHDy5Ekq82Cz2QeyePh56HkQzOfzCIVCiMViGBoaOtJB0Gq1YmJigm6HJy2Kfs/SyAbvmZkZ6PV6VCoVxONxLC8v45133sGdO3eozdHTghiRTTx8+BByuRxWqxUSiWTfaqFuV8NEo1etVlGv12mWKZVKKf2+Xq9/ahBksViQSCSwWq2Qy+UYHx/H5cuXaRDsBAmCxWKRGqR3E6TqCIfD1PFFLpfv83YlciSpVAqDwQCTyYTXX38dVquVtrJJENze3obf7++p1pVUt4SNTK5lb2+PdlrK5TL0ej3Onj0LrVZLuwCkouymafvjIM8BmWOdOnUKJ0+ehN1ux9zc3L7dqeQ9MhqNkMlkiEQi2NjYwOLiIn71q1/R9498bTf3IXYDIpEIOp0Oly9fpjpBDoeDWCyGra2tQ3ufeh4EyWFF2hz9iDNnzuDixYtot9vY2dmhOh0CskD1m9/8JgwGA9bX1/Fv//ZvWF9fRzwe7/ks7NNQLBaxt7cHr9cLrVaLUqmEzc1Negi+yFyr2Wzij3/8I1gsFnXoIHOzdDq9b41SNxCNRnH79m0YDAYIBAKYzWYMDg6Cy+VibGyMVoNsNpsGjs77xOVyIRaLIZfLce7cOXzzm9+EUCik9k6dRsDk8+/t7eHGjRu4ceMGVlZWuvI5O7G2toadnR28//77uHDhAv7mb/4GU1NTlE1ns9nwT//0T1TAT3b1KZVKmqzk83n867/+Kx48eIBYLNY3h+zj71Cz2YRSqaQzT7LVpNlsYn19Hevr6/j5z39Ot4P0Eq1WC3t7e4jH41hcXIREIqEEl1qthp2dHaTTabr5g1TtpLX+OIu5H0AkKtVqFZFI5HMlGgKBAAMDA3j99dcxNzcHu90Os9kMk8mEVquFjY0N/OEPhUiLHgAAIABJREFUf8CdO3fw9ttvH9p97HkQFIlEUKvVlFzQj1AqlbS6IWytTpquUqmEVqulbhwbGxu4d+/ekdEIPq5lEovF0Gg0UCgU1LbocacOYtNFfDiFQiFsNht0Oh01jOZyudBoNLBarYjH4/D7/V37TM1mE9FoFJubm5DJZKjX61RXRQgGjUZjn66z8zMSHRYx2bZarXR7eycajQbd5rC2toa1tTWsr68jGo127bMSEFstLpeL9fV13Lp1C8lkkiYAIpEIRqOR0thrtRoajQb1kiQV18rKCkKhUF93MIiuc2JiAiMjI9Dr9XT2HIlEsLKyQgX2/QDynBSLRbrPkBg6ECPvbpGoDgKDg4M4efIk1agGAgEEAoEX+l4y8zMYDFTfSVa0SaVSRCIR6vG6vLyMzc3NQ51L9zwIKhQK2O32rhn1fh4IBAIoFAqYTCbqct/Z3qvVaqhUKrh//z5CoRDdFN/Ph0gniN8gYaOR+ZfP54NarQaXy9032yKzNeJsodFooNfrsbCwgKmpKRiNRkgkEjQaDcjlchiNRlptdBPJZBJLS0t0o4JcLqdOKu12GzKZDOfOnXvqHkFChuFyuVCr1XT+9zhI+9Pv9+Ojjz7C6uoqXC5XT5iIBPl8HltbW/jtb38Lg8GAy5cv4+rVq/u2z5NddIFAAGtra4hGo5RlSPR0/UyzJ5KekydPYmpqinpVEsH28vJy3waVdruNVCpFGdNHRUfcieHhYbz22msAQGU0LxoEicB/enqa7rdUKpVUl0rE8p1bJA4TPQ+CfD4fUqkUEomk64fki4JYcSkUCspIe/zPM5kMlpeX4XK5aCbTL62kTwNxBiHVgUgkotuwR0ZGqNktgUAggFarhUKhoOtTBgYGcOLECQwODlINFyExvKhjxEEjl8vB4/GgWq3SWRghhhAD7U6R+4uAzGFIFUXMgDc3N3Hv3j34fL6u+VI+C4QFWi6X6UZ14nBE0Gq14HK54HK5cPfuXezt7SESidBlpv0MNpsNg8GAoaEhzMzMYHh4GHK5HMViEdlsFsFgEC6Xq+dt0OehWCz2bZB+ERBNKTHTFwqF2NraohtVOt93klCSrhHZvjM7O4vR0VEIhUKk02kkEglEIhHcvHmT7hPsxjna86jTuY+NeN/1G1wuF373u99BqVSCx+M90RKrVCpUmJtOp1/IcaSfUK1WqabKZDKhVCpBKpXCarXi1VdfhcFg2FfZEEo9cf2XSCTUSk4qlVINXq1Wg8/nw82bN+F2u7teHRGiQSKRwPLyMm2pjIyM0MWknxUkAMZiMWSzWaysrODBgwfweDw9ZyJ2XmOz2aTC8tu3byOdTu9bgUWqkVQqhWAwSMXbR6F7wePxcPbsWUxPT1NHIIFAQH1afT4fSqXSkRhFHFV4PB784Q9/wMTEBEwmEy5fvgy1Wk3JSJ3PEZfLpf68DoeDrmSTSCQoFot4++234fV6kclkntgs341zlPW8H8JisQ79ChwOB0ZHR3H27FlcuXIFJpMJ//mf/4lbt27hxo0bRzpbOiog1nVGoxEOhwPf/va3MTc3B5lMBh6P90S7hgjGxWLxPh1kpVKhlkfpdBrLy8u4du0aPvjgA/p39CI5IJmoQCDAqVOnMD8/j5MnT8LhcFARNlnlolAoqN0UqfaAT1iJuVwOgUAATqcT+XweTqcTLpcLmUymb4ldLxsUCgV+8pOfYHR0lG4rbzQa+MlPfoL33nsPHo8HHo/nyLUYjxJkMhmVM3z961/H7OwsWq0WAoEAdnd3oVAo6JokYP9WkEwmQw0MAoEA/vSnP2F3d/dQ2+/tdvuZ9PSeV4JEQiCXyzE2NgaRSIRMJsNkcl0ECVDJZBI+n4+6oDgcDvrvj8/LiGaJoN1u04pyd3cXXq8Xv/vd7+DxeKiNU6+qY+Kv2Ww2sbGxgUajQXfWLSwsUJE7MQrweDzwer0olUqUlUfaoIR0sb29TSUR3VoYzOAROBwOrQC5XC69D36/H6urq8jlckxCcsgoFAool8twuVzQ6/W0y0OMTzQaDWZmZigRi2imV1ZWsLm5ifv371Nj+V7Pn3seBKvVKrLZLNxuNz7++GN4PB5sbW0hFosxB0uXQIIECQ4PHz6EUChEOBzG6OgohoaGaNUnEAhowCyVSsjlcrTyIxZRkUgEoVAITqcT6XQajUajLxKaVqtFKzkASCQSVMLSbDah1Wqh1+spUaRSqdBqggTBVCpF1xAx6C5EIhE0Gg3sdjt0Oh2kUik4HA4qlQrS6TTi8Tit4PvheXuZQUwyEokE1tfXn3gfMpkMkskk1Go1tVRMpVK0Xe31ehGPx3t09fvR8yBIDkgiahUKhUgmkz3PDr6MIMFwY2ODrq1JJBLg8XgwGAx05yPZ0E2c6gmTi7ilEDsociD1UzJTrVYRi8VQKBTg9XqxsrJCAxyRTpDNIEQ2AnzSDq3Vaj1lfn6ZIZVKMTo6ivn5eahUKmpZR3wl0+n0Ew4sDA4XmUwGW1tbT+wOXVlZgVQqBZ/PR6vVQq1W26cJ7yfyVc+DIBniv4iDP4PDB2n5RaNRBINBLC4u4ne/+x2tBAnrkwyx8/k80uk0MpnMviWs/QpCSWcC2dGDVqvFxYsX8dprr9GVSe12G/l8nppYMG3Q7oJoU48yeh4EGfQfOlt/pIXBgEGvQZY3i8ViRKNRauJANkUwJDoGnwdMEGTAgMGRQDwex7Vr1+iSWhIEicyjX2ZMDI4Wei6RYMCAAYMXATFB79zcAXxi+0dMpRkweBzPk0gwQZABAwYMGLzUeF4QfNIMkQEDBgwYMPiSgAmCDBgwYMDgSwsmCDJgwIABgy8tmCDIgAEDBgy+tGCCIAMGDBgw+NKC0QkyYPAMdBqFs1gstFotSsdnqPgMGLwcYIIgAwZPgUAgwMDAAIxGI8xmM1QqFeLxOILBIHZ3dxGNRnt9iQwYMDgAMEGQAYOnQCgUwmaz4dixY3T34NbWFpaWllCpVJggyIDBSwImCDJg8P/B4/EgEAgwOjoKq9WKyclJTE1NYWJiAnq9HvV6HalUCpubm2Cz2cy2AgYMXgJ0PQhyuVxqgku2kxMn8kqlgkqlgkwmw8xcGHQNXC4XXC4XNpsNQ0NDePPNNzE+Pg6NRgOVSgU+n49CoQCj0YjBwUGoVCrweLwj757/aSDzUDabjWaz2dfbQY4q+Hw+1Go1XeMlFAohEon2fU2r1UK5XEaj0UCj0UCtVkM+n6fnJjOj/mLoehCUSCQYGBiAxWLB/Pw8rFYr4vE4YrEYotEowuEwHjx4wLx0DLoCNpsNkUgEqVSKmZkZXLx4ETMzM9DpdBCJRODz+eBwOCgWiwiHwwiFQkin0y/9rksOhwMej0erY2b91OFAoVDgxIkT0Gq10Ol0GBgYgMlk2vc1jUYDe3t7KBQKKBQKtBsRj8eRTCbprj4Gnw9dDYJsNhsKhQIOhwNzc3O4fPkypqamEAgE4Pf74ff7sbOzg3A4TF86svGcQf9DLBaDx+OBy+Wi1Wohm832fcuQx+NBqVRCr9djenoaFy5cwMjICPh8/r6vK5VKNEkjuxOPOjgcDjgcDgQCAWW/Ao9+J3w+HwKBAGKxGGKxmK7VIu/jy54EHDY4HA64XC70ej1OnToFk8kEs9mM4eFhjIyM0K9jsVio1WpwOp1IpVLIZDKIRCLgcDjw+/3g8XjIZDLIZrNH/p6QxEssFoPL5dLgXq/XD/WzdS0Islgs8Pl8DA4O4uTJk7hw4QIcDgcUCgUAQCaTwWQyYWxsDBqNBj6fDzs7O3TDOYP+BovFwpkzZ2A0GjEwMIBCoYBf/OIXqFarfZulcjgcqNVqTE5OYnZ2FtPT09BoNOBwOPu+rtVqoVgsIplMIplMolKp9OiKDw4sFgtqtRparRajo6PgcrmoVCpoNpuwWCwQiUQQCoWQSCSQyWQIBALY29tDMBhEKBRCKBQ68odur0B+9zqdDgsLC7hw4QLkcjkUCgVUKtW+r22322Cz2dDpdJBKpdDpdDAajVAoFAiHwwgEAtjY2MD6+jpCodCR7p6p1WqYzWZcvHgRarUaXq8XOzs7CIVC8Hg8h/ZzDyUIkpUnSqUSEokEOp0OBoMBWq0W58+fx9mzZzEzM0O/XqFQwGq1AnhU+p8/fx47OzvY2dnB3bt38bOf/QyVSoV56foUJMH567/+a0xMTMBmsyEajcLpdMLn88Hv9/fdzILFYkGlUuH111/HmTNncPbsWWi1WqjV6n1BsNVqYWdnB3/84x+xvLyMra0tJJPJHl755weHw4Fer4fVaoXNZoPNZoPVasXU1BR4PB6KxSLq9TrMZjP4fD54PB5tFScSCcRiMTidTjidTrz11lsMQ/Zzgs1mY3JyEhcvXsSpU6dw5coVAI/OvmQyiQ8//BCJRIImW+QsFQqFEAgEUCgUuHLlCprNJtLpNH7/+9+j1WohkUigXC738qN9IVitVnz1q1/F3/3d38FgMGBxcRF3797F7du3j14QZLPZ4PF40Ov1GBgYwPT0NGZmZmCxWDA3Nwe5XP7M7yXZuUgkwtDQENrtNn7961+j1WoxQbBPQe73+Pg4bDYbFAoFqtUqJiYmUCwWEQgE+ipDZbFYYLFYUCgUOH/+PCYnJ2G1WiEUCsHl7n8lms0mPB4PPv74Y6oPPKqzMR6PB4vFgosXL+L8+fMwGAwwGAz0fSStTlJ9kO9hsVjQ6/VQq9WQy+UwGo14++23mSD4OcFms2E0GjE3N4ehoSG6HLheryMYDOL999/HxsYGUqkUgEea1eHhYSiVSlownDt3DnK5HGq1GiqVCgqFgt6zowrSDZRIJGCz2RCLxdBqtZBKpYf6cw8lCEqlUhgMBpw5cwY2mw0jIyMYGxuDwWDA4OAggEeHS6FQQKPRgFgsptk3i8WiA3mFQgG73Y6hoSF4vV4Ui8XDuNwXBpfLhUAggEwmw/z8/DO/jiz8/DzVTzQahcvlQrVaPVKz0E4nFRaLBbFYjOHhYfh8vn0LUPsBpMLR6/WYmJjA4OAgpFIpPUTq9TpKpRJisRjC4TDu3bsHp9OJdDqNQqHQt+3dxyESiWglJ5VKodFocO7cOZw8eRKzs7OQy+WQy+WIx+PI5XLI5/PI5/NIJBIAHt1T0qKy2WwQiUQQi8Xg8/l9d09fBOS5JBUVIT3VajU6B+VyufQzcrlcFAoFlEoluFyuA03CxWIxNBoN5HI5Go0GSqUSEokEtra2cO/ePbhcLuRyOQCPntdsNguFQgGZTIZgMEilPAqFAq1WC1wu90jeE+BRG1StVmN4eBgmkwlCoZB2lyQSCQQCwaH+/EMJgkqlEjMzM/j617+OsbEx+rJ1Un+bzSZisRhKpRIGBgbon7HZbHA4HHpDtVot5ufnkcvlEAqFDuNyXxhCoRBqtRpDQ0P4x3/8x0P5GTdv3sRPf/pTpFKpIxMEm80mGo0GQqEQFAoFJBIJhEIhhoaGsLS01Hcvp0gkglarhdlshsVigUwm23eNRAx/69Yt3LlzB263G5FIBNVqFfV6va+q2udBpVJBr9fDZrPBbrfDZrPhlVdegVarhUajoUHA6XTC6/UiEAggGAzC6/VSkszExAQuX74Mg8EAPp+PXC6HcDh8ZBKBTnC5XKhUKuh0Omg0GipNSKfTNMBIpVI6c+Pz+QiFQnQOmslkDuQ6iB0fl8sFm81GtVpFIpGA1+vFysoK1tfXkcvlaNBls9nwer00ULvdbtRqNZTLZYyOjqJQKBzIdfUKVqsVc3NzmJ+fh8VioUGPy+XSZ/QwcShBUCaTwW6349ixYxgbG0Oz2aRVAqlw8vk8dnZ2EIlEYDabIRaLATzSzdhsNqolVKlUmJiYgMvlgtPpRKPR6PohRB5YlUqFkZERHDt2DK+99tozv/6LVIIcDgcff/wxXC4XarUa/d31O5rNJjKZDK3uiRTm8QDTa3C5XCiVSqoJ1Gq1NItutVpotVqIRqNwu924f/8+PvzwQ8rKOyrg8/mQyWQYHx+H1WqlnRiHw4ETJ06g3W6j3W7Tqm9lZQVbW1vY2dmBz+eDx+OhpBixWIxcLkff31wuh2AweCQ0kiRokMpPIpFgeHgYg4OD0Ov10Gq1EIlESCQSUKlUUCqVkMvlsFgsNED6fD54vV786le/OtBrq9frKJfL9B2v1WooFApUKvb4Gdc56yNaa6vVCq1Wi3K53Hcz9xcB6fpZrVbMzs5idHQUOp0OXC63qwXAgQdBNpsNqVSKwcFBiMViVCoVJBIJpFIp2veOxWLwer344IMP8M477+w75DUaDX74wx/i5MmTOHXqFPR6Pb7yla8gmUzSanBvb6+rN10qlUKpVOKrX/0q3nzzTVy4cOHQAtOrr74KHo+Hn/70p/jjH/+IbDaLfD5/KD/rMEGCjVAo7PWl7IPFYsGFCxfw2muvYX5+HgKBgLZys9kscrkcfvSjH2FxcZFWR0cFRNg+OTmJ73znO/jud79LKz4y26vVami1WqhWq/jv//5vvP3221hcXKRt3kajAS6XiwsXLuDq1atYWFjA+Pg4lEolqtUqvF4vPvroI9qq61ewWCxMTExgbGwMc3NzmJ6ehtVqxcTEBEQi0RPVBTlPWq0WDUDNZpPOuSUSyYFdW7PZhNfrxYcffohyuYxvfetbGB0dhUqlgs/nw7Vr1xCPx5/JQm40GvRcKBaLVDB/1CCRSDA0NIRz587h2LFjNPkAHnVjUqkUgsEg0un0oV7HgQZBwgoljNBMJoO9vT24XC5awrdaLeRyOSSTSXg8nieCWaVSweLiIs3I9Ho9ZDIZhoaGcOzYMTSbTQSDwSOZ+bzsIO3Cfr03LBYLg4ODMJlMMBgMUKlUaDabdB7mdrvhdDqxsrKCvb29vj/oO8HhcDAyMoKpqSnMz89jYWEBCoUCAoGAzt9TqRSWl5eRTCaRSCSwtrYGj8dD9bitVgsCgQBXr17F6dOnMTc3B6vVCplMBp/Ph729PWxubiIQCPRtO5QQnhQKBb75zW9idHSUynaUSuUz55nlchnlchmxWAzr6+tUp0xcWQ7yWWi324jH49je3qYcCRaLBZFIhNnZWZw7dw5LS0uIxWIol8tPnUWWy2UEAgGIxWJ4PB4EAoEjRxwUCASw2WwYGxuDyWSi92d3dxe7u7uUHep2uw/1Og40CJJMVCwWQ6fTIZ1OY2NjA3fu3MGdO3cosYWIH0ul0lOD4J07d2A2mzE9PU0H+0NDQygUCgiFQoxvY5+CBMF+vTcsFgsmkwmDg4MYGBiASqVCq9VCJpNBKBTC0tISPv74Yzx48ADZbPbIzP6AR0FwfHwcb7zxBk6cOAG9Xg+lUgk2m00rht3dXfzmN7+By+WC1+ulNoWdiYtAIMBrr72GqakpTE5OUsnIvXv3cP/+/b4Pgmw2G0qlEhaLBW+88QbGxsaogQMRqD8eBNvtNsrlMtLpNJxOJ37zm98gkUggmUyiXq+jVqshm80e2DW2Wi3E43G0222MjIzsI5PNzMzg3LlzVO7QbDafGtxKpRL8fj/q9TrVbx4VDgEBaemOj49jcHAQIpEIbDYbu7u7WFlZwZ07d3D9+vVDZ2MfeDu0c+hbr9eRz+eRTqcRj8eRz+f3zV6edlg2m01ks1mkUikkEgloNBooFArodDpYLBZoNBoIhcKuDoNJu4wE7mKxeKDtkX4Ei8WCTCaDQqFAPp9HoVB45j0DHv2OwuEwbDZbXx+QWq0WKpWKMgAbjQb1qyXGDJ2khKOCVquFQqGAeDyOcDiMVquFZDKJYrGIeDyOSCQCr9eLhw8fIhwOIxaL7ft+4tRhNBoxOzsLs9lMmYupVAobGxtYWVnB7u5u32jRSOdJJBJBJpNBq9VCIpFgZGQEIyMjsFgsTxWfk3eZzOEePnyIRCJBySkPHz6k3QFC+jroAFMul2k3bHV1FSaTCVqtFnK5HHNzc6hUKhgYGMD29jYCgcAT96tSqSASiaBUKiGdTiOXy1Fij0qlgkAgQKFQQDgcRj6f76vEVCAQQCqVwmw207kmGZtUq1Xs7OxgfX2dvouHnYweqmMMyWI6/yGamOe1zMjDmUwmkc/nwefzoVKpYDQaoVKpIJFIUCwWu9Z2a7fbaDabqFaryOfzyGazL3UQJIeLRqPByMgIfD4fPTSeFwR3d3cxNDTUl6QJkpwRWrpAIACbzaZkrUKhgGw2i0wmc+QCIPDoXQuFQlhZWUG1WoXdbkez2UQ4HKZ2hNFoFLu7u0+dNQkEAuh0OtjtdoyOjkIul4PP5yOVSmF3dxdra2tYXV1FIpHom98Ph8OhZ4PNZsPs7Cx0Oh3Gx8cxMTHxRAAEPnmXy+Uycrkc9vb28F//9V+Ix+OIx+NIp9MIh8PUGo6cVQcdRAhB0OVy4caNG7hw4QJ0Oh14PB6mp6dhNBphs9kglUrRbrefGgSj0ei+apUYIIyPj0OhUCAYDOLmzZsolUp9FQRFIhGMRiOGh4eprpjD4aBaraJUKsHj8eDhw4eIxWJdue4DDYLkASsUCohEIrDZbBgeHobb7YZIJHpmf7sTYrEYFy9exNmzZ3H8+HGYTCYqxhYIBODxeHTTd7eCIHFwX15eRq1Ww+bmJv7lX/7lU78vk8nQWQOpjqRS6T6t0mHTfz8PiH/h8ePHcebMGfzyl7/Ehx9+iHw+/8z71263kc1mUSwW+64tw+fzodVqMTAwgDfeeAMWiwVKpRKNRgPhcBhOpxOLi4vweDxHdoNJu92G3+9HMpnEnTt3IJPJ0Gw2USwWUSgUkM/nUavV6LtELLrUajX+4i/+gv5OiPA6Ho8jFAphfX0di4uLeP/99xGJRHpubE/0Y7Ozs5iamqImHHq9Hnw+H7VaDfF4HDdu3EC9XodKpQKLxUKj0UAkEsHKygoikQgl68Xjcayvr9PZX7PZ7Mr9J79Ht9uNt956CysrK3R35enTp6HX62EwGDAzMwO3240f//jHlL0rEAiowYPZbIbRaITRaES9Xkcul0MikUAkEkEgEEAikeirtj6Xy4XRaMTp06dx5swZjI6Ogs/n02Q0k8nA4/HA6XSiUql05V4ceBBstVq0vTQ2NobBwUE6mGaxWMjlcuBwODSQPd6fVygUmJ2dxfj4OBwOB+Ry+b5sgLRau0m7Jw9sNBpFq9X6VGcG8ntIJpNIp9PIZDIolUpgs9kYGBiAVqsFADqn6Bew2WwIBAIMDQ1hfn4eMzMzGB4ehkwmo5qm56HzvvYTOBwOZDIZDAYDhoeHKQOtswJMp9Oo1Wr79KpPA7m3nYlNL/A0GQ5JuOLxOP0aMqfncDgQi8U0CROLxXQ2+vrrr8PhcFBNFmFvE5LQ0tISIpFIz9vcxKxCLpdjZmYGZ86cwblz56jLSCgUQjgcRjAYxN27dyEWi2EwGMBms1Gv17Gzs4Pr16/D5/MhFovR97KXqFQqlDSYzWYhEokwNTVF7dGUSiUMBgPu3bsHLpeLcrkMsViM2dlZjI2NYWRkBFarFRaLBR6PB1tbW3C5XHC5XPD7/Qc6yzwICAQCqFQqWCwW2Gy2fe5hhICUz+dRKpW6FrwPJQiStiFx5Thz5gxEIhF8Ph/cbjeUSiVkMhl1qu+ESCTCiRMnqGiSHEZCoZD2u3U63VO1NP2AVquFWq2GSqWCpaUl+P1+7O3tIZvNQiwW49SpU5icnASbzYZQKHxiW0EvQA5LpVKJsbExXL16FZOTk6jX67h9+zY2NzeRy+We2+ZksViQy+X73H+OAohNn8PhoDMxuVz+TGkHmQvfu3cPbre7Z1WvUCgEm82mLvtPAwl2hC2pVqsxOjpKxfJkhmQwGGhXolqt4p133oHX64XX68Xu7i7C4XDP3zXS9rTb7RgeHsY3vvENWK1W6PV6KnMJh8PY2tqi/qa1Wg1SqRQsFov6bO7s7CCTyVCf1H5AtVpFPB4Hi8WCUCiEyWTC1NQUNBoNndVeunQJZrMZExMTkEgkmJiYgFQqBZ/Ph9/vx/r6OpaWlhAKhRAIBBCNRvtS26rRaGAymTA0NASHw7GvZZ1Op7G1tYV4PN5VffSBzwRJWZvP5yEUCqkj/cjICLa2tnDr1i1aHYrFYshksv0XxOVS5h5Z8UIqDJlMRl0w+vWg7fz8y8vLWFtbw/r6OlKpFNRqNcRiMdRqNaRSKd2g0WuwWCyq61tYWMDVq1cxNDSEmzdv7guCn9aaIEHwcf/NfgaXy4VGo8HQ0BAGBgZQLpcxPDz8zHtTLpeRSqWQTqfh8/m61j57HMTnlGhvnwZizUXW9FitVnzlK1+BxWKB2WymnRjyfgFALpfDO++8A5/Ph2AwiGKx2BdLW0lLe3Z2FqdPn8Y3vvEN2p0g3INQKITt7W04nU643W6sra3t60p0Wvv1+vN0ggTBTCaDTCYDh8NBPTNJBX/p0iVMTEwgHo9DIpFAr9cjm80iEolgfX0dd+/exbVr15DL5SiRp58+IwF5HoeHh+FwOPZ1XNLpNLa3t7vewj2004rQfjkcDmXkWa1WXLx4kW7yJq2aJy7q//9ZZ6Aj+p9vfetbuHTpEn7wgx9ge3sb6XS6a2y1RqNB20337t2DwWDAwMAAeDwe/ZparQa324319XX8+te/RjgcRrVahUqlwvz8PL72ta9hYWEBcrl83/f1Enq9HpOTkzh27Bi++tWvQqfTIRgMYmtrC2tra9DpdDh27BhmZ2cxOzsLDoeDTCZDWYbZbJY6xZC5Sj9BJpNhdnYWFy5c2Ffh8fl82O12mM1memi0223weLxnJllETD0/P49EIoHr16/j2rVrcLlcXV351Wg09gm7gUddFLlcjrGxMVy6dAlXr16FUqmEWCyGSCSirink/SKroWKxGMRiMZ0L/sM//APeffdd/Pa3v+0LrSSbzcY///M/0w6R0Wik97HdbsPj8eCjjz7CW2+9RWdJ3ZonHRRIBy0UCuGtt97Cu+++i4sXL+JKWrrxAAAZ8klEQVRb3/oWTp06BYFAgMHBQdre9fv9eO+993D9+nW43W54PB7K4O5HkPP8L//yL3HixAlYrVY6OikWiyiXywiFQvD5fF23gTuUIEgGtOl0GtlsFgKBgBrWfpojeKvVQqlUAp/Pf2K+xOFwoFKpIJPJcPLkSQgEAng8HkQika64qpAgmEqlcO/ePQwPD6NWq+07WMvlMtXtdM4cyAZzmUz2XFNYolciGqHDfpH5fD50Oh0mJiaodx+xx+JyubDb7ZBIJLBYLJiYmMDExATVnsViMaRSKdrDFwgEMJlM+zxiew3SYjIajZiYmNhXpRKSxedpSVssFuh0OuRyOZTLZUgkEqRSKaqVPGzU63VaBQGPPovBYMDo6Cjm5+dx/Phx2jojlV6tVqNLgTOZDJUFpFIpKJVK5HI5yjAcGBiAXC6n7MNeHa5KpRJKpRKTk5MYGxuDSqWicyQiX0gmkzQJOWx3kcMGMfAmXsscDgfNZhOVSoUunSXFhUAgoO9auVzu2wAIPPpcPB4PBoOBWtIRpFIpGgCj0WjX2eWHEgQrlQpllxEWGqn+Pg3NZhPJZJKabj9eDRJ226uvvgqVSgUej4dms9mVINhsNumGcbLzq1Qq7Tv0q9UqfD4fpVl/VhBvRsLEPOyqSiwWw2QyYX5+noqsibia7H+0WCwYGBigbu+EaGAymVCpVCidnOw965c2L4B9c5bp6ekDa6MTEsn4+Dhtca+urtLE77BBAi05+LhcLhwOB77yla/g+PHjsNvtkMlk4PF49P6kUincvXsX29vbcLlcyGazyGazKJVKMBqN1JrwxIkT1EtTIpH0bHMGWTlEdlRqNJp9hyfx30wkEvD7/X05A/ss4HA4kEql1PWHSD4A0PGSUCikrlxDQ0O02DjoLRcHic6gLZVKIRKJ9sUCwtrd3NzE7u7uyxEESWm7u7sLuVwONptND8ZO7WCtVqPtJ0IoKRQK2N7ehs1mow4PxGQWAN14PTc3BwDUtHlnZ+cwPso+kGvMZrNYWlpCrVbbxygEHr2Y4XAYkUjkcwVBMmtKpVLP1eUdFAhr0uFwYHh4GFwuF8ViEVwuFwaDAWazmRoNE5NswtLj8/kQiUSU4ERWoACg5KBeyiVI+89gMMBoNMJkMgEAffYAfG69J0nqBgcHoVar0Wg0oNVqUa1WuxIEH0+OiOMIIb0IhUIqVyEWYKFQCHfv3sXq6ioePnyIUqlEK4hoNAqhUAiRSITLly9TZqJEIkGlUulqECTGyiKRCHa7HQsLCxCJRDQp5HK5kEgk+4TvvX7WvghIkCAJ6bFjx3DixAkYDAbUajX4/X5Eo1Go1WpoNBoaSMxmM2q1Gvb29rCzswO3292XGl3gUdJIKtzHeQPpdJr69PZie86hBMF8Pg+/3w+n0wmJRAKJREIPILI2hGyqJodHuVxGJBJBOBzGgwcPcPHiRVy8eBEcDgfhcJjO/ex2OxwOB13AODMzg2q1imvXrh3GR3kqms0mUqkUNjc3kUgk9t1Q4tzxebPnWCyGjY0NxGIxVCqVQ68E1Wo1nRuRWZFKpQKbzaZzMrfbjWg0ing8jmQyCYVCAaPRCOBRUkKITlarlcpX6vU6otEoCoVCz2YzCoUCIyMjWFhYgMFgoP8/n8/ThbCTk5Nf6GcQR3+5XA69Xt+zdlyj0YDf78eNGzeQSqUwMjICoVCITCaDZDKJVCqFaDRKPSkJO5IkWfV6HdlsFolEgiY3ZCVWt4lOPB4PGo0GBoMB09PTOHXqFAKBAEKhEJV5TE1NUeakVquF3W6HUqmk8pCjBB6PR5PR06dP45VXXoHZbEYmk8G9e/fg8/mws7OD8fFxKh0j7FEAOHPmDPh8Pt566y0kk8m+IDJ1gkiviKtPp4crYe5Wq9WuJP1Pw6E83STz9Hg8UKvVMJlMtH/v9Xpx/fp13L17F/F4HLVaDSqVCtVqFdFoFIlEAru7u3A6nXjw4AFYLBYikQjK5TI4HA6OHTuGhYUFfO1rX4PD4YBCoYBer8cvf/lLKgw+7Aeg3W7TuYrL5TrQvzsej1OacDeybyKO7mxRkJZzMBjE9vY2fv/738Pr9VI/RZlMBr1eDwBUb2Y2m/Hmm2/CYDBAqVSiXC7D5XIhmUz27IUkxuujo6P0wCCf72ltUeIY4/P5kMvlUCqVUKlUqJk72ZVIXmjiSUkEwGfPnkWhUIDH4znQz0Gutd1uU1YxCerxeJx2DdxuN8LhMG7fvg2TyQQOh0M3Y+RyORSLxaeODeRyOXQ6Hd00T+akRMLT7Y3lIpEIDocDs7OzOH78OGZnZ/HjH/8YwWCQ7oIcHx+ncya9Xo+xsTFotdojFwSJ8P3EiRNYWFjA/Pw85HI5Hj58iOXlZcrOJuYjdrsdp0+fxt///d9TVrNarcaJEyewsbGBzc1NxGKxviA0EQgEAoyNjeHkyZMwmUx0pluv11EoFKh0LhqNPnNzxmGiqykecei4f/8+3nvvPWrey+Fw0G63KbW30WhQo17gE2Nm4oeXTqfpclCdTodCoQCDwUBd149qW6RfUCgUEI1Gsby8jPfffx+3bt2iHn5kLppMJgE8OqC3t7chk8nwyiuvUAIQWfdSrVZ7FgRJ672znQ48cu15GjEpl8shEAjgxo0b2NvbQyqVQjabhclkwpkzZygZhmxnIEkDi8WiMxoyMz0oGj4xhyCfR6FQwGQy0XHA1tYWarUaDXDErzcYDNIsm7BIn3U9crkcAwMDGB4exsTEBIBPWLC9qCo4HA4N9KQN6vf7sb29DRaLBa1WSyuGdrtNK42jJM0hEAqFGBkZwYULF3Dp0iUoFArcunULf/jDH6hXK0kkg8EgYrEYOBwOvv71r4PP59O2tUwmw+joKJ3n91MQ5PF4sNlsOHXqFIRCIX2e6vU60uk09vb26PvWi9nzoT41ZPtxp0s98e0rFArPZdIVi0WaFZCXsVKpUBp6IBCgfXSRSAS1Wo1CodB3biV8Pp/OpfR6PcRi8ROZNZm1ZbNZurW7F20BMmMhXpEPHjyA2+1GOp3ed59arda+RKNaraJSqdDdZuTA7YeFwMT0u/Mg79TFdYK0ZSKRCHZ3dxGLxajrD4/HQzweh06ng1gsxvT0NEwmE33+CANVp9NBqVSiUqkciBuJVCqF1WqljktqtRparRbz8/N0bmuxWLCxsYHl5WWaqLzIYUIqKbJvj1hxkfeWVMLdlLzw+XyYTCaMjIxgZmYGcrkc2WyWir/JnLLTg5g4jfSiivi8IHwHi8WCV155BePj49BqtdTv1ev10nVe5F0jXAq/34/79++Dx+NRH1xCmulF5f48kATLZDLBZrPtk4VVKhXqa9vJiO82DjUIVioVGuyIbpC0op51EBF0HlydATSRSKBSqWBnZ4casfJ4PDoP6KcHAAB1zbHZbDCZTJDJZE9cY71eRyQSgcfjgd/v7/rBQ0Cq8Z2dHfzpT3/C5uYmotHop1bWnWSnXonHnwZySD5elT0rUSJfl81mqaFyPB6nVXAkEoFSqQSHw0Gr1QKHw4FOp6PEIL1eD51OB61Wi3Q6fSBBUKFQYH5+HqdOnaL+uUKhEDMzMxCJRBgbG6PrxZaXlz/T302IQ6dPn8b8/DyGhoYo45dUlt20rwIeVUZDQ0OYnp7GwsICtbQjXR7il0mCIOlMxONxuqrtKIDH49Eq8MqVK1RvTHyXI5HIE8knQTQaxc2bN6nwnBiL9CM0Gg2sVitdYdZZrZfLZXg8Hrjdbupt+9LMBAl8Ph+q1SrGx8ephZFGo4HZbIbdbkc0GkUkEnnm9z9+mLZaLbrWJxaL0fUjYrEYp0+fpvKEfmJIKRQKTE1N4fjx4zh+/DiMRuO+B4EsNl1aWsL9+/cRCAT2ZX+HjUAgQHc9vv/++4jFYrh16xZ2dnaQz+dfqJ3ZWfX101A+nU5jdXUVzWaTvowGgwEcDuepgZBU6n/7t39LySSZTIZunyAsWQAwGo30v0lCR/bYTUxMwO12H8h8SiaTYWxsDK+88gp4PB42Nzfx8OFDyOVyDA0NwWq1YnJyEnq9HnNzc7RtduvWLSwtLT3xHJHuiUwmw/z8PObm5vDtb38bZrMZIpEIrVYL//M//4PFxUV4vV6k0+mujhf0ej3+7M/+jArj4/E4NjY2MD09DZlMhjNnzuDYsWPgcDjY29uD3+/HzZs3cffuXSQSia5d5xcB0XRaLBYcP34cU1NTAB614z/88EP89re/fea2D+DRuMLv9yMej6NQKFCmbD/i5MmTOHv2LObn56nTVy6XQzQaxfr6Oj7++GNsbW311GTjUINgsVhEKpVCuVymlaBAIIBYLIZEIvlcImXSwiEsRJK9K5VKiESivmiHkmpXIBBAo9HQdoBer39CSB4IBLC+vk5X1RQKha7qfYifIjEo2Nvbg8/no/KVowzCOCbmyolEAjqd7plaQcJkVqvVqFQqNOEiln1KpfKZGTeh6pNn/KD0iGQmSDaPFItFuFwuaixvtVrB5/PhcDgwMDCAdrsNp9OJYrGIcDhMpQOkQicenDqdDtPT0zhz5gzdHk9MElZXV+Hz+ZDJZLo+oxGLxbBarZShTFrUZPHqwsICJiYm0Gq1kEgk4HK54Ha7EQqFem7w/aIgW+TVajXkcjm4XC4VxHu9Xrjd7ue6YBFW5eNmIoTQ1A/dMCL7ICuhiA8q8CguRCIR+P1+hMPhnpuYH2oQ1Gg0sNlstIVEVruk02kkk8nP/OF5PB7MZjOtJBUKBWq1GjKZDJxOJ2KxWM8tu4jEgLhc2O12TExM0Fbo44jFYvD7/ZS23u0qljjg1Go1mqX1q+/gZwWZjRUKBSQSCQSDQYyPj3/q97HZbOpuRKjcnxbYyuUyZbkRdu9BoFar0WqMsHhZLBZu3ryJjY0NGI1GDA4OYmJiAgsLC2i32xgdHcXrr78Om81G728ymaSaVqKZJCuzBAIBPYRTqRQWFxefW4kcJggzmVgqksDXbrcpi5XFYiGTySAUCsHlciEQCBypVmi73abksnw+v29nYaVS+dTZGJfLhVQqpUkbcZGx2WwIBoMHzlj/PCCaQLIogXRfyPsYj8cRi8W6bpH2NBx6ECRZHQmChN2ZSCQ+s+cnCYInT56E3W6HVCpFpVJBLBaD0+lEPB7vOTOUuKYQs2Kz2UxJMU8LgvF4HD6fj7Y2ut0TJ+t3UqkUgCdb0EcZxI+xWCzSIPgiSRKZWT/eqXhel6Ezi9/e3j6wZKxarVIBMdluwWKxcOPGDVSrVWi1WhiNRnzve9/D1atX0W63oVKpMDQ0hFdeeQXFYpHqzAqFAqRSKYaHh6mjDFmTVa1W6bbzu3fv0u5Nt0ESENJiNhqN1Cmms/vTGQR3d3f74jB9UbTbbfq7JixOMlIgvqfPAwmCZC0WeU6tVit8Pl9f2BaKRCLodDpK3CEJZK1WQz6fp0Gw11UgcMhBkAx/O/VnAwMDOH/+PPh8Pnw+H9bX1+luNqIlfDyQESGyxWLBiRMncPz4cahUKpRKJezt7WFzcxNerxepVKovKkFio0VaOGRlzdPW85A5Wq9naS9T8OsEOXCCwSDW1taohm5gYOCpJKVOfJbWeqVSQSQSQS6X28eGPgiQv4vFYsFut+PKlSvg8/nU31UoFEKj0dDrJUGcVLLNZhNCoRDVahVCoRBarRYKhQLtdpvO16PRKHw+H1wuV09lLY+DBD5SHQKPEoO1tTU4nU7s7u5Sz9ajBNKl6DQs4HK5kMvlUKvVKJVK9M/IvSCV1cDAAJ2ZisVi2mYMhULUZKPXUKlUGB8fx+joKMxmMxQKBVgsFkKhEF0wsLGx0Rdz3EMNgoVCAclkEtFoFOFwmIpaHQ4H3njjDayuruLatWvIZDJU31IsFhEKhfYJka1WK13y6nA4MDQ0hFqthu3tbfzf//0fbt26hY2NjcP8KC8MNpsNqVSKgYEBnDx5korKHwdZ5krYh0ftJT5KyOfzWF1dpXRswra02+3Uf5ZsjiDEEQDUVoy4lHQGRXI4ESmBy+XCnTt3EAgEDjSAVCoVhMNhuN1uSKVSDA4O4vvf/z5effXVfe/N0NDQEyxYQpsnJBoyjigWi4jFYpT9euvWLXg8HmxsbMDr9fY0kSyVSggEAlCpVDCbzVRKAHyyyzEajeLnP/85XC4XdnZ2jlQrlKBSqVDmK/EFlUqlOHHiBL7zne/QzhCZ6ZJ2p9lshsPhwOXLl6HX6yGRSJDL5RCJRPDee+/h4cOHPTUMEIlEEIvFmJubwze+8Q1cuHCB2gpWq1V88MEHuHv3Lm7fvn3gphKfF4caBEOhECqVCvR6PQYGBlCv16FUKsHj8ShrUqVSUbEveSjW19chlUppq0an01EmnEwmg0AgoAQOl8vVN7/Mz4JUKoXt7W3s7OxQI+5+yb4/L8jAvh/ISZ0gh3+tVsPq6ipKpRJyuRzsdjvGx8fpfIUEDWLxF41GEY1GMTg4SPWd5LMRrWQymaTLXF0uF20rHxTy+Ty2trZw+/ZtNBoNuoxUo9HQmXij0Xhqq/1xECs7suUkFAohEong1q1bdNN6r8cJuVwOa2trGBgYoMunCUhCQAJ2IpE4sskjYUMSfTDpIM3OzoLH49ENNMRQhM1mQ6/XQ6/XQ6VSYWBgAEKhkHqHejwerK+v97w1rFKpYDQa6XMqkUjorLNUKuHBgwfY2trqK7PzQw2CqVQKhUIBTqcTer0ebDYbDoeD6qrIsk9gf2akVCohl8uhUCjA5XIhk8moCLlWq6FUKtHt0V6v97kyi35FLpeD1+tFKBRCJpM5si/zUQARVFerVerpWiqVEA6Hkcvl6MYSkUgEkUhEDbDJYlkyv+4MgvV6HY1GA8FgEIFAAA8fPqRJ30GiUqkgFAphZWUF7XYbxWIRzWYTQ0NDEAqFEAgENFA8nkiRAEnkK7lcDg8fPoTP54PP56N6tI2Njb6ppvL5PJxOJ6anp5HL5WiVTlZ3OZ1ObGxsIBAI9ExPexAgpgZEA0kqdrPZDJVKRc1CqtUqrQQVCgXdQ8pisVCpVOgGifv371Pj/V6BxWLRboXRaITBYIBAIKAr6DKZDDweD13W3C841CBIxNd7e3u4f/8+Go0GhoeHodPpKFmGtDrIsJfL5WJ2dpYGSsIW4/P5dKFtPB7HtWvXqKdev64QeR7ItoF8Pn+kX+ZOPE2Y3o8oFAoIBALIZDKIRqN03yWR35CNJ6TdqFAooFarn2iHEt0q0T0dxiYDUnF6PB7k83kEAgFsbm7i0qVL1FaMECEIaYSAON6Qlm08Hsfi4iJNNklrtJ+kBdVqFbu7u/D5fPB4PJS8c//+fezs7MDpdMLlcvVMWH3QyGazcLvd+/x4CdGFsHZbrRZlKJM/y2azCAaD8Hq9uHPnDm7evNlzkgm5RrLlotPzlrBhS6VS3927rgTBUChEmY+E7tx5Q0kLjaxy0Wg0+w5T4v9IvB13dnZw/fp17O3tIZ/PH6kAQg7PUqmEdDrds11tX2aQwx8Atre3e3w1nw5iZbe7uwuXy0WXkg4PD1PfSODJIOh2u7G7u0uNwQOBAG7dutWrj/FCqNVq9HB3Op3QarXQarW4ffs21tfXsbW1Bb/ffyQT36eByLvMZvO+9XFkLk0SL6LzbLfbqNfrSCaTcLvdWFlZweLiIm7fvt0X5yCfz4dMJoNYLKZBkIwj4vH4PsJPv6ArjrO5XI6y0O7fvw+NRgO9Xg+z2Yz5+XmoVCpqaqxUKnH+/Hk6j0kkElheXsb6+jq2t7eRTCaRSCRoW6jfq47Hce/ePdy/fx9LS0tYWlrqC3YUg6ODXC6HfD6Pf//3f6faq2cxXDtF8iT5OgqIRqP4xS9+gbfffpvqBUmVTT7Ty4JAIIAf/ehHePfdd2G1WmGxWHDlyhUMDQ1RiUGz2cT169fh9Xrh9Xqpd2ixWKSVVT/8TlgsFuRyOd0kw+Px6DLnDz/8EP/7v/8Ln8/X84r1cXTNdp0spE0mk9SNI5vNolwu0/KZx+NBKpUiGAwinU4jnU4jl8vB7XbD7/cjGAyiUCj0VT+5E2q1Gnq9HqOjo5iamnqquwjRrCWTSWSz2Z4TEQ4SZI5xVA7bowhSDfTrO3AQaLfbL6SXexnQarWQzWaxt7eHYrFIN0Zsbm5CoVBALBaj1WphdXWVznCJ3STx6u0XdEpuMpkMDYDBYBB7e3vY3d3ty65X13ePNBoN6oxCZilcLpeKY7lcLj744AOqoSE7pwhdvZ+DhtFoxOjoKKXgP00XSJiwJGD000P8RUAst7ptuMyAwVEHcQUiAWRvbw9CoZDKxIipO0kMKpVK383VgE/2rPr9foyMjNAznhDM+sHR62noehAkPe16vU4ZQy8LiKjfZDLBarXuWxtCgjmhpqdSqZcq02232/B6vdSEmcViYW9vD9ls9si1rBkw6CaIhIB0yI7yiIRUtdvb2xgcHESxWKSdvG4sPP88YD3volgsVv9dcR/j3LlzmJubw6uvvoorV65AqVTSeU08HsfNmzfxH//xH1haWqKEnn58KBgwYMDgZUK73X6mePnorWLuY5C9bgqFAnw+H6+++iokEgmAT7wBiXar1zZpDBgwYMCACYIHimAwiGw2C6FQiFarhXPnzu0Lgo1Gg4qs+62fz4ABAwZfRjBB8ADRbDZRLpfh9/sBAD/72c+ohiuXy8Hlcr3QpnYGDBgwYNAdMDPBAwYR/QuFQqjV6n2CUSKQ7yeXfgYMGDB42fG8mSATBBkwYMCAwUuN5wXBZy9TY8CAAQMGDF5yPLcSZMCAAQMGDF5mMJUgAwYMGDD40oIJggwYMGDA4EsLJggyYMCAAYMvLZggyIABAwYMvrRggiADBgwYMPjSggmCDBgwYMDgS4v/B1pBDph6wVVNAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 576x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#TO DO: your code here to adapt the code from the tutorial to experiment on MNIST dataset\n",
+    "from __future__ import print_function\n",
+    "#%matplotlib inline\n",
+    "import argparse\n",
+    "import os\n",
+    "import random\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.parallel\n",
+    "import torch.backends.cudnn as cudnn\n",
+    "import torch.optim as optim\n",
+    "import torch.utils.data\n",
+    "import torchvision.datasets as dset\n",
+    "import torchvision.transforms as transforms\n",
+    "import torchvision.utils as vutils\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.animation as animation\n",
+    "from IPython.display import HTML\n",
+    "\n",
+    "# Set random seed for reproducibility\n",
+    "manualSeed = 999\n",
+    "#manualSeed = random.randint(1, 10000) # use if you want new results\n",
+    "print(\"Random Seed: \", manualSeed)\n",
+    "random.seed(manualSeed)\n",
+    "torch.manual_seed(manualSeed)\n",
+    "\n",
+    "# Root directory for dataset\n",
+    "dataroot = \"data/celeba\"\n",
+    "\n",
+    "# Number of workers for dataloader\n",
+    "workers = 2\n",
+    "\n",
+    "# Batch size during training\n",
+    "batch_size = 128\n",
+    "\n",
+    "# Spatial size of training images. All images will be resized to this\n",
+    "#   size using a transformer.\n",
+    "image_size = 64\n",
+    "\n",
+    "# Number of channels in the training images. For color images this is 3\n",
+    "nc = 1\n",
+    "\n",
+    "# Size of z latent vector (i.e. size of generator input)\n",
+    "nz = 100\n",
+    "\n",
+    "# Size of feature maps in generator\n",
+    "ngf = 64\n",
+    "\n",
+    "# Size of feature maps in discriminator\n",
+    "ndf = 64\n",
+    "\n",
+    "# Number of training epochs\n",
+    "num_epochs = 5\n",
+    "\n",
+    "# Learning rate for optimizers\n",
+    "lr = 0.0002\n",
+    "\n",
+    "# Beta1 hyperparam for Adam optimizers\n",
+    "beta1 = 0.5\n",
+    "\n",
+    "# Number of GPUs available. Use 0 for CPU mode.\n",
+    "ngpu = 1\n",
+    "\n",
+    "# We can use an image folder dataset the way we have it setup.\n",
+    "# Create the dataset\n",
+    "transform = transforms.Compose([\n",
+    "    transforms.Resize(image_size),\n",
+    "    transforms.ToTensor(),\n",
+    "    transforms.Normalize((0.5,), (0.5,))\n",
+    "])\n",
+    "\n",
+    "dataset = dset.MNIST(root=dataroot, train=True, download=True, transform=transform)\n",
+    "\n",
+    "# Create the dataloader\n",
+    "dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,\n",
+    "                                         shuffle=True, num_workers=workers)\n",
+    "\n",
+    "# Decide which device we want to run on\n",
+    "device = torch.device(\"cuda:0\" if (torch.cuda.is_available() and ngpu > 0) else \"cpu\")\n",
+    "\n",
+    "# Plot some training images\n",
+    "real_batch = next(iter(dataloader))\n",
+    "plt.figure(figsize=(8,8))\n",
+    "plt.axis(\"off\")\n",
+    "plt.title(\"Training Images\")\n",
+    "plt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:64], padding=2, normalize=True).cpu(),(1,2,0)))\n",
+    "\n",
+    "# custom weights initialization called on netG and netD\n",
+    "def weights_init(m):\n",
+    "    classname = m.__class__.__name__\n",
+    "    if classname.find('Conv') != -1:\n",
+    "        nn.init.normal_(m.weight.data, 0.0, 0.02)\n",
+    "    elif classname.find('BatchNorm') != -1:\n",
+    "        nn.init.normal_(m.weight.data, 1.0, 0.02)\n",
+    "        nn.init.constant_(m.bias.data, 0)\n",
+    "        \n",
+    "# Generator Code\n",
+    "\n",
+    "class Generator(nn.Module):\n",
+    "    def __init__(self, ngpu):\n",
+    "        super(Generator, self).__init__()\n",
+    "        self.ngpu = ngpu\n",
+    "        self.main = nn.Sequential(\n",
+    "            # input is Z, going into a convolution\n",
+    "            nn.ConvTranspose2d( nz, ngf * 8, 4, 1, 0, bias=False),\n",
+    "            nn.BatchNorm2d(ngf * 8),\n",
+    "            nn.ReLU(True),\n",
+    "            # state size. (ngf*8) x 4 x 4\n",
+    "            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),\n",
+    "            nn.BatchNorm2d(ngf * 4),\n",
+    "            nn.ReLU(True),\n",
+    "            # state size. (ngf*4) x 8 x 8\n",
+    "            nn.ConvTranspose2d( ngf * 4, ngf * 2, 4, 2, 1, bias=False),\n",
+    "            nn.BatchNorm2d(ngf * 2),\n",
+    "            nn.ReLU(True),\n",
+    "            # state size. (ngf*2) x 16 x 16\n",
+    "            nn.ConvTranspose2d( ngf * 2, ngf, 4, 2, 1, bias=False),\n",
+    "            nn.BatchNorm2d(ngf),\n",
+    "            nn.ReLU(True),\n",
+    "            # state size. (ngf) x 32 x 32\n",
+    "            nn.ConvTranspose2d( ngf, nc, 4, 2, 1, bias=False),\n",
+    "            nn.Tanh()\n",
+    "            # state size. (nc) x 64 x 64\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, input):\n",
+    "        return self.main(input)\n",
+    "\n",
+    "# Create the generator\n",
+    "netG = Generator(ngpu).to(device)\n",
+    "\n",
+    "# Handle multi-gpu if desired\n",
+    "if (device.type == 'cuda') and (ngpu > 1):\n",
+    "    netG = nn.DataParallel(netG, list(range(ngpu)))\n",
+    "\n",
+    "# Apply the weights_init function to randomly initialize all weights\n",
+    "#  to mean=0, stdev=0.02.\n",
+    "netG.apply(weights_init)\n",
+    "\n",
+    "# Print the model\n",
+    "print(netG)\n",
+    "\n",
+    "class Discriminator(nn.Module):\n",
+    "    def __init__(self, ngpu):\n",
+    "        super(Discriminator, self).__init__()\n",
+    "        self.ngpu = ngpu\n",
+    "        self.main = nn.Sequential(\n",
+    "            # input is (nc) x 64 x 64\n",
+    "            nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),\n",
+    "            nn.LeakyReLU(0.2, inplace=True),\n",
+    "            # state size. (ndf) x 32 x 32\n",
+    "            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),\n",
+    "            nn.BatchNorm2d(ndf * 2),\n",
+    "            nn.LeakyReLU(0.2, inplace=True),\n",
+    "            # state size. (ndf*2) x 16 x 16\n",
+    "            nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),\n",
+    "            nn.BatchNorm2d(ndf * 4),\n",
+    "            nn.LeakyReLU(0.2, inplace=True),\n",
+    "            # state size. (ndf*4) x 8 x 8\n",
+    "            nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),\n",
+    "            nn.BatchNorm2d(ndf * 8),\n",
+    "            nn.LeakyReLU(0.2, inplace=True),\n",
+    "            # state size. (ndf*8) x 4 x 4\n",
+    "            nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),\n",
+    "            nn.Sigmoid()\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, input):\n",
+    "        return self.main(input)\n",
+    "\n",
+    "# Create the Discriminator\n",
+    "netD = Discriminator(ngpu).to(device)\n",
+    "\n",
+    "# Handle multi-gpu if desired\n",
+    "if (device.type == 'cuda') and (ngpu > 1):\n",
+    "    netD = nn.DataParallel(netD, list(range(ngpu)))\n",
+    "\n",
+    "# Apply the weights_init function to randomly initialize all weights\n",
+    "#  to mean=0, stdev=0.2.\n",
+    "netD.apply(weights_init)\n",
+    "\n",
+    "# Print the model\n",
+    "print(netD)\n",
+    "\n",
+    "# Initialize BCELoss function\n",
+    "criterion = nn.BCELoss()\n",
+    "\n",
+    "# Create batch of latent vectors that we will use to visualize\n",
+    "#  the progression of the generator\n",
+    "fixed_noise = torch.randn(64, nz, 1, 1, device=device)\n",
+    "\n",
+    "# Establish convention for real and fake labels during training\n",
+    "real_label = 1.\n",
+    "fake_label = 0.\n",
+    "\n",
+    "# Setup Adam optimizers for both G and D\n",
+    "optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999))\n",
+    "optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting Training Loop...\n",
+      "[0/5][0/469]\tLoss_D: 1.6178\tLoss_G: 2.7770\tD(x): 0.3999\tD(G(z)): 0.3887 / 0.0869\n",
+      "[0/5][50/469]\tLoss_D: 0.0672\tLoss_G: 7.8487\tD(x): 0.9826\tD(G(z)): 0.0460 / 0.0005\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-8-600722b81a92>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     61\u001b[0m         \u001b[0mD_G_z2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0moutput\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     62\u001b[0m         \u001b[0;31m# Update G\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 63\u001b[0;31m         \u001b[0moptimizerG\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     64\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     65\u001b[0m         \u001b[0;31m# Output training stats\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/torch/optim/optimizer.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    138\u001b[0m                 \u001b[0mprofile_name\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"Optimizer.step#{}.step\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    139\u001b[0m                 \u001b[0;32mwith\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprofiler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrecord_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprofile_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 140\u001b[0;31m                     \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    141\u001b[0m                     \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_optimizer_step_code\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    142\u001b[0m                     \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/torch/optim/optimizer.py\u001b[0m in \u001b[0;36m_use_grad\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m     21\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m             \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_grad_enabled\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdefaults\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'differentiable'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m             \u001b[0mret\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     24\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m             \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_grad_enabled\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprev_grad\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/torch/optim/adam.py\u001b[0m in \u001b[0;36mstep\u001b[0;34m(self, closure, grad_scaler)\u001b[0m\n\u001b[1;32m    250\u001b[0m                  \u001b[0mfused\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgroup\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'fused'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    251\u001b[0m                  \u001b[0mgrad_scale\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgrad_scale\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 252\u001b[0;31m                  found_inf=found_inf)\n\u001b[0m\u001b[1;32m    253\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    254\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/torch/optim/adam.py\u001b[0m in \u001b[0;36madam\u001b[0;34m(params, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, foreach, capturable, differentiable, fused, grad_scale, found_inf, amsgrad, beta1, beta2, lr, weight_decay, eps, maximize)\u001b[0m\n\u001b[1;32m    314\u001b[0m          \u001b[0mdifferentiable\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdifferentiable\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    315\u001b[0m          \u001b[0mgrad_scale\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgrad_scale\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 316\u001b[0;31m          found_inf=found_inf)\n\u001b[0m\u001b[1;32m    317\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    318\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/opt/anaconda3/lib/python3.7/site-packages/torch/optim/adam.py\u001b[0m in \u001b[0;36m_single_tensor_adam\u001b[0;34m(params, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, grad_scale, found_inf, amsgrad, beta1, beta2, lr, weight_decay, eps, maximize, capturable, differentiable)\u001b[0m\n\u001b[1;32m    410\u001b[0m                 \u001b[0mdenom\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mexp_avg_sq\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mbias_correction2_sqrt\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0meps\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    411\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 412\u001b[0;31m             \u001b[0mparam\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maddcdiv_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexp_avg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdenom\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mstep_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    413\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    414\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+     ]
+    }
+   ],
+   "source": [
+    "# Training Loop\n",
+    "\n",
+    "# Lists to keep track of progress\n",
+    "img_list = []\n",
+    "G_losses = []\n",
+    "D_losses = []\n",
+    "iters = 0\n",
+    "\n",
+    "print(\"Starting Training Loop...\")\n",
+    "# For each epoch\n",
+    "for epoch in range(num_epochs):\n",
+    "    # For each batch in the dataloader\n",
+    "    for i, data in enumerate(dataloader, 0):\n",
+    "\n",
+    "        ############################\n",
+    "        # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))\n",
+    "        ###########################\n",
+    "        ## Train with all-real batch\n",
+    "        netD.zero_grad()\n",
+    "        # Format batch\n",
+    "        real_cpu = data[0].to(device)\n",
+    "        b_size = real_cpu.size(0)\n",
+    "        label = torch.full((b_size,), real_label, dtype=torch.float, device=device)\n",
+    "        # Forward pass real batch through D\n",
+    "        output = netD(real_cpu).view(-1)\n",
+    "        # Calculate loss on all-real batch\n",
+    "        errD_real = criterion(output, label)\n",
+    "        # Calculate gradients for D in backward pass\n",
+    "        errD_real.backward()\n",
+    "        D_x = output.mean().item()\n",
+    "\n",
+    "        ## Train with all-fake batch\n",
+    "        # Generate batch of latent vectors\n",
+    "        noise = torch.randn(b_size, nz, 1, 1, device=device)\n",
+    "        # Generate fake image batch with G\n",
+    "        fake = netG(noise)\n",
+    "        label.fill_(fake_label)\n",
+    "        # Classify all fake batch with D\n",
+    "        output = netD(fake.detach()).view(-1)\n",
+    "        # Calculate D's loss on the all-fake batch\n",
+    "        errD_fake = criterion(output, label)\n",
+    "        # Calculate the gradients for this batch, accumulated (summed) with previous gradients\n",
+    "        errD_fake.backward()\n",
+    "        D_G_z1 = output.mean().item()\n",
+    "        # Compute error of D as sum over the fake and the real batches\n",
+    "        errD = errD_real + errD_fake\n",
+    "        # Update D\n",
+    "        optimizerD.step()\n",
+    "\n",
+    "        ############################\n",
+    "        # (2) Update G network: maximize log(D(G(z)))\n",
+    "        ###########################\n",
+    "        netG.zero_grad()\n",
+    "        label.fill_(real_label)  # fake labels are real for generator cost\n",
+    "        # Since we just updated D, perform another forward pass of all-fake batch through D\n",
+    "        output = netD(fake).view(-1)\n",
+    "        # Calculate G's loss based on this output\n",
+    "        errG = criterion(output, label)\n",
+    "        # Calculate gradients for G\n",
+    "        errG.backward()\n",
+    "        D_G_z2 = output.mean().item()\n",
+    "        # Update G\n",
+    "        optimizerG.step()\n",
+    "\n",
+    "        # Output training stats\n",
+    "        if i % 50 == 0:\n",
+    "            print('[%d/%d][%d/%d]\\tLoss_D: %.4f\\tLoss_G: %.4f\\tD(x): %.4f\\tD(G(z)): %.4f / %.4f'\n",
+    "                  % (epoch, num_epochs, i, len(dataloader),\n",
+    "                     errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))\n",
+    "\n",
+    "        # Save Losses for plotting later\n",
+    "        G_losses.append(errG.item())\n",
+    "        D_losses.append(errD.item())\n",
+    "\n",
+    "        # Check how the generator is doing by saving G's output on fixed_noise\n",
+    "        if (iters % 500 == 0) or ((epoch == num_epochs-1) and (i == len(dataloader)-1)):\n",
+    "            with torch.no_grad():\n",
+    "                fake = netG(fixed_noise).detach().cpu()\n",
+    "            img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n",
+    "\n",
+    "        iters += 1\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure(figsize=(10,5))\n",
+    "plt.title(\"Generator and Discriminator Loss During Training\")\n",
+    "plt.plot(G_losses,label=\"G\")\n",
+    "plt.plot(D_losses,label=\"D\")\n",
+    "plt.xlabel(\"iterations\")\n",
+    "plt.ylabel(\"Loss\")\n",
+    "plt.legend()\n",
+    "plt.show()\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig = plt.figure(figsize=(8,8))\n",
+    "plt.axis(\"off\")\n",
+    "ims = [[plt.imshow(np.transpose(i,(1,2,0)), animated=True)] for i in img_list]\n",
+    "ani = animation.ArtistAnimation(fig, ims, interval=1000, repeat_delay=1000, blit=True)\n",
+    "\n",
+    "HTML(ani.to_jshtml())\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Grab a batch of real images from the dataloader\n",
+    "real_batch = next(iter(dataloader))\n",
+    "\n",
+    "# Plot the real images\n",
+    "plt.figure(figsize=(15,15))\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.axis(\"off\")\n",
+    "plt.title(\"Real Images\")\n",
+    "plt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:64], padding=5, normalize=True).cpu(),(1,2,0)))\n",
+    "\n",
+    "# Plot the fake images from the last epoch\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.axis(\"off\")\n",
+    "plt.title(\"Fake Images\")\n",
+    "plt.imshow(np.transpose(img_list[-1],(1,2,0)))\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "5fbSgsrE1GqC"
+   },
+   "source": [
+    "# Part2: Conditional GAN (cGAN)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "7SjXNoT7BUey"
+   },
+   "source": [
+    "Let's take the example of the set described in the next picture.\n",
+    "![Map to satellite picture](https://raw.githubusercontent.com/Neyri/Projet-cGAN/master/BE/img/map_streetview.png)\n",
+    "\n",
+    "We have a picture of a map (from Google Maps) and we want to create an image of what the satellite view may look like.\n",
+    "\n",
+    "As we are not only trying to generate a random picture but a mapping between a picture to another one, we can't use the standard GAN architecture. We will then use a cGAN.\n",
+    "\n",
+    "A cGAN is a supervised GAN aiming at mapping a label picture to a real one or a real picture to a label one. As you can see in the diagram below, the discriminator will take as input a pair of images and try to predict if the pair was generated or not. The generator will not only generate an image from noise but will also use an image (label or real) to generate another one (real or label).\n",
+    "![Diagram of how a cGan works](https://raw.githubusercontent.com/Neyri/Projet-cGAN/master/BE/img/cgan_map.png)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "0JRaeHfzl6cO"
+   },
+   "source": [
+    "### Generator\n",
+    "\n",
+    "In the cGAN architecture, the generator chosen is a U-Net.\n",
+    "![U-Net](https://raw.githubusercontent.com/Neyri/Projet-cGAN/master/BE/img/unet.png)\n",
+    "\n",
+    "A U-Net takes as input an image, and outputs another image. \n",
+    "\n",
+    "It can be divided into 2 subparts : an encoder and a decoder. \n",
+    "* The encoder takes the input image and reduces its dimension to encode the main features into a vector. \n",
+    "* The decoder takes this vector and map the features stored into an image.\n",
+    "\n",
+    "A U-Net architecture is different from a classic encoder-decoder in that every layer of the decoder takes as input the previous decoded output as well as the output vector from the encoder layers of the same level. It allows the decoder to map low frequencies information encoded during the descent as well as high frequencies from the original picture. \n",
+    "\n",
+    "![U-Net](https://www.researchgate.net/profile/Baris_Turkbey/publication/315514772/figure/fig2/AS:485824962797569@1492841105670/U-net-architecture-Each-box-corresponds-to-a-multi-channel-features-maps-The-number-of.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "xFqMOsoYwzFe"
+   },
+   "source": [
+    "The architecture we will implement is the following (the number in the square is the number of filters used).\n",
+    "![UNet Architecture](https://raw.githubusercontent.com/Neyri/Projet-cGAN/master/BE/img/unet_architecture.png)\n",
+    "\n",
+    "The encoder will take as input a colored picture (3 channels: RGB), it will pass through a series of convolution layers to encode the features of the picture. It will then be decoded by the decoder using transposed convolutional layers. These layers will take as input the previous decoded vector AND the encoded features of the same level. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "yzy7y4hmbbX3"
+   },
+   "source": [
+    "Now, let's create or cGAN to generate facades from a template image. For this purpose, we will use the \"Facade\" dataset available at http://cmp.felk.cvut.cz/~tylecr1/facade/.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "Q_jf9H_NDESm"
+   },
+   "source": [
+    "Let's first create a few classes describing the layers we will use in the U-Net."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "uOKvYDyu0w8N"
+   },
+   "outputs": [],
+   "source": [
+    "# Importing all the libraries needed\n",
+    "import matplotlib.pyplot as plt\n",
+    "import imageio\n",
+    "import glob\n",
+    "import random\n",
+    "import os\n",
+    "import numpy as np\n",
+    "import math\n",
+    "import itertools\n",
+    "import time\n",
+    "import datetime\n",
+    "import cv2\n",
+    "from pathlib import Path\n",
+    "from PIL import Image\n",
+    "\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "import torchvision.transforms as transforms\n",
+    "from torchvision.utils import save_image, make_grid\n",
+    "from torchvision import datasets\n",
+    "from torch.autograd import Variable\n",
+    "\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "import torch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "Zk5a6B5hILN2"
+   },
+   "outputs": [],
+   "source": [
+    "# code adapted from https://github.com/milesial/Pytorch-UNet/blob/master/unet/unet_parts.py\n",
+    "\n",
+    "# Input layer\n",
+    "class inconv(nn.Module):\n",
+    "    def __init__(self, in_ch, out_ch):\n",
+    "        super(inconv, self).__init__()\n",
+    "        self.conv = nn.Sequential(\n",
+    "            nn.Conv2d(in_ch, out_ch, kernel_size=4, padding=1, stride=2),\n",
+    "            nn.LeakyReLU(negative_slope=0.2, inplace=True)\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.conv(x)\n",
+    "        return x\n",
+    "\n",
+    "# Encoder layer\n",
+    "class down(nn.Module):\n",
+    "    def __init__(self, in_ch, out_ch):\n",
+    "        super(down, self).__init__()\n",
+    "        self.conv = nn.Sequential(\n",
+    "            nn.Conv2d(in_ch, out_ch, kernel_size=4, padding=1, stride=2),\n",
+    "            nn.BatchNorm2d(out_ch),\n",
+    "            nn.LeakyReLU(negative_slope=0.2, inplace=True)\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.conv(x)\n",
+    "        return x\n",
+    "\n",
+    "# Decoder layer\n",
+    "class up(nn.Module):\n",
+    "    def __init__(self, in_ch, out_ch, dropout=False):\n",
+    "        super(up, self).__init__()\n",
+    "        if dropout :\n",
+    "            self.conv = nn.Sequential(\n",
+    "                nn.ConvTranspose2d(in_ch, out_ch, kernel_size=4, padding=1, stride=2),\n",
+    "                nn.BatchNorm2d(out_ch),\n",
+    "                nn.Dropout(0.5, inplace=True),\n",
+    "                nn.ReLU(inplace=True)\n",
+    "            )\n",
+    "        else:\n",
+    "            self.conv = nn.Sequential(\n",
+    "                nn.ConvTranspose2d(in_ch, out_ch, kernel_size=4, padding=1, stride=2),\n",
+    "                nn.BatchNorm2d(out_ch),\n",
+    "                nn.ReLU(inplace=True)\n",
+    "            )\n",
+    "\n",
+    "    def forward(self, x1, x2):\n",
+    "        x1 = self.conv(x1)\n",
+    "        x = torch.cat([x1, x2], dim=1)\n",
+    "        return x\n",
+    "\n",
+    "# Output layer\n",
+    "class outconv(nn.Module):\n",
+    "    def __init__(self, in_ch, out_ch):\n",
+    "        super(outconv, self).__init__()\n",
+    "        self.conv = nn.Sequential(\n",
+    "              nn.ConvTranspose2d(in_ch, out_ch, kernel_size=4, padding=1, stride=2),\n",
+    "              nn.Tanh()\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.conv(x)\n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "1rZ5Qz1mBUe8"
+   },
+   "source": [
+    "Now let's create the U-Net using the helper classes defined previously."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "4Tbp_535EVPW"
+   },
+   "outputs": [],
+   "source": [
+    " class U_Net(nn.Module):\n",
+    "    ''' \n",
+    "    Ck denotes a Convolution-BatchNorm-ReLU layer with k filters.\n",
+    "    CDk denotes a Convolution-BatchNorm-Dropout-ReLU layer with a dropout rate of 50%\n",
+    "    Encoder:\n",
+    "      C64   - C128   - C256   - C512  - C512  - C512 - C512 - C512\n",
+    "    Decoder:\n",
+    "      CD512 - CD1024 - CD1024 - C1024 - C1024 - C512 - C256 - C128\n",
+    "    '''\n",
+    "    def __init__(self, n_channels, n_classes):\n",
+    "        super(U_Net, self).__init__()\n",
+    "        # Encoder\n",
+    "        self.inc = inconv(n_channels, 64) # 64 filters\n",
+    "        # TO DO :\n",
+    "        # Create the 7 encoder layers called \"down1\" to \"down7\" following this sequence\n",
+    "        # C64   - C128   - C256   - C512  - C512  - C512 - C512 - C512\n",
+    "        # The first one has already been implemented\n",
+    "        \n",
+    "        \n",
+    "        # Decoder\n",
+    "        # TO DO :\n",
+    "        # Create the 7 decoder layers called up1 to up7 following this sequence :\n",
+    "        # CD512 - CD1024 - CD1024 - C1024 - C1024 - C512 - C256 - C128\n",
+    "        # The last layer has already been defined\n",
+    "        \n",
+    "        \n",
+    "        self.outc = outconv(128, n_classes) # 128 filters\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x1 = self.inc(x)\n",
+    "        x2 = self.down1(x1)\n",
+    "        x3 = self.down2(x2)\n",
+    "        x4 = self.down3(x3)\n",
+    "        x5 = self.down4(x4)\n",
+    "        x6 = self.down5(x5)\n",
+    "        x7 = self.down6(x6)\n",
+    "        x8 = self.down7(x7)\n",
+    "        # At this stage x8 is our encoded vector, we will now decode it\n",
+    "        x = self.up7(x8, x7)\n",
+    "        x = self.up6(x, x6)\n",
+    "        x = self.up5(x, x5)\n",
+    "        x = self.up4(x, x4)\n",
+    "        x = self.up3(x, x3)\n",
+    "        x = self.up2(x, x2)\n",
+    "        x = self.up1(x, x1)\n",
+    "        x = self.outc(x)\n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "1hmcejTWJSYY"
+   },
+   "outputs": [],
+   "source": [
+    "# We take images that have 3 channels (RGB) as input and output an image that also have 3 channels (RGB)\n",
+    "generator=U_Net(3,3)\n",
+    "# Check that the architecture is as expected\n",
+    "generator"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "xIXFtHzcBUfO"
+   },
+   "source": [
+    "You should now have a working U-Net."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "RqD1katYBUfP"
+   },
+   "source": [
+    "<font color='red'>**Question 1**</font>                                                                  \n",
+    "Knowing the input and output images will be 256x256, what will be the dimension of the encoded vector x8  ?\n",
+    "\n",
+    "<font color='red'>**Question 2**</font>                                                                  \n",
+    "As you can see, U-net has an encoder-decoder architecture with skip connections. Explain why it works better than a traditional encoder-decoder."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "cchTp3thBUfR"
+   },
+   "source": [
+    "### Discriminator\n",
+    "\n",
+    "In the cGAN architecture, the chosen discriminator is a Patch GAN. It is a convolutional discriminator which enables to produce a map of the input pictures where each pixel represents a patch of size NxN of the input.\n",
+    "\n",
+    "![patch GAN](https://raw.githubusercontent.com/Neyri/Projet-cGAN/master/BE/img/patchGAN.png)\n",
+    "\n",
+    "The size N is given by the depth of the net. According to this table :\n",
+    "\n",
+    "| Number of layers | N |\n",
+    "| ---- | ---- |\n",
+    "| 1 | 16 |\n",
+    "| 2 | 34 |\n",
+    "| 3 | 70 |\n",
+    "| 4 | 142 |\n",
+    "| 5 | 286 |\n",
+    "| 6 | 574 |\n",
+    "\n",
+    "The number of layers actually means the number of layers with `kernel=(4,4)`, `padding=(1,1)` and `stride=(2,2)`. These layers are followed by 2 layers with `kernel=(4,4)`, `padding=(1,1)` and `stride=(1,1)`.\n",
+    "In our case we are going to create a 70x70 PatchGAN."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "ge6I7M0aBUfT"
+   },
+   "source": [
+    "Let's first create a few helping classes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "RYqomFO8BUfV"
+   },
+   "outputs": [],
+   "source": [
+    "class conv_block(nn.Module):\n",
+    "    def __init__(self, in_ch, out_ch, use_batchnorm=True, stride=2):\n",
+    "        super(conv_block, self).__init__()\n",
+    "        if use_batchnorm:\n",
+    "            self.conv = nn.Sequential(\n",
+    "                nn.Conv2d(in_ch, out_ch, kernel_size=4, padding=1, stride=stride),\n",
+    "                nn.BatchNorm2d(out_ch),\n",
+    "                nn.LeakyReLU(negative_slope=0.2, inplace=True)\n",
+    "            )\n",
+    "        else:\n",
+    "            self.conv = nn.Sequential(\n",
+    "                nn.Conv2d(in_ch, out_ch, kernel_size=4, padding=1, stride=stride),\n",
+    "                nn.LeakyReLU(negative_slope=0.2, inplace=True)\n",
+    "            )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.conv(x)\n",
+    "        return x\n",
+    "    \n",
+    "\n",
+    "class out_block(nn.Module):\n",
+    "    def __init__(self, in_ch, out_ch):\n",
+    "        super(out_block, self).__init__()\n",
+    "        self.conv = nn.Sequential(\n",
+    "            nn.Conv2d(in_ch, 1, kernel_size=4, padding=1, stride=1),\n",
+    "            nn.Sigmoid()\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.conv(x)\n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "5m4Dnup4BUfc"
+   },
+   "source": [
+    "Now let's create the Patch GAN discriminator.\n",
+    "As we want a 70x70 Patch GAN, the architecture will be as follows :\n",
+    "```\n",
+    "1. C64  - K4, P1, S2\n",
+    "2. C128 - K4, P1, S2\n",
+    "3. C256 - K4, P1, S2\n",
+    "4. C512 - K4, P1, S1\n",
+    "5. C1   - K4, P1, S1 (output)\n",
+    "```\n",
+    "Where Ck denotes a convolution block with k filters, Kk a kernel of size k, Pk is the padding size and Sk the stride applied.\n",
+    "*Note :* For the first layer, we do not use batchnorm."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "AH6u5a-PBUfg"
+   },
+   "source": [
+    "<font color='red'>**Question 3**</font>                                                                  \n",
+    "Knowing the input and output images will be 256x256, what will be the dimension of the encoded vector x8  ?Knowing input images will be 256x256 with 3 channels each, how many parameters are there to learn ?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "g_9LxNhGBUfi"
+   },
+   "outputs": [],
+   "source": [
+    "class PatchGAN(nn.Module):\n",
+    "    def __init__(self, n_channels, n_classes):\n",
+    "        super(PatchGAN, self).__init__()\n",
+    "        # TODO :\n",
+    "        # create the 4 first layers named conv1 to conv4\n",
+    "        self.conv1 =\n",
+    "        self.conv2 =\n",
+    "        self.conv3 =\n",
+    "        self.conv4 =\n",
+    "        # output layer\n",
+    "        self.out = out_block(512, n_classes)\n",
+    "        \n",
+    "    def forward(self, x1, x2):\n",
+    "        x = torch.cat([x2, x1], dim=1)\n",
+    "        x = self.conv1(x)\n",
+    "        x = self.conv2(x)\n",
+    "        x = self.conv3(x)\n",
+    "        x = self.conv4(x)\n",
+    "        x = self.out(x)\n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "W_sevZRnBUfn"
+   },
+   "outputs": [],
+   "source": [
+    "# We have 6 input channels as we concatenate 2 images (with 3 channels each)\n",
+    "discriminator = PatchGAN(6,1)\n",
+    "discriminator"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "v_QubOycBUfv"
+   },
+   "source": [
+    "You should now have a working discriminator."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "DiI2CByRBUfz"
+   },
+   "source": [
+    "### Loss functions\n",
+    "\n",
+    "As we have seen in the choice of the various architectures for this GAN, the issue is to map both low and high frequencies.\n",
+    "To tackle this problem, this GAN rely on the architecture to map the high frequencies (U-Net + PatchGAN) and the loss function to learn low frequencies features. The global loss function will indeed be made of 2 parts :\n",
+    "* the first part to map hight frequencies, will try to optimize the mean squared error of the GAN.\n",
+    "* the second part to map low frequencies, will minimize the $\\mathcal{L}_1$ norm of the generated picture.\n",
+    "\n",
+    "So the loss can be defined as $$ G^* = arg\\ \\underset{G}{min}\\ \\underset{D}{max}\\ \\mathcal{L}_{cGAN}(G,D) + \\lambda \\mathcal{L}_1(G)$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "k4G_xewPBUf4"
+   },
+   "outputs": [],
+   "source": [
+    "# Loss functions\n",
+    "criterion_GAN = torch.nn.MSELoss()\n",
+    "criterion_pixelwise = torch.nn.L1Loss()\n",
+    "\n",
+    "# Loss weight of L1 pixel-wise loss between translated image and real image\n",
+    "lambda_pixel = 100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "c12q2NwkBUf7"
+   },
+   "source": [
+    "### Training and evaluating models "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "vGKjO0UMBUf9"
+   },
+   "outputs": [],
+   "source": [
+    "# parameters\n",
+    "epoch = 0 #  epoch to start training from\n",
+    "n_epoch = 200  #  number of epochs of training\n",
+    "batch_size =10  #  size of the batches\n",
+    "lr = 0.0002 #  adam: learning rate\n",
+    "b1 =0.5  #  adam: decay of first order momentum of gradient\n",
+    "b2 = 0.999  # adam: decay of first order momentum of gradient\n",
+    "decay_epoch = 100  # epoch from which to start lr decay\n",
+    "img_height = 256  # size of image height\n",
+    "img_width = 256  # size of image width\n",
+    "channels = 3  # number of image channels\n",
+    "sample_interval = 500 # interval between sampling of images from generators\n",
+    "checkpoint_interval = -1 # interval between model checkpoints\n",
+    "cuda = True if torch.cuda.is_available() else False # do you have cuda ?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "PhPkU7BDYooV"
+   },
+   "source": [
+    "Download the dataset. \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "8wyPjAxPYsNF"
+   },
+   "outputs": [],
+   "source": [
+    "import urllib.request\n",
+    "from tqdm import tqdm\n",
+    "import os\n",
+    "import zipfile\n",
+    "\n",
+    "def download_hook(t):\n",
+    "    \"\"\"Wraps tqdm instance.\n",
+    "    Don't forget to close() or __exit__()\n",
+    "    the tqdm instance once you're done with it (easiest using `with` syntax).\n",
+    "    Example\n",
+    "    -------\n",
+    "    >>> with tqdm(...) as t:\n",
+    "    ...     reporthook = my_hook(t)\n",
+    "    ...     urllib.request.urlretrieve(..., reporthook=reporthook)\n",
+    "    \"\"\"\n",
+    "    last_b = [0]\n",
+    "\n",
+    "    def update_to(b=1, bsize=1, tsize=None):\n",
+    "        \"\"\"\n",
+    "        b  : int, optional\n",
+    "            Number of blocks transferred so far [default: 1].\n",
+    "        bsize  : int, optional\n",
+    "            Size of each block (in tqdm units) [default: 1].\n",
+    "        tsize  : int, optional\n",
+    "            Total size (in tqdm units). If [default: None] remains unchanged.\n",
+    "        \"\"\"\n",
+    "        if tsize is not None:\n",
+    "            t.total = tsize\n",
+    "        t.update((b - last_b[0]) * bsize)\n",
+    "        last_b[0] = b\n",
+    "\n",
+    "    return update_to\n",
+    "\n",
+    "def download(url, save_dir):\n",
+    "    filename = url.split('/')[-1]\n",
+    "    with tqdm(unit = 'B', unit_scale = True, unit_divisor = 1024, miniters = 1, desc = filename) as t:\n",
+    "        urllib.request.urlretrieve(url, filename = os.path.join(save_dir, filename), reporthook = download_hook(t), data = None)\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    # Download ground truth\n",
+    "    if not os.path.exists(\"CMP_facade_DB_base.zip\"):\n",
+    "        download(\"http://cmp.felk.cvut.cz/~tylecr1/facade/CMP_facade_DB_base.zip\", \"./\")\n",
+    "    # Extract in the correct folder\n",
+    "    with zipfile.ZipFile(\"CMP_facade_DB_base.zip\", 'r') as zip_ref:\n",
+    "        zip_ref.extractall(\"./facades\")\n",
+    "        os.rename(\"./facades/base\", \"./facades/train\")\n",
+    "\n",
+    "    # Download ground truth\n",
+    "    if not os.path.exists(\"CMP_facade_DB_extended.zip\"):\n",
+    "        download(\"http://cmp.felk.cvut.cz/~tylecr1/facade/CMP_facade_DB_extended.zip\", \"./\")\n",
+    "    # Extract in the correct folder\n",
+    "    with zipfile.ZipFile(\"CMP_facade_DB_extended.zip\", 'r') as zip_ref:\n",
+    "        zip_ref.extractall(\"./facades\")\n",
+    "        os.rename(\"./facades/extended\", \"./facades/val\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "6DHT9c0_BUgA"
+   },
+   "source": [
+    "Configure the dataloader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "rxi_QIpgBUgB"
+   },
+   "outputs": [],
+   "source": [
+    "class ImageDataset(Dataset):\n",
+    "    def __init__(self, root, transforms_=None, mode='train'):\n",
+    "        self.transform = transforms.Compose(transforms_)\n",
+    "\n",
+    "        self.files_img = sorted(glob.glob(os.path.join(root, mode) + '/*.jpg'))\n",
+    "        if mode == 'val':\n",
+    "            self.files_img.extend(\n",
+    "                sorted(glob.glob(os.path.join(root, 'val') + '/*.jpg')))\n",
+    "\n",
+    "        self.files_mask = sorted(glob.glob(os.path.join(root, mode) + '/*.png'))\n",
+    "        if mode == 'val':\n",
+    "            self.files_mask.extend(\n",
+    "                sorted(glob.glob(os.path.join(root, 'val') + '/*.png')))\n",
+    "            \n",
+    "        assert len(self.files_img) == len(self.files_mask)\n",
+    "\n",
+    "    def __getitem__(self, index):\n",
+    "\n",
+    "        img = Image.open(self.files_img[index % len(self.files_img)])\n",
+    "        mask = Image.open(self.files_mask[index % len(self.files_img)])\n",
+    "        mask = mask.convert('RGB')\n",
+    "\n",
+    "        img = self.transform(img)\n",
+    "        mask = self.transform(mask)\n",
+    "\n",
+    "        return img, mask\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.files_img)\n",
+    "    \n",
+    "# Configure dataloaders\n",
+    "transforms_ = [transforms.Resize((img_height, img_width), Image.BICUBIC),\n",
+    "               transforms.ToTensor()]  # transforms.Normalize((0.5,0.5,0.5), (0.5,0.5,0.5))\n",
+    "\n",
+    "dataloader = DataLoader(ImageDataset(\"facades\", transforms_=transforms_),\n",
+    "                        batch_size=16, shuffle=True)\n",
+    "\n",
+    "val_dataloader = DataLoader(ImageDataset(\"facades\", transforms_=transforms_, mode='val'),\n",
+    "                            batch_size=8, shuffle=False)\n",
+    "\n",
+    "# Tensor type\n",
+    "Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "Okb3LU76BUgG"
+   },
+   "source": [
+    "Check the loading works and a few helper functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "xuxq4TZRBUgJ"
+   },
+   "outputs": [],
+   "source": [
+    "def plot2x2Array(image, mask):\n",
+    "    f, axarr = plt.subplots(1, 2)\n",
+    "    axarr[0].imshow(image)\n",
+    "    axarr[1].imshow(mask)\n",
+    "\n",
+    "    axarr[0].set_title('Image')\n",
+    "    axarr[1].set_title('Mask')\n",
+    "\n",
+    "\n",
+    "def reverse_transform(image):\n",
+    "    image = image.numpy().transpose((1, 2, 0))\n",
+    "    image = np.clip(image, 0, 1)\n",
+    "    image = (image * 255).astype(np.uint8)\n",
+    "\n",
+    "    return image\n",
+    "\n",
+    "def plot2x3Array(image, mask,predict):\n",
+    "    f, axarr = plt.subplots(1,3,figsize=(15,15))\n",
+    "    axarr[0].imshow(image)\n",
+    "    axarr[1].imshow(mask)\n",
+    "    axarr[2].imshow(predict)\n",
+    "    axarr[0].set_title('input')\n",
+    "    axarr[1].set_title('real')\n",
+    "    axarr[2].set_title('fake')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "m2NxLrQEBUgM"
+   },
+   "outputs": [],
+   "source": [
+    "image, mask = next(iter(dataloader))\n",
+    "image = reverse_transform(image[0])\n",
+    "mask = reverse_transform(mask[0])\n",
+    "plot2x2Array(image, mask)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "zAvaxAbxBUgQ"
+   },
+   "source": [
+    "Initialize our GAN"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "dVgF3qfDBUgR"
+   },
+   "outputs": [],
+   "source": [
+    "# Calculate output of image discriminator (PatchGAN)\n",
+    "patch = (1, img_height//2**3-2, img_width//2**3-2)\n",
+    "\n",
+    "if cuda:\n",
+    "    generator = generator.cuda()\n",
+    "    discriminator = discriminator.cuda()\n",
+    "    criterion_GAN.cuda()\n",
+    "    criterion_pixelwise.cuda()\n",
+    "    \n",
+    "# Optimizers\n",
+    "optimizer_G = torch.optim.Adam(generator.parameters(), lr=lr, betas=(b1, b2))\n",
+    "optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=lr, betas=(b1, b2))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "rN3cbiWaBUgf"
+   },
+   "source": [
+    "Start training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "msmQQUX-BUgh"
+   },
+   "outputs": [],
+   "source": [
+    "def save_model(epoch):\n",
+    "    # save your work\n",
+    "    torch.save({\n",
+    "                'epoch': epoch,\n",
+    "                'model_state_dict': generator.state_dict(),\n",
+    "                'optimizer_state_dict': optimizer_G.state_dict(),\n",
+    "                'loss': loss_G,\n",
+    "                }, 'generator_'+str(epoch)+'.pth')\n",
+    "    torch.save({\n",
+    "                'epoch': epoch,\n",
+    "                'model_state_dict': discriminator.state_dict(),\n",
+    "                'optimizer_state_dict': optimizer_D.state_dict(),\n",
+    "                'loss': loss_D,\n",
+    "                }, 'discriminator_'+str(epoch)+'.pth')\n",
+    "    \n",
+    "def weights_init_normal(m):\n",
+    "  classname = m.__class__.__name__\n",
+    "  if classname.find('Conv') != -1:\n",
+    "      torch.nn.init.normal_(m.weight.data, 0.0, 0.02)\n",
+    "  elif classname.find('BatchNorm2d') != -1:\n",
+    "      torch.nn.init.normal_(m.weight.data, 1.0, 0.02)\n",
+    "      torch.nn.init.constant_(m.bias.data, 0.0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "6UXrZLLNBUgq"
+   },
+   "source": [
+    "<font color='red'>Complete the loss function </font>  in the following training code and train your network:  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "7NUuGcQ0SiJw"
+   },
+   "outputs": [],
+   "source": [
+    "# ----------\n",
+    "#  Training\n",
+    "# ----------\n",
+    "\n",
+    "losses = []\n",
+    "num_epochs = 200\n",
+    "\n",
+    "# Initialize weights\n",
+    "generator.apply(weights_init_normal)\n",
+    "discriminator.apply(weights_init_normal)\n",
+    "epoch_D = 0\n",
+    "epoch_G = 0\n",
+    "\n",
+    "# train the network\n",
+    "discriminator.train()\n",
+    "generator.train()\n",
+    "print_every = 400\n",
+    "\n",
+    "for epoch in range(epoch_G, num_epochs):\n",
+    "    for i, batch in enumerate(dataloader):\n",
+    "\n",
+    "        # Model inputs\n",
+    "        real_A = Variable(batch[0].type(Tensor))\n",
+    "        real_B = Variable(batch[1].type(Tensor))\n",
+    "\n",
+    "        # Adversarial ground truths\n",
+    "        valid = Variable(Tensor(np.ones((real_B.size(0), *patch))), requires_grad=False)\n",
+    "        fake = Variable(Tensor(np.zeros((real_B.size(0), *patch))), requires_grad=False)\n",
+    "\n",
+    "        # ------------------\n",
+    "        #  Train Generators\n",
+    "        # ------------------\n",
+    "\n",
+    "        optimizer_G.zero_grad()\n",
+    "\n",
+    "        # GAN loss\n",
+    "        # TO DO: Put here your GAN loss\n",
+    "\n",
+    "        # Pixel-wise loss\n",
+    "        # TO DO: Put here your pixel loss\n",
+    "\n",
+    "        # Total loss\n",
+    "        # TO DO: Put here your total loss\n",
+    "\n",
+    "        loss_G.backward()\n",
+    "\n",
+    "        optimizer_G.step()\n",
+    "\n",
+    "        # ---------------------\n",
+    "        #  Train Discriminator\n",
+    "        # ---------------------\n",
+    "\n",
+    "        optimizer_D.zero_grad()\n",
+    "\n",
+    "        # Real loss\n",
+    "        pred_real = discriminator(real_A, real_B)\n",
+    "        loss_real = criterion_GAN(pred_real, valid)\n",
+    "\n",
+    "        # Fake loss\n",
+    "        pred_fake = discriminator(fake_A.detach(), real_B)\n",
+    "        loss_fake = criterion_GAN(pred_fake, fake)\n",
+    "\n",
+    "        # Total loss\n",
+    "        loss_D = 0.5 * (loss_real + loss_fake)\n",
+    "\n",
+    "        loss_D.backward()\n",
+    "        optimizer_D.step()\n",
+    "        \n",
+    "        # Print some loss stats\n",
+    "        if i % print_every == 0:\n",
+    "            # print discriminator and generator loss\n",
+    "            print('Epoch [{:5d}/{:5d}] | d_loss: {:6.4f} | g_loss: {:6.4f}'.format(\n",
+    "                    epoch+1, num_epochs, loss_D.item(), loss_G.item()))\n",
+    "    ## AFTER EACH EPOCH##\n",
+    "    # append discriminator loss and generator loss\n",
+    "    losses.append((loss_D.item(), loss_G.item()))\n",
+    "    if epoch % 100 == 0:\n",
+    "        print('Saving model...')\n",
+    "        save_model(epoch)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "Ed-ZbuVWBUgu"
+   },
+   "source": [
+    "Observation of the loss along the training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "nOLW054DTLpg"
+   },
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "losses = np.array(losses)\n",
+    "plt.plot(losses.T[0], label='Discriminator')\n",
+    "plt.plot(losses.T[1], label='Generator')\n",
+    "plt.title(\"Training Losses\")\n",
+    "plt.legend()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "S58kJj9HBUgV"
+   },
+   "source": [
+    "If the training takes too much time, you can use a pretrained model in the meantime, to evaluate its performance.\n",
+    "\n",
+    "It is available at : https://partage.liris.cnrs.fr/index.php/s/xwEFmxn9ANeq4zY"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "i0TC5qK3BUg4"
+   },
+   "source": [
+    "### Evaluate your cGAN"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "fYBRR6NYBUg6"
+   },
+   "outputs": [],
+   "source": [
+    "def load_model(epoch=200):\n",
+    "    if 'generator_'+str(epoch)+'.pth' in os.listdir() and 'discriminator_'+str(epoch)+'.pth' in os.listdir():\n",
+    "        if cuda:\n",
+    "            checkpoint_generator = torch.load('generator_'+str(epoch)+'.pth')\n",
+    "        else:\n",
+    "            checkpoint_generator = torch.load('generator_'+str(epoch)+'.pth', map_location='cpu')\n",
+    "        generator.load_state_dict(checkpoint_generator['model_state_dict'])\n",
+    "        optimizer_G.load_state_dict(checkpoint_generator['optimizer_state_dict'])\n",
+    "        epoch_G = checkpoint_generator['epoch']\n",
+    "        loss_G = checkpoint_generator['loss']\n",
+    "\n",
+    "        if cuda:\n",
+    "            checkpoint_discriminator = torch.load('discriminator_'+str(epoch)+'.pth')\n",
+    "        else:\n",
+    "            checkpoint_discriminator = torch.load('discriminator_'+str(epoch)+'.pth', map_location='cpu')\n",
+    "        discriminator.load_state_dict(checkpoint_discriminator['model_state_dict'])\n",
+    "        optimizer_D.load_state_dict(checkpoint_discriminator['optimizer_state_dict'])\n",
+    "        epoch_D = checkpoint_discriminator['epoch']\n",
+    "        loss_D = checkpoint_discriminator['loss']\n",
+    "    else:\n",
+    "        print('There isn\\' a training available with this number of epochs')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "4V0DwQomBUg9"
+   },
+   "outputs": [],
+   "source": [
+    "load_model(epoch=200)\n",
+    "\n",
+    "# switching mode\n",
+    "generator.eval()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "gyvmvkIvBUhB"
+   },
+   "outputs": [],
+   "source": [
+    "# show a sample evaluation image on the training base\n",
+    "image, mask = next(iter(dataloader))\n",
+    "output = generator(mask.type(Tensor))\n",
+    "output = output.view(16, 3, 256, 256)\n",
+    "output = output.cpu().detach()\n",
+    "for i in range(8):\n",
+    "    image_plot = reverse_transform(image[i])\n",
+    "    output_plot = reverse_transform(output[i])\n",
+    "    mask_plot = reverse_transform(mask[i])\n",
+    "    plot2x3Array(mask_plot,image_plot,output_plot)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "nqvrxBoGBUhD"
+   },
+   "outputs": [],
+   "source": [
+    "# show a sample evaluation image on the validation dataset\n",
+    "image, mask = next(iter(val_dataloader))\n",
+    "output = generator(mask.type(Tensor))\n",
+    "output = output.view(8, 3, 256, 256)\n",
+    "output = output.cpu().detach()\n",
+    "for i in range(8):\n",
+    "    image_plot = reverse_transform(image[i])\n",
+    "    output_plot = reverse_transform(output[i])\n",
+    "    mask_plot = reverse_transform(mask[i])\n",
+    "    plot2x3Array(mask_plot,image_plot,output_plot)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "qkFVjRsOBUhG"
+   },
+   "source": [
+    "<font color='red'>**Question 4**</font>                                                                  \n",
+    "Compare results for 100 and 200 epochs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "k85Cl5_UDWyv"
+   },
+   "outputs": [],
+   "source": [
+    "# TO DO : Your code here to load and evaluate with a few samples\n",
+    "#         a model after 100 epochs\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "colab": {},
+    "colab_type": "code",
+    "id": "_GbMIfRXBUhH"
+   },
+   "outputs": [],
+   "source": [
+    "# And finally :\n",
+    "if cuda:\n",
+    "    torch.cuda.empty_cache()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "rVxSSPJgK60P"
+   },
+   "source": [
+    "# How to submit your Work ?\n",
+    "\n",
+    "This work must be done individually. The expected output is a repository named gan-cgan on https://gitlab.ec-lyon.fr. It must contain your notebook (or python files) and a README.md file that explains briefly the successive steps of the project. The last commit is due before 11:59 pm on Wednesday, March 29, 2023. Subsequent commits will not be considered."
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "collapsed_sections": [],
+   "name": "BE2 - GAN and cGAN.ipynb",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}