From e3d32f66b0d735b6c9f99a67fe072e250d3a31d4 Mon Sep 17 00:00:00 2001 From: Anna Date: Sat, 4 May 2024 22:09:47 +0200 Subject: [PATCH] Completed lab --- your-code/main.ipynb | 2392 +++++++++++++++++++++++++++++++++--------- 1 file changed, 1870 insertions(+), 522 deletions(-) diff --git a/your-code/main.ipynb b/your-code/main.ipynb index 5759add..95b0cfc 100644 --- a/your-code/main.ipynb +++ b/your-code/main.ipynb @@ -1,522 +1,1870 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Understanding Descriptive Statistics\n", - "\n", - "Import the necessary libraries here:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Libraries" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Challenge 1\n", - "#### 1.- Define a function that simulates rolling a dice 10 times. Save the information in a dataframe.\n", - "**Hint**: you can use the *choices* function from module *random* to help you with the simulation." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 2.- Plot the results sorted by value." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 3.- Calculate the frequency distribution and plot it. What is the relation between this plot and the plot above? Describe it with words." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Challenge 2\n", - "Now, using the dice results obtained in *challenge 1*, your are going to define some functions that will help you calculate the mean of your data in two different ways, the median and the four quartiles. \n", - "\n", - "#### 1.- Define a function that computes the mean by summing all the observations and dividing by the total number of observations. You are not allowed to use any methods or functions that directly calculate the mean value. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 2.- First, calculate the frequency distribution. Then, calculate the mean using the values of the frequency distribution you've just computed. You are not allowed to use any methods or functions that directly calculate the mean value. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 3.- Define a function to calculate the median. You are not allowed to use any methods or functions that directly calculate the median value. \n", - "**Hint**: you might need to define two computation cases depending on the number of observations used to calculate the median." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 4.- Define a function to calculate the four quartiles. You can use the function you defined above to compute the median but you are not allowed to use any methods or functions that directly calculate the quartiles. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Challenge 3\n", - "Read the csv `roll_the_dice_hundred.csv` from the `data` folder.\n", - "#### 1.- Sort the values and plot them. What do you see?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 2.- Using the functions you defined in *challenge 2*, calculate the mean value of the hundred dice rolls." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 3.- Now, calculate the frequency distribution.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 4.- Plot the histogram. What do you see (shape, values...) ? How can you connect the mean value to the histogram? " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 5.- Read the `roll_the_dice_thousand.csv` from the `data` folder. Plot the frequency distribution as you did before. Has anything changed? Why do you think it changed?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Challenge 4\n", - "In the `data` folder of this repository you will find three different files with the prefix `ages_population`. These files contain information about a poll answered by a thousand people regarding their age. Each file corresponds to the poll answers in different neighbourhoods of Barcelona.\n", - "\n", - "#### 1.- Read the file `ages_population.csv`. Calculate the frequency distribution and plot it as we did during the lesson. Try to guess the range in which the mean and the standard deviation will be by looking at the plot. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 2.- Calculate the exact mean and standard deviation and compare them with your guesses. Do they fall inside the ranges you guessed?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 3.- Now read the file `ages_population2.csv` . Calculate the frequency distribution and plot it." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 4.- What do you see? Is there any difference with the frequency distribution in step 1?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 5.- Calculate the mean and standard deviation. Compare the results with the mean and standard deviation in step 2. What do you think?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Challenge 5\n", - "Now is the turn of `ages_population3.csv`.\n", - "\n", - "#### 1.- Read the file `ages_population3.csv`. Calculate the frequency distribution and plot it." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 2.- Calculate the mean and standard deviation. Compare the results with the plot in step 1. What is happening?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 3.- Calculate the four quartiles. Use the results to explain your reasoning for question in step 2. How much of a difference is there between the median and the mean?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 4.- Calculate other percentiles that might be useful to give more arguments to your reasoning." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Bonus challenge\n", - "Compare the information about the three neighbourhoods. Prepare a report about the three of them. Remember to find out which are their similarities and their differences backing your arguments in basic statistics." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# your code here" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "your comments here\n", - "\"\"\"" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "ironhack-3.7", - "language": "python", - "name": "ironhack-3.7" - }, - "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.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Understanding Descriptive Statistics\n", + "\n", + "Import the necessary libraries here:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Libraries\n", + "import numpy as np\n", + "import pandas as pd\n", + "from random import choices\n", + "import matplotlib.pyplot as plt\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenge 1\n", + "#### 1.- Define a function that simulates rolling a dice 10 times. Save the information in a dataframe.\n", + "**Hint**: you can use the *choices* function from module *random* to help you with the simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here\n", + "def dice_rolls(num_rolls=10, sides=6):\n", + " #from 1 to sides (inclusive)\n", + " rolls = choices(range(1, sides + 1), k=num_rolls)\n", + " \n", + " df = pd.DataFrame({'Roll': range(1, num_rolls + 1), 'Result': rolls})\n", + " \n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
RollResult
121
451
342
892
233
014
784
9105
566
676
\n", + "
" + ], + "text/plain": [ + " Roll Result\n", + "1 2 1\n", + "4 5 1\n", + "3 4 2\n", + "8 9 2\n", + "2 3 3\n", + "0 1 4\n", + "7 8 4\n", + "9 10 5\n", + "5 6 6\n", + "6 7 6" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dice_rolls_df = dice_rolls()\n", + "dice_rolls_df = dice_rolls_df.sort_values(by='Result')\n", + "dice_rolls_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.- Plot the results sorted by value." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# your code here\n", + "plt.figure(figsize=(8, 5))\n", + "plt.bar(dice_rolls_df['Roll'], dice_rolls_df['Result'])\n", + "plt.xlabel('Roll')\n", + "plt.ylabel('Dice Value')\n", + "plt.title('Dice Rolls Sorted by Value')\n", + "plt.xticks(dice_rolls_df['Roll'])\n", + "plt.grid(axis='y')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.- Calculate the frequency distribution and plot it. What is the relation between this plot and the plot above? Describe it with words." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1 2\n", + "2 2\n", + "3 1\n", + "4 2\n", + "5 1\n", + "6 2\n", + "Name: Result, dtype: int64" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "frequency_dist = dice_rolls_df['Result'].value_counts().sort_index()\n", + "frequency_dist" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8, 5))\n", + "plt.bar(frequency_dist.index, frequency_dist.values)\n", + "plt.xlabel('Dice Value')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Frequency Distribution of Dice Rolls')\n", + "plt.xticks(frequency_dist.index)\n", + "plt.grid(axis='y')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'frequency distribution plot shows how often each value occurred across all rolls while Dice Rolls Sorted by Value shows the result of each roll'" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"frequency distribution plot shows how often each value occurred across all rolls while Dice Rolls Sorted by Value shows the result of each roll\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenge 2\n", + "Now, using the dice results obtained in *challenge 1*, your are going to define some functions that will help you calculate the mean of your data in two different ways, the median and the four quartiles. \n", + "\n", + "#### 1.- Define a function that computes the mean by summing all the observations and dividing by the total number of observations. You are not allowed to use any methods or functions that directly calculate the mean value. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here\n", + "\n", + "def calculate_mean(data):\n", + " total_sum = 0\n", + " for value in data:\n", + " total_sum = total_sum + value\n", + " mean_value = total_sum/len(data)\n", + " return mean_value" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.- First, calculate the frequency distribution. Then, calculate the mean using the values of the frequency distribution you've just computed. You are not allowed to use any methods or functions that directly calculate the mean value. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean value: 3.4\n" + ] + } + ], + "source": [ + "# your code here\n", + "\n", + "frequency_dist = dice_rolls_df['Result'].value_counts().sort_index()\n", + "\n", + "sum_products = 0\n", + "for value, frequency in frequency_dist.items():\n", + " sum_products += value * frequency\n", + "\n", + "total_count = frequency_dist.sum()\n", + "\n", + "mean = sum_products / total_count if total_count > 0 else 0\n", + "\n", + "print(\"Mean value:\", mean)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.- Define a function to calculate the median. You are not allowed to use any methods or functions that directly calculate the median value. \n", + "**Hint**: you might need to define two computation cases depending on the number of observations used to calculate the median." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here\n", + "\n", + "def calculate_median(data):\n", + " sorted_data = sorted(data)\n", + "\n", + " num_observations = len(sorted_data)\n", + " is_odd = num_observations % 2 != 0\n", + "\n", + " if is_odd:\n", + " median_index = num_observations // 2\n", + " median_value = sorted_data[median_index]\n", + " else:\n", + " upper_median_index = num_observations // 2\n", + " lower_median_index = upper_median_index - 1\n", + " median_value = (sorted_data[lower_median_index] + sorted_data[upper_median_index]) / 2\n", + "\n", + " return median_value\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3.5" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculate_median(dice_rolls_df['Result'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 4.- Define a function to calculate the four quartiles. You can use the function you defined above to compute the median but you are not allowed to use any methods or functions that directly calculate the quartiles. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here\n", + "\n", + "def calculate_quartiles(data):\n", + " sorted_data = sorted(data)\n", + "\n", + " median = calculate_median(sorted_data)\n", + "\n", + " lower_half = [x for x in sorted_data if x < median]\n", + " upper_half = [x for x in sorted_data if x > median]\n", + "\n", + " q1 = calculate_median(lower_half)\n", + "\n", + " q3 = calculate_median(upper_half)\n", + "\n", + " return q1, median, q3\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2, 3.5, 5)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculate_quartiles(dice_rolls_df['Result'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenge 3\n", + "Read the csv `roll_the_dice_hundred.csv` from the `data` folder.\n", + "#### 1.- Sort the values and plot them. What do you see?" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Unnamed: 0rollvalue
0001
1112
2226
3331
4446
\n", + "
" + ], + "text/plain": [ + " Unnamed: 0 roll value\n", + "0 0 0 1\n", + "1 1 1 2\n", + "2 2 2 6\n", + "3 3 3 1\n", + "4 4 4 6" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "roll_the_dice_hundred = pd.read_csv('/Users/anna/iron_hack/Descriptive-Stats/data/roll_the_dice_hundred.csv')\n", + "roll_the_dice_hundred.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 1\n", + "47 1\n", + "56 1\n", + "9 1\n", + "73 1\n", + "63 1\n", + "26 1\n", + "89 1\n", + "3 1\n", + "94 1\n", + "82 1\n", + "97 1\n", + "33 2\n", + "37 2\n", + "41 2\n", + "Name: value, dtype: int64" + ] + }, + "execution_count": 105, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sorted_values = roll_the_dice_hundred['value'].sort_values()\n", + "sorted_values.head(15)" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0EAAAIjCAYAAADFthA8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABPYUlEQVR4nO3deXxU9b3/8fckmewLJCEkKEsEFAH1yipulCubuFz3K4YrAqI/ChW1rS22CqlVxN66VC2IreBG3aniFRQ3cGFHVAQp2uAGGJNAVhKSzPf3R5iBISzJkDnnTM7r+XjweDDnnJnzPfAlyZvv53yOxxhjBAAAAAAuEWX3AAAAAADASoQgAAAAAK5CCAIAAADgKoQgAAAAAK5CCAIAAADgKoQgAAAAAK5CCAIAAADgKoQgAAAAAK5CCAIAAADgKoQgAECTvf/++/J4PHr//fctPe+2bdvk8Xg0f/58S88bDk8//bR69Oghr9erNm3aWHruGTNmyOPxBG3r0qWLrrvuOkvHAQB2IwQBgEU+//xzXXHFFercubPi4+N13HHHadiwYXr44Ydb/Fz33HOP/vnPf7b45zbFxRdfrMTERJWXlx/2mLy8PMXGxqq4uNjCkdnvyy+/1HXXXaeuXbvq8ccf19y5cw97rD+w+H95vV516dJFN910k3bv3m3doAGgFYqxewAA4AYff/yxhgwZok6dOmnixInKzs7Wd999p5UrV+qhhx7SL37xixY93z333KMrrrhCl1xySYt+blPk5eVp0aJFWrhwoa699tpG+6uqqvTqq69q5MiRysjIsHx8dnr//ffl8/n00EMPqVu3bk16z+zZs5WcnKzKykq98847evjhh7V+/Xp9+OGHYR4tALRehCAAsMDdd9+ttLQ0rVmzplEJVGFhYYucwxij6upqJSQktMjnheriiy9WSkqKFixYcMgQ9Oqrr6qyslJ5eXk2jM5e/r/r5pTBXXHFFcrMzJQk3Xjjjbr66qv1/PPPa/Xq1RowYEA4hgkArR7lcABgga+//lq9evU65A+/WVlZQa/r6up01113qWvXroqLi1OXLl10++23q6amJui4Ll266MILL9Sbb76pfv36KSEhQY899pg8Ho8qKyv15JNPBkqpDrzn44cfftD48ePVvn17xcXFqVevXnriiScajev777/XJZdcoqSkJGVlZemWW25pNIZDSUhI0GWXXaZ33nnnkAFvwYIFSklJ0cUXX6ySkhL96le/0imnnKLk5GSlpqbq/PPP16effnrU8/zsZz/Tz372s0bbr7vuOnXp0iVom8/n04MPPqhevXopPj5e7du314033qhdu3YFHbd27VqNGDFCmZmZSkhIUG5ursaPH3/UsUjSX//6V/Xq1UtxcXHq0KGDJk+eHFS21qVLF02fPl2S1K5dO3k8Hs2YMaNJn32gc845R1LDnDrQiy++qL59+yohIUGZmZkaM2aMfvjhh2Z/fm1trfLz89W9e3fFx8crIyNDZ599tpYuXdrszwIAp2IlCAAs0LlzZ61YsUIbN25U7969j3js9ddfryeffFJXXHGFfvnLX2rVqlWaOXOmNm/erIULFwYdu2XLFo0ePVo33nijJk6cqJNOOklPP/20rr/+eg0YMEA33HCDJKlr166SpB9//FFnnHGGPB6PpkyZonbt2mnx4sWaMGGCysrKdPPNN0uS9uzZo/POO0/ffvutbrrpJnXo0EFPP/203n333SZdb15enp588km98MILmjJlSmB7SUmJ3nzzTY0ePVoJCQn64osv9M9//lNXXnmlcnNz9eOPP+qxxx7T4MGDtWnTJnXo0KGpf8RHdOONN2r+/PkaN26cbrrpJhUUFOiRRx7RJ598oo8++kher1eFhYUaPny42rVrp9/+9rdq06aNtm3bpldeeeWonz9jxgzl5+dr6NChmjRpkrZs2aLZs2drzZo1gc9/8MEH9dRTT2nhwoWBErdTTz212deybds2SVLbtm0D2/zX1r9/f82cOVM//vijHnroIX300Uf65JNPmrXyNGPGDM2cOTMwh8rKyrR27VqtX79ew4YNa/Z4AcCRDAAg7N566y0THR1toqOjzaBBg8xtt91m3nzzTbN3796g4zZs2GAkmeuvvz5o+69+9Ssjybz77ruBbZ07dzaSzJIlSxqdLykpyYwdO7bR9gkTJpicnBxTVFQUtP3qq682aWlppqqqyhhjzIMPPmgkmRdeeCFwTGVlpenWrZuRZN57770jXm9dXZ3JyckxgwYNCto+Z84cI8m8+eabxhhjqqurTX19fdAxBQUFJi4uzvzhD38I2ibJzJs3L7Bt8ODBZvDgwY3OPXbsWNO5c+fA6w8++MBIMs8++2zQcUuWLAnavnDhQiPJrFmz5ojXdrDCwkITGxtrhg8fHnQtjzzyiJFknnjiicC26dOnG0nmp59+Ourn+o/dsmWL+emnn8y2bdvME088YRISEky7du1MZWWlMcaYvXv3mqysLNO7d2+zZ8+ewPtff/11I8nceeedjT7zQJ07dw6aK6eddpq54IILmvVnAACRhnI4ALDAsGHDtGLFCl188cX69NNPdd9992nEiBE67rjj9NprrwWOe+ONNyRJt956a9D7f/nLX0qS/u///i9oe25urkaMGNGkMRhj9PLLL+uiiy6SMUZFRUWBXyNGjFBpaanWr18fGEdOTo6uuOKKwPsTExMDK0tHEx0drauvvlorVqwIrFxIDaVw7du313nnnSdJiouLU1RUw7ei+vp6FRcXKzk5WSeddFJgLMfqxRdfVFpamoYNGxZ0zX379lVycrLee+89Sfvv03n99ddVW1vb5M9/++23tXfvXt18882Ba5GkiRMnKjU1tdHfWXOddNJJateunbp06aLx48erW7duWrx4sRITEyU1lPAVFhbq5z//ueLj4wPvu+CCC9SjR49mn79Nmzb64osvtHXr1mMaNwA4GSEIACzSv39/vfLKK9q1a5dWr16tadOmqby8XFdccYU2bdokSfrmm28UFRXVqHNYdna22rRpo2+++SZoe25ubpPP/9NPP2n37t2aO3eu2rVrF/Rr3LhxkvbfuP/NN9+oW7dujZ4pc9JJJzX5fP7GBwsWLJDUcI/RBx98oKuvvlrR0dGSGu7VeeCBB9S9e3fFxcUpMzNT7dq102effabS0tImn+tItm7dqtLSUmVlZTW67oqKisA1Dx48WJdffrny8/OVmZmp//qv/9K8efOOeh+U/+/k4D+b2NhYnXDCCY3+zprr5Zdf1tKlS7VgwQKdccYZKiwsDGp+cbjzS1KPHj2aff4//OEP2r17t0488USdcsop+vWvf63PPvvsmK4BAJyGe4IAwGKxsbHq37+/+vfvrxNPPFHjxo3Tiy++GLhpXlKj8HE4zekE5/P5JEljxozR2LFjD3lMKPeoHE7fvn3Vo0cP/eMf/9Dtt9+uf/zjHzLGBHWFu+eee3THHXdo/Pjxuuuuu5Senq6oqCjdfPPNgfEejsfjkTGm0fb6+vqg1z6fT1lZWXr22WcP+Tnt2rULfN5LL72klStXatGiRXrzzTc1fvx4/fnPf9bKlSuVnJzc3D+CFnHuuecGusNddNFFOuWUU5SXl6d169YFrTy15Pm+/vprvfrqq3rrrbf0t7/9TQ888IDmzJmj66+/vsXPBwB2IAQBgI369esnSdqxY4ekhgYKPp9PW7du1cknnxw47scff9Tu3bvVuXPnJn3uoUJUu3btlJKSovr6eg0dOvSI7+/cubM2btwoY0zQZ23ZsqVJ5/fLy8vTHXfcoc8++0wLFixQ9+7d1b9//8D+l156SUOGDNHf//73oPft3r078IP/4bRt21b//ve/G20/eOWja9euevvtt3XWWWc1KTSeccYZOuOMM3T33XdrwYIFysvL03PPPXfYAOD/O9myZYtOOOGEwPa9e/eqoKDgqH/WzZGcnKzp06dr3LhxeuGFF3T11VcHnf8///M/g47fsmVLk+fMgdLT0zVu3DiNGzdOFRUVOvfcczVjxgxCEIBWg3I4ALDAe++9d8hVC/89QP5SplGjRkmSHnzwwaDj7r//fkkN93k0RVJSUlB7ZqnhPp3LL79cL7/8sjZu3NjoPT/99FPg96NGjdL27dv10ksvBbZVVVVp7ty5TTq/n3/V584779SGDRsaPRsoOjq60Z/Liy++2KTWzl27dtWXX34ZNO5PP/1UH330UdBxV111lerr63XXXXc1+oy6urrAn9OuXbsajeU//uM/JOmIJXFDhw5VbGys/vKXvwS9/+9//7tKS0ub/HfWVHl5eTr++OM1a9YsSQ1BOisrS3PmzAka5+LFi7V58+Zmn7+4uDjodXJysrp169ak9ugAEClYCQIAC/ziF79QVVWVLr30UvXo0UN79+7Vxx9/rOeff15dunQJ3JNz2mmnaezYsZo7d652796twYMHa/Xq1XryySd1ySWXaMiQIU06X9++ffX222/r/vvvV4cOHZSbm6uBAwfq3nvv1XvvvaeBAwdq4sSJ6tmzp0pKSrR+/Xq9/fbbKikpkdRwU/8jjzyia6+9VuvWrVNOTo6efvrpwM34TZWbm6szzzxTr776qiQ1CkEXXnih/vCHP2jcuHE688wz9fnnn+vZZ58NWlE5nPHjx+v+++/XiBEjNGHCBBUWFmrOnDnq1auXysrKAscNHjxYN954o2bOnKkNGzZo+PDh8nq92rp1q1588UU99NBDuuKKK/Tkk0/qr3/9qy699FJ17dpV5eXlevzxx5WamhoIp4fSrl07TZs2Tfn5+Ro5cqQuvvhibdmyRX/961/Vv39/jRkzpll/Zkfj9Xo1depU/frXv9aSJUs0cuRIzZo1S+PGjdPgwYM1evToQIvsLl266JZbbmnW5/fs2VM/+9nP1LdvX6Wnp2vt2rV66aWXglqdA0DEs60vHQC4yOLFi8348eNNjx49THJysomNjTXdunUzv/jFL8yPP/4YdGxtba3Jz883ubm5xuv1mo4dO5pp06aZ6urqoOM6d+582FbGX375pTn33HNNQkKCkRTUAvnHH380kydPNh07djRer9dkZ2eb8847z8ydOzfoM7755htz8cUXm8TERJOZmWmmTp0aaCt9tBbZB3r00UeNJDNgwIBG+6qrq80vf/lLk5OTYxISEsxZZ51lVqxY0aj99aFaZBtjzDPPPGNOOOEEExsba/7jP/7DvPnmm41aZPvNnTvX9O3b1yQkJJiUlBRzyimnmNtuu81s377dGGPM+vXrzejRo02nTp1MXFycycrKMhdeeKFZu3Ztk67zkUceMT169DBer9e0b9/eTJo0yezatSvomFBaZB/q2NLSUpOWlhb0Z/T888+b008/3cTFxZn09HSTl5dnvv/++0N+5oEObpH9xz/+0QwYMMC0adPGJCQkmB49epi77767UTt3AIhkHmMOUZ8BAAAAAK0U9wQBAAAAcBVCEAAAAABXIQQBAAAAcBVCEAAAAABXIQQBAAAAcBVCEAAAAABXieiHpfp8Pm3fvl0pKSnyeDx2DwcAAACATYwxKi8vV4cOHRQVdeS1nogOQdu3b1fHjh3tHgYAAAAAh/juu+90/PHHH/GYiA5BKSkpkhouNDU11dax1NbW6q233tLw4cPl9XptHQsiC3MHoWDeIBTMG4SKuYNQWD1vysrK1LFjx0BGOJKIDkH+ErjU1FRHhKDExESlpqbyxQHNwtxBKJg3CAXzBqFi7iAUds2bptwmQ2MEAAAAAK5CCAIAAADgKoQgAAAAAK5CCAIAAADgKoQgAAAAAK5CCAIAAADgKoQgAAAAAK5CCAIAAADgKoQgAAAAAK5CCAIAAADgKoQgAAAAAK5CCAIAAADgKoQgAAAAAK4SY/cAAAAAcOzqfUarC0pUWF6trJR4DchNV3SU56j7mvLeVQUlWlfkUUZBiQZ1y2rS5zppn9PG44brdzrbQ9APP/yg3/zmN1q8eLGqqqrUrVs3zZs3T/369bN7aAAAABFhycYdyl+0STtKqwPbctLiNf2inpJ02H0je+c0473Remrr2iZ9rpP2Ne8aW98+O65/ZO8cOZ3HGGPsOvmuXbt0+umna8iQIZo0aZLatWunrVu3qmvXruratetR319WVqa0tDSVlpYqNTXVghEfXm1trd544w2NGjVKXq/X1rEgsjB3EArmDULBvGmdlmzcoUnPrNfBP9B5pEbbDtwnSTecm6u5ywua/d5I2Se1/mt02vVL0uwxfTSyd47lX3Oakw1sXQmaNWuWOnbsqHnz5gW25ebm2jgiAACAyFHvM8pftOmQP5Qe6X+5/fvmftD4h+OmvjdS9rnhGo+0z+rr96hhhWhYz+wjHGk/W0PQa6+9phEjRujKK6/UsmXLdNxxx+nnP/+5Jk6ceMjja2pqVFNTE3hdVlYmqeF/tmpray0Z8+H4z2/3OBB5mDsIBfMGoWDetD6rCkqCypGay756IOu44RqPxOrrN5J2lFZrxVeF6nN8iiTrvuY05zy2lsPFx8dLkm699VZdeeWVWrNmjaZOnao5c+Zo7NixjY6fMWOG8vPzG21fsGCBEhMTwz5eAAAAJ1lX5NFTW6PtHgbQyLXd69U309qYUVVVpWuuuaZJ5XC2hqDY2Fj169dPH3/8cWDbTTfdpDVr1mjFihWNjj/USlDHjh1VVFTkiHuCli5dqmHDhlFnjWZh7iAUzBuEgnnT+qwqKNGYJ9baPQygkWfG91Of41Ms/ZpTVlamzMxM598TlJOTo549ewZtO/nkk/Xyyy8f8vi4uDjFxcU12u71eh3zxdxJY0FkYe4gFMwbhIJ503oM6palnLR47SytPuK9GocT5Wkol2rNFWNuuMYjsfr6PZKy0+I1qFuWfPV1kqz7mtOcc9j6sNSzzjpLW7ZsCdr2r3/9S507d7ZpRAAAAJEjOsoTaFd88NNZPIf5vf+1R9LEc3JDem+k7HPDNR5pn13XP/2ino5/XpCtIeiWW27RypUrdc899+irr77SggULNHfuXE2ePNnOYQEAAESMkb1zNHtMH7VLCa6WyU6L15wxfTRnTB9lp8U32jd7TB9NG9VTsw+z/0jvjZR9brhGp12/vz2209l6T5Akvf7665o2bZq2bt2q3Nxc3XrrrYftDncwnhOE1oC5g1AwbxAK5k3rtvGHUl348IdKjovW49f214Dc9MD/xtf7jFYXlKiwvFpZKfFB+462v95ntOKrQr31wSoNP2egBnXLatLnOmmf08bjhuuXrP+aEzHPCZKkCy+8UBdeeKHdwwAAAIhou6sa2gN3aJOgQV0zgvZFR3kabWvq/ugojwbmpqt4s9HAg37IPdr7nLLPaeNxw/U7na3lcAAAAGgZxZUNHXTTk2JtHgngfIQgAACAVqC4Yq8kKSO5cSddAMEIQQAAAK2AfyUok5Ug4KgIQQAAAK1ASWXDSlB6EitBwNEQggAAAFqBokA5HCtBwNEQggAAAFqB4op95XCEIOCoCEEAAACtgL8cjsYIwNERggAAAFoBf3c4WmQDR0cIAgAAiHA1dfUqr6mTJGXSGAE4KkIQAABAhPOXwsVEeZSaEGPzaADnIwQBAABEuANL4Twej82jAZyPEAQAABDhivZ1hqMpAtA0hCAAAIAI518Joj020DSEIAAAgAjnvyeIznBA0xCCAAAAIlxR5b5yODrDAU1CCAIAAIhw/nK4DMrhgCYhBAEAAEQ4fzlcBuVwQJMQggAAACJcMd3hgGYhBAEAAES4IsrhgGYhBAEAAEQ4yuGA5iEEAQAARLCqvXXaU1sviXI4oKkIQQAAABHM3xkuLiZKSbHRNo8GiAyEIAAAgAhWvK8ULjM5Th6Px+bRAJGBEAQAABDB/J3h0rkfCGgyQhAAAEAE40GpQPMRggAAACJYcaAzHE0RgKYiBAEAAESw/Q9KZSUIaCpCEAAAQAQr5hlBQLMRggAAACJYIATxjCCgyQhBAAAAESxQDsdKENBkhCAAAIAIRnc4oPkIQQAAABHKGKPiSn9jBMrhgKYiBAEAAESo8po61dYbSZTDAc1BCAIAAIhQ/lK4pNhoxXujbR4NEDkIQQAAABFq/zOCKIUDmoMQBAAAEKH87bHTKYUDmoUQBAAAEKH85XCZdIYDmoUQBAAAEKH2PyOIcjigOQhBAAAAEcpfDsczgoDmIQQBAABEKO4JAkJDCAIAAIhQ/nK4TLrDAc1CCAIAAIhQJZTDASEhBAEAAESoogrK4YBQEIIAAAAikM9ntKvK3yKbcjigOQhBAAAAEah0T63qfUaS1DaRlSCgOQhBAAAAEai4sqEpQmp8jGJj+JEOaA7+xQAAAEQg//1AlMIBzUcIAgAAiEDFFXSGA0JFCAIAAIhAJfvK4egMBzQfIQgAACACFQVWgiiHA5qLEAQAABCB/I0RMlkJApqNEAQAABCBSip5UCoQKkIQAABABKIcDggdIQgAACACFVc0lMPRHQ5oPkIQAABABPKXw/GcIKD5CEEAAAARpq7ep11VtZK4JwgIBSEIAAAgwpRUNawCeTxS20RCENBchCAAAIAIE+gMlxir6CiPzaMBIg8hCAAAIMIUV9AeGzgWhCAAAIAIU0RnOOCYEIIAAAAijL8cjmcEAaEhBAEAAEQYfzlcBuVwQEgIQQAAABGmuHJfOVwSK0FAKAhBAAAAEabIvxLEPUFASAhBAAAAESZwTxDlcEBICEEAAAARpjjQHY5yOCAUhCAAAIAIU0w5HHBMCEEAAAARpKauXuU1dZIohwNCRQgCAACIIP77gWKiPEqN99o8GiAyEYIAAAAiiL8ULj0pVlFRHptHA0QmQhAAAEAEKfZ3hqMpAhAyQhAAAEAECXSG434gIGQxdg8AAAC4T73PaHVBiQrLq5WVEq8BuemK3lfaZfU+p43naPvWf7NLkmSMUb3PBF0HgKaxNQTNmDFD+fn5QdtOOukkffnllzaNCAAAhNuSjTuUv2iTdpRWB7blpMVr+kU9JcnSfSN75zhqPM3Z99HXxTp71ruB6wDQdLavBPXq1Utvv/124HVMjO1DAgAAYbJk4w5Nema9zEHbd5ZW6/89s/6Q7wnXvknPrNcN5+Zq7vICR4znWK5j9pg+BCGgGWxPHDExMcrOzrZ7GAAAIMzqfUb5izY1ChySDrnNin1zP2gcgOwcTyj7PGpYIRrWM5vSOKCJbA9BW7duVYcOHRQfH69BgwZp5syZ6tSp0yGPrampUU1NTeB1WVmZJKm2tla1tbWWjPdw/Oe3exyIPMwdhIJ5g1DYPW9WFZQElXk5gTlSwogQRtKO0mqt+KpQA3PTw3IOu+cOIpPV86Y55/EYY98//8WLF6uiokInnXSSduzYofz8fP3www/auHGjUlJSGh1/qHuIJGnBggVKTEy0YsgAACBE64o8emprtN3DaLWu7V6vvpmtINUBIaqqqtI111yj0tJSpaamHvFYW0PQwXbv3q3OnTvr/vvv14QJExrtP9RKUMeOHVVUVHTUCw232tpaLV26VMOGDZPXy9Ob0XTMHYSCeYNQ2D1vVhWUaMwTay0/r1s8M75fWFeC+JqD5rJ63pSVlSkzM7NJIcj2crgDtWnTRieeeKK++uqrQ+6Pi4tTXFzjB4N5vV7H/IN00lgQWZg7CAXzBqGwa94M6palnLR47SytPuJ9LlaK8jSUxDllPKHwSMpOi9egbllhvyeIrzkIhVXzpjnncNTDUisqKvT1118rJ4fuJgAAtDbRUZ5Aq+eDeQ7z+3Du80iaeE6upecM177pF/WkKQLQDLaGoF/96ldatmyZtm3bpo8//liXXnqpoqOjNXr0aDuHBQAAwmRk7xzNHtNHyXHBxSjZafGaM6aP5ozpo+y0eEv2zR7TR9NG9dRsC88ZruugPTbQPLaWw33//fcaPXq0iouL1a5dO5199tlauXKl2rVrZ+ewAABAGI3snaMPvyrSMyu/1fCe7TXurFwNyE0PrGQM65mt1QUlKiyvVlZKfNj3jeydY/k5w7EPQNPZGoKee+45O08PAABssquyoZXtoK4ZGtQ1I2hfdJSn0bZw7rPjnOG6DgBN46h7ggAAgDsUVzZ0e01PirV5JADciBAEAAAsV1yxV5KUmdy46ysAhBshCAAAWK64siEEZSSzEgTAeoQgAABgqXqf0a6qhhBEORwAOxCCAACApXZV7ZXZ93TS9ERCEADrEYIAAICl/PcDtU30KiaaH0UAWI+vPAAAwFL+znAZNEUAYBNCEAAAsJR/JYj7gQDYhRAEAAAsVVzRsBKUSWc4ADYhBAEAAEuV+NtjJ1EOB8AehCAAAGCpokrK4QDYixAEAAAsRTkcALsRggAAgKX8jRHoDgfALoQgAABgqRLK4QDYjBAEAAAsVUQ5HACbEYIAAIBl9tb5VFZdJ4nucADsQwgCAACW2VXVUAoXHeVRWoLX5tEAcCtCEAAAsIy/FK5tYqyiojw2jwaAWxGCAACAZfyd4bgfCICdCEEAAMAydIYD4ASEIAAAYBl/ORzPCAJgJ0IQAACwTPG+laAMVoIA2IgQBAAALFPCPUEAHIAQBAAALFNc2VAOl84zggDYiBAEAAAsU7RvJSiDlSAANiIEAQAAy/i7w1EOB8BOhCAAAGCZ4grK4QDYjxAEAAAsUV1br8q99ZIohwNgL0IQAACwhL89dmx0lFLiYmweDQA3IwQBAABL7C+Fi5XH47F5NADcjBAEAAAsUUxnOAAOQQgCAACWKNq3EpSRTFMEAPYiBAEAAEv422NnJLESBMBehCAAAGCJYkIQAIcgBAEAAEtQDgfAKQhBAADAEpTDAXAKQhAAALAE3eEAOAUhCAAAWKKYcjgADkEIAgAAYWeMoTECAMcgBAEAgLCr3FuvmjqfJMrhANiPEAQAAMLOXwqX4I1WYmyMzaMB4HaEIAAAEHaBUjhWgQA4ACEIAACEXaAzHPcDAXAAQhAAAAg7OsMBcBJCEAAACDs6wwFwEkIQAAAIO385XDr3BAFwAEIQAAAIu+LKhnK4zCTK4QDYjxAEAADCLtAYgZUgAA5ACAIAAGHnvyconXuCADgAIQgAAISdvztcJt3hADgAIQgAAISVMUYlPCwVgIMQggAAQFiV7alTnc9IohwOgDMQggAAQFgV7esMlxIXo7iYaJtHAwCEIAAAEGZ0hgPgNIQgAAAQViX7VoIyaIoAwCEIQQAAIKyKKmiPDcBZCEEAACCs/OVwmZTDAXAIQhAAAAirQDlcEuVwAJyBEAQAAMKqqJJyOADOQggCAABhVVzhb4xACALgDIQgAAAQViWV/nuCKIcD4AyEIAAAEFbFdIcD4DCEIAAAEDb1PqOSKh6WCsBZCEEAACBsdlXtlTENv09PJAQBcAZCEAAACBv//UBtEr2KiebHDgDOwFcjAAAQNkX+znDcDwTAQQhBAAAgbPxNETLoDAfAQQhBAAAgbPzlcKwEAXASQhAAAAgbHpQKwIkIQQAAIGyKAitBlMMBcA5CEAAACJuSffcEZbISBMBBCEEAACBsiisbyuHSWQkC4CAxdg8AAGC/ep/R6oISFZZXKyslXgNy0xUd5WnS/ta+z2njOZZ9qwpKtK7Io4yCEg3qlmXJ9X9fskeStLNsj+p9JuhzAcAujglB9957r6ZNm6apU6fqwQcftHs4AOAaSzbuUP6iTdpRWh3YlpMWr+kX9dTI3jlH3C+pVe9rndcfrae2rrXu+ssa9t31+mb97YOCwOcCgJ08xhhj9yDWrFmjq666SqmpqRoyZEiTQ1BZWZnS0tJUWlqq1NTU8A7yKGpra/XGG29o1KhR8nq9to4FkYW5g1C01LxZsnGHJj2zXgd/I/D/X/0N5+Zq7vKCQ+4/3DeP1rJP4vrDcf2SNHtMH4JQhOF7FUJh9bxpTjaw/Z6giooK5eXl6fHHH1fbtm3tHg4AuEa9zyh/0aZD/sBq9v2a+0HjH4D9+w+ntezj+sN3/fmLNqneZ/v/wQJwMdvL4SZPnqwLLrhAQ4cO1R//+McjHltTU6OamprA67KyMkkNKbO2tjas4zwa//ntHgciD3MHoWiJebOqoCSojOlQ7K8VsBfXH4bPlLSjtForvirUwNz0lj8BwoLvVQiF1fOmOeexNQQ999xzWr9+vdasWdOk42fOnKn8/PxG29966y0lJia29PBCsnTpUruHgAjF3EEojmXerCvySIpuucEAzfDWB6tUvNnlKTMC8b0KobBq3lRVVTX5WNtC0HfffaepU6dq6dKlio+Pb9J7pk2bpltvvTXwuqysTB07dtTw4cMdcU/Q0qVLNWzYMGpl0SzMHYSiJeZNRkGJntq6toVHBjTN8HMGshIUQfhehVBYPW/8VWJNYVsIWrdunQoLC9WnT5/Atvr6ei1fvlyPPPKIampqFB0d/D+UcXFxiotr/JwBr9frmH+QThoLIgtzB6E4lnkzqFuWctLitbO0+rD3cUR5Gkqi3Pr/9Vx/y1+/R1J2WnxQi25EDr5XIRRWzZvmnMO2xgjnnXeePv/8c23YsCHwq1+/fsrLy9OGDRsaBSAAQMuKjvIEWhkf/KOoZ9+viefkHnb/oX7fmvZx/eG7/ukX9SQAAbCVbStBKSkp6t27d9C2pKQkZWRkNNoOAAiPkb1zNHtMH01/7Qv9WLa/8Uz2Ac+JOb1T20bPgsk+wnNiWtM+rj881097bAB2s707HADAXiN756hbVoqG3r9McdEezR8/UANy0wP/Uz+yd46G9czW6oISFZZXKyslPmh/a9/Xmq5/xVeFeuuDVRp+zsCgcjQ7rh8A7OSoEPT+++/bPQQAcKXdVXslSe3TEjSoa0aj/dFRnkNud8M+p43nWPYNzE1X8WajgQeFETuuHwDsZPvDUgEA9iuubAhB6UmxNo8EAIDwIwQBAFRc0RCCMpMJQQCA1o8QBABQcUVDU4SMpMaPIQAAoLUhBAEA9pfDsRIEAHABQhAAIBCCMrgnCADgAoQgAECgHC4zmXI4AEDrRwgCAKjEvxJEORwAwAUIQQAAFVXQIhsA4B6EIABwOZ/PaFeVv0U25XAAgNaPEAQALle6p1b1PiNJapvIShAAoPUjBAGAyxVXNjRFSI2PUWwM3xYAAK0f3+0AwOX89wNRCgcAcAtCEAC4XHEFneEAAO5CCAIAlyvZVw5HZzgAgFsQggDA5YoCK0GUwwEA3IEQBAAu52+MkMlKEADAJQhBAOByJZU8KBUA4C6EIABwOcrhAABuE1IIqqur09tvv63HHntM5eXlkqTt27eroqKiRQcHAAi/4oqGcji6wwEA3CKmuW/45ptvNHLkSH377beqqanRsGHDlJKSolmzZqmmpkZz5swJxzgBAGHiL4fLSGIlCADgDs1eCZo6dar69eunXbt2KSEhIbD90ksv1TvvvNOigwMAhFddvU+7qmolsRIEAHCPZq8EffDBB/r4448VGxv8zbJLly764YcfWmxgAIDwK6lqWAXyeKS2iYQgAIA7NHslyOfzqb6+vtH277//XikpKS0yKACANQKd4RJjFR3lsXk0AABYo9khaPjw4XrwwQcDrz0ejyoqKjR9+nSNGjWqJccGAAiz4graYwMA3KfZ5XB//vOfNWLECPXs2VPV1dW65pprtHXrVmVmZuof//hHOMYIAAiTIjrDAQBcqNkh6Pjjj9enn36q5557Tp999pkqKio0YcIE5eXlBTVKAAA4X6AzHM8IAgC4SLNDkCTFxMRozJgxLT0WAIDF/OVwGZTDAQBcpNkh6Kmnnjri/muvvTbkwQAArFVcua8cjmcEAQBcpNkhaOrUqUGva2trVVVVpdjYWCUmJhKCACCCBFaCuCcIAOAize4Ot2vXrqBfFRUV2rJli84++2waIwBAhCmupBwOAOA+zQ5Bh9K9e3fde++9jVaJAADOVhzoDkc5HADAPVokBEkNzRK2b9/eUh8HALAA5XAAADdq9j1Br732WtBrY4x27NihRx55RGeddVaLDQwAEF41dfUqr6mTRDkcAMBdmh2CLrnkkqDXHo9H7dq103/+53/qz3/+c0uNCwAQZv5nBMVEeZQa77V5NAAAWKfZIcjn84VjHAAAi/lL4dKTYhUV5bF5NAAAWKfF7gkCAEQWf2e4dErhAAAu06SVoFtvvbXJH3j//feHPBgAgHX8neEy6QwHAHCZJoWgTz75pEkf5vFQTgEAkYLOcAAAt2pSCHrvvffCPQ4AgMX2PyiVlSAAgLtwTxAAuNT+B6WyEgQAcJdmd4eTpLVr1+qFF17Qt99+q7179wbte+WVV1pkYACA8Nq/EkQIAgC4S7NXgp577jmdeeaZ2rx5sxYuXKja2lp98cUXevfdd5WWlhaOMQIAwiAQgmiMAABwmWaHoHvuuUcPPPCAFi1apNjYWD300EP68ssvddVVV6lTp07hGCMAIAz85XC0yAYAuE2zQ9DXX3+tCy64QJIUGxuryspKeTwe3XLLLZo7d26LDxAAEB7+7nCZ3BMEAHCZZoegtm3bqry8XJJ03HHHaePGjZKk3bt3q6qqqmVHBwAIi6q9ddpTWy+JcjgAgPs0OQT5w865556rpUuXSpKuvPJKTZ06VRMnTtTo0aN13nnnhWeUAIAW5V8Fio2JUlJstM2jAQDAWk3uDnfqqaeqf//+uuSSS3TllVdKkn73u9/J6/Xq448/1uWXX67f//73YRsoAKDl+JsiZCbF8qBrAIDrNDkELVu2TPPmzdPMmTN199136/LLL9f111+v3/72t+EcHwAgDPY/I4hSOACA+zS5HO6cc87RE088oR07dujhhx/Wtm3bNHjwYJ144omaNWuWdu7cGc5xAgBakH8liM5wAAA3anZjhKSkJI0bN07Lli3Tv/71L1155ZV69NFH1alTJ1188cXhGCMAoIX57wnKoDMcAMCFmh2CDtStWzfdfvvt+v3vf6+UlBT93//9X0uNCwAQRv5yuEzK4QAALtTke4IOtnz5cj3xxBN6+eWXFRUVpauuukoTJkxoybEBAMKkhHI4AICLNSsEbd++XfPnz9f8+fP11Vdf6cwzz9Rf/vIXXXXVVUpKSgrXGAEALaxoXwjKIAQBAFyoySHo/PPP19tvv63MzExde+21Gj9+vE466aRwjg0AECaUwwEA3KzJIcjr9eqll17ShRdeqOhoHqwHAJHMXw5HYwQAgBs1OQS99tpr4RwHAMAixphAdzjuCQIAuNExdYcDAESe8po67a33SZIykiiHAwC4DyEIAFymZN8qUFJstBJiKW8GALgPIQgAXKa4sqEpQjr3AwEAXIoQBAAuU1Thb49NKRwAwJ0IQQDgMv7OcJmsBAEAXIoQBAAu439GEJ3hAABuRQgCAJcJlMPxoFQAgEsRggDAZYr9D0plJQgA4FKEIABwmZJ93eEyuCcIAOBShCAAcJliusMBAFyOEAQALrP/niBWggAA7kQIAgAX8fmMdlWxEgQAcDdCEAC4SOmeWtX7jCRaZAMA3IsQBAAuUryvKUJqfIxiY/gWAABwJ74DAoCL+JsiZPKMIACAixGCAMBF/M8IohQOAOBmMXYPAIB71fuMVheUqLC8Wlkp8RqQm67oKE9E7bNrPKsKSrSuyKOMghIN6pbV5Pet3VYiSfJ4Gl4feB0AALiFrSFo9uzZmj17trZt2yZJ6tWrl+68806df/75dg4LgAWWbNyh/EWbtKO0OrAtJy1e0y/qKUkRsW9k7xybryNaT21dG9Jnrtm2S2fPejdwHQAAuInHGGPsOvmiRYsUHR2t7t27yxijJ598Un/605/0ySefqFevXkd9f1lZmdLS0lRaWqrU1FQLRnx4tbW1euONNzRq1Ch5vV5bx4LI4sa5s2TjDk16Zr0O/uLjkRptc+o+Sbrh3FzNXV4Q8dcxe0wfgpBLuPHrDVoGcwehsHreNCcb2HpP0EUXXaRRo0ape/fuOvHEE3X33XcrOTlZK1eutHNYAMKo3meUv2jTIX8wP9L/yDhtn5E094PGAciu8RzLvvxFmwJtswEAcAPH3BNUX1+vF198UZWVlRo0aNAhj6mpqVFNTU3gdVlZmaSGlFlbW2vJOA/Hf367x4HI47a5s6qgJKhcK5LZt47ecoykHaXVWvFVoQbmpts9HISZ277eoOUwdxAKq+dNc85jazmcJH3++ecaNGiQqqurlZycrAULFmjUqFGHPHbGjBnKz89vtH3BggVKTEwM91ABtIB1RR49tTXa7mHgINd2r1ffzFaQ6gAArlVVVaVrrrmmSeVwtoegvXv36ttvv1Vpaaleeukl/e1vf9OyZcvUs2fPRsceaiWoY8eOKioqcsQ9QUuXLtWwYcOolUWzuG3urCoo0Zgn1to9DBzkmfH9WAlyAbd9vUHLYe4gFFbPm7KyMmVmZjYpBNleDhcbG6tu3bpJkvr27as1a9booYce0mOPPdbo2Li4OMXFNX7An9frdcw/SCeNBZHFLXNnULcs5aTFa2dp9RHvV4kEUZ6GkrhIvg6PpOy0+KA222j93PL1Bi2PuYNQWDVvmnMOxz0s1efzBa32AGhdoqM8gZbNB/Mc5vdO3OeRNPGcXMeM51j2Tb+oJwEIAOAqtoagadOmafny5dq2bZs+//xzTZs2Te+//77y8vLsHBaAMBvZO0ezx/RRXEzwl6DstHjNGdNHc8b0UXZavKP3zR7TR9NG9dRsh4znWK6D9tgAALextRyusLBQ1157rXbs2KG0tDSdeuqpevPNNzVs2DA7hwXAAiN75+jknK+14btSTTgrV0N7tteA3PTAisSwntlaXVCiwvJqZaXEO3bfyN45toxnxVeFeuuDVRp+zsCgUrZQPxMAADexNQT9/e9/t/P0AGxWUtnQyvL8U7LVr0vwTfnRUR4N6ppxyPc5aZ9d4xmYm67izUYDDwoyx3IdAAC4hePuCQLgHiWVeyVJ6UmxNo8EAAC4CSEIgC2qa+tVUVMnScpIbtz1EQAAIFwIQQBsUbxvFcgb7VFqvO3d+gEAgIsQggDYoqRifymcx8PN+QAAwDqEIAC2KKpseB5YRhKlcAAAwFqEIAC2KN63EpSRTFMEAABgLUIQAFuU7FsJyqQpAgAAsBghCIAtiitojw0AAOxBCAJgiyLK4QAAgE0IQQBsESiHozECAACwGCEIgC38zwmiHA4AAFiNEATAFnSHAwAAdiEEAbCcMUZFFXSHAwAA9iAEAbBc1d561dT5JFEOBwAArEcIAmA5fylcvDdKibHRNo8GAAC4DSEIgOWK9nWGy0iKk8fjsXk0AADAbQhBACxXQlMEAABgI0IQAMsVB1aCCEEAAMB6hCAAlisKrATRGQ4AAFiPEATAciX7HpTKShAAALADIQiA5Yr3PSOIe4IAAIAdCEEALFccWAmiHA4AAFiPEATAcsV0hwMAADYiBAGwXPEBzwkCAACwGiEIgKWMMfsbI7ASBAAAbEAIAmCpsuo61dYbSVI63eEAAIANCEEALOXvDJccF6N4b7TNowEAAG5ECAJgqWJK4QAAgM0IQQAsFegMRykcAACwCSEIgKX8neHS6QwHAABsQggCYCn/SlAm5XAAAMAmhCAAlvI3RuCeIAAAYBdCEABL+RsjUA4HAADsQggCYCnK4QAAgN0IQQAs5W+MkMFKEAAAsAkhCIClSgLlcKwEAQAAexCCAFim3mcCIYhyOAAAYBdCEADL7K7aK59p+H1bVoIAAIBNCEEALONfBWqT6JU3mi8/AADAHvwUAsAyRRXcDwQAAOxHCAJgGX9nuEw6wwEAABsRggBYxl8Ol0FTBAAAYCNCEADLUA4HAACcgBAEwDLFFfselJpMORwAALAPIQiAZXhGEAAAcAJCEADLFFMOBwAAHIAQBMAyRfu6w2XQHQ4AANiIEATAMv6VIMrhAACAnQhBACxRW+9T6Z5aSZTDAQAAexGCAFhi176mCFEeqU0iIQgAANiHEATAEgc+Iyg6ymPzaAAAgJsRggBYwt8em1I4AABgN0IQAEsU0xkOAAA4BCEIgCX85XAZdIYDAAA2IwQBsETJvpWgzGRWggAAgL0IQQAsUVzBPUEAAMAZCEEALEE5HAAAcApCEABLlNAYAQAAOAQhCIAliitZCQIAAM5ACAJgCf89QRncEwQAAGxGCAIQdtW19aqoqZMkZdAdDgAA2IwQBCDsSvaVwnmjPUqNj7F5NAAAwO0IQQDC7sD22B6Px+bRAAAAtyMEAQi7IjrDAQAAByEEAQi7Ep4RBAAAHIQQBCDsigMrQYQgAABgP0IQgLALtMemMxwAAHAAQhCAsPM/KDWdlSAAAOAAhCAAYVdc0VAOl8k9QQAAwAEIQQDCzr8SRHc4AADgBIQgAGFXTHc4AADgIIQgAGFljDmgOxwrQQAAwH4xdg8AOJx6n9HqghIVllcrKyVeA3LTFR3liah9TXnvqoISrSvyKKOgRIO6ZTnyOo7lGsur61Rd65Mkff1ThY5rmxD0XgAAAKvZGoJmzpypV155RV9++aUSEhJ05plnatasWTrppJPsHBYcYMnGHcpftEk7SqsD23LS4jX9op6SFBH7RvbOacZ1ROuprWsdeR3Heo13vPpFYPu4+WuC3gsAAGAHjzHG2HXykSNH6uqrr1b//v1VV1en22+/XRs3btSmTZuUlJR01PeXlZUpLS1NpaWlSk1NtWDEh1dbW6s33nhDo0aNktfrtXUskW7Jxh2a9Mx6HTwxPVKjbU7dJ0k3nJurucsLIvo6wnWNkjR7TB+C0DHgaw5CwbxBqJg7CIXV86Y52cDWlaAlS5YEvZ4/f76ysrK0bt06nXvuuTaNCnaq9xnlL9p0yB+gj5TWnbhv7geNw4Gd4wnHvlCv0aOG1aVhPbMpjQMAAJZz1D1BpaWlkqT09PRD7q+pqVFNTU3gdVlZmaSGlFlbWxv+AR6B//x2jyPSrSooCSqrimT2rbFaJ9RrNJJ2lFZrxVeFGph76H/vODK+5iAUzBuEirmDUFg9b5pzHlvL4Q7k8/l08cUXa/fu3frwww8PecyMGTOUn5/faPuCBQuUmJgY7iHCAuuKPHpqa7Tdw4BFru1er76ZjvgSBAAAIlxVVZWuueaaJpXDOSYETZo0SYsXL9aHH36o448//pDHHGolqGPHjioqKnLEPUFLly7VsGHDqJU9BqsKSjTmibV2DwMWeWZ8P1aCQsTXHISCeYNQMXcQCqvnTVlZmTIzM51/T5DflClT9Prrr2v58uWHDUCSFBcXp7i4xs8Z8Xq9jvkH6aSxRKJB3bKUkxavnaXVR7yvJBJEeRrKxSL9Oo4k1Gv0SMpOiw9qCY7Q8DUHoWDeIFTMHYTCqnnTnHPY+rBUY4ymTJmihQsX6t1331Vubq6dw4EDREd5Aq2VD+Y5zO+duM8jaeI5uY4ZTzj2Hes1Tr+oJwEIAADYwtYQNHnyZD3zzDNasGCBUlJStHPnTu3cuVN79uyxc1iw2cjeOZo9po/iY4KnZ3ZavOaM6aM5Y/ooOy3e0ftmj+mjaaN6arZDxuO0a6Q9NgAAsJOt9wR5PIf+X+B58+bpuuuuO+r7eU5Q63bl7I+15ptduu7MzhrRK0cDctMDKwf1PqPVBSUqLK9WVkq8Y/c15b0rvirUWx+s0vBzBgaVhznpOo71Go/0XoSGrzkIBfMGoWLuIBQ8J+gwHNKTAQ5VXLVXkjSiV44Gdc0I2hcd5Wm0zYn7mvLegbnpKt5sNPCgcOCk6zjWazzSewEAAKxmazkccCQllQ0hKCM51uaRAAAAoDUhBMGRaut92l3V8MCrjCRCEAAAAFoOIQiOtGvfKlCUR2qTSAgCAABAyyEEwZGK94Wg9KRYbqIHAABAiyIEwZGKK/aHIAAAAKAlEYLgSMWVNZKkjKQ4m0cCAACA1oYQBEfyrwTRGQ4AAAAtjRAER9q/EkQIAgAAQMsiBMGR9q8EUQ4HAACAlkUIgiMV86BUAAAAhAkhCI5UXEE5HAAAAMKDEARH2r8SRDkcAAAAWhYhCI4UuCeIlSAAAAC0MEIQHKe6tl4VNXWSWAkCAABAyyMEwXFK9pXCeaM9So2PsXk0AAAAaG0IQXAcfylcelKsPB6PzaMBAABAa0MIguPsf1AqpXAAAABoeYQgOM7+B6XSFAEAAAAtjxAEx9m/EkQIAgAAQMsjBMFxeEYQAAAAwokQBMc5sDECAAAA0NIIQXCc4oqGcrhM7gkCAABAGBCC4Dj+5wTRHQ4AAADhQAiC4xTRHQ4AAABhRAiC4/CcIAAAAIQTIQiOUrW3TtW1PkmsBAEAACA8CEFwFH9nuHhvlBJjo20eDQAAAFojQhAcpahifymcx+OxeTQAAABojQhBcJRAZzhK4QAAABAmhCA4ir8cLoMHpQIAACBMCEFwlKJ9neHS6QwHAACAMCEEwVH8K0GZlMMBAAAgTAhBcBTuCQIAAEC4EYLgKAd2hwMAAADCgRAER/GXw6WzEgQAAIAwIQTBUfzlcJmsBAEAACBMCEFwDGOMivd1h+OeIAAAAIQLIQiOUVZdp9p6I0lK5zlBAAAACBNCEBzDXwqXHBejeG+0zaMBAABAa0UIgmMUV1AKBwAAgPAjBMExivyd4SiFAwAAQBgRguAYgQel0hkOAAAAYUQIgmP4y+EyKYcDAABAGBGC4BjF/pUgQhAAAADCiBAEx/CHoHTK4QAAABBGhCA4BuVwAAAAsAIhCI5RXEFjBAAAAIQfIQiOUVzZsBJEi2wAAACEEyEIjuDzmUCLbMrhAAAAEE6EIDjC7j218pmG37dlJQgAAABhRAiCI/ibIqQleOWNZloCAAAgfPhpE47AM4IAAABgFUIQHMHfGS6TznAAAAAIM0IQHMHfGY6VIAAAAIQbIQiO4F8Joj02AAAAwo0QBEfYvxJEORwAAADCixAERwjcE0Q5HAAAAMKMEARH8HeHoxwOAAAA4UYIgiP4nxOUQXc4AAAAhBkhCI7gXwmiHA4AAADhRgiC7erqfdpdVSuJcjgAAACEHyEItiupalgFivJIbRIJQQAAAAgvQhBsd+AzgqKjPDaPBgAAAK0dIQi284cgmiIAAADACoQg2M7/oFTuBwIAAIAVCEGwXWAliM5wAAAAsAAhCLbzrwRlJlMOBwAAgPAjBMF2JZX7GyMAAAAA4UYIgu2KKIcDAACAhQhBsF1xRUM5HN3hAAAAYAVCEGznL4djJQgAAABWIATBdvufE0QIAgAAQPjF2D2A1qDeZ7SqoETrijzKKCjRoG5Zio7yBPatLihRYXm1slLiNSA3PbDvaPtbw76j7a/aW6fymjpJ0r+LKtU5IynovQAAAEBLszUELV++XH/605+0bt067dixQwsXLtQll1xi55CabcnGHcpftEk7SqslReuprWuVkxav6Rf1lKQD9jXw7xvZO+eg9wbvP9J7I2VfU67xzle/CGy//sm1Qe8FAAAAwsFjjDF2nXzx4sX66KOP1LdvX1122WXNDkFlZWVKS0tTaWmpUlNTwzfQw1iycYcmPbNeB/8BeqRG2w7cJ0k3nJurucsLmv3eSNknhX6NkjR7TB/XBKHa2lq98cYbGjVqlLxer93DQYRg3iAUzBuEirmDUFg9b5qTDWxdCTr//PN1/vnn2zmEkNX7jPIXbTrkD/NHSpX+fXM/aBwOmvreSNkX6jV61LC6NKxnNqVxAAAAaHERdU9QTU2NampqAq/LysokNaTM2tpaS8eyqqAkqMSruexbf7NOqNdoJO0ordaKrwo1MDe9RcfkRP65a/UcRmRj3iAUzBuEirmDUFg9b5pzHlvL4Q7k8XiOWg43Y8YM5efnN9q+YMECJSYmhnF0ja0r8uiprdGWntNtru1er76ZjpieAAAAcLiqqipdc801TSqHi6gQdKiVoI4dO6qoqMjye4JWFZRozBNrLT2n2zwzvp9rVoKWLl2qYcOGUWeNJmPeIBTMG4SKuYNQWD1vysrKlJmZ6fx7gporLi5OcXFxjbZ7vV7L/0EO6palnLR47SytPuI9LocT5WkoF3NEAg2TUK/RIyk7LT6o1bgb2DGPEfmYNwgF8wahYu4gFFbNm+acg4elhig6yhNo83zwj+mew/ze/9ojaeI5uSG9N1L2Hes1Tr+op6sCEAAAAKxjawiqqKjQhg0btGHDBklSQUGBNmzYoG+//dbOYTXZyN45mj2mj7LT4oO2Z6fFa86YPppzmH2zx/TRtFE9Q3pvpOw7lmt0U3tsAAAAWM/Wcri1a9dqyJAhgde33nqrJGns2LGaP3++TaNqnpG9czSsZ7ZWfFWotz5YpeHnDAwq4xrWM1urC0pUWF6trJR4DchND+zzv/dw+1vDvmO5RgAAACAcbA1BP/vZz+SQvgzHJDrKo4G56SrebDTwoB/io6M8GtQ144jvPdz+1rDvWN8LAAAAtDTuCQIAAADgKoQgAAAAAK5CCAIAAADgKoQgAAAAAK5CCAIAAADgKoQgAAAAAK5CCAIAAADgKoQgAAAAAK5CCAIAAADgKoQgAAAAAK5CCAIAAADgKoQgAAAAAK5CCAIAAADgKjF2D+BYGGMkSWVlZTaPRKqtrVVVVZXKysrk9XrtHg4iCHMHoWDeIBTMG4SKuYNQWD1v/JnAnxGOJKJDUHl5uSSpY8eONo8EAAAAgBOUl5crLS3tiMd4TFOikkP5fD5t375dKSkp8ng8to6lrKxMHTt21HfffafU1FRbx4LIwtxBKJg3CAXzBqFi7iAUVs8bY4zKy8vVoUMHRUUd+a6fiF4JioqK0vHHH2/3MIKkpqbyxQEhYe4gFMwbhIJ5g1AxdxAKK+fN0VaA/GiMAAAAAMBVCEEAAAAAXIUQ1ELi4uI0ffp0xcXF2T0URBjmDkLBvEEomDcIFXMHoXDyvInoxggAAAAA0FysBAEAAABwFUIQAAAAAFchBAEAAABwFUIQAAAAAFchBLWQRx99VF26dFF8fLwGDhyo1atX2z0kOMjMmTPVv39/paSkKCsrS5dccom2bNkSdEx1dbUmT56sjIwMJScn6/LLL9ePP/5o04jhRPfee688Ho9uvvnmwDbmDQ7nhx9+0JgxY5SRkaGEhASdcsopWrt2bWC/MUZ33nmncnJylJCQoKFDh2rr1q02jhh2q6+v1x133KHc3FwlJCSoa9euuuuuu3RgDy3mDZYvX66LLrpIHTp0kMfj0T//+c+g/U2ZIyUlJcrLy1NqaqratGmjCRMmqKKiwsKrIAS1iOeff1633nqrpk+frvXr1+u0007TiBEjVFhYaPfQ4BDLli3T5MmTtXLlSi1dulS1tbUaPny4KisrA8fccsstWrRokV588UUtW7ZM27dv12WXXWbjqOEka9as0WOPPaZTTz01aDvzBoeya9cunXXWWfJ6vVq8eLE2bdqkP//5z2rbtm3gmPvuu09/+ctfNGfOHK1atUpJSUkaMWKEqqurbRw57DRr1izNnj1bjzzyiDZv3qxZs2bpvvvu08MPPxw4hnmDyspKnXbaaXr00UcPub8pcyQvL09ffPGFli5dqtdff13Lly/XDTfcYNUlNDA4ZgMGDDCTJ08OvK6vrzcdOnQwM2fOtHFUcLLCwkIjySxbtswYY8zu3buN1+s1L774YuCYzZs3G0lmxYoVdg0TDlFeXm66d+9uli5dagYPHmymTp1qjGHe4PB+85vfmLPPPvuw+30+n8nOzjZ/+tOfAtt2795t4uLizD/+8Q8rhggHuuCCC8z48eODtl122WUmLy/PGMO8QWOSzMKFCwOvmzJHNm3aZCSZNWvWBI5ZvHix8Xg85ocffrBs7KwEHaO9e/dq3bp1Gjp0aGBbVFSUhg4dqhUrVtg4MjhZaWmpJCk9PV2StG7dOtXW1gbNox49eqhTp07MI2jy5Mm64IILguaHxLzB4b322mvq16+frrzySmVlZen000/X448/HthfUFCgnTt3Bs2dtLQ0DRw4kLnjYmeeeabeeecd/etf/5Ikffrpp/rwww91/vnnS2Le4OiaMkdWrFihNm3aqF+/foFjhg4dqqioKK1atcqyscZYdqZWqqioSPX19Wrfvn3Q9vbt2+vLL7+0aVRwMp/Pp5tvvllnnXWWevfuLUnauXOnYmNj1aZNm6Bj27dvr507d9owSjjFc889p/Xr12vNmjWN9jFvcDj//ve/NXv2bN166626/fbbtWbNGt10002KjY3V2LFjA/PjUN+7mDvu9dvf/lZlZWXq0aOHoqOjVV9fr7vvvlt5eXmSxLzBUTVljuzcuVNZWVlB+2NiYpSenm7pPCIEARabPHmyNm7cqA8//NDuocDhvvvuO02dOlVLly5VfHy83cNBBPH5fOrXr5/uueceSdLpp5+ujRs3as6cORo7dqzNo4NTvfDCC3r22We1YMEC9erVSxs2bNDNN9+sDh06MG/Q6lAOd4wyMzMVHR3dqBvTjz/+qOzsbJtGBaeaMmWKXn/9db333ns6/vjjA9uzs7O1d+9e7d69O+h45pG7rVu3ToWFherTp49iYmIUExOjZcuW6S9/+YtiYmLUvn175g0OKScnRz179gzadvLJJ+vbb7+VpMD84HsXDvTrX/9av/3tb3X11VfrlFNO0f/8z//olltu0cyZMyUxb3B0TZkj2dnZjZqH1dXVqaSkxNJ5RAg6RrGxserbt6/eeeedwDafz6d33nlHgwYNsnFkcBJjjKZMmaKFCxfq3XffVW5ubtD+vn37yuv1Bs2jLVu26Ntvv2Ueudh5552nzz//XBs2bAj86tevn/Ly8gK/Z97gUM4666xGbfj/9a9/qXPnzpKk3NxcZWdnB82dsrIyrVq1irnjYlVVVYqKCv7RMDo6Wj6fTxLzBkfXlDkyaNAg7d69W+vWrQsc8+6778rn82ngwIHWDdayFgyt2HPPPWfi4uLM/PnzzaZNm8wNN9xg2rRpY3bu3Gn30OAQkyZNMmlpaeb99983O3bsCPyqqqoKHPP//t//M506dTLvvvuuWbt2rRk0aJAZNGiQjaOGEx3YHc4Y5g0ObfXq1SYmJsbcfffdZuvWrebZZ581iYmJ5plnngkcc++995o2bdqYV1991Xz22Wfmv/7rv0xubq7Zs2ePjSOHncaOHWuOO+448/rrr5uCggLzyiuvmMzMTHPbbbcFjmHeoLy83HzyySfmk08+MZLM/fffbz755BPzzTffGGOaNkdGjhxpTj/9dLNq1Srz4Ycfmu7du5vRo0dbeh2EoBby8MMPm06dOpnY2FgzYMAAs3LlSruHBAeRdMhf8+bNCxyzZ88e8/Of/9y0bdvWJCYmmksvvdTs2LHDvkHDkQ4OQcwbHM6iRYtM7969TVxcnOnRo4eZO3du0H6fz2fuuOMO0759exMXF2fOO+88s2XLFptGCycoKyszU6dONZ06dTLx8fHmhBNOML/73e9MTU1N4BjmDd57771D/kwzduxYY0zT5khxcbEZPXq0SU5ONqmpqWbcuHGmvLzc0uvwGHPAY4ABAAAAoJXjniAAAAAArkIIAgAAAOAqhCAAAAAArkIIAgAAAOAqhCAAAAAArkIIAgAAAOAqhCAAAAAArkIIAgAAAOAqhCAAgCO8//778ng82r17tyRp/vz5atOmTdjPa9V5AADOQQgCAByz6667Th6PRx6PR16vV7m5ubrttttUXV0d1vN6PB7985//DOs5AACtT4zdAwAAtA4jR47UvHnzVFtbq3Xr1mns2LHyeDyaNWuW3UMDACAIK0EAgBYRFxen7OxsdezYUZdccomGDh2qpUuXBvbX1NTopptuUlZWluLj43X22WdrzZo1LXb+bdu2yePx6JVXXtGQIUOUmJio0047TStWrAg6bv78+erUqZMSExN16aWXqri4uNFnvfrqq+rTp4/i4+N1wgknKD8/X3V1dZKkP/zhD+rQoUPQ+y644AINGTJEPp+vxa4HABA+hCAAQIvbuHGjPv74Y8XGxga23XbbbXr55Zf15JNPav369erWrZtGjBihkpKSFj337373O/3qV7/Shg0bdOKJJ2r06NGBALNq1SpNmDBBU6ZM0YYNGzRkyBD98Y9/DHr/Bx98oGuvvVZTp07Vpk2b9Nhjj2n+/Pm6++67A5/fpUsXXX/99ZKkRx99VB9//LGefPJJRUXxbRUAIoIBAOAYjR071kRHR5ukpCQTFxdnJJmoqCjz0ksvGWOMqaioMF6v1zz77LOB9+zdu9d06NDB3HfffcYYY9577z0jyezatcsYY8y8efNMWlraEc8rySxcuNAYY0xBQYGRZP72t78F9n/xxRdGktm8ebMxxpjRo0ebUaNGBX3Gf//3fwed57zzzjP33HNP0DFPP/20ycnJCbz++uuvTUpKivnNb35jEhISgq4LAOB83BMEAGgRQ4YM0ezZs1VZWakHHnhAMTExuvzyyyVJX3/9tWpra3XWWWcFjvd6vRowYIA2b97couM49dRTA7/PycmRJBUWFqpHjx7avHmzLr300qDjBw0apCVLlgRef/rpp/roo48CKz+SVF9fr+rqalVVVSkxMVEnnHCC/vd//1c33nij/vu//1vXXHNNi14DACC8CEEAgBaRlJSkbt26SZKeeOIJnXbaafr73/+uCRMmWDoOr9cb+L3H45GkZt2rU1FRofz8fF122WWN9sXHxwd+v3z5ckVHR2vbtm2qq6tTTAzfUgEgUlC8DABocVFRUbr99tv1+9//Xnv27FHXrl0VGxurjz76KHBMbW2t1qxZo549e1o2rpNPPlmrVq0K2rZy5cqg13369NGWLVvUrVu3Rr/89/w8//zzeuWVV/T+++/r22+/1V133WXZNQAAjh0hCAAQFldeeaWio6P16KOPKikpSZMmTdKvf/1rLVmyRJs2bdLEiRNVVVVl6UrRTTfdpCVLluh///d/tXXrVj3yyCNBpXCSdOedd+qpp55Sfn6+vvjiC23evFnPPfecfv/730uSvv/+e02aNEmzZs3S2WefrXnz5umee+5pFKYAAM5FCAIAhEVMTIymTJmi++67T5WVlbr33nt1+eWX63/+53/Up08fffXVV3rzzTfVtm1by8Z0xhln6PHHH9dDDz2k0047TW+99VYg3PiNGDFCr7/+ut566y31799fZ5xxhh544AF17txZxhhdd911GjBggKZMmRI4ftKkSRozZowqKiosuxYAQOg8xhhj9yAAAAAAwCqsBAEAAABwFUIQAAAAAFchBAEAAABwFUIQAAAAAFchBAEAAABwFUIQAAAAAFchBAEAAABwFUIQAAAAAFchBAEAAABwFUIQAAAAAFchBAEAAABwlf8PMB2j1YOWMUcAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 6))\n", + "plt.plot(sorted_values.values, marker='o')\n", + "plt.title('Sorted Values of Rolls')\n", + "plt.xlabel('Roll Index')\n", + "plt.ylabel('Value')\n", + "plt.grid(True)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nThe values 4 and 6 are the ones with highest frequency\\n'" + ] + }, + "execution_count": 107, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "The values 4 and 6 are the ones with highest frequency\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.- Using the functions you defined in *challenge 2*, calculate the mean value of the hundred dice rolls." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "3.74" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "roll_the_dice_hundred_mean = calculate_mean(roll_the_dice_hundred['value'])\n", + "roll_the_dice_hundred_mean" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.- Now, calculate the frequency distribution.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1 12\n", + "2 17\n", + "3 14\n", + "4 22\n", + "5 12\n", + "6 23\n", + "Name: value, dtype: int64" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "frequency_dist_hundred = roll_the_dice_hundred['value'].value_counts().sort_index()\n", + "frequency_dist_hundred" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 4.- Plot the histogram. What do you see (shape, values...) ? How can you connect the mean value to the histogram? " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# your code here\n", + "plt.figure(figsize=(8, 6))\n", + "plt.bar(frequency_dist_hundred.index, frequency_dist_hundred.values, width=0.8, align='center', edgecolor='black')\n", + "plt.title('Histogram of Dice Roll Values - 100 (Frequency Distribution)')\n", + "plt.xlabel('Dice Roll Value')\n", + "plt.ylabel('Frequency')\n", + "plt.xticks(frequency_dist_hundred.index)\n", + "plt.grid(axis='y')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4.0" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "calculate_median(roll_the_dice_hundred['value'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 5.- Read the `roll_the_dice_thousand.csv` from the `data` folder. Plot the frequency distribution as you did before. Has anything changed? Why do you think it changed?" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Unnamed: 0rollvalue
0005
1116
2221
3336
4445
\n", + "
" + ], + "text/plain": [ + " Unnamed: 0 roll value\n", + "0 0 0 5\n", + "1 1 1 6\n", + "2 2 2 1\n", + "3 3 3 6\n", + "4 4 4 5" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "roll_the_dice_thousand = pd.read_csv('/Users/anna/iron_hack/Descriptive-Stats/data/roll_the_dice_thousand.csv')\n", + "roll_the_dice_thousand.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1 175\n", + "2 167\n", + "3 175\n", + "4 168\n", + "5 149\n", + "6 166\n", + "Name: value, dtype: int64" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "frequency_dist_thousand = roll_the_dice_thousand['value'].value_counts().sort_index()\n", + "frequency_dist_thousand" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8, 6))\n", + "plt.bar(frequency_dist_thousand.index, frequency_dist_thousand.values, width=0.8, align='center', edgecolor='black')\n", + "plt.title('Histogram of Dice Roll Values - 1000 (Frequency Distribution)')\n", + "plt.xlabel('Dice Roll Value')\n", + "plt.ylabel('Frequency')\n", + "plt.xticks(frequency_dist_thousand.index)\n", + "plt.grid(axis='y')" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'the more times you roll the dice the more evenly the result is distributed'" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"the more times you roll the dice the more evenly the result is distributed\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenge 4\n", + "In the `data` folder of this repository you will find three different files with the prefix `ages_population`. These files contain information about a poll answered by a thousand people regarding their age. Each file corresponds to the poll answers in different neighbourhoods of Barcelona.\n", + "\n", + "#### 1.- Read the file `ages_population.csv`. Calculate the frequency distribution and plot it as we did during the lesson. Try to guess the range in which the mean and the standard deviation will be by looking at the plot. " + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
observation
068.0
112.0
245.0
338.0
449.0
\n", + "
" + ], + "text/plain": [ + " observation\n", + "0 68.0\n", + "1 12.0\n", + "2 45.0\n", + "3 38.0\n", + "4 49.0" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "ages_population = pd.read_csv('../data/ages_population.csv')\n", + "ages_population.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0 2\n", + "2.0 2\n", + "4.0 1\n", + "5.0 2\n", + "6.0 2\n", + " ..\n", + "69.0 1\n", + "70.0 1\n", + "71.0 1\n", + "73.0 1\n", + "82.0 1\n", + "Name: observation, Length: 72, dtype: int64" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "frequency_dist_ages = ages_population['observation'].value_counts().sort_index()\n", + "frequency_dist_ages" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "frequency_dist_ages.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.- Calculate the exact mean and standard deviation and compare them with your guesses. Do they fall inside the ranges you guessed?" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "36.56" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "ages_population_mean = ages_population['observation'].mean()\n", + "ages_population_mean" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12.81649962597677" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ages_population_std = ages_population['observation'].std()\n", + "ages_population_std" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nGiven the plot of the frequencies above I was guessing it could have been around 35\\n'" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "Given the plot of the frequencies above I was guessing it could have been around 35\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.- Now read the file `ages_population2.csv` . Calculate the frequency distribution and plot it." + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
observation
025.0
131.0
229.0
331.0
429.0
\n", + "
" + ], + "text/plain": [ + " observation\n", + "0 25.0\n", + "1 31.0\n", + "2 29.0\n", + "3 31.0\n", + "4 29.0" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "ages_population2 = pd.read_csv('../data/ages_population2.csv')\n", + "ages_population2.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "19.0 3\n", + "20.0 13\n", + "21.0 17\n", + "22.0 35\n", + "23.0 41\n", + "24.0 78\n", + "25.0 98\n", + "26.0 120\n", + "27.0 125\n", + "28.0 139\n", + "29.0 115\n", + "30.0 90\n", + "31.0 61\n", + "32.0 31\n", + "33.0 22\n", + "34.0 7\n", + "35.0 3\n", + "36.0 2\n", + "Name: observation, dtype: int64" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "frequency_dist_ages2 = ages_population2['observation'].value_counts().sort_index()\n", + "frequency_dist_ages2" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGdCAYAAAA44ojeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABRyElEQVR4nO3dd3gT9+EG8FeyZHlKxnuDAWOzMWaZHXCYZZOElCxCoSSQhJBm0F9DmyYtWc1OIZOkDWSzQhMIMRvMsjEbg7GNpzyx5Clb0v3+kC1wAjbGkk/j/TyPngbpdH51laXXd9/7nkQQBAFERERENkQqdgAiIiKiX2NBISIiIpvDgkJEREQ2hwWFiIiIbA4LChEREdkcFhQiIiKyOSwoREREZHNYUIiIiMjmyMQOcDuMRiMKCgrg7e0NiUQidhwiIiK6BYIgoLKyEqGhoZBKW95HYpcFpaCgABEREWLHICIiotuQm5uL8PDwFpexy4Li7e0NwPQClUqlyGmIiIjoVmi1WkRERJi/x1tilwWl6bCOUqlkQSEiIrIztzI8g4NkiYiIyOawoBAREZHNYUEhIiIim8OCQkRERDaHBYWIiIhsDgsKERER2RwWFCIiIrI5bS4o+/btw7Rp0xAaGgqJRILNmzffdNklS5ZAIpHgrbfeanZ/eXk55s+fD6VSCR8fHyxcuBBVVVVtjUJEREQOqs0Fpbq6Gv3798f777/f4nKbNm3C4cOHERoa+pvH5s+fj7Nnz2Lnzp3Ytm0b9u3bh8WLF7c1ChERETmoNs8kO3nyZEyePLnFZfLz8/HYY49hx44dmDp1arPHzp8/j+3bt+PYsWMYNGgQAODdd9/FlClT8Prrr9+w0BAREZFzsfgYFKPRiPvvvx9PP/00evfu/ZvHk5OT4ePjYy4nAJCYmAipVIojR47ccJ06nQ5arbbZjYiIiByXxQvKK6+8AplMhscff/yGj6vVagQGBja7TyaTwdfXF2q1+obPWb16NVQqlfnGKxkTERE5NosWlJSUFLz99tv47LPPbulCQLdq5cqV0Gg05ltubq7F1k1E9i+juArv785AXYNB7ChEZCEWvZrx/v37UVxcjMjISPN9BoMBTz31FN566y1kZ2cjODgYxcXFzZ6n1+tRXl6O4ODgG65XoVBAoVBYMioROYjSKh3mf3wYRVod6hoMeGpCjNiRiMgCLLoH5f7778epU6eQlpZmvoWGhuLpp5/Gjh07AAAJCQmoqKhASkqK+Xm7du2C0WjE0KFDLRmHiByc3mDEYxtOoEirAwB8cfgKauu5F4XIEbR5D0pVVRUyMjLM/87KykJaWhp8fX0RGRkJPz+/ZsvL5XIEBwcjJsb0V03Pnj0xadIkLFq0CGvXrkVDQwOWLVuGefPm8QweImqTN3ZeRHJmGTxcXaB0k0OtrcN3qXm4f1hnsaMRUTu1eQ/K8ePHERcXh7i4OADAihUrEBcXh1WrVt3yOtavX4/Y2FiMHz8eU6ZMwciRI/Hhhx+2NQoRObFfzhXh33suAwBemdMPS8Z0BQB8sj8TBqMgZjQisgCJIAh295us1WqhUqmg0WigVCrFjkNEHSynrAZT392Pyjo9HhreBX+b3hvVOj0SVidBW6fHB/fHY2LvG49pIyLxtOX7m9fiISK7UtdgwJIvUlBZp8fASB/8eUpPAICnQob7Gg/tfLw/U8yIRGQBLChEZFdWbTmDc4Va+Hm64v35A+Equ/Yx9uDwLpC7SHAs+ypO5FwVMSURtRcLChHZja+P5eCb43mQSoB37o1DiMq92eNBSjdM7x8GAPh4f5YYEYnIQlhQiMgunMnX4PktZwEAT02IwYju/jdcbtHoKADAT2cKkVte02H5iMiyWFCIyOZpahrwyPoU1OuNGB8biEfGdLvpsrHBSoyK9odRAD45wL0oRPaKBYWIbJrRKGDFN2nILa9FhK873rh7AKTSli+lsWiU6ZTjb47nQlPT0BExicjCWFCIyKat2XsZSReK4SqTYs38eKg85K0+Z1S0P2KDvVFTb8D6o1c6ICURWRoLChHZrIMZpfjXz+kAgBdn9EafMNUtPU8ikeAPjXtRPj+UjXq90WoZicg6WFCIyCapNXV4/MsTMArA3YPCcc/gyNafdJ3p/UMR6K1AkVaHH04WWCklEVkLCwoR2Zx6vRGPrk9BWXU9eoUo8fcZfdq8DleZFA+N6AIA+Gh/Juxw0mwip8aCQkQ2Z/VP55GaUwFvNxnW3hcPN7nLba1n/pDO8HB1wQV1JQ5klFo4JRFZEwsKEdmUH04WYN3BbADAG3cPQKSfx22vS+Uhx92DIgAAH3HiNiK7woJCRDYjo7gSz35/CgDw6NhuuLNXULvXuXBkFKQSYN/FElxQa9u9PiLqGCwoRGQTqnV6LPkiFTX1Bgzv5ocVd/awyHojfD0wqY/pysac/p7IfrCgEJHoBEHAcxtPI6O4CkFKBd65Nw4yF8t9PDVN3LYlLR9F2jqLrZeIrIcFhYhE9/mhbPxwsgAyqQTv/34g/L0UFl1/XGQnDOrcCQ0GAZ8fyrbouonIOlhQiEhUKVeu4qX/nQcA/HlKTwzq4muVn9M0cdv6Izmo1umt8jOIyHJYUIhINGVVOixdnwq9UcDUfiFY0DhviTXc2SsIXfw8oKltwLfHc632c4jIMlhQiEgUBqOAx786AbW2Dt0CPPHKnH6QSFq+CGB7uEglWDgyCgDw6cFsGIycuI3IlrGgEJEo3tx5EQczyuDh6oK198XDSyGz+s+cGx8BHw85cspr8PNZtdV/HhHdPhYUIupwSeeL8N7uDADA6tl9ER3k3SE/193VBfcP6wwA+HB/Zof8TCK6PSwoRNShcstr8OTXaQCAh4Z3wYwBYR368+9P6AxXFylO5FQg5Up5h/5sIrp1LChE1GHqGgxY8kUKtHV6xEX64M9TenZ4hkBvN8yKM5Wij/Zx4jYiW8WCQkQd5m9bz+JsgRa+nq54//cD4SoT5yPoD6NMg2V3nFMju7RalAxE1DIWFCLqEN8cz8VXx3IhkQDvzItDqI+7aFmig7wxNiYAggB8epB7UYhsEQsKEVnd2QINnt98BgDw1J09MDLaX+REwOLGidu+PZ6Hq9X1Iqchol9jQSEiq9LUNuCRL1Kh0xsxLjYQj47tLnYkAEBCNz/0ClGitsGA9UeuiB2HiH6FBYWIrMZoFPDUNyeRU16D8E7ueOPu/pBKrTcZW1tIJBIsGm0ai/LZoSvQ6Q0iJyKi67GgEJHVfLAvE7+cL4KrTIo18+Ph4+EqdqRmftcvFMFKN5RW6bDlRIHYcYjoOiwoRGRRgiDg0OVSPPDpUbyy/QIA4O/Te6NvuErkZL8ld5Gar//z8YFMCAKnvyeyFdafW5qInILBKGD7GTU+2HcZp/I0AACpBFg0uivuGRwhcrqbmzckEu8kXcLFoirsvViCsTGBYkciIrCgEFE71TUY8F1KHj7an4krZTUAADe5FPcMisAfRnVFhK+HyAlbpnKXY96QSHxyIAsf7c9kQSGyESwoRHRbKmrq8d/kK/jsUDbKGk/T9fGQ48GELnggoTP8vBQiJ7x1C0Z0wWeHsnEwowxnCzToHWp7h6OInA0LChG1SX5FLT7Zn4WvjuWgpt505kuYjzsWjYrC3YMj4OFqfx8r4Z08MLlPMLadKsQn+7Pwxj0DxI5E5PTs75OEiERxQa3Fh3szsfVkAfRG02DSniFKLBnTFVP7hkDmYt9j7heP7optpwqx9WQBnp4UgxCVeDPdEhELChG1QBAEHMkqx9q9l7EnvcR8//BuflgyphtGRftDIrGNeU3aq1+4D4ZE+eJoVjk+O5SNlZM7/kKGRHQNCwoR/YbBKODns2qs3ZeJk7kVAExn5EzuG4I/ju6KfuE+ouazlsWjuuJoVjk2HMnBY+Oi4aXgRySRWPjbR0RmdQ0GbEzNx0f7M5HVeJVfhUyKuwaF4w8ju6KLv6fICa1rXGwgugZ4IrOkGl8fy8XCkVFiRyJyWm0+aLxv3z5MmzYNoaGhkEgk2Lx5s/mxhoYGPPvss+jbty88PT0RGhqKBx54AAUFzWdoLC8vx/z586FUKuHj44OFCxeiqqqq3S+GiG6PpqYB7+/OwMhXduPPm04jq7QaKnc5HhvXHQefG4eXZvZ1+HICAFKpxFxKPj2QBb3BKHIiIufV5oJSXV2N/v374/333//NYzU1NUhNTcXzzz+P1NRUbNy4Eenp6Zg+fXqz5ebPn4+zZ89i586d2LZtG/bt24fFixff/qsgottSqKnFS9vOYfjLSXhtRzpKq3QIVblh1e964dBz4/DUhBj429HpwpYwZ2A4fD1dkV9Ri5/OqMWOQ+S0JEI75naWSCTYtGkTZs6cedNljh07hiFDhuDKlSuIjIzE+fPn0atXLxw7dgyDBg0CAGzfvh1TpkxBXl4eQkNDW/25Wq0WKpUKGo0GSqXyduMTOa2LRZX4YG8mtqTlm8/IiQ32xh/HdMXv+oVCbudn5LTXmzsv4u2kS+gfrsLmpSMcZiAwkdja8v1t9TEoGo0GEokEPj4+AIDk5GT4+PiYywkAJCYmQiqV4siRI5g1a9Zv1qHT6aDT6cz/1mq11o5N5LDW7LlsvkYOAAzr6os/jumGsT0C+EXc6P6Ezliz9zJO5mlwLPsqhkT5ih2JyOlY9c+kuro6PPvss7j33nvNTUmtViMwsPlU0jKZDL6+vlCrb7w7dfXq1VCpVOZbRITtXteDyJYVa+vw5i8XAQATewdh06PD8dXiBNwRE8hych1/LwXmDAwHAHy4L1PkNETOyWoFpaGhAXfffTcEQcCaNWvata6VK1dCo9GYb7m5uRZKSeRcPtiXiXq9EfGdO2HtffGIi+wkdiSb1TRYNulCETJLOIifqKNZpaA0lZMrV65g586dzY4zBQcHo7i4uNnyer0e5eXlCA4OvuH6FAoFlEplsxsRtU1plQ7rj1wBADw+Ppp7TFrRPdAL42MDIQjAJweyxI5D5HQsXlCaysmlS5fwyy+/wM/Pr9njCQkJqKioQEpKivm+Xbt2wWg0YujQoZaOQ0SNPtqfiboGI/pH+GB0tL/YcezCotFdAQDfpeShrErXytJEZEltLihVVVVIS0tDWloaACArKwtpaWnIyclBQ0MD5s6di+PHj2P9+vUwGAxQq9VQq9Worzdd7bRnz56YNGkSFi1ahKNHj+LgwYNYtmwZ5s2bd0tn8BBR25VXm648DABPjO/OvSe3aGiUL/qGqaDTG/HF4Ryx4xA5lTYXlOPHjyMuLg5xcXEAgBUrViAuLg6rVq1Cfn4+tm7diry8PAwYMAAhISHm26FDh8zrWL9+PWJjYzF+/HhMmTIFI0eOxIcffmi5V0VEzXxyIBM19Qb0CVPijpjA1p9AAExTKfxhlGksyn+Ss1HXYBA5EZHzaPNpxmPHjkVLU6fcyrQqvr6+2LBhQ1t/NBHdhoqaenx+yLT35LFxHHvSVlP6huDV7enIr6jFphP5uHdIpNiRiJyCc8/GROQEPj2YjSqdHrHB3rizZ5DYceyO3EWKBSO6AAA+3p8Jo/G257YkojZgQSFyYNq6Bqw7aDoD5fHx0ZBKuffkdtwzOALeChkul1Rjd3px608gonZjQSFyYJ8fzEZlnR7RgV6Y1PvGp/FT67zd5Lh3qOnQzkf7OXEbUUdgQSFyUFU6PT5unL9j2bju3HvSTg8N7wKZVILDmeU4nacROw6Rw2NBIXJQ/0nOhqa2AV39PfG7fjyFv71Cfdzxu34hALgXhagjsKAQOaBqnR4f77+298SFe08s4g+jTBO3/e90IQo1tSKnIXJsLChEDmj9kSsor65HZz8PTO/PvSeW0idMhSFRvjAYBXxx+IrYcYgcGgsKkYOprTeYr8C79I7ukLnw19ySHm485XjDkRxO3EZkRfzkInIwXx7NQWlVPcI7uWNWXJjYcRxOYs8ghPm442pNA7ak5Ysdh8hhsaAQOZC6BgPW7r0MAHh0bHfIuffE4mQuUjyQ0BkAsO5g9i3Nnk1EbcdPLyIH8s3xXBRX6hCqcsOceO49sZZ5gyPhLnfBBXUlDmeWix2HyCGxoBA5CJ3egDV7THtPHhnbDQqZi8iJHJfKQ47ZA00FsGmmXiKyLBYUIgfxXUoeCjV1CFIqcNegCLHjOLyHhncBAOw8X4Tc8hpxwxA5IBYUIgdQrzfi37tNe0+WjOkGNzn3nlhbdJA3RkX7QxBMk+IRkWWxoBA5gE0n8pBfUQt/LwXuHRIpdhyn0XSV46+O5aJapxc3DJGDYUEhsnN6gxHvN+49+ePortx70oHG9ghEFz8PVNbpsTE1T+w4RA6FBYXIzm1JK0BOeQ18PV0xfxj3nnQkqVSCBxvHoqw7lA2jkaccE1kKCwqRHTMYBby3OwMAsGhUV3i4ykRO5HzmxofDSyFDZkk19meUih2HyGGwoBDZsW2nCpBVWg0fDznub5w8jDqWt5scdw0KB8BTjoksiQWFyE4ZjALe3WXae/KHkVHwUnDviVgeTOgCiQTYk16CyyVVYschcggsKER26qczhcgoroLSTYYHGsdBkDi6+HtiXEwgAODzQ9nihiFyECwoRHbIaBTwXuPekwUjoqB0k4uciBaMiAJgmjBPW9cgchoi+8eCQmSHfj5XhAvqSngpZHi48YuRxDWiux96BHmhpt6Ab47lih2HyO6xoBDZGUEQ8E7SJQCm6dZVHtx7YgskEgkeGm4qi58nZ8PAU46J2oUFhcjOJJ0vxrlCLTxcXbBwJPee2JJZcWFQucuRW16LpPNFYschsmssKER2RBAEvLPLtPfkgYQu6OTpKnIiup67qwvmDTFdqPEzDpYlahcWFCI7sudiCU7laeAud8EfRnHviS16IKELXKQSHLpchgtqrdhxiOwWCwqRnbh+7Mn8oZHw91KInIhuJMzHHRN7BwEAPjuYLW4YIjvGgkJkJw5mlOFETgUUMikWj+4qdhxqQdNg2U0n8nG1ul7kNET2iQWFyA4IgoC3ky4CAO4dEolApZvIiaglg7t0Qu9QJXR6I748liN2HCK7xIJCZAcOZ5bjWPZVuLpIsWRMN7HjUCskEol54rb/Jl9Bg8EociIi+8OCQmQHmsae3DM4AsEq7j2xB9P6h8DfyxWFmjrsOKsWOw6R3WFBIbJxR7PKkZxZBrmLBEvGcu+JvVDIXPD7IZEAOFiW6HawoBDZuHcb5z2ZGx+OMB93kdNQW9w3rDPkLhIcv3IVp/M0YschsissKEQ2LDXnKvZfKoWLVIJHx3YXOw61UaDSDVP7hgAA1h3MEjkNkX1hQSGyYe82jj2ZHReGCF8PkdPQ7WgaLPvDqQIUV9aJnIbIfrCgENmoU3kV2J1eAqkEWHoH957Yq/4RPoiL9EGDQcCGIzzlmOhWsaAQ2ah3kjIAADMHhKGLv6fIaag9mvaifHE4Bzq9QeQ0RPahzQVl3759mDZtGkJDQyGRSLB58+ZmjwuCgFWrViEkJATu7u5ITEzEpUuXmi1TXl6O+fPnQ6lUwsfHBwsXLkRVVVW7XgiRIzmTr8Ev54sgkQCPcu+J3ZvcJxjBSjeUVunwv1OFYschsgttLijV1dXo378/3n///Rs+/uqrr+Kdd97B2rVrceTIEXh6emLixImoq7t27HX+/Pk4e/Ysdu7ciW3btmHfvn1YvHjx7b8KIgfz3i7T3pPf9QtF90AvkdNQe8ldpLg/oTMAYN3BbAiCIHIiItsnEdrxmyKRSLBp0ybMnDkTgGnvSWhoKJ566in86U9/AgBoNBoEBQXhs88+w7x583D+/Hn06tULx44dw6BBgwAA27dvx5QpU5CXl4fQ0NBWf65Wq4VKpYJGo4FSqbzd+EQ26YJai0lv7QcA/PzkaPQI8hY5EVlCWZUOCS/vQr3eiO8fSUB8Z1+xIxF1uLZ8f1t0DEpWVhbUajUSExPN96lUKgwdOhTJyckAgOTkZPj4+JjLCQAkJiZCKpXiyJEjN1yvTqeDVqttdiNyVE17T6b0DWY5cSB+XgrMHGD6A+xTTtxG1CqLFhS12jSdc1BQULP7g4KCzI+p1WoEBgY2e1wmk8HX19e8zK+tXr0aKpXKfIuIiLBkbCKbkVFcif+dNo1RWHZHtMhpyNKaBstuP6NGQUWtyGmIbJtdnMWzcuVKaDQa8y03N1fsSERW8d6uDAgCMKFXEHqF8vClo+kZosSwrr4wGAX89/AVseMQ2TSLFpTg4GAAQFFRUbP7i4qKzI8FBwejuLi42eN6vR7l5eXmZX5NoVBAqVQ2uxE5msySKmw9WQAAeGwc9544qoeGm/aifHk0B3UNPOWY6GYsWlCioqIQHByMpKQk831arRZHjhxBQkICACAhIQEVFRVISUkxL7Nr1y4YjUYMHTrUknGI7Mr7uy/DKADjYgPRN1wldhyykjt7BSG8kzsqahqw+US+2HGIbFabC0pVVRXS0tKQlpYGwDQwNi0tDTk5OZBIJFi+fDleeuklbN26FadPn8YDDzyA0NBQ85k+PXv2xKRJk7Bo0SIcPXoUBw8exLJlyzBv3rxbOoOHyBFll1Zjc5rpy+qxcZz3xJG5SCV4MKELAJ5yTNSSNheU48ePIy4uDnFxcQCAFStWIC4uDqtWrQIAPPPMM3jsscewePFiDB48GFVVVdi+fTvc3NzM61i/fj1iY2Mxfvx4TJkyBSNHjsSHH35ooZdEZH9e/zkdBqOAMT0CEBfZSew4ZGV3D46Au9wF6UWVSL5cJnYcIpvUrnlQxMJ5UMiRnMqrwPT3DkIiAbY9NhK9Q3l4xxn8ZfNpfHE4B3f2CsJHDwxq/QlEDkC0eVCIqG0EQcDLP10AYLrmDsuJ82gaLPvL+SLklNWInIbI9rCgEIlo36VSHLpcBlcXKVbc2UPsONSBugd6YXSPAAgC8HlytthxiGwOCwqRSIzGa3tP7hvWGRG+HiInoo62YEQXAMA3x3JRpdOLG4bIxrCgEIlky8l8nC/UwlshwzKeueOUxkQHoKu/Jyp1emxMzRM7DpFNYUEhEoFOb8DrOy4CAJaM7QZfT1eRE5EYpFIJHhzeBQDw2cFsGI12d84CkdWwoBCJ4IvDOcivqEWgtwIPN16fhZzTnPhweCtkyCytxt5LJWLHIbIZLChEHUxb14D3dl0CADx5Zw+4u7qInIjE5KWQ4e7BpgugruNVjonMWFCIOtgHey/jak0DugV44q74cLHjkA14MKELJBJg38USZBRXiR2HyCawoBB1ILWmDp8cyAIAPDMpFjIX/goSEOnngfGxQQCAzw9lixuGyEbw05GoA72ddBF1DUbEd+6ECb2CxI5DNuThxlOOv0/Ng6a2QdwwRDaABYWog2QUV+HrY7kAgJWTYyGRSERORLYkoZsfYoK8UVNvwDeN7xMiZ8aCQtRBXt1+AUYBuLNXEAZ18RU7DtkYiUSChxr3onyenA0DTzkmJ8eCQtQBUq6U4+dzRZBKgGcmxogdh2zUzAFh8PGQI+9qLX45XyR2HCJRsaAQWZkgCFj9o2lK+7viIxAd5C1yIrJV7q4uuHdIJABg3cEskdMQiYsFhcjKfjlfjONXrkIhk+JJXhCQWnH/sM5wkUpwOLMc5wu1YschEg0LCpEV6Q1GvLLdtPfk4ZFRCFa5iZyIbF2ojzsm9Q4GYJr+nshZsaAQWdH3qXnIKK6Cj4ccS8Z0EzsO2YmmqxxvTstHeXW9uGGIRMKCQmQltfUGvLnTNKX9sju6Q+UuFzkR2Yv4zp3QN0wFnd6Ib47zlGNyTiwoRFay7lAW1No6hPm44/6EzmLHITsikUgwf6hpsOx3KXkQBJ5yTM6HBYXICq5W12PNnssAgKcm9IBCxgsCUttM6RcChUyKjOIqnMrTiB2HqMOxoBBZwfu7M1BZp0fPECVmDggTOw7ZIaWbHJP6mAbLfpeSJ3Iaoo7HgkJkYXlXa/Cf5CsAgGcnxUAq5ZT2dHvmDDRd7XrryQLo9AaR0xB1LBYUIgt7Y+dF1BuMGN7ND2N6BIgdh+zYiO7+CFa6QVPbgF3ni8WOQ9ShWFCILOhcgRabTuQDAJ6dxAsCUvu4SCWYNdB0iJCHecjZsKAQWdCrOy5AEICp/ULQP8JH7DjkAJoO8+y5WIKSSp3IaYg6DgsKkYUculyKPeklkEkleHoCLwhIltE90AsDInxgMArYkpYvdhyiDsOCQmQBgiDg5Z9MU9r/fmgkuvh7ipyIHMnceNNeFM6JQs6EBYXIAn48rcapPA08XV3w+PhoseOQg5nWLxSuMikuqCtxtoAXECTnwIJC1E4NBiNe22Hae7JodFf4eylETkSORuUhx529ggCYru9E5AxYUIja6aujOcguq4G/lysWjeoqdhxyUHMbB8tuSStAvd4ochoi62NBIWqHKp0ebyeZLgj4xPhoeCpkIiciRzUq2h8B3gqUV9djTzrnRCHHx4JC1A4f789EaVU9uvh5YN6QSLHjkAOTuUgxK45zopDzYEEhuk0llTp8uC8TAPD0xFjIXfjrRNbVNCfKrgvFKKvinCjk2PiJSnSb3t11CTX1BvSP8MGUvsFixyEnEBPsjb5hKuiNAraeLBA7DpFVsaAQ3Ybs0mpsOJIDAHiOU9pTB5rTOPU9z+YhR8eCQnQbXvs5HXqjgDtiApDQzU/sOOREpg8Ig9xFgjP5WlxQc04UclwsKERtdDK3Av87VQiJBHhmUqzYccjJ+Hq6YlxsIADgew6WJQfGgkLUBtdPaT8rLgw9Q5QiJyJnNDc+AgCw6UQB9AbOiUKOyeIFxWAw4Pnnn0dUVBTc3d3RrVs3vPjii82uHyEIAlatWoWQkBC4u7sjMTERly5dsnQUIovbe7EEyZllcJVJ8RQvCEgiGRsTAD9PV5RW6bDvUonYcYiswuIF5ZVXXsGaNWvw3nvv4fz583jllVfw6quv4t133zUv8+qrr+Kdd97B2rVrceTIEXh6emLixImoq6uzdBwiizEar+09eTChM8J83EVORM5K7iLFjAGcE4Ucm8ULyqFDhzBjxgxMnToVXbp0wdy5czFhwgQcPXoUgGnvyVtvvYW//OUvmDFjBvr164f//Oc/KCgowObNmy0dh8hiNqfl44K6Et5uMiy9o7vYccjJzYk3FZRfzhWjoqZe5DRElmfxgjJ8+HAkJSXh4sWLAICTJ0/iwIEDmDx5MgAgKysLarUaiYmJ5ueoVCoMHToUycnJN1ynTqeDVqttdiPqSHUNBvzrZ9N7+tGx3eHj4SpyInJ2vUNV6BmiRL3BiB9OFYodh8jiLF5QnnvuOcybNw+xsbGQy+WIi4vD8uXLMX/+fACAWq0GAAQFBTV7XlBQkPmxX1u9ejVUKpX5FhERYenYRC364vAV5FfUIljphgUjuogdhwjAtTlReJiHHJHFC8o333yD9evXY8OGDUhNTcXnn3+O119/HZ9//vltr3PlypXQaDTmW25urgUTE7VMU9uA93ZnAABW3NkDbnIXkRMRmcyMC4NMKsHJ3ApkFFeKHYfIoixeUJ5++mnzXpS+ffvi/vvvx5NPPonVq1cDAIKDTVOCFxUVNXteUVGR+bFfUygUUCqVzW5EHeWDvZdRUdOAHkFemBMfLnYcIjN/LwXGxgQAAL5LyRc5DZFlWbyg1NTUQCptvloXFxcYjaZz9aOiohAcHIykpCTz41qtFkeOHEFCQoKl4xC1i1pTh08PZgEAnpkYCxcpp7Qn29J0AcFNJ/JgMAqtLE1kP2SWXuG0adPwj3/8A5GRkejduzdOnDiBN954Aw8//DAAQCKRYPny5XjppZcQHR2NqKgoPP/88wgNDcXMmTMtHYeoXd7ZdQl1DUYM6eKL8T0DxY5D9BvjegbCx0OOIq0OBzJKMaZHgNiRiCzC4gXl3XffxfPPP49HH30UxcXFCA0NxR//+EesWrXKvMwzzzyD6upqLF68GBUVFRg5ciS2b98ONzc3S8chum16gxHbGq8Yu/zOaF4QkGySQuaC6f1D8Z/kK/g+JY8FhRyGRLh+ilc7odVqoVKpoNFoOB6FrOZIZhnu+fAwOnnIcfwvd/LwDtmsU3kVmP7eQShkUhz7SyKUbnKxIxHdUFu+v3ktHqKb2J1umkJ8TI8AlhOyaX3DVIgO9IJOb8T/OCcKOQgWFKKb2H2hGABwRyzHnpBtk0gkmNt4hhnnRCFHwYJCdAP5FbVIL6qEVAIe0ye7MCsuDFIJkHLlKrJKq8WOQ9RuLChEN7Crce9JfOdOnNae7EKg0g2jG8v099yLQg6ABYXoBpoO74yN4eEdsh9Nc6JsTM2DkXOikJ1jQSH6lboGAw5dLgUAjOP4E7Ijd/YKgrebDAWaOiRnlokdh6hdWFCIfiU5swx1DUaEqNwQG+wtdhyiW+Ymd8G0/qEAeJiH7B8LCtGvXH/2DidnI3vTdDbPT2fUqNLpRU5DdPtYUIiuIwiCeYDsOI4/ITsUF+GDrv6eqG0w4MfTnBOF7BcLCtF1MoqrkHe1Fq4yKYZ39xM7DlGbSSQS81W3eZiH7BkLCtF1mvaeDOvqBw9Xi1+qiqhDzIoLg0QCHMkqR255jdhxiG4LCwrRda4d3uHkbGS/Qn3cMaKbPwDg+1TuRSH7xIJC1Ehb14DjV64CAMbFBomchqh9mgbLfs85UchOsaAQNdp/sRQGo4BuAZ6I9PMQOw5Ru0zsHQwvhQy55bU4ll0udhyiNmNBIWpkPrzDydnIAbi7umBq3xAAvIAg2ScWFCIARqOAvRd59WJyLE1n8/x4uhA19ZwThewLCwoRgFP5GpRW1cNLIcOgzr5ixyGyiMFdOiHS1wPV9QZsP6MWOw5Rm7CgEOHa7LGjov3hKuOvBTkGiURivoAgz+Yhe8NPYiIAu9N5eIcc0+yBYQCAQ5fLkF9RK3IaolvHgkJOr7iyDqfyNACAsZz/hBxMhK8HhnX1hSAAm7gXhewICwo5vT3pJQCAfuEqBHq7iZyGyPLmxkcAAL5PzYcgcE4Usg8sKOT0msafjOXFAclBTe4TDA9XF2SVViM156rYcYhuCQsKObV6vRH7L5UC4Pwn5Lg8FTJM7sM5Uci+sKCQUzt+pRxVOj38vVzRL0wldhwiq5kTbxosu+1kIeoaDCKnIWodCwo5tabDO2N6BEIqlYichsh6hkX5IczHHZU6PXac5ZwoZPtYUMipcXp7chZSqQRzGk85/j41X+Q0RK1jQSGnlVNWg8sl1XCRSjCqh7/YcYisbnbjpG0HLpVArakTOQ1Ry1hQyGntulAEABjUuROUbnKR0xBZXxd/Twzu0glGAdh0gntRyLaxoJDT2tU4/wkP75AzuX7qe86JQraMBYWcUk29HoczywCwoJBzmdIvBG5yKTKKq3CycQZlIlvEgkJO6VBGGer1RoR3ckf3QC+x4xB1GKWbHBN7BwMAvuecKGTDWFDIKe1Kv3b2jkTC04vJucyNNx3m2XqyADo950Qh28SCQk5HEATz/Ce8ejE5o+Hd/BGsdIOmtgFJ54vFjkN0Qywo5HQuqCtRqKmDm1yKhK5+Ysch6nAuUglmN86JwqnvyVaxoJDT2d14eGd4N3+4yV1ETkMkjjmNh3n2XixBcSXnRCHbw4JCToeHd4iAbgFeiIv0gcEoYMuJArHjEP0GCwo5lYqaeqRcMV1unqcXk7NrmhPluxTOiUK2hwWFnMreiyUwCkBMkDfCfNzFjkMkqmn9QuEqkyK9qBJnC7RixyFqxioFJT8/H/fddx/8/Pzg7u6Ovn374vjx4+bHBUHAqlWrEBISAnd3dyQmJuLSpUvWiELUTNPhnbGxASInIRKfykOOO3sFAeBgWbI9Fi8oV69exYgRIyCXy/HTTz/h3Llz+Ne//oVOnTqZl3n11VfxzjvvYO3atThy5Ag8PT0xceJE1NVxoBZZj8EoYO/FxuntY3h4hwgA5jYe5tmSlo8Gg1HkNETXyCy9wldeeQURERFYt26d+b6oqCjzfwuCgLfeegt/+ctfMGPGDADAf/7zHwQFBWHz5s2YN2+epSMRAQDScitwtaYBSjcZ4jt3av0JRE5gVLQ//L0UKK3SYd/FEozvGSR2JCIAVtiDsnXrVgwaNAh33XUXAgMDERcXh48++sj8eFZWFtRqNRITE833qVQqDB06FMnJyTdcp06ng1arbXYjaqumwzujewRA5sLhV0QAIHORYnr/UADARl7hmGyIxT+lMzMzsWbNGkRHR2PHjh145JFH8Pjjj+Pzzz8HAKjVagBAUFDzlh4UFGR+7NdWr14NlUplvkVERFg6NjmBXReuTW9PRNfMijNN2vbLuSJo6xpETkNkYvGCYjQaMXDgQPzzn/9EXFwcFi9ejEWLFmHt2rW3vc6VK1dCo9GYb7m5uRZMTM5AranDuUItJBJgTA8OkCW6Xp8wJboHekGnN2L7mRv/oUjU0SxeUEJCQtCrV69m9/Xs2RM5OTkAgOBg01U0i4qKmi1TVFRkfuzXFAoFlEplsxtRWzTNHts/3Ad+XgqR0xDZFolEYt6LsimVh3nINli8oIwYMQLp6enN7rt48SI6d+4MwDRgNjg4GElJSebHtVotjhw5goSEBEvHIQLAwztErWkah3I4qwwFFbUipyGyQkF58skncfjwYfzzn/9ERkYGNmzYgA8//BBLly4FYGrqy5cvx0svvYStW7fi9OnTeOCBBxAaGoqZM2daOg4RdHoDDmaUAmBBIbqZCF8PDInyhSAAW09y6nsSn8ULyuDBg7Fp0yZ8+eWX6NOnD1588UW89dZbmD9/vnmZZ555Bo899hgWL16MwYMHo6qqCtu3b4ebm5ul4xDhaFY5auoNCPRWoHcoDw8S3UzTYZ7NPJuHbIBEsMMLMGi1WqhUKmg0Go5HoVa98MNZrDuYjXsGReCVuf3EjkNkszQ1DRj8j19QbzDix8dHoRcLPVlYW76/ORkEOTxevZjo1qg85Bjf0/R7sjmNe1FIXCwo5NAyS6qQXVYDuYsEI6P9xY5DZPNmNh7m2ZKWD4PR7nawkwNhQSGHtjvddO2dIVG+8FJY/MoORA5nbEwAVO5yFGl1SL5cJnYccmIsKOTQzId3eHFAoluikLlgar8QAMAmDpYlEbGgkMOq0ulxJMv0FyBPLya6dbMbD/NsP1OI2nqDyGnIWbGgkMM6cKkUDQYBXfw80DXAS+w4RHYjvnMnhHdyR3W9ATvPF7X+BCIrYEEhh9V0eGcsD+8QtUnzqe/zRE5DzooFhRySIAjm6+/w8A5R2zWdzbPvUilKq3QipyFnxIJCDulsgRbFlTp4uLpgaFdfseMQ2Z1uAV7oH66CwShgG6e+JxGwoJBDajq8M6K7PxQyF5HTENmnpr0oPJuHxMCCQg5pFw/vELXbtP6hcJFKcDJPg8slVWLHISfDgkIOp6xKh7TcCgCc/4SoPfy9FBjdOAPzFu5FoQ7GgkIOZ+/FEggC0DNEiWAVr5BN1B7mwzxp+bDDa8uSHWNBIYez60LT4Z0AkZMQ2b8JvYLh6eqC3PJapFy5KnYcciIsKORQ9AYj9l00XX+H40+I2s/d1QWT+nDqe+p4LCjkUFJzKqCt06OThxwDIjqJHYfIITRN2rbtVCHq9UaR05CzYEEhh9J0eGdMjwC4SCUipyFyDAnd/BDorYCmtsE8ASKRtbGgkEMxX72Yh3eILMZFKsGMAaEAgM08zEMdhAWFHEZ+RS3SiyohlZj2oBCR5cyKCwcAJJ0vhqa2QeQ05AxYUMhhNO09GRjZCT4eriKnIXIsPUO8ERPkjXqDET+dLhQ7DjkBFhRyGDy8Q2Q9EonEPCfKRh7moQ7AgkIOoa7BgIOXSwHw9GIia5kxIBQSCXA0qxx5V2vEjkMOjgWFHEJyZhnqGowIUbkhNthb7DhEDinUxx3DovwAAFvSeIVjsi4WFHIITYd3xsYEQiLh6cVE1jLruiscc+p7siYWFLJ7giBcN709D+8QWdOkvsFQyKTIKK7C2QKt2HHIgbGgkN27XFKFvKu1cJVJMaK7n9hxiBya0k2OxF5BADj1PVkXCwrZvaa9J8O6+sHDVSZyGiLHN2uA6TDP1pMF0Bs49T1ZBwsK2T3z4Z0YTs5G1BFG9whAJw85Sip1OHi5TOw45KBYUMiuaesacDzbdAn4cbFBIqchcg6uMimm9efU92RdLChk1/ZfLIXeKKBrgCci/TzEjkPkNJombdt+Ro1qnV7kNOSIWFDIrl07vMOzd4g6UlyED7r4eaC2wYCfz6nFjkMOiAWF7JbRKGDvRZ5eTCSG66e+33SCk7aR5bGgkN06na9BaVU9vBQyDOriK3YcIqczs/FsngOXSlBcWSdyGnI0LChkt5oO74yK9oerjG9loo7Wxd8TcZE+MArADyd5hWOyLH6qk93anc6rFxOJ7drU93kiJyFHw4JCdqm4sg6n8jQAgLGc/4RINL/rFwqZVIIz+VpcKqoUOw45EBYUskt700sAAH3DVAj0dhM5DZHz8vV0Nf+RsDmNc6KQ5bCgkF3i4R0i29F0Ns/mEwUwGnmFY7IMqxeUl19+GRKJBMuXLzffV1dXh6VLl8LPzw9eXl6YM2cOioqKrB2FHESDwYj9F0sB8PRiIluQ2DMI3goZ8itqcSy7XOw45CCsWlCOHTuGDz74AP369Wt2/5NPPokffvgB3377Lfbu3YuCggLMnj3bmlHIQWSWVOHR9amo1Onh5+mKfmEqsSMROT03uQsm9w0GwMM8ZDlWKyhVVVWYP38+PvroI3Tq1Ml8v0ajwSeffII33ngD48aNQ3x8PNatW4dDhw7h8OHD1opDdq68uh5/23oWE97ch53niiCVAMsToyGVSsSORkS4dphn26lC1DUYRE5DjsBqBWXp0qWYOnUqEhMTm92fkpKChoaGZvfHxsYiMjISycnJN1yXTqeDVqttdiPnUNdgwNq9lzHm1d347FA29EYB42IDsX35aNyf0EXseETUaFiUH0JUbqis02N34xxFRO0hs8ZKv/rqK6SmpuLYsWO/eUytVsPV1RU+Pj7N7g8KCoJafePrOaxevRovvPCCNaKSjTIaBfxwqgCvbk9HfkUtAKBXiBL/N7UnRnT3FzkdEf2aVCrBjAFhWLv3MjadyMfkviFiRyI7Z/GCkpubiyeeeAI7d+6Em5tlTv9cuXIlVqxYYf63VqtFRESERdZNtudIZhn++eN5nGyc5yRY6YY/TYzB7LgwHtIhsmGz4kwFZXd6MSpq6uHj4Sp2JLJjFi8oKSkpKC4uxsCBA833GQwG7Nu3D++99x527NiB+vp6VFRUNNuLUlRUhODg4BuuU6FQQKFQWDoq2ZjMkiqs/ukCdp4zndHl6eqCR8Z2w8KRXeHu6iJyOiJqTUywN3qGKHG+UIttpwpx37DOYkciO2bxgjJ+/HicPn262X0LFixAbGwsnn32WUREREAulyMpKQlz5swBAKSnpyMnJwcJCQmWjkN2oKxKh3eSLmH9kRzojQJcpBLMGxyB5Yk9EODNYkpkT2bHheEfhVpsPpHPgkLtYvGC4u3tjT59+jS7z9PTE35+fub7Fy5ciBUrVsDX1xdKpRKPPfYYEhISMGzYMEvHIRtW12DAuoPZ+PfuDFTq9ACA8bGBeG5yLKKDvEVOR0S3Y/qAUPzzp/M4fuUqcspqEOnnIXYkslNWGSTbmjfffBNSqRRz5syBTqfDxIkT8e9//1uMKCQCo1HA1pMFeG3HtQGwvUOV+L8pPTGcA2CJ7FqQ0g0juvnjQEYptqTl47Hx0WJHIjslEQTB7uYl1mq1UKlU0Gg0UCqVYsehNki+bBoAezrfNAA2ROWGpyfGYOYADoAlchTfp+ThqW9Poqu/J5KeGgOJhL/bZNKW729R9qCQ88korsLLP13AL+dNA2C9FLLGAbBRcJNzACyRI5nYJxj/t/k0MkurcSpPg/4RPmJHIjvEgkJWVVqlw9u/XMKGozkwNA6A/f2QSDyRGA1/Lw6AJXJEXgoZJvQKxtaTBdh0Ip8FhW4LCwpZRV2DAZ8cyMKaPZdR1TgANrFnEJ6bHIvugV4ipyMia5sVF4atJwvww8kC/N/UnpC7WP3atORgWFDIooxGAZvT8vH6jnQUaOoAAH3DVPjzlJ5I6OYncjoi6iijov3h5+mKsup6HLhUijt45XFqIxYUsphTeRVYufE0zhaYrpUUqnLDM5NiMb1/KAfAEjkZmYsU0/qH4rND2dh0Ip8FhdqMBYUsQlPTgAXrjqGsuh7eChkevaM7FozowgGwRE5sVlwYPjuUjZ/PqVGl08NLwa8cunU8KEgW8a+d6Sirrke3AE/seXosHhnbjeWEyMn1C1eha4An6hqM2H7mxheDJboZFhRqtzP5Gnxx+AoA4MUZfeDHs3OICIBEIsGsAWEAgM0n8kVOQ/aGBYXaxWgU8PyWMzAKwLT+oZwJloiamdFYUA5eLkWRtk7kNGRPWFCoXb5LycOJnAp4urrg/6b0FDsOEdmYSD8PDOrcCYIAbEnjXhS6dSwodNs0NQ14efsFAMATidEIVrmJnIiIbNGsgaa9KJtOFIichOwJCwrdttd/Tkd5dT2iA72wYESU2HGIyEZN7RsCuYsE5wu1uKDWih2H7AQLCt2W03kafHHENDD2hRm9OUskEd2Uj4cr7ogxzYOymXtR6BbxW4XarGlgrCAA0/uHYng3DowlopbNbjzMsyUtH0ajIHIasgcsKNRm36bkIi23cWDsVA6MJaLWjY0JhNJNhkJNHfZeKhE7DtkBFhRqk4qaeryyPR0A8OSdPRCk5MBYImqdm9wF0weEAgCWrk/Fz2c5cRu1jAWF2qRpYGyPIC88OLyL2HGIyI48PTEWI7r7oabegD9+kYJ/78mAIPBwD90YCwrdstN5Gqw/kgMAeGF6Hw6MJaI2UbnL8dmCIbh/WGcIAvDq9nQ89c1J1DUYxI5GNojfMHRLjEYBf2kcGDtjQCgSuvmJHYmI7JDcRYoXZ/bBizN6w0UqwcYT+bj3o8MoruQss9QcCwrdkm+O5+JkbgW8FDL8mTPGElE73Z/QBZ8vGAKlmwwnciow872DOFugETsW2RAWFGqVaWCsacbY5YnRHBhLRBYxMtofm5eOQFd/TxRo6jB3TTKvekxmLCjUqtd2pONqTQMHxhKRxXUN8MKmR0dgZHd/1DYYsOSLFLy/m4NniQWFWnEqrwIbjpoGxv59BgfGEpHlqTzk+GzBYDyY0BmA6Y+iJ79O4+BZJ8dvG7opo1HA85tNA2NnDgjFsK4cGEtE1iFzkeKFGX3w0sw+cJFKsDmtAPM+5OBZZ8aCQjf19fFcnMzTcGAsEXWY+4Z1xn8fHgKVuxxpuRWY8d5BnMnn4FlnxIJCN3S1+trA2Cfv7IFADowlog4yvHvj4NkATxRq6nDX2mRsP1ModizqYCwodEOv/ZyOipoGxAZ7m48LExF1lCh/T2x6dARGRTcNnk3Fu0mXOHjWibCg0G+czK3Al0ebZoztDRkHxhKRCFTucqx7aDAeajx78F87L+KJrzh41lnwm4eaMRgFPN84Y+ysuDAM5cBYIhKRzEWKv03vjX/M6gOZVIKtJwtwz4eHUazl4FlHx4JCzXx9LBen8jTwVsiwckqs2HGIiAAA84d2xn8WmgbPnsytwHQOnnV4LChkdrW6Hq/uuG5grDcHxhKR7RjezR9blo5AtwBPqLV1mLv2EH48zcGzjooFhcxe3XFtYOwDHBhLRDaoi78nNi0dgdE9AlDXYMSj61Px9i8cPOuIWFAIAJCWW4Gvjl2bMZYDY4nIVind5Pj0wUFYMKILAODNXy7icQ6edTj8FiIYjAJWNQ6MnR0XhiFRvmJHIiJqkcxFir9O643Vs/tCJpXgh5MFuOeDZBRx8KzDYEEhfHUsxzww9jkOjCUiO3LvkEj8d+FQ+HjIcTJPg+nvHcCpvAqxY5EFsKA4ufLqery6PR0AsGICB8YSkf1J6OaHLUtHoHugF4q0Otz9QTK2nSoQOxa1EwuKk3t1+wVoak0DY+8fxoGxRGSfOvt5YuOjwzE2xjR4dtmGE3h/d4bYsagdWFCc2Imcq/j6eC4A4MWZHBhLRPZN6SbHJw8OxsKRUQCA13ak8xo+dszi30irV6/G4MGD4e3tjcDAQMycORPp6enNlqmrq8PSpUvh5+cHLy8vzJkzB0VFRZaOQi0wDYw9C0EA5gwMx+AuHBhLRPbPRSrB87/rhcWjuwIAnv3+NAoqakVORbfD4gVl7969WLp0KQ4fPoydO3eioaEBEyZMQHV1tXmZJ598Ej/88AO+/fZb7N27FwUFBZg9e7alo1ALvjyag9P5Gni7yfDcZA6MJSLH8qcJMegXroKmtgFPfp0Gg5HzpNgbiWDl2W1KSkoQGBiIvXv3YvTo0dBoNAgICMCGDRswd+5cAMCFCxfQs2dPJCcnY9iwYa2uU6vVQqVSQaPRQKlUWjO+Qyqr0mHcv/ZCU9uAv03rhYdGRIkdiYjI4rJKqzH1nf2oqTfgTxN6YNm4aLEjOb22fH9bfdCBRmO6VoKvr+kQQkpKChoaGpCYmGheJjY2FpGRkUhOTr7hOnQ6HbRabbMb3b5Xt6dDU9uAniFK3MeBsUTkoKL8PfH3GX0AAG/+cgmpOVdFTkRtYdWCYjQasXz5cowYMQJ9+pjeJGq1Gq6urvDx8Wm2bFBQENRq9Q3Xs3r1aqhUKvMtIiLCmrEdWur1A2Nn9ObAWCJyaHMGhmFa/1AYjAKe+OoEtHUNYkeiW2TVb6elS5fizJkz+Oqrr9q1npUrV0Kj0Zhvubm5FkroXJpmjAWAufHhGMSBsUTk4CQSCf4xqw/CO7kjt7wWqzafETsS3SKrFZRly5Zh27Zt2L17N8LDw833BwcHo76+HhUVFc2WLyoqQnBw8A3XpVAooFQqm92o7TYczcGZfC0HxhKRU1G6yfH2vAFwkUqwOa0AG1PzxI5Et8DiBUUQBCxbtgybNm3Crl27EBXVfABmfHw85HI5kpKSzPelp6cjJycHCQkJlo5DjcqqdHht+wUAptHt/l4KkRMREXWc+M6+eGK8aZDs85vPILu0upVnkNgsXlCWLl2KL774Ahs2bIC3tzfUajXUajVqa03noatUKixcuBArVqzA7t27kZKSggULFiAhIeGWzuCh2/PK9gvQ1unRK0SJ+UMjxY5DRNThlt7RHUO6+KK63oAnvjqBBoNR7EjUAosXlDVr1kCj0WDs2LEICQkx377++mvzMm+++SZ+97vfYc6cORg9ejSCg4OxceNGS0ehRilXruKb46Zdmi/O5MBYInJOLlIJ3pw3AEo3GU7mafDGzotiR6IWWH0eFGvgPCi3rrbegLlrD+FsgRZ3xYfjtbv6ix2JiEhUP54uxKPrUyGRAOsXDsXw7v5iR3IaNjUPCnU8o1HA4cwyPPPdSQz+xy84W6CF0k2GZzkwlogIU/qGYN7gCAgC8OQ3aSivrhc7Et2ATOwAZDnZpdXYeCIfG1PzkHf12rUnInzd8ffpfTgwloio0appvXAsuxyXS6rxzHen8NED8ZBIJGLHouuwoNg5TW0DfjxdiO9T8nD8yrVZEr0UMkztG4LZA8MwuIsvpFL+4hERNfFwleHteXGY/e9D+OV8Eb44koP7ObO2TWFBsUN6gxH7M0rxfUoefj5XhHq9aSS6VAKMjA7AnIFhmNArGO6uLiInJSKyXX3CVHhmUgxe+t95vLTtHIZ08UVMsLfYsagRC4oduaDW4vuUPGxOK0BJpc58f48gL8wZGI6ZcWEIUrqJmJCIyL48PCIK+y+VYu/FEjz+5QlsWTYCbnL+cWcLWFBsXGmVDlvSCvB9Sh7OFV67SGInDzlmDAjDnIHh6BOm5LFTIqLbIJVK8Ppd/TH57X1IL6rE6h/P44XGCwySuFhQbJBOb0DS+WJsTM3DnvQS6I2mM8HlLhKMiw3EnIHhGBsTCFcZT8IiImqvAG8FXr+rPx5adwyfJ1/B6B4BGN8zSOxYTo8FxUYIgoATuRXYmJqHH04WQlN77Yqb/cNVmBMfjmn9QtHJ01XElEREjmlsTCAWjozCJwey8PR3p7D9iVEI5CFzUbGgiKygohabTuTj+9Q8ZJZcuzZEsNINswaGYc7AMHQP5KAtIiJre2ZSDJIvl+FcoRYrvjmJ/zw8hGdAiogFRST7L5VgzZ7LSM4sQ9Ncvm5yKSb3MZ0aPLybP1z4i0FE1GEUMhe8c28cfvfufhzIKMVH+zPxxzHdxI7ltFhQRPD1sRys3HgajUNLMKyrL2YPDMeUviHwUvD/EiIisXQP9MJfp/XGyo2n8dqOdCR080O/cB+xYzklfht2sA/2Xsbqny4AAGbHheHJO3sgwtdD5FRERNRk3uAI7LtYgp/OqPH4lyfwv8dHwZN/PHY4ngbSQQRBwOqfzpvLyR/HdMW/7u7PckJEZGMkEglent0PoSo3ZJfV4K9bz4odySmxoHQAg1HAyo2n8cHeTADAc5NjsXJyT85dQkRko1Qecrx5zwBIJcB3KXnYerJA7EhOhwXFynR6A5ZtSMVXx3IhlQCvzOmLJRx0RURk84Z29cOyO7oDAP5v42nklteInMi5sKBYUbVOj4WfHcdPZ9RwdZHi3/MH4p7BkWLHIiKiW/T4+GgMjPRBpU6PJ746Ab3BKHYkp8GCYiVXq+vx+4+P4EBGKTxcXfDpQ4MxqU+I2LGIiKgNZC5SvD0vDt4KGVJzKvDOrgyxIzkNFhQrKNTU4q4PknEytwKdPOTYsGgYRkb7ix2LiIhuQ4SvB/4xuy8A4L1dl3A0q1zkRM6BBcXCMkuqMHdNMjKKqxCsdMO3SxIwIMJH7FhERNQO0/uHYs7AcBgFYPlXJ6CpaWj9SdQuLCgWdCZfg7vWJiO/ohZd/T3x3SMJnKaeiMhBvDCjN7r4eaBAU4eVm05BaJoGnKyCBcVCjmSW4d4PD6Osuh59wpT4ZkkCwjtxjhMiIkfhpZDh7XlxkEkl+PG0Gl8fyxU7kkNjQbGAX84V4YFPj6JSp8fQKF98uWgY/L0UYsciIiIL6x/hgz9NjAEAvPDDOWQUV4mcyHGxoLTT9yl5+OMXKdDpjUjsGYTPHx4Cbze52LGIiMhKFo/qihHd/VDbYMDjX56ATm8QO5JDYkFph08OZOGpb0/CYBQwZ2A41t43EG5yF7FjERGRFUmlErxx9wB08pDjXKEWr21PFzuSQ2JBuQ2CIOBfP6fjxW3nAAALR0bhtbn9IHPh5iQicgZBSje8Nrc/AODjA1n454/nkVFcKXIqxyIR7HAYslarhUqlgkajgVKp7NCfbTAK+OvWM/jicA4A4E8TemDpHd15XR0iIif0t61n8dmhbPO/+4erMHtgOKb3D0UnT1fxgtmotnx/s6C0Qb3eiBXfpGHbqUJIJMCLM/rgvmGdO+znExGRbTEaBfx8To3vUvKwJ70EeqPpK1XuIsG42EDMHhiOO2IC4SrjHnaABcUqaur1eOSLVOy9WAK5i+n447T+oR3ys4mIyPaVVumwNa0A36fm4WyB1ny/r6crpvcPxeyBYegbpnLqPe4sKBamqWnAw58fQ8qVq3CXu2Dt/fEY0yPA6j+XiIjs0wW1FhtT87HpRD5KKnXm+6MDvTAnPhwzB4QhWOUmYkJxsKBYULG2Dvd/chTpRZVQucvx6UODEd+5k1V/JhEROQa9wYj9GaXYmJqPn8+qodObroYslQAjuvtjbnw4JvQKhrurc5wByoJiIVfKqnHfJ0eQW16LQG8F/rtwKGKCOXU9ERG1naa2AT+eLsT3KXk4fuWq+X4vhQxT+gZjzsBwDO7iC6nUcQ8BsaBYwPlCLR749ChKKnXo7OeBLxYORYQvp64nIqL2u1JWje9T87ExNQ95V2vN90f4umNWXDjmDAxDZz9PERNaBwtKOx3PLseCz46hsk6P2GBv/GfhEAR6O9+xQiIisi6jUcCx7HJ8n5qHH0+rUaXTmx8b3KUTZg8Mx9R+IVA6yAzlLCjtsDu9GI98kYK6BiMGde6ETx4aDJW7Y7wxiIjIdtXWG8ynLB/MKEXjGctQyKSY0DsYsweGYVR3f7ueFJQF5TZtScvHU9+chN4o4I6YAPx7frzTDFwiIiLbodbUYXNaPr5PycOl6y5IKHeRwN9LAX8vBQK8FQjwUsDf2xUBXgoEeLvB38vVdL+3Al4Kmc2d0tyW729ZB2WyGwZBwIwBoXj9rv6Q23FLJSIi+xWscsOSMd3wx9FdcTpfg42p+diSlo+rNQ0o1NShUFPX6joUMqm5rDQvNIrGQnPtf23xj3HuQfmVI5llDj+KmoiI7I/eYERxpQ4llTqUVpn+1/zfVU3/XY+SSl2zsSy3wksha7b3xd9LgaFRfpjaL8Sir4F7UNphaFc/sSMQERH9hsxFilAfd4T6uLe6bG29AaVVut8WmiodSiuvFZqSSh10eiOqdHpU6fTILqsxr0NvFCxeUNpC1ILy/vvv47XXXoNarUb//v3x7rvvYsiQIWJGIiIisnvuri6I8PVodXoMQRBQpdM32/tSUlmH0qp69AtXdVDaGxOtoHz99ddYsWIF1q5di6FDh+Ktt97CxIkTkZ6ejsDAQLFiEREROQ2JRAJvNzm83eToamNXcBFtFOgbb7yBRYsWYcGCBejVqxfWrl0LDw8PfPrpp2JFIiIiIhshSkGpr69HSkoKEhMTrwWRSpGYmIjk5OTfLK/T6aDVapvdiIiIyHGJUlBKS0thMBgQFBTU7P6goCCo1erfLL969WqoVCrzLSIioqOiEhERkQjsYqKPlStXQqPRmG+5ubliRyIiIiIrEmWQrL+/P1xcXFBUVNTs/qKiIgQHB/9meYVCAYVC0VHxiIiISGSi7EFxdXVFfHw8kpKSzPcZjUYkJSUhISFBjEhERERkQ0Q7zXjFihV48MEHMWjQIAwZMgRvvfUWqqursWDBArEiERERkY0QraDcc889KCkpwapVq6BWqzFgwABs3779NwNniYiIyPnwWjxERETUIdry/W0XZ/EQERGRc2FBISIiIpvDgkJEREQ2hwWFiIiIbI5oZ/G0R9O4Xl6Th4iIyH40fW/fyvk5dllQKisrAYDX5CEiIrJDlZWVUKlULS5jl6cZG41GFBQUwNvbGxKJROw4t0Wr1SIiIgK5ublOfao0t8M13BYm3A4m3A7XcFuYOMJ2EAQBlZWVCA0NhVTa8igTu9yDIpVKER4eLnYMi1AqlXb7RrMkbodruC1MuB1MuB2u4bYwsfft0NqekyYcJEtEREQ2hwWFiIiIbA4LikgUCgX++te/QqFQiB1FVNwO13BbmHA7mHA7XMNtYeJs28EuB8kSERGRY+MeFCIiIrI5LChERERkc1hQiIiIyOawoBAREZHNYUGxgNWrV2Pw4MHw9vZGYGAgZs6cifT09GbL1NXVYenSpfDz84OXlxfmzJmDoqKiFtcrCAJWrVqFkJAQuLu7IzExEZcuXbLmS2mX1rZDeXk5HnvsMcTExMDd3R2RkZF4/PHHodFoWlzvQw89BIlE0uw2adIka7+c23Yr74exY8f+5jUtWbKkxfXa2/sBaH1bZGdn/2Y7NN2+/fbbm67X3t4Ta9asQb9+/cwTbCUkJOCnn34yP+4Mnw9Ay9vBWT4fmrT2nnCWz4gWCdRuEydOFNatWyecOXNGSEtLE6ZMmSJERkYKVVVV5mWWLFkiRERECElJScLx48eFYcOGCcOHD29xvS+//LKgUqmEzZs3CydPnhSmT58uREVFCbW1tdZ+Sbelte1w+vRpYfbs2cLWrVuFjIwMISkpSYiOjhbmzJnT4noffPBBYdKkSUJhYaH5Vl5e3hEv6bbcyvthzJgxwqJFi5q9Jo1G0+J67e39IAitbwu9Xt9sGxQWFgovvPCC4OXlJVRWVt50vfb2nti6davwv//9T7h48aKQnp4u/PnPfxbkcrlw5swZQRCc4/NBEFreDs7y+dCktfeEs3xGtIQFxQqKi4sFAMLevXsFQRCEiooKQS6XC99++615mfPnzwsAhOTk5Buuw2g0CsHBwcJrr71mvq+iokJQKBTCl19+ad0XYCG/3g438s033wiurq5CQ0PDTZd58MEHhRkzZlghYce40XYYM2aM8MQTT9zyOhzh/SAIt/aeGDBggPDwww+3uB57f08IgiB06tRJ+Pjjj53286FJ03a4EWf4fLje9dvCWT8jrsdDPFbQtEvS19cXAJCSkoKGhgYkJiaal4mNjUVkZCSSk5NvuI6srCyo1epmz1GpVBg6dOhNn2Nrfr0dbraMUqmETNbyZaH27NmDwMBAxMTE4JFHHkFZWZlFs1rTzbbD+vXr4e/vjz59+mDlypWoqam56Toc4f0AtP6eSElJQVpaGhYuXNjquuz1PWEwGPDVV1+huroaCQkJTvv58OvtcCPO8PkA3HxbOONnxPXs8mKBtsxoNGL58uUYMWIE+vTpAwBQq9VwdXWFj49Ps2WDgoKgVqtvuJ6m+4OCgm75ObbkRtvh10pLS/Hiiy9i8eLFLa5r0qRJmD17NqKionD58mX8+c9/xuTJk5GcnAwXFxdrxLeYm22H3//+9+jcuTNCQ0Nx6tQpPPvss0hPT8fGjRtvuB57fz8At/ae+OSTT9CzZ08MHz68xXXZ43vi9OnTSEhIQF1dHby8vLBp0yb06tULaWlpTvX5cLPt8GvO8PnQ0rZwxs+IX2NBsbClS5fizJkzOHDggNhRRNXadtBqtZg6dSp69eqFv/3tby2ua968eeb/7tu3L/r164du3bphz549GD9+vCVjW9zNtsP1H7p9+/ZFSEgIxo8fj8uXL6Nbt24dHbNDtPaeqK2txYYNG/D888+3ui57fE/ExMQgLS0NGo0G3333HR588EHs3btX7Fgd7mbb4fqS4iyfDy1tC2f8jPg1HuKxoGXLlmHbtm3YvXs3wsPDzfcHBwejvr4eFRUVzZYvKipCcHDwDdfVdP+vR/K39BxbcbPt0KSyshKTJk2Ct7c3Nm3aBLlc3qb1d+3aFf7+/sjIyLBUZKtobTtcb+jQoQBw09dkz+8H4Na2xXfffYeamho88MADbV6/PbwnXF1d0b17d8THx2P16tXo378/3n77baf7fLjZdmjiLJ8PQOvb4nqO/hlxIywoFiAIApYtW4ZNmzZh165diIqKavZ4fHw85HI5kpKSzPelp6cjJyfnpsdeo6KiEBwc3Ow5Wq0WR44cuelzxNbadgBMr2HChAlwdXXF1q1b4ebm1uafk5eXh7KyMoSEhFgitsXdynb4tbS0NAC46Wuyx/cD0LZt8cknn2D69OkICAho88+x9ffEjRiNRuh0Oqf5fLiZpu0AOMfnQ0uu3xa/5qifES0Sd4yuY3jkkUcElUol7Nmzp9kpYTU1NeZllixZIkRGRgq7du0Sjh8/LiQkJAgJCQnN1hMTEyNs3LjR/O+XX35Z8PHxEbZs2SKcOnVKmDFjhk2fMtbadtBoNMLQoUOFvn37ChkZGc2W0ev15vVcvx0qKyuFP/3pT0JycrKQlZUl/PLLL8LAgQOF6Ohooa6uTpTX2ZrWtkNGRobw97//XTh+/LiQlZUlbNmyRejataswevToZuux9/eDINza74YgCMKlS5cEiUQi/PTTTzdcj72/J5577jlh7969QlZWlnDq1CnhueeeEyQSifDzzz8LguAcnw+C0PJ2cJbPhyYtbQtn+oxoCQuKBQC44W3dunXmZWpra4VHH31U6NSpk+Dh4SHMmjVLKCws/M16rn+O0WgUnn/+eSEoKEhQKBTC+PHjhfT09A56VW3X2nbYvXv3TZfJyspqtp6m59TU1AgTJkwQAgICBLlcLnTu3FlYtGiRoFarO/4F3qLWtkNOTo4wevRowdfXV1AoFEL37t2Fp59++jdzHNj7+0EQbu13QxAEYeXKlUJERIRgMBhuuh57fk88/PDDQufOnQVXV1chICBAGD9+vLmcCIJzfD4IQsvbwVk+H5q0tC2c6TOiJRJBEAQr7ZwhIiIiui0cg0JEREQ2hwWFiIiIbA4LChEREdkcFhQiIiKyOSwoREREZHNYUIiIiMjmsKAQERGRzWFBISIiIpvDgkJEREQ2hwWFiIiIbA4LChEREdkcFhQiIiKyOf8PR8gySx2s7Q8AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "frequency_dist_ages2.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 4.- What do you see? Is there any difference with the frequency distribution in step 1?" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nThe frequency distribution is respectively on the left and on the right of the maximum, monotonically increasing and monotonically decreasing\\n'" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "The frequency distribution is respectively on the left and on the right of the maximum, monotonically increasing and monotonically decreasing.\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 5.- Calculate the mean and standard deviation. Compare the results with the mean and standard deviation in step 2. What do you think?" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "27.155" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "ages_population_mean2 = ages_population2['observation'].mean()\n", + "ages_population_mean2" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.9698139326891835" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ages_population_std2 = ages_population2['observation'].std()\n", + "ages_population_std2" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nThe max and min value of the population age are closer to each other than a smaller std is to be expected, as the variation around the mean is smaller'" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "The max and min value of the population age are closer to each other than a smaller std is to be expected, as the variation around the mean is smaller\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenge 5\n", + "Now is the turn of `ages_population3.csv`.\n", + "\n", + "#### 1.- Read the file `ages_population3.csv`. Calculate the frequency distribution and plot it." + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
observation
021.0
121.0
224.0
331.0
454.0
\n", + "
" + ], + "text/plain": [ + " observation\n", + "0 21.0\n", + "1 21.0\n", + "2 24.0\n", + "3 31.0\n", + "4 54.0" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "ages_population3 = pd.read_csv('../data/ages_population3.csv')\n", + "ages_population3.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0 1\n", + "2.0 2\n", + "4.0 2\n", + "5.0 1\n", + "7.0 1\n", + " ..\n", + "73.0 6\n", + "74.0 6\n", + "75.0 2\n", + "76.0 1\n", + "77.0 2\n", + "Name: observation, Length: 75, dtype: int64" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "frequency_dist_ages3 = ages_population3['observation'].value_counts().sort_index()\n", + "frequency_dist_ages3" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABsZ0lEQVR4nO3deXhb5Zk28Pto9yZ532JncyD7RoBgKDQlKSGlFEq+TtuhA12GDkzoQOlMIW2BbjR8nfm6zAwDM1MK7bSUlg57aQIESKEkQFKcneyLk3hfJG9aLJ3vD+k9OpK1W5Z0pPt3Xb4gliwfxbH1+NleSZZlGURERERZosv2BRAREVFhYzBCREREWcVghIiIiLKKwQgRERFlFYMRIiIiyioGI0RERJRVDEaIiIgoqxiMEBERUVYZsn0B4Xw+H86dO4eysjJIkpTtyyEiIqIEyLKMoaEhNDY2QqdLLteRc8HIuXPn0NzcnO3LICIiohS0t7ejqakpqY/JuWCkrKwMgP/JWK3WLF8NERERJcLhcKC5uVl5HU9GzgUjojRjtVoZjBAREWlMKi0WbGAlIiKirGIwQkRERFnFYISIiIiyisEIERERZRWDESIiIsoqBiNERESUVQxGiIiIKKsYjBAREVFWMRghIiKirGIwQkRERFnFYISIiIiyisEIERERZRWDEaI8IMsy/mf7Sew6NZDtSyEiShqDEaI8sP+cA/c+tx/ffGZvti+FiChpDEaI8sDAqBsAYB/zZPlKiIiSx2CEKA+Mur0AANe4L8tXQkSUPAYjRHnA6QkEI4H/EhFpCYMRojwwFsiMOJkZISINYjBClAfGAhkRr0/GuJcBCRFpC4MRojwwpirPsG+EiLSGwQhRHnC6GYwQkXYxGCHKA6MhwQibWIlIWxiMEOWBkDKNh5kRItIWBiNEeYA9I0SkZQxGiPKAUxWMOLlrhIg0hsEIUR4YYwMrEWkYgxGiPBBapmFmhIi0hcEIUR4IyYywgZWINCapYOThhx/GkiVLYLVaYbVa0draij/+8Y/K7atWrYIkSSFvt956a9ovmohCsYGViLTMkMydm5qa8OCDD+K8886DLMv4xS9+geuuuw7vv/8+Fi5cCAC45ZZb8N3vflf5mOLi4vReMRFNwDINEWlZUsHItddeG/LnBx54AA8//DB27NihBCPFxcWor69P3xUSUVxj7mA2hJkRItKalHtGvF4vnnzySYyMjKC1tVV5/69//WtUV1dj0aJF2LhxI0ZHR2M+jsvlgsPhCHkjouRwtJeItCypzAgA7N27F62trXA6nSgtLcUzzzyDBQsWAAD++q//GjNmzEBjYyP27NmDu+++G4cOHcLTTz8d9fE2bdqE73znO6k/A6ICJ8sye0aISNMkWZblZD7A7Xbj9OnTsNvt+P3vf4+f/exn2LZtmxKQqL322mtYvXo1jh49ipaWloiP53K54HK5lD87HA40NzfDbrfDarUm+XSICo9r3Iu539qs/Pmra87HHWvOy+IVEVEhcjgcsNlsKb1+J50ZMZlMmDNnDgBgxYoVeO+99/DTn/4U//mf/znhvitXrgSAmMGI2WyG2WxO9jKIKMDpDs2EsIGViLRm0ntGfD5fSGZDra2tDQDQ0NAw2U9DRFGMhfWIsExDRFqTVGZk48aNWLduHaZPn46hoSE88cQTeOONN7BlyxYcO3YMTzzxBD72sY+hqqoKe/bswVe/+lVcccUVWLJkyVRdP1HBmxiMMDNCRNqSVDDS3d2Nm266CR0dHbDZbFiyZAm2bNmCj370o2hvb8err76Kn/zkJxgZGUFzczPWr1+Pb33rW1N17USE0O2rADewEpH2JBWMPProo1Fva25uxrZt2yZ9QUSUHJZpiEjreDYNkcaFZ0a4Z4SItIbBCJHGMTNCRFrHYIRI49jASkRax2CESOOc4Q2szIwQkcYwGCHSOJEZKbP4+9E5TUNEWsNghEjjRDBSXmwEwDINEWkPgxEijRsNlGkqik0AWKYhIu1hMEKkcWKU11ZkDPyZwQgRaQuDESKNE3tGypXMCMs0RKQtDEaINE7pGSkSPSPMjBCRtjAYIdK48AZW97gPsixn85KIiJLCYIRI48LLNACzI0SkLQxGiDRuTJmmMSrvYzBCRFrCYIRI40SZptRsgE7yv49NrESkJQxGiDROjPYWmwwwG/QAuIWViLSFwQiRxonMSJFJB7PR/y3NzAgRaQmDESKNEz0jFqMeZoP/W5qLz4hISxiMEGmcCEaKjPpgmYYNrESkIQxGiDRuLKRnhGUaItIeBiNEGubx+jDu8y84KzLqYTEyM0JE2sNghEjDRFYEACwmXTAzwp4RItIQBiNEGuYM9IvoJMCk5zQNEWkTgxEiDVPGeo16SJLEPSNEpEkMRog0bFRM0pj8QQgbWIlIixiMEGlYcOFZeDDCzAgRaQeDESINc6p2jADgnhEi0iQGI0Qapu4ZAQCLaGD1sExDRNrBYIRIw0QwIvaLmLlnhIg0iMEIkYaNRW1gZTBCRNrBYIRIw8LLNMGD8lIr0wy7xvHItmM43Tea0P27HU78xxtH0TfsSunzEREBDEaING1iZmRyZZrn287hwT9+gP/3yqGE7v9ffzqOH24+hF9sP5XS5yMiAhiMEGnahMzIJDew9gz5MxwnekcSur+4X3t/YpkUIqJIGIwQaVi0Mk2qG1iHnB4AiQcX7QP++3XanSl9PiIigMEIkaY5w8o0kz21d9g1DgAYGPUo/x+NLMs4MzAGAOhyMBghotQxGCHSsAmjvZNcBz/kDAYgZwZiZ0f6R9zKOvpOhxOyLKf0OYmIGIwQadhomjewOgJlGgA40z8W877tA8HbR91eDMXJpBARRZNUMPLwww9jyZIlsFqtsFqtaG1txR//+EfldqfTiQ0bNqCqqgqlpaVYv349urq60n7RROQnRniLTekZ7VVnRtrjZEbCMydd7BshohQlFYw0NTXhwQcfxK5du7Bz505ceeWVuO6667B//34AwFe/+lW88MILeOqpp7Bt2zacO3cON9xww5RcOBFFOCjPOLmlZ0PqzMhAnMxIWOakk30jRJQiQzJ3vvbaa0P+/MADD+Dhhx/Gjh070NTUhEcffRRPPPEErrzySgDAY489hvnz52PHjh245JJL0nfVRAQguGfEEl6mSXGaRt20Gm+iJjwz0sHMCBGlKOWeEa/XiyeffBIjIyNobW3Frl274PF4sGbNGuU+8+bNw/Tp07F9+/aoj+NyueBwOELeiCgxY4GgY8JobxoaWNvjZUYCt5sCn5NlGiJKVdLByN69e1FaWgqz2Yxbb70VzzzzDBYsWIDOzk6YTCaUl5eH3L+urg6dnZ1RH2/Tpk2w2WzKW3Nzc9JPgqhQOcPLNJNoYB33+pSGWCD+NI24fWmTDQDLNESUuqSDkblz56KtrQ3vvPMObrvtNtx88804cOBAyhewceNG2O125a29vT3lxyIqNKNufyZDZEYsk+gZCd8rMuQch33UE/G+Pl9wx8iFMysBcNcIEaUuqZ4RADCZTJgzZw4AYMWKFXjvvffw05/+FJ/+9KfhdrsxODgYkh3p6upCfX191Mczm80wm83JXzkRRT2bxuuTMe71waBP/PcNUaKxGHUoNRvQO+xG+8AobMW2CfftGXbBPe6DXidhWXM5AGZGiCh1k94z4vP54HK5sGLFChiNRmzdulW57dChQzh9+jRaW1sn+2mIKAJneM+IMfgt7UwyOyKCkVKzEU0VxQCil2rE++utFkwrLwIAdNp5ci8RpSapzMjGjRuxbt06TJ8+HUNDQ3jiiSfwxhtvYMuWLbDZbPjSl76Eu+66C5WVlbBarfjKV76C1tZWTtIQTYFxrw9ub2gwYlJlQlweL0rNiX+Li7Feq8WApooitLUPRh3vFWO9zZVFqLdZAAB9I/5siWhoJSJKVFLBSHd3N2666SZ0dHTAZrNhyZIl2LJlCz760Y8CAH784x9Dp9Nh/fr1cLlcWLt2Lf7jP/5jSi6cqNCpMx+iTKPTSTDpdXB7fUn3jYjMSJnFgOZKf2Yk2nivyIw0VRSjstgEo16Cxyuje8ipZFWIiBKVVDDy6KOPxrzdYrHgoYcewkMPPTSpiyKi+MZUky9mVTbCbEgxGHH5MyNlFiOaKvyll7iZkYpi6HQS6qwWnBkYQ5eDwQgRJY/5VCKNGlOdSyNJkvL+4BbW5HaNDCs9IwY0BwKKaCvhzwyKzIg/aKm3+ks17BsholQwGCHSqLGwc2mEVLewOlRlGnVmJNJpvMGeEX/QUhfoG4k3UfNc21l84t/fwum+2DtMiKiwMBgh0igRjIhV8EKq59MEe0aMmFZRBEnyn8bbP+IOuZ/XJ+PcoD8YCc+MxNs18j/bT2HPGTteP9Sd1LURUX5jMEKkUeE7RgSRGUn25F4xTVNmMcBs0KOuzB9ghPeNdDqcGPfJMOr9vSKAukwTPRiRZRlHe4YBYEKAQ0SFjcEIkUYpq+DDMyOGyWZG/H3tIusR3jciJmway4ug1/l7VRIp0/SPuDEY2Og6MMpghIiCGIwQadRY3GAkyQZWV2gwEhzvDc2MiExJs2pqJpEyzdHuYeX/+5gZISIVBiNEGiUOtbOEl2mMqTWwBss0RgBQNbFGzow0VxYp7xPBSIfdGbHhFYBSogGAAQYjRKTCYIRIo4KZkdBv43SVaYLjvZEzI+p9IrVW//lS7nGfUooJd6x7RPl/9owQkRqDESKNcrrFaG/o7kIxXZNsmUY9TQPEyIwMhO4YEZ+zssQEIHrfiDozwmCEiNQYjBBpVNTR3hQzIw7VNA0Q7Bk5MzAGny9YejkbITMCQJmsiRaMHFP1jAyMuqOWc4io8DAYIdKouA2sSfSMyLIcbGANHK5Xb7NAJ/lLL73D/s2qHq8PHfbgIXlq9YFSTVeE8d4R1zjODgbLPR5v8PMRETEYIdKo4J6R8J6RwJ6RJMo0I24vRKJClGmMeh0abKHjvecGx+CT/QFPTak55DHqY4z3nuj194tUlpiU4ImlGiISGIwQaZT6bBo1ZQNrEpkRMUlj0EmwqBpiRfZDNK0Gm1eLQs7DAYJlmkjjvWKsd05NqdJbwmCEiAQGI0QaFb9nJPHMiHqSRh1kiL4QMc4r/hvpZN5YW1hFMNJSGwxGuPiMiAQGI0QaFTwoL3SaRjkoL4kG1vAdI4IY7w3PjIT3iwDBMk1HhGDkWGCSZk5tKSoCwUjfMIMRIvJjMEKkUco6+Ak9I8lP04jMSKk5NLAJXwkfHOuNkBmxxS/TtNSUoIqZESIKw2CESKOi9Ywoe0aSOCgvfOGZoB7vVf+3OUaZZmDUE3JI37jXh5N9/gbWObWlqCgWPSORl6MRUeFhMEKkUco6+DTsGQlfeCaIzMi5wTF4fbKqZ2RimcZWZFQ+d7fDpbz/dP8oPF4ZRUY9Gm1FqCzxf47+EdeExyCiwsRghEijop7aG5iGcSaVGfFnKaxhmZE6qwVGvQSPV8apvhF0D/kDCJExUZMkKeJ4ryjRzK4pgU4nobLEPxLMzAgRCQxGiDRKWXoWflBeCg2sYgFZaVgwotdJaCz3Z0HeOdEPACgx6VFRHJpBESJtYT2qal4FoGRG2DNCRAKDESKNCk7TpLNMY5hwm+gP2X6sD4C/eTV8x4gg+kbUW1jVO0YAqHpGGIwQkR+DESKNGovbM5J4mcYRZbQXCPaHbD/uD0YijfUKkcZ7j/UEm1cBoKqUwQgRhWIwQqRBPp+sZD4m9oyIaZo0ZUYC/SE9gX6RSGO9Qn3YFlZZlpUD8lpqQzMj9jEPxr3JHeZHRPmJwQiRBo2pmlPDe0bEOvd0LD0DJk7ORJqkEcIbWLscLgy7xqHXSZhZVQIAKC82QVR5BkbZxEpEDEaINEkdjFgM0RpYEy/ThJ/YqxaeCYmVGakLWwkvNq/OqCyGKVA+0usklBexiZWIghiMEGmQ6BcxG3TQ6UKbSZWekbSVaYpi/llNZEa6h5zw+WTVWG9pyP0qeFgeEakwGCHSIGeUSRogGIy4vT74fHJCjxdt6RkA1JSalccEYmdGasvMkCTA45XRP+oOTtLUhgYjlZyoISIVBiNEGjQWZeEZEGxgBfwBSTyyLKt6RiZmRiRJUvpErBYDbEWRd4wAgFGvQ1VgqVmn3RlyQJ5aJTMjRKTCYIRIg5Sx3hiZESCxUo1r3AeP159BiRSMAMFsSKysiFBv8wcjXQ5n9MyIOCyPwQgRgcEIkSaNxsiMGHQSRBtJIk2sokQjSUCJKXIwIvpEYvWLCGK893DXsLI+fnZNSch9RDDSx2CEiMBghEiTnFFO7AX8ZRXl5N4ExntFiabUZJjQDCtcNLMy5L+xiCbWt4/1AgDqrGZYw3pRlMwIp2mICEDkX4OIKKdFO5dGMBt0GHV7k8qMRCvRAMB1y6ahtaUKNaXmuI8nMiPvBs6yCS/RAFwJT0ShmBkh0qBYDaxAcNeIM4GekViTNGq1ZZaoZ9KoiV0jIivTUjMxGKnkSngiUmEwQqRBooE1ambEmPj5NMOu6JM0qRBlGiFSZkSM9rKBlYgABiNEmuSMmxlJfPGZI5AZKU1XMGINC0YiZUbEaC97RogISQYjmzZtwkUXXYSysjLU1tbi+uuvx6FDh0Lus2rVKkiSFPJ26623pvWiiQrdaJQTe4XgSvj0lWkSVZdIZiQQjDg9Poy6x9PyeYlIu5IKRrZt24YNGzZgx44deOWVV+DxeHDVVVdhZGQk5H633HILOjo6lLcf/vCHab1ookKXSAMrkOhob3rLNGVmg7IZtsxsQE3ZxKbXYpNeOauGfSNElNRPn82bN4f8+fHHH0dtbS127dqFK664Qnl/cXEx6uvr03OFRDRBvDJNcqO98adpkiFJEuqtFhzvHUFLbWnEpldJklBZbEKnw4mBEQ+aKtLyqYlIoybVM2K32wEAlZWhuwd+/etfo7q6GosWLcLGjRsxOjoa9TFcLhccDkfIG1Eh2XqwCy/t7UjqY0QDa6SzaYDkekaGA8FI+C6QyRBNrJFKNEJw8Zkr6n3a2gfx2J9PJHzGTjaMe3342ZvHse+sPduXQqRZKf8q5PP5cOedd+Kyyy7DokWLlPf/9V//NWbMmIHGxkbs2bMHd999Nw4dOoSnn3464uNs2rQJ3/nOd1K9DCJNc3q8uO3Xf4F73If/+dLFuPy8moQ+TpRpovaMJDFNMxSYpik1p2/t0IyqErx9rA/zG6xR75PI4rOv/343DncNY0mTDStmxF+4lg3bj/fh+384iItmVuCpWy/N9uUQaVLKP302bNiAffv24a233gp5/5e//GXl/xcvXoyGhgasXr0ax44dQ0tLy4TH2bhxI+666y7lzw6HA83NzaleFpGm9Ay54A6UUr75zD5sufOKqH0gamOBjEd694ykLxi5Y/V5mFtXik9dGP17uUI5LM8T8Xb3uA/Hevz9aD1DudtX0u3wZ3bODoxl+UqItCulMs3tt9+OF198Ea+//jqamppi3nflypUAgKNHj0a83Ww2w2q1hrwRFYre4WCJ4nT/KH6y9XBCHzcWmEBJRwOrI83TNIC/TPP5y2ahJEa2pUoJRiKXaU72jcAbKM+IJttcZB/zX1vvsBuynLvlJKJcllQwIssybr/9djzzzDN47bXXMGvWrLgf09bWBgBoaGhI6QKJ8lnvsP83/pJAUPGzN08k1HsQfwOrCEYSP5smnZmRRARXwkcONI4FTvwFgGFX7o7/OgJ/f26vTwnsiCg5SQUjGzZswK9+9Ss88cQTKCsrQ2dnJzo7OzE25k9PHjt2DN/73vewa9cunDx5Es8//zxuuukmXHHFFViyZMmUPAEiLesJnGrb2lKFaxY3wOuTsfHpvUpGIJqxeHtGkpimEQ2s6ewZSURliT8TE20L61FVMDKUwy/yjrHgtYmvJxElJ6lg5OGHH4bdbseqVavQ0NCgvP32t78FAJhMJrz66qu46qqrMG/ePHzta1/D+vXr8cILL0zJxRNpnSjTVJeacf8nFqDMYsDes3Y89ucTMT9O9ILEn6ZJ/KC8dE7TJKKyxL9/JNqekaM96mAkd8s0DtW1qctuRJS4pH4VilcPbW5uxrZt2yZ1QUSFRB2M1JZZ8I2PzcfGp/fi/718GGsX1qO5sjjix8VbepbonhGP16c8VsbLNIHMSLSV8FrJjIieEYDBCFGqeDYNURYFgxF//8SnL2zGxbMqMebx4lvP7ov6C4ByUN4ke0aGVS/y6TqbJlHKaG+EzIjPJ+N4T3Czcy4HIw51MMIyDVFKGIwQZZHoMagp8y8J0+kkbLphMUx6HbYd7sHzu89N+BifT46/ZyQQjDjjlGnEi3yRUQ+jPrM/DtR7RsKXmp2zjynPEQCGpqiB1T7qCclspELdtNrDzAhRShiMEGWRmKYRmREAaKkpxe1XzgEAfP8PBye8UKuzHdFHexMr0ygLzzKcFQGC0zQ+GRMCAnWJBpianpExtxerf7QNn3zozxj3xm/0jSY0M5K7+1CIchmDEaIsEmn96rDD5G79cAssRh16hlw43hv6wqzOGEQt0yS4gXUqFp4lyqjXKZ83vG9ELDsrL/b3lUxFmaZ9YBS9wy4c7x3Buyf6U34cB3tGiCaNwQhRljg9XqX8UF0aGoyYDDosnmYDALS1h+4dEcGIyaCDXjfxEDog8bNphqZg4VkygovPQoMRkRlZ1lwOYGoyI+r+ji37O1N6DK9PDikhMRghSg2DEaIsEf0iJoMO1giZCfFCvLt9MOT98ZpXgSTKNIEX+UifPxMqogQjxyYEI+nPjKj7O7bs70rpML7hsOvinhGi1DAYIcoS8Vt0TakZkjQxw7FUBCNnBkPe74yzfRVIvEwjNptmo0wDAJXFkSdqjgV2jCyfXgEAGHV74y6CS5Y6cOh0OLEnhVN3w3tduBKeKDUMRoiyJFLzqtrSpnIAwMEOR8hUzKg79o4RIJnMSHa2rwpioqZPFYwMjLiVPy8L/B0AE7MQkyX+/oVUSjVi4ZnobeFKeKLUMBghyhL1wrNImiqKUFVigscr40CHQ3l/vLFeIPHRXodyLk12ekYi7RoRm1cbbRbYio3Kc3GkuW9E/P3Pqy8DAGzZ15l0VkM0r9aWmVEWCOjYN0KUPAYjRFkS3DESORiRJCli30iwZyT6t6/FmNjSs2xO0wCqnhHVNI3oF2mpLQUQDJTS3TcigoZPXdgMk16H470jE0aK43EoPTdGZSKKfSNEyWMwQpQl8TIjgKpvRBWMiGxHsSl6AKGUaXJ8mqYyQgOrCAjmBIIR0Vyb7pN7RdAwq7oYl82pApB8qUb0jFiLjEq5jZkRouQxGCHKkvBV8JGIYKRNnRlJokzjGvfGLD0MK2Wa3GlgFWUaEYyIhWzpHu9VB4NrF9YD8E/VJEOc2Gu1GJSgkivhiZLHYIQoS8S2zvCFZ2pLm/y7Rk72jWIwUMpIpoHVJwPjMaZQlMxIlhpYI5ZpAsFIS40o04hgJH2ZEZ9PRl+ggbWmzIw1C+qgk4C9Z+04MzCa8OOIMo2tyKiU28IbY4koPgYjRFnSoxrtjaa82IRZ1SUAgN1n/KOnwdHe6N++ZtVtsfpGsl2mUZaeBV7AnR4vzgyMAQhmRsrMomckfZkR+5hHCdKqSsyoLjXjwpmVAICXk8iOOELKNOwZIUoVgxGiLIm2Cj6cyI6IvpHElp6pgpEYEzVDWS7TiMzIiNsLp8eLYz3DkGX/qKwIVMS1pXNkVgSCtiIjTIG/K1Gq2ZxE34jSM2IJBiPsGSFKHoMRoiyItQo+XHgTq9IzEqNMI0mS8iLrTCgzkp1gxGoxwBBYaT846lHOpGmpKVUWwYmsTTobWJVAUNWvs3ZhHQBg58l+9CUYUIgAyVpkYAMr0SQwGCHKAvGCZdJHXgWvpm5ilWVZCUaKjbE/Lng+TeTMiM8nY9id3TKNJElKdqRvxBWcpAn0iwBT08CqlMhUWammimIsmmaFTwZePZhYqUaUadgzQjQ5DEaIskC9YyTSKni1BQ1WGPUS+kbcODMwBqfSwBr72zfeFtYR9zjEoE22MiOAeqLGo+wYEf0iQHC0N50NrMHtt6FZqatFqWZfYqWakD0jqp4RroQnSg6DEaIsiLcKXs1i1GN+gxWA/5ya0QR6RgD1eG/kYES8uBv1UkiPSaZVlPizMv2j7uAkTW2JcvtUTNP0DEXe8SL6Rv58tC+hTIx6z4jIjHAlPFHyGIwQZUEiC8/UxDk1u9sHE9ozAqgOy4tSplFP0sTLzkylqpJgRuF4r79nZE5NmXJ7cANr+so0vRHKNIA/IzO7ugRurw9vHOqJ+zjBPSNGWIx6roQnShGDEaIs6I3ym3k06r4REYzE2jMCxC/TDLuyO0kjiMzInjODcI/7YDboMK2iSLk9mczIG4e68b+7zsS9X2+UsWpJkrB2UWJTNe5xn/K1sBX5n4OYjOLiM23pcjjx0OtHE25cpvRjMEKUBZEaKGMRZ9TsPWtXTq+NV6aJdz6NI8sn9gqiZ2TnyQEAwOyaUuh1wUyNuL54wYgsy/jKE+/ja0/txrnBsZj3VTJTZRPLZGvm+6dqth/ri/kY6oP7RJOtKLv18EVNU/7ttSP45y2H8Mvtp7J9KQWLwQhRFiSyCl5tdnUJyswGOD0+HOkeApBIZiS4Ej6SbI/1CuJ8mrOBAKKlpiTk9kTLNCPu4Lj0yUC5J5poPSMAlCVz/SNueLzRx6LFJE2Z2aAET1wJr027Tg0CAE7E+XdDU4fBCFEWJLIKXk2nk7Ck2b/8zOP1T2rEb2D13+6MclhecOFZdsZ6BTHaK6gnaYDQg/JiTamoz7dpj7HSXb0KPlIwUl5kVIKLvhhjusEdI8G/P473as+oexyHu/wBfqx/NzS1GIwQZUGyDaxAsIlVyLfMiBAejIhgyScHz+WJpE8VjIiV8pGErIKPkJnS6aSEFpipV8EL3MKqPfvPOeAN/HuI9e+GphaDEaIsSLZnBAj2jQhxMyOB211RMiOi98Sa5cxIeDDSUhMajFiMOiVTEatvJCQz0h/9N9xe1Sp4kT0Kl8g5M8FV8MFgjufTaM9u1YnYPUMu5ewnyiwGI0QZ5vR4lRfVZDIjSQcjcfeM+F9Ms97AqgpGdFKwZ0OQJEk1URO9byTRzEhPhFXw4ZSgIlZmxBkpM8KV8FrzvioYAZgdyRYGI0QZlswqeLVaqwUNNovy51hn0wDaKdNUFAeDgubK4oj7UxI5LC/RnpGeBEpkiZRbxI4RG3tGNE1kRsQAF/tGsoPBCFGGqbevJrtsTN03En+0N/aeEYczu+fSCBajHiWBwGpOWIlGKDPHn6jpHw0GAF2O6Ol28fcfq0SmBBVDsRpYg6vgBXVGhSvhc1/vsAtnBsYgScDFsyoBAGdilPho6jAYIcqw3qHk+0WEZdPLAfhXuBv18c6mERtY403TZDczAgQnalpqowQjqomaaPrDshHRdo0k0jycyL6Q4Cr44N+fshJ+PPpKeFmWcbJ3RGmapOzZc2YQgL9PSRy5wDJNdjAYIcqwRMoE0YjMSLxV8IBqtDdKmUa8sOdCMFIVCEaiZkYS2MKqzowAQHuUF5WeBILBmgQ2qSrTNKrMiMWoV3pwopV4tuzvwqp/eQP/8vKhqI9NmdF2ehCA//uquaIYAMs02cJghCjDkl0Fr3bhzAqsW1SPL31oVtz7Bs+miX1QXi4EIze1zkTr7CqsWVAX8fZEFp+JnhFR+z8T5UUlkYVzCfWMOCf2jADxA5k3DnUD8I+UUna1nbED8GccmwJHEDAzkh3Z/ylEVGBirSKPx6jX4eHPrUjovvEbWHNj6RkArF/RhPUrmqLenlBmJBCMnF9Xhg86h9Den3qZJtiImtyeEf/jmnCidyRqE2tboGGSW1qzS5ZlpXl1WVM5DHp/FBtrLJymDjMjRBmmNFCmkBlJRqyD8mRZzqnMSDzJlGmWNPk31UbNjAzFb2AVgcrAqCfqSnhHhD0j6o/tGXJO+Bj1tk+eX5Ndp/pGYR/zwGTQYW59mZIZGRj1xOxNoqnBYIQow5Q9Fyk0sCYj1p4Rp8enbCHNhcxIPMEyTeQXiXGvT2koXRLoq4nUM+LzyegbiZ8ZSWQlfKQ9I+rHjZQZ2XfWAdG32j/iho9NrFkjMlQLG60wGXQosxhRXuz/WkYLZGnqMBghyrBUVsGnQhntjTDiOuTyv5BKEpSx2lwWPLk3cs/I4JgHYpJ28TR/ZuRshBcU+5hHOdsn0ip4QaeTlKbaSKUaWZYj7hkBYpd42toHlP/3+mQMjHIfSbaIYES9TFA0sZ6JUuKjqZNUMLJp0yZcdNFFKCsrQ21tLa6//nocOhTaEe50OrFhwwZUVVWhtLQU69evR1dXV1ovmkjLJjNNk4xYmRGRYSg1G5LedZIN8co0onnVVmTEzMAG195hN0bdofcXAYLVYoi6Cl4QQUWk1e5Ojw/uQPkmemZk4sftbreHXQ+DkWzZHRjrVQcjolTDiZrMSyoY2bZtGzZs2IAdO3bglVdegcfjwVVXXYWRkeCxy1/96lfxwgsv4KmnnsK2bdtw7tw53HDDDWm/cCItUq+CT2XPSDLENE2k5V9DOXIuTaLEdYqMTjjRvFpZYoKtyKj0cZwNK9UkcyZQrJXwokSji5BZUnaURAhi2sJWj/MMm+xwj/uUaSb1IsHmykBmhBM1GZdU59rmzZtD/vz444+jtrYWu3btwhVXXAG73Y5HH30UTzzxBK688koAwGOPPYb58+djx44duOSSS9J35UQalOoq+FSI3/zdETMjubPwLBHxMiMiGKkI1PybKopxoMOB9oFRnFdXptwvuP028WAkUoZDPUkTnlmqjrISvmfIhbOD/m2fixpt2HvWzjNssuRQ5xDc4z6UFxsxo6pYeb+SGeFETcZNqmfEbvenHCsr/Wt0d+3aBY/HgzVr1ij3mTdvHqZPn47t27dHfAyXywWHwxHyRpSvJrMKPlmxyjTDGpqkAYINrMPRgpFRkRnxBwLNleJFJSwzkkTzsBi9jrQSXmRGwvtFgOCUVPhKeDFG2lJTqhwGyGAkO0TvztKm8pDvw+DiM2ZGMi3lYMTn8+HOO+/EZZddhkWLFgEAOjs7YTKZUF5eHnLfuro6dHZ2RnycTZs2wWazKW/Nzc2pXhJRzuvN0CQNoFp6FmHPyKnAb35TXSpKl9IEe0YqS4KZEWDiVIR48U9krLomRpnGHmH7qvJxqpXwQ6oRUXWPQiKnAtPUaQv07iwNOwk7uPiMmZFMSzkY2bBhA/bt24cnn3xyUhewceNG2O125a29vX1Sj0eUyzI1SQOo9oxE2MAqfktfoqqX5zKRwXF7fRF7YPpEmSYwAdNcETkzksy5QLE2qYpJGvW5NELISnjVx4p+kaXN5UrWhT0j2REMDG0h7xdB7JBzHPbR6Nt+Kf1SCkZuv/12vPjii3j99dfR1BTcmlhfXw+3243BwcGQ+3d1daG+vj7iY5nNZlit1pA3onylnIuSgWDEYoxeptkdYawxl5WaDBDZ9EjZEZEZEeO4SmZkMHJmJNYqeCFmz0iMMg0wcRInfNtnTYxdJDS1HE4PjvUMAwhtXgWAIpNe+bfBiZrMSioYkWUZt99+O5555hm89tprmDUr9HyMFStWwGg0YuvWrcr7Dh06hNOnT6O1tTU9V0ykYZNZBZ8spYHV6wtZrtXtcOKc3QmdFNzJket0Ogmlpugn9/YHfoutKA5kRgJTERN6RpLITCXUwBplGkm8oIlg42TfKBzOcZgMOsxrKAs2uTIzknF7z9ghy/6+oqoI/w6ilfhoaiXVvbZhwwY88cQTeO6551BWVqb0gdhsNhQVFcFms+FLX/oS7rrrLlRWVsJqteIrX/kKWltbOUlDhOSmOSZLNLAC/uxIUWAEVZQLzqstQ4lZGw2sgL9vZMg1HnHxWX9gq6pYZCZq//YxDxxOjxI0iGbUxIIR/2OJlfBGffDv0x7lXJrgx4YGMqJhclGjFUa9TpUZYTCSaUq5LEqJsqmiCG3tgxzvzbCkMiMPP/ww7HY7Vq1ahYaGBuXtt7/9rXKfH//4x/j4xz+O9evX44orrkB9fT2efvrptF84kRZlauEZEB6MBPssRL18abM2siJCrPHegZHQzEiJ2YDKQMlGbNOU5eAq+ER6RiqKTVFXwis9I1GmkcKDkd1hDZPi9j6uhM+4eCXKYFaNmZFMSurXIvWYWjQWiwUPPfQQHnrooZQviihfJdNAOVkGvQ56nQSvTw7pGxEvjMuaK6b8GtIpeD5NpMxIcOmZ0FxRhP4RN84MjGJBozXhVfCCWAnfPeRC77AL9TaLcluyPSPhq8fF5xcr4SOVC2hqRNq8qqashGdmJKN4Ng1RBmUyMwKodo0EJmp8vmAjpVYzI46wzMiY24uxwISNOhhpCtsZIQKDRFbBC9FGcKMdkhf+cb3DLrjHfTgQ2PYpXgCNep2yoI1NrJnTYR9Dl8MFvU7CwsbI//65Ej47GIwQBZzqG8HP3zoR9cj4RL17oh9Pvnt6Qvo9ZBV8poORQJnmeO8IhlzjsBh1OF+1mVQLoi0+EwvPjHpJGakFgKbK0J0RSiCYRFaqOsr5NLH2jACqlfDDbhzscMDt9W/7nF5ZrLoP+0YyTQTic+vKlB6qcOqV8IlUA9SOdA3hl9tPsvSWAu10rxFNsR9uOYQ/7OmAT5bxt5fPTvlx7njyfXTYnfDKMm5cOUN5v9iFYdLrIu6nmAr+DIBHKdOIH8aLGm0hDZlaEDy5NzQYGVBWwYdutVUyI4GeEZGBSCYQjNZoGmvPCICQaRmlRyds22d1qRlHuoe5aySD9p4VvTvRs4KN5RZIEjDq9qJ/JLkS2u1PvI9DXUOYUVWCD59fM+nrLSTa+mlENIXODfpftP64L/K24EQMjrrRYXcCAB586QN0OZzKbcoq8gysghcsYVtY49XLc5lVaWAN7Rnpi9AvAgQXn4nMSCrbb6OthI/bM6Iq77SdHgQw8e9cWarGzEjGHO327xeJlRU0G/SoK/P3ByXTN3KsZxiHuoYABH+WUOIYjBAFiN+w/3J6AN1Dzjj3jkz8sAOAIdc4vv38fuXPmVwFL4RvYVVvAdWaaNM0A1GCkaaK0HR7TxKr4IVImRFZluPuGVGvhP/zsV4AE4MRroTPPPH9Oae2NOb9Uukb2bI/+EuMaKimxDEYIQoQv2HLMvDKga6UHkNsdpxZVQy9TsIf93Xi5cAPqUyughfE+TTOcS+cHi8OdoQ2UmqJMk3jCs2M9IetghfEC8qwaxyDo55gMJjAJI2gBAyqUsqwaxyiJSBaA6t6JXyXw/+xS5pCSwOxDuKj9PN4fTjV5w8uWmpiByPRlubFsmV/8GcGg5HkMRghgv8Hlfo37s0plmrEb14fmVeLWwJ9J/c9tx9DTk9Sq8jTRT1Nc7DDAY9XRmWJSXmh1pJomZH+sFXwgsWoVzIUZwbGgofkJZGZilRKEdM8Jr0uZJdLOPXXOdK2T2ZGMutU3yjGfTJKTHo0qMa0I0n2wLwO+5jSjwUEs3WUOAYjRAAGRkN/eGw/1qdMTCRDBCMtNaW4Y/V5mF5ZjE6HE/+85VDwXJpslGnGfSHLnjLVs5JO0RpYxTSNWHim1qxKt6ey/TbSxItDtX011t+j+uscaadLrIP4KP2U783a0rj//pvDxsLjeXl/aCa1j8FI0hiMECF0adZ5taUY98l4/YPupB/naE+wJl1k0uMHn1wMAPifHafw5hF/70BGyzSq0d54a7BzXbSlZ9F6RoDQc0aCDcTJBCOhK+EB9Sr42BNR6s+ztGni9AZXwmeWKKHGK9EAyWdGRCb1ktmVACb+ckPxMRghQmgwcvUi/wnTyZZqnB6v0n0vGuQ+dF411l/QBFn27/gAstMz4hr3YfeZ+GONuSxamSbaNA3gL48AwOn+UWUVfDINxJFWwsdrXhXUX+dIPTpcCZ9ZxxJsXgVCd43E+9oMjLjx7sl+AMBnL54OgD0jqWAwQgRVMFJswtqF/mBk2+EejLm9sT4sxPGeEciyf9xT3b/wrWvmh7xQZjIYsQTKNF0OJ04EgiGtZkbEi3/4qb2xMiMi3b7/nENZBZ9Mz45YCQ8EMxiiZyTaWK8gvs7Rtn2Gr4SnqXU0icxIg80CvU6Ce9wXN3P16sEueH0y5jdYle8tBiPJYzBCBNXirBIjFjZaMa28CGMeL/50pCfhx1CXaNQ16YoSE+77+ALlzxntGQlkRt474T81dmZV8YSpE60QmZFRtxfjqi25AzF6RkSZZv9Z/xRRMqvghfBGU0ecE3sF8XWeVx952ydXwmeOLMtJZUYMeh3qrf4m13jjvWKkd+3COuV7a9Ttn16jxDEYIQLQHzj1tbLEDEmSlOyIendAPMoPuwi/eV23rBG3XD4LN1wwDS01JWm44sSIF14t7xcRSlUn5IrsiM8nY2DU/7WLdPidKNO4A8FLKjteqsMaTYOr4GP3jFw5rxaXzK7E3324Jfpjs28kIzodToy4vTDoJMyoKo7/AQj+24m1+GzENY4/BXrBrl5UD6vFAEOgrMdsV3IYjBAB6A/0E1SW+H9TXbuwDgCw9WB3wmfVKGng2onBhiRJ+OY1C/Cjv1qW0UkW0cAqXoy1WqIB/JkEsVFW9I04nB54AzX98uKJmYoGWxHUf92plMiC58yIMk1imZF6mwVPfrkVn1jaGOOxGYxkgpikmVFVnPAxCMHjBKJnRrYd7oF73IcZVcWYW1cGSZKU7Egfs11JYTBCBKA/8Nu1SPVfOLMSVSUm2Mc8eOd4f0KPkUwaOFPC92BoOTMCBCdqREAgavNl5sjlF5NBhwZrcKdEKiWy4AiuaGBNrGckEdEO4qP0SnTzqlqzaoNvNKLJfe3CeuWXjMpiMYHFYCQZDEaIEOwZEal+vU7CRxf4syOJlGq8PlmZlplTkzun4ZqNwRdog07CwkZrFq9m8kTfiDi5N9r2VTXxGy6Q2mnJ4SO4SmYkzjRNMo/NxWdTK5mxXiHeSnjXuFcZ/xeZVCDYSM0m1uQwGCFCcDxU3QSp7huJN953ZmAU7nEfTAYdpuXQdlN1ZmR+gxUWY3LNm7mmLGzxWULBSGXw65HK9tvwlfCJ7hlJ6LG5Ej4jUsqMxFkJ//axPgy5xlFTZsZy1VI7BiOpYTBChMjjoZfOqUKp2YDuIRfaAqfdRiN+2M2uLlH2UuQCdWZEq/tF1MLPpxGp8PBV8GrqzEhqPSNhmZEE94yk8tg0NY52B7KWSQQjIjNybnBM6UtSE2dOXbWgDjqdenrO/++CK+GTw2CECp4sy8pKcXUwYjbo8ZF5tQDil2qO9eRevwgQmhnRcvOqEL74LFJGK1xzhTozMomekUDAMJTgnpGEHjvCQXyUXvbR4LlQs5Mo09RZLTDqJYz7ZHQ6Qk/x9vpk5TBNkUEVKkv8X9N+9owkhcEIFbwRtxfucf+0SfjirKtFqWZfJ2Q5eqlGfSZNLlEHI8unl2fvQtIkPBgJZrSiBwYhPSOpjPaGrYRPdM9IIiIdxEfpJabcGmwW5XyjROh1EhrLA+O9YRM1u04NoHfYDavFgEtmV4XcVhmY6mKZJjmTL3oSaZx4QTMbdCgK66lYNbcGJoMOJ/tGcbhrGHPrIzenplKTzgQxYVJqNmB2dW5dWyqC59OInpHgfphomtU9IykEI2IlvNcno3vIhaHAjpN4e0YSEb4SXhehxLfzZD++++IB/OCTi7FomvZLbZk2mSm35opinOobxS2/3BnSbyU2M6+eXwdT2MRaBXtGUsLMCBU89RH04TtASswGXD6nGkD0Uo0syzjWk3xNOhPm1JZCr5PwkXm1EV/otCZ4cq8Y7Q3dDxNJg60ITRVFaLBZUJtCMKLTSUrG7ETg6wykJzOiXgk/GOWU6J//+QT2nLHjF2+fnPTnK0TJrIEPd9FM/8F3Duc4uodcypsISNdf0DThY6oCgfHASPKnfhcyZkao4MWbyFi7qB5bP+jG5n2d+IfV5024vXfYDfuYB5IEzKrO3HbVRMypLcW731idlv6GXBBepgnfDxOJXifh5a9eAZ+MhBdehaspNaNnyIXjvf4XtmKTPuXHUjPqdSgvNmJw1IOeIVfE83V2t/sPONwdp4maIhOZkZYUflH4h9VzcM2SBrjGJ652Ly82YVr5xMk50cDax8xIUhiMUMHrj3HQGgCsmV8HnQQc6HCgvX9UGfkTRImmuaI4J0dnqzJ4MN9UsyplmtDMSKRV8GrFpsn9qKsuMwMdwRe2dEzSCDWlZgwGmiznIrQM2D3kxNlB/2jpke5hDLvGk+p7INWZUSlkRiRJSjrbKX6ODIy6IctyRjcuaxnLNFTwBiJM0qhVlpiwcpa/SS1SqSZXJ2nykbL0zCUaWONnRtJBNLGKclw6dowEHzt6E+ueQFYEAGQZ2HvGPuE+FJ3T41XWuUc6pmEqiH+LXp+snPBM8TEYoYKXyHio2LAYKRgJTtLkVokmH6kbWF3jXiUoiRZIposYwT3ek/7MSKyV8OGlGXHgISXmZN8IfLK/2TiV7bupsBj1KAmc0swm1sQxGKGCF2nhWbirAiO+O08NTHjRYGYkc0pVPSMiK6LXSWkNDiIRI7jn7P59E+nswQk/iE9NBB8zAyfN7mYwkhT1lFsmyyWcqEkegxEqePF6RgCgsbwIS5tskGUoy46EXDwgL1+JMo3D6Qk2Hhcbp3xSKHxZWjomaYTwg/gEn09Wgo+bWmcCYBNrsrI1cl/FYCRpDEao4CUSjADB7Ii6VDPiGld+W861hWf5SN0z0hdoXp3qfhEgQjCShh0j4Y8d3jNysm8EDuc4zAYd1q9ogk4COuxOdIVtA6XoRI9Ppr83RWaEK+ETx2CECl6kVfCRiLXPbx/rVU5uFSWa6lITyjPwoljoRDlGloNHu091vwgQPNBOSGeZJvxUYEFkQRZNs8FWZMT5df5JG/aNJC5bmRHlsDyuhE8YgxEqeIn0jAD+H2hzakvh8crK0eGpHE1OqTMbdDDq/SWZU33+KYmMBCNTWKYJPxVYaDs9CCB4ppD4L/tGEuP1yUrDccaDkWKWaZLFYIQKmnrzZSLp/vCpmlxdA5+vJElS9myc7ven4DMRjIiV8EJa94yUha6EF9oCY7zLAmcKif+ybyQx5wbH4Br3wWTQhZxPlAlsYE0egxEqaIOjbojz7yqK47/AXL2wAQDw+gc9cHq8OXtAXj4T472ZzIzoVSvhgfTuGYm0Et417sXBcw4AwLKwzMiedntI0EKRie/N2dUlIYFkJlSxZyRpDEaooImFZ7YiIwwJrPdeNM2KaeVFGPN48eaR3pw9kyafiSZWEYxkooEVCC3VpLNMI1bCA8G+kQ86huD2+lBRbFQO+ju/rhQWow5DrnFlLT1Fd3QSa+AnS2RGuBI+cQxGqKD1DSfWLyJIkoSPLvCXav6w5xxO9jIYybTwLazxVsGnS7Xq86R7r0l434hoUl3aXK7sxzDodVgcOLW3rZ2bWOPJZj+XeiU8JYbBCBW0eKvgI7l6kX+q5sU9HRj3ySg26dFgs0zJ9dFEpebQQCBTmZEa1Ym/6T54MHyiRjSpLmsuD7mf+DObWOPLZj9XJXtGkpZ0MPKnP/0J1157LRobGyFJEp599tmQ2z//+c9DkqSQt6uvvjpd10uUVv0pnG1y0cxKVJaYMB6o27fUZHa7Y6EL3/GRiZ4RACHrxNOeGQlbCd8WaFJdGhaMiD+ziTU2WZYndUDeZIlpmiHnONzjvox/fi1KOhgZGRnB0qVL8dBDD0W9z9VXX42Ojg7l7Te/+c2kLpJoqohTXytLEn9x0eskfHR+nfJnlmgyqyxLwYgopUjSxGuY/GP7n0PvsBv2MQ+OB3qRRNOqIP58sMMBp2fisfbk1zfixuCoB5IEzM7CmVG2IiNEz+wgSzUJSfo7at26dVi3bl3M+5jNZtTX16d8UUSZIjIjlSXJHaK1dlEdfruzHQAPyMu0Mkt2yjRi8Vmp2ZD29fPqnhFxMu/0yuIJgVZTRRGqSkzoG3HjQIcDF0yvSOt15AtxRENTRREsRn3GP79OJ6Gi2P916h91o9bKMm48U9Iz8sYbb6C2thZz587Fbbfdhr6+vqj3dblccDgcIW9EmRLsGUku7X5pS7VyMiczI5mlzkoUGfUoMmXmxaam1P+CMhWH8inn0wy70NY+AGBivwjgb6Bm30h8R7qzV6IRlF0jw8yMJCLtwcjVV1+NX/7yl9i6dSv+7//9v9i2bRvWrVsHrzdySnHTpk2w2WzKW3Nzc7oviSiqPuWwteR+u7YY9dj4sfm4akEdPnx+7VRcGkVRqgpGMlWiAYALZ1Zg1dwa/O3ls9L+2OoGVjEpE94vIixlMBLXvrP+v8P5DdasXYOyhZVlmoSkt/AJ4DOf+Yzy/4sXL8aSJUvQ0tKCN954A6tXr55w/40bN+Kuu+5S/uxwOBiQUMaIpUSpjId+7pIZ+NwlM9J9SRSHukyTyWDEYtTj8S9cPCWPrS7TdDn8fUzLmm0R7xtsYuV4bzRtUaaRMqmSi8+SMuWjvbNnz0Z1dTWOHj0a8Xaz2Qyr1RryRpQp/SlmRih71GWaigwGI1NJ9KN0D7nQO+yCQSdhYWOUYKTJ//4TvSNsjoxgxDWOw11DALIbjHDxWXKmPBg5c+YM+vr60NDQMNWfiihp/Qkekke5Qz3aW5UnX7eqsAbqeQ1lURsvy4tNmFXtb5pmdmSifWft8MlAg82S1cZR0YfGzEhikg5GhoeH0dbWhra2NgDAiRMn0NbWhtOnT2N4eBj/9E//hB07duDkyZPYunUrrrvuOsyZMwdr165N97UTTcqY24uxwHgkgxHtUJdp8iWjZTIEV8IDE0d6w4nsCPtGJhI7WOL9HU41MaHXP+rJ6nVoRdLByM6dO7F8+XIsX74cAHDXXXdh+fLluO+++6DX67Fnzx584hOfwPnnn48vfelLWLFiBd58802YzcmNThJNNTFJY9QHT4Kl3Kf+WiU7BZXL1GffRGteDb+dwchESr9I4JTjbBH/NsUuI4ot6Z/Aq1atgixHPzFyy5Ytk7ogokxR94twg6p2lIVM0+TPLznVpSYc7fb/f7xeBxGMtLUPQpZl/vtV2S2mkbKcGRFZO7HLiGLj2TRUsNgvok0lJgPEa28+ZUZqyvz9DaVmQ9zD3RY0WGHUS+gbcePMwFgmLk8TuoecODs4BkkCFjdFbgDOFNEHxJ6RxDAYIc37oNOB6/79Lbx9rDepj0vlkDzKPp0uWFbLt8wIACyeZoM+zoZXi1Gv7NBoY6lGsSeQFTmvtjTrpdcKpUzjjllNID8GI6R5/7P9FHafsePnb51M6uP6ApsR82U8tJAsarShyKjPq+23ojRz5bzElugtbPQHI2LbKOXGfhFB/JLj9vow4uY5QvGwa480T3TPJ1s/F5mRfBkPLSS/+OLFGHWPozxPpmkA4Lpl09DaUhVyOnAszZXFAIAz/aNTeVmasjvKacfZUGwywGLUwenxoX/YnfVMTa5jZoQ0zenx4oMO/4Kj3mEXOuzOhD+WC8+0yz8Km39ft9oyS8LBdFNFIBhhzwgAwOeTlemibDevClwJnzgGI6Rp+885MO4L1mOTGXVkAytpWXNFEQCgfYCZEQA42TcCh3McZoMOc+vLsn05AIIlYDaxxsdghDQtvHkvmWY+BiOkZSIz0ulwwj3uy/LVZJ/43l88zQajPjde2iq5Ej5hufEVI0qRyITMrPL/YE4mGOE0DWlZdakJFqMOsgycG2SpRinR5EC/iMDD8hLHYIQ0TTSs3dQ6EwCw96wdXl9iY3TsGSEtkySJfSMqbYFzenIpGKlgz0jCGIyQZg2MuHGqz18v/+TyaSg1GzDq9uJoAqOOPp+MgcCZEVWlDEZIm9g34uca9+LgOQcAYFmONK8CwUm9/mEGI/EwGCHNagtkRWZXl6CixITF0/wbF9vaB+J+7JBzXMmgqA8oI9KSYGYkfjByuGsI/7PjFHwJZg615GDHENxeHypLTGiuLMr25ShEAyszI/ExGCHNCq8RB8/riH+sel/g8KpSswFmQ+Sj2olynXjhbe+PX6b51jP7cO+z+7Blf+dUX1bGBUd6bTl1Tg97RhLHYIQ0a3fYtsVlSZxkyuZVygciMxKvTCPLMg50+MsYO0/FzxxqTS42rwLBny/9DEbiYjBCmiTLsjI5szQsGDnUNYSxOOuXxUmaXAVPWtacYANrl8OFYdc4gOR28WhFWw5tXlWrZJkmYQxGSJPa+8cwMOqBUS9hfoN/wVG9zYI6qxlen4x952KXavoDZZpK9ouQhokyTc+QC05P9AD8WE+wqXvfOTs83vzZS2If9eB4zwiA3Nm8KohpGvuYB+N59Hc+FRiMkCaJ34QWNFhDej7ED6N4v/2JzEg+nfpKhcdWZFTOPImVHVFPmDk9PhzqHJrya8uUPWcHAQAzqopzruxaEfhlR5aBwTFPlq8mtzEYIU0K7xcRlk33/zne8rNgzwgzI6Rd/l0j8cd7w8fdxX6efJBr59GoGfQ62Ir8P2PYxBobgxHSpPB+EUHsGIj3w7YvMPfPnhHSukQWn4lgpNFmAZBffSNiei7X+kUENrEmhsEIaY7H68O+s5F/AC1qskGS/D0lfcOuqI8hMiNVDEZI40TfyJn+6JkR0TPyyQumAUju2IRcpm5kX9Zsy+7FRMFgJDEMRigntfePRm34OtQ5BNe4D2UWA2ZVlYTcZrUY0VJTCiB2doSr4ClfxMuMOJwedA/5A/P1FzQBAI50DyvTNVrR3j+KnSf7Q95ePdiN3mEXDDoJCxtzMxjhSvjEGLJ9AUTh3jvZj089sh2r59XiZzdfOGGJkQgyljWXQ6ebuOBoWXM5jnYPo63djivn1UX8HDyxl/JFvJXwokRTZzVjdk0pppUX4ezgGPaesaO1pSpj1zkZH3Q6cPVP3ox6+7yGMliMubm8UPSlsWckNmZGKOe89kE3AGDrB914tu3shNvbTg8CiN6wtjSB5WcDDEYoT8TLjBwLBCMiY7g0UM7QUhPrBx3+6Z8iox6zqktC3ubUluLLV7Rk+QqjExN7fQxGYmJmhHKOOoj43osH8eHza0OCht1xFhypm1hlWZ6QWXGP+zAUSFEzGCGtawr0jPSPuDHiGkeJOfTH+tFAv8ic2kAw0lSOl/Z2KkG9FgwGShxXzqvFQzdekOWrSQ4zI4lhZoRyis8nY0/gKPDqUjP6R9z4/h8OKLcPu8ZxJPCb3tIoDWtz68tgMugwOOpRTvVVE82rep0Eq4WjvaRtVotRGR+NlB0RmRElGBGZQw1lRsSODpsGlxSKzEj/KPeMxMJghHLK8V5/Y12RUY9HPncBJAl4+i9n8eaRHgDA3jN2yDIwrbwItWWWiI9hMuiwqNEKIPIP3GDzqjFizwmR1gQPzJsYfB8LbCcVZZrF02zQSUCH3YkuhzNzFzkJg4EX8vIiLQYj/msWW58pMgYjlFPeD6SOFzfZcOHMStzcOhMA8M1n9mHM7VXtF4ndOR88wXdwwm0DnKShPNNUHvnAPNe4F6f6/MGIyIyUmA04v85/hIJW9o2IMk25BjMj4ufMwAgzI7EwGKGcop6UAYB/XDsXjTYLTveP4idbDye8bTHWCb59bF6lPKPsGgkr05zsHYVPBsrMBtSWBY8+EN8/Wtk3Iso05Rr8BaJKaWBlZiQWBiOUU3aLbYqBH5alZgO+e90iAMDP3jyBPx/t9d8eZ9ui+Ph95xxwj4fuKwmugtfeDzaiSJorA5mRsDKNWHY2u7Y0pJFba30jWi7TVATKNE6PL+5p4oWMwQjlDKfHi4MdDgChZZg1C+pwzeIGeH0yhlzj0En+uncsM6qKUV5shHt84qFgSs8IgxHKE+J8mvDMiNgxMifQLyKI76897Xb4fHIGrnBy7BrOjJSaDTDq/YEgF59Fx9Feyhn7zzkw7pNRXWrCtPKikNvu/8QCvHmkBw7nOM6vK5swvhhOkiQsbSrHtsM9uPFnO0IWIg05/WO9XAVP+aK5InLPyNGwSRphbl0ZLEYdhlzjON47jDm1ZZm50BRpuWdEkiRUlpjQ5XChf9g94Wcb+TEzQjlDfRJv+G6Q2jILvv2JhZAk4KMLIm9VDbd6fi0AwOEcR/eQS3kb8/hTpfGyK0RaMS2QGRlyjitZBCBYpgkPRgx6nfLvXxw0l6t8PjmYGdFgmQYA6m3+r8+JQDMxTcTMCOUMZZlZlObUGy5owofPr0l4CuZvLpmBD82pVoIPNavFqNTZibSu2GRAdakJvcNutPePwjbNBp9PVoKRlpqSCR+ztKkc750cwO72QfyfFU2ZvuSEDbnGISpJVo0GI0ubbNjdPojd7YP4xNLGbF9OTmIwQjlDmZSJ0ZxaVWqOels4SZIwO6xWTpSvplUUo3fYjTMDY1g0zYazg2Nwenww6XWYHiHw1koTqz3QvFpk1Ofs+TPxLGsuxy+3n9LMKHU2sExDOWFw1I2TgW2p8cZ2iWiiZqWJ1f99JLIiM6uLYdBP/FEvxt8PdjjgjJA9zBWDY9rtFxFE4Lf3rB2eKKeRFzoGI5QTxL6D2dUlmlz5TJRt4QfmHQ07IG/i/YtQVWKCxyvjQGCKLReJsV6bRks0ADCrqgRlFgNcEab7yC/pYORPf/oTrr32WjQ2NkKSJDz77LMht8uyjPvuuw8NDQ0oKirCmjVrcOTIkXRdL+UpZb9InP0hRBRZ+Er4aM2rgiRJCZ1wnW3BhWfaDUZ0OknJ+OZ6WSxbkg5GRkZGsHTpUjz00EMRb//hD3+If/3Xf8UjjzyCd955ByUlJVi7di2cTm2cgUDZEWxe5YQLUSqawsZ7j3WHroGPRHmBzOFgxC7Geou0PYofays0pdDAum7dOqxbty7ibbIs4yc/+Qm+9a1v4brrrgMA/PKXv0RdXR2effZZfOYzn5nc1VJekmU5oeZVIoquWbX4TJZlHO2JXaYBgsvPcnkt/ECgTCM2mWpVrPOyKM09IydOnEBnZyfWrFmjvM9ms2HlypXYvn17xI9xuVxwOBwhb5RfvD4Zv9x+EjuO90W8/czAGPpG3DDqJSwInLZLRMlpDCzTGnV7caxnWNk0PDvCWK8gfls/2TeqLBbLNcGeEW1nRkTW90i3/2RyCpXWYKSzsxMAUFcXupSqrq5OuS3cpk2bYLPZlLfm5uZ0XhLlgF+8fRL3PbcfX3z8PaXTX038prCgwQqzQZuje0TZZjHqUWf1j76/cagHADCtvAjFpugJ8PJiE2ZV+4OVd070T/1FpiAfpmkAoNZqQaPNAlkG9p7J7UVz2ZD1aZqNGzfCbrcrb+3t7dm+JEqjs4Nj+JeXDwHw/8Z233P7IcuhZ2GwREOUHmIt/LbD/mCkJUa/iLBqbg0AYMv+yL8wZptdw4fkhVs2vRwAm1gjSWswUl9fDwDo6uoKeX9XV5dyWziz2Qyr1RryRvlBlmXc++w+jLq9mFdfBpNeh9c+6MaLezpC7hdv8yoRJUYcmPfOcX+WI/yAvEjWLvT/bN56sDsnd2DkwzSNoIWG4WxJazAya9Ys1NfXY+vWrcr7HA4H3nnnHbS2tqbzU5EGvLinA6990A2TXod//+vl+PuPtAAAvvPCfqU+7fH6sPcsx3qJ0kEcceAOBBWxJmmEi2ZWorLEBPuYB+/mYKlG/KzQes8IwCbWWJIORoaHh9HW1oa2tjYA/qbVtrY2nD59GpIk4c4778T3v/99PP/889i7dy9uuukmNDY24vrrr0/zpVMus4968J0X9gMA/v4jLZhTW4bbVrVgTm0peofd+MFLBwEAh7uG4PT4UGYxYHZ19EY7IopPZEaESGfShNPrJHx0vr/Pb/O+3CvV2PMoM7J4mg06CeiwO9Hl4LoLtaSDkZ07d2L58uVYvnw5AOCuu+7C8uXLcd999wEAvv71r+MrX/kKvvzlL+Oiiy7C8PAwNm/eDIvFkt4rp5z2g5cOonfYjTm1pbhtlT8jYjbo8eANiwEAv9t5Bm8f6w0uO2sqh04nRX08IopP9IwIiWRGAGDtIn8w8vKBTvh8cpx7Z44sy8o0TT4EIyVmA86vKwPAUk24pIORVatWQZblCW+PP/44AP9Wv+9+97vo7OyE0+nEq6++ivPPPz/d1005bPuxPvx2p78RedMNi0MmZC6cWYkbV04HAHzj6b1454R/3FfsOyCi1DWpgpGKYmPCB0te2lKNUrMBXQ5XTjVXjri9GA8ER1pfeiZwE2tkWZ+mofzi9HjxjWf2AgBuXDkdF82snHCfu9fNQ53VjJN9o3iu7RwANq8SpUNDuQUiwZhoVgTwjwWLqZrNOTRVI/pFTAYdLMb8eLli30hk+fHVpZzx768dxYneEdSWmXH3unkR72O1GPGdTywKed8yNq8STZpRr0ODzd83EmvzaiRiqubl/V0Txu+zZVA11itJ+VHGFVngPe32nCqJZRuDEUqbDzodeGTbMQDAd69bCKsleo336kX1uGqBv07daLOg1sqeIqJ0EE2syWRGAOAj82ph0utwoncERwIn/mabaF6tKM6PEg0AzK0rg8Wow5BrHMd7R7J9OTmDwQilhdcn457/3Ytxn4yrFtTh6kUNcT/m+9cvwqq5NfjK6vMycIVEheHzl87ExbMq8bHF8b8H1UrNBnzovGoAuTNVMyDGevOgeVUw6HVYPM2fHWETaxCDEUqLX+04hbb2QZSZDfjudYvifwD865Ef/8LF+OzF06f46ogKx7rFDfjd37UqZ9UkY+1Cf7YyV7axDubR9lU1NrFOxGCEJu3c4Bh+uPkDAMDX181DvY0lFyItWjO/DjoJ2H/Ogfb+iedIZVo+7RhRYxPrRAxGaFJkWcZ9z+3DiNuLFTMqcCOzHESaVVVqVibgciE7IqZpyvOoZwQINuwf7HDA6fFm92JyBIMRmpSX9nbi1YPdMOolPHjDYi4uI9K4qxcFp2qyTZRpbHlWpmmqKEJViQker4yDHY5sX05OYDBCKbOPenD/8/6V77etmoPzApsFiUi7rgqM+L53qh89Q66sXks+HZKnJkmSUqphE6sfgxFK2YObD6J32IWWmhJsCByCR0TaNq28CIun2SDLwKsHs5sdsSsNrPlVpgGCTazsG/FjMEIp2XG8D795V6x8XxKy8p2ItE2UarLdNzI4JnpG8iszAgDLppcDAHafsWf3QnIEgxFKmtcnKyvfP3vxdFw8a+LKdyLSLjHi+/bRPgw5PXHvL8sy/ump3bjrd21p3Sqarz0jALC0yb9r5ETviNKoW8gYjFDSPuh04HjPCErNBtwTZeU7EWnXnNoyzK4pgdvrw+uHeuLef99ZB57adQZP/+Us9pxNz2/6siznbc8I4J8QElty3zzSm+WryT4GI5S03e3+HzbLmsvz8jcWIgKuDjSybklgG+vm/R3B/0/T9lanxwf3uA9A/o32Ch8NHImRS4cTZguDEUqa6P7m4XZE+UscnPf6oe64uzC2qMaAt+zvTMtBe6JfxKiXUGLKz5408Xf8xgfx/47zHYMRSppYYbyUwQhR3lrSZEODzYJRtxdvxSgjHO0extHuYRj1UloP2gv2i5jy5sTecEum+f+OR9xe/PloYZdqGIxQUkZc4zjcNQQg2IBFRPlHkiTlN/dYUzXitktbqpWD9hIp7cQzMJq/kzSCTicpp5dne3Ip2xiMUFL2nrXDJwONNgtqrTyDhiifXRWYqnn1YBfGvb6I93k58CK6dmF98KC9A5N/YbXn6SF54UTA9+rB7qh/x4WAwQglRekXCczIE1H+unhmJSqKjRgY9eDdk/0Tbj83OIbdZ+yQJH8zpjhob9/ZyR+0l8+TNGoXz6pEebER/SNuvHdyINuXkzUMRigpSr9IYHsgEeUvg16HNfP92Y5IZ9WIrMiFMypQU2YOOWjv5QOT296q7hnJZ+q/40Iu1TAYoaS0nR4EwOZVokKh7hsJn5LZrCrRRLr/ZOTz9tVw4u/s5TRNImkRgxFKWLfDiXN2J3QSsHgam1eJCsGHzqtGsUmPDrsTe1Sry/tH3Hj3hL90ExKMBFbJv3eyH73DqR+0Vyg9IwBweeDv+Jzdib1pWhqnNQxGKGHiDIXz68pQYjZk+WqIKBMsRj0+MrcWQGi249WDXfDJwIIGK5ori5X3hxy0N4lSjSjTFEJmxGLUY9XcGgCFW6phMEIJE82r7BchKiwi26HeFCrGd8WhempXR7h/skSZxpan21fDiexSujbYag2DEUqYOOqa/SJEheUjc2tg0utwvGcER7uHMOwax5uBJV3qEo2Q7EF7kQwWUJkGAD4yrxZGvYRjPSM4moalcVrDYIQS4vPJqs2r7BchKiRlFiMunVMFwP+b+xuHuuEe92FmVTHOryudcP9kD9qLxB4Y7a0okMyI1WLEpS2BpXEFWKphMEIJOdE3giHnOCxGHebWlWX7cogow5SD8/Z3KWfRrF1UH3VVezIH7UVSSD0jgihvMRghikL0iyyeZoNBz382RIVmzQL/QrO9Z+145cDEkd5wyRy0F87p8WIs8DG2AgpG1syvgyQBe87YcW5wLNuXk1F8VaGEtLF5laigVZeacWFgoZnT40Od1YxlMX4eJHrQXiSOQIlGr5NQVkCTezVlZlw0I7A0rsCyI4XzVaZJ2c3mVaKCt3ZhvbJb5KoF9dDpop+mKw7ae/ztk3hqV3vEcsu8BitKIwQbA8r2VWPentgbzVUL6/DuyX48t/scFkXY59RSU4qKkvzro2EwQnG5xr040OEAACxjMEJUsK5aUIfvvXgAQOwSjXL/hXV4/O2TIX0magsbrfjDP1w+4f2D4sTeApmkUVu7sB7f/8NBvH96EP/nke0Tbq8pM+PPd18JkyG/ChsMRiiugx1D8HhlVJWY0FRRlO3LIaIsaa4sxt+vakH3kAuXzK6Me/+Vs6pw7dJG7IuwVfRE7wj2n3OgZ8iFmjJzyG3ikLxC6hcRmiuL8aUPzcJrH3RPuO10/yh6hlw41TeC8/JskIDBCMXVdtp/kuTS5vKCS5kSUaivXz0v4fvqdRL+7bPLI9720R9tw5HuYew5M4jVgYPihEJaBR/JvR9fgHs/vmDC+6976M/Y3T6Io93DeReM5Feeh6aEWAPP5lUiShfRfyb60dSCh+TlX2/EZLTUlABAXi5FYzBCcYkfFsuml2f1Oogof4hgpO3MxBLOoKqBlYLm1PoXzB3tYTBCBcY+6sHx3hEAwNImbl4lovQQY8G72wchy3LIbaJnpJAWniViTo0/GDnGYCS+b3/725AkKeRt3rzEa4yUW8QK+JlVxUyZElHazGsog8mgg33Mg5N9oyG3iZ6RQlkFn6iWQGbkWPcIfD45zr21ZUoyIwsXLkRHR4fy9tZbb03Fp6EM4H4RIpoKRr0OixqtACb2jQR7RpgZUZtRWQyjXsKYx4tz9vza0DolwYjBYEB9fb3yVl1dPRWfhjJAZEa4X4SI0k3pGwkPRtgzEpFBr8PMKn8T67GekSxfTXpNSTBy5MgRNDY2Yvbs2bjxxhtx+vTpqPd1uVxwOBwhb5QbZFlGW3tgkobBCBGlmfglR/zSIwQPyWOZJlxLoG8k3yZq0h6MrFy5Eo8//jg2b96Mhx9+GCdOnMDll1+OoaGhiPfftGkTbDab8tbc3JzuS6IUnR0cQ++wCwadhAUN1mxfDhHlGbEuYP85B9zjPuX99rHC3jMSizJRw2AktnXr1uFTn/oUlixZgrVr1+Kll17C4OAgfve730W8/8aNG2G325W39vb2dF8SpWh3ICsyv8EKi1Gf5ashonwzo6oY5cVGuMd9+KDTnxV3j/sw7BoHwJ6RSEQwkm8TNVM+2lteXo7zzz8fR48ejXi72WyG1WoNeaPcIFKnS5s50ktE6SdJkpIdEU2sIisiSUCZhcFIOFGmOcbMSHKGh4dx7NgxNDQ0TPWnojQTTWXLmiuyeyFElLeCTaz+TKw9MEljtRihj3EqcKFqqfU3sPaNuDEw4s7y1aRP2oORf/zHf8S2bdtw8uRJvP322/jkJz8JvV6Pz372s+n+VDSFxr0+7A1sRlzGzAgRTRHx80VkYoPNq8yKRFJsMmBauf/A0nwq1aQ9GDlz5gw++9nPYu7cufirv/orVFVVYceOHaipqUn3p6IpdKR7GGMeL0rNBsyuLs325RBRnhJlmmM9w3A4PcFghM2rUc3OwzNq0n5q75NPPpnuh6QsEPXbJU026JgqJaIpUlVqRnNlEdr7x7D3jF1ZBW/jWG9Uc2pL8eaR3rwKRng2DUXEZWdElCkiO9LWPojBUX8fRAXLNFHl40QNg5ECs/NkP57aGX98+v3TgwC47IyIpp6y/Kx9kDtGEqAsPsujYCTtZRrKXR6vD7f8cicGRj1oqihGa0tVxPuNusdxuMu/pI6ZESKaaupNrHVWCwCWaWIRmZEzA2Nwerx5sQeKmZEC8s7xfgwEmsM27+uIer99Zx3wyUC91aL8YCAimioLG23Q6yR0OVzK8jNmRqKrKjGhvNgIWQaO58kZNQxGCsiW/Z3K/798oAuyHPkI6uBJvRzpJaKpV2TSY25dGQDgL4ESMUd7o5MkKe9KNQxGCoTPJ+PlA8FgpMPuxJ7AHpFwXHZGRJkm+tO8Pv8vSQxGYpuTZwfmMRgpEG1nBtHlcKHUbMBHF9QBADarMiUh92VmhIgybHlYf5qtiD0jseTbRA2DkQIhSjQfmVeLa5c2hrxPrWfIhbODY5AkYPE0BiNElBnhk3vMjMQm1sLnyxk1DEYKgCzL2LLPH3isXViHj8ytgUmvw/GeERztHgq5r+gXmVNTykOqiChj5tSWotgUnAphA2tsc2r8PTbHe0eU0paWMRgpAIe7hnGybxQmgw6r5taizGLEZXP8Y72b94VmR4In9ZZn+CqJqJDpdVJINtbGYCSmaRVFMBt0cI/7cGZgNNuXM2kMRgqAKMdcPqcapWb/apm1C+sDt3WF3DfYvFqesesjIgKAZdPLAQBlZgMMer48xaLXSZhVnT9n1PCrXQA2KyWaeuV9axbUQScBe8/alahalmWlTMNghIgybVlgLXx5CbMiiRBNrAxGKOe194/iQIcDOskfgAjVpWZcOLMSAPByIDtyoncEDuc4TAYd5taXZeV6iahwfXhuDT58fg2+cOmsbF+KJuTTRA2DkTwnSjQXz6pEZUnoqFywVOO/j+gXWdRohZEpUiLKsGKTAb/44sX44ocYjCSCmRHSDBFoXK0q0QhrF/ozJe+d7EffsAu72/1L0LjsjIgo97WoFp9F26itFQxG8ljPkAs7Tw0AAK6KEIw0VRRj0TQrfDLw6sEuLjsjItKQWdUl0EmAwzmO3mF3ti9nUhiM5LFXDnRBloElTTY0lhdFvM/aBf4g5YXdHThwzn9AFZtXiYhyn8WoR3NlMQDtl2oYjOQxUaJZGyErIly9yH/bW0d74fb6UF5sxPTAP24iIspt+XJgHoORPOVwevD2sV4AsYORObWlmB2YVQeApU3lkCRpyq+PiIgmT5moYWaEctHrH3TD45Uxp7ZU+ccaiSRJWLsoGKywRENEpB3i9N5kxnu7Hc6pupyUGbJ9AdnWN+zC3/5yJ84OjCX8MXqdhFsun50T42f//afjePStE/CFdVIPu8YBBCdmYlm7sB4Pv3EMAIMRIiItEQfmHe4ags8nQ6eLndnuHnJizY+2YdXcWvzghsXKVu5sy42ryKLvvXgA758eTPrjfvDSQVw6pwrz6q3pv6gE7Ttrx4ObP4h6SJJBJ+H6ZdPiPs6SaTYsmmZFp92JC2ZwrJeISCvm1ltRbNKjy+HCb3e247MXT495/+88fwAO5zhO9I7AYsid4khBByPbDvfg2bZzkCTgkc+tQFNF5ImTcD9+5TBePdiNe/53L/73tkuhjxOJToVxrw8bn94Lr0/G2oV1+IfV5024T02pGbVWS9zH0ukkPPV3l8IryzkTJRMRUXylZgO+dtVcfO/FA/jBSwexel5t1J/7rx7owh/2dkCvk/Dg+sU5df5Pwb7yjLrH8c1n9gIAPn/pzJhNnuG+f/1i7Di+DW3tg/jVjlO4+dKZU3SV0T3+9knsPWuH1WLA965fhNqy+EFHLEWqo7uJiEg7Pn/pTDzXdhZ7ztjxnRcO4KEbL5hwn2HXOO59bh8A4G8vn4WFjbm1Typ3wqIM+/Erh3FmYAyNNgu+dtXcpD623mbB3Vf7P+aHmz/AucHE+03Sob1/FP/v5cMAgG98bP6kAxEiItIuvU7CgzcsgV4n4Q97O/Dqga4J9/mXLYfQYXdiemUx7lx9fhauMraCDEb2nrHj0bdOAAC+/8lFKZUmblw5AytmVGDE7cV9z+3L2CpeWZbxrWf3YczjxcpZlfj0Rc0Z+bxERJS7FjRaccvlswEA9z63D0NOj3LbX04P4BfbTwIAHvjkopzMhBdcMDLu9eGep/fAJwMfX9KAK+fFnzaJRKeT8OANi2HUS3j1YDf+uK8zzVca2fO7z2Hb4R6YDDr84IbF3AlCREQAgDtWn4fplcXosDvxL1sOAQDc4z5s/N+9kGXghgum4fLzarJ8lZEVXDDy8z+fwP5zDlgtBtx/7cJJPdZ5dWW4bdUcAMD9z++HfdQT5yMmZ2DEje++cAAA8JWPzFE27xERERWZ9PjBJxcDAH654xT+cnoA//3mcRzqGkJliQnfumZBlq8wuoIKRk73jeJHr/h7Lb55zXzUlJkn/ZgbPtKC2TUl6Bly4cHNH0z68WJ54KWD6BtxY25dGf7uwy1T+rmIiEh7PnReNdZf0ARZBr72u9346dYjAIB7Pz4flSWmLF9ddAUzTSPLMr757F44PT5cMrsSf3VhenotzAY9HrxhCf7qP7fjN++ehiQB5imY3XZ6vPj9rjOQJGDT+sUw5dB8OBER5Y5vXjMfrx/qxoneEQDAFefXJLRzKpsKJhjZsr8Lbx7phcmgw6YblqS11+LiWZX47MXT8Zt3T+OJd06n7XEjuemSGbhgOheTERFRZJUlJtz38QW487dtKDLq8cD1i3K+v7BggpHV82txz7p50EsSZqkOhkuXez8+H9MrizHsmrq+kTKLEZ/Pwk4TIiLSluuWNUKSgGnlRWjWwEnskpypmdQEORwO2Gw22O12WK3ZW7VOREREiZvM6zcbD4iIiCirGIwQERFRVjEYISIioqyasmDkoYcewsyZM2GxWLBy5Uq8++67U/WpiIiISMOmJBj57W9/i7vuugv3338//vKXv2Dp0qVYu3Yturu7p+LTERERkYZNSTDyox/9CLfccgu+8IUvYMGCBXjkkUdQXFyMn//851Px6YiIiEjD0h6MuN1u7Nq1C2vWrAl+Ep0Oa9aswfbt2yfc3+VyweFwhLwRERFR4Uh7MNLb2wuv14u6utDTcOvq6tDZOfFk202bNsFmsylvzc3pWdNORERE2pD1aZqNGzfCbrcrb+3t7dm+JCIiIsqgtK+Dr66uhl6vR1dXV8j7u7q6UF9fP+H+ZrMZZvPkT88lIiIibUp7ZsRkMmHFihXYunWr8j6fz4etW7eitbU13Z+OiIiING5KDsq76667cPPNN+PCCy/ExRdfjJ/85CcYGRnBF77whan4dERERKRhUxKMfPrTn0ZPTw/uu+8+dHZ2YtmyZdi8efOEplYiIiKinDu11263o7y8HO3t7Ty1l4iISCMcDgeam5sxODgIm82W1MdOSWZkMoaGhgCAI75EREQaNDQ0lHQwknOZEZ/Ph3PnzqGsrAySJKX0GCI6K4TsSiE9V6Cwni+fa/4qpOfL55q/wp+vLMsYGhpCY2MjdLrk5mNyLjOi0+nQ1NSUlseyWq0F8Q8CKKznChTW8+VzzV+F9Hz5XPOX+vkmmxERsr70jIiIiAobgxEiIiLKqrwMRsxmM+6///6C2OxaSM8VKKzny+eavwrp+fK55q90Pt+ca2AlIiKiwpKXmREiIiLSDgYjRERElFUMRoiIiCirGIwQERFRVuVdMPLQQw9h5syZsFgsWLlyJd59991sX1Ja/OlPf8K1116LxsZGSJKEZ599NuR2WZZx3333oaGhAUVFRVizZg2OHDmSnYudpE2bNuGiiy5CWVkZamtrcf311+PQoUMh93E6ndiwYQOqqqpQWlqK9evXo6urK0tXnLqHH34YS5YsUZYGtba24o9//KNye748z0gefPBBSJKEO++8U3lfPj3fb3/725AkKeRt3rx5yu359FwB4OzZs/jc5z6HqqoqFBUVYfHixdi5c6dyez79jJo5c+aEr60kSdiwYQOA/Praer1e3HvvvZg1axaKiorQ0tKC733ve1DPvqTlayvnkSeffFI2mUzyz3/+c3n//v3yLbfcIpeXl8tdXV3ZvrRJe+mll+RvfvOb8tNPPy0DkJ955pmQ2x988EHZZrPJzz77rLx79275E5/4hDxr1ix5bGwsOxc8CWvXrpUfe+wxed++fXJbW5v8sY99TJ4+fbo8PDys3OfWW2+Vm5ub5a1bt8o7d+6UL7nkEvnSSy/N4lWn5vnnn5f/8Ic/yIcPH5YPHTokf+Mb35CNRqO8b98+WZbz53mGe/fdd+WZM2fKS5Yske+44w7l/fn0fO+//3554cKFckdHh/LW09Oj3J5Pz7W/v1+eMWOG/PnPf15+55135OPHj8tbtmyRjx49qtwnn35GdXd3h3xdX3nlFRmA/Prrr8uynF9f2wceeECuqqqSX3zxRfnEiRPyU089JZeWlso//elPlfuk42ubV8HIxRdfLG/YsEH5s9frlRsbG+VNmzZl8arSLzwY8fl8cn19vfzP//zPyvsGBwdls9ks/+Y3v8nCFaZXd3e3DEDetm2bLMv+52Y0GuWnnnpKuc/BgwdlAPL27duzdZlpU1FRIf/sZz/L2+c5NDQkn3feefIrr7wif/jDH1aCkXx7vvfff7+8dOnSiLfl23O9++675Q996ENRb8/3n1F33HGH3NLSIvt8vrz72l5zzTXyF7/4xZD33XDDDfKNN94oy3L6vrZ5U6Zxu93YtWsX1qxZo7xPp9NhzZo12L59exavbOqdOHECnZ2dIc/dZrNh5cqVefHc7XY7AKCyshIAsGvXLng8npDnO2/ePEyfPl3Tz9fr9eLJJ5/EyMgIWltb8/Z5btiwAddcc03I8wLy8+t65MgRNDY2Yvbs2bjxxhtx+vRpAPn3XJ9//nlceOGF+NSnPoXa2losX74c//3f/63cns8/o9xuN371q1/hi1/8IiRJyruv7aWXXoqtW7fi8OHDAIDdu3fjrbfewrp16wCk72ubcwflpaq3txderxd1dXUh76+rq8MHH3yQpavKjM7OTgCI+NzFbVrl8/lw55134rLLLsOiRYsA+J+vyWRCeXl5yH21+nz37t2L1tZWOJ1OlJaW4plnnsGCBQvQ1taWV88TAJ588kn85S9/wXvvvTfhtnz7uq5cuRKPP/445s6di46ODnznO9/B5Zdfjn379uXdcz1+/Dgefvhh3HXXXfjGN76B9957D//wD/8Ak8mEm2++Oa9/Rj377LMYHBzE5z//eQD59+/4nnvugcPhwLx586DX6+H1evHAAw/gxhtvBJC+15+8CUYoP23YsAH79u3DW2+9le1LmTJz585FW1sb7HY7fv/73+Pmm2/Gtm3bsn1Zadfe3o477rgDr7zyCiwWS7YvZ8qJ3xwBYMmSJVi5ciVmzJiB3/3udygqKsrilaWfz+fDhRdeiB/84AcAgOXLl2Pfvn145JFHcPPNN2f56qbWo48+inXr1qGxsTHblzIlfve73+HXv/41nnjiCSxcuBBtbW2488470djYmNavbd6Uaaqrq6HX6yd0LHd1daG+vj5LV5UZ4vnl23O//fbb8eKLL+L1119HU1OT8v76+nq43W4MDg6G3F+rz9dkMmHOnDlYsWIFNm3ahKVLl+KnP/1p3j3PXbt2obu7GxdccAEMBgMMBgO2bduGf/3Xf4XBYEBdXV1ePd9w5eXlOP/883H06NG8+9o2NDRgwYIFIe+bP3++UpbK159Rp06dwquvvoq//du/Vd6Xb1/bf/qnf8I999yDz3zmM1i8eDH+5m/+Bl/96lexadMmAOn72uZNMGIymbBixQps3bpVeZ/P58PWrVvR2tqaxSuberNmzUJ9fX3Ic3c4HHjnnXc0+dxlWcbtt9+OZ555Bq+99hpmzZoVcvuKFStgNBpDnu+hQ4dw+vRpTT7fcD6fDy6XK++e5+rVq7F37160tbUpbxdeeCFuvPFG5f/z6fmGGx4exrFjx9DQ0JB3X9vLLrtswvj94cOHMWPGDAD59zNKeOyxx1BbW4trrrlGeV++fW1HR0eh04WGCnq9Hj6fD0Aav7ZpabfNEU8++aRsNpvlxx9/XD5w4ID85S9/WS4vL5c7OzuzfWmTNjQ0JL///vvy+++/LwOQf/SjH8nvv/++fOrUKVmW/aNV5eXl8nPPPSfv2bNHvu666zQ7NnfbbbfJNptNfuONN0LG50ZHR5X73HrrrfL06dPl1157Td65c6fc2toqt7a2ZvGqU3PPPffI27Ztk0+cOCHv2bNHvueee2RJkuSXX35ZluX8eZ7RqKdpZDm/nu/XvvY1+Y033pBPnDgh//nPf5bXrFkjV1dXy93d3bIs59dzfffdd2WDwSA/8MAD8pEjR+Rf//rXcnFxsfyrX/1KuU8+/YySZf+05vTp0+W77757wm359LW9+eab5WnTpimjvU8//bRcXV0tf/3rX1fuk46vbV4FI7Isy//2b/8mT58+XTaZTPLFF18s79ixI9uXlBavv/66DGDC28033yzLsn+86t5775Xr6upks9ksr169Wj506FB2LzpFkZ4nAPmxxx5T7jM2Nib//d//vVxRUSEXFxfLn/zkJ+WOjo7sXXSKvvjFL8ozZsyQTSaTXFNTI69evVoJRGQ5f55nNOHBSD49309/+tNyQ0ODbDKZ5GnTpsmf/vSnQ/Zu5NNzlWVZfuGFF+RFixbJZrNZnjdvnvxf//VfIbfn088oWZblLVu2yAAiPod8+to6HA75jjvukKdPny5bLBZ59uzZ8je/+U3Z5XIp90nH11aSZdUaNSIiIqIMy5ueESIiItImBiNERESUVQxGiIiIKKsYjBAREVFWMRghIiKirGIwQkRERFnFYISIiIiyisEIERERZRWDESIiIsoqBiNERESUVQxGiIiIKKsYjBAREVFW/X8UMoTlHtoCVAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "frequency_dist_ages3.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2.- Calculate the mean and standard deviation. Compare the results with the plot in step 1. What is happening?" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "41.989" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "ages_population_mean3 = ages_population3['observation'].mean()\n", + "ages_population_mean3" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "16.14470595986593" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ages_population_std3 = ages_population3['observation'].std()\n", + "ages_population_std3" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nThe mean and std are similar but they do not capture that the distribution is made of two gaussian shapes\\n'" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "The mean and std are similar but they do not capture that the distribution is made of two gaussian shapes\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3.- Calculate the four quartiles. Use the results to explain your reasoning for question in step 2. How much of a difference is there between the median and the mean?" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(30.0, 40.0, 53.0)" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# your code here\n", + "ages_quartiles = calculate_quartiles(ages_population3['observation'])\n", + "ages_quartiles" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nthere is not much difference \\n'" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "there is not much difference \n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 4.- Calculate other percentiles that might be useful to give more arguments to your reasoning." + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "22.0\n", + "32.0\n", + "45.0\n", + "67.0\n" + ] + } + ], + "source": [ + "# your code here\n", + "quantiles = [0.10, 0.30, 0.60, 0.90]\n", + "for q in quantiles:\n", + " print(ages_population3['observation'].quantile(q))" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "60.0" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ages_population3['observation'].quantile(0.82)" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "48.0" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ages_population['observation'].quantile(0.82)" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "60.0" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ages_population['observation'].quantile(0.965)" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nIn ages population3 18% of the data points have age above 60, while in the original age population only 3.5% have age above 60 (even if the two distributions have similar mean and std). \\n'" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "In ages population3 18% of the data points have age above 60, while in the original age population only 3.5% have age above 60 (even if the two distributions have similar mean and std). \n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Bonus challenge\n", + "Compare the information about the three neighbourhoods. Prepare a report about the three of them. Remember to find out which are their similarities and their differences backing your arguments in basic statistics." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "# your code here" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nyour comments here\\n'" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "your comments here\n", + "\"\"\"" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.6" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}