{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Adapt from the Stanford CS231n [assignment1](http://vision.stanford.edu/teaching/cs231n/assignments.html), find the original version on the course website.*\n",
    "\n",
    "In this exercise we will:\n",
    "    \n",
    "- implement a fully-vectorized **loss function** for the SVM\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** using numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import time\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "\n",
    "# plotting setting\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load CIFAR-10 data\n",
    "\n",
    "Load the data and split into training / validation / testing datasets. See notebook 00 for more details. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape: (3073, 49000)\n",
      "Train labels shape: (49000,)\n",
      "Validation data shape: (3073, 1000)\n",
      "Validation labels shape: (1000,)\n",
      "Test data shape: (3073, 1000)\n",
      "Test labels shape: (1000,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "\n",
    "    # subsample the data\n",
    "    mask = range(num_training, num_training + num_validation)\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = range(num_training)\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = range(num_test)\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "\n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "\n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "\n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))]).T\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))]).T\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))]).T\n",
    "\n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR10_data()\n",
    "print('Train data shape:', X_train.shape)\n",
    "print('Train labels shape:', y_train.shape)\n",
    "print('Validation data shape:', X_val.shape)\n",
    "print('Validation labels shape:', y_val.shape)\n",
    "print('Test data shape:', X_test.shape)\n",
    "print('Test labels shape:', y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class LinearClassifier:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.W = None\n",
    "\n",
    "    def train(\n",
    "        self, X, y,\n",
    "        learning_rate=1e-3, reg=1e-5, num_iters=100, batch_size=200,\n",
    "        verbose=False, seed=None\n",
    "    ):\n",
    "        \"\"\"Train this linear classifier using stochastic gradient descent.\n",
    "\n",
    "        Inputs:\n",
    "        - X: D x N array of training data. Each training point is a\n",
    "             D-dimensional column.\n",
    "        - y: 1-dimensional array of length N with labels 0...K-1 for K classes.\n",
    "        - learning_rate: (float) learning rate for optimization.\n",
    "        - reg: (float) regularization strength.\n",
    "        - num_iters: (integer) number of steps to take when optimizing.\n",
    "        - batch_size: (integer) number of training examples to use\n",
    "                                at each step.\n",
    "        - verbose: (boolean) If true, print progress during optimization.\n",
    "\n",
    "        Outputs:\n",
    "        A list containing the value of the loss function at each training\n",
    "        iteration.\n",
    "        \"\"\"\n",
    "        dim, num_train = X.shape\n",
    "        # assume y takes values 0...K-1 where K is number of classes\n",
    "        num_classes = np.max(y) + 1\n",
    "        if self.W is None:\n",
    "            # lazily initialize W\n",
    "            self.W = np.random.randn(num_classes, dim) * 0.001\n",
    "\n",
    "        batch_rs = np.random.RandomState(seed)\n",
    "        # Run stochastic gradient descent to optimize W\n",
    "        loss_history = []\n",
    "        for it in range(num_iters):\n",
    "            batch_ix = batch_rs.choice(\n",
    "                np.arange(num_train),\n",
    "                size=batch_size, replace=True\n",
    "            )\n",
    "            X_batch = X[:, batch_ix]\n",
    "            y_batch = y[batch_ix]\n",
    "\n",
    "            # evaluate loss and gradient, internally use self.W\n",
    "            loss, grad = self.loss(X_batch, y_batch, reg)\n",
    "            loss_history.append(loss)\n",
    "\n",
    "            # perform parameter update\n",
    "            self.W -= grad * learning_rate\n",
    "            \n",
    "            if verbose and it % 100 == 0:\n",
    "                print('iteration %d / %d: loss %f' % (it, num_iters, loss))\n",
    "\n",
    "        return loss_history\n",
    "\n",
    "    def predict(self, X):\n",
    "        \"\"\"\n",
    "        Use the trained weights of this linear classifier to predict labels for\n",
    "        data points.\n",
    "\n",
    "        Inputs:\n",
    "        - X: D x N array of training data. Each column is a D-dimensional point.\n",
    "\n",
    "        Returns:\n",
    "        - y_pred: Predicted labels for the data in X. y_pred is a 1-dimensional\n",
    "        array of length N, and each element is an integer giving the predicted\n",
    "        class.\n",
    "        \"\"\"\n",
    "        score_pred = self.W.dot(X)  # shape: C x N\n",
    "        y_pred = score_pred.argmax(axis=0)\n",
    "        return y_pred\n",
    "\n",
    "    def loss(self, X_batch, y_batch, reg):\n",
    "        \"\"\"\n",
    "        Compute the loss function and its derivative.\n",
    "        Subclasses will override this.\n",
    "\n",
    "        Inputs:\n",
    "        - X_batch: D x N array of data; each column is a data point.\n",
    "        - y_batch: 1-dimensional array of length N with labels 0...K-1, for K classes.\n",
    "        - reg: (float) regularization strength.\n",
    "\n",
    "        Returns: A tuple containing:\n",
    "        - loss as a single float\n",
    "        - gradient with respect to self.W; an array of the same shape as W\n",
    "        \"\"\"\n",
    "        raise NotImplementedError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def softmax_loss_naive(W, X, y, reg):\n",
    "    \"\"\"\n",
    "    Softmax loss function, naive implementation (with loops)\n",
    "    \n",
    "    Inputs:\n",
    "    - W: C x D array of weights\n",
    "    - X: D x N array of data. Data are D-dimensional columns\n",
    "    - y: 1-dimensional array of length N with labels 0...K-1, for K classes\n",
    "    - reg: (float) regularization strength\n",
    "    \n",
    "    Returns:\n",
    "    a tuple of:\n",
    "    - loss as single float\n",
    "    - gradient with respect to weights W, an array of same size as W\n",
    "    \"\"\"\n",
    "    # Initialize the loss and gradient to zero.\n",
    "    loss = 0.0\n",
    "    dW = np.zeros_like(W)\n",
    "    num_train = X.shape[1]\n",
    "    f = W.dot(X)  # shape: C x N\n",
    "    p = np.zeros(num_train, dtype=np.float)\n",
    "\n",
    "    for i in range(num_train):\n",
    "        f_i = f[:, i].copy()  # shape C x 1\n",
    "        f_i -= np.max(f_i)    # improve numerical stability\n",
    "        f_i = np.exp(f_i)\n",
    "        x_i = X[:, i]\n",
    "        all_class_p_i = f_i / np.sum(f_i)\n",
    "        p[i] = all_class_p_i[y[i]]\n",
    "\n",
    "        # Update gradient\n",
    "        # all_class_p_i no used later, don't copy\n",
    "        dw_x_weight_i = all_class_p_i\n",
    "        dw_x_weight_i[y[i]] -= 1\n",
    "        dW -= dw_x_weight_i[:, np.newaxis] * x_i[np.newaxis, :]\n",
    "\n",
    "    loss += np.mean(-np.log(p))\n",
    "    # Add regularization\n",
    "    loss += 0.5 * reg * np.sum(W * W)\n",
    "\n",
    "    # Gradient\n",
    "    # ref: http://ufldl.stanford.edu/wiki/index.php/Softmax_Regression\n",
    "    dW /= -num_train\n",
    "    dW += reg * W\n",
    "    return loss, dW"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sanity Check\n",
    "\n",
    "In a randomly initiated weight, the loss should be close to $-\\log(\\frac{1}{10}) = -\\log(0.1) \\approx 2.303$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.361666\n",
      "sanity check: 2.302585\n",
      "CPU times: user 6.36 s, sys: 91.5 ms, total: 6.45 s\n",
      "Wall time: 4.44 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(10, 3073) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_train, y_train, 0.0)\n",
    "\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Class: 0 Dim: 2221] numerical: -1.882017 analytic: -1.882017, relative error: 2.026398e-08\n",
      "[Class: 6 Dim: 2581] numerical: -0.205202 analytic: -0.205202, relative error: 3.305388e-08\n",
      "[Class: 2 Dim: 2379] numerical: -0.884728 analytic: -0.884729, relative error: 2.291555e-08\n",
      "[Class: 9 Dim: 2941] numerical: 0.779991 analytic: 0.779991, relative error: 2.284831e-08\n",
      "[Class: 0 Dim: 710] numerical: -3.913095 analytic: -3.913095, relative error: 1.904841e-08\n",
      "CPU times: user 1min 7s, sys: 1.06 s, total: 1min 8s\n",
      "Wall time: 48.5 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "loss, grad = softmax_loss_naive(W, X_train, y_train, 0.0)\n",
    "\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "f = lambda w: softmax_loss_naive(w, X_train, y_train, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 5)  # increase 5 here to check for more times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vectorized loss function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def softmax_loss_vectorized(W, X, y, reg):\n",
    "    \"\"\"\n",
    "    Softmax loss function, vectorized version.\n",
    "\n",
    "    Inputs and outputs are the same as softmax_loss_naive.\n",
    "    \"\"\"\n",
    "    # Initialize the loss and gradient to zero.\n",
    "    loss = 0.0\n",
    "    dW = np.zeros_like(W)\n",
    "    num_train = X.shape[1]\n",
    "    _train_ix = np.arange(num_train)  # for sample coord 0...N-1\n",
    "\n",
    "    f = W.dot(X)  # shape: C x N\n",
    "    f -= np.max(f, axis=0)  # improve numerical stability\n",
    "    f = np.exp(f)\n",
    "    p = f / np.sum(f, axis=0)  # shape: C x N\n",
    "\n",
    "    # loss function\n",
    "    loss += np.mean(-np.log(p[y, _train_ix]))\n",
    "    loss += 0.5 * reg * np.sum(W * W)\n",
    "\n",
    "    # gradient\n",
    "    # ref: http://ufldl.stanford.edu/wiki/index.php/Softmax_Regression\n",
    "    dW_x_weight = p  # no use p later, don't copy\n",
    "    dW_x_weight[y, _train_ix] -= 1\n",
    "    # CxD -= CxN dot NxD\n",
    "    dW -= dW_x_weight.dot(X.T)\n",
    "    dW /= -num_train\n",
    "    dW += reg * W\n",
    "\n",
    "    return loss, dW"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.361666e+00 computed in 4.406073s\n",
      "vectorized loss: 2.361666e+00 computed in 0.124524s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_train, y_train, 0.00001)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_train, y_train, 0.00001)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# The losses should match but your vectorized implementation should be much faster.\n",
    "# The loss is a single number, so it is easy to compare the values computed\n",
    "# by the two implementations. The gradient on the other hand is a matrix, so\n",
    "# we use the Frobenius norm to compare them.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stochastic Gradient Descent\n",
    "\n",
    "We now have vectorized and efficient expressions for the loss, the gradient and our gradient matches the numerical gradient. We are therefore ready to do SGD to minimize the loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Softmax(LinearClassifier):\n",
    "    \"\"\" A subclass that uses the Softmax + Cross-entropy loss function \"\"\"\n",
    "\n",
    "    def loss(self, X_batch, y_batch, reg):\n",
    "        return softmax_loss_vectorized(self.W, X_batch, y_batch, reg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0 / 1500: loss 771.351533\n",
      "iteration 100 / 1500: loss 6.911816\n",
      "iteration 200 / 1500: loss 2.059462\n",
      "iteration 300 / 1500: loss 2.065780\n",
      "iteration 400 / 1500: loss 2.084819\n",
      "iteration 500 / 1500: loss 2.094321\n",
      "iteration 600 / 1500: loss 2.060693\n",
      "iteration 700 / 1500: loss 2.053175\n",
      "iteration 800 / 1500: loss 2.047805\n",
      "iteration 900 / 1500: loss 2.082586\n",
      "iteration 1000 / 1500: loss 2.086963\n",
      "iteration 1100 / 1500: loss 2.060702\n",
      "iteration 1200 / 1500: loss 2.057573\n",
      "iteration 1300 / 1500: loss 2.116810\n",
      "iteration 1400 / 1500: loss 2.082615\n",
      "That took 4.024618s\n"
     ]
    }
   ],
   "source": [
    "# Now implement SGD in LinearSVM.train() function and run it with the code below\n",
    "softmax = Softmax()\n",
    "tic = time.time()\n",
    "loss_hist = softmax.train(\n",
    "    X_train, y_train,\n",
    "    learning_rate = 5e-8, reg=1e3,\n",
    "    # better params:\n",
    "    # learning_rate=5e-7, reg=5e4,\n",
    "    num_iters=1500, seed=9527, verbose=True\n",
    ")\n",
    "toc = time.time()\n",
    "print('That took %fs' % (toc - tic))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": [
       "iVBORw0KGgoAAAANSUhEUgAAAm0AAAHuCAYAAADNxztVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
       "AAALEgAACxIB0t1+/AAAIABJREFUeJzt3X+8ZXV93/vXmxkG+aVINcOPmRRiIBVjEk1ETGIySQ0l\n",
       "aQSaRqCtlhhu+sglxh83RsH2EWh7e0Ntc/PrljZp1EyoUif+IHCTKCNljCY34g9QYEQgySiDzoCK\n",
       "/BAZZpjP/WOvzew5c87MPjN7n33WWq/n43Eee621117ru7+zz573+XzXj1QVkiRJWt4Om3UDJEmS\n",
       "dGCGNkmSpBYwtEmSJLWAoU2SJKkFDG2SJEktYGiTJElqgamGtiSXJ7kzye1J3pPkiCTHJ9mY5O4k\n",
       "NyY5bs769yS5K8nZ02ybJElSm2Ra12lLcgrwv4DnV9WOJO8F/gx4AfDVqnp7krcCz66qy5KcAbwH\n",
       "eAlwMvAR4PSq2j2VBkqSJLXINCttjwA7gaOSrASOAr4MnAusb9ZZD5zfTJ8HXFtVO6tqC3AvcOYU\n",
       "2ydJktQaUwttVfV14DeALzEIa9+oqo3A6qra3qy2HVjdTJ8EbB3ZxFYGFTdJkqTeWzmtDSd5HvBG\n",
       "4BTgYeCPk7x6dJ2qqiT7G5/d57kDrC9JkrSsVFUmsZ2phTbgB4C/qqqvAST5APAyYFuSE6pqW5IT\n",
       "gQea9e8H1o68fk2zbB+TevNdkuTKqrpy1u1YbuyXfdkn87Nf5me/zM9+2Zd9Mr9JFpumeUzbXcBZ\n",
       "SY5MEuAVwGbgBuDiZp2Lgeua6euBi5KsSnIqcBpwyxTbJ0mS1BpTq7RV1WeT/BHwKWA38Bng94Fj\n",
       "gQ1JLgG2ABc0629OsoFBsNsFXFrTOrVVkiSpZaZ2yY9pSVIOj+4rybqq2jTrdiw39su+7JP52S/z\n",
       "s1/mZ7/syz6Z3yRzi6FNkiRpSiaZW7yNlSRJUgsY2iRJklrA0CZJktQChjZJkqQWMLRJkiS1gKFN\n",
       "kiSpBQxtkiRJLWBokyRJagFDmyRJUgsY2iRJklrA0CZJktQChjZJkqQWMLRJkiS1gKFNkiSpBQxt\n",
       "kiRJLWBokyRJagFDmyRJUgsY2iRJklrA0CZJktQChjZJkqQWMLRJkiS1gKFNkiSpBQxtkiRJLWBo\n",
       "kyRJagFDmyRJUgsY2iRJklrA0CZJktQChjZJkqQWMLRJkiS1gKFNkiSpBQxtkiRJLdDK0Ja0s92S\n",
       "JEkHq63hZ+WsGyBJkrSU2hraDp91AyRJkpZSW0OblTZJktQrbQ1tVtokSVKvtDW0WWmTJEm90tbQ\n",
       "ZqVNkiT1SltDm5U2SZLUK20NbVbaJElSr7Q1tFlpkyRJvdLW0GalTZIk9UpbQ5uVNkmS1CttDW1W\n",
       "2iRJUq+0NbRZaZMkSb3S1tBmpU2SJPXKVENbku9KcuvIz8NJXp/k+CQbk9yd5MYkx4285vIk9yS5\n",
       "K8nZC2zaSpskSeqVqYa2qvpCVb2oql4EfD/wOPBB4DJgY1WdDtzUzJPkDOBC4AzgHODqJPO10Uqb\n",
       "JEnqlaUcHn0FcG9V3QecC6xvlq8Hzm+mzwOuraqdVbUFuBc4c55tWWmTJEm9spSh7SLg2mZ6dVVt\n",
       "b6a3A6ub6ZOArSOv2QqcPM+2rLRJkqReWZKKVZJVwCuBt859rqoqSe3n5fM892MXJZte2MxsqqpN\n",
       "E2imJEnSIUmyDlg3jW0v1TDjTwKfrqoHm/ntSU6oqm1JTgQeaJbfD6wded2aZtkcN/9JFf9jiu2V\n",
       "JElatKaQtGk4n+SKSW17qYZH/xl7hkYBrgcubqYvBq4bWX5RklVJTgVOA26ZZ3se0yZJknpl6uEn\n",
       "ydEMTkL4hZHFVwEbklwCbAEuAKiqzUk2AJuBXcClVTXf0KnHtEmSpF7J/Jlo+Roc/1aXVvFfZ90W\n",
       "SZKk/UlSVZVJbMs7IkiSJLVAW0Obx7RJkqReaWtos9ImSZJ6pa2hzUqbJEnqlbaGNittkiSpV9oa\n",
       "2qy0SZKkXmlraLPSJkmSeqWtoc1KmyRJ6pW2hjYrbZIkqVfaGtqstEmSpF5pa2iz0iZJknqlraHN\n",
       "SpskSeqVtoY2K22SJKlX2hrarLRJkqReaWtos9ImSZJ6pa2hzUqbJEnqlbaGNittkiSpV9oa2qy0\n",
       "SZKkXmlraLPSJkmSeqWtoc1KmyRJ6pW2hjYrbZIkqVfaGtqstEmSpF5pa2iz0iZJknqlraHNSpsk\n",
       "SeqVtoY2K22SJKlX2hrarLRJkqReaWtos9ImSZJ6pa2hzUqbJEnqlbaGNittkiSpV9oa2qy0SZKk\n",
       "XmlraLPSJkmSeqWtoc1KmyRJ6pW2hjYrbZIkqVfaGtpI2tt2SZKkxWpr8NmF1TZJktQjbQ1tOzG0\n",
       "SZKkHmlraHsSWDXrRkiSJC2VNoc2K22SJKk32hradmKlTZIk9UhbQ5uVNkmS1CttDW1W2iRJUq+0\n",
       "NbRZaZMkSb3S1tBmpU2SJPVKW0OblTZJktQrbQ1tVtokSVKvtDW0eXFdSZLUK20ObQ6PSpKk3ph6\n",
       "aEtyXJL3Jfl8ks1JXprk+CQbk9yd5MYkx42sf3mSe5LcleTsBTbr8KgkSeqVpai0/TbwZ1X1fOB7\n",
       "gLuAy4CNVXU6cFMzT5IzgAuBM4BzgKuTzNdGK22SJKlXphrakjwLeHlVvROgqnZV1cPAucD6ZrX1\n",
       "wPnN9HnAtVW1s6q2APcCZ86zaSttkiSpV6ZdaTsVeDDJu5J8Jsl/T3I0sLqqtjfrbAdWN9MnAVtH\n",
       "Xr8VOHme7VppkyRJvbJyCbb/YuB1VfXJJL9FMxQ6VFWVpPazjXmee+0LYduzkw+dCmyqqk2Ta7Ik\n",
       "SdLBSbIOWDeNbU87tG0FtlbVJ5v59wGXA9uSnFBV25KcCDzQPH8/sHbk9WuaZXO866+BO6v4L9Nq\n",
       "uCRJ0mI1haRNw/kkV0xq21MdHq2qbcB9SU5vFr0CuBO4Abi4WXYxcF0zfT1wUZJVSU4FTgNumWfT\n",
       "Do9KkqRemXalDeCXgXcnWQX8DfBaYAWwIcklwBbgAoCq2pxkA7AZ2AVcWlXzDZ16IoIkSeqVzJ+J\n",
       "lq/B8W/1fwGPV/EfZt0eSZKkhSSpqsokttXWOyJYaZMkSb3S1tDmMW2SJKlX2hrarLRJkqReaWto\n",
       "s9ImSZJ6pa2hzUqbJEnqlbaGticxtEmSpB5pc2hzeFSSJPVGW0Obw6OSJKlX2hrarLRJkqReaWto\n",
       "s9ImSZJ6pa2hzUqbJEnqlbaGNittkiSpV9oa2qy0SZKkXmlraLPSJkmSeqWtoc2L60qSpF5pc2hz\n",
       "eFSSJPVGW0Obw6OSJKlX2hrarLRJkqReaWtos9ImSZJ6pa2hzUqbJEnqlbaGNittkiSpV9oa2qy0\n",
       "SZKkXmlraLPSJkmSeqXNoW1lQmbdEEmSpKXQytBWRTEIbg6RSpKkXmhlaGs4RCpJknqjzaHNkxEk\n",
       "SVJvtDm0WWmTJEm90ebQZqVNkiT1RptDm5U2SZLUG20ObVbaJElSb7Q5tFlpkyRJvdHm0PYkhjZJ\n",
       "ktQTbQ9tDo9KkqReaHNoc3hUkiT1RptDm5U2SZLUG20ObVbaJElSb7Q5tFlpkyRJvdHm0GalTZIk\n",
       "9UabQ5uVNkmS1BttDm1W2iRJUm+0ObR5cV1JktQbhjZJkqQWaHto85g2SZLUC20PbUfMuhGSJElL\n",
       "oc2hbQeGNkmS1BNtDm0e0yZJknpj6qEtyZYkn0tya5JbmmXHJ9mY5O4kNyY5bmT9y5Pck+SuJGfv\n",
       "Z9NW2iRJUm8sRaWtgHVV9aKqOrNZdhmwsapOB25q5klyBnAhcAZwDnB1koXauAMrbZIkqSeWang0\n",
       "c+bPBdY30+uB85vp84Brq2pnVW0B7gXOZH6eiCBJknpjqSptH0nyqSS/0CxbXVXbm+ntwOpm+iRg\n",
       "68hrtwInL7Bdh0clSVJvrFyCffxQVX0lyXOBjUnuGn2yqipJ7ef1+zyX5Er48RfCqacl71hXVZsm\n",
       "22RJkqTFS7IOWDeNbU89tFXVV5rHB5N8kMFw5/YkJ1TVtiQnAg80q98PrB15+Zpm2dxtXpnwKuDC\n",
       "qj/YNNU3IEmSNKamkLRpOJ/kiklte6rDo0mOSnJsM300cDZwO3A9cHGz2sXAdc309cBFSVYlORU4\n",
       "Dbhlgc07PCpJknpj2pW21cAHkwz39e6qujHJp4ANSS4BtgAXAFTV5iQbgM3ALuDSqlpo6NTrtEmS\n",
       "pN7IwploeUrSHAbHjwFXVE1n3FiSJOlQDXPLJLbV5jsieJ02SZLUG20ObV6nTZIk9UabQ5snIkiS\n",
       "pN5oc2jzRARJktQbbQ5tVtokSVJvtD20WWmTJEm90ObQ5okIkiSpN9oc2hwelSRJvdH20ObwqCRJ\n",
       "6oU2h7ZdwIqk1e9BkiRpLK0NPFUUHtcmSZJ6orWhreG12iRJUi+0PbR5MoIkSeqFLoQ2K22SJKnz\n",
       "2h7aPKZNkiT1QttDm8OjkiSpF7oQ2hwelSRJndf20ObwqCRJ6oW2hzaHRyVJUi+0PbR5nTZJktQL\n",
       "bQ9tVtokSVIvdCG0WWmTJEmd1/bQ5okIkiSpF9oe2hwelSRJvdD20OaJCJIkqRfaHtqstEmSpF44\n",
       "YGhLckKSdyT5UDN/RpJLpt+0sRjaJElSL4xTaftD4EbgpGb+HuBN02rQIhnaJElSL4wT2p5TVe8F\n",
       "ngKoqp3Arqm2anxPYGiTJEk9ME5oeyzJ3xvOJDkLeHh6TVqUHcAzZt0ISZKkaVs5xjq/AtwAfEeS\n",
       "vwKeC/zsVFs1vicwtEmSpB44YGirqk8n+VHgu5pFX2iGSJcDQ5skSeqFA4a2JBcDBaRZ9OIkVNUf\n",
       "TbVl4zG0SZKkXhhnePQlDEIbDALSPwQ+AxjaJEmSlsg4w6OvG51Pchzw3qm1aHE8e1SSJPXCwdwR\n",
       "4XHg1Ek35CBZaZMkSb0wzjFtN4zMHgacAWyYWosWx9AmSZJ6YZxj2n5jZHoX8MWqum9K7VksQ5sk\n",
       "SeqFcY5p27QE7ThYhjZJktQLC4a2JI+x56zRuaqqnjmdJi2KoU2SJPXCgqGtqo5ZyoYcJEObJEnq\n",
       "hXGOaQMgybcxEpCq6ktTadHiGNokSVIvHPCSH0nOTXIP8HfAR4EtwJ9PuV3jMrRJkqReGOc6bf8n\n",
       "8DLg7qo6lcEdET4x1VaNz9AmSZJ6YZzQtrOqvgoclmRFVd0M/MCU2zWuHcCq5On7okqSJHXSOMe0\n",
       "PZTkWOBjwLuTPAA8Nt1mjaeKStjJ4FZWT8y6PZIkSdMyTqXtPAa3rnoT8CHgXuCV4+4gyYoktw7v\n",
       "rJDk+CQbk9yd5MbmXqbDdS9Pck+Su5KcPeYuHCKVJEmdN05o+0XghKraWVV/WFW/U1VfW8Q+3gBs\n",
       "Zs813y4DNlbV6cBNzTxJzgAuZHCbrHOAq5OM0z5DmyRJ6rxxQtGxwI1JPp7kdUlWj7vxJGuAnwL+\n",
       "AJ4+7uxcYH0zvR44v5k+D7i2CYdbGFT0zhxjN4Y2SZLUeQcMbVV1ZVW9APgl4ETgL5LcNOb2fxP4\n",
       "VWD3yLLVVbW9md4ODEPgScDWkfW2AiePsQ9DmyRJ6rxxKm1DDwDbgK8Bzz3Qykl+Gnigqm6F+c/u\n",
       "rKpi4VtlcYDnhp5gcCKCJElSZx3w7NEklwIXAN8G/DHwv1XV5jG2/YPAuUl+ikEl7JlJrgG2Jzmh\n",
       "qrYlOZFBGAS4H1g78vo1zbL52nTlnrkbDoefttImSZJmLsk6YN1Utj0odu13578OvLeqbjvonSQ/\n",
       "Cry5ql6Z5O3A16rqPya5DDiuqi5rTkR4D4Pj2E4GPgJ8Z81pYJKqquyZ56PAr1Xx0YNtnyRJ0jTM\n",
       "zS2H4oCVtqq6fBI7Ys9Q51XAhiSXMLgl1gXNfjYn2cDgTNNdwKVzA9sCPKZNkiR13gErbcvNPJW2\n",
       "PwHeWcWfzLBZkiRJ+5hkpW0xJyIsV1baJElS5x0wtCU5JsmKZvq7kpyb5PDpN21shjZJktR541Ta\n",
       "/gI4IsnJwIeB1wB/OM1GLZKhTZIkdd44oS1V9TjwM8DVVfUq4Lun26xFMbRJkqTOG+uYtiQvA/4F\n",
       "8KeLed0SMbRJkqTOGyd8vRG4HPhgVd2Z5HnAzdNt1qIY2iRJUueNc522j8LgwrVJDgMerKrXT7th\n",
       "i7CDwU3tJUmSOmucs0evTfLMJEcDdwCfT/KW6TdtbFbaJElS540zPHpGVT0CnA/8OXAKgzNIlwtD\n",
       "myRJ6rxxQtvK5rps5wM3VNVO9tySajkwtEmSpM4bJ7T9HoN7hB4D/EWSU4CHp9ekRTO0SZKkzlv0\n",
       "vUeTBFjZVNyW3Dz3Hv0Z4NVV/Mws2iNJkrSQJb33aJLjkvxmkk8n+TTwn4GjJrHzCbHSJkmSOm+c\n",
       "4dF3Ao8ArwIuAB4F3jXNRi2SoU2SJHXeAa/TBjyvqkaHHq9M8tlpNeggGNokSVLnjVNp+1aSlw9n\n",
       "kvww8Pj0mrRohjZJktR541TafhH4oyTPauYfAi6eXpMWzdAmSZI6b5zbWN0GfM8wtFXVw0neCCyX\n",
       "IdIngCNn3QhJkqRpGmd4FBiEtaoaXp/tV6bUnoPxOIY2SZLUcWOHtmXsWyyvS5BIkiRNXBdCm5U2\n",
       "SZLUeQse05bkMRa+x+iyqWxVsTOBhMOrmMldGiRJkqZtwdBWVccsZUMO0eMMguRyuieqJEnSxHRh\n",
       "eBQ8rk2SJHVcV0Kbx7VJkqRO61Jos9ImSZI6y9AmSZLUAl0JbR7TJkmSOq0roc1j2iRJUqd1KbRZ\n",
       "aZMkSZ1laJMkSWqBroS2b+HwqCRJ6rCuhDYrbZIkqdMMbZIkSS1gaJMkSWqBroQ2j2mTJEmd1pXQ\n",
       "ZqVNkiR1mqFNkiSpBQxtkiRJLdCV0OYxbZIkqdO6EtqstEmSpE4ztEmSJLVAl0Kbw6OSJKmzuhLa\n",
       "voWVNkmS1GFdCW0Oj0qSpE4ztEmSJLVAV0Kbl/yQJEmdNrXQluQZST6R5LYkm5P8erP8+CQbk9yd\n",
       "5MYkx4285vIk9yS5K8nZi9jdDmBVwopJvw9JkqTlIFU1vY0nR1XV40lWAh8H3gycC3y1qt6e5K3A\n",
       "s6vqsiRnAO8BXgKcDHwEOL2qds/ZZlVV9t0XjwEnVPHY1N6QJEnSIiyUWw7GVIdHq+rxZnIVsAJ4\n",
       "iEFoW98sXw+c30yfB1xbVTuragtwL3DmInbncW2SJKmzphrakhyW5DZgO3BzVd0JrK6q7c0q24HV\n",
       "zfRJwNaRl29lUHEbl8e1SZKkzlo5zY03Q5vfl+RZwIeT/Nic5yvJ/sZn530uyZUjs5uqahNW2iRJ\n",
       "0owlWQesm8a2pxrahqrq4SR/Cnw/sD3JCVW1LcmJwAPNavcDa0detqZZNt/2rpxnsaFNkiTNVFNI\n",
       "2jScT3LFpLY9zbNHnzM8MzTJkcBPALcC1wMXN6tdDFzXTF8PXJRkVZJTgdOAWxaxS29lJUmSOmua\n",
       "lbYTgfVJDmMQDq+pqpuS3ApsSHIJsAW4AKCqNifZAGwGdgGX1uJObX0cOHqSb0CSJGm5mOolP6Zh\n",
       "P5f8eD/w7io+MINmSZIk7aM1l/xYYt8Ejpl1IyRJkqahS6HtMQxtkiSpo7oU2r6Jx7RJkqSO6lJo\n",
       "s9ImSZI6q0uhzUqbJEnqrC6FNittkiSps7oU2qy0SZKkzupSaLPSJkmSOqtLoc1KmyRJ6qwuhTYr\n",
       "bZIkqbMMbZIkSS3QpdDm8KgkSeqsLoU2K22SJKmzuhTarLRJkqTO6lJoexw4MunUe5IkSQI6FNqq\n",
       "2A08ARw567ZIkiRNWmdCW8Pj2iRJUid1LbR5XJskSeqkroU2K22SJKmTuhbavomhTZIkdVDXQttj\n",
       "ODwqSZI6qIuh7dhZN0KSJGnSuhbaHsHQJkmSOsjQJkmS1AJdC22PAs+cdSMkSZImrWuh7REMbZIk\n",
       "qYMMbZIkSS1gaJMkSWqBroW2R/FEBEmS1EFdC21W2iRJUicZ2iRJklrA0CZJktQCXQttHtMmSZI6\n",
       "qWuhzUqbJEnqpK6Ftm8BqxIOn3VDJEmSJqlToa2KwvuPSpKkDupUaGs4RCpJkjqni6HNkxEkSVLn\n",
       "dDG0WWmTJEmdY2iTJElqAUObJElSC3QxtD2KoU2SJHVMF0Obl/yQJEmd09XQZqVNkiR1iqFNkiSp\n",
       "BQxtkiRJLdDF0ObFdSVJUudMNbQlWZvk5iR3Jrkjyeub5ccn2Zjk7iQ3Jjlu5DWXJ7knyV1Jzj6I\n",
       "3T4MHHfAtSRJklpk2pW2ncCbquoFwFnALyV5PnAZsLGqTgduauZJcgZwIXAGcA5wdZLFtvEh4NkT\n",
       "ar8kSdKyMNXQVlXbquq2Zvox4PPAycC5wPpmtfXA+c30ecC1VbWzqrYA9wJnLnK3hjZJktQ5S3ZM\n",
       "W5JTgBcBnwBWV9X25qntwOpm+iRg68jLtjIIeYthaJMkSZ2zcil2kuQY4P3AG6rq0SRPP1dVlaT2\n",
       "8/J9nkty5cjspqraNDL/DeC4hFTt+1pJkqRpSbIOWDeNbU89tCU5nEFgu6aqrmsWb09yQlVtS3Ii\n",
       "8ECz/H5g7cjL1zTL9lJVVy60vyp2JnyLwRmkj0zgLUiSJI2lKSRtGs4nuWJS25722aMB3gFsrqrf\n",
       "GnnqeuDiZvpi4LqR5RclWZXkVOA04JaD2LVDpJIkqVOmXWn7IeDVwOeS3Nosuxy4CtiQ5BJgC3AB\n",
       "QFVtTrIB2AzsAi6tqoMZ4hyGti8eWvMlSZKWhxxcJpqdJFVV2f86bAL+bRU3L02rJEmS9jVObhlX\n",
       "F++IAA6PSpKkjjG0SZIktYChTZIkqQUMbZIkSS3Q5dB2/KwbIUmSNCldDW1fx0qbJEnqkK6GNodH\n",
       "JUlSpxjaJEmSWsDQJkmS1AKGNkmSpBboamj7BnBcwkRuGyFJkjRrnQxtVewEvgUcO+u2SJIkTUIn\n",
       "Q1vj68Dfm3UjJEmSJqHLoe1BDG2SJKkjuhzavgo8d9aNkCRJmoSuh7bnzLoRkiRJk2BokyRJaoEu\n",
       "h7YHcXhUkiR1RJdDm5U2SZLUGYY2SZKkFjC0SZIktUCXQ5vHtEmSpM7ocmiz0iZJkjqjy6Ht68Cz\n",
       "E1bMuiGSJEmHqrOhrYpdwMPAs2fdFkmSpEPV2dDW8FZWkiSpE7oe2rYBJ8y6EZIkSYfK0CZJktQC\n",
       "hjZJkqQW6Hpo+wqGNkmS1AFdD21W2iRJUicY2iRJklrA0CZJktQCfQhtJ866EZIkSYeq66HtQQa3\n",
       "sjp81g2RJEk6FJ0ObVU8BXwN74ogSZJartOhreFxbZIkqfX6ENq8VpskSWq9PoQ2K22SJKn1DG2S\n",
       "JEkt0IfQ9hVgzawbIUmSdCj6ENq+BKyddSMkSZIOhaFNkiSpBfoS2r591o2QJEk6FH0IbV8DnpFw\n",
       "7KwbIkmSdLA6H9qqKOA+HCKVJEkt1vnQ1vC4NkmS1GpTDW1J3plke5LbR5Ydn2RjkruT3JjkuJHn\n",
       "Lk9yT5K7kpw9waZ4XJskSWq1aVfa3gWcM2fZZcDGqjoduKmZJ8kZwIXAGc1rrk4yqfYZ2iRJUqtN\n",
       "NbRV1ceAh+YsPhdY30yvB85vps8Drq2qnVW1BbgXOHNCTTG0SZKkVpvFMW2rq2p7M70dWN1MnwRs\n",
       "HVlvK3DyhPbpiQiSJKnVVs5y51VVSWp/q8y3MMmVI7ObqmrTAXZlpU2SJE1dknXAumlsexahbXuS\n",
       "E6pqW5ITgQea5fezdzVsTbNsH1V15SL3+SVgTcKKKp5abIMlSZLG0RSSNg3nk1wxqW3PYnj0euDi\n",
       "Zvpi4LqR5RclWZXkVOA04JZJ7LCKJxiEQ4dIJUlSK0210pbkWuBHgeckuQ/4NeAqYEOSS4AtwAUA\n",
       "VbU5yQZgM7ALuLSq9jd0ulj3MgiCWya4TUmSpCWRyeai6UtSVZXFv47fB26t4r9OoVmSJEn7ONjc\n",
       "Mp++3BEBBpW275x1IyRJkg6GoU2SJKkFDG2SJEkt0Kdj2o4GvgocXcXuybdMkiRpbx7TdhCq+CaD\n",
       "W2pN6i4LkiRJS6Y3oa1xD4PLfkiSJLVK30LbF4B/MOtGSJIkLVbfQtsdwAtn3QhJkqTF6ltoux1D\n",
       "myRJaqG+hbY7gO9OmMhZHJIkSUulV6GtigeBJ4A1s26LJEnSYvQqtDUcIpUkSa3Tx9B2B/Dds26E\n",
       "JEnSYvQxtFlpkyRJrdPH0HYb8OJZN0KSJGkxenPv0T2v53DgG8BJVTw8uZZJkiTtzXuPHoIqdgKf\n",
       "AV4y67ZIkiSNq3ehrfEJ4KWzboQkSdK4DG2SJEkt0OvQ5p0RJElSW/Q1tN0HPAV8x6wbIkmSNI5e\n",
       "hrYqCvgo8COzboskSdI4ehnaGpuAdTNugyRJ0lh6H9o8rk2SJLVBn0Pb3cDheFybJElqgd6Gtua4\n",
       "tj8H/vGs2yJJknQgvQ1tjeuBc2fdCEmSpAPp3b1H994WRwNfAb69im9MYpuSJElD3nt0Qqr4JoNL\n",
       "f5wz67ZIkiTtT69DW+M64FWzboQkSdL+9Hp4dLA9ngV8EfiOKr4+qe1KkiQ5PDpBVTwMfAi4cNZt\n",
       "kSRJWkjvQ1vjXcC/8kK7kiRpuTK0DWwEjgFeNuuGSJIkzcfQBlSxG/gvwJtm3RZJkqT59P5EhD3b\n",
       "5WjgXuAnq7ht0tuXJEn944kIU9Bcs+0q4N/Pui2SJElzGdr29nvA9yb84KwbIkmSNMrQNqKKJ4DL\n",
       "gN9LOGLW7ZEkSRoytO3rWuBvgX8z64ZIkiQNeSLCvPvgROA24J9W8fFp7kuSJHWXJyJMWRVfAf4l\n",
       "sCHhebNujyRJkqFtAVV8GPi3wEcSvn3W7ZEkSf22ctYNWM6q+L2EZwB/mfCqKv561m2SJEn9ZKXt\n",
       "AKr4beCXgOsT3pywYtZtkiRJ/WNoG0MV1wNnAT8FfCrhH3tzeUmStJQ8e3RR+ybAPwH+HbADuAb4\n",
       "4yrun0V7JEnS8tbps0eTnJPkriT3JHnrrNszqoqq4gPA9wD/Gvhe4PaEjyX8h4RXJnzbLNqWZN0s\n",
       "9rvc2S/7sk/mZ7/Mz36Zn/2yL/tk+pbViQhJVgD/D/AK4H7gk0mur6rPz7Zle6tiN/Ah4EPNiQrr\n",
       "gJcBrwOuSdgFfAn4IrC1+fky8CiDCt0O4MmRxyfnWbYDeLLZ1zjWAZsO+c11zzrsl7nWYZ/MZx32\n",
       "y3zWYb9hjQJtAAAMQ0lEQVTMZx32y1zrsE+malmFNuBM4N6q2gKQ5H8C5wHLKrSNam599aHmh4TD\n",
       "gOcApwBrgTXAycALgWOBI4BV+3nca1kTAIchbic8HeJq75+3PjPhtXOWM2d6Eoa393qyedzVtHVl\n",
       "M/1U08bRUvDo9A7g6GbdAM9oXrOD+T+PTzFo/+HNNM1rvtU87mLQLysYVI53N+uvGEy/5biE17Cn\n",
       "Hw5v9ju3f+aWrnePrHNEs+0nmL8vFyp7z7d8MetOatsFPM7gPRwGbzm++ayMPj/6OJw+jEF/rWDw\n",
       "3r/J4N9uBft8/p5+7VMj0xlp02KHBsZZf1LrAOyGNz8z4Z+zd5vnTh/sczD4nO5k8Jkdfe6wkeli\n",
       "z+/Q8HP5VPN4JIPP4uMM/l1WNs8N+/xAP8ew5/dlN3u3be53xvD35Cn41eMTXj3S5lGHOj9q7udw\n",
       "+BlcMfKeh30yHCXa2Uyv5Onf+af7b6HHY5vXPNU8rmLQL/N9D8Cef5853vqshJ8b4/2MO72SPX/E\n",
       "j34mmGd6vsfh9ub7WcHgfc7dJ+zpt5Xs2wfz/ZvM3cawbw+Dtz4n4V+y9+drf78fO0b2mTnbLA78\n",
       "XoftHv7san52A1dU8W46Zlkd05bkZ4F/VFW/0My/GnhpVf3yyDozO6ZtqTXH0K1k8EV9BHu+SOf5\n",
       "WfMm2PrbLPzLMZEmMfglgz1fACvZ85/RimZ+9D8C5kwfxaDiuJLBL9aO5nVHsOeLc9QwyO1q1guD\n",
       "AHFk87hyZFu7eDqYDL9E/v7r4Yu/y56+2Dmyj7n9M7r8sJHpHc32n7FAv8x9rwdavph1J7Htwxj0\n",
       "++7Bzym/DFt+k73D9Xwhuxj011MM3vsxDILbMHDP/TKGPf/+8/3RMNq/43zxLOU6K+B5b4K/+V0W\n",
       "/qNnf38QHeg5GPz+DsPWcPnuOY+HzfkZLoPBHypPMvi33MHg32UFe34vDvTzGHt+X4bbnBveho/D\n",
       "gLOi+bz8zkhfze3PQ50f3e/cx2GIPYbBex5+doZ/vA7/mBv+Rx329MlhCzw+2qw77N8n2fO5nTuy\n",
       "MVw294/fwNo3wn2/xfyf54X+aN3f9PAP4GE4HeczNfq4v3/7YVgf7mv0d3H4+l0jz+0vMM1t97Bf\n",
       "d8Pa18F9v8ve+1jovcDge3+034fLR6/SsNB7Hu77KfZ8Tw3D+wrgwSq+wTIwydyy3ELbPwXOOVBo\n",
       "m1X7JEmSFmtSoW25DY/ez2BIcWgtg+PBntaXKpskSdKo5Xb26KeA05KckmQVcCFw/YzbJEmSNHPL\n",
       "qtJWVbuSvA74MIMx6XcstzNHJUmSZmFZHdMmSZKk+S234dH9Ws4X3p2mJGuT3JzkziR3JHl9s/z4\n",
       "JBuT3J3kxiTHjbzm8qaf7kpy9uxaP31JViS5NckNzXzv+yXJcUnel+TzSTYneWnf+6V5j3cmuT3J\n",
       "e5Ic0cc+SfLOJNuT3D6ybNH9kOT7m768J8lvL/X7mLQF+uU/Nb9Dn03ygSTPGnmut/0y8tyvJNmd\n",
       "5PiRZZ3vl4X6JMkvN5+XO5L8x5Hlk+uTai7zv9x/GAyX3gucwuCU6NuA58+6XUv03k8Avq+ZPgb4\n",
       "AvB84O3AW5rlbwWuaqbPaPrn8Ka/7gUOm/X7mGL//B/Au4Hrm/ne9wuwHvj5Znol8Kw+90vzvv4W\n",
       "OKKZfy9wcR/7BHg58CLg9pFli+mH4QjNLcCZzfSfMTjzf+bvb8L98hPDf3fgKvtlr+VrGVyf9O+A\n",
       "4/vULwt8Vn4M2Agc3sw/dxp90qZK29MX3q2qncDwwrudV1Xbquq2ZvoxBhcbPhk4l8F/zjSP5zfT\n",
       "5wHXVtXOGlyo+F4G/dc5SdYAPwX8AXuuH9TrfmmqAS+vqnfC4FjRqnqYfvfLIwyu5XRUkpUMrnX2\n",
       "ZXrYJ1X1MeChOYsX0w8vTXIicGxV3dKs90cjr2ml+fqlqjZW1fAaYp9gcLF06Hm/NP5v4C1zlvWi\n",
       "Xxbok/8d+PUmn1BVDzbLJ9onbQptJwP3jcxvbZb1SpJTGCT8TwCrq2p789R2YHUzfRJ7Xyqly331\n",
       "m8CvsvdFMfveL6cCDyZ5V5LPJPnvSY6mx/1SVV8HfoPB7eW+DHyjqjbS4z6ZY7H9MHf5/XS7fwB+\n",
       "nkE1BHreL0nOA7ZW1efmPNXnfjkN+JEkf51kU5IfaJZPtE/aFNp6f8ZEkmOA9wNvqKpHR5+rQX11\n",
       "f33Uuf5L8tPAA1V1Kwvc+aGP/cJgOPTFwNVV9WIGdzG4bHSFvvVLkucBb2QwPHEScEwGF+9+Wt/6\n",
       "ZCFj9EPvJPnXwJNV9Z5Zt2XWkhwFvA24YnTxjJqznKwEnl1VZzEoJGyYxk7aFNoOeOHdLktyOIPA\n",
       "dk1VXdcs3p7khOb5E4EHmuVz+2pNs6xrfhA4N8nfAdcCP57kGuyXrQz+Cv5kM/8+BiFuW4/75QeA\n",
       "v6qqr1XVLuADwMvod5+MWszvzNZm+Zo5yzvZP0l+jsEhGP9iZHGf++V5DP74+Wzz3bsG+HSS1fS7\n",
       "X7Yy+F6h+e7dneQ5TLhP2hTaenvh3SQB3gFsrqrfGnnqegYHU9M8Xjey/KIkq5KcyqBsewsdU1Vv\n",
       "q6q1VXUqcBHwv6rqNdgv24D7kpzeLHoFcCdwA/3tl7uAs5Ic2fw+vQLYTL/7ZNSifmeaz9gjGZyV\n",
       "HOA1I6/pjCTnMKianFdVT4w81dt+qarbq2p1VZ3afPduBV7cDK/3tl8YvJ8fB2i+e1dV1VeZdJ/M\n",
       "+iyMxfwAP8ngzMl7gctn3Z4lfN8/zOCYrduAW5ufc4DjgY8AdwM3AseNvOZtTT/dBfyjWb+HJeij\n",
       "H2XP2aO97xfge4FPAp9l8Nffs/reLwwOmr4TuJ3BwfaH97FPGFSlv8zgRun3Aa89mH4Avr/py3uB\n",
       "35n1+5pCv/w8cA/wxZHv3at73C87hp+XOc//Lc3Zo33pl/n6pPk+uaZ5j58G1k2jT7y4riRJUgu0\n",
       "aXhUkiSptwxtkiRJLWBokyRJagFDmyRJUgsY2iRJklrA0CZJktQChjZJU5fksebx7yf5ZxPe9tvm\n",
       "zP/lJLc/aUl+LsnvzrodktrH0CZpKQwvCHkq8M8X88IkKw+wyuV77ajqhxaz/Rk4pItjJvF7W+op\n",
       "f/klLaWrgJcnuTXJG5IcluQ/JbklyWeT/CuAJOuSfCzJnwB3NMuuS/KpJHck+YVm2VXAkc32rmmW\n",
       "Dat6abZ9e5LPJblgZNubkvxxks8n+R/zNbRZ56okn0jyhSQ/3Czfq1KW5P9N8iPDfSd5e9PGjUnO\n",
       "SvLRJH+T5JUjm1+b5OYkdyf5tZFtvbrZ361J/tswoDXb/c9JbgPOmsi/hKTWOdBfsJI0SW8F3lxV\n",
       "rwRoQto3qurMJEcAH09yY7Pui4AXVNUXm/nXVtVDSY4Ebknyvqq6LMkvVdWLRvYxrGT9DIPbeX0P\n",
       "8Fzgk0n+onnu+4AzgK8Af5nkh6pq7rBqASuq6qVJfhK4AviJed7TaOXsKOCmqnpLkg8A/47B/Qhf\n",
       "wODWWTcAAc5sln2radefAo8DFwA/WFVPJbmawU3Kr2m2+9dV9eb99K2kjjO0SVpKmTN/NvDCJD/b\n",
       "zD8T+E5gF4ObKn9xZN03JDm/mV7LgW/i/sPAe2pwr74HknwUeAnwSLPtLwM01atTgPmOhftA8/iZ\n",
       "Zp0DebKqPtxM3w480QSwO+a8/saqeqjZ/weatj7F4F6EnxrcP5ojgW3N+k8B7x9j/5I6zNAmadZe\n",
       "V1UbRxckWQd8c878PwTOqqonktwMPOMA2y32DYnDqtiOkWVPsfB34Y551tnF3oeWjLZj58j0bgY3\n",
       "H6eqdu/n2LyMtGt9Vb1tnnWeKG8ULfWex7RJWkqPAseOzH8YuHQYaJKcnuSoeV73TOChJrD9A/Y+\n",
       "rmvnAoHoY8CFzXFzzwV+hEFlbm6QW6wtwPc1x8ytZTDUuVg/keTZzVDvecDHgZuAn23aSpLjk3z7\n",
       "IbZVUodYaZO0FIZVos8CTzVDku8CfofBsOFnMhgTfAD4J836o5WlDwG/mGQz8AXg/xt57veBzyX5\n",
       "dFW9Zvi6qvpgkpc1+yzgV6vqgSTPZ98zOMepYg23+/EkfwdsBj4PfHo/26l5potBeHw/sAa4pqo+\n",
       "A5Dk3wA3Nicg7AQuBb40ZvskdVysuEuSJC1/Do9KkiS1gKFNkiSpBQxtkiRJLWBokyRJagFDmyRJ\n",
       "UgsY2iRJklrA0CZJktQC/z9O9iqjWzY/9QAAAABJRU5ErkJggg==\n"
      ],
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10ab0fa58>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# A useful debugging strategy is to plot the loss as a function of\n",
    "# iteration number:\n",
    "plt.plot(loss_hist)\n",
    "plt.xlabel('Iteration number')\n",
    "plt.ylabel('Loss value')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training accuracy: 32.312%\n",
      "validation accuracy: 34.700%\n"
     ]
    }
   ],
   "source": [
    "y_train_pred = softmax.predict(X_train)\n",
    "print('training accuracy: {:.3%}'.format(np.mean(y_train == y_train_pred)))\n",
    "y_val_pred = softmax.predict(X_val)\n",
    "print('validation accuracy: {:.3%}'.format(np.mean(y_val == y_val_pred)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.341000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best svm on test set\n",
    "y_test_pred = softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": [
       "iVBORw0KGgoAAAANSUhEUgAAAkwAAAF/CAYAAAC7YpZdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n",
       "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvXvQbflZ1/k867Iv73vO6XQSRBIgjiACch2RS3GRAQvB\n",
       "CYhQOIATCChTFFEGKbmIgJEoQUFGBWZGHSgobkEucrGUYka8gMgoIEMhF4OQpEMShATSfc777r1u\n",
       "v/lj735/n2dl7bPe0713n+4+309VV6+z37X3Xmv9Lmvt5/v7Po+nlEwIIYQQQhymuN8HIIQQQgjx\n",
       "dEcPTEIIIYQQM+iBSQghhBBiBj0wCSGEEELMoAcmIYQQQogZ9MAkhBBCCDHDA/nA5O4f6e6P3O/j\n",
       "EEJk3P017v7RE69/uLv/yjE+SwjxxHH3b3X3V9zv47hfPJAPTEKIpyVp/198MaWfSCm9+zE+Szwz\n",
       "2D/wftT9Pg7xNjzQ40oPTEKYmbtX9/sYxL2jdnvWkszM7/dBiEmO2i7uXh7z807Js/qBaf8r5Uvd\n",
       "/T+7+1vc/VvcfTmx35e6+6+5+6P7fT8Rf3upu/+ku3/t/jN+3d0/Fn9/yN2/2d3f4O6vd/dXuPuz\n",
       "+ro+HXH3d3L3H3D3/+buv+Pu3+Duf9Ddf3z/79929+9w94fwnte4+xe7+y+Y2WNqt6cFHzger2MJ\n",
       "faLdSnd/ibu/dt/WX3Yfj1+MuNex6e7fbmbvbGY/4u6Puftfub9n8ODi7u/v7j+3vze+ysxW+NuL\n",
       "3f3n3f133f3fuft7428vcPfv37f5r7v7X8LfXu7u3+fu3+7ubzWzz3xqz+qJ8yDcID7dzD7GzN7F\n",
       "zN7NzL7c3jak+Gtm9mEppVtm9jfM7Dvc/e3x9w80s18xs+eZ2d8xs2/G377VzJr957///rv+wtHP\n",
       "Qhxk/wvln5nZb5jZi8zshWb2Ktv9EvpbZvYOZvYeZvZOZvby0ds/1cw+zsyek1IanqJDFtO4XW+8\n",
       "mqHdzOwPm9n/bmZ/zsxeYLtx+o5PwfGKGZ7I2EwpvcTMXmdmL04p3Uwpfd1Tf+TC3Rdm9oNm9m1m\n",
       "9rCZfa+ZfbKZJXd/f9vdBz/HzJ5rZv/QzH7Y3ev9D88fMbP/ZLvx+NFm9gXu/jH4+E8ws+9NKT1k\n",
       "Zt/1FJ3Skyel9Kz9z3aD9H/Bvz/Odg9Hf9zMHrnL+/6TmX3CfvulZvZq/O3MzAYz+31m9vZmtjGz\n",
       "Ff7+aWb24/f73B+k/8zsQ8zsv5lZMbPfJ5rZz436x0vv9/Hrv9Aes+N13G5m9pVm9l3495mZbc3s\n",
       "o+73OT3o/z3Jsan2u79t9xFm9puj1/6dmb3Cdj9Qvmr0t1/Zv+eDzOy1o7/9VTP7lv32y83sX9/v\n",
       "83si/z0I+j/dcK+z3RNvwN0/w8z+spn9gf1LN2z3K/Vx3vT4Rkrpwt0f3+f5Zlab2Rv3r5ntonav\n",
       "O86hi2vyTrYboCFCtI8S/n0z+zAzu2m7tnnL6L1ySz69mB2vE/u9g5m9/vF/7Mfom09wbOLeeTJj\n",
       "U9xfXmBmvzl67bX7/7/IzD6TUpvt7oXvYLuI8Avc/Xfxt9LM/i3+/Xp7BvIgSHLvPNp+A//o7i8y\n",
       "s39kZi8zs+emlB42s1+06y1se8R2v2Sfl1J6eP/fQyml9557ozgqj5jZO08sHvxqM+vN7L3SLvT7\n",
       "EnvbPv/AOj6eptx1vAK22xttd2M2MzN3P7P4g0fcP57o2NS4vP+80XYSKnnR/v+PmNnfwn3v4ZTS\n",
       "jZTS99juh85vjP52K6X04v17n7FOu2f7A5Ob2ee5+wvd/blm9tdsp5+Tc9s13u+YWeHun2Vm73Wd\n",
       "D08pvdHMfszMvt7db7p74e7v4u4fcbxTENfg/7Xd4P4adz9z95W7f6jtooB3zOxRd3+hmX3R/TxI\n",
       "MYub2ctmxusU32dmL3b3D92vu/gqe/bPbc8UnujY/C3brWMT94+fMrPO3T9/vzbpk8zsj9nufvmP\n",
       "zexz3f0Dfce5u/+P7n7DzP6D7cwYX+zu670p473c/QP2n/uMdT8+2yeVZLsFZT9mZv/VzF5tZn/T\n",
       "dg2WzMxSSr9kZn/XzP697aS39zKznxx9xvhpmP/+DDNbmNkv2S6k/L1m9vuPfB7iLuzD/R9vZu9q\n",
       "u183j5jZp9huAf9/b2Zvtd0ixO+3Z+gvmweEZGbfaXcZr5Nv2o3hl9lurL/BduNQUuvTgCcxNl9p\n",
       "Zl++d2B94VN60MLMzFJKrZl9ku3W8b7ZzP6s7drJUko/a7sF399ou/H2atvdCx9v8xeb2fuZ2a+b\n",
       "2W/bTsW59fhH2zN0Hvb9IqxnJe7+G2b251NKP36/j0UIIYQQz1ye7REmIYQQQognjR6YhBBCCCFm\n",
       "eFZLckIIIYQQx0ARJiGEEEKIGU6WuPKlL//Jq9BVP+ScZQO2yyqn5kh0GiaffH1A7rOua8P38TtI\n",
       "SOyBaJpjkT6STtow9JOvF2WF1/mp2Kdw7JM/vziw/zCqxMH38PgO+QlweOE7iiJf12/5yg89ioXz\n",
       "a7/4y66OYrHI16Is88d3bTf53qJeXG0vlnV+L04ghX6R96mX+b3b7Rb7oO/g+nRNPoYBfxhG15CX\n",
       "vuvyH1f4vuWC3zFgO7/3UPk59tsefaoq82d2be7DbdvkY8W16HHgX/CKrzxKW/6Vr/gf0NF4YdiX\n",
       "83kldEAeG9ub46brYz9w9EdeL8c4d4wv9t8Sx7GoMQY51rDdYF7ocE37Ph9f3+XtlHisuLzjduVg\n",
       "47jDd4cxyPcO7Id5+xu+5qeO0p6v+PjcnoswT+V92AYF+iCGry3L6XPpMFb6nvMS5kq8t8X1rao8\n",
       "nobQBrjuI5WjRxuGNscJOe8FeH+Lg60x7yxX66vtEtci4TPbNt5THqco83zUYJ9Nk+ejL/uhHz1K\n",
       "W/6JT37Pq5M5W+djXizyuRT8JrRTyA3KtueYQzos9l2O34KdAvMDxxA7V+GcJ0dt2efrFeYU7NZi\n",
       "HmHf5GkO/fQzRN9Pz/dFuLckbOMaHbhv/Ng//eWDbakIkxBCCCHEDKcrjYKn3QLbjKKEB9kQ5cGj\n",
       "H56CU+KDX0wcW3mNf/FXEI6Dv1C4D5+ip4Mk8bGev27xHFwV07+Ai/i4j6OMT+PhFwK2B/xiC0/d\n",
       "jIYh4lKWx29W/CgL0R3+aijx/M1fI2WZX1/yl1K4joRtzmvEqGB+lZG6GIWc/kVkZuYJ54BfYIw+\n",
       "9OgXS0TG+Ku0CVEW/MLBr1L+0mXUo8Uv6XSgPybDORyJspqOQoRYE67JcGAMGX/1ob0ZzTAzWy6v\n",
       "CpyH6KHb9C/fCvuwf3GbvywZDOIsUIRDxTVdYD46ELUeRyT569UY9UJ/LovQKfPmEMKZdmzW65tX\n",
       "29WBKAz7bIlf8RXGZunTv9D7Bn0wTUccakat8JmMMKWC9wFEG/rYxwubjioy+sAoVI8xxfemxP6C\n",
       "zw8RTFwvdp4wXyDahj5fV0s7Nut1vl4rbHNOZ4SMx9kj4sf+7n7gvZbPpWJ0sc77hLk1RJWm1Zex\n",
       "HFLju/lZjCrx+DiYGY2vD0SnOkYte45r9lP0Fd5L04FnjrugCJMQQgghxAx6YBJCCCGEmOFkktyW\n",
       "oeewkBqhQoRDK4Re4+I1Lu68y/Nd0Ba4yCu/3PEfA8PADJ9DMiwpB0zLakF+oDxVTi9WPCw3mXU9\n",
       "Fql2XOSG80nTMkhiWLM8fqoILvBlWJdtSNmiw/XtG0gDCP3WFRePI/SO720hZ7QIuV60l/nzca22\n",
       "WLzH7WIkE/HfXPdcon226JMr7MNF7y3aJoSZ++nFhX2X25gSUOhrOKDxAupjsFhOSwn8Ll6fYJwI\n",
       "5gpIakbJJ04rXHBLqTIsMg+SXH5/FaTN/HqD6xjME8FgkvvgwCEI6aJrNvkzsYjXiyjhDpTe6xrb\n",
       "+ZhCuJ+SHMZpk+LnHoOyzNJNlMamF+9y2qHsUUCi4aLssGC8oKxi2B9yCNqPi8S5cDesPhgtr+D8\n",
       "2uFzi2BKgFxT5/4clnxACueSBTYBlxeUNi37UCYqB45NOzqLBfpWOT0m/MD8WwxopyDJQWIbpvvB\n",
       "cpWvYVFSgqR0lvfnMgbH/uMqcUHK5nMA5wu+3SnH4lrwQ3EgVZruXx6+N/eDZpvnDS4JsGuOS0WY\n",
       "hBBCCCFm0AOTEEIIIcQMp3PJhdwPCJUZw7JwGPUHwq0Lhh/xfDdKmRFcAeEwEF5Evp2QAYkr/hGi\n",
       "DeHRis6B6XwtDFPW1SjMvCeu8B+55A7ICSEPTkgCxFw5977i/16gK6lppx0xMc8GpC2cZ7fJDbde\n",
       "MoSMPoL2H3COLbrrZkvnQ/58qHC26Q7LnwVky7pCGLhk6D5/X7dBbhnE4oNzi+FuOuCmTZ+hn7Lt\n",
       "E507J0jET1fLdBYmG+V3wcuUMOBCMozTuqLsZlYU/Pf0eKY0UlFiqqclCvaLjvIRZChObgPyLW23\n",
       "Wc6lk4oOvnFWtzLIUgzlc/zTOYTxCKmd33csgkpaoy9Tej3ghuQ/KMkZZJwFxinz1Ww2WcK8wLiu\n",
       "Fwfy+NDZhjaja2/8N8rTtp3ObbfiPA3XYk0HI8Z4x3sF5q8owzJfGK6pcX44gYOVEmnUqrCN/XFe\n",
       "VbgH5H166NG8/5Zwddfh/oa5Dt/LcV3hmh+8P1kcR/1ABxxPh+2Pa82duDQhpCjE/Mu8YJTqcF0w\n",
       "nQSXXF9P53EcowiTEEIIIcQMemASQgghhJjhZJJcWNUfMrZTqrPJbTtQIoTbdT2SvOhKYgJBvCcm\n",
       "vptORBnVNpZuQDiRciPT7FNWQcLB8kDSrWFUSiS4A3HcMcjJsD/jmnRCHN+JE6ShkDCTshf2P+Cg\n",
       "GpAwckCaQZoW6YxJOMdtm7/gokWIvWVZDkh4+Mx+FHEt8e8L7Hi+RqI1SkZ030ACpBMpwaUy0N3D\n",
       "yDrLcsBm5JCMBrR4fwKXXGJ5BFzfJV1FOOb+gLtpwMAeGiR99LEcPZ1UlW6zIHOFxHxIoBlKMNjk\n",
       "/pTOKedsNneutpvgpIS8Wh2QQyzOBSzDRFdWOFZMJPVihdeP/xuV7Rm2OTcFByQSya5XeB3uNDgG\n",
       "mTiXrkBerwZli1hKJcqXeXMLt9JYDEkHSglRihq6aUfjGo45JmjlNvWq4Npkpw/luaa5m2n7iRJL\n",
       "/uTXeyxfqavcZhXGLA+H7sQSSwt6Onk5z4RlHHmb9/El3ME1Evl2oSzSqDVxEmzzDm2wWNChh/kh\n",
       "JE+dTphrkBUpj4dEukzIOt2dbIGSWHdDESYhhBBCiBn0wCSEEEIIMcPJJDkmJUwd5aXpBHAh7Em1\n",
       "jCFZJrocJcfzkECQcth0VXP6dvogf03XoRuCfDhdiygca3AOIIEeJblxLTmGnENFZoQUUZspVp6m\n",
       "1Hl8SS4k5QsVvvM+PM8CoeLBGJbN+2z7i/w5kHQaSkDoRxskwKTctoEc0Ce2B+SDUeLKBRN9UpKF\n",
       "s65BqLkMcjBC05RIQ/0w7I/v9eCkQx2zNp8D+0E6hSSH9giSRIFQfHDo5GOgI5FOyERpqojh7aKa\n",
       "duXxs0q6YVl/igkOQzm3/B1r1Kpj1+/anJSyQ0i/ycqA9QPOn3LxWMI9kLQvcdyFuQNzFdxF/Qnk\n",
       "8lB7jw5I1soKiQJRk43LCDCfdIljPLd/6jkG8+tMcDjQqorvZVLCBhNHe5elCXSN1ZBNWGPOa45l\n",
       "OuDYaHQws54ljqmh9RrXi67PcB84wTxL5xaTKBecyxjnyPvTFVkE91je5zJlhygTtcZlJtMJmCt8\n",
       "/gAhNSSMHJ1PdGTSrXcg6W2QRTkfYc7FchzOZVXFupDsm5CaW64PYh3U66EIkxBCCCHEDHpgEkII\n",
       "IYSY4SlxycXEVnQPTS9Zp3RWMvR6UP6Ksk9R5HAcj4Pf0SOkWNPFRqcLwsw8h1CLqWBIEMcU6lXB\n",
       "QbKFW2XsxEFgsEOStkOh3z4kupyuS3YsOrq7KEPhutNVhsh4qLe2Qfid7ps7SIIHpcYcidk2DVxy\n",
       "CLM2HfoIQ8h04XVR/lwVObzM8G1/Ox/HEiH9Ja7pCknOlkx6SRUL7ZHgJFwW0zIJXY503g1vE+R+\n",
       "8tDdROWJddtKJKbrIcnR8tqHWm2UhKMk1yaGxPN1oYN16JnQdFp+oIR9dp7r0y2XeXsLN9x2g2Sr\n",
       "6Dtu+fiWaDSe8zD2bjmdYtN1/wo4Ywublk3GY/4YUJKjBkKJiX2KJqMOLsGOTk3Mfe0GNS7Rfg3G\n",
       "Mp1S/N4+WubyZ7ZMJAqN1CzMnUvIrQMTS5Z5/LaUbuiswu5VTfdkvl4tk2kmuh85lzPxIWSp4fhy\n",
       "OZNtcpxSzqQEyXp5BfpByeOHY2yFmnFVxbll2pUd6sfhft0dWH5gd5Ep65oJafEWymq8h/DNIUH0\n",
       "9Py4YOJZ2nnREfxAjdd+7O47gCJMQgghhBAz6IFJCCGEEGKGk0lyrANDBw1revUH5DkmkaIkUwTD\n",
       "XAz9dfjczhhazfuw7o6H756W5PiZfsCFxmRvJV5PdDjguBcI5w9VPIeCDq9EyYgJxqbrxzECOb42\n",
       "x4AJOqsQNkZStFDkiDXW8ssDrxGcTrwWfZDz8ufcYbJJuI2GMoftt6gx110g1D9KGHh2RscGJKom\n",
       "77euISXh/RvIEkuczxntcE12AHZo84TkbwY5oEI/WiB03RfHD/uT4CSEe4gJ4Zg8lP19wRqRBSTb\n",
       "FPsfw+OJiT6N447OOA50Sikcg0iaiDpmPV2b+BxHPbtgDIQ2wCSO2za7iczMBshtsf4YE+NiTuHc\n",
       "wdplxfVC//cCk8EmyFl2IDFhCSmJ4zcmIGRyz+w2ZIJSD0stsB1kMZ/ehzU+PY5NypzsCj363m0c\n",
       "R7rNNRLoz3QAQnavQr3I6eNgLTJn3TsmAz2BXH5+80b+B+dK7MP6iutVlqO5VoT30xXup1x+cIEu\n",
       "noIjDe519idcH0qlCxwPkwibRbmOjmceK29XZzgfJoJmwk0eK12bTJ4a3J+U+TCvBUHSrzfPKsIk\n",
       "hBBCCDGDHpiEEEIIIWY4mSTHJ7FQpcYPvI7QH+tnVSERW95/nP+NklFZUz5CiBavO8LYdIAdSsZW\n",
       "QTJgyJLOnQpyAyWDhPpmQ8mEhqOTQDSzgtwRpEGERWuu+A8uweOHihdwEK0oycGx0UO2YukfXlPW\n",
       "0urh3qDs2KT8mRdIJHmBNruDUO8lnD5NT6kGiSfpYDSzvs/nwzpuVYIshfYoIOcmhJ3ptizRKb2l\n",
       "BJL3X6PvLKosu67QN5erfP5MLncs6KZZwDXjlN7oNqSzL0Tcp5MEMuxvFqWRIWWZlOF0Sgh0T24h\n",
       "f1aQDBvLMlFLzZdyEPrUAKdMgkuqXJ3nt9KVlKJ0FkpXFpT8++nXOS9w3rqmG+decCY1DImBmTyW\n",
       "x4DxGJxkkG6YtJd19CBBtnDAtUxOy/eO3Mz5e9F3lnX8G9qtw32h5hiEbn+J/rLA2KywT8J8umRd\n",
       "yILzF2RXHA+TKVKOP4FJzhZrjEeMiSAfUeKmLB6ShEI6Z9LHcD+dTrTKzkK5N0h+TPWIsV+Mlj4w\n",
       "iXRDuY7LWkKy2UO17iC9hfmF2WzZrnS7T+4dahbaNe+ZijAJIYQQQsygByYhhBBCiBlOJsl1DD1D\n",
       "eqHTjXXYGHJjXa0CIceE+DHdLWYxyZfRlWdMzDbthtsitsoQMCWKEJZmYI/HjRB1qMXF8CA+n8nk\n",
       "zMxKhqLxuUVPSSPvzxAs6/x4cfzn4BrXomIiPiZIY9LPlrJFDvXTWXLnIssqF5CwNgj9bpFk8A4c\n",
       "UBdMegnZru3odMlOjq4bSQNwiFQ4hwVzSWL3YotEp4lZ15BM8zJ/6Hk1PbQGHKsHNwokSdTbG9fZ\n",
       "OgYlxw7r6DExLBP94Zq2uO7B8ci+nMb9D6H8clqSpfTIZIcDJJCyQHLTFToDJhUmSaXbssE/BkoI\n",
       "HFuUahZ5PJmZ1ah11w1MtAgJgfJcmpYW2F+OBRMCVnTt0YVLWWmTHZz8yUzHXNEfmPsg6VziHDeY\n",
       "7ikiM8Ew55DUcx4cJfBF4lIa6Aq4vSiTcR7kcSxYgxNOVdxSwrKIVEx/b5Ae0V/6aAg7CnQS1rgu\n",
       "vEZ0YCebluQKyna8l+Bzzld5fqQkt4XrlPN1j/buw7w0PV7NzEqfdi3y3lrxoSAUceQ9hE5TyuvT\n",
       "yTeHNL1/VUKmRgN6MS0dj1GESQghhBBiBj0wCSGEEELMcDJJzhFOC7JaB5cMw309w3UIP7JuE0Om\n",
       "ozAu3Up0O4RaZ8YkbZDS8N4UJEPWr8mvMzzIEPsWibMSXGWsY7Rk+HKTJSkzs77N18YhE9KxUyHs\n",
       "WIaabkzwd73w4r0whLpR/APbKicdo7tiQGi8hdxUWt7/fI1kpfhMynkb1Gdbo/npitxCPuI1KatY\n",
       "3ywkr0MCyRUu3RISS9HntlovznAcuBgIA6+XqDFn0+FxuifpdhlYo60/voTDEDU7NsPkPeu/0eXG\n",
       "eozcDrJ7nFZoxkGE3pgrrkXCUcp+ofYiruOG/QhyfBAEUPerqNn+cNzAMcaEgKy5tfsbE44ycS0k\n",
       "B0gW3KfnnDdK6nkMmJhvCIk0p+vwFcE9R0ciau9BbmpwzBvKqPj8Hg62jp2E9dno5IUzrkyxj5cV\n",
       "ry+24c6t0FZ0JFPRaSBd1TgHugoHvE4XF/sCl0F01OH8+PEGSo2U4SilDYnJQ21yO9RppWyMTKAV\n",
       "votLYlrU9otLaPBdB65JexnvaRUSxjr6BR2ybaj9GgpyXm0OB54V2HNKyOaUGMM+uFewbl9fKnGl\n",
       "EEIIIcRR0AOTEEIIIcQMJ5PkQhJHhGW7LofsQoJFulgSw2/YhaG4JoZxGyahYiKsBkna8GGh7hni\n",
       "izxuJqILSRYRrw4SC2S0FeSN87MsPTkyOl42MXzZITw+IIxf4rk2VIpi2HFAmPkEteRYQ6mumOAO\n",
       "oXjIEDWSA1I+oyRTnaNu0jJvPwa5ZYM3oNSXtQanFxIxNqEbwP1WR4mFIetuk6VUJrEsIQHWkORW\n",
       "kD0WCI/X+I4bS0ikA3xDXd6uoEk5xgUdWdUySonHgH2fMgnD56GWHOrE0W1EuYwqbTW61gPaoYfD\n",
       "jK4bJi6982h2cfWoGUaJlZIArxFlG2fb0DkaZH7KWcziGGXtAi7UBdqnxLWhjN6xTldwBx3fWjUc\n",
       "SFg40D3Y8rrn98LMahtc6wbn0uNz6JKj+7fH/mXJ60N3F+RVSCPdSJKj1BvkRsiiA+uXMXEl3I09\n",
       "k2mifyUmOIQsdQf9eYVbY0huyXtFEZ3ax6DGXMZ5tmQ9St6jcE1TkO9xX6Lzm85WdMUWzrgWS0Wa\n",
       "Nm9XGBO4hJYwjtMom2fH5Ti4ppQAw3oXzJsd5l8uFzBIsFyKMxxw0bOWI/tsSIQ9SlR7CEWYhBBC\n",
       "CCFm0AOTEEIIIcQMJ5PkRlVb8hZCXwy3D0xWFxLLTdfwSn1MkMWkew1D4EjA5lV+/2WDGmBwZSwZ\n",
       "rueie0h+3SbH2zsc09k6S28dnFcdwuFVx/BlDM8PDFnDLbCg/IRwJN0uCeHhdAL3xpK1xZgQEAkH\n",
       "+b10Lp1Z1tJu3sjSW7W8dbV9ifpxJcPGdX7v87Hdow4ba6Ml/AY45IYxM2taJmHDOaB9KsRslxBD\n",
       "F3TGXd7O+3hu85trdJ4mS0ybR9+C772T92GEOjhG7ejQVeTOa5T3CbIKpDBG3B11EenMbEe/wzaQ\n",
       "Qy7u5BD/cNFgO7fB770V1+s2rhHao0R/XJ1l1+LqRq4NV9D1hHOjy5H14yhDjoWzy46SE51oGI+Y\n",
       "g8pl7qt0OJ1ALbc+HWgHLm1grT7KdpibO9bho4MKCVZ9CfmP8xf6LOX79QqSMp2/lEZGyVlDskp8\n",
       "VkJiTTrg2uCawhyKNuDdor2ELI47YI/zb7AEY3EgOe8JygJaBXd1CQky5HbkXBYcgqzN2U++PmAZ\n",
       "QMISiu1lHoubO3lOu7jI28F5hpNfQF5dLeMjxZC22EatUdzviwXfk+f1kCAW90PKbRW/j4la6TA8\n",
       "cDukJFcqcaUQQgghxHHQA5MQQgghxAwnk+RahLBDDRnKLQzRIghecjU9JR/Ia8UiOhQqSDQXkPoc\n",
       "+lGNzy2QLIshyx4WjVDWJiSrxLnBJXOJ8GVzmaWE/jJLDCtICX0bXXIDXAEFE9AxCSjeTymRueK6\n",
       "4fixYsqHTCwYk/gxqWZ+Fl8vs1RZ13DGeW6zqszbZ6u8f7HO+w/Yp4c8Vy6wjRg7ay41XZRwLxsk\n",
       "E0TyQmeNK/Rho2MDn+WL/B1n0H1uIANmAbfLEm3Dkl4t5ek296PCj++qYrJFunJSSAY7LduEIQHJ\n",
       "gLLdYxestWb2GGoG3rkNOfuxPEbaR/N2g/dfYpvSNp0/KyTLu4E2W50jkSoj9x3mDsgElDq2fdTO\n",
       "UmLSVLr+ppPYBqkOEkLRHX/K9QKJKKdXQphzvKCZO7hxHRrFsM3XNJUHZA8kmK2pNVKaRAJQzvc8\n",
       "zmpUt48ST3GgblgL93PUVjC/op93dJBBTir6fH+pWTOPfYHfBSnJR+6+Y+B0l/OSHqj5yCUIrB9X\n",
       "0vXFFQRwwF0+hrGIc2zhGu6QxLLZUM6DDEqXahOlLbrP6HjkPWTpeZzSAVhg6UOB+ajmspmaki3G\n",
       "JZ8zeL9iDcJwHa+nlSvCJIQQQggxgx6YhBBCCCFmOKFLLsOaOBUdOizDhYyDTMTWITTcsVbTNh56\n",
       "0eeQMxM6tj3lAcgtCJ/3kFsuUA+uwnGXBUOClPbg1oB82CDE2TAZIuvXbJHdzsz6LZP0ZZiAscJn\n",
       "FXDr9DxPP36zNpBDBiTfxOWyAbrHzVtIwLbOzqWzxc2r7RK15/oih+UHbHud37uFk87K/N5ymV1P\n",
       "CzhjHGH4OxdwW1kMX4e8ZgeuHV0hrPmX4AAb4NzctkyamD+nKiCNGF0/rAVIV+Txw/5VRVl32nXZ\n",
       "hXGKcceQOR1DqB24WMWwfHUxnaByCxmSTi8YWEMi0pZyCGVCJh4ts85Jx9GaDjBKtZDzCujaXRX7\n",
       "wXKR/8bPpWTqIfkd3WT51eO3ptnAepk4N8oVLRPscn7EOV9gzrqEFFMtppdCsC4oZV5K3JR5E+vu\n",
       "oe/UI0mOkiGXArCPMEljh8/i51aQRUu4iFvM90xIXJeQluiwhduywj5puJ6Mcy94qO1IuyBkTki8\n",
       "l1juQedFQrbbAAAgAElEQVS427S0RymMy2bYdwu6UYN7Fy51ZDz1sLwlOh6L4G6bjs8UwZl86N6V\n",
       "v6/GZ1YHkpkyOW8ZZF0cA52WxfVGpiJMQgghhBAz6IFJCCGEEGKGk0lylC0KJPRLSCG2hYTF/Snh\n",
       "MdlZx9prfQz7J9TrYsKyCvHI7jJLYBXcHluENRvIZAuG3hFML86zTESJkTXTOsQyU5s/85LOuGYU\n",
       "vkQYsYBUUgb3DRPEISxNueJQpq4nQb3IEti2owODzjjIapTtbkNqRDutziG94XqVJZN75uvlkLOs\n",
       "RrJRJNZbIJTOsPRQR7cZjBnBKbRBH2Ey1YIuOzrsIAe1fe5HW4SQK7YfkrFtNhwL+fhu3shhf9Yt\n",
       "OxZFqMtEZxD6LN0kcNKxENmh14uRVFHVTMYHSQcySQ/X27ZjTTPIMJBLeQqUnqqatfeQiBBjrUPi\n",
       "wmKNel14aznEED1rQw6Qt5h0r8Z4dCYfRdcpTpBUdsPaluhrrOPGZMAtpJsWSVsbyKWUWAvjmMLx\n",
       "l5SOpxMlOmSxxTLPmwNkn7Ob+fXd92E5AyRTOjGrCtI7k/biHLj8oTTWnsN5YoxTnowOuOk6ZqdI\n",
       "Qsr8iXRBc0oPNTJxjnSxhbEM+SwknKx4PXMbU/ruDZI1pLCE61NRORw5B2vIv7y/Lc+QhJj31uAI\n",
       "n66fF5fHYJ5ahYuH88G4DIlHqZVfz42sCJMQQgghxAx6YBJCCCGEmEEPTEIIIYQQM5xsDROz8nJ9\n",
       "yoJFZbHWqA/WP67/wNoWT5P7mI0yhSMrLz2qDdYPtbDwN7CcM8XAtsO6BWi/TB+wWmVLO1z+VtDq\n",
       "ywKn0Ie59sZsVGwR+jitrEwZwPUBBa5xO8pqfQzWZzkdQAvLMdMZtNDQ222+ps+5lRcMXTSPXW1f\n",
       "Ym3T4ixn9K5RxHiD4o0by59ZMAM89OfLmustMv2owCeLI7ewQW9v5+PzUDQZ6+2YxR3pujcbZHpH\n",
       "X+uD3ZcWXHxmn/dfrvParnP0r2PRsog119RwvcESdmCsk2Cm4w77czR2fVwP0DGzMtaAMJvyxTa/\n",
       "p2HmdaytYDqPFdYOLVbYZtoO9ACu8ynr/Pln5/n61kyxMErnUHG9B46jxjqTyqfXvfRMvdEfP7EA\n",
       "13YNmBe5bqtY8Lrn9/ZhrRps9SzyvcRaTi5YYcUDrplB5v0F3nt+M88hbBtm9jYzK1j6GNnES8yX\n",
       "7FMVsphzXl9g/wIZ3Qusz7poYS3nuMDxlGH+Zvb/EySJQPvVCxaCx/0RX7vw3GZOa/yWx4l2ajlS\n",
       "8/YK9xKuG3SkR9ni43k/TNhnvBJogXWOXFNa4XU2f2Jhc1yL5WqFbfRTrGFanmFNLD7/coNnEYzL\n",
       "pmUGcLsWijAJIYQQQsygByYhhBBCiBlOJsnVJcNvzCyc43qLJQoldjnkRjmjRtbjFiHEZpRR1A8U\n",
       "x20QmryEfLJF+oAGtvIuZMTFRyJmd4nPbJq80woS4xJxxhLHHbK3jhzjlAF4zRaQAFLitmEboeUu\n",
       "Fj89BkWZz21AtvHbd3I49hJFVuuCxWTz51QVJJBVluGKywavs/huthz3kAwGhJ8bhK47yg0IFbfb\n",
       "WOg4Ws6zZnLn9lvzLrBcF5D0WqQVaO9kCa+7zJLcbWz3kPOQ9cAWsLRXde4jZ5CnnlPQJn8cOpxL\n",
       "CRt+YoeEbOE46ArpHJoNMyYj8/ao9jNtyltIAj1s3AzlM6UGv3uFsbOC1BMyUTM7P4ve4jxLZnSG\n",
       "N3wJme/sRpRCV/gOZhlnMXHK6MOB65HGg/4IUBqlrMZit5SbOAdVkM+GYlpmoXyyXE+nguB2EZZd\n",
       "5OM5QzFkpj4pq9HvdlywGkXVe2SprlgouIJMXKInsZA6+mCNuRnqv13ezlJ7OiA3s1279vhLHyjz\n",
       "pUR5DstXIIfx4Apko+9Tnu8GyNErtB9UV6vRLx2TaHE+veRky+Nkv0lR26J0ylQbNSVZjOWe6SlQ\n",
       "2J6FkStsF+ibIaVISdl8+p5ecY67Zo4IRZiEEEIIIWbQA5MQQgghxAynK76LEO0CLoaKGZ3hMEl8\n",
       "dIPLjaEyFibsoyIXsiZXAwsMQhoKYXKE/uDqaZnJmJm3EeLrWHjQkNEcYU1uD3SiIPK3rKNLbgEp\n",
       "6nydQ6EhBNvzGrCAMPU5OzoJ14KZU3u6KyiZ4rrffvObr7ZLe/Rq+/z81tV2UdD5AAfFeXbWFJBJ\n",
       "fJP3v3ORPzMhzkw3o40kXMoMLdxwmzuQ5PD+Du6bGpJG12Tp7eIiy3NvfTQfU9Nk+Xe5Rqi4z+dw\n",
       "4yFII0aHGrKbH4lQxBZ9mdmzS/yDbc+ipHT/NRuMpy52QDrX6HbpzlEBAOMuLVGMldnWWViWmfBZ\n",
       "4BOS1PIMRZnPIMmtIEuwkCfG+KqOUmhw6+J1pxyGsZ3YhkFWPb5czoK7S8qNaMMObtYBGnmNQtfl\n",
       "ivMdZDi4kla4jtuOTmhILGhjHsMCkucSEudyFefBywssl6DbGDJ/mPsSXZ/oU9RIIRt1OP/EIs6U\n",
       "wCjpYI7rEu8bI+35CPAex4zWxYHi0XSOM+t11+N+VdMxB8kSbdaHYrpcTkN5lRnV4WrFvbfrok8u\n",
       "FChmkV3cc0sUbbeK93tmFscx0f2Ibd7fCxYxRvtx5U4JjbGQJCeEEEIIcRz0wCSEEEIIMcPJJDln\n",
       "8VGE2WoW34Q3pmaYrYIzqkPxRbgbhiY6FG6jSOMiIaTvDBXnED0lQOQuswGh65LFRRnqZrFAhG65\n",
       "PYRMWPnL1sssu9ULHKeZGQpK9nAHOsLXLdxkDYoRdx1dXGNH2BE4lOAO7i4mzdvAibXFMRcpb1+E\n",
       "6DArOKK/bLLMVW1gaamYwBMJ7UJiMsi0KYbP16t87Zkgrod7ckCCzijn0iUFOaCkc4fyUb5eHYuj\n",
       "4nhWOJ4zJPhbI6HnsWDRScoQofClT4e3qfwu0d+t5GdGSW59M7dbGQptZiomeqT7jm2A9iwZZg+V\n",
       "SZnQEglA4dAqlpDzIBOxkLaNpAUmq1wycSWmiIS5I1RRpfMnXS/0fy+0cO1WFQpXwy1MxYEJHReY\n",
       "gxJlqAWSGiKRasU5GEOKDqVFnfenaxGKkZ3hwjG5oZlZB+nNMaZY85vJatknabgbsE/JuRnyHGU1\n",
       "Fite0GGJ722Di/r4ax9CQVzImRX7U037NiQ5FlvGfNqE48/bXUs5kv19Wu6MkjM/E3KnRYrgkIfM\n",
       "T4kR+7MNOOYc918m2+W0TpnQ4Zakq5XLC7gUx67ZloowCSGEEELMoAcmIYQQQogZTibJBXcawl0V\n",
       "HDMFkw8yu2GQP1jDKb93fRYTwHV0cSGMuETiLYYHQ70cJjtjPR5IKY5QPyXGBSS2Em7A4CzCcdcL\n",
       "SnLRAUWpa9vR/UC3BxOqse6OTW8fC8gVvNa3t9lJdnGZ5ayQ3BNx4ERnFT6HyRRZt2tt+fPLLieW\n",
       "Y30+hmg7tivbYGQdTNv8/vV5vu4Nzqej84sXlQn74LDbYruFGyqqMEjcCimxWOTtEjIJ6y0ei4aJ\n",
       "K+lcwbGVkFKY6LCESy6Uc4RcthnJ5ZSn6opyEM4fktklZJKhhcsK9e0WGMt0zDFh3XJJdx4TXeLc\n",
       "6EpCO3mKktwAtw+Tx7LmGiWtAdeYof/hFPXHKLFi3k2Qawb2f4yXwugm4nkhoSfmNTopO0pvuA50\n",
       "6lGGCfX/6GAbuSpXZf7cLRJuUkKKGWrpJsM54DtayDWJMhzOv6TDkm0JZ1moSefxHnQMWGt1iWvH\n",
       "xI10YNNFTsmTY45OWMd1KNCnGxQ8pEuRLlDOswWXk0Dz69s4biiXLzHGa4xNLguo0H6UUUOuTrT3\n",
       "uqbjlS5PXrt8DJeY3x3jprjmsFSESQghhBBiBj0wCSGEEELMcDJJjq6tdMBZEJKaIRTZcik/DnFt\n",
       "2THki1HoDyvqL1mLbkV5I4cEmUxzyddRcwzKYKgfNiDsSPmIS/bpjGJ4tMU+/Ug6C8pbcWAbYe0N\n",
       "w+Mtk7odPzne8jw7F4sa7jyEircDa4tBkmXdNvQLSj0bJIn0Nu+/6fN30VlhkDlDuBZ9rURfY9I1\n",
       "M7OLi7zfQy2kVMrBfT6+LY67gFzDpJctzplJ/Vhbi8noksExirD/Kri7ju+SY30nyoV0hRYHZDSH\n",
       "w6pHKJ7ygS9j0kfWmaOIscD4p8MySHWQQGDQsjW+g/XwSswDZzfyuF6f0c2Kg2AmO4b0fRSjR79i\n",
       "rcbC2Lb8WCa0pDPn+JIcpQvKRINxDkaiQcjldLEt1kgOCCm4gBRDebF29hEsl2A9O7qlcU1K/lYf\n",
       "yZSU9AY4/QY4Mbshy0Y9k8rSfYc53iA5dWwz9B068irI5ZyzeNjF8RW5MLdwu+P8iC+mssmJkKav\n",
       "4ICjtId7SYF7WonEo0PoK1gmgu015oR61JaUgmssj6kX0/3UQ8JcSo/cnpaU6Zxl3cEOSYspw6We\n",
       "svn16gIqwiSEEEIIMYMemIQQQgghZjidJNfmkGkLyWMYmLgS4XbKAQjjDimHzWq4ZIpVPPQKddjO\n",
       "EF5jyJmh6wbOuPUyhwrPEMrbtDkMyhBfjxAt3RRUjBhCpBvufI3jRIjSLIa4wwp+7EPHIR1LqUeI\n",
       "elxo7wiwLle1zMkkmW+yhSS3RbsxSruBnHGJBJuXG7rKIA1Qh6GEu6b7EXXhIKkOkFHXfbzWS0h0\n",
       "Vb50QWJrmtzmdACGsC6kjg3OJ0GGWyHEvT7L7Z/QN+kYrWDXqkZJ/Y4Bx0GQMJjEMYT9p22XFROM\n",
       "MuHcSJLrmHEQ0nFCQsQFJLCuRjh9iwR0uNaUNh3vXUJWW3Ebrp4SLrkEKZBJ+oIDdfR9oewlzi2x\n",
       "9lVPGYuJ9o7/G7XFNaWZs2SCQ54PN5mgk06yEuO3YcJQXNMl3XMYmwWdTtyfr+P4mzhfsZbiCssl\n",
       "mOFwA/fsis5LyIFcOrGA25pyfpcol+K+AwdZcMji3HhvOhZM+Ow23X5FMS1JUV5OrDfHWouoa9gz\n",
       "gSfG1lmZ58r2AklE4UzsuCxlDQm2jDrlFn0z1HSDpW9ZTztnw/2UjkHcE1LP+QHuV14vLtPANXXc\n",
       "J6uxBH8ARZiEEEIIIWbQA5MQQgghxAwnk+RYV6lFfa7UM4yLGkV4dKuCAwa1wRA2ZG03M7OLDZxb\n",
       "lKSYmA6r+QfLx8Qw7gqy2ApJriiFMdxpkP8oGdANeA658OYNOAWWsZYcE5J1DT8XYf+OTo783rLg\n",
       "8R0/VFyjDh8TKxZwOxRIDjhAtqRjrEFCRyY4pHOLr9P15DjhM4RoS5zv5Z1H8zGgbVIVJZYuof5c\n",
       "n7/jDmoSMslZx4RnrK+EvhBqI67QPxEqHlq4klIeCy1Cwhv03+4EWUjZtxhaby7zOdYYm4xWt3Ab\n",
       "9aEII8LeIwmPyQvbIrf/EmO7GpCkjg4zhOtZSy7IfMEplI8vwW1ZWR6DlBtDr4DEQtepWWjCkMSW\n",
       "iUgHXKgWNfDa0M+v58a5F3qMnQLzbmwGSBEhQSVkfc5rSLzZO/oFHJwr1glDO9Wsh4bX15DBKdXV\n",
       "ZXQ8byCls1ZYXXKZQv6sFeUayM2XSDy7QJtXSB68ZWJGNCsdoAnSbot5rYtTylGgxN9heQDviQVk\n",
       "5FAPjQlS4casOYcywTNqHBYlHIU4sQ5tTImT9yEmnuxGtRJLyNFMHH0DSSztQAJmJpV1SrsrLoNB\n",
       "v8b4LfGZTMLLKQvKvPXV9SyPijAJIYQQQsygByYhhBBCiBlOJsn1XTu5zVXtCa+3CAcv13AVYdV8\n",
       "QoKyUfmhEGrs4PYIebQoWxldbJAfDriDGK5mUs4e4UiGovkkegNuoLPFYddTQticifNSmnYKFQxB\n",
       "Hkh4diyWcPfRubY8w7ndyu227XIY/9E7Wf7scMysddUl9BGEUylg9AgVD5eQ5BC6vXORJTmG/cs2\n",
       "hlwvkNzUcE23kCIaOjBYP45OPPS1mzdyck8mMdzgWtxBmJ1y5jY9nN9QUYY8vkvu8uIifxWTPkKe\n",
       "qUtIb5AnWrYBnEd0GMVsenEsFJCqa4bT0eaUNhcVZXRKLxhrQZqG+3VB5xa+CxIu24mHPTazeZCr\n",
       "pt10dC+lULuMUsnxdZwg4zT5OHv0ZU6DlNQH1INLcE2FZKuYW2tsV5Q3IIWt4QqNyYmZGDW/txj/\n",
       "bkcf8ZBkNX/WGc+BCQjRP5c4t4q1MNEeUdqlE5L9EbLlJtez7E7QlsMwnUzRE52WdErn91KC7TC2\n",
       "FnCkJcrdTKJbs12xPyTYDk5mXucecvxlO1oOggmcrvAbWJrCJMeUz9gHGzwroKsFNZ6JNbkkJiEx\n",
       "JuuAsq5pDyn/bijCJIQQQggxgx6YhBBCCCFmOGEtuRzualAHZ7NBAkA6nZZcpY9klX7oEKMmR/ms\n",
       "YkJH7DMgy2LN5IAMxWK7REiXySpLhER9kSWNCmH/EFZm/Ti4ZxjKNDMrIcXQdcT3D3QfwsmzgYur\n",
       "aY5fS46y5dmNm1fbq/XvXW3TINE7HY1w9i2nXW99cBvBiRISimF/yhBomzuXOWTO8DZlMbNY64uh\n",
       "WX4bk48yVDxAMioQyqY8yRqDF1vWlYO7B9LzTVxTbq+WMeHmMdjCDbeo83hco403Zb6OBdylVQVn\n",
       "J01ydNCk2K+D1My6TnBPhvJukHHqAzJDhb6zoESMeeQG6h8O0IDo6qFjrre7yOWsB9dxbEJWRuJW\n",
       "1p7k3FGcwFk14HtZZyvU36JLjp2ckldHWR/XmvW68FYmHOR2FZYyYO7C5zs1uVH9sQJjk58brt3N\n",
       "XGNxA4f0xe3cn8N9gHO2se+w5iccZBjjqaU8F2xcdmwoRxvmUEpGlOcWkMxKXNMSiTcLXLgOa1kW\n",
       "KyY+Rr9hPU2f7gc2MIEn3KGXUZIL9ergVG6HfD6syVevkLR0jYSWkPZ6LpUImVpRs5S1VemaDzX2\n",
       "eKzXc5YrwiSEEEIIMYMemIQQQgghZjiZJMeEUlzJ3yMkzwSTTEoXcl8l1pZh7ap46C3CqUvIZCkW\n",
       "eMvHVDKMD8cFwr4XSGLYI/kcXSmUy+jO4/kbQpwtEjfaSLqgS6cIEgBcXJscytxC6uH2ZnO9Ff/3\n",
       "QoHrTRdjVdOygLAurAxLuMfckTASUdD6LO9zcSe7uLYIv9L7l3h58Tkl2t4RlvZRjSNKDqwVVSGs\n",
       "TXmHfYROiwWkoVuQCegOKuEuuXkzn+fzn0sZLr93iUSn1V1clU8YSkR0cEE653haLOC8QiMMwbmT\n",
       "X29HknCJPxZMQMc6hIyVU1pAvJ51oCj7lJxr6FzqpzuJOyUWjkEc57i0FCYxjkE6fJoDMhzlsLY5\n",
       "/tgMTiHOkZCbOHeWoW4nxgjaKeF69f10Uj++t/RpFxc1kB7XJ8x8o0SnlOtqjK+QtLfkGMR8j2Ha\n",
       "o/23rPOI72I9Trre6AbdNnThYWnGCSS5GtkUKVWxz8ZbGu85cI7ivbxf8cqHJSAYl5TketZQxDY/\n",
       "sm25/GJ0T+M2E4PS+V1SFs+v0zlPx9xiyXt/PiY6nIcDyTAHuuSC/Hk9rVwRJiGEEEKIGfTAJIQQ\n",
       "Qggxw8kkOUT4wir1hjW5GG6nnGU5rkq3Ap1KXjDMaFaw3loocQW55UCImuF92kAaOnRsHKPfvxfh\n",
       "xLAyHw4g1jeqeGFGZcIoZTAJXge57RIyISUAJm9zO74Vp4UWUyGUe36W5aNbN7PExCMob2fHlaMG\n",
       "IJOHMuydKJ/hHDu0MfsRv4xJNXl560WUFViDiRIFpTeez2IxXSvrFpxYNRwhTAr3EPo2ayg9dCu/\n",
       "d7XO12WxZD+9Xo2je6FAX06sjYV+xnPkSGvgNuzRfgnjjHX3zMyWCKcvKTEycSmcTnQwlqj7VeOa\n",
       "Mikl5bMtxuDFY4/hezEGl7imdInhmIuR3EI5KNQP7KZdZpTwuQyhucwurmMRJDDmD6UbjPUfMX7Z\n",
       "r0vUTOMcemib80/Bem7ov+HQgrsJCUwXsS4or3yDZMUXSIB7h7I9JFI64LjN2modkxBjTunZfthn\n",
       "OCAxFqMErceA5sGUKIvyfoWxCTf6gCyRNdyFHo4Tkh8GDiVkNkAJibBEX2lY6xRy1qgsYEi6HBLM\n",
       "sr+scG64Pya6BPk5TLCLvtyjr2yRXJidtg3JXHmXul6yZ0WYhBBCCCFm0AOTEEIIIcQMJ5Pk6Aah\n",
       "Y4zbCaHq5Son6GONtH5Lq0DeLEaup4HhV9rsmLwNoTk6BC4pbQ0HXG94vQrOD9S32+aQMWXIwSBR\n",
       "MBGbR5mP4dWWjg3IDFtIchtub6a/+1j4ASfZDUhyz3no1tV2qPUHe0QBGZaR7gXrFCE5p4d6c/ma\n",
       "rCGrtJCAlkiOxlpMi2V0mzHBH2XVFepg3bqVJbnzs9w/l/isNRxtQUrjlyGcfIZEcw8/9NDV9ts9\n",
       "//lX2895Tr6Oi+r4Q5QSFl0/rHlmdGZukQB0AwmAiT0LSACjRIQcmy2dWLDaUBpMKOTmiPFTquu2\n",
       "02OTCXOtZJ28/HKQOjiWnfJDlIn6AQ44jEc6WFknjvLTcKCW5rGo4RJbog9Sag79He1Wl9PSzbbN\n",
       "YyrIWZjvmku62SiT5M9kksEW45GyftmP58HcPlyCcHEnbz/2e7fz5zb8XI5z3BNCLVD0l4Hz7KF5\n",
       "E32E+59gnt3iHkLJr6DVHEtWuPyCDslwz8V87aGmXv7EgTVKuT/vmUz2jOFR4noyOeXu+/J74n0p\n",
       "73cOuZjf0bHW26FajthnwBhl/bgtnkXo5k0xg6tdB0WYhBBCCCFm0AOTEEIIIcQMJ5PkmoahRaxS\n",
       "38IBg8c1unK2CN0x8aTTJTeymCWu/me9K8gtLWOQdAoN02HNIM9hm249ygpDy3o/cFkwfx5rpo0S\n",
       "V3YI9TM8HJNVomYc9u+CY+74Yf8FJAo64x66hZpOCI2XkAaei+vehPNC4s1V3l6hxhFlUTr1eO6U\n",
       "f1PKchbbrxxJW0ysyTZfQDJdI0Enz/l8fYZ94OLCOVOicEhy5/jM59zKktzznvu8q+0VEmaewonD\n",
       "GntBqkD7XQyUIfJ7OYTCOAgJ6+IxUwJp4V4p4a5hfTYb8pi9hFwT2gmOrqGbltSXZ6gNtkUSww3q\n",
       "EKJtjM6dIY4h1sejZMQ6hnS5duiTTL7o9fETkTplNfRrh4sxJDWk5EK5qaOkmD+/Z0LAiksc8j4t\n",
       "ZFtLGI/oCg2dWHA5Jsqoo+/b4po2kIO3lIZxv+hYB23gXI4vYJJNnkM7Lbdt6b5q2N7xuI9Cmh5H\n",
       "dL3VSBZMg3ecK6Y/JzjjUIMwSn58K+7dTMZK5yTrFJZx7FOS4/Gl4EKEHMgklkxajO1u4Hyfv4vt\n",
       "x35dhTqgvO+ztuG0C36MIkxCCCGEEDPogUkIIYQQYoaTSXI2TIewud1suHp9urZXdMMxpDdajY9Q\n",
       "dL1EPBnh5xRCk3QOwAlwQJKja42VsqAMRGkAIUQmwWtbuADaWHOL14ZhSiZvYxi4C24dup2On7iS\n",
       "NePOUTON31TBMfYwE2wixB6kRtbCo/uG/QXnsqHkwdqDCGPzulEuKUeuyorSCNqHbcUki2eQ0tZI\n",
       "bslab0yMuqiZrBQuPEqbuF504dFJmK4XKb4nmobySW6nFv2Mqlpdw8VCe0yCK6WblvnMzII3pkNN\n",
       "LyTBpHaTIMlRGmJ7UGGlJFNyvIdzyMe95VhhYly4H/uxTER3X5p+neOZ7p0W0lBKxx+b25YOJ0ga\n",
       "5fQ8WBQYL2hzzo/Owl9MlMhks22+EE3LWm15m+OMco2jjfuRW7jFvMDkmJz7EhqBkm9wPiHB4ZCm\n",
       "7x38HAuOLkpRcHOifiLdZ8diBVmffSXMXweSQiecI8+XTrqBLnVeQ0rtaHveD/tu2jnJGm79eMKi\n",
       "Ky1R/sUX3oF8NkowfPUx3fS8zvtJx3FwYN70kJCW10K15IQQQgghjoIemIQQQgghZjiZJMewPMOG\n",
       "LcLWDI2GFfg+/RwXEnCNnDjO1fUM3wW3D1bRs5Ycw9WU5PD5DDWGqCOT79F9FOomhax5eR+6RizK\n",
       "SX3YnpYDmKQvhDhPEPbn9QqOuRtZniuRgOzGjWknEUPdHZ0PbDO64bppxwwdhnRfhER5dO2NJLk6\n",
       "uOampVq6wCjp0HXB61LWdN7hcyCTMBElZbvovJyWs48F677RATQMdHaxThzevGGdOJw7JHGGxs1i\n",
       "oscE2TrBVUopqYbLte/yd2yccwqTm+bvWiAx6GJ7SBrCdYemXtKVY5EuLAGAhIDrVFAaZuJKpyR3\n",
       "fI31DurwFXDk0bDUbvKxsd5eqK8ZZB8k6sUc2kLqaTGWq3J6jqsxrtnHt5dov1GdznjvQJug7/At\n",
       "nAvakESRn4m3Btcn5m/j8g1+Pv7FW9MJJDnOWXSuDS3vMwccZpSjeb9y9lc67CB94zPd0Tb8LiZj\n",
       "xkXchDkktiWvdUz0yQSVuQ8WKOAa5PWQeBT3EzQsnbZ0WvK97O9DSA4tSU4IIYQQ4ijogUkIIYQQ\n",
       "YgY/RYhYCCGEEOLZhCJMQgghhBAz6IFJCCGEEGIGPTAJIYQQQsygByYhhBBCiBn0wCSEEEIIMYMe\n",
       "mIQQQgghZtADkxBCCCHEDHpgEkIIIYSYQQ9MQgghhBAz6IFJCCGEEGIGPTAJIYQQQsygByYhhBBC\n",
       "iBn0wCSEEEIIMYMemIQQQgghZtADkxBCCCHEDHpgEkIIIYSYQQ9MQgghhBAz6IFJCCGEEGIGPTAJ\n",
       "IYQQQsygByYhhBBCiBn0wCSEEEIIMYMemIQQQgghZtADkxBCCCHEDHpgEkIIIYSYQQ9MQgghhBAz\n",
       "6IFJCCGEEGIGPTAJIYQQQsygByYhhBBCiBn0wCSEEEIIMYMemIQQQgghZtADkxBCCCHEDHpgEkII\n",
       "IYSYQQ9MQgghhBAz6IFJCCGEEGIGPTAJIYQQQsygByYhhBBCiBn0wCSEEEIIMYMemIQQQgghZtAD\n",
       "kxBCCCHEDHpgEkIIIYSYQQ9MQgghhBAz6IFJCCGEEGIGPTAJIYQQQsygByYhhBBCiBn0wCSEEEII\n",
       "MYMemIQQQgghZtADkxBCCCHEDHpgEkIIIYSYQQ9MQgghhBAz6IFJCCGEEGIGPTAJIYQQQsygByYh\n",
       "hHviO+kAACAASURBVBBCiBn0wCSEEEIIMYMemIQQQgghZtADkxBCCCHEDHpgEkIIIYSYQQ9MQggh\n",
       "hBAz6IFJCCGEEGIGPTAJIYQQQsygByYhhBBCiBn0wCSEEEIIMYMemIQQQgghZtADkxBCCCHEDHpg\n",
       "EkIIIYSYQQ9MQgghhBAz6IFJCCGEEGIGPTAJIYQQQsygByYhhBBCiBn0wCSEEEIIMYMemIQQQggh\n",
       "ZtADkxBCCCHEDHpgEkIIIYSYQQ9MQgghhBAz6IFJCCGEEGIGPTAJIYQQQsygByYhhBBCiBn0wCSE\n",
       "EEIIMYMemIQQQgghZtADkxBCCCHEDHpgEkIIIYSYQQ9MQgghhBAz6IFJCCGEEGIGPTAJIYQQQsyg\n",
       "ByYhhBBCiBn0wCSEEEIIMYMemIQQQgghZtADkxBCCCHEDHpgEkIIIYSYQQ9MQgghhBAz6IFJCCGE\n",
       "EGIGPTAJIYQQQsygByYhhBBCiBn0wCSEEEIIMYMemIQQQgghZtADkxBCCCHEDHpgEkIIIYSYQQ9M\n",
       "QgghhBAz6IFJCCGEEGIGPTAJIYQQQsygByYhhBBCiBn0wCSEEEIIMYMemIQQQgghZtADkxBCCCHE\n",
       "DHpgEkIIIYSYQQ9MQgghhBAz6IFJCCGEEGIGPTAJIYQQQsygByYhhBBCiBn0wCSEEEIIMYMemIQQ\n",
       "QgghZtADkxBCCCHEDHpgEkIIIYSYQQ9MQgghhBAz6IFJCCGEEGIGPTAJIYQQQsygByYhhBBCiBn0\n",
       "wCSEEEIIMYMemIQQQgghZtADkxBCCCHEDHpgEkIIIYSYQQ9MQgghhBAz6IFJCCGEEGIGPTAJIYQQ\n",
       "QsygByYhhBBCiBn0wCSEEEIIMYMemIQQQgghZtADkxBCCCHEDHpgEkIIIYSYQQ9MQgghhBAz6IFJ\n",
       "CCGEEGIGPTAJIYQQQsygByYhhBBCiBn0wGRm7v6t7v6K+30c4t5x9z/s7j/v7o+6+1+838cjroe7\n",
       "v8bdP/p+H4d46nD3l7v7t9/l77/o7h/xVB6TeOpx98Hd/+D9Po4nQnW/D+BpQtr/J555fLGZ/cuU\n",
       "0vvd7wMR94TG3IPHXds7pfReT9WBiLvj7q8xs89OKf34/T6WpxOKMGX8fh+AeEK8yMx+aeoP7q7+\n",
       "/SzG3fWD75mF5thnDskOtNeDPO4eyBuKu7+/u//cXsZ5lZmt8LfPcfdXu/ub3f2H3P0d8LePcfdf\n",
       "dfffc/dvcvd/4+5//r6chDB3/3Ez+0gz+0Z3f8zdv9Pd/w93/+fuftvMPtLd38Pd/7W7/+4+5P/x\n",
       "eP/z3P1H3P2t7v4f3P1vuvtP3K/zeQB5f3f///bj6VXuvjSbHYODu3+eu7/azH51/9r/5u6/tW/H\n",
       "X3D3P7J/fenuX+fur3X3N+37xmrySMRRcfcvcffX7+fYX3H3j7LdTXjh7t+2f/0X3f2P4j2v2e/3\n",
       "uHz3fft+8ai7/6y7v8/9Op8Hib1s+s5m9iP7efWL9uPus939tWb2/7j7H3f3R0bvu5LZ3b109y9z\n",
       "91/bt9/PuPsLJ77rw9z9dc8UKfaBe2By94WZ/aCZfZuZPWxm32tmn2xmaT9Yv9rMPsXM3sHMXmtm\n",
       "r9q/7/n7fb/EzJ5ru8n6Q0yywn0jpfRRZvYTZvaylNJNM2vN7NPM7BUppRtm9h/N7EfM7EfN7O3M\n",
       "7C+Z2Xe6+7vtP+KbzOwxM3t7M/tMM/sMU3s+VbjtxtmfNLP/zszex8xeercxCP60mf0xM3tPd/+T\n",
       "ZvbhZvaHUkoP7d/35v1+X2Nm72pm77v//wvN7CtPeE7CdusKzexlZvYBKaVbZvYxZvYa27X5J5jZ\n",
       "d5vZQ2b2w2b2jXjreOx9gpn9E9vN099lZj/4IEc3nipSSi8xs9eZ2Yv38+o/2f/pI8zs3c3sY206\n",
       "+kSZ/QvN7FPN7OP2feCzzeySO7v7x9quXT8ppfRvj30ep+CBe2Aysw82syql9PdTSn1K6fttd2N1\n",
       "M/t0M/vmlNLPp5QaM/urZvYh7v4iM/tTZvaLKaUfTCkNKaV/YGZvul8nIQ7ygymlf7/ffj8zO08p\n",
       "fU1KqUsp/Ssz+2dm9mnuXprZJ5nZX08pbVJKv2y7h2jJBk8Nycz+QUrpTSml37Xdg+372eEx+M54\n",
       "7ytTSr+XUtqaWWNmN83sPdy9SCn9akrpTe7uZvY5ZvaF+31vm9krbTeJi9PSm9nSzP6Iu9cppdel\n",
       "lH59/7efSCn9aEopmdl32O5h9hA/k1L6gZRSb2Zfbzsl4INPeuRiisfnxJenlC5TSptrvOcvmNlf\n",
       "Sym92swspfQLKaW34O//k5n9n2b2sSmlnznu4Z6OB/GB6QVm9puj116Lvz2+bSmlO7b7tfpC2/3a\n",
       "ff3ofeN/i/tLstgmLzCzR0b7vHb/+vNtZ3rg39WeTy38wXFhZjds1zave/zF0Rh8nEfw939luyjF\n",
       "N5nZb7n7P3T3m7aLKJ6Z2c/u5djfNbN/Ybt2FyckpfRrZvYFZvZy27XJd0NW/S3semFmq7usNbwa\n",
       "j/sHrNfbbh4W94fxXHo33tHM/utd/v75ZvY9KaXJ9adPVx7EB6Y3Wpx8zXYLh83M3mBmf+DxF939\n",
       "3MyeZ7uB+kbbdYLH/+b8t3jawLD+G8zsnfZt9Tgvst0D82+bWWdm74S/cVvcH95geTxyDPJHTpBu\n",
       "UkrfkFL6ADN7TzN7NzP7Itu176WZvWdK6eH9f8/ZywPixKSUvjul9OG2a8tkZn/b7l3uvhqP+4eq\n",
       "d7Rd/xCnZ6qt+Nod2/0gMbPdmiXb/Uh5nEdsJ4Mf4lPM7M+4++c/mYN8qnkQH5h+ysw6d/98d6/d\n",
       "/ZNstx4i2U5b/yx3f9/9AtSvNrOfTim9zsz+uZm9t7v/6b2O/jIz+/336RzENGM57adt9yv2i/dt\n",
       "/ZFm9mIze1VKaTCzHzCzl7v72t3f3cxeYlrDdL94vO3uNgbf9k3uH+DuH+Tute3aemNm/T4i8Y/N\n",
       "7O+5+9vt932hu3/Myc/kAcfd383dP2rfflvbt8kT+Kg/6u5/Zj/ffsH+c376iIcqDvNbZvYud/n7\n",
       "f7FddPBP7cfel9tOhn2c/8vMXuHu7+o73sfdn4u/v8HMPtrM/ld3/9xjH/ypeOAemFJKre3WrrzU\n",
       "dqH+P2tm37//2780s6/Y//sNtluM+qn7v/2O7Z6K/46Z/Y6ZvYeZ/YztJgTx9CDk9tm39ceb2cfZ\n",
       "LuLwjWb2kpTSf9nv8hdtt/j0TbZbv/TdtlsTI556ku2Ul4NjEPuRW2b2j8zsLbZbWPw7Zva1+799\n",
       "iZn9mpn9tLu/1cz+b9tFoMRpWdpuvdhv2y4y/3zbrUUze9v2O/QDJZnZD9lurctbzOzP2W5x8BN5\n",
       "8BL3zivN7Mvd/S22N0Xxjymlt5rZ59nuwej1ZnbbomT39bZbLP5jZvZW2/14edyhmvaf8YjtHpq+\n",
       "1N0/+2RnckR890NM3Cv7EPEjZvbpKaV/c7+PRzx53P1vm9nvSyl91v0+FiEeZNz9r5vZu+4dW0I8\n",
       "LXjgIkxPBt/lYXrOPtT8ZfuXFSJ+huK7sirvsw8Zf6DtrK//9H4flxBCblXx9EM5Le6ND7Fd3oiF\n",
       "mf1nM/vEvbVZPDO5aTsZ7gW20+y/LqX0w/f3kIQQptI54mmIJDkhhBBCiBkkyQkhhBBCzHAySe5/\n",
       "/uA/dBW66rvh6vU0ZJNDhce1osj7lEibs0vvcPWv/N6Kr5vVZT4VR9Csquqr7eUib5dV3r/H5/aI\n",
       "uC3rBY4vH+zQd1fbHc+Nn9Pn8+wRWe77vN1uoyGr7zr8g9csvz7gsy6b/P62a6+2yzJfm+/5hUeO\n",
       "shbgb/zlD7764gLtkwacT4vjTPha5KXbbHKSWEY3z8/XV9tlic9HWzZNPsdmm7eHLl/rgSaaIr95\n",
       "GGIktcAxLWq4YdF5HMfRD7k92A8LfEfBLjmwH+XyZdUi96nQ3mwlHAPP/6v+3n88Slv+3W/5gatP\n",
       "bTq2Wd6Hp1vg4HhN2N/53nHUmmOefyswZmuM52ab+0jX8735oDi+YpotHDc+v8d4WmDsLxaYN9hl\n",
       "Rx9Z13k/9vkO47nE9y2Wea7h8XFO+dxP+RNHac+v+OZfvjqILcbIgEYsMX+xDbiPl9iHbdtNzz+W\n",
       "pg+/66aPgXMo56ix8MZ25nb4rDLO/1f45KalMH7xhV5MvRoGXonrUuMewj77ys9536O05b/4uW2+\n",
       "b6KPd+i/bIMBr/N+UoRzxJyG72qavJqkxxjl/ZMDoV7mvrvEPMZrNR77TEnKPw2Jx4T7elHjDTjW\n",
       "Nvcp/oHv5XVJ2K4XeX7nuK7K/F28p734g84PtqUiTEIIIYQQM5wswsRfED0iAAUeX8uCv9Tzs1sR\n",
       "Ikl4osdTbT36hcFHwgJRqQq/Js/WiGLgdcc2v4PfTfhrpUdUhb9iW/wq2+L8N/gV4ONfVjiOAU/U\n",
       "CGhZwiMufxH2PZqyOP5zcIHwCX/V8Anf0Z5lwa7FaE6+vsPAE2Mfyd9VoA3Yj/iL2UtELfjrGZ9Z\n",
       "1bEtWY2BfY/nUCCa4p6PlRGGcBy47ItlPv8S5xN+vLHP480HAiZH4+Li9tV2g2vK6GfX5PNlb+K1\n",
       "atl+jl9rVZxW+gMRpjAG8fp2k2t0sg15HIw29Axv4eJV6GscmzyHZZ3bpmTEexT2YJSMR8JasI45\n",
       "abnKv2r563U4y3PQsdhsc6SAUVj2L14X/rrvEMEpE6Po+XwbzHEpRJhscv+OESm0TZjjEY17mw7P\n",
       "CJMx0o42ZAQ+HNP8/aXveT4H5gEcElWHGKc6/vrfywvUp8Wc0DO6ir4Y7j+MWFOVwPlyftwikstr\n",
       "wvsvI+sVxsoGfT2F6P34mky3n+N+wshsgftG4n0A+3OuTLiJ8lg5twRFhEcGVYt9zuzcDqEIkxBC\n",
       "CCHEDHpgEkIIIYSY4WSSHCUPylwhvM9thNYKxMZLSDKrdV48e7bCojOLCysppa1XOQR+tr6qFRhk\n",
       "A4buFwsuBIPsxxhtmpbkKLd1lOEQJr9zmUOu20U8hxaLuLs2bzftdNi4HqYXR6YTaDp+QFZiI7rl\n",
       "8wkhUYR4y7DIEou1O5wvrlddHVjQW7A9EHrH57f9dJ96m2PiZx1oZ8exlpRxcJ78nNUySzJdxyvG\n",
       "MDND0Wxj7F0e/zdNhbE2cIE5pbPm4mqbpo0BB8dFowOkqXLJklJROuYi7gAX93IRKRfrcmFqWODJ\n",
       "RelY6I0xNOC9bZu3tz36Gq/7uNtBsqhpBqnytmPeKQYswMUxbSkDHIkwb3CRfEe5grJofm9cKIvX\n",
       "IbM0bW5nzmt2DXmOdAMuMNcZeOzjYfG9TS/65heGdcboR1VJuRXy1sC+lt/KZSRhfgE014RlEEei\n",
       "abJMFkwY2A7HzwX22I73qNx+JRuK+7c0EE23X9/xGmJuRYP1TTQyUQ5sKZmFa81lDViWUkHWLrlU\n",
       "BnMNZX20WY/7ScIYP9T3qzDPsoZwRBEmIYQQQogZ9MAkhBBCCDHDySS5xSLLZ9HBxrBZDtcxKrtE\n",
       "vgdKewy315DXzMxomlsgTH5+duNq+9bNW/k7Vvn4GB6sma8kfMN07iHmyqiRG2iD0GSJ7QL5XOpl\n",
       "PgYzswY5ijZ0Cm3p1oKUlKZD7sPYqHAESkguA1Ur5tOgXAhXWkI7Nz1dPAj7I4TKC1/BHbGAPDdA\n",
       "JurToX4Ex8WoNBVdWZ4oD1DaRV8Nzii0AcP+dI4ESTofB/N2DQPdG8xRA1fh4vhDlO7EUPwd12EJ\n",
       "TWq7Qbge7s3gjMLHdJdZzjMzq9Yca3TZURqBZIS2otxEhw8lsyCpUw5EO13CScaDbS/pFMrntlpE\n",
       "F25JGbNHX0U/LxIcoJAQUsr7dM0BSfJJMFB+wVjrQ74oOKt43fE5dJJyCmn5Xo61Q/OMT8t8dLwd\n",
       "cqTtduQ1oixOZ5xNblO2o4ttoL34QP4wtjhdlSGfVUzuZMemC1I4ctwN03O94xiimzVvDwMd18gh\n",
       "CJdci222K5cuNLzHMA8ajx/3sN135+O72OQxyGUjzI9YrfJ9vT67mT/HKfXl967P8v4V7q1xZQWd\n",
       "wHRw4t69mHbEj1GESQghhBBiBj0wCSGEEELMcMLElZBwEE5MIbFcDoJSSilRqqIISRiZoC4eOksX\n",
       "rJZ0xuWw3kO3Hs7fjbosTMRYc7U8Y70HkkFuIcO1PdLIT+fSCy6L5WJ8DjlhVpDYDqR8D+4QOlOG\n",
       "44eKF5APq2o+vE+proEcQjkjlNw44NYKshXOcWhz6LoMcmlup6qmdBbbjzLh0E4n2ltAzl0gVEz3\n",
       "XUe3SEm3B5PmwRECRx+T0VHmi0ndrhcqvhd6tAGlB4cU0sFZ024hD0PO6iiX4ZhDeQMzK9p8bosC\n",
       "bheMi4bJFJkkEsfBY61YogKfswyuSs47KCmEz0wtJT/IDCPprO2y1FCu8/xUImkq+2EVSjqxlMPx\n",
       "f6PG5LFYUjBMJ9WNPjdcI4yJsjowNzMh7YFSFxbKXuA48Q9K9tUo0WkH9yU1s5A6NIyp/HobSppA\n",
       "Iucx8R50YMzagSk0JAO1sZb45Ln96FuuttsmHwQTzJa4d1UHSt4w8WqD8dtRUkd7t3BvMyk09+F7\n",
       "y6D5cU5gCZMoAdItTocw598SDtYlnxsKuuGY8JduTjjfqZ0mfBdde5i/+vZAqZ0RijAJIYQQQsyg\n",
       "ByYhhBBCiBlOJskxmSCjtUxMtUBYtqdzBzFgJq60UCcsPuutFlnOunnzoavt83V+nVIB3VdMoBgS\n",
       "ah2qQcPQJ67ggnWJENK+czFdQydZDPsPIZzM5FysI8REfgwzUxo6fqiYzsO+gFMGx9O0026MEscT\n",
       "wu+hLh6S+0Hm7LosvSESbYsl+gJkzgQJj86msaOFzrgKMX2GihcFwsM4bCZL2yKETBWGsiJdRtyJ\n",
       "EkBVU+ZhwtTjD1E31I0apqXJFvXmnMkQEcYe4IihxLIaJRtd4BzOIKX1OP8LhOtZu2tFlw4cbQv0\n",
       "lwVruGGktpDbKiaepLSHY3AmOmVdLouJVYsO7QYHXMmkidB0OtYui4rFccDlDon8WM8T16UIkv20\n",
       "LEwJm7JwdI9N11RkEl0mki0OzANvW+F+2n5X2LTcSolmsYRUW9KdOu2EDcdHzbDg/WuYevltk5se\n",
       "ge3mztV2s8FyD9ZjLSnJoY1ZXw/juuDxU2oNCUIhfTYH3NqY35dYAlOFwnuxg3M5Rof5ZYFlM0yM\n",
       "23aU4OGMo1saNWE7NEJCYs0B55l61r2bTpbMfe6GIkxCCCGEEDPogUkIIYQQYobTSXJBVsM2E5Yx\n",
       "6R+joYfcB5T2Rs969SK7mJZLJsrjCnnWW2MIOX8Ok8CxBhRjsayNtaJkSLkCRo8EGaagA3B0Di0k\n",
       "joI19KrpkDglh+AgOWTxeBJQMgtJwQxSCsO6CH1SoVkhYShD9NsGyeRw8RLOd4FiX2vUEmwQNqYU\n",
       "WNVMWBZrHJWQ9DyxfyJcb6jRhePrKJPhvUymGSRj1A8r4RKrl5SnUYePjrP6+C45S0iqakyCh6Si\n",
       "cIU5Qun9RZZIWctwQVlzEyUV1q9i4lZ2pHNss/Rei65MOY8urjBuEh03qKGFfZYtky+iz4aaaVFa\n",
       "4JhKkCbayyxdMiGoo80HRPuHE/xEpRTOec1DRkjKSqihhfYIUjDAEAzJJ+nedbgFKXOVmPtKTAQ1\n",
       "7gldP5LLLbezB/cd9qFLLkjYvMCQRZvpKqZ0GNKFy3mEbe+J1/T4mtz2MktyPTt/6KehAN7VJh3l\n",
       "TErJe8OqxPzLOorOuqSU7Fk7D/U+sb2lxNvHsd9umZAYrjfIvPUqb9NJt7nkeOL9GvNUyLIJeRL9\n",
       "euB2R6c15sH6em2pCJMQQgghxAx6YBJCCCGEmOFkkhxryBhrYx0IyQcnXdR8rmCyshrS1u778jZr\n",
       "X9H50iXKO0igh21KQEWJkCBcHQvISqwTVkJLGBA2HPBcOhhDyfF5lTkK6SZk3Z4SIUWGKRtcANbL\n",
       "ORqUoRC+7XA8dLvQBVMijE0ptWngysLnrFF7jHWlStQTqipIACsmrsQxQxYpLMoNvPQ9w8h0jeE8\n",
       "G4bHCzjaKhzrAXebF6Fh88fQxcRkjdwnHT/s3yPpZ0KCxj6MG9T/g2Ou20CSY4gdjpNyGccmJaCO\n",
       "TlcMbiaiLCFndhu2eX59CdnGUKOqu4AjDbIaxw26RQjL93TNjJK/poKSLKUSjEfMWzAaMW/eSWoD\n",
       "tpSCIR9VFeWaUABycju4pjC39MFNlanh3qVEymUXVagZh/bGAKxHv9uHbnq+CIkZMb8EpxiTKNLZ\n",
       "yPHIupi4drw/pHjjyftHu7Qdmy3HWsN+RofhtMbb4vi7LaU0zGm8JqyDyiUnlNA5xpk4mIl2cfzh\n",
       "ullc4sCklk2Tl1GUWGrBfJhcssPlND0SmzZ4Q4k5JA25jYuB9R4hr9JdbddDESYhhBBCiBn0wCSE\n",
       "EEIIMcPJJLkUnEcIiUHOYBIp7k/3WInw6XqVE1bVSKRoZtYgtB5kFUqACC+e3UAiLDh8OiQiTNhe\n",
       "LBCCZC011sNCiLalIy8YPaZlSLPDCeJaJr6jEw2fNTBRqF0vCde94HC78BqxHg9dQmfnua0YBt02\n",
       "WdJ5DI4QQzLFcyZ0dIaN0R6QZ5gANCRAxfVhQjuzUcJCnBvVzJ6OI7rkghMkn9uSSTnL3D/p6An1\n",
       "9ujUhCJHWbHw47dlgsPlEskgt4/mtil69q0cuq5KHFxL+Yu1ysZyFuQX9HFKWMMFEuTh7QvKBglj\n",
       "Fm1Ot88l+lQYv3B5MlFeA+2sRN9pKZGa2RDcvfl1tg9lyW6L48MclmifPRJ9N530053zLiQKOos4\n",
       "B7MP4rxislnOX0z4izGLfVAuNMhwdC93Y2krOL+YgJCuKUpUqM8IOY9171rWiwzJNzlPT9fpDMsO\n",
       "eJjXFnKuz51HH8WxTdfI5HKCspp2yfH4KVP2LWVnJIhd4b6Mdl1D5loGeZXXP7/O5TBmZheWx3XC\n",
       "OODoarZ0h3PZDZc1sDYn5mKMObrXKamzfisneDowvb1eWyrCJIQQQggxgx6YhBBCCCFmOJkkt6B8\n",
       "tsxJJcOKeoQEKyRnpJRCN1y9yDIHw49mMQTZIkTPVfoGqcoRpWuRqItSmEMyaSAztJZDiHRWbCAB\n",
       "MPEZo/stnHSUs8xizanpak9mGyQCYyQ7hRplx38OLkL7sN4e5AafliEZKt0gJNxBblkt6fxgDSE0\n",
       "VJCGkNjzLPcRyhA9a13VUdpiOJYyURP6BcLAkBwut3B68Tti9tV82JBAakoMTGi6oGSSt+sySs/H\n",
       "oIXL5PIyy3ANHHAVToCmnHqN9maySkiZYchZrDdI/9yNszwvsE7cHUq1uHaOcZ0uIQdBGjnHYAvD\n",
       "ADLDZT/tIOL+w0huaXEcIRFvNd3/Czsgew3Hd7B2SLiZ0L9oz2NCXkoozoScODZKmAXGTkGZiPM0\n",
       "ndCUiXhNWAuSbsGRGhITZUJiC05qm/xHz4SWkOcoyXVsf4zfFGRYtjeuBU+iO35bbu7kvk83H5cK\n",
       "UDKrIZktMEcHRymLcEKC5rlv0/S5VxDPKH3WBxKejl1y2zZ/X8VlHVvWjoXbEm1f4XX20ypYnNF/\n",
       "e4yDgf0O0ixq27WY7JlE+G4owiSEEEIIMYMemIQQQgghZjiZJFcvWTMMITuE3BwOKNY0WiyRVBIh\n",
       "xy5kp4xyFuU6SkB9cKVBYrtAnSm43hITcjG8jZBuBccUw8HbbtqNwCjlFokCmzY6cTaQR5aL6dpi\n",
       "fMbtGXZE2LiPH3scIFuVNeRWSlJIJpiQHbBDqJsJOemIYAmoBhJD2+UQ9erh3Kd6yHNl6Dt5n1BW\n",
       "ykc6ER0STCzKxGlBkqM1ijIsHCJwY3hISjrt6FmgTlwJ6S3BDUbn5LFgnbO6xnVYou9DOj5H3T7W\n",
       "SwwuRNRiGjZRqljjUpxRKsBkcIYxX2Ps3L6d23+7ZSLC6YSLIXcojoHyddFSd82fuVxnwXB986Fw\n",
       "DncwiDtIr+uz3N9a1N1irlLWkgtWtCPBduCcwPkydXQWod4eZNUa0ltwEEHCYl1ISpN1qBOX9ylC\n",
       "cmJ8L2pQMnGwmVlzwJXGJIqUhLC7DZhrhnCtKe9ASsZY6J02wWkHd6hhOtaej8D2YlqSYxvzmgZH\n",
       "apjT2N6H9snncok+4WFlwXRyyxqu445LWlKswWhhPqX8i4SxkNVqyuKYWwf0wQHjL7iOsT8l2B4y\n",
       "6hYJPel+bNrruZEVYRJCCCGEmEEPTEIIIYQQM5wucWWonzaddKqgAw4h+SWSaDHsWWLVfDV2gpV0\n",
       "7yAMHCSNvM8WdcwMNXsSk6YdiNLxotGhc3EJBxjlGZuW7cb52vjPDlJBjdp1K7gPLXwW69gd370R\n",
       "6i8Zk85RVsvb25bnj/A2w9iQVbZwbxSodeYdXB09ZTE4HyiFoN/VNRP3xf5C2ZIOIoO0ZJQxEOpv\n",
       "YFlp4UTaNHRfwflRrrCdz+HmzfOr7YouDRYfO0HiyiJBhoIaUnSUG+j+yy/H8DnaHmOo62NyxsIg\n",
       "zzOxaEe5BnILmmAF2ZYf27DuHSUE1nY84G5iLTjWjmzgoFlCajMzWzLxqVNipoyDPk9pPyg3I8ni\n",
       "CNBtSddfH1xlTJKK5QXl9HhZLjh2IGFBtqMTK0peeXu95BICJmKEBDRKtMtktawnFsu7UTKErDaw\n",
       "DSi95ffiVhESaLaQ4bYbSDfQ6Znosjp0g3gSbG/nxJUJSwK4LIP30HKZ7wd9l/vvsKGrN8+hnOvo\n",
       "QOdnUu78/9u7t+VEkixKw3EOQFJm1fTYmM37P2B3V6YExHEu2ib92xgqcqzRXO11RVEIggh3D3L/\n",
       "vtYWkbkQiLbswejjqqqq2hBp+sftrOshR1U3oE0fkfPUcdTq5AYxLoY6sw3GaTldf++emRWmVCqV\n",
       "SqVSqQfKH0ypVCqVSqVSD/R1SA5kojMqhJ1RMu90ufX3g7AMtxRtVFX1KT9b+Wxzxq4GllET1Fhh\n",
       "uVrHRQ3OMxRss78OpVLL81eccNVNFXA4FERT0e/LMLqGEnJb3+/l1XbPd28EJBesK15bUJXWXIw5\n",
       "XQAAIABJREFUld2wSl6jk3Ap5doGtPH2WsrGLVgkPD4Q2HbCXRicg9GdJKLYbAjI9ZxAbDp3JljH\n",
       "Srl3o6w9EW5pZRmSUK3vpSzdcyrG8bUcZ//8sn9LOpyIoR8d7yI2erJ53vn31gIOuA0J3Q19pWTf\n",
       "Mi8cF/a+Mq2wJ9x0mcU75eX2VGx6w1ZxufF9rrr+uK775XZpLONw8/yBMQfNXp08DHx06yJ6gsKW\n",
       "B7YgDAPIhbWMqVwNhq2CNxrDEU0uNcDTjmCgsCpQd9Yu1wHdbDfkpePzXIPtaWf/vI9rWVM3HWHM\n",
       "8RkcNONUNiRzwVk1Ee66gMh1uTb18+sNH3/9s/wHqPU4gIjFy4z3Wdd0mFsENOrMJb3Ze9fKlg6d\n",
       "kzEw0gBmtlzchHkaWttxrDovHXc6eHXRi07DuLOnpEHOIelTHM06zjW+zL/X4zErTKlUKpVKpVIP\n",
       "lD+YUqlUKpVKpR7oy5CcjimRkk4Jy4w1KCQQH8qPe3C6xLJ/390PetS55GOx0opDxyCwzlKxnycD\n",
       "oNy32X9J3GiPH0qUcx3L84bI7SsoMRA2UaJ9ySi53+LKJ8iQM3HWyrmwN15wlYHeNkr3YpKQC6lr\n",
       "BsdGcyzjpcPF1L2AIUB4ASVsEVN+vJcS/SaioaQvVm44jno2+I8AtwvfmYvWgpUOuLjsPTjZB6nm\n",
       "u33iFPlv1NuUi7FvQN/FgFVcKT2YR5St8+zW2Lf6eSJsxrtYZmKMXHH4zKDwRTeU7kxK8ZblJ1Dg\n",
       "BeRgXt1qmOIWS/R8vWoNPRPL9RwPpTfeQH9DAxGb7gv+jVrfd1A5T93+EC7/yvkFS2ykjY4tvUA/\n",
       "sTTtwZkLsmSJa0MzOMbLfhNC3OAE5n0Xrr84dwhLM7hG0s7nrWCcgOFwOU+EpK4BAX0SYvkkTZcS\n",
       "XGmY7eI1MwjXHqK+hntlw83OoNpKjB569tlHsqxvNRi8bnHaMv+2Lgbt6kqTmZ1097H22cOw5bjX\n",
       "a1mv+/b+lpMZTHulN2VvMKrOcpzc22/2BcwKUyqVSqVSqdQD5Q+mVCqVSqVSqQf6MiS3gEBqy8Sy\n",
       "F8rEVAGrBieCfYZEW/tNVW61pxmv23h+wxIRnHuh4gp6oWxogOa+iPlKOXG1BxJlypby6PhSHFDd\n",
       "ITq3Nnf2e9wc4Exp0nNQc87q51OcUN631m2QoX37qmbgeXrD8R1rD5QS++FUznt7vD9eNvsTei0t\n",
       "Ceu2aeJQrwkqWyn1e07bEawCuuo2sBoBcZdzuTbrSjkdR8i8lde0XfmeIw61hTL22j//Yr5wTi+4\n",
       "+a4cZ9PgrNE9hxMyhH/y/HZj/5zAthfmTuh7BvabwXC67z4u5dxdwCddVxCm824jHE+ksYkSKe/3\n",
       "BOY2h8gV28N9B6EWyA4X38Dfu+b1w/OXXPsciuQMA7UnmAhM15591QwW1MxqKOWGk3ek36DHUIHI\n",
       "wraBELYZx/gagjV1xoE2WVNfj4RshjDc8j4H++S5LeKiMxCnMeuRuHjRSVk9f27O9JKrOu8HjFOw\n",
       "+GCfzk+wWq0zzv0ufBeDPQ+Mp7G5f/438K3zZrsJCHZsugPlcCq9GldRMNes4fgmxlp9m/j863ke\n",
       "62qedFFyL2ULybSkSy6VSqVSqVTqKcofTKlUKpVKpVIP9P+ll5wuFu1QKyVaM7FqyrDjsSAsQ/MM\n",
       "nKuqGzTE+3b0YTvxOFSBLTnjthuO95HcdCnl6ssszgHn4XDYKGvaM29oIlfcZsO2CB6jJu55XUBd\n",
       "9WoQ3P2S5X+jBffYuljKBYHMug1BpGDVeQOX2n9qYCzg0Bley9/2OI/6AxjOUD5QoE7F949yzf7z\n",
       "BpS1T7zXpIOGa76L1crz7x/l2pzPOABrkRzXtS3X7Hgsx2BIm0aqvXq+4/GF82jI6YprJISfOk7B\n",
       "cM6DUInv47/DflDufiesc7DfJJ89877TzGPm/McHZXyWsdB/S+Tf30e1w/F+eO46xPNewzLENXW4\n",
       "ViIjQgRDn67q6VpgRi0YrjZIltcfcErZ660x0RI8u1x4T12FbBXoNrdLEKYYHKWudyCvKq6D07W8\n",
       "7+g1NOyyFbezdthvjkW+EwuzjWJ3SwXHurDGzd4sCOJct+fXGzbQtNsIXnHpHkXHHIKOP51khjwb\n",
       "oqwLr2PODsz9l4NprKBlj4H5tN2kkO469xwvNowUl9JGdj3jnuMa6H7dDcZkbBrouYjn2O5w+VlQ\n",
       "3fvlZ/U7ygpTKpVKpVKp1APlD6ZUKpVKpVKpB8ofTKlUKpVKpVIP9GV7mNzbooW0DnZwU7xhjnq7\n",
       "eZ+efSe33LsNHR/l8jzddeEv/q90bzbsYepGksh5o5G9TS2bEhrSQl9Npe7k9ewHqON3qPvyvrLf\n",
       "sIeJ/UmzqdTsq2na5+9h0qJrY12bXZrEG0YW13ljLGwV+x5IlHVrwIV9RCde35OqfCL127hbG7G2\n",
       "Pa+p4l4Hh8Xe3G8Cu3Dez9eyv+Mn6d7X3f1c2OxJbTd0NqS2czzuvalvY7OfoONw/3NPJy8a9mz3\n",
       "ZjHPBvaRueVpO8Rxff6rjN93LL4L0QAzezfef/woz8/GGNi42ebA5bO0jI/ss6iYy8NrmWd/Hoq9\n",
       "eeHr9zdzaNqxUZvob0I947bnhAzszxuG5zfGdj4upCZvRh6wPrjF0UbEYR8p8+gyl2vWscFuYA+e\n",
       "8QGm4puy3IfFuDxc13iuQ5/s0FmZuA32WE3uPWKvy8ZCMl3KeZk+aMRLFMhM1IgNd903aur9FzRU\n",
       "qFrm3YELcuS89+5Ts4m8MQFGSnzS6Jh0lKrjvue968Q9t2WNHo82A6a5/M3e4pl7YkPki+OrdQ8U\n",
       "Y3Zi3ensFmJ8D3OxZwJO7tsiymQmOb6pjJGofktZYUqlUqlUKpV6oPzBlEqlUqlUKvVAX4bkTN72\n",
       "V5lVzA6cFQyn1oYpuW3YXoPt+ebvrZXWNiGkpNhRany17Mgxzaa6asfk8EZKzisW1TcwkSmzV15T\n",
       "3SA5484vFxvWci5Nsm5CDb0cx5fEClAGpa5r6vEI9jCt/TyV9Np1BR0OWu9pjnrVGg2qXU1bduhS\n",
       "lqW8a9LxMNwgOc6dSMBk6WrH0k769PnDJrA2Ii7HITLqGTCjcQamwQfrbzmE5gv+STMM8r/786Om\n",
       "UaZNWY0I6U13dvzFbtHVxPldL+XzfhrJcC1j5K9zsfieQSmzjVV3r18514Op+uDikXRzk+TrI/P6\n",
       "xDW4QWdavPte1MtreH4k9bshMmJfI7J4hi5XoxrK+x9BgQvNSE2rrjZwP7jiwLXtRxEx44UYkZY1\n",
       "rmUeDOC5FgSyh/iDaEU3rdv5b7L2Auq5kgC/7o5DMDrNtrXfG23iXDA12hiJHkTeds+/fRp9s9EA\n",
       "+PKzzI99AKN2ppyDyLnrGpXi+RQb2+i24/vauFcMetXOP3BfvbmnNaa7gxXbzvl7P87B29gKUt7D\n",
       "Fh+SyOWNrA8z91JTxU0/OY2/dy2zwpRKpVKpVCr1QPmDKZVKpVKpVOqBvgzJTZTD25YSoo0AKe93\n",
       "reU60RtODJO0m9uS+X0XmyU7KEl1AB8dTsVx1fHZHySNWh7sbaY50siRQzpxDKEszfdcgh0kYhyx\n",
       "VyhfN/fLkVtD2fUrfgaLsKzo684DWwycx3nV7YBNjLq3CMimvDZcnicwEeRsAZ80oSTs42hpsRGz\n",
       "l2FeWh6X73y+bHcfQwZCGvpAg8zDUMaCKb2djkGdTqRe6yZ5lkybFkl0HY95zXDAzQiGOZC8b9ry\n",
       "5YY6NSCBcX359XjGEfRjAqvovjvokrVpsM2TyweKhnrdPn+8/Xr85//+x6/H376XTgK6ntqb8z6C\n",
       "244H3Zqkz4fmu/e3G+xbbEz8DG0MQhPzHTu9bj7Qm6nODUd64H1GuhPYJH1baF76s4zZDVev82Bi\n",
       "HdCVdLCjQhWvoev8wtg7M9dsBCuWcW3aQO0bE97lwmNqSKW+TuDMyvvR82PbT4zZ6a/iTvz511+/\n",
       "Hr9XBc8dDtxnxnIf8/7Rhi0uuO2whS7gv5ltDS1rq83Va7BmPd3frlFV0aWu89atHFc+26a5C3Pc\n",
       "TgDrbkeM8rdX3MsXEPTqfdUuFbjnfheVZ4UplUqlUqlU6oHyB1MqlUqlUqnUA31h811RjWX1Ut6N\n",
       "DjadGPebafoag7aqqqoGOMNACbmjJLyCtjqOQ6dBzW/IF8qd+yeuiZEy40opc8TtYNPJmmNom4jk\n",
       "dKyItDZKhzV1Y1HdZsjiDep7hgwKnSlrGhrYc15swiiqqwl3nCmhanprR8+dLkTKuGdwA+dxpnFn\n",
       "z3XtuohYRLjvP0v59l//Ltfg53sp458/KNETVrnr0IPpnEA1Ac8yF0J5uLvvRLIJ87NU20F3syxN\n",
       "+CAfO2AnscHsAKYSq9RzHH8fIKMVBNgf//z1+Gx72Ndyjo6ETB5fC3L462dx0tk09YRjR6r2+laQ\n",
       "3P/8X+Vz33jPKyjJOVdV0bnVDuVaHbjOIyixBTE3YJCujW7Np4h1IDSQ5ZiPuv5Wxy/X3AbDXicQ\n",
       "ua6nmc81NLEHZ9WgsL4SEbJW3gxxXVO6EzdQzAYm8zPWiy5k7hcc08Z5WVnYbcxa6cidcWLR0Lhu\n",
       "I356hjpw5ML9ZP4gqBNX5BUc1nRl/PbD/W0gLffQ06G8Xlfk+z//Xd7H4NFjmSu6jmfW+okg0Kqq\n",
       "qlr0xpxquF9vq9eVecf7LgSGLrp2meNiOF2UA1h/Y7zvu1g3kVwqlUqlUqnUU5Q/mFKpVCqVSqUe\n",
       "6MuQnFatjvLrgbDCAWTS87zOKF11YrTDEB0KA+VLcdYw4koyKBMcGAmCThHcQZT+xGoNgVf7Kjqj\n",
       "tKpjQTfbbZ+wELqGK+v8wfOgN0qc9vC5XiJOeIYazpfuxgn7oOVeEeEEJmtwqx27UtbdCfe7XsEB\n",
       "nSikXI9//5NQyTPl14Fx0PJ8H891E/oflc/78a/yvj8pg88X8CfjZeT6j5bBcdBYvm65xtNyHx+K\n",
       "5PYvwKs7X0A8p1NkJ2B0MNySMSuSa8ETh5tAv5dFRE55nHNxbb79evzHXkr/h9dy7o4v5fk/z6UH\n",
       "3IqDBhJWbbhsTjhhX7/znke2CHyU73D5uJlDYi+cboYuhmu138dPIRHxSWrCOoKDSKShUwgEUvF4\n",
       "10mne4x3d7vDgINZd7HjS7dZ6FVnQOGNrVI3lg7AEDjJNbePqMca3MWuwVyCnr/V6dngkK2jz7Ec\n",
       "z/J8x6NBzQY0QiarhfVdx990Ke451zcxqn0Qrwfcy2z1mLmXOG+Ob2XOddxXXaEuH++VuoJIf76X\n",
       "tfXle0Hk9lpceL1zedflOLuN4L7bbubeeNj4nWFApYGkh+jU/ExZYUqlUqlUKpV6oPzBlEqlUqlU\n",
       "KvVAX9dLjnLlbOgUGMId7vb2enE3Po9Fe9VtZZt6co+D7oTjasTRoutr0vW16O6yH5Q9zXAKiQa3\n",
       "8rkbZfuJ3fuWz29DCbeGIEfKqAPfwV50ForFBPPy/H5VVQg45NjAnAbc9aAXv6Xl142+V1KFbafk\n",
       "bOme63/9KOfh40d5fAiIrBzP2EUkd8DF+HHGGfevgj/3/T5i6xqRA4GGoLd+KOO2Cr2PCGvlPXXJ\n",
       "teLsPrpBnyGdK6IXy/IGGl4pe/dc7+OJHoyMiSZ2dqy+fcORSi89S/RrW0riYrvTN9cC5sFVfMia\n",
       "Ah/4+Ks4djqavr1+o48kPR/tEVfvcQ419Ay0X9ZnYZc7c3AHB6/b83H5FWfRDm+avM4giu1azku7\n",
       "l7nj8RvOefko1+kAwjxyPQbmmjiSYVFtnxg+35ef4b9X0jF1U618h7P94yZQnQnDhu1KIe+T06qh\n",
       "flBzjd2+YQjispbz8iwNzPdLVdYit0Qsob9b+TLn2XngfRZXN+dT7G64sPfrF1x4R777zP1gZn2Y\n",
       "cLNVVTxfE+/1ASI9sY7otN75PvZpNTB1BtN6n7lyz52Yc9+7ggJ1JPrb4O+UFaZUKpVKpVKpB8of\n",
       "TKlUKpVKpVIP9HVIzt37BBTOlk8XLS3Ua0PfNkMlDW2Mn2c4ol/Lfl2N5Vqwh0GUe627QCRX/rTt\n",
       "7yMp7VPvhB7uYMjWPj03biJRxkQI2Qj2u3SGkN13cuy3J+cJMrhTp9sQegPqTiyl5W8hKK6UPi/X\n",
       "UorfcGg1IFVDzcwSvOJaE/9O9Hnr6GF4GCKSaxuQ3s9S3r+A5w4vfjecFqCbfjC4sPQls1fhvOjI\n",
       "A+cF56Ehrl7jGyflE7QY0BjYNu7PELYKztF5Rd+9l7ficmvryF7WM27AXgxQvuf3gOTK869v5fnx\n",
       "VB5fJ+ZRQCbgcrCiLa5eXsv4ejnpZtRtFdGCjjuZjv33WoIfp5kAPx1L7Sdc6r/QBy7UHTI2cF52\n",
       "5mbDWF4nr2153DN3rnzfGeRyJjz0gGuq6VyXQOrMU7dX3K5X/qfH7Tz3schpJkDzKkICP23V/fNy\n",
       "5R7EMlBdQE4XMdb2fAfrH8yjlbDcH/8sveTsg/kTh+EVlOmqsTEnWH6qjVfNrLNXrrFjqwPN1szj\n",
       "ZfUax3PifNTqV/M3E2i+c3roiuT+YGjpGVTXcz/1fn2w9ysBu8cjY7b9vWuZFaZUKpVKpVKpB8of\n",
       "TKlUKpVKpVIP9GVITvpllc4y6cVAw76Ug0d3vusIoK6+L9EmdwSBNNR03S0/T5ZiKUfqjAMHtWAc\n",
       "Q80kDubQGQp2pjzqTn6PrW1j+KY97Tp764nbOB81n1FvIpTnl/23zX6A5Vx3FeV9ej1dLuVxa9gh\n",
       "eK4bC8K6Xkp5vyGxTAfjDtpqmpHXgOSuWmDK8+83tsomYABxJqVmPrtmvOgOOhzLdwjxdryPfQ/3\n",
       "6r7jrGt1GYGYtueH420ruKnRxkRvJc7pkUBOw1VDmRyc0w1xWfH/TRPjn7FwEHOCvBv6KzYroIEg\n",
       "u7a3D195ycuR+b77POgYRAapqpYxolBdRC3coK3FRARo1vBjQ1Ob5y+5tQ5QnbaN6Jiehz1zClfp\n",
       "OhVXVt2I0enDxvoTgiENzCR4tm51quHmW1wfbpBcdd8RJorSRVyDli4goBln47zdx3Yb12/Caf3B\n",
       "eifqmn38/AzS4N59fXn59fj87ngva99+FQPL23B+c//p+O57q3sTNxvX5oP757Eua13flOP0b9sh\n",
       "us3aznFUnr8GdOfWHE7qpkuuHIdrk31N7Qv4Cm6rWVvFkB7rcfy92lFWmFKpVCqVSqUeKH8wpVKp\n",
       "VCqVSj3QlyG5rtc1UWrd2yflVnfaTwZdsnvfIMlb6jTj/FlasQEBXsFxxGdwHMH0xrGulP11eOgy\n",
       "mix3GsoJerOkfbnGEDu/kgaMLWApLST+rUiuerrse7c3IsLymohMQS8iFpEEmGOkdFsTvtfUpfRr\n",
       "f7p1I7gObDPRF058eehv8GdzH9f0B3u6ed14PWhQYmag58pYaMEbhxE3WK8b0DFIAGj/e4Fq/y9q\n",
       "qvvYph1lUuVcj5SuvX7TqusJh93NqmKPvV0nD+NFpDz2992pjSd7tW8U/adY0mJfMcbFJErkGEBP\n",
       "9RaDK0VvfQgfLX8f0RXbCtw+8AW95BZTGbv77qUV3FQb0Mi60bBOGX67O5a5Ho7ZZdatxPXrRb64\n",
       "gEPY5I1DibkpQlnt4WmQI8hJKmWgYri/uE5zeLMuZQcxSH2ZOafV87c+jKwPp7dy/CNO3uMbPUS5\n",
       "rhPOzn/jYLxeC84yXFicp2vcx95nAx4VhXH8/e2l5L6hq/Djx4/yGq6lPQndLVC7fcXtDvwmMET6\n",
       "QA88AyrdirP7ucPvBQRnhSmVSqVSqVTqgfIHUyqVSqVSqdQDfRmSE0M14TEfyc+13d3xlF630Let\n",
       "oIFhjIfeBteEjrb7Pa7qUNIF59FbqQvYhtI95Tv7D1kavhIoZpiXgZ7rTb8qz4GBjQZfWt73165h\n",
       "gV+B5AyinAm781q9voDP4IUrIX4LZfIZfFZXho6JMEAGYjv+FmNJ1eKe0zzU34SEdowLsYxVdgND\n",
       "G5wWhk/aw3D3OxhK2RqA2d59jaXozrC+7QsuJmNwD33lcELWYifdibyNLinGcr3Ff4cNoMorAZCG\n",
       "IO6iLc7vHrga8+MTpFODwoLL0XBa+xN2OuxANWt0J864dKr2Pr6oQZ2X9/fyGSDc8fj83oC6oyZD\n",
       "TzkvF5BpCzrswBvtbkgk18CtEwCYlusRdjs4ZHkfx9fGfJqreK4vXFuR2QrS2/gO1xC+KZIsfxu3\n",
       "FIBtO/qL7qJAt5HoqCaEeXs+Xu1xe/djOQ+HF1Cdvdu4fh/M6+bDMGbDPMs81VXmV2mr+2PaAMzj\n",
       "yPsbBHqzXNljMjh+wz2ebTehHynbI8Tdy/1gVF3HOlMb3O72LB1x0h3fiiPx75QVplQqlUqlUqkH\n",
       "yh9MqVQqlUqlUg/0ZUjO2lcdMASuB/EUYVSGbomprPoeh+h6crd8L0qjfBnQGKXlFYdH6DOku48S\n",
       "4qqLgBKwboSJx5dLQVKGvekUqaqqWkL5mrLr1b+3DC56NEzv+e6NEPNonx7Kmq+UNc/glim4h0pJ\n",
       "u67L8FtwLnWWwCm36wYyDLKm/HoaijtiwPV125Ot3nX44AgCY9gfa6P03YjzGHcLY7WBBw44X3SZ\n",
       "NV4z0JB963TbPUsTYXRbGCsiYXqsMQ8amz1xPaYLY3eNqGIiyFCnTaUrjXE9X3Sw0jOMNUUM47Xd\n",
       "P3FiOe9GSvc7CCBwif3mOzCHa4My2WIQ0KXji2PtvmDF/UnjM11cl7qc3+UCFsS12fKamuu5zvT3\n",
       "YuqIaFw3xZm6Qg2uHJlPohTRaVVV1QTC1Ja3w8u9VCsYfvG8u+UjbNPQ6Vnec9XRxXw/s5afSatc\n",
       "v6DecCKs0rXv7VsJjXTOGjL5MukcLWuOQbDnC3Nffqb7sfIecx9nGcBbeX9v4wDfWS+cmx1rs1sT\n",
       "xN2bIcc8fwjraXlP0b/O3NOhzPE//3grj//xx6/Hr2/lvvF3ygpTKpVKpVKp1APlD6ZUKpVKpVKp\n",
       "B/oyJNfo+glOFGp/VudFXqtlX9wwIrU5hj7ulJZbXGy1veh4L0PmhBId9efpiqOAGvDhZMnZ3mMc\n",
       "k+RCVwNum4/3UuavqthzzjL4Gpw/JoPhiAnOj4grnyFRoN+t8fuDsww8a0QgUMiW/mH2xdsDwuO6\n",
       "EiSpy60mVNDyblPTF/CmVGzi5Gh5uNZZZQ2ac813m3F0daCagEtxyQ29WKLIq6qTcF2e78RxDK1c\n",
       "qBVcKvMQdxsqe2Us2zptq+O4xjBa7aL64L67P6cMTTRM8XI1KLGc38VeYhyrIYv1AdQK7vY7G2xa\n",
       "VTfrkI47zo1jtdHxyvPLDYZ/hn68lx5wC46gtXOBLQ+vfLXQJpAtEmZJDoabikV5zQIa6kEjIsiP\n",
       "xYFgqGQ8J2G+MG/F4kvluMCdyHz0eXGe4aEbM29r+FueP4OUL7xn3T3f8fj9e0FGblPx/uiK4Hzc\n",
       "wsYJelbikDye3GbiJ7sasRb7rK5etkHoIuzHeE50sw/04HSrTZhpzK2eddl2jL0YjjV3dBsEA/sb\n",
       "uO0f/6NguO9/fPv1+PW1YL6/U1aYUqlUKpVKpR4ofzClUqlUKpVKPdCXITn7YRleJapofExZvQ69\n",
       "yiirgiquN0hOiRxq+x3hIjDdsScQcxUrEag2Lwbl8bcjpcld9FaObwLVXcB8FxwLVRWDL+2HZ8DY\n",
       "QklYHEQ1PfTxe5Z0YxjoaXihoWhe25ayaYPrYiHscAtOHMqsDXiVMrlos6royWa9GoQnCvrP/wMH\n",
       "iuEaEZW40ePT+QM+OJTj7kcx9H3HqHNhpq+g42D/gnA8kZ/uoSr0dvPYCv6axTZiWtxZjveqqqq6\n",
       "BUOCW6LT7b4zStQTCAIXZJPzMvcNbtycN+XrVBsocAcZ1Tf/lqyDjcjzZI+y8n18r64XMT7/eooF\n",
       "DTJsfByOs5yvAdRsWKXIe918zBplfzrGMqe3anChRe8uWyWW+H9csw3Z9B0M6xS9hf55Dk+DOCvn\n",
       "e3nNCsYyoNN1JIRnfgFefTkVNOSWEO8nI4+//fH91+OeBF97xl0uYD4+KyC5/T7i9Hzai7UDlbqG\n",
       "dDdu5OD+lc86h7geYj+xWssarav5oBsO5Hfg+78Q+vn2rZyL19fiSHzN4MpUKpVKpVKp5yh/MKVS\n",
       "qVQqlUo90JchuQGnmq6n9ZM+VpblBkp3h76UH88X3CBLdIIFFwSl6M6wMzCeTpyZ2m3N3wbnnoFo\n",
       "YomN78khWE41gGy2B9ZNKKElccPcYs8fS5Pr/eetuz5JOgA369g61wLdwenF94zGDJxkINz6k9A/\n",
       "z3sD5hGvivw8vbcBkG2t+8a+Rn6H++V9nRmffXZ1iwB/vSeY1xA8Ptd/xexfEEIa4AinxZ5OBkl6\n",
       "7iyHh/5swdkaeyRWja6kglLFJKJQh9ey6RQSw/FtQOq1jtSzPQxBOBNI1Z5TISQznveQabnKccr3\n",
       "aTmZO5hw83y3z3dWhXE+u9beD4ds9zKnGiENLsneKc7hL+t893EdQgZ1KxlQ6Nrq45uwQ6nlen+N\n",
       "8/r7GJod5uw0i6GLapxxhhZ7CL5+3hwXz6832AdUd/mIs/PkYsG57glo1LGr+zqsJzpBXQP58sER\n",
       "ai9WH7PWNTfg1XERtkHw2aHPJ8fReKghVBekzPw9Hgt6OxKSKpL7RgDoCfx5AOf9nbLClEqlUqlU\n",
       "KvVA+YMplUqlUqlU6oG+ziVHiJSYI1S6Kb9Zhl0on15BWOtWSux9dxNcSYnXXlwdgY6Gz9kLp250\n",
       "gIF0cOgEHGQw21k8cz/0csadJ5LUeVdVsYRsCNkUHEGGQ94vr4Yy6JMUXEOc64CzNsvsFc/zp/YJ\n",
       "DMiM13uOLpb9OR7L+6AH+3mFML0hDvWjIWrBhagLTASoY47yfkh287uJIe/3//vMMRVK1F/wbxr7\n",
       "FOp6E/GGnNL6/nVVhjPW1e2L7JFIMF3z2Tm1LO/Y1zHLuAM32cOtBj3ZM63FqWepX4zW3Jz3PuCB\n",
       "oivjsyegNQYzcj7a5yPWD3tVch4N+5tc7zZ7J4LaF8NAwSwaBEW14lJe45aKgSUuZoGQzSY4AAAD\n",
       "C0lEQVTaFy7OA9FbLZ/9BMP5/CyG/OTxHtCpLFw3rw5b5qyO1+r56hhDIiM59YAD7I01Ttfp9Q/u\n",
       "m2FN2+8+jreS++71NTgQ7691t1M/uHy5lCJD1wT7dIawZNaXgbHZ8z7i3xOOQeflkd6nA9huHH4v\n",
       "7DkrTKlUKpVKpVIPlD+YUqlUKpVKpR7oy5DcBm5oKbNZfrMkaM8se6zpkhrtG3O4ccmFqq679g1m\n",
       "A7HZ98kSnyXI4JKidCsyELFQpNUZF3f+f16KXj8JKbScPNnTatdxhTvmC8IOG3s6rToWymtWUKDl\n",
       "2xDWCM6cgwOuvM+uE0UHBtcpOBJXg0FBEjjv+iaOF900loE9dUtwT5bnxQGWu3VbjgPfnzq1GX2W\n",
       "k50jteO3ff6/aSz1n8/F5SUitMoeQ+qK4nm73zutquK1MrzOMNCICnTVic6FIPcdN5q+jpbZPQYx\n",
       "Pe7PdS2oyrL/f/7GsFZ7/RlQysfxH4ZyigGepZl+eCsOokWnm70zwXD7pmtXhKkLivcx5LX1OzI3\n",
       "9/tzoq7uY5xbgOvY04EV1mO3SHBxxWf2ngvbAiJH529le/xBK5++/7nP0utbcXF1jN8RB9jbUsIX\n",
       "Z66394YQMBvm9f3+es4/r6Xj1W0vwUUaMl1v8Kqu+E8CKr0nBvddfCeOj79lTRhx5o+sM+GzDFTm\n",
       "Xt82v3cts8KUSqVSqVQq9UD5gymVSqVSqVTqger9M9tLKpVKpVKpVKqqqqwwpVKpVCqVSj1U/mBK\n",
       "pVKpVCqVeqD8wZRKpVKpVCr1QPmDKZVKpVKpVOqB8gdTKpVKpVKp1APlD6ZUKpVKpVKpB8ofTKlU\n",
       "KpVKpVIPlD+YUqlUKpVKpR4ofzClUqlUKpVKPVD+YEqlUqlUKpV6oPzBlEqlUqlUKvVA+YMplUql\n",
       "UqlU6oHyB1MqlUqlUqnUA+UPplQqlUqlUqkHyh9MqVQqlUqlUg+UP5hSqVQqlUqlHih/MKVSqVQq\n",
       "lUo9UP5gSqVSqVQqlXqg/MGUSqVSqVQq9UD5gymVSqVSqVTqgf4PWsGH6ExOr/8AAAAASUVORK5C\n",
       "YII=\n"
      ],
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1139c2518>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = softmax.W[:,:-1] # strip out the bias\n",
    "w = w.reshape(10, 32, 32, 3)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "\n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}