{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Start by getting the MNIST data -- the handwritten digits -- again through the Keras interface. Remember, we are trying to train a model to classify the input data into which digit (0-9) it represents.\n", "
\n",
"Here we explicitly reshape the input data and normalize it, and encode the training labels. Keras also has an interface to the MNIST data: it returns the images and integers giving the true values. We can use the keras to_categorical function to convert the true values into \"one-hot\" vectors.\n",
" "
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2024-04-30 09:34:03.047380: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
"To enable the following instructions: SSE4.1 SSE4.2 AVX, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"training data shape: (60000, 28, 28)\n",
"First label: [0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]\n"
]
}
],
"source": [
"#import data\n",
"from tensorflow.keras.datasets import mnist\n",
"(train_images, train_labels), (test_images, test_labels) = mnist.load_data()\n",
"\n",
"# shape input data into 1D and scale\n",
"shape=train_images.shape\n",
"print('training data shape: ',shape)\n",
"train_images = train_images.reshape((shape[0],shape[1]*shape[2]))\n",
"train_images = train_images.astype('float32') / 255\n",
"\n",
"# shape test data input 1D and scale\n",
"shape=test_images.shape\n",
"test_images = test_images.reshape((shape[0],shape[1]*shape[2]))\n",
"test_images = test_images.astype('float32') / 255\n",
"\n",
"# convert labels into vectors\n",
"from tensorflow.keras.utils import to_categorical\n",
"train_labels= to_categorical(train_labels)\n",
"print('First label: ', train_labels[0])\n",
"test_labels = to_categorical(test_labels)\n",
"\n",
"# number of input nodes\n",
"ninput = shape[1]*shape[2]\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we will define the Keras model and the parameters we will use to train it. We will start by instantiating a model using models.Sequential(), then add layers using the add() method. This takes as a first argument the number of neurons. You can specify the activation function with the activation() keyword. \n",
"
\n",
"For the first layer, you have to specify the input shape, but for all subsequent layers, it will inherit the input shape from the previous layer.\n",
"
\n",
"After adding the layer, use the compile() method to specify an optimizer with the optimizer() keyword, a loss function with the loss=() keyword, and, optionally, an accuracy metric.\n",
"
\n",
"Note that Keras supports a layers.Normalization layer that you can use as the first layer to normalize the data."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"from tensorflow.keras import models\n",
"from tensorflow.keras import layers\n",
"from tensorflow.keras import optimizers"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model: \"sequential\"\n",
"_________________________________________________________________\n",
" Layer (type) Output Shape Param # \n",
"=================================================================\n",
" normalization (Normalizatio (None, 784) 1569 \n",
" n) \n",
" \n",
" dense (Dense) (None, 30) 23550 \n",
" \n",
" dense_1 (Dense) (None, 10) 310 \n",
" \n",
"=================================================================\n",
"Total params: 25,429\n",
"Trainable params: 23,860\n",
"Non-trainable params: 1,569\n",
"_________________________________________________________________\n"
]
}
],
"source": [
"#instantiate a model\n",
"net = models.Sequential()\n",
"\n",
"# add layers\n",
"net.add(layers.Normalization(input_shape=(ninput,)))\n",
"net.add(layers.Dense(30,activation='sigmoid'))\n",
"\n",
"# how many neurons does the last layer need to have?\n",
"net.add(layers.Dense(10, activation='sigmoid'))\n",
"\n",
"# print out a summary of the architecture\n",
"net.summary()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You now specify the optimizer and loss function using the compile() method. You can find information about optimers and loss functions . Here are a couple of examples."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"net.compile(optimizer=optimizers.SGD(learning_rate=30.),loss='categorical_crossentropy',metrics=['accuracy'])\n",
"net.compile(optimizer=optimizers.Adam(),loss='categorical_crossentropy',metrics=['accuracy'])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we train the model with the input data using the fit() method, specifying number of epochs with the epochs= keyword and batch size with batch_size= keyword. We can also include validation data with the validation_data= keyword, which takes a tuple of (validatation_input,validation_labels)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch 1/10\n",
"469/469 [==============================] - 5s 7ms/step - loss: 1.0112 - accuracy: 0.7948 - val_loss: 0.5002 - val_accuracy: 0.8972\n",
"Epoch 2/10\n",
"469/469 [==============================] - 3s 6ms/step - loss: 0.4113 - accuracy: 0.9012 - val_loss: 0.3352 - val_accuracy: 0.9160\n",
"Epoch 3/10\n",
"469/469 [==============================] - 3s 6ms/step - loss: 0.3127 - accuracy: 0.9167 - val_loss: 0.2794 - val_accuracy: 0.9254\n",
"Epoch 4/10\n",
"469/469 [==============================] - 3s 7ms/step - loss: 0.2683 - accuracy: 0.9259 - val_loss: 0.2488 - val_accuracy: 0.9298\n",
"Epoch 5/10\n",
"469/469 [==============================] - 3s 7ms/step - loss: 0.2403 - accuracy: 0.9330 - val_loss: 0.2282 - val_accuracy: 0.9341\n",
"Epoch 6/10\n",
"469/469 [==============================] - 3s 6ms/step - loss: 0.2198 - accuracy: 0.9384 - val_loss: 0.2130 - val_accuracy: 0.9389\n",
"Epoch 7/10\n",
"469/469 [==============================] - 3s 6ms/step - loss: 0.2034 - accuracy: 0.9431 - val_loss: 0.2012 - val_accuracy: 0.9424\n",
"Epoch 8/10\n",
"469/469 [==============================] - 3s 6ms/step - loss: 0.1900 - accuracy: 0.9470 - val_loss: 0.1899 - val_accuracy: 0.9442\n",
"Epoch 9/10\n",
"469/469 [==============================] - 3s 6ms/step - loss: 0.1787 - accuracy: 0.9501 - val_loss: 0.1812 - val_accuracy: 0.9473\n",
"Epoch 10/10\n",
"469/469 [==============================] - 3s 6ms/step - loss: 0.1686 - accuracy: 0.9531 - val_loss: 0.1746 - val_accuracy: 0.9488\n"
]
}
],
"source": [
"history = net.fit(train_images,train_labels,epochs=10,batch_size=128, \n",
" validation_data=(test_images,test_labels))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can now inspect the learning curves. The fit() method returns a dictionary that has keys 'loss' and 'val_loss', among others, that are arrays with length of the number of training steps, so you can plot loss against training steps for both training data and validation data."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"history keys: dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])\n"
]
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABIbUlEQVR4nO3dd3iV9f3/8ec5JznnZJyc7EUSwILIkLCUAtqhFoujUmnBrwNxfYtiEWm1UltXrXxbrbXVQiuK46dV3DiwSrUOwMUIUPZOIIEMyB4nOef8/jjJgZAEknBO7pPk9biuc+Xkzn3O/Q5E8+Iz3rfJ6/V6ERERETGI2egCREREpHdTGBERERFDKYyIiIiIoRRGRERExFAKIyIiImIohRERERExlMKIiIiIGEphRERERAwVZnQB7eHxeMjPz8fhcGAymYwuR0RERNrB6/VSUVFBeno6ZnPb4x/dIozk5+eTmZlpdBkiIiLSCXl5eWRkZLT59W4RRhwOB+D7ZmJiYgyuRkRERNqjvLyczMxM/+/xtnSLMNI0NRMTE6MwIiIi0s2cbImFFrCKiIiIoRRGRERExFAKIyIiImKobrFmREREAsfr9dLQ0IDb7Ta6FOnmLBYLYWFhp9x2Q2FERKQXcblcFBQUUF1dbXQp0kNERkaSlpaG1Wrt9HsojIiI9BIej4c9e/ZgsVhIT0/HarWqkaR0mtfrxeVyUVRUxJ49exg4cOAJG5udiMKIiEgv4XK58Hg8ZGZmEhkZaXQ50gNEREQQHh7Ovn37cLlc2O32Tr2PFrCKiPQynf3Xq0hrAvHzpJ9IERERMZTCiIiIiBhKYURERELe9773PebMmWN0GRIkCiMiIiJiqF4dRt5Zn8+vXtvA+rxSo0sRERHptXp1GHn/vwUsWZ3HF7tLjC5FRMQQXq+XaldDlz+8Xm+naz5y5AjTp08nLi6OyMhIJk2axI4dO/xf37dvH5deeilxcXFERUUxdOhQli1b5n/tVVddRVJSEhEREQwcOJBnnnnmlP8c5dR0uM/IZ599xsMPP8yaNWsoKCjgzTffZPLkySd8zaeffsrcuXPZtGkT6enp3HnnncycObOzNQfM8IxYlm08qJEREem1aurdDLnngy6/7uYHLiTS2rlWVzNmzGDHjh28/fbbxMTE8Ktf/YqLLrqIzZs3Ex4ezqxZs3C5XHz22WdERUWxefNmoqOjAfjtb3/L5s2bef/990lMTGTnzp3U1NQE8luTTujwT0JVVRXZ2dlcd911TJky5aTn79mzh4suuoibbrqJF154gZUrV3LLLbeQlJTUrtcHU3ZGLAAb9pcZWoeIiLRPUwhZuXIl48ePB+DFF18kMzOTt956i5/+9Kfk5uYyZcoUzjzzTABOO+00/+tzc3MZOXIkY8aMAaBfv35d/j1ISx0OI5MmTWLSpEntPv/vf/87WVlZPPbYYwAMHjyY1atX88gjjxgeRs7McGIywYHSGooq6khy2AytR0Skq0WEW9j8wIWGXLcztmzZQlhYGGPHjvUfS0hIYNCgQWzZsgWA2bNnc/PNN/Phhx9ywQUXMGXKFIYPHw7AzTffzJQpU1i7di0TJ05k8uTJ/lAjxgn6mpEvvviCiRMnNjt24YUXsnr1aurr61t9TV1dHeXl5c0ewRBtC2NAkm/obsP+0qBcQ0QklJlMJiKtYV3+6Ow9cdpaa+L1ev3veeONN7J7926uueYaNm7cyJgxY3j88ccB3z+o9+3bx5w5c8jPz+f888/nl7/8Zef+8CRggh5GDh48SEpKSrNjKSkpNDQ0UFxc3Opr5s+fj9Pp9D8yMzODVl92ZiyA1o2IiHQDQ4YMoaGhga+++sp/rKSkhO3btzN48GD/sczMTGbOnMkbb7zBL37xCxYtWuT/WlJSEjNmzOCFF17gscce48knn+zS70Fa6pLdNMcn4KZk21YynjdvHmVlZf5HXl5e0GrLznACkKN1IyIiIW/gwIFcdtll3HTTTaxYsYL169dz9dVX06dPHy677DIA5syZwwcffMCePXtYu3YtH3/8sT+o3HPPPSxdupSdO3eyadMm3n333WYhRowR9Lv2pqamcvDgwWbHCgsLCQsLIyEhodXX2Gw2bLauWb/RNDKyYX9ps2E+EREJTc888wy33XYbl1xyCS6Xi+985zssW7aM8PBwANxuN7NmzWL//v3ExMTwwx/+kD//+c8AWK1W5s2bx969e4mIiODcc8/l5ZdfNvLbEbogjIwbN4533nmn2bEPP/yQMWPG+H9wjHRGagxWi5nS6npyD1fTNyHK6JJEROQ4n3zyif95XFwczz//fJvnNq0Pac1vfvMbfvOb3wSyNAmADk/TVFZWkpOTQ05ODuDbupuTk0Nubi7gm2KZPn26//yZM2eyb98+5s6dy5YtW1i8eDFPP/10yCwYsoaZGZweA8B6TdWIiIh0uQ6HkdWrVzNy5EhGjhwJwNy5cxk5ciT33HMPAAUFBf5gAtC/f3+WLVvGJ598wogRI/jd737HX//6V8O39R5rROO6ES1iFRER6Xodnqb53ve+d8I2vs8++2yLY9/97ndZu3ZtRy/VZYZnxAL7FEZEREQM0KvvTdOkaRHrf/PLaHB7jC1GRESkl1EYAU5LjMJhC6O23sP2Q5VGlyMiItKrKIwAZrOJM5vWjagTq4iISJdSGGl0bL8RERER6ToKI42a7uCbk6ftvSIiIl1JYaRRdqZvmmb7oQpqXG6DqxERkUDr16+f/w7y4LslyVtvvdXm+Xv37sVkMvn7anVWoN7nZGbMmMHkyZODeo1gCXoH1u4iNcZOssNGYUUdm/LLGNMv3uiSREQkiAoKCoiLiwvoe86YMYPS0tJmISczM5OCggISExMDeq2eRCMjjUwmU2O/EchRvxERkR4vNTW1S+6DZrFYSE1NJSxM//5vi8LIMUY0TtVsUFt4EZGQ8Y9//IM+ffrg8TTvA/WjH/2Ia6+9FoBdu3Zx2WWXkZKSQnR0NGeddRb//ve/T/i+x0/TfP3114wcORK73c6YMWNYt25ds/Pdbjc33HAD/fv3JyIigkGDBvGXv/zF//X77ruP5557jqVLl2IymTCZTHzyySetTtN8+umnnH322dhsNtLS0rjrrrtoaGjwf/173/ses2fP5s477yQ+Pp7U1FTuu+++Dv251dXVMXv2bJKTk7Hb7Zxzzjl88803/q8fOXKEq666iqSkJCIiIhg4cCDPPPMMAC6Xi1tvvZW0tDTsdjv9+vVj/vz5Hbp+RyimHaNpR42294pIr+H1Qn111183PBLaeZf0n/70p8yePZv//Oc/nH/++YDvF+kHH3zgvxFrZWUlF110EQ8++CB2u53nnnuOSy+9lG3btpGVlXXSa1RVVXHJJZdw3nnn8cILL7Bnzx5uu+22Zud4PB4yMjJ45ZVXSExMZNWqVfzv//4vaWlpTJ06lV/+8pds2bKF8vJy/y/1+Ph48vPzm73PgQMHuOiii5gxYwbPP/88W7du5aabbsJutzcLHM899xxz587lq6++4osvvmDGjBlMmDCBH/zgB+36c7vzzjt5/fXXee655+jbty9//OMfufDCC9m5cyfx8fH89re/ZfPmzbz//vskJiayc+dOampqAPjrX//K22+/zSuvvEJWVhZ5eXnk5eW167qdoTByjOF9YgHYV1LNkSoXcVFWYwsSEQm2+mp4KL3rr/vrfLC27y7p8fHx/PCHP+Sf//ynP4y8+uqrxMfH+z/Pzs4mOzvb/5oHH3yQN998k7fffptbb731pNd48cUXcbvdLF68mMjISIYOHcr+/fu5+eab/eeEh4dz//33+z/v378/q1at4pVXXmHq1KlER0cTERFBXV0dqampbV5rwYIFZGZm8sQTT2AymTjjjDPIz8/nV7/6Fffccw9ms2/SYvjw4dx7770ADBw4kCeeeIKPPvqoXWGkqqqKhQsX8uyzzzJp0iQAFi1axPLly3n66ae54447yM3NZeTIkYwZMwbwLfBtkpuby8CBAznnnHMwmUz07dv3pNc8FZqmOYYzMpz+ib7/ODYc0FSNiEiouOqqq3j99depq6sDfOHhiiuuwGKxAL5fvnfeeSdDhgwhNjaW6Ohotm7d2uzGrSeyZcsWsrOziYyM9B8bN25ci/P+/ve/M2bMGJKSkoiOjmbRokXtvsax1xo3bhymY0aGJkyYQGVlJfv37/cfGz58eLPXpaWlUVhY2K5r7Nq1i/r6eiZMmOA/Fh4eztlnn82WLVsAuPnmm3n55ZcZMWIEd955J6tWrfKfO2PGDHJychg0aBCzZ8/mww8/7ND32FEaGTlOdoaTPcVVrM8r5bunJxldjohIcIVH+kYpjLhuB1x66aV4PB7ee+89zjrrLD7//HMeffRR/9fvuOMOPvjgAx555BEGDBhAREQEP/nJT3C5XO16/xPdALbJK6+8wu23386f/vQnxo0bh8Ph4OGHH+arr77q0Pfi9XqbBZFjr3/s8fDw8GbnmEymFutmTnSN49/v+GtPmjSJffv28d577/Hvf/+b888/n1mzZvHII48watQo9uzZw/vvv8+///1vpk6dygUXXMBrr73Woe+1vTQycpymHTXqxCoivYLJ5Jsu6epHO9eLNImIiODyyy/nxRdf5KWXXuL0009n9OjR/q9//vnnzJgxgx//+MeceeaZpKamsnfv3na//5AhQ1i/fr1/zQTAl19+2eyczz//nPHjx3PLLbcwcuRIBgwYwK5du5qdY7VacbtP3KtqyJAhrFq1qlkAWrVqFQ6Hgz59+rS75hMZMGAAVquVFStW+I/V19ezevVqBg8e7D+WlJTEjBkzeOGFF3jsscd48skn/V+LiYlh2rRpLFq0iCVLlvD6669z+PDhgNR3PIWR4zQtYs3JK2tXUhYRka5x1VVX8d5777F48WKuvvrqZl8bMGAAb7zxBjk5Oaxfv54rr7yy3aMIAFdeeSVms5kbbriBzZs3s2zZMh555JEW11i9ejUffPAB27dv57e//W2z3SngW3exYcMGtm3bRnFxMfX19S2udcstt5CXl8fPf/5ztm7dytKlS7n33nuZO3euf73IqYqKiuLmm2/mjjvu4F//+hebN2/mpptuorq6mhtuuAGAe+65h6VLl7Jz5042bdrEu+++6w8qf/7zn3n55ZfZunUr27dv59VXXyU1NZXY2NiA1Hc8hZHjDE2PIcxsoriyjvyyWqPLERGRRueddx7x8fFs27aNK6+8stnX/vznPxMXF8f48eO59NJLufDCCxk1alS73zs6Opp33nmHzZs3M3LkSO6++27+8Ic/NDtn5syZXH755UybNo2xY8dSUlLCLbfc0uycm266iUGDBvnXlaxcubLFtfr06cOyZcv4+uuvyc7OZubMmdxwww385je/6cCfxsn93//9H1OmTOGaa65h1KhR7Ny5kw8++MDf6M1qtTJv3jyGDx/Od77zHSwWCy+//LL/z+MPf/gDY8aM4ayzzmLv3r0sW7YsYGHpeCZvN/jnf3l5OU6nk7KyMmJiYoJ+vYv/+jmb8stZeNUoJp2ZFvTriYh0hdraWvbs2UP//v2x2+1GlyM9xIl+rtr7+1sjI63wT9Vo3YiIiEjQKYy0IjujsROr7uArIiISdAojrWgaGdl4oAy3J+RnsURERLo1hZFWDEiKJiLcQmVdA7uLKo0uR0REpEdTGGlFmMXMmX18UzXrddM8ERGRoFIYaUN24x181+eVGluIiEiAdYNNlNKNBOLnSWGkDU2dWHUHXxHpKZrai1dXG3CXXumxmn6ejm9f3xG6N00bRjQuYt1SUE5dgxtbmMXYgkRETpHFYiE2NtZ/s7XIyMgW9y4RaS+v10t1dTWFhYXExsb6b1rYGQojbciIiyA+ysrhKhdbCir84UREpDtrurV9e+/+KnIysbGx/p+rzlIYaYPJZGJ4hpNPthWxYX+pwoiI9Agmk4m0tDSSk5NbvW+KSEeEh4ef0ohIE4WRE8jOiOWTbUXk5JUyfZzR1YiIBI7FYgnILxGRQNAC1hPQjhoREZHgUxg5gaYdNbuLqyiv1XCmiIhIMCiMnEBitI2MuAi8Xvivmp+JiIgEhcLISWT7+40ojIiIiASDwshJaN2IiIhIcCmMnIQ6sYqIiASXwshJnNnHidkEBWW1FJbXGl2OiIhIj6MwchJRtjAGJjsArRsREREJBoWRdhieoXUjIiIiwaIw0g7Zja3gtW5EREQk8BRG2qHpvjQb9pfh9XqNLUZERKSHURhph0GpDqxhZspq6tlXUm10OSIiIj2Kwkg7hFvMDE2PATRVIyIiEmgKI+3U1Ik1R4tYRUREAkphpJ2aOrFu0PZeERGRgFIYaaemkZH/Hiij3u0xthgREZEeRGGknfolROGwh1HX4GH7oQqjyxEREekxFEbayWw2Hb2Db56makRERAJFYaQD1IlVREQk8BRGOkCdWEVERAJPYaQDmjqxbj9UQbWrwdhiREREegiFkQ5IibGTEmPD44X/Hig3uhwREZEeQWGkg5oWsW7QVI2IiEhAKIx0UNO6EXViFRERCQyFkQ46OjKi7b0iIiKBoDDSQWc2bu/NPVzN4SqXwdWIiIh0fwojHeSMCOe0xChAW3xFREQCQWGkE5rWjWxQJ1YREZFTpjDSCdlNnVg1MiIiInLKFEY6YXhTJ9a8Urxer7HFiIiIdHMKI50wJC2GMLOJkioXB0prjC5HRESkW1MY6QR7uIXBaTGA7uArIiJyqhRGOqnpDr7qxCoiInJqFEY6SZ1YRUREAkNhpJOaOrFuPFCG26NFrCIiIp2lMNJJA5KjibRaqHa52VVUaXQ5IiIi3ZbCSCdZzCbO7ONbN6KpGhERkc5TGDkF/k6sWsQqIiLSaQojp6Bp3Yi294qIiHSewsgpaNreu6WgnNp6t8HViIiIdE8KI6cgIy6ChCgrDR4vWwrKjS5HRESkW+pUGFmwYAH9+/fHbrczevRoPv/88xOe/+KLL5KdnU1kZCRpaWlcd911lJSUdKrgUGIymfzrRtZrEauIiEindDiMLFmyhDlz5nD33Xezbt06zj33XCZNmkRubm6r569YsYLp06dzww03sGnTJl599VW++eYbbrzxxlMuPhQM99/BV+tGREREOqPDYeTRRx/lhhtu4MYbb2Tw4ME89thjZGZmsnDhwlbP//LLL+nXrx+zZ8+mf//+nHPOOfzsZz9j9erVp1x8KPCPjGhHjYiISKd0KIy4XC7WrFnDxIkTmx2fOHEiq1atavU148ePZ//+/Sxbtgyv18uhQ4d47bXXuPjii9u8Tl1dHeXl5c0eoappR83uoirKauqNLUZERKQb6lAYKS4uxu12k5KS0ux4SkoKBw8ebPU148eP58UXX2TatGlYrVZSU1OJjY3l8ccfb/M68+fPx+l0+h+ZmZkdKbNLxUdZyYyPAOC/BzRVIyIi0lGdWsBqMpmafe71elsca7J582Zmz57NPffcw5o1a/jXv/7Fnj17mDlzZpvvP2/ePMrKyvyPvLy8zpTZZZpGR9SJVUREpOPCOnJyYmIiFoulxShIYWFhi9GSJvPnz2fChAnccccdAAwfPpyoqCjOPfdcHnzwQdLS0lq8xmazYbPZOlKaobIzYnl3Q4F21IiIiHRCh0ZGrFYro0ePZvny5c2OL1++nPHjx7f6murqaszm5pexWCyAb0SlJzjaFl7TNCIiIh3V4WmauXPn8tRTT7F48WK2bNnC7bffTm5urn/aZd68eUyfPt1//qWXXsobb7zBwoUL2b17NytXrmT27NmcffbZpKenB+47MdCwPjGYTXCwvJZD5bVGlyMiItKtdGiaBmDatGmUlJTwwAMPUFBQwLBhw1i2bBl9+/YFoKCgoFnPkRkzZlBRUcETTzzBL37xC2JjYznvvPP4wx/+ELjvwmCR1jBOT3Gw9WAF6/NKmTg01eiSREREug2TtxvMlZSXl+N0OikrKyMmJsboclr1q9c2sGR1HrO+/y3uuPAMo8sRERExXHt/f+veNAEyPLOxE6vu4CsiItIhCiMB0rS9d8P+UjyekB9sEhERCRkKIwEyKNWBLcxMeW0De0uqjC5HRESk21AYCZBwi5mh6b75MN2nRkREpP0URgLIf9M8rRsRERFpN4WRABqhO/iKiIh0mMJIAA1vXMS6Kb+cerfH2GJERES6CYWRAOqXEEmMPQxXg4dtByuMLkdERKRbUBgJIJPJ5F83ojv4ioiItI/CSIAd229ERERETk5hJMC0o0ZERKRjFEYCLDvD1xZ+R2EFVXUNBlcjIiIS+hRGAiw5xk6a047HC/89oNERERGRk1EYCYLhjaMj6jciIiJycgojQeBfN7JfIyMiIiInozASBCMad9Ss1/ZeERGRk1IYCYJhjdM0+4/UUFJZZ3A1IiIioU1hJAhi7OF8KykKgA2aqhERETkhhZEgUSdWERGR9lEYCRJ1YhUREWkfhZEgOXZHjdfrNbYYERGREKYwEiSD0xyEW0wcrnKx/0iN0eWIiIiELIWRILGFWRicFgOo+ZmIiMiJKIwEUbb6jYiIiJyUwkgQ+dvC6w6+IiIibVIYCaIRjYtYNx4oo8HtMbYYERGREKUwEkSnJUUTbQujpt7NzqJKo8sREREJSQojQWQxmxjWx7eIdYOmakRERFqlMBJk/k6s2lEjIiLSKoWRINOOGhERkRNTGAmyppGRbQcrqK13G1uMiIhICFIYCbJ0p53EaBsNHi+b8suNLkdERCTkKIwEmclkIrux34humiciItKSwkgX8N80T+tGREREWlAY6QL+Tqz7tb1XRETkeAojXaBpR82e4irKquuNLUZERCTEKIx0gbgoK30TIgHYcKDU2GJERERCjMJIFxmufiMiIiKtUhjpItlaNyIiItIqhZEuMkI7akRERFqlMNJFhqY7sZhNFFbUcbCs1uhyREREQobCSBeJsFo4PcUBQI5GR0RERPwURrrQ0XUjpcYWIiIiEkIURrpQUydWtYUXERE5SmGkCzU1P9uQV4bH4zW2GBERkRChMNKFTk+Jxh5upqKugd3FVUaXIyIiEhIURrpQmMXMsHTdwVdERORYCiNdTJ1YRUREmlMY6WLZmerEKiIiciyFkS7W1Il1c345rgaPscWIiIiEAIWRLpYVH0lsZDgut4etB8uNLkdERMRwCiNdzGQyHV03oqkaERERhREjjGjqxKpFrCIiIgojRmgaGdH2XhEREYURQwxv3FGzo7CSyroGg6sRERExlsKIAZIddtKddrxe2Kh1IyIi0sspjBhEN80TERHxURgxSFMYWa8wIiIivZzCiEGG+3fUaJpGRER6N4URg5zZx4nJBAdKayiqqDO6HBEREcMojBjEYQ/nW0nRgNaNiIhI76YwYqBsdWIVERFRGDHSiEx1YhUREVEYMdDRe9SU4vV6jS1GRETEIAojBjojzYHVYqa0up68wzVGlyMiImIIhRED2cIsDE6PASBHi1hFRKSXUhgxWHZjv5ENWjciIiK9lMKIwbKPWTciIiLSG3UqjCxYsID+/ftjt9sZPXo0n3/++QnPr6ur4+6776Zv377YbDa+9a1vsXjx4k4V3NNkN+6o2XigjAa3x+BqREREul5YR1+wZMkS5syZw4IFC5gwYQL/+Mc/mDRpEps3byYrK6vV10ydOpVDhw7x9NNPM2DAAAoLC2loaDjl4nuC0xKjibaFUVnXwI7CSganxRhdkoiISJcyeTu4p3Ts2LGMGjWKhQsX+o8NHjyYyZMnM3/+/Bbn/+tf/+KKK65g9+7dxMfHd6rI8vJynE4nZWVlxMT0vF/WVy76klW7Svi/y8/kirNbD3QiIiLdTXt/f3domsblcrFmzRomTpzY7PjEiRNZtWpVq695++23GTNmDH/84x/p06cPp59+Or/85S+pqWl7K2tdXR3l5eXNHj3ZcK0bERGRXqxD0zTFxcW43W5SUlKaHU9JSeHgwYOtvmb37t2sWLECu93Om2++SXFxMbfccguHDx9uc93I/Pnzuf/++ztSWrd2tBOr2sKLiEjv06kFrCaTqdnnXq+3xbEmHo8Hk8nEiy++yNlnn81FF13Eo48+yrPPPtvm6Mi8efMoKyvzP/Ly8jpTZreRnRkLwLZDFdS43MYWIyIi0sU6FEYSExOxWCwtRkEKCwtbjJY0SUtLo0+fPjidTv+xwYMH4/V62b9/f6uvsdlsxMTENHv0ZKkxdpIcNtweL5sLNDoiIiK9S4fCiNVqZfTo0SxfvrzZ8eXLlzN+/PhWXzNhwgTy8/OprKz0H9u+fTtms5mMjIxOlNzzmEwmf7+RHE3ViIhIL9PhaZq5c+fy1FNPsXjxYrZs2cLtt99Obm4uM2fOBHxTLNOnT/eff+WVV5KQkMB1113H5s2b+eyzz7jjjju4/vrriYiICNx30s01dWLVHXxFRKS36XCfkWnTplFSUsIDDzxAQUEBw4YNY9myZfTt2xeAgoICcnNz/edHR0ezfPlyfv7znzNmzBgSEhKYOnUqDz74YOC+ix6gad3IBu2oERGRXqbDfUaM0NP7jACUVrsY8YBv+ivnnh8QG2k1uCIREZFTE5Q+IxI8sZFW+iVEArBhv9aNiIhI76EwEkKapmq0bkRERHoThZEQok6sIiLSGymMhJCmTqw5eWV0g6U8IiIiAaEwEkKGpjuxmE0UV9ZRUFZrdDkiIiJdQmEkhNjDLQxKcQBaNyIiIr2HwkiI8S9i1Y4aERHpJRRGQszRO/iWGluIiIhIF1EYCTFNO2o2HijD49EiVhER6fkURkLMwORoIsItVNY1sLu48uQvEBER6eYURkJMmMXMsD6+lrm6g6+IiPQGCiMhKLtxqkY3zRMRkd5AYSQEqS28iIj0JgojIahpZGRzQTl1DW5jixEREQkyhZEQlBkfQVxkOPVuL1sLKowuR0REJKgURkKQyWTSTfNERKTXUBgJUUfXjWhHjYiI9GwKIyHK34lVIyMiItLDKYyEqKZpml1FlVTU1htbjIiISBApjISoxGgbfWIj8Hp9reFFRER6KoWREDZC60ZERKQXUBgJYcMzfOtG1IlVRER6MoWREKZOrCIi0hsojISwYX2cmEyQX1ZLYUWt0eWIiIgEhcJICIu2hTEwORqADVo3IiIiPZTCSIjLVidWERHp4RRGQtzwxnUjOVo3IiIiPZTCSIgb0TgysmF/GV6v19hiREREgkBhJMQNSnVgtZgpq6lnX0m10eWIiIgEnMJIiLOGmRmSHgNo3YiIiPRMCiPdgDqxiohIT6Yw4gr9qY+mTqwaGRERkZ6od4eRnJfgsTOhcKvRlZxQUyfWTfll1Ls9xhYjIiISYL03jHg8sOFlqC6GV6ZDXaXRFbWpf0IUDnsYtfUeth+qMLocERGRgOq9YcRshsufAkcaFG+Dd2+HEN06azabjrlpntaNiIhIz9J7wwhAdBL85BkwWWDjK7DmGaMrapO/E6uan4mISA/Tu8MIQN9xcMG9vufv/wrycwwtpy3DG8OIOrGKiEhPozACMH42DLoI3C7f+pGaUqMraqFpe++OwkqqXQ3GFiMiIhJACiMAJhNMXgCxWVC6D5bOCrn1I6lOOykxNtweL5vyy40uR0REJGAURppExMHU58Fiha3vwhdPGF1RC8O1bkRERHoghZFjpY+EH873PV9+L+R+aWw9x/F3YtWOGhER6UEURo435gYY9hPwuuHV66Cq2OiK/PydWDUyIiIiPYjCyPFMJrj0L5B4OlTkw+s3gsdtdFUADO8TC0Du4WqOVLmMLUZERCRAFEZaY4v2rR8Jj4Td/4HPHja6IgCckeGclhgF6D41IiLScyiMtCV5MFzyZ9/zT/4Pdn1sbD2Njk7VaN2IiIj0DAojJ5J9BYy6FvDC6zdBeb7RFflvmrdBIyMiItJDKIyczKQ/QuqZvhvqvXoduOsNLSfbv6OmFG+I9UIRERHpDIWRkwm3+9aP2GIg70v46H5DyxmSFkOY2URxpYsDpTWG1iIiIhIICiPtEX8aXPY33/NVj8PW9wwrxR5u4Yw0B6A7+IqISM+gMNJeQ34E357le/7mzXB4j2GlqBOriIj0JAojHfGD+yHjbKgrg1evhfpaQ8oY0RRGtIhVRER6AIWRjrCEw0+fgYh4KFgPH8wzpIymRawb95fh9mgRq4iIdG8KIx3lzIDLFwEmWL0YNrza5SUMSI4m0mqhyuVmV1Fll19fREQkkBRGOmPgBfCdX/qev3MbFG3r0stbzCaG9dF9akREpGdQGOms782D/t+B+ip4ZTq4qrr08iOO6TciIiLSnSmMdJbZAlOehuhUKNoK786FLmxC1tQWXtt7RUSku1MYORXRyfCTxWCywIaXYe1zXXbp7MYdNVsKyqmtD427CouIiHSGwsip6jcBzv+t7/myO327bLpARlwE8VFW6t1ethSUd8k1RUREgkFhJBDG3wan/xDcdfDKtVAb/KkTk8lEtqZqRESkB1AYCQSzGSYvBGcWHNkDb93SJetH/DfN044aERHpxhRGAiUyHqY+CxYrbH0XvlwQ9Es2rRvJ0Y4aERHpxhRGAqnPaLjwId/z5fdA7ldBvVzTjprdRVWU19YH9VoiIiLBojASaGfdCMOmgKcBXrsOqkqCdqmEaBsZcRGArzW8iIhId6QwEmgmE1z6F0gYCOUH4I2bwOMJ2uWy1fxMRES6OYWRYLA5YOrzEBYBuz6Czx8J2qX8d/DVIlYREemmFEaCJWUIXPKo7/l/HoLdnwTlMk3rRtbnaZpGRES6J4WRYBpxJYy8BvDC6zdCeUHALzGsjxOzCQ6W13KovDbg7y8iIhJsCiPBdtHDkHImVBXBa9eDuyGgbx9lC+P0FAegqRoREemeFEaCLTwCpj4HVgfkroKPHwj4JZr6jTy6fDv7Srr27sEiIiKnqlNhZMGCBfTv3x+73c7o0aP5/PPP2/W6lStXEhYWxogRIzpz2e4r4Vsw+W++5yv/AluXBfTtbzy3P4nRVrYerODSx1fw8dZDAX1/ERGRYOpwGFmyZAlz5szh7rvvZt26dZx77rlMmjSJ3NzcE76urKyM6dOnc/7553e62G5tyGUw9mbf87dmwpG9AXvrgSkO3v35uYzMiqW8toHrn13Nn5dvx+MJfkt6ERGRU2Xyejt2E5WxY8cyatQoFi5c6D82ePBgJk+ezPz589t83RVXXMHAgQOxWCy89dZb5OTktPua5eXlOJ1OysrKiImJ6Ui5oaXBBc9eBPu/gfSRcP0HEGYL2Nu7Gjz87t3N/L8v9wHw/UFJPDZtJM7I8IBdQ0REpL3a+/u7QyMjLpeLNWvWMHHixGbHJ06cyKpVq9p83TPPPMOuXbu4995723Wduro6ysvLmz16hDAr/OQZiIiD/HXwwa8D+vbWMDO/mzyMP/00G1uYmf9sK+LSJ1awOb+H/PmJiEiP1KEwUlxcjNvtJiUlpdnxlJQUDh482OprduzYwV133cWLL75IWFhYu64zf/58nE6n/5GZmdmRMkNbbCZcvsj3/JunYONrAb/ElNEZvH7zeDLiIsg9XM3lC1fy1roDAb+OiIhIIHRqAavJZGr2udfrbXEMwO12c+WVV3L//fdz+umnt/v9582bR1lZmf+Rl5fXmTJD18AfwLm/9D1/ezYUbQ/4JYb1cfLuz8/hu6cnUVvvYc6SHO57exOuhuC1phcREemMDoWRxMRELBZLi1GQwsLCFqMlABUVFaxevZpbb72VsLAwwsLCeOCBB1i/fj1hYWF8/PHHrV7HZrMRExPT7NHjfP/X0O9cqK+CV6aDK/BbcmMjrSyecRazzxsAwLOr9nLloi8pVHM0EREJIR0KI1arldGjR7N8+fJmx5cvX8748eNbnB8TE8PGjRvJycnxP2bOnMmgQYPIyclh7Nixp1Z9d2a2wJSnIToFirbAe7+Ajq0lbheL2cTciYN4avoYHPYwVu87wsWPr+CbvYcDfi0REZHO6PA0zdy5c3nqqadYvHgxW7Zs4fbbbyc3N5eZM2cCvimW6dOn+97cbGbYsGHNHsnJydjtdoYNG0ZUVFRgv5vuxpECP1kMJjOsfwnWPh+0S10wJIW3bz2HQSkOiirq+J8nv+SZlXvo4GYqERGRgOtwGJk2bRqPPfYYDzzwACNGjOCzzz5j2bJl9O3bF4CCgoKT9hyRY/Q7B877re/5sjugYEPQLtU/MYo3Z43nR9npNHi83P/OZuYsyaHaFdgW9SIiIh3R4T4jRugxfUba4vHAy/8D2/8Fcf3hZ5+C3Rm0y3m9Xp5ZuZffL9uC2+PljFQHf796NP0Se/lIlYiIBFRQ+oxIkJjNMHkhOLPgyB5YOiso60eamEwmrj+nP/+8cSyJ0TZfG/knVvDRFrWRFxGRrqcwEioi4+Gnz4I5HLa8A18uPOlLTtXY0xJ4b/Y5jMqKpaK2gRueUxt5ERHpegojoSRjNFz4kO/58t9C3tdBv2RKjJ2X/3cc08f51vz85aMd3PDcN5RV1wf92iIiIqAwEnrOvgmG/hg8DfDqDKgqCfolrWFmHrhsGI9OVRt5ERHpegojocZkgh89DgkDoPwAvHGTb4FrF7h8VAZv3DKezPijbeTfXLe/S64tIiK9l8JIKLI5YOrzEBYBuz6Cz//UZZcemu7knVuPtpG/fcl67l36X7WRFxGRoFEYCVUpQ+HixhDyyUOw+9Muu/TxbeSf+2If/7PoSw6pjbyIiASBwkgoG3kVjLwavB54/QYoL+iySx/fRn7NviNc8vgKvt6jNvIiIhJYCiOh7qJHIGUYVBX5Aom7a7ulXjAkhXeOaSN/5aIvWbxCbeRFRCRwFEZCXXiEb/2I1QH7VsLHv+vyEvod10b+gXfVRl5ERAJHYaQ7SPgWXPaE7/nKx2Dbv7q8hEhrGH+5YgT3XDKEMLOJpTn5XL5gFXuLq7q8FhER6VkURrqLoZNhrO/OyLz5Mziyr8tL8LeRv+nbaiMvIiIBozDSnfzgd9BnDNSWwqvXQkOdIWWc3T+e92afw+i+cf428o+qjbyIiHSSwkh3Emb13b8mIg7y18EHdxtWSkqMnZdu+jbXNraR/+tHO7j+uW8orXYZVpOIiHRPCiPdTWwmXL7I9/ybRfDf1w0rxRpm5v7LhvHnadnYw8180thGflN+mWE1iYhI96Mw0h0N/AGc+wvf87dnQ/EOQ8v58cgM3rh5AlnxkeQdruHyBat4Y63ayIuISPsojHRX3/s19DsXXJXwynRwVRtazpD0GN659Ry+PyiJugYPc19Zzz1qIy8iIu2gMNJdWcJgytMQnQKFm+G9X4DBjcickeE8fe1Z3Hb+QACeVxt5ERFpB4WR7syR4gskJjOs/ye8dh0cWGtoSWazidt/cDqLZ4whprGN/MV/XcFXu0sMrUtEREKXwkh31/9c+MEDvueb3oRF34fFP4Qt74DHbVhZ552Rwjs/P4czUh0UV9Zx5VNf8bTayIuISCtM3m7w26G8vByn00lZWRkxMTFGlxOaCtbDFwvgv6+Bp7FNe1w/GHuz74Z7NochZVW7Gpj3xkaW5uQD8KPsdP5vyplEWsMMqUdERLpOe39/K4z0NOX58PUiWL3Y1xwNwOaE0dPh7J/5tgZ3Ma/Xy7Or9vL797bQ4PFyRqqDv189mn6JUV1ei4iIdB2Fkd7OVQXrX4IvF0LJTt8xkwWGXAbjboWM0V1e0jd7D3PLi2spqqjDYQ/jsWkjOH9wSpfXISIiXUNhRHw8HtjxIXzxBOz9/OjxzG/DuFvgjEvAbOmycgrLa7nlxbWs3ncEgNnnDeC2C07HYjZ1WQ0iItI1FEakpYIN8OUC2PgaeOp9x2L7+m7AN/JqsHfNn62rwcNDy7bw7Kq9AHz39CT+csUIYiOtXXJ9ERHpGgoj0raKg43rSp6GGt8IBbYYGDUdxv4MYrO6pIw31+1n3hsbqa33kBkfwd+vHs3QdGeXXFtERIJPYUROzlUNG1727cIpaWwpb7LAkB/Bt2dB5llBL2FzfjkzX1hD7uFqbGFmHvrxmUwZnRH064qISPApjEj7eTywczl88TfY8+nR4xlnN64rudTX8TVIyqrrmbNkHf/ZVgTA2f3jmTyiDxedmaqpGxGRbkxhRDrn4EbfDpwNrxxdV+LMgm/PhJHXBG1dicfj5a8f7+CvH+3A0/gTGW4x8d3Tk7hsRB8uGJxChLXrFtqKiMipUxiRU1NxEL55Cr55GmoO+45ZHUfXlcT1Dcpl80treGd9Pm/l5LOloNx/PMpq4cKhqfxoRDrnDEgkzKLmwSIioU5hRAKjvgbWv+zbhVO83XfMZIbBl/r6lWSeHbRLbz9Uwds5+Sxdf4C8wzX+4wlRVi4ZnsaPRvRhVFYsJpO2BYuIhCKFEQksjwd2feRbV7L7P0ePZ5wF374FBv8oaOtKvF4va3NLeTvnAO9uKKCkyuX/WmZ8BJdl9+GyEekMTDGm5b2IiLROYUSC59Am3w6cja+AuzEYODN90zejpoM9eNtz690eVu4s5u2cfD7YdJAq19GbAQ5Oi2HyiHQuzU4nPTYiaDWIiEj7KIxI8FUWNq4reQqqS3zHrNG+ha7fnum7UV8Q1bjc/HvLIZbm5PPp9kLq3b4fZZMJzu4Xz2XakSMiYiiFEek69TW+3Tdf/A2Kt/mOmcy+VvPjZkHmWF9CCKIjVS7e/+9BluYc4Ks9h/3HtSNHRMQ4CiPS9bxe2PkRfPk32PXx0eN9RvvWlQy5DCzhQS9DO3JEREKDwogY69Bm3w6cDa+Au853LCYDxv4vjLoWImK7pAztyBERMY7CiISGyiLfPXC+XgTVxb5j4VEw6hrfgtf407qkDO3IERHpegojElrqa327b75YAEVbGg+a4IyLfetKssYFfV2JvxTtyBER6RIKIxKavF7fepIvF8DOfx89nj7S10Sti9aVNNGOHBGR4FEYkdBXuMUXStYvOWZdSR/faEnf8dB3AkQnd1k52pEjIhJYCiPSfVQWwerF8M0iqCpq/rWEgb5g0u8c30dnRpeUpB05IiKnTmFEup/6WtjxAexdAftWwaH/tjwnNgv6NgaTvuN9C2CDvNZEO3JERDpHYUS6v+rDkPsl7FvpexSsB6+n+TmOtKNTOn0nQNKgoIUT7cgREekYhRHpeeoqIO8r2LvSN3JyYA146pufE5nQPJykDAVz4Nd4tGdHzvcGJTMwORqzWSMmItI7KYxIz1dfA/u/8QWTfSsh7xtoqGl+js0JWd+Gfo3hJC074Lt1ju7IOcAn24po8Bz9T8phC2NEViwjs+IY1fjRGdF1u4VERIykMCK9T4ML8tcdndbJ/QpcFc3PCY+CzLN9waTfBEgfBeH2gJXQtCNn2cYC1uYeofqYEZMmA5KjGZUVy6isOEb3jeNbSRo9EZGeSWFExN0ABzc0jpw0jp7UljY/x2KDjDGN0zrjfUHFGhWQyze4PWw7VMHa3FLW7TvC2twj7C2pbnFejD2MEY0jJ6Oy4hiRFUuMXaMnItL9KYyIHM/j8XV/3bfq6I6dqsLm55jDfA3Y+o737drJGgt2Z8BKKK6sY11uKWtzj7B23xE27C+jpr756InJBAOToxmVFed79I3jtMQojZ6ISLejMCJyMl4vlOyCfY3BZO9KKN/f/ByTGVKGHe1zkjUeohICVkKD28PWgxX+cLI2t5Tcwy1HT5wR4YxsHDkZlRVHdqYTh0ZPRCTEKYyIdJTXC6W5jVM6jQHl8O6W5yUNbmzE1rgo1pEa0DKKKup84ST3COv2lbJ+fyl1Dc23NJtMMCjF4V8YO7pvHP0To9TrRERCisKISCCUFzQuiG1cc1K0teU58acd3Urcb4KvMVsA1bs9bCko94+crM09wv4jNS3Oi4sM94cT3+hJLFG2sIDWIiLSEQojIsFQVQy5XzT2OlkJBzcCx/0n5Mz0jZykjfA1YUs6A2LSA9qMrbC8tnH0pNS39uRAGa7jRk/MJhiUGuMfORmVFUffhEiNnohIl1EYEekKNaW+RmxNoyf568DT0PI8q+NoMDn2ozMTzKd+fxtXg4fN/tGTI6zLLeVAacvRk/goq7/fSdPak0irRk9EJDgURkSMUFfpa8SW+yUUboaibXB4V+sBBSA8EhJPbxlS4vqdcufYg2W1xyyMPcJ/D5TjcjcfPbGYTZyR6vD3PBmVFUdmfIRGT0QkIBRGREJFg8u3ELZoqy+cFG31PYp3tGxn38RiawwpjQEl+Qzfx7j+YOncSEZdg5tN+b7Rk6btxQVltS3OS4y2+kdORmXFMrSPk2itPRGRTlAYEQl17gY4sudoOGkKKsU7oKFlSADAHA6JA1tO+cR/C8KsHS4hv7SmcfTEF0425ZdR7275v4Q0p50BydEMTHb4PqZEMzA5mtjIjl9TRHoPhRGR7srjhtJ9x4yiNH3cDvVVrb/GZIGEbx0TUhqDSsLADrW7r613sym/zB9O1uWWcrC8jWAEJEbbGJAcxcBkBwNTohmQ7HskRds01SMiCiMiPY7H42vKduxUT9E236OuvPXXmMy+9SfHr0lJPL3dbe/LquvZWVTBjkOV7CisZGfjo7UFsk2cEeEMTD4aTgam+EZU0p12hRSRXkRhRKS38HqhosAXTgqPm/I5/l48x4rN8jVwazaacjrYHO26bFVdA7uKKo8JKRXsLKxk3+Fq2vq/SpTV0hhQGqd7Gqd8MuIisajdvUiPozAi0tt5vVBZeNxUT+PH6uK2XxeT0XwUJb6/bwtyTJ92rUuprXezu6iKnUWV7DxUwY5CX1jZW1xFg6f1/93YwsycltQYTvyjKdH0TYgi3HLqW59FxBgKIyLStqriVtakbIPKgyd4kQkcaRCb6Qsn/o9ZRz8/wdRPvdvDvpIqdhzyTfM0hZRdRZUtGrY1CTOb6JcYdTSkpDgYkBTNaUlR2MNPbeuziASfwoiIdFzNEd9C2WNDSuk+KM0Dd93JXx8RfzSkNAssmeDMgsj4Fp1o3R4v+49UH7cmxTeiUu1yt3oZswmy4iP9Uz5N0z3fSopWC3yREKIwIiKB4/VCVZEvlJTlNn7Ma/6xruzk7xMeBc6MliGl6XNHqr/Zm9frJb+s1jeKcqjCv3B2+6EKymvbaCIH9ImNOLpwtjGkDEhy4IzUXY5FuprCiIh0rdqy40LKcaGlqvDk72EO861Nic3yhZYW00EZeC1Wiirr2Hmokp3+BbS+sFJc6WrzreOjrGTGR5IZF0FWfCSZ8ZG+j3GRpMXatTZFJAgURkQktNTXQtn+Y0LK/ubBpewAeFuflmkmOqXNNStHwlPZWW46Zl2KL6S01mn2WBaziTSn3R9OshIimwWX+CirtiSLdILCiIh0Lx63b4uyfzQlt+VUUEPbvU387M5jpn58oys1UekUeOPJcznYVR3FnjIPeUeqyT1czf4jNW0uoG0SabWQFR9JRlzjaEr80dGVzLhIIqxaTCvSGoUREelZvF6oLmk9pJTl+kZaao60771sMRCdDNEpeKOSqbYmcMQcx0G3k/310eyqiWJbZSSbSq3kV9a32TelSWK0jaz4iGZTP5mNoSXNGaEeKtJrKYyISO9TV+ELJa2tWak4CJWH2rcryM+ENyoRlz2RqnBfYCn0OtnvcrCnNpqtVRHsq3NQ5HVSThTQMnSEW0ykx0a0PrISF0lsZLimgKTHCmoYWbBgAQ8//DAFBQUMHTqUxx57jHPPPbfVc9944w0WLlxITk4OdXV1DB06lPvuu48LL7ww4N+MiMgJeb2+hbaVhb5gUnnomOfHfawuBu+Jp2+O5TaHUx2eQKkljkJPLPkNMeyti+KQx0mRN5Yir5NCYinyxlLH0eZxDlsYGfGRvpGVpvUqjSMrGXER6qci3VrQwsiSJUu45pprWLBgARMmTOAf//gHTz31FJs3byYrK6vF+XPmzCE9PZ3vf//7xMbG8swzz/DII4/w1VdfMXLkyIB+MyIiAeNx+6aFThZaKg/5Ak4HVJkiKfbGctAT4w8qRd5YimgKLrEUep0cJobEmMZFtfGRZMRHkhEbQarTTqrTTkqMnRh7mEZWJGQFLYyMHTuWUaNGsXDhQv+xwYMHM3nyZObPn9+u9xg6dCjTpk3jnnvuadf5CiMiEtLqa31bl0844nIIKjo2TeTxmijBQXFTYMH3sbjpgZMKSxwWRwp2ZxIpsVG+oBLjCyqpTjtpTjuJ0TatWxFDtPf3d4daFbpcLtasWcNdd93V7PjEiRNZtWpVu97D4/FQUVFBfHx8m+fU1dVRV3f0P9jy8jbuSCoiEgrC7b4txrEtR4eb8Xp9d1g+WWipLMRbVYQZD0mUk2QqZ/CJ3rca3FUmDufHUOx1+gILTr72Oin2xnDYFEu9PRGTIxlrTCrR8SkkOaNJddpIjYnwBxjtChKjdCiMFBcX43a7SUlJaXY8JSWFgwdPdE+Lo/70pz9RVVXF1KlT2zxn/vz53H///R0pTUQk9JlMvq3HdickDjzxqa1NE1Uc9HXCrSyEqkI8FYV4Kwsx1x7BYvKSRBlJprLWg0sDcMT38Ow1cYRo/wjLBpx87HVSERaHOyIJb3QS4TEpRMSmEpPYh+S4aN9IS4xdPVckKDp1E4fjfxC9Xm+7fjhfeukl7rvvPpYuXUpycnKb582bN4+5c+f6Py8vLyczM7MzpYqIdE9mS+P242TgzNZPaXribvAtuG0MKVQW+aeNPJWF1JcfwlNRiLmqiPC6w5hNHhKoIMFUwSD2N3/TmsZH0dFDpd4oir1OduDkME6qrQnU2xPwRCUTHpOMzZlGdGIasYkZpCQ4SXbYsYapo620X4fCSGJiIhaLpcUoSGFhYYvRkuMtWbKEG264gVdffZULLrjghOfabDZsNltHShMR6b0sYb77+jhSW3zJDDT7v6nHDdWHj65xqSrCW3kIV9khaksP4i4/hKmqiPDaYiJch7HgJtZURaypigHk+96jAahsfBxqfr1ybwT7vU7KzLFUhcfjsifiiUzC7EjGGptKdHwazqQ+xCf3IcbhxGRWaJEOhhGr1cro0aNZvnw5P/7xj/3Hly9fzmWXXdbm61566SWuv/56XnrpJS6++OLOVysiIqfGbIHoJN8jZSjg645i47jQAuDxQG2pf8SlvvwglSUF1B45SH35QagsIqymGLurBEfDYcJpIMZUQ4ypBjgI9fgeFbQILQAur4VKUzRVFge1YU7qrU48NiemiDgs0fFYo+OJjEkkOi6JKGcSpog4iIjzTXNZdHfmnqTDf5tz587lmmuuYcyYMYwbN44nn3yS3NxcZs6cCfimWA4cOMDzzz8P+ILI9OnT+ctf/sK3v/1t/6hKREQETqczgN+KiIgElNkMkfG+B2cQDsS1dW5jDxdPRSEVJfmUFR+g5kgBrrJDeCsLsVQXYasrIbr+ME5vKRG4sJrcxFNGvLsM3PuhDl9waYcacxR14TE0WGPx2p2YIuIJi47H6kjA7kjAHNkUXGJ9H5se4RG+tTsSUjocRqZNm0ZJSQkPPPAABQUFDBs2jGXLltG3b18ACgoKyM3N9Z//j3/8g4aGBmbNmsWsWbP8x6+99lqeffbZU/8ORETEeCYTRMRijojFmXw6J/ynptdLbXUFh4sLKTtSSFVpCTXlxbgqinFXHcZbU4q5rpRwVxm2hnKiPRXEUoXTVNk46gIRnioi6qqgrqDdAQZ8zenc1li8EXGYI2IJi47HFBHfGFZij4YWf4iJPToaY9Zuo2BRO3gREQlpdQ1uSipdFFfWUVJeRdmREipLi6itKKG+4jANVSWYan0Bxl5fjtNUiRPfOpdYKv2fW03tuCv0CfhGYI4bbbE7webw3e/IFu17bm382PQ49vNeFmiC0mdERESkq9nCLKTHRpAeGwHEAn3aPLfe7fEHl6LKOvZU1FFc6aK4opbyilLqykuorzyCp/ow5rpSnDQFl0rfc1MVsU2fm6pwUoWjcTTGVFvW4W67LYRHHhNOohtDjOO4Yw6wOk7yeXSPCjYKIyIi0mOEW8z+dvkn0+D2cLjaRXGFL7wUV9ZxoLKO9ZUuiit8Yaaooo4jFdV4qg8T0xhcnP4RF19YiTLVEk010aZaoqkhylSLgxqiTdU4THVEUY2VBt9F66t9j6rCAHyzUS0DSntHaI49Zo32rQ8ykMKIiIj0SmEWM8kOO8mOkwcXt8fLkerG0HJMeCmudHGwykVJlYsj1S4OV/keZTX1zV5vpZ6oY4JKFDVEm2qIprbxo+/zWHMd8eF1xFnqiDHX4jDVEkUNEd5qbO4qwhuqMHubgk2V71EZgD8MazT86K8wbEoA3qzjFEZEREROwmI2kRhtIzHaBi3bubRQ7/ZQWl3vDyeHq1wcrnZxuNIXWkqqXBypcrGr8ePhKheuhsa7RLtO9M5ebNQT1RhiHKYa0uwNpNjqSba5SAivJz6sljhzHQ5zLQ5TDZHUYPdUY3NXE9ZQidlV5bstQV0FeBvX0bgqwRx+qn9MnaYwIiIiEmDhFjNJDhtJjvY18PR6vVS53ByubAwtVXUcrqpv46MvvOTWNoAXNlUD1e2vLdJqIS7SSkJ8OMkRkB5RT7Ktnu/bhzK0c9/uKVMYERERMZjJZCLaFka0LYyshMh2vabe7Wk2NXS4cZSl5NiP1S5KKo9OIdW7vVS73FS7ajhQWtPs/bIGmhVGREREpP3CO7DmBXyjL5V1Dc2njo6ZQjoj1RHkitumMCIiItILmEwmHPZwHPZw+iZEGV1OM7pDkYiIiBhKYUREREQMpTAiIiIihlIYEREREUMpjIiIiIihFEZERETEUAojIiIiYiiFERERETGUwoiIiIgYSmFEREREDKUwIiIiIoZSGBERERFDKYyIiIiIobrFXXu9Xi8A5eXlBlciIiIi7dX0e7vp93hbukUYqaioACAzM9PgSkRERKSjKioqcDqdbX7d5D1ZXAkBHo+H/Px8HA4HJpMpYO9bXl5OZmYmeXl5xMTEBOx9pfP0dxJa9PcRWvT3EVr093FyXq+XiooK0tPTMZvbXhnSLUZGzGYzGRkZQXv/mJgY/SCFGP2dhBb9fYQW/X2EFv19nNiJRkSaaAGriIiIGEphRERERAzVq8OIzWbj3nvvxWazGV2KNNLfSWjR30do0d9HaNHfR+B0iwWsIiIi0nP16pERERERMZ7CiIiIiBhKYUREREQMpTAiIiIihurVYWTBggX0798fu93O6NGj+fzzz40uqVeaP38+Z511Fg6Hg+TkZCZPnsy2bduMLksazZ8/H5PJxJw5c4wupVc7cOAAV199NQkJCURGRjJixAjWrFljdFm9UkNDA7/5zW/o378/ERERnHbaaTzwwAN4PB6jS+u2em0YWbJkCXPmzOHuu+9m3bp1nHvuuUyaNInc3FyjS+t1Pv30U2bNmsWXX37J8uXLaWhoYOLEiVRVVRldWq/3zTff8OSTTzJ8+HCjS+nVjhw5woQJEwgPD+f9999n8+bN/OlPfyI2Ntbo0nqlP/zhD/z973/niSeeYMuWLfzxj3/k4Ycf5vHHHze6tG6r127tHTt2LKNGjWLhwoX+Y4MHD2by5MnMnz/fwMqkqKiI5ORkPv30U77zne8YXU6vVVlZyahRo1iwYAEPPvggI0aM4LHHHjO6rF7prrvuYuXKlRq9DRGXXHIJKSkpPP300/5jU6ZMITIykv/3//6fgZV1X71yZMTlcrFmzRomTpzY7PjEiRNZtWqVQVVJk7KyMgDi4+MNrqR3mzVrFhdffDEXXHCB0aX0em+//TZjxozhpz/9KcnJyYwcOZJFixYZXVavdc455/DRRx+xfft2ANavX8+KFSu46KKLDK6s++oWN8oLtOLiYtxuNykpKc2Op6SkcPDgQYOqEvDd4XHu3Lmcc845DBs2zOhyeq2XX36ZtWvX8s033xhdigC7d+9m4cKFzJ07l1//+td8/fXXzJ49G5vNxvTp040ur9f51a9+RVlZGWeccQYWiwW3283vf/97/ud//sfo0rqtXhlGmphMpmafe73eFseka916661s2LCBFStWGF1Kr5WXl8dtt93Ghx9+iN1uN7ocATweD2PGjOGhhx4CYOTIkWzatImFCxcqjBhgyZIlvPDCC/zzn/9k6NCh5OTkMGfOHNLT07n22muNLq9b6pVhJDExEYvF0mIUpLCwsMVoiXSdn//857z99tt89tlnZGRkGF1Or7VmzRoKCwsZPXq0/5jb7eazzz7jiSeeoK6uDovFYmCFvU9aWhpDhgxpdmzw4MG8/vrrBlXUu91xxx3cddddXHHFFQCceeaZ7Nu3j/nz5yuMdFKvXDNitVoZPXo0y5cvb3Z8+fLljB8/3qCqei+v18utt97KG2+8wccff0z//v2NLqlXO//889m4cSM5OTn+x5gxY7jqqqvIyclREDHAhAkTWmx33759O3379jWoot6turoas7n5r0+LxaKtvaegV46MAMydO5drrrmGMWPGMG7cOJ588klyc3OZOXOm0aX1OrNmzeKf//wnS5cuxeFw+EesnE4nERERBlfX+zgcjhbrdaKiokhISNA6HoPcfvvtjB8/noceeoipU6fy9ddf8+STT/Lkk08aXVqvdOmll/L73/+erKwshg4dyrp163j00Ue5/vrrjS6t+/L2Yn/729+8ffv29VqtVu+oUaO8n376qdEl9UpAq49nnnnG6NKk0Xe/+13vbbfdZnQZvdo777zjHTZsmNdms3nPOOMM75NPPml0Sb1WeXm597bbbvNmZWV57Xa797TTTvPefffd3rq6OqNL67Z6bZ8RERERCQ29cs2IiIiIhA6FERERETGUwoiIiIgYSmFEREREDKUwIiIiIoZSGBERERFDKYyIiIiIoRRGRERExFAKIyIiImIohRERERExlMKIiIiIGEphRERERAz1/wFOLNTUgojABwAAAABJRU5ErkJggg==",
"text/plain": [
"