hello.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "gpus = tf.config.experimental.list_physical_devices('GPU')\n",
    "for gpu in gpus:\n",
    "    tf.config.experimental.set_memory_growth(gpu, True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "import datetime\n",
    "import random\n",
    "import math\n",
    "import pickle\n",
    "import gc\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "import tensorflow.keras.backend as K"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = tf.keras.datasets.fashion_mnist.load_data()\n",
    "(X_train, y_train), (X_test, y_test) = data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((60000, 28, 28), (60000,), (10000, 28, 28), (10000,))"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape, y_train.shape, X_test.shape, y_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x2310a3d7190>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(X_train[0])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 28, 28)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Conv2D, Dense, Flatten, Reshape, LeakyReLU, Dropout, UpSampling2D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Build Generator\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_Generator():\n",
    "    model = Sequential()\n",
    "    model.add(Dense(7*7*128,input_dim = 128))\n",
    "    model.add(LeakyReLU(0.2))\n",
    "    model.add(Reshape((7,7,128)))\n",
    "    # model.add(LeakyReLU())\n",
    "\n",
    "    # applying upsampling\n",
    "    model.add(UpSampling2D())\n",
    "    model.add(Conv2D(128,5,padding='same'))\n",
    "    model.add(LeakyReLU(0.2))\n",
    "\n",
    "    model.add(UpSampling2D())\n",
    "    model.add(Conv2D(128,5,padding='same'))\n",
    "    model.add(LeakyReLU(0.2))\n",
    " \n",
    "    # down sampling block\n",
    "    model.add(Conv2D(128,4,padding='same'))\n",
    "    model.add(LeakyReLU(0.2))\n",
    "    \n",
    "    model.add(Conv2D(128,4,padding='same'))\n",
    "    model.add(LeakyReLU(0.2))\n",
    "\n",
    "    model.add(Conv2D(1,4,padding = 'same',activation = 'sigmoid'))\n",
    "\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "generator = build_Generator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " dense (Dense)               (None, 6272)              809088    \n",
      "                                                                 \n",
      " leaky_re_lu (LeakyReLU)     (None, 6272)              0         \n",
      "                                                                 \n",
      " reshape (Reshape)           (None, 7, 7, 128)         0         \n",
      "                                                                 \n",
      " up_sampling2d (UpSampling2D  (None, 14, 14, 128)      0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " conv2d (Conv2D)             (None, 14, 14, 128)       409728    \n",
      "                                                                 \n",
      " leaky_re_lu_1 (LeakyReLU)   (None, 14, 14, 128)       0         \n",
      "                                                                 \n",
      " up_sampling2d_1 (UpSampling  (None, 28, 28, 128)      0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 28, 28, 128)       409728    \n",
      "                                                                 \n",
      " leaky_re_lu_2 (LeakyReLU)   (None, 28, 28, 128)       0         \n",
      "                                                                 \n",
      " conv2d_2 (Conv2D)           (None, 28, 28, 128)       262272    \n",
      "                                                                 \n",
      " leaky_re_lu_3 (LeakyReLU)   (None, 28, 28, 128)       0         \n",
      "                                                                 \n",
      " conv2d_3 (Conv2D)           (None, 28, 28, 128)       262272    \n",
      "                                                                 \n",
      " leaky_re_lu_4 (LeakyReLU)   (None, 28, 28, 128)       0         \n",
      "                                                                 \n",
      " conv2d_4 (Conv2D)           (None, 28, 28, 1)         2049      \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 2,155,137\n",
      "Trainable params: 2,155,137\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "generator.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 1s 526ms/step\n"
     ]
    }
   ],
   "source": [
    "# np.random.randn(1,128,1)\n",
    "img = generator.predict(np.random.randn(3,128,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 40ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 15ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 14ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 16ms/step\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAN5CAYAAADZ5oiRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAADBRUlEQVR4nOz6Z5Ql6X2Yef6vN3lveltZVVm+urraN4AGGp4OopEoklpRoryWOqORjmZGo7HnaHdGM6uRm9HorGa5GkkjRy1FSnQgQAgE0DCE6wYajfbd5W16nzevd/uB3ygd9oPs7tAHPb+v9ZyIGxFvvBHxVqaGw+EwJEmSJEmSpASl/0P/AEmSJEmSJP3Hx0UpSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJS5Lw6X/62+jLpUboO4nHv4u6tqDHOq+cOsC295hAXWpRoZ1nRTqIiKGUx0Ysm0Om+w3BrwmKbi91Dg8jm12rgdF9vsyNfb7BrNt1A3rbPin4PUYOVZj+4Xbi4hotdj4j9UiytJwvHanemy/2SHK5hd2UffcJ/4m2+/v8tFn/ivU/ZkTX0fdem8Mdf/0zQ+g7gPHb6PuE5OvoO7zuw+h7qWtY6iLiNjeqaBueJBH3dQSu+alXBd1927NoI5Kddm9kD1k/3eTO2Dba0+x+a4/xc7LBy/eQN1qYxR1yzts7EdEtOtsLEQP/v8Xm04iU2Hnplxmz4IzEzuo+40P/x+o+/e59Gv/I+pGyy3UnR3bRt3VXXbfPD5zH3VUKcOu0VabzTsREWdHNlH3i28+ibrODntujl5l7wpdeCiZJ/ZQ9/DsKuq+dWcJdf06e59Itdj9euEyGzPtPjt/l8fXUPfV5TOo+15Ui2yuWF6dQF2uxMb/cMDO9Zm5LdR9/uP/O+p+t7/wnT+OuvdV2fPmbmcadb904wnUHe6VUEefNcdOsPmzkoPfOxGx32bzyUiebXP9oIq65l3WZQ/ZO0q/xB7EuRo71+1T7N7KFtk9U4LdgH5Lw+6RuRXU3amxOSIiYuU2u0/yE+y9oLdaRl26zY65N9pHHX13u/Pn/+vf89/9SylJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJS5Lw1SHrV8N00PUXSyvoe5kbht1r+4uoG4zM0Bd+s0x1BV22PFGRGQ6BdQVd/uo273ALl+6g7KoL7JjSe8VUTd6k+13mMmgrldOoa5zwH5fb4Qd75Au3X5jHGWDPNxeRFR3WTf3zX3UNY+PoG73fA51jQV2Djdyo6g7qv6AXaT7nSnU/fLtx1A3eI0d1/Hz7EJ+evtRtr3iHuqenr+FuoiIF3PHUXfy3A7qMik2Nl7dYnN3fpPNE6UNNk8Ud9mzoH6Mba81DZ8Fx1oom6w2ULfaYGPw1vI06rKr7DkVEZEusGNOsUdapBebqOt12Vjo99m8sNcuoe7t+JHTr6PuSm0OdevNKuraXfaesNmqoO4Dk+zB/ou3nkRdt8+uZUTE4QQbm2n4HppusvGRbqMs2ifYnDKZ66Hu5j57Xg0HbI4K9vNiWGY37PXVWdR99Ow11D1z+wLqil9hYz8iIn8A3/Oa8NpNsjHTK7KxerjE9ju1VEfdURXSXdS9t3gXdX9ydAt1Gx12LRfP7aHuH//bH0DdSrB7KzvCzktExPREDXV0zit9mj3bJ/bYGEr1WVc7zp4Z7XGURWaNffRka+yeaVTZPd0bY/NYfptdj1OnX0EdfSeLiJhfYmscH5m/gbpfG7BviN4m+07O7bNz051gz7S34l9KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcVkaFufqqMtkBqj75v5Z1P3zvfejbmVlEnUj403UtSaHqBtkUqiLiEh3WdcrZVCXYqc6yhssrKywY955gP2+7ff0UVdcY9trzbDtxZBdE3z+Th2grrFQQN2gw443IqK/lmNdJY+3SZTX2cmpH4cb3GTn5qjuX5lF3T9en2AbrLHzXmFDI241plD35s4c6r7bYSd+MODz0+CVMdRtto/hbRLZBuuK8FAG8Fagc/fMix3U3f0h9jjtH7KxtR9l1NWb7N7KrLNu5rF11EVErNxl47o40UIdHa/DHvv/tMZuCXXbafbsezsOekXUHS/voe7z1x5AXQ/OZdfgc3OjUUVd98vTqOs/vY+6iIi9NruenTa7F089soK6e61F1A2K7Lm5c429r55/9B7qDopsbA2vsfM3vFxD3eBmBXVfzZxBXbfJxmqpz+/XLptGoz3G3ssOT7J9Z5usS8FDSdPwiPbgicrA3/HHb38Mdd+8cRp1pRH2HKbfWdltNkf04HdCRMRulp3DarmNuq33sm+eU7/OfuTqB9n9Nf8cO4m5wx7qmjPspWz3PLsHhyfY+8T419l8l+6xMf3LVx5DXbfBv8cKFTYWisfYNalW2BpH5zsjqOuyx32k2u/M3zj5l1KSJEmSJElKnItSkiRJkiRJSpyLUpIkSZIkSUqci1KSJEmSJElKnItSkiRJkiRJSpyLUpIkSZIkSUqci1KSJEmSJElKnItSkiRJkiRJSpyLUpIkSZIkSUpcloZzYzXUHbQKqHth7Tjb3mYFdZmDDOrqwxLqUqUh6ko3UBYREZXlHuqyjT7qdh5g5zrdY8fSqbA1yvIa216uwa5JZxRlMRxh5yXYz4shXJJtNuB5zrAdZysdtuOIKK/kUXd4nP3G/OEAdf18CnW5GuuG8Nwc2XgXZQ8traDuytos6g6DzSffvHUGdf0eG5T0OK5+5TTqIiIq9+E8McauOb2vR1bYfrtVtt/iOhvjh8fZuR6/xsZW9Ra7Vw/OoyzgbBej803U7Y2w81KDz/CIiMJ4C3XtRg51wwG7xuNTh6jbW6uirtPBr0JH9kjlPurms/tse4/dQ106xe6vz25eRt31nWnU5ffYfvvPjKEuImKrytqZZTbW94uLqJvbYdsbptn4Xf4Btr1ylr0r9K6ycT6osGuSus3eu/v0PTnHZrOpsTrq1h6dQl1ERLBTHfkd9r5avbCLut7XJlHXnmXnppBm3w9H9cXXH0Dd1555GHW9ETY2hhNsjOez7PgbY+yC53bZ8z9Vok/iiD68b7aq7L0xU2e/ccAer5Fus/lp5cPseVjcYDvujaAsUvBU599k56+8yTZ4eJzd+5nX4bw4DiediMi9yd4bfyX7GOqG8FMry15r8Ryf6rOx9Vb8SylJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCUuS8OxfAt1+XQfdTvNMurSxR7b750c6lKnmqibOVFH3Z3qNOoiImrL7DcWd1jXnhiiLtN+Z9cep18+RF3t9AjqGvD3lZ6soa7ZzqNuvNJA3c4BO47eMhvTxRV+PdJddo1rS2yb/SLrsmz4R3dsgLoUmxaOrPx6EXVX7pxGXb/EznsUYQcNWxnU7bVKqOudY/NdRMTOGDuHkWbXPMa6KNs9z7aXzrBuf43dh4UdlEWvwubj3CEbC8MU228Kzou7K2Nse3Copp+ZYGFE9E6yjabhzmcub+J9o/022f3U7bD76e34+u451HUG7DdXc23UfWftOOpqO+w5d/nMMureeJiNy7lvfi9zKLsnJr+zjbr2wijqdi4VUNdnWZw4vYq6jUYVdaV1NqkcPMjm5HPn1lB3a429/56eYpPth6euo+4XO0+i7nuxl2Pnevg6mx97J9lLT26X3e9fvXUWdfE+lv07+vDBBOUX2UtkucjmsZ0tdn1SFfbNGHvsOyG1xbqIiOIGPIcb7NO7fgK+a0GtBTYmi/Ps2tXG2LtW6T473tkX2Px0eIxtrzvCnhfNOfYMKq+w61te4/dSYZ9d490ie54OCuxYSvR9NcO6Qfmd+cjzL6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpS4LA0ruTbqbu1Oou5grYq6qe9kUJerD9h++2OoG/1926grVtl5iYhonxiirrOYQl16j12+xjxbe+yX2O9rzbBrd3imh7oIdu2emtpE3e19Nga3dtlx9A7yqEvPsLHQ7BdRFxERKTYWuiNwbM3Da9Jl+82Md1A32C6w/R5R/RQda8zofA11P3TyTdR9cfk86k4s7qPu6uYM6splPj8dptg1GrvC5uRekXWtaTZ2uwvsWIqLh6h77D3LqHvlsQXU1e+Ooq6wy+bjVB9lkWmxjs7HBxfhjiOifJ9d4wg2n4wV2MFcvTeHumGRPVtS7Xf//+eevX4adcMme64XNti5L6+iLDLn2H149RunUHfqGfZsqC/kUBcRsfAV9l4WqxsoyxXZsz3TYt0wzcb5veUp1BVvw99HXykG7PetHbB3o1yezSnvnbiDusdLt1E3d5E9JyMi/u6b34+6/Ch8vrzGxms9B9/dJth8m0ux+/PI+uz35i4doO5jJ66j7vnNE6i7uLSGuttfO4m68avwvWOEnZeIiMnXm6jLbbD3y/p59i1T3GLPzcJGBXUj34Hf5/vs+Vq+z4734NwI6lJst7H9KLvGw4ku6vrwO2YA7/2IiOp9NoeWNtg2W1Os64yjLPoV9vveqXco/1JKkiRJkiRJiXNRSpIkSZIkSYlzUUqSJEmSJEmJc1FKkiRJkiRJiXNRSpIkSZIkSYlzUUqSJEmSJEmJc1FKkiRJkiRJiXNRSpIkSZIkSYlzUUqSJEmSJEmJy9LwZGkHdcsjY6irV4uo2/t4B3Xl75RRN/1qD3WvnD+Ouu9FfjmHus5MH3WZVgp17ckh6tJdlEVrCm6vwdY8h9PsGj9/5yTqii+xsTCcHaCutMOOI9Nht9PED6yiLiLi3o0Z1I3cYfvuttixjF7NoK72PjZoMvV3d/17fOEAdXsro6g7WKui7jP9B1HXf5XNiy/NjqOucotd79pFdm9FRESJ3Q/NWXYtyytst70ym8d6fbbf1nIFdS+nj6EulWLzXbbBjuPRH3wTdTd2p1G3dX8cdWl47+f3+L06ssLOzZCdmrhyawF1mV02/gfskRvDAhv7b8fZ45uoq+ZaqKufL6Du6q151FGDNns23P1EHnXD402879qJKdQtfoW9X6bb7H2wM84GcLbO7ofose0NCmx7xS22vZHb7L45/n+iLFY+yp6T//LWR1H3yQceRt25yS3URUS022wS+O8f/Szq/nr/R1CXuldiXYddu+4eG9NHRd/X65vs/fqzrUtsx/DhsH44wbY3zb6fNqbYfis3+PMwNYDPwzv3UVcqszm+eXwEda0l9j7YL7F7pn8Hvguyw410l52//dNsv4Mq+z6BryfRY0M/+iX4HIiIzIvs3aNfYL+yeRJ+yMODnju+i7rNbfYseCv+pZQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhKXpeHnlx9A3fmJTdTdXz6GukFuiLry+gBuL4W6/GoOdZ1jHdRFRHRme6jLbbPLUthjx9IZY+dwkEFZZFpsv2l4ajpFdrzZLfYDJ671UbdVYttrnmujLtpsez85f5VtLyKezXZRdzXF7qdUmY3B3gg7luGAjYXUUgN1R1U7LKHu5Gfe2f1uPTSGukGV3YN5OMbnvtVCXbdSQF1ExPh72Ny9kR9F3SDP9p3qsXNTvJtHXedsE3UnJ3ZRd2l0DXW/uvkk6g46RdT9nUu/jLq/MvxDqNtZZWO1Pc7mnIiIww67xuPX2fM5+mw+GcJnVflEDXXNOhtbb8ft9SnULUzto+7+1VnUpdgpjaWLbJyvPMueNdW7bL/NvTILI6Kwy+aKnQfZNhtz7OT0y2y/3QrbXukue7/sjrL9dtitHT14HFd+toq6YYHNFcVldry7W2y/316BBxwRS2c2UPf/uf4x1PW32ZyXpv/lD+/Pd9v8g+w81Vrs+HMZ9h6+fzCCOqo4w57/7XU2R6T54zBqS+zZPl47hbrWMfYbO1U22CpX2LcWfb8svLmMuu7pedQNM+xmaC6xi3LhNHum7bfZdQv2yI3JEv/e6f8qey/IH7B3lMp1Ntem2O0ZcZxl2Tzd4O/Nv5SSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4rI03L41wTaY6aOusJ1i22uwrrzRQd2QbS5ytQzqOn24wYi4cG4VdSs3TqJuwH5i9MpD1J1/9B7qvn/2TdTt98qoW22Noe65X38EdcWNNus22e9LdQuoa55lY3CzU0VdRMSNtRnU5SZaqCsVu6jrpYpsv/fYuenM9lB3VP/PJz+FutcePI66f/PyE6grlJuoe//xO6j7+jcfRN3qB9j1ydZRFhERW7tsXM7OHLANfn4aZYX9Aeqak2zCq3dKqLu6toS668fZPThyM4e6N4vzqPu53MdRd9hgYyHVYv8HNRzwZ1qGTTvRZ6cmisssbE+x94xUij37UhnWvR3/6Kl/gbrPHTyEut/40gLq2hPs2Ja3xlE3zKMMj42Z77JnUkREfYG9srYm+Rgm6DvU5HW2vcIBm/N6JXYcxR32fB3k2fY2H2XneeZFdl5Kn/wG6g5+5v2oG39tH3UREXsPsvm2P87Ozdw+O+aDJba95gNs/Gey7+4cRe+YRoO98/UbbAylGuy5nq+x51dmht1b2Wn27tZdrqAuIqK4A8MU/f5lz7n2GDuH5TU2hvKvsW/B3uYm6rINdq4LYxdRd/nCfdSdGmEX5POfZe/7C0+xb/jVg1HURURUj7H31d3L7Nr1x9izIA3XOI6XGqirt+GLwVvwL6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpS4LA2H2SHq1tfHUVcosP0Wdtl+m1PsUA5OsXW41ABlkV/PsTAiVq6eRF2uBo95JoU6eiwXRjdQdya/ibrrwznUnR5j2/vS4mXUbT1SRl17AmXRnmQncPEzGdR9+eYTbMcRMZxi++7PtFFXO2D3SXqSjcHcIRuD0YfdEX11/yLqRrLsPE1P11CXy/RRt1wfR13lLpufOmMoi5Fldh0jInLfKKFu/Uk2zscm2LFkOiiL2mk2hjJNtr3KPba9/fE86gpsKEQqza7J7f1J1E2PHaJuZaeIutJ9/FoQbThPpPpwXE/Ah9V4F2X0/uxk4H7fhn+w9jHUpYOd02yD7bdyj22vcZHdiO0Oe74ewPt146N8jkofsnb09C7q8ml23R8c30HddyqnUTf1LXaP9XPsHDZn2P2VZo+/6Iyz87L1MDuO+eZ7UNcdgcd7vIK6iIjKvRbqCgfsXb4+x465N8LGar7E5rLxCnywHdFegz3/6Zvcw+fvo+715XnUFW/AeWeGdZmRHuoaJ1kXETF8kk3Kg+w46jpj7GzXF9lYK+yw7U3NsneP4YVF1G2fYWNrh33ixR+orqPuVn0KdfkDdl7ub7KPxtGvsnetiIjCFruv+yPsPXTqOTY/7TzG5vjr69Oo6+7DRZ234F9KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcVkaXnrgPur220XUbS3Poa68NUDdxuNsfa1fHLKu0kddaaaBuoiIZjuHutRIC3Xfv3gTdb+9fAZ1PzP5LOr+l3s/irrrm9OoGyl2UFe5lUEdXWqd+zbb7/4Zdt0yLTZWx6+zLiJiv88OpnCWjcNshu17s8P2mz/Ioy7YbXdkz3z7IdSlxtk1H3TYWJuYrqGu2WFjqLzBrk9pE2XRz6dYGBED9hMjfcAeG/uPdFHX2GLbG+TYuekV2TH3S6yrvsFOTOMY+32FN0qoazVZt3WWPavKy2xMp9jmIiKiz35iNI6xCWDiVXZN6sfYe8buMTa2cuPsmft2lDLsfvjt6+dQV6yw/TZn4P1wYwx102+ya7n9CMqiONZmYUT0N9i9WLs2jrqRc/uoe3n5GOrSpR7qBhk2Lkc22M2YbbC5p3ac7Xfh0gbqVtbHUVe/U0DdyCo73pGXVlAXEdGfn0DdxpNl1B1cZvdx9OGz94CdmwH8LjiqxiqcUHrsuF7rL6Aus8zm8oCn84cffwV1314/ibpGEb4YRcRUhb2H7yyMoi7FppMor7CTk23BF/H1LZR1j59G3dRzbD4ZpmdR9/nN96Oueo/Ni4OzKItqpYm6vYfhd1FEDNNs3okie062ptgcPyywc9OF89M7xb+UkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4rI0/JunfxV1326eQt0v5t6Luhujx1BX2EyhblAYoi7dZut1qRTbXkREv5ZDXQ12z+dPoO7UxC7q/odbP466W5uTqItbIyjbP9VAXfdSl+03w65JdySPuqnXeqjL1Vk38vVbqIuIqDxwEnXXlsZQN7+0jbqRySbqGq0M6lLdd3f9O3vItr/wW+ze6hXZfHKwNIW6+qk+6hZbbOxW32T39N4j8F6NiCG7lFFeZuf68OwAdZkWO9dTj22gbmu3irpWiz3+8q+weSLdY8dRYJcusnAsDO+wCzd2g43Bbpnfq6n7dK5l5ybXYNsbWUZZdKvs3AxH3/3/nztVYnPvy2MLqNufLKCO3teVO+wctMfZ9oYZdv+nXmT3a0TEYJJtc8iGWzRb7Hnw4MI66l579gzqemX2A9tVdk3oPUvvr/Eie/6n59n2Wul51K09xQZr5vEl1EXw8T+4dMjCA3bfFTbZjjun2Htju4s/145k4iR7MD02s4K6L75xEXXFA/iu9SB7/3+schd1L2+zb8un5u6gLiJivrCPup+vsPuhtMHOTXOO3YeZJtveys+wa9dnr0Zx4jbbL33nmXuOzU9bj5ZR1xln++28OYG6VI6vC9TOsGfa5dPsvnsjy8bW5HgddXvX4DfEbJt1b8G/lJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuKyNPzC4YOoaw1yqLt+fR51mckO6lIbJdQVN1Oo64yjLIYvjLEwIrLVIeoyZw5Rt35nEnX7a7Ooay30UJffzKCuX2bH298voG7kNhuu7UcaqMsd5lGX6rPj6JXZecnPTqHud/Y9QN3Sp9hvvPtDM6jLzbNzOCz3UZfKsuM4qn6eHX/+oIu68r023HMVVYM8GxupPrsHBwU2z+5e5P/vUNhlXWeUnevCZBN16Rk2Nj7z0M+j7p8fsGfV//HZ34c6Ks0eVdGaZl1qwJ5VAzj2DxfhGPwebtVMi3XdKjuW8ibb+RAO6yE75Oi3Yfg2/NK1J1DX67GDy7TYOS3swHEE3wZr59icH3AcVZ7eZGFE/IlT30LdjRZ7ztV78N0jy54HL02fQF2nzebvCHbtittsDth+jO31QqHOQuip//xZ1G11Kqgby7FnS0TE529fRN3Ti3dQ99zKEura26OoG8K5J5N+d9+hdrbYu0xzko3dFBu6kYWXcvZrbIL6m53fj7pUj/3AH/m+11AXEfH59QdQ1y+x+7XzkRrrtsqoy2+xsVZ/kF2U6m+z7+5hkY2Z/AF7tqS//hLqUg+/H3XZOhsLC99gz4HVD7LnSkREe4Yd87V19kxLbbB9H6wW2fYy8Du+Rp9pvzf/UkqSJEmSJEmJc1FKkiRJkiRJiXNRSpIkSZIkSYlzUUqSJEmSJEmJc1FKkiRJkiRJiXNRSpIkSZIkSYlzUUqSJEmSJEmJc1FKkiRJkiRJiXNRSpIkSZIkSYnL0nAut4+6nxhZRd3nTl9C3b3X51E3eLiGuuZOCXWRHrLue1BYzaEu93wVdWm2uVj4Zht1tRN51OUaA7i9DOq6o2xttM9+XqTS7Pc15tk1nn6pi7rsXgt1/SvXURcRkV08BsspVJXW2NhqDcqoS02wczNSZefmqAaVPuoOloqoS/ULqOtUU6grbrOxtn+aTcnFDdblDlEWERHdEdYN4bzT2WZzbW6PzRM/kP/TqFscPUBdfomdnPoCO9eDDjuO3D04zx6ysZVtsq52ms2Llbvfy/9VsX0Xdtj4Ly83UHe4xOYnOlZzxR4L34YPnriFupk8e5f55tRp1N19dQF1WTreamx8lFfY9vb3p1EXEdE4ye6dtdYo6rIpdk/89u2zqEvV2RzQOcXeyfpr7DnUK7NzPciz4z3ssv1eXZ1F3WqNvXfUm/B4e+w8R0ScnttG3X8+/wXU/Ub5MdT9k9rTqIs+u58OamzOO6qlRXaenrt1im3wkD036Xs9fddKdeC9UGL3wo3GDOoiIm7fZPfD1OvsN+7OsQdYpsrew4fwXSubY+/TrSl2HP0RdpH3z7LjHf6lD6Du4Dw7jvwce+84WKmgrshupYiIaC2x3/jUyduouzsxibo799hzN5Vj90k0+Zz8e/EvpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlLgsDf9fL/8ICx/5DMp6A7Yelp5toa7TzLHtteA63IBllbt8Xe/4L95AXX93D3XNH3wUdfVj7NzUF1Ooayyxk5Nusu2V1tg5TPVQFvFGBWWtObbB5Y+XUVfcKqGu82NPoy4iYvaFDuryX3kFdYUnnkBdewplcebEBupurU2zDR7RxXMrqFt5cwl1leUh6uae3UddZ4qNjcPFPOru/Cgbk4MzDdRFRMR99huLm+y+HruSQd3eJZTFdJkdy/966ldQd+H8COr+6sbDqGsP2OP0+cWTqNv/lWOoy7ApInolNs92Rtn2IiJyj++irt5k43rvATZ35/fYGBxm2Bzfhe8Pb8dgyH5zH/5fYb3Dzmn51AHb3v0q6oYF9vwfbLFz2jkOB3BEfGqZ3Yurb8yirrjBznVlmz0PStvs3PRK7Nqtf5iN35NPrKOOjsEXb59AXeXFIuraH2LH8ePn2XvMv/nGU6iLiFgtsgntD33zP0Hdmbkt1A3r7HmQ6rFrUhhrou6oHpxYQ10u00fdapmd98aAzfkj99n7RLDTGSN32PX57uIi22BElO+wOe9wic0ngwP4Xdth89ggx/Y7W62jbudxtr1rJ9m7ZXWOvU8c7rH336VFdq/e25hE3dhN9qyi39wREfNfYOPw2bXLqEuxSxIZ9gjCUovvzPzkX0pJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxWRp274yg7m/lfgh19ZtjqMu0UqjLDVAWmQdqqPvRM6+h7rfuPsB2HBH3U2dR1x5n28u0WFfcHqIu22DbW/hiBnUTzy6j7vbPnEDdoIiySPVg12Vrst0qO3+teTYIs/t8Lbg1yW7R4tkl1HUr7H4qbLPu7tYE6gbwXB/Vrc0p1KXYtBPbk+z4U4Mq6loT7PjLm2wMDdNse/2tAuoiIooH9JjZ9jrjbHuZFru/bnz3OOo+ceUvo+7U+XXU3VmeRl11nE2gtbujqJvfY+cl1Wdd5ja7HptPoiwiImZK7CE0O7WJujfyc6hr1tm4Tu3nUDfsvPv/P7feYnPFSLaNumKWPej2Dsqoe+SR26hr9dkz6XqNPdcfPXMfdRERL11j23z4iduoq3XYOFr95jHUlbdQFmNX66hL99h7d+sZ9vs2H2dzQPE8e0+uPcDeBR+e2kbdJ689jLqp5/n9uvMou++CTaOxXGQvEX/yg19H3b985X2oazXzqDuqtSY7T7fW4bsW3G/lNhtDffz+D8f4Frvg2xtw/ETExA7bZhp+o3SrbJwXN+D7IDyHW99iz+HOyQ7qfvSJl1E3gKOmusTeO76yeg515xY2UHf/vew7qzMBJ5OIqNxhXbbJzk1rto+6TJONmdIa3O8J+GHwFvxLKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJS5Lw6c/+DrqvnVvCXXD/BB12W22bjbygS3U7VyfRN0vb74Xdbm9DOoiIia22TEPsinUNRYHqOtV2Paqt9nvS/dY1zo3i7pemW2vO8mON6pdlKXSbL/D9QLbXped59TZOuoiIjbyZdRlW+OoK+zDazfJjqVzwM5N9Nj2jurppVuo+/rNh1CXO2C/tz3K5qe5r2yibvPpGdTlauz3DdP8/x1a833UVW+wOa/Lhm60Z+B+r7HHVb/Ajnl5cgx1E9/Io27vgRzqqvfY7xu9to+6nYdGUdeaovcgnGcjopzroO7aNhvXjb0S23GXncNsnXXp03xOPqr3TtxB3f8ww961PrR1gu34DrsRr71yFnVDOKVU91j3WvcMCyMi32Pd4Bwb64sj7B573+9n1+7X0x9AXTxRQVnlLtvc1CsN1JU22dzde/IQdetDdp6nCuz+6nUXUFc44HPU5MtswA7Y9B2HdfbceHb0NOomx9m52dqsou6ojpUOUPfy8DjqUhn2XB+7zbrDefitBcdka5ptrjDaZmFEtKbZu0KeneoobrBjSbNTGJ0Se/8vbrL9libY2P36CrsX9u+ye2vhPHufvjy5hro399i3av08e98ZucbGQUTExFU2vjpr7P0322Rz4+2fYl3mLpsYu4f8mH8v/qWUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZISl6Xhc3dPoa70tQrqhvND1LUvNVH3Dx7816j71YX3oO4Ldy6irj4cQV1ExOEiO92ty+yYB3W2vfReDnUHZ9k12XkohbqYYNsbHvZRl9/NoG78uQLqNt7P9puea6NuuJdH3aX5ddRFRLy0u4S6lQ+z9eXqLXbtsg2URabcQ92g++6uf9e67Jr3RgaoyzbYWGvNsPO5+oOzqBu70UVdfZHd0yl2uBERMXKXHXMb3tfVW2y/hT02j5W22cGU1zuou3GKjZm9B+E8lmZdc4Z1me0a6or77Bk0yLPrezjFzl9ExImRPdR1B2zfi2P7qLu+NsP2m2Jzcqb/7v//3P3WBOqeabJzVWux8bv03vuou35jHnWZGpwnplAWgyp7hvzOztm9c3dvHHVv1tkx5/LsN3am2TtFqsi65gPs3WNnWEVde4w9r0Z6bE7+A+deQd2tOhsMf+Ty86j79Zc/jLqIiPI6GzPFHfZ8aU+w8X/1DhtbqTrbXqYD37uPqJRh8/77Tt1G3WGPzU9vPHUadcULe6ibrdRRd/see4akGuwZEhExfZ+NtfoCu5bwkkSGTRORabL9dkbZcfSfn2Q7ZpuLuRvsHtxozqFuZYr9vvwqe5+evomymP0ie+ZGRPSnR1GX6rOTuH+G3XeFVZRxvXfmHcq/lJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuKyNOyul1A3XByirnBxH3UThQ7qnmucRd2Hq1dR9/Cl+6hbPzeGuoiIG40Z1P3ciS+h7sMv/gzq9sbYtevuFlE3/iobNvvvQ1mU5+qoy7/OznXtJNtvqsvWZAtvsvPXPMXG6vdidL6Guvct3EXdM9MXUTfyKhsL/WYGddF7d9e/X1+fR1315AHqDooV1OW22L3Qmmbz4thNlMXSp3ZRt/LxCbbBiMgdst/YmGddcY91sceyTGfAui+9gLrxB59G3d4T7L5O1+DjNMWy9qlp1o2ye7A7wnac2sqjLiLiC51LqCveZdvsl9mYgSMrsnDa6eXoFo/ucmUZdd+sn0fdifE91N185jTqCnD4FrdZ12ePkGjPd1kYEX/4Eru3P3X7IdTNTbH30JkSe0d5vceeQ334PGzfZc+h05++xfZ7nL2DXn+C7fevPPx11L1QnUTd37n9CdQ1jrFnwe9g57q4xboBvE/OLa2j7vb6FOr6HfiudUQv7h5H3U6DvQ/vrLH39bFl9lw6PMGeIXcPC6iLPtvvsAcf2BGx+yAMB/A5By95fxp+ewzYsdB3mfQu216/yI63OQO/yeAzqDfKtteZ6bEN3mTnpXlhlm0vIgZZdg63Hs6hLv9BdnJyfTa4ajdHUZduvTPfeP6llCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEpelYXk5g7rOxBB1/+jRn0fdL+y8H3Xf2V9C3a38DOo++9pl1A37KdRFRFSn6qj76faPoa7eyqPuzOw26v7Ck19C3a89/iTq/unJr6LuJ6//IOqujI6hrj09QN34G+zaTV5poe5+voC669fPoi4ionGsj7qv906jbthkt3xrit3H6RrbXopdkiNbnNhH3fIuG0OleznUpXooi3SPjbVss4O67mQJdbPfaaIuIqIzxo65foxd850H2H4bJ9hJTLfYM+jE8L2o27/ABmV5HJ7DcZY1dsqou/MjbD4ZucfGVnOe3dNDdpojIqJ0hz2DeiW27+4kGwv5dTYGB+znJSIT7By8p3wLdc/usDm/co/tt7DP7odekY232hL7P89Sic15ERHX6+z9rfXqOOoyy2y/Z3/2OdS9NlxgG9xi93bMtlH2xn/P3n+HI+x9InuXPQv+i7vsXfWbV8+gLp1jY/DkpTXURURsbBxDXR+O684E+403X15E3czFLdTtHLDnxlFt19/Z7adr7EFycJadz9xN9s5TfGgPdaWpLuoaHXYvREQcdkZRNyyy+zANuw+fvYG6SpbNtZ+7xl7eKucaqNu+MYm6QY7dg304fWZG2fFO/2YRdaM32fFm9/l7d6TYMZfm2Tmsvci6zin2bBlOwHeyVX6f/F78SylJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCUuS8Pm3AB1w+kO6r7auIC6L9y+iLpTUzuoa/VyqEvtsu7Xf+LvoS4i4oXWSdT9kzsfRN3Z6W3U5dM91I2mW6j70Ng11P16vYK623uTqIshywaj7HhLO2z4bz1cRF1+D2WRO4QHEhHtCbhu/NIoytJT7D5O99lu8xvw96VYdlRzpRrq/rtTn0Hdn1v9WdSNv8aOf/cJNiazDTbWeiMoi0GGdRERY7fY2OiOsW5QZOM8Xe2y7aXZnNwrs2sydpV1e9US6n780RdRVz7DnpEFOG//yr/4GOqqN1EWvRH+f1Vz32qgbv09ZdQNT7GxkFpjc3dvmm0veu/yBBURbzQWUFfrszngsFNA3cgqOwf9Ervu9WNsUhmw2zV6HfwaGi+tLKIuv8+u58SVNuo+/dmn2H4P2X7Hb7A5dOX74Ekssu2NvpxHXXuKzd3Pf/UB1KVKbHuDKpvzNmvwARgRvRG278Ieu3bZOutyNdaVHmL35+Qom2uPau/eOAvh8zoK7LxXbrD5pLHIxvjhIZs/62k2f56d20JdRMS1IXsPjww7N+URNj/NFdj7bzrF9js5VkfdmXH2DXp4jJ3rFvxmpPdqe5ftd+8i215xj82fOw+x952IiGyDXZOtp9jcmDlgz9NCid3H7Q12LN/Lt8bvxb+UkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4rI4bKRQl75ZRN3y5QnU/cUHv4K6PzV6DXVfa42h7r9Yn0XdH3/xz6AuIuKPnHkBddtfXkDd6vgQde/90Juo+7nVj6Nu+ZCdw7U32TmM6TbKRlgWpZt51NXn2PaaM+w8F3bZPRIwi4go7LC4O8p+Y2auyba3ze7j/ml2UdK3S6g7qsNuAXW1Afwd1R7Kdt/Lrs+ffs83UPfPWx9G3TDLrne6w//fobQBB+Z8C2ULU/uo6/YzqCvOsmty/8Pwxk71WQd95upl1FUr7B6cqxyirjnLxkL9cXbdSuUO6iIiNnrsWdA4xn5j9moZdSP34fjvsmdBZ2yAurfjfmMcdT81+W3UrUyw7b0+nEbd4QK7DyeusPswd8i622MjqIuIGBTYdU+xx0FsPs7CzgK7J3oH7JW6t8zm2vw2uyZdOH477LU7qrdYV1+E7ydTbCxktnOoa6Dqd5QP2W9szrGxNYSP1MIu295UsY66Xp6NhaMaluDzEL5TFNfZ783X4LvrTbbf/Wl2vRem2fvJD8+/irqIiFyGncODNnu//sjcddSdLmyibqtXRd0fOPEK6na77Hl95twW6r49uYS66zfnUXfiJNvv/QqbGLfq7LqV19iYjogYf72GulyjgrqDk2z8txtsLGRK7Fj61XfmHcq/lJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLisjTsVoeoG1a6qFtpjqHu+0ZfR93eoIe6a+151LW3Sqjrtvm63ptzc6hrnGLnMDLsmry6yY75gekN1K3cm0JdFAcomx6vo27rXI7tNwvH6n22vQHcbY8NmUj3UiyMiLGbfdQdHs+grjUoo66yy35jawqe63d5+ft8lY3dM7kt1FXGG6g73GcX/edffQp1wyqbx86dZMd7/eoC6iIitp9i1/KDp2+h7g/NPI+68TQ71xdzB6j7G1MfR92zf/89qKv/gUPUlQts3t6vsTEzkmfbqzywi7o/cfZbqPu5lz+CuoiI9AIbM+lTbI5vb7Bzk26z+W6QY78v0+Zz8lEVM+x67vVHULfTYXP53T/FniGj1Rrqlq9NoK64UUTd+BvsGkVEdCvsQTKEb7Y99hNjcobNPcNpNo4Odtg7VHeMXbuosOdGeoHNZfuFUdSVV1EWmSvsJWr6VXaP7J7Psx1HxJBNFVHaZF2nyq4xfR/calZQt3HAuiNrwZc0+N3RK7Ou8FPrqFu9MYO66Wk2j02W2HvHl7cuoi4i4o8usGfsJzcfQ92fn/wm6v71wSOoW+2w7+7X9th74+11No9lsmwemx9n1y5dZzd1Js2+QYdN9sBIw0/zFnwORET0xguoG31xDXXpLlxnqLFzWF9kx9KfgyfnLfiXUpIkSZIkSUqci1KSJEmSJElKnItSkiRJkiRJSpyLUpIkSZIkSUqci1KSJEmSJElKnItSkiRJkiRJSpyLUpIkSZIkSUqci1KSJEmSJElKnItSkiRJkiRJSlwWl2NdlFXGmqh7c2sWdb+Qej/q7ozfQN3d9iTqRo/VUHd5Zg11ERH3DidQV55uoK51p4q6em0Mdc/fHUVdup9CXfYYO45ao4C6uW+wNdT2GOsK+wPUUesfZ/dIq5HB28zV2LFkWkPUZZvs2nXG2fbGR9k13l58d9e/v7Z+BnV/dvLrqHtsbhl1L8Ui6g42K6iLLBuTZ6pbqLtZnWb7jYhCkY3fb1xn5/qFleOo+5kLz6PuuVQfdZ968VHUXXyNzfHlzTLqcvUe6uJsEWVbiyOoay6w/f7/0u9BXb+WQ11EROTZPNHfY3N8cYvNjaVNtt/GApvv+im2vbfj+RtLqDs3som6Z6+x+/Avv/cLqLvRmkHdJ9ceR1367D7qtlfZe0xExLHTbN7LwOtZyLJ750fnX0Hdb2+fR93LF9mc8kce/A7qPnnzYdT1++w53Kuy59D+JOuye+xTY+cBNvdMv9xGXUREus9+49ZDJdRlm2xs7T/dQl2mnUfdcMjmsqOqwm+eYo7dM2Pn2PGP5dk340qRfbtt3Wbd3gF7N+pV+HfC66tzqBuvsmP+WvME6n5j5RHUNbrs/spn2LsWHZODAevubbBv5EGFjcEz1W3UjTzQQd3qIntW7Wywb+mIiEybvQ/23su+NbJ1tt82O9XRK7P5bth9Z77x/EspSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlLkvD3P086lprrBu/yvb77UfGUPfc2GnUlapt1L1n8S7qHq4uoy4iopRZQN2d5WnUDSt9tuNeCmXpDlujHOaHqBvcGmFdgW1vmGLHUdoeoK45zY43d8h+XyrDuhjrsi4iDpeKqGtPsrFQ2M6grrPE7hOqNNJ5R7f3uy1W9lH3W/UHUffe0Tuoe2BkHXW/MHgP6h6ZW0Fds59D3XDA7pmIiOZmGbdEO8Xuhy+sPYC6p2duoi5dYPfC3R8eRV3v8iHqujvsXi0tw2sCpxP6X0v7VydRN/PANtxxxEie3dcbBxXUNYKNwc44m8eyDZRFd5w9M94O+nz4V8+9H3Wnf5mN8388/jTq5qs11KXg/ZVNs3NamWf3V0TE/+3EC6ibz7Lnwed3L6Nuq1tF3cohe199+swN1H3y5sOo67TZ82BirI667XH2aTA1zra3vzOFulydTnpcc5p9kwxYFv08m7/p/b6zwsZMZZad66Mq59l76WDIjn8ky54Nt/bYc6kAv0E78F24V2HzU/XEAeoiIup19g5wamyHbW9QQN1H566h7pX9Y6h76e5x1FWeL6Guyx7/kYOftI0zbKy+ss2+ufcO4LsvfKel39wRET12Ct/x7bXm2cnO7bMXzFT+nXmH8i+lJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUuCwN090U6jItuOPWAHXVm2zdrFspoK41m0Pd1+rnUHd3YRJ1ERGnR7dRN2xk8DaJbO2d3V7lKrsmtTPsGmdabGw1Z1g3zMKOZdHPs7Bwk43BVJ/tNyJiCC8dvT+7VXZNUjt51O3mRtj2UkPUHdW17RnUXdmaRV2/z8b4ZKWBumaDnc/7h+OoO2yz7WXvszEZEZGtszHUL7NrOThgg/dOg127tb0q6gLe180TXdTlb7AxXobnrznPJoBMk43BzOE7+39LW9vwPEfENryvBz32GwsT7AVisFtBXa8E552RHuvehsEBe/eIPJujDxfZHNC4yrq7jQnUxRQbv3spdt+kM/zZ8P/+4idQN8yxbc4vsXeyVwYLqNuG4/JYZR916TQ7jrPzm6i7MLqBuk/fegJ1u2vs+TKyBr8f2ux481t11EVEtCfGUDeAX0OtGXZ/zk8eoG77yjzq0nPv7jvU1i6b9wd9di139ti90K+xeTED3zty++xZM2DTYhzeYuMnImIwyp4j3375LOpem2NjYwg/ZvpvsmuchUMt02JhusN+X7bJtlfcYTdr/8fYflNwnu3ss/kuu4uXVvD3YI89TvE8NoTvGZ1Jdm7Gx9i30FvxL6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpS4LA3H37+OukY7j7qNB4psv2N1tt86215mmEJdZaSFuien7qIuIuKJyh3U1R4uoK43yKDu1u4k2+9BCXUHOXaNy2tszTPVQ1mkBqw7XIRheoiy7DQbC4MBO94h2+3vbLPDrnG2yE5ir5ZjO86yH5lJwXOY67P9HlE+y7b/wYWbqOsM8NSIzJZrqKt12Tx2COfZ2SfYvB0RsXx7moVw/Kb6bK4tTzdQ9+j8CutG76NuIbeLun94+yOoo7d1ocPuwf39MtvvgJ3nUqWNuo+evIG6iIg/OPEd1P3LzQ+gbr0xirr6KHsvWL47hbqJyUPUvR2F6SbqysUO6jY/WkVdKsOehwP4PBwesvG7OLuHulKui7qIiN4se8am4XPpR+dfRV0uxZ4vk+fYONrpVVC33mDXeKmyg7oPjV5F3cbjbL9XtmZRtzfJjjczzZ6Tb35gDHUREZkxNu89doI9N+7XxlH3kbnrqPs3F9mcV4HvOEd1bHqP/Y48O5/NHpsnmhOsuzy5hrovXz+PujSc73Lfw3kv5Nl7+MHWCOroN8XZmS3U5T/C3gf3O+xbsN1j78mrW+x+HTTZ9tKH7LtoDH7vz43D93P4bN7Ps+sbEVGbYte4OsOeLd0uO4flNHsvaDXYt0YWvme8Ff9SSpIkSZIkSYlzUUqSJEmSJEmJc1FKkiRJkiRJiXNRSpIkSZIkSYlzUUqSJEmSJEmJc1FKkiRJkiRJiXNRSpIkSZIkSYlzUUqSJEmSJEmJc1FKkiRJkiRJicvSsJzroq4/YOtc1el91E2X6qi7h6qIYq6Hur16CXWfvv4Q3HPEFwoXUdftZVBXzLNr0mzlUDcxcYi69CTK4mCxiLpBn42ZfheuoaZglhqiLpvroy6dZmNrrNxEXUTEfoONw26XjZlUkR1LvsTG1kipjbraITuOo2p12VT2pXvnUUfvwQo8/norj7pWk3XlEXjeW/z/HbKjHdSl0gPUdQ/ZsfTguX7+3gnUNRbYfgdwomjCsdXpsW4C3v+pcTY/dfvs/B0bPUDdVnsEdRERv7T1FOoaPXZNNuts3w14P8WAXeO9PX7MRzU1yt5lJopsfNB3rcMaew4P4XN4/BgbR49NLaMum2bPpIiITLC553xpHXXFNHvOvdZYRN2r9WOoO1HcRd3ZsS3UFeC7x3O1s6i7czCBuqVxdhyDIbsPZyvsHbRwih1vRMQ+fJfvDeA8WmHfLhM5dr+fnd9EXTnLns9HVcmzd4p2nz3n6HOpC+ed13bmUUff17stdhz0OyEiorbPxlp2h32T9Svsmi/vj6GO3oftDjs3Q7i9FPwmy4zAdYY+2+BhnT37Dmpl1A122XtHapzfq+kce6bVttk7SqbE5sYqPNfZagt1+Syfk38v/qWUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZISlxoOh8P/0D9CkiRJkiRJ/3HxL6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpS4LA3/1Lf+LOq+tXwSdc21CuomX2TrZvVjKdTFQzWU9W6y3zf1ypDtNyIOltixVO+ybW7+YBvvmyhcL6Iu/eg+6lp3qqjLLDRR19thv29Y6KNu6eQW6qZLh6j7sZmXUXe/M4m6iIhfuPoe1GWz7JjrN8dQNygNUDd+7IB1ZXaNv/L9/yvqfrelf/q32O+YZtcyB8/nXq2EumKxi7r6LXZ9xt9g811rCs6LEdGeZtc85tm889fe8xuo+yf3Poi6tWeOo66wx+bPdA9l+NkyyLH99gtsv+eevIu6bJpdt8tjq6gbDPmY+c2bl1HX3Gdzd/l6nm3vIhuDwy575qY6rLv9n/5XqPv3eeq3/jvUnR/fRF0uxa776TJ7zn36/kOoa3RyqKOj6HsZb1MjDdSdH2Pn8PYhexbf2WAdPZbUXfbcGOTZnFLYZeO3fYE9h3/y8ouoy6XYc/Juk52/1zbnUTcJx0FERKPLxutYoYW6So7NPfdr46gbL7JrMoRj6/Mf/99R97s9/bn/FnXNLvts3NkYRV0qw8b42EQddXsrbL8XLqyg7uLYOuoiIl7cZu8oG/vs+3Jpahd1zR4b47kMu1/TKXZN7m5NoK6zz156RmfZ+/l0hY2Fm3dmURfwPSE3xu79bp1dj4iIVDvDwir7hnhkaRl1xSzcXpVt79fuPoq67/zIX/89/92/lJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuKyNPzm3VOoy+X6qEu3Uqgbv9ZGXbaRR93howPUTXx3iLrSZhd1ERHdEfYbGwvs3Dx4chV1N585jbr2xSbqsm+Moi7fgdf40iHq1jsZtt9iD3X1Drse21+4gLoXTpxFXRqel4iI8jJbN+6Ms/E6ugb3nWb73R+MsW5khO33iFJNNjYKOTY2pst11E2WGqi7/dUl1JXZrRC1M+x6xwB2ETGcZXNtZaSFuv/pxR/F+yaWvsKuSbrNrvHa02zsTr7BnhntKru39s+jLDYOK6jLpNk1bvfZ4351n83vERHte+w3pibYc7I1x851qcrGYOc6O5aRZT4nH9VYgf3ml9YXUdcfsDn6m4NTqKNzYzbNrtHeLpvzTy9uoS4iotVjY/h0iW2z3mPvADd2jqEuPcHm0EGR3bMZ+J6cYq/dkV4uou6Xu0+iLj/SQd2gz8bqcJX9voPUOOoiIobs1SDWKmz8xwBekxy7T9abk6hLV/i3xlEcq+yjbqNRRV167gB1ja9Poy77wRrqUvD6nB/dRN1/Ov0V1EVE/Lf1n0QdnceuXmXzTnGdba9bZWNy7Ao7h5k51pXga2j+GJvIbq9OoS5bYvd0Ab6fNOvseZHZzaEuIiJ3yM5hK8uu3ct32PvDsM0mxsPzBdTtwOf9W/EvpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlLgsDdu7RdRl7uRQN7Y9RF2600ddts2217kyirr8fg91G08WUBcRUVpnv7F1mnVbjRHUNU92UffwiVXUvb5+CnWLX+6grv00O95ytY26x+aXUffcVy+x/bLdRrDDiFQ3BTcY0YfDa+Q+62af3UHd/U9Mom6YG6AuV2Rj8Kjo79i4No269QI7/siwi56aZPNYv8j+n2DkPhtDzVk4KCNi2Gf77j03gTr6cGkeY+dm5xL7fdMvH7Idw9uwPcbCFHtkxNn33UXd1ftzqBsfr6Pu8jib39N0IouI6zN51F04toG6mysnUdftsNHVL7F5Idt49/9/7kPTN1D3r3afRN3luTXU3auNo244ZOO83WXnvnSFvTPe7LBxHhFRmWZj/V/dYOewA8cRfb4MB3BSmWIvFd1uBnXpDnvv7o2xuXbkCruvO2Nsv5VleF5g1mKP8YiI6JXZfNYrs52nD9k1GZRRFhk49wxG+HvjUby+MY+6Votd8+w1dgJKByiLrXvjqEu32Xn67DX2/n+9xgdbq8fOzaPTK6j7Rovdh71JNibjLvtm3HmSvcxU59i7Vv5T42y/19l797HfZvf02vvZvdXMwfWN+SbquiNsno2IGJTgvDPCrsmJ2V3UrWyPoe7WNrsm6VV2Dt9yO+/IViRJkiRJkqTvgYtSkiRJkiRJSpyLUpIkSZIkSUqci1KSJEmSJElKnItSkiRJkiRJSpyLUpIkSZIkSUqci1KSJEmSJElKnItSkiRJkiRJSpyLUpIkSZIkSUpcloYzx/dQV789g7p+IYW65Y+NoK49NUDdoMi68t0Dtt/xCdRFRPRK7JiLF/dRN12uo249M4661+8voO7CP95G3TDPhtfhv5pDXf3DXdQ1pnOo6891UFd+iW1vmMmgbpBHWUREVO+w8RpsaEV7voK6bINtL3psx4VCD27waNJ1du6zi+zARkdaqBsvNVFXaxdQt74+hrqDCru3SvfZeYmIePqBqyx8gGXf+PxDLKyysdEvsHNYP15GXXNuiLreSTYWBg12TT4ytoq6G8+fRF33lSLqfqs8hbrOOTamIyKGB2wye+rh26i7Mn0MdYsTNdTt5tnYaq2w++7tWGmPo67TZs+bV9fY87q1wt6hsrPsuncP2TUfZ68xkZ05ZGFEZNLsedgbsP9vPT3D3mXuZth7XrvJrl1mmd2z2T7KIltnz+FUj81RKTY1Rho+1nsl1tWX4AHD952IiPQEe89LbbNxXdhhY6sNf2P2EG5v8ns46CNot+B77oD9ju4ou1cr9+jYZV3+gJ3PTordgzdvs+dwRET+AfbdWMiwG2dihM3Jy/cnUTd5DWVR2mbncP8smxdTQzahVG+y/W5fQlkUzrGH0PHxPdTd3WHHO7LIxkFExA+dfBN112psbeWN9XnUDYfsfmqss/eHPPs8f0v+pZQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhKXpeFhs4C6QZFtrz01QN2JR1dRd9hmv2//1SnUrX9oEnVjNzqoi4ioL+RR17w5yrb3SB11qSw716l77OI1TrNhU/7aFdTN7NRQ1544ibrvdk6jrnKLHcfYv/4W6rp/5r2oOzyBst/Z93V2jXcfqKBukE2hrsOGIF7Wru+X4AaPZpgbom5wZwR13XvsfN54so26Ift5cebEJuouj7N58QurbExGRHz1a5dRl62ziz52ix305kyGbe92F3W9Evt9mQa7F4a5PuuKbHt73TLqAo6ZkVU2v1fus2fVrTH2LI2IKG2xc/2v3ngSddXZQ9SN5Nix7KXYvNMdgSf7bXh+g038vTa7H3ot9vwqbrHtlU6xuWxvg53TNnuFip85810WRsRGp4q6qwezqKvk6PzN7u0MnCuKD+yh7mPHr6OulGFz4/Pb7B3q1so06rL0eD/H5rxsg43VwyV+v2bneqhrFdn91HuwhbrFyQPUrX1nHnWp9Ls7R6XS7DlyanYPdVsV+K7FXtcj7rOX0v5F9s6ch99FnWV2HBERqRS7RsdG9lH3rWV2v2b22NitrLD7de8c3N59dg5b4+w94fAk2171FtveX33oU6h7ucmezVffOI669hhfF/g3X30KdbkaO+azT99B3fV1Nsen+vCbcYKNrbfiX0pJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxWRp22jnU9Y91UffwhXt010i9k0ddaS2Ful6J7bdXybAwIia/u4u62tIk6jafWUTdX/mTn0Ld33vx+1G3d7aMupE32XEMd9h5mX/2EHXZ5gjquhWUxbDXQ11xd4C60hbbb0REZo2dm0qVjf9+8Z1dhy6ssymkPT98R/f7u6Wn2qhL3WY3dmeM7Te1x+bFDz31OupuH0yh7jNXHkJdf5GN3YiIVJm1nQI75r08G2u58RbqIgqoGn1pA3UHSwuoa22wMZOfb6Buv1tEXXmFPavSXXZvpTt91J35NXYvRUTUTrJrslNhc3ITvpFcm2PXpDjSQV1nip2bt6PWYNf92AKb81dWJ1DXWmTvZPMldh+OXVpD3cKTB2x7mSbqIiJu9GZQl8+w67nVZC8Bp6e3Uffm3XnU1Q7YffPp/YdRR2XzcJzD51p/wN47WtNwLoOPq4XH2BiMiKi12Llupdj9mS+wH9nqsclscAqO/967+zcE3Tq7lmsvHWfbe5S9r//A2auo+9y1x1H3wLF11K0dVlHXexN+KETE3jh7Ln3tGnt/m7jMPhYe/gA7h99tXkTdMMPeKXplNib77BaMQZHtd+9J9lz/qQp7Bt3psHswc8iOt5dm82dExOJXWLd3js2hb1xh92eqDeeTCXauo89+31vxL6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpS4LA37rQzq3nvpJuru1cZRt35jGnUxYFmcZuHIfbZed7jAzktExPalSdS1ZthvTE22Uffy4XHU5V8po660xX7f3pNzqEv3WVd9dQt1O48XURd5dhwTP/Y+1BW3umy36zXURUR0T0yhrj3JbuVBJoW6XB1lkRqyrnfI75Oj6LfY8Wd7bHuZFuvG32Dn89nWZdQde2KVddN7qPulD/886iIi/uLtn0Ddd68voa4/3kFd9toI6rYeYed6oT6Ousoyu/8bi2y/wyHrXlk5hrpjb7LzV37pHuoaj55A3TDNjiMiYuKVPdQdnGbPvvYDTdT92Ue+ibp/+eZ7UTeztIu6t6N3q4K60x9i13Pzu+y5mWmx63k7M4O66LF3o9tZtr1v7T7A9hsRhTMHqOv12PPmQ0vsffWj42+i7ucHH0Dd9ZvzqMuX2DtFe7uEum6HnZdHH72NukGwsdV+mD2fb6yxMdOtsWdGBJ+X0yX2cjCE7zyNdh5185NsTG/us/njyNLswDoTrMvA7X3hxgXU5erw+XqFPedGX8+hrtCCFzwihg12f/XG2Fg7qLNvmedWz6Du9FfYO0XAd4DbP8POzR959NuoW22Poe4+fMf7z1bY8/+zX3gP6lJwnSFT53/vc3CKtblDtr1UmY2t3HYBdd1xtt/ovjN/4+RfSkmSJEmSJClxLkpJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcS5KSZIkSZIkKXFZGqYOWZpP91F30CiibuzNDOrqi0PUdSd7qOuMpVD303/iS6iLiPi1O4+wsJNDWb/P1hRf2DiBuiEcDWsfHqAu1WW/r7TGuvboLNtvj/2+3DY7z6XlA7bfPhv7jdPjqIuIaI+z8d8dYeM13WH7bU2xrl9i991gBu74iD5w8Qbqrs9No675lRnUpdhQi+5sF3W1dh51nR67WZ/+zH+JuoiIyLODKV9jv7Fxmh1zig2h6LNHRtz/WAl1k6+z+3WYYvfWEB5HNsvO8+0/yObF8bNnUdeeRFlMvsHOS0TEzmMTqKvcYyenucjm5F+59Rjq+rcqqNs5jl+Fjmy42ELdN66y6xmjbBwNltqoS/XYeBubOURdo8XmiV6Rj7fvX7qKun/7xfeg7kutC6g7+/gm6qo5do0zI2xu7HbYuEz12Bw1vriPumtb7Dn50ZPsubvXYXPyZnUEdeU8O38REftN9uDow/E/PtJEXa1VQN12jR0zfd8/qmMLu6jbH2PXMp9l31rtb7KXzfI6e4b0L7J3zeZTsLtVRl1ExAcfY/PTerOKup9aeAF1f/fl72f7fR97Hk6/zK7d6AtsfvrU2EOoq++zsZXeYu8J1yfmUDfNLlsM4S24/QT8MIgI+rdBhT22zWGHba8zza7x/Cx7ZvT67Fv1rfiXUpIkSZIkSUqci1KSJEmSJElKnItSkiRJkiRJSpyLUpIkSZIkSUqci1KSJEmSJElKnItSkiRJkiRJSpyLUpIkSZIkSUqci1KSJEmSJElKnItSkiRJkiRJSpyLUpIkSZIkSUpcloZzFzZR9+LaIuq6V0ZZd3yIunQ7hbrSvRzqRt6/hbpn1i+iLiJiMGBrgE8fv426L379YdRtZ0ZQV31yF3WDDhs2XdiNX9xH3cqdKdQVJlqoi1mWpYZsDG6+bwJ13QobqxERpc0B6mon2fY6sz3UpYp91BVHOqgb3K2g7qgeH7uLul84/SXUPTn4w6g7Nb6Duv7ONOr29ti9mrlXRF1ll4+1/D4b54UDNibHbmVQV/3X30Ld8n/zFOoG8KnWmGG/LzXXRF2hwO6t9yzcQ9033ngIdeM3u6hrb7Pj7ef5mGmPs7Y9CTcI5529Zfb+EGNse48eX2HbexuyOTY+qmNt1O3ly6g7OcvmqPvb42y/K+zcp8rseKPG3skiIl7YOoG6foHNZXTfL+yz/d47YO8A+dfYtWueY2Mhv8feLffG2PMllWbn72aNvZP9ueNfRd3U/CHqXmuz74yIiF9deRx1a4Mq6uh7aHGSvYeenWHfGisHcM47op0aGxutzRLqmm02JkvsdSLS7DEXwyF7JhVeZvdgaR3OJRGx+j52jW5enUfd337196NuWGAncXSTHcveOfYSVTvLnq+pegF17z9/E3XXpmdQN/gNdq82Z9iY6Y6y81dawUsr0Vhg165xjG0vlWW/sTJdZ/tt51GXzbCx8Fb8SylJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCUuS8OfPfV11P2jWx9C3f75Q9SlUkPUxYujKJv80BrqKvk26q5cO4a6iIjcaAd17x29hbrnz55AXb1RQF1tmZ3DdIOtZU5cQVnM/IkV1G2OVVD34aWbqDtW3EPdz//f2Zg+dn4ddfVvzqPud7BzPciz+yTVyqAuO8bGfy7bR11njm3vqK43ZlH35RK7t9rdHOqOlfZRdzc7gbrUWhF1g6UW6lpZtr2IiNY066ZfYt34q3ssLLHfOLLMxvjmD7Cx1r/P5sVsroe6wmfGUPfcJ9g9nW2kWNdkvy/TYvfq8l/soi4i4tIce57e2WfjvzRkx9xs51GX/3oVdZunRlD3drzn+D3UrTfZb/5jp7+FuqsN9ry5szGJuu97/HXULTfY/XB/bxx1ERGz5RrqJh9roO5ilT2zn9s8hbrDJptTuuNsLiuMsHfG/ll2b5+e3UHdf3LyK6jLp9h+X28uou7pkWuo2++VURcRcfM2ezfIltk8GmyKivEKG4O7rRLqWh32TnJUf+4S+8b78x94E3Xvfe7PoC61wuaJbGuAutwbbGxU7rHtldf58/DWCnuJSpXZfZMtsve8v/Qwu19ffvw46l7ZXkDdXzv/WdR9cvtx1P3E1HdQ9w86H0Nd+zp7lh4usveJXTZUo8Cm2YiI6FbhhAKXQlI7bJ7oXWfvZN0q23HmNFvTeSv+pZQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhKXpeGnNh5F3cnRXdS9Ui+hLpvto652sou6yVIDddvNMuoixbKIiF6bne6//ekfR93Ifbbz4VPsmHPTTdSdnd1C3Y32EupmioeoK37rLOqe2XoIdZXjB6ibfJmt3a7EDOqKPZRFRESuNmRdlY2F3gTbeXeviLp+JYO6QffdXf9+aWsRdb9954+hrt3MoW4ix+6tnTemUHfm19k9mKl3UBfDFusiYuX7JlBX3GZz7dpHJlG30GdjfOqTr6Eu3X8QdYfH2D2T/e0q6nKHA9R1r7PtFdmjL1Y/wJ6lC19jY7V3s8J2HBHXvnUedVm262h/nM3JgwG7dq0pNrYOt8ZQ93bcOmD3w9Y+O/+/2nscdekUfIbk2IB7rHoPdWfLm6iLaZZFRBzPb6OuNmD3xOc32Vxxssrea2n33M1LqJsaraPu/TO3UXfjkL2jfKPG7uvegD3/v7nG3gXPXVxD3YcqV1AXEfHMqYuou3lrDnWZffYevzvOviEmqmxyzGTY8+Woyuk26j7dYGOo3WbvUKlpNj+NrMLvnUdqqNuYZ9cnt5tHXUTE//zUv0bdr22wufuFG+y++dL2BdRd/U14X8PP3/9y6w+jLn+7gLrnHmTHO3idvUMt5Nn3zv45NrYKbHqPNnvUR0REpsX2XV5l90l7kn1rNc6z+z3gu9bZ6R22vbfgX0pJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxWRpe3ZxBXfdGFXUj91Ooa0+hLOJ4B2Ufm7qKuk9UXkPd15fOoi4i4mx+HXV///4PoO7Obbbv/mYRdYPJNupufekU6mZf7aPu5SuPoK7aYtur3kNZrH5sFHXztSHqJl5ha7z1RZRFRER7gt0nzVNs/EefbS9S7JgHXbiuPYT7PaL9egl1xS+z+al7ZoC6X/7Fj6IuD2fajSfKqFv4Sgt1g1eusB1HRPb970fdwVIOdfVFNoaWf4hN8gtfZfud/Op91I3v7KIudXwBdY1zE6grr7LjOPZl9vuiz85ze34EdYu/3WP7jYjiSgN1mQ12LJv1JdQ1Z9h8kt9n5+Ygx56Rb8ejUyuo+62tS6jrDtjcW851WVdkz/+77UnUfbB6DXVfPbiAuoiIa41Z1KWDXfdX7h5D3aDBJvDcKHsOZ5ts/K4ss3MdM7dRdnGUvYPeqrM5+bFRNtf+2MlD1F1tsbn2VoqNg4iIdo9du6WlTdTd32O/sXePzbfpy3XUjRTgO94R/dLye1B3+/406oq3C6jrl9i9uvsAu2dmqux81r8Ev1XX2XdHRMT/dP5HUZd5pYK6iU12bl7aZd+CefaaHIM82+/vu/Q66r47wz56TlT3UHctx95R2q+Po65XYe/7pXX2zO1/D68TgwtwvKbZt0Fnmp2b3Hqedfvw2+00y96KfyklSZIkSZKkxLkoJUmSJEmSpMS5KCVJkiRJkqTEuSglSZIkSZKkxLkoJUmSJEmSpMS5KCVJkiRJkqTEuSglSZIkSZKkxLkoJUmSJEmSpMS5KCVJkiRJkqTEZWnYaedQl+mw7VVW+qiber2Hus4YO5T/c+0TqPvCBx9A3WcufgZ1ERFvdBqo+wuLX2TdBxdQl79eQl27hIcD0iumUJfpDt/R/Y5/awV1jdkTqNt6lP2+7mwXdekCG/sREZ0eXDduZVCW3WNd6lSd7XfIrnE6M2DbO6JOi43d9gX2O4Z51s28xK7l9oNs/mwcY2Nt+QcmUTc9+wTqIiIybdYdnmDX/MxTd1B3/3NLqEvvsTE52N5BXQzYNd59Yhp11dtN1NWPs7F6cGEUdZ0qmyO2P8ou8LDJrm9ExOiVMdQd/7Ua6iZfZd2Vny2jbvYbbL4rbfJjPqp8mr3LfPDsDdS9tjWPuo1tNo4KRfb8+rU3HkPd4mO7qHt45D7qIiJ+7sZH2TanVlE3P7OP90388LHXUfeN+TOo6w7Y+P3BsddQ98/WP4i6EyV27R4q3UPd/3zlx1B32CygLpXi74ztuxXU5U+w5wu8jSPVZ3PK7iGby05NwefaEWXT7HmYyrBz3xth3SDPuunvwHfN97LtHX6IfY8doup3TI+yMTT6cXYt1z51EnUnvsAG5QF8d8uxUxOfyz6OuuLZA9Q9v8neBUtvFlGXLbOxMPnAFup2BuxdkI7piIjhQR51Ofh5nuqya9wvwvszy7pbm1Ooeyv+pZQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhKXpeETS3dR9+LdC6jbvZBBXbrPuuZjDdT19/OouzC6wbY3HKAuIuL/ce8PoO7uwQTqTszsou52PYe66KVQln+C7XerPI664hbbb3l9iLrhwSHq5v7h86jLHJtD3WBnD3UrP/sw6iIieiXWNU72UNevsPGaY5ckOg02tkbGm2yDR3RqYRt1P/r4q6j7uZc+irrGTBF10690UJdt9FG3f5btN3fA9hsRsf0Iu5aD0S7qfnLhu6j7G6ePoW73few+7BXnUVfcZffC+Ct7bL8T7Gad/Q6bx8ZeZ/ttHq+i7vAGGzNpNpVERMT4dRj32blO31pB3cyzF9l+oT57LXhbxrJsDvzSvfOo63TZ69vEV9h1b02x8Tv9EfZu1B6w+eT5xmnURUSMFVuou18fR93a1hjqMlk2Lz+TYeNyp15GXbfH3n9/Y/Rx1HXg+/Rfnvlt1H2mzt73Uyk255WLbdRl0mx7ERGtyQLrDtkkkBqBc9kUe/b22+w+6Q7YtTuq+185gboR9qkVPTbEY/LpddTtbrHn+lSejaHvO3cFdVf3Z1EXETGWZ/PTS9fZuc4usHE+epf9fUlph22vNc4+AGZeYNvb7o2irlRj+63cY/vdY9NTFD83w8Kn2OAfG2HjICKi8Sr73u+V2TFnmmwsLDy2hrp7K5Ooy30Pc/Lvxb+UkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4rI0nMg3UNcd76Oud6yHuvLrRdSl7pVQN/fKEHX/duu9qPsjf+w51EVELJV3UPfUxC3U/ezYK6j7E7mfQt2NL59GXe/uBOqm7wxQt3sxhbrtOZRFefMc6nYu5lDXnmJjJuI4y+jmImL+uS7qGsvsVt5+nO2822bby26wc1hH1dHdvD6Pur9/dxZ1E99ixzWEy/rFdTZ/7j04irrNp9n8eXCmgrqIiHOP3kPdjfVp1N1tT7EdD9j935xmJ3vmu03U5TZqqBtU2TMo98pN1KXnHkBdav8QdcUMO38TV8bZfr+H+WnnIpsnDhdOoG7+c8uoqy2xYx5ZZgdT2voeDvqI/trMa6irZFqo++r2edS9dmkEdcVNdk639ticUjnFjuPxyh3URUR85f5Z1LXfHENdmh1ypNhjOG7vsLni4ct3UbdaY8+DK/vsuXZ5fBV1z7WOoW40zeba6TJ7A7i/z67bfq2AuoiIzEYedb0J9kwdVlk36LLn1RB2vcG7+zcE3Sp8N6yy7Z1+4j7q/vTxb6Du7/zmT6Pu1pdPoe7KxEnUZetwkoiInS3WZufZuc6cZu8AG102Jxe32e8rr7Nvt9pJNia7Y+ye6VXZ70v3MqjrHOugbphj7/snZnZR99OLz6MuIuLXq4+h7iZ87x4M2Tm8d5dtL9hQiPZ6mYVvwb+UkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4rI0vLo/i7r5U9uo2/4u215reoi6zMk62+9wBHXDk03UrfXHUBcR8ereMdQ1R/Oo+4X0RdQddgqoay10UZepsq7w8T3UtW/NoC5dz6CuPseGdb+IssjWU6jLHbLtpbtsTEdElG/vo66www6mM1pB3WGPjcF+ZYC6d1t6hI3JQYeNodYUu+b5A5TF3qVR1BX2+qib+Tob4805dhwREVdvz6Mut55D3a8XH0FdZZ7dOE89eQt13/j4adTN/70q6jqj7HhH7rF5dvTlLdT15ydQFyk4PzXYvdoaZ/dIRES69852a59YRF23yo6lO8L+362wz+fko/q7O2dQ90qNnYN0sN88qLA5ZbjDztVwgz1r/tnND6Du0tQa6iIisml23Q/nO6hLZdg5rI6z98vRNNtep8/usXyW3Tg/eey7qPtg6TrqbvemUHezw97d3ri9gLoYwudVlz/XsvDWzlXYmCmVWNftwXeNFfZNstcooe6oMi3WdZfaqKvm2Ab/2f2nUVdZYfNY9T7KYvkn4PfOJvxQiIiFr7IXwkGejY32FLvmdfY5HQGfGY1Z+NzcY9sbWWHHu3sZZTGAryiT32Lvbp0xNp8sb42j7szpDdRFRPzB+RdR9/d3P4a6bod9G6S3WDfIs2ucX4IfwG/Bv5SSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLisjS8tzmBuh86/ybqLv3486j7pzfej7qTY3uoWx4ZQ93ea1Oo++ujP4K6iIite+Oou711AnX/9thDqLt4ehV1qVIfdcViF3Wru6Oo+8BD11FXyrD9fnHiIuomp2uo++DCLdQ9c+cC6lLfYmMwImL5E9OoO3ikzTbY6qFs/DU2NdSPDVE3aKVQd1SDwxzqMocZ1KUGbL8pdsvE+BsHqGvNldl+4e+r3INhRIzdYOemn2fXfKNURd2gwk7i6iS7bzodNnYzz76OupFqBXXDwzrq+ueOoW7zcTYWZr7bQF2mzcbCIMvGQUREfp+NhcnXDlHXWGTHnO6y/0/rjqAshu/u9BQREY1BHnXrDfbc/ImF76Lu5u4k6lpV9vtSA3bud66y/T67UEJdRMTgPhsfMcqec8McG78HNbbf0Sq7F69/5yTqzj5xD3XXmnOoe7jItvcv19h791qdjdWHzyyj7pU32HmJFLtuERH5fXZzD3PsOdRssXeNHNzeED7/cln4snFEnUX2fh09dv8Phqxb3WdjKHuMPZfgbiO7zMLZF+B5iYj0dXZ/7f3YJdS1x9hvbCzA93A2xUfuDHtfra2wB2x5mV27LHtNiIDP606VhT34COptsPC39h9mG4yI37oDx0KbzTv9Fnv/zbNHZGT67BwWcnCDb8G/lJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuKyNOwf5FH33a1F1FXnW6g7bBRQd/LYDuoujq6j7t/2LqHusZll1EVEvJQaoq55YwZ1s9/NoG5z5iTqUpfY78uMNlHXGbDhVcp0UXdlbxZ1v/Sxf4C65xrnUDeX20Pdt0pLqDvAd11Emp2aKFXbqGs2y6gbwuXqQZ6NmX61zzZ4ROPHDlDX6uRQl12poq45z45/5aPjqCttDVDXK6EsmrP8/x0yHda1x9kxp+H2Tp1mc/L9/TG2wesjKOt+6CHU9YvsHOZ32QFvPs7uwf1L7J4pr7Nn5OYT7Dj6JXZ9IyKKG2ybpR02YDtVtr2t97BzU7nNJtthOoW6t+NXbj2GunaX/eZvj5xGXRdur9tkc2P5GnsXLG2xcVR5hm0vIqJXYvPj+nvZMfem2AP2+Mwu6lo9ON5y7NxsNdhc8czBBdQ1++wa39qbRN3uNntO1ifgNYbvyNkqfDGKiM4ouyaD+xXUpWbZt0sWvtdOzrB3l2qBveMdVeqQfU+MLe2jbrPJnsOdDttve5GNjcIum8u7M3QM8WdD6z3sm2L0BvuGyh6wsdY8MYq6dJfNn2tPse1V2WFEaZPtd+8CO9dDeElm32D73b3IxuDUi2zHn+w8hbqIiP4EHId9tu+Rm2yOb0/y9zzioAY/St6CfyklSZIkSZKkxLkoJUmSJEmSpMS5KCVJkiRJkqTEuSglSZIkSZKkxLkoJUmSJEmSpMS5KCVJkiRJkqTEuSglSZIkSZKkxLkoJUmSJEmSpMS5KCVJkiRJkqTEZWmY28ugbi01ibpf26ugrt9n62b3G+Oo+2+OfxZ1v3Lj/aj72guPoi4iItNhXXF3iLpsY4C63Q/0UDdku43GlXHU5c8doO5Lzz2EurFTe6j7hZ0PoO63PvU+1LUn+6gbFtj1SE+xLiJiUGPjv71bQl2qzI6ldobtd/T0Hur2Ntn9flQ/e/7rqCumuqj7X+79QdRlmynUNZ5qoG7kN4qoG+TZfqt34E0dEQdn2DYz5w9R127kUNfts2fL/n4ZdSOX91B3c6qKuokX2e8bnmbHm+qxa5LqsOsxcr+Juq1H2fkrbPH/q+pW2LGU1lus++TLqGuPPY26NDzXzRl2rt+OdJrN+x88cQt1uTSby3tdNn4L99n4Hb/O9jt6rYa6GPDnYXeSjeFcjc2j6R475pXKKOoG9+Ectcrusb1g79PjZ3dQt99l7wk7W2xuTOfYtTu4NY66VAbOjSn+XKMGY+zdoFpuo25xbB91m3X2bkSfk0dVWGDvKM02u2f2Vtk9c+78Kuruv8nOU+U+G5OlDXYctRMoi4iI3YfYvs//Ahtr20+w+3/6ayuoG1TZ/V9az6Nu+4PsOA567Pk68QJbkkjBR0YfvieXV9l8MnaTvceM3uHvUFuPFlCXrbPf2Gebi/YU69LsEke2wNYZ3nJ/78hWJEmSJEmSpO+Bi1KSJEmSJElKnItSkiRJkiRJSpyLUpIkSZIkSUqci1KSJEmSJElKnItSkiRJkiRJSpyLUpIkSZIkSUqci1KSJEmSJElKnItSkiRJkiRJSlyWhvndFOoGuQzqusMC6nK7bHu3RydR95cO/ijqYr6NstEXi2x7ETH50i7qhm/cRF1magJ1pSfOoq4532f7ZacmGpsjqBu/wtZGFx/dR92nXn8YdQuvsuPducjGYL/IjmPsiS3UfS+2tquoG/bgOvRkB2WXZ9ZQ9+3WSbbfI3r58Djqfm7x66j761Ps+HvpIeqGm2yeSPfY9jrscsf+eba9iIjjD7BrSa12x1C32yihLpVhx/LDS2+g7tIDK6j73+Z+AHXdV9jxnv1H91A38w9XUZcusbGV+b5HUder8jGT6rIu3YRhkR1LvgbvO/baEoM8P+ajmiw3Udcbsjn69gF75xmsw/EBT1a+NkDd8I0brGvDF4qIyI2wd4r5/CXU1Y7nUHfYraAu9zB7R3noA2zuGcmy59Byg8092RS7dg+fWUbdXLGGuv1TbAz+2PRLqPvf3vxB1EVEtE7De3uPfZO0WmzM/MGLL6LuV1cfR12jm0fdUf2Bc6+g7k6DzTvf6bF3vsvj7Dl3p8De8fYusPmzV2H3Qm6f/+3Gx9/3Guq+sfMI6sausd/YOc6uyf5Zdh92xtiz4Mnzt1GXTbPjeGN2DnWDr7Nv38oq+8ar3mmhLlODz6oBO96IiIWv30Vd+sQx1HWOs3NTO8vmk2GKjQX8bfkW/EspSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlzkUpSZIkSZIkJc5FKUmSJEmSJCXORSlJkiRJkiQlLkvDyv0B6tpTKdSNvsF2fXC5i7pshv2+nTenUDd8N5br0myj6XNLqOuOl9/Or/l3ZBrs91Wf2Ebd//XgL6LuZ6f+FOo+On0VdVe/cQp11Td3UTdMj6OuvNJC3XJrBnURESMrQ9RVR9l9162w/faqbL/jl5qoS6XY9o7qXHkDdb/ZYCcglWG/d7ibZ12OzU9bj2TY9tJwXNzmE9nW4gjqfvr8C6h7Ji6irpRlc/wjS8uoe2HnBNve8XuoGw7ZvTX7nT7bXqeDunSxgLru+9h5bk+xMVjY4WMm22Bd8zi77/KVB1CXq7NjybbYfVI/hl+FjmyvWULdyt4o6ho77PmfnmmjrnCX/b7iSg11AzjOUwU2ziMiUscXUFc7nkNdpk3nUZTFXpFduxf68F0QzvPNgyLqymPseV0tsTHzvonbqHu2eRp1X9q7hLrv5W3i9Ax7X72dmkRdBn5r7PbY8/Sww8Z/Kceek0eVCXZcA/g8PDu/iboPV9l7/aeXHkJdf53dC0u/yc5nc5bNJRERtw/ZGOpdYA/O9Tn2fnl4m83dC99g9//4VTYW3iheQF1vhN2xlz50E3WvPMqucWOB3VuZNrtXp19iz9xOhd0jERGji+yZke6xc7jzAHyeDuE3zjz7rs1k2Zh5K/6llCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEpelYX0Brl8Nhigbu91DXabDfuJWe5Jtr5dCXa7OutJ2F3UREen1HdR1zs6jbvPxMuoa59uoix67xo12DnVfOnwQdaVCB3WfW2fbm3gTZZHe2kVduzqBumqTjYXO5AB1ERHtS+zaDersPsntsK60ysb/564/gLpeN4O6o1prj6HuxyqvoO6PP/wt1O122T240xlB3YufZGO88/gh6ppn2XWMiHj/4l3UPbdzCnWlLLsf7u6w++sPH3sedfV+AXX/5N4HUXdygs0T1z8wirrjzZOo64yye6Zyp4G62W/nUXdwGmURETH3nSbq0u0+2+Bz7P7M/Ph7UdecZOcwxafkIyvl2P1Au8ZBEXXjY3XU1WbZ9mrn2VxbybG5rHGczY0REd0ye0fZ+gB7vyzeZ+8yGfgK1Z2A74N1di/Oz++hbrLC5oC1bXbt+n12nj9eeR11j5dvo+7LB5dQ14HfBRERV64fQx0dC8NHDlC30amibrzI5tDxPOuO6leuPoa60zPbqLu3O466Z6psnii+zN61xq+zZ017kl3vQZa/Q926soC60xdXUXf5AutWHmL39Y3aBdRlOuw7PsdeQ2OYZufwxs4U6k7OsW/p1hSbJzZfm0Hd6sfZ2ErX+fdOZZXNtQdL7FhqZ9h+ByX20rM4s882+A7xL6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUOBelJEmSJEmSlDgXpSRJkiRJkpQ4F6UkSZIkSZKUuCwND8/0UFeYbqJuq1ZFXWqIshjmWNgvDVA3yKVQt/pBfAqjePEM67bZsQzybL+ZLRb2J7qoe//iHdRdrc+i7rBRQN0fP/Nt1H1yZwF1/eMzqMu24SBMsTEzyw4jIiJqx0uo60yw35just84YJck+mvs9w3LfbbBIyqk2fx0pcvGZCXTQt2v3nwUdc2bo6groiqi8EIFdd331OAWI7529RzqMqtscAxPsHM48m02hv5G54dRNz3Bjrk/YP8nU3thCnWnP32IuvQbt1FXGmXPyGGZjZpsq4y68hqc7yIi3Wb3dW2J7Tuz8D623y77jZVV9kxrT8CH6dtwvLKHuru1CdRVxtm71vctXkPdF1EVsXshh7qVZTZHVW5n4J4jhvC/UYvLLOyMsffBYZ6Nt6XTm6h7bOo+6mpddm/vdtgcerK6i7orO+zd6JXWCdR1h+w9+ZW9Y6gbDtl7TEREdZbNy/USO9epDjuWl/cWUTdTZL8vl35336EGfXbPXLnJ3q+Ld9mc+tnDB1E3s0I/Blm2/l42hkZvsu1FRKSbbJuNLptDP3P1MurOzbN5p8+miZh8s4O6TJO9d+88xJ7/O3fZe3Jjir2DDprsXp28xq7b/jm2veI2n5/6BTZg25Pw2y3Pnmml6Qbqsmm2vUq+jbq34l9KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcS5KSZIkSZIkKXEuSkmSJEmSJClxLkpJkiRJkiQpcVkaLp7ZQl0l30bdlTMF1BVH2fYend1AXbOXQ10130Ldd++cQF1ERDNdRF1pc4i6TCuFumwTZfHg++6jLp1iv6/TZ8Or12FdOjVA3cYTbHv9B9mabHeH7bdTrbL9Fth1i4jIdFjXHWe/MbvPjjl3wH4jHYOpQQZ1RzWbP0Dd37z2+1A3kmcnnt4LAzjT1s92UTf7NXhvPVNhO46IzkNsDC0+sYq6co6dw+U4hbrqN0uoq38/e2bUa3A+brIxvnuJnevS7CXUZVp91B0ez6Nu8/1se5cu3kFdRMQbt46hLkUnskP2fM5vs/kk3YbPgjK7j9+O1cYo6vabbFw2m+y6X6nNoW5nk/2+gKeKPuVSH9mFZURtk91j88d3UJdLw2d7n423RpeN3xe3j6OumGXPg/02GzMZ+LwaLbI59P979SOoazTY+/7cJHuOj1XgS21EbN6dQF1ppoG6yQrrbq9PoW5kkc2NdP44qo+dvYa6K3uzqGvOs3uhX2PP9cY8m1GmXmP39Mx32fYOTvG/3Zh/lu17b4vNyYMH2H24/Nkl1C08y8Zu5pDtd/DSG6ibWz+FusryDOpWn2bz3YA9ImP/ApsXpy+xdZDaV9k9EhGx+lPs/i+PsDWJv3juOdT14RP6C+vsffXu3jjq3op/KSVJkiRJkqTEuSglSZIkSZKkxLkoJUmSJEmSpMS5KCVJkiRJkqTEuSglSZIkSZKkxLkoJUmSJEmSpMS5KCVJkiRJkqTEuSglSZIkSZKkxLkoJUmSJEmSpMRlafgnl55F3a+vPcZ2vJlDXSuFsnjp8DjqJqdrqLu3O852vFlgXUSkO+xgWhOsyzaHqOtMDFD3ypsnUNc+t4q61VoVdZXRJurutSZR157uo25pah91O9+soG70dhd1jTl820V3hI2FNLxRUmfrqGulR1A3yLEx2C+zMXhUq51x1I0X2Vi7enee7TjFjv9977mKuudeOoe62gl2vXsPH6IuIiI2Sii7uzKFusp4A3VD9iiIQZ51Hz5+E3VLxW3Ufe7YJdTdWWfnZbjOnhmpOTaf9PfZfDdzYhd119enURcRUai0UdfeK6KuvJxBXeN4D3X5bba9IXzPeDvubU6g7vj0HupOzt9HXW/AzsHlM8uou7PLjuOwy56bB1vsWRMRMTLF5pS5Mpv3sml27zw8uoK653ZOoW6rwY75eGUPddtwewujbA7oDNg7ykp7DHXpDHv+NzrsYVA7ZM+qiIh0m/3fe2udncPpmU3U9cbZfvMZNpdtHfL75Cje2J1D3UGLPb8Wquxb6+Al9tysL7IxVNxiYzfTYe9uIyusi4jIH7D5pF9gc3L1RXau4e0atSX2HM422X7z00+irt9n57A9xs5LZ5bdM8X7cJ1hnl239bvsG7SMqt+Ry7NjaVxnc+0v5tg1OQmfBVfvsnlhbo59T78V/1JKkiRJkiRJiXNRSpIkSZIkSYlzUUqSJEmSJEmJc1FKkiRJkiRJiXNRSpIkSZIkSYlzUUqSJEmSJEmJc1FKkiRJkiRJiXNRSpIkSZIkSYlzUUqSJEmSJEmJy9Lwb7/wCdQN+inUzbzO9ruTyqEu02L73WlnUJcd7aBuUOmjLiIitcfWAFszQ9RVb7P95nfZfntldg6vXj2Guh9/3wuoe21vAXVfWj6PuhjrouzOm/OoGymw3e5eYGN1kGfbi4hoT7CxEDArFNi56Z2roa7dYsf8bq9+/+aty6hrHLKLmVtmF6l6E2Xx4u0HUDexxi7kyBqbd/abFdRFRFSWB6hrj7Fzs/sIe7xkp9gx9/Os+8rds6gbvPIE6krrbL+L99k1qS2yebZ3v4S6xiK7btu7bCxkbxdRFxHRXmTPyewuGwv9IpzIiuyYsw2238443O/bMOixWbDRZXPqN2+dQd3C1D7qyjl2Ldttdk5T8F0wfYhfQ6ORZWPz1RZ7p6DX5M3KHOoaB+z3lUdbbHs9NhZ29kZQN5Jn13jrkG2vc8Cep0tLm6jbbbA5r1ppoi4iolOE7zxwLPSG7+zbzH6bHfNwyO6noxovsnPa6LAxeWtjCnVp+Ak1+Qo7/rGbbbbfLnyG7PGx1n/9KuqqC+9H3dgNtu9sjR3z+gfGUVe9w+anzigbC7nDHupS7JLEyE34rcUy/IFS2GDrB0OWRUREe7WMuvImfH84w97Pb+1Nsv3CZ1V/8M7Mi/6llCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEpel4U9cehF195oTqHuucY7tuNBH2fHjW6hLp4aouzy+irr5/AHqIiJ+aeYJ1GUz7Ji3p9i5HjlWY122h7ofOH4VdT88+jLq/shEF3VfPHwQdb84YOe51mVrsvWH2O+LQQplqd0c215EDMpsLORGO6jrdNgt/6NnX0PdJ688grpiEZ7DI2o186hLpdn9P4CXqPP791A3UWDXp9fPoK5caqBuJtdGXUTEK8+yOXmw0ELd+WObqDvoFFDXaLNrfGJ8D3XXLrFzvT9eRt3uwyiLjz3xKuqafTYIf2b2WdS90VpE3b8ovQ91ERGFzAB1tTY71z12e0a2yJ5VjSX4/245dhxvx8cvsOcmve6d0d2383P+HcfLe6g7McK6V8fmUUffySIi5srsXWYi30Td6TJ7b+wO2fh97WABdR+avI66/R6be85fZnNte8Ce/19psmfB5fP3UbfdZMdRyLH7+un5W6iLiHhs5C7q3mgeQx29P+eKbKyut6qoOzO1jbqjujzGvnlo99zmKdTdbbMxuXeWzdE7j7P3hGGRvVunMhXURURk196Puv4ie4fau1SCe2Zdb569h+4+ycZ4Cj43M2tF1PVL7FkwdmoHda0OO44PH7+Duhv706grwm/piIhWj43//CU2Xv/o8W+j7ldW2Hfyrfok6vpw7n4r/qWUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZISl6Vhs59/R3d84fwK6q6vzKBubW8Ude3VMupujU2j7sGlVdRFREyONFCXTg1R15yro26s1HpH9/vCzgnUzeUOUPf8/hLqVupjqKsW26j7yKM3UdcesNtkrsCO93qdjemIiHu1cdwSGzvsPrlVn0LdxCgb0yk4to7qsZP3ULffKaHu5pDd/4f7bHvF6R7qKgU2dndbbL/77SLqIiJSJ9l8Mthj27y2PMv2m2Zjo1Dsou7GJrt21GCM7Tf6KZR9+fWLqCuPNVH3t2q/D3Vb+xXU9e+zZ2RERL/aR12qw87NMM/GQr/H/j8tU2XXrt959/9/bjLP7q/VFnvOvdOu19hz6eTILupOVPdQd9gtoC4iopxl13OzzcZ6s59DXavP3gF2WiOo++LWA6grZzuo22uz58Fhh53rbj+Dut6A3TeFDJsn5kfZ2Mql2PYiIt5oHkPdaou9G1GXK+zbYLXJ9lvJsXeDo6LXsj1g98xsuYa6yql39rguXVpD3Z3GJOo2GlW87/0J9m7U6rBz2F9i79e9Drtfp6YOUTdXYdeOfjPeGmPnOpsesC4DuyybJ15aX0Tdwij7xitm2Pt+REQf3ncdOCd/euMR1A2CvZNVR9j6wTvFv5SSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiXJSSJEmSJElS4lyUkiRJkiRJUuJclJIkSZIkSVLiUsPhcPgf+kdIkiRJkiTpPy7+pZQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhLnopQkSZIkSZIS56KUJEmSJEmSEueilCRJkiRJkhKXpeFHvvBfv6M7nizWUffmxhzqZkcPUffY1H3UfXXlDOra3RzqIiKqpRbqNrZGUXfm2BbqLo+vou5Trz+MukGTDZvCODveTiOPuvMn1lF3/ZXjqBu9xtZkG8eGqOsXWTdydh91EREH6xXUpQoD1KXzfdT1a2xcZ6td1BWKrHv9D/6PqPvdfuS3/zPU1btsrG0djqBuotxE3frz86jrzPZQNzLVQF19s4y6iIi5E7uoa35+FnW9Etvv9CvsmIvr8Fy/v4q6gwvsXgg4xnNFdhwzY+xZtVtnJ7D/6hjqemU2P+XqKdRFRJRX2DZ3nmDnOr+ZQV1ngV2T+UU2prf32Dx7/af/Kur+fR741b+GuhZ8HqazbM4f7BZQd/zcBup+aOEN1F0o/v/btdMYy9L7MO//u69169Ze1VW9L9M9q3o4w30VRUqiqF2R40gxLMBJ4DgLHH+yAgRGDAtwAsRwZAiCE8WBhUiCFoYSRUWmKNLikBoOZ+2eme6Z6WW6u3qpfb119yUf8k0IOM/UDE8+5Pl97Qfn3HvOe9733LeLvXf8YpWvh/92bxp1xTQbH8eyW6hLp9i1Xu5Noe7nq3uo643Yc/O1FluveiP27natw967/3btEuo2Bux94re3PoK676yy9/OIiI1tth5ECr7nwXejwgR7/52v76NueXUCdW//0q+i7m/6wJ/9t6i7MLWCugy8ntTHx6+hbrXH1sNHS8uou92dQV1ExF9unEfdieom6nZ77B3gpRX2m+dHjr6JugH8e5WrO+y99to99s6Y2mRr33CMvWs9cuYe6q6+chx12X32bjRzia0XERH7S+ydJ/0ZtlZNV9neSqfP1oLugH2+4Yhdmxd+/Ne+77/7l1KSJEmSJElKnJtSkiRJkiRJSpybUpIkSZIkSUqcm1KSJEmSJElKnJtSkiRJkiRJSpybUpIkSZIkSUqcm1KSJEmSJElKnJtSkiRJkiRJSlyWhrut4vt64jsPJlG3MLfDjnd/inXX5lAXYz2U5Qp9dryI+NDx26i7PzaOui9OX0Ld251Z1KXvsXucyo1Ql705hrrCh7dR1x1m2Hn3U6gb5lEWsy8O2XkPBqi7+5k6O3FEFDrsu/ROt1A32GFfOt1l+9XZyTbq+v0f7P73YnkHdV+79CjqyjdzqNvp1NnxOiiL8j123nS/hrq561124ohIjdgxU/PseVj9OJsn1tNsGco12HxS3GTnXfgWe7a2z7J5cVhg5105zeax43Ob7Hgdtl5k2uz7zj8HB2tE5LbZ8z/Ms894sMSuYSrHxuDKgwnURYqd973oddk4zxfZu0f6EnseupPsWnUHbFxe2V9A3eW9RdT9q7fZvBMRMRyxMXykuou6T0xcR9145gB1d7rTqLucX0PdM82zqPvDe0+ibgSvXzHLxuCX7z6Buokiez95e5P9LuhfeRdjZoKN//xsE3WDEXuH6myVUHfvVhV1wyp7vzysp+fuoO5ceQV1N1szqPvOg5Ooe2JsGXWT2QbqzuY2UPdTFTYuIiK+dP+HUHdpi82Ne+0C6vbvsufhK63HUHdmfh11Y3m2/scue6/N77LfCcMDdryre8dRV9xg583voSxGaTbPRkSk2PSE176VPfZeMAXH9fZ+GXWp9+kdyr+UkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4rI03N0poy61lUdddZnth60uzKGufhNl0Z5KoS53PYO6vYd77MQRkUsNULfdYdf6X9/6JOo6fXab032URa86Qt3BCXbAc2P7qLvx8hLq0nBU96qs69TYWG1Os27isQ124ohYvz2BujS7Jdgoxw44OXaAuq39ynv5OO/oTHkNdc/cyaEuv8fOu/NkF3WnjrPPNxyx+en2G/Ooyx2w7xsRMfWNW6jrTBxn595hz0N5hY21zafY/Fn8azZ3d2pwLWBDPNpF1k3WG6gbDOG8c4aNwew6GwutWT5mejV2rcffZutkYYcdb7fFLvYQzmN9uKa9FwtTu6i7u8rm/Gqbnbd8lY3zve1Z1H13YQp1hdkm6nI5+OIREfsPxlDXP86ena92H0Vdb8jG5f3tcdSVL7Bn9isPHkPd7SsLqItx+L7aYC9RuZkW6jZ24cvWdfaeMMK/XCKWvs6e7f0lNraGR9jxsk323A1KcO7JD1l3SP/ujQuouzRzBHVj+Q7quvD3yR8sP4m6iSIbk//iOz+Fut4ie1YjImovFVA3gn8O0mFLQcQ0ezcarJZQ98baMdSNamw+qd1g82d7hj0L9J6Uxtgi2Rxn1yX/ItvfyDb5szp+k7VbBTYYWvPseHeKbL4bldn6nC/zvZDvx7+UkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4rI0PH5kE3U//dQl1P1v1z6CuplCF3VrmRnU1W6mUFdaH6KuV86hLiLiD4dPoa4w0UZd/04FdaP5DuombqMstuqsi/QIZTdeWULdxOvs3rWnWdetsc/XnGfHG+RRFvEcG6sREeUe67rjGdTl2OMUw3MHLIQGA3YND+teZwJ19J6XH7DzFpfZTd+ZLaKukmc3PN1l17P2dgt1ERFRYp+x9IDNT+UHbH6KYPckv87GeHOOXZsM+xrRq8LuGJtnG8+y53+ffd3Iltn1G2VZt/phdt6IiPpV9iGzcBjSOXTyKlufD+bZ/7sd0Ln7PVjdGUPd1GQDdd0Be16zbfh87bHnZpRh97y/zx6cYR9lERGRqrH7vnqXrQdbY2yOmqqze9JusIH0B8sXUbd6cxp1xy6soO7uq/Oom3kBZbHxk+z56u+x61LbgO9u7FGKiIjqs7dQVzi3iLr8HnvuqvfYenD30+zapPJs7B/W8ID9llnPsef64ZOrqPvVE19FXW/E5p2pdBN1/1Phc6j7eP066iIi/vnOT6Euv8Wemx6c70bwt9bit1AWxTU2drceLqGuPcXO26+w7xENtnVRmWE/eDJT7DrvPsLGYHsGb63E3PfYO//si+yeNOfYc7x3kn4X+NuN/lh9B/6llCRJkiRJkhLnppQkSZIkSZIS56aUJEmSJEmSEuemlCRJkiRJkhLnppQkSZIkSZIS56aUJEmSJEmSEuemlCRJkiRJkhLnppQkSZIkSZIS56aUJEmSJEmSEpel4b3NcdR9JfU46jKpEerW3pxBXWmV7a8VN4eoq9xro27/WBl1ERGRYd85/eoY6mob7Hh7oyLqOvUU6srLGdS1Z9nxhjn2PQ5+ooG6TIbd4/7tGup6dXa81IB939we6yIiulXWDYrwMw7Zc3Jkcg91xWwPdfdbE6g7rEtbi6jLsMc6elV2j6YvD1C3Up5C3X4fZTFY6KLu2q/k2QEjYuHr86grr7Fzd9iSEYURu9a9SXatuzNsPkmV2cUee5HNn60h+x5p9sjE2A32TI/YdByZDrsuKx/l81OKfcQorbNr3ZphryRd+Hz2KiiLTIt/58P60LFbqJsr7KPu/zw6ibrORw9Q1++xaz/2bAl1+8dRFr0yHEQRkT1g61evzOaK0W32/rbaYdemerWAut2bc6ir7aAs7rbZ3D2a7aAu02XrxsyfsLlx/MuvoK7xhSdQt3kBTnoRcfD0CdStfpAdM91hc0Vrmo2F3lF2T37QsjW2rg8H7Dp9/bULqLt+bBp11INt9l6fzbJ5ZybPfndERMQ0u5ef+/hrqCuk2bpJuz9ZeBR1K2/WUTeCf9ZC3z1KD9gBuxPseOv36qjL1dh9O35uBXV3amxtjoh48DBbq2Z/j627B0fgNRxn17C4xo7XyrHP9078SylJkiRJkiQlzk0pSZIkSZIkJc5NKUmSJEmSJCXOTSlJkiRJkiQlzk0pSZIkSZIkJc5NKUmSJEmSJCXOTSlJkiRJkiQlzk0pSZIkSZIkJc5NKUmSJEmSJCUuS8N+O4e626tT7IArBZRVT++ibux8B3Vbz8yjbpAvoa6wPUJdRER7g13DztQQdYNiCnWZNspiBLcoWwvs82X32eer32Jd91YNdfk9dk8aTw1Ql611UdffzaNumM+gLiIiv8OuTb/Mbl5viX2Xs+PrqPvruydQl86xMXNYa3tV1A3ZIxjpHusqdw5Ql32Ujd1+mY3diakG6naW66iLiOjW2FhrTRVRl4XzTrDTYqkBO2B6la1B3To7b2WcfeFMm5134i+uoW73M2dQd/9H2DP42Pll1EVE3D45wc59pY66YZ6N/9SQ3eNUnx2vP/6DnZ8iIp6u3Ubd3S67ppPnN1H388deQd1un73z/N72R1BXWGfr3NKT91EXEfHPTn0JdV/ffxR1v/WXn2EnbrBXZbpuNM6ysP8Ie689ObONutvPL6Fu+xycQ+H3rVcrqMvv9lE3+xJ/Xgv/1/OoKy+xcT1gj0n02CsJVijBi31ImSx7H+624EsUXNdv3ZhDXbrCvn/xCrtBlXtsbfjSR55CXUREpsY+4zeXz6LuF069grql/Bbq9jfZc5g7zt5rB+vsWqf77PfJwSl2/UpTLdT11suoy77KHtbNp9nnOzrH5uOIiEKGzXnXPruIusotdt7iJntAh/TnKnzvfif+pZQkSZIkSZIS56aUJEmSJEmSEuemlCRJkiRJkhLnppQkSZIkSZIS56aUJEmSJEmSEuemlCRJkiRJkhLnppQkSZIkSZIS56aUJEmSJEmSEuemlCRJkiRJkhKXpeH0zB7qLs7cRV33NDv11a051O22iqhrzw9Q11oaoS5VYseLiCheL7Bj7qVQ154dsuPNtlE3uM+uYUx12Hn32PEGJfZ9+x9lY3CUYdcl3WD342fOX0LdscIW6p7bPYm6iIjvXD6Huvx6BnWpnRzq1ttV1DV3SqirTzdQd1hZeM+b0z3UtZt51K09PYY6avoSm3cGVydRl32Inzu/z869e5I9r80zXdRlttlaMEqzz5fdZc9Cts2+R6/GxlYHznf1Lvsee58+g7q1p9j/LT10lq3Nb9xna25ERPqtCuomr7Fr2Fhi32XIbnEMyuxap+tsrL4Xz+6cQt3L95dQVyqwz/zi7jHUXd+aRl1x/gB17RqbQx/s1lAXEXGls4i6l3aPou4nP/kC6v7s2sOoKzzPnof6JbYO755nz8ON1TLqyttszhuyWxcp9ioYo8VZ1K18iL2T9eFzHRGxkH4adb0xuB6wV6MYZdhnHKs3UTc79oN9h/pnP/THqPsXN38EdesvsHUkv8Oue3ccvuOypSYaS+y8uW242ERE9i57l/noT7+Buu0+e65/+/UPoi7oO1SWXcT+kF3DqcvsvL0yu34T19n8md3ZR93yj02gbqrCntXFyi7qIiKmC+y5vhZs7Sutw/d49noZuQN2jzPwffqd+JdSkiRJkiRJSpybUpIkSZIkSUqcm1KSJEmSJElKnJtSkiRJkiRJSpybUpIkSZIkSUqcm1KSJEmSJElKnJtSkiRJkiRJSpybUpIkSZIkSUqcm1KSJEmSJElKXJaG5ybWUTccsX2uvzX9PdT928FHUffczROo+/uf+TrqfuOZz6IuDvAljPOfv4a61+4dQV252ENdY6eEuvR8B3Xz07uo27vMzrv3oRbqHpraQt2nptl1/kz1Cup+7c4XUbdY2EbdTpddl4iI8m02vir3R6hrT7Pn8/LkIupyqznU7ebKqDus/vcmUFfKsONl2JCM9lQKdd2JIepG8PPtnGdd5kyDhRHReLiPutSz7FqXr+dRl99HWXRr7+//oQzZ0I3cHjvvsM2+7/YHu6jrv1ZAXYzYs39jZQZ1gy4chBERx9ma0V1h1ybDDhfdWfade7NsjSwVWPdenKpsoO7hhx6g7vIem6N3O2y9+bkTl1D3W9/5JOqCTY3RzrB7GRHxwv5J1P3tOfZ+SX3lwVOo61XZl0732Heuv87mnsoqW182HkNZ9GrseLkG+3wbT9bZ8eBakO7BwRURe0fpOxT7znun2HcewGl0b2UMddnMgB3wkD5UvI+6Xz72HOq+nP8h1N378+Ooq95FWVRW2XtMv8juY6bD56fiBlvbv5W5iLr2EluXsltsjOdOHKCu22XHGxXZmNx6lB2v+MgO6hq/P4666oDdO7htEXt/wH6br/1olR0wIh6bZ+t9dqqNut1z7LdWb5zNd326pnX5nPx9j/O+HEWSJEmSJEl6F9yUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4rI0fLj6AHVfGLuMurVBFXXThQbqTixsom6jN4a6n3jqEuq+eecM6iIifmn+OdT9k80voq59bRx1+Q7KIv/oLuru355CXfrxFupSK0XU3b56AnW/eXYBdc+eOoW6V188ibrLk0uo+8Ijr6EuIuL1E+yYo0wOdf3KiB2vx/ar+0tscKWzQ9QdVusc+xyjZgZ11bfZ1JhlQzzKr6dQlztg12nhr1m3s8bmu4iI/TMD1E2tsTFU2mbH65XZWCtsoyxyTfb51i+y81Zvs/N26+weLzzN1qo7jTnUferpK6hbLO6g7srePOoiIh4c1FC3vTCLugK7NJGC00l6jz3H6Qk2Zt6Lv3xwDnXnJ9ZQd2t3EnXpFPtuv3/zIupmjrEHcX15AnWpZbb+R0RsnKig7t/c/xjqfnH+edTlFg9Q111n8+0wy+aKzjSbQ3cuoCxy+2ws5Pbh+g9vXfM86/I7rHs3ds+z71y9xb5zt84mn1Sf3WNqNHp/j/c3/cuNT6DuA5VbqHtknP1mXM4cR11hB97Hq1uoGxXY2pDqv//vrrW32YPTnWTvq+UHbGy0gs2f5TX4vtpg92T7Y+z9nK4Em4+yz1daY9evsM2+R2GPde0X2W/ziIiXHmefsdfIo666y65Nr46yGOXZd87svT9/4+RfSkmSJEmSJClxbkpJkiRJkiQpcW5KSZIkSZIkKXFuSkmSJEmSJClxbkpJkiRJkiQpcW5KSZIkSZIkKXFuSkmSJEmSJClxbkpJkiRJkiQpcW5KSZIkSZIkKXFZGv7Z/UdQN318H3V/uvY46va7BdSt7VVRl5kaou7NvVnUHZ/cRl1ExOncOuoWx3dRt/tYB3Xr22OoG41SqEuX+6hLrbJ7F0faKGvPs8Olhux7HKtsoe5y4QTqKuMt1L2+A79IRKQKbLzm2GMX+V12bRp5NjWMMuy8gzE2Zg7rC4+8hrofn7iEuv/x5o+h7u76BOoaW3nUjSoD1B39Y/b/CSl2uIiIyO6yY0691kBd80gJdf0iG5PDHMpi7UMj1KWn2LzT32DfozXHznv/pQXUjS+z6/LM5BnUnZzfQN297XHURUS09oqoS9fYtaH3mBrWe6jrdvCr0KGt3GNzxX6LXdP2jRrqJi5sou5nT15G3bUGezf64Owd1L24sYS6iIj7DTY2j1TZO9RLBydQd2qGXcN7TfiuBdfNyTfYHLB1ns3d5RX2HB4soix68LkeFOGc3IPvJ6fexfsEO2QUtlnYnGfdKMu+c67O1qFWh71DHNZf3j2Huj9ceQp15akm6lJPs2d1ZYH9xiuvsnlx6wL7fTKA7ycREaV19r6+9Rg+JELXTTYiI/rslQc/r5XX2Zo2HLKuvsG+SekGe+fpV+ZQN3ZpBXX1b7JnOiIilWZz9/qPnkRdA87d+Q22CHWn2I+Id/Nb4/vxL6UkSZIkSZKUODelJEmSJEmSlDg3pSRJkiRJkpQ4N6UkSZIkSZKUODelJEmSJEmSlDg3pSRJkiRJkpQ4N6UkSZIkSZKUODelJEmSJEmSlDg3pSRJkiRJkpS4LA0/u/Am6p7fO4m6N7/FumEBZTFabKPuXGkFdV/ZexR1jc0y6iIifnH1P0Fdf7OEusJsE3WDnTzquhMj1JVeY5+vuMGOt51hN3lYHKIuUiz76hvsHk9cZnu3o9fGUZf++QbqIiLS+QHqOpPseLl91g3K7FrndjOoKx5tsRMf0rW9GdRdrNZR91+e+AbqfjPzKdTd2D6CuuiysVb99nXUFdePsvNGxCjNHpzU6zdQlx2/wE48xcZQCj7+Md5D2bkjq6i79uFZ1FUrbA3ae7uOum6N3Y/RKps/by8voW5QYPN2RESuxT5jtsm61mIfdakSmxezq2zt603BReM9OHViDXWDIZsD1k6yz7yxWkPdb9/+OOoW/oqd9+os+x5jy+yeR0Q8+CibK9ZOVlE36B9DXancQV3rCHt2Cptwrh2w43XrbHJsH2PXen5xG3WbO+w659Lse+SuVlA3fhX/dIkuG/6xd5p9xkGJdekZth70duGPnFqXdYe0vTGGupnFHdT1+uxZbXdzqDv9yH3Udb+2gLpBnj2D/SLKIiKiPcHmvEGBPa/pLvuMvRobk/06Wzf7s3A+2YfPYQq+U7AhE80ldl2GOfjeDd8ti0cmUNcdZ+8dERG9Mfale2U4XqvsWpfvs+NV77IxvXeKvzd+P/6llCRJkiRJkhLnppQkSZIkSZIS56aUJEmSJEmSEuemlCRJkiRJkhLnppQkSZIkSZIS56aUJEmSJEmSEuemlCRJkiRJkhLnppQkSZIkSZIS56aUJEmSJEmSEpelYW+YQd03v/U46grNFOpaEwPUfe7sG6j7881HUddp51CX22BdRETxSh51qSE7XqMGb19uhLLslQrqJt5i92QEtzxTAzYWLpy/i7q3XjqGuvK1EuqmX95HXa9eQN3bd2dQFxGRybNrXbnH7nFnkl3r0n02ttpz7POl+mz+OKwjlV3U/dHKk6ir51uou3lpEXXzz6EsmrPwOqXYfUz34GQSEVsPV1GXXWJz/M5ZNgGkL7J717lWQ93EZAN1jS57XvOFHurmxtg8sZsbR12wW4z1FzosHPETZ3bYNSxsseO1jrCuMs6ez+YOXMfX+Tp+WOkUm6NPja+jrjdkz1dri61zY4t7qNt8ZAJ1VHcMv4bGBz7O3vNeWl5C3QiO9VMTbAAffIDNPTfvT6NuUGD3bpRj63Cm3Efdyq0p1NXeZPeuNcvGfn6fdQcLfI5a+Ax7bxyHa/7yHhv/mxtjqMuNs3m512S/H37QNt9iY2PyMrtHkwfsnl//NHsWZqbYO1SaLesxfBdLw8I34TxxlI2hfpU917l99hxOHGHvWtvrbOzmd9k97sJXnlGBzU/jS2ye7d+cRF2KXebojbHBkB6wMR0RAbdWorzOPmR3nB2wx1738W+NQYH/1vh+/EspSZIkSZIkJc5NKUmSJEmSJCXOTSlJkiRJkiQlzk0pSZIkSZIkJc5NKUmSJEmSJCXOTSlJkiRJkiQlzk0pSZIkSZIkJc5NKUmSJEmSJCXOTSlJkiRJkiQlLkvDtxqzqCtupFA3KLLzFjYyqGsNcqjb67ITDwZsvy6VHaEuIqJxYoi66m32nYcN9p0L6+x4U68NULdzhh0v00FZnPvALdTtddi9K2yye9eZYPfu9herqCutsbFfuImyiIgYu8M+Y36fja1Rhl2bfpl9l3Sbdd1N+MAf0rN3TqAuxT5u/OcPfwt1r5+aR9327gTq6DM4WppDXXuWX3c6J69/lH3G3HgTdUeqB6grPr2DusGIjfG3V6dQd2RqF3Wfn72KumqOTYxXVs6h7vif91HXnM2jrjXN/68q02HzU3uKPXipEZxPXhtHXYYtkTHM83X8sJ6cXEbdEF4DOJXF9BE2fnf2yqjrH+mhLl1k43K4zOeo5f066nrb7JiZBnuXuXRwDHW5sS7qUqsF1HVOt1FHTdcbqDtxfAt13+uyOSrq7LqsLrBRndmCD3ZE3Lp8BHX5o2wd6vXYmBmfYMdrttm8/INWu8Q+R/0me67Lt/dQt3+WzeWPPMzmz9sL7F1rvMSere632DteRMTtn5lEXZY9hjFcYHNtp8LuSX4If9fm2O+J+pts3SzsseP1KmxLYuUTbMwU6iiLPFsiY+84m3fmfu91dsCIKBbYWkCN0qff1+PtnWBjJtegbyTfn38pJUmSJEmSpMS5KSVJkiRJkqTEuSklSZIkSZKkxLkpJUmSJEmSpMS5KSVJkiRJkqTEuSklSZIkSZKkxLkpJUmSJEmSpMS5KSVJkiRJkqTEuSklSZIkSZKkxGVp+J8u/BXq/sHEWdRV7qdQ11wYoW6huIe6q5vzqJusH6BuczuPuoiI3A7bA9w/22cHZJcmFj5yH3Vbj5dRN11pom75lSOoe7BXQ93urTrqZm8PUZeC16+wO0Bd6W4DdXd+YoKdOCK6NfacNBYzqOvMsGszrPVQl2qw82bqXdQdVjbLvle7xZ7XX7/8adQNVkqoK8BHujXF5ojqn1xHXWrucXbiiGhPsrFWnWVzYzbN7sntG7Ooy8CxNnaLfY9yAWVx9zQLX6geR91wxD4fNUqz403+uxuou/332BoeETHMsnPn2fIcuX12j7NtNnlvPcHm7swBO+97kUuxzzKeY+vrzy29grrfuPxJ1JVfYOv/MIeySA1Y2J6FC3FElHNsXcrA9auwzF6B06vsu+Q+yQb6zMVN1B2p7KLu0hp719raraDuY3M3UUeNBvD/v3tsPkkN+Bw6qLLnrr3L5vnMDhszsxc3UPdgNIa6Qf8HO0d14Wvp8o+we1m7Pom6g6Ps+b9QYs/WjfVp1H124U3U/fZDddRFRBz/XXaP7n2SjaH6M0XUbX2EvV9/aom9N946mELdzaVTqNucYs9rcQM+15UOyjqn2It3d5vN74UtNvZ7T5xGXUTExuPsN0Rllc1jgzz8zbjEuhGcukfv0/TkX0pJkiRJkiQpcW5KSZIkSZIkKXFuSkmSJEmSJClxbkpJkiRJkiQpcW5KSZIkSZIkKXFuSkmSJEmSJClxbkpJkiRJkiQpcW5KSZIkSZIkKXFuSkmSJEmSJClxWRrOZhqo60/2UZe6sI+6v3PyFdQV0j3ULYztoe76+jTqUv0U6iIisk3WTn+D7RWufoidd32/irrhkH2+hTK7hmtbi6hrvjqBuumLG6jrnmTXL5Meoa7Zz6Du3lt11D30wbdRFxFx5fYC6qrjLdS17o+hLr3LpoZhcYi6fJ7NC4dVyLHnv7lfYAfMsjE0rA5Q186ysTZxjT2Do4sPoe5gIYe6iIjcAev27tRYWO+irPYWG2uzL7Axnu6xe7L9UAV1Eez5f2HqKOoKL7L5eOYqe2baE+zzFY7PoW6E3woiRuzxj/YU6058ha0t7ZkS6raeZs9dqsGu4Xvxxj67/j818wrqTuTZenhy7hHU3TjN5sZRgT1fY9NsQulv0OcwYjzP5oCxKuua5SLqyjtsXt7ZZt+l02MP2c3n2ZySZrcE/zf0n6YfRV1xgx2wnWHP18TxbdRtl9gcGhERHfhs99l3yW+z7q1rR9h5M2yOwt0hpTusG42xdWlQyqOuP8Xe3f79jbPseDvsvF/KPoG6+nfhO2NE9MtsQSytsfkk3WP3PJ1j573brKPu9Tvsd0dmgn2+IXz/7VXYdZl8ht3j9jQ7XnORTaD5XZTF7im2rkRE9OHy166zeWfrMXat6TqeGsDfJPD39DvxL6UkSZIkSZKUODelJEmSJEmSlDg3pSRJkiRJkpQ4N6UkSZIkSZKUODelJEmSJEmSlDg3pSRJkiRJkpQ4N6UkSZIkSZKUODelJEmSJEmSlDg3pSRJkiRJkpS4LA2/0zqDutpsA3WFXB91K51x1P3lVz+Aus70AHWTL7P9utRsCnURESO4BTiCh5y+sIG67ZdmUNcbG6Hu7lgddVR3voe6pbEd1B0p7aGulm2h7gEcgy+iKuKhsVVYRly7ewJ1o1obdZX5A9TN1fZRt7w+gTr6vB/W1noNdT/5+CXU7fRKqPv2NTYv/t6P/Abq/u7Kf426jcerqKPPVkRE9c086kZFNodmckPUTbzFPmN+eRN1/Vt3UDdzbwl1d3/hGOryr7B70mdDK+7+MFswMh22YOT3y+zEbBn4f8C1qnKPHbQ9xy5OpsXGVnQzKBul382XPpy7+3XU/VXuPOr+pFdE3e3n2DivbrKbmYbXtDWbQ92Jb/M56vq5c6hLwds53oDhiHXFShd12Qwbv8MWuyc59todvQ+zdb3XY/e4e5TdO/q7YL/Bnv/iNTb2IyI6E+xaZ+G1Lmyz87YX2PFSFbj+FX+w71D9KhvjM3O7qOu+wn53RI+tc/00G5PpDjtet8t+/may/Dde4wj7jJk2u9aVFXbPt9YKqHvzyll2XvZzImYudVBXfJu9uw1r7B2lX2Xvqvfn2PHG32L37eAIu29jd+H7SURMv7DDwj577x7kZ1G3+xA7LV5M2SV8R/6llCRJkiRJkhLnppQkSZIkSZIS56aUJEmSJEmSEuemlCRJkiRJkhLnppQkSZIkSZIS56aUJEmSJEmSEuemlCRJkiRJkhLnppQkSZIkSZIS56aUJEmSJEmSEpel4afLb6Huq+OPoW6xvIu617YXUFe7OULd2jzrNj8wQF2m3kVdRETuzTLqOvUU6mq5HurWjnZQF/s5lGXSQ9S1Z1g38SI77+25CdRtd9h1/uWl51B3eXcRdfsbFdT9xbc+jLqIiFyedf2X6yxkQyu2nmTjP26za70zh6eaQ8mV2XP4hfpl1P3Py59FXeW1Iup+pfJ3UTd1hV33IbycG8GerYiIIU1HbBANGvC5/kl2vJO9WdQVqmxMtufY81rYZmvGwRH2PdJs2o6xW+z/jOjn64yz443dZseLiOhVWTf3zAYL1zZR1vzgaXa8PFuD4Gz3nqRS7LrWc03U3T2oo278cXZNN2+z9TVzwMZRf6KPuv2jfI4asOkWd/TZ2T7Pnu3UkHWPzT5A3XeOsjmqX2bXenDAXigyK6xLF+Hcc4mNrf4EexKL7BGJiIhujd0Tuqa2p1k3KrLvAl/JYqbWgOXhdOfZwrSxOYa6eo+NjdxWBnWpEev6x9qoW5raQd3NR+BkEhGz32GfcQDf60v32T2ffX4cdek+G5O7p9j3aE2zuXuUmkJd6Y0V1A1m2b5A6wj7vuM36FPI1r7Ru/hzn+bxGurKb7F3qAx97ubZJNprwfV5QK/h9+dfSkmSJEmSJClxbkpJkiRJkiQpcW5KSZIkSZIkKXFuSkmSJEmSJClxbkpJkiRJkiQpcW5KSZIkSZIkKXFuSkmSJEmSJClxbkpJkiRJkiQpcW5KSZIkSZIkKXFZGv4vm59A3UJpD3XPPTiGunY7h7rUWZRFbieDusJmCnXtGXa8iIje2BB12Zvs3Pu/fwR1k6iK2Hqcfb5bd2bYAWt9lPV/9IAdb8Cu9fIa+8a/9urPsPPOdlBWey2PusWvrrDzRkSk2Fh44x+we1K7zvahd1bHUJdntzii94Pd/54aZ2PoycIW6v7piS+j7u9/6pdQ968e/h3U/dKN/wp1/Tq78D9+8RLqIiL+/LtPoG7yZfYc1q93UZffbKFu96Ea6u5+ZgJ142+hLII9ghEjlg3ZNBG1K+we3/84ux+jBTaPxUaBdRExdoM918NqkR3wJnuOe1V23nSD3bxRFt689+DjczdRd770AHVfX34IdU/M3UPd8y1239u7rEvBazrxBnv+IyJ2zpVQV9hj7zKdGhtHvXF2vNEG+3zfvX0BdbX7bPymu2xSGcFlONti9273DPt84zfY8TZ+iB2vsMWfV7jkR3uanbtxtoe69B77eZVbYvPycEQXosOpTzdQ96ml66j749ZF1J06vYq6jUYFdfnsAHXtPrs/2T3+Gy/bYeNy6zF2L3cfqqOODo0j32Hz2NwLbEwWVtiYaS9UUde/y9aq/gcWUTf5Mvy9A+exYYHd39IGf1Z3zrA9jo3HFlDXfLiNuqcW2bW+dI9d695KGXXvxL+UkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4rI0zMQQdR8dv466b1y+wE48Ylk2z7oU+xrRfLyFutzNEjtgRFTus64zkUJdpsMuTmuGHW/82C7qfv7kK6hbbk+g7h/NfR11/9lb/xHqWs0C6iYvs+sSUURVYXeAusFUFZ43oj3Nzp1ip8ayO3BqgJcwXe4f/sMA69tjqPvna59A3V8sP4S65vVx1P2HN/8L1GXh/HTh7D3U/cbid9kBI+I3P7uMun+x91OoS/fYpDw6xbr9YyiL4oUddt4bddRlW3CeXWI3b+nMGupWSvOoG1TZw58asoc13aPzYkRxm33n7fNszkufuYi6vRPs/9NGWXhtuvw7H9YLm2wAv5JeQt3w22x9fXa2jrrMiQbq0ntwbZjtoKy5wNbriIiJN9l7WWrAxmX3oQrqChsZ1OWe3EZd414Ndf0iO28KXsLCNpvLds+w46V7rGsswnfaNjter8qf1/Fb7N2jPcXGdWk5h7pujV3rTAaO1QEbC4f15Nxd1PWH7HM88hA73l6HveMere+g7vU3jqJu8cQG6uiYjIjojLNxWTizh7reVTZP9Ba7qFt/gk0Usy+iLAoddt70AD4LZ06yDv72nf32Ouqap9la2lhkc0T9hVXURURkH51BXa/E3nm6P8TeeV5bWWDH24WLSw0uBu/Av5SSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLisjScL+yi7o9WnkRdqsf2w3JbrMt0UqhrHeuhbrJ+gLrdagF1ERFbH+yjrnQzj7r66gh1gwK7NvvX6qj7P178YdRlL+6g7ur2L6Pu/uY46sb/qoS6yUt7qEsNh6jr14qoy+y1URcRUdnvoO7kn1RQt3eCjdfeNhsz7Rl2bWan2LU+rEEjh7pnVk6j7uAWG2vVZTo/sWeVemNhHnXfPT7Ax/z1q59GXWmFjY1ujZ23+mMrqNt9ZQ5156bWUXfpTB112dNsLfiPz72EupMF9vn++wc/ibpipYu69EtjqJv/HptzIiL2jrG1qjPJxkztNptPUvRxGrDzJvHfc2N5dl3Twb5ce5Z1/Rk2PgYrZdTlWuyaZt5k63Bx612MtxNsje3W2GfceYSNt1GedXPlFuoafba+pNkrYzTOs3vc2WTrZAqet3+CvcvkX2VjIbfP7luuwdfT8p191BVX2c+hxnH2nGxdyKBurMTGfzELb8ohvbS6hLr+kE2WnQ67nr0d9kyn23CSLrN3no/Mvo26PzpeZ+eNiNFd9n7ducZejrI99jyMXWLnPVhi89j6RXbv9o4toK6yxu5Je3IWdaVV9swMy+y6lG+x/Y1ss4q65tlp1EVENObZPJFity56LTbHj26zeSxVhmvk+/QTx7+UkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4rI0/Mq9x1G39tw86s7+d8+iLl0us25qEnW7H1xEXWNxGnVnf+sS6iIiho+cgmUHVa0jJdTtPjxE3eKJDdTdu8uu9b95/PdQd6vHrvWXik+i7sYku87Dcg51uXtbqMsORqhrnK2jLiKiNZVBXabLzt2rplDXPNpHXXqsh7qjYzuoO6xCvY26rZ0q6upX2XWafKOFultfKKIu2Glj1GXjYjLDrktERHObzSezO2ysDfLsvL3fnWPhIyzLpweoW/rAfdTdusE+X3vI5pMvVt5G3b+cOEDd3j67b3l4P1oz7HtERGTbbCw0C2xgb59l47ozxda0TIuddzDGjvdezBQaqPvpqZdQ90/O11G3vTGGulGe3cshfGsssq8b2+fgwIyIYB8xGkdZd+TMOj83sLw2wcIU+yKFLdaNrrFr2Fxic2N2mq1rhSx7bkZpNkeN2OMf/TJcKCNi9/w46nrwmN0669oL7B2q2GMP1FiB/S44rN0d9ltr1GN/y5CrsHfDdJMdr7jBusmr7Jn55vc+jLqZd3HZx280UddcqKCuM8We1/YR9hyeOLmGurvrbB5LvcrGzDDHHuz2DLt3pTV23vp1NgZ3T7F3Hrr27V1g542IyLOf3dGdZ8f8xIW3UPft/YdRR98LYsDn5O/Hv5SSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLisjScLjVQd3d8xE68eAR1g/kJ1B3MllG3/iTbhxu7xb7H8JFTqIuIWPnYGOrq1/qoO5jLoC6/jrK4l51E3fT8Huq+tvco6r61egZ19WILda2lAeoaS0XUdR5ZRF1hj42ZveN8L7h5jH2X3DY75jDHPmNuj42tUb2LuvYgh7rD6myze1mYaKOuV02hbus8O29/qoe6zC6ckgfs8/0HL/89drx3ccyDI7A7w75z9U02NgYV9iw8aNbY8YbsmXniwm3UUc0RewYPWnnU5QtsvWgfY8/q6jh+LYjaDXYNm8fZWCjeZ2NhWGDXcFQeoi7V+8H//9xuj80V93vsnWevUUJdZovdz8EEG0eLF9dQd+etOdTlZti6HhHRW2Hvebn5JuomS6xbO6iibthl62Z6gj2Lmx+Dx9th9zjbYOM8tVNh591na0FpjT2vGx9j80TrODtvRET/GptTGqfZuQO+Q2U22Xl3d9iYrhTYmDmsQpl9//YOfOfpsDFZOHqAulaGjcneHTY28vvsPrYn+VhrHGNzcrBTR/aAPa+9Kns3Wt1lv0FHD9g97o3BdTjLrmF3lq1B6T57tkr32L7FxmNszU3DKaL4gP/eycDlb5Bnx7y2M4O6UQ2+k1XZvNNZY/PYO/EvpSRJkiRJkpQ4N6UkSZIkSZKUODelJEmSJEmSlDg3pSRJkiRJkpQ4N6UkSZIkSZKUODelJEmSJEmSlDg3pSRJkiRJkpQ4N6UkSZIkSZKUODelJEmSJEmSlDg3pSRJkiRJkpS4LA0frq2g7q0HZ1HXuLiEut2T7CPuPTRA3ekLd1E3/skW6l5+/gzqIiJG023UDXNF1B0sse8c4z3Wtdi1TqVGqPvdZz+MuvxWBnVrp5uoS3VSqNu4yLoRy2JQZdelMLvPDhgR8aCMstS5BuqGHfjIrxdQNjV+gLqddomd95AuXriFuvYgh7rrT7Ob/vixO6h7a3sGdeuDOuqqs+y6d3t4io9Uh/0fxcEpNp/8449/FXW/Pv1p1M0VO6j7hyf+AnX/+PLPoq6aZ+f9zuop1L2yxda+3g5bBwpz7Nk/urSJuvvbc6iLiDhYZHNe8R577go77LzpLlsz+nBO7k7BtfQ9+JWFb6PuYMjm3kGHXYNUnl2Dcp298wzhglg/toO6/pD/32i32kfdZI3Nj2sHVdTNV9iavdqdRF1qC87L1SHKcvvsGvbLbCzAV56Ar4JxsMSOWJlkY/Bgk70XRUQcPMLeu4/Ob6Pu3noddcMiez6zeTb3dAfseIeVybCxFgN2L3OredT1T7Hvn22x8zZnWVdeZd+3ep+vDeW7bN4ZpcdQV7nfRd3mo/A348fZ8Qon2HzXesDmz9EJ9g712CLbZ3ijNou6a39nHHXjb7KJbPJNNpfsnGL3IyKiW2fjdeIqO97OAXx/m2VraXe7grpMn64a359/KSVJkiRJkqTEuSklSZIkSZKkxLkpJUmSJEmSpMS5KSVJkiRJkqTEuSklSZIkSZKkxLkpJUmSJEmSpMS5KSVJkiRJkqTEuSklSZIkSZKkxLkpJUmSJEmSpMRladga5FCX7rHjdcfYfli2NULd2NIe6tLBjlfM9FE3moRfOCIW/jSPutYk+4y5fXYNh9ND1P3Eoy+hbiLbRN2zpZOooz4/exV1v974LOp+4annUffS1lHUdfrscdpvF1AXEdGd6KLuf7j4R6j76vYTqHttZgF1VL3Yel+P9zf92MzrqLvRnkXdhdoK6k4UN1G3UNxF3b8fnUVdPsvmp5X1cdRFRKS7KdbNdlD3ZnMedfO1fdRR//C7fwt19WeKqLt+qoa6YQZlMcyz+X3hWXa8jcfZPb5bYd+jep//X1Vxi32X1JB1nTobg/0qO96gwLpsjc2z78WXNp5C3ecm2Fx25tga6h7ssvv+kcVbqPvu/eOoG43Yvfz00euoi4j48+YF1K0sT6LuJy5eRt0XJ15B3T/a+AXUVY6y8Xasto269nn2fn5ri12XcoF9vr0Xp1HXnWDvoKO1CuoizZ7riIjyGFuvZstsHVpuT6EuVWO/Dcaq7N2IPk+H9eMnrqDuGzn2jtKZZWPyYLuEuqXvsTG0fZYtxJ1xts61pvl62KuMsa7E7uXmw+wdZedJ9rw+vXQPdc9fO4G68kIDdUt19v77uWn2G6+eZ79Bnzk4h7rWLPxtvsm6FJ+eIg1fPejj3x1nz8n0sR3Ubb/J1oxBhZ33nfiXUpIkSZIkSUqcm1KSJEmSJElKnJtSkiRJkiRJSpybUpIkSZIkSUqcm1KSJEmSJElKnJtSkiRJkiRJSpybUpIkSZIkSUqcm1KSJEmSJElKnJtSkiRJkiRJSlyWhieKm6h7+OfeQN33Xj6LuvxWCnWd1Srqht+eQN3G3gh1tSL7fBER2+wrR/uhNuqqtRbqej12mw/6BdQNR+w7/zfHvoa6z5d7qPtqs4i6UydXUdcZsuuyvFlHXXetjLrUeBd1ERG5Qh91v7P2YdQt79dR12izsdDpsmtIx8xhfWPrPOo+N3kFdS83jqPuyw+eQN1Go4K6/dvjqKvcY/+fUN9l81hExNZTbKwNDvKo+/IVdm1GA/ZdMqvsvMUdNtYOFlEWo2DXMNtk5+1l2fG2z7HrMoLHKx/dR91+tYS6iIj+2+yeDErsM6bZUhC92pCFULXceV+P9/+mlGFfrj3KoW6/w+bogx12P69VZ1B3cf4u6uYKbLy9m7VhZoIdc21QQ91f3T2NuhfWj6KudcDuSa+XQd1kqYm6uzt11KVS7Dn8zJFrqPt2ZoA6eo83Xp1FXb/KzhsR0WqyOWqzzdboQo3NFYM+u8f7DfZ8Lk7voO6wDgZs7Kbh4zoz1mDn3WXv9WtPsvWwN8HGRuU2uz+FLf4ONcixi5NvsGM2xtnxCstsjD/fP4W64n22BrXHWXcNzotfHrF3xokCmxfT++z3SWeavU/snWBjJv8u3rv7bNqJFJzy8tvsOdnaYSfOdNgYHEyw3w/vxL+UkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4rI0/J07T6Gu2cmjbvxqBnWp4Qh1lXvsq0y81UZduj1A3SiTQl1ERKRYu1woom5/ie0plmrsO99qTKLuxhtHUNf/ILvH32vuoK6c7qLuWHUbdX+9chJ1/dtV1OWbcCxsllgXEb3aEHXPbZ1BXbrSQ934eBN1cEhHt8/GwmE9/71zqHuh/xDqxt5mX2xYQFkMc6yr9lmXbbF5McMe/YiIKC6zD9mdZGMyt8eOl2mxa52F3yV7wK5NeYN9j4M5Ns+mBuy8rS47Xo49gtGvsK55l81jmS5f0+j4qt1i16YPp8ZBHl7DffZdmpNszX0v6vCGXm/Poa7ZZc9Xqsnm3vtbNdTtw3e810YLqNt7awJ1ERGDSThBDth9b3TZtTnIsvGR3mDXJrPPjndzBJ/FFHu+fvahy6grptl7wv3lKdTR+1HahWvByRY777tw6xp77tJw/o6pDsrqdTYv7DT5e+Nh3DngzyGxvs/Wm2ixZ7A3ztbrUZnNEcMsO29znq+HxU26zsHnYR2+y6yyrrMG1wz4LkO/x3CLzYv3S+OoWx7UUVdcfX//7iYFl59e5V28Q8GprDPJjjl2m927zUn242UEL2Eqw57Pd+JfSkmSJEmSJClxbkpJkiRJkiQpcW5KSZIkSZIkKXFuSkmSJEmSJClxbkpJkiRJkiQpcW5KSZIkSZIkKXFuSkmSJEmSJClxbkpJkiRJkiQpcW5KSZIkSZIkKXFZGn524S3UPbd5AnXXn6iiLtXKoG5UGKJu72QBdekBymLIPl5ERJTWU6jrHOmirjrRZOfN91D3+bkrqPvjXg51V7bnUfer57+OupkMu3c3q6+hbjjP7sf/vvBR1D2zchp1zS67fhER3d0SCwdwf5l95egP2fFSqRHq0vC8h3Xm8buoK2T7qHu1fhR12U02haaOs2d1AO9jCl7PifEDFkbEYJ+NtXKRzScHe0V2YvhdRgfsWldvsG7rQ2ySz5Y6qOvvw+c6x56Z9j77HqMKG9OZEvu+gyZ+LYh2n928xim2Pgf8jOksPF6OHW+80mbHew8+X3sVdVfai6h7fPYB6thZIyYrbI6aKrI5pZxl7zG52Xuoi4h4bIzN8xu9MdS91ZhF3XqLva/+8gefQ91fbD2MukfH7qOuPWRzz/WDGdSNZdmc98OPXUXdzf0p1O0eYWvGZ5fY75GIiNvNSdTdKrOukmfjeqNRQV0+y+aoTIrN84dVzLB1fa66j7qDXh514+UW6nab7P2k22U/yiof20Pd3gF8j4mI7QP2neuTbA5t9Nl3aW6VUZdqsXeP1ICt69WTu6ibHWugbqLA1qA0/N3xXPMU6qLD3rtzu+x+pOD+QUTEoMi+y6DC3nmaJ9nxxmbYPTnYZ+M/C9+13ol/KSVJkiRJkqTEuSklSZIkSZKkxLkpJUmSJEmSpMS5KSVJkiRJkqTEuSklSZIkSZKkxLkpJUmSJEmSpMS5KSVJkiRJkqTEuSklSZIkSZKkxLkpJUmSJEmSpMRlafhWYxZ1d7fq7ID9FMpGY33U5Uo91A0qbB+uWO2gbnF8F3UREddXZlB3ZHIPdQsV1t3dr6PuXmcCdZ0+Gza5AruG/3Tlc6jb7ZVQ1x1kUHe6uoG6vX4Rddn0EHWDAd8LHnXZd8lVu6ibHD9A3Ri8dz14rQsZ9hwf1r3dcdT1+/Dap0fseHPsuufh8WrlFupmqw3UDYPNsxERgyFr9xvsORwdwOUly65NFAcoO3iMjbWxcXat2+0c6lIF9vyPumwMZueaqMvn2XVpNfOoiyz7HhERwzy8d3AYZvLs3MUSe+7ScE4eDn/w/z/37MFZ1L26v4i6nS57Dh+ZWUHdbHEfdccKW6j79tZp1FVzbK2JiPja2sOoG8D7Wcqy98ZWj80B/+utj6Fu94Dduyvrc6irFNjzkEmx53W6xN4Tlso7qKPrfx/et2v77PdIRMRcib0nbxYqqJsosHl5NOJrL1GEY/WwXnuwgLohfH+tVtqoO2gV2PHK7HilPLtOvT57d314ns2fERH3G+w9NJ9ha/bqzhg7MXyuRxV2Xjp0m0127+7Ba72WraJussKewTR8NxrCd7LBEhuDafi+HxExgu/dtSo7d6vF3vNqRfgbr4e3id4X/qWUJEmSJEmSEuemlCRJkiRJkhLnppQkSZIkSZIS56aUJEmSJEmSEuemlCRJkiRJkhLnppQkSZIkSZIS56aUJEmSJEmSEuemlCRJkiRJkhLnppQkSZIkSZISlxqNRqP/rz+EJEmSJEmS/v/Fv5SSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi3JSSJEmSJElS4tyUkiRJkiRJUuLclJIkSZIkSVLi/m9womEfJ++8DgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1200x900 with 12 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# # generating some random image\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Set the figure size\n",
    "plt.figure(figsize=(12, 9))  # You can adjust these values as needed\n",
    "\n",
    "for i in range(12):\n",
    "    img = generator.predict(np.random.randn(1, 128, 1))\n",
    "\n",
    "    # Plotting the images\n",
    "    plt.subplot(3, 4, i+1)\n",
    "    plt.imshow(img.reshape(28, 28))  # Added cmap='gray' for grayscale images\n",
    "    plt.axis('off')\n",
    "\n",
    "plt.tight_layout()  # Adjusts the spacing between subplots for better layout\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_discriminator():\n",
    "    model = Sequential()\n",
    "    model.add(Conv2D(32,5,input_shape = (28,28,1)))\n",
    "    model.add(LeakyReLU(0.2))\n",
    "    model.add(Dropout(0.4))\n",
    "\n",
    "    # second block \n",
    "    model.add(Conv2D(64,5))\n",
    "    model.add(LeakyReLU(0.2))\n",
    "    model.add(Dropout(0.4))\n",
    "              \n",
    "    # Third conv block\n",
    "    model.add(Conv2D(128,5))\n",
    "    model.add(LeakyReLU(0.2))\n",
    "    model.add(Dropout(0.4))\n",
    "\n",
    "    # Fourth conv block\n",
    "    model.add(Conv2D(256,5))\n",
    "    model.add(LeakyReLU(0.2))\n",
    "    model.add(Dropout(0.4))\n",
    "\n",
    "    # Flatten \n",
    "    model.add(Flatten())\n",
    "    model.add(Dropout(0.4))\n",
    "    model.add(Dense(1,activation = 'sigmoid'))\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "discriminator = build_discriminator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d_5 (Conv2D)           (None, 24, 24, 32)        832       \n",
      "                                                                 \n",
      " leaky_re_lu_5 (LeakyReLU)   (None, 24, 24, 32)        0         \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 24, 24, 32)        0         \n",
      "                                                                 \n",
      " conv2d_6 (Conv2D)           (None, 20, 20, 64)        51264     \n",
      "                                                                 \n",
      " leaky_re_lu_6 (LeakyReLU)   (None, 20, 20, 64)        0         \n",
      "                                                                 \n",
      " dropout_1 (Dropout)         (None, 20, 20, 64)        0         \n",
      "                                                                 \n",
      " conv2d_7 (Conv2D)           (None, 16, 16, 128)       204928    \n",
      "                                                                 \n",
      " leaky_re_lu_7 (LeakyReLU)   (None, 16, 16, 128)       0         \n",
      "                                                                 \n",
      " dropout_2 (Dropout)         (None, 16, 16, 128)       0         \n",
      "                                                                 \n",
      " conv2d_8 (Conv2D)           (None, 12, 12, 256)       819456    \n",
      "                                                                 \n",
      " leaky_re_lu_8 (LeakyReLU)   (None, 12, 12, 256)       0         \n",
      "                                                                 \n",
      " dropout_3 (Dropout)         (None, 12, 12, 256)       0         \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 36864)             0         \n",
      "                                                                 \n",
      " dropout_4 (Dropout)         (None, 36864)             0         \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 1)                 36865     \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 1,113,345\n",
      "Trainable params: 1,113,345\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "discriminator.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 120ms/step\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0.5092199]], dtype=float32)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "discriminator.predict(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Constructing Traing Loop\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.optimizers import Adam\n",
    "from tensorflow.keras.losses import BinaryCrossentropy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "g_opt = Adam(learning_rate=0.0001)\n",
    "d_opt = Adam(learning_rate=0.00001)\n",
    "g_loss = BinaryCrossentropy()\n",
    "d_loss = BinaryCrossentropy()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building the subclass model using base class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(1, 128, 1), dtype=float32, numpy=\n",
       "array([[[-4.15853620e-01],\n",
       "        [ 9.59574342e-01],\n",
       "        [-1.60071015e+00],\n",
       "        [-2.44751155e-01],\n",
       "        [ 6.77774549e-01],\n",
       "        [-4.83888566e-01],\n",
       "        [ 1.46601111e-01],\n",
       "        [-1.47163916e+00],\n",
       "        [ 3.24657440e-01],\n",
       "        [ 4.41436023e-01],\n",
       "        [ 2.52050948e+00],\n",
       "        [-6.71251118e-01],\n",
       "        [ 7.27078617e-01],\n",
       "        [-1.02758098e+00],\n",
       "        [ 1.43968493e-01],\n",
       "        [ 3.93999428e-01],\n",
       "        [-9.20615047e-02],\n",
       "        [-2.79407907e+00],\n",
       "        [-1.94907680e-01],\n",
       "        [ 1.36391222e+00],\n",
       "        [ 1.87971246e+00],\n",
       "        [ 1.96495402e+00],\n",
       "        [ 4.84693311e-02],\n",
       "        [ 8.62839818e-01],\n",
       "        [ 1.77200580e+00],\n",
       "        [-4.35859174e-01],\n",
       "        [-1.19154775e+00],\n",
       "        [ 6.10669911e-01],\n",
       "        [ 1.09770989e+00],\n",
       "        [ 1.57589400e+00],\n",
       "        [-1.53616321e+00],\n",
       "        [-1.39947593e+00],\n",
       "        [-1.75134838e-01],\n",
       "        [ 1.70954734e-01],\n",
       "        [-7.06311107e-01],\n",
       "        [-3.43167335e-01],\n",
       "        [-1.16182470e+00],\n",
       "        [ 1.06471682e+00],\n",
       "        [ 1.95803022e+00],\n",
       "        [-8.14764857e-01],\n",
       "        [-1.28355980e+00],\n",
       "        [-6.87927054e-03],\n",
       "        [-1.34221935e+00],\n",
       "        [-3.91897351e-01],\n",
       "        [ 6.36312246e-01],\n",
       "        [ 1.87870657e+00],\n",
       "        [ 4.15132940e-01],\n",
       "        [ 2.52471018e+00],\n",
       "        [ 8.05304050e-01],\n",
       "        [ 6.09309793e-01],\n",
       "        [-9.55435783e-02],\n",
       "        [ 7.03268111e-01],\n",
       "        [ 6.28261626e-01],\n",
       "        [ 3.48535210e-01],\n",
       "        [ 1.83772936e-01],\n",
       "        [ 7.21196294e-01],\n",
       "        [ 2.07558110e-01],\n",
       "        [ 5.37381589e-01],\n",
       "        [ 8.15202296e-01],\n",
       "        [ 5.31122804e-01],\n",
       "        [-1.05358100e+00],\n",
       "        [-9.47786272e-02],\n",
       "        [ 2.39751160e-01],\n",
       "        [-7.64680207e-01],\n",
       "        [-8.16065907e-01],\n",
       "        [-2.59616804e+00],\n",
       "        [ 9.75312293e-03],\n",
       "        [-2.11447430e+00],\n",
       "        [-4.77667898e-02],\n",
       "        [ 5.05562813e-04],\n",
       "        [ 3.80462781e-02],\n",
       "        [ 1.25882745e+00],\n",
       "        [-7.26231039e-01],\n",
       "        [-1.14295077e+00],\n",
       "        [-9.19599533e-01],\n",
       "        [ 1.30633891e+00],\n",
       "        [-2.62467790e+00],\n",
       "        [ 4.89508390e-01],\n",
       "        [ 8.51964831e-01],\n",
       "        [ 1.01459193e+00],\n",
       "        [-1.82183862e+00],\n",
       "        [-2.17306376e-01],\n",
       "        [-7.57423222e-01],\n",
       "        [ 1.58535171e+00],\n",
       "        [-1.00871742e+00],\n",
       "        [-1.99292094e-01],\n",
       "        [ 4.76133637e-02],\n",
       "        [ 4.44170795e-02],\n",
       "        [ 1.93840727e-01],\n",
       "        [-1.50781536e+00],\n",
       "        [ 1.03335655e+00],\n",
       "        [ 2.00613588e-01],\n",
       "        [-1.65785283e-01],\n",
       "        [ 8.10758591e-01],\n",
       "        [ 1.47085452e+00],\n",
       "        [-3.77255321e-01],\n",
       "        [ 4.17695016e-01],\n",
       "        [-9.93428767e-01],\n",
       "        [ 1.92742372e+00],\n",
       "        [ 9.87737656e-01],\n",
       "        [ 9.92503703e-01],\n",
       "        [ 1.55731833e+00],\n",
       "        [-3.25704962e-01],\n",
       "        [ 9.00377393e-01],\n",
       "        [ 1.26855791e-01],\n",
       "        [ 1.69784820e+00],\n",
       "        [ 8.22068870e-01],\n",
       "        [-2.46776104e+00],\n",
       "        [ 4.94524315e-02],\n",
       "        [ 6.75514817e-01],\n",
       "        [ 5.10414958e-01],\n",
       "        [ 1.06728756e+00],\n",
       "        [ 1.03163846e-01],\n",
       "        [ 4.37453717e-01],\n",
       "        [ 4.87451285e-01],\n",
       "        [-1.63680720e+00],\n",
       "        [-4.08333242e-01],\n",
       "        [ 1.53331411e+00],\n",
       "        [ 7.57330298e-01],\n",
       "        [-1.43811715e+00],\n",
       "        [ 3.17771621e-02],\n",
       "        [ 1.37070858e+00],\n",
       "        [ 9.73025501e-01],\n",
       "        [-1.01572883e+00],\n",
       "        [ 7.16877759e-01],\n",
       "        [ 7.29099708e-03],\n",
       "        [ 1.34214163e+00],\n",
       "        [-2.65885144e-01]]], dtype=float32)>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.random.normal((1,128,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class FashionGan(Model):\n",
    "\n",
    "#     def __init__(self, generator, discriminator, *args, **kwargs):\n",
    "#         super().__init__(*args,**kwargs)\n",
    "#         self.generator = generator\n",
    "#         self.discriminator = discriminator\n",
    "\n",
    "        \n",
    "#     def compile(self,g_opt, d_opt, g_loss, d_loss, *args, **kwags):\n",
    "#         super().compile(*args,**kwags)\n",
    "#         self.g_opt = g_opt\n",
    "#         self.d_opt = d_opt\n",
    "#         self.g_loss = g_loss\n",
    "#         self.d_loss = d_loss\n",
    "\n",
    "\n",
    "#     def train_step(self,batch):\n",
    "#         real_images = batch\n",
    "#         fake_images = self.generator(tf.random.normal((128,128,1)),training = False)\n",
    "\n",
    "#         # Train the discriminator\n",
    "#             # Pass the real and fake images to discriminator model\n",
    "#         with tf.GradientTape() as d_tape:\n",
    "#             yhat_real = self.discriminator(real_images,training= True)\n",
    "#             yhat_fake = self.discriminator(fake_images,training= True)\n",
    "#             yhat_realfake = tf.concat([yhat_real, yhat_fake], axis=0)\n",
    "\n",
    "#             # Create label for real and fake images\n",
    "#             y_realfake = tf.concat([tf.zeros_like(yhat_real),tf.ones_like(yhat_fake)],axis = 0)\n",
    "#             # Add some noise to the outputs\n",
    "#             noise_real = 0.15* tf.random.uniform(tf.shape(yhat_real))\n",
    "#             noise_fake = -0.15*tf.random.uniform(tf.shape(yhat_fake))\n",
    "#             y_realfake += tf.concat([noise_real,noise_fake],axis=0)\n",
    "\n",
    "#             # Calculate loss - Binarycrossentropy\n",
    "#             total_d_loss = self.d_loss(y_realfake,yhat_realfake)\n",
    "\n",
    "#         # Apply backpropogation - neural network\n",
    "\n",
    "#         dgrad = d_tape.gradient(total_d_loss,self.discriminator.trainable_variables)\n",
    "#         self.d_opt.apply_gradients(zip(dgrad,self.discriminator.trainable_variables))\n",
    "\n",
    "\n",
    "#         # Train the generator\n",
    "#         with tf.GradientTape() as g_tape:\n",
    "\n",
    "#             # Generate some new images\n",
    "#             gen_images = self.generator(tf.random.normal(128,128,1),training = True)\n",
    "\n",
    "#             # Create the prediction label\n",
    "#             predicted_labels = self.discriminator(gen_images,training = False)\n",
    "\n",
    "#             # Calculate loss\n",
    "#             total_g_loss = self.g_loss(tf.zero_like(predicted_labels),predicted_labels)\n",
    "        \n",
    "#         # Apply backpropogation\n",
    "\n",
    "#         ggrad = g_tape.gradient(total_g_loss,self.generator.trainable_variables)\n",
    "#         self.gopt.apply_gradients(zip(ggrad,self.generator.trainable_varialbles))\n",
    "\n",
    "#         return {\"d_loss \": total_d_loss, \"g_loss \": total_g_loss} \n",
    "\n",
    "class FashionGan(Model): \n",
    "    def __init__(self, generator, discriminator, *args, **kwargs):\n",
    "        # Pass through args and kwargs to base class \n",
    "        super().__init__(*args, **kwargs)\n",
    "        \n",
    "        # Create attributes for gen and disc\n",
    "        self.generator = generator \n",
    "        self.discriminator = discriminator \n",
    "        \n",
    "    def compile(self, g_opt, d_opt, g_loss, d_loss, *args, **kwargs): \n",
    "        # Compile with base class\n",
    "        super().compile(*args, **kwargs)\n",
    "        \n",
    "        # Create attributes for losses and optimizers\n",
    "        self.g_opt = g_opt\n",
    "        self.d_opt = d_opt\n",
    "        self.g_loss = g_loss\n",
    "        self.d_loss = d_loss \n",
    "\n",
    "    def train_step(self, batch):\n",
    "        # Get the data \n",
    "        real_images = batch\n",
    "        fake_images = self.generator(tf.random.normal((128, 128, 1)), training=False)\n",
    "        \n",
    "        # Train the discriminator\n",
    "        with tf.GradientTape() as d_tape: \n",
    "            # Pass the real and fake images to the discriminator model\n",
    "            yhat_real = self.discriminator(real_images, training=True) \n",
    "            yhat_fake = self.discriminator(fake_images, training=True)\n",
    "            yhat_realfake = tf.concat([yhat_real, yhat_fake], axis=0)\n",
    "            \n",
    "            # Create labels for real and fakes images\n",
    "            y_realfake = tf.concat([tf.zeros_like(yhat_real), tf.ones_like(yhat_fake)], axis=0)\n",
    "            \n",
    "            # Add some noise to the TRUE outputs\n",
    "            noise_real = 0.15*tf.random.uniform(tf.shape(yhat_real))\n",
    "            noise_fake = -0.15*tf.random.uniform(tf.shape(yhat_fake))\n",
    "            y_realfake += tf.concat([noise_real, noise_fake], axis=0)\n",
    "            \n",
    "            # Calculate loss - BINARYCROSS \n",
    "            total_d_loss = self.d_loss(y_realfake, yhat_realfake)\n",
    "            \n",
    "        # Apply backpropagation - nn learn \n",
    "        dgrad = d_tape.gradient(total_d_loss, self.discriminator.trainable_variables) \n",
    "        self.d_opt.apply_gradients(zip(dgrad, self.discriminator.trainable_variables))\n",
    "        \n",
    "        # Train the generator \n",
    "        with tf.GradientTape() as g_tape: \n",
    "            # Generate some new images\n",
    "            gen_images = self.generator(tf.random.normal((128,128,1)), training=True)\n",
    "                                        \n",
    "            # Create the predicted labels\n",
    "            predicted_labels = self.discriminator(gen_images, training=False)\n",
    "                                        \n",
    "            # Calculate loss - trick to training to fake out the discriminator\n",
    "            total_g_loss = self.g_loss(tf.zeros_like(predicted_labels), predicted_labels) \n",
    "            \n",
    "        # Apply backprop\n",
    "        ggrad = g_tape.gradient(total_g_loss, self.generator.trainable_variables)\n",
    "        self.g_opt.apply_gradients(zip(ggrad, self.generator.trainable_variables))\n",
    "        \n",
    "        return {\"d_loss\":total_d_loss, \"g_loss\":total_g_loss}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "fashgan = FashionGan(generator, discriminator)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "fashgan.compile(g_opt, d_opt, g_loss, d_loss)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building Callback\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from tensorflow.keras.preprocessing.image import array_to_img\n",
    "from tensorflow.keras.callbacks import Callback\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ModelMonitor(Callback):\n",
    "    def __init__(self, num_img=4, latent_dim=128):\n",
    "        self.num_img = num_img\n",
    "        self.latent_dim = latent_dim\n",
    "\n",
    "    def on_epoch_end(self, epoch, logs=None):\n",
    "        random_latent_vectors = tf.random.uniform((self.num_img, self.latent_dim,1))\n",
    "        generated_images = self.model.generator(random_latent_vectors)\n",
    "        generated_images *= 255\n",
    "        generated_images.numpy()\n",
    "        for i in range(self.num_img):\n",
    "            img = array_to_img(generated_images[i])\n",
    "            img.save(os.path.join('images', f'generated_img_{epoch}_{i}.png'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "  6/469 [..............................] - ETA: 5:01 - d_loss: 0.9380 - g_loss: 0.7035WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.2533s vs `on_train_batch_end` time: 0.3977s). Check your callbacks.\n",
      "469/469 [==============================] - 312s 665ms/step - d_loss: 0.9225 - g_loss: 0.7389\n",
      "Epoch 2/20\n",
      "469/469 [==============================] - 314s 670ms/step - d_loss: 0.8351 - g_loss: 0.8260\n",
      "Epoch 3/20\n",
      "469/469 [==============================] - 316s 674ms/step - d_loss: 0.6588 - g_loss: 1.0217\n",
      "Epoch 4/20\n",
      " 39/469 [=>............................] - ETA: 4:49 - d_loss: 0.5475 - g_loss: 1.2231"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32md:\\generative\\hello.ipynb Cell 30\u001b[0m line \u001b[0;36m2\n\u001b[0;32m      <a href='vscode-notebook-cell:/d%3A/generative/hello.ipynb#X41sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39m# Recommend 2000 epochs\u001b[39;00m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/d%3A/generative/hello.ipynb#X41sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m hist \u001b[39m=\u001b[39m fashgan\u001b[39m.\u001b[39;49mfit(X_train,batch_size\u001b[39m=\u001b[39;49m\u001b[39m128\u001b[39;49m, epochs\u001b[39m=\u001b[39;49m\u001b[39m20\u001b[39;49m, callbacks\u001b[39m=\u001b[39;49m[ModelMonitor()])\n",
      "File \u001b[1;32mc:\\Users\\Amit Yadav\\miniconda3\\lib\\site-packages\\keras\\utils\\traceback_utils.py:65\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m     63\u001b[0m filtered_tb \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m     64\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m---> 65\u001b[0m     \u001b[39mreturn\u001b[39;00m fn(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[0;32m     66\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n\u001b[0;32m     67\u001b[0m     filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n",
      "File \u001b[1;32mc:\\Users\\Amit Yadav\\miniconda3\\lib\\site-packages\\keras\\engine\\training.py:1570\u001b[0m, in \u001b[0;36mModel.fit\u001b[1;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[0;32m   1568\u001b[0m logs \u001b[39m=\u001b[39m tmp_logs\n\u001b[0;32m   1569\u001b[0m end_step \u001b[39m=\u001b[39m step \u001b[39m+\u001b[39m data_handler\u001b[39m.\u001b[39mstep_increment\n\u001b[1;32m-> 1570\u001b[0m callbacks\u001b[39m.\u001b[39;49mon_train_batch_end(end_step, logs)\n\u001b[0;32m   1571\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mstop_training:\n\u001b[0;32m   1572\u001b[0m     \u001b[39mbreak\u001b[39;00m\n",
      "File \u001b[1;32mc:\\Users\\Amit Yadav\\miniconda3\\lib\\site-packages\\keras\\callbacks.py:470\u001b[0m, in \u001b[0;36mCallbackList.on_train_batch_end\u001b[1;34m(self, batch, logs)\u001b[0m\n\u001b[0;32m    463\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Calls the `on_train_batch_end` methods of its callbacks.\u001b[39;00m\n\u001b[0;32m    464\u001b[0m \n\u001b[0;32m    465\u001b[0m \u001b[39mArgs:\u001b[39;00m\n\u001b[0;32m    466\u001b[0m \u001b[39m    batch: Integer, index of batch within the current epoch.\u001b[39;00m\n\u001b[0;32m    467\u001b[0m \u001b[39m    logs: Dict. Aggregated metric results up until this batch.\u001b[39;00m\n\u001b[0;32m    468\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m    469\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_should_call_train_batch_hooks:\n\u001b[1;32m--> 470\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_call_batch_hook(ModeKeys\u001b[39m.\u001b[39;49mTRAIN, \u001b[39m\"\u001b[39;49m\u001b[39mend\u001b[39;49m\u001b[39m\"\u001b[39;49m, batch, logs\u001b[39m=\u001b[39;49mlogs)\n",
      "File \u001b[1;32mc:\\Users\\Amit Yadav\\miniconda3\\lib\\site-packages\\keras\\callbacks.py:317\u001b[0m, in \u001b[0;36mCallbackList._call_batch_hook\u001b[1;34m(self, mode, hook, batch, logs)\u001b[0m\n\u001b[0;32m    315\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_call_batch_begin_hook(mode, batch, logs)\n\u001b[0;32m    316\u001b[0m \u001b[39melif\u001b[39;00m hook \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mend\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[1;32m--> 317\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_call_batch_end_hook(mode, batch, logs)\n\u001b[0;32m    318\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m    319\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[0;32m    320\u001b[0m         \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mUnrecognized hook: \u001b[39m\u001b[39m{\u001b[39;00mhook\u001b[39m}\u001b[39;00m\u001b[39m. \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m    321\u001b[0m         \u001b[39m'\u001b[39m\u001b[39mExpected values are [\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mbegin\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m, \u001b[39m\u001b[39m\"\u001b[39m\u001b[39mend\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m]\u001b[39m\u001b[39m'\u001b[39m\n\u001b[0;32m    322\u001b[0m     )\n",
      "File \u001b[1;32mc:\\Users\\Amit Yadav\\miniconda3\\lib\\site-packages\\keras\\callbacks.py:340\u001b[0m, in \u001b[0;36mCallbackList._call_batch_end_hook\u001b[1;34m(self, mode, batch, logs)\u001b[0m\n\u001b[0;32m    337\u001b[0m     batch_time \u001b[39m=\u001b[39m time\u001b[39m.\u001b[39mtime() \u001b[39m-\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_batch_start_time\n\u001b[0;32m    338\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_batch_times\u001b[39m.\u001b[39mappend(batch_time)\n\u001b[1;32m--> 340\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_call_batch_hook_helper(hook_name, batch, logs)\n\u001b[0;32m    342\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mlen\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_batch_times) \u001b[39m>\u001b[39m\u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_num_batches_for_timing_check:\n\u001b[0;32m    343\u001b[0m     end_hook_name \u001b[39m=\u001b[39m hook_name\n",
      "File \u001b[1;32mc:\\Users\\Amit Yadav\\miniconda3\\lib\\site-packages\\keras\\callbacks.py:388\u001b[0m, in \u001b[0;36mCallbackList._call_batch_hook_helper\u001b[1;34m(self, hook_name, batch, logs)\u001b[0m\n\u001b[0;32m    386\u001b[0m \u001b[39mfor\u001b[39;00m callback \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcallbacks:\n\u001b[0;32m    387\u001b[0m     hook \u001b[39m=\u001b[39m \u001b[39mgetattr\u001b[39m(callback, hook_name)\n\u001b[1;32m--> 388\u001b[0m     hook(batch, logs)\n\u001b[0;32m    390\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_check_timing:\n\u001b[0;32m    391\u001b[0m     \u001b[39mif\u001b[39;00m hook_name \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_hook_times:\n",
      "File \u001b[1;32mc:\\Users\\Amit Yadav\\miniconda3\\lib\\site-packages\\keras\\callbacks.py:1081\u001b[0m, in \u001b[0;36mProgbarLogger.on_train_batch_end\u001b[1;34m(self, batch, logs)\u001b[0m\n\u001b[0;32m   1080\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mon_train_batch_end\u001b[39m(\u001b[39mself\u001b[39m, batch, logs\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[1;32m-> 1081\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_batch_update_progbar(batch, logs)\n",
      "File \u001b[1;32mc:\\Users\\Amit Yadav\\miniconda3\\lib\\site-packages\\keras\\callbacks.py:1157\u001b[0m, in \u001b[0;36mProgbarLogger._batch_update_progbar\u001b[1;34m(self, batch, logs)\u001b[0m\n\u001b[0;32m   1153\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mseen \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m add_seen\n\u001b[0;32m   1155\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mverbose \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m:\n\u001b[0;32m   1156\u001b[0m     \u001b[39m# Only block async when verbose = 1.\u001b[39;00m\n\u001b[1;32m-> 1157\u001b[0m     logs \u001b[39m=\u001b[39m tf_utils\u001b[39m.\u001b[39;49msync_to_numpy_or_python_type(logs)\n\u001b[0;32m   1158\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprogbar\u001b[39m.\u001b[39mupdate(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mseen, \u001b[39mlist\u001b[39m(logs\u001b[39m.\u001b[39mitems()), finalize\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n",
      "File \u001b[1;32mc:\\Users\\Amit Yadav\\miniconda3\\lib\\site-packages\\keras\\utils\\tf_utils.py:635\u001b[0m, in \u001b[0;36msync_to_numpy_or_python_type\u001b[1;34m(tensors)\u001b[0m\n\u001b[0;32m    632\u001b[0m         \u001b[39mreturn\u001b[39;00m t\n\u001b[0;32m    633\u001b[0m     \u001b[39mreturn\u001b[39;00m t\u001b[39m.\u001b[39mitem() \u001b[39mif\u001b[39;00m np\u001b[39m.\u001b[39mndim(t) \u001b[39m==\u001b[39m \u001b[39m0\u001b[39m \u001b[39melse\u001b[39;00m t\n\u001b[1;32m--> 635\u001b[0m \u001b[39mreturn\u001b[39;00m tf\u001b[39m.\u001b[39;49mnest\u001b[39m.\u001b[39;49mmap_structure(_to_single_numpy_or_python_type, tensors)\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python310\\site-packages\\tensorflow\\python\\util\\nest.py:917\u001b[0m, in \u001b[0;36mmap_structure\u001b[1;34m(func, *structure, **kwargs)\u001b[0m\n\u001b[0;32m    913\u001b[0m flat_structure \u001b[39m=\u001b[39m (flatten(s, expand_composites) \u001b[39mfor\u001b[39;00m s \u001b[39min\u001b[39;00m structure)\n\u001b[0;32m    914\u001b[0m entries \u001b[39m=\u001b[39m \u001b[39mzip\u001b[39m(\u001b[39m*\u001b[39mflat_structure)\n\u001b[0;32m    916\u001b[0m \u001b[39mreturn\u001b[39;00m pack_sequence_as(\n\u001b[1;32m--> 917\u001b[0m     structure[\u001b[39m0\u001b[39m], [func(\u001b[39m*\u001b[39mx) \u001b[39mfor\u001b[39;00m x \u001b[39min\u001b[39;00m entries],\n\u001b[0;32m    918\u001b[0m     expand_composites\u001b[39m=\u001b[39mexpand_composites)\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python310\\site-packages\\tensorflow\\python\\util\\nest.py:917\u001b[0m, in \u001b[0;36m<listcomp>\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m    913\u001b[0m flat_structure \u001b[39m=\u001b[39m (flatten(s, expand_composites) \u001b[39mfor\u001b[39;00m s \u001b[39min\u001b[39;00m structure)\n\u001b[0;32m    914\u001b[0m entries \u001b[39m=\u001b[39m \u001b[39mzip\u001b[39m(\u001b[39m*\u001b[39mflat_structure)\n\u001b[0;32m    916\u001b[0m \u001b[39mreturn\u001b[39;00m pack_sequence_as(\n\u001b[1;32m--> 917\u001b[0m     structure[\u001b[39m0\u001b[39m], [func(\u001b[39m*\u001b[39;49mx) \u001b[39mfor\u001b[39;00m x \u001b[39min\u001b[39;00m entries],\n\u001b[0;32m    918\u001b[0m     expand_composites\u001b[39m=\u001b[39mexpand_composites)\n",
      "File \u001b[1;32mc:\\Users\\Amit Yadav\\miniconda3\\lib\\site-packages\\keras\\utils\\tf_utils.py:628\u001b[0m, in \u001b[0;36msync_to_numpy_or_python_type.<locals>._to_single_numpy_or_python_type\u001b[1;34m(t)\u001b[0m\n\u001b[0;32m    625\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_to_single_numpy_or_python_type\u001b[39m(t):\n\u001b[0;32m    626\u001b[0m     \u001b[39m# Don't turn ragged or sparse tensors to NumPy.\u001b[39;00m\n\u001b[0;32m    627\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(t, tf\u001b[39m.\u001b[39mTensor):\n\u001b[1;32m--> 628\u001b[0m         t \u001b[39m=\u001b[39m t\u001b[39m.\u001b[39;49mnumpy()\n\u001b[0;32m    629\u001b[0m     \u001b[39m# Strings, ragged and sparse tensors don't have .item(). Return them\u001b[39;00m\n\u001b[0;32m    630\u001b[0m     \u001b[39m# as-is.\u001b[39;00m\n\u001b[0;32m    631\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39misinstance\u001b[39m(t, (np\u001b[39m.\u001b[39mndarray, np\u001b[39m.\u001b[39mgeneric)):\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python310\\site-packages\\tensorflow\\python\\framework\\ops.py:1157\u001b[0m, in \u001b[0;36m_EagerTensorBase.numpy\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m   1134\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Copy of the contents of this Tensor into a NumPy array or scalar.\u001b[39;00m\n\u001b[0;32m   1135\u001b[0m \n\u001b[0;32m   1136\u001b[0m \u001b[39mUnlike NumPy arrays, Tensors are immutable, so this method has to copy\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   1154\u001b[0m \u001b[39m    NumPy dtype.\u001b[39;00m\n\u001b[0;32m   1155\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m   1156\u001b[0m \u001b[39m# TODO(slebedev): Consider avoiding a copy for non-CPU or remote tensors.\u001b[39;00m\n\u001b[1;32m-> 1157\u001b[0m maybe_arr \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_numpy()  \u001b[39m# pylint: disable=protected-access\u001b[39;00m\n\u001b[0;32m   1158\u001b[0m \u001b[39mreturn\u001b[39;00m maybe_arr\u001b[39m.\u001b[39mcopy() \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(maybe_arr, np\u001b[39m.\u001b[39mndarray) \u001b[39melse\u001b[39;00m maybe_arr\n",
      "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python310\\site-packages\\tensorflow\\python\\framework\\ops.py:1123\u001b[0m, in \u001b[0;36m_EagerTensorBase._numpy\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m   1121\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_numpy\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[0;32m   1122\u001b[0m   \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m-> 1123\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_numpy_internal()\n\u001b[0;32m   1124\u001b[0m   \u001b[39mexcept\u001b[39;00m core\u001b[39m.\u001b[39m_NotOkStatusException \u001b[39mas\u001b[39;00m e:  \u001b[39m# pylint: disable=protected-access\u001b[39;00m\n\u001b[0;32m   1125\u001b[0m     \u001b[39mraise\u001b[39;00m core\u001b[39m.\u001b[39m_status_to_exception(e) \u001b[39mfrom\u001b[39;00m \u001b[39mNone\u001b[39m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Recommend 2000 epochs\n",
    "hist = fashgan.fit(X_train,batch_size=128, epochs=20, callbacks=[ModelMonitor()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Review Performance\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.suptitle('Loss')\n",
    "plt.plot(hist.history['d_loss'], label='d_loss')\n",
    "plt.plot(hist.history['g_loss'], label='g_loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Testing the model \n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "axes don't match array",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32md:\\generative\\hello.ipynb Cell 34\u001b[0m line \u001b[0;36m1\n\u001b[1;32m----> <a href='vscode-notebook-cell:/d%3A/generative/hello.ipynb#X50sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m generator\u001b[39m.\u001b[39;49mload_weights(\u001b[39m'\u001b[39;49m\u001b[39m./generatormodel.h5\u001b[39;49m\u001b[39m'\u001b[39;49m)\n",
      "File \u001b[1;32mc:\\Users\\Amit Yadav\\miniconda3\\lib\\site-packages\\keras\\utils\\traceback_utils.py:70\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m     67\u001b[0m     filtered_tb \u001b[39m=\u001b[39m _process_traceback_frames(e\u001b[39m.\u001b[39m__traceback__)\n\u001b[0;32m     68\u001b[0m     \u001b[39m# To get the full stack trace, call:\u001b[39;00m\n\u001b[0;32m     69\u001b[0m     \u001b[39m# `tf.debugging.disable_traceback_filtering()`\u001b[39;00m\n\u001b[1;32m---> 70\u001b[0m     \u001b[39mraise\u001b[39;00m e\u001b[39m.\u001b[39mwith_traceback(filtered_tb) \u001b[39mfrom\u001b[39;00m \u001b[39mNone\u001b[39m\n\u001b[0;32m     71\u001b[0m \u001b[39mfinally\u001b[39;00m:\n\u001b[0;32m     72\u001b[0m     \u001b[39mdel\u001b[39;00m filtered_tb\n",
      "File \u001b[1;32m<__array_function__ internals>:180\u001b[0m, in \u001b[0;36mtranspose\u001b[1;34m(*args, **kwargs)\u001b[0m\n",
      "File \u001b[1;32mc:\\Users\\Amit Yadav\\miniconda3\\lib\\site-packages\\numpy\\core\\fromnumeric.py:660\u001b[0m, in \u001b[0;36mtranspose\u001b[1;34m(a, axes)\u001b[0m\n\u001b[0;32m    601\u001b[0m \u001b[39m@array_function_dispatch\u001b[39m(_transpose_dispatcher)\n\u001b[0;32m    602\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mtranspose\u001b[39m(a, axes\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[0;32m    603\u001b[0m \u001b[39m    \u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m    604\u001b[0m \u001b[39m    Reverse or permute the axes of an array; returns the modified array.\u001b[39;00m\n\u001b[0;32m    605\u001b[0m \n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    658\u001b[0m \n\u001b[0;32m    659\u001b[0m \u001b[39m    \"\"\"\u001b[39;00m\n\u001b[1;32m--> 660\u001b[0m     \u001b[39mreturn\u001b[39;00m _wrapfunc(a, \u001b[39m'\u001b[39;49m\u001b[39mtranspose\u001b[39;49m\u001b[39m'\u001b[39;49m, axes)\n",
      "File \u001b[1;32mc:\\Users\\Amit Yadav\\miniconda3\\lib\\site-packages\\numpy\\core\\fromnumeric.py:57\u001b[0m, in \u001b[0;36m_wrapfunc\u001b[1;34m(obj, method, *args, **kwds)\u001b[0m\n\u001b[0;32m     54\u001b[0m     \u001b[39mreturn\u001b[39;00m _wrapit(obj, method, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwds)\n\u001b[0;32m     56\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m---> 57\u001b[0m     \u001b[39mreturn\u001b[39;00m bound(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwds)\n\u001b[0;32m     58\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mTypeError\u001b[39;00m:\n\u001b[0;32m     59\u001b[0m     \u001b[39m# A TypeError occurs if the object does have such a method in its\u001b[39;00m\n\u001b[0;32m     60\u001b[0m     \u001b[39m# class, but its signature is not identical to that of NumPy's. This\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m     64\u001b[0m     \u001b[39m# Call _wrapit from within the except clause to ensure a potential\u001b[39;00m\n\u001b[0;32m     65\u001b[0m     \u001b[39m# exception has a traceback chain.\u001b[39;00m\n\u001b[0;32m     66\u001b[0m     \u001b[39mreturn\u001b[39;00m _wrapit(obj, method, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwds)\n",
      "\u001b[1;31mValueError\u001b[0m: axes don't match array"
     ]
    }
   ],
   "source": [
    "generator.load_weights(os.path.join('', 'generatormodel.h5'))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 66ms/step\n"
     ]
    }
   ],
   "source": [
    "imgs = generator.predict(tf.random.normal((16, 128, 1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(ncols=4, nrows=4, figsize=(10,10))\n",
    "for r in range(4): \n",
    "    for c in range(4): \n",
    "        ax[r][c].imshow(imgs[(r+1)*(c+1)-1])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}