{ "cells": [ { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "## Importing libraries\n", "import numpy as np\n", "import pandas as pd\n", "import seaborn as sns\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Pandas\n", " \n", "## Motivating Example\n", "Today we are going to continue learning to apply python to data science by introducing another python library that is similar to `numpy` called `pandas`. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ ">Consider: based on what we've learned the past several days, what are some *limitations* of `numpy`? Can you think of any tasks you might want to do or analysis you might like to perform that would be difficult with `numpy`? Does this give you a guess as to what `pandas` specializes in?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Answer: `numpy` is specialized primarily for numerical operations, e.g. matrix multiplication, vector math, etc., but is more limited when dealing with other data types such as string, python objects, etc. In contrast, `pandas` objects are able to handle mixed data easily! As you will often run into this type of data when doing bioinformatics, `pandas` can be very useful.\n", "\n", "Before we dive into the syntax, let's take a look at an example real-world application of `pandas` for a task that you might commonly face in biology. We are going to use the \"Palmer penguins\" dataset, which is a collection of various biometric data for several different penguin species and is a commonly used example dataset. Let's take a quick look at what the data looks like.\n", "\n", "In the Palmer penguins dataset, each row represents an individual penguin, and each column represent a different measurement or characteristic of the penguin, such as its body mass or island of origin. The data are organized in this way so that variables (things we may want to compare against each other) are the columns while observations (the individual penguins) are the rows. This is a common way to organize data in data science and is called **tidy data**. Tidy data formatting also makes it easy to use code to manipulate and analyze, which we will see in this lesson. \n" ] }, { "cell_type": "code", "execution_count": 70, "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", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
speciesislandbill_length_mmbill_depth_mmflipper_length_mmbody_mass_gsexyear
0AdelieTorgersen39.118.7181.03750.0male2007
1AdelieTorgersen39.517.4186.03800.0female2007
2AdelieTorgersen40.318.0195.03250.0female2007
3AdelieTorgersenNaNNaNNaNNaNNaN2007
4AdelieTorgersen36.719.3193.03450.0female2007
\n", "
" ], "text/plain": [ " species island bill_length_mm bill_depth_mm flipper_length_mm \\\n", "0 Adelie Torgersen 39.1 18.7 181.0 \n", "1 Adelie Torgersen 39.5 17.4 186.0 \n", "2 Adelie Torgersen 40.3 18.0 195.0 \n", "3 Adelie Torgersen NaN NaN NaN \n", "4 Adelie Torgersen 36.7 19.3 193.0 \n", "\n", " body_mass_g sex year \n", "0 3750.0 male 2007 \n", "1 3800.0 female 2007 \n", "2 3250.0 female 2007 \n", "3 NaN NaN 2007 \n", "4 3450.0 female 2007 " ] }, "execution_count": 70, "metadata": {}, "output_type": "execute_result" } ], "source": [ "penguins = pd.read_csv('https://raw.githubusercontent.com/rfordatascience/tidytuesday/main/data/2020/2020-07-28/penguins.csv')\n", "penguins.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here is an example of a transformation that we will be able to do with `pandas` that would be difficult to do manually or with `numpy`. We can summarize the data by calculating the average body mass (in kg) of each penguin species, broken up by sex. Using a few lines of code we can go from our raw data to a table that looks like this:\n", "\n", "\n", "| species | sex | body_mass_kg|\n", "|-----------|--------|----------|\n", "| Adelie | female | 3.368836 |\n", "| Adelie | male | 4.043493 |\n", "| Chinstrap | female | 3.527206 |\n", "| Chinstrap | male | 3.938971 |\n", "| Gentoo | female | 4.679741 |\n", "| Gentoo | male | 5.484836 |\n", "\n", "\n", "Now, let's get started learning how this is done!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## Pandas Series\n", "A `Series` is the simplest data structure in Pandas. They are one dimensional (1D) objects composed of a **single data type** of any variety (string, integers); you can basically think of them as a single column in a spreadsheet. They are similar to arrays in `numpy`, however unlike those other 1D structures Series also have **label-based indexing**, meaning each element in the object can be accessed by specifying its specific label. In that way, they are similar to dictionaries in python. \n", "\n", "We can manually create a Series in several ways:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Using the `pd.Series()` function, we provide it the data we want to store as a list, and optionally we can give each row of the data a label using the `index` argument. If we don't give it the index argument, it will automatically assign a numerical index to each row starting from 0. \n", "\n", "When we print the Series, it will display as a column with the index on the left and the data on the right. The type of data being held in the series will be displayed at the bottom of the output. \n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Using the pd.Series method:\n", "s0 = pd.Series([10, 20, 30, 40])\n", "\n", "print(s0)\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Using the pd.Series method:\n", "s1 = pd.Series([10, 20, 30, 40], index=['a', 'b', 'c', 'd'])\n", "\n", "print(s1)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Another way to create a Series is to convert a (non-nested) dictionary into a Series. The keys of the dictionary will become the index labels while the values will become the data. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Converting from dictionary to series\n", "my_dictionary = {'first': 10, 'second': 20, 'third': 30}\n", "s2 = pd.Series(my_dictionary)\n", "\n", "print(s2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can then access specific elements in the Series by referring to its index label enclosed in quotes and brackets. This is very similar to how a dictionary works!" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(s0[0])\n", "\n", "print(s1[\"a\"])\n", "\n", "print(s2[\"second\"])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Multi-indexed Series\n", "\n", "Series objects may have multiple levels of indices. We call this **multi-indexed**. Using layers of indexing is a way of representing two-dimensional data within a one-dimensional `Series` object. Some people really like using multi-indexed Series. You can create a multi-indexed series by passing a list of lists to the `index` argument of the `pd.Series()` function. The first list will be the outermost level of the index, the second list will be the next level, and so on." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "my_index = [[\"California\", \"California\", \"New York\", \"New York\", \"Texas\", \"Texas\"], \n", " [2001, 2002, 2001, 2002, 2001, 2002]]\n", "my_values = [1.5, 1.7, 3.6, 4.2, 3.2, 4.5]\n", "\n", "s3 = pd.Series(my_values, index=my_index)\n", "\n", "print(s3)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Retrieving an item from this data structure is similar to a nested dictionary, using successive `[]` notation. Or, you can passs it a tuple. You must pass the index labels in the order they were created (left to right)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(s3[\"California\"])\n", "\n", "print(\"---\")\n", "print(s3[\"California\"][2001])\n", "\n", "print(\"---\")\n", "print(s3[(\"California\", 2001)])\n", "\n", "print(\"---\")\n", "# you can also use slicing to select multiple elements\n", "print(s3[\"California\":\"New York\"])\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In our work, we typically don't use multi-indexed Series. However, they are often the output of pandas functions, so it's good to know how to work with them. If you don't like the idea of multi-indexed Series, you can always convert them to a DataFrame using the `reset_index()` method." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s3.reset_index()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Pandas DataFrame\n", "\n", "While Series is a \"one-dimensional\" data structure, DataFrames are two-dimensional. Where Series can only contain one type of data, the pandas DataFrame can have a combination of numerical and categorical data. Additionally, DataFrames allow you do have labels for your rows and columns. \n", "\n", "DataFrames are essentially a **collection of Series objects**. You can also think of python DataFrames as spreadsheets from Excel or dataframes from R. \n", "\n", "Let's manually create a simple dataframe in pandas to showcase their behavior. In the below code, we create a dictionary where the keys are the column names and the values are lists of data. We then pass this dictionary to the `pd.DataFrame()` function to create a DataFrame. \n", "\n", "When we print the DataFrame, it will display as a table with the column names at the top and the data below. The index (in this case, automatically generated numerical index starting at 0) will be displayed on the left side of the table." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "tournamentStats = {\n", " \"wrestler\": [\"Terunofuji\", \"Ura\", \"Shodai\", \"Takanosho\"],\n", " \"wins\": [13, 6, 10, 12],\n", " \"rank\": [\"yokozuna\", \"maegashira2\", \"komusubi\", \"maegashira6\"]\n", "}\n", "\n", "#Converting to a pandas DataFrame\n", "sumo = pd.DataFrame(tournamentStats)\n", "\n", "print(sumo)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pandas dataframes have many **attributes**, including `shape`, `columns`, `index`, `dtypes`. These are useful for understanding the structure of the dataframe." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(sumo.shape)\n", "\n", "print(\"---\")\n", "print(sumo.columns)\n", "\n", "print(\"---\")\n", "print(sumo.index)\n", "\n", "print(\"---\")\n", "print(sumo.dtypes)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pandas DataFrames also have the handy `info()` function that summarizes the contents of the dataframe, including counts of the non-null values of each column and the data type of each column." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "sumo.info()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Selecting data in a Pandas dataframe\n", "\n", "As with series objects, pandas dataframes rows and columns are *explicitly indexed*, which means that every row and column has a label associated with it. You can think of the explicit indices as the being the names of the rows and the names of the columns. \n", "\n", "Unfortunately, in pandas the syntax for subsetting rows v.s. columns is different and can get a little confusing, so let's go through several different use cases." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Selecting columns\n", "We can always check the names of the columns in a Pandas dataframe byt using the built-in `.columns` method, which simply lists the column index:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "sumo.columns" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we want to refer to a specific column, we can specify its index (enclosed in double quotes) inside of square brackets `[]` like so:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Single column:\n", "sumo[\"wrestler\"]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we want to refer to *multiple* columns, we need to pass the columns as a **list** by enclosing the column indices in square brackets, so you will end up with *double brackets*:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Multiple columns (note the double []!):\n", "sumo[[\"wrestler\", \"rank\"]]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Selecting rows:\n", "\n", "The syntax for selecting specific rows is slightly different. Let's first check the labels of the row index; to do this we use the `.index` method:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(sumo.index)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we can see that while the column index labels were strings, the row index labels are *numerical values*, in this case `0` thru `3`. If we wanted to pull out the first row, we need to specify its index label (`0`) in combination with the `.loc` method (which is required for rows): " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "sumo.loc[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we want to select multiple rows, like with columns we need to pass it as a list using the double brackets. If we want to specify a **range** of rows (i.e. from this row to that row), we **don't** use double brackets and instead use `:`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(sumo.loc[[0,1]])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "print(sumo.loc[0:2])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that in this case the row index labels are numbers, but do not have to be numerical, and can have string labels similar to columns. Let's show how we could change the row index labels by taking the column with the wrestler's rank and setting it as the index label (note that the labels should be unique!):" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "sumo = sumo.set_index(\"rank\")\n", "\n", "print(sumo)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "sumo.loc[\"yokozuna\"]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We also need to use `.loc` if we are referring to a specific row AND column, e.g.:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(sumo.loc[\"komusubi\", \"wrestler\"])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we want to purely use numerical indexing, we can use the `.iloc()` method. If you use `.iloc()`, you can index a DataFrame just as you would a numpy array. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Select the first two rows and the first two columns\n", "\n", "sumo.iloc[0:2, 0:2]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are many ways to select subsets of a dataframe. The rows and columns of a dataframe can be referred to either by their integer position or by their indexed name. Typically, for columns, you'll use the indexed name and can just do `[]` with the name of the column. For rows, if you want to use the integer position, you will use `.iloc[]`. If you want to use the index name, you will use `.loc[]`. \n", "\n", "For reference, here's a handy table on the best ways to index into a dataframe:\n", "\n", "|Action|Named index|Integer Position|\n", "|---|---|---|\n", "|Select single column|`df['column_name']`|`df.iloc[:, column_position]`|\n", "|Select multiple columns|`df[['column_name1', 'column_name2']]`|`df.iloc[:, [column_position1, column_position2]]`|\n", "|Select single row|`df.loc['row_name']`|`df.iloc[row_position]`|\n", "|Select multiple rows|`df.loc[['row_name1', 'row_name2']]`|`df.iloc[[row_position1, row_position2]]`|" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> Exercise: we'll use the penguins dataset from our initial example.\n", "> 1) Print the 'species' column\n", "> 2) Print the first five columns and first five rows\n", "> 3) Print the columns \"species\", \"island\", and \"sex\" and the first ten rows of the dataframe" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "penguins.info()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Your code here\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Importing data to pandas\n", "One of the most useful features of pandas DataFrames is its ability to easily perform complex data transformations. This makes it a powerful tool for cleaning, filtering, and summarizing tabular data. As shown above, we can manually create a DataFrame from scratch, but more commonly you will want to read in data from an external source, such as the output of a bioinformatic program, and do some manipulation of it. Let's read some data into a DataFrame to demonstrate. \n", "\n", "Below you can see an example of how to read files into pandas using the `pd.read_csv()` function. The `csv` stands for 'comma-separated values', which means by defaults it will assume that our columns are separated by **commas**; if we wanted to change the delimiter (e.g. in the case of a tab-separated file), we can set the delimiter explicitly using the `sep=` argument. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "penguins = pd.read_csv(\"https://raw.githubusercontent.com/rfordatascience/tidytuesday/main/data/2020/2020-07-28/penguins.csv\", sep=',')\n", "\n", "# The head() function from pandas prints only the first N lines of a dataframe (default: 10)\n", "penguins.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When importing data into a DataFrame, pandas automatically detects what data type each column should be. For example, if the column contains only numbers, it will be imported as an floating point or integer data type. If the column contains strings or a mixture of strings and numbers, it will be imported as an \"object\" data type. Below are the different data types for the penguins column. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "penguins.info()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Looping through a dataframe\n", "As a note, if we want to go through a dataframe line-by-line (i.e. row by row), because both the rows and columns are indexed it requires slightly more syntax than looping through other data structures (e.g. a dictionary or list). Specifically we need to use the `.iterrows()` method to make the data frame iterable. The `.iterrows()` method outputs each row as a `Series` object with a row index and the column: " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for index, row in penguins.iterrows():\n", " print(f\"Row index: {index}, {row['species']}, {row['island']}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This can be slow for very large dataframes, but is useful if you need to perform actions on individual rows." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Modifying a dataframe\n", "Now that we have our external data read into a DataFrame, we can begin to work our magic. If you have ever worked with `tidyverse` in the R language some of this might look familiar to you, as `pandas` serves a similar role and can do many of the same functions. Let's look at several useful common examples.\n", "\n", "### Filtering\n", "When we discussed indexing, we looked at how we can select specific rows and columns in a dataframe, but often we will want to select rows based on a certain condition, e.g. in the dataframe that we just imported, only take the rows where the 'body_mass_g' column has a value greater than a given number. We can do this easily by specifying which column to filter on and a boolean statement, like so:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(penguins[penguins['flipper_length_mm'] == 181.0])\n", "\n", "#Saving as new data frame:\n", "penguins_filtered = penguins[penguins['body_mass_g'] > 3300]\n", "\n", "penguins_filtered.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can get more advanced with our filtering logic by adding multiple conditions and the following logical operators:\n", "\n", "- `&`: \"and\"\n", "- `|`: \"or\"\n", "- `~`: \"not\"\n", "\n", "**Note that these are different logical operators than we have previously learned in base python!**\n", "\n", "If using multiple conditions, be sure to enclose each of them in parentheses!" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "penguins_filtered = penguins[(penguins['body_mass_g'] > 3300) & (penguins['bill_length_mm'] > 38)]\n", "\n", "penguins_filtered.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pandas also has a helper function called `.isin()` that is similar to the `in` operator in base python. It allows you to filter a dataframe based on whether a column value is in a list of values." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "penguins[penguins['species'].isin(['Adelie', 'Gentoo'])]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> Exercise: filter the dataframe to only keep the birds observed in the `year` 2007 and with a `bill_length_mm` greater than 38mm" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Your code here\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also filter based on strings, not just numbers! For this, you will want to use a string matching function from python, such as `.str.contains()` (which also a partial match), `.str.startswith()` (checks to see if a value starts with a given string), or others." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "penguins_filtered = penguins[penguins['species'].str.contains('Adel', case=False)]\n", "\n", "penguins_filtered" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the above example, this code looks for the string 'Adel' (case-insensitive, as we specify `case=False`) and only takes rows that contain the string somewhere in the `species` column." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Missing data in DataFrames\n", "\n", "Missing data in a DataFrame is represeted by `NaN` (Not a Number). Pandas handles missing data in some specific ways, which we will discuss in this section. \n", "\n", "Missing numbers are propagated through the DataFrame when doing arithmetic operations. In the example below, when we try to sum the two columns together element-wise, any row where one of the columns has a missing value will result in the sum being `NaN`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "ser1 = pd.Series([np.nan, np.nan, 2, 3])\n", "ser2 = pd.Series([1, 2, np.nan, 4])\n", "ser1 + ser2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When using descriptive statistics and computational methods like `.sum()`, `.mean()`, pandas will ignore missing values and treat them like zero. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(ser1.sum())\n", "\n", "print(ser1.mean())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This behavior can be changed by using the `skipna` argument, which is `True` by default. If you set `skipna=False`, pandas will treat missing values as `NaN` and will not ignore them, resulting in the whole operation returning `NaN`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(ser1.mean(skipna=False))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "One very useful function to know is how to get rid of rows with missing data in them, as including them can often cause errors in downstream analysis or skew your results. There is a convenient function built in to `pandas` that does this called `.dropna()`. By default, it will drop any row that has a missing value in any column. This may not always be what you want. You can specify which columns to look at using the `subset` arugment. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "penguins_nona = penguins.dropna()\n", "\n", "penguins_nona.info()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "penguins_nona_bill_len = penguins.dropna(subset=[\"bill_length_mm\"])\n", "\n", "penguins_nona_bill_len.info()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Alternatively, you may want to fill in missing values with a specific value. You can do this using the `.fillna()` method." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Calculating new columns\n", "\n", "Let's say we will want to create a new column in our dataframe by applying some function to existing columns. For instance, in the dataframe of penguins data that we have been using, we want a column that normalizes `body_mass_g` column by performing a z-transform. A z-transform is the value minus the mean of the column divided by the standard deviation of the column. \n", "\n", "First, we put the name of the new column, `body_mass_z` in square brackets after our `penguin` DataFrame variable. Then we pull out the `body_mass_g` column and perform the calculation, using helper methods like `.mean()` and `.std()`, on the right side of the assignment operator. This syntax is similar to creating a new key in a dictionary." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Z-transform the body mass column\n", "\n", "penguins[\"body_mass_z\"] = (penguins[\"body_mass_g\"] - penguins[\"body_mass_g\"].mean()) / penguins[\"body_mass_g\"].std()\n", "\n", "penguins.head(10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ ">**Exercise:** We can use multiple columns in the calculation of the new column. Create a column that contains the volume of the penguin's beak by assuming it is a cylinder, with `bill_length_mm` as the height and `bill_depth_mm` as the diameter. \n", ">\n", "> **Hint:** The volume of a cylinder is given by the formula $V = \\pi r^2 h$, where $r$ is the radius (half the diameter) and $h$ is the height. Remember also that numpy has a built-in function for pi, if you need it!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![](https://allisonhorst.github.io/palmerpenguins/reference/figures/culmen_depth.png)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Your code here\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Summarizing your data\n", "\n", "Another common task in data analysis is to calculate summary statistics of your data. Pandas as a number of helper methods like `.mean()`, `.median()`, `.count()`, `unique()`, etc. that can be used to describe your data. Pandas DataFrames has a handy `.describe()` method that will give you a summary of the data in each column. By default, it will calculate the count, mean, standard deviation, minimum, 25th percentile, median, 75th percentile, and maximum of each numerical column. However, if you give it the `include='all'` or `include='object'` argument, it will also include the count, unique, top, and freq (of top) of each categorical column." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "penguins.describe(include='all')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "penguins.describe(include='object')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Grouping and transforming your data\n", "\n", "What if we want to use one of the categorical variables in our data as a factor level to calculate our summaries? For example, we may want to separately get the mean flipper length of each `species` of penguin. In order to do this, we need to do the following things:\n", "\n", "1. Split our data into different **groups** (e.g. based the values in the `species` column)\n", "2. Apply some function (**aggregation** or **transformation**)to each group in our data (e.g. calculates the mean) \n", "3. Combine each group back together into an output object\n", "\n", "We input the column we want to group by into the `.groupby()` method. This creates a **grouped dataframe** object that acts like the regular dataframe, but is split into groups based on the column we specified." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "penguin_groups = penguins.groupby('species')\n", "print(penguin_groups)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see that on its own this is not especially useful, as grouping the DataFrame does not produce a new DataFrame (just this weird output message telling us that this is a `DataFrameGroupBy` object). In order to output a DataFrame, we need to pass the grouped DataFrame to some function that aggregates or transforms the data in each group.\n", "\n", "We group our data, select the column we want to aggregate (in this case, `flipper_length_mm`) and apply the `.mean()` function to it:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Note the square brackets around the column name\n", "penguins.groupby('species')['flipper_length_mm'].mean()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When we apply the `.mean()` method to the grouped dataframe, it returns a `Series` object with the mean flipper length of each species. The exact details of whether pandas returns a `groupby` object as a Series or a DataFrame gets a little technical; for our purposes, just know that you can make sure the returned object is converted to a DataFrame (which is usually most convenient) by using the `.reset_index` function:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "penguins.groupby('species')['flipper_length_mm'].mean().reset_index()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can group by multiple columns by passing a *list of column names* to the `.groupby()` method (and using `reset_index()` as before to have it output as a DataFrame): " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "penguins.groupby(['species', 'sex'])['flipper_length_mm'].mean().reset_index()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "So far we have just been applying the `.mean` function to our groups, but we can use other functions as well! One very useful function to know when grouping is `.size()`, which will return the number of rows in each group." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "penguins.groupby(['species', 'sex']).size()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ ">**Exercise:** Use grouping to answer the following question about the penguins dataset: Which island has the most Adelie penguins?\n", ">\n", "> **Hint:** Think about which order you should group by for the most readable output" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Your code here\n", "\n", "penguins.groupby(['species', 'island']).size()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> Now try your previous code with the order of the columns to group by switched. What changes?" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "penguins.groupby(['island', 'species']).size()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This shows us that grouping occurs **hierarchically**, meaning pandas groups data in the order that you specify in! In our case the result is the same (i.e. the counts are equal no matter which column you group on first), but one way is more readily readable for our question than the other. \n", "\n", "\n", "There are niche situations where it might matter, e.g. your aggregation function depends on the order of values (e.g. if you are sorting your grouped data), or you are doing some non-commutative operation, but generally speaking the results will be the same. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> Exercise: now that we have an understanding of pandas, let's go back to our initial example! Calculating the average body mass (in **kg**) of each penguin species, by sex. We are aiming to reproduce the table below:\n", ">\n", "> Make sure you end up with a DataFrame and not a Series. \n", "\n", "\n", "| species | sex | body_mass_kg|\n", "|-----------|--------|----------|\n", "| Adelie | female | 3.368836 |\n", "| Adelie | male | 4.043493 |\n", "| Chinstrap | female | 3.527206 |\n", "| Chinstrap | male | 3.938971 |\n", "| Gentoo | female | 4.679741 |\n", "| Gentoo | male | 5.484836 |\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Your code here\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Exercise**: using the `.max()` function, find the largest bird on each island." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Your code here\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Seaborn\n", "## Plotting with Seaborn\n", "In addition to knowing how to import and manipulate data, we often want to also *visualize* our data. There are many tools available that are specialized in plotting data, such a R and ggplot, Excel, etc., but often it can be helpful to do some quick visualization in python as part of a pipeline. The \"classic\" way to do this is using the `matplotlib` library, but for this workshop we are instead going to use `seaborn`, which is based on `matplotlib` but has (in our opinion) better syntax (being somewhat reminiscent of `ggplot`, a commonly-used R library), and is specially designed to integrate with `pandas`. \n", "\n", " Plotting can get quite complicated, so we are going to stick to some more \"cookie-cutter\" implementation that is geared more towards exploratory analysis, rather than making publication-quality figures." ] }, { "attachments": { "image.png": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnkAAAHJCAYAAAD5Ky9JAAAEDmlDQ1BrQ0dDb2xvclNwYWNlR2VuZXJpY1JHQgAAOI2NVV1oHFUUPpu5syskzoPUpqaSDv41lLRsUtGE2uj+ZbNt3CyTbLRBkMns3Z1pJjPj/KRpKT4UQRDBqOCT4P9bwSchaqvtiy2itFCiBIMo+ND6R6HSFwnruTOzu5O4a73L3PnmnO9+595z7t4LkLgsW5beJQIsGq4t5dPis8fmxMQ6dMF90A190C0rjpUqlSYBG+PCv9rt7yDG3tf2t/f/Z+uuUEcBiN2F2Kw4yiLiZQD+FcWyXYAEQfvICddi+AnEO2ycIOISw7UAVxieD/Cyz5mRMohfRSwoqoz+xNuIB+cj9loEB3Pw2448NaitKSLLRck2q5pOI9O9g/t/tkXda8Tbg0+PszB9FN8DuPaXKnKW4YcQn1Xk3HSIry5ps8UQ/2W5aQnxIwBdu7yFcgrxPsRjVXu8HOh0qao30cArp9SZZxDfg3h1wTzKxu5E/LUxX5wKdX5SnAzmDx4A4OIqLbB69yMesE1pKojLjVdoNsfyiPi45hZmAn3uLWdpOtfQOaVmikEs7ovj8hFWpz7EV6mel0L9Xy23FMYlPYZenAx0yDB1/PX6dledmQjikjkXCxqMJS9WtfFCyH9XtSekEF+2dH+P4tzITduTygGfv58a5VCTH5PtXD7EFZiNyUDBhHnsFTBgE0SQIA9pfFtgo6cKGuhooeilaKH41eDs38Ip+f4At1Rq/sjr6NEwQqb/I/DQqsLvaFUjvAx+eWirddAJZnAj1DFJL0mSg/gcIpPkMBkhoyCSJ8lTZIxk0TpKDjXHliJzZPO50dR5ASNSnzeLvIvod0HG/mdkmOC0z8VKnzcQ2M/Yz2vKldduXjp9bleLu0ZWn7vWc+l0JGcaai10yNrUnXLP/8Jf59ewX+c3Wgz+B34Df+vbVrc16zTMVgp9um9bxEfzPU5kPqUtVWxhs6OiWTVW+gIfywB9uXi7CGcGW/zk98k/kmvJ95IfJn/j3uQ+4c5zn3Kfcd+AyF3gLnJfcl9xH3OfR2rUee80a+6vo7EK5mmXUdyfQlrYLTwoZIU9wsPCZEtP6BWGhAlhL3p2N6sTjRdduwbHsG9kq32sgBepc+xurLPW4T9URpYGJ3ym4+8zA05u44QjST8ZIoVtu3qE7fWmdn5LPdqvgcZz8Ww8BWJ8X3w0PhQ/wnCDGd+LvlHs8dRy6bLLDuKMaZ20tZrqisPJ5ONiCq8yKhYM5cCgKOu66Lsc0aYOtZdo5QCwezI4wm9J/v0X23mlZXOfBjj8Jzv3WrY5D+CsA9D7aMs2gGfjve8ArD6mePZSeCfEYt8CONWDw8FXTxrPqx/r9Vt4biXeANh8vV7/+/16ffMD1N8AuKD/A/8leAvFY9bLAAAAOGVYSWZNTQAqAAAACAABh2kABAAAAAEAAAAaAAAAAAACoAIABAAAAAEAAAJ5oAMABAAAAAEAAAHJAAAAAE+jJRUAAEAASURBVHgB7F0HfFPVF/7o3i1QoJRV9ix7i7L3EgVF3Ip7gYoKCi4QFdcfFQVRVJagDFFA9t57Fyi7g1K69+R/zg0vpGnSJm0pbXoOv0de7nr3fu+l+XLuGeVukEBEEBAEBAFBQBAQBAQBQcCmELCzqdXIYgQBQUAQEAQEAUFAEBAEFAJC8uRBEAQEAUFAEBAEBAFBwAYREJJngzdVliQICAKCgCAgCAgCgoCQPHkGBAFBQBAQBAQBQUAQsEEEhOTZ4E2VJQkCgoAgIAgIAoKAICAkT54BQUAQEAQEAUFAEBAEbBABIXk2eFNlSYKAICAICAKCgCAgCAjJk2dAEBAEBAFBQBAQBAQBG0RASJ4N3lRZkiAgCAgCgoAgIAgIAkLy5BkQBAQBQUAQEAQEAUHABhEQkmeDN1WWJAgIAoKAICAICAKCgJA8eQYEAUFAEBAEBAFBQBCwQQSE5NngTZUlCQKCgCAgCAgCgoAgICRPngFBQBAQBAQBQUAQEARsEAEheTZ4U2VJgoAgIAgIAoKAICAICMmTZ0AQEAQEAUFAEBAEBAEbREBIng3eVFmSICAICAKCgCAgCAgCQvLkGRAEBAFBQBAQBAQBQcAGERCSZ4M3VZYkCAgCgoAgIAgIAoKAkDx5BgQBQUAQEAQEAUFAELBBBITk2eBNlSUJAoKAICAICAKCgCAgJE+eAUFAEBAEBAFBQBAQBGwQASF5NnhTZUmCgCAgCAgCgoAgIAgIyZNnQBAQBAQBQUAQEAQEARtEQEieDd5UWZIgIAgIAoKAICAICAJC8uQZEAQEAUFAEBAEBAFBwAYREJJngzdVliQICAKCgCAgCAgCgoCQPHkGBAFBQBAQBAQBQUAQsEEEhOTZ4E2VJQkCgoAgIAgIAoKAICAkT54BQUAQEAQEAUFAEBAEbBABIXk2eFNlSYKAICAICAKCgCAgCAjJk2dAEBAEBAFBQBAQBAQBG0RASJ4N3lRZkiAgCAgCgoAgIAgIAkLy5BkQBAQBQUAQEAQEAUHABhEQkmeDN1WWJAgIAoKAICAICAKCgJA8eQYEAUFAEBAEBAFBQBCwQQSE5NngTZUlCQKCgCAgCAgCgoAgICRPngFBQBAQBAQBQUAQEARsEAEheTZ4U2VJgoAgIAgIAoKAICAICMmTZ0AQEAQEAUFAEBAEBAEbREBIng3eVFmSICAICAKCgCAgCAgCQvLkGRAEBAFBQBAQBAQBQcAGERCSZ4M3VZYkCAgCgoAgIAgIAoKAkDx5BgQBQUAQEAQEAUFAELBBBITk2eBNlSUJAoKAICAICAKCgCAgJE+eAUFAEBAEBAFBQBAQBGwQAYeStqbklHSERyQi9Go8wiIS9Efo1QREx6YgPSML6el08CsdImUHAQd7Ozg52cPJUXe4uTrCv4qnOqr56V79b75WLO+GcuXKlQlwsrMykRZ9DalR4Ui9flW9ptF5yvVwVZ6dnorszAxkZ6TTazqQnV0mcJFFEgJ2drBzcIKdo+PNV2c4la8EV19/uFT0g4tvVf2rc4Uq1MaxTMB248YNxCbH4mp8hDrC47TXq7hK50lpSUjPykAGHen0mcnMlu+aMvFg3FykE30OHO0d4WTvBD73dvVGVe8q8PO6eXj70Xs/9d7d2a1EQ1OOHvYbd2qGMUTaduy/jG17L2PrnksICr6O2PhUNR17+3Ko7OuBKpXcUbmiB527w9vLRX3BOzrawdHBng5SRJaN7/E7dYtKznXpKc3KvoEMIvaZmdn0hzcLySkZiIxKwrVIOq4nIuJ6EhKTiMSQMBGs4e+FTm1q4J4OtXB3+5poWNe31BM/JmuxZw4h+uguRB3dQeeHkRZzTU/cHL3Kw6V8ZTj7+MKZvsydvCrA3skZ5egPFX+Bl7N3QDn64hcpGwjcIEJ/g34E8KGIfnoa0uKjkRZ7nZ6bSHWkx0XpwKAfRfzceNVrjorN76KjM3watabnx6VUg8VfcRejLmHX+b3YTceei/txJfoK0vgHD4mrowsqe1aGr2dF+Hr4qld3Jzc40Je8I31e+Mverpxdqf/bUapvYjFOnp+XzOxMZNJnhg8m+wmpCbiecB2RiVG4nkivCZH0AyBTzcrT2QN1K9dBpzrt0bE2HfTq61GxGGec96WKleQxqVuzJVhP6k6cuQbWxrQO9Eeb5v5o3KASqtwkdhV83OhHqDC4vG+f1BojwCSPiV9EZCIuhcTiwLEwHDgShsuhcfCt4IYu7Woq0tezS200b+xn3L3Evb+RlYXrR7Yjig8idTGn9iuNnFethvBp0BI+9QN12pibxM7O0anErUEmVLIRYPKnkb7UqAjEnTuGmNOHEX/hFP0gsIdPw1Y60teiM3xbdysV2r4zEcHYfGYbEbs9ROz24VrCNfiRJqZljRZoUSMQNSvUIGJXiQidL5jQlRWtf8l+EkvP7LJvZCMuOY5IHxO+6zhLz9uRkGM4cuUoEcJE1KtcV5G+TnU6oEfDrqhEz9mdkmIheceDIjB9zh7MX3YMri4OaNuiGtq08Ec7em1UrxIcWCMnIgjcRgSuEuk7cCQU+4nwHTgailNnr6Nj6+p47akOuH9AEziS5q8kSXpCDC6vmosLy2ap7VefeoEoT1+2Po1aoXz9FnBw8yhJ05W52CACmakpiAs+ipigQ0T6DiH27FE4evogYMjTqDXoSbhUqFyiVp1FW6r/nViHWdvmYHvwTtTxrU2Erjla1myOVkTuqvqU/B91JQpQmYzVCDD5O3ftPA5dOYLDl4/iML0yGby31RA8e/eT6jm0etBCdrhtJC8rKxv/rDutyN2mnRfRuV0NPDa8Jbp1rg17sq0SEQTuJAKs5Zu35AiWrDwBdzcnvPhoOzz7cBsyD7iz5Cn+wkmcX/ojQtb9AWeviqjZ5wFU63ovHD287iRccm1BAJkpSQjbvhKX1/yBlGuh8O9xH+rc9zxp+lrfUXTYtm7enj8we/tvaittQGA/jGh3H+pWqnNH5yUXFwSY9O09vx+L9y9RPzza1GyF5+55CoObD1BmAMWB0G0heSvWBuHV91crG6l7+zVW5K5+nZKzR10cwMo1SgcCvL3793+nMPevw7gSFo/Ro1rj8wm9FfErzhUkX72EI1+NQeS+DajQrANq9XkQlVrfo7bLinMeci1BID8E2M4v6vgeRfYiD29DhaYd0OLNb+FJJgTFKewQ8el/X2Lmtl9Qwb0CRrQdhiEtBsLLVX4QFed9kGtZhsCV6BD8uX8p/jmySpkIfDD4XTzQ9j7LOheiVZGSPPaMff2jNZi98CCeI83IUyNbK2eJQsxPugoCxYJANjl1bN97CR9+uQkuzg744/vhaNWsarFcO2T9Yhz9eiy86zZDw0deh2eNesVyXbmIIFBYBJKuXsaZP6aT3egONHtxKmoNfqpY7NvY5u65ea8oz9g3+ryGrg3vhj3ZD4oIAiUdgaS0ZPx1YClmbvkZQ0ij98XwT27rD5MiI3mHT4TjoZeXIIk8Hr+c1BetyJlCRBAobQiwZu/jrzcpU4NP3uqJ15/tRA5At8e8ICMpHke/eR3hm5ej/shXUKvfKPF8LW0PjMwX7I0YSs9w0O/T4NumO1q+9T2cvW/Pzg1f6/fdCzBh+Qdk2N4BEwa+BR83b7kLgkCpQ4CdNd5b/iEyyPFp5iPT0aF2u9uyhiIhed/9ugdvfLQWA3o2wKQ3usHT3fm2TFYGFQSKC4GV609j0ucbyUnIH4tmDCfPXPcivTSHPtn//qMU0sQezV+iX3IBxbvVVaSLkcEEAUIgKfwSjn4/QXnqtpn4K3xbdilSXBIpdt2L81/DxtNbMLb3q2TMPrhYtIZFuggZTBAwQCA1Iw3TN3yPpQf/xlt9xuCN3q8V+TNdaJL36+JDePbtfzD13T4Y2reRwfTlVBAo3QiEUUDulyb8C29PZ2xY+DicaRu3KITt77Y+3w2+zTuhyVMTYO/sWhTDyhiCwB1HgMOxnJ7/NcK2/oMu36+HV+0mRTIn9px99JfRCIo4gy8e+BQBFWsWybgyiCBQEhDYdnYH3l36Psb3fxMvdXuuSKdUKJK3jQIY93zoN3zwRg88MKRZkU5MBhMESgICHHNv+Og/0OvuOvj1q3sL/SuLt2i3v9xLBZ1t/eY34lhREm6yzKFIEeAt1WMz3kNs8DHc88NmFZS7sBeYtGIy5u/9A3OemIXqFaoVdjjpLwiUOAQ2Bm3BhKWT8PuTP6Ff095FNr8CGxudvxSNYc/8gUcpLIoQvCK7HzJQCUOgUkV3/Pj5EPy18iQ+/2FHoWbHgY0PfPwkbmRmosXLU4XgFQpN6VxSEeDAwk2fmUQhgCpg78SHkEVp9Qoj83b/QbHvfsZn908RglcYIKVviUagR6OueK7raDw792WcCDtVZHMtEMmLo9Rjg55cgBZN/PDWi0Vrd1FkK5OBBIEiQqBx/Ur46oN+ePfzDVi2uuAfvuM/vKsyVrQiDZ4EMy6imyPDlEgEOJVey9e/RErEFRye9rJyzijIRHcE78KbS8bjnf7j0LpWy4IMIX0EgVKDwBOdH0E3InsPzX4CEfGUrrIIpEAk77MZ25GWloUvP+gvgY2L4CbIECUfgZ5318UrT3XE82Sjl5qaYfWE2dHiwtIf0GrMF3CrLNtNVgMoHUodAuxh2/rN/yFs8zJEHthk9fzZDm/s4rdxX2uKf9dyoNX9pYMgUNoQYC34hAHj4E0e41P/+6JIpm81yYtPSMWM3/fhxSfaw8Nd8mQWyV2QQUoFAk+PagPO5PLbX0esnm/wH9+gUqt7UJ4SvosIAmUFAc+a9eHfZSCCF3xt9ZJXHluDsLhwjL77Cav7SgdBoLQi4OTgRNu2T2PRvr9UHMjCrsNqkjdz/gFF7gb0alDYa0t/QaBUIcBBkh8b0UrZ5jHZs1SSQs8jbMty1B7yhKVdpJ0gYDMIBAx8DNcPb0Xs6YMWr4mdN/638XsMpTApEgfPYtikoY0gwDEgA3wD8CMFTC6sWEXy0tIy8dVPu/DUQ23g6CDRxQsLvvQvfQg8fF9zSteXiCWrTlo8+eBF0+FTvwXKNxCbIotBk4Y2g4BHtdqo3LY7zlqhzdsWvBPHQ0/i4Q4P2gwOshBBwFIEeNv2sU6j8OvOuYhPibe0m8l2VpG8uUuPIC09C8MHNTU5mBQKAraOgLeXCx4cGoip32+3yJg8NToCV/6bj9qDn7B1aGR9goBZBPj5D9+2AolXzpptY1jxDQWI7dusN/y8/QyL5VwQKDMI9GzSXaU7+4WIXmHEKpK38O/juH9gE7i5OhbmmtJXECjVCDxyfwscPnEVZy9E5buOq9tXUpwwX1Qq4uj/+V5YGggCJQgBn3qB8KrTRJkt5DetmKQYbDmzDSOKIXl7fnORekHgTiHgYOdATkdDVTaMwszBYpLHNhKHjocXW9L2wixK+goCtxOB6lW9UKmiGw4cDc/3MrFnDsG7bqDkpM0XKWlg6wgw0Ys9fSjfZR4OOQY2Pm9YpX6+baWBIGDLCARWb4bTEWeRmlHwWJMWk7wLl2MQE5eKZg0r2zKmsjZBIF8E2F6iWaMqOHAsLN+2cfSl5l2ncb7tpIEgYOsIeNVujDgKJZSfHCGSxwTPwb5o0gjmdz2pFwRKKgIN/eoj60ZWoYIjW0zyDhwLRwUfV1St4llS8ZB5CQLFhkBT+rGz/2jeJC8rPQ3xF08VWf7OYlucXEgQuA0IcB7blGshSIu9nufoh68cRUM/id6QJ0hSWSYQcHNyQ+2KAeAfPgUVi0kef6E1a1S50Lk7CzpR6ScIlCQEWKN96PhVZGebD6WScOEEpTDLgGdAw5I0dZmLIHBHEHD3D4Cdkwtp8/Lesj0SchSNq8pn5o7cJLloiUOgYdUG4B8+BRWrSF7ThlUKeh3pJwjYFAJNabs2PjEN5y7FmF1X7OnDcKtaC45uov02C5JUlBkE7Gj71SugETj7izlhp4vL0SFoJCTPHERSXsYQaOTXsHhIXkh4PGr4e5UxeGW5goBpBKr4usPZyR78uTAnqddD4SopzMzBI+VlEAH+PKREmjdzCI+7qlCp5iOp/8rg4yFLNoFA9fL+KvOLiSqLiizW5CUmpcPdzcmiQaWRIGDrCLDzhRt9HvhzYU4yU5Lg4OJurlrKBYEyh4CDsysykxPNrjspPVnVudK2roggIAgAbJeXfPNzURA8LCZ5ScnpEh+vIAhLH5tFwM3FIU+Sl5WSDHtn+bKy2QdAFmY1AvYurshKTTLbLzEtCa6OLrArZ/FXk9mxpEIQsAUE+POQlpmOzKzMAi3H4k8SZ7pwou0pEUFAENAh4Ey5bFMp1Z85ycpIgx3F+xIRBAQBHQJ2js7ITjcf8yudvswc5TMjj4sgoEeAY0aypGam6cusObGY5PGg5eifiCAgCOgQsOjTYFEjQVQQEAQ0BOR7RkNCXgUB4l1kGlQYsYrkFeZC0lcQEAQEAUFAEBAEBAFBoPgQEJJXfFjLlQQBQUAQEAQEAUFAECg2BITkFRvUciFBQBAQBAQBQUAQEASKDwEhecWHtVxJEBAEBAFBQBAQBASBYkNASF6xQS0XEgQEAUFAEBAEBAFBoPgQEJJXfFjLlQQBQUAQEAQEAUFAECg2BITkFRvU5i+05+AV1O/8jTrOnLtuvqEVNSHhcfoxN+44b0XP/Jteu56EeUuO5N9QWggCZhAI3bICa0a1UofWJPrkfn1ZwpVgrfiOvO79eLSay+Fv3izS69/IzsLldYuRFhdVpOPKYIKAtQikUdy12dt+tbZbnu3/ObIK7SZ3UUdhsjSYusjJsCBsCtpiqkrK8kBASF4e4EhVbgT+XhOEPiN/w+qNZ3JXSokgIAiYRSAl6ip2TngIp+ZMpYDABQtsanZwqRAErEDg9NWzeODHRzBzy2wret25pl+u/R+enPMszkbc2R9/dw6Bgl/ZoeBdpWdZRGDHvkvgFHcigkBRI2BH+UrdqwaoYe0cHIt6+Ds+XkpECBIvn73j85AJCAJnIs4iLDa81ACx5fQ2ZN/ILjXzLUkTFZJXku6GzEUQKMMI+NRrhi5fLivDCMjSBQFBQBAoWgRku7Zo8ZTRBAFBQBAQBAQBQUAQKBEIiCbPwtvAzhGPvLwEnh5O2LZ8NKb8bwvZpZ3FjRs3ULOaD6ZN6ouGdX3V+/82BWPJyhM4HnQN8Qmp1McZgY2rYFj/xujfowHs7CzLRcfOE93vn6NmuPOfZ3ApJBbfz9mDY6cikJnF1/XG4D4N8dC9zeHhrktibOFyVLNtuy9i0YrjOHw8HNGxKXB3c0L9OhUxsGcDDB/cFM5Otx4PXs87U9bph997KFQ5dnDBpiVPonpVb32dnAgCjEB6Qiwur12EiL3rkXItFPbOLqjQpB3qDHvGJEDseLFvsq6u82d/wrNGPX277MwMhGxahqu71iCBtjyz0lLg6O4Jjxr1UaV9T1TrOhT2Ts769nzCzhMxpw6g/shXUKPHcAT/NQPXDmxBenwMnMtXQvlGrREw8NEc18kxQB5vUq6H4/Kahbh+ZCdSIkNVS5cKfqjYvBMCBjwC10r+OXqzk4mhbH1toHpb977nUG/484ZVcl5GEcjMysSaE+uw6tganI+8gNjkOPi4eaN59UA81H4EWtZskQsZ3sLcTFuZ609uxInQk4hOjkF2dja8XD3RqGpD9G/WF72b9NDnP+Ut2qHfjcgxDjtKsEwaPAGDWwwAO0989M8nqFWxJv56YQFWHF6JP/cvwcWoy3B1dEGdSrUxrNUQ9G7aE3blrNMTZWRl4N8jq7H2xHqcvRaMpLRkeNMam/k3wdBWg3B3/btyzO2DFVOw8uhqfdlP2+aAj6refljxyl/6cjkxj8Ctb3HzbaTGAAH6/OCl8f9ixz564F0ckJ6RhavXEhBQw0fZqo2ZtBqbd17Q9/DydEYcEb0tuy6q469/T2D6lIHwdM/5haTvYOZk1YYzmPrtVmQRuXNzdSSSl41TZyPVsXTVSfzy1TBUreJppnfO4ozMLLz18Vr8u+60quD8x0xEE5PSse9wqDoWLDuKmdOG6Mmbi7MDfCu4ISExDWnpWXB0sIO3l4vqb29n3Qc952zknS0iwN6xBz9/BankbMDCBI+J2dXdaxGxfxOqtO1u8bKZ4B349CVEn9yn60NfLA5uHopERp/YCz5CNy1H2/dmwtEt92cgPS4auyY+gpSIKyhn76DmknIthIhnCMJ3rkbg8x+haud+Fs8nnIjmiVkfqvVwJ14baE5J4RfVEbJxKZo+Mwn+XQbox3TyrgheR2ZSvCpz9PShLvawd3HTt5GTsovA9YTreHvJRBwNOaZAsC9nD1cnV1xPjMLGoM3Kq/TF7s/iibse1YOUmJaEcYvHY/+lg/oyTxcPJGemqH7bz+4EH3vO78XEweNVGyZlFdwrgD1rk6g/C79ncXbI/Z007b+vsZgIHouHswfiUxJw4NIhdWw+vRUfDp0IJwfLFAzX4iMxZtE4vfMEr9Hd2Q3RidHYcmabOno17o4Phr6nn4uHs7uaX2xyrLLJc3V0Vbj4uPmoOcl/+SMgJC9/jHK0YKeDnfsv48NxPTByaKAieUHBkUrrNfb9fxTBq+zrjrHPdka/7vWVhi0lNQP/bTqLqdO3Yvveyxj34Rr8+PmQHOPm94YJnl8lD0wZ3xt3tasJJmpM0j74YhOCL0Rj7PursfCHEfpfbHmNN+nzjXqC9/RDrTH64TZE4NyRlpaJVeQ1O/mbLThzPgqj3/gbS2aPVBq+gb0ago+3Jq/BslWn0CqwKuZ/n/MXYV7XlLqyg0BWeioOfTFGETwX36qK8FRs1kEBEHV8D07O/liRPUsR4ZAjTPAciMAFvvARKrW6WxEkvs6VDUtwet5XiL94Chf//R31H3gp17CX1/yhNOz1qK5Wv1FwIGLF2sATP32EuHPHceyHifCsSZ/V6nVz9TUuiDqxD8dmvIcbpHXxrtsMjR4bB5/6zVWzuPMnETT3C8SePqTGdPIqD1/S7LF0/2E9reGWprLT5Pm5tH2qofxX5hDg3aD3ln+oCJ4bEbsxvV5B/8A+cCGtWUT8NbBnKYcOmbFpFgKrNUWbgNYKo+nrv1cEz8neCW/1ex19m/WmPs7IzM5EUPhpfLV2Oo6FnsCKIytxf5thaOLfCH7eVbBm7Aq9to4H4vemJCQ6FJdIe9e2Vmu8M+BNpdlLTE3EnJ1z8fvO+Vh/ahOql6+Ol3o8Z6p7jrL0zHS8vGAsLly/COM1MoFbuGcx5uyYq8Z0pPV8dO9E1f/NvmPAx5BvhyM87ioe6TgSz3Z9OsfY8iZvBEQFkzc+Jmt73V0Xo4Y1V9uurOFq2bQqkbdLWLflHPj9ghkjMHxQU/0WqquLI23VNsEPnw0hEgZs2H4evP1rjbg4O2Lud8MVweN+jg72asyvPuyvhjlwNAzrt57Ld8gTp6+prWRu+NoznfDOK/cogsfvnWnuPM9fvh4GB3s7nLsYjd8WH+YqEUHAYgQur12stjDt6Aun7fgf4BvYUf34KEcPP5+3fXeWVRqsaCKGLP73DEblNt0UweP39uSNG9D/YdqqHaK0aYmhpuNBcmy6hqNeQ917RyuCx32Z1LWd8KMiWkzYzi76jovzldPzvlAEz4O2kttN/ElP8Lijd50maPfuTHjRK2gbLei3z+lFPALzBbWMN9hEGjHWjrF8ev9kDGs9RBE8fl/FqzI+GfYh6lWuixv0b/6eRVwMjkG38uh/6vw5Ij281ckEj8XBzgHNiAxOoX6aHAk5qp1a/Jp1IwuNacv3fw99oQged/QgTeErPV7AqA4PqnHm7/kDUaSJy0/+OrBMETzWJH714Oc51shauRdISzmm98tqmNXH1+DIFevnm98cymq9kLwC3Pl7Ogbk6sXaLZZObWugVnXTquQ2zf3RqF4l1W7N5vwJmWp487+H72uOGv657d56dqmDZo0qq1aryEYwP/l3/WnSagDlvV3wDGnwTEmLJn7o211nD7X8P926TLWTMkHAFALX9m1QxVXa9aCQKLVyNXGrXA3ViLBZKtqWZtTRXaQdjMjVrclTE9Brzi60GvtlrjoucK5QGbWIDBqLg6s7ag14VBVfP7oTmSm67Svjdtr7xJBzSLikiw9Z9/7nFMnU6rRXDv1Sf4ROm5gUfhFxwbrtN61eXgUBYwQ2kD0dS1P/xuhUV6fxNmzjQCYGr/R8AS91fw73tR6qqpjI/fjodEy+933c28r0Z6mqjx/cnXTmAMlk+1YQeb7bMya3Y5/q8jgc7R3BNna81ZqfrCEbPJbO9TqiTa2c9qla3wfbDUdlT913mUZgtTp5LTgCsl1bAOzq1Cqfq9chcl5g2Um2ep0GzcpVrxXEk00bS/CFKK3Iotd7Oub+stQ6dmhVXTl5HDmhs3/Syk29am3atqyWw7HCuO1d7Wth5fozuHA5RjmPeHmS3ZGIIJAPArz1xNuWLD4NW5ptzQ4Y7JRhibBTBTtcJIVdwNaxg1G+YStUaNoOvAXsXacp8oupx+3Y/s2UVGjSVhVnZ6QTgTutnDFMteOyuODj+ipt+1lfYHDCY7LtH2sI486dgE+D3AbzBs3ltIwjcIq2VllamyE/XNe5bkd18DkL28EFVm+mDl0JkEUa66txEQiJCUXwtXO0VXscqRm675uCxJhjEtcuwLQiwNvVi7SLdcBzZ4cPjXxqczF81baPuaxD7XaGVTnO7ekz2jaglXI8OREmyoUc4BTijZC8AoDHzhTGEhml0wKwU0JadP6/mtgZwxqpVtXLbPPKvh6qTpuD2YZUwV60LGzfl5f4kV2hJtxHSJ6GhrzmhUAGedQyuWFxJmcDc+JcoYq5qlzlbNfW7NkPEERbpZnJicrRgp0tghd/D0cPH1RqfTd5z95vlky5+ub0dDW8AHvZapIWe107NfmanhCjylmzaMrBQ+tk5+gEdqxIp/HS4/PfytL6yWvZRCAqSfeDv+JNBwhrUGDbu78OLFfbm1diQhTR0/qXA9kG3RT+8WWt+HpUVNo6c/18PXyp6rRy8jDXhsvZWUMjmZU9b33eTPWpdLM+hryERYoGASF5BcDRjg3rjCT75ofouUfb4s0XdC7pRk0K9TYvD9asm3Y/jo75775b+mHX1sOTZlsqEUHAWgTYhsic2DlY96enWrehqNKxDyIPbcX1Q9vADhxMyjISYxG29R911CGbO1OOF+Xy8v4m7Ycm5UhzkZdY+tlRY2i2ePLZyQtSqSMEMrNuPYPWADJv90JMXz9D2epxP97qrFMpAAG+tdDIrwFpxdrg4Z+eRFxKnDXD6tvmFx5FI26s8ctLrPnc3LiZ1cKQoOY1ttTlj4B1f2nzH6/Mtijv7YqIyESERyTeFgyuk3bQXIiUa9d1WkRNo5fXBCr4uOH8pRgK+5L3PA3XUaG8a15DSp0goEdAhQYhu7QbFC4kLSZSX258khZnnbkC93dwcUXVTn3Vwe+Twi4i8sgOXFo9H6kUt+783z+rUCjGXrJpFELFnKQazNFQq2eqPXvLsmSlJiMjKUHF6TPVjkPFZCTqvli1PqbaSZkgwAhwLLxrCZGISjL/nLKjBYdT4fhwTKpOhQfpCV6fJj2VzZ4f1RmLFibFuNyS9+z1ygTN3I/8SAr7wuLraV5jz/W8tcvhUtiRIyLhGheZFfYmZinvntskymwnqcgTgfxVP3l2l0oNgeYU7JiFw6tweBNTwjH1Bjw8F0OfmI9fFx0y1cRs2f6juoCrphrsPqDz1G1Hdnb5SYumuj8EHA8vLV23rWaqD3sLs1T397I6pp+p8aSsbCDAXwhaSJHo43vNLjr2tGVe25mpKeAQKqfIUzXhss7pQRvU3Z+0FuRQwR68StgekGzgjCX2jPnPWjSFRGFxcPWAV0BD46453vvUC9S/jzq+W39ufMJhVtijl8WzVt5jGveV92UPgcZVG6lFH87Do/S/4+tw/4yH0PXzPmRnl6qCH7OmnMORvD/kXQqNkpvgcbgStodjMa9TV9Um/0siYnkmIthkXXRSDM5F6rzZW9c0b3vLndlxpIFffTXO3vP7TY7HhTzX/Te9jBtUqWe2nVRYh4CQPOvwMtt6SF/dB5U1bj/NO2Cy3e9/HsZZcrg4eSYSDerm/evHeIDfKZQJBys2Fs66ERSs+0U1uHf+Xyham9j4VPw03/Q8Dx2jcCzbzqlLcfYLQ9G2jbOzC/Jnw3AkObdVBLQgwJG0rRprwruUNWshG5dYtHw7R0cKb/Ktyi7BZM+kGNgbOXp452rCHrHXDm7NVZ6RGI9Lq+apcs6akZ8DB2sIPWvpPg/nls4Cx+kzFnbgOPfXj6rYpaJfDjtBw21jjQQa95f3ZQ+BPpQ5guVYyHF9KBVDFDgTxvJD/6gi9kzl+HmcKYKFTXVMadpYAzdj00zVhv/jMQzFnkKZaMIOG+Zkzo7fTFbN3jZH2f+5U7DiLvU7m2xjWNiPYvix7Dy32+QauY5j5UWRtpKlN2knDUXbOs66uZ1rWCfneSNw607n3U5q80GgT9d66Ni6umr1zU878fn3ZDcUo/sgMjmb+fs+TJuxXdV3aV8TndvWzGfEnNUh4fF4YsxSInS6LTDWwv2x/BjGffSfashkrD152eYnTRtWxn0Dmqhm//tpFz79juZ501GEgyEvW30So9/8W2XWqF2zPF54vH2OIb1vOp1cuByLmDidE0eOBvKmzCPA3rAcK46JDGe94CwX2Te/ZGLPHsX+Kc+q1GKWAGVHWoAaPYerpiEU+PgsOVtozgwcgy6WPF6PfPuOqnf28UVFisNnSo5+Nx5h2/5VWSe4njV++2geqdERKsiyKVs+U+M0fPh15ambSBk99n38TA4SG3/hFPZ98rwKzEzfvGg6eiJ4/po4uN9ynoo9c0QrltcyjkCPxt0orp3ub/Jbf07Af8fXqtAkDEtoTBjGL52ktmeZ6Dxzz1MKrebkWcvCmSs++Huy3vmB7eQOXz6Cl+aPUenOVCP6LzUzVTtVr56unvr3R4lcmpMNpzarFGdaLDxOtfbFmm8ozdlS1YVj5rndDNNibgwuZ+/b2r4BygHjjUVvK9LKGkkWHvMHCvT87QadRr5v0965QslwmjYW9uTVbAFVgfyXLwK3/gLl21Qa5IUA56PldGUvT/gXnNeVtWSzFxxQ6cLiE3Ru7Nyft3W/nTIor6FM1nVqUwO7aFt28GPzVf7c1LQsZND2L0vXTgH4+J2cv3xMDnKz8CPK1pGcosvC8TPN8ZeFB+BFac24LCNTF7y1SYNKmD55oMp2YThWa4r19/PCg4rAdhk6WwV//vmre1VAaMN2cl52EeBwJa1e/xoHp72qwpIcmf42ODByOXK2yOJYdPRlxXHr2JbOEuGYdKwR5Dy055fPVoc9xbjLTk/Te/IygWpJcfKM89fy+B4U+JjtAzmzxQnKtmFH4ScyU3Q2qU5eFdDy9S9VLltL5sKhU5o9/6E+W8aeSY9RIGayWSVSx7Z6LPy+8ZPj4dsip4bD3a8m2EaPc+fyXILmfgk/sjFs8uQ7llxa2tgoAhzzbtrwTzB20VsIunoGE5d/hA9XfEKpvZzAW6YsbIc3fsA4ymOrI3d9mvXC34f/xcHLh7H25AZ1cNqxlIwUvYdt3Up14Eyfu5MUjiQ89moO9Br7NVTjp1EmiufnvgJPF0883vlhPNppVI527LzBuWw53yynTONUahrJ4lh5eYVOMRyItY/fjJyG14ng8TbvlJWf4dPVX1CqNHflfas5abF94bsD3zLsqs45fy+Ha9lzYR96TOunQsj8R5k6NA1frg5SoEdASJ4eisKfsPPFXEq/spICDv+9JgicXSI2LlWRsgZ1fDGItlMfHNpMZauw9mpPjGyFpygF2U/z96tx3Sl/bYNmfjReIAb1aqiyb1g6Jme2+JYI6cYd5/HXPydw+ES4mqcPBUiuF1ARg2nreSgdTo72uYZkjeV4ypIxf+kRhJPzBmfGYCeNlk1zNZWCMoyACwUg7vDBHNqWXYaw7f8i6eplta1UMbAT6tz7tNoatZTkcWYLzk4RtnUF5Zpdg8QrZ5XjA+eMda1cHZVadlHpysw5OTC5ajPuWwQv+RGRh7erMCzu1WqjSrueqNl3ZJ6hXkzdQv8uA1WsvotEUjlAcwo5ffBWLGfB4JRrrHl0reSfqyuHVmn91re6NGyk9cumGGYZN8Oy5GosBWUKAV9PX/zy5ExF3NYeX4/gyHNIIXMA9phtV7sNpfN6SMWl00BhYvjtqK+wgDJgMMm7Eh2ibPW8Xb3Jw7Y2elMO2EEtBmDJweWK5O27uB8JqQmKzPEYfL1pI6bih82zcD5SZ7tnyvFj2vAp+PfoaqV5C6EQLRxWJbB6U4xsNwIta7bQpmPRq79PVfz+9Gy1xnUUAPo8kb3k9BSVao0DQQ9pOSiXBk8bmANB85YzZwfhdbgToeVcuJymTSRvBMrR3r1FxlWu9SZj1rShKqND3kNKbVEhEBIeh+73z1HDzZw2BD3uqlNUQ8s4RYBAv4d+w7tEeJ98sJXJ0Q5OfY6MZtLR9On3TNZL4e1FYO/Ho5X2j+3tWo754vZeTEa3CAHebk8kr+iOn+m2+4w7cWaEFxaMwfo3VhpXyftiQoA1dx/984m62pa31lq0HVtMUyuTl+HA1g/NehyXpgYpzae1IIhNnrWISXtBQBAQBAQBQUAQEARKAQJC8krBTZIpCgKCgCAgCAgCgoAgYC0CQvKsRUzaCwKCgCAgCAgCgoAgUAoQEJJXCm6STFEQEAQEAUFAEBAEBAFrERDvWmsRK8b21at64+zOMcV4RbmUIGA7CLSfONt2FiMrEQSKCYHB5JXLh4htICCaPNu4j7IKQUAQEAQEAUFAEBAEciAgJC8HHPJGEBAEBAFBQBAQBAQB20BASJ5t3EdZhSAgCAgCgoAgIAgIAjkQsCmSdykkFi17zcCL43XJnHOs9Da82XPwCup3/kYdZ85dL9IrXLuehHlLcue3fGvyGnW9YU8tKNLr3YnBHn7pT7UWTgVnKNNn70LDLv/Dzv2XDYvl3AgBziKx/ukuOPT1G0Y15t+GblmBNaNaqcOwVfTJ/fryBMrLWhTCuWsvr1uMtDhd0nFrxjQ3H3Pl1oxdmLZx508gYt/GXENseXWAwu/0/K9y1ZWWAu3ZCN38d2mZcpHOk7NGdPu8D8ZR/tg7KZyPdva2X+/kFIr12h+smIJ2k7vgsZ+fLtbrGl/swMWDah48l+Br5/XVnFu315cD8MLcV/Up3fSVpeDEZkheJuVcHTtpNbKysvHea11LAfTmp8gp0fqM/A2rN54x38iGa557tB2qVvbAuI/WICYuxYZXWvClZVOKn6PfjafcrVlo9OibBR/oNvVMibqKnRMewqk5U1WO2dt0mWId9tTv07B74mOUj9c2P5f+9wyGdz3KEfrbZ0gKv1Ss2N7pi2VmZ+LdZR8gk36YvNHn1Ts2ndNXz+KBHx/BzC3iNHTHboLRhX3cvPFCt2ex/9JB/LZjnlFtyX9rMyRvzqKDOBYUgadHtYG/n1fJRz6PGe7YdwlJyekmW1Su6I46NcujWilfo8nF3Szk3LpvvXQ3WJs5dfrWvJqW2bpLq+Yj/vxJBAx8FK6+VQuNgx3lh3WvGqAOOwfHQo+XEhGCxMtnCzxOUc+nwBMx6Hht/ybgRrZBya1Ttyo1FHZOXhVuFZays3LlyqHRY+OQlZaCEz9PLmWzL9x0F+5ZjFPhQSpHrJ+3X+EGK0TvMxFnERYbXogRSl9Xzodbq2JNVPUu/N+x27X6e1sNRt1KdZSG9eL10vUDyCZCqERGJeG7X/bA29MZo4nk2bK8+UIX8GHr0r9Hffz4eyUsW30KI+8NROtAf1tfssXrS4u9jnNLZ8LB3Qu1Bz1ucb+8GvrUa4YuXy7Lq0mx1pW0+eS3+HbvzsyvSamo9yFNXuU23XDtwGaE71yNqp37l4p5F2aS1xOj8NPWOfBy8cSjnUYVZijpWwAEXu7xPPgoyWJvZ4/nu41WW/lfrv0fvh1VeswybEKT98Nve5GckoH7BjSBh7tTSX5WZG4WIsBahUeHt1Ctv5q508JeZaPZ+eWzlbalGm2vObi6l41FyyqLDYGafUeqawX/+QMpLrOK7bp36kJztv+OlIwUDKLYcO7ObndqGnLdEo7APQ26kLbRD7vP78WBS4dK+GxvTa/Ua/LiE1Lx178n1IpGDGl2a2V0xo4Rj7y8BJ4eTti2fDSm/G8L2bmdxY0bN1Czmg+mTeqLhnV9VR8u+29TMJasPIHjQdfA43p6OCOwcRUM698Y/Xs0gJ1duRzj5/eGiSfPbfPOCzhNjhkxcalwdLBDxfJuaNvCH6Pua46WTW+pqPna70xZpx9276FQ5ZjABZuWPAkOjsyOF8tWnUKzRpWx7JfcvzrDrsbj9z8PY+vuSwgJj1NjVa3siS4dauHJka3UGPoL3DxhBwi+1oTX7sEDg5vhp/kHsHZzsOrvQPNtXL+SKh/StxGYfJkSdpJYTlq3Q8fDERmVjPT0THh5uqBRPV/Crj7uG9iE1m5vqqvZskG9G2LyN1voPobg2KkIdS/MNi4jFRlJCQjdojOMr959mMlVpyfE4vLaRYjYux4p10Jh7+yCCk3aoc6wZ0y250J2aNg3WVff+bM/4Vmjnr5tdmYGQjYtw9Vda5BAW7C8nefo7gmPGvVRpX1PVOs6FPZOzvr27NhhKFtfG6je1r3vOdQb/rz+Wg5uHuj63RoEka1bxJ719LnMBm97Br7wMTIS48zOx3Dsawe34uKquYi/cEoVe1Srg6p3DUCNnvfDeNs5rzVqY15a8weCyCaNpe8C3R/yYz9OQtjWW85crEXlw4W2ybtOX6XasuNF6vVwtX3e8OHXVZnhf7HBx3CF7kl00EGwJpbx4u3xyu26o2bvB02SdQ3HTp/8oerPr/gFUcd2Uf8oOLp5wqdhSwQMeBTl6dWURB7ahpCNSxF77jgy6Jmwd3YlfKvDt8VdYCLn7F3RVDdUaNoerpWrIzniinIy8evQ22Q7WyhMSE3AiiMr1VKGthxkckmZZP+65sQ6rDq2BucjL4AN8dlOq3n1QDzUfgRa1tT9GDXsnE3P8ubT27D+5EacCD2J6OQYZGdnw8vVE42qNkT/Zn3Ru0kP/d9T3qId+t0IwyGUEwAXTBo8IUdwYrYf/PfIaqw5vg5nrwUjKS1ZzadZtaYY1noIOtftmGMcwzestVy4dzG2ndmB8LircHF0QeuaLfFUl8eQnpmOp37VadT2vbfdsJs6j02OxeJ9S7Dt7A6wk0oG4VLJ0xdtA1pjJOFQr3LdXH3YqWLl0dWqvl/T3pi25mucjTinyHTbgDb45L4PobVpTLj8/vTPuca4GheBZYdW0Jy3I4zmnJmVAX8ff3Sp3xmPkebVx80nV5+4lHgsPfg3dp/bg4tRlxCfkgBnByeabyW0qdUKD7Yfjtq+Abn65VVgV86O7sNAzNr6M+btWqjGyat9Sakr9SRvxdrTSEnNRK3qPqhf2/QfLfps4aXx/2LHvstwdXFAekYWrl5LQEAN3cPB9m9jyGmDyZgmXrT1G0dEb8uui+pgsjZ9ykB4ut/6MtPamno9eyEKo19fjrCIBFXNBJG1jPEJaaR1jMOVsDiwg8XUCb2VBpIbuZAtmm8FNyQkpiEtPUsRQm8vF9Xf3i5/pevK9acxYep6pdXkTrxWvu75yzHqWPT3MUwZ3xtDiayZkkiygRv6xAKwlzILzzchMV0RQCaBfEwZ3ytH14zMLOUgsXL9GX25pk2NiklWmDPuTK5/+XqYVUTZ1cURndvWwPpt5/Hnv8eF5BHC4TtWEclKVWTIo3ruP6rsGXvw81eQSo4PLEzwmJRd3b0WEWRTVqVtd1Vu6X9M8A58+hIRs326LvSHjskZE8noE3vVEbppOdq+N1MRD27kROSB+2Umxas+jp4+KEfbHfYuObUk/MPqMHkGRx3breaZnZFB844g8lMLsWeP6q6Xx/8X/v5FbSlyEwdXD2SlpyKOyBQfYdv+QZt3ZsDJwzuPESyr4rF5TenxMcomj8kSr8XJq7xFA7DH7cVV86jvDdWe8ctKT0MckS8+rqz7E63e+AZeAQ1Njhdz6gDOLv5O3cdy9vSZJpvJ9PhoXCMvX7YTZFLs30VHpLUBzi7+Hqzx1URdk54DJsN8XFn/F9pO+NHkNfmHXKXW9+DyfwsQunk5bJnkrT6+FqkZqahRvjrqVKqtwaV/vZ5wHW8vmYijIcdUmX05e7g6uYLJ0sagzdgUtAUvdn8WT9z1qL5PYloSxi0erwz1tUJPFw8kZ6aoftvP7gQfe0gjNHHweNWECUQF9wpgz9ok6s/C71mcHW5950QlRuONxW/jRJjuR0050PeKizuik2KIVG5VBxPISUPGw8Eu59d7UPhpvPbHm6otj+vq6IqU9GS1ji1ESIe3Nf2jkduy5+k7SycRwdV9NzBhcqTnMDQ2DKGHw/DPkVV4qftzeKzzw9w8l1yIvIiX5o9BEl3P3ckNMTROeRPkzLjjFiJ2H/w9GYlpiaqKSSnLhesX1cEE8rtRX6N+lXqqnP87eOkwbauORzwReBbeauW18hhJRPiY9PF8v3rwM3So0061sfQ/1uYxydt5bjf42fAlklvSJedTUNJna2J+azbpjLs7t6tholZXxCSONU0fjuuBkUMDFckLCo6Es5Nu+eM+XqMIXmVfd4x9tjP6da+vCE5KagZp984q4//tey9j3Idr8OPnQ8xeR6tgT9/X3lulCF71ql6KGHVoVR329nZITcvEph0XSEO1WTkWfELaRdZYOTnaY2CvhurQtHWtAqti/vc5f91p1zB+3X3gCt6k+WWSd3HzJlXw3phuaNVMpyU8Tg4prMXcfyQMb9FaK/i44m7S7BnLzwsPwt3NER+82Z2IYGOFARM+7nPwWDgW/3McI4Y0zaF9/HnBATDBYwXfG8/fhVHDmisNaHb2DQQT0f18xnZFkpnorSHtIGv1rJEu7WspkrdtzyVrutls24i9G9TaKjbrkGuNTHIOfTFGETzWMjV9ZhK0dlHH9+Dk7I8V2cvVMY8CDoHCBM+BNEeBL3yESq3uVoSNr3VlwxKcnvcV4i+ewsV/f0f9B15SI3X/Yb1eW8cFnSbPh2ul3DaVWSlJ4Hk1eWoCqve4n4hhutIU2jlaZnLBNmM+9ZujydPvwrNmA0XyQohwMqlip5QTMz8g8vR1HquzrKrx42+Bj1vauseURtKS3ueWzsLFlXNVUyZi9Ua8qLBg7+jrpGk79etn6n4d+OwldPpkAVzKV841bNC8L+HuV1M5RVRo2k6RPMbt6Iz3kE5awVO/fU4a1V56bWr8xSAdwaMPZYORr6JG7wfgQKT0Bv3avX50J479MFFp9tiLtsP7v+S6Hhf4BnZUJC/61EFkZ6TD0nticrASXLjp1BY1u/a12+aaJf8IeW/5h4rguRGxG9PrFfQP7KO0XxHx18C2WUzyZmyahUDSorUhjRbL9PXfK4LnZO+Et/q9jr7NelMfZ/LczQQTra/WTsex0BNKg3h/m2Fo4t8Ift5VsGbsCkU+PvrnEzUOvzcU1ii++ec7iuDVrFBD2bF1Iq0dj52Ymoh/jq7C9xtnYvXxNUpj+GbfMfruTDzHLHpLETwmtO8OeltporJoO34rEampq6Zh0b6/9O0NT5hQvU7EMjk9BXzdcX3Hon2dtmBieinqMr7d8AO2nNmGbzf+AG9XbwxtlVsjuufCPlQj7dsvT85UZDokJpRIaN47O3zdCUsmIT0rnTBqjDf7vIbA6s1UGJN9Fw7go3+m4lrCNbyz5D0sen6eIrWMw/ilExXBa+TXAO/0f1P15R8uyUQw157YgK/XTVdr+YpeFz2n+2warjev84Z+9Yl8l1c48poGNi/5Nqv5q4fyWvEdrmONHG8PsjSpn/uPo+H0et1dVxEQ1myxxkzbJt2+9xLWbTmnyhbMGIHhg5oqcsN9WZM0rH8T/PDZEEViNmw/r7aADcc1db6btolZk8fyzccDSBtVUxE8fs/XZqLDhIgljjR75y5Gq/PC/Ddl+hZF8BrUqaiIoUbweMxmjargt+n3I5BemXxN/nqzejW+Htd99UF/PHxfCz0GrCH95qMBav3cfsuui/yihP8Izl96VJ0/dG9zcOgT3uJmYZwb0Fb49MkD4ebqqMoOHgtTr9b817hBJdU8JCxer2G0pr8ttWXtmKbh8gzIrY29vHYxUiJD6QvZGW3H/6C+qPmPGx/8pd323Vm5tGn54RNNZIKFw2uwQT5r5FjsyRs3oP/DtFU7RGnhEkPPq3Jr/+Mxa/QaQePaqTHZ8N9S4e1O1kYxwWPhOdWibcgmT76j3rPzAMe1u1OSGnMN50nbyFKt270IfHGynuzakUauMmlV2036WacZpViCwX/9aHKq9i6u1G42bbN21m9BM3lvOGqsas8aU+254IKo43tVuWfN+qg9+AlF8LiAMa7UsosKucMaQd42zkxNVm2N//O8qVXMJjIfc/qQcbVNvM+gbb9jocfVWhrQl7exbCLNmGZ79en9k9VWqKZJquJVGZ8M+1BtUd4A/R3cs0h1ZyKx8uh/6vy5rk8rwsMkjIU1a7ylOoX6aXIkRPf3U3uf1ytrn47T1i9r+JgsdW/UVRE87uNBmsKH2j+AiYN0z/5f+5chJDpUP9zcnfMRRdpH1ij+8Oh0/VYja7l4HHYkMNb8aZ2/2/ijIkXsBfvT4zPQsW57RfC4nr1ip434BF0b3K2af7txhto+1voavo7t/YpeW1q9fDUitn6G1bnOmTwywWNS+uMj0xXB40ZMLlkD99nwj1Wfy7R1vJW2n1nW0fY4azV5LV8+8BmaVmui/v5xnRtpENlL9pGOD/FbtfXOpNBaqV9ZpzXcc36/tV3vSPtSTfIu0DYkb2uyNKxreqtWQ/WejgHaaY5Xtm9j6UTbgkxoTEmb5v5kW6YjG2s2nzPVJEcZk6p5391P5Kg/WjQx/SBrtoDc0Vy4lByD5vGGCWXQ2euqxStP0y87IpLGwprCsc92UsW8fXvkhI4cG7arUskD3TrXNixS51WreOpDtlyPvvWlwLtPM6YOJiI3gAhe7l/C3JkJXg1/3ZZZQdbZoI6vfj4nz0Tqz8viSVLYRdKqpKmlG9rMaVhc27dBnVZp10NteWrl2qtb5WpgZw1rRNtijTq6S22lGvdlLVyvObvQauyXxlUWvWf7sIJKnWGjlZ2ZcX+2EXQur/u8hu/UfeEatymO99f2048pul9MqOo/+LLJS/I9YZLLcpXmykTeWCq37mrSfs7QFi/dIOC0g6tuWzwp7BJiyAbQWKp27ofev+3GPV+v0BNA4zasUXS8udUdf/G0cbVNvGctVBppj1lM2ZNtIMLA0pS0SJ3q5tacO9B9faXnC2qb8r7WQ1VbJhc/EomafO/7ilCoQqP/qvr4qS1LLk4mezpLhbcmWXo17k4aMy+T3Xo37anqsm5kKe2a1ojJD8vQloPBBNVYGpLWqyeNayysAdwRvEsVP9xxpNJiGbfhH5EvEw4sbAu3nWz2jIXJpDVbo2xnuOf8PjXMqI4Pqi1y4zGZML9IW8SsLa3jG6Cq725wl9q+/XzEFFT20v0NMO5X18B2kLePrZW6leuoLqcjbpkoWTtGcbbPzQaK8+qFvFYoORloUoGcGfKSOrXKm6zWNIE7aTux06BZJttwYTzZybHwFmR+4kN2dB1a18jRjLdpQ8LjceFSNIKCr+fI5pBFGrTCyJETOvsrHuOudjXNDtW+dXVl55dB28lHTkaglVFYknoBFcz2ZRtFEC/MIO2pJqytY8cUPjRhbWBEZKLSujH55LldDtXZcWRlWb9Otu9zdrJXZJ5t/MqypJBhvyZO3jkAe2F3AABAAElEQVTvFWtV42iLkoUN8s0JO2CwU4alwoSJHS6Swi5g69jBZOTfigzz26ltYO86TfWaJUvHM27n7h9gXGTxe20r2rgDaxt5G5e3tuPOnTCuLrb3bBvI4kFOLOacHLi+ImlZL6yYo2zuWCPqVashF+uFnUlMiSOF0NHEkBwyyT+zcDoykxOw96On4UnjMVYVmrVHhUatTRJjbRzDV475xw4whgTSsL60n7PjgSYV3HJ/P5yirVWW1mSob07YycHQ0cGJbNV4S5EPTXhLlJ0HeIsy+No5pT1MvfljjR00LBHe6j1JcfxYWKO3/tQms92YmLGwkwgL2w9eiQlR5+wkYU7a126jHEwM63l7mefP0qF2O8OqHOcBpNFj8sjb2GwvyFvUhsJ1mhbUsNzceTA5lLAWj4UdQ8zJkwa2kNyGtY18GAprV0NjwtTWMsch3BG8W1/NzjDWCm/XsrDGsDRIqSZ57BSgiSIh2hsTr+bqOcYeC2sE0wy0VCaGUEXsjGGprNsSjOXkXMGeoezowZovTZgg6cWwQl9o+Ul0bIpqzPZ02napqd5sg+jj7aK8X6NNECb3PMLPaPPNNjHXi1diMPevI8oL9gKdp9/Urmpz0PrytkZBhNfE96ask7zM5FtbC2wjZyjsPXmDbHZY8iIUzhVuEXLD/ubOfZt3QrNnP0DQvC+INCTqnS2CybDf0cOHDPTvRg2yp/Np0MLcEHmWs5dugYS2bNgZwpw4++g0wOygcKdEOWrQxU3Z2RnOybBe62NYb39TM2dYps4NnbEMPpdMztq8872yvUumzBUJl06r4+LK39VWPpN0/7sHwa9jH/1WVq6xqYCdNVjuJIZqArfpv8RU3d9+Hp63O40lKkn3g77iTQcI4/q83jM5+uvAchy5clQRLI0ocR92ltCEf5xZIuwdytvLLBzuhY/8RHM8YAcBTYwJkFbOr+x5aiwx5BWsial6rY5fK1N/JnmmyI8nxSC0RtjBRJOKRqRNKzf3ylj/Rw41bH93mkgdb1MbCm/3alKQ7yQPZ92zEk9aS74WaylLspRqkkdaYr1k56MlsjNsrO8FMuLUfch4u7GoggxzarVXJ65SYUj4Uvb25VC7RnmwNpE9gJvTFm55cn4Y+fxig5kU/NTSPxR8Bf0PFxN4GMBp8WTYo3fcx2v1Gj72DmaNYJ1aFdCE7Ok6kPZw7PurVVgaiwc1asjaQZYs0kCWaTG4Z2xEb07y+sNl52D9R75at6GoQoQg8tBW5SzARv9sz5WRGKtCi3B4kTr3jtY7Xpibl8lygz+4JuvzKORtInOifXcah1Ex115fngeu+jYWn1j2Bc6hYzQxvSLTpVofU69s29hl2lLlNHPtwBay09uNpNALavv4+uHt4COUwuK0HjfdrFOF9oxx6jxbFMPHx5RGLbOA6563eyE5X8ygn7S6+1/ZszLZogUgwLcW2BmAQ4c8/NOTtLUZZzGshvMbT84E97W51+K+GjnkDobjGA+gzdewXPscGZaZO9fGNvW5NPf9a24s1lwWRFhr9+qCN3Dkpjc0b5/zVnytijVUxgre4mXv5fHkKVxQ0dbJr9Z89xb0eoXtZ/1f/MJesQj7G4YziaYcpxWJYFgr5b1d1fZieMQtLYm1Yxi35zh1HGeO/4gYepwatjtw1HonBMP+hufaVnVScoaK78fx6UwJewvHxut+AVYs72qqiVVlV2lbluP68RYuhzqZ+Hp3RfCMBzHUuBrX5feeCV5svE576nHTqSO/PrZa73hTs8Lry0iIIY3drS1bFaaEQhrcIJuutBjztotpBrZb1uDkQMb/VTv1VQf3Y/vAyCM7cGn1fBUf7vzfP1N2hH4wFdbFmutY3Jb+wLLWy1wYkzRyemDRNHrqjSFXMiBWqu7mf5kpRfd3wMlTt62TGh1heIlc5xw2RhPjbXitvCCv7GjB27Tatjbfew5Xw+FTYs8cVp7NIRQipSZ535oSfsZYNI2eqTaluUzTyPAaODSItg2nrYlj4V1LiERU0i2tklanvTKp4O1QDpLraO+oUqNpBK9Pk57KZs+Ug4EWJkUbJ79XtsFjDRQTC9aWWSOGmjCeqzkx1J5pbQzDnLAnK2NiTrR5GeNorn1e5eylqwlr4szZIF6lLXcHwp21rUwu2dOZCR7fi3f6v4E+TXvl2iZefWytNnSBXm+FkXGma5d8CnVLb1mg5d7ZTtX9b9mkaFuW1s6o+U17Mg6xwjHfTAl78Q54eC7FkJuPXxcdMtUkR9m/pN1i6URetYYep4aNOISLJtb8WtL6GL62NHDu2LHvimFVjvNdFGZFs4vjAMeFlQ3bzqmQMDzOZxP7miF4aeAAzUosU2zo2t78nwmepsnTHDhyNChDbwzDkKTf/ALWls9/4NgOjSX6pnelVmf4Gnv6sOHbPM8zU1PAIVQ4REfC5TM52rItHXvXshevEnqIi9v+jQMMmxK2T4sJ0n1OvQ28de3IXkqTzORbW3VaGb8mhpwzfFuoc+3aiRS7kDWf5oQDHLNo+XrNtbO0PJxsKM/8MT1XuBzexucwLu3em6UCOfN4HKfPnGhbxxwY2RbF36eqflkct81YGldtpIoO05arOfmPAhLfP+MhdP28j4q3x8GPWSPGIVfeH/KuSQ9SDg2iaaos/ZPIpEVzDuEYbeaECchgiqTw+C/PqO1Kbsfr1Ije4ctHzHXFocu5/zY0pvAu2vam5ghhaoDga+cV2eW6BgYx60y1taSMA0Zr29p54T9h2Qfo/81QTPpb52m77uQGNfyAwH4YQsGtTdkBsr2fJgXRxGnPSrXy/towJfq1VJM8DmaseZJa4hBh6k5wFgcW9hr9ad4BU01UBgl2ImDvzgb5ePHyAIlJOlvBG2YcKuKIuPw0b7/+WuwIYSha4GON3BjWmTqvT2FTGtX3VVXf/bJbT7wM26ZRBorps3V/HNhbtihywWrr5OuYW+s3P+0i8qxbn/ZqOK/8zg3vK2fPKMvi5ldTEQHGIDHkfC4o/LsMUGWc6cAUAUqLi6YMCEty9TNXYOfoiLOLvsXlNQsV2TPZzuAXiuaNye1Yi6TJ7UqNdYG0hxxvzlg48DBvJdMkcgQJdq5QWd805vRB/bl2whq1SNrGNCda+BhL18PZQDi+HLfnYMamhLNKXKGsFCyV23Q1u3Vqqq+5svDtK5Ujx7lls01666p7c3Nb2vCeGY7HTj4cRJuFQ7HYonDMNy3QMBMvY+lDnqosx0KO60OpGLbhuHXLD/2jijiLAhMK9gplySJ8TW1bMqmYsWmmasP/8RiGYm9gvmBox8dtOEYfS9DVMzCnjZq19RdcjY/AqbAgcAYJTQYG9lWnfx9eSTZq0Vqx/vVy9BU9KdQX0omHs7vKLMFlHCbGlL0dr+n7TT+qboxBl/p3qfPC/MeaO80b94+9f6og0cbjnSJHlJOhp1Rxl3qd1KumITU0gTDsxw4YSw+u0BdpZFtfYMEJB3ZmqW/gpasKSuh/t/4Sl9AJ5jUtTpPVmsKbsOw7FJpXU7N1fbrWQ0eyG2P55qed+Pz7bXoDfyYxM3/fh2kU0JelS/uaKuadepPHfxqBYs3ZLCJz7FnLwq+rN57BsKcWIvRqgn6EVNpGNRRv9mQluXA5llKh6f7QGtabOh//yj3K9u/M+ShwmrLDBiFSTpy+hideWwp+5S3kKW/3BKcrK6xo6+Rx3pmylrxodTYm/KHna702caUiyNp1jNeplef1uvew7r5yeJfaNXXbX3m1t+U6ti8rf9PBgbMgGAt7wnrVaaJIBWe94CwXGgniOGr7pzyry9pg3NHMe47lVqPncFUbsmEJEZXv9Ub4bK8VG3wcR759R9Xztih7iWriYOD5GXvGvPZAa1+QV17T4a/eQDKlbmPJpODKHHz47CIdoarZ58EcoWRcK/qpVGzcluPXcRw9flb54G1MTutm6KXK7QxFcxJh7Zdmr2ZYb3zOmNQe8pQqDt38t3KESInUmWnwfeHr7/v4GXBQaN52NpUOzXhMS97XoHWzJF45iyP/ewuJZIvHa2Th6x/9bgLUFjL9MfDvMkiVG/+nPV/l+JnLw1vbuF9pes9bbS1qBKopc5YEY+nRuBvFtWuiit/6c4Iy5tfs25gssF0XEw3WdD1zj+4+N7/pVcuZKzhTg7Y9ytusrEXjrA+c7kyT1EydKYr23pPSnmlylMiloQynwMlaKi4OmDx31wLK4qDTSLMG7+t13+LP/bofDByQuEYF3fcaj/Fop4dVhgm2A3xh3qvKIYTL+bnYfW4vXpo3xiSR4jac0YMzRvC26TO/vahCm2h2aRyGZhxhwxk8WDgWnrmtVdXAiv84gwZrMJmAv0J2dmcjglVvJmYc1uWtP98Fh4rhbBda+JdASjXHwinoOPWbRqIZpxWH/8WTc57VZ8/gdpqXM59bIrrYiidUU7atLA1S8jeU80Gxb7d64PAnew+H5NPSdDV7fnK6spcn/KvSdnHe1tmUxYE9OjkFmSa8rfvtFNN/ELU22uurFKtu6+6LKqMFE8QvftiuxuN0ZTf/1qJ317rKG5WvEaJtZ94cgIkrZ59gb9IuQ2crbeXPX92rD+CsXcfwlQMuf/ZuH0z4dD2OUniUEc8sUjHqmNSxrR4Lx6zjbBZ3dwxQ7wv7X7uW1TCkTyOsWBtEIWGuoOeIOZQxw0llFNFCrfiT1jCAyBnfI+N1WnL9fTdJXr/u9SxpbvNtWDvEjg+cA9VYWNPU6vWvcXDaq8qb8sj0t5U3ZTlytmAiwZqtWrTFynZ0lkrd+59TWkH+0uc0WXzYu7ojm9Jyad68TOhaUpw8w/y1nKGBiQtv+XGGhaC5X8KPbPq0QMWWXj+vdgEDH1XZJNghRKXtou1lTcvG12r48Nhc3TlzBWeXyKIgwIe+HKvTjNIXMGd14DE47t+JWR/m6scFPg1aqpRgTAg3PEM/qkhL123G+hxaS+OOdSlfMGsVL1NO3LBt/6qDPaM5fh5fk8W1UjW0eO0zuBhoGo3HseZ9JYo9GDD4CVz851dFJJlMcoDscvS3jlPisfCz0oiwMJdKTXu+eCxO42ar0qNRN+y9sB8HTWxVstH+tOGfYCxlimDt2cTlH+HDFZ+oHKhafDUmIeMHjKM8ts0URH2a9cLfRCZ4vLW0dcgH2/6xN6ymmatbqQ6c6X6cpFAj4bFXc0Db2K+hGp/j9z0/9xUKXuyJxylV2KOdRilN4Tcjp+H1RW/jXOR5TN8wQ2W4cKP7k2AQ1Jdzur5N9miGwrZ0XzzwKV5d+IYiTaOJrPGWMjseclo3zs7BsQB3Ua5XXpOh8Hw54DFnkmCN38sLxqo5OlIfLd0Ye5i+0O0ZaPECDfsX9Jy3bKcM+0BtxfJW8qifnlDxBRkbTQNXk4jslyM+1dvGjen1Ep77/WWVPu3Df6Zg8r+fwhifwS0GqDA0PK/wuHBwFgtLhe8ZE3h+NrpSirPSIKWe5A3s2QCffbdNhQVhZwYOXGytsPPF3G+HU3qu0yqfLGuhYuNSiZg5gYPxctqxB4c2oxhz9hYNzduhy+eMwoxf96oMERw+hbV4THiaUqDk4QObovtdtfHiO/9g3dZzWLMpGE8+2Fo/NmsXWTM3f+kRhF9LpAfYDuwY0rKpvonJk6H9GqNNC39lN8hpwMJIW8ip1DgLBl9v5L2BqF71lkGryUGsLJw2qS/atvTHkpUnVQzBNFon41anVhX0uqeuwm3PgRBF8k5TfEAOtxJAnsaWCJNcjeRxJhIRUNiLvpS262uVziqG7OuMtSxMFDp8MIe2ZZchbPu/SLp6WW0bVQzsRB6wT6u4dtaQPM4iwVklwrauoDyxa5R2KCOJnivKicu2WpxBoVa/UbkcIHibsvVb3+rSnlGuVCY1miF/Ud1H1nxxDLhL/y0kz9FzlM3DlUhLYxVc2K9jb5OXqdCkLaUPWwjOextFuXc5By/bqvm2vAt17yVCRrHlzEn9B19Rji2cAziDskw4Uk5bzmrBGkJzwlujjR9/W923y+sWgW0i2QHCgYiyV+3GKowJa2D5fVFKw4deUw4XrIFlzSNfsxzsVc5jjpdXs89ImAqozXNgbWbkwa1qOpypw5ald5Me+B+lIWMtFYc7aVGjeY7lcm5Szi7BxG3t8fUIjjxH+V5TKVxIZbSjuHKcPaHezeC43JG//Dl7xALa2mSCd4WyMTCJYkcCzo3bmwIODyKSseTgckXy9l3cTwQtQZE57s/XmzZiKn7YPIvi3Ols9wwdP9i+bu7on0krtRJs/xdMZI/7s/aMAxpzmq3+zUyHxmEiymm8ft0x92bu1SgiQG5qO3b03U8obRyTPHfaojUW3jr964WFWERbp9uCd1LcuVBFtAIq1gKnhBtGwaANcTDuX9D3nI1jMRHfBXsXKQLK8QaZUDKWHBR6ZPsROQIlMwa/Ez6/bP8dnPqMw+Ck0/PMWTPYs/a+1kPQsmYLnL56Fhwzb8OpzejW8B6Lp7eR0tixcNDl8jfj5Vnc+Q41LEfqWotsP13rTcasaUNVZog7NFezl2VN2cy5+5VW6csP+pltJxWlC4GZc/eRFnQHehNZnPHp4BI3+X4P/YZ3iYw/+WArk3M7OPU5Ms5JR9On3zNZX9BCNqrn4LlV7xqA5i9NKegw0k8QMIkAO24cpW14Tp3XacoCk7ZlJjtaUMhb/olhF9HxM922onGXNSfW44UFY7D+jZXGVbftPaft+m3nPPQjcvTxvZNu23Xu5MD8NW/KRtBwTpxTd+HexSrMy9zRvxhWyTkhwFu7A/93r9KaMj7WaAALAyAH0H5o1uO4NDVI2UhaO1bhDbOsveJtaD/64bYq1+p/m8+ioF62t2FaMmQhEGCnkz/+PqZsCF8d3bEQI9le14BBj5Pmx4MyOqy3ysbO9pCQFd0OBK6s/1MNW+/+5/MlBrfj+sU9Jm+FsvZqI2l1tPAYxT2H23093qYd+t0IzCEtnilhArP+1EZVZazNNNW+LJax5y4HmO7W6J5iI3hFgbNNkDxOI8bBjDnTAjs6iJR+BFZQppCQsHilndXyBpf+VRXNCpwop2jtIU8om64LZHclIggUFQKc65btL30ofR17+5YF4a3Oxzs/otJo/bZzvk0umYlbWGw4ft42h7xL/6YtZ51DHztQnAg9SY4NYxFJmTHYTm9kuxE2iUFhFsUOHKztZXvF57uOLsxQxd7XJkgeo/YMafNaB1ZV3pyXQih8gkipRSA5JUM5q7Bt46TXu5XaddzOidcmw3pOJXaJwpuw3Z2IIFBYBNhj+NTv05RjTeALHxd2uFLV/zHS5jUnz8xF+/5SdnSlavIWTPaRjiNVPl12Wpi6ahru+bw3en7RH52ndscT5HHKseg8KbXbJ/d9hOoVqlkwYtlqspi8ltmTmD2N2R6wNInNkDx2MPji/X4qmf0n07eWpnsgczVCgG3xIilu4bSJfWAue4dRlzL3lr0jA1+cQh6ezuTc8GWZW78suOgRCN3yNxIuUnw1chRxq1y2vujZmP+joRPhRAGzORSJrQnHr5v12HeYSiSOvWir+fgrL1GOg9egSn083eUJ/PHsXNx1M96cra2/MOuJTY7D7G2/oB2no+swsjBD3ZG+pd671hA1zohwaN2LhkVyXgoRGPtsZ/AhkjcC/EXc8+dbMbfybi21gkDeCFTvPgx8lFXhDAabx62x2eWz528v8ibmQ8RyBDj8zMY3/7O8QwlraTOavBKGq0xHEBAEBAFBQBAQBASBO4qAkLw7Cr9cXBAQBAQBQUAQEAQEgduDgJC824OrjCoICAKCgCAgCAgCgsAdRUBI3h2FXy4uCAgCgoAgIAgIAoLA7UFASN7twVVGFQQEAUFAEBAEBAFB4I4iYDHJs7cvh8ys7Ds6Wbm4IFCSEODPA38uzAmHObmRlWWuWsoFgTKHwA0KKsufC3PCoUyysuUzYw4fKS97CHAgZhb7chbTtRwgWdzLzdUJKakZOTrLG0GgLCPAQZs93J3MQuDg6oastFSz9VIhCJQ1BLLSUijYsofZZXPGhZSMFFiYUt3sOFIhCNgKAikZqbAjgsexDgsiFpM8DzdHJCcLySsIyNLHNhFQJM/NPMmzd3FH1s30QbaJgKxKELAOAf7R4+DqbrYT55BlTV5GlnzXmAVJKsoUAvyjx93JrcB5pC0meeW9XREdq8t3V6YQlsUKAiYQYK12Ev3o4bzJ5sTR0wfp8ZJizxw+Ul72EEhPiAF/LsyJj6u3qopJls+NOYykvGwhEJsUC28KyFxQsZjktWhaBSfPXivodaSfIGBTCASdjYSdXTk0a1TZ7Lq86zZD4uUzuCE2RmYxkoqyhUD8xdPwos+FOalRvjo8nT1w+uoZc02kXBAoUwicjjiLZv6NC7xmi0le20B/nDgtJK/ASEtHm0LgOH0WGtfzBduqmhPvBq3IJi8FSWEXzTWRckGgzCCQFheFtOgI+NDnwpzY2dkhsHozBIWfNtdEygWBMoVAUPgZtKzeosBrtpjktWnuj3MXo2mLKr3AF5OOgoCtIHAsKAJt6TORlzj7+MKlUjXEnT+RVzOpEwTKBALx50/C3sUNHtXr5bneVjWa49RVIXl5giSVZQKB7BvZCKLPQosagQVer8Ukr3mjKhQuwg6naJtKRBAo6wicPB0J/uGTn/g0bIX4C6fyayb1goDNI8CfA+/6LVDO3nwIFQahRfVA0eTZ/NMgC7QEgctRV5Ccnqw+E5a0N9XGYpLn6uqIJvUrgTUYIoJAWUaAnS7OXohCm8Cq+cIgJC9fiKRBGUEg/mIQ+POQn7So3hzXE6NwLV4UCvlhJfW2jcApMlvw86qCKl7mbb/zQ8BikscDde8cgP82npUYRvmhKvU2jcCaTcHwpPh4LZv65btO35b3IC74OFIiw/JtKw0EAVtFID0hFlHHdoM/D/lJHd8AVPX2w/pTG/NrKvWCgE0jsP7kRtxdv3Oh1mgVyRvzdEccOXkV+4/IF1ahUJfOpRaB7Owb+Gn+frz4WLs8nS60BZZv2l5pLy6unKsVyasgUOYQuLxuEdmn+qNKx775rp2dL17s+gwW7Fkk8fLyRUsa2CoC5yLPY1vwDvosPFuoJVpF8gJqlMcDg5ph1rz9hbqodBYESisCm3ddwKWQWLxGP3gskXLlyqHeqNcRsnk5xcyLtqSLtBEEbAqBzNQUXF7zB+qNHJOvPZ628Ec7jkJqRhr+O75OK5JXQaBMITB310J0rd8FzcnbvDBiFcnjC73z0l3YvPMCgoLFXqIwwEvf0onAT/MO4IkHWqJKJfOpmYxX5td5ANyq1MAl+qITEQTKGgKhm5fBztEZ1XuPtHjpni4eeKbLE5i7awHYw1BEEChLCFyNu4o19ANnTM+XC71sq0le88Z+6NetHmbO3Vfoi8sAgkBpQmD/kVAcPBaGcc/dZdW0y9H2U72HxuLKusXITE60qq80FgRKMwLZGem4uGoe6o54GfZOzlYt5Zm7n0Q4fdltPr3Nqn7SWBAo7QjM2/0HmlVrgi71OhV6KVaTPL7ih693AxufL1kp8b8KfQdkgFKBQFR0MsZ9tAZPPdgKdQMqWD3n6r0egHNFPxyd8a5kwLAaPelQGhG4ceMGTsz+GKDk6rUGP2n1Enw9KuKFe0bj01XTEBojduBWAygdSiUCW85sx18HluG9AW8VOF+t4cILRPLat6qOH6YOwsTPNmDvoRDD8eRcELA5BNLSMvHi+H9Qw98L337Uv0Drs3N0QocpixBLnrZnFk4v0BjSSRAoTQhc+GcOIvZtRIepf8LR3atAUx/f/020qdkKbyx+B4lpSQUaQzoJAqUFgdNXz2Li8g/xbv+30L1h1yKZdoFIHl/56ZGt8cpTHfDyuyuVIXqRzEYGEQRKGAKsjZjw6XpcJ03e8tkj4eLiWOAZulerg/YfLyDbvIUI2bSswONIR0GgpCPA5C548Qy0mTgHnMO5oGJvZ4+fHvsejvYOeG/ZB8jMzizoUNJPECjRCHBsyDfpx8yQ5gPxao8XimyuBSZ5PIPPJ/RG5zY18PzbKxATl1Jkk5KBBIGSgAATvO/m7MHGbefx75xRqOxrubOFuflXbN4ZLd6YjpNzpiLq+B5zzaRcECi1CHAav2Mz3kPjZz+EX+eCab7/z951wGVVfv+v7D0EBGSKeyDgwm1arjJXjtLSzNmwNG2YZWX5rxzZsKH+TM2VpqWV5h65RRFwAC5QZO+98X/Ogy8yFZDxjuf4udx7n/vM772v99wziy/ezMAUW6asE1kwvjmwQsZpLQ6OPFYLBDirxbu/fwBXKxcsH/NljahpFcA8FpPHac62rHgO5qYGGPbyJpyVqlsFrnKv4gikpGZh9sf/YuWvPtj60yi4t7atsRU5DxovHDEufPUGbu1cI230agxZ2VF9IsAfRexBfm7hZDgOHIemY2bW2HScGzph4ytrsDvgX8ze+i7i02Q4ohoDV3ZUrwhcjQjCS/+bjMzcLPw6aTX0darmoPSoyTegH+a9R1V61HW2WXqfVFrfk9Rj6vhOeHNKV+jqPDw/4aP6lNclAvWFgI9fODlZ7IWluaH4iGlHeZtrgyL++wv+S2dSwvamcH/tMxiSY4YkiYAqIpCdnIArqz9FQuAFuL+5FE7E5HGMyJqm0PjbmLZhJkJov+DZeehRA96HNT1H2Z9EoDII5BfkixBBK4+twdhOz+H/RnwKE33jyjStUp0aYfIUI+4/dgMTZu+kGGLG+PqTwXBxtFBcknuJgNIjkJuXjxW/nBXhgV6f2AVfzXvqsWzwKrNgTnd28YtpSLrmh7aTP4Rd1/6VaSbrSASUBoE4/1O4tPJjGNk5o8OHa2Di0LRW55aXn4elB77F1we/x6iOIzHzyRk1Lv2o1QXIzjUegeiUGHy863PciLmJb8YsxlCPp2sNkxpl8niWsfHpmDRnFw4ev4kh/VvipVGeaNuy+sl1a23lsmOJwH0EWDW7/Z+r2PiHP1gqvf7r4RjUt3md4XOvoAA3t32PwDULhZG6y8Dn0ahTX2jpVN/Jo84mLwfSSATukRQi9uJx3Nm/FfFXzqE5ZXVpOXFenT6zZ26dw7SNMyn1WR6e6zgMI7yGwtLYUiPvh1y0aiBwKzYE23x2YM+lvfBy9sTP476Fg2XjWp18jTN5PFvWAO87egPfkfr2X4qn18mjsWD2+vdpKtW4tXo7ZedVQeB6SDw2bPfDzn+DYGNlhDde7oIp5DVuaWFYlW5qrG5a+E2E/LEKYf9ugLahMZyeGgWnfiOhZ1b1uHw1NinZkUSgGAK56akIpxR9dyiwd3ZynMhi4TZyBsyatClWq+4OU7PS8JvPdqw+/gvCksIxsO1TGEOqr1b2LetuEnIkicBDEGC17MkbpwVzdzbEBz2adsP03q9gUNv+YO/x2qZaYfKKT5pfpGyrt26bH4yN9TB8UGt08XSAp7s9TI1r1sCw+LjyWCJQGoGCgnu4disO5/0jhKT55Lk7eKKbK96iUEDPktSZHYmUgfIyUhG2bzNu/fEzMqPDYOvdH9btu8GypRcMKcm7JIlAXSKQlRiDxKCLwhs86tRe6FlYo8nwaXB++iWl+QApIGn4keBjWHV8LQ4GHYGnU3v0bfUESUvao7ltM+ho6dQlZHIsDUcgMycTl8Ov4uIdP/x7eT84PMoYMi3gVH1tGreuU3RqnclTrCY1LRvrSWqyY0+g8MLNzslH6+Y26Ni+MUn6HNDZszGsG9a80aFifLnXPASyc/JwOSgG58mR4nxABHxpS6HnsGVTKzzZ0w0zyEmoJr1maxphVuPGnj+EO3s3Id7vBLLpZWtgbU/Mnqdg+CyI6TOh2HucNk2SRKAmEGAtTEbkbSQG+9LmJzb+0GBpckMK/8MOFXbdBqOBdu1LIKq7nhsxt7D+9EZi+v5DYFQwjPSMKMm7Ozyc3OFFzF9bh7YwoFy6kiQCNYVAUkYy/MMCcDHMn/aXRLgfLXI88nL2wOC2A/Gi99h6MyWoMyavOJg59PL1vRyJ4yRJ+e/sbZz0uUNx9rIoDpmxSPzOexsr48Jzik3Gjhwco8zC3AB65LWrq6tFmzZ0dLTAQEpSfwTYBzw/vwA55ByRl1eA3NwCZGTmICYuHdGxaWLPxzHxhcfRsemIjE5FPjFKnm3s0NvbBb26uKBnF2fxbKkaYvzyTY+4hYSA04gPOEXbSWREhAi1Lnvl6lvaQJ8kLPqWjcSxAZ/TpmduJXKGNiD7Prbx400yhap296s/X/5QKMjLxb28PBTk56IgJ5vUrAn0wRCL7CTaeE9blmKfEI289BQY2jqhoXs3WLXvQVt3mDi3qBVv2eqvrHItkzKScDbkPE6T/d7pW2fhf/eSMCeyNbeFDaVNszG1AadPszG1pr114Z6OjYkx5ADMOtq6Ys9qtQb0T5L6I8D/13LQbXbwyaXfDNt8pmSlIDY1TmxxaXGISY1FXGq8kNDxOTtSmOqboLNrR3Rr6o1ubl3og8KDPiYM6h2wemHySq+aRe1Xr8Ui8EYcIujFLLYosv2IThHHkdFpQgJTup08lwgwo29nY4LGtqZic7Ar3PO5s4M5OpOU2NREPb/as+KjyCv3IrLiopAVH4ls2mfGRRQe07XspDg2kJUPiUSgDALM/BvQxwFLhg2sGz84trKHefP2MGzkWKaNOhRkkBrNj6QtdxLuIiolGlHJ0YhMjio8pnN+WfOLXZJEoDQCLBG2M7OFHX0g2NPe3txOHHNZUxs3tCU1bF3Y2JWe16POlYLJe9Qk+XpaejYSkjKFBCcnNx9iI5Uvc92aRPGUWWTOwv1YtmAArCiOmyYRS2/1eNMr3Bsa6JCK3whaUl1Z7mPAEpwcYvTyc7NxL5ekOHk5KOBj+qjSNMpJTcSVH+ej7WuLoGeqOR6YLLXVItWklo4eGuiyJFevSLqrac9AZdbL75OE9ERwBoIcIcXJIe0BS3M0j/FLJBXkgr8WYuHQBbA0Mq8MfGpRh+M76mnrkZOoLu1ZkqsLc0NzmBo8fsaj+gBIZaxRTchJgzdNp7uRyQi8Hgt3CkvjaK85PzxNv+/VWT+rZllSIwnIjA1H2u0g4QVqaOMgIZEIlIsAv+CtTBrCCtKjPTwpEsHR19GaPJUdLOT/I+U+MCpQKC22VeAmySlKBCQCEgGJgERAIiARqCoCksmrKmKyvkRAIiARkAhIBCQCEgEVQEAyeSpwk+QUJQISAYmAREAiIBGQCFQVAcnkVRUxWV8iIBGQCEgEJAISAYmACiAgmTwVuElyihIBiYBEQCIgEZAISASqioBk8qqKmKwvEZAISAQkAhIBiYBEQAUQkEyeCtwkOUWJgERAIiARkAhIBCQCVUVAMnlVRUzWlwhIBCQCEgGJgERAIqACCEgmTwVukpyiREAiIBGQCEgEJAISgaoiIJm8qiIm60sEJAISAYmAREAiIBFQAQQkk6cCN0lOUSIgEZAISAQkAhIBiUBVEZBMXlURk/UlAhIBiYBEQCIgEZAIqAACkslTgZskpygRkAhIBCQCEgGJgESgqgg0uEdU1Ub1VT88MgWnfcMQE5eOtIwcpGfkoqBAZaZfI7Bl5+ThnF84ung6QF9Pp0b6VJVODPR1YGKsB1Pa2re2hWdbO+joaKvK9OtlnnmZ6Ui86oP0iBDk03FeZhru5efWy1zqc9D8nBwkBV2ARauO0NbTq8+p1OnYDbR1oG1oAh0DYxjZOcGyrTd0jc3qdA6qNlh+QT4CI4MREH4ZqVlpSM9JR1Zulqot47Hnm52XA987fujg7Al9HQ36zaABjPSMYKxvhIbGlujk0gFOlo5o0KDBY2NaHx0oNZMXl5COnfuCcPzsHfx37jZCw5LQ0MIQ9o1MYGSkB37pa2mpJvCPc7OZL1fVB+5x1p2Tk4+MzBwkp2bj9t0kGBvqoWtHR/Tu4oKBfZqii5fj43SvFm3v5ecj+sw+xPmfQHzASaRcD0ADbW16wTtDm170OvoGaKCjqxZrreoi7hUUoIGWZikv7uXnIT87k5j7DGTG3EV+bjbMmrSBVfsesPLoAbsez0BLQ5+H4s/P5fCrOBh0BKdvnsW50PNIyUqFo6UDzA3NYKhrCD1icjTx/9yCewXQaqBZvxlecxb9TjJzMhGbFof4tHjYm9uhm1sX2rwxuN0AcV78+VHmY6Vl8vYdvYEJs/+EjrYWvDs4opOHAzq2bww3F0uN/LEp80NUH3NLTsmC76VInPcPx4WACPhdicSrL3XG4g/6w9BQM5mYzNhw+C6aiqRgX1i26gDLlp60dYB507bQ0tWcL/H6eB5VYcyCvFykhAYhMegiEoNpC7wAE6dm6PDhGpg4NlOFJdT4HHNJqr1433J8e/hHtLJrCQ8nd3g5e8DTqT0sjCxqfDzZoWohwAKV8MQIXAzzh39YAHxv+yElMwXLx3yFYZ5DVGIxSsfkZWXl4v0vD2LFunOY9mJnzJxM6gWpklOJh6k+J8nM3txP98LC3ABbvh8Fd1LnahJFHNsF/6UzYeLcHO6vLoShlZ0mLV+utRoI5KQk4PKqT5Fw9TzcZy6B0+AXNeoDOiQuFNM2zsTthDAseHYeujftWg0UZRNNQoClfJvO/Iafjq7CqA4j8OXIz2Cib6zUECgdkzdh1p84dOIWliwYKNVvSv3oKN/kUlKz8PHSwzh0/BZCTs2CrY2J8k2yFmYUdepf+CwYj2ajX0WTIRNJJSntFGsBZrXskiUVYQd/R/Cmr9F+1nI4E6OnCZSWnQ6vz7uhtX0rYvA+ELZXmrBuucaaQSAwMggf7VyIZjZu2DZtQ810Wku9KJWyPTQsEZt3BmCxZPBq6Xard7dmpgZY9vFgODU2x3e/nFXvxd5fHb+kr29aCsd+z8Ft6CuSwdOIu15zi2Q7M+f+Y+jj4GVc3/w12G5RE2jjmS3Q0dLFktH/Jxk8TbjhNbxG/jj48rnPcTj4GC6FX6nh3mu2O6Vi8patOk1ek3bCc7Rmlyl70xQE2BFnyviO+PFXH7BkT90p4dJp8hr1heszL6n7UuX6ahEB5wFjkUU2nVEnd9fiKMrRdQ55ja44uhLjvMdAV1sz7XeV406o9iyaNXJDz2bd8R3ZcyozKQ2Tx4b0a37zxVR6QWuKFxNLYcqjisrLq6tqZXWxtiH9W8KInC/WbvNTNXiqPN8bW7+Dbdf+MGrkUOW26t6gLp61ymKoTHMpb856ZpZw6DsC/DypO+3y3410UtcO9xqq0ktV9meqpsFVxvVO7D4eO/3+Ec4ZNb3emupPaZi8m7cTkJmVh15dXWtqbUrdzwkKCTP57Z1l5ngpMBqjpv5Wprw+C77732k07/4Nflj7eCrQulobO+p07eSES0HR9QlbnYydGnIF1u2718lY1R3kxvafsW+cF27+ufqRXWTGRoi6/82u/gs4PfI2zn/5OrLiIh853sMqHHvzaTGXrPjqP0f3KObanf1bEbxx2cOGUopr1u27ITXkqlLMpTYncZXsqTzIe5bjoKkq7b9yUNiEVWX+nT/via6L+lSlyWPX/eSvReBx91za91h9nb3lgze3zHmsPmqjMT9H+rr6uBZzvTa6r5E+lSaablRsGkxNCmPf1cjKlLiTaFrrJHIwcbAzLTPLsdO3IjdPPe1i6nJtNg2NEBaeXAZfdSvIToiBvrmVui3rsdbju+RNZETdeaw+aqpx5On9CFz3JRr3framuqy1fvQtrJGXkYq8rAwKnqy6DNCjAIpJiVFpOzz/sEuY/+cnIkjxo9aqDtdjU+PwxubZShubztrYClH0TCkrKQ2Tx1I8IwPNsI8oqEBNyw/Jw64p60NU2XnV5doM6VnKpHA86k4c3FZb31BtlqlvaYMeS/54rAC9SqXWoZALqkKK56iAgidDjZm8rLxsGOgaqMptKTPPe9V8pn6fsQlkC1WmP2Uv4LAlykyGegZKnRFFaZg8Zb6Jcm4SAYlA3SDA2RdMHJrUzWByFImABiHgau2iQauVS1UgoJFM3tFTIVi39SKu3YoTKbJsrU3Qy9sFMyZ0hr1tSRXqv4evYfMfAQi6EYd8Ci/QxNkSLz7ngWEDW5dIqZZEjiNryXHkyMkQ3CE1YU5uvkjB1pWydbz2chfK1NFQYM72bd/fD+8RHpUqbN26eDlg5NNt8P6iA4r7IspZnXv0j8lFZTdDE/DT+nM4fSEMiclZaGRlhH49m+J16t+K1JMKuhuZjL7PrcXAJ5phAG2LfziBpORMtHCzxtZVYzCfgk3/uScQu9aNgw/lwf31dz+wCrmxnRmGD2qNyS90gD6ljKsM7dobiN92XULg9Tjk5eXD1ckSQ/q3wMtjO4i0c9zHjt1XHrm2yowl66g+AjG+/yHkr7VIvR1E6dZ0Yd7MHc1GzYAF7ZnYJu+/t56Boa0Tei//q2jBWaSWvrH9J5GpgW3ttMmeyrxpGzgPeB42Xr1EPQ7q6/P51KI23A/TwM0XxZ7tAk1dWqDTvJ8QtGEZYv1OgGKGwNS1FdyenQRrj8rZNuakJiHk73WIOX8EmWIuhjSXdnAdPL5EH+c+myKySvDgEf/9LbamI6eL9YoJyT8SgVIInLxxGlvObsON2FtIzUyFjak1ujbtgpe7vwQ7c1uwjdvugH9FK84ry/Zuz7QfjE+GzseqY2uw+vhaCu3xGU5cP42DgYdFztlx3mPxSs+Joq52A22cmX+saFRu39y2GX4YtxxfH/gep2h81ri0tGuOid1fRLem3kV1+WD6r2+IfLYH3v4Hv53bjr/99yA5MxlODR0xosNQjOo4olJp0PIK8vDHhV34J2APQuJuU7bYBmhi44ohtBbuR0er8P2jWBOPHZkcJdbAuXRXTljBRZIqgYDSOF5UYq41UmX/sRuY/u5f8KEMCc2J6enbvVBqsPnPAIycvAWx8elF43y0+BDe/HAPfC9Hol2rRiK1GjNa7362H59/8+CHwjl2R7yyGT9Slo6MzFx07+wEZu6ys/Owi3LvsiNFZHSq6LdlMxv0pzyrTOwBOnRAK/To7AJnBwtxrJCmc3n/Ps1EPf5z/OxtMQb319DSEP16NIG+ng42bPfDCJo3M5al6eq1WJrrPmH719nTgZg40xLZQ7793xmxDjNTffTu5orEpEwsX3UKk+fsFExq6f6KnxcU3MPsj//F3IX7wA4VXu3s0JucZmLi0rDs51N4fsa2ohAmj1pb8X7lsfoiEHnyX1xc+hZy05Ipd2p36JpaUH7dUzi3cDJSbgdXuHBmqph5Cz+6U6Rns/HqTWm4miAu4DTY/i786C7RVs+8Iex7PE05egs/eBp16ivOi3ecl5UJZr6izx2CZQsPmLm2JkbMFxcWv4GwQ9uLVy33OCM6DKfmjUXoP+tRkJONRh16w5SyjCRcPosLX72OGztWFrWzcu8KCxqDybCRo5gL15UkESgPgSNBx/D21vdw8Y4/mto0Qc/mhR8dOy7sxMRfpiKOcqi2d2yHrpRDlamhsSUGUR5VLitOPx5ZJRg87yadqU5DNLF2LX65zDHnaJ2+YSaOBB2lvtwpvVsLMYe3tswlRqyscyB3sPDvL7DmxDo4WNjD262z8C5dsnc5Fuz8rEz/pQuySV3+xqbZWELp5O7Eh6GTawd0dPVCKGUgWbz3a8z+7V1wujmmZsSAPtGytzjmHMK8Xh5PUuURqJy4pvL9KX3NL78/Tl8aDfDXuvFo6looXcvPL8AcSom1++A1bCFm780p3cC5c3/beQmOjc2w/tvniAkzF2uLjEnFmGlbBXM1dGBLeLa1xwqSzN2NSMGksV6Y92bvohAwaek5mEIME+dW/fPfQCHRY+la+za2OHDsJiwpBdeyTwYVYcaM2O5DwcjPv1eiPD4xA7MX7EFubgF++GIIBtxn/tj26Kf1PoIx45Re21aNLeqLD8IiksWcPnir0KOKGbPidJgyi3w0+wlMGO0pilkaOWnWHzjre1dI96aM61i8eoljZi7/ORAsJJu/LB8OR/tCfHjNzPyxtHTB4sP45rOnweuqaG0lOpUnao1AekQIWo5/uyimX0F+Hvy+mYvYC8eEB2q7qQvKXX/YgW3CkcJt+BQ0H/N6UZ3Yi8cFk3fjj5VweGIYqXnd0P71RWDP3ExyHmj10lwY2jQuqs8HmcSksd1f9y9+g3FjV3Et7tIZ0Q9L96w9e1aYEo5/b/7fvgd2dnHqP5b6n1NkO5h88woxeW/g5o6fSTrZDjYePdCU5mtobY+ka/6US9gL7jMWivHkH4lAeQh8e/AH8e7YNHUtFKrVfPLOXkCZFfZfPSQYrml9JsONmLYzt87B1coFnw0v+5vhXKvrJ68maVwLMcyjbNruJoYLieHGqeuoT2fRhr1ZZ299V0j3ujfrJqSIxed86uYZLB61CH1bFb5bIpOiMIMYxX1XDlBZbzzZum/x6iWOmQm9cPuiYCiXjfmiKEdwQnqiGJPX9vOx/2Fmv1fRj/pv27g1jgb/R/XMy11vic7lSRkENE6Sx5I6HR0t2JCqU0Ha2lp4e3oPfDK3L6k/3UQxS/aYmAlSMHh8bt/IFG9M8ibVpxVC7yRxESwtDEmK5YKZU7oWMXhcbmKsR6rLlnyIiOgUsa/On+1/XxFq5ZdGeRQxeNwPxxNkVbB7K1tcJGnjxUsRZbqfOMarqIwDBRenJ0iKqWDwuNzCzAD/N6+/qMIM7sOI1d1MX83vX8Tg8Tmv+WtiXNlTeg+puiOiqr9u7k+S+iDAqtniQZu1tHXgMmi8WGDanesVLjQ7KU5cM7CyLVGH1bRtJs8nxnF2lTI1tJrwThGDxx1ak8SNsz4U5GQJlWqJQYqdJAZdQEpoIIzJZrD1xHeKGDyuYt60LVq+OFvUDv3n12Kt5KFEoHIIsKSO1ZRWJoXCB26lTSkKX+07De8NnoNeLXpUqiNP5/ZFDB430Grw6Nf8nAFvFTF43IalZax6ZambQj3M5Qoa2WFYEYPHZfYWdnh7wJviMkseK6IschTj67yuRSM+KWLwuD5LJrmMVcq/+/whxq6oH1leeQQeffcr35dK1GSJUhapUUdO/g0rKO7bZYqlxl/ozMiNH+lBallbcc62arq62sJWr/TCxg5zx+6NL2H44Nbi0lsk+Vvz9QiYGusXVWXp26nzd3Ce+mFiKVx16YxvmGjq3dGp3C56kj0h07mLhWMpKrEa1sHeTHFaZj/kqcIvveIXWje3Eerd23eTwGFtyiNWPd+NTIFdIxN4uZeUlHB9UxNS/5LqlmAVNn/l9SHLNA8Bi+btyyxawbjlUuiOisiyVQdxKejXpbi8eqGwheMwH0xOT46CnXd/SudWuf/KtCimVaOOT4i2xf8oyhIDLxQvLnHMal0m285Plps+rnAe2iS58yOmM79EW3kiEXgUAl7OHoKxmbhmKv53fB04Pyq/mxwtHQTDxam0KkNsY1cV0tfRQ58WhXatxdv1adFTnLLtX2ka0ObJ0kXo3qyrYFL9wgLIrq/89x2viRlHd4e2ZaSD3CGvtU3jVsjMzURgRFCZMWRB1RHQOHXt5+89iRnv/U2OArH4dvVpsVlZsgNDEzxPzFv7NnbCqSGXHCfYCYMD61aGmCnauMMfvqSavXUnEay2ZFLY2N1DSVVpZfpU1ImMKWS2ZpAt4cOIVcnFiZm8h5Gzo0W5l3nd7BQSQ0yenY1JmTrRZHfH5PgQBpLzxzLFJhS+jMWJ/KPRCOgYl3RqYjBYmsf0sJyp9t0HIfnmZdzeuxnhR/4UWwNq17B1R9h3Hwz7Xs8U9SM6e8gfVp+yB29pUjCbWYmxpS8VnWffv1ZaBayowCFIOHMESx5z01LEseKa3EsEHoXA/GfexZxt83At+jpWkrqSN5Zu9Wreg5wRhgm15aP64OtmBhV/2JfX3s7cDjr3f4fFr9uaFUrOOU5daXIkR4vSxCni2AYwJjUGyRnJsKS5lyZFX/bm9qUvFZ03Jjs/zgcbn55QVCYPqo+AxjF57EG6c+04YXd28PhNIW27EZKA30kluv2fK1jwdl/hlVoVSP/aHyQcHNiWztXJAn1IitW0SUPKw2tLDhdpYAeOxyGFLd1TvdzIWUOvwq5akVNHcWLbw4eRdin1raIuS+CYWI1dHimul3dNUcZ2jkx6JA2VJBFgBBpUQm1UEVJsX+c88AXhMBHnf1LYucWTswNvd4/tQuf5K8tl3sr0V4HEjyUmTA1IjVQRVeZDTcGsaulW/DutqH9ZrtkIMLO1YcoaXAi9iGPXjuNcyHnyPA3FLkqb9ZffbswdNAtjOj33SJAe9f9+6Q4qUucqnndWrZYm7Qp/y4W/I61y2hT28WhhR/59KaDMK1wa9eqdaxyTxzCxbVo3SnvFGxOrJTdQGJFVG89j6U8nMPrZtiTB00IcSaHyKPsE2/AVp0QKR7L3yHW0amqNFrSxg4EWvTxWLh6CPt2aFK8qHBhKFFTjhO0HQ0g6OJkcITp5OFSjh/KbcNiU8ij8vh0dq2PLI1trY1EcRs4mFZHimnWx0C4V1ZXlEoHKIMD5eZsMmSC2fPJsZWbv6ppFSAq+KJg/lvg9ihTSuNL1FCnQFBK90tf5nB02mDjMS3mUl5mOnNREaFFwVB3Dwt9IefVkmUSgIgSY4ercpKPYuE5MSiy2nt+OX09twg+Hf8ZIr2EVNa12eVxaWUkdd8YhS5hszRqJffE/MSTdKy2py8nLEdI39oI1NyxfmmhtYi26iUgq/zfEF9lxhMmKpIKSHh+BktzL4/en1D2EhiViyEsbhcdr8YmySvKd13oKB4r0jFykpeXAnaRwrLI9TXZ1pYlj4TFjx+FMblBIlfSMHLRtYVOGweN2nKOWqbiJAjtMVEQcL6g0dfYsFI0fOx1a+pI4f+/z/Rj5yhYcIslkVai8/q4ExyCK1MNsm8dq7PKIpaEcw4+ZxPKcPVLTssW6mZlmG0gFlbc2xTW5lwhUhEDAjx/i8PS+yIwvfOlwPW09fbKN64fGvYaIZlnFrpX9BT3omdN2JZLNXGmKuXBUFFm7dyt9qei8YauO4jja51C5NnfRZw/SD/2eUCMXNSrn9/zgmjySCBQicCchDC+smggOW1KcGpnZCC9TCyMLZFCok5Ss1BLOfcXrVvc4NSsNnCqtNP137YQoKi9kCcfTK00nqIy9gb3dOpW+VHTO9nacbeRyxFVE3Wciiy7Swd2EcARHXYOJvglaUKw+JvneEDBU+49GMXlsJ8YOERxz7gDFyytOzIxxnDhmXjiw8HgKeMzE8fCKOyCw3Rvb8jGfNnRgK+Fty/Wuh8SXiFXH6kqOm8cMIVN2Tp7Y8x99vULxNzOUCjWR4qK+fuE1ZpQUNHZYOxga6GDNFl9wnL/ixIGG//z3KoIpsLNHW7vilx55vGP3VRw7XTg/rszYzPu/A6LdyxQO5mHEwY6Z3qMAzhx8WUHM8HI4GrZJ5HAxNlYPJBrlrU3RTu4lAhUhoE/x73IpVt61zd+gIC+3qBo7a4iAxlRi5ta2qFyLGECmipw5Atd+gZyUxKL63EfYwe3QNbGAfc+ni8pLH1iSDSAHTk4PD0Hg+iUl5pJ8i36DND8m5wEPQhlp6RWqbfMyypealx5DnmsmAg4WjcEhRDh8CIcLKU4cziQpI0nkbmUbPT1ylGBKy04vXu2xjr/au0yMoeiEgzKzF6y5oTkGtxuoKC7arz+9STiGKAo4DMvy/d+J0+c7j1YUl9kzgzfCa6hgBuf/+SmN+eDdkUjrn7/zE+G0wQGRFepaxXozcjLKvC/LDCALyiCgUepatjFb+E4/vP7BP3ht3j8i9Ah7n3JYFV8KP6Kt3QAL5vQVIHEw4pPn7uCPPVcx8Pn16OLliALKeHHeP0IEPH51Yhd0uO9Z+syTLSi+3TWSEm4Q9VjVG0ABgmPi0tGMbPPY5i82/oEDAocq4Y3j0nHQYJYaUVwEDAAAQABJREFUfjjrCTGuCzlDcBDjca//juZNrCgcCRmWU9iWrz4cgDmf7MXrNG8O3+JKmTfukLMHZ+JgidnSBQNh3fABQ1XmTpdTYE1q4KlzdwkVsAXF7OP4eCmp2ZTNo5XIwFFOk6IiDr1y8XIE9hy6jkEv/CrWbUCMKOPDzHIbkmx+SlgXp/LWVvy6PJYIlIdAk2GTEX3+KKJO70NikC8xdG1wLz8fSdcDkJdOXt5dB8CqbeeipkZ2zkgLuwH/b94RGS7aTfsEOkb3TQ/o64wZvONvD0NDasPMYyKpe7XoxdluxqfQowDNFRFL4D1mfgmfRdMQdmArYn2PiUwXOWlJSAq6KKR7biOmFmXg4H6MaS5MMRQL0JcCQXMgZ6cnH21XJRrJPxqDANu9zXt6Lt79fT7e+f0DsCdtYwpLEpcaj4C7l0VYkXcGzRZ4NCaGkOuzgwYHFe7g4ikyWlQXLJaUMRM58sfn0dGlA2WwSIEfBWTWIwelj4d+IOLTle7bWM8Yk9ZOR2fXjsJpwyfkgvCafaXHBHR0LRQAlG6jOH+t73QEkbTuInntDv9hDDiDBZMvxc5LJ0aOgz3P6DNFUV2ofln9y/Oasv414X3LIV8kVQ4BjWLyGBLOIsHhTtZt9UXA1WjhZcsMzsAnmmP6S51ECBUFdF9SDDhvylzBMePOXbxLQYoL0JJs8F6keHUjBrdRVMMXVM/NxVIEU+aUY+yR25TOmREcM7Qdug9ZBT+KY5dAzE9DiqnHL4slxJR98d1/uBQUIxhABZP32btP4sOvDgk1cExsumAEmSEc3K8FmElavekCMWNhCDmZBBuSOLK0jNOxceiXqtLsad2FypXXx1krODj0+JHtMWrIA6lIRX0yY/nNwqcpVMpVbPvrsmCS2XadHU+mv9hJYMQZOYpTRWsrXkceSwRKI6BnYg7vBWtw88/VZId3Smwix61jUzj0GQrHviNLNGk5bpZg5FJIupZD2TUy4yIoK0ULUYedP7w/WYfgTV+DgyBrkUcgZ8ZoOmIaZb9oWaKf8k6M7V3QbdEWSmu2VjBuMcTo6RqZUhDlHhTzbxys2nmXaMbjNn9+JnkGb0E8jadrbCaZvBIIyRMFApzZ4bsXlmHzua24GhEomDiWpPVr3UekGFOEUGGGZ/4z72H1f7+IFGOcIozTllWX2A5wzcSf8c3BFThLkkQd+k30adkLU3pNEunNyuv3oyHv40zIOfx7aT+yKNwJZ8kY3/X5ErHzymvHZQYUxuiH8cvx+/k/qf1e4WDCUju3Rm4Y6vEMhnqStzzNSUH8vvx02EdYTmnXOARLPMUTlEyeAp1H7xuQupBezfVPO0hi9vr83Tjx19T6n4yaz+Ddz/eJ3LUs/RtGuWrVkX6gGIj+VyJxeOvL6ri8ojX99aQFunz4P5FRoahQHpSLAOeuZe/ZAeRgJaksAumRt3FiznAM2hkCPXOrshXUpGTyr69BnxiNuQNnqcmKqr8Mzl1bOp/tw3pT5K5dPeEHeFJcP0nA+NUvY1qvVzCJ8gsrIz1gl5VxdnJOEgGJgERAIiARkAhIBCQC1UJAaZg8jtmWS+FKJEkEagKBPFKta1cQE60m+leWPlgyxTlgJUkEHheBe/efowbaZeOiPW7fytSeJVes4pQkEagJBPLIPpifKWUlpWHyGlHsNXZEUATRVVbA5LxUAwH2FC4vW4dqzL7ys9S3sCbngQeeopVvKWtKBEoikJ2cIBxQdIzNS15QszMbU6sSXp1qtjy5nDpGICEjETam1nU8auWHK2kZX/l2NV6Tc8dyZofgm3HkmVk2+GKND6jBHS7+cCB4U2cKuh6HweSUou5k2MgRKaHBwsNU3df6uOsbuPni43ah1u1TbwfDgAJOPyyOpzoAwPlR91zeL0J1FDfwV4e1VXUNPh+eqFKTlRNWVKm+uleOSo4Wnsn8TCkrKY0kz9HeHIPopfzLb4VJwJUVMDkv5UeAw+H4X43CpDGFrvnKP+Pqz9BlyCTcPbwDeVkPQvRUvzfZUlMR4PiDt/dtgeuzr6g9BKM6jEB0SgyOXz+l9muVC6xdBDaf3QpPp/Zo1/hBtI3aHbHqvSsNk8dTf5+yTvxzILhEcN2qL0m20HQEVpP35HNPt6EYherrIai4x45PjYG2gRHuHvlTUST3EoEqIxB1Zj84YLPLs5Oq3FbVGrBq7UXv50WqMCUJLqFqEMr5EgIcyHmX3994q9/rSi39Viomr3dXF3SkAMOfLjuC4hkf5BMlEagsApxq7uDxW/TB0KOyTVS6npauHtxGv0Fx29YhJSRQpdciJ18/CKRRBo8bO1bCddgUEcevfmZRt6O+/sQ0XKHUWlt9tsssCnULvVqMlpWbhaX7voGdmS2ecVdu0yelYvLYFmTtsmEiU8TQiZsoe0K4WjwQchG1jwB/FMxduBcfUFq2bz4ZVJSNpPZHrv8RXIdOhq33AJz5eCIxe+sp84L0Uq//u6L8M2ApVtih7Tg9fxzMm3ug+QuaEzfOxcoZ341dip+OrqYME/PAKbUkSQQqgwDn1p2wZgqCIoOx8sXvRfaRyrSrrzpKEwy5OACZmbl4l17WP23wIbVbW/To4ixSb7EHriSJgAKB7Ow8kT6OPwZ+//syTIz1sGXFKHi0qVoOX0V/qr4PP/IHAr5+C8YObrDvNlAESDZxbEYBgJXqW07VYVbp+TNjlx4RQunhLiLa5xCSgv3QbuZiOD89QalVTrUF+s3YEEzb8AbuJoVjZIdhZF/lAXfHtpSVwaC2hpT9qiAC/BHgFxaA86G++PPiLoz0Go4vRy6EmYGp0q9GKZk8BWp7j1zHz5TG6/jZ2yIlGKf16tDenkJjmMLYUBdGRroib6uivtyrMQKUlyU7Jx/pGTlIIandFUoHx84VBfTS8mprh8F9mwubTkN6LjSZMqLDcG3jEsT7nUD63RvQoTRali08YezoBh2y3dMxMEYDHaVxqtfkW1Una+fYd+yUk09bekQoEq/5IZdy9xpReraG7Xugxfg5MHFqXidzUdZBcvNz8SNJ9PZe2S9e5Px/Smv7lpQjtbV4iRvqGQqmT929jpX1/tT1vAruFSAzJxMZtHEKNf+wSwiNv03Pghm8m3TCuC5jRPq1up5XdcdTaiZPsSj++gy6EYf/iNk7dT4MMfHpSEvPQRq98DnsiiYRY5FDzI6enrbGfXkbGujAxEgPpib6JK2zRa8uLuhKuYWNqUxSWQSyE2MpX+ppJFw6hfTwW8jLTBPG9ffIk1LT6B7oX24uGujqUjr2Bhqz/AbaOtCh3Lo6hsYwtHOGlXt3WLXvDgNre43BoCoLZVsr3zt+OE05XAPuXkZqVirSczLEC78q/ahHXXrX5OVAT4f/f9Wg3wyZjRnrG8FEzxgNjS3RyaUjujf1Rmu7liRUUj2tiEoweerxg6mZVdyNTIZTl+UIOzcbHHZGkkRAIvBoBDJjw3FgTGv03xYIQxvljWn16JXIGhKBukEgPCkS7Rd2QcCCc3CwkB8FdYN6zY+iemxpzWMge5QISAQkAhIBiYBEQCKgdghIJk/tbqlckERAIiARkAhIBCQCEgFAMnnyKZAISAQkAhIBiYBEQCKghghIJk8Nb6pckkRAIiARkAhIBCQCEgHJ5MlnQCIgEZAISAQkAhIBiYAaIiCZPDW8qXJJEgGJgERAIiARkAhIBCSTJ58BiYBEQCIgEZAISAQkAmqIgErFyQuPTMFpXwqGHEfBkCkQcnpGrsYFQ87OycM5v3B08XSAvp5mZS4w0KdgyJS6zJS29q1t4UmZLnR0tNXwZ1lzS8rLTEfiVR+Ryiqfjjkg8j2K8K9plJ+Tg6SgC7Bo1RHaepoTPJuDIWsbmohMJ0Z2TrBs6w1dyoIiqWIE8gvyEUh5SQPCORhyGgVDTgcHSdY0yqZAyBwYuoOzJ/RFQGTNQICDpRvpGYmAyIXBkDvAydJRZZMPKDWTF5eQjp37giit2R38d+42QsOS0NDCEPaNTCilmR74pa+lpTmRuBU/Mc56oYkpdjjTR0ZmDpJTs3H7bhKlttND146O6E2ZLwb2aYouXo4KiDR2fy8/H9Fn9iHO/wTiA04i5XoAGmhrw4iyHWhTSjMdfQNKa6aZqd/uFRRoXB5fTmuWn51JzH0GMmPuIj83G2ZN2lDWix6w8ugBux7PQEtDn4fi/0lcDr+Kg0FHcPrmWZwLPY8UynThaOkAc0MzGOoaiqwPmvh/Lqf40mqgWQo/XnMW/U44tVlsWpxIbWZvbodubl1o88bgdgPA56pCSsvk7Tt6AxNm/wkdbS14U+qqTh4O6Ni+MdxcLDWSwVGVB6qu5pmcQumHLkXivH84LgREwO9KJF59qTMWf9Afmpq/lrM6+C6aSknnfWHZqgMsW3rS1gHmTdtCS1dzpFd19Qyq2jgFlM4uJTQIiUEXkRhMW+AFylvbDB0+XAMTx2aqtpwamS/nrV28bzm+PfwjWlHaKg8nd3g5e8DTqT0sjCxqZAzZieoiwAKV8MQIXAzzpxy2AfC97YeUzBQsH/MVhnkOUYmFKR2Tl5WVi/e/PIgV685h2oudMXMyqRekSk4lHqb6nCQze3M/3QsLcwNs+X4U3Emdq0kUcWwX/JfOhIlzc7i/uhCGVqrzpalJ90mZ1pqTkoDLqz5FwtXzcJ+5BE6DX9SoD+iQuFBM2zgTtxPCsODZeZSftKsy3R45FyVEgKV8m878hp+OrsKoDiPw5cjPYKJvrIQzfTAlpWPyJsz6E4dO3MKSBQOl+u3BfZJHlUAgJTULHy89jEPHbyHk1CzY2phUopXqV4k69S98FoxHs9GvosmQiaSSlHaKqn9X62YFLKkIO/g7gjd9jfazlsOZGD1NoLTsdHh93g2t7VsRg/eBSESvCeuWa6wZBAIjg/DRzoVoZuOGbdM21EyntdSLUinbQ8MSsXlnABZLBq+Wbrd6d2tmaoBlHw+GU2NzfPfLWfVe7P3V8Uv6+qalcOz3HNyGviIZPI246zW3SLYzc+4/hj4OXsb1zV+D7RY1gTae2QIdLV0sGf1/ksHThBtew2vkj4Mvn/sch4OP4VL4lRruvWa7Uyomb9mq0+Q1aSc8R2t2mbI3TUGAHXGmjO+IH3/1AUv21J0SLp0mr1FfuD7zkrovVa6vFhFwHjAWWWTTGXVydy2Oohxd55DX6IqjKzHOewx0tTXTCUk57oRqz6JZIzf0bNYd35E9pzKT0jB5bEi/5jdfTKUXtCZ6MSnzQ1J6biw9UmYa0r8ljAx1sXabnzJPs0bmdmPrd7Dt2h9GjRxqpD/ZSe0hoMy/Gz0zSzj0HQF+ntSddvnvRjqpa4d7DVX3pWrs+urqtzax+3js9PtHOGcoK9hKw+TdvJ2AzKw89OrqqqxYiXm9+/k+NO/+DXbtDSz3XBknfzcyWcz5ydFrH2t6qWnZWPj1UfxFYW2UmdhRp2snJ1wKilbmadbI3FJDrsC6ffca6au2Ormx/WfsG+eFm3+urvYQ7BHKfZz7bEq1+6hOw2NvPi3GzYqv/rN0j+Ku3dm/FcEbl1VnCnXWxrp9N6SGXK2z8eproKtkT+VB3rPG+kb1NQU5bjkIfPLXInT+vCf2XNpXztXKF5295YM3t8ypfIPHqMnPkb6uPq7FXH+MXmq3qdIweVGxaTA1KYx9V7tLlr1XF4GvVhzHhu1+yMtXfrsdm4ZGiIxJq+5SVaZddkIM9M2tVGa+mjjRyNP7EbjuS+Smpyj18vUtrJGXkYq8rAylnufjTi4mJUba4T0uiEraPjY1Dm9sno3b8XfqbIbWxlaIomdKWUlpUiawFM/IQPXsI+bO6InpFOqlkY1yu1HXxANYoORq2uJrNKRnKZPC8ag7cXBbbX1DdV+maq+Pwi6oAimeowIKngwD9ZVyZeVlw0DXQBVuiZxjFRHgECd1TYZ6BkqdEUVpmLy6vjE1NV4ja2PwJkkiIBGQCEgEJAISAYmAMiEgmbzHvBtso/fnnkAspbAvwwa1Fr0pynZveBH+gdHY8LsfbpHNIadi6+3tglnTusHR3rzMyP+dCcUvW3yFLVl2dh5cnSwxfHBrTBjtCT3dB7HPzlL+3hff2IGJYzwxnMb8ktSol2gcdjbwptReMyd3RVPXhmX6L6/g+q14rNzgg9MXwpCYlCnSxnXr5IwZEzqX6IPtEBX0/qID4G3jiucoG4mToljuJQJVQuDOgW0IXPsF9MwaovNHq2Hi4CZCeHD53SN/ICMqjK5ZwvGJ4bBo6VVh32nhIbi1aw0SLp9FTloyWO3YqGMfuA2fSqrskr8DtuszdWmBTvN+QtCGZYj1OwEaFKaureD27CRYe1TOvjEnNQkhf69DzPkjyIyLFNJU86bt4Dp4fIk+2IaQM0swRfz3t9iajpyOZqNmVLgeeUF9EDh54zS2nN2GG7G3kJqZChtTa3Rt2gUvd38Jdua2mLBmCuXJDcLGKb+gpV2LooVzoOYxP1Nwavq3/+2/S2TfOH79JN7e+h7Gdh6FuQNniTbRpC7kIL1nbp1DVHI0OP+utamVSMP1Ss+JaGRmU9Q3277tDvgXK19aAQ4lcy7Eh+wTjfF63xno5NoBw1aMRv82T+KNfjPww+GfcZauc2aQNvat8eZTr4nYghduX8SqY2tEjl9TA1N4u3XCm0++TvN88F6b/usbIvftgbf/wW/ntuNv/z1IzkyGU0NHjOgwFKM6jqhUyrS8gjz8cWEX/gnYg5C42wKTJjauGNJ+sOhHR6uQjeH5rD5eaHcemRwl7Ps47+7KCSuK1q6JB0pjk6eO4H+z+jQ++L8D0NZugN7dXKFN4T12kdPC8zN+R2p6doklr1h7FpPf3olzfuFo4WYl6sfGp4Pt4CZTerfsnLwS9fnk2s14jH99O26EJKAXMY/WZIe2+9A1jJ72GwKuRpWpX7rgwLEbGP7KZjGnhpaGeKp3U1hSbuCd5FQygsqZ6VTQ0AGt4OxQ+AP2amcPPrdqKCWYCnzkvmoIRJz8l+zUvoKuqQU6zV8pGDzuIeDH+Qha/xWF84iEtXtXGJLX8I0dK4VNW3kjxAWcxpkPxyHyxG7oEUPXqENvaJMh9J199ML7cDwyou+WaZaXlSkcOKLPHYJlCw+YubYmRswXFxa/gbBD28vUL12QER2GU/PGIvSf9SjIyRZjmlKmEWYyL3z1upivoo0VrcGCxmAybOQI+x5Pg+tKUn8EjgQdE8zYxTv+aGrTBD2bF35A7LiwExN/mYq4tHgKwdFNAHEu5HwJQHxCCj8M7uEeuH1xOnXjjDjl8B1Mt2JDMH71JGw5t43eMdro1tRbpGdLTE/CDt+dmLxuBnkTl7WzXLT7KwTcvUT1uwr1dUu7B89lRFKEYEAv3PETad5sTG1w/rYvXt3wJv7w3YXXN84ihi2FmLvOyCb1NzNws36bK+ZT+s/Cv7/AmhPr4GBhL+pzmrAle5djwc7PSlctc859v7FpNpZQ6rk78WGCCe3o6oVQYoIX7/0as397VzCg3LCZbTM80bK36IPzDQ+iHLM8P00nKcmrxSfg6KkQ/Lx4KJ7s6SZGYcZuzLStgin7e38wxo1oL8pP+tzBt8QQNrY1xf+WDUdzYvKYMjJz8fbH/4oMICsouO+cGT1EueIPS984r+9PXz0LU2N9Ufz9L2fw3f/OYD6lhtu1bjw4blx5FBOXjjmUBiwvr6CEFJLr/v7PFcz/4gBmLdiD/b9NJObRGMs+GYQPqOxOeDLGDmuH555pW163skwi8EgEYi4cxeWfF0DX2BSdPvgZppQ/lSnq7AFEndoL48ZN0PnDVUIix+WcduvC4pl8WII4LZf/9++jIC8PnrOXwbZzP3GdwyewZO/Gth9wiZhG70/Xl2iXSUyavqUNun/xG43lKq7FXToD3yVvCumetWfPCtPCcd/+374Hdnhx6j8WrV6aAy2dQlvi5JtXiMl7Azd3/AzzZu1g49EDTYdPgaG1PZKu+VM+YS+4z1hYYi7yRH0R+PbgDyIc2Kapa+Fq7SIWyhK2BZQpYf/VQySd2okexPix9Mkn9AJe6jauCAyf0PPQbqCN/Hv5QhrWt1Wfomunb56FkZ4hmNlh+u7Qj0JC9vaAN/FClzFF9RLSEwWDdzcxHP9dO4HB7gOKrvEBX98ybb2QKLItm1YDLUQkRYo6VyIC0dWtCwWL/oIYQH1ytsvD1F9fw+Xwq/hizxKS+k3Hyz0KY3PGpyWQ1HE8uE1w1HWSSD5gFrmzUzfPYPGoRVCsITIpCjM2zMS+KweorDeebN1XjFnenx+PrAJLDds7umPZmC+KJJo899lb3xWSy5+P/Q8z+72KfoRR28atcTT4PyFR/Gz4gvK61LgyKcmrxVs+uF+LIgaPh2FGbPjAQpXujZD4opHXbC78alvw9hNFDB5fZPXronlPwUBfBxt3+JeR5umSCnfZx4OKGDxu88Ykb7RpYYOgG3HwvRTBReXS1l2XRMia0c+2LVIzKyqOHtIWIwa3QWpaDn7bdVlRLPcSgcdGIP6KD/y/e1+oNzu+/yPMXFoW9Rl2sFCK1mrCO0UMHl9s2KYTXAY+X1RPcXD36E7kkccqB/JVMHh8jeNsMnNl5tYGSdcDBIOlaKPY8xgKBo/LWGrImR8KcrKESlVRr/Q+MegCUkIDYezQBK0nvlPE4HE986Zt0fLF2aJJ6D+/lm4qzzUMAZbUsSrRyuSByQBL2l7tOw3vDZ6DXi16kAq0lfD09bsTIBgphogZLt/bfkIKxWrU4pI89hoNJylblyadiwI5s9qXGShW3xanhsaWRZKtqJSyIYBY6sVtmZjBK02z+r8hGDwu19HWISbqCVHF0dIBEyg+nIJ4fZ7OhdLqu4llJecjOwwrYvC4jb2FHZghZWKpZkWURU5lfJ0xWzTikyIGj+vz2riMGeHfff4Q0sSK+tH08rJ3VtMRqcH1e7S1K9ObtVWh1xpL6ZjyKRyJD6lomcqzb7OyNELblo2Qlp6Dq9diRT3Fn84ejcvkZ+UXnEJyeO5iYb+K+sX3ijGffvKBHUjx60OeKiz3uVj2R1u8njyWCFQWgZRbV3Fx2SwU0H/eLcbNgjkxYQridFqJwRfRgKRiDduWVbE06viEomrRPuFKoYqrYZuy9bmSIn5gAjFmxUmLJBPl9acoU9jQFW+jOGa1LpNt5yfLTSFn591flCdd8yNTv3xFM7nXQAS8iPFhdePENVPxv+PrhO0dS4KZSWJ7NE6Nxf9fs7o0MzezKD1WUOQ1pGSlCtUkM4HXo28gLStNIMhSMaZe91W/fPz+4LlCUlacUYujUCJsD3gt+jpXIQay8H0jTu7/aU7qzYrIWM+IVMxuJS6bGxaa63Cmh+JjcSVTfRNRN5uyiZSmAWTfV5q6N+sqGGC/sADB1Ja+zudsq8j4uTu0LWJGi9djHNs0biWwC4xQ7titxedd18c6dT2gJo1nZlKoQi2+Zh3tQr5aEY4kKTkLWeRkweTV/8fiVcscR8WkUpl9Ubmzo0XRcfEDe1L7MsXEFf7HUPya4jj6/jUHOzNFUYm9I+V/ZYqNL2vLUaKiPJEIVBIBVtM2IIkA0+09G+HQawi0dPXEeW5aEu7l5cLAyg5a9+uIC/f/GNo0Ln4qjrMSCu1OmXF8GJUOZMzqU4WKtXg7A6tCqUZWYsmPqeJ1su9fK28+XI/DkLCzSHZSHHLTUsRx8fbyWHMQmP/Mu5izbZ5gtFaSSpE3lkD1at6DHAaGCdUio8F2eewI4UN2ecwYnifVLVNHlw4iNAercpkZYps+tsdjZ4we9+3xREX6w2rS7Rf+ECrTuwnhgvHha1yXqbwMEOaGhe8JUaHUH3amKE2KTFQKZq/EdWJWKyJHcrQoTZxOrqFxQ8SkxiA5IxmWhEtp4ph3TPbmD955pes0Jjs/zh0bn55Q+pI8v4+AZPJq8VF4yHNfNGp+wT1xbGigg/69K/6y4kpsG1ec2JGjPFKEs9PSeoigtnDY8pqLMsW89PQeePVWWFlekAhUAgEtiifVYe43uLWTPGGv+gi7uWajXr3fsvxnWdFtA+2yzyFL/5hYAqf9kLhups6lpNUV/C4UL8IGpB6qiNgQ/lGkmJeCgX1UfXldPRGwM7fDhilrcCH0Io5dO05erOfJOzQUuygN1l9+uzF30CyM6fScsH1jlSQzc9P6TBZ7E5KMsW0bS/iYfMkBopNrR1Ld+qE1Sa+Kq4DXn9qIFeQFy9SsUVNh59bE2hXtSAJ2PtRXOD2Ii6X+NChHRauowurZmiLtCscp/C1pVfh7e/RvLf9+XDyZg7jiu1Vzd7LiMeSVhyBgYW4AXR0tEqffw+KPBpAn7kMYs1L9RFOWkPIoPKowsr69baEIvbw6HNvv1p1E3I1MgUs5EsEwcrBgYo9dSRKBmkDA9ekXYdXOm5weGgnv1Ft/rYVd1wEwcWwqvGxZjcoSsAKS6JWWtHF5aeJQKRmRt+H6zATh1FD6ekXnCmlc6etZFAqFSSHRK32dz9lhgykzNkLsS//Jy0xHTmoimKHVMSz5UVa6rjxXfwRYrdm5SUex8WpjUmKx9fx2/HpqkwhPMtJrGEwMTOBBjgUBdy8jldS0/mGXSIrnJWzRWFWpr6MnnA9871wk9WUOSf4KvWq5P/ZUZecEc0MzfPvCsiLpIF9j4nAr9U0xJJErLanLoXWw9I29YHnu5ZG1ibUoZk/fiojXz2RFUkFJ5SNQeY6i/Pay9DER4Ph3Hm3tkZubj1Pnw8r0xqFThk/ajBdepdhhlIO2OHG4ldJZHVgacfjELVGtZxeX4tVLHHf2dBDn/x6+VqJccaIo70Jx9xSkEP0rzuVeIlAVBBSSLRNyWmhCjBmrZ6+sXihi47EqiG3x7pEXX+zF42W6FfHsSpVatuogSsq7xhcu/fwxTlMYFVYTFydO3ZVINnOlSVHP2r0wrEXp63zesFVHURztc6hcm7voswdZN4aGrQvrFfbxcCllYR35V50QuJMQhhdWTcRbW+aWWBbHq2NPUAsjC2TkZArbO67AqliOB8cx9Vh618HFU7TTIwbP3aEdgslO79DVI6KsuD3e1chAYdPmTY4Y7FlanNiBg6WDTArzoOLX6+r4FNkGlqYTVMaexhxfryJiezvOTHI54irF/isbEozV0sFR18BSzxb3PXrlO6osmpLJK4tJnZe8PNZLjLlgySGKffdAYsHhTT77+iiuBMcgPSO3TADllNRsfLz0sAiDwh0wg8ex+dizlkOrtG5eKHUob0FjhrkL793f/74i4uQVr7OdQqhwrDzOJTxsYKuiS/r6hWos9rqVJBF4HATcRlBoERsH4f0advB30ZXLoHFiH7RhSYn4dsm3riBk19oywzn1e45s4AwQumcDon0Ol7gefuwvRBz/G2lhNyiciXuJa3zCQZhzUhKLyplRZO9eXRML2Pd8uqi89IElMW8cODmdAjAHrl8ipI6KOsnkWBK8+Rtxyh6/CtLS0xOHeRnlS94V9eRefRBwsGgsQpRwcGIO6VGczt7yQVJGEtma2QkbPb7GjghMW84V/hbYHk9BHSlAMYdS2X1prwim3Mr+gUe6rVmhHak/xbvjuHUKYocFjiPHThtMOfn193/2+tObhBOFYm4c0mX5/u/E6fOdRyuKy+yZwRvhNVQwg/P//JQweyDkSKQQKvN3fiIYXA6srFDXMlPMlJGTUa4dYplBNKBAqmuV4CYPfKIZmNFbt/WikNq1a2UL9sK9HBSDyOhUkYXim4WDy8yUVan/ULw99pR1pzbXKSwLB0bmeHuL3n+qTP3iBXY2JqQeHojZFIdvLsXL4zAurk4WCAlLRND1OMEALqXwLLZUT0EKte4KisV33j8ck57vgI7tGysuy71EoNIIaJM6s/XL74nYdNe2fi/s6qzbdyPV60sI3b0BJ98bDau2XYiJyhFx8syatEbyjUsl+me1arvpCxHwwwfwWz4HJhRvz8jOmRjEMKTdIa9CUpW5v/o5Zb2wKtGOXBoFg3f87WFCephL2SvYs1eLXhDtZnwKPQrQXBGxxNFj5pfwWTQNYQe2Itb3GIVOaUeZNpKQFHRRSPfcRkyFjVevoi6MaU5MMReOwXfpW3StN5yefK7oujxQPwTYxm7e03Px7u/z8c7vHwhP2sYUOiQuNV6oZTn0xzuDZhctnD1ZmenjTA0KezzFRVbdMrHkq8f94MmKayy94xhyHNT4uR+fpyDI7VFAtqp8zh66bJvHdoDxFM6lvshYzxiT1k5HZ7IpZFs/DvTMTOgrPSZQrL8HzGx583uN4vEFkbSObRGH/zAGnMGCyZdi56UTI8ex/Gb0mVLUlFW/vDHDO2X9a8L7ds6At4qua+KBlOQpyV2f/1Yf/PjFEHQm9ehNSoH23+lQGFJ8vJdGeWLX+vFwc2lYZqacGWPttyNhQw4ZrKJlaR/X37Hm+XLt7Ep3wMzlH1R3SP+W5EWbjoPHKfUOSQfHPNsOO9eOQ78ebiWajCXpH0v22H7w+NnbuHbrgdSxREV5IhGoBALMCDWiAMb5ZMd2dd0XokXL8W/D/bVFwk4v4eo5pJIkjqVi7q9+Vm6Pdl37o+tnG2HXfRDZwiUJVS+rY227PEnlG8jmr3+Zdmxw7v3JOrIP7IJ4ylKRdvcWGnXqK4Imc8aMR5GxvQu6LdoCF7Ix5JAvMcTopVMf1p49RHDn5qNfK9EFO340f36myMgRT0GXObyKJPVHgOPQfUd2cpyBgu3KjgYfRxhJsfq17oO1r6wUXrbFUVAwcJ7EqDGTqKB2Dm3ILk9fnPYkz9zixPW+HvuViJHHzCF73/rfDUBTcsDgYMCrJlBAZvp3igIoszq4PuijIe/j+S6jycv4hmDOWlH6Ng6OzPECH0UciPmH8csxu/+bcKKQKey8wnED3SiMy/xn3iM7xKVQSO+4L/4I+3TYR3CxchbSw+PX6t8m8VFrrO3rDUjF92gXltqeBfW/Y89VvD5/N078NbUORlPtIRS5a7t3csL676REoLy7+QOlifO/EonDW18u77LalP31pAW6fPi/KjkeqM3iq7EQzl3L3rMDNp6vRmv1bpJOTiwn5gzHoJ0hxJCWkn6q0dInU+YGfWIeFHlf1WhpSrUURe7a1cRoKoIlK9UEa2gy41e/jGm9XsEkykesjCQlecp4V+ScJAISAYmAREAiIBGQCDwmAkrD5HHMt1xyNJAkEagJBPIok4h2BfHQaqJ/ZemDpVIF5JEqSSLwuAiwZzNTeTEJH7dvZWrP9nD1pbpUJhzkXGoGgbz8fJFerWZ6q/lelIbJ47htSSlZIs1XzS9T9qhpCMQnZoCdS9SdOFZcLsVlkyQReFwEspMThPOJjnFhtpvH7U9Z29uYWpXw1FTWecp5qQYCCRmJwutZWWerNN61zg7m5BV0D8EUQqRNi0bKipdSzItz3F4/NUsp5qKsk2AP4cHkWKLuZNjIESmhwSKosLqvtSbWN3DzxZroRi37SL0dDINGDsJ4XS0XeH9RnPN0z+X9IvxG6Rys6rzuul7bygkr6nrIOh8vKjlahMPhZ0pZSWkkeY725hhEL+VffitMAK6sgMl5KT8Cvpci4H81CpPGFLrbK/+Mqz9DlyGTcPfwDuRlyRzD1UdRtuQsI7f3bYHrs6+oPRijOoxAdEoMZYM4pfZrlQusXQQ2n90K9oZu17hN7Q70GL0rDZPHa3j/tZ7450BwmcwOj7E+2VQDEVhNnpPPPd0GzZqor4eg4rY6PjVG5G29e+RPRZHcSwSqjEDUmf3gYM0uz06qcltVa2Bjao0XvZ8XqcWUJLiEqkEo50sIcHDmXX5/461+ryu19FupmLzeXV3Q0b0xPl12BKlp2fJBkghUGYFd+4JEvL/3XysZT6rKHalIA04V5jb6DYT8vQ4pIYEqMms5TWVCII2yd9zYsRKuw6ZA17j8PKLKNN+amMvrT0zDFUqXtdVnu8yMUBOAalgfWblZWLrvG9hRxpFn3Acq9eqVisnjQIZrlw1DTFw6hk7cJLIqKDV6cnJKgwB/FMxduBcf/N8BfPPJIHSgjwVNIdehk2HrPQBnPp5IzN56kQtWU9Yu11l9BFiKFXZoO07PHwfz5h5o/oLm2PlysNzvxi7FT0dXU0aKeeA0WZIkApVBgPPlTlgzBUGRwVj54vclAldXpn1d11GaYMjFF56ZmYt36WX90wYfUru1RY8uzujk4QD2wJUkEVAgkJ2dh4DAaPEx8Pvfl2FirIctK0bBo42doopG7cOP/IGAr9+CsQOlSOo2UARINnFsRsF/lepbTqPuibItlhm79IgQJFIKtmifQ0gK9kO7mYvh/PQEpVY51RaON2NDMG3DG7ibFI6RHYaRfZUH3B3bgvOmSpIIKBDgjwC/sACcD/XFnxd3YaTXcHw5ciHMDEwVVZR2r5RMngKtvUeu4+dNF0QKrYSkTJGqq0N7ewqNYQpjQ10YGelCi+LrSdIABCgvS3ZOPqVuy0EKSe2uUF5fdq4ooJeWV1s7DO7bXNh0GtJzocnEeVuvbVyCeL8TlGrrBnRI/WbZwhPGjm7QMTCizZhScSmNU70m36o6WTvHvmOnnHza0iNCkUgp1XJTEmFEqdkatu+BFuM552/zOpmLsg6Sm5+LH0mit/fKfvEi5/9TWtu3pLynrcVL3FDPUDB9rGmSpP4IFNwrQGZOJjJo45y//mGXEBp/m54FM3g36YRxXcZgqMczKgOEUjN5ChT56zPoRhz+o3ypp86HIYbyrKal5yCNXvgcdkWSZiBgaKADEyM9mJrok7TOFr26uKBrB0cYU5mksghkJ8Yi/tJpJFw6hfTwW8jLTBPG9ffIk1LT6B7oX24uGujqilyemrL+BpQQXsfIFDqGxjC0c4aVe3dYte8OA2t7TYGgSutkWyvfO344fescAu5eRmpWKtJzMsQLv0odqUXle8jJy7mfG1ZzGFxm5o31jWCiZ4yGxpbo5NIR3Sn/cGu7liRUUj2tiEoweWrxe5GLkAhIBOoNgczYcBwY0xr9twXC0EZ5Y1rVG0ByYIlAKQTCkyLRfmEXBCw4BwcL+VFQCh6VOVU9tlRloJUTlQhIBCQCEgGJgERAIlB/CEgmr/6wlyNLBCQCEgGJgERAIiARqDUEJJNXa9DKjiUCEgGJgERAIiARkAjUHwKSyas/7OXIEgGJgERAIiARkAhIBGoNAcnk1Rq0smOJgERAIiARkAhIBCQC9YeAZPLqD3s5skRAIiARkAhIBCQCEoFaQ0AyebUGrexYIiARkAhIBCQCEgGJQP0hIOPk1R/2cmSJQK0jkJeZjsSrPiKVVT4dc0DkexThX9MoPycHSUEXYNGqI7T1NCd4NgdD1jY0EZlOjOycYNnWG7qUBUVSxQjkF+QjkPKSBoRzMOQ0CoacDg6SrGmUTYGQOTB0B2dP6Oto0G+GwqUb6RmJgMiFwZA7wMnSUWXT/kkmT9N+uXK9ao3Avfx8RJ/Zhzj/E4gPOImU6wFooK0NI8p2oE0pzXT0DSitmWamfrtXUKBxeXw5rVl+diYx9xnIjLmL/NxsmDVpQ1kvesDKowfsejwDLQ19Hor/R3A5/CoOBh3B6ZtncS70PFIo04WjpQPMDc1gqGsosj5oYlozTvGl1UCzFH685iz6nXBqs9i0OJHazN7cDt3cutDmjcHtBoDPVYUkk6cqd0rOUyLwCAQ4q4PvoqmUdN4Xlq06wLKlJ20dYN60LbR0NedL/BEwaezlAkpnlxIahMSgi0gMpi3wAuWtbYYOH66BiWMzjcSF89Yu3rcc3x7+Ea0obZWHkzu8nD3g6dQeFkYWGomJXPQDBDilanhiBC6G+VMO2wD43vZDSmYKlo/5CsM8hzyoqMRHkslT4psjpyYRqCwCEcd2wX/pTJg4N4f7qwthaKU6X5qVXaOsV7MI5KQk4PKqT5Fw9TzcZy6B0+AXVVYlVR1kQuJCMW3jTNxOCMOCZ+dRftKu1elGttEgBFjKt+nMb/jp6CqM6jACX478DCb6xkqNgGTylPr2yMlJBB6NQNSpf+GzYDyajX4VTYZMJJWk9qMbyRoSAUKAJRVhB39H8Kav0X7WcjgTo6cJlJadDq/Pu6G1fSti8D4Qieg1Yd1yjTWDQGBkED7auRDNbNywbdqGmum0lnrRLGV7LYEou5UI1BcC/JK+vmkpHPs9B7ehr0gGr75uhIqOy3Zmzv3H0MfBy7i++Wuw3aIm0MYzW6CjpYslo/9PMniacMNreI38cfDlc5/jcPAxXAq/UsO912x3ksmrWTxlbxKBOkUg4dJp8hr1heszL9XpuHIw9ULAecBYZJFNZ9TJ3eq1sHJWk0NeoyuOrsQ47zHQ1dZMJ6RyYJFFVUSgWSM39GzWHd+RPacyk2TylPnuyLlJBB6BwI2t38G2a38YNXJ4RE15WZkQYAmsMpGemSUc+o4AP0/qTrv8dyOd1LXDvYaq+1JVfn3K9jspDejE7uOx0+8f4ZxR+pqynEsmT1nuhJyHRKAaCKSGXIF1++7VaKl+TdhrdN84L5z7bEqJxRXk5iBow1Icfa0/9k/ogiO0T751tUSdypxwv9w/j/M4FHlqLy79MP9xuqiVttbtuyE1pOq41MpkarHTq2RP5UHes8b6RrU4yuN1verYGnT+vCfWHF/3eB3VQ+uh348Sc49Oian26ByrcNv5HVh+4Ptq91EXDfk50tfVx7WY63UxXLXGkExetWCTjSQCyoFAdkIM9M2tlGMySjqLW3+vxe1/NyGP4sXZePUSIWWMGjnWy2wTr/khYMU8ZCVW/wVYWxPXt7BGXkYq8rIyamsIpeg3hpgPDnIrSXkROHD1EJbsXS7iFSrvLAtnZm1shajHYGhre306tT2A7F8iIBGoPQQ4uK22vmHtDaAGPSffuCxW0ebl99G4Vz3HtipQLjVt8dureI4KiBmGgfJKuYrPuTrHWXnZMNA1qE5T2aaOEChQMnOGhy3bUM9AqTOiSEnew+6evCYRkAioPAKsrmUykLEDVf5eygVIBCQCVUNASvKqhpesLRGQCFQBgYiT/4o4bKl3rgFkZ2Ps0BROT46EwxMjygTejb90Brf3bkHyzcvIz8mCka0jHHoPg1P/0SVSb3GYjzsHtuHukT+QERUGdhpwfGI4LFp6lZhZ+LG/cHnlx0VlPp9PFcdNR05Hs1EzcOzNp4V6ss+K/bi25VtEnz0gxjVxcIPL4HGw7z64qO3DDjhtWOiejYg6s1/Mp4GODsxcWsDpqdEl+rj08wJE/Pe36IqzTbB9X+Pez8J9xsKHdS+vaTgC+y4fwPpTG3E7Pkyomfu1fgKTe06EGaVcK07+YZew8cxm+NE+jXLu2phao3uzrpjUYwJszRoVVX1763s4fv0kejbvjuVjFxeV88Hn/3yFXX5/o1fzHvh67FfiGtsGNrdthh/GLcfXZCN36sZpsKStpV1zTOz+Iro19S7RR0UnSRnJ+PX0JhwL/g+RydGULs4AbRq3Ji/nsSX6mP7rGyJnLvezO+BfsU3tNQnT+kyuqGtZ/hAEJJP3EHDkJYmARKD6CHA2hfCjO4U62byZO+0NKJWWL66s/oyyLFyA+2ufFzF6t3atwfVtP9C5FjFrntA1NhOpt4I2LEFC4Hl4zlpalHc24Mf5iCLnBR1DE1i7d0VuZhpu7FgJ48auJSbLTKJ9j6cRf+UccpLiYNXOG3pkv2hKWUEUxN57vkvfpFRwfmjYuqPI8xt/xYfs5j5A6p0baPH8TEXVcvc5KYlg5jHt7k3omlrA2qM75YrNIueMC8JBI/7SWbSb/oloa9HcA9mJlAuTwt7omTWEFc2dyyRJBCpCYC8xeKHxt+Fm0wS9WnTHpbtXsfnsVpwkRmvNyz+L3Lrclp0Ulu37lpivArg7tEUjMxtci7qBHRd24lDgUXz/wjK0sm8phvng6XcwdmUATlw/hcNBx9CvVR9RfurmGcHgsb3ih0PeF2WKP5zHdfqGmYhIikBn105CPel7x0+k+Xp/8ByM7DhcUbXc/d2EcGr/BmJSY9HItJFgIpMykuATcgFnbp3DtN6vYCptTN5unZFHH4QBdy/BwaIx3B3boRkxmZKqh4Bk8qqHm2wlEZAIPASBu0f+FAyeqUtLeM39pijNGjNFvkvfQuTJPSK/rtOTz5Gn6xVi8H4UjF3H93+EuVsb0XMuOQH4fDYVMeePIIqkbPbdBoo9M3jGjZug84erwM4CTJya68LikgyZyN9LOXx9Fk1HAjF5bsOnoGGbTqK+4k9+ZjpSQgLR+aPVsGzhKYpTQoOpzTSEkMOGbed+wlFDUb/0/sqazwWD14jqub/6OXQMCu0j06Pu4MKXryOc0s1x7mCW6vFaWUrITJ6xQxO0f31R6e7kuUSgBALM4E0hKdb0+1KsbLIn/PDPT3A0+Dh+PLIS84hhC466Jhg8PR09LB39hWCSuBNm+Ng7d9V/v+Dd7fOx/dXN4DrWJOGbM3AWPt71GbX7Bt5NOlPdfCwiKR7T/GfeK+OYcjcxXEgGN05dB1crZ1Hv7C0fzN76rpDudW/WDXbmtqK89B/+kJr3x0eCwRvdaSTe7v8mdLQLWY8rEYF4a8tcMce2Dm1EarlXSEppZ24nmDxPyiP8yVDl80QvvUZlPpc2ecp8d+TcJAIqikDoP7+KmZfOo8uq1XbTClWooXsK0wGFHdpB+bUK0PS5GUUMHjfWNTIlSdqbMLZ3RVZclOgv7P/bOw/4KKusjT/pFUjogZAAIr0jHUQQURRpIrqgqIBYEMuq+9kLoGLFVZdVWWx0RQFRBCz03kLvJJRQ0nsPfPfcMGMymVQm4Z2Z5/gb5n1ve8/934lz5pZz/lik35uPed5s4EmCGG+ht96r88r6z3XDJpgNPKlbtWEzNFFLuirmF878mfc8a22mR59D1Pa/4OFfTRl4U8wGnpT1qxuiZvDy+hl+hYW1NphGAsURaFgjVM1wPWQu4uXupYywF+Dp5qmWMVdAZtgWbFukDToxjmQWzCSualZcZsc6hXZQy6MX8MfBv0xZuL3NrejTtLc2vL5cNwsfrvpEXw9TvgNvbNrLXC7/xbMDnjIbeJIuzxrRaRjE8JRl1aJEZvwOK0O0Uc2GkDZMBp6Ub6WWa5/u/4SuOnvz/KKaYPpVEKCRdxXwWJUESKAwgcz4aKSej9DGT5WQpoUK+AdfB6/qtZF2/hQy1QxbvJqFE6nd8cZCZWX5s9eHi9Hozgd0yK34I7vh4u6B6q3+/jIzVard6SbTZZneZYbQUmrfcJNOkr1zRUm8ijQiUrN9L2XgFT6NWr3FDfBUM43pUWeREXuxqGaYTgJFEujfsh/EWMsvAb7qR0VwK21cic+/3cqIErmlRb/8xczXA1rerK/F2MovL9z+nF7uXaiMRDHSGgQG45lbCs6Gm8p7qRlAMQotpc8Vg9Cy7fzldp/eo2/7qmVhNytxtfu37As3FzfsVXsJxT8exbYEuFxrW55sjQScnkD6FYMmOyVRHy4oDogYP2LoiXjXsL7cY6qfnZKAyznZ+pSs65XlHlOevPvUqpf/tlTXrh6eVp9r0iUzIbrIdjKUMSviUzOoyDK+SifZD5iZGGP1OUVWZAYJKAJBatnSmsi+NpGY5BjEpOT9/QQFWC9bT+1rE4lNidPvpn9q+tfApH6PY+qv03TSc7c9DR/PvO0GpjKmd1k+zT8DZ0qvUzXvbzZa6VGUiI4i9apZ/zsRdzaBfgGqH7FIzkhGgG9AUU0xvRwEaOSVAxqrkAAJFEPgyq9x0+GCYkrCTc2AXS71r3eX4prShyaKLWAl08W14CyJqYg5nJKVmQdTGbWe+/dlEVdyEljEVc2EUEigrAS8VTSF4kQML7WroFjJVfvtRDzUDLilbDm51Zz0y57f9J44c0K+C8vZRFPW5St/A9Zm6CzLmO6tvcv+QREPtQxNsS0BGnm25cnWSMDpCXgF1tIM3Hz8SnW4QE68ZsScR4aK3mE5K3YpNwdn1Z49v6BQVFenY13Vl57M/F1SM3quFl9aphnBsgyAnITNTk1Whz6qFKgm+oh4Vy96dtErIK+fsjevKEmPjtRZ0kcKCZSVQFEzZOcT8z6ftavUUgcpaqhTr+f1q0H1wpFcItWJWBHLKB+yR++PQ6txXa3Gek+fRJno36IvxEWLpZhmCy3TZa+fSH4XLZZlavrnHY6Sk7nWJDUzDfGpCZD9hkYONWdNd3tIs/4z1h40p44kQAKGJCDLpuJ4OD0qEimRJwvpmJkYh/XPDtWnXiWElulUa8yejYXKJqgwYIe+mYYIFZbMxcVF78W7rAy/6N3rC5WNDttQKK00CdbqRe1Yo6tKPNeiRE7vKqUgelsLBSauWOQ0sZyk9apWPa8ZVZ5CAqUlsDV8e6GiUUnR2Bd5QBlEfspXXVN0CMk7FS4GmzX542BeuhzAMEl8ajzeW/GR3u/30h3/grhVcVH/vbviQ4hrE0tJVn73xA+fpaw7mvc3l//Ah2WZjuqErMhq5R/P2p67P5XeMiOYXz/RhWIbAjTybMORrZAACeQjEHrbKH1idt+MV5B+ZVZMssVxsDgolkMX7mqmTw4siHsRMZaOL/pcuyMxNZOdkoQjcz7St/V63a7fdbvqSvznpV08ayqq3bCEL/3afF+Wi2MLPinU1onFX+oDHlq3IhrzrV0fcthD9h7u+++rytBLN5cU3Q7MnKzvQwb8fepX9gCK5KSl6Hf+QwLFEdh8Yit+2rXUXERmvV7/eao2lu5SvunEJco9ne/SBxe+2vAttoXvMJeVLQcz132tD2bI3j5xcGySab99iHhlzA3vOARtlR86cVUypMMgxCnj712VZ00sDUDx1Sd++Kr5VMPA1oUPL5na6KiMSzFGw2Mi1CnefyNH/UgzySF1cOSTP2foW3GvYhI56CGSmsm/ExOT8r5zuba85FiPBEigSAKhA0cj4dgeXNz2JzY+PxxVG7eCu68/Eo/t1bNbvsrFSMtxef6vApt3gEShOPHj59j04r3aHYoYQwlH92gDShwam6JPyMxawzvuR8Svs7Hx/+5GjVZd1NJtlvaTV7VRCyQeLzzbUKSSpgz1ZbjphbvVc6WtbNXWdn2St+XYl/QysamYtfeW415RJ4lPaVcq6w7frn3/aWfIyoGzhFOTiBb5DUUfZRi6qH1UyaeOYMc7jyFQOWC+Tvnvo5CANQLi2Pid5e8rJ8W/oK465BB2Zo82xDo0aKcdCEudFkHN8cyASdpX3sS5T2vnwXXUMu7Ri8dwOu4sAtVBhneGTzbH61114E/lBHmNckpcCxP7PWp+7KR+j2Hd0Y16CbefWrq95cqpXCkgM2sywzd8xr1qxq0jEtOTEKZOzXqqLROvD35JHZaoZm7H8kJm4N8a9gYen/MUftjxk3rGBrRWPvEkAkbY6b2QPYPjej2oI3CY6pqWnUUfidAh0TnEIKWUnQCNvLIzYw0SIIESCMiBhnZPvqfDeJ1VUS+SIg4r76yXIEZOcL+70PD2+5WLlb/DMjW56xHln665Cms2TxlqKqxZdqY2sBoPe7iQ/7tmo/+JKqF5ZeMOboObinwRMuAebUxteHZoCZoVzu7w/L9xeuV85XR5jT4EUr1lZzQeMraQ4+TCNaGXYbtN/s4c1iwmbKOO7BGgHCs36D8CdbveUqCap/Kp12r8qypCx+cqksdOFekth0ZeAUK8yU/g3i53Y1DGQMzdugDrLx7Xe99GdBqOMT1G6T1sprL3dB6BpnWux+zN85QT4f04cv6oLishw+7r9g/tyFjKykzd+yun62rPKYfI/mrJ1yQSJu3ZAU/i5cVvqKXc6dqYM+3jk4MXsx74HB//8Rm2qggV7m4e6NOst3bULOHNSpJQ5UB59vivdHg2MfLEeKvi7a/DrkkfuzQq6KRcwqhN7PsIFmxfpIfdwEUAADbQSURBVJ63HVW9q9DIKwlyEfkuakr3chF5TCYBEjA4gZ9vDkCXV/6nZpD+3m9jcJUNo57ErpUDFn0+XUH3JmpUZEZSjOTbloTr8G+GGSgbKzLuu8fhpQ7wiJFDKZmAxK4VP3ZbXl5bcmEnLDF65oOY0HssHupxvyF7zz15hhwWKkUCJEACJEACJEACV0eARt7V8WNtErimBFyUHzdZ8qOQwNUSkFPLIi5ublfblKHry6xUziX+zRh6kOxIuZzcXD3TaVSVaeQZdWSoFwmUgoCXCpuVnRxfipIsQgLFExDXNuK02d2v6E30xbdgH7m1lF852fRPIQFbEIhLizfvebRFe7ZugwcvbE2U7ZFAJRLwqR2sDjUcQd1uAyrxqY7xqD6fLHeMjtioF3Li11tO/zq4L7/gwPpYvn+VdgBcVCQHGyF1iGa2v7LBIfpREZ24kHhRnzqWz5RRhTN5Rh0Z6kUCpSAQOughnP3rR6vOeEtRnUVIQBMQ1zGn1AnjhneOdXgiIzoOw8WkKKw/tsnh+8oOViyBeVsXon2Dtmhdr2XFPugqWqeRdxXwWJUErjWB4P4jdfzXs6sXX2tV+Hw7JnBhyyrtoDn0zofsuBelU71WlZq4r+u9+G7TXBX3lc4lSkeNpSwJyJL/0rBleKrfREPPftPIsxw53pOAHREQp8GN734C4cu+QVL4ITvSnKoahUBKZLjy2/cFGg4Zr2L4/u270Cj6VYQeE2+agAPnDmKh8sNGQ68iCDt2mxnZGfhg5cfaQfUdbYqO9mEECm5vKDGCItSBBEigfASqXtcGqWeP4+BXb+mN8wHXtzX0L8vy9ZK1bE1AjBtZ6g+b/hxqtO2BVo9OgZunt60fY8j2JEJDg8BgvP3b+9rY69ywE3w8fQypK5UyFoEjF47iyfnPIjo5BjPv/wz1A+oZS0ELbegM2QIIb0nAXglErv4Jez96Cn71GyOo+63aQbJ/cBNI9AkKCQgBMexSz4Uj/vBuXNz+JxKOhKH1pPcQcvsYp/xhcCI6HBNmP4GzCZE6okJ7FS6sTXArcwgwfmpIQAjEq0ghYWf2YkfELizevRTDOwzFNBUqTiJxGF1o5Bl9hKgfCZSBQNrFMzg6533Ehm3Qs3vuavktUIXY8gtuDHdvX/Xyg4s7D9WXAaldFxXfdzkZachVr9RzEYg/GobspHj4BoWietueaDr6Wfg3KDkslV1DKEH57NxszFgzEysOrNJf5JeUIdwiqBla1muhv8Rlhs/bw9spjeAS0Dlk9qXLl5CelY409YpNicWeM/sQEXtKfRaqoqsKvzaqy0gMbneH3fSdRp7dDBUVJYGyEciMj0bsvs2I27cJqZEnkZOeojfXX1YnKZ1NLkP9l50NFw8PHWzdWfrv4uYOd98qcPfxg0/dENRo00MvzXrXDHIWBGXqp+y12nU6DJtVfFaJAZuckYzUrDT9hV+mhhyi8GVk5WTBU/lOVC6yHaJHpemEuBDy8/KFv6cfJHbvDaGd0OO6rmhRtxlc7XBVhEZeaUadZUiABOyaQHp0JH4f2QK3fH8IPrWM69PKriFTeYciEJlwHm0nd8He17apfWf8UWCvg8vNOvY6ctSbBEiABEiABEiABIohQCOvGDjMIgESIAESIAESIAF7JUAjz15HjnqTAAmQAAmQAAmQQDEEaOQVA4dZJEACJEACJEACJGCvBGjk2evIUW8SIAESIAESIAESKIYAjbxi4DCLBEiABEiABEiABOyVAI08ex056k0CJEACJEACJEACxRCgn7xi4DCLBOydQE56KuIPbtehrHLVtThEvqw8/Dub5GZlIeHwTgQ076Tis4pzV+cQcYbs5uOvI5341m2AwFZd4aGioFCKJpB7KReHzh/B3khxhpyinCGnQpwkO5tkKkfI4hi6Y0h7eGmHyM5BwEU5fvb19NUOkfOcIXfUcY7FSbI9Co08exw16kwCRRC4nJuLi1tWImbPBsTu3YikY3vh4uYGXxXtwE2FNHP3UuGZ3D2KqO3YyZcvXXK6OL4S1iw3M10Z92lIjzqL3OxMVG3UUkW96Ika7Xqibs874Oqkn4f8n/b9kQfxx+HV2HxiK7ZF7ECSinQRHFgf1XyqwsfDR0d9sNcv+fz9LOu1hPhydXGuBT/pc4b6O5HQZtEpMTq0WVC1uujeuIt6dcXA1gMg9/YiNPLsZaSoJwmUQECiOux662EVdH4XApt3RGCz9urVEdWuawVXD+eZvSoBk9NmX1Lh7JIiDiP+8G7EH1GvQztV3Nom6PjKLPgHN3FKLhK39r2V0/Hvv2aguQpb1a5BG3QIaYf2DdoiwDfAKZmw038TuKziGEfGn8PuM3tUDNu92HUqDEnpSZg+8l0MaT/o74IGvqKRZ+DBoWokUFoC59YuxZ4PJsE/5Hq0eWwyfGrYzy/N0vaR5WxLICspDvu/fBNxB3egzaT30WDgfXCm2arwmAhMmDMJp+LO4LU7X1TxSbvZFjBbczgCMss3d8sC/HfNlxjRcRimDZ8Cfy8/Q/eTRp6hh4fKkUDJBC5s+g3bXxuNJnc/hkaDHlBLkm4lV2IJElAEZKbizB8/4Mjcj9D26ekIUYaeM0hKZio6TO2OFkHNlYH3kg5E7wz9Zh9tQ+DQ+cN4dclkNKnVGN9PmG2bRiuoFedabK8giGyWBK4VAfmSPjb3AwT3uwuNB4+lgXetBsJOnyszdyG3jFQ/Dh7EsXkfQfYtOoPM2TIf7q4eeP/ut2ngOcOA27iP8uNg2l1T8deRtdgXecDGrdu2ORp5tuXJ1kigUgnE7dusTo3uQsM77q/U5/JhjkUgZMA9yFB7Oi9s/NWxOmalN1nq1Ohna77AqK4j4eHmnIeQrGBhUhkJNKndGL2a9MAnaj+nkYVGnpFHh7qRQAkEji/8BHW63QLf2vVLKMnsa0FAZlrtQTyrBqJ+32GQz5Ojy9I9vyJVLdcO7TDY0bvq0P0zwt/WAz1GY0nYL/pwhlFh08gz6shQLxIoBYHk8AOo2bZHKUqySGkJHF/0OVaO6oATi2eWtorVcoknD2Dra2Os5hkxsWbb7kgOP2hE1Wyq00G1n6qdOj3r5+Vr03YrorEv185C56m9MGv9N+Vuftme5bqNqb9MM7dhLc2cWYEX0pdub/W5qidk5mRi5rqvMXvzvKtqxxaV5XPk5eGFo1HHbNFchbRBI69CsLJREqgcAplxUfCqVqNyHsanlInA1tcfROKJ/WWqcy0LewXURE5aMnIy0q6lGhX+7KikKO7Dq3DKFfeAeVsW4st1swzjoLqmXw1cUJ8po4q7URWjXiRAAiUTEOe2bl4+JRdkiconYCdLtSYwps/RJeU8Gd7Gn+Uy6V3W9ww1E+Tt4V3Watek/MjOd2FAq/4299nXt9mNaFO/Ffy9/a9Jv67moeLGxEji4+ltGIPTGhcaedaoMI0ESIAESIAErjEBcchcEU6ZxbizRwPvGg+HXT6eRp5dDhuVJgH7IrDv89dwbt0ydH71f4j49TvE7tsKdx8/NL33SeWQ9w1Ub9UFnV/+olCnVt13g3LrkYtb5+0ukJcefU7vmYvdtwVZSfHwq99IuQEZo12A7JvxClo/8ibq98nbWG96dve3F6hoDztxauUCyDK3d826qNd7EBrefr+KZ+tVoP2ibs5t+BVn/vwRyaeP4nJOjg4XF9TjVoQOHK3ayJsdilz7M/Z/8bq5Cdnf510zCH0+WW5O44XzEvjkzxl6P9mEG8fiYfWylO+3/4j3VRSOezqPQFXvKpi5/ms82mc8xvV+sEDR5ftWYvGupTh28ThyLuWgQfUGetbvH11GqpnK4j/Psidv8rK3ddSGVwa9oNs1pT1/6zNoWqeJWhL9CrJ/8bKaOWtVryXG934IHUPbm3U4l3AeQz67G32a9sbT/Z/Ah7//G7tP71Guadz1LOF4pW+r+i3N5Yu7uJB4Ad9snINNJ7YgOjkGVZQR2l5FHnmg++gCbQz+dATOq7IiwkVe4ufwzna3F9e8U+dxT55TDz87TwKVS+DA/6Yg4ege1GzfUy8zZ6s9YGWVlMhwbFEHGiLXLFHxeH1Qq0NvFZs1FXs/ewmnVy0ssrnji2bg8Hfvw8PXXz8/OzkBx7//D3a+9wQk5FdxIv7j9nz2IsSATDp5EAFN2qJmux7IjI/GsYWfYdsbY5GdmtcX3zrBCOqpvnSuBDSX6zqd+xXXPPOciMDtbW7Vvf394F9We73ywB86feCVcpaFZLnylcVv4PWlUyBOedsEt0b367pq42jG6i/w8LePIVnF3i2vbD65FY/OfhJixHVu2Al1qtbB9oidmDj3aew7W3iPqcR3Hf/d49rA69ywI0KqB2PD8U14+LuJWH9sY4lq7Fd+5v7x5YP4cdcS7dKmT7NeqB9YD6sPr8W4bx7Dz+r0qkluUsvM1ysDVKRJ7etwm4ojKzGGKUUT4Exe0WyYQwIkYGMCWYmx6PHuDzrsmhhO8crHX1nl4KwpkHYaDx2vonw8rkNxyWzf4dkf4vTK+UU2F71rHZo/8C+E3voPXSYrJRE733kM8Sqs16kV8/VMYFGVT69agAubVsA3KBQ3vDADPrXq6aJ5xuWLiN69HgdnTUW7J9/NixusYgdf2LxSzYLkou3Et4pqlulOSECMEzFUZAbueNRJZaw0NlOQGS0xpEJrhKjZsxbYeGyTOc90ITN9YgiGqJm7T0d9hHoBQTorNTNNG39iYL2z/AO8PfxNU5UyvW9Qzxzbcwwm9BkHNxU9R1yVvPHzVMjM4fxtP2ijMn+DB88dQuNajTBn/Feo6Z93COyXPb/hzWVv4a1f38NPj8+Hr6f1PZ4Zak/xvxa9jJTMFEzs+wge6PF3aL2Nxzfj/1Se9KWlYiHc/jngSX3SWNjJvkLRkVI8Ac7kFc+HuSRAAjYkUPuGfua4ui6uZf/fT1LEYWUY7kaVhs3NBp6oJ6Hcmt//LPyCGhaprcz4mQw8KeTpXw2tJuQtq579c1GR9STj1G9zdX4btQxsMvAkQZac2ygjzl3NDl7Y+jvSY87rcvyHBIojMFDNQIn8fvDPAsVWHfgTl9V/pvwCmVdu5m/9Xl+9Pvhls4EnCeISZsrQ11QsVX/8oWYJxWAsj9SpWhuP3DReG3hSX6KijOg0TDd1MjrcapOv3/my2cCTAoPaDcRNzXojNiUWa46st1pHEkVPWZ7t1rgLHux5f4HYyT2bdNdGnyxFm/pcZEPMKJJA2f8vW2RTzCABEiCB4glUCW1afIEScmUvn0jtTjcV+EKQNDH0anfuK5dWpW73vGWy/JlVQ5vp/XJpF88gQ+3TsybpsRcgewC9q9dBQNN2hYp4+FZRS7c9JRBsuWYmCzXIBIcnIMuMri6uysixMPLUvYv6T/KtyYXEiziXeB61q9RGW7VMaylymKKHWroVQ3GX2h9XHpFZM9Etv9S4MkOXnq1OXluILJe2rNfcIhW4Ue3VE9l1KqxQnilh9+m8vP4t+pmSCrzfok4Wi+y6Uq5AJm9KRaDgSJaqCguRAAmQQPkIePhVLV/FK7UyYvNmynxq1LXaTv5ZNssCvnUaWCbpe+8rbcn+OmtiSve+skRrrYxPrbx9QZkJsdaymUYCBQjUqlJT73c7HXcWRy4c1XkRsaf1tRhvsifNmsSo/W8i9QKsf/7z8vLqyixaeaSKmgm0FFm2FbEWZaKoPXEyIyhi0lnfWPwj+/lEgoroT/0rS9GxKXEWNXlbWgI08kpLiuVIgASumkBZlmjlC0VO9uWXS7k5+tYy3VymGN90MtNnVa7UKVK3Yto0tWfSx9WDsVBNTPhePIGBbUxLtnkHMH6/cuDCdDDDWm1rRpZluUtqH6iIp7unZVap7mV5tixiMgAt65h0tZwVzF/OVCZ/Wv7rXLVvV8TTnX9X+bmU5ZpGXllosSwJkIBtCVz5QpGDE5aSk56il0Dzp8uSqUiGWkK1JhmxF60l67SilmMzruyj866R17ZlA16BtXRSenSkZZb5Pv3iWX3N6CNmJLwogUDf5n20U+a/Dq3RJeW0rYebB/q3tL50KYVkBlBETr4WJZEJ53RWdb/AoorYND0q2foMuCwti5hm9Kw9tKT+RCbk/c1V96turTrTSkGARl4pILEICZBAxRBwvxJZIcvKMmfisX2FHlq9ZWedFr2r8GZumRWI2r2uUB1TQkzYBtOl+T0p/JDai3cRVdTePM+q1r9IfJSPO/FzJ771xP2LpYgbGPHXpzYF6pO15vwyzoiY6/HCKQjIiVNxCXIm/izE0AuPiUDPJt1Q1afoLQ11q9VFkHqJYbXXijuTlIwUbDm5Xe+p6xDyt0+7igR6MiocF62E9Vp7NO9vVA5VFCUmHf88tNpqkT8O5qXn989X1plGqw07USKNPCcabHaVBIxGwFedhnVRSzGp5yMQs3ezWT3ZB3dk3sfme9NFYLP2qNqoBZIiDmlnyKZ0MfBO/Pg5Uk4fy0uysuIUue5nROcz9LKS4pQj5jw3E6EDR5masvrecOB9On2fcnIshzBMInFe9/3nFeWnLwV1utwMif9qElePvOWy8vgCNLXBd8cmYFqy/XDVJ7qjA9vcVmKH/9F1pC7z5s9vFZjRS8tKw6tLJyM1MxX91CyhyZ1JiQ1eZYFctTw89ZdpBUJ7Ldm9TPvIE1cwPZThWpTcomYtZTZvy8ltyhny7AJ7/sQx8uzNc7Vz5WEdhpibMC1Dp6h+UkomQD95JTNiCRIggQoi4K6cGTe4+S7l324Bdr03SUW+6AxXZfTFHdyuokmEwr9BE6ScOV7g6RLNYtvkcTj+wwzti86vfmOknD2OVOUk2ad2MNKjzsJFLXtZiiyl7nr/SQQ26wCPKgGIO7AdOWoWLqjXHah/42DL4gXuQ269FwnH9uDCllXY8NxwBLbopJw5e+vTtOJUWVy6tBz7UoE6vnVDkKxcvmyfMh7+9a9D2yfeLpDPGxLo2qgz5ORqVHKUjvLQS7kNKUkkEobM4on7kZGfj4bMhkks3rAze5GQloBmdZvi/wY+V1IzNsv38/LTvv2G/ucetG/QRhmeF7STZonW8ebgV/QSdFEPE73fGT4FTy94Hv9Rjpwl6oZE25CZwX3KSbLs9/u/255Vfbre3IRE9hD5SUX7kOgXsodRlr4p1glwJs86F6aSAAlUEoHm9z+HZqOfUY6GQxB3aCeSTh1B/b7D0UWFQHPz8imkRZWQ69Ft6hyIS5RM5RQ5etdauKkvi/ZPf6Bcq+T9z16iWlhKk5GP4/q7JypfducQs2cTfJVB2Orh19DmsSmWRQvdy6GMtpOm6XBpVRs1V8u2YYhVM49yMld07/bmt/BUhmN+aTXuFb0MLBE6Yver8GvK+TKFBPITECPm1ituQm5u0bdUhyXkIMPbw97U4bya1W2mDL592KqWaGXv21P9J+KrBz9X8W6r5X9MhV4Hqvi6Mx+YgSa1GmPj8S16KfmOtgPx7dj/FQhJVpQS7ZRhKI6Uh3a4E5k5mVh7dAMuJF3UXL568AsM61jwB1jv63vg3i5369Btm9Vs3+HzR4pqmumKgIta5rhMEiRAAvZJ4OebA9Dllf+pvWAd7LMDZdRaQofJoQtxlSKOiC1l14dPI3rnWvR8/yc1e9ZIZ5ti17Z5fCrqqVk7inUCqedPYcOzQ3HbknB4qllPR5VxKgSXl4rt+tytTztqFyulX6bYteJCZfHEhZXyTCM+ZPTMBzGh91g81ON+I6oHzuQZclioFAmQgDUCmQkx2PTCSGx+eRQs97pF79mImN0b4KeMO5OBZ60NppEACZCAsxDgnjxnGWn20yEJiO83k+84h+ygRafEeKvV4UYVK3Yd1k26XUegkCXd9KhIfRjD3cdfL6laVONtKQhcvuKD0MWtCH+CpWjDHoq4ubhBQmVRSMAWBHJycyGfKaMKjTyjjgz1IoFSEJDTnNnJ8aUo6ThF2j/zASLXLMG59b8g8eQB5KoTrl4BtRCsDnA0GvQgfOsEO05nK7EnmYlx6tCLJ9z9Km8/VyV2z/yoWlVq4Fj0SfM9L0jgagjEpcWb/RdeTTsVVZdGXkWRZbskUAkE5DRpUsQR1O02oBKeZoxHyOnbBv3v1q/SaNTm0cmQF6V4AsnqwIt37fqFYgIXX8v+cmUP2fL9q3BJRVMpLhqD/fWscjWup0KObX9lQ+U+1GBPE4fPcqK5qNBuRlCXe/KMMArUgQTKSSB00EM4+9ePEH9tFBIoL4FLOdk4tXI+Gt45trxN2E29ER2HaRcd649tshudqagxCczbulC5jWmL1vVaGlNBpRWNPMMODRUjgZIJBPcfCTcVNeLs6sUlF2YJEiiCgPj/y0lLQeidDxVRwnGSxfnufV3vxXeb5hZwvus4PWRPKoNAQloiloYtw1P9Jhp69ptGXmV8GvgMEqggAhJVofHdTyB82TeQEF0UEigrAfHjd/zHL9BwyHh4+BUdUqus7Rq5/MSbJuDAuYNYuH0RDT0jD5RBdcvIzsAHKz9G3ap1cIdyxmxkcXtDiZEVpG4kQALFE6h6XRukqogPB796S2+cD7i+raF/WRbfG+ZWFgFxkSpL/WHTn0ONtj3Q6tEpcPP0rqzHX9PniLPgBoHBePu397Wx17lhJ/h4Fna8fU2V5MMNSeDIhaN4cv6ziE6Owcz7P0P9gHqG1NOkFJ0hm0jwnQTsnEDk6p+w96OnlJ+4xghS0SDEQbJ/cBNItAYKCQgBMexSz4WrcGy7cXH7n0g4EobWk95DyO1jnPKHwYnocEyY/QTOJkRieMchan9VO7QJbqXDhPETQwImAvGp8Tps3I6IXVi8eymGdxiKacMnQ0K3GV1o5Bl9hKgfCZSBQNrFMzg6533Ehm3Qs3vuavktsGl7+AU3hrvau+fu7QcXdx6qLwNSuy4qvu/kUI64mUk9F4F4FY4tOylehZALRfW2PdF09LMqPvDfcUHturPlVD47Nxsz1szEigOr9Bf5JWUItwhqhpb1WugvcZnhkxirLi4u5XwCq9kTATl1nZ6VjjT1ik2JxZ4z+xARe0p9Fqqia6MbMKrLSAxuZz+Rc2jk2dOnj7qSQBkIZMZHI3bfZsTt24TUyJPISU/Rm+svq5OUFOcg4OLmDnffKjoEnE/dENRo00MvzXrXDHIOAGXspey12nU6DJtPblMxYfcjOSMZqVlp+gu/jE05QPHLyMrJuhJP13kMXDHm/bx84e/ph+p+gbghtBN6XNcVLVScYFc7XBWhkecAf4rsAgmQAAmQAAnYkkBkwnm0ndwFe1/bpvad8UeBLdlWZlvcrFOZtPksEiABEiABEiABEqgkAjTyKgk0H0MCJEACJEACJEAClUmARl5l0uazSIAESIAESIAESKCSCNDIqyTQfAwJkAAJkAAJkAAJVCYBGnmVSZvPIgESIAESIAESIIFKIkAjr5JA8zEkQAIkQAIkQAIkUJkEaORVJm0+iwRIgARIgARIgAQqiQD95FUSaD6GBEiABEjA+ARyL+Xi0Pkj2BspzpBTlDPkVIiTZGeTTOUIWRxDdwxpDy93T6fpvgtc4Ovpqx0i5zlD7qjjHNtrxBMaeU7z0WVHSYAESIAErBHYH3kQfxxejc0ntmJbxA4kqUgXwYH1Uc2nKnw8fHTUB3v9krfW39KmSYgvVxfnWvCTPmdkZ+rQZtEpMTq0WVC1uujeuIt6dcXA1gMg9/YiNPLsZaSoJwmQAAmQgE0JSNza91ZOx7//moHmKmxVuwZt0CGkHdo3aIsA3wCbPouN2R+ByyqOcWT8Oew+s0fFsN2LXafCkJSehOkj38WQ9oPsokM08uximKgkCZAACZCALQmEx0RgwpxJOBV3Bq/d+aKKT9rNls2zLQckILN8c7cswH/XfIkRHYdh2vAp8PfyM3RPaeQZenioHAmQAAmQgK0JpGSmosPU7mgR1FwZeC/pQPS2fgbbc1wCh84fxqtLJqNJrcb4fsJsQ3fUuRbbDT0UVI4ESIAESKAyCMzZMh/urh54/+63aeBVBnAHe4b8OJh211T8dWQt9kUeMHTvaOQZenioHAmQAAmQgC0JZKlTo5+t+QKjuo6Eh5uHLZtmW05EoEntxujVpAc+Ufs5jSw08ow8OtSNBEiABEjApgSW7vkVqWq5dmiHwTZt19Ebk0MIRhGj6PJAj9FYEvaLPpxhFDaWetDIsyTCexIgARIgAYclcFDtp2qnTs/6efk6bB9NHes8tRe6vdXHdFuu98ycTMxc9zVmb55XrvqmSl+unQXRZ9b6b0xJ5Xo/eO4wHvp6Qrnq2rqSfI68PLxwNOqYrZu2WXs08myGkg2RAAmQAAkYnUBUUhT34ZVhkOZtWYgv180yjEPocd88igPnDpWhBxVbtKZfDVxQnymjirtRFaNeJEACJEACJGBrAhlqZsrbw9vWzRqyvR8enQu4uFyVbuI2xEhilKVaExMfT2/DGMAmnfK/08jLT4PXJEACJEACJOAgBBrWDHWQnrAb5SVAI6+85FiPBEiABEiABK6CgOxTm7n+a+3KReLjfrNxDs7Gn0UN/xq4uUVfPNjjPlRVodXyy54z+zBnyzyEqfcUFVu3VpWa6NGkGx7qOQZ1qtbOX1TvgXNzccOWl9ea02VfXIugZvhs1HTl1Hcm1h5dj8S0JNQLCMKd7W7HqG73KPcyeabB4E9H4HziBV1X9JSX+BWUcm/8/BZ+3fsb5oz/GrtVjNuF2xchOjla6VAHd7S9DaO73ati3nqZn1vcxfJ9K7F411Icu3gcOZdy0KB6Awxo1R//6DJSzbrmtbFsz3JMXva2uRnph4QX+3nSInMaLwoT4J68wkyYQgIkQAIkQAKVRuDnsF+1c11ZGu2p3HJIuDU56DDhuyeQqMJomeT7HT+qtIlYc2Q9GqjYun2a9dIG2Y87l+C+/43F4fNHTEWLfU/NTMP4bx/H8n0rcJ1y6Cuh3M7EncWnf/0XH//+mbnuTc1uxPV1muj7JrWvw20qbqvE9M0vX6z9Hz5c9W9U8fZHdxU1JDE9URuPT81/Tvcjf1nLa+nvK4vfwOtLp0AcDLcJbq3a6KqMxRjMWP0FHv72MSSrOMIi8lx5vov6T0SuRT9K8QQ4k1c8H+aSAAmQAAmQQIUSWH9sI+7r9g88efPjagudi9rjlYkXfnwFG49vhhhR/7rtnzhy4Sg+XPlveLp74oO730HXxp21TmIoyYnVL9d9hX8tehmLHpunyxSn8GkVyq153aaq7Hw9Eyhlt57cjifmPQMxGB+7aYI+ffzPAU/qtmWGra8yqCb0GVeoWdH9uVufxj2dR+g8MUonqXZ2ntqNBdt+wP3dRxWqY0r4fvuPWHngD4SombtPR32kZxMlT4xQMf42HN+Ed5Z/gLeHv6kNUTFGfz/wJ3Iv52LK0NdMzfC9GAKcySsGDrNIgARIgARIoKIJyCzZpJsf0waePEuWKGVZVJw1/7LnN4gD5wXbFkEMurG9HjAbeFLW1cUVD984Fp1CO+il1T8O/iXJJcoT/R4zG3hSWIzG0Bohern0dNzpEuubCohDYJOBJ2nV1PLyK4Ne0NmLd/1sKmb1ff7W73X664NfNht4kiDubcSI8/fyh/TnwpUlY6uNMLFYAjTyisXDTBIgARIgARKoWAL91f47MdbyS3W/QLSp3wrp2el6KVP2vYnc0qJf/mLm6wEtb9bXu66UM2cUcdFatW0pNfyq66T0rAzLrCLvb2mV99z8BZrWuV7vlzuj9hdGJUXnzzJfX0i8iHOJ51G7Sm20Vcu0luKvln97qKXby+q/Xaf3WGbzvpQECn6qSlmJxUiABEiABEiABGxDoEH1YKsNySEGEdmjFpMSo6+DAurqd8t/6gXU00mxKXGWWYXuxaC05gzazdVNl72sZgxLK7I30JqYDoFEX9HbsoypP/WK6I+U/7tPsZbVeV9KAjTySgmKxUiABEiABEigIghYzuKZniGzWCKuyvgqKaqY7FMT8XAvOR6v6fCCrnCV/4hu1sTkz87NYobSVNaUb7q39n7pSp9kHyKlfARo5JWPG2uRAAmQAAmQgE0IRKmZOmti2osms2I1q9TQRc4lnLdWFJEJ53S6LPNWpojbFGtyXi3Hiphm9CzLiOsXkaL6I3nXqk/ybEcRGnmOMpLsBwmQAAmQgF0S2KRO0VpKTEos9kceRIBvgD4J2yGkvS7yx6HVlkXz0g/mpcsBDFuKnPYtTuQEsKWIK5eo5CjI3rzAIozOusrHnfi5i1JG4t6z+y2b0D4At6gTvzLLaeq7LlS8OoXacfYEGnnO/glg/0mABEiABK4pga3h25Uz4L9PoqZnpeNN5WxYHAOPvGE4ZK/cPZ3vgjg2/mrDt9gWvsOsryx7zlyX55BYjKbe1/c059niwrRUmpKZarU5cVKc39CLT43HlF+m6bLizLg4+UfXvHzpa/4ZvbSsNLy6dLJypZKKfs37oKZyDm0SrytLt+IImlIyAfrJK5kRS5AACZAACZBAhRGQE6ZvL38PS8KWoa46bBF2Zi/iUuPQuWEnPKCiXoi0CGqOZwZM0r7yJs59WjsOrlOlFo5ePIbTypFxoJrxe2f4ZJvH5ZXoEyI/qYgUEv3i9ja3oq8yvExSw68GnlnwL7RXPuzEfcrOU7uUA+MUDGx9Kwa1G2gqZvVdXK/ILJ64SRn5+Wg9YydxhaX/CWkJaKZ8+f3fwOcK1BV9xGfghNlPoHHNRpg67PUC+bwpSIBGXkEevCMBEiABEiCBSiUwvONgbaTN3boQG6NO6FOl96mwYDIT5u7299e0GEWyBCrRMMQ4OnL+qN7zNqrrPdqZsmmfmy2V7319D9zb5W78pkKPbT6xRRlWDQsYeY/d9LAOZyZG4MFzh9BIxcsd0Wk4Bre/o0Q1ZCn27WFvKlcp3bBk9zLVp336gElIjQbKuB2tZjHvKuTY+cXbn8fbv76H8JgIxKi9jOJ8WYxLinUCLmqq97L1LKaSAAmQAAmQgGMRGPfd4/BSzoYlSsO1FlPs2kf7jMe43g9ea3XK9HxT7No3h7yqZ/fKVNmBCo+e+SAm9B6Lh3rcb8hecU+eIYeFSpEACZAACZAACZDA1RGgkXd1/FibBEiABEjAjgjI4QU50EAhAVsQyMnN1QdibNFWRbRBI68iqLJNEiABEiABQxKopfzNJaQlGlI3KmV/BOLS4gvEADZaD7gnz2gjQn1IgARIgAQqjMB/187El+u/xg+PzS0UL7bCHsqGHZKAxN+989O7sObZFTrOsBE7yZk8I44KdSIBEiABEqgQAiM6DsPFpCisP7apQtpno85DYJ46Dd2+QVu0rtfSsJ2mkWfYoaFiJEACJEACtiYgbkbu63ovvts0V7nroHMJW/N1lvZkyX+p8mv4VL+JKCkqyLVkQiPvWtLns0mABEiABCqdwMSbJuDAuYNYuH0RDb1Kp2//D8zIzsAHKz/WjqvvUM6hjSw08ow8OtSNBEiABEjA5gRCa4Tgk3s+wH/XzMTzP7wICcVFIYHSEJBoG2NmjYfE5/3ivk91yLnS1LtWZXjw4lqR53NJgARIgASuKYET0eE6PNbZhEgM7zhE7a9qp8KFtbJ5aLBr2kk+/KoJyI8ACbW2I2IXFu9eiuEdhmKaCiFX1bvKVbdd0Q3QyKtowmyfBEiABEjAsASyc7MxQ83orTiwSn+RX1L79FoENUPLei30l7iPp482+oy878qwcO1QsUuXLyE9Kx1p6hWbEos9Z/YhIvaU+ixURddGN2CUCjU3uF3JIduM0nUaeUYZCepBAiRAAiRwTQnIXqtdp8Ow+eQ2HRs2OSMZqVlp+gv/mip2TR5+GVk5WVdix7pcEw2uxUPFmPfz8oW/px+q+wXihtBOKrZuV7So2wyurva3w41G3rX4FPGZJEACJEACJGBgApEJ59F2chfsfW0b6gcEGVhTqlYcAfszS4vrDfNIgARIgARIgARIgAQ0ARp5/CCQAAmQAAmQAAmQgAMSoJHngIPKLpEACZAACZAACZAAjTx+BkiABEiABEiABEjAAQnQyHPAQWWXSIAESIAESIAESIBGHj8DJEACJEACJEACJOCABGjkOeCgskskQAIkQAIkQAIkQD95/AyQAAmQAAmQwBUCuZdycUjFJd0buR/JGSnKGXIqxEmys0mmcoQsjqE7hrSHl7un03TfBS7w9fTVDpHznCF3RIPAYNhrxBMaeU7z0WVHSYAESIAErBHYH3kQfxxejc0ntmJbxA4kqUgXwYH1Uc2nKnw8fHTUB3v9krfW39KmSYgvVxfnWvCTPmdkZ+rQZtEpMTq0WVC1uujeuIt6dcXA1gMg9/YiNPLsZaSoJwmQAAmQgE0JSNza91ZOx7//moHmKmxVuwZt0CGkHdo3aIsA3wCbPouN2R+ByyqOcWT8Oew+s0fFsN2LXafCkJSehOkj38WQ9oPsokM08uximKgkCZAACZCALQmEx0RgwpxJOBV3Bq/d+aKKT9rNls2zLQckILN8c7cswH/XfIkRHYdh2vAp8PfyM3RPaeQZenioHAmQAAmQgK0JpGSmosPU7mgR1FwZeC/pQPS2fgbbc1wCh84fxqtLJqNJrcb4fsJsQ3fUuRbbDT0UVI4ESIAESKAyCMzZMh/urh54/+63aeBVBnAHe4b8OJh211T8dWQt9kUeMHTvaOQZenioHAmQAAmQgC0JZKlTo5+t+QKjuo6Eh5uHLZtmW05EoEntxujVpAc+Ufs5jSw08ow8OtSNBEiABEjApgSW7vkVqWq5dmiHwTZtl43ZjoAceLAHeaDHaCwJ+0UfzjCqvjTyjDoy1IsESIAESMDmBA6q/VTt1OlZPy9fm7dt6wa/XDsLnaf2wqz139i6aZu398bPb2ldl+9beVVtbz25HU/Of/aq2qisyvI58vLwwtGoY5X1yDI/x73MNViBBEiABEiABOyUQFRSFPfhGXTsopNj8MS8Z+zKD11Nvxq4oD5TRhXO5Bl1ZKgXCZAACZCAzQlk5GTC28Pb5u2ywasnIC5K7E18PL0NHRGFRp69faKoLwmQAAmQAAmQAAmUggCXa0sBiUVIgARIgARI4FoSWLn/d3y7aQ5OxZ7Ry839WtyEcb0eQFUVes0kOZdy8PPuX7DywB84EX0S4g/Q38tf+QNspk4T34Pu13U1FcXOiF14dM6TGN3tXtTyr4lvVNsSo/eGhh0x/Z738Mh3T+jYtb//8xcs2LYIy/YsR2J6IhpUD8awjoMxotOwUoU8E51+2rkUv+xdjvCYUyoyrAsa1WqIQW0H6nbcXfPMENl/OHP911q/84kX9P4+iZv7xZjPzDrzouwEaOSVnRlrkAAJkAAJkEClEVihDLyI2FNoXKsRejftgX1nD2Le1oXYeHwzZj34uY6xKydSn//+JWw4vkmHZGtdv5XyBeiOY1HHseXkNsiBBvEL2KdZ7wJ6rz+6EWfizqJzo07Izs1Bg8DgAvmTl72D9cc2okODdmge1BTbw3fi/RXTsffMfkwd9nqBspY3mWpp/Kn5z2Hnqd3w8/TVBqSU2aXu31vxEdYd3YCP7nlXu7JpUqcJbmp2I9YcWafjBYuejWqGWjbJ+zISoJFXRmAsTgIkQAIkQAKVSUAMvPG9H8Ijfcbpx4rx9MriN5RBtB4zVn+BF29/Hn8eWq0NvLbBbfCf0R+rfYdeuqzsc/v4988wf9v3+H7Hj4WMvNMqrNuzA57CvV3uNpfP37dNJ7bgvRFvoW/zPjr5fMIFPDp7kpot/F2l3YibW/TNX7zA9YzVX2oDT3T6cOQ75njAcanxeGbhv7Tx+fna/2FSv8fQT7Xfql4LbeQF+FbDlKGvFWiLN+UjwD155ePGWiRAAiRAAiRQKQQa1gjFwzc+ZH6Wl7sXXr7jBXi6eeLXvSuQnpUOMeZubNoLT/R71GzgSQVXF1cM6TBI172QeNHchulC2hjecYjpttASrOSZDDwpFBRQF/8c8KQu/+POJeZ6lhcZ2ZmQfDdXN7w17A2zgSflqvsF6jQ3Fzf8sP0niNFKqRgCNPIqhitbJQESIAESIAGbEOjfsl8h40tmu9oEt9IGkvj+G9Cqv5otm4YOIe3MzxTj70DkQfx1aK1Oy1HLsZYSWjMEnu6elsnm+wEtbzZfmy56NOmml4LDzuzVxqUpPf+7xHcV462NWjauW61O/ix9HRxYHy3rNUd6djoOnTtcKJ8JtiHA5VrbcGQrJEACJEACJFAhBIKq1bXabu0qtXV6jPIvJ5KckYyfdi3F5hNb9SGHuNQ4nS6HHUQuq/8spZr33wc3LPPkPlgdtLAUCQdX3a86opKjkJiWiEA1M2cp4vNOJKhakGWW+b5eQJCO/Rp7RU9zBi9sRoBGns1QsiESIAESIAESsD0B0/66olp2d3PH8aiTeFydlo1PS9AGmMySNa7ZEM3qNtUnYsfMGm+1uotLngFoNVMluqnlXuuSZzC6quVY61LYoLQsl3vFLx5jCFuSsd09jTzbsWRLJEACJEACJGBzAqZZMcuGzyee10m1q9TCByunawNPDmhMuHEs8htvx6NOWFYt9X2UmpGznKnLysmCzL75ePjok73WGqup3LKInEs4Zy1bp0XG5+XVULOClIohUJSJXjFPY6skQAIkQAIkQAJlIrA1fHuh8lFJ0Xqp08/LT8/W7Vd770Qe6nl/AQNP0sSFikh5IkpsUm5aLGWDSsu9lIuujW+wzDLfy0yiRBbZf+4gLii/d5ZyNi4SRy4c1X78mta9XmeblpUty/K+/ARo5JWfHWuSAAmQAAmQQIUTkD12stfOJKmZaXj956na0Lqr01B9cKJO1bz9eeJ7Lr9sOLYJM9d9pZNkBq6s8u3muZBDFCY5Gx+J6as+0bf3ds5zu2LKy/8uBt6wDoO1ji8vfhMJau+eSeKVC5WXl7yhjU5xrGxarjUdAEnLSoP4/aNcPQEu1149Q7ZAAiRAAiRAAhVGQE6ovrP8fSwN+wV1q9ZB2Jk9EF9z4qBYlmZFJKLFtN8+wEs/vY7vt/+ol1jDYyLUAYwIiAEos2RJ6mCGGHomY6o0Cvt5+uGhrx9B54adIHv/xBmynJod23MMOqnoGMXJ430fwWE1W7f7dBiG/mckJIKFiDhDTlWGXLfGXfBon7/3ClZT0TvklZiehPHfPq5P34oPP0r5CdDIKz871iQBEiABEiCBCicgjooHZQzE3K0LsP7icW20jeg0HGN6jIL4zBORGT0fTx8Vgux7HL14DBJOTE62juk+SpW7D5OXva0jTMisoGXUi+I68OqgF7AlfBt+27dKhT1LR3N1kENCoeX3nVdUfTkw8p/R0/HDjsWq/gpsC9+hZ+0a126Mwe3uwOD2dxRwDSP7CN8c8iqm//6pnj2MTYnVjpqLap/pJRNwUVOinBMtmRNLkAAJkAAJOACBcd89Di9lfDx369MO0JuK64Ipdu3MMf9B+3y+9yruifbZ8uiZD2JC77F4qMf9huwA9+QZclioFAmQAAmQAAmQAAlcHQEaeVfHj7VJgARIgATsiICE0pKlTAoJ2IJATm6u8iVYlK9AWzzh6tqgkXd1/FibBEiABEjAjgjUqlKjwElPO1KdqhqQQFxaPGpVyfMJaED1wIMXRhwV6kQCJEACJFAhBCRm6vL9q7T7DtciozlUyKPtqtEvxnxmV/peC2UvJF5UPxgSIJ8powpn8ow6MtSLBEiABEjA5gRGdByGi0lRWK/8x1FI4GoIzNu6EO0btEXrei2vppkKrUsjr0LxsnESIAESIAEjEZCltfu63ovvNs2lw10jDYyd6SLOnZeGLcNT/SYWijBipK7QyDPSaFAXEiABEiCBCicw8aYJOKDCbS3cvoiGXoXTdrwHZGRnqFjBH2vH1He0udXQHaSRZ+jhoXIkQAIkQAK2JhBaIwSf3PMB/rtmJp7/4UVImC0KCZSGgMTbHTNrPA6fP4Iv7vsUbq7GPVkr/aEz5NKMKsuQAAmQAAk4HIET0eGYMPsJnE2IxPCOQ9T+qnZoE9wKEneVQgImAvIjIOzMXuyI2IXFu5dieIehmDZ8Mqp6VzEVMew7jTzDDg0VIwESIAESqGgC2bnZmKFm9FYcWKW/yC+pIFAtgpqpuKkt9Je4hAoTo09CblEcn8Cly5eQnpWONPWSsGp7zuxDROwp9Vmoiq6NbsCoLiN1SDZ7IUEjz15GinqSAAmQAAlUKAHZa7XrdBg2n9yGvWf3IzkjGalZafoLv0IfzMYNQ0CMeT8vX/h7+qG6XyBuCO2EHtd1RYu6zeDqan873GjkGeajRUVIgARIgARIgARIwHYE7M8stV3f2RIJkAAJkAAJkAAJOCwBGnkOO7TsGAmQAAmQAAmQgDMToJHnzKPPvpMACZAACZAACTgsARp5Dju07BgJkAAJkAAJkIAzE6CR58yjz76TAAmQAAmQAAk4LAEaeQ47tOwYCZAACZAACZCAMxOgkefMo8++kwAJkAAJkAAJOCwBGnkOO7TsGAmQAAmQAAmQgDMToJHnzKPPvpMACZAACZAACTgsARp5Dju07BgJkAAJkAAJkIAzE6CR58yjz76TAAmQAAmQAAk4LAEaeQ47tOwYCZAACZAACZCAMxOgkefMo8++kwAJkAAJkAAJOCwBGnkOO7TsGAmQAAmQAAmQgDMToJHnzKPPvpMACZAACZAACTgsARp5Dju07BgJkAAJkAAJkIAzE6CR58yjz76TAAmQAAmQAAk4LAEaeQ47tOwYCZAACZAACZCAMxP4f6qXuUVfFbW9AAAAAElFTkSuQmCC" } }, "cell_type": "markdown", "metadata": {}, "source": [ "Just as before, it can be helpful to think about what your end goal looks like. Let's say I want to end up with a scatterplot that shows bird bill length relative to body weight, with the *color* of each point corresponding to bird species, and the *shape* of the point corresponding to bird sex. With that goal in mind, let's look at syntax.\n", "\n", "### Defining the Data\n", "We are going to continue using our penguins data set. `seaborn` has numerous functions for drawing different plots, summarized in the figure below. There are three different broad \"families\" of `seaborn` plots, which are shown in the figure below:\n", "\n", "\n", "![image.png](attachment:image.png)\n", "\n", "- `relplot` plots show relationships between variables\n", "- `displot` show distibutions\n", "- `catplot` plot categorical data \n", "\n", "Each plot function within a family usually has similar syntax, as they represent data in similar ways. To create a plot, we call one of these functions and specify our (`pandas`) dataframe and which columns to encode in which axis. For example, if we wanted a histogram:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "penguins = pd.read_csv('https://raw.githubusercontent.com/rfordatascience/tidytuesday/main/data/2020/2020-07-28/penguins.csv')\n", "penguins.head()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "sns.histplot(data=penguins, x=\"flipper_length_mm\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see that for this type of plot, we only need to encode a single column (for the x-axis), but other types of plots might require additional axes. For example, a boxplot needs both an x and y axis defined:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "sns.boxplot(data=penguins,x=\"species\",y=\"bill_length_mm\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Documentation for each plot type is on `seaborn`'s website, and it lists all required and optional arguments for each plot function: [seaborn](https://seaborn.pydata.org/index.html)\n", "\n", "### Changing plot aesthetics\n", "We can do much more useful things than just setting the x and y axis, however! We will frequently want to group our data, e.g. by species, by sex, etc., and change the plot aesthtics to reflect these groups. To do this, we add an additional argument that specifies which column in our data frame that we want to group on. For example, to color the bars on our histogram based on species, we would use the `hue` argument: " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "sns.histplot(data=penguins, x=\"flipper_length_mm\",hue=\"species\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see we have changed the colors of the bars, but as they are overlapping it is difficult to read. If we dig into the documentation of the `histplot` function, we can find that there is also the `multiple` argument, which changes how overlapping bars behave...let's make them stack instead of overlap:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "sns.histplot(data=penguins, x=\"flipper_length_mm\",hue=\"species\",multiple=\"stack\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ ">Exercise: check the documentation page for the `scatterplot` function, and see if you can figure out how to make a scatter plot that shows bird bill length relative to body weight, with the *color* of each point corresponding to bird species, and the *shape* of the point corresponding to bird sex." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Your code here" ] } ], "metadata": { "kernelspec": { "display_name": "pyworkshop", "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.13.1" } }, "nbformat": 4, "nbformat_minor": 2 }