{ "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": [ "" ] }, "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": [ "" ] }, "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 }