diff --git a/cobra/evaluation/pigs_tables.py b/cobra/evaluation/pigs_tables.py index 6cca2d0..91d52d8 100644 --- a/cobra/evaluation/pigs_tables.py +++ b/cobra/evaluation/pigs_tables.py @@ -1,16 +1,20 @@ - import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import numpy as np from matplotlib.ticker import FuncFormatter - import cobra.utils as utils +import logging + +# logging.basicConfig(level=logging.DEBUG) -def generate_pig_tables(basetable: pd.DataFrame, - target_column_name: str, - preprocessed_predictors: list, - id_column_name: str = None) -> pd.DataFrame: + +def generate_pig_tables( + basetable: pd.DataFrame, + target_column_name: str, + preprocessed_predictors: list, + id_column_name: str = None, +) -> pd.DataFrame: """Compute PIG tables for all predictors in preprocessed_predictors. The output is a DataFrame with columns ``variable``, ``label``, @@ -26,25 +30,25 @@ def generate_pig_tables(basetable: pd.DataFrame, List of basetable column names containing preprocessed predictors. id_column_name : str, default=None Name of the basetable column containing the IDs of the basetable rows - (e.g. customernumber). + (e.g. customernumber). Returns ------- pd.DataFrame DataFrame containing a PIG table for all predictors. """ - #check if there is a id-column and define no_predictor accordingly - if id_column_name == None: + # check if there is a id-column and define no_predictor accordingly + if id_column_name is None: no_predictor = [target_column_name] else: no_predictor = [id_column_name, target_column_name] - pigs = [ - compute_pig_table(basetable, - column_name, - target_column_name, - ) + compute_pig_table( + basetable, + column_name, + target_column_name, + ) for column_name in sorted(preprocessed_predictors) if column_name not in no_predictor ] @@ -52,9 +56,11 @@ def generate_pig_tables(basetable: pd.DataFrame, return output -def compute_pig_table(basetable: pd.DataFrame, - predictor_column_name: str, - target_column_name: str) -> pd.DataFrame: +def compute_pig_table( + basetable: pd.DataFrame, + predictor_column_name: str, + target_column_name: str +) -> pd.DataFrame: """Compute the PIG table of a given predictor for a given target. Parameters @@ -76,38 +82,44 @@ def compute_pig_table(basetable: pd.DataFrame, # group by the binned variable, compute the incidence # (= mean of the target for the given bin) and compute the bin size # (e.g. COUNT(id_column_name)). After that, rename the columns - - res = (basetable.groupby(predictor_column_name) - .agg( - avg_target = (target_column_name, "mean"), - pop_size = (target_column_name, "size") - ) - .reset_index() - .rename( - columns={predictor_column_name: "label"} - ) + res = ( + basetable.groupby(predictor_column_name) + .agg( + avg_target=(target_column_name, "mean"), + pop_size=(target_column_name, "size"), + std_dev_target=(target_column_name, "std"), + ) + .reset_index() + .rename(columns={predictor_column_name: "label"}) ) - # add the column name to a variable column # add the average incidence # replace population size by a percentage of total population res["variable"] = utils.clean_predictor_name(predictor_column_name) res["global_avg_target"] = global_avg_target - res["pop_size"] = res["pop_size"]/len(basetable.index) - + res["pop_size"] = res["pop_size"] / len(basetable.index) # make sure to always return the data with the proper column order - column_order = ["variable", "label", "pop_size", - "global_avg_target", "avg_target"] + column_order = [ + "variable", + "label", + "pop_size", + "global_avg_target", + "avg_target", + "std_dev_target", + ] return res[column_order] -def plot_incidence(pig_tables: pd.DataFrame, - variable: str, - model_type: str, - column_order: list=None, - dim: tuple=(12, 8)): +def plot_incidence( + pig_tables: pd.DataFrame, + variable: str, + model_type: str, + column_order: list = None, + dim: tuple = (12, 8), + show_error: bool = False, +): """Plots a Predictor Insights Graph (PIG), a graph in which the mean target value is plotted for a number of bins constructed from a predictor variable. When the target is a binary classification target, @@ -130,28 +142,33 @@ def plot_incidence(pig_tables: pd.DataFrame, on the PIG. dim: tuple, default=(12, 8) Optional tuple to configure the width and length of the plot. + show_error: bool, default=False + Indicate if the standard deviation per bin should be showed. This can + be useful in regression. """ if model_type not in ["classification", "regression"]: - raise ValueError("An unexpected value was set for the model_type " - "parameter. Expected 'classification' or " - "'regression'.") + raise ValueError( + "An unexpected value was set for the model_type " + "parameter. Expected 'classification' or " + "'regression'." + ) - df_plot = pig_tables[pig_tables['variable'] == variable].copy() + df_plot = pig_tables[pig_tables["variable"] == variable].copy() if column_order is not None: - if not set(df_plot['label']) == set(column_order): + if not set(df_plot["label"]) == set(column_order): raise ValueError( - 'The column_order and pig_tables parameters do not contain ' - 'the same set of variables.') + "The column_order and pig_tables parameters do not contain " + "the same set of variables." + ) - df_plot['label'] = df_plot['label'].astype('category') - df_plot['label'].cat.reorder_categories(column_order, - inplace=True) + df_plot["label"] = df_plot["label"].astype("category") + df_plot["label"].cat.reorder_categories(column_order, inplace=True) - df_plot.sort_values(by=['label'], ascending=True, inplace=True) + df_plot.sort_values(by=["label"], ascending=True, inplace=True) df_plot.reset_index(inplace=True) else: - df_plot.sort_values(by=['avg_target'], ascending=False, inplace=True) + df_plot.sort_values(by=["avg_target"], ascending=False, inplace=True) df_plot.reset_index(inplace=True) with plt.style.context("seaborn-ticks"): @@ -160,35 +177,54 @@ def plot_incidence(pig_tables: pd.DataFrame, # -------------------------- # Left axis - average target # -------------------------- - ax.plot(df_plot['label'], df_plot['avg_target'], - color="#00ccff", marker=".", - markersize=20, linewidth=3, - label='incidence rate per bin' if model_type == "classification" else "mean target value per bin", - zorder=10) - - ax.plot(df_plot['label'], df_plot['global_avg_target'], - color="#022252", linestyle='--', linewidth=4, - label='average incidence rate' if model_type == "classification" else "global mean target value", - zorder=10) + error = df_plot["std_dev_target"] / 2 if show_error else None + ax.errorbar( + df_plot["label"], + df_plot["avg_target"], + yerr=error, + color="#00ccff", + marker=".", + markersize=15, + linewidth=3, + elinewidth=2, + capsize=5, + barsabove=True, + label="incidence rate per bin" + if model_type == "classification" + else "mean target value per bin", + zorder=10, + ) + + ax.plot( + df_plot["label"], + df_plot["global_avg_target"], + color="#022252", + linestyle="--", + linewidth=4, + label="average incidence rate" + if model_type == "classification" + else "global mean target value", + zorder=10, + ) # Dummy line to have label on second axis from first - ax.plot(np.nan, "#939598", linewidth=6, label='bin size') + ax.plot(np.nan, "#939598", linewidth=6, label="bin size") # Set labels & ticks - ax.set_ylabel('Incidence' if model_type == "classification" else "Mean target value", - fontsize=16) + ax.set_ylabel( + "Incidence" if model_type == "classification" else "Mean target value", + fontsize=16, + ) ax.set_xlabel("Bins", fontsize=15) ax.xaxis.set_tick_params(labelsize=14) - plt.setp(ax.get_xticklabels(), - rotation=45, ha="right", rotation_mode="anchor") + plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor") ax.yaxis.set_tick_params(labelsize=14) if model_type == "classification": # Mean target values are between 0 and 1 (target incidence rate), # so format them as percentages - ax.set_yticks(np.arange(0, max(df_plot['avg_target'])+0.05, 0.05)) - ax.yaxis.set_major_formatter( - FuncFormatter(lambda y, _: '{:.1%}'.format(y))) + ax.set_yticks(np.arange(0, max(df_plot["avg_target"]) + 0.05, 0.05)) + ax.yaxis.set_major_formatter(FuncFormatter(lambda y, _: "{:.1%}".format(y))) elif model_type == "regression": # If the difference between the highest avg. target of all bins # versus the global avg. target AND the difference between the @@ -200,40 +236,52 @@ def plot_incidence(pig_tables: pd.DataFrame, # the bins and versus the global avg. target. # (Motivation for the AND above: if on one end there IS enough # difference, the effect that we discuss here does not occur.) - global_avg_target = max(df_plot['global_avg_target']) # series of same number, for every bin. - if ((np.abs((max(df_plot['avg_target']) - global_avg_target)) / global_avg_target < 0.25) - and (np.abs((min(df_plot['avg_target']) - global_avg_target)) / global_avg_target < 0.25)): - ax.set_ylim(global_avg_target * 0.75, - global_avg_target * 1.25) + global_avg_target = max( + df_plot["global_avg_target"] + ) # series of same number, for every bin. + if ( + np.abs((max(df_plot["avg_target"]) - global_avg_target)) + / global_avg_target + < 0.25 + ) and ( + np.abs((min(df_plot["avg_target"]) - global_avg_target)) + / global_avg_target + < 0.25 + ): + ax.set_ylim(global_avg_target * 0.75, global_avg_target * 1.25) # Remove ticks but keep the labels - ax.tick_params(axis='both', which='both', length=0) - ax.tick_params(axis='y', colors="#00ccff") - ax.yaxis.label.set_color('#00ccff') + ax.tick_params(axis="both", which="both", length=0) + ax.tick_params(axis="y", colors="#00ccff") + ax.yaxis.label.set_color("#00ccff") # ----------------- # Right Axis - bins # ----------------- ax2 = ax.twinx() - ax2.bar(df_plot['label'], df_plot['pop_size'], - align='center', color="#939598", zorder=1) + ax2.bar( + df_plot["label"], + df_plot["pop_size"], + align="center", + color="#939598", + zorder=1, + ) # Set labels & ticks ax2.set_xlabel("Bins", fontsize=15) ax2.xaxis.set_tick_params(rotation=45, labelsize=14) ax2.yaxis.set_tick_params(labelsize=14) - ax2.yaxis.set_major_formatter( - FuncFormatter(lambda y, _: '{:.1%}'.format(y))) - ax2.set_ylabel('Population size', fontsize=15) - ax2.tick_params(axis='y', colors="#939598") - ax2.yaxis.label.set_color('#939598') + ax2.yaxis.set_major_formatter(FuncFormatter(lambda y, _: "{:.1%}".format(y))) + ax2.set_ylabel("Population size", fontsize=15) + ax2.tick_params(axis="y", colors="#939598") + ax2.yaxis.label.set_color("#939598") # Despine & prettify sns.despine(ax=ax, right=True, left=True) sns.despine(ax=ax2, left=True, right=False) - ax2.spines['right'].set_color('white') + ax2.spines["right"].set_color("white") ax2.grid(False) @@ -244,9 +292,15 @@ def plot_incidence(pig_tables: pd.DataFrame, title = "Mean target plot" fig.suptitle(title, fontsize=20) plt.title(variable, fontsize=17) - ax.legend(frameon=False, bbox_to_anchor=(0., 1.01, 1., .102), - loc=3, ncol=1, mode="expand", borderaxespad=0., - prop={"size": 14}) + ax.legend( + frameon=False, + bbox_to_anchor=(0.0, 1.01, 1.0, 0.102), + loc=3, + ncol=1, + mode="expand", + borderaxespad=0.0, + prop={"size": 14}, + ) # Set order of layers ax.set_zorder(1) diff --git a/tests/preprocessing/test_pig_tables.py b/tests/preprocessing/test_pig_tables.py index 3b1e6a7..3fbdaf5 100644 --- a/tests/preprocessing/test_pig_tables.py +++ b/tests/preprocessing/test_pig_tables.py @@ -4,6 +4,7 @@ from cobra.evaluation.pigs_tables import generate_pig_tables from typing import Optional +import numpy as np class TestPigTablesGeneration: @@ -36,20 +37,12 @@ def test_col_id(self, id_col_name: Optional[str]): # expected expected = pd.DataFrame( { - "variable": [ - "age", - "age", - "age", - "age", - "pclass", - "pclass", - "sex", - "sex", - ], + "variable": ["age", "age", "age", "age", "pclass", "pclass", "sex", "sex",], "label": [22.0, 35.0, 38.0, 54.0, 1, 3, "female", "male"], "pop_size": [0.2, 0.4, 0.2, 0.2, 0.6, 0.4, 0.4, 0.6], "global_avg_target": [0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4], "avg_target": [0.0, 0.5, 1.0, 0.0, 0.6666666666666666, 0.0, 1.0, 0.0], + "std_dev_target": [np.nan, 0.7071067811865476, np.nan, np.nan, 0.5773502691896258, 0.0, 0.0, 0.0,], } ) diff --git a/tutorials/tutorial_Cobra_linear_regression.ipynb b/tutorials/tutorial_Cobra_linear_regression.ipynb index 9699da6..35a0af3 100644 --- a/tutorials/tutorial_Cobra_linear_regression.ipynb +++ b/tutorials/tutorial_Cobra_linear_regression.ipynb @@ -9,12 +9,22 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 75, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "import sys\n", - "sys.path.insert(0, \"C:/Users/samuel.borms/Desktop/code/cobra\")\n", + "\n", + "sys.path.insert(0, \"/home/patrick/Git\")\n", "%load_ext autoreload\n", "%autoreload 2" ] @@ -28,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 76, "metadata": {}, "outputs": [], "source": [ @@ -44,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 77, "metadata": {}, "outputs": [], "source": [ @@ -100,7 +110,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 78, "metadata": {}, "outputs": [], "source": [ @@ -119,7 +129,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 79, "metadata": {}, "outputs": [], "source": [ @@ -142,7 +152,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 80, "metadata": {}, "outputs": [ { @@ -159,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 81, "metadata": {}, "outputs": [ { @@ -275,7 +285,7 @@ "4 70 usa ford torino " ] }, - "execution_count": 7, + "execution_count": 81, "metadata": {}, "output_type": "execute_result" } @@ -296,7 +306,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 82, "metadata": {}, "outputs": [ { @@ -314,7 +324,7 @@ "dtype: object" ] }, - "execution_count": 8, + "execution_count": 82, "metadata": {}, "output_type": "execute_result" } @@ -332,7 +342,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 83, "metadata": {}, "outputs": [], "source": [ @@ -376,7 +386,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 84, "metadata": {}, "outputs": [], "source": [ @@ -393,7 +403,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 85, "metadata": {}, "outputs": [ { @@ -410,7 +420,7 @@ "Name: mpg, dtype: float64" ] }, - "execution_count": 11, + "execution_count": 85, "metadata": {}, "output_type": "execute_result" } @@ -422,7 +432,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 86, "metadata": {}, "outputs": [ { @@ -431,7 +441,7 @@ "(398, 10)" ] }, - "execution_count": 12, + "execution_count": 86, "metadata": {}, "output_type": "execute_result" } @@ -451,7 +461,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 87, "metadata": {}, "outputs": [ { @@ -477,7 +487,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 88, "metadata": {}, "outputs": [ { @@ -505,7 +515,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 89, "metadata": {}, "outputs": [ { @@ -514,7 +524,7 @@ "['origin', 'name', 'cylinders']" ] }, - "execution_count": 15, + "execution_count": 89, "metadata": {}, "output_type": "execute_result" } @@ -533,16 +543,16 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 90, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['weight', 'model_year', 'displacement', 'horsepower', 'acceleration']" + "['horsepower', 'weight', 'acceleration', 'model_year', 'displacement']" ] }, - "execution_count": 16, + "execution_count": 90, "metadata": {}, "output_type": "execute_result" } @@ -563,7 +573,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 91, "metadata": {}, "outputs": [], "source": [ @@ -572,14 +582,14 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 92, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "The target encoder's additive smoothing weight is set to 0. This disables smoothing and may make the encoding prone to overfitting. Increase the weight if needed.\n" + "WARNING:cobra.preprocessing.target_encoder:The target encoder's additive smoothing weight is set to 0. This disables smoothing and may make the encoding prone to overfitting. Increase the weight if needed.\n" ] } ], @@ -601,7 +611,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 93, "metadata": {}, "outputs": [], "source": [ @@ -621,13 +631,22 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 94, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:\n", + "Percentage of missing values per variable:\n", + "horsepower 1.25%\n" + ] + }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "dd625b675c954873aaed2bcb4a6fea17", + "model_id": "05a0af4d00c14c68b192f36107d8f4bb", "version_major": 2, "version_minor": 0 }, @@ -641,7 +660,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "76fc6508056041d6bbfc161790ff15b4", + "model_id": "76cb408ca8aa43fc9070bdcf2e2bb83b", "version_major": 2, "version_minor": 0 }, @@ -655,7 +674,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6a461f8c403c4f6db2091e67dc8edeea", + "model_id": "23aa1bf549ae4d9ba25477a842a9f41f", "version_major": 2, "version_minor": 0 }, @@ -669,7 +688,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3890953c148d46d8bb752ce042fff0fb", + "model_id": "7065232fe34e4afd84b9d73e69561382", "version_major": 2, "version_minor": 0 }, @@ -697,13 +716,13 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 95, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "aa7ddebf11a642a59e461141833de520", + "model_id": "f8f085e490364f2d91d68252177d67d7", "version_major": 2, "version_minor": 0 }, @@ -717,7 +736,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4411d558ec814f269aea7ed56b414982", + "model_id": "11ff276fc1664056b74d6f8cb2483f8e", "version_major": 2, "version_minor": 0 }, @@ -760,22 +779,22 @@ " name\n", " id\n", " split\n", + " horsepower_bin\n", " weight_bin\n", + " acceleration_bin\n", " model_year_bin\n", " displacement_bin\n", - " horsepower_bin\n", - " acceleration_bin\n", " origin_processed\n", " name_processed\n", " cylinders_processed\n", " origin_enc\n", " name_enc\n", " cylinders_enc\n", + " horsepower_enc\n", " weight_enc\n", + " acceleration_enc\n", " model_year_enc\n", " displacement_enc\n", - " horsepower_enc\n", - " acceleration_enc\n", " \n", " \n", " \n", @@ -792,22 +811,22 @@ " chevrolet chevelle malibu\n", " 1\n", " validation\n", + " 113.0 - 145.0\n", " 3432.0 - 3883.0\n", + " 8.0 - 12.0\n", " 70.0 - 71.0\n", " 250.0 - 318.0\n", - " 113.0 - 145.0\n", - " 8.0 - 12.0\n", " usa\n", " chevrolet chevelle malibu\n", " 8\n", " 20.35871\n", " 17.0\n", " 15.051515\n", + " 18.769231\n", " 17.129167\n", + " 16.185185\n", " 19.057143\n", " 16.793333\n", - " 18.769231\n", - " 16.185185\n", " \n", " \n", " 1\n", @@ -822,22 +841,22 @@ " buick skylark 320\n", " 2\n", " train\n", + " 162.0 - 230.0\n", " 3432.0 - 3883.0\n", + " 8.0 - 12.0\n", " 70.0 - 71.0\n", " 318.0 - 350.0\n", - " 162.0 - 230.0\n", - " 8.0 - 12.0\n", " usa\n", " buick skylark 320\n", " 8\n", " 20.35871\n", " 15.0\n", " 15.051515\n", + " 13.612500\n", " 17.129167\n", + " 16.185185\n", " 19.057143\n", " 15.035294\n", - " 13.612500\n", - " 16.185185\n", " \n", " \n", " 2\n", @@ -852,22 +871,22 @@ " plymouth satellite\n", " 3\n", " train\n", + " 145.0 - 162.0\n", " 3432.0 - 3883.0\n", + " 8.0 - 12.0\n", " 70.0 - 71.0\n", " 250.0 - 318.0\n", - " 145.0 - 162.0\n", - " 8.0 - 12.0\n", " usa\n", " plymouth satellite\n", " 8\n", " 20.35871\n", " 18.0\n", " 15.051515\n", + " 14.380952\n", " 17.129167\n", + " 16.185185\n", " 19.057143\n", " 16.793333\n", - " 14.380952\n", - " 16.185185\n", " \n", " \n", " 3\n", @@ -882,22 +901,22 @@ " amc rebel sst\n", " 4\n", " train\n", + " 145.0 - 162.0\n", " 3432.0 - 3883.0\n", + " 8.0 - 12.0\n", " 70.0 - 71.0\n", " 250.0 - 318.0\n", - " 145.0 - 162.0\n", - " 8.0 - 12.0\n", " usa\n", " amc rebel sst\n", " 8\n", " 20.35871\n", " 16.0\n", " 15.051515\n", + " 14.380952\n", " 17.129167\n", + " 16.185185\n", " 19.057143\n", " 16.793333\n", - " 14.380952\n", - " 16.185185\n", " \n", " \n", " 4\n", @@ -912,22 +931,22 @@ " ford torino\n", " 5\n", " train\n", + " 113.0 - 145.0\n", " 3432.0 - 3883.0\n", + " 8.0 - 12.0\n", " 70.0 - 71.0\n", " 250.0 - 318.0\n", - " 113.0 - 145.0\n", - " 8.0 - 12.0\n", " usa\n", " ford torino\n", " 8\n", " 20.35871\n", " 17.0\n", " 15.051515\n", + " 18.769231\n", " 17.129167\n", + " 16.185185\n", " 19.057143\n", " 16.793333\n", - " 18.769231\n", - " 16.185185\n", " \n", " \n", "\n", @@ -948,36 +967,36 @@ "3 70 usa amc rebel sst 4 train \n", "4 70 usa ford torino 5 train \n", "\n", - " weight_bin model_year_bin displacement_bin horsepower_bin \\\n", - "0 3432.0 - 3883.0 70.0 - 71.0 250.0 - 318.0 113.0 - 145.0 \n", - "1 3432.0 - 3883.0 70.0 - 71.0 318.0 - 350.0 162.0 - 230.0 \n", - "2 3432.0 - 3883.0 70.0 - 71.0 250.0 - 318.0 145.0 - 162.0 \n", - "3 3432.0 - 3883.0 70.0 - 71.0 250.0 - 318.0 145.0 - 162.0 \n", - "4 3432.0 - 3883.0 70.0 - 71.0 250.0 - 318.0 113.0 - 145.0 \n", + " horsepower_bin weight_bin acceleration_bin model_year_bin \\\n", + "0 113.0 - 145.0 3432.0 - 3883.0 8.0 - 12.0 70.0 - 71.0 \n", + "1 162.0 - 230.0 3432.0 - 3883.0 8.0 - 12.0 70.0 - 71.0 \n", + "2 145.0 - 162.0 3432.0 - 3883.0 8.0 - 12.0 70.0 - 71.0 \n", + "3 145.0 - 162.0 3432.0 - 3883.0 8.0 - 12.0 70.0 - 71.0 \n", + "4 113.0 - 145.0 3432.0 - 3883.0 8.0 - 12.0 70.0 - 71.0 \n", "\n", - " acceleration_bin origin_processed name_processed \\\n", - "0 8.0 - 12.0 usa chevrolet chevelle malibu \n", - "1 8.0 - 12.0 usa buick skylark 320 \n", - "2 8.0 - 12.0 usa plymouth satellite \n", - "3 8.0 - 12.0 usa amc rebel sst \n", - "4 8.0 - 12.0 usa ford torino \n", + " displacement_bin origin_processed name_processed \\\n", + "0 250.0 - 318.0 usa chevrolet chevelle malibu \n", + "1 318.0 - 350.0 usa buick skylark 320 \n", + "2 250.0 - 318.0 usa plymouth satellite \n", + "3 250.0 - 318.0 usa amc rebel sst \n", + "4 250.0 - 318.0 usa ford torino \n", "\n", - " cylinders_processed origin_enc name_enc cylinders_enc weight_enc \\\n", - "0 8 20.35871 17.0 15.051515 17.129167 \n", - "1 8 20.35871 15.0 15.051515 17.129167 \n", - "2 8 20.35871 18.0 15.051515 17.129167 \n", - "3 8 20.35871 16.0 15.051515 17.129167 \n", - "4 8 20.35871 17.0 15.051515 17.129167 \n", + " cylinders_processed origin_enc name_enc cylinders_enc horsepower_enc \\\n", + "0 8 20.35871 17.0 15.051515 18.769231 \n", + "1 8 20.35871 15.0 15.051515 13.612500 \n", + "2 8 20.35871 18.0 15.051515 14.380952 \n", + "3 8 20.35871 16.0 15.051515 14.380952 \n", + "4 8 20.35871 17.0 15.051515 18.769231 \n", "\n", - " model_year_enc displacement_enc horsepower_enc acceleration_enc \n", - "0 19.057143 16.793333 18.769231 16.185185 \n", - "1 19.057143 15.035294 13.612500 16.185185 \n", - "2 19.057143 16.793333 14.380952 16.185185 \n", - "3 19.057143 16.793333 14.380952 16.185185 \n", - "4 19.057143 16.793333 18.769231 16.185185 " + " weight_enc acceleration_enc model_year_enc displacement_enc \n", + "0 17.129167 16.185185 19.057143 16.793333 \n", + "1 17.129167 16.185185 19.057143 15.035294 \n", + "2 17.129167 16.185185 19.057143 16.793333 \n", + "3 17.129167 16.185185 19.057143 16.793333 \n", + "4 17.129167 16.185185 19.057143 16.793333 " ] }, - "execution_count": 21, + "execution_count": 95, "metadata": {}, "output_type": "execute_result" } @@ -1005,7 +1024,56 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 96, + "metadata": {}, + "outputs": [], + "source": [ + "from cobra.evaluation.pigs_tables import compute_pig_table" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mcompute_pig_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mbasetable\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mpandas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDataFrame\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mpredictor_column_name\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mtarget_column_name\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mpandas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDataFrame\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Compute the PIG table of a given predictor for a given target.\n", + "\n", + "Parameters\n", + "----------\n", + "basetable : pd.DataFrame\n", + " Input data from which to compute the pig table.\n", + "predictor_column_name : str\n", + " Predictor name of which to compute the pig table.\n", + "target_column_name : str\n", + " Name of the target variable.\n", + "\n", + "Returns\n", + "-------\n", + "pd.DataFrame\n", + " PIG table as a DataFrame\n", + "\u001b[0;31mFile:\u001b[0m ~/Git/cobra/cobra/evaluation/pigs_tables.py\n", + "\u001b[0;31mType:\u001b[0m function" + ] + } + ], + "source": [ + "?compute_pig_table" + ] + }, + { + "cell_type": "code", + "execution_count": 98, "metadata": {}, "outputs": [ { @@ -1086,7 +1154,7 @@ " ...\n", " \n", " \n", - " 5\n", + " 249\n", " weight\n", " 2792.0 - 3076.0\n", " 0.100000\n", @@ -1094,7 +1162,7 @@ " 22.729167\n", " \n", " \n", - " 6\n", + " 250\n", " weight\n", " 3076.0 - 3432.0\n", " 0.100000\n", @@ -1102,7 +1170,7 @@ " 19.800000\n", " \n", " \n", - " 7\n", + " 251\n", " weight\n", " 3432.0 - 3883.0\n", " 0.100000\n", @@ -1110,7 +1178,7 @@ " 17.129167\n", " \n", " \n", - " 8\n", + " 252\n", " weight\n", " 3883.0 - 4280.0\n", " 0.100000\n", @@ -1118,7 +1186,7 @@ " 15.250000\n", " \n", " \n", - " 9\n", + " 253\n", " weight\n", " 4280.0 - 5140.0\n", " 0.100000\n", @@ -1131,23 +1199,23 @@ "" ], "text/plain": [ - " variable label pop_size global_avg_target avg_target\n", - "0 acceleration 8.0 - 12.0 0.112500 23.540833 16.185185\n", - "1 acceleration 12.0 - 13.4 0.095833 23.540833 18.069565\n", - "2 acceleration 13.4 - 14.0 0.095833 23.540833 17.560870\n", - "3 acceleration 14.0 - 14.8 0.104167 23.540833 26.832000\n", - "4 acceleration 14.8 - 15.5 0.129167 23.540833 23.645161\n", - ".. ... ... ... ... ...\n", - "5 weight 2792.0 - 3076.0 0.100000 23.540833 22.729167\n", - "6 weight 3076.0 - 3432.0 0.100000 23.540833 19.800000\n", - "7 weight 3432.0 - 3883.0 0.100000 23.540833 17.129167\n", - "8 weight 3883.0 - 4280.0 0.100000 23.540833 15.250000\n", - "9 weight 4280.0 - 5140.0 0.100000 23.540833 13.229167\n", + " variable label pop_size global_avg_target avg_target\n", + "0 acceleration 8.0 - 12.0 0.112500 23.540833 16.185185\n", + "1 acceleration 12.0 - 13.4 0.095833 23.540833 18.069565\n", + "2 acceleration 13.4 - 14.0 0.095833 23.540833 17.560870\n", + "3 acceleration 14.0 - 14.8 0.104167 23.540833 26.832000\n", + "4 acceleration 14.8 - 15.5 0.129167 23.540833 23.645161\n", + ".. ... ... ... ... ...\n", + "249 weight 2792.0 - 3076.0 0.100000 23.540833 22.729167\n", + "250 weight 3076.0 - 3432.0 0.100000 23.540833 19.800000\n", + "251 weight 3432.0 - 3883.0 0.100000 23.540833 17.129167\n", + "252 weight 3883.0 - 4280.0 0.100000 23.540833 15.250000\n", + "253 weight 4280.0 - 5140.0 0.100000 23.540833 13.229167\n", "\n", "[254 rows x 5 columns]" ] }, - "execution_count": 22, + "execution_count": 98, "metadata": {}, "output_type": "execute_result" } @@ -1170,16 +1238,24 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 99, "metadata": { "scrolled": true }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/patrick/Git/cobra/cobra/evaluation/pigs_tables.py:148: FutureWarning: The `inplace` parameter in pandas.Categorical.reorder_categories is deprecated and will be removed in a future version. Reordering categories will always return a new Categorical object.\n", + " df_plot['label'].cat.reorder_categories(column_order,\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1193,7 +1269,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 100, "metadata": {}, "outputs": [ { @@ -1202,7 +1278,7 @@ "array(['validation', 'train', 'selection'], dtype=object)" ] }, - "execution_count": 24, + "execution_count": 100, "metadata": {}, "output_type": "execute_result" } @@ -1238,7 +1314,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 101, "metadata": {}, "outputs": [ { @@ -1254,7 +1330,7 @@ " 'weight_bin']" ] }, - "execution_count": 25, + "execution_count": 101, "metadata": {}, "output_type": "execute_result" } @@ -1276,13 +1352,60 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 102, "metadata": {}, "outputs": [], "source": [ "preprocessed_predictors = [col for col in basetable.columns.tolist() if \"_enc\" in col]" ] }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;31mSignature:\u001b[0m\n", + "\u001b[0mgenerate_pig_tables\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mbasetable\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mpandas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDataFrame\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mtarget_column_name\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mpreprocessed_predictors\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mid_column_name\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mpandas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDataFrame\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Compute PIG tables for all predictors in preprocessed_predictors.\n", + "\n", + "The output is a DataFrame with columns ``variable``, ``label``,\n", + "``pop_size``, ``global_avg_target`` and ``avg_target``.\n", + "\n", + "Parameters\n", + "----------\n", + "basetable : pd.DataFrame\n", + " Basetable to compute PIG tables from.\n", + "target_column_name : str\n", + " Name of the basetable column containing the target values to predict.\n", + "preprocessed_predictors: list\n", + " List of basetable column names containing preprocessed predictors.\n", + "id_column_name : str, default=None\n", + " Name of the basetable column containing the IDs of the basetable rows\n", + " (e.g. customernumber). \n", + "Returns\n", + "-------\n", + "pd.DataFrame\n", + " DataFrame containing a PIG table for all predictors.\n", + "\u001b[0;31mFile:\u001b[0m ~/Git/cobra/cobra/evaluation/pigs_tables.py\n", + "\u001b[0;31mType:\u001b[0m function" + ] + } + ], + "source": [ + "# compute_pig_table\n", + "?generate_pig_tables" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1292,14 +1415,14 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 104, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABDoAAALPCAYAAACDoqApAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACByklEQVR4nOzde3zP9f//8fvbDsYmI5vzKWUOMxtDTinEchb6lFMoRg6hSJGEmlOJqYwOzjlui4isULSMEXIac9wcVubQTHb8/eG399e7nWzvsXl1u14uu7S9ns/X8/V4v9+bS+/7+/l8vkypqampAgAAAAAAMIBC+V0AAAAAAABAXiHoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDAIOgAAAAAAgGEQdAAAAAAAAMMg6AAAIBP+/v5yc3OTm5tbfpeSZ1q2bCk3NzeNGzcuv0tBHsnqNd29e7f5d3j37t35UB0epKx+F6Kiosy/C4GBgflQHQA8OAQdAIB8N27cOPP/gEdFRd3TOWn/Q9+yZcv7XB0AAAAeJgQdAAAgz/Cp8X8Hs0WMJTAwMMeBMwAUVLb5XQAAAAXV8OHDNXz48PwuI0/99NNP+V0CHqBGjRrp+PHj+V0GCoAKFSrwuwDgP4MZHQAAAAAAwDAIOgAAAAAAgGGwdAUAYDi7d+9W3759JUlLlixRo0aNtGnTJq1atUrHjx9XfHy8ypYtq1atWmnQoEFydnbOcBx/f3/NmzdPkiymfAcHB+utt96SJH311Vdq2rRplvVMnDhRq1atkp2dnXbt2qXixYub2yIiIhQSEqLw8HCdOHFCsbGxsrOzk4uLi7y8vPTSSy/J09Mz07H/XePff/+tJUuWaOvWrYqKitLff/8tPz8/Pf/885LubOIaHR2trl27atq0aenGi4mJ0datW7V7924dO3ZMMTExSkpKUokSJeTu7q6OHTvKx8dHhQql/6zk33enefvtt/X2229bHBs2bFiGy4EOHz6sVatWaffu3YqJiVFqaqpKly6tJ598Uv369VPVqlUzf4Kz8e/n6MaNG1q0aJG2bNmiCxcuyM7OTm5ubvrf//6nDh06ZDrOv5+7P/74Q8uWLVNYWJhiYmKUmJiYbmnA33//rRUrVmjbtm06c+aM4uLi5OzsLHd3d3Xp0kVt27aVyWTKsv4dO3Zo2bJlOnTokG7duqUyZcro6aef1oABA1S6dOksz83obyGr62zYsEH79+/XlStXlJycLBcXF9WuXVvPPPOMnnvuORUpUkRRUVFq1aqVxblp17jb3b93aRISErRmzRpt3rxZJ06cUFxcnIoXL65atWqpQ4cO6tixY4a/W9KdTYuDgoJUvnx5/fTTT4qJidHixYu1fft2XbhwQfHx8dk+xowkJydr5cqVCg4OVmRkpEwmkypVqqQOHTqoT58+iomJMT/ejB5Tnz59FBYWpoYNG2rp0qWZXiezf0/SxMfHa/v27dq1a5f++OMPRUVF6Z9//lGxYsX0+OOP65lnntGLL74oR0fHHD2+NHe/bnc/jrt/R9L8+/WV7vz+PPHEE3rqqaeUmJio//3vf5o8eXKW1/zpp580ZMgQSdLs2bPVrl27XNUOADlF0AEAMLSUlBSNGTNG69evtzh+5swZffnllwoJCdHy5cvl4uJyz2O2bt1aDg4O+ueff/Tdd99lGXQkJiZqy5YtkqQWLVpYhBwZvcFIO+fs2bM6e/asgoODNWjQIL3xxhvZ1nXmzBkNGDBA0dHR9/xY7pacnKwWLVooJSUlXVtMTIx++ukn/fTTT1q7dq38/f1z/YbrbikpKZo+fboWL16s1NRUi7YzZ87ozJkzWrt2rSZOnKj//e9/Vl/v/PnzGjBggM6dO2dxPCwsTGFhYQoJCdGsWbNka5v1/yJ98803mjp1qpKSkjLtExoaqpEjR+ratWsWx//8809t27ZN27ZtU4sWLTR79uxMn0s/Pz8tWrTI4tiZM2e0aNEirV+/XgsWLMiyzntx9epVjRo1SqGhoenaoqOjFR0drR9++EGS0r3Jz4moqCgNHDhQp06dsjj+119/6eeff9bPP/+sVatW6bPPPss0fEzz+++/a/Dgwbp69Wqu65GkmzdvatCgQdq7d6/F8SNHjujIkSPauHGjpk6datU17pWvr6/CwsLSHb969ar27NmjPXv2aMWKFVqwYIGqVav2QGr6t5IlS6pVq1bavHmzvv/+e40fP16FCxfOtH/ahsTOzs5q3br1gyoTAAg6AADGNmfOHO3fv1+tW7dWly5dVK5cOf31119asWKFtm/frrNnz8rPz08ff/zxPY/p5OSkli1batOmTfrhhx80adKkTP9n/+effza/0e3YsaNFW3JysooWLaoWLVroySef1GOPPSYnJydduXJFJ0+e1NKlSxUdHa0FCxaoSpUq6tatW5Z1jRgxQjExMerTp49atmypRx55RGfPnlW5cuXu6XGlBQ1PPvmknnrqKVWvXl0lS5bUzZs3df78ea1Zs0b79+/Xrl27NHnyZE2fPt3i/A0bNigmJkavvPKKJGnkyJHpPhl+9NFHLX6eMmWKVqxYIUlq0KCBunbtqooVK8rBwUHHjx/X4sWLdeLECU2cOFGlSpXK8JPmnBg1apSioqL04osvysfHR05OTjp+/LgWLlyoM2fO6Pvvv5erq6veeeedTMc4dOiQ1q9frzJlyuiVV16Ru7u7kpKSFB4ebu4THh6ugQMHKjExUaVKlVLv3r1Vo0YNubq6KiYmRps2bdL69eu1Y8cOjRs3Tv7+/umus2jRInPI4erqKl9fX3l4eOj27dvavn27Fi9erNdff123bt3K9fNx69Yt9e3bVxEREZKk2rVr63//+5+eeOIJ2dvb69KlS9qzZ482bdpkPqd06dLasGGDDh06ZH6ePvzwQ9WpU8di7DJlypi/v3nzpvr166fz589LuhMWduvWTa6uroqKitLy5csVFham8PBwDR48WMuXL5eNjU2GNd+8eVPDhw/X7du3NXjwYDVt2lQODg6KiIjIUWApSWPGjDGHHB4eHurXr58qV66sK1euKDAwUJs3b9bEiRNzNGZuJSUlqXr16mrZsqXq1KkjV1dXpaamKjo6WiEhIfr+++8VFRWloUOH6ttvv80yYMiJOnXqaMOGDfrxxx/1ySefSJK+/PJLubq6WvSrUKGCJKlHjx7avHmzbty4oa1bt2Y6Cyo2Nlbbt2+XdOffPnt7+zypFwDuBUEHAMDQ9u/fr5EjR5qnT6d56qmn9Oqrr2rnzp3asmWLYmNjVbJkyXset2PHjtq0aZPi4uK0bds2+fj4ZNjvu+++k3QnHHnmmWcs2mrUqKEdO3bokUceSXde8+bN1atXLw0ePFi7du3Sp59+qi5dumT65k+STpw4oYULF6pZs2bmY+7u7vf8mGxsbLR582ZVrlw5XVvDhg3VrVs3zZ07V59++qm+/fZbDRkyRFWqVDH3qV69uooWLWr+uXTp0qpevXqm19u1a5c55Jg6dap69Ohh0e7h4aFOnTpp0KBB+u233/TBBx+oRYsW2c62yMqhQ4f00UcfWbw5q1Onjnx8fNSrVy8dO3ZMS5cuVffu3TOt/eTJk6pevbqWL19u8drVr19f0p0ZOWPGjFFiYqKaN28uf39/FSlSxNwvbSlIgwYN9O677+qHH37Qrl27LGYGXblyxfyms3z58lq1apXFm/gGDRqoWbNmevXVV7OcVZKdTz75xBxy9OrVS++++67FUhp3d3e1bt1ab7zxhm7cuCFJsrOzU/Xq1S1mU1SoUCHL13revHnmkGPIkCEaOXKkxTXatm2rMWPGmJfOrFq1Sj179sxwrGvXrqlo0aL65ptvVKNGDfNxDw+PHD327du368cff5R0Z7bVZ599ZvG71aJFC82bNy/DEOp+8PPzs/h7SlO3bl21a9dO3bt31yuvvKLTp09r/fr16f5ecqto0aKqXr26/vjjD/OxKlWqmIONf2vSpInKly+v6OhoBQYGZhp0rF+/XomJiZKUbUgLAHmNzUgBAIZWu3ZtDR48ON1xk8mkfv36SbrzSer+/ftzNG7z5s3N0+s3bNiQYZ+bN2+ab+fapk2bdJ/AlixZMsOQI429vb3Gjh0r6c4SgqNHj2ZZU9euXS1CjpwymUwZhhx3Gzp0qEqUKKHU1FSrb1Wbtuyibdu2mb5pK1y4sPkT9ejoaO3evduqaz7zzDMZvjFzcnLSlClTJN1ZTrNy5cosx3nvvfcyfe02btyo6OhoFS5cWDNmzLAIOe72wgsvmN+cp03xTxMUFGSeqfHWW29lOFOhcePGVr3ZvXHjhlatWiXpzt/J+PHjM90vxN7eXqVKlcrVdRISErR27VpJ0hNPPJHhHi0mk0mTJk0y/00tX748yzFfffVVi5AjN9JCNnt7e02ZMiXDAO21117LMsDJSxmFHHdr0qSJWrZsKUnmgCY/FCpUyLyEKTQ0VBcvXsyw37p16yRJtWrVUs2aNR9YfQAgEXQAAAyuY8eOmb55q127tvn7tE+b75WdnZ15FsfPP/9s/rT7blu3btU///wjSerUqVO2YyYkJOjChQs6efKkIiIiFBERYbFvxbFjx7I8/99LY6yVkpKiy5cv69SpU+Z6IiMjzUsSsqsnK3Fxceb9CNq2bZtl32rVqqlEiRKSlONA6t+y2mPCw8NDTzzxhCTp119/zbRf2bJl5e3tnWl7WgDUoEGDbGcJpY3z+++/WxxP2y+jePHiWS7XseaT8t9++80cpvTt2zfL2ULW+OOPP8x/H127ds30Ok5OTnruueck3Zk1ExMTk+mY9/L3lJXk5GTz71/Tpk0z3dS1UKFC6tKli1XXyq3Y2FidOXPG/LcXERFh/n2y5m8vL3Tv3l2FChVSSkqKgoKC0rX/8ccf5plCzOYAkB9YugIAMLTHHnss07a7Nzy8efNmjsfu2LGjVq5cqYSEBG3ZsiXdp+tpy1ZcXV0zvRNEfHy8li5dqo0bN+rkyZNKTk7O9HrZbbz477ue5EZqaqrWr1+vtWvX6uDBg+agJjf1ZOXIkSPmTU9Hjx6t0aNH39N5f/31V66vKSndPhIZtZ84cUJnzpxRQkJChvsKZPc8py0B2Llz5z2/Jv9+XGl35ahZs2aWS3Vq1qwpOzs78xKBnDhy5Ij5+7RlN/fDiRMnzN/XrVs3y75169bVN998Yz7v3/tESHeWWlSsWNGqms6dO2cOebL7ncjpkhhrhIeHa+nSpQoNDU23ie3drN2E1VplypRRs2bN9PPPPysoKEivvfaaRXvaDCV7e/s8D2AB4F4QdAAA8t3dMy7+feeNzNxrPwcHh0zb7r6NZUZ3GslO/fr1zWvV/71m/sqVK+ZP5du3b5/hLTOjoqL08ssvKyoq6p6ud/v27Szb776jS27cvn1bw4YN088//3xP/bMKQbJz5cqVXJ1nzTWl9Juh/lva8ozU1FTduHEjw+UaWS03ku58Ep9T/35c169fl5R9vba2tnJ2dtaff/6Z42ve/WY5o0Ahr6Q9FknZznC5+/m++7y7Zff857Sm7J7j7Nrzyt23n82OtX8HeaFHjx76+eefde7cOe3Zs0cNGjSQdGdmWlrI27p1a6v/XQKA3CDoAADku7v3rsjuzXya+Ph4SbLY/PJBM5lM6tChgwICArR3715dvnzZPAX++++/N28SmdknmmPHjlVUVJRMJpOef/55tW/fXtWqVVPJkiVlZ2cnk8mklJQU8/r27MIda5cefP755+aQo2HDhurZs6dq166tUqVKycHBwRzW9OrVK93tOHPq7mBp8uTJ8vLyuqfzCsKbpuye57RZOU899ZTGjBlj1bUyW3b1sMqLx5PXS2wKwnMcGhpqDjkqVqyoAQMGqH79+ipXrpyKFClintUzZ84cffbZZ/lZqtkzzzyjUqVK6a+//lJgYKA56AgJCTEHSSxbAZBfCDoAAPnu7jevf/75px5//PEs+yckJOjvv/9Od25+6NixowICApSSkqLvvvvOfGvVtE80H3vsMYu9QNJERkaab0fq6+urUaNGZTh+VtPX81Jqaqp5w0hvb28tXrw4w1koUuaftOfE3cuGHBwcHtiGj1euXFHZsmUzbU9bQmIymXI9c8DZ2VkxMTFKTEzM9eMqXry4/vzzz2yX6iQlJeX6dyRt3xNJiomJsXo5SGbu/hu9cuWKqlatmmnfux/v/fzbvvu1ze45zm72UVpQkt2ssLRwNiOrV6+WdOcxr169OtOZL3nxt5dX7Ozs1LlzZ3355ZfavHmzJkyYIEdHR/MmpOXKlVOTJk3yuUoA/1VsRgoAyHd372Nw+PDhbPsfO3bM/Kl5XuxLYY0nnnjCfPeHtHDj/Pnz5k0zM5vNcfLkSfP37dq1y3T8u2/5eD9du3bNvPzBx8cn05Dj5s2bOn36dKbj3Oun4zVr1jT33bdvXw6rzb1Dhw5l2Z72fFeuXDnD/TnuRa1atcxjJSQk5GqMtIDk2LFjWd4+9tixY7nan0Oy3Iw3NzN07vW1TtvgVZIOHDiQZd+DBw9meF5eq1SpknlZW3a/E9m1Ozo6SlKGGxLf7cyZM5m2pf170KhRoyyX99zPfw9yM7MlbblefHy8Nm/erEuXLpk38u3SpUum/44AwP3Gvz4AgHzXsGFD89TsTZs2ZbtEY/369ebvGzdufF9ruxdpYcaRI0cUGRlpDjzubvu3uzcdTdsUMSPZ3eY0r9xrPWvWrMnyjffdy5CyepNfsmRJeXp6SroTEOVmX4vcyOgOEWkOHjxovlOENZ9Ep90C9O+//05329h7lfZ7fe3aNW3bti3TfmmfnudGo0aNzEu/li5dmuVGuBm519fa3d3dPIMiODg405kPcXFx+v777yVJjz/++H3dN8TW1lYNGzaUJO3atSvTO7xkdleRu1WoUEGSdPr0acXFxWXYJzY2Nss7+aT9TWU16+PIkSPZBkXWuNfX825Vq1Y13zkoMDBQQUFBSklJMS/HA4D8QtABAMh3pUqVMt+q9fDhw1qwYEGmfUNDQ81v/suXL29+U5mfOnToYP40dP369dq4caMkycvLK9PlAJUrVzZ/n9mb4RUrVujHH3/M42ozVrJkSfOb0e+++y7DNzoHDx7UnDlzshzH2dlZdnZ2ku7c2SIrQ4YMkXTnDe6IESOy/EQ8ISFBy5cvv+c9XDLz008/adOmTemO37x5U++9956kO5vU/u9//8v1Nbp27WpeHjN9+nTt2bMny/579+413+r07jHSZhz4+flluLwiLCzMvOQhNx555BHz4zx8+LA+/PDDTEPGxMTEdEs4XFxczN9n9Vrb29ure/fukqSIiIgM95hITU3VlClTzBuk9urVK2cPJhdeeuklSXd+tyZOnJhh0BMQEGAOvzKTFpgkJiZq2bJl6doTExM1YcKELDcQTfv3YN++fTp79my69tjYWI0dOzbLOqx19+uZk9ttp83q2Lt3r/nxN2zY8L4thQKAe8EeHQCAAuGtt95SaGiorly5oo8//lhhYWHq2LGjqlatKhsbG126dEnbtm1TcHCwkpKSVKhQIX344Yd5vjFhbpQpU0YNGjRQWFiYVqxYYX7DntVtFWvVqqXq1asrIiJCq1at0o0bN9S5c2e5uLjo0qVLWr9+vbZs2aJ69eo9kKUdhQoVUseOHbV8+XIdP35cL730kvr376/KlSsrLi5OO3bs0IoVK1S0aFG5urpmOg3f1tZWderU0b59+7Ru3TrVqlXL4hapxYsXN+/P0aJFC/Xt21dLlizRnj171K5dO7344ouqX7++nJ2dFR8fr3Pnzmnv3r3aunWrrl+/ri5dulh88pxT7u7uevPNN7Vnzx61bdtWTk5OOn78uBYuXGhektOrVy/zcqTcsLe31yeffKI+ffooPj5eL7/8stq1a6fWrVurQoUKSklJ0Z9//qnDhw9r69atioiI0Lvvvmt+wyzdCf9ef/11TZ8+XdHR0Xr++efl6+urOnXqKCEhQTt27NCiRYtUunRp3bp1K9czYl5//XXt2rVLERERWrZsmfbv368XX3xR1atXl52dnS5duqS9e/dq48aNGjlypMWn9OXKlVOZMmV06dIlffXVVypTpoz571W6c7cSJycnSdLQoUO1detWnT9/Xv7+/oqIiNDzzz8vFxcXRUVFadmyZeawx8vLy6qg6V61bNlSzzzzjLZt26Zt27bppZdeUr9+/VS5cmVduXJFQUFB2rRpk9zd3bNcMtKiRQvz3ZfmzJmjq1ev6tlnn1XhwoV18uRJLV26VEeOHJGnp6d+//33DMfo0qWLtm3bpvj4ePXu3VuDBg0yLy3av3+/vv76a/3111/y8vIyL4vLazVr1lThwoV1+/ZtzZkzR7a2tipXrpx5+Unp0qUzvIuVj4+Ppk6dqr///tscyLEJKYD8RtABACgQXF1dtWzZMg0bNkyRkZHauXOndu7cmWHfRx55RDNnztSTTz75gKvMXKdOnRQWFmYOOWxtbfXcc89l2t9kMmnGjBl6+eWXdf36dX3//ffmaftpqlevrjlz5qh58+b3tfY0o0aN0r59+3T06FH98ccfeuONNyzanZ2d5e/vr7lz52a534Cvr68GDx6sa9eupRtj2LBhGj58uPnnd955R8WLF9fnn3+uP//8U/7+/pmOW7RoUauDrU8++UT9+vXTihUrtGLFinTtbdu21bhx46y6hiR5enpq6dKlGjlypC5evKgNGzZow4YNmfZPCwTuNmDAAF24cEFLly7V5cuXNXnyZIv2EiVK6JNPPtHIkSNzXWeRIkW0ePFijRgxQnv27NHhw4f17rvv3vP5vr6+ev/99xUVFaXXXnvNos3Pz88cjDg5OWnRokUaOHCgTp06pS1btmjLli3pxqtXr54+//zzBxZgzpo1SwMHDtS+fft04MCBdJsC16pVS5MnT85yGYa9vb1mzJihgQMHKj4+XosWLdKiRYvM7TY2NnrnnXd0/fr1TIMOHx8fPf/88woMDFRMTIymTp1q0W5jY6O3335bN27cuG9Bh5OTk/r06aMvvvhChw8f1oABAyzalyxZokaNGqU7z8HBQR06dNA333wjSSpWrJjatm17X2oEgHtF0AEAKDAee+wxrV+/Xps2bVJISIj++OMPxcbGKikpSc7Oznr88cfVvHlzvfDCCypWrFh+l2uhbdu2mjx5snnJR9OmTbPcVFC68wlqcHCwAgIC9MsvvygmJkaOjo6qVKmSnnvuOfXq1cuq2Qs5VaxYMX3zzTf6+uuv9f333+vs2bOysbFR2bJl1aJFC7388ssqU6ZMtuM8/fTTWrRokZYsWaJDhw7p6tWrmW6YaTKZNGzYMHXu3FkrV67Ub7/9pqioKP39999ycHBQ2bJlVbNmTTVr1kytW7fO8BPlnKhYsaICAwP11VdfaevWrbpw4YJsbW1Vo0YNvfDCC+rUqZNV49/N09NTP/zwgwIDA7Vt2zYdOXJEV69eVaFChVSyZElVq1ZNDRo0UJs2bfTYY49lOMaECRPUvHlzLVmyRH/88Ydu3bqlMmXK6KmnntKrr756T69HdkqWLKlly5Zp69at2rBhgw4cOKDY2FiZTCa5urqqdu3aat26dYZvXnv27KlSpUpp1apVOnr0qK5fv57pHi4VKlTQt99+qzVr1mjz5s2KiIjQzZs3Vbx4cdWsWVMdO3ZUx44dH+gGlk5OTlq6dKlWrlyp4OBgRUZGymQyqVKlSmrXrp1efvll8ya9WfH29ta6des0f/58hYaG6urVq3J2dla9evXUr18/1atXL8sQT7oTDD355JNavXq1jh49qsTERLm4uMjb21u9e/eWh4dHtmNY680331SVKlUUHByskydP6u+//76nvVs6d+5sDjratWtn9d8pAFjLlJrdjm8AAAAPMX9/f82bN0+SdPz48XyuBg+bqKgotWrVSpLlLBX8n9WrV5tnAq1Zs0YeHh75XBGA/zo2IwUAAACQa2l3/6levTohB4ACgaADAAAAQK7s2bPHvPfIiy++mL/FAMD/xx4dAAAAAO5ZdHS0EhISdPLkSfn5+Um6c3ta7rYCoKAg6AAAAABwz/r06aPo6GiLYxMmTGATUgAFBkEHAAAAgBxzdHRU9erVNXjwYD399NP5XQ4AmHHXFQAAAAAAYBhsRooc6927t3r37p3fZQAAAAAAkA5LV5BjFy9ezO8SAAAAAADIEDM6AAAAAACAYRB0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBi2+V0AHk7RsXGqP2ZJfpcBAADySPjMvvldAgAAeYIZHQAAAAAAwDAIOgAAAAAAgGEQdAAAAAAAAMMg6AAAAAAAAIZB0AEAAAAAgIEEBgbK29s7v8vIN9x1BQAAAACQYw/6Low5vTvUuHHjFBQUJEmytbVV6dKl5ePjo9dff12FCxc293Nzc5MkrVq1Sp6enubjCQkJat68ua5du6YlS5aoUaNGkqSwsDDNmzdPx44d0+3bt1W6dGl5eXlpypQpsre31+7du9W3b8a17ty5Uy4uLumOp52zZ88ePfLIIzl6nBlp166dWrRoYfU4DyuCDgAAAACAITVv3lx+fn5KSkrS4cOH9dZbb8lkMmnMmDEW/cqWLavAwECLoGPr1q0qWrSorl27Zj528uRJvfrqq+rdu7cmTJggBwcHnTlzRj/88INSUlIsxty8ebOcnJwsjj366KNWPZ6EhATZ29tn28/BwUEODg5WXethxtIVAAAAAIAh2dvby8XFRWXLllXr1q3VpEkT/frrr+n6denSRRs3btQ///xjPrZu3Tp16dLFot/OnTtVqlQpjR07VtWrV1elSpX01FNPaerUqemChUcffVQuLi4WX4UKpX8LHhUVZZ4B0qBBA7m5uWncuHGSpD59+mjy5Mn64IMP1KhRI73yyiuSpK+//lodO3aUp6enWrRooUmTJunmzZvmMf+9dMXf31+dO3dWcHCwWrZsqfr162vUqFGKi4vL4TP6cCDoAAAAAAAYXkREhPbv3y87O7t0be7u7ipfvry2bNkiSbpw4YL27Nmjzp07W/RzcXHRn3/+qT179uRZXWXLlpW/v7+kO7NAdu7cqfHjx5vbg4KCZGdnp2+++Ubvv/++JMlkMmn8+PH67rvvNG3aNP3222+aOXNmltc5d+6cfvzxR82fP18BAQHas2ePFi5cmGePoyBh6QoAAAAAwJC2b98uLy8vJSUlKSEhQYUKFdK7776bYd9u3bpp3bp16ty5swIDA9WiRQuVLFnSoo+Pj4927typ3r17y8XFRXXr1lXjxo3VpUuXdMtU/r1HRrly5bRx48Z017WxsVHx4sUl3ZkF8u89OqpUqaKxY8daHOvXr5/5+woVKmjkyJF67733NGnSpEyfi9TUVPn5+Znr7NSpk0JDQzVq1KhMz3lYEXQAAAAAAAypUaNGmjRpkm7duqVFixbJxsZGbdu2zbBvp06d9NFHH+n8+fMKCgrShAkT0vWxsbGRn5+fRo4cqdDQUB08eFDz58/XwoULtWbNGrm6upr7Ll++XI6OjuafbW1z9/a7du3a6Y79+uuvCggI0KlTpxQXF6fk5GTdvn1bt27dUpEiRTIcp3z58hZhjKurq65cuZKrmgo6lq4AAAAAAAypSJEiqly5smrUqKEPP/xQBw8e1Jo1azLsW6JECT399NN65513dPv2bT311FOZjlu6dGl16dJFEydO1MaNG3X79m2tXLnSok+FChVUuXJl81f58uVz/RjuFhUVJV9fX7m5ucnf31+BgYGaOHGiJCkxMTHTcTIKWlJTU3NVU0FH0AEAAAAAMLxChQrJ19dXc+bMsdh09G7dunVTWFiYunTpIhsbm3sat3jx4nJxcdGtW7dyXVvaviHJycnZ9j18+LBSU1M1btw4eXp6qmrVqoqJicn1tY2IoAMAAAAA8J/g4+OjQoUKafny5Rm2P/XUUwoNDdWIESMybF+5cqXee+897dy5U+fOndOJEyc0c+ZMnTx5Us8884xF3ytXrujPP/+0+MpsxkX58uVlMpm0fft2xcbGWtxB5d8qV66sxMRELV26VOfPn1dwcHC62ST/dQQdAAAAAID/BFtbW/Xu3VtffPGF4uPj07WbTCaVLFlS9vb2GZ7v4eGh+Ph4vffee2rfvr169+6tAwcO6NNPP1XDhg0t+vr4+KhZs2YWX4cPH85w3NKlS2v48OH66KOP1KRJE02ZMiXTx1CjRg29/fbbWrhwoTp06KANGzZo9OjROXgWjM+UatRFObhvWrVqpejYODm2HprfpQAAgDwSPrNvfpcAAECeYEYHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMAg6AAAAAACAYRB0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBRwHWsmVLLVq06J77R0VFyc3NTUePHr1/RQEAAAAAUIARdBRga9eu1f/+9788HTMwMFDe3t55OiYAAAAAIP+MGzdOr7322n29xsP0wbptfheAzJUsWTK/SwAAAACADJ2bXOeBXq/SxEM56j9u3DgFBQVJkmxtbVW6dGn5+Pjo9ddfV+HChc393NzcJEmrVq2Sp6en+XhCQoKaN2+ua9euacmSJWrUqJEkKSwsTPPmzdOxY8d0+/ZtlS5dWl5eXpoyZYrs7e21e/du9e3bN8Oadu7cKRcXlxw9jvwwbtw43bhxQ5999pn5WNmyZbVz506VKFEiHyu7N8zoyEPbtm2Tt7e3kpOTJUlHjx6Vm5ubZs2aZe4zfvx4vfnmm5KkvXv3qmfPnvLw8FCLFi00depUxcfHm/v+e+lKZGSkXnrpJdWpU0ft2rXTr7/+Kjc3N4WEhFjUcf78efXp00d169ZVp06dtH//fknS7t279fbbb+vvv/+Wm5ub3Nzc5O/vf7+eDgAAAADIV82bN9fOnTsVEhKid955R6tWrdLcuXPT9StbtqwCAwMtjm3dulVFixa1OHby5Em9+uqrcnd317Jly7RhwwZNmDBBdnZ2SklJsei7efNm7dy50+Lr0UcfzfsH+YDY2NjIxcVFtrYFf74EQUce8vb21s2bN3XkyBFJd5K+EiVKKCwszNxnz549atSokc6dO6eBAweqTZs2Wr9+vWbPnq3w8HBNmTIlw7GTk5M1dOhQFSlSRGvWrNHkyZM1e/bsDPvOnj1br7zyioKDg1WlShW98cYbSkpKkpeXl9555x05OTmZ/9AGDBiQ908EAAAAABQA9vb2cnFxUdmyZdW6dWs1adJEv/76a7p+Xbp00caNG/XPP/+Yj61bt05dunSx6Ldz506VKlVKY8eOVfXq1VWpUiU99dRTmjp1qhwcHCz6Pvroo3JxcbH4KlQo47fg169f1xtvvKEnn3xSHh4eatOmjdatW2duv3jxol5//XV5e3urYcOGGjJkiKKiojJ93CkpKQoICFDLli3l4eGhTp06afPmzRZ9Tpw4IV9fX9WrV09eXl7q2bOnzp07J39/fwUFBenHH380f0C+e/fuDJeuhIWFqXv37nJ3d1ezZs00a9YsJSUlmdv79OmjqVOnasaMGWrYsKGaNm36QD5sJ+jIQ8WKFVPNmjXNwUZYWJj69eunI0eO6ObNm7p8+bLOnj2rBg0aKCAgQB07dlS/fv1UpUoV1atXT+PHj1dwcLBu376dbuxdu3bp/Pnzmj59umrUqCFvb2+NGjUqwzoGDBigp59+WlWrVtWIESMUHR2ts2fPyt7eXsWKFZPJZDL/oTk6OmY4RkJCguLi4jL8Sk1NzbsnDQAAAAAegIiICO3fv192dnbp2tzd3VW+fHlt2bJFknThwgXt2bNHnTt3tujn4uKiP//8U3v27MnT2ubMmaPIyEgtXLhQmzZt0qRJk8xLRBITE/XKK6/I0dFRy5cv1zfffKOiRYvq1VdfVUJCQobjBQQEKDg4WO+//742btyofv36acyYMeb3qpcvX1bv3r1lb2+vxYsXKzAwUN26dVNSUpIGDBig5557zjwbZufOnfLy8kp3jcuXL2vQoEGqU6eOvv32W02aNElr167V559/btEvKChIRYsW1erVqzVmzBh9+umn2rVrV54+f/9W8OecPGQaNGigsLAwDRgwQHv37tXo0aP1/fffKzw8XNevX5erq6uqVKmiY8eO6fjx49qwYYP53NTUVKWkpCgqKkrVqlWzGPf06dMqU6aMxXouDw+PDGtIW2Mmydw/NjY23ZhZCQgI0Lx58zJtL+MkLS02857HAwAAuZPTNekAgP+zfft2eXl5KSkpSQkJCSpUqJDefffdDPt269ZN69atU+fOnRUYGKgWLVqk2zfRx8dHO3fuVO/eveXi4qK6deuqcePG6tKli5ycnCz6tmjRwuLncuXKaePGjRle+8KFC6pZs6bq1Lmz70mFChXMbZs2bVJKSoo++OADmUwmSZKfn5/5vWezZs0sxkpISFBAQIC+/vprc0BRsWJFhYeHa9WqVWrYsKGWL18uJycnffzxx+bgp2rVquYxHBwclJCQkOV+IitWrFCZMmU0ceJEmUwmVatWTZcvX9asWbM0dOhQ8+wVNzc3DRs2TJJUpUoVLVu2TKGhoWratGmmY1uLoCOPNWzYUOvWrdOxY8dkZ2enatWqqWHDhgoLC9ONGzfUsGFDSVJ8fLxefPFF9enTJ90YZcuWtaqGuxPKtD+Ef68Xy46vr6/69++fYVunTp2UfD069wUCAAAAwAPQqFEjTZo0Sbdu3dKiRYtkY2Ojtm3bZti3U6dO+uijj3T+/HkFBQVpwoQJ6frY2NjIz89PI0eOVGhoqA4ePKj58+dr4cKFWrNmjVxdXc19ly9fbjGDPqu9LV566SWNGDFCR44cUdOmTdW6dWvVq1dPknTs2DGdO3fO/HOa27dv69y5c+nGOnv2rG7dupVum4LExETVrFlT0p39JL29vTOc3XKvIiMj5eXlZX7PKUn169dXfHy8Ll26pHLlykmy/CBeuvNh/JUrV3J93XtB0JHH0vbpWLRokRo0aCDpzh/XggULdP36dfMvW61atXTy5ElVrlz5nsatWrWqLl26pL/++kulSpWSJB06lPNPeOzs7MybpWbF3t5e9vb2Gbbd/YsMAAAAAAVVkSJFzO+5PvzwQ3Xu3Flr1qxRjx490vUtUaKEnn76ab3zzju6ffu2nnrqKd28eTPDcUuXLq0uXbqoS5cuev3119W2bVutXLlSI0aMMPepUKGCHnnkkXuqs0WLFtq2bZt27NihXbt2qV+/furVq5feeustxcfHq3bt2hY3uUiT0Z06025wERAQoNKlS1u0pb3H+/d+IvfTvwMek8l037dDYI+OPFa8eHG5ublpw4YN5tkb3t7eOnLkiM6cOWMOPwYOHKj9+/dr8uTJOnr0qM6cOaOQkBBNnjw5w3GbNm2qihUr6q233tKxY8cUHh6uTz75JMf1lS9fXvHx8QoNDVVsbKxu3bqV68cKAAAAAA+LQoUKydfXV3PmzLHYdPRu3bp1U1hYmLp06SIbG5t7Grd48eJycXGx+r1VyZIl1bVrV82aNct8hxhJql27ts6ePatHH31UlStXtvgqVqxYunGqVasme3t7XbhwIV3/tNUDbm5u2rt3rxITEzOsJaO7yGR0nf3791uEFuHh4XJ0dFSZMmVy+zTkCYKO+6BBgwZKTk42Bx3Ozs6qVq2aXFxc9Nhjj0mSatSooaVLl+rMmTPq2bOnunbtqrlz51pMdbqbjY2NPv30U8XHx6t79+6aMGGCBg8eLEkW94DOTr169fTiiy9q5MiRaty4sb744gsrHy0AAAAAPBx8fHxUqFAhLV++PMP2p556SqGhoRYzM+62cuVKvffee9q5c6fOnTunEydOaObMmTp58qSeeeYZi75XrlzRn3/+afGVWbAwZ84chYSE6OzZszpx4oS2b99u3mOxY8eOKlGihIYMGaK9e/fq/Pnz2r17t6ZOnapLly6lG8vJyUkDBgyQn5+fgoKCdO7cOR0+fFhLly5VUFCQJKlXr16Ki4vT6NGjdejQIZ05c0bBwcE6deqUpDsfkB8/flynTp1SbGxshnX37NlTly5d0pQpUxQZGamQkBD5+/urf//+md5d5kFh6cp9MH78eI0fP97i2Lfffpuun4eHh7766qtMx/npp58sfq5WrZq++eYb88/h4eGSZJ6KVaFCBR0/ftzinEceeSTdsffff1/vv//+PTwSAAAAADAOW1tb9e7dW1988YVeeuklFS1a1KLdZDJluBwkjYeHh8LDw/Xee+8pJiZGRYsW1RNPPKFPP/3U/EF3Gh8fn3Tnr1q1Sp6enumO29nZ6eOPP1Z0dLQcHBxUv359ffzxx5LuLL9ZtmyZZs2apWHDhunmzZsqXbq0GjdunG4D1DQjR45UyZIlFRAQoKioKBUrVky1atUyf1heokQJLV68WDNnzlSfPn1UqFAh1axZU/Xr15ckvfDCCwoLC1O3bt0UHx+vJUuWqHz58hbXKF26tBYsWKAZM2Zo9erVcnZ2Vvfu3TVkyJBMn78HxZTKvUIfGlu3blXRokVVuXJlnTt3Th988IEeeeQRi/DjQWjVqpWSrkVpaeeM9/AAAAB5h7uuAACQM8zoeIjcvHlTs2bN0oULF1SiRAk1adJEb731Vn6XBQAAAABAgUHQ8RBJ29UXAAAAAABkjM1IAQAAAACAYRB0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDAIOgAAAAAAgGEQdAAAAAAAAMMg6AAAAAAAAIZB0AEAAAAAAAyDoAMAAAAAABgGQQcAAAAAADAMgg4AAAAAAGAYBB0AAAAAAMAwCDoAAAAAAIBhEHQAAAAAAADDIOgAAAAAAACGQdABAAAAAAAMg6ADAAAAAAAYBkEHAAAAAAAwDNv8LgAPJ1vnCqo08cf8LgMAAAAAAAvM6AAAAAAAAIZB0AEAAAAAAAyDoAMAAAAAABgGQQcAAAAAADAMgg4AAAAAAGAYBB0AAAAAAMAwCDoAAAAAAIBhEHQAAAAAAADDIOgAAAAAAACGQdABAAAAAAAMg6ADAAAAAAAYBkEHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMGzzuwA8nKJj41R/zJL8LgMAABRg4TP75ncJAID/IGZ0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDAIOgAAAAAAgGEQdAAAAAAAAMMg6AAAAAAAAIZB0AEAAAAAAAyDoAMAAAAAABgGQQcAAAAAADAMgg4AAAAAAGAYBB0AAAAAAMAwCDoAAAAAAIBhEHQAAAAAAADDIOgAAAAAAACGQdABAAAAAAAMg6ADAAAAAAAYBkEHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMAg6AAAAAACAYTw0QUefPn30wQcfSJJatmypRYsW5dnYbm5uCgkJybPxAAAAAABA/rDN7wJyY+3atSpSpEh+l/FQGjdunG7cuKHPPvssv0sBAAAAACDPPZRBR8mSJfO7BAAAAAAAUAAVyKUr8fHxGjt2rLy8vNSsWTN99dVXFu13L11JTU2Vv7+/nn76abm7u6tZs2aaOnWqRd9PP/1Uo0ePlqenp5o3b67ly5dnef2ZM2eqbdu2qlu3rlq1aqVPPvlEiYmJFn1++ukndevWTXXq1FGjRo00dOhQc1tCQoKmT5+u5s2by9PTUz169NDu3bvN7YGBgfL29ta2bdvM1xkxYoRu3bqloKAgtWzZUg0aNNDUqVOVnJyc43F/+eUXPffcc/Ly8tIrr7yimJgYSZK/v7+CgoL0448/ys3NTW5ubhbnAwAAAADwsCuQMzpmzJihPXv26LPPPlPJkiU1e/ZsHT58WDVq1EjXd8uWLVq0aJE+/vhjPfHEE/rrr7907Ngxiz5ffvmlBg8erOHDh2vnzp364IMPVKVKFTVt2jTD6zs6OsrPz0+urq6KiIjQu+++K0dHRw0cOFCStH37dg0bNkyDBw/WjBkzlJiYqB07dpjPnzx5sk6ePKnZs2fL1dVVW7du1auvvqoNGzaoSpUqkqR//vlHS5cu1ezZs3Xz5k0NGzZMw4YNU7FixbRgwQKdP39ew4cPV7169dSuXbscjfvVV19pxowZKlSokMaMGaPp06fro48+0oABAxQZGam4uDj5+flJkooXL27VawUAAAAAQEFS4IKOmzdvau3atZo5c6YaN24sSZo2bZpatGiRYf+LFy+qVKlSatKkiezs7FSuXDl5eHhY9KlXr54GDRokSapatar27dunRYsWZRp0vPbaa+bvK1SooNOnT2vjxo3moGP+/Plq166dRowYYe6XFsJcuHBBgYGB2rZtm0qXLi1JeuWVV/TLL78oMDBQo0ePliQlJiZq0qRJqlSpkiSpbdu2Wr9+vXbt2iVHR0c9/vjjatSokX777Te1a9cuR+O+//775nF79epl3o/D0dFRDg4OSkhIkIuLS5avQ0JCghISEjJsS01NzfJcAAAAAADyS4ELOs6fP6/ExETVrVvXfMzZ2VlVq1bNsL+Pj48WL16s1q1bq3nz5mrRooWeeeYZ2dr+30Pz9PS0OMfT01OLFy/OtIZNmzZpyZIlOn/+vOLj45WUlCQnJydz+9GjR9WjR48Mz42IiFBycrJ8fHwsjickJMjZ2dn8c5EiRcxhhCSVKlVK5cuXl6Ojo8Wx2NhYq8Z1dXXVlStXMn2smQkICNC8efMybS/jJC0tNjPH4wIAgAer0sRD+V0CAAAPVIELOnKqbNmy2rx5s3799Vf9+uuvev/99/Xll19q6dKlsrOzy/F4+/fv15tvvqnhw4erWbNmKlasmDZu3Kivv/7a3MfBwSHT8+Pj42VjY6N169bJxsbGoq1o0aLm7+8OYiTJZDJleCwlJcXqcXMzA8PX11f9+/fPsK1Tp05Kvh6d4zEBAAAAALjfClzQUbFiRdnZ2enAgQMqV66cJOn69es6c+aMGjRokOE5Dg4OatmypVq2bKmePXvqueeeU0REhGrXri1JOnDggEX/AwcOqFq1ahmOtX//fpUrV05DhgwxH7tw4YJFn+rVqys0NFTdunVLd37NmjWVnJys2NhYeXt73/sDz0ZejWtnZ2cOT7Jib28ve3v7DNtMJlOurw8AAAAAwP1U4IIOR0dHdevWTTNnzpSzs7MeffRRzZ49O9M314GBgUpOTlbdunVVpEgRrV+/Xg4ODuaQRJL27dunhQsXqnXr1vr111+1efNmBQQEZDhe5cqVdfHiRW3cuFF16tTR9u3bFRISYtFn2LBh6tevnypVqqT27dsrKSlJO3bs0KBBg1S1alV17NhRY8eO1bhx41SzZk1dvXpVoaGhcnNz09NPP52r5yWvxi1fvrx27typU6dOydnZWcWKFcvVzBcAAAAAAAqiAhd0SNLYsWMVHx+vIUOGyNHRUf3791dcXFyGfR955BEtWLBA06ZNU0pKiqpXr6758+erRIkS5j79+/fXH3/8oU8//VROTk4aN26cmjdvnuF4rVq10ssvv6zJkycrISFBTz/9tIYMGWKxX0WjRo00Z84cffbZZ1qwYIGcnJwsZpv4+fnp888/17Rp0xQTEyNnZ2d5enrmOuTIy3FfeOEFhYWFqVu3boqPj9eSJUvUqFEjq+oCAAAAAKCgMKUa/BYaLVu2VN++fdWvX7/8LsUwWrVqpaRrUVraOeOlLQAAoOBgM1IAwH9NofwuAAAAAAAAIK8QdAAAAAAAAMMokHt05KWffvopv0sAAAAAAAAPCDM6AAAAAACAYRB0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDAIOgAAAAAAgGEQdAAAAAAAAMMg6AAAAAAAAIZB0AEAAAAAAAyDoAMAAAAAABgGQQcAAAAAADAMgg4AAAAAAGAYBB0AAAAAAMAwCDoAAAAAAIBhEHQAAAAAAADDIOgAAAAAAACGQdABAAAAAAAMg6ADAAAAAAAYBkEHAAAAAAAwDNv8LgAPJ1vnCqo08cf8LgMAAAAAAAvM6AAAAAAAAIZB0AEAAAAAAAyDoAMAAAAAABgGQQcAAAAAADAMgg4AAAAAAGAYBB0AAAAAAMAwCDoAAAAAAIBhEHQAAAAAAADDIOgAAAAAAACGQdABAAAAAAAMg6ADAAAAAAAYBkEHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMGzzuwA8nKJj41R/zJL8LgMAAOSj8Jl987sEAADSYUYHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMAg6AAAAAACAYRB0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDAIOgAAAAAAgGEQdAAAAAAAAMMg6AAAAAAAAIZB0AEAAAAAAAyDoAMAAAAAABgGQQcAAAAAADAMgg4AAAAAAGAYBB0AAAAAAMAwCDoAAAAAAIBhEHQAAAAAAADDIOgAAAAAAACGQdABAAAAAAAMg6ADAAAAAAAYhiGCjj59+uiDDz7I7zIAAAAAAEA+M0TQAQAAAAAAIBF0ZCghISG/S3hg/kuPFQAAAABgfIYJOlJTUzVjxgw1bNhQTZs2lb+/v7ntwoULGjJkiLy8vFSvXj29/vrr+uuvv8zt/v7+6ty5s9asWaOWLVvKw8NDkrR582Z17NhRHh4eatSokfr166f4+HjzeWvWrNFzzz2nOnXqyMfHR8uXLze3RUVFyc3NTRs3btSLL76oOnXqqEOHDgoLC7OoOywsTN27d5e7u7uaNWumWbNmKSkpSZK0bds2eXt7Kzk5WZJ09OhRubm5adasWebzx48frzfffNP88969e9WzZ095eHioRYsWmjp1qkXNLVu21KeffqqxY8eqXr16mjhxolXPOwAAAAAABYlhgo6goCAVLVpUq1ev1pgxY/Tpp59q165dSklJ0Wuvvabr169r6dKl+vrrr3X+/HmNGjXK4vxz585py5YtmjdvnoKDgxUTE6M33nhD3bp106ZNm7RkyRI9++yzSk1NlSStX79ec+bM0ahRo7Rp0yaNHj1ac+fOVVBQkMW4M2bMUP/+/RUcHCxPT08NHjxYV69elSRdvnxZgwYNUp06dfTtt99q0qRJWrt2rT7//HNJkre3t27evKkjR45IuhOKlChRwiIs2bNnjxo1amR+DAMHDlSbNm20fv16zZ49W+Hh4ZoyZYpFTV999ZVq1Kih4OBgvfbaa3n4KgAAAAAAkL9s87uAvOLm5qZhw4ZJkqpUqaJly5YpNDRUkhQREaEff/xRZcuWlXQnfGjfvr0OHjxonr2RmJioGTNmqGTJkpKkw4cPKykpSc8++6zKly9vvkYaf39/jRs3Tm3atJEkVaxYUSdPntSqVavUtWtXc79evXqpbdu2kqRJkybpl19+0dq1azVw4ECtWLFCZcqU0cSJE2UymVStWjVdvnxZs2bN0tChQ1WsWDHVrFlTYWFhqlOnjsLCwtSvXz/NmzdPN2/eVFxcnM6ePasGDRpIkgICAtSxY0f169fP/DyMHz9effr00aRJk1S4cGFJ0pNPPqkBAwZk+XwmJCRkuqwlLewBAAAAAKCgMVTQcTcXFxdduXJFkZGRKlOmjDnkkKTHH39cjzzyiE6dOmUOOsqVK2cOOSSpRo0aaty4sTp27KhmzZqpWbNmatu2rYoXL674+HidO3dO48eP17vvvms+JykpScWKFbOow8vLy/y9ra2t3N3dderUKUlSZGSkvLy8ZDKZzH3q16+v+Ph4Xbp0SeXKlVODBg0UFhamAQMGaO/evRo9erS+//57hYeH6/r163J1dVWVKlUkSceOHdPx48e1YcMG83ipqalKSUlRVFSUqlWrJklyd3fP9vkMCAjQvHnzMm0v4yQtLTYz23EAAIDxVJp4KL9LAAAgU4YJOmxtLR+KyWTK0cyDIkWKWPxsY2Ojr7/+Wvv27dOuXbu0dOlSzZ49W6tXrzb3nTJliurWrWtxXqFCebsaqGHDhlq3bp2OHTsmOzs7VatWTQ0bNlRYWJhu3Lihhg0bmvvGx8frxRdfVJ8+fdKNc3fQ8+/HmhFfX1/1798/w7ZOnTop+Xp0Lh4NAAAAAAD3l2H26MhMtWrVdOnSJV28eNF87OTJk7px44Z5hkNmTCaT6tevrxEjRig4OFh2dnYKCQlRqVKl5OrqqvPnz6ty5coWXxUrVrQY4/fffzd/n5SUpMOHD+uxxx4z17Z//36LQCY8PFyOjo4qU6aMpP/bp2PRokXmJSqNGjVSWFiYdu/ebRF01KpVSydPnkxXU+XKlWVvb5+j583e3l5OTk4Zft09AwUAAAAAgILE8EFHkyZNVL16db355ps6fPiwDh48qLFjx6phw4aqU6dOpucdOHBA8+fP16FDh3ThwgX98MMPio2NNYcUI0aM0IIFC7RkyRKdPn1ax48f17p16/T1119bjLNixQpt3bpVkZGRmjx5sq5fv65u3bpJknr27KlLly5pypQpioyMVEhIiPz9/dW/f3/zzJDixYvLzc1NGzZsMIca3t7eOnLkiM6cOWMOPyRp4MCB2r9/vyZPnqyjR4/qzJkzCgkJ0eTJk/P0OQUAAAAAoKAyzNKVzJhMJn322WeaMmWKevfuLZPJpObNm1vsrZERJycn7dmzR4sXL1ZcXJzKlSuncePGqUWLFpKkHj16yMHBQV9++aVmzJihokWLqnr16nr55ZctxnnjjTe0YMECHT16VJUrV9bnn39u3gukdOnSWrBggWbMmKHVq1fL2dlZ3bt315AhQyzGaNCggY4ePWoOOpydnVWtWjVduXLFHLxId/YVWbp0qT755BP17NlT0p1NUtu1a2fdkwgAAAAAwEPClMotNO6LqKgotWrVSsHBwapZs2Z+l5OnWrVqpaRrUVraOWfLYQAAgDGwGSkAoCAz/NIVAAAAAADw30HQAQAAAAAADMPwe3TklwoVKuj48eP5XQYAAAAAAP8pzOgAAAAAAACGQdABAAAAAAAMg6ADAAAAAAAYBkEHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMAg6AAAAAACAYRB0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDAIOgAAAAAAgGEQdAAAAAAAAMMg6AAAAAAAAIZB0AEAAAAAAAyDoAMAAAAAABgGQQcAAAAAADAMgg4AAAAAAGAYBB0AAAAAAMAwbPO7ADycbJ0rqNLEH/O7DAAAAAAALDCjAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDAIOgAAAAAAgGEQdAAAAAAAAMMg6AAAAAAAAIZB0AEAAAAAAAyDoAMAAAAAABgGQQcAAAAAADAMgg4AAAAAAGAYBB0AAAAAAMAwCDoAAAAAAIBhEHQAAAAAAADDsM3vAvBwio6NU/0xS/K7DAAAgAIhfGbf/C4BAPD/MaMDAAAAAAAYBkEHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMAg6AAAAAACAYRB0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDAIOgAAAAAAgGEQdAAAAAAAAMMg6AAAAAAAAIZB0AEAAAAAAAyDoAMAAAAAABgGQQcAAAAAADAMgg4AAAAAAGAYBB0AAAAAAMAwCDoAAAAAAIBhEHQAAAAAAADDIOgAAAAAAACGQdABAAAAAAAMw6qg49ixY4qIiMirWh56LVu21KJFi8w/u7m5KSQkxKoxAwMD5e3tbWVlAAAAAAD8N9hac3KXLl3UsGFDLVmyJK/qMZSdO3eqePHi+V0GAAAAAAD/GVYFHcWLF5eLi0te1WI4BeW5SUxMlJ2dXX6XAQAAAADAfWfV0hVPT0/DLV1JSUnRwoUL9eyzz8rd3V1PP/20Pv/8c/Xt21eTJ0+26BsbGyt3d3eFhoZmONbdS1eioqLk5uamH374QX369FHdunXVqVMn7d+/3+KcwMBAPf3006pbt66GDh2qa9eupRs3JCREXbt2VZ06ddSqVSvNmzdPSUlJFtddsWKFBg8eLE9PT82fP1/Xr1/XG2+8oSeffFIeHh5q06aN1q1bZ+WzBQAAAABAwWJV0DF06FCdPn1aX331VV7Vk+8++ugjLVy4UK+99po2bdqkWbNmqVSpUurRo4e+++47JSQkmPuuX79erq6uevLJJ+95/NmzZ+uVV15RcHCwqlSpojfeeMMcUhw4cEDjx49Xr169FBwcrEaNGunzzz+3OH/v3r1666231LdvX23atEmTJ09WYGCg5s+fb9Fv3rx5evbZZ7VhwwZ169ZNc+bMUWRkpBYuXKhNmzZp0qRJKlGihBXPFAAAAAAABY9VS1dOnTqlTp06aebMmVq/fr1atGihcuXKqXDhwhn279KlizWXu+/i4uK0ZMkSTZw4UV27dpUkVapUSd7e3rp9+7amTJmikJAQtWvXTtKd2RfPP/+8TCbTPV9jwIABevrppyVJI0aMUPv27XX27FlVq1ZNS5YsUfPmzTVw4EBJUtWqVbV//3798ssv5vPnzZunQYMGmeurWLGiXn/9dc2cOVPDhg0z9+vQoYO6detm/vnChQuqWbOm6tSpI0mqUKFClnUmJCRYhDp3S01NvefHCwAAAADAg2RV0DFu3DiZTCalpqbq2LFjOnbsWIZv+lNTU2UymQp80HHq1CklJCRkOEOjcOHC6tSpk9atW6d27drp8OHDOnHiRLoZF9lxc3Mzf5+2h0dsbKyqVaumyMhItW7d2qK/p6enRdBx7Ngx7du3z2IGR3Jysm7fvq1bt26pSJEikiR3d3eLcV566SWNGDFCR44cUdOmTdW6dWvVq1cv0zoDAgI0b968TNvLOElLi828h0cMAACQXqWJh/K7BACAQVkVdAwdOjRHsxkKusxmoqTp0aOHunTpokuXLikwMFBPPvmkypcvn6Nr3L0paNpzl5KScs/nx8fHa/jw4WrTpk26trvrL1q0qEVbixYttG3bNu3YsUO7du1Sv3791KtXL7311lsZXsfX11f9+/fPsK1Tp05Kvh59zzUDAAAAAPCgWBV0DB8+PK/qKBCqVKkiBwcH/fbbb6pYsWK6djc3N7m7u2v16tX67rvv9O677+bp9atVq6aDBw9aHDtw4IDFz7Vq1dLp06dVuXLlHI9fsmRJde3aVV27dtXKlSs1Y8aMTIMOe3t72dvbZ9hmpHALAAAAAGAsVgUdRlO4cGENHDhQM2fOlJ2dnerVq6fY2FidOHFCPXr0kHRnVsfkyZNVtGhRPfvss3l6/T59+uill17Sl19+qVatWmnnzp0Wy1akO7NoBg8erHLlyqlt27YqVKiQjh07poiICI0aNSrTsefMmaPatWvriSeeUEJCgrZv365q1arlaf0AAAAAAOS3PAs6Ll++rPDwcMXExEiSXF1dVb9+fZUuXTqvLvFAvPbaa7KxsdHcuXMVExMjFxcXvfjii+b29u3b68MPP1T79u2zXeqSU56enpoyZYr8/f01d+5cNW7cWEOGDNFnn31m7tO8eXPNnz9fn376qRYuXChbW1s99thj5iAmM3Z2dvr4448VHR0tBwcH1a9fXx9//HGe1g8AAAAAQH4zpVp5C43Y2Fi9//77CgkJSbfXhMlkUps2bTRx4kSVLFnSqkILiqioKD377LNau3atateund/l5ItWrVop6VqUlnbOeGkLAABAdtiMFABwv1g1o+Pvv/9Wr169dPr0aTk4OKhp06YqX768TCaToqOjtXPnTm3evFnHjx/X6tWrVaxYsbyq+4FLTEzUtWvX9Mknn6hu3br/2ZADAAAAAICCzKqgY8GCBTp9+rR8fHwynLURGxurKVOm6Pvvv9fChQs1evRoq4rNT/v27VPfvn1VpUoVzZ07N7/LAQAAAAAAGbBq6YqPj49u376tH374weK2qXdLTExUmzZtZG9vry1btuS6UBQcLF0BAADWYukKAOB+KWTNyRcuXFC9evUyDTkkme9ecvHiRWsuBQAAAAAAkC2rgg4HBwddvXo1235Xr16Vg4ODNZcCAAAAAADIllVBR+3atRUWFqZDhzKfevjHH38oLCxM7u7u1lwKAAAAAAAgW1YFHf369VNSUpL69eunTz75RJGRkfrnn3/0zz//KDIyUnPnzlX//v2VnJysl19+Oa9qBgAAAAAAyJBVm5FKUkBAgObMmaPMhjGZTHr99dfl6+trzWVQgLAZKQAAsBabkQIA7herbi8rSb6+vmrSpImWLVum8PBwxcTESJJcXV3l7e2tnj17ysPDw+pCAQAAAAAAsmN10CFJderU0fTp0/NiKAAAAAAAgFyzao+O4OBg7du3L9t+v//+u4KDg625FAAAAAAAQLasCjrGjRunNWvWZNtv7dq1evvtt625FAAAAAAAQLasCjruVUpKikwm04O4FAAAAAAA+A97IEHH+fPn5eTk9CAuBQAAAAAA/sNyvBnpvHnzLH4+duxYumNpkpOTdfr0ae3du1dNmjTJXYUAAAAAAAD3KFdBh8lkUmpqqkwmk44ePaqjR49mec6jjz6q0aNH57pIAAAAAACAe5HjoMPPz0+SlJqaqnfeeUf169dX9+7dM+xrZ2cnV1dXeXp6yt7e3rpKAQAAAAAAspHjoKNr167m74OCgvTUU09ZHAMAAAAAAMgvOQ467rZ06dK8qgMAAAAAAMBqVt115ezZs1qyZIkiIiIy7RMREaElS5bo/Pnz1lwKAAAAAAAgW1YFHYsXL9b06dOzvHWso6Ojpk2bpiVLllhzKQAAAAAAgGxZFXSEhoaqRo0aKleuXKZ9ypcvrxo1aujXX3+15lIAAAAAAADZsirouHTpkipWrJhtv0qVKunSpUvWXAoAAAAAACBbVgUdhQoVUkJCQrb9EhISlJKSYs2lAAAAAAAAsmVV0FGlShWFh4fr1q1bmfa5deuWwsPDVblyZWsuBQAAAAAAkC2rbi/btm1bffzxx5owYYKmTJmiokWLWrTfunVLEyZM0I0bN9SvXz9rLoUCxta5gipN/DG/ywAAAAAAwIIpNTU1Nbcn37p1Sz169FBkZKQeffRRtW/fXpUqVZIknTt3Ths3btSVK1dUtWpVrV27Nl0QgodTq1atJEk//kjQAQAAAAAoWKwKOiTpzz//1JgxY/Tbb7/dGdBkkiSlDduoUSPNmDFDpUuXtrJUFBQEHQAAAACAgsqqpSuS5OLiokWLFungwYMKDQ3VxYsXJUlly5ZV48aN5eHhYXWRAAAAAAAA98LqoCONh4cHoQYAAAAAAMhXVt11BQAAAAAAoCDJ0YyOPXv2SLoze6Nw4cLmn+9VgwYNctQfAAAAAAAgJ3IUdPTp00cmk0mbNm1S1apVzT/fq6NHj+a4QAAAAAAAgHuVo6CjS5cuMplMKlasmMXPAAAAAAAABYHVt5fFfw+3lwUAAAAAFFRsRgoAAAAAAAyDoAMAAAAAABhGjvbomDdvXq4vZDKZNHTo0FyfDwAAAAAAkJ0cBx0mk0n/3tbj7g1J09r+fYygAwAAAAAA3G85Cjr8/PzSHdu/f79Wr16tMmXKqG3btipfvrwk6cKFC/rhhx904cIFvfDCC/Ly8sqbigEAAAAAADJh1V1XDh48qN69e6tfv34aMWKEbG0tc5Pk5GTNnTtXX331lZYtW6a6detaXTDyX6tWrRQdGyfH1szQAQAAAJB74TP75ncJMCCrNiOdM2eOKlWqpNGjR6cLOSTJxsZGo0aNUuXKlTV37lxrLgUAAAAAAJAtq4KOgwcPys3NLdt+bm5uOnjwoDWXAgAAAAAAyJZVQUdycrKioqKy7RcVFaXk5GRrLgUAAAAAAJAtq4IODw8PHTx4UMHBwZn2CQ4O1oEDB+Th4WHNpQAAAAAAALKVo7uu/Nvw4cO1d+9evf322woMDFS7du1Urlw5SXfuuvL9998rLCxMtra2Gj58eJ4UDAAAAAAAkBmrgo769evL399f77zzjsLCwrRnzx6L9tTUVDk7O+uDDz5Q/fr1rSoUAAAAAAAgO1YFHZL0zDPPKCQkRFu2bNHevXsVExMjSXJxcZG3t7d8fHzk6OhodaEAAAAAAADZsTrokCRHR0c9//zzev755/NiOAAAAAAAgFyxajNSAAAAAACAgiRPgo6dO3dq6NChat68udzd3fX222+b23755Rf5+fnp8uXLeXEpAAAAAACATFm9dGXq1Klavny5UlNTVbRoUSUlJVm0u7i4aPHixSpbtqz69etn7eUAAAAAAAAyZdWMjuDgYC1btky1a9dWUFCQ9u3bl65PjRo1VLZsWf3000/WXAoAAAAAACBbVs3o+Oabb/TII49owYIFKlmyZKb93NzcFBERYc2lAAAAAAAAsmXVjI6IiAh5eXllGXJIkpOTk/766y9rLgUAAAAAAJAtqzcjNZlM2faJiYmRg4ODtZcCAAAAAADIklVBR5UqVXT48GElJiZm2icuLk7Hjh3T448/bs2lAAAAAAAAsmVV0OHj46M///xTH330UaZ9Pv74Y/39999q3769NZcCAAAAAADIllWbkb788svauHGjFi9erP3796tVq1aSpPPnz2vRokXaunWrwsPDVatWLfXo0SNPCgYAAAAAAMiMVUGHg4ODFi1apHHjxunnn3/WwYMHJUl79+7V3r17JUlNmzbVzJkzZW9vb321AAAAAAAAWbAq6JCkkiVLasGCBTp27Jh27typ6OhopaSkqEyZMmratKk8PDzyok4AAAAAAIBsWRV0DBs2TC4uLnrvvfdUo0YN1ahRI6/qAgAAAAAAyDGrNiPdsWOHrl27lkelAAAAAAAAWMeqoKNChQq6detWXtUCAAAAAABgFauCjvbt2yssLEx//vlnXtUDAAAAAACQa1YFHb6+vvL29lbv3r21detWJSYm5lVd+P/8/f3VuXPnHJ3Tp08fffDBB/epIgAAAAAACi5Tampqam5PbtWqlVJTU3Xx4sU7g5lMKlmypAoXLpz+QiaTQkJCcl/pf9TNmzeVkJCgEiVK3PM5165dk62trZycnO5LTa1atVJ0bJwcWw+9L+MDAAAA+G8In9k3v0uAAVl115Xo6GiLn1NTU/XXX39ZVRDuSE1NVXJyshwdHeXo6Jijc52dne9PUQAAAAAAFHBWBR3Hjh3Lqzr+ExISEjRjxgxt3LhRcXFxcnd319tvvy0PDw/t3r1bffv21YIFCzRnzhxFREToyy+/VFhYmEJCQvTtt99KkpKSkjRt2jQFBwfLxsZG3bt3119//aW///5bn332maQ7S1dq1Kih8ePHS5JatmypF154QWfPntXmzZtVvHhxDRkyRP/73//y7bkAAAAAAOB+sGqPDuTMjBkztGXLFk2bNk1BQUGqXLmyXn31VYtb9H700Ud64403tGnTJrm5uaUbY+HChdqwYYP8/Py0YsUKxcXF3dOSoK+//lru7u4KDg5Wz549NWnSJJ06dSovHx4AAAAAAPkuVzM6duzYoZCQEF28eFH29vZyc3PT888/r4oVK+Z1fYYRHx+vlStXys/PTy1atJAkTZkyRbt27dLatWtVp04dSdKIESPUtGnTTMdZtmyZBg0apGeffVaSNHHiRP3888/ZXv+pp55Sr169JEkDBw7UokWLtHv3bj322GMZ9k9ISFBCQkKGbVZs6wIAAAAAwH2V46AjbbaB9H9veLdt26avvvpKH3/8sVq1apW3FRrEuXPnlJiYqHr16pmP2dnZycPDQ5GRkeagI+2/Gfn777/1119/ycPDw3zMxsZGtWvXVkpKSpbXv3t2iMlkUqlSpXTlypVM+wcEBGjevHmZtpdxkpYWm5nlNQEAAICCrtLEQ/ldAoA8lqOgY82aNdq4caNsbW3VqVMn1apVSzdv3tS2bdv0+++/66233tK2bdtUrFix+1Wv4RUpUuS+jGtra/lSm0ymLGdm+Pr6qn///hm2derUScnXozNsAwAAAAAgP+Voj47g4GAVKlRICxcu1IcffqjevXvL19dXK1euVNeuXXXz5k398MMP96vWh1qlSpVkZ2enffv2mY8lJibq0KFDevzxx+9pjGLFiqlUqVI6dOj/Uufk5GQdOXIkz+u1t7eXk5NThl8mkynPrwcAAAAAQF7I0YyOiIgI1a1bV40bN07X5uvrq6CgIEVERORZcUZStGhRvfTSS5oxY4aKFy+ucuXK6YsvvtA///yj7t273/MdbHr37q2AgABVqlRJjz32mJYtW6br168TPgAAAAAAoBwGHXFxcapUqVKGbWnH4+LirK/KoN58802lpqZq7Nixunnzptzd3fXFF1+oePHi9zzGwIED9ddff+mtt96SjY2NXnjhBTVr1kw2Njb3sXIAAAAAAB4OptQc3EKjRo0a6tq1q/z8/HLVjryXkpKi5557Ts8995xGjhz5QK7ZqlUrJV2L0tLO9g/kegAAAMD9wmakgPHk6vayyD/R0dHatWuXGjRooISEBC1fvlzR0dHq2LFjfpcGAAAAAEC+y/GMjtzuBWEyme7Lppn/NRcvXtSoUaN04sQJpaamqnr16nrjjTfUoEGDB1YDMzoAAABgFMzoAIwnxzM6cpCL5Ml5sFS2bFmtXLkyv8sAAAAAAKBAylHQca93BgEAAAAAAMgPhfK7AAAAAAAAgLxC0AEAAAAAAAyDoAMAAAAAABgGQQcAAAAAADAMgg4AAAAAAGAYBB0AAAAAAMAwCDoAAAAAAIBhEHQAAAAAAADDIOgAAAAAAACGQdABAAAAAAAMg6ADAAAAAAAYBkEHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMAg6AAAAAACAYRB0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBi2+V0AHk62zhVUaeKP+V0GAAAAAAAWmNEBAAAAAAAMg6ADAAAAAAAYBkEHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMAg6AAAAAACAYRB0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDAIOgAAAAAAgGHY5ncBeDhFx8ap/pgl+V0GAAAAgHsQPrNvfpcAPDDM6AAAAAAAAIZB0AEAAAAAAAyDoAMAAAAAABgGQQcAAAAAADAMgg4AAAAAAGAYBB0AAAAAAMAwCDoAAAAAAIBhEHQAAAAAAADDIOgAAAAAAACGQdABAAAAAAAMg6ADAAAAAAAYBkEHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMAg6AAAAAACAYRB0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDAIOgAAAAAAgGEQdAAAAAAAAMMg6MiBPn366IMPPrjn/oGBgfL29r6PFQEAAAAAgLsRdAAAAAAAAMMg6PiPS0xMzO8SAAAAAADIM4YIOvr06aMpU6bogw8+UIMGDdSkSROtXr1a8fHxevvtt+Xl5aVnn31WO3bsMJ8TFham7t27y93dXc2aNdOsWbOUlJRkbo+Pj9fYsWPl5eWlZs2a6auvvkp33YSEBE2fPl3NmzeXp6enevTood27d+e4/qioKNWoUUOHDh2yOL5o0SI988wzSklJkSRFRETo1VdflZeXl5o0aaIxY8YoNjbW3P/nn3/WSy+9JG9vbzVq1Ei+vr46d+6cxXXc3Ny0adMm9e7dW3Xq1NGGDRtyXC8AAAAAAAWVIYIOSQoKClKJEiW0Zs0a9e7dW5MmTdLrr78uLy8vBQUFqWnTpho7dqxu3bqly5cva9CgQapTp46+/fZbTZo0SWvXrtXnn39uHm/GjBnas2ePPvvsM3355ZcKCwvT4cOHLa45efJk7d+/X7Nnz9b69evl4+OjV199VWfOnMlR7RUqVFCTJk0UGBhocTwwMFBdu3ZVoUKFdOPGDb388suqVauW1q5dqy+++EJXrlzRyJEjzf1v3bql/v37a926dVq0aJFMJpOGDh1qDkrSzJo1S3379tWmTZvUrFmzHNUKAAAAAEBBZpigo0aNGnrttddUpUoV+fr6qnDhwipRooReeOEFValSRUOHDtW1a9d0/PhxrVixQmXKlNHEiRNVrVo1tW7dWsOHD9dXX32llJQU3bx5U2vXrtXYsWPVuHFjubm5adq0aUpOTjZf78KFCwoMDNScOXPk7e2tSpUq6ZVXXlH9+vXTBRb3onv37tq4caMSEhIkSYcPH1ZERISef/55SdKyZctUq1YtjR49WtWqVVOtWrX04Ycfavfu3Tp9+rQkqW3btmrTpo0qV66smjVr6sMPP1RERIROnjxpca2XX35Zbdq0UcWKFeXq6pphPQkJCYqLi8vwKzU1NcePDwAAAACAB8E2vwvIK25ububvbWxs5OzsrOrVq5uPlSpVSpJ05coVRUZGysvLSyaTydxev359xcfH69KlS7px44YSExNVt25dc7uzs7OqVq1q/jkiIkLJycny8fGxqCMhIUHOzs45rr9169aaPHmytm7dqvbt2ysoKEiNGjVShQoVJEnHjh3T7t275eXlle7cc+fOqWrVqjpz5ozmzp2rAwcO6OrVq+ZA4uLFixbPhbu7e7b1BAQEaN68eZm2l3GSlhabmdOHCQAAABhOpYmHsu8E4IExTNBha2v5UEwmk8WxtFAjr2YjxMfHy8bGRuvWrZONjY1FW9GiRXM8nr29vbp06aLAwEA9++yz2rBhg8aPH29xvWeeeUZvvvlmunNdXFwkSYMHD1b58uU1depUubq6KiUlRR06dEi34ei91Ofr66v+/ftn2NapUyclX4/OycMDAAAAAOCBMEzQkRPVqlXTli1blJqaag5AwsPD5ejoqDJlyqh48eKys7PTgQMHVK5cOUnS9evXdebMGTVo0ECSVLNmTSUnJys2Nlbe3t55UlePHj3UoUMHrVixQsnJyWrTpo25rXbt2tqyZYvKly+fLtSRpKtXr+r06dOaOnWquZ69e/fmuhZ7e3vZ29tn2Hb3TBgAAAAAAAoSw+zRkRM9e/bUpUuXNGXKFEVGRiokJET+/v7q37+/ChUqJEdHR3Xr1k0zZ85UaGioIiIiNG7cOIs3+FWrVlXHjh01duxY/fDDDzp//rwOHjyogIAAbd++PVd1VatWTXXr1tWsWbPUvn17OTg4WNR8/fp1jR49WgcPHtS5c+f0yy+/6O2331ZycrKKFy8uZ2dnrVq1SmfPnlVoaKimTZtm7VMFAAAAAMBD5T85o6N06dJasGCBZsyYodWrV8vZ2Vndu3fXkCFDzH3Gjh2r+Ph4DRkyRI6Ojurfv7/i4uIsxvHz89Pnn3+uadOmKSYmRs7OzvL09NTTTz+d69q6d++u/fv3q1u3bulq/uabbzRr1iy98sorSkhIULly5dS8eXMVKlRIJpNJs2fP1tSpU9WhQwdVrVpVEyZMUJ8+fXJdCwAAAAAADxtTKrfQKFA+/fRTbd68WRs2bMjvUjLVqlUrJV2L0tLOGS9tAQAAAP5L2IwUKFj+k0tXCqKbN28qIiJCy5cvZxYGAAAAAAC59J9cupIf2rdvrwsXLmTY9v777+vXX3/Vd999p9atW6dbtgIAAAAAAO4NS1cekOjoaCUlJWXY9uijj8rJyekBV5R7LF0BAAAA/g9LV4CChRkdD0j58uXzuwQAAAAAAAyPPToAAAAAAIBhEHQAAAAAAADDIOgAAAAAAACGQdABAAAAAAAMg6ADAAAAAAAYBkEHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMAg6AAAAAACAYRB0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDAIOgAAAAAAgGEQdAAAAAAAAMMg6AAAAAAAAIZB0AEAAAAAAAyDoAMAAAAAABiGbX4XgIeTrXMFVZr4Y36XAQAAAACABWZ0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDAIOgAAAAAAgGEQdAAAAAAAAMMg6AAAAAAAAIZB0AEAAAAAAAyDoAMAAAAAABgGQQcAAAAAADAMgg4AAAAAAGAYtvldAB5O0bFxqj9mSX6XAdyz8Jl987sEAAAAAA8AMzoAAAAAAIBhEHQAAAAAAADDIOgAAAAAAACGQdABAAAAAAAMg6ADAAAAAAAYBkEHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMAg6AAAAAACAYRB0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDAIOgAAAAAAgGEQdAAAAAAAAMMg6AAAAAAAAIZB0AEAAAAAAAyDoAMAAAAAABgGQQcAAAAAADAMgg4AAAAAAGAYBB0AAAAAAMAwCDoAAAAAAIBhEHQAAAAAAADDIOgAAAAAAACGQdDxAPXp00dTp07VjBkz1LBhQzVt2lT+/v7m9q+//lodO3aUp6enWrRooUmTJunmzZvm9sDAQHl7e2vbtm1q27at6tatqxEjRujWrVsKCgpSy5Yt1aBBA02dOlXJycnm8xISEjR9+nQ1b95cnp6e6tGjh3bv3v1AHzsAAAAAAA8CQccDFhQUpKJFi2r16tUaM2aMPv30U+3atUuSZDKZNH78eH333XeaNm2afvvtN82cOdPi/H/++UdLly7V7Nmz9cUXX2j37t0aNmyYduzYoQULFmjGjBlauXKltmzZYj5n8uTJ2r9/v2bPnq3169fLx8dHr776qs6cOfMgHzoAAAAAAPedbX4X8F/j5uamYcOGSZKqVKmiZcuWKTQ0VE2bNlW/fv3M/SpUqKCRI0fqvffe06RJk8zHExMTNWnSJFWqVEmS1LZtW61fv167du2So6OjHn/8cTVq1Ei//fab2rVrpwsXLigwMFDbtm1T6dKlJUmvvPKKfvnlFwUGBmr06NEZ1pmQkKCEhIQM21JTU/PgmQAAAAAAIO8RdDxgbm5uFj+7uLjoypUrkqRff/1VAQEBOnXqlOLi4pScnKzbt2/r1q1bKlKkiCSpSJEi5pBDkkqVKqXy5cvL0dHR4lhsbKwkKSIiQsnJyfLx8bG4bkJCgpydnTOtMyAgQPPmzcu0vYyTtLTYzEzbgYLm3GR+XwEAAJA7lSYeyu8SkAMEHQ+Yra3lU24ymZSamqqoqCj5+vrqpZde0qhRo1S8eHGFh4dr/PjxSkxMNAcdGZ2f0bGUlBRJUnx8vGxsbLRu3TrZ2NhY9CtatGimdfr6+qp///4ZtnXq1EnJ16Pv7QEDAAAAAPAAEXQUEIcPH1ZqaqrGjRunQoXubJ3y/fffWz1uzZo1lZycrNjYWHl7e9/zefb29rK3t8+wzWQyWV0XAAAAAAD3A5uRFhCVK1dWYmKili5dqvPnzys4OFgrV660etyqVauqY8eOGjt2rH744QedP39eBw8eVEBAgLZv32594QAAAAAAFCAEHQVEjRo19Pbbb2vhwoXq0KGDNmzYkOlGoTnl5+enLl26aNq0aXruuef02muv6dChQypbtmyejA8AAAAAQEFhSuUWGsihVq1aKelalJZ2znhpCwAAAAAYCZuRPlyY0QEAAAAAAAyDoAMAAAAAABgGQQcAAAAAADAMgg4AAAAAAGAYBB0AAAAAAMAwCDoAAAAAAIBhEHQAAAAAAADDIOgAAAAAAACGQdABAAAAAAAMg6ADAAAAAAAYBkEHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMAg6AAAAAACAYRB0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDAIOgAAAAAAgGEQdAAAAAAAAMMg6AAAAAAAAIZB0AEAAAAAAAzDNr8LwMPJ1rmCKk38Mb/LAAAAAADAAjM6AAAAAACAYRB0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDAIOgAAAAAAgGEQdAAAAAAAAMMg6AAAAAAAAIZB0AEAAAAAAAyDoAMAAAAAABgGQQcAAAAAADAM2/wuAA+n6Ng41R+zJL/LAAAAAPCQCp/ZN79LgEExowMAAAAAABgGQQcAAAAAADAMgg4AAAAAAGAYBB0AAAAAAMAwCDoAAAAAAIBhEHQAAAAAAADDIOgAAAAAAACGQdABAAAAAAAMg6ADAAAAAAAYBkEHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMAg6AAAAAACAYRB0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDAIOgAAAAAAgGEQdAAAAAAAAMMg6AAAAAAAAIZB0AEAAAAAAAyDoCOHAgMD5e3tnW/Xj4qKkpubm44ePZpvNQAAAAAAUFDZ5ncByNy4ceN048YNffbZZ+ZjZcuW1c6dO1WiRIl8rAwAAAAAgIKJGR35IDExMdfn2tjYyMXFRba2ZFQAAAAAAPzbQxl0/Pzzz3rppZfk7e2tRo0aydfXV+fOnTO3X7p0SaNHj1bDhg3l6emp559/XgcOHDC3//TTT+rWrZvq1KmjRo0aaejQoea2hIQETZ8+Xc2bN5enp6d69Oih3bt3Z1lPSEiIunbtqjp16qhVq1aaN2+ekpKSzO1ubm5asWKFBg8eLE9PT82fP1/Jycl655131LJlS3l4eKht27ZavHix+Rx/f38FBQXpxx9/lJubm9zc3LR79+4Ml66EhYWpe/fucnd3V7NmzTRr1iyL6/fp00dTp07VjBkz1LBhQzVt2lT+/v65e/IBAAAAACjAHsppAbdu3VL//v3l5uam+Ph4zZkzR0OHDtW3336rW7duqXfv3ipdurQ+++wzubi46PDhw0pJSZEkbd++XcOGDdPgwYM1Y8YMJSYmaseOHeaxJ0+erJMnT2r27NlydXXV1q1b9eqrr2rDhg2qUqVKulr27t2rt956SxMmTJC3t7fOnTund999V5I0bNgwc7958+bpjTfe0Pjx42VjY6OUlBSVKVNGc+bMkbOzs/bv36+JEyfKxcVF7dq104ABAxQZGam4uDj5+flJkooXL66YmBiL61++fFmDBg1S165dNX36dJ0+fVoTJkxQ4cKFNXz4cHO/oKAg9e/fX6tXr9bvv/+ucePGqV69emratGmevS4AAAAAAOS3hzLoaNu2rcXPH374oRo3bqyTJ09q//79io2N1dq1a+Xs7CxJqly5srnv/Pnz1a5dO40YMcJ8rEaNGpKkCxcuKDAwUNu2bVPp0qUlSa+88op++eUXBQYGavTo0elqmTdvnjlokKSKFSvq9ddf18yZMy2Cjg4dOqhbt24W595dQ8WKFfX7779r8+bNateunRwdHeXg4KCEhAS5uLhk+lysWLFCZcqU0cSJE2UymVStWjVdvnxZs2bN0tChQ1Wo0J1JO25ubuZ6qlSpomXLlik0NDTToCMhIUEJCQkZtqWmpmZaDwAAAAAA+emhDDrOnDmjuXPn6sCBA7p69ar5jffFixd19OhR1apVyxxy/NvRo0fVo0ePDNsiIiKUnJwsHx8fi+MJCQmZjnfs2DHt27dP8+fPNx9LTk7W7du3devWLRUpUkSS5O7unu7c5cuXa926dbpw4YJu376txMREc+hyryIjI+Xl5SWTyWQ+Vr9+fcXHx+vSpUsqV66cpDtBx91cXFx05cqVTMcNCAjQvHnzMm0v4yQtLTYzR7UCAAAAQJpzk3k/kd8qTTyU3yXcFw9l0DF48GCVL19eU6dOlaurq1JSUtShQwclJibKwcEhy3Ozao+Pj5eNjY3WrVsnGxsbi7aiRYtmes7w4cPVpk2bdG2FCxfO9PyNGzdq+vTpeuutt+Tl5SVHR0d9+eWXFnuJ5KV/b15qMpmynJnh6+ur/v37Z9jWqVMnJV+PztP6AAAAAADICw9d0HH16lWdPn1aU6dOlbe3t6Q7+2SkcXNz05o1a3Tt2rUMZ2FUr15doaGh6ZaRSFLNmjWVnJys2NhY89jZqVWrlk6fPm2xPOZe7Nu3T15eXurVq5f52N0bqkqSnZ2deW+RzFSrVk1btmxRamqqeVZHeHi4HB0dVaZMmRzVdDd7e3vZ29tn2Hb37BEAAAAAAAqSh+6uK8WLF5ezs7NWrVqls2fPKjQ0VNOmTTO3t2/fXqVKldLQoUMVHh6u8+fPa8uWLdq/f7+kOxuEbty4UXPnzlVkZKSOHz+uBQsWSJKqVq2qjh07auzYsfrhhx90/vx5HTx4UAEBAdq+fXuG9aRtgjpv3jydOHFCkZGR2rhxo2bPnp3l46hcubL++OMP/fLLLzp9+rQ++eQTHTpkOW2ofPnyOn78uE6dOqXY2NgMb0vbs2dPXbp0SVOmTFFkZKRCQkLk7++v/v37m/fnAAAAAADgv+KheydcqFAhzZ49W4cPH1aHDh3k5+ensWPHmtvt7e311Vdf6dFHH9WgQYPUsWNHLViwwLwUpVGjRpozZ45++uknde7cWS+//LJFwODn56cuXbpo2rRpeu655/Taa6/p0KFDKlu2bIb1NG/eXPPnz9fOnTvVvXt3vfDCC1q0aJHKly+f5eN48cUX1aZNG40aNUovvPCCrl27pp49e1r0eeGFF1S1alV169ZNjRs31r59+9KNU7p0aS1YsEAHDx5U586dNWnSJHXv3l1Dhgy55+cUAAAAAACjMKVyCw3kUKtWrZR0LUpLO2e8tAUAAAAAUPAZdTPSh25GBwAAAAAAQGYIOgAAAAAAgGEQdAAAAAAAAMMg6AAAAAAAAIZB0AEAAAAAAAyDoAMAAAAAABgGQQcAAAAAADAMgg4AAAAAAGAYBB0AAAAAAMAwCDoAAAAAAIBhEHQAAAAAAADDIOgAAAAAAACGQdABAAAAAAAMg6ADAAAAAAAYBkEHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMAg6AAAAAACAYRB0AAAAAAAAwyDoAAAAAAAAhkHQAQAAAAAADIOgAwAAAAAAGAZBBwAAAAAAMAyCDgAAAAAAYBgEHQAAAAAAwDBs87sAPJxsnSuo0sQf87sMAAAAAAAsMKMDAAAAAAAYBkEHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMAg6AAAAAACAYZhSU1NT87sIPFzq1Kmj5ORklS1bNr9LAQAAAAD8R5QtW1bLli3Lth8zOpBj9vb2kiQyMuNJTU3VjRs3eG0NiNfWuHhtjYvX1rh4bY2L19a4eG0fLszoQI7FxcWpfv36Cg8Pl5OTU36XgzzEa2tcvLbGxWtrXLy2xsVra1y8tsbFa/twYUYHAAAAAAAwDIIOAAAAAABgGAQdAAAAAADAMAg6AAAAAACAYRB0AAAAAAAAwyDoAPD/2rvzoKrqh4/jH2RRcQcJFwo3uoiIcVsQRXHBJjVMITXHsHE0c1xqXNJqmilIg3Lyj9RKRU0tcRhXriSWGoZpueEuRWOauw6iMqAyXe7zx5POc3+sxv3NeTi8XzP8cZbv4XPnjCN8ON/vAQAAAADToOjAI/Py8tK0adPk5eVldBS4GPfWvLi35sW9NS/urXlxb82Le2te3Nu6xc3hcDiMDgEAAAAAAOAKPNEBAAAAAABMg6IDAAAAAACYBkUHAAAAAAAwDYoOAAAAAABgGhQdAAAAAADANCg68Mi+/fZbDRgwQN27d9fIkSN1/PhxoyOhlg4ePKjJkycrKipKFotFO3fuNDoSXGTp0qWKj49XeHi4IiMjNWXKFJ09e9boWHCBdevWKTY2VlarVVarVaNHj9aePXuMjgUXW7ZsmSwWi+bPn290FLjAokWLZLFYnL5eeOEFo2PBBa5du6bZs2crIiJCYWFhio2N1YkTJ4yOhVoaMGBAuX+zFotFiYmJRkdDNTyMDoC65bvvvlNycrISExPVo0cPrV69WhMmTFBWVpZ8fX2Njod/qaSkRBaLRfHx8Zo2bZrRceBCBw4c0NixY9W9e3fZ7XYtXLhQEyZMUGZmpry9vY2Oh1po06aNZs+ercDAQDkcDm3ZskVTp07V5s2bFRQUZHQ8uMDx48e1fv16WSwWo6PAhYKCgrRq1aqH2+7u7gamgSvcvn1bY8aMUUREhJYvX65WrVrp/PnzatGihdHRUEsbNmyQ3W5/uJ2fn6/x48dTUNYBFB14JKtWrdKoUaMUHx8vSUpMTFR2drY2btyoSZMmGZwO/1Z0dLSio6ONjoH/ghUrVjhtp6SkKDIyUqdOndKzzz5rUCq4woABA5y2Z8yYobS0NB09epSiwwSKi4v19ttva968efryyy+NjgMXcnd3l5+fn9Ex4ELLly9XmzZtlJyc/HDf448/bmAiuIqPj4/T9rJly/TEE0/oueeeMygRaoqpK6ix0tJSnTp1Sr169Xq4r0GDBurVq5dyc3MNTAagpoqKiiSJvzKZjN1uV2ZmpkpKShQeHm50HLhAUlKSoqOjnf7PhTmcP39eUVFRGjhwoGbNmqXLly8bHQm1tHv3boWGhurNN99UZGSkhg8frvT0dKNjwcVKS0uVkZGh+Ph4ubm5GR0H1eCJDtRYYWGh7HZ7uSkqvr6+zPkH6oCysjJ9/PHHslqtevLJJ42OAxf47bff9Morr+j+/fvy9vbWkiVL1KVLF6NjoZYyMzN1+vRpbdiwwegocLGwsDAlJyerY8eOunHjhpYsWaKxY8fKZrOpadOmRsfDv3ThwgWlpaVp/Pjxmjx5sk6cOKF58+bJ09NTI0aMMDoeXGTnzp0qKirintYRFB0AUE8kJiYqPz9f69atMzoKXKRjx47asmWLioqKtGPHDs2dO1fffPMNZUcdduXKFc2fP18rV65Uw4YNjY4DF/u/00SDg4PVo0cP9e/fX9u3b9fIkSMNTIbacDgcCg0N1cyZMyVJISEhys/P1/r16/ml2EQ2btyovn37yt/f3+goqAGmrqDGWrVqJXd3dxUUFDjtLygoUOvWrQ1KBaAmkpKSlJ2drdWrV6tNmzZGx4GLeHl5KTAwUKGhoZo1a5aCg4O1Zs0ao2OhFk6dOqWCggLFxcUpJCREISEhOnDggNauXauQkBCnRfFQ9zVv3lwdOnTQX3/9ZXQU1IKfn586d+7stK9Tp05MSzKRS5cuad++fXr55ZeNjoIa4okO1JiXl5e6deum/fv3KyYmRtL/Pgq/f/9+vfrqqwanA1ARh8Ohjz76SD/88IPWrl3L4mgmV1ZWptLSUqNjoBZ69uwpm83mtO/dd99Vp06d9Prrr/OGDpMpLi7WhQsXWJy0jrNarfrzzz+d9p07d07t27c3KBFcbdOmTfL19VW/fv2MjoIaoujAIxk/frzmzp2r0NBQhYWFafXq1bp7967i4uKMjoZaKC4udvpr0sWLF3XmzBm1aNFC7dq1MzAZaisxMVHbtm3TF198oSZNmujGjRuSpGbNmqlRo0YGp0NtfPbZZ+rbt6/atm2r4uJibdu2TQcOHCj3ph3ULU2bNi23ho63t7datmzJ2jom8Mknn6h///5q166drl+/rkWLFqlBgwZ68cUXjY6GWnjttdc0ZswYffXVVxo8eLCOHz+u9PR0JSUlGR0NLlBWVqZNmzZp+PDh8vDg1+e6gjuFRzJkyBDdvHlTn3/+uW7cuKGuXbsqNTWVqSt13MmTJzVu3LiH2w9ejzZixAilpKQYFQsukJaWJklKSEhw2p+cnExBWccVFBRo7ty5un79upo1ayaLxaIVK1aod+/eRkcDUImrV69q5syZunXrlnx8fPT0008rPT293CssUbeEhYVp8eLFWrhwoZYsWaKAgAC99957GjZsmNHR4AL79u3T5cuXFR8fb3QUPAI3h8PhMDoEAAAAAACAK7AYKQAAAAAAMA2KDgAAAAAAYBoUHQAAAAAAwDQoOgAAAAAAgGlQdAAAAAAAANOg6AAAAAAAAKZB0QEAAAAAAEzDw+gAAAAARrNYLE7bbm5uatKkiTp37qwhQ4Zo7Nix8vT0LDfunXfe0ebNmyVJo0ePVlJSUoXXLy0tVVRUlG7fvi1JWrNmjSIiIpzOOXfunFauXKlffvlFV65ckYeHh3x8fBQYGKhnnnlGQ4cOVWBg4MPzFy1apMWLF1f72Xbt2qWAgIBqzwMAwCwoOgAAAP4xYsQISZLdbtelS5eUm5urY8eOKTs7W6mpqfLwqPxHp6ysLL3//vvy8vIqdyw7O/thyVGRvXv3aurUqbp37578/PzUs2dPNW/eXFevXtXhw4f1888/y8PDQ5MmTSo3Njg4WF27dq302t7e3lV9ZAAATIeiAwAA4B8pKSlO28eOHVNCQoL279+vzMxMvfTSSxWOCwkJ0enTp/XTTz8pJiam3PGMjAy5u7srKChIeXl5Tsfu3bunOXPm6N69e5o8ebKmTZvm9PRISUmJdu3apcaNG1f4vWNiYjR9+vRH/agAAJgWa3QAAABUokePHg+f8ti7d2+l5w0dOlQNGjRQRkZGuWN37tzRnj17FBkZqdatW5c7fvjwYRUUFMjf318zZswoN0XG29tbsbGxFRYoAACgPIoOAACAKgQFBUmSbt68Wek5D6abZGdnq6ioyOnY9u3bVVpaqtjY2ArHPriuj4+PixIDAFC/UXQAAABUobi4WFL1RURsbKzu37+vHTt2OO232Wxq3LixBg0aVOG4tm3bSpJ+//13HTp0yAWJAQCo3yg6AAAAqpCTkyNJ6tOnT5XnPf/882rUqJHT9JXLly/r0KFDGjhwoJo0aVLhuPDwcHXp0kV2u13jxo3TG2+8oa+//loHDx7U3bt3XfdBAACoJ1iMFAAA4D+UlZXp4sWLWrFihQ4ePKiBAwdqyJAhVY5p2rSp+vfvrx07dujatWvy9/eXzWaTw+HQsGHDKh3n7u6upUuXavbs2crNzVV2drays7MlSZ6enoqKitLUqVPVvXv3CscvXry40tfMBgcHa+vWrTX70AAAmARFBwAAwD8sFku5faNGjVJSUpLc3NyqHT9s2DBt375dNptNEydOlM1mk6+vr3r37l3luICAAK1fv15HjhzR7t27dezYMZ08eVIlJSX68ccflZOTowULFlRYtlT1etkH02IAAKhPKDoAAAD+8eANK/fv31deXp7Onj2r9PR0hYeHKy4urtrxffr0UcuWLWWz2dSrVy/l5+crISFBHh41+5HLarXKarVKkkpLS7Vv3z4tWLBAf/zxhz744ANFR0eXmwLD62UBAHBG0QEAAPCPlJQUp+3U1FQtWLBASUlJioiIUPv27asc7+npqcGDBystLU0LFy6UpCqnrVTFy8tL/fr1U7du3TRo0CDduXNHubm5ioqK+lfXAwCgvmAxUgAAgEpMnDhRUVFRunv3bqXrYPynB8VGTk6OOnTooLCwsFpl8PPzU6dOnSRJhYWFtboWAAD1AUUHAABAFWbNmiVJysjI0KVLl6o932q1Kjg4WC1btlR8fHy15zscjiqP2+32h9/X39+/BokBAKjfKDoAAACqEBISopiYGP39999KTU2t0ZitW7fq119/1aRJk6o9d/fu3Xrrrbd05MiRcsdKSkr04Ycf6tatW3rsscf01FNPPWp8AADqHdboAAAAqMb06dO1a9cubdy4UVOmTJGfn5/Lru1wOJSVlaWsrCz5+fmpa9euat68uQoLC3Xy5Endvn1b3t7e+vTTT+Xl5VVu/M6dO6t80iQhIUHdunVzWV4AAP6/o+gAAACoRnBwsAYNGqTvv/9eq1at0pw5c1x27T59+mjZsmXKycnR0aNHdebMGRUWFqphw4YKCAhQXFycEhISKl0INS8vT3l5eZVePyYmhqIDAFCvuDmqmxgKAAAAAABQR7BGBwAAAAAAMA2KDgAAAAAAYBoUHQAAAAAAwDQoOgAAAAAAgGlQdAAAAAAAANOg6AAAAAAAAKZB0QEAAAAAAEyDogMAAAAAAJgGRQcAAAAAADANig4AAAAAAGAaFB0AAAAAAMA0KDoAAAAAAIBpUHQAAAAAAADT+B8iB+IYX6+3pQAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1332,32 +1455,32 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 105, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " origin name cylinders weight model_year \\\n", - "origin 1.000000 0.562702 0.550413 0.592037 0.169058 \n", - "name 0.562702 1.000000 0.798929 0.854352 0.591282 \n", - "cylinders 0.550413 0.798929 1.000000 0.876777 0.344348 \n", - "weight 0.592037 0.854352 0.876777 1.000000 0.300008 \n", - "model_year 0.169058 0.591282 0.344348 0.300008 1.000000 \n", - "displacement 0.654441 0.835537 0.895527 0.941594 0.334152 \n", - "horsepower 0.517409 0.832600 0.812487 0.878684 0.397575 \n", - "acceleration 0.292586 0.561621 0.640407 0.550888 0.347110 \n", + " origin name cylinders horsepower weight \\\n", + "origin 1.000000 0.562702 0.550413 0.517409 0.592037 \n", + "name 0.562702 1.000000 0.798929 0.832600 0.854352 \n", + "cylinders 0.550413 0.798929 1.000000 0.812487 0.876777 \n", + "horsepower 0.517409 0.832600 0.812487 1.000000 0.878684 \n", + "weight 0.592037 0.854352 0.876777 0.878684 1.000000 \n", + "acceleration 0.292586 0.561621 0.640407 0.695982 0.550888 \n", + "model_year 0.169058 0.591282 0.344348 0.397575 0.300008 \n", + "displacement 0.654441 0.835537 0.895527 0.879012 0.941594 \n", "\n", - " displacement horsepower acceleration \n", - "origin 0.654441 0.517409 0.292586 \n", - "name 0.835537 0.832600 0.561621 \n", - "cylinders 0.895527 0.812487 0.640407 \n", - "weight 0.941594 0.878684 0.550888 \n", - "model_year 0.334152 0.397575 0.347110 \n", - "displacement 1.000000 0.879012 0.586090 \n", - "horsepower 0.879012 1.000000 0.695982 \n", - "acceleration 0.586090 0.695982 1.000000 \n" + " acceleration model_year displacement \n", + "origin 0.292586 0.169058 0.654441 \n", + "name 0.561621 0.591282 0.835537 \n", + "cylinders 0.640407 0.344348 0.895527 \n", + "horsepower 0.695982 0.397575 0.879012 \n", + "weight 0.550888 0.300008 0.941594 \n", + "acceleration 1.000000 0.347110 0.586090 \n", + "model_year 0.347110 1.000000 0.334152 \n", + "displacement 0.586090 0.334152 1.000000 \n" ] } ], @@ -1371,19 +1494,17 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 106, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -1401,7 +1522,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 107, "metadata": {}, "outputs": [ { @@ -1417,7 +1538,7 @@ " 'acceleration_enc']" ] }, - "execution_count": 30, + "execution_count": 107, "metadata": {}, "output_type": "execute_result" } @@ -1443,13 +1564,13 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 108, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "083107d2da854d5cb5e28549ff1629a7", + "model_id": "2e66f30c27a843859c1f283292267ffd", "version_major": 2, "version_minor": 0 }, @@ -1510,7 +1631,7 @@ " \n", " \n", " 2\n", - " [weight_enc, model_year_enc, horsepower_enc]\n", + " [model_year_enc, weight_enc, horsepower_enc]\n", " horsepower_enc\n", " 2.910080\n", " 2.850227\n", @@ -1519,7 +1640,7 @@ " \n", " \n", " 3\n", - " [horsepower_enc, weight_enc, model_year_enc, o...\n", + " [weight_enc, horsepower_enc, model_year_enc, o...\n", " origin_enc\n", " 2.859103\n", " 2.737770\n", @@ -1528,7 +1649,7 @@ " \n", " \n", " 4\n", - " [horsepower_enc, origin_enc, weight_enc, model...\n", + " [horsepower_enc, weight_enc, model_year_enc, o...\n", " cylinders_enc\n", " 2.857995\n", " 2.713305\n", @@ -1543,9 +1664,9 @@ " predictors last_added_predictor \\\n", "0 [weight_enc] weight_enc \n", "1 [weight_enc, model_year_enc] model_year_enc \n", - "2 [weight_enc, model_year_enc, horsepower_enc] horsepower_enc \n", - "3 [horsepower_enc, weight_enc, model_year_enc, o... origin_enc \n", - "4 [horsepower_enc, origin_enc, weight_enc, model... cylinders_enc \n", + "2 [model_year_enc, weight_enc, horsepower_enc] horsepower_enc \n", + "3 [weight_enc, horsepower_enc, model_year_enc, o... origin_enc \n", + "4 [horsepower_enc, weight_enc, model_year_enc, o... cylinders_enc \n", "\n", " train_performance selection_performance validation_performance \\\n", "0 4.225088 4.006856 4.348181 \n", @@ -1562,7 +1683,7 @@ "4 regression " ] }, - "execution_count": 31, + "execution_count": 108, "metadata": {}, "output_type": "execute_result" } @@ -1593,14 +1714,14 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 109, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1614,14 +1735,14 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 110, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1645,16 +1766,16 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 111, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "['horsepower_enc', 'weight_enc', 'model_year_enc', 'origin_enc']" + "['weight_enc', 'horsepower_enc', 'model_year_enc', 'origin_enc']" ] }, - "execution_count": 34, + "execution_count": 111, "metadata": {}, "output_type": "execute_result" } @@ -1669,19 +1790,19 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 112, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'horsepower_enc': 0.23995291830303586,\n", - " 'weight_enc': 0.6043307579612885,\n", - " 'model_year_enc': 0.5934134477782862,\n", - " 'origin_enc': 0.1525062273428473}" + "{'weight_enc': 0.604330757961289,\n", + " 'horsepower_enc': 0.2399529183030354,\n", + " 'model_year_enc': 0.5934134477782859,\n", + " 'origin_enc': 0.15250622734284752}" ] }, - "execution_count": 35, + "execution_count": 112, "metadata": {}, "output_type": "execute_result" } @@ -1692,14 +1813,14 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 113, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1728,33 +1849,32 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 114, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'meta': 'linear-regression',\n", - " 'predictors': ['horsepower_enc',\n", - " 'weight_enc',\n", + " 'predictors': ['weight_enc',\n", + " 'horsepower_enc',\n", " 'model_year_enc',\n", " 'origin_enc'],\n", - " '_eval_metrics_by_split': {'selection': 2.7377702963941557,\n", - " 'train': 2.859102895087039,\n", - " 'validation': 2.9373087153532134},\n", + " '_eval_metrics_by_split': {'selection': 2.737770296394154,\n", + " 'train': 2.8591028950870387,\n", + " 'validation': 2.9373087153532125},\n", " 'params': {'copy_X': True,\n", " 'fit_intercept': True,\n", " 'n_jobs': None,\n", - " 'normalize': 'deprecated',\n", " 'positive': False},\n", - " 'coef_': [0.23995291830303586,\n", - " 0.6043307579612885,\n", - " 0.5934134477782862,\n", - " 0.1525062273428473],\n", + " 'coef_': [0.604330757961289,\n", + " 0.2399529183030354,\n", + " 0.5934134477782859,\n", + " 0.15250622734284752],\n", " 'intercept_': -13.893878727739835}" ] }, - "execution_count": 37, + "execution_count": 114, "metadata": {}, "output_type": "execute_result" } @@ -1766,7 +1886,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 115, "metadata": {}, "outputs": [], "source": [ @@ -1806,7 +1926,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 116, "metadata": {}, "outputs": [], "source": [ @@ -1817,7 +1937,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 117, "metadata": {}, "outputs": [], "source": [ @@ -1827,7 +1947,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 118, "metadata": {}, "outputs": [ { @@ -1840,7 +1960,7 @@ "dtype: float64" ] }, - "execution_count": 41, + "execution_count": 118, "metadata": {}, "output_type": "execute_result" } @@ -1851,14 +1971,14 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 119, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1871,18 +1991,18 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 120, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "quantiles [-2.128045234184984, -1.8339146358159146, -1.6...\n", - "residuals [-1.8528672099028296, -1.830647894988804, -1.7...\n", + "residuals [-1.8528672099028316, -1.8306478949888063, -1....\n", "dtype: object" ] }, - "execution_count": 43, + "execution_count": 120, "metadata": {}, "output_type": "execute_result" } @@ -1893,14 +2013,14 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 121, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+0AAALGCAYAAAAwW3BSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACyNklEQVR4nOzdd3RU1d7G8WdKeiEkoQYIPYTeBAEVKXZFELFxwV7xtRe49kZRsSLqVRCxgQ1EQUVAVKT30EKHJCAlAdJIJjNz3j8igUkmECaTSft+1nKZc/Ypv+hJ4Jm9z94mwzAMAQAAAACACsdc3gUAAAAAAAD3CO0AAAAAAFRQhHYAAAAAACooQjsAAAAAABUUoR0AAAAAgAqK0A4AAAAAQAVFaAcAAAAAoIIitAMAAAAAUEER2gEAAAAAqKAI7QAAoEIZOXKk4uLi1Ldv3/IuBQCAcmct7wIAAKiqMjIyNGvWLC1cuFA7duxQamqqrFaroqOj1a5dO/Xr108XX3yxLBZLmdaxcuVK/fLLL1q+fLkOHjyozMxM1axZUzExMTrvvPM0YMAANWrUqExrAAAAnjEZhmGUdxEAAFQ1X3/9tcaPH6+jR4+e9riWLVvqxRdfVKdOnbxewz///KPnnntOCxcuPO1xfn5+GjZsmB555BH5+fl5vY6zNXLkSM2YMUMxMTFasGBBmdwjLi5OknT//ffr//7v/8rkHgAAeAM97QAAeNm4ceM0efJkSZLVatXll1+uvn37KiYmRjabTbt27dJPP/2kpUuXauvWrbr55pv15ptvql+/fl6rYceOHbrtttv0zz//SJIaN26swYMHq127dgoPD9fhw4e1dOlSff/99zp69KgmT56sxMRETZgwQcHBwV6rAwAAlA6hHQAAL/riiy8KAnvdunX1wQcfKD4+3uWYrl27asiQIfrxxx81atQo5ebm6uGHH9Z3332nFi1alLqGzMxM3XPPPQWB/ZZbbtGjjz4qf39/l+N69+6tO+64Q4888oiWLl2qv//+W88//7xeffXVUtcAAAC8g4noAADwkpSUFI0bN06SFBwcrClTphQJ7Ke66qqrNHr0aElSbm6unnzySa/U8frrr2vv3r2SpCFDhmjUqFFFAvsJUVFR+uCDD9SqVStJ0g8//KD58+d7pQ4AAFB6hHYAALzk008/VW5uriTpvvvuU5MmTc54zoABA3T++edLkjZu3KhFixaVqobU1FR99913kqTo6GiNHDnyjOcEBQXpxRdfLNj+6KOPPLr3999/r7i4OMXFxSk5OVk2m02TJk3SoEGD1KVLF3Xu3FlDhgzRF198IYfD4dE9TpWYmKhnnnlGF198sTp06KBOnTrpiiuu0OjRo5WcnOz2nL59+xa8zy5JEyZMKKj5xD8l+W8GAICvENoBAPACwzD0ww8/SJICAwN1ww03lPjcm2++ueDrE4HbU7Nnz5bNZpMkDR48WKGhoSU6r0OHDurYsaMkac2aNdqxY0ep6khPT9cNN9ygV199VZs2bVJmZqaysrK0fv16vfjii7r55puVlZXl8fU//PBDDRw4UF9//bX27NmjnJwcZWdna/v27fr000912WWXaebMmaX6HgAAqAh4px0AAC/Ytm1bwUzxXbt2VVhYWInP7dmzpwIDA5WTk6OVK1eWqo5Tz+/Tp89Zndu3b1+tXbtWkrRq1So1a9bM4zqeffZZbdy4UZdffrkGDhyoqKgo7d69W1OmTFFCQoJWrFihJ554Qu+9995ZX/uLL77QG2+8IUmKjIzUnXfeqc6dO8vhcGjJkiWaNGmSsrOzNXLkSNWsWVO9e/cuOHfSpEnKy8vTVVddJUm68cYbddNNN7lcv0aNGh5/3wAAeBuhHQAAL9iyZUvB161btz6rcy0Wi1q1aqW1a9fq4MGDOnz4sKKjo0tVh9lsPu379O6cWvfGjRs9uv8JCQkJeuSRR3T33XcX7Gvbtq0uvfRS3X333Vq0aJHmzZunP/74wyVUn0laWppee+01SVLt2rX19ddfq169egXtXbp0Ud++fTV06FBlZ2frmWee0fz58wuWsiv8ykJUVJRatmxZmm8VAIAyxfB4AAC84MiRIwVfexK4o6Ki3F7L0zpCQ0MVGBh4VueeWndpapDy10G/6667iuy3Wq165ZVXCkL0l19+eVbX/e6773T8+HFJ0qhRo1wC+wmtW7cuuPeBAwc0b968sy0fAIAKg9AOAIAXnPp+tifrnJ96Tnp6eqnrKG0NGRkZHtcgSYMGDZLJZHLbVrduXfXq1UuStHz58rOalG7JkiWSpPDwcF100UXFHjdkyJAi5wAAUBkxPB4AAC8ICQkp+Do7O/uszz/1nFOXZ8vLy9OuXbuKPa9JkyYFvdYn6khPT/dqDZ5o167dGdsXLlyo7OxsJSUlqXHjxiW67tatWyXl96af+n0XFh0drZiYGKWkpBScAwBAZURoBwDAC2rWrFnw9eHDh8/6/NTUVLfXOnDgQMGkae7Mnz9fDRo0cDk3PT1dmZmZysnJOash8qfWfWoNnoiMjDxt+6lD8Y8dO1bi65449tTXCYpTq1YtpaSknNX1AQCoaBgeDwCAF7Rq1arg602bNp3VuQ6HQ4mJiZLy10yvX79+qetwOp0uk+OVxKl1N23a1OMaJBU7NN5byvr6AABUFPS0AwDgBS1atFBERISOHj2qlStXKiMjo8TLvi1evLhgcrXOnTvLbD75mXqDBg0KAn1JdO3aVb/++qskacGCBQVrr5fEggULXK5TGqmpqUVmaj/Vqb36Z7PEWo0aNXTo0KESjWY4dOjQWV8fAICKhp52AAC8wGQyaeDAgZKknJwcff311yU+9/PPPy/4+tJLLy1VHVdccUXB++jff/+9ywR5p7N+/fqCNdrr1at3VmHfnYSEhNO2b9iwQVL+yIKGDRuW+LonlmfbtGmT7HZ7scelpqZq3759LucAAFAZEdoBAPCS4cOHKyAgQJI0YcIE7dmz54znzJ49WwsXLpSU/w721VdfXaoaoqKiNHjwYEn5Pc2vvvrqGc/JycnRc889V7B9yy23uPT2e+KHH36QYRhu2w4cOKBFixZJkrp16yaLxVLi6/bo0UNS/gz7c+fOLfa4b7/9tuD+J8451Yn/TzabrcT3BgCgPBDaAQDwkpiYGD355JOS8mdiv+WWW077XvmcOXMKjpekp59+uiBMlsZjjz1W0Hs9bdo0jRs3Tnl5eW6PTUtL07333lvwPnt8fLyGDh1a6ho2b96sjz/+uMh+u92up59+uqCeG2+88ayuO3jwYAUFBUmSxo0bpwMHDhQ5ZsuWLfrggw8kSXXq1FH//v2LHFOrVi1J0t69e8/q/gAA+BrvtAMA4EVDhw5VcnKyJk+erH379mnw4MG64oor1LdvX9WvX192u107d+7UTz/95LJ++D333FPqofEnhIaG6oMPPtDtt9+uf/75R5MnT9bvv/+uwYMHq127dgoLC1NqaqqWLl2q7777TkePHpUk1a5dWxMmTDjtUmol1bZtW73++uvasmWLrr76akVFRWnPnj365JNPtH79eklSnz591KdPn7O6bmRkpB5//HG9+OKL+ueff3TNNdfozjvvVOfOnWW327V48WJNmjRJ2dnZMplMeumll9x+P506dVJycrIWLFigadOmqXPnzgUfmISGhpZodnoAAHzBZBQ3dg0AAHhs+vTpeuONNwoCcXECAgL0xBNP6D//+Y/Xa9i/f7+effZZ/fnnn2c8tlOnTnrzzTdVr149j+/3/fffa9SoUZKkGTNm6Kmnnip2Jv3OnTvro48+UmhoaJG2kSNHasaMGYqJiXGZHO9UH3zwgd5++205nU637f7+/nrppZcK5hkobPPmzbruuuvcDo8fNGiQxo4d6/Y8AAB8jZ52AADKwPXXX6/LLrtMs2bN0sKFC7V9+3alpaUpNze34JiQkBDNmDFDsbGxZVJDvXr19NFHH2nlypX65ZdftGzZMh08eFDHjh1zed/8pptu0rPPPuvVZdTCw8M1bdo0ffrpp5ozZ4727t0rwzDUrFkzDRw4UDfeeONZvcte2D333KMLL7xQX3zxhZYuXaqDBw/KbDarXr166tWrl26++WaX9esLi4+P1/Tp0zVp0iStXr1ahw8f5v12AECFRE87AAA+9uqrr2rSpEmSpKuuukqvvfaaz9cdT0pK0vXXX6/U1FQFBwfr888/V5s2bUp1zVN72ufPn3/a0AwAAEqGiegAAPCxxx9/XBdffLEk6ccffyzRDO/e1rBhQ02cOFEBAQHKzs7WXXfdpaSkJJ/XAQAATo/QDgCAj5lMJr322mtq166dJGny5MmaMmWKz+vo2LGjxo0bJ5PJpMOHD+v2229Xamqqz+sAAADF4512AADKQWBgoD744ANNmzZNhmEoMzNT6enpCg8P92kdl112mQzD0I4dOyRJa9ascbtEGgAAKB+EdgAAykl0dLTuv//+8i5Dl19+eXmXAAAAisHweAAAAAAAKqgqN3v8//73P40fP17Dhw/XU089Vd7lAAAAAADgsSo1PH79+vWaNm2a4uLiij3Gbrfr2LFjCggIkNnMQAMAAAAAQNlyOp3Kzc1VjRo1ZLWeXQyvMqE9KytLjz/+uF5++WW9//77xR537Ngx7d6923eFAQAAAAAgqXHjxoqKijqrc6pMaH/xxRfVu3dv9ezZ87ShPSAgQJLUoEEDBQcH+6o8VENOp1Pbt29X8+bNGdWBMsWzBl/hWYOv8KzBV3jW4CvZ2dlKTk4uyKNno0qE9tmzZ2vTpk369ttvz3jsiR/G5OTksi4LkCRt3769vEtANcGzBl/hWYOv8KzBV3jW4CuefDhU6UP7/v379corr2jy5Mln9alF8+bNFRoaWoaVobpzOBxKSEhQu3btZLFYyrscVGE8a/AVnjX4Cs8afIVnDb6SmZnp8YdDlT60b9y4UampqbrmmmsK9jkcDq1YsUJffPGFEhIS3P4Ams1mfjDhExaLhWcNPsGzBl/hWYOv8KzBV3jWUNZK8/pFpQ/t5557rn788UeXfaNGjVLTpk1155138sMHAAAAAKi0Kn1oDw0NVcuWLV32BQcHKyIiosh+AAAAAAAqE6ZIBAAAAACggqr0Pe3ufPbZZ+VdAgAAAAAApUZPOwAAAAAAFRShHQAAAACACorQDgAAAABABUVoBwAAAACggiK044zeffdd9ezZU3FxcZo3b155l1MmRo4cqfvuu6/Exy9btkxxcXFKT08vw6oAAAAAVHdVcvZ4eM+OHTs0YcIEvffee+rQoYNq1KhR6mu+++67mjdvnn744QcvVAgAAAAAVRehvSSyD3l+rl+o5BdUzHUPSzKK7g+u5fn9vMThcMhkMmnv3r2SpH79+slkMpVzVQAAAABQvRDaS+L92p6f23eC1GmE+7Yp8dLxw0X3P+omyJ/GsGHD1KJFC0nSDz/8IKvVqhtvvFEPPvhgQdC22Wx688039dNPPykjI0MtWrTQY489pu7du0uSvv/+e40ePVrjxo3T+PHjtXv3bg0YMEAzZsyQJLVq1UqSlJiYKEn65ptvNHnyZCUnJysmJkbDhg3T0KFDC2r6559/9Oqrr2rRokWy2Wxq2rSpnnvuuYKee0mKi4uTJI0ZM0bXXHNNke9r5MiRSk9PV/v27TV16lTZbDbdcsstuueeezR+/Hh99913CgwM1IMPPqjBgwcXnJeYmKhXXnlFa9euVVBQkC6++GKNHDlSISEhkvI/kHj11Vf13XffyWKxaPDgwTIM1//mTqdTH330kaZPn67Dhw+rcePGuu+++3TppZee1f8bAAAAACgNQnsVMWPGDF177bX65ptvtGHDBj377LOqX7++rrvuOknSiy++qO3bt+vNN99U7dq19dtvv+mOO+7Qjz/+qMaNG0uScnJy9NFHH+nll19WRESEateurW7dumnUqFFatGhRwb1mzZqlt99+W88++6zi4+O1efNmPfPMMwoODtagQYOUlZWl//znP6pTp44mTpyoWrVqaePGjXI6nbr88su1bds2/fXXX/rkk08kSWFhYcV+X0uXLlXdunX1+eefa/Xq1Xrqqae0Zs0anXPOOfr66681Z84cPffcc+rVq5fq1q2r7Oxs3X777erUqZO+/fZbpaam6umnn9ZLL72ksWPHSpImT56sGTNmaPTo0WrWrJkmT56s3377Teeee27BfT/88EPNmjVLL7zwgho3bqwVK1bo8ccfV2RkpLp16+bt/30AAAAA4BahvYqoV6+e/vvf/8pkMqlp06baunWrpkyZouuuu0779u3T999/r99//1116tSRJN1+++3666+/9P333+uRRx6RJOXl5en5558v6FWXpPDwcElSrVonh+y/++67GjlypC6++GJJUsOGDbV9+3ZNnz5dgwYN0k8//aS0tDR9++23ioiIkCTFxsYWnB8cHCyLxeJyzeJERETo6aefltlsVtOmTfXxxx8rJydH99xzjyTp7rvv1kcffaRVq1bpiiuu0E8//SSbzaZx48YpODhYkvTss8/qnnvu0WOPPabo6Gh9+umnuuuuuwrqf+GFF1w+lLDZbPrwww/1ySefqFOnTgXf46pVqzR9+nRCOwAAAACfIbRXER06dHB557xjx4765JNP5HA4tHXrVjkcjiJDu202W0GoliQ/P7+CIevFyc7O1t69e/XUU0/pmWeeKdhvt9sLesw3b96s1q1bu1zbU82bN5fZfHKRg+jo6IJXASTJYrEoIiJCqampkvInzouLiysI7JLUuXNnOZ1O7dq1SwEBATp06JA6dOhQ0G61WtW2bduCIfJ79uzR8ePHddttt7nUkpeXp/j4+FJ/TwAAAABQUoT2krj3oOfn+oUW33bLZrmdiM7LsrOzZbFYCt7hPtWp4TYwMPCMk81lZ2dLkl566SWX4CupIFwHBgZ6o2xJ+YH6VCaTye0+p9PptXue+B4//PDDgpEJJ/j7+3vtPgAAAABwJoT2kiir2dyDo712qfXr17tsr1u3TrGxsbJYLIqPj5fD4VBaWpq6du1aqvtER0erdu3aSkpK0oABA9weExcXp2+++UZHjx5129vu5+fn1ZB9qmbNmmnGjBnKzs4u+EBi9erVMpvNatKkicLCwlSrVi2tW7dO55xzjqT8UQIbN25U69atC67h7++vffv2MRQeAAAAQLkyn/kQVAb79u3TmDFjtHPnTv3000/6/PPPNXz4cElSkyZNdNVVV+mJJ57Q3LlzlZSUpPXr1+vDDz/UwoULz/peDzzwgP73v/9p6tSp2rVrlxITE/Xdd98VTCx3xRVXKDo6WiNGjNCqVauUlJSkX3/9VWvWrJEkxcTEKDk5WZs3b1ZaWppsNpvX/jtcddVV8vf318iRI7V161YtXbpUL730kq6++mpFR+d/SDJ8+HB99NFHmjdvnnbs2KEXXnhB6enpBdcIDQ3VbbfdpjFjxmjGjBnau3evNm7cqM8++6xgNn0AAAAA8AV62quIgQMHKicnR0OGDJHFYtHw4cN1/fXXF7SPGTNG77//vsaOHauDBw8qIiJCHTt21IUXXnjW9xoyZIgCAwM1adIkvfrqqwoODlbLli118803S8ofQj558mSNGzdOd911lxwOh5o1a6bnnntOknTJJZfot99+0/Dhw5Wenl7skm+eCAoK0qRJk/TKK6/o2muvdVny7YTbbrtNhw4d0pNPPimz2azBgwfroosuUkZGRsExDz30kCIjI/Xhhx8qOTlZYWFhat26dcEEeAAAAADgCyaj8ALVVVx2drY2b96sli1bnnapscpk2LBhatWqlZ566qnyLgWncDgcWrt2rTp27FhkLgHAm3jW4Cs8a/AVnjX4Cs8afCUjI0Nbt25VfHy8y7xiJcHweAAAAAAopWPZTv25KUebk/PkrF79oihjDI8HAAAAgFI4bjP06ox0HTyWP9nyjecHq287762ohOqN0F4FfPbZZ+VdAgAAAFBtLd6SWxDYJWnVDhuhHV7D8HgAAAAAKIXFibku21FhxCx4D08TAAAAAHgoOdWuvYccLvvObRlQTtWgKiK0AwAAAICHlmyxuWxHhJjUKoa3kOE9hHYAAAAA8IDDaWjpVteh8T1aBshsNpVTRaiKCO0AAAAA4IFNSXlKP+66vFuPVgyNh3cR2gEAAADAA38XGhrfpLZF9WpayqkaVFWEdkDSsmXLFBcXp/T09BKf07dvX02ZMqXsigIAAECFlZXj1LpdrqG9J73sKAOEdvhccnKy4uLitHnz5vIuBQAAAPDIiu022U8uzS6rWTqnuX/5FYQqi2kNz8DpNJSVa5z5QC8KCTCV6+QVDodDJpNJZrPrZzo2m03+/vwiAgAAAJYUWpu9QxM/hQTSJwrvI7SfxsrtNn35V5Yyjvs2tIcFmXTT+SHqWsJP6pxOpyZNmqSvv/5a+/fvV3R0tK6//nrde++9WrZsmYYPH64VK1YoPDxckrR582YNHDhQ8+fPV4MGDfT9999r9OjRGjdunMaPH6/du3dr7ty5Gj58uAYPHqw9e/Zo3rx5uvjiizV27FitXLlSb7zxhjZs2KCaNWvqoosu0iOPPKLg4GBJ+cPGr7vuOu3Zs0e//PKLatSooXvvvVfXX3+9JKlfv36SpIEDB0qSunXrps8++6zI93Wi9o8//ljjx4/Xzp071bFjR7355pvasGGDxo4dqwMHDqhPnz56+eWXFRQUJCn/w4VXX31Vs2fPVmZmptq2batRo0apffv2Bdf+448/NHr0aO3fv18dOnTQoEGDitz/TN8nAAAAqqd/jji084Dr2uw94hgaj7LBR0GnMXWh7wO7JGUcNzR1YVaJjx8/frw++ugj3XfffZozZ45ef/11RUdHn9U9c3Jy9NFHH+nll1/WTz/9pKioKEnS5MmT1apVK82cOVP33Xef9u7dqzvvvFMXX3yxZs2apTfffFOrVq3SSy+95HK9Tz75RG3bttXMmTN100036fnnn9fOnTslSd98840kacqUKVq0aJHefffd09Y2YcIEPfPMM5o2bZr++ecfPfTQQ5o6darGjx+v//3vf1q0aJFL6H/11Vf166+/auzYsZoxY4ZiY2N1xx136OjRo5Kk/fv36/7771efPn00c+ZMDRkyROPHj3e5Z0m/TwAAAFQ/iwv1socFmdSmoV85VYOqjtBeyWVmZmrq1Kl6/PHHNWjQIDVq1Ehdu3bVkCFDzuo6eXl5ev7559W5c2c1bdq0oNf63HPP1W233aZGjRqpUaNG+vDDD3XVVVfplltuUePGjdW5c2c99dRTmjlzpnJzT/7yuuCCCzR06FDFxsbqzjvvVM2aNbVs2TJJUmRkpCQpIiJCtWrVUkRExGlre+ihh9SlSxe1bt1a1157rZYvX67nn39erVu3VteuXXXJJZcUXDs7O1vTpk3TE088od69e6t58+Z66aWXFBAQoG+//VaS9NVXX6lRo0YaOXKkmjZtqgEDBhTpaS/p9wkAAIDqxek0tDTRdQK6c1sGyGphbXaUDYbHn8bwC0PKdXh8SezcuVM2m03nnntuqe7p5+enuLi4Ivvbtm3rsr1lyxYlJibqxx9/LNhnGIacTqeSk5PVrFkzSXK5lslkUnR0tFJTUz2q7dRrRUVFKSgoSA0bNizYFx0drYSEBEn5PeR5eXnq3Lmzy/fWvn177dixQ5K0Y8cOl6HyktSxY0ePvk8AAABUL1tS7DqS5XTZ1zOOeZ9Qdgjtp9G1ub86N/Wr0BPRBQSc/t2ZE5PJGcbJ7yEvL6/IcYGBgTKZit7zRI/7CdnZ2brhhhs0bNiwIsfWq1ev4Gur1fXRMplMLjWcjVOvZTKZ3F7b6XQWPq1USvp9AgAAoHopPAFdw2iLGkQTq1B2eLrOwGw2KSyo4g51ady4sQIDA7V06VKX3ucTTgxFP3TokGrUqCEpvxfZU61bt9b27dsVGxvr8TX8/PLf93E4HGc48uw1atRIfn5+Wr16tWJiYiTlf0iRkJCgm2++WZLUrFkzLViwwOW8devWuWx74/sEAABA1XLcZmj1zkJrszMBHcoY77RXcgEBAbrzzjv12muvaebMmdq7d6/Wrl1bMNlbo0aNVK9ePb377rvavXu3Fi5cqMmTJ3t8vzvvvFNr1qzRiy++qM2bN2v37t2aN2+eXnzxxRJfIyoqSoGBgfrrr790+PBhZWRkeFxPYcHBwbrxxhv16quv6s8//9T27dv1zDPPKCcnR9dee60k6YYbbtDu3bs1btw47dy5Uz/++KNmzJjh9e8TAAAAVcuqHTbZ7Ce3LWapWwuGxqNsEdqrgPvuu0+33nqr3nnnHV1++eV6+OGHlZaWJim/V/vEcmkDBgzQRx99pIceesjje7Vq1UqfffaZdu/erZtuukmDBg3SO++8o9q1a5f4GlarVU8//bSmT5+u888/X/fdd5/H9bjz2GOP6ZJLLtETTzyhQYMGac+ePfr4448LRhrUr19f7777rubPn6+rr75a06ZN08MPP+z17xMAAABVS+Gh8W0b+Sk8mEiFsmUyPH3RuJLKzs7W5s2b1bJlS4WFhZV3OajCHA6H1q5dq44dO8pisZR3OajCeNbgKzxr8BWeNfjK2Txrh9Id+u/nx1z23XtJqDo3o6cdZ5aRkaGtW7cqPj5ewcHBZ3UuHwsBAAAAwBksKbTMW0iASe0aszY7yh6hHQAAAABOw2kYRYbGd2vhLz/WZocPENoBAAAA4DS277frcLrrEsM9mDUePkJoBwAAAIDTWLzFtZe9Xk2LGtdmvgX4BqEdAAAAAIqRm2do1Y5Ca7O38pfJxNB4+AahHQAAAACKsWaXTTl5J7dNJunclgyNh+8Q2gEAAACgGIWHxrdu4KeIEGIUfIenDQAAAADcSMtwaEuy3WVfj1asyw7fIrQDAAAAgBtLt9pknLId5G9SpyaEdvgWoR0AAAAACjHcrM3etbm//K1MQAffIrQDAAAAQCG7Djr0z1HXtdl7xtHLDt8jtAMAAABAIYUnoKtdw6xmda3lVA2qM0I7AAAAAJwiz25oxXbXtdl7xAWwNjvKBaEdAAAAAE6xbneesnMNl309GBqPckJoBwAAAIBTLC40AV1cjFVRYZZyqgbVHaEdAAAAAP51LNupjXvzXPb1jAsop2oAQjsAAAAAFFi2NVfOU0bGB1ilzs0YGo/yQ2gHAAAAAOWvzb54i+sEdJ2b+SvQjwnoUH4I7QAAAAAgKemwQylpDpd9PVsxNB7li9AOAAAAACo6AV1UmFkt67M2O8oXoR0AAABAtWd3GFq21XVo/Lkt/WVmbXaUM0I7AAAAgGpvw948ZeYUXpudofEof4R2AAAAANXe4i2uQ+Ob17WqTgRrs6P8EdoBAAAAVGuZOU6t3+O6NnuPVizzhoqB0A4AAACgWluxPU8O58ltP4vUlbXZUUEQ2gEAAABUa0sSXXvZOzbxV3AAUQkVA08iAAAAgGorLdtPew8XXpudXnZUHIR2AAAAANVW4uFQl+2IEJNaN/Arp2qAogjtAAAAAKolh9PQtkKhvXvLAJnNrM2OioPQDgAAAKBa2pxsV3ae1WVfT9ZmRwVDaAcAAABQLS3d6joBXWwti+pHsjY7KhZCOwAAAIBqJzvXqbW7XUN7z1b0sqPiIbQDAAAAqHZWbrfJfsqk8Raz1K0Fs8aj4iG0AwAAAKh2FifaXLY7NPZTaCDxCBUPTyUAAACAauWfow7t+Mfusq8HE9ChgiK0AwAAAKhWliTmumyHBZrUthFrs6NiIrQDAAAAqDachqGlhYbGn9PcT1YLa7OjYiK0AwAAAKg2ElPsSst0uuzrEccEdKi4CO0AAAAAqo3CQ+OjgnPVMJq12VFxEdoBAAAAVAs5NkOrdrgOjW8ZnVlO1QAlQ2gHAAAAUC2s2mmT7ZRJ480mqQWhHRUcoR0AAABAtbBki+vQ+DYNrQr2cxZzNFAxENoBAAAAVHmH0x1K3Oe6Nvu5TECHSoDQDgAAAKDKW1JombfgAJPax1rLqRqg5AjtAAAAAKo0wzCKzBrfrbm//FibHZUAoR0AAABAlbb9H7sOpRdam71VQDlVA5wdQjsAAACAKm3JFteh8XUjzGpSm7XZUTkQ2gEAAABUWbl5hlYWWpu9Z6sAmUwMjUflUOlnXvjyyy/11VdfKSUlRZLUokUL3Xffferdu3c5VwYAAACgvK3dZdNxm1GwbZLUvSVD41F5VPrQXrduXT322GOKjY2VYRiaOXOmRowYoRkzZqhFixblXR4AAACAcrS40AR08Q2sigxlwDEqj0of2vv27euy/fDDD+urr77S2rVrTxvanU6nHA5HWZeHauzE88VzhrLGswZf4VmDr/CswVuOZDm1Odl1bfbuLf2KPGM8ayhrTqfzzAcVo9KH9lM5HA798ssvys7OVqdOnU577Pbt231UFaq7hISE8i4B1QTPGnyFZw2+wrOG0lqzr4YMI7Jg28/slDl9s9auNVyO41lDRVYlQntiYqJuuOEG5ebmKjg4WO+9956aN29+2nOaN2+u0NBQH1WI6sjhcCghIUHt2rWTxcLspCg7PGvwFZ41+ArPGrzBMAzNTMyUdLKHs1vLAJ3TpUPBNs8afCUzM9PjjuMqEdqbNGmimTNnKiMjQ7/++quefPJJff7556cN7mazmR9M+ITFYuFZg0/wrMFXeNbgKzxrKI1dB+z656jrkOSerQLdPlM8ayhrZrPn8yhUiRkY/P39FRsbq7Zt2+rRRx9Vq1atNHXq1PIuCwAAAEA5KTwBXa1ws1rUqxJ9lqhmqkRoL8zpdMpms535QAAAAABVTp7D0PJtrnng3DjWZkflVOk/aho/frwuuOAC1atXT1lZWfrpp5+0fPlyTZo0qbxLAwAAAFAO1u/OU3au62RzPeL8y6kaoHQqfWhPTU3Vk08+qYMHDyosLExxcXGaNGmSevXqVd6lAQAAACgHi7e4Do1vWd+qWuG8s47KqdKH9tGjR5d3CQAAAAAqiPRspzbszXPZ1zMuoJyqAUqvSr7TDgAAAKB6WrbNJucpI+P9rVKXZgyNR+VFaAcAAABQZRQeGt+5qb8C/ZmADpUXoR0AAABAlbD3sF3JqQ6XfT1bMTQelRuhHQAAAECVsKRQL3tkqFlxMZV+Gi9Uc4R2AAAAAJWe3WFoWeG12Vv6y8za7KjkCO0AAAAAKr2NSXnKOF54bXaGxqPyI7QDAAAAqPQKT0DXtI5FdWuyNjsqP0I7AAAAgEotM8ep9bsLrc3OBHSoIgjtAAAAACq1FdtssjtPblst0jnNWZsdVQOhHQAAAECltjjRdWh8x8b+Cg4g6qBq4EkGAAAAUGntT3No98HCa7PTy46qg9AOAAAAoNIq3MteI9ik1g39yqkawPsI7QAAAAAqJafT0NKtrqG9e8sAWcyszY6qg9AOAAAAoFLalJyno1mua7P3jGNoPKoWQjsAAACASmlJos1lu1Eti2KirOVUDVA2CO0AAAAAKp3sXKfW7HQN7T3jWJsdVQ+hHQAAAECls2qHTXmnTBpvMUvdWjA0HlUPoR0AAABApbN4i2sve7tYP4UFEW9Q9fBUAwAAAKhUDh5zaPs/dpd9DI1HVUVoBwAAAFCpLCm0NntooEntYlmbHVUToR0AAABApeE0jCKzxndr4S+rhbXZUTUR2gEAAABUGtv22ZWa4XTZ17MVQ+NRdRHaAQAAAFQaf29xHRofE2lRo2hLOVUDlD1COwAAAIBKISfP0OodrkPje8T5y2RiaDyqLkI7AAAAgEph9Q6bck+ZNN5kkrq3ZGg8qjZCOwAAAIBKofCs8W0a+ikihEiDqo0nHAAAAECFl5rh0JaUQmuzt/Ivp2oA3yG0AwAAAKjwCi/zFhxgUsfGhHZUfYR2AAAAABWaYRhFhsZ3beYvPysT0KHqI7QDAAAAqNB2/GPXwWOF12anlx3VA6EdAAAAQIVWeGh87RpmNa1jLadqAN8itAMAAACosGx2Qyu2u4b2nq0CWJsd1QahHQAAAECFtXaXTcdtRsG2SVKPlgyNR/VBaAcAAABQYRUeGt+qgVWRYZZyqgbwPUI7AAAAgArpaJZTG5PyXPb1iAsop2qA8kFoBwAAAFAhLduaK+PkyHgF+EmdmzI0HtULoR0AAABAhWMYhv7e4jo0vmszfwX4MQEdqhdCOwAAAIAKZ88hh/YfcbjsY2g8qiNCOwAAAIAKZ3First2VJhZLeqzNjuqH0I7AAAAgAolz2Fo+VbXofE94vxlZm12VEOEdgAAAAAVSsLuPGXlGi77GBqP6orQDgAAAKBCKTw0vkU9q2rXYG12VE+EdgAAAAAVRsZxpzbsZW124ARCOwAAAIAKY9lWmxzOk9v+Vqlrc9ZmR/VFaAcAAABQISzdmqvvl2a77OvYxF9B/kxAh+qLNRMAAAAAlCun09B3S49r7tqcIm29WjE0HtUboR0AAABAucnKceqj37K0MSmvSFunJn6Kb0BkQfXGTwAAAACAcrEvzaH3fs7QwWPOIm0XtgnQ9ecFy8Ta7KjmCO0AAAAAfG7dbps+/i1TOYU62C1m6abzg3VBm8DyKQyoYAjtAAAAAHzGMAzNWZWjH5Yfl1GoLSzIpHsvDVWLen7lUhtQERHaAQAAAPhETp6hKQsytWpH0ffXY2tZdN+loYoMs5RDZUDFRWgHAAAAUOYOpTs08edMJac6irR1a+Gvm/uEyN/K++tAYYR2AAAAAGVqS0qePvw1U5k5rgPiTSZp8LlBurhjIBPOAcUgtAMAAAAoE4ZhaEFCrr7+O1vOQi+wB/mbdNfFIWrbyL98igMqCUI7AAAAAK/Lcxj64o8s/b3FVqStXk2zRlwWpjoRvL8OnAmhHQAAAIBXHc1y6oNfMrXjgL1IW4fGfrq9f6iC/BkOD5QEoR0AAACA1+w6YNfEXzJ0NKvwgm7SFV0CNaBbkMy8vw6UGKEdAAAAgFcs3pKrz/7Ikr3QBPH+Vum2fqHq0oz314GzRWgHAAAAUCoOp6Fvl2Rr3rrcIm1RYWaNuCxUDaOJHoAn+MkBAAAA4LGsHKc+nJupzclF31+Pi7Hq7otDFRZkLofKgKqB0A4AAADAIympdr33c6YOpTuLtPVtF6AhPYNltfD+OlAahHYAAAAAZ231Tpsmz8tUbqEOdqtZGto7ROfFB5RPYUAVQ2gHAAAAUGJOw9DslTmateJ4kbYawSbde2momtX1K4fKgKqJ0A4AAACgRHJshibPz9SaXXlF2hrXtui+S8NUM5T31wFvIrQDAAAAOKNDxxx67+dMpaQ5irT1iPPXsN4h8rPy/jrgbYR2AAAAAKe1KSlP/5ubqaxcw2W/ySRd1zNY/doHyGQisANlgdAOAAAAwC3DMDR/fa6+XpwtwzWvKzjApLsvDlXrhry/DpQlQjsAAACAIrJynPryr2wt32Yr0lY/0qIRl4Wqdg1LOVQGVC+EdgAAAAAu1u+2aerCLB3LNoq0dWzip9v7hSrQn+HwgC8Q2gEAAABIkrJznfr672z9vaVo77okXXVOkK7sGigz768DPkNoBwAAAKBNSXn69PcspWU6i7QF+Zt0S98QdW7qXw6VAdUboR0AAACoxnLyDH23OFsLN+a6bW/byE/DLwxh/XWgnBDaAQAAgGpq6748TVmQpUPpRXvXA/2k63oF67x4lnMDyhOhHQAAAKhmbHZDM5Zma/76XBWdak5qFWPVLX1DFBXG7PAl5nRIZv57wfsI7QAAAEA1suMfuz5ZkKkDR4v2rvtbpWt7BKt32wAmmyspw5A2TpGWvSJd/5cUWq+8K0IVQ2gHAAAAqoE8h6FZy4/r17U5Mtx0rzevZ9WtfUNYe/1s2XOkJS9K6bulhY9IV35V3hWhimE2CQAAAKCK23PQrpe/Sdcva4oGdqtFGtIzSI9fHUZg94RfkNTvvfyvE6dJu38r33pQ5dDTDgAAAFRRdoeh2auOa86qHDnd9K43rm3RbX1DVS+SsF4qTS+XWgyWtn0n7f5FanxReVeEKoTQDgAAAFRByal2TZ6fpaTDjiJtFrN01TlBurRToCxm3l0vkYxkyWmXajR2397nLantbfkBHvAiQjsAAABQhTichn5Zk6MfVxyXo+hcc2oUbdGt/ULUIIooUCJOu7TmXenvZ6V650rXzpXcTdIX1iD/H8DL+EkFAAAAqoj9Rxz6ZH6mdh0s2rtuNklXdAnU5V2CZLXQu14i+5ZK8+6RDq3L3947T9oyTYq/sXzrQrVCaAcAAAAqOafT0Lz1OZq57LjyiuZ11Y+06La+IYqtzV//SyTniPTXKGn9/6TCK9kvfFhqcpkUGFEelaEa4qcWAAAAqMRy8wy993OGNifbi7SZTNIlHQM1oFuQ/OhdPzPDkDZ/If3xqJR90P0xza7ybU2o9gjtAAAAQCW2bGuu28BeJ8KsW/uGqlld/spfImmJ0rx7paTf3bdHt5P6vy/F9PJtXaj2Kv1P8Icffqi5c+dq586dCgwMVKdOnfTYY4+padOm5V0aAAAAUOZ2HHAN7CZJ/doHaGD3YAX40bt+JiZHjkxLnpNWviY5bEUPsAZLPV+QOj8oWfx8XyCqvUof2pcvX66hQ4eqXbt2cjgceuONN3T77bdr9uzZCg4OLu/yAAAAgDKVkur6EvvV3YJ0Rdegcqqmktn9q1qvuFvmnGT37c2ulvq+I4U38m1dwCk8Cu2HDx/Wrl271KRJE0VHRxfs37t3r958801t27ZN9erV04gRI9SxY0dv1erWpEmTXLbHjh2rHj16aOPGjTrnnHPK9N4AAABAeXI6De1Lcw3tTRkOXzK/3iHLhkmyuGsLayj1fVdqfrWvqwKK8Ogn+n//+58+++wzzZkzpyC0Z2Zm6qabblJqaqoMw9D27du1YsUKzZw5U40bN/ZmzaeVkZEhSapRo8Zpj3M6nXI43EytCXjJieeL5wxljWcNvsKzBl/hWSu5A0cdRWaLrxvBf7uSMNWMk7nQPsNkkdH5IRndn5H8QyX+O8JLnE6nx+d6FNqXL1+u5s2bq0mTJgX7vv/+ex0+fFhXXnml7r//fi1cuFBjx47V5MmT9eKLL3pc4NlwOp0aPXq0OnfurJYtW5722O3bt/ukJiAhIaG8S0A1wbMGX+FZg6/wrJ3ZzrRgSXUKtoOsDu1MXF9+BVUmpgsUH9JCwVnbJEmZ4e21p+V/lRPaXNpEVkDF4VFoP3DgQJFh73/88YesVqv++9//KjIyUrfccotmzpypFStWeKPOEnnhhRe0bds2ffnll2c8tnnz5goNDfVBVaiuHA6HEhIS1K5dO1ksbgdeAV7BswZf4VmDr/CslVzSyhxJuQXbsXX8y/z11KrEWftj2WcOkC4Yp6B2t6mVqXDfO+AdmZmZHnccexTas7KyFBR0cnILh8OhNWvWqE2bNoqMjCzY37RpU/3+ezFLJnjZiy++qIULF+rzzz9X3bp1z3i82WzmDwH4hMVi4VmDT/CswVd41uArPGtntv+I65DbBlFW/pudYBhS4tfSkUSpx7Puj2nQS+t7/KT27Xvw3w1lymz2/AMhj0J77dq1tXPnzoLtVatWKTs7W926dXM5zm63y9/f3+PiSsIwDL300kv67bff9Nlnn6lhw4Zlej8AAACgokguNHN8TBST0EmSjmyX5o+Q9syVTGap6RVSnS5uD3VamGkfFZtHcb9jx45KTEzUlClTlJiYqLfeeksmk0l9+vRxOW7nzp2qXbu2VwotzgsvvKBZs2Zp/PjxCgkJ0aFDh3To0CHl5OSU6X0BAACA8pSbZ+jQMdee9pjIat5bbM+Vlrwkfdo2P7BLkuGUfrtHcjKpHConjz6Ku/vuu/Xbb79p3LhxkvJ7u7t3767OnTsXHJOcnKzt27fr2muv9U6lxfjqq68kScOGDXPZP2bMGF1zzTVlem8AAACgvOw/4pBxyrZJUv3qHNr3LpDm3Ssd2Vq07cBKacePUouBPi8LKC2PQnuLFi305ZdfaurUqTpy5IjatGmj22+/3eWYRYsWqVWrVurfv79XCi1OYmJimV4fAAAAqIhSCg2Nr1XDrAA/UzlVU46yDkh/PCZt/tx9e2h9qc87rLmOSsvjl17atGlT0NPuzg033KAbbrjB08sDAAAAOI3kVLvLdrUbGm84pfX/k/4aJeUeLdpuMkudHpB6vSj5h/m8PMBbmKkCAAAAqIRS0gpPQleNQvvBtdK8e6T9y9y31+0m9f9AqtPJp2UBZYHQDgAAAFRChWeOb1AdZo63ZUiLn5NWv53f015YQA3p/LFSuzslczX6EANVWol+suPj4z2+gclk0qZNmzw+HwAAAICr9GynMo4bLvuqxfD4xc9Lq9503xY/VOr9uhRS16clAWWtRKG9Xr16ZV0HAAAAgBIqPDTezyLVruHRas6VS7dR0sZPpZzUk/tqtpD6vS/F9iu/uoAyVKLQvmDBgrKuAwAAAEAJFZ45vl6kRWZzNZg5Pjha6v2a9OttkiVA6v5f6ZwnJGtgeVcGlJlq8OILAAAAULVU+Znjsw9JwbXct7W5WUrdLLW/M7+XHajiqsEYGgAAAKBqKTw8vkFVmTk++5D0yy3S5Jb566+7YzJLvV8lsKPaKHVPe2ZmppKSkpSVlSXDMNwec84555T2NgAAAAAkOQ1D+wov9xZZyQfQGk4pYbL01xNSzpH8fX88Kl3+efnWBVQAHv90b926VaNHj9by5cuLDesnbN682dPbAAAAADjF4XSnbK6j49UguhL3tB9KkObdK+3723X/5i+kNrcywRyqPY9C++7du3XTTTcpMzNTnTt31qFDh5ScnKzLL79cycnJ2rhxoxwOh/r27avw8HBv1wwAAABUW4XXZw8NNCk8qBJOQpeXJS15UVr1huS0F233D5OyixkiD1QjHoX2999/X1lZWRozZowGDRqkUaNGKTk5WePHj5ck7dmzR0899ZS2b9+ur7/+2qsFAwAAANVZ4ZnjY6IsMpkqWWjfPkta8H9Sxl737XHXSxe+IYXW921dQAXk0UR0S5cuVbNmzTRo0CC37bGxsZo4caKOHDmit99+u1QFAgAAADgpJc21V7pBZZo5Pn2vNHOg9MPV7gN7jabS4F+kK6cR2IF/eRTaU1NT1axZs4JtqzW/wz43N7dgX3h4uLp166aFCxeWrkIAAAAABdz1tFd4jjxp5XhpSmtpxw9F281+0rnPSDdvkBpf4vv6gArMo+HxERERstlsBds1atSQJKWkpKhp06Yux6amppaiPAAAAAAn2OyGDhxzuuyLiargM8cfWCP9eot0aL379oZ9pH4TpahWPi0LqCw86mlv0KCB9u3bV7AdHx8vwzA0Z86cgn1paWlavny56tWrV/oqAQAAAGj/EYcKL9xUv6IPjzdbpdRNRfcH1ZIu+0waMp/ADpyGRx/L9erVS++//75SUlIUExOjPn36qGbNmpo4caJ27NihOnXqaO7cucrIyNDQoUO9XTMAAABQLRUeGl8r3KxAvwo+CV2tdlLnh6WVr53c1/4u6bwxUlBk+dUFVBIehfarr75aNptNqampiomJUXBwsN544w099NBD+vnnnwuO69Wrl+69916vFQsAAABUZ5XyfXZJ6vmclDhdCoyQ+n8g1e9R3hUBlYZHob1Ro0Z69NFHXfb16NFDv//+u1auXKn09HQ1btxYbdu29UqRAAAAAKTkQjPHx1SUofF5x6V1E6WO90vWgKLtfiHSkHlSjSb5w+UBlJhXf2KCg4N1wQUXePOSAAAAAP5VIXvad/0szb9fOrZTsudI5z7l/riaLXxbF1BFeDQRHQAAAADfysxx6li26yx0DSLLsdc6I0X6cYj0/eX5gV2Slr0sHd1RfjUBVZBHP+UTJkwo8bEmk0kjRozw5DYAAAAA/lW4l91qkWpHlEMfnNMurX1PWvS0lJfp2mbPkX5/SBr0o+/rAqooj0O7yWSSUXi9iX+ZTPkzWBqGQWgHAAAAvCC5UGivV9Mii9nHM8fvXy7Nu0c6uMZ9e8z50vljfVsTUMV5FNrHjBnjdr/T6dT+/fu1ePFirV69WkOHDmUyOgAAAMALirzP7stJ6HKOSouekta9L8lNx11glNT7danNzZKpgi9BB1QyHoX2QYMGnbb9/vvv10cffaSJEyfquuuu86gwAAAAACcVnjm+gS8moTMMacs0aeHDUvYB98e0vU264FUpKKrs6wGqoTJ7CebOO+9UnTp19Oabb5bVLQAAAIBqwWkY2ufrmeOPbJO+vViac5P7wB7VRrr+T+mSSQR2oAyV6XSTLVu21JIlS8ryFgAAAECVl5ruVK5rR7saRJXhX+XTtkpT20kOW9E2a5DU4zmpy8OSxb/sagAgqYyXfEtKSpLdbj/zgQAAAACKlZLm2sseEmBSjeAyfHe8Zgsp9uKi+5teKd2ySer2JIEd8JEyCe3Hjh3T2LFjtXnzZrVv374sbgEAAABUG4Vnjo+JshSs2FQmTCap77v5veqSFNpAGvCdNHCWVKNx2d0XQBEejanp169fsW3Z2dk6evSoDMNQYGCgHn30UY+LAwAAAOBm5nhvvc9uOCWZ3M/4XqOx1OslKXO/1PN5yT/UO/cEcFY8Cu0pKSnFX9BqVb169XTOOefozjvvVPPmzT0uDgAAAICUUnjmeG8s93ZglfTbPVL3/0otilkdqisdcEB58yi0b9myxdt1AAAAAHAjz2HowFGny75S9bTnHpP+fkZa+15+T/uCB6TY/pJ/WCkrBVAWynQiOgAAAACls/+IQ07DdV9MpAd9b4YhJX4tfRIvrXn336HxkjKTpcXPl7pOAGWjTJd8AwAAAFA6hd9njwozK9D/LCehO7pDmj9C2v2r+/Y9cyV7rmQN8LBKAGWlRKF95syZpbrJwIEDS3U+AAAAUF0VDu0NzmZovD1XWvmatOwVyZ5TtN0aKJ37jNT1MZZwAyqoEoX2kSNHerSkhGEYMplMhHYAAADAQ4XXaI8p6SR0e3+X5t0rHUl03974Uqnfe1JE01JWCKAslSi0jxgxokho37t3r2bNmqWgoCD16tVLMTExkqR9+/Zp0aJFOn78uAYMGKBGjRp5v2oAAACgmkhOdZ05/oyT0GUflP54TNr0mfv20PpSn7elFoPdL/UGoEIpUWj/v//7P5ft3bt3a8iQIRowYID++9//KiIiwqX92LFjGj16tH7//XdNnz7da8UCAAAA1UlWjlNHs1xnoSs2tBtOKeFj6c8npdyjRdtNZqnT/0k9X5QCwr1fLIAy4dHs8W+88YbCw8M1ZsyYIoFdkmrUqKFXXnlFYWFheuONN0pbIwAAAFAtFR4abzFLdWoUE9qddmnVW+4De91zpKErpD5vEdiBSsaj0L5s2TJ17NhRFkvxQ3OsVqs6duyo5cuXe1wcAAAAUJ0VnoSuXk2LrJZihrRb/KX+E133+Yfnv7d+4xKpTucyqhJAWfIotOfm5urgwYNnPO7QoUOy2Wye3AIAAACo9pJTz3ISuoYXSq2H53/d6ibptkSp432S+SxmnAdQoXgU2uPi4rRq1SotXry42GOWLFmilStXKi4uzuPiAAAAgOqsyMzxURYpfY+UtrX4k3q/Lg2eK13xhRRSt4wrBFDWSjQRXWF33XWXRowYobvvvltXXnmlLr/8ctWvX19S/uzxP//8s3788UcZhqE777zTqwUDAAAA1YFhGEopNHN8g8MzpL/ulGp1kG5clD+5XGHBtaTGF/moSgBlzaPQ3q9fPz333HMaO3asZsyYoZkzZ7q0G4Yhf39/Pf300+rXr5836gQAAACqldQMp3LyXPfFbHhcMrKl/UukhMlS+zvKpzgAPuNRaJekG2+8Ub1799a3336rVatWFbzjXqtWLXXt2lXXXHONGjRo4LVCAQAAgOqk8ND4YOOoahr7Tu746wmp+dX5PesAqiyPQ7sk1a9fXw888IC3agEAAAAgSYah5E3LJbUu2BXj3KST88abpLgb8meMB1CleTQRHQAAAIAycnijNL23UrZvdtkdY/y7XaujdNPS/OXdAmr4vj4APlWqnnYAAAAAXpKXLS19SVr5uuS0KyVgjEtzjGmH1OctqeMIycxf44HqokQ/7a1atZLZbNbs2bPVpEkTxcfHl/gGJpNJmzZt8rhAAAAAoMrbOVuaf7+UvluSZJefDpiauxzS4PLnpGb1yqE4AOWpRKH9xHJuVmv+4fXq8csCAAAA8Ipf75A2THLZ9Y+phRwmP5d99RvU8WVVACqIEoX2BQsWnHYbAAAAgIfqnlMktCdb2rlsR4aaFRzAdFRAdcRPPgAAAFCe2t8p1Tv35HaDC5TS7lWXQ2KiLD4uCkBFUSahPS0tTXa7vSwuDQAAAFQtJrPU/30ppK506RTpuoVKya7pckiDSEI7UF15FNoTEhI0YcIEbd++3WX/b7/9pl69eqlXr17q3r27Pv30U68UCQAAAFRahiFt+lz644nij6ndUbpjt9TmZslkUkqaw6WZnnag+vIotH/++ef68MMPFRUVVbAvKSlJDz/8sFJTUxUdHa3jx49r7NixWrZsmdeKBQAAACqVtETpm37Sz8Okla9JyX8Vf6w1QJKUnetUWqbTpYnQDlRfHoX2tWvXqnXr1qpZ8+Swne+++052u11PPvmk/vrrL3399dcym82aOnWq14oFAAAAKoW849Lfz0pT20tJv5/cP+9eyWE77amFe9ktZqluBKEdqK48Cu2pqalFln1bvHixgoKCNHToUElS27Zt1aVLF23ZsqX0VQIAAACVxe5fpantpKUvFQ3oqRulHbNOe3pKqmtorxthkdVi8naVACoJj0K7w+GQw3Hyl0lWVpY2bdqkzp07y9/fv2B/7dq1dfjw4dJXCQAAAFR0mfukn26QvrtUOrqjaHtYI+nqH6SW1572MoVDO0PjgeqtROu0F1a/fn1t3LixYPuPP/6Q3W5Xz549XY7LzMxUWFhY6SoEAAAAKjKnQ1r3vrToKcmWXrTdZJG6PCL1fE7yCznj5ZILT0LHzPFAteZRaO/Tp48+/vhj3X///erevbs+/vhjmc1m9evXz+W4zZs3q379+l4pFAAAAKhwDqySfrs7/9/u1O8p9f9AqtWuRJczDIOedgAuPArtt912m37++WfNmzdP8+bNkyTdeuutaty4ccEx69at04EDB3TFFVd4pVAAAACgwsg9Ji16Wlr7niSjaHtgpHT+OKndbfnrsJfQkUynjttcr9eA0A5Uax6F9sjISM2aNUu//vqr0tLS1KZNG/Xo0cPlmEOHDmn48OEaMGCAVwoFAAAAKozl46S1E9y3tblFuuBVKbjWWV+28MzxQf4mRYZ6NA0VgCrCo9AuSSEhIbrmmmuKbe/fv7/69+/v6eUBAACAiqvbSGnjFClr/8l9kfFS//elhr09vmxy4aHxkRaZTMwcD1RnXvnYzmaz6eDBgzp69Kg3LgcAAABUbAHhUp+387+2BknnjZGGry1VYJeYOR5AUaUK7dOnT9fAgQPVsWNH9e7dW+PGjStomzt3ru6//37t2bOn1EUCAAAA5SJzX/FtLa+Ver4g3bJR6j5SsvgXf2wJFelpJ7QD1Z7H67SPGDFCzz//vHbs2KFmzZrJMFwnzGjVqpXmzZunOXPmeKVQAAAAwGeyDkhz/iNNbiml73V/jMkk9XhWqtHEK7e0Owz9c5Tl3gC48ii0f/7555o/f74uuOAC/f777/rxxx+LHNOoUSPFxsbqzz//LHWRAAAAgE8YTmndB9IncdLmL6S8LOn3B31y6wNHHXI4XfcR2gF4FNpnzJih6Ohovfnmm4qOji72uGbNmmnfvtMMKQIAAAAqioNrpa96SvPuzV/S7YTtM6Xts8r89smFZo6vGWJWSCAzxwPVnUezx+/atUu9evVScHDwaY8LCgpSWlqaR4UBAAAAPmHLkBY/J61+O7+nvbCAGvk97mWMSegAuONRaLdarcrNzT3jcfv371dISIgntwAAAADKlmFI277PH/6emeL+mPihUu/xUkidMi+H0A7AHY9Ce4sWLbRx40ZlZmYqNDTU7TGpqanavHmzOnbsWJr6AAAAAO87tkuaf7+0q5hJk2u2lPpNlGL7+ayklELD4xvwPjsAefhO+4ABA3T06FE999xzstlsRdodDodeeOEF5eTkaODAgaWtEQAAAPAOh01aNkaa0sZ9YLcE5C/jNny9TwP7cZuh1AzXofn0tAOQPOxpv/766/XLL79o9uzZWrNmjc477zxJUmJiol5++WUtXLhQycnJ6tWrlwYMGODVggEAAACPHFidv4xb2mb37bEX5feu12zu27okpaTaXbbNJqluTUI7AA972i0Wiz766CPdeOONOnjwoL7++mtJ0qZNm/T5559r//79uu666zRx4kSZTCavFgwAAAB4xD9MOraz6P6QutIV06TBv5ZLYJeKDo2vE2GRn4W/RwPwsKddkgICAvTcc8/p//7v/7Rs2TKlpKTI6XSqbt266t69u+rUKfvJOgAAAIASq9lC6jZKWvL8vztMUscR0nkv588QX44KT0LXgKHxAP7lUWgfNGiQGjZsqHfeeUeRkZG67LLLvF0XAAAA4H3dnpS2fCH5hUkXfSjV7VreFUkq2tMewyR0AP7l0fD4Xbt2yc/Pz9u1AAAAAKWTlyUtfUXKy3bfbg2Urv1NGrq8wgR2wzCUzHJvAIrhUU97bGysjh496uVSAAAAgFLYPkta8H9Sxt788H7+aPfHhcf6tq4zOJplKDvXcNlHaAdwgkc97ddee62WL1+uHTt2eLseAAAA4Oyk75VmDpR+uDo/sEvSytekwxvLtaySSklznTk+wE+KCvPor+kAqiCPfhsMGzZMgwYN0rBhwzRlyhTt2bPH7XrtAAAAQJlx5EkrXpc+iZd2/ODa5rRLvz9ULmWdrSKT0EVaZWYFJgD/8mh4fHx8vKT892/GjRuncePGFXusyWTSpk2bPKsOAAAAcCdlsTTvHulwgvv2hn2kvu/6tiYP8T47gNPxKLTXq1fP23UAAAAAZ3Y8TfprpJTwkfv2oFrShW9I8UOlStJbXWTmeEI7gFN4FNoXLFjg7ToAAACA4hmGtOkz6Y9HpeOH3R/T/m7p/DFSYE3f1lYKDqeh/UdY7g1A8TwK7QAAAIDPpG6W5t0rJf/hvr1We6n/B1L9Hr6tywsOHnXK7prZ1YCedgCnILQDAACg4jq6U5raQXLmFW3zC5F6vih1fkAyV86/1iYXmjk+IsSkkEBmjgdwUpX4jbBixQrdc889Ou+88xQXF6d58+aVd0kAAADwhoimUotriu5vcY10y2ap6yOVNrBLRWeOj4msvN8LgLJRJUJ7dna24uLi9Nxzz5V3KQAAAPC2C9+Q/MPzvw6PlQb+KA34TgpvWL51eQEzxwM4kyrxUV7v3r3Vu3fv8i4DAAAAnnLaJZPF/YzvofWlC8ZJ6Xukc5+R/IJ9X18ZKTJzPJPQASikSoR2TzidTjkcjjMfCHjoxPPFc4ayxrMGX+FZQ5n5Z7nM8++T0flhGfFD3T9rbe88+XUVeQZzbIYOpztd9tWraeJnzIf4vQZfcTqdZz6oGNU2tG/fvr28S0A1kZCQUN4loJrgWYOv8KzBWyx5Gaq/6z3V2vedTDJkX/CQNmY2lMMvfyh8VX/WDmQESKpfsG2SoYN7Nygt2Si/oqqpqv6soXKrtqG9efPmCg0NLe8yUIU5HA4lJCSoXbt2slgY6oayw7MGX+FZg9cYhkyJ02Ra/phM2QcKdvvlHVH79GmyX/hutXjW/tpsk3S8YLtOhEVdO3cov4KqIX6vwVcyMzM97jiutqHdbDbzgwmfsFgsPGvwCZ41+ArPGkolbas0/z5p73y3zeb9S2QxbJKq3rOWm2doX5pDSYftSkp1aONe12XsYqKsVer7rUyq2rOGisds9nwO+BKF9uHDh3t8A5PJpE8//dTj8wEAAFAF2HOk5WOl5WMkh61ouzVI6vG81OVhVfYFjgzD0LFsQ8mpdiUddvz7j10HjjllnGbkewNmjgfgRolC+/Lly93uN5lMMor5zXOizeRuBlAvy8rK0t69ewu2k5OTtXnzZtWoUUP169c/zZkAAAAoc7t/y+9dP1rM0NCmV0p935VqNM7frkSTghmGoX1H8oN58uGTvegZx8/+vfQW9artIFgAp1Gi3wzz5xcdvvTJJ5/oq6++0iWXXKIrrrhCMTExkqR9+/Zp9uzZ+vXXX3XDDTfo1ltv9W7FbmzYsMFlNMCYMWMkSYMGDdLYsWPL/P4AAABwI+sfaeEj0pav3LeHNsgP682vdr/UWwXmcBpavs2m2auO68BRz2eFliSTpN5tAtSyPqEdQFEl+s1wIpCfMGvWLH355ZeaOHGiLrzwQpe2Vq1aqW/fvhowYIDuvfdetWvXrsj53ta9e3clJiaW6T0AAABQQk6HtP5D6a9Rki29aLvJInV+SOr5vORfuSYGdjgNLduaH9YPHjv7sG6SVCfCrIbRVjWMtqhBlEWNallVI7hyvxIAoOx49HHelClT1KVLlyKB/VS9e/dWly5d9Omnn+rqq6/2tD4AAABUOoa0/iP3gb1eD+miD6Ra7X1fVik4nIaWbrVpzlmE9QCr1CDaqoZRlvyAHm1VTKRFAX6Va1QBgPLlUWjfuXOn+vXrd8bjateu7XZoPQAAAKowszU/mH/ZQ9K/73YH1pTOHye1u10yVZ5eZbvjZM/6ofTiw3pEiEmN/u09P9GLHh1ulrmSDfsHUPF4FNqDgoKUkJAgp9NZ7NT1TqdTCQkJCgoKKlWBAAAAqITqdZc63COte19qPUzq/boUXLu8qyoxu+Nkz/rpwnpsLYsGnBOkdrF+PpmAGUD141FoP++88/TTTz/pueee05NPPqnQUNd3kbKysjRu3DglJSXpyiuv9EqhAAAAqGCO7pDsx6Xotu7bzxstxV0nNbzQp2WVht1haEmiTXNWH9fh04T1xrXzw3rbRoR1AGXLo9D+6KOPasmSJfr222/1yy+/6Pzzzy9YWm3fvn3666+/lJmZqaioKD3yyCNeLRgAAADlzJ4rrXxdWvayFBkvDV2ePyS+sMCIChnYnU5DNoeUZzdksxvKs0t5DkO7Dto1Z1WOUjOKD+tN6lh0VVfCOgDf8Si0161bV9OmTdPzzz+vRYsWac6cOUWO6dWrl55//nnVq1ev1EUCAACggkhaKM27V0rbkr99cI20dqLU+YHyrErSyTXTNyfZtSUlT0cynfmh3KF/w3n+1w4PVmhrWseiq84JUpuGhHUAvuXxYpANGjTQxx9/rKSkJK1atUoHDx6UlD/5XJcuXdSwYUOvFQkAAIByln1Q+uMxadNnRdv+flpqMVgKK9tlft1Jz3ZqU3KeNiXlaXNyno5mGV69frM6Vl11TpBaN7QS1gGUC49D+wkNGzYkoAMAAFRVhlNK+Fj680kp92jRdpNZanOr5B/mk3Jy8wxt25+nzUl2bUrOU3Kqo0zu07xufliPb0BYB1C+Sh3aJWn37t06cuSIIiIi1KRJE29cEgAAAOXt4Dpp3j3S/qXu2+t0lS76UKrTuUzLcBqGlm+1aXFirrbtt8teBjndZMpfV71pXasu7RSkVjGEdQAVg8eh3WazacKECZo+fbrS09MlSQMHDtSYMWMkST/88IOmTJmi0aNHKz4+3jvVAgAAoOzZMqXFz0mr35YMNwnZP1w6f4zU/m7JbCnTUvYetuvLP7K144C9xOdEhpoV38CqZnX9FORvkp9V8rea5GeR/Kwm+VtO2ffvfotZhHQAFZJHoT0nJ0c333yz1q9fr6ioKPXu3VsLFy50Oebcc8/VyJEj9fPPPxPaAQAAKgPDkLbPlBY8IGUmuz+m1U3SheOlkLplWkqu3aTpfx/Xwo02GWd4TT3QT4qL8VPrhn5q3cBPdSLMBHAAVYZHof3jjz/WunXrdO211+qZZ55RQECAWrVq5XJMnTp11Lx5cy1evJhl3wAAACqDuXdIGya7b6vZQuo3UYrtX6YlGIahZVttmra+gY7n2dweYzZJTWpbFd/QqtYN/dSktlVWCyEdQNXkUWifM2eO6tevr+eff15Wa/GXaNKkiVavXu1xcQAAAPChhhcWDe0Wf6nbf6VuT0rWwDK9fUqaXV/+ma2t++xy99fU2jXMGtgtSG0a+Sk4wFymtQBAReFRaE9OTtaFF1542sAuSX5+fjp27JhHhQEAAMDH4v+TH9qTFuZvN+ov9XtPimxZprfNyTP004rjmrc+x+0a6n4W6fIuQbqkY6D8rPSoA6hePArtgYGBJQrjycnJqlGjhie3AAAAgK+ZTFK/96XvLpEuGCfFXZ+/r4wYhqHVO/M0fVG2jmS5SeuS2sf66YbzglWrRtlOeAcAFZVHob1Vq1basGGD0tLSFBkZ6faYpKQkbdq0Sb169SpVgQAAAPASw5A2TpH+WSn1f8/9MVGtpDt2SGavrAxcrLRMpz5fmKWEvXlu20P98zSsTw11bla2Q/IBoKLz6GWg6667TllZWXrkkUeUlpZWpD09PV3//e9/Zbfbdf3115e6SAAAAJTS4Y3S9N7Sr7dJ6yZKu38t/tgyDOyGYWjR5lw9P+2Y28BuMUuXdgrQ9e1T1KGxX5nVAQCVhUe/ka+88kr9/vvvmj17tvr3769OnTpJklavXq17771XK1asUGZmpgYOHKg+ffp4tWAAAACchbwsaclL0qrxkvOUtc7nj5CGJ0h+QT4rJS3DoakLs7UxyX3veusGVt14QYhqhUlr155hnTcAqCY8/hj19ddfV3x8vCZNmqS///5bkrRnzx7t2bNHYWFhevjhh3XXXXd5rVAAAACcpR0/SQvul9L3FG07uiN/Tfb4G8u8jBO961//na0cN3m9RrBJN5wXoi7N/GQymeRwOMq8JgCoLDwO7SaTSXfccYduvfVWbdy4USkpKTIMQ3Xq1FG7du3k7+/vzToBAABQUulJ0u8PSttnuG+v0SR/Vvgml5V5KakZDk39PUubku1u23vE+ev6XsEKCWQJNwBwp9QvLFksFrVv317t27f3Rj0AAADwlNMurX5HWvxs/rD4wsx+0jmPS92fkvyCy7QUwzD016ZcfbPYfe96RIhJ/+kdog6N6egBgNPxKLSPGjVKVqtVd9xxh2JjY4s97ptvvtHq1as1ZswYjwsEAABACexbKs27Rzq0zn17g95S//elqHiv3tbpNJSZYyj9uFMZx//9d7ahdbtt2pLivne9Zyt/XdeT3nUAKAmPQvuMGTNkMpk0d+5cvfXWW+rRo4fb41avXq2ZM2cS2gEAAMpKzhHpr1HS+v9JcjN5W1C01Hu81HpYqddctzsMzV2bo83JeUo/bijjuFOZxw13d3UrIsSk4ReGqF0svesAUFIef7zZsGFDHT9+XHfeeac+//xzb9YEAACAklrzrrT+Q7kN7O3ulG5NlNoML3VgdxqGPlmQpRnLjmtLil370hzKOIvAfl58gF64oQaBHQDOksehvUuXLvrss88UERGhV155Rc8++6zsdvdDoAAAAFBGuj4mhTd23RfdTrrhb+ni/0lBkV65zXdLjmv5NttZn1czxKwHrwzVzX1CFBzAcHgAOFul+s3ZoUMHffvtt4qPj9c333yjW2+9VUeOHPFWbQAAADgTv+D8meAlyS9E6v269J9VUkxPr91i3roczV2bc8bjQgNNqlfTorj6VnVt5q9rewTp+RvC1bYRvesA4KlSzx5ft25dffXVV3ryySf1yy+/aMiQIZo4caJatmzpjfoAAAAgScd25S/V5k7Ty6ULXpPirpPCG3n1tiu25Wr639ku+yxmaUjPYNWraVF4kElhwWaFBppkMZduCD4AoCivjFEKCAjQW2+9pf/7v/9TSkqKbrzxRs2bN88blwYAAKjeMvdJP14vfRIvHdlW/HHnPOb1wJ6YkqfJ84suHXdznxD1ax+o1g391CDaqhrBZgI7AJQRr75YNGLECL3zzjtyOp164IEHtGjRIm9eHgAAoPpwOqTV70qftJK2fi05cqX5IySjpFO/lU5yql3v/Zwpu9N1/zXnBqlHXIBPagAAeDm0S9JFF12kr776SnXr1tWhQ4e8fXkAAICq75+V0pfdpd8fkGwZJ/fv+U1KnF7mt0/NcOjtnzJ03Ob6AUGftgG6tFNgmd8fAHCSR++0T506VdHR0cW2t2rVSt9++62mTZsmp9NZ7HEAAAA4Re4xadHT0tr35HYJt0DvzAR/Olk5Tr39U6aOZrnev3NTP91wXrBMpVw6DgBwdjwK7d26dTvjMZGRkbrvvvs8uTwAAED1Yhj5PegLH5ay/nF/TJtbpQtelYKL7zgprTy7ofd+ztT+Iw6X/c3rWXV7/1CZeW8dAHyu1LPHAwAAoBSObMt/V33Pb+7bo1pL/d+XGlxQpmUczXLqyz+ztG2/3WV/vZpm3X9ZqPytBHYAKA8lCu2jRo2SyWTSI488oujoaI0aNarENzCZTBo9erTHBQIAAFRJ9lxpxThp2ej8SeYKswZJ5z4rdX1EspTNOudZOU6t2mnT8q02bd1nLzIgPyLEpAevDFNIoNenQQIAlFCJQvuMGTNkMpl05513Kjo6WjNmzCjxDQjtAAAAhRxYLc2+UTqy1X17k8ulfhOKX5e9FHLyDK3bZdPybTZtTMqTo5jph4L8TXrwijBFhVm8XgMAoORKFNqnTp0qSapfv77LNgAAADwQFC1lphTdHxoj9XlbanGNdBYTvh3Ncmr9HpuSDzsKQnhBr7lx8uvsXKc27M2Tze7mIqewWqR7Lw1Vg2jepASA8lai38SFJ54ryUR0AAAAKEZ4I6nnC9Ifj+VvmyxS5welns9L/mFnPN0wDKWkObRuV57W7bZp10HHGc8piUA/qVNTf13aKUj1I+lhB4CKgI9PAQAAykOnB6SNn0p+wVL/D6TaHU97uN1haNt+u9btsmnt7jylZnhnWV2rRWof66duLQLULtaPCecAoIIhtAMAAJQFW4a0fJx0zhNSQHjRdoufNPhXKaSOZCp+orf0bKf+3JSrhRtydCzbzdrtHjCbpPgGfurWwl8dm/gpOICJ5gCgoipRaO/Xr5/HNzCZTJo3b57H5wMAAFQqhiFt+076/UEpc19+eO/7tvtjQ+sVe5k9h+yavz5HK7bZZC9Bp3qgn9S6oZ9qhOQHcNO//xRsKP81+boRFnVq4q/wYII6AFQGJQrtKSluJko5A5PJJMPwzqfBAAAAlcLRndKC+6VdP5/ct3aC1OZmqU7nM57ucBpauytP89bnaPv+M8wWJyky1KwOTfzUsbG/Wta3ymphaDsAVDUlCu1btmwpsu/ll1/W999/r6FDh+qKK65QgwYNJOUH/NmzZ+uLL77QoEGD9PTTT3u3YgAAgIrGYZNWjpeWvijZc1zbDKf0+0PSDX+e9hKLt+Tqh+XHlZZ5+m71RrXye8o7NPZTgyiLTGcxyzwAoPLx6J32qVOnatq0afrqq6/Url07l7a4uDjFxcXpoosu0o033qgGDRrolltu8UatAAAAFU/SH9K8e6W0ze7bYy+W+r1X7OkOp6Fpi7K1cENuscdYzVK3lv7q1y5QjWoxJREAVCce/dafPn26unfvXiSwn6pdu3bq3r27vvnmG0I7AACoerIPSX8+nj8DvDshdaUL35Lirit2zfWsHKc+nJupzcnuh8LXCDbpwraBuqB1AO+gA0A15VFoT0pKUlxc3BmPq1GjhlauXOnJLQAAAComwyklTJb+ekLKOeLmAJPUcYR03stSQI1iL3PgqEPvzsnQgaNFh8M3qWNRv/aB6tLUn/fUAaCa8yi016hRQytWrFBubq4CAgLcHpObm6sVK1YoPNzNEicAAACV0aEEad490r7F7tvrdMlfc71u19NeZnNynj74NVPZua6T9lot0s19QnRuS/d/vwIAVD8ejbO66KKLdOjQIT3wwANKTk4u0p6cnKwHH3xQhw8f1kUXXVTqIgEAAMpdepL0eRf3gd0/TOr7rnTTsjMG9oUbcvTWjxlFAnt4kEmPDwwnsAMAXHjU0/7ggw9q6dKl+uOPP7Ro0SK1bdtW9evXlyTt27dPGzdulN1uV9OmTfXggw96tWAAAIByEd5Qaj1M2jDZdX/c9dKFb0ih9U97usNp6Ou/s7UgoeiEcw2jLbr/slBFhlm8WTEAoArweHj8tGnTNH78eP3www9at26d1q1bV9AeGBioa665Ro8++qhq1Cj+XS4AAIAKzTBcJ5E7f5y0/QcpJ1WKaCb1myg1vrhEl5q14rjbwN6piZ9u7x+qAD/eXQcAFOXxmiHh4eF64YUXNHLkSG3cuFEHDx6UJNWqVUtt2rRRcHCw14oEAADwGUeeZLZIJnPRWd+Do6U+b0pHtkvdRkp+QSW6ZI7N0Lx1OUX2X945UFd3D5KZtdYBAMXwKLQPGjRIDRs21DvvvKOgoCB17Xr6d7cAAAAqhZTF+RPNdbxP6nCP+2NaDzvry67cYZPtlFXdzCbp1r4hOjeO99cBAKfn0UR0u3btkp+fn7drAQAAKB/H06S5d0rTekmHE6S/RkpZB7x2+b+3uA6LbxfrR2AHAJSIR6E9NjZWR48e9XIpAAAAPmYY0sZPpU/ipISPT+7PPSb98ahXbnHwmEPb99td9vVsRWAHAJSMR6H92muv1fLly7Vjxw5v1wMAAOAbqZulr/tIv9wiHT9ctP3wBikvq9S3KdzLHhpoUvtYRiwCAErGo9A+bNgwDRo0SMOGDdOUKVO0Z88e2Ww2b9cGAADgfXnZ0qKnpKkdpOQ/irb7heQv4faflflfl4LTaWjJFte/I3Vv6S+rhYnnAAAl49FEdPHx8ZIkwzA0btw4jRs3rthjTSaTNm3a5Fl1AAAA3rRzjrTgfunYLvftLa6RLnwrf012L9iSYteRLKfLvl4MjQcAnAWPQnu9evW8XQcAAEDZyUiRFj4kbf3WfXt4rNR3gtTsSq/etvDQ+IbRFjWM9njFXQBANeTRnxoLFizwdh0AAADe53RIaydIi56W8jKLtputUtfHpHOfkfyCvXrr7Fyn1ux0HRrfkxnjAQBniY96AQBA1WUySYlfuw/sMedL/d+XotuUya1Xbrcpz3Fy22LOf58dAICz4dFEdAAAAJWCySz1/0AyWU7uC4ySLvlEuv6PMgvsUtGh8e1j/RQWxF+9AABnp9Q97du2bdOePXuUmenmE+x/DRw4sLS3AQAA8EytdlKXR6SVr0ltb5cuGCcFRZXpLfcfcWjnAYfLvl7xDI0HAJw9j0P74sWL9cILL2jv3r3FHmMYhkwmE6EdAACUrbStUl6GVKeL+/aez0nNr5ZievmknMWFetnDgkxq05C12QEAZ8+j0J6QkKC77rpLJpNJV155pbZu3aqtW7fqrrvu0t69e7V48WKlp6frmmuuUf369b1dMwAAQD57jrRsjLRirFSjqTR8nWRx8964X4jPArvTaWjpVtfQ3qNlAGuzAwA84lFo/9///ieHw6GPP/5YvXr10qhRo7R161Y9/PDDkqT09HQ9++yzWrhwob777juvFgwAACBJ2j1Xmj9COro9fztti7Tydan7f8u1rI1JeTqaZbjs69mKCegAAJ7xaDaUNWvWKD4+Xr16uf/EOjw8XK+++qrMZrPeeuut0tQHAADgKnO/9NON0neXnAzsJyx9STq6s3zq+tffW1yXeYutZVFMFAv2AAA841FoP3r0qBo3blyw7eeX/45WdnZ2wT5/f3916dJFf//9d+kqBAAAkPLXXF/znvRJKylxWtF2k0XqMEIKru372v6VlePUul2uob1XKyagAwB4zqOPfSMjI11mi69Zs6YkKSkpSXFxcQX7c3NzTzurPAAAQIkcWCX9do90YKX79no9pIs+kGq1921dhSzfZpPdeXLbapa6tWBoPADAcx6F9tjYWCUnJxdst2/fXoZhaPr06Xr22WclSXv27NHSpUvVsGFD71QKAACqn9xj0t/PSGvfkwxn0fbAmtL546R2t+evye4ldoehg8ecsjsMGZIM499//v3a4TR0LNupI5lOpWXm/zs1w6l/jrgu89ahib9CAlmbHQDgOY9C+wUXXKA33nhDO3bsULNmzXT++eerfv36+uqrr5SQkKC6detq6dKlys3N1eDBg71dMwAAqOoMQ9r6jfT7Q1LWfvfHtB4u9X6t1MPhDcNQaoZTuw7YtfOAXbsOOLTnsF12x5nPPZNeTEAHACglj0L7wIEDFRYWJqcz/xNvf39/vf/++3rooYeUkJCghIQEmc1mDRkyRDfffLNXCwYAANXA3DukDZPdt0W2kvq/LzW88IyXycpxatk2m1IznHI4DNmd+b3oDqeU55By8wztOWRXxnHjjNc6WxEhJrVmbXYAQCl5FNpr1aqlG264wWVfXFycfv75Z+3YsUPp6emKjY1VZGSkV4oEAADVTNMrioZ2a6B07jNS18fcr8VeSJ7d0PhZGUo67IUu87MUFmTSrX1DZTGzNjsAoHS8vv5Is2bNvH1JAABQ3TQflB/cd87O3258qdTvPSmiaYkv8cuanFIHdotZMpkkk07+WybJbDIpNNCkyFCzaoaaFRlmVmToyX9qR1jkZyGwAwBKj0VDAQBAxWMySX3fldISpfPHSC0G5+8roYPHHJqz+vhZ3TIkwKSmdaxqUseqJnUsalLbyiRyAIByV6LQPmrUKI9vYDKZNHr0aI/PBwAAVZDhlBI+llIWSZd+6j6Q12gi3bpFMlvO7tKGoa/+ynaZSM5sknrE+cvfapLFIlnNJln//XdUuFlN61hVK9ws01l8MAAAgC+UKLTPmDHD7f4Tf7AZhlHsfkI7AABwcWh9/prr+5fkbzcfJLUY5P7YswzskrRmZ5427M1z2de3fYCu7xVy1tcCAKC8lSi0T506tci+X375RV9++aU6dOigK664QjExMZKkffv2afbs2Vq7dq2GDh2qSy65xLsVAwCAysmWKS1+Xlr9lmSc0g2+4AEptr/kH1bqW+TkGZq2KNtlX0SISQPOCS71tQEAKA8lCu3dunVz2f7rr780bdo0Pffcc7rxxhuLHD9s2DBNmzZNL774onr37u2dSgEAQOVkGNL2mfnhPDO5aHtmcn5762GlvtVPK47rSJbTZd91vYIV5M+wdwBA5eTR7CoffPCBWrdu7Tawn3DDDTeoTZs2ev/99z0uDgAAVHLHdkszB0izrnEf2COaS4PneiWwp6TaNW99jsu++AZWdW125uXhAACoqDwK7Zs3b1ZsbOwZj2vUqJESExM9uQUAAKjMHDZp+ThpSmtp509F2y3+Uo/npZsTpMYXlfp2hmHoiz+z5Tilk91qlm66IITJ5QAAlZpHS75ZrVZt27btjMdt27ZNViurygEAUK0k/yXNu0dK3eS+vVH//DXXI1t67ZZLEm3att/usu+SToGqG3H2E9kBAFCReNTT3rVrV23btk0TJkwoMnP8Ce+99562bt2qrl27lqpAAABQSWQfln65TZp+gfvAHlxHuvwL6dq5Xg3sWTlOfbvEdfK56HCzLu8S5LV7AABQXjzqBn/kkUe0dOlSvffee5o1a5YuueQS1a9fX1L+7PFz587V3r17FRwcrIcfftirBQMAgApqwyRp4yduGkxSh3ul816RAiO8esucPEMfz8tSxnHXToQbzguWv5Vh8QCAys+j0N68eXN9+umnGjlypHbs2KGPPvqoyJrtTZs21dixY9WiRQvvVQsAACquzg9JGz6Rjpwyn03tTlL/D6R63Yo9zVNpmU5NmJOhpMMOl/0dm/ipQ2MmnwMAVA0ev3Derl07zZ49W8uWLdPKlSt18OBBSVKtWrXUtWtXde/enYlfAACoTqwBUv/3pW/65q+53uslqeMIyez9+W32HLJrwpwMHc1y7WEP9MvvZQcAoKoo9Z+i3bt3V/fu3b1RS6l88cUXmjRpkg4dOqRWrVrpmWeeUfv27cu7LAAAqp60RKlWa/dtjfrkTzLX7GopLKZMbr92l00f/ZYpm+u8cwoJMOm+y0IVFcbkcwCAqsOjiegqmjlz5mjMmDEaMWKEZsyYoVatWun2229XampqeZcGAEDVkZGsphsel/nzDtKhhOKP63hfmQR2wzD027ocTfy5aGCvXcOsUYPD1bK+n9fvCwBAeSpVT3tSUpJWrVqlgwcPymazuT3GZDJpxIgRpbnNGX3yySe67rrrNHjwYEnSCy+8oIULF+q7777TXXfdVab3BgCgynPapTXvyvz3s6qZl5m/b9690g1/SibffP7/zxGH5qw+riWJRf++0bK+VfdeGqrQwCrRFwEAgAuPQrvNZtPTTz+tH3/8UZKKXfZNKvvQbrPZtHHjRt19990F+8xms3r27Kk1a9YUe57T6ZTD4Si2HSitE88XzxnKGs8aytT+pTLPHyHT4XVymalm399yrp8ko+1tZXZrh8PQuj12/bExV4n73D/f57b009ALguRnMfgZqEL4vQZf4VmDrzidTo/P9Si0v/POO5o1a5bCw8M1YMAANW7cWCEhIR4XURpHjhyRw+FQVFSUy/6oqCjt3Lmz2PO2b99e1qUBkqSEhNMMIQW8iGcN3mTJS1fMzgmK3j9DJhX9cD7PL0JJ+1J1xL7WK/czDMlhmORwmpRjN2vr4VBtPhim7Lzi/6pyToM0dYg4po08+lUWv9fgKzxrqMg8Cu0//fSTwsPDNWPGDMXElM0kM2WtefPmCg0NLe8yUIU5HA4lJCSoXbt2sliYFAllh2cNXmUYMm35UqZlj8l0/JDbQxxtbpP5/LGKDYxU7GkulecwtCXZroPpTmUeN5SZYygzx6mMf7/OzjWU5zCU55DsZ9HJ5WeRbr4wSF2bNzm77w2VBr/X4Cs8a/CVzMxMjzuOPQrtqampOu+88ypEYK9Zs6YsFkuRSedSU1MVHR1d7Hlms5kfTPiExWLhWYNP8Kyh1FK3SPPvk5J+d9tsRLdTYsOH1KL3zWd81tbttmn6omwdSvd8OGBhoYEm9WoVoD7tApghvprg9xp8hWcNZc1s9nzeFY9Ce/369T2+obf5+/urTZs2WrJkifr37y8p/32BJUuW6D//+U85VwcAQCWQd1xaPlpaPk5y5hVt9wuRer4gZ/sRykrYeNpLHTzm0LRF2UrY4+Y6HmpW16oL2wSoSzN/+VlNZz4BAIAqxKPQPnjwYH344YdKS0tTZGSkt2s6a7feequefPJJtW3bVu3bt9enn36q48eP65prrinv0gAAqNgOrJZ+HCIdK2YemOYDpT5vS+GNpNNM1JSbZ+iXNcf1y5qcsxrqXpwgf5POae6vC9sGqGF0qRa7AQCgUvPoT8E77rhDmzdv1vDhw/X000+re/fuMpnK75Pvyy+/XGlpaXrnnXd06NAhxcfH6+OPPz7t8HgAACApNEbKSS26P6yR1G+C1Owqt6fZ7IZSM5w6nO7QgaNOzVufo9QM90PhYyItqhNhVliQWWFBJoUGmhUaZFJogFn+fpKfxSQ/i+RnNcn679chASaZzfSqAwDgUWi/6KKLJEn79u3TrbfeKqvVqlq1arkN7iaTSfPmzStdlSXwn//8h+HwAACcrZA60nlj8t9llySzVeryqNTjmfxh8cpf2nVLil1LE3O0I6WevkxIV3p28cu9nhAeZNK1PYN1bkv/cv1wHwCAysyj0J6SkuKynZeXp3379nmlIAAA4GPt75I2TpHMflL/96Va7STlD3lfkpir3zfkal/aiTHvgZKbJeBOZTZJfdsH6KquQQoO8HziHQAA4GFo37Jli7frAAAAZSX3mLT0ZanbSCkoqmi72SIN+im/zWTWoWMO/b4hV39vyVV27pl71E8VV9+qGy8IVkwk76EDAOAN/IkKAEBVZRhS4nRp4cNS1j9SzhHpko9dDrHZDaWkOpR0OExJh49r72G7dh1wnKEv/aTQQJOiw82qFW5R1+b+6tTEj6HwAAB4EaEdAICq6Mg2af4Iac9vBbuOb/hae+vcpz2K155DDiUdduifow4ZJUzodSPMig07rC5tGqh2Dauiwi0K9COgAwBQlkod2jMzM5WUlKSsrCwZxfypf84555T2NgAAoBh5DkNZOYZybIZycnKVm/CVcjbPVI4RrmPW+7TH1EF7zB11wNxcWixJx0t8bZOkdrF+6tc+UC3rmbRu3Q61j20ii8VSVt8OAAA4hcehfevWrRo9erSWL19ebFg/YfPmzZ7eBgAAuHHomEPrdudp3W6btu23y+Gy2togyW9Qqa4f5G9Sr3h/9WkbqNo18gO64zTrtAMAgLLhUWjfvXu3brrpJmVmZqpz5846dOiQkpOTdfnllys5OVkbN26Uw+FQ3759FR4e7u2aAQCodpxOQ7sO2rVuV57W7ck7ZTb30jNJqhNhVsNoqxpGW9Qw2qIW9fwUwNB3AADKnUeh/f3331dWVpbGjBmjQYMGadSoUUpOTtb48eMlSXv27NFTTz2l7du36+uvv/ZqwQAAVFU2u6FNSXk6lO7UkcxT/sly6miWU86zm8jdLYtZiom0KLaWVY1qWdQw2qoGURYCOgAAFZRHoX3p0qVq1qyZBg1yP/QuNjZWEydOVP/+/fX222/r2WefLVWRAABUdRv22vTJ/CylHy9dMrcauQpUpgIseQoMi1RQULDq1bSoUS2LGte2KibKIj8LAR0AgMrCo9Cempqqjh07nryINf8yubm5CggIkCSFh4erW7duWrhwIaEdAIBi2B2GZiw9rrnrcs763DDjkNo75qqD4xc1dy5TkNJlDQiRzh8rtb9TMpnLoGIAAOBLHoX2iIgI2Wy2gu0aNWpIklJSUtS0aVOXY1NTU0tRHgAAVdeBow599Fum9hwq+fvp9SMt6hDrpw5pE9RkyyiZdcoMdK2HSRe8JoXUKYNqAQBAefAotDdo0ED79u0r2I6Pj5dhGJozZ47uv/9+SVJaWpqWL1+uevXqeadSAACqCMMwtDjRpq/+zFKuvWh7o2iL6tW0qGaoOf+fkPx/R4WZFRb0b+957t1S0ltS1n6pZpzUf6LUqK9Pvw8AAFD2PArtvXr10vvvv6+UlBTFxMSoT58+qlmzpiZOnKgdO3aoTp06mjt3rjIyMjR06FBv1wwAQKViGIYyjhtKy3QqLdOpldttWrHdVuQ4q1m6tmew+rYLkMlkkhy2/CHuZjd/XAfUkPpNkFI3SV0fl6wBPvhOAACAr3kU2q+++mrZbDalpqYqJiZGwcHBeuONN/TQQw/p559/LjiuV69euvfee71WLAAAlcHBYw79viFHSYcdSsvIn/3dfoYR8HUjzLrr4lA1jP73j+akP6R590rtbpe6Pur+pBbX5P8DAACqLI9Ce6NGjfToo65/gejRo4d+//13rVy5Uunp6WrcuLHatm3rlSIBAKgMDh5z6KeVx7Vsq+2slme7oHWArusVnL/sWvYh6c/HpY2f5jcufk5qOUQKb1Q2RQMAgArNo9BenODgYF1wwQXevCQAABWep2E9OMCk4ReGqEszf8lwSusnSX89IeUcOXlQXpb0+4PS1TO8XzgAAKjwPArt/fr106WXXqrHH3/8tMeNHz9eP//8s+bNm+dRcQAAVGQHjzk0e9VxLU0sWVg3m6SIELMiQ81qXNui/h0CFRVmkQ6tl367R9q/xP2JGUlSbroUEO7dbwAAAFR4HoX2lJQUpaWlnfG4I0eOKCUlxZNbAABQoa3dZdOHv2bK7nTf7m+VLmgToKa1rYoMM6tmqEURwSaZzaaTB9kypT9ekFa9KRluXnr3D5fOHyO1v1syW8rmGwEAABWaV4fHF3b8+HFZrWV6CwAAfC4926nJ87PcBnZ/q9SnXaAu6Rh4cnk2d7b/IC34v/xedHda3Sj1Hi+FsnQqAADVWZkkaqfTqV27dmnZsmWqX79+WdwCAIBy883ibB23uY6HL3FYT98jLXhA2jHLfXtEc6nfe1Lji71YMQAAqKxKHNrj4+NdtmfOnKmZM2ee9hzDMHTdddd5VBgAABXR1n15WrrVdY319rF+uqVvyOnDutMhrXpDWvy8ZM8u2m7xl7qNkrqNlKyB3i0aAABUWiUO7fXqnRyet3//fgUGBqpmzZpuj/Xz81Pt2rXVr18/DRs2rPRVAgBQAdgdhr740zVwB/mbNLzPGQK7JJnM0p7f3Af2Rv2kfhOlyJZerBYAAFQFJQ7tCxYsKPi6VatWuvTSSzVmzJgyKQoAgIpoQUKO9qW5Thh3dbcg1Qg+Q2CXJJMpf9j7p+0kR27+vuDa0oVvSK1uym8HAAAoxKN32qdOnaro6Ghv1wIAQIV1JNOpWSuOu+xrGG3RhW0DSn6Rmi3yh8AveUHqcLd03mgp0P2oNQAAAMnD0N6tWze3+3Nzc5Wenq6aNWsyazwAoEr5ZnG2cvNc9w29IFgWc6Ee8tRNUs4RKaaX+wt1Gyk1vUKq27VsCgUAAFVKCcbzSZmZmVq/fr127drltn337t26/fbb1aVLF11wwQXq3LmzHn74YR08eNCrxQIAUB42J+dpxXbXyed6tfJXs7p+J3fkZUt//Vea2kGa85/87cIMQ7IGENgBAECJlSi0//DDD7r++uu1cOHCIm2HDh3S0KFDtXjxYtntdhmGIZvNpl9++UXDhw9XTk6Ot2sGAMBn8hyGvvwzy2VfcIBJg3sEn9yxc440pY20fIzktEvpu6WlLxe9GO+tAwCAs1Si0L58+XKZzWYNGDCgSNvEiROVmpqq8PBwTZw4UatXr9aMGTPUtm1b7dmzR1999ZXXiwYAwFd+W5ujf446XfZdc25Q/mzxGcnSrGulGVfkB/VTrXw9f6g8AABAKZQotCcmJqply5aKiopy2e90OjV79myZTCY98sgj6tu3r4KDgxUfH68JEybIYrFo3rx5ZVI4AABlyek0tHVfnmavcp18rnFti86Ps0ir3pI+iZe2fVf0ZLNV6vqYFN7YJ7UCAICqq0SzxaWlpem8884rsj8xMVHp6emyWq264oorXNrq1KmjDh06aMeOHd6pFACAMpaW4dDGJLs2JuVpc3KesnMNl3aTpKGtd8n85a3SobXuLxJzvtT/fSm6TZnXCwAAqr4Shfbs7GzZ7fYi+zds2CBJiouLU2hoaJH2unXrat26daUsEQCA0sk47tTGvXnKzDFkdxqyO/LfVT/xb1ueoZ0H7Np/xHna6/SusUyNf75CklG0MTBK6v261OZm3l0HAABeU6LQHhkZqZ07dxbZv3r1aplMJrVv397tebm5uQoLCytdhQAAlEJahkNjvk/X0Sw3QfssROgfDfznRrkN7G1vly4YJwVFFW0DAAAohRK9035imPuCBQsK9qWlpWnu3LmSpF693K9Fu337dtWuXdsLZQIA4JlvFh8vVWCv53dAF+W9p5E5FytEx1wbo9tKNyySLvmYwA4AAMpEiXrahw4dqt9++00PPvigLrvsMkVGRmru3LnKyspS/fr1deGFFxY5JykpSbt379bVV1/t7ZoBACiR7fvztHKH7cwHniI4wKTWDfzUuqGf2jS0KjJ1hfTds64HWYOlns9LnR+SLH7uLgMAAOAVJQrt5557ru6//3699957mjVrlkwmkwzDUGBgoEaPHi2rtehlTiz15m4COwAAyprTMDRtUbbLvkA/qXk9P1ktkp/F5PLvGsFmxTfwU2wti8zmU95JD7tEirteSpyev930Kqnfu1J4rA+/GwAAUF2VKLRL0v33368+ffpo7ty5OnLkiOrWraurrrpKDRs2dHu8v7+/hg8frvPPP99rxQIAUFLLttq055DDZd/A7sHq1z7w7C924RvS4Q3Sea9IzRlBBgAAfKfEoV2S2rRpozZtSraEzUMPPeRJPQAAlFpunqHvl7r2steNMKt3m4CiBzsd0roPpL3zpAHfu5/5PbS+dHMCs8IDAACfO6vQDgBAZfDrmqKTzw3pGSyrpVDoPrBK+u0e6cDK/O3NX0it/+P+ogR2AABQDko0ezwAAJVFWqZTv67NcdnXuoFV7WJPmTAu95i04AHpi24nA7skLXxEyjnio0oBAADOjNAOAKhSZizNls1+cttkkq7rFSyTySQZhpT4tfRJvLTmXclwup58/JC0Y5ZvCwYAADgNhscDAKqMXQfsWrrVdYm3C1oHKCbKKh3dIc0fIe3+1f3Jka2k/u9LDS8s+0IBAABKiNAOAKgSDMPQ9L9dJ58L8jfp6s4WaenL+f84coueaA2Uzn1G6vqYZPH3UbUAAAAlQ2gHAFQJK7fbtOMfu8u+K5olK+ybIdKRRPcnNblM6jtBimjqgwoBAADOHqEdAFDp2eyGvlt63GVfLesh9V3dVZKt6Amh9aU+70gtrmFWeAAAUKER2gEAlUZunqFDxxz656hTB446dOCYQ/8cdejAUaeyc12XeLs261H5FQ7sJrPU6QGp5wtSQLgPKwcAAPAMoR0AUOGlZzv18bxMbU62n/lgSS3rWdQpPUU6fMrOuudI/T+U6nQqmyIBAADKAEu+AQAqNMMwNHl+VokDu0nS9eeFyHTxB/lbATWkfhOlG5cQ2AEAQKVDTzsAoEJbucOmjUl5JTo2OMCkwecGqVEtq6Tu0iWTpSaXSiF1y7ZIAACAMkJoBwBUWNm5Tk1flF1kf81gp+raN6tO9jLV6XSV6jRqoroRFkWFmWU2nzKxXNtbfFcsAABAGSC0AwAqrJnLjutYtusEc/c0/U1dEm+V7P/OFr/7S6nXcslsKYcKAQAAyhbvtAMAKqRdB+xauCHXZV878xJ13njDycAuSQfXSGvf83F1AAAAvkFoBwBUOA6noc//yNKpfez+RrZuyr5XRVZVD64jhcb4sDoAAADfYXg8AKDC+T0hV3sPO1z2XWl/TdFG0il7TFLH+6ReL0uBET6tDwAAwFcI7QCACiUt06mZyzJ16mCw+s7Nusg+8eRBtTtJF32Yv/Y6AABAFUZoBwBUHHlZmj5zvXLtcS67h+U9Iqvskn9Yfs96x/skM3+EAQCAqo+/8QAAKoYDa7Ru5hta7XjbZff59qlq7lwutRwiXfimFMb76wAAoPogtAMAKoTcoFh96XjCZV+ocViDg6ZIV82RmlxWPoUBAACUI0I7AKBC+HFDoNLk2os+pNEKhVy6RPILKqeqAOD/27vz+Kiq+//j71mSCSEQkshO2JmAEGQL+w4KuH0Fi3UptIpFxIr12/IDXLBCW/gWXIoCWmpFBa2KqBWpLYsssgSQLUhYwxaBJJCwZJskM/f3RyQwZAIhJDOTyev5eOTBzDn33vkkcxl455x7DwD4FqEdAOBzh07la8WuXLe2mDp56nH3w5Kp2CJvAAAAVQbrtAMAvCcnXVo9Qco8VdS07odcvfLlRbmuWJTdapZ+Mai2TAR2AABQxTHSDgCoeIYhJS6S1vxOykmTstOUP+xDfbQuW+sTHcU2H9opRPUiLD4oFAAAwL8Q2gEAFetsorRqvHRiTVFT+oF1euv8CR05H1Zs81ujrbqzM9ewAwAASIR2AEBFyc+R4v8kbf2L5Movat5v7qW3g9/RRQ+B/Y4OIRrRvZosZqbFAwAASIR2AEBFOPKNtOop6XxSUZMhaYX1SX1m/YNcJvd/fmxW6ZcDqyuupc3LhQIAAPg3QjsAoPxknpS+/a104FO3ZodC9V7Q69pqvb/YLnXCzRo/NEwNo/gnCQAA4Gr8DwkAcPNcTmnnXGnDC1LeRbeu06aWmh/8nk6aWxfbrX2TII0ZXF2hNhYzAQAA8ITQDgC4Oae3SivGSanbi3V9b75HC23zlKvQYn33xFXT3V1CZGZZNwAAgBIR2gEAZZedKv2zj+R0X7atQFYtDfmzVpjGFNulWrBJYwZX121Ng71VJQAAQKXFfEQAQNmF1pE6P+vWdE719ErEJo+BvVGURS+MrElgBwAAKCVCOwDg5nR/UarZVJK0v9bDmha+S4dymxfbrEdMsCaPqKk64RYvFwgAAFB5MT0eAHB9BbmSTJLVw5JsQaEyBs3TNwnS5ye7yTDcu60W6aE+oerTxiYT168DAADcEEI7AFRxBU5D+U4pv8BQXoGh/AIpz2n89FzKP7VTebveVXa9wcpuOEw5DkM5eYay8wxlOwzlOAxdyOmhtAuuYseOqmHWk0PC1KQO/9wAAACUBf+LAoAqyDAMbdiXp2925CjlXPGw7a6FpD9KJySdyCn1a8Q2LlzOrXoIV2IBAACUFaEdAKoYR76hxeuytGl/XoUc3yTpf7pW07DOLOcGAABwswjtAFCFpJ53av43mUo+66yQ44eHmvTYoDDdGh1UIccHAACoagjtAFBF7DySp3+sylJOnnHdbS1GnoKVqyDlKMjIVbDJodCakaoWUU+hNrNCg02qFmxSNZtJoTaTQoNNqhFqVst6VlktjK4DAACUF0I7AAQ4p8vQF/E5+mZHbrE+W5D0C/sPapX4WwVnHVOQchWsHJl1xXXut46S+s6Sqtf1YtUAAACQCO0AENAuZLv0t/9mav/JgmJ99cOdGh80WfW2/cPzzhEx0uB5UuOBFVwlAAAASkJoB4AAdehUvt76T6bOZxefDt814qBGpd6pkIL04jtabFL3F6QuEz2vyw4AAACvIbQDQIAxDEOrdju0ZFO2nFet5mYxSz/vFar+h2bI5CmwN7lDGjRXimjpnWIBAABwTYR2AAgQ57Jc2no4Txv3OXQqo/ja6xHVzXpiSJha1LNKTeZIx1dIBdmFndXrSwNel+wjJZZpAwAA8BuEdgCoxPILDG1PytN/9tVV8paLMkq4MXybRlb9+vYw1ahmLmyo2Vjq+Qdp/WSpw1NSr+mSLdxrdQMAAKB0CO0AUMkYhqGjqU5t3OfQlkN5ynYYkkJL3P6uziG6N66azOarRtA7/VZqcrtUp0NFlgsAAICbQGgHgEriXJZLmw84Spz+frU6riQ9aJml2A4LpKsDuyRZggjsAAAAfo7QDgB+LCvXpe1JedpyME/7fyxQCbPfi9gsBeri+ko9c/+uVq7NMknSxp+uVwcAAEClU+lD+/z587V27VolJiYqKChI27Zt83VJAHBTHPmGdh/NU/zBPO05nl/sDvCeNAo7p9stH6vz6T/Kpmz3zh1vSLf+UqrbsWIKBgAAQIWp9KE9Pz9fQ4cOVYcOHbRkyRJflwMAZVLgNLT3RL7iD+Zp15E8OQquv0/tmmb1tFvVNXehor6fKIsrt/hGlmApbpIU2br8iwYAAECFq/ShfcKECZKkpUuX+rgSALg2l2Eov0DKKzAKv/KljCyXvj+cp+8P5ynLcb3J75ItSOrSIlg9W9vUyhkv0+onpTN7PG/ceKA0aJ4UGVPO3wkAAAC8pdKH9rJyuVxyOp2+LgMB7NL5xXkWeJwuQ+ezDZ3LdCkjy9C5LJcyslw6l2UoM7cwkOcXGMorCuiFf+aX8VSwmqV2ja2KaxWs2MZWBeeny/TdMzL98A+P2xuhdWT0fUVGzIOFa65zDqKc8LkGb+Fcg7dwrsFbXK5SXO9Ygiob2g8dOuTrElBFJCQk+LoE3CBHgVlns4OVmWdRVp5VWT/9mfnT45x8iwx5uBt7OTLJUMOauWp5S6aaRWTLZnVJ5w2lrFimRodfl6XgfLF9DJmU1uB+nWw2Xs7cmtKuXRVaI6ouPtfgLZxr8BbONfgzvwzts2fP1oIFC665zfLly9WiRYsyv0bLli0VFhZW5v2B63E6nUpISFBsbKwsFouvy8F1GIahw6edWrs3T9uTSnfzt4rQvK5FcS2D1Ll5kGqG1nLrM60cJ/P+v3vcLzvMrqBh7yiqYQ9FeaFOVE18rsFbONfgLZxr8JbMzMwyDxz7ZWh/7LHHNHz48GtuEx0dfVOvYTab+YsJr7BYLJxrfiw3z9DmAw6t2ePQj+nenxpnNUv1Iy3q0iJYca2CVbvmNc6VtqOlPVeF9qAwuXq8rET1UoeGXTjX4BV8rsFbONfgLZxrqGhms7nM+/plaI+MjFRkZKSvywAQwH48W6A1Pzi0eb9DufllO4bVLEWEmRURZlat6mZFVDerZqhJtiCTgq2XvnT5cVDhY9tPz4OsksV8A9PsG/WR2j0m7fnpWnb7z6T+r8kIrS/t3Fm2bwIAAAB+zS9D+404efKkzp8/r5MnT8rpdCoxMVGS1LhxY1WvXt3H1QHwJwVOQzuS8rTmB4cOnLz2mmpWs1Q7vDCI1wor/LMonP/0PCzEJJOpAq5tN4zCG8h50uf/pDMJUo8/SM3vLGzj5jkAAAABq9KH9jlz5ujzzz8ven7fffdJkt5//31169bNR1UB8CdnLzq1bq9D3+116ELOtZdVqxNuVr+2NvVsbVNYSNmnMZWJq0Da8aZ0ZLl0/zeSycPrh94iPRxfcqgHAABAQKn0oX3mzJmaOXOmr8sA4GdchqHEEwVa80Oudh3Nl3GNrG4ySbc1DVL/tiFqE22V2ReB+FS8tGKclLaz8PnuBdJtT3jelsAOAABQZVT60A4Al5zLcikppUBHUgq0PSlPqeevfQv4GtVM6nOrTX1vtSmqho9uPpN7TvruOWnXW5Ku+M3C+slSy/uk6nV9UxcAAAD8AqEdQKXkyDd0LK0woBcGdacyskq3Tpu9gVX92trUqXmwrBYfjVobhrTvQ2nN/0rZqcX7HeekpK+l2Me8XhoAAAD8B6EdgN9zGYZOZ7guB/TUAv141inXtS9Pd2MLknrE2NS/rU0No3z80Ze+X1o1Xjq+2nP/Le2kwW9JDXt5ty4AAAD4HUI7AL9zIdulI6kFRVPdj6Y6lZN3Awn9Cg0jLerfzqbudptCgn18LXhBrhQ/Q9o6U3LmFe+3hko9/yB1+q1kCfJ2dQAAAPBDhHYAfiHb4dK/tuZo55F8nb1YumnunlQLNqlpHYua1bGqXZMgtaxnrZhl2W7U0f8Wjq6fO+y5v/k90qA3pJpNvFsXAAAA/BqhHYBf+GRDtjbs8zD6fA0mk9QoqjCgN69rVbO6VtWLMPvm7u8lyTxZeN36/o8999eIlgbMkVrd59WyAAAAUDkQ2gH4XLbDpfgD1w/sEdXNalbXUhTQm9S2yhbkRwHdkyP/9hzYTRap8/9KPaZKwWHerwsAAACVAqEdgM99fzhfBVfNiLdZpaZ1CsN5s7qFI+m1qpt9U+DNaPeolPCOdGrT5bYGPaXB86Xa7X1XFwAAACoFQjsAn4s/4HB7flvTII0fGiaz2c9H0UvDZJZuf0v6oJNkqyn1+UvhMm6mSvgLCAAAAHgdoR2AT6VnunTgZIFbW48YW+UK7IYhnd4i1e/mub92e+muD6XoAVJobe/WBgAAgEqNoR4APrX1oENXLuZWLdik9k0q0XJnGYekz4ZKH3aXTqwtebuYBwjsAAAAuGGEdgA+tfmqG9B1ah6kIGslGGUvcEibpkvvtZOO/bewbeWTntdfBwAAAMqI0A7AZ348W6Dks063tu4xNh9VcwOOr5beby9tnCo5r7gePz1R2vaK7+oCAABAwOGadgA+c/Uyb7Wqm2Rv4McfS1kp0trfS4mLPPeHNZAi23i3JgAAAAQ0P/7fMYBA5jIMxR90D+1dW9lkNvnh1HjDJe3+m7R+iuQ4V7zfZJY6TpB6TZOCa3i9PAAAAAQuQjsAnzh0qkDpme6Ls3ezB/uommtI3SmtHCedivfcX6+rNPgtqW5Hr5YFAACAqoHQDsAnrp4aXz/Cougoi4+q8SDvorTxJWn7XwtH2q9mC5f6zJRify2Z/ahuAAAABBRCOwCvK3Aa2nbYPbR3twfL5C9T41N3Sp/fLWX+6Lm/zSNSv9lS9XpeLQsAAABVD6EdgNftOZ6vbIfh1uZXU+NrtfDcHtFKGjRfajLIu/UAAACgymLJNwBed/Xa7C3rWxVVw4+mmAfXkAbOufzcYpN6viyN3k1gBwAAgFcx0g7Aq3LyDO0+6h7au7Xyo1H2S1oOl5rdKbnypUFzC0fZAQAAAC8jtAPwqu1Jecp3Xn5uMUtdWvogtGefkTY8L3WdIoU3Ld5vMkl3fywFVS98DAAAAPgAoR2AV8UfcLg9b9c4SGEhXrxSx3BJe96V1v0/KTe98GZz933lOZgHh3mvLgAAAMADrmkH4DXnslzal1zg1ubVG9Cd2SP9s6/038cLA7skJX0tHfrCezUAAAAAN4DQDsBrthx06Mp7xocESbc19UJoz8+S1k2SPugondxQvH/DC5JhFG8HAAAAfIzp8QC8Jv6g+w3oOjYPVrC1gq8XP/yVtOo30sXjnvvtD0gDXuO6dQAAAPglQjsArziV7tTxNKdbW3e7reJe8MJx6dtnSp76Ht688K7wzYZWXA0AAADATSK0A/CKzQfdb0AXHmpS64YV8BHkzJd2zJE2vlQ4Lf5q5iCp6ySp63NSULXyf30AAACgHBHaAVQ4wzC05aqp8XGtgmU2l/OU9JObpJXjpLTdnvuj+0uD5ktRrcv3dQEAAIAKQmgHUOEOny7QmQsut7burcp5anxOuvTpYKkgu3hftdpS/1ekNr/g2nUAAABUKtw9HkCFiz/gPsper5ZZjWtbyvdFqkVK3Z4r3t7+CenRfdKtowjsAAAAqHQI7QAqVIHT0LbD7qG9m90mU0UE6C6/lyJ/mvpeu7300Ebp9rcKAz0AAABQCTE9HkCF+uFEvjJz3ddA79bqJtZmz8+RZEhBocX7rDZp8FtSyjap0zOSmY84AAAAVG6MtAOoUFdPjW9R16ra4WWcGn/kG+m9dtKml0veJrqf1OV3BHYAAAAEBEI7gAqTm2do19Grp8aXYZT94o/SVw9IS4dJ55Ok71+V0hLKqUoAAADAfxHaAVSY7Ul5yiu4/Nxilrq0vIHQ7iqQts+RFraRDnzq3r7ySclwlbwvAAAAEACYPwqgwsQfdLg9vzU6SDWqlfJ3hae3SivGSanbPfebTFJuhlQt6iarBAAAAPwXoR1AhTif7VJicoFbW6mmxjvOS989L+2cJ8ko3h8SKfWdJbX7lWRishAAAAACG6EdQIXYejBPxhWZ22aVOjS9Rmg3DGn/x9KaZ6Ws0563afeY1Of/pNBbyrdYAAAAwE8R2gFUiM0H3KfGd2weLFtQCWuzZxyUVo6Xjq/03B/VVho8X2rUp5yrBAAAAPwboR1AuTt9zqljaU63No9T4w1D2jRN2jJDcjqK91urST1ekjo/K1luYm13AAAAoJIitAMod/FXjbLXqGZSm0ZBxTc0maSMA54De/O7pYFvSOFNK6ZIAAAAoBLgLk4AypVhGIo/4L42e9eWwbKYS5ga3/8VyRZ++XlYI+nepdJ9/yKwAwAAoMojtAMoV0dSnUq74L5+eje7reQdqteTes+QTBap8/9KjyZKrYYXjsIDAAAAVRzT4wGUq6tvQFcn3KymRoKUdFJqfpfnndqPlaL7SVG3eqFCAAAAoPJgpB1AuSlwGtp2yH1qfLeg1TJ92EX69y+lnLOedzRbCOwAAACAB4R2AOUmMTlfF3MMt7buyb+XDJeUe1ZaN8lHlQEAAACVE6EdQLm5+gZ0zVzfq45x5HLDnnekk5u9XBUAAABQeXFNO4BykZvr0I7DWZIuL+3WreDTyxtYQ6Ruz0t1Onq/OAAAAKCSIrQDuHkn1mjnN58rz/VSUZPZKFCc8/PCJ02HSIPmSrVa+KY+AAAAoJIitAMou+xUae1Eae/7ig/+p2S53HWra41qVg+SBnwi2X/GEm4AAABAGRDaAdw4wyUlvCOtnyTlZuiCbtFe8wC3Tbo1uiDduU+y1fRRkQAAAEDlR2gHcONWjpd2v130dKtluFymyx8nwRaXOtw9RgpidB0AAAC4Gdw9HsCNi31c0uVAHm/9mVt3h+YhCiGwAwAAADeN0A7gxtXrInV4SpKUamqmI+Yubt3d7cG+qAoAAAAIOIR2ACUzXCX39f6j1LCP4mO/dGsOCzGpTaOgEnYCAAAAcCMI7QCKc+ZLW2dJ/+wjuQo8b2MLl/HztYpPi3ZrjmsZLKuFqfEAAABAeeBGdADc/bhBWjlOOrOn8Pn2OVKX//W46dFUp1LOuY/Gd2NqPAAAAFBuGGkHUCjnrPTfX0v/7H05sEvSxqnShRMed4k/6HB7XrumWc3r8rtAAAAAoLwQ2oGqzjCkPQuld1tLCX8v3p+fLR39pliz02Vo68E8t7Zu9mCZTEyNBwAAAMoLQ2JAVXZ2r7TySSl5nef+2h2k29+S6ncr1rUvuUAXcgy3tm6tbBVQJAAAAFB1EdqBqig/W9r8R2nbLM83mgsKk3pNlzr+RjJ7/pjYfMB9anyT2hbVi7BURLUAAABAlUVoB6qapK+lVb+RLhz13N/qfmnA61KNRiUewpFvaMcR96nx3e2MsgMAAADljdAOVBUXk6Vvn5EOLvXcX7OpNGiu1PzO6x5q19E8OfIvPzeZpLhW3DUeAAAAKG+EdqCqSF7nObCbg6S4iVK356Wg0FIdKv6A+yh7m4ZWhYdyX0sAAACgvPG/bKCqaP2Q1HiQe1ujvtLonVLvP5U6sF/McemHE/lubd2YGg8AAABUCEI7UFWYTNKgeZIlWKp2izR0ofTAGinq1lIfwjAMxR/Ik9N1uS3IInVsztR4AAAAoCIwPR4IJIZROA0+up/n/ki7dM8SqUFPqVrUVbsaynYYysh0Kf2nr4xMlzKyrnic6VK+0/2QHZoFq1owa7MDAAAAFYHQDgSK9P3SqvHS8dXSiOVSs2Fu3Tl5htIzncoIGqL0Iy5lZGYXBfRLgdzhYfW36+lmZ5QdAAAAqCiEdqCyK8iVY+MspW//pzKMOsqwPKz0/+5QRsueSs82Kz3TpXNZLuXkGeX+0rWqm9Q2OqjcjwsAAACgEKEd8DLDMJRXULjWeW6+IcdPX4WPC9sdBSW0X7WPIydHObl5ytFTUvBTl1/EKWm/86cH5c9kkhrfYtGDvUNltTA1HgAAAKgohHbgGgqchvIKDOVeEZqLBed8eQjfhV9nz9XX14cuynFFSM/Ll8pvzNv201f5MUmqGWpSRJhZkWFmRVQ3X37801et6mZZzIR1AAAAoKIR2gFJaeed+mpbjo6mOt3CeYHr+vteW4ikmz5IuapRreRAHvlTIGf0HAAAAPAPhHZA0jursnT4dBnuwuZnqge7FFEjyG1UPPLKUfLqZgVZCeQAAABAZUFoB1Q40u4rJpMUEmSSLUiyBZlkCzIVPrcWPrZZ8hWStkm2tE2yGZmyGVkKUVbhY2XJFmxVzS6/UkTHkbIFW3z2fQAAAAAof4R2QFL/diH619ac624XZLkqWF8VtIOtl9uDrFLa6WS1bBatajbLFdu572O1SCZTCaPfabulz4ZKWac897f9ldT3L1Jo7bJ/8wAAAAD8FqEdkHR3lxB1ah6kkxnOohHukJ+Cte2KcH4jN19zOp3aaVxUB3uwLJYyjoDXaiVZqxVvj2wjDZ4vRfcr23EBAAAAVAqEdkCFI90No6xqGOVnfyWCqkmD5kpLhxU+t4ZI3adKXX4nWYJ9WxsAAACACudnCQVAMc2GSvaRUn6mNPBNqVZzX1cEAAAAwEsI7YCvZaVI6ydJcZOlqNaetxn6XuEoe0nXvgMAAAAISIR2wFcMl7R7gbR+suQ4J104Lo1c5TmYB3m4rh0AAABAwDP7ugCgSkrdJX3US1o5rjCwS9KJb6XExT4tCwAAAIB/IbQD3pR3UVrzO2lRZ+nU5uL9m6cXjsADAAAAgJgeD3iHYUiHvpBWT5Aykz1v0+YRqd9sycTv0gAAAAAUIrQDFe38UWntb6WkZZ77I+zSoHlSk0HerAoAAABAJVCpQ3tycrLmzZunzZs368yZM6pTp47uvfdejRs3TsHBrGENH3Pmqe6xhTJ/945UkFO832KTuj0vxf0/yWrzfn0AAAAA/F6lDu1JSUkyDEPTpk1TkyZNdODAAb344ovKycnRpEmTfF0eqrLkdTKveFKN0vd67m9ye+HoekRL79YFAAAAoFKp1KG9b9++6tu3b9Hz6OhoHTlyRB999NF1Q7vL5ZLT6azoElEV5Z6T+fO7Zcq7WKzLCK0no9+rMuwjC5d24xxEObj0WcZnGioa5xq8hXMN3sK5Bm9xucp+s+lKHdo9uXjxosLDw6+73aFDh7xQDaqqOtGPK/rwa0XPDZmU1nCkfmw2Xq6cMGnXLh9Wh0CVkJDg6xJQRXCuwVs41+AtnGvwZwEV2o8dO6ZFixaVamp8y5YtFRYW5oWqUCW1byfXh6tkPrNbrtodZQyer6i6XRTl67oQkJxOpxISEhQbGyuLxeLrchDAONfgLZxr8BbONXhLZmZmmQeO/TK0z549WwsWLLjmNsuXL1eLFi2KnqekpOjxxx/X0KFD9cADD1z3NcxmM38xcXPyswrXVA+uUbzPYpFz0Hwd//5zNbzzT7IEcWNEVDyLxcLnGryCcw3ewrkGb+FcQ0Uzm8u+rLNfhvbHHntMw4cPv+Y20dHRRY9TUlI0evRodezYUdOnT6/o8gDp0L+k1U9Lze+WBs/1vE39bkprZFNDM/8AAAAAACgbvwztkZGRioyMLNW2lwJ727ZtNWPGjJv6DQZwXReOS6snSIe/LHy+a77U7ldSvTiflgUAAAAgMFXqhJuSkqJRo0apfv36mjRpktLT05WWlqa0tDRfl4ZA48yXts6W3m1zObBLkgxpxROSq8BnpQEAAAAIXH450l5aGzZs0LFjx3Ts2DG3pd8kaf/+/T6qCgHnx43SynHSmRLuKmqrJeWek0Jv8WZVAAAAAKqASh3aR4wYoREjRvi6DASqnHRp/WQpoYSbIlarLfV/VWrzSOGa6wAAAABQzip1aAcqhGFIez+Q1v5OyjnjeZv2T0h9ZkghEd6tDQAAAECVQmgHrnQ2UVr5pJS81nN/7fbS4LekBj28WxcAAACAKonQDkiFo+sbp0pb/k9y5RfvD6ou9ZwmdZogmflrAwAAAMA7SB+AVHhNenaq58DeaoTU/3WpZrTXywIAAABQtVXqJd+ActV7RuHN5S6p2US67yvp3s8I7AAAAAB8gtAOXFItUuo3u3D6e9fJ0q9+kFrc7euqAAAAAFRhTI8HrnTrKKlBTymipa8rAQAAAABG2gE3JhOBHQAAAIDfILQDAAAAAOCnCO0AAAAAAPgpQjsAAAAAAH6K0A4AAAAAgJ8itAMAAAAA4KcI7QAAAAAA+ClCOwAAAAAAforQDgAAAACAnyK0AwAAAADgpwjtAAAAAAD4KUI7AAAAAAB+itAOAAAAAICfIrQDAAAAAOCnCO0AAAAAAPgpQjsAAAAAAH6K0A4AAAAAgJ8itAMAAAAA4KcI7QAAAAAA+ClCOwAAAAAAforQDgAAAACAnyK0AwAAAADgpwjtAAAAAAD4KUI7AAAAAAB+itAOAAAAAICfsvq6AG9zuVySpNzcXFksFh9Xg0DmdDolSdnZ2ZxrqFCca/AWzjV4C+cavIVzDd6Sm5sr6XIevREmwzCM8i7In509e1ZHjx71dRkAAAAAgCqmadOmioqKuqF9qlxoLygo0Pnz52Wz2WQ2c3UAAAAAAKBiuVwuORwOhYeHy2q9sQnvVS60AwAAAABQWTDUDAAAAACAnyK0AwAAAADgpwjtAAAAAAD4qSod2seNG6f+/fsrNjZWvXv31sSJE5WSkuLrshBgkpOT9dxzz2ngwIFq3769Bg8erDlz5igvL8/XpSEAzZ8/Xw8++KBuu+02denSxdflIIAsXrxYAwcOVGxsrEaOHKndu3f7uiQEoK1bt2rcuHHq3bu3YmJitHLlSl+XhAD19ttv6/7771fHjh3Vo0cPjR8/XklJSb4uCwHoww8/1D333KNOnTqpU6dO+vnPf661a9fe0DGqdGjv3r27Xn/9dX3zzTeaM2eOTpw4oWeeecbXZSHAJCUlyTAMTZs2TV9//bWmTJmif/7zn3rttdd8XRoCUH5+voYOHaqHHnrI16UggCxfvlwzZszQU089pc8//1ytW7fWmDFjdPbsWV+XhgCTnZ2tmJgYvfTSS74uBQFuy5YteuSRR/TJJ5/o3XffVUFBgcaMGaPs7Gxfl4YAU69ePf3+97/X0qVL9dlnn6l79+566qmndPDgwVIfg7vHX2HVqlV66qmnlJCQoKCgIF+XgwD297//XR999JFWrVrl61IQoJYuXao///nP2rZtm69LQQAYOXKkYmNjNXXqVEmFy9b069dPo0aN0tixY31cHQJVTEyM5s6dq8GDB/u6FFQB6enp6tGjhxYtWqS4uDhfl4MA17VrV02cOFEjR44s1fZVeqT9SufOndNXX32ljh07EthR4S5evKjw8HBflwEA15WXl6cffvhBPXv2LGozm83q2bOnduzY4cPKAKD8XLx4UZL4/xkqlNPp1Ndff63s7Gx17Nix1Pvd2KruAWjWrFlavHixcnJy1KFDB7311lu+LgkB7tixY1q0aJEmTZrk61IA4LoyMjLkdDoVFRXl1h4VFcX1nwACgsvl0p///Gd16tRJdrvd1+UgAO3fv18PPvigHA6HQkNDNXfuXLVs2bLU+wdcaJ89e7YWLFhwzW2WL1+uFi1aSJLGjBmjn/3sZzp58qTefPNNTZo0SW+//bZMJpM3ykUldqPnmiSlpKTo8ccf19ChQ/XAAw9UdIkIEGU51wAAQOm8/PLLOnjwoD788ENfl4IA1axZM33xxRe6ePGi/vOf/2jSpElatGhRqYN7wIX2xx57TMOHD7/mNtHR0UWPIyMjFRkZqWbNmqlFixbq16+fdu7ceUPTFVA13ei5lpKSotGjR6tjx46aPn16RZeHAHKj5xpQniIiImSxWIrddO7s2bO65ZZbfFQVAJSPadOmac2aNVq0aJHq1avn63IQoIKDg9WkSRNJUrt27ZSQkKD3339f06ZNK9X+ARfaL4XwsnC5XJLEUlwolRs51y4F9rZt22rGjBkym7mdBErvZj7XgJsVHBystm3batOmTUU3BHO5XNq0aZN+8Ytf+Lg6ACgbwzA0ffp0rVixQh988AG//IZXuVyuG8qcARfaS2vXrl1KSEhQ586dVbNmTR0/flx//etf1bhxY0bZUa5SUlI0atQoNWjQQJMmTVJ6enpRX+3atX1YGQLRyZMndf78eZ08eVJOp1OJiYmSpMaNG6t69eo+rg6V1aOPPqpJkyapXbt2at++vd577z3l5ORoxIgRvi4NASYrK0vHjx8vep6cnKzExESFh4erQYMGPqwMgebll1/WsmXLNG/ePFWvXl1paWmSpBo1aigkJMTH1SGQvPLKK+rbt6/q16+vrKwsLVu2TFu2bNE777xT6mNU2SXf9u/frz/96U/av3+/srOzVbt2bfXp00fjx49X3bp1fV0eAsjSpUs1ZcoUj3379+/3cjUIdJMnT9bnn39erP39999Xt27dfFARAsWiRYv0zjvvKC0tTW3atNELL7yg2267zddlIcDEx8dr9OjRxdqHDx+umTNn+qAiBKqYmBiP7TNmzOAXkihXzz33nDZv3qzU1FTVqFFDMTEx+vWvf61evXqV+hhVNrQDAAAAAODvuLAWAAAAAAA/RWgHAAAAAMBPEdoBAAAAAPBThHYAAAAAAPwUoR0AAAAAAD9FaAcAAAAAwE8R2gEAAAAA8FOEdgAAAAAA/BShHQDgEzExMTf0NXDgQElSfHy8YmJiNHnyZB9/B/7BVz+P5ORkxcTEaNSoUV593cqkpPdm6dKliomJ0RtvvOGjygAAlYnV1wUAAKqm4cOHF2v7/vvvdfz4cbVu3Vpt2rRx64uIiPBWaX7ljTfe0JtvvqkZM2ZoxIgRvi4HV+C9AQB4A6EdAOATM2fOLNY2efJkHT9+XIMHD9bTTz/tg6oqn/bt22v58uWqUaOGr0vBVXhvAADlgdAOAEAlVq1aNbVo0cLXZcAD3hsAQHngmnYAQKV17tw5vfTSS+rdu7fatWunu+++W0uWLClx+1OnTmnatGkaPHiwYmNj1bVrVz3xxBPavn17ifusXbtWjz76qOLi4hQbG6shQ4Zo9uzZunDhQrFt33jjDcXExGjp0qXavXu3nnjiCXXr1k0xMTFKTEws2m7Xrl2aMGFCUd19+/bV888/r5MnT7odb+DAgXrzzTclSVOmTHG7xj8+Pl7S9a9pX7duncaNG6eePXuqXbt26tevn5544gn95z//cdtu27ZtmjZtmu655x7FxcWpffv2Gjp0aInfa1mdOnVKEydOVPfu3XXbbbdpxIgR+vLLL0u8Rn7y5Mlu3+/VrrzfwSUOh0OffvqpnnzySQ0aNEjt27dXly5d9Mgjj+jrr7/2eJwrX2fr1q0aPXq0OnbsqE6dOmns2LE6dOiQ2/bl8d54YhiGli1bptGjRxedc8OGDdMbb7yhnJycYttnZWXp7bff1r333qvOnTurY8eOGjx4sCZMmKD169eX+nUBAP6LkXYAQKV04cIF/fznP1d2drY6d+6sjIwMbdu2Tc8//7wMw9DIkSPdtt+xY4eeeOIJnT9/Xs2aNVP//v2Vnp6u7777TuvXr9fs2bN15513uu3z9ttv69VXX5XValVcXJwiIiK0fft2LViwQCtWrNDixYt1yy23FKtt69atmjp1qpo2bapevXopNTVVJpNJkrR48WL98Y9/lCTFxsaqc+fOOnLkiJYsWaLVq1dr0aJFRaOzQ4YM0caNG7Vv3z516tRJTZo0KXoNT697tZkzZ+rdd9+V2WxWhw4d1KBBA6Wmpmr79u06ffq0hgwZUrTtX/7yF+3bt08xMTHq0aOHHA6HfvjhBy1YsEBr1qzRxx9/rOrVq5fy3fHsxIkTeuihh5SWlqbo6Gj17NlTKSkpmjRpkh555JGbOvaVkpOT9cILL6hOnTpq1qyZ2rdvrzNnzmjHjh3atm2bkpKSSrz84ttvv9X7779f9AuOxMRErV27Vrt27dKyZctUu3ZtSTf/3njicrk0ceJELVu2TKGhoWrXrp3Cw8O1Z88evfnmm1q3bp0++OADhYSESJKcTqceffRR7dq1SxEREeratatsNptOnz6tdevWKTQ0VH369ClTLQAAP2IAAOAnJk2aZNjtdmPOnDklbrN582bDbrcbdrvdePbZZw2Hw1HUt2LFCsNutxv9+/d32+fixYtGr169jDZt2hhffvmlW9/u3buNuLg4o0OHDsbZs2eL2nft2mW0bt3a6NChg7Fz586idofDYUyYMMGw2+3G008/7XasOXPmFNX2t7/9rVjtO3bsMNq0aWP06dPHSEhIcOv75JNPDLvdbowcOdLjMT/77LNr/jwmTZrk1v7FF18Ydrvd6N27t7F37163vpycHOO7775za1uzZo1x4cIFtzaHw2G8+OKLht1uN9544w23vhMnThh2u934xS9+4bEuT8aMGWPY7XZjypQpRn5+flH7qlWrjDZt2ng83qVzYvPmzR6PabfbjQEDBri1paenGxs2bDBcLpdb+/Hjx40BAwYYrVu3Nk6cOOHxdVq3bm2sWLGiqL2goMB4+umnDbvdbrz++utu+5T1vfnss888nucLFiwo+hmkpqYWtTscDuO5554z7Ha7MWvWrKL2TZs2GXa73bj//vuN3Nxct2NdvHix2DkGAKicmB4PAKiUwsLC9OKLLyo4OLiobfDgwbLb7Tp58qSSk5OL2pcsWaK0tDT98pe/1L333ut2nNjYWI0fP17Z2dn617/+VdS+ePFiuVwujRo1SrfddltRe3BwsKZOnaqQkBCtWLFCp06dKlab3W7X448/Xqz9b3/7m5xOp15++WW1a9fOrW/kyJEaOHCgdu3apb179974D+Qqb7/9tqTCqdtX34k/JCREvXr1cmvr169fsRumBQcH67nnnpPVatXq1atvqp4TJ05o/fr1CgsL05QpU2S1Xp7sN3DgQLdR/5sVERGhnj17Fs1uuCQ6OlpPPvmkXC6Xvv32W4/73nXXXRo8eHDRc4vForFjx0oqvISgohQUFOjvf/+7QkND9dprrxWN6EuF78OLL76o2rVr65NPPpHL5ZIkpaenS5I6deokm83mdrywsLBi5xgAoHJiejwAoFJq27atx2XgmjZtqgMHDigtLU2NGjWSJG3YsEGSdPvtt3s8VufOnSVJu3fvLmq7FNDuueeeYttHRUWpV69eWrVqlbZv36677rrLrX/AgAHFAqPL5dKmTZtUrVo19e7d22MdXbp00erVq7V7927deuutHrcpjZSUFB0+fFg1a9bUsGHDbmi/1atXKykpSZmZmTIMQ5IUFBSko0ePlrkeqXA5P0nq06ePx7up33XXXVq+fPlNvcbVtm3bpi1btiglJUV5eXkyDENpaWmSpGPHjnncx9N707RpU0lSampqudZ3pb179yojI0O9evXyOL0+JCREbdu21Zo1a3T06FE1b95cbdq0kdls1tKlS9WyZUvdfvvtVXZpRAAIZIR2AEClVK9ePY/tl667zsvLK2r78ccfJUkPPfTQNY+ZkZFR9PhSQGvYsKHHbS+1p6SkFOurX7++x2NnZ2dL0nVHQK+soyxOnz4tqXBk+epfHpTk3Xff1SuvvKL8/Pybeu2SXPp5NmjQwGP/pV+wlIeLFy/qN7/5jTZv3lziNllZWR7b69atW6wtLCxMkirsZyOpaGbIhg0bFBMTc81tL50fzZo108SJE/Xqq6/qxRdf1EsvvaRWrVqpR48eGj58uFq3bl1h9QIAvIfQDgColMzm0l/hdWk68ZAhQxQaGlrids2bNy/1Ma8Vhq+eqnxlDaGhodedCt6qVatS11Eedu7cqZkzZ6pGjRqaPn26unbtqtq1axddetC7d++iEWp/culnerVZs2Zp8+bN6tq1q55++mm1atVKNWvWlMVi0XfffacxY8YUzSK42o2cV+XpUj1NmjRRp06drrltrVq1ih4/9thjGjZsmFauXKkNGzbo+++/18KFC/Xee+9pypQp+uUvf1mRZQMAvIDQDgAIePXq1dORI0c0duzYUl/nW6dOHSUnJ+vkyZNq2bJlsf5Lo/eeRmY9iYiIkM1mk9ls1owZM0o9Al4Wl2YhnDhxQoZhXPe1VqxYIUl69tlnNXz4cLe+3NxcnTlz5qZrunSN9tXL2l1y6ed5taCgIEkqmqVwJU/3E5CklStXymKxaP78+UWj5JecOHGi1DV706XzqHnz5po5c+YN7Vu/fn2NGjVKo0aNUkFBgb7++ms999xzmjVrlu677z6Fh4dXRMkAAC/hRnQAgIDXs2dPSZfDaWl06dJFkrRs2bJifZeWijOZTNcdFb3EarWqa9euyszM1KZNm0pdx6XQ6nQ6S71P3bp11aJFC124cEH//ve/r7v9pXXYPf0C4ptvvilxVPpGXLpvwPr165WZmVmsv6Tr2S+FfU/X1G/cuNHjPhcuXFBYWFixwC6pVD+P0irLe1OS9u3bq0aNGtqyZYvOnTtX5uNYrVb9z//8j2JjY5Wfn1/itfsAgMqD0A4ACHgPPvigoqKi9M477+jjjz8uNq26oKBA69ev14EDB4raHnnkEZnNZn3wwQdKSEgoas/Ly9P06dOVm5urO+64w+P16yUZN26czGazpkyZovj4+GL9WVlZWrJkiXJzc4va6tSpI0lKSkoq9etIKrrj+cyZM7Vv3z63PofDUXRzPunyjdaWLFnidt32oUOHNHv27Bt63ZI0btxYvXv3VmZmpmbOnOkWdNeuXatvvvnG435xcXGSpI8++sjtWv/ExET99a9/9bhP06ZNdf78+WK/CFi4cKHHn3tZlfW98SQ4OFiPP/64srKy9PTTT3ucEZCSkqIvvvii6PnmzZu1cePGYufziRMndPjwYZlMplLPBAEA+C+mxwMAAl7NmjU1b948jRs3TlOnTtX8+fOLrnM+c+aM9u7dqwsXLmju3Lmy2+2SCkc+n3nmGb322mt68MEH1bVrV0VERGj79u06deqUmjZtqqlTp95QHV26dNHUqVM1ffp0jR49Wna7XU2bNpXVatWPP/6oxMRE5eXl6Y477lBISIgkqVevXrLZbHrvvfd08OBB1alTRyaTSWPGjLnmNfj33Xef9uzZow8++EAjRoxQhw4dVL9+faWmpmrfvn1q0KCBvvzyS0nSiBEj9O677+rbb7/V0KFDFRsbq/Pnz2vr1q0aNGiQEhISSpy+fiP+8Ic/6MEHH9Snn36q+Ph4xcbGKjU1Vdu2bdPDDz+sxYsXF9une/fu6tq1q7Zs2aK77rpLnTp1UkZGhnbt2qVRo0bpH//4R7F9xo4dq4kTJ+rZZ5/V4sWLVa9ePe3bt09JSUn61a9+pYULF9709yKV/b0pydixY5WUlKQvv/xSw4YN06233qpGjRopPz9fR44c0aFDhxQTE6P77rtPkrRv3z7NmDFDkZGRatu2rWrVqqWMjAxt2bJFeXl5GjVqFKEdAAIAoR0AUCV06NBBX331lRYuXKi1a9dq69atkgqnX8fFxen2229Xjx493PYZN26cWrdurYULFyohIUG5ublq0KCBHn/8cY0dO7ZM1wo/9NBD6tChg9577z1t2bJF3377rapVq6a6devqnnvu0R133OG2JFrdunU1b948zZ07V99//33Rtd333nvvdYPhCy+8oB49eujDDz/Unj17tHv3bkVFRalz5866//77i7aLiIjQkiVLNGvWLG3dulWrV69Wo0aNNGHCBI0ZM6bEpfJuVHR0tD755BO9+uqr+u6777Ry5Uo1b95cM2bMUFxcnMfQbjKZNG/ePM2ePVsrV67U2rVr1aRJEz3//PN66KGHPIb2e++9V+Hh4Zo3b54SExN14MABtWvXTi+99JIMwyi30H4z740nZrNZf/nLXzRkyBB98sknSkhI0N69e1WzZk3Vq1dPY8aM0Z133lm0/YABA3Tu3DnFx8dr3759OnfunCIjI9W5c2c9/PDD5fa+AQB8y2SUx4VqAAAANyE5OVmDBg1S165d9cEHH/i6HAAA/AbXtAMAAAAA4KcI7QAAAAAA+ClCOwAAAAAAfopr2gEAAAAA8FOMtAMAAAAA4KcI7QAAAAAA+ClCOwAAAAAAforQDgAAAACAnyK0AwAAAADgpwjtAAAAAAD4KUI7AAAAAAB+itAOAAAAAICf+v9nh+049IAWfAAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1928,7 +2048,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.9.16" } }, "nbformat": 4,