ee046202_tutorial_09_deep_unsupervised_vae_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# <img src=\"https://img.icons8.com/dusk/64/000000/artificial-intelligence.png\" style=\"height:50px;display:inline\"> EE 046202 - Technion - Unsupervised Learning & Data Analysis\n",
    "---\n",
    "\n",
    "#### <a href=\"https://taldatech.github.io\">Tal Daniel</a>\n",
    "\n",
    "## Tutorial 09 - Deep Unsupervised Learning - Variational Autoencoder (VAE) - Part 2\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <img src=\"https://img.icons8.com/bubbles/50/000000/checklist.png\" style=\"height:50px;display:inline\"> Agenda\n",
    "---\n",
    "\n",
    "* [Recap](#-Recap)\n",
    "* [Implementation in PyTorch](#-VAE-Implementation)\n",
    "    * [Architecture](#-VAE-Implementation)\n",
    "    * [Reparameterization Trick](#-The-Reparameterization-Trick)\n",
    "    * [Encoder](#-Encoder)\n",
    "    * [Decoder](#-Decoder)\n",
    "    * [Assembling the VAE](#-VAE,-Assemble!-(Putting-It-All-Together))\n",
    "    * [Loss Function](#-The-Loss-Function)\n",
    "* [Example on MNIST](#-Example---VAE-On-The-MNIST-Dataset)\n",
    "    * [Interpolation in the Latent Space](#-Interpolation-in-the-Latent-Space)\n",
    "    * [t-SNE on the Latent Space](#-Latent-Space-Representation-with-t-SNE)\n",
    "* [Recommended Videos](#-Recommended-Videos)\n",
    "* [Credits](#-Credits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# imports for the tutorial\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "import time\n",
    "\n",
    "# pytorch imports\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "import torchvision\n",
    "\n",
    "# sklearn imports\n",
    "from sklearn.manifold import TSNE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## <img src=\"https://img.icons8.com/dusk/64/000000/rewind.png\" style=\"height:50px;display:inline\"> Recap\n",
    "---\n",
    "#### Notations\n",
    "---\n",
    "1. $X$ - the data we want to model (e.g. images of dogs)\n",
    "2. $z$ - the latent variable (this is the *imagination*, the hidden variable that describes the data, we have seen this before)\n",
    "3. $p_{\\theta}(X)$ - the parameterized probability distribution of the data (e.g. the distribution of all dogs' images in the world). Also, the **evidence**.\n",
    "4. $p(z)$ - the probability distribution of the latent variables (the source of the imagination, the brain in this case or the distribution of dogs' images feaures/hidden representations). The **prior**.\n",
    "5. $p_{\\theta}(X|z)$ - the parameterized distribution of data generation **given latent variable** (given the features we want the dog to have, the probability of images that satisfy these conditions, turning imagination to real image). The **likelihood** (remember MLE?).\n",
    "6. $p_{\\theta}(z|X)$ - the parameterized distribution of latent variables **given data** (given the image of dog, the probability of latent features that satisfy this image). The **posterior**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Objective\n",
    "----\n",
    "* The optimization problem: make the simpler distribution, $q_{\\phi}(z|X)$ as closer as possible to $p_{\\theta}(z|X)$.\n",
    "* The **KL-divergence** is formulated as follows: $$ D_{KL}[q_{\\phi}(z|X) || p_{\\theta}(z|X)] = \\mathbb{E}_{q_{\\phi}(z|X)}[\\log \\frac{q_{\\phi}(z|X)}{p_{\\theta}(z|X)}]  $$\n",
    "    * $\\mathbb{E}_{q_{\\phi}(z|X)}[\\log \\frac{q_{phi}(z|X)}{p_{\\theta}(z|X)}] = \\sum_z q_{phi}(z|X) \\log\\frac{q_{\\phi}(z|X)}{p_{\\theta}(z|X)} $\n",
    "$$\\mathbb{E}_{q_{\\phi}(z|X)}[\\log \\frac{q_{\\phi}(z|X)}{p_{\\theta}(z|X)}] =  \\mathbb{E}_{q_{\\phi}(z|X)}[\\log q_{\\phi}(z|X) - \\log p_{\\theta}(z|X)]$$\n",
    "\n",
    "Using **Bayes' Rule**:\n",
    "\n",
    "$$\\rightarrow D_{KL}[q_{\\phi}(z|X) || p_{\\theta}(z|X)] =  \\mathbb{E}_{q_{\\phi}(z|X)}[\\log q_{\\phi}(z|X) - \\log \\frac{p_{\\theta}(X|z)p(z)}{p_{\\theta}(X)}]$$ $$ = \\mathbb{E}_{q_{\\phi}(z|X)}[\\log q_{\\phi}(z|X) - (\\log p_{\\theta}(X|z) + \\log p(z) - \\log p_{\\theta}(X))] $$ $$ = \\mathbb{E}_{q_{\\phi}(z|X)}[\\log q_{\\phi}(z|X) -\\log p_{\\theta}(X|z) - \\log p(z) + \\log p_{\\theta}(X))] $$\n",
    "\n",
    "* Notice that the expecation is over $z$ and $p_{\\theta}(X)$ does not depend on $z$:\n",
    "\n",
    "$$\\rightarrow  D_{KL}[q_{\\phi}(z|X) || p_{\\theta}(z|X)] = \\mathbb{E}_{q_{\\phi}(z|X)}[\\log q_{\\phi}(z|X) -\\log p_{\\theta}(X|z) - \\log p(z)] + \\log p_{\\theta}(X)$$ $$ \\log p_{\\theta}(X) \\geq \\mathbb{E}_{q_{\\phi}(z|X)}[\\log p_{\\theta}(X|z)] - D_{KL}[q_{\\phi}(z|X) || p(Z)] = ELBO $$\n",
    "\n",
    "* **Loss Function**: $$ \\mathcal{L}_{VAE} = -ELBO(x;\\phi, \\theta) = -\\mathbb{E}_{q_{\\phi}(z|X)}[\\log p_{\\theta}(X|z)] + D_{KL}[q_{\\phi}(z|X)|| p(z)]  $$\n",
    "* **KL-Divergence Closed-form Solution**: \n",
    "    * Having:\n",
    "        * $z \\sim \\mathcal{N}(0,1)$\n",
    "        * $z|X \\sim \\mathcal{N}(\\mu(X), \\Sigma(X))$\n",
    "\n",
    "        $$ D_{KL}[q_{\\phi}(z|X)|| p_{\\theta}(z)] = \\frac{1}{2}\\sum_{i=1}^d[\\Sigma(X)_{ii} +\\mu(X)_i^2 -1 -\\log \\Sigma(X)_{ii}] $$\n",
    "*  **Reconstruction Loss**: $\\mathbb{E}_{q_{\\phi}(z|X)}[\\log p_{\\theta}(X|z)]$ - this is also called the **log-likelihood** of $X$ under $z$. Maximizing the likelihood is a well-known concept from Machine Learning course, as **Maximum Likelihood Estimation (MLE)**. You have seen this many times in *supervised* learning settings like *Linear Regression* or *Logistic Regression*. Maximizing the likelihood is equivalent to *minimizing* the **negative log-likelihood** (NLL)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"./assets/vae_lilian_weng.png\" style=\"height:300px\">\n",
    "\n",
    "* <a href=\"https://lilianweng.github.io/lil-log/2018/08/12/from-autoencoder-to-beta-vae.html#beta-vae\">Image by Lilian Weng</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <img src=\"https://img.icons8.com/color/96/000000/code.png\" style=\"height:50px;display:inline\"> VAE Implementation\n",
    "---\n",
    "We will now implement the VAE components using PyTorch. The general structure of the network: \n",
    "<img src='./assets/tut_xv_nn_arch.png' style=\"height:400px\">\n",
    "And remember that we need to implement the **reparameterization trick**:\n",
    "<img src='./assets/tut_xv_reparameter.png' style=\"height:300px\">\n",
    "\n",
    "* Note: we are going to use a simple architecture since we are going to work with a simple dataset, but more difficult datasets require more complex architectures that use convolutional layers, batch normalization layers and etc..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### <img src=\"https://img.icons8.com/office/80/000000/magic-lamp.png\" style=\"height:30px;display:inline\"> The Reparameterization Trick\n",
    "---\n",
    "We will first implement a function that takes the mean $\\mu(x)$ and the variance $\\Sigma(X)$ and outputs $z \\sim \\mathcal{N}(\\mu(X), \\Sigma(X))$ using the reparemeterization trick so that we can backpropagate the gradients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# reparametrization trick\n",
    "def reparameterize(mu, logvar, device=torch.device(\"cpu\")):\n",
    "    \"\"\"\n",
    "    This function applies the reparameterization trick:\n",
    "    z = mu(X) + sigma(X)^0.5 * epsilon, where epsilon ~ N(0,I)\n",
    "    :param mu: mean of x\n",
    "    :param logvar: log variance of x\n",
    "    :param device: device to perform calculations on\n",
    "    :return z: the sampled latent variable\n",
    "    \"\"\"\n",
    "    std = torch.exp(0.5 * logvar)\n",
    "    eps = torch.randn_like(std).to(device)\n",
    "    return mu + eps * std"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### <img src=\"https://img.icons8.com/dusk/64/000000/lock-2.png\" style=\"height:30px;display:inline\"> Encoder\n",
    "---\n",
    "* The encoder takes the high-dimensional data, $X \\in \\mathcal{R}^D$, and encodes in a lower-dimensional latent space vector, $z \\in \\mathcal{R}^d$, that is, we model $q_{\\phi}(z|X)$. \n",
    "* Since we are in a *variational* environment, and we model a distrubution $q_{\\phi}$, the outputs of the encoder are the mean, $\\mu(X) \\in \\mathcal{R}^d$ and the co-variance, $\\Sigma(X) \\in \\mathcal{R}^d$. \n",
    "    * Remember that since we assume independce between the latent variables, the co-variance matrix is diagonal and we can represent it as a vector in $\\mathcal{R}^d$, where each value represents the variance (the $ii^{th}$ element in the co-variance matrix)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# encoder - q_{\\phi}(z|X)\n",
    "class VaeEncoder(torch.nn.Module):\n",
    "    \"\"\"\n",
    "       This class builds the encoder for the VAE\n",
    "       :param x_dim: input dimensions\n",
    "       :param hidden_size: hidden layer size\n",
    "       :param z_dim: latent dimensions\n",
    "       :param device: cpu or gpu\n",
    "       \"\"\"\n",
    "\n",
    "    def __init__(self, x_dim=28*28, hidden_size=256, z_dim=10, device=torch.device(\"cpu\")):\n",
    "        super(VaeEncoder, self).__init__()\n",
    "        self.x_dim = x_dim\n",
    "        self.hidden_size = hidden_size\n",
    "        self.z_dim = z_dim\n",
    "        self.device = device\n",
    "        \n",
    "        self.features = nn.Sequential(nn.Linear(x_dim, self.hidden_size),\n",
    "                                      nn.ReLU())\n",
    "        \n",
    "        self.fc1 = nn.Linear(self.hidden_size, self.z_dim, bias=True)  # fully-connected to output mu\n",
    "        self.fc2 = nn.Linear(self.hidden_size, self.z_dim, bias=True)  # fully-connected to output logvar\n",
    "\n",
    "\n",
    "    def bottleneck(self, h):\n",
    "        \"\"\"\n",
    "        This function takes features from the encoder and outputs mu, log-var and a latent space vector z\n",
    "        :param h: features from the encoder\n",
    "        :return: z, mu, log-variance\n",
    "        \"\"\"\n",
    "        mu, logvar = self.fc1(h), self.fc2(h)\n",
    "        # use the reparametrization trick as torch.normal(mu, logvar.exp()) is not differentiable\n",
    "        z = reparameterize(mu, logvar, device=self.device)\n",
    "        return z, mu, logvar\n",
    "\n",
    "    def forward(self, x):\n",
    "        \"\"\"\n",
    "        This is the function called when doing the forward pass:\n",
    "        z, mu, logvar = VaeEncoder(X)\n",
    "        \"\"\"\n",
    "        h = self.features(x)\n",
    "        z, mu, logvar = self.bottleneck(h)\n",
    "        return z, mu, logvar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### <img src=\"https://img.icons8.com/dusk/64/000000/unlock-2.png\" style=\"height:30px;display:inline\"> Decoder\n",
    "---\n",
    "* The decoder takes a lower-dimensional latent space vector, $z \\in \\mathcal{R}^d$ and decodes it to a high-dimensional *reconstruction* data, $\\tilde{X} \\in \\mathcal{R}^D$ , that is, we model $p_{\\theta}(X|z)$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# decoder - p_{\\theta}(x|z)\n",
    "class VaeDecoder(torch.nn.Module):\n",
    "    \"\"\"\n",
    "       This class builds the decoder for the VAE\n",
    "       :param x_dim: input dimensions\n",
    "       :param hidden_size: hidden layer size\n",
    "       :param z_dim: latent dimensions\n",
    "       \"\"\"\n",
    "\n",
    "    def __init__(self, x_dim=28*28, hidden_size=256, z_dim=10):\n",
    "        super(VaeDecoder, self).__init__()\n",
    "        self.x_dim = x_dim\n",
    "        self.hidden_size = hidden_size\n",
    "        self.z_dim = z_dim\n",
    "        \n",
    "        self.decoder = nn.Sequential(nn.Linear(self.z_dim, self.hidden_size),\n",
    "                                     nn.ReLU(),\n",
    "                                     nn.Linear(self.hidden_size, self.x_dim),\n",
    "                                     nn.Sigmoid())\n",
    "        # why we use sigmoid? becaue the pixel values of images are in [0,1] and sigmoid(x) does just that!\n",
    "        # however, you don't have to use that (see what happens without it).\n",
    "\n",
    "\n",
    "    def forward(self, x):\n",
    "        \"\"\"\n",
    "        This is the function called when doing the forward pass:\n",
    "        x_reconstruction = VaeDecoder(z)\n",
    "        \"\"\"\n",
    "        x = self.decoder(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### <img src=\"https://img.icons8.com/officel/80/000000/avengers.png\" style=\"height:30px;display:inline\"> VAE, Assemble! (Putting It All Together)\n",
    "---\n",
    "We now want to have an end-to-end encoder-decoder model that does everything with one line of code, and we also want the ability to generate new samples (that is, sample a random vector from the unit normal distribution and decode it - without encoding!)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Vae(torch.nn.Module):\n",
    "    def __init__(self, x_dim=28*28, z_dim=10, hidden_size=256, device=torch.device(\"cpu\")):\n",
    "        super(Vae, self).__init__()\n",
    "        self.device = device\n",
    "        self.z_dim = z_dim\n",
    "\n",
    "        self.encoder = VaeEncoder(x_dim, hidden_size, z_dim=z_dim, device=device)\n",
    "        self.decoder = VaeDecoder(x_dim, hidden_size, z_dim=z_dim)\n",
    "\n",
    "    def encode(self, x):\n",
    "        z, mu, logvar = self.encoder(x)\n",
    "        return z, mu, logvar\n",
    "\n",
    "    def decode(self, z):\n",
    "        x = self.decoder(z)\n",
    "        return x\n",
    "\n",
    "    def sample(self, num_samples=1):\n",
    "        \"\"\"\n",
    "        This functions generates new data by sampling random variables and decoding them.\n",
    "        Vae.sample() actually generates new data!\n",
    "        Sample z ~ N(0,1)\n",
    "        \"\"\"\n",
    "        z = torch.randn(num_samples, self.z_dim).to(self.device)\n",
    "        return self.decode(z)\n",
    "\n",
    "    def forward(self, x):\n",
    "        \"\"\"\n",
    "        This is the function called when doing the forward pass:\n",
    "        return x_recon, mu, logvar, z = Vae(X)\n",
    "        \"\"\"\n",
    "        z, mu, logvar = self.encode(x)\n",
    "        x_recon = self.decode(z)\n",
    "        return x_recon, mu, logvar, z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### <img src=\"https://img.icons8.com/dusk/64/000000/bearish.png\" style=\"height:30px;display:inline\"> The Loss Function\n",
    "---\n",
    "The loss function is composed of the *reconstruction loss* and the *KL-divergence*: \n",
    "$$ \\mathcal{L}_{VAE} = -\\mathbb{E}_{q_{\\phi}(z|X)}[\\log p_{\\theta}(X|z)] + D_{KL}[q_{\\phi}(z|X)|| p(z)] = ReconLoss(\\tilde{x}, x) +  \\frac{1}{2}\\sum_{i=1}^d[\\Sigma(X)_{ii} +\\mu(X)_i^2 -1 -\\log \\Sigma(X)_{ii}]$$\n",
    "\n",
    "* **Reconstruction Loss**:\n",
    "    * For images, we will use <a href=\"https://ml-cheatsheet.readthedocs.io/en/latest/loss_functions.html#cross-entropy\">Binary Cross Entropy (BCE) </a>, as the values of the pixels are between [0,1] (normalized). There are other alternatives, like \"perceptual loss\", MSE or MAE (see below).\n",
    "    * For continuous inputs, we can use $L_1$ (MAE) or $L_2$ (MSE). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def loss_function(recon_x, x, mu, logvar, loss_type='bce'):\n",
    "    \"\"\"\n",
    "    This function calculates the loss of the VAE.\n",
    "    loss = reconstruction_loss - 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)\n",
    "    :param recon_x: the reconstruction from the decoder\n",
    "    :param x: the original input\n",
    "    :param mu: the mean given X, from the encoder\n",
    "    :param logvar: the log-variance given X, from the encoder\n",
    "    :param loss_type: type of loss function - 'mse', 'l1', 'bce'\n",
    "    :return: VAE loss\n",
    "    \"\"\"\n",
    "    if loss_type == 'mse':\n",
    "        recon_error = F.mse_loss(recon_x, x, reduction='sum')\n",
    "    elif loss_type == 'l1':\n",
    "        recon_error = F.l1_loss(recon_x, x, reduction='sum')\n",
    "    elif loss_type == 'bce':\n",
    "        recon_error = F.binary_cross_entropy(recon_x, x, reduction='sum')\n",
    "    else:\n",
    "        raise NotImplementedError\n",
    "\n",
    "    # see Appendix B from VAE paper:\n",
    "    # Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014\n",
    "    # https://arxiv.org/abs/1312.6114\n",
    "    # 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)\n",
    "    kl = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\n",
    "    return (recon_error + kl) / x.size(0)  # normalize by batch_size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <img src=\"https://img.icons8.com/bubbles/50/000000/hand-with-pen.png\" style=\"height:50px;display:inline\"> Example - VAE On The MNIST Dataset\n",
    "----\n",
    "The MNIST database of handwritten digits has a training set of 60,000 examples, and a test set of 10,000 examples. It is a subset of a larger set available from NIST. The digits have been size-normalized and centered in a fixed-size image.\n",
    "We will now build the training loop of the VAE and learn an approximation to the hand-written digits distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# let's load the dataset and see some examples\n",
    "\n",
    "# in order to create batches of the data, we create a Dataset and a DataLoader, which takes care of:\n",
    "# 1. pre-processing the images to tensors with values in [0,1]\n",
    "# 2. shuffling the data, so we add randomness as learned in ML\n",
    "# 3. if the data size is not divisible by the batch size, we can drop the last batch \n",
    "# (so the batches are always of the same size)\n",
    "\n",
    "# define pre-procesing transformation to use\n",
    "transform = torchvision.transforms.ToTensor()\n",
    "\n",
    "train_data = torchvision.datasets.MNIST('./datasets/', train=True, transform=transform,\n",
    "                                        target_transform=None, download=True)\n",
    "test_data = torchvision.datasets.MNIST('./datasets/', train=False, transform=transform,\n",
    "                                       target_transform=None, download=True)\n",
    "\n",
    "\n",
    "\n",
    "sample_dataloader = DataLoader(train_data, batch_size=6, shuffle=True, drop_last=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(8 ,5))\n",
    "samples, labels = next(iter(sample_dataloader))\n",
    "for i in range(samples.size(0)):\n",
    "    ax = fig.add_subplot(2, 3, i + 1)\n",
    "    ax.imshow(samples[i][0, :, :].data.cpu().numpy(), cmap='gray')\n",
    "    title = \"digit: \" + str(labels[i].data.cpu().item())\n",
    "    ax.set_title(title)\n",
    "    ax.set_axis_off()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### <img src=\"https://img.icons8.com/dusk/50/000000/exercise.png\" style=\"height:30px;display:inline\"> The VAE Training Loop\n",
    "---\n",
    "We will now build the training loop of the VAE in PyTorch. Pay attention to the order of each function, it is very important in PyTorch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# define hyper-parameters\n",
    "BATCH_SIZE = 128  # usually 32/64/128/256\n",
    "LEARNING_RATE = 1e-3  # for the gradient optimizer\n",
    "NUM_EPOCHS = 150  # how many epochs to run?\n",
    "HIDDEN_SIZE = 256  # size of the hidden layers in the networks\n",
    "X_DIM = 28 * 28  # size of the input dimension\n",
    "Z_DIM = 10  # size of the latent dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running calculations on:  cuda:0\n",
      "epoch: 0 training loss: 171.84777 epoch time: 7.842 sec\n",
      "epoch: 1 training loss: 128.69239 epoch time: 7.625 sec\n",
      "epoch: 2 training loss: 122.78445 epoch time: 7.774 sec\n",
      "epoch: 3 training loss: 119.74014 epoch time: 7.808 sec\n",
      "epoch: 4 training loss: 117.81168 epoch time: 7.726 sec\n",
      "epoch: 5 training loss: 116.45555 epoch time: 7.780 sec\n",
      "epoch: 6 training loss: 115.35806 epoch time: 7.660 sec\n",
      "epoch: 7 training loss: 114.56222 epoch time: 7.645 sec\n",
      "epoch: 8 training loss: 113.82657 epoch time: 7.708 sec\n",
      "epoch: 9 training loss: 113.21288 epoch time: 7.673 sec\n",
      "epoch: 10 training loss: 112.67187 epoch time: 7.772 sec\n",
      "epoch: 11 training loss: 112.20706 epoch time: 7.669 sec\n",
      "epoch: 12 training loss: 111.83337 epoch time: 7.681 sec\n",
      "epoch: 13 training loss: 111.46434 epoch time: 7.642 sec\n",
      "epoch: 14 training loss: 111.14702 epoch time: 7.829 sec\n",
      "epoch: 15 training loss: 110.86055 epoch time: 7.660 sec\n",
      "epoch: 16 training loss: 110.57215 epoch time: 7.662 sec\n",
      "epoch: 17 training loss: 110.28147 epoch time: 7.639 sec\n",
      "epoch: 18 training loss: 110.04906 epoch time: 7.883 sec\n",
      "epoch: 19 training loss: 109.85175 epoch time: 7.645 sec\n",
      "epoch: 20 training loss: 109.66326 epoch time: 7.672 sec\n",
      "epoch: 21 training loss: 109.46986 epoch time: 7.629 sec\n",
      "epoch: 22 training loss: 109.28426 epoch time: 7.678 sec\n",
      "epoch: 23 training loss: 109.12090 epoch time: 7.636 sec\n",
      "epoch: 24 training loss: 108.94051 epoch time: 7.623 sec\n",
      "epoch: 25 training loss: 108.80147 epoch time: 7.698 sec\n",
      "epoch: 26 training loss: 108.66099 epoch time: 7.756 sec\n",
      "epoch: 27 training loss: 108.53297 epoch time: 7.658 sec\n",
      "epoch: 28 training loss: 108.42440 epoch time: 7.610 sec\n",
      "epoch: 29 training loss: 108.30579 epoch time: 7.680 sec\n",
      "epoch: 30 training loss: 108.18119 epoch time: 7.617 sec\n",
      "epoch: 31 training loss: 108.06430 epoch time: 7.724 sec\n",
      "epoch: 32 training loss: 107.97036 epoch time: 7.636 sec\n",
      "epoch: 33 training loss: 107.86317 epoch time: 8.004 sec\n",
      "epoch: 34 training loss: 107.78109 epoch time: 7.914 sec\n",
      "epoch: 35 training loss: 107.68400 epoch time: 7.731 sec\n",
      "epoch: 36 training loss: 107.61546 epoch time: 7.759 sec\n",
      "epoch: 37 training loss: 107.50388 epoch time: 7.813 sec\n",
      "epoch: 38 training loss: 107.44395 epoch time: 7.651 sec\n",
      "epoch: 39 training loss: 107.34560 epoch time: 7.745 sec\n",
      "epoch: 40 training loss: 107.27498 epoch time: 8.247 sec\n",
      "epoch: 41 training loss: 107.20559 epoch time: 8.170 sec\n",
      "epoch: 42 training loss: 107.14346 epoch time: 8.016 sec\n",
      "epoch: 43 training loss: 107.07263 epoch time: 8.166 sec\n",
      "epoch: 44 training loss: 107.01250 epoch time: 7.900 sec\n",
      "epoch: 45 training loss: 106.96018 epoch time: 7.876 sec\n",
      "epoch: 46 training loss: 106.90081 epoch time: 7.882 sec\n",
      "epoch: 47 training loss: 106.84647 epoch time: 7.771 sec\n",
      "epoch: 48 training loss: 106.79369 epoch time: 8.149 sec\n",
      "epoch: 49 training loss: 106.70217 epoch time: 8.143 sec\n",
      "epoch: 50 training loss: 106.66743 epoch time: 8.199 sec\n",
      "epoch: 51 training loss: 106.60985 epoch time: 7.750 sec\n",
      "epoch: 52 training loss: 106.57071 epoch time: 7.985 sec\n",
      "epoch: 53 training loss: 106.51574 epoch time: 8.312 sec\n",
      "epoch: 54 training loss: 106.48122 epoch time: 8.811 sec\n",
      "epoch: 55 training loss: 106.44102 epoch time: 9.061 sec\n",
      "epoch: 56 training loss: 106.40275 epoch time: 13.830 sec\n",
      "epoch: 57 training loss: 106.31404 epoch time: 8.314 sec\n",
      "epoch: 58 training loss: 106.26953 epoch time: 8.260 sec\n",
      "epoch: 59 training loss: 106.24339 epoch time: 7.720 sec\n",
      "epoch: 60 training loss: 106.21802 epoch time: 7.762 sec\n",
      "epoch: 61 training loss: 106.16079 epoch time: 7.869 sec\n",
      "epoch: 62 training loss: 106.15153 epoch time: 7.929 sec\n",
      "epoch: 63 training loss: 106.11558 epoch time: 8.092 sec\n",
      "epoch: 64 training loss: 106.05807 epoch time: 8.271 sec\n",
      "epoch: 65 training loss: 106.07709 epoch time: 8.422 sec\n",
      "epoch: 66 training loss: 106.01839 epoch time: 8.946 sec\n",
      "epoch: 67 training loss: 105.93994 epoch time: 8.047 sec\n",
      "epoch: 68 training loss: 105.92013 epoch time: 8.151 sec\n",
      "epoch: 69 training loss: 105.90470 epoch time: 8.121 sec\n",
      "epoch: 70 training loss: 105.83137 epoch time: 8.442 sec\n",
      "epoch: 71 training loss: 105.84895 epoch time: 8.035 sec\n",
      "epoch: 72 training loss: 105.80781 epoch time: 7.754 sec\n",
      "epoch: 73 training loss: 105.78372 epoch time: 7.860 sec\n",
      "epoch: 74 training loss: 105.75193 epoch time: 8.152 sec\n",
      "epoch: 75 training loss: 105.74861 epoch time: 7.931 sec\n",
      "epoch: 76 training loss: 105.72887 epoch time: 7.948 sec\n",
      "epoch: 77 training loss: 105.67473 epoch time: 7.935 sec\n",
      "epoch: 78 training loss: 105.66093 epoch time: 7.891 sec\n",
      "epoch: 79 training loss: 105.60130 epoch time: 7.673 sec\n",
      "epoch: 80 training loss: 105.63635 epoch time: 7.712 sec\n",
      "epoch: 81 training loss: 105.53343 epoch time: 7.683 sec\n",
      "epoch: 82 training loss: 105.53965 epoch time: 8.461 sec\n",
      "epoch: 83 training loss: 105.54196 epoch time: 7.819 sec\n",
      "epoch: 84 training loss: 105.48760 epoch time: 7.793 sec\n",
      "epoch: 85 training loss: 105.46871 epoch time: 7.776 sec\n",
      "epoch: 86 training loss: 105.44570 epoch time: 7.801 sec\n",
      "epoch: 87 training loss: 105.42324 epoch time: 7.864 sec\n",
      "epoch: 88 training loss: 105.40410 epoch time: 8.129 sec\n",
      "epoch: 89 training loss: 105.41238 epoch time: 7.855 sec\n",
      "epoch: 90 training loss: 105.36060 epoch time: 7.779 sec\n",
      "epoch: 91 training loss: 105.34268 epoch time: 7.679 sec\n",
      "epoch: 92 training loss: 105.33472 epoch time: 7.725 sec\n",
      "epoch: 93 training loss: 105.31941 epoch time: 7.680 sec\n",
      "epoch: 94 training loss: 105.25264 epoch time: 8.079 sec\n",
      "epoch: 95 training loss: 105.25664 epoch time: 7.830 sec\n",
      "epoch: 96 training loss: 105.23884 epoch time: 7.729 sec\n",
      "epoch: 97 training loss: 105.24771 epoch time: 7.838 sec\n",
      "epoch: 98 training loss: 105.18528 epoch time: 7.851 sec\n",
      "epoch: 99 training loss: 105.17426 epoch time: 7.761 sec\n",
      "epoch: 100 training loss: 105.16605 epoch time: 7.840 sec\n",
      "epoch: 101 training loss: 105.17681 epoch time: 7.814 sec\n",
      "epoch: 102 training loss: 105.13540 epoch time: 7.704 sec\n",
      "epoch: 103 training loss: 105.11075 epoch time: 7.695 sec\n",
      "epoch: 104 training loss: 105.10130 epoch time: 7.815 sec\n",
      "epoch: 105 training loss: 105.04798 epoch time: 7.683 sec\n",
      "epoch: 106 training loss: 105.04240 epoch time: 7.764 sec\n",
      "epoch: 107 training loss: 105.08118 epoch time: 7.655 sec\n",
      "epoch: 108 training loss: 105.01203 epoch time: 7.728 sec\n",
      "epoch: 109 training loss: 104.99548 epoch time: 7.885 sec\n",
      "epoch: 110 training loss: 104.96709 epoch time: 7.770 sec\n",
      "epoch: 111 training loss: 104.96980 epoch time: 7.729 sec\n",
      "epoch: 112 training loss: 104.97029 epoch time: 7.729 sec\n",
      "epoch: 113 training loss: 104.94572 epoch time: 7.780 sec\n",
      "epoch: 114 training loss: 104.93574 epoch time: 7.658 sec\n",
      "epoch: 115 training loss: 104.91825 epoch time: 7.704 sec\n",
      "epoch: 116 training loss: 104.90452 epoch time: 7.692 sec\n",
      "epoch: 117 training loss: 104.89628 epoch time: 7.758 sec\n",
      "epoch: 118 training loss: 104.84048 epoch time: 7.668 sec\n",
      "epoch: 119 training loss: 104.82133 epoch time: 7.742 sec\n",
      "epoch: 120 training loss: 104.82935 epoch time: 7.649 sec\n",
      "epoch: 121 training loss: 104.81333 epoch time: 7.725 sec\n",
      "epoch: 122 training loss: 104.78670 epoch time: 7.676 sec\n",
      "epoch: 123 training loss: 104.76939 epoch time: 7.726 sec\n",
      "epoch: 124 training loss: 104.78630 epoch time: 7.681 sec\n",
      "epoch: 125 training loss: 104.75781 epoch time: 7.750 sec\n",
      "epoch: 126 training loss: 104.75630 epoch time: 7.681 sec\n",
      "epoch: 127 training loss: 104.71424 epoch time: 7.722 sec\n",
      "epoch: 128 training loss: 104.73129 epoch time: 7.672 sec\n",
      "epoch: 129 training loss: 104.69816 epoch time: 7.737 sec\n",
      "epoch: 130 training loss: 104.70272 epoch time: 7.648 sec\n",
      "epoch: 131 training loss: 104.70613 epoch time: 7.715 sec\n",
      "epoch: 132 training loss: 104.68254 epoch time: 7.672 sec\n",
      "epoch: 133 training loss: 104.63357 epoch time: 7.705 sec\n",
      "epoch: 134 training loss: 104.65751 epoch time: 7.660 sec\n",
      "epoch: 135 training loss: 104.62752 epoch time: 7.688 sec\n",
      "epoch: 136 training loss: 104.60925 epoch time: 7.667 sec\n",
      "epoch: 137 training loss: 104.59311 epoch time: 7.662 sec\n",
      "epoch: 138 training loss: 104.59436 epoch time: 7.700 sec\n",
      "epoch: 139 training loss: 104.60375 epoch time: 7.678 sec\n",
      "epoch: 140 training loss: 104.54786 epoch time: 7.988 sec\n",
      "epoch: 141 training loss: 104.56324 epoch time: 8.464 sec\n",
      "epoch: 142 training loss: 104.56199 epoch time: 7.915 sec\n",
      "epoch: 143 training loss: 104.51522 epoch time: 7.674 sec\n",
      "epoch: 144 training loss: 104.53867 epoch time: 7.713 sec\n",
      "epoch: 145 training loss: 104.51754 epoch time: 7.674 sec\n",
      "epoch: 146 training loss: 104.47265 epoch time: 7.698 sec\n",
      "epoch: 147 training loss: 104.48947 epoch time: 7.657 sec\n",
      "epoch: 148 training loss: 104.52602 epoch time: 7.701 sec\n",
      "epoch: 149 training loss: 104.47982 epoch time: 8.150 sec\n"
     ]
    }
   ],
   "source": [
    "# training\n",
    "\n",
    "# check if there is gpu avilable, if there is, use it\n",
    "if torch.cuda.is_available():\n",
    "    torch.cuda.current_device()\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "# device = torch.device(\"cpu\")\n",
    "print(\"running calculations on: \", device)\n",
    "\n",
    "# load the data\n",
    "dataloader = DataLoader(train_data, batch_size=BATCH_SIZE, shuffle=True, drop_last=True)\n",
    "\n",
    "# create our model and send it to the device (cpu/gpu)\n",
    "\n",
    "vae = Vae(x_dim=X_DIM, z_dim=Z_DIM, hidden_size=HIDDEN_SIZE, device=device).to(device)\n",
    "\n",
    "# optimizer \n",
    "vae_optim = torch.optim.Adam(params=vae.parameters(), lr=LEARNING_RATE)\n",
    "\n",
    "# save the losses from each epoch, we might want to plot it later\n",
    "train_losses = []\n",
    "\n",
    "# here we go\n",
    "for epoch in range(NUM_EPOCHS):\n",
    "    epoch_start_time = time.time()\n",
    "    batch_losses = []\n",
    "    for batch_i, batch in enumerate(dataloader):\n",
    "        # forward pass\n",
    "        x = batch[0].to(device).view(-1, X_DIM)  # just the images\n",
    "        x_recon, mu, logvar, z = vae(x)\n",
    "        # calculate the loss\n",
    "        loss = loss_function(x_recon, x, mu, logvar, loss_type='bce')\n",
    "        # optimization (same 3 steps everytime)\n",
    "        vae_optim.zero_grad()\n",
    "        loss.backward()\n",
    "        vae_optim.step()\n",
    "        # save loss\n",
    "        batch_losses.append(loss.data.cpu().item())\n",
    "    train_losses.append(np.mean(batch_losses))\n",
    "    print(\"epoch: {} training loss: {:.5f} epoch time: {:.3f} sec\".format(epoch, train_losses[-1],\n",
    "                                                                          time.time() - epoch_start_time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "saved checkpoint @ ./vae_mnist_150_epochs.pth\n"
     ]
    }
   ],
   "source": [
    "# saving our model (so we don't have to train it again...)\n",
    "# this is one of the greatest things in pytorch - saving and loading models\n",
    "\n",
    "# save\n",
    "fname = \"./vae_mnist_\" + str(NUM_EPOCHS) + \"_epochs.pth\"\n",
    "torch.save(vae.state_dict(), fname)\n",
    "print(\"saved checkpoint @\", fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loaded checkpoint from ./vae_mnist_150_epochs.pth\n"
     ]
    }
   ],
   "source": [
    "# load\n",
    "vae = Vae(x_dim=X_DIM, z_dim=Z_DIM, hidden_size=HIDDEN_SIZE, device=device).to(device)\n",
    "vae.load_state_dict(torch.load(fname))\n",
    "print(\"loaded checkpoint from\", fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# now let's sample from the vae\n",
    "n_samples = 6\n",
    "vae_samples = vae.sample(num_samples=n_samples).view(n_samples, 28, 28).data.cpu().numpy()\n",
    "fig = plt.figure(figsize=(8 ,5))\n",
    "for i in range(vae_samples.shape[0]):\n",
    "    ax = fig.add_subplot(2, 3, i + 1)\n",
    "    ax.imshow(vae_samples[i], cmap='gray')\n",
    "    ax.set_axis_off()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### <img src=\"https://img.icons8.com/officel/80/000000/one-way-transition.png\" style=\"height:30px;display:inline\"> Interpolation in the Latent Space\n",
    "---\n",
    "Let's have some fun!\n",
    "\n",
    "We will take two images, encode them using our VAE and by doing interpolation: $$ z_{new} = \\alpha z_1 + (1-\\alpha) z_2, \\alpha \\in [0,1] $$ we will see the transition between the 2 images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x576 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# let's do something fun - interpolation of the latent space\n",
    "alphas = np.linspace(0.1, 1, 10)\n",
    "# take 2 samples\n",
    "sample_dataloader = DataLoader(test_data, batch_size=2, shuffle=True, drop_last=True)\n",
    "it = iter(sample_dataloader)\n",
    "samples, labels = next(it)\n",
    "while labels[0] == labels[1]:\n",
    "    # make sure they are different digits\n",
    "    samples, labels = next(it)\n",
    "x_1, x_2 = samples\n",
    "\n",
    "# get their latent representation\n",
    "_,_, _, z_1 = vae(x_1.view(-1, X_DIM).to(device))\n",
    "_,_, _, z_2 = vae(x_2.view(-1, X_DIM).to(device))\n",
    "\n",
    "# let's see the result\n",
    "fig = plt.figure(figsize=(15 ,8))\n",
    "for i, alpha in enumerate(alphas):\n",
    "    z_new = alpha * z_1 + (1 - alpha) * z_2\n",
    "    x_new = vae.decode(z_new)\n",
    "    ax = fig.add_subplot(1, 10, i + 1)\n",
    "    ax.imshow(x_new.view(28, 28).cpu().data.numpy(), cmap='gray')\n",
    "    ax.set_axis_off()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### <img src=\"https://img.icons8.com/color/96/000000/3d-glasses.png\" style=\"height:30px;display:inline\"> Latent Space Representation with t-SNE\n",
    "---\n",
    "Let's see how descriptive is the latent space. We will take 2000 images, decode them, and reduce their dimensionality with t-SNE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 't-SNE of VAE Latent Space on MNIST')"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAHiCAYAAAA037JSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy9eXwUdZ7///p0p5PuHKTDEXIgIsgGxIMIDqiDghcqgyKezMyqMzrsjjoLjuKi4yi4zpCvjKPsD2dncXbHcwUPJhJBUTlmMig4QDjEEBVEoEkMRzrk6E76+Pz+qK5OdXWdXZX7/Xw8eCSprvrUp6qb1Cvv9/vzejPOOQiCIAiCIAj7cHT3BAiCIAiCIPoaJLAIgiAIgiBshgQWQRAEQRCEzZDAIgiCIAiCsBkSWARBEARBEDZDAosgCIIgCMJmSGARRD+AMTaUMfY3xlgTY+zZ7p4PQRBEX4cEFkGkAGPsEGPsKp19xjHGPmSMNTDG/IyxHYyx62OvTWWMccbYC7Jj/s4Yuzv2/d2MsQhjrFn2ryiFKc8FcALAAM75Q7JzPsoY+5vC/AczxtoZY+dKtonzfkS274jYdvlcb1e5N5sZY/eavQjG2EuMsafNHqcxnpH38THG2Dex6znKGFtl1/l7EpL3cKdsu/g5OCTZdogx9h1jLEuy7V7G2GbJz5wxdnbsey9j7H8ZY3Uxkf8lY+zfGWPDZZ8Xzhhrkfw8pfOvnCA6BxJYBNF5VAD4CMBQAPkA/g3AacnrLQDuZIyN0BjjU855tuzfsRTmciaAL7iys/CrAC5hjJ0l234HgL2c888l2+4CcCr2VQmvbK69Wowwxu4C8M8AruKcZwOYCGBD986q08mSimoAPwTwjcJ+aQDmGRzzOQDZAMYCyAVwA4ADnPPD0s9LbN8LJNsqU7wGguh2SGARhEkYY68CGA6gIvZX9iMK+wwGcBaAFznn7bF/Wzjnf5fs5gfwEoAnbZrXJYyxfzDGGmNfL4ltfwmCIHokNt+EiA3n/CiAjRCEhJQ7AbwsGT8TwC0A7gcwmjE20Y55K1zHW7FIR2MsrTkutn0ugB9JrqMitr2IMfYOY+x4LNL0b5KxFjHG3mSMvRKLnOwT523kfQRwEYD1nPMDAMA5r+Ocr5CMv5kxtoQx9llsvu8yxgbqXUvsNQ9j7FnG2Lex1//OGPPEXpvMGPuECZHP3YyxqRr3a2xsHv7Y9d0gee0lxtgLjLG1sevfxhgbpfMWvIpEAX0ngFcU9lsK4GHGmFdnPEC4j//HOW/gnEc55/s5528bOI4gei0ksAjCJJzzfwZwGMDM2F/ZzyjsdhLA1wBeY4zNYowNVRnuNwBuZoyVWJlT7KG+FsB/AhgE4PcA1jLGBnHO7wbwOoBnYvP9WGGIlyERWLH5jAfwhmSfmwE0A3gLwHoID97O4H0AoyFE/XZCmDtiwkZ6HTMZYw4IkcLdAIoBXAlgPmNsumS8GwCsBOAFsAbA8th4Rt7HrRCijAsYYxMZY06Ffe4E8FMARQDCEN4DzWuJ8TsAEwBcAmAggEcARBljxRDey6dj2x8G8A5jbIj8xIwxV+z6P4yd4xcAXpd9nuYAWAwgD8Jn8jcK1yDlNQB3MMacjLGxAHIAbFPYbzuAzbH56bEVwG8YYz9hjI02sD9B9HpIYBFEJxBLxU0DcAjAswBqYxGM0bL96gD8EcBTKkNNjkUmxH8HVPabAeArzvmrnPMw5/wNAPsBzDQ45b8AGCpGvSCIhvc558cl+9wFYBXnPALg/wDMiT3gpZyQzXeswfPH4Zz/L+e8iXPeBmARgAsYY7kqu18EYAjn/KlYlPAggBchpDdF/s45Xxeb96sALjAxl9cgiJbpAP4KoJ4xtlC226uc88855y0Afg3gNlGIqV1LTBj+FMA8zrmPcx7hnH8S2+/HANbF5hzlnH8EQcxcrzDFyRBSb2Wx698I4D0IokpkNef8M855GILAG69z2UcB1AC4CsJ7rhS9EnkCwC+UxJ+MX8TO/QCALxhjXzPGrtM5hiB6NSSwCMIGGGN/lBTmPgYIqTfO+QOc81EQaqBaoPyw+n8ApjPGlB78WznnXsk/tfROEYBvZdu+hRDV0YVz3gohMnUnY4xBSMVJ04NnQBCMYgTmXQBuCMJOymDZfKuNnF9yHidjrIwxdoAxdhqCQAWAwSqHnAmgSCrqADwGoe5NpE7yfSsAN2MszeicOOevc86vghAB+1cAT8kiZEck338LwAVgsM61DIZw/5QE85kAbpVd0/cBFCrsWwTgCOc8KpuD9H2XX3829HkFwN0QhNprajvF6vPeAyAXnfL9Apzz33LOJ0CIsL4J4C1pOpUg+hoksAgiNRKKxTnn/yopzP1t0s6cHwHwAoBzFV47CeB5AP9hYT7HIDyYpQwH4DMxxssAbgNwNYS00HuS1/4Zwu+LCsZYHYCDEASC3WnCHwK4EUL0JBfAiNh2FvsqL9I/AuAbmajL4ZwrRXuUUCr6V96R8xDn/C0Ae5D4Pp4h+X44gBCEFZta13ICQBCAkmA+AiEqJr2mLM55mcK+xwCcEYuISedg5n1X4h0I4vkg51wu3OU8CeBnMC7mTwP4LYAsCHWKBNEnIYFFEKnxHYCRai8yxvIYY4sZY2czxhxMKHr/KYRaFCV+D6EWx3RKLcY6AP/EGPshYyyNCfYI5yBRJOlRCaHwfgWAlZzzdslrd0Ko4xkv+XczgBmMsUEpzjmNMeaW/HNBEHZtEGrYMiE8iKXI7/tnAE4zYcm/JxY1OpcxdpHBOei9j3czxmYwxnJi7+N1AMYhsSbpx4yxc5iwCOApAG/H0pGq1xKLOP0vgN8zoUjfyRi7mDGWASFiNJMxNj223c0Ee4xhClPcBiEy+ghjzBUrhp8JoeYsZWLpzisA6FppcM6/BrAKwipZRRhjv2aMXcQYS2eMuSGsPvRDSEUSRJ+EBBZBpMYSAI/HUjhKRb7tECIWH0OwZvgcwsP2bqXBYn/VPwOhqFnKxSzZWypJPMSiYD8A8BCEB/ojAH7AOT9h9IJidWOvQIiExVOZjLHJsWt5IbaKTvy3BkLRtLTexy+b6y81TvlfAAKSf3+OnfdbCBGYL5AsSP8HwDmx+14eEzIzIQi+byBEhv4EIWJkBL338TSElONhCILgGQA/l60GfRXCatA6CFE9UWjoXcvDAPYC+AcE64v/B8ARi3beGDvvcQgRrQVQ+H0dE8E3ALgudu1/AHAn53y/wetXhXO+XVw9aYCnIESkVIeD8P6egBB1uxrADM55s7VZEkTPhXFFWxyCIAhCDyYYa77GOf9Td8+FIIieBUWwCIIgCIIgbIYEFkEQBEEQhM1QipAgCIIgCMJmKIJFEARBEARhMySwCIIgCIIgbMawm3FXMHjwYD5ixAi0tLQgK0trxS8hhe6XOeh+mYPulznofpmD7pc56H6Zo7Pv144dO05wzhVbRfUogTVixAhs374dmzdvxtSpU7t7Or0Gul/moPtlDrpf5qD7ZQ66X+ag+2WOzr5fjDHVTgeUIiQIgiAIgrAZElgEQRAEQRA2QwKLIAiCIAjCZnpUDRZBEARBEP2LUCiEo0ePIhgM2j52bm4uqqurLY/jdrsxbNgwuFwuw8eQwCIIgiAIots4evQocnJyMGLECDDGbB27qakJOTk5lsbgnOPkyZM4evQozjrrLMPHUYqQIAiCIIhuIxgMYtCgQbaLK7tgjGHQoEGmI2wksAiCIAiC6FZ6qrgSSWV+JLAIgiAIguj3fPDBBygpKcHZZ5+NsrIyy+ORwCIIgiAIol8TiURw//334/3338cXX3yBN954A1988YWlManInSAIgiCIXkN5lQ9L19fgmD+AIq8HC6aXYFZpsaUxP/vsM5x99tkYOXIkAOCOO+7Au+++i3POOSflMSmCRRAEQRBEr6C8yodHV++Fzx8AB+DzB/Do6r0or/JZGtfn8+GMM86I/zxs2DD4fNbGJIFFEARBEESvYOn6GgRCkYRtgVAES9fXWBqXc560zWrhPQksgiAIgiB6Bcf8AVPbjTJs2DAcOXIk/vPRo0dRVFRkaUwSWARBEARB9AqKvB5T241y0UUX4auvvsI333yD9vZ2rFy5EjfccIOlMUlgEQRBEATRK1gwvQQelzNhm8flxILpJZbGTUtLw/LlyzF9+nSMHTsWt912G8aNG2dtTEtHEwRBEARBdBHiakG7VxECwPXXX4/rr7/e8jgiJLAIgiAIgug1zCottkVQdTYksAiCILqZlqp6nF5/CBF/G5zeDAyYPgJZpfndPS2CICxANVgEQRDdSEtVPfyrv0LE3wYAiPjb0LCqBt+9uLubZ0YQhBVIYBEEQXQjp9cfAg9Fk7aHDpzGqfKvumFGBEHYAQksgiCIbkSMXCnRuq2uC2dCEISdUA0WQRBEN+L0ZqiLrGRz6STk9VsZY/LQtr+B6rkIopuhCBZBEEQ3MmD6CPUXNTp1tFTVw7f4EzSsqkmo32rdWpfws3/1V2ipqrdxxgTR9/jpT3+K/Px8nHvuubaNSQKLIAiiG8kqzYdr1ADF1zInFShuFwvjeSCi+LoUHori9PpDVqZIEH2eu+++Gx988IGtY5LAIgiC6GaG/uwCZE4u6IhYMSBzcgEGzhqtuL9aYbwaEX8bji6sRG3ZZxTNIno/e94EnjsXWOQVvu550/KQl112GQYOHGjD5DqgGiyCIIgewMBZo1UFlRytwni94/yrhZWJVJdF9Er2vAlU/BsQijV3bjwi/AwA59/WffNSgCJYBEEQvQynNyPlYyllSPRqNjzVIa5EQgFhew+DBBZBEEQvI2NMnuJ2lm7sVzqlDIleS+NRc9u7EUoREgRBdCGptsWRHqeEa9QAhA83m5qL6BrfWHEAuTNHUdqQ6PnkDhPSgkrbexgUwSIIgugilNriSG0UWqrqUVv2WVJ0SX6cEqGDp00VvkuJtobR8PaXFM0iej5XPgG4PInbXB5huwXmzJmDiy++GDU1NRg2bBj+53/+x9J4AEWwCIIgugyl1X88FEXDmzVo+7YRgR318delBemGVg0aMCXVJMLRWHGAolhEz0YsZN/wlJAWzB0miCuLBe5vvPGGDZNLhAQWQRBEF6Hl2N66NbktjliQnuqqQbNEW8Ndch6CsMT5t/W4FYNKkMAiCIKwiLQ+KjS+FS1V9fFIkF7tlB5irVZXiSyCIOyBBBZBEIQF4q7qYgovEo2n9gAkvpYCYiF8w6oaq1PVhXmcnX4OgugvkMAiCIKwgFpdleg1ZUVcMZcjvsrQv+ZrQ61xOg6GYl1WXLC9VQNIp+YAvDecnfJc+yqprvokCBJYBEEQFlBL3aWS0nONGoDoyTbFh7n3hrNNRbGY2wneHgUiHSpLKtgAmBYO/U1syKOT5IRPmIEEFkEQhAVU66NUIkhahI+1oPjJSxRfyyrNR9u3jYrF8ErwQARwAI7MNERbw0mCKKs035RIUBIbDauE1Y8DZ43uk+JLa9UnQCKL0IYEFkEQhAUGTB+hXGeVgm0CD0TgW/xJPFUnFywDZ41Gxpm5HUXzeiIuCrB0J4Y9cbH5ychQs4oQBZ+axURvFiFaqz77wvURHRw5cgR33nkn6urq4HA4MHfuXMybN8/SmCSwCIIgLCBPt2khCqXGigOqlgg8EElKBcoFi3jOowsrdednNFUpjUAxjxOMsYTIl9Y4ahYTvT3So7V6k4ei8fept14f0UFaWhqeffZZXHjhhWhqasKECRNw9dVX45xzzkl9TBvnRxAE0S8RH7DS1YNKFC78Hlqq6lPymxIL56UPcyP2DfLG0EqpPHHuYgSKByLxwFhc3LkYEDIZluvlkZ6MMXm6KVmx1ZBSGpboHNYeXItlO5ehrqUOBVkFmHfhPMwYOcPSmIWFhSgsLAQA5OTkYOzYsfD5fCSwCIIguhsjbuunyr9CYEfq7WjkYko1PRlDLGoXUSvaZi6H5tytrIRUEoadhZ11YC1V9YbfK1Ew95XUaE9m7cG1WPTJIgQjQQBAbUstFn2yCAAsiyyRQ4cOoaqqCpMmTbI0DvUiJAiCsAEjqbjWbXWWPbGkZJXmwzt7dHy7IzMt7mXl9GbAO3t0woNerWi7sx3cu8IkVa/Po1kMtSdSQGrRQdjPsp3L4uJKJBgJYtnOZbaM39zcjJtvvhnPP/88BgwYYGksimARBEHYgCG3dYv9Anl7BEcXViZEZ8ysBuwuN3i5MOwM1MSjf83XSYsCjES3rNwrct3vPOpalFO2atvNEAqFcPPNN+NHP/oRZs+ebXk8ywKLMVYCYJVk00gATwDwAvgZgOOx7Y9xztdZPR9BEERPxJDbusaqP9FOgXmS/auEHaynojqz5Q5zOeCZkJ+wmlDcPmD6iE63cVAtRg9EEBENWnnHvnr3z8q96gpB2V8pyCpAbUut4nYrcM5xzz33YOzYsfjlL39paSwRyylCznkN53w853w8gAkAWgH8Jfbyc+JrJK4IgujLZJXmI3Oy+i955nIgc1IBmMuRtD3v9hIUPXExhpVNQfGTlyDvln9KSPuBIdF1HamlojLG5GnvwGJfXazjeyYYoMrnDSdLSkcOnDU6IWUpbgdga/pOCbOiRu/+DZg+Ivma5ai8rHufiZSZd+E8uJ3uhG1upxvzLrRmqbBlyxa8+uqr2LhxI8aPH4/x48dj3TprssXuFOGVAA5wzr9ljOnuTBAE0ZcYOGs0nO9/2xH9UEhJtUh8rNQiOWLar6WqXmhpoxL1MhthadvfoL0DB/JuL0k8JwdC35xG5vcK0La/QTcCJU1ZajW6jgucyfrzbqmqT7C2YB4nvDecnXB+vYJ/JbTuX5L9hsJ7WVv2meIYuveZSBmxkN3uVYTf//73wbnFHL4MuwXWHQDekPz8AGPsTgDbATzEOadPHUEQfRqHJw2FC7+n+rpazZRSCq1h9ZdJkSs5tWWfaabbtESOHKc3A/41XyefMwoEdh9XdZlXO6+e4NGak6Y4C0QEEYgOIWTGj0xEL+qlV99mZ5skwjgzRs6wbcVgZ8LsUmyMsXQAxwCM45x/xxgbCuAEhL+D/gNAIef8pwrHzQUwFwCGDh06YeXKlWhubkZ2drYt8+oP0P0yB90vc9D9MoeR+xUNhBFpbAciUcDpgMPtFKIz0t/HZlrtMAZnXgYcnsS/maOBMCINbYnj6owRORVU3cVVbPxzEKprFa5Ph2BmFFnuzIS5G5630wFXQWbyuX3N+hOU3DP5++HMTU+6l0qoXqODAYwpjhfxtyHaEurYNctlKr3ZF/8/5ubm4uyzO6fReCQSgdPptGWsr7/+Go2NjQnbpk2btoNzPlFpfzsjWNcB2Mk5/w4AxK8AwBh7EcB7SgdxzlcAWAEAEydO5FOnTsXmzZsxdepUG6fWt6H7ZQ66X+ag+2UOvfvVUlUP/4avwEP2FkI7vRlJkTO1FJYSmZMLMPC60Zru8MN+NEVzjMSoU46h81af14iSnZ4ESwkz8x5W1jGnU+VfoXVbHcBzNY9JSNkqvB/M5UiyuFBCMUrnZIIwlGwSx1PrJZk5uQADZ43WuVKBvvj/sbq6Gjk5xj4vZmlqarJtbLfbjdLSUsP72ymw5kCSHmSMFXLOxVL/mwB8buO5CIIgeiWp+ivpoSRIzKSqxLohcTWjElrpSCMpQTXkZqSppPhOlX+l6bquJprU7B2MmKPK05JObwaibWGh0bbCeJFG5etq3VZnWGARvQdbBBZjLBPA1QD+RbL5GcbYeAhB7kOy1wiCIPolnVWfo5RmMmM1IO6XO3MUGt7+MtkmAtr2BlaFo3SehubtQIJLfes2dXGlVZSvVUd17KlP4T5/sGZxv9HaL83rsbe2mugh2OLkzjlv5ZwP4pw3Srb9M+f8PM75+ZzzGyTRLIIgiH5LZ3gkyVviiBiyGoghziurND/BJkIOD0XRWHEgabtV4Sg9n968mceJvFtLEgWThkgpXPg91aibFtHWMFq31mnaS8gd5NVwejM6rC/k0KL7Pgk5uRMEQXQhpuwExAevhnjQs0wA9KMrcoEmrp5Tq8eKtobRUlVvuvE0AMDFwMASr98BRFra4+dzZKbBMyFf1xbC0ApJDfGSSksbUWDK7Ru0EO+vag3WJGsmmYR1gsEgLrvsMrS1tSEcDuOWW27B4sWLLY1JAosgCKILUarbURUIBlJHWpYQ4vkSPLVkus6RmQb3+YNxev0hNKyqSRAzWnOT1ygZEY5iHZR4fMTfJqy44wBCHRcrRo4AdQFptOZLS7ykGnWLtoYBsU5Nb6GjrK0REEtncgBMmB/VX3U/GRkZ2LhxI7KzsxEKhfD9738f1113HSZPNmDUpgIJLIIgiC5G7q909NFK5Qc1A5y56iLHdLqRycItTgb3+YMT2ttI66y02v9E/G1JfRGBROGYMSYvHoUChOhPw6oaODLTkDtzFLJK81G9cp2mSFGr+9Kt+TIgXjqzdZA4B9HVXVwZ6cwMIy/nFWS1/wXIHQaMfAIACSwzNFZUoP655xGurUVaYSHyH5yP3JkzLY3JGIvbX4RCIYRCIVg1TCeBRRAE0c1kTipQTR1lnJmrGHmCkynWXan1/Du9/lBy4XqEd0RTJIir3goXfg/+NV8nrYpLGMLfhoZVNWisOIDcmaOSImpKkbNoa1gopAcMeWXxUBQNb9YkRNi0hJHUukGrB2Iq7u+m4EDr1rqE9zbSmgY/fgiknURW41+Bin8T5hmZmlJT6v5GY0UFan/9BHhQ8GsLHzuG2l8/AQCWRVYkEsGECRPw9ddf4/7778ekSZMsjUcCiyAIopsRoyxaqSOp0JFGgKQCQt4oWhr9MZuGFPf33nC2IRESbQ2rRpoU3egjXHhthMG1VrJGzczjVBR+0qiePI0oisG2bxsxcNbopKgb8zjBw9GEdKVhTBjDcrhxOnwXstL+CoQCaHnvffgDxR332ERT6v5G/XPPx8WVCA8GUf/c85YFltPpxK5du+D3+3HTTTfh888/x7nnnpvyeCSwCIIgegADZ41WTWdptdeRCgglwRHv+WfGGR6JqwoBYy1olPyj9KwLnLnpwnp2E0EkHorC4UoDXI4E4Scv1ldLI4oRJVFkKd1bLcNVpnBe7+zRqulUJSIY3DHP0z8AV7kBRj25+gvhWmVDArXtqeD1ejF16lR88MEHlgSWLTYNBEEQRNdj1Hsq4m/TFFdySwSlVYWFC7+HYWVTdOu+Iv62BBsDrf0dmWnC3FLI0EVbw/DOHh0f3+nNSDIS1RJ3rVvrdG0a1FA9r4mSHSdOoCV8OWqD/4sIhmjuS70NO0grLDS13SjHjx+H3+8HAAQCAXz88ccYM2aMpTEpgkUQBNFLMet4rrS/WOejVqckx0jdkjQNN2D6COUaMkdsNV5UpvycDJkXDe0ojleJvDm9GbrNmPWK2LUiQ6qO9i6mel61Wjo5DEFksG3wh38BDrfu/p3hndZbyX9wfkINFgAwtxv5D863NG5tbS3uuusuRCIRRKNR3HbbbfjBD35gaUwSWATRxyiv8mHp+hoc8wdQ5PVgwfQSzCot7u5pEZ2AkVVwzOVAxpg8BHYfV3xNbiGgh7ifXvF769Y6ZJyZq7i/IzMNnHPl4yMcrVvr4PRmIO/2EuFYmaBTM1aVo7UKEtAWqLkzR6HhzZpkcRdFkgcYIGwT2w11TBRwjRyASG1rXKwxVwRez//F0oL64srotfYXxDoru1cRnn/++aiqqrJjinFIYBFED8asWCqv8mHBW7sRikUFfP4AFry1GwBIZPVB9ASEaJUgtWEQkRbKmyXBW0vj/GKESEnAadU4AR0F6czjNGQ6qjZPNXNPQDsylFWaj8aKA8lRrAhHw6oanF5/KLFhtIII9EzIV7j3LuC6/4eIVr0WrSLUJHfmTMuCqisggUUQJhFFj88fgJMxRDhHcSdEih4v34vXtx6O/wHt8wfw6Oq9ANTF0qI1++LiSiQU5Xh09R4SWH0QVREQQ0z9KaXzWLrT8oNbtH/Q6ucnNogGEj2y1FYByuGBCAI76hUbNRshvkJTQWRF25Id6RNeV7mvQOKKxLb9DYoNo5XOKRata0UfnbkZugayRM+HitwJwgTlVT48unovfP4AACDCOyJFj67ei/Iqn23nkYorkUAogqXr1f/y9QdCitsDoajhuZVX+XBp2UactXAtLi3bqDom0TPInTlK9TU98WMHeumriL8NDW/VoOHtLxN6+vF245Xt8ZWQKTJw1mjk3V4CR2ZiTIEHImhYVYNjT32qWPBupPZJ2qvQKBF/m+Z9o6L2vgEJLIIwwdL1NQiElP/qDoQimL9qFx4v32v5PIsr9qku+joWE3dm0RJmIlIBySEIR19DwDbhSNiPVlRHjBYpYWvhtN6TJApFk1NHZprhlXfi6sTass9wdGElass+Q0tVveI2JbJK88HSncrTi3l4yY810yzbDGKBPvMoz0dtO9G7IIFFECYwIm5e23rYksgqr/KhoVU9alTk9ai+lpfpUn3NZ2DuSgIyyrkhcUZ0H1oiSkkk2Fk4rWokagAhBWdMYTGPE/7VXyVEwRpWCe7u0m1KQklEKzIktvGRirSs0vwESwY7kN577w1nKz6FeXs0ZQsJoudAAosgTKAlbqS8se1IyufQEjMMwILpJaqvPzlznOprTpW+WmJKcMTCtaoiLNWoGdE1aIkouUhgHieYy5EkJlLFUjqLAeD67qfM5QBjzJDnl1Y60YhQkos00QNMXNFoCQZ4JnQU/GeV5sPhViiFjhXS2/H+EN0HFbkThAkWTC/Bgrd3IyRPd8iIGHhoqKElZn40eXi8WF2t2F5rTpeWbUwoxhdTgmppTxGjwpLoHpQaLUtXnyWs+nv7S3BJKx2xJ2CqBe+WGiZr/DcRxxWvxZRLusp8jPYelIo06T11jRqA0IHThueRPDAQ2FGPFol9hZFCemkPRqLziEQimDhxIoqLi/Hee+9ZHo8EFkGYJKIjrgD1aJERirwexUiS1+PC07POA5AsjKTF9lodUeS2DVo1ZSIOxjSjZkTPwIiXVWPFAcVaqMaKAykLLEXR4mRg6Q7dVYJaqU35KjojrXr0xjXq4QV0RLKkfQwj/jbTbX3kyM9QR90AACAASURBVFvfGBWoohiOfl9dkBHWWLZsGcaOHYvTpy2IaAmUIiQIEyxas8/Q79Y5k85I+RwLppfA40oscvW4nFh0Q0f6T0sYxXoFqxKKcixasw+Asbqs4jwPWTz0EdSiJVpRFD3kKUinNwN5t/wTip+8RDMlF4/IyP4YEY1R5YXrRgvO9erLskrzUfzkJci7vUQ7ZcigHOmKAnAmz9k1aoDu3ERE+4qjCysRaTQR/YtwWmEI4MttdXj5sS144V834uXHtuDLbfru+XocPXoUa9euxb333mvDDAUogkUQJtCzLHAyhjmTzohHmtTQMhAVv2oZjOrVRHEAxSqRMPE6yqt8hvv/Xlq2kZzh+zi1ZZ+ZNvIUUYueaYmBuAiSahUXA1iiZ5UYSfLOHg3v7NGakSypeeqp8q/Quq0u/hdH5qSChGba8rRpUmRPq3djugOOjLSE+2XWRiJ+DWarCeSthfoZX26rw6bX9yMcs/loPtWGTa/vBwD806SClMedP38+nnnmGTQ1NdkyT4AEFkEokkq7mUNlMwyPLU3vKRmIziot1jyfWhpRpNjrwZaFV2DEwrWq+yxdX6P7uz3T5YCvIQCf36k6V6L3oGXuKV+JByAuQKR1SBlj8gy7qqulv0Q/Kv/qr4Axkk9hiIMrfCrFtFrhwu/FzyWfl3Qep8q/SjT55B2iTSqyxGs0kjJMmE8gAmR0PD7bvm2kyFIX8em7B+LiSiTcHsWn7x5IWWC99957yM/Px4QJE7B582YbZilAAovoNaw9uBbLdi5DXUsdCrIKMO/CeZgx0pioMYOSAJq/ahcWrdmHrHQnWtqTfxFr2SPIUUrviQaiRkXLguklqsXpHpczXjOVl+lStHzIy3TpRsFcDob0NCeivN3SXImeg/eGs5UbL8sQLQvkheURf1tSdEl0M884MzdJ8CjVZzGXA7kzR6k6zKshFzBaNWetKimj1m11SQILgClxJZ+P/J5oYdS9XrMuy5F6fWdfoPmU8n1R226ELVu2YM2aNVi3bh2CwSBOnz6NH//4x3jttddSHhOgGiyil7D24Fos+mQRaltqwcFR21KLRZ8swtqD6hGaVFGrb/IHQmgPR+GU/YJzOZmmPYIcNWGjVw8ldVhfur4GN08ojq8aFIvqi70eLJl9Xlz8zDi/MGkccb5aKwOLvR4svfUCNKqkRMVrkLu+kyFpzyarNB95t5Yk1EvZQevWuiQ/qoa3BHEmr88SW96YjfiYmqtaaFZhe0tVvWGz01QRG1fr1aWJ+8ZtIeRPaIfNBrG9kOyBytevtt0IS5YswdGjR3Ho0CGsXLkSV1xxhWVxBVAEi+glLNu5DMFIMGFbMBLEsp3LbI9iaUV2xD5/VnoQelWiSgAwfvGHWHTDuKTxlKJq7+zwJYgp6b6Xlm2MryiUwgDcfpFQgN/anlzY7HE5E8YUPLmSaxK8mS7VSN/8VbsM16IRXY+09shK+xldosJqveInL1GMNJm1dzBlUaBWXMgSU4vM4xRa9qgJMqNFiirk3V6SdO1aVhHSAn016w1H4xepT6gPcPGNoxJqsAAgLd2Bi29UbxnVXZDAInoFdS3KIfhjzbVJ3k5W0atvAgRbBDEVZ+a85VU+NAfVV2z5AyHFGiejaUW56JE/GziA17cdxmtbDyed2+NyYMlsQRCJRe3eTJfiH/fNwTAWV+xTXckY4Tx+Dqm1hNm6NqJzaKmqN+QHZRWtdJgoNIxipug+c1KBYtrONXJAwnXrpussiCuxHY4cuXASRZxSPZtiGnRz/xZYYp3Vp+8eQPOpNmQPzMDFN46yVOAuZerUqZg6daotY5HAInoFBVkFqG2pTdrOQ17bC6+16pukpFKLtHR9TTwKZmZctaiafLsRXys1D9RgKIrt357COzt88TEaWkOKz5hQlGu28xF5Y9sRPD3rPEOF/UTXYbb+qTOIC4ea7QBiEa2WdiCU/IkzmxYT66zkqwjb9jekdt1iJMtgRMuIVUSqvmOEILLsElSdCQksolcw78J5WPTJooQ0IY+60HZ8OgB7C6/FMX755i7dFdFmW8gY3V++n1pUTV5HZaWlDYcgiKy40MuJcI7yKh8eenN30rhULN99pLrizWiRtoi4WlCNrNJ8uBozMaxsCgDlyFqqfRMHzhqdVNB+dGGl6XEAAFyYh6I4UxBfHIJ5q9SBnQRV/4OK3IlewYyRM7DokkXIdeWDcyDa7kWwdjbCp0vj+9jZL29WabGRFmmmW8gY3V+6X3mVD/7WdsX9po0ZYmk+csyIK6/HlWSIKocBeHT1XtVxqcdh96AWEWIeZ8drCrlhHlQRVy6WZL4JJ0PuTHN1MUqmpWJRvB2kXCCuZjoKdES0pB/xEI+bt+o1oCb6LhTBInoNM0bOwG/f9KBZ5aFsd788vVoshmSBo4eR9KM47uPle/F/2w5rRtE27T+uO76ZOl2xeF9pTtKtUmf5+at2qY6XqWJrISK+Z1Sf1bWo2Sd4bzg7wWcqydJB7YMU4si7vUTVl8oMnZk+UywwdwAOdxqireGOoneJ6ahq5MoE8vY4RP+ABBbRq9CKeEwbMwSlT30Yrw3yelyKK/KMoieGOIB3dvjwzfFmbD3YgAjncDKGySPzcOhkIC4Wpo0Zgk37j8d/vnlCccLPIwZ58MmBUwl/CCsVoSshvx9KLvDTxgxJqKtSw+Ny4uYJxUn7OhjDjyYPT5izVACJDaflqHmGSc+3YHqJYn3Wg6t2Yfu3p2gVYieh1xxafM1ozz2xoLunCwgj161kYGqmD6IaZETa/yCBRfQq1KJKmS4HVv3jCEKSvzz9gVBCY2PpdiNCTC5WHArRnUAogi0HTsV/jnCe8LPPH0gQS0r2CpeWbUx5sZJS1E7uAn9p2UZFccUYkOt2oTEQShBNE88cmCDQivMiuP86daGjJEQ9LiduurAYr289rHhtTsbi90BpfhzA61sPY+KZAymS1UnoCSKjgiDVGqnuQu+61V63uuqyv/tX9UdIYBG9CrWHeYbLgVaFVW2hKE8opC6v8uFoQwANrR21Q/5ACPNX7cLiin14cmai0JKKlbM02s6YQV7cnWodktSxXQu1NCfnwK4nr0naLhdoeq0j1HonqrXiYQCeve0C3evnsTFJYHUPmj5VGtYCfRE1awWj9DYR2l8ZMWIEcnJy4HQ6kZaWhu3bt1sajwQW0atQe5hr1QH5/IG4r5ODMcw/V/k3Y0OrsgeViBF/LKNIRUUq4ypF3dTqmNTqqkT3dztQ6p34oMp7wpF4f7Wun4rgu48B00cot9VxMuTd8k99XlTJkUa2VH3EXAwIcTCPE4wxRFvD/UaE9hU2bdqEwYMH2zIWCSyi16H0MFeyARBh6Iji6K2S07IOmDZmiGrKyyzS1J5R3y0Rl4MliKvyKh8WrdkHv6StjdRnSu2a7bRjUEJNOBXL0prTxgxRrTmze+ECYRxREEgbITsy05A7c1S/FwtGarmIzqO6chMqV76CppMnkDNoMKbccSfGTpnW3dNKggQW0WuQCwkHA6JceGBriQWzMkIpalJe5cOqz44kjTU0Jx3fNSlbKKghT+2JQmlxxT5D5p3StKe8QFxKIBTBQ2/uVm34LBc6ephd6aeWzpWnNeUrIUVYbAyi++gNhevdBd2b7qG6chM+XLEc4XYhfd104jg+XLEcACyLLMYYrrnmGjDG8C//8i+YO3eupfFIYBG9gvIqHxa8tTvBBV38Vuy5Z1c8RilqsmjNPkUHdqPiyskYopyrChMxKjd+8YcJkSg1RBGo59we4RzNwTBcTpawAMBo/ZbI4+V7E6J3RpzY1dK58v21arCo/oogCCmVK1+JiyuRcHsbKle+YllgbdmyBUVFRaivr8fVV1+NMWPG4LLLLkt5PBJYRK9Ar8WMUhcLj8sJt8thKCokPUZJeBgRPVpEOcc3ZfpNqRsNnkcUgUZqlEJRDq/HhayMtJR8pvyBkGJq1IgTu1I6V47RVCJBEETTyROmtpuhqKgIAJCfn4+bbroJn332GQksou9jREhwCA9lqYgAoFnf5HQw5GSkJVkV2I1aLZE87ZbrcemKOakINFog3xgIKa4YNMJ3jUFwlaYPdhShG00lEgRB5AwajKYTyWUFOYOsFaa3tLQgGo0iJycHLS0t+PDDD/HEE09YGpMEFtErMCIkir0ebFl4heJravVNkSgHY9CNLqnVMRlBrZZIyWDT5WTx2jK1sS4cnoul62vw4KpdyPW4ktJ/SlgpFm+PRKHWVcuOInSjqUSCIIgpd9yZUIMFAGnpGZhyx52Wxv3uu+9w0003AQDC4TB++MMf4tprr7U0JgksolewYHpJUg2WFL2IR1DDINCIcHpy5jgseHt3gpBxOhgcgGbqElCvJVKqn9ITShxIcH33B0JwORjyMl3wt4aQ63GhpT1sqd5KSnmVT/U1O4vQjaQSCYIgxDoru1cRjhw5Ert377ZjinFIYBG9AvHhK7cjAISWLL+56TzVB7ReIbiZ88ujLNJtSk7vgHotUarpNfkZQlGOzPQ0VD0hpADt6OsnjuHzB/CQion7jyYPJ1FEEESXM3bKtB5pyyCHBBbRa5hVWozt355K8kxqaY9g+7enVB/2ekLG63EZPr/SOaR+VGZqiTrLuNRqNEjL+kHKxDMHpnwOgiCIvo5yYQVB9FDe2HbE1HZAu05INO20g1mlxVgy+zwUez1gECJX0p6DchZML4HH5UzYlqq3up2GnEYjfgve3q2ZQiQIgujPUASL6FWk4kqu5pSel+lK6j1oFTPRI2na0ecPgDGhP6AeSnYUdq64M5q6DEU4FlfsozQhYYloIIzass/IEZ3oc1AEi+hVqPXP0+qrN6u0GDdPKIZ0l0yXw3ZxlQqzSouxYHoJXA5mSFwBHXYURqJkqWAmGtbQGsJZC9fi0rKNFM0iTNNSVY9IQ1u8qXTE3wb/6q/QUlXfzTMjCOtQBIvoVcyZdIZi37o5k85QPaa8yodV/ziSIGBaQ1EseEtYMdLdImtxhbJLvBpadhR2YLY3IocxZ3eCkHN6/SHgjMTPPg9FcXr9IYpiEb0eimARvYLyKh8uLduI17ceRqbLEY9GORnDjycPx9OzzkvYTxpVWbq+RtH+QOzp1508Xr7XFqd5OxFrybSigkqIzu4EYRQxcmV0O0F0Jn6/H7fccgvGjBmDsWPH4tNPP7U0HkWwiB6PfFVbaygKj8uJmycUY9P+43ht62G8se0IIpwn1CeJURWtSIwdTuSpUl7lw+sK0TgpVlrcWGFWaTEeXLXL9HHdeT+J3ofTm2FqO0F0JvPmzcO1116Lt99+G+3t7WhtbbU0ni0CizF2CEATgAiAMOd8ImNsIIBVAEYAOATgNs55gx3nI/oXSqvaAqFIQn88schdqV+eU8WfStz/0rKNCcLFDh8pIyxdX6PZoNrlFFY4dsa5jVxjKjYS3kwXLi3bSI7shCEGTB8BVCe2PWEuh7CdIFRoqarH6fWHbF0Ycfr0afztb3/DSy+9BABIT09Henq6pTHtTBFO45yP55xPjP28EMAGzvloABtiPxOEadSiIkarliKcw+VUT3f5/AE8uGoXRixci9KnPsSCt3bD5w8k1BZ1RgG3VrSHMWDpLRd0mrh6dPVe3WtUspHQwuVkaA6Gu+TeEX2DrNJ8OPMy4hErpzcD3tmjqf6KUKWlqh7+1V/ZvjDi4MGDGDJkCH7yk5+gtLQU9957L1paWiyN2Zk1WDcCeDn2/csAZnXiuYg+jFWPp2KvB0tvuQB5meqGoqJYa2gNJRWcm6ktUqoBU0PtuhiA524b32mRn0Vr9ilGBOXXKNZipTsdYBDSlXKhKv5U7PUgKz3N0r0j+icOTxoKF34Pw8qmoHDh90hcEZqcXn8IXNb6TFwYYYVwOIydO3fi5z//OaqqqpCVlYWysjJLY9olsDiADxljOxhjc2PbhnLOawEg9pX+1xApYcWQUywKn1VajKonrsEhnabOahipLTIaGRJRu67ObEFTXuVLajUkonSNs0qLUVKQg2/KZmDXk9dg6S0XJFhEPHf7eBwqm4EtC69Ao4lxCYIgUqGzFkYMGzYMw4YNw6RJkwAAt9xyC3bu3GlpTMaNmu9oDcJYEef8GGMsH8BHAH4BYA3n3CvZp4Fznqdw7FwAcwFg6NChE1auXInm5mZkZ2dbnld/oT/cL38ghO8ag2iPRJHudCDHnYaG1hCiGp/fdKcDQ3Pd8HpcCccXeIA6k8/8dKcDJQU5mvvU1DWhPZLcVFp+rHQuTgcDAxCO8oT5dhZqc1Sap0hzczPCzoyE+680T6PX39fpD/8f7YTulzn64v3Kzc3F2WefbWjf0//fPvDTyX/MsQEuDPhFcleOSCQCp9NYqcP06dOxfPlyjB49Gr/97W/R2tqKp59+Ov76119/jcbGxoRjpk2btkNSGpWALUXunPNjsa/1jLG/APgegO8YY4Wc81rGWCEAxQQp53wFgBUAMHHiRD516lRs3rwZU6dOtWNq/YL+eL/Kq3xYWrEvbnEgrh4sViisfrx8b6wg3gHAgYfOC+PZvcY/+h6XE0tmn4epOlGlnyxcGztHMsXeaNxe4dENexEICXORjt8VxeB3L1wLtcD187ePV7zG8vc/woLKEELRjjm7HCEsvfWchDn7VXoxGrl3fYn++P/RCnS/zNEX71d1dTVycoz9Eea4biT8q79KSBMylwPe60YiS2GMpqYmw2P/4Q9/wL333ov29naMHDkSf/7znxOOdbvdKC0tNTQWYIPAYoxlAXBwzpti318D4CkAawDcBaAs9vVdq+ciCEC5GbFbRaSIVghKcS6t1YVqgk1r9Z3WqjsxXZiR5lCtf+oKgaV2zYypG4Qe8wcQiib+BRiKcixak9gmR976x8lYQg0WrSYkCMIqYo2e3asIAWD8+PHYvn275XFE7IhgDQXwFyaYEqYB+D/O+QeMsX8AeJMxdg+AwwButeFcBKFq2zB/1S4sXV8TjxSJD3o1opyjWEUUcSTWbwHJwk7uXr5gegkeXLVLdXVjIBRR9eTy+QMor/LZIkK0RKCqXYVGpUBExWVerOWSn2/amCF4Z4dP9T4RBEFYIas0v1cshrAssDjnBwFcoLD9JIArrY5PEHK0iqZ9/gDmGzTILPJ6NMcKhCJ48M1d8fEcDJBrDWn0aVZpseFzK/HgKuFcSmlOoyiJwPmrdmFxxT48OXOcqqAsTnGlptL5lFoZdWWUzihd5XdGEET/hFrlEL0Oq7YNgJACXDC9RHcsaWRHrV2gzx+I2zJoWUHoIXegT8U/Sim6Bwj2Ew+u2gWfP5C0AlOv/U6aQ3nNZl6mS/V8SvSk1YRmV3wSBEGYhQQW0eswa4CpxCWjBsbTelbHAjoaHjcHw5qmpkZJxT+qvMqnmRLlkq9S/yq9AvtchVWNLifDkzPHmXJ6t0MY24Vampk8uwiCsAvqRUj0OuTF1Kmw83BjQs3TojX7VP2hzBCKcsMeXXqYifiIERmjiAX8WxZeoTuusFIzUYSmORi2f3sqofejFl3RpNoMave2J0XZCILo3VAEi+iVzCotxpaFV+D528enFIGSr27b9eQ1eP728XETTSdTl0lOxjRFlHVnuY5x9NzgRcyk6kSMiIml62sUvcYCoSheU1mdKUctSvZ4+V6MenQdRixci1GPrsPj5cYFolXUomk9KcpGEETvhgQW0asR27ko1T7pRZLkAkMUbd+UzcCzt10Al0LtkcvJ8OxtF+CbshmmCsOLvR78ePJwTeGmhF5tUHmVD6VPfZhSJM+ImLAS0fG4nHj+9vHYsvAKRXH12tbD8VWNEc7x2tbDXSaylFLDPS3KRhBE11FTU4Px48fH/w0YMADPP/+8pTFJYBG9HrENjjQCJbZx0ZIzWgJjVmkxlt56QYJbeV6mK6EBs9H6LQZgy8Ir8PSs8wThZrJGS602qLzKhwVv746brZrBqJhINaKjV9v1xrYjprbbjSjMpZ+XrjJ7JQii51FSUoJdu3Zh165d2LFjBzIzM3HTTTdZGpNqsIg+g2iVIEWtTktcRWh2PPnrgH79lihSyqt8WLRmH0IRbXNTJZQiSUvX16iOpYUZG4gF00vgq95heGyjrvRqflxq2zsDvfeXIIieyZ49e7BhwwY0NjYiNzcXV155Jc4//3zbxt+wYQNGjRqFM88809I4FMEi+jRqUSa7GirPKi1GVob63ykuJ8OC6SVCtOmt3ZpCjEO99kspkqSXvpNHyrRSdmrMKi1GcZ4HWenqkTqxJs1MFEjtOs2mUAmC6F/s2bMHFRUV8Z6AjY2NqKiowJ49e2w7x8qVKzFnzhzL41AEi+jTSFccioaSZwyM4BfXnWfbObSETlZ6GmaVFmP84g8RUjPSkhDhHB6XM6mfn1K0Tas1jxilUjLSTMVgU23qqfZRnDPpDEVD0jmTzjA1DkEQ/YsNGzYgFEr8QzUUCmHDhg22RLHa29uxZs0aLFmyxPJYJLCIPo88FbR582Zbx9cSOv5ACJeWbTRsAaEljOQsmF6CBW/vTkoTuhwsfoxSb0a58/qDq3Zh+7en8PQsZdH5XWMw1pw6ESdjKdctied6Y9sRRDiHkzHMmXSG6hwIgiAAxCNXRreb5f3338eFF16IoUOHWh6LBBZBWESvB6HRFX7S3odGRIu4z+KKffFCd6/HhUU3jFM9XsnOgQN4fethTDxzoOJx7ZEolKoJopxbSrM+Pes8WwUVtb4hiL5Pbm6uopjKzc21Zfw33njDlvQgQAKLIFKmvMqXIG6skGr/QbOF2mrpTA6o9gpMdyqXavYkzyi9RtwEQfQNrrzySlRUVCSkCV0uF6680nrr49bWVnz00Uf47//+b8tjASSwCCIlRIuEVFbxibicLMH2wcg5rUZotNKZauJraK4bHlfEUF1Yd6HV+oYEFkH0HcQ6q85YRZiZmYmTJ09aHkeEBBZBpICWRYKTMUW7Aa/HhayMtJQEkpUIjVSYeTWaUatFpLweF5bMPqdHp9+o9Q1B9B/OP/98W20ZOgsSWASRAloPbrWVgFq1UXqkGqGRC7OG1hCcDoaIbFmgXkSqp3tGqUXmelIa0yrVlZtQufIVNJ08gZxBgzHljjsxdsq07p6WJr1xzgRhFySwCMIEYjRIKzFoZiWgUYxGaEQzU3HVImOAPJgWiXLkZbqQmZ5aNK0nsmB6SYKQBHpeGtMK1ZWb8OGK5Qi3twEAmk4cx7rlz2LjyytwxV1ze6RoUZrzhyuWA0CPnC9B2A0JLIKIoVXjJBcuamhZJFjBSIRGNDOV+m2pGaP7W0OoeuIa2+bX3Sj5nfV20SilcuUrcaEiJdjUhA/+uAwfvrgc4Tbh9YzsHFx5d/eLLvmcvaMaUTSpHr72e3FqSxFGjnoYhQU3duMMCaJzIYFFENCucQKQFB1RQs8iwQpaERpRGJpp+JzrUa/F6q309DSmFZpOnlB9LRoOIxoOx39ua27C+/8lNKntTpElnbN3VCOGX14Lh0tQ/MG2Y9i//1exV+1ZXk8QPQ0SWAQB9RqnxRX7cDoQ1uyRxwB8UzajU+enFqEBjIk/OS3tYZRX+fqsIOlr5AwajKYTxw3vzyMRVK58BQC6pAZKqdZKOueiSfVxcSUSjQZw8MDvAPyH7fMhiJ4A9SIkCKjXODW0hnQbEHdVNGhWaTG2LLwC35TNiPcTVBKGRghFOJaur+mEWRKdwZQ77kRaeoapY8Sap6YTxwHO4z9XV26ydW5irZX8PCNLL4rP2ZUdVjw22FZr61wIwgrPPfccxo0bh3PPPRdz5sxBMBi0NB4JLIKAtdVm3dmf2ExaUA5ZGPQexk6ZhmvmPoCM7BzDxzCHI6luK9zeFo9s2UF15Sa8/4fnFM+z+8O1YMEAMjIyEGpWTpa4MwptmwtBWMHn8+E///M/sX37dnz++eeIRCJYuXKlpTEpRUgQUK5xMorfBif3VHi8fK/uPnkx3yslt/m+ZGHQm0jVumDslGkYO2Vax/E6KUMejSpu16rnMoMYuVI7DxhDiDE4AwHk+qehLffviEY7RL3D4cHIUQ+jZr/585L1Q/+mtu5dHDzwOwTbauHOKLRtwUQ4HEYgEIDL5UJrayuKioosjUcRLIKAkH5bMvs8FHs9YBCsFrwGU3/dIVTKq3x4bethxdcYgOdvH49DZTNQ9cQ1eHLmOHhczoR9+pKFQW9CLZ1mNm0XatNOXVxw9fXIGTxE8bWcQYNNnUsNtZWNciIOB3ZVHMaYMb+BO6MIAIM7owhjxvzG9EPRrvtH9F5q697F/v2/QrDtGAAeXzBRW/eupXGLi4vx8MMPY/jw4SgsLERubi6uucbaSmuKYBFEDPkqNPnKQiW6S6gsrtin+hpHort7X7cw6E0oiRIxbacXhamu3ISNL69AsKlJdR/mcOC6+x6MR7qkPlQAkJaegSl33GntImKYiYQFHAyFBTdajjKo3b+NL6/o1CgWRc16DgcP/C4hEgp0LJiw8vlqaGjAu+++i2+++QZerxe33norXnvtNfz4xz9OeUwSWAShgpIwmTZmCDbtP94pQsVMr0GtBtPFChG1vmxh0JtQEyV6YkVJLCnBOY8/+MWvWsLAinAws7LRE029Z6cUtfsUbGrCx3/6A6669z5bziOFDFN7FmoLI6wumPj4449x1llnYcgQIfI7e/ZsfPLJJySwCKKz6CphouTDteDt3Vi0Zh8aAyFTYo5Sfz0XNVGil7Yzmo6TjyPWbSnx8Z/+gN0frYv/LLrD+2qqDQmVKXfcmST6GGNAJAru6Fj54YxGMemyq3THM4KWqNv90Trs/mgdcgYPsTXCZCXqSNiPO6Mwlh5M3m6F4cOHY+vWrWhtbYXH48GGDRswceJES2NSDRZB9ACU7BZCEQ5/IASODuPT8iof3qk7hfbLCxC8pgjBy4YiXNARsfK4HBSp6sEo2S0YSdsZTn8RUAAAIABJREFUSceZSf9VV25KEFdSdn+0zlBNk7iyMWfwEIAx5Aweguvu/yUun3IlPJEowDk8kSimTLkKE/7tl4bmpcfI0ot097G7LktN0JnxJSPsY+Soh+FwJEbpxQUTVpg0aRJuueUWXHjhhTjvvPMQjUYxd+5cS2NSBIsgugF5OlDLbmFSwT8we/R7GORuwIf11+LNxnsQdceK1j1pCJ/rFb6tD2LJ7J7fYb4/YyRtp4ReOk6tPY5aClDPquH9PzyXMF+t60naZ8o0WwSVfO4jSy/Cvr9uMHSsnREm5nAorpRkDopPdAdinVVnrCJcvHgxFi9ebHkcERJYBNHFKKUDGaDYQHpSwT9w17iVyHAKNVfrXDciyGW/2J0OYEwull5Ohes9HanFAnM40HTieFzsaIkBpXQc0CGsAEG0rXvh98jIygZjSCqGl9YO6UXEeDTarXVGSulLtYibGnbZUajZUEi3UxF812LHgomugAQWQXQxSulADiiKrNmj34uLKwA4AeVanUiGk8RVD0deLC0+oI0UTWtFvuTjtjWrrzIUIztGCtTNRIHsFBha6Usz6NW1GZ1zzuAhynVzMRsMKoIn1CCBRRBdjJqDOoewAlCaLhzkbkjYZzBO4ATyk44tzuh7zZv7GlqF6uH2Nrz/h+ew7oXfxx/24jFNJ0/AnZ0NzoG2luYkMWC0AF6k6eQJXH//Lw2tSjQSBVISGOuWP4t1y59NqeDcDqd5vXo0M3NWix62Np3GC/fOUbTNoCJ4AiCBRRBdjlrNVbHXgy0Lr8BZC9eCA0gbUIWGsBMDXR3RrtvwOv7Ef4525o5v8zgYHh1JLUd6OkbSckDHw15a+yN9iMsjJGZTYTmDBidGxDQiWUZMSbUEXirRHDPXk5aegWvmPhCfh9EImpk5i+PIPcgibW2ItKkLVLtSlETvhar0CKKLWTC9RNNZvcjrQdqAKrgLV+O90w60S0pALsXfcQ/+hMK0MBiAYRku/K7kDNxcMLALr4BIBbMO6qotaJDYU9DMuNLIztgp0zD3hT/joVXv4foHHkppdSOgLyTU+h9WV27Civt/gu8Ofo0V9/8kvupP63riDvWxVYvXzH0gLoLmvvBnPLSyAnNf+LOumDM757FTpsGV4dY4Ihm7HPOJ3gtFsAiii9FzVl8wvQSP73gSzBHCzlYh9feD3DDynByNESfmnj8TTxZY82chuh61VFOqNJ04jhX3/wQjSy/Cno3rwSPafTS10nV6qxu16pWM1HNJX6+u3IQNL62I14rlIjFqpHafLrj6+rg/l+hqL6b11FZRSpFeA2MMnGubn8pFmNnIml2O+UTvhQQWQXQDWgams0qL8es9jfGfd7a64kKLgWHPNT1/9QwhIBcm4y6/Eger/hFfRcijUVUbACM0nTiOfX/dAGdaGsIqAksqTNTmJQomJYGiV8RtVDiKESq1fcWo0dwX/gxAW+x98MdliIbD8WPbmpvw/n89H5+T3jXoiSsgOQJlyLmec3iiHJMuupTqr3ohy5Ytw4svvgjOOX72s59h/vz5lsYjgUUQPZDCrALUtiS3fijIKuiG2RBmCDY3YcX9P0l6GItiSExriVRXbsK65c+mfD49YbPvrxtQXDIWgHLNlVwwycVXezCo6GS+4aUVCaJMr55rw0srkO52a85XjBJpOdBXrnwlQVyJ8EhEtbDc7EIApQiUUSE57fNvgM9fRG1DEwqffBKNFRWof+55hGtrkVZYiPwH5yN35kzDcyG6hs8//xwvvvgiPvvsM6Snp+Paa6/FjBkzMHr06JTHJIFFED2QeRfOw6JPFiEYCca3uZ1uzLtwXjfOqnciFQxxj6jm5NV4dp3r9PF6VaGhtLps7JRp8NVUJ1kTMKcTGZmZCDY3w52djVB7u2ZRtRqiGIq0t2uuYhRrjuTRKjXamptQXbkpLoZEcaYmFtuamzQtJABjdUtaqbpUez1KUUs3ij9L05ty3KEO4edfuQoA0PiXcvCg8P84fOwYan/9BACQyLLAO3WnsORgLXxtIRRnuPDoyELLdajV1dWYPHkyMjMzAQCXX345/vKXv+CRRx5JeUwSWATRA5kxcgYAYNnOZahrqUNBVgHmXTgvvp0whpZHVGf4FVWufAW5Ey7V3EfpYX/VvfehuGSsqs9V5cpXFO0ARNw5OQi3qQsoPWEjzstspGfd8mdRufIVww7xWulQo3VLWqk6NYGmdkxGdg7S3W7d1Yfy+i1FOEdJ7amEn/1vvgXIUrc8GET9c8+TwEqRd+pO4eGaIwjEGogfbQvh4ZojAGBJZJ177rn41a9+hZMnT8Lj8WDdunWWexGSwCKIHsqMkTNIUFlETzDY7VfUdPIEcvV24hwr7v9JkteV0gNeLhDVKJk8BTVbKy0V0OcMGpyStYBZh/i09IykebpzcnDFXdpF6iJT7rgzqQYLECJ+agJNKb2Xlp6hWxgPmKvfKvY3J25QqYsL1yan/wljLDlYGxdXIoEox5KDtZYE1tixY/Hv//7vuPrqq5GdnY0LLrgAaWnWJBIJLIIgei16btxGBIPSPh//6Q/Ys+GDeLTF5XYj1Namm1Y0ujS/6cRxfPDHZeCcx1f/KUXUjEaUdFcRMgZoCAMxeqRaR6VzvFGHeHElo/Q9y80fitv/9Ib63CWI73c0HE6Yk94qwlR7QIrHGHkPpOlBPdIKybcuVXxtIVPbzXDPPffgnnvuAQA89thjGDZsmKXxSGARBNFj0RJQam7cvprq+Ko5Iyu/3NnZCT/L++ABQChWQ6OXVpxyx53Y+/VBQ9emVKgtj6gZjSjpWTSAc8XIEZBs36AU6Rl3+ZXY99cNugXqWg7xooiTGnc2nTiOxvrvsPyeOYZsFhLGjl2TfNGAGlqF81oYeQ+czJGYHpQiE6fM7Ub+g+ZWp4m2FMGmJgybPgvLX/1vjLl4irAitZ/1PyzOcOGogpiyo5tFfX098vPzcfjwYaxevRqffvqppfFIYBEE0SNRswfw1VTHrQ6UEMXRVffehyl33Km7Qk8emNmz4QPN/bXSimOnTMO3jc3x/nV6FgzeUY0omlQPV3YYoeY0HNuWD//BjhofQ9YABkiIHEnmJRdXWpGeeI2YRv2TfEWh/DwAsPyeOUk1YXo2C+KYSqsZO7sljdp7wBwOcM47Whv97L6kfXzebNQUDkTQlQZ3KIxzghwX3vcLU/VXarYU8mbY/aX/4aMjCxNqsAD7ulncfPPNOHnyJFwuF1544QXk5eVZGo8EFkEQPRK1B6qRRsC7P1oXtybQo60lsW7GiCeVVlTDnZ0T93ISUbJt8I5qxPDLa+FwCQ+K9Jwwhl9eC+Zg8dV5dpiTyiNHeo2J1SI90pWCSlEuqUO8ES8qOVo2C4A9KwRTQa1+Sx45+6qoCOFjx+I/+7zZ2HvGEEQdQsOUYLoLuz1pKPBm69fpQRK9NSiw+0v/Q7HOyu5VhABQWVlpeQwpJLAIguiRWH1wbnx5BcJt7br7yeumjBh/mm2DovSQLpp0PC6uRBwujsKLvlOsxRIjSqG2oOaKQjlSIWBHFCjVeiYjtUxa77laJEnpvVCz5tBqmq2G0evNf3A+an/9RNySoaZwYFxciUQiYfztz/9turDeKP2l/+HNBQN7RXswElgEQfRI3NnZpoSEHCPHKlkDnH/ltZpRMiN2ArV17+Lggd8h2FYLd0YhRo5+GNfMfSDhIZ2eU614rCs7jHF378K3/vvhrVuCsVNuTGllISCkBo0U/Zt9MKdSz2TkHFrCVS2SJH8vtKw51Jpm+2qq44samMOB86+8Nsn9ngcCQDSK0LFjqPvtEhTd15yQ6hO/F01Fgy7lx2uzAcsMs3YZItT/sGdBAosgiB5HdeUmtLW2duo51FaeiQ/WVFYRAkAo3Ij9+3+FaDQAAAi2HcP+/b/CmDG/SUgdbtkyBcG2Y0nHizZLrqw27N//KwBAYUFHeySliMrI0ouSitCVxIeZKJDd6NWTadksAMYjSWbESbi9DR++uBxhiYErj0YT6viqKzdh/X8tQyQirFwMpruwKy2K6DNLMBFIElnizxtvmo5genLhtZHVhqlEoqj/Yc+DBBZBED2OypWv6K+M0yAtPQPO9HRFg03mcOC6+x7UFElX3XtfUgTDKO1tdXA4AgnbotEADh74XYJQGjnq4QQhpoTScYByBEnNqFSKXhRIz/ZCCekKN0BduGrVkxlp1qx23XKUxIniYoIDQiVUWMUdf8+GD3DVvfehcuUrgriSEHU4sH9wDoZrGIaeE+SCEJOkCR3RKM4Jct37rCdGM7Jz+twqQs65uolrD8BI/0o5lgUWY+wMAK8AKAAQBbCCc76MMbYIwM8AiJ+Sxzjn+tWpBEH0e6zUkjCHA9fMfQCAsuWA0WX9qRKNKvvxBNsSzSVF0VTzxdMIc2GJv9LzRX6cGtIi9A0vrcC65c9i3fJnE0w8taJAuqs2LTZeVjv3dxGG2396r6FrNIJcnKgtJgAQF1lKiNFLtc9i0JWGcO0R1eMvvO8XiD6zBPsH58RXEY450YQBt96SdJ8/+OMyoQVPrDZMLSJ5zdwHTN+v3tAL0e124+TJkxg0aFCPFFmcc5w8eRJut9vUcXZEsMIAHuKc72SM5QDYwRj7KPbac5zz39lwDoIg+gHiX/ZappZ6cM4THuypmEtaweFQ9uNxZyQvIy8suBGFBTeiunITvvXfD1dWcjRF6Tg1qis34f3/ej4h+hdsasIHf1wGoEOEGW2ILF+1KV91aLbxstK5v9u82fD1GUEeKSuaVK+4mKBoUr2mwGKxyJNaNMkdCusahhY1B1F0vCE2IIP3jttRUbM36T5Hw+F4tLXpxHHs/mgdnBkZcOfkJPXNNHO/GisqEgrvw8eO4diCR3DskX8XfMSKinqE4Bo2bBiOHj2K48etW5LICQaDpoWREm6327TxqGWBxTmvBVAb+76JMVYNoNjquARB9C9SXTklR1pPlKq5pBXSMwrgcHgSUn8OhwcjRz2seszYKdPgrVuSlDLUO06OWmo1Gg7rrhQ0GjWUrjpMpfFyZyOPlLmylWue1LaLnH/ltQAEwRavwYrhiEYx5kQT8h95VPHYxooKHHv0MUAqPjlH49vvoOmc4YauI9LWBsaB6+//Zcqf4frnno+LqwRif8D0lObTLpcLZ511VqeMvXnzZpSWlnbK2Ho49HcxDmNsBIBSANtimx5gjO1hjP0vY8yaYxdBEH2aVFdOyWkPBlFducmGGaWGKy0XY8b8Bu6MIgAM7owijBnzm6Q6KjmFBTemdJwUK4LHTKG7OJbWMd25om3slGmY+8Kf8dDKCnjcRYr7eNxFyBk8RPG1tIyMeA3e2CnTMP3n85CdlQ1wDnd7COObw5j4yKOqoqT+uecTxVUMHgrBE9H3WRMRxWyqGOl5KDafJuyHpVK4pTgQY9kA/grgN5zz1YyxoQBOAOAA/gNAIef8pwrHzQUwFwCGDh06YeXKlWhubka2rH0FoQ7dL3PQ/TJHV92v7w5+bdtYjDEMGJIPd3aObWMapTs/XycOH0JE4cEOAM60NAwePkL12GBzE04frzdUzCuOpXoMY8g1eP87+36Fwo0IBn0Alwgb5oDbXYxI0JE0fzs+O8F9+9Tn43QgkJFuqmh66Miz49+buV9tX34JHjLWo889bpzh+fQmOvvzNW3atB2c84lKr9kisBhjLgDvAVjPOf+9wusjALzHOT9Xa5yJEyfy7du3Y/PmzZg6darlefUX6H6Zg+6XObrqfim5nVshZ/CQJEf1rqA7P19KNVgA4EhLw7X/Os/QikA993D5QgGjqwjV2Lx5M4Y6eafWyiX5ko16OB4ZTGXlpB5fXXFlgqu7lLSiIoQXPx4/pzs7G22traqrZuWfYzOfL3kNlipOJ4rKlnR7LVZn0Nn/HxljqgLLjlWEDMD/AKiWiivGWGGsPgsAbgLwudVzEQTRd1h7cC2W7VyGupY6FGQV4O4rrkPTmxtsG7+/uFpLGTtlGnw11QmF6S63G1ffe7+phshqYldcoSlfHWhFkASbm/Dhqpc02/fIMbsyTlxMoERn1OnlPzg/uQYLAHO5hLlOmYYif7NwDbsPoG7EMOwbkoM2mWWEFW8r8R7piisAiER6RC1WX8OOGqxLAfwzgCsYY7ti/64H8AxjbC9jbA/w/7P37nFSlGfa8FWHnu6eGexmUOjuUWJAhpkBScQDKgLCeNjEsGhcCZGsfu66vsmrr6JBCWg8oGAScRU37rubn7919Y0GyWKcnWDW6HAUlCiYgMwJmSgy3c1p6HYO3T3d1fX9UVPVdXieOvT0HIC+/lGqq556qrqmn6vu+7qvG3MB3F+AcxVRRBGnATa2b8TjOx9HpCcCESIiPRE8l3gdvhm1BTsHw0g9/eINDTgwrw7NNbU4MK8O8YYG4jY1lM+ra9A8ZSqaq2uI+400NG/fjP1btSQ1nUyi8T9/5UiXNmvRbeBL3JptfInb0j8sH3R3niBWL25+/hfS/a+uQdvlVyj3Xo7KZMJhQBQVofZI+m588+cj9PRqMH6/so3z+xFcvQq++fMN1xD465e4Zm87rp45T9KFMQxGnX1O3pYimvFtoqjFKjwKUUX4PgCScUXR86qIIoogYu2etUgK2jfrpJDE+vF/xtpLlxNTNs9+7zuOziFms3jn/67FhV8eVUrlM+EwIiselvQv/dEFfSWVIa3Sn7oZKRVXZqAVCqS6uyyjQmrk228wH9A0Ywku9/4vxGKIrJBc7UlRGZkcDNb3ko+XlNrVXQ/aNZz11kbctclZFJc0N9uRKx3siOKLsI+ik3sRRRQx5Ij2RKnbaSkbd/koojO7GQQhg5azR+W8iACi6Fe9QJstToO9kA8UZmlRtb2CHd2Rk9TZQHRYHE9ehvQtZcR0WiESJJC2F0JfFW9okEh5/3Mjk3Qgf6JNvYZwGM3VNQDHwb/wFgQfe8x6bjqfK1uaKwqsfL2s5jLSDU2HGkWCVUQRRQw5AmUBRHqMi0ygLKD8v35xzGbsVUPpQWu6q4e86Fm9xZt93rx9M4598Tme/Z7kr+xU8D1QWLVY6TpxnOrYDtiLbunhxM2dhPKKMeBL3JrIG5vNYnKk07CvvHiTUl96clCI64w3NCimnGqI6TSOrFqdN4GgXYMCQUDsN+sAwJRk0SJh4Dgl8moXjMeDsfcvcXSMDBrRA8xJ6OlOygrqg1VEEUUUYQf3Tb8PHi7nrvz1jlLcsvlcXP/bErz+9Lfx3jvfREffnTjvup3wT4ih6/gxpPN8K7fTXBfILdBWb/G0zxWioVrYZKIxVL5cJO2UHm//8lmi5ilfvyUrN3creMpH4bq77lG0R14hiwu/PIbKWLdxZ1GE0NsLxqV1yyeRA5oz/du/fBYv3vl9/PIfv49nF83Hr+6+g/j9yKSB1lVAiMUsr42m9Rt7/xIwNtzFY+veMNUKUsm+INgaX43gkyvzJjdmaVsaTgUt3UBRJFhFFFHEkOOGCTfg8SsfR7AsiAkdZbjq07NRluBQeWUEYy9rBePqAsPk+sb5J8bzOg/H8ag+rk0rMi4XoEtLqRdos8XP7C1/oESjEKiZNRfX3XUPPKMoHk4mtjz5Vl0Wws1dbQy6+PYfobKbTqbFWAyiKILz+wGGAR8KEckBrelz7a0HMPn7f8LEv92jkPc//uqXBpKVr45Jhpxa1BCIFQ8j3tAA3/z5CD65EnwoRG5AqVysaCAgQjz3t0Aj+3woBN9NN0qRLEA6h9dLPQ0fCg0ocmSW8qQRpnxI2amGIsEqoogihgU3TLgBf/y7P+KGjhpwAgP/xDjOnhozrDdy3zgSWJ4H585FbFweD9zlo5QqrOt/dB8ueWi5spDxoRCCq1ch9PRq7TbVAq1Z/ABlkaIt5DJGStuYmllzcfdLv5HugwPk67xeaDd3UgWeAZkMmNJS1DQ3YdKmRuJ3oj+33PS5ZFTGQN5JETyrVLHp/AAcWbXaoPeTU4uAdJ2TNjWiprkpR4QsICaTyBw5ovyb9DLAeDwonzMbsd/+Vy5NKIpAOg3/9xcR9883NSjDLOorR6Wat2/Gr+6+Q4kafpH4irj/6SS0L2qwiijCBt76pAPPvNOKcCyBkN+LB6+fjBsvKrbcLARk8hGacZT6Mi/3jXOXj0KJx+NYtExagM3e2M0qwGgw0z8NR9uYVA8hxUbBQPyWZi26zaDBAgCG4/IeU33/m2tq0XtxBl0LBAgVANcJjKrnULrbfCF22vRZT4L1OqneS4TcHE4yGF96nen5aSlE0nb/wlsUzZUVxHRaMjLt1y35broR3Vu3aXRMkVWrja16MhnE//A/CD65suC6p7H3L6GK68VkEnv+9V/wl9GlSj/HruPH8Om5YwERhlTwQIT2Iw1FglVEERZ465MOLH9zHxJp6W2wI5bA8jf3AUCRZBUAMjExa76b7ubBl7iHVDDuFDLR0EMmGoPhGG4GK8G7st/Z5wxoLvJxA3FzN0PymlGIf/s4xP5ApTAGiC8WwI42b2+rsZoweb7k7XoSrCYNvZcIiP29APRLv4QKEZ8zb8AbnU40MHWqI5KF7LH1v5WiThwHpqQEYiJB3F8mfplwGPHfvWWIrIYffIh4nBiL5fXyYAV5PNp5mzyMplk2AAgsg9ZghZZg8fyAo2kjCUWCVUQRFnjmnVZ8s+cvqPJ+BYbnIWYyaOs5C8+8U1IkWAWAHGlId/MoGUXQMIlA/PNycCUlwzA7+5AX9E/bP1e2yUQDQEEr96wQb2jApPYO7Bnlomp89C1vBoLBcEOX0b1AgKgTs4huIL6g1/a8mrdvxucnf4SScmMlqkze9dE2mTQcfe55xBd+rpArZQ5iGm1tTxoIliKOp4CWWgw+9pimYvDzO+5A4oMPzS5PmscIsQ6RLU5I1ZG0Sl79dsZMj3YKokiwiijCAl87+hGqynsAVvqFZVwuTOZ6wBz9CMC84Z3caQB5Yf7k/WdwzvQ2QxqHYYAx1XH0HDk8qKSkEKiZNRdHhC245Y3fK9si0Xr85aPlmPL/pZDu5hHeNRaxgz6NL1UhIS/wgWQS/JSvIUPwmSK1vBmp6GNPErcLbC8i0XpqCxw1ambNRe+W29HZ9x9g+VzT52yawcmmidR7IUd7Dm2aSBw3kzHOzVQczzAIPrzCcr7xhgZb5EqZh063xPn9xFQkZ6Ebcwp9VPbiG29A2X/8P8P1e9IZJEtchuNpXmfDTRYLhaLIvYgiLFDl/QpgdX8qLCttL6IgqJk1F7cufxtTv/EsAKPgV9bKDMROYKgRidZj69aL0dT0AFxlKWJV5GCI39UL/JSOE2CzWc3nVi1vItF67NgxC42bLsCOHbMQidYb9tELlgfXhoIuAG8/uMb2KBdfvRxTp62Bxx0CwMDjDmHqN57FrcvfLijRNBNpcz6fLfLgtJJOr1sa9/AKo5WFy4VxNsidXcg+Y13HjwGiiK7jx/D+RzvQ8w9/b6iOnBzpNDyHZl5npwuKEawiirACxWmaur2IvBEMLEBT04+Jn8lamVOhiXNzy6MIh18HYLRFUAurB0P8rl6gZH1La7ACSRePUeeMNdVbRaL1aGl5GNmspP1JpsJoaZFcy+VIUaGNSq1BN8xMpuz32gPMmz6bgef8yAjGiBDPGSNCZiaidr2znPQQJFUBqtObg2XiSfMZ2926T2n3c2BeHTLhsOE59KQzmBztJHqdFUXuRRRxBoHLChA4458Kl5V++Pfu3YvGxkbE43H4fD7U1dVh2rRpQz3N0wYed5C4cKa7pe9gOCrynCCdiVPJlQxXeWZAlXtm0C/wlbFuVMa6wYdCmLT+ZdNj2w+uUciVjGw2gfaDaxRiQltY8013JpNhNG6qgkSkOIRCi1BTvVL53OMOmRApxnaa0AyRaD3aD65BMhWBxx3EhIlLNWNWTX4UTU3LAKg1XC5UTTZqrcbev4Qq9rayY7DSb4FhwFVUgA+FLInTYIjZ1aC96HQdP4Zf3X0Huk4cR/n55+CCdAKhYyeV5xCQdGi+b30H8d+9pUknFsIyYiShmCIsoggLXHrhVEAX3oYoQuRdWLVqFd58803E+83/4vE4GhoasHfv3mGY6emBCROXgmW1pojZNIPwrrGDRkoKib5UFGbkCgAyvYUTmOtB80ays3AlU+T0jHo7dWHNI7LY3PIo0ulO5KJUAsLh19DckiMZEyYuhUFhrkB0lCYkIRKtR3Pzsn4SJyKZCqO5eZkmNRoMLEBt7c816cXa2p8TiZ0pqbFoX2Nlbupf9D24gkHFP4vmATYUMHvRkdOG3T3d2Fd5NqJfP0/xnAs98wtUf/iBJOpXma1a+cydiihGsIoowgJ/s3ARgHXY9el+iAwraQsYBllRRJbQODidTqOxsbEYxcoT8qIlRRTCSPe40fHhGAjxC3DdXYNrbVAIZLPmPRNZ1otvXLoKwcDgXMdA0kO06KHHnUvbyPYP/olxhGYchas8g3Q3j5NNEx33lguH1wG4l7hdjmLJz0NT0wPEMWik0C7a2p6EKOoMQQkVgk7Si3woRO6XKJvXUmCmPwo98wv45s9H65YttuYw2ND7jNEgiFm0BSsw9w9/NHw22FG24UaRYBVRhA38zcJFaO54TolUWcHufkWQYVjMTqHfYJalRVsAnh+NqqqfDjilJUNdxRX8hoDQjGMQcBKeiiAmvL7U8XkmTFyq0WABEiGUokgSZi26DbveXYnKmRGl4rNkVAbjLmrD/g8fQN+Psv2GoJ/jq9/9BBfALKpDi+hotwcDCxTCrYea/OUDuRJwB67CeizGcZyNs3EcCzOvYU6eY5KMN9VRxHhDA46sWq1oshi/H8GHV9AbWQ+wlc1AQCPNGp+x/irCrmNHibYg3d1dhm0bop14uj2CjlQalW4Xlk8I4uZAxaBfz1CiSLCKGHa07Yrig/qD6O5MobzCjSsWTETVjMBwT8sAJ6TJ5/OEhv6lAAAgAElEQVQN4kyKGMkocQfAsl6dlolBKHSrRluUDza2b8TaPWsR7Ynim8dD+OYnHojpDPwT4zhnegRCf2oymQrjpebf480DlYhmeNsLmDZ6SNYj1cyaiyPph5Rz5S5cRGKWCPSvr8IYIH5LEu1vP4WLqOSApkkybrdD/vLFDlyFl/Aj9DFSavU4xuIl8UeYEu3Ma9E3iyLKPQrVbXTEWAzh5Svgv+XvCqpLshtRpO0XeeIJxNa9ofSwlPshyteo9z978abrbdkxbIh2Ymnrl0hkpXEPp9JY2volANi+37tf+Gfs2vYeEiwDb1bEjNnX4OJ7yVHO4UKRYBUxrGjbFcXm11qQ6ZM0Tt2dKWx+rQUARhzJ8vl8tkiWy+VCXV3dEMyoiJEIF+/D5OpVpiQlH2xs34jHdz6OpCAtvhP3AmL/wqVvA7MDV+El8R/Rl5F+4p0sYHZSYQLI3lTQBS9ENxCfTddmhUKL8NkB8nbSvABz8pcPeM6P9cJihVzJ6GM8eLo9kndUhZb+Ovrc84YehQCATAbdW7c5amVjRqCsyJF6DHW0Td6vd88eYvseM2PT2qSIP/NZZFW2Nmw2i9qklow/3R5RyJWMRFbEyvd3Y9q//swytbz7hX/G9u3vQeCk8yQ4Btu3vwcAI4pkFQlWEcOKD+oPKuRKRqYviw/qDw6IYJGiYvu+VoKn2yO4rSuBpTv3a97obVUCzpyL1070osvtRXkqgRnt+zHpWIdmF6/Xi29961tF/dUZjnztAMywds9ahVwBQFkyF+XRt4FZDyNhSGTFAREGNWhaLRIEk9PVVK/EF5+/DiliRa4iVGMw7mvV5EdxvIks2O5Imevp8oGZzioTidjWJZkRKAC2yRFJWC8mk1LbHto8w2FNP0SZEE3/3/8H2V88jZazRyl2DNXHuzD9oeWa42n39WjFGA3B0/dYlOe9a1uOXMkQWBZb32/Elp2bh6QVlR0UCVYRQwYS6enuJAskadvtjHv+1DFo+TCqiYo9v/UgNl5aBnlU9Rv9pKOH0dDQgHT/W6VcCQhAIUobop14IcEg4SmVxvSUYuvk6XCVlOD8jr8W7RmKGHREe6Kaf/d4BJQnpZ9wfZuh4xhcwjBh4lI0//nHEEtUUQgRhggWAJSI5j0DPZ4Qrr66rSDzygfBwAIED3yMSMZYVF/ppuvp1HAi7jfzyaJ5QKnHT92/BJGtW00JlBn0BI9K+CwqHtX9ENXErjItItR8SPk3qTVQpduFw4RncWznCQD9BE91ffroW4Ilt9QRGUYxPZW92YgP5RChSLAGgFNFOzQSQEoFvvtyk+kxr6zYYXlPX3y/HS/ETyJ+TSl8vR7M3ZtA9zbjj1djrQd6yia/0S/e1aiQKxlyJeCBsefikQMdOJkx/thkOA6fTrkE//lPt5teRxFFFAKBsgAiPbnFcPfkk5i5bwz4LIvwrrEYPycnOj8bx3EcYw1j2CUMZog3NKD7uRfgC7HoWiD0C9qBkn0MkleKEFUtI1nRhQum/nTA56TByr/KLh6ZNEGjCQIAL8tg+QRrAT0pxRZ+8CGEH1omRZc4DhAE8KEQxt6/RBLA6zRYAKiNjvXji+k0kVzJsHJC15M4KuHrn7cdiMkkjqxajWwyaYyGxWKG1OTyCUHD/XanUriznn5d6uibNysiwZkTJ9mbreqW4ft9LhKsPLH19RZ8qlrIZe1Q5GAMn396At2dKTAsIGZRJF8gpwKtYKXH2hDtxM+ScaRLpVRJvIzDxkvLAAAXHurT7BsvJVu+daTSVF3VxyXl+OeWL5EW6Z5Gg5FCKKIIEu6bfp9Gg/XXyl642BLM/mslYu0MvKNGKVWEi/m38e/Z25BUdUm2Sxj0/eXUqRb1Yl8a5lD6cS5NyYdC4C6/ChH3poJqpGgguc43Nf0YTU0PwOMOOTq3nDbNp6qN6l0l/270kxQ5ChN8ciWCq1cRqwipmi0Tbyw9ZAJFJE0Mg7H3LzFUMRp283jgu+lGg+DeDGYu9frU5M2BCiQ++QTPJBkc9fkxtvME7qxfh2s+2ml6Dpk8zph9jaTB0rcw02G4uz4UCVYeaNsV1ZArGZm+rGa72M8nRrJwe6hglfKTyagemb4stq1vJd63p9sjSOveYtI8g83TJJPKzdO8iJey8PVm4U2JSHiMbzyVbhdVvP7RBVNNyZV8fBFFDAVumHADAChVhIGyAP5h4X3KdjXqAFTlUQavboMj+Vy1oaNvG45sqsDk2kfQ/dwLxAWXD4Uwqb89ygQ84ei60pk4duyY5ZiUkVznoaqi1Lf4scLNgYq89GlOeufJRMOJQaij3nz9BAqAwSYCkIxKAZAjaP2QI22++fNROn26IfV59LnnHbXyIV1HvKEBl/z0UawzaYoNwm+vTB5lIbtcRcigPz2ow3B3fSgSLBOQtD1ydMopCiHcPhUh30MrkMiVjFSPgBd/uMkQCaRFj+KlLDZeWoY0L/3Bxcs4cIKoyGhlyG/0k8rrNBosQKoE7CrRuonrYTciUEQRhcINE24gEioS8iEMchsc/8S4JuUooBMtLQ/DfVUSfReKSlpwVL0UxZIXT7PoFwmRaD2SicNgWWnBll3UAWtiZGUwms0m0NT0ANoPrhnUSJqZpooEp82MqeMTSIh/0fcMAna9LuzAvDoquZIJmjwGTXBP8viCxwPRJIqlTk2aReX4UAjlc2Zb2lVcfO8DCtHS98cEoHR9OGIvyzkoKBIsAtp2RbFtfStSPblvprszRYxaOUE+xGyoMBh6Mr3uygy0CJYa+kggTSjJiFDIlQyBYzCa51DGsUA3cK76jb5/EdJXEf6umyOOD0g1T2smn3faGeMVcWZDTqnobR8AibAk5kDrc7VY+o08K3yeoybQOe1UGMD9ms9ILuok2K1kzCea5QQkU1Ez8MGgRrTO+XzIAhDjcaJAnmZa6rvpRmqVHUAnR6YETxSpFgzqcQEjeQPIUTMAYFwuCL29aK6uMdd2MQwmbWpEvKEBXX/4HwjyWF4vWLcb4YeW4ehzzxuulWR6KpP7I8PofF8kWDo4IQVOUV7hLviYhUA+XlSk6N5nu48i2SNVMrnLODBgbN9HK3IlQx0JJAklXYJoSBvKOJkR0DzrQmzZcgwfXzlF89m0adMMFYDLo51YQtBguQA8XzN+0MlVsYiiiKGG3AZHb/uggOBz1XVjFhe4l+ANG02gI9F6tLWuREagRzoAyV29cdMF1JRhJFqPjKBPD9Khb1hdSMgLvZmmCQDeu/RKvHTj93F09BiMPXkCd1aej2vCYc0xJK8qPaFhXK4B9eyzirhlwmHEGxpseW9xPh+E3l6EH1oGPhjMkb5wWCFSnN8PobsbkK/TRDgvk08DUUskICQSyvxINg6h+5fgrhfNm5kPNYrNnnXYtr51UMgVIBGXV1bsQNsuqdy6bVcUr6zYgRd/uEmzfSjRtiuKd19uonpR0Y7Z/FqLEpGTo3syuQKktJ7633rIZJPJ4wmUz3tzoAJrJp+Hc90uMJCiUs9P/RrOpeiiGEjCeLu4OVCB56vPw2g+J+QdzbFDRq7093jzay3D8owUceZg1qLbwJe4ke62/+4tjBbhmz/fsgm0LEq3Ilc5iEr0Sd14WRknQzE7pWCgPQtp2BDtRN2YCZjz9P/F4hf/HzZda0zhvnfplVjzg/+FIxVnQ2QYHKk4G2sW34X3Lr3SsK/eakFvAcGPGzegtjlj718CxmWuHY389FHE+61q1JDJTyYcBkQRQiwmpQVFUSJmv3sLY+9fgpqWZtTs/xQ1Lc1gSkuBDH0tUKN8zmxbon7ZxkGeh0y6SHMeThQjWCq07Ypq0oK2wQD6rhE0qKsN9V5NQy2Eb9sVxXuv0q0SaCnNfCoC1SivcOP21TMBAC/+cFNex8ug6UzuaT5k+EpESML4NQ7Ola/wlQQnESkrA9ZidKsIM+gXZW7pVYj46NV9zS2P9jdeFjD1Dha90XLwni5DmpAIRnoBkaNfeshCY7Io3Rr66FO+4wy0ZyEJ+pYvYZbHMwsWIRuL4ZqPdij7vXTj95EqKdEcm3K78dKCRcTKOTmNR7KASHeEEXniCdP0oBokj67g6lWIPPY4xN5e4jE0t3Yr8kM6zonmTL6mfGDmMD9cKEawVLAjxlaDL2Fx7R218JSSeaqnjCemBTN9Wex/P+woajQY+KD+IEQTPklLaQ5ES8aXsLhiwUTLc9g9noSbAxVUvjtctgqkiNS7LzfhpR9vJUal5P32jS/BmgV+PLlwNJ5cOBqPz/Lixffbi9GtIgyIROuxY8csNDZOxCep+/FV6EtAFPFV6Et8zv66X69kjApJ5Oo15EpAsigNfIWysy5AricgR/2bEvuPk6NfashCY2BgEaRkKqJcn10HeTUK1bNQD1LLlyTH46UF39NsOzqa/JJ2tGIMcbssCCcSGjGL2Lo3bEVv9BEndQqyes9uhJ75BfXaSETHDvnR70MzTyUe2z/PfJEvORssFAmWCmbEwVPGY+rskCa1JRMiWios2ZOhjknTHA2lEN7qXDQi44QUucs4Zf/yCjfmLq7WRFquWDARfIn9x1B/PA20NOFw2SrQon6pHoFIjtpqS7FmgR9vXV6GhIeVKoYYBgkPi1WpOD4JaEn9UJPzIkYW5LRZMhUGGECoEBFfLKD3EgFdCwSN+SeQiwoB6I9cGZFIHECOdAnUKH08JZGHmllzcd1d92DU2ecADINRZ5+D6+66R9FfmUeQZHEXufkzz/tz12cDDOMCz/kBMPC4Q6iuXmWpv4o3NODAvDo019TiwLw6W+kms5YvasgO5XqQtqur5aiEQUdCaA7ukVWriW1w5H198+eDD4WIpyARI1tkSRQ192/s/UukKsNCgmDJADgjc0OBIsFSwYw4zFpYhTm3ViuEQO1xZTYebUya9mgohfBm5/KU8VQiY5cUMRwwe+Fk3L56Ju7+t3m4ffVMw5hVMwKYu7haQ8LcZeQf2fIKt+002PIJQXh17RSsbBU2RDtxyc79CG7+My7Zud+RXssKH5SLeOE7Pjy5cDRe+I4P+8bnVjw9OdoQ7cRbF3pyxEqHLJvz+lJjJFepnulQokubLsCOHbM0mqJCgJQ2E91QnNZJyEWU7MkiSNZEKcGF37bmNEc1s+birhdfxq3P34kpt36GcPqflOudMHEpWNb43DIMh9raZ1E37yBqa58x7MOyXkAUbacFeX40amp+jjlzdqNu3meYOXO7LXJFivRYkSzaC5ueON1Zvw7ulPbv093Xhzvr3wDn90vtZBgGfCikEbA7iv7oyFi8oYFqm6Del0SA9JYIZvsSx1fdP9/8+fDddCOVFFmBD4Xg//4iiQj23yP/ou/ZnvNwoqjBUuGKBROp7VvefbkJH9QfRDqVsWc7wOUiQPqqRL6ERfXlAY0GS95ulf4qJK5YMBHvvdpkSBOyHINZC6uox8kkx6qKcPbCybYIUdWMgGY/UiWn03tj5sy8pcW4/7LWQ3g13Km8pKt7FQ5Ug7Uh2omNl5Up1Y0kx3m5AKK7M4V/+Vs/Ul5zAktyph+pVapnOkiO4y0tDyMW243OE5sH7HoeidZTIzuyX5VAyETlIkp6hzhzyCSrK12KdS0343BytmE+Rof1B8DzoxEIfNdwza0tPgQDVwOARmel3qep6ce258dzXtv3UdEnEarq7Gh67LZ8kXVWL313MY76KxDMZvCPv1+PeR/vBBMMIkjRUDmxgNCTsSOrVtval2a7oJ+PfK/s2lGoI2Wx9b8lp/44DshmTdOCNH0ZyQR1JOmvgCLB0qBqRsC0P56TCIHbo40AkQTJwYl+W0LlwRI0y2PoPb+ygoh3X27C9vVtmLWwinguPSkCgDm3Vg94Tup5DfSa7QrUN0Q7NeRKhtyrcKAEy8xxXt3SR36+YgTHeT18vUaSf/7UMWjbFcX29W15Ed0iBgek6FI2m0A4/DoG4jwO5MgMDbIZaPwH2jShWpMUCi3q12BZQx2EcHNplHAsHrx+smYfmgg9kzmJaPRNQ7qutWWLZr9gYIHhHuQ8s6xhV+tFtAPQz9lC06N/kQtmM7hj/X8ShevXfLQT13z8AUK/+LlBuK63ZpBBIj9cRQUYj4dowqkWtFuRFv15zMiJnXtFQiYczvVkJCGbRU1zEw7Mq6NaR9BIrtWcRwKKBEuH8gp3QVItal0WiYyYbVcjH48qJ5DnIFcUqqNZyZ4MGl9tLti58pnXUODp9sigiuLNHOefXDgavt4s5u5NKGTL15tFnJImBQBWEDF3r3EBO7D7CJp2RJAVcleT6hGUStEiyRoe0Bd8o5GnU68ms4o6po/BqP9mcVb4PIzO0nsE1lSvBAClihDg4PfPwFdffWKalnNzadx24f/g2ose1Ww3IzhOrlHdyJnnfGAYF0RR/bdELt+2Wy1oJxpDS9Gpe/nVAvi1qpdgvDeC8K7tRL8nPhgkntcsWqYnEh1btiD45EpHRp+kMZ3AaT9EDUyInnx/XV8bTyVYJJJLqowciWSrSLB0uGLBxIIYjRYqXUMr13/vlcIumrSKwqwgnvYtfsxIVCFE8TTHeTkcoE8Zzt2b0LT6UcPbl8X1u3sNzawBUC1GRAGn/Xc4XFCTAJm4AD7NPnYdxwEpkrVjxyzb6UIzMlPzzWcR/JvcGGY9AmuqVypES4b62mgKdzZ71LDN6npJc9bfx4oxcxGNvqkQPMk7ywWeH41MJkbcB3BWLWgVnaJpeuINDYZefmIshvDyFQBy5IXkvj72/iUIP/gQeT4O2u2QojcH5tXZIkGM32/7PMrcBqE6T74fkSeeQOKDD6n76UluvKFButf93lqZcNhw70cKigRLB316Kh/o9UIDSfGZVSHKkaxCwOxa870Pp0q6itpyByhIr8E7sl78LNNHJEwy1ClDmTzJzar9SRGrpp+PmwMVefmGAUUB/GCApq3KZFZp9pswcalmPyuo04WAUY+kJl40MuNxhwbsWq5O1dHsEUjRIo/3fFOCpT8mnYkb7iM5ZZkGz3kxZ/bHyha//2LT+2MGM0dzdcNjPY4+9zy5l18mo0ShzHRN4Z8sJ7uZc8aoNSlSg1GjiHO2RdB4HsGHV1jupj8v4/OZ9hl0DI5TxPzhnyyn7kYiuZFVq43GpZkMIqtWFwnWSIeaDLnLOKSTWU3KxQoMC1RfnktvkVJ8777chMjBmC3NklnKUq4++9p12u1bX2/B/vfDELPSfKZcFTI9l5V/Uj7RuLZdUTS+2nxKpKtIQlUGwG2hwpiMlr8dwQ3lokKYpBMYyVa8lMW+8SXKfr7eLG78sAcXHurDzd+W5mH2PHjKeKplSFEAX3jQtFXJxJfYuu0SVFX9VENSrKJB+nHaWlciK6YMBA7I6bRI5G0wPJ/snqe55VHEYkb9kdkxfakoWNYu+dRGUkh6Lbug9fizakNjFs1Rkxw10ZIJi6keSUe6Ik88gdhvcmJ5WaslPPE4+XiLHn92U2kkc1PG5QJ43rYjuxnkPopHn3ueGs2TQfouaESvoASwQCgSLBX0ZCjVI4DhzBcuPcQs0PJhFMGJflTNCFD9jz7dFlb2MYNVylJabHMVZVtfb9E0pRazUP5NI1lm/kksx+RV2fhB/UEiMRUF4L1XmvDuy01D4kC+IdqpqSSsGzMK5/ck8f3Nf9ZUFgLkisNCoLszhQs7cxWDL3zHR9RYeVOiJjUopw7d5bk/U9rzMHV2CMGJfgOpBbQVrUUUDmbpuUzmJJqblwHIkYBgYAEi0fr+ijhrkkVqKZPNJtDU9KBmXIAe5Xrrkw48804rwrEEQn4vHrx+Mm68qNLppVqeRwbNUwuQomrqY+S0YDb7PeoxxjEK53Nkt3pOD9Nefgxj6ONnVyCu9qOKNzQgtu4Nwz5iMonMkSPkAUx6/NU004u39CBqxNJpgGHA+P0DIjJ8KITyObMR/91b1ulMjhtxESmnKBIsFUhkSBQA3s3h7mdn207PqFuamKVm9LoYs1Tiu//ZRPxN9pTxAHJz3v8++Q9///thKsEym2PtzGBeBMhsTLWHWL6CfTtpV30bi8OpNF4Jd2JFVoQIoxXDYPUX1EedSBorL8sAHhb6xEOaZ7BlWqnybzsVlqdCWvZUhkwMrEiSKKYNgm47x1lD0ESyaFGctz7pwPI39yGRlhbejlgCy9/cBwB5kyzraBF9kZ85c7vy//r0qh0UMjKnvHiVn4fKp15w9EI19v4lBg2WAlE0iNVtCcR5HmJvL5prasEHgxB6e6mRLvm8hnZIfj+x2TTn90tVejZJpKm5aU8P2RCNcE6mtJR4TrtaMf/CW6hj065zpKFIsKBdrEnIR78iH2OW0lFvt0ol6q0UZGTSAtQt7mkO8bTtVnM8sPsIPv/0hJIyZcAg2ZOxjD7ZrcZUk1G7IN2r57cexI7EURwVs0oEitTGQo98rRicpGH1UacLD/WB5RnsuGyUMt+6MaPwSphsbHpU9+WZVVgWqvpyWesh/DrcCQHAiu4E/tB6CD+fPH7A457KiETr0db2pKMmw3KLFyfpQUAiEyzroZ7LTjXeM++0KuQKAGYEPsJ3J/0e5Z0nsXWrZGwpC8bz9eAyguappY3Y2u4nKABgAe4kg/GlNw9ojjIh+Z/Kr2PND+5SegM69byTiYKZWF0mSmPvX2Itpvf7gZ4ehTRYaakYl4uYxgPPg3G5NMSPcbkgdHcDqrFplhAyzCJ0RFKpn5/Hg3H9FZUk2BLMMwxKp08nfjTu4RUGgsu4XBhnQ1s21Djjndz1PeJIkPUrUrTIHuRjzFIzal2MWSrRrAl1pk9ESpW+pDnE07ZbzTHVIyj3JtUjKJERq/53VyyYCJaz59zrlMDq79W+8SVouKgUR8SsJjJFrNwjwKkVg5yGlXmPnIbd+jq56IDkVr9kzkT85eppiMz9Jj6+cgoaT3RRzzfU7X2WtR7CK/3kSsYr4U4saz00pPMYSZAjLk7IFSC1eGluXqb0AaTvNxoedwjq1i5VVT8lOp/LsPJ7CsdyBGZG4CPcPmUdzvaeBMNI6UfpWoy9CYH8nOcj0XowDFnrFwotcjR3AGBSgP8VDqG7SzDuEReENe9bHkOD2qn9pQXfMzRell+07MI3f755NZ7KDZ7x+ej7MQy40lJbxEU5pKSEHBXLZICyMo3jOcrKDLopWlsdGXm3tiE40ZNgt90ObY6++fMRXL1Kc53B1atGZDrxjI9gbV/fZmrJoK4InLWwyqBxYVgGYESNxYH6mKoZAUQOxjS6KBmZlIC2XVHLVOJ7rzSZ6sC6Y7ljp1wVIp5rylXkflPyHGkRMjOYRZ/kbep0FQ1OBdj6e7V5mtdQoWcVuVLDKYHJJw1rFVkyI3mFqGR0gl9TImm/DneesVEs2xEXFRjGBUFI6byb6KBFkSTNlfFv00qPFPJ70dFPsr476fdwc/R5qCNikWg9mpuXKfNOpsIaPRkJMgEVRf09YhAK3WqwgLC0rhAA32scSj/ORb4GYhWgJiS0BstOXrTiDQ1SuswCYjIJzuOBQEmr8cGg4+vK9vRSjxHjcUz68APl3801tcT9rLylGJ8PSKXsN16WHdltwK47vdl9ORVMRoEzPILVtitquvjrmxNXzQig7rYaTSTimttrcM1ttaYNjefcWo2ps0PqTB4Aycjz3ZebLLVdYhZIJenzzAq5B1s+lxyxYlhJAG1VsTh74WRHTZdlmBHDqhkB/OOzs3H3v83D3f82D9feUWs4Rz7tgcor3Ng3vkTp7UdqG2MXVv0JScgnDWsFGskbzbF5a8Py7a1Io9nO6PfpBeuICwOGyWnl5H54othra/xM5qQhigRIhIbWn89Kj/Tg9ZPhdUkEZYzHOvImpzObmpYaSKEoptHW9iT1WBoB9biDBnIFgNqXEJAMUv2vaMkVAIBlHTViVkOd8qI1XnbyokW1aiBAiMfhX2QU8ssWBM4bFIvUY/TbqWOzrOYe6nsxirGYfXIFSAL7/qhd+MGH0FxdQ/2efPPnI/jkSmqTacu5n0I4oyNYZtVzAIgaIzNXdhradkXR8mF0QNpWkgmoDJbTEow5t1Y7bltDEk9nUkJBo0+FaIGzIdqJ1deWIy5mHTcPPbdf6+T6LAoGMFQL6isOacJXhqWTKTkiaTZ/0jlIVhFelsFTVec6Gkf9uV7gf3fzITxyoANPTao0JW32VDSnL0jmodZmoSIYRkRNzT+jtcWneDU1NT1g+7w0XZXdCj49ZCH7M++0oitdirNKzMkez/n6xfPkh9ssPUq7NzRiqr6m3h5Afuo87hCCyXno+/S/IUIX4eivksvLWFIVQbqzfh3WLL4LKXfut8udSuGON3+N+Ik5tsZ0EnXig0EEH3vMtHceyS5CNIkg0Swm9J5R1GiRIGi0WANyaqfAqgWQ2sLCzrWcijijCZaV9ked/hqIWShNX1UI8CUsyv2F8Tiy03RZf26r6BPpvt2+emZe89sQ7cSSli+RhuiYXDEAPr5yCgBgS6Qdkau/aRhbT0howldaGhYwd0y3cw47BI80zpJ+8nQyI4AFbYkETmYES0HvD0IVRMH9D0KDU2U5ktDc8iixR2Ag8F3NdhJkC4Vs9hllG8/5iXYLNJgRknwE3jdeVIkbL6rE1m1uZDJ0gsWyXoBhkBWcpUEj0Xq0Nj0FkfInqU5jkojrzJnbsWXLFlx9dZvmuLhwSa6nHmAkGg6MJeMNDZrjlcbLCxbhaMUYjO08gTvr12HeRzsR2d4IwJq4mVo1qMEwClGgpbVodhHhRx8DEoTvg2UtLSY06T4vOVKobs8zGE7t+nPQ2tvYscto3r4Z29e9iq4TxzFqzNmYteg21MyaOyhzLiTOaIJlVekmf6Y3zezuTDnq0TdYLtoyYQknCuforq+Oq5zkR+xYwnEVIWCvj6IVcVVHahjQiYMV/Jwxjagem4UxakOrMJxzazU+3RbGvvEleOeiUiTc0sriTYm4/pNe3HxkxsQAACAASURBVE44/4ZoJ+5tPmR6DrtWEaTqyDQk8gRY3yOryklZZ/VrldD99lDFaa+/ikTriSQqm02g88Rmw3YyBCSTHYhE6xEMLEDV5EcdRbFouipNXz7eL6VjhLhpNMtu9SLPj0ZV1U/7/bno4DmtqFuxWkCCSK6yGRYTapdq9yWYpupbCwFaMtJcXUOcj10/JpJY+pqPdhIbMpv1BFTDro7Iv+h7Bk8sGsnQnzP80DLyoP1aJxph00eExF46sZaJlW3CmAcy4bD0HaqiiProlpmmqnn7ZvzxV79Epk9aR7uOH8Mff/VLABjxJOuMJlhWJp5y+mv7+jaDeWNWELF9fZstglWoBtJ6ZFIC3n25CYFZCcvUlB2QTEoPt8ZsabhIoPVRlKM8VnYLfp5Dd0ZQvKGslrdz+6M+S5oPGfykurMiNkQ7NelAdRSIloGlVSK21Zbiv2vdyKoqJRMeBm9dXoat2/biqapzcXOgAhuinUpkiQanVYyD2YBaxs8nj1cI1ZYtMdx7GpIrfURFivCQnzJpn5C9noJiVkn1BQMLbBMsmq5KT07UqTqSu7t8jFqoTgPPj1bSmdK9oF2fC1WTtU2daborUQTS3TzCfxqLqdPobXbklChA13YVAk6jM3b2J0VdyufMRvfWbdQoDMlawcwygdqehtBSRw0n6T5Z52TWI7Fg0EUh7ZLZ7eteVciVjExfCtvXvTriCdYZLXKXy+fdBFdtdfqLpkOy6+5+xYKJjgTkfAmLqbNDlvom+fxZIWtqmdC2K4pXVuzAiz/chFdW7KDuZ1Ydlw+s/L+s7BZOqsiVFVxMTqxOojJpUVuGbccjC5BSiyRx+JZppRpylTuAwUkhi6WtX2JZ6yEsbf3SlFwBzqsYC9WA+kyGTFpk+4RkKmyZyqsYM9fUNkENdapPsl8wguf8BmsGUiTKqoIxR1RyaGt70pJcMYwLY8d+G1u3XozGTROp5Irn/Kit/blhbmbC/6bXJ8FbPkp1j8mwY9dAM5C0ayxJFUtTZAb5iqtLp0/HpE2NqGluwqRNjZp03YF5dQg/+JDRId3EMoG2YliJI2wTSl360ux+8qFQXk2irWBnrl0njjvaPpIw6ASLYZi/YRimlWGYzxiG+clgn88pqmYEcOezc3DtHeaVgAM9x9zF1RofLXcZpyFRctWffO45t1bj9tUzbYvI5ciQHltfb8G7LzcppMbMv6rQ1XG0ucvb7dgt2IYo4k/xbixt/ZKaIlNHbexGgUSA6I+jN//UI5EV8etwpyWJy6eKcaC2Dfmc83SDc9sFEeHwegQC31VIkZQyIz+v6lQfqWKOZb2omvwoZs7cjrp5n2HmzO1UjZUdEqLfx45flygKCId/Y0IsOYRCizFnzm7i3MxsImoXf4bAjA7Le2yn9c24h1dIvfBUcGIsSfJ1Yjwe+Bd9j7jdjrg63tCA8PIVStWdLLzXV81pqvMooJEMIR4nbhdNWuIA9gmiPn057uEVxPsReuYXmLSpEUHC5wOFnbmOGnO2o+0jCYOaImQYhgPwIoBrARwG8BHDMP8tiqL9xkhDBH2Fm1WFIQBi5MsMmXRuUU71CGj5MGpJ5KzSmGroCUvbrijZf4viX0WrjjMzKTUDae7qyKA+dToQu4U0tJohEvx87vuqdLsGZERq53grWwMOwJrJ5zm2Ybg5UGGZdlSDBeDjOcQyQsH7LJ6qsENajEij88Rm65YvDKtJ9dGqAAF1+ixXRafXVFlXMObbo8/qN0VANPom/P6LiQSL1AAakAJDJeVpiDbizxVj5uKIea/5vHsG2jnerLLPDJFVq42NjwnCezvpOjPLBRIx05NNPYgVhi4XUFYGMR6nXqfVfdZ/7sjGgQC7ZHbWots0GiwA4EvcmLXotgGdfygw2BqsywB8JopiOwAwDLMOwAIAI45gkfRAja82Q6RoMhhO8o4yG08t3k6nMqZ6JBrkz957pclWJOlf//cmpW2LGUkkpe/yMSk1g5Utg56A+XqzxCbIarBZEVmWHDWwohvxjIAN0U6MAYi2CAzIChxSOo2m9bILL8vkRa5kPDWpkjp/dRXhaI5V9GBF5EAjLTw/2sKOQEvMSOQpm6006KFy+iYOyVQYba0rIWR7VGk8oX/8MJqalvW35JHa2FSMmYto9E1qNIik3XJavUiDVUselvU4NmBVQyoemGe5Xz7GkpEnnkBs/W8leweOg3/hLQg+9tiAxwXoAnv9dss2OSYkg2bFwI8bZzqmXUJqVdVHG1vdUzBfYTwfCtkms7LOqlhFaEQlgC9V/z4MYMYgnzMvkATZemG7DIYFrrmtlkqMSGSNBjvid/k8diJZctsWq7FJ6TtZyG63x54dWPXNA3IE7G/a03jrQg7qWXOCiJK0iISbga83i7l7E/j46tHE6BHNv0lGFsDS1i/xXEYg2iLUjRmF9dGTBi8qdTpNXXno5zmkBAG9Dl/kSKTHrgeXDPmzJ1oP4aggojyVwNXRv+Leiy/EtGnTnE3oDAQp+sKyXlRV/dRU7E2KFOktFLZs2aL8vzHC1e/lZEp+0grJS6bCCIdfA8N4+8lfzFYVoVS9uAzI+xUgB1K0L59mzbSxCQW+A0bkiScQ+8263AZBUP6tJ1mDCbPqPCuSQSNK0VGjLM9rRZSIgvsVDyOyarVplEsNq0pKxuWS0pkqh3fG5cqrrU3NrLmnBKHSgxEHGOYzHZxhbgFwvSiKd/b/++8BXCaK4v9R7XMXgLsAYNy4cRevW7cO3d3dKC8vH7R5kXDsEL0XHAlnjfHCTehNmOrJ4KsT9n90kh4WXaUsMiLAZUWclRIxtsxNHbs7lkJWyEotegCIWRF8WRaZHuOvFMMyEGkaoP5wB8tJPlqk8w0HYhkBkVQa6awILitiVCILb1/uGliOBTfOgy+TfZoINQPAk+lDgnfBSgYazKZxju8s8jn7DxVEwMUyCLpdSmoxlhEM5wVEBDgGJSUlOJTos7g6ad+xpVo9DnlcCfo5qJFIJBCPx6H+G2YYBj6fD16K9w3tGZIhPw8AlP1c5Vl43WUj5hkpFNKZOPpSUWSzabCsCyXuAFy8D+lMHMnEYRjjmQw83nPh4k16ywGa36+enlZkswMnOdLpWXg8ldTz66+H40ZBELqQzabBMBxEMQvtNdFitlqwrAtlZdpovd3rYhgODMNS92VZF0SxsuC/98n9TSBfGwPPFHL7GGfj76d+5pkyRfl/IR5HuiOs1V4wLFyVIXBmPQpNUIj1MdXWZu1Eb2OeQjyOzJEjENNpMBwn3XFBkMhVNquYw2qGdbngrqoa0PydYLD5xNy5c3eLongJ6bPBJlhXAHhcFMXr+/+9HABEUXyatP8ll1wifvzxx/3Gc1cP2rxI3kt2U3Ay+BLWoJ+yMubUY9/4Erw9owx9qpSXKyNi/ie9WDLHnpHpiz/chLFX9uDozjLDZwxn7gBvdi3DDdK9VM9THfE5hwW+2fIJJkS+wIFzKvH+BdOQcpVQq4RWdEdw7/xvATDaNQD09N0lO/cTI2ejkr3YUFmOf+jmzHVZoojrDvwZf66+CMeyOSf5p9sjpseR5rN371787ne/A+nv1+fz4f777zdst/t8shwDEbn+mmOv7EHnx6NG3DMymIhE6/vTdFIkief8qJr8qC2zT/XvV+OmCzCgFg46eNwhjQZMPV9SRE5dmUgy+gSAttaV1IiafgwZdq5LfazZ/FpbfHn93pOup/QjVor4mKSualqaHZ9Lj7bLr4BASBNyfj+qVL0AAXoqLl8UYn1srqm1raFyks6zdQ6GQU3z0KmEBptPMAxDJViD/Ur6EYBJDMN8HUAHgEUAbh3kc5qClL5792XnX3amL4t3X27CtvWtivmmWQsVEjZP82rIFQCkeQaNtR7MsNBmyTAToNshV4B0Le+9It2DkbKAWum31Kaczz33HOL9FTeTjnVg0rEOHDinEpuqL4bIGm+QS3XPHznQYaj0S2RF3Nt8CPc0H9Kk62iVh11uLxobG7H8+7cbyJoa7nQfNk28EJn+Z0R2creqNNQbg+7duxcNDQ1EcgVAuRd62O0oQEqN29ELnk7I1zldDzsCdSegifNJVZF6/RTtmsh6MfOWPPTr4gBkDceatftpbdli48q1IBqX7l+Gs37HoTRs8oxbeEjZxbiHVyCy4mFNFIhW2TgSGxM7MRa18utyeo7TocegXQwqwRJFMcMwzD0A3oH0l/cfoijSY6tDgEK3rUn15FiMUzsDWtVcvJS11GbJUbiBNBhWQ8zC4LI+3DDTb6lBIhSTjnUAALZOvggZLveYe/tTboAUvaJV4slb1e1saJWD5SkpVScTIFKFHy9kwACauQASebLSjgHaSsbGxkakTcL7PkpIv7szCWsXHToGqyPBqQ49KUlncoJzWqUdDTzn14nftaBVC9J7AYaJc6QRJz0Rkv219PvSNGw0Ly95jEKQVnl+BkLJpNH1rTRKd5ZQj/MvvEXz73hDg6Q76o9GcX4/xj28wrS1CzDwysZCYCCRMbtO9DLsmILqiwq8l10KobPztOwxaBeDLqoQRfFtAG8P9nnswskiwZewg9ZDEKBXzfl6s6b+V2apHlmY/vmnJxwviKdqlMLn85mSrD9NmIJuT6kSjfK3nFRa19iBHEFaPiGI+/b/FRk2953xQgYz2vcrpEaOrG2IdmL5X1rxlcuD8lQC449H0FQ5gTi+AIn4mUWy1JWMtAgVALhcLtTV1Rm2b2zfiG53EuWp0VaXS4WTxt5nCkiRlGSyA80tj6LzxGaptQ3nA8t7+tONMp3W658YhEK3oqZ6ZX8/xNcM52IYF9HpXQKtAyVr2qZGT3js7uu0AfVAUq4k0CJ5Aq0uRFdFqCdWyvGxGCIrHkbvnj2I/+4tU9f14YhMxRsakIpE0PzDH5m2nrGCniByPh+E7m6j9YQK6opIPblzfW08Eh98mNtZEJD44EN4r7gc6S8ODRsJHW6cXqpVGyC1rdk3vgSbp3kRL2WVSrUruhlcsWCikqIaDNQ1JfH7i8vQpwpkuTIi6pqSpk2UaVE4hgWuuV2qbgxSSJjLzSGTEajpw6GMUuzduxeNjY2Ix+Pw+Xyoq6vLqwKurq4ODQ0NhqjOgXMq8dEFU9Fd4tWk+t76VGp4bDODCkCKIN0cqMChQ4fwryd60eX2ojyVwIz2/aiNHUWd7kfj5kAFJh0tQ0NDA5r8Y7F18kVUTdi5Oi2WfunVVzLSCCXDMJg/fz7xHq7dsxZl54Uwp30RXFn6Gz4Ndhp7n4kgGpaKWU1Pw4wQA8t6UVv7zwqh0DeVBkTFc0qyLjCCY8tMCAntRTBrK31odj1SE+sH+lv+cAiFFqGmeqUSkZKjY01NP0b7wTUGokVq25MRYv1VjgCpF6F8HI3A0VKUnLHpAvhQCJM2NSr/1lfQ6SGm07lIjHq7zdYug4XIE08gtu4NiPfc3T+h/FrPyNATRIU00aoe+1N7pApE2jGJP32Emv2fUudQaH3aSMMZ1ypH37Zm3/gSbLy0TIokMQziZRw2XlqG8ntrUDUj4LjNDQ3lFW6DW/ySORPx3JTxGMewgCjC1yPgu80pS4E7jQTJaT65L+HcxdWa8117Ry3uWjsH19xWS9VuDVWUQtYRyUQhHo+joaEBe/fudTzWtGnTMH/+fCWK5PP54Pv2jdg59TJ8VeKFiFyqb0O0E5FU2labHD0Cm/+Mn/cAjLcU3/miCT/Y9Udc0tetITUbop24ZOd+BDf/Gf/QzaH02hvw0QVTDalBGTJ5ujlQgY+vnILo3G/ilzXjca7bBQYS+dIL3Ovq6uDSmQ26XC7cdNNNVIIa7Ynis3N2Y+uEdegq6aT6u6khPyMsN/KKIEYK6IalxobR6nY2pObR8j60MTNCDJFofR5zpKUPjeexNmAVEA6/huYWKVpCajnU0vKwZp7tB9dQUp5pQ4sfGVbjEt3xRRdG/cHamd1Wrz6KW7rTvoaFQryhQbKZsBCmD2R+vvnzMWlTI0LP/MLU4d5Jr0MIgtIqqLmmFgfm1Slu9xqX+343/MhPHzW44Z/KOOMiWPIisX19G5I9GWJ7ljTPKKJivdjaXcYh1Ss4Lgzq7kwRNUVVgGMTSLPm0eo0H03DRPLV2je+BJu/4cVXpRz+Zef+QXf7bmxsRJN/LHZNmIJuVTSotLHRcRSrbVcUn9R3oaTzG/h6hRtXXDkRt2ZOIKErDZdTfbflQa7UR3wlAu98fSqe/9a3DF5WatH64VQav0gBYgm9fx2pWlEt4CdBvj9Oon+BsgAiPRF8ds5ufHbOblxw7GLLaJaYBe7+t3nYsmXLsJErp/5gQ4WN7Ruxds9a/NNZQIXNX1E1eaERGbWrOwnNzVLUR18ZaA6yHQNJz2VXlB8Ov46a6pW2omNmpI3mg2U1Li1FWXoTi6Ofm0dEbJEQjiOSrOESaNP6FepRiPlZ6csckTiGoTa4JhE1MZk0uOGfyjjjCBaQE09vfb0F8VKy+FQtKlYTlbZdUTS+2kystJId29XCd/VnNJBsI8wWtPOnjiE6rstwYl76Qf1BfFAuYuNlZUj3m0AdTqWx5NMvEP0shruvIuuGrGC1MH5cUo7N1dOR7dczdXtKsbl6OtCyx9F5aFWhhxeOJqbkOlJpTRVhvpCbR6uvidRA2ozKnet25U0Wpk2b5oiI3jf9Pjy+83EkBekH7bNzdsPFujAv+j0IX5HDmcOtuSIR1iXNh/DIgY5hbfuzsX2jci9/L/JYNDoNO0FuNaExJzL05LUoptHW9iTV+oByFPQki+T+DjgR5YuIROtNiKK62TX9Wj3uIEj1GnbGJYrm51trkKwq6BiXC76/u1mjwQKGV6Bth9QUcn5m+jInFYiM1wuxt1ezTU5l0q5JjMUQb2g4LUjWGZciVGPOrdUYx5LLdkntUQCJkNDI1e2rZ2L2wsmGlKKZfkUmCOpmzO++3IQXf7gJr6zYgbZdUbTtiuKVFTuUbQd2HzG9LrsLY9WMAG5fPRMfXz1aIVcy0hyDF+IniU2hrSAvjIdTaUN6TsbOqm8o5EpGluWws+objs5F0qPtG0+PylS6XQi6XfAWgGTJJFxOC5p5WenPNtQNl2+YcAMev/JxBMuCYMAgWBbE7TfeiB/+4hpce0eto2d2qEAirGkAJzMC9bkaCqzds1Yhqnt6XVh30oXODGOavdETGlKKyy5kobizhtWi0qTa4w5Rq/2CgQWorl6l7GuG9oNrqFWN+mbXDEP6PaWL9u2Mmy9IzZ9lcH4/gqtXIfjYYwg+uRJ8KAQwDPhQCMEnVw7bom8VmRrK+dGaZ3uvuDxng8Fx8H9/EcQE+fnMhMOm13Rk1eqCzXc4cUZGsNR4tPpcotEkbfGjRYfk7Vb+TXqY2Uao+yHKonSr6FQ+CyPN3ynuZfOqKiQtjHovpwRPJkG07TSQ7sfmaV5i9IoB+qsIj2HN5PPwSNthnBTMq0TNvK4r3S6iUSkJInKJn3OHKfJyw4QbcMOEGwzbnT6zQwXac6mG/rkaCkR7tC8de3pd2NPrwnPn9lKOgIHQaFNc+flkOWtYzVlW+0nC+3WQnlIOoZBkWUiqaJTPX1v7rEHArq92lM+lriJkGC84zoOmph8jmXgQkWhcMyeaDQS9itI+7FosjCT/Kpqtgv/7i4a09Q9g7/7J4nXqWwfDoHzObG07IxWE0ySKdcYTLFJPOrPFj6Z/UkeN7Po3AdaEidYPkQSGRV5iZJq/k683m1dVIS2SY2fBdArS90HzFxNFERd+0YcwpO/96faIKcEazXP427E+vB7uNHR0czGMUvlnVzAv2zGQnq/h1ho5eWaHCrTnUo/BeK7MIOvZnIAWLQoGFmDHjlkUkkWm9zznB2CWeiMdl2smTbJdMFpDSGL2UGgxGKYUomgkjzwvzUO/hpLWVHU6T05tymQrm02jqenHaGp6AB53SEMA7dpAOMVIIk92oCY1QP7u6oWcD+3cVlWaAABRRPfWbRqrCT2Gs2KzUDijU4Qy5AquyNxv4uMrp5gubKSqwoGkUwqlc+FLWMWiwSmWTwjCpSNyroyIuXsTjue3IdpJTSyo066jKR1eadtpuGLBROyf4MYL3/HhyYWj8cJ3fPCmyH+wvt4sNr/WglSP5PVitjC/WDMezbMuxM8nj8fzNeM18xrNc3i++jxTd3ca5IiLjA3RTtRs24u7mw+ZplTPRCyfELSVyqWl8wcL902/Dx5OmyLxcB6TjJrxA3Xav+PjvwUD7d8Zy3r7I0jGv4ex46QoJLGSrv+4XIrPKIHQVzQC6I9cGREOr0NNzVPEFF8m0422tidhbCid7t9OBjm1Kf3NygSwueVRKrna2L4R1/3XdZj2yjRc91/XYWP7Ruq5TifIVX6eKVMwaVPjiCUfdqsMM5GIaVXkcFVsFhJnfATLKQqdTrliwURH/QtpGEgZ/c2BCkQ/i+GF+EnEvTkvsIuiGVyxuNrRWE+3R6gptboxuS7wT1WdiyXNhzQ/za7+7U6w72uSzYYcw4qXcWAFEZwgQlDpymTCmOnLojsm7U2LkOjF52ZVfX6eI7rBm7mzH06lEdz8Z/g5Ft1ZEWnCj8xwpL5GGvTRZdL9GmotGwAlzbp2z1pEe6IIlAVw3/T7wHx+L+UI7ferL8w41nwx0skMKi9rgCAe1fQJDId/YxgtElkPv/9iW1EeqWegEcb0Iu1pFRAMLKD0K0wrUSg9MpmTiETrNT5Z8hytUqLZbELjEaaOuu3p5TXFGpGeCB7f+TgAENPfTiGnttKRME6exeHXc0QcvKwS902/ryDjnwmwS4xkDZaV79apjCLBygO0dIrTakB5LAADMjRlOXbA6Z27r5qAa/Xzz4O0mUV0Xg134pVwp6JBer5m/IDTYk+3R6C/a1mOgTeZRUkyqzGPvfBQn/R5f1pw+YSgI/2dHhuinYhTWu38IFSBxhNd1BSXCFjqv4Y69TUSoSe3w51KlUHSs+2I/IxIHqRoUg4k3WXsrzOQic/G7atn5sbbMQskA1FRTGvsCszSZjRCYxSL014JpAhYRqB3D6BBjpLpneHtgewRtjbiVciVjKSQxNo9awdMgNSpLQZARVzAXW8D/47DeDz5OIDCkLjTHXaqDNUVj/qejtIg/GnRUqdIsCxglzSR7ALs9vbT20A4aT7Nl7Ao9xcmzVgIHY6Zbkb+yZRTYGsmn4ePr5wyoPPRSEjSw+Lxd3uIpJXtT/c51d/p8XR7hOqf3Xiii0jgnGCoU1+nAqw8woYTsjBbDZIw26pQRoaVf5STOVmJxUOhRUQxeyi0CEB+TavlXob2Kx2tx4v2lBI/i/ZEB+wKTkpteTLArVtE7JhSGBJ3JoAoyOd5cOXlEOJx4ndzZNVqCP1tixi/H8H+fpCnOooEywROSBPprTSf3n5VMwLUaJZM8PSEL5xocXppgwa7pKJQKTAaoat0u4jpVz0hHciCbRZhklvrADkC55RmDXXqq4iBQY4k7dkdhWSHQBZm2ymUAaz9o0gg9fwLBL6r9EWkzammeiUA6KoIFynbyf5YZjW28vwLp6PxuIMIlHk1BQbTS9P4ji+D0ZyIT07ej1EhFqVhzrI3n6YtDMVUVMaYr6T/6qtHiyDDaSPsU63gwAmKBMsENNL07n82KVEmTxmPWQurbL+V2gGNGMjRMz1hC28ZOQRLJhX3Nh+y7PVnp0LMCmZpvqr+uQwWITWL1snRJzWBq9m21zItKGM0x47YSI2MfFLipzuCgQUoK9uCq6/+jLqP2d+3GhMmLkVT01Lo04RqGwS1vonnfBCyXRBVjUYzQgzh8HrU1v7csgKvpnqlQqhI1wXAtpZKjpINxIaCNN59wZwGa3ppWmPyKlSI6Pz7LE6WeVC5NU3tzWeocjMhVwBw4izpv4GyM/vZdoLTmTQ5QZFgmYBKjlQvbcmeDBpfbYanjEeyx9iJvLzC7XghGqm+RHYhEwOrSFYhSljlc6k9rTxsbmQnhNSpvmf5hCCWtHxpEKm7ANyR9eKVFTs031+fzWvysoxjsf9QYyAp8dMRaqKj9nXSEyAwDDKZGCbfNBaxL6bCM+YT8KWd4NlxGPW1ZQByVgZSJZ6RkAeDC4lO7kYRuow02lpXDtjyQE+yzHRbat8vY+TLBYbJaoigFeTx5ATd2j1r8Z2z2g0O+qxLRN+3U+j4y1mojHUTBddOeukleeD1qxl4OA/um36f7fkWUQRQJFimMOv5p0ZWEJHsyYDlGI1vFV/C4vypY/JaiEaiL5ETqNNjtCiPfumwS3DU+/l5DilBQK+K45zMCFja+qVmHlZY1noIr4Y7DToxszEUcnegQ6kkHM2xuIctB7/+ELp133nPTX7q+eVkS6FNSNt2RbFtfavSvkmOuA702SpUSvxURfP2zdi+7lV0nTiO4DcEBGb8FWI/hc5m02hpeRix2G5Eo28SCZAgHsGo8Uc0/1brt8za1UiNop05uWeEmHJ+mheWFSLRejQ1LUPOlsFIkFjWq5AhmVxKc5TImOxzBQBNTQ/YPrd6nnKBAa1C0lWeQWuwApWxbmIlmp0qN5GBUkXYflklHi9WERaRB4oEywROLRREiEokS62XynchOpNSMKS+cySCo9+PZJEAONN4bYh2asiVkzH0OqsynkPbx0dRRfjOIYpEh3nAce9wW2jbFcV7rzZBHSiQI67AwCJNZilx2nOrL9cvpHHkUKJ5+2b88Ve/RKZPugejaw9ChDZ6LVkNyHome1D7U5kRJ1nXNBB9k74hsx20ta6E0fMKkH2+1N+psU+iAIBBxZi5OWd3ovUDCeR2ZrQ0ZbqbR9LFU3vzWVW58aEQJm1qBADMpO41tFAL+FP3L0G8q6uYgjsFUCRYJtCn6hgWEE24ligAvJvD3c/OVrbRKgKtImOnWgpGH32qGzMK66MnLcXuNdv3AaJI1CaRCI4T53S7Ngdm3l1WY5CI4Zs1btzQnVFs+SK3OwAAIABJREFUIWR4UyISHnPjTDuRM7v4oP4gSFmYrCDig/qDAIDt69uU1La7jMPshZNtPV+06K6njCc+tz3pPyKW+YWmXD+fKMpIwPZ1ryrkCpAiJmTYJ1cy7JAmWeCeT2Wf9lxhNG66QOO7ZUaA6WRIRN28g5otNDPRcPj1nIcX5WVDD7mSUY8JE5fi071LwfK5345smkF411h4syK1Nx+t7QwwvA2daYg3NODwIw+D7f8tEtNpHH5E+tspkqyRjaKTuwXkhsh3/9s8XHN7LRjyy5QC/aJDc0K3ckg3i3yNNJCaO78a7rRFhE5mBFPht57gOPGG0tscyE2Z93YlcMnO/YpTutmYVlYJxIbEPCP1Q9Thbw/0wY7xgt7tPV+YkXi5z6VaN5jqEfDeq022GnzTOhqIEInP7dH4Lw0LLslR/FRA14njmn+nu2nvqRY/FgR43EFJq0WFC+lMDI2bJlLIlQscl7My4Dk/eH60yXgikqkwmpqWobl5Wf+YokKAI9F6x9cAmBFFUfnOMxmr6BWHUGixqfC+ouQf0NftgigCfV08Dm0NovvLsZh734OmVWtKI2dAaVA83A2dafjimdUKuZLBptL44pnToyHy6YxiBMsB5Dd7taZFDz1xslsxpEchqxIHGySSUaiUl57g2O1PJ/cKlGGWgqSOKYpYzJufi9oou9RIPu6ecT5mf63EVpPpw8k+fP0nGxHye/Hg9ZNx40WVpvuTYKYhZFhyn0tRgK30Na0Qgxax5TwniNsLWcY/VBg15mx0HT+m/Du8ayzGz4mAdeXuJ8t6EQh8V6PBsoJcKUdvM8OAYbIQBHJTaX0fPxnGdB0JaUPXEn0akedHE53bSQTOLLqWTEX6iRsLUpTP4w5h5sztJnPN4eKrl6N5++WKHm7UmLNx3V23oWbWXNPjTqUqN/4omYjStg8nnvrwKfy27bfIilmwDItbqm7BI5c/MtzTGjYUI1gOUTUjgDufnYNr76i11ZOwakYAcxdXK8SrvMJtq61NvpGv4cBgOo73CFlNTz67/en0qwWJBMqRouUTguCzuh96UURtRzuwY7PpaWgRrnEsR/zObw5UoHn2NLxYMx7nmkXHRCAd8KIjlsDyN/fhrU86TOdBwhULJhIjrizHmKa67ZL4qhkBXLFgokLkPqg/CHcZOWojJMcQt9P8nEYyZi26DXxJ7u8wdtCHjh3ngUMFAAYs60J19SrUVK9EdfUqpS8gwxijmjn9UkgRh9MjOyK18k4mJbSm0up5OIGaAFdV/dTQk5BhXKiq+qnhOCnlSD4Xz/v7xfJkkbzeBNUKNbPm4q4XX8aP1zXgrhdftiRXpxI2tm/E8bPIn9G2Dxee+vApvNH6BrL9Py5ZMYs3Wt/AUx8+NcwzGz4UI1h5womVQj4VgTSB/flTyQuVHkMpkLcbVcoH+opAQ386nkM8IxgqEtP9+8j700igbAj65oYN2DVhCrrdXpSnEpjRvh+TjnXAqkEIzYfr0cnn4uarzcXxNwcqDJE1BSyDzFSp6jARTeCZd1odR7FIEVe5itCsNZNdEk/SCbIcA4aDRvvFl7AY67tHo8EC8ltMRwLkBVwdNZlx7Y+V7Vu2bEEwcDUAGFrZ2BH65+uabgb1PHbsmGV7fDUBttP7UL1vLLZb01MQkL5zQUiCLJYHAoHvnnKavMHE2j1rMeFqBv/rbREeldRPto+YTT90yPHbtt8St7/R+gYAYNvhbZrenWdCVWaRYA0AdohTvkSnakYAkYMxfLpN+0PY8mEUwYl+0zFIC9+7LzchcjCGObc6a95sBzSSwYiixj4hX+jF7nr39eDmPxOPU5MqM8d3ALikrxuTdv3R8LnPZ6aHsddux8x+wtSYlWORqToLfDSBcCy/diNmz2jjq82GNCHDwTJ9LYOkE8wKUiUt7+Z0z/zViER9p0UVISCRrHwiJVa9AwF6exuWcVOF5moiRPPe8riDqBgzFxmB9Cy5wDBSn0P1OfUE2M78ZdRUr4Tff7HhOzezZ5AtKIqQEO2JIjJFsri4dYuIMV8BGQ74928z2D/d3sv2YGNj+0as3bNWiVyRIJMsoPANukcyigRrEDFQovP5p0bdih2LB9LCBwCfbgtbkjM99u7di8bGRsTjcfh8PtTV1WHatGmafWgk40/xbrwS7jSMOdlbgrZEnyOdFi0CtSHaSVFyaNN3Vo2d6+rq0NDQgLSq6ajL5UJdXZ3l3Mza7WyIdmrMSA+n0ljSoq0SvDlQgXuaD5EH90gpt5CflF7KH/IzkG8VIUBPJSZ7MppKWhlOFufTCU7tKWiRIgBobl6mIUEStM7uNPPRZCpM7DfIc35UTX6UeM6Bfl+k79yMYJ2KmrzBRKAsgEhPBDumcNjR37b1R+UMdng5/Oyynwzv5AD8Ye/jSERfw0Ojszh5FoPfx3ns6bUu5SlUg+6RjiLBGkQMlOjkK3Q3+3zb+lbbC+jevXs1pCMej6OhoQEAiCRLTnk93R7BPc2HqAK/L+NJnFXCIe6AYvk5Fpfs3K8hcIDkFk8iV2ryJM8PkEgguo2GnvL1WJFJp3jkQIfB6T0tinjkQIeGlFHTrEkBXheHB6+fPKB5kOA0da2OxjIm6s2RqBMcLugJj1ydF4vt1vQHrBgz19AvkCb01vcarJr8qIaUOW2uzPOlyvF2CVVzy6PUvoXW5yOL5YFTU5M3mLhv+n1KayA1vFxhX7jyQSRaD+bYrzGal37fKngRi0ZLv2F2SFakJ4KN7RtPa5JVJFiDCDOiYxaFkhcyGqwWMLPqsVSPgLZdUVsLa2NjoyaiAwDpdBqNjY04MPZcQ8QKgCZaQ3MB6nWZN4nVwwWgOyviZD8BkaNAGVEkjsIBWDP5PENUSf53tPMQDqfSuLv5EB450IGnJlXi5kAFpk2bNmBCpQfNCFW/ndgkW8hibEcSK797YV5VhDTkk7bWR2Np2QC+hIXnyi5c91/XnXF6CxnJ7i786u470HXiOKYsPghXmfZvUTIhzWmT9JElM48wqyjg/9/eu8dHVd/5/6/PXJJMAgygYqKQVjR4H0WoWF0pNl1+pSHFoqK9fJfvtlvX77ot0nZ/XESatX4L7Hab0t3ur9ttu1/67cWi3AopWzRrKtiCy0VGLQiKGiJJqQZGCJNkMvP5/XHmMzlzzudzLjNnkpnk/Xw8eJCcOXPOZz65zCvvy+udSwTI7XM0caWPhCUznzsRWdOmPYYjR/5OUrAfLI2avOhGoPVxINYBhCcD9avRMqYK6w+u9/x7Xlxj7YtrcbZvMBoZT8aHPc124o1vIciyfwOX+YD54QFHAgvAsL+GQkMCyyVu3pyshI7quPGNzIgTiwerdnnAWRs+oEWsZGy/uBZHjrSbxsr4GDNFa6Q4NBgEgAkBLUVmFCRW91EJu01d3XjkSDv+zjBWx5iyGw6UtVwf83ZNTtLWx/Z1ZaUOL/2zC3jj0DHbiQZjJpaj4vZz+NbZxzJ/cY+megtAc3l//0+nMzYOgUrVH1nWPye5OK0DuRXIu40aaZEr2fFfOBJYGSd3i0hc0RLdCGz/MpBIRwljJ9Hy7N+h6eKL0JtO3aq+5/Vu7IGaGkxa+ogjq4iGqQ1Yf3B9lsAChj/NphLmE/zO/3ge7tdQaMimwQXizUmII/Hm9MOv/lZqzmglhFRRKFVaUTzHicXDtFnVuGH2ZcrHnbbhywq8j19yOf5w+VTpWJkeG28nACb7BDt6UyllFMiKr712MsveAdDEi6ySK8G9MfaUMcEv/xGTHb+neiL23349Ou+6Gftvv74ggs8qbX1sXxeO7esyGZDyFJcOMjey+Jt34Ee93zalM8Qv0ZHCsX1d2LDyBXzvof/ChpUvZP3s737yJ+C673G1Cak9uUSjpl75Nfh8btJHuUSN5D+PnKdwZLezIvWa6gX4yOz9qP/oGxg79gZ85CMHil9cAVrkKpGdgl0/rjIjrgTG7/nY9u3ofGy1NqKHcwycOoXOx1Yjli65sKOrR27+qzo+FKiE+dmkD/dffT9qqmrAwFBTVYP7r75feZ3hfA2FhgSWC1RvTn09STz3s6MmkWUldM5395l+OR/b12UpftxYLdRcOV5peeO0Rqa+vh7BYHao98Wp17uKQAHQRBXnCPckEepzJ7DiKZ6DH7bcDd3Kr6tQXl5PTJtscm8Ppo8PB3Zp699ve0NqQGqH+J4qxjcCL1H9kfXbn2tjrIwu76f2TUIqYfx5cfbzk0s9ktHzKuAfn+XsbiQQGJODsFH8RHJNYI5oYh2mQ10B+X7ov+dPN3/HNJqH9/bidPN3HN22ukr+e191fCiQifkEZ6iq/ixW3bYKu+7dhejiKHbduwurbluFcJm8I3tcWZEZenkIpQhdYPXmpOru+8hnrkHNleOlvkNiXIlAzBpU4TS1J94EZFkIJylGgazw+3yF+pe1inGM4atbzmKgP4WXa8vQ8qEqJALORZo2Jta9O7xRNFn5ddmNxMkVJzYOQ4lIW/96eiUOXlUOzgDGgVte78MnDskdwu3Qf0+Jricjw/lG4CV2jStjL7o46/jZN7Q3lcs//B6CVf2ZgnZZN5+efDzCZN5bqs49+3E1Zi677AG8887Psv7O4hx499XxJoE54ghPBmInsw5VDyTRGTS/leq/5wc65dFI1XEjsmL3Cn8FltyyxNHzvUJYMohas6XT7sW4c62Z5ozrLDpPmeIPc9XxkQAJLBv0Hkbj5odxVzRuGuIrUAkw0a31o68+b0q1pJIcz/zHH2wHSQPA78dw/LOhk072Rq16E2A+OEox6jEWfv/sd6+6NhVdc20tbqysxu+3vYEb2/tQPiaAtkglTvMUJjEfprx+AYc/UK4UXbmIK8AsmlZMrcEjEjsE41gdO9wWiVvZOAw1H15wJZa+9BYO1JVnIpGcAQfqyhGs8OFTryVcjWMyWjsUyxtBoTDuzdgpezEpsgWBym68+e5FmHHfp/DGm9nfx+dPTsIH5j2e5Zt1+vSvlZ10XtcjWc17zCVKdu01j+PI860YN7Ur88P57qvj8c7vajD24ottn1/S1K/OrsECsOT9C1k1WID5ez5QU6OlBw0Eapztv6hREmnHmqqaIW8eaTnRkvWz3dnTidXRFjTd3mS5Dv34HBmxPjs759KFBJYFRpftWJUfLR+qAgCpyLJLvVnVsdiJq5dry9ByaxUSuk464XButJtTvUHyFFyJKxmybjcGoNLvk9ZgVfan0NX0Es4rhMiGlS/gfHcfJp8ewG+mVyJezrJSkCpx5QNM7u16goyhZyCJmudeMonRrv2DfzVOCPgzXYROOLavC8/+5A8Zp/Lz3X149idaQ0GhnPK9ZNqsahzq6TJnqRjDi7Vl+IdraqUGpCr640k88x9/wO+3vYEPL7gSDbMG3whGYhehvnFl7JS9qPnQ/4UvoP0uCITew/v4GcZcsgpjL74k4/J+5wPm2XjTpj0mmQ/IcNlln3Fsd+AUq1quXKNk1177BHb94F8w0D/4uyZQVo47H/iLnK7nlJYTLVkddeGyMFbMWjF031+RRdr/ui7ChvrVgE0X4aSlj6DzsdVZaUJWUYFJSx9xPL+vYWoDGqY2oK2tDX8z528K/lKNrD+4Xllfqdp/MT7HipES3ZZBAssC2fy6RIDhuUjIJLACZT588IaLMoLB6/E0z90UQsKf/a4o6oyMf5+quhe98CdSpbwAmIRXcIBj7gEt7XS+uy+TAtXviVjnje39uLG9Hy/XluG5SAixSh8mV5Qpo2UpaF5XRqHHoYmvBOc4kxw093z4SDsePtKOCQE/1lSUoeuum3N6/c9vfA3G7nKedOcvNtykFBH5FOQGpFaIPwz0X9+GWQ0jRlAZ0XfoTopsyYgrQSoVB2cxPPi9/7C8jpuxM/mi6iwM+MfnfD/ZuCCZkPSSlhMteOyFx5BIDf5OiPXHsGqPJkaGVGQJoZWmweb+olvQ2EX4z5cczhIgYn7f27G38fa5t5WCzZiqG4o/YlR1lFZ+VqrxOYKRFN2WQQLLAlXhc6wyuzdgzMRyfPCGi3B0b5ep/X33xmO4c9E0TJtVjfIqf2YmnBvGTCzH+5XyQsp3+hKmaIRsjmGgzIfzn6gxmXXmkrqySnkJ4RWOpzDnJU1cfXd+GLFKH8IXUvjDvrewXidEjGJQCK0xE8ux+JvTMVORkvRjsAA+Cc04tP6isdjYdcY810/HmYEkTvb2Y1NXd06vXfX1y+XrOlyIPZMdB8wGpL9peRanHVzXyZSBUkc/wipQaZ5SAACplLMU+lA526tG7wj39lzJdVxQrqw/uD5LXAkG+EDRt/q3nGjB+r5/RtfiP6G6ajKW3LIEdVMb8NRPzJEqANjbtTfzsdH2IdYfwxO/e2LIrVBU9ZUAsHz3cizfvRzhsjAYY4j1xVBdVW05Pmc40pxDDQksC1RF0eELg980mhC4AxtWviCte+rtGcCzP9GEVi5vwqKA+PLke+pZeoZspX4Q9e/HcLTdXImzIR9Y4n2TdxVg7/+kmqUnq0Xaf7s2z+F7D/0XXq4tw69urUIqHXmLVfnx1HU+zNaJG5UYFEXTUgNODAqEJAZd22URRxmcZw+Ctnq9k5gPc6IXMO0PF2wjgN976L8KPljbCz532UTpCKPPXSbfj/KqAG6YXW2aiynDTf1WqSIaV9589yIEQuZxVj5fYRomcmUoo2WFxKoTdbi7VK0iSrLaJSGIrASInt5kL1buWQkAON1z2nWqzgtUrvJ6Yv2D9VQqMQYAPubDrnvNs19HGmTTYMGKqTUI+bLDQ8EBjrui2l+C+sG4Vm8sPGldf2WFiArI1mIcB6Nn2qxqjPnytfjNHWNxNqR9mWXeVXb+T6IOraMvAY5BF/Vpz72E2T2d+ObtFXi5tiyTIhK2E2MmluM30ysz4kqQ8jOsOjbY6jxtVjXu+uw1GfEi8/qq0NVkyb5hxetwY7UgO3dTVzeu3f0yHj7Snnm9f+QpbL62PPMa7TDuQzGy7upaLL5sYiZi5Qew+LKJWHd1rfI5H/nMNfjzv7wu83VSjcoZLWNyps2qRmTGo6Y2dZ8vhLLy4hPXNdULcMcdu1H/0ddxxx27S05cAda1OvnW8cS2b8fxj9bjyLXX4fhH6x37UwGDAqqzpxMcPCOgWk60ALCuXWIOLTsATYw1/a5JGsUDCi8yG6Y2oOn2Jk+udd+0+zy5TrFDESwLjPVG4QspzDl8ATe295u6p6xc22VUVAVw56JpUvsGI+e7+7DYot2/TeHu4CSiYydKpHVonGuGnYyZCv9FiujDC65EXPEXzBlDMbxqJp6xyQBQF7aLPXHa4WjsMJTdS6Cqu1NRCqmydVfXWgoqGfqvk2zigBsLkJGAKjL02lG53w+RH0tuWWKqwQKAAAvkVccjTEBFAfrAqVN4a+UyfH/3crxx6+W2aSy74m+r2iU3AktcV8VQFIsLV3mr6JQdfubH9EnTPVxV8UICywZTvZHi50yW6rJCRLQWf/MO2/E4Iiqgqn06O5CU1lY5iejY+T85uYZegAixOG1WNfCc+i8qJ7VgTlN+ADLXUYkkPYzBFPmzu5ex7s6OkZ4q06ehC9HUUSrI6qheO9o2PIspUrwqyJbN5fOii1BmAlqW4Ph0G8fD16vrm8TrUokNIaxUtUs+5nOcIrRjKIvFnaQKrUjyZNHXzHkFCSyPEG8sz298zXGtlYhyWHVu2UUFNnV141RvPzr8ZvsGu4iOVYpR4DQqJASIPkU0IeBXjrnpkNhNGEWW02iUeB2yDsf6i8biV388m4maTQj4MaWiDHcb7mUnJI11d4C1iBoNqTJV5JEgBFb1R7mKLK/fmFVmnxe9r/3fm+zFmn1rskTi7Mmzse31bY4iSrMnzzZZFVT4K3IWKDJuvuTmIRMsek+uXCNZw10zN1RQDZaHTJtVjb/6p49k1aqUV6kHvejfoKfNqsYX/ml21nPtZg9u6urGl4+0m8b7xVMcq46/I63bEp9NLg/iW1dPsS1wl11DRvhCyiQGPznJWapEVQum2jkftPUzmF+HcZ7fuqtrcWR2BF133Yyuu27GkTtvxHjJaAurSJ6+7k68xg8vuBKBMvmPz2hLlRGECqv0WbGgMvt8TzfBJdYfy6qx+uVrv7QUSCKi1HKiBdte32Z6fMFVC1BT5d7kVcWLf3zRs2s5oWFqA3bduwsvL34Za+9cm5k7GC4LY3z5eNvnj2TvKz0UwSoAxr/sf/jV30qjWrIoh9OogKgZUsXKROToW1dPyWtMyz3VE/Fi7Dx+eqobSQwqcn1gOzjA8fETiSwxuKmrGxu75E7VMjp6+7Fh5QtZaSbVa0sB+PGYJFr3PYdYLIb2cBjR+vosx3m3qNKL4wDMO9KHaWnrCGMaTKTIhBP/aE2VEd7R2bWt5Dv+BKUwm1JmAtobAH4+J7cRLnr7gblPz5UKsaeOPYX7pt1nGwULsADGlI3J2B6oIkZepRpzQRVVNJrCCka695UeElhDwOxFV3tSEKy3D/BBLUAEa050Yv/t1+c1pkUIJXGvFLRhxeGAH2cHkppou7YG9/x59j3c1E8BWgTMaEY6WZGenOQDtm/fjkRCeywWi2F7uusnV5FlOTNQYfVDKTLCazq7tuHoq8uQYtr3dm/fKRx9dRkAlKTIKoXZlHoT0ETnKbw3juFnHwFeuN79mPmaqpos+wGVkEzxFLa9vg0LrlqA5zuez0o96j831qvd9JObpNfzqdp6hxEhvOwsLEbq1AeABNaQIN6Ev7vnBJ65uhyxSh/GxzkGEhcwzeE1jF1uTqq8OvoSORtqCqRdhNAiZFat/W7mFepTcPoOPFlUKeRjuPXEKxlxlVlTIoHW1ta8oljFNDOQGJ28/so3kPJlf2+nWAKvv/KNkhRYpTKbMtzYmBFaLSdacOLgerD0m358IG6KwsiQva5xZeOyvKH09CZ78XzH8678oO6bdh/wjuJ4kWIV4fKyPq8YIYE1RDyTuIBtkVBmoPHZSoa18Riw5wQe/rOpts93GxESWJmJOhlabFX8LcwqZSJL5RZuhKU4Gv67J8sCQdSmqaJKLz+3RXqtWGzkDg0lRgf9TJ5WVx0vdvQF0V5EKZzO7csHoyAwCgFAE1PG6JPsdTFmnWZ0mypdddsq/KLlF/D1+Aq6B0PBmn1rhsUwdSghgTVE/PP7Z5EIZYdxEwGGf37/LB528Hw3Jpp69AXkeqHyl6kQAhvbs0b7yGYF2nUR/vRUt1RgORFXwSRHw4s9Jn8pfW2aLKrUHg5LxVQoFDIdG0qi0ShaW1sRi8UQDodRn2dd2EhkJNUXFQJ/N5A0Tm9PHy9VvOr8Mw4OFnP7AOQtMKyGSOcjEmN91n/05ZIqramqweGGw66fN9zo04Hh8rAysldM9Xn5UnyJ2xHK2Qr5XzKq40bs/Kqs6OhL4G917uQdfQms7Y3hUHW2vhbpOT12XYQqITVZsV4/kOn+W14RxvQud7YUAFBfXw+/31wf0dfXh2g0avncQhGNRrF9+/aM8BN1YcO1HidEo1E0NzejqakJzc3NBV9rZ9c2HD36aHrwMNfqi44+is4uc5fVaGXs9iCYwf2D9WnHRzuqwcF2A4XtEEOk9WlAMURauLGLrrno4ih23bvLsWC0E1Bne88isiGCuU/PzdyroEQ3As03AE3jtf+jGwt/T5jd7q1SrsVUn5cvFMEaIsb3cpwNmYXK+F5naT8nJpoM5nE4AuPxhJ/hN9Mr8VwklBnEfFc0jhvbs3+7i+jRw0faHa3Tar0hHzNZQxwLVro2q4xEIti5cyfi8XjW8VQqlXcdlhNksxnbW1sLUhcW274dp5u/g4HOTgRqajBp6SOZWhEV0Wg0a39CoRDmzZuXtY5oNIpfbdmCgbTHRywWw6+2aKnXQu3fsWPfyBo4DACpVBwn3vgWRbHSVL7IgJQf5xYkkZyoRa7GbvOjcn9uHW0jCVWnXL4ddIUcIi3zwNITT2o/D509nVi+ezkOnT5UsHRfS9tjWP/GJnRN8KF6bA2WnHkPDdu/rD0YWVSQewpkdh0qiq0+Lx9IYA0RXxo3HmvjsUwNFqAVd39pnL1nCGCuR5J1EXJYiywj8XKGeLr7RIy8KR9j/pa4p3qia4Fl2ZWnI9dOPKO4EhS6DsvYbCCMUm8vG4M6mO/tdD2y9OIH3n7bNMKj87HVAKAUWdFoFNu2bUMyOfjdEY/HsXXrVgCD4umZHTsy4kowwDme2bGjIAKrs2sbBgbkdUS9fbmP3RhpBC67DJX7T6Fyv990fLSjcj7Pt4OukEOkn+943tX5v3ztl5g+abq0yy5cHgbnHJ8p+wy++fQ3XdWytZxoQdNbW9Cb9gDsDAbQdPFE4N1uNLQ+XnCB5XQfhYfW3KfnjojOwry+Mxlj/8gYO8oYizLGtjDGxqePf5AxFmeMvZT+931vllu6PPxnU7E8FMb4eArgHOPjKSwPhR0VuAv0Jpqqv9mEyHKEoQAzEWBoi1RKT1Wl/FTHAaDudAc+u28X/vq3W/HZfbtQd7pDea4botGosni00HVYsmaDeIrjv6+6Qfkcq9RbNBrFunXrsHnzZlN6cd9Pf2Ya4cF7e3G6+TvK67W2tmaJK4GI7gnO9cld6FXH8+XEG99SPlZR7p3hYqkzaekjYBUVWcdYRQUmLX1kmFZUPKg65fLtoCvkEOlcBJowYZWl1UTdknGgtB1r9q1Br+F3Zq/Ph/UTxgMxb34vWxEud2Y6fc2EaywHZ5ca+dZgPQPgBs55BMAxACt0j73BOb85/e+hPO8zInj4z6bi6CduQddHp+PoJ25xJa6MqGqy/HAewZJxWhFul9ViWY3aKVRNkrguN9rXp+nv7y9oLZGq2eBcmVrYbdmyRVrnJF6LLBqXSCTwUu0U6fVUoz0A64iZ/rHKCxek5zDOC1KTZRWlmnrl1zy7T6kTbmxEzTce1yJWjCFw2WWo+cbjtmnh0cBigCWIAAAgAElEQVSq21bh/qvvz0SsfMyH+6++P++U2pJbliDoM/8+zXeINKDZNLhFiDK7tJpTR/yWEy3qgvKAHwhPdr1GN7ScaMH5/vOOzt3btbfonf/dkFeKkHOuN/DYC+De/JZDOEVV4+SkRmtyeRA9A8nMfD49KuHmNOUnaC1QTZLsunqSyWRB67BUXZVWTQhcV+e0efNmtLe3Y/78+bav5UKlPJqoGu0BAGFFh6V4THBz+0nsq7sKyYDuVwDn4D5fZq3CvNULKspr0sXt2QT846n+yoDek4nIZtVtqwpiywC4GyLt1CBTFWlnYOCKP4UZY2g50eIo+uXkHCtxUp1MoWX6PVj/9Fx09nRm0rB6N3onRqGq54r7D/AB5RqcUKqdhV7WYH0egL6a7wrG2CEA7wNYxTnf7eG9Rj16wYPzmmiqv2gsfnKqWxnB+gudMaixlgiwH/7sxohT9Safb42Uk+eLcwphm6AStium1uAVxpSRNT379+9HbW2t7WsZW14OVlGRlSa0SxfV19dj69atSKWyxbPP50N9fX3m81mf+yxS3/83RK+7FhcqK8F04kogBPH06dNtX5MdU6/8Go4efTSryN3nC2Ha1avzvjZB5IsbKwmZQeby3cux9sW1WH7r8qzrWNk03FZ9G/Z27TUdT/EUmn7XZGlSKpClMI2CSDmQmXPMvvRWNHX8Z+a1iBo3kZo7dPpQ1jgfvRkogKx90D931Z5VWPviWsT6Ykoh6YZS7Sxkdm8IjLFnAche3aOc823pcx4FMBPAQs45Z4yVAxjDOX+PMTYDwFYA13PO35dc/0EADwLApZdeOuPJJ5/E+fPnMWbMmLxe2Gjh7EASiZ4edEpC3EYYA6ZUlGWGHZ8dSKKzL4FEiiPoY6gpD0oHIefC6dOnpbVAfr8fkyZN8vy6xnuMHTsWsVjMJHgqKyvh9/vz+v5S7VunRepOtkYAytfCGEM4HEZZfz8G/vhH8EQCLBhE4NJL4Q+r6xni8TjOnjW3QFdWVmZFsAAgGYtlrn1mwgRTTZ5g7Nixnvw8JgZi6O/rQiqVgM8XRFl5NYIBZ7UZpQT9/nJHqe3X8TPHpV2HAj/zo3pMNcJlYeW5IiVpeR2fHymeMv0Ou8R/Cf6U/BMYY7hszGUIlw3+DMX6Yzh1/pSjP/T8Pj988FmuQYWT9XuF7HW6odDfX3fdddcBzvlM2WO2AssOxthiAA8BqOecSws7GGNtAL7GOd9vda2ZM2fy/fv3o62tDXPmzMlrXaMBEYVa+v4pfHOMs0LhyenUXj4DoJ0g6ov0KbBgMIjGxsa8okiy6+oR9xCRKxmzZs3CvHnzcl6DiubmZlcRuoULF0pfi8xWId81hMNhLF261PXzgMLt10iFfn+5o9T2K7IhYhuVqfBXoOn2JgCQusA33d6EFbtXWF6HgWHNnWukXYRb+Vbp3EKRrrPD6Rqs1gYg5+hU0BfEwrqFtsOujenGXCj09xdjTCmw8u0i/DiAZQA+qRdXjLFLGGP+9MdTAdQBOJHPvQgzuYzPEbYCetPRr712Epu6vLWKjkQiaGxszERNwuFw3uJKdt1QKJTpHNTfw0ronDt3Lq81qKivr0cw6MwQMhwOS/do4cKFWLZsWc77lGtqVp8+NFKo/SKIUsRJuqo32Yu1L65Fw9QGNN3ehJqqGjAw1FTVoOn2JjRMbUCFv8LyGtVV1VkGp7sf2I09n96D6y66DktuWYJNxzZlddut2rPKUlzJ1mD3WlQWGNVV1Xml7TjnmD5pOhZcpa6/ZGD4wNgPYOWelbhxw4246Sc34Ym9T+R8z+Eg3xqsfwFQDuCZdDHf3nTH4GwAjzPGBqDZNT3EOS/hYQ/FSS7jc/yA1GZANk4n38hWJBIpSLG5k+taFXvbpRhzrd0S5+ifO3HiRLz55ptZ5wWDwYygsXstbteiet3G9KBs7Zs3b5Y+lkwm0dzcTKN/CALyAdYyzvadRcuJFml91xN7n8iYjMqwG4i9Zt8aU+G4VSF5TVWNdKi01WsR8xaNUSb92pzsgwxh4moFB8+qUfNyNNJQkW8X4VWK45sAbMrn2oQ9dnMCjaajVl2GIpKlN9B8+Eg7Vh1/B0/UXe55CrHQ1NfXKwUDAKVg2LFjB/bvH8xk67vpnIos43luRZL+fD1O1lJfXy9NzVpFqARWolR0QG7ZsgWcc5q1SJQ8TjsBjYhz1uxbY1uEvmbfGuk1rcb7OEmL2d1Xj5VY03f6qToBp0+abrlPxueGy8K4MHDBtj4r187Ap449NToEFjG8rJhag79VOKyraq3WnOiUijJZZAsAzgwk8bXXTgJASYmsSCSC9vb2LLGkRyZWotGo9Px87SXcRPLsaszs1iKLojkVQjJxZkRvOeFGeOrZsWMHDhw4AM45GGOYMWMG5s+f7+oaBJEPsk5A0R3nVGQJCwO9vYMRlRCyGu8jizQ5uaaKBVctsLRbsOugtHpc9ZjdvgCDqVYnNWN68h2NNJSQwCph7qmeiBdj54Fj2d+gwjZAZavg1j9LpBCLTWDZRYbmz5+P2tpaZcG7Uazonc6NFHoEj8DOG8vJWnJNzRrFmR25CE9jhJBznvmcRBbhNTJRAQAr96w0vVH3JnuVEScV4tzlu5dbrsF4zVzH/rScaMGp82Y/OSue73heaS1RqNmHegEqi/Tlk2bMdzTSUFI6KyWkrLu6FrWhMkwuD4JBi1wZByrruad6Ir519RTT+VYjb4Dc6r0KiVdO8XohYSUq7GqYvMKJsBmqtTjBrfA8cOCAq+MEkSstJ1rw2AuPZRWCP7rnUazas0oZBYn1x9ByogUtJ1ow9+m5iGyIYO7Tc5WjWoRwsWLti2tN18p17M/6g+sdWTDo6erpUrrC//K1XxZ0DE3D1Abs+fQerL1zrbTIXjQBuCHf0UhDCUWwRgDjA37sv/16x+c7jWzpsXIqHw6cOMUboyUy9GLFqgbJSQ2TF1itAXBeT5ULdulJGW7FnurNIV+7GKJ0MEaVHh73cEHus/bFtaY6oCS3bnABzNEoq/Sh3TgbQCt2F6kycS0hKp469hRSPAUf8+G+affZRpO6eroAl5ZO1VXVlvVO6w+uL/gwZbs0o8peIsiCSCLpao+KCRJYBIDB+qpVxzpMI3TsHN6HAmM60KoYu7m5GXV1dbbiSi9WotEo+vv7peddccUVeXt3Oa2JsqqDKnRhuZP0pB6/34/+/n40NTU5XhtTuN2rRooQIwtZquqU75Q0jZYvVvU/bhHz8PRrbDnR4rp+SH+tXffuci0WVNYIIX8I5YFy02sWqTgrf6xCjKF5Yu8TrsSjrJtReHUVWvwVEhJYRAYR2drU1V1wI1I3GCMrdmmpWCzmKHIlBIFd5KajowPRaDQnYSNb+7Zt27Bz507E43GTMMmnSD0XVB2LdoRCIfT19WUGVTstep8xY4b0azNjxgxX9ydKE1nEh3OedxRFVWvlJXoh4iQ16PRablhyyxK0v2RubEqkEvj6rV8HAGXHn6pOzOsxNE/sfSJjpwA4s1fQdzO67eosZkhgESbczBwsJLm++dvBGMtyNbeL3OTTRSi7djKZtBQmhfAPM0bR6urq8Oqrr2bW4RS9U77xuU72SRSyUxfh6EQlLPKJoqg6AkP+kKXXlFv0QsRJarCmqgYXEhekXX8cHHOfnutaRDRMbcC/vfRvpuMDfAAr96zEN//sm9IuxIapDTh0+lCW8AHs/bZyQWVBYWev4GYeZKlAAosoSpzWA9nVLMngnGPDhg146623HNf+5CryCtWN5wZZFM0uwieDMYabbrrJ0pTUyeudP38+CapRhkgZqUar5BNFkYmd3mQvwmVhJFKJLAPOAAvgnmn3ZEbMjCsbB8aYbTrRKESsBOHaO9dmhIJR/OkR7uuAM2sIgaqOTAyJVl1v1W2rbD2t9Dj1CTOep2ogKCV7Ba8ggUUUJU7qgcR8PbczAAGY3NXtyLVzz6kALKQNhNvaKhWccxw6dAi1tbU5O8YTow9jysgIYwxLpuceRVGJnff738+a5WcnElRCSGb8WV1VraxpEg7l+oiMqgZqgA/g73/3964Elhi0LENWK6bHaZSo5UQLVu1ZlRGnKjEoix6qKCV7Ba8Yfa+YKAnsBIe+QN3NDMBcyKdzz+nahDCJRqNobm5GU1MTmpubXdtOyPBSvCWTSezcuVP6uhzvU3Qj0HwD0DRe+z+60bP1EcWHnWv5ZWMuyys1NK5snPK4fpbfrnt3WQoP48zAtXeuxcuLX5Y+b8ktS5SzBDt7OvHYC49l7A/EGlTEk3FXVgmTqiZZzjHs7Om0tJVwYj+hGsWzZt+arGNOUqWCUrJX8AqKYBFFiV3kRz84Wvwvxrh4CWMscy99HZMYMC0rVNdjLFoXxeGp1GC4XAiTfMf0qMgljWpFPB7PRMVEV6DjYvzoRmD7l4FEujYmdlL7HAAiizxbI1E8WKWGltyyBFXtVXldX9WBqjouUlqy0TB2LuoCu8hUIpXIDHt2gpsi/3BZGE23N1mam8pShcZIopX9hMot3njcLmJVqvYKXkECiyhK7GYJCtd1o8gy1m35/X5wzrMEjVNEQbes01Bf4C3m9G3evFkqNIxF6zLbBgAFGdMDOBuBA2idgddffz0OHz7s2E2ec54RiI7W2Pr4oLgSJOLacRJYBSe2fTtON38HA52dCNTUYNLSRxBubCzoPVWu5YAmBFZNyu+NN9anEAO643pRpUesy+2oHHFew9QG3LjhRunjxrqu8eXjlbVeXlslGFOFLSdapGlau5SiHVaO9If/4nBO1xxJkMAiipJcZgmqLA6Mx8rKymzvr49ciec7qWNyEnWSdQk2NzdbXjMfnI7AWbZsGQBYjheS4UoExjrcHSc8I7Z9OzofWw3eq6V0Bk6dQudjqwGgoCLr1ktvxd6uvdLHepO9eOfcO3n5YKnqoRhjmRSYk3Es+YoNO5bfutwzqwRR52WFXrRZnS8Td6oOzPHl47M+p4J2a0hgEUWLmCUoPKOMyN7YVRYH+mNtbW2YOXOmZScd5zzrOW5ETi5Rp0KP6RH7omoI0N9DnLtu3TrHNg6O9yc8WUsLyo4TBeV083cy4krAe3txuvk7BRVYb5972/YcY/TI2Jk2e/LsTOefvli95UQLLiQuSK8puurK/eWO64Q6ezpx44YbXaW1wmVhaUotXJb9c+ulVYKTiJdetFml8vSWEYDmgC8TVz74sPzWbIFoFZ0shHlsqUECiyhqIpGI1HNJ4OSNPRqNZom0a665Btddd52lwDKKGrd1TE7PFelCK7wcjSNLF6qK0914ZDkWgfWrs2uwACAY0o4TBWWgU/4mKzvutEXfCU7EgD56JOtMk9UOHTp9CNte32YpnnqTva4GCQucmGMKVsxakdVxB2h2ECtmrTCd69YqQY/4mtzN7lZORNATH4hnRI6VEAIGC/M556bidsG48nGmdVpdc+WelQDcWVCMNEhgEUVPPtGdaDSKbdu2IZkc9I7hnGPr1q0IhUJKEWEUHE7rmNysSxWZ03PFFVegtbVVWd/lFjdO8U5FpasuS1Fn1fq4lhYMT9bEFdVfFZxATQ0GTp0yHU9cEsbcp+dm3vA/MPYDWSk9vaDRR5FUUSUjVpYGeoQQc9KZ1pvszYxiKSR25piAexfyXAw1s0TnGGcpuLN9Z7F8tzotacQ4t9GIrNatpqpG+bW18+UaDZDAIoqefIYwt7a2ZokrgSh6DwaDJtE0c+ZMk+AQnzsRRXaCw6mJajAYRHt7e2b9XnUVOnWKF6LSuKabbroJx48fz32UT2QRCaphYNLSR7JqsAAgVR7ED2+Po7PnPABNTMneMHuTvaYokvFz8WZu9I2SzZmTIVJaTgu+h6LOx+k9Cu1CrhKdPuYD5xzVVdVK13ivkNWJLblliaWAK3RdW7FDAosoelTRI5kQMmIVgYnH45g5c6ZpbEttbW2mVkkvIKzSlTK7An23oP7x/v5+R5Ew2TmFdn3XI+5x9OhRAIUfNk0UFlFnpe8i/PHtvXiu7n1P72PsyDNGeMaVjcOFgQtZERN9HZLTiJdd2ssLisUcUyU6OeeILta88iIbCvdzqaoTU9WV6SnEMOlSgQQWUfTkMwDZKvoVDAaz6rCEU/nBgwczES5j1Eh1Lc45Fi5cmEnn7dy5M8vvStRLeOFHVUjXdyORSATd3d1YtIgiTiOBcGNjVkF7S4HelI2RC2OER1/jFfQF0XR7k6uIV4W/AguuWmBbg2WFE4F237T7hszaQr8n+hE+PuZzNGLIqTBlYFKRG/QFpTVY4bIwVsxaoYxCrbptlaXA8nqYdClBAosoCXIdgFxfX2+qwRLIIkSq80TUyEqw6X273A5RdgONoyG8wumbci5YXVcvuNra2jBn6pysxwA46iIUBeNuX4OdQBNdhF/6001DYm1hLOzXp/pUItAYVXIiTGuqajJmqrJGBsB5LZnxuqqvgdfDpEsJEljEiEb4aYk0IKCl86wK3GUIUWVngDoU1NXVDev9iZGD0/qo26pvw4HTB2wLoY3k2qpvVdMkhMGK3StMlg1OxZaImNl19B3/aL3J2uKtSZOwbc8exA8ccBVNt+rMdDNyBpDPR7RzlzcKMtUe5/L1Un0f3X/1/aO2/goggUWMcIzjZwRuI0wiahSJRDwRWKFQCGVlZZmUp5u03+HDh1FbW+tZLZTMWZ7qrEYHooZGdOT5mA+3Xnor3j73timysa9rn+317ng1ic+0cVz0PvDeOGDn8W+i4Qnv3mBlFg7Ldy/HodOHsOq2VVKbByM1VTXK1KURo4XF27W1+O9bP4RkQHvrdNp4Yrdut3VKqpE++tfjpdWGHW47KUcLJLCIEUs0GpWKK1HQ7nRuobErMN/ZfsFgEPPmzcv6hawyAJXhZaG7saPRq05FojRoOdGCzcc3Z9JQKZ7CgdMH8I07vpH15jj36bnKOiDBHa8m8de/5qhIl/Bc8j6waGs3YrO2e5ZOU0V6fvnaL/Gfb/5nVq3Qmn1rTF11Tk09hThZNZbjEl0PQPSmSEZcCYw/jzJhY7Xu6ZOmu0rVBn3OBtsLsaWP+K0/uL5gwqfQnZSlSHG0SBBEAbAy8BQz9OwwjswBtDShk+cCyAyFFoNnw+Gw6Xrimn6/39E1Ae8K3WUjgMQbBjHyWfviWlPaTwwq1uMkwvKZtkFxJagY0LoWvcJqHbH+GJp+15RJS+759B6svXMtaqpqwMBQU1WTVUyvQkSbOns68fM5DL06PXWhslJ+7/TPo/65HDxj4GklnoToqfBXWK4L0ATipKpJtufJXotYj9gjovBQBIsYsdgZlNbX12dSY6FQKKvrD8ge9qzH2NUYCoXQ399vKpCfOXMm5s+f72it4po7duxAf3+/7fleFbqr9mgoOxWJ4UM1fNh43EmE5SKF24PKQT4X7Nah6l50E8XRR5teuN4PYDDtWR6/gL7KKtNzxM+jLFJlV7fW2dOJ9QfXY8FVCzKF/MYuwhRPZequqtrN91chW89o96YaSkhgEcPCUNT92BmUGjsT3awpn+da4dQpvr+/H9FoNO89U6VKRcSNIACtiNk4DsbIe+OQlU4TBGpqPFvH7MmzLS0BAHOUS1b/ZOUwbnz+C9f78cL12seTz72CGe/NQIAPvnXqSwhy9Xzq7OnEtte3OYqwtbW3Ob6uaj2j2ZtqKCGBRRQco/ioq6vD4cOHC173ozIoraysVA6EzvX++TwXGKyFcloXFo/H896zaDSqvJ/TdRCljZtBxYC8rknw8zkMD/2ao1ynwVhFBSYtfcSz9T7f8bztOUbfJVUUZ+WelaZORPF8WZTMx3x4Z+w7mFAxATecuQH9Pf2mP6bysb0oRGRJtZ7R7E01lJDAIgqKsYsvFotJC88L4VCuMijt7u727B5eIauFsiPfPbOqsyKvrdGBm0HF+iLmGzfcaHr8hev9YEjhK/urC2bKaRd5kRWxq54jCvuNES2Z5UCFv8JRdMmp7YUKryNLqtcymr2phhISWETBUHXxqShE3Y8sstTW1ub5ffIl19eez55ZPdfx8GaipMm1vV5lLPnGrZej7h/kFgJeYBUhknlD2T1HoI8eOdkTlQWCnRcVoHUBVgYqpZFAryNLZJ8wvJDAIgqG2040L6Im0Wg0ayBzKBQyWSJYPVdWR5VLfZVqDqHqublaP+SzZ6p7hkIhsmgYReTSXj9ckZFcoktOo0r66JGd0ak+6tfZ04lVe1ZlPa9hagPmPj1XKrIqA5VYMWuF7f555WNF9gnDBwksomC4EQxGr6lciEajprE48Xg8MxvQSmip/KDa29td14sZr6WfQ6h6rqpezIp890x2T+HRRRBWDFdkJJf7Gp/DGJOOnzFGj1QCZ82+NaZi/wE+gBW7V2TVdKnSfe/3v2/7OqwK86vgvIuQGF5IYBEFw2lUxqsuwtbWVuksQSC7KFz1XJkflKpebPPmzWhtbZWu26qeSlU3JT7fsmWLowJzL/YsnyHaBDFckZFc7mt0OHcSPVIJHFWRvzBiFeeOKxtnmQa0eh1W9gorL17p5CUTRQAJLKJgOI3KePWmbifmhLiZPn266+eq7ieLSNldS/W4uIbVnoXDYSxdutT1WlXk2/1IEKWGkyiYlcBxQm+yFxWBClT4K3JKo1raK1zsaAlEEUBO7kTBiEQiaGxstK0T8so13Ek9kkrc5FrLJHM9t7uW1eNiz4QDvB4v0qgEQWgia9e9uxBdHMWue3eZIklWAmd8+XhH94j1xdB0e5NrJ3lAXexO9gqlBUWwiIIiIiRWs/acRI+cFJrX19ebarCMqMRNLjVQglgslnl9Mp8vPU5EktizfMxLaYAzQeSOlX/UkluW4LEXHrN1aBdiKD4Qz4ypWbF7BZbvXq7seBRYNhG05/HCiCGFBBYxJNTX12Pz5s3SxxhjaGpqUgoBpwOJxcf6LkI9QtzIfLDc1kAZESIxFovh8OHDuOmmm3D8+HHHXYQycknfGbsoxZpogDNBOMdK4BhTjBX+CsST2b9vKvwVmD15tkmIGeu0ALmbvFUa042TOzG8kMAihoRIJIL29nZp0bhdl53VQGJZsbg4JnOQb21tRXV1NZqbm01iR1UD5ff7wTnPmlNoRSKRwPHjxz2tlXKCUYga1+S1kStBjFTs6rT0Mw6FUNIj5gpaRbnsnNvJXqH0IYFFDBnz589HbW2tyR9Kj0wIWKUWZUJJRn9/Pw4ePIhUKoXq6mqTmNOLsVAohEAggHg8nok6AebIWCgUkkbKrNZcKKLRqG30jQY4E0VNdCPQ+jgQ6wDCk4H61UBk0bAtx4nAkRXDA8gMbbaDZgKObEhgEUOKPsLU1NQkPccoBKzsHmKxGLZt25YRP3pBpI/myIRQIpHAzp07TcIpHo8jGAxi4cKFWdGwgQGD983AgFJkDcWoGb0odIKscJ4ghg0hqKr/Clj3l0DfOUBEfGInge1f1j4eRpFlh1UxvBMHeSpaH9lQFyExbKhEiPF4fX09gsGg8jrJZDIjckRkaufOnY4K1uPxuFJ86bsDVWlKAKa1DUW3n0gHuolK9ff3IxqNFnBVBOGQ6EZNQMVOap/HuwfFlSAR1wRYEWPV7bfkliUI+tS/t2gm4MiHIljEsKFyEjeKE6Mhph2JRCKnbkAj+nup7huPx7Fw4UJXHXs7duzAgQMHwDkHYwwzZszA/PnzXa0tl+HQyWSS6rCI4qD1cU1A2RHrKPxa8sBJMfzaF9fibN9ZAAADAwe37SIkRgYksIhhw6mT+LF9XXh++zGcQy/gB8CGZn36SFpZWRn6+/tN54i5fbLOR9nr2rFjR1ahP+c887kbkTUcw6EJwjOcCqfw5MKuI0+cFsMToxMSWMSwYmdFcGxfF1qe+i1ila8BPmddfCr8fj/KysocnauPpEWjUam4UiGzldDXick4cOCAK4E1HMOhCcIzwpMH04MqgiGt0L3IIRFFqCCBRRQ1v9/2Bs5VnMhbXOmjSL/4xS9szw8EBn80rJzmZYJJVv+lrxOTYez+M3Y1inuJzstQKASfzye1jlCZnZITPFE01K/WarD0aUJ/GVA2BoifKYouQoLIFxJYRFFzvrsPqUv78rqGcX6f3++3fY5+OLRdpEhvFbFjxw5LIeUEYwRMfz0hxOLxOPx+f6aLUZZe1VtikJs7UVQI4SSK2MNTSFARIw4SWERRM2ZiOd5LliMVMIsso0O6yineKJDGjh2LYDBoWyQuOgnt0nGic1FlpOoWpwXsyWQSZWVlWLZsmfRxGuRMFDWRRdq/tjbg068M92oIwnNIYBFFzYcXXInupzpMNVh+XwAL7v5kloBQGW0yll0VHwqF0NjYmJWCszIMXbhwoe2cwkQigQMHDrh9eRn0tVFuaqvszlUV29OsQoIgiMKSl8BijDUB+CKAP6UPreSc/zr92AoAXwCQBPBlzvlv8rkXMTqZNqsawEewa7sf3anjSPn7UBkag49/Yq5JEKhczFM8hQ3PbsDijy3OHNMPVBapQBnhcNixTUQuMwwFdXV1Wfd0KrKsitZlxfabN282RfpoViFBEIT3eBHBauacf0t/gDF2HYAHAFwP4DIAzzLGpnHOkx7cjxhlTJtVjWmz7rU9TyVMGBhe3fsqWqa2mLp9rNJx+qJwfbqtublZfh/J6B+nHD9+PPOxzB/Mbn0y3Hhl0axCgiAIbymUk/sCAE9yzvs4528CeB3ArQW6F0EAgKXYCA2EsP7getNxq0hRY2OjVHDInOWDwSBmzJhh6ThvhX4dkUgEjY2NmehUKBTKdBKKdGc4HFauT3ZNt2sgCIIg8sOLCNbfMsb+AsB+AF/lnJ8BcDmAvbpzOtLHCKJgRCIRpdfUBf8F6dwwVdRLnxqU3QeQG6QaO/dyTfU5LVC3qqVy65VFHlkEQRDewexSGoyxZwHIBi49Ck1EvQuAA/gGgBrO+ecZY98D8HvO+Vla2fUAAB8oSURBVE/T1/gRgF9zzjdJrv8ggAcB4NJLL53x5JNP4vz58xgzZkweL2t0Qfs1SDwex5mzZ8B0du8cHD2BHiAA1E2oy9qveDyOWCyWldpjjCEcDnsyHLmz03rYq9v7xeNxnDt3DslkUpmSFNcDYHptuayBvr/cQfvlDtovd9B+uaPQ+3XXXXcd4JzPlD1mG8HinH/MyU0YY/8OYEf60w4AU3QPTwZwSnH9HwD4AQDMnDmTz5kzB21tbZgzZ46T2xIA7ZeBDc9uwKt7X0VoIIQL/gt4ZcIreHf8u2ia0YQ5U83fX4XsqLOr13JzP2PRuhXBYBCNjY24/PLLsWPHDksners10PeXO2i/3EH75Q7aL3cM537l20VYwzkXf6J/CoAwM/kVgJ8zxr4Nrci9DsCL+dyLIJyy+GOL0TK1JWs+WNMtTcpxFoX0i1INtLarn5KRS9H60qVL0draKhVYZWVlWLlypas1EARBEM7ItwbrHxhjN0NLEb4F4K8BgHP+KmNsI4A/ABgA8DB1EBJDSSHng7mJeInj+tow/RgeN9fPtWhd9bz+/n5Eo1HqHCQIgigAeQkszvn/sHjsfwP43/lcnyCKDZm3lJ2HVHt7e1bhvX4Mj/E5Vte3MkSVIeqwrIrdyZqBIAiiMBTKpoEgRiSyNJ1Ix8mIRqPS8Tmq56iuv2XLFgwMDLhaq7CtsLKvIGsGgiCIwkACiyBcoBIkVhEiN9dSXYdz7rj+CtCiXSIyFYlElB2KZM1AEARRGEhgEYQLrARJU1MT1q1bh2g0mjlmFSGSXcsLwRMMBjFv3rysY/PmzZOao1pFtwiCIIjcIYFFEA6IRqNKywU98Xgc27Zty4gsK8EkEzcyl3g3qBzeje7wTpzgCYIgiNzxwsmdIEY0bvynACCZTGaKx1VzBWfOnCkVN+LYli1bXM01DIVCWLZsmeU5MjuKHTt24MCBA+CcgzGGGTNmYP78+YhGo3hmxw6c6+vDtXV12HX/A5j1uc8i3NjoeE0EQRCjGRJYBGGDG/8pgYh0WY3VUSEecyPqcmHHjh1ZBficc+zfvx/vvfceTr71FgY4BxhDyu/HvrqrkPr+v+HDAIksgiAIB5DAIggbcum006cGrYxMVZ5XkUgE7e3tmeiSHfF4HE1NTQiFQpg3b56lgNPfU8abb75pOpYMBBC97lpc2fwdElgEQRAOIIFFEDaofKRCoRD6+vqQSqWyjvv9fmXxuF7chEIh9Pf3I5nUPHj1nlft7e1Sewc74vE4tm7dCkDuy2WMWrnhQmUlBhzMViQIgiCoyJ0gbJEVnotOvbvvvjvLAiEUCmHBggVScSNquYRYi8fjGXElSCQS2LlzZ84iCABSqZTUHkLlyeWUygsXEKipyfn5BEEQowmKYBGEDXZ1VE478ZzWcrlxa1cRi8VM6Uergc96rrjiisEarDT+gQFE/nAEk5Y+kvfaCIIgRgMksAjCAV4MhB5K1/RQKGQauWOHqovQl0xi1vHXMeuhv6b6K6JwRDcCrY8DsQ4gPBmoXw1EFg33qggiZ0hgEcQQYTUTUBAMBhEIBPKKYvl8WubfTQfiwoULswSkXlC2tbVhzi+fzHk9BGFLdCOw/ctAIv19HzupfQ6QyCJKFqrBIoghQlbL5fP5MjVcwvxT5rrulFAohLvvvtuVQFN5chEjiOhGoPkGoGm89n90Y3Hdo/XxQXElSMS14wRRolAEiyCGCLeeWFZWCkbC4TCWLl1q+9xQKISysjLHnlzECGDHV4D9PwaQrqkrRHTITQQqkwo8CTA/MG219rGM2EntfIpiESUICSyCGEKc1nKJ85qamhxd1yimZA7yovORBNUIRVbDBGSLK4GIDnklXFQRqO2PZK+pbi5w+OeD5/Kk+VpGNj8ItO8F5n/bm7USxBBBAosgihgndVviPD25OMgT3nB2IImZv3sV7/QlcHl5ECum1uCe6omFvakqghQIwSSuBLEO7+6vulaiB4j1DK5JJvZs4drzam+jSBZRUpDAIogiRjXLUE8wGJQam3rR+Ui4Y1NXN07F+9Dh175eHX0JfO3IWwBQGJGlT7cZScTNUSU94cnerSM8WZ3my8KtuNI9z8uIG0EMAVTkThBFTCQSQWNjY5aZqZ5QKITGxkYSUkXCmtfeAAfLOhaHD2tee8P7m4molSNhI6Fu7uB18i2AF+nIQuJlxI0ghgCKYBFEkSMiUaq5hUTx8E5S/iv1naTf+5vJ6p6MhCYC8TOQRo6O7/KuAD6yCNi5DIh3O3+OW7yMuBHEEEACiyBKBEr5FT+X9/1Rcfx0fhc2FrDXzXURuVLVYJ0E9v/IfDzXAvh567LrwJzA/IP/8yQQngJMnAq8+Xz2uoOhoYmSEYSHUIqQIAjCI1Z0bQJD9vDvULIXK7o25X7RrFQgVwsjGfFuwJCydEQu6bjIIqDxu5pIAtP+n/mFQRFlJDwF+Ho3UHMz8Knva5/HOoDuE8DMz2dfp/G7VH9FlBwUwSIIgvCIe2b8ObYe+yMmB/x4p3wSLu87jRXt/wf3fHhh7hd1kgq0hEMTWS4KzHNNx0UWmYVQ7W3myJY+IhU/Y+6APPxzElVEyUMCiyAIwisiizD+nS3Yf/Rr6pl6O74CHPg/WkqM+YEZ/9Pa48mT4m433XvM23SceO36Gq2ArmnjXKfaxZ0EFlHCkMAiCILwktAEYOkr8sd2fCU7vceTg5+rRJZjCwQLwlOcX+OK2YURNgM6ERXvBjZ/URNdtUvk5+crLPV1a6EJ6fueoUHSxJBBAosgCMIrohuB0+8CTXcPFqMf3zUYzVKJhv0/0s6TvfHXr3ZfPK5HpOOcdvl1n8jtPlao0pxW68mna9BovKq/j6xTUuaCTwKMyBMSWARBEF4g3tSnLoe0GN0ugqSySBAf6wWArNNOBvNn1zJtexhI9tusowB+U26v6Qvml6a0q1tLxDXBKTNpLcSsRmJUQl2EBEEQXpB3MToGa4+MRBZpacems9r/3SdgK66CIa07T4iEyCJgwfcGu/OU3X0F8Jtyfc2U+ZAbQ1Qngi7erRa9qq8DQbiABBZBEIQXeBX5cXIdu3NU1gZ6ofap72siTE+h/KbqV5vvZUUqmS1wZFYV27+sFlleiERyjifyhAQWQRCEE+wiKKKQOl+ciAPVOeEpQFNME1F26S2Zb5XX1ghizzY/mN056AS9wJFFB62iTG4FnQxyjifyhGqwCIIg7DAWTReqTsdpBElW+J5L9EnmW+UF0Y3movp4N+Av06JTPGl/jdAETZzFOqB2o1dEmYx1a8YuQicdlf092uvQ749+uLbefZ6K4gkJJLAIgiDsUEVQtjykfRxZlJ75lydOozyywvdc3+S97qAzilE9yX5tPmJZVbbwMeLzA33n7LseraJMRvGof53MB3BJnZeeeHe2iDa+LiESqSieUEACiyAIwg5VpIQnB/2cQhPyH3ZsfFM3UmgxFDuppfM2fzG3yEx0oyY6rSJU8TPAsjcHP9+5JT2UOr13oYnp82z20k3EziSOHBqv6g1PrZoY8jRGbTnRgvUH16OrpwvVVdVYcssSNExtyOlaRPFAAosgCMIOu7SSSH/5gvnfS/VmXYg0pVQ0cGfXlw2gPvR/7dN/xqhTaEK24AK0OjclzL24VIkj5tciWVZfX3Hcrug9x6L4lhMtaPpdE3qTvQCAzp5ONP2uCQBIZJU4VOROEARhR91c+3OS/UD5WE1o6Ycdi4gMoH088wvpwnILZG/WVmlKK8sCt/cxXl9WSK4aQG3nseU06qRK/cmsJZzYNygjkKlB6wuVbYU4btfEYFyzQ1uJ9QfXZ8SVoDfZi/UH11vfjyh6KIJFEARhx/Fdzs6LnwEmXQcsOjt4bP63s6M9wrFdZnIpkAkMyzTlg0D7XuuZhqr72BqgOhR7doQmAvPWOYs6qdzrjXVPh36abbiqirqpXqd+n1WRN54E1l0B9MXU6zUKx+hGYOvfAKnE4Lq2/s3g47rIX9dEJr1kV0+X+n5ESUACiyAIwg6n6R+ZMJLWOX3R+jr1q80pOMsaLw7s/zFQe5u7dKGTMTxSsedyNuLCf3efxgyEBtclK0pPxIE3f2t+nrH5AHDWdWk1r9GqHoz5siN9kUVaTZ4QV4JUwvx1j51E9djL0Bk0vxVXV1Wr70mUBCSwCIIgjLgSN2nEG7bxNLfRHpFS1I+1iZ3UOut8QfMbdwbuvNBabzcAeQQFgDqlJywKnKIXH1n37wCu+Qaw7i8HLRTq5gKHf569Z3Ydf0Z4MjuSpbJt2Pygdqx+de4zH8Xa9NEzF80OS86cRdPFE9HrG6zYqfBXYMktiiHYRMlANVgEQRB6ZPVF/efNBey+YFoM2Zh0uil+Doa0NNrOZeZ6plQSCJSpa4Wc3ivr9QFZHlP+MmevyY24ArKd1437y5NpQSJquX6c/8ghwFw/JlzsF/4AGIhn31MIo4zxqkf3dEBDzwU0vduNmsQAGOeoqapB0+1NVOA+AqAIFkEQhB5ZxMno3+Smi82psSUYMPlW7f6qCEh/j5ZuU6UYnbjJW0XUkv3aazR29RmxSqep0IsPSwHl0EIBzP7c2EmtyFz/9bJyhRcO+OuuyN1yI3Yy23bCAQ09F9DQc0H7pOmV3O5LFB0ksAiCIPSookBG/yan1K/OLnhWwuU1RUYii4Adj2hiy0jv2cFuNZVflq3dwMlBB3WVkKxfraXXHIsh3bVzxShwZalEKYYoler1ezV7kOWRGLKKThIlBwksgiAIPU46ztzCLOqc3CDqs/ovyB/nKU3MMZZdv6WvR7KNqDGd95OiKy+ySOta3P9juBNZDqJOsvNE6tQo9GpvM9SSWVxbRKmcfH3zceXnqdyjX25Tr0RRQzVYBEEQemSDgnOZ8ydofdzeH8oJvqAmMgBrsZdKmO+XiGtpxeYbtMiPchCyRKSo6ormf1urZ9L7fAmUpqsOxFUwBMz8vLMh1JFF2tclPEW7tl0EKNbh7Os7XIOe86n/IooOimARBEHo8XLOH+BN6sk4tqZurmbs6XotJ7W02k2f0fy4jEOLlW7mFkOVxZw+437lEuFy6pVl6oJM34MnNbEUCMmjSOHJHncUOo3IOSAfEU8UJSSwCIIgjBgHBeeDyuLBWFMU75bXVTGfWeA5NT6VkYhrz18qKaZuviG39Khsv1ofh2Px4WbuoWmYtCTiFghpgkUvkPxl2v42hQdFZWii1iFqTKc2flf7t3OZOt0XDOmEavpr2N+Te3pQFaUjShYSWARBEIUiuhHoO2c+7kunsvQF269uASARWDyleWLtXDboFZVPsbi4rwwnhpz53kNPMASM/wDwaYvOOWN0rL/HPrIUP6OlL/VRqr5zg+JH1DrJxJC+o1DV0cn8ckFkEn8OCU8hcTUCoRosgiCIQtH6uLx7MGX0fvqRdeQj2Z99vsoclPnlNVFGVBGpyCKdF5RN/VOu92C+7GtbWUvIPMmcRIhEKnDpK9qswbIqB12cOoQ4tJphqKoJa/yus6+BgFKDIxaKYBEEQRSC6Mb8I01KOKSddo3f1T62iqLYvaF7lR5V2VP4AsCC7w3eo61NfY2dy9xHg2Svz+3XQYjDXDpK9XVpWx6y7gx0M5+RKDnyimAxxn7JGHsp/e8txthL6eMfZIzFdY9935vlEgRBlAAi8lJQuDrSFNB1yQWrnLmz50N0o1a/1TRe+z+6UbtH+Vjzucl+TTg5uabbeibZ64tuhOU4ICN6gZZPR2lkEfCp78s7NkMTNcPYZW+SuBrB5BXB4pzfLz5mjP0TAP248Tc45zfnc32CIIiSxO38wVwITzEXqu/4irlzL3EBSPS4KyR3g2yYdWYmn8JPKt49aIh6+l2g6W5zt6bLkTPS/chcx6bYnvkAzs1ryLej1OuOVKKk8CRFyBhjABYB+KgX1yMIgihpvLBmCE3UBIoo0Nan2mRRlOhGhS1C+nOVaWi+WI2esSrI37lMmwk4dTlMbuuRRe73sL9nMHKmx8l1ONdqtWTkmzL1siOVKCm8KnK/E8AfOefHdceuYIwdYoz9ljF2p0f3IQiCKH7yNaqc+QUtfdR0Vvv/7n+1Lzx3EqnJYRixLVajZ6xSafFutTAD3O9hvFur+RKRMZG2dGIVMVzGosSIhnFu/c3HGHsWQLXkoUc559vS5/x/AF7nnP9T+vNyAGM45+8xxmYA2Arges75+5LrPwjgQQC49NJLZzz55JM4f/48xowZk8/rGlXQfrmD9ssdtF/uOH/+PMb4E8DZduRkQsn8QPWNzs6NnwHOdbp3iq/xsHrj9B/k9/eXAZOuA7petiz0Pl9+Gcb0nTKvL35Gi2rxlPzaqQH5Y8w/GDmTPW4636eJVieDsosA+nl0R6H366677jrAOZ8pe8w2Rcg5/5jV44yxAICFAGbontMHoC/98QHG2BsApgHYL7n+DwD8AABmzpzJ58yZg7a2NsyZM8duaUQa2i930H65g/bLHZn9WndFjqaTDHhAka7Sk4/nkpXvlLi207qh6Gm5d1bjd4HIHPXjabf1tqv/HnNe+7p8fVbraAq7e90CYaEgPMXqVwORT+V2rWGAfh7dMZz75UUN1scAHOWcZ+LEjLFLAHRzzpOMsakA6gCc8OBeBEEQpUGuA4OdpqtyKaR30gFnVbSu8n4S65EJIdXjgLnT0rg+Y/2SSPvlXOPGtJQrQQwBXgisBwD8wnBsNoDHGWMDAJIAHuKc5zg/gCAIogTJxXFdCAwnESS3IkPlPm5EVbS+c5n6ucaZhJu/OOgBJboXZR1+AHD0XWi1ZXaRshwjdnqo1ooYQvIWWJzz/yk5tgnApnyvTRAEUbLUr9ZG3DitjxJCBLCOIAkR46a+K5OyM0SDxMBkJwOf491a2lNljGkUQKLuyioCFlkEdLcBixykRPO1viDHdGKIoVE5BEEQhSCyCChzWFwrPJwii6xtD7JGx1jgC1qbixqvoxdDVqac8W7teaJTT4+VAPKiezEf64tCGawShAU0KocgCMJrRHTIaZG7PrJiZXtgJWL0USg7M0vLaJBDqwejYLMTffl6g+WaciVhRQwTJLAIgiC8JH7GXa1QaGK2ALCaf6cUKQz4uo2Y09d15WIfoUe/DqdjgfK1Qahfbd5Xf5kWJRQdgXVzgeO7yDWdKApIYBEEQXhJrMNdrdC8ddmfy4SEqB8SNVNG7Iq3vSgQV93PaW1UvFvrAMxV9NDYGaLEIIFFEAThFdGNlqaaUmSF34BaSKjElxVezkY03s9N6i/fcT00doYoIUhgEQRBeEXr40D1Xzk/X5heGlEJiVyjOPnWP4m5iLL7ua2NktVwEcQIhAQWQRCEV8Q65IPFvCSXKI5KBInCeDt6Y8DCH8jvK0tp2uHFMGyCKHLIpoEgCMIK4R7eNF77X2ZRIHA9oDhHt3e31K/WUnt6giHn6UyeNNsziH3Z/KA29kYVjZNBhp/EKIAEFkEQhIosvyiu/b/5QWDHV+Tn16/Whgc7xUpouBF2dkQWaXYF4SnI8sYKT3F+Db2XlXFf4t3AQNyZyCLDT2KUQClCgiAIFdLicA7s/zFQe5u8QP2dLWlH9A5NbKmiRFZCw+08QCeoUotu0nsitacyQw2EtNelf8wXBMrHqmu4CGKEQhEsgiAIFcpaIa52Jg9N0FzZF/7AOgVnZYBpNQ/QS7IiW9BqsqwQETfVvsTPmCNld/+rNmC56eygWz1BjAIogkUQBKHCqkMudlKLNFnN5VNed4q10FAKmG75PZ0Mh1Yhi2zJfLP0ETcrM1SyUiAIABTBIgiCUGNXK5TLXD4nNUhWtVnGyJmsTky1LqeoaraEcFIVzVNtFUFkIIFFEAShIrIIKKtSP64aYmzlC+VkNp6VUImdBJrCg4XvVsOh8yGySEvpyVJ7dgKMIAhKERIEQUgR4qW/x/q82EnJCBgG+bw/pk4pGlN8wSogYXFvEalSRcoK7TVFqUCCsIQEFkEQhBG3s/v0XX6YBPUwZa6JMb2QAuQdg07sHqzWR15TBDGskMAiCIIwksvsPpGWm/4v1ueJ9KEQUoGQPMWXD1QPRRDDDgksgiAII7mm12IdmlUB8wE8ZX9+Iu7dEGZBeAp5TRFEEUACiyAIwojbAcaC0ATteU7EVUFgWkE6QRDDDnUREgRBGMkpvca0/9yKq9BEs+WB5W0szECp7oogigYSWARBEEYii9wNLwaAmZ/PbXjzvHXZlgcqARWeAjTFgK93Awv/nXyoCKLIIYFFEAQhY946h5ElBsz8AjD/21qK0C3C7kB4Tn3q+/biiXyoCKLooRosgiAIGUKs7FymjajJIu1zpS8oj24E+s+7u4csSibuazf6hnyoCKKoIYFFEAShQogYJ7P+Wh8Hkv3Or+0v06JkVvclCKJkIYFFEARhhxPBY2XtEJ4C1M0Fju/KbSAzQRAlBwksgiAIL1BZO4SnkHUCQYxCqMidIAjCC+pXU2cfQRAZKIJFEAThBSLdd/RdaJ19lAYkiNEMCSyCIAiviCwCutuARWeHeyUEQQwzlCIkCIIgCILwGBJYBEEQBEEQHkMCiyAIgiAIwmNIYBEEQRAEQXgMCSyCIAiCIAiPIYFFEARBEAThMSSwCIIgCIIgPIYEFkEQBEEQhMeQwCIIgiAIgvAYElgEQRAEQRAeQwKLIAiCIAjCY0hgEQRBEARBeAwJLIIgCIIgCI8hgUUQBEEQBOExJLAIgiAIgiA8hgQWQRAEQRCExzDO+XCvIQNj7E8A3gZwMYB3h3k5pQTtlztov9xB++UO2i930H65g/bLHYXerw9wzi+RPVBUAkvAGNvPOZ853OsoFWi/3EH75Q7aL3fQfrmD9ssdtF/uGM79ohQhQRAEQRCEx5DAIgiCIAiC8JhiFVg/GO4FlBi0X+6g/XIH7Zc7aL/cQfvlDtovdwzbfhVlDRZBEARBEEQpU6wRLIIgCIIgiJKlqAQWY+xmxthexthLjLH9jLFbdY+tYIy9zhh7jTH2/wznOosJxtiX0nvyKmPsH3THab8UMMa+xhjjjLGLdcdovwwwxv6RMXaUMRZljG1hjI3XPUb7JYEx9vH0nrzOGFs+3OspNhhjUxhjzzHGjqR/Zy1JH5/IGHuGMXY8/f+E4V5rscAY8zPGDjHGdqQ/p72ygDE2njH2dPp31xHG2IeHa8+KSmAB+AcAf885vxnA6vTnYIxdB+ABANcD+DiAf2WM+YdtlUUCY+wuAAsARDjn1wP4Vvo47ZcCxtgUAH8OoF13jPZLzjMAbuCcRwAcA7ACoP1Skd6D7wGYB+A6AJ9O7xUxyACAr3LOrwVwG4CH03u0HEAr57wOQGv6c0JjCYAjus9pr6xZD+A/OefXALgJ2t4Ny54Vm8DiAMalPw4DOJX+eAGAJznnfZzzNwG8DuBWyfNHG/8LwFrOeR8AcM5Pp4/TfqlpBvD/QvteE9B+SeCc7+KcD6Q/3Qtgcvpj2i85twJ4nXN+gnPeD+BJaHtFpOGcd3LOD6Y/Pgftze9yaPu0IX3aBgB3D88KiwvG2GQADQB+qDtMe6WAMTYOwGwAPwIAznk/5/wshmnPik1gPQLgHxljJ6FFY1akj18O4KTuvI70sdHONAB3Msb2McZ+yxj7UPo47ZcExtgnAbzDOT9seIj2y57PA9iZ/pj2Sw7tiwsYYx8EMB3APgCXcs47AU2EAZg0fCsrKr4D7Q/ClO4Y7ZWaqQD+BOA/0mnVHzLGqjBMexYYipvoYYw9C6Ba8tCjAOoBLOWcb2KMLYKmQj8GgEnOHxXtjzb7FQAwAVqo/UMANjLGpoL2S7VfKwHMlT1NcmzU7xfnfFv6nEehpXZ+Jp4mOX9U7JcNtC8OYYyNAbAJwCOc8/cZk23d6IYxNh/Aac75AcbYnOFeT4kQAHALgC9xzvcxxtZjGFOoQy6wOOcfUz3GGPsJtHwzADyFwbBoB4ApulMnYzB9OKKx2a//BWAz17w2XmSMpaDNXaL9MsAYuxHAFQAOp3+ZTwZwMN1IQfulgDG2GMB8APV80NNl1O6XDbQvDmCMBaGJq59xzjenD/+RMVbDOe9kjNUAOK2+wqjhDgCfZIx9AkAFgHGMsZ+C9sqKDgAdnPN96c+fhiawhmXPii1FeArAR9IffxTA8fTHvwLwAGOsnDF2BYA6AC8Ow/qKja3Q9gmMsWkAyqANtaT9MsA5f5lzPolz/kHO+Qeh/SDewjnvAu2XFMbYxwEsA/BJzvkF3UO0X3L+G0AdY+wKxlgZtEaAXw3zmooKpv118yMARzjn39Y99CsAi9MfLwawbajXVmxwzldwzienf189AOC/OOefA+2VkvTv85OMsavTh+oB/AHDtGdDHsGy4YsA1jPGAgB6ATwIAJzzVxljG6Ft1ACAhznnyeFbZtHwYwA/Zoy9AqAfwOJ0lIH2ywX0/aXkXwCUA3gmHfXbyzl/iPZLDud8gDH2twB+A8AP4Mec81eHeVnFxh0A/geAlxljL6WPrQSwFlqJwxegdfjeN0zrKwVor6z5EoCfpf/IOQHgL6EFk4Z8z8jJnSAIgiAIwmOKLUVIEARBEARR8pDAIgiCIAiC8BgSWARBEARBEB5DAosgCIIgCMJjSGARBEEQBEF4DAksgiAIgiAIjyGBRRAEQRAE4TEksAiCIAiCIDzm/wfBI+Wf7GfO1wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# take 2000 samples\n",
    "num_samples = 2000\n",
    "sample_dataloader = DataLoader(train_data, batch_size=num_samples, shuffle=True, drop_last=True)\n",
    "samples, labels = next(iter(sample_dataloader))\n",
    "\n",
    "labels = labels.data.cpu().numpy()\n",
    "# decode the samples\n",
    "_,_, _, z = vae(samples.view(num_samples, X_DIM).to(device))\n",
    "\n",
    "# t-SNE\n",
    "perplexity = 15.0\n",
    "t_sne = TSNE(n_components=2, perplexity=perplexity)\n",
    "z_embedded = t_sne.fit_transform(z.data.cpu().numpy())\n",
    "\n",
    "# plot\n",
    "fig = plt.figure(figsize=(10 ,8))\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "for i in np.unique(labels):\n",
    "    ax.scatter(z_embedded[labels==i,0], z_embedded[labels==i, 1], label=str(i))\n",
    "ax.legend()\n",
    "ax.grid()\n",
    "ax.set_title(\"t-SNE of VAE Latent Space on MNIST\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <img src=\"https://img.icons8.com/bubbles/50/000000/video-playlist.png\" style=\"height:50px;display:inline\"> Recommended Videos\n",
    "---\n",
    "#### <img src=\"https://img.icons8.com/cute-clipart/64/000000/warning-shield.png\" style=\"height:30px;display:inline\"> Warning!\n",
    "* These videos do not replace the lectures and tutorials.\n",
    "* Please use these to get a better understanding of the material, and not as an alternative to the written material.\n",
    "\n",
    "#### Video By Subject\n",
    "\n",
    "* Variational Inference (VI) - <a href=\"https://www.youtube.com/watch?v=2pEkWk-LHmU\">Machine Learning: Variational Inference</a>\n",
    "    * Until 13:30 mins\n",
    "* Analyzing the KL-Divergence in VI - <a href=\"https://www.youtube.com/watch?v=uKxtmkfeuxg\">Variational Inference Part 2 (KL divergence)</a>\n",
    "* Generative Models (VAEs + GANs) - <a href=\"https://www.youtube.com/watch?v=5WoItGTWV54\">Standord CS231n - Lecture 13 | Generative Models</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## <img src=\"https://img.icons8.com/dusk/64/000000/prize.png\" style=\"height:50px;display:inline\"> Credits\n",
    "---\n",
    "* Deep Learning - Unsupervised Learning, <a href=\"https://www.cs.cmu.edu/~rsalakhu/talk_MLSS_part2.pdf\"> Tutorial by Ruslan Salakhutdinov (CMU) </a> - https://www.cs.cmu.edu/~rsalakhu/\n",
    "* <a href=\"https://sites.google.com/view/berkeley-cs294-158-sp19/home\"> CS294-158 Deep Unsupervised Learning Spring 2019 </a> @ UC Berkeley - https://sites.google.com/view/berkeley-cs294-158-sp19/home\n",
    "* <a href=\"https://jeremyjordan.me/variational-autoencoders/\"> Variational autoencoders. </a> by Jeremy Jordan - https://jeremyjordan.me\n",
    "* <a href=\"https://wiseodd.github.io/techblog/2016/12/10/variational-autoencoder/\">Variational Autoencoder: Intuition and Implementation </a> by Agustinus Kristiadi\n",
    "* Icons from <a href=\"https://icons8.com/\">Icon8.com</a> - https://icons8.com\n",
    "* Datasets from <a href=\"https://www.kaggle.com/\">Kaggle</a> - https://www.kaggle.com/"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}