{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Convolution Neural Network (CNN)\n", "In this notebook we show how to do the classification using a simple CNN. First we load the data and the necessary libraries. As in the previous notebook we could also load the whole data set.\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "((4000, 1, 28, 28), (4000,), 28)" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "import matplotlib.image as imgplot\n", "import cPickle as pickle\n", "import gzip\n", "with gzip.open('mnist_4000.pkl.gz', 'rb') as f:\n", " (X,y) = pickle.load(f)\n", "PIXELS = len(X[0,0,0,:])\n", "X.shape, y.shape, PIXELS" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [], "source": [ "#from create_mnist import load_data_2d\n", "#X,y,PIXELS = load_data_2d('/home/dueo/dl-playground/data/mnist.pkl.gz')\n", "#X.shape, y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "X contains the images and y contains the labels." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "### A first simple CNN\n", "Now let's train a network using the loaded data. First we have to design the architecture of the network.\n", "#### Definition of the network\n", "We again use the simple definition using the class `NeuralNet` from `nolearn.lasagne` to create a network like this \n", "\n", "" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false, "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "from lasagne import layers\n", "from lasagne import nonlinearities\n", "from nolearn.lasagne import NeuralNet\n", "\n", "net1 = NeuralNet(\n", " # Geometry of the network\n", " layers=[\n", " ('input', layers.InputLayer),\n", " ('conv1', layers.Conv2DLayer),\n", " ('pool1', layers.MaxPool2DLayer),\n", " ('conv2', layers.Conv2DLayer),\n", " ('pool2', layers.MaxPool2DLayer),\n", " ('hidden4', layers.DenseLayer),\n", " ('output', layers.DenseLayer),\n", " ],\n", " input_shape=(None, 1, PIXELS, PIXELS), #None in the first axis indicates that the batch size can be set later\n", " conv1_num_filters=32, conv1_filter_size=(3, 3), pool1_pool_size=(2, 2), #pool_size used to be called ds in old versions of lasagne\n", " conv2_num_filters=64, conv2_filter_size=(2, 2), pool2_pool_size=(2, 2),\n", " hidden4_num_units=500,\n", " output_num_units=10, output_nonlinearity=nonlinearities.softmax,\n", "\n", " # learning rate parameters\n", " update_learning_rate=0.01,\n", " update_momentum=0.9,\n", " regression=False,\n", " # We only train for 10 epochs\n", " max_epochs=10,\n", " verbose=1,\n", "\n", " # Training test-set split\n", " eval_size = 0.2\n", " )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "####Training of the net. \n", "As in the MLP example the data is split automatically into 80% training set and 20% test set. Since it takes quite a while to finish an epoch (at least with a CPU), we reduce the data to 1000 samples (800 for training and 200 for testing). Note also that the geometry makes sense. The first 3x3 convolution knocks off 2 pixels from the 28x28 images resulting in 26x26 images. Then the maxpooling with size 2x2 reduces these images to 13x13 pixels... " ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false, "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " DenseLayer \t(None, 10) \tproduces 10 outputs\n", " DenseLayer \t(None, 500) \tproduces 500 outputs\n", " MaxPool2DLayer \t(None, 64, 6, 6) \tproduces 2304 outputs\n", " Conv2DLayer \t(None, 64, 12, 12) \tproduces 9216 outputs\n", " MaxPool2DLayer \t(None, 32, 13, 13) \tproduces 5408 outputs\n", " Conv2DLayer \t(None, 32, 26, 26) \tproduces 21632 outputs\n", " InputLayer \t(None, 1, 28, 28) \tproduces 784 outputs\n", "\n", " Epoch | Train loss | Valid loss | Train / Val | Valid acc | Dur\n", "--------|--------------|--------------|---------------|-------------|-------\n", " 1 | \u001b[94m 2.209664\u001b[0m | \u001b[32m 1.983545\u001b[0m | 1.113998 | 52.32% | 7.0s\n", " 2 | \u001b[94m 1.702469\u001b[0m | \u001b[32m 1.365793\u001b[0m | 1.246505 | 65.03% | 7.0s\n", " 3 | \u001b[94m 1.008289\u001b[0m | \u001b[32m 0.821318\u001b[0m | 1.227647 | 77.47% | 6.9s\n", " 4 | \u001b[94m 0.603863\u001b[0m | \u001b[32m 0.681294\u001b[0m | 0.886347 | 79.03% | 6.9s\n", " 5 | \u001b[94m 0.410593\u001b[0m | \u001b[32m 0.666037\u001b[0m | 0.616472 | 80.35% | 6.9s\n", " 6 | \u001b[94m 0.322080\u001b[0m | \u001b[32m 0.649832\u001b[0m | 0.495636 | 82.59% | 6.8s\n", " 7 | \u001b[94m 0.253211\u001b[0m | \u001b[32m 0.570976\u001b[0m | 0.443471 | 84.81% | 6.8s\n", " 8 | \u001b[94m 0.211008\u001b[0m | 0.582091 | 0.362500 | 85.07% | 6.8s\n", " 9 | \u001b[94m 0.177194\u001b[0m | \u001b[32m 0.512190\u001b[0m | 0.345954 | 86.90% | 6.8s\n", " 10 | \u001b[94m 0.143672\u001b[0m | 0.515285 | 0.278821 | 86.51% | 6.9s\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/Library/Python/2.7/site-packages/lasagne/init.py:86: UserWarning: The uniform initializer no longer uses Glorot et al.'s approach to determine the bounds, but defaults to the range (-0.01, 0.01) instead. Please use the new GlorotUniform initializer to get the old behavior. GlorotUniform is now the default for all layers.\n", " warnings.warn(\"The uniform initializer no longer uses Glorot et al.'s \"\n", "/Library/Python/2.7/site-packages/lasagne/layers/helper.py:69: UserWarning: get_all_layers() has been changed to return layers in topological order. The former implementation is still available as get_all_layers_old(), but will be removed before the first release of Lasagne. To ignore this warning, use `warnings.filterwarnings('ignore', '.*topo.*')`.\n", " warnings.warn(\"get_all_layers() has been changed to return layers in \"\n", "/Library/Python/2.7/site-packages/lasagne/layers/base.py:99: UserWarning: layer.get_output_shape() is deprecated and will be removed for the first release of Lasagne. Please use layer.output_shape instead.\n", " warnings.warn(\"layer.get_output_shape() is deprecated and will be \"\n", "/Library/Python/2.7/site-packages/lasagne/layers/base.py:109: UserWarning: layer.get_output(...) is deprecated and will be removed for the first release of Lasagne. Please use lasagne.layers.get_output(layer, ...) instead.\n", " warnings.warn(\"layer.get_output(...) is deprecated and will be \"\n" ] } ], "source": [ "net = net1.fit(X[0:1000,:,:,:],y[0:1000])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note this takes a bit time on a CPU (approx 7 sec) for each epoch. If running on the GPU it onlty takes about 0.2 sec for each epoch." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We have a trained classifier with which we can make predictions." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([9, 0, 9, 8, 1, 3, 2, 5, 7, 4])" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "net.predict(X[3000:3010,:,:,:])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**That's basically all we need! ** We can make predictions on new data.\n", "In the following I will show you how to store and reload the learned model. The reloaded model can then be further trained.\n", "\n", "##### Storing the trained model\n", "We now store the trained model using the pickle mechanism as follows:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [], "source": [ "import cPickle as pickle\n", "with open('data/net1.pickle', 'wb') as f:\n", " pickle.dump(net, f, -1)" ] }, { "cell_type": "code", "execution_count": 98, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ls: data: No such file or directory\r\n" ] } ], "source": [ "%ls -rtlh data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Loading a stored model\n", "We load the model trained model again..." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false }, "outputs": [], "source": [ "import cPickle as pickle\n", "with open('data/net1.pickle', 'rb') as f:\n", " net_pretrain = pickle.load(f)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Training further (more iterations)\n", "We can now take the net and train it for further iterations. We will see that the training loss already starts with the low value from the previous model. So the model is really reloaded." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false, "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " DenseLayer \t(None, 10) \tproduces 10 outputs\n", " DenseLayer \t(None, 500) \tproduces 500 outputs\n", " MaxPool2DLayer \t(None, 64, 6, 6) \tproduces 2304 outputs\n", " Conv2DLayer \t(None, 64, 12, 12) \tproduces 9216 outputs\n", " MaxPool2DLayer \t(None, 32, 13, 13) \tproduces 5408 outputs\n", " Conv2DLayer \t(None, 32, 26, 26) \tproduces 21632 outputs\n", " InputLayer \t(None, 1, 28, 28) \tproduces 784 outputs\n", "\n", " Epoch | Train loss | Valid loss | Train / Val | Valid acc | Dur\n", "--------|--------------|--------------|---------------|-------------|-------\n", " 1 | \u001b[94m 0.124337\u001b[0m | \u001b[32m 0.522876\u001b[0m | 0.237795 | 87.17% | 7.1s\n", " 2 | \u001b[94m 0.113882\u001b[0m | 0.532682 | 0.213790 | 87.44% | 6.9s\n", " 3 | \u001b[94m 0.097049\u001b[0m | 0.533600 | 0.181877 | 87.44% | 6.9s\n", " 4 | \u001b[94m 0.082564\u001b[0m | 0.534813 | 0.154380 | 87.44% | 6.8s\n", " 5 | \u001b[94m 0.069916\u001b[0m | 0.538397 | 0.129861 | 87.44% | 6.8s\n", " 6 | \u001b[94m 0.058491\u001b[0m | 0.545280 | 0.107268 | 87.83% | 6.8s\n", " 7 | \u001b[94m 0.048879\u001b[0m | 0.550748 | 0.088749 | 87.17% | 6.8s\n", " 8 | \u001b[94m 0.040898\u001b[0m | 0.556807 | 0.073451 | 87.17% | 6.8s\n", " 9 | \u001b[94m 0.034421\u001b[0m | 0.562090 | 0.061238 | 86.90% | 6.8s\n", " 10 | \u001b[94m 0.029226\u001b[0m | 0.568106 | 0.051445 | 87.29% | 7.0s\n" ] } ], "source": [ "net_pretrain.fit(X[0:1000,:,:,:],y[0:1000]);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Training further (new data)\n", "We can train also on new data. Now for 5 epochs..." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " DenseLayer \t(None, 10) \tproduces 10 outputs\n", " DenseLayer \t(None, 500) \tproduces 500 outputs\n", " MaxPool2DLayer \t(None, 64, 6, 6) \tproduces 2304 outputs\n", " Conv2DLayer \t(None, 64, 12, 12) \tproduces 9216 outputs\n", " MaxPool2DLayer \t(None, 32, 13, 13) \tproduces 5408 outputs\n", " Conv2DLayer \t(None, 32, 26, 26) \tproduces 21632 outputs\n", " InputLayer \t(None, 1, 28, 28) \tproduces 784 outputs\n", "\n", " Epoch | Train loss | Valid loss | Train / Val | Valid acc | Dur\n", "--------|--------------|--------------|---------------|-------------|-------\n", " 1 | \u001b[94m 0.522029\u001b[0m | \u001b[32m 1.349795\u001b[0m | 0.386747 | 75.89% | 6.9s\n", " 2 | \u001b[94m 0.281187\u001b[0m | \u001b[32m 0.891798\u001b[0m | 0.315304 | 81.61% | 6.8s\n", " 3 | \u001b[94m 0.196492\u001b[0m | \u001b[32m 0.872268\u001b[0m | 0.225265 | 82.62% | 6.8s\n", " 4 | \u001b[94m 0.122728\u001b[0m | \u001b[32m 0.852510\u001b[0m | 0.143960 | 81.84% | 6.8s\n", " 5 | \u001b[94m 0.085803\u001b[0m | \u001b[32m 0.837496\u001b[0m | 0.102452 | 82.23% | 6.9s\n" ] } ], "source": [ "net_pretrain.max_epochs = 5\n", "net_pretrain.fit(X[1000:2000,:,:,:],y[1000:2000]);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Evaluate the model\n", "We now make predictions on unseen data. We have trained only on the images 0-1999." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 9, 8, 1, 3, 2, 5, 7, 4, 9, 8, 6, 3, 9, 0, 6, 2, 4, 1, 9, 3, 9, 2,\n", " 0, 5])" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "toTest = range(3001,3026)\n", "preds = net1.predict(X[toTest,:,:,:])\n", "preds" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's look at the correponding images." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false, "scrolled": true }, "outputs": [ { "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAksAAAJXCAYAAACDqRDiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", "AAALEgAACxIB0t1+/AAAIABJREFUeJzsvXl4VdX1/7+jhClzyEDCHAJhSJiEKAgIgiCoFbFarKCg\n", "tlQcPtZPUfpUxLb2o9ZPS6tWq9YRFR8Uix+rDCoCMgiIMg8hzEMICZlDEgLJ74/+sr9rr96z2Pd4\n", "k5ybvF/Pc59nnax9hnvW2fuerLX22iG1tbUKAAAAAAD45pLGvgAAAAAAAC+DlyUAAAAAAAG8LAEA\n", "AAAACOBlCQAAAABAAC9LAAAAAAACeFkCAAAAABDAy5IP8vLy4nv37r2nqqqq1cXa5ubmJvbp02f3\n", "uXPnWjbEtQH/gT2bDrBl0wL2bDo0dVs2i5elgoKC2Jtuuumf4eHhZV27dj28cOHC26T2Tz/99JwZ\n", "M2a80apVqyqllKqqqmp11113vR4VFVWclJSUM3/+/F/WtU1MTMwdPXr0V6+88srP6/t7gH+zZ8+e\n", "3ldfffXK6Ojooh49euxfsmTJJKk9t2dJSUnk1KlT34mPj8+Lj4/Pmzp16julpaURSsGeDc3x48c7\n", "3nDDDZ+0a9fuTFJSUs4DDzzw/IULFy51ag9bepsXXnjh/sGDB3/bunXryhkzZrxxsfbcnosWLbp1\n", "2LBh68PCwspHjx79FW0LezYsU6dOfScpKSknMjKyJCUl5eAf/vCH30jtuS0feeSRP3bu3PloZGRk\n", "SceOHY8//PDDfz5//nwLpYLUlrW1tU3+M2XKlIVTpkxZWF5e3nbt2rVXRkVFFe3atauPr7aVlZWt\n", "4uLi8k6cOJFc97c5c+Y8NXLkyNVFRUVRe/bs6dW+ffucZcuWja/Tr1u3blh6evqOxv6ezeFTXV3d\n", "okePHlnz589/qKamJmTlypWjw8LCyrKysnrY2vOXv/zln8ePH7+stLQ0vLi4OHLs2LGfP/zww3+C\n", "PRv+c9NNN300ffr0N6qqqlqeOnUqMSMjY/tzzz33AGwZnJ+PPvropiVLltx47733vjh9+vQ3pLa+\n", "7PnFF1+M+eCDD378u9/9bu6oUaO+4vvAng332blzZ9+KiorWtbW1au/evWmJiYmnli5deq2tLffu\n", "3ZtWWloaXltbq06cOJHct2/fnS+99NIvgtWWjX4B9f0pKysLa9myZdX+/ftT6/52xx13vDVnzpyn\n", "fLVfvXr1yNTU1P30b8nJySc+//zzsXXbjz/++G+nTJmysG67urq6Rdu2bcuPHj3aqbG/b1P/7Nix\n", "Iz08PLyU/m3cuHHL586d+ztbe44bN2457bQvvPDCfePHj18Gezb8p2fPnvvoADx79uw/zpw58++w\n", "ZXB/Hnvssd9f7GXJlz3rPq+++uo9vl6WYM/G+ezduzetQ4cOx7ds2TLIX1vW1taq48ePd8jIyNi+\n", "ZMmSG4PVlk0+DJeVldWzRYsW51NTU7Pr/ta/f/9tu3bt6uur/Y4dOzLS0tL21W0XFhbG5OTkJPXv\n", "339b3d/69eu3ne5fd/ytW7cOqK/vAZypqam5ZOfOnem+dNyeSik1fvz45YsXL765qKgourCwMGbx\n", "4sU3T5w48bM6PezZcIwfP375e++999OKioo2J06c6LB06dIJEyZMWOqrLWwZPNTW1oZcrI0ve14M\n", "2LNhmTVr1othYWHlffv23fXYY489OWjQoO98tXOy5dNPPz0nIiKitFOnTseuv/76f914440f1+mC\n", "zZZN/mWprKwsPDIysoT+LSIiorQur4FTVFQUHRERUUr3V0qpqKio4rq/RUZGlvD9IyIiSouLi6MC\n", "e/WAk5aWti8hIeH0s88+O7u6ujp0xYoV49asWTOyoqKija/23J5KKXXffff9TSml2rVrdyYuLi4/\n", "NDS0+t57732JtoE9G4YnnnjiiZ07d6ZHRkaWdOrU6diQIUM20wGVAlsGDyEhIRdddNSXPW2APRuO\n", "F198cVZZWVn4F198Mfaxxx57ctOmTZm+2jnZcs6cOU+XlpZGbNmy5bJ333339o8++mgy1QeTLZv8\n", "y1J4eHhZSUlJJP1bcXFxlFMnjY2NLaAvQuHh4WVK/TuRVNq/tLQ0Ijo6uiiwVw84oaGh1UuWLJn0\n", "6aefXleXbH/rrbcu6tix43Ff7bk9lVLq9ttvfzctLW1fWVlZeElJSWRKSsrBqVOnvkPbwJ71T21t\n", "bcj48eOX33LLLR+cPXu2bX5+flxBQUHso48++oyv9rBl8GDjWfJlTxtgz4YlJCSkdtSoUatuueWW\n", "D5wmR13MlgMHDvx+1qxZLy5YsGAa/Xsw2bLJvyz17Nkz6/z58y2ys7NT6/62bdu2/unp6Tt9te/X\n", "r9/2rKysnnXbMTExhUlJSTnUVcj3rzs+DdWB+iMjI2PHqlWrRuXn58ctXbp0woEDB7pnZmZu8tWW\n", "21MppZYtW3btzJkzX27Tpk1FWFhY+cyZM1/+7LPPJtbpYc+GIT8/P27Lli2X3X///S+EhoZWx8bG\n", "FkyfPv1NagsKbBk82HiWfNnzYvvDno1HdXV1aFhYWLkvnWRLp/2DzZZN/mUpLCysfPLkyR89/vjj\n", "vzt79mzbtWvXDv/kk09umDZt2gJf7YcMGbK5qKgo+uTJk8l1f7vjjjvefvLJJx8rKiqK3rNnT+9/\n", "/OMf90yfPv3NOv2mTZsyu3bterhTp07HGuArNXt27NiRUVlZ2frs2bNt//d///dXubm5idQeFF/2\n", "7Nev3/ZXX331Z5WVla0rKiravPLKKz+nHRb2bBji4uLyk5KScl566aV7L1y4cGlRUVH0W2+9dafT\n", "4Albep8LFy5cWllZ2fr8+fMtLly4cGlVVVUrp1IQvuxZU1NzSWVlZevq6urQmpqaS6qqqlpVV1eH\n", "1ulhz4YhLy8v/v33359SXl4eduHChUuXL18+/oMPPrjFKUTObVlbWxvy8ssvzywqKoqura0N2bRp\n", "U+aLL744a/LkyR/V7RN0tmzsDPOG+BQUFMRMmjTpn2FhYWVdunQ5vHDhwilS+9mzZ//xmWeeeaRu\n", "u6qqquVdd931WmRkZHFiYuKp+fPnP0Tbz5o162/PP//8/Y39PZvLZ/bs2X+MiYkpCA8PL504ceKn\n", "Bw4cSPHHnvv27es5fvz4ZbGxsWdiY2PPTJgw4bPs7OzusGfDf7755pvLhw8f/nV0dHRhXFxc3k9+\n", "8pP3T58+HQ9bBudn3rx5T4SEhNTQz29/+9vHbe35xhtvTOf7z5gx43XYs2E/eXl5cVddddWq6Ojo\n", "wqioqKIhQ4Zs+vjjj38k7UNtWVNTE3LttdcujY2NPRMREVGSnp6+47XXXruLtg82Wzb6BXjxk5eX\n", "F9erV689lZWVrS7WNjc3N6F37967q6qqWjb2deMDezb1D2zZtD6wZ9P5NHVbhtTWXjS0DAAAAADQ\n", "bGnyOUsAAAAAAD8EvCwBAAAAAAjgZQkAAAAAQKBFfR143759fzpy5MjD9XX8QBESctHaaUqpfyfC\n", "BxPjxo2z+2KWHD58OLhuQBOia9euAbXlhg0bFh47dmxKII8J7Ln11lsDas8lS5agbzYSkyZNCqgt\n", "z5w5s+bcuXMjAnlMYEdSUpJoS3iWAAAAAAAE8LIEAAAAACBQb2G4QGEbJqvv4zVmuC7YQoAA2BLo\n", "/u0P6Fc/nMa0nwRsCwINPEsAAAAAAAJ4WQIAAAAAEMDLEgAAAACAgOdylmxj4FI7rqPbkk46jtSO\n", "xsd5rNyNjrezPXdTxR9b2+rcINnP5u/NBbf9z1bnTx+WbFFTU+OzHf0719k+A00Jt/ajXHLJJY7t\n", "3IyzfJvrnGzrzzGaO062aIg8NVtbNKTN4FkCAAAAABDAyxIAAAAAgECjhOECMX1fcuVSly/flva7\n", "9NJLf/B1chc+3bbV+eMqptcYzG5kt+FQW9e/7T6SO5/v58aFH8w2krDtf/70zRYtWli1s7Un738X\n", "LlzwqaN/l9pJ5wo23Iba6Jhpa3d/ngGK1DdtbcbbNVV72mIbAnXTzh8CkeJQ3/aCZwkAAAAAQAAv\n", "SwAAAAAAAnhZAgAAAAAQ8FzpAI5TPJvHvWnsnOceSTqaFyHtR8/N497Lli3T8ssvv2zoDh48qOUN\n", "GzYYuvPnz/s8phRXl6Y1e3XpgTrcTi2mSHlltrkQbvMipJwzbjOndhc7n5exzROU+lFoaKiho/2P\n", "yrwtlfnx6bn5/aR2of1NKaWqq6svKvNtKTeG67xuW6c+4c/Yamu/3NxcLf/iF78w2p0+fVrLb775\n", "pqEbNGiQlvn9pfaUbEZl/gy4HXeDiUCU7nBb+sFtyZ1Al/UIRF+EZwkAAAAAQAAvSwAAAAAAAp4L\n", "w0mhFGmaKnX52rrz+XbLli0NHT0OdeV++OGHRrtdu3ZpOSMjw9DdfPPNWm7Tpo2hO3funM/jc9el\n", "bYjHi25/Ny5gKcziT4jAyXXM20luXtvpyfRc/oTdvG4/itQ3bcMxvI/R7VatWhm61q1b+9TxY2zf\n", "vl3LGzduNHSrV6/Wcp8+fQzdihUrtEzD5e+//77RLjY2VstSuIdDnw8v2Jb3P6f+IYVKpfGT24/a\n", "qbKyUss0tMZ1BQUFhi4hIUHLPIRWVVXl8xh8m7ajYy7f5veHni+YKrf7U1bHTckPf0qD0OOXlZUZ\n", "urNnz2q5sLDQ0FG7UF1WVpbR7rLLLtNySkqKssWN/eBZAgAAAAAQwMsSAAAAAICAJ8JwUqjGycXn\n", "TzhNcvXTba4rLy/X8o4dO7R85swZo118fLyWw8PDDd2JEye0/Pbbbxu666+/3nE/SlNZCNK2ero/\n", "obbS0lItFxUVGTrqiqcuYH58et/48alrNyoqSrlBCvN5fZFkyU3vFHrj/U/qYzQ0zcPUbdu21fLh\n", "w4e1vHPnTqPd559/rmV+zyIjI7W8d+9eQ0fDfLT/vfbaa0a73/zmN47HdwrFKuW9EKvU/6QwKrWn\n", "ZFt6P5Uy7ZmYmKjl//qv/zLa0TSGQ4cOGTo6rvMxsqKiwvGanfqV28V4pVlYXsD2N1R6BniaAQ2T\n", "0X7Ex1karuShNgoNhypl3lMeYqVhOKqLi4sz2uXn52s5NTXV8fgchOEAAAAAAAIMXpYAAAAAAATw\n", "sgQAAAAAINBgOUu2KxVL+Sq2cXUpL4nnRUj5FKtWrdLytm3btMzzpZxWt1fKjAMfPXrU0B04cEDL\n", "UqVa2+rTXsCf6q5O+Wg8nkzvG60EzI/J7eL07MTExDheP5/Cevz4cS23a9fO0DnlO/iTl0R1XsiD\n", "sLWRUs6VuaW8Ft7/wsLCtHzq1ClD9/zzz2uZ5jDw4w8ePNinrJSZR/Pqq68aOjrtn+ZT8H5Knx2e\n", "W0HvgT92byik/mc7tkrlAag9aY6ZUqZtqW7//v1Gu927d2tZKgnDj2877lKbcfvRbdsVALyCk239\n", "KR1A7z3N/1TKtC3tc/z5cFrp4mLX5VR6RClzLKTPXEREhNEuOTnZ6tyo4A0AAAAAUM/gZQkAAAAA\n", "QKBew3BOrkt/XP1OFby5206qMitV/6X70SnISim1ZcsWLUvTEGll4GHDhhm67777Tsv/93//Z+jo\n", "dXrRzesGfxZSpLal08FzcnKMdtQdTF37SinVsWNHLfOp/dHR0VqmzwB/dijZ2dnGNg3LuV2oN5hs\n", "Wx99k/Y5Pr2cbv/1r381dDT0Rm154403Gu0mTJjgeP1O7nyllHr00Ue1TEM8Y8aMMdp5PRwj4SYM\n", "7s9iuVKIldqd9iMe5qR25uGS9evXa3ns2LGO1297zVKF6aaCP6Ew2v/at29v6GjpFfr7x+8hLenA\n", "+zfV8f5H4WP+yZMntUyfIz7GJyUlOR4z0MCzBAAAAAAggJclAAAAAAABvCwBAAAAAAg0ynInbuPE\n", "bqbBch3n2LFjWqbxcaXMqZQ0V+auu+4y2tFYL4+5B3r6oheml3Ns7SlN9aXLHPApwnSpBL5yPJ9K\n", "SnGazs9XiqfXz1clp23pkhtKmUsA8Fi903X4o2sobPOtbKck8/7mVGJAKaU++eQTLfOlEnr16qXl\n", "6dOna5nnVpSUlDieW8pJpM8EteWMGTOMdnTZI2m5DC8sieF2xXnb8i3cflI+Ez1OXl6elvnK8XT6\n", "Pr+HNOdzxIgRhi7Qy0BJy514oZ9K2I7BvF1aWpqWpd9NaeyW7rW0nArNXeNLqND96DImPGeVHpMf\n", "P9A2g2cJAAAAAEAAL0sAAAAAAAKNEoYLBNI0ZsndXFBQYOjoCuPUVayUORX2tttu0zKdxqyU6f6j\n", "0y2VUmrDhg1a5tVj6X62LmUvuPrrg5SUFC1zO1B3MA93SSuDc7dsHdKzc+bMGUNHw3J8eit9Dty4\n", "/TlNxZZSiJzf+2+//VbLPDxKQ2P0XtPV0PkxeZjon//8p5ZpX1TKDPdOmjRJy/y5kcIxwRSq4Thd\n", "rxTKk8KcHDre0VAm72O0HS/tQsdTPn7S6+J9n25Te0rtJF0wE4gwu+1vENfR31ua8qKU2W95WQFa\n", "Eob2U/4M2I67qOANAAAAAFDP4GUJAAAAAEAAL0sAAAAAAAKeyFmyjTvart7O29FciC+//NLQ0fwY\n", "nm80ceJELcfHx2tZyoni02LpdGge7+/Zs6eWpdyHQOTDeAEez6b3Iz09Xct0mRmlzKUSjhw5Yui6\n", "du2qZaccJX+ui8fO6f3OyMgwdNJq9E7HkGzbWARiCrY09VxaLoQek/c/mptE+7C0bMfmzZsN3aJF\n", "ixyvmfZvOi2d5tcoZZ+X5MV8QimfRCqpQrHNB+Xfl9qM2paXiKB5Svz4e/fu1TJdAkMpc8V53ved\n", "8kH9sVEwjbv0+gK1hIvTd+b3uqKiQssHDx40dFVVVVrm+W0dOnTQMv195dDnqDHHT3iWAAAAAAAE\n", "8LIEAAAAACDQKGE4qcqnLf64+jdu3KhlHuKh18JXtR46dKiWaXiGT2+l58vPzzd0NDwzaNAgQ0en\n", "RvPK0bZ4wT3sNjxDoSGBAQMGGLo9e/Zo+fjx44aOlneIi4tzPL5UYZqWBODT0ukUVh6io7YNRCjZ\n", "C9RHGE4qHUBDKdTO/HxShf5t27Zp+fXXXzd09Pno37+/oZs8ebKWaRXwQIXTGqNv+jO2uikdII27\n", "HKfwJS//QcdBai+lzFIQvN9KpQOcygV4YbxsTGxTWTh0XDx16pShy83N1TK3EbUn7etKmSszcPtJ\n", "aQ1uQOkAAAAAAIB6Bi9LAAAAAAAC9RqGc8rQ9yej3ckFLM3K4Ozfv99RR7Pwr776akMXHh6uZeo6\n", "5q5GWqV0x44dho66g8eNG+d4HRTJDd6UcJrBSO+7UuZCinR2jFLm7AsenqFhOWozHmqjCzrSkIBS\n", "SnXu3FnLbl3DwWw/277ptkrwjTfeqOUvvvjC0K1evVrLd955p5b5gsZvvPGGlnmI/Nprr9XyTTfd\n", "ZOiKi4u13FRDNYEIo0r2czoXh4bTYmJiDF1UVJSWuf1oKgQdB5QyZ9VJoVNpppjtdwsm/Pn9oLbm\n", "9qOzD2nojc+GozbjqQq9e/fWMg+xNuRMRGkWri3wLAEAAAAACOBlCQAAAABAAC9LAAAAAAAC9Zqz\n", "FIgYsG1eBOW9994ztmleC883opV7+dRzp1gsj3du3bpVy3QKslJmHg2P59LqphJNMa7Okb4XtQud\n", "yq+UmW/Ec9NoPL59+/Za5lNfqV169erleAxbgtlG/uQTOuUQSveMH49OJ6b5KUqZZT6eeuopLfOc\n", "CZoLwfOSRo8e7XhuN1Pnperhtqu2NyS253X7HaXcEtqW9jGao6SUUmFhYT7PpdR/5iE6wXOWnK4j\n", "UDov4KZqt9SOV0inJQGcyngoZdqIHz87O1vLvHQAzQ8NBjvAswQAAAAAIICXJQAAAAAAgUYpHSDh\n", "dmonPdexY8ccdQkJCYaOhuG4y9fJBcwX/Dxw4ICWeYiAhgHqw9XoBVe/LW5LIlAXe7du3QwdLelA\n", "7aCUueju6dOntVxaWmq0o1OS+fRW23IBXnEVBxq3JQEo9Lnk/YPux0OstAwH7XPcRg8//LCWefV3\n", "GurmC7hSpFBTU8WpXIBkZx7uottS+I6WDuDlAaQFfenxeV+UFs52k77R3OHhUTpO0vvWtm1box21\n", "C38+6MoUNGVCKfOZSElJMXSBCCsGGniWAAAAAAAE8LIEAAAAACCAlyUAAAAAAIF6zVkKBE4xSZ6f\n", "Q2OlfEo+3U5LS3Pcj8fE6bmpbt++fUY7uvwCz6cYMmSIz+v3B6/nIkm4yWuRpiDzPAVaEqC6utrQ\n", "nThxQsv0GYiNjTXa0Ty2QK04b4vXcs78yatzynOR+qaUZ0Jtyfej/Y/buV+/flrmfZ/mTPBzu8mp\n", "lPBiPoytPaV+Su+TtDo8tzvNRaL3nttPWnIjIiLCcT/pWWoOuFluSOqbPBeJ/lZKy+FI9qNLS9Ey\n", "AlxXVFRk6PiSOF4AniUAAAAAAAG8LAEAAAAACHgiDBeIFa937typZe7So6vYX3bZZYaOu3Yp1KVI\n", "py5/9NFHjsegpQiUMqe2SxW73awO3lSRXMX8+1Ndhw4dDB2dKk6fCV5lnbqDeZV1L4TGGhPbvknh\n", "94yGS3iom9rl3XffNXQVFRU+j89DQbQsBO3r/Ny2q5xLSM+m15HCqFI7KYwqheGcxk/a3/jx+TVd\n", "ddVVPs/l63w2+FOhvrnBbeumnAa3H63OTn8LlTJLE/ByPLY0pP3gWQIAAAAAEMDLEgAAAACAAF6W\n", "AAAAAAAE6jVnySnO6c+yF7ax0vLyci3zPCSau8JXps/IyNCyNCXyn//8p5Z5LkV0dLSW+/fv73iN\n", "tjkTwRxHD0ROlVQ6QILnhOXn52u5Xbt2WuY5S9u2bdMyfR6U+s+lGZyQ7NdU7BmI5U4KCgoM3e9/\n", "/3st8+UQ6BIIPXr00DLNT1RKqaeeekrLc+bMMXS8lIfTddG8Gal8RDDbkiPloznhTz4hhebD0HIO\n", "/NxSf/NnbHGyrXT9wWzbhlzSRRrfpPsbTPl9voBnCQAAAABAAC9LAAAAAAAC9RqGs62Q66Z0AD8e\n", "rRZLVzNWygyT8TBLixb/7xbw1a/Xrl2r5YMHD/rcRymlJk2apGU+dZlOiZRW7JbcwU0lDGAbxnEb\n", "7qFhN96WhnF4KOjQoUNazsrKMnTp6elatrWLP65+r9nTn3vvpON9uLi4WMt33XWXoaPTiSdPnmzo\n", "7rnnHi1T29LQnVJm+K6wsNDQ0arEtiEC3k9pCCnYQnSBGFvpfvwYdMzk4ydtK43PdJufm6ZN8LIv\n", "9H7zae9ONgs2+0m4CbdJ+9iWBvFnjKDlAXiaBG3Lw6+2Y2tDpj/AswQAAAAAIICXJQAAAAAAAbws\n", "AQAAAAAIeGK5E4rbVd9pHhEvq07j5XRpBKWU6tatm5ZpjpJSSm3ZskXLdBmMkSNHGu06deqkZV62\n", "XVotnercxtWDKc5ue61STJzH1em9ysvLM3SJiYlapquX0xL8SplTmY8fP27ocnJytEzLD/BzB3Pu\n", "g4RtSQBpn82bN2uZ33s6tX/06NGGjralfTghIcFoR/OZpKU6+HIZtD86yUqZ+S88NyaYbO12SrlT\n", "7hHf5nkndEymtuTPAN2P38/t27dredCgQYZOGlud7MmfAdvlcLwIzeeiv3l82SepfAZFylWTxmC6\n", "Tcv0KKXU4cOHtczvb1RUlJbj4uIMXSB+GwMNPEsAAAAAAAJ4WQIAAAAAEPBEGE5yn9lWWI2MjNSy\n", "FIb78ssvDV1MTIyWT5065Xhd7du31/KQIUOMdrSiN58eSUM83AVMt6XpybaVT4PNjWx7vVIYgJYB\n", "4K54ajNpBe3k5GQt8zDcrl27tDxw4EBDR8MHtqGaYLaR26n3K1as0DKfNv7f//3fWuZhFnp/qZ2L\n", "ioocr5E/A9Jq91RH+60U0rEt/8GvywtI9rMtj8D7Dg218TAcTV2gJRz4+Ez7Jr/31C48xYGOu1zn\n", "ZE8pDOd23G0ouP1ee+01LdNVCaZNm2a0GzVqlNXxbUsC8Os4efKklnn5Fgq3e+fOnbXM7eKmrA4n\n", "0OMuPEsAAAAAAAJ4WQIAAAAAEGiwMJzkynVa9FAp001KXXU8I79r165apmEVpcxZUtxNSCv+8hBP\n", "bGysln/0ox9pmS+k68YdrJR9GM7WnVjfCyjaILlJ+fei10t10ow3rqP3TQoRSGEyanc6O1IppVat\n", "WqXl9evXGzo6K5IfkxJMsxml6+Pf0Wk2Eq9wT6v4cne7dG9OnDih5cWLF2uZL8RKq6zTWY/83DwM\n", "5xQ+58d36qdKeX8hVjdjqzRrkNuWbtuGrXg7ej5uI7riAp9pRRdPdxuGs13o1Yu2/fjjj7VMZ5N9\n", "//33Rjs6pkkzEfn9peOpNFtUgqbHdOzY0dBJv3lerMAOzxIAAAAAgABelgAAAAAABPCyBAAAAAAg\n", "0CilA/zJi7BdcZ5y0003GdvvvPOOlukK6EqZU5n79+9v6OiUS3qNPLZL4+XStGOpdIAUl7XNi/Bi\n", "XF3KmaC4qRStlDlllt9fGp+neShS7g2f2k5z3GjFXKWUGjZsmM9r9GdlbK/Br0/KCaNI/fTee+/V\n", "8v3332/o5s2bp+X58+cbOjr1nF4Hr0g8ffp0LUt5STzXkD4TUokPKd/N6zlLFMm2dJwKVO4jPT61\n", "5YgRI4x2ixYt0jKvPp2UlKRlmn+mlDnu8jwzJ3ty+9nminoBbpeXX35Zy7feequWaakOpcznvnv3\n", "7oaO5jrxfD9qMzou8jGS5iLxY1D8ufduSgfUdz4oPEsAAAAAAAJ4WQIAAAAAEPBEBW8pPENdqLbT\n", "YPn01ttvv13LvDwAn4pOodNPqXtfCqfZhtr4NUvfzWvuYAnbauy8LdVx+zlNcVZKqUOHDmmZVxCm\n", "7mfp/tJt7mKm29u2bXO8/mAKtfmDFCKn0JAIb0cXNP7Zz35m6Ogiu9nZ2YaOLnp95513apmW8VDK\n", "DJXycIw05dkpRC6F2oKtb9qGwZ324ftJFbbpVH6lzH5Mx10avlZKqczMTMdrdAqV8msJxOoIXi/r\n", "wRk+fLiWad9ZsGCB0Y6mjfBQHrULLZWjlFLx8fE+2/FxlobFbcd4t7rGTEOBZwkAAAAAQAAvSwAA\n", "AAAAAnhZqwg1AAAgAElEQVRZAgAAAAAQ8ETOEqU+4uo01i2trCydwzZfynZldr7t9fi4W9x8L55/\n", "QOE5ZzQvacOGDYZuwIABVtch2TY3N1fLy5Ytc9wv2Eo62GKb82LbP/gK6GPGjNEyzx90KkfAj0/L\n", "gUj5RrZLXTSlvBaKNDZJf5fuIR1r/ckHdUI6t2Rb2zyzxlwuoz5p27atlmfOnGnopLIebnUUnktG\n", "sR0X3ZZbaUibwbMEAAAAACCAlyUAAAAAAAFPVPCmcHef7RRCus2PYVuFWLpOty7DYHM11ie231Fy\n", "B3N3+5VXXulTVkoO59le16xZs7T8i1/8wnG/pmIjCdswjrSfVKHfNmzjz+rw0pjhpAvmCuz+4DS2\n", "cjs4lW9RyrSnbRhVug7p3rudet6QVZ69iO135O0CVcnd5jqC4fcPniUAAAAAAAG8LAEAAAAACOBl\n", "CQAAAABAwHOlAzi2+QJu85ICEZcNhnirF3G6N/7cs4aMq/+Qtk0Rp1wk21wmpWT7Bbpvop86Y5tX\n", "Ji1505C29LVtq2vO1HfOlm1uWjACzxIAAAAAgEBIsL/tAQAAAADUJ/AsAQAAAAAI4GUJAAAAAEAA\n", "L0sAAAAAAAJ4WQIAAAAAEMDLkg/y8vLie/fuvaeqqqrVxdrm5uYm9unTZ/e5c+daNsS1Af+BPZsO\n", "sGXTAvZsOjR1Wzb5l6Vz5861vPvuu1/r2rXr4cjIyJKBAwd+v2zZsmulfZ5++uk5M2bMeKNVq1ZV\n", "Sin1q1/96n979uyZFRkZWdK7d+89CxYsmFbXNjExMXf06NFfvfLKKz+v7+8C/s2oUaNWtWnTpiIi\n", "IqI0IiKitHfv3nuk9tye06dPf7NVq1ZVdftHRkaW1NbWhigFezY04eHhZXV2iIiIKG3RosX5Bx98\n", "8Dmn9tyWffv23UX3Dw0Nrf7Rj370f0rBlo3J/v37e7Ru3bpy2rRpC6R23J51FBQUxMbHx+eNGDHi\n", "67q/wZ4Ny549e3pfffXVK6Ojo4t69Oixf8mSJZOk9k2+b9bW1jbpT3l5edsnnnhi3pEjRzrX1taq\n", "f/3rX9dFRESUHD58uIuv9pWVla3i4uLyTpw4kVz3t3nz5j2xb9++nrW1tWrjxo2ZMTExBevXrx9a\n", "p1+3bt2w9PT0HY39XZvLZ9SoUV+99tprd9m09WXP6dOnvzF37tzfOe0DezbOp6ysLCw8PLz066+/\n", "Hm5rS/7p1q3bwQULFkyFLRv3c80116wYMWLEmmnTpr3t1Eay5z333PPqyJEjV48YMWIN/Tvs2TCf\n", "6urqFj169MiaP3/+QzU1NSErV64cHRYWVpaVldXDX1vWfYK9bzZ5z1Lbtm3Pzps377edO3c+qpRS\n", "11133afdunU79N133w3y1X7jxo2XR0dHFyUnJ5+s+9sTTzzxRM+ePbOUUiozM3PTiBEjvt6wYcPQ\n", "On1mZuamgwcPphw7dqxTfX8f8G9q/39P0MXwZc+L7Q97Ng4ffvjhjxMTE3OHDx++1pfeyZZ1rF69\n", "+qr8/Py4m2++eXHd32DLhuf999+fEhMTUzhmzJgvpX7mZM/169cP27VrV98ZM2a8wfeHPRuGvXv3\n", "9srJyUl66KGH/hISElI7evTor6688sp1NKpCaQ59s8m/LHFyc3MTs7Kyevbt23eXL/2OHTsy0tLS\n", "9jntX1FR0Wbz5s1D0tPTd9b9rUWLFudTU1Ozt27dOqA+rhn8J7/+9a+fio+Pzxs+fPja1atXX+XU\n", "zsmeL7744qx27dqdGTx48LcfffTRZKqDPRuHt95668477rjjbSf9xfrmW2+9deePf/zjD9u0aVNR\n", "9zfYsmEpKSmJnDdv3m/nz5//y4v9Q+PLnhcuXLj0gQceeP5vf/vbfb72gT0bj5qamkt27tyZ7kvX\n", "HPpms3pZqq6uDr399tvfnT59+pt1niJOUVFRdERERKnTMX7xi1/8fcCAAVvHjRu3gv49IiKitLi4\n", "OCrQ1wz+k2eeeebRQ4cOdTt58mTyz3/+81duuOGGTw4ePJjiq60vez744IPPZWdnp+bl5cX//ve/\n", "nzt9+vQ3169fP4y2gT0bliNHjnRZs2bNyDvvvPMtpzZS3zx79mzbxYsX3zx9+vQ3uQ62bDjmzp37\n", "+3vuuecfycnJJ0NCQsTlIXzZ87nnnnvwiiuu+GbgwIHfO+0He9Y/aWlp+xISEk4/++yzs6urq0NX\n", "rFgxbs2aNSMrKira+GrfHPpms3lZqqmpuWTatGkLWrduXfnCCy/c79QuNja2oLS0NMKXbvbs2c/u\n", "3r27z6JFi27lutLS0ojo6OiiQF4z8E1mZuamsLCw8tDQ0Oo77rjj7SuvvHLdZ599NtFXW1/2HDhw\n", "4PcxMTGFl1xySc2ECROW3n777e9y7xLs2bAsWLBg2ogRI77u0qXLEac2Ut/86KOPJrdr1+7MyJEj\n", "13AdbNkwbN26dcCXX3455qGHHvqLUhcPlXN7njx5Mvn5559/4Mknn3xM2g/2rH9CQ0OrlyxZMunT\n", "Tz+9LikpKWf+/Pm/vPXWWxd17NjxuK/2zaFvNouXpdra2pC77777tby8vPjFixfffOmllzound2v\n", "X7/tWVlZPfnf582b99vly5ePX7Fixbjw8PAyqjt//nyL7Ozs1P79+2+rj+sH7nGypwTs2fC8/fbb\n", "d0heJaVkWzqF8GDLhmP16tVXHT58uGvnzp2PJiUl5fzpT3/678WLF988ePDgb3215/bctGlTZk5O\n", "TlKfPn12JyUl5Tz00EN/2bRpU2ZycvLJuhcv2LPhyMjI2LFq1apR+fn5cUuXLp1w4MCB7pmZmZt8\n", "tW0WfbOxM8wb4jNz5sy/X3HFFRvKysrCLta2qqqqZXx8/Gma1f8///M/v+7Ro0fWqVOnEn3ts27d\n", "umF9+vTZ1djfszl8ioqKopYtWza+oqKidXV1dYt33nnn9rCwsLL9+/en2trzgw8++HFpaWn4hQsX\n", "Llm+fPm4iIiIktWrV4+EPRvns27dumFhYWFlF+ufvmxZW1urjh071rFFixbVBw8e7Obr2LBlw3zO\n", "nj3bJjc3NyE3Nzfh1KlTib/61a+e/fGPf/xBfn5+Oxt7VlVVtazbPzc3N+Gvf/3rg5dffvk3ubm5\n", "CbBnw3+2b9+eUVFR0bq8vLzts88++6uUlJQD586dC7WxZd2nKfXNJu9ZOnLkSJdXXnnl59u2bevf\n", "vn37U3U1HxYuXHibr/YtW7Y8N3369DffeeedqXV/+81vfvOHY8eOdUpNTc2u2//pp5+eU6d/9913\n", "b7/33ntfaojv09yprq4OnTt37u8TEhJOx8fH5/3tb3+77+OPP74xNTU121d7X/Z87rnnHuzYsePx\n", "mJiYwkcfffSZf/zjH/dQFzHs2bC8/fbbd9x8882Lw8LCyqV2vmyp1L9DeMOGDVvfrVu3Q3wf2LLh\n", "aNOmTUVCQsLphISE04mJibnh4eFlbdq0qWjXrt0ZX+25PVu2bHmubv+EhITTUVFRxXV/q9sH9mw4\n", "FixYMC05OflkYmJi7ldffTX6888/vyY0NLTaV9tm0Tcb+23Ni5+8vLy4Xr167amsrGx1sba5ubkJ\n", "vXv33l1VVdWysa8bH9izqX9gy6b1gT2bzqep2zKktlacsAAAAAAA0Kxp8mE4AAAAAIAfAl6WAAAA\n", "AAAE8LIEAAAAACDQor4OfObMmVnFxcX/UbwRNAwpKSmjAnm8HTt2rArk8YA9GRkZowJ5vLy8vMfL\n", "y8uvDuQxgT1du3YdFcjj7du3b1UgjwfsSUtLGxXI4+3cufO50tLSfoE8JrBj6NChoyR9vb0snTt3\n", "rnt5ebnjml0guCguLoYtmwhVVVW9z549C3s2EUpLS2HLJkJJScmAgoKCEY19HeA/QRgOAAAAAEAA\n", "L0sAAAAAAAL1FoZraEJCxDUbPQlqXP1wLrmkft/3a2pq6vX4zYFg65vol84Emy2Vgj0DAcZZeJYA\n", "AAAAAETwsgQAAAAAIBBUYbhAuIC5O1E6ppvzcZev5AK2dT02Bzey5OaldvDHXrb7SdB7L9lWahcM\n", "LuYfiu39dWs/N+fiSP3I1s7+HDNY8ef+uumbbsdcf+xg2zclmqJtbcdZvi3Zz1bHcTO28rFU0gUa\n", "eJYAAAAAAATwsgQAAAAAIICXJQAAAAAAAc/nLNnGz2ks1m1M1Z94qxNS7JXHVOnxbdtd7HzBhJPN\n", "+PeVbGtrd9upr/7Yj25T2R+bBHM+k21OUSD6X33nRUj2s815Cea+6DbfSOpjTvv5kzdK8ScX0LZv\n", "SrZ1Gp+DDdvxk9vFSSfZz22JAWlsvXDhglU7/t0Cnc8EzxIAAAAAgABelgAAAAAABDwXhpNcspI7\n", "sbCwUMtTp041dNddd52Wf/rTnxq6/Px8LRcXFxu6vn37ajksLEzLbdu2dbxGW3ci10nuRL4fJZhc\n", "xW7dvJdeeqlPmbdt0cJ8nGlb6fiSu5bee26H8+fPW7Wj24EoJdFYuA2TuXH1820nW/Lz+RNGdbKZ\n", "bbjV17YTXuybgbAfbcv7plO/lewsjf/+jK10m/ZTbgepb9qGeLyGNEZKYysfP2nb0NBQx3Z0Wzq3\n", "NO2f2ohvV1dXW7WTngGOm7EWniUAAAAAAAG8LAEAAAAACHgiDGcbepPciTSENmDAAMfjLVu2zNiO\n", "iIjQMg21KaXUli1btEzdi507dzbapaSkaDk8PNzQUTehrQtRCnfwY3gdW/e7FGqj2y1btjR01AVM\n", "XcV8m7aTwnDcdXvu3Dkt83tPdVSWvqfkGuZ4ISznZiaUP2FUKQzgpOPHkLB19Uv9VAqx0nvgNkTX\n", "ULi1n1M/VUq2C9VJ/VQaI6QwqhSeqays1PJrr72m5T//+c9Gu23btmk50GGbhkS6h7Y24mMrtVOr\n", "Vq0c21FdTk6OofvLX/6i5S5duhi6++67T8vUlkopVVVVdVFZKXl8tv3dtLUtPEsAAAAAAAJ4WQIA\n", "AAAAEMDLEgAAAACAgCdylii2U4t57PXbb7/VcmpqqqGLjY3VcnJysqFLT0/XMs1fUkqp3NxcLZ89\n", "e1bLZ86cMdoVFBRoOS4uztDR/CaeE2ULjdvz7y3lOjUG/lR3dcpJ4bkrNHbO4+V0m8bOuY4eg99D\n", "GrOW8pJoHoRSzvk8PK4uVQn2ei4ExXZKuT95LbZTkqktpSnO/P5KuUjUtm6rSNPtQKwA0JDYVth2\n", "az9qM8l+9Bhu8wkrKioMHc1NPXLkiJbvvfdeo5307Ei29QJu+p+U18nHT7rdunVrLbdp08ZoR3U8\n", "Jzg6OlrLfFykYx//7aXX7PbeS/lubko/wLMEAAAAACCAlyUAAAAAAIFGCcPZLtrIt6mrcfPmzUY7\n", "WsE7ISHB0A0dOlTLGRkZho66FLl7uHv37lqmLuCTJ08a7Xbv3q3lU6dOGboTJ05oOTMz09DRMgNS\n", "lWAvuoCd8Kf6r1MYjruKqTtYchVLYTh6Lun+chc21fHprUePHtVyXl6elteuXWu0o9Nn6TOllFLv\n", "vvuuz3M1Fv4sdOum9IMUBuAh1pKSEi3TULe0WOeePXuM7aKiIi3zMBwNC4wdO9bxOmjf5+f2ehjV\n", "TWVuf+xH+63UN2nYY+XKlUY7mqoglX2RyjbQvqiU2R9pWsaMGTMcjxls467Tb6M/9nMKtSll/jbS\n", "VSt4GI6GQ/lvI+1L3H40debaa69VTtiuomC7kLNb4FkCAAAAABDAyxIAAAAAgABelgAAAAAABBos\n", "Z8l2SRPbnKVu3boZ7Y4fP67l9u3bG7pevXppmcdlbacdU3j5gaSkJC2vX7/e0B07dsxRN2bMGC0H\n", "Ir7aWCthu7Ef35aWvbAtHSCVBFi+fLmWDx486ONb/JuoqChjm8bIaSkJpcz8NFrmn9pcKaWuu+46\n", "LZeWljqeu7GwzSG0zWf6/PPPHdtFRkYaut69e2uZl+Sg+Ua8bAPF9rmXcuakaeJul6uhNFTf9Cfn\n", "zLZ0gJQPQ/umlM9E+wfP66TjKc8LlKD9e+vWrYaO5uJcddVVWpbGCK9jW1bHn+WGpLGV/lbS+1lW\n", "Vma0W716tZb5GCk99/R8tvms/Pql355AA88SAAAAAIAAXpYAAAAAAAQ8V8Gb4+Ra46GwqVOnalla\n", "PZkfT5o6alvBlboGL7/8ckfdrl27DN0333zjcz+pkqxEY011tXX12+4nTX2VVpwvLy83tj/55BMt\n", "5+fna/nKK6802lG3Mg39KKVUcXGxllNSUgzdkCFDfF5/TEyM0Y66iuk0W6XM56+xwqgUt88Q3Y9O\n", "21bK/F78+2/ZskXLPPxKkfopRXLnc+h1bdy4Ucs0bBMovDAN3fYapDAk10l9k/arTZs2ObZr166d\n", "lqUq+Xw/Wk6Ch3BpuLdnz55a5s+f1Oe80B8ptmOrZD+egvD6669ruUOHDoaOpiTQ31ReLZ2OrVKY\n", "modpaQiep7w4rXrgj71s97MFniUAAAAAAAG8LAEAAAAACOBlCQAAAABAwPM5SxQ302D5No+p0vwH\n", "Kd4qTa2VSEtL0/K2bdsM3YEDB7RMSyHwnBdKMMXYlXKXbyXF3Dk0Bk/LA/Bz/+QnP9EyL9dPc2Wk\n", "vBk+rZnmV1CZr67N8yScrrGpIJV+4KUDqK153gK939LK9LQPu516To/PbULb+ZMXEeicicZCyhuS\n", "8vFWrVqlZboMBi/7Qp8Jbj9pmaLvvvvOUZeenq5ltzay1QUT/Dfo9OnTWuY5RTQ3idqZ5yzRXFFu\n", "B1py4LbbbjN08fHxjvs5Lf8l9U0p5zgQ9oNnCQAAAABAAC9LAAAAAAACQRWGk5DCOJI7znZKMnUH\n", "S2Eifgw65bJr166GjpYOoGEcyWXoxYqzgQg32IZRt2/fbuioq5+HCKjbl5eTcDq+BL/3Ts+OPy7f\n", "YHXnc+g9zMjIMHS0zAfvA3TaMS85QMOZNKzCw3CHDx/W8vfff299zdRmgwYN0rI/NgmmUFt9982s\n", "rCxDR1dVCA8P1/Jll13meF3S2MrDP0eOHNEyDyGlpqZq2bY8R7CF2myfPXpPR40aZehWrlypZanM\n", "Bg2xhoWFGTq6X2FhoaOOh1/pdUm/y06yr/2cdCgdAAAAAABQz+BlCQAAAABAwBNhOOoOt634LOmk\n", "dpKrVXIBSzOm/Dkfhc788GJ4zQ3+uLJtF4KkoZovvvjC0LVt21bL06ZNM3TUTvSY3GVPQ3TcltRG\n", "trNl3Lp8vfAMBMJd3b9/f2ObzojhJCYmajkhIcHQOc1O5ddIwz883CotlE0rO9NFQ/1x9XuhMreE\n", "NL45fS9/ZhrTRaO//fZbQ0f75sSJE33+XSnncVYps6/u2bPH8broc8SPSWdZej20JhGIlR34fXrp\n", "pZe0TFcrUMoMi/M+TVm8eLGWN2/ebOikfkX7Kp9J6TTLTZrxxpHCfG7GWniWAAAAAAAE8LIEAAAA\n", "ACCAlyUAAAAAAIEGy1mSYudu4HktbvOG6HGk1e5tKwjzuCyd7nr06FHH63Kbq+UF6PeXpp/a5kJI\n", "eUM81lxUVKTljz/+2NDRXBlaLZZPX09JSfG5Dz93U63QbPsc8u9oaz9buG2dKkdLuTc8Z4nqaP6E\n", "Uuaq57RMQVOxpVJy3gaFjmlSP+XlHdasWeN4zCuvvFLLtHQAHyNonhK336FDh7S8c+dOQ0cr8V91\n", "1VWGTqqa70QwjbNKOV+vZD9+72n19Pbt2xu6Pn36aFkqv0BtGx0dbejo76a0cgK3lxfL5cCzBAAA\n", "AAAggJclAAAAAAABT5QOkAi0q18qD8CnlNsusCq5DAsKCrRcWlpq6JxCC153B7vFbRiOTim/4oor\n", "DF1OTo6WeXiUun3p9GE+xXnv3r1aHjNmjKGTFliluF3kOZiQvpebdkqZ95Tbz6lv8n5kuwguX8TX\n", "CX+uv6kgPaOnTp3S8ldffWXo6Bg2YMAAQ0crt5eUlGiZLryqlFJnz571eS6lzPGT25amOCxatMjQ\n", "0fA8Pd/dd99ttLNNfwim0Kzb8ce2rA7/LaRhOF7dW/p9tZ3ab2sjKTUnIKk/P/gIAAAAAABNGLws\n", "AQAAAAAI4GUJAAAAAEDAczlLgcj34HlDNJZJVyhXyoyVdu7c2dDxaZB18PIA0tRGKaeGrs5O4/u2\n", "U3wvdm4vYJvLQ+Hfn35nnrMkLZVAywDQeHllZaXR7tVXX9Xy119/bej4Kt2UQOfQBZttbXGzLINS\n", "5v2gSzHwnDPpXPQe0uVNeNtA5DTYLifiFZyeXz6N+/PPP9cyLaWhlJkXSKf5K6XUgQMHtExLM/AS\n", "DjyXhULtJ+XKlJWVGTpaDoTbvSlim7vDkfJt6XNAS0RMmDDBaOe0rBSHLlullLlUjlRyhlIfucq2\n", "4yw8SwAAAAAAAnhZAgAAAAAQ8FwYzhY+/fTTTz/VMq/CTF183E1IXcB0CrlSSkVFRWmZVjelLl6l\n", "zKqzkiuauxppJWmqo9Pcgx0301Z5mFNy7VK4O5Ueh56bVwnu1q2blvnK5iNGjLA6d3NACqNSG0lT\n", "kP0JLdLj0+r3dBr6xa6RTmfnpQOc+llzKBUgkZ2dbWzT6fx0TFTKDNUUFhYaOhqio1PKu3fvbrQ7\n", "c+aMlmmpAKWUioiI0PLYsWMNHR27eeiQbtPQIQ8jNhVs0x2kMDUfd+mKCCtXrtTyrl27jHa295eX\n", "d6BteWgvMzPT5/VLfbO+0xbgWQIAAAAAEMDLEgAAAACAAF6WAAAAAAAEPJezJMVb9+/fr+VNmzYZ\n", "7Wh8nK4mrpQZZ+f5LzSGS6cyKmVOR923b5+Ws7KyjHZ0OY4TJ044Xn+/fv0MHS1VQPMnvD7lWMKf\n", "0g+2pQOkFa9prpd036Ty+fSZoFOclTLzY/iUZ1vodQWbbW2XGpCQ7r203AntE7t373ZsR+E26tKl\n", "i8/jSQSbjWyx7Zs8p49O0Y+NjTV0Q4YM0XJiYqKhc8pZ4jlnNFeUlxEYOXKklnkuKs+xcUMw29rN\n", "UmDS2Mr3o2V2aA4Y//2jduY2kqboU1vzsj1O+GOvQNsWniUAAAAAAAG8LAEAAAAACHgiDEddddwV\n", "ePLkSS3TSrLUNayUUoMHD9ZyWlqaoZNclPTcdAq5Ukrl5uZqmYYA6YrWSpmhN+7qp+7n9PR0Q2cb\n", "evO6q1iyH92mU4SVUurIkSNapveJu2Rp2QZ+fDr9VKqATUtN7Ny502j33XffaZnbiE4359OTnabE\n", "S1Png5lATKm3DZUqZdqThgt4OxqKjYuL+8HXJdkvmG1pG4bjFa/79OmjZV7+hNpIqhxNxzpegZ32\n", "YTqOK2WuouA27NZUbMvvr9O4a5vuoJT8/el0flougJcHaNeunZZ5GgOt7k3TVZRS6qGHHtIy/250\n", "lQXpGhtylQN4lgAAAAAABPCyBAAAAAAggJclAAAAAAABT+QsSTFVOn2Rxid5/JPG2W2XZeDb0pRk\n", "KTdGgk6llOKtwRQ7d8uvf/1rY5veGzrtmC9L0aFDBy23bdvW0NE8BskuNGeCt6PLzgwfPtzxGLb2\n", "43H0YLatbS6Em3ZKycuk0KVn6H48b4Y+HzznxU2+hj95LcFmTzfY2k/KWaLLPvHyKjExMVrmZV+k\n", "54P2ad7n6LaT7Gs7WLHtf/78/qWmpmr5ySef1DLNQ1LKLAHwj3/8w9DRXFFqZ6XMkgM0R0kp52VY\n", "bO2sFEoHAAAAAAA0KHhZAgAAAAAQ8EQYToKvgF0HnyJcWlqqZbpCuVKm25C78Knr7vjx44aOt62j\n", "Y8eOxjZdGZtW+lbKrApOXdH8OLaufq+7jaWwBw/D0bIQZ8+e1TItI6CUGa7j1YWpjXj1ZloKgrbj\n", "9qPH5KUfqHuY66h72NZVHMy25di6uaUQmlRaglYKpq5+HgZISUnRMn8+aPic399A28+LIblAlHug\n", "8FANtSe3bWFhoZa3bNmiZV7lecCAAVrm9rMNofGyAk72lPqYF+0nYbsCgrQPtSe3H7UFTVXgVdbp\n", "dqdOnQwdLbnDf//o+M9TL2i/peMuH4NtQ7GBKDkAzxIAAAAAgABelgAAAAAABDwRhpPchtTlTquD\n", "8nAXdenxGVOSC5/q+Aw76rKkVaWTk5ONdrSyM3cT0gVAFy5caOhuvPFGLVM3Z31n9dcnUpiCfkel\n", "zBmMUqiNbnOdZFu6TW3JXfb0ueJVuuk21zm5ivnxJXdwMOE2BCXN1KE2oguqKmU+EzRcQMPeSplh\n", "Vd7/qI145WEn975kv2DumxJuw4mSbTdu3Khlaufu3bsb7WjVfCmcVt+2DbaZjk428yccRW0m/TZS\n", "mYdRpTGYwsdPmuLAx3WnMZnb2SmUrlTgQ+TwLAEAAAAACOBlCQAAAABAAC9LAAAAAAACnshZovB4\n", "6w033KDlNWvWaJnnJV1++eVa5jFVGv/k+Q60iiivMErjnDTuzVdWpnFUfgw6HZOu3KyUWa2W5kT5\n", "M83Ra3F16dpt8xGk8g7+5BU4TR/msXNqT25bGlcPRM5SsOW82OZCSJXUpSrBOTk5WqblPzi0315x\n", "xRWGzjavjOc70LZS7oPb0gFesK3tiu2S/SQd7auHDh0ydLR0AM1TGjlypNGO2kWyH++bUi6LU86S\n", "bRV+vu0FW3LoNUm5XXSb3yeaY8T34yUCfJ2X78ftV1FRoeWSkhJDR/s7Pxcdd6ndpZwlf3K13ADP\n", "EgAAAACAAF6WAAAAAAAEPBGGk8JMtCrzhAkTtCxNE+cuParj+1G3srSYn1RFlLoGeQhp0qRJWp43\n", "b56hy8zM1LKTSzUYoPeJTx92uoe8rTQFmcLdqfRecRetbTspjCOVhXAKvfkzhdXrVbula6ff09Z+\n", "/N7TcgE8DEf76tixY33+XSmz3/LjO4VK+fUHooK317ENw0kLsXJo5f0vv/zS0NGxMDw8XMs0NMPP\n", "zW0khdok2zpVdg7mRa75tTuVQ+H3ybZvStDj8zGSwqvw05I+eXl5ho6GafnqC05253aW0jxsK7fb\n", "As8SAAAAAIAAXpYAAAAAAATwsgQAAAAAINAoOUtSyXXbafL+TFGnsXM+9dU2P8Y2Nsp1tIwBLx3g\n", "JrzM1DEAACAASURBVE/J63F1t/lWUm4TjV/zfDRqW1tb8muU8tGkXCSnPBfp2QymHCWObdkD3o7e\n", "p9zcXENH81zCwsIMHV0CQZo+LD07bnIa3OaVebFv+mNPp32kPkDzj06dOmXoEhMTtZyUlKTl4uJi\n", "x/NJfcwfna1tvV76QcLNbwa3uVS2geaj0TxB/htKKSoqMrZXrVrl81xKmX2V5wvb5oMGot/aAs8S\n", "AAAAAIAAXpYAAAAAAAQ8UTqAus+kqedO+/B23FUnTZ20Dd3Yumv9qRDr9ZBMIJBcwE463k6qEEtd\n", "wtyWtmEi2yrVtvt53X3vD7bfhfY56Tk/ffq0oVu+fLmWo6OjDV2PHj20TEMCvDyH2/7nxn7BFqqh\n", "2Ibk/BnfaHjmZz/7maGj/VEqz2E7tvrTb92M3cGMFMq0Lf/Bw2R0bLVNd5g2bZqxfdtttzmem27z\n", "Z8Jp3G3M0g/wLAEAAAAACOBlCQAAAABAAC9LAAAAAAACnshZotiWFeDTF21zDtyWe7fNYwhEXlJT\n", "iaMrJdvMqR3//lJekht7up0+bKtrqrlots+ltCxDZGSkoTt8+LCWy8vLDd1jjz3m89zSsjZuV453\n", "064p4TafSSr74mYJI7f5YoGwezBj+9vIkXKdnMZd29xQrvMn38jpmWvMvF94lgAAAAAABPCyBAAA\n", "AAAg4LkwHMeprEBTCHU0FRewLW5tJoXvKG5DrBQ3FY+bK073SrqH8fHxxvbGjRu1LIVYpdCbhJs+\n", "1lz6pe33tG0XiP7nD4G+/qaCNE5JVb+lcdbWtm5DdBwvjrXwLAEAAAAACIQ0t7duAAAAAAB/gGcJ\n", "AAAAAEAAL0sAAAAAAAJ4WQIAAAAAEMDLEgAAAACAAF6WAAAAAAAE8LLkg7y8vPjevXvvqaqqanWx\n", "trm5uYl9+vTZfe7cuZYNcW3Af2DPpgNs2bSAPZsOTd2WzeJl6fjx4x1vuOGGT9q1a3cmKSkp54EH\n", "Hnj+woULlzq1f/rpp+fMmDHjjVatWlUppVRJSUnk1KlT34mPj8+Lj4/Pmzp16julpaURSimVmJiY\n", "O3r06K9eeeWVnzfU9wFKvf/++1N69+69Jzw8vCw1NTV77dq1w53acntWVVW1uuuuu16PiooqTkpK\n", "ypk/f/4v69rCng3L1KlT30lKSsqJjIwsSUlJOfiHP/zhN1J7bstHHnnkj507dz4aGRlZ0rFjx+MP\n", "P/zwn8+fP99CKdiyMdizZ0/vq6++emV0dHRRjx499i9ZsmSS1B5jrXcpKCiIvemmm/4ZHh5e1rVr\n", "18MLFy68TWrf5MfZ2traJv+56aabPpo+ffobVVVVLU+dOpWYkZGx/bnnnnvAV9vKyspWcXFxeSdO\n", "nEiu+9svf/nLP48fP35ZaWlpeHFxceTYsWM/f/jhh/9Up1+3bt2w9PT0HY39PZvLZ8WKFdd06dLl\n", "8MaNGzNra2vVyZMnk6i9LmbPOXPmPDVy5MjVRUVFUXv27OnVvn37nGXLlo2HPRv+s3Pnzr4VFRWt\n", "a2tr1d69e9MSExNPLV269FpbW+7duzettLQ0vLa2Vp04cSK5b9++O1966aVfwJYN/6murm7Ro0eP\n", "rPnz5z9UU1MTsnLlytFhYWFlWVlZPWztibHWO58pU6YsnDJlysLy8vK2a9euvTIqKqpo165dfWxt\n", "2dTG2Ua/gIb49OzZcx8dgGfPnv3HmTNn/t1X29WrV49MTU3dT/82bty45XQAfuGFF+4bP378srrt\n", "6urqFm3bti0/evRop8b+rs3hM3To0PWvv/76DJu2vuyZnJx84vPPPx9bt/3444//dsqUKQthz8b9\n", "7N27N61Dhw7Ht2zZMsjWlvRz/PjxDhkZGduXLFlyI2zZ8J8dO3akh4eHl9K/jRs3bvncuXN/Z2tP\n", "jLXe+JSVlYW1bNmyav/+/al1f7vjjjvemjNnzlO2tmxq42yzCMONHz9++XvvvffTioqKNidOnOiw\n", "dOnSCRMmTFjqq+2OHTsy0tLS9vH9Fy9efHNRUVF0YWFhzOLFi2+eOHHiZ3X6Fi1anE9NTc3eunXr\n", "gPr+Ls2dCxcuXLply5bLTp8+ndCjR4/9nTp1OvbAAw88X1lZ2dpXe27PwsLCmJycnKT+/ftvq/tb\n", "v379tu/atatv3Tbs2bDMmjXrxbCwsPK+ffvueuyxx54cNGjQd77a+eqbSv3b/R8REVHaqVOnY9df\n", "f/2/brzxxo/rdLBl41JTU3PJzp07033pMNZ6l6ysrJ5197rub/37999Gx0lKcxhnm8XL0hNPPPHE\n", "zp070yMjI0s6dep0bMiQIZvpgEopKiqKjoiIKKV/u++++/6mlFLt2rU7ExcXlx8aGlp97733vkTb\n", "RERElBYXF0fV37cASv07MbC6ujp08eLFN69du3b41q1bB3z//fcDn3zyycd8tef2LCsrC1dKqaio\n", "qOK6v0VGRpbU5UXUAXs2HC+++OKssrKy8C+++GLsY4899uSmTZsyfbXz1TeVUmrOnDlPl5aWRmzZ\n", "suWyd9999/aPPvpoMtXDlg1DWlravoSEhNPPPvvs7Orq6tAVK1aMW7NmzciKioo2vtpjrPUuZWVl\n", "4ZGRkSX0bxEREaV8nKyjOYyzTf5lqba2NmT8+PHLb7nllg/Onj3bNj8/P66goCD20UcffcZX+9jY\n", "2AJu0Ntvv/3dtLS0fWVlZeElJSWRKSkpB6dOnfoObVNaWhoRHR1dVJ/fBSjVpk2bCqWUeuCBB55P\n", "TEzMbdeu3ZmHH374z5999tlEX+25PcPDw8uU+nciad3fiouLo/igDXs2LCEhIbWjRo1adcstt3zg\n", "lEjqq29SBg4c+P2sWbNeXLBgwTT6d9iyYQgNDa1esmTJpE8//fS6uoTeW2+9dVHHjh2P+2qPsda7\n", "hIeHl9ExUinf42QdzWGcbfIvS/n5+XFbtmy57P77738hNDS0OjY2tmD69OlvOv249uvXb3tWVlZP\n", "+rdly5ZdO3PmzJfbtGlTERYWVj5z5syX6f7nz59vkZ2dnUpdjqB+iImJKXQafH3B7RkTE1OYlJSU\n", "Q12/27Zt65+enr6zbhv2bDyqq6tDw8LCyn3pfPXNi+0PWzYsGRkZO1atWjUqPz8/bunSpRMOHDjQ\n", "PTMzc5OvthhrvUvPnj2z6u513d/4OElpFuNsYydN1fenpqYmJDk5+cQzzzzzyPnz5y8tLCyMnjRp\n", "0j9vv/32d3y1r6qqahkfH3+aZvUPHTp0/QMPPPBcRUVF67Nnz7a59957X7zyyivX1unXrVs3rE+f\n", "Prsa+7s2l8/jjz/+2yFDhmw6ffp0fEFBQczw4cO/fvzxx39ra885c+Y8ddVVV60qLCyM3r17d+/2\n", "7dvnLF++fBzs2bCf06dPxy9cuHBKWVlZ2Pnz5y9dtmzZ+MjIyOJNmzYNsbFlTU1NyN///veZhYWF\n", "0TU1NSEbN27MTEpKOrl48eLJsGXjfLZv355RUVHRury8vO2zzz77q5SUlAPnzp0LtbFnbS3GWi99\n", "pkyZsvC22257r7y8vO3XX389PCoqqmj37t29bW3Z1MbZRr+Ahvh88803lw8fPvzr6Ojowri4uLyf\n", "/OQn758+fTreqf3s2bP/+MwzzzxSt71v376e48ePXxYbG3smNjb2zIQJEz7Lzs7uXqefNWvW355/\n", "/vn7G/t7NpdPdXV1i1mzZv0tOjq6sH379jn/9V//9ZeqqqqWtvasqqpqedddd70WGRlZnJiYeGr+\n", "/PkP0fawZ8N88vLy4q666qpV0dHRhVFRUUVDhgzZ9PHHH/9I2ofasqamJuTaa69dGhsbeyYiIqIk\n", "PT19x2uvvXYXbNl4n9mzZ/8xJiamIDw8vHTixImfHjhwIMXWnrW1GGu99CkoKIiZNGnSP8PCwsq6\n", "dOlyeOHChVP8sWVTG2cb/QK8+MnLy4vr1avXnsrKylYXa5ubm5vQu3fv3dKPNT6wJz6wJT6wZ1P+\n", "NHVbhtTW1jZ2JBAAAAAAwLM0+QRvAAAAAIAfAl6WAAAAAAAE8LIEAAAAACDQor4OfPDgwT+dPHny\n", "4fo6PpAZPnx4SCCPl5WVheS2RqJnz54BtWV2dvbCgoKCKYE8JrAnMzMzoPbcsWMH+mYjkZGREVBb\n", "njx5ck1lZeWIQB4T2JGSkiLaEp4lAAAAAAABvCwBAAAAAAjUWxiuMbnkEm++A9bU1DT2JQBQ74SE\n", "BDQy0eCgnIo7GtrusBNoSLz5VgEAAAAA4BHwsgQAAAAAIICXJQAAAAAAgaDNWZLyknjsnG5Luosd\n", "xwYeR6fb/JqpToq/N/dcJ7c2ctJJ+0h2sNU1x1yKQNgoEO0kpL5paz+3umDG7f2m412gx1ml7G0h\n", "jZ9N1WZuCPQ4+0MIRH8MNPAsAQAAAAAI4GUJAAAAAEDA82E4p3CbFE7j+wRCR2V/QmaSO5huU5kf\n", "n15XUw3J2YZKJd25c+cM3caNG7V8+PBhLefn5xvt8vLytNy3b19DN2TIEC137drV0IWGhmpZchs3\n", "1RCdbZgz0P2PI4Xkpf5i2/9swzj8GoPV1v7ca9u+KYXkbMM4/vQrajNp7G5uITp/wmlOtnVrP4lA\n", "hMgvdswfCjxLAAAAAAACeFkCAAAAABDwXBiOu/RGjPh/awquW7dOy9wdTLcvvfRSQ0e3+X4tWrTw\n", "2U4ppc6fP69lGqpZv3690a6qqkrLH3/8sePxJ0+ebOjGjx+v5QsXLmhZCtdxgiks59bNK4VZ9u/f\n", "r+WtW7cauurqai2Hh4drOSYmxmjXs2dPLVdWVho6auvjx48bujFjxvi8Jn9CscHk6re1nz9907bf\n", "Sn1YCrPQbdrH+LaTzLdtQ+kXuy6v4TZUSre5zsl+/DmSdBTp3tvaVrIRP0Yw2Y/iT6jNNjwq2dlt\n", "iNU2RYXaRerf9R1ShWcJAAAAAEAAL0sAAAAAAAJ4WQIAAAAAEPBEzpIU86R5Sk4xcKXM3CAqX0xH\n", "p39v3rzZ0B04cEDLxcXFWuaxUZobM23aNEO3YcMGLe/YscPQ/ehHP/J5DCn+LuHF/CXbXCQpL4La\n", "evv27YaO5izxXKTWrVtruXfv3lpOTEw02kVFRWm5qKjI0O3evdvnuZQyyxGkpqZqmdvLNufMi3kR\n", "tvZzk3uklH3fpLKUW1hRUWHo6P3duXOnoVu2bJmWCwoKtDxz5kyjXfv27X2eSyn/cmy8hpucFMm2\n", "tuMub+c2Z4nago6ffJv2R24/quPnpm29XhbCTQkHrrPNJ5TGZ+n4HHrvDx48aOhoGRja95OSkhyP\n", "wc8l5RO6sR88SwAAAAAAAnhZAgAAAAAQ8EQYjiJNK5Vcvk4ue77dqlUrQ7dp0yYt05CLUkq1bNlS\n", "yykpKVq+4oorjHZdunTR8jfffGPojh49anVdttMepamTXsTWPSy5ck+ePKnlY8eOGbrY2FgtR0dH\n", "G7rBgwdruV27do7XQYmPjze2qa3LysoMXXZ2tpYjIyO1nJCQ4Hh8jlcWiazD7bRj21Cb1Adof1PK\n", "LMlBw2SHDh0y2p09e1bLZ86cMXQ0lMLLQsTFxWmZfjce0qHfx58yHvWxwOgPoT7CqHSb249Wyqf2\n", "42Pwnj17fF6HUkplZGRomYfQaKiG933a32k7f/ob/W62qRBewJ/yALa2lUrs2JbfoXZWSqmSkhIt\n", "8/A57avl5eVapr/XSimVm5urZfpbq5RSP/3pT7XcvXt35YTtOAvPEgAAAACAAF6WAAAAAAAE8LIE\n", "AAAAACDQKDlLbsvp205T5bFzGiPncU06nbhNmzaGbujQoVq+/PLLfV6HUmY8m8de6TIbPFZPr1kq\n", "6e613AcJf6atOuVMcBvRcgH0fipl5pLR8gBKKRUREeHz+NI0YOn6O3ToYOhoLJ3GznnOkm0ekBfz\n", "z2ztR9tJ+YT79u0zdLRP5OTkGDp6f2keET8+hetsp6LT50rKb5CmIHuxn9o+e26WLVFKqe+//17L\n", "tLyKUkqVlpZqmZbxkPLWOLt27dKyVDqAj7t0mSyam8b7GD2mF+0nYbtclFQeQPpNpTqpdAe1M80f\n", "VMrMN+U5g/Te83PTcYH+NtL8M6XM33r+3M6dO1fLCxcuNHQoHQAAAAAAEGDwsgQAAAAAINAoYTh/\n", "pjbaTm+VpidTVx2fAkr34+73IUOGaFmqtEynK/MqwfT4ffv2NXTS9w4mbF3AtiE6OiVfKaXatm2r\n", "ZTolWCmlBgwYoGXuypVWnHdDjx49jO0jR45omYYOacVnpf7zmr2GmyrrfJv2R14F/f3339cyD5HT\n", "6uk8DE7tGRYWpmVaqkMpM9xKq6orpVReXp7j9dPn6uqrr9YyDRkpZZYwCGak9AfbcCufuk2r2lM7\n", "KGXeR/p88PGTlwSwRQr9rlixQsu0uv6gQYMcjxFs2IbhbKuz24ZfaWhNKbPP+VPahoba+LhAxwI6\n", "RvC+uG3bNi3zsjK81MsPBZ4lAAAAAAABvCwBAAAAAAjgZQkAAAAAQKDBcpZ4PNQJ25wXf6a30m2e\n", "P0Lj5TzfqH///j7343HTRYsWaZlPb6V5UMOGDTN0fCqlE16cUh4IqD1pzg9fbiImJkbLPOeAPgf8\n", "3kurTlNsVz3npR/oM1FYWKhlnjcj5SwFk21t+yaf3ku/I88HovcmOTnZ0NHcpG7duvk8nlJm3szx\n", "48cNHX0+6NI4SpmlQWhehG2/9HUtwYRtzsubb76pZd436T2VyjbQnEE6lV8pc0kTnu9Hj0Hzz5Qy\n", "y3Vs2bJFObFx40YtDxw40NAFk/1s86vcLlkk5TOdPn1ayzynVBpnaS4S799JSUla5vmK9Hmhv9H8\n", "+aPPDs1TU8pcYicQdoZnCQAAAABAAC9LAAAAAAACjVI6IBD4406kcDcvdSMfOHDA0H311Vdavuaa\n", "a7T8wQcfGO1opWG6+rxSSqWlpWlZChNRN6E0/VKqIBxs0O9CKwHzaaTx8fFaplPI+TFs76/kpuYh\n", "XAlqa+oqpqtpc/xZ9dxrSNcnVTqfMWOGlnlZDxqGo1P5lTJd8TS89u233xrtaAiX9/3OnTtrefTo\n", "0YaOno+G1qX+50/f9DpO9uSrw9N7z21L+wtNW1BKqX79+ml52bJlWh41apTjdfAwCz0+HQf49ubN\n", "mw0dfXboMXkIiT4f/kx7bypI4Vd6D2mZFJ6GQtvxFRboM8FD8DRsK1VWl/ofTXng4XNe4oCCCt4A\n", "AAAAAAEGL0sAAAAAAAKeCMNJbjYn/Mn4l1zl1G3I3XjUHX3q1CnHdjRsdO211xo66irmiwzauhop\n", "weYalq53/fr1WqahTB5qozOhOPQe8irdTud2W7WXH4/O6qHnPnTokNFu+PDhjuf2uj3dXB//jnRh\n", "YWkxaT6LjlbnXblypeP56EwaGlZRSqkbbrjB8bpoeEYK57q1kZtxzQvs3bvX2JYWW50wYYKWeYiO\n", "fme6egHvp25XAKDPB68CTm1Lw0Z/+ctfjHZ//vOflRPBFlatQ1qIXRr7+D2kixjT1ALejvY/Hoql\n", "oTfbGfEcafUM+rvMr+uyyy5z3M8N8CwBAAAAAAjgZQkAAAAAQAAvSwAAAAAAAg2Ws0TjjtLq1xLS\n", "Cui2VZh5HHrcuHFa5qul06mHNB7KV9eeOnWqo47mN/kzJTmYsJ1Szqec0twIWqWbrhKulFld2e25\n", "6bMjVXiXps/yc/EyEXXw0gG2ZQu8gJTvIGGbd8Lz/Wi5Dl6FmVbgpcfg1X6vvvpqLdM8C6XMHCme\n", "0+CUy+i2PIDX+zC/dqccEt4/6D3MzMw0dLwUi9P5pHb0OnhOVH5+vpb5Cgt0fObfjea/0UrR119/\n", "veN1SHjBtrZjnT9jDM3tolW6lVKqtLRUy/T+8t84WhWdl32RVtZwqvCulPNvI8/7LS4u1jJ/dsaM\n", "GaMCCTxLAAAAAAACeFkCAAAAABDwXOkACVtXvz/Hp67BTp06GbqysjIt08rDiYmJRjs6NbqiosLx\n", "3LYVYv35bsHEhg0bjG16r2iJBeo29wepqju1M68iLS3GK4XhnGzLwxu0RAKvIDxt2jTV2EhhQttQ\n", "sdQ3aVmIL774wtBRNzoPk1E7UZlX+qbhXH7vaWiBL6Trpvo2Pz4PHwQTTvbkoRR677du3WroqC0G\n", "DBjgeC4pDH7mzBkt8+rhdLFcCT4mjxgxQst0bOH24s9cU0Tqm/R+8/QBaidaYqdjx45GO6k8AA2N\n", "cR19/mz7Ea/UTlNneBiOh+t/KPAsAQAAAAAI4GUJAAAAAEAAL0sAAAAAAAKNkrPE8wOkld6d4q1u\n", "83j4fp9++qmWT5w4YeicYrF8+iKdYsnjpoGe7hnMy2WsWLHC0KWkpGi5a9euWo6OjrY+vnQPaa4F\n", "tYv0vPmzxEFOTo6W6RRcfvx//etfWv7www8NnRdylmyxXWKIt6P9heYoKSXnSyUnJ2uZ5j3xJVPo\n", "vef9YenSpVoePHiwoeM5ik64/d5e6JvS/XW69okTJxrt/v73vzseg+Yw8fIANJeT9gmeE5WVlaVl\n", "Wi5CKbPf8r6ZkZGh5Z49exo6WjrAaVkbpQLzm+J1aP/j95fm/PCcIrpNlzGRliySyrJwpDwl+tzS\n", "kjO89Ai9RvobopRSN954o+Px3QDPEgAAAACAAF6WAAAAAAAEPFE6QMLWTWo7DXjZsmXG9uHDh7XM\n", "V80eNmyYlmkIiYfhaIkBp6rOSjXdkgAS9Dvy+0bdt1K5ANtQJnf5ShXfKbbVm7kLeP/+/T7Pza8j\n", "LCxMy3/4wx8cr98LYRt/sF1FnE7dvvvuux2PIVXlp65/Huo+dOiQljdu3Gjo6LT0L7/80tB169ZN\n", "y0OHDnW8juaANM7SqeK8D9O+s3z5ckM3fvx4LdOxdeXKlUY7aiMODeWNGjXK0NFQG18dIBBIJUWC\n", "qa8ePHhQy7TquVJmSQAqK6VUnz59tExTGqRwnTQm8Hsojbs0dLpt2zYt8+ePru5wzTXXGDpa1iIQ\n", "JT7gWQIAAAAAEMDLEgAAAACAAF6WAAAAAAAEGiVnSYprus3roTFJfvyvv/5ay3zl6ri4OC3zFbVT\n", "U1O1/O2332qZThlXyiwdwOO+gSaY8yn4MhVO00p5/JrGtqVnR9pPyg2i7fjyB8eOHdMyX+qB5qrR\n", "4/P8K5pr0aNHD0MXTMtl2E4959guayDZVurfdMowzY9SSqlPPvlEy9SWSim1Y8cOLdN+m5aW5ngd\n", "EsHWN52ul/998uTJWt6+fbuh27Vrl5Z5Tspnn32mZZpzJq1Mz8sP0L7Dnx0pN9VNSYBgykPi0O9I\n", "baKUUvv27dMyzfFRyrynfDzmbeuQxk/puqScJZ4PSp+zwsJCn8dTyiwZwX97ncZ/pdzZGp4lAAAA\n", "AAABvCwBAAAAAAh4onSA5DJ10klTvOlK40optXr1ai3zFefHjh2r5c6dOxs6pyqwPFRDK9ByN7Ib\n", "gtkdzKEhE1oRXSlne/pTRduNi50fnz4v2dnZho5WnJauix6fr3ZNwzrBFHZTyr5vUmzDoRfbz6kf\n", "8L/TZ4z3b1qN+oMPPjB0x48f1/J3332nZX/CcF7vq26rjzsxaNAgY5uGnHmFflrigY6fHGqz0aNH\n", "Gzr67PgzLlCojWyfsWCGl3Do0qWLlvn3pWUheAVs235L4ceXfrNzc3O1zMO79DeWHqN79+5GO9sq\n", "/IEAniUAAAAAAAG8LAEAAAAACOBlCQAAAABAwPM5S7bQ1ZPfeOMNQ0djr5dffrmhozF3aWqjVJqd\n", "Ik1RlOLl0jGDKa4u2e+KK64wtvPz87V85MgRLcfExBjtaG4JLz9Ap+Jz+9ElEOj0U3o8pcwSANKq\n", "5Bwnu/AV0IMZN/mEHKn0g22umpTrJZ2b5s3wZVLofjRHQuqnbvNmvIA/JVuc4PcmOTlZyzNmzDB0\n", "NHcmLy/P8TroNs97oktY+PPbYGuzYBpbOU79j5dmkOxOl5PhuZZO8HtG+6ZkI5qjpJRSe/bscbzG\n", "iIgILdMSPvR6+bnrOx8UniUAAAAAAAG8LAEAAAAACARVGE5qR6vzcnccrUQ6cOBAQ0erlnJXoNNK\n", "8rzSqW1JA9swn7TCdbC5jem9GTdunKFbs2aNlun0/bVr1xrt6P3moRRa+ZWGYm2viW9LYVT+XFHd\n", "8OHDtcwreAdTuQCp//H7S1cDp9OTBwwYYLSj9pPuve1q5vwZsK38zaev09Cb1P9swzhe75tuV0eQ\n", "+oe04rxTv+XjJ93mZV/ee+89LfOyAjRcb2uzpjS2OiGFmxMTEw0dvYe24yJvR+1HS60opdTu3bu1\n", "zO99dHS0lnnokKZb0FU2eNmeQKS52ALPEgAAAACAAF6WAAAAAAAEGiUMF4gFJ/kxDhw4oGW6aKNS\n", "Sg0dOlTL1KWnlOlC5NV/6aypM2fOOF5L3759tcxDLtRtyHV0W5pt53X3sG0YlbvfafV0Wjmbz1aT\n", "QqB0Rh3X0bCA06K9Spl2kGZ6cPtddtllWqazNPxx9XvdtpQHH3zQ2C4vL9fyI488omXJnc/tQEMG\n", "UhiOuuklW9Kq+0optXLlSi3zEM/Zs2e1nJGRoWXbcLlSwWU/t9iGSrldaNiWjsk8TERn1PEZU/R+\n", "07CvUmaldT6D1qnf+tM3g3XmoxT252EsaSYbDalJz8CJEyccj0/h1bfpbzG/9/Q40kxV21nqgQCe\n", "JQAAAAAAAbwsAQAAAAAI4GUJAAAAAECgUXKW/Jni56Tj7fbv36/l8PBwQ0endfO8JBo/P3z4sKH7\n", "8ssvfV5/t27djG1abZTnTNDpytLUZbdxda/hdvpmr169fMpKmbkmUs7L0aNHDZ3TSufSNfJ4PI2z\n", "x8fHO57baRo6P77X7ceh17t161ZDR6f+fvrpp1rmOWc0N43bVsoZdJpuzvMiNmzYoGU6VVkps3J7\n", "aWmpoevTp4+WaWV/Ka8jmG1bHysISDlLdEV4KbeQltqgz4pSSr355pta5uNzQUGBlnlZEtucJduc\n", "l2CyLX/O6fNM+4NSSm3ZskXLrVu3NnS0LItt6Rzeh+mYyfOFKVI+L5Xdlg4IBPAsAQAAAAAIqu8C\n", "6wAAIABJREFU4GUJAAAAAEDAExW8pSrXTi447gqk07h37dpl6BYtWqTl9u3bGzppMT96bhpqGzNm\n", "jNGOLthKZb7Nw0J0e+7cuVqeN2+e0c7r01vpNfmzkLDTlGw+tZi686UwHLctDYlS9zN35YaFhTle\n", "P3Ur25Z+CObSAfx66P149913Dd3s2bO1TEs/cHd+SUmJlumimEop1blzZy23a9fO0FE70Wn+tEyI\n", "UqadaTulzEWSaYkPpZQaPHiwlun35Ha2Levhddty6Pei39mf8gDS+EOrRdPSK9IYz8dImkLx4Ycf\n", "GrpDhw5pmVf3dpPi8P+1d+bxVVVZvt+RKZAZEkLCPCQQhjDIjEwOWFLlWBaNDVigtpZaVqkt71Gf\n", "p+BQXZZl29jl0KVVDk9KaaRFbAcGLRlkkCgzJBBAAkhCEggZSUICeX/Uy+61V92zsu+pm9xzb37f\n", "z+d8WCdrn3PPPevsczdrrb22F96l/uD07PHfIPru432Tlnfgi5TTch1SSRi6AG+fPn0MHQ3V8/eu\n", "U3kAvh+I/ocK3gAAAAAAzQwGSwAAAAAAAhgsAQAAAAAIeC5niecL0FgpjWfzGGpGRoaWaSxbKXM6\n", "8YkTJwwdzXnp3LmzoaPx15EjR2qZ50XQnAleOkCKy9JY7OLFi33+XSnv5z5QmjunSopL82eCLrFA\n", "8yf8WZKGPnO2y2B4Ma/MLfS78Gn/tFzAjh07tHzo0CGjHS0lwO8vXd6C5j4oZfZNeh28H1VXV2uZ\n", "52TMnDlTy3zFdae+GU7Lndjm5EjLXtien9+LuLg4LfN3JkVaqormwp06dcrQ0X2e62SbTygtDeJ1\n", "21LotT7++OOG7r//+7+1zEsH0LwknitKc9XotH+eW8hLqlDo76FUkkN6J0vPMEoHAAAAAAB4BAyW\n", "AAAAAAAEghKG46406u7jOlt3HHXhz54929A5VQLmny1dJ61mKk1ztJ1eznW27kSvh3Qk16d07dL3\n", "p/dXchVL4QPpHjpNoeY622nH4VIJmCPZb/z48VqmIWulzFIePAxOq7PTcJpSSo0ZM0bLNDzDVy+n\n", "ZT14BWF6HJ9S7RT+d+vq97ptObbvEqkP0L7JQ2G0JMeoUaO0/MEHHxjtaNh2zZo1ho6WHOBhOHp+\n", "KcVBun5KqNnP9npvuukmLfPfO/p7KJWMkN6ztF/ZlodpSmf7bm1Jm8GzBAAAAAAggMESAAAAAIAA\n", "BksAAAAAAAKeKB1AY5I8buoUY5ZiozzvRIq32ua52E5fdBuX9fqSJm6xzYGRvr+0FAXVubGldE1N\n", "HReIVdu9jpscJjodWSlzKSKah6SUu77pT04fnbociLyIcLIlvb9u8wmlpUro+el0c7oEhlLmyveb\n", "Nm0ydDSnjS57pJRS69evd7x+2zylcMH2uZT6gG3/s83zbQo379ZgvmfhWQIAAAAAEMBgCQAAAABA\n", "wBNhOIptWQF/XPFSqIbu27r4ArXysdPnhavb2K2rmOJPGNX2Otza3fYc4YqbMJY/fdPNdQSib/pj\n", "y1C2u1MIxp/p9bStbd+89dZbjf2bb77Z6vP8mZZuc75wxZ/3lO1vI8Xt75M/1+XUNpj2g2cJAAAA\n", "AEAAgyUAAAAAAAHPheE4Ti4/21lzSrl377vBbQXk1oib0EdL2lKp1uG2t8X2Xvgzm9ONPfkxbq/r\n", "720XTkjf2e0iuy1Ja7SZLYFIH2gOu4eazeBZAgAAAAAQwGAJAAAAAEAgItRcYQAAAAAALQk8SwAA\n", "AAAAAhgsAQAAAAAIYLAEAAAAACCAwRIAAAAAgAAGSz4oLi5OysjIyKmtre3QVNvCwsLkwYMHZ1+8\n", "eLF9U21BcIA9wwfYMryAPcOHcLdlqxks/ed//ufsjIyMnOjo6MoBAwYc3bJly1VObX/7298uWrBg\n", "wVsdOnSoVUqp2traDnfdddebcXFxZSkpKQVLly59pLFtcnJy4fTp0ze8/vrr97bE92jtXLx4sf3d\n", "d9/9Rp8+ffJiY2PLR44cuXvt2rU/kI7h9nzsscf+NT09PTc2NrY8IyMjZ9myZfMa28KeweHIkSNp\n", "kZGRNfPmzVsmteO2bKSkpKRzUlJS8eTJk79q/Bts2fK8/PLLPx89evS3kZGRNQsWLHirqfbcnu+/\n", "//6siRMnbouKiqqaPn36BtoW9mxZcnJyMq6++uov4+PjS9PS0o6sXr36Fqk9t+Xp06e733zzzR91\n", "6dLlXM+ePU+99tpr9zW2DUlbNjQ0hP22fv3663r37p23Y8eOsQ0NDSo/Pz/l9OnTqb7a1tTUdEhM\n", "TCym+kWLFj07ZcqUTaWlpXE5OTmDunXrVrB27drrG/Vbt26dOHTo0P3B/p6tYauqqur05JNPLjlx\n", "4kSvhoYG9cknn/wwJiamPC8vr7etPZcsWfLk4cOH0xsaGtSOHTvGJiQklGzbtm0C7Bm87brrrls/\n", "efLkzfPmzXvHqY0vWzZu99xzzx+nTJmyafLkyZvp32HLlt1WrVp16+rVq2++//77X50/f/5bUltf\n", "9vziiy+uWbly5e1PP/30E9OmTdvAj4E9W2arq6trm5aWlrt06dKHL1++HPHll19Oj4qKqszNzU2z\n", "teW0adM2PPLII/9WX1/fZu/evZmdO3c+t2HDhmmhasugX0BLbBMmTNj25ptvLrBpu2nTpikDBgw4\n", "Qv+Wmpp6+vPPP7+2cX/x4sVPzZ49ezl9sDp16lR18uTJnsH+rq1xy8zM3Ltq1apbbe3Jt5tuuumj\n", "F1544VHYMzjb8uXLZ8+aNWvFk08+uWTu3LnLnNo52XLr1q0TJ0yYsO2tt96af9VVV31FdbBlcLbH\n", "H3/8maYGS1Lf/OMf/3iPr8ES7Nky2/79+4dGR0dX0L/NmDFj3RNPPPG0jS0rKiqiIyIiLhcXFyc2\n", "/u3ee+99jf5nKNRsGfZhuEuXLrXZuXPnlUVFRV3T0tKO9OzZ89RDDz30Uk1NTaSv9vv37x82cODA\n", "w43758+fTygoKEgZPnz43sa/ZWZm7jt48OCQxv22bdvWDxgw4OiePXtGNO+3AZzCwsLk3Nzc9CFD\n", "hhz0pef25FRXV3f85ptvxgwdOvRA499gz5ajvLw8dsmSJU8tXbr0kYaGBnEBKl+2vHTpUpuHHnro\n", "pVdeeeVBX8fAlsGhKVsq1XTf9AXsGTwuX758xYEDB4b60nFbNtqfPgf8+FCzZdgPlgoLC5Pr6ura\n", "ffDBBz/esmXLVXv27Bmxe/fukb/+9a8f99W+tLQ0PiYmpqJxv7KyMloppeLi4soa/xYbG1teUVER\n", "Q4+LiYmpKCsri2uu7wH+lrq6unZz5sx5d/78+W+np6fn+mrD7cn52c9+9ocRI0bsmTFjxnr6d9iz\n", "ZXjiiSeeueeee/6UmpqaHxERIS4n4MuWv//9738xfvz4r0eOHLnb6TjYsuVpypZKNd03nYA9m5+B\n", "Awce7tq1a9Hzzz+/sK6urt369etnbN68eUp1dXVHX+25LWNiYiomTZq09Zlnnnmitra2w65du0at\n", "WrXqNn58KNky7AdLHTt2rFZKqYceeuil5OTkwi5dupx79NFH/+2zzz6b6at9586dS+hAKDo6ulKp\n", "v/4PuPFvZWVlcbyTV1RUxMTHx5c2z7cAnMuXL18xb968ZZGRkTUvv/zyz53acXtSFi5c+Hx2dvbg\n", "999/fxbXwZ7Nz549e0b85S9/uebhhx9+UammvRHclvn5+akvvfTSQ07/8WkEtmx5bDxLUt+UgD2b\n", "n3bt2tWtXr36lk8//fSHjZOaZs2a9X6PHj2+99Xely3ffffdOcePH+/bs2fPUw8++OArc+fO/XP3\n", "7t1P0zahZMuwHywlJCScdzKwLzIzM/fl5uam0+NTUlIKqKtw7969w2nYpr6+vu3Ro0cH0FAdaD4a\n", "Ghoi7r777jeKi4uTPvjggx+3adPmklNbbs9GlixZ8tS6deuuX79+/YzGAXEjsGfLsGnTpql5eXl9\n", "evXqdTIlJaXghRde+OcPPvjgx6NHj/7WV3tuy6ysrLEFBQUpgwcPzk5JSSl4+OGHX8zKyhqbmpqa\n", "3/hjDVsGBxvPklPflI6HPVuOYcOG7d+4ceO0s2fPJq5Zs+aGY8eO9R87dmyWr7a+bNmrV6+TH3/8\n", "8Y1FRUVdt2/fPqG4uDhp3LhxOxr1IWfLYCdNtcS2ePHip8aMGZNVVFSUVFJSknDVVVd9tXjx4qd8\n", "ta2trW2flJRUxGfDTZ06deP58+fjs7OzM7p161awbt26GY36rVu3Thw8ePDBYH/P1rLdd999fxg/\n", "fvz2ysrKqKba+rLnb37zm1+lpaXlnjlzJtnXMbBny2wXLlzoWFhY2LWwsLDrmTNnkh977LHnb7/9\n", "9pVnz57tYmPL2tra9o3HFxYWdv33f//3X4wbN+7rwsLCrrBlcLb6+vo21dXVkYsWLXp23rx579TU\n", "1HSor69vY2PPhoYGdenSpSuqq6sj/+M//uNnU6ZM2VRTU9Ph4sWL7WDPlt/27ds3rLq6OrKqqqrT\n", "888//1i/fv2OUVs0ZcucnJxB5eXlMbW1te2XLVs2NzExsZj27VCzZdAvoCW2urq6tg888MAr8fHx\n", "57t161bwy1/+8sXa2tr2Tu0XLlz4u+eee+5/0QfhrrvueiM2NrYsOTn5zNKlSx+m7R944IFXXnrp\n", "pZ8H+3u2hi0vL693RETE5Y4dO16Ijo6uaNzee++9O2ztGRERcTkyMrKaHv/ss88ugj2Duz355JNL\n", "pNIBvmxJt7fffvunvHQAbNmy25IlS56MiIi4TLennnpqsa0933rrrfn8+AULFrwJe7b8tnDhwt8l\n", "JCSUREdHV8ycOfPTY8eO9WuqPbXliy+++MukpKSiqKioysmTJ2/euXPnKNo+1GwZ9Avw4lZcXJw4\n", "aNCgnJqamg5NtS0sLOyakZGRLQ2+sMGe2GBLbLBnOG/hbsuIhoYmQ8sAAAAAAK2WsE/wBgAAAAD4\n", "e8BgCQAAAABAAIMlAAAAAACBts114vz8/F8VFxff1VznBzLDhw9PC+T58vLyjgTyfMCePn36BNqW\n", "S0tLS38UyHMCe0aMGBFQe546dQp9M0j07NkzoLY8fPjwexUVFWMCeU5gx+jRo0VbNttgqb6+PrG2\n", "tnZAc50ftCx1dXWwZZhQV1fXraamBvYME+rr62HLMKG2trYH+qY3QRgOAAAAAEAAgyUAAAAAAIFm\n", "C8N5lYiIJtd39BvUqgoezWFPCmwbPNzYFvYKHs3dFyVg98BzxRXe8KVcvnw52JeglIJnCQAAAABA\n", "BIMlAAAAAACBsAnDSS5gquPtbI+zRXIHcx3dd5JbC7b32q293IYIbO3pj91bG4Humy1tS/TN5u2b\n", "tu38ufdubNYabCuF1qT+57YP2yL1OXrNUjtOoMN38CwBAAAAAAhgsAQAAAAAIBBSYThbl/3FixcN\n", "3YMPPqjl/Px8Q7d27Vott2nTxtDt2rVLy9u2bdPyhAkTjHajR4/WMncLUlegpLN1GYaTq9g2zGJr\n", "9+YOwzVHGDVc7OnWRnSfhwicjvMnlC7Zxalv8r4o9c1wsR/Fn37k1i4Ut7OubO1i24f59Yaqbd2G\n", "2qT+R3WBegZs+6btbyjX0WsOREgOniUAAAAAAAEMlgAAAAAABDBYAgAAAAAQ8HzOkm3ctK6uTsuL\n", "Fy82dHv37tVyenq6oSspKdFy7969Dd3kyZO1XFRUpOWvv/7aaJeSkqLl5ORkQ9exY0ef16iUGWO9\n", "dOmSlsM1Z8I21s3bUbvzuHp9fb2W8/LyDF1WVpaWIyMjHc+RmJio5aFDhxq6Ll26aJnaSCnnPBdu\n", "r3AtMWDbN6mO5wVKOrpPZSm3QspJ4faj+04y35f6pj/Tmr1AoHMGuV2c+q30fEj4k69SXV2tZfp7\n", "8O677xrt6DuCvgea+myvYZtTJNnItm9K/VTqmxxqP97n6Htdauf2d9NNDhM8SwAAAAAAAhgsAQAA\n", "AAAIeC4MZxuC4a7AY8eOafnMmTOGbubMmVpOSkoydCdOnNDy4MGDDV3btv9ze+bOnavld955x2jn\n", "FO5RSqkbbrhByzQkp5QZlqPfm7saJR3Fi65iN+E1yZVbXl5u6HJycrRcUVFh6Hr16qXldu3aOZ6f\n", "3rejR48aOnrO/v37GzrqyqVuY/49bae+crxmT7d9k+6///77hm7Hjh1aHj9+vKH7p3/6Jy1T+0nh\n", "An7Ptm/frmXe97t166Zl2hepLfm+bSiP4zVbctxMIef7bsM40vml/iHd+82bN2u5R48eWr7zzjuN\n", "dtHR0T6voym8YE+n0Js/NpLsQvsc/S2kf+c6KvPPlt59PEWF7lOZlwWi5+f91taetiE5eJYAAAAA\n", "AAQwWAIAAAAAEMBgCQAAAABAwBM5S27irTzOuG/fPi0PGTLE0HXt2tWnrJRSV155pZajoqIMHY2/\n", "0pg4LzFw9uxZLdfU1Bi6Tz/9VMvXX3+9oYuJiVH+wuO+Up5EMAjE1GIeO6f3d/fu3Yauffv2Wo6L\n", "izN0nTp10nLfvn21zJ+B48ePa7mgoMDQ0ZIRnLS0NJ9/57FzCn9upWnvXsBN3+R5C3SfltlQyrRL\n", "bW2toaP2o3kSPGdCyougOWgHDx40dPPnz9ey22UZJF0o9U3b3EJ/cl6cngmpnWQHKV/s3Llzho6e\n", "JzU1Vcvjxo0z2tF3sD9lIbyG1E9t85J4v6L79D1bWFhotKP5YdxGI0eO1DK/9/T+8lwk+i6Qngl6\n", "nGQj6b1rCzxLAAAAAAACGCwBAAAAAAh4LgxnOz35k08+MdodOnRIy9zVn5CQoOXRo0cbun79+mmZ\n", "uhqVcnYP33bbbUa7devWaZmWIlDKrCT71VdfGbrMzEyf1+zP9NlQCuPYhgH496ch1g4dOhg6Gqrh\n", "YTE61Z+GAfh1DB8+3OcxSpllIbj7mbrwaWhPKk0QargJz3BXP733sbGxhq5z585a5mFwamvaN6Wp\n", "5/xe89AChZ5TqsBuq+N4oW9K4QanPud26rkUfpXCcLYVvPl3oSGYw4cPO56Tpk3QtAtf5/QytiUd\n", "/AnDSSUBaP/Lzc3VMi33oZTZj3hqyYEDB7TMV7cYMGCAcsJ2dQvbCt6BsDM8SwAAAAAAAhgsAQAA\n", "AAAIYLAEAAAAACAQlJylQKxqzacZ07wkWsJeKTM3iE9fpDFbnlcgTQGn0OmRxcXFho7G1UtKSgzd\n", "Z599puXp06drmS7TEQq4yUtSyj7nZdKkSVo+ffq0oaN5SjT/hX+eNI2btuNL0tB4PM8FoNdCl86w\n", "zRPxIm7tZzt1OT093dDl5eVpmd97Wrahe/fuWrbtl0rJeQtultsJZSTbSn93mw/jlPPptsQCP44+\n", "O/wc9L1OnzmeV+W18g4SgSj9YJtXppSZB/zNN99omecEX3vttVrmy1HR0jllZWWGjvZN/lzRHLSq\n", "qiot8zynluyb8CwBAAAAAAhgsAQAAAAAIOCJ0gEUydWYnZ2t5WPHjhntEhMTtUzLAShllgvg0yOp\n", "S59PPXSa7stdhvHx8VqeOHGioaOhNs6FCxe0/Oabb2r5kUceMdrR6fGcUJ6WTpHcyDS8xqefUltw\n", "l7pUXdnps91O+w90Oy8iubxtQzXc1U/7Iz8/7Zs07C5N19+1a5fjOfi08UAg2TMYtg5EWMJtKFYq\n", "ASBVw7btmzQspJRZ2Z+fg4Zt6W9DKIXdlJLvqW0YztZ+PLVl586dWqYlAa677jqjHQ2fR0ZGOup4\n", "GI72TbqKglJKbdmyRcs0xUYqN8Cxff/bAs8SAAAAAIAABksAAAAAAAKeC8NxKisrtfzcc89pmYfa\n", "6Ay4KVOmGDoaJpMqgEphHOq+lKqg8sVcqVuytLTU0NXV1WmZzpTbv3+/0W7s2LE+rylcsZ21o5S7\n", "6sr+nJ/eb9vz+xOaCUd7Sve3Z8+ejjre/6hrnrri+T2j59i2bZuho1WIbRdKlcLx/iykGy5IYRwJ\n", "p/vrTyiMzoris4kpPL2iR48eWg7EIslex/ZapTAcX6ScLgo/c+ZMLfN7TcN3/DpoGI7PUt++fbuW\n", "+W8eXfmiT58+jud32zfd2BaeJQAAAAAAAQyWAAAAAAAEMFgCAAAAABDwXM4SjyXSuDeNY/K4Kc1p\n", "6NKli+M5eT6CVDqA4lSNlu/zuCytbrpixQpDR2PCNO7785//3Gj3+eefa5mvzB5KcXUJ26mvko1s\n", "V532p8K29OzQeL90XV6bXu4Wt3kR0r2n5+SVuWn1e5rnIp2f5xPa5rvR87vNb/BCzouUzxUI/Dmf\n", "U56SdF9ojqpScp4SzRUdNmyYoaO/D/S58scmXu+bbq6P249Wxz548KChoytJ0PILvJ9K7z66AsL5\n", "8+cN3Xfffadl+luolPm8SDnHLVmyBZ4lAAAAAAABDJYAAAAAAAQ8EYaTXGRff/21luk0YOreU+pv\n", "KwPbfhbd59VSnRYg5CFA6trkLkpafZpXH6UVyelxtKSAUkrdcccdWv7oo49UKOEmdOM2dMA/y2mh\n", "V2nBTx4G4FVtKX379vX5d8ktLeFFt38g7Eft8O233zqen983vui1r/MpZfZH+o5Q6m9t7fTZtqUD\n", "JLxoPwmn0ihuK0DbhiH5OWhJle+//97x/Pyd37VrVy3zytFuQ29OBMu20mKz0uLETvBz0FUk+O/O\n", "qFGjfB7HSz9IVdxpf+SLoNMyOzTFRikz9Na/f38t25ZvaQ7gWQIAAAAAEMBgCQAAAABAAIMlAAAA\n", "AACBoOQs+TO9dceOHVqmpdN53hBdUVyansyhOQ3SMib083g7pynI/LMnTZpk6Oh3y8vL0zLPu6Dl\n", "Avz5bi2F7arhUr6Dbc6EhBTTp7bk+W30OB5Xp7kPNI6ulJmPxnPVnK4j0FO5A40/fTMQq55LULvQ\n", "PsftR3NZeF6L03UoFfilSrzYNyluywoE+pktLy839ukUcp6D0qlTJy3TZS+UMkvE0DITSnnv3jcH\n", "tjlhTu9Zvs91/HfI1/mUMn/ztmzZYuhoDtoNN9xg6E6ePKnlM2fOGLr09HQt0/4u5ZA2N/AsAQAA\n", "AAAIYLAEAAAAACDg+dIBNARFXbI8DCdViJXcyNS9z1349DOo7HZ1Y34d1L1IP5u7P2n4sTUi3UMK\n", "11Gb0XvNw6gVFRVa5u5gSlJSktVnS25q6Tgvhg7chFhtV3lXygy7dO/e3dA59Q/e953srJQ8hdxt\n", "RXJbnRew7TtSqCYQ0NDb0aNHHdvRd7xSSg0dOlTLvDwAn+r+9+JP+D8YfZWHKJ3KYvgTaqO/Lbzv\n", "0JIONOWApowopdT27du1TMsBKKXUnDlzfJ5DKbMsECctLc3n36UQI3/P2q4cYAs8SwAAAAAAAhgs\n", "AQAAAAAIYLAEAAAAACDgiZwlCVrSvri42LHdvn37tDxkyBBDJ8XtpdIBTjFhHjumsVKp/Dqflk6X\n", "1qCfxa+Rrvjs9RwJjpuSADyeTFce58cUFhZquVu3boaO5n7Raf989etDhw45fjY9rmfPnoZOykVy\n", "g9ennnPc5ClJyxXwnCWnZRT27NljtNu1a5fj+aXPpth+l1DOX+IE4nql5ThovhjtY7wdzVPq3bu3\n", "oaM5NVJZFk6wyiIEC7elV2JiYrRMf2eUUmrdunVapn2zoKDAaEfzi37wgx84nv/IkSOGjr6HaW6a\n", "UmbuEy0XEKiyJG6AZwkAAAAAQACDJQAAAAAAAU+E4SRX2u23365l6srlLnXq8pXctdwFLFXfdrou\n", "3o5+Np/OWlRUpOXNmzcbupqaGp/XSMslKKXU008/rZzw+tRzW+h01Pz8fENH3bDcfnSfu4fplHJ6\n", "T/mzQ+3AdXT6bHZ2tqGjIQIaIuZ2oKUJ+OraEydOVF4mEG5uek95pXO6TyvaK6XU7t27tUynjTuF\n", "x5X623tP+2Mgwqb+9LFQ6pu2tpXKL9C+opRZoZnamU9Rp6kWvDwHfXakEKvb++t1u1D4u4/i1n6U\n", "66+/3tjfuHGjluk7ODMz02g3btw4LfPyO/SZ4L9/9Jy2ZVk4ga7CLwHPEgAAAACAAAZLAAAAAAAC\n", "GCwBAAAAAAh4ImeJIpUzpzKPX9OcET5FkU5t9Ceu6TQtluc+nDhxQss7d+501NHcFX4tdNXsf/iH\n", "fzDaRUdHO3621/BnauexY8e0fPDgQS3zZQ1ovlFycrKhq6qq0rKUD0PLNPDrkO4pPQddQVspM/+o\n", "rKxMy3zJFPrdPv74Y0MXGxur5W+//dbxOrxAIPJauI3oc89zWZyeHb7cSWpqqpZ5vpu0DFJrwM2U\n", "cn+W+aD25MuY0D5BbcunidMp61JfdLtcjS2h9nzYLjck2ZP+xvF+RXOY6O8fzxmkx/Gc3U2bNmn5\n", "3Llzho6WFejTp4+hc7KFPzayXerHFniWAAAAAAAEMFgCAAAAABAIShjOn1ANrcI8fPhwLdPKzUqZ\n", "07+/+OILQ7d//34t8+reNMTFwwC0VAGFhwBp2EVaCZu7mGkIglaxve222xzP4UXcVjXmlbQbycjI\n", "MPb79++vZT59Vjo/DWvR54Ofg4YBpGnp3H7U7vQ6Bg0aZLQbOXKkln/yk58YuvHjxzt+XjDwp2+6\n", "Wal+7Nixxj6tis5LP/Tq1cunLIXr/vjHPzp+tlQhXZqCbKvjhFJYx9Z+dLq3Ukp98803WuYhVmqn\n", "gQMHajkhIcFo5zZc4k+4sKm/hyK2YTgJ2/thW4Wf62jqCf8sGo7lfZr+Nkr9j35ec/dFeJYAAAAA\n", "AAQwWAIAAAAAEPDEbDjJbUjdc9dcc42WV6xYYbSjGfncFXj27Fktb9myxdDRsAuvPspnBzghVVal\n", "oRvqWlTKDEHcf//9WqaLCCr1t+5titfcym7d6F26dNFy3759jXZOMyL5OXhols5Wo3bu16+f0Y7u\n", "S5XhuR1oeFCqIC8ttGzrRg4Wbtz7UiiP24+G1/giqk4zcPg5qG7MmDGGLisrS8t8puqwYcO0LIUS\n", "pBl1XrSZE25nBNH3J53ZyaEV7ZUyF1+li1y7DefahlGb0lGkxZXDBbcz5Zz6LU9VoDqFb5mzAAAg\n", "AElEQVTex2iqAn3HK/W36QoUp7BfoELkboBnCQAAAABAAIMlAAAAAAABDJYAAAAAAAQ8kbNkC417\n", "83gnzVfhuUd0n09RpPFXqTKpNHWS5qvw0gF8lXnKjBkztNy5c2ct85yXllxZOVjQKab8nvEcLsrx\n", "48e1fOrUKUNH7Ufzi3hOlBQTpzpuF6fj3OZPeN220vXZ5jbxPkb7o5SLRNvxPkyheTJKmTbi096p\n", "PaW8Mqnvh2Pf5Ll/OTk5Wub2o6VXBgwYYOhSUlK0bJvzwrHtm7bT2aUcJa/bz598I1vovef9yqlv\n", "8nZUl5eX53iOzMxMQ0d/l3nfdMoBld7BUt8MBPAsAQAAAAAIYLAEAAAAACDgiTCcbYVO6tKjISyl\n", "zGrb2dnZho6GY3g5ACkMR92ckiuQuhC5jrqm09PTDV3Xrl21TN2ObsM4XkS6XnqvpAU56X3jVdVp\n", "OQYefqVuX3qvJZe9NO1fcgHbhnFCeeq5bRiEt5NKPziF2pQy+yptJy2EnJSUZOho5Xa6mLJSZshc\n", "KhHhdupyKEHD2Xv37jV0NNRGF7VWyuxj8fHxhs6p3INU/qM5+qZtqMbrtrW9PrfvGKlv0r7I++nu\n", "3bu1LC0Wz0sH0P7Hy+pQnVM/Vcr9e9dNyQh4lgAAAAAABDBYAgAAAAAQwGAJAAAAAEDAEzlLFNup\n", "2zz3iK7sTle4VkqpjRs3aplP7afxcv7ZdDX6qVOnapmvjh4TE+N4fnpOrnOKtzb3FMjmRIqX8+9F\n", "Y+IXLlzQMi8BUFJSomWel0RzkWh5AKXM1c2d8qP4PtdRm9kuYxLK9uPYxv2l/BG6z/MCbUspSPeX\n", "2ohPQT5//ryWi4uLDR3Nk3Bj56au32vwa6UlOlauXKnl2NhYo11qaqqWef+j+Su2uTL879KzI9nF\n", "domhcFmuhuPUP6R7KOUl2T7b/O/0fc3fn2lpaVqmv5NKmfmEvN/SvinZuSXzCeFZAgAAAAAQwGAJ\n", "AAAAAEAgKGG4QEzjk+DTW2+55RYt8/CdbfVY6srkU2Spzp9V6wMxvdULuAmlKKXUkCFDtEyndfMw\n", "Jz2OunWVMssK8BABdeVKbmrJRm6mJwdzZey/F3/6plPVbn8qC9tWxqdIYQYe6qZhogMHDhi6wYMH\n", "a3nXrl2O5w/XvknDcBs2bNAyr8RN98eMGWPoaBiH20uyLcW2PIA/08adQm+h3Dc5TveX3yfaH/1J\n", "Q7ENg+fn52u5rKzM0NHQGw27KWW+n3npAKd3sm2ldl/7fy/wLAEAAAAACGCwBAAAAAAggMESAAAA\n", "AICAJ0oHSHFjHsO2acdjttLK5rY5S7Y5L7ZLYijlHBMOtdi5hO0yGBMmTNCytCo510n3nuJmCjzX\n", "2eareH3ZBH+Qrt1piR5/8vak5Yac+qaUn8LtN3z4cC2vWrXK0NFnTsp/Cde+SUsEfPjhh1qW3pHc\n", "RjTXhN972zw2277pT75KoJcC8QL8O1K72ObnSH2H5zNR21K783Z0CSpa5kUps4xPcnKy42fbln5w\n", "mzMYiPwleJYAAAAAAAQwWAIAAAAAEPBEGI7C3WVO7lt/QinUnSiteC19hq0rXnITunUVhxL82qWp\n", "qU73VDqHFGqztaWkc2tb288KZZqjb9L+6E/JAafP459Ny1OsWLHC8TjbKs+hbFupX0ntpBCGFEpx\n", "Y09/PttNeM32PRAK0HsjheSkd5hUcsCpb3K7lpeXa/m//uu/DF1mZqaWaakO/tm2oW9/+iZKBwAA\n", "AAAAtCAYLAEAAAAACHguDCdh65KVwgXN4eoPxEyoUHMB20K/F7/3Tt9Zsp9tKMj2mprSubFZuNqS\n", "Y1uhGX3Tmzj1TbezimzDfLbX1JQOffN/cArJSe2a0tn2zX/+53/W8qOPPurYTlpk3rZvNveMNwl4\n", "lgAAAAAABDBYAgAAAAAQwGAJAAAAAEDA8zlLTjFKt1PIJWyP8yfuHa4xcje4zQtxa89AA1s64zQN\n", "n4O+6U1s+6ZX+mJTtGbbSrk7PJ/JNs+nue0ezFwkW+BZAgAAAAAQiGjNI3AAAAAAgKaAZwkAAAAA\n", "QACDJQAAAAAAAQyWAAAAAAAEMFgCAAAAABDAYMkHxcXFSRkZGTm1tbUdmmpbWFiYPHjw4OyLFy+2\n", "b4lrA/4De4YPsGV4AXuGD+Fuy1YxWJo7d+6fU1JSCmJjY8v79ev33b/8y7/8H6n9b3/720ULFix4\n", "q0OHDrVKKVVbW9vhrrvuejMuLq4sJSWlYOnSpY80tk1OTi6cPn36htdff/3e5v4e4K/k5ORkXH31\n", "1V/Gx8eXpqWlHVm9evUtUntuz9OnT3e/+eabP+rSpcu5nj17nnrttdfua2wLe7YcFy9ebH/33Xe/\n", "0adPn7zY2NjykSNH7l67du0PpGO4LR977LF/TU9Pz42NjS3PyMjIWbZs2bzGtrBly1NSUtL51ltv\n", "/TA6OrqyT58+ecuXL79Dao93rXeZNm3axo4dO1bHxMRUxMTEVGRkZORI7bkt58+f/3aHDh1qG4+P\n", "jY0tb2hoiFAqRG3Z0NAQ9tuBAweGVFdXRzY0NKhDhw4NTE5OPrNmzZof+GpbU1PTITExsfj06dOp\n", "jX9btGjRs1OmTNlUWloal5OTM6hbt24Fa9euvb5Rv3Xr1olDhw7dH+zv2Rq2urq6tmlpablLly59\n", "+PLlyxFffvnl9KioqMrc3Nw0W3tOmzZtwyOPPPJv9fX1bfbu3ZvZuXPncxs2bJgGe7bsVlVV1enJ\n", "J59ccuLEiV4NDQ3qk08++WFMTEx5Xl5eb1tbLlmy5MnDhw+nNzQ0qB07doxNSEgo2bZt2wTYMjjb\n", "7Nmzl8+ePXt5VVVVpy1btkyKi4srPXjw4GBbe+Jd651t2rRpG9544427bNr6suX8+fPfeuKJJ552\n", "OibUbBn0C2jp7dChQwO7d+/+/c6dO0f50m/atGnKgAEDjtC/paamnv7888+vbdxfvHjxU7Nnz17e\n", "uF9XV9e2U6dOVSdPnuwZ7O8X7tv+/fuHRkdHV9C/zZgxY51Tp+T2rKioiI6IiLhcXFyc2Pi3e++9\n", "97V58+a9A3sGf8vMzNy7atWqW21s6Wu76aabPnrhhRcehS1bfqusrIxq37597ZEjRwY0/u3OO+/8\n", "v4sWLXrW1p5413pnmzZt2oY//elPd9u09WXL+fPnv/X4448/43RMqNmyVYThlFLqgQceeDUqKqpq\n", "yJAhBx9//PFfjxo1apevdvv37x82cODAw43758+fTygoKEgZPnz43sa/ZWZm7jt48OCQxv22bdvW\n", "Dxgw4OiePXtGNO+3AL64fPnyFQcOHBjqS8ft2fD/3cCN//o6HvYMDoWFhcm5ubnpQ4YMOehLz23J\n", "qa6u7vjNN9+MGTp06IHGv8GWLUdubm564/1u/Nvw4cP30nclBe9a7/OrX/3q2aSkpOKrrrpqy6ZN\n", "m6Y6tXPqm6+++uoDXbp0OTd69OhvV61adRvVhZotW81g6dVXX32gsrIy+osvvrj28ccf/3VWVtZY\n", "X+1KS0vjY2JiKhr3Kysro5VSKi4urqzxb7GxseUVFRUx9LiYmJiKsrKyuOa6fvBXBg4ceLhr165F\n", "zz///MK6urp269evn7F58+Yp1dXVHX215/aMiYmpmDRp0tZnnnnmidra2g67du0atWrVqtv48bBn\n", "y1JXV9duzpw5786fP//t9PT0XF9tuC05P/vZz/4wYsSIPTNmzFhP/w5btgyVlZXRsbGx5fRvMTEx\n", "Ffxd2Qjetd7mueee+9/Hjx/vm5+fn3rvvfe+fuONN3783Xff9fPV1lff/MUvfvH7o0ePDiguLk56\n", "5plnnpg/f/7b27Ztm0jbhJItW81gSSmlIiIiGqZNm7bxJz/5yUqnxMPOnTuX0M4ZHR1dqZRS5eXl\n", "sY1/Kysri+MPRkVFRUx8fHxpc107+Cvt2rWrW7169S2ffvrpDxsTQGfNmvV+jx49vvfVnttTKaXe\n", "fffdOcePH+/bs2fPUw8++OArc+fO/XP37t1P0zawZ8tx+fLlK+bNm7csMjKy5uWXX/65Uztftmxk\n", "4cKFz2dnZw9+//33Z3EdbNkyREdHV9L3pFK+35WN4F3rbcaOHZsVFRVV1a5du7o777zznUmTJm39\n", "7LPPZvpq66tvjhw5cndCQsL5K6644vINN9ywZs6cOe9y71Io2bJVDZYaqauraxcVFVXlS5eZmbkv\n", "Nzc3vXE/ISHhfEpKSgF1Fe7du3c4dfXX19e3PXr06ADqPgbNx7Bhw/Zv3Lhx2tmzZxPXrFlzw7Fj\n", "x/qPHTs2y1dbbk+llOrVq9fJjz/++MaioqKu27dvn1BcXJw0bty4HY162LPlaGhoiLj77rvfKC4u\n", "Tvrggw9+3KZNm0tObX3ZUimllixZ8tS6deuuX79+/YzGH9xGYMuWIz09Pbfxfjf+jb8rKXjXhg9O\n", "fVMi5GwZ7KSp5t6KioqSli9fPruysjKqvr6+zdq1a6+PjY0ty8rKGuOrfW1tbfukpKQiPkNj6tSp\n", "G8+fPx+fnZ2d0a1bt4J169bNaNRv3bp14uDBgw8G+7u2lm3fvn3DqqurI6uqqjo9//zzj/Xr1+/Y\n", "xYsX29naMycnZ1B5eXlMbW1t+2XLls1NTEwsPnv2bBfYs+W3++677w/jx4/fXllZGdVUW1+2/M1v\n", "fvOrtLS03DNnziT7Oga2bNlt9uzZy++44473qqqqOn311VdXxcXFlWZnZ2fY2hPvWm9spaWlcWvX\n", "rr2+uro6sq6uru2f//znOVFRUZU0eb8pW65cufL2ioqK6EuXLl2xbt26GTExMeWbNm2aEqq2DPoF\n", "NPdWXFycOHXq1I3x8fHn4+LiSseMGZP10Ucf3SQds3Dhwt8999xz/4s+CHfdddcbsbGxZcnJyWeW\n", "Ll36MG3/wAMPvPLSSy/9PNjftbVsCxcu/F1CQkJJdHR0xcyZMz89duxYP3/s+eKLL/4yKSmpKCoq\n", "qnLy5Mmb+cxI2LNltry8vN4RERGXO3bseCE6OrqicXvvvffusLVlRETE5cjIyGp6/LPPPrsItgzO\n", "VlJSknDLLbd8GBUVVdm7d++85cuXz5ba413rza24uDhxzJgxWTExMeXx8fHnJ0yYsO2LL764xh9b\n", "Tp48eXNcXFxpbGxs2YgRI3avWLFiVijbMugX4MWtuLg4cdCgQTk1NTUdmmpbWFjYNSMjI7u2trZ9\n", "sK8bG+wZ7htsGV4b7Bk+W7jbMqKhoSHYkUAAAAAAAM/SKhO8AQAAAABswWAJAAAAAEAAgyUAAAAA\n", "AAEMlgAAAAAABNo214krKipeqK6ufrS5zg9kunbtGtF0K3uysrIwEyBIjB07NqC2PHLkyPJz587N\n", "DuQ5gT3jx48PqD1XrVqFvhkkbrvttoDa8rvvvtt84cKFyYE8J7Bj6NChoi3hWQIAAAAAEMBgCQAA\n", "AABAoNnCcAC0BBERAfWC/w2oQxZYmttegQA2d0dL2xZ2Ai0JPEsAAAAAAAIYLAEAAAAACIRlGM6t\n", "O7g53Mi2ruLW7lKW7r2tjrdzOk46n2QHrqP7TnJT5wwXbPuOrY24zu3zYWtPt/Zr7ba17X9XXGH3\n", "/3Kp3eXLlx11tn2Tn6M12M8Wfu/dvD/d/oa66acc6fkIBPAsAQAAAAAIYLAEAAAAACCAwRIAAAAA\n", "gEDI5iwFIsfFH51bbOOtTseEM075Dv7kPtjq3CLZj8bIqSy1k84fatjmNEi2pTaz1bm1q5Sv4mRL\n", "3q415C/50//ovq1O6qf+5J9JNrt06ZJPHT+/1G/DxZ4Uf+69m/ezPzmJtnmCtjbi3y3QOUzwLAEA\n", "AAAACGCwBAAAAAAgEFJhOLfuPttQjT/npNi6E23DM/xz3YTyvIgUZrF157dp08bQ0X1JJ4V7pPtL\n", "3flUVkqp+vp6nzrbkADH67a1db/7E6pxshHXSe3y8/O1vHnzZkN38eJFLf/jP/6joXOyLbcztRnX\n", "hcu0dLf9r23btj5lvn/gwAEtr1y50mhH7ffiiy8auuTkZC3ze0/36+rqDB3dp/2Uyvwckt1D1ZZK\n", "2YfBbfstfwboOblOQuo7Tnbh7aRQLL0ubls3wLMEAAAAACCAwRIAAAAAgAAGSwAAAAAAAp7LWWqO\n", "0vq2OikWS2UeHy8pKdEyj43GxcVpuV27do7ndxsf93osXcoVcspD4bkPtB3X0Xtqq5OeMW4/amsp\n", "L0JqJ8XObaesBws3+Q5S7pGU1yLpqC0LCgqMdgcPHtSylBP21ltvGfvjx4/X8pAhQ7TM7UfzXPg9\n", "kHIhvJ7z4pSH4k9eErVL+/btDR3d37t3r5b5/e3Tp4/jZycmJmqZ5xvRfLSamhpDV1tb67MdlX1d\n", "C0Xqt16zp20JDtu8QEkn9VMp70nK2ZXyQamNpLw16d3KcZPDBM8SAAAAAIAABksAAAAAAAKeC8Nx\n", "bKcnN8fUZbpP3YJnzpwx2lVXV2tZCuNwN2R8fLyWJVcmxWvuX47b6r+2rn4eyiwvL9dyTk6Oofv+\n", "+++trqNHjx5a7tu3r6Gj+9S1z88pIT0DXrcnxda9bxtO4/tcR/sVDbXl5eUZ7WjfpLZUSqmYmBgt\n", "Hz161NDt3LlTy126dNFyt27dlC1S2Ql6v7xgZ8l+tqFubqPIyEif51BKqQ8//FDLJ0+e1HJqaqrR\n", "rlevXj7Pp5TZh3nIjNqWyko5v0P9Ke1Cnysvhsgptu9ZKcTKj3OyO38GpHe3FIaTSj9Iv4FOSLaV\n", "nn3bSt/wLAEAAAAACGCwBAAAAAAggMESAAAAAICAJ3KWArHycSCWVOA6Os309OnTWubxVanEO827\n", "4NNWae5Tx44dtdy7d2+jHY0R+7MqdzAIRM6SlNdSXFxs6D7//HOf51DKnLpMbcSvkU5FpzkSSil1\n", "7tw5LY8ePdrQOU37d1uSX1qGpaVwaz/bqefctvR+fP3114aO9jmn8yml1MCBA7V85ZVXGrpOnTo5\n", "nn/79u1aps9A9+7djXY0t8KfFde9gBv7STlLHTp0MHQ0x4g/r3v27NEyzc/keUllZWVafvfddw0d\n", "fT546YCoqCgtL1iwwNBFR0drWZpeLum8jlO5AH/KA9C2vPSDU54SPwe1u3R+Dv09lJY7ob+3/DeU\n", "lozgOYk0T+7aa691vA5b4FkCAAAAABDAYAkAAAAAQMATYThb3FbwlkJ01P1XWlpq6HiJAH+vke9L\n", "Uy5puIeH+TIyMvy+jpYk0OFR7sqtqKjQ8vr16w0dvYc05KKUUkOHDtUyDQNwqN3pFHWlTNfu2LFj\n", "ra7fi+EYCTdhcEnnTwXorKwsLR8/ftzQ0f5Cp/ZTuyqlVHp6uuM1UugK9vw6z58/r2WpLEmoEYgK\n", "7FIYlYZuduzYYehomIwex8N1tJ2U0lBVVWXs0377+uuvGzoamp0yZYqW3UxJ9wrSc+n2t5HaVuq3\n", "Fy5c0DJ/R9LUCP6elUqKFBYWapk/EzTcRu1OfyeVUio/P1/Lu3fvNnT0eczOzlZ/L6H75AAAAAAA\n", "tAAYLAEAAAAACGCwBAAAAAAgEJScJX9yAJzaBiK3QikzblpSUmLoaByVxtyl0vd0yqpSSsXFxTl+\n", "No2507ycU6dOGe1ozpIXl8uwnT5tG0vn00NXr17ts51SSiUkJGj5Rz/6kaHjOUw218WX0qB2aY57\n", "LS234AVs7Wm76jnPi4iNjdVy586dDR1djX7YsGGO56DTh22XLOJIuTK2eNF+FNv3om2JD6XM/kFL\n", "MfBz0jxMXhrlnnvu0TJ/f9LP5n1z48aNjp996NAhLdMp5D/+8Y+VE163n4RtP/Wnb9I8JVp2g+eO\n", "0ZwzWgZCKbNv0r6ulLlEDe+bNPfJqYSIUubvclpamqELRJ4SBZ4lAAAAAAABDJYAAAAAAARCtnSA\n", "23a8QjMNhfEKrtTFl5SU5PPvSpmuRz49mV4LP39iYqLPdryEQSi5h/25Vif38NatW412tbW1WuZT\n", "U3/4wx9qmVcGpuE8el1SCQMeYqU24t/NqTK3Pyubh5JtbfGnfAStuM2rbztVV+b9SAolUHJychzP\n", "T8sP+GOjULat0/X5M/V85cqVWi4qKnI8LjU1Vcvz58832lGb0b6ulBn269u3r6GjYVoeGlq3bp2W\n", "V6xYoWVagkIppSZNmqRlqfJ+qNqyKaiNaPkMpcwSAeXl5Vru1q2b0Y72W+ke8urvtqHvyspKLdMV\n", "MZQy3/H82bz//vu1LL27bYFnCQAAAABAAIMlAAAAAACBoIThuEusuSvk0lluPFufZuHz8Bp1+1Id\n", "d/fR2QAc6uqXXH/0OkJtQUdqT7eLwdLj+IKItEpwZmamoaMLEPMZFdICqBTqyqUuXw53ATuFYPxx\n", "54eLe9/tjEgpjOUUevPn/NRmdLFc6fzSbFd/Qqxew+310fcdDccoZb5bpcVQJ0+erGU+o44eJ83E\n", "k+zev39/Y5/OwqIz9rZs2WK0mzhxouM5vW5PW6QwKg29HThwwNDRdyENefJZZ1L1fvrulqqH83tN\n", "Z0/SdlIoj7//achVmglrCzxLAAAAAAACGCwBAAAAAAhgsAQAAAAAIBBSpQMo0vRkPgWSrorM4+p0\n", "KjqfEkljpdL0Z3ot/kxJdIqJB6KacLAIROkAaery4MGDHT+Pf7bTlHJ+fprHQGPlSpnPDp8aTWPi\n", "bqaicoKVIyF9Lr1XbvKXlJLzTqRcL6dyD7z/0XxCnndIc2x4LiA9v5Q/EcpI/cPpmZX639tvv23o\n", "aB4Yv/fXXHONlkeNGuV4fnrvaY6LUmY5EH6cU2kQpcxcNVqJmpaIaAqv5aNxe7n5nTh27JixT8tp\n", "8FyyESNGaJnm70q5Y1JeEj+/VFbHNh+0JW0EzxIAAAAAgAAGSwAAAAAAAiEbhuPQKaznzp1zbMen\n", "HtLQG3cBO02JdDs9nkOvk4Z/Bg0a5HgdXnAHc6TSARJOoTfJvcwXzBwyZIiW+UKsdOorrdzOF+Sk\n", "oRr+2dQ9TBddVspcxFfCdvqzF3ETepPC1P7gFEbl7nzab3kl5z179jheB+1nvXr10jJfyFki1Ozp\n", "BlrJOTc319DRhW95GO7aa6/VMrUZb0ftR0uB8ON4qIa+MyUdDd3Qhc05UvjRi9hWYKflcvjqCJL9\n", "9u/fr2Xaj/i9TklJ0TItMaCUuQICT3OhdpHK5bgN/wcaeJYAAAAAAAQwWAIAAAAAEMBgCQAAAABA\n", "IKRylmhMkpcvl8ru0+N69Ohh6KRy7NJ0ZYrtquQcmisjTY8PJQJROkCCrxxP8yloGQilzOeAxuN5\n", "XhLV8eunq6BL+Q6tETf240j5btROtJ/y3Aq6/8033xi606dPa5nnOo0ZM8bnNfmznIqk80J+oe3U\n", "aqf8MKXMpUN4aQ3ax/j3j42N1TK99zwvieaR0lIB/JqlaeO8XAz9PlLf93pekhv4d6K5sfwdRvf5\n", "vaf3UOqn1C6HDx82dHTpKv7bS5eo4bnETs8q/x22LdkSCDvDswQAAAAAIIDBEgAAAACAgOfDcNR9\n", "Riux8pXpqRuvU6dOhi45OdlnO35+26mjblcep+5spZQqLS3Vcs+ePbXMSxgEojp0SyHdQymUSbn5\n", "5puNfboa9smTJx2Po1V7lTLd/XSaf79+/Yx2dOrr559/buhouJeHf5xKAgSifIJS3gjjUCTb2n5n\n", "/ixLZRWcQkP8OaLPBw8D0CnJ48aNM3T0+ZDKBYRjqEYpd88vtx/tH3z6Nz0/DcPxUBgPjzqdn6de\n", "0M9bv3694zmlVAuJUOqbEgMGDNByRkaGoaP3htvF6fmQQpm8vAotW8Crh+fn52t55MiRhi4mJsbn\n", "+f0h0P0WniUAAAAAAAEMlgAAAAAABDBYAgAAAAAQ8HzOEo0N0yUrpJgxn0JO45/S+W1zkfzJWaL7\n", "Z8+eddTZLp0RytjmhPGy+HTK6e7duw2dU3kApcxS/nQFbd6O5rnQGLtSchn+1oZtDgCfXr5z504t\n", "83wHus9z+ui0fzqtOSkpyWhXXFysZZ7XQvc3b95s6GiOG10ah18jzWnjuRVRUVEqVHCbc0bfUzy3\n", "i5bWGDt2rKFzWs6C24g+L5L9+HNFr4W/d51y3MI1/8xN7q1ScukHilMZAaXMe83LA9BcXJ6bRpdQ\n", "oX1YKfk325ZA55XBswQAAAAAIIDBEgAAAACAgOfCcNwVSENvtBIprwJLXfN89XkpTBYIt6xtlW5e\n", "ZbZv375appVUQ6lUACcQrn7+/akLn4bTlJIrD1O3Lz0nd+d/++23WuZhABoSpCUo+DVLfw8Xe3L7\n", "0bDyrl27fP5dKTPcxUt3UBtxNz3dp3bh4Tp6Xfze02eH253u03ASn/5My0m88847hu71119XXsY2\n", "PCO1o7bl9572uV69ehk6en9tVzmQKjTv27fP0H3yySdalko//PSnP9Xy9OnTDZ10nNextZ+E9N51\n", "aufPihX0Wvi9pn2Tl/vxIvAsAQAAAAAIYLAEAAAAACDguTAcd+PR0BV16XF3vjSbTFoEUPps2+Mo\n", "tMq4UkoVFBRombuYbWfSeL1abKAWHnVCcgFLszmojsp8xpvTM6aUUldeeaWW+Sw6GpJw66b2OvR+\n", "0Iq7Sin1u9/9Tsu0/1199dVGu9TUVC0PGzbM0NE+wc+/d+9eLVdVVWmZ24HOwqLVipUybUTPoZRZ\n", "vZjOxvn000+NdocOHdIyTQUINaQK6VJfpDNQpdlqPIzjNBuOzzCVZpzS8Civrp+bm+t43KhRo7Q8\n", "d+5cLfNQrG2/DVdsZ3JLf5fewU4rcHCdrV2kxZSb237wLAEAAAAACGCwBAAAAAAggMESAAAAAICA\n", "53KW6DRupZSqqKjQcteuXbXcp08fo520crWb6bOSjsdN6TXSqsNKmXFUWs1UKTP3IpSnl1Pclg6Q\n", "2tHcCp73RdtyndNxW7ZsMdrRnAl+DlqiQoqXU51t7D/UoJW4lVKqqKhIy3PmzNHyddddZ7STVpw/\n", "cOCAlvnUcJqvQqcWX3/99Ua73r17O14zrfzNcwTp+WmJCJrjopRZtVsqS+J13Kbq8iUAAAdLSURB\n", "VJYOoPbjuaJ0n7+Dqa2dZL7PKzm//PLLjjp672npFaWUmjVrlvKFlFfldVtK7z63JXCk96eTjrej\n", "8LxAmld28uRJQxcbG6tlnnPsJge0ud+78CwBAAAAAAhgsAQAAAAAIOCJMBx192VlZRm6gQMHapm6\n", "/+giqVznzxRZWzckhU+BpFXG+dRaGjrk1+zkAva6O7g5kOxg68KXKnhTmU9TpZ/HK8kmJiZqmYZt\n", "lHKeDu3P9Fav2Z0/8/SalixZYuho6G3q1Kla5n2ATr2nfUUps9o3t19mZqaWx40bp2UecqHwaej0\n", "+qUp65L90tLStMy/m9cXWrYtlSKVSaGLo544ccLQ0f7CQzA0REdTDngV8P3792t548aNho6W+eD3\n", "moZV77nnHkNHF1OnFeS5/ZzKiyjljf7oBl4ahYbL+coXNEwtVdCXVkqgdj927JjjdfHfP7oaA184\n", "l1b7lvqmbfpDIGwJzxIAAAAAgAAGSwAAAAAAAhgsAQAAAAAIeCJnicYTS0tLDR2Nb3fp0sXqfG7z\n", "kmynRPLyADSmmpSUZOhoLNY2pur1vBZ/CESpemoXKa7Ol8GgsXUaA+c5EzSPYcyYMYaO5jfxXCd6\n", "nLScQyiVFZBWDaf5W0qZ9/Qvf/mLlmkeklJmjhHPCaN5Sf379zd0tDwItSXv39K9l+znpJPykoK5\n", "3IIbbN8rUu7Otddeq+U333zT0NE+x0ty0JIqdGkZnttE36fSvZ88ebKho0vn8Dw22sed+infD+X3\n", "LrXZQw89ZOhoH6MlMpQyc7t4PhO1rVT+g+7TcgBKmcsP0dw3pcz3B5WVcvdube7yO/AsAQAAAAAI\n", "YLAEAAAAACDguTDc0aNHDR1dsZwiudzcVjOlU0yVUqqkpETLNDzIXYHUBczdkJRQc+G7QVqR2nbq\n", "tj9hLNvPpiUp+MrxNATDw0S0XAB3FTuFboLpKm5O1qxZY+xTNz0Ns/BwKNVRuanjbMNE1A68vAMN\n", "x9iG4fyxX0tWEP574dfj1Of4faLvYJ5mQN+Z/Ljs7Gwtc7tL10WhJSNmzJhh6GgJFx5ap31VCrGG\n", "UukAfn30d45eKw2bKmVWuOepLHQ6Pw/DOfVN/htHw/NSKgvvm9QuUhjO9t1qG2Z2CzxLAAAAAAAC\n", "GCwBAAAAAAhgsAQAAAAAIOCJnCXKJ598YuzTfCC6dIhTLpMvaPl3HtekcVQ61VUpM1ZKS/fzKdS0\n", "7L603IJtTNzruQ8c6TvSuDq/NzxO7e9n8c/jORMUuqI9z1mi5+SrqtPng+c7OMXSQzmvhSNdu5Tn\n", "4gZ+3/j99vW5vJ2UVyblLIVL6QeO1Ded7MdzPuk7+P777zd0X331lZa3bdtm6Og5ac7LzJkzjXY0\n", "z2XIkCGGjr5bKysrDV2g8wlD2bZUnj17ttHOadknvs9zBp2O48+HlJfqlHuklH25jkAsdxII4FkC\n", "AAAAABDAYAkAAAAAQMATYTjqLuvVq5ehS0hI0DJ1tdKp4EqZrmI+BVKqPkpdijwEQ6dO8sqnFOpC\n", "9KcKrG0YLpSQwmRNtW1EqsLMp59Se0rTVmlJitzcXMfrkKp7Sy5gt9PLvYZ0fba25OeQXPG0T3P7\n", "OdlTsoMUBpBKVwSiPECo2ZbfD5t2vLTGj370Iy3feuuthk5671Lo/ebPB02NkCroByJEHmplPZyu\n", "158+TO8Nv4dOKydIpXmkvm9buoJfp22ozZ/fHjfAswQAAAAAIIDBEgAAAACAgCfCcNStt2PHDkPn\n", "5IqXFsuV3IRuq3s7uayVsq8q7U/16XDBTehGCpdwV7yt3Wlo9rPPPjN0N954o+P5pfCMk3s4nGxp\n", "69KXvj/tw/we0jCc277pdE38WtzaL5RnM1Kka5UWlJXCJdR+PNRG7W4burENdfN9HkJyOmco20+C\n", "fkf+mynZVgph0/O4ne1qGyazrb7tNk0gEMCzBAAAAAAggMESAAAAAIAABksAAAAAAAKeyFmi8Ng2\n", "jVE6rbLMkXRu8yJsY9v+xMDDJV5ui5v8F65zm6s2a9YsLd9+++2O7aTcB9tclnC1q+338mfqvZv8\n", "Qn/6fqDtF062dfouUu4H7x9S3pBt37S1kT/PVWvIJ3SC3ycpZ1D6TXV6DvwpHSDp3PS5YJZ3gGcJ\n", "AAAAAEAAgyUAAAAAAAHPheEkmsM9Hojpyq3BtRsI3E7btbVRc9sSdjZxcqNLduDTkwNhM1uaI5Qe\n", "LtiGtJqjLEsgwjqt0Wa2uA1dSSsiBJpQqJ4OzxIAAAAAgAAGSwAAAAAAAhFwXwIAAAAAOAPPEgAA\n", "AACAAAZLAAAAAAACGCwBAAAAAAhgsAQAAAAAIIDBEgAAAACAAAZLAAAAAAACGCwBAAAAAAhgsAQA\n", "AAAAIIDBEgAAAACAAAZLAAAAAAACGCwBAAAAAAhgsAQAAAAAIIDBEgAAAACAAAZLAAAAAAACGCwB\n", "AAAAAAhgsAQAAAAAIIDBEgAAAACAAAZLAAAAAAACGCwBAAAAAAj8P2HZijmyd+aJAAAAAElFTkSu\n", "QmCC\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig = plt.figure(figsize=(10,10))\n", "for i,num in enumerate(toTest):\n", " a=fig.add_subplot(5,5,(i+1)) #NB the one based API sucks!\n", " plt.axis('off')\n", " a.set_title(str(preds[i]) + \" (\" + str(y[num]) + \")\")\n", " plt.imshow(-X[num,0,:,:], interpolation='none',cmap=plt.get_cmap('gray'))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Miscelaneous \n", "\n", "### Accessing the weights of the network\n", "To caluclate the number of weights in the networks, we have to take the following layers into account:\n", "\n", "1. First Convolutional Layer: 32x3x3 + 32 = 320(32 filter and 32 biases)\n", "2. Second Convolutional Layer: This layer goes from 32 to 64 using 32*64 = 2048 Kernels of size 2x2. So Altogether: 32x64x2x2 + 64 = 8256 weights are used.\n", "3. Fully connected layer (hidden4): The fully connected layers contains 500 nodes with connect to the 64 6x6 images for the last pooling layer. Hence, we have 500 x 6 x 6 x 64 + 500 = 1152500 weights\n", "4. Output layer: The 500 nodes of hidden4 are the fully connected to the 10 outnodes reflecting the 10 classes. Together with the bias, we have 5010 weights.\n", "\n", "So altogether for this toy model we already have about 1.2 Million parameters, much less then we have examples. A nightmare in classical statistic. Modern architectures like \"Oxford Net\" have more than 100 Million parameter. The weights can be obtained as follows (the biases are given in the one dimensional terms)." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "('0', ' ', '(10,)', '10')\n", "('1', ' ', '(500, 10)', '5000')\n", "('2', ' ', '(500,)', '500')\n", "('3', ' ', '(2304, 500)', '1152000')\n", "('4', ' ', '(64,)', '64')\n", "('5', ' ', '(64, 32, 2, 2)', '8192')\n", "('6', ' ', '(32,)', '32')\n", "('7', ' ', '(32, 1, 3, 3)', '288')\n", "Number of parameters 1166086\n" ] } ], "source": [ "import operator\n", "import numpy as np\n", "weights = [w.get_value() for w in net.get_all_params()]\n", "numParas = 0\n", "for i, weight in enumerate(weights):\n", " n = reduce(operator.mul, np.shape(weight))\n", " print(str(i), \" \", str(np.shape(weight)), str(n)) \n", " numParas += n\n", "print(\"Number of parameters \" + str(numParas))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Visualizing the weights\n", "\n", "The 32 3x3 weight of the convolutional layer can be visualized as follows." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": [ "iVBORw0KGgoAAAANSUhEUgAAAX4AAAFtCAYAAAAAmAHJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\n", "AAALEgAACxIB0t1+/AAAD5NJREFUeJzt3VuIV3W/x/HvpB3M4ulkkbWz3B0n2QpZQxa77CIJxora\n", "YUHRGBaWFQQVlJBpFhVaQWIHbZwg6DwKRhl1EZRRFIWGRnYwM8MyJjsbo/73lTeyL5a/397ObL6v\n", "1/X68PuvZ03vZ9HFqq3VagUAeewz0D8AgL1L+AGSEX6AZIQfIBnhB0hG+AGSEX6AZIQfIBnhB0hG\n", "+AGSGTrQP2CXTz75pOrbEUcccUTxdtSoUcXbVqvV1vTaiRMnVt1jb29vzTwOPfTQmnmj+1yyZMmS\n", "lStXdpUeMn78+NJpRERcfvnlxdsRI0Y0fpaTJ0+uepavvfZazTzGjBlTvP3ss88a3Wer1VoTEe2l\n", "50yYMKF0GhERH3zwQfF2T/65bFV8t+aee+4pnUZEREdHR/G2s7Oz8T3uzhs/QDLCD5CM8AMkI/wA\n", "yQg/QDLCD5CM8AMkI/wAyQg/QDLCD5CM8AMkI/wAyQg/QDLCD5CM8AMkM2i+x3/AAQdU7Tds2FC8\n", "rfke/5546qmnqvZXXnll1X7ZsmXF22HDhjW6btSoUbFt27bic2666abibUTE4YcfXry94oorGl+7\n", "7777Fp8TUf8d9wsvvLBq38TDDz8cmzdvLt7PmTOn6vzu7u6qfVM///xz8bbmf5+IiJEjR1btS3nj\n", "B0hG+AGSEX6AZIQfIBnhB0hG+AGSEX6AZIQfIBnhB0hG+AGSEX6AZIQfIBnhB0hG+AGSEX6AZAbN\n", "9/jb29ur9lu2bCnednR0VJ3d1LXXXlu1/+qrr6r2w4cPL97u3Lmz0XXHHHNMDB1a/me1ffv24m1E\n", "RGdnZ/F2T77H/+qrrxafExHx4osvVu1POumkqn0Tp512WtX34mfNmlV1/pAhQ6r2TS1evLh4W9ut\n", "8ePHF2+b/jP5P/HGD5CM8AMkI/wAyQg/QDLCD5CM8AMkI/wAyQg/QDLCD5CM8AMkI/wAyQg/QDLC\n", "D5CM8AMk09ZqtQb6NwCwF3njB0hG+AGSEX6AZIQfIBnhB0hG+AGSEX6AZIQfIBnhB0hm6ED/gF3W\n", "rVu3qGY/b9684u1VV11VvJ04ceL1Ta995plnqu5x5MiRNfO46KKLauaN7rO3t3fqp59+OqH0kP7+\n", "/tJpRER0dXUVb0899dTGz/LNN9+sepaTJk2qmcd7771XvD333HMb3eesWbNm//DDD8V/dPvvv3/p\n", "NCIipk2bVrwdN25c42f50UcfFT/LE044oXQaERF33XVX8XbRokWN73F3gyb8mzdvLn/KEbF48eLi\n", "7bhx44q3exL+d955p+oeTz/99Jr5Xgn/xx9//J9Lly7tKj1k27ZtpdOIqAvqnoR/9erVVc+yNvzr\n", "1q0r3jYN/yuvvPJfa9eubS89Z/jw4aXTiIi48MILi7d7Ev7169cXP8sjjjiidBoRdd2qCb9/1QOQ\n", "jPADJCP8AMkIP0Aywg+QjPADJCP8AMkIP0Aywg+QjPADJCP8AMkIP0Aywg+QjPADJNPWarUG+jdE\n", "RESr8ofccccdxdu+vr7ibXd3d1vTa88+++yqezzooINq5vHss88Wb0eOHNnoPv/5558l27dv7yo9\n", "58ADDyydRkTdZ52HDRvW+FnOnTu36ll+8sknNfNYtmxZ8Xbnzp2N7nPFihVrfvvtt+LPMq9Zs6Z0\n", "GhERW7ZsKd4uXLiw8bNctWpV8bN84403SqcREbFw4cLi7Xfffdf4HnfnjR8gGeEHSEb4AZIRfoBk\n", "hB8gGeEHSEb4AZIRfoBkhB8gGeEHSEb4AZIRfoBkhB8gGeEHSEb4AZIZOtA/YJd169ZV7Xt6eoq3\n", "xxxzTNXZTe2zT93/z7799ttV+3HjxhVvf/rpp0bX3XjjjVXP4sEHHyzeRkT8/fffxdtZs2Y1vvbg\n", "gw8uPici4tJLL63av/vuu1X7JubNmxdffvll8b72v62wdu3aqn1TY8eOLd7ut99+VWd//fXXVftS\n", "3vgBkhF+gGSEHyAZ4QdIRvgBkhF+gGSEHyAZ4QdIRvgBkhF+gGSEHyAZ4QdIRvgBkhF+gGTaWq3W\n", "QP8GAPYib/wAyQg/QDLCD5CM8AMkI/wAyQg/QDLCD5CM8AMkI/wAyQg/QDJDB/oH7NLT01P17Yj5\n", "8+cXbx9//PHi7fnnn9/W9Np777236h4nTZpUM4/u7u7i7aJFixrd59SpU5f09PR0lZ5zyimnlE4j\n", "ImL27NnF2ylTpjR+lq3Kb52MGDGiZh4ff/xx8fb4449vdJ9jx45ds3bt2vbSc2r+3iIirrnmmpp5\n", "42d58sknFz/LWbNmlU4jIuLqq68u3rZarcb3uDtv/ADJCD9AMsIPkIzwAyQj/ADJCD9AMsIPkIzw\n", "AyQj/ADJCD9AMsIPkIzwAyQj/ADJCD9AMsIPkMyg+R7/jz/+WLWv+Vb9BRdcULzduXNn42vnzJlT\n", "fE5E/be/b7jhhqp9E93d3VXfYX/ssceqzh89enTVvqna/27AE088UbWvuc+mf7M7duyIHTt2FJ/z\n", "zTffFG8jImbOnFm8vf/++xtfu3nz5uJzav/ejjzyyKp9KW/8AMkIP0Aywg+QjPADJCP8AMkIP0Ay\n", "wg+QjPADJCP8AMkIP0Aywg+QjPADJCP8AMkIP0Aywg+QzKD5Hv+dd95Zte/t7S3enn/++VVnN/Xi\n", "iy9W7VutVtV+06ZNVfsmtm/fvkf/jYLdHX300VXn1/x3Gfr6+hpfu2HDhuJzIuq/4z5q1KiqfRNj\n", "xoyJ4cOHF+//+uuvqvM/+OCDqn1TW7duLd5Onjy56uwJEyZU7Ut54wdIRvgBkhF+gGSEHyAZ4QdI\n", "RvgBkhF+gGSEHyAZ4QdIRvgBkhF+gGSEHyAZ4QdIRvgBkmmr/dQvAP+/eOMHSEb4AZIRfoBkhB8g\n", "GeEHSEb4AZIRfoBkhB8gGeEHSGboQP+AXaZPn76qZn/bbbcVb7u7u4u3Dz300Nim127atKnqHj/8\n", "8MOaeVx22WU180b3uXr16jmbNm26pPSQjo6O0mlERPT19RVvTzzxxMbPcuzYsVXP8swzz6yZxznn\n", "nFO8nTp1aqP77Orq6v3222//vfScP//8s3QaEREfffRRzbzxs3zwwQeLn+XFF19cOo2IiOeff754\n", "e9999zW+x90NmvB/8803/1Gz37ZtW/H2u+++qzm6sf7+/qp7rIna3vLXX3/929atW4vvc/v27VXn\n", "1/wd7InVq1dXPcvDDjus6vyTTz65at/E119/fcoXX3zRXrr/7bff/jd/zv+ZH374ofhZ/v3331Vn\n", "b9y4sWpfyr/qAUhG+AGSEX6AZIQfIBnhB0hG+AGSEX6AZIQfIBnhB0hG+AGSEX6AZIQfIBnhB0hG\n", "+AGSGTSfZX7zzTer9n/88UfxdsiQIVVnN7Vs2bKq/UsvvVS133fffYu31157baPr+vv7qz5VW/uZ\n", "2zFjxlTtm7r88sur9i+//HLV/q233qraN9HX1xdbtmwp3h911FFV59f8vfb39ze+9tdffy0+Z/To\n", "0cXbiIh58+ZV7Ut54wdIRvgBkhF+gGSEHyAZ4QdIRvgBkhF+gGSEHyAZ4QdIRvgBkhF+gGSEHyAZ\n", "4QdIRvgBkhF+gGTaWq3WQP+GiIjo7e2t+iG333578Xb9+vXF21ar1db02uXLl1fd45VXXlkzr/rW\n", "/c6dOxvd5913371k6dKlXaXnrFu3rnQaERHvv/9+8bajo6PxsxwxYkTVs/ziiy9q5vHII48Ub+fO\n", "ndvoPs8444w1n3/+eXvpOcuXLy+dRkTEggULirdLly5t/Czb2tqKn+UhhxxSOo2IiF9++aVm3vge\n", "d+eNHyAZ4QdIRvgBkhF+gGSEHyAZ4QdIRvgBkhF+gGSEHyAZ4QdIRvgBkhF+gGSEHyAZ4QdIZtB8\n", "lhmAvcMbP0Aywg+QjPADJCP8AMkIP0Aywg+QjPADJCP8AMkIP0Aywg+QzNCB/gG7rFy5surbEeee\n", "e27x9l//+lfxduvWrW1Nr+3u7q66x+nTp9fMo7+/v3jbarUa3ecDDzyw5I033ugqPWfNmjWl04iI\n", "6Ovrq5k3fpaTJk2qepZ//PFHzTzef//94m3TZ/nkk0+u+fnnn9tLz5k2bVrpNCIi7r777uJtd3d3\n", "42e5zz77FD/LTZs2lU4jIuKFF14o3t52222N73F33vgBkhF+gGSEHyAZ4QdIRvgBkhF+gGSEHyAZ\n", "4QdIRvgBkhF+gGSEHyAZ4QdIRvgBkhF+gGQGzWeZzznnnKr9p59+Wrw9/PDDq85u6tFHH63a//jj\n", "j1X7W2+9tWrfRGdnZ4wbN654P2PGjKrzFyxYULy9+eabG1+7YsWK4nMiIm666aaq/XnnnVe1b2LB\n", "ggWxdu3a4v3rr79edf5DDz1UtW/qpJNOKt7Omzev6uz58+dX7Ut54wdIRvgBkhF+gGSEHyAZ4QdI\n", "RvgBkhF+gGSEHyAZ4QdIRvgBkhF+gGSEHyAZ4QdIRvgBkhF+gGTaWq3WQP+GiIh44YUXqn7IlClT\n", "irf//PNP8faAAw5oa3rtLbfcUnWPv//+e808lixZUrxta2trdJ/XXXfdkp6enq7Sc2r/Ho899tji\n", "7caNGxs/yxkzZlT90EsuuaRmHu3t7cXbY489ttF93nzzzWs2btxYfNDMmTNLpxERcdZZZ9XMGz/L\n", "U089tfhZrly5snQaERHr168v3o4fP77xPe7OGz9AMsIPkIzwAyQj/ADJCD9AMsIPkIzwAyQj/ADJ\n", "CD9AMsIPkIzwAyQj/ADJCD9AMsIPkMyg+SwzAHuHN36AZIQfIBnhB0hG+AGSEX6AZIQfIBnhB0hG\n", "+AGSEX6AZIQfIJmhA/0DdjnuuOOqvh3R3t5evJ09e3bxtqOjo63pta3K72MMGTKkZh5PP/108Xba\n", "tGmN7xMY3LzxAyQj/ADJCD9AMsIPkIzwAyQj/ADJCD9AMsIPkIzwAyQj/ADJCD9AMsIPkIzwAyQj\n", "/ADJCD9AMoPme/zff/991f76668v3nZ0dFSd3VRvb2/V/rjjjqvav/7668XbadOmVZ0NDB7e+AGS\n", "EX6AZIQfIBnhB0hG+AGSEX6AZIQfIBnhB0hG+AGSEX6AZIQfIBnhB0hG+AGSEX6AZIQfIJm2Vqs1\n", "0L8hIiKee+65qh9y3nnnFW9XrVpVvO3s7Gxrem1fX1/VPdY+q/nz5xdvH3jggcb3CQxu3vgBkhF+\n", "gGSEHyAZ4QdIRvgBkhF+gGSEHyAZ4QdIRvgBkhF+gGSEHyAZ4QdIRvgBkhF+gGQGzWeZAdg7vPED\n", "JCP8AMkIP0Aywg+QjPADJCP8AMkIP0Aywg+QjPADJCP8AMkIP0Aywg+QjPADJCP8AMkIP0Aywg+Q\n", "jPADJCP8AMkIP0Ay/w14cQKkiMYGYAAAAABJRU5ErkJggg==\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "conv = net.get_all_params()\n", "\n", "ws = conv[7].get_value() #Use the layernumber for the '(32, 1, 3, 3)', '288' layer from above\n", "fig = plt.figure(figsize=(6,6))\n", "for i in range(0,32):\n", " a=fig.add_subplot(6,6,(i+1))#NB the one based API sucks! \n", " plt.axis('off')\n", " plt.imshow(ws[i,0,:,:], interpolation='none',cmap=plt.get_cmap('gray'))" ] } ], "metadata": { "kernelspec": { "display_name": "Python 2", "language": "python", "name": "python2" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.5" } }, "nbformat": 4, "nbformat_minor": 0 }