Vanilla - SVM Classifier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vanilla SVM Loss\n",
    "\n",
    "Built with reference to http://cs231n.github.io/assignments2017/assignment1/ \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": "markdown",
   "metadata": {},
   "source": [
    "### Import Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\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'\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.core.debugger import set_trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((50000, 32, 32, 3), (50000,), (10000, 32, 32, 3), (10000,))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PATH = 'data/cifar10'\n",
    "X_train, y_train, X_test, y_test = load_CIFAR10(f'{PATH}')\n",
    "X_train.shape, y_train.shape, X_test.shape, y_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(49000, 32, 32, 3) (49000,) (1000, 32, 32, 3) (1000,) (500, 32, 32, 3) (500,) (1000, 32, 32, 3) (1000,)\n"
     ]
    }
   ],
   "source": [
    "num_training = 49000\n",
    "num_validation = 1000\n",
    "num_test = 1000\n",
    "num_dev = 500\n",
    "\n",
    "mask = range(num_training, num_training + num_validation)\n",
    "X_val = X_train[mask]\n",
    "y_val = y_train[mask]\n",
    "\n",
    "mask = range(num_training)\n",
    "X_train = X_train[mask]\n",
    "y_train = y_train[mask]\n",
    "\n",
    "mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "X_dev = X_train[mask]\n",
    "y_dev = y_train[mask]\n",
    "\n",
    "mask = range(num_test)\n",
    "X_test = X_test[mask]\n",
    "y_test = y_test[mask]\n",
    "\n",
    "print(X_train.shape, y_train.shape, X_val.shape, y_val.shape, X_dev.shape, y_dev.shape, X_test.shape, y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(49000, 3072) (1000, 3072) (1000, 3072) (500, 3072)\n"
     ]
    }
   ],
   "source": [
    "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",
    "X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "\n",
    "print(X_train.shape, X_val.shape, X_test.shape, X_dev.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[130.64189796 135.98173469 132.47391837 130.05569388 135.34804082\n",
      " 131.75402041 130.96055102 136.14328571 132.47636735 131.48467347]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1d0df608d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Preprocessing: subtract the mean image\n",
    "# first: compute the image mean based on the training data\n",
    "mean_image = np.mean(X_train, axis=0)\n",
    "print(mean_image[:10]) # print a few of the elements\n",
    "plt.figure(figsize=(4,4))\n",
    "plt.imshow(mean_image.reshape((32,32,3)).astype('uint8')) # visualize the mean image\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# second: subtract the mean image from train and test data\n",
    "X_train -= mean_image\n",
    "X_val -= mean_image\n",
    "X_test -= mean_image\n",
    "X_dev -= mean_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(49000, 3073) (1000, 3073) (1000, 3073) (500, 3073)\n"
     ]
    }
   ],
   "source": [
    "# third: append the bias dimension of ones (i.e. bias trick) so that our SVM\n",
    "# only has to worry about optimizing a single weight matrix W.\n",
    "X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "\n",
    "print(X_train.shape, X_val.shape, X_test.shape, X_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SVM Naive Loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3073, 10)\n"
     ]
    }
   ],
   "source": [
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "print(W.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def svm_loss_naive(W, X, y, reg):\n",
    "    \"\"\"\n",
    "    Structured SVM loss function, naive implementation (with loops).\n",
    "    Inputs have dimension D, there are C classes, and we operate on minibatches\n",
    "    of N examples.\n",
    "    Inputs:\n",
    "    - W: A numpy array of shape (D, C) containing weights.\n",
    "    - X: A numpy array of shape (N, D) containing a minibatch of data.\n",
    "    - y: A numpy array of shape (N,) containing training labels; y[i] = c means\n",
    "    that X[i] has label c, where 0 <= c < C.\n",
    "    - reg: (float) regularization strength\n",
    "    Returns a tuple of:\n",
    "    - loss as single float\n",
    "    - gradient with respect to weights W; an array of same shape as W\n",
    "    \"\"\"\n",
    "    dW = np.zeros(W.shape) # initialize the gradient as zero\n",
    "\n",
    "  # compute the loss and the gradient\n",
    "    num_classes = W.shape[1]\n",
    "    num_train = X.shape[0]\n",
    "    loss = 0.0\n",
    "    for i in range(num_train):\n",
    "        scores = X[i].dot(W)\n",
    "        correct_class_score = scores[y[i]]\n",
    "        diff_count = 0\n",
    "        for j in range(num_classes):\n",
    "            if j == y[i]:\n",
    "                continue\n",
    "            margin = scores[j] - correct_class_score + 1 # note delta = 1\n",
    "            if margin > 0:\n",
    "                diff_count += 1\n",
    "                loss += margin\n",
    "                # Gradient update for rows corresponds to the incorrect class\n",
    "                dW[:, j] += X[i]\n",
    "        # Gradient update rows corresponds to the correct class\n",
    "        dW[:, y[i]] += -diff_count * X[i]\n",
    "\n",
    "  # Right now the loss is a sum over all training examples, but we want it\n",
    "  # to be an average instead so we divide by num_train.\n",
    "    loss /= num_train\n",
    "    dW /= num_train\n",
    "\n",
    "  # Add regularization to the loss.\n",
    "    loss += 0.5 * reg * np.sum(W * W)\n",
    "    dW += reg*W\n",
    "    \n",
    "    return loss, dW"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "from http://cs231n.github.io/optimization-1/\n",
    "![SVM](image/SVM.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def svm_loss_vectorized(W, X, y, reg):\n",
    "    \"\"\"\n",
    "    Structured SVM loss function, vectorized implementation.\n",
    "\n",
    "    Inputs and outputs are the same as svm_loss_naive.\n",
    "    \"\"\"\n",
    "    loss = 0.0\n",
    "    dW = np.zeros(W.shape) # initialize the gradient as zero\n",
    "\n",
    "    num_train = X.shape[0]\n",
    "    delta = 1.0\n",
    "    \n",
    "    # evaluate class scores\n",
    "    scores = X.dot(W)\n",
    "    correct_class_score = scores[np.arange(num_train), y]\n",
    "    margins = np.maximum(0, scores - np.expand_dims(correct_class_score, 1) + delta)\n",
    "    margins[np.arange(num_train), y] = 0\n",
    "    \n",
    "    # Comp\n",
    "    loss = np.sum(margins)\n",
    "    loss /= num_train\n",
    "    loss += 0.5 * reg * np.sum(W * W)\n",
    "    \n",
    "    dx = np.zeros(margins.shape)\n",
    "    dx[margins > 0] = 1\n",
    "    num_pos = np.sum(dx, axis=1)\n",
    "    dx[np.arange(num_train), y] = -num_pos\n",
    "    \n",
    "    dW = X.T.dot(dx)\n",
    "    \n",
    "    dW /= num_train\n",
    "    dW += reg*W\n",
    "\n",
    "    return loss, dW"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Naive loss: 8.692604e+00 computed in 0.086515s\n",
      "Vectorized loss: 8.692604e+00 computed in 0.007527s\n",
      "difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "tic = time.time()\n",
    "loss_naive, grad_naive = svm_loss_naive(W, X_dev, y_dev, 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, _ = svm_loss_vectorized(W, X_dev, y_dev, 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",
    "print('difference: %f' % (loss_naive - loss_vectorized)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Naive loss and gradient: computed in 0.084936s\n",
      "Vectorized loss and gradient: computed in 0.007443s\n",
      "difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of svm_loss_vectorized, and compute the gradient\n",
    "# of the loss function in a vectorized way.\n",
    "\n",
    "# The naive implementation and the vectorized implementation should match, but\n",
    "# the vectorized version should still be much faster.\n",
    "tic = time.time()\n",
    "_, grad_naive = svm_loss_naive(W, X_dev, y_dev, 0.00001)\n",
    "toc = time.time()\n",
    "print('Naive loss and gradient: computed in %fs' % (toc - tic))\n",
    "\n",
    "tic = time.time()\n",
    "_, grad_vectorized = svm_loss_vectorized(W, X_dev, y_dev, 0.00001)\n",
    "toc = time.time()\n",
    "print('Vectorized loss and gradient: computed in %fs' % (toc - tic))\n",
    "\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",
    "difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('difference: %f' % difference) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stochastic Gradient Descent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinearClassifier(object):\n",
    "\n",
    "    def __init__(self):\n",
    "        self.W = None\n",
    "\n",
    "    def train(self, X, y, learning_rate=1e-3, reg=1e-5, num_iters=100,\n",
    "            batch_size=200, verbose=False):\n",
    "        \"\"\"\n",
    "        Train this linear classifier using stochastic gradient descent.\n",
    "\n",
    "        Inputs:\n",
    "        - X: A numpy array of shape (N, D) containing training data; there are N\n",
    "          training samples each of dimension D.\n",
    "        - y: A numpy array of shape (N,) containing training labels; y[i] = c\n",
    "          means that X[i] has label 0 <= c < C for C 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 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 iteration.\n",
    "        \"\"\"\n",
    "        num_train, dim = X.shape\n",
    "        num_classes = np.max(y) + 1 # assume y takes values 0...K-1 where K is number of classes\n",
    "        if self.W is None:\n",
    "          # lazily initialize W\n",
    "            self.W = 0.001 * np.random.randn(dim, num_classes)\n",
    "\n",
    "        # Run stochastic gradient descent to optimize W\n",
    "        loss_history = []\n",
    "        for it in range(num_iters):\n",
    "            X_batch = None\n",
    "            y_batch = None\n",
    "            \n",
    "            #########################################################################\n",
    "            # TODO:                                                                 #\n",
    "            # Sample batch_size elements from the training data and their           #\n",
    "            # corresponding labels to use in this round of gradient descent.        #\n",
    "            # Store the data in X_batch and their corresponding labels in           #\n",
    "            # y_batch; after sampling X_batch should have shape (dim, batch_size)   #\n",
    "            # and y_batch should have shape (batch_size,)                           #\n",
    "            #                                                                       #\n",
    "            # Hint: Use np.random.choice to generate indices. Sampling with         #\n",
    "            # replacement is faster than sampling without replacement.              #\n",
    "            #########################################################################\n",
    "            \n",
    "            sample_indices = np.random.choice(np.arange(num_train), batch_size)\n",
    "            \n",
    "            #########################################################################\n",
    "            #                       END OF YOUR CODE                                #\n",
    "            #########################################################################\n",
    "            X_batch = X[sample_indices]\n",
    "            y_batch = y[sample_indices]\n",
    "\n",
    "          # evaluate loss and gradient\n",
    "            loss, grad = self.loss(X_batch, y_batch, reg)\n",
    "            loss_history.append(loss)\n",
    "            \n",
    "            #########################################################################\n",
    "            # TODO:                                                                 #\n",
    "            # Update the weights using the gradient and the learning rate.          #\n",
    "            #########################################################################\n",
    "            \n",
    "            self.W += -learning_rate * grad\n",
    "            \n",
    "            #########################################################################\n",
    "            #                       END OF YOUR CODE                                #\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",
    "        y_pred = np.zeros(X.shape[1])\n",
    "\n",
    "        y_pred = np.argmax(X.dot(self.W), axis=1)\n",
    "\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: A numpy array of shape (N, D) containing a minibatch of N\n",
    "          data points; each point has dimension D.\n",
    "        - y_batch: A numpy array of shape (N,) containing labels for the minibatch.\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",
    "        pass\n",
    "\n",
    "\n",
    "class LinearSVM(LinearClassifier):\n",
    "    \"\"\" A subclass that uses the Multiclass SVM loss function \"\"\"\n",
    "\n",
    "    def loss(self, X_batch, y_batch, reg):\n",
    "        return svm_loss_vectorized(self.W, X_batch, y_batch, reg)\n",
    "\n",
    "\n",
    "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)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0 / 1500: loss 777.812714\n",
      "iteration 100 / 1500: loss 283.440780\n",
      "iteration 200 / 1500: loss 107.143580\n",
      "iteration 300 / 1500: loss 42.166446\n",
      "iteration 400 / 1500: loss 18.659098\n",
      "iteration 500 / 1500: loss 10.321332\n",
      "iteration 600 / 1500: loss 7.141670\n",
      "iteration 700 / 1500: loss 5.744095\n",
      "iteration 800 / 1500: loss 5.269255\n",
      "iteration 900 / 1500: loss 5.201265\n",
      "iteration 1000 / 1500: loss 5.644797\n",
      "iteration 1100 / 1500: loss 5.008502\n",
      "iteration 1200 / 1500: loss 5.439898\n",
      "iteration 1300 / 1500: loss 4.810589\n",
      "iteration 1400 / 1500: loss 5.589985\n",
      "That took 8.689837s\n"
     ]
    }
   ],
   "source": [
    "svm = LinearSVM()\n",
    "tic = time.time()\n",
    "loss_hist = svm.train(X_train, y_train, learning_rate=1e-7, reg=5e4,\n",
    "                      num_iters=1500, verbose=True)\n",
    "toc = time.time()\n",
    "print('That took %fs' % (toc - tic))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1104ce2b0>"
      ]
     },
     "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": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training accuracy: 0.370327\n",
      "validation accuracy: 0.388000\n"
     ]
    }
   ],
   "source": [
    "# Write the LinearSVM.predict function and evaluate the performance on both the\n",
    "# training and validation set\n",
    "y_train_pred = svm.predict(X_train)\n",
    "print('training accuracy: %f' % (np.mean(y_train == y_train_pred), ))\n",
    "y_val_pred = svm.predict(X_val)\n",
    "print('validation accuracy: %f' % (np.mean(y_val == y_val_pred), ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 1.000000e-08 reg 1.000000e+04 train accuracy: 0.220612 val accuracy: 0.214000\n",
      "lr 1.000000e-08 reg 2.000000e+04 train accuracy: 0.221776 val accuracy: 0.230000\n",
      "lr 1.000000e-08 reg 3.000000e+04 train accuracy: 0.226653 val accuracy: 0.231000\n",
      "lr 1.000000e-08 reg 4.000000e+04 train accuracy: 0.250878 val accuracy: 0.253000\n",
      "lr 1.000000e-08 reg 5.000000e+04 train accuracy: 0.244673 val accuracy: 0.261000\n",
      "lr 1.000000e-08 reg 6.000000e+04 train accuracy: 0.264980 val accuracy: 0.276000\n",
      "lr 1.000000e-08 reg 7.000000e+04 train accuracy: 0.280000 val accuracy: 0.289000\n",
      "lr 1.000000e-08 reg 8.000000e+04 train accuracy: 0.280224 val accuracy: 0.282000\n",
      "lr 1.000000e-08 reg 1.000000e+05 train accuracy: 0.296816 val accuracy: 0.311000\n",
      "lr 1.000000e-07 reg 1.000000e+04 train accuracy: 0.372163 val accuracy: 0.377000\n",
      "lr 1.000000e-07 reg 2.000000e+04 train accuracy: 0.381122 val accuracy: 0.374000\n",
      "lr 1.000000e-07 reg 3.000000e+04 train accuracy: 0.382286 val accuracy: 0.398000\n",
      "lr 1.000000e-07 reg 4.000000e+04 train accuracy: 0.377776 val accuracy: 0.382000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.366102 val accuracy: 0.375000\n",
      "lr 1.000000e-07 reg 6.000000e+04 train accuracy: 0.369184 val accuracy: 0.383000\n",
      "lr 1.000000e-07 reg 7.000000e+04 train accuracy: 0.358531 val accuracy: 0.375000\n",
      "lr 1.000000e-07 reg 8.000000e+04 train accuracy: 0.361347 val accuracy: 0.366000\n",
      "lr 1.000000e-07 reg 1.000000e+05 train accuracy: 0.357449 val accuracy: 0.371000\n",
      "lr 2.000000e-07 reg 1.000000e+04 train accuracy: 0.387510 val accuracy: 0.382000\n",
      "lr 2.000000e-07 reg 2.000000e+04 train accuracy: 0.376306 val accuracy: 0.390000\n",
      "lr 2.000000e-07 reg 3.000000e+04 train accuracy: 0.363796 val accuracy: 0.369000\n",
      "lr 2.000000e-07 reg 4.000000e+04 train accuracy: 0.361510 val accuracy: 0.365000\n",
      "lr 2.000000e-07 reg 5.000000e+04 train accuracy: 0.365735 val accuracy: 0.376000\n",
      "lr 2.000000e-07 reg 6.000000e+04 train accuracy: 0.363184 val accuracy: 0.365000\n",
      "lr 2.000000e-07 reg 7.000000e+04 train accuracy: 0.358000 val accuracy: 0.371000\n",
      "lr 2.000000e-07 reg 8.000000e+04 train accuracy: 0.355469 val accuracy: 0.359000\n",
      "lr 2.000000e-07 reg 1.000000e+05 train accuracy: 0.343184 val accuracy: 0.341000\n",
      "best validation accuracy achieved during cross-validation: 0.398000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of about 0.4 on the validation set.\n",
    "learning_rates = [1e-8, 1e-7, 2e-7]\n",
    "regularization_strengths = [1e4, 2e4, 3e4, 4e4, 5e4, 6e4, 7e4, 8e4, 1e5]\n",
    "# results is dictionary mapping tuples of the form\n",
    "# (learning_rate, regularization_strength) to tuples of the form\n",
    "# (training_accuracy, validation_accuracy). The accuracy is simply the fraction\n",
    "# of data points that are correctly classified.\n",
    "results = {}\n",
    "best_val = -1   # The highest validation accuracy that we have seen so far.\n",
    "best_svm = None # The LinearSVM object that achieved the highest validation rate.\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Write code that chooses the best hyperparameters by tuning on the validation #\n",
    "# set. For each combination of hyperparameters, train a linear SVM on the      #\n",
    "# training set, compute its accuracy on the training and validation sets, and  #\n",
    "# store these numbers in the results dictionary. In addition, store the best   #\n",
    "# validation accuracy in best_val and the LinearSVM object that achieves this  #\n",
    "# accuracy in best_svm.                                                        #\n",
    "#                                                                              #\n",
    "# Hint: You should use a small value for num_iters as you develop your         #\n",
    "# validation code so that the SVMs don't take much time to train; once you are #\n",
    "# confident that your validation code works, you should rerun the validation   #\n",
    "# code with a larger value for num_iters.                                      #\n",
    "################################################################################\n",
    "\n",
    "for l in learning_rates:\n",
    "    for r in regularization_strengths:\n",
    "        svm = LinearSVM()\n",
    "        svm.train(X_train, y_train, learning_rate=l, reg=r, num_iters=1500, batch_size=200)\n",
    "        y_train_pred = svm.predict(X_train)\n",
    "        y_val_pred = svm.predict(X_val)\n",
    "        training_accuracy = np.mean(y_train == y_train_pred)\n",
    "        validation_accuracy = np.mean(y_val == y_val_pred)\n",
    "        results[(l, r)] = (training_accuracy, validation_accuracy)\n",
    "        if validation_accuracy > best_val:\n",
    "            best_val = validation_accuracy\n",
    "            best_svm = svm\n",
    "            \n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1d1ba2dda0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# Visualize the cross-validation results\n",
    "import math\n",
    "x_scatter = [math.log10(x[0]) for x in results]\n",
    "y_scatter = [math.log10(x[1]) for x in results]\n",
    "\n",
    "# plot training accuracy\n",
    "marker_size = 100\n",
    "colors = [results[x][0] for x in results]\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.scatter(x_scatter, y_scatter, marker_size, c=colors)\n",
    "plt.colorbar()\n",
    "plt.xlabel('log learning rate')\n",
    "plt.ylabel('log regularization strength')\n",
    "plt.title('CIFAR-10 training accuracy')\n",
    "\n",
    "# plot validation accuracy\n",
    "colors = [results[x][1] for x in results] # default size of markers is 20\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.scatter(x_scatter, y_scatter, marker_size, c=colors)\n",
    "plt.colorbar()\n",
    "plt.xlabel('log learning rate')\n",
    "plt.ylabel('log regularization strength')\n",
    "plt.title('CIFAR-10 validation accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "linear SVM on raw pixels final test set accuracy: 0.375000\n"
     ]
    }
   ],
   "source": [
    "# Evaluate the best svm on test set\n",
    "y_test_pred = best_svm.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('linear SVM on raw pixels final test set accuracy: %f' % test_accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAADfCAYAAADmzyjKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzsvWmsLFuWHvTtmDJynvNknvmOb6yxq9qqbrfdLYwMBkRjgRASshsLhBHGEpYBG1l2t2hkkLBAyAIhg4zEaDAWEuIPWEbqpt109VCvqt54p3PumXOeMyOHyODH953i9uvqqpdVxX31bseSrs49JyMj9l577djfXnutb5koihBLLLHEEstnX6xPuwGxxBJLLLH8aCR+occSSyyxvCISv9BjiSWWWF4RiV/oscQSSyyviMQv9FhiiSWWV0TiF3osscQSyysin9kXujHmZ40xF592O2L58RZjzKkx5o99l7//jDHmoy3v9V8bY375R9e6WH4c5bM8zp/ZF3ossfwwEkXRr0ZR9Nqn3Y7Povx+i2Qsn77EL/RYfo8YY5xPuw2fpvxB738sP3p5WTb1Y/9CFxr4y8aY940xfWPM3zbG+N/lur9kjHlqjBnr2n/mhc9+wRjzfxtj/iPd48QY84+/8HneGPNfGWOujTGXxphfNsbYL6uPP2oxxhwYY/6eMaZtjOkaY/6mMeaeMeYf6PeOMea/M8YUXvjOqTHm3zHGfAvA9BV7qX314/bzcZfdd+u/MeZLxpjfkU39HQC/x+4+67KtrRhj/hsAhwD+N2PMxBjzb3+6Pfjh5XuNszHmnzTGvGOMGRhj/qEx5vMvfLZrjPlfpLsTY8yff+GzXzTG/F1jzH9rjBkB+IWX0pkoin6s/wE4BfAugAMAJQC/BuCXAfwsgIsXrvvnAOyCi9Q/D2AKoKHPfgHACsC/AsAG8K8BuAJg9Pn/CuC/AJAGUAPwdQD/6qfd9x9QXzaAbwL4j9UfH8AfBnAfwD8KIAGgCuBXAPwnH9PzO9Jz8tPux6dgP7+r/wA8AM8B/JsAXAD/rGzolz/tPv2Y2Mof+7Tb/yPSwe87zgC+DKAF4A9JV39afU/oPfPbAP6q7nEXwDMAf1z3/UXd5+d17UuZU5+6Qj+Bwk8B/NkXfv8TAJ5+fEJ+l++9A+Cf1v9/AcCTFz5LAYgA1AHsAFi8qHAA/wKA/+vT7vsPqK+vAWgDcL7PdT8P4Bsf0/Of+bTb/2nZz8f7D+CP4IVFX3/7h6/YC/2HsZVX5YX++44zgP8cwL/3ses/AvBH9ZI/+9hnfxnA39b/fxHAr7zs/nxWttXnL/z/OYjEf5cYY/4UgL8A4Fh/ygCovHDJze1/oiiaGWNurymBK/O1/gZwRX3xmZ8lOQDwPIqi9Yt/NMbUAPynAH4GQBbsY/9j3/2s9vn7yfe1n+9y3S6Ay0iz84Xvvkryw9jKqyLfa5yPAPxpY8y/8cJnnr4TAtg1xgxe+MwG8Ksv/P7S59OPvQ9dcvDC/w/BFfU7Yow5AvC3APw5AOUoigrgNtvg+8s5iNArURQV9C8XRdFbP5qmv3Q5B3D4XXzgfx3clXw+iqIcgH8Rv1c/ryr15ve0nxfkxf5fA9gzL6zy+u6rJD+orbxKdvK9xvkcwL//wnuhEEVRKoqi/0GfnXzss2wURX/ihfu8dD19Vl7o/7oxZt8YUwLw7wL4Ox/7PA0qrw0Axph/CcDbn+TGURRdA/g/APwNY0zOGGPpUOiP/uia/1Ll66CR/gfGmLQOAH8aRFoTAANjzB6Af+vTbORLlu9nP99Nfh3AGsCf1wHpnwTwk/9/NvJTkB/UVpqgz/hVkO81zn8LwJ81xvwhQ0kbY/4JY0wW1N1IB+lJY4xtjHnbGPPVT6kfAD47L/T/HnzpPtO/3xX0H0XR+wD+Bjg4TQCfAw+/Pqn8KXAr9T64tfy7ABo/dKs/BYmiKATwT4EHW2cALsBD4l8CD3mGAP53AH/v02rjpyDf036+m0RRtATwJ8Hzlz6ow1dKZz+Erfx1AH9FkR9/8eW1+Ecv32ucoyj6LTCQ4m/qsye67kXdfRHACYAOgP8SQP5ltv/jYn636+jHT4wxpwD+5SiK/v6n3ZZYYokllh9n+awg9FhiiSWWWL6PxC/0WGKJJZZXRH7sXS6xxBJLLLF8MokReiyxxBLLKyIvNbHoL/zF/zkCgE24AgB0vTHMfB8AcLQOAQCz1AgAME7dBwBUgt9BOCGtyrjF5o4S/H7G499nC96/kjZA0AEAnHhZAEAuzR1INZMDAAx6A7hzfsHKcT3rhHUAQGM9BwBE4RpRwgUALBz+rTTjs629JADAGfNnfzmHl+f/bacGAPgPf+lnP0n8OwDgr/25v8Yc7KgLAJh2dpHJM1chs5/hRZct9gUbAEDL38CZe2xHmj+z7SUAYP3FAABQ3LBP87kHJ5wBADbX/L5dYo7V5Zg6SRsH6yR1kYt4v8sJf97J89qn/j7KnQkAYLSXBgCklnzWZs3+zzocj+U6wDLLw/7EzRMAwC/+j//ZJ9bJL/3Vr9JOShzDctLBuUP9uAP2q2SxLa32FADgmT7maVLTDJe0Ac9moFIwZXvLd8b8fegj9GhnlfWbAIAJfpO6cO8AALqjKwyfJ3ifIpselfisyOdzGs9H6B/QLtpt2mTS5rU5sYEUc8xtC+druDaf6UyL1Mkv/son1gkA/JU/sh8BQLF6zPtczrDwOAazHeql2GObEw7HIpnKwHgbtY1j2k/T/v0s9bt5fgIAGPh17IdNAIBxaXtXC9q/73CM7wd30Sywr3ZOdjnnM590OWf21lPkQ17fvMe/ZZac376u/fZzjp+p2wj6bXZwQFv7S7/+O59YL//Yn/n5CAASHhV+lAQ6RT4rFVE3q4h2kE/wmYtlgLyC2CY+5wCMdJTkd5/ePAUAFAILxQdMY7jVY3fI+bmzoh4dbx9zw+8F4yEAoLauAgDGQ+o8TF/hzGPf1xPaQcqnHVQtpkUMzpiHdGlVsd/5Jv/vcV7+g//p/BPpJEboscQSSyyviLzc1P+VVrgJf5Zqa1x5RFOXPlfnSv8NAECU+IDXRllEWa7yw0oKAJBackWfLrjClQk0cDoOUCgREeWXzGZ2xlzYOhHXrrVjYyPUNNIK2ViTdG+U4DVJK43Q8PvpEds6VzLdYkq0O8w/AgDsdz8HzIiO8/Xh9irp8X71Q7apaPkIU2rrmEgg0SDS6Hd5zd1kgOG+EMCMCCqwuPrXmse8sdfj/e0OfCH7nk1EYTyiktmMKM6kmljb3CmtpMtKit+ZDPmcHX+Bixx1WTNEX6kUn/nB+gwAcOwT1V3CRuQye/ostxUIBQAsikQ1Bwk2ZlCLEF2wX4USdR32OD6hTx1Fdh2tiO1qeA8BAKUNddA9oD7dIfvtlBzULnjNBw5RN9yvAQDsBTPcM+E9XNbZr12b/Spda6eY5Xc65TQObvj8zYg26nyeNnVnxu/0LbY3WrlYrWSL2e3tBADqCSYwJqMy++VnsFPi+KcsIsRhyGek8rymdGRheEUb686os8yaz78JeG1pzh1HMVMFlrJ37ZQzIT9j2DXQypdg5dT+CfvaE3i0PaHUlIfNAcfw8Ir9v67zM0dI1s3z/m47h3lEO7IKr2+tk4zFMfGmHIdWzkepT92PC7SHGtjvkxui+GTRwzTJv6UG17x2TftvJbgTxJLjOSsGiAb8/0Gb/c7rvideCQBQGn8LvSQR/9WYu/T3Q97nXpZ6KC99lITsc0LdrQHvN9ynThbpPd5/MoBTo96XznakrzFCjyWWWGJ5ReSlIvSE/NCRT6S4CFIozrlK+RZXz6H3LgDAC4gM+9MhVmuuerXltwAA813+nhtzZZ/cEM1jdx/DDhGL5/Nnvsz7XPk7AAC3t4JJ0wf4dvAeAKDrc6UtNong3KMBLvpcwS8q9MEfy0/sXHHFtcdEQDfhOfJlrqJ+uD0atTJE+t0W22lFFkxB3FFTIsyrMf3Rxwvq6un+fdxfUJdySSKdYZ9GK7Z74bK9w9EMZ6KpmO9S76WQqKlyTL/rxeoIU5f6P7ygPy9f5xnGoEp0l8104d2w76M2devKD11asBGXK7azNG9jIKr1bHiytU6yDu/nhkTC2dEdbJL0f8+1o2la3K3ly9RVopvDXoLXpDQeS4c7Gt8lkky5/I4V9jAu8j53C8Q0vR5Rkjcn0lqkAtwpfQkAEF5xh+R9lTpunrJPXtXBo/QDAMDOHv2zk4g++JsMd319ocOd4xJKYz4zvUlvrRMAMK9Rp4WQbR5tnsMY7jTCPnW/8zrvPVtRd6tmgNmKCNNPcvxbAfVT29AHXmoQnZ73nmO8x/tEwyMAQE47vfGGY2/mvwXj8X457X7Xdc6tcp/3XaVmsPtsV3POKn+pGeeRkU/Zs7WTTk1x6ZNFwB7Ot9aJO6dO11mOX872MJmyPbs6S1muOFfsMu9fsTK4CdnPqwl3kvf8DwEApxn+PdViXzJ+HdPoEgBw7XH8ndtrZuxLL3EPFYs20nFpB6UszyIWPq91wvsIkpyTuQqvtW/4jMKUtvIspF5L0xSmFb6TdlezrfTxUl/oF3MquGFx4l2bDZwyt0f+GTuT3GGndQmSmQWKS07w9owDn9J7c5akIuYJKi3rZDCo6rBwyq3zExnL7pqG6TslWItvAwCeF78MAMiMeW1OL7xvdOuobDghcjqsLOqwsLnHSRD1+ZKYBQE2a7oG/G5pa50E1zxwWW04cMVyGtWAL+5Oidvfig7T2hsOV/3bQ3zrTSqhKkMeNjhhViNO9kmXv1+uDJIWt3phn5M9owNiO6LO7fUKDywa6/Qu9eWlqRMryYkXXeWR97g9fZRguwpt3ieSgVZWXBTm6Ws0kjTWb/7OamudpDfHAIAnFX432+/BWtFOXI29leWilOlzYZ0cpLA/YVs7PidVMmJfnID9D9bUSZSxYS85fh/qQK50xravj9nvfKeMoVxSlQccj/4j9jNfvz3wsuGmeM8ww4XFP+P9TPr2kI7t22kCzT2OdXkw2VonAOBs+JItyvVjzAFGDT6v51BXvsWxyRu+pC+PWyheUFdp2Ua7TZvZHPKla0p8+aQ3FWSz7E8f/FsvFNAY2vp7Fosbtv+qz8W/1uCgOAdcMOf9EjoVvgQLXeou2tGho8M5km/z82l+jeMB+2DteFvr5PiIz7zRAX3KtoEMXWWRwzGJ0vysMGVf7EYHjSHHZXVMO+g41E1mRF019un+eB9p7K54P+shrwna0v+GfVjfr2H2lOP98A6ftZwQEK3XvHZS7aMSckwWZwwUmGX5Lkl2Oa4Vm7Z3M7fhl3i/ynvTrfQRu1xiiSWWWF4ReakI/Xan2WkSTRjXwmZJ1JfMc3WeKtwunBGVB8U0SnLHmAdc5WcjrmR1HYLld7mKmdEMt9XpghS3p/seV1ejUMlokMbha6wN/KSrg1Ohmp0aEefb8w56K6KXFPiMboYIMX1DxD7JcSXPbTaAVmH/B6haFzrc6hVT3GX4BzlMbg+mekQ3TxSOl73mtmVVK2F1uzudKqQuS6SxMURY8zWHdn1sY9S+Rx0UqdOOwj5tj4jF9IFCkih2NDF6BhFK9YTt6t87xeQbREP3Fco5bFyoXULCr9N9NPyGj65h2wf59tY6sXPs57rIsUxEWVzIxbSx5EbpEN2YsdwIZorx7aM0HmltV90y233P5u+TqzIGE/Z39w32MxVRJ5M1dRQeJGCd8//2DZHeKvN1AEBpxPuZzj4yDe6eRm3tWvIKhZUrYKdPRHpViRDcgi3/B5t2xRndOR+WnrHtoQ085+6wpkP81Yh2gCzbte8lEO3Qrpe5U97n1r7G1OHqGfuT8MaYtRR+eaIQxwdE8zsD7nADx0FgcWfX2dDWpnLBZc+pp+XeABkFPvTkyls35Y7z+J3OAccx2V/i3DoGAKS7vx+r8e8vV3IFNeq83yQc4P6ESHisIIeExcNk94gGMlv+JMo5egtaaR28D9nvgwTHbZBnWzJnKVxW2ebGFd8F0DObCpV88GyNVsR5k4kc3UcHxQouGPRcWHk+w6pwHO+mqPd2k+0M6xzDWmKCYlJho3fqW+kjRuixxBJLLK+IvFSEnp9ztb8+4kpXHyVxMSV6KPhcvRLXXMkXh0QEtbKDTYtow1hEqgfy1d7s8X7pkCgos1OBXyCCLjwnHLqyiVj2dIAxe+0CH3S5KqdcIrlEgm34aMUVfOWPkF7RTxgFRCOHHj97nOKz7syJIk9tCyUlRBT2XiyQ9MlkZtjvWpurc6f4DAlPh0xTHsqN+u/z2ioPg1eOjZuIbW+Dfckq3M53qT+TIaoYPQWSET+zpTdLh4VPyuyD1w6Qkf/Sd6ivDybU3478fIsrD6781jcDXuum+HPTlM/f4+fexMK0JD/2dLG1TkY6YKqeKHnLiRBcU/8Ps/R9fl0H7DfyzVZCC7Makdgixbav+7SbrEI6Tz1uEefVGqZCqd4T+bOX7Evp+Au8JvE+0jXuYC7SPDibPybysyoKadu1sM7x3tM+7S6tXei+Dkc3isSLBnPkB9RFPrUd6vqOqM1v7hD9nfVnOK0Qk72lBJmVwzF1dSg9mwKpAW2sN2YfJy3qMFHlLmWt8Wzb17DmbFvqIduaPeWYjnz2uZFJ4fSS450oKMjB0X0POR8zhTWyaz4jXWJ7nCTHpjMiAs6f8Nm9yh5SPSbU1D6X21olJYXOuq2m+lRDuUydjCdsQ6tGX7ffoz2Z5AVu5BHABduX8zhvxpYG8JLzq2FXkc5T3+kJbbCrMOcv+5yPj9YpjLUT8Qx3K9fahWVV48J185hM2c++DpGrPe4OrfVjAEC4Yfsypo2lDl7Tk85W+ogReiyxxBLLKyIvN7GoQhTzWkT/UDcZoZzkSrlQGv7E+QYAoDinD3s2K2DjnAIAohqR5rJK9LHT4Qq5U+Yq/Y7ThTlX+r6iCxJzdrElH3E9/TrmniJXFjr1XxD5LLWCJ8YLzAtEbqk8kfOyJQoBIfN5lvctDlZYFPms2ySSbWTHJSq5EvI/8oCN0PV1kmjmzoK6uOzyvCHITtEmYEJ2pvMFAY5Bjve7xTrJ/D6aKV48MtT7jkIycx5RzZnvoLsiuqoEOrm32f+ZKA7MOA2vQNSyCIhUBkP5RY+JYAqqoNiqz+ErLXqUSG2tk/ZUCWQZ7iS83gCJO0Qz/Ss+u/IFngs0T4kWm8v3kfV31Vb2r6/ImPYT/v6WfJb5ozQqLr83Wyg87Zg2lAm1Y0x8Cdc7fNb6m0Rtkc4cWkPep2oDqz53A6kEvx/ZtKnlV44BAEmlc5cTFUx17pJQwtS24ri0i+dz6sI4LaREi7GUg36WENnePdpnZrrABgz3XYy0Gylyp2Ei9m/hKAmtn8JIYxtOaVDHCiu+esxwzov8CYKCoqMC2t6xEuH8MXdWtayF8yT7unfGMRwrZDKnMKX2GwrZux5hniZ6n14mttZJU4l17TT7NG8N0K1yl1mosy/HM9rpBym2t+YE2FmyHcMGdyS+dtnnovHY6CwlyIVoJJRUFfH7OUV5TTZKkLwzR/aCNmZOeO3I53hsIt7fSw7RP6Q9Hj6ivocFJXr51MW3etxRHuzdRUXRQE7tbCt9xAg9llhiieUVkZeK0E2Sq2jnmUidyhlUFOPZU3RKekIkMJfvNpGPEJ7ws901EcbjBlfGNxz+PI3kJy9M0VvKTwyuuFOhbzdJVD+dPUJVfq22w2etXK6MeRErbTJAOkFEb1tEbJOyEgQ2SpseEcmuvCRqc/ooZ9geoa887jLsAld0d7+BzOK2ihXbeeUR3WyCY+pmHsAZ0Y+X6LN/oWKjg0siq65SwZsmj8GSKOnhnP18NiPCdEP+bCy6aC+JJMZ73L3cvVA0QoJROGszQhSwrUaoNhEpjnaf8dX2iH3YW24wd6nb+ze3BdQ/ubjyxVeUor5K5zEYcndylRRZ2iVNN+lSN5n519DOcKf0oMNrP5Q/NFWkbpBQ0tnoBnu71PF7l+zvcsqcBDviM82mh82G13QMn1EIqdvCRFE+rxfgzmiTGcPd1IWiJvY+4jW2RcS3TLgIRRzXj7ZLFrmVtGKmTY9RLlfdJMw+MdnimSJ68iKhaxKdJr021mMi+iDi9xo71O8KnCtX8qFPSi4yAfu63nAuBNLp4AHvl/Vc4IJ9XPlMsHri0Y5yRc7r4aQKWxQZF0LLlhF9R/0UAFB6j/OxU8/BCTiWF6PtE4tSDcZwB12RtC3X39k1LW3tnCtEwrsLRbS0Zih87XYOsO+BzieOpxyjpsNxzc4LmLlsa7IhD4FDe8pqh+o1N3Cr7MOqyD7UHOmtrbEO8iiPeO9zR7k3iucPRUvy5i6f46+BcM1nPb9Zb6WPl/pC7+rw0j1W9tk0QGJEF0ak7cy5YbhQTokaqXkG1S/QmMb9nwAAfDmiq+CixG3R6kaHXjODpOG1nl72E4eG9FAHgk+cNdoeJ5k357OWcndEXWWClZYYDDgJGmkZx5TPXN3hS2L3nD/DRRueNjqrwde21kkpx/umltx2zns2do9oDM9P+NKelNmXqM+JuFmO4HVokBcJHbBdcSLOtP1d5JRUMVsh3DAj9tcGfMnuFDjJumc0sMgqIGH4ErzpsD3RhsY/u6Dx7RcNphc0/ozPl14qzzbYl1w878pQR1YCxuZkH76x/QHgnuoP3yixamoBZsXFxLrk34YKz/QTDEG1GnMkH3MRtu4rsxacTO0mF9/KiH+3a2M8GtEVUtIkHXTlpJrSllpv5eFoG75T5DS5FsOj85A2VfdaMHItNcG+z+QCmQe89nzBhbV2N4OKDth7SujaVqI82z+cKDEMA6TlvtzYfJHcqM8/lRaTpp3GR3KpZIp8bltJZBlxISVuWTMzRZT3+f/chHOkE1GnVWWkeuZdvC93QrrOccr4nHOZmcL6wil8uVAtPbNELIHnl2zXWkmGk7AMXwe5tdze1jpZjZTF6ytrM5VBeaD2KcN8IVsphgQgxfshhu9TB1UBteoOx+03n/M+SYXODrtNZAJ+P6cENSjpB2P2YXNQQnpIu+xAoHXGfh9PqZvl4RmCOed4VUlXT9acz9UDtrPZpZLS/R6K0ltxtN0rOna5xBJLLLG8IvJSEXpmRPTXmXPVqr6WRxBwRRNlBPb6DOlZKuEIBwGa41tEQkR9MRVvwkYHWEo0OkoZPJpytcsaPqteFbPZgivyOLQwOacbwNfqvHvOFTNX4JZnMCvBW/D7nhgK00onn33E3x8Xubrefe7iA4VO/fT+9dY6mTZ1aFgm6t2r7+GpUosthYNlmkRSixqVtP56ApsSkVllwnacrOV62eMWNOyeAgCazgFGQx1sNnjt2Zho7iDF+058C8sxdykNcc4Hc6LTuVD8OFvC/pL3NBAnihKzwqoSecTXsUy6WAitt7452FonmCgBo8h7JIMUMhu2eXaXfxsquae0IpJqbYo4EtfN5YA7nGKFn+315FY5IHJzlhPUNtw2t8d81uqC4/2RQvFS31zhJiGXhM9n7TqyBYu7FyvfQEthZbc8Reu+QgQt2hQ2/K7zZAaIRqJX2NleJwAuxkT7pZAhke1kH0faWbRrnBuHTdpwoi66h3wGpZB66c353OFQu7Br2te5aAr2Vs9wKpbIlHhPqhv+frTk/d5fv479IvuWsmlPw77oAWqcB349RGLDeTh7h/q5ukc9HIx47bLEubdpF2FlOH+Dg/HWOkncpU7MkvdwbvaBhNggE0Tk5b52XQO2xc0eI5XhbnXtcM52LjhHKh5tOiHv6SyZREFcMB82dCj6bXEMyWVVclxsdjkH6s+1S1Qy0mCftph87KGZYxv3V/y5F1D/4y4f9pUEn9M8rmG8YDuS2e3cUDFCjyWWWGJ5ReSlInS7T5T7Ba3Olx8u0VgRtYxvmfG+LH/eSinZrRU2DaKEpuG1lqr11GY8sBuIA/1m6qFyn+ij+0jVa9pEU2+mRSgUGBQULrQe835rJT1M1kQRD1KXeG/KlbWXJfKxrnQ4oQO77AXR2th/gIalg7R1d2udJEMRCYGoa9BvY36jFH+hrOya/vrFMyH2N2twevys02M/0w+I1MryE59XiIQOzn10Egoh7LKfh4EQZqDDMT+PVIk+77Sr8L0LIqxxXhVnogkWCiOsTKjj8g7vsw9+Z6Q0Zx8TDFpsz9h+tLVOui5tYNKhTqpvOZi/qzTuA/ZlAp4v4JQoqRBOcZOjnRzn6Ed+ql1focHvlhbs7zJ5F77H7xff4+Gfd60wM7EAdu8/Q0sc2Z9T0sj72jG9IWTVHS9RKyjEVGyejecMu/UO6V/uiqKglQ4Rin+87J9urRMAqOdECjai3T/cr+LJjGNRGcmHXyB6Pgt4hlKzshiJrTPUgW8o1snpl3Um0CTKPV2GyIosL3vCn5kD2v27cyLFpNXDqMKdXX/M10fJ53lEO8FEuHywQBTRrpP7tJFnZbJSFrOa3yFtsdkZwhnzUP1h5TYY4JPLpq3vqHKU//QE0wOOf+cD7jq9KnebRxbPc9ZP1yiC9u7c4/xZp4nQQwUgnIp983OOjWDKOVBRkEJYo42sFjo/uTZY5lUTIcn+JVQdzP8Cv2vyKWRks2dzEc2ViOpDUXx8PUs720cDyQz/FuS32+HGCD2WWGKJ5RWRl4rQowSRzWDG09zdiot1U8lBSvQYa2UqTbnitXZ9LBUaFop0yVLY17miVRYiDvK8HQy6qhBCcIWcTo7HSiS4a6exmjIfexQqPV2LfNEQGdszG+W7XGlLTa7CXYWBFRT9kdwlcvnwN34db/4c0ej17P7WOmmpJmRB6DZzHQBLIrG1fKYjVcxZKhSxNAMWLqMOBqrYc39GPUYpXtNb/RQAYJi+QPGc63ZVPOtzoRDj6n6pBJ5eUof5mWgRdvnZrq2ohGEDO1OmKB9lP8fvy3/vFhU6mGFfbk67WK6pn8+Xt0+iqVSJVPIhx274LIPmHfo/Mwq5LI24a7HFnX6FDvbyjHjp5YW2RaIEh9cOROW6aX+Am3NFGCRpF81DIjVboafDRyXsiULgWoRNpYfctbkBdTIv+7Bmt2c2tKXxEdHbTJEjd/MibrspAA3eb3B1sLVOAOC0TTTuukSevdHVg9vwAAAgAElEQVQYjds5Jd7166EoHxL007pzC1OaFq5DtV9Vea60Y1mrdmt+7GGmFPpRmfc5Eebb2aPeT68DlBLsx6LCvs8VdbP3JnVgfXsH6wp17tlE5hNFYV2rTsGaeWE4WNro6Uzserx92OLGEtd/W2GCwTkqa+6O3D2R75Wpb+9ypr7Z6CdFj62EsEbEcbNHPF8zT0QfvAtkfSXvvc/v1ASDV6LtGPYvgafskKczHkeU0gvt2qfRErk29eVlVEO0ooFR8tFhwJ1Es5BHJakoJX+7XX+M0GOJJZZYXhF5uRWLFJmxOxWKXIaA6FVtIbrzx1z1ivJNdjs32FGqdLKsSuEh79Npc+Usi7SrVxvDU93NdEVEUlXeLz0Tub2zwGWS93nN4TO7M65re6KcXaYXeKAiAs9FJXBH1LpNw9XU6rMqeKZahDflyl3PFbbWyYPJMZ99LZKnXIRykn7X7oL1VYuqz+nv0E8b9TNIqPBA5SG3F89vVD9zSDSSv8vdxuGohJsEzyPcstBMj+jJ2qhKz6M5fjrDz4zS5Qtr0fku6ZPdKywwKf00ACCXJ/pLWrwm9xGR++ihqk+FHfQD+kjPJ5db66Q3Uy5BSmcHvotQ9KQ3T3WOUub9ywe8ZowcVjZ10Oxz52ZviJKcEb/TlA97eWKQEb3t5YfUU2dPPtXVbZGF+2j7tCErQ19+r8lrpyLHupP74+hBPuGASTvN1DEA4IEjetYMfy+t50grZX5hto/mAAD3XBTCe4p2GkW4yrHdgbLm12LPbQv1hsUlOn2iY1e7j2hCu++lOVd2l7TxbtFCLs3d10D63td5xgcj3qO+56CjVPrkJXdQT3ZFE/CM9jmoWHDl0/8w+6sAgJnL6KtoraigR5xPfnEFR0l/40Fxa52Eu6p9OiSp2mj3EhPFflc89i8c0p/fF5FaLixjfE1bFW8bWs3fBgC0Byw+MbK5C7r34QadDM8sHJ1F2TW+G7I96iiZrMJYfB+Mhm8CANKiB4ieco7NNxNMNMfsHb5DJgPO60AROhUR4xXaXWTv0r7bybimaCyxxBLLH0h5uQjdJTKYpLjquKU5MiuuVos5sxm/kKRv+DzUKhsdY9EnmioURJjj8vfDHaVCW1w5l01gZYiW26pzuVPSSXdIVHQxzmNXMZ7W6tbXqvqPOSIM/3qAbqSYVS6U6E2IiPcz/M5Y971/CUyWX9L9+lvrZF0mwhwuuZM4t0MUtVvZwykAIBpQR1FRdSuTh7Cv+f/A5i6l2CCKzHYYcTBXjHHbfQNHB0QJ/TZ1UrGUtlcjYgv3E3jQVJX6seKFleGYVW3RjDvARvHYCKnvPaVJdxR5Mr6mOZnoAdaD3wEAPKxvb2LWjONQ37klnDpA7YS6fXSHPtlEQFRpqc5jeQh0lDVrzYgqZyqm8N4N0dKDtXYLxQjPOypgIIQ2u6FNbeoc11T/AufgmcNXbrM/60SVsxXvez5+DGfKcVhq93lfFAX+jg5xzmRjuQVWyhXIrRtb6wQAXKWnTycqYlJqIWUR+fo+fb7+DdtxXaFdrHpzuGI+WPZu6/cJqR6IBnjD37NhARMQLbsa26cioErbIrGybPQV1eXfVda0MmDHRdmZXUba55zqPRFdgmrBXunMqKoarM41sBrS3kd4srVOIlE3J1v8bibtoOq9DQAYinws1LR0tZO4etbG51LU1+VTzgWnz9qn1R598VjQn12pGHTa1Mlxjc/ynlI33bvEw/bAQRCqoMnkN/m3iGO8zNNO530PKe2IEppbpaHoThJsZ1+RP/ZxFh0VyPC97Wzlpb7Qq8c07kKbL4Yw04EnBsDNKQ8yns2V8qos4Kk7RKrDgVgZul4mOvi7AY2iYGiQD/y7WDhklgtcvuCsBQ3oos57vDYLMFe1klXEQ4q9uRJO5mLTy44RKuHkvpIywhW3Xa1IvCpdTvb+IkDCIV95OC9vrZOleMzPNCn2ol0MVK1ptNEhbYYvlPzJVwAAB3fmGIpx0lFyla8DmrEO7AYBX3wD6xoJ8S9/YYfXXIr/I6P5k4wMHIcvoL0sr8mnlFkxuOWwaWOQVLLVUFWCdIC9cRUy53N8hs3/E7t5HZAutue3Kee5UD/ralEtd3BVZH8XSpdOiB2yt6GhRKXnOFDFqO5YgKHHrfbViv19/m29yO4uMCxRT92WbKFFN0bBVd3ITRr5NXXxfo4um4y28HaH9vLYHSClUMCG1rrlmuP4ZMj7PlQKfDQZYqoXTLK3vU4AYO3zJXMjllBv7MMR7/aF3GemxBdA2OTzp5UIKb2Ar1WTtnaHdrqc0/5vAi5uB70Rhkdc9NI1julqzQXdT6s497WDnRznXV+6qygsclnVoa0zw0RcQKkB9fy8wTZkAo6XI/fK8+wY9+QejN7NbK2T6ZB2buUVJpl8E6cWwWFP4/5m5ZaSgno/fm2Eyx4XqPMrLsB1+aqsDBewYpLtb82uUdEC2lFyW0Nnt9UiBz05v8FU7pJESofiYryIJmJt9e/i81oc3xdoso4IHoIlfy+nyro2AgY63Pa2s5XY5RJLLLHE8orIS0XoF7/Fn7f8y/0HKewqpTijFbGaI0LoQnzASx8ruVTat+n446w+41ZtNuDfTxIu8iI+WkY8pFgoGaN+JlSfTSLh8OAwmyay3jPctr53S8D1gYtcqBVyV2naYhcqiHf6NizJsmzcfKiK6HWztU6siDsHs+CSHrgr5HUgtVZf1gslv5T5zOyogElBpELSSX+gaifisbZ2iJ5e31TwXobo4fVAxEsXqiVquOtYRh7cNPWdBvXvPCGyilQRfjxaIi23RzfDvxUIYOGXiPQaM4WmWV/COGBCUaG4XcUVAOiuecC42eM4R+sFnFt+bqjWJTdICGU/a3sXU1sVmISoZiKqqthsaPNI7rLmFAHETmlkZ1kSv0WLdwEAq1oK3SXR1f0Brx2KDXCd5XfK4wnSNep9KnuZJ+UCS7Itky4xkwsP3lBJS/b2CWgAENWJvkvvsl29exlkxBRaWCu5bsRdwMjRIffzDAY+XRCVI847s6S9Jj0dUHbkMiskkVfSy3mXaPKgLBfSIW1oOhzCyilET66Dk4qqeMl1s3jPgWfTRjba8dW0u4mWRJzBjN9NmACLJQczWf4B6gloJzhVUpLdPMOdu2xPTjltU0uEWz26gQbDNeZpJWeJ8Mz4HOPFUx2WKmTYTnoYptmX2oS7i6TYKveG1GMnnYQr70HLpT2Uz0V2N6auErtjnGvXG5Spy7RcaHtv8b6TJu+xmCxRStGeeuJX/6QSI/RYYokllldEXi4fusVV50z0o8f9FjylHV8pxbyoyugpW9Su/hFOM0pOUdLQxOd3qqr1l0jx85PRFZ4INmbXqhEpBHuqtF1/6SGSHzYbiQgsED9xgsgn/SWDxZjtKYeio/X5/fEpkbQtSttqKQk8WKmtp1vrxK0SdS0Wqqo+qeNKlV/uy5fuHMrvqOSRU3+NvRlDntYREUH1nM8O2+zLXIcq63Qd9xVuN9wlwgxEYJbLimZ04iOa8JqSKAUKFk2jp0SQy2wHni1fvqqozzK8ptuh3taKncs2PGxO6BdcFr60tU6CiQitRDRlh3OUsxzPpepFmi7Rd5DnTxN4sBZsq3PM+4Qd7ryuLUK1zm+z/Yd3dpHaMNwvlRMnvsffs8dfBAC4iTGcJsNHr8aqlfoV6tRZiw5i4yG4Euf6Pf5c7XLsdq+UdCPf7nyUgltSRZ93b0Mjt5PpUHz9XxFN7aWF0Yzj1vM/4GeBzqdCHZCkDuArVf9a42OL0GxsuAvbKXNXsS6UYGc57/wm+5Mo8LOF6GCT+d3vkGktV8fUx/s6XA+pF++uj9yAc3RqaLs72r1dramD0YK6zfkRJjorao+2P4Pq+7TFrCidqzsnGIsqo7Evug6Ria0/VLWkYIO994jI819VktSpAiIy3PHMk9TD+sagkeJnlsP+uUNVz3qT/U5eG0SgTiyb86df4jikDQ9bJ8M9uB7HIXvGnYK1x3amHyn5TO+8ZcJGpOpaodmODz1G6LHEEkssr4i8VIQeekSV6Xe4Uk6zFUA0tFPRjtpJrlqnCnOq7T5BdaJEIqW+e3n5u5b8+0ShS3YjheKC37Pkqzvb8KeR7zXbXAA5rqIfDPk3RSsiEqpd2MDBBVHn/J6q3qveYfVtIhUxXWJ8Okdhl4jpt6+rW+vEq4ja9kY+WKQQqF0dFf3othiKmAiIWDPFGdZ7RCbDp9odKCzo5JJ9e33E9n5g97ESKZoH+m6zbaKleZKIIxwPvoMETIYot+nTx4iA/shSb4n5FVFIXzVcvQ/ZnpHus1FSUrfXgyP9fMXeDmEAgLPmrirU7ujqsI5jVXW5uSFyWd3Sn54T3a3vrDBYMLJp/MG32b+8qHGVLFR8Q0lEgyF21YdANlQGUdKmRBtw0ylU3NvanbSp2WOiy+UO/aKhn0XpgGOUWnGMwhbb1474rLcV0vphcYnsE4a0PVL9y23FFZFdoD53bgxmS+7sRkLbOek9XTsGAEyTNlYObaJYYKLazTOixsM73GUGqpvb6CYw2mfUyFGb/VmEKqri0e7TIw/9Mb/XnNBPXEkTeQYZ+cBbNjKRCMFUB/VUSVX+eyKe82n3J9kEXuuovudie/rprEOdLK6ph16mBm+luqBLnf/MdaYiOuVCM4Wp6uDK1Y+sinQYVZxyBtTDLLjBuqkiN1X24U6N7fzoQ/6+s17iVEVjDo65g18qumkTKXosNcYox3YUNrSZ8W3UVIpteaSdYDoXYSk65kImps+NJZZYYvkDKS+XPjcgwi7Ib2zWA1gLkbznCZMTEyHsItHVwNuBMyFK7uW5+mU2QmtjLq+2/MjF+QbKUcBiRX+cX1Da85i+sW4qQHrFVbioONVWmytkKOpRtA9waRN1zpRQVC8TAU27vPaycQoAcOp1TJqK0DHbr4+2R9QbzjkUUfoSKaHrhU7DBR7wfMr739/pYPCRYnZVJ/RKSSsNUcWeVklUdTdq46RCpGkvhRruiQr1UhFB+2Osn3IcRhH76S0VzSP60+HawrigiI4L6qmdpt82fVvSTPUZ1/4cOVVNN4rL3UZ6AdFd8TFR8/HsPcyPWfPTpOkbfj3HZ/2milB40xGKbZ2xbFTN/n0VtlBN1fSK7Vx31kglaSgrW8o9oE0mV+LcnVUxUg3KbIJ66gjx5Vbsv/EzSII7pdRUdSdB33nhDm1imiDSPfhoiHVdyUfvnmytEwD4ULU8l6qjmptu4N4mhymWOZVjW+cz6q6Sn+H0OedWFexb7iFzPkanjGu3Vc83kVvhblskeUnqrFDgNQtRSswPXNiP+fyyxR1LI0sU+mxHURvJBt5psf9/+PMiqXqHevkwwfvd0vTaLQczFZmwrdLWOimLYC5R5f0vChOkHnHuzmV790e85j1FtxVqV5hzWFDMMlU/GPIdUxNNQlfROdn8EdaZdwAA/oUIA33OkboKsJx/NMfRkcZ2zPdFWFRZubfpF5+fZpHIca6arug1bovu1DgfyyXqLJhMYR2qBuuWJehe6gvdEgdLf0q3SqG0RNIX/3aTB1fG5zUPlDgznS7RujXgueoHKnGkeMzvDlU39NFyjcyGg2l06DL7Jp9dzHDiLXwLxuNBlZPktqpQFFdKnoZdSeaB1jEAIKmswL7LF1xYUjHYaw7YbmKNjxo0yE1z++K/tfrP8D87bGjvcheXlVMAwOix2CAdGnqhxJf/unuMUcBtcz6p2EElaz2S6yV5w4OXq9Qlch771c6wL4dPNGmVMZuduAhVbWamLMsR+PIed+l6yUV5PIr4Ipor6aqs0LixXAgLHaitmiHwOieTJ66VbeQsRwMfqdZiOagip7bXJ+LS7/L3fF11Zd9Z4FlKIZJpLlxpsQh2J3yJJIZsi58/x3TMUDlXNTPTKuBrVzjBr9tPUGywD/Mp71NI085W4rlJDG3MPL4s9hOqwKPall3xyGT7/Hu+sEFHPCGd7T1zAPCdBCFbnDVYz5Fd6MBuh3YZlsSOeE7w05k08fAB2zBXNaadR3px5NivnDKcd8IUBgrHTaqS1kL1NPuOsosvLdSrOrwcyP2lurvHETs2bQU4VtnNkbIhFzU+49B+i30REDmdBKhrQTgZrLbWyVwJZmuXNpPubjBb8JmOzRfxqaGrqbHh+DmrBA7LbHurdgoAKDQInjzVT3g74n27qQTemXBMQ4HDjOgrdzg90csvkdWicSa3cvRMLuS3VHNhJ4mNMo43x+Llv6ILaKFC5euK3MLTGtyh3Jud4Vb6iF0uscQSSyyviLxUhF5Zant7hyuRnfCRn3JlPVoTWQY7REzBhggxyARIL/j/ZJVIY6SEj5QR29+CyHHabWEWKtRP7oWiavJtLN53OUvBShOF1WY6ALtRrORjrtrRzg1WvtBnxJU2HHIFzumg8qDKlbPd3ENW/BcT9/HWOino0cMakdbN/AoYqgL9G+JKOSeacdtikFzMsS9enP4xXQXFXW2DIx1QZlWVZlrHVPvLjVK/vy0unFyL96jujfBuQERXu2KDpgkic29OVPGkcA23w/8vCkQPkeEhZDpFBDwdUWf3D7PIvKGU7On2VWgaOlBLXdK1MS9mkbsRAiuK/kFopjZQnU5/hWSP1+QUTmlyRJtGad2BYTs3qyK82yQh1UfdDDiGN3XqKnnYQLHBZ6TE012cEdUPwbHfqZRw7StpSXQSKXGo167F2yHmyPb+HLMx9Z6+3p4jHgDOLrmztNNsR35vgBuFktaVTLXJa8eSYJvvlV2klJY+ddnW9h0eGuct7oAuJ7TpaWaI15Sxlfky52PzjLa4OxaaDDdYyvZsQ3vsKDGoFik8MLlCSjpPT8QMOeX3kys+M/Tp/tjJnqGvsbVn26FRAIi0a4mWSuhZzXCtg21vecw2G7l0JtxZpC0LiyTny50zhrZOtLPBkhWn3plr/LJn8JrUxcBjwtvwGe3LfovjeNhboSM+/Emeu42kdjQLMWRmDg2MR1u7+BXeZ/eB6AIM9bd8V56DhxMg5E7G9rfjh4oReiyxxBLLKyIvFaFfKovV8fjYI7NCJ69qPAojq6e5Yq4ioqlouIv+XSI2uZUQ2kQ6Tp8r8UWeHM6Hk29gpao8JwFRu53ks+YRUUXOBqodrp5ekeipueB36m/w92BWwmQs7nXDVT2XU1KNDkQyCa6FZ7MV3Omv8G+zu9srRUw/H4pvOptzsFHIpn3FtuflEzyf0j9X3/8JTIfcccz/vmqy/hz7V1RF+kCJHFYnAR09YCRGxwehWAwLPGd42tlDakB0NdwXv7e44TszIoWN08WuKhK1VVs0L177/oDPbm+0k4ju4I/IHbr31nZ8zgCwbKqii6VKODkXF2UisLz8maUknz3Y8Hwh6Wywr4PYbJY6eK6QxJbNvn1un+gpeD6F4/B+qSzHObo9P7GJmopOBatA/nWRYS0f8JqNwmjXjQl+rkDE+dymjab7StnO8Ls7h9Sjd+bCT5Do6mJ8vrVOACCdY1/FdwWvm0L9NbYtNVbSUZ8Ht8kad1ybMI9Nkih2eqLamNppjErU11FXcbsPDewS9XLeUsq+zd/bWfZ53xqi+4i2FYrpM5kkzcbKFzpdDtFRe3KG906KUz7XUiJUhrZ3U0vCueQcsyrbH4rOVMXs+Ip9G1h9lLK3FKlEvAUlHk60W+8klqivtdsqsz2NiNd0nK/yOy35uwcBlkVeU1nxO8/vi9e+ybnX3c0iW+Q4O4EoOFJ6t4gADY83KOma4gP2czyi/tyySNvU/8UAmCVEnZDa7hUdI/RYYokllldEXipCn6zpQ/piVz7XiofSlKvp/hHXFv+aq//FkggjVWujFSrVf0r0FM6ICAdFkS/1iMAStQIyNSKLRY8+3F6KkQW+ojfKVxZqVUKc9og/bSUarYfy1RdzmN1yj18RFWcSSndXjciBQo8y7jnWt7VEhVi2kbFDVH9PO4n/Z3qJQNQGJQUTPC4q1domAgo7Mzy32L6hiLIajxmm2BYNQXWq6irFIc5F2JS6JGr6KM9n1Rfsf1gZIqUEoN6Kz3BWitypKfrodILTtBC6QvMSc36/o5qnP7EhOk3vHGFwqPOI/A9AWLZk/6OM6EmDANYToiFb4RORxnOt6AJ3pwZPlKPRSuhQoapvFtnOvOqP7r1VwPwD7uA6OpewFKLoifO8cGeGss17X1RoiztTjn3uAX2gmWka1mPaTEX223eo97dvK+GoncF0jm7EMZtmt4/8AYCJJ/wV0SYTiTuwLdpGT+c49YQiwLSLeDLZwD3nPMlXVZv3UNEaJ0TN/gPqee0D2R7H/42SiNYGtINBmrq9DADnbUWWnFBn5aVqbop07GplkIqo+5USn85aRJ9h4Za/nudY49m3kCjpnGu9va1k19o9qW+WnUJHvvjMsbjdpfd5l4g9gTcx1plHVbQi74tErSHSsLYIBA/sNDwlNDYN7d5aMyLtunYbFeegHPD73XuctJsZz7YOVd3LNWlE2vVmZNdpfX+4Et3CnLqxrA5cUYaPSjFCjyWWWGL5AykvFaHX8qr5uFESxuxt2KogPlBM8/ktvabPWM96N4nZnN9LV+lbtQdcKTMNpbBnRKAVphBF/F5lj/fLb5iQ4tmiMX1ths6AiGCliIBEQASbzyn6o2rB63OlndWEplQ8oaOM+COPceC9tA9fCRYLRThsI3vy956BfrmS76J3TrS83JX/2RD55PJEVKtuCKSIgCzFFo9zp7z0kggzJYIiWFM42jg0s7xvYVe1G1XNfnkzxGojMqkb+ndvRHqVnGqb8JqPyxMiCe8xY9w7ZSLXuepzvucSefzUZo2qcgUmze2JqC4G7FOqyHs0/Qf43BH/P5a9nIkq4U6aqOb66QwNoch2lv2zldxhVF8zaAvNBg4qFhFU/lB1IZVDEISKZffTeO9GURH3iMJXIcfKZQY/TG6DgZJFXEUS7fW5Mxwd0sZuyedSiT6Gz2jbd1I/WMUie8J7ZvLcjWXnIdA+1v1p3+GIseArpZN//qCH02f070/E2pue6QxAaL60VK3S0MCUSR/cU5z+M3CMi4riWM1ayKhe5iMlWmUuFQ1U5d/XyylsRf/k52xXIqSefFEJLLXrzJo3UJlzx3Gx2o4qFgBWhjvIRJ+2d53M4m7I3UCrycmaUIWuYqjooJkN/z4nReeUvvy6z7O7kd5R61DFRAIfi0N+L9v7DfbBvA4AmOywvVZuCqy5s/m8OC9m4k/zd5TLUG9ieaIdtstqXm5TNL91Ufh61PFg6OLpUGhetAWfVF7qC73XVaJMnh2xe+eYvkXFjlRgNn8l98f9/48/+XWdK/R6txl7Yt7r08ALjqoKnS9Q+Akqe5mmRmcdTtBGxEl9Ngq+47IpD1UIWRVcakm+CDo3Hei8FaWEDm0v+Ky9ivhBHH7njfEK1yMqPeFsH3Zl5scAgP0E3UbPEzai49uFRhWeAmVb2jQ+q5SAaMuxm+YEnih7FodKAFFlpadTB/WsDmMs6q8W8b6XAfVQtw/x3OPWuvs6r30oPpnlDn/6kx6yLssDjmt0YzmGE9g4vF/iSAdz5RsM5Pao5+9vrZOpkoceJMXp3XyKqMBxSKi/+8pO7YkDfW3SKCmjM23xBfH+QvzhRb2YVQ1rk8jhpHcKAHjDp/1dgddUVUatc77Aa1kVmV7yJTdSYW4jnvVlJo1ABZPLYHu6emsaheLd04H0uF/BgceXxeVtKbwtxVeS23Cg7ND6Ev6ai8ydPc6b5I3mjfi0W34FSbEN2ueqyJViaN49MZJmtIDm8zkEZ3zJj/b5neSIL6FUm7aS2eTQuqSd18RAOshT39ZHvJ/zxTXySbJW9m7o2srrgH8i3peCknLyWQtXyvo1re2LZ89U+i1IcPwO7RWQokvsYVksrKqfUJnRxq1CAYMe50nOIvCZLMWuWFUY6EaHylYPnSSvrYD2f5OgrhPKUn1w/JPwVDcAc/bF9QSEAoXBnpTQd6nTXJfAbLojbhcVL5835RI7WyMjPv20v10WWuxyiSWWWGJ5ReSlIvSFVuWp4eGE6/hInwltqN7fvMwm7SodOUIPHRXo29NueFjldshZEOlbCbHp7brI6GBsLC7xvIq1zlNER9Wmj+mcKCoh0rvMDVfwzS63bdnNPiwdlNoq+lvOEvFfe1w5s44OY8IminXCsEEv2FongTiQhzb7P/YHuBbVh3GIgF0hy4RC49ydHOZyowxX4sFO/RwAoGLzO0OL28T17BKzd1V/tE7dPL1zyxHDZw+CAaZVIsxjVXa6VPKXtSSqCE/2kG0Q+YzFq50QcmnM+Ex0FDpWzmC1zzEbNbY/ALyXoy4uhaL2sx6eX6u2aZd/S/2E6sl2lfK+7OC0x7/ZqjOZFlpeiuAnv2S7T+ptHJ+Lcz1JG9p/g26kwzOipyeHARJJjvk6pP5y4vz5aE1UePA0g9GBkk0G/J4rHpmwRVv4DfGCr8I5HBW2LrnbU0QAwHrFNs8vWWlrZ3Ef1Tsqtvw+27ZUeO1Mu9jEs2eAqlHtjuiy9HfJFrnZlWtrJV57f4R7F3TZzXM69Jfbq80ph918DUZ0CZbmBiyGtpqHtJXXRkm0jWzDZUjxN20eJJoC0X0wFAIeG0QjzqVsaXv3XGoittEyn9ef7QFzjqWd5STZ06Z1llTNzvkS6zTHoqUw30aV82U1Zp+WhjpJVMvYKbBdgzHtydeBbzJHe+pmOsgPtDvZ0NaCpGqzHtP+w9YGxUt+1lWVpYyKrk8X1LWb5E53+DCN6oJtXTe3C3GNEXosscQSyysiLxWhl2pEyZEqbqePgMWcyCuwuTrl99mkts9VMPM8+50DwCfis070lXgz4Ep3ZXN1LLs51GdEI/0qkVOuy1V65fI562CMTZ2I8nJChJoJ6L/vCHk6rQ9QrTGc0BJD3kZ0A/ZKKNQQpWDl4MzhypvY3gUIY/FLbgxwnpUAACAASURBVIUocO95CY9dHuaMe2KKrAhijI/Zz+kERjzqpQ7R6PKCfZqJ1CxV5Hd2wxxmd6kvL8/122lLn/JRj+EiITIuT5zNxSV1ciDGx5s3E/DALc36feq2bJQu3+C4LsSS6C8rSKa0W1EftpGJwg2zSe6udspJXBidhRzxmYHYDW/PCqxggkXI0NJIoXLzDdFbbkmUtK4RLR9ObMzz7K+T1+GqT/9ov0H7q06GmC95UDbWWcYhaAOfF7f+5XqOyrX8yK5488U5n+vx2RtPyU7jPr7l8dq7z3+wmqID1ezc2xNdwV0X3aZS/Q9VuckVgR1ENjZ2EE6IWC9yos54xt1vYaiq80o88v0peh51eNVVOGeOSPF4h/2p9wfwE5wb3xgqGGHGa+vVYwBAmPOwI3K8wZS7gntiU31XiXqFu0r2mV4iq9C+aLi7tU6ckLqwROOxzJzDdFU71RGlwF3uOoIedyZu/RsY9nkwd9+lblZr2UpGh6Xi308FK0Q3vPcsozNAhR9uQHvyu1MkxKM+3Yizvkdqg0SG4zIZD+GLTbGS5d+aI1XC0uHyRvz74fQMzTXfL14xJueKJZZYYvkDKS8VoXcNVy0/zVUwNCGWotXcdOVr1ap155Kr1SrXRl4VPnpDnviWMkRMOqRHQwi5lilhkqPP6dgRDWxZKbwKS0u+lkBGkSVFW3SkqgqSXovw6ksbrKe8T1ZUscOZkifEXJpQ8s+qt0CgJIDAam+vFFF6huJdzyYK8G1VyilwtU9liKTcgDrKYYnalGimVVRCQ4FIaEeUpo5DPXbDNdYV/q2QKKnfRKf9Lv2arUIdx1raHyWF8BWm5vfZT3NUwGrCv1V+kpErcyXe7IC7g9RcNV6rJUxtIf359mjUPqLDdi8gmhvPRyjuKplJ1XLEaIsbkT4VExEa2nF1FXFSKYvSti8SqZ6iRK5GiNJKrtpwBzLrE+mmMrxfLhPCHtGfut5VYs6aY/VcyWV3gjVOFM1Q+EB+1hl1NNvnsxbnsh/Lxe4Z2zdWGv22EuTZHlfEV/1OBp9XWG1bxGlljza8sFVdabbASlQNRvVBl2fc1QSgvd7SZQxGC0RFosVb4ru8ItPaSV4zLoRYXWu+3HAyJJVYdJWknvcvnmO44o7HLVCvPSXx3avQZkaiK15eJ1HKvs1rloOtdRLt0hAGIrCL0gWUx0qh1znQ4rn84mWOSWa+xqHChGeqIbpS0t1liePve9ydWUEToYi/nNFtaj5t2lKk1aQRwlFoZGqX/YxEb7060/0qFQQR9baryl7tDu1qmKGOki2eLUb9EGJjxuxxfSt9xAg9llhiieUVkZeK0LNdoshRnkj97nKFxQ1Xv06BCKM64Gr1REk+heUK47HiizdcaSceV+W8aiF6Nle+1GYH65aq/ayFxrJCwHMiu+qkhanNldW1+OzFlAhmatN3nR4nsRIyPQ+JZmZlohG3wx2FM1CiUTFEcUO0kZ4VttZJs01fY1JVcCaJLO7rdP5melshSIjgc+ynmdQwcolmMioKsLfgUN4mN93MlbBV9pAR6uzd8GeYJ9pK1ohKHmY6mHeorx1VUTcbIrOeLMQkhrgjWNxXfHblikhxHchnqbT51+6eoWbo25/Otj9YOJxwXOdj7qDcvAP7Q2EPRRTlr/m71+X4un4eU+1WbKXoL8e8T1q7LFt1MROejYZ2O9YXFSXyAT/LpvjMmZNDQj7n4Yz9Wiq23raE+Pwc7l/Id56+rfikeO0lddNLqErQ2oNV4X2c8fb5CgCQu61ONP48AGAvF+C3FDVyR5TLE6HkclJFX7BEWbvAsiprWTXOBT8kCvUW7Ne6V0BOETydJe87v6vqYirqsB57eHrNeewuuauMVHPVOeHYvFPax0Ge9llJUM9ZFbLx+8onWLOds2oPE4ftMD9A9M/6Q+4yogei+Y0eY6Z4cc9TQtmcO95Ki/kT/Xoa3SOOy4Nr6uZGO8msS7vdVaHh5H0P7SvuWqYtficUmn9DXGLj6CO4GyZ75SzaQ6Azu6VI5MrLBco56qIpKo6kKI+zviJj9DOTzGO+4DN9d7mVPmKEHkssscTyishLReiDFFfpO0shznEKyR0VBJgQCU98rv5pUdHOLBfre1x3Cn1lmynDc5aQT3HGlc9bzpBIaFVOceU9GKrAgBDLxSKBbFEV458wYw4qLVZ1ibC76w3mXbYro+yuhGKsh0qx1mIKdzhHb0P0Eqq26TZyqjqkc50DbBIDODX2IVL69e5PMsY56Ko82CoJd6ZycKr9ODtgG+xv0/9cTlEnZjNHKhQpVEG0ACrxtljQL52Gj3pOKFZl7j7qqLQaeJ+9roVb6jFbSH0mWtGUR6KlgyqRS2p6DNe6rZG6fWzxSn7pTEoUxosCQkdZsldETpdHRHN1w/a59hShK4KtMSMXFqIenaeUxXlO1Ohm7wKgvW1ayqy8S1QfPuMzr4cjZFTXdthnJuRehkiyfZtGjMcYJunjTCwUiy/a5k2NY5Y/oS/VbNJIGZWn23mwtU4AwL4gJHRcnf2ENdSVIh7kOKfSOuMZ3Vds91UDXo627L2hohMefdZjEbJdKxqofDTDswH7XypSrz0dVD0QB/PV+WPkdkS8ppqa6zOR5WX5cG+cQvOpzsm+wmtnis++6HEMyortnlyuMRhxjm2y21W4BwD3rs5WIp55OZUqjnO03ZnyQjIZjle04dlPOuqhOFAd1X22rxTQvlztEtKKI79+ssJaBF6LBWmyy3WdOaT4HvLyNloztj2cqDDGgs+2j+Wrv1oD734LAHAl3RYPVExG9mTlOGbWsg1byeG55Ha7/pcbtlhlg689dqA1WyLX5+RL2HzJ3lb4qFSooKh0Df9MfBApKt9XCOGpJWa5Bg382Yc+9h6qjuT7CrvSyyGvai2tyRVWG4VpJfjMUMk4T5qc5NXcECMjRroxjbSd0uHECdu79LngdNdDQKn0t5zp24gtzu3Kgs87n+aRBV9aD5Ps90WBk+HtPsMGnx6cYNIRx0ZOE7BDw87+IzTUrlK43UWIcYM6eWMio7/kd1zVhkzZCfhJLrZpi9//Wpn3Gx6Ls+a9KvJ7NK4DMeYlxnTPJPTCjJR6340i9MTomO5uf1D8YZsvxePMMQBg0u6gvmFbn1Y58Y6fab+r/gduFoszvtROVbtxVwV/W2O6xBLgd7KTMQKXL5TNN1i9x3/Ayf6NoerUThbI6WA4Jz76500+eyXXTiqZxmRCO7PrfGZKLILRpYqd79DGVqtzXD2+TYQbba0TAEgXaBdzVb6ZTK6x0QFbI+DL2skrsewJ+9cPFkjs88XTUQivpULiBR0ad85p071WB7WiDrinelkrUGA+4xinCg1AvPqPVUg87egQWnwmT+pdNFa896p9mzBIvZbGtAtryhfm4qKG5S5BXDXY3mGQEH3Fck09j7N9QPqdNDgmBSUEueKQWmZTwJDtWgz4ch3L7VNNczGwA4UBuw4shXlml7R3W4fjTbmFnSsgoWLlrSvae+Mt3ieUq3Do+Xj/mG6UynPa8pXq4VoK093IheV4Gxgl60387QqKxy6XWGKJJZZXRF4qQi+MlLwisqjQW2De1OGR4cpWKHAVvc5y1XfOXQSqTt9IEDE1b2845yp7yyw3abVw9kS8xgo/agVCSrPbJJ0Oph/ykMTJEmGEPaKZ9Yop1Sf9EqIFV9hfc/m9nR5Xyoy4sQsrIvebRg/2gFuwILs9Qp8qSWoyYZtS6QHmRSEJbcW+eKN+R0SIa/cQJVUb8jviL8jfVmIn2knsUtfFpcHhhPcZHPAaZ4c/73ls7/pmgoUq74yUOFUHD2xyT78CABjnu5j4dHGNVG8RhujWzbHtNdUftWDQn1C3ydnx1jopDxTeKvRtrjxcKsGiOKH+30uJWOya6Ls1HqKuTPRbwqWBePLPzzhWhwcc06UzwBOj/ul88vqCOyWT4njn/SwGj4i61j1Vcj8gak01xdVfT2IkF8JcNWwv9Mw7QtFJJZPA2oVTIBIrnH5za50AwOWQ/ThShftlpoKCDrPTJXb+dM427oT6GZXgzti2jFBkJAbESAfqpS7tza8ksGmyjR+FHMtDpePPOMTIJ0Jc6fD/rY4SBd8gcl2vOIdfO0/iokI7slTP9P7g/2XvzWNl2/LzoG/tXbVrnutUnfGec6c39XuvJ7sT4xhsx0pEEMKygohEwqAkCkogMRHEIgpgSCBghSRAAIsQFDnIIhYQJRYRCsGJA7Kdlt3d7/Wb7nzmU/NctatqT/zxfae5buL2q5fue/NO70+6uqeq9rDWb03f+q3fQMZ5HQlzvVKkx/wUew7L+rVPEDrDlXxfPyaLftorYVpSHuCIY+tyyP66XRcrP/GQOGC9Wi0FGgs4Rk4VnmE2oKzyoYdLRzHNW8o0VGUbZxXjvVW2MB6yr76pcBG9c6o+lYoY5VwZpc7rAIAww2tzjyjr8QFVoStFWc02DXYVVfTpk9lG8ogZeowYMWLcEJgo2izebowYMWLE+CcTMUOPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCeEKPESNGjBuCGzOhG2P+qjHmz7zscrwsGGNeNcZ81RgzNcb80ZddnpcBY8yxMeZHXnY5Po0wxvykMeZ/+ha/v2+M+cEXWKRPNYwxkTHm3ot+b+JFvzDGdwx/AsDfj6Lo8y+7IDFuHqIo+szLLsO3G8aYYwB/IIqiv/uyy/Ltwo1h6DFwCOD9f9QPxhj7BZflUwtjTExyYnxq+8GndkI3xnzeGPMVqRj+OoD0c7/9QWPMY2PMwBjzt4wxu8/99juMMQ+MMWNjzH9rjPlFY8wfeCmV+DbBGPMLAH4IwF8yxsyMMT9rjPnvjDF/2xgzB/BDxpiSMeZnjDFdY8yJMeZPGWMs3W8bY/4LY0zPGPPMGPNvasv4aezUnzPGvKv2/evGmDTwm/aJyBjzR4wxjwA8MsRfMMZ09Jx3jTFv6tqUMebPGWNOjTFtY8xPG2MyL6munwjGmJ8wxlxo7Dwwxvx2/eSoj0ylYvme5+75hjpL6pn/RfKdahx+9qVU5hPCGPPXANwC8PMaM39C/eD3G2NOAfyCMeYHjTHn33Tf83KwjTF/0hjzRHL4NWPMwT/iXb/NGHNmjPmh73jFoij61P0D4AA4AfBvA0gC+N0APAB/BsAPA+gB+AKAFID/GsA/0H11ABMAPwaqm/6Y7vsDL7tO3waZ/P3regD4qwDGAL4fXLTTAH4GwN8EUABwBOAhgN+v6/8NAB8A2AdQAfB3AUQAEi+7XhvK4BjAlwHsAqgC+FB1+w37hO6LAPyfuicD4HcC+DUAZQAGwOsAdnTtXwTwt3RtAcDPA/izL7vuG8joVQBnAHb1+QjAXQA/CWAJ4HcBsAH8WQC/8k2y/RH9/ZMaN79b4+/fAfAMQPJl1+8T9JfrOh2pH/wMgJz6wQ8COP8W9/y7AL4umRoAnwVQe65P3VNfOgPwpRdSp5ct1E/YEP80gEsA5rnvfgmc0P8KgJ967vu8Ot8RgH8FwC8/95uRsG/ihP4zz/1mA1gBeOO57/4QqHMHgF8A8Iee++1H8Omd0H/vc59/CsBPf6s+oc8RgB9+7vcfBhe83wrA+qb+Mgdw97nvvg/As5dd9w1kdA9AR22cfO77nwTwd5/7/AYA95tk+/yE/vxkbwG4AvADL7t+n6C/fPOEfue533+zCf0BgH/hN3h2BODfA4nnWy+qTp9WlcsugItIkhNOnvvt+m9EUTQD0Aewp9/OnvstAvDrtlQ3CGfP/V3H/7erucYJKBPgm+TyTX9/2tB67u8FOHl/qz5xjef7xS8A+EsA/hsAbWPMf2+MKQLYApAF8GvGmJExZgTg/9D3nwpEUfQYwI+Dk3LHGPM/P6d++mbZpb+F2u15eYXgONr9Da79NGGTvn8A4Mm3+P3HAfxcFEVf/8cr0sfHp3VCvwKwZ4wxz313S/9fggeEAABjTA5ADcCF7tt/7jfz/OcbhucXux7ISA+f++4WKBPgm+QCdtSbhG/VJ67xvLwQRdF/FUXRFwF8BsAr4Pa6B8AF8Jkoisr6V4qiKP+drsC3E1EU/WwURb8NlEkE4D//BI/5Rh/RWcw+KOdPE6Lf5Ls5uIAD+IZxwfOL9xmorvqN8C8C+FFjzI//4xRyE3xaJ/RfBuAD+KPGmIQx5scAfEm//SyAf90Y8zljTArAfwrgH0ZRdAzgfwfwljHmR8U8/giA7Rdf/BeLKIoCAD8H4D8xxhSMMYcA/jiAa7vjnwPwx4wxe8aYMoCfeElF/U7hW/WJ/x+MMd9rjPktxpgkOKiXAAIx0b8M4C8YYxq6ds8Y8ztfSC2+DTD0V/hhyWEJLlDBJ3jUF40xP6Zx9OOgSu9Xvo1FfRFoA7jzLX5/CO5S/jn1hT8FnsFc438A8KeNMfd1kP62Mab23O+XAH47OE/94W934f9R+FRO6FEUrcGDzX8NwBDAvwTgf9Nv/xeAfx/A/woyz7sAfo9+64Gr5k+BW+43APwq2BlvOv4tcHJ6CuD/ASe5/1G//WUAfwfAuwC+CuBvgwvmJxno/8ThW/WJ3wBFUCZDUFXTB/Dn9NtPAHgM4FeMMRPwAPnV70zJvyNIAfjPwN1GC0ADwJ/8BM/5m+C4GwL4fQB+LIoi79tVyBeEPwvgT0l19ru/+ccoisYA/jA4cV+A4+d5Fe2fB8nQ3wGNLf4KeJj6/DNOwUn9J8wLsKYzv14N/d0FbRXPAfzLURT9vZddnn9SYIz5ZwH8dBRFh7/pxTG+62CM+UkA96Io+r0vuywxfj0+lQz9HwfGmN9pjClry/knQcuFT9tW8dsKY0zGGPO7pL7aA/AfAvgbL7tcMWLE2AzfdRM6aGb2BNxy/vMAfjSKIvflFumlwwD4j8Dt81dB++3/4KWWKEaMGBvju1rlEiNGjBg3Cd+NDD1GjBgxbiReaKyO//jHfzACgKvWAgAQAtgNGIIlnNCkfJyj9iNR5PcFq4jIpqVQquzzu2wZADA/nfHeBO9tWT4Ka1YpU+V303ESADAZMW5VItxHPd9ggTzen6/MAQDmEU1Oo4M5PpqFfKfFd45m9LlYDnlNs8LyTWZLTBNdAMBgwt3OL3755Hn7+G+Jn/nzX4oAYDBkKIzq4gSnTpHvku3Nyue7zZpfZKwaFrKeKqR4qD6/9m/Ism6lkHUaDh1EVf5d6vD+dpIyToX0qymUfDwbcm1vjmmokMzy2iDDezuwkAbbbbe6AwCwrTXfMajz+RMaxXRzl5jNeE01NQAA/NRf+fLHlskf/C9/PgIAb5YDAKRDG1OH78ok+Q7bY7yxbn4KAMi3cqgpmk87WgIAPJdtWKnQMjXL5sYIXeRsyq2b5nOdyQQAMM6UAAC5ZRaliDIwhm3uHzwFALht3tss2FiO2Q6NHZ4fd7M9AMDTK757r8r+c+gcINFkffbv0GXi9901H1smAPCn/9pX6II4pO9LYRFhkeRYcApstzA1YvmnDsvsJjEv8O/5k6XkwWtt9SurSDP6lj+BL7PqpEc/rJ10FQAwWFPuiWCNmXb1zSH7kZvimAuyrOsguY/c6lLPYX+0brEfocW6J7baAIDaOAu3xneYHK/9o7/nzseWyx//G+cRAEwfsyw7Ww5sl32iv8V2KvzqBwCAaZPvmTUuYA9Z59mC10QltvXwkvV8dcH+4B004a5ZL1Pmd7shLRMX7pB1LDlou+wjlvpKetkBAPgHvNbqTeEE7Gu+xXaIlgUAQCNPF5DLFctSqw2RSdLMP5iNAQB/+l999WPJJGboMWLEiHFD8EIZ+qrJ1Wq85Er35iqJVYO0yvPJXpokGJgWuNZsAUiBLHs6IxMsBlzJliWyoMwrXPXf/ocPETkVAMB8yBV3dasJALjb4OpsewtAzKuZPQIADFYfslzfS3aGjoPPNMliljZX4fyCrKRmkz33HZap+GYBjpzLnp0970n+8ZDIMwZ+ekEG0yvm4fTElhtkC5ddOSI2ycaS/Q6CKuW2s+Z3y8XrrPe8z2tuUyb3kkn0h2QLkwpl/PqAzW7t8vlrU0B9hwxnvMf/ZxeUoxWQxd1z8lgtySzqIOO7ABnH1mtky3ntjpJBGWs2MaKxv7lMPuBzO9edobOC57Gs/W2Wq5zkDiC6JFt10wNMrnd7Jf0f8J7eJQvjpMh2+nBRiUh4Fku27yJie/ae0nk0lb5AO/9F/h3wGu8B2zmdphzHl+dYO3zORP0j8sk8s7wEw5nYWNMgf072vri64o93f+tGcmmcsh7dgHI5i4pI2CrTQh7rabbNeMa2GJsuUh3260VOu80ityrpj/g5ONWO7SCBfvKU5e/w/pXqU73LNrk4T2Kd5ztGOe1iHe3q5uy3c/sZEmkyzET2GQDgas4y3Cqx7gObu70gjOC12WcLd9RpvqWvz69HcPYYAOBs83kdqwzb4d/LkGM1XeIYcbfZH1a/YqF2n30h4VMW3RlZfeGC9by8xQZMHn8dXpLjL+fxeVcr7l6qeV7jnayRaWq3uuR42Qq40wne5efyrkEnInuvrNmHvXRfz2NZyhmWxe8ZhBrf69RD1fTjuTrEDD1GjBgxbgheKEN3ZtQV3XG4wndgo1airi1/yhVymiKz3PG4anXKCdxekWXP0lwpyz0yikad32evqD/u21uolbjK7zi8djuplThPVj9bFpDrHwEATgtkGLcWeyofWZo5LGB+Thb0wCGz/5xhCIfZPr/fa7IOvSCBoPUaAKBe25yNrubcteRrZHKD0wJK2gVcJd8BANh5PrfkkmEsywdItub6jezb1MgI3C7ZcioiE8rZW3h2KCbhcv22bvH5Z2PKPLEYYjEhq9ly+I7XCmSePZffD8olNDLURS8cyrTS5nMs6R1TObIwt+xjPpHe8e3NfZNWe2Q786R2Eokl7kjvCJssZtQ/BgDMDHdb6RUwXk31BLZ9cakzlifsE8e7ZER37G1UC2TLrTzL7nlkkqUMPxfmt9G6x7beDakn98Zsq6slWWF35GDniNd4Rco98Y5YtM4/MkXpaHtPsb5Ppmiui7khno65e8iB9ZoMHKQrZItBnXGxVgPKqbagDHeiBEYr7jAqdZa/02HbrOv8P9lju/XdEZZr3pfaE+NtcScUjll2v3oBcyF9+m22f9TRuUGaZ0lH7isIV1/h/UmO+c5Dlmu3yb6T3pMsBiFMjWPJWIONZTIa892lOeXvWH1ECTlrZvm888kxACDzNZYlcbiC3WIdhh2On6VDGd2tslwdquax99m7wIds49MBG65Rp4yiC14zv92Bf0X2nbdZz07Ed4dbrG+m18S8QDlHciZNB7zWanMeWu2o7fwRJhec4xbRZs7aL3RCL+Yo/GcFCq1yOcZwwEo6NifMSoHC+lCHTd+3XuPEoUC3LU5ShV123uaCHfvikp2u4TzDoqADsC4nvKS2epltHkCUlh5Su9wiTm0KvXdOQRZu62DWmyO4y0nh3jts6PUtlms1Y8cJ5nxnxUvgSZbX7GPzxEDDIhvM6fN9ln+FMMu6JxwuNEaHrV6BdZqdDjAOWeaLDK/9gW1OVjOpms5n91mn6hA58L61S1kMTx4AALam/DzfG6N7wU61MLy2n+NzM0n+73tzrHz+5hcpp2WZckx9lQvh7IjP8FYe1jNu1bcvvpF35GNjOuQgOPTVqeGhqy38/ISqhZoO/V7ZYt84b6eR1IFpcsl2sGuccGYFBrsrDXnPcVgEAqnrlpRB0rBPjiMOtuPJA9zqcwLoh2ybsMU+MFM+i/J0jvQ537mw2BfLNklGoyDVTaCB7kzgeXxXs9fdWCYA4Iwoy6s0n7lTeoTJinJZjPj+pCaJRYp9Jkz6yOgQs72m7AKPi46tuFOrfU7e+WkG4YDtvcizDTypEnoXmohTFcwPSMJWQ46fyyTlujcncVjbcwQJjrfcim1x4HAyvJSKMKE+XSmOscyQaPgfDDeWyaJM+dfafF/7VoBkJ6P6sL5hiXOCFfI9zmyFsce+m416+p9zSiLk591DEpHU9BnCCst1e6oFLMFpM7rN95RaHtbSdVx6lJ+lcXkkEjuvJZHXYmlZHD/JEcs+rVItUz/jODrJjmB7lOUkv5lMYpVLjBgxYtwQvFCGvhhydW5UtFVZhUildNAZkTWk22SBjg7jnlo/gLJM6KwCGYpvyK6WOa7+1jbvPcx8Bu6Ca9QqzaplZe7WW/Cwx0YVyw/IZnNZbkHbWbK8yylZyL5fRSHkKjq/y1V4ci7TyeAYAFAqknF8mM7jzor1Wcw2skIDADTPZFJWpGwWIYAs2d10TPaVOSQT8ipkIc6kiGT61wAAd0+4qn8YsTyLNVltEWQgw2yA/GPKNJ9lOXsW6/R0lzue1YdJlMSuC0Zqk5DPyYklR1YCw4DyqV1x5zDIsXxXb7MdcsuPAAD16Q7KRzz4iZabc4a6TFfXOjxPWjWgQ9VCfs66jHbZvqkFQ52IBQAAIABJREFU2fNeao6J2NEqz/ZsZCjbvMN2fuyTvTrWE7TWlEXC43P2Pcrxbp9qiHbzDfRd1rc0pWyGEdtF5BWNcoThkm2+p3JdggwvL9NY9x7rUM86aE14+L7O399YJgBweZ9jIhhRxThKfR/mQ46Jokzr+iXtTtQXi47BuEJ10mLG3UPGaAcoS8Ke6lcsJhAekq2nB2y/hJi1U2b/TE1HmFxQ5ok033Fnzf8jqTmr6SSeZWUKPJXxgORRvMV3zS/Zz3rpJ7AHZMfZUnJjmeQek8GupDLJD0P4Ad8dLaS+vcP65k84JkaFLLI99qfODncpuZD1tHUgeziSuW56hDLIlqNtGjBcTDiXmEeUlWOt0CsxZtfrRY7RjsvPVyWy+sLxLiCbi5JUZq00ZZpts10HZapNw06ETOoYAJAKNhs/MUOPESNGjBuCF2u2qMO9do+s4lbBxUIHGIFMEbshGc3RPs10sucPcDGSzr1B5rZsUL81veR6lLa5mg7cMSwdOOSkTx2JaWd16DdMZ5AskbGtF1yVqynuAKK5dOipKZw12VjRvQ0AeDrn/VFdThlikZabRKfEg9O92ea5gn2ZJ02l+452y5h4ZJh5mfxVE2Q3nSsy4GIli+mS7+y/xbpbEVf95oAyScqpwl5Psdjnb7kS2UhwQfawtyCDTdwaILniOy7KZFkmSaY38slucvk6xi6ZSl5nBiUdgu6EPFhKTFkXs79C55Ssa//A2VgmeSkkR3usv/cVBwdinuhyR+d+hXU4a5AuHwUrNFLsF5ZLljTlpTjSYZSfk+5/tEDOfwUA0JPuObPNPja5xffsRxmsW2TxuQT7Qj1DdjnLUQ6VZICcLUc4m7/d36IMuimxt0vKM1m9xCuFIwDASWnzwz8AsMYcrr4OKLP5B5jq0L7q8T15nRMsQdmt8g5kmYdkh2MizJIJJyEWX5f56nqFcK1zljn7Y8UiUzdyoilmdtD22Q93dyjnC5fvjCLufLtBGamv85lBk3Udp3lGVn3K79N1jvNoAlg1tuXp49LGMhksOVZ8i+VNXOZQ0bSWL7A803c4zq9y7JM7qQ4Gau+qdnPZr7O9qvfY1g9kQBDMS5hk+by9JfvaXqQ23ufYmy9CWMxFjvf6fF5zTqEX15RR0HgCV05HkyWfV9AuoXqXslmOeLbVdspwLtkPx3rOx0XM0GPEiBHjhuCFMvR6i6whqpH1jstzFPvU6wUz6qVwm4wj7JEZnFsL7GS5+lXL/G1bq9eqTh3weE2LEz/pIjPmSl1M8p5VnjrN2fSIz5h1v+GOPanwOe/MqWurZI5ZvkUas7EckbjAYu8NmVkNleDIpeiaiQEwl8PCFzZno7OVzLlI8BCsRxhkZBlRZx1Goli5is4bRg7cItnCei6941Qu7FLP1i5lgVDPwZ3KMWbIlwQ5ynZxSmadiSaY77AdPqtziSfOuwCA1Ii7mSBMourxGsunXnBySWuH0ZzlrBywHcrjAGGaTKXfrmwsk8WuzLpsMUrfhwcyukydrLlsc6dU61P/6OSOMKvIGW0k8zKlW1iYSHWgXEPXxk6S5wBWmYzMlkNJ/YhWCSm3i8jnc3qG/aXsU7jbVVqppC9H6Hi8JliyzCnplSuXvGZdZ/s+26ri9SR/u+hdbSwTAFgf6xyoQkY3zPpwxPYWtsqhndV4xLaZeSVEXemAU9KD6wxqVGE5tHHGzHFhJ+Wqn5Fjkce+M21K9z25QGOLTHd6RYZaLYjFW2S5NpJw3+bfRZna9qR3Drc4rrz3yMprt/YxOZczU3pzs99ihiw8P+fYSxdTWKUo8+WK5cvYbOuFRTPgZcdHdSCHvjc4wFdynOo9pXXWmUIoFMdZNNbs7z2Hc0muTNk4HY7LfimAneQ4LE05BpIVWTJl+L21cpCu0OqmE3w/ACCKyMiXFt953pBl0HmAhSzIMhumDIkZeowYMWLcELxQhj6UM46RA4I/SSDlcglKl8lwwjOyjzBJ/dKW2UY0IItqKXDSSoGp7g8VvKnFFW7c7GNWIMOY+WSzW0sxajk0uIsiuhFXwsqA5XhbOub3n5GpJ49mMKdko35I9llbkwlcpFgGKyv78bCEmcfnJK9yG8vEu80VvftlsqVJa4FcgbuMUZksYWvF5/af0KFlkbyP8Y4CRI1536M6GdrnT1m+j7KsY9l9iChFPa+nVX99LMb/mkIJeDswCdbnPEFLjFflePFANvGVmgs3JMMYrsiyCqeyWb8jhyeL1hdudhvlFeW/l9w8f7Kf/TLLeUKLg8Ldcyyfkr11IzkbZciomjaZ1ioRYP+YrG/RkPI85GdrSlnsFqRnLtuoGP7m+5RXo8w2dF2ysKG3hO2yX0WXZGhbCf6W2OG1s8wusrKc6TXZZqUe22xYoIztAf8vFL1v2HtX2pv3EwAoymrnNMudVW5ZQJRlGVdJjhv/PX5O1Fnng60KetppLAayafbZl92qzpJUB/uqAldBqcqyqMoZjp+MrLuW0QKJC7Z7947OLCaikVXWPfE0RK5KmQ1XHD/NgNd0FR4g0G7ucb+Nco7feaPNrVyWU4XxeIW7hNFjCw1fTkNNagKKW3yu3xUb31kg02S7BD22hSs2n9rnPanLX2Rd8gF8Be4qhJxbKlvsiw8WfGd1PUdHZykNi/WN8nQ2zOoswrziws3wXPD7A47jJw7H1tqTHb/o9WIC5HVmNJhvRtFf6ISekrPDoMsJurJqwr0+FFxQIH6SkdFqcwpvlHqI9ZwD8VDnA+MSO+iXddBZqbDBEuW7MDMdcnX426TAd5oqJ8DVfICknD1OPN2fYyNGclLw5hbsqczjFHPCDCj03VscDIsLeebdMrAU2TB77R64AQrvKYKiHJlaFy2shtya121OuOd9Lkb5CjvQSXSJLZVvkOd9dzRgxjVOOq+lOdG7JoCToWyfnLKTvFK/frulurWQ2uHfywTbY3ZLh6rvyWM3WCMrp5l7Snzuv85J1eQVN+SU5Z7V10il5ZjiPZ8z9+Mh0+YWeeRRbdR+8hjWim1UKShmia2F1aNqIXVikNHCvL6Q44YWrNqY5bxKKraHvUT2RI5JdygvV57KDYfvXLbSaORY9vsK0VOTKeeyRDmcL0YYXEp90uWzzTbbYynT0EmTKqHMWRJ3RxzA1f1PlsK2q9g0u4/Yp5flBEyKi2tWNojLXY6FUAvKyXEWRma12RrbP+NTrbTyKZdSj/W0bR9VORKlZKQQZrlIz4ascynrwTVs74bi66w9qdzavGbcuEDa4jWTLMePu6eJba4Df8VFed3JYZiV6k6xdjbCipNrXmrYYtnBKuRYqA+lUipw4VmXpYZ9ZiPaYXmyiji6kHngyVMulls2ZVStZmB0+B+6lG37TB7IMzkDumncOeDfnV3OLeUxr1m8Ii/jkUFeTnYnJbZHqih1pMv6988+AwC4nTpDW+lZZ6vr+DYfD7HKJUaMGDFuCF4oQ7dcsbWQsclzOzZacqzJJLjSNtdHAAC3RsZ0NH4TfUUATM55TfhIZnLaJl01uZqWL1xU81wRx9qeNrM8zDkNyQxKhSLWYgkVbY8e/YpMsrb53O6ghoklZyGPjOVgwtX58dflIixzvGCwhlnJoUWsYxPY2yzf00Du17kZggtS6JnRDqIpp5EFmadrDTGSmVTdkSPVRI4RcgDxU2Qn9UQKYYdy36uLLeS5y1hbWs/TBp5iZu/4ZAZnYBnC25RVZhCisEV5u+tHAIDLhVibGFrmM9zSbn1osDrQwd0nyO7XPeHhVcFlGSZ+Co0yVSTjAZ0v3vAUyyZDdcFpM4/ZKbfPd5uUW3PEfmHvs+1en5Pdr4/zmDXZ5uG7vKZe5OdUlXJ4fTtAbsl3tUpy428pSt4J2ddeuYl0mexqsMX7cmuywZoOEytqsysT4uslhTRYfbJgLlkdqoa32W6FucFsn0x6sdSBZILtXwrJWKv1NfIR+9hgoMPQgOVPJCivYu09AEBnfQcmLeejCVUi2fQxAGCsWODLyW2sFSUwrUPm9G3Wx31Hh9j9PKLP8/rbC6oZTsH2C6X1mShfwdB2MOxxNz5QaIlNkG/yPZbi+dt7BhmLbfFA8ZEOM9z1eyOFjygbTM8UiqCkw1rFLCpdh+Kocmr02g7Sim/U13CpHVFG6Taf63TmGPTI0Avqj1kdkudO+ZxBHijU+S43x12VtZL6KWL9X838EgBgkdtC8fogP7lZOJGYoceIESPGDcELZeiDbemeDGN3D/sLlMQWozZX+8fKZHKQUMxla4G0AjFZWTKkqwvqOYsHivqmA7wn6AKvkEF7ebKR1oWyHIkxpr0lvBUZ24M09Wjhmmx2LrO+yeQMMx1EFpNcyR8rbntqQAbrRIxTnLJ3MRZLmgabOxb1lZnJe0J2Uhh/CYsDMrmsnK48ZQ1a61AyZa9gd7iCX1rcVVjKsFTeImPMpBV4K32OZY7PMUqBZDyyiFya1y7CJHJtMpTVnpyDrk31JmIYpTImCiaUNWzH/SwZj18Qi7iijM1rfTyT6u8L7ua7lkSD5XV6rONObhezkOV7XQfF0YSHdXkj5zIzxZbDsm4ro0yY0CGbI/3qUkG2EhF2znjtxYoydeSYEkDRL2drlBzqv9Mef1vvst7Lh3IzX06QKrLOU7mOu2lFzhvR+cYq8T2vpFd4NqNsh+XmxjIBgI508FOdWeSXQHnAvnErohw6avfjJA/e3hrfRifNHYYpkxU7Q4WQkE1cMGJc9nJ9ib2ZzoiWHIdhi4x/S8YBuUwXA5lKZhIch47N3y7ucsykbB8TOfSl8nxO40oOWFmW86qrIGi5CImMdPyd2xvLxO+zvc4bbBPn3EfzNhlvc6Ld/wXfVbw2i7QHsLIaHyOWz9tVzHOX5Wy1Wc5EKomDDO+vyzR0OZCppM6Huqki/BSzWXlTtq188LCTozaitLiP0RZ3PTsKoDjMcacbXfJ5J+ziyI3WSEjPPrQ2OyiOGXqMGDFi3BC8UIbundDcy1b4XDeVxkDZVDI+V1N3Lj32nKv1F0trjBTV5jjgSpb6DFf/h2JpmRpX52WvgcWAK+1alh3jgnTqV8pjerCDlUXLBsUdwqXckHtfVejRrRygULVdhd/9gpjGRZk3JW2a1M1NhKLyOm6nNz+lX54qvKZM5JJ2AlOZjCVkkjYJyCwaMvtcnyxxGvG7e0mWs33IZd+/JOsayLHnIJmG2aEMLp4eAwCiPbq9Zx/yfCDccpHIkGWNMzQDrD9iXX7tHvV99y7WuEyQ6S68I5ZZ8ca3Hml3UVM4hNw+bo+lty1nN5bJtsK7uoZtuRPNcSGWbMl0rKBY5f1jUqGj0QkmCnfwRCFk73XJllILhTStk007kwyitax3OuxTUCz7hsK9hpnbcHfZXwNZQkRy/Z443NFd4QzB9LcAAEyOQ2m9TcafzNIEdjmljAZ7ITJPuVvZrW7oLSLsymJi+JDBtmbbOWQLlHmQYd3WCZZt6x0yu/XtcxTK7E/NId+/iJTvMkH5+p/n+LHbdbiRdh8Znl/Yl5TlZYn/p9JFGFmwpCZi3QpjfdtW2AFrDDegHF2fbZCssy8/UQjnvIK2ufYM0XUM9/7TjWVizvlcbIn2Jvcxt6mvb7tHAIBclW3cmsnB7iqH7W3+nbnPd3c97v6HXVlnXeeudS4xnHIuKsiE82zN3XlN52zOtIW8whiXL7irOztQSOA2Wfw74QBfDDhvrbWzSYeU40jhG1JDjsdEZYFAYbqt1GZhImKGHiNGjBg3BC/W9d+R5QS46ly5KWw3yCTcgEX57PgLAIDlHTHNboCJLfdunURbKyWrCOT4sVb4gFyAhRIr5BpccXsWn2MVlYTha0/wppxypjpJfiRHj2iHOq6mGWIa8vp7KtfXFvztlphAoDJ5eBPWA+oon74dbSyTAyVhmM6o+/cLEe6fkPkMZHmxkGNIVLwObFTFzkB5QhUe4HtLlE0vpGwzGQWFyq5hWmROtSO6rk+uWHb7czqnmKRRSpFJJL76NQDA+znK9FCu9Q/RRC6inJZKHnIdCnVRU/CwJnctuQ8GcJQNquFv7iySaeqEX2EXEl2DHTmVGU+ONApzmi6TuY/nB8iHciFXObIV7g6a2slZaTn53Mnh6YTnB8sdhXCQbfmlMmbt9idoDLl7enxbDkpt9pvhGWXdXSew91m2Q13nLwmbcl9sKQTwiiy/czFAPuI7LiT/TTFcksG5ctrJDDLIKDzt1FG4hLFC7KptV2YLvsowk5590Syp/GSjbz2Um78dYaT8oEXZ9IfKG9tQViN/YWElC5BWgdeW27LyUq7V5IFBqc92uWpTzo5ywPp9tt+ly13YrVdtzMfcXawam4+fqTIELR6yDLeLPSSfsN22lLxiFLJc20YhjRtdTBRWez3jjsaTpU22xHlj54nqVPbhXJ+LrDQPyVlu3dKOvLqNgmF9lFoWFVnHDW22z2cbXYRKbNHUGcRcAd1yZfahbE+B557uYCl/l9XJZhZRMUOPESNGjBuCF8rQ20XqmWo9pYja6QP4EgBgPKH+rLRQDtAPyDxbaQ85hZFdvKpA9Y/JvKyEguSfyDXXvsTgTeqH5wqutR/ytP//7nPFrFSAcqAQsaEYr7J3210+N7Fno2Lx+u4OmVZZuvn5gNf6SpXZDB/i2uFrMStvLBM/eQwAWA3kmTk9wVdrZDW5vEIRTLkDeHTGstxCG+U6X5qXy/k/WJD5vOqwDFaJNtRRdQ6vTJbg9Ph/WTb0/T6fUWxMUVjzt1WTbbR7ztALZylec5Z0kT1X0pAmyzEasczbDbKvaKCT/toOKrISSi9TG8skVEQ0T96rUX+KZUK5O8dkp0197oSs92xZRJigp13CYr8oXSkt27bsfXtkyOvSMRIHLJeZkOE9npAlNfd5bb9ex55srx3lFP0gR7aUuUOdeiqYY7iSZ3KOZb6c8jllsfDh5ynPuj9D1NCuafSljWUCAIESUVQXfNewUMGZwzJWkqxHufEGAMAbM/DTfGeFw7HygtZ5f28on4+Swj0sKdOK66F0KIuQCf+/2JNFTZFlryUGyJxod2grNWKRO5ZtqbHH8zECXyFnq0rR11H43DfFSp8p/eOvLmEVrgPNbR6cC0N5+L6i3K2zEH6d/bvRlOXPir8lk/R6XV2EaGa4I75osf3u2zpXk//KKquw27kBpm1aAW0ZpjKELJu25AsSukt05UeS3aUsGz3uYoMtfn7vpIRDeX9e7VEGRgHmtp5wRzme6JzoYADvgrsq73gzhv5CJ/Q9mZh1isoSMo0wzbNTNEI5NNjHAIBekY07nUxQUmxiR67GsyrvGcuhJQrZYO30a6gol3BKg2+mjlTa1oFNJ4PHDif5rQ7vXyiZ7K1dHkTMrQa2mjx48rpUU7hbnOBzBU4k9REPSpzMAF05/tQTWxvLpDtWZMWA6oIHuQXuLjkZhoovPdBAzijEwKiRRbfL73YViTJxf1vXqpPoMHfQDFHVttTfY/nKI17r7HBg9toeZjpczWlbmvycog4ey1SxlYc0GGgrel9ii/EqpgqPUHyq8Aq3UvAU08StVDeWia0tcuWc9T/Yy+OrbbbnWOEZMorhHYID0zRHKGxx+2w0cX99yO69k+LgsBJsw85pExmZmRmfMrhYcpIcScWws+7jHVv9rsfBbS/ZzmNF0NvKv4mkraTQjg78leFpVqAKK5JzyzQ6xGGNk/v2UW9jmQDAOqPYOwUl4IaHUo79OpSD3nSPctopcpII1w++Eb0y0WPdsmuWraLz4FSNDdteGdSV9/KZMjh5yux0MOU17xrAV+yVqnKcpmR2ONK4zJsAWal3VhX2w4RRDs8nfI4fcHKdHxZRknlptXewsUxmina5WPA961WIAyXFHj9kPYc5OXnJ9DhnZvBklluvU05Wl+M9kKrEryoyp+8j36TjVaB+WVZsJDfFOpWeTdG4y+vXHU7Klzafk/yIzkepHQ+pqRbHjowLMlxojXK9RuC4zEULWIqMWZ6+t5E8YpVLjBgxYtwQvNicoiOtlEeK2fzYQdMlO96dcdv1jg4qQ+U9zGCN4J7yG36VTGlwTyY9Y7nwl7gFXtkLuCGZilPmatpUvPHtog6SCkk8m/L63m2yhK3rs5iKnre+hdD5LADgKCkGBgVESnLV71s8KLP9LPbkJr2qNjaWiaUsKskS19ZG3UZP8aGXFt81U1TInFzv5xdVVNJUiXjKXt4YkQlv6eBlmOFWcie9hWpF296+IgBus56Dc7IUa2sbVp/3faAsLAmptfLgcxvpBQYKOFTMssy2JdYsh6WSYmg7yyGGyoxuKfPTJmgqs9BQjl+XKYN0Ww5YK5kOKty0vVBgtlUNtly0F8opGe6yb63kWGKX2DeGuQsU+txVPHzC/rFShqHsh3z+PJFGpLyazq5iY6+5K5uVyb7upWe4lOlZT+7weZmejQ3fteVR9VUa9pBT9vj2aPPMPAAw1LsKM8olX0tgfkVZVdctlZH9vmqzD7Vmu0idUS01qrOf1rYVcO6MY6Kz5C5lua6h2+XfoXa6toJ8PZO6rWg/xFKZrjJl7jSC9Od57UPKe73voCjGvJI6Jlvkcy877DNdOffNzhygpuid1c0CUQFAWQ5ddY0fJ8ygLDNfV05C2UMdzEsNFOYtpHJUSfld9uWZRVVVuSiNwYJtNXQPcVTls58oj21D6tu11JThVgBff9sV6mJvXZFZX77JeWR3fopBlvVMKxhXNGZ/taRatI7Zh+xHQwQH7HuD+mZzSszQY8SIEeOG4IUy9JKC0awvFNxm2cPcIZs60cEk5lxVd2QSVS+/CXdERvLsjgLgFBVWNUWmXdQBRmluwROLmiuw1btyntgekyG0M03sGl7feaJD0SOyG+tcK3kKCPbITCZ1Mo3sFstgn5K6RODh63r0DN0861DqbZ4rMrMky1kpQ0qlk0PQVxaahEKvvkrdYrRiWa6mj+BHiqGcVb7EJctV2eY17g6ZRiaZwkQ6SpOm/MdrObYkucsou0cwCQVPUs7OBKhT7IQKt5BLw9OOyJPZ6W2fzxsocNlUuTKn/g5sOZak7c3D59rblHX1SiFJwy2sdHaRmyqwkUzvcEK2hHstnLpkW6GYY1E6+Jb/Nq9p8fP7k4+Q964dR1jmuS3TyyXL/ezMoPbPkNneUlCuSYm6zlDB2N6JgOWaTG4tJ5uxsrzXdfBem3MnlT4sYyfFstrjzfSi19iVM1m/x/odDPJw7nEnpe6OFViOs452WFYXE53TNJWJPnRljpln/ypMFUjN9rDl8SyhoBC51Rnb+Mwho81mcni3xLGxu+Jzah5d2DMKmzA6W2GUp1wH5zI/fsAx9yyhEBWgnPKlDtIKxHfZ2t5YJmOZE9syPc7eqgFz9v30bbZl8pLXLPJsc7fgQhtvTLv847AkHfpY50v3uSPcOS0hzLB8bymM91IBuAoh++lZco6dPuX2npwWDxsyhU7qvCHVwCSSc1aK5Zkl2FbXY6WQ1bmhm4B7rGCC9mbB7WKGHiNGjBg3BC+Uoc89WiFUalyhpikH+RT1m0FH7t67ZF7PZKo4RBbJplymlzwxnhrqJXdkThYGZE611BewyvA+v6PgQLKsySmBRLmUQUq60bR/DAC4yjFYWDmi/vR2M4eUQ1b8NC19oUKvftQVOzrg5/YwjXtrORstN89EM5xIP3dM5mKnBghLrFdqIfNKWaBkFTCo6lRgGerhrto8DT8q8d0fHLDeX7xiHTu1FJIdsofDooJoeWSqufo/BQDIzybwQjnqZCiDpctrbWVVT1/kkMryXVOfdbcz3A2VcmyPdFtBxaZr2Mpb6hQ216FXfb5ztss2uI8uFrI4yaSUT1ZOR1kx1FP3VYwr0iO32F9Wd8i2FlcMxxv02e+GxT6egv2kplAJBZ9yWwRkm9NkEcnHrMN1n1wEbPs7soQ4T9VQFicqFNlmywVlO5EpXlT7HADgXq2NtjLCH9Ze21gmAGApX+le5oiySHcxf0JWXKqwbH7InehnFD5imixjKtPb4YJjbavEOn+fgt59TRm83gq6cLOUkaPMTZ5CCjQc9sVpx8WdKndkTR0+XVv/DFIKdtdNYhbxXWWL7e/JGWcvrb6cJcvvhG8jn+B9ssbcCLkEn5NWEordoodLhZw9Cjmmzm1aNKUD7ujzZyksS7Ree6vIXUvSZT8aL4/53PERAGDoPIWz4t9GDLvn8flBUedfgwCZHb7rzjMFYCvx/8KAO79++gxBj30rvKN+9RHb87bhc/oOdwml21sYqH8Gz2LX/xgxYsT4rsQLZegjhTU1F1y1+9kJcmIwCYXb3D8mm5g0ucJn1gsUOmLABbLIjCerln2e5FtTPmM+WGEpBmA1yJgCZYDPDxSi01rhCmQh7hZX7mqbzKl2jyx3alu4HJMB31PCg8u2TqTzsu9eceW0Kj7GhrpEk988m/tqRT1tfpur87qfQy7F1b2sU/Wh0s21IzLDV2ppuB5X8JFHZmFb0uv1yKiWb5EpNi+aKN0lA/JBWYzW0pOKTTq5BrLXekc5xDzs87fzr5KVNw9WMCMy3+1DhQgVC2nISsJXkgc7WKAVHQMAvqf1OzaWSb9DPbmbZH7TtZ9E9qymd1IGfcN+8saCbVd1bsEZKBFBkvWtJMiO0g3W+yOFyh1OS2itZM3xphzYOkoUsaDM03ds3F/IlnpL+tQ03718mwHMCtkh9i+ovG7prMZq8drkLSWzyLCvN8IkbOW5HVQvN5YJAOR9MvueRaaXWDSxc6AwDi77e3KH7/C140hkbNRbZJRZnatkfZoITdZkio1tstQlXoOnfm8rFISjhCdzBcBblRJInSkMs86OVgs5vyzZL6qlZ5iOyDpHCh9sJfmcHY/XPAoUjsLuIuGzL3eamztcfe5NWpXUX2f/f3i1j3pLPh13lKTmQz5/57Osm1fzkXc1fiz27yinAHOQ9Y2sejyzhaTDZ1s9coIvAAAdsElEQVRt/u/W5BjZo1ah7bWxdhVeQgkz/DOOy0n+GAAQtPqwNdvaZzxXScnp6tFETlcDBdFzk6jssF85s8106C90Qn+q6Hx7W2zUSlBFMOGgdUIK9upVXpOaKqa1D3QtTkDVPXaK5podstfmgDXX8Ty2HeyMZdooQaSzd/Ucfu51Eyjm2bD+goLcrhwDAGxNam6tjqNIB31Temsuepz8D+TdNRtr22Xt4lSOO1llRdoESZlp+l15M24ZzDTgkh4XsFKedVop/kXvag0/KRkeshPMFeu6qCiThS7luc7U0J5yIiooubM1oLweTDj59KJzzEfsgNF1uss+ZfPqLbZHO3uIvVv8zl7I7M2mDPqKzJc84yTpzlfY0oH18DObZyyy7lEmpff5vgVGKL2mRL9LxQ8Zses+SSiB83qB8pY8h7XQDKechPw6t9elLAdbvXOMWxll29lXvPY2ZX46Yr+7t/sKTifK7NPgOzMVOZMpTk3OTWF4wHI1Ttg2Q3mX2lPKZJmnQB9bPnZe4wAuVfc3lgkATHeuA2bz/cHjMRx54q6UV2CxptxnvjIMzR5goQiVzoj1mU6VUDnDqIH+FSdFJ7tCT2qT1689t2VSmAXH4AOrjDvy1g1EIi7liTlVPPpZZwfFO1JhSfW3W+cE+lTkZEeRCq1xGaMcn7d3sbnZYuc6o88/5Niz5zM8DlnWMC2TxibldZ2wujxtYb5k36o5mtiLbwIAxhMeWDeUszZ5K42F1E8tj2MqrfwLUx1qutMVqkqufaqom3WpNUfK9TuYeNhecHyYV1lfX/lCnT77ynlSjnSvBHB0KJ1SJqqPi1jlEiNGjBg3BC+UoTsBVRoNl1vffuoNOAMyzdG2XGUvuLoGdbKr3UYKuTl/G4RyVuhzZTyQRdygyJX4tf4tXCnqWWrNLbBT0bXK+rNc2FgllHPyVa7uqQ5XzBOZ9xWWY0yVEX064vM8HY4ufcZzGBs6DGSjGQoDbnsnF8HGMvFt1tPaF2OcLbG/JCsa9biiXx+4VOdiQLUEHDHpr12R6Rw+5U5nW4c9wdssL9LA7inrMJ2wvmu5MOfktm4t8vAmlE9HrLSykPmnQ3aStHJYHohRrFmeykCMf8Z7UxnuZmb9c/TlFp072Tyy4LjP9jxUppiFa+FyQtXFdkox8CvkInXlRW2PB3B22XcaS7LDZZYMMnzGLW5YIgPaCe8i+7bi8CsrfSi38GKPuzfroIHvX7M+pyOa7Hl3WJ6svG4sb41+j8+cRSzXTo3P8UH5Zx2Zr+Vb8Dr8e2xtbt4KAK7MLp0183R69a+ju6asSopGWT6V+kROaOMZUM2zH3mK672esU1SPZneHrFdg+4FsnKIGmd1SDhTVrApdzDlzhKLOxwvKam9sgo6OFeuWSt7BHfC+3ZCvmu1YIe9V+aus+uz386jGYI1+6Vf3zy7VdFmOUdqWzuVRanAnVhGu35XB/zehG297uewrTpcTlmHfJbjxx2zjXrb7G/p0R2EUreafdZl3dLBMTg2ztwyWsospLTEWGnnXXAVD9+rwCjn8HhMWaTaHKurEp/jOlKfRmUYOQjWDzdTz8UMPUaMGDFuCF4oQ8/WlQFdwZy2wwTmKWX2kLlhSWk5qzPqGbvpEfzL6xXtGABQvktX41WVK2/u/AgA0JuuUQzIVEYpZfPWwdhMekMvPENhi2zKtMi0Wguu0tM+Wc2kEiKrw5xakWzUl5NPOOMBrKfAYMtRC6kFV94ZjjeWiRuy7GmZbfqVEVpyIFlmWQa3x3KWDBmHUxxjIb1bo8tyJUETv/a22M67LF9+GCLvkCV0h3LRv0WGkZce86ujEAdrvnN1QTkFNUUqfF+mco4P+5yybSiGeygTwqTLXcZHlmJcFwwCHUy6Ciy2Ca5zqE77Oq/YCxAMdVg+5neJV1m/VVf1zLWQHLJ8FTloLBVA7arKw+prx6xoN4EjHYDnamSMJ9N3AQDm6i0AgG1dodRjvT4nR5BCmjvLhc9717klPMUaj2YslxnIHFJZ7dtjyiSa13Gk8AKJySeIKgigqFyiwYTlKCTnmNti/T0y87wOe1NniiCaraDXoZ69UGRZ82XKzI60a9XZ0bLg4b5DRjg03H1dO06d6zxiFWTx2pD3PQzISt/ERGVgf9jKhGhp1zosshwLl2Uv2yzfsK0IoNkGUsrF62t8b4Idme9O8qzj0YGNDy8VUK/HIHzvzqgv/56SQl7sl/DApjFC1bDMH/FSlFM6w3O5w58UzjFKcKztfcj2e6SDz1yDKoLC6QBnF5RP7U1+Zy+/yPuXzC27yhpMJTdPUV7dHfWNB9wd9G8rQNwFULyvM6OjzWw5Y4YeI0aMGDcEL5Sh44yrmHuLq9hD/wMcgiwqrRNzJ8/V0OmT2SUXKVjSR80csu2cguMkpVMeBvy9GXTQksVJQXGN7SGZUlK6QT+bgqVYxfMC2YM3IytNRQrJWl6jFpGFWmVaDWSlL2tsKRN8h8+bpBxcvadcgMv0xiKxZBaWTDFQ2Gy+hR2FIw1lnZK4jkA7Vb7Lfh5bOoX37lMfG52w3rZPtuOtpNt9dIwv71NXmpvwHRYJASo6gS+tZ/hA1kFuVzrFFetn5ZXf9GwJW3GmzZpsqKMosBO5z2fllDKNdrBe89r9z76xsUzutNk+ly7Lt36cQLqjGOSK++0pRKr3GmW1664QOcqgtGQ7lndZwGNZRZUU2tRENaTkkh+W2Ycqb7Gc9aqyMg1s5NfsA3MF47KjaxM+mYQGVeTOtRMJqHOdt/g83+bnI5cWJL3tKyCnQGDuzsYyAYCV8u7uKjyBu/s2ago3ff4By+pEZJaBYpXbpSWS6guToUK8jhVIrMqyTRtkpYduF+dr1ien8BwI2B8ar5MxLpMB+mOy25TCwF7IVLKwJaYeAU5ImReVLWq5UOzwfZkrbisG+JMh3JWcu3L1jWViJbTTStI58L3jAK1jxYKX9dVamYHeXbFuRT+H1VAByWyeR4S3FO1N7v1tn/3e7geYy/T0/CF3yHWZND68ZB8sukWU3+L4MT3K+CJ6V/Vm+ayLd9ArkD+Hl5RlNONYzRV57ytj7fr3tnEoJ7LKeZyxKEaMGDG+K/FCGbqRrSbeI9NelluYr2g1kl8eAQAGUzJg81ukw55n0Y7ICOp53j9oy25WCRsqW1yRL9dp5AIylYRsR9sKa1ne5SrrjjKYK1PD9lo5ByvKkgTqIQudI9Tf5nNGWQWFkhXIWhnkWwqQ79oFJO/oJP+hs7FMLOk3+w4dMTJOgFmHujqvyZ3M4ZrMbq4QAHWvBFfZ2O+XeY0XqJw2mZWRW/40/BDFpwr3WaHcn7TJiCLD5w16AcaBQuPaZAkD6dS35aiV9u5ioOqZipiF7OMn/SMAwI7Puvg77jcC/M/b7Y1l8li63Rr4vHXmEk5JDChHdltVuNTh1yiri70MXld2mLxCJQdNBTf7VbLVlsIY3KlWoA0N9nJkZk3tNqaGn4PpNpw9MtmMGFk0Z3luOfzfmy0wqZHBVlMsX9RgX3Kv2C7v75HF3V3MsU6yvxaLn8zKxaTlzl9nW+WDHuxLJatQFqngjO2W3td5SXIJo1C24yornVbmpOAZzxaSPhlsu1jB3SVZ7eJz2uF9pH6uBDR26xIJxXZLazftB2S7doIMdtlbIbNL5rsEZX5+qlydT3W+cZflPa3kkRqwr4SfgF4GB2Tm22can6UW/DfI/qfvsn7pGndstYi7PKvsYKbsSJVtZSqKdPYkm/hAbv7FrI/sM52R3WO/P4moty/JEqWKPLJjJZEJOEeNEuyn/Sl3guvMAoUO6xx6lIlV4M45kT0CAHQt+gXc7R/hOMn5wK1vZpv/Qid0W9usljzD7kT34VXZcfoWJ5L9qgQs06C2tUB7rjge2urn84pzMGWDja4o6NdNhIsKO/tWQD2Fn6MQLWWxyVbPUNS2qFtgIySvU3qNebBoalkMZZKVeap4MZGCpu8ycl9y+Ev8ftXDs0u+E4nNEyIXbyvWucvOthydY7CnCIItdpynZQ7IXIKDN9cJsVIC6WqO114u6UVYLSpK5Iwdofj1Ko6lEgnk0VfXNrU9UbyblI03RvKSVWo7z3DQDxcsQzG1RjZJOQ1aHNH7acqkovIOFdXPWR6gqtgriVV+Y5lUPaWvC9k3UrM0VvKqq1bklTq9zu6i2OezNLwjXl8ccmH+5bky6pQ56cuyDSsskdOsFL2rJN15EovAIlnILL6GzpztuaN6eo5MERVLfT6sIx/JlM1IbRdwkss33uf3x3K6qfVR7LH9ltfRLjeEkengRCqlwAdWUy10iiOU8KT6GbM8Jt9GKi0vZzkh+VP2p6V5qgcr61WtivM1+481ZN1zuxwjxlLS69Tn0C+zzg15YRtXURYXUvsVI4wuVR5lAWvU5A3aorFDTp6a9xYJzBXN8GHD3lgmRx6nsA7Yz9KrEjxFOLTySu48Vwz9Cus5bwP5kItrT0YPKaWzzMsMVo/Aw6ED/3rilkyCvjIzFTge+uVznFiKaFni80bvc0Ft3CGhOWmXgWuSkySxytiU9Xp1DADYbpCEhc4SYYl9uL5hfKhY5RIjRowYNwQvlKEnxIRTDa5wyekEflUmiXL7tQ+5VXPdaxVAE47P1dPOiSU7fM5chzOVBFn9eaIEVyZh577ijRTI6GZKojyrVrCq8sAidUVGvhzJ1CvNVXEavIaZsvmkMnJ0kjohuSKraciUyfV7OFY2o0Ww3Fgmrg46XTl/VII6cr7YQ57maSmjA68U67D+TB77j/ndeovb3HszymD2riIVRnJOwgStmfKPWmSL53XWu7rNulj9ClK7fHagOM5756xTsGLckrC+RnRGppO6w3p2PW4LGz2ZwXky8bRWiApkLPXq6cYySS3JhD1bTLRRxUFCuzI50Iy7RwCA7SKvLSUuYaUUg9unTA8fs42CIXcZKeXCnC4fw8jcMfE2+9vC5g6npN3MdBWg1pbKJUe5zdNkl+E5+6ZbPUe9TBO5yUOq/XZSfFfrQowvSTY/yqTgbPM0Opx9skPRy5BlfkM5RWf+FOstsseazH57CrkQVvje/cs8uhXt+JbKuJQli0+pn+XqCuVwMcdqV+opsfjb22Sl4wH/n7sXyLuUeVe5NcfKw1pVhECTqWOdVJz4JcvjKu8u5DzTkuMZgh6iPpN77151N5ZJqA1gRofZZjpE7ZR/97+XO4fEM7bbqC0HO7+HME9ZZqbcHaxzrN9CcXv8CafG3NhH8RUljJ9wjEwUMsNVJrBpUEF1SIODk1CqWot1Sc0p40J/CT/DXdOW4hF5ActXl3plGCl3cKmAezIJDtT3Pi5ihh4jRowYNwQvlKH35mTAgYISnuZ9VD+SXkuxtpP9rwIA8gok1d+aoSzztcYrZDahTBoTOiSsKD7zYuZgrtykpsADhryyGQ3yCtb1eIpElSvi2Y6C7eg0JifHg2Iziauv8R3rXepW9y0ysXPDVXmuaHFZr4j8lAzHDzY/FE3l5Jzgk/XNXjVIy4wyrSBYbod1yssk0e8ZDHRYGep8YW5fx1AnC6s3KeQweYiEshktlHOzIFXlK1lGt3t/+gxOm7INDNnDLCSTWtb5f3VpI9rmricYKe/iPepSp4rwGEgPmXNcHDXlhDHdPPZ3U4d+xy22wVNnAVuOZrsD9pfKgfKuTmTyNrzzjdyrns5j1nXucMbKXG+l2U+sQRX3QPZ9cv73AAClBvWats4HjFnCgIKaPWM5DppkeE922ZfuLcuwHnX0Lvaz1nXWnW0ytqyCni1bHna1s5wtNw9CBQCnXZbDlYJ3O/U9KEvn3c4zWmdNQbRcBXh7N7nAkacDux2Z657J/HJLGZ7m3F1Uygso5DtKyiW6fkrGOczozCFxDk8u9dABtbOgnIZ55isoXtXQpjhQaJCpj2aU77YOtxNzPq83aiKrHfukuHlA9JLOQpIZUvWLVAVGB52HH7K+9lzMX05O090InqwB02POMwnlMF5qh19csY5ddFA4406vaSlUiHYkq+vT4d4UwZR9qya9eqIkZ8Up+6K5P8GdiONjslbALftEz+F4z6XZHuWtHODxmryyb31cxAw9RowYMW4IXihDD5Xpe57j8lguplFbc9XqbHO1s9ZcMac9BkaqWBEaMvNKSGe7Ligjd0HBoTyxo+0QDek9O4Zsclc616BDNhnVC4BPttCIuGMYl8miwjn1qf5xC16Fq7FU78i/qWBDj5QFvSnLm0SI4q5CmI5SG8vE1Uq8SJN9/dbeHC0FmZqMyDoy1/pRWRrUvHPMSrLi8Si3V2fSeVev43rz99VhCutAOVMvyHInS5b9XIGXLBjYytGZlit0kFJ8dDEPf8tBrcX3j8rUq49PubvIiHDmbymW9KqKp0O5mbc2N1tcKxxrNsPy/fAMmIvZXa1YvrFMLxcpnVtYV6h3FGZgV/Htn/B8Zi0HoYSCu6EaoJ1hnzpKk1G3B2TUvTH7mBP5CH25aMtBKatctIkB5deK2kjXFIRpRAuusvMVvlNxto3c4ou7BazleLad3XwnBwCJtYJsaRfWKzxDU+FuOzLDSyjwnL+QKWAqi6eyBGlO8noOZbdSPt+5zBrPhyWUqtoFiMG2IwWImyiExuHb2FrIhV39qisnnDIYqvrJcoh0ku+ca8xXXcr3+EznZ2mWpYceoinbK+htnlPUyrIvduU85o0aSB9TBpkUx+MTOZ+tnsq5aeAgW+JZxyspjpPBLV676CmcteqWr1axHlOWpsy+l9lhv8jLbLNaSmI041iYDdlXoiXrknfY/qG1hfaVLIjK3HFXLcq9fpvnDNWyAgB2fPj3+OzUeLMwETFDjxEjRowbghfK0Kd5shZvxVUw9chDt87VPi+rg4oyyS+/oLCrawvLNZnl6oqM2revs9bz2nJG+q7jHvp52ZtHCqsqa5mkwxVv7vbgyVGpfUpmvpOnDniVla1tpwCroGD4IXXR7ROulPOGwurKJrUTlLCcsj7VxGZuugCQVyCuUAGSPkyWkRrItfy+Ai9dsJm2p9RZdranmOfJFkrvsZ7vWNy1lO9ylY8eiWl0QjgK5p9TDtaEkmEMVmS3t0pfQEaJI7oVBWEa0OkhKFAvGrQs2D9AXV9BQZlCMfzCbbmLe2TW60EC6SvKsuNtHlLY8mSd4JF1jQd52DMmHijKimOlswyX7gBI3ssgo3KZA8ppkla4X4/69pVyxm5FNrJKStqbsuyRckpWFW4hVfPhK2HJ9oVCGsgGvnDFPnuaquONouyffepDRwv2s4QMsiK1ayZdRihntFV986QfANDMsZ+fKanDbZND32WZ5grTu0hzN2Kfa1e2E8DISmqks57PptnuJy3es58VQ7w/xPojhVFW/3duccdyoWw6h4UFFtrpBAqR2yuyXtmuHHd2IownbIu7WY7Hkzz7ZThTSFvZ9OcGBmcKrZA2441lEh1R3uWvsG7J7WN0Xbbt8oTPe1NWTx/ZLFO6Brhj1uHDIu/fVvYua6V5QmEkXll3Ed3jOZCvHepYu+nURLvD7QXOV8q4NmV/OEtcByeTg97AwnDJcbwnq5ZyhmMtpSxhZ1M6Sd2638J8fZ217GgjecQMPUaMGDFuCF5sgguF4oyUddzPApdypbdSXO2Xytm50yVLS3oTPJBH27aCSeUWZFMz6Xs/HClrOAZw7ur+NteqX75QOMwk2f1+ehvDBO/btpUlIkF9at8mk/WyF3CzStqwIsNYKFbR1kSemXINDt0t9GShUsteR9H6+BjvyJBWzKgUugjzPD/wlQ3dDbnK97cUBvbyDez2WZ8PG9xtJBWUqal4+Ct5/+Xd2+ileG3OIUOxVd/mirpYt9LH8JLsOpzwfycvKxLZPO9mDlCakl1NFSwtzPOdDbXhM6UCTJ4uMXZkD537YGOZrHzWyS1xR3CAIcI123OgELRbLZbFl8++SfQRDnl9diZd50x26SEZUaBwyW55grmSTBTE1Kd5frbXZFpONEV6yT64ukOmn3xfFgyHfPddv4+Sz12Zn5OLvHTnjZ5CMRQUNiA7Rr6ivJPR441lAgCzBvv29nVQtNwUKFBvbY34zIrKU9/j/xen+5jcJrMsR5TP12VlE+5wB9RSONdyZ41Wge0f2Ep7uFKOXjFGf5WHrwQ1Y4vPK4/Zr9pr9s/yIsBsn+314TFlXq7x2mmeY8WPFMiunMFKoXTDZHZjmSTUxguFgngwL6BqKPtHSg8Yrqj/f7PEspwPHSRKvC8ZKVXeKdt2521ZpSiv7ZXj4/Ap69v+f9s7t6Y2jiAKn5VWdwkkLAQGycYXHhynyo6T+P//BVe5kkrF2MZY3JGEdoWuy+bhHPKuF1dlc74XCpBmZ2Znert7p7vbtGjqqgGaU4Tr9aciugVaHFPtiZ5O3jWmuuY8j1ct7puFIm2/n/KzbzTn+y9VbGX0Gu0Wv9eZr2f1/1CBXqrKvCnrpgYdpDGFTXPGwaaqf7jSkcTFVoKKcnPM/uZK7ifcoN08zaRhj6ZV/rKMuwEnZzjRNaYUMrkqN+e3eYxWwBvydYuL4DEUkq3JH0VVtFQfcVhQdZ4zSsoPqpgTxQrZ3x1gR+31l+vn6KgOlUFxR/Uz52N8uWPbnaWOXam67K3ymZeTM1zLLdHTy6VEx8yiiVwdDboJOsMzHOpo5JVcVaPrAwBAW4VxT+IAATj2RMe3VnJphH+wX+EvIW4KHN+8wMCkXWVo/JzwO8Vr9ju3n/4bbl0rrF8/M85zrvdiVXgZx7hQqPiu1vfwCTdQ/ZLjvkEXz3u8/jyl+yNX5uasHis1QZsbfVUpoSohVCkoxYNcfRXVBK1PSljM2U7hL5rcjaL8KDrbV2uEOMmzXwf6fnpO5SPa4Tp5MmGHk2IFS9W5zfeerj0nALCSa+9OtVzb+QC3ehm4oxd3JyuO63SXwn9R/BPNKQXReMoHeHqjqkSnHGvco7BFFCFu6IXnghrMhvKDr9oc81X/N5Rb3MeXEvadHMcYbUnoJ48QKKcJalyfcYl7NbjhWqwXpDgEATblwpjM1g/MK+kBuiv3xXbawpcDXmN/yH1T2eRaXn5hn5qHV7gYU2lqXnJ9t18rh9SFFD8pWkFygPufqNy8PWY7RzqS+CjkPHa6m5hJ4Tgfc4/UA44lrLL993sRYsmSvSkDqYpdpbZQMfhann3qlGMkCv6r5NZzotjlYowxGeGHaujTGZ/y90qslE5HaMhEgZ7ydzpK9WlC86szi7A4U6X3FTWJvqqUoEmNpTjk0/7i9gaBMuLdSmu821bOc2lKDUT42ub/8oMDAMBW8oHt1Wh2rRYlRAPl2VZyr3PQBKspZHh1xM+eJVU05BJ6dbh+TcThSFnecpybxuYmXsayFMYPOcD1wk35rOPcDBvLrwCAm0iZD8+oocRNalZxj+Ptljv4rpdgoVxVD4bteETtph6E6KcMxOooEOauJPeMNJVvJyHCJ9Qw6jn+HCd0jVx9p+Yb1jg3tftNbOV5rzZUBWodfn9D62KiLIeFxga6oDVQHfIaf+qYXlBgP9/V+ojuua52+9Qgqw+J2n5VtsmRarLGVbR6qjqkYK2i3DyFMtdaMgnR2D0AAJQa1KRmRzKrlcd6hRx6OgkZ1tRel5bJ2ynHfZMqsOYuRPeA9/pwe/2EZQCQm6nCkMz749M8NkKOaSQ32AI6MPCZ97yUPsMFFMiSo+sg3eNcxjMdMz3lWhk0z9EeyDXSlitJv68+cn0U333ExSf+LV9nu4OY7ZZztMZue98QHfH7I4Wwd0a0vNMC52cjUj3b2jbup3oZuv6pXzSVgTLYeTiSG+FQ++SF0k9MNCeTLi+QoISOrL/Ge/bzcvEzAGDZ4rraf0wtv1m5x0QVv/Z7tHCe3soa0xHMoLfChWqkvohpRS+3KDdq19S0BzjGc8mOjXvOW6wgsJZqqZY/c78Xn6VId1SbYeTQf2OM+V8SpA9pYY0xxvynsYZujDEZwQLdGGMyggW6McZkBAt0Y4zJCBboxhiTESzQjTEmI1igG2NMRrBAN8aYjGCBbowxGcEC3RhjMoIFujHGZAQLdGOMyQgW6MYYkxEs0I0xJiNYoBtjTEawQDfGmIxggW6MMRnBAt0YYzKCBboxxmQEC3RjjMkIFujGGJMRLNCNMSYjWKAbY0xG+AfeGC/vS0iDMAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1d1ba15cc0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class.\n",
    "# Depending on your choice of learning rate and regularization strength, these may\n",
    "# or may not be nice to look at.\n",
    "w = best_svm.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "w_min, w_max = np.min(w), np.max(w)\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])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}