07 Generative Adversarial Networks (optional).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "Generative Adversarial Networks (GANs) are a modern content-generation network architecture first introduced in 2014. These models are comprised of two networks which work against one another, called the generator and the discriminator (or adversary). The generator is trained to transform noise into content resembling the training data, while the discriminator is trained to distinguish between real training data and generated content.\n",
    "\n",
    "This can be viewed as a forgery detection task where the generator is making forgeries and the discriminator is learning how to detect forgeries. The objective is to have the discriminator detecting forgeries 50% of the time, or choosing randomly if the image is real or forged. As training goes on, the discriminator learns better and better how to detect fakes, and the generator improves at fooling the discriminator.\n",
    "\n",
    "The space of possible inputs to the generator network is referred to as the latent space. Ideally, two similar points in the latent space will have similar (but not identical) generator outputs.\n",
    "\n",
    "# History\n",
    "\n",
    "## 2014 -  Generative Adversarial Nets.\n",
    "GANs were first introduced in 2014 by Ian J. Goodfellow and a team of researchers at the University of Montreal. They showed that this two-model system could be used to train models of opposite, but related tasks. In their work, the implemented the generator and the discriminator as simple multi-layer perceptrons.\n",
    "\n",
    "They based the loss function off of a two-player minmax game function where the discriminator is trying to maximize its score (correct forgery detections) and the generator is trying to minimize its score (forgery detections).\n",
    "\n",
    "<img src=\"./images/gan-minmax.png\">\n",
    "\n",
    "Where $G$ is the generator, $D$ is the discriminator, $x$ is the training data, and $z$ is noise. This is quite different from traditional deep learning models where the objective is to minimize some value. With generative adversarial networks, we are instead trying to balance the performance of the two networks without letting one dominate the other. This can make them difficult to train.\n",
    "\n",
    "In order to avoid overfitting the discriminator, model training alternated between adjusting the discriminator and the generator. Specifically, the discriminator would update for $k$ steps before switching and updating the generator for one step.\n",
    "\n",
    "(Generative Adversarial Nets., Goodfellow et al.)\n",
    "\n",
    "## 2015 - Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks\n",
    "Deep Convolutional Generative Adversarial Networks (DCGANs) were introduced in 2015 by a team of researchers at indico Research in Boston. They applied CNNs to unsupervised learning using the two-network generator/descriminator approach put forth by Goodfellow et al. Up until this point, CNNs had primarily been used for supervised learning for classification of images.\n",
    "\n",
    "Radford et al. had two major goals with this research. First, they wanted to train GANs to learn feature representations of unlabeled image and video data so that the representations could be transfered into a separate model that is trained in a supervised manor. Doing this would hopefully speed up the training time of the image classification network because the filters would have been learned by the discriminator. Second, the team wanted to visualize what filters the GANs learn and how the generator uses those filters to draw new images.\n",
    "\n",
    "The team used three image sets to evaluate their architecture: Large-scale Scene Understanding (LSUN), Imagenet-1k, and a data set of faces. When training on scenes, the generator was able to produce the following images of fake bedrooms.\n",
    "\n",
    "<img src=\"./images/gan-bedrooms.png\">\n",
    "\n",
    "When training on face images, the team was able to perform vector arithmetic on sets of images to create classes of images that were not represented in the original data. For example, by starting with a man with glasses and subtracting a general man and adding a general woman will produce images of a woman with glasses.\n",
    "\n",
    "<img src=\"./images/gan-vector-faces.png\">\n",
    "\n",
    "(Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks, Radford et al.)\n",
    "\n",
    "## 2016 - Generative Adversarial Text to Image Synthesis\n",
    "An interesting unsovled problem is generating a photo-realistic image from a sentence describing that image. In other words, taking a caption for an image and using that string to create the image. Researchers at the University of Michigan, Ann Arbor, created a generative adversarial network that does just that.\n",
    "\n",
    "The network is trained using pre-captioned images. A convolutional-recurent network creates a representation of the string that is given to both the generator and the discriminator. It is up to the discriminator to decide if the string is an accurate description of the image it is receiving. The generator also receives the string and creates an image that is meant to fool the discriminator.\n",
    "\n",
    "<img src=\"./images/gan-text-to-image-model.png\">\n",
    "\n",
    "Some examples are given below. It is important to consider the quality of the captions on the training data when creating these models. If you were to have a large group of undergrads caption your test images for you, it is likely that they will use different terms to describe the image than the researcher who tries to generate a new image from a caption. In the fourth example below, the input string includes \"raised orange stamen\", but none of the generated images carry this feature. It is possible that it was not in the training set at all.\n",
    "\n",
    "<img src=\"./images/gan-text-to-image.png\">\n",
    "\n",
    "(Generative Adversarial Text to Image Synthesis, Reed et al.)\n",
    "\n",
    "## 2016 - Photo-Realistic Single Image Super-Resolution Using a Generative Adversarial Network\n",
    "Z. Wang, et al. were able to show that deep convolutional neural networks could be used to compress and reconstruct images using an encoder and decoder pair that operate on a shared sparse latent space (Deep networks for image super-resolution with sparse prior, Z. Wang, at al.). However, small details fail to be captured and reconstructed by this method. A team of researchers at twitter showed that the generators in GANs could be used to generate high-resolution, photo-realistic images.\n",
    "\n",
    "The researchers generated data by taking high-resolution images and applying filters on them to obtain low-resolution versions of the same image. The generator was then trained to take the low-resolution versions and upsample them into images that fooled the discriminator when compared to the original, high-resolution images.\n",
    "\n",
    "They used a perceptual loss function that uses adverserial loss and content loss. The content loss is based on the ReLU activation layers of VGG19, similar to the VGG loss used by Gatys et al. to minimize the perceptual loss in neural style transfer. The adversarial loss is defined by traying to minimize the probability of the discriminator deciding that a generated image is fake.\n",
    "\n",
    "The resulting images were compared using mean opinion score testing to the original images. 26 image raters were presented the original high-resolution images and images generated using eight other encoding methods, including the GAN implementation. Using a scale of 1 - 5, 1 being poor quality, and 5 being excellent quality, the original images were rated at around 4.3 - 4.4, and the GAN generated iamages were rated 3.5 - 3.7.\n",
    "\n",
    "(Photo-Realistic Single Image Super-Resolution Using a Generative Adversarial Network, Christian Ledig et al.)\n",
    "\n",
    "## 2018 - Progressive Growing of GANs for Improved Quality, Stability, and Variation\n",
    "A problem with generating high-resolution images using GANs is that it becomes easier for the descriminator to detect fake images because of the work associated with generating photo-realistic images at a large scale. To address this, team of researchers at NVIDIA introduced a method of generating progressively higher resolution images with GANs by increasing the resolution of images over many iterations. The training starts with low-resolution images and progressively adds more layers in the generator network as it increases the resolution of the training images. This allows for a faster training cycle because less time and memory is needed to generate each batch of images.\n",
    "\n",
    "They applied this method to images of celebrities to generate dozens of images of fake celebrities that are photo-realistic. The generator and descriminator are mirror models of each other and layers are added to them at the same time during training and growth.\n",
    "\n",
    "<img src=\"./images/gan-faces.png\">\n",
    "\n",
    "(Progressive Growing of GANs for Improved Quality, Stability, and Variation, Karras et al.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Common Problems\n",
    "\n",
    "## Mode Collapse\n",
    "Mode collapse can be summarized as a failure of the generator to express a variety of features of the data it is trying to imitate. If the data the generator is trying to mimic has multiple modes (bi-modal, tri-modal, etc.), a common problem when training GANs is that the mode of the data generated will only represent one of the modes of the original data. This can lead to training oscillation where the generator produces data following one mode, so the discriminator learns that all data from that mode is fake, and data from any other mode is real. Then, the generator learns that the discriminator thinks all data from another mode is considered real, so it switches to that mode, and so forth.\n",
    "\n",
    "Mode collapse is generally easy to detect, as results from the generator will appear nearly identical.\n",
    "\n",
    "There are several methods for countering mode collapse. The first is to encourage diversity in the individual batches so that the discriminator can compare all of the elements of the batch to each other to see if items are real or fake.\n",
    "\n",
    "Another method is using unrolled GANs so that the generator can see how the discriminator will react to a certain set of inputs. When unrolling a GAN, the generator provides input to multiple update stages of the discriminator before the discriminator is updated. The generator can then learn from how the discriminator reacted to the generated inputs before updating itself. This essentially allows the generator to see into the future of the discriminator's decisions based on the generator's current outputs. This will significantly increase the training time because the discriminator needs to be updated several times for a single generator update, and then those changes are discarded. (Unrolled Generative Adversarial Networks, Luke Metz, et al.)\n",
    "\n",
    "The method of experience replay shows old, forged samples to the discriminator every so often so it remembers what forged samples from a different mode look like.\n",
    "\n",
    "The last method for countering mode collapse is to accept that the generator will learn a single mode, and use multiple generators to cover each mode in the data. This way, one discriminator will keep seeing multiple forged images from each data mode, balancing its training. Again, this will substantially increase the training time because multiple networks need to be updated in each epoch.\n",
    "\n",
    "(Mode collapse in GANs, Aiden Nibali)\n",
    "\n",
    "## Overpowerment\n",
    "Another common problem in training GANs is overpowerment, where one network learns how to easily exploit the other. This can happen in the generator, where the generator learns to put features in the forged images that frequently result in false negatives in the discriminator. This can also happen in the discriminator where it starts guessing classification values close to 0 or 1 which drive the gradient down and make it slow to update the generator.\n",
    "\n",
    "There are several methods for addressing overpowerment. Since the discriminator typically overpowers the generator, it can be helpful to slow down the learning rate of the discriminator. It can also be useful to unroll the GAN as described above. This can give the generator more information to help balance the training of the two models. (Unrolled Generative Adversarial Networks, Luke Metz, et al.)\n",
    "\n",
    "# Examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fashion MNIST\n",
    "Here, a GAN is used to generate images of fake clothing based on the fashion MNIST data set. This is based on the Keras DCGAN implementation that can be found here:\n",
    "https://github.com/jacobgil/keras-dcgan\n",
    "\n",
    "Which is based off of the Alec Radford et al. paper. The pretrained weights for this model can be downloaded from here:\n",
    "https://drive.google.com/open?id=1SBy9SzeqhVYy7Y60Cg24PEbskON_JLOe\n",
    "\n",
    "The data set can be viewed here:\n",
    "https://github.com/zalandoresearch/fashion-mnist\n",
    "\n",
    "The generator will take an input vector z of random noise, and generate an image. This network is trained with the loss calculated from how the discriminator classifies the generated images. The discriminator will take an image and classify it as fake or real.\n",
    "\n",
    "Because we are training the generator on loss computed from the discriminator's output, we combine the models for convenience.\n",
    "\n",
    "Training is composed of these steps:\n",
    "1. Feed (predict) vectors of random noise through generator to get generated images.\n",
    "2. Train discriminator with real images and generated images.\n",
    "3. Feed (predict) same vectors of random noise through discriminator, and train generator with this loss.\n",
    "\n",
    "Generating images is done just by feeding the generator random noise. The discriminator can be used to filter out the most \"realistic\" images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.layers import Reshape\n",
    "from keras.layers.core import Activation\n",
    "from keras.layers.normalization import BatchNormalization\n",
    "from keras.layers.convolutional import UpSampling2D\n",
    "from keras.layers.convolutional import Conv2D, MaxPooling2D\n",
    "from keras.layers.core import Flatten\n",
    "from keras.optimizers import SGD\n",
    "from keras.datasets import fashion_mnist\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "import argparse\n",
    "import math\n",
    "import os\n",
    "\n",
    "def generator_model():\n",
    "    model = Sequential()\n",
    "    \n",
    "    model.add(Dense(input_dim=100, units=1024))\n",
    "    model.add(Activation('tanh'))\n",
    "    \n",
    "    model.add(Dense(128*7*7))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation('tanh'))\n",
    "    \n",
    "    model.add(Reshape((7, 7, 128), input_shape=(128*7*7,)))\n",
    "    \n",
    "    model.add(UpSampling2D(size=(2, 2)))\n",
    "    model.add(Conv2D(64, (5, 5), padding='same'))\n",
    "    model.add(Activation('tanh'))\n",
    "    \n",
    "    model.add(UpSampling2D(size=(2, 2)))\n",
    "    model.add(Conv2D(1, (5, 5), padding='same'))\n",
    "    model.add(Activation('tanh'))\n",
    "    \n",
    "    return model\n",
    "\n",
    "def discriminator_model():\n",
    "    model = Sequential()\n",
    "    \n",
    "    model.add(\n",
    "            Conv2D(64, (5, 5),\n",
    "            padding='same',\n",
    "            input_shape=(28, 28, 1))\n",
    "            )\n",
    "    model.add(Activation('tanh'))\n",
    "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "    \n",
    "    model.add(Conv2D(128, (5, 5)))\n",
    "    model.add(Activation('tanh'))\n",
    "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "    \n",
    "    model.add(Flatten())\n",
    "    \n",
    "    model.add(Dense(1024))\n",
    "    model.add(Activation('tanh'))\n",
    "    \n",
    "    model.add(Dense(1))\n",
    "    model.add(Activation('sigmoid'))\n",
    "    \n",
    "    return model\n",
    "\n",
    "def generator_containing_discriminator(g, d):\n",
    "    model = Sequential()\n",
    "    model.add(g)\n",
    "    d.trainable = False\n",
    "    model.add(d)\n",
    "    return model\n",
    "\n",
    "# Utility function combine generated images into a tiled image\n",
    "def combine_images(generated_images):\n",
    "    num = generated_images.shape[0]\n",
    "    width = int(math.sqrt(num))\n",
    "    height = int(math.ceil(float(num)/width))\n",
    "    shape = generated_images.shape[1:3]\n",
    "    image = np.zeros((height*shape[0], width*shape[1]),\n",
    "                     dtype=generated_images.dtype)\n",
    "    for index, img in enumerate(generated_images):\n",
    "        i = int(index/width)\n",
    "        j = index % width\n",
    "        image[i*shape[0]:(i+1)*shape[0], j*shape[1]:(j+1)*shape[1]] = \\\n",
    "            img[:, :, 0]\n",
    "    return image\n",
    "\n",
    "def train(EPOCHS, BATCH_SIZE, TRAIN_PROCESS_DIR):\n",
    "    os.makedirs(TRAIN_PROCESS_DIR, exist_ok=True)\n",
    "\n",
    "    (X_train, y_train), _ = fashion_mnist.load_data()\n",
    "    X_train = (X_train.astype(np.float32) - 127.5)/127.5\n",
    "    X_train = X_train[:, :, :, None]\n",
    "    d = discriminator_model()\n",
    "    g = generator_model()\n",
    "    d_on_g = generator_containing_discriminator(g, d)\n",
    "    d_optim = SGD(lr=0.0005, momentum=0.9, nesterov=True)\n",
    "    g_optim = SGD(lr=0.0005, momentum=0.9, nesterov=True)\n",
    "    g.compile(loss='binary_crossentropy', optimizer=\"SGD\")\n",
    "    d_on_g.compile(loss='binary_crossentropy', optimizer=g_optim)\n",
    "    d.trainable = True\n",
    "    d.compile(loss='binary_crossentropy', optimizer=d_optim)\n",
    "    for epoch in range(EPOCHS):\n",
    "        print(\"Epoch is\", epoch)\n",
    "        print(\"Number of batches\", int(X_train.shape[0]/BATCH_SIZE))\n",
    "        for index in range(int(X_train.shape[0]/BATCH_SIZE)):\n",
    "            noise = np.random.uniform(-1, 1, size=(BATCH_SIZE, 100))\n",
    "            image_batch = X_train[index*BATCH_SIZE:(index+1)*BATCH_SIZE]\n",
    "            generated_images = g.predict(noise, verbose=0)\n",
    "            if index % 20 == 0:\n",
    "                image = combine_images(generated_images)\n",
    "                image = image*127.5+127.5\n",
    "                file_name = \"%d_%d.png\" % (epoch, index)\n",
    "                Image.fromarray(image.astype(np.uint8)).save(\n",
    "                        os.path.join(TRAIN_PROCESS_DIR, file_name))\n",
    "            X = np.concatenate((image_batch, generated_images))\n",
    "            y = [1] * BATCH_SIZE + [0] * BATCH_SIZE\n",
    "            d_loss = d.train_on_batch(X, y)\n",
    "            print(\"batch %d d_loss : %f\" % (index, d_loss))\n",
    "            noise = np.random.uniform(-1, 1, (BATCH_SIZE, 100))\n",
    "            d.trainable = False\n",
    "            g_loss = d_on_g.train_on_batch(noise, [1] * BATCH_SIZE)\n",
    "            d.trainable = True\n",
    "            print(\"batch %d g_loss : %f\" % (index, g_loss))\n",
    "            if index % 10 == 9:\n",
    "                g.save_weights('generator', True)\n",
    "                d.save_weights('discriminator', True)\n",
    "                \n",
    "def generate(BATCH_SIZE, nice=False):\n",
    "    g = generator_model()\n",
    "    g.compile(loss='binary_crossentropy', optimizer=\"SGD\")\n",
    "    g.load_weights('generator')\n",
    "    if nice:\n",
    "        d = discriminator_model()\n",
    "        d.compile(loss='binary_crossentropy', optimizer=\"SGD\")\n",
    "        d.load_weights('discriminator')\n",
    "        noise = np.random.uniform(-1, 1, (BATCH_SIZE*20, 100))\n",
    "        generated_images = g.predict(noise, verbose=1)\n",
    "        d_pret = d.predict(generated_images, verbose=1)\n",
    "        index = np.arange(0, BATCH_SIZE*20)\n",
    "        index.resize((BATCH_SIZE*20, 1))\n",
    "        pre_with_index = list(np.append(d_pret, index, axis=1))\n",
    "        pre_with_index.sort(key=lambda x: x[0], reverse=True)\n",
    "        nice_images = np.zeros((BATCH_SIZE,) + generated_images.shape[1:3], dtype=np.float32)\n",
    "        nice_images = nice_images[:, :, :, None]\n",
    "        for i in range(BATCH_SIZE):\n",
    "            idx = int(pre_with_index[i][1])\n",
    "            nice_images[i, :, :, 0] = generated_images[idx, :, :, 0]\n",
    "        images = nice_images\n",
    "    else:\n",
    "        noise = np.random.uniform(-1, 1, (BATCH_SIZE, 100))\n",
    "        images = g.predict(noise, verbose=1)\n",
    "    images = images*127.5+127.5\n",
    "    return np.squeeze(images)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz\n",
      "32768/29515 [=================================] - 0s 4us/step\n",
      "Downloading data from http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz\n",
      "26427392/26421880 [==============================] - 5s 0us/step\n",
      "Downloading data from http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz\n",
      "8192/5148 [===============================================] - 0s 0us/step\n",
      "Downloading data from http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz\n",
      "4423680/4422102 [==============================] - 2s 0us/step\n"
     ]
    }
   ],
   "source": [
    "(X,_), (_, _) = fashion_mnist.load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def plot_gallery(images, titles=None, n_row=3, n_col=6):\n",
    "    \"\"\"Helper function to plot a gallery of portraits\"\"\"\n",
    "    plt.figure(figsize=(1.7 * n_col, 2.3 * n_row))\n",
    "    plt.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35)\n",
    "    for i in range(n_row * n_col):\n",
    "        plt.subplot(n_row, n_col, i + 1)\n",
    "        plt.imshow(images[i], cmap='gray')\n",
    "        if titles:\n",
    "            plt.title(titles[i], size=12)\n",
    "        plt.xticks(())\n",
    "        plt.yticks(())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABxwAAAOFCAYAAABQt5cBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzs3XncXtO9//+V00GNkUSQBCEhpoi5IqbEPBNjS1Xrwamh\n1SqqrXMc5fSY2qJUW7TU0ChFVQk1TzGHShAhkYEkMpjnVu/fH37f5f1537nWNdxD7uH1/Gutx7ru\n69rXXnutvfbe9/X59GhqakoAAAAAAAAAAAAA0Ij/WNQbAAAAAAAAAAAAAKDz4oEjAAAAAAAAAAAA\ngIbxwBEAAAAAAAAAAABAw3jgCAAAAAAAAAAAAKBhPHAEAAAAAAAAAAAA0DAeOAIAAAAAAAAAAABo\nGA8cAQAAAAAAAAAAADSMB44AAAAAAAAAAAAAGsYDRwAAAAAAAAAAAAAN+3w9L+7Ro0dTW20IGtfU\n1NSjtd6ro/Xxl770pVBfZZVVQv3111/P5ffffz+0NTU1Vawvvvjioa1Xr16h/uGHH+bya6+9Fto+\n+eSTapvd6rpaH3/+859NPX369AltCxYsCPV//etfrfKZ3ud6bL355puhzY+d9tCafZzSounnL37x\ni6G+9NJL5/Kyyy4b2rxftd99LPs8oON1mWWWCW3//ve/K77v/PnzK257e+lqY3lR+MIXvhDq//zn\nPxfRlixcV+tjna91TKeUUt++fUNdx7WeR1NqPq9+7nOfy+WllloqtL377ruh/uqrr1Z8n0Whq/Ux\nFmp+U1NT3+ovq01H72cfgx999FEu1zPH+jpgySWXDPU33nijga1rO4zlro8+7vo64zXUf/xH/L//\n/v37h7rOyX5tPG/evLbbMKHXW8stt1xoe+utt3J57ty57bI9jOWFW2yxxUK9Z8+euezX276G1vV2\nR7ieoo+7vs44X6N+jOWur5Y+ruuBI1CrHj3isdfoDcJVV1011C+88MJQv+6663L5qaeeCm0ff/xx\nqOsiaujQoaFt9OjRoT5lypRcPuecc0KbP5xC/Xr37p3Lhx56aGi74oorQn3OnDmt8plrrrlmqK+1\n1lq5fP3114e2jrDg7oz8YnnkyJG5vNdee4U2v3i+6qqrcnn8+PGhTfsqpZT23XffXN5uu+1Cmz+s\n1Pe9+OKLK206OhF/yDVr1qxFtCUdm56HW/KQTufrbbfdNrQdfvjhoa7nx+effz60+TlZ/wlhxIgR\noe2RRx4J9R//+Me5/MEHH9Sy2Sml1luLoFuavqg3YGH8mFYtOb433njjUNd18CuvvFLz+/g6YNNN\nNw11XbcDQHfl/wj7/e9/P9R1XfSHP/whtP36179uuw0T22+/fS77em/s2LG5fN5557XL9mDh/H7Z\nzjvvnMv6z/kpNf9nwHHjxuWy/nNfS7D2BgCkREhVAAAAAAAAAAAAAC3Qo57/OOGnrB3Tovq5cqP/\nvbTBBhuE+le+8pVQ118vefhSD82k/x3ooTnrMXny5FDXsIz+yzgNsXr77beHtp/97GehPnHixIa3\nSXX2n6R7qC7t8+9+97uhzX8Fo2Ewvc3rGu7Pw4ustNJKoX7TTTfl8sMPPxzaFsV/4HeW8BK77LJL\nLh933HGhzX95pKHV/D8qPTSj/up4hRVWCG3Tpk0LdQ0PM3v27NCmIX5SisfBgAEDQttdd92Vy8ce\ne2xqD519LOs+SymGW/JfrR5xxBGh7v1Yor+Sueeee0Kb/1f49Omf/RBJ/6s3pZTee++9mj+ztXSG\nc7KGxvI5WP+jPaU4hnx/+jyrv0b2Me70l+T+Cyof19rn/t/a999/fy5fcMEFoa2twjd29nGMmjzZ\n1NS0SWu9WWv1s4fh8zDiytc9hx12WC4ff/zxoc3Dk7cWX8fr+fukk04Kbeeff37N76v7obQPqmEs\nd330cdfXWa6hfvOb3+Ty1ltvHdo0zHxK8X7DOuusE9o8RcTMmTNz2e9pvP3226GuUSs8uoSHxNbz\ngkcT0Wt7/fyUUvrP//zPUJ86dWpqDd1pLNezpr/77rtDXSMLeBoKX7erSy+9NNTXX3/9XPZrrwce\neCDUdU3h9wP82C6lJ+pOfdxddZb5Gi3DWO76auljfuEIAAAAAAAAAAAAoGE8cAQAAAAAAAAAAADQ\nMEKqdgEd8efKHprpiiuuyOVhw4aFNg8P9c477+Syh2HUEGwpxZAMHjKiZ8+eoa6h4Dz8Uj3j4Etf\n+lIue3gJD0Wi4SYOOeSQmj/DdcQ+bon9998/lz3sxsknnxzqGlrRQ216WBANn/fuu++GtjvuuCPU\nx4wZk8se8vUvf/lLxW1vKx01vMTgwYND/dRTT81lDfeTUkpLLLFEqJdCnmlYtZRSWnnllStug/+t\n1j2Eqr+vzhkeilFDrL755puh7YQTTqi4PS3R2cfyvffeG+p6fPh49PlR5/brr78+tH3ta18LdQ2/\n4+cB7yudQzT8z6LSEUOq+ji++eabc9nHcem862GQPvroo1DXMebzaulv/dzZt2/fUP/85z9f8bVa\nf//990Obhi9LKaUbb7wxtYbOPo5Rkw4TUrXW8KHjx48P9TXWWCPUdf3qY8XDJetrPTSxz8H9+vXL\nZV8H+OfoecHnCJ0/7rzzztB28MEHp0rqCTPruvNY1nNGtX1Yuk7yc0+tf1eNhnscN25caPN0FxpG\n0j+zO/exKvVTSi3rq1pdeeWVoX7uuefmss9fvqb09YbqqNdQo0aNCvUf/vCHuexpCDwMvY5JX0/7\nGknn3Tlz5oS2J598MtQ32eSz05rO8yk1v6bS9eHyyy8f2nS+XnbZZUObrvdTSmn06NGpNXSnsVzP\nee3ZZ58Ndb0P52tmT0ejfeehT/W483twft9NUxp4mhI/fv3ej+pOfdxdddT5Gq2Lsdz1EVIVAAAA\nAAAAAAAAQJvigSMAAAAAAAAAAACAhvHAEQAAAAAAAAAAAEDDunQOR81VUO17atz8LbfcMrSNHTu2\nps9IKcY+91xi9agnH0ZHjI/suVcGDhyYy56zwGPSa64m34el/eKx7j1GvcelL/1trUo5s1KKeW12\n2mmn0DZp0qSaP6cj9nFLaC6euXPnhjbPEaF5AHr16hXaPL+H5hXynBW///3vQ3211VbL5Xnz5oW2\n2267reK2t5WOGs/+oosuCnXN7+Zj1/MxaW4QH8ue10nbPYeI5xjRz/VjwGneON8G/S5Dhw4NbZp3\nNqWUbrnlluLn1Kqzj2XPvai5YLxPe/fuHeqac8bn3Pvvvz/UNdev5xjUc0RKKU2fPj2Xt91224rb\n3l46Yh9fe+21ob7ccsvlsuc29bwsel7zHC4+B2iOJc+35Lkhdex6zmXfhlrP/Z6rxt9n7733zmXP\n81uPjtjHaHWLLIdjtbWlevjhh3NZ5+OUmufy0jHn7+lrZG0v5WdOKc79nqvVx2Apd5O+VueolFK6\n6aabQl3Hsqtn/3XnsVzK4ej92BZGjhwZ6uutt16oaw5SXROk1LyPd9xxx1z2c09n7+N6jueWvLbW\nv0spjlVfF+h62teMQ4YMCXUd1z6mq+Wes+3tkNdQZ5xxRqjrutivX3wdpGtdnzc9Z6L2pc/lvk7T\nse7j3HMv6rq9lPfX/05zCKaU0s9+9rNcfuihh1KjOvtYrodf6+g1rI8Nv7emfeXHgx932o9+PTBo\n0KBc9vHneRl1vp42bVrxM9srH2tH7+PuqqPO12hdjOWujxyOAAAAAAAAAAAAANoUDxwBAAAAAAAA\nAAAANIwHjgAAAAAAAAAAAAAa9vnqL+m8SjHqV1999VA//PDDc9nj5Gts85RiHqLHHnsstJXyNnqu\nBN0+byu9j8Zib48cG7XaeOONc1lzNqaU0vz583PZY9J7bHnN1zZgwIDQVsoj4zkk/HN0X/n+9hwz\nuv89L8Err7yy0NctjH6mHmMppXTCCScU/7Yr09xZnqdH87GllNL3v//9XF5ppZVCm+aWSCmll19+\nOZc9n4F/jh4fpTwm3d3ll18e6scdd1wue+5Lz7WnuXF9fDrNDeF95d5+++1cLuWDKn1GSjFfysyZ\nM0Nba+Vs7GqmTp0a6sOHD89lnw89R0dpnHm+j6222iqXX3311dDmeUP8vIBPaQ7hFVdcMbRpnlTP\nBeP9qPt3ySWXDG2e90tzBfn6xOt6rvf39dfqNnmbnk88T6S/7x577JHLY8aMSUBHVMqfNnr06FDf\nbLPNclnXpymV17qe12sh+eFz2dfB9VzP+HjV+du3Qcf5jBkzQpvm6EsppV122SWXx44dW3Hbuxvd\n/9X2g7bXcz359a9/PdQfeeSRUNfzt+ZhTymlWbNm5bLnZXzxxRdDffz48bn8ve99L7Q9/fTTNW9v\nZ+f9WE/uRb/GVn7+LuUM9Nfqmn7rrbcObTfccMNCX5dSSpMmTQr1Y445puL2Vbtu6Az69+8f6nr9\n4nnt/Ptq31XLgaf3qqrlwNax7rkWfT2tuQD9PKDHmh8ffhzqnNCSHI5dWem86jxf/VJLLRXqui72\nNb7T48XfR487v682YcKEitvg1xyeT1q/m68DAABdB79wBAAAAAAAAAAAANAwHjgCAAAAAAAAAAAA\naFiXDqlaCj3qoQi23377XPaQRB7GQsNN7LDDDqHt0ksvzWUPL+jhJUrhazykgYYb0PAWHcmoUaNy\n2feZ1j10god70TAhJ510UmjTUDwpxb7ysCWzZ88OdQ3f4KEVfXt1/2+00Uah7Tvf+U4ua6jYlJqH\nm9Dvut9++4W27hxStRSKthRO0/e3h+jQsenheH286XjszuG3qvGw0Q8//HAu77nnnqHt0UcfDXUd\nDx6mx0Pe6pj0fvYwifpePuY0XFFKzcPuVnqfH/7whxVfh88899xzoV4K1+XhyLWPPZSa03BeHmao\nWp/jU7169cplD2+k86GHW/IwpDpf+7nSz+faV9VCVeux468tva/P5TrGfe7w76ZrNkKqoqPwebR0\nfaDhClOKx7yGMU8ppTfffDPUNWSfz6OlUIzVwuWVlK59SqEiPSyghoFOKaVbb701lzV8dErN14b6\nXaulQsCn1lprrVDXfThy5MjQtskmm4S6nns8LP/999+fyxoyNaWYmiOllDbddNNc9us2T43y0ksv\npe6invFXmku8rRTC1M/JK6+8ci57CgIN5+hzm6bJSCmGzPd1QGe9NtP50kOW6jzmc5qGmXc+X3td\n+dzpY0fbS2F1vd3ft5TSwo+XIUOGVHwtPuXHu/eb0rkxpebnPD33+773z9F+9HswpdDqN910U6jr\n+trndt8+UtkAQPfALxwBAAAAAAAAAAAANIwHjgAAAAAAAAAAAAAaxgNHAAAAAAAAAAAAAA3r0jkc\n64l9vuqqq+ay5xvw+Pa33357Lm+44Yah7eyzz87lJ554IrRNmDAh1J9//vlc/vKXv1zcvnHjxuWy\n5lDTPAmLmuYo9BwppXyanrNAcxpccskloW3HHXcMdc2veNlll4W2b33rW6E+ceLEXO7du3fF7Usp\n5t8899xzQ9vRRx+dy57rwL+L5tv0fCgeU3/y5Mmpu9AxVS23qfbNsssu2/BnlnKDlHJhIPrlL3+Z\ny9/97ndD24wZM0J93rx5uez5/DwXreeGUD4+9b287zzHiL5vz549Q9vYsWNzmTyAtdF8OynFnD9+\nrvS+0Ly6nt/D+18/x/vfx7LnwcGnNE+m70PN6ej95nXNoep5lKdMmRLq06ZNy2Uf856LVds9d5Tn\nXtTvsvvuu1d8Xz9HeD5sz08JdASlPGspxVxJnpdRrwMGDhwY2vy1mlerWi5DnwdaSyl/tu6H0nk/\npZh3ynMKXnPNNRXft6urJ++d5rEeMWJEaPOcW7pG+t3vfhfajjvuuFDX84RfQy2//PIVt/WFF14I\ndc3pqPnBUmp+PulOORx1bHquvJIVVlgh1DXXZkop9enTJ5c9L6f/ra6933jjjdCmx46vu5988sma\nt7ezWm211XLZ59HFF188l33t6vtR97H2TUrN52/Nr+1rZL83oe2+9vJrKn2tH2ta92s6N2DAgGI7\n6sth6uc8f60eS3feeWdoGzRoUMW/1ZzoKaX01FNP5bLf8/RrPM0vPX369EqbnlLqXufktqL3rlda\naaXQ9uCDD7bz1gDAwvELRwAAAAAAAAAAAAAN44EjAAAAAAAAAAAAgIZ1qTiCpVAEHorFQ4VoODcP\nueWhL7X++OOPhzYN6eKhvDbffPNQ32effXLZQ1r4+x5++OG5/NFHH+Wyh21dlNZff/1cnjlzZmjT\nkCIa9mNhlllmmYptt912W6hriKV11lkntJ1wwgmhfuONN+byHnvsEdo8hIiG+9OQPinFMCZ+rHiI\nCA034uEm/XjoTiFVdWz48eBhkjSslodzqRZqUZXCBnq4GXzGx4Ye/1tuuWVo++lPf1rxfTzcjocD\n0jBDGiptYdugdZ0PUyqHgfO2m2++ueJrsXAeUlPPXT7+fLzq2H7uuedCm4fm0b7ysFM+Z5TGfXem\nYQUfeOCB0HbwwQfn8tChQ0Pb//3f/4X6pEmTav5MDdGnY3phdT1/+hzs4RPHjBmTyz/60Y9Cm66X\nPOybzzseSgroDHy9qDT8sM+FpbBlHoKtFL6tNefYUkhV/Rzfdj9H6Jzh13QeUrWeMKOdXWnN7PtB\n1+K+9vbzgobw85QVO++8c6hr6hE3d+7cim0abjWllF5//fVc9pCMhx12WKg/9NBDuawpNLqiUh8P\nHjw41M8777xc9pDjHsp+3XXXzWUPn69tKaV07733Vnytzkm+Rm+tFBalVC2Lmoas9++v/eXzqoeh\n1O/oKXT8b3U95ddXfozout37w9dM+rf+XTR0rq79Ukpp6aWXDvUFCxbksoft1PQb3Znf0yiFPfdx\n7vejdM2g+z6l5seOhsvWcZ1SDNWp6/CUUjr55JMrbl894WFRm/333z/UTz/99Fz2+6MenvnZZ59t\nuw37/+l1ZUopvfjii7n82GOPtfnnA+iY+IUjAAAAAAAAAAAAgIbxwBEAAAAAAAAAAABAw3jgCAAA\nAAAAAAAAAKBhnS6HY6N5RDTOdUop9evXr+JrPQ69x1D/+OOPc9lzmGkeEY+Zr3kBU4r5Hv0zjjnm\nmFDXvEP77bdfxW1vT57fQ2Pw+/fRuPTeh57XyWPNlz5T8wl4n3o+Of1cz5np21TKl6M5zDynSCmH\no+el22qrrUL9D3/4Q8XP7Go0Z4Tve69rLreWvNaPSX2t503AZ0o5JGbPnh3qU6ZMCfXVVlstlz0/\nkOeO0bHir/Xci5rLxHOBlPrZ86OgfvPnzw/1VVddNZc915/3o47Janl89DxbLS+Zz+f41Nlnn53L\nvh655557cvmpp54KbZ5HWfu1lPslpXj+fvPNN0Ob95PmdPH37dmzZ6hr/iifZzRviOc58vWE5yDC\np0pra8+9U0+OOB3npXOJ8znfP6dWnvfPt6Gz5BXS9aPmR0upnL/M+1XHoO8bH5/ad76f/DO1v7zv\nqv2t0m3yserfW/O8eu4gz+HenehYqXZ863Hl/bbtttuG+lVXXZXLRx55ZEs2saI+ffqEup6Lnnji\nidDmx4fmdtb38fNQV1Ba8/j58Rvf+EYul66v66XX/J6DecKECbl87bXXhjbPA146n/i1mc5n9ZxP\n2ttyyy2Xy36dpGsbvw9w9dVXh7ruK7/H4bnMdSyX1lopxTlY19oplc8Lnn91+PDhuex99/zzz4e6\njuU111wztJHD8VPVcpHqPUe/9vUcfb17987lXr16hTbP76e5czUvZ0oprb766rnsfYr6VVvb6n3F\n888/P7RpPs2UUpo6dWour7feeqHt4osvDvUtttiipu3TvM4pNc+VrHOb37/16y+f67s6PT/Vc21x\n7LHHhro/L9B5V+fclJrPnc8880wue27l1vKjH/0o1HXu+etf/9omn4nOjV84AgAAAAAAAAAAAGgY\nDxwBAAAAAAAAAAAANIwHjgAAAAAAAAAAAAAa1ulyODaab8XjlXssfI1973HxPdeUxrf2HFUaz9rj\ncnus/hEjRuSyx/TWeOoppXTbbbeljuakk04Kdf3uHsdb49J7zG/fh5qXQXNiptQ8v4fGqPe8Ayus\nsEKoax4C/0zPDbPsssvm8oEHHhjaNBa+52X0vFOlvDv+3boTPd7ff//90OY5O0p5GUv5DqrNFeTy\nan0+jy299NK57POhz7OaC87Hio9XzzmiSnldPP8I6uf5PZT3v8/J3q58vOrflnKLpdT8/I5P3X77\n7bm83XbbhbZ99903l3fcccfQ5vmEjzrqqFzWc2NKMb9LSnF9VMr9l1Ic5z6mfb7Q/GGe/1XXIv4+\nfmzss88+uaxrsJRSev3111N3Vc/aup48JfXk2dLj7L/+679Cm+fLrlVnze+6/vrrh7rmzfG8qZo/\nzY9/z62m59JquYS0Xi1XZ+m1Jb4N2l++3vM8VPpdO3I+t/ZWz1jWufT+++8PbV5X1a7jSttQmj/8\n2lznZJ/3x44dG+r9+/fP5YEDB+ayX6d1N5q30cebn5PrmS81D7SeV1OK591tttkmtJ111lmhXrqO\nK7V15Dydml/Pc6KNGjUql3VeT6n5fQEdg8OGDQtt/p113i3NqynFtZcfA37O0PssM2bMCG16/b7Z\nZpsV32fmzJm5vMEGG4S2Bx98MKH63H3IIYfkcrWxrHOnz4F+vtTrrdJ8ed1114X6z3/+81A//vjj\nc9m/i5/PO0v+7NZWypeeUlzneK7TadOmhbrm7/Px5/eRv/a1r+Wyzt0ppbT77rvn8ujRo0Obn+t1\nTrr88stDm+cR7W50DFZbk26//fa5fM0114Q2z8u4995757JfG/g91KOPPjqXNcdnSik9/vjjuew5\nsSdNmhTqq666ai77/QNdX6UUjxFyODZG5wU9NlJq3o+ap7uzzKv8whEAAAAAAAAAAABAw3jgCAAA\nAAAAAAAAAKBhnS6kaqOWWGKJUPdQBKUQj2+99Vaoa3gS/clxSvGnrP4zV/9M3SYPG+IhiVZeeeXU\n0YwbNy7UV1xxxVz2MGvLLLNMLi+55JKh7cUXXwx13RePPPJIaCuFfPJ96OElNAxftdCc2lcexmfy\n5Mm57MdVKRzorFmzQttf/vKX1F2VQiv6PtQ+Lu3fajwMo4ZU9dATqEz3uY/HV155JdQ1BJD3lYe0\n1bnTQ3H6+NRQPR7+xUN7aciiV199NVXixwch2mpTCk1cCu1QCsmXUuxz73+fvz3EID515pln5rKH\n1NLz0fPPPx/a9thjj1A/5ZRTKn6Gv68eD95v3uc6xnxu9zlAw5J5mNTHHnsslz3kr4cO0vVGdw6h\nWlItREs9c+NXv/rVXN5www1D2/777x/qOpfPnz8/tI0ZM2ah71mNh+f+wQ9+EOr/+7//W/N7tSc/\nH+n48P7QNXW1uVLHVbVrFG2vFn610dD3/r6lOcGPO33flVZaqeJnoDaltXdK5fW2t5X6vERDUaYU\n03P4ceXbq+cI1m+fKYWwLYVQrbYmvuKKK3LZ53I9Hvx+gIfoK4VwXGeddUL9V7/6VS7r9UZpjbIo\nXHrppbl8xx13hDYNmXjssceGtsMOOyzU11prrVyullpCz3U+dn09pceEv4/fA9PUGJtuumloO+CA\nA3L5uOOOC20+Jx955JG5TEqTz+g8Vm3e3GGHHXLZ10i+v/X+lPd/KS2Jpy5SV155Zaj7nHDTTTfl\n8l577RXaOmqov0bpHOffrfRdq/XxxIkTc9mvddZdd91Qf+ihh3J5/Pjxoc378YILLshlv1fz9NNP\n57KHydXtSSml2bNnV9x2P0frOaSzpjdQ1dbBOh507k4pzpUpxfG6yy67hDYPl637TkNT+2emFEPe\n+vMLfZbgc7mnHNLj9Nprrw1tHvp+yJAhqatqrZClgwYNCnVfs2i4ZA9D72Fqzz333BZvTzXHHHNM\nqOscofNOrfiFIwAAAAAAAAAAAICG8cARAAAAAAAAAAAAQMN44AgAAAAAAAAAAACgYZ0uh2Mpp4jH\nxdZ8Dv379w9tHj9e64sttlhoK8W3X3bZZUOb5nf0/H6eS0ZzA/bs2TO0PfPMM6Gu32WTTTbJ5eee\ney4tKr/+9a8r1jVHQUoprbHGGrl81FFHhTaPVax5lTx2uMe11rj0ns+jHqVcNp43QfvK++nggw9u\neBu6Mj8etK+qxceuJ0+j8tjqno9E+9XzimqOQO9/VKYxyFOKfefznx8T+rcek95zEWheA3+tz+26\nDeT1aX0+zkpKOY69XmrzOeK9996reRu6kxtuuCGXt9tuu9Cm64ixY8eGNs8XoDluZ8yYEdpKuRd1\nHk2p+RysfGx6HiFdh2lO6JRSGjhwYC5/73vfq9iWUkojR47M5aeeeiq0aY6Crq40pqrlhNCcXJ67\na8SIEaG+44475vKUKVNCm+eR0Vysnh991113LW5TJV/5yldCfbPNNmvofdrbRhttFOo6rkprJL9e\n8fxoei1RyuPkn1Ntni/l2nbaXnqtr/0895teQ2muv5Sa9/Ojjz5a3CZUzy2l7X5clfqxnhw4vhY/\n9NBDc/lvf/tbaPvjH/8Y6noM6PmjnjVKV9Rojp9q+037w/Mh63Wy55HadtttQ13PA7pmWRi9bjjo\noINy2fPZdSTTp08P9X322afiaydMmBDqW221VS77+bI0rurJz+vXZp4TXa+/fJxrv//3f/93Qv1K\n43PYsGGhvtpqq+Xy1KlTQ5uvt/Xeha/bBw8eHOp6bJXOA34sb7HFFqHuc3Jnp+PG58P2OK+ceOKJ\noX7nnXeGuubJ1PVQSs1z/b322mu5/O1vfzu03XfffS3azv+nnhzBHYnOh6V7E9XWSDvvvHMue07b\nCy+8MNT1emjNNdcsvu8KK6yQy76P/VmDroN83td1m7f5fZTrrrsul/1Y11yQKcXzsuam1GOuIynd\nb6onH6vnxvUcq3vuuWcue95LN3To0Fz2ezB+v3TLLbfM5QcffLD4viUbb7xxLl900UUVtyelmJ+X\nHI4AAAAAAAAAAAAA2hUPHAEAAAAAAAAAAAA0jAeOAAAAAAAAAAAAABrW6XI4aixdjyXvsZUPPPDA\nXF5xxRXYr5q4AAAgAElEQVRD27x580Jdc4N4rGLPKaGxiz0HiuZ/9NjVnr9IP9NzlP3qV78K9Q02\n2GCh71OKQ7woaY61lFJ67LHHctlzrHk+B+1jzy3gfaHHQLV46qUY3f632o/exxonf9y4ccXPxKdK\nOVPryS9S7bWlHK9Ojx3PMULexsZ4Xp/SmPQ27Q/PReGv1fllueWWC21LL710xc/0eOtouXpyrOr4\nrJbnS9/Xx72f6zXHID6zzjrr5LKPzTlz5uTyI488Eto8L4vG8ve+KPWjj1v/29I52d9X30u3PaWY\nN8bzMHqeG81rMnny5Irb3lH5eNP94uulUo6+0rnUc5P/9Kc/DXVdW3uuzdmzZ4e6rv18/vWcfJMm\nTcplzQOSUkqnn356xe318a/b94tf/CK0rbXWWqGuOSyefPLJip/R3ko5uHxc1ZMnR9/X86Z6/nqd\nZ/36xbehnvOAHnv+mboWK633U4rb7+/juVy/+tWv1rx9HV09ORHbi5+TS+eFUh4kz8WneXY173BK\nKf32t78Ndc1LptdmHWH/tKd6jo9Svqp69pvnF9R1eO/evUOb5+LUz5k7d25o87nt3nvvzWU/13Qk\npWtRrfv38xyOmo+rlLs3pXh+9bm9NF/7WPXP0XO8n5dLGp0DupvSdbLmwE4pHi++vvP7FnrO9uti\nP1/qWOrbt2/Fz1xllVVCW2lddvnll4f6N77xjYqvbWu1zmvV7g0qva98yCGHhLZddtkl1P0+Z608\n9/S1115b8XN8TPn8oON4v/32C22lHI4+jjU/r+YET6n5mr5///65rPdtXnjhhYqftyhov5fmSs+1\n6N/jlFNOyeXDDjsstPm+0mvTq6++us4t/oxfr+200065rM8OUkpp0KBBuex5zzWnZEpxHtAckik1\nzxupc5GeI/xZQGuodN+gntyLLVkT6hzo18Y+VjR37rRp00Kb573WHKx77LFHaHvzzTdDffTo0bk8\nfPjw0LZgwYJc9vWFH78DBw7MZc8Fueqqq4a653SsF79wBAAAAAAAAAAAANAwHjgCAAAAAAAAAAAA\naFinC6mqIQJK4aJSSmnixIm57CEdPbST/gy2Wrg2DVugP1319/WwgB4eSH9q7OFIDjrooFA/55xz\nctnDn3UU+tNm37/aV/5T5rfffjvUS31RTyiE1gqjUwoL4j9zLv1ttfByXVk9Yfjaaxs8pAhqUwox\n4mF8NHS1z9elUAve5n+rYTs8BJOHg/GwEWhdpbDepXBdHu7Fjx19rYfz89d66Ad8SsOn+D7UsCce\notTDZOr+1rAfKZX7sVrY+xJfL2loEB/jur0eOspDgGn4GQ+17+FXO4LSGHLV1sRqu+22C/V99903\nl3396evc5557Lpd9LC6zzDKhrukCPKyvH2caMtGPSd2mE088MbT5+2pYOj/P+7rcj+eOorRdPua0\n3z2ETik0q6vntS2h2+jzUq3hVlOK2+fXeN7PXUlnuHaoda73kF//+Mc/Qv2aa67J5d133z20aeiw\nlGJIaQ2dXU/I4a6gJcdHtdQklay//vqh/swzz+SyhtVLKaWvfOUroa7njJ/85CehzdcBd9xxR0Pb\n1960D3wslPbxe++9V7GtlN4lpfLaqxTO3rfH31e3qZ6x1J3veZSU1sV+zjv22GNDXVMGeHi8Ukh9\nv8/mNJS1XjekFM+z/j4eJnX69Om5PHLkyNDm87eHVm4vpXQdJeedd16ob7rpprns6zUPc3nRRRfl\n8tFHH13zZ7ojjzwy1DVU/DbbbBPa/LpY51nvNw0T6XOsX0PpNZbf6/XrAZ0vXnzxxVx+9dVXU3uq\ndn9Y56ovf/nLoa1Xr165/O1vfzu03X333aGux7jv/6uuuirUPaytqnbPQ/l96D/96U8LLacUw2Ie\nc8wxoW2HHXYIde1bP4f7XNMWoVMr0b6rZ/zquPfwtpqaycNGa/+nlNKQIUNy2Z/d+PpV17d+PXXU\nUUeFuvZjtXWOjisfn5r2z/vJr5P0/qmvtW699dZQ17C6+lq//q6EXzgCAAAAAAAAAAAAaBgPHAEA\nAAAAAAAAAAA0jAeOAAAAAAAAAAAAABrWajkcPT6yxyjX2LX+Wo1FWy1/QCmOsdP4sx4X32POapxb\njwmsechSit/NY92X4tt7m35X31/Dhg0Ldc9d0hHpfivthylTpoS6x4SvJ0+nfmY9ORxLeZD8cz1G\nuaoWF1+P+3ryV3U1pZyNPubryRvUkr8t9Y22NZrTpKsq7RvPn6axzz1fV+/evSt+huaTSCmlJZZY\nItR79uyZy9XmCB3rAwcOrPi6es4t+ExpLvXxWE++R1UtFyA5HBdO97/mnk4p7kPPP+LjrbRW8Xop\nT2fpeKg2l+sazT/T5wvl84yuLzwvRUfM4ejrmHrWEZr/x3O/aD6GlGIuCs2BuLDP9L9VpbxN3qf+\nWl1rey5INW7cuFAfPXp0xdf+13/9V6h7/pwZM2bk8te+9rXQ9tJLL1V837b24x//ONR1Te3nKs37\n5Me7j41qa9+24ONVz9l+DOh38bW3z1Oay9mv6fbee+9Q1+9NLrHWV0++3pNOOimX/Xj99a9/HeqH\nHHJILnsuWc8xo+u7evLZdifVrpP1/Oh9WMoD6LmB9Nq4njnn5JNPDnU/rq677rqa36uj0u/kc3kp\nJ5rfVynlufZcgP45petfnVdTin07efLkVKt67sl0J6W50dcrmo8rpZjnS9cuKaW01lprhboeS+++\n+27N21dai3ubX9frOt3nhF122SXU9X7BmDFjat6+RjSa9009++yzoX7wwQfnso8Lv8+p65Ezzzwz\ntHk/lvgcoDnjfG3r+dseeuihXH7qqadCm675X3755dD22GOPFd9X+TyjOdx1fV/KVdsSlfJzVutz\nzafn9xO03++9997Q5nkP77nnnlzecsstQ5uvVzSnpSuda0ttC2tXek3Yr1+/0OZ5IzXPod5zS6l5\n3kidX2bNmpXLbZ0/W/vb579SLkbPsar3PPw6o3SP47nnngttW221Vai//vrruaz5ElNq/mxJ58Nq\nOU713O95I/W7+TjzNYN+bx/3/nxDc5tqzsvZs2cXt/X/4ReOAAAAAAAAAAAAABrGA0cAAAAAAAAA\nAAAADeOBIwAAAAAAAAAAAICGtSiHo8a19ZjkbZUPa+utt87lfffdN7RtscUWoa6xxT33g8egLuUt\n8Bjl+r09Tr7mdPQ4yv4+pe3xeOv77LNPLt98880V36ej8Fw9uk8914rn2tB96seRx5iuJ651KbeU\n/63Gnvd8Vvo+5H2rjec6LcVW937TY8f7rZQb0pXinPs26Hj03GfdXSmnpccknzhxYi7PnDkztPm4\n0v3sOcJ8jpg2bdpC/y6l5rHmNb6452xD/YYMGRLqOlb82PD5WlXL76h1b/N5V+PJ4zOl3NnaV5pn\nIKXmOXz0tdXOnaW20lzvuR58baXHkm/DnDlzcrmUqzKleM7wnLMdxUYbbZTLniNkzTXXDHU9t/r8\npjk4POeG54jQedPP16Xzt69rPQeV9rH3hc8Pepz5OlH7VXNJpBRzhqQUv7fmpkyped4UPQ8dccQR\noU1zzbW3QYMGhbquSX1saH369OmhzcdyR8hlqNvg53btOz8+fHt1LPtrdY2wsL9F6yrlVT711FND\nm/abrxn322+/UNfx6n3s811b5wtqbX5OLp2vnc6VrZlnXt+r2ph5/PHHc1lzV6WU0k477VTzZ5by\nM/t8VsrX3BWUjmk/DzvNz1RtLGg/+znb/7aU73GllVbKZT/XLop8wR1RtdzV6hvf+Eaov/HGG6Gu\n+9tzjT3zzDOhvsYaa+Sy5i9Lqfn5Uc+7pfy3Pif4dbzeu7zrrrtC2zHHHFPxfdtSjx49wjGu2/zW\nW2+F15bmvEsuuSTUv/rVr+ay5/Y77bTTQv2RRx7JZZ8b/X01b+fw4cNDm68LdU7w/tf5OaXYNz6X\n6PGw6aabhjY/zjRHnOef9Pl7wIABuTx27Nhcbqv1WKPnQp27PL+lrjs8V6fe40op9t348eNDm47d\nlJrnOFWlPK+utC/9WNNrnNtuuy206XyRUnxu4td5Pm50e/V6rLXvkffu3TvtuuuuuX7GGWfk8mWX\nXRZe62tLzUnoz4R0XeHPX/r27VvxtZ6D3PMp6vrVx9yFF14Y6nq+9FyL/rd6TvF8lKVt97qe6/1+\niL/Wc5vWi184AgAAAAAAAAAAAGgYDxwBAAAAAAAAAAAANKxFIVXr+cmv/uzUQ0boz3i9TUOJphTD\nufnPkT1sgf4EuE+fPqHNQzBpuCYPb7r88suHuoYb8HAC48aNy2UNUZBSDAebUvzpt/882UNa+M/q\nO7rST7z9J+9+HJVCXXofl963FG6zFMrGP9ffV19bLSwAYZw+VU+4xNI+a80QLaX3Kh1nqGyrrbYK\n9alTp+ayh0by0Ica7mCZZZYJbR4mVcPtefiXfv36Vdy+FVdcMdR1bp87d25oqycMTney9tprh7qG\nIvHzlodqUj4/1zMe/dyvIXhHjBgR2vSc3J35/tbj+bXXXgttHoaxpBSq1UPgeT+WQsiVQqG6Ugio\nUnj3ekJyt6W+ffumAw88MNd13VsKiZlS/O4+3nQN7H/n61Ptt/feey+0eThW7VefFz30i36uhwL1\n/a/f1d9Hv5ueK1JqHrZHw5B5m+/PjhJWV0NPpdT82kLD+HibHgPV1sGl8Mj+t/WMZeVj1+v6tz6X\n67nezye+ZtB1gvezhrbqLEppStr781NqPmfotbGH2FprrbVC/ZxzzsllD2OsfXP88ceHttL6f4MN\nNgh1Dy/38MMPV/zbtlRPao/S9e2i6HNXWudef/31oT5hwoRc/uY3v1nx76rNMzq3+Nzm4e26gtIx\nvvnmm4e6zoF+b8rHq86lfp7zebYUUrWURsjfV6+hPKRqae3V1ZTGebVrxz322COXPeyir710//t1\nsq/pNLyfHzsDBw4Mde1j/0zd/mp9qNf8hx9+ePG17WWxxRYL4QB33nnnXK52L1DHgq+LdT279957\nhzYPQ6prtIsvvji0eVhGnQ99DTRp0qSK2+AhMj00qo9PpWEZ77///tC2/vrrh7qGyvV1q88lGoK0\nI99D0TQNpRCVfg/J16Qamtb3zeDBg2veHl9v630tH/c+Z+g51LdBry09zZGHb9bj3Y9Dv+bWz2zL\nVGNvvfVWCM2rn+XH+7rrrlvz+2oYVT/HrbbaaqGu+8KvaX39ou/l52uv67WPv08pbaEfKzr3eHhY\nn8NKY9L7WO+zadoXD6dfCXfVAQAAAAAAAAAAADSMB44AAAAAAAAAAAAAGsYDRwAAAAAAAAAAAAAN\na1EOR80rePrpp4e2vn37hrrGRC7l5vHY4R4LWGPTenxZj8Wteb48j9MBBxwQ6k888UQue04Xj32v\nscDdeuutV/F9PF6yxgb3mMEei93jrXclHmNa40h7jONSTsfWzO+n7+uxq/VzOkoOqI6utfZTtfwo\npTb/W90m3z6Pid2dlfKveJ6kddZZJ9Q1n4PHxV9uueVC/aWXXsrlJZdcMrR5DHU9T3g8+xKPZ37Q\nQQfl8nnnnRfaOnK+gUVpu+22C3UdV36s1JOftdRW7TwwZcqUXD7qqKNCW3fO4VhrPlzP3eB5OEr5\naLyPdc1Wyo1cbft87Vc61+v6ydeQnguw1rb29Prrr6crr7wy1x9//PFc9pykQ4cODXVdG/qas1ev\nXrns57RSXj1fv3tdjwEfm54rSD+3Wm5knZ8914Su9/3Y8M8s5WT399X1/S233FLcvrbk+Y+d9pd/\nJ903nlPG8wPpetbHn4/tRufrevh1nF4X+fb48a3Hln/vzrg2L+XHKq11W6svquXN1b7x6zbPxXj3\n3Xfnst4rSCml/fffv6HtK63hffvak25XPWueEs+Jedhhh4W65sicN29e8b103q2Wc1fHkd/X0Xx9\nKaW07777Fj+30meW2r1PdW3nSrkzO7LS/lh99dVDXc91ntfJ12l6LvPzvd/HKG2DHxM6rvzcs+aa\na+by+PHjQ1tn6pOWasl3Pe2003JZc8ClVM5/6/3k9ya33HLLXNZceik1n+tHjhxZsU3vpfox5+pZ\nU7fX+P3kk0/Cuk/zIPp+0eM5pZgv3PP3XXbZZbns/eT3LM4///xcvvHGG0Ob56nVMeb3n9dYY41Q\nnz59ei7r/eeUml/Xad/4ONZ+HTJkSGjzaypdq2qe0JSar/H79++fy3Pnzs1ln49aw5JLLhnyPGu+\nwjlz5oTX+nfSOa6Uh0/HQkrN79Wvvfbauez7YsaMGaGuuUR9vvZrHL0n5nO3v1a/i+f81LFd7f6d\nHhM+7r3/dG3wu9/9Lpdff/311JqamprCZ19zzTULLbcm/+66/z2HY+l5QbW5UfvG38fri/rcqtdi\nfk1dCb9wBAAAAAAAAAAAANAwHjgCAAAAAAAAAAAAaBgPHAEAAAAAAAAAAAA0rO5EZRpf/5e//GUu\n9+vXL7zOY4BrvZRnweNKl2KJu549e4a65rY588wzi++jeZ9mzZoV2jw3yF133ZXLmqMspRhfu0+f\nPqHNc5VoXGCP9ezxeqvlaOho6okv7PGnVbXjQeMje+6MUi4Nb/OY2No3HkNd36daPPtFHWe5o/D9\nrf1YLS9jKe9TPTmGSu/jn6lzicbw745KuT522mmnUH/uuedCXWOW+370fBOvvvpqLnv+Gt+GV155\nJZeHDRsW2l577bVQ13nYcxpoHiLPnaI5JfEZz8ek5yrPv1Oag+vJk+pjt5R3aPPNN6/5fbFwvn91\n/FWbnxvNNVYtv6Oun/wzNceGj1vN6eHv05p5n1tKt2XixIm5/Oijjxb/TnNIeN4YndN8vtXcKinF\nPq/Wx3o8zJ8/P7R5ntwFCxbksudNKdV9jV7PdUOpX317Nf/EolyvVctpo+vQ0pjzXMmla4tSv3q7\nv9avZ0rrq1I+RX8fncu9zfNR6vuWriO6grY6Nkt5tEo5JU899dRQ9+vm9ddfP5cPPPDAFmxh5e3x\nPOB+vLSVHj16hPWL7sNq+ZU0L+IRRxwR2jzPlPK5fa+99splzzvmSudvv7+heZ0OOOCA0LbrrrtW\n/Aw9B6cU5+9q84zmGva2Bx98sOJndpYcjqXv7+tgz5Op/VPtWll5bikfGzqWqt1/0nZvKx171XJ3\ndmWlvKmbbLJJqOtc6euTTTfdNNT1Gvbll18Obb721TxbG220UWh75513Qv2hhx7KZb/G02PJ/86/\n21tvvZVq1V5jtqmpKcxHet2vc09Kze8jaw46f63mJFxppZVC29NPPx3qq6yySi57zsZS7kXf33qf\nJKW4jvfrNl9Daz/6/KDHq36vlJrPUdrHntfSX6tzVCk/d2v48MMP07PPPpvr2id+veP35/XcO3v2\n7NCm+3WZZZYJbb4G0f2qeRdTaj7PnnzyybnsuVv9b0v3S0rnAb8/pn3nY9XHY+n+tu7nlOK+vuKK\nK2ratkb8+9//DvcStT+8b/y6Q895vi7T15bWvSnF/eTjyNdTpfOsKz3PKL3W31frvn1+HJW+q7+v\nXmfrHFF6Lhfer6ZXAQAAAAAAAAAAAMBC8MARAAAAAAAAAAAAQMPqCqnap0+ftOeee+a6hiydMmVK\neO1SSy1Vse5hcZT/hNd/3j5z5sxc9hAuSyyxRKhraL0//OEPoW3vvfcO9ZtvvjmXPfSUf5eNN944\nl0eNGhXa9CeoHsLCf9rqYaCU/8xV94uGPCmFYOksPGRpKUyS/0Raf5bvPwf312p/+Gv9Z8baXgrl\n5eGrsHA+rnWc1PPT8dYMwVEK6+pjFQvn4RqeeeaZUNcx6PNdaR+XQrClFMe9h+YohYjysK5a93mf\nkKoL5/tJw794CIbSePU+rmds+9/qud9DvOhx5ueark7D8VQL76I8PFrp3FkKjVMtBJjWqx0PGsqr\nFPJzxowZoc3DV+kxUG2eaS+ffPJJCCeqfeXpCkrnSw3/lFJK9957by57uKVSCM9qfaH729/X/1bn\nfV9n+d/qWrtv376hTcPl+HrCv4t+jl8XeIgq/dvp06eHNg1t29buu+++Yrv2gY+5UtgeX0OXjv/S\nurgUniileFx6m/9tadzp9vvx4nX9bh05pGKtSmtdvdZYYYUVQpvPETruq6lnv/3kJz/JZT+ufC04\nevTomt6zWmh1/Rx/rYczay9NTU1VQyBXoqENvR+1L3wce5g7nR/32GOP0Kb3M1y1/v7jH/+Yy7fd\ndlto8/s8qtawWguj+0FDXKeU0rhx4xp+346idM72MHAagjyl2M9+7tKQmSmVw2U7nYN9+0rnBR+D\ngwcPrvgZfp7qLCFwKymFrvPvWloXn3322aGu52TfL349q6EL/VrMr29eeOGFXPZ0Jz736P1cX/do\n2Fz/Xj4PetqSjuCTTz4J1/r6HfyegPex7lN/ra63fSyuvfbaFd/Xwya/+OKLoa7jz9fIvn163TBp\n0qTQ5vfaNVSop63R7+mf6aE3dY7ya0W//tLP0XQLbRFS1a+j/vSnP9X8t6V9rtdj/jzA+0Pncx+P\npRClfi/Z52TtO58TfE7Wax5/X/2ePnb9GNZ1vB/7fl9c0xz5dWhb0u3q7umvOjp+4QgAAAAAAAAA\nAACgYTxwBAAAAAAAAAAAANAwHjgCAAAAAAAAAAAAaFhdORz/9a9/hTwCmk/RY/967GJ9rcdA1hwv\nHs/eYwFrjhV/H88hoHGOPd/EjTfeGOoTJkzIZY+L7nGwNZ+RxotOKcZE9s/0mNUaz7kU6z6luI+G\nDBlS8fM7o3pieft+KeUB8NjapTwKpVxT3qb96vHLq71vd+UxxuvJ3dVafDwqj2VeLf9Fd6bzo8aV\nT6l57HuN2V/Kv5RSeSyV5tJq+TY11rznrXj11Vdz2XOG4VO9evUKdc+bpLmSvf/rmVc971cpz6vn\nA/373/+ey/vvv39o05zLXSEfUInvl1JOqFK+g2o58ip9hm9DKc+b8/nB/7aUr1n/dtq0aaHNv4u+\nbymnxqKkeaw8p1WJz6H6/Xx/+vpZ59Fq+0XP2dVyBlb6u4XRHFWeo12PHT9WfHtLed98+/T84J/Z\nnnbbbbdiu153eH54PXfpfLyw15ZyJPpaXPdVKf9qSuU8X6Xcvt53et3mx0upL/347oxKa9911lkn\nlzUvdUrN53LN4VPKQV/NgAEDQn3EiBG57Of6rbbaqqHPaElO4FVWWaWhz2yppZZaKuRi1O3485//\nHF7r+Zb69+9f8X01V5bf+/D7G3peOO+880JbKYeju+mmm0J96NChubz33nvX/D4toXmm6skFWVpP\ndCSl7fSx7PfS9Jj3a53Ses/b/G/1uPRx5esIPS/7+VPXhtXWjXoe6KjztfaVfx8/l9Z67+rEE08M\n9c022yzUNX+zzrEpNd/fOkf4+dG3V3P7et5Ad/jhh+fy8OHDQ9sGG2yQy55H1M/J8+bNK37OotDU\n1FTxvq3nMvQ+1vu/fn9a5+B68qB6P/k1tq7nfNz6/KCf62O+dN/N1wx6LHtOaM0bmlKco/1ev88l\nTz311EI/o6PR+civubTuuZQB1Ia76gAAAAAAAAAAAAAaxgNHAAAAAAAAAAAAAA2rK6Tqxx9/HELQ\n6U+nX3nllfDaJZdcMtQ1DJuHAZ0/f34u+8/x/SfhpbBPHuJFf3ruIX30M1NKae21185l/zm1hoNN\nKaU33nhjodvj7+vhJEqhKDyExYorrhjqGkZBwxtMnDgxdXb1hK+sJ9xmS0Kq6t+WQqpq6CJU5qEe\nVLWQSm0V3lQ/18cq/VqZho/yvvL5Wvvd52cPqeN/qzzkSClkntdffvnlXF5jjTVCm4af69mzZ2jz\nUNoe4qq70PNNSs3nUe3HaiGvdSz78eBzRCmEpp9L11xzzVz2/tdze1cPqer7qRTmUNdyrhQOqFpY\nHD0GqoVh1Pfy+aC0Df5aXetNnjw5tJXCRnaWkGy18nB0pfB0uo7ForfzzjsX23WN4mGs9Pg/6qij\nQttVV10V6jrPeng0H9saXqye8VltTafXTX4e0POwhppLKaWBAweGej0pJTScuoedbW2l0OGN/t2i\nOHddfPHFoa7pPKqFAK5VPWG3/bUeDq+9LLbYYmnQoEG5/tvf/jaXTz/99PBaTSuQUgyp6m06xj3U\npoe1033hY/Hss88O9UsvvTSXzzrrrNA2atSoUL/jjjtyecGCBak9aAi/Uqh31xVSlvgx7GEb9Tzt\n10Ee/lHXOr7u8XtMGlLV30dD3Hq7hwjW+duvofw+W2dYb+kx5fvF6bjz8fqd73wnl7///e+HNp/L\n9X6ft2no5pRiKPxq21daq++5556hrmGYd9lll5rf0/tU71W6elIitSVNqeX3l/wegfaNh6XVc4Df\nN/Z1jV6z+rrF72XrPQu/7+DnDH3fOXPmhDZf49ca0tTPJ/699Tzl98D9HF06HgB0H/zCEQAAAAAA\nAAAAAEDDeOAIAAAAAAAAAAAAoGE8cAQAAAAAAAAAAADQsLpyOH7wwQfp6aefzvUbbrghlw877LDw\n2lmzZoX61KlTc9ljwGtMco9l7XHnNf+Ix5n2vCYaS9pjhb///vuhPnv27IqvLeUaK30Xj6/ucbu1\nXi3f42qrrZbLmn/E/66jaElsdu/XWj+nWn6A0vuWttdjvJdyZ2DhPD+b7m8/1tsqz0OpH30crb76\n6rmscx7iMe/71OdVzYXpc7vPj6WcfTqvphSPGZ/3BwwYEOpPPPFELm+99dahTed9z3ni+VK6aw7H\nPfbYI9Q9L4uOHc8R4XXtRx/npZzMntfHx6vm2fD5ZL311kvdlY4jH6ulHI7+Wn0f7yd/rc4P9eR7\nrLbuKp0XNHfQs88+W9w+rXeGnELoHnyN5PkVl1xyyVwujSvNT5RSShdccEGoH3TQQbmsuR9TSqlP\nnz6hrtdxnqvHlc7ffq5fbrnlctnH+aOPPprL559/fmjbZpttKn5mtblGc1Zdcsklxde2VKPXP6W/\n03nsvuAAACAASURBVLnq1ltvDW2+5jnjjDNyecyYMTV//imnnBLqnldU+2PixIk1v29rqbZGay8L\nFixIl19+ea4fccQRubzuuuuG1/o26vHuObd0jHsePV93eY4wdeKJJ1asz5s3L7R5nt//+Z//qfi+\nfi6tNSdYNfpd68nL2lqfvyh5rnjvV13reo5Ez7Gp46OUPz2luI7zvHD+OXou8nseWtd1eErNj9nO\nZr/99gv1yy67LNT1u/u9St3/nsdu6NChof7kk0/msl+vvPTSS6Gu7d4Xpeui0aNHhzbN2eh8ni3x\n48zv/arSPZhFxeeQF154oVjvDrxf9D4JADSCXzgCAAAAAAAAAAAAaBgPHAEAAAAAAAAAAAA0jAeO\nAAAAAAAAAAAAABpWVw5Hp3kiPM/ZCSecEOqrrrpqLntcd43Z/95774U2j1GueU48zri/tpQfyPMQ\nad1zqfhrS3l/tE1zLabUPA+Zxu73OOIeC/+ZZ57J5auuuqri53cUvo9KuUk8v4vmfatG95v3fyk3\nYEtyTNaTw7Eln9OV9O/fv2JbKV9YSuU+rif3po8xPR78WOnsuSfakuZf8rnS88NorgrPTeJ5+fS9\nvD8815S+1vPoDhs2LNRvueWWXPb8MPo+nmunnjwWXdngwYND3ftCz1U+5jzvpb7Wc0P+7W9/C3XN\nLeTnBM9vpjQPUkrNcyp1J6UcjjNmzKj4d54XVce173sfq6paHsZSPkWvaw45n0u0zz03pb+PngcY\n4+gofC3j82w9uc3UD3/4w2K9RMeZb09pjV8th6Of+xul2+Bj2XPT6fmmLXM4LrXUUmmTTTbJdf3u\n/r3feOONUNfrX5+DdZ3jax4/Rx9//PG5fNddd4W2uXPnhvqOO+6Yy8cee2xou++++0K9nmOnUfWs\n6X0/LCrTpk3L5eHDh4e2mTNnhrreT1hhhRVCmx7Pfi/Ec6jqfvKx6OsuP5aU36co5eZs9HrWt93H\npuYM9O1xOid1lP6vpnTPaLXVVgt1nyv1b31tO3Xq1FAv5dldZpllQl3nHv9Mn+s1P6EfS7p9fo/L\ndYac2f369cvlc845J7T5WlfXwp6nUfl9C++nzTffPJcfeeSR0DZo0KCKn7n88suHNt//N9xwQy7/\n5S9/qbh9zo8H5fvA54TSOqUz9D8AoPXxC0cAAAAAAAAAAAAADeOBIwAAAAAAAAAAAICG1R1PSkOa\naGiqsWPHhtd5fdSoUbmsoVhTSmngwIG5rKE1/PNSiqEJPISOh+9SHkbGwwBoGC4PGfHuu+9W3Aan\n7/vPf/4ztL3//vuhrt/tjjvuCG3PP/98qI8bN67iZ3Y1ul/qCcnmx0oppGa10A6lUHSqWkhVfMpD\n32hYIR+LpdDIfjyU9r+PP3+tHg8eimT69OkV37e705CqPjYWLFgQ6jqf+3w9e/bsUNfwpqVQYwv7\n3BKdv/199Rjwz9DQOiml9MILL9T8mV2JhzodOXJkxdd62GINxeT8vOo0dE8pxE9KcV7wuWbChAnF\nv+1KqoUlVaWwhh7ySes+r2po+JRiX5TCmrvSud2310OLachu738P+6zzkLcBi8rhhx8e6vvuu2+o\na1hpHxula5+WKIXxXBRefvnlUO/bt28ueyg3D7v80EMPtd2GicUWWyykENGybm9KzcMc6tzqYTH1\n3OphOq+++upQ1xQc2223XWgbMWJEqGsIet9HGpo1pXge9nNEKWxna/Fr6L///e9t/pm10HsaBx10\nUGhbaaWVQl3Pc74G0nCJvubxtZVeQ3nal9J9E7/WOfjgg1Ml1dJS1Kra9baOVb9XU22bOjufu30c\n6Rrajwlfi+l6xtdIvk7TubTaOqh0T8aPvVrfp6Pac889c9n32Zw5c0Jdz8l+f0GPaW8r3dfScNwp\nNU8R8Pjjj+fyxhtvHNr0XJNS8zWEKs3ffi1c+jvn+wgAgI5/9gcAAAAAAAAAAADQYfHAEQAAAAAA\nAAAAAEDDeOAIAAAAAAAAAAAAoGF153BsNIb/Pffck8vDhw+v+Lq11lor1DVfWEoxT4fnRpg2bVqo\na3z7KVOm1LytaDnPy1cya9asUB8yZEguew4oP/607rkESq/17fOY+p5vTunfVsvhWM9+6Moee+yx\nUNc+XnbZZUPbBx98UPF9PBeIHx/17G/N0ef9P3ny5Jrfp7vRHDCeU6dXr14V/85zKnk+Eh1znuto\n3rx5oa75Sfy1fs4YPHhwLvucUCkncUopLb300gkpXXLJJaF+8cUXh7qOyfnz54e20nqh2lpC38tz\nO3vuGu0rz4t1/vnnFz+nK/HzkY4xnytL+XSuv/76UNd96jmW/Fzpn1N6rR47Prf78aHv+9Zbb4W2\nJ554ouJn+vZovTPkFEL34DkINbd9SjG/ns+HY8aMaZVtKOVB97bSWqvaOkzHto9znQf8fW6//fZQ\n17yXfr6+5ZZbQv2ss84qblNrWbBgQbr88ssb+ts+ffrksl/faj6xUl7AlOKx4zkbfT/deuutufzH\nP/4xtHmuSNUeORud5xE97rjjQv30009vz83JJk6cmMveFzvvvHOon3baabm86aabhjZfu7SFBx54\nINT13kxbqbbW02PU7we4rnZN7ddBpRyJvvby/apj0u+H+PtqjljNRZhS89yipeskVS3Pb6P3D9vT\nFVdckcv7779/aFt77bVDXedSPy5LeS99P+h1tK/h9fo1pXi96/dORo0alWpVWqf79VWpzdf0pfyP\n/t1K2wAA6Dq42wIAAAAAAAAAAACgYTxwBAAAAAAAAAAAANAwHjgCAAAAAAAAAAAAaFjdORzb2qRJ\nk2p+reZNQOflceg1P5vHh/f8bKUcM57DoMRj7Gusec9jovkOPL6+qzX3QVfnuf40T4LnHfA+1uOh\nnhwAfjx4H7/88su57HlMfHvxmTXWWCOXdR+m1DxPo/L+8Lwhmv9j3Lhxoe2ggw4KdZ0X7rrrruLn\naN3nGs034d+lPXLbdEbrrbdeqE+YMKHia0t5npZffvni56ywwgq5vPjii4c2Py9oLpWddtoptE2f\nPr34OV2J7yfNJ+XjwseCOuOMM1p3wxahUm6d0j4AFqUZM2aE+mKLLZbLnofPc/opXT+lVM6xVMp7\n3l50jefru6effjrUNZ+U5pZOKaVf/epXbbB1bWvBggULLeNT06ZNC/XO0Me33XZbsa40t/3GG28c\n2oYNGxbqAwYMyOVS7vSUUnr11Vdz+cgjjyy+VtcMrTX+q+X7PPvss3P5hRdeKL7Wcx52dtrnKTVf\nk+gc523e71/84hdz2a+jPT+oXsf5WnzDDTcMdb0e83OPHi9doW8++OCDXN5+++1Dm59nDz300Fze\nfffdQ9tGG22Uy9ovLaXX2Lvttltou/fee1vlM1588cWKbX4MTpkyJdSfffbZin/r92AAAN0Dv3AE\nAAAAAAAAAAAA0DAeOAIAAAAAAAAAAABoWA8PN1V8cY8etb8Y7aapqalH9VfVprX6WMNspNQ8rJk6\n55xzQl1DR7355puhrRQm1UPGvfvuuxW3wbfPQzdpKBkPE6JhTB577LHQ9re//a3i9rVER+zjOj8z\n1OuZd3r37p3LK664YmjzMDFqzpw5xbqG8HS6vfVsa0u0Zh+n1Hb9rOEsfdz4GNRx5OGHPdSlhqvx\n0FldSWcfyyVbbrllqK+zzjqhvu222+bycccdF9pmz54d6npe8JBP11xzTaiPHTu2/o1tQx2lj3/+\n85/nsocwvuWWW3LZz1s+X6v2mg9by09/+tNQHzRoUC5raO+U6juOOkofo0092dTUtElrvVk9/exj\n8Otf/3ouv/7666FN584nnngitHn46VIY+o5AQ6p6CLbRo0eH+qWXXprLvk7XcHcppfT3v/+94mcy\nlrs++rjr66jXUJ4KROe1448/PrR5KNS5c+fmsl+zzp8/P9R1bteQuyml1K9fv1AfP358LnvIz1VX\nXTXUdc3n6UY22GCDXD7hhBNCm5+nSnN7PTrbWPawuboGTSneU/J95iFLX3rppVbZptIx6UaOHJnL\nejym1Hx7/T5LozpbH6N+HXW+RutiLHd9tfQxv3AEAAAAAAAAAAAA0DAeOAIAAAAAAAAAAABoGA8c\nAQAAAAAAAAAAADSs3hyO81JK06u+EO1pYFNTU9/WejP6uEOij7u+Vu3jlOjnDoqx3PXRx10ffdw9\n0M9dH33c9dHHXR/XUN0DY7nro4+7Pubr7oGx3PXV1Md1PXAEAAAAAAAAAAAAAEVIVQAAAAAAAAAA\nAAAN44EjAAAAAAAAAAAAgIbxwBEAAAAAAAAAAABAw3jgCAAAAAAAAAAAAKBhPHAEAAAAAAAAAAAA\n0DAeOAIAAAAAAAAAAABoGA8cAQAAAAAAAAAAADSMB44AAAAAAAAAAAAAGsYDRwAAAAAAAAAAAAAN\n44EjAAAAAAAAAAAAgIbxwBEAAAAAAAAAAABAw3jgCAAAAAAAAAAAAKBhPHAEAAAAAAAAAAAA0DAe\nOAIAAAAAAAAAAABoGA8cAQAAAAAAAAAAADSMB44AAAAAAAAAAAAAGsYDRwAAAAAAAAAAAAAN44Ej\nAAAAAAAAAAAAgIbxwBEAAAAAAAAAAABAw3jgCAAAAAAAAAAAAKBhPHAEAAAAAAAAAAAA0DAeOAIA\nAAAAAAAAAABoGA8cAQAAAAAAAAAAADSMB44AAAAAAAAAAAAAGsYDRwAAAAAAAAAAAAAN44EjAAAA\nAAAAAAAAgIbxwBEAAAAAAAAAAABAw3jgCAAAAAAAAAAAAKBhPHAEAAAAAAAAAAAA0DAeOAIAAAAA\nAAAAAABoGA8cAQAAAAAAAAAAADSMB44AAAAAAAAAAAAAGsYDRwAAAAAAAAAAAAAN44EjAAAAAAAA\nAAAAgIbxwBEAAAAAAAAAAABAw3jgCAAAAAAAAAAAAKBhPHAEAAAAAAAAAAAA0DAeOAIAAAAAAAAA\nAABoGA8cAQAAAAAAAAAAADSMB44AAAAAAAAAAAAAGsYDRwAAAAAAAAAAAAAN44EjAAAAAAAAAAAA\ngIbxwBEAAAAAAAAAAABAw3jgCAAAAAAAAAAAAKBhPHAEAAAAAAAAAAAA0DAeOAIAAAAAAAAAAABo\nGA8cAQAAAAAAAAAAADSMB44AAAAAAAAAAAAAGsYDRwAAAAAAAAAAAAAN44EjAAAAAAAAAAAAgIbx\nwBEAAAAAAAAAAABAw3jgCAAAAAAAAAAAAKBhPHAEAAAAAAAAAAAA0LDP1/PiHj16NLXVhqBxTU1N\nPVrrvTpCHy+xxBK53KdPn9D2r3/9K9T//e9/53JTU9z0z3++8uH98ccfh/riiy8e6l/4whcqvs/k\nyZMrvm9b6Wp9XPK5z30u1D/55JNFtCXtqzX7OKVF0889esSv8MUvfjGXv/SlL4W29957L9R9bDdK\nP9M/9+23326Vz2iJrjyW/+M/4v8w+byqffHBBx+ENp3LU4r9+M9//jO0+d92NF2tj5deeulcXmyx\nxULb/Pnz22Ub+vbtm8ve/++++267bIPq7H3sc7Wvn5BSSml+U1NT3+ovq01HGMv10HVwz549Q5uv\ni/V48vOsn+s7ms4+llFdV+7j3r17h7qer1OKY9Xnfb/e0nW4n1dfe+21Fm1nW+sK11D18PW2r6Fr\npfdcUkrp/fffb3ib2kNnH8tLLrlkqOt4XW655ULb3LlzQ13PpX5vxI8HXav7HOF9Pm/evFx+/fXX\nQ5vfL2sPnb2P3TLLLJPLei2TUlxnpRT3t/dpid9j+fDDD0N9zpw5ubworplcd5uvu6uuNpbroXO9\nn5/9mlvXYn4O7ujX57X0cV0PHIH2sM466+TyoYceGtoWLFgQ6u+8804u+wMLX7jpgJ0xY0ZoW3/9\n9UN9hRVWyGVfHIwaNaritqPlll122VB/6623crm1HkrVwy/Qvd7oRV5HUrpwreei1hfOK6+8ci6v\nu+66oe3RRx8NdV0Mt0S/fv1CXeeT2267LbTVcxLX/dAV+rxW9fS/X8R6n2tfTJgwIbT5xVH//v1z\n2W90/eMf/6i4DTxIWbiW7JdNNtkklwcNGhTafve737Vsw2q033775bIfOw8++GC7bENX4jcnOtpD\nfH+gtSjO/Sml6YviQ1vCx3lJtTlg+eWXz+Xdd989tPXq1SvU9dx/9913h7aHHnqo4meU5iXmcqC6\nnXbaKdS32267UNdrWF+j+8NJvcb2cXvOOee0aDvRupZaaqlQb/QfKtdee+1Qf/LJJxveJlTn95u2\n2WabXP7mN78Z2i688MJQf+KJJ3L5zTffDG1+PAwcODCXDz744NC28cYbh/pFF12Uy2PGjAlt06ZN\nS91FW605hg8fnsvf+ta3QpveJ0kppZdffjmX/Zra6UOKNdZYI7RNmjQp1M8666xc5pqpeyrdx2K9\n3fo22GCDXPZ/vPR/pNe12NNPPx3a/P5YZ0RIVQAAAAAAAAAAAAAN61HPE+zO9lPW7qKr/Vz5xBNP\nzOVdd901tPl/ZKy22mq57P+p6b9w1DAR+qu5lJr/p5j+l+fqq69e8TPbS2fvY//PGf2P3AMOOCC0\n+S9I9b/s/VcZv/nNb0J9o402ymX/ZZb/F6f+99fhhx8e2p555plUK/1uLfmPoEUZXqL0K87SL9p+\n+9vfhrqHW/zoo49yWX81nFLz8ar7zsOiPvXUU6GuoTr9v4T8V3X6K+ipU6eGNv017V//+tfQdv31\n16dKWhLKqLOPZbfmmmvmsvepjzn9r9oHHnggtHkYH/2vfP/vLv+Fuv832KLWEfu49N+L/mslP/Z1\nnPgvzR5++OFQ17Hh86Fvg4ZM99euuOKKoa7nAX+tHh9f/vKXU3voiH3cEjrn+r5/9dVXQ730K7pS\nGGVv8zBfb7zxRi5Pn94hflz4ZFNT0ybVX1ab9ujnar9wLK1Rdtttt1DX/8T3+VlDsPnn6q/TU0rp\njjvuCPXLLrusuI0Le8+Faa3/wO5qYxnNdYY+rieKhs6VGq4vpea/dJs9e3Yu+6+gPLSergX8fT38\nql+Pqda6LqpHVwzRp78q9fnZowDo8ePrMr8u0l9Defi2V155JdTPO++8XL7yyitr2ew21RHHsq9l\n9FeMI0eOLL521qxZubzSSiuFtqOOOirU64lgoO68885Qv/TSS0Ndr+M8ytTMmTNz+a677gpt9dwr\nqUdH7GO36qqr5vIFF1wQ2kaMGBHqGlrR7zf6/QSPqlYrT2/h866+r0eL06gx/ivbtvqFa2eZr0vn\nMj8H7rzzzrm8ww47hDa/H6LHgd+v9utsfa3/6vWRRx4J9T//+c+5PHHixFRJe6Wv6gxjubU899xz\noa6/XvYobr7G0371e17+62Xl84ceox1p7cUvHAEAAAAAAAAAAAA0jAeOAAAAAAAAAAAAABpGSNUu\noKv9XPnUU0/NZU+mrCHYUoqhKaqFmtCfvvtrSyFVt9xyy9C2xRZb5HJ7JdPuDH2sCcqvvfba0OYh\nADRkh/+s3EM9fOELX8hlDWGRUvPQioMGDcpln9uefPLJUNfwj/oZKcVj5ZJLLgltZ555ZqqkJUmX\nF2V4iXpChJ5xxhm5PHjw4NCmoWFSimH6PFxDz549Q71fv365fMMNN4Q2D52r4YJee+210OaJmTXM\niIeQ0O/tYW48TMW5555b8X3qCUXRGcZyife5jkkPg7jPPvuEuoajvvrqq0Obz6X6OT4neMgfDT/x\nxBNPVNjy9tPZ+vjyyy8PdQ8F89JLL+Wyh3rxkDIajstD7I4dOzbUhw8fnssffPBBaBs2bFio6+f6\neBsyZEgun3TSSaHNv1tr6Wx9XI2GudSQ5yk1D0Gv5zkNm51S8zBvOlf6+dDD++l8PGDAgFo2u611\nupCqrnRuHz16dGj7+te/Huo6tv3c7v3uc7TyddvPfvazXP7HP/5RcXvrCVXeEl1tLKO5zt7HntpD\nr2cmT54c2nx9pCGxfUz5WlbDqPoY93Gs54wf/ehHlTa9RSkI6tFZQvSVnHbaaaF+8skn57KHOvXr\nTU1p4es072ftA79m8jWdhrPfcccdQ9t9992X2lt7jWVfy/g+1fPn73//+9Cm1zPebxoOOaW4nvV7\nURqKM6V4nVztulOvxzwkuodu1bWZf6aGSPe/02uDlFI67rjjclnT1tRrUc3XpT7XMLkpxTQsntrF\n97f21ccffxza/F5IKVy2r8M0FK7P135/TEOqenoD3QbfB/vvv3+oP/TQQ7ncWe95lfj9QO1bTzfh\nqWF07nz00UdD29ChQ0Nd52Af9z5f6zndr5VffPHFUNd7J88//3xoO/jgg1MlLenLko6y9qo1zLun\ndPLxqn7wgx+E+ne+851Q1zHp48rnDD3ufPs8hUWtqWP8WPZzWHv2Mb9wBAAAAAAAAAAAANAwHjgC\nAAAAAAAAAAAAaBgPHAEAAAAAAAAAAAA07PPVXwK0L83HpDHHU2qe80djzXueQI95rDGxPa6xx0nX\nnBP+2q233jqX2yuHY2egubJ69eoV2jxnwfvvv5/Lns/D6xrb3Pf3csstF+p33nlnLr/99tuhzfv4\n3XffzeVS7PJdd901tO2xxx6hrjk9Wysednsr5VjRvJgpxTj0niNAc4ikFPeH96vmlfG/1XygKTXP\nIaDHj4/zd955J9R13Ps2aF4Fz43g8fb1fTx3RktyOnY2nh9ozpw5uew5JGbOnBnqhxxySC57/rBb\nbrkl1HUsex4Cz9upx4vnpvB8B/iUjnnNA5JS81ycOs9qTtSUmucl0PO3zrEppbTNNtuEun6u5zPw\nOVnHrn/m7Nmzc9lzSbVVDseuRuc7H19+XtO5WnMKpdQ8/4+eI/yc7GOTsdpypXHjdtttt1D3HOna\nt1OnTg1tnudLx7af2zUHVEoxz8nRRx8d2jRfSnvlfmttteaKWRSfX1rrlvK8+Wur5fupdRs665q5\nUbV+d8+XePrpp4e6zqU+vko56X2N7uslzTfn51nPS7bLLrvksuf51Vz3fhx11nHdHnSfphSvfz3/\nko9BXUN5m1+TaLsfL34e1m049dRTQ9uoUaNSV+X72+la95JLLgltej3jOcG8XpoT9Fo3pfJY8b/V\n+dzvnY0fP77iNvh1nK4H11prrdC21157hbrmFmtJDsdFpdTnmns6pTh3+j2u0prZc8L17t071Fde\neeVc9msov07S+1re5seOXrt7H+vneE7JX/ziF6G+2Wab5XJXOX/r8e/7UR1wwAGh7jlMdVz5PLrJ\nJpXTwfs1l+dK1RzOmr85peb3RfWe2AYbbBDaBgwYkMu+Tu8qfVmJfr/SGqSUszGlmK93ww03DG16\nPyyl+AzD70369bD2jef9LeUOPeWUU0LbPffck8ulYzml9l2L8wtHAAAAAAAAAAAAAA3jgSMAAAAA\nAAAAAACAhvHAEQAAAAAAAAAAAEDDyOGIDkfzRS299NKhzfMDaaxxzy/h+Ug0ZrO/j9N46/4+np+w\nuzriiCNCffnll89lz6vnuUBKeQg894Tml6iWn03zFHiOoVKePc9v8eGHH+ayfxfPBbnvvvvm8vXX\nX586o1Legu222y7Ute98HOl+S6l5vyvPKaF52Dw3p+fNfOqpp3LZ5wg/RnR7PZ65zgl+3Hmeja22\n2iqX77333tDmf9vZ6X7xHJ7eb5ojwHM2el7MwYMH57L3he9vjWc/YsSI0LbKKqtUfF+PfT9mzJiK\nbd3ZWWedlcu+771vNKeBz5U+B+v481wgPlaV51R47733Ql3nEp/bdf7ynCf/H3t3HnZlVe9/fFlZ\nZpk5gAwiIIogMiiogeA8p+RUmqWnria1jtmopXU66ZVe2cnUTudoV+FQ6jlpmpoTomIqTsQgM4KA\nIAo4YPPg8feH12/5+X4e9rqfvXnAZ+/n/fprrWtt9r6fe91ruO/N/n51fk6peefoDU1zRPheys+p\n5hvxXCOe60/XBM+N4XUf56hfPXk45s+fH+q+D9Cx4ns2X+t1TfT5xPfMmi/U5wjdbzVrrrdafeB5\nof1869r65JNPdvjnV7XVk3u66jpr9BhaXelv/9nPfpbLhx56aGjz3Mla13uvlNqu33oP5XmbSvs7\nX2d9Tda63w9+4AMfyOVjjjkmtJVyOjbLGN9QNH+b83vYqjyqJaV8rE73ePvuu2+7P6PV+N+u+cKv\nvvrq0KZ5in099HGl/PqvJyezv9bXT+VrT+mZmO69fV2aOXNmqOtYv+aaa2q+Z7PYbrvtcnnXXXcN\nbTqXlu6ZUoprq/e/75lHjhyZy/78yZ9vaN/4+q3PVFJKqX///us89pRiTkff73tub52j/J6/WZXm\nznPOOSeXfS/71FNPhbrO0b5mP/LII6F+3HHH5bLPEX6vrHOw7hNSarv+a+5OzeeXUkpnn312zeO5\n4YYbUivT+bE0j370ox8N9VNOOSXUN99881z2Z0p9+/YNdZ0HevbsGdo8H66OV8+17fOJziGXXHJJ\naJsxY0YuX3XVVaHNr4eNuRfnF44AAAAAAAAAAAAAGsYXjgAAAAAAAAAAAAAa1mVDqn74wx8O9c99\n7nO5PGfOnNA2adKkUP/Nb36z4Q4MIcSShwTwkAFDhgzJZf+pu4d8UqVQEynFn6R7mAoPq9BVnX76\n6aGu56kUSjOlGH6iKpyL/uS7qt80TIiHn/GfpOsxaDiJlGIIIj8+D0WiP7dvxXB9fr3r+fAwLH6O\n9bX+030PaaDn3PvDQzlp+IlS36UU5wyfE3Su8TAnfrwaDs1DqpZC0jYjDbPlIZ48hObTTz+dy8OG\nDQttjz/+eKhrKMZ+/fqFNg9X9MQTT+TyXnvtFdo8jMt9992Xy75G7LPPPrnsIQSnT5+eugqfOzXk\nmYc19FAwPsaUz486VjUc0broHO3hd/19NZSQt2kYOA85dMYZZ4R6K87RHUHnVJ/PSuFddEyn1HZe\n1z6uCsupc66Hplm6dGnNY0djBg8eHOpbb711qOvcrnvtlFKaN29eqOs1oiGHUmq7tv7hD3/IvNZP\nAgAAIABJREFUZQ9RXwqpuj4hBDeWt73tbeHv/chHPpLL48ePD6/1cHQ6PjSEe0pxzXv/+98f2jz8\nlvabh6f3uV35+/q8r8fn+2v/nFdeeaXma0vrifep7ud8b+fzkh7DhAkTctnD0nUWBxxwQKhrny9Y\nsCC0+TnU+xcPgef7cD2nPt4eeuihUNd2DWufUtu9lY7j559/PrTp3PKtb30rtJ1//vmh3tXDqCrf\nM+n66mOjFG6z6n5L+9LbSvdUPidreoNly5alVrZkyZJQ1znGn3nonDx79uzQ5uep9KzKx5z2lfdb\nqc99/nD6Wn+WpnuxUaNGhTZ/BvDMM88UP6fZfOELX8hlTTuQUuy3V199NbT5eqjj2J9n+JjSeyGf\ng2fNmhXqQ4cOzeWFCxeGNr93X7t2bc3P1DFfur9KKaVPfepTufyd73wntRq/9+jWrVsue/hbD2eq\n66c/09B9WUpxzfTP9LGtz1L8OYumlEkppSlTpuSy7/f0+vHju/fee0O9tFdsRqX7hSuuuCKX/Znn\nyy+/HOoajthD4Xq/vfjii7nsY87vs3Uf5+uJ32fr3ONrhI77H/7wh6HtrrvuCnUNC76h8QtHAAAA\nAAAAAAAAAA3jC0cAAAAAAAAAAAAADeMLRwAAAAAAAAAAAAAN67I5HPfee+9Q17jLe+65Z2j713/9\n11C/9NJLc/mss85q+Bg09vl5550X2jwu9GmnnZbLmruhFXgeDo197/HK/W/Xds8/sv3224e6nm+P\nt645G1OKsas9nn3Pnj0T2tIcAVW5Vko5Mkv5PKpyFmjd42OXcsN4bG2Nj+35Ffy1ej306tUrtHle\nsmbk8eH1vHo/e/40PXc+dj3uuF4HpXw1KcW46f4+3u9a9+tQryc/dr8uNY5/q9O5dNWqVTXbUorj\n6p577gltPs8effTRuXz33XeHNh9XmjvZ+9ivj2222SaXPT+GXqM+d3tOBc+F1Ep87tR8Uddcc01o\n8z2Q5uPyfirlJXjppZdCm6+lmqPZx63ngdPj9zZ93/vvvz+0aQ41vMnz6un85jmGfPxpfgkfM57j\nVfOJeS4Yp9eLj1VyOL7J1yatV+VD0/w7y5cvD22ea0rHtu9lvC91nvXcdHPmzAl1vZ6OOeaY0PYf\n//Efuey56Hyu6Yw5HLfccst06KGH5vqIESNy2e/zPE/j4Ycfnsu+79R8w/379w9tvj/S/Lyeh8fz\nUOna6WPXcx/usssuuexzu79W8wz5++p64vniPK+QHp/nXJ47d26o6zW5884757LvQzoLzf+eUuxH\nzw3k9Nov5dr0ds8N5Ouujs2rrroqtHlOsIEDB+ayr8ma98hzxeJNfg/ltC993ve+0/nR20prhs+r\nvr8uXYuaI73Vczgedthhob7TTjvl8i233BLadC31fa+PB13nqvJ0Kh/n3o/a7nOw97HndlWLFi3K\n5R//+MehTXMLp5TSRz/60VzW+SGltnlpm8H++++fy77m6bzqbf4sSNdkPw8+bjTvm187Pgfr9eH3\nvv7MQo+xNO97Hlmv77XXXqmVeZ5SzbXoz4o9l7nmtPU8np4LUPNBei5U/xzN4afjMaW2e7rSPKx7\nJM9Ju99++4X6TTfdVPN9mt3ll18e6trnF1xwQWjz/Jqai93nP7/X0e8zfCz7nKx7/tL3IinFse7r\ngLZ5Tt0hQ4aE+rHHHpvLN998c9qQ+IUjAAAAAAAAAAAAgIbxhSMAAAAAAAAAAACAhrVUSFUPEeBh\noNTYsWNDfe3atbnsP1194IEHQv2LX/xiLl977bWhberUqTU/00PR6ftq2JiU2ob305BnkydPrvkZ\nzWjrrbcOdQ3R5eGA/Cfq+rNj/0m6/8xYz+kjjzxSfK2GG/DQRqUQF63u5z//eS57CB2tezjbP/zh\nD6Gu4QE8HJCHb9G+8XAjpTHuPISEhxZSGtrIwxX4Nah/m4ckuP7669t9fJ2JhvnxkHk6P3oor969\ne4e6hhuoCk3r87fy8AKqdL1U0ff1echDJey4447tft9m4+uNnlMfNx62Rce9h3DxsI0aFtFDST32\n2GOhriH8dt1119BWCiXl87OOc7/mfJ7y8ChdxamnnhrqN954Y6gffPDBuexh7fza0Tnaz7eHHdLX\n+vrt76t97uGfvve97+XyJZdcklDN5ztdSz30TykUqoe9dDrv+97a1w8NXeT7ZbzJ90G6dvr65+FN\n99hjj1z2kD4+r+p7+R5uyy23DHUd27fddlto0xBhKcV51+dgTVmh91p+PCnFub6zhFf9xz/+kVas\nWJHrek49VJeHrtb7UC2nFPeWfg/o4ds0VOddd90V2vr16xfqek5vuOGG0OapPXSOrrpn1bCBU6ZM\nCW16PXjYPQ87pXOEh0b149P7+gkTJqzzPToT3wPpXsXnPw+jVhWeutb7+j67FKZYQ+iu63g11J7f\nJ+h172EA8Sa/Z3K6Lvv9bmnOK91P+b/1ed/vt0rv5ffHrcznTp0DP//5z4c2nXOefPLJ0FZ6/lRK\nE5NSfc88dNx7n/p9kt7X+T7thBNOyGUPL6hhIVNK6aCDDsrlX//616GtGUOq6v2t75d0rfJ9sN9L\n6vnVsJspte0bPU8eyn748OGhrteOr53z588Pdf1c38/p9eD3Bh56X0MJt6JS2hh/bujPOJRfA57C\n5YorrshlDcOfUtt75SeeeCKX/Vma74P0mvD7ar0OfQ5o9XRh+vf6vlOvcQ9DOnTo0FAvpePyfbDO\nCz53+35W+8bTyXnf+OfWOj6/PmfMmBHq//7v/57LhFQFAAAAAAAAAAAA0GnxhSMAAAAAAAAAAACA\nhvGFIwAAAAAAAAAAAICGtVQOx1I8e49J3b9//1DXWMueE8zj7GocZo/NrrmPNF9VSil95StfCXWN\nfa65a1Jqm6PIcxm2Eo87rjn9PGeL942+1vMMDBkyJNQ1r4rHUF+yZEmoa4xs7//Omg9kY7jsssty\n+ZBDDgltGqva8zt6v2lccc8fUU+eCm/T68VjXPvn/PnPf85lj4mubX4deYxu/cx99903tDVrDkeN\nF+59qefc88j4PKs5BLw/Sjkcfdz72NZjqMqpqu/l+UI1n5XnJvR8Na2cU8zzkuo59bHhMeE114Dn\novCxoufw05/+dM33SSnmB/I+9n7UvAo+zvWa9Dwb+hkpda0cjjr+fLxpzpaUYu4azSWRUtvcUjrX\nl/JDpVTOheA0J5jvj3S+Rvv4vkvz0/jc50r5j0t97uPYc+LoHOxzEmor5XUaM2ZMqL/yyiu57POh\n5xPTPCKe82T27NmhrnsB3yN7DkfNh7xy5crQpvmjfD/ha4Rea/XkttqQNttsszRo0KBc1xyVft/h\neVoGDBiQy54vbNiwYbl8//33hzbP76Jzso8j3+f4fary60PzWut8nFLbXJy+b1Saw/3oo4+u2ZZS\nPEeeO8pzYuq6oHuPqrXlreJ9o+uw7008l5f2jc/HPhZ03q3K4ajv69er77s0D5jn2dY8ZL4P9H70\n3FZdiY7rKt6v3nd6/fgaXrpX9vf1vF8PPPBALp944omhrZVz2zt/Dvfoo4/mss93et+kz55SSunw\nww8P9dJc6XumUj5Nnwf0+vD7OH+t1n1Pf9111+XySSedFNr82aW+tpTfrll4fjyl+1e/h/J7FD1P\nvo/xvZWuazNnzqz5PinFudXnWX2+kVLcT/l98pw5c3LZ/xY/Xt+XtRqf/1RpvfT2qhyJep49F6q/\nrx6T508v5dwtrRmlnMytaO+9985l33stXLgwlzWvYUopdevWLdT1nHqf+jqr9zM+5rxeysfq15K2\n+9yu7+t7OH9WomuaP6f3a3B9dc5dOAAAAAAAAAAAAICmwBeOAAAAAAAAAAAAABrGF44AAAAAAAAA\nAAAAGtZSORw97rT66Ec/GuqaxySlci4Qj1etMXA1R1lKMTa75zfTGNkpxfi4HpPZY3H36dMnlz13\nSrPzOO+lfEwec1rjI3t8fY+lrH3uMY/79u0b6ppzxuMsV+U3amXTp0/PZb0mU4r5S7fZZpvQ5jkB\nNK60jyEfx/XkltJY5p4fynMW/PGPf8xlj7evMes9/4LnI7rkkkty2XO6NiuN/e/nXGOJ+zzl+SV0\n7Pj7eD9rvZS305Vyk/jx+tyux+dzsOdK0H73/EqeA7bZlHIv+jrma6fmFvDzW8qNOn78+NA2efLk\nUNdz6vkzfSzrdef5UDTGvs5fKaXUo0eP1FV4DgAdJz5uvR91bfXrwd9X91KlHEP+uX4Mpdw15Gxc\nf6Xctz4f+B6o9Fofm5ozrup60H/blfdZVbzvSuulr2u+11Gaky2lmE/Pc4H42q/H4PlRPB+J9rvu\n4VOK19Pw4cNDm+cu7Iw5HP/5z3+GvYLmf/E9heZsTCn+PZ43RvvC86Z96EMfCvWpU6fmsudW9JxQ\nBx54YC73798/tHmOyT333DOXH3nkkdC23377hbruEzyXlPaVzwm+t9Lz4Ndc6T5e54+qPN9vFV9L\nlefT8b3K6tWrc9lzppbyvPmezOdZPYees9E/R+/d/T5ex7jvyfya7Mo5HHfeeediu567qpxKOq78\n+imNAW/zcfa73/0ulz2HY1dap0v5Zn0s6zg6/vjjQ5uvY5o/zJ9b+JjTMen7p9I+zfl41eMfN25c\naNtll11q/rtp06aFuq7fI0aMCG133nlnu4+vs9C5avny5aFN/1YfBz536hjzPbPnLdbnZ752+h7t\n1VdfzWXPz+zXkh6/77t0T+GfUTV/txrvH33G4XOj57fU/bX3h49Xna99ffe+W7t2bS77ft/rei36\neq995/1ayl3ZCnR/6/2oPB+1r7t6Tn1+9n277lH1mXNKKfXu3TvUV61alcs+z/r76jMQH8t6Pfge\n2e/j9LrzfNId/TybXzgCAAAAAAAAAAAAaBhfOAIAAAAAAAAAAABoWEuFVC0577zzQl1/npxS/Bm0\n/0TWw03oT1297dlnn81l/5mz/5xWf9Lr4YA8HMYHPvCBXL7rrrtSKymF0HQefkf7cfDgwcXPefnl\nl3PZ+0JDWqQUf3bsP6/3cAN4wwknnFCz7Ze//GWod+/ePZf9/HoIAL0+vP993JRCi3nIC/23fs1p\n2AENk9xVbLfddrnsc5yGCvEwEBreI6V4zqvCPunneD97v2rfeVtp/i6FPfEwZQsWLKj5Ph4qptlD\nqnrIUp0fPVyDz516Dj0MhNM1b9KkSaFN105/L58T/HM05IXPJxp6wsPc+PtoH9cT1rcZlP6eqr/V\nz5vyEJq6d/F/5+O6FPrN37e94aLqCTfZlfkeU9dZX1d9zOsY85AtHiJdwzD6+lAKh11KkdDVlfZB\nHnrHQwfpWuUhfXwd077zvurVq1eoP/XUU7ns4fY9DL2O+9122y20adhRD/Hjoeg649h+29veFsLT\nPfPMM7n80EMPhdf63lL7at68eaFNx47vuy699NJQP+CAA3LZr4eDDjoo1PWY/Pj8+rjjjjty2fvG\n779uuOGGXPZ7Vg2b6iFe9V43pbYpTZSnKdFzpmHqfE/YWQwaNCjUNaSWz89O5wDf8/g+V8eJz6ul\nz6kKc15Kg1AK4Tl06NBQf+CBB2q+ttX5XOl07izdw3rd90veP9petWcqhf71taiV+Zys/XHSSSeF\ntpNPPjmXff906KGHhnopvYuPQT3fvrb7PKB1fx+fE1euXJnL/nxUQ8nqOp9S29QY+j6+32tGOif7\n+dVxUrrvTCmGr/T0T5r2I6UYYlrD2abUNoRnaX7wcavH4M839F7Y38frnXU97Sg+BvX5goekXLZs\nWahrGFXf9/p41WfSVc8y9Zx7KFS/nvRaLN1He5uP+1ajzzX9mtYwxj42vK4hV71PPW2CXks+R3jI\nUn2u6PfVvm/Tfb3OuSnFPfX+++8f2nzs6rW9odfyrrNTAAAAAAAAAAAAANDh+MIRAAAAAAAAAAAA\nQMP4whEAAAAAAAAAAABAw5o6h2NV3HnNE+E5Lzzmrcav9hi3pTxP/lqNiewxgj32tvL38Zxao0eP\nrvlvm53HDS7l7vE2jYnsucbcokWLcnn48OGhzWM0axzuLbfcMrR5rG1U83Omfe75Ez3Oda1/V/U5\n/lqv6zj2/AYe27xE39fnoM6YY6g9BgwYkMs+j2k+PY17nlLbcaTj1d/Hlc5jVS6ZWp/p/9ZzaWib\nf4Yfgx6f51VoRpoHwOdOXY88t6XnptBY81XXu14Dngu3lN+vanxqn3tM/W233bbm8XkuBL2ePS9C\nK6vqN70eNOZ/Sm3HdSnXor9Wx3FpjUip7XWH9eP5XbxflfeN9mNVns73vOc9uex5KXzfW1q/8abS\n+uc5lXwe0xybPlZ976U58jTvdkptrx/Ntedj1XPw6nqj10dK5VyFrr15XTemTTfdNOSK0fs+z/3s\nuYJ0PHibvqffv3g+ZD0vvlf5yle+EuraVx//+MdDm+YyTymlCRMm5PLkyZNDm+aNTCleZ74ma753\nv9dduHBhqOs16Tkl/X31etVrbPXq1amz0HHi1772m4/F0rzqzyg8d5q2V+VH172WzzOltb907+Nt\nI0eOTHiDjut1+cEPfpDL3/zmN0NbKS+fz42l/JvO+7mUw9Gv4Vbi84vfJ2meWN8j3X777bk8ZMiQ\n0HbGGWeEuuaG9P2U5wTT+ya/h/K6zu0+n/i9u643pbyiP/nJT0Ldc4RNnDgxl5vx2vDzUnp+oPtZ\nv7fx861rlz6bTqltHmPda/leSq+5lOL66fl4/XrQ69nvofXa1ryVKbWdv6ue5TQ7H+fPPfdcLlc9\nQ9A8iD4nlNb00vMm522+x9e+9TVC5xPP7+3PultN//79c9n3TDrufYz5Pljna88xPnDgwFDXfvVr\nRXNBphT3qX5v7N8f6ef6fbXmV/c273O9Rqvut9YXd/QAAAAAAAAAAAAAGsYXjgAAAAAAAAAAAAAa\nxheOAAAAAAAAAAAAABrWdDkcNQa1xzr3GMj/9m//lsuew8FjW2uc46rcb8rjYGvd4317fG19rceK\n93/rcdJbiecS0NwDHr/c8/1pfq6qHE+aX27MmDGhzXPMaAznXr16hTaPiY1qno+mpJSfzWPHe66J\nUu7FUt4jj7Xu46+klAujWfXs2TOXPda5xgT3mOQ+jrQ/qvLEleZZ77t6cjfpOuFz8Msvv5zLfm2V\ncubo+WlW2h9+Devf6mPX190SH4/6mb7m+dyuPIeMXw8a795j6GvuDO9jXzM0n06r53DUc1hPrlnN\nzZVS27wPmv/Yz7evnVr3OdivHc2NgfXn87qOIZ8PvG+033wvrflOnM+/Tj/H1xa8qTRePUeHz5V6\nL+H9vHTp0lDX/ECe38P7fbfddstlzxvix6v5R3xc6/zhOaA8B049a9HG8uc//zlNnTo114855phc\nfvrpp8NrV65cGer77bdfLns/Xnrppbnsed++/vWvh7qel6997WuhzfPTfPGLX8xlz1/leWRGjx6d\ny7feemtou/zyy0NdrzO/dmbMmJHLvp4cddRRob7DDjvk8qxZs0Kbry+a23LKlCm53Jnu2fTvqcob\nrnzu1DHm++HS/tjHvM8PpfskPz7NdVWVM1CVcsR1NVXX5r333pvLZ599dmjzNVzvv6ruS7V//F7H\n917PPvtsLlflMGslQ4cODfXjjz8+1HWe937U9VFfl1JK3/3ud0N92rRpuexrXinHqt+b+X1SKZfb\n3Llza762dC+u+ctSSun8888PdV3b/TnbL37xi1B/8cUXa37OW8XnJl0T/R5V1zXPe+j3t3q+/R51\n7Nixoa7rt3+m7wt0v+T3sz429Zg8t7M+S/N9VSkXp9//Net9ms6lPq70nsbvhXzd07FTlTe39AzG\n/62+1ufn0nrvz+T0mblfW54ju9XoefO9o/brVlttFdr8Gtd2fwatzxRTimPO53Kfr0v34KW8nZ5H\nUvdlfp/m15XmpySHIwAAAAAAAAAAAIBOiy8cAQAAAAAAAAAAADSs04dU9Z9/lsKuHX300aH+iU98\nIpc9lI3/ZFp/ylr1M2it+89c9efL/rN0/3l7KbyU/yx3p512yuXDDjsslzVsTKso/XTcfx6uP4v2\nME5u9uzZNdv0Z+YpxWvAw/HWE34Ob/CffOs4LoVQTSmOsarwM9peFRZO39dDR3XGUF0bk4YR8dAD\nykM5lObnqlDV9YRU1WPyfvY5QudZH7ul0Ln+d+ua4WGWm5H+fRqWxdv8fHoYHL1W/Pz62NZ+9HPv\n144eg4/PUuhkD/+ioSd8jfCQVB4Gp5WUQrTUw8OAlELK+Dzq/1bDffjc7uGBSiFPdL/UUX9nq6sK\nb6p8/Ok5rgopUxXqvpZ6jq+r8b2MGjJkSKj//ve/D3Udkx7ay/ty+fLluezjSMNiplReS5ctWxbq\nGsbH52D92/wz9T4opfKe/q3y2muvhfX0iCOOyGU/3uuvvz7UdS31PbOGNTz55JNDm9/PatjOxx57\nLLQtWrQo1K+99tpcPu6440Kb78n0Wtpxxx1Dm4e71Tna92j6d2o4wZTa/t36PnfeeWdo03v8lOL6\nrXNUKbznxqbhcH28lZ4tlNYxP7++lpb21iU+NktzvYfj0ucdfuy+nnRlVX2j87WP89La6mtEKXSu\nv9b7XY/R+7KV12k/v1dffXWo69++66671nwfv1/59re/HeoeVlqV1nrvC9+La7v3qc8ZvjevZfr0\n6aHuqSc0tOh9990X2jwcaGcMqep7DOV9ofsYXZ9TarseDh48OJc9zKHTf+vvo2Hune/BVqxYEeo6\nl3iYSL1GS8/KnKeXadaQqhqGsvTMy9v8POo59r7zeul5Zikdic8nPgeX0qXoGuL/rvQdha/9zUhD\nxvo1ree36m999dVXc7mUjiileA69v/15lO5f/bmb96M+L/Pj1bQJpXHu/3ZD78v4hSMAAAAAAAAA\nAACAhvGFIwAAAAAAAAAAAICG8YUjAAAAAAAAAAAAgIZ1WA7HUnz4ddWVxsD1OLWlvAXf+MY3Qv28\n884L9blz5+ZyKR5ySjHusr+2FL/a4+GWckF6XGyNt16Vd0jj9Q4fPjyXPZ56M/LzqzGPq3JI6LVT\nyiGTUkpPPvlkzc/060Hf1+NuN5qTqCvTnC0pxRjYnjfN88mVcjiW5gcfm54jTuOVe0z9qmup1dXK\nhZNSHJOe+9T7rirnpirlr/H38fjmpdfq+/rcrmPZ5xafe3ReajQnTmei17+PFR1XPnZ9PtTX+rXi\nOUW0b/wceu4mvZaq8iHr+/pnas4kzzPkOUS8z1tJaa70vvC8BJ/61Kdy2a+VUh4C3/N4XfdLPjZ9\nLtG+u/DCC0PbaaedVvPYsW4+T/q4VqW8TVX5j7Vf/Trz60Ff28pjsaNpnrvSuEkppd122y2XZ86c\nGdqef/75UNc8fT63+xyseUM8V5Pn+9N8UX5NDBo0KJd9LO+1116h3hlzOG622WZpl112yXXNe+jX\nu+f9+t3vfpfLPs/us88+uez9pvvplGK+KM+f+bGPfSzU9Vhvv/320Ob5aMaOHZvLPu79XlT326tX\nrw5tuu/64Ac/GNoWLFgQ6j/60Y9y2XOOlvK/9+nTJ5fnzJmTOgvdM5dyRTk/3zon+1zue6BG10R/\nHz/f2o9+H6fzhX++5yLsyqryi+o48vP20ksvNfy+pRyOfq2V8kW1wr1QLePGjQt1z3mmY9n3Pcrz\n7s2aNSvUdY3wsezruX6O94Xv03S8+lxTGpPPPPNMqsVzdHvuQp0TFi9eHNp8LzJv3ryan/NW8fOk\n59Tvdfr27VvzfUpzpec59Dzbus5VzcFaX7lyZWjza3Lp0qW53KtXr9CmezbNZ7iuY9Brp1Xmcr3f\nKD238rFc9fxS+XnVz/Q2fwZZygXo927a7z5n6Wf63+LXvr5vK+RwvO2223J53333DW36nOvBBx8M\nbT6vlu63/L5I19mqvNzaN8uXLw9t3jd63fmzbeXXSmnP7HNCR2vdnQIAAAAAAAAAAACADY4vHAEA\nAAAAAAAAAAA0jC8cAQAAAAAAAAAAADSsw3I41pN7sR7jx48P9e9///u5rLknUkppxowZoe5x6ZXn\nbNP4uB6T2eNX69/mcdC17rFyPZayxvSueq3G6NVcV/7vmpHHNdaYx/73aexkf21Vng6Pv678ei3F\n8O6oa7vZVeUdVaUcfFtuuWVo837Sf1uVl6KUy62UK9TjY5diYtfzdzeLUv4uz6Wlsf49b4/3nebP\n83wCPneW8vt5TpHSvOd9p6/1v1PzTnksds9PWcp54tePH29npDHrfb3RvijlJEgpjjM/D36eSnlO\nvM91jvD8BqXzv2bNmtCm63npM1KKeZ+6kqo57MADD8zlqnlVVeVgLuVF9TVD90sjR44sHi+qlc63\nr3E+V+s86jl9PA+g9rFfO6X1vJ78Zl2dnmPPqXP33XeHevfu3df571JqmzdE13Ndy1NKaaeddgp1\nHeue99fzCOqc7HOP7uM9r6/ngOqM/va3v6WFCxfmuv6tPjbmz58f6qecckou+/3M3Llzc/m8884L\nbVOmTAl1PU9HHnlkaPP8mjvssEMua27NlNqujyeffHIu33rrraHNrw9dS/1+u2fPnjXfx/doxx57\nbC4/9thjoW3q1Kmh/qEPfSiXNRdkKef3xqbXtF8PyvPz+Wt1vFXdF+lc73N5ae3315aeUzz++OOh\nTf9On2f8Pr4rq9p7ad/6nsj3wdrP9TyT8+vH+1nzUvkaXtrTN7vRo0eHuq6dKaU0dOjQXPb5T/ma\nPHny5FDXud33zD4GdSx5vjCn/er7qVI/9u7du/i+asyYMaG+884757Lnd9S2lFJ64IEH2v05G4vn\nLdb8yKVnyqX7FW/XPNUptX1esGTJklz2/fXuu+8e6rpP8PvkYcOG1Tzefv36hfpzzz2Xy/7sw49B\nr0k/X82qlD9e+86fL3g/K993+L/V++FS/tWU4jn3/ZTPEXo9lZ5N+bNXvw51fvHPbEYIL/EGAAAg\nAElEQVQ6fv2c6bnw75Z0fk4p3hf5ntnPoa7JVbk3NW+n79N97nnxxRdz2XNx6jH42uPfb+l15/NH\nR+MXjgAAAAAAAAAAAAAaxheOAAAAAAAAAAAAABq20eJxaoidgw8+OLSNGDEil4866qjQtttuu4W6\nhkl54oknQpv/BFl/Ouo/c60KQaKqwlgoDT/nP5f1f6d1DzXmP4PWMAqln2E3Iw+3ov3mP0Hv1atX\nqOs59vANTn8S7uEk/NrRn0H7a72vUM2vZz3fVWH39Gf9Pm59bOr7er+VQgH6WPWf27e6UogjD72n\nP7uvCrmkfP7zuUv7tp75uRRWKKU4v3j4Hw0H4qFDBw4cGOoaPtbnLA+1s2LFiqrDfsvpmPS/R0Pf\n+Bjz0F66RmtIiJTajm1VNca0r3ze9xAve+65Zy6vXbs2tGnYXA975NeZh5LpKqr2EXreqkK/lMK5\n+Dxb2suUQtnXswb7fNDV5vb20n7zvvBzpmuAz3UaTjKleA34+5RCgrVCuoCN5bjjjstln4N9zOma\nt9dee4W2I444ItQ1XJCHm/7e974X6ieeeGIue1jzUaNGhbqGL7r33ntDm15b22+/fWhbunRp6uw2\n2WSTcO3+7ne/y2XviwMOOCDUNVS0hjhLKYbnWrx4cWjzEFDKx/J9990X6nq+PYyT75dmzZqVyx5C\n00M16d/qf7fuKarC7mlIVT++X//616F+2223rfO1Pie9lfQ8+b5L+8r3MatXrw513Z/6eCulKXGl\n0Jv+73yvrX/LU089Fdo0lFcpRF1X533n/VEKnev90WgqGP93vk6Xwps3w5zcqFNPPTXUPYy4hlT1\nlE7KQ1ueccYZoa4h+zzMoe+DdX33cI6lcV917eiaVU/4xB/96EehrnO9h7yeNm1au9/3reLPQvT8\ne4hMbfOwhh4SW68dD9Hofa77Yl/zfH9Xuh78b9HP8ffRZ/S+9/a5Q+esVgmpqn9z6Xmlf5fga5ue\nV3/e4K8dMGBAzff1vYF+T7Jo0aLQ5qEwdfx63+m49+tu1apVoe57umZ3/PHH57Kvu3oOvZ88tYPu\ni72ffOxovRQmN6U47v15pPejfq5fOxoG2j/Dx6vOGRs61D2/cAQAAAAAAAAAAADQML5wBAAAAAAA\nAAAAANAwvnAEAAAAAAAAAAAA0LD1SpKy//775/K3v/3t0Ob5PjTHled80di5HrdW81+kFOPYlvIf\npBTj2mouknX9W80J5PHLPe6uxrsv5U7w2LmvvPJKzfepiu2rxz9lypRc9jjcrUDzaHlMcu83jbX9\n9NNPt/szvI/9fbVfPZ6zX6NdlecEKOWI8HOodY8/7TkLdJz4Z5RyFviY8pwFeu14m8fsVq2QN9V5\n/gHNw+DnWGOAe/4O72fty6o8IXpe/TNL/V6Vk03/recS0ljss2fPDm077LBDqOsa4X9LM+YxKPWN\nzocvvvhizbaUYpz/qvVI1zHPw+drtOYX8Nf6WtqvX79cnjNnTmh77LHHctlzlHneIZ0/Bg0aFNrm\nzZuXWon+rVVzWs+ePXPZ58pSDgu/rkr5JHw9Kc3fmh8qpfrmA7zB+037xtdkH3/ar55rznON6bj2\n9/W+KuX/RG26/vgcPGTIkFBfuXJlLu++++6hzcen7r89f5HPwdp3nvvF5wEd654XS3MEz5w5M7R5\nXuXOaNNNNw05hzWfiu8T/BxqjkT9dymldMopp+Sy5wbyNVrvX8aMGRPafH+t66PnOvR+vPzyy3NZ\n802mFHNApRRzXnseKl2vDzzwwNB25513hrrmAfN9ql9Xmg+ynjzgG5OOI1/jdM6bP39+aPM+1ucm\nnu/R31fXx6q9tc7JVbl89Xh1Xkkp5m2t+kx9H18jWp3vp/269TxbJdo/Pja8D0p7L3/uojlifZ/u\n80kr82dM7X3m5PcZp59+eqjrvFV1Pej84W2ldbbqGaOOO80XV+Xcc89t92ubkZ4nP2c6hny91mfe\nKcW1VZ9xppRS7969Q700B3of9+/fP5c9B58/x9LnH1XPY5Tf85WeqTQrnR/9fkf3baU9svM8nr7/\nmzRpUi77fsrPuT7X8L2Wz8H6b/1+QNcTn8v9eV6r9O3/p/e8njtcz7+fT+9HHVel/OQpxXm3NH+k\nFJ9HVt0r6Of6mlHKy+jH9/LLL6/zPTcEfuEIAAAAAAAAAAAAoGF84QgAAAAAAAAAAACgYXzhCAAA\nAAAAAAAAAKBhdeVwfMc73hFiB//kJz/JZY857XlctO5xazX2tcdO9vizpXjJpXxuVXl9Sq/1z9QY\nzqVcgD169AhtHjtX4/V6rgzPr6PH8OCDD+ay55BsRn49bL755rm8/fbbhzbP66Pn23NelHhMZs8N\nonGvPWZ3K+bw29CWLVsW6ho73HMD+fnVGNhVORx1jHkc7lJ8ah+bXS1/lMcA1/ncY4nrebzrrrtC\n2/Dhw2u+j/eV0372+c/XBX1tVS6CUr5Q/Vs8f9GHP/zhUC/lH9Q5q1noeSnl5fM8yqX10fvC6Zj0\n9/EcI8rz5vp8XcqlormPPA+S96POL55no9XUk8NRr33PF+V97tdSrc90Veus1n28aV4KzUmA2nw9\n1L6pyg2k48/3wJ5HRtfSqrzPOgc045z6VtFz5XsXz/ei+bh8rJbGp++n/LWl66c0v/g8u3z58lz2\nXK2ec6Yzeu2118I9reZn0ly4KaX05JNPhrrmQx0wYEBo0xx5S5YsCW2aEzGleG/5wAMPhDbf6+l9\nk+d88vskzR3p15mvrX379q3Z9sILL+Syr+X77LNPzeO74447QpteyynFa13PV2fKC6hjwc+htnnO\nntK9j4/j0p64ao9W69+t63N0PHof6zXo49jv+TTnqeeRanX33XdfqC9YsCDUfbyWlHL2ed+Vrh8f\nk/r87pvf/GZomz17druPr9lU5YHVc+iv1fXygAMOCG3f+973Ql1zPPq+p5QHvSp/WOm5px+vzpG+\nnugzx4cffrjme7aCUk5SHxd6Dq+//vrQdtppp4W6znn+vNfvqfR+19cBf8aiz8j9ftb34lr3v3O3\n3XbL5dI9nOusuZLrpc+5/HmDtvkY83Ouc4KfY/+3eh34+u57Fq37NVHKOeltpe86/Hj9Om12el37\nNa5/u+/T582bF+rajz4H+/2wXkt+L+bPVnWO8P73dUH3V6VnJf7c1ftcj5ccjgAAAAAAAAAAAAA6\nLb5wBAAAAAAAAAAAANCwukKqdu/ePX3uc5/LdQ31oCFkUmr7U1z9iWfpJ53+E1N/bSnMkv8cWH8y\n66FH/bUaQs5/9uw/r9a/20N+ahhVDRuTUgyXk1IMV+Pnz/9u/Sm/H08r8+vB6c/D6wmlpmGbUkpp\n8ODBoa4/V/awN/4T9a6q9FNtD7Pg41bHpv903MdfKVSX07HpY7wUYsZ/kl5P2KF6QhN2VqUwIqVQ\nMaVQpynFOa7qp/36b32O8/AH+tP/qjAAa9asyWXvnz59+uTyQw89FNo8zInOAxpyOaUY0rFZ6Ljz\nv0dDO/i1URUaV3nfaCgQH/ceRlfPv6+zfgyLFy/OZQ3PlVIMB+XriYerevbZZ3PZz0lXVgpz6NdH\nKZyHzyU6pnxslsIyer9pKEBCqrZPqS+qQoprKD0P7+h0b1tKFZBSvF7qmWe6Op3zHnnkkdDm8+zQ\noUNzuSrsXj0h2bTufed1nTP8WtOxPHLkyNDmIVVLYbDeSnre9JofPXp0eN3OO+8c6nqePHzbzTff\nnMs+5saMGRPqs2bNymUN15dS2zX5M5/5TC77fs7DZOr5vvvuu0Obh4c9++yzc1nDtaWU0pVXXpnL\nM2bMCG3f+MY3Ql2vbV97fF+gYfF1T1bPfn5D02u/NE40JGxKbceqroe+BvuYanQc+7/zuj7n8XVX\nw5B5iEZ/HqNhAbtaSNUrrrii2K5j2/vKx7JeE37Nl/bx9dzHXXbZZcXjbSVV9/PtDT3p9yQe5rq0\nR/J+07FTFea8pJQaw0P/6X1ylVZ4HqJKIWz1b508eXJo++pXvxrq+mzYny34dTRw4MBc9mdnM2fO\nDPVhw4blsu+PfJ7V+9tSOjDn14r+3a0SdlP3Nh6ydIsttshlf65fCqnq59TnZH3O4m2+N9Brz+dn\nX+/1fX0Mlp6X+fcQzZDCoB6l7xP0mX/peXVK5ZROfr5L9yg+X+vc7+kMSn3un6n95teG3w/qvL+h\nxzJ39AAAAAAAAAAAAAAaxheOAAAAAAAAAAAAABrGF44AAAAAAAAAAAAAGlZXDsfXX389xAzXOLEe\nK9rjGmtsWo8HrTFuPaatv1bj7Go5pbZxdjW2rrd5nHT9HI9x7HkiNI+Ex2L/1re+lcuHH354KtFz\n6XGAPdawx1RvZRq72mMpe12vs3pyN61atSrUBw0aFOqaP8VzqaxYsaLdn9NVlfIwphTHYymXX9X7\nlvI8VeVt0VjWfl15LPNW53+/nhuNB59SnB+9zWPWa94Cj0nu8cJ1jvPxqTle/Pg8F4HPlTvssEMu\ne2x+nWc9Droee0oxF5L/3c2Yx0DHpI8Vvf49l6GvTTqWS/k+U4pj28e5zwN6TP5a70e9Jrt37x7a\n9Jp8/PHHQ5v/LbqPafUcjqV8L3496PXt46SUW2p9cuP6a0t5qHr27JnLixYtavdn4E16vv3c+55Y\nx7XmT10Xnfd9vPk4Rvt4zuDSPdSOO+4Y6h11L1HK/Vb1Wr1+ND9OSnEvMmnSpNB26KGHhrreg3aW\nHI7/+Mc/Qp4fXVPmzp0bXuvjSu817rjjjtCm95q77757aHv00UdDXedA39v5Z2o+yO222y60+XjV\nf9utW7fQ5nkaNY+k54LUvZXv33w+0bnIczj6mqBrtubuLuUo39j0ntXXR30u4feZnu9Tn3/48w1/\nXz1P3lbK3eX5fkp7NH/fZ555Jpercko2Yw70juL7J79WtX/8GYfPq3o/7O/r9yza7teA36uV1ozS\nc7ZW1958hT6vTp06NdR17SqNXbc+ea79+tC6f+bxxx+fyzfccEPxfZs9h6PmkE6p7bNspWuX72V9\nrdLxt2zZstDma3JpXvW5UvMyek503/vttNNOuey5IKdPn57LnrPT5xm9XvXeq5npHFia//zeyK8P\n7Uufy0u5cn0se7/rGurH4Ou07iO8rdRffg37ut1K/Hxr3/h87euf9mvVfkrPoe/Ffbzq/tXnYP+3\nasqUKaF+0EEH1Twevx70/oQcjgAAAAAAAAAAAAA6Lb5wBAAAAAAAAAAAANCwukKqrly5Mp1//vm5\nriFVDjjggPBaD0dXClGoPyMt/TQ4pRiywX8S63V9r1IokJTiT2b9tT/84Q9D/Uc/+lFqj1NPPTXU\nV65cWfN4PTys/5S5FPak1ejPlb1P/WfFGtKgFPrAeYgf/7d6DH7uO1N4ns7Kx20ppGop7GJK8Sfr\nPm5LYff82imFavV5R0N1VWn2ECIptb3GdT70EB7adx4Ozf/+UngJP+c653m4Lg95rCHEqsKv6nVQ\nOt7nn38+tPl8PW/evFz28FbNOD9rf/jY0L9HQ5OllNKoUaPa/Rm+rul4rZqvta88HJSHelMeClXD\nwyxYsCC07bvvvjWP10Npt5rSXOXzt46hqlCK9YRWrGfu1Haf25sxpPFbzcdfaWz6vKlzR1UoSw3T\n4+uqr986DzXrWrox+Pr43HPP5fLAgQNDm99L6Lrm66rfp5XGZyn0m99D+Wt1/vZ7RT2m1atXhzZf\nZ3fddddc1jCmb6XNNtss7bLLLrl+0kkn5bL2U0ptw4nq33vyySeHtgEDBuSyhndPKaX+/fuHuqYB\nueeee0Kbh2PVvV5VGHHdW2l4tpTa3lNpiFV/X33tiBEjQtuwYcNCXa/JUjj3lOK+bPTo0bncWa6N\nlOLc6eNEr28NlZdS2/OkeyJfD/19S6EXS2EwS2HHUorhuHyNaO/np5TStttuW2xvZVXrnIZdq3rm\npfN11TWha6/fi/m/LT3zYJ1eN53/jjjiiNDmYf/1uVZpT5RS7JuqPq5nTda1qCpFVivz/ZKG1/Rn\nIRqG1J9N+l5FwyH7/s1DOOp9aq9evWoeT0pxP+fr42OPPVbzmDxM5LRp03J57dq1oU33HinF+aJv\n376pFZT2ujoePOSuP+PQe2cPlev31TqufIz5Pa0eQynEp3+u7zk11K//nf63lJ6ZNjvf9+j49fsO\nDzWr++2qsPNa9/Pp6fr0GaTvmX1d0GP0eyjdX3vYVj8Gve7WJ0R3e/ALRwAAAAAAAAAAAAAN4wtH\nAAAAAAAAAAAAAA3jC0cAAAAAAAAAAAAADVuvAL1nnnlmLnvc67POOivUNZ+hx6TWmMget9brGm/W\n44x7bFqNY+yxcj2u7QUXXJDLF154YeoInotCc0mlFGMIe/xvz5ulMb41DrfHD25GHtdacwJ5zic/\nTx6fur2WLFkS6n79es4w1QrnvCOUcnWVcqw5jxvtsao1zrjH3S7lOyjlJvHXevx0v85anefWKuWw\n1LGy9957hzaPfa5znp/jUj4e71efD3Vd8GP1dUBzHgwZMiS0aWz2Qw45JLR5/H3NX+Sx7j0HQ7Mr\nzX++7ur14OfecwtoH/v49DlY51kfj37taM4Jz0Om7+ux+EtzTekctDrvt1L+RM9ZoOuCrxGeM0LP\nv7eVPsc/069JVPM9sJ5vH29+vjXfT9U6qzlmNLddSm3HsR4D+6zaPIeL3t8sXrw4tC1cuDDUjz32\n2Fwu5dhNqZyfq5RPzP+d58PVHFaeV1fnbx/XzZA//bXXXgvjQ3Mo+r2O5vlKKfaH51/SNh+fpRyr\nI0eODG2+BtaTD3n27Nm57Gt9z549a76P74/69euXy37NLVu2LNT1+YBfr34fp3XNud2Z1nLfVyod\nQ/63+njT+dHX2dKa7O/j83dprffP0fFZOgbf2/nfVrrf6Op0LHt/lPZTVXkYS/mafGyzFq9baX3U\nXGmXXXZZaHvmmWdCvfTcorSHrroeSv1WyvPq69SoUaNy2XP3Pv300zU/oxmVzqnvu2677bZcrspz\nqXlqfXzpWpVSnC99jdO109/L12vvR52v9fpMKT539eeqO+64Y83XtsrcoOPB91d6Tfhextdz/bc+\n5/qY03728+g5QLUvfT11Omf436L/1u8B/bXNsN+uh45l7wvtR79n8lzrul/xMef7a71e/Hx6Xcey\n979/jr6vf7/15JNP5rLnnfVntrpnKD3T7wj8whEAAAAAAAAAAABAw/jCEQAAAAAAAAAAAEDD+MIR\nAAAAAAAAAAAAQMPWK4djKd/KxRdfXKyrAw44IJc934TnuOjbt28ue14Qp3m//vM//zO0XXTRRcV/\nW6J/t8cBVuecc06oe7xkjfldFQd46tSpdR9ns/B41BrX2OMYe93PU3utWrUq1D32vdb9+Ep9jjd4\n3OhSbqBSLqCUYlxpj3ntMadLOSz8GLyuqmKkt5pu3bqFuuZl8L7UfEHPP/98aPOcAZqr5d3vfndo\nK/Wlv4/Pj5rnojR/pBTz+3muGD0+n1s0T0FKKQ0aNKjmZ5RyeTQDz0OgeZQ814PnwZw5c2Yue7+V\ncqx6m+8hSteO5wDS68HfR4+pKieBtnueja7Ez6+eF+/j9bn2O2rceI4FtaHzErQKzf3n177n9vA8\ngSUrVqzIZZ87vP/1OutMedc6G1+vdR/co0eP0OZzp+bx8fx9pbFSzziq2qddddVVuXz77beHtokT\nJ+bys88+W/yczrhPe/vb3x7WTM1r7ePqoIMOCvVp06bl8uOPPx7a9H527Nixoc3zFut41dzTKaV0\n8803h7rec++www6hze91NLeTf6b/W11DvJ/0evU92fz580Nd92+HH354aJs0aVKo6x6uf//+uTxn\nzpzUWeiY83Gi58LHsT8/qGeslvL1le59/X28rs8w/DrTPZnvJzzfme8p8Cbt96p+1brvr0vXQNVr\nvf9Q7ayzzsplz4FXyuPqSs9DPN9j1TOPEh33Pi/pvfCsWbNCW6vlcPT7x9LzPr1P9vOi635KKb34\n4ou57HOuXw/ab97HntNR93el+dnb/e985JFHclmfdaSU0rhx42oer98bNCs9H37O9W/0fY/nY9U9\niN/D+Dyqn+l5+Dx/uda97/Ta8uPVfOkpxfE6fPjw0FbK59wKSnsmneN8D+p7L+0Lb/PniNoXuodP\nKe5tU4rzrh+r9/GAAQNyufRdmOdj9TVC5wjPBd/R+IUjAAAAAAAAAAAAgIbxhSMAAAAAAAAAAACA\nhq1XzLCOCi15//33r7PcWbX377766qs38JG0hqqQiMp/Duw/O1f+k2T9ebj/1N1DD+hPy/0n9IT6\nekPp5+keZsH7TfuiajyVwoKU2vyn7R7OoNHwM62oFLq4FP7IQy54eAENvVHPuPEQAR62Qvl16Meg\nfVsKpexhWz1MYylEVFWozs5Iw7716dMntE2fPj2XPVRav379Qn3GjBm57CHj/LyUQsV46Idtttmm\n5ms93K2G/fX+7969ey779eqhSbbddtuan9mV6dj1EMv17ANLIdr8fPu1pK/1fvRQJarVwsJ0FA/z\npdf+Sy+9FNp8PtbwS1U07JSvqx5KT0O6+DyDN3kqAQ096ufU+07DNpbCKaYUx7avnb169Qr1Uuhy\nDwf0pS99KZcvuOCC0KbrycKFC0ObhyD1uagz+Mtf/pJmz56d67oX9jnuxhtvDHVdH3fdddfQtnLl\nylz2UPYa1jyllI466qhc9tBu2223Xajr/c1TTz0V2nwe0Hs1D9WroZP9eP0z9Tz4teyhxfS6mzt3\nbmjr3bt3qGsY1f/93//N5c66P/N7S00Z43Ol73l0v1oVWlGV7ou9XrV26rXlofe1r3y/XBVSEG8q\n3TeVwm1WpRDRelWo1kZT13RlGsrQz5+PB10jqkKXa7/5OCr9W3+t39frvZDfC+sewv9d1ec0G7/2\ndV/88ssvhza/Z1Ue9l7XQ/+MUtqmqpRO+gzUX+tjXtcJDcmYUkrLly/PZd97+55S77dK56CZ6Hn1\ndVn3Og888EBo23fffUNd76u8n32d01Rp/sy09BzDQ6E6HaM77bRTaNN92u677x7afP7ojCkL1ofu\nUfzZj/6tHrbY76F0P+nv4/ckpfRPPpdqn3u6C59PdF/se8NS2qsbbrgh1PWa1LluQ+haT9UBAAAA\nAAAAAAAAdCi+cAQAAAAAAAAAAADQML5wBAAAAAAAAAAAANCw9crhCGwIHiddeaziUg5Hj5+tsZQ9\n55Pn+NB43h6TnhyO1TyHj+fjUlW5BerJ4ah9422eN0GV8slV5TxpBR4vXmOdezxzjVHuccW933W8\n+mtLefk8h4THvvf8QcpzyehrS/lqPFehzwkaq93nqFKOyc5q1qxZuezHr/m4NJdiSin95je/CfVS\nX5RyJ/l49LrGzfd8mh7fXq8lXxP0+D1X6c033xzqGvveY/N3ZZ6vTXm/1ZNHRtdonw88V4nWvW98\n/mrv8XRl8+fPD3WdAzzvg+d71Dx7VTS/nOcy8rqu2ffcc0+7P6Or8XwvOm9tvfXWoc1zimi+R1/z\n9H1SiuPT12D/HJ1nt9pqq9Dm41Xrfh1q/pxBgwaFtt/+9reh7vuEzuCvf/1rWFu1vLFcc801G/0z\nUT+/fnWtWrx4cWg77LDDQl3HtefY8nufeu6/Snw/pzmJfI2YPHlyLvva7sfn+zK8SfPfVu1JtS+9\nr/y5RSm3rO+Z/B6w9NpWVs+zAF0DS/eSKcW9V9V41L6q59xX5XnVMVjKWea5/5wefymHYGeluQxT\nis8l/F7XcxyrIUOGhLo+c6zq40bHVNX7aj/685gFCxbk8ogRI4rvq/dijz76aN3H2RnpcwM//7p+\nTpw4MbR5DnLdB1c9r9b7LB8r/m/12vNnMv7MVPfxffr0CW2aP/3AAw8MbaV+bgUvvPBCLpeeVepY\nSCnmz0wp5pL3a8XvzXRv5vOH73t0jfa+8Ps47XO/HjS/o+ccveKKK0Jd881r3uENgV84AgAAAAAA\nAAAAAGgYXzgCAAAAAAAAAAAAaBhfOAIAAAAAAAAAAABoGDkc8ZbzWOJa1/wFKbXNVVHKp1jK4egx\n9T0/jcZP9jjLHvu5qyrFi/dz5HGuNea05wfTHD4pxX4sxVZPKfaxt/l1pjHTPYedHp/nMyjlGG1W\nGsc7pZgTbdiwYaHt3HPPzWUfRx5LXPMWePzynXfeOdTHjx+fy54zxGPJDxw4MJc9j4LmlUkp5gLz\nOUHjonteV4+ZPnLkyFz23GMPP/xwajY6znzMqT322KP4PqU52HMtKs/n4fnDtM/9fXwdUKX8sZ6z\n7Omnnw51zxXZyurJ3aRjrEePHqHN8ydqX1X1m+YhqMrvovkvSjmpXCvm3O0It99+e7HeUTSX1/77\n7x/amiGnT2fkeVNHjRqVy74eek6ik08+ueb7Dh8+PNR1b+Zru+cm1OvH11nPVaf7DZ+DdV/261//\nuubxpJTS1KlTE9BMdM/s+5HSPcndd98d6uPGjctlX4M9H1TpHsrn4NKcXMor9Mgjj4S2hQsX5rKv\n+z6XbLvttjU/s9VV5cnSPanfo/h8qP3suaQ8567Oyf5an7/9/lC1Wp6vktIzJd+TnnDCCbns69Tg\nwYNDXZ8/VeWJ1LHtry3l/qvKka48J5yO5T333DO0ffe73635Ps3Inznq2PA+njJlSs33mTNnTsce\nWAcrPcd68MEHQ/3CCy8MdZ2vPd97s9Jx5s/8dMz533vMMcds2ANbh4svvrjhf6v37z4n+DMvn++a\nnT43XLlyZWjTse3PJvWZZ0op9e3bN5f9+Zc/E9Vz7OfTc/mW8t/6syldvz3f54QJE3L52muvDW3+\nXYfyv7ujtdbVBAAAAAAAAAAAAGCj4gtHAAAAAAAAAAAAAA0jpCrecjNnzgz12267LZc9PKKHi7r/\n/vtrvm8pZIT/LF5DRqSU0lZbbZXLq1atCm0eSqqr8p+Oq7vuuivUDzvssFDv3x5aPf8AACAASURB\nVL9/Lns4HQ+/oyESPVyi/zxc+9yvnbVr14a6/qTef5K+ePHiXK4KodoKIfv8mr7oootyeezYsaHt\n1ltvzWUPvbI+zj///A57r47w85//PNQvvfTSXH7ooYdCW2ksNCMNL+EhI7yu49XbfGzoefLwNKXQ\nFN27dw9tPifrvODhYTUUZyl0bEox5EWrh4qqZ95asWJFLnvoWz2/KcU12ucHD92lfezhoPz8a5gb\nXyOq+hVteaj4Rudy7wufC7VeFUJVw8j4/OBhRLsyDVObUkpnnXVWLnuYnq997Wvtft8ZM2YU6yXT\np09v92tL9BrxcLC+/584cWKHfCawsej97cEHHxzadP/he5z/+q//KtY7M71nSKltaLEbb7xxYx5O\np1LPPuzKK68M9QMPPDDU9TxPmzYttJ144omhrvfHHvLaw/n6tdhVle4JfN+j4eM9fJ/vg/V9SyFU\nnb+2nmvJ/xY9fh+f+pzF9431fEYz+P3vfx/qN998cy77HtRTqyjfv+q5qAqbuzH4daX7Rn8eet11\n14W6Pi/rqH3fW02fMfg9jZ4Pv99tNjrXL126NLS9733vC3W/l2h2X//613P56KOPDm0aNvynP/1p\n8X0+//nPd+yBbUAeUtX7VOtPPvnkBj0WfuEIAAAAAAAAAAAAoGF84QgAAAAAAAAAAACgYXzhCAAA\nAAAAAAAAAKBhm9QTO3qTTTZZnVJaWvlCbEx9X3/99W4d9Wb0cadEH7e+Du3jlOjnToqx3Pro49ZH\nH3cN9HPro49bH33c+riH6hoYy62PPm59zNddA2O59bWrj+v6whEAAAAAAAAAAAAAFCFVAQAAAAAA\nAAAAADSMLxwBAAAAAAAAAAAANIwvHAEAAAAAAAAAAAA0jC8cAQAAAAAAAAAAADSMLxwBAAAAAAAA\nAAAANIwvHAEAAAAAAAAAAAA0jC8cAQAAAAAAAAAAADSMLxwBAAAAAAAAAAAANIwvHAEAAAAAAAAA\nAAA0jC8cAQAAAAAAAAAAADSMLxwBAAAAAAAAAAAANIwvHAEAAAAAAAAAAAA0jC8cAQAAAAAAAAAA\nADSMLxwBAAAAAAAAAAAANIwvHAEAAAAAAAAAAAA0jC8cAQAAAAAAAAAAADSMLxwBAAAAAAAAAAAA\nNIwvHAEAAAAAAAAAAAA0jC8cAQAAAAAAAAAAADSMLxwBAAAAAAAAAAAANIwvHAEAAAAAAAAAAAA0\njC8cAQAAAAAAAAAAADSMLxwBAAAAAAAAAAAANIwvHAEAAAAAAAAAAAA0jC8cAQAAAAAAAAAAADSM\nLxwBAAAAAAAAAAAANIwvHAEAAAAAAAAAAAA0jC8cAQAAAAAAAAAAADSMLxwBAAAAAAAAAAAANIwv\nHAEAAAAAAAAAAAA0jC8cAQAAAAAAAAAAADSMLxwBAAAAAAAAAAAANIwvHAEAAAAAAAAAAAA0jC8c\nAQAAAAAAAAAAADSMLxwBAAAAAAAAAAAANIwvHAEAAAAAAAAAAAA0jC8cAQAAAAAAAAAAADSMLxwB\nAAAAAAAAAAAANIwvHAEAAAAAAAAAAAA0jC8cAQAAAAAAAAAAADSMLxwBAAAAAAAAAAAANIwvHAEA\nAAAAAAAAAAA0jC8cAQAAAAAAAAAAADSMLxwBAAAAAAAAAAAANIwvHAEAAAAAAAAAAAA0jC8cAQAA\nAAAAAAAAADSMLxwBAAAAAAAAAAAANIwvHAEAAAAAAAAAAAA0jC8cAQAAAAAAAAAAADSMLxwBAAAA\nAAAAAAAANIwvHAEAAAAAAAAAAAA0jC8cAQAAAAAAAAAAADSMLxwBAAAAAAAAAAAANOwd9bx4k002\neX1DHQga9/rrr2/SUe/V2fp4hx12CPVVq1aF+l//+teG3vfd7353qHfr1i3Uly1b1tD7biit3Mfu\nPe95T6i/853vzOW3v/3toe0f//hHqG+66abrLKeU0t///vdQf/HFF9frODtaR/ZxSp2/nzfZJP65\nu+22Wy57X/lrdfy+8MILoe25557rqEPcIFptLG+22Wa5/L73vS+0+XzdUfr27RvqK1asyOV//vOf\nG+Qz69Fqfdyod73rXaHev3//UJ8/f34uv/56c/2Z9PGGtfnmm9es+/7N13qdA55//vnQ5mtLhTWv\nv/56t+qXtU9n62fdW6WU0hZbbBHqje6RvO/e8Y54q/nqq6829L4bSquN5be97c3/S9y7d+/Q5nvm\neug48/na6/pav5/6v//7v4aPoVGt1sclPt4GDx6cy1Xr7GuvvZbLy5cvD21/+MMfOuDoNpyudg/l\n+yvdF2s/ptS233XuX7RoUWhbnzliY+hKY7mroo9bX1ebr7sqxvIb/H5rq622CnV/ltlM2tPHdX3h\nCHQE//KgdAN09tlnh/rll18e6vPmzWvoGHbZZZdQ/8xnPhPqn//85xt6367E+1Hr6/NAYfjw4aGu\nXzr7Fxr+MLF79+65vP3224e2xYsXh/o111zT8DEqfbjzVjxI6cz0mvBx7jfLv/3tb3P52WefDW3+\nAGXXXXfN5csuuyy0nXvuue06nnUdE+q344475vLBBx8c2ny+7qjz/a1vfSvUv/GNb+Ty6tWrO+Qz\n0D4+NvXLnj59+oS2CRMmhPp+++2Xy3V+EYQWp3N8SintscceuTxkyJDQ1rNnz1Bfs2ZNLn//+98P\nbUuWLKnnMJbW8+L14WuT07mzo9Yx3yONGzcu1K+++uqG3tf7buuttw71e+65p13vo3urlMpfcrG2\nv0n/097Xv/710OZfIuk59nPm/8GvR48euez/scf/86e+9swzzwxtnf2Lq87Ar32/vv0LJbXtttuG\n+q233lrz3/nnvPLKK7ns998TJ06s+Zl+rei1xH1R+9Uzj/n+6sorr8zltWvXhjbfX+ncf8IJJ4Q2\n/Q98VfR4/VoqXaMAALSS0vrt91vHHXdcqP/gBz/YcAfWCRBSFQAAAAAAAAAAAEDD+IUjOh39X3J/\n+tOfQpv/b/U//vGPuexhQTzM1oABA3LZ/9eghnZDbaX/ha/n1P+nY+l/uHp4tCuuuCLU9Ves+r+m\nU2ob8mvYsGG57L9oHDNmTKjr9fLwww+HttLfWc/f1tWV/neuh2/T12qYzpTa/u/pW265JZdfeuml\nDjmersyvdw3N5GNO/wd8SvEXhR/+8IdD29ixY0Nd+9H/F/6f//znmsfn7/PjH/841PUaGDRoUGjT\nX+D5rzJ83uf6qObzn59THbv+i6lPfvKToa6RBC655JLi5zDPtp7TTz891Hv16pXL/isonR/uuuuu\n0Oa/oPvqV7+ay08++WRo83mns/C5pxRBojRPeUj6ESNGhPqoUaNy2cfYIYccEupHHnlkLo8ePTq0\n+a9rJk2alMved17Xvbj+GjWllB5//PFcXrp0o/3AtKV8+tOfzuUvfOELDb+P/0LJ92GqlN5g8uTJ\noe2qq65q+JhaWWmvUo+LL7441Pv165fLf/vb30KbzyUa9vyHP/xhaBs6dGjNzyz9mq0UBaEr0nve\nv/zlL6Gtnj3opz71qVAfOHBgLt97772hzftdf11x0UUXhTaP8FQKga3HWzVf8ItHAECrKq3f119/\nfajvueeeoX7++efnsj8D3Rj8GcyXv/zlUG/vPWgt/MIRAAAAAAAAAAAAQMP4whEAAAAAAAAAAABA\nwwipik5Hf6rroZgWLlwY6vqzYw+rVQrj4knRS6GC3Pr+rLiZtffvree83HzzzaHuffz+978/l5ct\nWxbattpqq1C/6aabctlD8B122GGh/tnPfjaXly9fHtpKobw8LEwp/GpX8773vS/UtX88dK6Gyk0p\npeuuuy6XzznnnNDmIZj0vTR8XkopvfOd7wx1Df3m4UDXrl1b8zO6kuHDh4e6htrzseAhbP/+97/n\n8r777hvadt5551C/8MILa77WQ2Lfd999ubzTTjuFthdeeCHV4teVhu7dZpttQtvIkSND3cMvon4H\nH3xwLvt487659tprc9nDeRBCtfV5iD4Nke8hlnVfcPfddxffV+ezj3/846HN55Knn366fQe7gfk+\norSH6t27d6jrXKph9dZFz7GHyvNQlxom84477ghtvl7qvsj7zvcF2223XS77HLzXXnvlsu//n3ji\niVDX0LpdbS9eomuez6MLFiwIdQ3B6/dMHnJX75O8j//617+Guobm9H16V1a6fyztQY899thQ/9rX\nvpbLHu7Y90fPPfdcLntIaZ93NE2F3nul1LaPJ06cmMu33XZbaLvyyitzuSvurUv97GFU1f777x/q\nJ510Ui4fc8wxoW3lypWhrntoD6HqY1n3uv6ZM2fODHWd26dNmxbabr311lzWe7iUuma/AwC6hqrU\nL/o8RFOGpNT2ebbeJ/n76nO2lOJe3T+znmcn733ve3P5qKOOCm0eUnV977H4hSMAAAAAAAAAAACA\nhvGFIwAAAAAAAAAAAICG8YUjAAAAAAAAAAAAgIaRwxEbnccBLuWu2XLLLUOb54TSHC8et1jzz6RU\nzve4/fbbVx026nD00UeHuucY0RxLnt/H+3HQoEG57DkhVq1aFera5x/5yEdCm+dq2n333XP5Zz/7\nWWhbs2ZNLt9+++2h7Re/+EWod7XcQdpfPXr0CG1/+tOfQl37S3PDrMuDDz6YywceeGBomzVrVqjr\nWB4zZkxo8/xemndG8xWlFHP6eb4oz4/Sanr27JnLno9Jz4XHjvccmZtvvnkuv/zyy6HN80Udf/zx\njR2sede73hXqnnuqFu9jj5Pfr1+/XF6yZElDx9bqqnIWaD6gCRMmFN9LcxnpuU+p7fnXzyW/Y2s4\n44wzQl3H9fjx40Obzh3nn39+aJs0aVKo6z7Ac8MeeeSRoX7ZZZfVccQbTtU+YsSIEbl8yCGHhDZd\nZ33c+PuW8pV7zjb9t1X5uDSvsr+P5xPT3JGeb06Pz99n7733DnXdB9xyyy01j72r8TylyvfbOub8\nXsz3Bdru71PK/7jLLrtUHHHXUboudY777ne/G9p0v5ZSzKtXtVfRfa/nD/RxrTlened8HTt2bC7v\nt99+oe2ss87K5S996UuhrSoHbyso9bOem4MOOii0eZ4n3X97DuxNN9001Lt161bz833PpPc+vm/3\nPO36Xn379g1t2ree8+nMM88Mdb3HqydnMQAAnU3Vs4iLL764ZltpDfR9mu73vO73dNrmn+Hfiyjf\nT3Q0fuEIAAAAAAAAAAAAoGF84QgAAAAAAAAAAACgYXzhCAAAAAAAAAAAAKBh5HDERldP7H7P0ec5\nuDTfhOaQSaltXONSvkfPU1ZCroF1O+2003L5X/7lX0Kbn1/Nj+d53jxPiOYf8RwWmgsypZg3ZuLE\niaFt6dKlNY992223DfVRo0blsv8tI0eODHXPT9Lqttpqq1z2XB+eq6mUW89zlcyYMSOXPS+jxy9X\nnvtNcwqmFPNKeoxyjZPu+WK9vnbt2prH0Az8b9fcqD6uNBeM5970vE46l26xxRbF15b6sXS8Pl/7\ndaZ1/zv1etCcX+t6n+222y6XPYa+5xrrqqpyufXv3z+XZ8+eXXztTTfdlMuaUzclcmi2Ct3vVe2d\ndDz+6le/Cm1a1zUopbZr/VNPPZXLd9xxR2jzvICdlecZP/TQQ3PZc5n7PFuiOTx8rvT8Hrpvq8oF\nqXN7KQ9cSnE+93y8Or/4XtDvB4YOHZrLU6ZMCW3PP/988Rha2cCBA3PZrw3Pwav96m1eV5obO6Xy\nGu17PbzBr/3LL788l32v5Nez5tL2e2ofm9rHnmfdx7zm5izdbzt/H90LXn/99aFN89GmlNKyZctq\nvm8r+OAHPxjqn/jEJ3LZ57QVK1aEul4j3h+lvJ5+TfjeV/uyKq+nXj9+vDru/Xg8D6nm9+Y5CgCg\nlenepnfv3qHN12hdS/3Zqe/ptO5tJaX7LX+W6veg+ry3nvv6/49fOAIAAAAAAAAAAABoGF84AgAA\nAAAAAAAAAGgYIVWx0dUTUtXDAb33ve8NdQ355CF9/H015Iv/rNjDwZRomCH/zK7E+3GfffbJZQ2Z\nmlJK8+fPD/Xly5fn8jbbbBPaPOSPhhLyUC833HBDqH/5y1/O5TvvvDO0+bWkIXg9RNlzzz2Xy088\n8URo03BVKaV0yCGH5LKHdmsFHlq0FBbTw/boa/1n/94fWtfQlim1DZes/bVmzZrQ5p+joac8RJiO\nXw9XpKGlUmr+kKp+TjVUqoco1FB2Pj51bKTUcaGRvN90Tva5xkNTaKiHUqg3fx8PGaH/1q/7rhxS\nVcN7+Bw8duzYUH/mmWfa/b733ntvLh9++OHF1za67pbGPNZf1X6uND/06dMn1I877rhcHjduXGjT\n8Jm+fzv33HNDXcOnP/vss6HN57rOavDgwaFe2q/o3FkV+lTbfa70EKu6dvq493Gk87WPOd8XlI5X\n/63vNTxcun6mhwPqyiFVu3fvnsu+ny7dJ3kfe7/pa/268j7XvvE9BN7g6Rh0jHvoSh2LKZXD3Xqo\n+NK9r18Pus+tmkt87lcaptPv2y+44IJQP/XUU2u+TyvQdCMpxf2q95X3j86Bfh493YGue75H9vsX\n3ad5ShHvd71G/BrQlCcecrdv376hvv322+eyPgMAsP6OPfbYUD/jjDNCXdMD+X08gPapJ5zokCFD\nctlTUPm6q+/rIVX9XqjR5xh+j6f3kp5u5Igjjgj1X/7yl7ncyHM/fuEIAAAAAAAAAAAAoGF84QgA\nAAAAAAAAAACgYXzhCAAAAAAAAAAAAKBh5HDERldP7GHPb+Axhkt5nTwGsr7W82FozrIqHZWzrNmN\nHj061DXnkudNWrRoUaj36tUrlz2Xn+cm0TxrmhdkXXWNMe35Izz3hOb8mTFjRmjTfFFLliwJbWPG\njAn1FStW5HIr5nD0caRxxj23ovdHaax4f2jOPG/zPER6TP4ZnlemNN/ov/XrrpSfphn5eFi8eHEu\n9+zZM7RprpinnnoqtJ1yyimhfuCBB+by5MmTQ1spD5HnmPEck5r31ceg54TaY489ctnzMt544425\n/PLLL4c2z9OpeW38eLqyUr6oE044IdT9GiiZPXt2Lo8fP774Wh3HPidp7jFyNm5cpRx8KcXz722e\nY0ZzUv3sZz8LbZ6TueQzn/lMLk+fPj20eZ6pzmqnnXYKdV1bPQ+H5mjzvIxV+6ta75NSXIercnXq\nGPQ8ZL6PL+WB1vf1/YXnFNS/zXNePvroozU/o9XpNeDXive/9tsWW2xRfK1eD54Tzq8HzYn997//\nvT2H3eVofh/n96g+NrVv/Nz7+NOx63trH4ulHKqltbSe/bOP1Van97spxbFT1R/a7m3ez/pav2fy\nf6t7fO/X0j2U97PO0T7OPSfsbrvtlsvkcERXUk/et3pee9ttt+Wy5z33Ma/Pqnz9/ulPf5rLvnfy\nXLGrV6/OZc+J7nPA448/nsv1/F1AM/LxMGDAgFzWPXFKbcen3idV5c9WpXs65/tIf5aizjvvvFDX\n5+uN4BeOAAAAAAAAAAAAABrGF44AAAAAAAAAAAAAGkZIVXRq/vN8/zlwKWyLt+lPkv3nyq+88kq7\nj4lQAG/w0KIaRtXPp4ZSSSmlp59+Opc9xJmH37rqqqty+aKLLgptZ555ZqifdtppubznnnuGNg+f\nqGF0X3jhhdB233335fIdd9wR2nbddddQHzhwYGpl/rN/HZMegsvDuelP/T28TlUoIeXXhIabqgp9\nqu0+f2jYTD/2VgvFOGvWrFDXMKreN9qmISFSSunBBx+sWV+6dGlo+/a3vx3q2m8//vGPQ5vXf/Wr\nX+Xyxz72sdCmoWFSSumCCy7IZQ8voWHLPBSrhwDW63nNmjUJbyiFxNt7771D/ZxzzmnoMzzcyC67\n7BLqGmK3FEKk1cZtZ1cValN53zz22GOhruGZDzvssND2gx/8IJff8573hLZrrrkm1DWMk+8vmiWk\nqqcP0HCiHiZTw+J4m9N1ztfc0hpcT8hEX9v93+o14qEjNUxgVZoEnb99f9eV1bOX0pCIvj/q379/\nqD///PO57H3haSl0zfDPxBt69OhRs83HRSl0dT1j08eUv69+rrd5P5bmer0+SukTugKfk3W/raFN\nU2q7D9LXer96f2h71TqgY933d37t6fW1+eabhzat+7H79UGago5Vz97LjRgxItRPPPHEXB4+fHho\n05QWHlbv4YcfbvdnYv35c7exY8fm8ksvvRTafG7RlCIenv5LX/pSLletJzrveFjne++9N9QPOeSQ\nXObZKVqdPy/TtA8rV64Mbf48SseH79N8D6Vj0vf72la690opzgMeOnnQoEGhfvDBB+eyj/P24BeO\nAAAAAAAAAAAAABrGF44AAAAAAAAAAAAAGsYXjgAAAAAAAAAAAAAaRg5HdGqeS8Bjkq9duzaXPf+I\n52TTnBJV+TFQbeeddw71mTNn5vLgwYND29Zbbx3qmp9oypQpoc3jXH/yk5/MZc39mFJKn/3sZ0Nd\n42U/8cQToW3UqFGhfumll+bykUceGdo0T4HnoZsxY0ao+zXZajxXj+b78HweHndcY4JrrqB10bwA\nnn/E8zPp2PYY5aUcNR4HXXOBef6RUp64ZqRzZUrxPHm+PJ0fPd+Oz6s+JtXVV18d6kcccUQue76J\n//mf/wl1zauqORr92FOKc7/nFd1qq61yed999w1tjzzySKhrnkDNd4E3aU7MlNrOD359qNJY9evT\nc5Vo33j/6/uSw3HjWp+90y233FKs1+Jj/Itf/GKojxs3Lpdvv/320LY+eY82Js/LoWupr7uaN8Tz\nZPkcp2ug590r5VX2fGE+7vXf+rH7Odb13OeLfv365XKvXr1Cm/8tOu97Xs+uTHOoey5Qz9emY8n7\n3+dkzdfk+Y9LOR39OsMbPIejjhM/n55nW19bytnpr63K7ef7YOV7eP1cH+P6Wl+TW/2eyXmes1IO\nND83vk9Wfs71mintkVIqXzM+J2tf+vHp+5RySaXUdt3C+qln7zJ+/PhQ/81vfhPqixYtymWf2/VZ\nz+mnnx7a/LWal9vvDT3vl9/ztTLtq6ociaWxedFFF9VsK+3J/H19Tdb5wt/H6d/i+wvdeyCqelal\nPvCBD4S6ntd58+Z1yPHUcy9UyiGYUtv9SSsrnSefZ3XNK+2fUorXh59fr3t/tFepz/07FHfdddfl\ncvfu3ev+7NZ6ogoAAAAAAAAAAABgo+ILRwAAAAAAAAAAAAAN4wtHAAAAAAAAAAAAAA0jhyM6Nc8F\n+Kc//SnUNQZyt27dQpvHx9acYB7H2PMRotr2228f6ppjy02dOjXUS/32hS98IdQ1d9GSJUuKxzR7\n9uxc9nwRGn86pZQOPfTQXF6+fHloO+uss3J52rRpoc3ft9Vy/TnPd+pjUHl+GB1nHnPcx6fmDajK\nBaLn3N/X45BrjhTPTaK5pNasWRPaPGeV/m1Vsc6bgebqWbFiRWg77LDDctlzOHo+Vr0+NIdqSnHs\nppTSf//3f+ey54n41a9+FeqaK8ZzeJZyw2g+s5Ti9XrTTTeFNv+7ydtY7ZRTTgn1hx9+uOZr68lZ\nMXfu3FDX3L0ppTRhwoR2vU89x1DP8WH9lebxlMq5a7bZZptcPu2000Kbzw+ag7nqGDpLDseqfFea\nc8fzpWjeRt+HPffcczU/x9exUu4eP756xoq/r649fg3oPKB9vi66tvv58r1IK6zZ7bV69epcHj58\neGjzNVr71fM7Oh0rnnvuj3/8Y6hvu+22uaz7crzJczjq/OfjzZXGXyn/T1X+MG33ubG0L/fxpftC\n30tXjetW4GuS0vnbz42Om5Rijjy/9yqtZd5Xpby63ubXluZB97lcj9+Px6+J0jlB++g5rtq7aB64\n73znO6HN88Dp/O1zud6LzZo1K7T5Oqt5l/v0+X/s3XncnFV9///Dt9oKFFmyAQlJSEISQhKWQICw\nyb5EQPZNRUtksYpSWUSkgmhBWxBcSq0KVLRQsBAW2SIgyA5hCSEkJCEL2SCLJohLteX3B4/f8f15\n35lz3TO57+SeuV/Pv87JmXvmmjnLda5rMp/PVjWPJ6WU7rvvvlz2fMGtptRvpbXc9zWanzyllN54\n441c9nyKpfXa53Hp+Pwei65f/li/n9edlXJougMPPDDUTzvttFDXe1ee697ryvtZz+8+7vx4dW2v\nyhON95xwwgmhPn/+/Fz+wAc+ENpKn3/V/q+kdF7wNh0PvtbMmzcv1AcMGJDLY8eOzWU/J9TS2nfK\nAQAAAAAAAAAAAHQqvnAEAAAAAAAAAAAA0DBCqmKtqyeklYd/8VAP+hNkDeXgbSnF8HkeVshDEaCa\n942G1vCQXxoOL6WUjjrqqFyePXt2aDv88MNDXcMyetgND0k0fvz4XNYQuim1Dcf62GOP5fKpp54a\n2jQso4ce8RAFHgqh1ZTCa/hn4WEXdEz48/gY0fHkz+OheTQUgT/Wx6WGJNLQMCnFsGAe3sDXqfXX\nX7/m8TS7xYsXh/rXv/71XD7yyCNDm4cs1X7UsH8ptf28NWSph+JxpTXZ+0pDVWy44Yahbc6cObn8\n+uuvF18T1XSNTSml/fbbr+Zj6wm7+Pzzz4f6FVdcUd+BNXAMhFBdu6pC9J144om5/LnPfS606Vrt\nIYR8rKxYsSKXmyVsru9XPfyOhsn0tfGuu+7KZQ2xlVLbtAS6L6pag0vn2XqUQu15yG5dox966KHQ\n5u/ltddey2X/THr37h3qHj67leme1c/fPv419GVVSHENz9u3b9/iYzVspu/x8R4PManXt95PpRQE\nHbmmeajc0jGUlPbzpdDNrUJDC5bSPvg675+/fo7+WA/Hqvz6ylNjaB+UQvCmFM8T/l50DPt1hPOQ\nbWir6v5Y6X7ZuHHjQl1TSHg4Xr8HpuPF02bota/z49HrbU9h4ud6PZ8/9dRTNV+jFTQauv/HP/5x\nqHu/6Xz09dn3vnoMVekNlD+vjiW/xtfwy91d1Z5Zwxx7+OGXX3451IcNdYT0awAAIABJREFUG5bL\nfr/S75lqOFY/D5SUHrvTTjuFuq81I0aMyOVbbrkll5977rl2v34zGj16dKgPHTo01DVdV1WaB52T\nVfOz1Fc6X/15/PytaRR8Lvvx6tp+2GGH5bJfc9bCLxwBAAAAAAAAAAAANIwvHAEAAAAAAAAAAAA0\njC8cAQAAAAAAAAAAADSsywfS32GHHUJ9+PDhuez5mDyOrMam1Txw9aon5yCqVX2eGgNcYwanlNKy\nZctCXfO0PP3006HNc3lpThHPBeix5dsbF31N8to0I43p7PkkNB6/x7Hed999Q13zKZ5zzjmhbcKE\nCaGueZ08zrmvAfPnz89ljSmeUuz/lFLaZZddcvmVV14JbZpPwGNe6xrkx+B5MnQNalY+P0u5Op3G\nKK/K/6Kv4zleqnJFKu8vzTfg+Q/0ef29+Pv2dau78FyoPv713Oqfr8ed32ijjXK5auxoPqOqPGw6\nt32svP322zVfo9XO7Z5nQddo/exTivlVPJfAq6++Guo33HBDLo8cOTK0+bqq7W+99VZo877Qup+D\nNfdmSin16dMnl/3cruuu5wny81TPnj1zecqUKaHN8/yic1122WWhrvkw/v7v/z60eY7PEp3XzTKn\nfe/g57hSXg7NT+i5mnzeax4+z9Hh66quET6v6skp4m363jyPnZ5Dpk2bFtr23HPPmsfg634p71Sr\n0/w/3k++P9L6kiVLis+rOR49h6OPVx3PM2fOrDji7snHrPaF91NVjvFSm9arnkfXy6rci6V9uD6v\nz/9SfnS/5m9Wvu4qff/+Gfq9Cc2r5PexSmPE+7l0PnGeR1JzRfrz6LnH+9Wvf3Xv1QpKObdKn6/P\nI50f9exXrrnmmlA/4IADQl3Xc8+nqNdXKcUcyKX3UvU+dexUXfNrHrBWz+Go50PvY7/+2nvvvXP5\nmGOOCW2eJ1U/76p7FroXqCc3qM95vf7yceXXh62udM9v7Nixoe1HP/pRqN9555257Huk/fbbL9Qf\ne+yxmo899thjQ33SpEm5fPfdd4c2vSb3+zXed5tvvnku+3WF5w/Wcan3f6dOnZq6Ij93qnru62u+\nypTazgd9HW8r3dequjeljy3tvb2fStdpfk7w60Pdp2m5lP9V8QtHAAAAAAAAAAAAAA3jC0cAAAAA\nAAAAAAAADeMLRwAAAAAAAAAAAAANqzuHo8YeryfObSk+9AsvvJDLHvP7hz/8YaiPGzculzXmeEop\nLV26NNQ1/qzn83j22WdDfeLEibk8Y8aM4rGX4mB3lmbJQ9MeVe9l1KhRuez5lzzWea9evXJZcwmk\n1DaHwmabbZbLs2bNCm0eq3i77bbLZc/z1J3p5+/zX/NfeT957sXjjz8+ly+66KLQdvLJJ4f6zjvv\nnMueW+KJJ54I9SOOOCKXt95669DmuYI036PngtTY655H6MUXXwx1XZP8+Foxh6P2u78/nWMpxXnm\n67XHKNfn9Zjg/rl6nhNV+luP217Kq+DvrbvmcPS8ufXEhC/x3AeulI/GaS7AbbbZpqHjaQUDBgwI\ndc3B4PkaNJ+A96nTnB2aHyylcn5ez+Xr5wV9Xs8R4fkeNT+N5qFLKeZ/9L2erwf9+/fP5RUrVtQ8\ndrRPKV9YSnHu+jnYc1IdeeSR7XpNX8d9L9KM+2XP61TKHe75TnX/6vNTc2CnlNJrr7222udMqZxH\n0vOmer4P7feqXNb63jRne0opLViwYLWvv7pjKOW88z1Dd6LX1M7P1zp2POeu0/m6atWq0FbKvffS\nSy8Vn7c76d27d802nSd+HvPxXc8ap/PN52Zpb+WvUZWLUen8q1qfhw0blst+fdWsSv2s667mRU0p\npfvvvz/Uv/SlL+Wy51MvnTOqzst6DH4e8P7SPJJ+7XXPPffk8qmnnhrafM85ZMiQ1F1o3/i8KV0z\n+Tw//fTTQ/2LX/xiLvu1mY8PPV/6udP3EDonfTxom+/hnY4dn+eew0z3Jv/4j/9YfN5mp59L1b3z\nRx55JJe9j/1v68mZWco5WuL3R3X8+rWj33fVdbBqf9GZqnLilT4bnQ8+d0v3+M4444xQ9/ybeu9T\n72WnlNIee+wR6nvttVcu+7XxT37yk1AfPnx4Luu97JRS2nbbbXPZ36evH3pu8v2drwN6n/yBBx5I\nXV1780+n1Has9OvXL5f79OkT2ny+brDBBjVfx8+PuvbXk2PVzxnaN1V5t0vXlf6aOu4uu+yyXPb3\nUQu/cAQAAAAAAAAAAADQML5wBAAAAAAAAAAAANCwukOqNho+TR177LGhrj8DHzNmTPFvr7322lz2\nn73uuuuuoT548OBc9vAvHu5iwoQJuewhif7rv/4r1KvCj3UGfa/6E9h6wtp2FVWhYDQMW1VISv35\nflV4KA3p6J+b/1xcx46HVG3Gz7wzeD9q+EwPpeeh0nSOHX300aHNQ3VNnjw5lz00q/fx008/ncsa\nmiultv04YsSIXB4/fnxo69GjR83X8JA3o0ePzmUPPdGsdC6VQuT5T/k9LERprSqF9KgKxaJhAkoh\nX/14vS81ZHNV2KdW6dvVKYWQ8PAdHj7BQzYo7zete1/485RCPvl5Qc/vHkqvI/YszcJDhOr4XrJk\nSWjTsBseBscfqyFMvS+mT59e83m9n7wv9LH+vB7eRUPMeXgoHTsemtX3az179qx5PHhPVUiZRnnI\npzfeeKOh5/G1eocddqhZv+GGG0Kbj7OqMFRrS1UYUq2X5quPd1+vPVSj8ufVz9nXcqfP6+dKH0+l\nkFwatrMqLKqG6G2F8PUdRddkD33ln9NvfvObXPa54fRvfU0ovQ4hVf9CrzuczreqEMvtDYGYUpx/\n/jylEFv1rPt+DH5tUKJh8FslpKquXT7ndK33tDEaTjGllL7xjW/kcmmvnVJ994bqCamoIVU1FUlK\nKT333HO5fN5554W22bNnh7ruvboS/Sz0M/Yx7ecqnR8+V0r7Ck0Tk1JKZ599di77fUy/j6H3Qzwc\nr6YLSKl8/vbweaXw5KX1o7Tu+15DzzUpxdCPmppBx1SrKM1H36Npn/uY22KLLUJd+8OvZ3y9aO96\nXtqv+Ws6bzvmmGNyWe/fr21V773RuewOOeSQXPZ0AX5Nqzwl3OGHHx7q+p2Ff44akjyleA7xOad7\nc0+B5OFBda1/6KGHQpvea201VWNF12CfY6V7HL4GlMLbl+67entpfvo5zFNb6Xrt53a/96dp6/w+\nfXvwC0cAAAAAAAAAAAAADeMLRwAAAAAAAAAAAAAN4wtHAAAAAAAAAAAAAA2rK4fjBhtskLbddttc\n15jgHifYabzZW2+9NbQNHDiw9gEW4uN6nN2nnnoq1DWPxVlnnRXaZs6cGepXXHFFLo8cOTK0nXHG\nGaF+xx135PK8efNqHntH0vfaajkEPU9Lv379ctljHHs8Ys1/4GPF48dr7GJ/Tc+x4Lno8B79TDV/\nTkpxjvvn6XkpPFa08jjnmo9p2bJloc3zB2iOCI+JvuWWW4b6Cy+8UPN5dNy99dZboc3HleZC8Nyw\nnlOtWehc8nwOuv74Gux95/lJlMckL+Un8RjlpbHmsc9LeXE0F1wpR07V8bUy/3w9F0gpR6Z/pqXY\n8iVV+Xl1fHjceXJ7vcfnotY9J6LH+V+5cmUuz5kzJ7T5uqqfv+cf8fGgfaOvkVLbXCWaD2PatGmh\nTXP7+ljxuuZrLuWz685KOcBW116in7/nffDcNZpL2a8pdDx4/iHP4ejjo9bxpNR1cjj6HPTzrh6n\n5xz3Oak8z5POI1/LPde95nvxddTnjh6ff6b+XnTt8XyPupb78fm4K+V4JD/rezS3ekrlnNeaq211\nSnljnOf2xXs835LSz9THtl9v+flS1bNe+2O1Xmrz5/X9sc75qr2z7yFaga6znhNb17wNNtggtPm8\n0fOgjwnfX6mqHI3a7muwP6++rl9Xa745PyeU8hB3JTqO/V5Ao/Qe0pgxY0LbOeecE+o6P6ZMmVJ8\nXl0HdN+bUtt7g9pvPh783KpjwMdDKR+rj8lSHjIf63puOvroo1f7752tlK/Sle4RVO2JNV+e3zfW\nvNUpxfHg637pGqqe9bqePbyf63UP7a/ha8ell16ay2sjh6MeTykfcWnf7+P0gAMOyOX9998/tA0a\nNCjUdd4vWrQotJXuh1XR+5CaFzOllK6++upQ/+hHP5rL/r2I5mnv0aNHaLvyyitDvXQdVaJ9UM84\nW5tK9zWd55XWvZe/P7821Ws1f83SPTB/bGl/9c4774Q2vX/jY873Inr+9nOC51zWsdMIfuEIAAAA\nAAAAAAAAoGF84QgAAAAAAAAAAACgYXzhCAAAAAAAAAAAAKBhdSWl2nTTTdMJJ5yQ6/vuu28uT5o0\nKTzWYxdrjNnvfve7oW348OG5vP3224c2j2OrscU9dm4p3qzHKu7Tp0+ojxgxIpe32Wab0OYxtDXf\nwIMPPhjaNJ55Kb9cSuX8g56jRd/3yy+/nMtTp05Nzc5zNelnWIod7zzuvMdk1vwk/liP5+0xvPGe\nAQMG5HJpbvrn6bmbtO6P9TyNmgfRc0BsvfXWob7jjjvm8i9+8Yuaz5NSzCM5duzY0KZxrX2d8TjW\n+jl4DsdmzWNTisGu/aV5CVJq288az99zPfiap/PVP2M/hlIM9VJOKM8/ojHUfTyTA+o9VTnO9DP0\nx5Zy8NaTz8Vj3XuseX0df15dyz3WfVfNL9Aoj9e/+eab57L3jX6mVTkyde30Ndf/9pe//GXNNs9T\np3Wf8y+99FKo63vzdVbzJXlOEd+H6TH5eMDqVeV0VPXkRPR5fPbZZ9dsK+UG8r1ePbmDuwqfGz53\n9D16nhy/Xqj1dynFz8bPcT5XtO7nR3+sPq+/ZmkfX89519t0XPp53/PQdleaqzyllEaPHh3q+plW\nXfdoztWqnNeTJ0+u6zi7i379+uVyKU+4zyHPJa/j2+d/PbmCSjmPSzm4U4pzztfrUj7Kqns3rUD7\nx9ctnWeeq9jpWu/7Mj8PlPrZP/N68nrq63o/z507t+br+3jxc1xXdNBBB+XydtttF9r8nKJ1v0+o\nY9r/7s033wz1Us4+X5P1saU8z97ufVqa96U8v6UcginFsV6VN1KfS++r+jjvCLXuaZRyt60Jv0bR\nPve82k7XS/+8fS0p5cf1PZq+b+//0p6+Kgev8nOR5jRcGxrt289+9rO5vNdee4U27TvPged5DjWf\n/E477RTaPGd9ST15mD//+c+H+qGHHlrzGPQe2KuvvhraSjkb6zmedXVfxcdp6VqiNDY816h/L7V4\n8eKaz+Proa5l/rn4eCjtv32t1zXEc/mqww47rFjX3Ln+vV09n2d78AtHAAAAAAAAAAAAAA3jC0cA\nAAAAAAAAAAAADasrpOrChQvT+eefn+sa/ujwww8Pj/UQpvqzcP8Z6ahRo3L57bffDm36M/uUYviG\nqnCb+pNx/4m+1/XnwlXhP3bfffdc9p/a6k9Qq0JY6GfiP1X1z0h/pq6hVWbMmJGanYe31X71z6X0\ns3/vUw8nUArn4c+roSI9PJeHhehOhg4dmssaojallPbcc89c9jnkoes0bIj38cCBA0NdQ+35T8eH\nDBkS6j/72c9yWcPsre4YdN0phQ7y/teQCSnFn9T7utcKPESAvt/1118/tGko2pTiergmYTlKIdr8\neX3ea9gnD2Wi4SU8lI2HvfHn7S58fvp4KIVJrQqx1Cjvc31dX5/79u2byx5St9X4+9NQqD6n9Hzp\n4Qg17FtKKT366KO57OFm/Nyp66yvD17XkGAeUnX58uWhXgr1pnPVz0s+JjXETz0hbppBaX9UFeam\nFH6rFMrS+eevz3XssceGNg/Pq2HOfTzovPY2/buUUnrggQdqHl9XDaPs76kUas/bSuGBfB+kf1tK\n3ZBSnHM+V/x4S+FXfb3Wdu+P0jz39U2vF32M+vF1Vx7m3vtYVV1T61palZbCr+XxHr3eLYUl9vBW\njz/+eKifcsopubxq1arQ5vOtnlCbpT2at+laP3PmzNCm5+QxY8aEtqp0M61A51Ip1GVVSFVdo/0e\nRynUeWnNTam+lAZ6fvHze+k1/H2Xrge7SgoLHaueXsnvR2oIPH+vpb2YpqZJKfZraa6mVA6p6vXS\neGh0r+h7DT8P6LgqrW9e1/NF1WfQiI7Y93n6p3HjxuXycccdF9o0/VhKbfeoykMp6jWU96l//jru\n/HMr9Xlpr+dzsZ7wq6UQsHvvvXcuP//88zWfo6NoKGO/9tSwmCnF+8OeCknvuZdSo6UU06z5/vrE\nE09sz2GnlMrj1c+ngwYNCnUN5+vrvKas8uv8Sy+9NNR1D+3jzq/PFy5cmMs33nhjzWPvTGtyDtH9\n1JlnnhnaPPSspqrxsOauND/9nqNe45bC7acU74X7vUo9b/k+/OSTTw710nWSX/P5tUS9+IUjAAAA\nAAAAAAAAgIbxhSMAAAAAAAAAAACAhvGFIwAAAAAAAAAAAICG1ZXD0X37299ebTmltvFmNdeh5sdL\nKeY00JjLq3sejWftMYVL8ew9xq3Hol25cmUua96jlNrmhNI4wR5fWx/rsaw9lrLGN/dYz90pX5jH\nRdfP12Mel3KCeRx0//w1r2Aph6e3a7zmlGIe0e5GY5lrOaU4xzw2uMdP1z72WPL+WM3p6Dkcf/7z\nn4f6zjvvXPOxd955Z6hrLgqPw665GjyXiueHOvjgg3O5nrwYXZn2ia9xOo88L6auoynVlw9G53Zp\nLfd2byutGT7v33jjjVwu5Xhd3TG1ktJ783Ny6dzkMfTrySW0JvT86THrN9544055za7IP2+Nz+/7\nGN0/+d/5Z6g5ITz/jOfr3XHHHXN5yZIloa10jvaxUcot4HkTdL3ydcXXKB0PrbbPqmeN8nWzlAew\n5Mtf/nKoa573lFI655xzctlzo1x//fWhfvXVV9d8nZ122imXr7nmmtB20003te9gU9ddx6vWKT0/\n+fVL6T2VcndV5ewr5fwpvU4pz5A/l++ZdP/nc9dzOOrr+FxudDy3Gh8bvgbrnqhq/6rrbtW+vWps\ndVea591z5Gi+1V/96lehTfeqKbU977aXj4fSXrtqrdQx4Ofk5557Lpf33HPP0Ob7At9jtgLtW1//\ntF7K7ZZS/Fx9flZdJ6lSfj/nz6tra6mvfv3rX4e67+n0GDwfYtXn0Fne9773hXl3+eWX13ys568c\nMmRILns+6hEjRuSy34vwe6Cay8uvQ/3z1vXb1wDvU93XV52/23ut7o/z/LE6Xv2+pq8Res9o4sSJ\nuVyV13RN/fSnP81lX5t8H6GfoV/7KL8f5veN9HPz6y2/NtN279N6ci/6HkjbS3llff6XcrP68ZXG\noL5+Z+zDt9pqq3Teeeflus4dz8PXv3//UNecjr6O6frgY9rvKem8f+ihh0Lb4MGDQ/3QQw/NZf+M\nDzrooFDXtUfzMKbU9jsLzTPpa4Tm9/M9Wyk3vPeX7mNSinkl9frk4YcfTmvLBRdcEOpHHXVUqOs5\nx9dkfX+ey1KvYVOK5/aq8V+aV17X/vDn8XyPkyZNymUfKyV+b0dfx9cEPz4f+/XiF44AAAAAAAAA\nAAAAGsYXjgAAAAAAAAAAAAAaxheOAAAAAAAAAAAAABq2RjkcSzyW9OTJkzvrpdDkevXqFeqlHDOe\nE0BjDHsevlLuJo9tXsoDRw7Hv9B44B53XuPx77LLLqHN8zVov3m8dK9rLi/PYfH000+Huo4XX4Oc\nxuP3MajjQXPMphRzk6TUNh9JK9Dx73NF+8Nz0HiMb803UcoDkFLsL88z5HHoNVekj0OPqV/KcaB9\np7lC/e9S6rq5vzqbzw3/vLUfq3I4NsrHij+vzlE/Ph2vPgZ9bJfykDUDP+fpvPHPTOuey8FzxOlc\n8BwnnnNGz5eeW8If6zldVCmnjOd3LOV88dfU91J6/Vag5zHf4/jnq+doX+s838XJJ5+cy56X5Dvf\n+U6ojx07NpdPOeWU0ObzUfMBee4izfdYlbNRx7a/l646r/285XWdd35+VFU5RfTzKOVE93bPHVR6\nrJ8HSjkcq/ZpyvMk9e3bN5d9XSKH4Ht8rHhd++Kpp54qPte0adNy+SMf+Uho8xyknu8M79FcPH6e\n1dxus2fPDm2lvVTpXOmqcp5re9X6oGup56V79NFHc9nz+vrzlNazZuX7UKVr8EsvvVR8Ht3D+fVW\niX/Gfu1cysvna73mffL7IWrOnDmh7tdtOp58vKyrHI7rrbdeeL/bb799Lvvxz5o1K9RfeeWVXH7x\nxRdD2+23396Rh9kuPl+1Xsqn6Uq5Qav2T6VxVc861ZE22GCDkFvv+OOPz2Ufd77v0vdezxgt5XIr\n7Z1c1eet5wU/5/o8Ll0PlI6hdLze5vfv1BNPPFGzrSOsWLEi/ed//meuf/Ob38zlYcOGhcd6HkTt\nd7+nN2/evFz29+fnZb0PrbkfU0rpRz/6UahPmDAhl6tygOo9L83DmFLbPKS6RvsY0POS36/zeV96\nrOcC1LyRr7322mqfozPsu+++uXzFFVeEtpkzZ4a6vgf/vPXcesYZZ9Rsc1XXW6V7qaVcqT6X/Xxy\n9NFHt+uY/DU8567et/drMf9OpSoPcBV+4QgAAAAAAAAAAACgYXzhCAAAAAAAAAAAAKBhnRZSFWgv\nD52loZE81Jv/fF1/LuyhEPwn3xqGzcMA+M+O9afXQ4YMCW1VYYdamYZd85AEy5cvz2UPpechCjQs\ngYcp8Z9tb7fddrnsIU7Gjx8f6i+88EIu9+jRI7R5uBcNP+gh+jQkgYdFcDpGS+FmmonODw9VpuGP\nPFyC1zWcoT9PiYce8OfVdg9h4K+j7T62dJ57CANfE7prSFUPq1AKqephWTxEQynETyncTlXYPT0v\nLF26NLRpv2oIvpTahshZVyF/OoqGXfF6KWSOh1fyc6l+vlXh0Hr37p3L06dPLx6vPlcp/JYfo89x\n7WMPU1cKre7hVruiUkjMKvpY/7sddtgh1J955plc9vAtF1xwQahfeeWVuXzxxReHNg/ZouFuPRy9\njx0NN+jngO9///upveoJ09lV+Dgtha8prVP6GabUdv0u/W0pfFc947CecKa+py/9rc9tf2+qnv1G\nK/NwyKVxVRXyzMMGlp63X79+7Ti67kfPVaW5qGHJUkrpgAMOCPXSHrg0V+uZx1X7IW33c+mUKVPa\n/bytGH639Nnpmvfss88Wn0fvj/g1d2lP50opLUqhOFOK53BPj6J8zGoYy5TiWPPz1Lrypz/9KYQv\n1Pfq1/7+3nXM+3lM56eHs/W67n19H1w6P3qYw1LoS+9/XwdqvUZKcW339cJfU8/Jfuy+L9NrSe2D\njk5b9Oc//zlcF2ooXL1eSam8/yjdf3R+PtQ+rwqfr6/jx+N7IH3eUltK8fP20KA6lryffF+oeysP\nN+mvucUWW+Syrgevv/566mjvvPNOuD+799575/JRRx0VHvt3f/d3oX7MMcfksoeH18/NP5uFCxeG\nul5z+7WQn+d0fvp6qKkoUorjyUOq+v1WXcO8PzT9jLd5ahIdlz4O/f66piRam/fKxo0bV7OtFBra\n6X1cf5z3eSlkaWmd9euV0n0MDXWaUjmEqisdn4eZ1XFVT/jmRvALRwAAAAAAAAAAAAAN4wtHAAAA\nAAAAAAAAAA3jC0cAAAAAAAAAAAAADSOHI9a5Xr16hfrixYtz2WPol3KEeXxkf2wp30spX5vnQOnO\nNLa5x//edtttc9ljgWt+x5Riv3nOAv9bjRXueY50rKSU0n777ZfLL730Umjz49UY9t7HmkPA81l5\nbHWNl11P7qKuTGN5e1xvjTNeT4x0fx6fnzoO/Hn/+Mc/1nydqmPQuscg1/Hk64M/T1V881bl+Qw8\nT6DOZf98SzlFXCnnTVWuGv1bz8eqx9ezZ8/Q5jkcmz1P5+DBg0Nd+87nkI59X7e8H4cOHbra50yp\nbU7PrbfeOpc1V0pKbXMhaH94//t6rfPPczvr3/rfeZ9qvos1zUmwLnhf6edy8MEHhzbN06i5O1b3\nPJ/85Cdz2T/f2267LdSffPLJXPb8IZ6LROubbbZZaPP8L5oD+c477wxt/fv3z+VddtkltHnuGv1M\nPI/oggULUlfkOXVKeVV9j6Q8J7rTvCGeZ8jrOnd87pbmjreVcgn5/k9z/ngOHD8P+NqjfK/YXQ0Y\nMCDUfZ3VfY7nI3LTpk3L5ao8qZ5nCO9pb969SZMmhfqpp54a6ppzq+o8VsrhWKpXPVbntedwLF0L\n+V66lFe0Wfmap/T9V+Uy0+uSUk70lBrPQe65pEp95/drlF9zb7fddjUf21XzZ+uexPcnvj7qvPMx\nrHsob/PPV+dn1TWTvmZV3nN9rtK+MaV4feDPo/Pe23yc6xj18eqP1df065OOtP7666fRo0fnuq6d\nnrfY9086Tv0z1MdWrZU6HvyaxO+PlfIp+vjQY/LP0J9X72v16NEjtGnfVN3r0PHs79P3ZDpehgwZ\nkstVe42O5vfxvF6y00475fL2228f2vzcu8cee+Sy94fnJtVrab9O8RzIzz//fLuPt0RzLep1fUrl\nHLXOr/suuOCCXNZ94rrk88zv/yidZ6U5llIc//5YHw96bvXHlvbQZ511Vs22NeH9pvPT57Kft/x8\nWC9+4QgAAAAAAAAAAACgYXzhCAAAAAAAAAAAAKBhzRdPCk3Pf3Ls4bv0Z9AaRiqltj9t1p8oe3gJ\n/zl16efh/tNhDSnQu3fvmn/X3ey11165rKHzUop99eqrr4Y2/ym2hozwcC4asjOllPr165fLHibr\nzTffDHUNO+DH532s4Q18bGioA//Z+4c+9KFQ1xBgs2bNSq1A56iHQSm1lcKb+twthSz1vvI1oxT+\nxekx+fNqyDZ/DV9PPGxfd7UmYVL1sVUh2fSx3jcetkXH4QYbbBDaNISEt7UaXStTiiE2582bF9pK\nIUR8XdVQl0uWLAltHsJW57GGwUyp7VgpjQcPR6PhUKoeqzz8pJ7EyP3wAAAgAElEQVRvPORQV+Rr\nqoc70nXUw/1oyPEvfOELoe3CCy8M9dI8vvXWW0NdQwx5X3hoap2rvg8o1T/2sY+FttNPPz2X/Vzi\n4Ug17Ns//dM/hbabb745dUW+DyqFuSuF69OQSSm1ndvaH76u+jlZ93T+2NJ48THq51Ldx/meriok\nbK3j88/EP7/uqnR9lVLsx6rPTNfZUhqKlNru41EfD33l1yjaV/Xsgd2ahFTV9dpDbfpepPQ8jYYC\n7cpK1yiawqMqjL+ucWuypvmaXAqzW7rP4vs9dffdd4e6n8NVK+zFS+FD9R4H1q2VK1emu+66K9fn\nzJmTy7vvvnt47LBhw0JdQ496Oolly5blsu+PfF7rnKoKhatjR1MKpdQ2XOUjjzySy5MnTw5tpesb\nD3+s9zn9NUt7P18rfE+v+wD9/Jop/ZDeV6wKbfqDH/ygsw9njeh9Tw/x2oxK4eR9X6H3+/y7hdLz\n+HzV86W/RinsqJ8jfI+kKX7qCfnrSqmt/FpZ9wVV+8hSCov24BeOAAAAAAAAAAAAABrGF44AAAAA\nAAAAAAAAGsYXjgAAAAAAAAAAAAAaRg5HrHWa8y6ltnnVSrkFPMZwKT+b85jNymMra64EzzWgOVG6\nW5x+zc3ouXY0Z6K3lXIOeY6ZpUuXhrqOAc3jlVLbOPQaI37QoEGhbebMmaGusav9GDQu9zHHHBPa\nPE6+xuz2PGnNSuPrey4CjWfu77c0P+vJReZzzh+r46nqeXVd8HxRtV5/dcfgueBamcesV97HGvve\n19FSzr4q+lj/u1KeOF9rdN33v/M+r8qn09V5fkXNxeGx+/Vz8X7zsa9r8owZM0LbypUrQ13zQnhe\nJ8+1qK9bGnMpxXyEnv9D12/PW+LjQfcfPh66oj322CPUNX9iSjG3rOeT0PE8YcKE0OY5jvXcqXlr\nUmq7z9HzruajSqntuV/Xh6rHat94Tg0d296nPnb0b5944onUjEr72VLOM9/3+HlL533V/lpVnWeV\nz/NS//jYKuUIK41vP57S8XUnvufxtV0/06pcerru+tjx+Vraa3Vn7c2Z49fJnj9M51hVfnSdJ6V8\n6P63/ry+Buh1sl9D1Xrc6o6hFa+j9T3Xs8+s6sv2Ku3TXdV5QN+LH5+ewz0n2JAhQ0Jd20v3Y4DO\nNHXq1NWW66XzRHMgptQ2h7Fea+iePaWYWy6luCZ31nn0ggsuCHW9xvP1wPeQuk/wtd3XjkWLFtV8\nLLCmSveW/Vyley/f65b2wX5/pJTn2um1T1VO7CuuuKLm85TuebnSMS1YsCDU9b353PXn8dyu9eIX\njgAAAAAAAAAAAAAaxheOAAAAAAAAAAAAABrGF44AAAAAAAAAAAAAGkYOR6x1/fv3D3WPl6xxhKvi\n/JceW8qP4W1+DJo/x+NAa46cV155pXh8rUZzbfzsZz8Lbfvss08ue64mzyukca398/WY3MOHD89l\nz1F2wgknhPrmm2+eyytWrAhtw4YNC/VDDjkklz3efinHhrctXLgwl0t5MppJKUZ5KSZ5KQdQVX48\njVHueWU8x4Hy+Oo+njQHgufFeeONN3LZx4vn0NLnbfVcBJtttlnNNs/noHPH12DNb5pSnNtVOWY0\nRr0/rz+2NO/0dXysNHvORufzRse35zbUuVq1bmn+KM+N5n2z6aabrvY1Ukppww03DHXtD3+s53LT\n/AE+N/X4PUeZr+36Os2Qw9GP/9BDDw11Xd/69OkT2nS++Vz0fAz6eXsf+/j44Ac/mMu+VnheRh0f\npbwZKcXzu7fpMfnxlfIL+p6hq/L34Oujjvlly5bVfB7//L3fS7nWSjlG6tnbeN/58+ox+PjWPZzz\n9bu0F6knX3Ar0xxKKbXdA+n6MWvWrOJz6VzyPZCPq/nz59d1nN3F7Nmzc9mvi5R/nj5PdP32Pa/P\nE61X5QjUuetrkv9tKY+QrhelPJEptWa+T/1s/HPzvZjyPVKj1xql+yrOz6elayq/Ptf7OX5t4Lnq\n9BxWylEMNAOdY82yz/z/3Xfffev6EIA1Vjo/lvK4+95G636+9nsc+tiqHI7a7ue8X//616F+7bXX\n1nyejrrn6Hu2Uk5xf2+lfJntwRUZAAAAAAAAAAAAgIbxhSMAAAAAAAAAAACAhrVG/D80FQ/5VArR\n5j9lLv18uSrsnv5MuiqsjIaz0TCiKaXUt2/fXO5uIVU9VKrSz2zKlCmhbfvttw/1l19+OZc9FIWH\n11m6dGkuP/PMM6Ft7Nixoa7huO69997QNmfOnFDXY9xuu+1C21tvvZXLHsrIw/Dpz+s1nGAz05/v\n+9zQn+T7z/NL4ZlK4VZTKod98p/662fu895fR5/XwzRq+EV/Hg8rVBU6oZXoXPYwChpOcXXtJdqP\npX6qeqyPh1LYRj0P+Nz1EBfNHipX18qUYshBp5+LzzfvY503Hg7MQ4CVQqlVnaOVh5TTeuncXnrP\nKcU1+oYbbig+tiuYPn16qPt+SdelUlha3bek1LbffAyo0hrroVk9hKfXla8dOq9LY8PD4fj71j3b\nmoaBWVuqQoDqey69pyFDhoT64sWLQ72ekKo6JnzclcIV+Wv42Cqtsx7yU/n71rFXT0qF7sT31z6v\ndH56SESnfe7hEnv06BHqhFRdPb32GT9+fGibO3duLvscKe1VquZXKUVIKfyx78lK512n/e/nAN+H\nrVy5subzNCv9XH0tmjp1as2/8/sNpXXW6TnCz5Gl8LdVKWa0/tprr4W20nn6+eefD3W9f+DrBQAA\n9Zg8eXLNNk/PUEoxovcqqtL96D0GPz/73+r53O+rXH311TWP3dWzDyjdq/QwrvXcd/W/rRdXZAAA\nAAAAAAAAAAAaxheOAAAAAAAAAAAAABrGF44AAAAAAAAAAAAAGkYOR6x1I0eODHXPNVDKVeOxlDXu\nsufP87994403ctnzPHl+A23349O8gQ888EDqTjTe86BBg0Kb5gm55pprQpvnyhowYEAu9+zZM7St\nWrUq1DWH4vDhw4uPPeecc3J5//33D22ary+lGBPbc5WMGjUql/297LvvvqGuuShaJaen5kPyXD0a\nF11zXaaU0ooVK0JdY4L73PU8ITrPPAa5z8HS83gccs1VpjlyUoo5izbbbLPQ5jHTfYy0Mu0rzynj\nn4N+/lWfUSkvo6/Bmuen9JpVr6tt/jiPqe/5CZvNjBkzarZ5nlrPaau8z0u59TyHn7ZXzflSXtdS\nTk/Pv6Cv4/mrPFehzmvPj9gVeS60bbbZJtQ1/5V/Zro/8nOlP1bnW9Wc13NpVd5T/byrcv5qH5fy\nbPtrem7eZszF6jkISzk76slt7jmoS7nfnPaHf6Z+Tq4nv7qOJ9+XlXKC+fPoPt3zxZLD8T2vv/56\nsd3X7/byfC4DBw4M9VdffbWh5211el1a2sd4Lnufx5qb0+dmKQeRP9avkz2/Yumxevw+/3XceR7R\nfv36hbrP61YwdOjQXO7Vq1doe/PNN2v+nfePziPvVz8v13ONouu3P29VLie1cOHCmm2+j9hkk01W\nWwYAoF4PP/xwLut925Ti/eCUUjrwwANzeeuttw5tpRzHfq2j12Z+bvS9jN5jWrx4cWi7+OKLa77m\nmijdL/Vzsp7r/XsRzxvu+796cUUGAAAAAAAAAAAAoGF84QgAAAAAAAAAAACgYXzhCAAAAAAAAAAA\nAKBh5HDEWjdt2rRQ33bbbUNdcxR5rgfNuZZSzP/nj/W8EYMHD87lrbbaKrR5vgx9rOc+mj17duqu\nzj333Ib+7vzzzw/1m2++OZc9l4PnhtF42Z6XcdGiRaF+6qmn5rLHyx43blyoa64Sz49y11135fLt\nt98e2rzeiko5OzQnmn9u/nf6GXtOKo8HvvHGG+dyPfkePXeT0xxRno9S+frhuaVKcdFbjeezLNGY\n9VW5FrVeyt/nfFz535ZyAJVex/P7NXsOR/eNb3wjly+66KLQNmzYsFz285/n8NH2Un6olOKc95wA\nJd5PpXxRPuc1h58fj+dL+vKXv9zuY+oKfN3xXJznnXdeLn/sYx8LbZpv1+eIP69+br5We59rvq5S\n7j7/21J+vqrn1bXF88P5eNW8Hs1Cz38pxfmZUpwPU6dODW3al5/5zGdqtqVUX991lNIxVK0nysew\nnqN9rfG8nt2Vn+P8M/Q9XKPP62OJHG2rp9ee/hnp2J81a1Zou/zyy0P9wgsvzGXPpe7zTV/H55eP\nBz3P+tjw/ZG2l66LR48eHep+fqlnn9As9Bz12GOPhTbPo1Siey8/R/geacCAAblclatT+Rrs40nX\n0ilTpoS2Uj7Kl19+OdSXLVuWy82QPxsA0Bz8uui0006r+Vi/36f5HfU+ckop7bLLLqFez575lltu\nyeUTTjih3X+3Jkr3Kv1cr7nXn3/++dDm+d393ny9+IUjAAAAAAAAAAAAgIbxhSMAAAAAAAAAAACA\nhq1XT5i49dZbr/vElGsi7777bofFRVoXfbz++uuHuoZY7dOnT2gbM2ZMqM+fPz+XPayWh1TV8B6n\nnHJKaJszZ06oawiRe+65J7R5qM61odn7uKR3796hPnTo0FDXn7576B2v9+rVK5dnzpwZ2pYuXRrq\n2udz585t/wF3ko7s45Q6r581JJOH0HQarslDOflP+3XOvf/97w9tHtZY2/0Y/vCHP4S6hhLyUE5q\n0003DXUP39xRIVWbYS7379+/ZpuH4CqFM3Uf/OAHa7bVE37V+1jHlo8VDQvhY/B3v/tdzceuia7Y\nxz7f9t1331zW0JsppTR8+PCaz+Nrbqn/NYRWSm0/Xw2NWhXeUV/HQ4tp2DEPB3bjjTcWn7dRXbGP\nnYblHDlyZGjTsPEpxfNsKaRuSjEknK+TPjf1b73Nx4O2l9o8NPbKlStDfU1Dv4jJ77777s4d9WSl\nfva1cciQIaG+YsWKXPYx7utYq9IUCinFMexru6duKI2JZpjLjfK1/Otf/3qoT5w4MZfrWSuPOuqo\nUPcwVBoC9Omnn27383aWrtLHW265ZS6ffvrpoU2vUb73ve8Vn0dDsx599NGhzcNu6/ndr7c1BHpK\nMRSn7611DUopzrGvfvWrNY/VU2GMGDEi1DXFhl+n1aNZrqEa5fvyLbbYItR1bPkeycPQa0hkP7/7\nuVfD+3aFUKhdZS6j89DHra/V12u8Z23N5arUO+g87eljfuEIAAAAAAAAAAAAoGF84QgAAAAAAAAA\nAACgYXzhCAAAAAAAAAAAAKBh9eZwXJpSmtd5h4MGDHj33Xd7VT+sfejjLok+bn0d2scp0c9dFHO5\n9dHHrY8+7h7o59ZHH7c++rj1cQ3VPTCXWx993PpYr7sH5nLra1cf1/WFIwAAAAAAAAAAAAAoQqoC\nAAAAAAAAAAAAaBhfOAIAAAAAAAAAAABoGF84AgAAAAAAAAAAAGgYXzgCAAAAAAAAAAAAaBhfOAIA\nAAAAAAAAAABoGF84AgAAAAAAAAAAAGgYXzgCAAAAAAAAAAAAaBhfOAIAAAAAAAAAAABoGF84AgAA\nAAAAAAAAAGgYXzgCAAAAAAAAAAAAaBhfOAIAAAAAAAAAAABoGF84AgAAAAAAAAAAAGgYXzgCAAAA\nAAAAAAAAaBhfOAIAAAAAAAAAAABoGF84AgAAAAAAAAAAAGgYXzgCAAAAAAAAAAAAaBhfOAIAAAAA\nAAAAAABoGF84AgAAAAAAAAAAAGgYXzgCAAAAAAAAAAAAaBhfOAIAAAAAAAAAAABoGF84AgAAAAAA\nAAAAAGgYXzgCAAAAAAAAAAAAaBhfOAIAAAAAAAAAAABoGF84AgAAAAAAAAAAAGgYXzgCAAAAAAAA\nAAAAaBhfOAIAAAAAAAAAAABoGF84AgAAAAAAAAAAAGgYXzgCAAAAAAAAAAAAaBhfOAIAAAAAAAAA\nAABoGF84AgAAAAAAAAAAAGgYXzgCAAAAAAAAAAAAaBhfOAIAAAAAAAAAAABoGF84AgAAAAAAAAAA\nAGgYXzgCAAAAAAAAAAAAaBhfOAIAAAAAAAAAAABoGF84AgAAAAAAAAAAAGgYXzgCAAAAAAAAAAAA\naBhfOAIAAAAAAAAAAABoGF84AgAAAAAAAAAAAGgYXzgCAAAAAAAAAAAAaBhfOAIAAAAAAAAAAABo\nGF84AgAAAAAAAAAAAGgYXzgCAAAAAAAAAAAAaBhfOAIAAAAAAAAAAABoGF84AgAAAAAAAAAAAGgY\nXzgCAAAAAAAAAAAAaBhfOAIAAAAAAAAAAABoGF84AgAAAAAAAAAAAGgYXzgCAAAAAAAAAAAAaBhf\nOAIAAAAAAAAAAABoGF84AgAAAAAAAAAAAGgYXzgCAAAAAAAAAAAAaBhfOAIAAAAAAAAAAABo2Pvq\nefB66633bmcdSHv99V//dS736dMntG244Yahvnz58lz+85//HNo23njjUP/ABz6Qy2+99VZoe/vt\nt0P9T3/6Ux1H3Pnefffd9TrqubpCH6OtVuvjD37wg7n8f//3f6Htt7/9bae85uabbx7q+ro+59eF\njuzjlNZNP//N3/xNqOuavP7664e2jTbaKNRXrVq12vLqvO99fzl19erVK7T9v/8X/x/NsmXLaj7v\nuljLW20ul2yyySahrvNez88pxXO7/+0777wT2n7zm9+E+v/8z/+s0XF2tO7Ux+utV/utvvtu+w9d\n53RKbfdsXU2z93HPnj1DXfvK+9T78f3vf3/NNvdXf/VXNZ/3j3/8Y6jrPP7f//3fms9TdX7oQMve\nfffdXtUPa5+uPpe7q2afyyWbbbZZqG+66aah/oc//CGXfe/t+yNdo/3c7uv1kiVLctn3+OtCK/ex\nr6u+l9K674+9b/S5fA32fZb2eT3n+s7SCtdQJX7f6m//9m9DXeerzuuU2valnsP93pnvxfQe2IoV\nK+o44s7RynPZ9e/fP9T1XqVfFzmd9379PXPmzFDnvmbXoWuwr6t+Ptd98dKlSzv3wDpYK67Xeg/M\n7zn+/ve/D/WOuu+41VZbhXrp3ib3vDpX7969Q13PrX69698t6Z66dB8zpeq1f21rTx/X9YVjPapu\nWDSqX79+uXzOOeeEtl133TXU/+M//iOX33zzzdB2xBFHhPqQIUNy+Tvf+U5oe+SRR0J90aJFdRwx\nALfHHnvksp+Ef/nLX3bKa5522mmhrgv21Vdf3Smv2d0MHDgw1HfaaadcHj16dGjbd999Q33SpEm5\nfP/994c2vwDu0aNHLk+YMCG0+UX4ddddl8u/+MUvQtsbb7yR0Hn233//UD/wwANz+YYbbghtem5P\nKaWjjz46l5999tnQdtttt4X6vHnzGjq+qptv3VU9+ze9AZJSvLFVzxfB/gWY3rBGxzvqqKNCXW8e\n+7zwm5VbbLFFzTav6w0Sf97XX3891BcsWJDL/qWi/meFe++9N60ljS0sQBcxfvz4UP/IRz4S6nrj\n+fHHHw9tixcvDnX9z11HHnlkaPObnZdffnku/+53v6vjiFEv/49+/iWF3pDcYIMNQpt/MaU3sP2G\nmK/XehOsq31h0Yr23HPPYl3n6/Tp00Ob36DUG6N+78y/1Hj44Ydz+aabbmr38XbWfcCuovTFUEf5\n0pe+FOrDhw/P5SeffDK0+TEMGDAgl0eOHBnaDjnkkFD3tR7rjt7v8HX14IMPDnW9F/Ld73635vOk\n1PX/E2cr0HOtz92XXnop1K+55poOec3zzz8/1HW/5WOCe16d6+STTw71XXbZJZfnzp0b2h566KFQ\n172579N+8IMfhPpTTz21Joe5ThBSFQAAAAAAAAAAAEDD1qvnf+V01k9Z9X9NHn/88aFNfwmVUvwf\n0h5Wbeeddw71QYMG5bJ/W+z/20v/58GLL74Y2vTXjynF/9X3q1/9KrRNnDgxl3/961+ntaE7/Vy5\nu2q2PvZfr337298OdZ2PGtolpbYhW+bPn5/Lt99+e2jzn6/r/7r2ECL6Cwnnv8r4+Mc/nstr63+S\ndNXwEoMHDw51/R88/j9sPeSP/nrV/3ePh/bafffdc9n/Z57/j9uVK1fmsv+PLV+/daz5r+j0f4L5\nL9m/+c1v1nzsmmiGuaz/y93nhtNfG/q50vtYfxnlkQJ8HdA+91+7+f/61Ll9xhlnhDZdM9bWLxqb\noY/rob9Uveqqq0Kbr8Ha5z6P/fPWcebhRvx/6P/85z/P5Ysvvrg9h92pmq2PTzrppFC/8MILQ13X\nSe9TX7v1f0r7r1j9msJ/faN8fIwaNSqXfX8/derUXJ4xY0Zo81+5d6DJ77777s7VD2ufrjCX0Vaz\nzeVDDz001H1/7edh5WFTNSKEX7M+//zzoa7nAT8H+7zXcH6+h/jWt76Vy+edd17NY+1IzdbHVfr2\n7ZvLZ555ZmjTX72kFO9veEQC33fpePD9m0cP0f20r8k/+clPcvmZZ55p+wZER/1SrCtdQ7X3Pfl1\n6gUXXBDqxxxzTC77r/79b7fZZptcXrhwYWibMmVKqGuUL/8lq5/v9Vc7Ppf1lxeXXHJJWhuafS4f\ncMABoX722Wfnsv8i3aOz6Z7J+9/pWu+/ZNZfP6YU14grr7wytOlcXluavY/r4SGwdU/tkQT8nvjs\n2bNz+fvf/37xddbGL3Lr0ZXW647yxS9+MZc/9rGPhTaN4JJSSmPGjMllP3965Dedr75P8+fdYYcd\ncvmss84KbR49bG1o5bl88803h/pee+0V6rNmzcplv/9UmoP+HdXYsWND/fTTT8/l//7v/27fwXai\n9vQxv3AEAAAAAAAAAAAA0DC+cAQAAAAAAAAAAADQsE4LqVpKFu0Jqr/+9a/nsofD858Va1g7D8/l\noR40cfqGG24Y2jycm4Zv0hCvKbX9aauGDdSQYCmlNHTo0Fz+x3/8x9A2efLk1Bla+efKeE+z9fH1\n118f6gcddFCoawgAD3fs4TN17nrSaw/npmGePPyMrxf6XJtvvnlo+9nPfpbLn/vc59La0JXCS2gI\nHQ1/lVJcyz08l6/X2h/ezx4mU9dvX4N9ndW+9df00LkaQsrHj4ak8XCwPl6+8pWv5LKHe6xHs81l\nd8cdd4S6hk/28LalkKUe2sv7RkMAeehFp6G+PITjgQcemMuvvPJKaPNwYh4mrlHN3se+f9Ow1pts\nsklo8/mnfC76eNA+9pBP3uf6ul/72tdC21e/+tWax9BZmq2PH3jggVAvfb5Ow8KkVA7l5fNY1/Wq\nseOhpZTOaz/v+/6iAxFStRtohrmsYe7+4R/+ofhYXUs9VLWv7fpY3895GPktt9wyl/3egZ9LNXyU\nn5P1sRoqOaUYDiyl6pDu7dUMfVwPDaur9x1SatsXu+22Wy57/2t6Av/bxYsXh7ZXX3011PW+id8n\n0T37vffe2/YNiFYIqVq65+XOPffcXN57771Dm++ZdA76Na2H1tPPXNMXpNT23Kt95yFVPXSunu99\nbOnx+vrx5S9/OdQfffTR1BGabS77fU0PZ6prtPeF75l1nPme2ddKHQ8+Pr0f9frcr800rOuHP/zh\n0DZv3ryax9dV5nJXWK9LfC+ue2jft3vY4mHDhuWyrw8ealH3176HXhe60j2vzuDXTaV7TL5H8nmv\n/eVtft301ltv5fKIESPqOOLO0cpzWUOKpxTDmqeU0tKlS3PZ11xfk5Xvp/z8rXP7Rz/6UfsOthMR\nUhUAAAAAAAAAAABAp+ILRwAAAAAAAAAAAAAN4wtHAAAAAAAAAAAAAA0rJ0ZaA6XY3Z///OdD/Zln\nnslljXebUkqbbrppqG+00Ua57HGLPR+MPpc/r/9tz549c9ljW3s8c30djYOfUoyp7u/ztNNOC/Wu\nEEMb6Ayeh8LzEnhOPrV8+fJQ17wQHvPacxZ4/ijlf6s5ZjwXwvbbb1/zebqDSy+9NJd9XS31h9d1\nnfX8eJ4nRM8ZPl78fKL5Jvx5tF9TivHufS3X5122bFnx+E4//fRcrsqh1Mo8x6rmC/D+99wU2jel\nuZpSzBvj/e/1FStW5LLnYz3hhBNy2fMqd1R+qFbjeba1HzWfY0pt13rNReH7I+83fV6ft/63Wv/E\nJz4R2tZFDsdmcNZZZ+XyyJEjQ9vMmTNDXftN51NKbXNPaD9W5VfVNdfPJf63ulYPGTIktOm5xI/v\nwgsvDPXLL7+8eExAV+fr6mc+85lc9tyKfh7T87DPXc//o6/j19u+T/d9cukYdI3wPJKan8bXpdtu\nuy3UjzzyyJqv2WpKOX383KlrqffLpEmTQl0/fx9X06ZNC3U9z+reLqW2faz7cM8Z6GO01ZXueR1+\n+OGhfthhh+Wy52H0fY+e93yPNHjw4FDX82JVbntdB/r27RvaPBejnqc33HDD0LZkyZJc9hxlV111\nVaiPHTt2ta/frEr5Cs8888xc1ty3KbXNdV/aB5fWYO9Tf6x+xj6u/PPXPvdrYT0v3H333aFt1KhR\nob4meRu7C+/j0rVw7969Q/2JJ54I9UMOOSSXS3neUirfd0PH8/zIvnbqOdLXXJ+fWvc55vdk9N4J\nOpee/1Jqe+9E2/17J+9jXRd8r9WvX79Qnz17dv0Hu47xC0cAAAAAAAAAAAAADeMLRwAAAAAAAAAA\nAAAN4wtHAAAAAAAAAAAAAA3rtByObty4cbns8cE1HrHHOPYcL5r3sCqfm+aO8TaPoa11z/Pl+RH0\nGDxmfSlm+vjx40P99ttvz2V/L8RBRzPTnKgplfOt+pz3XH8a29xj0Ps80XafU/63+jq+Hmy99dap\nOxkwYECoa94fz8WieVs8N4/nItD+8c/Y81po/3i/+vqt+cb8fKL5gVKKY8/z5uoY8THq70XHxJgx\nY0Lb5MmTU3eheZRTiv3qc66Up6Uq/6eOgarxoDkLvG3YsGE1j6EV8sh0Bl//dE/kc2jVqlWh3qdP\nn1yu2qNp3dt836VrUj1zvDvT/FCe88Hrmv/F83E5XferPm/tN88np+t4SjEn0XXXXRfaBg4cmMue\na85zOgLN7sADDwx1XeN8bfTr5FIuQKfz1/doft7V5/XH+jwrLqoAACAASURBVL5AeX4infe+v9xr\nr71CvTut7fVc92vuy49//OOhzfP96Hh58MEHQ5vnINJ7Gp4LSvf+KcUx4PvnBQsW1Dx21+r3O04+\n+eRQ1xz1vgf1z0L3Xn5tXMqpOWfOnNDmfannU98L+DFpPnuf9zqXfX76eVpzSn/ve99Lza40bj/1\nqU/lsufp9LlSuhdReg3vJ78eL12beV2vd/0YNBed5xScMGFCqP/whz+sebx4j++Dvd+OOuqoXH7z\nzTeLzzV16tRcvuyyy4qP1ftu3HPufJ5bsXQfw9uqcrkq78v58+fXdZxo3KJFi0Jd73+klNL06dNz\n2a93S+d+z8fqffzkk0/Wf7DrGL9wBAAAAAAAAAAAANAwvnAEAAAAAAAAAAAA0LC1FlLVQ3woDd+0\nfPny0KY/5U8p/uzff2LsYQr058oecqYUJrAUvs+PwdtKYeA0hIXj5+xoJT4XPUyxzl0PienhWEvh\noeoJ+eRhnXr16lXzNZYuXVrzNVvRhz70oVDX9dA/Yw3/4m2ldcxDDTz++OOhfscdd+Syh3nysLu6\nlp5yyimhzUO16vjyEAZa93OEh4/S9rFjx4a2Vg6p2r9//1DXsIcpxfAw3lYKB1MV4kd53/g52seH\n8mNCtS996Uuhruu5h1SaO3duqOueqCq0n7b73s/D0Wg/akiylGLIshtuuKH4mt3JzTffvNpyFe8L\nDwnmIaCUz0U9J/i+u0ePHqGu6/7ll1/evoMFWtCuu+5as6207616rPN9svJrbN0veYjGZ599NtQ1\nxOqQIUNCm4eEVZ6mRM839YTpbHZ+DTVixIhQ11Dm119/fWjzfe7rr7+ey77metjL0j0W30tpaPNt\nttmm5vFV0fHbKvdCdM/q9780BHhVCh+dnx6y1PtH/9b3yH7u1ZQ/HqLe57a+F+8fHaceKtKP97DD\nDsvlVgipqp544olQ1z73exylkKquNB+qQnPq+KhKR6Nrhq8f+rfepxdffHGo33nnnbn81ltv1Tz2\n7qzqukhTkFWd83Tc+Xl2u+22C/VXXnkll/2aujQG0Ri/5+hrva7tPpdLoaurQur79Ro6z8SJE0P9\nX/7lX0Jd98F+Ti6FydUw5im1DZFeugbvqviFIwAAAAAAAAAAAICG8YUjAAAAAAAAAAAAgIbxhSMA\nAAAAAAAAAACAhq21HI6aV8tjgPft2zeXPWejx6nVfAOaa2B1z6vxcT0esufn8r8ttWl+t7322iu0\nvfbaa7nscdA9FxbQSnROea4Pj1mveZ48f0Qpp4zzGNj6OlU5C0rHpzksPLZ6K8a632233UJdY417\nLHH9HH2N81wVm2++eS7fdtttoe2+++4L9RNOOCGXPReBf+YPPPBALl9wwQWh7Qtf+EKo77TTTrk8\nb9680KZx8T2+vufZUGPGjKnZ1mo8N4/mPk0p5pB49dVXQ9unP/3pUJ89e3YuV+Vw1HXAcyX7mnHr\nrbfmsuf09JywqDZhwoRQP+2003L5uOOOC22bbLJJqOva4X3qezZt93XG87/oOeXpp58ObbNmzUro\nOM8880yoe15czaHp+UP8nFDKV+N9/otf/KKu4wRa1aBBgxr+247Kg1fKee3zetq0aaGu+ZvPP//8\n0Kb7OV8/fP8/cuTIXO5OORzHjx8f6n4fYvr06bmseYJSanv9pWPp97//fWjzPi6NHc8DuHjx4lye\nOXNmaNN94x577BHaPH97q+RtVJor03Nq6Wfufae5FVMqzxXPZa3XMD4GvJ81x6a3+bWPtntf6Tnc\nx6jfv/NriWa3zz775PKoUaNCm14Le05Mv34p8fsYuj76dbH3je7Ffe9dWnf9efQeiK/Pffr0CfVr\nr702l4855piEtjyXmxs6dGguf/vb3y4+Vs+J3jd77713qJPDce3y82XpvqivuT5GSvdDqvIAo/Po\nHiilmJ85pXhf3Nd930Pr+dP3BXrPs1nxC0cAAAAAAAAAAAAADeMLRwAAAAAAAAAAAAANW2shVXv3\n7p3LHs5Uwy5oqMWU2oYBUP4z4lL4Lg8R4M+rP1f2sBD+vPqz6BEjRoS2KVOm5LL/ZJ3QbmhlOsd9\nbnpoAZ0nu+66a2grzfmqMKk6jz0kgYcz0PCOHupFwxtoyOeUUpo7d27N42tW/fr1C3UNAaRhrJ1/\nFhpCNaWUXnjhhVy+8cYbQ9ull14a6hpCYPDgwaHtt7/9bahfffXVuTxx4sTQdskll4T6VVddlcs+\nBpYvX57L3s+lMBUeRqaV+dzwEMMaRnzSpEmh7eyzzw51ndt+fiyFVHUeoujmm2/O5ZNOOim0achP\nDwer4dHxFx6yVOsewljX0ZRiSBHvU1+TNYzPsGHDQtuZZ54Z6tdff33VYaODaLi+lNqeH+qhY8Dn\nvM+/VgytBzRiiy22qNnm66rPG21fkzlVOgd72K6PfvSjoa57dQ/jqetAKeRySimNHj06lz0Mf6vZ\nfvvtc9nvF3i4euV7soULF4a6phLw8Jnex/pcHmbPr+N0j+yh1efMmZPLO+64Y2jTcLsptWZIdA1n\nWBrjfp1RSjHi/exzUMOb+mNLoVpL19wptR0z7T0+fy96LbnvvvuGtocffrh4DF3RI488ksseDt7T\nlChPHaUhEn3OeV0/bx9XpfD2VX2s5wl/TZ3bHgZ/xowZod5dw6hWnce0vSp8qc6TBx98sN3H4OEd\nx40bF+oa7tbDHZfO9aX5j9o8LYivj/qZ++fvY0Tnr481D8fKfY11x0Oq6tru9zFLa8bAgQND/dFH\nH13zg1vH+IUjAAAAAAAAAAAAgIbxhSMAAAAAAAAAAACAhvGFIwAAAAAAAAAAAICGrbUcjhqf2POw\nldo87rjm+fIY1J4fSJ/X81h4HHJt9/xQnrdA46QvWLAgtGmMZo+v78+r+aSIufwXpRwSJVUx1OvJ\nZaLHUIp978/psbQ1H6jH767nvTWDjTfeOJd9Hvt7XbZsWS77Z+bzxvMSKI8tr4/19UBjaaeU0uTJ\nk3N56NChNZ/Hc2y0As23mVLb/B46Vj2nreYWWrVqVWjr0aNHqF933XW5PGjQoNCma3lKMYebzzmP\nhX/vvffm8uGHHx7aLrroolCfOnVqLh9xxBGhTdf2AQMG1GxLKY5Zz0M8cuTImq/Z7IYPHx7qpXVW\nP6PVPVbXS89Z4HNZ56+vnb6+6Fz2fFF6rvfcoJx3V6/UN5rfNaWU3n777ZrPU7VH037119TzSdXx\n1TpWNMbXcT9/6/nRz6tO57zPWx8PnmMVa640l73N97P17Jn1/Om5g2666aZ2P09H5R9sdn69qPy8\nWpXTsaQ0Hkprqe/RqnKEKT2+qmP1fVkr0z2x5/vxNVnzj3v/b7jhhqGu67Wfk72Pfb+v/NpM65tt\ntllo032Xv4bnem/FHI577LFHLvv+Vce8X//6HNRzpvern3u1n6tydZZyK1flBlT63vxxPob1Os5z\nHDZjDkd17rnnhrrmPS/lbkupnJ/N10fdM9WTy7fqsTrOfE+v40zzC6aU0mWXXZZQfR4rtY8ZMybU\nfZ1tL19HNf+x4zqp882cOTPUDzzwwFDXPvDzrtd1bfXrMe9LXXuwdnl+ar2m9X4qrcG+n/a83M2I\nXzgCAAAAAAAAAAAAaBhfOAIAAAAAAAAAAABoGF84AgAAAAAAAAAAAGjYWsvhqPkoPM67xjP3PAAe\n6/ydd95Z7XOm1DbmbSl3jMdA1jj6Hm/dY59rfG3PZ6TxeufNmxfaPH7vNttsk8vkkvoL7ceqHDPK\n+6kUo3zChAmh/tOf/jTUPQ9Ye3ncbR13p556ami75ZZbQt3z4TUbzcvh880/T81D4DkSPZ9gKRer\nj49SPlhfdzQXodPHbr311qFt+vTpNf+uWWh+kZTa5lPU9dE/Y32s/53nxtW+XblyZWhbtGhRqN9x\nxx2r/buU2ub60uObMmVKKtlyyy1X+3cpxfXa84e99tproa7riY8lXctTaq0cjh/84AdD3efgxIkT\nc9nPeU7/tiqHRCmHo+fX1Of1dbRPnz65PGrUqND21FNPFY+hu6onB5jvgTS/qc8Tz32qfTV//vzQ\n5vl/VCkHDtZc//79Q93zfmm/+ljxPtd5XspxnVI554xak5x13U0pl1c9eXwuueSSUH/ppZdCXa9h\nLrzwwtDm58evfvWrNV+nnj2+PnbIkCGhzcfajBkzctn3E12R74H0vdYz/qty25fy4dajNM58L15P\nDkfff7cSz8mn82T27NmhrbQm+57Hx7d+xn7fxPtf1+TFixeHtv322y/UdYzeeeedoU1zsntub79O\naEWHHHJILi9ZsiS0aX/4udWvQ3Qf5GtCaX9Vus/mj/WccZ4b0tdSpcfkuf/87/R6ceDAgTWfsxn5\nfNX6LrvsEtp8/Ou1cdX9x9I529v08/c2Hx86Jn2frn2seThTSulb3/pWzeNB+xx77LGh3uh+9pVX\nXgn1k046qd1/q2OyKp8g2sfXBD8vlz7X0jrga7nfD/Frcqw9pdzrfl4t7b1L+XibFb9wBAAAAAAA\nAAAAANAwvnAEAAAAAAAAAAAA0LC1FlJVf9rvPyvWMKr+E2P/eWopdJr/BFl5KD2va1gLDzXgr6Mh\nXjwE1D333LPaY02p7fsuhXTszuoJt1Pr71JqG8Znq622yuVDDz00tJ1yyimh/rWvfS2XH3zwwXYf\ngzv99NNzee7cuaHNQxU2e0jV3XbbLZf9p+Oluer95D8z13nj4Wf8b/V5Pcyehy9SpRDLffv2rfl3\nzcpDOHsoHP2sPFSZhll65plnQtvxxx9f83k8VO5hhx0W6gMGDMhlX8s9dKuuu9OmTQttP/7xj0N9\nxIgRqZb7778/l4cPHx7aNERwSvEz8/GiYTtbjYd48nAduj7usMMOoc3D+GhYCD/P+vlRx4B/3h7y\nR3n///M//3Mu9+vXr+bfoX022WSTUPe5qvsaDx01c+bMUNf9nocL22677WoeQzOERGxmvvatWLEi\n1P28qzz0iz7Wx4qfdzbddNNc9vQKegyEVG2crsm+1zrnnHNCfaeddlrt36XUNryinhc8VLWHVNV0\nAr5nKPF+1r2JrxcexlCv22bNmtXu11xXSvvVjgqD2pFKIZ/WJOSrr0Wt5KCDDgp17XMPQzp27NhQ\n13OnP9ZDZOq1kKalSSmljTfeONT1POxzfuTIkaGuc+r222+v+bzLly8PbT169Aj10l6vWZ122mm5\n7Ouq7kN9L1NPeHifV/q3VaFztW+9n/15S/NXr8n9vfi180MPPZTLZ5xxRs3nbBal8OSf+tSnctnD\nj/s+SP+2avyX9r7eT/pcVeNM2/3aTMfSN7/5zeLxdVff+973Qt0/7x133DGXPYXTPvvsE+qvvvpq\nLvu9tMGDB4e63v/wfbrP+UceeSSX/bz685//PJd9fH72s59NqJ+nESrtdbytdB1VtUYQAnfdGTp0\naKjPmTMnl0t9mlLsV5+Dvvf65S9/uSaHuU50vasWAAAAAAAAAAAAAE2DLxwBAAAAAAAAAAAANIwv\nHAEAAAAAAAAAAAA0rNNyOHqsWo3n73GNNZ6/xrtNqW2ccY1n7THqPW5xKX+Yx87VnG3e5nHRFy5c\nmMueJ0TzhT355JPF5/EcNa1Mx0NH5tvRceW5YDzHjOZ4mTFjRmj77W9/G+rnnXdeLh9++OGhTf/2\n9ddfD22e705zVj3wwAOh7ROf+ESoa96b6dOnp2bTu3fvXPZ8XJ6vcsGCBTXbPB+Jzk3P3eaxzHV9\n8DwEnmPh0UcfzeVjjz02tOl49djZreCxxx4r1pXn5Zs9e3Yun3jiiaFN8zumlNLZZ5+dy9dee21o\n8zG+11575fLvfve70Ob9rDkO/vVf/zW0nXTSSaGueeR8nuv64e/T+33q1KmpO/JcDz179qz52N13\n3z3Ufa3XeeU5LnzPoPPVz9/bbrttzWPwfCnKcwpi9Uo58vbcc8/Q5vmYNH/U73//++Lr6Hrt+UY+\n8pGPhLrmQfJxVcqlg/bRXK0+33yu6h7Z+8JzT+jfVs153VsPGjQotHl+GjRGc22fe+65xcfqXPI9\nnV+raW5Xz9noY0Qf6/t2ze9YjzvuuCPUfa1vtvy9pfNhPTlMq6631iS/Yokebylfc1W+OM3t3Wom\nT55cs02ve1Jq+zloLkbPyV7i59lSTjjPf/7DH/4w1FetWpXLvl7r/ZnS/ZaUYo72VlnnH3/88dWW\nU0rprrvuymXPHT9//vxQ18/O73GVcrkuWrQo1P1+me7rNQ9j1fP6/NTj0zx1KbW95vv0pz9d83mb\nUWmvOWXKlFz2PvV7Hm+++WbN5yztp3x9Ls1tb/Pn1bHleV31+C6//PKEtvy62Oeq9oXPeb+vpXPz\niiuuCG1+/1zntT+P79H0nrPex0kppXnz5uWy541EY8aMGRPqvg/SOeh9V1pb/Hn8fDp69OhcnjRp\nUvsOFg05+OCDQ937UXPb+zWUn0u1z+fOnRva/HsIcjgCAAAAAAAAAAAA6Fb4whEAAAAAAAAAAABA\nw/jCEQAAAAAAAAAAAEDDOi2Ho8cH1zjvno9rq622ymXPReA5tzRvgb+G5gFIqZxDosTzDnmuRc3b\n6HnINDa3x/L1fJRbbLFFu49pXdG471W5QPQz9j6uJ2+j5ojyPtaxklJKhx56aC4PHTo0tD377LOh\nfv/99+fy8uXLQ5vnsRg3blwu77///jVf0/vU37fSvJAppdS/f/9Q//d///dcbsYcjppj6zvf+U5o\n83jkmqfxsssuC20+VjQXj48H//z1bz3WvffN3Xffncsez74US7sV1JMD6MUXX6zZ5nPOc1XomuC5\nmnS8p5TSV77ylVz+5Cc/Gdr8vDBt2rRc9nnkud90rPkY8PyEqrvmbHQed95zUyjN2ZlS21ycnmtA\n+RpRymHg+Ug0/6bnFNSxrnlmUVvpsz/uuONC3fP/eF15v+l89Nf0PdvAgQNz2ddk3V+Sw3H1/LP3\nz0n3Xb539XOpzmPfO/nr6Pzz805pLdlll11C/bnnnsvljswDvra1N5+5f45a931PyVlnnRXqhxxy\nSC77PNp0001DXfP6DBs2LLR5LlcdE36+9jVZcz1/9rOfDW2ag1nP8ym1HS96fXjjjTeGNs+tMmHC\nhFzeZ599UlfnOSdLuVBLOdeqlMZjKQdzVS5AHaOl3DX+PP6afv3dSkr3SUp5DlOK48Pz9XkOLl3r\nvZ98T6z94edgz9Ooz+vnE33sggULQpvPY81p1yo5HEs0H9O//du/hbZRo0aFul5Tlc4JKcW+9ZyN\nvgaXcsKW8sf6mNX6EUccEdo0V2WrK+2v/B7SfffdV/Nv/dzu60Apf3bpGEprTUqxz/01r7/++oQy\nv0/i+Uy1r1544YXQ9qEPfSjU9R603m9OKaUPf/jDoa57IM/r5uNB13Pvfz1Hl/blaD/fZ7799tuh\nrmPCv+twOpd93uv3IimldOSRR+bylVde2b6DRUP0s04p5mxMKc7BqpzoOj99n6b3uJoVv3AEAAAA\nAAAAAAAA0DC+cAQAAAAAAAAAAADQsE4LqaohMlKKIZo8zJr+fLtv376hzX+Cqj8D93Af/rz6k9Sq\nEIIbbrjhav8upRjSMaX40+aFCxeGNg0H9PTTT4c2D5XQq1ev1BXpT4DrCU+moVk8pIuG2rj11ltD\nm4ZKSymlo446Kpc9fID344wZM3L5hhtuCG0e/kU/7wEDBoS2WbNmhbqGPCiFVvSxoaFYU4rj1cMK\neeiYLbfcsubrNAOdx1UhYS+44IJc1vBa/jwppfTWW2/lso8rp/PaQ/tts802oX7AAQfk8k9/+tPi\n87aaqpB0Os889IauYx4qydc0DSHhoYLOP//8UH/44Ydz2ceAH4Ous4MHDw5tHtJAj9efp57QIfWE\nLWulsI7+vv2ct/POO+eyz7E33ngj1PXzL4VeTCmOUR+vHgZMw/L94Q9/CG3axx6SG/XzUJe+zuq+\nzPvN91alECK+v9t9991z2UNB+t+iLQ+pVTo/+lz0viitm6VzS1XIxlrHU89rNJNSOMt6QkyrY445\nJtQ9tJeeHz1sp7/GKaecksubbLJJaPPzwOOPP57Lb775ZmjzcFG6F/ZrRQ2RPn78+OLx6bz3UOp+\nftHjHzJkSC77OWpd0uvQ0vmwKjyynmer1sZG55K/ZilclD+2tJeqCjvVSvyaUPc1fr9g4403DnUN\ntelru9OQ2FXriLZ7eplSKDcPx6z7cl0bUmp7PvHPoTs588wzQ/2ee+4JdQ1vWRX6VM/Lfq1T2ov5\nYz2kpo5LD816zTXX5HJ3CqHqSvPK7y/96le/CnXd2/r1az2v40p9XNrjeTjeSy65pN2v2V3NmTMn\n1P1aU8Pq+n0s31vttNNOuezXOr/5zW9CXe/BjBgxIrR5aoRVq1bVfE1dvz2FAhrje2+/X6brbNV6\nrXX/rsNDqnq6A3QeTaOXUtv5qXsb3/f4Wq597OtzKf1Ts+AXjgAAAAAAAAAAAAAaxheOAAAAAAAA\nAAAAABrGF44AAAAAAAAAAAAAGtZpORw9t53mGPDcHxpX2uNVO41d7HHGPU+Ixsst5YJMKeYq8JwX\nnuumZ8+euey56jSGvubjSKlt3qktttgidUW1YsQPGzYs1DUPSkoxlvEee+wR2o488shc3nrrrUPb\ngQceGOo6Vjy3nuaESynmAvHcUp5TQnkMbM/pqHnAvP819rnH6PbcRjruvP+dxm1vRtoXVbmaNMa4\nzzefm8pzlfi81vHhr+lry0EHHZTLPs7qeS+tSN9jKQeQ5tdMqe1c0VwFHr9+o402CvXjjjtuta+f\nUtt+1rV++fLloa2U+8pjqNdDn6cqJ3Cz03xBQ4cODW1+/r7oooty2ePXV+WCay/PKeM5wnbbbbdc\n9vVD9xee7xP18znu64POeX+sK+UscJrP+aabbgptrZQztbNUfUa6H61af0t5vkuP9bHij9Xnavac\n1rU0eq7Qz8P34ieccEIub7bZZqHN8+XptZnn8fFrKs09NW/evNDm66yez3U9Tqnt+q17AV/LdU/h\nua/8vWieds8F78en12O6RnWlnIF+TaV0bvh783lVmnOulEe0Ht43jT6XXyf52Gklfo9A8zZ6rryX\nX3451PXc6nvpJUuWhLp+hp7vqbReV9Hj92vfBx98MJd79+4d2vwYPNdYK2h0XvlnofciqvpK1wi/\n/1F1v0z5Pl2PwXOLam66q6++uuZzdjel/l+0aFGoa9/49Wxprffn9X7T+5qeN9DXWb23UsrR7Vr9\nWri9fE3T+8QpxfXbc1Nfd911oa6f4TnnnBPaJk6cGOq63/N7oFdddVXNx5566qmhTdedp59+OqEx\nel/R+RzUOVfPNZfviTzXsq7XJ554Ymi7+eabax4f6ufXUL6uaj9W7a203dd9/06tGfELRwAAAAAA\nAAAAAAAN4wtHAAAAAAAAAAAAAA3jC0cAAAAAAAAAAAAADeu0HI4ef1bj2nqbxsCdMWNGaPOY5Brr\n3OPhat6plNrGmlelvHH+mh5buVevXrk8f/780DZ16tRc9hjM/ppdMe/Q+973vtAf3/rWt3LZP1/P\nCaDxqP1zueWWW3LZY0p7XkaNYe/5DDw+ssbE9rj4ffv2DXXtR+3DlNrmM9Dj33zzzUOb5o3xvIA+\ndj7wgf+PvTsPu7Kq9z++/J0mU1EBEUHBAQREBkVxHjNtcEztlJpmHjUz62iZlllmx2OapalXmifz\nysyxrBwDBxxzAAdAGZVBREAURbI61Tn+/vA6y8/387DX/ewNDzzP3u/XX2tdaz9739zrXsN9b/b3\n+6Fc1rjay9PVc5XUcz3reVqRcVDK91iVm8evD9UZx2Zn5HOs94fO0aU8jF6vinWuc6m/1vN8lvL+\n1pO/aWXlOuoKNNdhVf7jffbZJ5eXLFkS2kp5nerJjVraT6QU+9zXKZ13Pa8G2mfrrbfO5W7duoW2\npUuXNvy+em2Vcq+m1DaXKOpTlUO6X79+Ndt8/JXySjlt9/2crx96jL7vakYHHnhgLnvec8/3suGG\nG+ayz5Wap9bHzWuvvRbqs2bNymWfK/1v9XM8J5jnmNO+88/0HHMDBw7MZc/vpvnn/Pg8x6HORX5/\n5deW7sX137IieZ1XNj0XpTxaVXlTS2upt+l7+XpdGtv1vLa0n64nZ6Bfc57vrKvRazKleA37XmXs\n2LGhrvm6PBek30vqteRtpf2yjyHvRx3Xb7zxRmhbvHhxLvu41bblHUMz0HFWyrVYesbl71N136Fr\nhs8fnmNO38vXGv8c7R/PF6Z7Q7yndL/ofazj3ueE0jxblfdN39f72POr6+d4H6Pa1KlTQ91zaWtf\n+Bzsexed2/1Zqt9vLViwIJd9L3X44YeH+mOPPZbL/txVNUO+uNVl2223rdnm91G6DlTN7boW+5rh\n66eOZT8ecjiuXFX9pn1TlYNZ54WqZ15dEb9wBAAAAAAAAAAAANAwvnAEAAAAAAAAAAAA0LAOiyXj\nP9/XnwB7+I8333wzlz0spofx0ffxn5h6CAn9SaqHAvGwBdrur/VQmPq3/tN4DQnrYYQ0VElK8ae4\nHqZMQyStSt26dUsf//jHc11DGmk/pdQ2RIf+5Nv7X8/p7NmzQ5ufJ+3jUaNGhTbvCz0mD+PkP3XW\n685/yuzhD/T4/SfpGhZs8ODBoa0UNtevbQ8v1tXDA9UTclLPi49j/ym5ntNGQ2Cm1DY8UHtDOZXC\n4bQ6D8tSChXi14S/tp5QMTpHlEJnp1QOu6vho/EeDc1ST6gP74uq8OTt5X/nY9KvQ6XXjq9LaB8N\nsevjthSG0fvf92jaN1UhRKpCkmPF+F67pDSn+tjUNaAqRJ++r++Xm8Faa62VRowYkev77bdfLnuI\ncb/eJ0yYkMs+BjX8rIc29D2phylVfg1of3ifL1q0KNQ1DJeHvvQQba+++mou+zWg++ChQ4eGNn9f\nvZ48rFTpvqJ0/a5Oeo/ic2U9KRdKYRh9L6X1evbXP6fNVAAAIABJREFUVXQeKKUwKR2P82u3q98z\nle5B/JmAz4c6zn3c+j5H6z6v+HWmr/XQj6U52ftYnw/4v7MqJFyzWZFxpX9bSlGQUjyv/pm+R9Zz\n7s8iSqHffF+m65anqvHQua2UlqKkKiS28rGszwarQmlr3fvY9wm6vngbqr3wwguh7n2sc6mm3lre\na3V91BDzKaW0ySabhLpeA9OmTQtt/lxTj6H0nK2rp3danTbbbLNc9vHoc3DpOVZpj+qv9br230Yb\nbVRxxFgRpWeTKZWfgZaUQt13VfzCEQAAAAAAAAAAAEDD+MIRAAAAAAAAAAAAQMP4whEAAAAAAAAA\nAABAwzosh6PHgNa8AZpvJKUY19jzBHrMeo1D7m0e81hj4Hp+AY+zq3HpPfeH5wbU3AQez/7FF1/M\n5b333ju0LV26NNQ1R4PH2l5dORxTivHEN91001yeP39+eJ3nV9E40pqjJaUYO9xz1XiMeu1jjyWv\nuaRSSqlPnz5tjv//eP4A/Vy/VubNmxfqL7/8ci7PnDmz5vv6dVWKqe85Lz13xmOPPZa6slJ+Bh+r\nG264YS57/Hofm1U5+mrxz/TzrcfgY37ZsmW57NcKORzfU8rDmFI8V1XztfI+L+X58WvN+0eP0cer\n58nBuzQPQVWeED3f9eSqqSeefVUeKr2WvI/V3Llz2/2ZeI/u2Ty3QFXftFdVvkfPJ4WVS/uxnhx3\n/lqv6/7O5/VS7i7fdzeD7t27p09/+tO5rvlVPL+L74s333zzXNb9SUpxv+3jr7S/9rHr91865jRH\nY0pt71k0t71/pu61/BhmzZoV2nbbbbdc3mqrrUKb5+zTc+b3FX6O9J7qwQcfTJ1R//79c9n7RseK\nt/map+2lfGzLe6+Sel5bWpNLueZK64deY82olIva50OdS/3+RXOBphTHgu95S/naPN+jj7ES/beU\nclWm1Py5tUv3jJ6XtHSNV51H5etw6Z68KmdbKR+rrhGjR48ObXfeeWeot1IOx9I85vm4SufC54TS\nPq2Ur9nHcukzZ8yYUbPNNXs/NsrnSp2jPZ+m1xcsWJDLuu9LKaWePXuG+pIlS2q2+XNkfQZdek7i\nz7XRfnqvXBq7KcXxWvUsWeveP36vXNobYOXy/PQ+BvUaqCfnrj8P8fm7K+IXjgAAAAAAAAAAAAAa\nxheOAAAAAAAAAAAAABrGF44AAAAAAAAAAAAAGtZhORw9Dr3GLF9vvfVCm8Yh19x5KcUcJynFWPIe\n999j6WocY49X7bHwNc6uH7vnmdHXej5KjZldlYdMc/p1lhwGS5YsSTfccEOua3z+W265JbzWcyrp\nuRg4cGBo0/wv3v9Oz4XnvfQ+1utl2rRpNdu6Gs1V2VX+HRpz2mOK9+3bN9T12vHY5T7eNHZ1PfnB\nfIz7eNS4+dttt11oGzduXM3jw3s8V0wp7rj3nfdHKT+JXxOlvIH+PqW8IfTt8o0YMSKXPXevr6Wl\nHKulmPVVOfu0H+vJXeN9rPkOfG33nMCagxnv0Twi9eT3c1U5DEqv1X2B5z3yfQLqp7mp+/XrF9pK\n+SM8n4jn+tN+9Hncx7zOCc2Yw3Hp0qVpzJgxuX7EEUfk8pQpU8JrvQ90DG699dahTceGz6ulubMq\nH7X+rb9vaSz7nnXy5MmhrvdJL730Umgr5Uh/5ZVXQn3OnDnL/buUUlq0aFGoe26VzkiP0XPv6Lmo\n6jdtr8pxXY969t/6Wv9M/bfUk1Oy2XI4+lqqebQ8r57nBNPz5ufX52udH3xM+bMHzffoY97v+fUa\n1ecZfrz+b/E1o9G8z81gk002CXWf4/Tc1LMP9td6Xfuk6r5I1+3SWN5nn31Cm+dwXJG5p6vRc+bn\n09dvzXHsc4L3m47BUi77lOJezM99r169Ql2vB8/PrOrZw7cyn4P1/Pq+119bes79X//1X6Guc+nH\nPvax0Obzt16Tft+uuX3J4dg47buqeVX7x9fI0jir6p9Szl2sXDNnzgz1LbfcMtQ1R7bf/5aeifpr\nZ8+evULH2RnwC0cAAAAAAAAAAAAADeMLRwAAAAAAAAAAAAAN67CQqv7zYP3JuIdF0Z9yz5o1K7Tt\nvvvuNT9DQ3+k1Dbch/5c2X9WrGFR/bX+83YNveh/66G8ZsyYkcsHH3xw8fjefPPNXPafz65OGnrh\njjvuyOX77rsvvO7VV18NdQ1H9/TTT4c2Pafjx48PbX49aF95yFp/rbZ7+F0PRaD96CEN/HP05+se\n2khDxXifOv0cfx//ub2G9TzzzDNzeeHChcXP6Ao8fEfpJ/+lMCFVr60nDKO2jxw5MrRpSNVWDxlS\nT1jM0jkvhTqteq3T66AqxKOOQV+X6gkPWQrN2mz0nGm4n5Tarp06H9YT8sn7wufk0jn2z9F+9LVU\nw9T5mqXhLlCbhnf0fimF7KsK+VQPnWs8DBkhVVfcvHnzcnmHHXYIbb7uaj96n3q4Hx2rVWGDtI99\nrDaDt956K91999253qdPn1z2PchDDz0U6jfddFMue3hF1aNHj1Av7b3ac7z/x+dKD2H6+uuv57KH\n6/Jwbro392tA5+/SPV1KKW2wwQa5vNVWW4W29ddfP9S1/eGHH87le+65J3UWmnrE+1jD1/t9kK/J\nev59fl5Z4Sur0pSU9ks6D1SFWVZ+D9XV+XyoYUmr9tY67/r6V5qD/fx6mpJS6D+n9/V+vPq+/gzF\n+7wZQuWW7pNKbQMGDKjZVsWvCe8D5et06fj8fXWsl56l7brrrhVH3DpKY+c///M/Q12fG3rKIQ+t\nrvczPu/73+r49FC9HrJen0fq+ojGlEKi6zPvlN5NZaV0vGnY+JTaXg/63NPDyG+22WahrvOwzwf6\nmStyn9bqdG3z9d2fSXu7Kt1neyojX8NL91xYufz5vI97HVe+Z65nDHpqo66IXzgCAAAAAAAAAAAA\naBhfOAIAAAAAAAAAAABoGF84AgAAAAAAAAAAAGhYh+Vw9PizGtfY48x379695vt4rH+PWa4034gf\ngx+P5wbRmMeef8RzOmq8+7XXXju0TZkyJZc9zrLHydc8C/7azkLjE2uOwZRS6tu3b6jvtttuuezn\nV/OnbLHFFqHN44xrPPstt9wytHluCj3fGts+pbbX2brrrpvLCxYsCG2e70Xz1fj7aL4Jj9c8c+bM\nUNeYzFUx9O+8885cfvTRR1NX432jPEemjoWqnDLa7uPYc39oDhTPNeF5KUp5NGq9DmWlXCWlXG8p\nxf4pvY//rb/W+13r/j7NkDumI3zlK1/J5alTp4Y2nedTSumAAw7IZc/rVcrrVMpJlFJch6v2AZpn\n8tZbbw1tc+fOzeV77703tHnuDCyf7tF8vFXV26sqH5HmotDcbWgfP5++z9X9iL/W52rlY3NF8vrq\nHKA5hVzV+tBVXH311TXb9t1331AfOHBgLnseH/33+xxcyg/kOZ+8L/X+xvfinjdG8w/6NeC5azS/\nlee60j2c7yn9OtR/t/5dSjEnaUrxXFflpltdNMdSKfei32f49aD9WNqX+/v6eKzKma7qmSM036d/\nht8rqM033zzUH3zwwZqv7Qo8v5L2uZ9PH6uam9XzfPleqpTH3O9h9bWl8eaf45+p99T+Pn49NEOe\nqdIaVBo3/tyilD/Nz1uJf6bPwTpHr8j76vXiubXreZ+uuobXUpoPJ0yYUKy3l187Y8eODfVhw4Y1\n9L4lzdZPHWXZsmWhrvcsVftrXRP92fBLL70U6tOnT8/lvffeO7T5s2vlz2j1M0s5wlGm+ZR9Lvf9\nldar9lqlfZpfP/ra0jyEFVfPMy/nr9U12ufZF198sdFD7DT4hSMAAAAAAAAAAACAhvGFIwAAAAAA\nAAAAAICGdVhIVQ/foD8z9nBY+pNfD4taCrNVFbqrFEqm9JN2f99SmBn/ybSGFSqFxPHP9NCsXcH8\n+fND/cYbb1xNR4LOQK9vv/ZLY96Vwqx5GC8PjVUK1VoKW7HpppvWPJ5WVwqh4nNsKSxE1bxaCgNR\n+ls/Bn+thg7x13bFeXdVu+KKK0L9rrvuCvXPfOYzuexho0uhmkqho1Iqzyd+7WgfazjslFL6zne+\nU/wcVNNx4ude9zwplfutFKKtaj+nn6shdLFyaJj5qlBAykOz+t9qv/q+u9TnGnbRNXs4tpTahkdD\n89OwtaW9yU033RTqJ598cqhraNbVRcekH8+0adNy2dNbHHTQQTXfc8iQISvp6DoHnzuVr6u+5ule\n21/brVu3UPd5V/l8rf3mKQd8/dbnNb7XGzFixHJftzylVDnNwO+LlJ6nlNquZaW+K63L/j7eP9rv\npXQjVZ+j91QevrtPnz6h7vcHrcL3K6W+KKVwSimOQU9vsSIhbZVfc1VhudFWKV2Ln9/S82gfe77W\n63NYD786ceLEUNd51q9BPV5/fo/20xQuzudV7Y9S+NuU4h6qKtS51kt7DKw4T41Wen7tbR5KvpTq\nYdKkSY0eYqfBLxwBAAAAAAAAAAAANIwvHAEAAAAAAAAAAAA0jC8cAQAAAAAAAAAAADSsw3I4etxg\njVXrcaY1XrTH+vfY/hqbuJQfKqUYk9pjZPv7apxdzzfh8cu17m0ek1d5/N5ly5a16++ArqCUR2nz\nzTcP9VJc8VKuRc834jGvNZdbKb9jSnHslnJstLpSviyf00p5GevJs1WVz62UH6F0bXk/l3KTtDI9\nLz4ejzrqqFDXNbtqHStdO6W8MVX5kDVv41577VU8BtSvb9++uez7Lh9v2lc+X/vfek5e5X2se7iq\n/J9oq2qN0/xLVeNNx2ZVXsbS9VC6PjwvGdDsNOeZ5/TRva3nZtK2lOI67Peo9ex5VmSe1X2DzxF/\n/vOfc3n69OnF99H5o3fv3g0fT2fk50XnPJ//+vXrF+raj55zy/9W+8L3c6W6Pyfxe6pS7kXt1z33\n3LPm61KqfpbTFZX20Grw4MGhrs+FUor3Oj4e/X11zvC9le/N9dqryvNVWu/1GvB5aPfddw/1G2+8\nMZdbIQ/z//F/WylXlyv1effu3UPbn/70p4aPSZGzccX5nKz95ntxXQ9TSmnQoEG5vO6664a22bNn\nh7peA/4+I0eODHXdN/j8oMfUGXJAd1WLFi2q2ebnXOfSqvlP/9avH18HNP931bM0rJjHHnss1P18\nr7POOrns66yvpdru10PpuuoqeNoKAAAAAAAAAAAAoGF84QgAAAAAAAAAAACgYXzhCAAAAAAAAAAA\nAKBhHZbD0fNPlPJGaJvGHk4ppfXWWy/UX3vttVyuysel7Z5roJRryuNgl/KFaXxef99u3bqFNo/J\nq3WP5Qt0NaUY5D6OS9e+j2Nt9zafL3TeqcpDpXkKfKyifapyiug59zm3lNekKndQ6W+rcgO2t62V\nlc6v5pdIKfZxVb4A7Rvv4xXJFapjuZ48T62UR2ZFrL/++jXbfP7W/VKpn7y9Ko+TvtZzBaGa95P3\nha6d9eQ09nxEnv9Fx5jnsPDxp/POm2++2e5jAJpBr1692vW6cePGhbrPs/Xkxi3l2V6R9bC0h9Cc\ny9OmTSu+j85F22yzTcPH0xn58wPl+yO/19F8bd7/pWcW3qf+bKS0fvv8rdeZrycbbLBBzc/wewHP\nd9YMdL31NXLEiBG57OfGx03pXsjPuT678n72c6596f3sa3gpt5T+rc87Rx55ZKhrDsfS/ID3lM6T\n53BsxlyoXUVpXfV6VY5M7ceNN944tD333HOhrmN+yJAhoa2UY9fng7feeiuXyeHYOJ0P/T7K1wHt\n56rnldpeda0p8rF2rBkzZoS6r6W6t/G53K8PXeu93xYuXLhCx9kZ8AtHAAAAAAAAAAAAAA3jC0cA\nAAAAAAAAAAAADeuwOJ5TpkwJdQ3X5OE+7rvvvlzWkKkptQ0xoz9X9Z+n+k+S9eepVSGi9LUe3sND\nUWn7uuuuG9pmzZqVyzNnzgxtpZ9BT506tXh8QFe2ySabhLr+XNzDgPg41vHnPzP3EAU6P1SFKdY5\nwcMVoX38HJfmuKpwmzqfl0IN+Ht5+G5fX/Rv/XqpJ6xP1fG3iv79+4e6hluqOkelMVkKu15F54wl\nS5a0++/8uvKQYXjXyy+/nMv9+vULbd6n9YTmLIXYdXpt+b4L1ar6QufG0l46pRiqyUMz+WtLIdFL\n468UFhJoRgsWLMjlAQMGhDYNnfb666+HtmXLloW6zpW+5ympCqFazx6otLfacMMNc/mOO+4IbT5P\n6TE9++yz7f78rsD7Tec8D2P+6quvhvrhhx+eyw888EBoW2uttUK9FGrRz3dpH96zZ89QL10veq/m\n1+CK7MO7itJe8itf+Uou+7nw5096bny99NDyes34NfCXv/wl1LVvfQ9X2iuU1nf2zyufj13de3n6\nCL8Xxqrj47aU8sufY/n4e+aZZ3LZw4j37ds31GfPnp3Lffr0CW2+tmrYVH9OovWqezHUVpoD/V5J\nx7afc3+t7g18nHtd1wXm5FVr/Pjxoa5ztO+fS89OfG/o+7+uiF84AgAAAAAAAAAAAGgYXzgCAAAA\nAAAAAAAAaBhfOAIAAAAAAAAAAABoWIflcPQ8Shqf2HMTnHPOObnsca8HDx4c6prDoSofjLZ7rgHP\nGaCxdf19Pd62xlAfMmRIaNN4ybfffnto+8xnPhPqixYtyuUXXnghAc3K8zHpGPLY9z7edE7w+cHz\nG9QTJ1/nhFKOk1ZXytPiceY9Rrn+bT353Dw3idO8J34MPn/r5/q/pZ749lX5jVpF9+7dQ13HclVe\n5Vp/l1LbHDPaj96n3ud6Pfj+YvPNN89lzbG8vPfF8mk+IO/jddZZJ9RL483pnq0ql6/2VdVcgvrN\nmDEjl30s+tqp86b3hc+per34uHXax7o/BlqBrk977LFHaLvzzjtr/l2PHj1CXcek74NL98lVORrr\n2QPpPOBz+w477JDLixcvDm2axzKllDbeeONc/slPftLuz+8KfK8yaNCgXJ43b15o0xyeKcU8gFOn\nTg1tpX70PizN7VX7Zb22PK/y9OnTc/ntt98ObVtvvXWoz5kzp+bxNiN9jnXqqaeGNs2zllL52ZTT\ndu/XtddeO9R1/+397NeP1n3+0Pp6660X2q699tri8aJaKb+p5+ks5a/3a6cZ86auTn4+vS90bFQ9\nYx49enQue+423aenFPfUEyZMCG2eB/rNN9/MZZ9zuRdeOTS/tj/39Gedui/yOdf7Q3Ns+vv48zJ9\nL7+20LH8vnXkyJG5/Nprr4U270ft47vvvrsDjm71YoYBAAAAAAAAAAAA0DC+cAQAAAAAAAAAAADQ\nML5wBAAAAAAAAAAAANCwDsvh6ObPn5/LU6ZMCW2av9DjFj/yyCOhrnkNPG6xx5bX+Mia4ymltrkI\nSrmEvK75McaMGZNqmTZtWqj7v9vz5ADNqk+fPqGusat9HHs+Gh27nvfNx7HOHx4f22Psa46LDTfc\nMLRpjpHnnnsutbJSTkTPQaMxyFOKfef5JjzHiOYi8Hj2PlfqfO15wfx9S/mM/LWo5n2sOfy8jz2/\nXym3kOeG1Lwy/neeE0j72OeTvffeO5c9hyPaR+dkP7++P9I5wfP7+T5M52Sfrz2vkF5bPu+gY/n4\n03Ht49ZzRen6UZWry+cWoJXo+ND74pTK+1Cfk3v37p3Lvsfxeq9evXL5wx/+cGjzvIElvrfSNfpv\nf/tbaCutw5pnKqWUli1bVvMzujrP96Prmufu8tc+88wzuez5Hj2Xns7fVXk4dU329dufsehrly5d\nWvN49XpMqe0+0XNdNYPSeb7sssty2dfLI444ItR17+X94f2s46wqH6veO/veq557M70nv+CCC0Lb\nRRddVDwGVPNnHMrvrzwfriJnY8fye5u+ffuGuvaVj/ktttgi1LXPJ06cGNr22muvUNe1X3PDptQ2\nr+7w4cNz2Z+zae5YzZuM+pS+S/D9i86lPpZ9rte+9DnB117l1yU61kEHHRTql19+eS7fc889oc3z\nle+33365fOWVV3bA0a1e/MIRAAAAAAAAAAAAQMP4whEAAAAAAAAAAABAw1ZZPLnzzjuvob878cQT\nV/KRrDr33XdfsQ60Cg8loOGiSmF6UkqpW7duueyhKEo87ICH4dMwz/fff3/xGFqZh3ZQM2bMCHUP\nnathOpyfYw1B5NeE1z3Ma6lN39dDXBA6pH4DBw4M9W984xu57OPcQ7xoWPHDDz88tI0aNSrUNUzY\no48+Gto8lNTo0aNzecKECaHthhtuSLU0W4i2jjJ9+vRc9tBuHlJT+83Dinnoap0DPKyaz/UaNub5\n559vz2FDVIXSW7hwYS576FMPibdkyZJcvuSSS0KbrwkaJkbLyzum1157LZdffvnlmsda9W8BuqJz\nzz13ueUqHrK0KnSx8tQfq9uwYcNW9yGsNroe6n1PSm2fH2y77bar5JhWhkGDBoW6h3lr5X3Y+eef\nX6x//OMfz+WhQ4eGtv79+4e67sX8nPqaqXW/F/O1d+bMmbnsaYR0zcaK85C1pb3OrbfeGupbbrll\nhxwT6jdu3LhQ33nnnXN56tSpoU33026DDTYI9QceeCDUNey5h2YdP358qGv44+222y606TO5p556\nqubxoGzy5Mm57M+/xo4dG+oPPvhgLnsIXr8f1ntnf/7Rs2fPUNd7Z38ego7la+mXvvSldv/t448/\nvrIPp1PhF44AAAAAAAAAAAAAGsYXjgAAAAAAAAAAAAAaxheOAAAAAAAAAAAAABq2Rj25UNZYY43F\nKaW5HXc4aED/d955Z4Pql7UPfdwp0cfNb6X2cUr0cyfFWG5+9HHzo49bA/3c/Ojj5kcfNz/uoVoD\nY7n50cfNj/m6NTCWm1+7+riuLxwBAAAAAAAAAAAAQBFSFQAAAAAAAAAAAEDD+MIRAAAAAAAAAAAA\nQMP4whEAAAAAAAAAAABAw/jCEQAAAAAAAAAAAEDD+MIRAAAAAAAAAAAAQMP4whEAAAAAAAAAAABA\nw/jCEQAAAAAAAAAAAEDD+MIRAAAAAAAAAAAAQMP4whEAAAAAAAAAAABAw/jCEQAAAAAAAAAAAEDD\n+MIRAAAAAAAAAAAAQMP4whEAAAAAAAAAAABAw/jCEQAAAAAAAAAAAEDD+MIRAAAAAAAAAAAAQMP4\nwhEAAAAAAAAAAABAw/jCEQAAAAAAAAAAAEDD+MIRAAAAAAAAAAAAQMP4whEAAAAAAAAAAABAw/jC\nEQAAAAAAAAAAAEDD+MIRAAAAAAAAAAAAQMP4whEAAAAAAAAAAABAw/jCEQAAAAAAAAAAAEDD+MIR\nAAAAAAAAAAAAQMP4whEAAAAAAAAAAABAw/jCEQAAAAAAAAAAAEDD+MIRAAAAAAAAAAAAQMP4whEA\nAAAAAAAAAABAw/jCEQAAAAAAAAAAAEDD+MIRAAAAAAAAAAAAQMP4whEAAAAAAAAAAABAw/jCEQAA\nAAAAAAAAAEDD+MIRAAAAAAAAAAAAQMP4whEAAAAAAAAAAABAw/jCEQAAAAAAAAAAAEDD+MIRAAAA\nAAAAAAAAQMP4whEAAAAAAAAAAABAw/jCEQAAAAAAAAAAAEDD+MIRAAAAAAAAAAAAQMP4whEAAAAA\nAAAAAABAw/jCEQAAAAAAAAAAAEDD+MIRAAAAAAAAAAAAQMP4whEAAAAAAAAAAABAw/jCEQAAAAAA\nAAAAAEDD+MIRAAAAAAAAAAAAQMP4whEAAAAAAAAAAABAw/jCEQAAAAAAAAAAAEDD+MIRAAAAAAAA\nAAAAQMP4whEAAAAAAAAAAABAw/jCEQAAAAAAAAAAAEDD+MIRAAAAAAAAAAAAQMP4whEAAAAAAAAA\nAABAw/jCEQAAAAAAAAAAAEDD3lfPi9dYY413OupA0Lh33nlnjZX1Xquij7t161as/7//99734O9/\n//tD29/+9rdQf+utt3J52bJl7T6GD3zgA6G+4YYbhvraa6+dy6+++mpo+8tf/pLLf/3rX9v9mSui\nq/Ux6rcy+zgl+rmz6mpjuUePHqGuc2NKKc2dO7ejD6Eum2yySaj/93//dy77XN5RulofV/ngBz+Y\ny7169Qpta621VqjrGv33v/89tP3P//xPqOv6rp+xvNe+/PLLufzPf/6zPYfdoZqtj9Wmm24a6h/+\n8IdD/e233675t2usEU/LO+/U/qf5Pmzp0qW5vKrGaoXX3nnnnQ1W1putin72c+rjyOsdwa8B3+Pr\nNaF7+NWlmcdylX79+tVs83Gu/fj666+Hts7QjyXN3McbbBCnqHXWWafdf+vzwf/+7//mss/dfj28\n8cYb7f6cVaHV7qF8L6bPTkr96q/Vckpt15APfehDuex7r9mzZ9dxxCtHM4/lgQMHhno9+yl9NpVS\nSmuuuWYu/8u//Eto82dp+r6+9/LXrgrN3MfO77HXXXfdXP7HP/4R2nxc6/2tr8mdXavN107H9mab\nbRba9F4opTiWvZ9X1XPoRjXzWPax699Z+LqrfE4u8XVA12Rfg0trREdpTx/X9YUjsDLssssuob7v\nvvuGum52+/btG9qmTp0a6mPHjs3lcePGtfsYNtpoo1D/2te+VvMYL7300tD2zDPP5PKkSZOKn6OT\nxOqYBABgRRxwwAGh7vP38ccfX/Nv67lZXllOP/30UJ81a1YuX3LJJR3++c1Iv8Q95ZRTQtuOO+4Y\n6tOmTcvlOXPmhDZ/KK3r+xZbbBHa/GGm9uvixYvbcdTN6X3vi9v2jvjy9dxzzw314cOHh/rTTz9d\n82/9Jkq/dPb5wP9zwB//+Mdcvvjii9t3sB2rc/1vinbo3bt3qPt/xFtZXxKU5nb/zwO77bZbqOtD\ns7vvvnulHA8ac8YZZ+Syf/Hw5JNPhvo+++yTy7/61a9Cm47dKtwXrVyHHXZYqO+1117t/ts///nP\nNev+cPuxxx4L9Ztvvrndn4OV78gjjwx1nXd93vcvo/SBpf+HIv8PR4MHD85l33sdccQR7T9gVPrp\nT38a6qX9lPPnUVtvvXUu+38UnT59eqjrF1sdxGb/AAAgAElEQVSXX355aJsyZUrhiLE89dz7Hnjg\ngaH+sY99LJf9y1+/h3rhhRdy+Zprrmn3MZWOjzV51dB7uQsuuCC03XXXXaG+1VZb5fKvf/3r0Pbs\ns892wNGhPXzs+n8C0i+DfS73/4ipSv85O6WUhgwZksvHHHNMzc/sTAipCgAAAAAAAAAAAKBhfOEI\nAAAAAAAAAAAAoGFr1PPT6c4WOxfvWl3xkUs/yfcQXMcdd1wua3zylFJ66aWXQl1DPnm4sC996Uuh\nrqEe/KfNGtotpfjz9cmTJ4e2LbfcMtTHjBmTyxojPaWUDj744Fz2MEIaniillReaoJljYONdrR7P\nvlV0tbH8m9/8JtQPOuigUNcQfp5bwEO0leLZl9QTnsZDBmoI7L333ruhz69XV+hjDZWrofJSSmn0\n6NGhrnkK5s2bF9o23njjUF9//fVz2cOCvPbaa6GuIZ809O3y6t27d8/lN998M7Tpeq5rd0odF7Kx\nK/Sx8rH44x//ONQPOeSQXO7Tp09o8/3SAw88kMvbb799aPP9nPaVh4P13GP6Xj179qx5vGeddVZq\nrxWcg5565513tqvnD0o6qp9HjhyZy1/96ldD23PPPRfqpdBpfm46KvSl7qE9ZPePfvSjXF5Vody6\n2lh2Hqqpnjyd2q+elsJzw2ieIQ/D6KG1S/R4V0VO0ZS6fh87zZ186623hja/b9Zwip7fUXMjpxT7\nxsN4+Vzq+4bVrRnuoQYNGhTqJ598ci4fe+yxoc2fTeg1oSFTU2o7f+vc7u/jIbE1lY2H7Nb9nu+1\nPIWBpsBZEc02ljfccMNcnjFjRmh7/PHHQ133UP4srXSf5CF2PfyqzhHXXXddaKsnXdHK0mx9XPLL\nX/4y1DUktu/JPJ/m+PHjc/nEE08MbR5GubPpivN1Pc8i/Dn4Jz7xiVD/7ne/m8s+X9fD9/yeBmx1\na+ax7M9DPOSxhjf1a8efnSxZsqTmaz2Xq4bY/fa3vx3azj///KrDXuna08f8whEAAAAAAAAAAABA\nw/jCEQAAAAAAAAAAAEDD3lf9EmD5/KfkQ4cOzWX/Se+9996byx52Y6eddgr1bt265fLSpUtD27//\n+7+HuobP85+vb7755qGuoXs++9nPhrbttotRszTszBNPPBHa7rrrrlz2kDIeAmr//ffP5RdffDEB\nQFfi4ZY8XNc3vvGNXPaQ0itLVRiTU089NZc9bKOGtGhlV111VahrCLzFixeHNg+/pKFQPZTeo48+\nGuoa1stDn3rI3WeffTaXPbSeh377+9//nsse2k3DkO2www6hzfcX3/nOd1KrOOmkk3L5qKOOCm0a\nHjGleE79etA+TSmlUaNG5fL8+fNDm4dg1uvMQwp5n+v14qGkjj/++FzW8K8ppfTb3/421M8+++ya\n71NPSKSu4uijj87l008/PbQdeuihoX7DDTfkclV42Y46Nxrq65Zbbglt2j8ayjmltvNHKymFty2F\nJdXQSymldMIJJ4T6Pffck8seLvGRRx4JdQ3ntsUWW4S23/3ud6Gu6S8WLFhQ83g9HKxfk80wPjuC\nhqP2NdnvQzVEpq+rvtYrD+M1ePDgUNeQ6B66Ge2je9eU2obH01CXvhd/9dVXQ13nVQ+LvnDhwlDX\ndu9nD7M7cODAXC7tFbfddtvQ9utf/zrU9d/qYTtbme5ZJ0yYENo8rLGGXuzVq1doe+WVV0Jd51Kf\nIzx0r87Jvu6ifhtttFGoazqPj33sY6HN90C6F/d9u+91r7zyyly+/fbbQ5vPyb/61a9yee7cuaHN\nxzWWz8NNe4jbCy+8MJd9L+7PInT+9jXb71s1dKc/4/D0GOeee24uP/TQQ6HNU4+hfprCwkOoeio3\n3bf7tePrrt5Lf+ADHwhtXte5feedd27PYa92/MIRAAAAAAAAAAAAQMP4whEAAAAAAAAAAABAw/jC\nEQAAAAAAAAAAAEDDmiqHYyk3i8c8ricHhtPcFZ7/QOM5ay7ClNrmDdS6x753mueinmNdlb773e/m\n8tixY0Pb22+/nctHHHFEaLvjjjtCvW/fvrnsOSM0R0FKMS76gAEDQtv1118f6pqXQHMr+vGlFPM2\nerx1fe348eND25prrhnq48aNy+V+/folAOhKPBeF5yzYY489av6t52PSdawqV5PmsajKNXbiiSfm\nclXOyVaiOZY8x/Hs2bNz2fdOXtf8Ab4Gb7zxxqH+5z//OZc9j5DnDSzl1/Q8jbqHK/Wxr+Wab9CP\n13MVdXWXXnppqH/84x/PZc/35Pnw9Bz6+fW+0JyOvq/RsZhSzB3kOT01L2dKKa233nq57PmINN+F\n5yH71Kc+Fep6DfzgBz8Ibc2YE+5b3/pWLvv87DmgtO88/8jKUpUnU3OC+R5acwtprpSU2uYU7Or8\nPJWUrluf2/Uey3Mt+hjUex2/D9U1IqXYb35PrfN+SildffXVuez56y+55JKabWifbbbZJpd9vvYx\nr/ke/bmEv1avSV8j/HOGDBmSy+RwjNr7zObkk08uvo+u2z63+/y4dOnSXPacYKNHjw51zaGoz1FS\narvnf+ONN3LZcwHq3tD3GN27dw/1a6+9drmf3+p0j+rn3tdonb/9+eOMGTNCXfe3nhPO93S6p/L1\nxPNy412an/zf/u3fQpvnLdZ51vvU82nqfdH5558f2rbbbrtQ1zH2s5/9LLR9+tOfDvWDDjool339\n1vlKcwCm1HZtb2V+z+LuuuuuXPZ7Ic+TqXOpr8s+tvX+zF+ruf9Sirm4W/n5R0fRvZev7aXnFpqP\nOaW215Lem3m+R/8cvR/25yydFb9wBAAAAAAAAAAAANAwvnAEAAAAAAAAAAAA0DC+cAQAAAAAAAAA\nAADQsC6Xw1HzC3hOi1KOi6o4xv3798/lb3zjG6HNc9RsuummuaxxdFOKOS5mzZoV2jwmr8e772q+\n+tWvhrrmzXn88cdD2yc/+clc1hyNKaW0ww47hPqWW25Z8zM9/8h9992Xy88//3xo81jn+reed8r7\nQtt333330OZx0pXnPNFj8hwKTz75ZM33AYDOwPP2eA4/XQ8POeSQ0Pa73/0u1OvJP1zK26i5M1KK\nud88L6AeX6v50pe+lMue/0d57mFXylvhe6BSrsXSa71N8xmkFHNaaN6glGL+Ec9J5deR5s7+4Q9/\nmLo6PReeb1pzOnn+CM/PpefJz6HnpdDXel9ovrCU4rXjfaz9llLcQ/r1Wso96K/dc889c/miiy4K\nbc2Y02TffffN5dtuuy203XTTTaHu+V86QlWeTL030pyNKcVrotlyNjo/T3qP6HOntn3/+98Pbeuu\nu26o67ifOHFiaPP+18/xddXziWm+Rf0Mb0sppXnz5tU8Pr3H9vxDF1xwQc3jq8oN2ko0N6fPq55n\nT+drz6vn+yXd3/Xo0SO0+TrQs2fPOo64tega6vvek046KZf9nPq6rO0jRowIbU899VSoa77i0047\nLbQ9++yzoX755Zfn8uc///nQ5s/AdH+ox55SSosWLVru61Jqm/tNn494nsBJkyalVjVgwIBc9vsr\nz/um14PnK/dnlboX8+ePvmdauHBhLteTW7iVeK7FE044IZc1F3JKbXPaap41vV9Nqe0crHt136/6\nmN9+++1z+bHHHgtt/oxx6tSpuexrp+bjveqqq0Kb5yL0/IKtpGrP8dJLL9V8rY9BHcs+H/rfao5V\nvx/3vaL+7TXXXFM8XtRvww03zGUfuz536lj2+VrfJ6V47+OvLT0783ysnRW/cAQAAAAAAAAAAADQ\nML5wBAAAAAAAAAAAANCwrvE7zHbyMFAaZuTYY48Nbbvuumuo68/dNURESikNGzYs1D0MlNJwCL17\n9w5tHjpDQ86ceuqpoe3iiy+u+bf1hKXrSP7z/S9+8Yu57D/71/Or4WtTaht2Y8qUKbnsYXo8LOm0\nadNyuVevXqFtwoQJob7HHnvk8i9/+cvQpuFpUkrpQx/6UC77dXXMMcfksoeD0rAEKcWwJWeccUZo\nO/TQQxMAdGYeMsLDN2h4lVtvvTW0XXnllaF+ww035LKHoPGwIEOHDs3lww47LLR985vfDHUNie3z\nta8vrURDcC1ZsiS0aXgXD99SCmfrr/UQULpX8fAi3jcajtNDiHhYOA9HozSUl4cg8n+LhkhvhpCq\nX/va13LZQ5rp2PXz6edb+8LPYWnP6/tRvx5UVaguvbY8DKOGEfKQqv5avVaOP/740HbFFVcUj6Er\n0jBOTve9KcVQezvvvHOHHZO69NJLQ13THayqY+iMfDz4GqjOO++8XPb7jAcffDDUdaxXhdLTeeDG\nG28MbZ/+9KdDXceOp8bwca/ziYdg0znZ7708BPIpp5yS0Jbuw3yP4+db52hPH+KvLYVe93C8vp63\nMh/LpfOoqQf8nPr+SvvZw456KF3d73nYxpkzZ4b6+uuvn8uvvPJKaPM0N1dffXUu6/OPlGLYzjfe\neCO06XMUrx911FGhzcO4thJNI+RrgD831D2eXyuehkDnaE9H5H2j11Jpr93Kvve974X6nDlzclnT\naaXUNty09o2HZp08eXKo6zjaaqutQpuPeX0GOXLkyNDmz0s1RPprr70W2nQP7fvrM888M9TPOuus\n1Kr8XsjvlTbbbLOary09u/fx6c9Z9HP8fUvp5fx6wYrTUKg+X3uKER1nvtb7a/Ua8JQFfo+rey+/\ndjorfuEIAAAAAAAAAAAAoGF84QgAAAAAAAAAAACgYXzhCAAAAAAAAAAAAKBhTZXDseRf//VfQ32/\n/fYL9RdeeCGXPfef5wBae+21c9ljMutrPbbz9OnTQ11jfnus7a7gySefDPW99947l0844YTQNn78\n+Fz2vIye60DjHO+0006hzeOi77XXXrn8+uuvh7YePXqEusZS9hwF3leag/InP/lJaNP8KZ4Pw2M0\nax6yo48+OgFAVzJ//vxQ99wfGmt+1qxZoU3z+i6v3qiFCxeGusbR9zwmnruwmXlerVKeHt3HeJ4H\nr2tOCM9ZUMqd7TQPX0pt81SozTffPNQ1T4HnrCvluPbj1XzSntewlH+ws/rKV76Sy573QfNKeb4I\n/7fqHshf63mElJ9vzydS4rlI9Prw3LH6b/Pj8c/UPWUr5HB89tlna7Z97nOfC3XN5fWb3/wmtH39\n618Pdc1RVEXnmptvvjm0aZ6vlGL++hLPi1bPtdUV+HWsY8lztuh48PXPx6uu0aUcu/4506ZNC21+\nT6Xjs2qu1M/RayOlOJY9/4znnlPe/81+fZToOfR1zM+pXjuaPzWltuu15+FWrZwPu0ppLLtrr702\nl3v16hXaNAdYSnGs9+7dO7T5+vnd7343l/v37x/afCx/6lOfymXPp67Pa1JK6cILL8xlH8u6v/a9\noL/25ZdfzuV+/folvGudddbJ5QULFoQ2v5/Rfbtfc56XT/dBVft0XUP8M1vZ1ltvnct+L6n3L34+\nS/fNPjf4M1F9Lx/j3jf6OZ6PV6+VlOK15fdQmivS2/z5tM5DvhdpdlV7jNK8X+Jj2Z9Jlz7D90F6\n/cyePbuh40FtOgb9+yF/xqF9o88eUmq79uv49H2w97nO155ztbPiF44AAAAAAAAAAAAAGsYXjgAA\nAAAAAAAAAAAa1lQhVUuhvN5+++1QHzNmTKjrz90POOCA0DZx4sRQ15+2elgZDeN59913h7Yjjzwy\n1O+///5c/sIXvlDz2FMq/7y6s9CfA2uIiJRiqB4Ng5pS25/v6/n1UEF6zlKKoWM8vKmHEzjwwANz\nec899wxt3/ve90Jdw5p89KMfDW0f/OAHl3usKbUNaXDZZZflsl+DANDZaXjplNqG6NOQEh7+ZerU\nqaGuYSLmzp0b2nyu1/ATHsrGwwOV3sdDpDezYcOGhbr2Rylki4cdLYUH8/PrIUT8GlD+OcpDk0ye\nPDnU9XN9r6fH65/v76v/luHDh4e2xx9/vObxdRb7779/qGsYLd8n6r52zTXXDG1e19AvpRCqKcVz\n6P3v57v0Xh6eSOu+t9K9toei8X+Lhpjx9xk1alSo+/zW1XnIax9zb7zxRi537949tN1+++2hrvOJ\nz7mesuC+++7LZQ/t5iFUNcSqhixLKaXnnnsul+sJU9gV+VhRG264Yajr2lkVxknbq8ajtnvoWx8b\npRDYpfDIfl+kn+nH4/dtu+66ay4/8sgjoa3Zr48SHVN+zjwctYavvOqqq0Kbz6UaWu/5558PbZ4y\nxMMGtjJfy/Ta9DF43XXXLbecUkrHHntsqJ933nm57M8Q/Po/55xzctmvCd/raHhTt9tuu4W67tVL\noSI9jKs/Zzv99NNz2cM3t5JNN9001DVEn+/hPFyyXku+tnvIXZ0H/H08lZGGaC49S201I0aMyOVn\nnnkmtOl52mijjUKbX9+6R/X9aikEts/PvpbqvbHPMx6eV8Mq+/voXtBDvHr6rM9+9rO5fPHFF6dW\nUhVS9YEHHsjlqnC4GqLcX+thUkvH4Htz7WdP5YYVp/tg7yffg+o67GliHn300ZqvXbx4cc3PTCnO\n510lrDG/cAQAAAAAAAAAAADQML5wBAAAAAAAAAAAANAwvnAEAAAAAAAAAAAA0LAul8OxKn5yLYce\nemi7X6t591JKadasWaG+33775fL48eNDm+aY2GmnnULbjjvuGOreXqL/bo0Z3Oj56Ghz5swJdY0P\n7jkxPYeL5gR46KGHQpvmYUwppccee6zmMXjs85/+9Ke57LlKNGdjSjEm9j333BPadtlll1zeYYcd\nQtsmm2wS6p7LBtU8JnY917j2zRlnnBHaDj/88FDX/AelvDZAK3vhhRdC3cdGKZ69z8FPP/10Lk+Z\nMiW0eV4LzTkzaNCg0OY5ijS/m8fQ7wp5+VaWnj17hrrm0fKcLZqDzc+n55PQv/Ucjj4/6/Xg71vK\nAeZzsH9O6fj0b/19/LrS911//fVrfkZnddxxx4W65tXS/HwpxX2M5wbyvtBxXcofklI5x08pZ6O/\nb+l9/LrSa8lziXneQn1fzzV42GGHhXqz5XD0udLzqQ8cODCXfS7X3JcppXTvvffmsuco8tcuWrQo\nl0u5WlOKc7TnC9Mcjp31/mZlKf37tt9++1DXceXr6rPPPhvqmu9Ryym1nZOV5/nyPte509/XaR/7\nZ+q/2+/FfJ7adtttc9lzOLZSzkb30ksv5bLPf35dac64X/ziF6HNc4VqzjKfr31N9hyPrax0z1jP\nPe0111wT6jfffHMua86vlFKaPXt2qOu6OHjw4ND24IMPhrrmSPd8j/7MS68RP3bNG+if6e+Dd22x\nxRahruPKryPvc72WfH72uVTz+/ley+dZfV+/V2glvi/eeeedc/n+++8PbTreRo4cGdr8HkVzZG6z\nzTahzXP76f7J97o6blOKY9dzOfuzVc0V6bn99Nmq53f155r6LLvVcjjW82xQ5+6UUjrkkENCXa8R\nv16cjs9SnsCU2ub/w8qle3HvC68PGDAgl30ffPbZZ4f6z3/+81zWPJwptZ2XtM91L9iZ8QtHAAAA\nAAAAAAAAAA3jC0cAAAAAAAAAAAAADeMLRwAAAAAAAAAAAAAN63I5HFeFU045pdiusc81N2FKMd/E\nD3/4w9C2zz771HxPzbXjn5FSSh/84AdzuSo/SmfguS333XffXPbcL56XQ/NNPProo6HN815q7HPP\nF+AxsY8++uhc9tjmHt++f//+uez/Fs2J47kq77rrrlTLiuQmbCXebz4WlMe3v/LKK3PZ8xCcdNJJ\noX7JJZfkcj1x2Uv9SC5INBvPE+N57zRPiI/HSZMm1Xwvz63nY0f/dtmyZaFt9OjRoa5rosfJb6U8\nup6PqTQ36Z7Cc0D5vKW5vTQPSEpt52vNR1O1V9HP8c/0NVn/LaXcXX4Nzp8/v+bx+f6tK/A8IKee\nemouf+ELXwhtmuPH+8Jz+2muIN+P+vnWvvK8MaX8j6XcmynFPBWalzWleD1o3qiU2l6/ui8755xz\nQpvn5G42fk17DkvNDeL9qnN5SnGO8Dwhvi/Ta6YqB2gpD5Vq5f2T5tpMKeaAGjZsWGjz8arjSvsw\npbbroeeDVN7HOtZ97Pp8rfOwzz3ar97/L774YqhrTkG8R+9vvI/XXXfdUNe53seU78P0bz2np19n\npRy8eE/pXt/XRJ+T33777Vz2e1ofn9rPDz/8cGgbNWpUqGtudh/Lvmbo5/j+WvdTVTkb9bW+b2gl\nmtcrpfhMzPc9vp/VtbNv376h7cQTTwz1Cy64IJd9rPoarc/SWjmH40EHHRTqmhdzhx12CG261/Jx\n6+ua5kX09dDHlI4Nn9t9zOu+3e/N/N5H9xD6nDWllHr27JnLG2+8cWjza/KZZ57JZX22m1JKY8eO\nTa2k9DzQz389eX5L91w+X7v77ruvXZ/DM+jG6Bj0vvD9lM7ffj088cQToV6VF13pWuo5VzsrfuEI\nAAAAAAAAAAAAoGF84QgAAAAAAAAAAACgYS0TUnVlhrMcOnRoLo8ZMya06c/U586dG9pKP3OuCk3S\nGUMclM7pU089FdpOPvnkXN5iiy1C2zXXXBPqRxxxRC77T4wnTpwY6hrCw8MdeLgJDR300EMPhTY/\nJg1N5yEFtS923HHH0Pb9738/1cLP19unFELVQwX9/ve/r/m3Pt4+8YlPhPpuu+2Wy3/4wx9C27XX\nXlvzGEr92MohwNCcPAyEX/8aQmLx4sWhbcGCBaGu42Pw4MGhbe211w71p59+Opc9nJ+HddUQix5u\n0deMZub7CK176A8Nj+Z/52FBlIbySKnt9aDro8+HGjIzpbiH8LCYHnJLP6f02qowcBp2zMOKdkUX\nX3zxcsspxfVx++23L76PnlMPzeR9oetsVWg07eOqUEB67fg1qf3q1+DVV18d6meeeWbxc5qZjw0f\ny9ofvof38H4a+sv7zsdO6R7Fx6CO5U022aTm37UavWfxex8Nm+R7ZO9jDZ3mc+6iRYtCXUO/vfHG\nG6HNP6fUxxr6MaUYSkrDvvkx+fXqc8+gQYNqfmYr03nXx62vuzr+fE/m66XOrb62+1zvofbQPqU5\nuL1/l1IMg5lSDJfsaWN83G+22Wa57M+q/D5b9/V9+vQJbTrXVCmFwm8l/mxKz6Gvsz53auhLfzZ1\nyy23hPrNN9+cyxoGM6W2Y1nvv1555ZWax97s/LmR3v/uvvvuoU2fBfuedPLkyaGu4eo9rPmrr74a\n6rrO+vXgYe/1b3299jGv7+vzvh6Tz+t/+tOfah6DP+ttNd4/Osf5Xqb0fNCvn1JaNR+7fq80bty4\nmp9DSNUVpyGw60kT4uPc6fXhoZT9c7Td0xB0VvzCEQAAAAAAAAAAAEDD+MIRAAAAAAAAAAAAQMP4\nwhEAAAAAAAAAAABAw1omh2NVrGKNj+tx5j3HiMZU97jot956ay5fcskldR/n/znqqKNC/fzzz8/l\nww47LJefe+65hj+jI3m84X333TeXPV/elltuGerXX399LpfilaeU0vDhw3PZ+0nj16cU45d7Thnv\n8zPOOCOX99prr9CmuVUGDhwY2koxuv2crM58BnospWNuNMa355ooxTl3Hsv81FNPzeUf/OAHoW3k\nyJGhXsrX9sUvfrHm35500kmh7VOf+lQua7zulFKaMWNGqF922WW57LkZpkyZUvN4miGW+gEHHBDq\nnm9H83107969+F567jyXkOeq0PZ77rkntK2OnAIrM0dwZ+c5HTVG/bx580LbX//611DXvDJ+PXgO\nKM3J6+usrwOac1fzjqVUzgnbbPy6K+U9nDNnTi77euj5AzQXhc/dfu1rP3puMT8+fS9fH73fNOeI\nryd6fJ5H1HODar6LqtzZXd3BBx+cywMGDAht999/f6hrDhfvU98jaL96jjh/rfZVKY9oSjHvm/eN\n5m3V8Y5o0qRJoe75XEaNGpXLvpfxvttqq61y2a8Jn9u1v3z+8DVD93ieS6iV6TXu51DHjp97f62e\nX88X5edb37c0dp23+bpb6mO9h54+fXpo83VAr51NN900tOka1mr0HFbtN3W+9n2W32PrfO7Xg8/J\nfm+E+tVzr+C5zF0pb2ppL+b5Yj1HmK633uf6mZ430p9PNfN9UT30nKUU53M/Rz7mNPfmCSec0O7P\n9LFcWl8891wr8X/7448/vtxySjG34bJly0LbPvvsE+rar96nfq+jORR9rfe67ss896Lfq+nneH7H\nr3/967l87733hrZS7mbU5vOfP/O46667cnm33XYLbb4P0hze/pxF7/NSKj8HZQ5ecfr8sSrXouZD\nfvrpp4vvq2Pbn4OXPP/88+1+7erELxwBAAAAAAAAAAAANIwvHAEAAAAAAAAAAAA0jC8cAQAAAAAA\nAAAAADSs0+VwXF25sEo5HHv06BHqX/7yl3N5o402qvmeF154Yah7frNrrrkmlz33WynPhua98fPV\nWXg+j/vuuy+XPaeI5stLKaXbbrstlz3Hj+djGjFiRC7feeedoc1zOi5cuDCXPc7ysGHDQv24447L\n5X79+oU2zY0wefLk0Ob/NrU6czaqNdZYo2belqrxVrre9G9LubpcKa55SjHeff/+/UNbVU4LdeWV\nV4a6xsj2+On7779/Lvu1MXjw4FDfc889c1lz8KTUNufkLbfcksvaB6v72ijNuyeeeGJoO+KII3JZ\nczSmlNKDDz4Y6nrOPbeUxz7XfBQXXXRRaPOY9A8//HAun3766aHNcxwce+yxqRErMrc2Q37OWjzf\nhP77PC+E5+fVsf7EE0+ENj/f22yzTS77GJw6dWqoa86ZUk7aZufrmvIcPjp39urVK7R5fi7N6+Sf\n4bkGNFek5wLyul5LVbncdI5ca621Qpted57D0ecovc6a7VrxfIp6fj3fme+PNHeN50h85ZVXQl3P\noX+m56fRa8mvQb8e1llnnZpt3uclpbx0rWaPPfYIdR0fvvfyc6znTvM5ptQ2j4zm4vNry/MbaU4g\ncji+R/Nz+Rysufc8V5PTce/rail/fa9KKbcAACAASURBVFVO23py1C9dujSXfV+sbb6f8PzMuuf3\ndaqVcziWcu5q3qCU4njzHHx+vnU8et5n7yvPB4n20T1z1X3GFltskcu+Lvv9rz4f8Tb/W52Tq/Zp\nWi/l8Tz00ENDm+cw66zPq1Y13ec4f3bmY1nH/R133FH8HJ1nnfej5pVs5XHt627pudYjjzySy35t\nX3DBBaGu48+fY22wwQahrjnifA7u3bt3zb/1/JNDhgyp+b6el/Hyyy9P7dXMzzfqVXp299GPfjTU\nfe3VvIyeS9mfdc+aNSuX586dWzwm3W/5a1u9v1YGXTv9/tfpfDJu3Ljia/X68PnE995a7yq5tPmF\nIwAAAAAAAAAAAICG8YUjAAAAAAAAAAAAgIatspCqXTnEUc+ePUP9V7/6VS57mMDhw4fnsoeM8zBD\nGvrPwwB6aE4Nzfjoo4/mclf5ebSGT9x8881Dm4fQ1PBdHt7ggAMOCPUXX3wxl/0n6KNGjQp1PafP\nP/98aPOwMvrzdb9eNbyIhijoKt55550QTsPPcdXftoePmf/4j/8Idb0ePOyij5uvfvWrNT9nRUIw\naz9qyN+U4nV18803hza/XjVkwT777BPa/Hq9++67c1lD865uft40bKyGl02pbYi2RnnYnh/96EfL\nLaeU0lFHHRXqZ511Vi5PmDAhtG299dahfsUVV+TySSed1O7j6ypz66rmIV40nIOH5PNw1A888EAu\neyg9D7H79NNP5/Luu+8e2jTMVEpxLPn74F1+XkohNL2Pde30ECIemkfXS5+fPfyqvrZqX6gh+/w6\n01BvVeEG/d/WTDzkXanN503dP3lYL+9HrVeFSSuFHPI1wK8l1ZnWy87Mz7eHFNYwTh5e09c83Sf6\nvsfn5AEDBuSyh0D3EHJ6zfhc3so0pKrfW2g4Yg9R6uFMX3/99eX+XUrlse39X7o38Pm6KrSU0mPy\nMKl67+Wf4yHinnzyyXZ/ZjPzedRp33joNl+TdU7w66EUohGNqbrP0HnV+djW50g6l6SU0oIFC0Jd\n0wH58ya/f1ceHluvHw8V6VZ36pDOwtddnZO9zfdX/qyqRMe6v4+vAz4PtKrSfUgpZYE/3/W1acaM\nGbnsY8if/2r6Jw+36nupKVOm5HLV80i9N6onlP3qSnXW1Z1yyimh7muvpieqeg6700475fLIkSND\nm98b6edqejCsHDp3er/5XlzHyv333198Xx33vsf3z9GxXJUKobPgF44AAAAAAAAAAAAAGsYXjgAA\nAAAAAAAAAAAaxheOAAAAAAAAAAAAABq2ynI4lmI+a2zaUozslDou/2MptrzHvn/kkUeWW04ppZNP\nPjmXq2J6T5s2reZrPRa+5ljqLPGz6zmO3/72t7nco0eP0Ob5mDT/iOd3ueqqq0L9pZdeymXPZzBm\nzJhQP//883N50KBBoe2HP/xhqPft2zeX58yZE9qGDRuWy54vrqQzxUHXYynl3KrnGI899thcPvzw\nw0Ob52mZPXt2Lnucc83dVqWe4/MY2KW5RHMxem6D3//+96H+7LPP5vI111wT2g488MBQryfPzYp6\n3/vel9Zbb71c79atWy77vKrjKKWUvv/97+fy9ddfX/MzPC+c5xfQ2OL+b/dY5/pazS+XUkrXXXdd\nzbrnbvWcn5rv0WPoa5vnLfF8YqXcgH5taf3tt9/O5ar8cl2Bn+/Fixfnss/Xmgs1pTiW/Hz6WNbP\n8VzJQ4cODXXNYVSVU65VeW6YemjfeO4P3zvpuPY51us6P3keCp8fdOyU8od5mx+fjut68hd3BfWs\n3zovpRRzxegeLKW250nftyrvWym/mK+t2ldVueewfOuuu26oa070lGIeNs/v6H2lc7Dfv/h90cCB\nA3N5xx13LB6D9q3vPVqZjgfvi4033jiXu3fvHtp8jivl46rK96fqmR997tF52I9X52C/933mmWdC\nXfeq2223XWj75S9/2e7ja2Y+N/oaqHtr39dq3qCUYj/6GuxrBlZc1T3s6NGjc9lzvfmeSXOm+7yq\nORtTin3pObw9p6NeB368ui/zz0D76Jjzsez31DNnzmz3++qzK88J5v2o86ze0+E9pRzpnlvT99A6\n3jyHo/e5jmvvN8+jq3kbfX7wY9D2evYBeE/Vc8Rdd901l32t9XP+oQ99qOb7lO5x/Rj8+vn85z+f\ny+RwXPlK3xf58xHtx6oxp/dJ/jzS+9yfZXYFzfW0BQAAAAAAAAAAAMAqxReOAAAAAAAAAAAAABrG\nF44AAAAAAAAAAAAAGrbKEopp/FmPRav5BVZXXOlSTN7Pfe5zoa45wiZOnBjaNA/OmWeeGdo0B0dK\nKY0dOzaXDzjggNDm8cCvuOKKmsfXFey11165vOmmm4Y2zWWZUkpvvfVWLj/11FOhTfPEpJTSMccc\nk8uez8Pzhvzud7/L5f322y+0eR5Jzc04Y8aM0DZ37txc9lxzJZ0l92ZK8VjqyXn24x//OJe9L/Qc\net4Bz4PpOR5LNHZ5KYZ+SvHfsiL5KPXfptdjSm3zVGgOR3fbbbe1+zM7Qq24757PbcCAAaH+xS9+\nMZf9PA4ePDiXPceL94/+bVXfKc/56ceruQg838jll18e6pdccknNz9H8Qf5v8VxYyl/ra5rG5tfr\n5+WXX675nl2F53DUa0zzSaTUNs685m30/AZ+TrXu16DnBNMcNP5arXemOXhV8/Pi+X+U5wDT8VY1\njnU/5+PWc0BpXlnn14Pu0Ty/hb62KhekfuaK5LXsjOq5vr0f9Tz5PtznN/1b74vSfsI/0/O4au4g\nvzY8P01JK4/zrbbaKtR9/1K63/JzXMoJdvvtt4e63hf53tBz3esxed7fVqb5X3ysaN5Ln+Pmz58f\n6nr+fc/hc7vm/6nKMV7KI+R0vvZ/i96bVeUL07/1e2i8y3M4ed+U5mTfh2kf+7VS2jOgY4wYMSKX\nvT/8HkX33z4Hez51zd/r+XhLOWL9WtPrZfjw4W3/AWjD90y6D/U52MeyP0sp0dd6TjCn/bpo0aJ2\nfwbe5XOsPwPTsVvKd5xSObef7+f0uVvVXlyvrfXWWy+hfn6O3Te/+c12v5fubfw7CO87HZ/e5vt2\nbff8vIztlcufL+jYTants6qS6dOn5/I222wT2nwd8DywXQG/cAQAAAAAAAAAAADQML5wBAAAAAAA\nAAAAANCwlRZStSoso/5cuBS+dPfddw/1hx56qOZr/SemVT91bq+zzz471E8++eRQ1xAwGqYzpZSG\nDh2ay2PGjAltQ4YMCfWdd945lz2k6qWXXhrqHkqjq9E+f+aZZ0Kb/9s0RID/PHmPPfYIdQ09+53v\nfCe0ebhTDQHlbRo6KqWUJk2alMse3lHDEnhIsBUJ47m61HOMGgbYw+Ptueeeufz666+HNg9dd+ih\nh+byb3/72+Jn1hOKU/8t9fy7Nt9885rv433q4Wc6q3/+859p4cKFuV4KleRzZ+ka139/VUjCUtit\nUv/4+2oYOH9fD4dcCuvq/xYNh+DrkodK0Pfx1/pn6r9NwxyV1r7OysPtOl0PPbythohLKaW//OUv\nuez9X+o3Xwd8/tbrw9dZDUlVCn/cjPQceqgmDaXmY8hDLer84KGZtE/9b33u9PGn14sfn88Begwe\n1ks/09t8rtPXdsXxWFLP/sPPr543D9Hj4690XflaonO1X1ceNlX3FH58Hp65pCvsuzqKhjxPqe2Y\n07Hu66qHX9K+O/roo0Obh+Tq3bt3Lk+YMCG0jR8/PtRPPPHEXG62MVgPv8Z1vdS9W0opDRs2LJd9\nnPt6qGH/PS2FhpFPKY7X0lzpfNz7mNO67wP1c3zP4P82PQYPU4d3+dzo59vX9/bSML4ptZ1L8B4/\n5+2996ma//Te1FMW+F6nR48eufz000+HNg+1PXPmzOV+RkptQzRrGgXfG5TWd79e9Hg76vldV+B9\nruPM5+Cq0NUls2fPzuXtttuu+Fq9H/CwnXhXKc2DhzfWZ8EpxX7UlE0ptQ1VrWuir3l+/6VpvHwd\n8L2ghtjVuQIrzyc+8Ylc9nDxvkfSOa/qO5RSu7+v7iM9fdi1115b/BxU03CmPnZ9z+TPyUt03FeF\nxfe9QFfALxwBAAAAAAAAAAAANIwvHAEAAAAAAAAAAAA0jC8cAQAAAAAAAAAAADSs7hyOGkdWY8yW\nYhP7333ta18Lbbvssksu77333qFtypQpob7TTjvV/IwVcd555+XyaaedFtqefPLJUNfP3XjjjUOb\nxvP195k8eXKoa14cjZGfUvPlmtK49J6rS2PHpxRjHu+4446h7aWXXgr12267LZcHDhwY2h5++OFQ\nf+6553L5Ix/5SGjzeMia09HzDL3yyiu5XJWzTP8tnTW/Yylfn+fp+eMf/5jL66+/fmgbPXp0Lvv5\n9Ov7hBNOyOUXXnghtHleIeU5Ivy1evz+mZ4bQfvV85BprgnPeeM54jQXhsfX9+tD5w7PhdHRdNzV\nkxfTY5Sjtey1116h7nkipk+fnsueA8xzzOic5zmgnF6jPu49p5yOwUGDBoW2o446KpebbV11pTWl\nlMPRz6efb10HfN7y12peMu9/z2eg66Wvjz6369zp65TmUvH8wZ53Rd+3nnmwK/C8D6X8UN27dw/1\nUv5E7xutV+1j9LW+Z/fP0eP3Y9dcNajN8/Z43+m+zc//ZpttFuratyNHjgxtpTzQnsfkN7/5Tahv\nu+22uaw5b1KK+Qe7Sr7sRvn+Wudhnys1l5PmkFne+2hOR5/bfdzr/s7vX3z+Vj7X+Ofo9eBtet15\nm+YdSynO0b6n76z3VKuar5V+TuvJk6rv5Wun1/EeX9tW1vOpbbbZJpd9PvTP0PvY4cOHh7ZJkyaF\n+g477JDLEydODG29evUKdb0mfI7QMedrtOZPTyk+S6vKWdbMfI+qa7Lnz/QxV3XfpDQXo18rvofW\n+bzZ9sUrS2lM+3o4a9asUH/++edz2fddnjNz3rx5uex7Mh83+lzZn7v5HkLrnvcZjfH9tu6n/Nm2\nj92Vlb/crwkdv0ceeWRoI4fjipsxY0Yu9+nTJ7T587F68l7r/rZ0z51S23uAroBfOAIAAAAAAAAA\nAABoGF84AgAAAAAAAAAAAGgYXzgCAAAAAAAAAAAAaFjdORw1Xns98Yf/8Ic/5PLOO+8c2hYtWpTL\nc+fODW0aZz6llA4//PBcvuWWW0Kbx8Uu5YI799xzQ/3rX/96LnvOsldffTXUb7rppuX+XUoxv5/n\novj5z38e6tddd10ujx07NrR5To7FixenrmzUqFG5fM0114Q2z0vQv3//XN53331Dm//tJz/5yVy+\n/PLLQ5vnIVhrrbVyeerUqcVj0Bj7ffv2DW2aJ8FzQepnpNQ2hnpn8P73vz/kGvzoRz+ay56Py3Oi\naDxqjwF/ySWX5LKPi6VLl4a6xsL/7Gc/G9qeeOKJUNcY2Z77wHMN1Moxm1I5z6z/uzXevo73lNqO\nzeOOO26575lS2/7XHBc6V9x1110J6Ix0zU2p7bjXnKaeY9dzCSkfnx6jXseSj13PVaF5Vv21ukb4\nvNRs/Jxq/hffH+nc6Xs5n1e1LzyvV6nfnF8PmtPC52DPXaPtngtD51n/t/j14PlSWoXnV/V1TNej\nevIEVaknr5rmMvK13q/fknpyTDY7H1c6f2+66aahzce9jhW9PlJqe141N6Dvi7feeutQ1/s8z3Gi\n9wp33HFHamaeD03nTu8LHa9+n+z5NDV/lOdadzp3eo7EkqocbLoW+Zyr93ie58j/LXof7/OS56P0\nOaNV+Jrna2c9+eL1umv1uXNF6HXsc3BJKVexP7cYOnRoqOv8MX78+NC29957h/qjjz6aywMGDAht\n/gxM1wzda6fU9vmY2n333UNdcziurByXXdEjjzwS6sccc0wu+9j1MejPmEp0LPt87fcKmitwZeWW\na2X6nDCluAb6+PL5We9vu3XrFtp8jdax6Wup53nT13ofl/bM5Equ7eijjw71eu5TlI9HV5ovvU3v\n0bfffvuGjge16XdW3t+lcVVF79H9fXzv2xVzsPILRwAAAAAAAAAAAAAN4wtHAAAAAAAAAAAAAA2r\nK27SGmusEcLfbLzxxrnsIRM9BOj8+fNz2X8+Xgr75WFJzz777Fz2kKqlEKpXXHFFqJ9wwgmhPnny\n5Fz28D/bbrttqP/oRz/K5RkzZoQ2/Uns9OnTQ9uFF14Y6gMHDszlb3/726HNQ+2ozhIuqvQzew+L\no20e6sPD4rz88su57P3mIdnWWWedXB4xYkRoGzNmTKj37t07lz3Ez0YbbRTqEydOzGW/lnfcccfl\nvmdKXSMUxT/+8Y/wk3A9T96npfAe/m/Vn/Hvv//+oc1/Dq7jXPswpbbhAXTO8TBTHqpGj8mPz99X\n5yFv0/AiU6ZMCW1+vWooBD9/Pp9piAv9SXxp7gJWp1133TXUH3/88VDX8TBy5MjQ9vTTT4e6hgPy\nECI+XnXseGhiDQmdUgwNOG/evOLxNzOfH0vzofL12udD7Stfgz10kM71Ph/65+hrPRzQmmuuGeq6\nvvi+R68PX7OcHoMfTzPzfa3TtdTDXJauB1faQ/g16KGlNJycj2PdL/vn+/HpZ/qYaHY+B3/rW98K\n9bvvvjuXNXR8Sm3PuY5PD+3ldT3nDzzwQGi7/vrrQ133Pj63H3LIIbnc7CFV11133VDXa9X3zLp2\n+r7X50p9H++nJUuW1DweH1c+D+gx+Vj2z9FrycNE6lzv91Cl9cXvi3v06BHqrRpS1Xm/1RPSU/vG\nw6dzn1LbOeecE+qnnXZaLvvzMX125nsZH1c6XocNGxba/G91fG655ZahTUOoppTS6NGjc/mFF14I\nbb4v0v21P/PSlDO+Dh9wwAGhftFFF9U89lbiz6Z0H+QhM33O82dVJTqW/TmLP9fSse7zqu/x0Zb3\nk69run57H+rzuJRiGiFPfeD7Ag1x7OufzwF6nfneQ++361kvWt0ee+wR6rpGVt2L6n6rKgVUSSmd\nnF+HWHG6zs2ZMye0eZ9XpTRQ+iyttLan1HbO6Ar4hSMAAAAAAAAAAACAhvGFIwAAAAAAAAAAAICG\n8YUjAAAAAAAAAAAAgIbVlcOxT58+6ctf/nKuH3/88bm8YMGC8FrNZZhSzOfgsWk194PGuU4ppZ//\n/OehfsYZZ+Sy54o55phjQv0Xv/hF239EjeOdO3duLv/sZz8LbTvssEOoDx06NJe322670KYxszXX\nX0ptc1zoZ5566qmh7aabbqp57F0hP43HgNd8lpqLJ6W25+VPf/pTLu+7776hbezYsaGusdD322+/\n0Oa5EDQv3yuvvBLa/vCHP4S65sDYZZddQtuzzz6by8OHDw9tmusgpc6bU0RjUK/uWNClnDKry7Rp\n01b3IQCrjc7Jnh/K89++9tpruTxkyJDQ5jlndFx53gHP3aT5Jnw/4Z/z1FNP5XIpv5yu3Sm1zWHW\n1Xn+AD0XnpdD9w5VuZm03V9byv/oa7Afg+4FPUeB/61eH37t6L7R88348XaFPMuNKuX98FzkpbyH\npfzc3u7jzet6/kt5n1OK+S78tVrfeeedQ9sjjzyS8C6fc/2eqrT383wj2peeo8jHlV4Tvi/23JA6\nD/j7ei7XZqb5l1KK/3ZfD3VN9nOk+chTin3s92Kl8+tzuY9B7auq9VvvoXxu17XHrznfb+h87nOL\n5rpKqW1+uVbhe7J+/fqFus/1JTquPZ+c59zFe3xPqnwcLVy4sOZrfQ+nfef7J8/Vqeupj88RI0aE\n+sMPP5zLo0aNCm2+h9J98vbbbx/a9HmI5qZMKaXBgwcntOX7Hr2H8r2Xj916ctLr8yffw3kOP83p\n6PMJqvn65+tu//79l1tOqW2f61rva5znQ9b8q77O+tqq49qfHVflG8TybbXVVqGu66eP3dKzCdfK\nOW47O71v8rnc72f0e54q+pzL+9+vnZdeeqnd79tZ8AtHAAAAAAAAAAAAAA3jC0cAAAAAAAAAAAAA\nDasrpOr8+fPTN7/5zVzv2bNnLvtPxD0kg4Zs8J8ZP/PMM7nsP08+7bTTQl3DuK6zzjqh7dVXXw31\ngw8+OJd79+4d2pYuXVrzGDwcyemnnx7qGrrVQw+8+eabuew/eT3rrLNC/fDDD8/lF198MbTdeOON\nqZbO8lNr/4mvhg3xcLKzZ8/OZQ2vmlLbkLUHHXRQLns4Ab3mUkppvfXWy+WTTz45tI0cOTLUNfzI\noEGDQptfS3o9P/nkk6FNrzMPjeJhTACgqxk9enTNNg8do/P+1KlTQ5vPsxqOadKkSaFN186U4jrs\nYbifeOKJUG/vmujv02whVX1vpaF6PFyert++H/JQPHp+/TP83GtoHt8jlELAl/YTKcVQNaWwqd7m\n16uGJeusIekbVQqd52PRQ8HotVJPCD7n4aFKbaWwqb4n09DrAwYMCG0eUrWz7JFXBw97OG7cuFC/\n7LLLcrlv376h7Y033gh1Dano4bo8XYDuxT0Uo197M2fOzOVSqOdm5/c3Ond5aFE9p34/O2fOnJrv\n63369ttvh7qOMx+f3jd6f+NzhNf1c+bPnx/adE72cLsekkrTX/gaoSk1WpmPGe8Ln+tLtM/9ftZD\neOI9Hk5U5+HSmljVN7qf8rCHpbCIHmZZ59yUUvrIRz6Sy+PHjw9tHoZbw3g+9thjoU3TyPjey69D\nndP8+FqZPmPaY489Qpun/9E+9zC5EydODHW9BqtSFmid8Jr182vd1zwN9+3rt4ZFTSmOI+9/v4fV\n9/Vn4KW1tLS/8LFZmr9ane57U4r7Yh9zpfuqUtoKVxWatXT/o2E7V3c6ra5K58pevXqFNl8D9Rrw\nZxGe3kDDXJdSnqTUedO1lfALR/x/9u473qrqzv//MtWOFBFFiqJUBazYlSiWMXaMLcaSRBKNExNN\nm0Qzk2g0xuhoZizxYezBFmt82GJsWFFsIIgICigCIhaMMTPz5feHj9/K+/O+nHUK9+K9576ef631\nWOfus9l7r7L35nw+AAAAAAAAAAAAQMN44QgAAAAAAAAAAACgYbxwBAAAAAAAAAAAANCwunI4Oo0X\n7bGKL7zwwlDXHB577LFHaLv66qtz2XNGeL6/7bffPpf33Xff0OY5X2bOnJnLms8xpZTWXnvtUD/s\nsMNyWXMILovmy9DcQSmltMEGG+TytGnTQts999wT6hrP13OpeJ4NtTz5dVqTx4BXnmNH/z2ea9Hz\ndp533nkVv8NjU48fPz6Xd99999Dm+Q00nrnHV/dY50OGDMnlgQMHhrbu3bvnsue60mvOdea8QgA6\nji233LJim4+Hmsd27ty5oc1zU2jOpc033zy0eR7BNddcM5c9R5vHyde53+cTpeN6SindeuutFT/b\nEfkco8fU8/LoOsLzO/pndTuex8k/q+emnnxs/lnPiaRztp9/Xc/5mqyUC9I/28w8X5yvI0t5QUq5\nQevJ71Ith6Pms/I8gJrvQtdgy9Je1sgrivZJP8ae82fTTTfN5Q8++CC0+X2c3qN4PjfPKaI5gbxf\nlda+vvbWNX2z8/sHHQP1XjKleG/sY/AWW2wR6nrefGz386Z90PujXw+6Lc9d4/1Vry2/39ZrcuHC\nhaHN+65eH++//35o8/vmzqraWO7PVUr0s37teA4i/JPmGE4prqFLubK8P5bmrmp5nbT/+njta1/N\nG6h5vVJqOb7oZzW3ekpxzPI1vH9W+6vfG3RmN998cy6PGTMmtPkYrPUvfelLoc1zOOo1WW2tq/2+\n9GwPy+brLp/XtG+8/fbboc1zuek85+sjH0t0W57Xzeu6XR9L/DpDY/S4+jVR7f5H+fhdUs+zZX0X\nQw7H5ed9zN9D6VrM+7L3+3rWV/rcraPgF44AAAAAAAAAAAAAGsYLRwAAAAAAAAAAAAAN44UjAAAA\nAAAAAAAAgIYtV9DmO+64I5cff/zx0OYxhW+88cZcfuaZZ0Kb5lzq379/aPM8PhdddFEu33bbbaHt\n0EMPDXXNAaW5o1JqmYdK89v4vntOR/1333nnnaFNc1OccsopoW277bZLlXhOQc+tojpCLkCPUa65\nBjw/wJIlS0Jd41rPnj07tHmM48MPPzyXb7rpptA2evToivv0wgsvhDbPCfTuu+/msl8rTz/9dC77\ndeW5VO66664EAB2J5nvxPAOeN0Y/62P7nDlzQv3111/PZc3XllJKPXr0CPUnn3yy4v75Z0eOHJnL\nPj/q/nterGbjOSI0f0Apr5PnjPZjqPk9PPeHz996DVS7dnS7ns/A805pPin/t2i+C8+TUMpf5fvT\nzLp06RLqpfzY1XJFabtvR3P5pZTSRx99lMulc5pSXKN5fjvdP/8O1xHWyK1pk002yWU/H7/85S9D\nXXOuel4nzxuj2/LcJD5m6JrZLViwINR1nNL7tJRSOuCAA3L5ueeeC20+RjQbzYe21lprhbYpU6bk\nst8fei4vPTc+J3uupkmTJuWy56Hr169fqHfr1i2XPe+btqUU87X5mKzbffbZZ0Pbo48+Guo6Z/u4\n5PlJOyuf931crSfPro7RPh7Uk1eqs9lnn31CXfuVrk9TSmnevHm57M80fG2jc5mP1/63Oi96bimf\nE/W5m8/Lnotxm222yWV/JqPji85DKbW87saOHZvLZ511VsInHnjggVz2PLXel/Vc+TOu8847L9T1\nOvMc6b5OKK3p8Am/nrVPlfIUpxT7lOZ3TSmll19+OdT13lhz7qUU128pxfXTm2++Gdo222yzUNf5\n3ccDnlXWplevXsX2Ug7e0v15tXyPWq92f+N9XQ0YMCCXH3744eJ2UJ0+00qp5VyvayZ/X+Drbe3b\nfg693hFzIPMLRwAAAAAAAAAAAAAN44UjAAAAAAAAAAAAgIbVHVJVfwL8xBNP5PLuu+8ePvfnP/85\n1L/2ta/l8ksvvRTaNt1005q//8c//nHFNg11mlJKN9xwQy4PGzYstPXp0yfUf/SjH+Xy2WefXfP+\naNiYlOJP4e+5557Q9o1vfCPUwbFwUQAAIABJREFUd9ttt1zWkK4ppXTLLbeEuobBKf1cur3w0Csa\nHmvixImhbfjw4aGuP/n28/a3v/0t1DUUhYcP8DA++rceisKvV71GPeSPhjHxcBeln9MDQEeg4dw8\n3FIprJ2HYPOwiLNmzcrlhQsXhrbXXnst1DWEn8+PHmZG91FDOKZUDlPXbHz+0X+7h8nSNg/t4SFr\nNYSLh1vyuV7DfnnYXA8Fo/vgocRKYRg9pKbO0b5/us5KKYZ+9PCCHVGtoXY85KWHstRrx7fj50aP\nm3/Wr0FdI3nf9O327Nkzl/08argZD03T2Wk4Lw9/6+vtrbfeOpd9PPSQfauvvvoyyynFc5VSDPnp\nYZZ9ztB7vu9+97sVt+vj/syZM1Mz8TlQUzv42PTggw/m8vnnnx/a/uM//iPUNcyhhwArhXD0fqX3\nYimlNHfu3Ir75+dY5xTv5/rZX//616HN5wwNTeepR/ya7Kx8jVZt/C7R4+/30Bzv2m2++ea57Gsv\nXRd76FNfT+n58PX04sWLQ/3yyy/P5cGDB4c2H9t9n5TP05oaoRReXZ/HpJTShhtuGOp/+ctfKn4n\nPuHXg4/fOrd6CFunIVX9/Pt57Gxh6BtRuvar9S8do0uhNZ0/8/S/1TWEr7s8/LHeb3lYdp93sWw+\npvlx0/Pj58rvjeqZl/Wz1bZT2q6H/sXy0TVxSi3Tquk1UO3Y672yn2Ove/jkjoBfOAIAAAAAAAAA\nAABoGC8cAQAAAAAAAAAAADSMF44AAAAAAAAAAAAAGlZ3AptKOeruu+++UNccEimlNHLkyFw+5phj\nQpvmevB45Z5jpBQfec899wx1jWF/ySWXhLYzzjgjtQaNbV+N56rQHFX//u//XvzbemI9twfjxo0L\ndc0xMmrUqNA2dOjQUH/00UdzedKkSaHN84Ro3hjP+bTtttuG+qmnnprLxx9/fGjz2OwHH3xwLnse\nC/2s5zHx8+R5PAGgvdP8bp7roZTHwvPEad61lFrmP6j0nSnFPIKec9nzWpTySmouOM+P02xK+St9\nrtJz5bm7/FzovOY5pH0dpko5G327vrYs5Yr0PGQDBw7MZc+57LlV9Ds9d2VHVGsOR8+/VTqP1fL5\naK4Jz2Ptx1u3+/7774c2r3fr1q3id+q44+e/s9M8MponN6WWeUP02Pm50vV0SindeOONuez58w4/\n/PBQ13z2vmb260n76Pbbbx/adGz366HZcjj6Pcu+++6by5rPMaWULrvsslz2Ofn73/9+w/ug/XPE\niBGhzfOJnXbaablcyt27PNZZZ51Qv+CCC3LZ8yXNnz+/Vb6zo/Nz4WNyaX3kSuOs5wTDP/m9v65n\nPOe45l/y8dnPlT4D8xxtnjO9vZkwYULFNl83dqYcgqVr5YYbbghtP/jBD0JdcwPqM8SUWq7jNYej\nXzt+/HVsrWe86EwqPf9OqeX6yHM46lz/6quvhraXX3451HVd7NeKr+P1Ps7zuvk9lF4ffj28/fbb\nqZLSv7uz8efVfn60X/nx9+PouZeVP2dRPlb6vb3+ra8VycPcuiZPnhzqe++9d6jruzBf2zq9Xnx8\n/vDDDyt+tqPoWG+xAAAAAAAAAAAAALQrvHAEAAAAAAAAAAAA0DBeOAIAAAAAAAAAAABoWN05HBv1\n3HPP5fJ3v/vdFfW1bW6fffZZId9TivXcHt19992hrjmWPF75sGHDKn7WY8l7zkyNZb377ruHtmee\neSbUv/SlL+Wy50fx3KFPPfVULnucfM1v5THzPbcYAHQ0mhOgZ8+eoc1jy+tnS7lJUoq5vTw/l/+t\n5iHwcdVzFui2PM+TfmdHjHtfD88JpsfQj6/m3PJj5sdbczf5fOhrE52T/fz79+i15OfU81EqP48z\nZsyo+FnPI6q5Cz0vQkdUyqGpPH9EKS+Lnwv/rH6nt3l+EW333H5+/PX6KOUlGzNmTMV9d50hV5Tm\nCNt0001Dm6+ZdV28xx57hLYdd9wx1IcMGZLLnvPH1+al8eSWW24Jdc1z4ut2zVm23nrrhbann346\nNZP+/fuH+vDhw3PZ++DEiRMrbmd58ilqf9D79GXVG/2OenheRr2WPAd0s+dkrpXP7Zo3KKX6jpOe\n11VWWSW0eb/GP5Xm07feeivUjzzyyFw+6qijQlvXrl1DXfM0HnLIIcuziw0rrTG0za8z/ztdK3bm\nvHCl+ySfK0888cRQ12Pqefe+/vWvh/rpp5+ey1tttVVo8+djuk++TvNc251V6f7xtddeC/Unn3wy\n1Pv06ZPLusZJqWWuXL0ePMer5+fVc+XbHTBgQKjrvHDuueeGNl0HVLunqCffe7P5+c9/Hup+rPT8\ndOnSZYXsUz322muvXNac3GjMwoULQ91zZOqcWK1f6f2W52P1ekfELxwBAAAAAAAAAAAANIwXjgAA\nAAAAAAAAAAAatsJCqqJz+elPfxrqW2+9dS57GNLx48eHuoZRmjZtWmjbddddQ13D/b3wwguhTcNM\n+fdqWLWUUlq0aFGoa4gD3+7OO++cy5MnTw5tf/zjHxMAdGTXXnttLnsIzffeey/UNfyLh1fx0EEl\nHq5G/9a343UNY+Jju4amu+eee2ren47olVdeCXUPX640RMdhhx3WZvu0om2zzTah/uyzz4a6hvGc\nO3fuCtmntlRrSKM//OEPoe5h5TX8j4eY1zDyXtewvSm1DA+l++ef9RAzev0uXrw4tH3wwQe5PGnS\npIR/euCBB3J57Nixoe3mm28O9W984xu57OejR48eFeu9e/cObdOnTw91Dbd42223hbYrrrii4t96\nGNepU6fm8k033ZSa2a233hrqG2ywQS77vOv9Qfmc12jIM++P1UKk12p5wq7p/Zdfr7///e8b3m4z\n8WvjnXfeCfV333235m1p+HQPDzZv3rwG9g5O19dabq9K/VfbCLlbm1JoTu+rjz/+eKiPGjUqlz38\n6tlnn11xu9dff32o+3M4/R5CqC6/e++9N9R1LeUpK7x/6Xz+/PPPhzZfh+nY79eOn3N9nuprhtL+\nuFrTODQjDXuZUss1kZ5bTxemIfNTivdc/lzFU84MHjx4mX+XUkp33nlnqE+ZMiWXR4wYEdo6wnzT\nkXg///Of/xzqerw9zLLTVCH+TKYZ1l78whEAAAAAAAAAAABAw3jhCAAAAAAAAAAAAKBhvHAEAAAA\nAAAAAAAA0LCV6szvsDCl9Hrb7Q4a0G/p0qVrt9bGOMftEue4+bXqOU6J89xO0ZebH+e4+XGOOwfO\nc/PjHDc/znHz4x6qc6AvNz/OcfNjvO4c6MvNr6ZzXNcLRwAAAAAAAAAAAABQhFQFAAAAAAAAAAAA\n0DBeOAIAAAAAAAAAAABoGC8cAQAAAAAAAAAAADSMF44AAAAAAAAAAAAAGsYLRwAAAAAAAAAAAAAN\n44UjAAAAAAAAAAAAgIbxwhEAAAAAAAAAAABAw3jhCAAAAAAAAAAAAKBhvHAEAAAAAAAAAAAA0DBe\nOAIAAAAAAAAAAABoGC8cAQAAAAAAAAAAADSMF44AAAAAAAAAAAAAGsYLRwAAAAAAAAAAAAAN44Uj\nAAAAAAAAAAAAgIbxwhEAAAAAAAAAAABAw3jhCAAAAAAAAAAAAKBhvHAEAAAAAAAAAAAA0DBeOAIA\nAAAAAAAAAABoGC8cAQAAAAAAAAAAADSMF44AAAAAAAAAAAAAGsYLRwAAAAAAAAAAAAAN44UjAAAA\nAAAAAAAAgIbxwhEAAAAAAAAAAABAw3jhCAAAAAAAAAAAAKBhvHAEAAAAAAAAAAAA0DBeOAIAAAAA\nAAAAAABoGC8cAQAAAAAAAAAAADSMF44AAAAAAAAAAAAAGsYLRwAAAAAAAAAAAAAN44UjAAAAAAAA\nAAAAgIbxwhEAAAAAAAAAAABAw3jhCAAAAAAAAAAAAKBhvHAEAAAAAAAAAAAA0DBeOAIAAAAAAAAA\nAABoGC8cAQAAAAAAAAAAADSMF44AAAAAAAAAAAAAGsYLRwAAAAAAAAAAAAAN44UjAAAAAAAAAAAA\ngIbxwhEAAAAAAAAAAABAw3jhCAAAAAAAAAAAAKBhvHAEAAAAAAAAAAAA0DBeOAIAAAAAAAAAAABo\nGC8cAQAAAAAAAAAAADSMF44AAAAAAAAAAAAAGsYLRwAAAAAAAAAAAAAN44UjAAAAAAAAAAAAgIbx\nwhEAAAAAAAAAAABAw3jhCAAAAAAAAAAAAKBhvHAEAAAAAAAAAAAA0DBeOAIAAAAAAAAAAABoGC8c\nAQAAAAAAAAAAADSMF44AAAAAAAAAAAAAGva5ej680korLW2rHWkLa621Vi537do1tH3mM/Fd69Kl\n//ynvfbaa6Ht//2//9f6O9eKli5dulJrbaujnePOoqOf4zXWWCPU11xzzVz+8MMPQ5vX/+d//ieX\nV1opHgbttyml9MUvfjGXV1555dCm40FKcQxYvHhxaHv33XfTitaa5zil9teXe/XqFer/+7//G+r/\n+Mc/cvn//u//ip/V68c/63T8/jTOq+vofRnVNfM5HjBgQKj7eK39TcfulFqO3zoG+5rsc5+Ly9M3\n33yz/p1tQ818jt2qq64a6jqW+9ra18uLFi1aZjmlltdOO/T20qVL126tjbX389xZdaa+3Flxjptf\ns99D4RPN3Jd9rTVkyJBQX7JkScW/9fW13hv7s5LPfvazFT87Y8aM2na2DTXzOcYnmnG81j7ofc7v\nabt06ZLL+vzLt+N1307pfUbp/YV/h39W6/6czffX67Y/9OUmV8s5ruuFY0czevToXB47dmxoW2WV\nVUJdO8s3v/nN0PbBBx+0wd4BnceoUaNCfdddd83lp556KrQ9/fTToT5nzpxc9onWH2j36dMnl32h\nvu+++4a6vpC8+eabQ9sdd9yRy/6yq6TaC9HSYqTZHXPMMaH+9ttvh/rcuXNz+f333y9+dsyYMbns\nD7F98fX3v/89l//0pz/VsccA3DnnnBPqTzzxRKjrWuqNN94Ibf6QQx+u+IOWnj17hvqpp55a/84i\nqzY3lQwdOjTUTznllFw+5JBDQtvf/va3UL/iiity+aqrrgptTz75ZM37oNdOtf9k0opeX1FfBAAA\nmltpLTZ48ODQNnHixFB/9NFHl/l3KbX8T9b6H6k//vjj0Ob/AVufc+69994V9x1AZV/4whdy2ftc\njx49Qn3PPffM5ddfj7cauh2v+3/yXG211UJd748++uij0KZjhj8r8/3V/9zg/9Fh1qxZoT579uwE\nlBBSFQAAAAAAAAAAAEDDVqrnfzm3h5+y6i+cqv3yqPRvK/3y6MILLwxtJ5xwQqh//vOfz+XST5BX\n1C+YOvrPlZfnf97rZ5977rnQ5r+m0P8FsuGGGxb3oUT/V8iKCrfbEc7x17/+9Vz+1re+Fdr8ly76\naxY/9n379g11Pcb+v35mzpwZ6rvttlsu/+Y3vwltgwYNCvXVV189lz1c38Ybb5zL48ePD20+Puiv\nLP1/DNVzfTRjeAntg1OmTAlt/r+0dGz3X5X7r14POuigXF64cGFoe+ihh0L9rbfeyuUTTzyxlt1u\nUx2hL2P5NNs5/upXv5rLV199dWgrraXq4b9W13VWSvF/h/qvmj8NzXaODzvssFzebLPNQtuOO+4Y\n6t27d8/lF154IbT5eHz00Ufn8l/+8pfQ5ukLdOy+6aabqu9023tm6dKlW7bWxtrDeUZLzdaX0RLn\nuPk14z0UWmrmvvyTn/wk1E877bRQ12g/mlokpfhMI6WYQmTBggWhzaNFrb32PyPH+68fPw3NfI7x\niWYcr/U5s6eM+NrXvhbqF110US5rJK6UUurWrVsb7F199D7bo8roeJFSHHs8yg19ufnVco75hSMA\nAAAAAAAAAACAhvHCEQAAAAAAAAAAAEDDOlxI1Xpo6AEPbej/bg1N8Mc//jG0aajIeixPqNB6NPPP\nlfv37x/qw4cPD/Wf/exnubzVVluFNg8hoWEizj333NDm4XnvueeeXJ4wYULtO9xGVtQ5rueave66\n60Jdw6xp30sppX/84x+hrqFHvc3rut0f/vCHoU1Da6aU0rBhw3L52GOPDW1HHXVUqO+zzz4V91fD\nIqyxxhqhzcPAff/7389lH2fqCbHajOElDjnkkFy+4IILQtsTTzwR6l/84hdzeb311gtt/fr1C/V3\n3nknl6dPnx7aPJSyhpXxa+L999+vuO9tpZnH67ZSLUynti9PmGsNte3j0Ny5c0O9FN692c7xiy++\nmMvrrLNOaNOQxSmltMoqq+SynzcPm6p1P4Ye1vPHP/5xLv/617+uZbfbVEc/x7/4xS9CXUPkLF68\nOLTp2JxSXHd99NFHNX/nKaecEuoaWj2llLp06ZLL8+fPD21nn312zd/Tigip2gl09L6M6jjHn/D1\nsdN7Pr//a61nGB6yUUPNDRkyJLQNHTo01P/zP/8zl2+55Rbfv6a7h0JLzdyXPbSir6/1vsTX0yuv\nvHKoa2hDT1Pi9zf6bE2faaSU0hVXXFFlr1tfM59jfKIZx2vtg96XR48eHernn39+Lut9s28npfhc\nw58rltKa+P2ZbsfTlvh2NIyqP1fx8WTrrbdOldCXmx8hVQEAAAAAAAAAAAC0KV44AgAAAAAAAAAA\nAGgYLxwBAAAAAAAAAAAANOxz1T/SvnTt2jWXNT9YSimdfPLJoa7xzT3Wuccv1zjHnudryy1jCpc7\n77wzlz3f4+TJk3O5rXI2NhvNB5RSSl/60pdy2WNe33fffaF+8MEH5/L9998f2jQPX0op3X333bl8\n9dVXh7bnn3++4j699NJLoU3zP1522WWpmVS7Zg877LBc1r6YUkqLFi3KZY8b7rmaNDa45xTx86b5\no44//vjQtsEGG4S65he76aabQpvnDdFcjN26dQttmvvA8zt6PkHNDXn55ZeHtmq555pdnz59cnnm\nzJmhzcdgjXfv18SHH34Y6q+//nou+zH289yjR49c9tyQn0YOx47Oj3cpf6LnCPjCF76Qyz5G+HZ1\njKg2LtU612qOxpRSOvHEE0P96KOPzuVHHnkktO27776h7jkHm9kmm2ySy55TRvNfpxTzS/h58X6t\nY/vHH38c2jRPa0pxrm8PORw7Gs9/7fP37Nmzc9lzNmpuxZTqy9uoPPeIzwG6D/5ZzefteZQBoLPy\ntVNpPaTrqnr5es6fq6iRI0fm8kUXXRTattlmm4p/5/finttq7733zmXP4Qh0RLq+8rWX36Nqu+eI\n82cn7777bi7rvdeyvue9997LZX+uAqA2pfl14MCBoa590OdSv6/+3Of++brG+3LJGmusEep+z6X8\nHlzzNPp3vvrqqzXvA5ASv3AEAAAAAAAAAAAAsBx44QgAAAAAAAAAAACgYbxwBAAAAAAAAAAAANCw\ndpfDce211w718ePHh7rmofEYxxpvOKWUlixZksse29xzHmi+mDlz5oQ2zUOWUsz7dNJJJ4W2Bx54\nIJc110Bn47maNK71n/70p9C20047hbrmzHvxxRdD25AhQ0L90ksvzeV77rkntHm+P837c/rpp4c2\nzxel++D5B88777xcPvTQQ0PbmDFjUkeg17v2hWr5PTSHo/c33abn3fDcblr3mOKeJ0RzGPj51xwF\nKaX0yiuv5LLHI/dcCBoT3fOx6THRzy3rO3fbbbdc9vHKcyzoMfJj0ox07PRcmH7eNUb86quvHto8\n/6OOLz4PeI45zc85ePDg0DZt2rSK+45l8/xApXxBnpeglPNneWiOwW9+85uhTcdoH1tWXnnlUF+8\neHEuDxs2rDV3sUPZfPPNK7ZpftuUyvkkquWW0nbPKePj7IgRIyp+D6obO3ZssV1zffi85f1E1+kL\nFy6seR80n25KKc2fPz/UdU4YOnRoaNtxxx1zmRyO7U/fvn1zecCAAaFN87KnFOeB22+/PbTtsMMO\nuaw5uVNqucbv3bt3Ll9//fV17jHQHGrNYZ1SStttt12o77fffqH+xBNP5LLnSCyt3y677LJQ15zL\n+iwmpZbreb0X8vWE338vWrSo4j4AHZHmh9d7kJRarrdLz2s877X2Kx8j/LPat9vqPg1odqVnqJdc\nckmof+c738llv//152Ol55VO+7r3c51fvZ/7WKP3gf5Mf8aMGcV9ABy/cAQAAAAAAAAAAADQMF44\nAgAAAAAAAAAAAGhYuwup6mFxdtlll1DXUBweItFDFOpPkP1nzh4OUsNJ+XY8FKDykGEaUnP06NGh\nTcOtNjs/Luqaa64J9YEDB4b6Rx99lMsemtPPuYa983Cb55xzTqifcMIJuewhXt57771Q19B7/p16\nLb300kupI9Jr3H8qrzw8oYav9DC0es79p/p+Pejx9dCnHsJUt+V90UO9aSgB347T7/VjoGEHPMSP\nXw8arllDzqaU0uWXXx7qpX7RjDT0nod28JARGibCj/H2228f6q+//nouewhVD02h3+vhsbH8SmGC\nDzrooFDXUJ1+njzsec+ePXN5iy22CG39+vULdQ2/6ddZ6bry8EU6tq+//vqh7Xvf+16oa2jtZqPh\n0Krx4638evDP6njobR7WU8dzDUGVUsuwjGjphhtuCPVx48aFeteuXXPZw6T6XKrhTh966KHi92pY\nTF/PeQgf/Z7p06eHtmeffbb4PWh9e+65Zy5ffPHFoe26664L9UGDBuXym2++Gdr83Ol4vvvuu4e2\n//qv/8plDdOaUkr9+/cP9dNOOy2Xn3zyydDmYXc7Wzh7dB4eKt7vv/Q++cwzzwxtnpJA534Pw33E\nEUeEuoZf9RD0CxYsyGW/h+rSpUuq5MMPPwx1v8ebOnVqxb8FOqKvfOUruVxa96YU10y6Zkup5T21\nr7eUh2XU+ZGQqkBj6llb6rzo/dH7oD6jrJbWRuu+Xd2Of4ePH/pv8bW3h0UHquEXjgAAAAAAAAAA\nAAAaxgtHAAAAAAAAAAAAAA3jhSMAAAAAAAAAAACAhrW7HI69evUKdc/ZpvHMPe+ax07Wuretuuqq\noa65mzyXkOcQ0LxDHm9d8w8ec8wxoa0z5XD0uNHqlltuCXXPKaHxpz3GtJ8bvT481v1xxx0X6vPn\nz89lz+Hp+cR0/z0/Ro8ePXL5u9/9buqI9Br2/Kbqq1/9aqhrrkvvQ5pHTftBSi1zdmh7PXkNvc97\nXbfrcc1L+cP8/GseEf8OzzWncc8POeSQ0OY5HPVY6/f7vjYL/feWckakFOPZeyx5Hwd0PPfx2ccB\nzbP64osv1rLbKPD+WsqN5bkA99prr1z2/G0+zpZyws6ePTvU9dryvqT9168N79t6vWoOopRSOuus\ns0K9mXM4brLJJqGu58rPfz05K0p/W2281nPTu3fvmr8Tn5g8eXKon3jiiaG+ww475LLnIp41a1ao\nb7nllrlcLYfj/vvvn8ue98PPsX7Pn//85+J20Zh6cq6qu+66K9Q9R3op17174YUXclnz3qcUxxrP\ntb7ZZpuF+sknn5zLnrPRkbcRzarUp1OK8+7GG28c2jxnot7j7bLLLqHN18/6vMbXS+utt14u+3MS\nvxfQ9X61flrKS4fW4fnL9Zx4fl5y4y4/XXt5/mzv23qM/dnNxx9/HOr6rMKfyZTu47wvA6hNPc/1\nSs9evU37p8+fpb7sc28pv2PpGannYV68eHHFfe8MzzZXtLXXXjvUJ0yYkMtXXXVVaDvjjDNWyD7V\ni184AgAAAAAAAAAAAGgYLxwBAAAAAAAAAAAANKzdhVTt2bNnqHuIBv15rv/kuPTz5FK4VVfPT4A9\nJJv+7dChQ2veTrPT4+Tn6Z577gn1I488MpdnzJgR2krhVDwk3+233x7q22+/fS57aL3S9eHX5KOP\nPlpxH3z/PIxFe6eh0lJq+ZN7Db+z1lprhTYNe6hheVJKafXVVw91/Zm/nwsPC6KhW6uFENGf8pfG\njpRiiAAPO1AK8+qhBd55551c9nCrgwcPDvVp06ZV3G4z0lBJHkLTj7meW+9zEydODPWtttqqYtsa\na6wR6k8++WQue7ga1M/7USl8dteuXUNdwzF5mFQfB/Ta8bC5Xvc+WUm1MUFDinhYX6+PGzculy+5\n5JKavr+jWHfddUNdQ5D7MfMxWcfOauGyS2st365eL927dy9uF/XTkJR+rXsIej2vRx11VGjzsDzr\nrLNOLs+ZMye0devWLdQ95KrS9Z2PHaidrsWrHce77757meXl9fLLL+fyD3/4w9D2ne98J5c93Oro\n0aNDfc0116z5Own9h2ZSCjnv5s2bl8t+z+TpLrRerZ9Mnz49l31O1ntfvw/2tV5pneBrBE/l0RE1\nGta6Nb+zNJ/utttuoa4hVk8//fTQ1uj+Dho0KNR1Tmh2fv1rn5s7d25o87WY3t/6PbWfY00V4/dI\nvr7WffJQ5gBqo32w9E4ipTjulvquf7bafXWl1E0pxfm0WnoUHRN0DZFSSgMHDqz4/YRRXTZ/buVr\nMT1ufm9zxx13hLo+Y9eQ3CmltGjRolz2+7Zbb7011B955JFcfuuttyrue2vgF44AAAAAAAAAAAAA\nGsYLRwAAAAAAAAAAAAAN44UjAAAAAAAAAAAAgIa1uxyOngfAY8qWcgGWeHxkj6GusXOr5XnSuMe+\nHd2nevKLNDs9Tn7epkyZEuqaB9E/6+emlLPP82tqrjHPO+bx7bXdc0a89NJLqRL/bHvN4VgpzvgR\nRxwRPufHUPM+eJx/Pcd+LjzXQCl/hPdVjXPtMcd9/3QfqsU51+/1fqzb9e14ns7Sv/ukk04K9W99\n61u53BninGvOT+8b2pZSzPWlOUNSSunss88O9QMOOCCXn3nmmdA2f/78UNc8YZ6vBvXz/qnXvOfP\nXHvttUO91K+8D+oY4f3c6T6U+r3vu29Xx0Lfn/fffz/UzznnnFxuthyOpRxLfnz9mOq45nmVnY7B\nPh76PuiczNqq9WnuID+nnq9Zx27Pz+x5KvQcDxkyJLT5usDHblXKFYvaNXrf5Gub0jzgdL5OKaXD\nDjsslz2Pp+Zt33///UNXoC6vAAAgAElEQVTb8ccfX2WPKyNvI5qJzpelnIApxXWOz7OeR0hzR/m9\njt/zaY7u0j742t/zt+v+VeunHWXur3ZO/n/V/r315J7V+xvPkajjakopvfvuu7l85plnhjZ/DnfX\nXXcVv7dWI0eOzOU99tgjtE2dOjXUb7/99lb5zvZoww03rNjm/dGvI617P/L7LZ3rPSecr71K+wCg\n9elc7POyr9PreV5YmjNKz8F9jNBxwPdnu+22q3l/8Akfr0vPqm655ZZQ97Fd35v4Pbfm1t5yyy1D\n29Zbb13xOxcsWBDqnj/4sccey+Wf/vSnFbdTCb9wBAAAAAAAAAAAANAwXjgCAAAAAAAAAAAAaBgv\nHAEAAAAAAAAAAAA0rN3lcKxGYwx7TqVSnsZSXriUYq6hUs5Gr5fy1fTp06flP6CT0nPhx95z+Gk+\nB48h7LkWS/HsR40aFeoar7r0nf69pXyfrlrOqvaiUh6fjTbaKNQ1z0NKMaeHH4fVVlut4vd5voBS\nztRSvrZq+VVLbd6P9Vx5mx4fj3Pu+6d5Oj3nSa9evSr+bT25lDqq559/Ppf322+/4mf1OH7wwQeh\nzfO86riruR9Tajm+bLvttrk8e/bsKnuManw81LFSc/qkVF/uN+8P1XKwtgafX3RM8PnE6f5vv/32\nufzcc8+10t59enx+1HNRLTeRjrveFz3Hp46tPraX8hWV5hrUxvuXnrc33ngjtHn+CF8XqHfeeSfU\n9XrxudPz+Prf4tNVyq3m9cGDB+fy+eefH9ree++9UD/22GNzWfN6pZTSqaeemss+R1xzzTW17HZK\nqWW+Zs0jN2/evJq30xGU8nx5m8959dBcnEOHDg1tb731VqjvvPPOufy1r32t4jbryQV60003hbqf\n4zFjxlT822ZWLb+TnvMNNtggtL322muhXrqH9XlXz53/nc7tpTzPrtq6r9bciCtaab+WJ39sPX87\nYsSIXPZ8yD/4wQ8qfnbhwoWhbcKECaG+99575/IOO+wQ2jSXUykvYEqxf3rOxgEDBoT6euutl8tv\nvvlmcbsdjc6VKcX+oPfBKbUc4/QYe1/x/ll65lXKme65vNAx+PWg96UppTRx4sRc9nsz/dt68gX6\nd/oaX7fVGZ55NXrs/DljPeO+f6c+u/BjXrofK32nPw/ROSGllHr06JHLb7/9dpU97pz82Zmfcz03\nvp7u2bNnqOsx9nzN+rd+T+3Xg84Z/vza5ym9b9J3MT63VNI+V24AAAAAAAAAAAAAOgReOAIAAAAA\nAAAAAABoWLsIqdqtW7eKbf5TYf2s/8TXf55a4tvVnxJXC+mh4fz8J6ga5tXDrXZmpXAjfpz0PPrx\n9Z9867nyn4e//vrrod6vX7+K++A/CdZ98hAX+j2lkJkdxVFHHZXLHp7Sj6H++zREVUotz5Xyc6x9\n1499KaSPH996QgL4T8l1//3v9Jx7WEj/WbzWPeSvH5Mjjjgil6+66qqK+9os5s6dm8t+vfh4rWGf\nvE23k1IMW+khZ3xe0M8uWbKklt1GQSl8wlZbbRXq9YR6K/XdUljzap8thTjx8UP/bd6XSw466KBc\n9jGzI/IQiGuuuWYuex/y46thU1988cXQ5vOlzjf+nSXtNaxaR1LqFx7qVMPlpFQOhetzvbb72FwK\ntY62URpnvV+Vxvqzzjor1Lfccstc/rd/+7fQ9tRTT1XczmOPPRbqeo/n84lbd911c9nD/m699dah\nruHFrrzyylx++umni9/RXpTCWvvatp5wXDrPXXjhhaFtxx13DHXtrx6a1ddsem722muv0HbXXXfV\nvK+//e1vc9nDLnoIwYMPPjiXb7zxxuJ2OxM9Nz7G+nnTex+/zvxeWOu+Dtf7Ig+NXFItPFc967IV\nqdGwqX6M/f5X51O/3n0+1fXs8ccfH9o8BPK9996by5qqKKWWYdgeeOCBXP7yl78c2i666KJcfvDB\nB0Pb4sWLQ3399dfPZR93/b7629/+di5rmO1mUEq35NeRXw+absTbfH2tYXVL10pKcX7RVChoffXc\nozpPS6HPlPwZ57Bhw0L98ssvz+VbbrkltOk4VHrO6qrNJ6hM5zJPU+HPy0rPuktpqfz86LrNxwTf\nh1mzZuVy7969Q5vP6T/60Y9y2cN34xPeNzw8uc7J06ZNC20e9rx0HnWu97nd7xX0nPua3kPj6v3Y\nnnvumcsPPfRQqgVPbQAAAAAAAAAAAAA0jBeOAAAAAAAAAAAAABrGC0cAAAAAAAAAAAAADWsXORx7\n9uxZsc3jD2uc92p5fDxWrfLY5xoD2b+zFKO6tB38k8YGHjhwYGjzPE8TJ07MZY9J77kFNFa1x7V+\n9tlnQ13zB1Q7b5orYebMmaFNcw+MHDkytE2aNCl1NF/96ldz2WNB+7WvccU9lrzmK/RcH94XS58t\nxSP3WPJ+zvV7quW50X+rxyPXffCcIX379g31V199NZc97rrnJTv00ENzuTPkcNR8dn7u/DxrrHHP\nIeZee+21XPbcJG+99Vaoa44o8gssv1K+iV122aX4t3oN+PXgOVxK83eJ/109+f5KOXj9362x7zW2\nvefZ6Yg0x1ZKKe266665XG19pPkeZ8+eHdo8P9PGG2+cyz63+/igY/T06dMr7jtqU8oj4+Nkqa/6\nZ72/abuff19v4NPlfU7zIP7yl78MbZ4j78c//nFD36nr8pTimql///6hzfPI6L2E5w71fEa6Xc1F\nuCLv2XyO875SypX08ccf53K1uVFzrh599NGhbeeddw51zX3p/dPXUrpWL92bp5TSyy+/nMtnn312\naLv44otz+b777gttfs67d++ey2+++WZo8xzphx9+eC53phyO1fJh6/VSbd1V6e9SankvpOslzxWk\nqq0ZVLX7BM/V2l7Uk5NcP+v30f53Oo5539D7yZRSevzxx3P50ksvDW2aGzellDbbbLNc1tynKZWP\n8YIFC0L9hRdeyGU/r0OGDKm4Xc2pm1LLdXM9eT87Gn+upcfNn035Gkn7oF9zN998c6gfeOCBuew5\nwHy+1DnRn8mgfqX1dT05Gw855JBQ9xyq2m88B98zzzwT6kceeWQuew7H0pqinv3dZpttQl3zwM2Y\nMaPm7TQjX69oX/f7KJ9r9Xqq59mIzyc6DniuVl+L6fx+zDHHhDYflw444IBcJodjba6//vpQ1/Mx\nd+7c0ObrhLXWWiuX33jjjdD2/vvv57Kv7/x+S6+zas9H9Zzffvvtxc8uC79wBAAAAAAAAAAAANAw\nXjgCAAAAAAAAAAAAaBgvHAEAAAAAAAAAAAA0rF3kcPS49Kqe/AKlfG6ulCvD41WXctJ43oJSvqh6\n9q/ZaP6RYcOGhTbN85ZSzBGwySabhDbP86THW/NEppTS/vvvX/Gz1fIGai4+z0OlcdI9R8EjjzyS\n2rvVV1895J7UuMyeO0/PW0rxmu3atWto01wrnqPAt6t5W0t501KKY0A9+dmq9WPtu57PQK8Pz8vo\ncdgXLVqUyx4f2/dBt6v5iDwvRrN45ZVXctmPsR9XHVc934TTMWPdddcNbX6tdenSJZc1n0Bnp3Ng\nPTl1Sp/VXIYpxbwgKcXr3+d2z11S2r96+r2O7f5vKW2nWu7H0hqio/vDH/4Q6uecc04u+3nzeVfP\n4xNPPBHa1ltvvVAfM2ZMLvtc4+OFuv/++yu2oTalfuz5InxMLeWn8jwQ+tnSOgsrhubGWrJkSWjb\nb7/9Qv3YY4/N5YMOOii0+d+W+NiuuQJ9O5MnT85lzTOWUssxYaeddspln2s8H6GO50899VQtu92Q\nlVZaqeJ9q+9TozxP0m9+85tQ13Ps/Xzx4sWhrmstzxvkedQ0X5SPCb7m1/OhObdTiudx+PDhoc2P\nke6fn2PNVZNSSptvvnlCS6WcbN6n9Nr15xs+tmu7f7bW9WUt7Upzsa5oOob4XFaaE/0Zl17zfu+n\n99Epxb7ueUkfeOCBUNe+suWWW4Y2zcebUsyxeu6554a2Pn36hPoGG2yQy55HVb/H80T6ZzVHmOfj\nLeXA1HVjtXvDjsD7nF7/fhx8ftR7LM/P+9JLL4X62LFjK27X+5yP582m0v1aPWOPb0Pr3v9L2/Vz\n4fPWN7/5zVz2vIzep7Q/+HrJn7Xq3P/000+HtpNOOimXJ0yYUHHfU0pp1KhRuXzCCSeENs/NqgYM\nGFDcbjPQ55l+TayzzjqhXnqGsOaaa4a6Xk/Vcu3pPvjaW5+H9e3bN7T5+dHx3Nd3ft+v+Xl1u54H\nvLXVs86o9bOt+a5G11O+tr377rsr/p3Pj/Pnzw91vUf3/Mc6RvhzFX0mm1I8Jj7X+D3feeedV3F/\na8EvHAEAAAAAAAAAAAA0jBeOAAAAAAAAAAAAABrWLkKqehhCVQoDsDxh1qp9j/KfRZd+Bl0KAas/\nOU6p7X9q3F5pOM2UWobv+uCDD3LZQ0Toz8FTij919p9Ba6jLlOLx959I+znVsJke8qRfv365XC10\naHvUvXv3dNRRR+W6hjXzkLV+PWtIIw8LoiEaPEzu4MGDQ137Y7Wfr5dC1ZT6pvd5D0Ogn/X+r+dx\n4403Dm0e0sJDFqhSeMevf/3ruXzppZdW3EZHpufSQ4P4taV9rlq4yjfeeGOZ35FSyxCrI0aMyGUP\nSdSZlfqgXqfeN/x46/WvxzqllF544YWK3+nhJbyveOji0mdLIYlKYbD8mlQe7tGvV52Lbr311pq2\n2VF42D0NY+Zh90pz3owZM0J9zpw5FT/rfd6/R68Xv65QXbXQyLqW8TWaz+fK59VSuB8N355SyxC7\nuk6YNm1axe2gdqUQbRpaP6WUdt1111D3EKul7ZbWaaVQoocffnio65ix1157hTYNNZZSDK2sIQJT\najku1RMCdnksXbq04r/Xw2T59a/9zsOTa0jEQYMGhTY/9nPnzs1lD3Podf1bb/N0EtruYZx0TZZS\n/Ld6KDFdQ/s9h6dq0GPpY4ufU/1bHUs8pGuzqRZiTfm42qNHj1DXtAOlsG4pxXtA72+6TvT5pHTP\n59eyjzO+NlmRSmOc92V9ruX3iLpG9PWir3v12Pl6ysOs6Xjp33nttdeGup47v5f3cHlDhw7NZV//\n6/MRP6+le2dPb+Hb1fGvWnqDjqY0H3qbXw/aB6+77rrQ5vNCiZ+rjvDsanlUegbs11ZpnVxP2FQf\nV/fZZ59c1hDFKaU0cODAUNe1jIdGnjdvXqhrCOYvf/nLoe3KK68MdX024nP7bbfdlst+r+thGXXM\n8n6rz2+9ruOMb7NZlMYqHw/1evKQ5N4/dVzwNj9ful0fT/S+eqONNgptHpJXn837WsuvQ90HnS/a\n+nlIrc9+Uqr9uVa19wOlfn/YYYeF+jXXXJPLd911V2jzlAV6fzxr1qzQ5ukENOSqpxbQZ1e+9vLr\nTOcXv4583e7vX+rVXLM4AAAAAAAAAAAAgBWKF44AAAAAAAAAAAAAGsYLRwAAAAAAAAAAAAANaxc5\nHD1XkvJYuR5bt/RZjbvrf+fxcDXevcfrLcXv9bjGpdxjnh+jmXM4lo6Z5oNKKaXhw4eH+lNPPZXL\nEydODG2nn356qGtOA89Z8OCDD4b60Ucfncueh89j32vs88cffzy0DRs2LJc9XnlHMHv27HT88cfn\nuuYP9JjNnl9Fz6Pn3tR8Ep73cvPNNw917X9+rZTyZFTL7aexzT1GfCnvm187GufaxwqPc6392nNU\nlWLf33DDDbn8aeYlWVG8P3qeEM0/Uq1faczy0vWSUkp9+/bN5WYec5dHKTdFtT6neb48R5/Hi9cx\no1oOx9L3es6iUhz/Uj6DTTbZpOJ3eI6ZUh8dP358LvuY2Qx0TvacIqW81VOmTAl1zxWkfAz28zhp\n0qSq+4nG6brG5zGvax6QavmVtK/6fOjr51IOx2p52LFspflx9OjRoX7SSSdV/Gw9ORurueCCC3LZ\nc5/pekrHnZTKuYY1x2FKKZ1yyimh7vlT2spnPvOZcE/73//937nsOXz83lfzqPq4+tFHH+Wy52zx\nc6HH1Pucr620f2rux5Ra5n/R/uq5xfzfovOl3yvomszHAL8/1FyRPrd63kj9t2k+Ir8faXal++9x\n48aFtoceeijUdY3s6yWvl/JwaV/1fuv0+vXP+ri/zTbbFLfVlvQ69nHLc1Xp/bAfN83hNnbs2NDm\nufT0GYfnZHv++edDfdGiRbns61fPib3WWmvlss/vfs/7pz/9KZc1N6Vv18cWz52qOas23HDD0Obz\nvfb15Zlr2iM/3qXc9ptuummo/+EPf6i43VdffbViW2mdnlLHfJZVD12/6PW0PNeW5gzefffdQ9tO\nO+1U8e+8L/p984gRI3J56tSpoW3vvfcOdV0ze651zw2p86CuNVJK6e67785lz6Ps146uGfx69Xtz\nHS9GjRqVy88880xqRqU5cZdddgn10vPUUl7mas9kdB7QdWNK8Xz4WsvXYjoX6zZTatlv9N5er5dq\n+9qafJ9aa94o3Xsed9xxof7b3/421CdMmJDLfiw8D6a+p/L8jl7X8czXTFr3udxzy+o5nzlzZmjz\nNX6fPn3S8uAXjgAAAAAAAAAAAAAaxgtHAAAAAAAAAAAAAA3jhSMAAAAAAAAAAACAhrWLHI5rrrlm\nxTaPnevxoktKsYM9H0kpD43vg8bHnTVrVmjzHHjKY/B2Vp5bYOHChaGueVvOP//80OYxppWfb80J\nl1KMUe+f9fOvca6vv/760Pav//qvuezXo+cs0/b2kodg6dKlYb80t+VPf/rT8NmhQ4eGuv77PA69\n/vuGDBkS2jyOuMaq9v7lx6lS7P1l/a2e12rHW//Wc7xqDHLPzeG5xrTPe6x7j1N/5pln5nI9Y1kz\n8Pjf999/f6gfc8wxufztb3+7uC09X37u/Lh2hvyYy8v7kfa5Ui6BlFL6xje+kcvV+orOnZ7HxL9H\n+5KPq6X528eaLl265HK/fv1Cm4/tf/3rX3P5xBNPDG2es+e5557LZc8J3Gwee+yxXN52221r/jvP\nEVEak0t5CFJK6dFHH635e9FStRyI/fv3z2U/b6X1sa8DfA7UXL0+VnsuurXXXru4j6iuWq5FzYHm\n+cn9szp++7mrx5gxY0Jd1+Ke1+aiiy7K5VNPPbXm7/A8SJ5/xPOltJXevXunk08+Ode32mqrivvg\n+do0T473o1L/9blT50vN1ZZSyzm69B3+WT2mvq7yHER6D+Wf1XOl+exSaplzRvOS9e7dO7T5+PHK\nK6/kst67eJ7CZqD3OqX89O70008Pdc85peslv0/2vF+61vZ1t+Z08nGldO/jaz2/tjU3Z1tbbbXV\n0siRI3N9+PDhuex92fOL6r/fc6tpXjbPa+151/QZkz8rGTRoUMW6t/k50DHYc9v7+Snl99N1vOdx\n9Tlj3XXXzWXPCebPhfQ60O9oL89RloevbfU4VcuN+7vf/a7idku57Uv5j1MqP1trBpWuGx9v9BpN\nKaWNNtool/15mOZk9r7p9e7du+eyjxV+Lzx9+vSK+/PII4+E+uzZs3NZx+6UWj6H0znac0NqTlW/\nh/ZrR+cMXd+n1PJ+QO8l9B76xRdfTO1VKQfy8vD8w7rWKb0HSanlcVU+Puuc4nO2nju/7vya1XVa\n6R4wpTh+P/zww7m8IscVzfedUsv1da18Dj700END/Uc/+lEu+9z57LPPhnrpeHu/0v7r6wKnfdTH\nfV23e1/28U7HRT9+fs71XqYR/MIRAAAAAAAAAAAAQMN44QgAAAAAAAAAAACgYe0ipKr+xLPaT5c1\njIX/xNhDg+jPoj1MgX9PKVyQ/2Rcf/bqYSBKIaH85+7NzH8qrD/59dA7Hl7gpZdeymUNWZBSSvPn\nzw91DTvkP//1cH56jv3nyh6ap/TTYf2Ztv9c3X+Kr8ehI4QCOeOMM0LdQxhdeOGFuez97cEHH8zl\nr3zlK6HNf0quSiGLUyqHRvawU/o91UIA6Pf4Z3VM0pAVKaU0YMCAUNdwOb/61a8qtnV2/rP//fbb\nr2J7tXACGkKi2lju40uzKYXWKtHx0cemUmhiD1WtY+XkyZNDW8+ePUNdx2+fVzfddNOK++pjgocw\n1X+3j8l6rXhY37lz51b8zltuuSXUPXTGAw88UPFvm00pLHFpfPZz7OE9lF+7Pn8vWLCgtItYTjrm\nVgs5r/Ouz8FOxw8/p75d3YdS2LHOrhQ2tdo6U+9R7rjjjuJnNbRetfWU6tu3b6h7WM9x48bl8gUX\nXBDafvGLX1Tcbunf7aGC3LRp04rtreWzn/1suNfTca0UsjalOF6WwqS60nZ83PT7Zt1XD9/29NNP\nh7qeVw3BnFIMMZ5S7L+l+yS/p/N7Dg0LN2XKlNCm4e5SivckGq6svd57lcLmVhvvSms9D4113HHH\n5bKGCE2pZQhbPVceUtf7nx5vX7Prv83v/0pjiZ8rr2tYPu0TvtZoDV/84hdDqME33nij4mf9vlD3\nx8PQ632hrzM9rJ2ui3197f110qRJuXzppZeGthEjRoT61ltvncseKtKvCQ3r6delXgN+Xv3fon39\ntddeC22eckjX7c12D+fHW8MOVgtL+/LLL9f8PRrO0ucPf35TWps3A51zjj322Fz255FO51ZfF2s/\n9jDEPo/peSyFX/Zt+bjmz7JLa3EPKdmtW7dc9rlT96naWkqvUf+s74OuA3Tu0bCb7U09z1FK9yk7\n77xzaPNjrs8WPWVLKV2Uhyn1z+pY6nO4zmG+NvTru0ePHsssp1QOD+rP09vSueeem8t77713aPN/\nn+6zv1vQexRPz+D9U0Me+zw2c+bMUO/atWsul9KFpRSfs1Trg7otv1fQNb7fi/lzrFKqPx97SikD\na8EvHAEAAAAAAAAAAAA0jBeOAAAAAAAAAAAAABrGC0cAAAAAAAAAAAAADWsXORw1Fm213DEaj9jz\nQpRyHniMY495q+3V9kHrixYtCm2eS0OtueaaFds6E48DrHHmU0pp+PDhuezx7D1OusYq9rwDDz30\nUKiPHTs2lz1evW+3lEtI97dfv36hrZSbwr/j01Rr3jfPWeF595TmhFh//fVDm+eC0XjZpVjly8O3\n432+lHtC41r7uLLNNtuEeik/Jf7Jc/V47PCddtopl6vlvnz++edzuVp+Xs/B2WzqyTegah2PPFfT\nlVdeGeo6Rvi58BjwOmd7v9KcLSml9Morr1Rs22yzzUJd59aJEyeGtjFjxqRGeP4Lj7/vsfqbWWle\n8/lR+TXmc73y3B8+fpfWVlh+upby8+Zzp14PpfWx16vle0RtfCzSNbXnbBk9enSoe/4XVU9uNaf5\ngTyX/U9+8pNQv/7663PZczZqP69nzezXqM9FnrOqrcybNy+deeaZuf7b3/42lz3Pm68dS7k4dT7y\nex3/t5fyF/q6S4+359ocNWpUqGv+Fz++nvde8yz7/ur9gc8fnj9H/92eb8vzcur4ovfmfnzaUmk+\nTCmue5Znv7Rfn3DCCaHtwAMPDHWdS6dOnRrafE7Wa9TPsefkK+X9VX5MfJzRY+JtpePZ6FhRq5VW\nWil8f/fu3XP51VdfDZ/13Hp6rDwHlJ67ww47LLT5uljzfvma1J+P7LjjjrmszztSivkdU0rpr3/9\nay7feeedoc3zPer++/nRZyCa7zKlls/o9Fh25vWc5/3ScdefKXq+v3ru9zRHvedg8/6yIvOurWgr\nr7xy6Efbbbddxc82mh/b/87HQx07/P7Vx1ldi3vOZe/zb7/9di77/F3qY/4ctmfPnrns87X/W/Sa\n9GPi9+r6tzomrsg5uTX5sSi9dzjxxBND3cdvPV9+HP2a0L/1z/r8osfZc/bpufV8zp77Wb9Tr7Nl\n8fuOtvKZz3wm7Of++++fy/PmzQuf9etY14f+jFHXnb4u9/cFug719bSPA3oevS+Xcjr6vbLXtW97\nvke9Jn3NVnou7nONX4ODBg1Ky4NfOAIAAAAAAAAAAABoGC8cAQAAAAAAAAAAADSMF44AAAAAAAAA\nAAAAGtYuEqqU4mJ7zGPNC+H58zzOrsaq9e14bGuNZ+4x0ks55jxedYnnn+hMNHa/n4tnnnkm1E85\n5ZRc9ljKHndez6PHR/Y8BMqvOY9fr7G1L7744tB26aWX5rLnZCnFwG5PKuUB8PjO9eQL0Lj0njfP\nz41+z/J8p3+2FG/fY63r93qsb42Tv95664W2Us5GzzdSiu/e2XgOW4913rVr11zWPrYsmrvH4477\nOfDcFahu3LhxuXzWWWeFNo+TrzlH/ByXYtZ73HnPAaA5Jryfd+nSJdTHjx+fy9/61rdSJX7Nleb6\nauuAGTNmVPyeZjNw4MBc9nHV11Keq7Vk8eLFuVzKQ5BSSn369Kl5u6if5gHxfB1+zrVeLRdLaU72\n/qjXgOclaa9rqdZSyh2UUuxnmi/b+frE87mde+65Ne9T6d7M+73myt1ll11Cm//bPOecajQXm+c4\n8fFjReVw/Pjjj9P06dNzfZ999snlHXbYIXz28MMPD3Vt99x6uj7afPPNQ5uvXzVvj/+7/T5Z2z1/\nmI+5mofKeW6pddddN5c937EenwULFoQ2n2e13/v6Yvjw4RW/83vf+14u13OfvrzqWfPrOU0p3rPu\nvPPOoW3fffcNdb0G/Phq/uuUYi5tf27ieXn0eHv+J1+jad4vP/+69qt2T1fKHevzgK4vSvloW8PS\npUvDeKR54Pza83+D/p33Oc2N5PeXPq5qHj6/Jvw79fmYb8f/drfddlvmd6TU8lmVngMfI3RM2HTT\nTUObn5/HHnssl/2+7dlnnw11/R5d77f1OV8R/PmIPovwecxzcNVD19ees8+vnWbO4fj3v/89TZ48\nOddPOumkXPbj3bt371DXcczHOD2mfq9benbpc7I/s9Dx0scOHcudb6eUp9PX7drffP/8s6V9KNHr\nvJ7nfO1JKf9wSinttNNOubztttuGNl33pBTncD/GPs7pMfe8gb5W1DWVn8s999wzl/3ZjucT1vPl\n59z7wopaY33uc70FbXsAABXrSURBVJ8LOeLvvffeXPbnQqX8p55HV69HX+eWzo2v4YYMGRLq2gf9\nGPrYo9eWPxf386j74HO9jkt+TDzPsv7bfI7wfdAxVI9l6Zm44heOAAAAAAAAAAAAABrGC0cAAAAA\nAAAAAAAADWv3IVU9hIeGc/Ofo/rPVTW8pf8M2kNG6c9OfbulkFEeBqxEfwbc7PwnvsrDvfj532qr\nrXLZfyru4RE1/Iuft1LIXQ/T4teH/kR4//33D23nnXdeLnvIGd+O/qTbwx61F/qz6WrhAkohEfQn\n3x7awX+aXfpO3662+/5U+57Sdj0kgNLz7/vnP7fXUBTVwkQ0Q0iJRg0bNizU/dxp6Jg33nij5u16\nqAEPpaxhZZqdjoE+b/3kJz8J9eOPPz6XPaSSnisPHep9UMfkauHwdI72cd/n5G7duuXydtttF9qu\nuOKKUP/2t79d/N5K31kaL6qFlZkzZ05N39kMttxyy1z2dZbPpVOmTKl5u7oW8PDkfq48FAhWHJ8D\nSyHwvJ/oeawWiknD05S+oxmV7oNSimPrDTfcENo0NJOH+Hn44YdDvbQOrbYPatSoUaGua34NK5VS\nDN/nSukt6tk/D5/k64taw/60pQkTJhTrJRrO0UNqeVjMkSNHVvys9yvtrx6+7Ve/+lWoT506NZc9\nhJbfq2s4Vg3JnVIMuev77us1nYcfffTR0Hb11VeH+oMPPpjLjYZ9a20eXvi0007L5S222CK0achY\nv/f1EJTar31N5udcn4Vo2E3/zpTi9eF9xp93eB+rtB3/nM8Rei9U7R5vRa673nnnnXTttdfmuo5r\nft16OLL+/fvnsj/70TWTrnNTahnOtFevXrns17SPlXrN+LMJr+t9rI/BEydODHUNY+vrdA0P62Ow\n31c8+eSTuezrRr/W9BrW9edTTz2VOjo/TqV7VE3vUy8do/07SyGAm52ugfza17CBbaVa+Hy1PCmH\nStvy56U6tnubPyvTMdnH51KYSD3uPp992krPJPX8VAuZfsEFF+Syz7W+DtIQt/68wefa0rNkD3Ot\na7Evf/nLoe3000/P5VNPPTW0/fjHPw51Dc3qz959rbiinm/36NEjHXPMMbmu/ff2228Pn/W+ssEG\nG+SypzNQft78nOtc5eOmf6fOjz6Wewo2XYv5+dft+D7581Ldjo9vPs/qOfZ/t4ed1fctOn/Xmq6i\nc93RAwAAAAAAAAAAAGhVvHAEAAAAAAAAAAAA0DBeOAIAAAAAAAAAAABoWLvI4agxoDWmcUotY/2X\ncqt5nF39W4+T7/knSjy+tn6vt5W267kSmpkfF43xq3GUU2qZk0HzB/hnPW605jXxOMavvvpqqGvO\nGb/ONDeo83wGGtd47Nixoa3WWMbtSSl/RinHWWk7fp5K2/EY2B4TXveplDcypXKsdb8mdR8954l+\n1uNYl/4tvu/15ERqdp6zw+POa54Tj23u15PyWOe9e/cOdc3P2+xK+Ya32WabUNd+59fp008/ncue\ns7SU38CPtW9X50Df1/XWWy/UNZfNAw88ENpqzdlYTSm3kO/7kiVLQr095ARbUfS8+bjq/frFF1+s\nebuaV2jw4MGhzXNCdKZ+/GmolptE1TOv6WfryY/eXnKwfVpKuQ19rJw0aVIub7/99qHNc4t5jrDS\nZ3UfdK2dUpwjUkrpjDPOyGXN9ZdSy/W1ziH15I4qzT1+vEp52Tsiz6WsnnvuuVC//vrr23p3qtJ1\ns6+h77333hW7M23sgAMOyGXNkZRSy3+7rjkee+yx0DZ79uxc9n5ayuXm62PNtZNSXCP7vY7fJ+va\ne/311y/ug+aK8tyxOtb7fZr3VZ17/P7K5wHN56fHyP/NbUHzZnr+Vf836b75WsY/qzzfo4/1ysc0\nfc7luRY9x6pu1/fP/1bXf35dam4xf/7l8/2IESNy2cdnv+fTecFzS3V03udKuVB9Tq5H6VmFt/n9\neDPT8aaedW9rqWf9vDw5G0vb8nVXs+fwrJZrUueoeq6Jyy67LNT1nsbHOH/urOfD50/PuaqfrTZe\na95GXxt63sYS/U6/Zn0OW1Hjx5tvvhnyYB9xxBG5vPXWW4fP+vw4a9asXPb85Jtttlkub7zxxqHN\nz4XmJ/fryo+LHjc//37Mpk+fnsv+PsPzIWt7KZ9m6Rm5t3uf8H/LmDFjcvnII4/M5fHjx6da8AtH\nAAAAAAAAAAAAAA3jhSMAAAAAAAAAAACAhrWLkKq9evXKZQ+x5D9B1TAA1cI96s9g/aeiHoav0nek\n1PKn5rpdDQmWUkqvv/56Lg8aNCi0lcJoNBv/2a6GXfOfmftPfvWYetimxYsXh/rPfvazXPawuf6z\neA3Z4SEtrrrqqlDfdNNNc9lDNOr5958y+0+v/afvHU094RxWXXXVXPZzWgql5iFzPHReKYRxKQRs\ntX3Xvy2Fk/B99+u3Hq0ZHqOjmT9/fqg/8cQTob7HHnvksvejEr3uUmp5LjtraD4PneWheTQMh8+H\nGkLJj6fPYzqu+vXtn9Vz4WOE76/2z3/5l39JbaGe/vjee++FuocCb2bax3x95MfQ+3mJhhTxcdW/\npxR2CstP+1spdKXzz5bmRx+LS5/tiOHpq/n85z+fevTokesaAuipp54Kny2tSTSsYEopHX/88bm8\n7bbbhjYPt6ShcDxMp9c1RN6jjz4a2jyUlO6vpxpwbRFq3sP51ZM2A1ge++23Xy57v/VUKvq8w8dD\nXQP169cvtPk8q/fUvgb2Pq9zp4du87Beui2/91mwYEGo6z13KURdtWcqyj9bCm/Xt2/fXPZ7+rZW\nCk2WUryHKa2ZfZzyY6PrqWpho3Uf/D7an49oiFVPXaPPP1KKz1089KmeH7/H8DWb7u/ChQtDm6+n\n9TtnzpyZy6Uw7B2F3/tq6D/v536cdPzw549O+7JfV/49L7/8cnFbQEejc4nPI6V5RdfoKcVQ0D/8\n4Q9Dm4bXTCn2I09v4OGydR+qpWzRsdT7/cCBA0Ndn0trqFDn++7qSR/la4O2pGPXNddcs8xySikN\nGDAg1PU5kj/z0nHW3zv4cdBz42s4n5/0e3z+9nQ0umbw9YWP11tssUXFfdBz4/O10znZw9L7ulLX\np3q/Wuu9Or9wBAAAAAAAAAAAANAwXjgCAAAAAAAAAAAAaBgvHAEAAAAAAAAAAAA0rF3kcOzZs2cu\ne5x5jVeeUkrPPfdcLlfLv1TK/eZ0W/7ZUg4rz+G33nrr5bLHs+/fv39xH5qJH7Pu3bvnsscb1lwC\nKaU0derUXF5rrbVCmx9DjWXt8ZE9JrbGmPbztvnmm4e6xmG+//77K+6v5xj1mMceE7mZ+b9dlfJ+\nVcsXpX/rccP9nGtsbf9O/x7dlucMLOWKrZY7Fss2bdq0UPexXftSPXngStdLStXzXHRkXbp0STvv\nvHOun3POObnseXw8XrweN+9XOkZ73/DY99qvfDulPDf+WY99v8MOO6RKfB8azfdWTw7HarH6m1np\nevBjOGHChJq3O3369Iptfn14Tgu0Ll0v+VjhuahLa2vP5aV1n4P9WmrGvI3qM5/5TFpjjTVy/eij\nj87ln//858W/1dwwnu/x4YcfzuVRo0aFNs8RpnljfH3q+aL23HPPXH7wwQdDW7V5oS2U5hfN55ZS\nzLvjnwVa09ChQ3PZc0N5bmodZ/2zeo163/R5Vts9v/Qqq6wS6jru+rqw2nyu/P5bP+vro9J44N+h\n/+5SXl+na/tSXshPQymHrJ+vWv+urfh8grbl96SaV9X7kT/j0Nyc1e5tS/db3gfnzZtX3BbQ0ZTm\nMs/FqPnU9Xl1SjEPs+f3u++++0J9/Pjxuezj/A9+8INQP+CAA3LZ80b6PZjOC/6sdaONNgr1Wp9R\n+r/T7/OUH0ufp998882avrM11Ppux/M6/+53v6v4WT2Gnj9br42U4tpr/fXXD23+TkCPm18Pf/nL\nX0Jd7/GqPZvaZ599ctnfk+gaz9eYpVyb/l7E83v72rFe/MIRAAAAAAAAAAAAQMN44QgAAAAAAAAA\nAACgYbxwBAAAAAAAAAAAANCwdpHD8eCDD85lz3vocYGvvvrqXPYYtx7rXGOWexxbj3GscYB9ux77\nXOseZ3nHHXfM5f322y+0eS7AzkRjQ3scYM+FpTGwq/nNb36zfDu2nDzPhuetaLY8X9pvvJ94LhDl\nny3lSHSam6NaXsZSPy7F+vbzpJ/17/TxALV57LHHQv3iiy8O9WeffTaXfbwu8bjomuPCt9ts3nvv\nvXT77bfn+lZbbZXLBx54YPis5hdOKfYrz4+nuT+8zfuK5iTyOdj7p+ZC8PHiO9/5TqjPnj07VdJa\nud7qyeHox0FzLrz22mutsj/tlcby97wPHuffc72V3Hzzzbns+S08F6DmN0D9SnmUU4q5HTbbbLPQ\n5n3e17218j7kuUjeeeedin9bWnt0FB9//HHIW6o5XNzAgQNDfdttt81lH8uHDx+ey5ojclmfHTZs\nWC7vvvvuoc3nTs3r5OPzlVdeWXHfq+Xlbguem8RzwwNtRcdD70OeW1DztZX4Wqp0D+U8D5z2x9VW\nW624fzrv+r2OrvVSijl//LN6L+zfUZqLfKzwv+3WrVsu63rX7y+AjuKhhx7KZV97Oc/XVVLPM49S\nbi+go7vxxhtDfcMNNwx1fS6ta/SUUrr00ktz2XM47rDDDqGuc69/R69evUJdn4v7Mw2f/zW/ep8+\nfULbuHHjUiX+TFq/x9cipTWHjyU+36/I8aMt7idmzJixzHJK7fPdzR133PFp70Ld+IUjAAAAAAAA\nAAAAgIbxwhEAAAAAAAAAAABAw9pFSFUNn+chVN3GG2+cy6XwS87DcpR+kuuhS7z+1ltv5fK6664b\n2ubPn5/Lv//972vev2b3/vvv5/KsWbNq/jv/2XY9oRaXh4aVKYVFnTt3bqj7T/E7auivRuhP9/28\n+TEsHRcP16bhdz744IPiPuhnPayXhxbQ7/FwBrp/HmbAQ/2hNt43PLye12vl14SP9Z0pFOOpp566\nzHJKKR1zzDGhriG/PYzPRhtt1ND3a9iPlFqGztJwQGPHjg1tt912W83fUy08ZK3q+Tsf0xq9Xjsi\nXWt5KNw5c+Y0vF0NY+NjsIfb9PED9fH50NdSukbzsHt+zldZZZWK2ymFMvftePjPauv/zsSv9450\n/bdVCFWf25Ufn5EjR7bJPgBrr712OuSQQ3JdxzW/J/QxT8c4v5fQew1v8+3ouOv3NqUx2Nv8bzVM\nqn/W7810u97ndb6pNh7ov8XXWT5v6T698sorudxaYfaBFU3TEIwaNSq0VQtDX6Jjht8z+VyqzzWB\nZrD99tvn8iabbBLa/PrX8KdDhw4NbbvuumsuexhS347O4aVnmSnF5yWl9wwpxdQIL730UmgrvWso\nrZnXX3/9UPfntDove5s/F/V1D+D4hSMAAAAAAAAAAACAhvHCEQAAAAAAAAAAAEDDeOEIAAAAAAAA\nAAAAoGHtIhmZxuyvlqNPc754PGSP/a+xiz3esOcU0O/13AleL+V3K+2Pf2cz5/f73ve+F+pf+cpX\ncvmJJ54ofla1Vc7GajnASnkb1cEHHxzqF1xwQahffvnluXzeeefVs4vtUuma1dwkHi/d+4Lm2/Dc\nGx9++GGoa44RPy8en1zzHfhnvf9pu+dH0e36NeifrYded83c/5dl3rx5ob5gwYJQX7JkSUPb9eO4\nePHiYr2z0rFoWXWl8+zAgQND25prrhnqmqfA8+34OX3ooYdq29kqPo2+c9FFF4X6q6++usL34dOi\nY7SfY83DWC/NDfm3v/0ttGmewJTInbu8quXR0vzjPid7Tkfl86PP9Tpf+j74OdV9cHrdrahc3gDg\n/u///i+sKwcNGpTLr732Wvhs//79G/oOzaWYUst7HR07fU725xI6Jvvaye+FPw26T37f9u6774a6\n7u/rr79e8e+AjmLSpEm57P3T+7bmmnvggQeK21199dUrtvn3/OMf/6i6n0BHcuCBB+Zyt27dQlup\nn3neVH3mUW2u1Xscn7tK9z/e1qdPn1CfMmVKLo8ePTrVqvSsxNcmfs/9wQcf5LLnevZ/dylXJJAS\nv3AEAAAAAAAAAAAAsBx44QgAAAAAAAAAAACgYbxwBAAAAAAAAAAAANCwdpEUp558LL169cpljznu\nsZU17rLnivHv1G15LgD/W81Ztc4661Tc186cZ+aRRx4J9Q022CCX586du6J3p4XWygHm/5Ynn3wy\n1B977LFW+Z72QvuC9xPNvbjqqquGNs/P1bNnz2WWU4r541JKadGiRcv8Dt+flFJaa621ctlzk3hd\nv7eU71H7+7K+E43x8bHRXDJdu3YNdc8/hvpp7P5nnnnmU9yT9uOSSy75tHdhhenbt2+oax/zfuu5\nHZSvyUp5BH1sX3fddUN93LhxuXzLLbeENs1vgWXzc+HnUc/NVlttFdomT54c6pqvQ/NwplTOa+5z\n6ZAhQ0L9vvvuq/i3ANAevPPOO+naa6/N9dtvvz2Xhw0bFj7rY5yOj6X8bL179w5tPnbqOtfz5r73\n3nuh/v777+dytecmOg94Tl2fv7Xuue11u54D2HNFaZ5wn098f/V7yNuIZvD000/nsl/T/ixl/fXX\nr3m7pf6pYwLQjE4++eRcPu+880Kb3+NsvfXWuTx06NDQps8kvT96XT/bpUuX4meXLFmSy/PmzQtt\np512WqhffvnlqZLSHO7PK/XezfNEak7klFKaM2dOLvsz3B122CHUmYtRDb9wBAAAAAAAAAAAANAw\nXjgCAAAAAAAAAAAAaFiHiw148cUX5/Luu+8e2jxEgIYQ8J8ce3gB5WFD9GfPKaW0ePHiXL711lur\n7HHn9NZbb4X6yy+/nMsTJ04s/q2GVmyt0KdtxUPH6s/VU4rhQJtBKUywhpddsGBBaPNweddcc00u\nT506NbR5OAO9BqqFGymF5fSQAFrv1q1baNPv0XA/KaX0xhtvVPyOUsjAlNr/9bwi3XvvvaHuY0at\n7r///lD3cE0A6jN79uxQP+6443LZ+2kpNFO18VDttttuoa4h8VOKodXefvvtmreLT1Q7Fxo+57rr\nrqvYllJcB/gax0P4aN1D/3kIH18LqHquJQBYUTQE/RNPPBHavA4ASsMIe1oeD9Gsz9Kque2223LZ\nQ7E2W7ofoMTTX3nd03R0JKV7o1KoU72vB9oav3AEAAAAAAAAAAAA0DBeOAIAAAAAAAAAAABoGC8c\nAQAAAAAAAAAAADRspXpyiq200koLU0qvV/0gVqR+S5cuXbu1NsY5bpc4x82vVc9xSpzndoq+3Pw4\nx82Pc9w5cJ6bH+e4+XGOmx/3UJ0Dfbn5cY6bH+N150Bfbn41neO6XjgCAAAAAAAAAAAAgCKkKgAA\nAAAAAAAAAICG/X/t2bEAAAAAwCB/6znsLo2EIwAAAAAAALAJRwAAAAAAAGATjgAAAAAAAMAmHAEA\nAAAAAIBNOAIAAAAAAACbcAQAAAAAAAA24QgAAAAAAABswhEAAAAAAADYAlffq+AZbn05AAAAAElF\nTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11c2c25f8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_gallery(X, n_row=6, n_col=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generating Images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "generated_images = generate(128)\n",
    "plot_gallery(generated_images, n_row=6, n_col=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Top 5% \"realistic\" according to discriminator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "generated_images = generate(128, nice=True)\n",
    "plot_gallery(generated_images, n_row=6, n_col=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using the Discriminator as a Classifier\n",
    "While training the GAN, the discriminator has learned features which we can reuse to create a classifier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from keras.models import Model\n",
    "from keras.optimizers import SGD\n",
    "from keras.layers import Dropout, Input\n",
    "from keras.utils.np_utils import to_categorical\n",
    "\n",
    "d = discriminator_model()\n",
    "d.compile(loss='binary_crossentropy', optimizer=\"SGD\")\n",
    "d.load_weights('discriminator')\n",
    "\n",
    "# Create new model with the pretrained layers\n",
    "# of the discriminator up to and including the\n",
    "# flatten layer\n",
    "base_model = Model(d.input, d.layers[6].output)\n",
    "for layer in base_model.layers:\n",
    "    layer.trainable = False\n",
    "    \n",
    "# Now add a fully connected classifier on top\n",
    "model = Sequential()\n",
    "model.add(base_model)\n",
    "model.add(Dense(256, activation='relu'))\n",
    "model.add(Dropout(0.5))\n",
    "model.add(Dense(10, activation='sigmoid'))\n",
    "model.compile('adam', 'categorical_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "_, (X, y) = fashion_mnist.load_data()\n",
    "X = X[:, :, :, None]\n",
    "y = to_categorical(y, 10)\n",
    "\n",
    "# Now train with remaining samples with class labels\n",
    "history_pretrained = model.fit(X, y, validation_split=0.5, epochs=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Same architecture without pretrained weights\n",
    "model = Sequential()\n",
    "model.add(\n",
    "        Conv2D(64, (5, 5),\n",
    "        padding='same',\n",
    "        input_shape=(28, 28, 1))\n",
    "        )\n",
    "model.add(Activation('tanh'))\n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "model.add(Conv2D(128, (5, 5)))\n",
    "model.add(Activation('tanh'))\n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(256, activation='relu'))\n",
    "model.add(Dropout(0.5))\n",
    "model.add(Dense(10, activation='sigmoid'))\n",
    "model.compile('adam', 'categorical_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "_, (X, y) = fashion_mnist.load_data()\n",
    "X = X[:, :, :, None]\n",
    "y = to_categorical(y, 10)\n",
    "\n",
    "# Now train with remaining samples with class labels\n",
    "history = model.fit(X, y, validation_split=0.5, epochs=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "val_acc = history.history['val_acc']\n",
    "val_acc_pretrained = history_pretrained.history['val_acc']\n",
    "\n",
    "epochs = range(len(val_acc))\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
    "plt.plot(epochs, val_acc_pretrained, 'r', label='Validation acc (pretrained)')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the plot we can see that using the learned features of the discriminator gave an advantage in the beginning, but the untrained CNN eventually caught up. The advantages of using the learned features from the discriminator would most likely be more prominent after training large datasets.\n",
    "\n",
    "NOTE: The architectures above have some differences from the original paper such as:\n",
    "Replacing pooling layers with strided convolutions\n",
    "Using batch normalization in all layers except the generator output and discriminator input\n",
    "Removing fully connected hidden layers\n",
    "Using ReLU in the generator for all layers except output which uses tanh\n",
    "Using LeakyReLU in the discriminator for all layers except output which uses sigmoid\n",
    "However, after updating the architectures to use these guidelines, the results were not nearly as stable. Perhaps these guidelines are better suited towards larger images, such as the 64x64 images from CIFAR10 that were used in the paper, and color images, as opposed to our 28x28 greyscale images."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GAN DeepFake Detection\n",
    "Recent controversial work has been used to transfer the face of one subject to another. One particular implementation made its rounds on the internet as a way of taking a celebrity's face and putting it on content images or video frames.\n",
    "\n",
    "These models show how machine learning is being used for nefarious applications. It would therefore be useful to have a model that is capable of determining whether an image of a celebrity is genuine or has been generated by a faceswap model.\n",
    "\n",
    "GANs are an obvious candidate for this task because of their uses for forgery detection. The generator would forge faceswap images and the descriminator would learn how to detect if the picture is a real photo of someone or if it has been faceswapped.\n",
    "\n",
    "### CNN Detection\n",
    "To examine the performance of GAN faceswap detection, a simple CNN classifer is used to classify the real and fake images. The input data is a set of 4,000 real images and 10,000 images that have already had the face swapped. The swapped images have been swapped to new people and back to the original person. Additionally, some of the real images have been scaled down a random percentage to simulate someone moving further away from the web cam.\n",
    "\n",
    "When trained on real and a variety of fake images, the CNN is able to detect fake images with 64% accuracy.\n",
    "\n",
    "### GAN Detection\n",
    "A generator and discriminator network are used to generate faceswapped images, and classifying whether an image has been altered or not. Using this method, we were able to achieve a faceswap detection rate of 68%."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from keras.models import Sequential, load_model\n",
    "from keras.layers import Dense\n",
    "from keras.layers import Reshape\n",
    "from keras.layers.core import Activation\n",
    "from keras.layers.normalization import BatchNormalization\n",
    "from keras.layers.convolutional import UpSampling2D\n",
    "from keras.layers.convolutional import Conv2D, MaxPooling2D\n",
    "from keras.layers.core import Flatten\n",
    "from keras.optimizers import SGD\n",
    "from keras.datasets import mnist\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "import math\n",
    "\n",
    "from os import listdir\n",
    "from os.path import join\n",
    "from scipy.ndimage import imread\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "def generator_model():\n",
    "    model = Sequential()\n",
    "    model.add(Dense(input_dim=100, output_dim=1024))\n",
    "    model.add(Activation('tanh'))\n",
    "    model.add(Dense(128*5*5))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(Activation('tanh'))\n",
    "    model.add(Reshape((5, 5, 128), input_shape=(128*5*5,)))\n",
    "    model.add(UpSampling2D(size=(7, 7)))\n",
    "    model.add(Conv2D(64, (5, 5), padding='same'))\n",
    "    model.add(Activation('tanh'))\n",
    "    model.add(UpSampling2D(size=(5, 5)))\n",
    "    model.add(Conv2D(32, (5, 5), padding='same'))\n",
    "    model.add(Activation('tanh'))\n",
    "    model.add(UpSampling2D(size=(2, 2)))\n",
    "    model.add(Conv2D(3, (5, 5), padding='same'))\n",
    "    model.add(Activation('tanh'))\n",
    "    return model\n",
    "\n",
    "def discriminator_model():\n",
    "    model = Sequential()\n",
    "    model.add(Conv2D(64, (5, 5),padding='same',input_shape=(350, 350, 3)))\n",
    "    model.add(Activation('tanh'))\n",
    "    model.add(MaxPooling2D(pool_size=(8, 8)))\n",
    "    model.add(Conv2D(128, (5, 5)))\n",
    "    model.add(Activation('tanh'))\n",
    "    model.add(MaxPooling2D(pool_size=(8, 8)))\n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(1024))\n",
    "    model.add(Activation('tanh'))\n",
    "    model.add(Dense(1))\n",
    "    model.add(Activation('sigmoid'))\n",
    "    return model\n",
    "\n",
    "def generator_containing_discriminator(g, d):\n",
    "    model = Sequential()\n",
    "    model.add(g)\n",
    "    d.trainable = False\n",
    "    model.add(d)\n",
    "    return model\n",
    "\n",
    "def combine_images(generated_images):\n",
    "    num = generated_images.shape[0]\n",
    "    width = int(math.sqrt(num))\n",
    "    height = int(math.ceil(float(num)/width))\n",
    "    shape = generated_images.shape[1:3]\n",
    "    image = np.zeros((height*shape[0], width*shape[1], 3),\n",
    "                     dtype=generated_images.dtype)\n",
    "    for index, img in enumerate(generated_images):\n",
    "        i = int(index/width)\n",
    "        j = index % width\n",
    "        image[i*shape[0]:(i+1)*shape[0], j*shape[1]:(j+1)*shape[1]] = \\\n",
    "            img[:, :, :]\n",
    "    return image\n",
    "\n",
    "def load_data(data_dirs = []):\n",
    "    X = []\n",
    "\n",
    "    for data_dir in data_dirs:\n",
    "        files = listdir(data_dir)\n",
    "        for fp in files:\n",
    "            img = imread(join(data_dir, fp))\n",
    "            X.append(img)\n",
    "\n",
    "    X = np.array(X)\n",
    "    np.random.shuffle(X)\n",
    "    return X\n",
    "\n",
    "def train(BATCH_SIZE, load_models):\n",
    "    X_train = load_data(data_dirs = [\"df-data/ian-real\"])\n",
    "    X_fake = load_data(data_dirs = [\"df-data/ian-ian\"])\n",
    "    X_train = (X_train.astype(np.float32) - 127.5)/127.5\n",
    "    X_fake = (X_fake.astype(np.float32) - 127.5)/127.5\n",
    "    d = discriminator_model()\n",
    "    g = generator_model()\n",
    "    d_on_g = generator_containing_discriminator(g, d)\n",
    "    d_optim = SGD(lr=0.0005, momentum=0.9, nesterov=True)\n",
    "    g_optim = SGD(lr=0.0005, momentum=0.9, nesterov=True)\n",
    "    g.compile(loss='binary_crossentropy', optimizer=\"SGD\")\n",
    "    d_on_g.compile(loss='binary_crossentropy', optimizer=g_optim)\n",
    "    d.trainable = True\n",
    "    d.compile(loss='binary_crossentropy', optimizer=d_optim)\n",
    "    if(load_models):\n",
    "        d.load_weights('discriminator.h5')\n",
    "        g.load_weights('generator.h5')\n",
    "    FAKE_BATCH_SIZE = int(BATCH_SIZE/2)\n",
    "    for epoch in range(100):\n",
    "        print(\"Epoch is\", epoch)\n",
    "        print(\"Number of batches\", int(X_train.shape[0]/BATCH_SIZE))\n",
    "        for index in range(int(X_train.shape[0]/BATCH_SIZE)):\n",
    "            noise = np.random.uniform(-1, 1, size=(FAKE_BATCH_SIZE, 100))\n",
    "            image_batch = X_train[index*BATCH_SIZE:(index+1)*BATCH_SIZE]\n",
    "            generated_images = g.predict(noise, verbose=0)\n",
    "            faceswapped_images = X_fake[index*FAKE_BATCH_SIZE:(index+1)*FAKE_BATCH_SIZE]\n",
    "            if index % 20 == 0:\n",
    "                image = combine_images(generated_images)\n",
    "                image = image*127.5+127.5\n",
    "                Image.fromarray(image.astype(np.uint8)).save(\n",
    "                    str(epoch)+\"_\"+str(index)+\".png\")\n",
    "                d.save_weights('discriminator.h5')\n",
    "                g.save_weights('generator.h5')\n",
    "            print(image_batch.shape, generated_images.shape, faceswapped_images.shape)\n",
    "            X = np.concatenate((image_batch, generated_images, faceswapped_images))\n",
    "            y = [1] * BATCH_SIZE + [0] * (2*FAKE_BATCH_SIZE)\n",
    "            d_loss = d.train_on_batch(X, y)\n",
    "            print(\"batch %d d_loss : %f\" % (index, d_loss))\n",
    "            noise = np.random.uniform(-1, 1, (BATCH_SIZE, 100))\n",
    "            d.trainable = False\n",
    "            g_loss = d_on_g.train_on_batch(noise, [1] * BATCH_SIZE)\n",
    "            d.trainable = True\n",
    "            print(\"batch %d g_loss : %f\" % (index, g_loss))\n",
    "\n",
    "        d.save_weights('discriminator.h5')\n",
    "        g.save_weights('generator.h5')\n",
    "\n",
    "def generate(BATCH_SIZE):\n",
    "    g = generator_model()\n",
    "    g.compile(loss='binary_crossentropy', optimizer=\"SGD\")\n",
    "    g.load_weights('generator.h5')\n",
    "    noise = np.random.uniform(-1, 1, (BATCH_SIZE, 100))\n",
    "    generated_images = g.predict(noise, verbose=1)\n",
    "    image = combine_images(generated_images)\n",
    "    image = image*127.5+127.5\n",
    "    Image.fromarray(image.astype(np.uint8)).save(\n",
    "        \"generated_image.png\")\n",
    "\n",
    "def evaluate():\n",
    "    d = discriminator_model()\n",
    "    d.compile(loss='binary_crossentropy', optimizer=\"SGD\")\n",
    "    d.load_weights('discriminator.h5')\n",
    "\n",
    "    X_real = load_data(data_dirs = [\"df-data/jake-real\"])\n",
    "    X_fake = load_data(data_dirs = [\"df-data/jake-jake\"])\n",
    "\n",
    "    X_real = (X_real.astype(np.float32) - 127.5)/127.5\n",
    "    X_fake = (X_fake.astype(np.float32) - 127.5)/127.5\n",
    "\n",
    "    X = np.concatenate((X_real, X_fake))\n",
    "    y_real = [1] * X_real.shape[0] + [0] * X_fake.shape[0]\n",
    "\n",
    "    y_pred = d.predict_classes(X)\n",
    "\n",
    "    print(confusion_matrix(y_real, y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Can we do better?\n",
    "Using some of the recommendations (bag of tricks) in the textbook, including using normally-distributed noise initalization and using clipping on the gradient in the discriminator, we were able to increase the classification accuracy of the discriminator to 76%.\n",
    "\n",
    "Below is an image of some of the generated faces from the bag-of-tricks implementation. Notice the mode collapse: the generator is generating nearly identical images. Moreover, the images are not photorealistic. \n",
    "\n",
    "We leave it as an exercise to the students to improve upon this implementation. Keep in mind that our bag-of-tricks implementation is only one approach. Keep an open mind to trying different techniques, and hopefully you can beat our result.\n",
    "\n",
    "<img src=\"./images/92_0.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compare to Our Bag-of-Tricks Implementation\n",
    "\n",
    "Once you've completed your implementation of the face-GAN, compare your implementation to our implementation and see if you were able to out-perform our result. The training data for this GAN is available [here](http://www.lyle.smu.edu/~ianj/gan-data.zip), and our implementation can be found [here](http://www.lyle.smu.edu/~ianj/dfgan.zip). Do not look at our implementation until you've created your own, as we expect you to try different things to improve the GAN, rather than simply copying our implementation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# References\n",
    "\n",
    "Generative Adversarial Nets, Ian J. Goodfellow et al.: https://arxiv.org/pdf/1406.2661.pdf\n",
    "\n",
    "Introduction to generative adversarial networks reference notebook, Francois Chollet: https://github.com/fchollet/deep-learning-with-python-notebooks/blob/master/8.5-introduction-to-gans.ipynb\n",
    "\n",
    "Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks, Alec Radford et al.: https://arxiv.org/pdf/1511.06434.pdf\n",
    "\n",
    "Generative Adversarial Text to Image Synthesis, Scott Reed, et al.: https://arxiv.org/pdf/1605.05396.pdf\n",
    "\n",
    "Photo-Realistic Single Image Super-Resolution Using a Generative Adversarial Network, Christian Ledig et al.: https://arxiv.org/pdf/1609.04802.pdf\n",
    "\n",
    "Deep networks for image super-resolution with sparse prior, Z. Wang, at al.: https://ieeexplore.ieee.org/document/7410407/\n",
    "\n",
    "Unrolled Generative Adversarial Networks, Luke Metz, et al.:https://arxiv.org/pdf/1611.02163.pdf\n",
    "\n",
    "Progressive Growing of GANs for Improved Quality, Stability, and Variation, Tero Karras et al.: http://research.nvidia.com/sites/default/files/pubs/2017-10_Progressive-Growing-of/karras2018iclr-paper.pdf\n",
    "\n",
    "Mode collapse in GANs, Aiden Nibali: http://aiden.nibali.org/blog/2017-01-18-mode-collapse-gans/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n",
      "/Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:526: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:527: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:528: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:529: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:530: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:535: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    }
   ],
   "source": [
    "# Large amount of credit goes to:\n",
    "# https://github.com/keras-team/keras-contrib/blob/master/examples/improved_wgan.py\n",
    "# which I've used as a reference for this implementation\n",
    "\n",
    "# from __future__ import print_function, division\n",
    "\n",
    "from keras.datasets import mnist\n",
    "from keras.layers.merge import _Merge\n",
    "from keras.layers import Input, Dense, Reshape, Flatten, Dropout\n",
    "from keras.layers import 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 RMSprop\n",
    "from functools import partial\n",
    "\n",
    "import keras.backend as K\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import sys\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "class RandomWeightedAverage(_Merge):\n",
    "    \"\"\"Provides a (random) weighted average between real and generated image samples\"\"\"\n",
    "    def _merge_function(self, inputs):\n",
    "        alpha = K.random_uniform((32, 1, 1, 1))\n",
    "        return (alpha * inputs[0]) + ((1 - alpha) * inputs[1])\n",
    "\n",
    "class WGANGP():\n",
    "    def __init__(self):\n",
    "        self.img_rows = 28\n",
    "        self.img_cols = 28\n",
    "        self.channels = 1\n",
    "        self.img_shape = (self.img_rows, self.img_cols, self.channels)\n",
    "        self.latent_dim = 100\n",
    "\n",
    "        # Following parameter and optimizer set as recommended in paper\n",
    "        self.n_critic = 5\n",
    "        optimizer = RMSprop(lr=0.00005)\n",
    "\n",
    "        # Build the generator and critic\n",
    "        self.generator = self.build_generator()\n",
    "        self.critic = self.build_critic()\n",
    "        \n",
    "        #-------------------------------\n",
    "        # Construct Computational Graph\n",
    "        #         for Generator\n",
    "        #-------------------------------\n",
    "\n",
    "        # For the generator we freeze the critic's layers\n",
    "        #self.critic.trainable = False\n",
    "        #self.generator.trainable = True\n",
    "        \n",
    "        # The generator_model is used when we want to train the generator layers.\n",
    "        # As such, we ensure that the critic layers are not trainable.\n",
    "        # Note that once we compile this model, updating .trainable will have no effect within\n",
    "        # it. As such, it won't cause problems if we later set critic.trainable = True\n",
    "        # for the critic_model, as long as we compile the generator_model first.\n",
    "        \n",
    "        for layer in self.critic.layers:\n",
    "            layer.trainable = False\n",
    "        self.critic.trainable = False\n",
    "\n",
    "        # Sampled noise for input to generator\n",
    "        z_gen = Input(shape=(self.latent_dim,))\n",
    "        # Generate images based of noise\n",
    "        img = self.generator(z_gen)\n",
    "        # Discriminator determines validity\n",
    "        valid = self.critic(img)\n",
    "        # Defines generator model\n",
    "        self.generator_model = Model(z_gen, valid)\n",
    "        self.generator_model.compile(loss=self.wasserstein_loss, optimizer=optimizer)\n",
    "\n",
    "        #-------------------------------\n",
    "        # Construct Computational Graph\n",
    "        #       for the Critic\n",
    "        #-------------------------------\n",
    "\n",
    "        # Freeze generator's layers while training critic\n",
    "        #self.generator.trainable = False\n",
    "        \n",
    "        # Now that the generator_model is compiled, we can make the discriminator\n",
    "        # layers trainable.\n",
    "        for layer in self.critic.layers:\n",
    "            layer.trainable = True\n",
    "        for layer in self.generator.layers:\n",
    "            layer.trainable = False\n",
    "        self.critic.trainable = True\n",
    "        self.generator.trainable = False\n",
    "        \n",
    "\n",
    "        # Image input (real sample)\n",
    "        real_img = Input(shape=self.img_shape)\n",
    "\n",
    "        # Noise input\n",
    "        z_disc = Input(shape=(self.latent_dim,))\n",
    "        # Generate image based of noise (fake sample)\n",
    "        fake_img = self.generator(z_disc)\n",
    "\n",
    "        # Discriminator determines validity of the real and fake images\n",
    "        fake = self.critic(fake_img)\n",
    "        valid = self.critic(real_img)\n",
    "\n",
    "        # Construct weighted average between real and fake images\n",
    "        interpolated_img = RandomWeightedAverage()([real_img, fake_img])\n",
    "        # Determine validity of weighted sample\n",
    "        validity_interpolated = self.critic(interpolated_img)\n",
    "\n",
    "        # Use Python partial to provide loss function with additional\n",
    "        # 'averaged_samples' argument\n",
    "        partial_gp_loss = partial(self.gradient_penalty_loss,\n",
    "                          averaged_samples=interpolated_img)\n",
    "        partial_gp_loss.__name__ = 'gradient_penalty' # Keras requires function names\n",
    "\n",
    "        self.critic_model = Model(inputs=[real_img, z_disc],\n",
    "                            outputs=[valid, fake, validity_interpolated])\n",
    "        self.critic_model.compile(loss=[self.wasserstein_loss,\n",
    "                                              self.wasserstein_loss,\n",
    "                                              partial_gp_loss],\n",
    "                                        optimizer=optimizer,\n",
    "                                        loss_weights=[1, 1, 10])\n",
    "        \n",
    "\n",
    "\n",
    "    def gradient_penalty_loss(self, y_true, y_pred, averaged_samples):\n",
    "        \"\"\"\n",
    "        Computes gradient penalty based on prediction and weighted real / fake samples\n",
    "        \"\"\"\n",
    "        gradients = K.gradients(y_pred, averaged_samples)[0]\n",
    "        # compute the euclidean norm by squaring ...\n",
    "        gradients_sqr = K.square(gradients)\n",
    "        #   ... summing over the rows ...\n",
    "        gradients_sqr_sum = K.sum(gradients_sqr,\n",
    "                                  axis=np.arange(1, len(gradients_sqr.shape)))\n",
    "        #   ... and sqrt\n",
    "        gradient_l2_norm = K.sqrt(gradients_sqr_sum)\n",
    "        # compute lambda * (1 - ||grad||)^2 still for each single sample\n",
    "        gradient_penalty = K.square(1 - gradient_l2_norm)\n",
    "        # return the mean as loss over all the batch samples\n",
    "        return K.mean(gradient_penalty)\n",
    "\n",
    "\n",
    "    def wasserstein_loss(self, y_true, y_pred):\n",
    "        return K.mean(y_true * y_pred)\n",
    "\n",
    "    def build_generator(self):\n",
    "\n",
    "        model = Sequential()\n",
    "\n",
    "        model.add(Dense(128 * 7 * 7, activation=\"relu\", input_dim=self.latent_dim))\n",
    "        model.add(Reshape((7, 7, 128)))\n",
    "        model.add(UpSampling2D())\n",
    "        model.add(Conv2D(128, kernel_size=4, padding=\"same\"))\n",
    "        model.add(Activation(\"relu\"))\n",
    "        model.add(UpSampling2D())\n",
    "        model.add(Conv2D(64, kernel_size=4, padding=\"same\"))\n",
    "        model.add(Activation(\"relu\"))\n",
    "        model.add(Conv2D(self.channels, kernel_size=4, padding=\"same\"))\n",
    "        model.add(Activation(\"tanh\"))\n",
    "\n",
    "        model.summary()\n",
    "\n",
    "        #noise = Input(shape=(self.latent_dim,))\n",
    "        #img = model(noise)\n",
    "\n",
    "        return model #Model(noise, img)\n",
    "\n",
    "    def build_critic(self):\n",
    "\n",
    "        model = Sequential()\n",
    "\n",
    "        model.add(Conv2D(16, kernel_size=3, strides=2, input_shape=self.img_shape, padding=\"same\"))\n",
    "        model.add(LeakyReLU(alpha=0.2))\n",
    "        model.add(Dropout(0.25))\n",
    "        model.add(Conv2D(32, kernel_size=3, strides=2, padding=\"same\"))\n",
    "        model.add(LeakyReLU(alpha=0.2))\n",
    "        model.add(Dropout(0.25))\n",
    "        model.add(Conv2D(64, kernel_size=3, strides=2, padding=\"same\"))\n",
    "        model.add(LeakyReLU(alpha=0.2))\n",
    "        model.add(Dropout(0.25))\n",
    "        model.add(Conv2D(128, kernel_size=3, strides=1, padding=\"same\"))\n",
    "        model.add(LeakyReLU(alpha=0.2))\n",
    "        model.add(Dropout(0.25))\n",
    "        model.add(Flatten())\n",
    "        model.add(Dense(1))\n",
    "\n",
    "        model.summary()\n",
    "\n",
    "        #img = Input(shape=self.img_shape)\n",
    "        #validity = model(img)\n",
    "\n",
    "        return model #Model(img, validity)\n",
    "\n",
    "    def train(self, epochs, batch_size, sample_interval=50):\n",
    "\n",
    "        # Load the dataset\n",
    "        (X_train, _), (_, _) = mnist.load_data()\n",
    "\n",
    "        # Rescale -1 to 1\n",
    "        X_train = (X_train.astype(np.float32) - 127.5) / 127.5\n",
    "        X_train = np.expand_dims(X_train, axis=3)\n",
    "\n",
    "        # Adversarial ground truths\n",
    "        valid = -np.ones((batch_size, 1))\n",
    "        fake =  np.ones((batch_size, 1))\n",
    "        dummy = np.zeros((batch_size, 1)) # Dummy gt for gradient penalty\n",
    "        for epoch in range(epochs):\n",
    "\n",
    "            for _ in range(self.n_critic):\n",
    "\n",
    "                # ---------------------\n",
    "                #  Train Discriminator\n",
    "                # ---------------------\n",
    "\n",
    "                # Select a random batch of images\n",
    "                idx = np.random.randint(0, X_train.shape[0], batch_size)\n",
    "                imgs = X_train[idx]\n",
    "                # Sample generator input\n",
    "                noise = np.random.normal(0, 1, (batch_size, self.latent_dim))\n",
    "                # Train the critic\n",
    "                d_loss = self.critic_model.train_on_batch([imgs, noise],\n",
    "                                                                [valid, fake, dummy])\n",
    "\n",
    "            # ---------------------\n",
    "            #  Train Generator\n",
    "            # ---------------------\n",
    "\n",
    "            g_loss = self.generator_model.train_on_batch(noise, valid)\n",
    "\n",
    "            # Plot the progress\n",
    "            print (\"%d [D loss: %f] [G loss: %f]\" % (epoch, d_loss[0], g_loss))\n",
    "\n",
    "            # If at save interval => save generated image samples\n",
    "            if epoch % sample_interval == 0:\n",
    "                self.sample_images(epoch)\n",
    "\n",
    "    def sample_images(self, epoch):\n",
    "        r, c = 5, 5\n",
    "        noise = np.random.normal(0, 1, (r * c, self.latent_dim))\n",
    "        gen_imgs = self.generator.predict(noise)\n",
    "\n",
    "        # Rescale images 0 - 1\n",
    "        gen_imgs = 0.5 * gen_imgs + 0.5\n",
    "\n",
    "        fig, axs = plt.subplots(r, c)\n",
    "        cnt = 0\n",
    "        for i in range(r):\n",
    "            for j in range(c):\n",
    "                axs[i,j].imshow(gen_imgs[cnt, :,:,0], cmap='gray')\n",
    "                axs[i,j].axis('off')\n",
    "                cnt += 1\n",
    "        fig.savefig(\"images/wgangp_images/mnist_%d.png\" % epoch)\n",
    "        plt.close()\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_1 (Dense)              (None, 6272)              633472    \n",
      "_________________________________________________________________\n",
      "reshape_1 (Reshape)          (None, 7, 7, 128)         0         \n",
      "_________________________________________________________________\n",
      "up_sampling2d_1 (UpSampling2 (None, 14, 14, 128)       0         \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 14, 14, 128)       262272    \n",
      "_________________________________________________________________\n",
      "activation_1 (Activation)    (None, 14, 14, 128)       0         \n",
      "_________________________________________________________________\n",
      "up_sampling2d_2 (UpSampling2 (None, 28, 28, 128)       0         \n",
      "_________________________________________________________________\n",
      "conv2d_2 (Conv2D)            (None, 28, 28, 64)        131136    \n",
      "_________________________________________________________________\n",
      "activation_2 (Activation)    (None, 28, 28, 64)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_3 (Conv2D)            (None, 28, 28, 1)         1025      \n",
      "_________________________________________________________________\n",
      "activation_3 (Activation)    (None, 28, 28, 1)         0         \n",
      "=================================================================\n",
      "Total params: 1,027,905\n",
      "Trainable params: 1,027,905\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "WARNING:tensorflow:From /Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py:3368: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d_4 (Conv2D)            (None, 14, 14, 16)        160       \n",
      "_________________________________________________________________\n",
      "leaky_re_lu_1 (LeakyReLU)    (None, 14, 14, 16)        0         \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 14, 14, 16)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_5 (Conv2D)            (None, 7, 7, 32)          4640      \n",
      "_________________________________________________________________\n",
      "leaky_re_lu_2 (LeakyReLU)    (None, 7, 7, 32)          0         \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 7, 7, 32)          0         \n",
      "_________________________________________________________________\n",
      "conv2d_6 (Conv2D)            (None, 4, 4, 64)          18496     \n",
      "_________________________________________________________________\n",
      "leaky_re_lu_3 (LeakyReLU)    (None, 4, 4, 64)          0         \n",
      "_________________________________________________________________\n",
      "dropout_3 (Dropout)          (None, 4, 4, 64)          0         \n",
      "_________________________________________________________________\n",
      "conv2d_7 (Conv2D)            (None, 4, 4, 128)         73856     \n",
      "_________________________________________________________________\n",
      "leaky_re_lu_4 (LeakyReLU)    (None, 4, 4, 128)         0         \n",
      "_________________________________________________________________\n",
      "dropout_4 (Dropout)          (None, 4, 4, 128)         0         \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 2048)              0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 1)                 2049      \n",
      "=================================================================\n",
      "Total params: 99,201\n",
      "Trainable params: 99,201\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "WARNING:tensorflow:From /Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/keras/engine/training.py:479: UserWarning: Discrepancy between trainable weights and collected trainable weights, did you set `model.trainable` without calling `model.compile` after ?\n",
      "  'Discrepancy between trainable weights and collected trainable'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 [D loss: 8.071113] [G loss: -0.000747]\n"
     ]
    }
   ],
   "source": [
    "wgan = WGANGP()\n",
    "wgan.train(epochs=30000, batch_size=32, sample_interval=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n",
      "/Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:526: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:527: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:528: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:529: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:530: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:535: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "Epoch:  0\n",
      "Number of batches:  1093\n",
      "WARNING:tensorflow:From /Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/eclarson/anaconda3/envs/mlenv/lib/python3.6/site-packages/keras/engine/training.py:479: UserWarning: Discrepancy between trainable weights and collected trainable weights, did you set `model.trainable` without calling `model.compile` after ?\n",
      "  'Discrepancy between trainable weights and collected trainable'\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:  1\n",
      "Number of batches:  1093\n",
      "Epoch:  2\n",
      "Number of batches:  1093\n",
      "Epoch:  3\n",
      "Number of batches:  1093\n",
      "Epoch:  4\n",
      "Number of batches:  1093\n",
      "Epoch:  5\n",
      "Number of batches:  1093\n",
      "Epoch:  6\n",
      "Number of batches:  1093\n",
      "Epoch:  7\n",
      "Number of batches:  1093\n",
      "Epoch:  8\n",
      "Number of batches:  1093\n",
      "Epoch:  9\n",
      "Number of batches:  1093\n",
      "Epoch:  10\n",
      "Number of batches:  1093\n",
      "Epoch:  11\n",
      "Number of batches:  1093\n",
      "Epoch:  12\n",
      "Number of batches:  1093\n",
      "Epoch:  13\n",
      "Number of batches:  1093\n",
      "Epoch:  14\n",
      "Number of batches:  1093\n",
      "Epoch:  15\n",
      "Number of batches:  1093\n",
      "Epoch:  16\n",
      "Number of batches:  1093\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-11972fb0a598>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m    306\u001b[0m             discriminator_loss.append(discriminator_model.train_on_batch(\n\u001b[1;32m    307\u001b[0m                 \u001b[0;34m[\u001b[0m\u001b[0mimage_batch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnoise\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 308\u001b[0;31m                 [positive_y, negative_y, dummy_y]))\n\u001b[0m\u001b[1;32m    309\u001b[0m         generator_loss.append(generator_model.train_on_batch(np.random.rand(BATCH_SIZE,\n\u001b[1;32m    310\u001b[0m                                                                             100),\n",
      "\u001b[0;32m~/anaconda3/envs/mlenv/lib/python3.6/site-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mtrain_on_batch\u001b[0;34m(self, x, y, sample_weight, class_weight)\u001b[0m\n\u001b[1;32m   1213\u001b[0m             \u001b[0mins\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0msample_weights\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1214\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_make_train_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1215\u001b[0;31m         \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mins\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1216\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0munpack_singleton\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1217\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/mlenv/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, inputs)\u001b[0m\n\u001b[1;32m   2664\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_legacy_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2665\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2666\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2667\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2668\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mpy_any\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mis_tensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/mlenv/lib/python3.6/site-packages/keras/backend/tensorflow_backend.py\u001b[0m in \u001b[0;36m_call\u001b[0;34m(self, inputs)\u001b[0m\n\u001b[1;32m   2634\u001b[0m                                 \u001b[0msymbol_vals\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2635\u001b[0m                                 session)\n\u001b[0;32m-> 2636\u001b[0;31m         \u001b[0mfetched\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_callable_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0marray_vals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2637\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mfetched\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2638\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/envs/mlenv/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1437\u001b[0m           ret = tf_session.TF_SessionRunCallable(\n\u001b[1;32m   1438\u001b[0m               \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_session\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_session\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_handle\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstatus\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1439\u001b[0;31m               run_metadata_ptr)\n\u001b[0m\u001b[1;32m   1440\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1441\u001b[0m           \u001b[0mproto_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_session\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTF_GetBuffer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_metadata_ptr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "\"\"\"An implementation of the improved WGAN described in https://arxiv.org/abs/1704.00028\n",
    "The improved WGAN has a term in the loss function which penalizes the network if its\n",
    "gradient norm moves away from 1. This is included because the Earth Mover (EM) distance\n",
    "used in WGANs is only easy to calculate for 1-Lipschitz functions (i.e. functions where\n",
    "the gradient norm has a constant upper bound of 1).\n",
    "The original WGAN paper enforced this by clipping weights to very small values\n",
    "[-0.01, 0.01]. However, this drastically reduced network capacity. Penalizing the\n",
    "gradient norm is more natural, but this requires second-order gradients. These are not\n",
    "supported for some tensorflow ops (particularly MaxPool and AveragePool) in the current\n",
    "release (1.0.x), but they are supported in the current nightly builds\n",
    "(1.1.0-rc1 and higher).\n",
    "To avoid this, this model uses strided convolutions instead of Average/Maxpooling for\n",
    "downsampling. If you wish to use pooling operations in your discriminator, please ensure\n",
    "you update Tensorflow to 1.1.0-rc1 or higher. I haven't tested this with Theano at all.\n",
    "The model saves images using pillow. If you don't have pillow, either install it or\n",
    "remove the calls to generate_images.\n",
    "\"\"\"\n",
    "import argparse\n",
    "import os\n",
    "import numpy as np\n",
    "from keras.models import Model, Sequential\n",
    "from keras.layers import Input, Dense, Reshape, Flatten\n",
    "from keras.layers.merge import _Merge\n",
    "from keras.layers.convolutional import Convolution2D, Conv2DTranspose\n",
    "from keras.layers.normalization import BatchNormalization\n",
    "from keras.layers.advanced_activations import LeakyReLU\n",
    "from keras.optimizers import Adam\n",
    "from keras.datasets import mnist\n",
    "from keras import backend as K\n",
    "from functools import partial\n",
    "\n",
    "try:\n",
    "    from PIL import Image\n",
    "except ImportError:\n",
    "    print('This script depends on pillow! '\n",
    "          'Please install it (e.g. with pip install pillow)')\n",
    "    exit()\n",
    "\n",
    "BATCH_SIZE = 64\n",
    "# The training ratio is the number of discriminator updates\n",
    "# per generator update. The paper uses 5.\n",
    "TRAINING_RATIO = 5\n",
    "GRADIENT_PENALTY_WEIGHT = 10  # As per the paper\n",
    "\n",
    "\n",
    "def wasserstein_loss(y_true, y_pred):\n",
    "    \"\"\"Calculates the Wasserstein loss for a sample batch.\n",
    "    The Wasserstein loss function is very simple to calculate. In a standard GAN, the\n",
    "    discriminator has a sigmoid output, representing the probability that samples are\n",
    "    real or generated. In Wasserstein GANs, however, the output is linear with no\n",
    "    activation function! Instead of being constrained to [0, 1], the discriminator wants\n",
    "    to make the distance between its output for real and generated samples as\n",
    "    large as possible.\n",
    "    The most natural way to achieve this is to label generated samples -1 and real\n",
    "    samples 1, instead of the 0 and 1 used in normal GANs, so that multiplying the\n",
    "    outputs by the labels will give you the loss immediately.\n",
    "    Note that the nature of this loss means that it can be (and frequently will be)\n",
    "    less than 0.\"\"\"\n",
    "    return K.mean(y_true * y_pred)\n",
    "\n",
    "\n",
    "def gradient_penalty_loss(y_true, y_pred, averaged_samples,\n",
    "                          gradient_penalty_weight):\n",
    "    \"\"\"Calculates the gradient penalty loss for a batch of \"averaged\" samples.\n",
    "    In Improved WGANs, the 1-Lipschitz constraint is enforced by adding a term to the\n",
    "    loss function that penalizes the network if the gradient norm moves away from 1.\n",
    "    However, it is impossible to evaluate this function at all points in the input\n",
    "    space. The compromise used in the paper is to choose random points on the lines\n",
    "    between real and generated samples, and check the gradients at these points. Note\n",
    "    that it is the gradient w.r.t. the input averaged samples, not the weights of the\n",
    "    discriminator, that we're penalizing!\n",
    "    In order to evaluate the gradients, we must first run samples through the generator\n",
    "    and evaluate the loss. Then we get the gradients of the discriminator w.r.t. the\n",
    "    input averaged samples. The l2 norm and penalty can then be calculated for this\n",
    "    gradient.\n",
    "    Note that this loss function requires the original averaged samples as input, but\n",
    "    Keras only supports passing y_true and y_pred to loss functions. To get around this,\n",
    "    we make a partial() of the function with the averaged_samples argument, and use that\n",
    "    for model training.\"\"\"\n",
    "    # first get the gradients:\n",
    "    #   assuming: - that y_pred has dimensions (batch_size, 1)\n",
    "    #             - averaged_samples has dimensions (batch_size, nbr_features)\n",
    "    # gradients afterwards has dimension (batch_size, nbr_features), basically\n",
    "    # a list of nbr_features-dimensional gradient vectors\n",
    "    gradients = K.gradients(y_pred, averaged_samples)[0]\n",
    "    # compute the euclidean norm by squaring ...\n",
    "    gradients_sqr = K.square(gradients)\n",
    "    #   ... summing over the rows ...\n",
    "    gradients_sqr_sum = K.sum(gradients_sqr,\n",
    "                              axis=np.arange(1, len(gradients_sqr.shape)))\n",
    "    #   ... and sqrt\n",
    "    gradient_l2_norm = K.sqrt(gradients_sqr_sum)\n",
    "    # compute lambda * (1 - ||grad||)^2 still for each single sample\n",
    "    gradient_penalty = gradient_penalty_weight * K.square(1 - gradient_l2_norm)\n",
    "    # return the mean as loss over all the batch samples\n",
    "    return K.mean(gradient_penalty)\n",
    "\n",
    "\n",
    "def make_generator():\n",
    "    \"\"\"Creates a generator model that takes a 100-dimensional noise vector as a \"seed\",\n",
    "    and outputs images of size 28x28x1.\"\"\"\n",
    "    model = Sequential()\n",
    "    model.add(Dense(1024, input_dim=100))\n",
    "    model.add(LeakyReLU())\n",
    "    model.add(Dense(128 * 7 * 7))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(LeakyReLU())\n",
    "    if K.image_data_format() == 'channels_first':\n",
    "        model.add(Reshape((128, 7, 7), input_shape=(128 * 7 * 7,)))\n",
    "        bn_axis = 1\n",
    "    else:\n",
    "        model.add(Reshape((7, 7, 128), input_shape=(128 * 7 * 7,)))\n",
    "        bn_axis = -1\n",
    "    model.add(Conv2DTranspose(128, (5, 5), strides=2, padding='same'))\n",
    "    model.add(BatchNormalization(axis=bn_axis))\n",
    "    model.add(LeakyReLU())\n",
    "    model.add(Convolution2D(64, (5, 5), padding='same'))\n",
    "    model.add(BatchNormalization(axis=bn_axis))\n",
    "    model.add(LeakyReLU())\n",
    "    model.add(Conv2DTranspose(64, (5, 5), strides=2, padding='same'))\n",
    "    model.add(BatchNormalization(axis=bn_axis))\n",
    "    model.add(LeakyReLU())\n",
    "    # Because we normalized training inputs to lie in the range [-1, 1],\n",
    "    # the tanh function should be used for the output of the generator to ensure\n",
    "    # its output also lies in this range.\n",
    "    model.add(Convolution2D(1, (5, 5), padding='same', activation='tanh'))\n",
    "    return model\n",
    "\n",
    "\n",
    "def make_discriminator():\n",
    "    \"\"\"Creates a discriminator model that takes an image as input and outputs a single\n",
    "    value, representing whether the input is real or generated. Unlike normal GANs, the\n",
    "    output is not sigmoid and does not represent a probability! Instead, the output\n",
    "    should be as large and negative as possible for generated inputs and as large and\n",
    "    positive as possible for real inputs.\n",
    "    Note that the improved WGAN paper suggests that BatchNormalization should not be\n",
    "    used in the discriminator.\"\"\"\n",
    "    model = Sequential()\n",
    "    if K.image_data_format() == 'channels_first':\n",
    "        model.add(Convolution2D(64, (5, 5), padding='same', input_shape=(1, 28, 28)))\n",
    "    else:\n",
    "        model.add(Convolution2D(64, (5, 5), padding='same', input_shape=(28, 28, 1)))\n",
    "    model.add(LeakyReLU())\n",
    "    model.add(Convolution2D(128, (5, 5), kernel_initializer='he_normal',\n",
    "                            strides=[2, 2]))\n",
    "    model.add(LeakyReLU())\n",
    "    model.add(Convolution2D(128, (5, 5), kernel_initializer='he_normal', padding='same',\n",
    "                            strides=[2, 2]))\n",
    "    model.add(LeakyReLU())\n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(1024, kernel_initializer='he_normal'))\n",
    "    model.add(LeakyReLU())\n",
    "    model.add(Dense(1, kernel_initializer='he_normal'))\n",
    "    return model\n",
    "\n",
    "\n",
    "def tile_images(image_stack):\n",
    "    \"\"\"Given a stacked tensor of images, reshapes them into a horizontal tiling for\n",
    "    display.\"\"\"\n",
    "    assert len(image_stack.shape) == 3\n",
    "    image_list = [image_stack[i, :, :] for i in range(image_stack.shape[0])]\n",
    "    tiled_images = np.concatenate(image_list, axis=1)\n",
    "    return tiled_images\n",
    "\n",
    "\n",
    "class RandomWeightedAverage(_Merge):\n",
    "    \"\"\"Takes a randomly-weighted average of two tensors. In geometric terms, this\n",
    "    outputs a random point on the line between each pair of input points.\n",
    "    Inheriting from _Merge is a little messy but it was the quickest solution I could\n",
    "    think of. Improvements appreciated.\"\"\"\n",
    "\n",
    "    def _merge_function(self, inputs):\n",
    "        weights = K.random_uniform((BATCH_SIZE, 1, 1, 1))\n",
    "        return (weights * inputs[0]) + ((1 - weights) * inputs[1])\n",
    "\n",
    "\n",
    "def generate_images(generator_model, output_dir, epoch):\n",
    "    \"\"\"Feeds random seeds into the generator and tiles and saves the output to a PNG\n",
    "    file.\"\"\"\n",
    "    test_image_stack = generator_model.predict(np.random.rand(10, 100))\n",
    "    test_image_stack = (test_image_stack * 127.5) + 127.5\n",
    "    test_image_stack = np.squeeze(np.round(test_image_stack).astype(np.uint8))\n",
    "    tiled_output = tile_images(test_image_stack)\n",
    "    tiled_output = Image.fromarray(tiled_output, mode='L')  # L specifies greyscale\n",
    "    outfile = os.path.join(output_dir, 'epoch_{}.png'.format(epoch))\n",
    "    tiled_output.save(outfile)\n",
    "\n",
    "\n",
    "# parser = argparse.ArgumentParser(description=\"Improved Wasserstein GAN \"\n",
    "#                                              \"implementation for Keras.\")\n",
    "# parser.add_argument(\"--output_dir\", \"-o\", required=True,\n",
    "#                     help=\"Directory to output generated files to\")\n",
    "# args = parser.parse_args()\n",
    "\n",
    "# First we load the image data, reshape it and normalize it to the range [-1, 1]\n",
    "(X_train, y_train), (X_test, y_test) = mnist.load_data()\n",
    "X_train = np.concatenate((X_train, X_test), axis=0)\n",
    "if K.image_data_format() == 'channels_first':\n",
    "    X_train = X_train.reshape((X_train.shape[0], 1, X_train.shape[1], X_train.shape[2]))\n",
    "else:\n",
    "    X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], X_train.shape[2], 1))\n",
    "X_train = (X_train.astype(np.float32) - 127.5) / 127.5\n",
    "\n",
    "# Now we initialize the generator and discriminator.\n",
    "generator = make_generator()\n",
    "discriminator = make_discriminator()\n",
    "\n",
    "# The generator_model is used when we want to train the generator layers.\n",
    "# As such, we ensure that the discriminator layers are not trainable.\n",
    "# Note that once we compile this model, updating .trainable will have no effect within\n",
    "# it. As such, it won't cause problems if we later set discriminator.trainable = True\n",
    "# for the discriminator_model, as long as we compile the generator_model first.\n",
    "for layer in discriminator.layers:\n",
    "    layer.trainable = False\n",
    "discriminator.trainable = False\n",
    "generator_input = Input(shape=(100,))\n",
    "generator_layers = generator(generator_input)\n",
    "discriminator_layers_for_generator = discriminator(generator_layers)\n",
    "generator_model = Model(inputs=[generator_input],\n",
    "                        outputs=[discriminator_layers_for_generator])\n",
    "# We use the Adam paramaters from Gulrajani et al.\n",
    "generator_model.compile(optimizer=Adam(0.0001, beta_1=0.5, beta_2=0.9),\n",
    "                        loss=wasserstein_loss)\n",
    "\n",
    "# Now that the generator_model is compiled, we can make the discriminator\n",
    "# layers trainable.\n",
    "for layer in discriminator.layers:\n",
    "    layer.trainable = True\n",
    "for layer in generator.layers:\n",
    "    layer.trainable = False\n",
    "discriminator.trainable = True\n",
    "generator.trainable = False\n",
    "\n",
    "# The discriminator_model is more complex. It takes both real image samples and random\n",
    "# noise seeds as input. The noise seed is run through the generator model to get\n",
    "# generated images. Both real and generated images are then run through the\n",
    "# discriminator. Although we could concatenate the real and generated images into a\n",
    "# single tensor, we don't (see model compilation for why).\n",
    "real_samples = Input(shape=X_train.shape[1:])\n",
    "generator_input_for_discriminator = Input(shape=(100,))\n",
    "generated_samples_for_discriminator = generator(generator_input_for_discriminator)\n",
    "discriminator_output_from_generator = discriminator(generated_samples_for_discriminator)\n",
    "discriminator_output_from_real_samples = discriminator(real_samples)\n",
    "\n",
    "# We also need to generate weighted-averages of real and generated samples,\n",
    "# to use for the gradient norm penalty.\n",
    "averaged_samples = RandomWeightedAverage()([real_samples,\n",
    "                                            generated_samples_for_discriminator])\n",
    "# We then run these samples through the discriminator as well. Note that we never\n",
    "# really use the discriminator output for these samples - we're only running them to\n",
    "# get the gradient norm for the gradient penalty loss.\n",
    "averaged_samples_out = discriminator(averaged_samples)\n",
    "\n",
    "# The gradient penalty loss function requires the input averaged samples to get\n",
    "# gradients. However, Keras loss functions can only have two arguments, y_true and\n",
    "# y_pred. We get around this by making a partial() of the function with the averaged\n",
    "# samples here.\n",
    "partial_gp_loss = partial(gradient_penalty_loss,\n",
    "                          averaged_samples=averaged_samples,\n",
    "                          gradient_penalty_weight=GRADIENT_PENALTY_WEIGHT)\n",
    "# Functions need names or Keras will throw an error\n",
    "partial_gp_loss.__name__ = 'gradient_penalty'\n",
    "\n",
    "# Keras requires that inputs and outputs have the same number of samples. This is why\n",
    "# we didn't concatenate the real samples and generated samples before passing them to\n",
    "# the discriminator: If we had, it would create an output with 2 * BATCH_SIZE samples,\n",
    "# while the output of the \"averaged\" samples for gradient penalty\n",
    "# would have only BATCH_SIZE samples.\n",
    "\n",
    "# If we don't concatenate the real and generated samples, however, we get three\n",
    "# outputs: One of the generated samples, one of the real samples, and one of the\n",
    "# averaged samples, all of size BATCH_SIZE. This works neatly!\n",
    "discriminator_model = Model(inputs=[real_samples,\n",
    "                                    generator_input_for_discriminator],\n",
    "                            outputs=[discriminator_output_from_real_samples,\n",
    "                                     discriminator_output_from_generator,\n",
    "                                     averaged_samples_out])\n",
    "# We use the Adam paramaters from Gulrajani et al. We use the Wasserstein loss for both\n",
    "# the real and generated samples, and the gradient penalty loss for the averaged samples\n",
    "discriminator_model.compile(optimizer=Adam(0.0001, beta_1=0.5, beta_2=0.9),\n",
    "                            loss=[wasserstein_loss,\n",
    "                                  wasserstein_loss,\n",
    "                                  partial_gp_loss])\n",
    "# We make three label vectors for training. positive_y is the label vector for real\n",
    "# samples, with value 1. negative_y is the label vector for generated samples, with\n",
    "# value -1. The dummy_y vector is passed to the gradient_penalty loss function and\n",
    "# is not used.\n",
    "positive_y = np.ones((BATCH_SIZE, 1), dtype=np.float32)\n",
    "negative_y = -positive_y\n",
    "dummy_y = np.zeros((BATCH_SIZE, 1), dtype=np.float32)\n",
    "\n",
    "for epoch in range(100):\n",
    "    np.random.shuffle(X_train)\n",
    "    print(\"Epoch: \", epoch)\n",
    "    print(\"Number of batches: \", int(X_train.shape[0] // BATCH_SIZE))\n",
    "    discriminator_loss = []\n",
    "    generator_loss = []\n",
    "    minibatches_size = BATCH_SIZE * TRAINING_RATIO\n",
    "    for i in range(int(X_train.shape[0] // (BATCH_SIZE * TRAINING_RATIO))):\n",
    "        discriminator_minibatches = X_train[i * minibatches_size:\n",
    "                                            (i + 1) * minibatches_size]\n",
    "        for j in range(TRAINING_RATIO):\n",
    "            image_batch = discriminator_minibatches[j * BATCH_SIZE:\n",
    "                                                    (j + 1) * BATCH_SIZE]\n",
    "            noise = np.random.rand(BATCH_SIZE, 100).astype(np.float32)\n",
    "            discriminator_loss.append(discriminator_model.train_on_batch(\n",
    "                [image_batch, noise],\n",
    "                [positive_y, negative_y, dummy_y]))\n",
    "        generator_loss.append(generator_model.train_on_batch(np.random.rand(BATCH_SIZE,\n",
    "                                                                            100),\n",
    "                                                             positive_y))\n",
    "    # Still needs some code to display losses from the generator and discriminator,\n",
    "    # progress bars, etc.\n",
    "    generate_images(generator, \"images/wgangp_images/\", epoch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You want something similar to this:\n",
    "\n",
    "\n",
    "generator = create_generator(output_shape=some_shape)\n",
    "discriminator = create_discriminator(input_shape=some_shape)\n",
    "\n",
    "Real_image                         = Input(shape=some_shape)\n",
    "Noise_input                        = Input(shape=some_z_shape)\n",
    "Fake_image                         = generator(Noise_input)\n",
    "Discriminator_real_out             = discriminator(Real_image)\n",
    "Discriminator_fake_out             = discriminator(Fake_image)\n",
    "\n",
    "Discriminator_fake_average_out = K.mean(Discriminator_fake_out, axis=0)\n",
    "Discriminator_real_average_out = K.mean(Discriminator_real_out, axis=0)\n",
    "\n",
    "def insert_your_custom_loss_here(y_true, y_pred):\n",
    "    return K.mean(K.square(Discriminator_real_out - Discriminator_fake_average_out))\n",
    "\n",
    "generator_train = Model([Noise_input, Real_image], [Discriminator_real_out, Discriminator_fake_out])\n",
    "discriminator.trainable=False\n",
    "generator_train.compile(OPT, loss=[insert_your_custom_loss_here, 'binary_cross_entrpy'])\n",
    "\n",
    "\n",
    "# Then you can do something like the folliwng:\n",
    "generator_train.train_on_batch([noise, image_batch], misleading_y)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}