ContextualGAN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function, division\n",
    "\n",
    "from keras_contrib.layers.normalization.instancenormalization import InstanceNormalization\n",
    "from keras.layers import Input, Dense, Reshape, Flatten, Dropout, Concatenate, BatchNormalization, Activation, ZeroPadding2D\n",
    "from keras.layers.advanced_activations import LeakyReLU\n",
    "from keras.layers.convolutional import UpSampling2D, Conv2D\n",
    "from keras.models import Sequential, Model\n",
    "from keras.optimizers import Adam\n",
    "\n",
    "from keras.preprocessing.image import img_to_array\n",
    "from keras.preprocessing.image import load_img\n",
    "\n",
    "from sklearn.utils import shuffle\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import datetime\n",
    "import natsort\n",
    "import scipy\n",
    "import sys\n",
    "import os\n",
    "import cv2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helper Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_filename(path):\n",
    "    dirFiles = os.listdir(path)\n",
    "    for i, file in enumerate(dirFiles):\n",
    "        dirFiles[i] = path + file\n",
    "    return natsort.natsorted(dirFiles ,reverse=False)\n",
    "\n",
    "# load all images in a directory into memory\n",
    "def load_images(list_path, size=(256, 256)):\n",
    "    img_list = list()\n",
    "    # enumerate filenames in directory, assume all are images\n",
    "    for filename in list_path:\n",
    "        # load and resize the image\n",
    "        pixels = load_img(filename, target_size=size)\n",
    "        # convert to numpy array\n",
    "        pixels = img_to_array(pixels)\n",
    "        pixels = (pixels - 127.5) / 127.5\n",
    "        img_list.append(pixels)\n",
    "    return np.asarray(img_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# select a batch of random samples, returns images and target\n",
    "def generate_real_samples(dataset, n_samples, patch_shape):\n",
    "    # unpack dataset\n",
    "    trainA, trainB = dataset\n",
    "\n",
    "    # choose random instances\n",
    "    ix = np.random.randint(0, trainA.shape[0], n_samples)\n",
    "    \n",
    "    # retrieve selected images\n",
    "    X1, X2 = trainA[ix], trainB[ix]\n",
    "    \n",
    "    # generate 'real' class labels (1)\n",
    "    y = np.ones((n_samples, patch_shape, patch_shape, 1))\n",
    "    \n",
    "    return [X1, X2], y\n",
    "\n",
    "# generate a batch of images, returns images and targets\n",
    "def generate_fake_samples(g_model, samples, patch_shape):\n",
    "    # generate fake instance\n",
    "    X = g_model.predict(samples)\n",
    "    \n",
    "    # create 'fake' class labels (0)\n",
    "    y = np.zeros((len(X), patch_shape, patch_shape, 1))\n",
    "    \n",
    "    return X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate samples and save as a plot and save the model\n",
    "def summarize_performance(step, g_model, d_model, dataset, target_dir='', n_samples=3):\n",
    "    if target_dir and not os.path.exists(target_dir):\n",
    "        os.mkdir(target_dir)\n",
    "    # select a sample of input images\n",
    "    [X_realA, X_realB], _ = generate_real_samples(dataset, n_samples, 1)\n",
    "    # generate a batch of fake samples\n",
    "    X_fakeB, _ = generate_fake_samples(g_model, X_realA, 1)\n",
    "    # scale all pixels from [-1,1] to [0,1]\n",
    "    X_realA = (X_realA + 1) / 2.0\n",
    "    X_realB = (X_realB + 1) / 2.0\n",
    "    X_fakeB = (X_fakeB + 1) / 2.0\n",
    "    # plot real source images\n",
    "    for i in range(n_samples):\n",
    "        plt.subplot(3, n_samples, 1 + i)\n",
    "        plt.axis('off')\n",
    "        plt.imshow(X_realA[i])\n",
    "    # plot generated target image\n",
    "    for i in range(n_samples):\n",
    "        plt.subplot(3, n_samples, 1 + n_samples + i)\n",
    "        plt.axis('off')\n",
    "        plt.imshow(X_fakeB[i])\n",
    "    # plot real target image\n",
    "    for i in range(n_samples):\n",
    "        plt.subplot(3, n_samples, 1 + n_samples*2 + i)\n",
    "        plt.axis('off')\n",
    "        plt.imshow(X_realB[i])\n",
    "    # save plot to file\n",
    "    filename1 = 'plot_%06d.png' % (step+1)\n",
    "    plt.savefig(target_dir + filename1)\n",
    "    plt.close()\n",
    "    # save the generator model\n",
    "    g_model.save(target_dir + 'g_model.h5')\n",
    "    \n",
    "    # save the discriminator model\n",
    "    d_model.save(target_dir + 'd_model.h5')\n",
    "    \n",
    "    print('>Saved: %s and %s' % (filename1, 'g_model & d_model'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generator(img_shape):\n",
    "    def conv2d(layer_in, n_filter, norm=True):\n",
    "        d = Conv2D(n_filter, kernel_size=4, strides=2, padding='same')(layer_in)\n",
    "        d = LeakyReLU(0.2)(d)\n",
    "        if norm:\n",
    "            d = InstanceNormalization()(d)\n",
    "        return d\n",
    "    \n",
    "    def deconv2d(layer_in, skip_in, n_filter, dropout=0.5):\n",
    "        d = UpSampling2D(size=2)(layer_in)\n",
    "        d = Conv2D(n_filter, kernel_size=4, strides=1, padding='same', activation='relu')(d)\n",
    "        if dropout:\n",
    "            d = Dropout(dropout)(d)\n",
    "        d = InstanceNormalization()(d)\n",
    "        d = Concatenate()([d, skip_in])\n",
    "        return d\n",
    "    \n",
    "    # Input Layer\n",
    "    in_img = Input(shape=img_shape)\n",
    "    \n",
    "    # Downsampling\n",
    "    d1 = conv2d(in_img, 64, norm=False)\n",
    "    d2 = conv2d(d1, 128)\n",
    "    d3 = conv2d(d2, 256)\n",
    "    d4 = conv2d(d3, 512)\n",
    "    d5 = conv2d(d4, 512)\n",
    "    d6 = conv2d(d5, 512)\n",
    "    d7 = conv2d(d6, 512)\n",
    "    \n",
    "    # Upsampling\n",
    "    u1 = deconv2d(d7, d6, 512)\n",
    "    u2 = deconv2d(u1, d5, 512)\n",
    "    u3 = deconv2d(u2, d4, 512)\n",
    "    u4 = deconv2d(u3, d3, 256, dropout=0)\n",
    "    u5 = deconv2d(u4, d2, 128, dropout=0)\n",
    "    u6 = deconv2d(u5, d1, 64, dropout=0)\n",
    "    u7 = UpSampling2D(size=2)(u6)\n",
    "    \n",
    "    out_img = Conv2D(3, kernel_size=4, strides=1, padding='same', activation='tanh')(u7)\n",
    "    \n",
    "    return Model(in_img, out_img, name='generator')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Discriminator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def discriminator(img_shape):\n",
    "    def d_layer(layer_in, n_filter, norm=True):\n",
    "        d = Conv2D(n_filter, kernel_size=4, strides=2, padding='same')(layer_in)\n",
    "        d = LeakyReLU(0.2)(d)\n",
    "        if norm:\n",
    "            d = InstanceNormalization()(d)\n",
    "        return d\n",
    "    \n",
    "    in_src_img = Input(shape=img_shape)\n",
    "    in_target_img = Input(shape=img_shape)\n",
    "    \n",
    "    merged = Concatenate()([in_src_img, in_target_img])\n",
    "    \n",
    "    d1 = d_layer(merged, 64, norm=False)\n",
    "    d2 = d_layer(d1, 128)\n",
    "    d3 = d_layer(d1, 256)\n",
    "    d4 = d_layer(d1, 512)\n",
    "\n",
    "    out = Conv2D(1, kernel_size=4, strides=1, padding='same')(d4)\n",
    "    \n",
    "    return Model([in_src_img, in_target_img], out, name='discriminator')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GAN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def GAN(g_model, d_model, img_shape):\n",
    "    d_model.trainable = False\n",
    "    in_img = Input(shape=img_shape)\n",
    "    gen_out = g_model(in_img)\n",
    "    dis_out = d_model([in_img, gen_out])\n",
    "    model = Model(in_img, [dis_out, gen_out], name='GAN')\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train GAN model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(d_model, g_model, gan_model, data, target_dir, n_epochs=100, n_batch=16):\n",
    "    # determine the output square shape of the discriminator\n",
    "    n_patch = d_model.output_shape[1]\n",
    "    \n",
    "    blue_photo = data[0]\n",
    "    blue_sketch = data[1]\n",
    "    \n",
    "    for i in range(n_epochs):\n",
    "        print(' ========== Epoch', i+1, '========== ')\n",
    "        \n",
    "        blue_photo, blue_sketch = shuffle(blue_photo, blue_sketch)\n",
    "\n",
    "        for j in range(int(len(blue_photo)/n_batch)):\n",
    "            \n",
    "            start = int(j*n_batch)\n",
    "            end = int(min(len(blue_photo), (j*n_batch)+n_batch))\n",
    "            \n",
    "            dataset = [load_images(blue_photo[start:end]), load_images(blue_sketch[start:end])]\n",
    "\n",
    "            # select a batch of real samples\n",
    "            [X_realA, X_realB], y_real = generate_real_samples(dataset, n_batch, n_patch)\n",
    "            \n",
    "            # generate a batch of fake samples\n",
    "            X_fakeB, y_fake = generate_fake_samples(g_model, X_realA, n_patch)\n",
    "            \n",
    "            # update discriminator for real samples\n",
    "            d_loss1 = d_model.train_on_batch([X_realA, X_realB], y_real)\n",
    "            \n",
    "            # update discriminator for generated samples\n",
    "            d_loss2 = d_model.train_on_batch([X_realA, X_fakeB], y_fake)\n",
    "            \n",
    "            d_loss = 0.5 * np.add(d_loss1, d_loss2)\n",
    "            \n",
    "            # update the generator\n",
    "            g_loss, _, _ = gan_model.train_on_batch(X_realA, [y_real, X_realB])\n",
    "            \n",
    "            # summarize performance\n",
    "            print('Batch : %d, D Loss : %.3f | G Loss : %.3f' % (j+1, d_loss, g_loss))\n",
    "        \n",
    "        # summarize model performance\n",
    "#         if (i+1) % 10 == 0:\n",
    "        summarize_performance(i, g_model, d_model, dataset, target_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loss Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import keras.backend as K\n",
    "from keras.losses import mean_absolute_error\n",
    "\n",
    "def pixel_loss(y_true, y_pred):\n",
    "    return K.mean(K.abs(y_true - y_pred))\n",
    "\n",
    "def contextual_loss (y_true, y_pred):\n",
    "    a = tf.image.rgb_to_grayscale(tf.slice(\n",
    "                                y_pred, \n",
    "                                [0,0,0,0], \n",
    "                                [16, 256, 256, 3]))\n",
    "    \n",
    "    b = tf.image.rgb_to_grayscale(tf.slice(\n",
    "                                y_true, \n",
    "                                [0,0,0,0], \n",
    "                                [16, 256, 256, 3]))\n",
    "    \n",
    "    y_pred = tf.divide(tf.add(tf.reshape(a, [tf.shape(a)[0], -1]), 1), 2)\n",
    "    y_true = tf.divide(tf.add(tf.reshape(b, [tf.shape(b)[0], -1]), 1), 2)\n",
    "    \n",
    "#     tf.assert_rank(y_true,2)\n",
    "#     tf.assert_rank(y_pred,2)\n",
    "    \n",
    "    p_shape = tf.shape(y_true)\n",
    "    q_shape = tf.shape(y_pred)\n",
    "#     tf.assert_equal(p_shape, q_shape)\n",
    "    \n",
    "    # normalize sum to 1\n",
    "    p_ = tf.divide(y_true, tf.tile(tf.expand_dims(tf.reduce_sum(y_true, axis=1), 1), [1,p_shape[1]]))\n",
    "    q_ = tf.divide(y_pred, tf.tile(tf.expand_dims(tf.reduce_sum(y_pred, axis=1), 1), [1,p_shape[1]]))\n",
    "    \n",
    "    return tf.reduce_sum(tf.multiply(p_, tf.log(tf.divide(p_, q_))), axis=1)\n",
    "\n",
    "def total_loss (y_true, y_pred):\n",
    "\n",
    "    px_loss = pixel_loss(y_true, y_pred)\n",
    "\n",
    "    ctx_loss = contextual_loss(y_true, y_pred)\n",
    "    \n",
    "    return (0.2 * px_loss) + (0.8 * ctx_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dataset path\n",
    "b_photo_path = 'Dataset/Augmented photo/'\n",
    "b_sketch_path = 'Dataset/Augmented sketch/'\n",
    "\n",
    "blue_photo = load_filename(b_photo_path)\n",
    "blue_sketch = load_filename(b_sketch_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x204a34c4320>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANYAAAD8CAYAAAAL1Fp+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOy9SY9t2XXn91u7OefceyPiNZlM9mSRIilRKqqXqgqC4XIBAsqeFDywYRvwtCb23II/gT9DDQx4ZgOGhzI8cAO7VLAsVZVV7EpkkpnJ7F4fLyJuc87ZzfJg7XMjXnakJL7yY+FtIJHvRty45559Vvtf/7W2qCov18v1cv18l/v/+wu8XC/Xv43rpWK9XC/Xc1gvFevlermew3qpWC/Xy/Uc1kvFerleruewXirWy/VyPYf13BRLRP6hiPyliLwuIn/0vK7zcr1cL+KS51HHEhEP/AD4Q+Ad4M+A/1RVv/dzv9jL9XK9gOt5eazfB15X1R+r6gz898A/ek7Xerlerhduhef0uZ8H3r7x+h3g73zcmzd3X9U7n//S8/kmH3TIAnLjxYf9tSIIqIIIoBydensNIGr/Wv7vxP5Ga6WWQi0FLYVaMmk6MO53lJJRVQTFC3jv8E7wIlStaK1ou74CpV1YuL6ufWdFValqF1dAVe07I4gTlrsUAXEOJ2JfH0DtM27cGE5oP4Oqeryatte0a4IiuvxOceIQu0jbHwERnI+IOPphRdcPhK7DhQDOU529ty573e5Olv3V6we3fGdd7ujGA/vQoxV55m+X5/1RL/RDf/2Bt/4M693v/MtHqvqpj/rd81Ksj/qOz9yJiPxj4B8D3P7cF/kv/qc/eS5fxN9UoyYRThQVqDgWp+3UBKWURPCeUgree0QExYSn1kpOE9F5HILWilRBFJwKl/ce8OThPcan5+wunvCT13/AG//6XzFMF9xJe2qe6L3ndB1ZRcfZZmDdefa7p8zTgXkeKaWY0iAQB7y07wc45xAcqRYudlvGcSY1Za2qOBF86FitNogIIThijHgviMgzD0VLUww1gVx3kVISWaHUSjJrQVEhlUwphVJTu9dKzpnd5RUkxfuIeo+6SHWe6gLd6jbQc3rnFc5e+QyvfekrfO4rX+PVL32Zky98mbkL0EVQB96Ri+JjwDuAindN4dT2w/4TIg5VJbdnqNi9qSpenCn9ovlUrlMde4bO2X4WrR+SFfmwrn3i+q+/sX7r4373vBTrHeCLN15/AXjv5htU9Z8A/wTgC9/67b9Woqeqzcp99M9NmASwTVzeqzTL1oTWlMy8he8iDqFoPlqCUpIJbym4ohzmkTIndM5oMW/lK7zx3b9gf/6Qp/ff5dG7P+Hq8T3C4QKmLZtOObm14dbZCV0Q0jRCnrg6zJSaSVXJ6iiqeO8JMRBjJIi7FhrvyLlSUsWhOMdR0HBCcB4XIl4gBE/sPM5JE06IIdp91Iprrts5ud4XNY/hnCNggusqOO9IogTtcApQCd4jq0LooZTCVCpznlBxKI4pg3OBi2nL/vIp54/e4ydv/IBXPv8Ffucf/CGrVz9Dd3YbHztCHJhRDmmCEKiaKO7aEIo6nAs4VSpKddww00ff2jzgtZcDd/TuizOtH+Gpnsd6Xor1Z8DXReQrwLvAfwL8Zz/vi3yUUh0Vqlknj6DNGx0VTh16/NNq4dwNEGfKid53iAhlTuRpIs+JgHD/nXd5dO999k8vSLstF4/P2T55yOHiKU/f+yFrX1iHTCwjr7jKeuOIt4TT9ZqcM9PhPlMpiHgy5jGCj9RsnrHvIn3fE7pIiIu3EkII5JzZpi2uzKxiYBUDeIfg8UGIoQegpGTKo5XoPKrmbaOohZoh2N54j9MlzXZ0IeIciHeUUpibN3Q+kuq15yilUFOmP/XoNKGqDLWi4igCqaq5xJLZ754ybR+wfyA8Es+9753w5nf+GaevfZHPfOUbfOaLX+Erv/Ib3Pn053CxY06J2AeKzlhYq6BCyRXnHFWap5HmcVvYrqgpokBVe/5VMIME0DxUPXq/RQnlI+Xob7qei2KpahaR/xL4XwAP/Leq+t3nca2ba9mgm5u1bOKN72YbXRXXwo0qHMOJUgqUimohzYlpHJmmiTolymHire9/n+2TxxwuztmfP+Hy0X2uHj+iph13+sLKVc56z631mnWAGATnYbfboVoJHrxzqAh1Mq+YDwlUWcXIer0mek+hkEvGgkAll0rOMxGH7ztc8M2zRbyzkC+GHqUwjxO1gDjFuwhSKaWQU0WCO3o/EW8eLFdKXUIjORoaqW2vtKAlocXytc4Hqji8BFQ8NRfmnFp4pabQ0eNiIDqlZGVMif18oOxnrt4vXJ0/4dF77/DeZ7/MvN3x9b/9W5x9+WuEzjPNGVDUK6IOmrIjcvSqghmcm6E+1bystDxUFFQcorWlny0vvSEvy3P/eSvX8/JYqOofA3/8vD7f1iIM7hmluvEduJnaHX+nGGDQ/t4dk3FQdVRV6lwpUyYfEmm743C55fLhQ+7/6HXGiycczh8yXz0m73eEwyXRFVYCa+84Wa/ZrD29N+EupeC8px8Gcq7M84yqEKJnHif6GJtFLdRphzaPEvvO4lRVSskISh896jz1MOK8IwTLK0Qt/8t5RnNBVchzYtYR1WI5UlEkeKKLuHYNu28h5dKEzPLKUjNazUukeSKlBEXBO7yPLYcLOOeZZW4hZmnZtVArKIkQAjEKm82Gk5zJKNtpJo2JKR149+IxV48f8s6Pf8wf/kf/OetXXqXvArELqAgFqArqhKTVwldtoXxDNISKawqjIqg0b4RDqx7DQf2ALCygjyyyssjQzyFafG6K9W9ifdDSfFip+NBmth9yM3UVboQIRdFSOOwOpO2B/e6Kp48ec37/feanl1y+8xbj1WMOFw8J5cDgKoQD0SmbruOVuwN3bp0irpDTgYAj50zXDcQYca6aIKfEPM/kWvAI3hmo4qh450zpMLSQUtGccc5QtFoyWhN5LuQm9JYDKtM4Hu+/NsXw3lNrBfE455icKZV4e+1coLZt8t7jvFlx+1tBxd5fi+1RquYBY2jCKViu5D0ueFJKTOPeQgEHoua1vTqcwrpXcLCfDqSSubr/Jt95/IhPfeZz/Mpv/i53P/d54nqFhkh1Ct6jQai5eTC5zptVTYGgHJXlGU9ULfe6qS0f551+np7rF1qxPi7HWjboQyFgy7tUzIsIYkiXCKij1kqaM5oK03ZPHUd0nNmdn7N7/IiLt99ifvo+48VDfNoxhEwd95ysAiKFu7fOODtdoyRqKeCE3WEiqGe1XqOqHOY9+92B3XhgnmcA+pMeHzzBQfAGlxcHtVa0JPKcyDmjWnB4xEOeR+Y5k+u1iagVpC4QvYEqTpyVA5wj+NhQR8uX0mz/DyEgPtANPb55sRgjMZr3GpwBJKVpkTrPPM/MU6ZWKFrQasqiatfqug7NhZKyRQa1EkKglApZcVJYR2FOM/s5UfYH/vn//se8+Zff43f/4O/z9W/9Fv50g48dbhXYTTN4d/QsIh6tmbpA9D5QDUnC0MDlmTtaJeRjZeZ5rF9oxbq5PsggWV7fVLBaDX5VJxQMnlYRaimkeSbnTJoy5ELvhJQzj959m/ff+DFP3nmD+fF7yHxJz4jIROeVGD3rVcD7jtgJtWZKUbRa4q+5gIvkXMilsNsdeHJxaV5s6Bm6ntB3Jg+iZKrVu1Im5wmqlQBqKdRaKWWk1gxOEK14aShiCIactexjCXNU7b4LSi0m9Djbk5wtREwpgfNMaSb6gMg1qtp1HX3fG6ASTFzEB7quY465GYdq37cW6lzIteDaZ7hgpQnnrsN13/K44ATfBzpzylw8eIv90ydcPXnE++/8hC9841f41N/6KievfZq46QFH0WLg04JailBEqSXj/bUGPROx/BtWKvgFUqyPCvNuEkc+PiwUROrxPVWgtFwg12RQ8WEkpYJTcM4johyuHvP4vfd4540f8vjdt5guHtCXK6IfqX2lSiVGWHU93RAYhg5xwcKyUqFmEyg83kfSXNiPB7b7kcM4mweJPT50IIGi1ZC3XKjFUD2PRxtoUUsBahN4xXlH1w32OSGY0DevO465pTpCbVbbKcyarVDsgu2hd4DlS4dxxhuqQ27XV1X2+z0AXdch3v4uho7VasVqtcGLMnSBPkZUhFwL28OeNE6EEKyG1pBHC8kWxLbDe8FpofNCCJEwVcay4+KdH/AvLs95/V9/l6//5u/yy7/3d7j79a+SFaI3I6SqFIFCQZ3Dx85yWb02KEhFpB6vv8T/VtD+6ERqKeBfr78eOemFV6yPAiU+6j03FesmtF5qPdZDlt+Bo5TEfrvDUdFS6RQ6H/AVkMJu9xSevstZfkrVK7Q/oHXH0IH3a+bZUWpi6NctvHQc9hWtmeAEV0E0E0IgxcrFbstut0Oc5/anXjmGpSKOw35Ca7Z8oIEGoNQ8QrVC9Wowz+FFyTkRhx5xroWLZrFzzqRUyEVa6KjmxVoo57HCqJaEAqGFbBI8w9ARQmc5lnPUBtGDIY62efa58zyz3+54eO++hZaiBB8JXcS5AChDH3HOUQrkBTgRj4owl4xTh6sOL4pIRese5oned0QJ1H1i++Zj/u+3vs+f/M//I1/77d/jN3737/K5r36D1dltwnpNdpCCJ4tQSjZvXBWngogD9VafVIUCN1wXEj5shI+RDdey9NcFMl5Yxfo4hfpgyPfT3ueOtCRL5mut5BYeebWwxPlAUCGKFYPHq0v2Tx6i+wvq5SNWTPSDx/cnDLFSc+HqqjDPYgm7BHJRcio48VSFnGdKTnhfGGJH1mrFZxeumQIYiLG/2uI89MGE0RSm0A2DKalzBG9MCgvyggn9Ukpo7AnvPeCIXTwyOPS6YEdVJTSvbbmKg5ZvLu/P2bd9Cy1fsX0zON8Ur+97bt+6xW6z4fz8CbkWSq5Mh9EYI4CLgdVqdQ1ve4eqHJ8DOFQtcvBewBnIIxXwlfkwgetYr89QhR/+6f/F/PgJX/nV9/jyN/82X/jqLxE2A1krIZi3pCpUbQVlQDy11CP8vsjJB2Xmw7LzV5HUj14vhmLpNeR9E7kDrqFQrl8vq35CyHxEhqphssdcoxTKXADwRalpplaDs6dcGK8urEb16B7T+WPctGVVD/Qug4NNN3AoByQb6yGoR3FQCjnXJiRCqlbwVaAUxamj852FMNmurwIxOEJ05lU94KzO5MWz6TtcE2zUUC/xjhAsp6pNSLXoUTGkGYeSzYPVYvddsVysougRxHEGZasY9ckZTasg+ODpuo5clf3uQJozwc8NRXSsup7T9Zr1ZsOUZna7A/v9nnk2+tM0JqYxQTMMSyEb54jdgHcLhayg1epNzvdIEDweNyjjNJG2j3DdirXruff6d3h07zFPHjxh3G351Je/RHfnDoQeRPASLNyrYvLkBK8OlXqE0nVRLIMTPyQzx9xsydH/SoJ8vV4MxfoZ1zMKdrQ8i/Vr7lulWagGVDQQARxUi/c9aoJ3OFCnkTrPzPsrDhcXHC6fMl+dc3j3R7A7p9MZLTMljfZsVh0LNr2EHjnP4Bw1FxzhaKWdj8Q+HEPTRbGX71qpuKpW7BWO0HgXIl0f6ZxQc7KaVujoewvJSs2klEg5X4eCzRurCuM4khr7Ygk5HaA12965BuMrZhTUIeqp2W7NQsHMNDV+XoPQsxp8L1VJ40jXdbg+AsJ6PdD3/TFUfHT+hMPhgDTQQt1S23LE2FmtbiHgKtSqVBxePbmYEQkL4FFnvIOUlfEpvP4Xie2TB3z9N36Dr/z6r3M2bCje40JoaVQ1CL6xLQTfhKa2CMaKyLUpn7RcdJErM8R/M7f1YiiWyBFKXWLaY2z7TAHvA+wKrY3ysnDCHVVcs9DgvDKnkSEOeCJzSuQpAZBS4urRQ9LVJfPlE/bnj9g9fcTV4/fxdWKTR1ZS0LKn5BFqRgSurnYWGvWdwfPJ2BGaC8ELaKEW+06xi0QfSHMxVkCpDb2zhDhrxSPkUvAxEpwnxsgQOwy8q4RuaFSdaqhbU840paMylYYYHpF3p/jokGr7KC3063xA3eKt2vbaH1g+pOCdecMFpnbO2Bnrobs2CLUyTRPnTx/j+w5p9bHgo4WMmxW7scOHymEc27PzqFZyEUrbh4XN7pzDqbFRShWcizjviblQa0Yc5OmS0K9ZCdRD4cEPn7J/+D7z06f85u27cHKC9kp1ZghyTYjaPYXevrtTh28lLZUKzjoIFI5UKXfclGse6SJvz8jnT0EYXwzFOrYkfPwyJOfZG6pCu3Nrw6iiaCsIllKoWs2qqhh/LiuuOtK04+rRA3YP75MvL7i49zYXD95h2j4hkum9ElyilkQ+7CnzZJZOhO3WmAwiSgyBGCDNCe98Ax0ahy04pM7kKVOyMQb6IVqOV4qFXgiHw4Gh69is10aidY4gFhrmeW4W27xiLsZw8N5YFSmZkfDeFDJ6TwVi8pRq3swAEftewzDY9RviVxtFWZzdm1Bxi+cUf7Te4liaVXDeHWtc3numlCzHasqdUkKpnKwHcrZcZ5omcqmUWhDA+46U5iMEb4VsSKmCOoZuZZGHWr3KN8MiOpEBcibKmun8Hj/+l3/O2Ze/zFd/47dwQRAXcW0f5znjQ09KCRe8hYsNIVzYKqJQxUjKFkU8iwN+nFz+NHl9IRRrKeZZW0RD9RZLsdCNFgvbkm8RMSb18QaVUguqmaog3iwfWhkPCU0Flz2xJC4e3udw/z3O33yd6fwJh6cP0WnHqVM673A1kac9lELKM2maKDWxWa1BE1qTJYW1EL2H0GootbQHOuNdh5ZMyUqaM7du38HFwJRmlHJkzEfnWQ0WRjnkCCTUWim5NitZyHkmpQnvjOMnDtZDf1SqJSytKMEpOTdBaZ+3hFYZPSpNRagFcJZj5VqPpFwHx2JxrUqplVITZAM2nHOsViv61cp4iNmUapwnq205MwBdFxqBuHLYT0wpMU8HFHdkhlh7lj/KQ24hrqgRa6Vz4Cw/q6qUPNPFjjxuOX/vLb79J/8nc574yre+xeruq2hWXN/Tx45JC+IFlUq7VYII1PYIq+WlTm6S35y9qIq665+azP1sSOELoVjSFOW6BnEDOr/JsXyWb9liZ4dQKTpRSkuWfUAIRrDeVXQ3IfPMk/v3ePf17/Pwje9w8f7bxHnHSQgMZYQ8ImRSnkj5QK7Xibp9ycpuvODWSeDkZMXQe4KHLjhS8pSUuf/gkrOzW+z3hZL3+FVEJCCnPblMPH3ymJIVnEfF0a/WnG5OjrnJftoxTVMjCLsjF89CxI7QDQaV13ydY2pBkyLB0fc9MUZKdc3aw818IRchFSWVQioFcYbyqZhSem81N8tNDYqPMRplyXsLm1SZ0kxKib5fsR9nvK/ATCmFLlj4q1LJZQYNzGVGamE9DKz6nu1+Ih3BpEROdj9OOqsjumDGRytaC9O+4nzGqVo7iXPM4wWdRJzO3P/2P+P+j77Nn5zd5fNf/Qa//vt/jy9+7Rv0t+/g1wNVPNUHKoK6SqnQqXnhgJjhENClT09pXMQb8Pxfsbj8QijWsj7IRP+kZYhfg9KlwayNwmN8uorOIFNlvLji8p4Ve9//4XfZvf9DemZO+oibL6nziKPgvQIJCYKTYJa4JsChNROl4H1H3zlOTjpWvaeLDooJdM0jm81A74WL7Q4nGR8MSt5udwSB2AUOU6IbVjiUNM2tqDsyTnsTzq6j63qC7yg1MeXS6EzaQhih84EYvKGKrRAbWjfv0PWYQl1TexaGRUGpWdFaWkhrVjjPqTErjBOY0sx+v0da0XfhFVqtyhpEc4V1a4fpuo71es04jhwOB3KeGfr1NWVsTOQWlobg8DiyVnKGYiAptTbycJ6P9TeTC6FqY4gE6HwHGNJXUiI4IHmmxzNvbLcwjuTdni/92q/SfeHzeBeZVShixkbFFNQv8lONRFDd4rWaInkj9N6Uz/bbnyqfL4xiLdXyj2OpL7WXozsGFKO3oEZeldZ96oqj5kodC/Vix/7hYx6//RaP3/wB5+++jt+f4zslVUXSTHQWF8wp45x9rvOOUqWxExyo4LtI30e7TsnEENisIn3nGbqePL1iOYFTUtpSi3KyWXFy+w7wiFyUuUH9VSGNE6NmXLCOZXGO4QaFaLezrmJUCU7oGszuxdMHj3PW3u8acZaGNOZquUqpFooeywzFqE2lKLkYz1Ax0roW80rBW4iakoV3uUm9NhqUj6GFkY4Qu2OXdRej5bMtvwEY9wcWHmYIHV6VLBmcJ5VMaAmNKBQ1Q1C1UqviXD22xoizFhVZEFAt5mmo5oHyDsZKDCu0Ft7/wfdJuz3bi6f85n/w7wMQuhU4h2J9WouHEl2Y75bT6SJ7H7DvC0lb+OQyz7JeGMVa1sc1nt38kTTL49U1anptsO41rO0LOBzvvfs2b373L7j/5vcZn75PzDv6WAiaCSJIsNkUpWSqZvDeSNntgkGCtUkET/AV5826T26GEghuYOgifRQ+++lXScnY6rUkahFe+/RrdOtTzs8veXx+we7qgAvRGihVW7t7h3PuyMcrpbDdbtntDtSa2azXnJ5s7PdOcCi+IaLWa6TMuVLVSgtBgNYqknNGczqyMHIxdkYqxWpcbVZFjKujZ6sVU6qcyaUwprkVi0EnIefKlGa8C5YbOkdYAJQYLWwsBtXP2UoDpnw9sfOkabQ63MLdVDUCcaNrSSufLKCLc8ZZrGJ9YyUZ+VYprd9M0bwnouQ6oVm5eA++O+75xm//Fne++EWKBgiR3MYUFPGtvWQpaV/XrZZ64M31V4mm4AVUrJvk2Q/+/Kh07SG7wJEhLo3JUEpFU0Fm0Llw760f8+DtH3L58B18OmfwE31NBGmNjiJUDEEU56hOjizs2Ph3Thx9N5CmLVeXO7oO+rgCHCklDofCuC/cvX0Hf7YhxsjhsAMCJ5uBKpXLiyekaUYczPOI0h1D+FxmKMZdFBEKBoKs1yuC941mZI+qFqVqJXQWKuUGFpSabghqsUpeQwWXes7QeaITBI+rtYVArcakQs7KNE1Hb1VKAbH9MMJraLWsQhd7Uqlst9uWm/kjZ3F5dgtlq+8Gci1MSy7lAqUhnMv7JVVcF1oB3ZKcUjL2FYx1EkIw4rH3DX10FKDkhFCMmykR8hX784mqhe/903/Kt/7eH3Drc19GVhtcDOQg7DSx6gfKNONwOFp7jgBOm3ENR6T3o2Txk9YLp1gfXB9lJZafpTyzWJpaK+K9QdNzws9KPUw8eucNnt5/h3o452SV6epM7wUvFR/s/VXFak+tqzjnzKpftbAu4tSR8qHVbxJ9t8K5jnEuFilq4O5tAyFWqw3eRbbbO2h1nJ5tuLjcEVxlvepwk/EHpyUkJBhg4YTOdVbg1Gt2hIghhQsZNjYED4yOlXJinpMRdZtidV3AicMHj3fSlKscB+Ssem8gRjKWhKuCYp3AhiKmVnRe0ElwwdN1jhjMK4nzLVzdGdNimpim6WjorCxgBF8fQ8sDHeqEeb83Y9ZQwRCCGYJcjuiwGYjrgvo4mpcLzgrS4j2iFtapOARlTge8Twxxg1Mlb5/y1ne+jRTll3+n8NovfY1aI84PlK5nnmeCC1ALqHVq21yNlpdqaj+/jqQWdfqFU6yboeBNpfJYiwfQYJvaqCpL8djCjzxn6jTjq7C/eMK0e0QZz5GyxVXoOugqOPEWRjklxAit07fmAs7Rh4ioI8aAx7MtEw7PNGbGkLmKI6KVIZziVx2oQcqqymY98Nqrr5CrEjzUMnN2umJOSh8iqcBlOZCopJxwFKoaP9DHgPcmiPN0oDQrH8Ss+SQNGu9jy28AF/DxyC8gdp7OO2JwxOChWHdxTYbcGaVKiB6i91bg9QNdCEQvTClQUyG1+tRhnqg1k+cJH4vxHVtn8Wa9AiCvhubtUgshLZQ0kEPJ2QxfCAEfAl6sLFEL11xHWv9YbI2WxeEw8CQlI/ImZ2yS4DtiNEOUixGTndhQoCrJgJ488uTNH6EH61j+1ZI4++Ln8HIHHzxZFeMMe6yCteT3zkoqJoTPKNQioz9tvVCK1RpOgRsh4Y061tLEV1tPdlBL+jOK9460PxByYSWO9374fe796C/ZvvNdwvSQk07pUKIEujZmywqbZs3N5gmr9dpyhJrpY4e4yjiPpDwa364/IatnPATyXNhuL6j1Pq/ePeGbv/wlfJhZrXtu3T1DRJinzCv5lPT5T5Or4/LyiovLPWebWxzGRCrK093YCq3WuuGwPGKeCmmcyDnjG7vBibVo1DkQfcBHT9d4fsa+yECiCIZqoSiFznnu3trYvtY2FOboEYTDNBGjsHKenIVcBa0WAhZWVBQnNuuiVEPqfIjG9nAO7Ty6MoZDroXL7UQuC1CizPPMYd4C0K8Mxl8NGysGY0VkLXtSyeTJwkScGZjoO1LKrbhuIaIXJaTS6mkDtbW05FLY7fdogS5MDD5x/u4VTx68wbf/7H/ji7/6a/za7/9dPvM7f8CwOmE+TFRnZQYrjkubCWL3ruVZGf04DOCD64VSLPjkivZR2ZzVvJwaE1xLJh0mRNXGk11ccPXwAU/vvYNOF5x1jlWnnJ6srDHQWRHSWtYzU4O8vffH+Nk7wQWxUVw6QxS6bmDeT9Qq7A9WT3KSCE6JMfLevftM8y1OVgP9EFmtevph4NVwF62Vwziz7gdu3ZrZ70amVBmnxPnVpXkX6ZhyYpwSc6rE/vTIlnDH+YetoIqiVKSCFkOzfGMTdCESgzPkUBSh0AebZbjso3H6cmNegOtjQw4dNQDS2j5UbFBMKRS1tpOs9gxiF/CxM9i7wfm1VqQofQvvaGPlQgh0dMewcRxH+r5HV7Qw0TMMA4zjNYrZ8pvQvLSqdT37RgzIeTbCrWj7DJuVYYqYUK2kekByxrtM2o689d2/oJTC5rNfoX/l07iTU0QF/DVPsJaGQkvjHN5YP2s964VVLMezN7BMnAWrmIuCqzZFFrzVPoqS9yNP3n2fx+++w/m7b7PxcNZHuiBEWuhkfbrHECQ0QmiM0eb1KfjOk5htQm2nBHXMh9rmQ6i1xc8TTipDL+SkPHzwmJQmbt864ezsxGhPLdN6er8AACAASURBVB9a9z21Vlb9wCYXzgHZT8zzyKrzxK6nqOAnmFBicLg2gs1YE2aRa8rGOXQe74y8K1qgKOIgeOh9Ayq80YFaBkWaD8eicwyO4HtrrS+FiKNWQ/xqrUfiataKF8dUkyXyqlaAF/AoTiD2EYjkGs1gpUJVT8jKOBUkLZC9hdtZlXnKNv0q2x51nbFPRDw+huNMkFRs+I7znT17EcQ5U7qWCqRxokoyAnPXEUKEYN5rrjNSEzFlfBgYLzJvff/bnP7Zn/LZb/war375K4TTUyR41HUs9DoD4D/c5HiTL/hJ64VTrJtr4ZFZG/qHrUU9IjZKdA6XM+O45/DkAZf332E8f8AtXwnOcXZ6aiGGCFNrAszZunyHYaCPHSF667SdRwMNcrE8zjukQOxci/UNkhYfaTPBeLo9QGN/O1pvVK04PKfrDUjlztkZcynU7YHTsw05Z56kA3dO14TYM+WCF2U99AbJl2hF3VKQVuNxovgI3hW8hyDYmGovRB8IEc5OBmJwQG2K50ELwTlCaKULbX1XLlCwXjLbU/Pmi4L5ClIqBMt/aq2kbFOmBJsS5avgQ6D3EfoVuSpRJvbTTJDMQZJNH56L1Rs1IIO0MMuG96RxYog9fT9YoXme2O/3uGliSplakimdb5lki9FCcKTRvNM82wyO2HPtgbzRurQmpkOi607RwyU//Od/SlGl73tuuS9QEfwgqHe41r6zEG8/iFT/LND7C6FYCs9wsFRtLkWbiPKh3Eva7HEJli/McyLUgh526NUFl+/+hPH+uwxlYtgEQh+Y64zWhKZKqdmmys6J4I0/52rFEdskWtvAGAJzSqQW84sa0mYPsBwbCxVhnhOHKMRDZRjg6fmBw9XI7nLkdLNi2AzHwS/OK7VMxACbVccQTUm7lBk6h/iIuMCjh1eU0eDsGGwWBd5mRQQvRAddDAyxI8Q2gNNB3wnBW4ew99KqE94gZQy48d6DD0fOmLjuyPmb55lpMqCD6ric9sToUO9ISa32hSPVjKYRLZnsHd51+NgRJXKyGuhiZOcM5GnmhjRjU4SLAT0eD6qkPDOFmb4KYT3QxYDbREI348c92+3Wuqu1TZgSjzRGv+8iNWVElFRm5jEdOZR96FHR42gDygEZE7v3f8Q73xbONgNeKyevfYZ45w4SOyTY2Lmi2kZ8L4JJY++6D9W5PrheCMX64PoQg739/wYf0pLvalYr+gCHkXm35eFbb/DgJ28w787pSITo0IABHFzXIHLOFvodyb2FlGCaDnRdx0k8YcwzqcHHxmTvKbMiG2H2NqXIrKLHAVe7nfH6/IH9dscQI2enNgDURUcIFe+MGT4MkWkauXW2Js1WvE3ZkLhclHFODFGJ667tCQTv2nRfpYue6Lx1FjtrsPTeGBpBMsF7oz1Fe49RgPSIMC4DOxGPw0MIqC650sA4juRptklOm6GhiUrvAwv/8Oowo9i8Q0PWPFIyuWZShZwtBD07WbHWnmlK7PZ7Sp1BLGKwQhUEHygps88GdhBbC81gOWWabK59KgtMH46sDqQSWhuPqinRku+txFpgvIfovOXXZUbGC7YP3uaNv/hzcs58tiQbpnpyigRHdkLsu6MB+OiZKx+/XkjFurluumO94dGWZflGZBoP7M7Pee/tN3j6+D4lzaw3DvWWcKdcrC1dC9K6V7sQKOmabLsgZEs7e5kKdbaHFkNP1w2MyR5wLhYmdl2H946abeaCj11DwbKxrJ1jmg+46Lh9+3abK6h4UVZ95HSzYp4KUypMUyJkzzwnZs2sBk8NtPqTsGokW9FKoLWLBPNU0UtrHXH00eGD0IVooZo4lHoMnT2uddJ6K/zicaFnae+v1VC6eZw4HCaCtzrSNE0mvGLE1S4KRWe0CloNmXQNuO6c55BGm3chrfPZwdB7znTgaqzMKEkLWqwlv4q3+tZYoHhKiYTeKF4nJyeklNjuD8cOgIVOlXPrvpZr9kathZwNjRSRRo53BNcBQhcDOu05f+8tKjZtq+sDq1I4OT1p+WxCaYSE63DKwI6fsl4IxRKepeI/ozg33yc3OjuLkSd99fhame4/5K1/8efc/+6/ojtccvf2is1GED82qk6GamFHroUYArvdrnkBD1UILjJsTMD22wOHcWqNhwNUGMcZwXHr7DbujhypOrVmDodKnoSL7chVG/8VxHHv0TnrDmJLyO/ePqPrAt4pJyvrHaLBx6vQU1FS8pwOC7u8Bxpo0JoUnYNV34qvbqkBcRSgoTEggrumBmmxsKneYFw45xFvQVoRd1QyMzodbDqcnrKfjGg7jnv248GAm5w57KcjujjNI7nMlHywZsVuza21Zy7KlBOHaeSwG5lywvuesxipnXnjnGyy1KHlSDibK1Jr5jAfUFWGzsZvr1cb5nm2k1ZSIjc0d+kCXozDkp9XzaCQ272nbO8PdYe4LXl8ypOrB/zp2z9g9doXeO2Xvsnv/cP/kJM7d3HDQO2iwaY3ugTcT4sDeUEU6+OWoTO2FmKkLH0ygFahilBy4sl77/Do7Z+Q9ltWFFDj6vWudSCHSM1KrlanmNMEGNRrpNNk3kCsiJlSesaT5VwtwW0bHLtghF211oc5jcfiZxptvp4X631abTZGgG2TZH2rldihBLBZ3caJ5Wu1WmG1lMIwrI+wskPo+jbmzLqZ2oNuzehtLgbAprOJS/aLa/5fmQtVKjVYy83NWX8xeNQJoc1zz5mjUvbV4wOIGwjRt3YO2G73htzNhcOYmLIyz6BzbbPcE6iRh0UGO9xhFKY5oepbGO7onCBdRKlMqZA1IxgH0DmPVPM8OWdQQ3E3G1Ow/TgfvdKNtvNrmWlr8dapZIpWhsFKESkd0Gpz8nfO86hbcfXwHqfrDeoDEoJN4+Xa4Ff5BaY0/XQ+lsP30RLynHjvJ29y/vgeddoiMVOqtSTE4CDdiMkbebPkRBcDQVybimvsjjxlKBiZVoxCI62jN/iARxo3LzMMnZ0gMk0G8zYhyMXyiyFGuq4nJWW/Gzk52QAWwq1Xa9Z9hwAnmzOWE0FyLnYYgUF3x7zBOIPLwQ0J5xd0qp2nVcuRJdC70OYjCpRKKXb8z1xtBNlx0E5THBvmmfEu2NQp5+nCtWh4v9T9hBitf0tE6FcD05TIqXKYE4f9zP6QYTeRDkZu1VqQInROcF1HcILUPQUhp2pTdFUJzjP0BtCM2UJ2LTajwjuHZigpA4ITIcTAMAxIm+6bUrIWnRvDw5eZKGagLb+tNM+VJoJUas4Una3lZtwzPb7P5b33uHv7FU66wZpnuUYIqyx9br8AqODPsowxwJG6L2KhmNeKz4nd04dIOhB9JfiCc4qLQtZMTokh2jwMvKO00crWQ9UAkNaFuwjbNE3HGXt2Ik2lUNgMK8tlukAIrvUOOXKZj1NoQ+zxrseJI9fCYZxwd9ZEF6i5EJxB8CE4bt+6xbpfH8EBlvYEaRNws16z9jUb7Sf2rdeikjVTUyZrPSqkGYOG9rU6lXPGh1sG1ojTpsiz/a3YeFGRclRm7yMhBM76E+acGXJtbA0l5UIchC7bKSbhMFNlx5QPIJl5HpuXX1p9LHeVoqz73ihPZHJVUrE8OGghSWUIjrla+4jmRBWb3CSN7FtKZZ4OdP2KTetgPow7FiVavj9wLPrXqq0bwLYu52we2nuCCKXM1P0VxQfuvfFDNqsNq80aP0SoHnHW2r9Mefpp8MULq1i1WYWbLK1jjNsG+VOLKdWTc64ePmC8esJZyARvkLZ4Z8ihs/qE4jhMI7UUVqsV0lrOgWO7w9I6EcSjiLEy2s8KwslqjaoNo/G+O7Z5pOoZVhtqKUjoDVCZJup8IM3V4NuiBBeP04fWqxVD7Fph1BL/JXRTLVSNSF3GVheDmpvXRbT1MWWKz8aMxxjZIuG4X7WA+Ir4gnjjv4nYuVNBAlHD8Z5rE2aqUXukHXsTvPWh9b2NSysKczYmyawTh3HPbi5MCaZsHnspPJdiQ0iXsNM7x9BZITk5a3cJTo1POBeGYI0crjrSXEg1teGhCR+DsU3EkIqU7GyuzckKH4RpOjTScj6291vB90a4DKg6CBFQstoZWh4hp5Hx4jEP33ydk/Upr3z6U3zq7l3m1ssWYmdUMfE/9QC7F1axPmo9gxDWTABqzlw8esDTh/dw80Tfe7oAhQRqDA7XlCa34m5sytCHeGPuQpsW6z1jo9XUZtlKGzDpo6Fy86yUnFoCbeyJ0HdtCEswqpUIIVeS2OkfS6H32GdUr/OARakd0nLIfARFjkLfZmQsYVyty2d5ig9UDUePJHI9bvpaYa4nRMmNnEG1HjmGFo7qkdGt4tAqlGVUGA7noyFlZWY3HdiOhcvdzNV2z247sd2NTHM+Xsuu0REWkEWs70y1kEo2NDRlDlMia1MiPKEYahiKUNVxmBI1J3CBSkbwqHNmJBvjwrmFrnXdFbDcv8Lx314cru9RscK5cbqrHYtUZ5689xar1YZbd++gseP2575ItxrsRE/xWDf3J4+efuEU64PdmUsocZN5sQAYUjLjxTlv/+X3SNtzTn2m1MSYM+sQ6URwKngXKDlR50QXHFEghI7Ly0tSSty+fduuVSulVMZxolsNpNlONUy5UKWw6QZSLeyn0XKp/cw0TYToidFTs9L3jSSbC1I9edJGDjXBcBiXb7NacbY5oV9t2JzeMqRKHDT42YsdcXqN6C0wvbQwcSkNXJ+0mHWZpeiPP1uUahnYaV3H8fgZ9rnlWGJQFVTspMeKUKpjzoVxTuwOI0+vDlxcXnFxueXR0yuuDiPb/Z7Dbk/JFqb3Q8+nP3PGEOP14QhiR+os9yKi4ISshtSN88S9B+fs9iPjIVMcaIxkhFyUbVBSUfZzIie7Zx87Ko754tyMWhcJwR9nf9ghFxO1TZOysW82vPVqf7gGcDBGyxCLkX7Tlgc//H+595MfcPv/+Rq/8+/8u3z5G99k86nXiJvb1BAW4srHrhdOsT5u2YyL1rzXDmNLNTHNe/bbC2JnhNwsM06rnXroPFIKIQbj2LVQcul0BeHs7BabzUkjbXIk4+acOUwTqeQG4VrfUE7XyXFKhZLaeVYusBwVrqUNSSkztSS8x9gRIbSi52ATjvqeYRjwodWAZBm6YIx0NGCJpVlIVTsaVJyBELVAbUVdVZuwpFXAXzcbHr2Wtvl9HryLLdG3tTDJ7d/NO1WhVJhTZawj6oVCZs7Kfi5sx8T5xZbdYc88ZXIyoTxZrTk5WfP5z3wKJzanwzfATqoVhcfDwXq+hOYNA5tNhKps9weePL4wdLBUy3+cp/qOcZrBRbTtfc6ZisM1Zvs0jZRie+zaoB8af3HlLHy1VhaeOTw8p2zVt5LxwTHEHvKMlsSjN1/nL9cD4/aKz3/jm7zyjW9ZTl3/LQkFb1pfUSEAQ/Bsa2La79qmgI/OhlUu5NVGT1libh/tCJoj2tag9XEcjzlWjJHDbDWaIzIpdiRNrdXaJ3SZ8Wez2+cpE50j+4x4UwaP0vWeQMdq1bNeDQyD/XsYOis893ZiCNIKkWr/icqxII4z3p/TdoxpBRt4omgx9oFfUEAw9vnSmHfsYWshrzQAw10fgAAW9uEEITZlxOhcmqhkUs7sDzNX+wPb3cR2P7HdTeTUZn+s15ysBm7dusXZ6Qmv3tngneKlQG1cx2zKcOjgcIA5JzRlEIg+8uqdE07XHeu+4/LqwOXVlsNUUCqbfkA8MNvEXOeSjVy74c1LK4LnMtvxQ2GZw+GO7TRGFi4GZmgxUm9w5JSYS8Xj8OMO8c5mgMmB+z9+3Yrl40z/6udY3XkVPwyfKK+/EIqlatT2BQ0UrG0k7/fMTy/IlxesY8DrbPw/UWrprAvXB9JsilO00nk7PPtwOBwFa5m7t8wEFGmQejErfJyBIfWo3EvjXReMeXFkybvrjlPnYd233qN1z2az4uTk5OitloeubURAmz1qyKCNx2zdsdcTaZf/pM3o8j7iPUdwQETwDfECrkdaN8BnKaB6b60alphYC70pcGv6q40tBOS0Z7+beXq55/LqwMXVnqvtiKpw+9Zdbp1uOD3dcHpywmYzsOojQ6d0AdCKlok0jSSpNqquF8T1yKjUamcXOwpDH+jiis1qzclqx3roudjuudwfyMGhvkOd2mhuHyhFmVJmN9n8fT0WhRtJtlRWK5sVkueWSjhFciXt9xYCuqVTu+VntVrTZLY8OI0z85zo+p4Hb59y640fc3fOvPLpz3yizP6NFEtE3gSusENSsqr+rojcBf4H4G8BbwL/saqe/7WvoUtHTwPDsCNapBakVqbdlsPVFYGK5IKPsO6GNozRzk9KpaFqcj0sZGFNHNnScPRQ6uTINQvBxjIv/UBVrfZxOBi1po82YnmZk27DXexAOKUQomPosElOq47VcH2IW/DdcZYfAG38F23Onwlc82QIbgmFaUJv3KyjUaDdmwR/vM+lyC5i3Dt1Yt3TPpoiiW9k51agRkjV4PRcIBc4jJnzqz2Pnpzz8PETtts9KVe+9IXPc/f2CbdvnXG63jD0RgsyAnDGiYEiaap2tGtJIGp5bvTgbI/SXFqBuxLE47pAvHXKyXrDZrslPH7C00OyCpWLlJJMLlptL5VCbs2by5CZnK0MEaNFBxIjFKG0Ux+75CmptNn41mKTl2J6s+IetRNo8sh0+ZQn7/2EJ+++Q1XXyLkfv34eHuvfU9VHN17/EfC/qup/IyJ/1F7/V5/4CS38oQ1M/GC/y4IGzloIjdkeVBlix7Q/sJ+uWJFAE1Gt4Y8KeNjPkx3mVgshRKLz1FpskEz7bGviE6YlKfaeXK6HZooYDB7UA5VpnuyBNIDBuYAXYZ4miqtEr6hUvFeG3rPqDGIeYrDJsO2ZLCifeWTX9sFGVZdS8e6aHVHbqfSKARiLQTBhohUul8+SFh4B4m1EmvOID4gTxAdwjoxRdRaGu3OOnGCa22khSTlMmfPLAw8ePuHRkwv2e2OY3Dnb8KXPv8bdV87YDL15Zu/sYG6nVE24aDzJOTqmnIjV2lNSmc1YqprXplCmSpoy3itSM4MPrPuOs5MVd25t+N6P30QOiTIVTjrPvijTPOIk0ntHPCqYsUzADn44HHbUmp85kbLWCr1jVo+q4Xu5gqt2SF9KGR8CZCUEpc4T0/YpoYts779PKcKd01ufKNLPIxT8R8Dfb//+74D/g5+mWB9YKtgBcHAcJw1W7BPsUDctmadPn7LbbU2wakaLnVMrbZJsVQhdJLXEPcZ4rBmVUo6bbXSZeoSHl/cued0S5okI8zibJ7F6IbVam0X0nkQFX/DREaMwdJFVHxg6IXbe0MOmEAtbIITSwIiKJ4CrjQVyHEbVetJ8S8OeLVCqmnU1oNQKzIsCIiDeal/LsE2zYb6xCaweVG+MG0tVjVcnjlwz+93Eg4fnnF/syKlycnLC6XrDyWbFq3fPeOXOGUMfGII/Nj6C4kNHKpkYeg7jTOzWVPUwKV3fMc4jSMJJIHil65Uos6Gp3oFXRAouOG7FFZ/91B2eXG5xlxNjAukEx/9H3rvESJal932/75xzXxGZWVVZj+7q6kfNoznkzNBDSAYNSBsCBrwy7I0leKcFAW4MeCt5ZcArrrzyxlwYsgXINjeytLIkG6CphWlKw8eQIoeaGXZPs7rr/chHRNx7z+Pz4js3Ims000P3eAz2+AKJzIrKyoyKuOec7/t//0dgjpnWYWmY1SW3ZBvMA/vKA9iX3zFOdG3Aq7l8lWo3rc5il1KxmSNk8rSj6wZK2jFevGTllBePHvD82vVPvYd/0oWlwD8Ti0z8b1X1N4A3VPVhfdMfisidH/YPReTXgF8DuP7WO//2MbX8ArWEPirk7hRKzMy7kVKUzbgze+Z5Yu0E37WoNxszsQqKOUVC13J0dARAjImUDvMds1E2xGjpsxYEb/ke7z2xRHZpJGkmo+Zt3ghNY1QgKeba1DqhC46jNrDuWo5XDet+jajYSdBFgs8IiZxGVqXFNaFmXzU2vPQNmkxwKX4BN4BiXLXXXktqc6bmJovL9SzyB4BCfH0NtVp6mY4MnKXZB4g5Q46keWR7GTm/3PHy1SUC3H/3bdZDT9sFvIc2wMlRw9Abaz04QyxLUqYpMs2Os+2Wy13k2atXfPzJE3IsXFxsOHtxztnzl1ASwTlWfeDa8cAbt45pnCPPERfs9UAdTdvy5S+8xThntrvEy1eXPHtxzstXZ1zslL5x7KIhmAlH8pCLkDUwzoUUCy/HM/q+5+TkhL5fMYvQ+lKBLGPzj3MFuJzFQOWUaUNgns7xbUtKwqMHf8aXvv7X2b168KkL4yddWH9TVT+pi+efi8i3/7L/sC7C3wB4++t/7Udil746J6A1RG5p7q/MafZlkXBwbPXmtqpJyKngGl+Hi5CSWXUNw0ARGON8CL6GPcp09cQy2pIROFPJVc1rMvKm7yDZDE3V7v7gjFwawHhwfb9HHSmyHzDu/w9FKNUeTJxleREaW1DLwpJCqanwy7zPAAvLTXbFMn2LtyVjnoiVqWFWwlRtBSA1AME+VBOUghqIt38Nmqbh9ulN+nXPemjwASDhndK3StcKrfekOTHNiZyEmISPnrzgwaPH/PGffofHT56z2c28eftN3n33PsNRw/ZiJu42ZpRaitk+5xlE8EEIDYTW2+kqBSkzXXD011YMfUMXhECm8zuenO9wIrTOM6bMpIoLAVeU2UEjDi2FeZy45IKy6g2UciaoDU7QykCJGaZsJOOlsgnB5qAybXn+6GPe+cKXGE5ufOr9/RMtLFX9pH5+IiL/CPhl4LGI3K2n1V3gyU/yO+rPryyKA63JS6hcMjtRHAdkrIgBHiklVquVmZRcuZaFspRxtnj8vixcvmdhmXddB94ynFJNTxR38Mtbghg0ibn8OEzhG8yCzIvSeIvnWUo5sEO6udJHGeLpq/4HC0+AvYp6Ib8uRNr9/2W/eBQpzkK6F1m2AhgaVmKqr0BFLqlzL4A6A1M1qpRzjtYHUlNYr9d0Q0vbmLQ/5R0lT6yGDi/mlFQQ5iJstjNPX1zwv/zT3+KTx8/YzZndbkLEc+fNFW/cu8/u6CW9c+Rpg/eZrhdWHRwNjq5pWK/X9bW1CNQ5Rc4vLyDbAjvqW7i+pqRIExybcUdTYJRCKdloR2rsjNYJiIk+x2hMeFXl+vUTmxvWyxDdQJMScbO1PchVFbZIjcHNzNstjz/+mHfanxLcLiJrwKnqRf36PwD+K+CfAH8H+PX6+R9/1t+xXEa8tXnNMgj13hOv/D3YybA4skqdCy0ABLB/PMcJ5xyxZFxF/qTqkHwTCCgtUnsgT9cNeGeIWghm8OKaQL9a0XYW+0nJ+GDgRNPYENqcYe05a46INBUFFJyX156rsR9q7q+IWYrVXXQ5iVlOM+esDFW17903XOWwkJb5bwUmihZS3YWd2b2SFli6mH2cZfceZlsiEBpH20DbQBPAuVJFiRDEoZgf/W4svLqY+fa/+T7f/IM/5V/98YeEbqDgyKWtIL6nH1aEMiPzMUE6ulbwIeOZOD7qOF6vWa+O6xghGLMiRZqurZYBES3C0aqDG0cEL1xcXDDGQuuzWXBLYkpKLAUN9jN8aGmaYGOXnKtBTe3bS64vuY0kutTsPSJLtgCJEFpcaJnHiU8+/Ainn750fpIT6w3gH9WdMwD/UFX/VxH5l8BvisivAh8Bf+sn+B2vXUvTbjB52AMOXdehdYgqIsYBxE6E7eWGPEfatmdJHlS1OVW/Xu3txeJsvLLQNq8NVw+q2uqvIKH6ToTXBqyxJFZ7/3Joa1Zw4wUnmZSiScirVbIpVhcGhFJEDZ4m74O1c6XfSOUy4t3+dNsvqOVUqsBFWfJ3KyCxnEr7ZJa68Ixlssx7pA5QqTMt48MpZljTD4GuWzhypsD2rjH5fipkdXzy5CV/+mcf8rvf/GO+++FDUgl41xHnmRQTXfBcv3GCk8LJuuV0fYcgMz4UNO/IqeXkeGC9OqZte7xrcS6gOPpSCK0nxpmSzNZ6miJDnRFutlvOL3cMc6GfM97PXI4zYwS0mLmNV7wLCC3jPLHb7WhazzAMgO7ZKyJC17RQIjHVWWXboSrkWFAS43bH7uL8U+/Vz7ywVPXPgW/8kMefA//+Z/25P+Z32o21DPGcY70+tvJpGdCqIW7DsOb81Zmx2MXvGcyiWMpGtY+Oc67e5DbnytVkUkVwNSUeFxA1t9Wcq1NuN7DqTEKiJTGPU01GLDRNi2vMi4HqCx680jWBxlupZnhPATJNKzZH8mLAhBRzCQrtAkvYKeUrFLlcpZ5Q2ZyONNWpbv3QnGt4t/ENc7Ibp6B7JIxKsHVqWrIlSMHIwdVersxoVkKwYXVWo7ireuYobHczH3zwkD/81rd5+OgFc4a7d+/x9rvv8fTZE54/fsSt60fcPlkzhMKt44E+BBpfSHlkngTVjusn1+i6gbYZDEG8QnQtEpHgKTFx5IR+zuS10vfmwCvygjEm+qQ0XYs/39DsUmXKCJpmuraD4lDv2Uw75l1EijIMhhbmmEglM3QdUgSwWWfMudoumIOv5EScp0+9Vz8XzIvlsh7kQNdpuoF+dcR6veayJgKWAiUbaigi9E3LnONrcu3Ff+6q2A+oJ5MNj7Oawcti+J9zMTOSOlC1PiQg4s2ZlYVCFfChpmaImlS+t5PJB1MBG7JmJwBiMaHqgUYNvAvexgbNoZdytQS0Xgqb3Ko/AA4RclTI2YK6K/vdyucaIVukLugFnFheWSsDlz9LJWQ4D4hS1E4dLQapA2gpTHOi5MDzlxsuL3b0/YrT01Mk7Gg9bM+e4+OOt06P+dIX7vGFeze5Pnj6kM2Xw4GThuCPCMFx7fopXbuyjbKW5rlyHZsy2OC+KG3bE5z9/7quQ8XRDj1Pnj3nYjPtK4Lzyx2qWxJm651Kogk2zBjnGjU0jojUeZoIwVkKSdMa96EqDgAAIABJREFUez7vJuJs6nJyBElojmwvf0on1v9Xl0nya9IehVAbcRUgBNrV2mr5Gj2TnTky5ZxJ08wu7CxDC5t1AOA8w/qIJZMq5sI4zhSsD8taY2WckIsyx4oSit+b8/fXB45Way4uLph2O/oQ6Dpl1bV0nSP4hPOW8xRcoG8b2rAsfuMSijR2kgaHBocGjzQOGoe4gG9bwFE9nY0EmKuQby6kOZFnE0OWUtBk/+9xu0Wz4muIwBLv0zQWUOec9Ub7UrCSfkUUF4RGGoqLMFvgW1t5iE0tL9OcKDlzcnSNZy+3hBB45+17/Nz773N68ybeNzx9+hi0sB46usbZc8gzbYi03lnoQhaCH2h6C61br6/RNB1O6sbjhKKJnCPt2NQeyxDdPFuHnWbrv27fvslms+Ppi+ecnW94+vwlsVzno4+fcrmd2I2FBBR1jDEgcsR2nOm9I8aJXd6Z9bj3aC70bUffe/q+4+zi3E7FHIhsQZScPudcwbxXoNadsj5upAKPCw0qvu5yi3K07vKyGIuYMG1hqgffktPEuNsRujqNh3qiQSrKPEV6MV+LGDMxTgflKeC81Jt4R84JrS5EgmXn+tozWf+TaZquljm9UZlcUxt0DxUwUOes7HTBIPaFjVEM8SMrJdoOPm+qNVkpFi6XEtNo7rGXlzu8BNquI/h5D+50XapD6krEra+paNlTxpyvdnLSIR5ymvFVvnLgVEpFUR03rq1xDlpnVKHjlbfSSq6jOZqJjxo4IK0FkC9VgIizFJPGXHDBLK2tAjQr8CCBxgkldfXrhta3zG4yIKrNXF6eE0Xo+5Y7d+6wWplH/DgnLs43rIaOJ09eIU0L0rKLpl7GO4paRNDiQLWMbnLOqAU0c7xeoTmhCk3jGXNkHrefet/+lV9YUNlOUg3+S53ROCHbsGH/dc7ZZkEqlHSA3+GAHLZtS8nsYdf971CD531TZ1YpvQbFW0xOMkWtsxd+s7kwkaMzlp1FwljqoGuEmpK6n4WZp2Bju7IzHz+tpwBqDAhxBreLOGNglowmIz7mmElzJM+ZzcW2LqREHC3W9PJyazcIgaHt6FYDfdPtiaZQTBdWbdGop5ernh6+dbZowGQkziJF82yeEC4s+WR19haEXgRxA024TtLCahVQnVGZDazxhqQGv5S0wmq12pe2zhli531ji0pKZZEUpPhqnlr2IBFFCb3lMi+9YN/3uHlGc9mjsTkVdtPMq1fnxGT2beNYaFcdt49POfvuxzS5mIK5huAVzVUI6vb5YE1naoQ0t2zHmdYHYrGf92nXX5GFdeAKftq1N/Nw1CR0RzNYn7UgdPthbrFGfp5n1FlPpWK5SobCmYNq03SVoDtVB59DDzcny8313uYjKUULhQt9jaupdltiIQp2ryqu0olc5bA5CSxB5MtHQSoAYBooXlvkmHSkCGRjmqQYiWNi2u2YdjPnLy45Ozvn4uKCzWbHZrNhTgaW3Lp9h641Mq/4htB4fHB4V2k61RVW1HqK4AXfmWmM9zV3RRt8E0hzYBcTwRvEb4EEi1jRYpG8F5rQo+KqbD/R9T1UWU4QA2y894TG2WyoWRxtrex1LlT62jKULzhVNAHoXo/mxeG8sxKjAE4Z+n6vwp5TBB84PT1lO07cvr3l4nJDLoUnz17hvHLzxjVK/KAqHqSal8p+rmXloBG4KTbXGzpDlbel2BhAP2cKYqiMdjk431ogQu0HFhjcO1wbaNcD/fqI4gJJTdCXSuW+oYz1ptAgaJ1fLIkXi8WZNfI225mmieAbirESLYSsFJtrLEaR1cPcYaafS8qgY4G0M5RKwXKLUf8iVbc0Cx+khgtY6bG40u55gMUMI/OciJOhjuNmZHN5yXYz8ujjxzx79oJX55dG7xI4Ojrh+HjFyckJ6/WaYVjTt10l/jq0mOefZrMbEAWCiSkHKpgTXJ3p2L/xXYuWhKSC18W22ow+Y5xQKagk2sFK8mlOtE1HvzKuZetNGmOrpuC0/kqo+c4gziPBEcTMWlxVGKsuYXTgKmvFZB1pb9gZgmeatWrMHLLbEcKhWnnrzVs8fmr0tlgyl5tInHfEZIknuerTQtsA3kxy2gHxgtdSBbCGPjZdz9mzS3zbcDDm++HXX42FtVjn8PqhdVWmL8qeql9QxAlJCtl73HBE8mt2Y6R1isxW2ydNdN2KOSlOI51vaZoKbJRIzDO+hD0hdhpn83mgELORQBfVMhQ0Gw1oHEfa0LDqzYJYsPJPayqg7ezFUkDUoc6k8bmamphxTO0LK+PBHAulJm0XxDvG7USckiXRn2+5PN9wdnbB2dk5H37wgMvLSxDP0XrNyckJ164dc3RyzMmNY9b9mja0dKGr7A+HSiFnMRvrZHxHe76m4i0Eu4FbRSxtAV9aulwo0wjJ+PA+1FFAG0hpxvsOoSGjrDrrkVTr3Eg8aGXJqOUnV7HyMruufpg1shUMeQU7ukN1n8oF740ki/e4EKrMP9M35osfZaLve+Zkw/ggrqZ+3rDwhJzwfuJy84I22FwsqlHHpOZ8NU2Dz+CDJc/Y07D+3DcDoXFMcaLphk+9pf9qLKz/h9cSktAMPb5ruX7zFuo6imtIRPPSSxERJS2IXtOQU2HczWTyIbM3Lz4RtdTMGfUL7cjt5zpG9SkGIOTF0Kaa22BfL9ZizkUMSFncU4tJ7cvBn6KUglclx4Rfmf2Zz86CCkph2m15/uwlF+cbpt3MeLHj1atzXr58xdmrC2JMHF874ejoiJOTE/uoAeCro4EmOPP8INubrMk2Cg8Bk5CYISYWUOfEQJPgcK1HG1NMizokObJz5HFXM6kyjSZC19v3CmgxpE/FEkB821THXY/QUqp1t2rG+2yAkubazxmzprhKW6vvsxZBSoKiOK9o9jQ+oNm0VsVlXBaiVi8Q19owPfh6os2s+64O9234//TZGQ+fn1PyzDReoqEHcaRss8Ncwa/WB7zzhGAViKGuM0ergTZq3ZR+9PW5XFhQK4vG0x2veev+F2i7NU5nJIwmAcfyq1pvQ9bttGHWmUEHG/BtZ+tb1FgVeY7M02SuRDqi4ijVmbZgpQZag9dSMhu1ys5ugzcbsuTMyKU4UvG1GTcHXmKGkvDVd70Rk62H0CC5GKw/Z6a44dXmgsuLLY8/ecS4ndhejLx6ecF2u6Vte46OjvjGL32ZGzeu09XIVMsJK2hJdH7CybgHblJRc45KVqx6YzUjmB2ZD452JYRBkL6HrgVfPwj4o4jrtvjpkjxtSNOOpLHu7C3ePBEIUnmOlZ8nobFZm7SVAQK5RHzjKERUcw3vsBJ/4TwugdpOzVzHTC4SogmyBSmUONviStncmjRTksc1Le0igYkR5wLHx5HL9Tkvzy846gdOr9/g4eMXpHnk6cXW/OPVkTLMORJrTvTJarAwhQpupDhz4+iYKR4yoX/U9bldWAAaoFn1yHrg5PQWlw/PGadI6yzTSudqNV0gJoubE+9oqX1bLuSUDlJuqJ4JCVy1UlatKJ0RYTNaM3GjnWAh0AZDqFLxZEyioaVQsjE5NGiF4cFLRtyiwapASTFWxy4mLseJ87MLzs/Pmbc7thcjl+cbckwcr0+4desWN2+fcu/uHYahwy+nq5ja2JUG4sYaVMnV1MZKQM2CE1M8B+/ALyJISJJREg1qyKTvIPQgnWnEamiC4Uzmbisoxdlp7ooaWKIekcZ0Jd6k/ktiQUqFqCYCDT5gtCt7M5aT3ImzATnYuAFfRw0ZLYaaagVXFoNRUoJSS0p0z+IXr3RtVRXUUYtzl+AcX3jvLS4vR8aU2cwg6gjSmh4tKzElduOIH9p99QKZOI04J6yH5lPvzc/twjKKnNIOPTIMDMcnXD5tydkzp2q1pUrKNQ1DHFozi/EHRsNeUi92/I+53iiVi5cr6XcBOAyZ1H3PlMl1eK2M40wblBaHtsahQ69A/pjR//IhxZlbkWsYx5ntNBPnxDzO7DY7drsd8zjTtj2nN465ceMGp6enHJ0ccXw8EJplTmf5wBRBSkbxpBLJasrpnM2BytMZPYlAKQb/OzFWiDolV1SuUQEJ4Bqgg8bUXU6KWUR7sZypZNlXmHoJ8+gruJTt0Gq6Ss2yYXtwHi2W62ybijnyGhG4loUilEXRLGInnsvWbwvgLCtaXUXzKs1NVVFvdDf7MXXD8Y4gZke9lwE5z/237zJOiTElnrzYsU0OXMtcYDOZ1m9KEdkpq944iW5JfsHXYL8ffX1uFxbUReEaQj9wdHqL55+sKOkSzRtbFDFRGqP+GNOgOvpc0V0t4kYQrs697LPuZ0wqlmaxJFrsJSqLvZgTSzD0hdZZ7lZp/f7nGkSdjV6VZ3xekj7KPpN3GhNjjBahMydQx9HJMcfH17h18w7Xrl2jH1q6ztOtLeHeOWxRiUHzxMQ0B2Iy16GUzPDfI8ZOVzE/dRyihr6FENCuJ4eAJRarUZcWr0Hx4Ad7vt4h3lEmR8lTfZ3KXu0sRUilkOfRVOBe8eqQpvp7BE+GA5vEyIz74HZxQspLovYipalMG6mGptTgNwUwa4TlRFHNqJjEXhTE21ys6wZSShz5IyQ03J4zRd/lfDsRy2PK+UgRG8aP8aAGmLKgMTE48450ZLKWPZvnR12f64XlvWeejFx54827fP/PepIKrWvxNEzlgDzN8wzFXFCzyH5RiSwORt4ML+vpQ4XrDSyyga0uEep1URlp18pCh9AGriw6yCoVXTycjoZIJnyJiLY0ImynkRgjMSZ2my3T1kYBhvTd4MaNmxwfH1uIXHD0Q0Mz1B25lErGdZRcSDFzfj5zOU2kPFKk4BHaxtfXzCQvOIdvGnzX4kOgtMa5Q66SX0uFaY03J5hkXl2i+BkJHZpnRBNm42wlqSU6O0oqiEYUX4WXARpvPZ5yBcxJaK0wDAipjlVItUCoC8zZZrAw+2sV+ZqRzkLRWq5SClmENE+EtgNNtCVzcjygEnj/C+/w6uySOWYmDQQVxtSg0X6G88baGeeZjKfzbp8482nX53ZhyfL6iUDjuHH3Huubt8iXzym7LV4tnGA3zaah8g6thpETS5moqEbwjrY1guuiPtYatRPr7KrpWqbdDFcCz0rJBPy+xFg4hqpyxVZLqvOPBdWVOqDNOSN5ZoozcTa0cpzmPduj6zru3H2To6MjVqsVXd/QtM7AimAG/4t7k/EJYXM5cnGx4zvffcAUJ+Y0gUaaxrFqG96//zark1X1A1FCG1BjwuLa3oSVKuRS0DLjCEjVUznngRY8uNY2i5InqGT8RSBp1mzmLEuOFr5X5sMOV23bKBnISMq4Klmx17DYONg5CB7NNtdz9g12amWbb5WcbYhMtWyQhWFSqxPAhZZCApcozkHx9KuBY+fIMvL2vTd4/Pwl55db0mYG3xEah/i2/gyrVJxU4rIT5hhZrT7nXMFPu6QODgVPf/06b93/ItOLh8R0SdERJFg/IJ6SEznb5H5XG9kiZkpp2cINLhiqlbPFsC5qXmWJsbEM3ZQS2RkNiNorOBcoJdbhZUD1ILrkij7KDFuigQzFGu+YLUonpkSMka5vOF2dcv30BkPXMgwDw6o3WXwQEzSa/oU4F6Yp8vLpK77/wQM+fvCIP/qTD3j3/jscHa1JcaZxmU92Z9w46unawNHJ2ha8K2gpOOcJvrEsqHpDWjJHpOBAZqCtJ48H1yEhg+/RMhtyV8yq2nrbQklmdyBSF0COEAN7Fx7V+u/qZyq3E+qcy44kYQkyKMZpjAmtJOB9VlrK+6pguZZUEBFsU/XBrB3EwgP7tnC8VmIqfPG9t3j56pyz7/yF3UutY05QsKghBYLX+rSNtTLNnwtK02e7Fu/AKMrqzm3uffVrPH34EU+3F8TdBpE1Lo+0zsAL0Yj3UmewphYmVR2yk/2O5EOgZGGK0dA/FywYofIJ45zJrhAaTwgdwTfm6uNMWGhuUEY4pVg21xJInQ0RgTiTESQ5NmPh4nzDnDJd35ip52rF8dCxGjq6zoFL2E4fIGe2u8J3vvchf/itb/Mvfvt3+ODPPyKlwvHRDfqj65y++S6/9Nf/He7cPGbcvOLy5WPWRw0SPAlFmoBvBrRtkLaD0NUTK1JyJEcDJ3CCDzPiekRWgEHr+GM0jnVQD0UnnCqOiKQCMRqQUKwvzbXEKwLiOsy91+wKFikLjSe4gMYZ9QEkGiAhgogZcZITWnupRT9mG6zbS3dYKFc+2PcWcE1P2Is+Iw5D9bw4uvYdQjAG/gefPCPVnlvFs2qtV+/7nq5pqvGocnl+8an35ud6YS3wtwP8MDBcu8Gd9+5z/uwT5u0ZmiNlnnBZ8GqLa04RcFATFXOx0La2moY45wzarTX0UjbFmF6LyNTFC1EXPyRqn+T3Tj8WuO1qkMHycfADVBVyqiyInGm84/h4zWo1GGevRCQLGgNiJEaQzDRnfuf/+mP+5e/9Ed/+sz/nowePSBq42G6IbFgV5cX5S3KZaMIJyReOj3qGPuz9KRyO4gy+9k1XpTgH4xyt1CxNBS2XEBK4Aq4DWnv92hWFCVfttim204mAz0qJav9mOZ3EWPopG6BRXKA4X3VfAnNGQzEyslrvC874nSJ2elVNmsNAhYXeZtqtvDfcNKCJvX5vEckW9YgrUEwOUxoYusLN0xPee/ce33/wiHlX0ApAeXFYZJJVOxpMyhPa+VPvzc/1wlpmTAq4pqW/dsKdd97h4Qe3mC5eMqUJJpOCUNnxMafq574EvL3Ofi+l2EC3qo2td5BKPbKSY0GEZBERVoNMZ523RaRemREZdelqw7vMRSqnrViZ2TQNwUuFzxWniTxlyHWOhmOaM89fbvjn/+y3+c6f/wXqe+bo2E2ZG3fe4uTkiODh9u0boInd5hWdhxQspypn6wvbbkD6AXWLqtFVZK9KWIg2aM8zWjJFo5WiSi1HWyT0SFntwQvJissO0cnmanXnt1LPeJJSqDuiLTYrz7zNsoCSog3nS0VN1VdOY52h1fdMqsxGvPVrOec9n7SolbilgldazYZUrG+uECMqSuuESZTrRyvuv/sWf/Ttf8NfPH9CM1ige5CCK0ZdSzEbl1E8bfcz3GPhjHGgBXwTWB0fcXLrDrffeZfp/AVpe0mWBi2xOmC6fT0PvKa/Wa79oHJJAszLjmc770Jbuup3kWNCKQy1p1oMY7xjHz+kpexpUwfk0GMhcTPrYaAd2moi6ukaj9NCyWVvRxbnzOPnF3zw0WMeffKSaRISBd+uTZW7Oub+l79MHyL33rrF0AklbdmmDWncMgzX7Lk4h9n/B7OaDsHkGqos+TQ1EgCvBS0TWmwWJq1g3KNgC8L3qCaD7hGUaX84iauLytniEbMkxZfGBJqlUKoBjsdOIinmzZ6lgHqcKl4V7w4Wd6V6vWtVX5dKdZeFS1oWj33rr4DDrKtI9WG0Uy84ZT105Kq7evveXb79/VeUIhaXGzxt05nlHYILgRCE8gP3zQ9en+uFtYTGLYb4Ehqa9TG37r7Lq08+YfP8BZlHexmCCOCdRc44j7oDBF5KZXR7RxQbVppWyXQ6KZkX+cEMpiE4Xz02It7Z6WRzw7Jn12sFScpyYqm9ocvi8g4cQtMGVl2Pa/wezi06I2p8xXE3c3Gx5aPvP+LP/uQDvvrVr/PibMuff/Qx+fKczplV84MPv8d/8h/9Cvfv3WTVZiSNxHGLdzUtfjCdlh8Giq+ooA+2w6tQUsJptTKsDHgpueaUeXzpwXVomVHfo74F7XFqFClVV/mHmVxM+gF1Lugqg1+tT6QuAOprreKqXTYgRoE9QOjsQY9SNW9CtUuswsvFCq/sf66z98g5i19yasggAacZaPHOUlD6Xlite956401K/hZzcfR9IOZqBVBBnb5bISKEUvi063O9sPa7EBY743xgff0W1269xcnNuzx78GAv5/BYj1Wyyfu12I64vJMxZkKwgGyTRdQhJFUA57FScD8YvOJJV70E7eY1Rap44xqqF/sIlWCLI+dqxewNQRtWLU3T0QQbKAuVbuVt/jJPiXGX+fDDh/zJn3yHV5cjf+NX/iapOH7u6XPGeeLy8pycI2/cvs7Xv3SHzhfKdI5qpG3UfOuHHt/1uNZ8EgnGrVPnyMVYIs4VvFoPItUeLucCUig5ImVEtK1cyg6RBtesK2MCRD3etZVDVirBdbYMYV08N+zxrFT33MKokeH0mJRmJBjKqs4cpwQ7fep8hYZgjJdapqtg3hiayJr2izXI4lRlIe+pmumoC2SfUWd+JVlNzDp0PXfffAPvBCnmOalNx2ayWKCha+mq7mu3233qvfm5Xlh7gAGtA1yTALRHx6yu3aRbnzC7gBSbbWh9AUtFAkNjAjutZVCubjzOuT1PcG/KwmHnXE456pvtnaOUXC3Eyv652c55CIRe6AlLM23m8uZ+tFfK1psBbPg8xcxuO/LyxTkffvh9Hj58zGp9Qskz169d5/bN+wxDD2r2AX0DR81ISZGkycZ8bWdxNsOKpu1Moh4aQ82qj6GxN6icP3suFOMASmV9K4rmCH6uJexSPhYcnsa39Y1x4BucS2y255SYGAYDZFLOZA6IXk7ZRlo4Budp10eGHPrD0Nct/Zhq3dgU75Ss/t8q7a++vvbcDn30VUhepTHE0Fm2cMwJJwbuuDq8jnky2wcfcMVs1PaVxs9yKbggPSw3rYJrO27cvUsov0SaLvmDD//YGvayO7RZ3pM0kV2BRnBq1tNRTYjHAg2XReF7WFih9Thf0Dyb71/l1syaOVo3+GHA962VHRrREnCUfV+2lJHedcZ1c55VN1wpd5K5d5TC7sxyvT7++CHf+c53efnijC994S3efu893rl7xMnJimEYaKs4scyBeR7ZbgrBNRxdX9O0PaFtLCN5fYT0K6TtTfrrPFkwdW6xElBVkZTMw92GdqRsoXxLKowTY76HvDPEbxrJcbLTJs9ITuyen5mn4JTQXHj+5DGPHj3mwYMHNF3DW3ff4ObNGwyhZRxtiH/05hu4pjGFsDfgQ1SN/jTP9euKTmbjNSrUAHHqLBGgZjdTcOUKc0OkOm5VCX6pigCE1aplTHDvzbuE4Lh48QrfDUy5sIsTjQ9sGk+Ka07WR7Rt+6n35ud6YckV/3OpxFgRh2taVtevc/rmWzTHp8zzzoaItcnGO4OxtXLKfJ2HlUzrm8oqSPtdb0EHy8KwyNliX7zNOgBKTERpbRDpQ/XuW0Kzq6S88gadcwc5uFv8B40vZ9Qfc19NcWK7uWDcbRiGltMv3+eNN+9y7fQm9+7esuQUp2hOxGlk3llARNcYCNKvekLTWl5W10HTGzE2dLWHcYeTutjJQzH0UGPVPOVku77D+HyaURntxHICKVLGydyFS7Y52JyYp4k0mR/hk4dP+OY3v8nv/94f8tHHD/jlX/53Oe5XdC6Qu55SwK8tt9mlXDFyjK6uB7b6nuaRU2W41M1IXSVzGNATszlQiRwSZJZKAg6nl3OC5GpvVxZCthnAun3Fb76CmhNaAlsndMGz6rtPvTc/1wsLlkXlK1cN8+32gh/WXH/jHu3JDXYvn6I6IyXRBhuCGkJUKtLsDtxBrsr1r/LBaoNcb8Ts1ISBdlAyl0LCU5xHfUB8JbqK1L7r4Jwr1SXJBb9PXoSKpImJAc0Rama32yEe3n7vHifXTxnWK/rVEVkic1HyGI1VMk8IyrDq6Pq12QE0DcULCSEjhKUM9MEOHzUltr1wkSqYMqPPZHC7lmIAADZUN4lfQnQ0geRuS54nm/3VHNccI3mO5Ji5ON/wb/7su/zB73+LTz55xOm1U77281/j9MYNA5CS0oRAG5ra01iPZjIbt1/sBo2apm0JJQdek5lfPZl+8B5Z7o9Db2zmOjbbsve673vmXaojEiNN+8VYhoKv90iaIz/u+lwvrP2cyTmymirVAUXMo2+4ccq123fZPH/COO0o2eJmxHkg7lFFM8+seqFoETIlm2TEUiDtjfJXbKX37HaUnAuzKts5MeVDxCkSLcvWuX0ftSwq7/3eh90spQ8ImuIQXxAH3dBye3WLa6c3WJ0cm99g0+KalhQTRRyuaRi6ngaH80LbD7jQmo7M28oX30DTIsE86HO2m83h6qk3V91TQVOkJCvpTGBcyyZZZnuZkibmaUcad9WX3k6AkjJxNlKxFuXJkydcXFzwxS9+kV/8+te5e/cuv/ALX0HjTMlWfvZtR9+0ZjeWEkRDen1xB5pUSUYnqjMqLWY4qkX2Cu+MgA8EBBHrvdTmHUidNR56ZZs/UsWsznm6zuGrfwYcfDPs67B/3w+o44++PtcLCw5zIftcUOfNAMZ5huun3Hn3i2xfPePltCNdFLIksysTT0kJcYpr3H56H/MPSEY4ABHO+coL9EjVBeVk/hhTTGy2I5djZIqF1Jk/Rs4H25GFh6pggAnmWLTMtBwWsyo0FApN13LadwaRr1esj45xXYeKp2gNMVBntl/OmxVhLsjQQuU7lopwqve4roOmAYSUrDwO3uQmoRQkJ3PYTckoSWrJl04a40TW524cxZGzV5eQTAls7kl2k6dkyl6Ksl6v+erXfp7VakVwnq7rGPrW7A9KixdH23c0XUfwRm/SkqyfgiuL6lBBmJ7NKsScjGYGr4eaL5FJ4jkARbxOBNhvmJWBE6NZiLdta+EYXUdSM9AJzuNdoAuNUdPyATT5YdfnfmEtO4hUoxFF67zKM6fM3S+9z3jxgt3FK863G+ZijrFDtyZOZxRRvLceaC9BqBKGxV8wJxuOLt7ukWinhjPe4RQjc1KmWLi43HF+sWPdr+jahqSJKUVccLRtY9m7P4BSLTeCr0ibK9ZSn97pcN7j+5ZmWGByowF511fuq6V/uLoZCAU01Zww22Bc0+LbFmkC6jCD0Ss3mNeCxhkp2aJycrJFBraayl6ei6iQ5sw8TsybnRnpaCaWA0CjyTRmOSbaLtC3odqseYRMShMEeBM7AAAgAElEQVRDa/qsxnlcEwhtILSeJDZsNxZUtR8TJdV4JXQ5MZZ+V0mpnk41AB0WVo7ud7Orj9sHxj3EeIbbaVeJacI4jjRNYxVFNus2zaYoWE6rHH+WT6zFHVfg6lxJBaRtyVl592vf4PTmTdYn1/jet36PFw++x3z2jDJHijOYtewswbFvW+ZFPq5XysQq8wiuqZy+jkIgxsw0R8aYmeaZxjuev7ikD445jpwed9w9XRFLIIsni/VgNkvZ5zDud9klRiY4o/OUtrdZU9egwbRM+JrCEVqLhN038FQr6YLG0V4PJ3jfIE1AXFNblWy+GI03hLQkyhyRnNAUUeviccssiFCZGYJGGMeJ7XbkwUcf8w/+/j/g2ZOn9H3L/fv3+cY3fpF333ubtm3Z7ba2q0uh8x2u83hfezQnlNAak6kLtEOLaxqKFJP71xNIs51cJRfGaWunVIayBFdcKZ0BiqT962ib1qHXcs6i/uJ+YI1JeVQpOeG943I3M8XIdprJyXRipQghdDhnhqklBLLLbHY/w54Xr1+vKzpVM64JbHcbmpNr3Hv/K0zTjovzF+w2l7hkRiikhdd5mH2I/qjdqNT5je18KRfmXAeJamXQuJu42O5ofcZrYdV6rh155oV8ms1uzPaCgvjD79rfFM6BBJyvN7UP1huJgAt1+AyIKaMNUDDfoKJqzpvUHiH4OuMzByqoPdPCDslp71RloeALcdVKTK0EVNRK55KU509f8C9+6//g93/3D1mtGr7+9a/ylS+/z727d+lCwzRP5BIZVgPOObpgbP8FaeuHDl97Fu+9PeeUrFwVZ2V2ttlYqUkpabaSr8y5ajvLIZ96CeKr/et+wZXDDMvr62DUIlpd6GapRviM48h2N1HEkYv116ZilpoGmowJ/7PcYzktlCWVrzrpLgqEkq00GUUI/cC1N9/mjc0lDx884PLZU9BMJ6XSkeqPqB7jThzemSdgpkbZiBld0lQofYHgy+IKK6SkTBPstoELZ+Xl0DfcGjvmqMyJaqd1GHg6V9CmkusWnFlc5dfJniDLgnbVD4F6w+uhdxPqELq+rc7t+XOouckCiBbTMy1+H7XHK2JOuJYbW+rQG3xStEykOVNi4uLFKx4/+IQvvneP+198j2984xu8//6X6PsWxahRx+trFo2T7YSS4GlaA3/6odsDR2GfUilQNy1JhRQP4QvzlJh3iZgTcZpJxShmpZiOrV9ZSHvbtqgaD3JReO/L7fp+mX/JIQJ3cd5dFt04T/az1ZPrHqVgHotgnMEfs6jgc76w7DJYVn/gMVfBCNe2RtLsB45u3ead999n8+wRL//ie6hkQ9fSTNZI01Sj/tpfLW63Gfaeogtsviyqq/ISKhxrpjKe1kcuNyPnm4FxKvRdIQSlDca0/sGfsb/BloW3UKiKs9kN3hA4w71sfiN1vuSsQ1CcZRBfvWHrJSKUmJjnEU2RxnkaT7XebvB4G8aKGKVpYaTESC4mi9lcbCgx8f6Xv8xXvvA+77//JU5vn7LqWzKFrm1Yrzuart07DS/BFs4Fmq6hHQa0xKoCtxkUpTBdXJKj9WfzGCmzLaA8J8YULeo0RsZpxzhNiFOGYSCEG/v/n1HYFu7h4TXNuS4G5cpmqFXYmlGEmBObzQacI8+FrKZydi7ifIMLztDM/z+ggj/schWEiKXgfINqgrZlfeMmb96/z/zyKX968ZJ89pjQVOVvtIDtpV4RtUXlWAxMSq3dK6hRlFjpTt5bbpRztitOY2RX9VjdhXB23jLuIlMXaUIgODGJuwu1JDHYpSyZWmL8R5HqqUc9hSoXT3Nlc+952gfQRo1Wbk67IvsTXGo4eqriTafFSLH7F83V3xENypZc53amak6xEKPNkFbDwBfeu8+N4xOOjlY0XaA1pxr7MaI0waJeRWyGJs7hfGPaL+8RzcRxQ9xVlnssPHv6nBizgSO7mTwZ+pemxCZGtvPE+eYVSWdEhPXREYv1ATOVhxhQV0ceHDYXl5dS/zD41+owBUY9m+eZJ0+e7JHmkgu5RBCbQ5pUxUYsU/wZVhDD4nVgX79mT113FHUC6mlXa4oXVpd3OL13n2t/8YAn5y/Rkmia3kRsxehEqbItFslHcCB6mF8sb4rFa2abUSEMrTdraXGUAjkW5jlyfrFjs4usVpmuK4RQaOorvwgf65+AQ4yp04RkMbNPdZWIkHBSZ3Fu2YVNDoGrUai1tDNs0e2ha+rnII7ga+II1SedmnAiB43Zwm9MWZlLYbsdGaeRpm25duM6x8NA2wbEQdsb4hmLhfw5b6RW82m0EIpQo03LNHPx8iXnL1+wvdjWMg0uXm4AR5wi82ZCZyhJGeeJ5xcXXI4b2iNPs2o4OTnh+vUTjo+P90yJ/VijVgJ7w5l6apd8ha0h1TSogPpgARhZefr8DC2e0LbMmohT3GdYiwiu9q8p/YQnloj8d8B/CDxR1a/Xx06B/xm4D3wI/G1VfVn/7r8AfhUz4/rPVfWf/rjf8dmvOshTLGK0XkvfJbVMyqXuzqGnv/km198aeeOLL/nkg+/ROI+mrdFxSo3WpFjwtzNun2UlGaRtWcZ1l3TgnadrOjxC7wPBKwGl8Y7GBTTDZjPy7Pkruq6jbZeAbxuqdtUijVralWxvuPe+Mg+oVmHJTqJgN7uGiBRXveZtcxG1vxNZ2Pl2emlZSL1zZXyY7/lc43m8ryrddCAQ52KaKB8awiowbkdoA6IdRXcEaemPeobOFqgEj3jolj6ptTBsD/gKxRsmE3j88QPOHj1lvNxQ0iIKbXDaMs+J+VKJW0WnaP71ObHqO05vX+fk5pp2bZQtnFaBaN2cqrGqW163qoIuumQv101DqMaqjiKOMSWSOr770Sd876NPILTkKrSs7gpMuxnXNnS+sermx6ycv8yJ9feB/wb4H6489veA/11Vf11E/l79898Vka8C/ynwNeAt4H8TkZ9T1U+fpn3G62pownLpDzxmCJpWn4cWd3TCm1/5Oic33+DFk4c8+d6fMr56TOuLJWqIgQ5t682hx4lpjUTQZCdZ8MK1o57r0tF6o+ME78mjIUZN09C0FtfZeCWmLR98/6HdNPNNbt444eSkQ1crxEGTKtK4uBPhKBQkFlym1raVwR8VXKSEgEr1TZcr4d++MVdnyt5SDBYs5AcAEHG1dPTgbW6USOQgqDfon7ajH47oC+RUjM6TzAU4pFo2pkiRQqmSjdZ7Qj9AhunikjQmpmkmjhPkwu78nHhpltwJGKNSpg3x4Tn5fERioW97uvURJ+/cYzg9pr+2QjrHTjeMeSQWiy/tVx1N15gui2VmtXy2pBLrWxcPyDqwb2rIIJmUhY8fPeVfffMP+b1v/WtGOcE1K4RM09iAehy3lBg4vnXL5pz8hANiVf1tEbn/Aw//x8Cv1K//e+C3gL9bH/+fVHUCPhCR7wK/DPyfP+73/LSuffOqBdTYE8k7muNrvPeVr5LHLY+2l8zbmcY1iM5LJvcBfq8S8VKLjcZ72sYRvKPzzhaWOIoT+mFN1/WIX8ICIhILZ2c72vYlw9DS9YG2c3RdYs4zXemgCJId0Oyh/z1yVelEdpeYNsksMKz5liqWNOevUkvDKvhbmCR7mg42CDVW7cFGTpXsClnMURaBIp7SeHwwdyWfBWlseCwloqOYc1Iy1kjRRI4zLnjKNLI52/Lk4SPidiaopxFnFKpZCRrYjSOooClx9vgFlx8+5sb6hDu33uD27dusbtygu7ZChpZRJy6nC8a8o3ilaRraNuDcQjlye6QWDu/d8rXsxaNLPJD1YRmrKB598oiPP/6YaUrQL+ruYnFHYHo+CjFNNuwOn750PmuP9YaqPqxP+qGI3KmP3wN+58r3PaiP/VSuq6fToUl//e8WCNooMBmcJzpHtz7h3pe/ynR+wcXLF2weRaZ5wifBE2nbJbdqUfo2iK8wb+Nx6nAlIxiRNzSB9fERJ8fXaYcjssJ2jsRpR0pWzpyd73j69BltIwRXaGvAdRoSJdliCWquTqG4ygZxOF/pN65K/BdrsDq7ESwZnlx7ppSMq7gw1rkCzy9/8tZHVacJM2JRhcbjFgjeO6RpKG1jUtEALjhIQokZ1wZjwztBKnHYextXPH/2nBePX3D24gyS0rmGHDqCFjQqLntWZSBtR8anZ0wPn3H3zpu88+59br35Bke3bkEXQDNjGtlsRzbTlplo9KLXIldlX+6pKmk5qas93cIVpHpu5JyZcybXDerl8xd8/PHHPH36FA9MuVQtZjUXUq1RvcI0TdC0tO1PZ2H9qOuHFGc/gIQv3yjya8CvAVx/653/l59GnVssoEbwuKSknKtnnici3HjzHvfe/wXOXjznUU6cp0jenlWnIbthRSwFo7iElGq+mTJuaFn1LavWs+4bvMAbb9zm+OQ6LnRMSQnbkS3CdtzhJDONiecvL2hah/MmcHTOcXSUq67LLu8VdQGfEnBgEUgljYqAL6BOr8g9qDp1BWeLw1HLPKiqieUFya/t6AA4M0kR8eav6Cu/0DeobwwEUKmfnSUtOssSq78JR4AS0Gnk+aOnnL88xxVP4wJEYdxN+AKd65gvdowXG6aLDWkXuffm2/zS3/j3aG+cQt9C20CJMG1Jc+L88owpjrjO7QPKgX2va8z7BflbjHsOA2I4cEDBfEpSVqIq5+fnXJ6fUbIBUZuUkJDxIdB0AzmNxGw8zsVfMv9IEoFdn3VhPRaRu/W0ugs8qY8/AK6ukreBT37YD1DV3wB+A+DtX/xrP3TxfZbrNZRQlhdYXusvshjjOwwrbr/7Jd67OEc0M+22RIBJgBlRaKQC2yJEp2g22UiQwLWja9y4NnA8dLQB7ty5RWh7YhIYE513ZO8YnSPNAIlx57k4H2nDBV1ogMDx8QlNozRXYGDnCpmAiGVt2e7pqU/doG2AqopePNDN6EUOA+bl+sEtr87Klr/asz6qyHDpscSHOnODpFXTVtJ+BIFU1yRxlh02z5w/f8Xli0uYFIqS52y9YSwmIJ1n2ETmyy3NuuPtL36RN+6/Q/vWHdsIRGAa0XHHZnvJZnPJPE74TmjaFt9WTmI125GauLJHgvcgqO5RwVwBmaQWSFhKIuVskpA40baB09PrTPmSy0sLl3DSGFrq7DVNsTDFeCVy90dfn3Vh/RPg7wC/Xj//4yuP/0MR+a8x8OJ94Hc/4+/4zNdeCVu1Nk4NorQeBeY8M7QDs/Osrt/gvZ//RfI08/DjT5i3O0qciWnEa7EU+SqJAMccozEBUkJ8oO9W9H3HybrnaDVY/1MSrkQ6AW08Ox+4mCaQTHDC5XZG9Aww6tCdW7fRXtCgNM2hLyiuQvqCEW2dzbaWEIBST1Stc7s6xjGG+h6ksNdEl917YSI4a/WXm0+LmmpXbWcyAabfD6FRA3dI2XosijFRilgjnwppmrl4/pKnDx8xb2ZCDpSobC+36AxpF4nTzPX1CUPTcO+997j57lsc3TmFk7VxIWMkj5E07iizKah30whSzNSlaQ5sCbGyWLLZ0h3Ai8P/ebm0WgEs7Pt5nhnniTlm+r7l1s0bvPXmHbZj5tlmyzxvUTKhNf2a81WLVRTJiRA/XZP1l4Hb/0cMqLglIg+A/xJbUL8pIr8KfAT8rXoz/GsR+U3gT4AE/Gc/LUQQXp9bvZZXXCfuS/MP7HlpKSd88KQ80rcNKSndtVPuvPdl3vm5T/hg3LHJkXK5JchE61wN7LbyShsjib4627AeXnHt+Ijj46pzUiXFmTjOkIrZKqf/u713jZUkye77ficiMutxn337/ZjXzszOvkhxl2vKtGBCMgGLkmWsZMgwZcAiYML0Bwq2AfkDKX0wAWEB27DkL4YFUJBg+iWCgC2INgRIMmFTMC2KWj73vTs7Mzuv7p7ume6+j6rKzIg4/nAiq+r2dM/0zu6d7pnJP9C4dbPqVkdl5cmIOOd//v8GNJl7CJHcNSiJsd/mYH/BG3Kb82cP2NndJNXB1vJOsXSApflpkxmEB4/3AU8yDcMUsbJVKOI45ptsd2kLruU+tGT+WLuLGwPe6nJOnJlbu2LfWhp58TYLoWp7yhiR2FkOum1teRwjqe24dfNN3nj1Ggdv3UEPM21saQ7NjbJdtOQuMxmNeeK5jzM9tcNka4OwMV1qBnKwIC0aNCfa+YzD2RGHzQHzOKeejPGV2bFKtjSS+Tj3LowsnWDoExWmsVA0TEwuDTF3zayRGFsUmIwrTp/a5dK5GXcOF7x47QBSomsTrnJLzy7pTDHLpcTh7Ogdr80HyQr+pfs89ZP3ef0XgS++2/v+IOD03sf74HLa671kvKyWPEk7pLDNk3dU0wlnn/skP3HxMp/4Yz/KH/32b/Kd3/rHpPaQ7CIjUbyLpK4hBE+nmcNmwQuvvM6s7XhycZHzZ3aYzQKpWdAcHXKwf4f54RFdyhw1kUXb4AXwwkHX0h7N2ZiMuFHdpFs0XLp0jvMXzrCzu8F4XFHV5gzpi1SAdxU+W73HtDMyvffWSkTFm2BmKoHo3XJWAiHRz+TQcw+dc6hXhFD2ag5csgK0JNBIyNEskVJXitYZUsfizh3aNnJw+w43r93k1htvMj+c080Ts9stkh0726e5/OQznLt4ibNnzzLa2YQqQGohJtqmIR825C5ydHTIojOjiCYWU4ci+BLbSKstYTICNc0Kr2K2r2G1LLPM3xrh1llPnIDdAEqnwtHRESJQh4rJqBcpTYgoV6/d4M07M+axZTHbZzzdYjqqCQKzoyPa3tjhHfCBZ17cjbvrWP2eS9RS0v1+ofT+gjiimhR02Jxy6vJjPP3DP8Lzv/9btDlSuY55Mwc1cmkIoRA+E23bsn94wNUbFW2zIJ/eZnF4hzg/pGsbYrOwLzhnxsF4bCZxlgnOlZSx52D/kBuVxwch58jm1pjpdMKozkBHLwmgWi1rNCLOZlBdGa+tCKdqxNflnqP0H5WLQcQYKUEcOXjjGkoRM+1rDS6DWPKEbLOU5IjLidR1dO2Cw8MZ84M5+7duc3B7n/nhnNnhnPaoY2O0w7kz57h0+QkuPXaFamsTsGDNzQxVZT47pDk4IrUtZDjs5tbbliOLbmHiNEVSblwH6rrs93oysQi576Iq5Yieib68Hpafv1fdsi7xnDN1XVMFa3Ic14G97U2ac6e5dPYUsWuI+43JH8SO5ITgndn6pMS983QrfCgC616F4vuhd6iwDmC7iNQpXVaSc4TtLS4+/Sznn36ON198nsXRW4h2VIB4JXjrOBU/wi8czaLhjZs3kBTZHtdoghDGTEIgFVf5jTBGpIi2FArR9uYWZ8+dYXtzA6Uha+LwYAYoKZsbyGhSGu4k4XIg+14EdNXY2Wux23Scl/5Sol3Zf8mShpXXgs8SHCCpb7WIOOfBmSScuH4F70xcJmckJ2LqaBcNi8ZS4M28Zf9gwZs377D/1i1Skxj7ER9/9mnOnj7H3qnTuI2p8YnaFpVEKvzD+dER8/kRqWsR8bSpJebIrJnTdC0pdVS1I9TGtHAeOnTp7pgFQs8ugSXxuJeQ6/VDQGm7bHzHNtEsjHZVl2ZLovmbTcc1ezubPH7xLIv5EV2XSHOhiw1JM9V4RKi8NcvqR2zGeif4MmO55SbXSJm9XQ8iVBsTqrzLJz77Y3wjRm682BLbiEYlKIjkZYtCr3+R24bD2YKYla2NTSaVx9FaWwaZjY0NHJnDw32Ojo7IKTKZ1mxtbXDu3BlGI8/R7JAYFywWDXrLLopx8WCqqsouSBOPLS0XYdnuci+NuxXRdBVY/d3bWCTZ0vXOiqQxRryrCKGCsPLdXbLvNaEp03UN8/mcxWLBwdGCO2/uc/P6W9y8eZuu6djb3ObS+QtcuXKJyWiK8wLzI2KKdNnoRXdmB7SLhpjaZfuIamT/4KAsA80AfLwxZTKpqUcBqYQsmSo4srPaYU+TApZ7q565siTSrs3aOefCfolUVW1aIyij0Yi+X20chPNntjnY32XRdHS55c4i0rXmVFNVNSnmD3dr/vpMdfcSsMeycLy+VJDSXKfWAi7OAi6WZr/kPU994jPEZgY5cvOlF2gPbuKSiZuk3BGjfYl1HYiizJsF+wdH1MEzqiuqasSoCkxHgUmoi49UJMWGZtGCdsRuTreYs7t9Gi/QtoH9g9sc7R8W9nZtafSxKdka8x3ISuc7slsFz3qSZr2Ws6xXZVnpzfd9XCkX7URjvas31oYlfVatMYAp86ZE0zTMFgvm8zlv3HiTG6/eZHbnCPGBs+dOcenMWc6dPYtKJtGaDWwbWSQjubaaaJo5oSw9cy77p7bl4OiQnG1m2NzaYGt3h3oczMdLTJ/E++KsKat+qvXWnV4vMGvxiU5qhNkEuTMvsRjtZhfsZFoW2TlC8IzHNedP73G4f8DRoqVNcxILDuZzUmwJo4nd6NzJpNs/sOgb4GIXjdngeraPEjXTdpHgA9vnLvDUp/4YbRM5mre0saObRTzRiLJtg3hPCJ5KRjRJeev2QZEti2xtjC27ph0NHRpnLBam+6dQ7p4LDg4OmG7YzJTxdEmYzRPiF+zfOQL15KyMRpmqGiHBbgypi0iw1Kt9Lr+2/OkViAyq1v6Scynw0ic08vKu3gdRjBGXlIx1RfciLDlHYsw0zdyCazbjxo0bzGYzQuU4c+YSF8+eZWMyJjjPIi04PJhZf1qMxJzoktIV8dKcjCDdplg8l1vGG2OqUc3u7i7jDWtHiWTzOvYBEWX1CQp7X0sNjZWqUj8zp16uLEZi19G2rfWiaWZc1aVrpk/8QCu2O9ve3uDsuT0WUZnHN+kUuthYGxLm2Zy+X67gBwXyzkveJasZMKO4bCIotoxKRJNtx4cajQk/3Wb34pN8LMI8wrcVmmtCt2+euyNxOLWs1mS6gQsVTYIbt2fM5i3NqW3S9tg4hS7jybRdx7ztIHdknRaJZ8+izUwnm4xGNV2ErjPGxHwRyemQlJQgAVJD9hE3BvHJXDlS0f4LwdjxhdvIXfsA9UWYVNNSlXnJTgCQUBhQSpZSF9K89JxKKZKSNf+l1NG2C0IF5y+cYmejtG9UAUgscsfiaG6JglwkpJ2pW3mxBE0GumQOmHgYbU/Y3d2lHtlsZfr5guaW0AVUO+toZqURKGKGE32CTntKZREqkCzkLpPajlkzY97MEU2M6wonWhSyLOsacyKEirqu6bKyt7dLwtNqRRevMZ/PuTNfLIm8KwHQe+NDE1jfC8RBXVXk6IrfLiCYgGYW3Lhmv+uoJ2MuPfdpdi5c5hM//CN8+/f+P37vH/0akuYcLfYZ+0RVBRbzGV2GzsFBs+DazRnffPm7BK9UVeDU1jYXzu1RBSHHCo+QG4HDzObpLeqtHQ7mc1xqWaSO0dYGVy5f5PzpU9y6dYvDwwP2999kPK7Z2d6wdvRxhSci3hPbBhcDwZs6q3dhWSUV7ZMTQtNG+myWyMr1RPoiMD0jXJczWM5pmUVLxQpWiUw3Rjz3iWeopSqOJEU1KWerKwcQ9YwkrO3XzLygb76tJiNCMHHRuq6pJ1NbrgZfsnfmybyUVCtexVL8x1zpftZykadkSk79WDRnjg73mTczZrNDVJXKB6bjUTFKD0syrTYNoajgRs2cPrXD5uY2k4mZqk/Ggas37/DymwdEFfL99h4FH8nAohBnccU609ny0PQIbZMs3qTOGhJhOuX05Sto/jzf+cN/wez6y0huaPOCrmkIIZiOQt/7EzxZhVlsiIsZB4cNN966w8ZkRBWEyitbmxvsLyLUI7ZP7RKmY7a2ttjOEeccFy9dJqDsaGAR4c6Nm+wfLewL9Q5XC14StavKXddIp8s9Vc/MV5ZkW9VehrtXMgrmAFJm814dd50Vvt7ceTecc1ShWv2uRmFCMhpTSQ6UM25RRcqZusi8ASZiWinq1CQSkkC0ZW1Xlm99oqDfN9p2spBuyzK+l/ZYjlsjKUZbus5npC4utfOXwdTffGSlRVgDqR6RvFJXsNiOnNnbYb5oiQpX7xyhnZF43wkfzcDKPcu7WPWUzJmlshOC+VWlzvYFLnj81jY7V57k2c/+cb7z+4n5tUhqtOhMCCF45m3vLAh+XKMRkrQcLhKzZsGbBzNq76kCjO/Mmdx8i2tv3sbVgb3T2+y1kbOnTzHZ3OawSbgkHB0mvvvaW7z04ouIV65cPs8ljVwZ7zCq7QIMzmhOrvRWrRSXSie09HupEjD9RSmRXJIeKeuyzkX/qj7IxAiovbRzXzurqsqUdikXqYIrDpsiK8UkO7d5Rb0SC5JekUq8oC7TlRln1U/VKySV/SNFE7GULHp1LR+0LAdLoiWbDHTTNHSLIkwq1t4zqUeMQrVk4pjMQipSccaUnwYT5OxiZmtzwplT2zZrC3z3+pscHrXLa+h++GgG1hq8OKIDiqS0YMVV6yCGJM72LikjW9s89UOfJbULXs4dR9cTdB7RSMARPNYHVTZ8Lni8BlxMpavZ0Whm3kZmsWEcPTfuvMLto1vs7W5z7sxprly6xLkzZ9nY2OJw/4hrr13jW88/z9XXXmG6UfOpTz9LdI7dvU0AtBJ8ZR3BHU1Jw9cgxRZUVkq7mtParJSLz4axevN6N8BdjPD1WUxElnf8EMKyNiauZ3kkY2/YDtBYEJgirSvEYUFwbiXVDZQZKpbA7S/yVeatl5Hui93G0Hf2nkvSbV7SyhaLGfP5nLZryDkzqsdWEK7M4LyqKtOx8A5t4nLG6veWYMz56ajm9O4GbexoUuLU1hRRwb3Lpv4jGVh9N21a1j4UVVeYCnbCYtLlHiSXgPOTDXYee5KPkwkOXv5qzeH11+iODkATIxcIAdpkLOpU5NnqsefosC2MAE8XIxo8IzciusTV67e5/sZtnv/Oa4TwNTYnm+zt7XH1+g1yl1l0Voj1t+cctN/ijVv77OxOOH9mh73NCZPtQrJN2Xh0IeOdN+KwOnyRxtawujD77keHJOIAACAASURBVNqeqqqYFEDPXFgG2RpvrA+EY0tEKP1bPQPExG5i7lZKRoW72TtVGhfYln9Z+qWbifP0FqdOs4nqqDGo+8Dqx9Pr/XkxWbpeXzGlRLdoaOcL2vliObvaErDndEopkAtRM76ukGwzsmTBFXfXHAJVatjaGDFfTFg0HWdObUEWKu+AO/e9xj6SgaXF3LlXjHEqVnTMSsZmKGOLZ2JO5ghZedqUqTZ2OPX403wsG2vjFTwH118lzg6opSX4srGNpuMnwepFVWkFT2qWrikrh/OWUFmKXVRpmoRzysHBHV6/cUDTddR1TYyJnIUqCNfePGB/PueZp5/gk888jp6zzFbtMuPgGY+FnG3pQ+klM6lJU40yTT1LWRsr4XhaHo7PWOuUqfWkRp/aX3bS6mp/lvtgvev9Vr+ryQks3VuKGGfu62alMN27NuayJHT92Eu/XHHdTDktZQFibOnadrk3894TfEVdj405UWYpVwXbYxdmfFY9thB2zjGSisVibvXISc3mpGZnc0rXRCo/JC/eBl1SYCidobZmDyGwWLSIMxPnrLq87JJmJHiiD4w3dzn95HM4V4EKr6rnzusvkZu38KoEhBAqSyXnSBalrgI5CV20/UcOmG5dBnEmbOnEFHC9C4gTcnbMoyJSIcEK2EomzTO//TvfYP/OnE9//ElSOs/OZkVXO6Jmdvxo2YhXVSO6TgmhtgZGypJPQbDEQ055uZxKmkzMU45fOOvBBav+LWu8LLWuZOO7+3VvbzYsS1OsrSflvNrjibemyX5mTAkRR6iMTOulpNpRNLdEFVKKy8AyTcLFcoarvGUcfV3Z/lMoSsPe7q29/mTwaOpJym45G09HY5rYUQfHZBQ4s7tF7jLt4kNslfqeULpwAVTNE0oKwTKow9djupShM18o+wrNmynliBuPmUXFb1ec+uQpfvTik3zqx36C1776e/zzf/A/M9YFLncETYx9ok0ti7QA6cjBM3bmvdulRBuT7d1cRfA1ZCHlTJczmgTvJoVxveqjUufIzvHNl2/z/Ms3+Ce/+S95+snz/NBnPsazT1/hiStnuRIT43pk+4nF3JgC7ZxRPS02QgFxPbEXqz+Ujf8qwHqD8lXC4m6hSlVF4yo71gus2F7Hkg42DfRMelky9a2y1y/FhSpUOEnLNPl6et2Js+K2RvvOxFj4UhIsVg6wQnPXdXSdaSJW4zGT6RQfipx1XVGPRpbOt0UsvbZF/7kyxcbHhO3xmHHfVlYEz5XzLV4gpyGw3oZVZ3FBNk0DEcUHE65skzmMSN/bBXgpSQ0fSCosUmS8uc3p8YTpqOaFL/8ub77yHaQ5xJNJ3QInNZ6IV2sOtA55hzrIXkjZmXm4M+a03eELwzyXm0Dv3yp9J7QnScA7zzw2fPvlq7x1uM/rb9zgs5/5ONUnnmB7Q6lCR1XVbLqAqOLUnBsl23Js2buUc2nVWjcaKMs6Pe5Evz4Traf1y5ldsuNF8nK272c3R5+wCHZulwHnULF9rpaT3o/PqGhmwpc19rdETKWXJVsklWJzLlJrvSVtqKqiXuWXy8A+QdH36/XJimUypc/4iUNdxosRdsdZmYw8W5tjzp7efcdr7KMXWMulH8v2g+XhQv0RL0Q4JkPc39VVEyb34HB1IAdHjIHxuYv88L/+b/C1351y9flvMFscMK4CIURGxf6lS0rMCdGMBLvA2hTpUrkInaURtBgB1EWBKIttzXF9icAyl+o9mpUmKm+8OWM2f4mbb+1TO+GZp59mOqqZjjxtnlM5z0R7iewK6IpicDCx0kJfWtKBSqE4k0tRtzd7O26WbRwHXR1f52b2bHOOB5ZIn8bpmRLWpGhNnhQz9FAC2ZjHWeOS78ma/npKqwI2FI1EZ7WqUFVmYVSCyoeAk+KyYm0Adt77pI2YDEPM6fhnLJ+tqipGo5qNaU1KG+94mX30AguWlXrDemVRytLL44K5Ey7zhGo8NdsimJl0EoiYUKVMtnjsM58lO6uB3HjpBbr5ES5BGI2ZSEbaFu1ModVTXEUo+7e1xsNcJJ5XtJm8/KEOsmZGIyP5tp0YW0Tg4LDhW8+/zvboj7hzmDh39jQXz55md3vKuGjvjXIihFQyao5KsjU5puJ62NevWK8/HU8trxeQ73UcKMu+wuFba+dYXrBujWm//LvVeei5jKom5bY+e+WcSCkToxnFpViSUH3QFhUnLbWpqqrwIay9hwCr4Om7A/pCdM+4Pz4WqLxjc2NEjFO6rn3Ha+wjGVhS7F2W7Pi76CmqiVA5cBVtimQtKWi1niyHEiWatAQBCg0n7J7mwsc/SdvMGdcjbn33Jdrb13EKIdgeLmYp9jLWeOnV45LdnRGr71SVzUbEuBqz65dosaTLHYqYo0fnyF0EHeNkxFe/9TrXb845d/YUzz71GM88dZm9U5tcOr9Hqh2jYmidnaDJGiZ9Gi2VdAFSb/NTVqHrwbT+2PXKSLJqzwCMG1gep1I4jkVvfr1Xqm+DyTnbsjPpsaVnKr0yyz1QtH1YisWxsihqlYWlSQz0Xs/98nrNdWW5lKWf/WVNFq7Qe93KZEOxmdd5+/43NzfpUmTR1O94jX00A2upUumOBZUtX6wh0Yeq1DlcsVQ12eLUKwOJNeA5daSozGJmo97Ab+/xxKc/y/bOKV7c2OHmi9/k8I2XGCOMxOMUYulG9ggNEelspqBk41yx7dGcSytmv89bZSk9Qmw7ggSCC7ixfdExtsy6xKvXb3Ht5lu88uo1XnjxZa5cOcePf/4zbG+O2dqcUAVbUlbeUflArdncRvxqVjF5ZlkqqK2n29fO5jLJsf6aSmTF/y6B5N1qdWDmLOt7N1k+7lq7oSzT+muJk9SuZR11lZFcNjmG4u8cVpqDFjz9V338+w5iOhZZTEFK8IjLK0qYeHtPVZJmxnVgMq4Zj4a2kbdh6akFx2jxvRCmcw7NCQdMAiSx2pCa/CzqtARgi+BM2EWEOQ429tDRlFPnLrP7yc8xv3mNF37/d3jp//k/GLWHbIwWpGbG4WJO0GzO9pLJWpmNzHyBRGtuHIUxy56jfiYp+6/cWK1KSjUzBSV5JVcB8Ttm7yrKrbnj5tdf40tffYnf+M0vsXdqi1M7U85fOM35c6c4vbfLhbNn2NvYYFwVXflyeoIr7IqYWGVSV+cr57jGjsjLGUxEaBcNsGJWGFbvIcWppS8Qq+oy+bD+upQSOa0SGa6USiiFbMECCe+WgeS9GOvFe3wV7DtywVSDe+GpbAKjfe+ZU2cSDkHxatuAlEx+2vaSAecyo5Ewbadsbw3Ji+8LPdXF44gkXOzAS9FSLzOY2Drda5Ek89biHqrA1ijwlGRufPvLHL72EtIJ1bRiIo75fE7lHF0SmhzNDWU6oesysU1UYpdYFsU5X5Zbgq8rNGQj0EqwRj0Ej7VaEDydQoptkdYOaFZmTWZ29S2++/LrTL/zMjvbm2zvbHD+zFmefvwi586eYW9vl+k44Au7pPIOr3nFyri7eNzXxvrlVIm7PkDW/2bFAVztn9b/dsVD7IvOq14xS7gIWRx9KXeZbSzCpyGEwvmTNS5gUcotxuE4EEmUzhp7Py17V7FSAbGIonqjTFHWCjkLXfZoNWG0+f4q4X7osNpsC7UXUlt6ghAi5mnlEbJ2iJrrnwRv/UYKbjRh+/ITPPP5f41Xx2P2X3+J9ugO2UeqWvCaGcnC6lcUGTIHyUPsMqgtDwOOLBm8I4ysoOxVjJ6lDq+YY6M4FjlbE6evkeVyrmcumFPh0UJYNHOu3Tjkxe/e5BvfepHLF8/ysace54nHL3Fqa0LtM4HExHu8690XV4HkvUc7WfIPYRVYKaVSI1rfvx5fZt6N1WzolsmDPrHQB0jfdt8zQnq3EQswX4KNpfho39fVC5iKYEteivZiMQDvq1hge6ysRiBVjF+ZZUSX4Q4TmvGI5IbA+r6wvvTx3hMkENV0v1VstlKxvU/OxjXz3pPEmZl3UFyoeOyHP8fW7g6vffPLXP3W12jfuEZwFTQzNqoJlQ/QzDhoW3KhCsXWxMWDNw33PkmQc8YFZ3XSlHGaSuZSzPVeMk4o/ldhWedpO1PUlWpjqe6aYiR2SnOr4dbhK7x1Z04XM08/dZntjcCkEqqcLDUtVp/ql3tgBW1dO1duGUgChdG+yryulnSyvhzv/2J5E+vrXX65lOxnMc2rLF0fWCbiKThfmB4lKJcBJlLaSyxhYe8DSC7CpSbVnTOI+tJGo2SiNXqKY+4nzEZbvDl9jNloi1RP3vG6GQLrHnhbAblHuQOa62axMcWCKzi7E7plYRU6AcnmgrGxc5azz06ot7Zw4ymvfv1r3Hntu4RFYiSRceWJoqiDJiViUsKoIrat5VlSxjsTp0xJqdz6GI1BkXJnlJ3KleKrLW0sFxJQL8u9TBOzEUn92NLZPjBrDvnua9dRVY6Ojnjy8lkund9hY2sMRRckLAmtARDCqnRF39phvxzfW/WJgNXSMN81m61xFKWfeVav7wOrdzztTQH7oq5zDh9WMuKWFVz1nmlf0lDI2rMnWdbZlF5B2VxWEplWRrRuxEzGzMIW8/EZ9k89w6ya0krFO2EIrHvgXkGlzrTLCYJPQsoe57LRbehVe1apX69CJcbdc87T+ECYbDK69CQXfEUebZLCiHjtKu21F5Eu4kXYGk0Yp5aD+QKZTMhO6BYdqYuW0ncB7bRkriyge85eL0apsUXKnkSXs4vSdIVwiiuNnZaGTpqLAdyEFOe8dvUmi9mco/0DND/JVn2GySgQameTjwcJxVM4rJZ7qmrScmU2WwXX6ufK1f54YBl/cT1rWFLoy1qTXciSjnMQHat2D9cHpGeZWZVi+B6KGV0fUCoeJCBLNxYFyWSERiqSwJGr2R+d4sBvsKi2WdS77FenaQnkd9HcGwLrLqwzC972nFMk2DrfL0VNrFqPw7J12BfpnNWp+haV1nk6VWS0yfTyEzxWbTCebPHWN77Bq7duQANkxeWGCZ4wmXCUIUxq5llZzBo0CfiMdpnknCUWZOXVpJKJYtQrLUVUcNYu0dON+qJnTnQpFRd5y/ARHFUYk3PHGzdu08znOIVLZ7dxHuq6JjtrCZFsKrL9+eqXbOJYzjY9o6EPrH7Gsj1SOpbYyKjZvbJi1Mt6Qbkw4cMaI2Kd1SHHjq+WhPTfUHneamtlfFCSEoW75gMdngM/ZeFHHFabHIxOM692aKoNFlIzpwIc4obA+p5w36ASE+EXCXgvttfKELO1dKgIKZQ9RVZEI04zNRDTHFfVxFAXxvwE/9g2j5+/xMd/9Mf53c0Jbzz/dQ6uv0y6dZPQzAjaMp1kPI5qWrMxqlAJNDGx6FokOnN6kLIOdYobeSYS8Nkc7mO0dHh/fU3HlXHrcl4WPLPJJZmMc86oeIKMqOoxR03m97/6Gim2PPH4GZ587CLnzmyzs72F7/uhfEkI9NJqedX/1M84plXLMvFhCcP7szZ0ORus2CirTOEqFb++1+p/rncGr79vQi0RBASbs+gQogu0oaKRmkY2OPKbXJ1e4GA0Ze42IE9QvCWOAC9tzzx7RwyB9YBYGtqpWan2G3kRR4eieGLh1knhzbpek09sGWJp8fJlO0FGIwjCE5/7PNXGhGvfGLGfPfnWTVxe4PIRzgm+kHDV24Vc+4rYJmJKZR8BhAwec1/0Fly69NOSY8uv5X1cM6Im6ZVcQtU4kjEl1NU4PF0XeeHl6yyapiRBLqHq2dmYEiSilS/p7VSSF34ZDMsZR98+o3gfWPZu6Sqp0Rd+j7edFAkFVvvfwv89VgbojeKkpNDt3BvDY7nH63u6xKMEGhlz4LfYr7bZD9scVlvcqbdK8knoDdRdrwxVvsN8j+TLOobA+h5gZZDyhTsTz/SlBtIpy71Lv7jp+QkqQs8Nkt7HymXUO+ZR2HvyaUJdU1cjXsVzIDXMb9MdHpKKcmBGibGYjDtX2jmSWd7EDldDqO1OHXxAvByjC61j/W7eX6i9kpOqELMyT9EsQQm8dbQgXXvLNAAXicW848rFc2xMpqXvaeU/5vwqVb5OH1oPHl9ek3Ne9l4dq5Hp8cbK9bHC8VVFz5Bn7e/XP2/fJpNSV8ogjijCzE1p3IQDP2E/7LBfbXLot5lXYxpX0dfZ7C3j8vtXzBD8XUSahsB6cLiyeiliKH2frLMal8TjF69iUsjAat9FYXNLubi9w9UjosL4wmOcF0/CqvyHV7+Lzm7QtQ3OKd5JUW41NnlVeaJCFyO5TfiShtYsjLc3ybBKZuh6mnvF1RMciUQmGQFXM048IUCMmTZHIoLTitvzRLx+SNu8RrOIxAh7e7uMg+BcVepWgi/CNWnZLLm801hiRyja6qmcJXvaSW9YoSZrppDTSm9jFVT9Y796jrX62loSREQoOXiCmEtm58cc6Ihr4QKH1RYzN+XIjWldsPKIYr7Ky1nSTPaW7T5iHM138wsYAut7QMazcsMuBlLB7GRSWeql3LMyxIqMkpep775dpfQqLLt8swTCeJONi1e4WGg8vobmzlXafAdNjRGDsQQKKC6M8M4hjZByR8Ya/lJKdJOm9CN5ejOGno93fImFuZKomIF4VAjlLu2BbOn9Vj2qjoN5R0pH5HydqJkL53a4eG4P56XMCons8rE0+HrNapU6f3s3stGGDKvnVjPU+qy2/p45Z1DT3u/T/c45+1zldREh+U3aUDPzG9xmzPXqDId+i4UfEZ0nqVl9LzU+eleXte6HPqgeBENgPSjKfkXJcKylAxDwlcO1pb8niyU6sI24L9k4WOkX2pKw1L6qGnIC79m4eJmLuWUyqZm//l0ORehmt9HuiNR11uznAlpZQ181cvjsiKkjJeuZWsyPGI/HhBAY1YGcHV2MxfxOSb2uez988VQ4XFY0m0e4R9HKoyrMu0RSoVVHXHRwe0bMr3Ph/BY5NZw/c4qdnR2qqiK5dEx9yd5/fa8k5WZzN91JLfWtuiaGuXp++dpiXqF9iwlWagBwEoxTKW55+WdVWhlx2++yH7Y48CP2w5QbYZtEZVQnTWUVUvrRyp7YUr1rXz+6ZOzfz5utxxBY3wOW1B1XJi4nJuUsDi+CFy38M9tUq1ityTb1ZV1e0sx4Y7prMlnoLlmzej2dsnX5CpPJhBvf/BoxG/dQZ462OSB1CeeFHCO5NA56X4HYhSlOic2CRhTVukh+GSE1JSsuo9maCbHPIKK4CFo0/ihLXOv9MmqQiiPGTM4OFpF5t+DbL7yG04wm8xmbTqfLVHrP13OucBm9w6kVwPsG0l4vEI5n+ZZ66k7oiXy9/o/HKtJ97BnlyfaG3tugI46Ip3Xe0uZ+ypuyyx23ydyPmIcxi2B6+Z7esPztktGqqWQ08+oCQN81qGAIrAeHKILd2Uw3r6S7Wa0O6+DJLtMlS12vUrKu1GkUEePcgWXl8IoTS3+TAx2BON1D/Qaf/nP/Hs31q7z+zS/z+re/wv6N13GLQ7r5IdLNILUmIVYMA8Z1XRjbkdi0y5T79sYm42oEk0DbReaxhbI8RBVNieRYEmoDprmRO9NWnIxqW0aGEanzHMUFLnq+/MIBV28s+NbLb/HElRtcOr/LhbPbnD21yRk5RZAK7ys0jPHZk0nW4esBPEmKSlQ/K/WeZanUndSEZMRhvWOUQMMCsTSq4N0IfEWWmoXYcm/fTblVbfBKfZrGjUiMjmXywjKO1L7Lu7vJ+6ZWVgboPR7Ej20IrO8BKqu0+73Qk0b7FHLq7XXW9hLAsb3F+sa8bw3x3pNDwG/vsh08SWNpd1CaN69TSaY9mJOckEVIAqpGiQjO00XrUO4DbO5npLIvc3hqKiImpY0IKUNLNpZI+XyVt+xZzpnYmey1E2+exDpCU+SozbR3FjQizFPiYD6jjQ0iyvbGBlo5VCrjNGIlhpQzwQtOupKG90h/2ea3Z/j6vWnIxu5f9lSvBUkXKlo/4shvs++2uOW3ueOmzNyYua8t2fB9f/vfGx7E3PvvAX8OeENVP1OO/RLwHwE3ysv+mqr+o/LcLwI/i4X6f6Kq//gExv1Iog+U4DzqFdIqZXy/wnOP9QKpiMmvMd1AvWfj8mM8sTHGe+HmC9/k8LqnPbqDYNlCKFqGGaIqUR2VE0Jw5GjO8zFnJlOHDwEvFS1K6qzPK1Se2JlIacL6vJwTglXl6GKHatm/4MAFRI2ulXPi9lEHckDOEUfGo1zY22PKin1hfWumzCTqSyiltVldlr8bK+L4HUyKwKiKM28qcWRnLPM7YZcjv8WB3+KO3+DAbTHzI1rCKmjXJRjeBzzIjPU/AP8d8D/edfy/VdX/Zv2AiHwK+Gng08Al4P8SkY/rvXoEPmRQMk798nKofEA00q351d4ruCx7mG1F1BdSvbWz+8kmOh4jDiaTCU94z972Di9+9fc5uH0NbeeWLRRBiix2yoo6T5c6Kl+kvFA0mZb5eGwCluozLmkpdoqZGBSZ6L4BUFNEgMrZGDVHVExVNzuh00yVoW07Dg4iPmdCBonw9KXLuF2FSYfQ4rOHUOGkIudR4SmaVPOy11iP17+WxXSKihYeSyB5koxo3YSjsM1r1WPs+w2O3JTOGc8PdZZiV9uD5XdaapwA3jWwVPWficiTD/h+XwB+VVUb4EUReR74MeCfv+cRfoCghQ4gvX6eNzuavHaxHHstbw+25e9OaFKmrmrydIsmZabnr7C9sU2blauvvEB7+ya5meFzInhZ6k4k50wyILWIZqo6IM6xmB+ZmOhYrIkyWFKiyx0+eqJGcjIDBFlzng/iSWXJiFoPmuDIKsSUQa3pcl8iXuc4dbx+/TYiwimdlGBJxmEUkM6b4IsI+RjPr6TYk5pZg1gvVXaezlckCWSZGuu87KUOqy3eCKeY+Q1aCUWmDgqDExDSstD7/uH72WP9FRH5y8CXgL+qqreAy8Bvr73m1XLsbRCRnwN+DmD30mPfxzAeDfQM8vKDQiayvqqsxzxr7+bFLfdYrMzxrICcSeKopht0XWTeePypCWee+yG2vvFVktTM37yOLA4QEi5HvIBowAWxJsQs5GSuKDSZVhcQM1VV4byzVhUJjMeeZr6giQ2C7fP61vgeDgHnlnkyEYeWtpiYYN6WBI9vef6VN8B5snpwNXUt1GS8ZtBozYSlXtaT2kPp1nVQWuUzyY9pQ81BtUXjJizcFguZMJcxcz9hHqbM/ZgkGcFm2FQMKBQp2Vveldv3g8Z7Day/DfwNbLh/A/ibwH/I8eRJj3t+JFX9ZeCXAa780Ofe5499cujZBv2+qnLmBdUzIODtyQvnjvsF9zWbEAJdSviqJmzu0CnMUqK+8DhnnvkUms1vN95y+HiE05bKKU3uACmCKtZuEWMmOEfqOtpC+fEEkigJYVTVpgpVtCj6vjKw/qUA4C0JYDNzAlFi4eW1momtceoOXOLVq28xHU+oi+P9JlZElmUtL4MrDpRqctOtmJ66uJroKqKvaaoJCzdhv9pkIWNat2kBJjWdHxN9XcLJQklLlm+1dSuf5QELuz8ovKfAUtXr/WMR+TvA/1l+fRVYn36uAK+/59E9Yrj3Mr3PN62zqXV5i1HMxyk4o/mUdqIVmdRBLMqrbp1fpxByRoOj00yoPfWpPVLb0LUNT/3ET3Hl03+c/Re/zY2v/R5vvfAV4p2r+HSESw13mhY/mhCLh3FvpSq5JanSdAs8pmleu4pmfoAAW5vmnbxoTQSzEs9sNlumv70kqy85mHcdvq6IKZins8JRFNr5nFddZjabcfOtN3nmqce4cuEsu9tbbEyE0daU274iuRpxY8SPSWHKfOMSbbXJzI9Z+AmtH9O6mii2DFQ1GYRjOb7kQCprngaQjMsZI4dZljPLiuP3fuE9BZaIXFTVq+XXvwB8pTz+deB/FZG/hSUvngV+5/se5SONd/+yBDX9dFVyrxVYuG2iuqzjLCk9FHk/NSKtipIl47zivKJeYDyl3nNspUQ3P2Q2O2AWW5g5Jg7mrWnA+1CTMZ34aV2RYiqyagopQWsaD77MUBoT4p3pFUZLwU83Jube0UW0NAY65xjXFTGZHkaszASiVUWd49a8YTzxXL9xi+l0wmhjQhpNaSYV1fgss4094mgLV2+R6w1y2ORItuioyFVAxfZwfc3I2OWu3NzKTUykUBFzOZ5LbbtPfjjaIiIl+ohlBUXk7wN/EjgjIq8C/wXwJ0XkR7Br4CXgPwZQ1a+KyK8BX8MowT//UcgIvht6Os/6vuV+yYt19PutjJqvLhlXnFE6VVxdMzp7jr34HLFdcKPrWLwh1G1mqo6jriNJWQJ6BW8tmktJgZytdyw4xqOR8QxTJncd4ovrYVJTncKSC85ZnS5mY5NIkYAWvHEfXSAG4VCUa42wHwI6d/hugzg6T9y+zOaF52ineyzchOjGNiO5MY2brFpGJJeAyW87T70+4GreKq0dd+06knOWIaTIWb+PG44HyQr+pXsc/rvv8PovAl/8fgb1oYRmgjdxFyse95fFvYUfU9l79Ww4KXLPoibdVdeV0Y3CiMn5S+w2c+Ki5SAEFq8cUY89ncxpk9kSeZRYrEh98La/SmnZCiNi2uRJO5qmM9dCZ2oQXjyVd7Rql25WR3aQEJw3jcDaWx9Ym6GJifGFx6gvX2bvsce58MlPc+4Tn2L38mNoPeWmVmTvScUk2xiMgLaYxp/xKC0QbE+WxBIRbnmzWd14hGSd2vR8+VJAVrFg600m3kcMzIv3AVIYDM45k0rLJqW8TFhw75nr+O6tEHcBnOKrQNdBIlGPN9g8f5l0eITTyNG1byECdYrk2JBSR3DO9MZ9WAlb9hp9Yo4dvZVojJmYIzn3RFnboyXNNF0qhgw1TYKq9syblqSO6c4pzp+/wN75S/zJf+cv8sRzn0DGmyQX6FzNga9YZEACpM6Wn27FWM8pkXO3pHxZUc2vaEzSt7UZWVDK4yUhvZy1u934wAAAC9JJREFUZb9U6TjgfV4GwhBY3xOc3r/QeK/Gt/6lktOqdcJBqFYi/EmPp9/X38+cNlZevFJUYJOUDXlp+/CTDSY+EA8PaY/uMNk7T7N/09wKw4LYmgWOd6boS6qQylpgco7ErFRFkKaqgrXON42l2m3yWEk2Z8iuIuIZ7Z1m6+Jlrpw5z4XHn+ITP/RZnnzuU/jpJq142uDJSYt6Lxivz1gTEgKSC/WrV14KZlCeU1w7E6nso8q+qvS4Sd8fV7oOcqldafnZv6ZKvpyr/L4WiYfAep+wZBRIr4fX9xKZfPPdlCawlkaPbdylFExxAdVk4pQpkrpMKwlXefzOLvWZ82xduGLt6G2Lzw1eIzF3BJdp4qqj2LmVVU6vIiuiuGCt/ZGWLmXrMZMRjGvC7pRTe+fYPnOOn/i3vsDFZz7BeO8MXXY0KrShtgyeWAuAkgjBLFtjMTwwtQnL8IGYkRugRatx3QgPTIW3z+7BvTibNj2pWEeBrCb25c90jxvfSWIIrO8B73THe6eboa339djrnBdGvsbFyGLRWOD1KkblIgjq6e0GeqVytAIqVJMt3Xwmx0QjjnzmLJsbEy7sjOiuv85Xfus3ufPqCzitcGnG2LeMVGjbjnY2Q3ygHk3IXjjygZgFITDd3WV79zRhc4czFx/jJ//iv4/f2CJVY6IEcqhK86BnljIzuMdWsbD7vbPG9pLqLN0frJIPazeUY78el07rg0rULc9hPv4HxVJ6tezLAtk/nNzZEFgPCf2sVIVA56NlCksSQcry0GE8vh7HmPA9DcgXWoFi7PPRmDzZZnQ6c+6JZ4jzfY5uNkjX4doFmo353gUh+cA8R/KoZufJH2ayc5Zzly7z5Mc/zuMff47x7g6deI58havGgCMm29NYx4s5jT1IG8VHDUNgPWT0cl2qunQpXC0b7+qwXeum7Y9ZWceZYhO2jGvrCX7ScfaJp7h943XmswNcCnRHQpeUzisaJvitLU6fPsOlZ57mx//tv8zG7jn8qKZRJYnjqPJElOiC6VHEkj30Ae+VHFeF8AHHMQTWQ8JSTg1dCl+qRjQnEL/UQF9Kla2Rc/s9e59NLLZ4aMoQHHFc03YVG2fOs33+CoeHh9zZv4k7fYnNrW22z13msWc+wdOf+hF2zp2ndYFZFubBXOVjUYJKUqSh1RlP0BcLoRxJmvDi31c2wwcJQ2A9ZPTSY1XR2btX4Xi9WXJdebaf3fp0fiok4DDZMoM759l+6jnc7h6n44x/5U/9Kca7p3CTbVoNLLLjplQk5/G1ZSGNZmV8OyPLmwEevUCM7x0cve39PjQszx8shsB6yOgF+b33VKqQTVjNFJ3uUTzOutyLuaL/YO4iincQJFCNNqnCGL91iic/9izTac3+/IA8HnOkYrJiBPAVOI+Io41HplOxpFqJtXmoFZRNSq2vFGFkWbH03BBcb8cQWA8Zq9nI+IQhmO1O07VFkuu4AKWTXmQzUxUTa+ccbrTqa0IUb3IaJIX9BLneo1sqsJT3ArTo5lXUKw2P8n/FogOYcl9LKtIBJaCd6pC4uA+GwHrIuLs43C/zgvMs4so4YKnVV2arEMKaT1X/ZpjtqtiSUNQtybyI9TixphtBURzKknFr+fK7OXh3T0kPolL0UccQWI8I+iSE/eLQEKjpXTeMfmSBtRZoy79el2KGnolgYpysZe56sqr9TQ9zhVz7XdZfvVKbundADcmLe2EIrEcIx5ocnceNi03ommbGcvLIq5lnfdISkRV3To6nw0XfHhy2lHPGmn+X8Q3LvgfHEFjvA95NNm0J6Ttgi2ZGX7dSE6uhJDfgeNbw7gt+vaFi/f92a3GmsCSrKtxFZF09t35sNczVuIbMxb0xBNajjNw37LGMiLtZ8Pfizy1rZPd47tjKcAlzo++D6/4z0zBlPSiGwHoUUaLg2LKtD5oSWFHvwbTrOYbJkfqtz9q0k9fed8W967swZElUPRagovjlf1LS7X18DXF2XwyB9T7gva6W7j1zHF8Kri/t7p6pbIu1drBPStz9vnKX1Mpdz6/a44d91oNiSOl8SLAevPe8+H8Ae6EhqB4cQ2ANGHACGAJrwIATwBBYAwacAIbAGjDgBDAE1oABJ4AhsAYMOAEMgTVgwAlgCKwBA04AQ2ANGHACGAJrwIATwBBYAwacAIbAGjDgBDAE1oABJ4AhsAYMOAEMgTVgwAlgCKwBA04A7xpYIvKYiPzfIvJ1EfmqiPyn5fieiPxTEfl2+Xlq7W9+UUSeF5FvisifPskPMGDAo4gHmbEi8FdV9ZPAvwr8vIh8CvgF4DdU9VngN8rvlOd+Gvg08FPAfy/31EoeMODDi3cNLFW9qqq/Vx4fAF8HLgNfAH6lvOxXgD9fHn8B+FVVbVT1ReB54Md+0AMfMOBRxve0xxKRJ4HPAv8COK+qV8GCDzhXXnYZeGXtz14txwYM+MjggQNLRDaB/w34z1R1/51eeo9jb1MyEZGfE5EviciXjt66+aDDGDDgA4EHCiwRqbCg+l9U9X8vh6+LyMXy/EXgjXL8VeCxtT+/Arx+93uq6i+r6udV9fMbe2fe6/gHDHgk8SBZQQH+LvB1Vf1ba0/9OvAz5fHPAP9w7fhPi8hIRJ4CngV+5wc35AEDHn08iGDnnwD+A+DLIvIH5dhfA/5L4NdE5GeBl4F/F0BVvyoivwZ8Dcso/ryqPhzr8gEDHhLeNbBU9f/l/mLCP3mfv/ki8MXvY1wDBnygMTAvBgw4AQyBNWDACWAIrAEDTgBDYA0YcAIYAmvAgBPAEFgDBpwAhsAaMOAEMATWgAEngCGwBgw4AQyBNWDACWAIrAEDTgBDYA0YcAIYAmvAgBPAEFgDBpwAhsAaMOAEMATWgAEngCGwBgw4AQyBNWDACWAIrAEDTgBDYA0YcAIYAmvAgBPAEFgDBpwAhsAaMOAEMATWgAEngCGwBgw4AQyBNWDACWAIrAEDTgBDYA0YcAIYAmvAgBPAEFgDBpwAhsAaMOAEMATWgAEngCGwBgw4AQyBNWDACWAIrAEDTgBDYA0YcAIYAmvAgBPAEFgDBpwARFUf9hgQkRvAEXDzYY/lAXGGD85Y4YM13g/SWJ9Q1bP3euKRCCwAEfmSqn7+YY/jQfBBGit8sMb7QRrrO2FYCg4YcAIYAmvAgBPAoxRYv/ywB/A94IM0VvhgjfeDNNb74pHZYw0Y8GHCozRjDRjwocFDDywR+SkR+aaIPC8iv/Cwx3MviMhLIvJlEfkDEflSObYnIv9URL5dfp56SGP7eyLyhoh8Ze3YfccmIr9YzvU3ReRPPyLj/SURea2c3z8QkT/7qIz3PUNVH9o/wAPfAT4G1MAfAp96mGO6zzhfAs7cdey/Bn6hPP4F4L96SGP7CeBzwFfebWzAp8o5HgFPlXPvH4Hx/hLwn9/jtQ99vO/138OesX4MeF5VX1DVFvhV4AsPeUwPii8Av1Ie/wrw5x/GIFT1nwFv3XX4fmP7AvCrqtqo6ovA89h38L7hPuO9Hx76eN8rHnZgXQZeWfv91XLsUYMC/0REfldEfq4cO6+qVwHKz3MPbXRvx/3G9iif778iIn9Ulor90vVRHu874mEHltzj2KOYpvwTqvo54M8APy8iP/GwB/Qe8aie778NPA38CHAV+Jvl+KM63nfFww6sV4HH1n6/Arz+kMZyX6jq6+XnG8A/wJYj10XkIkD5+cbDG+HbcL+xPZLnW1Wvq2pS1Qz8HVbLvUdyvA+Chx1Y/xJ4VkSeEpEa+Gng1x/ymI5BRDZEZKt/DPybwFewcf5MednPAP/w4Yzwnrjf2H4d+GkRGYnIU8CzwO88hPEdQ38TKPgL2PmFR3S8D4SHnT0B/izwLSzj89cf9njuMb6PYZmpPwS+2o8ROA38BvDt8nPvIY3v72PLpw67w//sO40N+OvlXH8T+DOPyHj/J+DLwB9hwXTxURnve/03MC8GDDgBPOyl4IABH0oMgTVgwAlgCKwBA04AQ2ANGHACGAJrwIATwBBYAwacAIbAGjDgBDAE1oABJ4D/H22BaxFHcVlzAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(cv2.cvtColor(cv2.imread(blue_photo[1102]).astype('uint8'), cv2.COLOR_BGR2RGB))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x204a35a7a20>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(cv2.cvtColor(cv2.imread(blue_sketch[1102]).astype('uint8'), cv2.COLOR_BGR2RGB))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define GAN Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "img_shape = (256, 256, 3)\n",
    "\n",
    "d_model = discriminator(img_shape)\n",
    "\n",
    "g_model = generator(img_shape)\n",
    "\n",
    "gan_model = GAN(g_model, d_model, img_shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"GAN\"\n",
      "__________________________________________________________________________________________________\n",
      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      "input_4 (InputLayer)            (None, 256, 256, 3)  0                                            \n",
      "__________________________________________________________________________________________________\n",
      "generator (Model)               (None, 256, 256, 3)  41825691    input_4[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "discriminator (Model)           (None, 64, 64, 1)    539203      input_4[0][0]                    \n",
      "                                                                 generator[1][0]                  \n",
      "==================================================================================================\n",
      "Total params: 42,364,894\n",
      "Trainable params: 41,825,691\n",
      "Non-trainable params: 539,203\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "gan_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "opt = Adam(lr=2e-4, beta_1=0.5)\n",
    "\n",
    "d_model.compile(loss='binary_crossentropy', optimizer=opt, loss_weights=[0.5])\n",
    "gan_model.compile(loss=['binary_crossentropy', total_loss], optimizer=opt, loss_weights=[1,100])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Start Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " ========== Epoch 1 ========== \n",
      "WARNING:tensorflow:From c:\\users\\user\\anaconda3\\envs\\tf-gpu-1\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:422: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n",
      "\n",
      "WARNING:tensorflow:From c:\\users\\user\\anaconda3\\envs\\tf-gpu-1\\lib\\site-packages\\tensorflow\\python\\ops\\math_grad.py:1250: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
      "Batch : 1, D Loss : 2.262 | G Loss : 42.058\n",
      "Batch : 2, D Loss : 1.777 | G Loss : 21.263\n",
      "Batch : 3, D Loss : 2.124 | G Loss : 16.144\n",
      "Batch : 4, D Loss : 1.989 | G Loss : 14.232\n",
      "Batch : 5, D Loss : 2.531 | G Loss : 13.015\n",
      "Batch : 6, D Loss : 4.515 | G Loss : 13.539\n",
      "Batch : 7, D Loss : 2.256 | G Loss : 12.942\n",
      "Batch : 8, D Loss : 2.218 | G Loss : 11.719\n",
      "Batch : 9, D Loss : 4.467 | G Loss : 12.478\n",
      "Batch : 10, D Loss : 2.330 | G Loss : 10.870\n",
      "Batch : 11, D Loss : 2.607 | G Loss : 11.588\n",
      "Batch : 12, D Loss : 3.373 | G Loss : 11.687\n",
      "Batch : 13, D Loss : 2.681 | G Loss : 11.481\n",
      "Batch : 14, D Loss : 2.573 | G Loss : 10.598\n",
      "Batch : 15, D Loss : 2.629 | G Loss : 11.233\n",
      "Batch : 16, D Loss : 4.183 | G Loss : 11.090\n",
      "Batch : 17, D Loss : 2.189 | G Loss : 11.511\n",
      "Batch : 18, D Loss : 2.335 | G Loss : 10.908\n",
      "Batch : 19, D Loss : 4.519 | G Loss : 12.389\n",
      "Batch : 20, D Loss : 2.727 | G Loss : 11.845\n",
      "Batch : 21, D Loss : 2.600 | G Loss : 11.249\n",
      "Batch : 22, D Loss : 2.516 | G Loss : 10.602\n",
      "Batch : 23, D Loss : 2.363 | G Loss : 10.622\n",
      "Batch : 24, D Loss : 4.347 | G Loss : 10.624\n",
      "Batch : 25, D Loss : 2.597 | G Loss : 8.816\n",
      "Batch : 26, D Loss : 1.898 | G Loss : 11.320\n",
      "Batch : 27, D Loss : 4.080 | G Loss : 11.499\n",
      "Batch : 28, D Loss : 2.402 | G Loss : 7.653\n",
      "Batch : 29, D Loss : 2.225 | G Loss : 7.833\n",
      "Batch : 30, D Loss : 2.476 | G Loss : 7.711\n",
      "Batch : 31, D Loss : 2.050 | G Loss : 6.253\n",
      "Batch : 32, D Loss : 2.581 | G Loss : 7.128\n",
      "Batch : 33, D Loss : 2.724 | G Loss : 7.293\n",
      "Batch : 34, D Loss : 2.261 | G Loss : 7.426\n",
      "Batch : 35, D Loss : 2.261 | G Loss : 6.352\n",
      "Batch : 36, D Loss : 2.333 | G Loss : 6.632\n",
      "Batch : 37, D Loss : 2.447 | G Loss : 6.757\n",
      "Batch : 38, D Loss : 2.398 | G Loss : 6.884\n",
      "Batch : 39, D Loss : 2.483 | G Loss : 6.786\n",
      "Batch : 40, D Loss : 2.418 | G Loss : 6.549\n",
      "Batch : 41, D Loss : 2.003 | G Loss : 7.247\n",
      "Batch : 42, D Loss : 2.395 | G Loss : 6.834\n",
      "Batch : 43, D Loss : 2.195 | G Loss : 6.685\n",
      "Batch : 44, D Loss : 2.534 | G Loss : 6.311\n",
      "Batch : 45, D Loss : 2.350 | G Loss : 6.295\n",
      "Batch : 46, D Loss : 2.208 | G Loss : 6.204\n",
      "Batch : 47, D Loss : 2.295 | G Loss : 6.627\n",
      "Batch : 48, D Loss : 2.279 | G Loss : 5.951\n",
      "Batch : 49, D Loss : 2.420 | G Loss : 6.254\n",
      "Batch : 50, D Loss : 2.112 | G Loss : 6.072\n",
      "Batch : 51, D Loss : 2.130 | G Loss : 6.149\n",
      "Batch : 52, D Loss : 1.803 | G Loss : 6.464\n",
      "Batch : 53, D Loss : 2.267 | G Loss : 6.190\n",
      "Batch : 54, D Loss : 2.437 | G Loss : 7.174\n",
      "Batch : 55, D Loss : 2.271 | G Loss : 6.602\n",
      "Batch : 56, D Loss : 1.843 | G Loss : 4.610\n",
      "Batch : 57, D Loss : 2.380 | G Loss : 6.033\n",
      "Batch : 58, D Loss : 2.313 | G Loss : 6.456\n",
      "Batch : 59, D Loss : 2.274 | G Loss : 6.569\n",
      "Batch : 60, D Loss : 2.274 | G Loss : 6.242\n",
      "Batch : 61, D Loss : 2.166 | G Loss : 6.124\n",
      "Batch : 62, D Loss : 2.320 | G Loss : 6.085\n",
      "Batch : 63, D Loss : 2.126 | G Loss : 6.737\n",
      "Batch : 64, D Loss : 2.252 | G Loss : 6.092\n",
      "Batch : 65, D Loss : 2.046 | G Loss : 5.496\n",
      "Batch : 66, D Loss : 2.390 | G Loss : 6.025\n",
      "Batch : 67, D Loss : 2.049 | G Loss : 5.764\n",
      "Batch : 68, D Loss : 2.294 | G Loss : 5.353\n",
      "Batch : 69, D Loss : 1.950 | G Loss : 5.273\n",
      "Batch : 70, D Loss : 2.556 | G Loss : 6.479\n",
      "Batch : 71, D Loss : 2.027 | G Loss : 6.512\n",
      "Batch : 72, D Loss : 1.907 | G Loss : 5.601\n",
      "Batch : 73, D Loss : 2.565 | G Loss : 7.373\n",
      "Batch : 74, D Loss : 2.228 | G Loss : 8.712\n",
      "Batch : 75, D Loss : 2.384 | G Loss : 7.407\n",
      "Batch : 76, D Loss : 2.579 | G Loss : 7.034\n",
      "Batch : 77, D Loss : 2.062 | G Loss : 6.939\n",
      "Batch : 78, D Loss : 2.608 | G Loss : 6.352\n",
      "Batch : 79, D Loss : 2.226 | G Loss : 5.870\n",
      "Batch : 80, D Loss : 2.528 | G Loss : 6.487\n",
      "Batch : 81, D Loss : 2.210 | G Loss : 5.880\n",
      "Batch : 82, D Loss : 2.317 | G Loss : 5.851\n",
      "Batch : 83, D Loss : 1.921 | G Loss : 5.078\n",
      "Batch : 84, D Loss : 2.509 | G Loss : 6.861\n",
      "Batch : 85, D Loss : 2.451 | G Loss : 6.088\n",
      "Batch : 86, D Loss : 2.200 | G Loss : 5.315\n",
      "Batch : 87, D Loss : 2.164 | G Loss : 6.233\n",
      "Batch : 88, D Loss : 2.308 | G Loss : 5.804\n",
      "Batch : 89, D Loss : 2.092 | G Loss : 5.313\n",
      "Batch : 90, D Loss : 2.312 | G Loss : 5.361\n",
      "Batch : 91, D Loss : 2.358 | G Loss : 5.635\n",
      "Batch : 92, D Loss : 2.243 | G Loss : 5.745\n",
      "Batch : 93, D Loss : 2.389 | G Loss : 6.473\n",
      "Batch : 94, D Loss : 2.225 | G Loss : 5.830\n",
      "Batch : 95, D Loss : 2.139 | G Loss : 5.547\n",
      "Batch : 96, D Loss : 2.051 | G Loss : 5.265\n",
      "Batch : 97, D Loss : 2.164 | G Loss : 5.894\n",
      "Batch : 98, D Loss : 2.172 | G Loss : 5.499\n",
      "Batch : 99, D Loss : 2.356 | G Loss : 5.996\n",
      "Batch : 100, D Loss : 2.187 | G Loss : 5.309\n",
      "Batch : 101, D Loss : 1.820 | G Loss : 5.354\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-17-2899ecd49915>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtrain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0md_model\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mg_model\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgan_model\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mblue_sketch\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mblue_photo\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'Pixel[02]_Context[08]/'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_epochs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m100\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_batch\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m16\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-8-cd00650cfdb5>\u001b[0m in \u001b[0;36mtrain\u001b[1;34m(d_model, g_model, gan_model, data, target_dir, n_epochs, n_batch)\u001b[0m\n\u001b[0;32m     28\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     29\u001b[0m             \u001b[1;31m# update discriminator for generated samples\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 30\u001b[1;33m             \u001b[0md_loss2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0md_model\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtrain_on_batch\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mX_realA\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX_fakeB\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_fake\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     31\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     32\u001b[0m             \u001b[0md_loss\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0.5\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0md_loss1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0md_loss2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\users\\user\\anaconda3\\envs\\tf-gpu-1\\lib\\site-packages\\keras\\engine\\training.py\u001b[0m in \u001b[0;36mtrain_on_batch\u001b[1;34m(self, x, y, sample_weight, class_weight, reset_metrics)\u001b[0m\n\u001b[0;32m   1512\u001b[0m             \u001b[0mins\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mx\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0my\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0msample_weights\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1513\u001b[0m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_make_train_function\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1514\u001b[1;33m         \u001b[0moutputs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtrain_function\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mins\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1515\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1516\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mreset_metrics\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mc:\\users\\user\\anaconda3\\envs\\tf-gpu-1\\lib\\site-packages\\tensorflow\\python\\keras\\backend.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, inputs)\u001b[0m\n\u001b[0;32m   3290\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3291\u001b[0m     fetched = self._callable_fn(*array_vals,\n\u001b[1;32m-> 3292\u001b[1;33m                                 run_metadata=self.run_metadata)\n\u001b[0m\u001b[0;32m   3293\u001b[0m     \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_call_fetch_callbacks\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfetched\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_fetches\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   3294\u001b[0m     output_structure = nest.pack_sequence_as(\n",
      "\u001b[1;32mc:\\users\\user\\anaconda3\\envs\\tf-gpu-1\\lib\\site-packages\\tensorflow\\python\\client\\session.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1456\u001b[0m         ret = tf_session.TF_SessionRunCallable(self._session._session,\n\u001b[0;32m   1457\u001b[0m                                                \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_handle\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1458\u001b[1;33m                                                run_metadata_ptr)\n\u001b[0m\u001b[0;32m   1459\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1460\u001b[0m           \u001b[0mproto_data\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtf_session\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mTF_GetBuffer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrun_metadata_ptr\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "train(d_model, g_model, gan_model, [blue_sketch, blue_photo], 'Models/Pixel[02]_Context[08]/', n_epochs = 100, n_batch=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}