{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Going Deeper\n",
"> By the end of this chapter, you will know how to solve binary, multi-class, and multi-label problems with neural networks. All of this by solving problems like detecting fake dollar bills, deciding who threw which dart at a board, and building an intelligent system to water your farm. You will also be able to plot model training metrics and to stop training and save your models when they no longer improve. This is the Summary of lecture \"Introduction to Deep Learning with Keras\", via datacamp.\n",
"\n",
"- toc: true \n",
"- badges: true\n",
"- comments: true\n",
"- author: Chanseok Kang\n",
"- categories: [Python, Datacamp, Tensorflow-Keras, Deep_Learning]\n",
"- image: images/competitor.png"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import tensorflow as tf\n",
"import numpy as np\n",
"import pandas as pd\n",
"import matplotlib.pyplot as plt\n",
"import seaborn as sns\n",
"\n",
"plt.rcParams['figure.figsize'] = (8, 8)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Binary Classification"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Exploring dollar bills\n",
"You will practice building classification models in Keras with the Banknote Authentication dataset.\n",
"\n",
"Your goal is to distinguish between real and fake dollar bills. In order to do this, the dataset comes with 4 features: `variance`,`skewness`,`curtosis` and `entropy`. These features are calculated by applying mathematical operations over the dollar bill images. The labels are found in the dataframe's `class` column.\n",
""
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" variace \n",
" skewness \n",
" curtosis \n",
" entropy \n",
" class \n",
" \n",
" \n",
" \n",
" \n",
" 0 \n",
" 3.62160 \n",
" 8.6661 \n",
" -2.8073 \n",
" -0.44699 \n",
" 0 \n",
" \n",
" \n",
" 1 \n",
" 4.54590 \n",
" 8.1674 \n",
" -2.4586 \n",
" -1.46210 \n",
" 0 \n",
" \n",
" \n",
" 2 \n",
" 3.86600 \n",
" -2.6383 \n",
" 1.9242 \n",
" 0.10645 \n",
" 0 \n",
" \n",
" \n",
" 3 \n",
" 3.45660 \n",
" 9.5228 \n",
" -4.0112 \n",
" -3.59440 \n",
" 0 \n",
" \n",
" \n",
" 4 \n",
" 0.32924 \n",
" -4.4552 \n",
" 4.5718 \n",
" -0.98880 \n",
" 0 \n",
" \n",
" \n",
"
\n",
"
"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"# Use pairplot and set the hue to be our class column\n",
"sns.pairplot(banknotes, hue='class');"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Dataset stats: \n",
" variace skewness curtosis entropy class\n",
"count 1372.000000 1372.000000 1372.000000 1372.000000 1372.000000\n",
"mean 0.433735 1.922353 1.397627 -1.191657 0.444606\n",
"std 2.842763 5.869047 4.310030 2.101013 0.497103\n",
"min -7.042100 -13.773100 -5.286100 -8.548200 0.000000\n",
"25% -1.773000 -1.708200 -1.574975 -2.413450 0.000000\n",
"50% 0.496180 2.319650 0.616630 -0.586650 0.000000\n",
"75% 2.821475 6.814625 3.179250 0.394810 1.000000\n",
"max 6.824800 12.951600 17.927400 2.449500 1.000000\n",
"Observations per class: \n",
" 0 762\n",
"1 610\n",
"Name: class, dtype: int64\n"
]
}
],
"source": [
"# Describe the data\n",
"print('Dataset stats: \\n', banknotes.describe())\n",
"\n",
"# Count the number of observations per class\n",
"print('Observations per class: \\n', banknotes['class'].value_counts())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Your pairplot shows that there are features for which the classes spread out noticeably. This gives us an intuition about our classes being easily separable. Let's build a model to find out what it can do!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### A binary classification model\n",
"Now that you know what the Banknote Authentication dataset looks like, we'll build a simple model to distinguish between real and fake bills.\n",
"\n",
"You will perform binary classification by using a single neuron as an output. The input layer will have 4 neurons since we have 4 features in our dataset. The model's output will be a value constrained between 0 and 1.\n",
"\n",
"We will interpret this output number as the probability of our input variables coming from a fake dollar bill, with 1 meaning we are certain it's a fake bill.\n",
""
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Model: \"sequential\"\n",
"_________________________________________________________________\n",
"Layer (type) Output Shape Param # \n",
"=================================================================\n",
"dense (Dense) (None, 1) 5 \n",
"=================================================================\n",
"Total params: 5\n",
"Trainable params: 5\n",
"Non-trainable params: 0\n",
"_________________________________________________________________\n"
]
}
],
"source": [
"from tensorflow.keras import Sequential\n",
"from tensorflow.keras.layers import Dense\n",
"\n",
"# Create a sequential model\n",
"model = Sequential()\n",
"\n",
"# Add a dense layer\n",
"model.add(Dense(1, input_shape=(4, ), activation='sigmoid'))\n",
"\n",
"# Compile your model\n",
"model.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy'])\n",
"\n",
"# Display a summary of your model\n",
"model.summary()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Is this dollar bill fake ?\n",
"You are now ready to train your model and check how well it performs when classifying new bills!"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"from sklearn.model_selection import train_test_split\n",
"\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, stratify=y)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch 1/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.8882 - accuracy: 0.4665\n",
"Epoch 2/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.8308 - accuracy: 0.4791\n",
"Epoch 3/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.7804 - accuracy: 0.5005\n",
"Epoch 4/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.7370 - accuracy: 0.5238\n",
"Epoch 5/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.6974 - accuracy: 0.5559\n",
"Epoch 6/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.6639 - accuracy: 0.5802\n",
"Epoch 7/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.6326 - accuracy: 0.6006\n",
"Epoch 8/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.6052 - accuracy: 0.6210\n",
"Epoch 9/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.5807 - accuracy: 0.6414\n",
"Epoch 10/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.5585 - accuracy: 0.6774\n",
"Epoch 11/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.5388 - accuracy: 0.6968\n",
"Epoch 12/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.5203 - accuracy: 0.7162\n",
"Epoch 13/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.5037 - accuracy: 0.7279\n",
"Epoch 14/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.4884 - accuracy: 0.7464\n",
"Epoch 15/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.4740 - accuracy: 0.7551\n",
"Epoch 16/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.4605 - accuracy: 0.7716\n",
"Epoch 17/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.4479 - accuracy: 0.7862\n",
"Epoch 18/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.4361 - accuracy: 0.7940\n",
"Epoch 19/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.4249 - accuracy: 0.8076\n",
"Epoch 20/20\n",
"33/33 [==============================] - 0s 1ms/step - loss: 0.4144 - accuracy: 0.8192\n",
"11/11 [==============================] - 0s 853us/step - loss: 0.4147 - accuracy: 0.8192\n",
"Accuracy: 0.819242000579834\n"
]
}
],
"source": [
"# Train your model for 20 epochs\n",
"model.fit(X_train, y_train, epochs=20)\n",
"\n",
"# Evaluate your model accuracy on the test set\n",
"accuracy = model.evaluate(X_test, y_test)[1]\n",
"\n",
"# Print accuracy\n",
"print('Accuracy: ', accuracy)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Multi-class classification"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### A multi-class model\n",
"You're going to build a model that predicts who threw which dart only based on where that dart landed! (That is the dart's x and y coordinates on the board.)\n",
"\n",
"This problem is a multi-class classification problem since each dart can only be thrown by one of 4 competitors. So classes/labels are mutually exclusive, and therefore we can build a neuron with as many output as competitors and use the `softmax` activation function to achieve a total sum of probabilities of 1 over all competitors."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" xCoord \n",
" yCoord \n",
" competitor \n",
" \n",
" \n",
" \n",
" \n",
" 0 \n",
" 0.196451 \n",
" -0.520341 \n",
" Steve \n",
" \n",
" \n",
" 1 \n",
" 0.476027 \n",
" -0.306763 \n",
" Susan \n",
" \n",
" \n",
" 2 \n",
" 0.003175 \n",
" -0.980736 \n",
" Michael \n",
" \n",
" \n",
" 3 \n",
" 0.294078 \n",
" 0.267566 \n",
" Kate \n",
" \n",
" \n",
" 4 \n",
" -0.051120 \n",
" 0.598946 \n",
" Steve \n",
" \n",
" \n",
"
\n",
"
"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"sns.pairplot(darts, hue='competitor');"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"# Instantiate a sequential model\n",
"model = Sequential()\n",
"\n",
"# Add 3 dense layers of 128, 64, 32, neurons each\n",
"model.add(Dense(128, input_shape=(2, ), activation='relu'))\n",
"model.add(Dense(64, activation='relu'))\n",
"model.add(Dense(32, activation='relu'))\n",
"\n",
"# Add a dense layer with as many neurons as competitors\n",
"model.add(Dense(4, activation='softmax'))\n",
"\n",
"# Compile your model using categorical_crossentropy loss\n",
"model.compile(loss='categorical_crossentropy',\n",
" optimizer='adam',\n",
" metrics=['accuracy'])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Prepare your dataset\n",
"In the console you can check that your labels, `darts.competitor` are not yet in a format to be understood by your network. They contain the names of the competitors as strings. You will first turn these competitors into unique numbers,then use the `to_categorical()` function from `tf.keras.utils` to turn these numbers into their one-hot encoded representation.\n",
"\n",
"This is useful for multi-class classification problems, since there are as many output neurons as classes and for every observation in our dataset we just want one of the neurons to be activated."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Label encoded competitors: \n",
" 0 2\n",
"1 3\n",
"2 1\n",
"3 0\n",
"4 2\n",
"Name: competitor, dtype: int8\n",
"One-hot encoded competitors: \n",
" [[0. 0. 1. 0.]\n",
" [0. 0. 0. 1.]\n",
" [0. 1. 0. 0.]\n",
" ...\n",
" [0. 1. 0. 0.]\n",
" [0. 1. 0. 0.]\n",
" [0. 0. 0. 1.]]\n"
]
}
],
"source": [
"from tensorflow.keras.utils import to_categorical\n",
"\n",
"# Transform into a categorical variable\n",
"darts.competitor = pd.Categorical(darts.competitor)\n",
"\n",
"# Assign a number to each category (label encoding)\n",
"darts.competitor = darts.competitor.cat.codes\n",
"\n",
"# Print the label encoded competitors\n",
"print('Label encoded competitors: \\n', darts.competitor.head())\n",
"\n",
"coordinates = darts.drop(['competitor'], axis=1)\n",
"\n",
"# Use to_categorical on your labels\n",
"competitors = to_categorical(darts.competitor)\n",
"\n",
"# Now print the one-hot encoded labels\n",
"print('One-hot encoded competitors: \\n', competitors)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Each competitor is now a vector of length 4, full of zeroes except for the position representing her or himself."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Training on dart throwers\n",
"Your model is now ready, just as your dataset. It's time to train!\n",
"\n",
"The `coordinates` features and `competitors` labels you just transformed have been partitioned into `coord_train`,`coord_test` and `competitors_train`,`competitors_test`.\n",
"\n",
"Let's find out who threw which dart just by looking at the board!"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" xCoord \n",
" yCoord \n",
" \n",
" \n",
" \n",
" \n",
" 0 \n",
" 0.196451 \n",
" -0.520341 \n",
" \n",
" \n",
" 1 \n",
" 0.476027 \n",
" -0.306763 \n",
" \n",
" \n",
" 2 \n",
" 0.003175 \n",
" -0.980736 \n",
" \n",
" \n",
" 3 \n",
" 0.294078 \n",
" 0.267566 \n",
" \n",
" \n",
" 4 \n",
" -0.051120 \n",
" 0.598946 \n",
" \n",
" \n",
"
\n",
"
\n",
"\n",
"
\n",
" \n",
" \n",
" sensor_0 \n",
" sensor_1 \n",
" sensor_2 \n",
" sensor_3 \n",
" sensor_4 \n",
" sensor_5 \n",
" sensor_6 \n",
" sensor_7 \n",
" sensor_8 \n",
" sensor_9 \n",
" ... \n",
" sensor_13 \n",
" sensor_14 \n",
" sensor_15 \n",
" sensor_16 \n",
" sensor_17 \n",
" sensor_18 \n",
" sensor_19 \n",
" parcel_0 \n",
" parcel_1 \n",
" parcel_2 \n",
" \n",
" \n",
" \n",
" \n",
" 0 \n",
" 1.0 \n",
" 2.0 \n",
" 1.0 \n",
" 7.0 \n",
" 0.0 \n",
" 1.0 \n",
" 1.0 \n",
" 4.0 \n",
" 0.0 \n",
" 3.0 \n",
" ... \n",
" 8.0 \n",
" 1.0 \n",
" 0.0 \n",
" 2.0 \n",
" 1.0 \n",
" 9.0 \n",
" 2.0 \n",
" 0 \n",
" 1 \n",
" 0 \n",
" \n",
" \n",
" 1 \n",
" 5.0 \n",
" 1.0 \n",
" 3.0 \n",
" 5.0 \n",
" 2.0 \n",
" 2.0 \n",
" 1.0 \n",
" 2.0 \n",
" 3.0 \n",
" 1.0 \n",
" ... \n",
" 4.0 \n",
" 5.0 \n",
" 5.0 \n",
" 2.0 \n",
" 2.0 \n",
" 2.0 \n",
" 7.0 \n",
" 0 \n",
" 0 \n",
" 0 \n",
" \n",
" \n",
" 2 \n",
" 3.0 \n",
" 1.0 \n",
" 4.0 \n",
" 3.0 \n",
" 4.0 \n",
" 0.0 \n",
" 1.0 \n",
" 6.0 \n",
" 0.0 \n",
" 2.0 \n",
" ... \n",
" 3.0 \n",
" 3.0 \n",
" 1.0 \n",
" 0.0 \n",
" 3.0 \n",
" 1.0 \n",
" 0.0 \n",
" 1 \n",
" 1 \n",
" 0 \n",
" \n",
" \n",
" 3 \n",
" 2.0 \n",
" 2.0 \n",
" 4.0 \n",
" 3.0 \n",
" 5.0 \n",
" 0.0 \n",
" 3.0 \n",
" 2.0 \n",
" 2.0 \n",
" 5.0 \n",
" ... \n",
" 4.0 \n",
" 1.0 \n",
" 1.0 \n",
" 4.0 \n",
" 1.0 \n",
" 3.0 \n",
" 2.0 \n",
" 0 \n",
" 0 \n",
" 0 \n",
" \n",
" \n",
" 4 \n",
" 4.0 \n",
" 3.0 \n",
" 3.0 \n",
" 2.0 \n",
" 5.0 \n",
" 1.0 \n",
" 3.0 \n",
" 1.0 \n",
" 1.0 \n",
" 2.0 \n",
" ... \n",
" 1.0 \n",
" 3.0 \n",
" 2.0 \n",
" 2.0 \n",
" 1.0 \n",
" 1.0 \n",
" 0.0 \n",
" 1 \n",
" 1 \n",
" 0 \n",
" \n",
" \n",
"
\n",
"
5 rows × 23 columns
\n",
"
"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAfgAAAHwCAYAAABKe30SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOy9d5hcZ333/bm3zeyutmhXsmRZsmXJTXLFGNu0gAnFNDs8JKaE8IZmyBt4IITkMQkvPQkQCBjshxIwoQSIEwIIAhib0GIDLiAbW82WLFlrS/JqtX13+v3+cZ975uzslHPOnLZn7s916ZrV7MzO2TLnd77fXxNSSgwGg8FgMCSLjqgPwGAwGAwGg/+YAG8wGAwGQwIxAd5gMBgMhgRiArzBYDAYDAnEBHiDwWAwGBKICfAGg8FgMCQQE+ANhoQjhNgshJBCiC4Hj/1TIcT/hHFcBoMhWEyANxhihBDioBAiJ4RYU3X/TitIb47myAwGw0rDBHiDIX48DLxC/0cIcT7QG93hxAMnDoTBYKhgArzBED++Arza9v//B/iy/QFCiCEhxJeFEONCiENCiHcJITqsz3UKIT4qhDguhDgAvLDGc78ghDgihHhUCPFBIUSnkwMTQvy7EOKoEGJaCPFzIcS5ts/1CiE+Zh3PtBDif4QQvdbnniaEuEMIMSWEOCyE+FPr/p8KIV5v+xpLUgSWa/HnQogHgQet+663vsaMEOIeIcTTbY/vFEL8jRBivxBi1vr8JiHEjUKIj1V9L98VQrzNyfdtMKxETIA3GOLHr4BBIcQ2K/C+DPhq1WM+BQwBW4BnoC4IXmN97g3Ai4AnAJcAf1j13C8BBeAM6zHPBV6PM34AnAmcBPwG+Ffb5z4KPBF4CjAC/DVQEkKcaj3vU8Ba4CJgp8PXA/gD4DJgu/X/u6yvMQJ8Dfh3IUTa+tzbUe7HC4BB4LXAgvU9v8J2EbQG+H3g6y6Ow2BYUZgAbzDEE63inwPsAR7Vn7AF/XdKKWellAeBjwF/Yj3kGuATUsrDUsoTwD/YnrsOeD7wNinlvJTyceDjwMudHJSU8ibrNbPAe4ELLUegAxVM3yqlfFRKWZRS3mE97o+B26SUX5dS5qWUE1JKNwH+H6SUJ6SUi9YxfNX6GgUp5ceAFHC29djXA++SUu6Vinutx94JTKOCOtb3+1Mp5TEXx2EwrChMTstgiCdfAX4OnE6VPQ+sAXqAQ7b7DgGnWB9vAA5XfU5zGtANHBFC6Ps6qh5fE+vC4u+AP0Ip8ZLteFJAGthf46mb6tzvlCXHJoT4S1Qg3wBIlFLXRYmNXutLwKuAW63b61s4JoMh9hgFbzDEECnlIVSx3QuA/6z69HEgjwrWmlOpqPwjqEBn/5zmMJAF1kgph61/g1LKc2nOK4GrgWej0gObrfuFdUwZYGuN5x2ucz/APNBn+//6Go8pr7y08u3/B+VSrJZSDqOUub5aafRaXwWuFkJcCGwDvl3ncQZDIjAB3mCIL68DniWlnLffKaUsAjcDfyeEGBBCnIbKPes8/c3A/xZCbBRCrAausz33CPAj4GNCiEEhRIcQYqsQ4hkOjmcAdXEwgQrKf2/7uiXgJuCfhBAbrGK3JwshUqg8/bOFENcIIbqEEKNCiIusp+4E/pcQok8IcYb1PTc7hgIwDnQJId6NUvCazwMfEEKcKRQXCCFGrWMcQ+XvvwJ8U1v+BkNSMQHeYIgpUsr9Usq763z6LSj1ewD4H1Sx2U3W5/4ZuAW4F1UIV+0AvBpl8e8CJoH/AE52cEhfRtn9j1rP/VXV598B/A4VRE8AHwY6pJSPoJyIv7Tu3wlcaD3n40AOOIay0P+VxtyCKtjbZx1LhqUW/j+hLnB+BMwAX2Bpi+GXgPNRQd5gSDRCStn8UQaDwZAAhBC/h3I6Nluug8GQWIyCNxgMbYEQoht4K/B5E9wN7YAJ8AaDIfEIIbYBU6hUxCciPhyDIRSMRW8wGAwGQwIxCt5gMBgMhgRiArzBYDAYDAkkMZPs1qxZIzdv3hz1YRgMBoPBEBr33HPPcSnl2lqfS0yA37x5M3ffXa9l2GAwGAyG5CGEOFTvc8aiNxgMBoMhgZgAbzAYDAZDAjEB3mAwGAyGBJKYHHwt8vk8Y2NjZDKZqA8lNNLpNBs3bqS7uzvqQzEYDAZDhCQ6wI+NjTEwMMDmzZux7b5OLFJKJiYmGBsb4/TTT4/6cAwGg8EQIYm26DOZDKOjo20R3AGEEIyOjraVY2EwGAyG2iQ6wANtE9w17fb9GgwGg6E2iQ/wUTIxMcFFF13ERRddxPr16znllFPK/8/lco6+xmte8xr27t0b8JEaDAaDIWkkOgcfNaOjo+zcuROA9773vaxatYp3vOMdSx4jpURKSUdH7WutL37xi4Efp8FgMBiSh1HwEfDQQw9x3nnn8aY3vYmLL76YI0eOcO2113LJJZdw7rnn8v73v7/82Kc97Wns3LmTQqHA8PAw1113HRdeeCFPfvKTefzxxyP8LgwGg8EQZ9pGwb/vuw+w67EZX7/m9g2DvOfF53p67q5du/jiF7/IZz7zGQA+9KEPMTIyQqFQ4IorruAP//AP2b59+5LnTE9P84xnPIMPfehDvP3tb+emm27iuuuua/n7MBgMBkPyMAo+IrZu3cqTnvSk8v+//vWvc/HFF3PxxReze/dudu3atew5vb29PP/5zwfgiU98IgcPHgzrcA0Gg8GwwmgbBe9VaQdFf39/+eMHH3yQ66+/njvvvJPh4WFe9apX1Wx16+npKX/c2dlJoVAI5VgNBoPBsPIwCj4GzMzMMDAwwODgIEeOHOGWW26J+pAMBoPBsMJpGwUfZy6++GK2b9/Oeeedx5YtW3jqU58a9SEZDAaDYYUjpJRRH4MvXHLJJbJ6H/zu3bvZtm1bREcUHe36fRsMBkO7IYS4R0p5Sa3PGYveYDAYDIYEYgK8wWDwl08/De76fLTH8LWXwy1/G+0xGAwRY3LwBoPBX8Z3w9HfRXsMxx6AuaPRHoPBEDEmwBsMBv8olaBUgMWpaI8jNwuZaZASzAImQ5tiLHqDweAfpby6XZyM7hikhOwsZKdhYSK64zAYIsYEeIPB4B9Fa0tiJkIFX8gqFwFgYn90x2EwRIwJ8AHix7pYgJtuuomjR00+0bACKMZAwefmKh+fMAHe0L6YHHyAOFkX64SbbrqJiy++mPXr1/t9iAaDvxSy6nZxOrpjyNqWShkFb2hjTICPiC996UvceOON5HI5nvKUp3DDDTdQKpV4zWtew86dO5FScu2117Ju3Tp27tzJy172Mnp7e7nzzjuXzKQ3GGKFtuiz01AqQkdn+MeQNQreYIB2CvA/uM7/1p3158PzP+T6affffz/f+ta3uOOOO+jq6uLaa6/lG9/4Blu3buX48eP87nfqOKemphgeHuZTn/oUN9xwAxdddJG/x28w+I226EFVsfeNhH8M2qLv6jUK3tDWtE+AjxG33XYbd911F5dcoqYLLi4usmnTJp73vOexd+9e3vrWt/KCF7yA5z73uREfqcHgkqKttmRxMpoAn51Vt+vPg8d3m1Y5Q9vSPgHeg9IOCiklr33ta/nABz6w7HP33XcfP/jBD/jkJz/JN7/5TT73uc9FcIQGg0eWBPiIKunLAf4CGLsL5h6HgXXRHIvBECGmij4Cnv3sZ3PzzTdz/PhxQFXbP/LII4yPjyOl5I/+6I943/vex29+8xsABgYGmJ2djfKQDQZn2C36qCrptUV/8oXq9sSBaI7DYIiY9lHwMeL888/nPe95D89+9rMplUp0d3fzmc98hs7OTl73utchpUQIwYc//GEAXvOa1/D617/eFNkZ4o9dwUfVC68V/AarZuXEfjjtydEci8EQISbAh8R73/veJf9/5StfyStf+cplj/vtb3+77L5rrrmGa665JqhDMxj8o5itfByVgtdV9Gu3QUeXKbQztC3GojcYDP6xxKKPSMHn5qBnFXT1wPBpplXO0LaYAG8wGPyjuoo+CrKzKsADjG6FCZODN7QnJsAbDAb/iEsOPmUF+JGtqshOymiOxWCIkMQHeNlmb+x2+34NMUNb9D2roq2ityv4/DzMml0OhvYj0QE+nU4zMTHRNkFPSsnExATpdDrqQzG0K1rBrzopwj74OUgNqI9Htqhbk4c3tCGJrqLfuHEjY2NjjI+PR30ooZFOp9m4cWPUh2FoV/Symf6Tos3BD29SH49uVbcT+2Hz06I5HoMhIhId4Lu7uzn99NOjPgyDoX3QFv2qk2DqUDTHkLMV2Q1tgs4eo+ANbUmiLXqDwRAyZYt+XbR98Nqi7+iE1ZtNL7yhLTEB3mAw+EdZwa+DQgbyi+Efg72KHiqV9AZDm2ECvMFg8I9iDkRHZYtc2IV2xbyaptczULlv1ArwpVK4x2IwRIwJ8AaDwT+KOZXz7l2t/h92L7yeQ5+yBfiRLcpNmH0s3GMxGCLGBHhD9Oz+rtrbbVj5lAP8sPp/2Hl4vUnObtHbK+kNhjbCBHhDtJSK8M03wK/+b9RHYvCDYg46uysKPmyLXiv4nqocPJhKekPbYQK8IVqmHoHCImRmoj4Sgx9oBZ+OSMFnayj4wVOgK20UvKHtMAHeEC3je9WttlYNK5tiPtocfE7n4Acr93V0wOrTTSW9oe0wAd4QLcetAJ81AT4RaAWfGgREBAq+hkUPqtDOKHhDm2ECvCFatILXJ2bDykYH+I4OVWgXeg6+hkUPMLoFJh9WNR8GQ5tgAryhNUrF1k7iZYveBPhEUMyrIjtQefjIqugHlt4/slVdfEyPhXs8BkOEmABvaI3ffhWuvwByC+6fK6VNwRuLPhEUskrBg8rDR9UH31MV4EdNJb2h/TAB3tAa02OQmfbWxz57RCn31KApsksKusgOLIs+ghx8Vxo6q/ZojZheeEP7YQK8oTUK1qzxo/e5f+74HnV7ysXKPtWrRg0rl2IOumwKPgqLvtqeBxg4Gbp64cTD4R6PwRAhJsAbWiOfUbfH7nf/3PF96vaUS9StselXPrrIDqwcfARFdtUV9KCK/ka2GIve0FaYAG9ojbKC/537547vUSpv5HT1f1Not/KxF9npHHyYS16qN8nZGTWtcob2wgR4Q2vodaDHHnB/Ih/fC2vOrliqplVu5WNX8L3DIEvhXrjl5pYX2GlGtsLkQSgWwjsegyFCTIA3tIa26HNzqs/YDcf3wtqzK5aqsehXPsWqKnoINw+fna2dgwdVSV/Kw/Th8I4n7swcgW/8cfi1Eknk8F3wnTer7qCYYAK8oTUKi6p4Cdzl4eePw8KECvD6hGwq6Vc+1X3wEG4evpFFb5bOLOeRX8Ke78GhO6I+kpXPvh/Cb78C2fjs1TAB3tAa+QysPx9Ep7s8vO5/twf4GL0xDB5ZYtFHoOBzdYrswLY21sykL6N/N/r9aPBOZlrdxsiJ7Gr+EIOhAfkFWLUO1pwJR10oeN0it+bsyn0xemMYPFLMQ2dKfax3woc57CZbp00O1N9pzyqj4O3o340J8K2jf5YxciKNgje0RiED3Wml4t0o+OP71Ml2aGPFUo3RG8PgEb0PHsJX8KUi5OfrB3ghVMeGqaSvoH83x02AbxmdiopRsbAJ8IbWyFs5+HXnwcwYLJxw9rzxPbDmLHXS1VXPRsGvfKr74CG8HLy+QKxn0YPKwxsFX0H/bsb3hdvOmETKFr0J8IakYFfw4LzQbnyfyr+DGiva1Wty8CudYkG1xekA392r7PqwFHy9TXJ2RrfC5CGVSjBUfjf5eZh5NNpjWekYi96QOLSC1wHeSR4+Mw2zj1UCPKiTcozeGAYPFHPqVlv0Qqg8fFg5eK2c6ln0oBS8LMLUI+EcU9zJTFcuyEwevjWMRW9IHPlFpdRWnaSKmJzk4fWIWnuBXc8qY9GvdMoBvqdyX5jz6MsWfYMAP2qWzixhcRI2PEF9rAtfDd6IYRW9CfAG75SKanBIt9UHv+48OOYgwB+3tchpUgOxuvI1eEDb3l22AB/mPPqygm+Ug9+ibk0eXrE4pVyNvlFTaNcK+UU15AliNXI70AAvhLhSCLFXCPGQEOK6Oo+5RgixSwjxgBDia7b7P2Ldt1sI8UkhhAjyWA0e0GNqu9Lqdv358PgeKOQaP298j8rNrt5cuS81YCz6lU5dBR9ykV0ji75/rVL4RsErFifV72jtOcaibwWt3qE9FLwQohO4EXg+sB14hRBie9VjzgTeCTxVSnku8Dbr/qcATwUuAM4DngQ8I6hjNXhEB3it4NefrxR9MyUwvk/1zXd0Vu7rWWUU/EqnZoCPIAffqIpeCLV0xih4dSGen1e/ozVnqQAfozGrKwr7RWyMzmNBKvhLgYeklAeklDngG8DVVY95A3CjlHISQEr5uHW/BNJAD5ACuoFjAR6rwQuFGgEemhfa6RY5O0bBr3yqi+wg3Bx81oGCB2VJGwVfufDSCj4zBXOPN36OoTb2i9gYnceCDPCnAPatDmPWfXbOAs4SQtwuhPiVEOJKACnlL4GfAEesf7dIKXcHeKwGL+hFM9qiH9mqPm5UaJdbUBXMa89Zen/KKPgVTy0Fnx5WJ7ww2tJyDqroQRXaTR9unkpKOlp1pocr9TAmD++NJRZ9fM5jQQb4Wjnzav+nCzgTeCbwCuDzQohhIcQZwDZgI+qi4FlCiN9b9gJCXCuEuFsIcff4+LivB29wQLWC7+yCk7Y3LrSbeBCQSwvswFTRJ4F6OXgIJw+fnYWObuhKNX7cyFbVrz95MPhjijPaWeldXXk/mjy8N/Tfd+9I2wT4MWCT7f8bgcdqPOY7Usq8lPJhYC8q4L8E+JWUck5KOQf8ALi8+gWklJ+TUl4ipbxk7dq1gXwThgZUF9kBrD9PKfh6uTzdIlcd4FOD6oLB7OpeuWiVXp2Dh3Dy8Nm5xhX0mlGzVQ6wWfTDMHCyeg+aAO8NreCHNraNRX8XcKYQ4nQhRA/wcmBH1WO+DVwBIIRYg7LsDwCPAM8QQnQJIbpRBXbGoo8b5SK7vsp96y9QymCm+lrOYnyP2jynV3dqyvPo43P1a3BJQwUfQh4+N9e4B14zYnrhgaUKXgir0M70wntCXywNbYqVExlYgJdSFoA3A7eggvPNUsoHhBDvF0JcZT3sFmBCCLELlXP/KynlBPAfwH7gd8C9wL1Syu8GdawGjxSsHHy3TcGvO0/d1svDj+9Rvcj2XmmoVD7H6M1hcEm9HDyEZ9E3y78D9I1AesgoeHsOHkyrXCssTkF3v7pYipFFH+i6WCnl94HvV933btvHEni79c/+mCLwxiCPzeADZYu+t3LfunPV7bHfwdlXLn/O8X3L7XkwG+WSQNmir6qih3AUfHbWmUUvhKmkh8rvJD2kbteeBTu/qhZG9Y1Ed1wrkcy0+jnGrBvITLIzeKeWgk8PqgE2tRR8IadOqjUD/KC6jdHVr8ElBWuSV1Q5+Nxc4x54O6Nb4cSBYI8n7mSm1Puu09J5urPl+L7ojmmlkplSf+t6p0ZM5gmYAG/wTn5B3dpz8GDthq/RC3/igFr0Ud0iBzaL3gT4FUutIruyRR+Ggp9zZtGDKoaaPRKbE3EkLE5WLsCgMpvC2PTuWZxSf+s9q1SHhj43RowJ8AbvVPfBa9adr4J5dT5dF/AYiz6Z1Bp009mlCt9Cy8E7VPDpISgVKmmmdkQHJc3wqSrdZgK8e+wWPcRGqJgAb/BOdR+8Zv35gITHdy29//g+QMDomcu/VvmNYQL8ikUH+Oo+9LCm2TmtoodK3tk+oKTd0HPoNR2dsOYMM+zGC2WLPl7nMRPgDd7JZ1TLm12xgeqFBzh639L7x/coldBTZelD5cQckytfgwdqWfQAvUPB5+CldF5FD5Waj3YO8Doo2TGV9N7QCr4nXu2+JsAbvKN3wVcztEn9sVfn4cf31rbnwfTBJ4FaFj2Eo+Bz84B0YdHr4r82DvDVCh7U+3P6cGwU6IqgVITsjPqbSsWrlsgE+KAoZOH4Q1EfRbAU6gR4IVQe3l5JXyrC8QfrB/iulFJ+5sSycinWqKKHcHbC69oNp1X07W7RS7k8Bw+wRs+kN5X0jtF/Q8aibyN2/it8+ilquUpSyWeW9sDbWX++ysGXiur/kwdVAFhTJ8CDWRm70tEWfUcECt7pJjmNDvDZmWCOJ+7k5tVq52UK3upwMTa9c3T6KT1USTXGpFjYBPigmBtXAS0mv+hAKCwu7YG3s/481Sqie421IqjVIqfRPaSGlUkxBx1d0FF1WtE74YNsSdOB2m2AD2tXfdywz6G3M3K6+h2aQjvn2CcCli36eFw4mgAfFPl5dauHwSSR/OLyFjlNeTe8ZdOXW+TOqv14UFe/MbG2DB4o5qCzxia33tXqc0H2BhuL3h32OfR2Orth9Ayj4N1gv1gyFn2boK35fMIDfPWQG83ac5QSKAf4fWpjlT6x1iI1YIrsVjLF/PICOwhnHn3ZoncY4LvTqlagbQN81Rx6O2vOMgHeDfpvKD2kzoeiIzZOpAnwQaHVSiHBgzQKmfoWfVdK5duPWZX043vqF9hpUiYHv6Ip5pYX2EE48+j1341uf3NCeqiNA3wdBQ/q4nzy4WSLEz+xXywJYdUSmQCfbMoBPhvtcQRJfrF+kR1YI2ut3fDH9zUusINYvTEMHijUC/AhzKPXzo9Tix7aO8DXy8GDuhCXJbNtzyn2KnqIVbGwCfBBUbboE6zg8w2K7EAV2s0egSP3KsuqqYKP1yYmg0uKudoWfSgK3qVFD1aAj0cxVOg0VPDW+9TshndGZkqlI3W6MkapRhPgg6IdFHwhUz8HD5VCu/u/qW6dBPiYXPkaPFDPog8jB5+bU7nPRn+P1bSzgl+cUlMoazkeo2eon+W46YV3hJ4nIIT6fyo+TqQJ8EGR01X0CVfw9aroQQ27Abj/P9VtoxY5UCeb3ByUSv4cnyFcivloc/A9A5WTrBPaOsBbU+xq/by6e2H4NKPgnaLH1GqMRd8GaGs+8Qq+QQ6+fxQGNsDMGPSOQP+axl9Pt5joFkPDyqKYg64aAT41oNRikDn47Jw7ex5UQV67Bvhac+jtmJn0zqn+WcYo1WgCfFDoIJXUHLyUKg3RSMFDZfFMM/UOsZvjbHBJPYteCHUCDFLB52bdFdiBUfC18u+atWfBxENQLIR3TCuVzPTSdsNUfOZ5mAAfFLmE5+CLeVVp26jIDip5+EYDbjQ98RoSYXBJvSI7CH4evZtNcpr0kJo22Y7tYLXm0NtZe44aZTv5cHjHtFJZnKph0cejeNME+KAoW/QJVfDlXfBNiprWeVDwMalATSQHfgaP3hPM166n4CH4efReLPp2nkffTMHrllZj0zennkUf5Ghmh5gAHwTavobkKniteppZ9Kc9VZ0sTn9G868ZszGPieS/3g4//VAwX7thgB8OuA9+zoNF38YrY5vm4C3HzRTaNUbKGhb9KigVYnHu74r6ABJJfhGQto8TiL6AaVRkBzCwDt58p7Ov2WNy8IFSKsHUI9DXpNjRK/VG1YJSixMBrk/OzrqbYgftO4++VFTfcyMFnxqAwVPM2thm5OZVMF9i0ds2yjVLYQaMUfBBYF+qEYOruEAoOFTwbkjFa9Vi4pg9olR2UD/festmIKQcvFsFb10QtNtGufLs9AYKHtTcCqPgG1NrImCMNsqZAB8ESwJ8UhW8wxy8G8oWvVHwgTB5UN0G9fOt1wcPSi1mpoOZcSClR4u+TRV8oyl2dtacDccfNHMpGmFfNKOJUarRBPggyLWRgvfTgjIWfbBMHVK3gSr4ehb9MCAhG0AwLWSVTeq1yK7dAnyjOfR21p6txMr04eCPaaVSayufPo/FwIk0AT4I7INaEpuDt76vRstm3NLdG6tVi4lj0grwQV1AFbKNFTwEU0nvZZMc2AJ89FZqqDhV8LrzxVTS16d60QzEyok0AT4I7EE9qQq+bNH7qOCFiNWQiMShFXwxpza/+U2jIrsg59F72SQHKr3U0dV+Cr7RLng7enfEcRPg66LdkJoWvQnwyURb9KIjuTn4skXvYw4eVAWqUfDBoHPwEMzPuFkfPASk4D1skgN1QdmO0+ycKvi+EehfawrtGmEs+jZEW/S9q5Ov4P2sogdrE1ObWaZhMXlIKVbw/2cspZp81lWnij7InfBli97lJDtoz3n0TnPwoArtzFa5+tQsstO1RCbAJxOt4HtHkpuDLyt4H3PwYI15jP6NkTgKWdUmpyeU+f0zLubVbaM+eAhGwWul1OMhwLelgp9Szlu9izE7a89WOfgYTGWLJZkpdZHY0Vm5L0bFwibAB4Fuk+sbqQTCpKG/R98VvLHoA2HqMCAry3/8/hkXrZx+PYs+yBx8WcG7tOihfQN8s/y7Zu3ZqvNh7liwx7RSqfWz7OiE7v5YnMdMgA+CcoAfTXCAD0jBp+KzSzlR6Py73g3g98+4WYDvTquOi0Cr6D0q+HZLCTWbQ29HF9qZPHxtMtPQO7T8/picx0yAD4KyRb86uZuqCovqZG63pvygx1TRB8LUQXW77lx1G1iAr2PRQ3Dz6MsWvVHwjmg2h97OSlk6c/9/wq3vCf91M3XckB4T4JNLfl5Z1929yVbwfvbAa1IDZptcEEweUmNkR89Q/w/bogdro1wQFr0J8K5wo+AH1qvf6cyjwR5TKxTzcMvfwj1fDP+1M9NLC+w0MUk1mmUzQZBftIpY0gkO8AvBLFLQ1paUqo3J4A9Th2D41Mr89cCK7BoE+KDm0efmVM6zw4NeSQ+pv+VCDroaHHuScJODF0KlGucngj2mVti9A2YfA4Qaq+vl78Ar9X6WMZnnYRR8EOQWoKe/EuCTWIFayPhfYAdKhclScrsPomLyIKw+rVJpHnYOHoLbCZ+d8ZZ/h/bcCe/Goge1fXDheHDH0yq/+oz1gQzf/av3szQWfYLJzysF351WwUqrmyShXQq/MRvlgmHyEAyfBp1dKrXi94nQUYAPKAefnfNWQQ/tN4++kFWOhZsA3z8KCzFV8I/eA2N3VopHwxw7XMipn2U9BR+DVKMJ8EGQX1T5d61wk2jTFzIBWfTxGfOYGBanVGBdvVn9PxXArIFChAreyyY5TbsFeJ0icZqDBzw0jfoAACAASURBVKXg52Oq4H/9WeVKXf5n6v9h/h5rDbnRBPEe84AJ8EFgt+ghmQE+vxhMkV1UQyIe3w3HHwr3NcNCz6BffZq6DcI+dFJFnx628t1NpjvmFuDB25y/dna2dYu+bQK8wzG1dvpiquBnj6rq+Sf8MQxtVPeFGuAbTATsWRULF9IE+CDQFn3SA3xQRXYQ7ptDSvjay+BHfxvea4aJ3iI3bAX4VAAnH6cWPTQvtPvlDfCvL4WpR5y9dnbOBHinlJejuLHo16gahbiN3b77JrUm+NJro/k9lhV8HYu+kIk8PWsCfBDkFpRFr4fAJLEXvpAJNgcfpr11ZKdSuUlNC1Qr+NRgNFX0WjU2y8Pv+o66PXHA2WvnZr1b9HrFbLsEeK8KHuKl4gtZFeDPfC6Mbo0mwJcXzdRpk4PIzykmwAdBftGy6K1Zz0lV8IFU0Ufwxti1Q90m8fcESsGnhyon9Z4AFvpoBd+o1ays4Bvk4Sf2w7H71cfaeWiGseids9jAVq5H/xp1G6cAf/83YX4cLn+T+n8qCgXfxKKHyG16E+CDoGzRWwo+iYEjcIs+pAAvpeqjhfhZkH4xebBiz0N0Fn1aL5xpoOD170J0VJyHZrRSRd+zSr1W2wR4LwreCvBxKbSTEn71aVh7Dmy5Qt1Xnu8QYhV9rV3wmlQ8Fs6YAB8EuQXo6Uu2gi8EVGQXtkX/+G6YeEitUU3i7wlUoFxtD/ABDOFwOqoWGiv4XTtgw8VqKI99f309CjkoZr1tkgM1FCU12D598JkpQFQUrxPiZtE/8is4eh9c9sbKMKzObjXsKBKLvk4OHiKvpDcB3m9KJRX8uvuSnYPPZ/xfNAPqTQrhWVu7dwACtjwzmQpeSlWsZlfwQVT4Oh10A/Vz8FOH4bHfwPar1PE6sej19+FVwUN7jatdnFTfr5tpb/0xU/C//rQKqhe8bOn96aFg5izUIzNtjSSv4WTqC86Ie+FNgPebgjWBrTvBCl5K6yImgADf0RHuFKhdO+DUJyvFmLTfE6g1n4VMpQcelLrIL0Cx4N/rOLLoLdVYT8Hv/q663XaVchycWPStbJKzH1fbBHiXU+zAujAT8VDwU4dh9/fg4lerOic7Yf8eM1O17XkwFn1i0ZvkevqTm4PX308QRXZgWcghvDGOPwSPP6AUY1e6MqwlSWibuzrAg78qvlxF38Ci7+hU1nC9HPzuHWoi2ehWpeDnxyE33/h1W9kkp2mrAO9i0YymoxP6RuIxrvaufwYkXPqG5Z8LPcBP1283LM/zMBZ9sshbJ6QkK3g9Jz4IBQ/hDYnYbbVjbXux+l0l7fcEy3vgIZgKXycKHpR6rKXgZ4+q3Oq2q9T/9QVJM5s+ayx6V9Rbb9qMvtHoLfrcPNzzJTjnRcpxqyY9GO6o2kZuSExGbpsA7zf24JfUHLwOhEEF+FRIFv2uHXDKE9UUrK60KtZK2mIgbXPbT4hB2IflAJ9q/Lh68+h3fxeQyk2BSoBvZtOXLfpBp0e6nPRQuIEhSrwoeLAWzkRs0d93s/rb0WNpq4mVRW+K7JLJEoteT7JL2GY0fRETRBU9hLNqcfKQGnCjFWPZbUlYod3kIRg4eWkhUE8AJ59iHhDKzm1EvXn0u3fA6Jmq9QkqjkMzBa+LmIxF7wwvOXhQC2eiVPBSqrnz6y9QNTO1iJNF39mtLnYj7s4wAd5vllj0OsAnLGiUFXxAOfiegeCtLV3QpRVjUscKV/fAg80+9FHBF7LKntdtS/WotRN+fgIO3g7br648v3+Neg81VfA+WfS5WX+LDuOIlCtXwR/4KYzvhsveVP9vTAf4sFy4ZhdLqRDOY00wAd5vtILv7lOrOTu6krfbPHAFH8CktWp274D158PIFvV/nTtO2sVYdQ88BGTR55vn36G2gt/7XyCLlYstUCfx1Zub98JnfVLwELnaCpzcnPo5e8nB96+BxROqDTgKfv1ZdZFx3kvrPyY9pL6/ZoWZflAqWQq+wTyBGGyUMwHeb/LaorfmtHelkxc0ynUGQSn4gN8YM0fg8K9h29WV+5Ko4It5mHl0uYIPosK3mGtcQa/ROXi7ytq1Qx3j+guWPtZJL3y5D77FNjlIvk3vZYqdpm8UZCmYdb9OeOw3cNbzGp9zwvw95mYB2fhiqSekbqAGmADvN3mbggcrwCdMwZct+gCWzUDw1tae76lbu2JMYg5++rA6Kdtb5KBSkOZ3Fb1TBV8qVF57cUrZr9uvWm696l74RpZrdla9x5xcXNSjXRbOeJlDr9HjaqNqlStkmrs0qRDH1TZaNFM+HmPRJw97kR0kW8EH1ge/SgWMoH5uu74Da86GtWdX7kuigi/3wIdk0TdaNKPRikefIPfdAqX8UjdFM3yaOkEunKj/9bItbJIrH1ObWPStKPj+iMfV5jPNHcMwFbx+jYY5+BAHdtXBBHi/KRfZWfnp7nRyc/CB9cEH2GIyfxwO3b5UvUMyCyJr9cCDcis6uv1vk3Oq4KESbHbvgIENql2xmnIv/MH6Xy/Xwi54TbtY9F52wWuiXDhTKqkW1maCQn9foQR4Bz/LMCdy1sEEeL+pLkBLooIvBK3gA5zjvOd7yrbeVh3gEziUaOqQCuSDG5Z/zu+NcsWswwCvT8JT6gLuodvUoKFas9G18zB1sP7Xa2WTnKZdAnxLCj5Ci97p5Mwwf4+OLPqQBnY1wAR4v8lZq2L1CSuJOfh8CINuIBgFv2uHUobrz196/0pQ8KUiHL3f+eMnD8Hwptq96X7PGijmHRbZ2RT8gz9SJ+9qN0XjpBc+N+d9k5ymbQJ8Kzl4y6Kfj8CidzpYK3YW/aCpok8c+YWlf4hJVvBBjqoF/+2txUl4+GdL+601WsEXY/y7uu298JmnwrFdzh5fqwde43eFr1OL3p6D370D+tfWH1ySWqUCS6Ne+OxM6xZ9ahAQbRDgJ9XvyEtxbFdK/c3EWsHrYskQNso5tejz8+rCPCJMgPeb/GJl5SkkOwcfmEUfQJU3wN4fqgruWgVdcS+ye/Q38Msb1Me7vu3sObV64DWpVf6mQNz0wYOaPb/vR2queKPpd8164f2w6Ds61EVC0gO8nkPfbBhRPfpHoymyc3q+6Uqp1GgYY4cXp0B0NC7w1H+XEdr0JsD7TW6+0gMPyVTw+UX1fXk9UTQjqFWLu3fA4EY45eLln4tzm1whB995M6xaBxsuVmmGZmTn1Mm4noL33aJ3qOB7+tXwp/u/qdRNPXte06wXPjfXehU9tMc8eq9T7DR9a6IpsnMzOTM9GJ5Fnx6qXTuiicE8ehPg/Sa/sNQCS2IOvpAJzp6HYLadZWfhoR+rgq5aFyZxVvC3f0KttX3Rx+HCl6uRneP7Gj9H29rVPfAavyt8nQZ4IVSQOb5XqcnNT2/8+NWnwfRYfZszO9u6RQ/tMY/e6xx6Td9oxBa9g3NOWL/HRotmNEGcx1xiArzf5GoF+BiqwlbILwY3phaCUfAP/kjl1+spxrgq+Mf3wM8+okZ0nv18dYEClVW39ajXA6/xu8K34HCSHVTylue8sPlzVm9WffIzjy3/XKmoLqhNgHdGqwq+f000RXZ5Nwo+rADfYNGMpqzgo2uVMwHeb/ILSy36pObggxpTC8H0we/6DvSfBJsuq/35OLbJlYqw483qRHHlh9V9gxtg45Oa2/TlHvjNtT/vd4WvUwUPlSBT3apYi3Il/cHln9MXKL5Z9AkP8F53wWv6rBx82CuV3bTlhvV7dOKGmACfQGpa9DFTha1SyASr4Du71Nf3qwhs4QQ8eCtsa1DQ1RlDBf/rz8LYXfD8D8OqtZX7t10FR++DEw/Xf+7UIRX4+kZqf77HUvB+LQ9xG+B7BmDrFc0fW+6Fr5GHL++Cj2mA//H74ft/7e/XbIXFqdYVfDEbvuWcd1hFD8air8IEeL/JLVTG1EIlBx/2VW+Q5BeDzcGDv2Mef/hOFYCe9Ib6j+noUAEqLgr+xMPw3x+AM58H5//R0s/pNINeeVuLyYPK3q5XCJlaBcjK5MVWcdoHD/D0t8NLPl1xTRoxtElVK9cqtCuvivXBok/5XJz14G3wi4/BnZ9tXi8RBsWCailsKQcf0TQ7p33woIJuGCOHHVn0ARULu8AEeL/Jzy/vg5cl1Z6VFIIusgP/qrz3/Qju+wY8/S9h3fbGj42L2yIlfPetIDrhRf9UYwnLZrV5bXcDm37yUP0KevB/o5wbBX/q5ZVagmZ0dqvOh1oKvmzR+5SDz87442hkZ+F7b4ORrcoZuvOzrX/NVikPZmmlij6iefRO++ChcqEWtKByYtEHOXLbIYEGeCHElUKIvUKIh4QQ19V5zDVCiF1CiAeEEF+z3X+qEOJHQojd1uc3B3msvpFfXGrR61x1kvLw+YXgeuA1PT4UgWVm4Ht/AWvPUQG+GV2peCj4335VDeR5zvtgaGPtx2y/Wtn3048u/5yUjXvgwf9ZA8W8M0XuhdWn1c7B+23RI/1JC/34/ary/yWfgfP/EHZ+vTJFLipamUOv6Y9IwbuZu5EeshZVBfg+zmdUqqKZRR/kyG2HBBbghRCdwI3A84HtwCuEENurHnMm8E7gqVLKc4G32T79ZeAfpZTbgEuBx4M6Vt8oFa21hlUWPcQjcPiFk81OrZLyYdLaj9+n9qFffaOz4BMHBT9zBG75WzjtqfDE19R/3HZrWI9efWtn/ri6CGuk4Mv2oU92ZjHb2srWRtTrhS8HeJ8UPLRu0x/6Jdz5ObjsTbDpUrjsjcrV++1XWj/GVmhlDr0magXvtIoegs3DO71Y6kqpmQ8JVfCXAg9JKQ9IKXPAN4DqEWJvAG6UUk4CSCkfB7AuBLqklLda989JKRcCPFZ/KO+Cr7LoIVkBvhBwmxy0HuAP3QF3fR4u/39h4yXOnhO1gpcS/usvVbC86lONh2isORPWbqtdTV9ukdtc//lRWvRuWX0azB1d7oL5XUUPrQWGfEZ1PQyfCs96l7rv5Avh1KeooB/hyNKW5tBrolo447YPHoIN8E4WzYBKrUW8US7IAH8KcNj2/zHrPjtnAWcJIW4XQvxKCHGl7f4pIcR/CiF+K4T4R8sRiDflNap2i976o8wnKMDnQ8jBt2LR5xfV5Lfh0+BZf+v8eVEr+F3fgb3/BVf8DYxubf747Vep1bdzVeZWechNIwWv7UMfAnypqOpMAgvwm9Xt1OGl9/tZZOdHYPjZh2HiIXjx9UvTBpe/CaYegb0/aO0YW8EPBd+zStUUhG7RZ1ShpROHKIyVsU4WzWhSg4mtoq9Vvltd+dAFnAk8E3gF8HkhxLB1/9OBdwBPArYAf7rsBYS4VghxtxDi7vHxcf+O3Cs5qyJ5iUUfw/7qVgmtit7jG+OnH4IT++GqTy79XTSjKxVtgH/gW6qg7PI/d/b4bVcBcrlNrxX88Kn1n+tnj24xp26DtOhheR5epxd8UfB6UYnHwHDkXrj9enjCq2Drs5Z+7uwXqm6AX3+mtWNsBT9y8EJUeuHDpJBxPhq7fKEWYCV9+Wfp4GLJz24gDwQZ4MeATbb/bwSqx1GNAd+RUuallA8De1EBfwz4rWXvF4BvA8sGiEspPyelvERKecnatWurPx0+ZYve3gdvBcIkBfjCYjhFdl7eGI/9Fu74FFz8atjyTHfP7UpH+3vKTMPgyWoOgBPWnQsjW5bb9FOH1Ja2Rhc3fm7sKwf4AC16WF5Jn5tT++79KO5rJTAU8/CdP1cW9nM/uPzznV1w6Rvg4C/crfv1k7KCbyHAQzQLZ/IuzjdhbJRzatFDoi36u4AzhRCnCyF6gJcD1QnDbwNXAAgh1qCs+QPWc1cLIXTUfhbgcEdmhORqBfiEKfhSUZ3QA1fwg+pCouiivbCYh++8RQW353zA/WtGreCzs5XqdicIoVT8wV+oYT4a3QPfCD8t+mJe3QYV4FetUyf4ZQre2iTnx9KjVqzdOz4JR38HL/xYfQv84ler88KvP+39GFthccqy2Ft0WaJYOFPIOj/fhFJk58ai93kktEsCC/CW8n4zcAuwG7hZSvmAEOL9Qgg9o/IWYEIIsQv4CfBXUsoJKWURZc//WAjxO5Td/89BHatvaAXfk+AcvJuhE63gZdXi7Z+AY79TveNelErUCt7LbvPtV6kZC/b8brMeeFC/P9HhT5Fd0ApeCPX9VCv47Kw/PfBQubByGxjG98FPP6y6Ghr19veuhgteBvf9ezQb2VqdQ6/pXxNBkZ0bBR9mFb0DBe/31kaXBNoHL6X8vpTyLCnlVinl31n3vVtKucP6WEop3y6l3C6lPF9K+Q3bc2+VUl5g3f+nViV+vKlp0SdMweddVLS2glsLeXyvWspy7kvUEhMvdPZEr+DTLhQ8qPWxQ5sqQ2+KBdWD3ajADqwKXx9aEaHyMwsqwEPtXvjcnD8FdqBs9J5V7gJDqQQ73qIull7w0eaPv+xNqkPini96P06vtDqHXtMXwcIZN0W9XWn1dxi0gu/ud+aG+PUe84iZZOcnNYvsYp6Dz827m95VvogJoQ8enCn4UlFVzff0w/M/4v01o1bwmRl3Fj1UbPr9/62eP/MoyGJzix78sw/LFn1ARXZg9cI/svS+7Kw/Q240bueY3/0FOPwruPJDsOqk5o8/6RzYcgXc9YXKzywsFidbz7+DKrLLzYZ7IVxYdF5nIUTw8+jdrN1NqkXfltTsg4+xgi/k4OPnwr1fd/GckBR8ysWYx30/hLE74Xn/4OxEW48oc/ClohqI4jbAg7Lpizm1ErdcQd9EwYM/w4QgeIselILPTleKxcCy6H0M8KlB58VZpSL8+AOqYv7Clzt/jcv/DGaPqJbIMGl1F7ymP4JhN4Wsu/NN0PPo3bghqQEV4CPaRWICvJ+U++BtCj7OOfj8vDphTjzo4jn6ewzJoncy5vHIfSqffO5LWnvNKBW8PiF5sZw3Xgqr1sOubzvrgdf4VeEbSoDfrG7tE+38tOjBXWCYHlMXHNv/wF2R3xnPUZ0PYbfM+ZWDj2LhjNv11H4vDqomM+0s/w7qPSZLFfEXMibA+0nZol8hOXitVt28GdyMjWwFN33a43tUAGj1mKJU8K2MXe3oUKtwH7wNHt+jltQM1plhb8dvi74rwABfqxdeV9H7hRtr98R+dTuyxd1rdHTApW9UewTG7nH33FbwKwcfxTQ73QfvlLhZ9BBZHt4EeD/JLwBi6R9jnHPw+pjcLMLQV6KBW/QuRqmO71ULZVpFK/go7DTdf+22yE6z7SqVq7z3a2pBjZNeer8qfMOy6GFpJX1uzr8qenAXGCasAO9k4mA1F71SHXdYLXP5RfV37YuCtyz6MAvt3PTBQ/AB3skueI1OuUVUSW8CvJ/oTXJ2y66zSymqWAZ4reDdBPiQFHyPwyK7YkGNB11zVuuv2ZUCZPgFUND64pTTngq9I8qKdWLPg38VvsUQqujTQ0qBaoteymiL7E4cUO/1gZM9vM6gmnj3wLfUcqGg8WMOvaYvCgWfdXe+CTzAO9gFr3GTagwAE+D9JDe/1J7XdPfGNAdv5dNdWfR6dWNYCr5JTnTyYSjl/VPwEM3FWDnAO1QG1XR2VdoDnRTYgWXR+xHgQ6iiB5WG0Qo+Nw9I/3PwTneJT+xX9rzXITuXXasK9e7+grfnu8GPOfSa3tWq3iXUIjuXy62CDPClojonGYu+DckvLO2B10S9paweWsG7suhDGnTTlVKKsJm1Nb5X3a71S8FTsZzDpJUiO832P1C3jhW8Ne+/1ZREGBY9LO2F93OTnCY9qAqinNQlnNjvPv9uZ2QLnHUl3H1Txe4PCj/m0Gs6OpRTFGqRncv11Okhdb4Nop5GXzi4KbIDY9Engtx8nQDfG9MAbx2Tm6vdWq2AQeFko9z4HnXri0UfpYJvMQcPsOUZcOm1lUDfjNSA6plv9fsNelStZvg0tZWtVPJ3F7zG6Tz6YkFdaHjJv9t55nVKEX7uCtj9veaP94qfCh7CnWYnpfvdF0EunHF7saRz8BH1wpsA7yf5xdoWfdwVfGbKuYor98EHnIMHZxvlju9TFeN+nOjLAT6CSvqMDwq+sxte8I9qV7wT/NooF/Q2Oc3q09RrzR0NOMA3ueCdfkSNBx5pMcBvuAje+HMYOR3+7Y/h1ne7273gFD9z8KAK7cIqstN/W54CfAA2vdufpdNUY0CYAO8n9Sz6uObgdbAuFSotfs0Iqw8e1NVvs+AzvgfWnu3P60XZ0pidVcWYtf5+gsKvjXLlAO/DVrdG2HvhA7HoHQaGiQPqtlUFD+qi5bW3wCWvVetmv3w1zB5r/eva8VvBh7ky1sv5JsgAbyz6NqauRZ+qFKfFCbtSdfpmKGRUkU3QdixYFn2D4FMqqWUfiQjw1qIZPzajOcWvjXKFkHLww5vV7eRBm4KPIMCXe+B9CPCg8ssv+ji85LPw6D3w2afDwdv9+dqgHDrR4V9LYZgWvRfHsPx7DGBlrFuLvqcfEMaiTwR1LfreaJeY1MMeyJy+GfJWRWsYgaiZRT99WF04+R7gI/hdeVk00yp+VfiGZdEPbwKEqqTXfxe+9sE7XBk7sV9dfLYyFrkWF74c3vBj9bW/9GKl6P2YybA4qb63Dp9O931r1HriUtGfr9cIreDjYtG7VfBCRLpRzgR4P8kvLB1Tq+lKVf5Q48SSAO/wzeB2bGQrNJuVrivo1/gV4CMssvOyaKZVdHBs9eQTVhV9VwoGN1gWfQA5+PJQkib50hMttsg1Yt25cO1PVcvjre+Gf3uV8/RZPfyaQ6/pXwPIpXsBgkJfbLutoodg8t5e6hn8GgntARPg/aRRH3wsFbztmJy2yhUywffAa5pV0R/XLXJJUPAedsG3il8WfVh98FDZC68vSny16PVO+CbvhYn9/uTfGx3HNV+G5/097Pke3N3ielm/5tBrytPsQrDpvczd0BdqgSj4Kejodlcr49e8CQ+YAO8n+YXaxSBd6Zjm4G3H5MaiD6PADppbW+N7oP8k6Bvx5/WibpMLW8H7VeFbzKkCwY7O1o+pGboXPjur8sp+FiV2pVQgaRQYinnVqudX/r0eQsCT/xzWn9/65jm/5tBr+kLcKOdlcmZPv/p7DMqiTw+5c2+MRZ8AigV1oqtp0afjr+DjaNHrIrt6++rH9/qn3iH6HHzYCt6vCt9izvm+7lYZPg1mHoPFEyrF4LdN3mwK2uQhNTsgSAVvZ9vVahXyzGPev4bfCj7MhTMFDzn4IHfCe0l3GIs+AegBMDUt+nR8c/A6b+rYonc5NrIVdMDL18hBSulvBT1EP6o27CK78pxsHwJ8GPY8WK1yEh7f7a89r2kWGPyuoG/G9qvUbSuDcPzOwYe5MlZfbLuduxFUgPfihuid8BFgArxflCe81aqij7GC7+6z9ic7tehdjo1shUYb5WaPqn3cfhXYQfSDbsJW8B0dlXG1rVDMhdM2CZUxvMce8LcHXtMsMLSyRc4La89WexZ27/D2/FJJvbd9zcFbKbFQLHqPczcCC/AudsFrjEWfAHSla90AvxjNGtJGFDLqjePmzVBYDG8YS6ONcn4X2EF0ffCFrNrIFnYOHqwA70MOPqwArxfpBFWUmB5sPOL0xH61EEjnocNg21Vw6HaYG3f/3Nysmq/vZw6+K6X+VsMI8F4nZ6aH3I+qdXJ+9mzRm0l2Kxt9pVmzDz6t3mSlAMZQtkIhq96s6WHnFr3b3cytUB6lWuPNMR5AgNeT2Aoels1MPwofPatyXG4oD22JIMCnHMz7b0YxH55FP3By5WIiEov+gBotG+ZAou1XqfPHHg82vd9T7DR9o+FY9F764MG6UHOzJTMH118Av/5s48e5WRWr0e+xCASeCfB+UbboaxTZaUs7bnn4Qka9cXqHXRTZZUKsom9g0Y/vVSfjVev8e73OLujo8qbgTxyAuWNw7H73z/Vj0YxX/LAPw1TwHR0wfKr6OCqLPix7XrPuPFh9ujeb3u859Jqwptl56YMH9xb9zJjqjrj13XD8odqPkdLKwXuw6EuFSFJ/JsD7Rdmir9MmB/HLw5cV/JDzHLzbzU6t0KgIbHyvyr/7raS60t4CvL548zL8w49FM17xo8K3mA8vwEPFpg/Eom+wE76QU9MTwyqw0wihVPzDP3f/9xWYgl8TzsIZL33woFS2mwA/PWa9XgZ2vKV2505uXgVq1xa9T/MmPGACvF80s+ghfr3wWsG7sujDVPANtp35uWTGTmePtwsx7eA4/TnaidSi96HCN0wFD5VCu6ACfClf222bPKis8rAVPKh2uVIB9v7A3fP83AVvp280HAWv++DdtmGmh1T3jR7C1Awd4J/+l/DIHXDPTcsf43ZMrSbCjXImwPtFI4s+7grelUVfZ5hPENQL8PMT6uQSRICPQsFnI1TwzcYBO6GQjUbBB2XRQ+33Q9gtcnZOuVitRd7l0qYPSsH3Wxvlgs4ra8fQrVPndie8DvC/99ew5Zlw63tg6vDSx3i9WIpwo5wJ8H6hLfp6ffAQvxy8LphzerVbzKshH2GOqoXlCrNcQX+O/6/ZlWpNwXvZYBXEbnOn+GbRh1RkB5W1sUEU2TWaRx92i5wdbdPv/293v6+gcvB9a5RzE/QAl0LWW0qwPI/eoXCZekTV83Sn4cXXK6fme3+x9ALG68/Sr5HQHjAB3i+a9cFDfBW80y1a5Z7UkHLw3b1qHGn1lW8QFfSalhW8hwCvVYZb688PfKmij8qiDyCl0ei9cGK/+rxfo5Hdsu0q1U657xbnz1k8of6m/Xbdwppm53U0ttt59NNjMLRRfbx6M/z+u+GhW+G+myuP8WzRN0g1BowJ8H7hKMDHTMGXc/DWH2yz4OS1J9Ur5VWLVW+M8b3q5zy40f/X9KzgWwjwUVr0PQMqQHtpDdSEHeDXngNnXQmnPtn/r93Ioo+igt7OpsuUynQ6m37hBNz7DTj5Iv+PpTzNLuBCO32OcovblbH2AA9wNU9tAwAAIABJREFU6bWw8VL44f+pzB9o2aI3AX7lkltQarNWMUisFXy6Yjk1s5fLCj6kQTegAlAti37NWf7tt7bjWcHrIjuPOfjOVHjz3O34YR+GbdF398Ir/w3Wn+f/126Ygz8QTf5d09EB57wIHrpNnW+accvfqL/HF37U/2MJa+GM17kbbgK8lFaA31S5r6MTrvqUSr3+4K+Xfi1j0bch+QUV+GoVg8Q1B2+vogcXAT4kBQ/KQq6l4IOw56F1Be81Bx+Fegd/KnzDXDYTNOXAUPV7zGdUEIhSwYPKw+cXVJBvxIO3wb1fh6e9XW2k85t+HeADtugLWW/nGzcBfmFCuav2AA9w0jmq6O6B/4Q9/1Vx59ymhlJGwa98cvP1lW2US0waYe+DBwcWvcee1FaotugzMzDzaIABPgoFH8GiGY0fFb5hW/RBUi8wTD4MyGgVPMBpT4PekcZDb7Kz8L23qTkRv/eOYI4jrIUzhYy3842bAD9tVcsP1Uj5Pe1tatDQ994OU4fUmGK3a5FNFX0CyC/WrqCHGAf4jEuL3sNu5lbpqSoCO/6guvVzyYydVhV8fsH986NYNKPxxaIPcZtc0HSn1cVKdXtVuYJ+S/jHZKezC855gSq0q/d3dtv7lNtw9Q3BOSs9/ercEUqRnYfzTc8qlTJ10ianW+RqBfjObvVznH9c1TN4KYTt6FTiz1j0K5j8Qu0eeKgE+HyMAnyxYLW8pZ1X0RciyMGnqradje9Rt0G0yIH6eRRbaJMD94V22dlohtyAPxW+SVLwUHvMaZQ98NVsu1qlVA78dPnnDt0Bd/0zXPYm2HRpcMcgRDjT7LwW2XV0qL9tRwpeB/hNtT+/4QnwlLcAEno9drr4MW/CAybA+0Vuvn47R3cMFXzBNiGqO62KvJoFJq+LH1ohNbj0jXF8rwomuhfab1rtgwf3efjsTHQB3o8K37BH1QZNrQA/sV8VlvndT+6FLc9QVnH10Jv8ohqzOnwqPOtdwR9H30jwRXZeAzw4n0c/PaZES6P2x2e+E0bPqH8R0Aw/5k14oCv0V0wqDS16K/DHMsBbbx4n0+y87mZuhZ5VauWlZnyveqN1BvSn22ofPLjPw2dnosvBpxrM+3dKkix6qKPgI66gt9OVgrOvVNvlip+o/Ox/9mGYeAj+5NvBDAGqJoyFM62MxnYa4KceUfZ8o2l53b3w+h97333hx7wJDxgF7xf5+foWfWcXiM6YBngrR+dk4UzYffBQsej1RKkgK+ihNQXfv1Z97Naij0MO3qu6kNIK8Ampoof6Cj7qCno7265S79eDv1D/f2wn3P5JeMKrYOsV4RxD35oQiuxaWG7ldOFMdQ98PXqHvQ+jSg2aIrsVTW6hvoIHdQUYpxy8DmL6zeNk4UwkffCrVK1AIaNef/JgcAV2YAV4jwp+4GT1sRsFL2W0bXJ605XXk48eb5xkBZ9bgNnH4qPgAc74fSUodu1Qv4Mdb1aK+rkfDO8Y+teE0AffokXvpP3TaYBvBWPRr3CaLWHxGjiColBVEd87DHOPN35OJH3wNoU5exSQASv4tNraVSy4SwPkF1UAOHqfuxx8fkFdwESVg+/sUt9zzuPJp2hNwEtSDj41uDQwnDigbkdOj+Z4atHdC2c+R9n0g6fA0d/By77q/1KZRvSNKNs5nwnunFBo4Ws7sejzGVUh7zW37pTUKu/vsRYwCt4vGlXRg8rDxzHAlxW8G4s+5D54UAH++D71cdAWPbivpM8vwMA69bEbBR/lohlNaqAFBZ/AAF8dGE5EuGSmEduvgvlx+MkHYfsfwLYXh/v6uhc+KBXf6nKr1GDzAD/zqLoNPMC38B5rARPg/aKZRR87Ba8tep2Dd2jRd3QFV+BWC/tGufE9qrd19IzgXs/rWOH8ojrW9JC7HHyUi2Y0rdiHSbXoC5lKSm0iRi1yds58rqp9SA/DC/4x/NcPeuFMq46htuhLxfqPaTTkxk+q53mEhLHo/aCYh1K+cW46djn4GlX02RkolerPePc6VaoV7Ap+fC+sPj3Ysaj6a7u5GJOyMqo4PbwCFXwLJ5+kKnhQ74futLLo+9dG1+lQj9QAXPVJVfux6qTwXz/oaXatFvXaf4/1UheNhtz4SWpAfT8h720wCt4P9C74RgE+9gp+SO1AbpQnalZnEAQp25jH8b3BDbjReJk6WK5n6FUnEjc5+PImuQiDRysVvokM8FWDn+LUIlfNhS9XffFR0B+wRe9XgG9k00+PAULVMQRJRBvlTID3A20lNbTo456DdzDNLshimnroKu/FSZULXXtWsK9XVvAuLHp7d0GvWwUf4apYTc8q78tmdIDvSlKArwoMcWuRiwtBb5TL2y6cvVD+PTb42546DAPrg//7jWijnAnwflDeBd+oyC5mCl6/eXRA0xO6GuWPC4vRWfRH71PV7XFU8OXfv6Xg3eTg9RV9lPavseiXon8XmWnlbMwdhZGIZ9DHkfSwmu8RmEXf4uRMRwr+cPD2PES2Uc4EeD8oW/QNgl/cc/D11mTaiULB6zfG2N3qdk3MFbzbHHwmLgq+1T74JAV4W2DQLXJGwS+no8MaVxtUkV2rFr3tQq0eYfTAQ+vzJjzSNMALId4shAixuXIF4siij5mCrzXoBppY9AvhDrmBiity5F51G3iA91BFrxV8T18lB68n7zWjXGQXpYJvYRFGWcEnrIoerAAf0wr6uBDkNLvqWR1uaabgpQwvwJct+vgp+PXAXUKIm4UQVwrhdRhvgslrBb/C++ChiUXfwlQpr3R0KIVZzMLQqcHP2G5JwfeqVEep4Nzyzs6ovxu3O6b9JDWg7NBiwf1zE2nR2wJDuUXOWPQ1CXKaXatzN5oF+PnxynklaOJq0Usp3wWcCXwB+FPgQSHE3wshzCWtJmdTcPWIrYKvysE3LbILOQcPlavfoAvsoDJT3c3vyt5FodtxnObhsxHOodf0tLBwJokWfXefmvegLfpV68NZ3rISCXKjXKt98KkmFn1YPfBgq6KPmUUPIKWUwFHrXwFYDfyHEOIjAR7byqFcZLXC+uA7uivKsWdADZFplINvZfFDK+g3R9AFduDRorcpeJ3qcJqHz0S4SU7TSoVvEhW8EJVpdqaCvjFhWPRezzkdncvHDtsJqwce4ltFL4T430KIe4CPALcD50sp/wx4IvDSgI9vZeAkwHelVIB0mpsNmkJ26Runo0O9GRopz/xi+Dl4qKinoPPv4G3QzZI2OUvBO+2Fj3LRjKYV+1BfCCUpwEMlMJzYb+z5RvSvURezjabFecWP7ZWN5tFHEeBDVvBOJtmtAf6XlPKQ/U4pZUkI8aJgDmuF4cii71WDZEqFeBQkFTLLJ8I12wmfXwy/ih5sFn2YCt5rm5xLBZ+dibbADlqr8E3iqFpQgWF6TOVpjYKvT98aQMLCCVi11t+v3WofPDSeRz89pupfwljQ09mt0n9e5014xIlF/33ghP6PEGJACHEZgJRyd1AHFimlEkwegrlxZ4/PO5xkBxW1FzXVCh6s/ckxK7KDSgAKIwff8qAbtzn4OCj4Fip8k2jRgwrwunPDVNDXp29E3QaRh2+1Dx4aK/ipR2B4k0rJhEEr8yY84iTAfxqwH9W8dV9yKebg+gvgnn9x9vjcghr40Ogkp69C3S4xCYrC4nIF32hRipSWgo+gyK5/DQxuDOdKu1UFvyJz8C1Y9EkO8Pr3ahR8fYJcONNqHzw03pIZVoucJoKNck4CvLCK7ABlzZP0JTXdaTWGcfYxZ4/PL0JPf+MrwbIyjLGCb2TRF3OAjCbAP+td8CffCue1OrsB4U3Bd6XV30FHt8scfNQWfQsVvkm26DWrY7QHPm4EuXCmkFEXjvWWXzmhWQ4+zADf08K8CY84+ckdsArtuq1/bwUOBH1gkTOwAWacBvj55sVnXXFT8DVy8I2udrWaCXtULahNWWHY86Au0rrS7hV8d596rhDO59GXrOU+UQd4P6rog9zwFwU6wA9saFxb0+4EqeD92F6ZHqo9iz6/qI45VAUfT4v+TcBTgEeBMeAy4NogDyoWDG6AmUedPTbnYMuaLk6LfQ6+ztVuvsWpUiuJrpR7BW///TudR5+LwapY++t7KQAqJrSKXgd4Y883Ri+cmQ8gB+9HUW95J3xp6f3lCvoQhtxoWpkY6ZGmVruU8nHg5SEcS7wY3ACP3uPssdqib4SX/uogKWSWB5beYXV/rZnz5YKXCBR82LhW8FXtg07n0cdh0QyoC5qO7tYs+o6EZe10gDctco3p7IbUUEBFdjVcRrekB6012HNL32dhDrnR9KyC7P7wXg8HAV4IkQZeB5wLlM/6UsrXBnhc0TO4QVk4ThasOLLodYCPi4LPQH9VW4t94Uz3+qWfazcFr61nJ+QXliv4uaPNnxeHRTMar/ZhMafUe9ImWBsF75z+0Xhb9KCcySUBPsQeeE1MLfqvoObRPw/4GbARCNdniILBDep29kjzxzqx6GOn4LM1cvANxtXaW8GSTqsK3mkOPhsTi14fg1cFnzR7HmwK3gT4pgQ1zc6P7ZX15tFPj6nJnfo8HwY98ayiP0NK+f8B81LKLwEvBM4P9rBigJsAn19obtHHLgdfo6e90U54P3pSVwpdPe63yS0J8KthscHAII3OeaeGGj8uDLxW+BZzyaugBzj1cnjCq+D0p0d9JPFHb1D0m8KivwreztRhGDg53L/d1IBye4OY+lcHJwHeSrIxJYQ4DxgCNgd2RHFh8BR166SS3ska1RWv4H2YKrVS8FBFn+1I8byP/5xDE/Pq55idbv5GzsbNovca4BOo4HtXw9U3Lm2XM9QmqOKxvB85eOv3V11AOn04XHseKvMmQrTpnQT4z1n74N8F7AB2AR8O9KjiwMDJ6tZJJX1uoXkrTdxy8PkaCr4c4NtdwaddV9HPFrrZe2yWe8embfPom6h4nYOPusgOrAIgDyeeQq6ygc/QnqQHa7eitUrBh+2VjSz6sAN8BBvlGgZ4IUQHMCOlnJRS/lxKuUVKeZKU8rMhHV90pAeVbZlYBV+nDx5qW/RtlYN3udo3v0BGqJ/libms83n0scvBG4ve4IGgFLwfo7FTNQJ8qaSEW+gKPvyNcg0DvDW17s0hHUv8GHQ47MZJgI9TDl5K1b9cLwffsMjOKPhl5BdZkMqmPjGfcz6PPjsDiMqVfZS0WkVvaF9Sg+p84rd4yfuh4GvshJ8fV3+3Q5ta+9puKc+bCK9G3YlFf6sQ4h1CiE1CiBH9L/AjiwODJzcP8IWc2hDn2KKPgYLXx1Ct4Du71Xalmha9ngvdDjl4twp+kfmSCnIT8znn8+j1mNo4tJh5rfAt5o2Cb3f0JEa/A1etfRluKZ/TbAG+3AMfcoDvaWHng0ecTKfQ/e5/brtPAsmfADF4Cuz/SePHlDfJNami7+xWC2nikINvFKzrLZwxCr4++QXmSyrILVHwzSqLs7PxyL+DUhe5WWVfupn9bRS8wa6S9ehaPyhk/REU1SO4oxhyA5FY9E4m2bXvpoXBDTB3DIoF6Kzzo8rZNok1w23gCIp6Ch6shTMNArxR8Esp5qFUYKaoAvzEfM55Dj4zHY/8O1QqfPPz7o7JBHhDUNazH6NqYfk8+iiG3ACsPQf+4oHlA8YCxMkku1fXul9K+WX/DydmDJwMsgjzj9cfiKADX7M+eFB/rHHIwZcVfI03T7159IVFVS3dymanlYKbCzFrCc9Mwabg0w3mCdiJwyY5jb3C122Ab4fWSUN9yha9j5X0pSKU8j4qeLtFP6ZSUmG3QHb1hH5R4eRs/STbv6cD7wWucvLFhRBXCiH2CiEeEkJcV+cx1wghdgkhHhBCfK3qc4NCiEeFEDc4eT3fcdILX7boHVSXu+2vDopGCr7eRjk/pkqtFNwoeOuCbarQCVgBvqtHpWya5uBnYqTgrZO0W/vQKHhDEAq+7Bj60IKZHlwa4KcOw/CmeNS+BIwTi/4t9v8LIYZQ42sbIoToBG4EnoPaQneXEGKHlHKX7TFnAu8EniqlnBRCnFT1ZT6AGo8bDVq1zzwKXFL7Ma4t+jgE+AYKvncYjj1Q4zk+TJVaKXSlVeCSsvlJwFLwkzn1VppcyFEsSTqdTPfKzsZn17i26N2qsKSOqjU4Jx1AkZ0WIX64Q+khOP5g5f9RDLmJCC9+6wJwpoPHXQo8JKU8IKXMAd8Arq56zBuAG6WUk1DeXAeAEOKJwDrgRx6O0R/KCr7BuFqt4J1Y9F3pykS4KCkr+FoWfT0F71M+bCWgVYMTm95SGidynXQIdU0wtZBzNo8+MxOfIjuvQzhMH7xBuz9+Drvxc7BWLYu+TQK8kxz8d1FV86AuCLYDNzv42qcAh23/17vk7ZxlvcbtQCfwXinlD60BOx8D/gT4fQevFQx9Iyrv3GianZsBMN1xUfAN7K/0sLU/uQgdnZX7qxeqJBk9ma3gZJOg+lkez3WxaaSPQxMLnJjPMepkJ3x2NkYWvccxmsaiN5Qteh8DvJ+jsXWAl1I5bosnTIC38VHbxwXgkJRyzMHzanmbsur/XSg34JmoLXW/sObdvwr4vpTysGhgkQohrgWuBTj11FMdHJJLhGjeC68teqcKPhYBvoGCtw+76bONO/BjqtRKwZWCV7//hVKKLWv6OTSxwMR8jjPTQzDRYPdzMa8utOKwaAa89zKbPnhDV0pdFPsZ4BuJELekh1SxdH7BVkEfQLyIIU4s+keAX0spfyalvB2YEEJsdvC8McA+SWAjUB0px4DvSCnzUsqHgb2ogP9k4M1CiIOoC4xXCyE+VP0CUsrPSSkvkVJesnZtQK0Hg6c03ihXLrJbiTn4OkV2sNym92OqVIQcGJ+jUCw5e3B5KJGD35Wl4BfpYetapYLLvfCNcvBxGlML3odwGAUfa+ayBR6dCqFzx+9xtWUR4pOCByVaouqBjwgnAf7fAfuZsWjd14y7gDOFEKcLIXqAl6OW1dj5NnAFgBBiDcqyPyCl/GMp5alSys3AO4AvSylrVuEHzsDJ/ln0ccvB1wrY9TbK5RdWrIKfzxa48hO/4Iu3H3T2BDcKPqcu8BZJscUK8OVe+EY5eP3zjUsO3qtFb5bNxJrrb9vHS//vHcG/kN8LZ/wcrJWyDeKJqgc+IpwE+C6rSA4A6+Oml+xSygJqjv0twG7gZinlA0KI9wshdJvdLShHYBfwE+CvpJQTbr+JQBncoIrsZHV2wcKNRR+bHHwDBV9vJ7wfm50iYmoxT65Y4ucPjjt7gkcFv2Wt+hs4MWcp+EKm/tyDuCn47j4QHR4VvLHo48r+8XmOzmRYzAW8g9x3Be/jaOwlCn5M/Z3rbaEJx0kOflwIcZWUcgeAEOJq4LiTLy6l/D7w/ar73m37WAJvt/7V+xr/AvyLk9cLhMFT1CKFhRPQP7r88/l56OhydpLr6o1ZgK9TRQ81FPziig3w89kCAHcfnCRXKNHT1eS61s3eACsHn5Ep1g6kGEh3cWI+C0O2C6VaP7fyLviYKHghvM2jNxZ9rHnMsuePzWTYvMaBCPFKatDnIjs/c/A2V3J6DAY21J9MmjCcKPg3AX8jhHhECPEI8H+ANwZ7WDFiSS98DXILzefQa9wuMQmKhoNu6uyEX8FFdnNWgF/MF7lvrEllO9gsencKfri3m9H+Hk4s5JvPo4+bggf3G+VKRVW8ZAJ8bNH596MzAZ93UoPx7oMHFeD1kJs2oWmAl1Lul1JejmqPO1dK+RQp5UPBH1pMKAf4OpX0+YXmm+Q03b0xycE3GXQDyy36BCh4gF8dcJABcqXg1Qk0Qw9Dvd2M9PcoBd9sHr0+GYY9LrMRbm3WYl7dGos+lsxm8sxm1N/+saADvN85eL/74KFSZNcm+XdwEOCFEH8vhBiWUs5JKWeFEKuFEB8M4+BiQTMF72QXvCZuCr6W8uruUymHBFn0c9ZJLt3dwS8dBXg3Cn6BguimL52iq7ODkf4UE3O55jvh9c83Tgq+Z5XLAG+V5hgFH0uOTFf+fo9OB63gB2LcB2+lwRYnlVAzAX4Jz5dSls9S1tS5FwR3SDFj1Tq15rVeq1zOTYDvVZamVj5RkV9UV8a1ZgwIYS2csQWmUknVIazQUbXaon/aGWu4++Ak2UKTgiOXRXY5kWJ1nwpyo/09VQtnmij4OAV4txa9DvB+5EkNvmNvjzs2E/AWS23R1ytGdoufffBdKXXuOv6gWmBjAvwSOoUQ5Z+yEKIXaJ93dEenCvJ1Lfp55xa9G2UYJIVs4zdO9WhHfbwrdFSttuifvW0d2UKJew/X2JZnx+Wgm6xIMdynbOqRVT1MLuSQvXVqGTTZGejojlddQ88qd0V2ZQVvLPo4ogvs+ns6g7foUwOVYTJ+4GcfPCgVf+x+9XGbDLkBZwH+q8CPhRCvE0K8DrgV+FKwhxUzBjc0sOhdjHDVdlPUefhmBXO9w0utZT9bViJg3moReta2kxACfrm/iU2vfzZFZzn4RVIM2xR8viiZkX2AqG/R6zG1cdpo5bZQylj0seaxqUU6OwTnbhgKocjO541y+UWrO8mnavf0EBzfpz42Cr6ClPIjwAeBbahCux8CpwV8XPFC98LXIrfgrAceYqbgGwT4aos+72JjXgyZyxbo7hScNJBm+8mD/PJAky7PLitgOSyyW5Cqgh5gpF8998RCofGwmzgtmtGkVkHOS5GdCfBx5LGpDOsH02wYTgefgy8XsvmUhy9k/BUU6SEoWcW2JsAv4yhqmt1LUctfdgd2RHFk8JTGFr3TwKf/YCMP8E0UfLVF72fBSwTMZwv0p5QSuHzLKL95ZIpMvkEe3lUOfoG5Ug+r+6oC/Hx2+YWSnTgtmtFoi95pHtVY9LHmsalFThnuZd1QmsdnM0i/8uO1CELB+1nboS9AUkPxu7AOkLoBXghxlhDi3UKI3cANqM1wQkp5hZTyhtCOMA4MnqyUTa2rUzcWfawUfIM3zzKL3seWlQiYyxTo71EB/slbRskVSvz2kQb98J3Oc/Ayv8hcqZuhskWvnluupK9bZDcTn0UzmnIe1eHscmPRx5rHphfZMJxm/WCafFGq4s+gKC8ralLf4pRC1l9BoQN8G/XAQ2MFvwel1l8spXyalPJTqDn07YfeC1+rkt6NRb9ScvBaeeor/hWu4OeyBVZZCv5Jp4/QIZr0w3d0qKDl4EKsmJ1nUaYqCn6VVvC55RdKdrIz8VPw+nicVtIXTICPK8WS5Oh0hg3DvawbVO/1QPPwfiv4wqK/gkIH+Day56FxgH8pypr/iRDin4UQv0/tFbDJp14vvJQuLXqtDEPY7tQIJ1X0pUIl965vV6iCn88V6E+p3fZDvd2cu2GoeT98V9qRgi/l5snQU66iH7Us+on5JgreQw7++FyWG/77Qedb8dzidqOcUfCx5fhclnxRLgnwgVbS679lv3Lw+Yy/XTvaYTABXiGl/JaU8mXAOcBPgb8A1gkhPi2EeG5IxxcP9GKC6jx8IQuy5K4PXj8vSpxU0UNFfZbb5Bx+nzFjLltkVbqSJ37y1lF2Ns3DOxxKlF9kUaYY7lVBLt3dSV9PZ6UX3scc/I8eOMZHf7SP3zRKL7SC241yJsDHFt0Dv2E4zfohHeADPO8YBR9LnFTRz0sp/1VK+SLUTvedQDSrW6OiXoDPu9gkBxXV7DTHGRSFTHMFD5VCOz9XN0bAfLbAKkvBA1y+ZYRcscRvDjVY5+pQwYv8oppD31e5gBjRw256V6uLpOriJimtAO9OwU8uqIB696ETrp7nGLcnaTOqNrY8Vg7wvZw0oN7rgVbSl3PwflXRN+n0cUs5wJscfF2klCeklJ+V8v9n783jJDnPMsEnIo/I+6jMuqu6q0+1+lK31LKFLVs2tpHlG7BhsFnGnt1hYJdjPLNmYbEB25y7vx1gsGF2MMcwDAxIY7CMDUayZXRZRt26Wl2S+qzuurquPCqPyIzIyJg/vvgiIzMjIr/Iq7LU+fx++kmqysrKyiPe73nf530e9Xt79YAGEh4fEEhaF3ine/CDzuAbA2fsvOt3AQrlmsgOAO6eG4GL5+zb9IwMnq/U78EDpE2vZ8KrSnPBrJSIo5ZDBp8VSUE9u2BzMOkEXlrghwz+paUMPvjFp3pvENMjGAu8x8UjGfL29m/hXSR0q5sq+l6I7IYMfghTRKaaC7zksMAP1AzeQYv+dbAHT9fkACDs8+D4dNTe8IaFwVercFXLKKG2JgfAEDhD/egbCnKbNrVpTQV9diGFarUHK0/DFj0AIFuU8ZN//hxeXMzghcUejUN6jJVMCWHBjYg2mhqP+HpvduPrYmRst9MrD70LePsvAtNnunefuwDDAs8KswIvF8i/ma1qB4nBO2nR714VvaqqWou+3hHrnv0jeHEpg6JUMf9BFgZfoUlyAsI+Y4EXkMpLzZ0QCipEcpgkl9EY/HapgssbDnPbWaC36Bkv0q/DFr2qqvj3D76gF8Pl9A4fxtvESkbEVKz2eZ2I+PrgRx/uosiuBzP4+37ulsmBpxgWeFZEpoBcY4Gns2mHDH7HZ/AtdkybWvR0D373FXhRVlBVUcfgAbIPLysqzlnN4VkYvPY6qh4/XHxtwSQRIi161SoylhZQhww+U5QwpQmmnl3owRxeV9GzMnjqF/76iab4wyeu4tFX1vHp994Ov8dVF9iym0B34CnGo77++NF3TWRX3rWan0HCsMCzIjIFFLfqd9glhyK7gZrBO2Xw3K68kNMkuZCvvsDrc3irNr1bYCjw5PXnGw54I0EvypUqRBeNqWxg8HqBdyayyxRlnJyJIRkSejOH9zpt0b++rGrPLqTwW//wGt5zYgIff9McpuN+LKW7FJ7SZ6xkSpg0MPjxsA+pgtQ6SbETCN1s0Yu7klAMGoYFnhVhbRfeyOJpi561de3ykOjZnZzBKxWy427X/uJd5MNqnMFbxcsOOAplckEzqugBwuhPzkStDW/V1hebAAAgAElEQVRcDC16jcG7hPoDHrWrzaja17s1gy/KiAc9uHsu3hslPc87y4R/HVnVbuXL+Km/eB6zcT9+8wdPguM4TMf8u5LBi5KCVEHCtLFFHyWH8/Ver8p1TWTX5T34WxTDAs8K3ezGWOAdtugB5vUrJiw/B7z6dWc/w9pWNe5wV0q7cv4O1KJijSp6iu/Zn8BLS1n9NnVwwODdvvrXn5rdbCja1y1n8OwMXlVVZEUJsYAXd+2NYzEl9mbtqa0Cv7sZvFJV8W//6gWkihK++LE7dWHadNy/K2fwK9naDjxF38xuujGDr1bJdWqXbu0MEoYFnhXUrtaYKidRkR1jix4gp9JOZ/CqCnzn94E/ehfw1Z919rN6znKLD48xcEbevQVeb9ELzQX+nv0JVKqq+Tzb7WNm8F5/PROnDH6rxJFOgCWDZy/wBUmBrKiI+T24e24EQI/24YXQLdei/+Jjl/HEpU38yvuP4dhUTfg4HfMjXZSthZgDitUMed9ORY0Mvh92tQ7jhq2gMF6jhmiJYYFnRYSa3RjsattZH+uUwZe2gQc/DnzjF8iMyukHih4uWjF4o496t12l+oh8SWPwJgX+zFwcHheHZ66aFXh2Bu/11R/w9MCZgmzuR9+GyC6jmdzEA14cnYrA73H1bg7vZA+e48lIZ5fiqcub+O1HL+JDp6bwI2+oN0GZiZPP9W5j8cYdeIrxsFbge212I+WAaodzfr0z2j1SsZ4r4VcevmDvXvk6xLDAs0IIkzewsUWv78E7YPBuX/sz+LV54A/fDrzyVeBdnwPe9FPkvhQHDIPVtMYXrbWWu2060UcUJOsCH/C6ccdMzNzwhoHBV8rk9fcHGhh8XeCMiR99eZsczhzMrjNFwpajAQ88Lh6nZmM9YvAO5qiVci15bxdifbuEn/3vz2N/Mohf+/4T4Bo0JnSGvbTL5vDLGREcV2PtABALeOB1871t0TsNK7JCD4y1Hjq3hD99egFPX9ns2n3uBgwLvBM0rsrJRdKedLJb2S6Df/GvgC+9gzD4f/kw8Oafbe8DVXEygzdY1e7SAm/XogdIm/7l5SxyJbn+GwwMXiwQJu4Phuq+HvS64HXz1n70bQTN0AIf1xzz7p6LY35lW//7ugYh7KxFv0vb8xWlip/+y+eRL1fwBz96l+kBcHoXM/ixsACPq3Z55ziu97vw3Qqc0buM3Svwj1/cAAC80KschwHFsMA7QaPZjVx0HsDidAZfKQN/90ngb34cmDwF/MQTwNy95HtO15oA9tNxXYu+y65SfUTBYk2O4nsOJKBU1eZ2N2XwjT7yBogF8rwHQ/UMnuM4g12tGYN3HjRDfeip5/2ZuRFU1R5csJyK7Hapgv73v30F372Wwq9+6AQOj5u/FmNhH9w8t+uU9GQHvvlAPtFrN7tuBc7Qg3WXVPSFckX3u3h+lzoTtothgXeC8FRzi95pgXfC4NPXgT++Hzj7x8Cbfgb4l18FwhO17wsOjUkAByK7GFkDVORdzuDJzC3gMZ8T37knDq+Lb27TuwUAak1IZoJSkTzvoXAzG68FzsQAMVv/zTYKPHWxowX+9J4YeK4HhjdOWvSKtCsZ/PWtAr7w2GW87+QkPnyXtTe5i+cwGfPtQgZfMi3wYxGhxy16GjjTaYHvrrHWM1e3ICsq9ieDeGEx0xub5wHFsMA7QWQKyK/VZt5ygd2mlsLJDP6vPgZsXQF++M+B7/t88yhAZ/AF9t/vZAYPkDb9LmfwQa8LPG++w+/3unBqNtZseEP/Xps5vCSSAh8JNxfrEVsGv+3c5EbzoaextGGfB0cmIt2fwwsag7fpXOhQ5F3H4FVVxS8/fAFeF4/PvO9oy9vvtl14VVWxkhHrduApJiI+3MyWoLK8tu2gW4lyujV2d645j1/cgM/D4xP37kOuVMHVTQfXy12OYYF3gsgUyX/Pr5H/l8XeMfhqFVh/FTjzr4Db329+G73AOzgxs87gjYEzcnHXMvhCQ9CMGe45kMCFlaye1gbAEAxk/VpJpQIUlUO0YQYPkF34VKFMOiFSrr4T0CaDp7N9irvn4nj+RgYVperovmzhHyFJdyyHxl3I4L9xYQ3ffm0D//adh/TdcDtMxwK7isETt7qqbmlsxETUh3Klim2xR2t/vi4V+C6L7J64tIl79idwzz6yXvr8jR6lMQ4ghgXeCRrNbqRC72bwxU1yoaX792Zoq0XfBoPfxXvwOZOgmUbcs5/Ms5+9ZmDDDAxeKRdIVGyoucjpgTM0Ua5kaNOXth0HzaSLUl0kLQDcNTeCoqTgldUuuYcBQIBcBCEydAZ2WYEvShV87qsXcGQijI+/aY7pZ6bjfqzlSpAqXTxE9RArdAfehMHTA03P5vD00NqpyK6LBX4xVcTVzQLecmgUB0ZDCAvuXZsQ2A6GBd4J9AKv7cLLxTZb9AwfMPo76O80Q1siOwcqegAopbUW/e4s8CwM/s49cXjdfL1trV7grRm8IhVRghdhk/tPhLwoSAokr4kffRsMPluUEfXXt8PvniOHh67O4QMJ8u+iTZQuhSIB7t1T4P/jNy9jJVvC5z90HG4X26VvJuaHqvZmfzxblPG1l1Zb39ABlk124Cl6bnbTLZFdF/fgn7hE1uLuO5wEz3O4YzaG528hJf2wwDsBZdM57UPZdouepcBrv8OuwLfzgaowrqDUtejFXesLbRYV2wifx4UT01G8tGxg2bRwKdYFXpWKKHO+pv1poLbOloN2CKNz+Gq1vRm8SHzojZiM+jEd81sn4rUDv8bgWQv8LmHwl9dz+NITV/Hhu2Z0J0AW0FW5pUz3Q2f++uwi/o+/eA43trp332YmNxTU7GatV2Y33hAAbqBa9I9f3MBU1IcDo+RzeHpPDK+t5SBKt4bhzbDAO4E/Tt50lF1LBWc2tQD5edkJg7dp0dPf7Uhk58CqFgCKKTIq2KUMPl9WWjJ4AJht9B1naNFDFiHz5p2QpsAZ3TSoAEBta02OCuyMODMXx7MLqe4Jp3QGz3Bo2CV78Kqq4jN/ewEBrws//8ARRz9LxWq9mMNfT5HP7YWVbItbsmMlI8Ln4REPNIsfxyLkvdozJT3HdceutksFvqJU8dSVTbzl0Kh+CD81G4NSVXF+uXvP+SBjWOCdgOOA8GRtBt+O+MzDyuBXAN4NBEdt7itArELb2oNnbNHnb2q/a3cWeMLgW1upTsf9uLldqgnWGER2XEVEhTe/CCW0ufxWtSFRro2gGYC0c2MmF+0zcyNYz5WxmGIrQF987DK+/NyS9Q0CThl8/WNSVRWf/7t5PH15cBzDHn5xBd+5uoVPvfsIkiFnznuTWmBLL5T0S9qh4cJKlyJWUduBN+sq+TwuxAMeRy16VVXxKw9fwHOswrRuBM50SUX/4lIGuVIFbz1cu4aemiXXtVtFaDcs8E4Rma61z6WiM5tagJxKVcV2vxoAKfDhSRLhaQWOc+YdDrAzeI+P3Ca3+ws8C4OfjgWgVFWs5RqeH5vDGF8RUXGZPy+UwW9UtPuhM/g2omJVVUVGNC/wTubwz1zdwv/7jdfwX5+5bn0jXwwA17bI7qWlLP7oyWv4i3++0frn+4BcScavfe0VnJyJ4qNv2OP45wW3C2NhoScMnhb4+dUuFvhMyXRFjmI84nPE4JczIv706QU8eHaR7QeEcBda9N3Zg3/84iZ4DnjzwYT+tURIwJ6RwC0jtBsWeKeITJH2uaq2L7IDWrP43Ir9/J3CG3K4JlcinQEWe11ftKY32KV78HmGGTxgYkvKwODdSgmqxcGHRsbeLNMCrzEGPWiGXUWfK1egVFV9rm/E4bEwwj43zraYw8tKFb/0lZcBAAt2e8AuN9FfsDD4SjODf/AcKQSD0gL97UcuYSNfxuc/eBwuCy+EVpiOd38XXlVVLKXJ7L3bLXpjilwjxh262dHuwktLjI9RiHRnD57jO/ZYePzSBk7OxJq2T07dQkK7YYF3isgkKXqyCEBtT2QHtJ7DUwbfCt6gcwbPWqx9sV3N4GWlinKlysjgtQJPxVQMBzFPtWT5+kd8Hrh4DltiFfCGazP4dpLkClrQjL/5gsfzHO7aG8fZFgz+T566hotredyzfwTpooxs0aaD5B8h2otWUKS6sJmSrODhF1bgcXG4vlW0/x19wPzKNv706Wv46Bv24A6tNdsOemF2s5mXUJKrmB3xY227jM185x7x5YqC9VxZHyuYwakf/bxW4F+7mWNLYnPihGgFaqxlMmZgRbYo48XFDN56KNn0vdN7Yri5XcJqdvf4G7SLYYF3isg0ubBltZZVO3vwgD2DV1VS4O0EdhRCyLmTXav5O4U/VmPwu7DAUx96RwWekcGXKwoEtQzO4nnheQ7xgLc5Ua6NFn1GrEXFmuHuuRFcWs/rkbKNWM2K+J1HL+Gdt4/hE2/eBwBY2LJ5zwQSjDP4epHdP86vYbtUwb+6l/yOnWTx1aqKz3zlZcQCXnzq/ts6uq/puB+rmVJXLU4pe7//KLGenu/CHH4tS96rZgp6ivGoD5v5MmRGcyQ6PqhUVbx6k6Fw+7oksuuwY/jUlU1UVdTN3ynoHP5WCJ4ZFninoG3zzUvk371o0ZeypP3P3KJ3KLIzfHiubuRRrliczH3RWmHahS16mrRmtqfeCL/XhUTQW2NqLV6nrCjDz5XBC9YajFrgTLQ2g29DZJcu1vvQN+KuvWQOb7Uu96t/9wqUqopffv8x7EuSx2tf4EcczOBrj+mhc0uYjvnxb956AMDOFviHnlvCuetp/PwDR5patE4xEw9AUqrY6ALLpljUDpLfd0wr8F2Yw9P3rt0MfiLig6oCGzm2v2V+ZRtntPcX0+sphLsjsuuQUDxxaQNhwW3auTk6FYHXxTuew2/ly5aH6EHFsMA7BS26W5fJv9tt0dsVeKrSZynwQriNFj1hp6Kk4IHffQJ/+tSC+W19hg/HrmTw5ODCwuABwtSW0o0F3vxCmCnK8EOCy+aAVwuc6ZDB60ly5oXqjpkYPC4OzzYm4oHsAX/t/Cp+6u0HMTsSwJ6RADgOuGY3hw8kHLToyWNazYp44tIGfvDOaYwEvZgd8eP88s4xpD9+8hpOzkTx4Tutw2RYMUNz4bsotKMM/thUBNMxf1eU9HY78BTj2qocyxw+U5SwnBHxzqPjGAl6cX6J4fXsypqc2BGhUFUVj1/cxJsOJuoicykEtwtHpyKOkuVUVcX/8kf/jHf/zhPY6uJBr9cYFninCHdY4GmhtJvBOynw7YjstA/PZr6McqVqLTgx2qnuYgYfZFiTA4AZo5hKb9Gbv06ZggQ/yvD4rBn8SMjbnAlPZ/BeJwXensH7vS4cn442zeHLFQW//PAF7EsG8eP37QdAVqWmon57oZ0/7rhF/+XnlqGqwIfvmgUAnJyOsQuzeoD1XBknZ6KWIUNOoAswuziHX0qLGAl6ERTcODoVwXwXhHZ0pjxp4kNPQe1q1xkKPB0bHJuKECMoltdTiJAC3WpLyA5OdEImuLpZwHJGxFsOWa8Yn5qN4fxSljnH4fxyFvOr27i5XcIn//rFXZNINyzwThEaAzhXrcA7btHbFw4AbDa1FN6gsxm8XJvBU2GPZXvQb2TwDv/OAYCeBc/K4GPE7EZV1Zp4zIrB5wtwcSoEf3PQDEUi6CWn/UYG7w3brz82/i5a4E1EdhRn9sbx0lK2Tgj1n//pKq5tFvDZDxyD4K4dcuaSAVyzc08LJMj7U2rhsKa16FVVxYNnF/HGfSPYkyDvkxMzUSylRaQL/W9pKlUV6aKEkQ5b8xS9MLtZTBUxqx0cjk5GcHWzgKLUWQjMcqaEZMgLn0U0MmCwq2Vws6PXhaOTpMBfWs+3Ftp1w662Q+fMxy9uAADuM5m/U5zeE4MoK3htje1xPnh2CYKbx//17iN4/OIGfv/bl9t+fP3EsMA7Be8i6nadwTvdg9cYvF2Bz60C4IDQhPVtKASne/A1Br+VJxffG6kitksmJ+66Fv1uZvDsBb5cqWIzL5F1Md5t+ToV8uTiJwRsGHzQi+1SBYqgzeBVVQuacWZyky5KCAtuW//0M3MjkJQqXtbmpIupIr7w2GW858REk9BoLhG0Z/AsZjeqSmx83QLOXk9jYauIj5yZ1b99cpp0f3ZiDp8VZagqEA92p8AHBTdiAU9tw6ILWE6LmImTw9CxqQhUFWwiNhusZETb9jwAjAS88Lg43GRQ0l9Y2cZExIdESMCJmSiUqtpaK0Df26UOXvcOsy+euLSJuUQAsyPWpOT0LNEVsKzLlWQFX3lhGe8+PoGfuG8/PnDHFP7DIxfx9JXBMXOywrDAt4PIJFAgp8SeMfjgKFuQhzestcQYT/+GGbxxNecVsxlgXYt+983g804ZvHbB1VuxLsGSwefz5GLsC1i32ukuvOiOkGIoi5oPvcOgGVFGLGi/E0yFUHQO/9mvXoCL50wzz/clg8iKsjW7pna1dkK7qvZ+c3nw4NlFBL0uvOdE7UB6bAcLfEr7u0a6VOCBWnenG6hWVSxlRMxQBj9FimKnc/iVjGjbngfIdsdYmM3sZn5lG8e0x3ZyRns9W7Xpd5jBlysKvnNly1Q9b8TsiB+JoJdJaPeIth3ykbtmwXEcfv0HTmAuGcTP/OULWM/1yPa3SxgW+HZgbJ07tqplnMGztOeBWmQsq5LecDreMlzgTS8u/t3N4J2syQEWq3IWBV4skAuY4Ldj8OQgleO016iUaStoxsqH3ohESMD+ZBDnrqfwyPwaHn1lHf/2nYcwaWJ6Mpcgj/malZKeJVFOIe8dCW587aVVvPfkJALe2vMc9XswlwjgJRZhVpfRswLfpRn8Rr4MqVLFjMYwp2N+RP2ejlblVFVlYvAAEdq1KvAlWcHljbx++JiI+JAMCa3n8EIXMuE7mMGfW0hDlBXb+TsAcBynGd60tqx9UNsOedMB8rkICW78/sfuRL4s42f+8nkoAzyPHxb4dmDcT3fcomdh8KtsO/CA88jYBgYfFtxIhgTz1puxRb8LGXzBociuJqYymN1YvE5ikTzfnI02gRaYbdWQKNdGVGzGwoe+ESR4Jo3PfvUCDo+H9J33RszRVTmrNr2eKGfD4LUCP79WQkFS6trzFCdmYnh5uXs2rKzoSYGPG/QZHYIq6CmD5zgORyc7E9ptixUUJMV2RY5iItraze7iWg5KVdUZPMdxODEd0UdAlugGg+9ARf/4pU24eQ7fcyDR8ran98RwZaOArGgtCDRuhxgFm0cmIvj8B4/jmasp/M6jF9t6rP3AsMC3AyO7dtyiZ5jBby+zM3iniXINM/hEyIujUxFzBk9b9JzL0jZSVdWBVZTmywq8Lr5OYGaHqN+DsOBmYvBlrcDbiQ9p4Eyqqt1GzLQ1g88UJaZd7jNzI8iKMpbSIj73weOmK0IAaU/ynE2B1xm8XYEnF8Wzi3nsSwb1EYERJ6YjWM6Ibbm0dcKKesXgC5JiWwxYQdftqMgOIHP4V2/mmFXdjVjJtl6RoxiP+FpGxtLrwdHJ2pjuxEwMl9Zz9mJAes3oqEVfartj+PjFDdy5N840ljulzeHtukyN2yFGfOTMLH7ozAy+8Nhl/JMm7GuFpXTR2nekBxgW+HZgtJB1vAffgsFLRdLKjTDY1AKGE7NzBr9VKCMREnBsKoLL6zlIlYaLC23Re/yWtpF/fXYRb/j1bzb/7ACABM2wFXeKOt9xGwYvlWiBt76g0gKzqdAC3yaDF2VbBT3FG7Sc8+8/PY179lszGMHtwlTMb62k92vF2m4GrzH4i1tlfPiuGdP0shPT5P3jdA7/9+dXceqz/2gu/GRAumjv/NcOKNvuxi78Yooy+Nq14+hUBOVKFVftxI82YNmBpxiP+FCQFORsnt/5lW2EBTdmR2r3d3I6iqrawnWPvrc7EtmJbXUMN3JlzK9u26rnjTg5GwXHWQvtzLZDGvHZDxzHbeNhfPKvXrC0vl1MFfH//9MVfPCLT+He33oMT17qnzhvWODbAW2fuwSiqneCVjN4ag3ruEXPeGJuZPBBL45ORiArKi42rozQ07hNu+yR+XVs5su9y5juAKxJckZMx4xmN9YMXi5pxdGmgxMPeMFxwJqsveZtzOCVqoqsKJvmezdiLhnEn37ibnz+Q8db3nZf0kZJ73KT195uBq89LxW48QN3mr9Xj0+Tv/Nlh/vwX35+GblypW1RW6ogIeh12a6LOcV0rEGA2QGW0iKSIaHu8R2bIp+1dufwtQLfmvlOaLvwdp70F1ayuH0qUndwO6EJ7Wzn8PoMvpMWfY2EOMGTlwmLfouJ/7wZIj4PDo6GLIV2ZtshjfB7Xfjix+5EWVbw03/xvG4BfH2rgD/49hW8//eexFv+n8fwG3//KqpVFT/37tt0XUM/4OzqNwQBbZ87bc8DZPWK42uRiI1wsgMP1ER2bTD4zXwZp/fE9Tnb/Oo2jk8blPPeMHmsFixVVVWcu05Y3mq2ZLuWshPIMSbJGTEd9+OfqWGMDYNXSlpxtOnguHgOMb8Hq5J20S1sEAtiBwU+VyIrX1FGNvq228aYbjeXCOJvbyxDVVVT9k0CZ6wLfLUigQewfyJhKuQDgLDPg/2jQbzkgMGXZEVnOHSN0ylSBalrK3IUTWmDHWApXVPQU+wfDcLr5nFhJYsPnWY83BuwnCnB4+KQDLYujON6gS/h4Fizj4Oi+c7/UENhG4/4MBYW7OfwbgHgPe2L7FRVU9E7Z/BPXNzESNCL41PsSY2nZmN49JU108+B2XaIGQ6MhvCbP3gSP/2Xz+PH/+ws1nNlfcRxx0wUv/DAETxwfNKyC9BLDAt8O6AteqcCO4C0ut1+6xhS6mIXZp3BOxDZqaouYFGqKlIFCcmQF3OJIAJeVzN74HnC5Cw+bFc2CrpP+iAmM7XL4HOlCrZLMiI2DL4qF0n/q8WFaCToxaroJjqG7BL5oiObWvL8sjB4J5hLBpErV7BVkJAMmRSFFna1Ly5s4DSANx4ct/09J6aj+O5VBttbDU9f2YSomalsFdqzBE0VJH1FsVuIBzzwe1zdadGnizg5U++R7nHxODIRbtuTnqzI+Zmc+1qZ3SxsFVCUFP3gb8TJmaj9gY3jOgucUSQAqmORXbWq4vFLm7j3YNKRe+HpPXE8eG4JN1JF7E3UrudFqWK6HWKF998xhbMLKfyX71zH6T0x/OJ7bscDJybqxjA7gWGLvh24vWRPvV1/dregxc2aQGfwjDN4JwVem5vCLSBTlFBVgWRIAM9zuH0yYt4e9EUtP2xGa9SVzGC26Nth8IDG1CwYfElW4Fa016+FBiMRFLBVkImeIXODfNFR0Az1oe9ugd+XJI/bVmhnw+C/NU8OK3fM2XcMTkxHcXO7xLwv/Mj8OryaOHBzgBg8x3GaPqMzsxulStbZGhk8AE1Jv92WUp+syLEVxVZ+9PQ6YNZKPjEdw5WNvO4xYYpOAmfoddHhtfXVmzls5svM7XkKPVmuoU3/9fM3LbdDrPArHziG5z/zLvzN//5m/Ou37t/x4g4MC3z7iEy116IHyJvXksGvkvU0L2N3wEmLnhYrt0/fgadK76OTEcyvbjcr4n0xyw/bswtpjAS9CPvcuDmADD7fToE37sJbMHgaNAOAicHrfvS0wDuKiqU+9N0tWPouvGWBH6nZ6zYgK8o4d2UNAOD12reEKVNtuV4FwsK+9eoavvfIGNw813aoR6ogdVVBT9GNXfj1XAmyopoW+GNTEaSLMlYZbGQbwboDDwABrxthn9vSj/7CyjY8Lg6HxprfpydmiOteS6Fduwyeft4czuAfv0Tm760MbhpxeDwEv8fVJLR78Oyi5XaIFTiO6/rBslMMC3y7OP6DwJH3tfezbsFmBs+YA0/hCZA5OQuDpx8ej09fXUpoM7tjUxHkyxUsphsYytEPALc9YHp3566ncNfeOKaifqy0cVHqNQplpS0VPaCJqSwYfLoowc/RC1GLAh8yJMrpBZ6dwetJcgwqeieYHQnAxXPWsbE2DP7vXlqBWtUU2C77C9qxqQg4roUwS8PLK1msbZfxrqPjSIS8ba3XAVqB7/KBCKjtwneCxRT5eTN2RxmzU6FdRaliLVdm2oGnmIhY78LPr27j0FgYXndzeaAaHVsDIyHa/gyeXhcdquhfuJHBvmRQ1xewwu3icXImWpcsd2OriO9eS1luh+wmDAt8u3jzzwL3/Vx7P2s7g19mb88DZOblZfSjNzJ4rf2ZpAzeyi7zLf8euPeTTXe1nithYauIu+fimIz5Xjcz+GRQgNfNawXemsH7IEFxCS1DYxJBL9JFCaovRgR2gMMCT2fw3S1YHhePmbgfC5s2q3Jy0XSU9ODZJeyPac9riwIfFNw4MBpqbXEK4NFX1sFzwNuPjCEZEtoS2YmSAlFWMBLqDYNPF+WOQmGoyc2sCYM/MkEOQ04ta9dzZShVlZnBA9Tspvm9raoq5leypvN3ABgL+zAZ9dmvPgrh9gs83S5yuAd/cS2Hw+PWwU92OLUnhvmVWlDTQ+cWwXGw3A7ZTRgW+J2A3Qw+t8quoKfwBtnW5PT2l4HBawKrw+NhuHiOmT2c0zzPz8yNYDLqx+qAzeBVVUVect6i53mu5jvuFoiHfAOyIomKVRlYxkjQi6oKSF6DstfRDF4GxwGRLjN4gLTprVv05mY3VzbyeGExg/sO0hXK1oX05HSUaRf+0fk13LU3jpGgF4mQgM02kuioZqEXDH6mC0p6KtIzK8ZBwY19iSDmV52tFdIVuVY+9EaMhc3NbjZyZWzmJdtVrhPTUfsDmy/S/gy+DQZfkhUsbBVweNyZvwTF6dk4ZEXVR5T/47ll3HswabkdspswLPA7AasZfEUC8uvOWvSAlgnPYJChM3jCjugaF0Bywg+OhnCB0S7z7PU0BDeP41NRTEbJTL9llGQfUZQUqCq7D70R0zE/lvQWffPrlNZm8HY2tRR0Fiy6DOzCwSYbv7IAACAASURBVAw+W5QQ8Xng6kKueSP2JYNY2CqYi7poolyD2c3Tl8kK253T2t/TgsEDZH96PWfvlbCSETG/uo133E5U+UkatesQ1MWuF7NQ2gJf6mAOv5QuYiwsWO7oW7pK2oDqAhy16KMCNvLlJsfAC3oGvPWq2YnpKK5uFqyNcvo8g7+6UUBVBQ61W+D3EJ3I8zcyePrKFpYzoiNx3SBjWOB3AlYz+PxNAGq9Ux4LWCNjDQx+q1DGSNBbt1JybCrCvKZzdiGFO2Zj8Lp5nTkMktmN06AZI+oYvMkMPlOU4efK4BhEllTjkOcNjMhBiz7N6EPfDuYSARQlBRs5k0JqETjz7EIa4xEBCUoWWQr8dGuDlG++QkR779QKfCLkbatFTwt8t9fkgO7swi+mRFu/iKNTESylRUeWuHSDZdLhDF6pqk2HKPr5v33SulhSwxvLnAFBW5Nrx7e/DRX9pXVymLitzQI/HvFhKurDC4sZPHhuERGfG9931H79c7dgWOB3AlYzeLoD3xaDdzKDF7CZb94VPjoVwdp2uaW4qShV8PLKNu6eIwpT2m4cpFU5usYTbqfAx/3YzJchc14Si9oQxZspSghwMjgvW4seAHLQtiI4l6OLV0aUu66gp9BDZ8wsay0CZ85dT+PM3Ag4XWTX+vBxdCoCngPO2wizHnllHfuSQRwYJY8pERIgyorjeXcvGfxY2Ac3z3WkpF/KFE0V9BTtONqtZERE/R5H4ygqRmsU2l1YyWJvIoCwz/p1PaFHAVu8nkIYqMr2eRtWMOiEWHFxLQc3z2Ffsg1fEg2n9sTw3atb+IeXb+IDp6a66oK4kxgW+J2A1QxeL/AOZ/BCmI3By0aRXbnJ4IRVxfvCYgZKVcUZzfucMvhBEtoVymRc0C6DB4BtWfuQN8zhM0UZYRdbi56uIaZV7eIjhC19/c2QKUpdV9BT7LNLlTNh8MsZEcsZEXfvjdc8FRgYfMDrxqGxsOUcPl+u4JkrW3jHkTFdtUwPn05ZfC8ZvIvnMBnztc3gK0oVq5mSbYE/OllzlWTFapZ9RY7CyuxmfmVbfwxWSIQETMf81h0ZXwd2tW0w+Itrecwlg6aqf1acmo1hPVdGuVLFR0yCZXYrhgV+J2A1g2+3wDOL7Awz+IKkFx8K+sFuNQM8u5AGxwF37iEMnopR2tnf7RXyDqNijaCt2IysfTwaXqt0UUKIl5kuQlT9vkUDZxwnybH50LeD6Zgfbp4zz4UPNDN4amx0Zm6E6EUApgIPkPWq88tZ03n/Exc3IClVvNPQFk2GyeFzw+EcPlWQwHPEZ7wX6GQX/uZ2CZWqilkbA5TRsICxsMCshQGITe00o8kNhW5XaxjP5EoyFraKlgp6I05MR629DegIShPaZYsyHnttne2BtTGDv9SBgp7itHYtOzwewskZdqvbQcewwO8E3D7zGfz2Ctlr9zl8gzkW2fmwmSvr82GKWMCL6Zi/JXs4ez2N28bDiGrM0u91IRbwDBiDJwXeqYoeqDH4rZLGtBtajRlRRoCTmKyKvW4eYZ8bGxXtou5g/g6Qw0SvWvRuF489IwFzBu/ykMdqENmdu55G0OvCkYmwIwYPEIvTzbxkegh89JV1RP2eOlMR6qnumMEXJcQDXkd2pU4wHQu0zeCpgr6Vw9nRKQtXSQtQm1onSIYEuHiuTkn/6s2c/vtb4cRMFAtbRWSLJloBPXCG/A3/50Mv4hN/8qylNW4dHKroS7KC66miqSmPE5yYjiIZ8uLjb9q363ffjRgW+J2AhTobuRXC3p2+wRyK7EqqBwVJaWLwAFXxWrMHpariuetpnJmrd3gatFW5fAciu4moDzwHbFoVeGp0w9hGTAS9tcAZBwW+olSRK1V6JrIDyBze1s3O0KJ/diGNO/fG4Xbxjgs8FWY1tumVqorHXlvH228bJfergb43nSrp0z1ysaOYjvuxliu1FY9cK/D27xsS35xnyg3PlyvIirLjFr2L5zAaEupm8Be018ZOQU9BWe7LZtcKPcJ6G996dQ2PzBMB5fM3zJ0R6+BwD/7yeh6qirZX5Ch8Hhf++f9+Jz76xj0d3c+gYVjgdwIen/UM3ml7HiCpbxWxSQzWBK1QpSTyso+ahIwcm4rg2mbBUtz06s1t5MsVnNk7Uvf1yahvoNzs8h0weI+Lx0TEhw36ElWaZ/A+VWIu8CNBL1bK2nPtZEWO2tT2aAYPkF3461tF81U5/4jeot8uyXj15jbuoixbYRfZAWT84+K5pv3p52+kkSpIde15oCZO3HK4C7/VAx96I2ZifqiqdVCLHRZTRXBc68z2o5NRVKoqLq21PrSvOoiJbcR41Fe3+TK/uo1E0IuxcOv2OE1sM9VVaO9xqZDFLz98gSTluXjLWNY6OGTwNOK60xY9gJ51fXYSwwK/E3D7AFVpLsjbK+wpckYIjIEzWqGirWdTBj9JvKZfWTWf6Z+7Tg1uGhm8b6D86Dtp0QOEqd2k4nIDg1dVFZmiDK9abhk0QzESFHCjqF00Hczge+VDb8S+ZACirJhngxvsap+/kYGqAndrwkooEokFZew2+TwuHBoLNSWRPfLKGtw81+Qh7vO4EBbcju1q0z1IkjOC6jOW2gidWUqLmIj4WorBjumukq3n8O3swFOMh4W6An9hZRtHGzLgrRAPejE74jc3vNHe49968TIWUyJ+9YPHcXQq0uT3bgqHM/iLa3l4XJy+ETJEPYYFfidAV0CMc/hqtT0XO6AWTNOywJMP81aZFngTBq+twFjN4Z9dSGMy6mu6oExpNp6iNBhmN4VyBRwHBLztrbtMx/xYzWus1sDgRVmBpFThrbJnVieCXqwVQViJo6jY3iTJGUEvjKZt+sCIPoM/u5CCi+f09C0oEnN7nuLkTBTnlzJ13YJH59dwz/6EqSiunV34XiTJGVEXRuQQS2n7FTmKPSMBhAQ30xyeahqctugBza5W+3mpUsWltTzT/J3i5HQML5mtymljqGdfu44P3DGFNx1M4vSeGM4vZ1FRWow2ZM1givHgeGkth33JIDyuYSkzw/BZ2QnoBd7ATgobZOe6rQJPGXwLoZ32+9Y18mHGdKaiPkT9HsxbsIezCyRgpvGUP2ircvmygqDX3bZgZjrux6oJg08XZbigwKXKzAw+Tv3oH/gt4K5PMD8G6kPfSwZPU+VMQ2cMmfDPLqRwdDJS0zQoMnN7nuLETAzpoqyzzmubBVzZKOCdt5tHziZDgiMGX62qSBd7y+AntVZ4O0r6pbRoq6CnIPHNYSZHu5WMCBfPMbXVGzEe8WG7VIEoKbi8noekVJnm7xQnZqJYTIlIN4xRVO16FONFfPq9twMga2iirOC1tRbbPpWSsx349VzH8/fXM4YFfidABSTGObyeA99GwIEuamFg8K6ax7dZi57jOOJoZ3JxWc6IWM2Wam1aAyb0Aj8Yc3gSNNO+WcVMPIBSVft5w0EsU5TgY4yKpUgEvZAVFdtHPwpMnmR+DLWgmd4x+KmYH14Xb7ELPwJIechlES8sZurHMkrZMYPXDVK0ti51r6P2tI1wyuC3SzKqaveDeYwQ3C6MhQXHDF5WqljNmufAm+HoZASvmMU3N2A5I2I8LNQJFFkxYTC7oR27VjvwRtDXs1Fo941XtyCqXtw358OY9jvoSm3LNr3M3hkrShUspsRhgbfBsMDvBHQGbyiG+g68Q5tawMDg2U7HW3kJAa8LAa/5fProZASv3sw1tdNqe9DNGclTHezC38yWcO56yvaf9Zyz+823kSRnxHTMjzK0QlFX4Nmz4CmoYCzlUDCW1qNie1ewXDyH2RG/eYtec7N77doNlORq/cFOkR1ndh+ZCMPNc/oc/tFX1nBkImxp3ZoICdgqsDN4KsjrpYoe0GJjHTL4m9kSqmrrFTmKY1NRFCSyAmYHJznwjdB34bdLuLCShd/jcuQGR4V2RsObQrmCz351HiIfxPFErXs2E/cjEfS2FtpVyszvq8vrhNB0Q2D3ekX7V0AGcBz3bgC/C8AF4Euqqv6myW1+CMCvAFABvKiq6kc5jjsF4A8ARAAoAH5NVdW/6uVj7SvMCnxulfy7HQZPZ/AsDN4tmLrYGXFsOoJypYqrm/UJTc8upBAS3Dgy0XzK1xl8G63LH/j9p1oq8A+OhfDov7uP+T7zZedJckZMx/0oQ2PODQXeR7PgWUV2IVrgy44uoFlRBs8BYV9PP6Z66EwTNDe7i1evAUDdnjqZwTvrLPg8Ltw2EcbLy1lkizKeXUjjJ+7bb3n7ZNCLVEGCUlWZwnbS/SrwMT9TOp4Ri1qhZmbwBldJs/dMRaniS09ew3PXM/jQ6TbGeiCBMwAp8PMr2zgyGXYUahQNeDCXCNQJ7f7jty5hNVtCYCwG3uBkx3FEv9FyVa4iOlDQk+tduyEztwJ6duXgOM4F4IsA3gVgCcCzHMc9rKrqvOE2hwD8AoA3q6qa5jiODuOKAH5MVdVLHMdNATjHcdw3VFVlkGHuAtACLxsZ/DJRJQeSzu+PtuhZZvBun6mLnRFHJ8nJ/MJKtq7An11I4/SemOlFwOdxIRH0Ol6VSxUkrGRL+NF79uD7jk6Y3uavzy7ikfk1qKrKPFMvlCsIWnQoWDAd86Os0gJvnMFLjhl8u7ar6aKEqN/T8/WduUQQT1zaRLWq1v8uzc1uYWkJe0YO6O1WAG2J7AAitPv6+Zt47LV1KFVVD5cxQyIkoKqSsYiZILQR/WLwM/EA/vHCWvPzZQO6A28XNGPEofEQ3DyHCytZvPdkfVfvtZs5/NxDL+LFpSzuPzaOn3v3EWd/gAbK4FezpEX/wVPODwonZmJ4TtusubSWwx89cQ0fuWsGvnS8yar29J4YvvnqOrKirJtkNUEuMe/AX1rLwevisZfxOb0V0csW/RsAXFZV9aqqqhKA/w7ggw23+dcAvqiqahoAVFVd1/59UVXVS9p/rwBYBzCK1ws8Fi368CTAt/GSOGrR06AZ6wvmgVHi62ycw2dFGa+t5Uzn7xQTUZ9jkR1ts73jyDjeenjU9J87ZmIoV6rIldmDR/LlCkIdMF+fx4VgUGNOhtcpK8rwwyGDb7NFT2xqe1usAKKkL1eqWG1MA9QY/NrN5eaxTBsiO4BY1mZFGX/y1DUkQwLumIlZ3lY3u2F83vrG4ON+SErVkY3uUroInqt1ulpBcLtwcCxUt80iK1X83jcv4X2/9wQW0yK+8NHT+E8/epdtN84OYZ8HQa8LZxfSyJUq+sHeCU5MR7CcEbGVL+MzX3kZQcGNn3/giJaPUa/jOTVL3kMv2rXpKyVHO/D7R4Nt6Q9uFfTymZkGsGj4/yXta0YcBnCY47inOI57Rmvp14HjuDcA8AK4YvK9H+c47izHcWc3Nja6+NB7DKsZfDsKeqC2B9+yRV8GPD5s5stI2jB4t4vHkYlw3cXluRtpqGpDm7YBk1G/YwOQKxvkMR8cs56jjWoK4U2zWFMLFKTOWvQAkIhqo4gGkV3MrR00mBm8ZrvaRoGP9lBgR2EZOqPN4N3lTJOxUdsMfpoU9BeXsnjHkTFbBkwLF+vr3jcGT3PhHQjtFtPETtbJOtexqaiupJ9f2caHvvgU/r9HLuL+YxN45JNvxftOTnVsqzoe8eGpy5sA2CxqG3FCez1/7Wuv4JmrKXzq/ttIt8UXaWLwJ2ej4DjYz+E1EsKCi2v5ocCuBXpZ4M3eeY2SUDeAQwDeBuBHAHyJ4zj9SM9x3CSA/wrgE6qqNi1Qqqr6n1VVPaOq6pnR0V1E8Ltd4D0BABzTHrzq8iHVokUPELONCyvb+s7yuYU02YPeY824pmI+rDicwV9ez8Pn4W2NOuiF3jS33AKFstKRih4ARkdoga9fk0sI2q4/I4P3e13we1zOGbwo9Y3BAya78FqLPo6cHg2so+JcRQ8AhydC8GpFrtG9rhH0ELrpgMEHvK6eR33qufAO3uusO/BGHJ2KYCNXxue+Oo8PfOFJrG2X8Z9+9C584aN3Mo0sWDAe8UGUFfAcEUE6xfFp8hn58vPLODkTxY+8QbN6FSJ62AxFxOfBwdGQfYGXS0wH53y5guWMOBTYtUAvC/wSAGPu3gyAFZPbfEVVVVlV1WsAXgMp+OA4LgLgawA+rarqMz18nD3BhZUsfvFvzpuvuTTO4FW1swLPcaRNz8DgK7wXSlW1bdEDREmfKcq6Kv7ZhRSOT0UslfcAYfDbpYruIseCy+t57E+GbJmczuAdzLA7VdEDwEQsjKrKQTUU+IyxwHvZZ38jmmDMCdIFuac2tRSTER8Et8mqnFtAiQ9gwlPEgdGGC6kit1XgBTcR2gluHvcetNeb6J0PxlY4DZrpNdoxu1lKi8wKegrqaPfHT13D+++YwiOffCvefdxcp9Iu6MjgwGiorYNR2OfB/mQQHAf86oeO1/Q5Qtg0LpYK7UytkQFNZNd6jHFJ26cfCuzs0csC/yyAQxzH7eM4zgvgXwB4uOE2fwvg7QDAcVwSpGV/Vbv93wD4M1VVH+zhY+wZvn5+Ff/tuzfMT/mNM3gxTd7Y7RZ4gLTpGRi8xJGCkWxhjHF0igrttiFVqnhhMYO7Gtu0DZhsYxf+8nretj0P1JjcBuOqnFSpQqpUEepAZAcA0/EAyvBALNZWlTJFCXGPsxY9oO10OyzwWVHuqckNBc9z2JsImCrp02oIB4Ll5gNYmy16APg39+3Hp+6/Df4WLoNRvwcunmMWJ6Z6HDRDERTciAU8WGa0qy1XFNzcts+BN8Op2Rg++sY9+NKPncFv//Cpnjj0UaEdS0SsFX7ibQfw6fcexUmjnkKIkBl8tb7xenpPHOmijBtW63+MDJ769N82LPC26JmKXlXVCsdxPwXgGyBrcn+squoFjuM+B+CsqqoPa9/7Po7j5kHW4T6lquoWx3E/CuCtABIcx31cu8uPq6r6Qq8eb7dBT/fLGbFZOdvYotdX5Doo8F6WAl9GmSfCqWSLi8WRiTA4jsz+kiEvypVqc5u2AUY3u1ZFGyBGFcsZET90Ztb2dvGAFy6eY2bwhQ6S5IygBV4uFkBfwYwoI+6jBd4Zg3fiyiZVqsiXe5skZ8RcIqjrISi28mWsKyFMCSaH1DYZPAC87yTb+5znOYwEvcy78L1OkjNiOuZnZvCrmRJUlV1BT+HzuPDr33+inYfHjPEIOei3M3+nMP38CmEAKiAX6uyZqdXx8zcy2JswWRllnMFfXMtBcPOOn9NbDT1dsFVV9esAvt7wtV8y/LcK4N9p/xhv8+cA/ryXj63XoMzd9CLQWOB1kxtnO/D/4ZGLeObKFv76J76HLTJWFiF6yEveaoYXFNzYlwziwkpW93O/q0WBp4YbrLGxVzcIY2x1GOB5Domgl3kG30mSnBHE7MaDcrHGbDNFCZGgcwY/EvTi4s0WWw4G0CS5XrrYGbEvGcS3X9uo2zk/dz0NQQ3hIG/yuNvYg28HiaCX+WC3VZCwv3GU0CNMx/zm3gEmYI2J3QnQz+xxBxa1TKChSqXtugJ/eDyEgNeFFxYz+NBpk+sdo4r+otb5c7K3fytiuF/QIxgZfBMaZ/C6TS07gy9XFPzZdxbw7PUUSrLCzODFKi3wrZnO0ckI5le38exCCnOJAMbC9rMx2u5bYVyVY1HQU4yG2X3JC1rUbSdrcoBmdqN6UCqRdiJNkou66B48O3tIBEmL3nL22AAaNBPtQ4seIEI7SanWiSTPXk8jw0Xgr5iYunTQoncCJ697Xxl8nDB4ltdzMe3M5Kaf+N4jY/jdf3EK9+xPdPeOdfvs+sOh28XjxHTU2vBGFpn24C+tDT3oWTAs8D2ArFRxU9spNmXwLg/A8QYGvwqAA0L2qmIjvvnKOjJFGaoKMs9iEtmVUFDc4Dg2v+5jU1EspUV85+pWy/k7AHjdPJIhgXlV7vJ6HjwHzCVbF8pkSGDeO+5Wiz7q96DCeSGVyGuYL1dQqaoIuSSAdztisCNBAeVKFUXGtL1Mnxm8WejM2YUU3MEEeNHkYtynAp8IsvnRl2QFBUnpa4u+ICl6p8UOS+ki3Dyne78PEjwuHh88Nd19MyVB6wiYCO1O74ljfnWbEBMjFJnEaLdg8NslIv49NFTQt8SwwPcA1HcasGDwHEfexBUDgw+NOyoYD55dhFv7UF7bLDCK7MrIKW6MaDPtVqBzuVyp0nL+TjEV8zG72V1ez2NvIgjB3Vq9OxoWmPeh82Vy4Qh1uCYHAFW3AFkiryENfwny7ElyFAmHZjfUtKWXPvRGNO7Cl2QF55ezCCfGiViq0vC4+9WiDwlMKnrq298PFT1QY+Msu/BLaRGTMd+tZciiM/jm7s+p2RhkRW2OpKbXwxYzeCqwOzw2ZPCtcAu94/oHWtSJ0tbiAuAW6mfwDtrza9sl/NPFDfzw3UTcsrBZYGzRl5CruJidr4zJUmdsHOyMmIz6mP3oL6/nm9evLEAZPEtLNF/qDoMHAM4toCqR14kW+AAkR/N3oGa+wqqkpwy+XyK78YgAv8eFa5uknfziYgayomJsTLNJbWTxiuQ4bKYdJEJeFCQFYovOR6pPJjcU0zFywGPZhV9MFTETu8XEYHQGb8rga0K7OtCRZYvPFl2RG7boW2NY4E0gSgp+4+uv4PGL7bnj0bb83XMjWM6I5rvwHr9hBu+swH/5uWVUVeB/vXcf4gEPFraKrUV2VQWoysjKLqb5O0BY81hYQDzgwYFRtpCUyaifaU2uolSxsFXAgTG2+x0NC5AVlaklqrfoO1yTAwDe49P34DMiKSJ+ruy8wBsCZ1hAZ/D9KvAcV78qd1bzF5+ZniE3KG7V/0CbVrVOkdRdAO2ft74XeIcMfnZk8ObvPQVl8KXm2OnxiA9TUV+z4U1Fey5b7MFfXMvD73ENpKZh0DAs8CYQ3Dz+5OkFPKlZODoFPdXfPReHVKli0+ziZGTwOfYCr6oqHjy3iDN749g/GsJcMqgx+DD5gCgWJjOa3Sop8OzM6/tPT+OHzswyW2JORn3IlyvIlewL8Y1UEbKi4iAzg9dczRjatd1S0QOAy+uHuyphuyQjrTF4QS130KJvfUABSLfAzXNd+RtYsY++l0Dm74fGQgjFNV2ImKq/cb9m8NSPvsUcvt8FPh7wYCbux4NnF5tilY0oyQrWc2XHJje7HoI1gweAU3tMkuUYGfzFtRwOjtmbYw1BMCzwJuB5DrNxP64zrsE0YjktIhkSsD8Z0v+/CXQGX84DpSxzgX/uRgZXNwr4yBnCrPYltKhPGhlr1abXDhOpMqcXGxb8wntuxy+853bm20/SVbkWLJ6GzLAo6IGam906wxy+WyI7APAKfgiQsZwWkdVYtVdtg8EHnTH4dFFGLODp2GvcCeaSQdxIFSFVqjh3PU0CZjS72joGX60C1UpfCrzuR9/iYNfvAs9xHD793qN49WYO/+U71y1vRw/7txzbpAFY5WYGDwCnZ+NYSov1ryvjDP7iUEHPjGGBt8DeRBDXt9icqhqxnBExHffbe1ZTBu8wB/6hc4vwe1x4r2YWMpcMYjVbguTSGIJVZKzG4LcrLtugmU4xpZndtPKkv6ytyB1gLfAhdrvavFSB183D6+787S34AvBqBZ4yeLdScszgQ4IbXhfP7MqWFSXrSM0eYV8iiEpVxbdfW8d2qUICZrREORQNDF7R/oa+iOzYGHy6IIHn0Nfn7P5j43jbbaP47UcuYq0xiU9DbQf+FmPwPE+6ijYMHgBeMM7h9QJvfRjKFmWs58pDD3pGDAu8BfYmAriRKjLvLRuxnBExEzMUeDMGT2fw1OQmPNl8mwaIkoKvvriKB05M6K1bGhSyIWsXthYMvqx6uhZUYYYJRrvay+t5jEcERHxsF2TK4FnMbgrlzpPkKHyBIAROxnJGRKYoIyS4wVdExwyezrhp56IV+hUVawR9Lz10bgkA0ZDQRLk6Bq8X+H6syWkHu1Yz+KKEGON2SLfAcRw++4FjkJQqfu1rr5jeZknbgb/lZvAAEdqZzOABYqzj4jk8v2ho08vaddJmD/7i+lBg5wTDAm+BvSMBFCXFUeYzAFSrqs7gIz4Pwj63DYMXDS52rVv0/3BhFflyBR+5q2YNuU/bX74pagXNSmhHCzy8bedHs2A84gPHtS7wVxg86I2I+j3wuDimGXw3kuQofL4AfKAFXmPVsuiYwQPAiZkoXlrOMh0aaYu+n6B+BN96dR2jYYEUJY8P8ATrVfSKpiNw9V5F7/e6EPS6mGbw/fIMMGJvIoifvO8AHn5xRY9dNWIpLcLj4lqaRL0uYZIJT+H3unD7ZLheaMfA4C/qITNDBs+CYYG3APVJvuGwTb9ZKEOqVPXEKUvPareftM0duNg9eHYJsyN+vHFfbWWNXpQXC1pBkyzsUPUC72FW0bcDj4vHWFiwXZVTVRVXNgrMAjuAsKVkSGBi8LlSpSsKegDgPD74ONKiz4gy4sEOCvx0FBu5Mta2W/8NWY2R9hOjIQFBrwuVqoq75+K1+X9gxILB96egsuzCpwpSy4TEXuEn33YAe0YC+KWvvAypUi+4W0wVMRXz35qWqjRwxgKnZmN4cTELhW4ZMczgL63lEfS6bOOlh6hhWOAtsCdBLuBO5/C0mNM34Ezcb83gZY3B++MtW76LqSKevrKFD985W6ceDfs8SIa8uJ7TvmbJ4MkFsgyPvnrUK7RalVvbLiNfrjDP3ymSITbb0m626OEWIEDGksbgY34vIBcdt+gB4OQMcfc6v2xi/dqAdLE/UbFGkDECOdieMToXWhb4/hxAWJL4UgWJHL52AD6PC5/9wDFc2SjgS09erfveUlrE7K02f6ewiIylOD0bR75cqYUcMajoL67lcHA83Ffx6W7GsMBbYCbuB8/BsZKeFnM6f7dk8B6NwedWmQR2/+O5JXAc8IN3Nd92LhHElW3tDW8psiMfnpLq7SmDB8iqnJ0fva6gdxgMMhpmY/AFqfMseB0uAR7IdePwOAAAIABJREFUWEkViA99gDJ45wX+6GQUPAecX8rY3q4kKxBlpSfxoK1AHe3OGJ0LA4kGkR1t0ffn8bF0blIFGSM7xOAB4O1HxnD/sXH83jcv1x3oSQ78Lco2fRHbAn9KN7zRxj8Me/AX1/I47JAY3MoYFngLCG4XJqN+XLfKLbaAzuBpgY/7kStXmg1a9Bn8csv2fLWq4qFzS3jTgYSpGncuGcSltNbmsmzRkwuk6hb0dLheYTLqx81syXLWfFkTyjiZwQNkF551D77ToBkdWrtwu1DAeq6MuN+tMXjnrMzvdeHQWBgvtWDw9L3SbxU9QNqm4xEBtxtcDOHf2RZ9sgWDr1ZVpIsSRnaIwVP80vuPAQA+99ULAIgodjNfvnULvBC2FNkBRD8U8blrc/gWDD5dkLCZLw8Fdg4wLPA22JsIOG/RZ0SEfW5dHa5bWjayeH0G39rk5plrW1hKi3XiOiP2JYNYyGsvZQuRnd8f7Hl7ayrmQ1FSsC2am+5c3sgj7HPrynhWkGQxydwZ0IBCuYJQl2bwlE0IkJAvV5AUVABqWwweIEK7l1sI7aglbr9V9ABxR/ynT70dHqNveiBRb3SjaIesfrXogwJSBevXPVeqQKmqO8rgAdKt++l3HMQ3LqzhsVfXsZyhCvpbtUVvz+B5nsOpPfGaZW2LGfxQYOccwwJvg70JYvzhBMtpsU4AYrkL7xYIEyxsAGH7Av/Q2SWEBTfuPzZh+v25RBAiBKjgbNbkyEU5GGSzhu0Ek1HyN1u16S9rCnqnB41kSIBSVXWfdisQFX13GbwAclhJ+DRP9DYYPEDm8Jt5yVajkO6zTa0RPM/B52no8ARGiBkTdUmkLXp3/2bwStXapjhVpCY3O8vgAeB/u3c/DowG8csPX9BHUbcug48AcsHaXROkY3RxLUfMqVqo6GmBv21iyOBZMSzwNtibCCBVIDalrFjO1M/caLFfTjccFDx+QNUUtzYMPleS8fWXV/G+O6bgt2itEyU9h4o70HIGH+pDga/twpsXeKcKegqWXfhqVUVBqnQlSQ5AjcFz5D0w4qUFvk0GP02Edi8tWbfpKYPfiQJvCmp2Q1fl+i6ys/ejp+6AO9HxaITXzePzHzyOG6kifuPvXwVwC5rcUNDAGauxIUjwTFXVPg+ySN5TvHlZuriWR1hwD2Ts7qBiWOBtsFdrrTlZlWtk8MmQF4KbN2fwFDYF/msvraIkV3VrWjPQLO8yH7BuiWkMPhzqfXtrKmZtdpMVZWzkyo7n7wCbbWlRVqCq3bGpBaC/Tn5a4D0aG2mTwd8+GYGL53B+2VpoVwua2fmCBYBseQC1OXyfC3wySHMIzOfw1N9/p9bkGvGmg0m8/44pXN8qwuvmdRfGWw42gTMUp2Y0od1impCQFjvwh8add/5uZQwLvA2crsplRRm5ckVvywNk9Wg6ZrIqZ3wj2xT4B88t4cBoEKdnY5a3CQpujIUFFOG3bNGrmktUJNz7Aj8W9sHFc1jNNBd42rZkjYk1goXBd9OHHoDO4KdD5KMS1Qt8ewze53Hh8HgY55etL3p0BLETxi2m0Bm8NofXVfR9EtmF7Q92OoMfgBY9xaffeztCghszMf+tG4rSInAGAOJBL/Ylg8SytlKy34Ffzw8Fdg7Rv6iqXQi6E3w9xbYqV9uBr2d303GTVTkGBn9lI49z19P4+QeOtDy1ziWD2N4QMGYhsiuLRfgARPrA4F08h/GwYDqDv+IwZMYIFgZPk+TCXVPR0wLPAdtA1N1ZgQeAk9NR/OP8Taiqavq6posSvC4e/sZZ+E5B96PfGQZPw5Gs3OwGjcEDxNHxCx89jXLFOmnudQ/K4G3MbgAyh3/y8ibUkAjOwqZ2M19GqiDh0LDAO8KQwdsgJLiJicwmG4Nv3IGnMGXwtEB4Q7WTbgMeOrcEF8/hB0633pPflwgio3gtGbwoFqCoHBLh3s/gATKHN2XwG3l43XxbyuKIzw2vm2dj8F1T0ZOiMRkihTjMa0WmzRY9AByfiSJdlC2zxLPavv3AtCIbE+Uq/VXRxwJe8Bws3exShTJ8Ht5So7JTeNttY5bC2FsCDAweIAV+I1dGSSy0FNgNQ2acYVjgW2DPSMABgycHgUYbxemYH5t5CSVZqX2RMvjIFGBxIf+7l1bw1kNJjDGISvYmA0hXBCgl8wJfEosowYtknzyxJ2N+3DRJ2Lqynsf+ZLAt606O4zAaEmzzAfI9atHPhnn4PDyCvNae7pDBA8DLFvvw6eLO+KpbQg+c2ZkWvYvnMBL0YtNiFz5VkDEyKHqFIWqgIjubGTyghRoBOHt5FSsF4DtXtmr2tRourZHr2rBF7wzDAt8CexNBZpHdckaE4Oab4lhNV+XoSdUiRS5dkLCYEnHP/gTT796XCKIAHyoWHyapVOy5D70RU1EfVjJi07735Y28Y4taI5It3OwKZXKI6qZVLQDcfySGh3/qXrgU7dDibb8TcmQyDI+LszS8yRRlYok7KPAGyPu1qUXfv5Z4ImjtR58uShjp0/t6CAdgbNEfnYrgD3/sDJI+FTeLKn7kD5/BG3/9Ufzi35zH05c3UVGquLiWQ8RHtEZDsGM4g2+BvYkA/vaFZZRkpXk/uAE0Ra6xtUrXZJbTYk1cRmdNFja186vkQ3F0yrx934i5ZBDPqX5LoxtJElFG721qKSajfpQrVaSLMka0GWpJVrCYKuJDp1qPHKwwGvJi2aT1T5EvE3bZrTQ5yuB9kAl7WNYOex0weMHtwm0TYZy3WJXLFGXsTQzYalUgsWNrcoDmR28xg98qSAOxIjdEAxhb9ADwrqPjwHc8UFwT+MKdp/H352/iy88t479994Z+/Tg89KB3jCGDb4G9iQBUtZbrbIfGFTkKcwZPC7y5wG5+RSvwk4wFPhFEHj7wsnmBr5RFlFVP31qZkya78Nc2C6iq6IjBt/Kjz3edwWvPF50765nVnRXgE9NRnLdwtMuI0uDswFME4gYG398WPWAfNJQuSLoQb4gBgscPcK6WDF6HLMLlDeB9J6fwxY/diec+8y78wcfuxJsPJlGWFXzPAbZu5hA1DBl8C+wZ0ZT0W0UcHLOf/yxnRFPGPR4W4OK5eiW9XuDNW/QXVrKYiPh0k49W8Htd4IUQPEqZOEe56l9aRSqhwnvhdvXnTDepHXRWMyUcmyIz53ZDZoxIhgSkCmUoVdV0jt+rNTndZUvunMEDwInpGP7ynxexmBL1dUyKTFEePEZqDJwZMAZPkuQG7PkagmiLWgTO1KFSqgua8XtdeODEJB44MYlqVb111w07wJDBt8Ac4y58SVawmZdMGbzbxWMi4qvvAozsA/a+GZh7q+n9za9u4xhje55CCGq3l5tFgapcgsL3b341ZcLgL6/nwXHA/tH259ejYQFVlVzUzVAoV8Bx6F6gDhVDNjJ4m8QrFtDo2JcaDG9ESUG5UiWpdYMEY+DMDhT4ZEhArlypF6oCKFcU5MuVIYMfVLQInKlDQ4E3Yljc28OwwLfASNCLkOBuGRtrtSJHMd2YCy+EgU98HRg93HTbkqzgykaBef5OEQprZjhmc/hKCWqfvMMBckF28xxWDG52VzbymI0HWmoZWt0vYL0Ln9eCZro2q6MXHBqwIhVIe77D+z88HobXxTfN4TMiKZ4DyeBFI4PnAL5/a2m0gDce7PRgnmGBH0wIUXYGL5dq2qQhuoJhgW8BjuO0VTl7Bm9lckMxY5ULb4LXbuagVFXHDD4SJesmue1mG1TO5nTcC/A8h/GIDzcNBZ6GzHSCVm52hXIXs+CBmlLcyOA7bM8DxLP8yGQY5xuU9GnNtCW2A1GxtggkADFDxj+KRDobfRQ86X70DW16+v/DNbkBhRBmn8G3sKodwjmGBZ4BexOBlqtyLAz+5nYJstLa2eqCLrCLOnqcI3HiGb66sdH0Pb5aBtfHAg8QT/oV7XlRqiqubhY6LvCtGDxJkusis+R50orWZ/BixwI7Ciq0M8agUgY/MD70FIERACpQyhCRXR/b8wD07Y/NhsCZtJ4kN2DP1xAEvogjkd2QwXcXwwLPgL2JIBbTxSbzBSOW06Ju0WqG6ZgfVRV1jNYK86tZhAU3ZkecnWZHk0RlurG1Wfd1qVKFuyrB1ecPz2TUrwfOLKWLkCrVjgR2QGsGnytXuqegp3D7DAy+2BUGD5A5fK5UqesODVySHIVuV5siDL6PCnoAemDLZsPrvlUYFviBBusMvqoAVbmvXcZbAcMCz4C9iQBkRdXZqBmWMyImIj5LlbplLrwJ5le2cftUxPEceSyRBABspdJ1X08VJAiQ4RL6u1s9GSUt+mpVrYXMjHVmlRv0uuDz8DYMvssteoC0o+sYfHcK/HHN0c7YptdnyoPG4I2Jcoq0Ywx+q2EGnx4W+MGGEGabwetZ8MMC300MCzwD9NhYmzn8clq0bM8Dxlx4+wKvVFW8sppzPH8HACFICkY2k6r7+ma+DIGT4Rb6O9+ajPogKVWkipJhRa4zq0mO42x34XtT4BsZfHcOSofHw/C6eZxfqmkm0npU7IAyeDEFVPrP4ANeN/weV5Ob3VZBAscN4EhjCAKBsUUvawW+S4fnIQiGBZ4BLLGxyxkRMyYrchRTMTYGv7BVgCgrzAY3dfCS9nc+Vy/c2tIYvODrc4E37MJf2cgjGRK6sv5FTE/M1+Ty5QrCu4TBe1w8jk5G8JJBSZ8VZfg8fEebBj2BMXBmBxg8YL4Lny5IiPk9bWUbDNEHCGHyfqlYm1MBACrdWT8doh7DAs+AyagfXhdvGTpTUaq4uV2yZfA+jwvJkNCSwVOBHTWHcQTNH72Ubyjw+bJW4Pvbop+KkudjJStqCvruJNmNhnaSwXdPZAcQod2FlW1daEcK1gCy0aYZ/E4UeKEpcCZVHJrcDDR82nWsVZuefr6GBb6rGBZ4Brh4DjMjfsvY2JvbJShV1dTkxoimXXgTzK9sw+Pi2lObe4NQwcFVySNTrF0IN3MlCJDg8/cnKpZigprdZMSurMhRJMPWtqVERd9LBt+9Fj0AnJiJIl+u4Jrms5AR5cFrzwPkb3b7NAbffxU9ACSD3qYWfSovDVfkBhk0cKZknrugQ7eAHhb4bmJY4Bmx12YXXt+Bt2HwgLYL36LAX1jJ6rNZx+A4KO4Agijj2mat25DOFeHiVHj7PINPBL3wuni8tJzFdqnSsYKeYjQkIFWUUGlYOSxXFEhKFaFurskBZBe+y3vwFNTRjhreZIoD6EMPkJ13/wiZwe8Qgzfzo08XpaHAbpDBGjiji+yGM/huYljgGUFiYwum4SD6Djwjg69arNupqor5le325u8UQhhBiFgwOO9lc0TgxvX5dMzzHCaiPjx5iaztdRIyY0QyLEA1saulUbG9V9F3j8EfHA3B5+H1OfzARcUaQf3od4jB0xm88TO4VRgW+IEGY2TskMH3BsMCz4i9iQAKktK0pgMASxqDn2pV4GN+SJVqk1kHxXqujK2C1JaCnsLlCyPElXDNME7IFbTT8w7MtyajPqxr8/JutejpTvR6wxy+60EzFG5fQ4u+eyzDrQntXtZW5dJFGfHgADJ4oJYotwN78ACZwVeqKrZF8jqrqor0sMAPNnysDH44g+8FhgWeEXt1JX2z0G45LSIZEloqn1utyukRse0I7DRw3iASHgkLhhZ9Ia/9t7t/YTMUNDY2JLgxEenOh3c0rLmaNbRr81qB742KvkyYa1XuKoMHgJMzMby8koVSVZEVJUQHnsGXd6hFX+9mt12qoFJVhwV+kKHP4Fsw+KGKvicYFnhGGGNjG7Gcsd+Bp2hldnNhhbC42yc72BUXwoh7pLoWfaFAC3z/51t0Ve7AaLBrATCjIXIRaFTS95bBlw1txO4+jyemoyhKCs4vZyErKuKDOIMHaolyirwzDD5Y70dPTW4GzhRoiBoERhX9cA++JxgWeEbMjvjBcdYF3m4HnkIv8FYMfnUbexMBhH0dXDy9IUR5IrJTVRWqqqJY3DkGT2NjuzV/B4CkzuDrxyX5nhV4jcF3KQu+ESc0od0TF0mGwECK7ADC4EsZctDZgfeS7mandW5S1Ic+NCzwAwtB+9yXW6johwy+JxgWeEYIbtf/bO/eg+M6yzuOf5/d1a6kleSLJCe+OxcnTQg0QBoooRAyAdxCSaekBQY6mQ4tHYYOUFquLaWlMB3+6QXITIeCp3QmlDLQQMqQQialpbQUCPfYaYgJJhc7sSXFsSRLu1rp6R/nHO1almOtfI6O9t3fZ0aj3aPV5vUb7T77vLeHbRv6zhiiX1jwFWfwQ709DPaWniKDb78G/JkNHaDKLJOzDSam60zWGhQW8pvf2hrvhU9r/h2iU82q5eIyGXy0yC6bs+hnWwJ8ukP0l4wO0NdT5GsPJAF+nQas/mHwBZgey22RHTSnZiZUSW79K1WiXSiag8+FAnwblisbOzZdo95YOOcK+sT2s5SNnZyd42fjp85vBT1AeYDehaiNh8enGZ+KTrEDcsm6Lt0yQMHg6p0bU33e0WX2wk/Von9nqtXkoCWDz2aIvlgwrto+xHcfio6sXXelYhPJaXb1yVyG6Df3lzFrjtxMqJJcZ+gdOvccvFbRZ0IBvg17Rs4sG9usA7+yN/0dZzns5r6j0SfcVZ1g16pcpTQfjTL8dOxUdIqdJQF+7V88e0aqfOuPb+R5l4yk+rwjy5xmN5V1Bl/PJoMHePr2jYvVCtftyWxJgIdcMvhSscCm/jLj8SK7CRWa6QwrKTijffCZUIBvw67NVcan60zOzi1eO1cd+KXOlsEfjBfYXXneQ/SDFBqz9BScw2PTjE3V6SWeq84hg4dmDfc0jQ5WOD61VovsKoA35xEzWAj09B3N/+/rNoPvyzfAQ3R4Uusiu0qpQH95nZ3bL6erDK1gkd0MFEpQTPm12+UU4Nuwe5miMys9xS6xfVMfk7UGT87MnXb9wJGTjAyU2XKWevIrFhec2bsRfjo+zfh0rWWIPpzhr+VONZuuNaiUCvScpWTvqiX9NhNXfcsog0+kUZAnE8l59JDLED2cXnBmIt4Dn9buDMlIZfDcB900akG9P60XCvBt2LVM2dhHT8ww2FtiaIUr37dvjJ5jaRZ/8OhJrtjafg34M8SrVi/baFEGP5nvHHxWRgcrnDg1R73RPK52qtZIf3gemv0280T0PYMM/uKRKtVykf5ykUppnWakpw3R5/O3FBWcaQ7Ra4tcB+jdsIIh+hkF+AwowLfhbBn8jk0rz+h2LLMXvt5Y4MePT57/8DwsZvCXbiAeoq+xsRwHwYBeQMmw/3jLqYCZVJKDNQnwhYLxtO0b1u/wPER/W8nQfE5D9CPVMmOTzW1yw9oit/5VBlewyG5We+AzoAmPNgz29jBcLfNQS9nYR0+0F+Cbe+GbHxIOHZtibt7Pf4EdLAb4PYPzTNfh/scmeUFlAWoEtUJ1NJ7KOD5ZW9yKN5VZgE+G6OMAX86mKt+bb9jLYydnM3nuVCQFZ6Yey22IfmSgwsnZBvXGAhPTdXa28dqTnFSGVjBErww+C8rg27RruJ/DY0sz+JV/8hyuluntKZyWwScn2J33FjlYHKLfUY1WZP/gkRNs6gkxgz/zuNpoiD6D4e01yOABnr93hJufvSOT505NMg+f1yK7eORmYrq+OAcv61yyin6ZQl2LNAefCQX4Nu3e3L84B//kzByTtcaKt8gBmBnblpSNPXj0JH09RS4aSSEzjDP4bf3RivJaY4EN5Wj7WF7zpllozeATmdSChzMz+G7eypPMw+e4yA7g6JMzTM42FOA7Qd8m8HkYP3T2x8zNBDXCuF4owLdp93CVI0/OUGvMt72CPrF0q9yBIyf5ua2DFAsprAaOizsMl+qU4ucbKs1HGVchnP/dyRx863G105kvsjsR9WM3b+VZDPA5zcHHAf7QsagEsgJ8B7jqldGZ9P/6VlhYWP4xjVll8BkI5x1/jewe7sc9KhG70jrwS7UeduPu3JfGEbWJeH642JheXPU/UJoP7sXT21NksLd0Wgaf3Sr6lgy+2xcC5T1EHxecUYDvIENb4aUfgJ99Hb77yeUfMzej11YGFODb1Fo2Nlkot5oMfmyqzuzcPA9PzDBZa3Dl1hQW2MHiED21KfbEQ/7VYiOoLXKJ0YHTD7vJfhX9RCZ74DtKcthNKa85+Oi/++PHo21X2ibXIZ75W3DRC+Er74UnHz3z541akO9ReVOAb9Pu4WbZ2EdPzNDbU2C4zSyitWzswaPRArt0M3iD+jR74rZWC3PBZfAAI4PN42oXFpzp+hrMwXd7lpFzBj9QKVEpFfjx41EGr21yHcIMfvVvo7n4L/7BmQvuGjPdvbYlIwrwbRqulqmWi4sBftvGvrYPp2k97ObAkZMUC8blF55HDfhWZlEWX5/iopHov9Nn4WbwySr66Xq0qDDTVfQLDWXwOc/BmxkjA5XFKS5l8B1k80Vww3vhgS/DvZ87/Wdzs1pklwEF+DaZGbuGqzw0cYpHn5hpe/4dlmTwR05yyWiV3p4UA1NlAGqTvOCyUa67dJihnvDm4CE+jz7O4JNSsZlm8KAMfjGDz+9AntasfdN6PdZXlvec34Pt18Cd74jKDieUwWdCAX4Vdm/u5/D4dHzITft/lBcMVigWbDGDT2X/e6tyFepT7B6uctvvPJeehXqQAX5koMzkbIPZuXmmakkGrwCfqR2/AFfdDFuvzq0JyZTYhr4eSmnXHZBsFYpw00ejk+3ufGfzuubgM6FXxyrsHunn4YlTjE3VV5XBl4oFLhzq5YePPsljJ2fTOcGuVXkAalPN+4EeIpHshR+bqi1Wkst0mxxoiL5vI9z8idPPpV9jyWE3WkHfobZcAS98B9z7Wbj/zmg+vqGjarOgAL8KuzdXmZuPFom0u4I+sX1TH9/4STRElcoZ9K0qg1BvHqcb7TEN79Nx6174zErFwukHBOlNKHfJEL0CfAe77q2w5WnwxbfB1LHoWoBJSN4U4Fch2SoHzQVz7dqxsW/xQ0L6Q/QDUG+p3hR4Bn98spbtEH2xBBavkej2DH4dGI0/2GmBXQcrleGmj0R1De58e3RNH55TpwC/CskBMnB+GTzAtg29bEo7E6ksHaIPPYNvBvhMMnhofkBSgM9dksG3uz1V1pntz4ZffBMc/EJ0P8D3qLwpwK/Cto199BSNYsG4YHB1f5TJ3P2Vac+/w+Iiu0WBZvDJG/3xyVrLEH1GtdSTNx9lGblLTrNL/YOxrL3r3wObL45uaxV96hTgV6FYMHZu6ufCod5Vr+JNMvjU599hmUV2M0F+Oq6Uimzo64kz+GibXCZD9KAMfh1RBh+Qcj+84iNQKMHQtrxbE5wurppxfp5z8WZm6vOr/v3LLxxkqLfEL+0dSbFVscpgFNQX5qNtKYFm8NDcCz/U20PBoC/N8wRaKYNfN3Zu7mdkoJzNh2NZe3ueD+88vFgoS9KjAL9Kf/nrzziv398y2MsP/+ylKbVmieQ8+voU9G4Idg4eor3wY1M1LhjqpVoptX2q4Iopg183hnp7uOdPXpx3MyRNCu6ZyHSI3sz2mdn9ZnbIzN51lsf8ppkdNLMDZvapluu3mNkD8dctWbYzOHFFOWpTUXnG+TAPugEYHexdnIPPbHgelMGLSMfJ7B3RzIrArcCLgUeAb5vZHe5+sOUxe4F3A9e5+xNmtiW+vhl4H3AN4MB34t99Iqv2BiX5NFyfgvm42lqg5zxHGXyd6XpGleQSixm8AryIdIYsM/hrgUPu/qC714FPAzcteczvArcmgdvd4xMPeClwl7tPxD+7C9iXYVvD0jpE35iNbgebwVeYqjU4PlnLOMAnGbyG6EWkM2QZ4LcDD7fcfyS+1uoy4DIz+28z+18z29fG78rZVJo14WnEGXywc/DRv+vw+KlsKskllMGLSIfJMsAvt9ppSRFgSsBe4HrgNcDHzWzjCn8XM3uDmd1jZvccP378PJsbkC7L4CHaC18tK4MXEUlkGeAfAXa23N8BHFnmMV9w9zl3/ylwP1HAX8nv4u4fc/dr3P2a0dHRVBvf0crdk8Enx5YCDPRqkZ2ISCLLAP9tYK+ZXWRmZeDVwB1LHvN54EUAZjZCNGT/IPBl4CVmtsnMNgEvia/JSiRD9PVJmJuJbgeewUOGh9yAMngR6TiZvSO6e8PMfp8oMBeB/e5+wMzeD9zj7nfQDOQHgXng7e4+DmBmf0H0IQHg/e4+kVVbg7M4RD8dfAbfWlFMq+hFRJoyPejG3b8EfGnJtT9tue3A2+Kvpb+7H9ifZfuCVa4CFg/Rhz0H31MssLlaZmK6nnEGH/dfWRm8iHQGnUUfIrO4ZGzrHHyYAR6ivfAA1XKWq+g1RC8inUUBPlTlKtQmg8/goTkPn+kQ/a7nweUvg6IKnIhIZ9BZ9KGqdFMGHwX4TIfo994YfYmIdAhl8KEqD8SL7JIMPsxFdtDcKpfpNjkRkQ6jAB+qymBXLLIDGFmLIXoRkQ6jAB+q8kC0Dz7wbXIAWzdEH1429PXk3BIRkfVDAT5U5WqcwYd90A3Avqsu5O9e9ywuGR3IuykiIuuGAnyoTltkZ1AMN7utlIrsu2pr3s0QEVlXFOBD1brIrtQb7Y0XEZGuoQAfqsogzJ2C+qmg599FRGR5CvChKlej76fGdX66iEgXUoAPVVJw5tS4MngRkS6kAB+qymD0fXos6BX0IiKyPAX4UCmDFxHpagrwoaq0Bnhl8CIi3UYBPlTJIjufVwYvItKFFOBDVR5s3lYGLyLSdRTgQ1VpObZVGbyISNdRgA9VuTXAK4MXEek2CvCh6ukH4uNpFeBFRLqOAnyoCoXmQjsFeBGRrqMAH7JkmF5z8CIiXUcBPmTJQjtl8CIiXUcBPmRlBXgRkW6lAB8yDdGLiHQtBfiQaYheRKRrKcCHTBm8iEjXUoAPmTJ4EZGupQAfsiSD71GAFxHpNgrwIdPJGhzjAAAGC0lEQVQqehGRrqUAH7KK5uBFRLqVAnzIlMGLiHQtBfiQVeKa8MrgRUS6jgJ8yHZfB1e9EkYuz7slIiKyxkp5N0AyNLQVbt6fdytERCQHyuBFREQCpAAvIiISIAV4ERGRACnAi4iIBEgBXkREJEAK8CIiIgFSgBcREQmQAryIiEiAFOBFREQCpAAvIiISIAV4ERGRACnAi4iIBEgBXkREJEAK8CIiIgFSgBcREQmQAryIiEiAFOBFREQCpAAvIiISIHP3vNuQCjM7Dvws5acdAcZSfs5upb5Mh/oxPerL9Kgv09NuX+5299HlfhBMgM+Cmd3j7tfk3Y4QqC/ToX5Mj/oyPerL9KTZlxqiFxERCZACvIiISIAU4J/ax/JuQEDUl+lQP6ZHfZke9WV6UutLzcGLiIgESBm8iIhIgBTgl2Fm+8zsfjM7ZGbvyrs9ncTM9pvZMTO7t+XaZjO7y8weiL9vyrONncLMdprZV83sPjM7YGZvia+rP9tkZr1m9i0z+0Hcl38eX7/IzL4Z9+U/m1k577Z2AjMrmtn3zOyL8X314yqY2WEz+5GZfd/M7omvpfb6VoBfwsyKwK3ALwNXAq8xsyvzbVVH+Qdg35Jr7wLudve9wN3xfTm3BvCH7n4F8FzgTfHfovqzfTXgBnf/eeBqYJ+ZPRf4EPDXcV8+Abw+xzZ2krcA97XcVz+u3ovc/eqWrXGpvb4V4M90LXDI3R909zrwaeCmnNvUMdz9a8DEkss3AZ+Mb38S+LU1bVSHcvej7v7d+PYk0RvqdtSfbfPIVHy3J/5y4Abgs/F19eUKmNkO4GXAx+P7hvoxTam9vhXgz7QdeLjl/iPxNVm9C9z9KERBC9iSc3s6jpntAZ4JfBP156rEw8rfB44BdwE/AU64eyN+iF7rK/M3wDuAhfj+MOrH1XLgK2b2HTN7Q3wttdd3KYUGhsaWuaatBpIbMxsAPge81d1PRgmTtMvd54GrzWwjcDtwxXIPW9tWdRYzezlwzN2/Y2bXJ5eXeaj6cWWuc/cjZrYFuMvM/i/NJ1cGf6ZHgJ0t93cAR3JqSygeN7OtAPH3Yzm3p2OYWQ9RcL/N3f8lvqz+PA/ufgL4D6J1DRvNLEl09Fo/t+uAV5jZYaLpyxuIMnr14yq4+5H4+zGiD53XkuLrWwH+TN8G9sarQsvAq4E7cm5Tp7sDuCW+fQvwhRzb0jHiuc1PAPe5+1+1/Ej92SYzG40zd8ysD7iRaE3DV4Gb44epL8/B3d/t7jvcfQ/Re+O/u/trUT+2zcyqZjaY3AZeAtxLiq9vHXSzDDP7FaJPpUVgv7t/MOcmdQwz+yfgeqKKSI8D7wM+D3wG2AU8BPyGuy9diCdLmNnzgf8CfkRzvvM9RPPw6s82mNkziBYsFYkSm8+4+/vN7GKiTHQz8D3gde5ey6+lnSMeov8jd3+5+rF9cZ/dHt8tAZ9y9w+a2TApvb4V4EVERAKkIXoREZEAKcCLiIgESAFeREQkQArwIiIiAVKAFxERCZACvIgAYGbzcVWr5Cu1IjZmtqe1wqCIZE9H1YpIYsbdr867ESKSDmXwIvKU4prVH4rrqX/LzC6Nr+82s7vN7Ifx913x9QvM7Pa49voPzOx58VMVzezv43rsX4lPlBORjCjAi0iib8kQ/atafnbS3a8FPkp0yiPx7X9092cAtwEfjq9/GPjPuPb6s4AD8fW9wK3u/jTgBPDKjP89Il1NJ9mJCABmNuXuA8tcPwzc4O4PxsVvHnP3YTMbA7a6+1x8/ai7j5jZcWBH61Glcbnbu9x9b3z/nUCPu38g+3+ZSHdSBi8iK+FnuX22xyyn9WzyebQGSCRTCvAishKvavn+jfj2/xBVFAN4LfD1+PbdwBsBzKxoZkNr1UgRadInaBFJ9JnZ91vu/5u7J1vlKmb2TaKk4DXxtTcD+83s7cBx4Lfj628BPmZmryfK1N8IHM289SJyGs3Bi8hTiufgr3H3sbzbIiIrpyF6ERGRACmDFxERCZAyeBERkQApwIuIiARIAV5ERCRACvAiIiIBUoAXEREJkAK8iIhIgP4fx7nY/zNaVyoAAAAASUVORK5CYII=\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"# Plot train vs test loss during training\n",
"plot_loss(h_callback.history['loss'], h_callback.history['val_loss'])\n",
"\n",
"# Plot train vs test accuracy during training\n",
"# \n",
"plot_accuracy(h_callback.history['accuracy'], h_callback.history['val_accuracy'])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Early stopping your model\n",
"The early stopping callback is useful since it allows for you to stop the model training if it no longer improves after a given number of epochs. To make use of this functionality you need to pass the callback inside a list to the model's callback parameter in the `.fit()` method.\n",
"\n",
"The `model` you built to detect fake dollar bills is loaded for you to train, this time with early stopping. `X_train`, `y_train`, `X_test` and `y_test` are also available for you to use."
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
"# Normlize the data\n",
"X = banknotes.iloc[:, :4]\n",
"X = ((X - X.mean()) / X.std()).to_numpy()\n",
"y = banknotes['class'].to_numpy()\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, stratify=y)"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [],
"source": [
"# Create a sequential model\n",
"model = Sequential()\n",
"\n",
"# Add a dense layer\n",
"model.add(Dense(1, input_shape=(4, ), activation='sigmoid'))\n",
"\n",
"# Compile your model\n",
"model.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy'])"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch 1/100\n",
"33/33 [==============================] - 0s 3ms/step - loss: 1.1413 - accuracy: 0.4052 - val_loss: 1.0880 - val_accuracy: 0.4198\n",
"Epoch 2/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.9852 - accuracy: 0.4490 - val_loss: 0.9373 - val_accuracy: 0.4606\n",
"Epoch 3/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.8559 - accuracy: 0.4801 - val_loss: 0.8066 - val_accuracy: 0.5044\n",
"Epoch 4/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.7452 - accuracy: 0.5432 - val_loss: 0.7030 - val_accuracy: 0.5627\n",
"Epoch 5/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.6581 - accuracy: 0.6210 - val_loss: 0.6263 - val_accuracy: 0.6385\n",
"Epoch 6/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.5934 - accuracy: 0.6890 - val_loss: 0.5683 - val_accuracy: 0.7289\n",
"Epoch 7/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.5438 - accuracy: 0.7891 - val_loss: 0.5240 - val_accuracy: 0.8367\n",
"Epoch 8/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.5052 - accuracy: 0.8707 - val_loss: 0.4889 - val_accuracy: 0.8688\n",
"Epoch 9/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.4742 - accuracy: 0.9018 - val_loss: 0.4609 - val_accuracy: 0.8921\n",
"Epoch 10/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.4489 - accuracy: 0.9106 - val_loss: 0.4384 - val_accuracy: 0.8980\n",
"Epoch 11/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.4282 - accuracy: 0.9145 - val_loss: 0.4194 - val_accuracy: 0.9067\n",
"Epoch 12/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.4105 - accuracy: 0.9203 - val_loss: 0.4030 - val_accuracy: 0.9184\n",
"Epoch 13/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.3950 - accuracy: 0.9164 - val_loss: 0.3887 - val_accuracy: 0.9184\n",
"Epoch 14/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.3814 - accuracy: 0.9271 - val_loss: 0.3762 - val_accuracy: 0.9155\n",
"Epoch 15/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.3694 - accuracy: 0.9261 - val_loss: 0.3649 - val_accuracy: 0.9184\n",
"Epoch 16/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.3586 - accuracy: 0.9291 - val_loss: 0.3550 - val_accuracy: 0.9213\n",
"Epoch 17/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.3489 - accuracy: 0.9310 - val_loss: 0.3457 - val_accuracy: 0.9242\n",
"Epoch 18/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.3398 - accuracy: 0.9349 - val_loss: 0.3373 - val_accuracy: 0.9242\n",
"Epoch 19/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.3316 - accuracy: 0.9349 - val_loss: 0.3295 - val_accuracy: 0.9242\n",
"Epoch 20/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.3239 - accuracy: 0.9378 - val_loss: 0.3222 - val_accuracy: 0.9242\n",
"Epoch 21/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.3167 - accuracy: 0.9388 - val_loss: 0.3155 - val_accuracy: 0.9242\n",
"Epoch 22/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.3101 - accuracy: 0.9427 - val_loss: 0.3092 - val_accuracy: 0.9271\n",
"Epoch 23/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.3038 - accuracy: 0.9397 - val_loss: 0.3032 - val_accuracy: 0.9300\n",
"Epoch 24/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.2979 - accuracy: 0.9397 - val_loss: 0.2975 - val_accuracy: 0.9271\n",
"Epoch 25/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.2923 - accuracy: 0.9407 - val_loss: 0.2922 - val_accuracy: 0.9329\n",
"Epoch 26/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.2870 - accuracy: 0.9407 - val_loss: 0.2871 - val_accuracy: 0.9359\n",
"Epoch 27/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.2820 - accuracy: 0.9407 - val_loss: 0.2824 - val_accuracy: 0.9388\n",
"Epoch 28/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.2773 - accuracy: 0.9436 - val_loss: 0.2777 - val_accuracy: 0.9388\n",
"Epoch 29/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.2727 - accuracy: 0.9456 - val_loss: 0.2733 - val_accuracy: 0.9446\n",
"Epoch 30/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.2684 - accuracy: 0.9475 - val_loss: 0.2691 - val_accuracy: 0.9446\n",
"Epoch 31/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.2642 - accuracy: 0.9475 - val_loss: 0.2651 - val_accuracy: 0.9446\n",
"Epoch 32/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.2602 - accuracy: 0.9495 - val_loss: 0.2612 - val_accuracy: 0.9446\n",
"Epoch 33/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.2564 - accuracy: 0.9495 - val_loss: 0.2575 - val_accuracy: 0.9446\n",
"Epoch 34/100\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.2527 - accuracy: 0.9495 - val_loss: 0.2539 - val_accuracy: 0.9446\n"
]
}
],
"source": [
"from tensorflow.keras.callbacks import EarlyStopping\n",
"\n",
"# Define a callback to monitor val_acc\n",
"monitor_val_acc = EarlyStopping(monitor='val_accuracy', patience=5)\n",
"\n",
"# Train your model using early stopping callback\n",
"model.fit(X_train, y_train, epochs=100, validation_data=(X_test, y_test), \n",
" callbacks=[monitor_val_acc]);"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### A combination of callbacks\n",
"Deep learning models can take a long time to train, especially when you move to deeper architectures and bigger datasets. Saving your model every time it improves as well as stopping it when it no longer does allows you to worry less about choosing the number of epochs to train for. You can also restore a saved model anytime and resume training where you left it.\n",
"\n",
"Use the `EarlyStopping()` and the `ModelCheckpoint()` callbacks so that you can go eat a jar of cookies while you leave your computer to work!"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch 1/100000000000\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.2492 - accuracy: 0.9504 - val_loss: 0.2504 - val_accuracy: 0.9475\n",
"Epoch 2/100000000000\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.2457 - accuracy: 0.9514 - val_loss: 0.2471 - val_accuracy: 0.9475\n",
"Epoch 3/100000000000\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.2425 - accuracy: 0.9524 - val_loss: 0.2438 - val_accuracy: 0.9475\n",
"Epoch 4/100000000000\n",
"33/33 [==============================] - 0s 2ms/step - loss: 0.2393 - accuracy: 0.9543 - val_loss: 0.2407 - val_accuracy: 0.9475\n"
]
}
],
"source": [
"from tensorflow.keras.callbacks import ModelCheckpoint\n",
"\n",
"# Early stop on validation accuracy\n",
"monitor_val_acc = EarlyStopping(monitor='val_accuracy', patience=3)\n",
"\n",
"# Save the best model as best_banknote_model.hdf5\n",
"modelCheckpoint = ModelCheckpoint('./best_banknote_model.hdf5', save_best_only=True)\n",
"\n",
"# Fit your model for a stupid amount of epochs\n",
"h_callback = model.fit(X_train, y_train,\n",
" epochs=100000000000,\n",
" callbacks=[monitor_val_acc, modelCheckpoint],\n",
" validation_data=(X_test, y_test))"
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"best_banknote_model.hdf5\r\n"
]
}
],
"source": [
"!ls | grep best_banknote*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now you always save the model that performed best, even if you early stopped at one that was already performing worse."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.6"
}
},
"nbformat": 4,
"nbformat_minor": 4
}