From cb166aefeb29349398252236e5d1ffde74db0696 Mon Sep 17 00:00:00 2001 From: ghiffaryr Date: Mon, 12 Sep 2022 03:00:44 +0700 Subject: [PATCH] release:grplot-0.11 --- doc/Notebook Documentation.ipynb | 839 +++- grplot/__init__.py | 8 +- grplot/analytic/__init__.py | 136 + grplot/features/plot/plot_single_def.py | 2 +- grplot/features/sep/text_sep/text_sep_type.py | 4 +- grplot_seaborn/__init__.py | 21 + grplot_seaborn/_core.py | 1491 ++++++ grplot_seaborn/_decorators.py | 62 + grplot_seaborn/_docstrings.py | 198 + grplot_seaborn/_statistics.py | 441 ++ grplot_seaborn/_testing.py | 108 + grplot_seaborn/algorithms.py | 129 + grplot_seaborn/apionly.py | 9 + grplot_seaborn/axisgrid.py | 2386 ++++++++++ grplot_seaborn/categorical.py | 4023 +++++++++++++++++ grplot_seaborn/cm.py | 1585 +++++++ grplot_seaborn/colors/__init__.py | 2 + grplot_seaborn/colors/crayons.py | 120 + grplot_seaborn/colors/xkcd_rgb.py | 949 ++++ grplot_seaborn/conftest.py | 235 + grplot_seaborn/distributions.py | 2723 +++++++++++ grplot_seaborn/external/__init__.py | 0 grplot_seaborn/external/docscrape.py | 718 +++ grplot_seaborn/external/husl.py | 313 ++ grplot_seaborn/external/six.py | 869 ++++ grplot_seaborn/linearmodels.py | 7 + grplot_seaborn/matrix.py | 1410 ++++++ grplot_seaborn/miscplot.py | 48 + grplot_seaborn/palettes.py | 1038 +++++ grplot_seaborn/rcmod.py | 550 +++ grplot_seaborn/regression.py | 1121 +++++ grplot_seaborn/relational.py | 1157 +++++ grplot_seaborn/tests/__init__.py | 0 grplot_seaborn/tests/test_algorithms.py | 202 + grplot_seaborn/tests/test_axisgrid.py | 1784 ++++++++ grplot_seaborn/tests/test_categorical.py | 3024 +++++++++++++ grplot_seaborn/tests/test_core.py | 1284 ++++++ grplot_seaborn/tests/test_decorators.py | 108 + grplot_seaborn/tests/test_distributions.py | 2284 ++++++++++ grplot_seaborn/tests/test_docstrings.py | 58 + grplot_seaborn/tests/test_matrix.py | 1311 ++++++ grplot_seaborn/tests/test_miscplot.py | 34 + grplot_seaborn/tests/test_palettes.py | 423 ++ grplot_seaborn/tests/test_rcmod.py | 281 ++ grplot_seaborn/tests/test_regression.py | 673 +++ grplot_seaborn/tests/test_relational.py | 1859 ++++++++ grplot_seaborn/tests/test_statistics.py | 460 ++ grplot_seaborn/tests/test_utils.py | 607 +++ grplot_seaborn/timeseries.py | 454 ++ grplot_seaborn/utils.py | 821 ++++ grplot_seaborn/widgets.py | 440 ++ setup.py | 8 +- 52 files changed, 38625 insertions(+), 192 deletions(-) create mode 100644 grplot/analytic/__init__.py create mode 100644 grplot_seaborn/__init__.py create mode 100644 grplot_seaborn/_core.py create mode 100644 grplot_seaborn/_decorators.py create mode 100644 grplot_seaborn/_docstrings.py create mode 100644 grplot_seaborn/_statistics.py create mode 100644 grplot_seaborn/_testing.py create mode 100644 grplot_seaborn/algorithms.py create mode 100644 grplot_seaborn/apionly.py create mode 100644 grplot_seaborn/axisgrid.py create mode 100644 grplot_seaborn/categorical.py create mode 100644 grplot_seaborn/cm.py create mode 100644 grplot_seaborn/colors/__init__.py create mode 100644 grplot_seaborn/colors/crayons.py create mode 100644 grplot_seaborn/colors/xkcd_rgb.py create mode 100644 grplot_seaborn/conftest.py create mode 100644 grplot_seaborn/distributions.py create mode 100644 grplot_seaborn/external/__init__.py create mode 100644 grplot_seaborn/external/docscrape.py create mode 100644 grplot_seaborn/external/husl.py create mode 100644 grplot_seaborn/external/six.py create mode 100644 grplot_seaborn/linearmodels.py create mode 100644 grplot_seaborn/matrix.py create mode 100644 grplot_seaborn/miscplot.py create mode 100644 grplot_seaborn/palettes.py create mode 100644 grplot_seaborn/rcmod.py create mode 100644 grplot_seaborn/regression.py create mode 100644 grplot_seaborn/relational.py create mode 100644 grplot_seaborn/tests/__init__.py create mode 100644 grplot_seaborn/tests/test_algorithms.py create mode 100644 grplot_seaborn/tests/test_axisgrid.py create mode 100644 grplot_seaborn/tests/test_categorical.py create mode 100644 grplot_seaborn/tests/test_core.py create mode 100644 grplot_seaborn/tests/test_decorators.py create mode 100644 grplot_seaborn/tests/test_distributions.py create mode 100644 grplot_seaborn/tests/test_docstrings.py create mode 100644 grplot_seaborn/tests/test_matrix.py create mode 100644 grplot_seaborn/tests/test_miscplot.py create mode 100644 grplot_seaborn/tests/test_palettes.py create mode 100644 grplot_seaborn/tests/test_rcmod.py create mode 100644 grplot_seaborn/tests/test_regression.py create mode 100644 grplot_seaborn/tests/test_relational.py create mode 100644 grplot_seaborn/tests/test_statistics.py create mode 100644 grplot_seaborn/tests/test_utils.py create mode 100644 grplot_seaborn/timeseries.py create mode 100644 grplot_seaborn/utils.py create mode 100644 grplot_seaborn/widgets.py diff --git a/doc/Notebook Documentation.ipynb b/doc/Notebook Documentation.ipynb index f0364d0..5882a77 100644 --- a/doc/Notebook Documentation.ipynb +++ b/doc/Notebook Documentation.ipynb @@ -36,28 +36,43 @@ "name": "stdout", "output_type": "stream", "text": [ - "Help on function grplot in module grplot:\n", + "Help on package grplot:\n", + "\n", + "NAME\n", + " grplot\n", + "\n", + "PACKAGE CONTENTS\n", + " analytic (package)\n", + " features (package)\n", + " hotfix (package)\n", + " setting\n", + " utils (package)\n", + "\n", + "FUNCTIONS\n", + " plot2d(plot, df, x=None, y=None, Nx=None, Ny=None, figsize=[8, 6], pad=6, hpad=None, wpad=None, hue=None, size=None, fontsize=10, tick_fontsize=None, legend_fontsize=None, text_fontsize=None, label_fontsize=None, title_fontsize=None, sep=',', xsep=None, ysep=None, lim=None, xlim=None, ylim=None, log=None, xlog=None, ylog=None, dt=None, xdt=None, ydt=None, tick_add=None, xtick_add=None, ytick_add=None, rot=None, xrot=None, yrot=None, statdesc=None, xstatdesc=None, ystatdesc=None, text=None, xtext=None, ytext=None, label_add=None, xlabel_add=None, ylabel_add=None, title=None, legend_loc=None, saveas=None, optimizer='perf', style=None, palette=None, hue_order=None, hue_norm=None, sizes=None, size_order=None, size_norm=None, markers=None, dashes=None, style_order=None, legend=None, height=None, units=None, x_bins=None, y_bins=None, estimator=None, x_estimator=None, ci=None, n_boot=None, alpha=None, expand_margins=None, jitter=None, x_jitter=None, y_jitter=None, weights=None, color=None, seed=None, sort=None, err_style=None, err_kws=None, stat=None, bins=None, binwidth=None, binrange=None, discrete=None, cumulative=None, common_bins=None, common_norm=None, common_grid=None, multiple=None, element=None, fill=None, shrink=None, kde=None, kde_kws=None, line_kws=None, thresh=None, pthresh=None, pmax=None, cbar=None, cbar_ax=None, cbar_kws=None, shade=None, vertical=None, kernel=None, bw=None, gridsize=None, cut=None, clip=None, shade_lowest=None, levels=None, bw_method=None, bw_adjust=None, df2=None, warn_singular=None, complementary=None, a=None, order=None, orient=None, edgecolor=None, linewidth=None, saturation=None, width=None, dodge=None, fliersize=None, whis=None, scale=None, scale_hue=None, inner=None, split=None, k_depth=None, outlier_prop=None, trust_alpha=None, showfliers=None, linestyles=None, join=None, errwidth=None, capsize=None, errcolor=None, x_ci=None, scatter=None, fit_reg=None, logistic=None, lowess=None, robust=None, regplot_logx=None, x_partial=None, y_partial=None, truncate=None, scatter_kws=None, marker=None, dropna=None, label=None, zorder=None, color2=None, markersize=None, explode=None, colors=None, autopct=None, pctdistance=None, shadow=None, labeldistance=None, startangle=None, radius=None, counterclock=None, wedgeprops=None, textprops=None, center=None, frame=None, rotatelabels=None, normalize=None, norm_x=None, norm_y=None, treemaps_pad=None, bar_kwargs=None, text_kwargs=None, bubble_spacing=None, showmeans=None, meanprops=None)\n", + " -----------------------------------------------\n", + " grplot: lazy statistical data visualization\n", + " \n", + " by ghiffary rifqialdi\n", + " based on numpy, scipy, matplotlib, seaborn, squarify, and pandas\n", + " \n", + " version = '0.11'\n", + " \n", + " release date\n", + " 11/09/2022\n", + " -----------------------------------------------\n", + " \n", + " documentation is available at https://github.com/ghiffaryr/grplot\n", + "\n", + "FILE\n", + " c:\\users\\ghiffary rifqialdi\\appdata\\local\\programs\\python\\python38\\lib\\site-packages\\grplot\\__init__.py\n", "\n", - "grplot(plot, df, x=None, y=None, Nx=None, Ny=None, figsize=[8, 6], pad=6, hpad=None, wpad=None, hue=None, size=None, fontsize=10, tick_fontsize=None, legend_fontsize=None, text_fontsize=None, label_fontsize=None, title_fontsize=None, sep=',', xsep=None, ysep=None, lim=None, xlim=None, ylim=None, log=None, xlog=None, ylog=None, dt=None, xdt=None, ydt=None, tick_add=None, xtick_add=None, ytick_add=None, rot=None, xrot=None, yrot=None, statdesc=None, xstatdesc=None, ystatdesc=None, text=None, xtext=None, ytext=None, label_add=None, xlabel_add=None, ylabel_add=None, title=None, legend_loc=None, saveas=None, optimizer='perf', style=None, palette=None, hue_order=None, hue_norm=None, sizes=None, size_order=None, size_norm=None, markers=None, dashes=None, style_order=None, legend=None, height=None, units=None, x_bins=None, y_bins=None, estimator=None, x_estimator=None, ci=None, n_boot=None, alpha=None, expand_margins=None, jitter=None, x_jitter=None, y_jitter=None, weights=None, color=None, seed=None, sort=None, err_style=None, err_kws=None, stat=None, bins=None, binwidth=None, binrange=None, discrete=None, cumulative=None, common_bins=None, common_norm=None, common_grid=None, multiple=None, element=None, fill=None, shrink=None, kde=None, kde_kws=None, line_kws=None, thresh=None, pthresh=None, pmax=None, cbar=None, cbar_ax=None, cbar_kws=None, shade=None, vertical=None, kernel=None, bw=None, gridsize=None, cut=None, clip=None, shade_lowest=None, levels=None, bw_method=None, bw_adjust=None, df2=None, warn_singular=None, complementary=None, a=None, order=None, orient=None, edgecolor=None, linewidth=None, saturation=None, width=None, dodge=None, fliersize=None, whis=None, scale=None, scale_hue=None, inner=None, split=None, k_depth=None, outlier_prop=None, trust_alpha=None, showfliers=None, linestyles=None, join=None, errwidth=None, capsize=None, errcolor=None, x_ci=None, scatter=None, fit_reg=None, logistic=None, lowess=None, robust=None, regplot_logx=None, x_partial=None, y_partial=None, truncate=None, scatter_kws=None, marker=None, dropna=None, label=None, zorder=None, color2=None, markersize=None, explode=None, colors=None, autopct=None, pctdistance=None, shadow=None, labeldistance=None, startangle=None, radius=None, counterclock=None, wedgeprops=None, textprops=None, center=None, frame=None, rotatelabels=None, normalize=None, norm_x=None, norm_y=None, treemaps_pad=None, bar_kwargs=None, text_kwargs=None, bubble_spacing=None, showmeans=None, meanprops=None)\n", - " -----------------------------------------------\n", - " grplot: lazy statistical data visualization\n", - " \n", - " by ghiffary rifqialdi\n", - " based on numpy, scipy, matplotlib, seaborn, squarify, and pandas\n", - " \n", - " version = '0.10.4'\n", - " \n", - " release date\n", - " 25/08/2022\n", - " -----------------------------------------------\n", - " \n", - " documentation is available at https://github.com/ghiffaryr/grplot\n", "\n" ] } ], "source": [ - "from grplot import grplot\n", + "import grplot\n", "\n", "\n", "help(grplot)" @@ -65,10 +80,18 @@ }, { "cell_type": "markdown", - "id": "ee78305e", + "id": "005c1fd1", "metadata": {}, "source": [ - "# Plot" + "# Basic Understanding" + ] + }, + { + "cell_type": "markdown", + "id": "c925cea9", + "metadata": {}, + "source": [ + "## Argument" ] }, { @@ -76,9 +99,7 @@ "id": "629cb172", "metadata": {}, "source": [ - "Argument Introduction\n", - "
\n", - "
\n", + "
Here I tell you how to pass the argument into the plot function
\n", "ordinary argument:\n", "
arg = return\n", "
\n", @@ -118,6 +139,111 @@ "
- axes argument starts from 1 (*different from matplotlib which starts from 0)" ] }, + { + "cell_type": "markdown", + "id": "bba89a58", + "metadata": {}, + "source": [ + "## Image Quality Dots per Inch" + ] + }, + { + "cell_type": "markdown", + "id": "055a2526", + "metadata": {}, + "source": [ + "Scratch? Here is the solution. Pass below argument before plotting. Bigger value produces a higher quality of direct look and save as image. Usually 300 is enough." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c38fdc75", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib as mpl\n", + "mpl.rcParams['figure.dpi'] = 300" + ] + }, + { + "cell_type": "markdown", + "id": "75ba3055", + "metadata": {}, + "source": [ + "## Unsupported de Python Locale Solution" + ] + }, + { + "cell_type": "markdown", + "id": "120de0fb", + "metadata": {}, + "source": [ + "Not all environment support the de Python locale. So, the implementation of matplotlib axis formatter for comma thousand separator will not always work. The other implementation by directly draw string will always work. Just a little bit tricky to handle this by passing below argument before plotting." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4608ab69", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib as mpl\n", + "mpl.rcParams['axes.formatter.limits']=[-5,15]" + ] + }, + { + "cell_type": "markdown", + "id": "c396b8fb", + "metadata": {}, + "source": [ + "## Localized Seaborn Dependency" + ] + }, + { + "cell_type": "markdown", + "id": "a777f09d", + "metadata": {}, + "source": [ + "As the major update of seaborn comes, this is the best way to keep the production software work." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4714fe8a", + "metadata": {}, + "outputs": [], + "source": [ + "import grplot_seaborn as sns\n", + "sns.set_theme(context='notebook', style='darkgrid', palette='deep')" + ] + }, + { + "cell_type": "markdown", + "id": "2ddad3e9", + "metadata": {}, + "source": [ + "## Automatic Analytic Tool" + ] + }, + { + "cell_type": "markdown", + "id": "215344d8", + "metadata": {}, + "source": [ + "With great demand comes fresh idea." + ] + }, + { + "cell_type": "markdown", + "id": "ee78305e", + "metadata": {}, + "source": [ + "# Plot" + ] + }, { "cell_type": "markdown", "id": "15e79949", @@ -634,29 +760,31 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "id": "be977c67", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAFDCAYAAAAeSfYfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABOSElEQVR4nO3de1yUZd748c8MDKicQVARURAsNckDCpXar8xH97XpdjDQDF1RPEt4SkURSdAUAw+4pm3WNh5Qi8V2c9uedIu0B8zMMsLUDmKWOCIojJycuX9/uE5NoGIyMAzf9z/Pw33f1zXXl7v1y3Xd91xflaIoCkIIIYSwOuqmHoAQQggh6iZJWgghhLBSkqSFEEIIKyVJWgghhLBSkqSFEEIIKyVJWgghhLBSkqSFaGJVVVXs2bPnltd8+umnnDhx4qbns7KyWLNmzU3Pb9iwgZ07d9Y6PnPmTACioqL49ttvb3rdnfrpp584cOAAACkpKfz000933ecN27Zta7C+hLB2kqSFaGI6ne62Sfrtt9/mwoULDf7ZGRkZDd4nQG5uLkePHgVg8eLF+Pr6NljfmzZtarC+hLB29k09ACFauldeeYXTp0+TkZHBuHHjmD9/PuXl5RgMBp5//nlcXFz4+OOPyc/PJygoiAMHDvD+++9TUVGBh4dHvRPtBx98wL/+9S8qKytZsmQJISEhPPTQQxw6dOiW7Z566inWr1+Pn58f7733HkeOHOEPf/gDq1atwt7entatW7Nu3TqcnZ0BMBgMbNmyhcrKSvr06cMbb7zBsmXL2LdvH9999x3FxcVcuXKFJUuWEBoaavqcvLw81qxZg0ajISIiglatWrF9+3auXbuGSqUiIyODXbt2cfnyZZYtW8bixYtJTEzkzJkzGI1G4uLiCAsL+/03QggrJDNpIZrY1KlTCQoKYubMmWzatIkHH3yQ7du3s27dOhYvXkzPnj0ZNGgQ8+fPp3379pSWlvLGG2+wZ88eDAYDx48fr9fndOzYkTfffJOUlBQSExPrPb5Ro0aRnZ0NXF9Wj4iI4IMPPuAPf/gD27ZtY8yYMVy5csV0vZ2dHZMnT+bxxx9nyJAhZn21atWKN998k9TUVF588cVan1VVVcWOHTt44okn+OGHH9iyZQs7d+4kKCiIgwcPMm3aNNzc3Fi2bBl79uzBw8OD7du385e//KXO/oRo7mQmLYQV+fbbbxkxYgQA7dq1w9nZmeLiYtN5tVqNRqNhzpw5tGnThvPnz3Pt2rV69d2/f38AgoOD0el09R7TiBEjePbZZ3nmmWcoLy+nW7duTJ06lVdeeYXx48fTrl07QkJC6tVXeHi4aQwXL16sdT4gIMD0/3t5ebFgwQKcnJz47rvv6N27t9m1J0+e5LPPPuPLL78E4Nq1a1y6dAlPT896xyaEtZOZtBBNTK1WYzQaAejatStHjhwBoKioiCtXruDu7o5KpUJRFE6cOMEHH3zA2rVrSUhIwGg0Ut/t928ks2+++eaOnhG7uLhw3333sXLlSp566ikA3nnnHZ588km0Wi3BwcHs3r37pjH9Wn5+PnA9wbZr167WebX6+j9JZWVlrF+/nvT0dJKTk3F0dDTFeeP/BgYG8sc//hGtVsurr77K8OHDcXd3r3dcQjQHMpMWool5eXlRU1NDamoqU6ZMIT4+nn//+99UVlby4osvYm9vz/3338+aNWtIS0ujdevWjB49GgBvb+96v1D2448/Mm7cOKqrq+94afiZZ55h0qRJrFixAoCQkBCWLFlC69atUavVtfrr1q0bmzZtomfPnmbHCwoKGD9+PBUVFSxfvvymn+fs7Ezfvn2JjIzE3t4eV1dXU5xdu3Zl3rx5rFixgiVLlvDcc89RXl7Os88+a0ryQtgKlVTBEkI0hg0bNtC2bVvGjBnT1EMRotmQmbQQNmTmzJlcvnzZ7Jizs7N8bUmIZkpm0kIIIYSVsshMOi8vj7i4OIKCggDQ6/X4+fmxZs0aHBwcal1fUFDA8uXLsbOzw8HBgVWrVtG2bVs++ugjNm7ciKIo9OzZk8TERFQqlandmTNnWLhwISqViuDgYBITE1Gr1WRkZPDhhx9ib29PfHx8vd88FUIIIayJxd6yCA8PR6vVotVqycrKQqPRmLYJ/K2UlBQSEhLQarUMHTqUV199lfLyclJTU3nllVfYs2cPHTt2pKSkxKzdypUriYuLY8eOHSiKwv79+8nPz+fw4cPs2bOHtLQ0kpKSLBWiEEIIYVGN8ky6urqaCxcu4ObmxoQJE1Cr1eh0OiIjIxk7dixpaWn4+PgA13crcnR05PPPP6dbt26sWrWKs2fP8swzz9T6/mN+fj4DBgwAYPDgwRw6dIiAgAAGDhyISqXC19cXg8Eg350UQgjRLFksSefm5hIVFUVxcTFqtZqIiAjUajVFRUVkZ2djNBoZMWIEw4cPNyXoo0ePsm3bNrZv387BgwfJy8sjOzubNm3aMHbsWHr37m222YGiKKblbycnJ8rKyigvLzf7ruSN45KkhRBCNDcWS9Lh4eGkp6dTUlJCdHQ0fn5+APTp08f0XDo4OJjCwkK8vLzYt28fmzZtYsuWLXh6euLu7k6vXr3w9vYGIDQ0lIKCArMk/evvROr1elxdXXF2dkav15sdd3Fxqfe4S0r0GI22+y6dl5czxcXlTT0Mi5IYbUdLiFNibP7UahUeHk4W6dviy90eHh6kpqYybtw44uPjKSgowGAwUF1dzenTp+ncuTN79+5l165daLVa0yy4Z8+enDx5kkuXLuHq6soXX3xBRESEWd89evQgLy+PsLAwcnJyCA8Px9/fn9TUVCZOnMj58+cxGo13NIs2GhWbTtKAzccHEqMtaQlxSoziZhrlmXRQUBBRUVEkJyfj4+NDTEwMpaWlps3yU1JS6NChA7NmzQKu7zEcGxvL3LlzmTRpEgDDhw+nW7duFBQUkJWVxeLFi1mwYAEJCQmkpaURGBjIsGHDsLOzIzQ0lMjISIxGI0uXLm2MEIUQQogG16jfk87LyyMzM5P09PTf3cfVq1fZvHkzs2fPbsCR/aK4uNym/+Lz9nZBpytr6mFYlMRoO1pCnBJj86dWq/DycrZM3xbp1YIMBgMxMTFNPQwhhBDC4hp1W9CwsLC7Lsp+Jy+BCSGEaDxHjx5h6dJFdOkSgEqlQq/X4+vbkQ0b1tZ5/alT35CenoparcbBwYElS5Lw9PQCwGg0Mn9+HIMGDeaJJ0aZtTt58gQvvDAbP79OADz55CiGDPkf1q5dw/HjX9C6dWumTYulZ8/7LBpvY5C9u4UQQjSYfv1CSUpaafp52bLFHDhwgH79Hqp17bp1LzN79nyCg+8hO/tttm//G7NmzQHg1Vc3UVZ2pc7P+OabE0RGjmXMmOdMxw4d+pjCwjO8+urfuHLlCnPnzuK117QNHF3jkyQthBDCImpqaiguvoibmxtxcdNRq9UUFxczcuSTPP10BMuWraBt27bA9UeZDg6OAPznPx+gUqkIC3ugzn6/+aaAwsIzHDz4EX5+nXj++bn88MN3hIWFo1arcXd3/+9nXcTLq22jxWsJze6ZtBBCCOv12WdHmDlzMs899wzR0WMZPPgR1Go1Fy/qeOmlNLZseZ3du3dQUnLJlKCPH/+CrKzdREQ8y3ffneZ///ffTJo09aaf0b17T6ZPf56NG1/F17cjW7e+SnDwPeTl/R/Xrl3j3Lkf+eGH76isrGyssC1GZtJCCCEazI3l7suXS5k9ewYdOvgCcN99IaaNrAIDu3Lu3I94eHiyf//7vPnmVlavXouHhwc7d76JTneB2NipnD//M/b2Gtq39yU8/EHTZwwe/Ijp/aTBgx9h7dpUZs6Mo6Agn1mzJtOlS1fuuac7rq5ujf8LaGCSpIUQQjQ4Nzd3EhKWExs7lSVLFnPq1EkMBgM1NTV8//13+Pn58+9/72Pv3iw2bNhsSqjTpz9v6uO11zbj5eVllqAB5syZyezZ8+nR4z4+++ww99xzL4WFZ/DxacemTVspKjpPcnKiTbxoLElaCCGERQQEBDJqVCTJycl4erZl3rxYLl++zPjxE3FxcWHt2jW0a9ee+Pj5APTp04+JE6fU2depU9+wb98/ef75ucybt4i1a1djZ2ePl5cXL7ywGHt7DZs3Z/D3v7+Fg4MDc+YsaMxQLaZRNzNpDmQzk+ZPYrQdLSHOlhDjd999zd/+pjV76/tOVVRU8OabW5kyZUYDjqxhyGYmQgghWjSDwcBzz41v6mE0OlnuFkIIYVFhYWEEBva4qz6cnS0zU7V2MpMWQgghrJQkaSGEEMJKSZIWQghhHVRwpaKGQp2eK5XXQNXUA2p68kxaCCGauZsVtkhMTEaj0dS6/maFLd5+ezf/+tc/Ualg9OgohgwZataupOQSq1YlU1ZWhtFoYMmSF+nY0Y+dO7fxv//7Hmq1mqioCTz88CN3HoQKCgovs373MapqDDhq7IiN6E13fzew3S/c3JYkaSGEsAF1FbY4ePAjHnnksVrX1lXYIioqmuzst3j99R1UV1fx3HMRPProY6hUv0xn//KX9Qwd+geGDBnK0aNHOHPmB1xd3dizZye7dmVTUVHBhAnP/q4kfeVqjSlBA1TVGFi/+xirpj+Ia+vaf2i0FJKkhRDCxtwobOHi4lrvwhbu7u68/voO7O3t+fnnn3BwcDBL0HB9j+2uXYN4/vnpdOjQgeefn4dGo6F9+w5UVFRQWVmBWv37nqKWllebEvQNVTUGSvXVkqSFEEI0bzcKW5SWlqBSqRg58ilTYYutW7ejKEbGjRvNo48+VquwRUbGqwDY29vz9tu7eO21LYwaFVnrM37++SdcXFxZt+4vvP76q2zf/jf+/OdJ+Pi0IyrqGQwGI1FRf/5d43d3ccRRY2eWqB01drg7Ofyu/myFvDgmhBA2oF+/UDIytrBx46toNJpahS0cHVuZClsA7N//PmvWrDQVtrjh6acj2bv3Pb744nOOHj1i9hlubu4MHDgYgIceGsSJE1+Tm3uI4uKL7N79Dm+//U8+/vgjvv76qzsev2tre2IjeuOosQMwPZN2bdNyZ9EgSVoIIWzKjcIWq1YlU1x80VTYorKy0qywxdtv72bDhs107OgHQGHhD8THz0dRFOzt7dFoNLWWu0NC7uf//u8QAMeOfU5AQFdcXFxxdHT87x8Cjjg7O1NeXn7nA1egu78bq6Y/yLJJYaya/mCLf2kMZLlbCCFszo3CFuvWrcHLy7vehS2CgoKZMmUCKpWK8PAH6dOnn1lhi5kzZ/PSS8vJzn4bJydnEhOTcXV15ciRw0ye/GfUajUhIb3p3z/s9w1cAdfWml+eQbfwBA0WKrCRl5dHXFwcQUFBAOj1evz8/FizZo2pnuivFRQUsHz5cuzs7HBwcGDVqlWmZyZGo5HJkyczZMgQxowZY9buzJkzLFy4EJVKRXBwMImJiajVajIyMvjwww+xt7cnPj6ekJCQeo9dCmw0fxKj7WgJcVoyxqNHj7B379tNXtjC1u9jsyywER4ejlarRavVkpWVhUaj4cCBA3Vem5KSQkJCAlqtlqFDh/Lqq6+azq1du5YrV67U2W7lypXExcWxY8cOFEVh//795Ofnc/jwYfbs2UNaWhpJSUkWiU8IIVqCllrYwlo0ynJ3dXU1Fy5cwM3NjQkTJqBWq9HpdERGRjJ27FjS0tLw8fEBrv8H4ejoCMB7772HSqVi0KBBdfabn5/PgAEDABg8eDCHDh0iICCAgQMHolKp8PX1xWAwcOnSJTw9PRsjVCGEsBp9+4bSt2/oXfXxewtb/HqDFQcHe0pLr9xyg5Xvv/+O1atTAAU/P38WLFiCvb15itJqX+fgwRxqamp46qlRPP74E6Zz69e/jL9/Z554YtTvGq+1sliSzs3NJSoqiuLiYtRqNREREajVaoqKisjOzsZoNDJixAiGDx9uStBHjx5l27ZtbN++nZMnT/LPf/6T9evXs3Hjxjo/Q1EU04sNTk5OlJWVUV5ejru7u+maG8frm6QttWRhTby9XZp6CBYnMdqOlhCnLcbo7t6GBx98gPT0dNOxuXPn8uWXhxk+fHit6xMTN7NgwXz69+/PwoUL+eqrIwwd+suOZ3l5eZw8+TVvvbWbiooKtm7dire3C5cuXeKFF17ghx9+oEePe2zud2mxJB0eHk56ejolJSVER0fj53f9DcI+ffqYnksHBwdTWFiIl5cX+/btY9OmTWzZsgVPT0/++te/UlRUxPjx4zl37hwajYaOHTsyePBg02f8+kvzer0eV1dXnJ2d0ev1ZsddXOp/0+SZdPMnMdqOlhCnrcZYWnqVqqoadLoyvL1d+OmnS5w79zOKomHs2KhaG6wsXboCOzu7/153HoPBzuz38v77B/Dz60JMzBT0ej0zZjyPTlfGTz9d4LnnJpKbe4jy8som+V1a8pm0xZe7PTw8SE1NZdy4ccTHx1NQUIDBYKC6uprTp0/TuXNn9u7dy65du9BqtaZZ8AsvvGDqY8OGDbRt29YsQQP06NGDvLw8wsLCyMnJITw8HH9/f1JTU5k4cSLnz5/HaDTKUrcQQtyK6vq2nKXl1bi7OOLa2r5B3qy+scFKWdlljEbllhuseHh4cv78z8TFTcfJyZmgoGCzvi5fLuX8+Z9ZvXotP/98jgUL5rBjx9v4+nbE17cjubmH7n7AVqhRnkkHBQURFRVFcnIyPj4+xMTEUFpayrRp03BzcyMlJYUOHTowa9YsAPr3709sbGydfRUUFJCVlcXixYtZsGABCQkJpKWlERgYyLBhw7CzsyM0NJTIyEiMRiNLly5tjBCFEKJ5smBhixv7idvbX2PcuPG1NlgBTBuseHh40r59BzIz/84//pHNhg3pLFnyy4u/rq5u+Pt3QaPR4O/fBQcHR0pLS/DwsO1JmEWSdFhYGGFh5t+TmzZtGn379iUzM9PsGQXA4cOHb9nfjeQN0LlzZ9q0aQNAQEAA27Ztq/P6X7cRQghRt8YobOHh4UFCwnJiY6cSGzvHtMFKTU2NaYOVBQtmM3PmbDp18qdNmza19gAPCenNnj07GT16LMXFF6msrMDV1a1BxmfNmt1mJgaDgZiYmKYehhBC2ITGKmxxqw1W3N3dee65P7NixTLs7TW0atWKBQsSAEhMXERs7FweemgQX3xxlJiY8RiNRubMWYCdnV2Djc9aWWQzk+ZMXhxr/iRG29ES4mzqGK9UXmPBxkO1Cls05Ez61zHe6QYrmzdvZNy4aFq3bt0gY7GEZrmZiRBCCOtn7YUt/vSnp606QVtas1vuFkII0YB+VdiiVF+Nu5PD9QRtoQXFO91gpX379pYZSDMhSVoIIVo6KWxhtWS5WwghhLBSkqSFEEIIKyVJWgghhLBS8kxaCCFsyK+rT6lUKvR6/V1VnzIYDKxalczZs2cAFfPnLyIwMMh03larT1kLmUkLIYSN6dcvlIyMLWzYsJmtW7dhb2/PwYMf1Xntli0bmTJlBps2bQXg0KGPzc7f+HnTpq3ExExjy5a/AFBSUsLcubEcPJhjwUiEzKSFEMKG1dTUUFx8ERcXV+LipteqPpWcvBo7O7v/Xldcq3704MH/jwcfHAhAUdF5nJ2vVxWsqLhKdPRkmy1sYS0kSQshhI25UX2qtLQElUp1V9WnAOzt7UlOTiQn50OSk1cB2Hz1KWshy91CCGFjbix3b9z4KhqNplb1KUfHVqbqU4Cp+tQTTzzNhg3pdfa5ZEkSO3e+zapVyVRUVDRaLC2dJGkhhLBRbm7uJCQsZ9WqZIqLL5qqT1VWVppVnzp7thCgzupT7733Llrt6wC0atUKtVqNWq1q9FhaKlnuFkIIG3a31acefvhRVqxIYsaMGK5du0Zs7BwcHVs1cVQth1TB+g2pgtX8SYy2oyXE2VgxNmX1KVu/j1IFSwghRKNq6dWnrIUsdwshRAsg1aeaJ5lJCyGEEFZKkrQQQghhpSRJCyGEEFbKIs+k8/LyiIuLIyjo+ibser0ePz8/1qxZg4ODQ63rCwoKWL58OXZ2djg4OLBq1Sratm3LG2+8wbvvvgvAww8/zMyZM83anTlzhoULF6JSqQgODiYxMRG1Wk1GRgYffvgh9vb2xMfHExISYokwhRBCCIuy2Ew6PDwcrVaLVqslKysLjUbDgQMH6rw2JSWFhIQEtFotQ4cO5dVXX+Xs2bO88847ZGZmsnv3bg4ePMiJEyfM2q1cuZK4uDh27NiBoijs37+f/Px8Dh8+zJ49e0hLSyMpKclSIQohhBAW1Shvd1dXV3PhwgXc3NyYMGECarUanU5HZGQkY8eOJS0tDR8fH+B6WTRHR0fat2/PX//6V+zs7AC4du0ajo6OZv3m5+czYMAAAAYPHsyhQ4cICAhg4MCBqFQqfH19MRgMXLp0CU9Pz8YIVQghhGgwFkvSubm5REVFUVxcjFqtJiIiArVaTVFREdnZ2RiNRkaMGMHw4cNNCfro0aNs27aN7du3o9Fo8PT0RFEUVq9eTY8ePQgICDD7DEVRUKmub0/n5OREWVkZ5eXluLu7m665cVyStBBC1N+d1qU+deob0tNTUavVODg4sGRJEp6eXgBcunSJ0aMj+dvfdtaabP3441lSUpahUqkIDOzKnDkLTFuT/vjjWeLj5/Hmm7ssH7CVsliSDg8PJz09nZKSEqKjo/Hz8wOgT58+pufSwcHBFBYW4uXlxb59+9i0aRNbtmwxJdSqqiri4+NxcnIiMTGx1mf8eo9ZvV6Pq6srzs7O6PV6s+MuLi71Hreldo2xJt7e9f99NFcSo+1oCXFaY4zu7m148MEHSE//peDG3Llz+fLLwwwfPrzW9bNnr+XFF5fRvXt3MjMzycrayaJFi/j44495+eWXKSkpxtvbpVaSTkhYz/z5cwkLC2Pp0qV8+eVhhg4dSnZ2Nm+++SZXrly2yt9PY7H4creHhwepqamMGzeO+Ph4CgoKMBgMVFdXc/r0aTp37szevXvZtWsXWq3WNAtWFIXp06cTFhbG5MmT6+y7R48e5OXlERYWRk5ODuHh4fj7+5OamsrEiRM5f/48RqPxjmbRsi1o8ycx2o6WEKe1xlhaepWqqhrT2Gpqajh37mcURcPYsVG16lIvXryctm3botOVUVqqx2BQodOVUVZWyeuvv84TTzyJTleGo2O12eccP/4VAQHd0enK6N27P/v3f0Tv3uGAA2vXvkJk5BNW+fv5NUtuC9ooz6SDgoKIiooiOTkZHx8fYmJiKC0tZdq0abi5uZGSkkKHDh2YNWsWAP3796d79+4cPnyY6upqPv74YwDmzJlDq1atyMrKYvHixSxYsICEhATS0tIIDAxk2LBh2NnZERoaSmRkJEajkaVLlzZGiEIIYXPupC5127ZtATh+/AuysnaTkfEqAP37h+PhcfOZ8K8fW7Zp44ReXw7AQw8NsnB0zYNFknRYWBhhYWFmx6ZNm0bfvn3JzMw0Wz4BOHz4cJ39HD9+vNaxq1ev0qZNGwACAgLYtm1brWtmzZplSvhCCCF+n379QklKWsnly6XMnj2jVl1qwFSX2sPDk/373+fNN7eyevVaPDw86vUZv35sefWqHmdn23/keCea3WYmBoOBmJiYph6GEEK0GPWpS/3vf+/j7bd3s2HDZjp29Kt338HB93D06BEAcnM/4f77+1gqjGapUQts1DXDvlN38hKYEEKIhnGrutQuLi6sXbuGdu3aEx8/H4A+ffoxceKUOvs6deob9u37J88/P5eZM+NYvTqFzZs30rlzF/7f/xvSmGFZPakn/Rvy4ljzJzHajpYQZ3OL8U7rUkPtGCsqKnjzza1MmTLDEkNsdFJPWgghhM0wGAw899z4ph5GsyD1pIUQQtTbndalrou8HFZ/MpMWQgghrJQkaSGEEMJKSZIWQghhGSq4UlHD8dM6rlReA1VTD6j5kWfSQgghGp4KCgovs373MapqDDhq7IiN6E13fzew3S/QNDiZSQshhGhwV67WmBI0QFWNgfW7j3Hlak0Tj6x5kSQthBCiwZWWV5sS9A1VNQZK9dU3aSHqIklaCCFEg3N3ccRRY2d2zFFjh7uTQxONqHmSJC2EEKLBuba2JzaitylR33gm7dpG08Qja17kxTEhhBANT4Hu/m6smv4gV2sMtNHYXU/Q8tLYHZGZtBBCCMtQwLW1hl5dvXFtLQn695AkLYQQQlgpSdJCCCGElZIkLYQQQlgpeXFMCCHELR09eoSlSxfRpUsAKpUKvV6Pr29HEhOT0Whqv639/fffsXp1CqDg5+fPmjWral0THT2WNm2cAPD17Uh8fCJffXWcdevWYG9vR//+4URHT7Z0aFZPkrQQQojb6tcvlKSklaafly1bzMGDH/HII4/VunbLlo1MmTKD3r37kpKyjP/85z/07h1uOl9VVYWiKGRkbDFrt2bNSlJSVuPr25H585/n5MkTdOt2r+WCagYkSQshhLgjNTU1FBdfxMXFlbi46ajVaoqLixk58kmefjqC5OTV2NnZ/fe64lr1o0+fPkVlZSWzZ8/AYDAwefIMAgICqKmppmNHPwAGDHiAI0cOS5Ju6gEIIYSwfp99doSZMydTWlqCSqVi5MinUKvVXLyoY+vW7SiKkXHjRvPoo4/h4eHJ+fM/Exc3HScnZ+69916uXfulr1atWjFmTBQjRjzB2bOFzJsXS0bGFtPyN0CbNm346adzTRCpdbFIks7LyyMuLo6goCAA9Ho9fn5+rFmzBgeH2lvCFRQUsHz5cuzs7HBwcGDVqlW0bduW3bt3k5mZib29PdOmTeORRx4xa3fs2DFSUlKws7Nj4MCBzJw5E6PRyLJly/jmm29wcHAgOTmZzp07WyJMIYRoMW4sd1++XMrs2TPo0MEXgPvuCzH9ux4Y2JVz537Ew8OT9u07kJn5d/7xj2xeeukl5s1bYuqrUyd//Pz8UKlU+Pt3xs3NDaPRSEXFVdM1V69exdnZpXGDtEIWe7s7PDwcrVaLVqslKysLjUbDgQMH6rw2JSWFhIQEtFotQ4cO5dVXX0Wn06HVasnMzOS1114jLS2N6mrzjdkTExN5+eWX2blzJ1988QVff/01H3zwAdXV1ezatYu5c+fy0ksvWSpEIYRocdzc3ElIWM6qVckUF1/k1KmTGAwGKisr+f777/Dz82fBgtmcPVsIXJ8Rq9Xmqebdd99hw4a1AFy8qEOv19O2rTf29hrOnfsRRVE4fPj/uP/+Po0dntVplOXu6upqLly4gJubGxMmTECtVqPT6YiMjGTs2LGkpaXh4+MDgMFgwNHRkS+//JI+ffrg4OCAg4MD/v7+nDhxgpCQEADKy8uprq7G398fgIEDB/LJJ5+g0+kYNGgQAL179+arr75qjBCFEKLFCAgIZNSoSNatW4OXlzfz5sVy+fJlxo+fiLu7O88992dWrFiGvb2GVq1asXr19clSYuIiYmPn8vjjfyIlZRnTpk1EpVKxaNFS7O3tmTdvEUlJSzAajfTvH0bPnvc1caRNz2JJOjc3l6ioKIqLi1Gr1URERKBWqykqKiI7Oxuj0ciIESMYPny4KUEfPXqUbdu2sX37dj7++GNcXH5Z6nBycqK8vNz0c3l5udnLCE5OTpw9e7bWcTs7O65du4a9ff1C9fJyvv1FzZy3t+0vIUmMtqMlxGntMQ4b9gjDhpk/bpw3L45Bgx4gMzOT9PR0s3OPPjqQRx8dWKufoKBA/P3b0aZNGzZuXF/r/COPPMgjjzzYsINv5iyWpMPDw0lPT6ekpITo6Gj8/K6/sXdjdgwQHBxMYWEhXl5e7Nu3j02bNrFlyxY8PT1xdnZGr9eb+tPr9WZJu67zrq6uVFZWmh03Go31TtAAxcXlGI22u8Gst7cLOl1ZUw/DoiRG29ES4mzOMZaWXqWqqua2478R49ChI9DrDej1zTPem1GrVRab4Fl8xzEPDw9SU1NZsmQJOp2OgoICDAYDFRUVnD59ms6dO7N37162bduGVqulU6dOAISEhPDZZ59RVVVFWVkZ3377Ld26dTP16+zsjEajobCwEEVROHjwIKGhofTt25ecnBzg+otlv24jhBCi4fTta/7d6dtp3769BUdjmxrlmXRQUBBRUVEkJyfj4+NDTEwMpaWlTJs2DTc3N1JSUujQoQOzZs0CoH///sTGxhIVFcWzzz6LoijMnj0bR0dHcnJyOHHiBJMnTyYpKYl58+ZhMBgYOHAg999/P7169eLQoUOMHj0aRVFYsWJFY4QohBBCNDiVoiiNtrabl5dX5/OLO1FcXMyePXuYOnVqA47s1/3LcndzJzHajpYQp8TY/DXr5e6GpigK0dHRTT0MIYQQwuIadcexsLAwwsLC7qqPtm3bNtBohBBCCOvW7GbSQgghREshSVoIIYSwUpKkhRBCCCslSVoIIYSwUpKkhRBCCCslSVoIIYSwUpKkhRBCCCslSVoIIYSwUpKkhRBCCCslSVoIIYSwUpKkhRBCCCslSVoIIYSwUpKkhRBCCCslSVoIIYSwUpKkhRBCCCslSVoIIYSwUpKkhRBCCCslSVoIIYSwUpKkhRBCCCtlb4lO8/LyiIuLIygoCAC9Xo+fnx9r1qzBwcHhpu1WrFhBQEAAY8aMAWDr1q3885//RKVSMXXqVIYOHWp2/ZkzZ1i4cCEqlYrg4GASExNRq9VkZGTw4YcfYm9vT3x8PCEhIZYIUwghhLAoi82kw8PD0Wq1aLVasrKy0Gg0HDhwoM5rL126xKRJk8zOX7lyhTfffJPMzEy2bt3KihUrarVbuXIlcXFx7NixA0VR2L9/P/n5+Rw+fJg9e/aQlpZGUlKSpUIUQgghLOqWM+ldu3bd9FxkZGS9P6S6upoLFy7g5ubGhAkTUKvV6HQ6IiMjGTt2LHq9nlmzZpGTk2Nq07p1a3x9famoqKCiogKVSlWr3/z8fAYMGADA4MGDOXToEAEBAQwcOBCVSoWvry8Gg4FLly7h6elZ7/EKIYQQ1uCWSVqn0/3ujnNzc4mKiqK4uBi1Wk1ERARqtZqioiKys7MxGo2MGDGC4cOH06lTJzp16mSWpAE6dOjAH//4RwwGA1OmTKn1GYqimJK3k5MTZWVllJeX4+7ubrrmxvH6JmkvL+ffHbOlNdRjhK+/PsrGjRtRFIWePXuSmJho9kdQfn4+iYmJODg40L17dxYvXoxarSY5OZmjR4/i5OTEvHnzuP/++y0b8F3w9nZp6iFYXEuIEVpGnBKjuJlbJuk//vGPv7vj8PBw0tPTKSkpITo6Gj8/PwD69OljSijBwcEUFhbi5eVVq31OTg4XLlxg//79AEycOJG+ffuaPV9Wq39Zrdfr9bi6uuLs7Ixerzc77uJS//84iovLMRqVOwu2kZSWXqVPn34kJa00HVu2bDHZ2e/yyCOP1bq+pKSE5OREzp49w7PPRqHTldG6tYqVK19iw4YtuLu7s3373zh16iweHh6mdosWLSYubh69et3Pli1/YceOPTg7u/DNN6fZtOl1rly5wty5s3jtNW2jxH2nvL1d0OnKmnoYFtUSYoSWEafE2Pyp1SqLTfBumaSXLl2KSqVCUcyTlkql4s0336zXB3h4eJCamsq4ceOIj4+noKAAg8FAdXU1p0+fpnPnznW2c3Nzo1WrVjg4OKBSqXBxceHKlStm1/To0YO8vDzCwsLIyckhPDwcf39/UlNTmThxIufPn8doNNrsUndNTQ3FxRdxcXElLm46arWa4uJiRo58kqefjqCi4irR0ZPJzT1kavP5558TGBhERkY6P/10jhEjnjBL0AA63QV69bo+S+7V634OHvwIX9+OhIWFo1arcXd3/+9nXcTLq22jxiyEEC3JLZO0VtswM6WgoCCioqJITk7Gx8eHmJgYSktLmTZt2k0TaGhoKJ988olpmbxv37489NBDFBQUkJWVxeLFi1mwYAEJCQmkpaURGBjIsGHDsLOzIzQ0lMjISIxGI0uXLm2QGKzFZ58dYebMyZSWlqBSqRg58inUajUXL+rYunU7imJk3LjRPProY/j6dsTXt6NZki4pKeHzzz/j9de307p1G2bMmETPnr3w9//ljyVf3458/vln9OnTj0OHPqaysoLg4HvIzNzG009HUlR0nh9++I7Kysqm+BUIIUSLccskHRsby/r16xk4cGCtcwcPHrxpu7CwMMLCwsyOTZs2jb59+5KZmUl6enqd7WbNmlXr82NjY82Ode7cmTZt2gAQEBDAtm3b6uznt33Zin79QklKWsnly6XMnj2DDh18AbjvvhDTY4TAwK6cO/cjHh61/wByd3fn3nt7mGbA99/fl1OnTpol6fj4paxd+zJvvPFXQkJ64+CgYcCAcAoK8pk1azJdunTlnnu64+rq1ggRCyFEy3XLJL1+/Xrg1gm5sRkMBmJiYpp6GE3Ozc2dhITlxMZOJTZ2DqdOncRgMFBTU8P333+Hn59/ne169uzJ999/S2lpKc7OzuTnH2fkyCfMrvnkk4MkJi7Hzc2d9PTVhIc/SGHhGXx82rFp01aKis6TnJx4R8/6hRBC3Ll6bWZy/PhxEhMTuXjxIr6+vrz44ot069btjj+srhn2nZLE8IuAgEBGjYpk3bo1eHl5M29eLJcvX2b8+Ilmb7j/mpeXF1OmzGDOnJkAPProYwQGBnHq1Dfs2/dPnn9+Ln5+/jz//HRatWpFnz79eOCBgVRVVbF5cwZ///tbODg4MGfOgkaMVAghWiaV8tu3wuowevRokpOTCQoK4ptvviEpKYkdO3Y0xvganTW/3X0zR48eYe/et83e+r6Zm71lWVFRwZtvbmXKlBmWGGKjsvU3SaFlxAgtI06Jsfmz5Nvd9dpxzNHR0fTd3HvuuQeNRmORwYimYzAYeO658U09DCGEEL9Srx3H7O3tWbZsGf379+fLL7/E2dl6N/xoifr2DaVv39C76kPuqRBCWJ967TjWp08fAL7//ntcXFzo3r275UcmhBBCtHC3TNIzZ868ZeMZM2awcePGBh2QEEIIIa67qypYv90BTFg/o1HhSkUNhTo9VyqvQe26JUIIIazEXdWTrqsylbBiKvi/4z+TvvMoVTUGHDV2xEb0pru/GzSvF9qFEKJFsFg9aWF9rlytMSVogKoaA+t3H+PK1ZomHpkQQoi6SJJuQUrLq00J+oaqGgOl+uomGpEQQohbuask7eYmezc3J+4ujjhq7MyOOWrscHe6eS1qIYQQTeeWz6Rffvnlmz53njNnDhs2bLDIoIRluLa2Z/aYvrWeSbu20cgzaSGEsEK3TNKBgYGNNQ7RGBR4oFcH2ns8SKm+GncnB0nQQghhxW6ZpJ988kkArl27xvHjx7l27RqKonDhwoVGGZxoeGq1CtfWGlxb/3drV0nQQghhter1FayZM2dSU1PDhQsXMBgM+Pj48Pjjj1t6bEIIIUSLVq8Xx0pKSnjttdcICQkhKyuLqqoqS49LCCGEaPHqlaRbtWoFXC9n2KpVK9nERAghhGgE9Vru/p//+R82btzIvffeS0REBG3atLH0uMRtHD16hKVLF9GlSwAqlQq9Xo+vb0cSE5NvWUp0xYoVeHt34IknRpkdNxqNvPzyS5w+fQqNRsPChQn4+XUCrpexTExcxOOPP0F4+IMWjUsIIcQv6pWkhwwZQrt27VCpVDz88MPY29/VbqKigfTrF0pS0krTz8uWLebgwY945JHHal1bUlJCcnIiP/10lsjIsbXOf/zxh1RXV7N58+t89dVxMjLSeemlNM6d+5Hk5KVcuHCBxx9/wnLBCCGEqOWW2fbkyZMUFRWxZs0a5s+fD1yfVaWlpbF3795GGaCon5qaGoqLL+Li4kpc3HTUajXFxcWMHPkkTz8dQUXFVaKjJ3P8+JE623/55THCwh4A4L77enHiRAEAV69eZcGCBLZv/1ujxSKEEOK6WybpK1eusG/fPoqLi3n33XeB60U1nn322UYZnLi1zz47wsyZkyktLUGlUjFy5FOo1WouXtSxdet2FMXIuHGjefTRx/D17Yivb8ebJmm9Xo+Tk7PpZ7VazbVr1wgO7tZY4QghhPiNWybp0NBQQkNDyc/Pp2fPnly6dAl3d3fU6lu/b5aXl0dcXBxBQUHA9QTg5+fHmjVrcHC4+RaUK1asICAggDFjxgDw0UcfsXHjRhRFoWfPniQmJpq9tHbmzBkWLlyISqUiODiYxMRE1Go1GRkZfPjhh9jb2xMfH09ISEi9fyHNyY3l7suXS5k9ewYdOvgCcN99Iabfc2BgV86d+xEPD89b9uXk5MTVq1dNPyuKIo81hBCiidXr7e6ysjKGDBlCdHQ0jz32GIcOHbptm/DwcLRaLVqtlqysLDQaDQcOHKjz2kuXLjFp0iSz8+Xl5aSmpvLKK6+wZ88eOnbsSElJiVm7lStXEhcXx44dO1AUhf3795Ofn8/hw4fZs2cPaWlpJCUl1SfEZs3NzZ2EhOWsWpVMcfFFTp06icFgoLKyku+//w4/P//b9tGr1/3k5l6/r199dZzAwCBLD1sIIcRt1GuqtG7dOnbs2EG7du0oKipi5syZPPTQQ/X+kOrqai5cuICbmxsTJkxArVaj0+mIjIxk7Nix6PV6Zs2aRU5OjqnN559/Trdu3Vi1ahVnz57lmWeewdPTfDaYn5/PgAEDABg8eDCHDh0iICCAgQMHolKp8PX1xWAwcOnSpVptbU1AQCCjRkWybt0avLy8mTcvlsuXLzN+/ETc3d1v2i4xcRGxsXMZPPgRPv00j6lTo1EUhfj4xMYbvBBCiDrVK0nb2dnRrl07ANq1a4ejo+Nt2+Tm5hIVFUVxcTFqtZqIiAjUajVFRUVkZ2djNBoZMWIEw4cPp1OnTnTq1MksSZeUlJCXl0d2djZt2rRh7Nix9O7dm4CAANM1iqKYlr+dnJwoKyujvLzcLCndOF7fJO3l5Xz7i6zAsGGPMGzYI2bH5s2LY9CgB8jMzCQ9Pb3OdrNmzTL7OSgoEH//drRp04bVq1fW2QZg7dqX737Qjcjb26Wph2BxLSFGaBlxSoziZuqVpJ2dndFqtfTv359PP/30ljOzG8LDw0lPT6ekpITo6Gj8/PwA6NOnj+l5aXBwMIWFhXh5edVq7+7uTq9evfD29gauPx8vKCgwS9K/fjau1+txdXXF2dkZvV5vdtzFpf7/cRQXl2M0Nt8NrUtLr1JVVYNOV1bneW9vF7NzQ4eOQK83oNfXfX1z9NsYbVFLiBFaRpwSY/OnVqssNsGr1zPpXr168fPPP7N27Vp+/vnnO1o69vDwIDU1lSVLlqDT6SgoKMBgMFBRUcHp06fp3Llzne169uzJyZMnuXTpEteuXeOLL74wvYh2Q48ePcjLywMgJyeH0NBQ+vbty8GDBzEajfz0008YjUabX+r+tb59zb87fTvt27e34GiEEELcjVvOpPfs2cNbb73Ft99+S9euXQH49NNPuXbt2h19SFBQEFFRUSQnJ+Pj40NMTAylpaVMmzbtpgnUy8uLuXPnMmnSJACGDx9Ot27dKCgoICsri8WLF7NgwQISEhJIS0sjMDCQYcOGYWdnR2hoKJGRkRiNRpYuXXpHYxVCCCGshUpRlJuu7d544Wvz5s1MnToVuL7E7OXldcuvUt1MXl7eLZ+X1sfVq1fZvHkzs2fP/t193EpzX+6+HVtfdgKJ0Za0hDglxubPksvdt5xJOzg44Ofnx/Llyy3y4b+HwWAgJiamqYchhBBCWFyj7lYRFhZGWFjYXfVxJy+BCSGEEM1ZvV4cE0IIIUTjkyQthBBCWClJ0kIIIYSVkiQthBBCWClJ0kIIIYSVkiQthBBCWClJ0kIIIYSVkiQthBBCWClJ0kIIIYSVkiQthBBCWClJ0kIIIYSVkiQthBBCWClJ0kIIIYSVkiQthBBCWClJ0kIIIYSVkiQthBBCWClJ0kIIIYSVkiQthBBCWClJ0kIIIYSVsrdEp3l5ecTFxREUFASAXq/Hz8+PNWvW4ODgcNN2K1asICAggDFjxpiOGY1GJk+ezJAhQ8yOA5w5c4aFCxeiUqkIDg4mMTERtVpNRkYGH374Ifb29sTHxxMSEmKJMIUQQgiLsthMOjw8HK1Wi1arJSsrC41Gw4EDB+q89tKlS0yaNKnO82vXruXKlSt1tlu5ciVxcXHs2LEDRVHYv38/+fn5HD58mD179pCWlkZSUlKDxiWEEEI0FovMpH+rurqaCxcu4ObmxoQJE1Cr1eh0OiIjIxk7dix6vZ5Zs2aRk5Nj1u69995DpVIxaNCgOvvNz89nwIABAAwePJhDhw4REBDAwIEDUalU+Pr6YjAYuHTpEp6enhaPUwghhGhIFkvSubm5REVFUVxcjFqtJiIiArVaTVFREdnZ2RiNRkaMGMHw4cPp1KkTnTp1MkvSJ0+e5J///Cfr169n48aNdX6GoiioVCoAnJycKCsro7y8HHd3d9M1N47XN0l7eTn//qCbCW9vl6YegsVJjLajJcQpMYqbsViSDg8PJz09nZKSEqKjo/Hz8wOgT58+pufSwcHBFBYW4uXlVat9dnY2RUVFjB8/nnPnzqHRaOjYsSODBw82XaNW/7Jar9frcXV1xdnZGb1eb3bcxaX+/3EUF5djNCp3HG9z4e3tgk5X1tTDsCiJ0Xa0hDglxuZPrVZZbIJn8be7PTw8SE1NZcmSJeh0OgoKCjAYDFRUVHD69Gk6d+5cZ7sXXniBPXv2oNVqefLJJ/nzn/9slqABevToQV5eHgA5OTmEhobSt29fDh48iNFo5KeffsJoNMpStxBCiGapUZ5JBwUFERUVRXJyMj4+PsTExFBaWsq0adPuOIEWFBSQlZXF4sWLWbBgAQkJCaSlpREYGMiwYcOws7MjNDSUyMhIjEYjS5cutVBUQgghhGWpFEVptLXdvLw8MjMzSU9P/919XL16lc2bNzN79uwGHNkvZLm7+ZMYbUdLiFNibP6a9XJ3QzMYDMTExDT1MIQQQgiLa5Tl7hvCwsIICwu7qz7u5CUwIYQQojlrdjNpIYQQoqWQJC2EEEJYKUnSQgghhJWSJC2EEEJYKUnSQgghhJWSJC2EEEJYKUnSQgghhJWSJC2EEEJYKUnSQgghhJWSJC2EEEJYKUnSQgghhJWSJC2EEEJYKUnSQgghhJWSJC2EEEJYKUnSQgghhJWSJC2EEEJYKUnSQgghhJWSJC2EEEJYKUnSQgghhJWyt0SneXl5xMXFERQUBIBer8fPz481a9bg4OBw03YrVqwgICCAMWPGAPDGG2/w7rvvAvDwww8zc+ZMs+vPnDnDwoULUalUBAcHk5iYiFqtJiMjgw8//BB7e3vi4+MJCQmxRJhCCCGERVlsJh0eHo5Wq0Wr1ZKVlYVGo+HAgQN1Xnvp0iUmTZpkdv7s2bO88847ZGZmsnv3bg4ePMiJEyfM2q1cuZK4uDh27NiBoijs37+f/Px8Dh8+zJ49e0hLSyMpKclSIQohhBAWZZGZ9G9VV1dz4cIF3NzcmDBhAmq1Gp1OR2RkJGPHjkWv1zNr1ixycnJMbdq3b89f//pX7OzsALh27RqOjo5m/ebn5zNgwAAABg8ezKFDhwgICGDgwIGoVCp8fX0xGAxcunQJT0/PxghVCCGEaDAWS9K5ublERUVRXFyMWq0mIiICtVpNUVER2dnZGI1GRowYwfDhw+nUqROdOnUyS9IajQZPT08URWH16tX06NGDgIAAs89QFAWVSgWAk5MTZWVllJeX4+7ubrrmxnFJ0kIIIZobiyXp8PBw0tPTKSkpITo6Gj8/PwD69Oljei4dHBxMYWEhXl5edfZRVVVFfHw8Tk5OJCYm1jqvVv+yWq/X63F1dcXZ2Rm9Xm923MXFpd7j9vJyrve1zZW3d/1/H82VxGg7WkKcEqO4GYsvd3t4eJCamsq4ceOIj4+noKAAg8FAdXU1p0+fpnPnznW2UxSF6dOnExYWxuTJk+u8pkePHuTl5REWFkZOTg7h4eH4+/uTmprKxIkTOX/+PEaj8Y5m0cXF5RiNyu+KtTnw9nZBpytr6mFYlMRoO1pCnBJj86dWqyw2wWuUZ9JBQUFERUWRnJyMj48PMTExlJaWMm3atJsm0A8++IDDhw9TXV3Nxx9/DMCcOXNo1aoVWVlZLF68mAULFpCQkEBaWhqBgYEMGzYMOzs7QkNDiYyMxGg0snTp0sYIUQghhGhwKkVRGm3amJeXR2ZmJunp6b+7j6tXr7J582Zmz57dgCP7hcykmz+J0Xa0hDglxubPkjPpZreZicFgICYmpqmHIYQQQlhcoyx33xAWFkZYWNhd9XEnL4EJIYQQzVmzm0kLIYQQLYUkaSGEEMJKSZIWQgghrFSjPpMWorEcPXqEpUsX0aVLACqVCr1ej69vRxITk9FoNDdtt379y/j7d+aJJ0YB8M47f2fv3izs7OwYP34iDz00yOz6L774nIyMtahUKnr37sv06bGmc5WVlUydGs3UqTMJD3/QMoEKIWyazKSFzerXL5SMjC1s2LCZrVu3YW9vz8GDH9V5bUlJCXPnxnLw4C9b0xYXX+SttzLZtOk10tIy2Lw5g+rqarN269a9TFLSCrZseYOCgnxOnvylCExa2ir+u2utEEL8LjKTFi1CTU0NxcUXcXFxJS5uOmq1muLiYkaOfJKnn46gouIq0dGTyc09ZGpTUJBPr1734+DggIODAx07duLbb0/RvXtP0zVbtryBvb09V69eRa8vp3XrNgDs2KHlvvtCaMRtCIQQNkiStLBZn312hJkzJ1NaWoJKpWLkyKdQq9VcvKhj69btKIqRceNG8+ijj+Hr2xFf345mSVqv1+Pk9MsGBW3atKG8vNzsM+zt7fnqq+MsWxZPly4B+Pj4cOTIYX78sZAXXljM8eNfNFq8QgjbI0la2Kx+/UJJSlrJ5culzJ49gw4dfAG4774QU5GXwMCunDv3Ix4etbendXJy4urVq6afr169Wuf39O+7rxdvvfUPtmz5C9u2/Y2zZwspKvqZmTMnU1h4hpMnT+Dl5UVw8D0WilQIYavkmbSweW5u7iQkLGfVqmSKiy9y6tRJDAYDlZWVfP/9d/j5+dfZrnv3nnz55edUVVVRXl7OmTPfExDQ1XT+ehGYSVy5cgW4PtNWqVQsW5bCpk1bycjYQljYA0ybFisJWgjxu8hMWrQIAQGBjBoVybp1a/Dy8mbevFguX77M+PETzeqP/5qXV1tGjRrNjBkxGI1GJk+ejqOjI7m5n3Dq1Emiov7MmDHPMW9eLA4ODnh5ebFgQULjBiaEsGmNWmCjOZACG83frWI8evQIe/e+TVLSyt/df0nJJf7xj2zGjYv+3X3crZZwH6FlxCkxNn9SYEMIK6IoCmPGRDX1MIQQLYAsd4sWpW/fUPr2Db2rPjw9vRpoNEIIcWsykxZCCCGslCRpIYQQwkpJkhaiLiq4UlFDoU7PlcprINt7CiGagDyTFuK3VFBQeJn1u49RVWPAUWNHbERvuvu7ge2++C+EsEIykxbiN65crTElaICqGgPrdx/jytWaJh6ZEKKlkSQtxG+UllebEvQNVTUGSvXVN2khhBCWIUlaiN9wd3HEUWNndsxRY4e7k0MTjUgI0VJZJEnn5eXxwAMPEBUVRVRUFE899RSxsbG1avH+1ooVK9i5c6fp5927d/PUU08RERHBf/7zn1rXHzt2jGeeeYbRo0eTkZEBgNFoZOnSpURGRhIVFcWZM2caNjhh81xb2xMb0duUqG88k3Zto2nikQkhWhqLvTgWHh5Oenq66ee5c+dy4MABhg8fXuvaS5cu8cILL/DDDz8wceJEAHQ6HVqtlrfffpuqqiqeffZZHnroIVP1IoDExEQ2bNhAp06dmDx5Ml9//TU//vgj1dXV7Nq1i2PHjvHSSy+xadMmS4UpbJEC3f3dWDX9QUr11bg7OVxP0PLSmBCikTXK293V1dVcuHABNzc3JkyYgFqtRqfTERkZydixY9Hr9cyaNYucnBxTmy+//JI+ffrg4OCAg4MD/v7+nDhxgpCQEADKy8uprq7G3/96BaOBAwfyySefoNPpGDRoEAC9e/fmq6++aowQha1RwLW1BtfWGtPPQgjR2CyWpHNzc4mKiqK4uBi1Wk1ERARqtZqioiKys7MxGo2MGDGC4cOH06lTJzp16mSWpMvLy81q9zo5OVFeXm523tnZ2ez82bNnax23s7Pj2rVr2NvXL1RLbZJuTby9a9dEtjUSo+1oCXFKjOJmLL7cXVJSQnR0NH5+fgCm2TFAcHAwhYWFeHnV3gvZ2dkZvV5v+lmv15sl7brOu7q6UllZaXbcaDTWO0GDVMGyBRKj7WgJcUqMzV+zroLl4eFBamoqS5YsQafTUVBQgMFgoKKigtOnT9O5c+c624WEhPDZZ59RVVVFWVkZ3377Ld26dTOdd3Z2RqPRUFhYiKIoHDx4kNDQUPr27WuakR87dsysjRBCCNGcNMoz6aCgIKKiokhOTsbHx4eYmBhKS0uZNm0anp6edbbx9vYmKiqKZ599FkVRmD17No6OjuTk5HDixAkmT55MUlIS8+bNw2AwMHDgQO6//3569erFoUOHGD16NIqisGLFisYIUVipo0ePsHTpIrp0CUClUqHX6/H17UhiYjIazc3f1l6//mX8/TvzxBOjap3Tal/n4MEcampqeOqpUTz++BOUlFxi1apkysrKMBoNLFnyIh07+lkyNCFEC6BSFKXR1nbz8vLIzMw0e+v7ThUXF7Nnzx6mTp3agCP7df+y3N3c/TrGo0ePsHfv2yQlrTSdX7ZsMQ8//AiPPPJYrbYlJSUkJydy9uwZnn02qlaSPnr0CJmZ23nppZeprKxk504tEydOISVlGeHhDzFkyFCOHj1CZWUlDz44sFFitGUtIU6Jsfmz5HJ3s9u7W1EUoqOjm3oYopmqqamhuPgiLi6uxMVNR61WU1xczMiRT/L00xFUVFwlOnoyubmH6mx/+HAuXbsGER8/D71ez4wZzwNw/PgXdO0axPPPT6dDhw48//y8xgxLCGGjGjVJh4WFERYWdld9tG3btoFGI1qKzz47wsyZkyktLUGlUjFy5FOo1WouXtSxdet2FMXIuHGjefTRx/D17Yivb8ebJunLl0s5f/5nVq9ey88/n2PBgjns2PE2P//8Ey4urqxb9xdef/1Vtm//G5MmWWa1RwjRcsi2oMLm9esXSkbGFjZufBWNRkOHDr4A3HdfCA4ODjg6tiIwsCvnzv14275cXd0YMOABNBoN/v5dcHBwpLS0BDc3dwYOHAzAQw8N4sSJry0akxCiZZAkLVoMNzd3EhKWs2pVMsXFFzl16iQGg4HKykq+//47/Pz8b9tHSEhv8vI+QVEULl7UUVlZgaurGyEh9/N//3d99n3s2OcEBHS1dDhCiBag2T2TFuJuBAQEMmpUJOvWrcHLy5t582K5fPky48dPxN3d/abtEhMXERs7l4ceGsQXXxwlJmY8RqOROXMWYGdnx8yZs3nppeVkZ7+Nk5MziYnJjReUEMJmNerb3c2BvN3d/NUnxrre+r6VzZs3Mm5cNK1bt26IId61lnAfoWXEKTE2f816MxMhbMGf/vS01SRoIUTLIcvdokXq2zeUvn1D6319+/btLTgaIYSom8ykhRBCCCslSVoIIYSwUpKkhRBCCCslSVoIIYSwUpKkhRBCCCslSVoIIYSwUpKkhRBCCCslSVoIIYSwUpKkhRBCCCslSVoIIYSwUpKkhRBCCCslSVoIIYSwUpKkhRBCCCvVqFWw8vLyiIuLIygoCAC9Xo+fnx9r1qzBwcGh1vUFBQUkJiZiZ2dHly5dSElJQa3+5e8Ko9HIsmXL+Oabb3BwcCA5OZnOnTtz7NgxUlJSsLOzY+DAgcycObPRYhRCCCEaSqPPpMPDw9FqtWi1WrKystBoNBw4cKDOazMyMpgxYwY7d+6kurqaDz/80Oz8Bx98QHV1Nbt27WLu3Lm89NJLACQmJvLyyy+zc+dOvvjiC77++mtLhyWEEEI0uCatJ11dXc2FCxdwc3NjwoQJqNVqdDodkZGRjB07lu7du1NaWoqiKOj1euztzYf72WefMWjQIAB69+7NV199RXl5OdXV1fj7+wMwcOBAPvnkE3r06FGvManVqoYN0gpJjLahJcQILSNOibF5s2RsjZ6kc3NziYqKori4GLVaTUREBGq1mqKiIrKzszEajYwYMYLhw4fTpUsXXnzxRTZt2oSLiwthYWFmfZWXl+Ps7Gz62c7OrtYxJycnzp49W+/xeXg43X2QVs7Ly/n2FzVzEqPtaAlxSoziZppsuXv79u1oNBr8/PwA6NOnDw4ODrRq1Yrg4GAKCwtJSUlh+/btvPfeezzxxBOm5ewbnJ2d0ev1pp+NRmOtY3q9HldX18YJTgghhGhATfZ2t4eHB6mpqSxZsgSdTkdBQQEGg4GKigpOnz5N586dcXNzM82KfXx8uHLlilkfffv2JScnB4Bjx47RrVs3nJ2d0Wg0FBYWoigKBw8eJDQ0tNHjE0IIIe5Wkz6TDgoKIioqiuTkZHx8fIiJiaG0tJRp06bh6elJcnIys2fPxt7eHo1Gw/LlywGYPXs28fHxDB06lEOHDjF69GgURWHFihUAJCUlMW/ePAwGAwMHDuT+++9vyjCFEEKI30WlKIrS1IPIy8sjMzOT9PT0el2flpbG1KlTadOmjYVHJoQQQjSdZrmZyejRoyVBCyGEsHlWMZMWQgghRG3NciYthBBCtASSpIUQQggrJUlaCCGEsFJN+hUsS7jTIh5nzpxh4cKFqFQqgoODSUxMNCvioSgKgwcPpkuXLsD17Ufnzp3LgQMH2LhxI/b29jz99NNEREQ0Snxw5zHesGLFCgICAhgzZozZcWssVNLQMQI8+eSTpu/d+/n5sXLlymYVY0FBAcuXL8fOzg4HBwdWrVpF27ZtTedt4T7eLkZo/vfx9OnTJCQkoCgKXbp0ITk52WzLY1u4j7eLEZr/fbzhH//4B9u2bWPXrl1mxxvsPio2Jjc3V4mLizM7NmfOHOVf//pXnddPmTJFyc3NVRRFURISEpT333/f7PwPP/ygTJkyxexYdXW18thjjymlpaVKVVWV8tRTTyk6na4Bo7i1O42xuLhYmThxojJkyBBlx44dtc7/+9//VhYsWKAoiqJ8/vnnytSpUxVFUZSRI0cqZ86cUYxGozJp0iQlPz+/gSO5uYaOsbKyUvnTn/5U63hzinHs2LHK119/rSiKouzcuVNZsWKF2XlbuI+3i9EW7uO0adOUw4cPK4qiKAsWLKj1b44t3MfbxWgL91FRFCU/P18ZN26c8swzz9Q611D30eZm0r91uyIe+fn5DBgwAIDBgwdz6NAhhg4damqfn59PUVERUVFRtGrVikWLFpkKeLi5uQHQr18/Pv30U/7whz9YZYx6vZ5Zs2aZdmf7LUsUKmlodxvjiRMnqKioIDo6mmvXrjFnzhyCgoKaVYxpaWn4+PgAYDAYcHR0NGtvC/fxdjHawn3csGEDdnZ2VFdXo9PpzGoNgG3cx9vFaAv3saSkhLS0NOLj40lISKjVvqHuo00m6Tsp4qEoCirV9QomTk5OlJWVmfXl7e3N5MmT+cMf/sCRI0eYP38+ixYtwsXFxXSNk5MT5eXlVhtjp06d6NSp000TmCUKlTSEhoyxVatWTJw4kWeeeYYffviBmJgYtm3b1qxivJG8jh49yrZt29i+fbtZX7ZwH28Xoy3cRy8vL86dO8eECRNwdnbm3nvvNevLFu7j7WJs7vdx2LBhLF26lEWLFtX6Q/KGhrqPNvni2J0U8fj18+e6inHcd999DBkyBIDQ0FAuXLhQZxGPXyftxnAnMd6OtRYqacgYAwICGDlyJCqVioCAANzd3TEYDM0uxn379pGYmMiWLVvw9PQ068tW7uOtYrSV+9ixY0fef/99xowZ02wKBzVkjM39Pn733XecOXOGZcuWMWfOHE6fPk1KSopZXw11H20ySd9QnyIePXr0IC8vD4CcnJxaxTgyMjL429/+BlxfounQoQNdu3blzJkzlJaWUl1dzZEjR+jTp0+jxwf1i/F2rL1QSUPE+NZbb5n+oSgqKqK8vJx27do1qxj37t3Ltm3b0Gq1dOrUqVYftnAfbxejLdzHqVOn8sMPPwDXZ1K/niiAbdzH28XY3O9jUFAQ7777LlqtlrS0NIKCgli8eLFZHw11H21yufvXblfEY8GCBSQkJJCWlkZgYCDDhg0DICoqCq1Wy+TJk5k/fz4fffQRdnZ2rFy5Eo1Gw8KFC5k4cSKKovD000/Trl07q43xZppToZK7jXHUqFEsWrSIMWPGoFKpWLFiBfb29s0mRjc3N1JSUujQoQOzZs0CoH///sTGxtrMfaxPjM39Pnp6ejJ58mQWLlyIRqOhdevWJCcnA7b1v8fbxWgL9/FmGvw+1uOlN5tQ15t7t5KcnGzB0VjGncb48ssvK3q93oIjangSY20So3WSGGuTGO+cTS93343o6OimHoLFtYRCJRKjbZAYbYPEeOekwIYQQghhpWQmLYQQQlgpSdJCCCGElZIkLYQQQlgpm/8KlhDizlVVVfHOO+9gZ2eHm5ubaUMfIUTjkiQthKhFp9OxZ88edu/e3dRDEaJFkyQthKjllVde4fTp09x7770kJiYSGBjIK6+8UqvIgBDCsiRJCyFqmTp1KidPnjRV8QFuWkhBCGE58uKYEKJefk9hEyHE3ZGZtBCiFrVajdFoNDt2o8hAdXV1vQubCCHujiRpIUQtXl5e1NTUUFlZaTp27dq1ehcZEEI0DNkWVAhxW3l5eWRmZpKent7UQxGiRZFn0kIIIYSVkpm0EEIIYaVkJi2EEEJYKUnSQgghhJWSJC2EEEJYKUnSQgghhJWSJC2EEEJYKUnSQgghhJX6/1c5qVG5MaQxAAAAAElFTkSuQmCC\n", + "image/png": "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", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='scatterplot', \n", + "ax = plot2d(plot='scatterplot', \n", " df=tips.head(5), \n", " x='tip', \n", " y='total_bill', \n", @@ -1181,7 +1309,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "id": "d278aaa7", "metadata": { "scrolled": false @@ -1189,7 +1317,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcQAAAFDCAYAAACk6n5/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABjG0lEQVR4nO3ddXyV9fvH8deJdRcwcmOEdA0QSSVGSEiMkppIjxJJyUmMlFBCJH50g4LAAAkJRYkhiAIDpo5c99mJ+/fHkfmdgA5ZsO16Ph4+5PR1X5zx3v257/vzUSmKoiCEEEIUcOrcLkAIIYR4FUggCiGEEEggCiGEEIAEohBCCAFIIAohhBCABKIQQggBSCAKIYQQgASiEEIIAYA2twsQIrfs3r2b48ePk5qayuPHj+nduzfHjh3j5s2bjB07lmbNmrFx40ZCQkJISUnBxcWFZcuWMWHCBNq2bUuTJk0ICwsjODiYVatWpb/v+PHjURSF+/fvk5ycTHBwMD4+PixYsICrV68SGxvLa6+9xuzZs7lw4QLBwcFotVpsbGxYvHgxjx8/ZsKECWi1WkwmEwsWLMDT05MFCxbw448/YjKZ6Nu3L61ataJXr1689tpr3Lx5k8TERBYvXkyxYsX49NNPOXr0KK6urqSkpDBixAgqVqzIpEmTiImJAeCjjz6ifPnyvPnmm5QuXRofHx98fX35/PPP0Wq1FCpUiEWLFqFWm39vjo6OpmfPnnz99deoVCpmzJhBvXr1ePToEXv37kWtVlOlShU++uij9F7cuXOHDz/8kJ07dwIwcuRIAgICSE1NZdGiRWg0GkqUKMGMGTPQ6XRMmjSJhIQEHj16RI8ePejRowe9evXC1dWVuLg4vvjiCzQaTQ5+S0SBoghRQO3atUvp16+foiiKsn//fqVz586KyWRSzp07pwwePFgxGo3K0qVLFaPRqCiKogQEBCg//vijcu7cOWX48OGKoijKnDlzlMOHD2d433HjxilLly5VFEVRTpw4oQwcOFBJSEhQVq1apSiKohiNRqVly5bKgwcPlDlz5ihr1qxRjEajcuTIESUiIkLZuHGjMnPmTCUtLU05e/as8uuvvyonTpxQRo4cqSiKoqSmpirt2rVT4uLilHfffVf58ssvFUVRlIULFyorV65Url+/rnTt2lUxGAxKSkqK0qxZM+W7775T5s6dq2zatElRFEW5c+eO0q1bN0VRFKV8+fJKdHS0oiiKEhgYqBw8eFBRFEXZs2ePEhcXl2HbRowYoZw/f17R6XRK69atFb1er3Ts2FEJDQ1VFEVRNm3apOj1+gyv6dmzp3Lz5k0lJiZG6dSpk2IymZQWLVookZGRiqIoyqJFi5Rt27YpV69eTe/lgwcPlObNmyuKoijvvvuuEhIS8l/+ioV4IbKHKAq0ChUqAODg4ICPjw8qlQonJyd0Oh1qtRoLCwtGjx6Nra0tDx48wGAwULduXT7++GOio6M5c+YMo0ePfup9X3/9dQBq1KjBrFmzsLKyIjo6Ov29kpOT0ev1DBo0iBUrVtCnTx8KFy5M1apV6dy5M59//jn9+/fHwcGBUaNGcePGDa5du0avXr0AMBgMREREAFCxYkUAihQpQmRkJGFhYVSpUgWNRoNGo6Fy5coA3Lhxg++++46DBw8CEBcXB4CLiwsuLi4ATJgwgZUrV7Jx40ZKly5Ns2bNMmyXv78/e/bs4fHjx7z11ltotVpmz57NmjVrmDt3LtWrV0f522yQXbp0Yffu3RQtWpR27doRHR3No0ePGDlyJACpqam88cYbNG7cmPXr1xMSEoK9vT0GgyH9Pby9vf/j37AQmSfHEEWBplKpnvvYL7/8wtGjR/nkk0+YPHkyJpMJRVFQqVS0a9eOjz/+mPr162NhYfHUa69duwbAxYsXKVu2LKdOneL+/fssXLiQ0aNHk5qaiqIofPnll7zzzjts2LCBsmXLsn37do4dO0atWrVYv349LVu2ZPXq1ZQuXZq6deuyYcMG1q9fT6tWrShRosQz6y5Tpgw//fQTJpOJtLQ0fv75ZwBKly5N37592bBhA5988gnt2rUDSB8SBdi2bRuBgYFs3LgRgCNHjmR473r16nH9+nV27dpFly5dANi+fTvTp09n48aNXL9+nUuXLmV4TcuWLTlz5gxHjhyhXbt2uLi4UKRIET777DM2bNjAoEGDeP3111mzZg3Vq1dn/vz5tGzZMkOw/tPfkxBZRfYQhXiOUqVKYWNjQ7du3QDw8PDg0aNHAHTs2JEmTZqwb9++Z7721KlTHDt2DJPJxOzZs7G2tuazzz6jZ8+eqFQqSpQowaNHj6hatSofffQRNjY2qNVqZsyYgaIojBs3juXLl2MymZgwYQIVK1bk/Pnz9OjRg+TkZJo1a4a9vf0zP7t8+fI0btwYf39/XFxcsLCwQKvVMmjQICZNmsT27dtJTExk2LBhT722atWqDBw4EDs7O2xtbWnSpEmGx1UqFX5+fpw9e5aSJUumf16PHj2ws7OjcOHCVKtWLcNrrKysqF27NtHR0Tg7OwMwadIkBgwYgKIo2NnZMXfuXFQqFR9//DFff/01Dg4OaDQa0tLSMv33JcTLUil/H98QQvyrhw8fMnbsWNavX//UY+PHj6d169Y0atQoFyqDqKgoDh06RM+ePUlLS6NNmzasX7+eokWL5ko9ANOnT6dFixbUq1cv12oQ4t/IHqIQLygkJISlS5cybdq03C7lmVxcXLh69SqdOnVCpVLRpUuXXA3DgIAAXFxcJAzFK0/2EIUQQgjkpBohhBACkEAUQgjxCrl58yYVKlTgxIkTNGnSBF9fX3x9falYsWL6SV6dOnWiRo0aVK9enbFjx2bZZ0sgCiGEeCUkJyfTr1+/9EuBTpw4wY8//siePXvQarV89tlnrF27locPH3Lp0iVOnz7NgQMH+P3337Pk8yUQhRBCvBK6d+9Oz549sbGxyXD/0KFDadWqFRUrVqRTp05s2bIFMF8GpCgK1tbWWfL5efos05iYJEymvH9OkJubPVFRibldRq6TPphJH8ykD2YFpQ+zZs3Azs4Rf/9erF69mvj4VKKiErl9O4zbt2+zc+fOP/ugxtbWhYiIx3Tv3platWqjVttkukdqtQoXF7tnPpanA9FkUvJFIAL5ZjtelvTBTPpgJn0wKwh9OH78KKCiefPGJCUlMnnyOFasWMP//d9aqlWrgaWlJSaTDoCIiAj693+XcuVeY+HCZVnWnzwdiEIIIfKHw4dPpv/Zz68J06bNpEyZcoSGXmLo0BHpj8XHx9G7tz+tW7flgw/GZ2kNcgxRCCHEKys+Po4qVaqn3541y7xUWEjIIfz8muDn14TLly9myWfl6Qvzo6ISM+wqG40GYmIeYzDkrfkP1Wo1JpMpt8vINVqtJS4uHhQp4sLjxwm5XU6u8/BwkD4gfXhC+mCWVX1Qq1W4uT17HuB8NWQaE/MYa2tb7OyK5KnZ8bVaNQZDwQxERVFISoonJuYxRYq45HY5QogCLF8NmRoMadjZOeapMCzoVCoVdnaOeW6vXgiR/+SrQARZNy0vkr8zIcSrIN8FYn4UHx9HSMihf31eTEwM3bp1RKczn5qcmJjI2LGjGDZsAAMH9uPq1SvZXaoQQmQtFcSn6Pnp1mPiUw2Qjb8/56tjiPnVrVs3OXPmJC1atHzuc77//hwrViwlOjoq/b5t2zbh61sbf/8e/PbbXaZNm8SaNZtyomQhhHh5Krj+WxxLtl9GpzdiZaFhuH91KpR0gmw4HVQCMQvpdKnMmjWdBw8eoNfrGT16LK+9VpFZs6Zz714ERqORbt160rRpC4YNG8CHH06kVCkvdu/eyePHj2ndui3Tpk2iUKHCRET8QcWKlRgzZgL/939ruHXrJvv27aZ48RJcuXKZfv3ez/DZarWKTz75jPfe65V+n79/DywtLQAwGIxYWlrlaD+EEOJlxCfr08MQQKc3smT7ZYKHvIGjjUWWf54EYhbau3cXRYoUZfr02fz++2+cO3eaX3+9jrOzM1OmBJGcnERAwLvUqlXnue/x+++/sWjRMqysrPH3b09UVCS9ewewb98u2rfvCECtWrWfel3t2q8/dZ+DgwMAUVGRBAVNZvjwD7JoS4UQIvvFJqalh+ETOr2R2KS0bAlEOYaYhX77LZzKlasAUKJESfz9e3D37l2qVasJgK2tHV5e3kRE/JHhdf97KWixYsWxtbVDo9Hg5uZOWtrLnX0ZFnaLESOGMGDAUGrUqPVS7yWEEDnJ0kKNlYUmw31WFhqc7Syz5fMkELNQqVLeXL/+MwAREX8wbdokvLy8uHLlEgDJyUmEhYVRtGhRLC2tiIqKBODXX39Jf49nnXFpvnD/xQfM79y5zeTJ45g69WPq1av/XzZJCCFyRWRsCp/vu0r3FuXTQ/HJMURH26zfOwQZMs1S7dt3ZPbsGQwbNgCj0ciIER/g41OW4OCPGTz4PXQ6HQEB7+Pi4kqXLl1ZsGAOhQsXoVChQv/4vsWKFef27Vts374ZH5+yzzyG+CwrVy4jLS2NxYvnA2Bvb8+cOQuzZFuFECK7xCWlMX/bZRKT9ZQt5kDwkDdI1huxtdCYwzCb5lfLV1O3PXgQTpEipXKxov+mIM9U88SDB+FUqVJZpqhCpup6QvpgVtD6kJyqJ3jzJR7GJDOmWw3KFHMCcmbqNhkyFUII8UrQ6Y0s3nmFe5FJDOtYJT0Mc4oEohBCiFy1f/8+/PyasHzvVS58f5ywQx8xemBH+vTphsFgAGDSpEk0a9aQpk0bMGLEYADCw8Np3fotWrRoTMeObYiNjX2pOiQQhRBC5JoxY4azYEEwujQ9V8KiiLq6h+HDRxMSchJbWzsWLZrHhQs/cODAAXbv3s/hwyfQ6/WkpqYydep4GjV6k5CQk3h5lWbOnKCXqkUCUQghRK7x8ipNC//RGE0KnRqXxmBIo0OHTgDUqfM6oaEX2b9/H8WLF6dPn+60bt2UOnVex9ramt9//43OnbsC0KZNu5eenlICUQghRK4pXq0dobdj0WpUtH69FNbWNmzfvgWAb745gk6nIyYmmvDwcD7/fD0rV65h3brV3L9/H4PBQKFChQFwcXEhLU33UrVIIAohhMgVR378nS/P3KWqjztajRqVSkVQ0GzWr19Nq1Zv4uTkjL29A87OLnh7e+Pu7oG3tw+Ojk5cvPgDWq02/XrumJgYrKxebnpKCcRcEhUVyfz5c3K7jEyTFTeEEFnp7NX7bDl6k5rlPGhZt0T6/Xv27GLFijUcPHichIR4GjZsTJMmTblz5w4JCfFER0cTHx9H9eo1KF68BNu2bQbgwIEvKVfutZeqKdsuzI+KiqJjx46sWbMGnU7HwIED8fLyAqB79+60bt2aZcuWceLECbRaLRMnTqRq1arZVc4rx83NnTFjxud2GZkmK24IIbLK5ZuRrDnwCxVKuTCwXUV+vvbXL8o+PmXp06cHGo0GH58yBAQMAOD48YZ06NAKgFat3qZYsRJMmfIxw4cP5JtvjmBtbcO6dVteqq5sCUS9Xs+UKVOwtrYG4Nq1a/Tr14+AgID051y7do3z58+zY8cO7t+/T2BgILt27cqOcnLM119/RXj4XQYPDkSn09GzZ2d27vyKYcMGULZseW7fDiM5OZGgoGAURWHq1ImsWrWOb745ypo1q3FycsbBwZ433mhIkSKe7Nu3i+nTZwPQrp0fX355mIcPHzB37ix0ulSsrKwZO3YihQsXSa/hv664sXfvTqKiomTFDSFEtvr1txiW77tKqSL2DOtYBQuthmrVanDkyLcADBgwmAEDBj/1us8+++ypC/N9fMpw4MCxLKstWwIxODiYbt26sWrVKgCuXr3KnTt3OHbsGKVKlWLixIlcuHCBBg0aoFKpKFq0KEajkejoaFxdXbOjpFxXoUIlRoz4gJUrP+XIkcM0a9YCAIPBwOLFC1mzZiMODo6MGTPiH9/n008X07lzV+rVq8+PP55nxYplTJ36cfrjsuKGEOJVFf4ggcU7r+DuZM3ILtWwsXq1Zg/N8mp2796Nq6srDRs2TA/EqlWr0qVLFypXrszy5cv59NNPcXBwwNnZOf11dnZ2JCQkvFAg/n36nUeP1Gi1uXdYVK1WoVar/pyKzTxJt1ZrPlBcocJraLVqPD09iYqKRKNRo1JBUlICTk5OuLmZt7tWrVqo1ao/H1elb4+iKGi1am7fvsXGjWvZvPn/AAWNRpthm//44zfq1auPVqvG29sLb28v5s2bTe3addFq1Tg6OuDtXZoHDyJQqVRoNKr0Gp98bvHiJXB0NAeZu7s7RqPhqXr+jVb719/FrVs3mTx5AoGBo6hd++kgNffO/FwPD4cXb3w+JH0wkz6Y5Yc+RDxO5JOdoTjYWTJrSAPcnW1e+D2yuw9ZHoi7du1CpVJx7tw5rl+/zrhx41i+fDkeHh4ANG/enKCgIJo2bUpSUlL665KSktL3JjLr73OZmkymXJ0TVKu14PHjxxgMJn7+2bzqhcFgQlEUTCbzn00mEyaTgtFoQlHA0dGZ5ORkHj16jKurGz//fI369Ruh0VgQGRmJwWDiwYP7xMfHYTCYKFnSi+7d36VKlWqEh9/l0qULGba5RAkvrl69yhtvNCIi4g8+/3w5VapU5dKlizRo0ITk5CRu3bpF4cKeWFhY8ujRY4oXL8Uvv1zH3d0Do9GUXjeAopBeq9GY+f4aDCY0GhN37txm0qSxTJ8+m7Jlyz339SaT+f6CNGfj8xS0uSufR/pglh/6EB2fyuyNFzCZFEZ1qYaiN7zwNuXEXKZZHoibNv11wkSvXr2YNm0aQ4YMYfLkyVStWpVz585RqVIlatasybx583jvvfd48OABJpMpzw+X1q37Bnv37mLw4PcoX74CdnZ2//oalUrFuHETGTduNLa2dqSlpQLw2msVsLe35/33++Dl5Y2nZzEAhg4dwYIFc0hLS0OnS2XEiDEZ3u+/rrjh7u7xj3XKihtCiP8iITmNBdsuk6wzMLZ7TYq42uZ2Sc+VratdPAnE1NRUgoKCsLCwwN3dnaCgIOzt7Vm6dCmnTp3CZDIxYcIEfH19X+j98+NqF8uXL6VUKS9at26by1XlLFnt4i/5YY8gK0gfzPJyH1J0BuZtuUREZBKj/atRvqTLf36vPLmH+L82bNiQ/uetW7c+9XhgYCCBgYHZWYIQQohcoDcYWbb7J357mMiwjlVeKgxzyqt1io9g8GD5BUEIkbcZTSZW7LvG9fAY3n+7ItXLuud2SZkiM9UIIYTIMoqisP7gr1y6GUmPZmWpV7nIv7/oFZHvAjEbD4mKbCJ/Z0K8Gu7cCaNRozqcO3eGY8cO06JFY/z8mtC6dVPCwm4BEBQ0haZNG9C8eUNWr16R4fWKorD9+C1O/3SfdvW9aOZb4lkf88rKV4Go1VqSlBQv/8DmIYqikJQUj1ZrmdulCFGgpaamMnLk0PRrgufOnc24cRM5fPgEdevWY+bMqdy6dYNvvjnKvn2H2LhxB5s2/R+JiYnp7/H1d+EcPv87TWsWp30D79zalP8sXx1DdHHxICbmMYmJsbldygtRq9Xp1+EVRFqtJS4u/3zZhxAiew0aFEDHjv5/TvoBS5eupFy58oB5Ri1LSyu++eYIxYoVw97eHnt7exwdHTl16jitW7flxKUIdp28zeuVCtO9eVlUKlVubs5/kq8CUaPR4u7umdtlvLC8fFq1ECLvmzMnCCcnJ/r0CUgPxCdhuHfvLr799iTr1m1mx46t2Nj8dR2hlZUV0dHRnL/+kA2Hf6WqjxsBrSugzoNhCPksEIUQQry448ePAir8/JqQlJTI5MnjWLFiDQcOfMm+fbtZuHApXl7eODk5kpqakv46nU5HqtGaz7/6mbLFnRjSoTJaTd49EieBKIQQBdzhwyfT/+zn14Rp02ayZ88ujhw5xIYN2yhWzHxyzFtvNWfLlk0kJMSTnJxMbFws391zoHhhO4Z3roalhSa3NiFLSCAKIYTIQK/Xs2/fLiwtrQgIMC/nVrZsOZYtW8VbbzXjnXdaYzIpuHo3wN3VhVFdq2NrnffjJFunbstuf5+6La+SY4hm0gcz6YOZ9MHsVezDo9gUZm+4gFqtYkLPmv9p5YoXlRNTt+XdwV4hhBA5LjZRx4KtlzAYTYzuWj1HwjCnSCAKIYTIlKRUPQu3XSY+Sc8o/+oUc//3FX3ykrw/6CuEECJ7qCA+WU9sYhoOthZsDvmVB9HJjOxSjdJFHXO7uiwngSiEEOJpKrj+WxxLtl9GpzdiZaGha/NyNK5WlIpeeXvt2ueRIVMhhBBPiU/Wp4chgE5vZNuRG5T0zH97hk9IIAohhHhKbGJaehg+odMbiU1Ky6WKsp8EohBCiKc4O1hh9bcL7a0sNDjb5d+J+CUQhRBCPOVxVCJdm5dLD0UrCw3D/avjaGuRy5VlHzmpRgghRAYPopNZtP0K3p4OzBxYj8RUPc52luYwzPtzoTyXBKIQQoh0iSl6PtkRikajonfL13C1t8TV/s9h0nwchiBDpkIIIf5kMJr4dPdPRMfrCOxYFY98NAtNZkggCiGEQFEU/u/wr/z6eywBrV+jTHGn3C4px8mQqRBCFHD79+9j0ScLKNVsGmVsf+ejEVNQqzV4enryxRcb0Wq1tGvnR2pqCiqVGq1Wy4EDRwkJOcjcuTOfem5eJXuIQghRgI0ZM5z58+eQpjdQp0Ihju37nGHDRhESchJbWzsWLZoHQEJCPIcOneDw4RMcOHAUgODgmc98bl4lgSiEEAWYa6HiFKvTF7VKRUDrCqSl6ejQoRMAdeq8TmjoRcLCbmEwGGnf3o8WLRqxevUKgGc+Ny+TQBRCiAIqJkFHpO0b2NnaYKFVY2mhwdrahu3btwDwzTdH0Ol0pKamUK9efXbs+IqVK9eyceM67twJe+Zz87JsC8SoqCgaN25MWFgY4eHhdO/enR49ejB16lRMJhMAy5Yto3PnznTr1o0rV65kVylCCCH+RpdmZMnOK6SkGenSpAwqlfn+oKDZrF+/mlat3sTJyRl7ewd8fMoyfvxkrK2t8fb2wcXFlYsXf3zmc/OybAlEvV7PlClTsLa2BmD27NmMHDmSzZs3oygKx44d49q1a5w/f54dO3awcOFCpk+fnh2lCCGE+BuTovD5/p/57VECg9pVopDLX5dX7NmzixUr1nDw4HESEuJp2LAxW7ZsoHdvfwCioiKJjY3B1/f1Zz43L8uW04GCg4Pp1q0bq1atAuDatWvUqVMHgEaNGnHmzBm8vb1p0KABKpWKokWLYjQaiY6OxtU1fy4rIoQQr4pdJ8O4eOMx3ZuWpVoZd0JDf09/zMenLH369ECj0eDjU4aAgAEAnDp1nObNGwIqunbtSalSpZ773LxKpShKls49sHv3bh48eMCQIUPo1asX06ZNo0+fPpw+fRqAc+fOsWvXLkqXLo2zszM9evQAoGfPnsyaNYtSpUplZTlCCCH+x9Hz4SzedplWb3gxuGNVVE/GSkXW7yHu2rULlUrFuXPnuH79OuPGjSM6Ojr98aSkJBwdHbG3tycpKSnD/Q4OLzb+HBWViMmU9+cS8vBw4PHjhNwuI9dJH8ykD2bSB7Os7MOvv8WwbEcolbxceKe+F5GRiVnyvjkhq/qgVqtwc7N/9mMv/e5/s2nTJjZu3MiGDRuoUKECwcHBNGrUiO+//x6AU6dO4evrS82aNTl9+jQmk4l79+5hMplkuFQIIbLJw+hklu3+iUIuNgzuUBmtRi4y+LscmVJg3LhxTJ48mYULF1K6dGn8/PzQaDT4+vrStWtXTCYTU6ZMyYlShBCiwElK1fPJziuoVCpGdKmGrXX+XcLpZWT5McScJEOm+Yv0wUz6YCZ9MHvZPhiMJhZtD+XmH7GM6VaDciWcs664HJQnh0yFEEK8GhRFYWPIDa6Hx9Cn5Wt5NgxzigSiEELkUyE//M6p0Hu8/UYp6lfxzO1yXnkSiEIIkQ9dvhnJ9m9u4Vvegw4NS+d2OXmCBKIQQuQzvz1MYOWX1/DydOC9tyuilmsNM0UCUQgh8pHYRB2Ld17B1lpLYKeqWFlocrukPEMCUQgh8gmd3jxhd3KqgRGdq+Jsb5XbJeUpEohCCJEPmBSFL/b/TPiDBAa2q0TJwnl75YnckCMX5gshhHi2tLQ0evfuSnR0FAAffTSdEiVKMmLEEHS6VABmzZpPrVq1mTx5POfOmeeFbtv2HUaM+CD9ffZ+e5sff31M17fKUL2se85vSD4ggSiEELlozRrzqkAhIafYtm0T8+fPwcbGhqZNWzBixAfs37+Ty5cv4u5eiNOnT3Lw4HESExPo2LENgYGjUKvVnPnpPvvPhtOoWlFa1C6Ry1uUd0kgCiFELho0aBh9+/YH4O7dO1hbW/Pw4QPu3YugVau3cHNzZcmSVbi6unLw4HGsra25cuUyarUatVrNjd9jWXfwFyqUcuHdFuVk9YqXIMcQhRAil1lbW+Pv356vvtpL27YdMBgMODs7c/DgNxQuXJjJk8elP2/y5HF88EEgVapU41GMecJud2cbhrwjE3a/LOmeEEK8ArZv38e6dZv5/PPlqFQq3n23DwD+/v6Eh99Jf15QUDCHD5/k5s0bjJm+CEVRGNm5KnYyYfdLk0AUQhRoaWlpdOv2Di1aNKJFi0acOnWcI0cO0ahRHfz8muDn14TFi+cD0K6dHy1aNMLPrwlt2jTLks+fO3cWo0cPA8DR0QmVSoWbmztbtmwC4ODBgxQpUpTvvjtD+/YtMZlMaC0sSTMoJKYYGdaxCoVdbbOkloJOjiEKIQq0Z53UUqfO67z+en3mzl2U4bkJCfEcO3YGtTrr9iX69x/Ee++9i59fY0wmEz169OKNNxoyduwojhw5hLW1FStWrKNYsWKULFkKP7/G6A0mLByLMWpof8qXdMmyWgo6Wf7pFSDL3JhJH8ykD2Y52YfU1FSsra0JDv6YCxd+wNLSksjISBTFhIuLG8uWrSQuLo6+fXvg7OyETqfD378H/fsPyvba/t6HIz/8zpZjN2n1ekm6NCmT7Z//qpDln4QQIgf8/aSWSpWqMHLkhxw+fJIiRYowbtxoUlNTqFevPjt2fMXKlWvZuHEdd+6E5Widobci2frNTWqW86BTY58c/eyCQAJRCCHIeFLLO+90pmXL1gB07tyNe/f+wMenLOPHT8ba2hpvbx9cXFy5ePHHHKvv90eJrPjyGiULOfC+TNidLSQQhRAF2rNOahk2bCAHDnwJwKFD+ylevARbtmygd29/AKKiIomNjcHX9/XsK0wF8Sl6frr1mMgEHRsO/4KNpYbhnatiZSkTdmcHOalGCFGgPeukFm9vH+bPn82SJQuxs7NjxYo1FCpUmFOnjtO8eUNARdeuPSlVqlT2FKWC67/FsWT7ZXR6I1YWGro1L0fZoo64OMiE3dlFTqp5BchJFGbSBzPpg1lB7kN8ip5xn51Fpzem32dloSF4yBs42hTM6w1z4qQa2UMUQohcpCgKMQk67kUlce9xEveikihd3DlDGIJ5aafYpLQCG4g5QQJRCCFyQHrwRSYREZnEvSf/RSWRovsr/BxsLShXyg0rC81Te4jOdpa5UXqBIYEohBBZSFEUouPNe3wRf+7xPQm/1LS/As7R1oKi7nbUq1SEou52FHO3w9PdDkdbS1CBi4NVhmOIw/2r42hrAXn/KNErSwJRCCH+TgXxyXpiE9NwdrDC0Ub7VBApikJUfCr3IpPTAy/izz0+3TOCr35lT4q621LU3Y6i7nY42P7D3p4CFUo6ETzkDZL1RmwtNBKGOUACUQgh/tczzvAc2rkqWpXCnfsJ/zPUmZwx+OwsKeZuR4PKnhT1sKOom+2/B98/UcDRxgKfkq7mk0kkDLOdBKIQQvyP+GR9ehiC+WSWT3deoX0jH3YcD8PJzpKi7nY0qOJJsT/39oq622EvJ7vkedkSiEajkY8++og7d+6gUqmYPn06BoOBgQMH4uXlBUD37t1p3bo1y5Yt48SJE2i1WiZOnEjVqlWzoyQhhMiU2MS0Z57h6eXpwJIRDSX48rFsCcTjx48DsHXrVr7//nsWLVrEW2+9Rb9+/QgICEh/3rVr1zh//jw7duzg/v37BAYGsmvXruwoSQgh/lVyqoEH0cnPPMOzqJttlofh/v37WLp0EYcPnyAk5CBz585Erdbg6enJF19sRKvVUr9+fZKTk1Gp1Gi1Wg4cOMqxY4eZM+djVCoVrq5ubNy4A61WBvxeVrZM3dasWTOCgoIAuHfvHo6Ojly9epUTJ07Qs2dPJk6cSGJiIhcuXKBBgwaoVCqKFi2K0WgkOjo6O0oSQoh/9NvDBGas+4Hdx2/Sv10lrCzM06NlOMMzC40ZM5wFC4IxmczBGxw8k2HDRhESchJbWzsWLZoHQFxcHIcOneDw4RMcOHAUgCVLFtG9ey9CQk5hMBhYs+bzLK2toMq2Xym0Wi3jxo3jyJEjLFmyhIcPH9KlSxcqV67M8uXL+fTTT3FwcMDZ2Tn9NXZ2diQkJODq6pqpz3jebAN5kYeHQ26X8EqQPphJH8xyqg9Hz4ezfNcV7G0tGdfbl9dKuVKljAfRCSm4Otjg6W6HWp21k2lXrPgaAwb0Z9iwYXh4OJCWpuP99/sC0KRJI77++mtiYu5jNBrp0KElOp2OPn36MGLECMqU8SE5OR43Nzv0+jRcXOwLxHcmu7cxW/exg4ODGTNmDP7+/mzdupXChQsD0Lx5c4KCgmjatClJSUnpz09KSsLBIfMbLFO35S/SBzPpg1lO9CFNb2TjkRucvnKfCqVcGNiuEo52lkRFJWKpgiKO1oBCVFRiln92QMAQQkMvoSgKjx8nYG1tw6efrsLfvzv79x8gNTWVe/ciady4MZMmBXH/fgT9+vWkXr3GFCtWkq1bt7Jz5060Wgtatmyf778zeXY9xL1797Jy5UoAbGxs/pw9fhhXrlwB4Ny5c1SqVImaNWty+vRpTCYT9+7dw2QyZXrvUAghXsajmGRmbbjA6Sv3efsNLz7oWh3HXJwJJihoNuvXr6ZVqzdxcnLG3t4BH5+yzJw586klp/bs2cmsWfM5ceI76tWrz5Ah7+da3flJtuwhtmjRggkTJtCzZ08MBgMTJ07E09OToKAgLCwscHd3JygoCHt7e3x9fenatSsmk4kpU6ZkRzlCCJHBxRuP+eLAdaLvfE/k9f10HH/yuSe1tGvnR2pqSoaTWjp2bJM+upWSkoK7uzu7dx94qZr27NnFihVrKFGiFH36dKNx47fYsmUDu3dv56uvjmRYckqj0eDm5gaAp2dRfv756kv3RGRTINra2rJ48eKn7t+6detT9wUGBhIYGJgdZQghRAZGk4ldJ29z6PvfiLq8nviHN9LPzgwOnklg4Cg6dOjE4MHvsWjRPD78cAIJCfEcO3YGtfqvAbUn4RcREUGvXv7MmbPwpWvz8SlLnz490Gg0+PiUISBgAABnz556asmpwMAPGDVqKCqVGrVazZw5C17684Us//RKkGNGZtIHM+mDWVb3ITZRx4q9V7nxRxxv1ihGzI2veb1uPSZN+pAjR76lYcPafPvtDwCsXfs5x46FMH36bPr27YGzsxM6nQ5//x707z8o/T379u1O2bLlmDRpepbV+XfyfTDLs8cQhRDiVfJLeAzT1v7A3YcJvN+2Ir38yjM8cBRWVn8ttmttbcP27VsA+OabI+h0OlJTU6hXrz47dnzFypVr2bhxHXfuhAFw504Y4eF3+fDDSbmyTSLrSSAKIfItk6Lw9XfhzNt6CVsrLZN7+1KvUpFnPvd5J7WMHz/5qZNaANauXU21ajWwtJQlmfILCUQhRL6UlKpn2a6f2HkiDN/yhZjcx5diHs+/dvnJSS0HDx4nISGehg0bs2XLBnr39gfIcFILQGjoJVq3bpsj2yJyhsz1I4TIFWlpafTu3ZXo6CgAPvpoOo0avQlAv349KVeuDBMmmI/NjR07igsXzqNSqejY0Z8hQ4b/43uHP0jg0z0/EZOgo0ezsjStVRyV6p8vrH/eSS2nTh1/6qQWgPj4OKpUqf4SHRCvGglEIUSuWLNmFQAhIafYtm0T8+fPoWRJL4YOfZ/ExATKlSsDwP379/nuuzMcOnSCmJgYund/57mBqCgKp0LvsenITRxsLRjfsyY+xZyeW0O1ajU4cuRbAAYMGMyAAYOfes7atZuf+drjx8+90PaKV58EohAiVwwaNIy+ffsDcPfuHaytrYmNjWHw4EAOHfrrmj4XFxesrW2IiYkhLi72uXt6Or2RjYd/5czVB1TydmVA24r/fS1CUSBJIAohco21tTX+/u25dy+CgQOHUr16TapXr5khEAEcHBzo1q0DAPXrN3rqfR5EJ/PZnp+IeJxEu/petKvvneVzj4r8TwJRCJGrtm/fx61bNwgIeJc2bdo/NX3j//3fFyQlJfL118cA6Ny5HQcOfEmbNu0A+PGXR6z5+jpajZpR/tWoXNotx7dB5A+ZCsSHDx+SkJCARqPh888/p1evXlSoUCG7axNC5GNz587iwYN7LFy4DEdHJ1QqFVqt5qnnubm5o9VqsbOzR61WY2VlRXR0FAajiZ0nwgj54XdKF3VkcPvKuDlZ58KWiPwiU5ddfPDBB0RGRrJo0SLq16/PrFmzsrsuIUQ+17//IO7cuY2fX2N69uxMjx69cHR8+gSYTp264uVVmhYtGtO8eUMKFSpM63bdmLv5EiE//E7TWsUZ37OmhKF4aZnaQ1SpVNSuXZsVK1bQpk0btm/fnt11CSHyOVdXV/bs+fqZjy1btirDVF3Llq1Kf+znu9HMWP8jaXoTA9tVom7FwjlSr8j/MhWIBoOBefPm4evry3fffYder8/uuoQQIgOTonDgXDh7v72Np5sdQzpUpqi7XW6XJfKRTAXirFmzOHv2LF26dOHo0aMEBwdnd11CCJEuMUXP6v0/cyUsitcrFqZ3y/JYW8o5gSJrZeobFRQUxJo1awBo3bp1thYkhCjgVBCfrOfBrcfYWmmJT0hl8Y4rxCXp6NWiHE1qFPvXWWeE+C8yFYiOjo4cO3YMLy+v9DXBvL29s7UwIUQBpILrv8WxZPtldHojVhYaujUvh4uDJUPeqYy3p2NuVyjysUwFYlRUFOvWrUu/rVKp+L//+7/sqkkIUUDFJ+vTwxDMs89sPXKDjwfWw81eZp0R2StTgbhhwwYSEhKIiIigRIkS2NnJgWwhRNaLTUxLD8MndHojSal6CUSR7TIViIcPH2b58uUYjUZatmyJSqViyJAh2V2bEKKAcbCzwMpCkyEUrSw0ONtJGIrsl6kL89euXcv27dtxdnZmyJAhHD16NLvrEkIUMDq9ke1Hb9K1eTmsLMwz1lhZaBjuXx1HW4tcrk4UBJnaQ9RoNFhaWqJSqVCpVNjY2GR3XUKIAkSnN7Jk5xV+CY/Bt7wHwUPeIFlvxNZCYw5DJbcrFAVBpgKxVq1ajB49mocPHzJlyhSqVKmS3XUJIQqI/w3D996uQK3yhQDwKelqnqlGwlDkkEwF4ujRozl16hQVK1bEx8eHN998M7vrEkIUALo0I4t3hvLr77H0f7si9SoXye2SRAGWqUBctmxZ+p+vXbvGjRs3KFKkCK1bt8bCQsb2hRAv7qkwrCRhKHJXpgLx119/xcrKCl9fX0JDQ7l//z4eHh6cPn2aefPmZXeNQoh8Zu/ePXyyZCE+ftOp5fGQySOmoFZr8PT05IsvNqLVaqlfvz7JycmoVGq0Wi0HDhzlzp0wRowYgk6XiqIozJ69gFq1auf25oh8IlNnmcbHxzN//ny6devG7NmzUavVzJs3jz/++CO76xNC5DOjRw9n4aJgjEYj779dkV2bPmXYsFGEhJzE1taORYvMv2THxcVx6NAJDh8+wYED5jPbx4//gKZNW3D48EkCAgZy+fLF3NwUkc9kKhATEhKIjo4GICYmhoSEBPR6PampqdlanBAif0lNMxCps6Oob18stGper1SEtDQdHTp0AqBOndcJDb1IWNgtjEYj7dv70aJFI1avXgHAw4cPuHcvglat3mLfvl28806X3Nwckc9kKhADAwPx9/enQ4cOdO3alcDAQNauXUvnzp2f+Xyj0ciECRPo1q0b3bt358aNG4SHh9O9e3d69OjB1KlTMZlMgPn4ZOfOnenWrRtXrlzJui0TQrxSUtMMfLI9FIuSzWnfqBwatXmCbmtrG7Zv3wLAN98cQafTkZqaQuPGjdmx4ytWrlzLxo3ruHMnDIPBgLOzMwcPfoOHRyEmTx6Xm5sk8plMHUN88803ady4MdHR0bi5uaFSqWjUqNFzn3/8+HEAtm7dyvfff8+iRYtQFIWRI0dSt25dpkyZwrFjxyhatCjnz59nx44d3L9/n8DAQHbt2pU1WyaEeGU8CcNbEfEMbFcJq7R76Y8FBc0mKGgKa9euwsenLFptEj4+ZZk5cyYmkyXe3j64uLhy8eKPqFQq3n23DwBt23Zg8eL5ubVJIh/K1B7imTNnGDhwIKNHj6ZPnz707t37H5/frFkzgoKCALh37x6Ojo5cu3aNOnXqANCoUSPOnj3LhQsXaNCgASqViqJFi2I0GtOHZoUQ+UOKzsCiP8NwQLuK1KmQcYX7PXt2sWLFGg4ePE5CQjwNGzZmy5YNtGnTBoCoqEhiY2Pw9X0dNzd3tmzZBMDx48coUqRojm+PyL8ytYc4e/ZsJk6cSJEimT8tWqvVMm7cOI4cOcKSJUs4c+ZM+hpmdnZ2JCQkkJiYiLOzc/prntzv6uqaqc9wc7PPdD2vOg8Ph9wu4ZUgfTDLL31ITtUzf9t3hN2LZ8y7tWhYvRgAzs62qFQqPDwcqFq1En379kCr1VKuXDnGjfsAgLNnT9GiRSNUKhX9+vXD17cyS5YsZvDgwRw7dhhLS0t27NiRb3r1TwrCNmZGdvdBpSjKv84D8f777/P555//pw94/Pgx/v7+JCYm8sMPPwBw9OhRzp49i5eXFzqdjvfffx+ADh06sGbNmkwHYlRUIiZT3p/GwsPDwTwjRwEnfTDLL31I0RlYtCOU2xHxDGxfidqvFXqh1+eXPrws6YNZVvVBrVY9d2cqU0Ombm5uTJkyha1bt7Jt2za2bdv2j8/fu3cvK1euBMDGxgaVSkXlypX5/vvvATh16hS+vr7UrFmT06dPYzKZuHfvHiaTKdNhKIR4db1sGAqRGzI1ZFq8eHEAIiMjM/WmLVq0YMKECfTs2RODwcDEiRPx8fFh8uTJLFy4kNKlS+Pn54dGo8HX15euXbtiMpmYMmXKf98SIcQr4ckxw9v34hnUvhK+EoYij8jUkCnA2bNn+f3336lWrRre3t5YWVlld23/SoZM8xfpg1le7kOKzsDC7Ze5ez+Bge1eLgzzch+ykvTBLCeGTDO1h7hw4UIePHhAWFgYlpaWrFq1ioULF750YUKI/ON/w3BQ+0rpq1YIkVdkKhAvXLjApk2b6NWrF++88w5btmzJ7rqEENkoNTWVXr38iYuLw2Qy4u/fnUOHviYpKQmAlJQU3N3d2b37AIGBA7l+/RoqlZqRI8fQpk27p94vOdXAou2XufsggUHtK1OrvEdOb5IQLy1TgWg0GtHpdKhUKoxGI2p1ps7FEUK8ohYtmou9vT07dnxJRMTvdO/eiVOnzgMQERFBr17+zJmzkJCQg9y8eYOQkFNcu3aVUaOGPBWIyanmPcNwCUORx2UqEPv06UPHjh2Jjo6mS5cu9O3bN5vLEkJkpwEDhvDk9AGTyZR+jTDApEljaNq0GeXKlWf9+i+oWLEyarWaKlWqoigKd+/ewcvLG8gYhoM7VKZmOQlDkXdlKhBbtWrFG2+8QXh4OCVKlMDFxSW76xJCZCM3N3cAIiMf8/77fWjXriMAd+6EER5+l1Wr1gOQmJiAs/NfP+9arZbIyMd4eXmTnKpnwbZQfnuYwJAOlakhYSjyuEyNfZ49e5bQ0ND0PcSvvvoqu+sSQmSza9d+omvXd2jY8E0++MA8SfbataupVq0GlpaWANjbO5CUlJj+GoPBgIdH4T/D8LI5DN+RMBT5Q6YCcdGiRXh5ebFhwwa2bNnC1q1bs7suIUQ2Cgu7xdChA3jvvQFMmjQ1/f7Q0Eu0bt02/XbDhk24du0nDAYDP/10BUVR8Chc9M8wTGToO1WoUVbCUOQPmRoytba2xs3NDa1Wi4eHR4bjDUKIvCcoaApGo4H169ewfv0aAHbs2Ed8fBxVqlRPf17Llq3Zv38vLVu+CSgMGDic+Vsv8/sjcxhWL+ueOxsgRDbIVCDa29vTv39/unbtyqZNm2R6NSHyuHXrNj/z/uPHzz1137JlqwBIStWzQMJQ5GOZCsTFixfz22+/UaZMGW7evEmXLrJKtRAFSVKqnvlbLxPxOJGhHatQvYyEoch/MnUM8fbt2yQkJBAaGsrHH3/MhQsXsrsuIcQrIkMYviNhKPKvTAXitGnTsLS0ZPny5YwaNYply5Zld11CiFdAYoqe+VvMYTisYxWqSRiKfCxTQ6aWlpaULVsWvV5P9erVZaYaIfIrFcQn64lNTMPOxoINB38mItIchlV9JAxF/papQFSpVIwdO5ZGjRrx9ddfY2Fhkd11CSFymgqu/xbHku2X0emNWFlo6Na8HC3rluK1kjIZh8j/Mn0d4jvvvEPv3r1xdXWVlS6EyIfik/XpYQig0xvZeuQGRT2evVSOEPlNpgJRrVaTkJDAvn37uH//Ptu2bcvuuoQQOSw2MS09DJ/Q6Y3EJqXlUkVC5KxMDZkOGzaM0qVLc+PGDaysrLCxscnuuoQQOchkUohPTsPKQpMhFK0sNDjbWeZiZULknEztISqKwowZM/D29mbt2rXExsZmc1lCiJwSk6Bj3pZL/N/B6/RtUxErCw1gDsPh/tVxtJVzBkTBkKk9RI1Gg06nIyUlJX1NRCFE3nf1ThSff/UzOr2RXi3KU7eCBxVKvUFsUhrOdpbmMFRyu0ohckamArFnz5588cUXlCtXjkaNGuHr65vddQkhspHRZGLvt3f4+lw4RT3sGNy+MkXd7UABRxsLHG3+3CuUMBQFSKYvu9i5cyeOjo5YWlrSsWPH7K5LCJFNYhJ0rNx3lRt/xNGomifdm5VLHyYVoiDLVCB+9tln7NixAzc3NyIjIxk0aBANGzbM7tqEEFnsp9vmIVK9wcT7bStSr1KR3C5JiFdGpgLR2dkZNzc3ANzd3bG3l+uShMhLjCYTe07d4evvwinuYUd5u3CmjZ7K4cMnCAk5yNy5M1GrNXh6evLFFxvRarW0a+dHamoKKpUarVbLgQNHOXLkEEFBU7CxsQWgdeu3GTFiTC5vnRBZI1OBaGdnx3vvvUft2rW5du0aqamp6Rfnjx49OlsLFEK8nOj4VFZ8eY1bf8TRuHpRQkM+Y/WlH9FqzcOkwcEzCQwcRYcOnRg8+D0WLZrHhx9OICEhnmPHzmSYqvH778/x+uv1mTt3UW5tjhDZJlOB2KxZs/Q/Fy5cONuKEUJkrdBbkaze/zMGk8LAdpWoW7Ewn4aVplu3Hkya9CEAaWk6OnToBECdOq9z7FgIYWG3MBiMtG/vh06nw9+/B/37D+KXX34mMjISP7/GuLi4sWzZStzdPXJzE4XIMpkKxHfeeSe76xBCZCGD0cTuU7c59P1vlChkz5AOlSnsah7mHDp0JKGhl9Kfa21tw/btW/D378433xxBp9ORmppCvXr1mTFjNvfvR9CvX0+aNm1OpUpVqFHDl5YtWzNy5BDGjRvNF19syK3NFCJLZSoQX4Rer2fixIlERESQlpbG4MGD8fT0ZODAgXh5eQHQvXt3WrduzbJlyzhx4gRarZaJEydStWrVrC5HiFdOamoqvXr5ExcXh8lkxN+/OxUrVmHGjI8A83H6NWs2Y21tDYDBYKB9+5bUrl2XadNm/uv7R8WlsuLLq4RFxPNmjWJ0a1oGC+3zzyINCppNUNAU1q5dhY9PWbTaJHx8yjJ+/GSsra3x9vbBxcWVixd/pG/f9/H09ASgc+duzJw5NQs6IsSrIcsD8csvv8TZ2Zl58+YRGxtLhw4dGDp0KP369SMgICD9edeuXeP8+fPs2LGD+/fvExgYyK5du7K6HCFeOYsWzcXe3p4dO74kIuJ3unfvhIuLCwMGDKFz52706NGRNWtWMWTIcACGDRtAWpouU+99+WYkXxz4GaNJYVD7StSp8O+HOPbs2cWKFWsoUaIUffp0o3Hjt9iyZQO7dm1j//6jREVFEhsbg6/v6/Tq5c+oUR/Spk07Dh3aT/HiJV6qF0K8SrI8EFu2bImfnx9gnvJNo9Fw9epV7ty5w7FjxyhVqhQTJ07kwoULNGjQAJVKRdGiRTEajURHR+Pq6prVJQnxShkwYAiKYr7i3WQyoVKp2LHjKywtLUlOTiY+Ph4XF/NyS0uXLkKlUlG+fIV/fE+D0cTOE2GE/PA7pQo7MKhDJQq72GaqHh+fsvTp0wONRoOPTxkCAgYAcOrUcZo3bwio6Nq1J6VKlWLs2InMnz+bJUsWYmdnx4oVa/57I4R4xaiUJz+ZWSwxMZHBgwfj7+9PWloa5cuXp3Llyixfvpz4+HgcHBxwdnamR48egHk2nFmzZlGqVKnsKEcIAJKTk2nbti2xsbEYjUb69OlDuXLlmDJlCiqVCo1Gw4YNGyhXrhz9+/fn/PnzWFhY0Lt3b0aMGJGltTx8+JA2bdrQtm1bpk6dyoULF+jduzdarZZ9+/Zx8+ZNZsyYwfHjx+nbty+FChV65tJrD6OTmbvhB278Fsvb9b0JaFfpH4dIhRDPluV7iAD3799n6NCh9OjRg7Zt2xIfH4+joyMAzZs3JygoiKZNm5KUlJT+mqSkJBwcHF7oc6KiEjGZ8v7cUh4eDjx+nJDbZeS6nOjD7NkzsLGxZevWvenDlTY2towdO4GmTf2YPv0jPvhgDL17v8f333/Pvn2HAOjQoRWtW3fE2dk5S+q4du0nhg8fzFtvNWfIkNE8fpxAyZLlOHHiO+bP/5h+/QJwcnIiPj6BOnXqkpKSglqtYt68RfTt2z/9fS7eeMyaA9dRUBjSoTK+rxUiNiY5S2rMbfJzYSZ9MMuqPqjVKtzcnn0tfaZWu3gRkZGRBAQE8OGHH9K5c2cA3nvvPa5cuQLAuXPnqFSpEjVr1uT06dOYTCbu3buHyWSS4VKR7QYMGMK8eYuBv4Yrly5dSdOm5mF+g8GApaUVoaGXKFnSCwcHRxwcHHFycubUqRNZUkNY2C2GDh3Ae+8NYNIk80kpbdu24Pz57wBwdHREpVLz+ef/x9Gj33L48AmqVq1GkyZN08PQYDSx+egNlu3+iUIuNkztVwff1wplSX1CFFRZvoe4YsUK4uPj+eyzz/jss88AGD9+PLNmzcLCwgJ3d3eCgoKwt7fH19eXrl27YjKZmDJlSlaXIsRT3NzcAYiMfMz77/ehXbuOlCtXHoC9e3fx7bcnWbduMxERf/Dll7uJjHxMSkoykZGPSUyMz5IagoKmYDQaWL9+DevXm4/BDRo0lI8+GotarcbS0pL585c+9/WPY1NYse8qd+4n0My3OF2alMFCm+W/2wpR4GTbMcScIEOm+UtO9eF/hyuf7KEtXjyffft2M3/+EmrWNK/mMnPmVE6ePI6DgyNGo5HAwNE0bdo82+v7pz5c+PURa77+BRXQr3UFapXPvxfFy8+FmfTBLCeGTLPlGKIQr6onw5UDBgymR4/eAMybN5sjRw6xYcM2ihUzX0Zw9+4dEhOTCAk5xcOHD+jZswsNGzbOtbr1BhPbv7nFsYt/4O3pyOD2lXB3tsm1eoTIjyQQRYHy9+FKRVFITk7C0tKKgIBeAJQtW44lS1bw2293adasAWq1mkGDhmJpaZkrNT+KSWb5vmuEP0igRe0SdG7ig1YjQ6RCZDUJRFGgrFu3OdPP3bRpZzZWkjk//PKIdQevo1apCOxUhRpl8+8QqRC5TQJRiFeFCuKT9Ty49RhrCzXHL/zBV2fu4lPUkYHtK+HuJEOkQmQnCUQhXgUquP5bHEu2X0anN2JloaFr83J0alwavzolZYhUiBwggShEDlIUhRSdgZgEHbGJaX/+X0fxIg6s3HMVnd4IgE5vZNuRGwQPeUPCUIgcIoEoBKQPV8YmpuHsYIWjjRZe8IoevcFEbKI54GISdMQ+Cb1E859j/nwsTW966rXdW5RPD8MndHojsUlpONpYvMyWCSEySQJRiGcMVw73r06Fkk6ggElRSEjW/xVqCX+Fnvl2GrGJOhJT9E+9tVajxsXBEmd7K7yKOOBs746zvRUuDlY421vi4mCFk70VOqPC7uO3MoSilYUGZ7vcObNViIJIAlEUePHJ+vQwBPOe2ZLtl+nZsjx7T4YRl5iG8W8TQKgARztLnB2scHeypkxxJ3PApYedFc4OVthZa1GpVP9ag5UlDPev/lQoO9pavPCeqhDiv5FAFAVebGLaM4crFQVeK+nyV8D9z56dk70lGnUWHttToEJJJ4KHvEGy3oithUbCUIgcJoEoCjw7Gy1WFpqnhiur+bjRsHKRnCtEAUcbC3xKupqnqJIwFCJHyelrokCLTdSxbv/PdGteDisL8xqCGYYrhRAFhuwhigIrKi6VeVsvEZeYRodGpQke8gaxSWk421lm23Dl/v37WLp0EYcPnyAk5CBz585Erdbg6enJF19sRKvVUr9+fZKTk1Gp1Gi1Wg4cOJr++gULgjl0aD9Hjnyb9cUJUcBJIIoC6WFMMvO3XCJZZ+SDbtXxKeoE8NclDtkQhmPGDOfChR/R/rmafXDwTAIDR9GhQycGD36PRYvm8eGHE4iLi+PYsTOo/3aM8siRQxw9eijrCxNCADJkKgqgiMeJzNl4EZ3exNjuNShTzClHPtfbuzTBwQvTb6el6ejQoRMAdeq8TmjoRcLCbmE0Gmnf3o8WLRqxevUKAH7/PZxPPpnPuHGTc6RWIQoiCURRoIQ/SCB48yVQwbieNSlVxCHHPnvo0JFYWVml37a2tmH79i0AfPPNEXQ6HampKTRu3JgdO75i5cq1bNy4jrCwWwwbNoCJE6fi4uKSY/UKUdBIIIoCY82GrfTq1gorCzVvFI2kTzc/WrRoTJ8+3TAYDAC0a2feM/Pza0KbNs0AOH36FC1aNKJFi0Z07dqB1NTULKknKGg269evplWrN3Fycsbe3gEfn7LMnDkTa2trvL19cHFx5cKFH4iPj2fGjMmMGTOclJQU+vXrkSU1CCH+IoEoCoRBQwez9vNPABPje9ZixafzGTZsFCEhJ7G1tWPRonkAJCTEc+jQCQ4fPpF+Msu8eTMZMGAIISGnAFizZlWW1LRnzy5WrFjDwYPHSUiIp2HDxmzZsoE2bdoAEBUVSWxsDHXrvsHx4+c4fPgE8+cvwcbGhrVrM7+MlRAic+SkGpHvhd6K5F6iLVWbDeLXU1/g5mT91PG7Y8dCCAu7hcFgPn6n0+nw9+9B//6D2LHjKywtLUlOTiYxMSHLhi19fMrSp08PNBoNPj5lCAgYAMDZs6do3rwhoKJr156UKlUqSz5PCPHPJBBFvvbjL49Y+eU1ajXpRouKMOXPqxWeHL/z9++e4fhdvXr1mTFjNvfvR9CvX0+aNm2Ot7cPP/0USmDgQDQaLQ0aNPrP9VSrViP9kokBAwYzYMDgp56zd+9e84X5//J6IUTWkiFTkW+d+ek+y/ddxdvTkQ+718DW+q/f/553/G78+MkZjt9dvPgjAFWqVOPEie94882mfPDB8NzaJCFENpJAFPnS8UsRfHHgOq+VdGF012oZwhCef/yud29/4K/jd76+r9O2bQvOn/8OAAcHB1Qq+bERIj+SIVOR7xw+/xvbvrlFVR83hr5TGYs/L4T/X887fnfq1PGnjt+9995APvpoLGq1Gq3WgoULl+XwFgkhcoJKUZQ8O4VwVFQiJlOeLT+dh4fDc48ZFSQv2wdFUfjqzF32nr6D72uFGNC2Yp5cbV6+D2bSBzPpg1lW9UGtVuHmZv/Mx2QPUeQLiqKw80QYB7//jfqVi9C39WtZuzyTECLfk0AUeZ5JUdh85AbfXIzgzRrF6NmiHOpMLMorhBD/K8sDUa/XM3HiRCIiIkhLS2Pw4MGUKVOG8ePHo1KpKFu2LFOnTkWtVrNs2TJOnDiBVqtl4sSJVK1aNavLEfmc0WRi3cFfOPPTA1rWKUmXN30ytUK9EEL8XZaPKX355Zc4OzuzefNmVq9eTVBQELNnz2bkyJFs3rwZRVE4duwY165d4/z58+zYsYOFCxcyffr0rC5FvKL279+Hn18TAI4dO0zz5g3/nBqtRfoUapMnj6dZswY0a9aAxYsXPPN9DEYTK7/8mTM/PaB9A28JQyHES8nyQGzZsiUjRowAzMd1NBoN165do06dOgA0atSIs2fPcuHCBRo0aIBKpaJo0aIYjUaio6OzuhzxihkzZjgLFgRjMplXp1+yZBHdu/ciJOQUer2eNWs+Jzw8nNOnT7J//1G2bt3Drl3bMJlMGd5HbzDy6e6f+PGXR/i/WYb2DbwlDIUQLyXLh0zt7OwASExMZPjw4YwcOZLg4OD0f6zs7OxISEggMTERZ2fnDK9LSEjA1dU105/1vDOF8iIPj5xbdSE3Vaz4GgMG9GfYsGF4eDhQpowPycnxuLnZodPpcHGxx9e3Mj/++CPW1tacOXMDtVpN4cJ/LdGUqjPw8drvCQ2LYnCnqrR+wzsXtyh7FJTvw7+RPphJH8yyuw/ZclLN/fv3GTp0KD169KBt27bMmzcv/bGkpCQcHR2xt7cnKSkpw/0ODi+2sXLZRd4TEDCE0NBLKIrC48cJFCtWkq1bt7Jz504sLCxo2bJ9ei9GjhzNiRPfUL16zfT7klMNfLIzlLCION5rU4HaZd3zXe8K0vfhn0gfzKQPZjlx2UWWD5lGRkYSEBDAhx9+SOfOnQGoWLEi33//PQCnTp3C19eXmjVrcvr0aUwmE/fu3cNkMr3Q3qHIH/bs2cmsWfM5ceI7mjRpwpAh76c/FhQUzOHDJ7l16wZbt24iMUXPvK2XuHMvnkHtK1O/imcuVi6EyG+yPBBXrFhBfHw8n332Gb169aJXr16MHDmSpUuX0rVrV/R6PX5+flSuXBlfX1+6du1KYGAgU6ZMyepSRB6g0Whwc3MDoHjx4iQnJ/Hdd2do374lJpMJa2trNBoNaXoTwZsvEvE4iWEdq1D7tUK5XLkQIr+RmWpeAQVtSCQ09BJjxgznyJFv2bVrBytXLkWlUqPVapg1az7VqtUgMHAgv/zyMwBlylbAuVo/YhPTGN6pChW88vdIQkH7PjyP9MFM+mCWE0OmEoivAPnCmz2rDw9jkpm/5TLJOj2julSnTHGn57w6/5Dvg5n0wUz6YCZTt4kst3//PpYuXcThwyfo2LFN+olNKSkpuLu7s3v3Afr37014+B0URaFx47eYPHlGrtQaEZnE/K2XMBoVxnavSakicqadECL7SCAWIGPGDOfChR/R/rn6w+7dBwCIiIigVy9/5sxZyNatm3j8+BFHjnxLYmIibdo0JSBgIMWKFcvRWsMfJLBg22U0ahVje9SguEf+ucRGCPFqkkAsQLy9S+Pv34NJkz7McP+kSWNo2rQZ5cqVx9PTk4YNmwCg/nNybGtrqxyt81ZEHIu2h2JjpeHDbjUo7Gqbo58vhCiYJBALkKFDRxIaeinDfXfuhBEefpdVq9YD4ODgiIODI6mpqfTq5U+tWrVxc3PP3sJUEJ+s58Gtx+j1RtZ+fR0HGwvGdK+Ou5NN9n62EEL8SQKxgFu7djXVqtXA0tIy/b6IiAj693+XcuVey/7FcFVw/bc4lmy/jE5vxMpCQ8+Wr1HV2wVHW8t/f70QQmQRWTCugAsNvUTr1m3Tb8fHx9G7tz/NmvmxePHybP3sxBQ94Q8T08MQQKc3sunQLyDzkgohcpjsIRZw8fFxVKlSPf32rFkz0Ol0hIQcIiTkEADBwQupXr3mS32Ooig8jEnh1h9x3IqI5VZEPPcik/BvVi49DJ/Q6Y3EJqXhaGPxUp8phBAvQgKxgKlWrQZHjnybfvv48XMZHp8z59lLLb0ovcHInfsJhEXEcfOPOG5FxJGYogfA1kpLmeJO1K1YmEpeLlhZaDKEopWFBmc7GS4VQuQsCUSRJeISddyKMAffrT/iuPsgAeOfkyYUdrGhWhk3yhRzokxxZzzdbP9a0V4Fw/2rZziGONy/Oo62FpD351wQQuQhEojihZlMChGRSX+GXyy3IuJ4HJsKgFajxtvTgRa1S1CmmBM+xZ3++eQYBSqUdCJ4yBsk643YWmgkDIUQuUICsaD785KH2MQ0nB2scLTRPhVGKToDt+/HE/ZHHDcj4rh9L44UnXmI09HOkrLFnHizRnHKFneiZGEHLLQveK6WAo42FviUdDVPzSRhKITIBRKIBdkzLnkY7l+dwi5W3AiPTR/+/P1xIooCKqCYhx11KxahTDFHyhR3xsPJWlaqF0LkCxKIBVh8sv6pSx6WbL9M+0Y+bD92AytLDT5FHWn7hhdlijlRuqgTttb/7Svzv3OohoQcZO7cmajVGjw9Pfnii41otVrq169PcnLynytfaDlw4CjHjh0mOHgWKpUKjUbD0qUr8fEpk5VtEEIIQAKxQItNTHvmJQ+ebrZM61ebYh52aNQvf6nq3+dQDQ6eSWDgKDp06MTgwe+xaNE8PvxwAnFxcRw7diZ9yjiAuXNnM27cRJo29WP69I+YOXMqa9ZseumahBDi7+TC/ALMwdYCKwtNhvusLDR4ezpQsrBDloQhmOdQDQ5emH47LU1Hhw6dAKhT53VCQy8SFnYLo9FI+/Z+tGjRiNWrVwCwdOlKmjb1A8BgMGBpmbPzqgohCg4JxAIqRWdgc8ivdG1eLj0UM1zykIWGDh2JldVfQWZtbcP27VsA+OabI+h0OlJTU2jcuDE7dnzFypVr2bhxHXfuhFGuXHkA9u7dxbffnmT8+MlZWpsQQjwhQ6YFUHKqnoXbQwl/kEDDakUJHvIGsUlpONtZ5sglD0FBswkKmsLatavw8SmLVpuEj09ZZs6ciclkibe3Dy4urly8+CPe3j4sXjyffft2s3DhUry8vLO3OCFEgSV7iAVMYoqeeVsvE/4ggcEdKlO1tBuONhaUdLczT5WWA5c87NmzixUr1nDw4HESEuJp2LAxW7ZsoE2bNgBERUUSGxuDr+/rzJs3mwMHvmLDhm3UrOmb/cUJIQos2UMsQOKT01iw9TL3o5IY1rEK1cpk87JOz+HjU5Y+fXqg0Wjw8SlDQMAAAM6ePUXz5g0BFV279sTT05N9+3ZhaWlFQEAvAMqWLceyZatypW4hRP6mUhQlz14GHRWViMmUZ8tP5+HhYL4gPRvFJaUxf8slHsWmENipCpW93bL18/6LnOhDXiB9MJM+mEkfzLKqD2q1Cjc3+2c+JnuIBcC2nTv57NNPqPD2x7zu+ZiR77d/6hrAdu38SE1NyXAN4BP9+vWkVCkvpk2bmYtbIYQQ2UuOIeZzI0YOY9mS+ZhMJkb7V2fjmsUMGzaKkJCT2NrasWjRPAASEuI5dOgEhw+fSA/Du3fv0KZNM27fvpWbmyCEEDlCAjEfi4xN4X6SLd71ArDUqilXwvm51wAaDE9fAxgbG8PgwYFUqVItNzdDCCFyhARiPvUoJpngzRcpVPFtevhVQq02zzf6vGsA69Wr/9Q1gNWr1+Ttt9vn5mYIIUSOkUDMh+5HJTFn00V0ehMfdq+Bp5tt+mNBQbNZv341rVq9iZOTM/b2Dvj4lGX8+MlYW1tnuAZQCCEKkmwLxNDQUHr1Mp8q//PPP9OwYUN69epFr169+PrrrwFYtmwZnTt3plu3bly5ciW7SilQIiKTCN58CaNJYWz3GpQq4pDh8eddA9i7tz+Q8RpAIYQoSLLlLNPPP/+cL7/8EhsbGwCuXbtGv379CAgISH/OtWvXOH/+PDt27OD+/fsEBgaya9eu7CinwPj9USLzt15CrVLxYY+aFHO3e+o5z7sG8NSp4xmuASxVqlQOVy+EELkrWwKxZMmSLF26lLFjxwJw9epV7ty5w7FjxyhVqhQTJ07kwoULNGjQAJVKRdGiRTEajURHR+Pq6podJeV74Q8SmL/1EpYWGj7sXoMirn8Nk1arVoMjR74FYMCAwQwYMPip169du/m57y0XwgshCoJsCUQ/Pz/++OOP9NtVq1alS5cuVK5cmeXLl/Ppp5/i4OCAs7Nz+nPs7OxISEh4oUB83sWVeZGHh8O/P+k5bvwWw/xtl7G1sWDmoPp4PmPPMK94mT7kJ9IHM+mDmfTBLLv7kCMX5jdv3hxHR8f0PwcFBdG0aVOSkpLSn5OUlISDw4ttrMxUA7f+iGPh9svY21jwYbfqaBVTnp3VQmbkMJM+mEkfzKQPZjkxU02OnGX63nvvpZ80c+7cOSpVqkTNmjU5ffo0JpOJe/fuYTKZZLj0Bf36WwwLtl/Gyc6S8T1r4u5kk9slCSFEnpUje4jTpk0jKCgICwsL3N3dCQoKwt7eHl9fX7p27YrJZGLKlCk5UUq+8fPdaJbsuoKbozVjutXAxUEWzhVCiJchk3vnoP3797F06SIOHz7BsWOHCQ6ehUqlwsJCy+LFK/DxKUPfvj34/fdwtFrzIr3/939bKVy4SIb3uXo7iqW7f6KQiw1jutXAyc4yNzYny8nQkJn0wUz6YCZ9MJPJvfORMWOGc+HCj2i15tXp586dzbhxE2na1I85c6Yxc+ZU1qzZxL17f7BmzebnXvZw+VYkn+35iaJudnzQrToOtvkjDIUQIrcVmJlq9u/fh59fEwCOHTtMixaN8fNrQuvWTQkL+2vy6rt379CkyeskJMRn6ed7e5cmOHhh+u2lS1fStKkfAEajEUtLKwwGAykpKQwfPpAWLRoxc+b0DO9x4dfHfLr7J4p72DOmew0JQyGEyEIFIhDHjBnOggXBmExG4K+9s8OHT1C3bj1mzpwKwPr1a3jvvXcxGAxZXsPQoSOxsvrrOF+5cuUB2Lt3F0ePHmX8+MnExsZQs6Yv69dvZfPmXXzzzRGOHzevPHH++kOW772KVxEHxnSrgb2NRZbXKIQQBVmBCMR/2jszGAxYWpqDSqNRsW7dZtRqTY7UtXjxfJYsWcAXX3yBl5c3jo5OTJ48A2dnZ9zdPShdujQ//HCec9cesPLLa/gUc2R01+rYWstItxBCZLUCEYj/tHf27bcnGT9+MgDvvtuPEiVyZsqyefNmc+DAV2zYsI26desC8MMP3+Pv3560tDRSU1O5e/cuTp4VWP3Vz5Qv4cwo/2rYWEkYCiFEdiiw/7ouXjyffft2s3DhUry8vHP0s9PS0ti3bxeWllYEBPRCrVbh41OWZctWUatWbVq3fguVSk3ZirX4PsKJSl4uDOtUFSuLnNlzFUKIgqhABuK8ebM5cuQQGzZso1ixEjn2uf87p+jp038tr/S/pxPPm7cYgGMX/mDTkRtU9XFj6DuVsdBKGAohRHYqcIH4970zgLJly71SE1iHnP+Nrd/cokZZdwa1r4yFtkCMbAshRK4qMIH4vL2zZzl16vucKOmZDpy7y66Tt/Et78GAdpXQaiQMhRAiJxSYQMwLvjx9h72n71C3YmH6v10BjVrCUAghcooEYm5SQXyynvu3HhMVm8Lpq/d5o3IRAlpXQK1W5XZ1QghRoEgg5hIFhZ/D41i2IxSd3oiVhYa+b1ekdnl31EgYCiFETiu4gfjn3llsYhrODlY42mjhJeYJVxSFFJ2RhJQ0EpL1JCSlkZCiJyHZfDv+z/8/ud2ibin2ngxDpzfPnqPTG1m3/2cqlHwDR5mFRgghclzBDEQVXP8tjiXbL6fvnQ33r06Fkk7poWgOOMOfIWYOsr9CTW8OvqQ/b/8ZfAbjsxPVykKDg60FDraWONtbUaKQPa6O1ulh+IRObyQ2KU0CUQghckGBDMT4ZH16GII5iJZsv0zv1hU4dO5u+l6c8TlLS1lZanD8M+BcHKwoWdgBBzsLHGws04PP8X9uWz7jgvr4VANWFpoMoWhlocE5nyzlJIQQeU2BDMTYxLRn7p3pDUbcHK3xKuKAg+2TcLPA0dYyw+2suEje0UbLcP/qT+2lOtpavNTQrRBCiP+mQAais4PVM/fOqpdxp1EVz5wpQoEKJZ0IHvIGyXojthYaCUMhhMhFBfJCtyd7Z0/mBs2wd5aTFHC0saCKj4f5uKGEoRBC5JoCuYf4v3tnsUlpONtZyt6ZEEIUcAUzECF97yz9jM5sDMP9+/exdOkiDh8+QUjIQebOnYlarcHT05MvvtgIQLt2fqSmpqBSqdFqtRw4cJQffzzPxIljABWFChVi3botaLUF969MCCGyU4EcMs1JY8YMZ8GCYEwm8/HK4OCZDBs2ipCQk9ja2rFo0TwAEhLiOXToBIcPn+DAgaMATJ/+Ee+9N5CQkJMArFr1We5shBBCFAASiNnM27s0wcEL02+npeno0KETAHXqvE5o6EVu3LiBwWCkfXs/WrRoxOrVKwCIi4ulS5fuADRs2Jhz587k/AYIIUQBka8Dcf/+ffj5NQEgJOQgzZo1oEWLxvTp0w2DwZD+vNjYWN56qz7r1q0G4PLli/j5NaZFi8Z06dKO2NjY/1zD0KEjsbKySr9tbW3D9u1bAPjmmyPodDpSUlKoV68+O3Z8xcqVa9m4cR137oShKKD+c4JvR0cnUlNT/nMdQggh/lm+DcTMDlUCDBzYD9X/TB86bdokWrRoTUjISapVq8HUqROyrK6goNmsX7+aVq3exMnJGXt7B8qWLcv48ZOxtrbG29sHFxdXLl78MUNN8fFx2NjYZFkdQgghMsq3gZiZoUqADz8cSeXKVXB390h/blxcLN26vQvAm28249atG1lW1549u1ixYg0HDx4nISGehg0bs2bNGnr39gcgKiqS2NgYfH1fx8nJmW3bNgHw7bcnqVWrdpbVIYQQIqN8G4iZGarcvPn/uHfvDyZPnpHhta6ubmzcuBaA3bu3o9cbyCo+PmXp06cHzZs3wsbGloCAAQwbNgwPj0I0b96Qbt060rVrT0qVKsVHH01nzZrPad68IQaDgcGDh2dZHUIIITJSKYqSZ6++i4lJwvSc+UYBQkMvMXp0IMeOnebcuTPMmDEZk8mEj09ZkpOTiI+PIz4+HrVaTVJSEhYWFkyaNI1SpUoxZsxIUlNTqFKlGjdu/MpXXx3Otu1wc7MnKiox294/r5A+mEkfzKQPZtIHs6zqg1qtwsXF7pmP5emL2p63UU84OtqgUqlwc7PnwIG9bN++HS8vL9q1a4efXwuGDRuW/tzmzZvzzjvv0K1bJyZPnszs2bNo1KgRgwYNok6d2ri52WfrtmT3++cV0gcz6YOZ9MFM+mCW3X3I04H4IsqXL0+7du3QarWUK1cuQxj+XbVq1QgMDESj0VC4cGF27dqVg5UKIYTIDXl6yFQIIYTIKvn2pBohhBDiRUggCiGEEEggCiGEEIAEohBCCAFIIAohhBCABKIQQggBSCAKIYQQQAG6MD83hYaGMn/+fDZs2MC1a9eYOnUqlpaWVKhQgUmTJqFWqxk8eDAxMTFYWFhgZWXF6tWrCQ8PZ/z48ahUKsqWLcvUqVPTl4PKa/5rD65fv05QUBAajQZLS0uCg4Nxd3fP7c35z/5rH5746quv2LhxI9u2bcvFrXh5/7UPUVFRfPTRR8THx2M0Gpk7dy4lS5bM7c35z17m52Lq1KloNBq8vLyYOXNmnv23ATLXh927d7NlyxaMRiNNmzZl6NChREdHM2bMGFJTUylUqBCzZ89+uVWBFJGtVq1apbz99ttKly5dFEVRlHfeeUe5cOGCoiiKsnDhQmXv3r2KoihKq1atFJPJlOG1AwcOVL777jtFURRl8uTJSkhISA5WnnVepgc9e/ZUfv75Z0VRFGXLli3KrFmzcrDyrPUyfVAURbl27ZrSu3fv9NfnVS/Th3HjxikHDhxQFEVRzp07pxw/fjznCs9iL9OHIUOGKCdOnFAURVFGjx6tHDt2LAcrz1qZ6UN4eLjSuXNnJSUlRTEajcqiRYuUtLQ0JSgoSNm1a5eiKIqycuVKZe3atS9VS979lSKPKFmyJEuXLk2//fDhQ2rWrAlAzZo1uXDhApGRkcTHxzNo0CC6d+/O8ePHAbh27Rp16tQBoFGjRpw9ezbnNyALvEwPFi5cSIUKFQAwGo0ZVjDJa16mDzExMSxcuJCJEyfmSu1Z6WX6cPHiRR4+fEjfvn356quv0n8+8qKX6UOFChWIjY1FURSSkpLQavPuYF9m+nD27FkqV67MuHHjePfdd6lZsyYWFhZcuHCBhg0bAlnzb2Te7WIe4efnxx9//JF+u0SJEpw/f546depw/PhxUlJS0Ov1BAQE0Lt3b+Li4ujevTtVq1ZFURRUf64SbGdnR0JCQm5txkt5mR4UKlQIMP9DuHHjRjZt2pRbm/HS/msfqlSpwpQpU5gwYUKe/oXgiZf5PkRERODo6Mi6detYtmwZn3/+OSNGjMjFrfnvXqYPXl5ezJgxg+XLl+Pg4EDdunVzcUteTmb6EBMTw48//siWLVvQ6XT06NGD6tWrk5iYiIODA5A1/0bKHmIOmzVrFitXrqRPnz64ubnh4uKCu7s73bp1Q6vV4ubmRoUKFbhz506GYwJJSUk4OjrmYuVZ50V6APD1118zdepUVq1ahauray5Xn3Uy24fbt28THh7OtGnTGD16NLdu3WLmzJm5XX6WeZHvg7OzM2+99RYAb731FlevXs3l6rPOi/Rh5syZbNq0iUOHDtGhQwfmzJmT2+VnmWf1wdnZmTp16mBvb4+bmxulS5fm7t272Nvbk5SUBGTNv5ESiDns5MmTzJ8/n/Xr1xMbG0v9+vU5e/Zs+m+5SUlJ3Lx5k9KlS1OxYkW+//57AE6dOoWvr29ulp5lXqQH+/btY+PGjWzYsIESJUrkcuVZK7N9KFOmDAcOHGDDhg0sXLiQMmXKMGnSpFyuPuu8yPehVq1anDx5EoAffviBMmXK5GbpWepF+uDk5IS9vXkppEKFChEfH5+bpWepZ/WhZs2anD9/Hp1OR3JyMmFhYZQsWZKaNWumfx9OnTpFrVq1XuqzZcg0h5UqVYq+fftiY2ND3bp1ady4MQCnT5/G398ftVrN6NGjcXV1Zdy4cUyePJmFCxdSunRp/Pz8crn6rJHZHjg5OTFz5kw8PT0JDAwEoHbt2gwfPjw3y88yL/JdyM9e9Gfio48+YuvWrdjb27NgwYJcrj7rvEgfPv74Y0aNGoVWq8XCwoKgoKBcrj7rPK8PnTp1onv37iiKwpAhQ3B2dmbw4MGMGzeO7du34+Li8tLfB1n+SQghhECGTIUQQghAAlEIIYQAJBCFEEIIQAJRCCGEACQQhRBCCEACUQghhAAkEIUQQghALswXIk/54IMPaNu2LU2aNCEsLCx9Oazw8HBMJhMjR46kbt26HDp0iE2bNmEwGFCpVCxbtoybN28yf/58LCws8Pf3p0OHDrm9OUK8UiQQhchDunTpwpYtW2jSpAk7d+6kRo0aJCYmMmvWLGJiYnj33Xc5cOAAd+/eZdWqVdjY2DBlyhROnz5N4cKF0el07NixI7c3Q4hXkgSiEHlI3bp1+fjjj4mOjubMmTPUqFGDixcvcuXKFQAMBgPR0dG4ubkxbtw47OzsuH37NtWrVwfA29s7F6sX4tUmgShEHqJSqWjXrh0ff/wx9evXx9PTE09PTwYNGkRqairLly/HwsKCJUuWcOLECQD69evHkxka8/Kq6kJkNwlEIfKYjh070qRJE/bt20eJEiX46KOPePfdd0lMTKRHjx7Y29tTs2ZNunbtilarxdHRkUePHlG8ePHcLl2IV5pM7i1EHvPw4UPGjh3L+vXrc7sUIfIVGT8RIg8JCQmhf//++WYJLCFeJbKHKIQQQiB7iEIIIQQggSiEEEIAEohCCCEEIIEohBBCABKIQgghBCCBKIQQQgDw/4JtnB5b2UlRAAAAAElFTkSuQmCC\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcQAAAFDCAYAAACk6n5/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAABjG0lEQVR4nO3ddXyV9fvH8deJdRcwcmOEdA0QSSVGSEiMkppIjxJJyUmMlFBCJH50g4LAAAkJRYkhiAIDpo5c99mJ+/fHkfmdgA5ZsO16Ph4+5PR1X5zx3v257/vzUSmKoiCEEEIUcOrcLkAIIYR4FUggCiGEEEggCiGEEIAEohBCCAFIIAohhBCABKIQQggBSCAKIYQQgASiEEIIAYA2twsQIrfs3r2b48ePk5qayuPHj+nduzfHjh3j5s2bjB07lmbNmrFx40ZCQkJISUnBxcWFZcuWMWHCBNq2bUuTJk0ICwsjODiYVatWpb/v+PHjURSF+/fvk5ycTHBwMD4+PixYsICrV68SGxvLa6+9xuzZs7lw4QLBwcFotVpsbGxYvHgxjx8/ZsKECWi1WkwmEwsWLMDT05MFCxbw448/YjKZ6Nu3L61ataJXr1689tpr3Lx5k8TERBYvXkyxYsX49NNPOXr0KK6urqSkpDBixAgqVqzIpEmTiImJAeCjjz6ifPnyvPnmm5QuXRofHx98fX35/PPP0Wq1FCpUiEWLFqFWm39vjo6OpmfPnnz99deoVCpmzJhBvXr1ePToEXv37kWtVlOlShU++uij9F7cuXOHDz/8kJ07dwIwcuRIAgICSE1NZdGiRWg0GkqUKMGMGTPQ6XRMmjSJhIQEHj16RI8ePejRowe9evXC1dWVuLg4vvjiCzQaTQ5+S0SBoghRQO3atUvp16+foiiKsn//fqVz586KyWRSzp07pwwePFgxGo3K0qVLFaPRqCiKogQEBCg//vijcu7cOWX48OGKoijKnDlzlMOHD2d433HjxilLly5VFEVRTpw4oQwcOFBJSEhQVq1apSiKohiNRqVly5bKgwcPlDlz5ihr1qxRjEajcuTIESUiIkLZuHGjMnPmTCUtLU05e/as8uuvvyonTpxQRo4cqSiKoqSmpirt2rVT4uLilHfffVf58ssvFUVRlIULFyorV65Url+/rnTt2lUxGAxKSkqK0qxZM+W7775T5s6dq2zatElRFEW5c+eO0q1bN0VRFKV8+fJKdHS0oiiKEhgYqBw8eFBRFEXZs2ePEhcXl2HbRowYoZw/f17R6XRK69atFb1er3Ts2FEJDQ1VFEVRNm3apOj1+gyv6dmzp3Lz5k0lJiZG6dSpk2IymZQWLVookZGRiqIoyqJFi5Rt27YpV69eTe/lgwcPlObNmyuKoijvvvuuEhIS8l/+ioV4IbKHKAq0ChUqAODg4ICPjw8qlQonJyd0Oh1qtRoLCwtGjx6Nra0tDx48wGAwULduXT7++GOio6M5c+YMo0ePfup9X3/9dQBq1KjBrFmzsLKyIjo6Ov29kpOT0ev1DBo0iBUrVtCnTx8KFy5M1apV6dy5M59//jn9+/fHwcGBUaNGcePGDa5du0avXr0AMBgMREREAFCxYkUAihQpQmRkJGFhYVSpUgWNRoNGo6Fy5coA3Lhxg++++46DBw8CEBcXB4CLiwsuLi4ATJgwgZUrV7Jx40ZKly5Ns2bNMmyXv78/e/bs4fHjx7z11ltotVpmz57NmjVrmDt3LtWrV0f522yQXbp0Yffu3RQtWpR27doRHR3No0ePGDlyJACpqam88cYbNG7cmPXr1xMSEoK9vT0GgyH9Pby9vf/j37AQmSfHEEWBplKpnvvYL7/8wtGjR/nkk0+YPHkyJpMJRVFQqVS0a9eOjz/+mPr162NhYfHUa69duwbAxYsXKVu2LKdOneL+/fssXLiQ0aNHk5qaiqIofPnll7zzzjts2LCBsmXLsn37do4dO0atWrVYv349LVu2ZPXq1ZQuXZq6deuyYcMG1q9fT6tWrShRosQz6y5Tpgw//fQTJpOJtLQ0fv75ZwBKly5N37592bBhA5988gnt2rUDSB8SBdi2bRuBgYFs3LgRgCNHjmR473r16nH9+nV27dpFly5dANi+fTvTp09n48aNXL9+nUuXLmV4TcuWLTlz5gxHjhyhXbt2uLi4UKRIET777DM2bNjAoEGDeP3111mzZg3Vq1dn/vz5tGzZMkOw/tPfkxBZRfYQhXiOUqVKYWNjQ7du3QDw8PDg0aNHAHTs2JEmTZqwb9++Z7721KlTHDt2DJPJxOzZs7G2tuazzz6jZ8+eqFQqSpQowaNHj6hatSofffQRNjY2qNVqZsyYgaIojBs3juXLl2MymZgwYQIVK1bk/Pnz9OjRg+TkZJo1a4a9vf0zP7t8+fI0btwYf39/XFxcsLCwQKvVMmjQICZNmsT27dtJTExk2LBhT722atWqDBw4EDs7O2xtbWnSpEmGx1UqFX5+fpw9e5aSJUumf16PHj2ws7OjcOHCVKtWLcNrrKysqF27NtHR0Tg7OwMwadIkBgwYgKIo2NnZMXfuXFQqFR9//DFff/01Dg4OaDQa0tLSMv33JcTLUil/H98QQvyrhw8fMnbsWNavX//UY+PHj6d169Y0atQoFyqDqKgoDh06RM+ePUlLS6NNmzasX7+eokWL5ko9ANOnT6dFixbUq1cv12oQ4t/IHqIQLygkJISlS5cybdq03C7lmVxcXLh69SqdOnVCpVLRpUuXXA3DgIAAXFxcJAzFK0/2EIUQQgjkpBohhBACkEAUQgjxCrl58yYVKlTgxIkTNGnSBF9fX3x9falYsWL6SV6dOnWiRo0aVK9enbFjx2bZZ0sgCiGEeCUkJyfTr1+/9EuBTpw4wY8//siePXvQarV89tlnrF27locPH3Lp0iVOnz7NgQMH+P3337Pk8yUQhRBCvBK6d+9Oz549sbGxyXD/0KFDadWqFRUrVqRTp05s2bIFMF8GpCgK1tbWWfL5efos05iYJEymvH9OkJubPVFRibldRq6TPphJH8ykD2YFpQ+zZs3Azs4Rf/9erF69mvj4VKKiErl9O4zbt2+zc+fOP/ugxtbWhYiIx3Tv3platWqjVttkukdqtQoXF7tnPpanA9FkUvJFIAL5ZjtelvTBTPpgJn0wKwh9OH78KKCiefPGJCUlMnnyOFasWMP//d9aqlWrgaWlJSaTDoCIiAj693+XcuVeY+HCZVnWnzwdiEIIIfKHw4dPpv/Zz68J06bNpEyZcoSGXmLo0BHpj8XHx9G7tz+tW7flgw/GZ2kNcgxRCCHEKys+Po4qVaqn3541y7xUWEjIIfz8muDn14TLly9myWfl6Qvzo6ISM+wqG40GYmIeYzDkrfkP1Wo1JpMpt8vINVqtJS4uHhQp4sLjxwm5XU6u8/BwkD4gfXhC+mCWVX1Qq1W4uT17HuB8NWQaE/MYa2tb7OyK5KnZ8bVaNQZDwQxERVFISoonJuYxRYq45HY5QogCLF8NmRoMadjZOeapMCzoVCoVdnaOeW6vXgiR/+SrQARZNy0vkr8zIcSrIN8FYn4UHx9HSMihf31eTEwM3bp1RKczn5qcmJjI2LGjGDZsAAMH9uPq1SvZXaoQQmQtFcSn6Pnp1mPiUw2Qjb8/56tjiPnVrVs3OXPmJC1atHzuc77//hwrViwlOjoq/b5t2zbh61sbf/8e/PbbXaZNm8SaNZtyomQhhHh5Krj+WxxLtl9GpzdiZaFhuH91KpR0gmw4HVQCMQvpdKnMmjWdBw8eoNfrGT16LK+9VpFZs6Zz714ERqORbt160rRpC4YNG8CHH06kVCkvdu/eyePHj2ndui3Tpk2iUKHCRET8QcWKlRgzZgL/939ruHXrJvv27aZ48RJcuXKZfv3ez/DZarWKTz75jPfe65V+n79/DywtLQAwGIxYWlrlaD+EEOJlxCfr08MQQKc3smT7ZYKHvIGjjUWWf54EYhbau3cXRYoUZfr02fz++2+cO3eaX3+9jrOzM1OmBJGcnERAwLvUqlXnue/x+++/sWjRMqysrPH3b09UVCS9ewewb98u2rfvCECtWrWfel3t2q8/dZ+DgwMAUVGRBAVNZvjwD7JoS4UQIvvFJqalh+ETOr2R2KS0bAlEOYaYhX77LZzKlasAUKJESfz9e3D37l2qVasJgK2tHV5e3kRE/JHhdf97KWixYsWxtbVDo9Hg5uZOWtrLnX0ZFnaLESOGMGDAUGrUqPVS7yWEEDnJ0kKNlYUmw31WFhqc7Syz5fMkELNQqVLeXL/+MwAREX8wbdokvLy8uHLlEgDJyUmEhYVRtGhRLC2tiIqKBODXX39Jf49nnXFpvnD/xQfM79y5zeTJ45g69WPq1av/XzZJCCFyRWRsCp/vu0r3FuXTQ/HJMURH26zfOwQZMs1S7dt3ZPbsGQwbNgCj0ciIER/g41OW4OCPGTz4PXQ6HQEB7+Pi4kqXLl1ZsGAOhQsXoVChQv/4vsWKFef27Vts374ZH5+yzzyG+CwrVy4jLS2NxYvnA2Bvb8+cOQuzZFuFECK7xCWlMX/bZRKT9ZQt5kDwkDdI1huxtdCYwzCb5lfLV1O3PXgQTpEipXKxov+mIM9U88SDB+FUqVJZpqhCpup6QvpgVtD6kJyqJ3jzJR7GJDOmWw3KFHMCcmbqNhkyFUII8UrQ6Y0s3nmFe5FJDOtYJT0Mc4oEohBCiFy1f/8+/PyasHzvVS58f5ywQx8xemBH+vTphsFgAGDSpEk0a9aQpk0bMGLEYADCw8Np3fotWrRoTMeObYiNjX2pOiQQhRBC5JoxY4azYEEwujQ9V8KiiLq6h+HDRxMSchJbWzsWLZrHhQs/cODAAXbv3s/hwyfQ6/WkpqYydep4GjV6k5CQk3h5lWbOnKCXqkUCUQghRK7x8ipNC//RGE0KnRqXxmBIo0OHTgDUqfM6oaEX2b9/H8WLF6dPn+60bt2UOnVex9ramt9//43OnbsC0KZNu5eenlICUQghRK4pXq0dobdj0WpUtH69FNbWNmzfvgWAb745gk6nIyYmmvDwcD7/fD0rV65h3brV3L9/H4PBQKFChQFwcXEhLU33UrVIIAohhMgVR378nS/P3KWqjztajRqVSkVQ0GzWr19Nq1Zv4uTkjL29A87OLnh7e+Pu7oG3tw+Ojk5cvPgDWq02/XrumJgYrKxebnpKCcRcEhUVyfz5c3K7jEyTFTeEEFnp7NX7bDl6k5rlPGhZt0T6/Xv27GLFijUcPHichIR4GjZsTJMmTblz5w4JCfFER0cTHx9H9eo1KF68BNu2bQbgwIEvKVfutZeqKdsuzI+KiqJjx46sWbMGnU7HwIED8fLyAqB79+60bt2aZcuWceLECbRaLRMnTqRq1arZVc4rx83NnTFjxud2GZkmK24IIbLK5ZuRrDnwCxVKuTCwXUV+vvbXL8o+PmXp06cHGo0GH58yBAQMAOD48YZ06NAKgFat3qZYsRJMmfIxw4cP5JtvjmBtbcO6dVteqq5sCUS9Xs+UKVOwtrYG4Nq1a/Tr14+AgID051y7do3z58+zY8cO7t+/T2BgILt27cqOcnLM119/RXj4XQYPDkSn09GzZ2d27vyKYcMGULZseW7fDiM5OZGgoGAURWHq1ImsWrWOb745ypo1q3FycsbBwZ433mhIkSKe7Nu3i+nTZwPQrp0fX355mIcPHzB37ix0ulSsrKwZO3YihQsXSa/hv664sXfvTqKiomTFDSFEtvr1txiW77tKqSL2DOtYBQuthmrVanDkyLcADBgwmAEDBj/1us8+++ypC/N9fMpw4MCxLKstWwIxODiYbt26sWrVKgCuXr3KnTt3OHbsGKVKlWLixIlcuHCBBg0aoFKpKFq0KEajkejoaFxdXbOjpFxXoUIlRoz4gJUrP+XIkcM0a9YCAIPBwOLFC1mzZiMODo6MGTPiH9/n008X07lzV+rVq8+PP55nxYplTJ36cfrjsuKGEOJVFf4ggcU7r+DuZM3ILtWwsXq1Zg/N8mp2796Nq6srDRs2TA/EqlWr0qVLFypXrszy5cv59NNPcXBwwNnZOf11dnZ2JCQkvFAg/n36nUeP1Gi1uXdYVK1WoVar/pyKzTxJt1ZrPlBcocJraLVqPD09iYqKRKNRo1JBUlICTk5OuLmZt7tWrVqo1ao/H1elb4+iKGi1am7fvsXGjWvZvPn/AAWNRpthm//44zfq1auPVqvG29sLb28v5s2bTe3addFq1Tg6OuDtXZoHDyJQqVRoNKr0Gp98bvHiJXB0NAeZu7s7RqPhqXr+jVb719/FrVs3mTx5AoGBo6hd++kgNffO/FwPD4cXb3w+JH0wkz6Y5Yc+RDxO5JOdoTjYWTJrSAPcnW1e+D2yuw9ZHoi7du1CpVJx7tw5rl+/zrhx41i+fDkeHh4ANG/enKCgIJo2bUpSUlL665KSktL3JjLr73OZmkymXJ0TVKu14PHjxxgMJn7+2bzqhcFgQlEUTCbzn00mEyaTgtFoQlHA0dGZ5ORkHj16jKurGz//fI369Ruh0VgQGRmJwWDiwYP7xMfHYTCYKFnSi+7d36VKlWqEh9/l0qULGba5RAkvrl69yhtvNCIi4g8+/3w5VapU5dKlizRo0ITk5CRu3bpF4cKeWFhY8ujRY4oXL8Uvv1zH3d0Do9GUXjeAopBeq9GY+f4aDCY0GhN37txm0qSxTJ8+m7Jlyz339SaT+f6CNGfj8xS0uSufR/pglh/6EB2fyuyNFzCZFEZ1qYaiN7zwNuXEXKZZHoibNv11wkSvXr2YNm0aQ4YMYfLkyVStWpVz585RqVIlatasybx583jvvfd48OABJpMpzw+X1q37Bnv37mLw4PcoX74CdnZ2//oalUrFuHETGTduNLa2dqSlpQLw2msVsLe35/33++Dl5Y2nZzEAhg4dwYIFc0hLS0OnS2XEiDEZ3u+/rrjh7u7xj3XKihtCiP8iITmNBdsuk6wzMLZ7TYq42uZ2Sc+VratdPAnE1NRUgoKCsLCwwN3dnaCgIOzt7Vm6dCmnTp3CZDIxYcIEfH19X+j98+NqF8uXL6VUKS9at26by1XlLFnt4i/5YY8gK0gfzPJyH1J0BuZtuUREZBKj/atRvqTLf36vPLmH+L82bNiQ/uetW7c+9XhgYCCBgYHZWYIQQohcoDcYWbb7J357mMiwjlVeKgxzyqt1io9g8GD5BUEIkbcZTSZW7LvG9fAY3n+7ItXLuud2SZkiM9UIIYTIMoqisP7gr1y6GUmPZmWpV7nIv7/oFZHvAjEbD4mKbCJ/Z0K8Gu7cCaNRozqcO3eGY8cO06JFY/z8mtC6dVPCwm4BEBQ0haZNG9C8eUNWr16R4fWKorD9+C1O/3SfdvW9aOZb4lkf88rKV4Go1VqSlBQv/8DmIYqikJQUj1ZrmdulCFGgpaamMnLk0PRrgufOnc24cRM5fPgEdevWY+bMqdy6dYNvvjnKvn2H2LhxB5s2/R+JiYnp7/H1d+EcPv87TWsWp30D79zalP8sXx1DdHHxICbmMYmJsbldygtRq9Xp1+EVRFqtJS4u/3zZhxAiew0aFEDHjv5/TvoBS5eupFy58oB5Ri1LSyu++eYIxYoVw97eHnt7exwdHTl16jitW7flxKUIdp28zeuVCtO9eVlUKlVubs5/kq8CUaPR4u7umdtlvLC8fFq1ECLvmzMnCCcnJ/r0CUgPxCdhuHfvLr799iTr1m1mx46t2Nj8dR2hlZUV0dHRnL/+kA2Hf6WqjxsBrSugzoNhCPksEIUQQry448ePAir8/JqQlJTI5MnjWLFiDQcOfMm+fbtZuHApXl7eODk5kpqakv46nU5HqtGaz7/6mbLFnRjSoTJaTd49EieBKIQQBdzhwyfT/+zn14Rp02ayZ88ujhw5xIYN2yhWzHxyzFtvNWfLlk0kJMSTnJxMbFws391zoHhhO4Z3roalhSa3NiFLSCAKIYTIQK/Xs2/fLiwtrQgIMC/nVrZsOZYtW8VbbzXjnXdaYzIpuHo3wN3VhVFdq2NrnffjJFunbstuf5+6La+SY4hm0gcz6YOZ9MHsVezDo9gUZm+4gFqtYkLPmv9p5YoXlRNTt+XdwV4hhBA5LjZRx4KtlzAYTYzuWj1HwjCnSCAKIYTIlKRUPQu3XSY+Sc8o/+oUc//3FX3ykrw/6CuEECJ7qCA+WU9sYhoOthZsDvmVB9HJjOxSjdJFHXO7uiwngSiEEOJpKrj+WxxLtl9GpzdiZaGha/NyNK5WlIpeeXvt2ueRIVMhhBBPiU/Wp4chgE5vZNuRG5T0zH97hk9IIAohhHhKbGJaehg+odMbiU1Ky6WKsp8EohBCiKc4O1hh9bcL7a0sNDjb5d+J+CUQhRBCPOVxVCJdm5dLD0UrCw3D/avjaGuRy5VlHzmpRgghRAYPopNZtP0K3p4OzBxYj8RUPc52luYwzPtzoTyXBKIQQoh0iSl6PtkRikajonfL13C1t8TV/s9h0nwchiBDpkIIIf5kMJr4dPdPRMfrCOxYFY98NAtNZkggCiGEQFEU/u/wr/z6eywBrV+jTHGn3C4px8mQqRBCFHD79+9j0ScLKNVsGmVsf+ejEVNQqzV4enryxRcb0Wq1tGvnR2pqCiqVGq1Wy4EDRwkJOcjcuTOfem5eJXuIQghRgI0ZM5z58+eQpjdQp0Ihju37nGHDRhESchJbWzsWLZoHQEJCPIcOneDw4RMcOHAUgODgmc98bl4lgSiEEAWYa6HiFKvTF7VKRUDrCqSl6ejQoRMAdeq8TmjoRcLCbmEwGGnf3o8WLRqxevUKgGc+Ny+TQBRCiAIqJkFHpO0b2NnaYKFVY2mhwdrahu3btwDwzTdH0Ol0pKamUK9efXbs+IqVK9eyceM67twJe+Zz87JsC8SoqCgaN25MWFgY4eHhdO/enR49ejB16lRMJhMAy5Yto3PnznTr1o0rV65kVylCCCH+RpdmZMnOK6SkGenSpAwqlfn+oKDZrF+/mlat3sTJyRl7ewd8fMoyfvxkrK2t8fb2wcXFlYsXf3zmc/OybAlEvV7PlClTsLa2BmD27NmMHDmSzZs3oygKx44d49q1a5w/f54dO3awcOFCpk+fnh2lCCGE+BuTovD5/p/57VECg9pVopDLX5dX7NmzixUr1nDw4HESEuJp2LAxW7ZsoHdvfwCioiKJjY3B1/f1Zz43L8uW04GCg4Pp1q0bq1atAuDatWvUqVMHgEaNGnHmzBm8vb1p0KABKpWKokWLYjQaiY6OxtU1fy4rIoQQr4pdJ8O4eOMx3ZuWpVoZd0JDf09/zMenLH369ECj0eDjU4aAgAEAnDp1nObNGwIqunbtSalSpZ773LxKpShKls49sHv3bh48eMCQIUPo1asX06ZNo0+fPpw+fRqAc+fOsWvXLkqXLo2zszM9evQAoGfPnsyaNYtSpUplZTlCCCH+x9Hz4SzedplWb3gxuGNVVE/GSkXW7yHu2rULlUrFuXPnuH79OuPGjSM6Ojr98aSkJBwdHbG3tycpKSnD/Q4OLzb+HBWViMmU9+cS8vBw4PHjhNwuI9dJH8ykD2bSB7Os7MOvv8WwbEcolbxceKe+F5GRiVnyvjkhq/qgVqtwc7N/9mMv/e5/s2nTJjZu3MiGDRuoUKECwcHBNGrUiO+//x6AU6dO4evrS82aNTl9+jQmk4l79+5hMplkuFQIIbLJw+hklu3+iUIuNgzuUBmtRi4y+LscmVJg3LhxTJ48mYULF1K6dGn8/PzQaDT4+vrStWtXTCYTU6ZMyYlShBCiwElK1fPJziuoVCpGdKmGrXX+XcLpZWT5McScJEOm+Yv0wUz6YCZ9MHvZPhiMJhZtD+XmH7GM6VaDciWcs664HJQnh0yFEEK8GhRFYWPIDa6Hx9Cn5Wt5NgxzigSiEELkUyE//M6p0Hu8/UYp6lfxzO1yXnkSiEIIkQ9dvhnJ9m9u4Vvegw4NS+d2OXmCBKIQQuQzvz1MYOWX1/DydOC9tyuilmsNM0UCUQgh8pHYRB2Ld17B1lpLYKeqWFlocrukPEMCUQgh8gmd3jxhd3KqgRGdq+Jsb5XbJeUpEohCCJEPmBSFL/b/TPiDBAa2q0TJwnl75YnckCMX5gshhHi2tLQ0evfuSnR0FAAffTSdEiVKMmLEEHS6VABmzZpPrVq1mTx5POfOmeeFbtv2HUaM+CD9ffZ+e5sff31M17fKUL2se85vSD4ggSiEELlozRrzqkAhIafYtm0T8+fPwcbGhqZNWzBixAfs37+Ty5cv4u5eiNOnT3Lw4HESExPo2LENgYGjUKvVnPnpPvvPhtOoWlFa1C6Ry1uUd0kgCiFELho0aBh9+/YH4O7dO1hbW/Pw4QPu3YugVau3cHNzZcmSVbi6unLw4HGsra25cuUyarUatVrNjd9jWXfwFyqUcuHdFuVk9YqXIMcQhRAil1lbW+Pv356vvtpL27YdMBgMODs7c/DgNxQuXJjJk8elP2/y5HF88EEgVapU41GMecJud2cbhrwjE3a/LOmeEEK8ArZv38e6dZv5/PPlqFQq3n23DwD+/v6Eh99Jf15QUDCHD5/k5s0bjJm+CEVRGNm5KnYyYfdLk0AUQhRoaWlpdOv2Di1aNKJFi0acOnWcI0cO0ahRHfz8muDn14TFi+cD0K6dHy1aNMLPrwlt2jTLks+fO3cWo0cPA8DR0QmVSoWbmztbtmwC4ODBgxQpUpTvvjtD+/YtMZlMaC0sSTMoJKYYGdaxCoVdbbOkloJOjiEKIQq0Z53UUqfO67z+en3mzl2U4bkJCfEcO3YGtTrr9iX69x/Ee++9i59fY0wmEz169OKNNxoyduwojhw5hLW1FStWrKNYsWKULFkKP7/G6A0mLByLMWpof8qXdMmyWgo6Wf7pFSDL3JhJH8ykD2Y52YfU1FSsra0JDv6YCxd+wNLSksjISBTFhIuLG8uWrSQuLo6+fXvg7OyETqfD378H/fsPyvba/t6HIz/8zpZjN2n1ekm6NCmT7Z//qpDln4QQIgf8/aSWSpWqMHLkhxw+fJIiRYowbtxoUlNTqFevPjt2fMXKlWvZuHEdd+6E5Widobci2frNTWqW86BTY58c/eyCQAJRCCHIeFLLO+90pmXL1gB07tyNe/f+wMenLOPHT8ba2hpvbx9cXFy5ePHHHKvv90eJrPjyGiULOfC+TNidLSQQhRAF2rNOahk2bCAHDnwJwKFD+ylevARbtmygd29/AKKiIomNjcHX9/XsK0wF8Sl6frr1mMgEHRsO/4KNpYbhnatiZSkTdmcHOalGCFGgPeukFm9vH+bPn82SJQuxs7NjxYo1FCpUmFOnjtO8eUNARdeuPSlVqlT2FKWC67/FsWT7ZXR6I1YWGro1L0fZoo64OMiE3dlFTqp5BchJFGbSBzPpg1lB7kN8ip5xn51Fpzem32dloSF4yBs42hTM6w1z4qQa2UMUQohcpCgKMQk67kUlce9xEveikihd3DlDGIJ5aafYpLQCG4g5QQJRCCFyQHrwRSYREZnEvSf/RSWRovsr/BxsLShXyg0rC81Te4jOdpa5UXqBIYEohBBZSFEUouPNe3wRf+7xPQm/1LS/As7R1oKi7nbUq1SEou52FHO3w9PdDkdbS1CBi4NVhmOIw/2r42hrAXn/KNErSwJRCCH+TgXxyXpiE9NwdrDC0Ub7VBApikJUfCr3IpPTAy/izz0+3TOCr35lT4q621LU3Y6i7nY42P7D3p4CFUo6ETzkDZL1RmwtNBKGOUACUQgh/tczzvAc2rkqWpXCnfsJ/zPUmZwx+OwsKeZuR4PKnhT1sKOom+2/B98/UcDRxgKfkq7mk0kkDLOdBKIQQvyP+GR9ehiC+WSWT3deoX0jH3YcD8PJzpKi7nY0qOJJsT/39oq622EvJ7vkedkSiEajkY8++og7d+6gUqmYPn06BoOBgQMH4uXlBUD37t1p3bo1y5Yt48SJE2i1WiZOnEjVqlWzoyQhhMiU2MS0Z57h6eXpwJIRDSX48rFsCcTjx48DsHXrVr7//nsWLVrEW2+9Rb9+/QgICEh/3rVr1zh//jw7duzg/v37BAYGsmvXruwoSQgh/lVyqoEH0cnPPMOzqJttlofh/v37WLp0EYcPnyAk5CBz585Erdbg6enJF19sRKvVUr9+fZKTk1Gp1Gi1Wg4cOMqxY4eZM+djVCoVrq5ubNy4A61WBvxeVrZM3dasWTOCgoIAuHfvHo6Ojly9epUTJ07Qs2dPJk6cSGJiIhcuXKBBgwaoVCqKFi2K0WgkOjo6O0oSQoh/9NvDBGas+4Hdx2/Sv10lrCzM06NlOMMzC40ZM5wFC4IxmczBGxw8k2HDRhESchJbWzsWLZoHQFxcHIcOneDw4RMcOHAUgCVLFtG9ey9CQk5hMBhYs+bzLK2toMq2Xym0Wi3jxo3jyJEjLFmyhIcPH9KlSxcqV67M8uXL+fTTT3FwcMDZ2Tn9NXZ2diQkJODq6pqpz3jebAN5kYeHQ26X8EqQPphJH8xyqg9Hz4ezfNcV7G0tGdfbl9dKuVKljAfRCSm4Otjg6W6HWp21k2lXrPgaAwb0Z9iwYXh4OJCWpuP99/sC0KRJI77++mtiYu5jNBrp0KElOp2OPn36MGLECMqU8SE5OR43Nzv0+jRcXOwLxHcmu7cxW/exg4ODGTNmDP7+/mzdupXChQsD0Lx5c4KCgmjatClJSUnpz09KSsLBIfMbLFO35S/SBzPpg1lO9CFNb2TjkRucvnKfCqVcGNiuEo52lkRFJWKpgiKO1oBCVFRiln92QMAQQkMvoSgKjx8nYG1tw6efrsLfvzv79x8gNTWVe/ciady4MZMmBXH/fgT9+vWkXr3GFCtWkq1bt7Jz5060Wgtatmyf778zeXY9xL1797Jy5UoAbGxs/pw9fhhXrlwB4Ny5c1SqVImaNWty+vRpTCYT9+7dw2QyZXrvUAghXsajmGRmbbjA6Sv3efsNLz7oWh3HXJwJJihoNuvXr6ZVqzdxcnLG3t4BH5+yzJw586klp/bs2cmsWfM5ceI76tWrz5Ah7+da3flJtuwhtmjRggkTJtCzZ08MBgMTJ07E09OToKAgLCwscHd3JygoCHt7e3x9fenatSsmk4kpU6ZkRzlCCJHBxRuP+eLAdaLvfE/k9f10HH/yuSe1tGvnR2pqSoaTWjp2bJM+upWSkoK7uzu7dx94qZr27NnFihVrKFGiFH36dKNx47fYsmUDu3dv56uvjmRYckqj0eDm5gaAp2dRfv756kv3RGRTINra2rJ48eKn7t+6detT9wUGBhIYGJgdZQghRAZGk4ldJ29z6PvfiLq8nviHN9LPzgwOnklg4Cg6dOjE4MHvsWjRPD78cAIJCfEcO3YGtfqvAbUn4RcREUGvXv7MmbPwpWvz8SlLnz490Gg0+PiUISBgAABnz556asmpwMAPGDVqKCqVGrVazZw5C17684Us//RKkGNGZtIHM+mDWVb3ITZRx4q9V7nxRxxv1ihGzI2veb1uPSZN+pAjR76lYcPafPvtDwCsXfs5x46FMH36bPr27YGzsxM6nQ5//x707z8o/T379u1O2bLlmDRpepbV+XfyfTDLs8cQhRDiVfJLeAzT1v7A3YcJvN+2Ir38yjM8cBRWVn8ttmttbcP27VsA+OabI+h0OlJTU6hXrz47dnzFypVr2bhxHXfuhAFw504Y4eF3+fDDSbmyTSLrSSAKIfItk6Lw9XfhzNt6CVsrLZN7+1KvUpFnPvd5J7WMHz/5qZNaANauXU21ajWwtJQlmfILCUQhRL6UlKpn2a6f2HkiDN/yhZjcx5diHs+/dvnJSS0HDx4nISGehg0bs2XLBnr39gfIcFILQGjoJVq3bpsj2yJyhsz1I4TIFWlpafTu3ZXo6CgAPvpoOo0avQlAv349KVeuDBMmmI/NjR07igsXzqNSqejY0Z8hQ4b/43uHP0jg0z0/EZOgo0ezsjStVRyV6p8vrH/eSS2nTh1/6qQWgPj4OKpUqf4SHRCvGglEIUSuWLNmFQAhIafYtm0T8+fPoWRJL4YOfZ/ExATKlSsDwP379/nuuzMcOnSCmJgYund/57mBqCgKp0LvsenITRxsLRjfsyY+xZyeW0O1ajU4cuRbAAYMGMyAAYOfes7atZuf+drjx8+90PaKV58EohAiVwwaNIy+ffsDcPfuHaytrYmNjWHw4EAOHfrrmj4XFxesrW2IiYkhLi72uXt6Or2RjYd/5czVB1TydmVA24r/fS1CUSBJIAohco21tTX+/u25dy+CgQOHUr16TapXr5khEAEcHBzo1q0DAPXrN3rqfR5EJ/PZnp+IeJxEu/petKvvneVzj4r8TwJRCJGrtm/fx61bNwgIeJc2bdo/NX3j//3fFyQlJfL118cA6Ny5HQcOfEmbNu0A+PGXR6z5+jpajZpR/tWoXNotx7dB5A+ZCsSHDx+SkJCARqPh888/p1evXlSoUCG7axNC5GNz587iwYN7LFy4DEdHJ1QqFVqt5qnnubm5o9VqsbOzR61WY2VlRXR0FAajiZ0nwgj54XdKF3VkcPvKuDlZ58KWiPwiU5ddfPDBB0RGRrJo0SLq16/PrFmzsrsuIUQ+17//IO7cuY2fX2N69uxMjx69cHR8+gSYTp264uVVmhYtGtO8eUMKFSpM63bdmLv5EiE//E7TWsUZ37OmhKF4aZnaQ1SpVNSuXZsVK1bQpk0btm/fnt11CSHyOVdXV/bs+fqZjy1btirDVF3Llq1Kf+znu9HMWP8jaXoTA9tVom7FwjlSr8j/MhWIBoOBefPm4evry3fffYder8/uuoQQIgOTonDgXDh7v72Np5sdQzpUpqi7XW6XJfKRTAXirFmzOHv2LF26dOHo0aMEBwdnd11CCJEuMUXP6v0/cyUsitcrFqZ3y/JYW8o5gSJrZeobFRQUxJo1awBo3bp1thYkhCjgVBCfrOfBrcfYWmmJT0hl8Y4rxCXp6NWiHE1qFPvXWWeE+C8yFYiOjo4cO3YMLy+v9DXBvL29s7UwIUQBpILrv8WxZPtldHojVhYaujUvh4uDJUPeqYy3p2NuVyjysUwFYlRUFOvWrUu/rVKp+L//+7/sqkkIUUDFJ+vTwxDMs89sPXKDjwfWw81eZp0R2StTgbhhwwYSEhKIiIigRIkS2NnJgWwhRNaLTUxLD8MndHojSal6CUSR7TIViIcPH2b58uUYjUZatmyJSqViyJAh2V2bEKKAcbCzwMpCkyEUrSw0ONtJGIrsl6kL89euXcv27dtxdnZmyJAhHD16NLvrEkIUMDq9ke1Hb9K1eTmsLMwz1lhZaBjuXx1HW4tcrk4UBJnaQ9RoNFhaWqJSqVCpVNjY2GR3XUKIAkSnN7Jk5xV+CY/Bt7wHwUPeIFlvxNZCYw5DJbcrFAVBpgKxVq1ajB49mocPHzJlyhSqVKmS3XUJIQqI/w3D996uQK3yhQDwKelqnqlGwlDkkEwF4ujRozl16hQVK1bEx8eHN998M7vrEkIUALo0I4t3hvLr77H0f7si9SoXye2SRAGWqUBctmxZ+p+vXbvGjRs3KFKkCK1bt8bCQsb2hRAv7qkwrCRhKHJXpgLx119/xcrKCl9fX0JDQ7l//z4eHh6cPn2aefPmZXeNQoh8Zu/ePXyyZCE+ftOp5fGQySOmoFZr8PT05IsvNqLVaqlfvz7JycmoVGq0Wi0HDhzlzp0wRowYgk6XiqIozJ69gFq1auf25oh8IlNnmcbHxzN//ny6devG7NmzUavVzJs3jz/++CO76xNC5DOjRw9n4aJgjEYj779dkV2bPmXYsFGEhJzE1taORYvMv2THxcVx6NAJDh8+wYED5jPbx4//gKZNW3D48EkCAgZy+fLF3NwUkc9kKhATEhKIjo4GICYmhoSEBPR6PampqdlanBAif0lNMxCps6Oob18stGper1SEtDQdHTp0AqBOndcJDb1IWNgtjEYj7dv70aJFI1avXgHAw4cPuHcvglat3mLfvl28806X3Nwckc9kKhADAwPx9/enQ4cOdO3alcDAQNauXUvnzp2f+Xyj0ciECRPo1q0b3bt358aNG4SHh9O9e3d69OjB1KlTMZlMgPn4ZOfOnenWrRtXrlzJui0TQrxSUtMMfLI9FIuSzWnfqBwatXmCbmtrG7Zv3wLAN98cQafTkZqaQuPGjdmx4ytWrlzLxo3ruHMnDIPBgLOzMwcPfoOHRyEmTx6Xm5sk8plMHUN88803ady4MdHR0bi5uaFSqWjUqNFzn3/8+HEAtm7dyvfff8+iRYtQFIWRI0dSt25dpkyZwrFjxyhatCjnz59nx44d3L9/n8DAQHbt2pU1WyaEeGU8CcNbEfEMbFcJq7R76Y8FBc0mKGgKa9euwsenLFptEj4+ZZk5cyYmkyXe3j64uLhy8eKPqFQq3n23DwBt23Zg8eL5ubVJIh/K1B7imTNnGDhwIKNHj6ZPnz707t37H5/frFkzgoKCALh37x6Ojo5cu3aNOnXqANCoUSPOnj3LhQsXaNCgASqViqJFi2I0GtOHZoUQ+UOKzsCiP8NwQLuK1KmQcYX7PXt2sWLFGg4ePE5CQjwNGzZmy5YNtGnTBoCoqEhiY2Pw9X0dNzd3tmzZBMDx48coUqRojm+PyL8ytYc4e/ZsJk6cSJEimT8tWqvVMm7cOI4cOcKSJUs4c+ZM+hpmdnZ2JCQkkJiYiLOzc/prntzv6uqaqc9wc7PPdD2vOg8Ph9wu4ZUgfTDLL31ITtUzf9t3hN2LZ8y7tWhYvRgAzs62qFQqPDwcqFq1En379kCr1VKuXDnGjfsAgLNnT9GiRSNUKhX9+vXD17cyS5YsZvDgwRw7dhhLS0t27NiRb3r1TwrCNmZGdvdBpSjKv84D8f777/P555//pw94/Pgx/v7+JCYm8sMPPwBw9OhRzp49i5eXFzqdjvfffx+ADh06sGbNmkwHYlRUIiZT3p/GwsPDwTwjRwEnfTDLL31I0RlYtCOU2xHxDGxfidqvFXqh1+eXPrws6YNZVvVBrVY9d2cqU0Ombm5uTJkyha1bt7Jt2za2bdv2j8/fu3cvK1euBMDGxgaVSkXlypX5/vvvATh16hS+vr7UrFmT06dPYzKZuHfvHiaTKdNhKIR4db1sGAqRGzI1ZFq8eHEAIiMjM/WmLVq0YMKECfTs2RODwcDEiRPx8fFh8uTJLFy4kNKlS+Pn54dGo8HX15euXbtiMpmYMmXKf98SIcQr4ckxw9v34hnUvhK+EoYij8jUkCnA2bNn+f3336lWrRre3t5YWVlld23/SoZM8xfpg1le7kOKzsDC7Ze5ez+Bge1eLgzzch+ykvTBLCeGTDO1h7hw4UIePHhAWFgYlpaWrFq1ioULF750YUKI/ON/w3BQ+0rpq1YIkVdkKhAvXLjApk2b6NWrF++88w5btmzJ7rqEENkoNTWVXr38iYuLw2Qy4u/fnUOHviYpKQmAlJQU3N3d2b37AIGBA7l+/RoqlZqRI8fQpk27p94vOdXAou2XufsggUHtK1OrvEdOb5IQLy1TgWg0GtHpdKhUKoxGI2p1ps7FEUK8ohYtmou9vT07dnxJRMTvdO/eiVOnzgMQERFBr17+zJmzkJCQg9y8eYOQkFNcu3aVUaOGPBWIyanmPcNwCUORx2UqEPv06UPHjh2Jjo6mS5cu9O3bN5vLEkJkpwEDhvDk9AGTyZR+jTDApEljaNq0GeXKlWf9+i+oWLEyarWaKlWqoigKd+/ewcvLG8gYhoM7VKZmOQlDkXdlKhBbtWrFG2+8QXh4OCVKlMDFxSW76xJCZCM3N3cAIiMf8/77fWjXriMAd+6EER5+l1Wr1gOQmJiAs/NfP+9arZbIyMd4eXmTnKpnwbZQfnuYwJAOlakhYSjyuEyNfZ49e5bQ0ND0PcSvvvoqu+sSQmSza9d+omvXd2jY8E0++MA8SfbataupVq0GlpaWANjbO5CUlJj+GoPBgIdH4T/D8LI5DN+RMBT5Q6YCcdGiRXh5ebFhwwa2bNnC1q1bs7suIUQ2Cgu7xdChA3jvvQFMmjQ1/f7Q0Eu0bt02/XbDhk24du0nDAYDP/10BUVR8Chc9M8wTGToO1WoUVbCUOQPmRoytba2xs3NDa1Wi4eHR4bjDUKIvCcoaApGo4H169ewfv0aAHbs2Ed8fBxVqlRPf17Llq3Zv38vLVu+CSgMGDic+Vsv8/sjcxhWL+ueOxsgRDbIVCDa29vTv39/unbtyqZNm2R6NSHyuHXrNj/z/uPHzz1137JlqwBIStWzQMJQ5GOZCsTFixfz22+/UaZMGW7evEmXLrJKtRAFSVKqnvlbLxPxOJGhHatQvYyEoch/MnUM8fbt2yQkJBAaGsrHH3/MhQsXsrsuIcQrIkMYviNhKPKvTAXitGnTsLS0ZPny5YwaNYply5Zld11CiFdAYoqe+VvMYTisYxWqSRiKfCxTQ6aWlpaULVsWvV5P9erVZaYaIfIrFcQn64lNTMPOxoINB38mItIchlV9JAxF/papQFSpVIwdO5ZGjRrx9ddfY2Fhkd11CSFymgqu/xbHku2X0emNWFlo6Na8HC3rluK1kjIZh8j/Mn0d4jvvvEPv3r1xdXWVlS6EyIfik/XpYQig0xvZeuQGRT2evVSOEPlNpgJRrVaTkJDAvn37uH//Ptu2bcvuuoQQOSw2MS09DJ/Q6Y3EJqXlUkVC5KxMDZkOGzaM0qVLc+PGDaysrLCxscnuuoQQOchkUohPTsPKQpMhFK0sNDjbWeZiZULknEztISqKwowZM/D29mbt2rXExsZmc1lCiJwSk6Bj3pZL/N/B6/RtUxErCw1gDsPh/tVxtJVzBkTBkKk9RI1Gg06nIyUlJX1NRCFE3nf1ThSff/UzOr2RXi3KU7eCBxVKvUFsUhrOdpbmMFRyu0ohckamArFnz5588cUXlCtXjkaNGuHr65vddQkhspHRZGLvt3f4+lw4RT3sGNy+MkXd7UABRxsLHG3+3CuUMBQFSKYvu9i5cyeOjo5YWlrSsWPH7K5LCJFNYhJ0rNx3lRt/xNGomifdm5VLHyYVoiDLVCB+9tln7NixAzc3NyIjIxk0aBANGzbM7tqEEFnsp9vmIVK9wcT7bStSr1KR3C5JiFdGpgLR2dkZNzc3ANzd3bG3l+uShMhLjCYTe07d4evvwinuYUd5u3CmjZ7K4cMnCAk5yNy5M1GrNXh6evLFFxvRarW0a+dHamoKKpUarVbLgQNHOXLkEEFBU7CxsQWgdeu3GTFiTC5vnRBZI1OBaGdnx3vvvUft2rW5du0aqamp6Rfnjx49OlsLFEK8nOj4VFZ8eY1bf8TRuHpRQkM+Y/WlH9FqzcOkwcEzCQwcRYcOnRg8+D0WLZrHhx9OICEhnmPHzmSYqvH778/x+uv1mTt3UW5tjhDZJlOB2KxZs/Q/Fy5cONuKEUJkrdBbkaze/zMGk8LAdpWoW7Ewn4aVplu3Hkya9CEAaWk6OnToBECdOq9z7FgIYWG3MBiMtG/vh06nw9+/B/37D+KXX34mMjISP7/GuLi4sWzZStzdPXJzE4XIMpkKxHfeeSe76xBCZCGD0cTuU7c59P1vlChkz5AOlSnsah7mHDp0JKGhl9Kfa21tw/btW/D378433xxBp9ORmppCvXr1mTFjNvfvR9CvX0+aNm1OpUpVqFHDl5YtWzNy5BDGjRvNF19syK3NFCJLZSoQX4Rer2fixIlERESQlpbG4MGD8fT0ZODAgXh5eQHQvXt3WrduzbJlyzhx4gRarZaJEydStWrVrC5HiFdOamoqvXr5ExcXh8lkxN+/OxUrVmHGjI8A83H6NWs2Y21tDYDBYKB9+5bUrl2XadNm/uv7R8WlsuLLq4RFxPNmjWJ0a1oGC+3zzyINCppNUNAU1q5dhY9PWbTaJHx8yjJ+/GSsra3x9vbBxcWVixd/pG/f9/H09ASgc+duzJw5NQs6IsSrIcsD8csvv8TZ2Zl58+YRGxtLhw4dGDp0KP369SMgICD9edeuXeP8+fPs2LGD+/fvExgYyK5du7K6HCFeOYsWzcXe3p4dO74kIuJ3unfvhIuLCwMGDKFz52706NGRNWtWMWTIcACGDRtAWpouU+99+WYkXxz4GaNJYVD7StSp8O+HOPbs2cWKFWsoUaIUffp0o3Hjt9iyZQO7dm1j//6jREVFEhsbg6/v6/Tq5c+oUR/Spk07Dh3aT/HiJV6qF0K8SrI8EFu2bImfnx9gnvJNo9Fw9epV7ty5w7FjxyhVqhQTJ07kwoULNGjQAJVKRdGiRTEajURHR+Pq6prVJQnxShkwYAiKYr7i3WQyoVKp2LHjKywtLUlOTiY+Ph4XF/NyS0uXLkKlUlG+fIV/fE+D0cTOE2GE/PA7pQo7MKhDJQq72GaqHh+fsvTp0wONRoOPTxkCAgYAcOrUcZo3bwio6Nq1J6VKlWLs2InMnz+bJUsWYmdnx4oVa/57I4R4xaiUJz+ZWSwxMZHBgwfj7+9PWloa5cuXp3Llyixfvpz4+HgcHBxwdnamR48egHk2nFmzZlGqVKnsKEcIAJKTk2nbti2xsbEYjUb69OlDuXLlmDJlCiqVCo1Gw4YNGyhXrhz9+/fn/PnzWFhY0Lt3b0aMGJGltTx8+JA2bdrQtm1bpk6dyoULF+jduzdarZZ9+/Zx8+ZNZsyYwfHjx+nbty+FChV65tJrD6OTmbvhB278Fsvb9b0JaFfpH4dIhRDPluV7iAD3799n6NCh9OjRg7Zt2xIfH4+joyMAzZs3JygoiKZNm5KUlJT+mqSkJBwcHF7oc6KiEjGZ8v7cUh4eDjx+nJDbZeS6nOjD7NkzsLGxZevWvenDlTY2towdO4GmTf2YPv0jPvhgDL17v8f333/Pvn2HAOjQoRWtW3fE2dk5S+q4du0nhg8fzFtvNWfIkNE8fpxAyZLlOHHiO+bP/5h+/QJwcnIiPj6BOnXqkpKSglqtYt68RfTt2z/9fS7eeMyaA9dRUBjSoTK+rxUiNiY5S2rMbfJzYSZ9MMuqPqjVKtzcnn0tfaZWu3gRkZGRBAQE8OGHH9K5c2cA3nvvPa5cuQLAuXPnqFSpEjVr1uT06dOYTCbu3buHyWSS4VKR7QYMGMK8eYuBv4Yrly5dSdOm5mF+g8GApaUVoaGXKFnSCwcHRxwcHHFycubUqRNZUkNY2C2GDh3Ae+8NYNIk80kpbdu24Pz57wBwdHREpVLz+ef/x9Gj33L48AmqVq1GkyZN08PQYDSx+egNlu3+iUIuNkztVwff1wplSX1CFFRZvoe4YsUK4uPj+eyzz/jss88AGD9+PLNmzcLCwgJ3d3eCgoKwt7fH19eXrl27YjKZmDJlSlaXIsRT3NzcAYiMfMz77/ehXbuOlCtXHoC9e3fx7bcnWbduMxERf/Dll7uJjHxMSkoykZGPSUyMz5IagoKmYDQaWL9+DevXm4/BDRo0lI8+GotarcbS0pL585c+9/WPY1NYse8qd+4n0My3OF2alMFCm+W/2wpR4GTbMcScIEOm+UtO9eF/hyuf7KEtXjyffft2M3/+EmrWNK/mMnPmVE6ePI6DgyNGo5HAwNE0bdo82+v7pz5c+PURa77+BRXQr3UFapXPvxfFy8+FmfTBLCeGTLPlGKIQr6onw5UDBgymR4/eAMybN5sjRw6xYcM2ihUzX0Zw9+4dEhOTCAk5xcOHD+jZswsNGzbOtbr1BhPbv7nFsYt/4O3pyOD2lXB3tsm1eoTIjyQQRYHy9+FKRVFITk7C0tKKgIBeAJQtW44lS1bw2293adasAWq1mkGDhmJpaZkrNT+KSWb5vmuEP0igRe0SdG7ig1YjQ6RCZDUJRFGgrFu3OdPP3bRpZzZWkjk//PKIdQevo1apCOxUhRpl8+8QqRC5TQJRiFeFCuKT9Ty49RhrCzXHL/zBV2fu4lPUkYHtK+HuJEOkQmQnCUQhXgUquP5bHEu2X0anN2JloaFr83J0alwavzolZYhUiBwggShEDlIUhRSdgZgEHbGJaX/+X0fxIg6s3HMVnd4IgE5vZNuRGwQPeUPCUIgcIoEoBKQPV8YmpuHsYIWjjRZe8IoevcFEbKI54GISdMQ+Cb1E859j/nwsTW966rXdW5RPD8MndHojsUlpONpYvMyWCSEySQJRiGcMVw73r06Fkk6ggElRSEjW/xVqCX+Fnvl2GrGJOhJT9E+9tVajxsXBEmd7K7yKOOBs746zvRUuDlY421vi4mCFk70VOqPC7uO3MoSilYUGZ7vcObNViIJIAlEUePHJ+vQwBPOe2ZLtl+nZsjx7T4YRl5iG8W8TQKgARztLnB2scHeypkxxJ3PApYedFc4OVthZa1GpVP9ag5UlDPev/lQoO9pavPCeqhDiv5FAFAVebGLaM4crFQVeK+nyV8D9z56dk70lGnUWHttToEJJJ4KHvEGy3oithUbCUIgcJoEoCjw7Gy1WFpqnhiur+bjRsHKRnCtEAUcbC3xKupqnqJIwFCJHyelrokCLTdSxbv/PdGteDisL8xqCGYYrhRAFhuwhigIrKi6VeVsvEZeYRodGpQke8gaxSWk421lm23Dl/v37WLp0EYcPnyAk5CBz585Erdbg6enJF19sRKvVUr9+fZKTk1Gp1Gi1Wg4cOJr++gULgjl0aD9Hjnyb9cUJUcBJIIoC6WFMMvO3XCJZZ+SDbtXxKeoE8NclDtkQhmPGDOfChR/R/rmafXDwTAIDR9GhQycGD36PRYvm8eGHE4iLi+PYsTOo/3aM8siRQxw9eijrCxNCADJkKgqgiMeJzNl4EZ3exNjuNShTzClHPtfbuzTBwQvTb6el6ejQoRMAdeq8TmjoRcLCbmE0Gmnf3o8WLRqxevUKAH7/PZxPPpnPuHGTc6RWIQoiCURRoIQ/SCB48yVQwbieNSlVxCHHPnvo0JFYWVml37a2tmH79i0AfPPNEXQ6HampKTRu3JgdO75i5cq1bNy4jrCwWwwbNoCJE6fi4uKSY/UKUdBIIIoCY82GrfTq1gorCzVvFI2kTzc/WrRoTJ8+3TAYDAC0a2feM/Pza0KbNs0AOH36FC1aNKJFi0Z07dqB1NTULKknKGg269evplWrN3Fycsbe3gEfn7LMnDkTa2trvL19cHFx5cKFH4iPj2fGjMmMGTOclJQU+vXrkSU1CCH+IoEoCoRBQwez9vNPABPje9ZixafzGTZsFCEhJ7G1tWPRonkAJCTEc+jQCQ4fPpF+Msu8eTMZMGAIISGnAFizZlWW1LRnzy5WrFjDwYPHSUiIp2HDxmzZsoE2bdoAEBUVSWxsDHXrvsHx4+c4fPgE8+cvwcbGhrVrM7+MlRAic+SkGpHvhd6K5F6iLVWbDeLXU1/g5mT91PG7Y8dCCAu7hcFgPn6n0+nw9+9B//6D2LHjKywtLUlOTiYxMSHLhi19fMrSp08PNBoNPj5lCAgYAMDZs6do3rwhoKJr156UKlUqSz5PCPHPJBBFvvbjL49Y+eU1ajXpRouKMOXPqxWeHL/z9++e4fhdvXr1mTFjNvfvR9CvX0+aNm2Ot7cPP/0USmDgQDQaLQ0aNPrP9VSrViP9kokBAwYzYMDgp56zd+9e84X5//J6IUTWkiFTkW+d+ek+y/ddxdvTkQ+718DW+q/f/553/G78+MkZjt9dvPgjAFWqVOPEie94882mfPDB8NzaJCFENpJAFPnS8UsRfHHgOq+VdGF012oZwhCef/yud29/4K/jd76+r9O2bQvOn/8OAAcHB1Qq+bERIj+SIVOR7xw+/xvbvrlFVR83hr5TGYs/L4T/X887fnfq1PGnjt+9995APvpoLGq1Gq3WgoULl+XwFgkhcoJKUZQ8O4VwVFQiJlOeLT+dh4fDc48ZFSQv2wdFUfjqzF32nr6D72uFGNC2Yp5cbV6+D2bSBzPpg1lW9UGtVuHmZv/Mx2QPUeQLiqKw80QYB7//jfqVi9C39WtZuzyTECLfk0AUeZ5JUdh85AbfXIzgzRrF6NmiHOpMLMorhBD/K8sDUa/XM3HiRCIiIkhLS2Pw4MGUKVOG8ePHo1KpKFu2LFOnTkWtVrNs2TJOnDiBVqtl4sSJVK1aNavLEfmc0WRi3cFfOPPTA1rWKUmXN30ytUK9EEL8XZaPKX355Zc4OzuzefNmVq9eTVBQELNnz2bkyJFs3rwZRVE4duwY165d4/z58+zYsYOFCxcyffr0rC5FvKL279+Hn18TAI4dO0zz5g3/nBqtRfoUapMnj6dZswY0a9aAxYsXPPN9DEYTK7/8mTM/PaB9A28JQyHES8nyQGzZsiUjRowAzMd1NBoN165do06dOgA0atSIs2fPcuHCBRo0aIBKpaJo0aIYjUaio6OzuhzxihkzZjgLFgRjMplXp1+yZBHdu/ciJOQUer2eNWs+Jzw8nNOnT7J//1G2bt3Drl3bMJlMGd5HbzDy6e6f+PGXR/i/WYb2DbwlDIUQLyXLh0zt7OwASExMZPjw4YwcOZLg4OD0f6zs7OxISEggMTERZ2fnDK9LSEjA1dU105/1vDOF8iIPj5xbdSE3Vaz4GgMG9GfYsGF4eDhQpowPycnxuLnZodPpcHGxx9e3Mj/++CPW1tacOXMDtVpN4cJ/LdGUqjPw8drvCQ2LYnCnqrR+wzsXtyh7FJTvw7+RPphJH8yyuw/ZclLN/fv3GTp0KD169KBt27bMmzcv/bGkpCQcHR2xt7cnKSkpw/0ODi+2sXLZRd4TEDCE0NBLKIrC48cJFCtWkq1bt7Jz504sLCxo2bJ9ei9GjhzNiRPfUL16zfT7klMNfLIzlLCION5rU4HaZd3zXe8K0vfhn0gfzKQPZjlx2UWWD5lGRkYSEBDAhx9+SOfOnQGoWLEi33//PQCnTp3C19eXmjVrcvr0aUwmE/fu3cNkMr3Q3qHIH/bs2cmsWfM5ceI7mjRpwpAh76c/FhQUzOHDJ7l16wZbt24iMUXPvK2XuHMvnkHtK1O/imcuVi6EyG+yPBBXrFhBfHw8n332Gb169aJXr16MHDmSpUuX0rVrV/R6PX5+flSuXBlfX1+6du1KYGAgU6ZMyepSRB6g0Whwc3MDoHjx4iQnJ/Hdd2do374lJpMJa2trNBoNaXoTwZsvEvE4iWEdq1D7tUK5XLkQIr+RmWpeAQVtSCQ09BJjxgznyJFv2bVrBytXLkWlUqPVapg1az7VqtUgMHAgv/zyMwBlylbAuVo/YhPTGN6pChW88vdIQkH7PjyP9MFM+mCWE0OmEoivAPnCmz2rDw9jkpm/5TLJOj2julSnTHGn57w6/5Dvg5n0wUz6YCZTt4kst3//PpYuXcThwyfo2LFN+olNKSkpuLu7s3v3Afr37014+B0URaFx47eYPHlGrtQaEZnE/K2XMBoVxnavSakicqadECL7SCAWIGPGDOfChR/R/rn6w+7dBwCIiIigVy9/5sxZyNatm3j8+BFHjnxLYmIibdo0JSBgIMWKFcvRWsMfJLBg22U0ahVje9SguEf+ucRGCPFqkkAsQLy9S+Pv34NJkz7McP+kSWNo2rQZ5cqVx9PTk4YNmwCg/nNybGtrqxyt81ZEHIu2h2JjpeHDbjUo7Gqbo58vhCiYJBALkKFDRxIaeinDfXfuhBEefpdVq9YD4ODgiIODI6mpqfTq5U+tWrVxc3PP3sJUEJ+s58Gtx+j1RtZ+fR0HGwvGdK+Ou5NN9n62EEL8SQKxgFu7djXVqtXA0tIy/b6IiAj693+XcuVey/7FcFVw/bc4lmy/jE5vxMpCQ8+Wr1HV2wVHW8t/f70QQmQRWTCugAsNvUTr1m3Tb8fHx9G7tz/NmvmxePHybP3sxBQ94Q8T08MQQKc3sunQLyDzkgohcpjsIRZw8fFxVKlSPf32rFkz0Ol0hIQcIiTkEADBwQupXr3mS32Ooig8jEnh1h9x3IqI5VZEPPcik/BvVi49DJ/Q6Y3EJqXhaGPxUp8phBAvQgKxgKlWrQZHjnybfvv48XMZHp8z59lLLb0ovcHInfsJhEXEcfOPOG5FxJGYogfA1kpLmeJO1K1YmEpeLlhZaDKEopWFBmc7GS4VQuQsCUSRJeISddyKMAffrT/iuPsgAeOfkyYUdrGhWhk3yhRzokxxZzzdbP9a0V4Fw/2rZziGONy/Oo62FpD351wQQuQhEojihZlMChGRSX+GXyy3IuJ4HJsKgFajxtvTgRa1S1CmmBM+xZ3++eQYBSqUdCJ4yBsk643YWmgkDIUQuUICsaD785KH2MQ0nB2scLTRPhVGKToDt+/HE/ZHHDcj4rh9L44UnXmI09HOkrLFnHizRnHKFneiZGEHLLQveK6WAo42FviUdDVPzSRhKITIBRKIBdkzLnkY7l+dwi5W3AiPTR/+/P1xIooCKqCYhx11KxahTDFHyhR3xsPJWlaqF0LkCxKIBVh8sv6pSx6WbL9M+0Y+bD92AytLDT5FHWn7hhdlijlRuqgTttb/7Svzv3OohoQcZO7cmajVGjw9Pfnii41otVrq169PcnLynytfaDlw4CjHjh0mOHgWKpUKjUbD0qUr8fEpk5VtEEIIQAKxQItNTHvmJQ+ebrZM61ebYh52aNQvf6nq3+dQDQ6eSWDgKDp06MTgwe+xaNE8PvxwAnFxcRw7diZ9yjiAuXNnM27cRJo29WP69I+YOXMqa9ZseumahBDi7+TC/ALMwdYCKwtNhvusLDR4ezpQsrBDloQhmOdQDQ5emH47LU1Hhw6dAKhT53VCQy8SFnYLo9FI+/Z+tGjRiNWrVwCwdOlKmjb1A8BgMGBpmbPzqgohCg4JxAIqRWdgc8ivdG1eLj0UM1zykIWGDh2JldVfQWZtbcP27VsA+OabI+h0OlJTU2jcuDE7dnzFypVr2bhxHXfuhFGuXHkA9u7dxbffnmT8+MlZWpsQQjwhQ6YFUHKqnoXbQwl/kEDDakUJHvIGsUlpONtZ5sglD0FBswkKmsLatavw8SmLVpuEj09ZZs6ciclkibe3Dy4urly8+CPe3j4sXjyffft2s3DhUry8vLO3OCFEgSV7iAVMYoqeeVsvE/4ggcEdKlO1tBuONhaUdLczT5WWA5c87NmzixUr1nDw4HESEuJp2LAxW7ZsoE2bNgBERUUSGxuDr+/rzJs3mwMHvmLDhm3UrOmb/cUJIQos2UMsQOKT01iw9TL3o5IY1rEK1cpk87JOz+HjU5Y+fXqg0Wjw8SlDQMAAAM6ePUXz5g0BFV279sTT05N9+3ZhaWlFQEAvAMqWLceyZatypW4hRP6mUhQlz14GHRWViMmUZ8tP5+HhYL4gPRvFJaUxf8slHsWmENipCpW93bL18/6LnOhDXiB9MJM+mEkfzLKqD2q1Cjc3+2c+JnuIBcC2nTv57NNPqPD2x7zu+ZiR77d/6hrAdu38SE1NyXAN4BP9+vWkVCkvpk2bmYtbIYQQ2UuOIeZzI0YOY9mS+ZhMJkb7V2fjmsUMGzaKkJCT2NrasWjRPAASEuI5dOgEhw+fSA/Du3fv0KZNM27fvpWbmyCEEDlCAjEfi4xN4X6SLd71ArDUqilXwvm51wAaDE9fAxgbG8PgwYFUqVItNzdDCCFyhARiPvUoJpngzRcpVPFtevhVQq02zzf6vGsA69Wr/9Q1gNWr1+Ttt9vn5mYIIUSOkUDMh+5HJTFn00V0ehMfdq+Bp5tt+mNBQbNZv341rVq9iZOTM/b2Dvj4lGX8+MlYW1tnuAZQCCEKkmwLxNDQUHr1Mp8q//PPP9OwYUN69epFr169+PrrrwFYtmwZnTt3plu3bly5ciW7SilQIiKTCN58CaNJYWz3GpQq4pDh8eddA9i7tz+Q8RpAIYQoSLLlLNPPP/+cL7/8EhsbGwCuXbtGv379CAgISH/OtWvXOH/+PDt27OD+/fsEBgaya9eu7CinwPj9USLzt15CrVLxYY+aFHO3e+o5z7sG8NSp4xmuASxVqlQOVy+EELkrWwKxZMmSLF26lLFjxwJw9epV7ty5w7FjxyhVqhQTJ07kwoULNGjQAJVKRdGiRTEajURHR+Pq6podJeV74Q8SmL/1EpYWGj7sXoMirn8Nk1arVoMjR74FYMCAwQwYMPip169du/m57y0XwgshCoJsCUQ/Pz/++OOP9NtVq1alS5cuVK5cmeXLl/Ppp5/i4OCAs7Nz+nPs7OxISEh4oUB83sWVeZGHh8O/P+k5bvwWw/xtl7G1sWDmoPp4PmPPMK94mT7kJ9IHM+mDmfTBLLv7kCMX5jdv3hxHR8f0PwcFBdG0aVOSkpLSn5OUlISDw4ttrMxUA7f+iGPh9svY21jwYbfqaBVTnp3VQmbkMJM+mEkfzKQPZjkxU02OnGX63nvvpZ80c+7cOSpVqkTNmjU5ffo0JpOJe/fuYTKZZLj0Bf36WwwLtl/Gyc6S8T1r4u5kk9slCSFEnpUje4jTpk0jKCgICwsL3N3dCQoKwt7eHl9fX7p27YrJZGLKlCk5UUq+8fPdaJbsuoKbozVjutXAxUEWzhVCiJchk3vnoP3797F06SIOHz7BsWOHCQ6ehUqlwsJCy+LFK/DxKUPfvj34/fdwtFrzIr3/939bKVy4SIb3uXo7iqW7f6KQiw1jutXAyc4yNzYny8nQkJn0wUz6YCZ9MJPJvfORMWOGc+HCj2i15tXp586dzbhxE2na1I85c6Yxc+ZU1qzZxL17f7BmzebnXvZw+VYkn+35iaJudnzQrToOtvkjDIUQIrcVmJlq9u/fh59fEwCOHTtMixaN8fNrQuvWTQkL+2vy6rt379CkyeskJMRn6ed7e5cmOHhh+u2lS1fStKkfAEajEUtLKwwGAykpKQwfPpAWLRoxc+b0DO9x4dfHfLr7J4p72DOmew0JQyGEyEIFIhDHjBnOggXBmExG4K+9s8OHT1C3bj1mzpwKwPr1a3jvvXcxGAxZXsPQoSOxsvrrOF+5cuUB2Lt3F0ePHmX8+MnExsZQs6Yv69dvZfPmXXzzzRGOHzevPHH++kOW772KVxEHxnSrgb2NRZbXKIQQBVmBCMR/2jszGAxYWpqDSqNRsW7dZtRqTY7UtXjxfJYsWcAXX3yBl5c3jo5OTJ48A2dnZ9zdPShdujQ//HCec9cesPLLa/gUc2R01+rYWstItxBCZLUCEYj/tHf27bcnGT9+MgDvvtuPEiVyZsqyefNmc+DAV2zYsI26desC8MMP3+Pv3560tDRSU1O5e/cuTp4VWP3Vz5Qv4cwo/2rYWEkYCiFEdiiw/7ouXjyffft2s3DhUry8vHP0s9PS0ti3bxeWllYEBPRCrVbh41OWZctWUatWbVq3fguVSk3ZirX4PsKJSl4uDOtUFSuLnNlzFUKIgqhABuK8ebM5cuQQGzZso1ixEjn2uf87p+jp038tr/S/pxPPm7cYgGMX/mDTkRtU9XFj6DuVsdBKGAohRHYqcIH4970zgLJly71SE1iHnP+Nrd/cokZZdwa1r4yFtkCMbAshRK4qMIH4vL2zZzl16vucKOmZDpy7y66Tt/Et78GAdpXQaiQMhRAiJxSYQMwLvjx9h72n71C3YmH6v10BjVrCUAghcooEYm5SQXyynvu3HhMVm8Lpq/d5o3IRAlpXQK1W5XZ1QghRoEgg5hIFhZ/D41i2IxSd3oiVhYa+b1ekdnl31EgYCiFETiu4gfjn3llsYhrODlY42mjhJeYJVxSFFJ2RhJQ0EpL1JCSlkZCiJyHZfDv+z/8/ud2ibin2ngxDpzfPnqPTG1m3/2cqlHwDR5mFRgghclzBDEQVXP8tjiXbL6fvnQ33r06Fkk7poWgOOMOfIWYOsr9CTW8OvqQ/b/8ZfAbjsxPVykKDg60FDraWONtbUaKQPa6O1ulh+IRObyQ2KU0CUQghckGBDMT4ZH16GII5iJZsv0zv1hU4dO5u+l6c8TlLS1lZanD8M+BcHKwoWdgBBzsLHGws04PP8X9uWz7jgvr4VANWFpoMoWhlocE5nyzlJIQQeU2BDMTYxLRn7p3pDUbcHK3xKuKAg+2TcLPA0dYyw+2suEje0UbLcP/qT+2lOtpavNTQrRBCiP+mQAais4PVM/fOqpdxp1EVz5wpQoEKJZ0IHvIGyXojthYaCUMhhMhFBfJCtyd7Z0/mBs2wd5aTFHC0saCKj4f5uKGEoRBC5JoCuYf4v3tnsUlpONtZyt6ZEEIUcAUzECF97yz9jM5sDMP9+/exdOkiDh8+QUjIQebOnYlarcHT05MvvtgIQLt2fqSmpqBSqdFqtRw4cJQffzzPxIljABWFChVi3botaLUF969MCCGyU4EcMs1JY8YMZ8GCYEwm8/HK4OCZDBs2ipCQk9ja2rFo0TwAEhLiOXToBIcPn+DAgaMATJ/+Ee+9N5CQkJMArFr1We5shBBCFAASiNnM27s0wcEL02+npeno0KETAHXqvE5o6EVu3LiBwWCkfXs/WrRoxOrVKwCIi4ulS5fuADRs2Jhz587k/AYIIUQBka8Dcf/+ffj5NQEgJOQgzZo1oEWLxvTp0w2DwZD+vNjYWN56qz7r1q0G4PLli/j5NaZFi8Z06dKO2NjY/1zD0KEjsbKySr9tbW3D9u1bAPjmmyPodDpSUlKoV68+O3Z8xcqVa9m4cR137oShKKD+c4JvR0cnUlNT/nMdQggh/lm+DcTMDlUCDBzYD9X/TB86bdokWrRoTUjISapVq8HUqROyrK6goNmsX7+aVq3exMnJGXt7B8qWLcv48ZOxtrbG29sHFxdXLl78MUNN8fFx2NjYZFkdQgghMsq3gZiZoUqADz8cSeXKVXB390h/blxcLN26vQvAm28249atG1lW1549u1ixYg0HDx4nISGehg0bs2bNGnr39gcgKiqS2NgYfH1fx8nJmW3bNgHw7bcnqVWrdpbVIYQQIqN8G4iZGarcvPn/uHfvDyZPnpHhta6ubmzcuBaA3bu3o9cbyCo+PmXp06cHzZs3wsbGloCAAQwbNgwPj0I0b96Qbt060rVrT0qVKsVHH01nzZrPad68IQaDgcGDh2dZHUIIITJSKYqSZ6++i4lJwvSc+UYBQkMvMXp0IMeOnebcuTPMmDEZk8mEj09ZkpOTiI+PIz4+HrVaTVJSEhYWFkyaNI1SpUoxZsxIUlNTqFKlGjdu/MpXXx3Otu1wc7MnKiox294/r5A+mEkfzKQPZtIHs6zqg1qtwsXF7pmP5emL2p63UU84OtqgUqlwc7PnwIG9bN++HS8vL9q1a4efXwuGDRuW/tzmzZvzzjvv0K1bJyZPnszs2bNo1KgRgwYNok6d2ri52WfrtmT3++cV0gcz6YOZ9MFM+mCW3X3I04H4IsqXL0+7du3QarWUK1cuQxj+XbVq1QgMDESj0VC4cGF27dqVg5UKIYTIDXl6yFQIIYTIKvn2pBohhBDiRUggCiGEEEggCiGEEIAEohBCCAFIIAohhBCABKIQQggBSCAKIYQQQAG6MD83hYaGMn/+fDZs2MC1a9eYOnUqlpaWVKhQgUmTJqFWqxk8eDAxMTFYWFhgZWXF6tWrCQ8PZ/z48ahUKsqWLcvUqVPTl4PKa/5rD65fv05QUBAajQZLS0uCg4Nxd3fP7c35z/5rH5746quv2LhxI9u2bcvFrXh5/7UPUVFRfPTRR8THx2M0Gpk7dy4lS5bM7c35z17m52Lq1KloNBq8vLyYOXNmnv23ATLXh927d7NlyxaMRiNNmzZl6NChREdHM2bMGFJTUylUqBCzZ89+uVWBFJGtVq1apbz99ttKly5dFEVRlHfeeUe5cOGCoiiKsnDhQmXv3r2KoihKq1atFJPJlOG1AwcOVL777jtFURRl8uTJSkhISA5WnnVepgc9e/ZUfv75Z0VRFGXLli3KrFmzcrDyrPUyfVAURbl27ZrSu3fv9NfnVS/Th3HjxikHDhxQFEVRzp07pxw/fjznCs9iL9OHIUOGKCdOnFAURVFGjx6tHDt2LAcrz1qZ6UN4eLjSuXNnJSUlRTEajcqiRYuUtLQ0JSgoSNm1a5eiKIqycuVKZe3atS9VS979lSKPKFmyJEuXLk2//fDhQ2rWrAlAzZo1uXDhApGRkcTHxzNo0CC6d+/O8ePHAbh27Rp16tQBoFGjRpw9ezbnNyALvEwPFi5cSIUKFQAwGo0ZVjDJa16mDzExMSxcuJCJEyfmSu1Z6WX6cPHiRR4+fEjfvn356quv0n8+8qKX6UOFChWIjY1FURSSkpLQavPuYF9m+nD27FkqV67MuHHjePfdd6lZsyYWFhZcuHCBhg0bAlnzb2Te7WIe4efnxx9//JF+u0SJEpw/f546depw/PhxUlJS0Ov1BAQE0Lt3b+Li4ujevTtVq1ZFURRUf64SbGdnR0JCQm5txkt5mR4UKlQIMP9DuHHjRjZt2pRbm/HS/msfqlSpwpQpU5gwYUKe/oXgiZf5PkRERODo6Mi6detYtmwZn3/+OSNGjMjFrfnvXqYPXl5ezJgxg+XLl+Pg4EDdunVzcUteTmb6EBMTw48//siWLVvQ6XT06NGD6tWrk5iYiIODA5A1/0bKHmIOmzVrFitXrqRPnz64ubnh4uKCu7s73bp1Q6vV4ubmRoUKFbhz506GYwJJSUk4OjrmYuVZ50V6APD1118zdepUVq1ahauray5Xn3Uy24fbt28THh7OtGnTGD16NLdu3WLmzJm5XX6WeZHvg7OzM2+99RYAb731FlevXs3l6rPOi/Rh5syZbNq0iUOHDtGhQwfmzJmT2+VnmWf1wdnZmTp16mBvb4+bmxulS5fm7t272Nvbk5SUBGTNv5ESiDns5MmTzJ8/n/Xr1xMbG0v9+vU5e/Zs+m+5SUlJ3Lx5k9KlS1OxYkW+//57AE6dOoWvr29ulp5lXqQH+/btY+PGjWzYsIESJUrkcuVZK7N9KFOmDAcOHGDDhg0sXLiQMmXKMGnSpFyuPuu8yPehVq1anDx5EoAffviBMmXK5GbpWepF+uDk5IS9vXkppEKFChEfH5+bpWepZ/WhZs2anD9/Hp1OR3JyMmFhYZQsWZKaNWumfx9OnTpFrVq1XuqzZcg0h5UqVYq+fftiY2ND3bp1ady4MQCnT5/G398ftVrN6NGjcXV1Zdy4cUyePJmFCxdSunRp/Pz8crn6rJHZHjg5OTFz5kw8PT0JDAwEoHbt2gwfPjw3y88yL/JdyM9e9Gfio48+YuvWrdjb27NgwYJcrj7rvEgfPv74Y0aNGoVWq8XCwoKgoKBcrj7rPK8PnTp1onv37iiKwpAhQ3B2dmbw4MGMGzeO7du34+Li8tLfB1n+SQghhECGTIUQQghAAlEIIYQAJBCFEEIIQAJRCCGEACQQhRBCCEACUQghhAAkEIUQQghALswXIk/54IMPaNu2LU2aNCEsLCx9Oazw8HBMJhMjR46kbt26HDp0iE2bNmEwGFCpVCxbtoybN28yf/58LCws8Pf3p0OHDrm9OUK8UiQQhchDunTpwpYtW2jSpAk7d+6kRo0aJCYmMmvWLGJiYnj33Xc5cOAAd+/eZdWqVdjY2DBlyhROnz5N4cKF0el07NixI7c3Q4hXkgSiEHlI3bp1+fjjj4mOjubMmTPUqFGDixcvcuXKFQAMBgPR0dG4ubkxbtw47OzsuH37NtWrVwfA29s7F6sX4tUmgShEHqJSqWjXrh0ff/wx9evXx9PTE09PTwYNGkRqairLly/HwsKCJUuWcOLECQD69evHkxka8/Kq6kJkNwlEIfKYjh070qRJE/bt20eJEiX46KOPePfdd0lMTKRHjx7Y29tTs2ZNunbtilarxdHRkUePHlG8ePHcLl2IV5pM7i1EHvPw4UPGjh3L+vXrc7sUIfIVGT8RIg8JCQmhf//++WYJLCFeJbKHKIQQQiB7iEIIIQQggSiEEEIAEohCCCEEIIEohBBCABKIQgghBCCBKIQQQgDw/4JtnB5b2UlRAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -1199,14 +1327,14 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "flights = sns.load_dataset('flights')\n", "may_flights = flights.query(\"month == 'May'\")\n", - "ax = grplot(plot='lineplot+scatterplot', \n", + "ax = plot2d(plot='lineplot+scatterplot', \n", " df=may_flights, \n", " x='year', \n", " y='passengers', \n", @@ -1218,13 +1346,13 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "id": "135cb2e6", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1234,13 +1362,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "flights = sns.load_dataset('flights')\n", - "ax = grplot(plot='lineplot', \n", + "ax = plot2d(plot='lineplot', \n", " df=flights, \n", " x='year', \n", " y='passengers', \n", @@ -1829,13 +1957,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "id": "1fc79960", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1845,13 +1973,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='histplot', \n", + "ax = plot2d(plot='histplot', \n", " df=tips, \n", " x='total_bill', \n", " xsep='.c', \n", @@ -1866,13 +1994,13 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "id": "7f3dfce9", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1882,13 +2010,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='histplot', \n", + "ax = plot2d(plot='histplot', \n", " df=tips, \n", " x='total_bill', \n", " hue='sex',\n", @@ -2446,7 +2574,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "id": "e7ae1611", "metadata": { "scrolled": false @@ -2454,7 +2582,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -2464,13 +2592,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='kdeplot', \n", + "ax = plot2d(plot='kdeplot', \n", " df=tips, \n", " x='total_bill', \n", " xsep='.c', \n", @@ -2904,13 +3032,13 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "id": "731acad0", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -2920,7 +3048,13 @@ } ], "source": [ - "ax = grplot(plot='ecdfplot', \n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", + "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", + "\n", + "\n", + "tips = sns.load_dataset('tips')\n", + "ax = plot2d(plot='ecdfplot', \n", " df=tips.head(5), \n", " x='tip', \n", " xsep='.c', \n", @@ -3319,13 +3453,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "id": "5ab18ba8", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -3335,13 +3469,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='kdeplot+rugplot', \n", + "ax = plot2d(plot='kdeplot+rugplot', \n", " df=tips, \n", " x='total_bill', \n", " xsep='.c', \n", @@ -3353,13 +3487,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 13, "id": "609a4990", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe0AAAFDCAYAAAAXolZlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAABXpklEQVR4nO3deVyU5fo/8M/swAz74hKLylJa7gtm2OLJnx6/x6X6hlBiR02TshKzo5EmJpqlYUct2pcvLmAnszrVOWpauCSpRbmgBBbgxjIswwwwM8w8vz9wxhnmGRhgtme43q9Xr2TmWe5rZuCa+7nv57p5DMMwIIQQQojb47u6AYQQQgixDSVtQgghhCMoaRNCCCEcQUmbEEII4QhK2oQQQghHUNImhBBCOIKSNiEOUFBQgLS0NOPP//nPf/C3v/0NV69excqVKzF9+nSkpKQgOTkZTz75JCoqKgAA27Ztw5QpU5CSkmL8Lzs72+L47bebPn0663ZdUV9fj6+++goA8O677+K3337r0fE6smPHjg6fv3jxIk6ePGn1+favb3t79+7F5s2bLR5PS0uDRqPBypUrkZ+fb3U7QtyV0NUNIMTT/fvf/8aHH36Ijz/+GCEhIQCA559/HnfffTcA4NSpU1i6dCk+++wzAMDf//53JCcnd3pc0+00Gg2mTZuGxMREBAcHd6udFy9exKFDhzB9+nQsWrSoW8ewVXZ2NubMmWP1+f379yMkJARjx46163m3bNli1+MR4myUtAlxoH379mHHjh346KOP4O/vz7rNmDFjIBKJUFZW1u3z1NXVobW1FRKJBNu2bUNISAiSk5NRWlqKjIwM5OTk4PDhw9i6dStkMhn8/f1x66234umnnzYe4+2338aFCxeQl5eHX375BdOmTUNNTQ0OHjwIlUqFuro6PPXUU5gyZYpxn//7v/+DQqHAkiVLoNFoMGPGDPzrX//C8uXLoVQq0dzcjLS0NCQkJBj3yc7ORkNDAzIyMvDiiy/ihRdewOXLl6HT6TBv3jyMHj0an3/+OUQiEW6//XZcvXoVO3fuRGtrK3g8HrZv327Ta1JYWIjHHnsMSqUSTz/9NO69915MmjQJ3377bbdfZ0JcjZI2IQ5y6tQpVFZWoqGhATqdrsNtg4ODUVdXBwD4+OOP8c033xifW7x4Me666y6LfT7++GN8/fXXuHbtGvr06YPMzEzIZDLW4+t0OmRmZiIvLw8hISF47rnnLLZZvHgxcnNzMXv2bPzyyy/Gx5ubm/HRRx+htrYWDz/8MP7yl79AKGz70zFz5kw88sgjeOqpp/Ddd9/hvvvuw7Vr11BfX4/3338fcrkcf/75p9l5UlNTsWPHDmRkZGDHjh0ICgrC5s2boVQq8eCDDyI3NxcPPPAAQkJCMGzYMBw/fhzvvvsuvL298dJLL+Ho0aPo06dPh68nAHh7e+Pdd981tttwZYMQLqOkTYiDhIaG4qOPPsKnn36K559/Hu+99x74fPZpJFevXkXfvn0BsF8eP3XqFP75z38CABYsWGC23dmzZ7Fs2TIMGDDAaltqa2shk8mMl+fHjBmDmpoam+IYO3Ys+Hw+QkJC4Ofnh9raWoSFhQEA/P39MXjwYJw+fRqff/45VqxYgejoaMyePRvLli1Da2srUlJSrB67tLQUEyZMAADIZDJER0cbx/cNgoODsWLFCkilUly6dAkjRoywqd2jR48Gj8dDcHAwfH19UV9fb9N+hLgzmohGiINERUVBIpFgzpw5EIlEVieKHTt2DF5eXsakzWbMmDHIyclBTk4O7r33XrPn7rjjDixcuBDLli2DXq+HRCJBdXU1AODcuXMA2hKfSqVCbW0tAODXX3+1OAefz4der7d43HCMmpoaKJVKizHzxMREfPLJJ2hpaUF0dDQuXrwIlUqFd999Fxs3bsS6dessjmlY8iA6OhqnTp0CACiVShQXFyM8PBw8Hg96vR6NjY3YunUrtmzZgszMTEgkEti6XMKZM2cAANXV1WhqakJgYKBN+xHizqinTYgTbNiwAbNmzcLo0aMBAJs2bTL2vKVSKd544w3jtu0vjw8cOBAvv/xyh8d/+OGH8e2332L37t3461//iqVLl+LkyZO4/fbbAbQl5NWrV2PhwoXw9fWFXq9HVFSU2TEiIyNRXFyMjz/+2OzxmpoaPPbYY2hsbMSaNWsgEAjMnh83bhxWr16N1NRUAMCAAQPw5ptv4ttvv4Ver8czzzxj0d7o6GgsX74cGzZswOrVq5GcnAy1Wo0lS5YgODgYd9xxB1577TVER0dj1KhRmD17NoRCIfz8/FBVVYXw8PCOX3AALS0tmDt3LpqamvDyyy+Dx+N1ug8h7o5Hq3wR0ju88847mDdvHsRiMZYvX46EhATMmjWrw3327t2LS5cuYfny5c5pJCGkQ9TTJqSXkEqlSExMhJeXF2655RZMmzbN1U3qsYyMDJSWllo8/t5778HLy8sFLSLEsainTQghhHCEw3raBQUFWLp0KWJiYgAAKpUK4eHh2Lx5M8RisdX9NmzYgIEDBxpnzxpuawGAe+65B0uWLDHbvqysDCtXrgSPx0NsbCzWrFkDPp+P7du34/vvv4dQKER6ejqGDRvmoEgJIYQQ53Do7PHx48cbZ7zu3bsXIpEIhw4dYt22trYWjz/+uNnzFRUV+PLLL5Gbm4s9e/bg6NGjuHDhgtl+r7zyCpYuXYpdu3aBYRh89913OHfuHH766Sd8+umnyMrKwtq1ax0ZJiGEEOIUThvT1mg0qKqqgr+/P+bNmwc+n4/q6mrMnj0bjz76KFQqFZ5++mnk5+cb9+nbty/ef/9942xVQ8UnU+fOncO4ceMAAHfffTeOHTuGgQMHIiEhATweD/3794dOp0NtbS2CgoKcFS4hhBBidw5N2idOnEBKSgrkcjn4fD4SExPB5/NRWVmJffv2Qa/XY/r06Zg6dSoiIiIQERFhlrRFIhGCgoLAMAxee+01DBkyBAMHDjQ7B8Mwxls5pFIpGhsboVQqERAQYNzG8DglbUIIIVzm0KQ9fvx4bNmyBXV1dZg/f77x3sqRI0cax7VjY2NRXl5udZEDtVqN9PR0SKVSrFmzxuJ50wpTKpUKfn5+kMlkUKlUZo/7+vra3O66OhX0es+dnxccLINcrnR1MxyuN8RJMXoGipH7+HweAgOlDj+PUy6PBwYGYtOmTZg7dy7S09NRVFQEnU4HjUaDkpISiyIPBgzD4Mknn0R8fLzVVYeGDBmCgoICxMfHIz8/H+PHj0dkZCQ2bdqEBQsW4Pr169Dr9V3qZev1jEcnbQAeH59Bb4iTYvQMFCOxhdPGtGNiYpCSkoLMzEyEhYVh4cKFqK+vR2pqqtWEevDgQfz000/QaDQ4cuQIAGDZsmXw8vLC3r178eKLL2LFihVYvXo1srKyMGjQIEyZMgUCgQBjxozB7Nmzodfr8dJLLzkrTEIIIcRhnH6fdkFBAXJzc3u0rm1TUxPeeecdpKWl2bFlN8nlSo/+Rhga6ovq6kZXN8PhekOcFKNnoBi5j8/nITiYfZU9u57H4WdwAJ1Oh4ULF7q6GYQQQohTOb2MaXx8POLj43t0jK5MKiOEEEI8BSd72oQQQkhvREmbEEII4QhK2oQQQghHUNImhBBCOIKSNiGEEMIRlLQJIYQQjqCkTQghhHAEJW1CCCGEIyhpE0IIIRxBSZsQQgjhCErahBBCCEdQ0iaEEEI4gpI2IYQQwhGUtAkhhBCOoKRNCCGEcAQlbUIIIYQjKGkTQgghHEFJmxBCCOEIStqEEEIIR1DSJoQQQjiCkjYhhBDCEZS0CSGEEI6gpE0IIYRwBCVtQgghhCMoaRNCCCEcQUmbEEII4QhK2oQQQghHCB114IKCAixduhQxMTEAAJVKhfDwcGzevBlisdjqfhs2bMDAgQORnJwMANizZw9yc3MhFAqRmpqK++67z2z7wsJCrF+/HgKBAAkJCViyZAn0ej0yMjJw8eJFiMViZGZmIioqylGhEkIIIU7h0J72+PHjkZOTg5ycHOzduxcikQiHDh1i3ba2thaPP/642fPV1dXIyclBbm4uPvjgA2RlZUGj0Zjtt2bNGrz++uvYvXs3fv31V5w/fx4HDx6ERqNBXl4ennvuOWzcuNGRYRJCCLEVD1A0a1FerYKipRXgubpB3OKwnnZ7Go0GVVVV8Pf3x7x588Dn81FdXY3Zs2fj0UcfhUqlwtNPP438/HzjPr/99htGjhwJsVgMsViMyMhIXLhwAcOGDQMAKJVKaDQaREZGAgASEhJw/PhxVFdXY+LEiQCAESNG4OzZs84KkxBCiDU8oKi8AVv3FEKt1UEiEuCZxBEYHOkPMK5uHDc4NGmfOHECKSkpkMvl4PP5SExMBJ/PR2VlJfbt2we9Xo/p06dj6tSpiIiIQEREhFnSViqV8PX1Nf4slUqhVCrNnpfJZGbPV1RUWDwuEAjQ2toKodBp31EIIYS0o2jSGhM2AKi1OmzdU4hXn5wAP2+Ri1vHDQ7NYuPHj8eWLVtQV1eH+fPnIzw8HACMvWcAiI2NRXl5OYKDgy32l8lkUKlUxp9VKpVZEmd73s/PDy0tLWaP6/X6LiXsf2QfR1Vdc4fbJP+/W/HIlNtsPqa7CQ317XwjD9Ab4qQYPUNviLFJozMmbAO1VocmrQ7RkUEuahW3OKXrGRgYiE2bNmHu3LlIT09HUVERdDodNBoNSkpKrE4SGzZsGN544w2o1WpoNBqUlpYiLi7O+LxMJoNIJEJ5eTkiIiJw9OhRLFmyBNevX8fhw4cxbdo0FBYWmu1ji9dSJ0Cv7/xaTXV1Y5eO6y5CQ3052/au6A1xUoyeobfE6CMRQiISmCVuiUgAH5GA8/Hz+TwEB8s637CHnHa9OCYmBikpKcjMzERYWBgWLlyI+vp6pKamIiiI/RtWaGgoUlJS8Mgjj4BhGKSlpUEikSA/Px8XLlzAokWLsHbtWixfvhw6nQ4JCQkYPnw4hg4dimPHjiEpKQkMw2DDhg3OCpMQQogVft5CPJM4wmJM289HRGPaNuIxDOPUl6qgoAC5ubnYsmVLt48hl8vx6aefYvHixXZsmenxlTb1tLmqN3yrB3pHnBSjZ+hVMfLaxrbrVRoESMUek7A9rqdtTwzDYP78+a5uBiGEkK5iAD9v0c2JZx6QsJ3J6Uk7Pj4e8fHxPTpGSEiInVpDCCGEcAeVMSWEEEI4gpI2IYQQwhGUtAkhhBCOoKRNCCGEcAQlbUIIIYQjKGkTQgghHEFJmxBCCOEIStqEEEIIR1DSJoQQQjiCkjYhhJCu4wGKZi3Kq1VQtLQCPFc3qHfgZO1xQgghLsQDisobLFbrGhzpT7XEHYx62oQQQrpE0aQ1JmwAUGt12LqnEIomrYtb5vmop83iH9nHUVXX3OE2M+4agFkTBzmpRYQQ4j7qlRpjwjZQa3WoV2lurt5FHIKSNovXUid49HrahBDSEwG+EkhEArPELREJECAVu7BVvQNdHieEENIlft5CPJM4AhKRAACMY9p+PtTLdjTqaRNCCOkaBhgc6Y9Xn5yAepUGAVJxW8KmC5QOR0mbEEJI1zGAn7fo5hg2JWynoMvjhBBCCEdQ0iaEEEI4gpI2IYQQwhGUtAkhhBCOoKRNCCGEcAQlbUIIIYQjKGkTQgghHEFJmxBCCOEIStqEEEIIR1DSJoQQQjiCkjYhhBDCEU6vPV5QUIClS5ciJiYGAKBSqRAeHo7NmzdDLLZc1q2oqAhr1qyBQCDAgAEDsH79evD5N79r6PV6ZGRk4OLFixCLxcjMzERUVBQKCwuxfv16CAQCJCQkYMmSJU6LkRBCCHEEl/S0x48fj5ycHOTk5GDv3r0QiUQ4dOgQ67bbt2/HU089hd27d0Oj0eD77783e/7gwYPQaDTIy8vDc889h40bNwIA1qxZg9dffx27d+/Gr7/+ivPnzzs6LEIIIcShXL7Kl0ajQVVVFfz9/TFv3jzw+XxUV1dj9uzZePTRRzF48GDU19eDYRioVCoIheZNPn36NCZOnAgAGDFiBM6ePQulUgmNRoPIyEgAQEJCAo4fP44hQ4Y4PT5CCCHEXlyStE+cOIGUlBTI5XLw+XwkJiaCz+ejsrIS+/btg16vx/Tp0zF16lQMGDAAL7/8MrKzs+Hr64v4+HizYymVSshkMuPPAoHA4jGpVIqKigqb2xccLOt8I44LDfV1dROcojfESTF6BoqR2MIlSXv8+PHYsmUL6urqMH/+fISHhwMARo4caRzXjo2NRXl5OdavX4+dO3ciNjYWO3fuxMaNG7FmzRrjsWQyGVQqlfFnvV5v8ZhKpYKfn5/N7ZPLldDrPXdx2NBQX1RXN7q6GQ7XG+KkGD0Dxch9fD7PKR0+l84eDwwMxKZNm7Bq1SpUV1ejqKgIOp0Ozc3NKCkpQVRUFPz9/Y295rCwMCgUCrNjjBo1Cvn5+QCAwsJCxMXFQSaTQSQSoby8HAzD4OjRoxgzZozT4yOEEELsyeVj2jExMUhJSUFmZibCwsKwcOFC1NfXIzU1FUFBQcjMzERaWhqEQiFEIhHWrVsHAEhLS0N6ejomT56MY8eOISkpCQzDYMOGDQCAtWvXYvny5dDpdEhISMDw4cNdGSYhhBDSYzyGYdziOnBBQQFyc3OxZcsWm7bPysrC4sWL4ePjY/e20OVxz9Ab4qQYPQPFyH294vJ4TyQlJTkkYRNCiMPwAEWzFuXVKihaWgGeqxtEuMbll8cN4uPjLWaGd6R///4ObA0hhNgZDygqb8DWPYVQa3WQiAR4JnEEBkf6u7plhEM429MmhBAuUTRpjQkbANRaHbbuKYSiSevilhEucZuetjv5R/ZxVNU1d7jNjLsGYNbEQU5qESGE6+qVGmPCNlBrdahXaVzUIsJFlLRZvJY6waMnohFCnC/AVwKJSGCWuCUiAQKklmsuEGINXR4nhBAn8PMW4pnEEZCIBABgHNP28xG5uGWES6inTQghzsAAgyP98eqTE1Cv0iBAKm5L2HRRj3QBJW1CCHEWBvDzFsHPW2T8mZCuoMvjhBBCCEdQ0iaEEEI4gpI2IYQQwhGUtAkhhBCOoKRNCCGEcAQlbUIIIYQjKGkTQgghHEFJmxBCCOEIStqEEEK6jtYGdwmqiEYI6Z14bctl1is1CPCVwM9bSBXKbNXR2uD0GjoUJW1CSO9DSadHrK0N/uqTE26WaCUOQUmbBa2nTYhno6TTMx2tDU6vn2PRmDYhpNfpKOmQzhnWBjdFa4M7B/W0WbyWOgF6PV0jI72As8d13WQc2ZB0TBM3JR3bGdYGbz+8QEuNOh4lbUJ6K2eP67rRODIlnR6itcFdhscwDL3M7cjlSo/uaYeG+qK6utHVzXC43hBnT2JUNGux4q3jFr1NR43rdvd8DnsfDb1+N0g69FnlPj6fh+BgmcPPQz1tFrZMRIuL8MfKR0c7qUWE2J+zJxO53eQlBvDzFt08t+d+TycehJI2CxrTJr2Bs8d1aRyZkJ6j2eOE9FKGcV3DLGCzcV0POB8hnoh62oT0Vs6eTESTlwjpMUrahPRmzh7XpXFkQnqELo8TQgghHOH0nnZBQQGWLl2KmJgYAIBKpUJ4eDg2b94MsdhyQopcLseqVaugUCig0+nw2muvITIy0vi8Xq9HRkYGLl68CLFYjMzMTERFRaGwsBDr16+HQCBAQkIClixZ4rQYCSEu4ibFWwhxFJdcHh8/fjy2bNli/Pm5557DoUOHMHXqVIttN23ahOnTp2PatGk4ceIELl26ZJa0Dx48CI1Gg7y8PBQWFmLjxo3Izs7GmjVrsG3bNkRERGDRokU4f/48hgwZ4pT4CCEu4EbFWwhxFJdfHtdoNKiqqoK/vz/mzZuHBQsWYMaMGdi5cycA4Oeff0ZlZSX+/ve/46uvvsK4cePM9j99+jQmTpwIABgxYgTOnj0LpVIJjUaDyMhI8Hg8JCQk4Pjx406PjRBiAzuty2xtERBFk9aOjSXEtVzS0z5x4gRSUlIgl8vB5/ORmJgIPp+PyspK7Nu3D3q9HtOnT8fUqVNx5coV+Pn54eOPP8b27dvx3nvv4dlnnzUeS6lUQia7WYVGIBBYPCaVSlFRUWFz+2wprpL8/27FI1Nu60LU7iU01NfVTXCK3hCnI2PU6xlcq1GhVtGMID9v9AuRgs/vZla1cvwfz1zDlt0/G3vHacmjcOfQfmbnsSXG6yXVrMVbmrQ6REcG2a3NjkKfVWILl14er6urw/z58xEeHg4AGDlypHFcOzY2FuXl5QgICMCkSZMAAJMmTTK7rA4AMpkMKpXK+LNer7d4TKVSwc/Pz+b22Vpchasl+Ty9nKBBb4jToTE64XKzollrTNhAW5Ldsvtn9A28WdrU1hh9JELW4i0+IoHbfw7os8p9vaKMaWBgIDZt2oS5c+ciPT0dRUVF0Ol00Gg0KCkpQVRUFEaPHo0ffvgBs2bNwsmTJ40T2AxGjRqFw4cPY9q0aSgsLERcXBxkMhlEIhHKy8sRERGBo0ePdmkiGq2nTYhz1py2Z2lTWgSE9AYuv087JiYGKSkpyMzMRFhYGBYuXIj6+nqkpqYiKCgIK1aswKpVq5CbmwuZTIbXX38dAJCWlob09HRMnjwZx44dQ1JSEhiGwYYNGwAAa9euxfLly6HT6ZCQkIDhw4e7MkxCOMcZtcLtWtqUireQXsBtVvkqKChAbm6uxeVva7KysrB48WL4+PjYvS20ypdn6A1x2iVGK7dJKVpaseLNY45dBcyGS/D0PnoGT4+xV1we74mkpCSHJGxCepUOkqZTLjfb0DvW6xkomunea0IAN+ppuxPqaXuG3hBnT2PsdI1rV685zQOKrzSazS73xHuv6bPKfdTTdiGaiEZ6i07HrV1cK1zRZDm73N6T4QjhEpcXVyGEuI5hIpgpd1rjuqMvFYT0RtTTZmHrfdqEcJ273yZl19nlhHgAStqE9GZufpuUn7cQacmjLMa03amNhDgTJW1Cejt3XuOaAe4c2g99A93zSwUhzkZJmxDi1vh8nuO/VNCSnoQjKGkT90N/QLnBke+TybE1DA9iPhz3GeABpVcbUXpVAT3DgM/jIbq/H6L7+9LnjrgdStrEvdCayNzgyPfJyZ8BZUsrLlcr8fn3JcbzJU2OQ58gb8gk9CeSuBf6RLKg+7RdxxmLVJCec+T75OzPgKK5FbkHis3Ol3ugGLGRgZS0idux6T7t2tpa/Prrr6ivr3dwc7hj/0nb1+cmtqP7cruJ11bdrLxaBUVLK9B+yevOnu/iea7XNXf8PvXgfPUqGz4Ddoy3Rd3Kej5Vs7Znr1VPdOX1s9d766j2Ebvq9Gvkzp078cknnyA2NhYlJSV48sknMXPmTGe0zWXoPm3Xoftyu6Gzy8n2utxscpyZ90Rbf596eD6pl4j12FIvkUPiDfH3Yj3f5apGZO362fnDM11pvyuGk2gIy6U6rT0+a9Ys5OXlQSKRoLm5GXPmzMFnn33mrPa5xILM/R59edytawDb8Q+CW8dpJ6Ghvigtr+2wfnin9cVtZHqckAAvTJswEHk3Liubvk+Kpp6d72ptE4ovN5gde/bkOMRF+KN/oE+n8XQ5XpbP3CNTbsVXRy+hpr7F/iubsTD9rHal/fZ6b7uiu+f09N9Ht6k9HhwcDIGgrcyhl5cXAgICHN0mTvjy2J+cTdpuzc2LfbijzuqH22tdbNPj1NS34Jvjf2Dm3dEYdIsf+gZ6G9+nnp5P5iPGgYIyzLw7uu2yKwMcKCjDqNjRjonX5DN3va4Zl64ojAm7q223h6603xlrnvekfcT+Ok3aDMNg1qxZGDlyJM6fP4/W1lY899xzAIDXX3/d4Q10Bbo87mLuXOzDDXU2pGCvIYf2x6mpb8EX+aU3e1iMbe3pjJ+3EHOmDrZaWtUh8d74zIHHw5bdv7h0eKYr7XfFcBINYblWp5fHf/rpJ6vPjRs3zu4Ncge0NKdn6A1xhob6orqm0elj2h0exx7nM1kStG+wDGI+c3NfR47hu2iMWKPn4XqNsu1+dx8hiso8b0zb038fnXV53GrSPnz4MO677z7k5eVZPDd79myHN8yVKGl7ht4QpzHGzta9tte62HxArtBArmhBsJ8Xgv3EgJ5lOzuuw836PjoyXpN9g3wl0OsZxxX6sZYAo/yhUNnYflesed6Nc3r676PLx7QbGhoAAGvXrsWTTz5pfFytVju8UYSQLupsSMEeQw482N4DdPQQhyPjNezrI3J4L7aze9Jtar8rhpNoCMtlrCZtrVaL2bNnw9vbG0eOHAEA6PV6szFtT0XFVQix1NsK3zgjXprURbrKatKeOXMm7rzzTrzzzjtYvHgxAIDP5yM4ONhpjXNnF8rrXN0EQpzKLROMA+ufOyNemtRFuspq0haLxQgPD8e6deuc2R63QLPHCbHkdgnGwZOwnBGvn7cQzySOsDpTnpD2bCpjSgghhgQjEbXVbTBLMC5g7fK1oklrl+M7Jd4b94j/c9m9yHg8Hq8+OYEqi5EOUTV8FjSmTQgLNyt84/DL186KlwFuCZNBzGOMPxNiDSVtFnR5nNiVq9YHt/d5TW7zkXqJoGzWAjyey9Y7d8rlepolTdwMJW1CHMlViyvY+7wsx5s9OQ4HCsowZ+pgl1zSpfFg0ht1WhGtN6LiKp7BHeJ0yIIOJj3oviHtqoU56LzWjjfz7mjzUqb20O4KwcBbAiCXKzve1g0u1/eEO3xWHc3TY3R5cZXezJYxbS+xAG8tu8dJLSJcZfdxVxt70PY+r7XjgWfncWSW+NKSRyHuFl/2ZEyXr0kvQ0mbBY1pE3uxedzVxvHnDgt++IiMx5D6iNAv2AfX5E0dn7eHcYCx7zgyW3xbdv/ssQVcCOkqStosbOlpx0X4Y+Wjo53UIsJVNo27dmH82VqP93pdMxqatHh772+4Jm+CRCTA4geHYs/BYuPPPRnvZYvDMKZtz3FktyzgQogbcXrSLigowNKlSxETEwMAUKlUCA8Px+bNmyEWW/+2/tVXX2HHjh0WC5jo9XpkZGTg4sWLEIvFyMzMRFRUFAoLC7F+/XoIBAIkJCRgyZIlNreRetocxNZTdea5rH1cbtw2tGnJXVC2tELVrIWPlwhKtQ4ySVtP1bR3GRLghUmjI1HT0IQqhRda1K0IkN08B1uPt1+wD3R6BkV/1uKxv92Ozw4V4/eKBry99wwyn7gTqhZtx4tqdCEOw+1Pvj5iqLU6RPbxRYi/F/s+pouL+Hsh2NfK4iIm3K6AS3e46m4B0iu4pKc9fvx4bNmyxfjzc889h0OHDmHq1Kms258/fx7/+te/wDZn7uDBg9BoNMjLy0NhYSE2btyI7OxsrFmzBtu2bUNERAQWLVqE8+fPY8iQITa1j3raHGOlpxoc5IBJId2clV1RpTLbJ2lyHMJDZYju72vsXYYEeGHahIE4UFCGyfFRWPPuCYtztO/x9gv2wYP3xWJr3s1jL5hxO+oai1FT34IGlQZCPg/g8XoeR1cW0uADv5bW4u29Z4zbLH5wKIZHB3WYuNl69GnJo7gzwcxVdwuQXsPlFdE0Gg2qqqrg7++PefPmYcGCBZgxYwZ27twJAKirq0NWVhbS09NZ9z99+jQmTpwIABgxYgTOnj0LpVIJjUaDyMhI8Hg8JCQk4Pjx43Zt922RgXY9Huk+a+O812pUTjtXR1W42PbJPVCM0qsKKJq0xt7lpNGRyDtQjIkjwpF3oJj9HCY93pVzx2DOXwfj/S/Omm37wZfnMGl0JCQiAUouNyDjgwKsePMYisobAF734+jKayBXaIwJ27DN23vPQK7QdHxwk/gMFcLuHNqPMwnP0VXaCHFJT/vEiRNISUmBXC4Hn89HYmIi+Hw+KisrsW/fPuj1ekyfPh1TpkzBSy+9hBdeeAESiYT1WEqlEjLZzR6VQCCweEwqlaKiosKuMXx57E8sfHC4XY/pTKGhvq5ugt1cL6lmHQetbWzG0OhQp5yrSatDdGRQl/bRMwyatDrcPjAEacmj8Oe1BrMZ2R2dIxSAl5cS3/9cwbotnw8kTY7D18f/MD62dU8h/rnsXtwSJutWHF15DX6/fpV1mzqlGrcN7HzRofbvGlc+rz15XbkSY0/0hhgdzaWXx+vq6jB//nyEh4cDAEaOHGkc146NjcWlS5dQVlaGjIwMqNVqlJSUYP369XjxxReNx5LJZFCpbvao9Hq9xWMqlQp+fn52jWHGXQM4e8+hp90v6SMRso6DBvl62z1Oa+fyEQmsnsvaPnweDz4iAeRyJeJu8UWwnwQ//HwZA/r62nQOMR8YMjCYddthMaHI2n0aNfUtxsfVWh2uy5UQ85huxdGV1yDIyth0oEzS5feES5/X7r6uXIqxuzw9Rmfdp+3Sy+OBgYHYtGkTVq1aherqahQVFUGn06G5uRklJSWIiYnB119/jZycHGRlZSEmJsYsYQPAqFGjkJ+fDwAoLCxEXFwcZDIZRCIRysvLwTAMjh49ijFjxtjcrtdSJ+DDlZM6/I/qjrsPaws79AuROu1cVheR4AF8HvDk/w4z2ydpchyi+/vd3I8Bgv3FePgvccj5tgizJ8d1fg4GGBodgiUPD7fYVuYtRKPK/JKs6YSu7sShaNaivLrty/DyR0Z1uG+wrxiLHxxqts3iB4ci2I9DE8q6wd0WVSGex+kV0QoKCpCbm2s2ES07OxuffPIJwsLCEBISgvr6eqSkpOCBBx4wbnP58mUsW7YMe/bsAQCkpaUhPT0dwcHByMjIQHFxMRiGwYYNGxAdHY3CwkJs2LABOp0OCQkJSEtLs7mNVBGNg1gqY4WGOChOW6twmUxK8pWKMG3CQPQPlUHmLYKftxAyL/NZxXKlBqve+dFsFjmfD4yIC0WYn4T1HKGhvqiuabRsD2yYENWNOEyPFREmRW2j2vq+prPH/bzaEnYns8fZOPzz6sAa7bZWafPI38l2PD1GZ/W03aaMKVsy70hWVhYWL14MHx8fu7dlQeZ+j5497um/PAaujrOrpUSLryqw8f9OWTy+cu4YxPVnH97pMEZ7lPjkAfLGm18mbInD3hz6PrrJbG9Xf1adwdNj7BWXx3siKSnJIQmbEHvpqFAIm2B/L+NlVQOJSIBgPyv3QXfmxi1akSHStuRqaxIyXAqvUaGipgm/ldZ0KQ4uodnehGvcpiJafHw84uPjbd6+f//+DmxN5+iWL9IZa4VQpF4iXK1tgreXCM0aHVrUrQjx90Kwvxgr5o5BcXkd9Axw5JfLSLw/7uZl5c4KyLQrZiIR8lGrUJtf8u3sUjBb7e8b49ecLnhiRb2ql1ZgowIwnOU2SZsQt9SDP25shVAS749D1u6fMX3iIKg1bfdrmz5nWozkqYeH446BAYAOnReQYSlmYrjlq1GlbbvkO8AfFVVNKPqz1viloP2ymmzV2a5UNeIfKaPx/hdn7VIS1Z1IvUSsX0ikXp6dsN1hSIB0DyXtbrpQXufqJpCesCUZ9/SPG0vpz5NFVZjz18GoqFTi8+9LjMli4ohwi2Ikb376q3Hc2Npl3OjwAIh57MVMcg8UY+bd0djzXTG27inEC4+NxSufnDSrHb7jP0VYMWe0sVfZvjqbociLodJas1qLIQOC20qSsrxeXOu9qTWtmD05zizO2ZPjoNa2AuD+lQQ2HS4648lXFzwEJe1uKq5ocHUTSHfZmIzt8sfNpPTnb3/U4fPvSzDznmjj8Uzb1NFlWmvj47WNzejr74XaRjXr84YKaGqtDhfKas1iybuR1E0vBbevzta+0lr638daTdhc7L3JfMQ4UFCGmXdHt71WDHCgoAyjYrk5ydQWtCgLt3F2IpqrBfmxV2gj7s/WyUddnUjW2TmzP/vNeDw+j8c66az9z4ZxY0MytXhe5oWi8gb8cVXBfjzm5r/17W63MlROM45N37inPPWhYeDz2b9EMAzTpSVD3X1Cl5+3EHOmDsYX+aXYc7AYX+SXYs7UwR59X7XVz5IHzFHoDShpk17H1mRs0x83k6IjipZWY8/WDA9QqnWYeU80Eu+Pwy8XK+EnFSHJpIDKkV8u44l2xUiWPDwcftK25GGtaIeAz8PWPYU4eLLMoiBL0uQ4HDpdbjzWkcLLFrEMjQ5pO8eNnvLz249hx3+KENnXr0t/2O35BcepWGqdu/vVgZ6iAjDcRpfHuylhaD9XN4F0k63LP3a6FrYtl4RZtpk9OQ6HT1cgYfgtWDV/HFQtrbharcTxX68Ya5Dr9cCu/14wmyhmOj4u9RKhVadDraIFD/8lFppWPX48c9V4mXd4TAh8vYUY2N+v7R5tqQhzpg62aMf2TwsxZ+pgRIRJjc+p63X48KuzSJocZ5wo19nkM5cuqdnTsXTDEIb3zep0Hq3dZ6nb9/ATl3Cb4iruxJbiKjPuGsDZUqaeXuTAwGqcXRl/7aBASYfFU3zaJo8p1Tqs+6DAYpsH7o1BRJgMEWFSPL/9GNRaHRL/Eocv8ks7LmJyo+3/PlqKmffEtiX4GzPBJ8dH4Zsbs8VZx91vFEo5fbEKej1w6HQ5aupbIBEJsHpBPFa9bb4SXkiAF5YmjUJrq67zP+wsr2nqQ8MwqL+fcd3w7uqsgAwXx9Lb6w2/k54eo7OKq1BPu5u+/rGMs0m71+tKT6ODXpi1S8LKFi2u1DRh655CzLwnmnWbmHB/DOorQ3mVyjhbu0+QT6cThBRNWuz4TxEeuDcGW3b/bNZrPlBQhvvHRiEiTMYeDwOomrXIPVBscY4WTatFT7lRpYVMIoBfgJdF7B29plfkTaioVGLHf4pu3m7WnSR64wvT9ZJq+EiErD3oDicL3vjixKXZ7IR0hpJ2N/nLaNIGp3Xnkmi7y7BB/l7oF+yDiSPCjWPZR365DIlIiK17ThoTCdtlYy+JEIrmVuMxJsdHobq+udNLzPVKDSaOCMcHX55jnQlu+DJgLR5rl7FDfCUdDwXY4sZ2W/MKzY7frduJbOxB2/LFics9cELao6RNiC14QOnVRpReVUDPMODzeIju74c5f70NO769gIkjwiH1FuCZpJFo0eqwaNZQSL2FEAn5eGb2CFRUKnHwZBkaVVo8MuU2/F5eBz4fiAkPxN//djv+uKrA6QvXze4Z7hfsgyceHNY2mYvHA58H6BgGgwcE4tBpEdT1NwuggAdE3+KPQD8JLl1XwlsihK+PyOLSdEfj9H52GOesUbDfelajULclbStV3do/Zuvtdta+hLT/4uS0e5Hbx+cjhEJlY2+fg/e5E+ejpN1NTS2trm4CcSJlSysuV98siGKYnS0RCzA5PgoHCsowfeIgFJfVY9d/L1hs88PPFZgzdTCaWtpugfrqSBkmx0fh5Rvj3YZL3IbJZN5ebbdzvfLxSbNjGSqcJU2Ow/EzV3Hn0P5mhUHabxMeKkN0f1+zP/5iIR8P3Btj/PIhFt64icTknnJFkxblVaouJw9vK+tJe0mEVnvPYiEfm3f9bPaY1Fto073E1r6EqFq0zr8XuV18bFXurPX29XrGI8bmiePRLV/d5ONF33d6E0Vzq3EmNXCz4ljfICnyDhRj4ohwKFRaY8I23Uah0mLiiHBkf/Yb/GUSfPJ1ESaOCLcoXpJ3oBgj4/pgz3fFUGv0eHvvbxbHmjQ60vjvB+6JtThG+21Kryra7pW+cWvapetKlF5V4ODJMuw5WIzcAxexedfPN++nvpF4Vrx1HBkfFGDFm8dQVN7AfisbC18f81vZDF8kOuo9l15VWDxmKC9qinU2upVbtgJkzr8XuX18bFXurN27fq1Gxcn73InzUdLuplqF2tVNIE7Uom5l7bm1aFqNlcf0DMO6jZ5hjBXP1BqdcXtrFcwkIoHVSWmmFc4YsJ/PdBs9w0DZojUm4syPfsLn35dg2oSBCLkxwcz0fuqeFkmRSQQID5XhgXtjkHh/HB64NwbhoTLIvIRWx5/17W5gUWt1UGtbbb+XmGU1M1fci2wRXwdV7tqrVTRz8z534nTUXeymGXcNcHUTiBOF3Fg202KSmEkBFkOVs/bb8Hk86PWMMRmbJpL220b19W0rLapsYX3ecKm0X7APvMSCDrcxnJttfDfPpC65aQ+0xyUuGSC6vy9CA7wsxsatjT/zeebdeIlIAJmXCP2DfPDqkxPQpNXBRyTo8qQ4Z9+LbC0+W+5dD/Lz9tiV1Ih9UU+bEGv4gFypQfFVBbQ6PV6YO8ai59Y3yKut2tgvl+EnFeGRKbdZXhqWinCk8DKeSRyBfsFt25ddrcfidhXQkibH4aN/n8MX+aWQiASsxzJUOHvsf27H+1+ctaiC9vjMO4zbJE2OQ3R/P6vju4ZevWkP1C4lLq2s422t9xvd38/iMUOC9fMWYWh0aNfWA++kHY7SPr4jv1y2eI+t9fb7hUipShmxCRVXYUHFVTxDj+JkWepy8YNDERPuD3lDi3nP7casX2WLFt4SEdRaHVQtrfCWCOEtFqBZrYXMS3RzewHwa0kt9hxsGwvn84G4yECEBXmhpq4FUi8RmtRaiMVCCPk8qJq1CJCKwefzUNuohtRLhNrGFrzyySmz2eNggNujA6HVMvC6cV+zzKvt1rIVbx6z6MWtXhDfdh+2aQ/U0cVK2IrVwHoBG4Bjn9f28UlFbbPHO+nth4b6orqmscPXges49T52g7OKq1DSZiGXK6HXe+7L4um/PAAAHqDR83C9Rtmt22fkSg1WvfOjRaLLXHwngnt4ydLasdcuGo8wP4lN7bTavifuRHD7GgJdTcQdVIFzhd7weaUYuY8qornQP7KPd9rTFvB5eO8f9zmpRaRL7NBblCtaWC8pV9Y2tyXFHiQxa8e+Wq2CvL7FpnZ2aR3orozvOuteYbonmZBuoaTN4rXUCR7d0/Z03S5tyQfqlFqoWrSQeotYJwZdrlKiT6A3GlQaqwVMzNxITjUKtXH70ED2SUcSsQBb8wqR+cSdbZfEO0hmXV4H2pYKcM6q4+0h9cI5gb4ceRxK2ixs6WkH+Umw+cm7nNQi0hXdKm3JA4rK61FV24zcA8WI7CvDwpl34L0vzhq3fXzmHdhf8CcABrkHio2TvdgKmABgTU6G7Z+ZPRxb8341O/a+H9oKt5y+WGU8vrVkZlgH2rSQx2KT6mnd+eNsaxWynnLWeXo9+nLkkShpd1OIv5erm0Cs6E5pS62OQUWlyljxbGRcH3x2+Heznuzew7/jnlERxqswxiIn98YgNMDLIuGwJSfD9mMGhyL972Mhb2iBRCzAvh9K8HtFAyQiAfR6WLTPIpnduOT9z2X3oqZehbpGDTaYVE/rzh/nHt/u5Wbn6e3oy5Fnolu+uqm4osHVTSBWWLu1qKPSlnJFi3lxFB5wTd6EPd8VY8/BYuz5rhjX5E3oE+SDQ6fLzfbXMwxrEYyOionIG9TY9mkh6pVqbM0rNCbsBTNutzi+1QIbDHBLmAwyLxG2f/prj6tp2eV2Lzc6T2/X0Zcjwl3U0+6muAh/VzeBWGPSC70uVxonXimaby4/abhVis8HpF4iSL1F+PNao1kPna23XtfYgpr6FrPH+Dwea8LpqJiIj5cQjSotvjn+h7E3z+fx0KxuRU19i0X7DL19NvbquXa0mIg9L6c66zy9nbXPH3054ja65YsF3fLlGSzivDHGt+M/RZgcH2U283r5I6Og1evR0KhGg0oLiZgPmbcY75uMabMtbsE6pn1j8k+zphXVDWq8+emvZtuH+HthQH8/lF9XmiWuR6bcCpGQj6+OXLJon7XL3aGhviitqMOrOacslghdMWd01y+DOut2ry6cpzd8Xh0So5uNaXv6+0j3absQFVfxDKxx8gB5o/k9ziEBXrh/bBRiI/wh4PPxzue/4Zq8yTi5i2EYi0IgNQq1sYAJ0FaL3rAUY1HZzS8GXmIBWjQ6+Esl8JIIUFXbhP0FZW0J1UeEq3Ut+K2kBmBgvCw+72+3W6xJLREJWMciQ0N9US1vZC0EMzw6CNBbeXE4NKu4N3xeHRajG91z7+nvI92n7eaOnrnG2aTdqzGAqllrlrCnTRhocb/zN8f/wDV5EzZ8fPJmsjSW4xQZ14Zu35NZ8vBw7PrvBeMqXjPvicaeg8UWzTBcupZ5CfHFD6VmCbqisrFLl7sVKq3FalJv7z1jfcKRm/XAiAPZcqsf4RSaiNZNtJ42d5lOhJo0OpJ1icxJoyONP1ubuMM2O3f7p7/i/nGRZis8dTTpim3S3OABQV2aqNXVCUc9XcmLEOI6lLS7idbT5i6zRNnBEplA15Olr1SEQf390S9Yisf+ZzACZWIsmHG79YUgWNaDjgj16dLiEV2djW1Tkr+x/nZ5tQqKllab19O2maOPT4iHcvqYdkFBAZYuXYqYmBgAgEqlQnh4ODZv3gyx2PKPTFFREdatWweBQACxWIxXX30VISEhxuf1ej0yMjJw8eJFiMViZGZmIioqCoWFhVi/fj0EAgESEhKwZMkSm9tIE9HcQGdjrh09fyMhVDeoIRHx4SMRokXTColIiFadDkKBoK3qmZcIWr0ea98rsBg/nnl3NL7IL8XiB4choo8UQNu4tZdYAB+JEFqdDjzwcb22CWIRH59/X4K6RjX+Z8JA5Jpcak99aBhC/L3Q2KyFn48YWp0OAVIb4vERsi800W47by8RqmtVqFNqjLd9dXa5W6nR4fiZ68Z1rA+dKkejSmtWMe6KvAkVlUocPFmGRpUWqQ8Nw6D+fh1Xf7P1PbT18vyN/VVqHcRCPtSaVsh8xG49/t5dnPid7CFPj9FjJ6IVFBQgNzcXW7ZsMT723HPPYfLkyZg6darF9nPmzMGLL76IwYMHIzc3F3/88QdeeOEF4/P79+/HoUOHsHHjRhQWFuKdd95BdnY2Zs6ciW3btiEiIgKLFi1CWloahgwZYlMbaSKai3X0Rx1gTSqmz7NVIZOIBfjqyCU8eF8s9h7+HdfkTW2zxh8diQaVFu/tM6985uMlNDt+0uQ4fH38DzSqtHhkym0I9BXjzX/9ZraPRtuK//vmgsUXgAfujUHugYvG8fIDBWWYM3XwzSTVhSTGFtvXx/+ASMC3nDRnY6lS4wz4W3xRVGb+nGF8v1GlxQP3xiAiTGbb2HcHMSmatFjx1vGOJ9qx7M/62nkIt/+dtANPj9FZSdvll8c1Gg2qqqrg7++PefPmYcGCBZgxYwZ27twJAMjKysLgwYMBADqdDhKJxGz/06dPY+LEiQCAESNG4OzZs1AqldBoNIiMjASPx0NCQgKOHz9u13bvP1lh1+ORm6yNuSpbWlFU3oAVbx3Hph2n8fn3JZg2YSB8pSLjmKy1KmQKlRYTR4Tj/S/Ott0adeO50iuN+OxQW+Wzpx8egQfujYGySYOteYXIPXARNfUtxmNMGh0JtVaHXf+9gKs1TWbneP+Lswj297ZaTMXw77wDbctxmo4h2zrGbC22SaMjjZPmAqTiDteOtnaM0AAvKFSWz+WZxK1nGJvHvjuKyZbL82z7s712hPQ2LhmYPXHiBFJSUiCXy8Hn85GYmAg+n4/Kykrs27cPer0e06dPx9SpUxEWFgYA+Pnnn7Fjxw5jMjdQKpWQyW5+uxEIBBaPSaVSVFTYN8m2aHQIDfW16zGdyZ3bfr2kmvWPukqtY/1DPvPuaOz5rhhNWh3AsI9R6xnm5vi1yfipnmGMlc8S74/DnoNt/+9onNs0EZs+LxYJWItZmCZQw3HUWh2atDpERwZZjdfwfGevi2m72u/TXkfnsvbagXczDlvO0dl5+obIWF+nvsEyhIbKOo3V1jZwjTv/TtpLb4jR0VyStMePH48tW7agrq4O8+fPR3h4W89n5MiRxnHt2NhYlJeXIzg4GN988w2ys7Px7rvvIijI/BdVJpNBpVIZf9br9RaPqVQq+Pn52TWGGXcN4OylHne/TOUjEbL+UTe9VcvANKn4iAQAj2e1Cplez1gkUX677U0nf1lLvobjmZKIBBCL+Fgw43Z88OU5i8vX7Y9jaG91dSNk3iIkTb7VYozZ8Hxnr4tpu9rvY+tr29lrZ7hMbss5OjuPmM+wVkQT8xnjcTuK1dY2cIm7/07ag6fH2Cvu0w4MDMSmTZswd+5cpKeno6ioCDqdDhqNBiUlJYiKisIXX3yBvLw85OTkICAgwOIYo0aNwuHDhzFt2jQUFhYiLi4OMpkMIpEI5eXliIiIwNGjR7s0EY2W5nQta2UuQ/y9rCaVZxJHwE8qQp1Si0Wz7sC7JmPUpmPaj8+8A3sP/27cNzxMipS/3oacby/g0KlyJE2Ow/6CMou1qg3Jt61yWduYtqEtEpEAC2fegU++Pg9lkxar5o2DslkLkYCP6vomNKq0xvMZxmVNZ4NXVCqNC5WYjjG3H5dme11M22VLKdAOS4gCFs8tfnAoFCoNvjp6yTh3wJYCHZ2VKu1sfW+2/S1eO/oVJb2QW0xEy87OxieffIKwsDCEhISgvr4eKSkpmDFjBu68807069fP2FMeO3YsnnnmGaSlpSE9PR3BwcHIyMhAcXExGIbBhg0bEB0djcLCQmzYsAE6nQ4JCQlIS0uzuY00Ec0NsFVyguXkpNSHhmFQP1/IvIXGSVS+UhGmTRiIfiFSeIkFEAn5aNHoIPMWoexaA2Q+ElyrUUGj1eNMSRXmz7gDpy9UQ88w8BYLoGcYyLxFiOzrh3qlGoG+EvD5QH2jBl4SIbzFArTqdODx+GhQahDk21btTN7QYtZWZUsrVBodWlv1UGt0kHqLoNG2wt/nZpJSNNswKauD18XbW4xrNcquVbvqqEpW++ekIvZZ7N19D7vy18Ywe1yjg1jAh1rbCpmXyCMTNid+J3vI02P02Nnj1rAl845kZWVh8eLF8PHxsXtbbEnaXF5Pm9O/PFYSgbXklzQ5DmqtHpF9feHnI8Ibeb8YF/wwLMoxoL8v/rzWiEOnys0WA8l8YjwalNrOZ3W3b1sXSoOWV6uQ8UGBxeMZj8cjMkTa6cvB6ffSRhSjZ/D0GHvF5fGeSEpKckjCthWtp+0iVsoyWit0IvMRIfcL9jFma+VLa+pbjOtv7/jPbzfX1Aaw4z9F7AtxdLM0KK3ERAjpCrdJ2vHx8YiPj7d5+/79+zuwNZ2raWjpfCNiXx30ZNmS3/1jo/D+jYQN3Ly96dnZIyAS8lF6RYGZ90QDaJv8ZZiJ/kV+KZY8PBxqbavFaluzJ8dB2aK1SNqmtygZevAVVY0IC/RGsK/YauLudJlKrizswZV2EsJxbpO0CbHAaxsXVjS3okXdthb2W5/9aiyMsuTh4bh9QACgB/x8hHjq4eFmy2D2DfYxS6KG3nKDSg2hgG82+cvQy+4b7IOZd0dj138vYMnDI1jrkmc+cadFU2sUauO5THvwn39f2nGPu6NJWVxZ2IMr7STEA7i8uAohrHhA6dVGnL5YjXUfFCDzo5+Q+dFPmHrnAIQEeEGtbVuco6K6CeADRWUNqFM0Y+bd0Ui8Pw4z746Gt0SIfsE+mDZhIL7IL8Weg8X44odSeImF2Hu4xCIZ3z82Ctdv3LN9Td6EC2W17PeLt1gW9vC+cYsS2wIknRYDuXHJPzJEalYYhSsLe3ClnYR4Akra3VSrULu6CR5N0aRF6VWFsY43gBvVyC6arcBV9Gct5AoNtu4phKpFZ0zOe74rxtUaJR77n9stkujbe88Yq6IZqLU69AnyMa5p3faY3uaFOHx9REiaHAc+n71AibUVt6ziAUq1DjPvafsSEhLg1f1jOVhXVxkjhHQfJe1uEvBpWSJHqldqoGeYDiuASUQC6PWAXNFWavSXi5VmK2qpNXpcqWZfm5rf7pMvEQlQ19hiNnv8yC+XseTh4TattiWTCBAeKkNkX78urbjF6sbl5nUfFBivDkybMBAhAV5uOUmtq6uMEUK6j8a0WVBxFdcL8JVYVCsDzKtiLZhxOw6fKsfYwWHoF+yDO4f2x+fflyBpchz6BPlAKORD6iVCv2AfXJM3mR1jQD9/s+Ioj0y5FWIh3+yxOVMHY3BUx0VAjBggur8vlC2tSH1oGLI/+81sfLcr9xZbq7ttWLDD3e5T7nQyHSHEbtzmPm13QsVV3MCNMe3L1UqzpS6f/N9hqG9sgapZhyOFl5F4fxyGxwShoqptwQxDYRXTGd+LHhiKf90YpzYUZIm+xQ+6Vj3qVRpIvURQa1vh5yOGXs90vxiISdt7UlTE2r3bq+aNw6C+MrNjuc172dNCKh3odowcmtHuNu+jA3l6jHSfNundbvRc+wR5IzYyEC3qVvjLxMja9bNZr/ntvWfw6pMTwNy4lD5zdLTFGPa7n5/BM7NHoKKyEaNvDbt5C5ZIYHLr1s1Lue3vAe9O29nuJbeVtXu3Q/wkbpt0ehqz3dGMduKhaEy7m46euebqJng+BpBJhOgf4IVBfWRQNWnNEjZwc8JTgOzGuCqPfSJY2fVG5B4obpv5bcNa0IpmLcqrVVC0tJqtCuYMhsvNtoylE3Y0o514Kuppd1PC0H6ubkKv01H1MEOiq6hSdjgO3unkKEf30Gy5ZGvDghqkYx3NaGet6U4IR1DSZkET0TrRk7FCW/a1so0tK0dFhEnRN9jHbCKYzatD8QB5owYVVY2YeU+0sRb51j2F1hfw6IqufCFwt8vNHEPlYYmnooloLGgiWgd60hO1Zd/OtrFlwlN3VodiOa9pLXJbF/DoSJdX9LKBp0/uAboZI8fGtOl95D5nTUSjMW3SJT0ZK7Rl3063sVI9zMyNbYbFhCJYJkb/QB/r23Zw3rwDxZg0OtJuPTQqQuJEJkMMGY/H49UnJ7htwiakKyhpd9P+kxWuboJL9CTx2LKvqxKbtfPy+bDbJDAqQuJktnzBI4RjaEybBY1pW9eTsUJb9nXVWKS185rdItZDVISEENJT1NMmXdKT25Fs2ddVtztZO6+9EjYAumRLCOkxmojGQi5XenRPu8cTQnpS/aoLE8l6ertTl+N0YFUvR/H0yT0AxegpPD1GqohG3FdPbkeyZV9X3e5Et1kRQtwcXR4nhBBCOIKSNiGEEMIRlLQJIYQQjqCkTQghhHAEJW1CCCGEIyhpE0IIIRxBSZsQQgjhCErahBBCCEdQ0iaEEEI4gpI2IYQQwhFOL2NaUFCApUuXIiYmBgCgUqkQHh6OzZs3Qyy2XMmprKwMK1euBI/HQ2xsLNasWQM+/+Z3jZaWFjz//POQy+WQSqV49dVXERQUhEOHDuHNN9+EUCjEQw89hMTERKfFSAghhDiCS3ra48ePR05ODnJycrB3716IRCIcOnSIddtXXnkFS5cuxa5du8AwDL777juz53fv3o24uDjs2rULs2bNwltvvQWtVotXXnkFH374IXJycpCXl4eamhpnhEYIIYQ4jMsvj2s0GlRVVcHf3x/z5s3DggULMGPGDOzcuRMAcO7cOYwbNw4AcPfdd+P48eNm+58+fRoTJ040Pv/jjz+itLQUkZGR8Pf3h1gsxujRo3Hy5EnnBkYIIYTYmUtW+Tpx4gRSUlIgl8vB5/ORmJgIPp+PyspK7Nu3D3q9HtOnT8fUqVPBMAx4PB4AQCqVorHRfGk3pVIJX19fs+dNHzM8rlQqnRcgIYQQ4gAuSdrjx4/Hli1bUFdXh/nz5yM8PBwAMHLkSOO4dmxsLMrLy83Gr1UqFfz8/MyOJZPJoFKpzJ43fczwuGkS74wz1kR1tdBQ218PLusNcVKMnoFiJLZw6XragYGB2LRpE+bOnYv09HQUFRVBp9NBo9GgpKQEUVFRGDJkCAoKChAfH4/8/HyMHz/e7BijRo3CDz/8gGHDhiE/Px+jR49GdHQ0ysrKUF9fDx8fH5w6dQoLFiywuV1yuRJ6vecupuzpi9Eb9IY4KUbPQDFyH5/Pc0qHz+Vj2jExMUhJSUFmZiZaW1uxcOFCPProo0hNTUVQUBBWrFiBbdu2Yfbs2dBqtZgyZQoAICUlBQCQnJyM33//HcnJycjLy8OSJUsgEomwcuVKLFiwAElJSXjooYfQp08fV4ZJCCGE9BiPYRi36FIWFBQgNzcXW7ZssWn79evX48UXX3RIW6in7Rl6Q5wUo2egGLmv1/S0u2v+/PmubgIhhBDiVC4d0zYVHx+P+Ph4m7fv16+fA1tDCCGEuB/O9rQJIYSQ3oaSNiGEEMIRlLQJIYQQjqCkTQghhHAEJW1CCCGEIyhpE0IIIRxBSZsQQgjhCErahBBCCEdQ0iaEEEI4gpI2IYQQwhGUtAkhhBCOoKRNCCGEcAQlbUIIIYQjKGkTQgghHEFJmxBCCOEIStqEEEIIR1DSJoQQQjiCkjYhhBDCEZS0CSGEEI6gpE0IIYRwBCVtQgghhCMoaRNCCCEcQUmbEEII4QhK2oQQQghHUNImhBBCOELo6gYQ7tp35BJmTRzksH037jyN2yIDjT8btt935BKOnrmGzU/eZXGcjTtPAwBuiwzEj+cqUVPfjOl3DcDRM9eQMLSfcTvD/svfOoaEof1wobzOuN/+kxUAgP83NgL7T1bAx0uIBqUG/3NnlHE7UysfHY3lbx0DAOMxQ/y9UNPQghB/L5RXKuHjJUSdQo3YCH8AQE1DCxKG9sPRM9cAwPjvppZW/L+xEfjq2J8W7Z41cRD2HbkEAMZ2jB7cF59/X4LIPjLjcQ3HMGx/obwOKx8dbfGatn9NTM9h+nqYvl6m57f23hh+NpzLsG/793blo6ON/zd9zMDQDrFIiGWJwy2eN2xj+rqYtoMtfjaGbQ2fHcO2pp+trn7WrbWn/TmtxdKd83a0rbXnevI7bNi/s9e3o317cu7eipI26bYvj/3Z7V86W/YtrmhAcUWD8WfD9l8e+9PqcQzbm+5n2N50P4Nahdrscbb9WjQ6q/ubHsf034afDf83HIPt+Nb+3f7/syYOsmgDW7yGfaxtb60NbOdgOy7bc+3fm1kTB1mcq7N2d3QutucN25i22bQdbPGzMWxr7TVs/29bWGsP27HZYunOeTva1tpzPfkdNuzfk30paXcdXR4nhBBCOMJhPe26ujps2bIFR48eRb9+/cDn86HT6dDU1IR169Zh6NChrPtptVqkp6fjypUr0Gg0SE1NxV/+8hezbQ4dOoQ333wTQqEQDz30EBITE9HS0oLnn38ecrkcUqkUr776KoKCgrB27Vo89dRTCAkJcVSohBBCiFM4rKf9xhtv4JFHHgEAfPjhh8jJycGuXbvw3HPPYfv27Vb3+/LLLxEQEIBdu3bh/fffx7p168ye12q1eOWVV4zHzMvLQ01NDXbv3o24uDjs2rULs2bNwltvvQUASElJweuvv+6oMAkhhBCncUhPW6lU4syZM1i7dq3Fc1evXoWfnx8AYNq0aRgzZgx+//13+Pv7IysrC1OnTsWUKVMAAAzDQCAQmO1fWlqKyMhI+Pu3TegZPXo0Tp48idOnT+Pxxx8HANx9993GpD1o0CBcunQJdXV1CAwMhC34fF73AucQe8QYFujd7ePYsm9YoLfZz4btDY/z+TyL47TfpyOG/XvK9Dj2OmZn5+lOu4DOX5+OztHZc6bHb79t+/fa8L6Zvn8dvZds73X747RvB9vjbDo7BlvbOtPRsawdz5bXpLNzWtvW2nM9+R027A/Y/veks9eAy5wVC49hGMbeBz169Cg+//xzvP7665g0aRL69esHtVqNqqoqTJw4EWlpaQgJCcGkSZPw6quvYuzYsXjttdcQGhqKefPmAWhL/KmpqUhMTMT06dONxz516hR27NiBN954AwDwz3/+E/3798fXX3+N1atXIzo6Gnq9Hvfeey/y8/MBAC+88ALuv/9+i8vshBBCCJc45PJ4XV2d2Rjyhx9+iH/961+YNWsWmpubERwcDAAQCoUYO3YsAGDUqFH4448/AADXrl3D3LlzMXPmTLOEDQAymQwqlcr4s0qlgq+vr9njKpXK2JsHgNDQUNTX1zsiVEIIIcRpHJK0g4ODoVAoLB5funQpqqqqsGvXLgBAa2srLly4AAA4ffo0YmJiUFNTg/nz5+P555/H//7v/1ocIzo6GmVlZaivr4dGo8GpU6cwcuRIjBo1Cj/88AMAID8/H6NH37xvsKGhwfhFgRBCCOEqhyTt4cOH4+LFi5Yn4/ORmZmJ7OxsVFZWAgDee+89JCcno6qqCklJSXj77behUCjw1ltvISUlBSkpKWhpacHevXuxd+9eiEQirFy5EgsWLEBSUhIeeugh9OnTB8nJyfj999+RnJyMvLw8LFmyxHjeoqIijBkzxhGhEkIIIU7jkDFtAHjppZeQlJSEIUOGWN1m0qRJ+PbbbyGRSDo93oULF3D27FnW3ndHSkpK8NFHH2H9+vVd2o8QQghxNw675evZZ581Xga3h4CAADz00ENd3i8nJwfPPvus3dpBCCGEuIrDetqEEEIIsS8qY0oIIYRwBCVtQgghhCMoaRNCCCEcwfmlObu7MInBr7/+is2bNyMnJwcAUFZWhpUrV4LH4yE2NhZr1qwBn3/zu421hUnYFjG5ePEiDhw4YHb7mb0UFBRg6dKliImJAdBWUCY8PBybN2+GWCy22N6ecTlaV2Mz2LBhAwYOHIjk5GQAwJ49e5CbmwuhUIjU1FTcd999ZtsXFhZi/fr1EAgESEhIwJIlS6DX65GRkYGLFy9CLBYjMzMTUVFRLo+xqKgI69atg0AggFgsxquvvoqQkBCPirGkpASrV68GwzAYMGAAMjMzIRQKPSpGg6+++go7duxAXl4eAM/6rJ4/fx5PPPEEBgwYAABITk7GtGnTsH37dnz//fcQCoVIT0/HsGHDzPbrykJQro5RLpdj1apVUCgU0Ol0eO211xAZGemc95HhuJdeeokpKipi7rvvPqalpcX4eH5+PrNo0aIO93333XeZv/3tb8zDDz9sfOyJJ55gTpw4wTAMw6xevZrZv3+/2T4ffvghs3XrVoZhGObf//43s27dOkaj0TD3338/U19fz6jVaubBBx9kqqurGYZhmOXLlzNlZWV2idXUiRMnmKVLl5o9tmzZMubbb79l3d7ecTlSV2OTy+XMggULmL/85S/Mrl27GIZhmKqqKuZvf/sbo1arGYVCYfy3qRkzZjBlZWWMXq9nHn/8cebcuXPMf//7X2bFihUMwzDML7/8wixevNgBEXY9xkcffZQ5f/48wzAMs3v3bmbDhg0eF2Nqairz008/MQzDMCtWrGD279/vcTEyDMOcO3eOmTt3rvHvjqfFuGfPHuaDDz4we+zs2bNMSkoKo9frmStXrjAPPvig2fPW/taw/V1yhK7GuGLFCubrr79mGIZhfvzxR+bw4cNOex85fXncsDDJbbfdZvFc+4VJXnrpJSQnJ2Px4sVoamoCAERGRmLbtm1m+507dw7jxo0D0LbwyPHjx82eP336NCZOnGh8/scffzRbxEQsFhsXMQGAv/71r9i5c6d9A2eh0WhQVVUFf39/zJs3DwsWLMCMGTOM57Z3XM7UWWwqlQpPP/00Zs6cadznt99+w8iRIyEWi+Hr64vIyEhj9T2g7bOj0WgQGRkJHo+HhIQEHD9+3Ox1GDFiBM6ePesWMWZlZWHw4MEAAJ1OB4lE4nExbtu2DWPHjoVGo0F1dTVkMpnHxVhXV4esrCykp6cb9/G0GM+ePYvvv/8ejz76KNLT06FUKnH69GkkJCSAx+Ohf//+0Ol0qK2tNR7T2t8atr9L7hDjzz//jMrKSvz973/HV199hXHjxjntfeT05fHCwkIMHDjQ+PP8+fPNFiZZsWIFgLZLv9OnTzcuTJKXl4d58+ZhypQpuHz5stkxGYYBj9e2WotUKkVjY6PZ80qlEr6+vmbPmz5meFypVAIAbr31VosvBvZy4sQJpKSkQC6Xg8/nIzExEXw+H5WVldi3bx/0ej2mT5+OqVOn2j0uR+tKbBEREYiIiDAuENM+Hra2K5VKyGQys+crKiosHhcIBGhtbYVQaP9fla7EGBYWBqDtj8WOHTuwc+dOHDlyxKNiDA4OxpUrVzBv3jzIZDLcdtttyM/P95gYp0yZgpdeegkvvPCCWUEpT/usDhs2DA8//DDuuOMOZGdn480334Svry8CAgLMYmhsbDRe6rb2GrD9XXKUrsR45coV+Pn54eOPP8b27dvx3nvvYcCAAU55Hznd0+7pwiRsTMd52y88AoB1YRJri5gAjl2sZPz48cjJycHOnTshEokQHh4OAMZve15eXoiNjUV5ebnd43K0rsTGprO2sz3PFrNer3fIH0Gg6zF+8803WLNmDd59910EBQV5ZIy33HIL9u/fj+TkZGzcuNGjYrx06RLKysqQkZGBZcuWoaSkBOvXr/eoGMvLyzF58mTccccdAIDJkyfj/Pnz3Yqxs4WgXBljQEAAJk2aBKCtsufZs2ed9j5yOmn3ZGESa4YMGYKCggIAbQuPtK9ZzrYwibVFTABAoVA4ZOKEqcDAQGzatAmrVq1CdXU1ioqKoNPp0NzcjJKSEkRFRdk9LmexJTY2w4YNw+nTp6FWq9HY2IjS0lLExcUZn5fJZBCJRCgvLwfDMDh69CjGjBmDUaNGGXvshYWFZvu4MsYvvvgCO3bsQE5ODiIiIjwyxsWLF+PPP/8E0NYL4fP5HhVjTEwMvv76a+Tk5CArKwsxMTF48cUXPSrGqKgoLFiwAL/99hsA4Mcff8Ttt9+OUaNG4ejRo9Dr9bh69Sr0er3Z38XuLATlyhhHjx5tbNfJkycRExPjtPeR05fHhw8fjs2bN1s8bliYZM6cObj//vsBtC1McvXqVfTv3x9paWlWj7lixQqsXr0aWVlZGDRoEKZMmQIASElJQU5ODpKTk7FixQokJydDJBLh9ddfN1vEhGEY4yImQNvs9DvvvNMB0ZuLiYlBSkoKMjMzERYWhoULF6K+vh6pqakICgqye1zO1FlsbEJDQ5GSkoJHHnkEDMMgLS0NEokE+fn5uHDhAhYtWoS1a9di+fLl0Ol0SEhIwPDhwzF06FAcO3YMSUlJYBgGGzZscHmM/v7+WL9+Pfr164enn34aADB27Fg888wzHhNjUFAQFi1ahJUrV0IkEsHb2xuZmZke9T72hs9qUFAQMjIysG7dOohEIoSEhGDdunWQyWQYM2YMZs+eDb1ej5deegkAsHfvXgDAgw8+yPq3hu3vkjvEuGLFCqxatQq5ubmQyWR4/fXX4e/v75z30ZaZde5s9erVzLlz5zrcpv3M8u7IzMzs1n7Lli1jysvLe3TurmCbBdmR7sblCl2NjU1NTQ2TnZ1tpxbZH8VoG4rR9ewRY1FREfPpp5/aqUX2547vI6cvjwP2X5jEmvnz53d5nwsXLiAyMtJ4OdMddScuLmMYxuNjphg9Q2+IsbsLQXGJvd9HWjCEEEII4QjO97QJIYSQ3oKSNiGEEMIRlLQJIYQQjqCkTQghhHAEJW1CegG1Wo1PP/3U6vMnT540q5Pc3t69e1lrIhhs27YNu3fvtnjcsMJdSkoKSktLrW5HCLENJW1CeoHq6uoOk/Znn32Gqqoqu593+/btdj8mIb0ZpyuiEUJs8/bbb6OkpATbt2/HmTNnoFQqodPp8Oyzz8LX1xdHjhzBuXPnEBMTg0OHDmH//v1obm5GYGCgzYn34MGD+Pbbb9HS0oJVq1Zh2LBhuOuuu3Ds2DEHR0dI70FJm5BeYPHixSguLoZKpcKECRPw2GOPobKyEsnJyfjuu+8wceJETJs2DX379kV9fT0+/vhj8Pl8LFiwAGfOnLHpHLfccgtefvll/P777/jHP/6Bzz//3MFREdL7UNImpBcpLS3F9OnTAQB9+vSBTCaDXC43Ps/n8yESibBs2TL4+Pjg+vXraG1ttenYhpX0YmNjUV1dbf/GE0JoTJuQ3oDP50Ov1yM6OhqnTp0CAFRWVkKhUCAgIAA8Hg8Mw+DChQs4ePAg3njjDaxevRp6vR62Fk00rOx08eJF9O/f32GxENKbUU+bkF4gODgYWq0WjY2NKCsrw3//+1+0tLTg5ZdfhlAoNK6Yl5WVBW9vbyQlJQFoW4HK1glqly9fxty5c6HRaPDyyy87MhxCei2qPU4IIYRwBPW0CSE2W7JkCRoaGswek8lkyM7OdlGLCOldqKdNCCGEcARNRCOEEEI4gpI2IYQQwhGUtAkhhBCOoKRNCCGEcAQlbUIIIYQj/j+z3iJFyLXF1wAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -3369,13 +3503,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='scatterplot+rugplot', \n", + "ax = plot2d(plot='scatterplot+rugplot', \n", " df=tips, \n", " x='total_bill', \n", " y='tip',\n", @@ -3675,13 +3809,13 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "id": "eba4a290", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -3691,13 +3825,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='pieplot', \n", + "ax = plot2d(plot='pieplot', \n", " df=tips, \n", " x='day', \n", " sep='.',\n", @@ -3933,13 +4067,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 15, "id": "914f2d0c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -3949,13 +4083,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='treemapsplot', \n", + "ax = plot2d(plot='treemapsplot', \n", " df=tips, \n", " x='day', \n", " sep='.',\n", @@ -4163,13 +4297,13 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 16, "id": "3b2c956b", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -4179,13 +4313,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='packedbubblesplot', \n", + "ax = plot2d(plot='packedbubblesplot', \n", " df=tips, \n", " x='day', \n", " figsize=[6,6],\n", @@ -4619,7 +4753,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 17, "id": "9aa84f26", "metadata": { "scrolled": true @@ -4627,7 +4761,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -4637,13 +4771,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='stripplot', \n", + "ax = plot2d(plot='stripplot', \n", " df=tips,\n", " x='total_bill',\n", " y='day',\n", @@ -4656,13 +4790,13 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 18, "id": "a2fbf61e", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmsAAAFDCAYAAABlW0kiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAADEa0lEQVR4nOydZ3gUVReA323ZTe+FEgIk9N5BpNk/FAQFRDoiKB2RJoJ0pIgUUYrSpAiCIKDY6L1J7wRCEkp6b9u/HysLIWWXtNkk8z4PD5mde885U3b2zL3nniMxGo1GREREREREREREbBKp0AaIiIiIiIiIiIjkjOisiYiIiIiIiIjYMKKzJiIiIiIiIiJiw4jOmoiIiIiIiIiIDSM6ayIiIiIiIiIiNozorImIiIiIiIiI2DCisyYiIpIrp06dokWLFvTu3ZtevXrRrVs3rl27li+ZcXFxDB8+nA8++IDu3bvz+eefk5GRAcCWLVvQarVZ+nzyySdoNJrn0qNWq3nppZfyZevzkpCQwO7du3Nt888//xAZGZnj/m+++Yaffvopx/0TJkzg8OHDmT6Ljo5m6tSpALz00kuo1eps24mIiBQ/RGdNRETEIs2bN2f9+vVs2LCBESNGsHjx4nzJ++GHH3jhhRdYvXo1mzdvxsHBgc2bNwOwYsUKDAZDlj4LFy7Ezs4uX3qLgps3b7J///5c2/z444+kpKQUqF5vb2+zsyYiIlKykAttgIiISPEiKSkJDw8PAK5du8aMGTOQyWQolUpmzJhBQkICY8eOZevWrfzxxx8cPnw4i3Pn5eXFX3/9RUBAAA0bNmT8+PFIJBK2bt1KdHQ0n3zyCX379uWrr75CoVDQrVs3lixZwh9//MGUKVMwGo08evSItLQ05s6dS2BgoFl2amoqY8aMISkpiQoVKpg/P336NEuXLsVoNJKamsqCBQs4ffo09+7dY/z48ej1ejp16sS2bdtQKpUADBs2jD59+tC0aVMuX77Md999x7hx4/jss8+Qy+UYDAYWLFhAmTJlzHqWL1/OjRs32LJlCy1btmTixIno9XokEgmTJk0iIiKC69evM378eDZt2sQ333zDlStXSEhIoHr16nz55ZdWXYdNmzaxatUq9Ho9s2bNQiaTMXr0aH7++ec8X1sRERHbRBxZExERscjJkyfp3bs37733Hp999hlvvvkmAJMmTeKLL75gw4YNvP/++8yZM4eaNWvStWtXJkyYwMaNG5k1a1YWef369eOtt95i1apVtGrVimHDhhEVFUXXrl3x9vZm4cKFgGkac9OmTXTq1ClTf39/f3788UeGDx/O/PnzM+3bvHkzVatWZePGjXTv3t38+e3bt5k/fz7r16/ntdde488//+TNN99k37596PV6jhw5QrNmzcyOGkDXrl3ZsWMHANu3b6dbt24cP36cunXrsmbNGoYPH05ycnIm/R9//DHNmzfnvffeY968efTp04eNGzfy+eefM3HiRNq2bUuNGjWYO3cuGo0GFxcX1qxZwy+//MKFCxdynR59moYNG7Ju3ToGDhyY5RyIiIiULERnTURExCKPp0G3bNnCjh07GD16NBkZGURFRVGjRg0AmjRpwu3btwHo3r07J06coEOHDjg5OfHnn3/Su3dvevfuzZUrVzh58iSdOnVi1apVHDt2jDp16jB79uwseitVqpSjPQANGjQgJCQk07579+5Rp04dAOrVq4dcbppA8PX1ZdasWUyYMIFTp06h0+lwcnKiSZMmHD16lO3bt9OlS5dMslq1asXly5dJSEjg7NmztG7dmi5duuDi4sKHH37Ixo0bkclkOZ63O3fu0KRJEwBq1KhBREREpv1KpZK4uDhGjx7NF198QVpaWrbxetnRuHHjHM+BiIhIyUJ01kRERJ4LLy8v898+Pj7cuHEDgDNnzlCxYkUA5s2bx4ABA9i+fTvh4eG88cYbrF+/nvXr11O7dm1+/PFHfvvtNwDs7OyoUqWKOR5NIpGYY9ak0uwfUVevXgXg3LlzVKlSJdO+wMBALly4AJimaXU6HQCTJ09m9uzZzJkzBx8fHx6XRe7WrRtbt24lNjaW6tWrZ5IllUp54403mDp1Kq+88goymYx9+/bRqFEj1q1bxxtvvMEPP/yQpc9j+wMDAzl79iwA169fN587iUSC0Wjk8OHDPHr0iK+//trsAFtbrvnSpUsAnD17Nss5EBERKVmIMWsiIiIWeTwNKpVKSU1NZcKECahUKmbOnMmMGTMwGo3IZDJmz57N3r17uXfvHpMnT6Z+/fqMGTOGDRs2oFAozPKmTZvGtGnTWLt2LSqVCnd3d3NwfOPGjRk0aBBDhw7N0Z7Dhw+zb98+DAZDlhiv999/n3HjxvH+++9TuXJls96OHTvSs2dP7O3t8fLyIioqCjCNvoWGhtKzZ89sdb377ru88sor/PXXXwDUrl2b8ePHs2zZMgwGA5999lmm9hUqVODWrVusXbuWcePGMXnyZFavXo1OpzNPCTdo0IBx48axbNkyvvvuO3r27IlEIsHf399slyUuXrxInz59kEgkzJ4922onT0REpPghMYrfcBERkWLEhAkTaN++Pa1bty4QeQaDgffff59Vq1bh5ORUIDJFREREChJxZE1ERKTUEh4ezrBhw3jnnXdszlHTaDQMGDAgy+eVKlVi+vTpAlgkIiIiFOLImoiIiIiIiIiIDSMuMBARERERERERsWFEZ01ERERERERExIYRnTURERERERERERtGdNZERERERERERGyYErUaND4+FYOh8NdLOO8wrdBK7ryq0HXZIp6eTsTGFmwRakvYpy8HIN3+4yLVC/DDZZPuD+vkrPuHH0y5vD78MPfs85ZkPS1HiPNsCSGvQ2Fii+e6pOIZvZq0dA3pFUrWPWRr5HRP2//w33f4Q/H8FwRSqQR3d8dC11OiVoPGxqYUibNW2vH2diY6OtlyQ5F8IZ7nokM810WHeK6LBvE8Fw1SqQRPz8JP+yNOg4qIiIiIiIiI2DCis5YHPFbVxGNVTaHNKFU4J/fDObmfILoH/d2PQX/nrnvQIBWDBqnyLctaOUIh5HUQKSEc7Y7zpX5CW1FqcR7UD+dB/YQ2Q+Q5KVExa0WFTlVNaBNKHTp5XcF01/ayrLt2bUOByLJWjlAIeR1ESgju9dGlqoW2Ar1eR3x8NDqdRmhTCoWoKCkGQ9bnSeSYTwEwRoQWtUnFHrncDnd3b2SyonedxJg1kedGjIUoGsTzXHSI57rosJVzHRPzCJXKAUdHFyQSidDmFDhyuRSdzrZf/ooTRqOR1NQkMjLS8PIqY/5cjFkTEREREREpJHQ6TYl11EQKHolEgqOji2AjsaKzlgc8VlXDY5U4FVqUuCT3wiW5lyC6+//Zi/5/5q67f38V/ftbjjWzJMtaOUIh5HUQKSEceReXi7ZxD5VGR00achdpyF2hzSiWCHm/iDFreUBnX09oE0odWnlTwXQ39rWsu3FjfYHIslaOUAh5HURKCF4t0KYIH7NWHJg4cSyzZ89/rj6rVq3gn3/+wtvbG6PRSFJSIi+//Bp9+5rygxods+YEO3hwHxs2rEMigVdf/R/dur2faX9CQgLTpn2OWq3Gy8ubiROnEB4eyuLFC8xtrl27wuzZX9G8+Qt5OFIRS4gxayLPja3EnJR0xPNcdIjnuuiwlXMdERGKn1+A0GYUOKtWrcDT05MuXbqh0xnQaDT06tWVFSvW4O7ukaW9Xq+nZ88u/PDDeuzt7enVqyvLlq3Gzc3N3GbRovlUrVqd9u07sH79WuzsFLz3Xk/z/v3793LkyEGmTJlZ+AcoMM/eN2LMmoiIiIiISBHh2qk9ys0bTRtarWl762bTdlqaafvXXwCQJCXi2qk9dr/tMm3Hxpq2//rDtB0ZaVHfnj27+fzzsYwZM4L+/XuwZ89uPvtsDN27d+bIkYMAdOz4OgDDhg1i8eIFjBw5hIED+xAR8QiAGTO+ICIiIlc9SUmJ6HQ6lEolq1atYMqUzxgx4mP69+/BxYsXkMlkbNiwFScnJ5KSEjEYDCgUmSfdLl26QLNmLQBo3vwFzp49bd6Xnp7O6tUrGDlyjMVjFsk74jRoHvBYHQRA3AfBAltScti06UfCw3NeSt7/1e0ArPnnnUK1IzExAQBXVzfzZzvsTbo7p+ese8eOfqY2ndfmKt+SrKflKBQytFo9/v4B9OjRx7LxRYBL0nsAJLlsEdgSkWLLoY64qHUkNRDvobS0NBYu/Ja9e/9iy5ZNrFy5lvPn/2Xr1p9o1aptprY1atRi5MhPWbHiW/755y969+7H5MnTs5W7efMm9u37m4iISLy9vZkwYTIODqbpT5VGy9JRYwkGpk2bxLp1PyGXyzl0aD9ffz2XFi1eRKWyzyQvNTUVJyfT6JGDgwMpKU/KWP32207atXsl00icSMEjOmt5QOcgxu0UNOHhody8HYxM5Zbt/hPXPAEIDo8pVDv0GQkARCfpzJ85ePynOy5n3Q4uF0xtLNhnSdazch7bYytoFW2ENkGkuOP7MtrUDKGtyELir3uebCgUmbcdHDJtG11cM297embe9vW1SmeVKqaFak5OzlSsWAmJRIKzszNqddYVh1Wrmtr6+voSGxubq9zu3XvQpUs3rly5ytSpE/H3r2De16hhY4zOzlT29iEu7omcNm1eolWrtsyaNZU///ydN9/saN7n6OhIWloaSqWKtLQ0nJ2dzfv+/vsPZs6ca9XxiuQd0VnLA0ndNwltQolEpnLDIeDlbPftf2T63KGQQ0zSQvf9p+eJHXX472/n7Hr81ybgcaxk9vZbK+tZOY/tsRXS7YcIbYJIcaf6SNJtIGbNFnie1YV5WYlYvXoNevXqy5QpE1m+fDUANx494DVvH+7eDcbb25vU1BTGjx/N118vxc7ODnt7e6TSzBFSderU48SJY7Rv34GTJ49Tt259AFJSUtBqtfj6+j23bSLPhxizJiIiIiIiUgyxJmbtrbc64ejoyI4d2wC4desmI0cOZs6cmYwbNwlHRydeffUNhg4dyODBAwAJr732P2JjY5gy5TMA+vYdwN69fzN48AdcvXqJd981hUOEh4dSpkyZnFSLFCDiatA84Lm6kknfByGFrssWKYzVXHPnziA4PCbHkbVxr80DYN7f4wpU77NkN7J2UGnS3Vads+6D29qZ2nQ5kKt8S7KelZMWuo8gfy/Gj59sjfmFjmuSKdYu0WW7wJYULLayQrE04H2lGxqNjsSGwt5DJXU16GOyq2CwatUKvAwG3nnpVfSBQbn21+l0LFv2DcOHf1KYZhY7hFoNKk6D5gGNkxi3U9ScC2sgmO5yesu6ywXeLxBZ1soRCrXd/4Q2QaS4U64D6hTbi1krLRjt7TG4ulrVtkeP3oVsjYi1iM5aHkjutlZoE0ode2+8KpjuKjrLuqs0uF0gsqyVIxQZqoFCmyBS3Kk6hAxxFFMQBgz4CABr5p/kcjmenl6Fa5CI1YgxayIiIiIiIiIiNozorOUBzzUV8FxTwXJDkQJj4htfMvGNLwXRvV/1JftVuevev+Ul9m95Kd+yrJUjFK5JHXFN6mi5oYhITux7Bdd/xXtIKGTBt5EF2/YIvkhWxGnQPKBxfkNoE0odJ+42F0x3BZ1l3RWq55zQ93lkWStHKNR2hZuUWKQUEPAe6mQxZk0oDO7uQpsgkgdEZy0PJHdZKbQJuXLs2GEAWrZsLbAlBceBW+0E0x2ks6w7qN6dApFlrRyhyFD1E9oEkeJO0MAii1kric/C/GIU49CKJaKzVgI5evQQID6gRERESje2/Czcs2c3oaH3GDx4uE3aMWXKZ0yaNB2FQpGlz+Ni8Z06dSkQG9q2bU7t2nUB0Ot16PUGpk6dRdmy5bJtn56ezrRpn5OcnIxcrmDSpKl4e/tkarNr1w527tyOTCajb98BtGzZisWLF3D79k0A4uJicXJyZuXKtQVyDIWN6KzlAc+15QGI7WfbaRYKipCQO2zevBFHR0f69v0Qb29n4uLi+PPP33B2dqZ9+47IZLJ86dDr9eSW8m/S/2YCMPOPSfnSkx1Gg564sLPo1CmoJOkolJnr4u1TmXS/nJGz7n2bXzG16b43V12WZFkrRyhcE9sDkOi6x0JL2yc0NITExERq1aojtCmli71tcdXqSWxc/O+h4sjjeDV9UJVc202bVnQxwi4urixd+mTG6tdff2Hz5g2MHj0+2/a7d++gWrUa9O8/kD17drNx44+MGvWkkHxsbAzbtm3mhx/Wo9FoGDJkAE2aNGPkyE8BUw65wYMHMH58wf+eFBais5YH1K6dhDahyNDpdHz++Vji4+MBiI2NZcmShYwbN4oHD8IBuHcvhOHDR2fbf8+eXdy5E8yLL7ahQYNG2bbZsmUjR44cQiKRUtY5CEfPilnaHL5deG/G0cGHSbh/AYBkqQy/CtUz7a+ks6y7Uu27VumyJMtaOUKRoewptAnZcv78v2zcuA4XFxcGDx6Jt7d3ru3/+ut3Fi9egNFopHHjpnz33dIislSEyv3IsMGYNdez7cko2xN12Z5g0OJ67m0yyvVBXaY76NNwPd+FjPIDUPu9i0SbiMvF90n3/xiNb0ckmlhcLvUmPWA4Gu//IVFHYlRaVx8U4KefNrBv39/IZDLq1WvARx8NpUePd9m4cRsJCQm88057du/+G3t7Bz7+uD+rV29k+fKlXLx4HoPBwHvv9eSll15h2LBBuLt7kJSUxJIl3wISEhMTGDlyCGvXbuLKlcuM/XQ4ezZuJToqkjlzZvDKK69z9eplPvlkKAkJ8XTq1IW3336HLl06sHHjNk6ePMaGDeuQy+V4eXkzbdpss93374czbdrnjB8/GT+/MsyZM53ExEQARo0aS2BgEO+++xYBARWpWLESLVu25tKlC/Tvn3sKoMjICJydXQDo2vVtatasxcOH96lUKZAJEybTrVsP9Hr9U20z1++7fv0qderUw87ODjs7O8qV8+fOndvUqFELgG3bNtO0aXMCLSQGtiVEZy0PpHQuPQ/2tLRUs6MGcP9+GAcPHjQ7agAXL57Ptu+ePbv55puFgKnY79KlKwkIqJSpTWpqCuvWrQLAaDQQHXwke2ctuDU6dQqpcVexc/TE3qXgatGpk6PNfxsMevR6rXlbp06lXGot7Bw8IJfSfJWfcbKibh0g8dFVlI6elK3TAbnSlOG6sgVn7Vk5tkaGskeeahTmhY0b13Hw4D4CA6swatQYVCr7bNulp6czffokMjJMDoBWq2PGjDm5yt6z5zfzSO7Zs6d59OgRdnYuBXsAItlTuR/qIohZCw0NISTkLg4ODoWuKz/cuRPM/v3/sHz5amQyGZ9/Po6TJ49Tr14Drl69zP374VSqFMjZs2dwcLCnSZPmnDhxjEePHrBs2SrUajUffdSfJk2aAfDKK6/Tpk07ZDJTBQNXVzdcXV2JjIzg1Knj+PiV4XpUJDduXKd167aAKafa118vJSLiEWPHjuTtt58sJPrnn7/o0aM37dq9wh9//EZqaioAYWGh/P77Lr74Yib+/hX47rslNGrUlM6duxAeHsbs2dNYtmwVUVGRrF69AVdXNwAaNWqS5RwkJSUybNgg0tJSSUpKok2bdgwY8DEA0dGRDBy4lPLl/Zk8eQJHjhykTZuXkMlkjBjxMXfvBrNw4beZ5KWmpuLo+KSqgIODAykpKQBotVp27tzO99//WBCXr8gQnbW8oE4z/a+07YdAQeDi4krbti9x8OB+AOLj45gwYUKmNmq1Otu+d+4Em//W6XSEht4jIKASsbEx2Ns74ODggEwmR6FQoNFoAJDKn8RH6DSpGI1GFEonjLok7p/bhCY9HZBQts5bOHkHYTQaiQ4+TNKjaxiNepx9quFb/ZXncijs3cuTnvgAAIXSHrnCDk1qHAkPLpJw/xJGiR4n36qUq/lWjjIMepM+qcxIWvx980hdRlIEsfdO4VvtZYwGA0apqfyLNIev3tNybIn4+Di++GICoaG3ad2qHaM/nZSl2HNBcvHieTZsWAuY3t7LlStP7979s22bnp5udtQe22qJ8uX9uXXrBgDOzi64u7uTmqrPv+EiljFoTf+kWWOhCoq4uFg+/XS42bHYuXN7JgckOzJNy0oVmbdlDpm2jQrXzNt2npm3n2NULTT0HrVq1UEuNz0T6tWrT0jIHdq0ecnslA0aNISjRw8hlUp56623OXfuLDdv3mDYsEGA6fkaEfEQgAoVspbQat26LSdOHOPy5Yv06tmHM6dPcuXqZT777AtOnjxO1arVkUgkeHh4ZvouAQwf/gnr16/ll19+JiCgotnBO3nyODKZzPwcuHs3mHPnzrJv398AJCcnAfznLLrleg4eT4Pq9Xpmz56KXK4wO9m+vn6UL+8PQJ06dQkLe7JifsmS5YSG3mPs2JH8/PNO8+eOjo6kpaWZt9PS0syjb2fPnqJ+/YY4ORV+iaiCRMyzlgc8f6qK509VhTajyBg3bhILFnzDu+++R3p6epb9Wq02y2cnThwlMTHB/EX29PSiTp16LFmygF69utKz57ucP/8vKpWKceMmYW9vj0Jpj281U8xW1K0D3D26kpBj3/Pwyu9MfGMe34y+8J90IynRplWTiQ8vkxB+DoMuA6NeS9KjKyRH3rT62PSadLNjBaC0d0KrySD0zIb/Pjdwq/ktzlX6DU1aQo5yDmx9mQNbs69rChB1+xC3Dy5hj3oU+xQz8ywnO+7eDeb+/bDn6vO8bNu2heDg2ywdd5NuLZZz5sypQtX3+C34MampKTm0BA8PD95805S3Sy5X8P77vSzKHzJkJJ06daFt25eYNWuezY++POb333fx8cf9mT59MklJiUKbkzf2v4rrubcLVcW9eyFmRw3g2rXLhaovPwQEVOTatSvodDqMRiMXLpzH3z+AJk2aceHCORISEmnRoiU3b17n9u1b1KhRi4CAijRo0JilS1eyZMlyXnrpFcqVM8VSZ/cS1apVW/bu/QtHR0de8PXj6L6/0Wi0eHh4AuT6crtr1w4GDBjE0qUrMRqNHD58EIBu3d5nxIjRzJo1Fb1eT0BARbp168HSpSuZMWMOr732vxztyQmZTMa4cZ9z+PABjh8/CkB0dDSxsTEAXLp0kUqVKrN+/Rr+/PN3AOzt7ZFKM8dM16hRi0uXzqNWq0lJSSE0NIRKlQIB00h68+YvWG2TrSCOrOUBtVvBrIApLkgkEmrWrE1ycjK//LIly/7GjZvy1Vez8fHxo3v3Xly6dIHp0yeb+/bu3Z/27TuQlpbGH3/8BkBGRgabNv1IgwaNaNmyFUePHiQ4PAalk2lZecL9i2b5KVG32H+jFbF3j5s/U/03DarXPHkgP8Zo0Fl9bJqMRAy6JyODWnUG6RIJRsOTURavMC8kUhmyiqoc5VSu82QU0cG9PK7l6pH06Ap2jp44eQfx4IKpaLXnPTdULp5QxrIca/juuyXs3r0DgEGDhtC5c9fn6m8tjx+4vx40XZ8Wrxfue17Tps1p0KAR58//i4+Pr8VVZ8OGfUKXLt2xt3fA1Yq6h46Ojnz00dCCMrdICA29x7ffLsJoNBIaeg93d/ccY0VtmsAPyUjO+tL3NGfPniY8PIwXXngRX9/nD3kICqqCp6eX+Ue+adMWeTK1KAgMDOKll15h8OABGI1G6tatR+vWbZFIJPj4+OLn54dUKsXfPwB3dw/AtLr1/Pl/GTLkQ9LT02jduh0ODo456vDx8UWtVtOoUVOc/AOQ2il54YWWVtlXo0Ytxo0bhYODI/b29rzwwots22b6HWjSpDkHDuxj48Z19OnzAXPmzGDXru2kpaXywQeDssj6998zFmPWlEoVEyZMZubMqTRo0Ag7OwULF84jMjKSWrXq0LJla2rWrM3MmVP57bedGAwGJk78AoD169dSpUpVmjd/gS5dujN06EAMBgODBg1BqVQCpunbN95406pjtyUkxtyW4OWBOXPmcPXqVaKjo8nIyMDf35/bt2/TokULFi5cWJCqshAbm4LBYFvTR0Iwd+4MAMaPn1zgsvfs2c3VqxeoXr02AQGVyMjIYM6c6eYRt86du+Do6GSewgL46KOhdOrUhYSEeHr3fg+dzjQS17JlKyZNmg7Al19O43ZoJE6VX0cikXDrwGIwGswyXMrUIunRVUCCa7m6+FYzZfnXZiQT/u9mdGrTyIu9a1nK1X8XqSzn9xBteiIZSRGoXPyQ2TkQdmYTmjTT1Jm7d3kkEglxUU9i8uycffAOfBFHj6zTC9agTo0l9NST+Ahnn2qUqd0+27Y6dSopMXexc3DHwb08aaH7CPL3yvZaajQa3n77dfO2p6cXGzZszZONlkhOTmLWrKncuXObNm1eYujQUYUeu2YwGEhKSsLZ2Tnfq40t4e3tTLSN16u8du0Kn376JL1Cq1ZtmDhxqnAG5RFL5/rvv/9g4cJ5ALi5ubNs2Wrc3NyeW09MTDTTp0/GwcGBOXO+zrI/IiIUP7+8faeLA3K5KWatuNOx4+vs2vWXVW2PHj2Evb1DtnFxBcWz941UKsHTs/CnVAt8ZO1xPNP27du5e/cuY8aM4dSpU2zevLmgVQlHsultDefSl1ywffsO9O3bw/ywvX37Zqap0bCwUPr2HcDPP29Co9Fgb29Pw4amL46bmzvjx3/Oli0b8fDwZPDgEeY+J08eR6PR4JCSTrk6b+NT7SWibu4HoxH3Co1JiziF0g7UGikZSY/M+hQqZyo274cuIxmZnSMyhTJX+9WpsYSf3YxBr0Eqs8O/cXf8G71Hauw9FCpnjIk3iHrwJDGtVK6iXON3kEiejCQZjUbSE+4jlduhcjbFpui0JmdCrsga96R09MSrckviw88jdXTELbBptrbptRmEnNqOXpOMVKrGr8bryDHFo2i12iz5jhQKRabRAz+/HIbrCgBnZxfTD57xvziQpxw1g8GA0WgsMIfq/v1wpk6dSETEIzp27MygQcVrBKywqF69Jq1ateHIkUO4uLjSrZttrsy1iC4N9Gkgy37q+d9/z5j/TkiI586d23n68fXy8qZcuezzdJVq/ltFSSG/AAlBUFA1/PwKbvGZLVHgI2uPedZZmzt3Lh4eHsTFxdGuXTuGDx9O7969mTp1KoGBgfz000/ExMTQuXNnBg8ejJubG61bt2bgwNyX+D5NUY2s2XqetYkTPyUxMTHbQNOCQKGQodWavvAGg4Hz58+Zg0lr1KiFr68vqampJCcn4eLiajEe6MaN60REPHHAytXrbF4RmvjwMqmxoSwY9Dtg5KNZ1XD0rES5ep3yZHtc6Bli7hw1b3sFvohHwJMfgtSQf3gQciVTn7D/pSCRSMy50R5e/o2UaFOuIq+g1nhUaGQxP5pem8Gjq3u4UGMvMoUD/5N+Zd6XlnAfTUosUrkdh3Z0BqBatY9w8g5CooknOTEWqVRGrVq18fT0zCQ3JSWFe/fuIpXKqFw5EJUq56naZzEajeh0umyTXubE4DdNL13Lfu8OmPIZXbt2FYPBQFBQFXPcTH64evUK0dFR5u1GjZpkWZpf0Dx9T9s6Go0GuVxeqAs8CpMhVTdjNMKy292z3f/gwQNz4lK5XE6TJs3MU1jPS1hYKK6ursyevSDLvtI6smZtnjWR7CkxI2s5oVar+e6779Dr9bRt25bhw3PO2hwdHc0vv/yCnZ1dUZn3XGR49hDaBJtBKpVSv34DEhMTUCqV5uXSjo6OODo+iaFITU3l2rUraDQaKlasZP5Rf/jwASkpmadEpAqTw5ESfYfIGybnZ9teL+RKZ5y8g/CpmvfSU0onn1y3n07bYUKC7wN/XHxNudf02gyzowam2DqPCo0Iqp97YeT4sH9JiwvFK8TkbD3U/Y7czgGFoyfRN/eZNMmV+PhKzDF3SicfYkNMMWwGg57bt29hMATh4eFhHsVycnIyZ/5+HtRqNf/+exaNRo1EIqFGjVr4+PhY7Hf8ev1M28HBt835joKDb1OmTNl8OxFSaebp1aJKFVJcsNXnorWcjGuIXp/z9Fy5cuVQKBSkpaXi4+OTZ0dNJHsMYrmpYkmROWtVqlQxP2QeL1F+mqcH+MqXL2/TD6TUDvOENiFXHi+VLoyYNchbfM/EiWPNq7Pu3Alm6tQvOXr0kDklCIBMYYejZyBxISexc/BAKn9yD/xzygOvoFaUrdM4X7Y7egZQpvabpMWH4+Duj6On6Q0pLS4Mo9GIVKZAobRHq348tWtEeSkej9oe4ANSmR0yO0fzwgZdRiLh//6Mf71Omex9lscLFjwemgKEU7gFgET2ZFTLqFNTpXEqBm06CofXcPapSuy9E/DfdyMjI52rVy8TFFSFBQuW5us7snbtD5w4ccyk12gkLCyUBQu+sbr/G//9P3jwAO7dM+WGs7NTMm7cpHxPh0ZFRTJr1lQePXrI22+/Q8+effMlzxqKQ8xaSeHxuX7DctN88zh+V+QJRrGQe7GkyJy17N6O7ezsiI6OJjAwkGvXruHra4r/sfXhfWmcKfjc4OEvsCVZychI5/r1ayQnJ7Fx47ocf+iOHTvC2bOnaN26XY6VBQoSvf7JCk2DwYBeryc4+FamNs6uXiRE3gCjkdTYEFzL1UUqV2HQZeDiosCnXDksrfPUaVJJiriB3M4RZ99q2d53zj5VcfZ5knol6tYBc/oOB2d3vMtWJjFZTWqMaVRLL9eToU/AGZBIpZRv8C4R1/9GnRQBQHriA2Lu3cbNvz52StPInF6bQXLkDaQKe+xdy6FJT0Qqs0MrSQepDJkprRzGp0byJDIFSpcaKOxdzXI8fSqQnhwNSEhLMzmIwcG3CQ8Py1f27WenpuVy6xwsicGULsIoNa24HDVqLAsXziUjI4OPPhpaIHFrPj6+LF68LN9ybIGEhASWLPmKyMgIOnXqwquvFoWLYuNoEpFokzEqLK/aFSkEHj+Lc1mEJWJ7CHq1+vTpw7Rp0yhbtqxVUzC2gvsu0zJwW4xZ27jxRyIjTU7Ehg1rkcvlvPfek0Dk0NAQ5s//kjt3TNN2f/75O19+uYD69RsWql0ffPAR06dPIjExgZ49++Lt7c0LL7Ri376/MRgMKJVK0wrOp0ZYDToNFZv1QZ0SzeyePyKRrMq1NqhBryP83y1o000OhSYtDq/KlvPpJEVcN/+dlhyPu3d5fKu9RHhqDNr0BO42D+WB81+8ojYtDFA6euJWtg6R/zlrAOeODUChdOLl7nsxGgzcP78NdYqpMoJc5YIuwxTTF/zCXeRKRwIPlAXA0bMSLmVqoU6Jxsk7iGO/m/KFPY59s3dypU6NQNzdPdixYxtgmvq0VE7JEm+//S6nT5/k+vWrKJUqq0dhXZLfB57UBq1WrTrLl6/Jly0lmdWrV5hHMBctmk/t2nUpU6asVX3Pnj3N999/h0plz6hRY8x5ooo9h9/GRawNKhiykBBAjFkrbhSas/bOO0+yRTdr1oxmzZqZt48dMz282rRpQ5s2bbL0/fnnnwvLrAIh3Sf7TOq2wP374Zm2Dx8+kMlZmzx5QqbgbTCVEylsZ61ateps3LgNvV5vHn1p3vwFFi9eRlhYKMeOHSb0UQIqFz8ykiKQSBVIpDKibx/CpUxN/r7+P4s6tBmJZkcNIC0+DLDsrCkdvZ5UMLBTIZFIkCsdqdisDzpNGirVNSS6zKO9Ln41SIsPJzXuHg5u/tQsF4ZEYjounSbV7KiBKR3HY3zueuFX83W8G1TAoNPg6FkJiVSKs4/pwVm1YfYJffv3H4SLiyvR0VH8738dcHHJ36iEUqnkq6+WPHe/dNXH+dJb2khKSjL/bTAYck3u+zSPM7k/Xmn99ddz+eablRZ6FROqjSA9Mfc8ayKwZMkCKlQIyDXH4KpVK/jnn7/w8jLFoSUlJfLyy6/Rt++AHPsYvLzJyMhg1OAPmDDhCwICKqLX65k7dybh4aGAhLFjP6Ny5cwj9wcP7mPDhnVIJPDqq/+jWzfTi9sHH/Q053grW7YcEydOyeeRi2SHOA6aB9La224cRKdO73Ly5DHzdrVqNcx/a7VaYmKis/Rp0KBwHbWneXaaLCioKkFBVTlz5qRpirFhV9TJ0aRE3SY+/F8AUqKDOWbfBzsHt1xlK1SuKFSuaDNMDpuDewWrbCpT5y3iQk+D0Yi97EmCXIlUhkLlTAVDsyx9JFIZZWo97UA+NP8lt3NA4eCONs1UU9XetSzpCfcBIwGSVvjREnIIG/GvGp7t5wqFgu7dLWfmL2w0yo5Cm1CseO+9nly9eomUlBTatn2JwEDrRjP0en2mMm5PZ+Mv9vi/g0YlxgfmRHx8PDNnTiE8PJQePXpbbN+9ew+zQ6fRaOjVqysdO3bG2zv7hQTXIx4yf/6XmV7ajx07AsCyZas5d+4sK1d+lyk3nV6vZ/nypfzww3rs7e3p1asrr732P+zt7TEajSxdWkJeJGwY0VnLA9JI0xSiwdf2hpHr1WtA3br1uH//Pu3avUKvXv3M+xQKBW+99Ta7d/8KmBYidOjQiVdeeT17YQIglcqxdy1Dwv0nxeGNRj0qHuKolJGszjmFg1Qmx7/ReyRFXEeudMT5vxWclpDbOeBTpS0AaaH7suxXY/phUZKzbnWaacWa0kGNRCrDv2E3kh5eQapQ4Vq2NtqMJIw6LTirUJOco6yn5dgiEkMsAEapp4WWIgA1atRk/fqtpKam4Pkcq/Ds7Ozo338Qq1evQKFQmItalwgyYpBoUjDa2dY95JrYngxlT9SqnmDU4pr0NhmqPqiV3cGYhmtSFzJUA1Ar30ViSMQl+X3SVR+jUXZEYojFJbk36fbD0dj9D4khEqM09/qgaWlpTJv2OcnJyVSqVJkrVy6xbt1m0tPT+OCDQZleugFmzPiCgQOH5JpHLCkpEZ1Oh1Kp5Pvvl3PvXgjx8fEkJycxatQ46tWrjyY9ndkz5jBj9jRzv9at2/LCCy8CEBkZgZNT5ueTTCZjw4atyOVy4uPjMBgMKBRygoNvk5GRwSefDEWv1zNo0FBq167zvKdexApEZy0PuP9hSh1hizFrAB4ennh4ePLhh1kf8EOGjOS119pjZ2dXaHnYCgIXv1qkRAVjNOqxc/Rk4ju/gESSa8wagFzpiEdA/laMPstR1WIAc561bNvsamVq81+smdzOAY+KT5Lf2tm7AbBPNTNXWc/KsTVckk1v+o9j1kQso1Kpniv/3WO6dHmPN9/siEwms+nV8c/N0S5izBqwY8dWKlcO4qOPhnL58kVOnToBmKYSy5Ytl8VZmzx5erZyNm/exN69fxMZGYm3tzcTJkw2T0sqlSqWLFnO3bt3mDZtEuvW/UQDZxd4qsj5Y+RyOTNnTuHw4YPMnDk32/2HDu3n66/n0qLFi6hU9qhUKt5/vzcdOnQiPDyMMWNGsGnTL9lmfBDJH+IZzQPpZYr3W25QMQgsdfQMIKBZH7QZidi7lGHP1SuWOxUS1bXZl4bK1KbxdYttrJFlrRyhSLfPOT+iSMFjb28vtAkFT/VPSU+yvZi1TC8gEsUz2w6Zto1S12e2PZ/Zzn1UDeDRo4c0a2ZarFanTr08O+SPp0Fv3LjO1KkT8fd/Ev7xuPJD5cqBxMWZRsUN3jkv5ps0aRqxsTEMGtSPDRu2Zrn/2rR5iVat2jJr1lT+/PN3Xn31DcqXN5Xoq1AhAFdXV2JjY/JUz1Ukd2w7R4aNkvb6JNJez32ERyT/2Dm44egRgFRux7nwhpwLL7rYuqcpp29IOX3uussFPaBc0IN8y7JWjlBo7P6Hxs7yYg8RkRwp3wGNt3gPBQZW4dKli4Ap96RGo8mXvOrVa9CrV1+mTJmIwWBKOnzzpunl7+7dYPMKcqOrK0bXzAuU/vzzd9avN63qVqlUSKXSTMmpU1NTGDZsEBqNBqlUir29PVKplN9/38U33ywCTLVYU1NTn2u6X8R6xJG1PCC9bxrlMZSvLbAl2fPii1lX2BZ3XO0TAEhMdyty3ekSk257Y86601NM01z2Thn5kmWtHKGQGCIB60YORESyJT0CiToFo7Lw7yFbfhZ26NCJL7+cztChA62qZ2lNzNpbb3Vi375/zGl+bt26yciRg0lPT2fcuP8GGLTPVmkxjZjNnj2NoUMHotPpGDFiNEqlij17dgOmmtCvvvoGQ4cORC6XExhYhdde+x8Gg4FZs6YyePAAJBIJn332hTgFWkgUWm1QIRBrgxYNhZHtfe7cGQSHx+AQ8HK2+yf9zxTrZSlmLb88XmDwtB2W4swAi7VBrZX1rJy00H0E+XsVWjWK58U10TSNW9Ji1sQKBkWH98UOaGwgZs2WaoOq1Wp69uzCtm27C0zmmjUrcXf3yJL643lqgwYH3+bGjWu89dbbBWZXcafE1wYtSaT5jxDahFLHrksdBNNdQ2tZd41mVwtElrVyhCLN/hOhTRAp7tScQFpi1gB3kaLB4GP9iKaLiwtvvimm67EFRGctD6S/PE5oE0odlx7UE0x3Wb1l3WUrPSoQWdbKEQqt3atCmyBS3Cn7BlqFOIr5NEqlskBH1QAGDvwYnc6Q5XOji4vVMnyew7ETKVzEBQZ5QH7vDPJ7Z4Q2o1Th4RiLh2OsILpTJbGkSnLXnZrkQGqSQ65trJFlrRyhkOrvI9WXzul/kQIiNRxphngPCYZGY/onUqwQnbU84HqwM64HOwttRqliSOtlDGktTHHvk8plnFTmrvvknhc4ucdyaStLsqyVIxTOKYNwThkktBkixZkTvXG+It5DQiELC0UWFiq0GSLPiTgNmgfSAj4V2oRSx68XOwmmu5bGsu5aza3LA2dJlrVyhCLNfqzQJogUd2pPIi1BjFkTCoOvOLVZHBGdtTyQ3k4Msi5qrjwULk2Kn8Gybr+KEQUiy1o5QqG1aye0CSLFHb9X0MrEmDWhMDpbH7MmYjuIzloekN82Fb3VVWklsCWlBx9nU9HhqOScs28XFikSk24nY866UxJMS7ed3FLyJctaOUIh1YcAYJBVEtgSkWJLyl2kaSkYHEr3PaTRaJg9exoPHz7A0dGR0aPH4+9fgUOHDvDtt4vMwf0DBnxEtWo1mDBhNGq1mrFjJxIUVIWLFy9w+fKFTPWfn+bXX3/hjz/2IJFI0Ot1DBw4hIYNG7Nn53ZCw8MYPGyUue25c2fZufMXpk37ssCOb9WqFfzzz194eZmS5CYlJfLyy6/Rt++AXPuZao0OYcKELwgIqAjA+vVrOHr0MFqtlnfe6cJbb3Uyt4+NjWHKlInm7eDgW3z88TBzypJDhw5w4MBepk6dVWDHJgSis5YHXI+9D0BsFTFItiDRZyRkW0gd4MN+fwAwaW3hZj7XZyQAmQu6Hw8w6X4xNGfdxw+YVgi/2G5ervItyXpWjske28kI7pwyFCh5edZEipCTH+BsA3nWhGb37h3Y2zuwcuVawsLusXDhPL7+eik3b15nyJARtG37JNfjoUP7efHF1tSv35DfftvJyJGfsnXrTznWC9279y9Onz7F4sXLkMvlPHz4gGHDBrF69UakcXFIk5KK5Bgfl8ICk3Paq1dXOnbsjLu7R7btb9y4xvz5XxIdHWX+7Ny5s1y+fIlly1aRkZHBTz+tz9TH09OLpUtXAnDlyiVWrvyODh1MMeWLFn3F6dMnqFKlamEcXpEiOmt5IDXwc6FNKHH4++eenPLw1bYABPkXruOSmGj6Sri6upk/U0pMuv1z0a1sd9BiG2tkPS1HoZCh1XpZPDdFSZrDRMuNRERyo840m4xZ6/Rre7pX70n36j3R6rV03f02PWv0oWu17qRp0+jxexf61RpApyrvkqROpM8f7/NhnY95K7AjsemxDPirN4PrD+f1iv8jMi0SX4fcY8NCQkJo3ty0mKhChYrcu2catb558wa3b9/k559/okaNWgwePBx7ewfUajVqtRp7e3v++edPWrduh1KpzFb2zp3bGTXqU3M1gbJly7FmzUZcXd0wuLpiTE7M0a6///6Dn3/+CYVCgb9/BcaN+5xBg/qxYMESnJ1daN/+Zb75ZgXVqlXngw96snz5GubOnWmxukJSUiI6nQ6lUsmqVSsIC7tHfHw8yclJjBo1jnr16v832jifGTO+MPc7ffokgYFBTJw4htTUVIYOHZmtfKPRyMKF85kyZQYymQyAOnXq0rp1W3bu/CWXK1E8EJ21PJDRarDQJpQ4evToI7QJNoctZtXXKl4U2gSR4o5vG7RS27qvhaBKlaocP36E1q3bcvXqFWJiotHr9TRp0pRWrdpStmw55s+fzc6dv9C5c1dOnDjGzp3bGTDgI779dhEffPAR8+bNoly58vTs2TeT7JiYaMqVK5fpM/MLqEqFUZF90fjExARWrVrBmjUbcXBwZMmSBezc+QutWrXh1KkT+Pj4UqZMWc6ePYWdnR3+/hWws7PLcYRv8+ZN7N37N5GRkXh7ezNhwmQcHBwBUCpVLFmynLt37zBt2iTWrfuJunXrZ2tTRMQj5s1bxKNHDxg/fjSbNv2CRCLJ1O7YscNUqlSZChUqmj97+eXXOHfubC5XofggOmt5QHHtHwC0NcUEoUWFTP9fiRSZ5RIpBU1wvEl3kHvOuoODTQ+OoKDcy51ZkmWtHKEQ8jqIlBCSbiJLTUXvaFv30K+dnkzLKmSKTNsOCodM2y5K10zbnvaembYtjaoBvPlmR0JDQxgy5EPq1KlHtWrVkclkvPnm2zg7OwPQqlUbDh7cj1QqZeRIUxaC9evX0LXr+6xbt4pPPhnH6tUrCAsLpUKFJyPwfn5liIyMJCCgsvmzU6dOEBhYxVQbVKfL1qaHDx9QqVJls0NVr15Dzpw5yTvvdGXdutX4+voxaNAQtm3bjMFgpE2b7MsDPubxNOiNG9eZOnUi/v4VzPsaNWoCQOXKgcTF5Zx70sXFlQoVKqJQKKhQoSJ2dkoSEuKzTKX+9dcfdO3aPVd7ijNinrU84HK6Py6n+wttRqnCKWUkTinZD38XNmMOjWTModx1jxmjYswYVb5lWStHKIS8DiIlhNMf4XRdvIdu3LhGo0ZNWbZsFS+99Aply5bDaDTSt293oqIiATh79gzVqtUw94mPjyMsLJR69RqgVmcglUqRSCRkZKRnkv3mmx1Zvfp7dP85ZWFhocydOxOZTGqKWUvOfmSzTJly3LsXQnq6Sd6FC+fw969A5cpBPHz4gOvXr9KiRUvS09M5evQQLVq0tOpYq1evQa9efZkyZSIGg6mqws2b1wG4ezcYb2/vHPvWrVufU6eOYzQaiYmJJiMjHRcX12zO53Xq1BGu0k1hI46s5YGUqtkP+YoUHqkOUwTTPbGZZd0TJ6oLRJa1coRCyOsgUkKoN5tUG4xZK2rKl6/A999P5McfV+Pk5Mxnn01GIpEwYcJkPv98LEqliooVK9Gx45ME7OvWrTKvpuzcuSuffjoMX18/goIyB9C/8srrxMfHMmTIhygUCgwGPZMnT8fd3QODmyuGHGLW3Nzc+OCDjxgx4iMkEinly/vz8cfDAGjQoBGPHj1EKpVSv35D7t27i729PQAzZnxhMWbtrbc6sW/fP+zYsQ2AW7duMnLkYNLT0xk3blKO/Vq2bMXFi+cYOLAvBoOB0aPHI5PJ2LPHVJ6rffsOxMfH4+jomGVqtCQhMRqNtjnfkgdiY1MwGErM4dgsthhLVRIRz3PRIZ7rosNWznVERCh+frazeKegkcul2dYGtQVWrVqBp6eneaVoXggOvs2NG9d46623C9Ayyzx730ilEjw9nQpdrzgNmgfsLu3G7lLBFt0VyR2Z7hoy3TVBdF+Pvcb12Nx1X78u5fp1y18nS7KslSMUQl4HkRJCwhVkKeI9JBjp6aZ/xRwXFxfefLOj0GYUGeI0aB5wPmdaDRpbt4PAlpQenFLHAMLk9/rsiEn30wHEWdp8ZlpC/+uvuT8ELcmyVo5QCHkdREoIZ4fhJOZZEwzZA1N+UH2QcAs8Bgz4KN8yHicNLi2IzloeSKk5V2gTSh2pjjME0z2lhWXdU6ZYF2tmSZa1coRCyOsgUkJoMJ/U+FShrSi16MuWFdoEkTwgOmt5QN20p9AmlDp08kaC6W7ga1l3gwbWxYZYkmWtHKEQ8jqIlBA8m6AzCB+zVmr5Ly2HSPHCdoNjbBi7c79gd674Z0QuTsh0l5DpLgmi+3LMJS7H5K778mUply9b/jpZkmWtHKEQ8jqIlBDiLyBLFu8hwUhLM/0TKVaII2t5wPmSKUdQbMN3Bbak9OCUOgEQJlZq8lGT7txi1iZPti7WzJIsa+UIhZDXQaSE8O8oMWZNQGQPHwDCxqyJPD+is5YHkusuFtqEUkeK4xzBdM940bLuGTOsizWzJMtaOUIh5HUQKSE0WkSKGLNWIISG3mP+/NksXbqSKVM+Y9Kk6SgUilz76MuWy3U/wLBhg1CrM1AqVRiNRpKTkxg8eITFJLj374czceIYfvxxCwCLFy/g9u2bAMTFxeLk5MzKlWvN7XU6HTNnTiEi4hFSqZTx4ycREFCR+/fDmTVrKhKJhMqVAxk9ejxSqe3OOBQForOWBzTiiFqRo5fXFUx3HS/LuuvUsS7WzJIsa+UIhZDXQaSE4F4fvU6MWStopk370rqGDg5WNZs0aToBARUBCAu7x+efj8vVWfvzz9/ZunUzCQkJ5s8el8jS6XQMHjyA8eMzJ789ceIoer2e5ctXc+bMSVau/JZZs+bzzTdfM3DgYBo2bMz8+bM5cuQQbdq0s+74Siiis5YHlKc3AuJCg6JErvsXECbA/XykSXduiwPOnze99VlaIGBJlrVyhELI6yBSQog9gzwxFZ2rbd1DnTrZ0727lu7ddWi10LWrPT17aunaVUdaGvToYU+/flo6ddKRlAR9+tjz4Yda3npLR2yshAEDVAwerOH11/VERkrw9c09QfuePbs5duwwarWa2NgYunZ9nyNHDhEScoehQ0fSqlVb9u/fy5YtG5FKpdStW5/Bg4cTExPD9OmTMBqNeHh4muV16dKBjRu38eBBON98sxCj0UB8fAJjxkygTp16dO/emTp16hF27y4ebh7MnLOA1NQU5syZyezZ83O1NSIiAmdnF8A06hYQUJHQ0HsATJs2G09PL5ydXVi6dCXvvdcpS/9t2zbTtGlzAgODMn3u7x+AXq/HYDCQmpqKXG5ySW7evEGDBqb7o3nzFzh9+pTorAltQHHE6dp4QHTWihLH1MmAMLFS006YdOcWszZtmnWxZpZkWStHKIS8DiIlhPNjcRRj1gBIS0tj4cJv2bv3L7Zs2cTKlWs5f/5ftm79iXr1GrB69Qp++GE9KpWKGTMmc+bMSY4cOcQrr7xOx46d2bfvb3P5pseEhNxl2LBPqFatKnv27GHPnt3UqVOPhw8fsHjxMsomJzNo5hSuX79G7dp1cnTUZs78AplMTmRkBLVq1WHixCel5mrXrsvYsRPZvn0r69evYdSosbRs2SpbOVqtlp07t/P99z9m2Wdvb09ExEN69OhCYmIC8+YtBMBoNJpLRzk4OJKampKn81uSEJ21PJDccJnQJpQ6Uhy/Ekz3l60s6/7yS+tizSzJslaOUAh5HURKCI2X2mTM2tMvSApF5m0Hh8zbLi6Ztz09jZm2LY2qPaZKlWoAODk5U7FiJSQSCc7OzqjVGu7fDychIZ4xY0YAJsfuwYP7hIeH0aGDqV5onTr1sjhrXl4+rF37A/b2KlJSUnF0NKXqcHV1w9fXD72LKz7ly6PR5P6seTwN+uuvv7B371/4+j6p+9moUZP/9Nfl6NFDuco5e/YU9es3xMkpa0mmn3/eRNOmLfj442FERkYwcuRg1q3bnCk+LS0tNdu+pQ3RWcsDGrFyQZGjl9cUTHcNT8u6a9SwbtrSkixr5QiFkNdBpITgVhu9VoxZA3ItPF6mTDl8fHxZtOg75HI5e/bspkqVqoSGhnL16iWqVKnK9etZy3YtXjyfL76YSVBQICtWLOPRo4eZddnbg0xmtY2dOr3L5csXWLnyO4YONWVCuHnzOj4+vly6dJFKlSrn2v/s2dM0b/5CtvucnV2QyUxuiIuLKzqdDoPBQJUq1Th37iwNGzbm5MnjNGzY2Gp7Syqle3lFHlEeX43y+GqhzShVyLWnkGtPCaL79KNTnH6Uu+7Tp6WcPm3562RJlrVyhELI6yBSQog+jjxBvIcs4e7uznvv9WTYsEEMHNiXkyeP4+8fQN++Azh8+CDDhg3i2LHDWfq99tr/mDx5PB999AFhYaHExERnbpCaAjodAElJiUycONaiLSNHjmHv3r+4ffsWAHv2/MawYYM4ceIoffp8kGvfsLBQyj6zAnXKlM+IjY2hW7ce3Lp1gyFDPmTEiI8ZNGgo9vb2DBs2itWrV/LRR/3RarW0bfuyRRtLOhKj0WjdeG0xIDY2BYOh8A/Hc215k75+9wtdly3i7e1MdHTRvhm7JrYHhImV6vSrSXduMWudOtmb2liINbMk62k5QpxnSwh5HQoTWzzXJRXvix3Q2EDMWkREKH5+AYLaUJjI5VJ0uqwj9bLg20De86wNGzaIsWMnmleK5oUVK76lT58PsLe3z7MMoXj2vpFKJXh6Fv40rTgNmgeSmq4R2oRSR4qTcLntvmpjWfdXX2UUiCxr5QiFkNdBpITQdAUpcbYXs1Za0Jf3F9oE3n773WLpqAmJOLIm8tyIoxBFg3ieiw7xXBcdtnKuS+vImkj+EGpkzXaDY2wY1ZFlqI6IK0KLEoX2KArtUUF0H39wlOMPctd9/LiM48ctB+1akmWtHKEQ8jqIlBAiD6GIE+8hoZCkJCNJEd5ZFnk+xGnQPOB4ZxYAGa0GC2xJ6cEhbTYgTKzUvDMm3b+Wy1n3vHl2pjYWYtYsybJWjlAIeR1ESgiXp+Cg1ZPoId5DQiCNiABAH+QssCUiz4PorOWBxJY/CW1CqSPZ6VvBdC9qZ1n3okXWxZpZkmWtHKEQ8jqIlBCaryY5VkxyKhR6/wpCmyCSB0RnLQ/oqmSfqVnk+di06UfCw0OLXG9iYgJgShJpyygUMrRafZ77+/sH0KNHnwK0CAyySgUqT6QU4lQZQ7o4DScYSqXQFojkAdFZywP2B0wlMdLbfSKwJcWb8PBQ7gXfwM/J8m1YrVIUADdDfPKtNz7FlGNImR5jVftwe5Nu//ScdYc/MhU49y9zKV+ynpaTnzG2iP+OsaBRaA4AoLUr3XX6RPJBxF4UCWloPcV7SAgkyUnMXDCXWyF3zPU+ExMT6N69F2++2THXvvHx8QwePIB1635CqVSSlJTI9OmTSU1NxdXVlfHjJ+Hu7mFuf/LkcTZsWGvevnTpAj/+uAW1Ws1XX81GobCjSpWqjBw5JlPVApGsiM5aHnAIXQBAOqKzll/8nOT0r+thsV3VF04AcOt49XzrXHMpDsAqvQCD1CbdXyhz1j3oxPumNq/nnnvPkixr5Vji8TEWNA7ppjqCiaKzJpJXrsw0xayJzpogSCMjkaSnM3jwCHNlgaSkRHr37kb79h1yrKpw6tQJli//hri4WPNnP/64hrp169OnzwecOXOKFSu+ZcKEyeb9zZu/YNaxadOP1KlTj4oVKzFgQG9GjRpDnTr1WLnyO/75509ef719IR518Ud01vJAYtsdQptQ6gg510Yw3dMVlnVPf++HApFlrRyhSHZaKbQJIsWdFutJjrO9mLVOnezp3l1L9+46tFro2tWenj21dO2qIy0NevSwp18/LZ066UhKgj597PnwQy1vvaUjNlbCgAEqBg/W8PrreiIjJRbrg+7Zs5tjxw6jVquJjY2ha9f3OXLkECEhdxg6dCStWrVl//69bNmyEalUSt269Rk8eDhRUZF89dUcNBpTv4EDh9C6dVv69u1O/foNuXMnGICvvlqISuXIJ58MZd68RSgUCgD0FQIwPlNrMzY2Fjs7JRKJhFmzpmI0GomKiiQ9Pc1cI1QqlbBo0XcMGNDb3O/evbsMGjQEgLp167Fw4bxsjzUqKpK//tpjLuYeHR1FnTr1AFN906NHD4nOmgVEZy0P6Co2EdqEUoc2Q7hCvn5Sy7r93OILRJa1coTCICsvtAkixR1HfwxpYswamIqzL1z4LXv3/sWWLZtYuXIt58//y9atP1GvXgNWr17BDz+sR6VSMWPGZM6cOQlI6N69Jw0bNuby5YusWrWC1q3bkpqayiuvvM4nn4xj2rRJnDhxnHbtXmXhwmcWBdnZgVTKsmVL+PHH1UREPKJixcrMmDHH3KRcufJMmjSNEyeO8t13i5k7dyFNmjTPYn+VKtU4evQwVatW5+jRw2RkZB+8sWXLRrp164GdnWm1e9my5Th//l8aNGjEsWNHyMiwzdXvtoTorOUB+32mt4f0l8cJbEnpwcXbNC2YFF30zsJxvUn3C7k4Ksdv1jK1qXY1X7KslSMUCs0/AGjtXhXYEpFiy8M/USSmofWyrXvo6XQ5CkXmbQeHzNsuLpm3PT2NmbYtjao9pkqVagA4OTlTsWIlJBIJzs7OqNUa7t8PJyEhnjFjRgAmx+7Bg/vUrduAdetW8fvvOwEJOt2T+NSqVU3yfHx8UavV2eqUJCWBVmueBj1x4ijLln1D2bJPnkkNG5oGJGrXrseSJV/naH/v3v1YtOgrhg4dSIsWLfH19c3SxmAwcOzYUfMIHMDEiV+waNEC1q79gbp162Nnp7DqfJVmRGctDziELwEgHdFZKyr8qlwEhHHW1upMunNz1tYeNA3hW3KyLMmyVo5QOKSbFtckis6aSF65NscUs2ZjzpoQ5BQfBlCmTDl8fHxZtOg75HI5e/bspkqVqvzww3I6dOhEixYt+f33Xfzxx29PS7SoUxplill7TIsWL3LlymXmzZvFzJlzAbh58zr16tXn8uWLVKoUmKOsCxfO06FDJ+rUqcfBg/vMU5tPc/fuHQICAlAqVebPjh8/ypQpM3B1dWPhwnnmuDaRnBGdtTwQ/8qfQptQ6rj7r3DByLOtCKaf3WNFgciyVo5QJDmLdXFF8knLzSSJedYs4u7uznvv9WTYsEHo9XrKlCnLSy+9Srt2L/Ptt4vZsGEt3t4+JCQk5ConS8xaQMUsMWv9+n1I//49OX7cVFni5MnjHD16CIPBwMSJU3KUXaFCADNnmvZ7eXnz2WemxQWLFy+gffu3qFKlGmFhoZlG7QDKl6/AyJFDUKlUNGjQiBYtXnyuc1MaEWuDijw3BVXbb+7cGWREBFu9KrOgeN7VoMWRNZfiUPkFMX78ZMuNRWymXmVpwFbOtVgbNHtmzZrKyy+/lq/Rrm3bNtO8eUvK20DR+IJGrA1ajHD4ayYOf80U2oxShatvGK6+YYLoPqwP47A+d92Hr9Xj8LWsUwDPK8taOUJhp/kDO80fQpshUpy5vxu7aPEeEgpJYiKSxMRC1fHii21LpKMmJOI0aB6wf7QcgDQmFYr8Y8cOA9CyZetCkV8c8Q28DEBiZNGXStmgM+luLctZ94Yjr5na1LyYL1nWyhEK+/RvANDY/U9gS0SKK/EnJqPX6+Fl8R4SAmm0KTG33tU12/2ffz413zr8/PzyLUMkM6Kzlgfi/3egUOUfPXoIEJ21p7lz9mXBdM+zs6x7Xq9lBSLLWjlCkeS8XmgTRIo5Sy+2QavVM1y4r3SpRl9RLBlXHBGdtTxg8K0itAmlDr1GZbmRFSRn6IhLTsNBaf1ScTeJZd1ujtYFTFuSZa0coTBKPYU2QaSYk6Z3QKvPe81bkXwiF3/2iyPiVcsDDntMQdtp7WcIbEnx5fLli0REPMLRyoe2W5l7ACQ8qphnnYnpWmbvvUVCuhapRMLdSk5U9nS02G+/3qT7JVnOuvdfaWhqU/tcvmRZK0co7NS7ANAoc68hKCKSE7VcbqLTP3/gu0jBIPlv9ajRzU1QO0SeD9FZywP2Uab0BWmIzlpe+Ouv31m06CsAVAo5GbU9UClkufbxqWTKO5YfZ+1aZDIJ6VoADEYjZ8MTrHLWNutMunNz1jYfM83pWHKyLMmyVo5Q2GeY4jVFZ00kr7zgeZaSk4Og+CGNiQZALzprxQrRWcsD8R1PCG1CsebYsSPmvzO0Oh4mZVh0moJP5z+BZhkXFRIJ5h+Kcq7WTa1+bUUC2K/7LC0QWdbKEYok55+ENkGkmPNj6LvotAZGCm2IwGg0GmbPnsbDhw9wdHRk9Ojx+PtX4NChA3z77SJ8fEzVAAYM+Ihq1WowYcJo1Go1Y8dOJCioChcvXuDy5Qv06tUvW/m//voLf/yxB4lEgl6vY+DAITRs2JjdN64SGhbK4KAnV+DcubPs3PkL06Z9mUnG4sULeO+9njkuGOjSpQO+vn5IJBIMBgPp6WmMHz+J6tVr5nrsV69eYdmyJSxdaqo1fPv2TebP/xKZTIa/fwUmTJiMVPokWYVOp2PmzClERDxCKpUyfvwkAgIqWuxXkhCdtTxg8BCXJOeHatVqcObMKfP2LxcfMqpNIApZzl8yg84u33orejgw+IVKbL0ShaPKjpaVrIu/cpJY1u1kb11tO0uyrJUjFEZp9ivICgO9Xs/PP//EvXt3adfuZZo3b1lkukUKB41Gw62QSDQaLUlJibi4FN39ZGvs3r0De3sHVq5cS1jYPRYunMfXXy/l5s3rDBkygrZtn6zAOHRoPy++2Jr69Rvy2287GTnyU7Zu/YnJk6dnK3vv3r84ffoUixcvQy6X8/DhA4YNG8Tq1RtBKgOJdQ7NyJGfWmzz9ddLUSqVAJw6dYLVq1cyb96iHNtv3LiOv/7ag0plb/5s9erv6d//Q1q0eJFp0yZx/PhRXnzxyQK7EyeOotfrWb58NWfOnGTlym+ZNWu+xX4liZLpghYyjrvH4bi79Jaaio2NRavV5rn/++/3pkmTZubt4JhUzoYn5NrHvexd3MvezbPOx9Qr50pgGU/83J2t7vO37i5/63LX/ffFJvx9sUm+ZVkrRyiU6l9Qqn8pEl07dmzjxx9XcfjwAWbM+IJ790Keq/+tWzdZvXol+/f/U0gWijwvCxbMIYCTVLH7l4kTxwptTiY6/dqezTc2AqDVa+n0a3u23twMQJo2jU6/tufX26Z7P0mdSKdf2/PbHVMMZ2x6LJ1+bc9f90z54yLTIi3qCwkJMSeerVChovn+vnnzBr//voshQz7km28WotPpsLd3QK1Wo1arsbe3559//qR163ZmJ+lZdu7cTt++HyD/bzFB2bLlWLNmI25ubpCaiiSbguvh4eF8+ukIPvigF6tWmSqpDBs2iNDQe4SE3OWrr+Zk6fMsERGPcHY2PVt79erKvHmzGDx4AOPHf0L6fyWuypUrz6xZ8zP1q1q1GklJSRiNRtLSUs12P8bfPwC9Xo/BYCA19cl+S/1KEoI5a/fv36dhw4b07t3b/G/p0sxTQJ988gkajUYgC3NGFbsJVewmoc3IF6biuoc5cuSQKeeRFej1eqZPn8zrr79O377vPfeP52OkUil169bP9JldLqNqAN4Vr+Ne4RoZ2qJfRbZNf51t+uu5tznZlm0n2+ZblrVyCoKkpETu3g1+LsdblbEKVcaqQrTqCffvP0kebDAYePTogdV9Hz16yLhxo9i69Sfmz5/Nnj27C8NEkefk6tXLdKkXTZd60dy5c5uMbJyG0kKVKlU5fvwIRqORK1cuExMTjV6vp0mTpowaNZZvv/2e9PQ0du78hcaNmxIXF8fOndvp2LEzhw8fICioCvPmzWLjxnVZZMfERFOuXLlMn7m6ugEgTUnJVBv0MRqNhi+//IrvvvuB7dt/zrSvUqXKjBkzIdvjGD16GAMH9qFz5/Zcv36VoUNHAZCRkcFrr/2PZctWERBQkZ07TY5u27YvZ3Gqypf3Z9Gir+jZswtxcXE0aNAo0357e3siIh7So0cX5s6dRZcu3a3qV5IQ1A0NCgpi/fqc8zYtXLiwCK2xnth3LwhtQr5ZtGg+//xjqnHaunU7PvvsC4t9rly5xIkTptpx8fHxbN36E2PHTsy1T0ZGOlqtzvy29ZiOHd9h164dJMbH8kJFdxqWz306ZPyialx8mIRGc5l+TSvQvGLBlYpKVev4+2YUBiO8Ws0bF1XmtB5L7F63KGNJ/8VW6bIky1o5eeX27Zt8//0yMjLSCQ8PJyMjnerVazJnztc5vqU/TaLLtkK172leeeV1Dh7ch1qtpnx5/ywOfm7cu3cXtfqJI3DjxjXat+9QCFaKPA/NmrVgxA5TUtZ69RqgUhVMSp6C4NdOe8x/K2SKTNsOCodM2y5K10zbnvaembZ9HXwt6nvzzY6EhoYwZMiH1KlTj2rVqiOTyXjzzbfNz8tWrdpw8OB+pFKpeUpy/fo1dO36PuvWreKTT8axevUKwsJCqVDhSQkkP78yREZGEhBQ2fzZqVMnCAysgsHbG0N6WhZ7KlcOxM7OFKYhk1nvGjyeBl2x4lsePnyAu7vp2SyXy6lf37S6vXbtepw8eSxHGYsXL+Dbb7+ncuVAfvnlZ5YuXcSnn4437//55000bdqCjz8eRmRkBCNHDmbdus0W+5UkbGrM8NSpU3z11VcoFAq6devGkiVL+OOPP6z6ESlSnL0KVXxiYgKJiYnMnVt4q02PHDn01N8HkUolFvskJ2eu53fz5vVcbYyOjub69asYDAYqVqxExWeSMTo7O+PrbMf7DXM/n5FJGZy+l8LjgeDN5+4XqLO24sQ9bkaZ8ptdeZSEnVxKulbPu3XLUq+cKyqJ5a+Jys66EWBLsqyVY4kUjYGosNAs1+fEiWOo1epMn924cY3Jk8fj6Wl7OdQaNGhIWlo6Li4uLF1q/cubRqNBobBDqzWdz4cPH+R6ryoUMrQCjNqWNoxGI64efqhUqizB7KWNGzeu0ahRU0aM+JQbN64RGfkIo9FI377dWb58NT4+vpw9e4Zq1WqY+8THxxEWFkrv3v356af1SKVSJBIJGRmZR8refLMjq1d/z+TJM5DL5YSFhTJ37kxWrVoPUilIsj7vs/nouRg4cDAjRnzM9u1beffdbuh0Om7fvkWVKlW5fPkilSoF5tjXxcUFR0fTIjMvL28uX85cwcXZ2cXsQLq4uKLT6TAYDBb7lSQEddaCg4Pp3bu3ebtr166o1Wq2bt0KwJIlS4QyLVecfh0FQEqnRYLakR+cnV1ISIj/72/r4recnZ0JCqrCo0cPsbd3yOJ8PUtIyB0MBlM+pXv3Qihf3j9PMQVGI/yvZSwAfxzzpKBX/YfFP3nLfJj0ZDTm+5P3WNipDv8YTTFm7eVBOcrYc665qU3Dk7nq2qMLzlWWtXLygtFoRKPJfsrT2heihkGm1CPngmsVmF25oVLZZwpEthY7OzsaNWpMXFwcjo6OuOZQWkekaJFIJPyvRhz29va29xJexJQvX4Hvv5/Ijz+uxsnJmc8+m4xEImHChMl8/vlYlEoVFStWomPHzuY+69atom/fAQB07tyVTz8dhq+vH0FBVTPJfuWV14mPj2XIkA9RKBQYDHomT55uGvXKIWYtN0JC7vLLLz/nOBUKmFdpDhs2kDZt2gGmxQSRkRH4+voxcODgHPuOHz+ZqVMnIpPJkcvljB9vKuU4ZcpnjBjxKd269eDLL6czZMiHaLVaBg0air29fY79SiISo1GYjDf3799n9OjR/Pzzk7nxU6dOsWnTJhYvNk0FvfTSS881shYbm4LBUPiH47m2vElfv/uFIv/xCMD48ZMLRT5AamoK27dvxWAw0Llzl+daleXt7Ux0dLLFdp98MpQbN64BoFKp+PnnXSgUT6YY586dQUZEMO9Vd2HXlQhSNDpeq+ZDBXeHLLIcam0jTaPn41nV6NGoPK0D8z66ueZSHAD965pG5zb+G87hOyZnUCWXkqEzOZgSYFHnOowwmKaLVyrfzFHmoBWmYOmVH83PsQ3AIPXvucqyVo4l1lyKQ+UXlOUe2rr1J9as+R6A2rXrIpVKefXVN3j55deskuua2B6ARNc9FloWL6y9p0XyT/KOWhiN4PLOVUHtiIgIxc8vwHLDYopcLkWny5p8WBZ8GwB9UOFW4unSpQMbN27Ll1O+YsW39OnzAfb2z//CVlg8e99IpRI8PZ0KXa9NTYMCxSJHSuz7t4Q2Id84OjrRu3f/QtUxevR4Fi/+ivT0NPr3H5TJUXuajf/eN68GvRaRzJy3amEnz3wfpF17h7hUDQveluOoLNjbtkfD8tQt44LBCBKMfH8yDK3eQKc6ZVApZHxntFxw+rsPv7ZK13cWCqBbKwfgwoMELj5IopKng9XOa9eu7/Pyy68hkUjMsSXPQ6LLzufuIyLyNKtCuqPV6rGttaClB33lnKcjbY23337Xphw1IbE5Z61YoMw68lNQ6PV67t69Q3JyEn/++TtvvJHzaI6t4+9fga++sjyVHZn8JIYqVaMnVaPDTv5MPjKjFA+HwglGlkgk1ClrGlnU6Q2MaReIi0qBu4PJBrkVOYnkMuvinSzJslbO3dhUlh+7hxE4fi8OO7mU5gHWOV8eHvmITZNYX1NVRCQ7DMgQi00JSBENiGzblv8V2Dkl4y2NCOaslS9fPtMUKECzZs1o1uxJ/q39+/cXtVlW4bRjGAApnQs+2/zOnb8QFhYKwOLFX1GhQgA1a9YucD22ROtATzb9ex8jULesC272WR0CT3/TaGZseNUs+woKjc7A1weDCYlLw8FOxidtAqng7sBunUl3B3nOunefNeVL6tD4eK46LMmyVs7DxIxMsXsPEjKgCGZ0lBmmPFRqVc/CVyZSImnodgm9Xqw3JRSSOFPIhzE/L20iRY44spYHlIm/ApBCwTtrUVGRz2xHUTP3yh3FntaBXgR5OZKi0RPk6Ygkm2VJnv6mOIvCdNauRyUTEmdabJCm0XMoOIbeTSqwW2/Snauz9q8pu75FZ82CLGvl1PJzxkUlJylDh51MSiN/t1zbFxQqteisieSPRu6XxdqgAiKNM8Xs6kVnrVghOmt5oLAWFgC8/vqb/P77LnQ6HQEBFWnSpGmh6bIlyrrmHpdw63jhTwe72yuQgHnEyu2/adDcFhY8xtoFAZZkWSvH3cGOya9V425sKuVc7fF2KpqVdSVtYYFI0fN9SE+0Wj0lMxuW7VPYCwtECgfRWbMxKlWqTLNmLcjISGfy5Jmlfnl7UVLB3YHejf05GRpPOVcVb1T3EdqkXHFRKahfzk1oM0REREREChnRWcsDztsGAZDcZWWhyFcoFCgUCtFRewqvCjcAiAmrXqh6Wlb2pGXlzNMDO3Qm3Z3lOevecaqVqU2zI7nKtyTLWjlCocpYC0CGqp+gdogUX5q4X0CvF5cY5ERIyF3mzZsFGClfvgLjx0/KMT/lqlUr+Oefv/DyMq0GT0pK5OWXXzPnYsuOvTu28vOuX5GplFSuHMSnn04wZ2GIj49jwIDeLFz4LQEBFbP0zcjI4JNPhjBhwhcEBFREr9czd+5MwsNDAQljx35G5co556MUyTu2nyfDBrFL/hO75D+FNqNU4V4uBPdyeatFml/+0Yfwjz533f9casI/lywXYLcky1o5QqHUbEep2S60GSLFmLpu16nnfkNoM2yWlSu/5aOPhrJs2WoAjh3L/cWte/ceLF26kqVLV/LDD+v5/fddxMfHZdtWrc7g+x/X8O2Yz1i2bDUpKSkcP26Sr9PpmDdvNnZ22Q8S3LhxjaFDB/LgwZMavY9tW7ZsNQMHDmblyu+e+3hFrEMcWcsDsf3DLDfKBy++2KZQ5RdHbp+wnOussPhOaUWetYFW5lmzIMtaOUKR6LJLaBNEijlhQatJSkqnpdCGPINrYnsylD1Ni2eMWlyT3iZD1Qe1sjsY03BN6kKGagBq5btIDIm4JL9PuupjNMqOSAyxuCT3Jt1+OBq7/yExRGKU5l4fNC0tjWnTPic5OZlKlSpz5col1q3bzMyZ85DJZGi1WmJjY3FyMiVcnTHjCwYOHJJrOoukpER0Oh1KpZLvv1/OvXshxMfHk5ycxKhR46hTpy7LVq1H8d/iAr1eb3bOli5dRKdO77J+/ZpsZWs0GmbPns+MGU/qSLdu3ZYXXngRgMjICJycrKuGI/L8iM6aDdKyZWuhTRAREREpFF566SWxWgSwY8dWKlcO4qOPhnL58kVOnToBgEwmIyLiEaNGDcHR0Ymg/xYETJ48PVs5mzdvYu/ev4mMjMTb25sJEybj4GCql6lUqliyZDl3795h2rRJrFv3kznP4rZtm0lPT6dJk2bs2bMbNzc3mjVrkaOzVrdu/Ww/l8vlzJw5hcOHDzJz5tz8nBKRXBCdtTzg/HM/AJK7rRXUjtKEd0VT2aroe0Wfx2SrzqS7qzxn3VtPtDW1aXEwX7KslSMUqgxTqaoM1UCBLREpttz6DlVKBhn+tnUPZVrpLFE8s+2QadsodX1m2/OZ7dxH1QAePXpIs2YtAKhTpx52dk8Sgfv5lWHz5h3s3v0r33yzkEmTpuUop3v3HnTq1IUbN64zdepE/P0rmPc1amQKqahcOZC4x/nVoiL5bt0qwmKimTVrHhKJhN9/34VEIuHs2dMEB99i5swvmDPnazw9rauMMmnSNGJjYxg0qB8bNmwVqw4UAmLMWh6wSzmEXcohoc0oVbj6huPqGy6I7iP6cI7oc9d95Fo9jlyrl29Z1soRCqXmD5SaP4Q2Q6Q482A3ymjxHgoMrMKlSxcBuHMnGI1GA8D48Z8QHm4KtXFwcLC6BGP16jXo1asvU6ZMxGAwLeC4efM6AHfvBuPt7Q3A/MUL0KSk8OWXC1CpTFVhvv32e3PcW1BQVSZNmm6Vo/bnn7+bR+JUKhVSqRSpNGueTJH8I46s5YHYD4QJdC/NBJ96XTDdS5SWdS8ZsLhAZFkrRygSXcTFBSL5pN0fJIrToHTo0Ikvv5zO0KEDM8Wh9erVj9mzpyKXK1CpVIwfPxmwLmbtrbc6sW/fP+zYsQ2AW7duMnLkYNLT0xk3bhI3b95g9+ED1KvXgBEjPgZM9YLbtGmXrbw9e0wlo9q375Dt/jZtXmL27GkMHToQnU7HiBGjUSoLpyxgaUdiNJacXNKxsSkYDCXmcGwWb2/nAok5mTt3BhkRwfSv+/wFxfPDmkumlVJFrbcoWXMpDpVfkPlBL5I7BXVPi1jGVs51REQofn5FUKPNCtRqNT17dimQepqPWbNmJe7uHnTq1CXPMoKDb3PjxjXeeuvtArOruPPsfSOVSvD0dCp0veI0aB5w2dwDl809hDajVOFT6Qo+la4Iovsn3RV+0uWu+6ejL/PT0ZfzLctaOUJhn/4d9uni8nyRfHBjMfZh4j0kFJLoKCTRUVa1dXFx4c03OxayRSLWIDpreUCedhp52mmhzShVOHs/wtn7kSC6T+sfcVqfu+7TwTU4HVwj37KslSMUCu0hFFoxXlMkH0TuQxEr3kNPo1QqC3RUDWDgwI+zHVWTJCcjSbZuZNPHxzfbWs0iRY8Ys5YH4j4IFtqEUsed068Kpnuh0rLuhf2WFogsa+UIRZLLFqFNECnutNlFkg1Mg5ZWDJUDhTZBJA+IzpqIoESk6MwxZEWpEyhyvUVJRIqOikIbISIiIiJSIIjOWh5w2dQNgKQePwtsSfHG39/64N42dUzTzocuN823XvfEBABUrm5WtT+jMOluos1Z95kzpkTGTZoczpesp+UoFDK0Wr1VNj5LRZ7v/FqLffoSANLtRxS4bJFSwvWvsE9Rk15RvIeEQBIVCYDRx3IuOBHbQXTW8oA8/aLQJpQIevToY3Vbl+ReADRvX/SrG/v/adI9/o2cdffvb1quPn587qXCLMl6Wo6trJp7GoXO5GymC2yHSDEm5gQKtU68hwRCkpoKgJg3oXghpu4QeW5s0YkoiYjnuegQz3XRYSvn2pZSdxQGcrkUnc5gdfsuXTqwceM2lMonhdxPnjxOZGQEb7/9TrZ9OnZ8nV27/sq3rQCrVq3gn3/+wsvLlIw3KSmRl19+jb59B1jsO3fuLFxcXBg8eDgGg4EFC+YQHHwbhULBhAmTKV/eP0uf+Ph4Bg8ewLp1P6FUKlm/fi2nTh0HICUlhbi42GyPTajUHeLImoiIiIiIiEgWmjd/oUj1PS6dBabC8b16daVjx864u+ecE/PXX3/h7t1g6tdvCMCRIwfRaDSsWLGGK1cus3TpQubM+TpTn1OnTrB8+TfmElwAvXv3o3fvfgCMGzeKIUNsa5pedNbygMvGzgAk9dwhsCWlB/t005ct3X50ketecs6ke0TDnHUvWWKq6zdihCZfsqyVIxRCXgeREsLVOdinqkmvZFv3kOvZ9mSU7Ym6bE8waHE99zYZ5fqgLtMd9Gm4nu9CRvkBqP3eRaJNxOXi+6T7f4zGtyMSTSwul3qTHjAcjff/kKgjMSpzjwnbs2c3oaH3GDx4eKakuMOGDSIgoCKhofcAmDZtNqGh9/jxx9VIpVJiY2Pp2LEz777bjTt3glm0aD5GoxFXV1c++2wKt27dYNmyb7CzU9ChQ2feeONNAJYsWUCdOvV4qWZtRs/4giYvtqZ7917MnTvTXKFgwYI5PHz4AIDZs7/i6NFDhIbe44MPBvHFFxNITU0lIyODQYOG0LRpc/OxrFjxLSkpKYwePY4DB/axZctGpFIpdevWZ/Dg4axatYIrVy6Rnp7OhAmTWb9+jcVqDElJieh0OpRKJatWrSAs7B7x8fEkJycxatQ46tWrz+XLF7l27Qpvv/2O+XxdunTBXHO1du063LhxPYtsqVTCokXfMWBA7yz7Dh3aj7Ozc6bjswVEZy0PyDNuCm1CqUOuuySY7isxlnVfuWJdykJLsqyVIxRCXgeREkL8BeRqrdBW2DS1a9dl7NiJbN++lfXr19C6dTtiYqJZvXojRqOBPn2689JLrzB37kw+++wLKlWqzG+//crGjeto0qQZGo2GNWvWZ5oGbd26HX/88RsvlitPcnIS//57hvfe68nNm9cZN+5zAN58823q1avPrFlTOXPmlLnvgwf3SUxMZMGCJcTHxxMeHmret3TpIqRSCZ9+Op6kpERWr17BDz+sR6VSMWPGZM6cOQlAQEAlRo0aA8DkydOzPe7Nmzexd+/fREZG4u3tzYQJk3FwcARAqVSxZMly7t69w7Rpk1iw4BvWrPme2bO/Yv/+f8wyUlNTcXR8Mi0plUrR6XTI5U/cnSZNcnbE1q9fy9SpsyxfpCJGdNbyQNyAa0KbUOpIdl4rmO6Vr1nWvXJlRoHIslaOUAh5HURKCC9uJtkGYtaeJbHxnicbUkXmbZlDpm2jwjXztp1n5m0Lo2pZyRxr3ahREwDq1KnL0aOmBMK1a9fFzs408l65ciAPHtwnNDSEBQvmAKDX6yhfvgIAFSpkjcWrW7c+ixd/xdnYGNq89j8OHtzHxYvnqVWrrjnxbfXq1QHw8PBErX7yLKpcOZC3336HqVM/R6fT0aVLdwDi4mK5c+c25cqZYsLu3w8nISGeMWNMU4hpaWk8eHA/R5ue5fE06I0b15k6dSL+/hWynJPKlQOJi4vlwIG9JCQkMGbMCOLiYsnIyCAgoCKOjo6kpaU9ObNGYyZHLTdCQu7i5OSUbYyb0Fh1BBqNxnyTiIiIiIiIiOQPOzs7YmNjALh580amfTdvXsfHx5dLly5SqVJlAG7fvoVer0er1RIScpfy5StQoUIAkyZNx8/Pj0uXLpjlSaVZqw5IpVKqV6/Jxo0/MnLkp8TFxfLdd0sYNGjIU62yr1Zw504waWmpzJ+/mJiYGAYP/oCWLVvh4eHJ118vZfjwjzh58jjVqtXAx8eXRYu+Qy6Xs2fPbqpUqcrhwweztSknqlevQa9efZkyZSLLl682n5PXX2/P3bvBeHt707Vrd7p2NTmNj6eU27fvwMGD+zh27Agvv/wqV65cpnLlIKv1nj17usjj9KzFKmft3XffpXnz5nTt2pWqVasWtk02j+v6twBI7P2bwJaUHhzS5gKQ5jC+yHUvOGvS/WnjnHUvWGB6mfn009xjzSzJslaOUAh5HURKCJdn4JCmJq1y6b6HmjV7gV9//YXBgwdQrVoNHB0dzfv27PmNLVs2oVKpmDx5OnfuBKPT6RgzZgSJiYn07TsANzc3Pv30M2bO/AK9Xo9EImHChMnExETnqLN163bMnjmFqk7OxDVtwZ9//m4OzM+N8uX9WbNmJfv378VgMDBgwEfmfY/1fvrpcFauXMt77/Vk2LBB6PV6ypQpy0svZa3aMmPGFxZj1t56qxP79v3Djh3bALh16yYjRw4mPT2dceMm5XqMZ86c4uOPP8BoNDJx4hTANL1ZpUrVXJ2xsLBQmjRpZvF8CIFVqTsMBgNHjhzhl19+IT4+no4dO9K+fftMN5ctUFSpOzxW1QYgboAwhcWFRoil987JHwKQ7PxDkeoFGPyPSfeyV3PWPXiwKT/asmW5T2NakvW0HFtJcfA0Ql6HwsQWz3VJxfv2YDIytCTXEfYestXUHcOGDWLs2IkEBFQ0f3bu3Fl27vyFadO+tFpOTqk7pP8F4huekm/rrFq1Ak9Pz2xrnVrL0aOHsLd3ME+n5hWbTt0hlUpp3dqUWX3btm2sX7+eX375hbfeeotevXoVqoG2SGl10oRESOcgNyfN3MaCk2atLGvlCEVJc9JEBOCFDTYZs1ZaKE5OWkESFFQt15E8W8eqkbV58+axb98+mjZtSteuXalbty4Gg4F33nmHX3/9tQjMtA4xKW7RII5CFA3ieS46xHNddNjKubbVkbWC4nmT4opYh02PrFWsWJHt27dnmvaUSqUsXbq00AyzZVzXvQ5AYt+CydwsYhmHtJkApDnkHKtQWMw5bdI9oWnOuufMMcWaTZiQe6yZJVnWyhEKIa+DSAnh0hc4pKpJCxLvISGQPnoIgKFMWYEtEXkerHLWmjZtyoYNG9BqTblxoqKimD59OuXLly9U42wVqS5SaBNKHTLDA8F0P0yxrPvhQ+vyo1mSZa0coRDyOoiUENLCkYl51oRDK5774ohV06BdunTh1Vdf5dSpU/j4+JCWlsaSJUuKwr7nQpwGLRpsZRqjpCOe56JDPNdFh62ca3EaVCQvCDUNatVrvIODAx999BG+vr7MmTOHmJiYwrZLREREREREREQEK6dBJRIJ0dHRpKamkpaWlik7cGnEbd3LACT03SewJaUHx9SpAKQ6Ti1y3TNPmHROapGz7pkzTbFmkyblHmtmSZa1coRCyOsgUkK48BmOaRpSq0wV2pISz7Bhg1CrM1AqVRiNRpKTkxj6Xi9aNGiEoWz2MWsTJowmMTEBmUyOUqliwYIl3L8fzqxZU5FIJFSuHMjo0eORSp+M9aSkpDBlykTS09NQKOz44ovpeHp6AaDX65ky5TPeequTzSacLQ5Y5awNGzaMvXv38vbbb/Pqq6/SsWPHwrbLppHoE4U2odQhMcYJpjtebVl3fLx12bktybJWjlAIeR1ESgjqWCRi3FSRMWnSdHPOtrCwe3w+7hNa1K2XY/v798NZv/5ncwkqgG+++ZqBAwfTsGFj5s+fzZEjh2jTpp15/549uwkMDGTIkJHs2rWDTZvWM3z4Jzx4cJ+ZM78gKiqKt97qVFiHWCrI1Vl76aWXzBfMaDSiUChQKpUcPHiQ8eNLb/bp+A/OCm1CqSPFSbgYyQVtLetesEBdILKslSMUQl4HkRJCs5Wk2EDM2rO4dmpPRveeqLv3BK0W165vk9GzD+qu3SEtDdceXcjoNwB1p3eRJCXi0ud90j/8GM1bHZHExuIyoDfpg4ejef1/SCIjMfrmXh90z57dHDt2GLVaTWxsDF27vs+RI4cICbnD0KEjadWqLb/8soVDhw6Qnp6Om5sbs2d/xa5dO7h06QLTps1m5swp1KxZm1deeY05c2Yye/b8XHVGRETg7OGJwb8Cw4YNIiCgIqH/JcmdNm02EomE5ORkxo//hOTkZHr16kfLlq24efMGDRo0AqB58xc4ffpUJmctMDCIsDCTnNTUVHMtzrS0NMaPn8zGjevyeFVEHpOrs/bnn39iNBqZNm0a3bt3p27duly7do2ffvqpqOwTEREREREpkaSlpbFw4bfs3fsXW7ZsYuXKtZw//y9bt/5Ey5atSUxMZNGi75BKpYwePYzr16/y7rvdOHv2FLNmTUWr1fLOO10BcnTUZs78AplMTmRkBLVq1TGXXwJTcfixYyeyfftW1q9fw/vv96Z791507dqd5OQkBg8eQM2atTAajeaBGwcHR1JTUzLpcHFx5fTpk/Tq1ZWkpCS+/fZ7AKpUEctTFhS5OmuPi7eHh4dTt25dAGrWrMndu3cL3zIbxm1NGwAS+h8S2JLSg2Pq5wCkOs4qct1Tjpl0T2uZs+4pU5SmNtNyHxmzJMtaOUIh5HUQKSGcG4NjuobUqrZ1DyX+uufJhkKRedvBIdO20cU187anZ+ZtC6Nqj6lSpRoATk7OVKxYCYlEgrOzM2q1BqlUikKhYOrUz7G3tycqKgqdTgdAz579+Pjj/qxatcGijsfToL/++gt79/5FGb0e6QNTCp7HpZfq1KnL0aOH8PT0olOnd5HL5bi7e1ClSjXCwkIzxaelpaXi5JR59eOaNd/To0cfOnV6l+Dg20yaNI516zZbdQ5ErMOq1aDOzs4sWrSI/fv3s2DBAry9vQvbLptGYsxAYrTtskAlDYkxHYkxXRDdGfp0MvS5687IMP3Lryxr5QiFkNdBpISgT0di4ftUWng6LuxZgoNvc/jwQaZP/5JPPhmH0WhKw6HValmyZAFjx05kwYI55vynlujU6V18fX1Z8dN6+E/WzZvXAbh06SKVKlXmzJlTTJ5sCnFKS0sjJOQOAQGVqFKlGufOmcJ/Tp48Tr16DTLJdnZ2Njtw7u7upKamPsdZELEGqxYYfPXVV2zevJmDBw8SGBjI8OHDC9sumyb+g1NCm1DqSHH6WjDdc1tb1j13rnUjYZZkWStHKIS8DiIlhCbf2mTMmq1Rvrw/9vb2DB78AQCenl7ExESzbNkSXnjhRd5++x1iYqJZvvwb+vYdYFXM2siRY+jb931effc9APbs+Y0tWzahUqmYPHk6rq5unD59kkGD+iGVShk0aChubm4MGzaKefNmsWLFtwQEVKRtW1NGhGHDBrF06UoGDhzMnDkz2LFjGzqdjvHjPy/ck1MKsSopbnFBTIpbNNhKUsuSjnieiw7xXBcdtnKuS3tS3GHDBjF27ETzStG8sHjxAkaO/DTP/YsjNl0bVCQzbmtaApDQ/5jAlpQeHFNNQ/OpjnOLXPekoybdM1/MWfekSaZYs5kzcx8ZsyTLWjlCIeR1ECkh/DvKFLNWTbyHhED64H6ByerevWeByRLJHdFZEym2bNr0I+HhoYWu56zyNABzj83Iuc3ZDqY2c3cDkJiYAICrq9tzyXpajkIhQ6vV59nuwqBjc5P9u05mtt/fP4AePfoIYZKIiEgeWLp0Zb5l+Pr6FYAlItYgToOKPDe2Mo0xd+4Mbt29iczVTmhTsqBLMI2Myd2UAltS+OgTNVStXI3x4ycLbUqesZV7ujRgK+e6tE+DiuQNcRpURCQPyFztcG2dfdkUIUk8/BDAJm0raB4fq4hIcePp/GEiIpYQcmzLqtQdIplxX90M99XNhDajVOGUMhqnlNGC6D4Zd4CTcQdyb7O+CyfXd8m3LGvlCEXvSgfoXSn3cyEikitnhuJ0XZjv8tPI5XakpiYJ+gMsBNL74UjvhwttRrHDaDSSmpqEXC7MTI44spYHjBKV0CaUOowSe8F0yySWvyYyO+tyHVmSZa0codAYxEeGSD6R2WOUyYS2And3b+Ljo0lJSRDalEJBKpViMGSdBpX8d7zGCHGK9HmRy+1wdxcmz6z45M0DYuWCokfIjPlN3FtZbvPezgKRZa0codgSavlciIjkSsOvSLWBmDWZTI6XVxmhzSg0cowNLMFxeiUZcRpURERERERERMSGEZ21POC+ujHuqxsLbUapwillBE4pIwTRfTx2H8dj9+XeZu17HF/7Xr5lWStHKPpV3ke/yrmfCxGRXDk1CKdrwnyXRcDp0xE4fSqe/+KGOA2aB4wyV6FNKHUYJR6C6VbKLMcoKp2sq4VnSZa1coQiRSfGa4rkE6UnRr1GaCtKLUZ34Z6lInlHdNbyQEJfcWShqEl1nCqY7kZuLS236fJbgciyVo5QbAuzfC5ERHKl/pc2EbNWWkmdNFVoE0TygDgNmgeOHTvMsWOHhTZDRERERETkuRB/v4on4shaHmh5otd/f4QJa0gpwjllMADJTsuKXPfR2H8AeNHz1ZzbrOphajNgU75kWStHKAYEmuxfdSfncyEikisn++OcoSW5VtF/l0Wg3KQJpj8OHBfWEJHnQnTW8kCy2hEAZ4HtKE5ERUVy9+4dqlatjodH7jETd+4E4+joiJ/fk2X1emm5POtOuZ+ANlmNcyUP5CrFc/d3lFm+0o4e8QUiy1o5+cGg0yOV5y3PVZxGvOtF8omDP3qjWmgrSi3xTk7o9Xr89XpkNpDvTsQ6RGctD3wnN41+jBfYjuJCSMgdPv10BOnpabi6urF48bIcCwB/9dWX7Nv3N1KplJEjx/Daa/8DIM1hUqZ2t27d5NGjh+jQ5ao77koEDw/dAcDOzZ6gbvWQKjI/oIwGIw8OBJN0NxYHP2f8X6+GzO7JV6OBW3MSb8cQevw69t6OeDfyRyLNXKKmfqc9RBwN4cbaWOx9nHBxcEYqzRpl0MCtea72Nuj8R67784MmKYN7O6+iScrAJcgT/9eqPXepnR3hudsvkjN68cfRRN3ppIkxa4IQFRXJNJkMtU5L1dHDmDPna+zthUs4LmI9YsyaSL65desmGzeu499/T2e7/+jRw6SnpwGQmJjA6dMnsm2XkBDPvn1/A2AwGNixY2u27c6ePc0nnwzh5s0bRAY/QJuS81t60t1Y89+ahHTSY7Kutky4GUnCjSgMGj0pYQnEXHiIQac370+PTiH8n5skh8QRdTqc2EtZa2Em34sn9tIjdKkakkPiSI5OzNGm7DAajcReeUTEsRAyYgtnRWjMuQdokjIASAqOJSU8oVD0iGRGr9czc+YXdOjwKkOHDiQ+Pq7QdZa2EkolCaPRyIIFc+nY8TW6devI+fP/Fpjs33/fhVptegbcunVDjF0rRojOWh74TLGCzxQrhDbDJggNDWHMmOFs2LCWSZPGc/Jk1jiIgICKz2xXylaWg4MjTk5Pptni4+O4du0KAM7JH+Kc/CEAJ08eM5dRMegNRJ4OIykkluAtF7i7/TLq+DSzDDu3zKkmnnbe9GodwT9f4MH+O5naRJ8N59r3p4i7FgHA8ZT9hNQPMe/XJGZksf3M9o8ICZlu3s7px/JIzF8cifkry+fRZ8N5dOguZ3Z8zN65XdClPyk7ZTQaMRqMpD5IJOMpZ9Og1T/Xj7JEnvnrLpU//9d/UNBfDArKan9+CAm5y4gRHzNwYB9OnjxWoLJtgZMnj3Hs2BGMRiN37wazfXv2LyEFxY8/rqZjx9fp378noaEhljsUAg8fPuD8+X9Rq7N5kTreC+fLHxa9Ubmwbdtmpkz5jF27dghtCn/++Tt79/6JVqslOTmZ+fNnF5hsV1dXpoeEMD3EdF+4uIhpqIoL4jRoHohLcwPATVArbIMbN66j1T5xLK5cuUTz5i9katO6dTvS0tK4cuUSTZo0o27d+tnKsrOzY8aMOUyd+jmJiQkkJiYyZcpnbNiwDQdZFXO76tVr8vvvu8zbCdejSLgRBf/5Lff33SawSz0AnCt6EHc5wtxWl/okv1PMpYdkRD8ziiXBJMdoJOJICB41/fBw8UFy3+QcShVS3Kr7ZLHdo3I8Uk00AEoPB5w9XbI9RheFe7afp0emAKBShQKgSUxHKpcSuuc6qfcTkank6DNMU75lWlVGnZBG3OUI5PYKAjrUxN7bKVu5T+PduDzq+DQy4tJwr+aDY9nnf1BHpGdv/2MMBgMLFszh8OGDVK1alSlTZln8QVi0aD63b98EYM6cGfz88y7s7IQpllwYyOWZ4yQViuePm7SW+/fD+emn9QBERDxkzZofmDq1aEu1nT59ghkzvkCn01GlSlXmz1+CUql80sC5GnqZ7cSs7d//D6tWmV6+T58+ia+vH82atRDMnvvPFFl/+vmaXzp06MyBhfPJUKvp1asfTZuKYQ3FBdFZywMrFKYM87YUsxYScodVq1YglUoZOHAI/v4VikRvrVp1UKlUZGRkIJVKadCgUbbt3njjTd54481cZWk0GtzdPXBzcycxMQGAlJQU0tJSUbo/OduvvPI6crmcr776Er3+v+nKpwaYHjs1AI5lXFB5O5IRnYpEJsW9hq95X9KdJ6NsAGXaVibm3wdok00/JFI7U3xRA8/m6JvpyQhMwc5VhcJRmamfQafHRbcAhUsKErmUsq0ro7uT/VRmPdem2X7uXNmT5NB4ypRZhZ2rCqVHfeJvRJF6PzHLMcVeemge3dOla4k6HUbAmzWzlfs0cpWCih1qWWyXG7seZG//Y06ePM7+/aYVo9euXWX79p/p129grn3S09PNf2s0mifXtITQtGlzOnToxOHDB6lSpSrvvtut0HQ9GyeZXdxkYfPXX3+g05nu19u3b3H79k1q1677pEGdyTYVsxYR8eiZ7axhDkXJSy+9ym+/7USjUSORSBg8eHiByVYoFJx/qyMA43v2LTC5IoVPkTprK1eu5Pjx4+h0OiQSCePHj6d27drZtt2yZQvvvPNOob6FliSmTv2cqKhIAKKjo1i2bHWR6FUoFJQrV46IiEhef709jRo1yZOcyMgIxo0bRVRUJL6+fkgkEoxGI6+++gZyuZyxY0dy+/YtWrduy6hRY2nb9mXWrv2ByEjTqJncXoEuXYtEJsG3xZNCxVKFjMrv1CE9KgWFswo7ZyUZsalEngw1x289xqWiJ/aejjw8eBej0UjZNpXN+2R2shxHotIeJZMeZRoZM+oMxF2NwEnhSFJ0Asn7UvFqUA6Vh0Oux+9R0xelm4q4q5Ekh8UTsuMyLoGe2ba1c1Vlmop9dsGEkDy7XkEieeIspKSkcPr0CXx8fDP9eH/44UfMnj0djUbNBx8MKrCAZ71ezx9//EZcXCyvv94+x0Utz8OePbu4dOkijRo14dVX37Cqj0QiYciQkQwZMjLf+i1Rtmw5+vcfxNatP+Ht7c2HH35c6DqfpXx5f/PfdnZ2+Pj45tJaeNq2fZndu38lISEeb28fWrZsLag9gYFBrF69gfDwMIKCquLkZHnUXKTkU2TOWnBwMPv37+enn35CIpFw/fp1xo8fz65du7Jtv2LFCjp16lRU5j0Xn9stB0DHZIEtMWE0GomLexK0HBMTA0BaWhpRUZGULVuu0KaVvv/+O+7cMcV87dixlY4dO+fpR3HPnt1mZzMyMoL+/QfRpEkzKlWqzNq1P9Cjza/QBiZ+m8ELL7xI8+YtqVatOmqpFmWAE+61TD8IEqkUmV1m50Uqz+xohf52DW1K5nI3LkGeKBztUDjaEdS9fqZ9h2JMKzTbeP0vW9sVTnbcDZkNRqhceSJ2riqirjxCm6GBaEi4GU1Q9/qoPBxylWXnouL8n58AJjlyBwUKZ+WTkT6VDNcgb/yaBZBwO5qY8w9QOCvxe6FirudWm6oh9UEiKk8HVJ6OubbNCaPRSOLtGEa/cASFs5IVIdmPkjZr9gKvvvoGR44cpEqVarzzjmkUSa1W8+mnwwgLM03zDh/+Ce3bm97wmzZtwbZtu9HpdKhUBVfOau3aH9i2bTMAf//9Bz/88CMqVd4dwWPHDvPNNwsBOHRoP+7uHjRunPtIoxB06/Y+3bq9L5j+Xr36IZPJePDgPm+88WZWZ+1od5zVWpLrrhXEvmcpW7YcK1eu5f79cCpUCMDRUXjnyNPTC09Pr0KR3fO33aY/xtvG75eIdUiMRbRsKDIykq5duzJ8+HBat26Nr68vGo2GCxcusHTpUoxGI6mpqSxYsICzZ88yffp0WrVqxXfffWe1jtjYFAyGwj2c+/fD0SxqicFgZIWsM15e3oWqz1ru3Qvh3j1T0GhgYBCenl6cP38OrVaDo6MjDRo0Qi5/Pt9co9EQGRmBnZ0SX98nD1yFQoZWa5qqunTpQiZHsUGDhri6umWSYzQaefToEenpafj5+WX7MAwPD+POnWDztr29PU2aNEMqlXL37h3a1TsFwLrdftSqVQdvb2/CwkJRy7S4v+afRV5OGA1Gri4/nmnaVGavIOi9elmmNx9zOfEsAHVcG+co98z6F0iPTqZq8914Ny7P9e9PZdrv90JFvBqUy1WWJimDw/NNI81+futw9HcjIyYV/VOLDZQe9lTqXMfqfHHaVA13fr6ALk0LUgkV36qJk7+bVX2fJvJUKNFn79O3QwRShZR/klviEuiFVCYl/u9wlHoFFSoE5Ng/OTmJf/89a952d3enXr0Gz23HsxiNRnQ6XbYj8OfO/UtS0pNVuU2aNMPRMbOzajQauXXrpnmEtmLFSjkeR2joPUJC7pq3AwODiizcoCTxStnT6PVGDkQ2E9qUEs3Tz+mnafD3n6hUKlr/LpZNLAikUgmenoXv4BfZyJqvry/Lli1jw4YNfPvtt6hUKj755BNiYmKYP38+vr6+LF++nD///JPBgwezbNkyFi5cWFTmWc3ixV9x5WogAFLpVVq2bGUTuZMqVqxknj5UqVTcuROMVmsaPUpNTSUmJjpTkllL6PV6zp37l4wMUzxRenoaFStW4uHDByQmJuDi4ka5cuWoVKkyycnJ5iDYCxfOU7NmLby9nwThh4WFmn/kHj16SNOmzbOM9JUrV57798PNq8fS09NJTU3F2dkZf/8K7DiUQHJyMr6+3nh55f2NUyKV4FW/HDHnHzw51nQtqfcTcauWdeEA5O6kPaZJ78erYCtiNBiRyqQY9AbzfpW3o0VZdi4q6nTYT/TZcOQOdvi1CCD63/uZYuvUcemE/n4dtyreeNTxs5gnLe1hoslRAzAYSbobmydnLe6qadRz3e7Ho6a3cboZnWMMXHR0FBkZGfj4+KJUKlGp7JHLFeh0JlucnbNfgPE8JCUlceHCOQwGA/b2DjRp0jRTjJaXl5fZWXNwcMx2ejUqKpJHj57EKN29ewcvL28cHLJOW3t7exMeHmZ2Dm3lRa24cSi6RbZOhEjRsLN6DVxdXRF2slfkeSkyZy00NBQnJye+/PJLAC5fvszAgQMZP348s2bNwsHBgcjISBo2bFhUJuWJ1NQU898Gg4Hhw0cXyA9PQfPrr9tYseJb83bfvh9Sv7715zY09B5Hjhwybzs4ONK27StMnToRMI2UvvdeT8LDQ0lLS+f69auAaaQiKiqKpk1f4I032uPi4sq0aZ+bnTWdTkfnzl0zBxz/x/LlS9m58xcA7O0dGDNmIm5ubjnaOHfuDO7EPn9qAr8XKiJRSIk+/d+qKwko3fMXJ5UUEoc6Lg2XQE9SHyZmctQ8avvhVN7NKjm+TSvg0/hJ0l2fphVIi0jOtIo1PSKZ9IhkjAYDXvWzVnbQa3Qk3Y1D7qBA6emIRCrB+N+I82OnMSMujZSweOy9nXAsl/tqzfTolEyje49JCUtAr9EhVcmo4BnA+P+mVbZt28LBg/tN5yUpiWXLVuPo6EhoaAh///0H3t4+dOjQOd8vOYMG9TWncElPT6Nmzdq8/fa7mdqcPn2C2NhYXnyxDc7OWasv7Nq1g+vXr2X6rF+/D6lUKTBbnXFxcYSEBBMYWAU3t9xXxpYU0tPTefAgnLJly2frxD4v3t7ORNvQAoOSSk7nee7cGQJYI5JfisxZu3nzJlu2bGHZsmXY2dlRqVIlXFxcmD17NgcOHMDJyYnx48eb80ZJJBLzg9iW6NfvQ5oceguMsLHsApt01MC0RDsmJoabN6/TsmWr53LUAPz8yuDnV9a8Mqp+/YZZlpQfOXKQQ4f2Z+kbHR3FmjUrOXBgL99++z3Nm7c051/z8ytDpUqB3LsXQlJSIrVq1TH/aD8OLo+OjuTNN9/Gzc0No9HIihVLaVd1Cc7OznjUOZ7nuCaDTs+DA3dIj0zGubIHZV6sRHp0Ci6VPbH3yfxDrtfo0WdoUTgrORizB4B23m+SEZOKVCHDzvWJDfHXIzn8/SAAqtaciEedzDF7dm72pMekkhIWz0Xvs8hUCtp5Zx/zdeDbDwBo1X85EcfvkRQSh0Hz3yjE47Qi/5H+bNoRwKg3EPLrFXNKEt/mAQR0rEXSnVjsvRxxr+mLOjGdu9suYfhvdKNC+xq4VMq5BNjTCxjmjTDFJ45bEoidqyrbxQ3nzz+Z7oyOjuL+/XCqVatOQEAlBg4ckqOe5+XZ54NUmtWWpk1zT8HQrt0r7Nq1nQcP7gPw+uvtc3TUADw8PPDwsL04tcIiNjaG0aOHERUViZeXN19/vTTTqHmeOPIuLmodSfU2FIyRIs9Fn12/mv4QY9aKFUXmrL322mvcuXOHLl264ODggNFoZNy4cZw5c4aePXtib2+Pl5cXUVFRADRu3JhBgwbx448/PndJnMKkadMWRP5ZHoymQFpbRSaT5WslmFKpZMGCJezb9zeenl60a/cKkZERbNu2mYSEeFxcXPH2zjwN5OvrR2JiAhkZppWK9+7dJTk5mddfb0+ZMmV59OgBzZq9wJEjB1myZAFGo5HGjZsxbdpspFIpdnZ29O07IJPM48ePsnPndpzby4F0FCHb6datR56OKfbiIxJvmXKhxZ5/SIU3a+BZr2yWdmmRyYTuvoZercO5ojveL/qBRMKDA8HEX4sECZRtHYhHbZNTlnI/EUfHS4Ap0a6dqwqFyg5thgaVlyP2vk7c3XYJo94AgXpca+Y8feYdaBopfHDwDskhWTPdyxwU6NO0IAHXoKzTwZpkdabccUl3Y/FuVB6np0bP0iOSzY4aQEp4Qq7OmtLNnjKtKhN78SE3or1QONrhWa8sXvXLZvvdrFevIefOmRw2T0+vTKsDc0Ov17NgwRzOnDlJzZp1eO21/3Hnzm0aNWpCrVp1srT/5JNxfPbZp2i1WipXDqJDh05W6XkaZ2dnVqxYC2Sg0UjF0jvPcOjQfvPCn5iYaA4c2Jf/xQteLXKtOiJSuISWMT3zrA+KEbEFijR1x+DBgxk8eHCmz1555ZVs286dO7coTMoTa5VdANvKs1YYeHh40rXrkwezn18Zli1bTVzcQzw8yqDT6Th8+CBRUZH4+PiyYME3bNmyid27TVnAfX39OHBgL6+++gZ169Y3J8Pds2e3eQT17NlTREdH5biC9PG084Y9pv3vvZeWbbtn0aVrSQ6NR+mmwsHPNPqp12SuI2pQZ19XNOb8A/T/7Uu+F0+lhnVQeThw/dp/iwaMEHPhAR61/dAkZaBL0+Dn92SUIOFmNL5BZTHoDbi3K0/8tUiTowb43fHDy7Uc5BCXXvuNAwAEb8n6Y+ZcyYPkuyYHTq5S4FAm67SewskOuZMduv9Wu9r7Zm1j7+uMRC7FqDPZZGkaFMCzbhk865bhcUGxMi/m3LZbt/fx8fElKiqStm1fyhLU/zSXLl3g6tXL1K/fkEePHnLgwF7ANH35uCzZzz9v4v/t3Xd8U/X6B/BP9m66Fy0UWvYeopfhABFEcYCIgHBBHHBFEQeggoICPwdy9QrivngBQRDBiSJL9kZWoVBG6YA2TdukSdrM8/vjlNDQZjRtcpL2eb9evIDk5Pv95jknJ0/Oec73fPjhJ8jIaOPy2o4dO2PDhk2wWCz1SrIEAgHi4hLp1Fwt4uJcr+SMj79xVE2jKcI333wFu92Gxx+fiGbNUnxrtP3LqKBYc+avW9gjwzQdbnihSXFJnURGRqJ161TnF9unn/4X+fl5aNYsBTKZDJMnT0W7du3x228/4/Tpk/jssyXYtu1PfPTRMudRmJSUVOeM9SpVhMcZ7isqXE/1+XLa2W624cL3x2HVswlPyqA2iGwTh5guSdBf0MKiq4SiWQQi0mu/UEEoq3ZlIQ8QSoXgiwQudxEQqSSwlJtxYe1xZ2J3nTFPBzEjgjJaBR6PB3miCjwB35mw+ZIcxXZLRt7W8wDDJmmJfdJQdPCK83lbhRUVRQaomrvWTfGFArR6uDNKTrN3N4jpXPP3syRShlbDO6M8h61ZU7Vo+NqrO+8c4HWZEyf+xquvvgSHw4FVq77Bo4+OrXU5u92Os2fP1EjWADbRoqNhgdO//x144omncfToYXTt2h133jnQ+dyCBW8iK+ssAHby2y+/XMHVMAlp9ChZ88MbcrZw3xwi86xxSSaTISPjxq2g+Hw+BgwYhJUrlzsfO38+CwZDuTPRevbZFxARoYZOV4rhwx/1+GV7fSqWxS+y03pkV3qfsqJCY3AmagB7KjCyTRxECglaj+0Bu9nmceqLhNtawG62waKrRHSnROy2bQW0QJ9hd6LoUC74IgES+6bBmKdzJmrZ2YsBABkZLwIAO8daFWmMAq1GdIbhShmOxR1EoawEAzGs1r63/oe9Z+LA57+EPFkNh9kGSYwcPB4PsngldOfZOfT4Qj4kUbUXe4sjpEj8R5rHGMnilD7doupm09qyczR9lFX7+Ovi5Mnjzrozu90OuVyO3r3/gcOHD6B58zTk5ubAbrdDKpU2yDQfxD8jR452OcJ+XUHBjator14tgMPh8O2OCX89wNasdf+uIYdJfDRxww/sP6hmLaxQsuaHy6XsFXh0zt+9rl27O6dEaNUqw+UG7QqFApMnT/WpncGD78Pevbtx8HQhmiWnYNADtU9MW50kSga+SOCsy5LF30hKeDye1znKBBIhUu9p6/x/kp6tuZJFqFxu6ySNUzqvtFSpDjpvlM4T8iGPdD31dz05StEXe+w7qf1557/FKgmgujH3W0zXZPCFAphLTVC3iWOfD7JMne9z2nnTrVsPfPvt/+BwOCAUitC9e0888sgoMAwDHo+Hc+eycO7cGXTp0p3mMwtBDzzwMFat+gYAMGzYQ77f2iphIKzGSu/LkYA434KdR7Cel4mQIKNkzQ//kzwEoPHXrNXH1KnT0bp1W5hMRgwefJ/fF4nI5XK8//5HsNvtPk/1IFJI0PLhTijL0kASKXPe3cBfHSK61fq4NFqOtIc6ofxSCVLjj0HRTA3TtfaQRstRcbzmxQGe2nI+P+gvt8/xeDznRQ1c+fNatwZrq2PHzvjgg4+RmXkKXbp0R3p6BgA4t5U2bdqiTZu2npogHHr88Qno06cfbDZ73dZTu2lUs8ah3T3Y+zf35XgcpG4oWSMBIRAIMHRo/U+VVW+vLvw9zVdXiqQIKJJu1NFdv6qywt0LiIt27TqgXTvvN6EnoalVqwyuh0BIk0DJmh8WRH0GANBTzVrQqPXDAQC6iB+C3veWoh8BAHfHP+h+mcXPsMu8+Fm92vK1Ha682I4d/+Kz7mNBiEfb74XaYoOuR/A/ywR4ZVvV3JhUsxZWKFnzAxNZ+3QjJHDMYu+1aoGSImvpfZlupxukLV/b4crfpd5jQYhHzYbBbKCaNa7IR7HzVNIaCC+UrPmh/NHlXA+hyamUPsVZ3+1UNW+NVWOZAbsbpC1f2+HKtkLvsSDEozb/QiXVrHGm8gnu9qXEfz5evkMIIYQQQrhAyZofYv7bHDH/pakEgkmtfwBq/QOc9L25cAM2F27wvMz7/8Lm973f99JbW762w5VX2m/AK+09x4IQj7beDfURbj7LBFCPeADqERT/cEOnQf1gUQ3heghNjlk8nLO+0xStvS/T+1iDtOVrO1w5qPUeC0I8ajEK5nKqmOKK+SHu9qXEf5Ss+aH8kc+5HkKTUymdwFnfbZSdvC9zx74GacvXdrjyV5H3WBDiUcZTVLPGocpxE7geAvEDnQYlhBBCCAlhlKz5IWZ5CmKWp3A9jCZFrRsKtW4oJ33/Xrgevxeu97zMu1Px+7veb6HlrS1f2+HKrA7rMauD51gQ4tGWO6E+zM1nmQDqh4ZC/RDFP9zQaVA/mNUPcT2EJqdSMrbWx+06C3Q7C2p9rqEkK9m7wOqy3PeTHLuZXaZqLLYys8v/fW3r5nZCzeaSqvGfujE+u84CxHA1IhJ2Wk1AJdWscabysdr3pSS08RiGYbgeREPRag1wOBrN2wlZcXEqaEKg5uTbb/+H3NwcrodRK52uDACgVkf63YZIJIC16mb0oS41tQXGjBnP9TD8FirbdFNAsQ4OinNw8Pk8xMQE/taGdGTNH2YT+7dEzu04mhLGyv7NEzkfClZyYLWzfYsEIvfLVA1P5H4Rn9qq3k5I7mxrWQ+E1InDyv7h0zbECV93ViSkULLmh5jVbQAA2gl5HI+k6VDr2XtR6tS/Bb3vkT+zfW98yH3fI0fK2GU2er6Fu7e2fG2HK1yuB9JIbBsEtdUOXS/ahrigHln1Gd5I8Q8nlKz5wRz5CNdDaHIqpdydYhvb3nvfY8daG6QtX9vhCpfrgTQS6U+isjw0f4w0BZVj6TMcjqhmjdRZSJ6ea4QozsFDsQ4einVwUJyDI1g1azR1hz/Ki9k/JHgYE/uHAyarCSar575NJvZPfdvytR3OcLgeSCNhMwF22oY4E/I7GVIbOg3qh5j13QBQzVowqfXsqWcuaqXG/Mr27almbcwY32rNvLXlaztc4XI9kEZix1CqWeOQekzVZ5hq1sIKJWt+qIwZw/UQmpxK6STO+p7Q0XvfEyb4VmvmrS1f2+EKl+uBNBKtp6BSH5o/RpqCygn0GQ5HVLNG6oxqIYKD4hw8FOvgoVgHB8U5OKhmLYTxS3LBL8nlehhNCs+hA8+h46RvvVkHvdlz33o9+6e+bfnaDle4XA+kkbDowLPSNsQVnl4Hnp7iH27oNKgfon76BwCqWQumiPLRALiplRq/ie3bU83a+PG+1Zp5a8vXdrjC5XogjcTOBxFBNWuciRhf9RmmmrWwQsmaHyriJ3I9hCanQjqZs76f7Oy97yef9K3WzFtbvrbDFS7XA2kk2j6PCl1o/hhpCiqepM9wOKKaNVJnVAsRHBTn4KFYBw/FOjgozsFBNWshjF94HvzC81wPo0nhObTgObSc9K2t0EJb4blvrZYHrZZX77Z8bYcrXK4H0khUFoNnoW2IKzytFjwtxT/c0GlQP0RtugsA1awFU0T5OADc1EpN+oPt21PN2qRJUnYZL7Vm3trytR2ucLkeSCOx+xGqWeNQxKSqzzDVrIUVStb8UJFE5/yDrUL2HGd9T+nmve8pUywN0pav7XCFy/VAGol2L6GC5lnjTMUU+gyHI6pZI3VGtRDBQXEOHop18FCsg4PiHBxUsxbC+HmnwM87xfUwmhSeoxA8RyEnfReaClFo8tx3YSEPhYXea828teVrO1zhcj2QRqLiGnhm2oa4wissBK+Q4h9u6DSoH6K2DAFANWvBFFHOTpfCRa3UM5vZvj3VrD3zjG+1Zt7a8rUdrnC5HkgjsecxqlnjUMQzVZ9hqlkLK5Ss+cGU+jzXQ2hyTLLpnPX9fA/vfT//vG+1Zt7a8rUdrnC5Hkgj0WEWTDoT16NoskzP02c4HFHNGqkzqoUIDopz8FCsg4diHRwU5+CgmrUQJrx8CMLLh7geRpPCt+eBb+fmtHN+eR7yyz33nZ/PQ36+91ozb2352g5XuFwPpJEw5oJfSdsQV/j5eeDnU/zDDZ0G9YN6x8MAqGYtmFSGpwFwUyv17Fa2b081a88+61utmbe2fG2HK1yuB9JI7BsHFdWscUb1bNVnmGrWwgola34wtXiJ6yE0OSbZK5z1Pb2n976nT/et1sxbW762wxUu1wNpJDrNhqmMata4YppOn+FwRDVrpM6oFiI4KM7BQ7EOHop1cFCcgyNYNWt0ZM0PwvO7AAC21v05HknTwbdfAgA4BC3r/Npvv/0fcnNz/O67jFcGAIhkIt0vUxbNLhNZ4ndbOl0Z9PpYqFQRiIwsgUgkgNVq92fIAROtKgMAlJRH1ul1qaktMGbM+IYfEAk/hovgmwxwyOv+WSb1x79ctS9No/iHE0rW/KDeMxoAoG1NNWvBojI8C8C/Wqnc3BxcOncWsQKBX33/lsEm58MuuE/Of9v1NrtM/zl+t1Vis2Hn3ucg4vG8tsOVp55ix7/4C99/qBTbQyvhJBzb/wTVrHFI9ULVvpRq1sIKJWt+MKa/zvUQmhyT/LV6vT5WIMCDqki/XttKdwsAoLOH17fq+YvXZby19WN5GW7r8B36yZVe2+FK6V52/HWJ5Y/lZYEZDAlPnedRzRqHTDPqty8l3KBkzQ+V/adwPYQmxyrqx1nfnSsTvS+TkNUgbSXHng7ZRA0ASq54jwUhHiXcASufaqm4Yu3D3b6U+I/mWfODKPNPiDL/5HoYTYrAfh4C+3lO+s4T6ZAn0nleRpeIPJ33RMZbW2XlyT61wxVFtA6KaM+xIMQjfRYERm4+ywQQZJ+HIJviH24oWfNDxMGJiDg4kethNClKwzQoDdM46XtJ3F4sidvreZkD/8SSA/+sd1u7/p7iUztc6XTvXnS613MsCPHo4DNQnuHms0wA5cvToHyZ4h9u6DSoHwxt3uJ6CE2OUf4mZ32P1/b0vky39Q3S1i0dVqK/XOVTW1zI2uE9FoR41HUhjFSzxhnja9ztS4n/KFnzg7nPE1wPocmxiW7lrO8O5njvy8RnN0hbiTFZ6BDCNWtl+d5jQYhHcX1gA9WsccXWm7t9KfEfnQb1g/jEzxCf+JnrYTQpAlsmBLZMTvq+LC7FZXGp52VKm+FyabN6t1Wib+5TO1xRxpVCGec5FoR4VHYKAgM3n2UCCM5kQnCG4h9uKFnzg+roFKiO0hWhwaQ0vgyl8WVO+v40dj8+jd3veZlDj+PTQ4/Xu609x5/yqR2udLxnPzre4zkWhHh0eCqUZ7n5LBNA+erLUL5K8Q83dBrUD4YO73I9hFrt2bMTANC37+0cj6ThGRVvc9b3E9pbvC/TY22DtHVrp29wRwjXrJ3d5j0WhHjU/X0YS41cjyKkBXJfbnyTu30p8R8la34w9x7L9RBqtXv3XwAaZ7JmE3JX2N7GHOt9mdhLDdJWfFQ22oRwzZruqvdYEOJRzC2wOahmzZNA7stt3ekioXBEp0H9ID66HuKjvl39RxqGwHYCAtsJl8cYhoHdbselSxdRVlYWsL4viLW4INZ6XqYkFRdKUuvdVnFZmk/tcEUVr4Uq3nMsCPGo9G8Iyk94X44EhODkCQhOUvzDDR1Z84PqBDtHjbbHCI5H0nQojbMAsPcGLS0twRtvzMLFixegVkeitLQEUqkU8+b9H7p06dbgfX8RexAAMCtnIAAgUiSuuczhMQCAd+7xfIr8elvvFNzr8riDYQAA+05Ownmh0G07VocDfxRehcZsRs+oaHRRR/r+RhpAh0Hs+A+sutfLkqQ2DMOAx+NxPQxuHXkBSro3KGeUc6r2pXRv0LBCyZofyrt8xPUQGh2LxYL9+/dAoVCiZ8+adVEGxTvOf3///XfIrpqBu7S0BABQWVmJjRvXByRZe6q4N46WlWLxZfaWUvfEJ6JfbJzrMr2+9bmtm+3QFGKHpggCgQDd2n+Ge9VRbl+/XVOEg1Xv+ZLJiH3aYqQrlRgQlwB+EJKAzD9rjp94d+VKDubOfQ0aTRGGD38UEyc+xfWQuNPzQxioZo0zhrff8b4QCTmUrPnBQkfUUFKixfffr4FAIMSjj46BSuV/UTzDMJgzZyZOnPgbADB69DiMH+86l51d2MX5b6Gw9s02Ls41gSoqKsSxY0eg1RbDaDKhTCJHpLjmUTFv0i0x+DbnqvP/fxUX1UjW0qNzfW6rujKrBds0RQAAh92OCsdRpEe3cft6vdXi8v/8ygrkV1YgQihC7+gYN69qOOVFge+jMfrmm69w9WoBAGDt2m8xYMAgtGiRxu2guBLVDXYb1axxxd65i/eFSMihZM0PkoOrAITuhQbBMHv2DFy6dBEAcOHCeSxcuMjvtnS6MmeiBgDr1q1Gjx690KlTtQTNdgQAe6HBI488hmPHDuP8+XPO57t164EJE24crdBoNHjuuaeh1+udjy0tLcVTaemIl0rrNL5zkmI4os2Alk30lEIhSi0W5FWYcFxXBimfjwxhX8iFQigVmTipL0O8RIrukTWPkJ2TFAO4caEBHzzwADBVz5cb2uNccXO3Fyz0jo5BlqEcZofD5XGd1Vqn9+QvdRI7fl8vNLA4HCirqADKA//lbLFYcOTIQahUanTq1Dng/V23YcM6bNy4HklJyZgx43VE15I08/mu5cECQd3Khe12O44dOwKZTIaOHYP33gJCewhCnRE2NRW6c0F4rGpfShcahBVK1vygzJwJoGkla1ptMebNex05OZcxbNgwZ6IGABcu+DZ7vzsqVQQSE5Nw7Rp79Mpms+GDD97FsmVf4ptvvoZGU4S5T2yHQqGETv0bVCoVBg++zyVZa9euA2QymfP/p04dd0nUAMDscOBMud5tsqYxV2JjQR50Vht6RUXhzrgEAMDXMYdQorIgcWcrdnwOBv/OznJ57S/ZwxErFiMybQIsVYmU2WHHbdGuSc3XMYcA3KhZixCJcF9iMrZriuDg83D+0jR8XShyW7PWXK7ACxltUWSuxE8F+dBaLVAIhLUmhv7yVFfVbgA7/v0rh+DHq/k4oStDklSGMaktoLjpiKeNceC/ly8iv7ICKC7Gn3/+jkGDhjTYOKtzOBx4441ZOH78GABg0qTJeOSRUQHpq7orV3Lw+eefAGCP5P73v1/gpZdmobDwGnbt2oHk5BT06dMPTzzxNK5eLUBRUSFGjHgUKSnN69TPggVzsW/fbgC1H3kOK8degaKqZk2n0+HixWy0bNkKkQ24DRP3FPPmAKCatXAT8GTt888/x969e2Gz2cDj8TBz5kx06tQp0N0GVHmPZVwPoQa73Q6Npgg8Hg8Oh6PGL3l3Ll++hC1b/kBiYhKGDh3m9nWrV69wJkfr168Hn8+Hoyopuf32O+s1doFAgHfeWYxJkx6H3W4HAFitFnz++SfYtOkXAMC0azzMn/8mrqdjvXr1RkSEGnq9DhKJFH379gfAHl3RaosRHR0LHo8HhmFc+kqslqhpLWYUVVYiVa6AUijExoJ85FZUAAC2aYpgdzAYmJCIycW3YV3uFecNcnS2mkex2qQtQt+YOGzV3TjidUqnQ6RIjLZKlTP5mVx8W43X9o6OQe/oGGzUl4JvWwwlgFO6MnSq5eIBndWKcwY9ZHwh+sfGQcLnI12pglQg8BpndxiGwY7iIlwwGFBht0NrMaOZTI4u6kgcKS1BpFiMB5OaQSEU4vRmdvznDeU4WsbeySC3woTdWg0GJyS5tFtsNrOJWpWtWzcHLFnTarXORA0Atm//02uy5nA4oNVqoVarnY/l5eVi8eJ3odfrMX78RNx++10e26isrKzxf71eh+nT/4XSUjY+zz47Dfff/xCWLPm8rm8LAGA0Gp2JGgB8//0aPPzwyHqVHnCq1xIYSo0oLLyGF174F8rKShERoca//70Uycmhe/eOxsLwf/6fBSHcCWiylp2djW3btmH16tXg8Xg4c+YMZs6ciZ9++imQ3QacpcswrodQw3vvLcDp06cAAB9/vBjTpnmfobqsrAyvvDINBgObhuj1OowZM77WZW8+0uKodhruttv6+jtsp4SEREyb9jKWLPk3+Hw+/vWvafjppx+cz2de4ONaaRxaRt5Y/pNPvsTZs5lo1SoDSUnJ0Gg0eOWV51FYeA0KhcKZqPF4PETJZBgQFYO2qggAwBWTEctzLsHGMFAJhZjcMgNGu81lTH9pNcg06DG+eUtk2GNwDOyXLx9A9ZOQPACDU8vRXsXDIaMQehvbzpUKE77NzUHvqGjcn8R+CaVZ3B89uFZeDiOTByOAdflArESCROmNo4VGmw2fXcqGwXZjnAIeDxNatEQLucJjfHdoinBSX4ZkqQzDkppBXC0pP6nXYXtV3dx1uRUm5FawN9u+Zq6ElM/H8GapMGjY8edXFLosb7S5xg4AIoQiSPl8VFZtK2lprTyOsT7UajViYmKh1bKnaVu2TPe4vMViwezZM3Dy5HHExsbhiy8+h1QaiSVL/o0zZ04DAN5////Qs+ctUCiUbttp06Ythgy5D7///iuio2MwZsx4XL58yZmoAcCxY0dx//0P+f3eZDKZy48jq9WKp58ej8WLlyIpKdnvdjkT2Ql2azn2bF6LsqqEX6/XYdeuHRg1qumcreCKvX0HrodA/MBjbj700IAKCwsxcuRIPPfcc7j99tuRkJAAi8WCSZMmYe7cuUhPT8fq1atRXFyMhx9+GC+99BISExORm5uLzp07Y968eXXqT6s1wOEI2Ntxkuz9GkDo3NCdYRjcf//dzp25QCBE//7eJ1PU6XQ4VlW/AAAxMTHo3LlrrcuazWacOnUSRqMBCoUC5dVqkHr27AVVVRJUX9UTrKKiQmRmZgJg0Kc7DxkZGbiicT8H2aVLF5GTc7nW5zISEjA+5sZNyDddK8C+khvzhQ1PToGQx8Pa/JoXCjRvLkDv6GgU5bFJSbRIjL0lxTBWHQUEgAGqexEvkSI16gyyDOX46Wq+8zmlQIgZbdsDADIlbFJU2w3dP8q5iJxCNslQKk9gTGoLtKsW13PleqzMzanxur4xsRickIS8ChN+LMhHhd2G3lExuD2O7eOi0YDlOTdq4O6Ki8ddVad4AWB3sQabi67VGjdnDGRy9I+NQ8+2Jgh5fCw/ZHEeWQOAKJEY01u3rfG6gooKrC4sAF8iQefOXX0+4usPk8mEvLxciEQiNG/eAgIPRxs1miLnjxsASE1NRXp6axw8uB8mk8n5eJ8+/SD24aIUu90OPp8PHo8Hi8WCQ4cOwFpVR9i6dRs0a5ZSj3cGHD/+t/PK5+vS0loiLa1lvdrlQrr6Kmw2B47kSHDq1I35vjp27IS4uJqfi6boypUcqNVqLFz4gd9txMWpoNHUrBUVHjwAgG7o3lD4fB5iYtz/oGsoAT2ylpCQgGXLlmHlypVYunQppFIppk+f7nb5y5cv46uvvoJMJsPdd98NjUZT4wq/UKA89waA0EnWeDweWrdug6ysswDg8+kRhUIBmUyGiqpTf7Gx7mMtkUjQs2cvAMDVq/nIyrpRs6XX6xssWat+BC8+PgFKpQoWiwXPj94EHq8Qy359zO1r3X2pKhRKiG6qp0qQ3DgdygcQL5EiWSZDvESKrZpCnCm/Ue+2v8V5HBcI8Eb53XAwwKcXs2GH64+CdScehUrE1pqlyRVQCoQwVB2pS65WS/e/GDY5vnmeNQCIVSiwL/9ZMABu7zINLRWuR8sSpFJI+PwaFxckVx19W5t3BWVVCcIWTSGEfD76xMSiolpSCaDG/7tGRuJQaQlKrRaI+XzwGAYpcjmkfAFOl+sh5PFwpcKEVbk5GDQhG4lSKVJO3eqSrBmsVpzUleFwaQliJRIMTkiCmM9HskyG5KgomCXSgCZqACCXy9GmTc2EsTZCocjl/zweDwaDwSVRi42N9ZioMQyDK1dyUFZWhpiYGKSksD8kxGIxevToBY2mCDKZvEH2YZ06dUZW1lkUFd04oimt44Uy9cEwDBiGaZB1ODjhLzAMkGN8DG3atEVpaQkiI6MoUatSUJCPa9euwWIxB6R9xUL2IAjVrIWXgCZrOTk5UCqV+L//+z8AwMmTJ/HUU0+57LyqH9hr3rw5lEo2Q42Li4PZHJiNtb70vf/L9RBqmDfvHcyYMQ08Hg+LFn3sjKM3er0OBw7sQ1JSssvVlwB7qmjVqm9w5UoOBg0ajD592Lqw7ds34b333nMuN3DgYDz44PCGezO1ENgnAwBmdmrtdhm73Y4vvvgEmZmnceut/8CgQUNgMJRj7dpvYbjIXgShNZuxXVMIPo+Hu+MSUGK1oL0qwplQxUulGJ3aAr9fu4rjujLESiQQnEiF0WbHJ8Zs9I2NrZGoKQRCjL7tG5jsNuzTFmO7ptB56q+dUoURzW4cDZyq6eN2/EqJBINu+RKdRWJ0j0uH6KYvRrVIjElprXBKrwPDsFdapshl6FxV22a6KQm7aDSgT0ws2ipVaClX4JLJCLVIVOOiB5VQhGfTW6PMYkGUWOzSr95qxZq8K8irOiX65pcpeDy1BXpFReN4WSlyqh5vGxGB9fm5cICd/03E42NIIlvDJufzkdC8BWbOnOP2vV+3efMm/PzzBiQlJeO5515ssB8BtXnvvQXYvn0LAKC8vBz33fcgDh8+6Hy+b987MHnyVLev37LlD/z113YA7Hx/48ZNRO/e/wjYeAHgxx9/wOHDB9CpU5egnTLct2833ntvAWw2G6ZMeR5Dh9avDCROMgklJUbMHO7+s9xUHTiwD3PnvgYAMJmM2LXrL/Tvf0eD9mFYRPOEhqOAJmtZWVn47rvvsGzZMojFYrRs2RIRERGIjIyERqNBeno6MjMzkZDAnpIJl5m9rR0GcT2EGtRqNVq1un4KzfdDshERardF38uXf4ENG74HAOzfvwcTJjyJUaPG4oEHHsCWLdvw999H0bVrDwwePLT+b8CL3EI5jh8/htatgYyM2nfyAoEAkyc/5/JYfHyCy3a14spllFTNVZYqk+MpN7VNQxKTMCQxCaf0OuTkGSGFCHYw0FmszqNmfAB3xMajV3Q0ck0X8VPhFdx8Et7scOC0Xof2EWrIBAKkWNW1decUq76G3qpIuLsTXKJU5lLHVt3dcQn4rfDGfHCtqmqthHw+JrRoCYPdBrlACEEtnzMxn1/rVbIRIhESpVJnslZUpAATEQMIgCfSWiHbaACvarSn9Drn68qsFpRZLIgQiWCyWHDm4H6MGTMcEyc+7XZ7y8/Pw0cfLYLD4UB29nkolSo8//xLtS7bEKrP11daWgqxWIKIiAjo9XoIBALceqvnxKuw0PXU8bVrnk8lN4QHHxzu8sNo166/sHv3DqSnt8Ejj4wKyNHLTz9d4ryQYtmyjzF48FCPp5i9imgLu5nmWatN/k1lGAUFeQ3eh93N/pOEtoAma/fccw8uXLiARx55BHK5HAzDYMaMGRCJRJg3bx6Sk5MRHx9+h76lu9irQSv7T+F4JIGVl+e64/juu28xatRYSKVSLFjwPgoK8iGXywN+OqagIB9ffjwK5spKLF0aiYULF/l1pwIHw6C02qSyJT6cZoiXSGCMMcABBiqtCqlyOe5JSMQlkxEJEikSqt77titp0BtjoVIddXn9JZMRl0xG7CkpxuSWGTgrZ2vWOlcm1v5eizvipEmJzglZtT7vyW0xsWilUOK0Xod4qRQdI24khjweD6qbTv1Vd7WiAuvyc1Fht+OehESXqUDuTUiCQiBAuc2GB3vYESPWoORKInv6XcmecrcxDqTJFbhsMkLE4+Gi0YDF2VlopVCi0GqByWKByWTCRx8tQp8+/aFQ1LwgQq/Xu1y4oq+W/AVChw6d8OefvwNgi/i7deuBjz/+HMePH0OrVhlIT8/w+PoBAwbh119/QmlpCRISEtGvX8MeAfHm3LksvPPOW3A4HNi5cwdkMimGDXu4wfuRSCTOf4tEovr/qC78C6IyE6zR/eo5suAqKirE6tUrwOfzMXbsP2udT6+++va9Hd9//x1KS0sgEonQv/+dDd6HaC97ZbG1T3jFv6kL+NQdU6ZMwZQpNZOaO+6ouWNbu3Ztrf8ONYoLCwA0/mRtyJD7cejQAef/o6Ojnf9euvRD/PLLjxAKhXjllde8TnFQHydO/I0J97Hzuj2zQIVDh/b7lazxeTzcEhXtvF2TLzP+x0uksHXRwmizY/T5trglKho8Hq/GPTlP50xEicWCtm2fgRBAn5g4nDXoUVR1Kl9jNqPEYsGqFHZ6idpq1gDgyJnHkOPh3qBexyuV1nnSXwD45VoBiquS1x8L8tBeFeGcDkTE52NgPJtc3jpwE4Ca9wYV8vj4Z4uW0JgrsatYg5NVidZFowGSakewHA6HS0JWXdu27dC3b3/s2bMLSqUKI0eOrvP7qIshQ+6DVCrF5csXMWzYUMTEsKdtfZ1eJCkpGZ9//g3y83ORmtoCcrk8kMOtoaAgzyWWN/+4aijTp8/Ehx++B4vFiilTptb/6N3JNyG32qGLDq+aqTfffA2XL1+fCDwbH374SYP3kZCQiE8//RoLF86DQqEIyFQm8vcWAqCatXBDk+L6Qdd3NddDCIo+ffrh9dfnYdWqb6BUKvGvfz0PACgpKcEvv/wIgJ3Ads2alQFN1lq3bosFC9Jht7E1We3adfS7rfuTmqF7ZBQEPJ7b04k3m6Vlf1gkRbu/cOON/v/DKb0ONmEMOqsjkSKTwwGgyKwBAKiEQkSKRJhW5PnX7B09luBuReDqtNyxV6sdZYAap3OvO/Gr+/Ffj6la5HoEL0GlwlWDAQwDPPHE024vgOHz+Xj99XkoLtZApVJB6uP6qY877xwIYKDbK+e8USqVaFt1pW+w9ejRC4mJybh2rQBSqRQDBgSmPKN9+w747LPlDdfgbV+jXGtouPaCJC/vivPfublXPCxZPxERakRFBW6C4PIPlwasbRI4lKz5wda6P9dDCJp+/W5Hv36u04DI5XKXq0ijoqJre2mDSU/PwNTpS3Dw4H60b98Rfep5+L6ZrG5HQJJs3q+uTYooRlIEANyY9+ru+AREikTQWa3oGRUFiUDgta0IRSGSVMG/sObexCSsyb2CSocd98QnQuamJqmizHss7oiLR7nNhiJzJXpERuGaSIhWXbvjlVde93pUhsfj0VWBPoqIUGPJks9w7lwWUlJSwyduylZwVIRfzdrgwUPx66/sHKFDhtzH8Wj85wjD6V4IJWt+kW3/NwCg4i7305A0ZlKpFG+8MR+rVn0DlUqFKVOmBbzPHm1L0KNtG1jFwa+zOCZjb8DdvcL9BKTHrrITTXZPynQ+xufxapxq9dZWXlEXHDMoXdoJhhZyBWa2bQ8Hw4DvoSYpJo0dv/ay+1hI+AKXK2B/LC8DUPP+mKT+FAoluofbPR6vbWFr1mICdzQ+EKZOnY477xwIPp+PDh3C9y48oqormK13hFf8mzpK1vwgz2EnKqxA00zWAPbG6d269Qhaf/KK9wEAOnHwdzDfRR0H4DlZ++4kO52BtyTLW1vHskYiVygMerJ2nadEDQAy+rLj95SsEeLRqflszVqYJWsAakxvFI7k/67al1KyFlYoWfOD7s4NXA+hySlX+ndfxYbwUqH3u0G81PeLBmnrrp4f4h6l5+k9uHT8J++xIMSjf6xAeUn41aw1FuVLuduXEv9RsuYHW9otXA+hVsGeOiCYHIL63a6nPuLsnu+7CQBxihKvy/jSllKuRZzC7nEZLlWWe48FIR4pUuEwhV/NWjAFcl/uqOetzwg3KFnzg2wrO3t/xcAZHI/EVd++jfeoh8jyJwDAKg7+hMSHZezElL0q3O/kDuezNSy9mp1yu4wvbeUWdsdhvcJrO1yJbcWOv/gi7fCJnwp+h0hngjU29CYXDxWB3JeLtlXtSwN09TAJDErW/CDP/Q8AoAKhlaw1ZvIK9qIOHQfJ2vdRJwF4Tta+P81eHeYtyfLW1t/nhiNPKAzZZC39H+z4KVkjfst8h61Zo2SNE/L/VO1LKVkLK5Ss+aH07t+5HkKTo1dxdz/WGYXeT0nM6L+sQdoaeMsHGKwM/jxrvjq2sfGeaidB0ncN9GE4z1pjof8s9O5tTbyjZM0PjpTwvWw7XDH8BM76jrZ7n5ctWqZvkLbk0jJEB34uWL9ZjMGdpZ80QrJEMBKqWeMKk8DdvpT4jyY+8oP8j/mQ/zGf62E0KWLLJogtmzjp+4A8Fwfknm/lcyC3Kw7kdq13WzlXe/nUDlfiM3IRnxGY2xqRJiLvZ4g13HyWCSD+YxPEf1D8ww0dWfOD7OqnAAATZnM8kqZDVvExAMAirv2emoG0IZKtH7vVlOp+mTPs/SRvTT1er7ZOZD+IAqHQaztcaXkrO/6ibPexIMSjsx9AZrXDEhf8zzIBZMuq9qWDKf7hhJI1P5Teu53rITQ5etUKzvp+9Zr3ySNfvd23++15a2tQ7/cwJITnWTv6A02kSeqp3/dUs8Yh/Vfc7UuJ/yhZ84MjoTXXQ2hyGH6M94UCRO2Qel9G6tuXj7e2pJJyqKW135czFFgrvMeCEI+ksWDEEq5H0WQxMdztS4n/KFnzg/y3OQAA09C3OR5J0yE2szdQtkge8Ov1xXa78x6VdXVJzd4Ps6XO/S2WLhXcxi6TvN/vtoptNuRf/QcuCQRe2+FK947s+I+d9v12U8V2O7zf/p00Gbk/QKyrgCXBv88yqR/xL1X70vsp/uGEkjU/yIrYS59NoGQtWGSVbJ2gP8laamqLevV9RnYEANAl1v20FWcOP8Iu01/rd1sOXRn2Hh4BoVCILv21EIkEsFpD624Ggway48+u9H0KDxXqvw5II5L1H7ZmjZI1Tsi+rNqXUrIWVngMwzBcD6KhaLUGOByBfzv8EvZqOEd00yyyjotTQaMJ7qX3PIcOAMDwg1/PpTezfUdI3Petr5q5I8LLFGne2qreDhdx9obL9RBIoRjrxipO7UBxcTkYUePahkKNu22ap6/6DEdQ/BsCn89DTIwy4P3QkTU/NNUkjUtcJgeekjTnMj7OY+utLV/b4UpjS9IIB8RqMCKaNYorlKSFJ/rE+EHx8wwofqZbTQWTxLweEvN6TvreeH49Np733PfGjUJs3Oj9t4+3tnxthytcrgfSSOR8B8k12oa4Itm4HpKNFP9wE7rfCiFMqv0WAGDEexyPpOmQVn4FADBLRgS97+Wn2b4fau2+7+XLRewyD9nq1Zav7XCFy/VAGonzyyC12mFOpG2IC9LlVZ/hhyj+4YRq1vxRXsz+rYoNfF8hiJP6HsbE/s0L/u2OTFa2b7nIfd+mquHJvQzPW1vV2wnJOioO10MghWSsG6m4KAE0xeWAoHFtQ6HG7Tbt686K+IRq1kJZE03SOMVhcuApSXMu4+PwvLUV8vvPRpakEQ4I5YAgtK5yblJCfidDakM1a35QbnwByo0vcD2MJkViXgOJeQ0nfa/LWoN1WZ77XrdOiHXrvP/28daWr+1whcv1QBqJSyshuUrbEFck69ZAso7iH25C91shhEnKvgcAGPAhtwNpQqSV/wMAmCWPBb3vVWfYvke2dd/3qlVsrdnIkZ5rzby15Ws7XOFyPZBG4sKXbM1aEm1DXJCuqvoMj6T4hxOqWfOHueqcv6RpHk7mpmbNyv7NEwW3XwBWO9u3SOC+b2vV8ERehuetrerthGQdFYfrIZBCMtaNVFyMlI01v3FtQ6HG7Tbt686K+IRq1kJZE03SOMVhcuApSXMu4+PwvLUV8vvPRpakEQ7wRZSocSnkdzKkNlSz5gflhqlQbpjK9TCaFEnlKkgqV3HS95qzq7DmrOe+16wRYs0a7799vLXlaztc4XI9kEbi4nJICmgb4opkzSpI1lD8w03ofiv4gc/nBaUfCXMUAGAKUn+hKFixvk5q3woAsPIfD2q/ALAjj+17TAf3fe/Ywf5aHTPG81Vu3tq6uZ1gx9kbLtdDoIVarButgt8htdlhTWl821CoqW2blu6o+gyPofg3hGDtNxpVzRohhBBCSGNDp0EJIYQQQkIYJWuEEEIIISGMkjVCCCGEkBBGyRohhBBCSAijZI0QQgghJIRRskYIIYQQEsIoWSOEEEIICWGUrBFCCCGEhDBK1gghhBBCQlhI3W7qwIEDeOGFF5CRkQEAMBqNSElJwaJFiyAWi2ssn5OTg1mzZoHH46F169Z48803weffyD8rKyvxyiuvQKvVQqFQ4N1330V0dDS2bduGpUuXQigUYsSIEXj00UeD9h65VNf4Xrdw4UK0bNkSo0ePBgCsXbsWa9asgVAoxJQpU3DXXXe5LP/3339jwYIFEAgE6NevH6ZOnQqHw4G5c+ciKysLYrEY8+fPR4sWLQL3ZjlU1zifOXMGb7/9NgQCAcRiMd59913ExsZSnH1Q11hnZ2djzpw5YBgGaWlpmD9/PoRCIcXaB/7uP37++WesXLkS3333HQDaf3hT1zhnZmbimWeeQVpaGgBg9OjRGDp0KJYsWYIdO3ZAKBTitddeQ5cuXVxeV9v3oLvvzMaqrrHWarWYPXs29Ho97HY73nvvPTRv3jw42zQTQvbv38+88MILLo+9+OKLzKZNm2pd/plnnmH279/PMAzDzJkzh9m8ebPL819//TXzn//8h2EYhvnll1+Yt99+m7FYLMzdd9/NlJWVMWazmRk+fDij0WgC8G5CT13jq9VqmUmTJjEDBw5kvv32W4ZhGKaoqIi5//77GbPZzOj1eue/q3vggQeYnJwcxuFwME8++SRz+vRp5o8//mBmzpzJMAzDHDt2jJk8eXIA3mFoqGucx44dy2RmZjIMwzCrV69mFi5cSHH2UV1jPWXKFObgwYMMwzDMzJkzmc2bN1OsfVTXWDMMw5w+fZoZP348M3LkSIZhaP/hi7rGee3atcxXX33l8tipU6eYcePGMQ6Hg8nPz2eGDx/u8ry778HavjMbs7rGeubMmcyvv/7KMAzD7Nu3j9m+fXvQtumQOrJ2M4vFgqKiIqjVakycOBF8Ph8ajQajRo3C2LFjcfr0afTu3RsAcPvtt2PPnj0YNGiQ8/VHjhzBk08+6Xz+k08+wYULF9C8eXOo1WoAQM+ePXHo0CHce++9wX+DHPMWX6PRiOeeew47d+50vubEiRPo3r07xGIxxGIxmjdvjrNnzzp/tRkMBlgsFjRv3hwA0K9fP+zduxcajQb9+/cHAHTr1g2nTp0K/hvmiLc4L168GPHx8QAAu90OiURCcfaTt1h//PHHEAgEsFgs0Gg0UCqVFGs/eYt1aWkpFi9ejNdeew1z5swBQPsPf3iL86lTp3Dp0iVs3boVLVq0wGuvvYYjR46gX79+4PF4SE5Oht1uR0lJifMombvvwdq+M5sSb7E+evQo2rZtiwkTJqBZs2Z4/fXXsW/fvqBs0yGXrO3fvx/jxo2DVqsFn8/Ho48+Cj6fj8LCQmzcuBEOhwPDhg3DkCFDwDAMeDz2jvcKhQLl5eUubRkMBqhUKpfnqz92/XGDwRC8N8ixusQ3NTUVqampLsmat/gZDAYolUqX53Nzc2s8LhAIYLPZIBSG3CbYIOoS5+uJ2tGjR7Fy5UqsWrUKu3btojj7qC6xjomJQX5+PiZOnAilUol27dph586dFGsf+RrrwYMH44033sCrr74KiUTifD3tP3xTl226S5cuGDlyJDp16oRly5Zh6dKlUKlUiIyMdLZ3/fvverLmbj3U9p3Z2NUl1vn5+YiIiMDy5cuxZMkSfPHFF0hLSwvKNh1yFxjcdtttWLFiBVatWgWRSISUlBQAcGauUqkUrVu3xpUrV1zq04xGIyIiIlzaUiqVMBqNLs9Xf+z649UD3djVJb618Ra/2p6vLe4Oh6PR7miBusf5t99+w5tvvonPP/8c0dHRFOc6qGusmzVrhs2bN2P06NF45513KNZ14GusL168iJycHMydOxcvvvgisrOzsWDBAoq1j+qyTQ8aNAidOnUCAAwaNAiZmZl+xVmlUtX6ndnY1SXWkZGRGDBgAABgwIABOHXqVNC26ZBL1q6LiorC+++/j9mzZ0Oj0eDMmTOw2+2oqKhAdnY2WrRogQ4dOuDAgQMAgJ07d6JXr14ubfTo0QN//fWX8/mePXsiPT0dOTk5KCsrg8ViweHDh9G9e/egvz+u+RLf2nTp0gVHjhyB2WxGeXk5Lly4gDZt2jifVyqVEIlEuHLlChiGwe7du9GrVy/06NHDeYTu77//dnlNY+ZLnH/88UesXLkSK1asQGpqKgCKsz98ifXkyZNx+fJlAOwvXD6fT7H2g7dYZ2Rk4Ndff8WKFSuwePFiZGRk4PXXX6dY15Ev2/SkSZNw4sQJAMC+ffvQsWNH9OjRA7t374bD4UBBQQEcDofLhQLuvgdr+85sKnyJdc+ePZ3xOXToEDIyMoK2TYf0T5OMjAyMGzcO8+fPR3x8PJ566imUlZVhypQpiI6OxsyZMzFnzhwsXrwYrVq1wuDBgwEA48aNw4oVKzB69GjMnDkTo0ePhkgkwgcffACRSIRZs2Zh0qRJYBgGI0aMQEJCAsfvlBve4lubuLg4jBs3DmPGjAHDMJg+fTokEgl27tyJs2fP4umnn8a8efPw8ssvw263o1+/fujatSs6d+6MPXv24LHHHgPDMFi4cGGQ3y13PMVZrVZjwYIFSEpKwnPPPQcAuOWWW/D8889TnP3gbZt++umnMWvWLIhEIshkMsyfP5+2aT/R/iM4vMV57ty5ePvttyESiRAbG4u3334bSqUSvXr1wqhRo+BwOPDGG28AAH744QcAwPDhw2v9HqztO7Mp8SXnmD17NtasWQOlUokPPvgAarU6ONu0b9dMcKu2KzY8mT9/fgBH0/jUNb61KS4uZpYtW9ZAI2qcKM7BQ7EOHop1cDREnM+cOcOsW7eugUbUeIXiNh2yp0Hr44knnuB6CE0OwzAU9yCgOAcPxTp4KNbBERkZiREjRnA9jCahobdpHsMwTIO1RgghhBBCGlSjPLJGCCGEENJYULJGCCGEEBLCKFkjhBBCCAlhlKwRQgghhIQwStYIIWHLbDZj3bp1bp8/dOgQzp496/b5H374AYsWLXL7/Mcff4zVq1fXeHzq1KkA2DkdL1y44HY5QghpCJSsEULClkaj8ZisrV+/HkVFRQ3e75IlSxq8TUIIcSek72BACCGefPrpp8jOzsaSJUtw8uRJGAwG2O12TJs2DSqVCrt27cLp06eRkZGBbdu2YfPmzaioqEBUVJTPCdeWLVuwadMmVFZWYvbs2ejSpQv69u2LPXv2BPjdEUIIi5I1QkjYmjx5Ms6dOwej0Yg+ffrgn//8JwoLCzF69Ghs3boV/fv3x9ChQ5GYmIiysjIsX74cfD4fkyZNwsmTJ33qo1mzZnjrrbdw/vx5zJgxAxs2bAjwuyKEEFeUrBFCwt6FCxcwbNgwAEBCQgKUSiW0Wq3zeT6fD5FIhBdffBFyuRzXrl2DzWbzqe1bbrkFANC6dWtoNJqGHzwhhHhBNWuEkLDF5/PhcDiQnp6Ow4cPAwAKCwuh1+sRGRkJHo8HhmFw9uxZbNmyBR9++CHmzJkDh8MBX2/ecuLECQBAVlYWkpOTA/ZeCCHEHTqyRggJWzExMbBarSgvL0dOTg7++OMPVFZW4q233oJQKETXrl2xaNEiLF68GDKZDI899hgAIC4uzucLD/Ly8jB+/HhYLBa89dZbgXw7hBBSK7o3KCGEEEJICKMja4SQJm/q1KnQ6XQujymVSixbtoyjERFCyA10ZI0QQgghJITRBQaEEEIIISGMkjVCCCGEkBBGyRohhBBCSAijZI0QQgghJIRRskYIIYQQEsL+H9+q05m8c/JWAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -4672,13 +4806,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='boxplot+stripplot', \n", + "ax = plot2d(plot='boxplot+stripplot', \n", " df=tips, \n", " x='total_bill',\n", " y='day',\n", @@ -4691,13 +4825,13 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 19, "id": "b6b152de", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -4707,13 +4841,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='violinplot+stripplot', \n", + "ax = plot2d(plot='violinplot+stripplot', \n", " df=tips, \n", " x='total_bill',\n", " y='day',\n", @@ -5134,13 +5268,13 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 20, "id": "7b182b2d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABBsAAAFDCAYAAAB7pwb5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAADWuklEQVR4nOzdd3iT1RfA8W9W012glJbZMsreQ5YMcaAIWBUUWaIICiKIoiCCgAI/xAEiiKAgiCgKKIqiIiBbluy9y2zpoisdWb8/UgKhg7ZJyfB8nsfn8U3yvvfc9HDb3Nx7XoXZbDYjhBBCCCGEEEII4SBKZwcghBBCCCGEEEIIzyKTDUIIIYQQQgghhHAomWwQQgghhBBCCCGEQ8lkgxBCCCGEEEIIIRxKJhuEEEIIIYQQQgjhUDLZIIQQQgghhBBCCIeSyQYhhBDCTcyfP58BAwbQt29f+vXrx+HDhwE4ceIEu3fvzvX6H3/8kfXr1xe5nZEjR7Jz50674y2K77//Hr1en+/zV65cYcOGDfk+f+nSJZ566ql8n9+5cycjR47M9fiUKVO4cuUKn376Kd99912+rxNCCCFE0aidHYAQQggh7uz06dNs2LCB7777DoVCwbFjxxg9ejS//PILa9eupWzZsrRo0cLmnCeeeMJJ0RbdvHnziIqKyvf5HTt2cPbsWTp16uTQdt9++22HXk8IIYQQFjLZIIQQQriBgIAArly5wooVK2jfvj116tRhxYoVxMbG8tNPP6HRaKhXrx5jx44lIiICjUZDtWrVKFu2LNWqVePzzz9HqVQSFxfH008/TZ8+fWyuv3TpUpYvX05ISAgJCQkApKWl8fbbb5Oamsq1a9fo3bs33bp14/HHH+fPP/9EpVLxwQcfUK9ePbp06QLA+vXrWbduHf/73/8AePzxx/nyyy/58MMPiY6OJjMzk/79+9tMLCxfvpy4uDhGjhzJZ599xrRp0/j3338B6Nq1K3379mX+/PlkZmbSpEkTAgICmD17NmazmfT0dD766CM0Gs0d38Po6GgGDhxIUlISzzzzDD179qRfv35MnDjRAT8hIYQQQtxKtlEIIYQQbiA0NJS5c+eyd+9enn76aR5++GH+/vtvQkNDefzxxxkwYAANGzZEp9MxdOhQZsyYYXN+bGwsc+fO5YcffmDRokXWCQWA+Ph4vv76a3744Qc+++wz63aG6OhoHn30URYuXMiCBQtYtGgRAQEBNGvWjK1bt2I0Gtm8eTMPPPCA9VodO3Zk37596HQ6Dh48SOXKldFqtezevZvZs2fz5ZdfolKpbGLr2bMnISEhzJgxg7///ptLly7xww8/8O233/Lrr79y+vRpBg8eTNeuXbn//vs5deoUH3zwAUuWLOGhhx7ijz/+KNR7qNfrmTt3Lt9++y1ffvkliYmJxf1xCCGEEOIOZGWDEEII4Qaio6Px9/e3rhg4dOgQgwYNomXLlrleW7Vq1VyPNWnSBC8vLwAiIyO5cOECwcHBAFy4cIEaNWpYn2/YsCEAZcuWZfHixaxduxZ/f38MBgNgmRxYsmQJJpOJNm3aWM8DUKlUdO7cmbVr17J//3569uyJv78/Y8eOZfz48aSlpdG9e/d8+3nmzBmaN2+OQqFAo9HQqFEjzpw5Y/Oa0NBQpkyZgq+vL7GxsTRt2rRQ72Hjxo2tsVavXp1Lly4V6jwhhBBCFJ2sbBBCCCHcwIkTJ3j33XfJzs4GLBMKgYGBqFQqFAoFJpPJ+lqlMvev92PHjmE0GsnIyOD06dOEh4dbn4uIiOD06dNkZmZiNBo5duwYAAsXLqRx48Z8+OGHPPzww5jNZgCaN2/OxYsXWbFiBT169MjVVo8ePfjll184ePAgbdu25dq1axw5coQ5c+Ywf/58PvjgA+vExQ03+lC9enXrFgq9Xs++ffsIDw9HqVRa+zh+/HimTp3KtGnTKFeunDWuOzl69CgGgwGdTseZM2eoUqVKoc4TQgghRNHJygYhhBDCDTz00EOcOXOGHj164Ovri9ls5s033yQgIID69eszffp0qlevnu/5BoOBQYMGcf36dYYMGUKZMmWsz5UpU4ZBgwbRq1cvypQpg4+PDwD33XcfkydPZs2aNQQEBKBSqcjOzsbLy4tu3brxxx9/EBkZmautypUrA9CpUyeUSiUhISHExcXRq1cvlEolzz//PGq17Z8gzZs3Z/DgwXz99dfs2rWLp59+Gr1ez8MPP0y9evVQKBTMnTuXevXq0b17d/r06YOPjw9ly5bl2rVrhXoPtVotgwYNIiUlhVdeeYVSpUoV6jwhhBBCFJ3CXNivA4QQQgjhlnbu3MmyZcty1XGwx5dffkmpUqXyXNkghBBCCCErG4QQQghRJGPGjOHatWt8/vnnzg4ll9mzZ7Nz585cj0+dOtW64kIIIYQQJU9WNgghhBBCCCGEEMKhpECkEEIIIYQQQgghHEomG4QQQgghhBBCCOFQMtkghBBCCCGEEEIIh5LJBiGEEEIIIYQQQjiUR92NIikpHZPJfetdBvw0EIDUxxc4ORJhj+BgfxIS0pwdhkP5ZFgqzmf4vOTkSBzvy0OWvr3QwL6+ffmlxnKdF/ROieX29j0xD4vLk/PXHUguClcRHOyPbt+HAGRUkfFAOEdRx0SfL3N+h70gOSscR6lUULq0X4m341F3o0hISHPryQbhGUJCAoiLS3V2GOI/TvJQuArJReEqJBeFK5A8FK5AqVQQHOxf8u2UeAtCCCGEEEIIIYT4T5HJBhdSZkFdyiyo6+wwhMglIHUAAakDnB1GiRi8dgCD1w6w/zqDvRk82NtpsTiifU/lyfkrhCiagIMDCDg4wNlhCFFoAYMHEDB4gLPDEKJYPKpmg7szeNdydghC5MmgbujsEEpM/bKO6Vv9+ib7r2FHLI5o31N5cv4KIYrGECDjgXAvhvq2OWs0GkhKisNgyHZSRMLdqNVelC4dgkp19z/6S80GIRxM9uIJVyB5KFyF5KJwFZKLwhXYm4fx8Vfx9vbFzy8QhULhwMiEJzKbzaSnp5CZqaNs2fLWx6VmgxBCCCGEEEIIK4MhWyYaRKEpFAr8/AKdthJGJhtcSJkFtSizQLZSCNcTmNqXwNS+zg6jRDz3R1+e+8P+vj33nDfPPWdfzQR7YnFE+57Kk/NXCFE0gQf6EnhAxgPhPgKf60vgc7Y5KxMNoiicmS9Ss8GFGHwaOTsEIfKkV9/j7BBKTPNQx/SteXOj/dewIxZHtO+pPDl/hRBFow+S8UC4F31z98vZsWPfYOrUD4p0zoIF8/jrrz8pW7YsACkpydx//0M8++zAfM/ZuHE933yzGIUCHnzwEZ566hmb569fv86kSW+TlZVF2bIhjB07gYsXo/nkk4+srzl69DBTp35Iq1ZtihSvKByp2SCEg8meUOEKJA+Fq5BcFK5CclG4AnvzMCYmmrCwcAdG5BoWLJhHcHAwUVE9AMjOzqZv357Mm/cVpUuXyfV6o9FInz49+PLLJfj4+NC3b0/mzl1IqVKlrK+ZOfMDatasTZcu3ViyZBFeXhqefrqP9fkNG9axZctGJkyYXMK9c77b80ZqNgghhBBCCCGEyFdQVBe0y5ZaDvR6y/HyZZZjnc5yvGolAIqUZIKiuuD16y+W44QEy/Gfv1uOY2Pv2N6aNat5++03GDVqOM8915s1a1bz1luj6NXrcbZs2QhA9+6dARg2bDCffPIRI0YMZdCg/sTEXAXgvffeISYmpsB2UlKSMRgMaLVaFiyYx4QJbzF8+Es891xvDhzYj0ql4ptvluPv709KSjImkwmNxnbR/sGD+2nZsjUArVq1Yc+eXdbnMjIyWLhwHiNGjLpjn0XxyTYKF1JmYQ0AEp8/7eRIhLAVmPI0ACmB3zs5Esfrt8bStyVd7Otbv34+lussyXBKLI5o31N5cv4KIYomcF/OeNBExgPhHgL75eTsEtfJWZ1Ox4wZc1i37k++//5b5s9fxL59/7J8+Xe0a9fR5rV16tRjxIjXmTdvDn/99Sf9+g1g/Ph387zusmXfsm7dWmJjYwkJCWHMmPH4+voBoNV6M2vW55w9e4ZJk8axePF3qNVqNm3awMcfv0/r1vfi7e1jc7309HT8/S3f3vv6+pKWlmZ97tdff+a++x6wWQkhHE8mG1yIwdf99mSJ/wa9poOzQygx7So6pm/t2hnsv4YdsTiifU/lyfkrhCgafbCMB8K96NsVnLPJq9bcPNBobI99fW2OzYFBtsfBwbbHoaGFiiky0lLQ3t8/gIiIqigUCgICAsjKyn3Hg5o1La8NDQ0lISGhwOv26tWbqKgeHD9+jIkTx1K5chXrc82atQCgWrXqJCbevE6HDp1o164jU6ZM5I8/fuPRR7tbn/Pz80On06HVeqPT6QgICLA+t3bt70ye/H6h+iuKTyYbXEhKr2+dHYIQecrwGersEErM4EaO6dvgwXr7r2FHLI5o31N5cv4KIYomo4qMB8K9ZAx2vZwtyt0NinMnhNq169C377NMmDCWzz9fCMCJE8fo3LkLZ8+eJiQkhPT0NEaPfo2PP56Nl5cXPj4+KJW2FQIaNGjEP/9so0uXbuzYsZ2GDRsDkJaWhl6vJzQ0rMixiaKRmg1CCCGEEEIIIe6KwtRs6No1Cj8/P376aQUAJ0+eYMSIIUybNpk33xyHn58/Dz74MC+/PIghQwYCCh566BESEuKZMOEtAJ59diDr1q1lyJDnOXLkIE8+admScvFiNOXLly/RPgoLuRuFCwleWBWAhOfPOTkSYQ9PrHYdlPIEAMmBPzo5Esfr9aulb8u62te3Xr0s+wSXLSt+zQR7Yrm9fU/Mw+Ly5Px1B5KLwlWEhASQ/eeDACQ3lfFAOEdRx8SgXjm/w5ZZctZT70ZRkNvvVFEQg8HA3Lmf8sorI+9CZO7DWXejkG0ULiTbX/YRCteU5fWIs0MoMQ9FOKZvDz1kf80Ee2JxRPueypPzVwhRNFkhMh4I95L1kORsUfXu3c/ZIYgcsrJBCAeTb/GEK5A8FK5CclG4CslF4QrszcP/4soGYT9nrWyQmg1CCCGEEEIIIYRwKNlG4UKCv7Lc3iXhuQtOjkQIW0EpltsIJQf+4uRIHOdyXBq+3hpe+LsnACu729e3J5+01ExYubL4NRue/KV7sWNxRPueyhPzVwhRPEH/5owHzWQ8EO4h6MmcnF0pOSvcj0w2uJDsgIedHYIQecryesLZIThMeqaeGT8c4OyVFBQKqBx5L81ql7P7ulFR9tdMiKpR/PfZEe17Kk/KXyGEfbJCZTwQ7iUrSnJWuC+p2SCEg8meUNe2astZftl23uaxdwfeQ6WQkt+3djdJHgpXIbkoXIXkonAFUrNBOIPcjUII4RISUzLJyDZSsayfs0MpEXHXM/N4LMPjJhuEEEIIIRxtzZrVREefZ8iQV1wyjgkT3mLcuHfRaDS5zinKLTQLo2PHVtSv3xAAo9GA0Whi4sQpVKhQMc/XZ2RkMGnS26SmpqJWaxg3biIhIbara3/55Sd+/vlHVCoVzz47kLZt2/HJJx9x6tQJABITE/D3D2D+/EUO6UNJk8kGFxK8qBIACQMuOTkS8V+19K+TbPj3EmagRqUgRvZshI9WTVByFwCSg9Y4N0AHaF4rhH+OxFiPd/qPI/5QEL9E/m7XdaOiLDUTVq0qfs2EqFWW93lVVNHfZ0e076k8KX+FEPYJ2pMzHjSX8UC4h6ConJxdJTlbGJMm/e+utRUYGMTs2fOtx6tWrWTZsm947bXReb5+9eqfqFWrDs89N4g1a1azdOnXvPrqKOvzCQnxrFixjC+/XEJ2djZDhw6kRYuWjBjxOgAGg4EhQwYyevS4ku2YA8lkgwvJCopydgjiP+zc1RTW/3tzouv0pWQ27L3Eo60jyNT2ASA2UcfWQ1fRqJW0b1SBUv7aAq9pMJo4cDqBjCwDTWqWxc879yyzIx05l8jq7efJ1hu5v1kl2jYob30uMSWTH/4+zaW4dOpXLYPeaCLQ14tmFQYSHOhtd9u9eumLfI7eYOSPXRc5fzWFmpVL8VTNZ1Aqi3eToOK070oSUzJZvf088cmZtKhdjvaNKjjs2jfyVwghMivIeCDcS2avgnM2aE8XMiv0IatCHzDpCdr7GJkV+5NVvhcYdQTt60FmpYFkhT2JQp9M4IFnyKj8Etmh3VFkJxB4sB8Z4a+QHfIIiqxYzNrQQsf23XffsH79WlQqFY0aNeHFF1+md+8nWbp0BdevX+eJJ7qwevVafHx8eeml51i4cCmffz6bAwf2YTKZePrpPnTq9ADDhg2mdOkypKSk8PHHn6JSqUhOvs6IEUNZtOhbDh8+xKhRw1mzZj3x8XFMm/YeDzzQmSNHDjFy5Mtcv55EVFQPHnvsCXr06MbSpSvYsWMb33yzGLVaTdmyIUyaNNUa96VLF5k06W1Gjx5PWFh5pk17l+TkZABeffUNqlevwZNPdiU8PIKIiKq0bduegwf389xzgwp8P2JjYwgICASgZ8/HqFu3HleuXKJq1eqMGTOep57qjdFovOW1ATbnHzt2hAYNGuHl5YWXlxcVK1bmzJlT1KlTD4AVK5Zxzz2tqF69RqF/Rs4mkw0uJO3x2c4OwaMdOB3PtsMxBPpqePieKpQt5ePskBxCbzCx40gMccmZNKsZQnhYQK7XZGQZ+H1nNJfj0mlQLZgOjSugUChsXhN3Pfc34vHJli0HWd59uJakY9Ki3WRmWwbJTfuv8N7Alvh65z2MmExmpn+3j9OXLIN34CYvxvdvTnCQ/R/s8xKfnMEnKw5gMFrqtiz47RilA7TUjSgDwJyfDnPuagoAV+LT6dS0In0fqgXUL3QbBqOJHUdiuXZdR5PIEKqWD7Q+16tX0Qs0Lvr9OP8ciQVg36l4Hmzeil4PRBb5OsVt31WYzGY+WLaf2EQdYJk0MpvNdGic9zLEosrydu8PFzGJOhauOca5K5ZJqYGP1qGMAybIhPgvypLJBuFmsu4w2eAsZ86cZsOGv/j884WoVCrefvtNduzYTqNGTThy5BCXLl2katXq7NmzG19fH1q0aMU//2zj6tXLzJ27gKysLF588TlatGgJwAMPdKZDh/us1w8KKkVQUBCxsTHs3Lmd0NAwjh8/yvHjx2jfviMAarWajz+eTUzMVd54YwSPPXazmOZff/1J7979uO++B/j9919JT08H4MKFaH777RfeeWcylStX4bPPZtGs2T08/ngPLl68wNSpk5g7dwHXrsWycOE3BAWVAqBZsxa53oOUlGSGDRuMTpdOSkoKHTrcx8CBLwEQFxfLoEGzqVSpMuPHj2HLlo106NAJlUrF8OEvcfbsaWbMmGNzvfT0dPz8bm7r9fX1JS0tDQC9Xs/PP//IF198bdfP7W6TyQZXkmX5Qxutr3Pj8EAHzyTwyYqD1uN9p+KZ9mIrNGqVE6MqnOiYVL5bf4prSTqa1AyhV6caNnF/+uNBDp9NBGDNP9G8+lRD6lcNtrnGZ6sOc+Sc5TX7TsWTlqGna5sIm9fUjSiDj1ZFRpbR+lizWiGW/zHr2X7oonWiASApNYt9p+JsVg/c6uj5ROtEA0BKejYb91/myQ7Vi/4mFMKRc4nWiYYbDpxOoG5EGVJ12daJhhsOnkkAQG+0rAjQqO686mLuqsPsOxUPwG//RPPKEw1pHFnWcp2chQV5bBHMk9FkYtexazaPbTtyiR73RRQqltsVtX1XciE21TrRcMOuY9ccNtmAOefNUbjhmwN8sfqoNX+PRSex6I/jvPZUY+cGJYS7MuWMB0r3HA/Ef9AdfsHbbAlSamyPVb42x2ZNkO2xV7DtcRFWNURHn6devQao1ZaPk40aNebcuTN06NDJOqkwePBQtm7dhFKppGvXx9i7dw8nThxn2LDBgGVbQEzMFQCqVMld9LJ9+4788882Dh06QN++z7J7904OHz7IW2+9w44d26lZszYKhYIyZYLJzLStyfXKKyNZsmQRK1f+QHh4hHWCYseO7ahUKutK0rNnT7N37x7Wr18LQGqq5fetZbKjVIHvwY1tFEajkalTJ6JWa/D1tXyOCw0No1KlygA0aNCQCxeirefNmvU50dHneeONEfzww8/Wx/38/NDpbv49pNPprKsf9uzZSePGTfH3d68aY8VbrytKRPB3NQn+rqazw/BIO47G2BwnpWZx4sJ15wRTBEaTiVkrD3Ly4nWup2Xz997LNndSuJqQbp1oAMs3xOv22Nb8SEnPtk403HBrzYIb/H00vPlMU5rXCqFuRGleeqyeddIiKOUxulUdkuscrSb/yZpsgyn3Y/rcjzlKhTwKWlYoaxnwfb3VBPl72TxXPtjy+p6rH6Pn6sfueP246xnWiQYAsxn+2nPRetyzpw89exZ+tYxSocDf1/YPhy1e4wsVS16K2r4rKe2vRaW0XWnjyBUwQSmPEZRSvPfV2YwmU66Jslsn8YQQRRO09zGC9rrneCD+m4J6PkZQT9fL2fDwCI4ePYzBYMBsNrN//z4qVw6nRYuW7N+/l+vXk2ndui0nThzj1KmT1KlTj/DwCJo0ac7s2fOZNetzOnV6gIoVLTXr8tpG2q5dR9at+xM/Pz9atmzDli2byM7WU6aM5e/T21fp3uqXX35i4MDBzJ49H7PZzObNGwF46qlnGD78NaZMmYjRaCQ8PIKnnurN7Nnzee+9aTz00CP5xpMflUrFm2++zebNf7N9+1YA4uLiSEiw/N148OABqlatxpIlX/HHH78B4OPjg1Jp+3d0nTr1OHhwH1lZWaSlpREdfY6qVS1f0u3Zs4tWrdoUOiZXISsbXEhWKcdURhW5lfLLXVsg6A71Bhzh4JkEvlt3ksTULFrWCaVf55pFWk1xNUFHUmqWzWNHzydaVwfc/gEtr8e8vVR4e6lsViXkVWshLUPPL9vOcfBMAhXK+lE26OYH10zv/igUBsoGeVu3VkSEBdCoRtl8Y29QrQyhpX2ITbJsz/BSK2nXKO9VEI4QWakUj7SswtrdFzGZzDSvXc666kKlVPLcI3VY8NtRUnV6wsr40ut+y363PnX6F+r6KqUCBXDr2gm16uYvoj59ilYzQaFQ8Mz9kXz561EMRjNeGiUDGgwo9l0xitL+uj0X+XX7eYwmMw+2qEz3tlWL1aajBPlriWpXlZ82n8NkNhNSyptut628sUemd+F+xq5IpVRStXwA567evE1ajYpBToxICPeWWdF9xwPx35TZxzVztnr1GnTq9ABDhgzEbDbTsGEj2rfviEKhoFy5UMLCwlAqlVSuHE7p0pYtrW3btmffvn8ZOvQFMjJ0tG9/H76++d/9rFy5ULKysmjW7B4CAwNRqVS0adO2UPHVqVOPN998FV9fP3x8fGjT5l5WrPgegBYtWvH33+tZunQx/fs/z7Rp7/HLLz+i06Xz/PODc13r339337Fmg1brzZgx45k8eSJNmjTDy0vDjBnTiY2NpV69BrRt2566deszefJEfv31Z0wmE2PHvgPAkiWLiIysSatWbejRoxcvvzwIk8nE4MFD0Wotf7NfuBDNww8/Wqi+uxKF2Ww23/llhTdt2jSOHDlCXFwcmZmZVK5cmVOnTtG6dWtmzJjhyKZySUhIw2RyaHeEi9AbTGzcd5mL19KoV7UMLesWbpnXtesZ/L33EumZBo6eTyQxxfLBvWPjCvR/uLZdMWVkGdiw9xLXkjJoViuEhtXLEpOoY+fxONJ1WbSuF8r0b/eTpb/5IT/q3qp0aR3O5gNXOH81ldrhpWhdLyzXzGx0TCqbD15Bo1Kw+cBVm4mCDo0r0Ov+SP7ee5krCenEJuo4lfNNp0atZFSvxkRWKgXArmOxHD6bSEa2gX0n4zCZwVerZuRTjQgPC2DjvstciE2jbkRpjkUnseXgVWs7ZQK1TH+pDUqlAqPJxJYDVzl5MQkvjYoG1YJpVKOszYftW2VlG9mw7xIXYtNQKxWUDtTSul4YZQK9rXE3ql725jaNQroUl8am/VdQqxTc16Qi5UrbbjnacTSGg6cTCCvjyyOtwtGob8YXHZPKpv2XMQOPtgovdM2ObL2Rv/dd5nJcOnHJGdYVMWqVgpFPNaZOeOkCz7+elsX6fy052LZBGNUrWD4oZmYb+HvvZaJjUykf7Mf9zSrh72NZ6WAymdl84ApnriRTs3Ip7m1QHoVCYT3naqKOJpFlaRJpef9uvN9XE3Q0rlGWpjVDbO7jferSdf45HEOArxc1KgYxY/kBmxiH92hI4zwmjnSZlhyPu55B89rlaFAtONdrHOHGv6WL19KoViGIB5pVQpnHRFpRHTmfyO5j1ygTqOX+ZpXyLVB6NSGdjfssyzjva1qRsDKusZUtNknH33svk6rL5nJcOpfi0qlVpRTPd6lj98qP3cevcehMAhVD/OjUtKLDtpQdPpfAnuPXCA7y4f6mlfD1Vtt9T/m7wWw2s/1wDCcuXKdq+QDaN66AqpjFWu/k3NUUth66io+XmvubVaJ0gO3kr8lkZsvBK5y5nEKNSkHc27A8ygK+vROF54hcPHc1ha0Hr+KjzfvnV5LikzP4e+9lsvRG2jeqQJXQ3DWahOuzNw9jYqIJC8u95UC4lu7dO/PLL38W6rVbt27Cx8c3z7oQjnJ73iiVCoKDS35LhsNXNowZMwaAH3/8kbNnzzJq1Ch27tzJsmXLHN2U50nNWaIdkP+3xf9VC347at3fvvXQVZJSs3i4ZZUCz0nVZTN58R7SMnL25KsVvNC1LuFhAVTMY8l9UX2ywrK9AWDLwav0fjCSVZvPocuyFOrbvP9Krq0Epy4n8/WfJ9ia86F+66GrxF3P5LF7b36zfCE2lSlL9ljrD/h5qwny8yI5PZs64aV5on015q46bK05ANCpSUXCgn1pXKOs9UP02l0XWLbhtPU1DauV4cEWVaheMRBvLzVfrD5iLU649dBVAm5b0p+YkkViSiZlS/nww/pDbN5/hSyj5Y+qAF8vmtWyvS/wreb8dIjDt2zdGPBIbcoH+zFz+QFr3FsPXqV/51p0bFK4ffmxSTomf73HuhVj26EYJr/QkkA/y/aI33dEs3zjGevrrybqeLG7pXrvpWtpTFnyLwaj5dz9p+KZMqgViamZJKalUq1CIP7avHPii9VH+fdknPW4Q+MKVCjrR6PqwTaTHTe22Pne8jk1W29kytf/kpBiWQ2y5cAVxvRtSvUKQXy68hDHopOsrw0O9KZpHctExMq/L/L33svWfsYmZtCjY3Xm/HiII+eTrO/fc11q065hBeasOsSBE8nWx599uBY9HrRMph2PTuKDZfu4Ma18Y0LjVmcuJ+c52TBz+QFOX7Zcd8vBq7z0WD3uqVP4/ZyFNXP5AeuE2a5j1wj009Cqbphd19x3Mo5PfzwEgFaVxeEzl3ir3725JvYSkjN5b/Ee64Te1kNXmfxCy7v6ASIvyWlZTF68h/RMy3ii9VLxvxdbEeKAwrZ/7bnId+tOWY9PX0rm5Sca2H3dPcev8dmqw9bjA6fjGde/ud3XvRtWbTnH6u3nAUsOXLiWxrN2Tkjn5XxMClOX/Isx54uRf47EMHVQK7ReNyd7lm04Zd0Ot/XQVa4mpPN0p+IVjhV5MOYM1qqiTyoW5udXUnSZeiZ//S8p6dkAbD5wlXcGNC/2ajjhRvL6A0N4lBo1ahEWZt/fPa7qrtVsiI6O5oUXXuCJJ57g008/BaBfv36cOWP5cPDdd9/x6aefcunSJbp160a/fv344osv7lZ4LiF4ZWOCVzZ2dhguR5dpYPdx20J6m/ZfvuN5e0/GWScaAPQGM9eSdA6ZaIhJ1FknGm5Yt/uSdaIBLDULbt/SUK18IP8ctq2XsPnAFZvj7YdjbAodpmcaeLpTDeaMbM8bzzTBYDTbTDQAnLmawgPNK9t8W7/ptuseOptIeFgA3l5qsrKN7Dxq+57eXk+hTKCWMoHemMxmOpUfwoSH37157f22175VYkqmzUTDjdcnpWblirug69xu55FYmxjTMvQ2kwC393fXsVgycn4e24/EWCcaAJLTs5m5/ADvLNjFU6ufoO3CzqTqsnO1marLZu8tbYDlg9mDzSvnWlXRu7cPvXvbfhA8cj7ROtEAYDSZ2XbwKnHXM2wmGsCSB71/68Ezv/Vgy4GruZ6LT86wTjRYH99/xfJ+n01k50+t2PlTK+vrb9hy8Cq3rl+79d/EDdXzWJZ/OT7dOtFwQ1F+XoV1NSHdOtFww2YHtHPrezDh4Xd5vsmbRMfm/iZp1/FYm5VDGVkGdh+Ltbt9e+05EWedaABy/s06Jq7bx5y9J+PyzH97r3v2SgoXr6XZfd274fbYtx26ajNmOMq2QzHWD6pgqR906KztuHh7LLcfC/sE7etB0L7ibVstzM+vpOw/HW+daADL3ZFu/3tCeKag3j0I6i1brd1NYVc1AB470QB3sWZDVlYWn332GUajkY4dO/LKK6/k+9q4uDhWrlyJl5dXvq/xRJnBvZ0dgkvSqBV4aVRk3fKBwDef5dC3ymvJdGHOKwxvLxUKBTYf4ry1ub/Z6NikAofPJlprNnRpVYUNOds6bsZk+88wr1tJ+vto8NFaHtdqlKhVCpsJCb88zrm9/2q1gnV7LpKeaaBF7RC0XkqbO0+ElPIhpJS3tWZD/4drWZey/33mUXS3vDav9m7w0qhQKRU2f5D5eavRalS54s7vtpl58cmzj+o8/x/Iac8yn+qrzX3ujQ/SEdmPQDZs2HvZZoUJgJdahUattFmhkl/MAwbk/hCfXw56e+V+j3y91QyoNxCAjRdUpOhs2/T2UudxjgZtzrUiGp2zefxmDLnjfbhlZbbn/NH8YIvKea5q8Mkjxwv6uReXt5c6j3bs/3d663uw5pil2FPXSrnjzys3HDVO2COvPHPU+397nzVqJV4O2EZxe8wKwCePcdEV+XqrSb7lg5y3l9ohW3lytZNnvtk+5uetIVt/s1aPr9b5+ehJMisNLPa5hfn5lZS8xqW71bZwrswBxc9ZIZztrq1siIyMxMvLCx8fH+stUm51a+mISpUq/ecmGgDSu00nvdt0Z4fhcjRqFVG3fAhUq5Q83v7OBe0aR5alRqWb39iWK+WNUkGuFQnFUcpfS+cWN7dx+GhV9H6gJhFhN/dPVinnzyMtw2kcWZbISkGUD/ZFrVbyRIfq3PgTVqVU8ES7ajbX7ti4IiGlbu7HrhtRmrpVy1iPfb01PNo6wnrspVHmWeAvql1Vm5oFPl5qftl2nvX/XmL6t/tpU//mLKpapeDJDlWpXaU0tauUolaVUpS7ZZVExYjn2HbuXmvMBd2+0t9HQ5dWN/eEaTUquretiq+3Olfct3+4L0jb+uVtVqVUrxhorVkA8Hi7ajY1JKLuvdn/Do0rUK70zf7cuEsFQAXDvVQw3Mv1NNtCnGBZut6t7c2YNWqlTS7eKirKQFSUweaxyEpBNh/kb9QOCPD1stkG5KVRcm/D8jxa9XGiIp/kyY7VubHaX6mwvN/+Phqbc7ReKrq3jcDPW8OjrcOpUOsKFWpdyXm/b8b8YIvKNnfiaFG7HE/dF8nM4e349NX2+RaHLBPozQPNKluPfbS2Pz9HKR2g5cHmt7ajynVb1uLo0qqK9cP51rP3og58KtdqFIBWdcOoUu7mMuTwsABa1Ml/i9Dd0rxWCNUqBFqPK4X40aqeY775iGpXzWZs6NY2wiHLwB9tHWEzIdKpaSWbQrOu7In21a0r0RTAkx2qlUidhE5NK1L2lnob9auVyVX35ckO1W7792/7O0LYJyvsSbLCnizWuYX5+ZWUBtXKULtKKetxaGkf2jeqcFfaFs6VFfUkWVHFy1khnM3hBSJvyKtmw40CkW3btmXbtm0MHDiQQYMG0apVK8aNG0doaCiPP/44r732Gj/88EOR23T3ApHKRMtt9ExlKt/hlf9NF6+lsuXgVfy81bStX75QBf5MZjPHopM4ezmZ1dvPW79V73xPZYfsgY2OSeXa9QzqhJfG30eD0WTiSlIWSdd11KtampnLD9rcdrJLq3B6dKxObKKO8zGpRFYKokxg7kJveoORw+cS8fZSU7tKqTxv7XPpWhpXEtKpHV6aQN+8J+eS07I4cfE6WXojX605bvNc63phdG0TzsVraURWKsXWQ1f5afNZ6/M1KgUxtm8zABSmZOKuZ3AmRkGNikGFKk538VoaVxPSqRNemoBb4itM3PkxGE0cOZeIWqWkTnjpXN883ijGaDCaaFU3jPBbJn/0BhO7jsVy8sJ1/H01bD5whfRMA3rSUQBv976XWlXy/qPxclwal+PTqVWlNEF+ececknN3wsBA28fNZjPbDl3lfEwqHRpVoPItBb0uxKZyLDqJDXsvE3c9Ay+fbPp3rkmb2tW4lqTj3NXUXO/3hdhUYhJ1ud7Xo2csxUKb1wsiwNfLpgBVVrYlnwL9NNbioYV1PiaFuOuZ1I0o7ZAVB/m58W/Jke3ocgrDhgRmExEWgFmZ910cjCYTR84loVRAnYjSJVYYsKhMJjNHoxMxmczUjSiTb0HW4khOz+bEhSQqlvWjogP3fOsy9Rw9n0RwkDdVy1v+MbhDgUiwbAE7dSmZiPIBhOYxMeUoeoORw2cT8dGqqZXP+B53PYOzV1KoXiGw0MVsxZ2FhAQQf8VSD8OsKd5dXQrz8yspJrOZE9FJZOlN1KtaxmbSULiPoo6JihTLSkxzoCVnpUCkKA6PKRBZFP3792fSpElUqFCBcuWc/02Ss5X+pTUACQMuOTkS1/TDhtPWPeu/77zAW32a2XyYzItSoaBeRBl+u2WiAWDdnks82joiz2J5RREeFmATg0qppGntcsTFpZKeqbeZaABLHYEeHasTWsaX0AIq3mvUKptv7fNSqZw/lcoVPEgE+Wu5p04o566m5HrOW6uifLAf5YMtqwVu36d++lIyiSmZlAn0JjD1GQJVULbumgLbu1Xlcv5UziO+wsSdH7VKWeDtNv/ac5Hfd1wAYO2ui7zQrS6tc74NzjYY+XHzWeutRL01KlrWDWXBtaEE+XtRq0q3fK9bMcT/jh/I+ve3fCBYtSrD5vG/913mm7Unrf//QtebMVUJDWDFxjPEXbecs1Exia3rlRyouYVypX3z/Ca+SmhAnhXIx75eNs/2wbIKoqh3/rghIiyQiLDAO7/QTrf/W3IEX281zWuXIyi5C6RCclDe+atSKmlYvWTutGEPpVJB/aolE1eQn1eJFPv09dbQvLZ7/j4vE+hNy7r23eWjMDRqFU1qFvzv0bKtTSYZSkLggWcASG5e+N9ntyrMz6+kKBUK6kSUufMLhUcJ7J+Ts6uKl7NCOFOJTTY88cQT1v9v2bIlLVu2tB5v27YNgA4dOtChQ4dc5xZnVYMnyCj3nLNDcFnnrqbYFMfL1pv4a89FXuhat1Dn335XCKPJXCLFv26l1ajw99HYFOQLzmMVw91QtXwgzWqGWAsqBvhqeKiF7QqaMoHeXIpLtx5rvVTWb5gzvF+6e8EWU5beyF+7b07UmYE1O6KtH+z/PRFnnWgAyNQbqRDsyzv1XndI+y+8kLtmg9lsZtWWc7ccw6otZ60xgaVA4g1Vs7sCkJFlxN+naN9Y5dW+sHCH/BVC3B0ZlWU8EO4l4wX3ytlZsz6iSpVwoqLyL2q5YME8/vrrT8qWtXxRkpKSzP33P8SzzxZcnyIzM5ORI4cyZsw7hIdHYDQaef/9yVy8GA0oeOONt6hWrYbNORs3ruebbxajUMCDDz7CU09ZJm+ef74Pvr6WL9wqVKjI2LET7Oi1yI9UlnEhui7vOTsEl5XXZh9TEXYAdWpakbNXbn6736xmCKX8S/bWdmqVkmceiGTR78fRG0z4+2joeV+NO59YQoY+Xp/jF66Tkp5Ng2rBuQpLPdG+GtExqSSnZ6NSQtOaIfyx6wLNaoVQKaS7k6IuKtucuHVbVV7LTTVqFQ9Xd0zfunY15HrMjGUS5Fa3FjoFaFSjLBtybnNZ3tCa6hUDi7XiJq/2hUW21l3yVwhR0rJDZTwQ7iW7q3vkbFJSEpMnT+DixWh69+53x9f36tXbOiGRnZ1N37496d79cUqXznv1zvHjR/ngg/8RF3fzbmrbtm0BYO7chezdu4f58z9j2rSPrc8bjUY+/3w2X365BB8fH/r27clDDz2Cj48PZrOZ2bPn29NlUQgy2eBClLGW+56bQuV+2rerViGQmpWCOJlzizy1Ssn9zSoV+vw29ctTyl/LgdMJlA/2pW2D8iUVqo3W9cJoUC2YmAQdVUL98dI4rzK7QqEosJBVldAApg9pQ3RMKis2nrbeUuvX7ecZ06sKNSqVwqx0vaXmN2g1Kjo2rsi6f2+ubnj4npsFFZvVDOH3EH8uxVluxVc2yJu2DcJIyLDctizYx76+JSRY9u0GB9+c4FAqFHRsXJG/9ly0PnZfU9u8feq+GqhVSo6cT6RMsIHubYtX8Cuv9oWFwmT5Gbty/goh7g5Fds544CXjgXAPioScnA3OO2eDkruQqe1DlncfMOsJSnmMTO/+ZGl7gVlHUEoPMr0HkqV9EoUpmcDUZ8jwfolsbXcUpgQCU/uR4fMK2V6PoDDFYlYWvMVOp9MxadLbpKamUrVqNQ4fPsjixcvIyNDx/POD2bFjm83r33vvHQYNGlrg7R1TUpIxGAxotVoWLJjHhQvnSUpKIjU1hVdffZNGjRqTnZ3N1Kkf8N5771jPa9++I23aWAqYx8bG4O9vux1TpVLxzTfLUavVJCUlYjKZ0GjUnD59KmeVxMsYjUYGD36Z+vUbFNhvUTwy2eBCSv9+HyA1G/Lzeq/G7Dgay/W0bJrXCrHWGiisuhFlqOuEvY7+Phqbu2K4Mo1aiZdGaZ3UAcuWkzD98wSm+uW7591VPPNAJLXDS3MhNpV6VcvYFEP00qgY/2wz9p2Kx2A00SQyBB+tmqhVltn3VVH29W3gQMsWmdtrJjx9fw3Cw/w5eyWFmpVL5don76VR0et+ywRj1KoubNpWvFjya19AYKrlZ+zq+SuEKHmBB3PGg2LWbBDibgscmJOzLlKz4aefllOtWg1efPFlDh06wM6d/wCWrQgVKlTMNdkwfvy7eV5n2bJvWbduLbGxsYSEhDBmzHjrtgat1ptZsz7n7NkzTJo0jsWLv6Nhw8Z5XketVjN58gQ2b97I5Mnv5/n8pk0b+Pjj92nd+l68vX3w9vbmmWf60a1bFBcvXmDUqOF8++3KPO+YKOwj76gLySjvXnuy7jaNWkW7hnKbp5KW173ld1x5hkcqu37lY4VCQdOaITTNp3iXRq3K9WF/SONXHNL2kCHZeT6uVChoU788berfeTWNPbHk176ADB/H/IyFEO4vI1zGA+FeMoYUnLM2E+kKzW3HvjbHZmXQbcfBtx3fuXDw1atXaNnSUtS+QYNGeHkV7c5iN9zYRnH8+DEmThxL5cq3rEZt1gKAatWqk5iYcMdrjRs3iYSEeAYPHsA33yzHx8e2wG6HDp1o164jU6ZM5I8/fuPBBx+mUqVKKBQKqlQJJygoiISEeEJDHXOLaXGT3DPHheg6j0PXeZyzwxD/cZVC/Gl8yx0fvNRKIqo/Q7bXI06MquR0jniEzhH2961zZyOdOxvv/MISisUR7XuqbK9HPDZ/hRBFkx3yCNkhMh4I95Hd+RGyO7tOzlavHsnBgwcAOHPmNNnZ9n3ZUbt2Hfr2fZYJE8ZiMlmKt584cQyAs2dPExKS/91f/vjjN5Ys+QoAb29vlEqlzZdm6elpDBs2mOzsbJRKJT4+PiiVSn777Rc+/XQmAPHxcaSnpxMcnP/dzkTxycoGF6K8dBgAU6X6To5E/Ne9/ER99p2MJzE1iyaRZSkXmAKmzELNeLubWJ3llp+hvvb1LTbW8sstNLT4NRPsicUR7Xsqhcnyvnpi/gohikaRlTMeaGU8EO5BEZuTs6GukbPdukXxv/+9y8svDyqwDsMNhanZ0LVrFOvX/8VPP60A4OTJE4wYMYSMjAzefDP/L2I7dOjE1KmTePnlQRgMBoYPfw2t1ps1a1YD0KVLNx588GFefnkQarWa6tUjeeihRzCZTEyZMpEhQwaiUCh46613ZAtFCVGYzUUo6e/iEhLSbKrPu5vgRZbCcVKzwb2FhAQQF5fq7DAcKii5C+CZe96jVln6Zm/Nhqgoy5I9e2om2BPL7e17Yh4WlyfnrzuQXBSuIiQkgOzf2wFSs0E4T1HHxKConN9hOTUbYmKiCQtzja2tWVlZ9OnTgxUrVjvsmgsWzCM4OLjAW2feyenTpzh+/Chduz7msLjc3e15o1QqCA72L/F2ZQrHhegqD3d2CELkSecz0tkhlJjhTR3Tt+HD7a+ZYE8sjmjfU3ly/gohikYXIeOBcC+64ZKzRRUYGMijj7rHLUM9naxsEMLB5Fs84QokD4WrkFwUrkJyUbgCe/PQlVY2CPfhrJUNUiDShajP70Z9frezwxAiF6XxEkqjZ27vuZx6icup9vft8mUFly/nvpPH3YrFEe17Kk/OXyFE0SgzL6HMlPFAuA/l5UsoL0vOCvck2yhcSNDGxwGp2SBcT0DaYMAz97y/vN7SN3trNrz8srflOnbUbLAnFke076k8OX+FEEUTcDhnPJCaDcJNBLyck7OrJGeF+5HJBheiC3/d2SEIkSedzxvODqHEjGzmmL6NHGl/zQR7YnFE+57Kk/NXCFE0uqoyHgj3ohspOSvcl9RsEMLBZE+ocAWSh8JVSC4KVyG5KFyB1GwQziB3oxCoT20BwBDZzsmRCGFLaTwHgElV1cmRON75ZEvfIoLs69v585Z6CRERxZ/wtCcWR7TvqTw5f4UQRaPU5YwHvjIeCPegPJ+TsxGukbPZ2dlMnTqJK1cu4+fnx2uvjaZy5Sps2vQ3c+bMpFy5UAAGDnyRWrXqMGbMa2RlZfHGG2OpUSOSAwf2c+jQfvr2HZDn9X/++UfWrv0dhUKB0Whg0KChNG3anDVrVhMdfZ4hQ16xvnbv3j38/PNKJk36n8P6t2DBPP7660/Kli0LQEpKMvff/xDPPjuwwPMyMzMZOXIoY8a8Q3h4BABLlnzF1q2b0ev1PPFED7p2jbK+PiEhngkTxlqPT58+yUsvDbPe8nPTpr/5++91TJw4xWF9cwaZbHAhQdueASAhUmo2CNcSkPYy4Jl73l/929I3e2s2vPqq/TUT7InFEe17Kk/OXyFE0QQczRkPpGaDcBMBr+bkrIvUbFi9+id8fHyZP38RFy6cZ8aM6Xz88WxOnDjG0KHD6djxfutrN23awL33tqdx46b8+uvPjBjxOsuXf8f48e/mee116/5k9+6dfPLJXNRqNVeuXGbYsMEsXLj0bnUPgF69els/9GdnZ9O3b0+6d3+c0qXL5Pn648eP8sEH/yMu7pr1sb1793Do0EHmzl1AZmYm3323xOac4OCyzJ49H4DDhw8yf/5ndOtmqd83c+aH7Nr1D5GRNUuie3eV3I3ChaRXf5v06m87OwwhctH5jkXnO/bOL3RDb7YYy5st7O/bm29m8+ab9tVNsCcWR7TvqTw5f4UQRaOrNhZdNRkPhPvQvTkW3Zv552zUqi4sO275MK436ola1YXlJ5ZZztXriFrVhVWnVgKQkpVM1Kou/HrmFwASMhKIWtWFP8//DkCsLvaO8Zw7d45WrdoAUKVKBOdzVl6cOHGc3377haFDX+DTT2dgMBjw8fElKyuLrKwsfHx8+OuvP2jf/j60Wm2e1/755x/p3/851GrL9+EVKlTkq6+WUqpUqTvGtXbt77zwQn+GDBnI1KmTMBgMPP98X5KSEjEYDDz0UAdOnDgOwPPP9yE7O5v33nuHmJiYAq+bkpKMwWBAq9WyYME8Jkx4i+HDX+K553pz4MB+4MZqjw+oUuXmNoVdu3ZQvXoNxo4dxejRI2nbNu+V62azmRkzPmDUqDGoVCoAGjRoyKhRb92xz+5AVja4kMx2Q5wdghB50mvudXYIJaZNRcf0rU0bo/3XsCMWR7TvqTw5f4UQRaMvI+OBcC/6Nq6Vs5GRNdm+fQvt23fkyJHDxMfHYTQaadHiHtq160iFChX54IOp/PzzSh5/vCf//LONn3/+kYEDX2TOnJk8//yLTJ8+hYoVK9Gnz7M2146Pj6NChUo2jwUFlbpjTMnJ11mwYB5ffbUUX18/Zs36iJ9/Xkm7dh3YufMfypULpXz5CuzZsxMvLy8qV66Cl5dXvissli37lnXr1hIbG0tISAhjxozH19cPAK3Wm1mzPufs2TNMmjSOxYu/o2HDxnnGFBNzlenTZ3L16mVGj36Nb79diUJhe5vybds2U7VqNapUibA+dv/9D7F375479tsdyGSDC9Ec/QsAfd0HnRyJELZUxlMAGFWRTo7E8U4nWfpWo7R9fTt92vLLo0aN4tdMsCcWR7TvqTw5f4UQRaNKzxkP/GQ8EO5BdTonZ2vknbO3br3UqDQ2x74aX5vjQG2QzXGwT7DNcahv6B3jefTR7kRHn2Po0Bdo0KARtWrVRqVS8eijjxEQEABAu3Yd2LhxA0qlkhEjLHfbW7LkK3r2fIbFixcwcuSbLFw4jwsXom1WA4SFlefatRj8/WtYH9u58x+qVy/43+uVK5epWrWadUKgUaOm7N69gyee6MnixQsJDQ1j8OChrFixDJPJTIcO9xd4vRvbKI4fP8bEiWOpXLmK9blmzVoAUK1adRITE/K9RmBgEFWqRKDRaKhSJQIvLy3Xryfl2orx55+/07NnrwLjcWeyjcKFBO56jsBdzzk7DCFy8U8bgX/aCGeHUSJGbRrBqE32923UKG9GjfJ2WiyOaN9TeXL+CiGKxv/YCPyPyXgg3If/qBH4j3KdnD1+/CjNmt3D3LkL6NTpASpUqIjZbObZZ3tx7ZplG8aePbupVauO9ZykpEQuXIimUaMmZGVlolQqUSgUZGba1pl69NHuLFq0AIPBAMCFC9G8//5kVKqCP7KWL1+R8+fPkZFhud7+/XupXLkK1arV4MqVyxw7doTWrduSkZHB1q2baN26baH6Wrt2Hfr2fZYJE8ZiMpkAOHHiGABnz54mJCQk33MbNmzMzp3bMZvNxMfHkZmZQWBgUK7XHT9+jAYNGhUqHnckKxtcSFrNvJfyCOFs6b4TnB1CiRnb0jF9Gzs2y/5r2BGLI9r3VJ6cv0KIokmvIeOBcC/pY10rZytVqsIXX4zl668X4u8fwFtvjUehUDBmzHjefvsNtFpvIiKq0r3749ZzFi9eYL2bw+OP9+T114cRGhpGjRq2BRAfeKAzCQnxDB36AhqNBpPJyPjx7+ZbmPGGUqVK8fzzLzJ8+IsoFEoqVarMSy8NA6BJk2ZcvXoFpVJJ48ZNOX/+LD4+PgC89947DBo0lLCwsHyv3bVrFOvX/8VPP60A4OTJE4wYMYSMjAzefHNcvue1bduOAwf2MmjQs5hMJl57bTQqlYo1a1YD0KVLN5KSkvDz88u1tcKTKMxms8esuU1ISMNk8pjuCDcl9/EWrkDyULgKyUXhKiQXhSuwNw9jYqIJCwu/8wuFwy1YMI/g4GDrnSqK4/TpUxw/fpSuXR9zYGR3dnveKJUKgoP9S7xd2UbhQrwOrsbr4GpnhyFELirDUVSGo84Oo0QcSzjKsQT7+3bsmJJjx+wbUu2JxRHteypPzl8hRNGo0o6iSpPxQLgP1bGjqI5JznqKwMBAHn20u7PDuGtkG4ULCdhruRtFQsNuTo5ECFv+6aMASA5yjXs8O9JbWyx9u7VAUrGu85blNk6rVmXc4ZUlE4sj2vdUnpy/Qoii8T+eMx40l/FAuAf/t3JydpXkrLMNHPii3dcoV+7ORTg9iUw2uJC0uu87OwQh8pTu956zQygxE1o7pm8TJthfM8GeWBzRvqfy5PwVQhRNeqSMB8K9pE+QnBXuSyYbXEjWPX2cHYIQeTKomzk7hBLTJNQxfWvSxGT/NeyIxRHteypPzl8hRNEYgmQ8EO7F0ERyVrgv2eDrQrz2rsRr70pnhyFELirDQVSGg84Oo0Qcij/IoXj7+3bokJJDh+wbUu2JxRHteypPzl8hRNGoUg+iSpXxQLgP1aGDqA5Jzgr3JCsbXEjAQcs9dBOaPunkSISw5Z8+BvDMPe/jt1r6Zm/NhvHj7a+ZYE8sjmjfU3ly/gohisb/RM54IDUbhJvwH5+Ts1KzQbghmWxwIakNP3F2CELkKc1vmrNDKDHv3euYvr33nv01E+yJxRHteypPzl8hRNGk1ZLxQLiXtPc8L2ejo8/zwQdTmT17PhMmvMW4ce+i0Wjsvu6wYYPJyspEq/XGbDaTmprCkCHDad26bYHnXbp0kbFjR/H1198D8MknH3Hq1AkAEhMT8PcPYP78RdbXGwwGJk+eQEzMVZRKJaNHjyM8PIJLly4yZcpEFAoF1apV57XXRqNU/rdXncpkgwvJlhUNwkUZ1Q2dHUKJaVDWMX1r0MD+mgn2xOKI9j2VJ+evEKJojAEyHgj3Ymzg2Tk7adL/HHq9cePeJTw8AoALF87z9ttvFjjZ8Mcfv7F8+TKuX79ufWzEiNcBy6TCkCEDGT16nM05//yzFaPRyOefL2T37h3Mnz+HKVM+4NNPP2bQoCE0bdqcDz6YypYtm+jQ4T6H9s/dyGSDC9HuWgpIoUjhetSGfwHPLLS3L9bSN3sLRe7bZ5m5tqdQoz2xOKJ9T+XJ+SuEKBp1cs54IIUihZtQ78vJ2XwKRUZF+dCrl55evQzo9dCzpw99+ujp2dOATge9e/swYICeqCgDKSnQv78PL7ygp2tXAwkJCgYO9GbIkGw6dzYSG6sgNNRcYDxr1qxm27bNZGVlkZAQT8+ez7BlyybOnTvDyy+PoF27jmzYsI7vv1+KUqmkYcPGDBnyCvHx8bz77jjMZjNlygRbr9ejRzeWLl3B5csX+fTTGZhMJq5fv86oUWNo0KARvXo9ToMGjbhwIZoyZcowefJ00tPTmDZtMlOnflBgrDExMQQEBAKWVQ/h4RFER58HYNKkqQQHlyUgIJDZs+fz9NNRuc5fsWIZ99zTiurVa9g8XrlyOEajEZPJRHp6Omq15SP1iRPHaZLzc2rVqg27du2UyQZnByBu8j86GpDJBuF6/NLHA565533SP5a+2VuzYdIk+2sm2BOLI9r3VJ6cv0KIovE7lTMeSM0G4Sb8JuXkrAvVbNDpdMyYMYd16/7k+++/Zf78Rezb9y/Ll39Ho0ZNWLhwHl9+uQRvb2/ee288u3fvYMuWTTzwQGe6d3+c9evX8tNPK2yuee7cWYYNG0n16jVYu/YP1qxZTYMGjbhy5TKffDKX0NAwhgx5nmPHjlK/foN8JxomT34HlUpNbGwM9eo1YOzYCdbn6tdvyBtvjOXHH5ezZMlXvPrqG7Rt2y7P6+j1en7++Ue++OLrXM/5+PgQE3OF3r17kJx8nenTZwBgNptRKBQA+Pr6kZ6eVqz315PIZIMLSW0619khCJGnNL8PnR1CiflfO8f07X//s79mgj2xOKJ9T+XJ+SuEKJq02jIeCPeS9r+Cc/bWLxk0GttjX1/b48BA2+PgYLPN8Z1WNdwQGVkLAH//ACIiqqJQKAgICCArK5tLly5y/XoSo0YNBywTE5cvX+LixQt06/Y4AA0aNMo12VC2bDkWLfoSrVaLTqfDz88PgKCgUoSGhgFQrlwo2dkF/71zYxvFqlUrWbfuT+u5AM2atchpvyFbt24q8Dp79uykceOm+Pv753ruhx++5Z57WvPSS8OIjY1hxIghLF68zKY+g06Xnue5/zUy2eBCsht2c3YIQuTJqK7r7BBKTJ1gx/StTh37ty/YE4sj2vdUnpy/QoiiMfrLeCDci7GO6+XsjW/v81K+fEXKlQtl5szPUKvVrFmzmsjImkRHR3PkyEEiI2ty7NjRXOd98skHvPPOZCIiqrJgwTyuXr1yx7YKEhX1JIcO7Wf+/M94+WXLHf9OnDhGuXKhHDx4gKpVqxV4/p49u2jVqk2ezwUEBKJSWT5GBwYGYTAYMJlMREbWYu/ePTRt2pwdO7bTtGnzYsXuSf7b5TFdjHb7QrTbFzo7DCFyUet3otbvdHYYJWLX1Z3sump/33btUrJrl31Dqj2xOKJ9T+XJ+SuEKBr19Z2or8t4INyHetdO1LvcJ2dLly7N00/3YdiwwQwa9Cw7dmyncuVwnn12IJs3b2TYsMFs27Y513kPPfQI48ePZujQF7hwIZr4+Lh820hJSWbs2DfuGMuIEaNYt+5PTp06CcCaNb8ybNhg/vlnK/37P1/guRcuRFOhQkWbxyZMeIuEhHieeqo3J08eZ+jQFxg+/CUGD34ZHx8fhg17lYUL5/Pii8+h1+vp2PH+O8bo6RRms7lw62XcQEJCGiaT+3YneFElABIGXHJyJMIeISEBxMWlOjsMhwpK7gJ45p73qFWWvtlbsyEqysdyHTtqJtgTy+3te2IeFpcn5687kFwUriIkJIDs3y37s6Vmg3CWoo6JQVE5v8NyajbExEQTFhZeIrF5smHDBvPGG2Otd6oojnnz5tC///P4+Pg4LrC75Pa8USoVBAeX/DYP2UbhQlLu+crZIQiRpzT/T5wdQon5sINj+vbhh5n2X8OOWBzRvqfy5PwVQhRNWh0ZD4R7SftQctZVPPbYk2450eBMsrJBCAeTb/GEK5A8FK5CclG4CslF4QrszUNZ2SCKw1krG2SDrwvx3jIX7y1yRwrhejT6rWj0W50dRonYfnkr2y/b37ft21Vs365yWiyOaN9TeXL+CiGKRpO4FU2ijAfCfWi2b0WzXXJWuCfZRuFC/M5MASCz3RAnRyKELV/dVMAz97xP323p26qK9vVt+nQvy3XsqNlgTyyOaN9TeXL+CiGKxvdsznhQRsYD4R58p+fk7CrJWeF+ZLLBhSS3/c7ZIQiRp1T/Oc4OocTMvM8xfZs50/6aCfbE4oj2PZUn568QomhS68p4INxL6kzJWeG+ZLLBhRgi2zk7BCHyZFJVdXYIJSYiyDF9i4iwv16MPbE4on1P5cn5K4QoGpOvjAfCvZgiJGeF+5LJBhfi8/cMADLuG+nkSISwpcn+GwC9131OjsTxNl209K1DZfv6tmmTpV5Chw5Gp8TiiPY9lSfnrxCiaDQJOeNBsIwHwj1oNuXkbAfJ2SlTJnLy5HECAgIBSE6+Tq9efXn00e4FnpeUlMSQIQNZvPg7tFotKSnJvPvueNLT0wkKCmL06HGULl3G+vodO7bzzTeLrMcHD+7n66+/Jysriw8/nIpG40VkZE1GjBiFUiklEAsikw0uxDf6IwAykMkG4Vp8Mz4AINkDP6zN+NfSN3snG2bMsNRM6NCh+DUT7InFEe17Kk/OXyFE0fieyxkPZLJBuAnfGTk5K5MNAAwZMpxWrdoAkJKSTL9+T9GlSzcUCkWer9+58x8+//xTEhMTrI99/fVXNGzYmP79n2f37p3MmzeHMWPGW59v1aqNtY1vv/2aBg0aERFRlYED+/Hqq6No0KAR8+d/xl9//UHnzl1KsLfuTyYbXEhyx5+cHYIQeUr1n+/sEErMnPsd07c5c+yvmWBPLI5o31N5cv4KIYomtb6MB8K9pM4pOGejonzo1UtPr14G9Hro2dOHPn309OxpQKeD3r19GDBAT1SUgZQU6N/fhxde0NO1q4GEBAUDB3ozZEg2nTsbiY1VEBpa8LbMNWtWs23bZrKyskhIiKdnz2fYsmUT586d4eWXR9CuXUc2bFjH998vRalU0rBhY4YMeYVr12L58MNpZGdbzhs0aCjt23fk2Wd70bhxU86cOQ3AtGkf4+/vz8iRLzN9+kw0Gk2+sSQkJODlpUWhUDBlykTMZjPXrsWSkaFj3Lh3CQ+PQKlUMHPmZwwc2M963vnzZxk8eCgADRs2YsaM6Xle/9q1WP78cw1ffPE1AHFx12jQoBEADRo0YuvWTTLZcAcy2eBCDBEtnB2CEHkyqSo5O4QSUzHAMX2rWNH+mgn2xOKI9j2VJ+evEKJoTN4yHgj3Yqroejmr0+mYMWMO69b9yffff8v8+YvYt+9fli//jkaNmrBw4Ty+/HIJ3t7evPfeeHbv3gEo6NWrD02bNufQoQMsWDCP9u07kp6ezgMPdGbkyDeZNGkcO3Zs44EHOjNjRt6FMefOncXXXy8kJuYqERHVeO+9adbnKlasxLhxk/jnn6189tknvP/+DFq0aJXrGpGRtdi6dTM1a9Zm69bNZGbm/YXN998v5amneuPlZVk9WqFCRfbt+5cmTZqxbdsWMjNlNemdyGSDC/FZb5lVy7j/TSdHIoQtTfZfAOi9HnRyJI634YKlb52q2Ne3DRssNRM6dSp+zQR7YnFE+57Kk/NXCFE0mvic8aCsjAfCPWg25ORsp7xz9tZbXms0tse+vrbHgYG2x8HBZpvjO61quCEyshYA/v4BRERURaFQEBAQQFZWNpcuXeT69SRGjRoOWCYmLl++RMOGTVi8eAG//fYzoMBgMFivV7Om5XrlyoWSnZ1dYNs3tlH8889W5s79lAoVbk7GNG1q+eK2fv1GzJr1cb7X6NdvADNnfsjLLw+ideu2hIaG5nqNyWRi27at1hUQAGPHvsPMmR+xaNGXNGzYGC+v/FddCAuZbHAhvhdnAZCBTDYI1+KbYSlemuyBH9Zm7bX0zd7JhlmzLLPenToVf5bbnlgc0b6n8uT8FUIUje/5nPFAJhuEm/CdlZOz+Uw2OEN+9REAypevSLlyocyc+RlqtZo1a1YTGVmTL7/8nG7domjdui2//fYLv//+661XLHIMrVvfy+HDh5g+fQqTJ78PwIkTx2jUqDGHDh2gatXq+Z67f/8+unWLokGDRmzcuN66NeJWZ8+eITw8HK3W2/rY9u1bmTDhPYKCSjFjxnRrXQeRP5lscCFJD/zh7BCEyFNKwFfODqHEzHvIMX2bN8/+mgn2xOKI9j2VJ+evEKJoUhrIeCDcS8o898rZ0qVL8/TTfRg2bDBGo5Hy5SvQqdOD3Hff/cyZ8wnffLOIkJByXL9+vcDrFKZmw4ABL/Dcc33Yvn0rYLmLxNatmzCZTIwdOyHf86pUCWfyZMvzZcuG8NZbluKQn3zyEV26dCUyshYXLkTbrJoAqFSpCiNGDMXb25smTZrRuvW9hXlL/tMUZrPZYzb6JiSkYTJ5THeEmwoJCSAuLtXZYYj/OMlD4SokF4WrkFwUrsDePIyJiSYsLNyBEXmGKVMmcv/9D9m12mDFimW0atWWSpUqOzAy13B73iiVCoKD/Uu8XVnZ4EJ8/5wMgK7zOCdHIoQtr+zfAcj2esTJkTjen+ctfescYV/f/vzTUjOhc+fi10ywJxZHtO+pPDl/hRBF4xWXMx6EyHgg3IPXnzk521lytqTde29HwsLCnB2GR5HJBhfic/VzAHTIZINwLT4ZnwKe+WFt7n5L3+ydbJg711IzoXPn4tdMsCcWR7TvqTw5f4UQReMTnTMeyGSDcBM+c3NyViYbCvT22xPtvoZMNDiebKNwIcrYUwCYQiOdHImwhycu01SYEgAwK4OdHInjJWRY+hbsY1/fEhIsxY2Cg4s/BtkTy+3te2IeFpcn5687kFwUriIkJID4y+cBMHvJeCCco6hjoiIh53dYsCVnZRuFKA7ZRiFkkkG4LE/+kGbvJIP1OnZMMlivYUcsjmjfU3ly/gohikYmGYS7uTHJIIQ7kskGF+K7xlIJVdflPSdHIjyBOduynF7h5WP3tbx0K9Cf20P62VKoytfCq/GjKNRedl/3btGf3Irh4mGUZSrh1eBBFGqt9blfz/wCQNfq3e1q49dfLcNp166GO7yygGvYEYsj2vdUXlmW9zVba9/PWAjh/rxic8aDUBkPhHvw+jUnZ7tKzgr3I5MNLsTnmuXWNjpkskEUn9lsJmvbN+iPbQQFaOrej7b1MwXeE/lOtNfew0uVSsrV9hivHsesS8a7/QCHxVySsvb/Rvau5ZaDM2CKO4vPQ8Otz395yFIrxd7Jhi+/tNyayZ4P+/bE4oj2PZVPpuV9lckGIYTPxZzxQCYbhJvw+TInZ2WyQbghmWxwIUnd/3F2CMIDGKL3oj+63nJgBv3htagr1UNdpVGxrmc2mbj6d0Mwm6yP6c/udJvJBsOJLbbH5/dhzkxD4W3Zp/b1I985pJ2vv7a/MKM9sTiifU+VEuCYn7EQwv2lNJLxQLiXlK9dK2ezs7OZOnUSV65cxs/Pj9deG03lylXYtOlv5syZSblyoQAMHPgitWrVYcyY18jKyuKNN8ZSo0YkBw7s59Ch/fTtOyDP6//884+sXfs7CoUCo9HAoEFDadq0OWvWrCY6+jxDhrxife3evXv4+eeVTJr0P5trfPLJRzz9dJ98Cz726NGN0NAwFAoFJpOJjAwdo0ePo3btugX2/ciRw8ydO4vZs+cDcOrUCT744H+oVCoqV67CmDHjUSqV1tcbDAYmT55ATMxVlEolo0ePIzw84o7neRKZbHAhpjKed09XcfeZEi7lesyYeKnYkw0KpRK05TCnJVgfUwaULXZ8d5vCJxCSY24+oNHCLVtAArVBDmknMNAB17AjFke076nMSsf8jIUQ7s+skfFAuBdzoGvl7OrVP+Hj48v8+Yu4cOE8M2ZM5+OPZ3PixDGGDh1Ox473W1+7adMG7r23PY0bN+XXX39mxIjXWb78O8aPfzfPa69b9ye7d+/kk0/molaruXLlMsOGDWbhwqVFinHEiNfv+JqPP56NVmvZVrtz5z8sXDif6dNn5vv6pUsX8+efa/D2vrk9eeHCL3juuRdo3fpeJk0ax/btW7n33vbW5//5ZytGo5HPP1/I7t07mD9/DlOmfHDH8zyJZ06huCm/1W/it/pNZ4ch3Jy6cn3g1i0TCtSV6tl1zVIdKuAXHms58PJF27q3Xde7m7yaPwHWGg0KtC2etKk3serUSladWml3O6tWqVm1yr75W3ticUT7zmK4fBTdL1NJXzGO7MN/Ofz62qyVaLPs/xkLIdyfNmYl2hgZD4T70K5aiXZV/jkbtaoLy45bPozrjXqiVnVh+YllAOj0OqJWdbH+bZGSlUzUqi7WGlEJGQlErerCn+d/ByBWF3vHeM6dO0erVm0AqFIlgvPnzwFw4sRxfvvtF4YOfYFPP52BwWDAx8eXrKwssrKy8PHx4a+//qB9+/usH/Jv9/PPP9K//3Oo1Za/ZypUqMhXXy2lVKlS+cZz8eJFXn99OM8/35cFC+YBMGzYYKKjz3Pu3Fk+/HDaHfsUE3OVgIAAAPr27cn06VMYMmQgo0ePJCPDsnK0YsVKTJnygc15NWvWIiUlBbPZjE6Xbo37hsqVwzEajZhMJtLTbz5/p/M8idN6dunSJbp37069ejc/BLVs2ZJhw4ZZj0eOHMn777+Pl5f7FKKzh3fCtwCkM93JkdyZKTkG/dk9KH2DUFdv6TbFAks6brPJRNqx7WRdOIu6SiNUZSPsvqYp5Rr6s7tQeAegqdHKprhhrtemJWC4cgJ1rXsxxZ0DhQqvRo+gKhuBKTUe/ZldKLS+lutovAsdg5//enwbp5Hl3RN1teaoK9Sxu19FYTaZMJzbgyn5KuoqjVGVzfuWT+ZsHfpT/4AhG3WNVij9SqP0K42mQWfI1qGp0xFVmUo25yw6sgCAqMgn7Ypx0SJLzYSoqOLXTLAnFke0f4MpNc6SK97+aKq3QqHJP+eKdf30JAynd4BGi6pCXTL+mAFGPQBZ25ei8C2FploLh7XnnWl5X7O09v2Mnc10/Sr6c3tQ+pVBXf0eFCpNibVlNuoxnNmFKT0RddVmqEpVKLG2hLhbzCYj2lMzwJCNzuseVLKiVLgB70U5v8OiXON3WGRkTbZv30L79h05cuQw8fFxGI1GWrS4h3btOlKhQkU++GAqP/+8kscf78k//2zj559/ZODAF5kzZybPP/8i06dPoWLFSvTp86zNtePj46hQwfbvtKCgUgXGk52dzf/+9yEmk4knn3yUgQNftD5XtWo1Ro0ak+d5r702jOzsLOLj42nZsjUvv/wqAJmZmTz00CM0btyUzz77hJ9/XkmvXn3p2PF+rl69YnONSpUq8/HH01m8eAF+fv40adLM5nkfHx9iYq7Qu3cPkpOvM336jEKd50mcOo1So0YNlixZku/zM2bMuIvROF/Ck/udHUKhGK+dRbf6f9YPB6qTW/Ht9paTo7qzuxF35uYFpJ3cBkD2v6vwfmAYmqrFH0CM8dHofpkChmwA9Mc34/vY2ygUuRclma7HkP7TJNBbZmCVZSrh+/h4FEo1xutX0P30LugzLdc5uh7fxyeiUKoKFUfcmWfJ3rcas3EzhhObMbfujVeDh4rdr6LK3PgFhtOWmibZ/67C58HhqCOa2LzGbMhG99O7mHK2TGTt/xXvDi+Quf4z68/clHABn25v2RTL/PbRFQ6J8dtv7a+ZYE8sjmgfwJh4Gd3P792SK3/jG/WOZTuNA5hS4kj/aSJkpQOg8C1t/flYY7h4yKGTDcmBjvkZO5Mx5hS6X98Hk2UySXVqO76PvlFi7WX8MRPj5SMAZP/7Mz5dR6MOk9szC/d27aeP0Z2IAMB8egI+D49EXbmBc4MS4g6Svy34d9iqqDXW/9eoNDbHvhpfm+NAbZDNcbBPsM1xqG/oHeN59NHuREefY+jQF2jQoBG1atVGpVLx6KOPWVcHtGvXgY0bN6BUKq1bGpYs+YqePZ9h8eIFjBz5JgsXzuPChWiqVLn5BVJYWHmuXYvB37+G9bGdO/+hevX8f/9Uq1bd+sW0SlX4j7Y3tlHMmzeHK1cuU7p0GQDUajWNGzcFoH79RuzYsS3fa3zyyUfMmfMF1apVZ+XKH5g9eyavvz7a+vwPP3zLPfe05qWXhhEbG8OIEUNYvHjZHc/zJC61jWLnzp307NmT3r17s2rVKjp16kRWVpazw7p7Aspa/nNx2UfW2Xw4MF49gfHaGSdGVDjZR9bnjjv2tMOub9IlYzi5/eYDZjP6g3/YdU390Q3WiQYA07UzGK+ezPO12cf+tk40AJgSL2G8eCjnOhutHx4BTAkXMV46XKgYzGYzWQf+xmy8OYBnH1hTwBmOZdJdt3wLfjMgsg/lfl8N0fusEw0AZKWTvedH2595zElMt+Wqr8YXX42v3XH6+lr+s+sadsTiiPYhJ+duzZX48xivHLX/wjeuf3yTdaIBwKxLyvUaZZmKDmsPAIWv5T83ln34L+tEA4Dx8hGM8dEl0pYxPto60QCAyYD+8NoSaUuIu8WUEkf68R2YzWrMZjWYTWQf+tPZYQlxZ476Be8gx48fpVmze5g7dwGdOj1AhQoVMZvNPPtsL65ds2zD2LNnN7Vq3VwFm5SUyIUL0TRq1ISsrEyUSiUKhYLMTNsvSh59tDuLFi3AYLD8vrtwIZr335+MSpX/R1Y7brYGwKBBQ0hIiOfHHy13LjMYDJw6Zflb+9ChA1StWj3fcwMDA/Hz8wOgbNkQUlNTbJ4PCAjEz88/57VBGAwGTCbTHc/zJE5d2XD69Gn69etnPe7ZsydZWVksX275Yc+aNctZoTmF/6pXAUiLmunUOO4oz3/Vdv5LvxvyDNuB820KhaUN822P2XfRvNvJr/38HivouULwr3QeDNmkXaySc66z5yntyMHb+n1jX2PPWr3simj5cstw2rNn8bcx2BOLI9oH8skVB/87uY26RisM5/aCUY86oimaOvc5rj1Am2V5X7O09v2MncrOf8NFayuvn7cbjPFCFCQnhf39LgCQll6l5P4NCeFA2uU5v8N6usbvsEqVqvDFF2P5+uuF+PsH8NZb41EoFIwZM563334DrdabiIiqdO/+uPWcxYsX8OyzAwF4/PGevP76MEJDw6hRo6bNtR94oDMJCfEMHfoCGo0Gk8nI+PHvWlcdFNW5c2dZufKHfLdSANa7RAwbNogOHSx/fyxdupjY2BhCQ8MYNGhIvueOHj2eiRPHolKpUavVjB49DoAJE95i+PDXeeqp3vzvf+8ydOgL6PV6Bg9+GR8fn3zP80QKs9lsvvPLHO/SpUu89tpr/PDDD9bHdu7cybfffssnn3wCQKdOnfj999/zLSJyu4SENEwmp3THIYIXWfYoJQzIfTcBV2KMP4/ul6nWb9xVFevi+6jrF7bMFXeFOvh2deySpczNC9Ef32w5UCjxeegV1OFNCj6pAMbEi+h+nmL9plkVVjPXNoAbTMmxpK961/qtsTI4HN/H30GhVFm2WKx6F7J1ludCquL72LhCb6MIvNwSU2ocVzdbKuVq2/bFq94Dxe5XUWVsXIDhZM4tLBVKfDqPyHV3Dcs2ikmYki5bXuYdgLbjC2Sum1PgzzxqVRfAdhlicURFWaoTr1pV/O0M9sRye/shIQHExaUW+TqWLTfv3dyOU66aJVccNOFgSo1H99MkzJmW2CzbfSaAyYjZqEfpHeCQdm4VlGx5X5OD7t6KHEczXjuDbvW0m9vAKjfE95HXSqw93e8fY7x40HKg0uDbdTSq0BoFn5SP4uaiEI5m2voFgYmWW+RdvXYfPg+/ZncBZSGKqqhjYlBUzu+wVZbfYTEx0YSF5V27StivR49uLF26otCfP/Myb94c+vd/Hh8fnzu/+C65PW+USgXBwf4l3q7LTTYsW7bMWqvhvzbZQJblgyBa11kqlR9TahyGc/+i8C2FumpzFEXYI+VMN+MOQl21hcPjNptN+F0/SVL0WdRVGuYqRlgcprQEDGf3oPAJsLzXBRS1NOmuY8gpAqmu1sKmmKQpPQnD2d05z91TtOKYZj2Gq8cxXotGHVYL1V3eu202mzBGH8B4/aql8GY+y+zN+kwMZ3ZhNmShrt4SpU/gHX/m+pwPbxo7i+3pc3ZraOy4jD2x3N6+PR/wTGmJGM7tRqH1z8kjxxZSNemSMZzdhUKttRRqdXABylzMOW+OouQKKt4NppRrGM7/i8KvDOqqzVAoS27cNZsMGM79izk9EXVEM5SB5Yp9LZlsEK6ibLAvV3dvwJxyDVVEcyl8KpyiyGPibb/gZbKhZDlisiEmJoawsDAHRmU/Z002uMcnxP8KN5hkuEEZEIJXw4edHUaRlXTcCoUSv5ot0JWu7bBrKv2D8WrYuXCv9S2Vb+FGpV/p4hd1VGhQV2iAuoJzCmkpFErUEU1QU/AqEYXGG01t2/sU3+lnbu8kg/U6DriMPbE4ov0blP5l8GpQuJwr1vV9g/Cq/2CJXT8XN59kuEEZWA6vho/clbYUSjWa6i3vSltC3C0KpQpNtVbODkOIonHkL3hxRytWrLb7Gq420eBMTptsqFSpks2qBrDc+rJly5t/3GzYsOFuh+VU/j9ZbvuZ9vhsJ0cihC1tpuX+zVnefZwciePduDd1r9r29W3ZMstw2qtX8Wsm2BOLI9r3VJ6cv0KIotFeyRkPKsh4INyDdllOzvaSnBXux9lV3sQttMmr0CavcnYYQuTinbUU76ylzg6jRCw7vtT6Id+u6yzTsGyZfd8+2BOLI9r3VJ6cv0KIovG+shTvKzIeCPfhvWwp3sskZ4V7clrNhpLg9jUbhEeQ/cnCFUgeClchuShcheSicAX25qHUbBDF4ayaDbKyQQghhBBCCCGEEA4lBSJdSMCKwQCk9pjv5EiEsOWduQiATO8BTo2jJCw5ugiAfnUH2HedJZYtDP366Z0SiyPa91SenL9CiKLxvrQIgMxKA5wahxCF5b1kEQCZ/QY4NY47OXfuLNOnTwHMVKpUhdGjx6FW5/1Rc8GCefz115+ULVsWgJSUZO6//yGefXZgvtf/668/+OGH71CrVVSrVoPXXx+DUmn53jwpKZGBA/sxY8YcwsMjcp2bmZnJyJFDGTPmHcLDIzAajbz//mQuXowGFLzxxltUq1a82zuLgsnKBhfilfoHXql/ODsMIXLRZv+INvtHZ4dRIlad/pFVp+3v26pValatsm/+1p5YHNG+p/Lk/BVCFI029ke0sTIeCPehXfUj2lWun7Pz58/hxRdfZu7chQBs27alwNf36tWb2bPnM3v2fL78cgm//fYLSUmJeb42KyuTL76Yy6efzmPu3IWkpaWxfbvl+gaDgenTp+LllfetKo8fP8rLLw/i8uXL1sduxDZ37kIGDRrC/PmfFbm/onDkL1MXkvDcBWeHIESekgN/cXYIJWZld8f0beXKDPuvYUcsjmjfU3ly/gohiia5mYwHwr0kryw4Z4OSu5Cp7WO545JZT1DKY2R69ydL2wvMOoJSepDpPZAs7ZMoTMkEpj5DhvdLZGu7ozAlEJjajwyfV8j2egSFKRazMrTA9nQ6HZMmvU1qaipVq1bj8OGDLF68jMmTp6NSqdDr9SQkJODvb6kH8N577zBo0NACbweZkpKMwWBAq9WyYME8Llw4T1JSEqmpKbz66ps0aNCQzz9fiLe3NwBGo9E6uTB79kyiop5kyZKv8rx2dnY2U6d+wHvvvWN9rH37jrRpcy8AsbEx+PsHFNhnUXwy2SCEEEIIIYQQ4o5++mk51arV4MUXX+bQoQPs3PkPACqVipiYq7z66lD8/PypUSMSgPHj383zOsuWfcu6dWuJjY0lJCSEMWPG4+vrB4BW682sWZ9z9uwZJk0ax+LF31GmTDAAK1YsIyMjgxYtWrJmzWpKlSpFy5at851saNiwcZ6Pq9VqJk+ewObNG5k8+X173hJRAJlscCEBPwwAIPWpRU6NQ4jbeWd+AUCm9yAnR+J4Cw9b+vZ8ffv6tnChpWbC888Xv2aCPbE4on1P5cn5K4QoGu+LOeNBZRkPhHvwXpiTs8/nnbPJQWtuHig0tx372hyblUG3HQffdlzwqgaAq1ev0LJlawAaNGiEl5eX9bmwsPIsW/YTq1ev4tNPZzBu3KR8r9OrV2+ionpw/PgxJk4cS+XKVazPNWvWAoBq1aqTmJgAgMlk4rPPZnHxYjRTpkxHoVDw22+/oFAo2LNnF6dPn2Ty5HeYNu1jgoPL3rEfAOPGTSIhIZ7BgwfwzTfL8fHxKdR5ovCkZoML8UrbhFfaJmeHIUQu2uzf0Wb/7uwwSsTa87+z9rz9fVu7Vs3atfbN39oTiyPa91SenL9CiKLRxv2ONk7GA+E+tGt/R7vWdXK2evVIDh48AMCZM6fJzs4GYPTokVy8aNkS7uvray3eeCe1a9ehb99nmTBhLCaTCYATJ44BcPbsaUJCQgD44IOpZGdn8b//fWTdTjFnzhfWug81atRk3Lh3CzXR8Mcfv1lXQnh7e6NUKlEqFYV9C0QRyF+mLiTh+XPODkGIPCUHun5houJa1tUxfVu2zP6aCfbE4oj2PZUn568QomiSm8p4INxL8jLXytlu3aL43//e5eWXB9nUYejbdwBTp05Erdbg7e3N6NHjgcLVbOjaNYr16//ip59WAHDy5AlGjBhCRkYGb745jhMnjvPrrz/TqFEThg9/CYCePZ+hQ4f78rzemjWrAejSpVuez3fo0ImpUyfx8suDMBgMDB/+Glqtd9HfDHFHCrPZbHZ2EI6SkJCGyeQx3RFuKiQkgLi4VGeHIf7jJA+Fq5BcFK5CclG4AnvzMCYmmrCwcAdGVHxZWVn06dODFStWO+yaCxbMIzg4mKioHsW+xunTpzh+/Chduz7msLjc3e15o1QqCA72L/F2ZRuFCwlc1pvAZb2dHYYQufhkfIZPhmfeFmj+gc+Yf8D+vs2fr2H+fI3TYnFE+57Kk/NXCFE0Phc+w+eCjAfCffjM/wwfuTVjkQQGBvLoo92dHYZAJhtcilq3C7Vul7PDECIXjX4TGr1n1hPZcnkTWy7b37ctW9Rs2WLfzjR7YnFE+57Kk/NXCFE0moRNaBJkPBDuQ7NlE5otrpmzWq3WoasaAAYOfNGuVQ0A5cqFolBIDQZXINsohHAwWaYpXIHkoXAVkovCVUguClfgSdsohPuQbRRCCCGEEEIIIYTwCDLZ4EICv32KwG+fcnYYQuTikzELn4xZzg6jRMzZN4s5++zv25w5GubMsa9mgj2xOKJ9T+XJ+SuEKBqf87PwOS/jgXAfPnNm4TNHcla4J9ng60LUGQecHYIQedIYLLVEPPHmintiHVMnZc8eVc7/6Z0SiyPa91SenL9CiKLRJMt4INyLZo/krHBfUrNBCAeTPaHCFUgeClchuShcheSicAVSs8GxevToxtKlK9BqtdbHduzYTmxsDI899kSe53Tv3plffvnTIe0vWDCPv/76k7JlywKQkpLM/fc/xLPPDrzjue+/P4XAwECGDHkFk8nERx9N4/TpU2g0GsaMGU+lSpVznZOUlMSQIQNZvPg7tFotS5YsYufO7QCkpaWRmJiQZ9+cVbNBVjYIIYQQQgghhPAIrVq1uavt9erV23oHjezsbPr27Un37o9TunSZfM9ZtWolZ8+epnHjpgBs2bKR7Oxs5s37isOHDzF79gymTfvY5pydO//h888/JTExwfpYv34D6NdvAABvvvkqQ4cOd2jf7CWTDS4kcOnjAKT0+cnJkQhhyyfDMthl+Lzm5Egcb9ZeS9+GN7Wvb7NmeVmuMzzbKbE4on1P5cn5K4QoGp9zOeNBVRkPhHvwmZWTs8PzztmgPV3IrNCHrAp9wKQnaO9jZFbsT1b5XmDUEbSvB5mVBpIV9iQKfTKBB54ho/JLZId2R5GdQODBfmSEv0J2yCMosmIxa0MLjGfNmtVER59nyJBXyMrKok+fHqxYsZphwwYTHh5BdPR5ACZNmkp09Hm+/nohSqWShIQEund/nCeffIozZ04zc+YHmM1mgoKCeOutCZw8eZy5cz9Fo9HQvfvjPPzwowDMmvURDRo04r77HuC1117hnnta0qtXX95/fzJdunQD4KOPpnHlymUApk79kK1bNxEdfZ7nnx/MO++MIT09nczMTAYPHso997Sy9mXevDmkpaXx2mtv8vff6/n++6UolUoaNmzMkCGvsGDBPA4fPkhGRgZjxoxnyZKvGDRoKGFhYfm+PykpyRgMBrRaLQsWzOPChfMkJSWRmprCq6++SaNGjTl06ABHjx7msceesL5fBw/up2XL1gDUr9+A48eP5bq2Uqlg5szPGDiwX67nNm3aQEBAgE3/XIFMNrgQdeYJZ4cgRJ7UhoPODqHEHI53TN8OH7a/3q49sTiifU/lyfkrhCgadaqMB8K9qA+7T87Wr9+QN94Yy48/LmfJkq9o3/4+4uPjWLhwKWazif79e9Gp0wO8//5k3nrrHapWrcavv65i6dLFtGjRkuzsbL74YrHNNdu3v4/ff/+VNm3uJTU1hX//3c3TT/fhxIljvPnm2wA8+uhjNGrUmClTJrJ7907ruZcvXyI5OZmPPppFUlISFy9GW5+bPXsmSqWC118fTUpKMgsXzuPLL5fg7e3Ne++NZ/fuHQCEh1fl1VdHATB+/Lt59nvZsm9Zt24tsbGxhISEMGbMeHx9/QDQar2ZNetzzp49w6RJ4/joo0/56qsvmDr1QzZs+Mt6jfT0dPz8bm5rUCqVGAwG1OqbH9dbtMh/ImHJkkVMnDil4B+QE8hkgwtJHHjU2SEIkafUgEXODqHEzH9okWOuMz/T/mvYEYsj2vdUnpy/QoiiSW24yNkhCFEkqfMXFfh8cvM1Nw+UGttjla/NsVkTZHvsFWx7fIdVDbnZ1spr1qwFAA0aNGTr1k2AZQLCy8uy+rJatepcvnyJ6OhzfPTRNACMRgOVKlUBoEqV3LUoGjZszCeffMjevXvo2LETGzeu58CBfdSr1xCFQgFA7dq1AShTJpisrJt/D1WrVp3HHnuCiRPfxmAw0KNHLwASExM4c+YUFStaaiJcunSR69eTGDXKsgVBp9Nx+fKlfGO63Y1tFMePH2PixLFUrlwl13tSrVp1EhMT+PvvdVy/fp1Ro4aTmJhAZmYm4eER+Pn5odPpbr6zZrPNRENBzp07i7+/f541HpytUD3Izs62JokQQgghhBBCiP8eLy8vEhLiAThx4rjNcydOHKNcuVAOHjxA1arVADh16iRGoxG9Xs+5c2epVKkKVaqEM27cu4SFhXHw4H7r9ZRKRa72lEoltWvXZenSrxkx4nUSExP47LNZDB489JZX5T4P4MyZ0+h06XzwwSfEx8czZMjztG3bjjJlgvn449m88sqL7NixnVq16lCuXCgzZ36GWq1mzZrVREbWZPPmjXnGlJ/atevQt++zTJgwls8/X2h9Tzp37sLZs6cJCQmhZ89e9OxpmfS4sSWlS5dubNy4nm3btnD//Q9y+PAhqlWrUeh29+zZddfrVBRWoSYbnnzySVq1akXPnj2pWbNmScf0nxW0pCsAyf1+dXIkQtjy1b0PgM53tJMjcbyP9lj69npz+/r20UeWCdnXXy9+zQR7YnFE+57Kk/NXCFE0vmdzxoNqMh4I9+D7UU7Ovu4aOduyZRtWrVrJkCEDqVWrDn5+ftbn1qz5le+//xZvb2/Gj3+XM2dOYzAYGDVqOMnJyTz77EBKlSrF66+/xeTJ72A0GlEoFIwZM574+Lh822zf/j6mTp1EjRo1ueeeRP744zdrYcWCVKpUma++ms+GDeswmUwMHPii9bkb7b7++ivMn7+Ip5/uw7BhgzEajZQvX4FOnR7Mdb333nvnjjUbunaNYv36v/jppxUAnDx5ghEjhpCRkcGbb44rsI+7d+/kpZeex2w2M3bsBMCyPSIysmaBkwkXLkTTokXLO74fzlCoW1+aTCa2bNnCypUrSUpKonv37nTp0sUmuVyBu9/6ssyC+gAkDjzs5EiEPTzx1loBqS8AkBrwpZMjcbwhf1n6NvdB+/o2ZIi35Tpzi7+dwZ5Ybm/fE/OwuDw5f92B5KJwFSEhAWRueBqA1AYyHgjnKOqYGDAk53fYXEvOuuqtL4cNG8wbb4wlPDzC+tjevXv4+eeVTJr0P+cF5kQLFswjODjYeqeK4ti6dRM+Pr7W7RjF5dK3vlQqlbRv3x6AFStWsGTJElauXEnXrl3p27dviQb4XyKTDMJVefKHNHsnGazXsWOSwXoNO2JxRPueypPzVwhRNDLJINzNjUkG8d9Uo0atAldSuLpCrWyYPn0669ev55577qFnz540bNgQk8nEE088wapVq+5CmIXj7isbhGeQb/GEK5A8FK5CclG4CslF4QrszUNXXdkgXJtLr2yIiIjgxx9/tNk2oVQqmT17dokF9l8UtLgzAMnP/unkSISw5aubDIDON/+9Zu5q2i5L38bcY1/fpk2z1EwYM6b4NRPsicUR7XsqT85fIUTR+J7OGQ9qyHgg3IPvtJycHSM5K9xPoSYb7rnnHr755hv0ej0A165d491336VSpUolGtx/jdIQ6+wQhMiTynTZ2SGUmCtpjunblStK+69hRyyOaN9TeXL+CiGKRpUl44FwL6orkrPCfRVqG0WPHj148MEH2blzJ+XKlUOn0zFr1qy7EV+RyDYK4QpkmaZwBZKHwlVILgpXIbkoXIFsoxDO4KxtFIX6KszX15cXX3yR0NBQpk2bRnx8fEnHJYQQQgghhBBCCDdVqG0UCoWCuLg40tPT0el06HS6ko7rP6nU4vsBuP7seidHIoQtv/SJAKT7TXRqHCVh8j8TARjXeqJ915lsqZkwblzxaybYE4sj2vdUnpy/Qoii8Ts1EYD0yIlOjUOIwvKbPBGA9HETnRrH3TRs2GCysjLRar0xm82kpqYwZMhwWrdum+85Y8a8RnLydVQqNVqtNx99NItLly4yZcpEFAoF1apV57XXRqNU3vyuPS0tjQkTxpKRoUOj8eKdd94lOLgsAEajkQkT3qJr1yhatWpT4n32VIWabBg2bBjr1q3jscce48EHH6R79+4lHdd/ksKY7OwQhMiTwpzo7BBKTFKWY/qWlKSw/xp2xOKI9j2VJ+evEKJoFHoZD4R7UST9N3N23Lh3CQ+PAODChfO8/fabBU42XLp0kSVLfkChuPn30KeffsygQUNo2rQ5H3wwlS1bNtGhw33W59esWU316tUZOnQEv/zyE99+u4RXXhnJ5cuXmDz5Ha5du0bXrlEl1cX/hAInGzp16mT9gZnNZjQaDVqtlo0bNzJ69Oi7EuB/SdLze5wdghB5SvN3vRotjvJRR8f07aOPsuy/hh2xOKJ9T+XJ+SuEKJq0ujIeCPeS9lHBORsU1YXMXn3I6tUH9HqCej5GZp/+ZPXsBTodQb17kDlgIFlRT6JISSaw/zNkvPAS2V27o0hIIHBgPzKGvEJ250dQxMZiDg0tsL01a1azbdtmsrKySEiIp2fPZ9iyZRPnzp3h5ZdH0K5dR1au/J5Nm/4mIyODUqVKMXXqh/zyy08cPLifSZOmMnnyBOrWrc8DDzzEtGmTmTr1gwLbjImJISAgELCseggPjyA6+jwAkyZNRaFQkJqayujRI0lNTaVv3wG0bduOEyeO06RJMwBatWrDrl07bSYbqlevwYULluukp6ejVls+Gut0OkaPHs/SpYsLjEvcWYGTDX/88Qdms5lJkybRq1cvGjZsyNGjR/nuu+/uVnxCCCGEEEIIIVyETqdjxow5rFv3J99//y3z5y9i375/Wb78O9q2bU9ycjIzZ36GUqnktdeGcezYEZ588in27NnJlCkT0ev1PPFET4B8JxomT34HlUpNbGwM9eo1YOzYCdbn6tdvyBtvjOXHH5ezZMlXPPNMP3r16kvPnr1ytlwMpG7depjNZusX576+fqSnp9m0ERgYxK5dO+jbtycpKSnMmfMFAJGRNUvibftPKnCywcvLsgf44sWLNGzYEIC6dety9uzZko/sP6jUVx0AuP7cJidHIoQtv/S3AUj3m+LkSBxvwjZL3ya1ta9vEyZoLdeZVPwVBvbE4oj2PZUn568Qomj8TuaMBzVlPBDuwW9CTs5Oyjtnk1etuXmg0dge+/raHJsDg2yPg4Ntj++wquGGyMhaAPj7BxARURWFQkFAQABZWdkolUo0Gg0TJ76Nj48P165dw2AwANCnzwBeeuk5Fiz45o5t3NhGsWrVStat+5PQ0DDrc82atQCgQYOGbN26ieDgskRFPYlaraZ06TJERtbiwoVom/oMOl06/v62d1/46qsv6N27P1FRT3L69CnGjXuTxYuXFeo9EIVTqLtRBAQEMHPmTDZs2MBHH31ESEhIScf1n6QwZ6IwZzo7DCFyUZgzUJgznB1Gicg0ZpBptL9vmZmW/5wViyPa91SenL9CiKJRGDNQOGDMF+JuUWRmoMh0rZy9tS7C7U6fPsXmzRt5993/MXLkm5jNJgD0ej2zZn3EG2+M5aOPpqHX6wvVVlTUk4SGhjJ//mfWx06cOAbAwYMHqFq1Grt372T8eMsWf51Ox7lzZwgPr0pkZC327rVsU9+xYzuNGjWxuXZAQIB1AqJ06dKkp6cX8h0QhVWoApEffvghy5YtY+PGjVSvXp1XXnmlpOP6T0p6fqezQxAiT2n+Hzs7hBLzfnvH9O399+1fUWBPLI5o31N5cv4KIYomrY6MB8K9pL3vXjlbqVJlfHx8GDLkeQCCg8sSHx/H3LmzaNPmXh577Ani4+P4/PNPefbZgYWq2TBixCieffYZHnroEQDWrPmV77//Fm9vb8aPf5egoFLs2rWDwYMHoFQqGTz4ZUqVKsWwYa8yffoU5s2bQ3h4BB07Wu78N2zYYGbPns+gQUOYNu09fvppBQaDgdGj3y7ZN+c/SGE2m83ODsJREhLSMJk8pjvCTYWEBBAXl+rsMMR/nOShcBWSi8JVSC4KV2BvHsbERBMWFu7AiNzLsGGDeeONsdY7VRTHJ598xIgRrzsuKDdwe94olQqCg/0LOMMxCrWNQtwdpb5qS6mv8r+lixDO4pc+Gr90z7wDzbitoxm31f6+jRunZdw4rdNicUT7nsqT81cIUTR+J0bjd0LGA+E+/MaNxm+c5Kwj9erVx9kh/GcUahuFEEIIIYQQQgjhTLNnz7f7GrcWmxQlS7ZRCOFgskxTuALJQ+EqJBeFq5BcFK5AtlEIZ5BtFEIIIYQQQgghCuRB3xWLu8CZ+SKTDS6k9MKWlF7Y0tlhCJGLf9pr+Ke95uwwSsToza8xerP9fRs9Wsvo0fbVTLAnFke076k8OX+FEEXjf+w1/I/JeCDch//o1/AffTNn1Wov0tNTZMJBFIrZbCY9PQW12ssp7UvNBhdiVng7OwQh8mRW+Dg7hBLjrXJM37wd8M/Xnlgc0b6n8uT8FUIUjdlBY74Qd4vZ2zZnS5cOISkpjrS0684JSLgdtdqL0qVDnNK21GwQwsFkT6hwBZKHwlVILgpXIbkoXIHkoXAFUrNBCCGEEEIIIYQQbkkmG1xI6YXNKb2wubPDECIX/7Th+KcNd3YYJeL1jcN5faP9fXv9dS2vv25fzQR7YnFE+57Kk/NXCFE0/keH439UxgPhPvxfH47/65Kzwj1JzQYXYlYFOTsEIfJkVpRxdgglprTWMX0rXdr+LVz2xOKI9j2VJ+evEKJozBoZD4R7MZeWnBXuS2o2COFgRdmLl5R5nSvpsVQLqoKPWopWCceRPaHCVUguClchuShcgeShcAV3q2aDrGwQwkm2XP6HH07+jMlswlulZUij56lRqqqzwxJ2OJJwnCMJJ6joF0ar8s1RKVXODkkIIYQQQginkJoNLqT0gsaUXtDY2WGIu0Bv1LPq9O+YzCYAMo1Z/HLmDydHlb+AtCEEpA1xdhglYviGIQzfYH/fnn4hhede0rPp0ja+PbGSJcd+uKuxDB/uzfDhcv/LvHhy/gohiibgyBACjsh4INxHwPAhBAyXnBXuSVY2uBCTOtTZIYi7JNukJ9OYafNYarbrLqkzKis6O4QSU8HfMX1L9zmNjzrNerwndj9P1XwMX43vXYmlQgVToV5nNps5GH+ES2lXqVumJlWDwovdprvw5PwVQhSNUSvjgXAvxgqSs8J9Sc0GIRzsTnvxrqTFcD7lIrtj9nLy+hnr412rduaRqvffjRABSMtO50zyOSr4lSfEN7jA1+qNeqJTLxHiE0yQNvAuRVh4JrOJTEMWvhrn1b34YM9szqdcsB5rlGqm3TsBb7XlDhEms4lrunjKeJfCS+VV4vHkl4c/nFzFpkvbrcf96zxNy/LNSjyeu81sNrMv7hAXUy9Tq3QNapeJtOt6JrOJw/HHSMy8ToOydQn2Ke2gSD1fSEgA20/uJzHzOnWDaxHgVfJ7RIXIi+yVF7dLzkrl32v7USvUtAhrfFfqZ0keClcgNRuE8ECbL23n+5OrrMeNQ+oDULdMLdpUuOeuxXEy6TSfHfgKvUmPAgVPRnbjvsr35vnay2lX+XT/F6Rmp6FUKOkR2Z0Oldrke+0MQwYqharEPlAnZV7nQPwRSmuDaFC2LkcSjvPd8ZUkZ6cSWaoaA+v3vesfZowmIx0rtWXJscsYzUYAHqjS0TrRcCUths8PLiIhMxEftTf96jxFo5yfvaOcT7nA2eRoqgaGUzWoivXx2PRrrI3eSJo+jWblGrP18k6b89Zf3OyRkw0rTv3CxkvbAFgb/TdP14yifQF5eycLDy9lX9whAFadWcOIJoP/E6tCHOGznV+z8fw/AHirvHm16YtUDpBv6oQQzpWUeZ1puz8hTZ8OwN8XtzDmnlfR3oUvBIT4r5DJBhdSZoHlw0fiwMNOjkSUBLPZzK/n1to8din1CpPajLnrsfxy5k/0Jr0lLsz8evZP7q3QEo1Kk+u1q8/+wYCwnwH49ML9rDr9Gy3DmuKttq0PYDQZWXJsOXti96FWqukc3snhKzUupFxixt65ZOfEXi+4NmeTo8kwZABw6vpZfjnzO33q9Cz0NYf89QIAcx/8slgxHYo/ytLjK1j3cQ981S/yzofR1ChVlYjAmx/4fzr9GwmZiQBkGDL57viP1A+uk6uAZHFj2XhxG6NGlAaCaTlsNj0iu/NUyCNkGbOZsfdzUvWW7R2HE46jVNiW6lGgKGqXXZ7eqGfr5R3W41eqrEer3wpsz/+kAsSmX7NONADoTXrWX9zCCzLZcEfXdPHWiQaATGMmf0Vv5Pn6fZwYlfgvCzhkGWdTGxRvzBeeY8fVf60TDQDXMuI5EHeYe8KaOjGq3AKG5OTsXMlZ4X6kQKQLMXpFYPSKcHYYooSYMZNtzLZ5LOu247sl/ZZfrjfi0JsMeb42KTOZK5mluJJZCrDUm0jXZ+R63faru9kduxczZvQmPb+e+5MLqZccGveGi1usEw1gufvDjYmGGy6lXSnSNWuUjqRG6eItsdcb9Sw5+gOp2WkElI9FFXKOS6lXbCYaAGJ1cTbHqfo0dIbc72FxY/kjej0B5WMJKB8LwJ/nNwCWFSw3JhpuKOdT1vr/ChQ8GN6xyO05kt6o53D8MaJTLjruogqFzaTKlcxSxOnLFnBCwYzm3PUwjCZjsa/3X3L7mAfOG/eEADD6RWL0s29blfAMCjeZazfWiMRYQ3JWuCdZ2eBCkvv96uwQRAlSKpTcW6EVf1/aan2sXaXWTomldfkW/Hz2d+txo5B6+dY7aB7amJVnbn6ArxoYnud+9StpV3M9djkthioBlRwQscWNLQq3CvQKIOWW4pq1ivhh/fXmo4sdz/WsFNINOgDqPml5Py+nheV6XaOQemy4uMV6XC0oPM+tHsWNxWQyWdsHMOS8T6W1pXK9tn5wHZqFNiLDkMk9YU2dupw9KfM6H/37GUlZ1wFLrj1Xr7fd19Uo1TwQ3pE15/4C4MdrzelYqS3/HliIn8aPh8LvI8yvXKGvV8E/jNqlIzmedAqw/FsuaCuRuKlSQAVqBVfjRMJZwDLB1a5iKydHJf7LdNWKP+YLz9KqfHM2XtxmnZQv51vW4VscHUH3uuSscF93dbJh/vz5bN++HYPBgEKhYPTo0dSvn/c/6u+//54nnngCjSb3sm5PdSrpDNezUqgXXKtIFew9kdls5kTSadL06dQLro3PbUv2TWYTJxJPozNkUC+4tnVvfElLyEjk9PVzVA6oSAX/3B8qDSYDey4f4HqyjrrBtdEob/4TM5vN1AuujcFswGgyUbtMJM1CG9mcfzU9lgspl6heKoKyPnkXbUzLTudo4gnK+pShWlCEzXOp2WkcSzyZ53M3mMwmKgdUpF3F1qRlpxMeWIk6ZWqy/OTPmDFzb4VW1r4ZTUZCfUNoW+EeEjKvU8EvlM7hnWyul2HI4EjCCQK9AmweVylU1CxVnWyjniMJx9Eo1dQpU9Nm60C6XsfRhBOU0gYRWboaAOeSLxCXEU/tMpHWaxpMBo4knKCifwUOxB2xTjpU8q9Ak5AGHE08QUJmEo1C6vFwRCcOxx/DYDJQL7g2GpWGK2kxXEy9TPVSVSnrUybP9wUsS77PJp8nIrDKHT+Mnr5+joSMRMr6lCE+I9H6eJ3gmrnen0r+FWge2pjY9DgqBpSne7WHrT8Le/I4TZ/O0YQTNAqpz/aru6yPd6p8LylZaVxJj6FxSAMOxB3GjJkQn7LsiNljs2z09smGi6lXuJJ2lZqlq1Pau9QdYzCajBxLPIk+5/32umUrTpYxmyMJx9GqtNQpE4lSobT5mR+KP2qdaADLHTw6VW5HeGDlIr0PeWlTvgVGkxGDyUhZn9I2tVKOJBxnUusxhX6/TWYTHSq1oaxPGXzUPjQLbUzlgAp5vvZOYxfA9axkTiSepoJ/WK73P9uo52jCcdS3/Hu5mSc66gXXKXKeZBuzOZxwHK3KizplaubaSpMfs9nMqetnSclKoW5w7WIVYNUb9TxUoz1lvILxUmpoFtqY6qUiinydGwp67xxFbzJwNOE4ChTUC66da7uTO7gxNpTxLk2NUlWdGovZbOZk0hlS9WnUC651xwJ8eY0b+TGZTRxLPEWWMYt6wbVlr30R3fjdWKNUVYIL+N3oqfzUvjxW4xHOJUdTyb8iLcKauGQOnb5+jsTMJOoG18Jf4+fscIQokrs22XD69Gk2bNjAd999h0Kh4NixY4wePZpffvklz9fPmzePqKiouxWe0y06sowBG18D4I0Gg3it2VDK+/13b4U579BiDsUfBSDAy59RzV62fvg2m818dmAhxxJPAhDkFcgbzYcV6oORPfZfO8SCI0sx5Syp7hHZ3aaoYrYxm4/+/cy6jL+8Xyijmr1srW3w+cFFHE44Zu3TwxG2H9pvLR6pVCgZUPeZXJMRF1Iu8cm+eWQaswC4t2Irnqn1BADRKRf5ZN886xLl9hXb8HStKJvz83rvHqzSgZn7PifDYLkV546re3j7ntcI8Arg472fcTH1MiOq/IV3KW9CKm2w+UPxmi6ej/6dY/3wWtG/PEaTEa1aS5eIB9CqvZi662PiMhIAqBpYhVebvoRaqeZKWgwz9s61bie4J6wp/ho/6woAL6WGV5oMoqJ/BT76dw6Xc1ZOhPgE0zikATHpsRxKOMaltCuolWqGNHyO6qWqMnPv59a7QoT4BNOmwj38fOZ36/v6XL3eNC3X0NqHwWsHADCo4QgWH12GGTMKFPSq9Tj35vMN7DfHlvPP1d0AaFVeVAuKYMWURyilDWTmNzfv1hGnS+Cjf+dYvzVpVLYe/eo8Zf1ZzNm/wPpteSltEJdTjuKl0jD/oUV5tnuri6lXmLn3c+stVI/MfRU/jQ/TZl0lSBvIK7+NJ0Nvea5ZuUbcX6U9Gy9tY1fMXus1/r64lY6V7rWuVPn93Hp+PfcnAGqFihcbDqBucK18YzCYDMzc+znnbnm/RzUfhr/Gj+SsFD7YM9s6mRBZqho9az7GzL2fW3/mZb1z/3GbdtsWn+I4knCC+QcXWVd4vFVtKyOqZPDJhQetbZxMOk3DkHp3vJbJbOLT/V9yMuk0YFkt0rFy23xfn3vsGmYzwXUs8SSfH1yEIWfb0qNVH6RLVUtc6XodH+z51PrvJSKwCq82eZF5hxYXe7xLzU7jgz2fkpCZBED1oKqMaDK4UB+gvzryLf9eOwCAn8aX15oOLdKKEJ1ex4f/zrFuIwoPqMzjNR4t9Pm3K+i9c5QMQyYf/TuHq+mWLUmV/CvwerOhd+UOMo5yOe0qM/bOtY7prco3t447zvDFoa85EH8EAH+NH6OaDcv3Dkh5jRvDmwzOc8LBZDYxa998Tl23rJoprS3FG81fIUgbkOu1two4OACA1IaLitchD7Hh4hZWnloNWH43Dqzf11q0+r9Ap8/IGZ+uAVAloCKtyzd3clS5fXNsOfeMmUopYOLr3RjZdAgV/cs7OywhCu2u1WwICAjgypUrrFixgtjYWOrUqcOKFSvYtWsX/fv3p1+/fjzxxBOcO3eO5cuXExcXx8iRI+9WeE51NT2W3bF7uWQszSVjaXSGDNZd2OTssJzmXHK09Y91sPyxvPHiNuvxqetnrH94AyRnp7D58j+UtNXn1lonGgB+O7fWZt/2v7EHbOoFWH6u+wE4m3zeOtEAOX26dLNPJrOJX8+utT3O+dB3qz+j/7ZONABsu7yThIwk63O37oXecvkfkjKv25yf13v385nfrX+UguVbpX9jD7A/57aBAOczy3I8zZ+dt3xQBUvl5ls/HF5Ou8qzdXvxZvNXqF+2Dv9c2W394ARwLuUCh+It78O6C5ts6hbsitnL3xdvbjHJNun58/wG/o3db51oAIjLSKCUNpBjOR/SwfKhd825dRyMO2Jz+8m4jATrUnqwvK+/nbUt0lm/bEPql23I6rN/YsZy61wzZlafzf3+g2WC5cZEw433q4x3KZ7pWItHWpe3KbL596UtNjUTDsQfsdYmOJl0xjrRAJZvbL3V/tQve3MipCB/Rf9tnWgAUFU4yr3NAmhQti5rozdaJxoA9l47iL/GL9cHeTNma/2OLGM2f0ZvsD5nMBtZc25dgTEcjD9qnWgAy/u94+oeALZc3mGzauHU9bP/b+/O45so8z+Af3I3adL0oC20UMp9yH3LIcoprLoseKGLq6uu8tP1WldcFU/wFl2PxdVddVUUxQPlEpQbOQWU+yhHoS30SM80ac75/ZE2NEePNEkzCZ/368VLM5nM830m3z7JPJn5Dr45vtzjPS+pKfUoUJkSl4TuSV2b0/1GrTz1o3uiAQAOG7U4XeNZsyEprnm3rjxamuOeaACAMku5R/HJ+vyPXVs81ll56kf3wTLgulNGTe3f37Zznn8vpyvPYE3uep+/2fq3Lm3Klvwd7okGADhRcQqHSo82+bp84zn3RAPgmghZd3ZTs9sFgO3nd3vUK8mtOus+6GyJlad+anDfhcqu83vdEw2AqwbMnqJ9IW0j3NbkrvcY07ef+wVFppKIxJJb6fmeG23VWJ+3ucH1/Y0bR0qP+133kOGoe6IBqP3bLPD/t1mfXdcPdl3zxtlY5XA6sOJk45+NsW7H+d3uiQYAOFOVj1+LxVWgve77xunsNjid3QZmu6vALlE0abUzG9LT07Fw4UJ8+umneOeddxAXF4cHH3wQJSUleOWVV5Ceno53330XP/zwA2bPno2FCxfi9ddfb63wIqruy9ILfX5Xb5mlodVjXv2D6TrmegdV/vZNqL9w+mPxatfqsMEJAXW/D/qLuy6upmIWBAEWp2fRNLOtBocNx+AQHO7TqS1ebQgQ3Mu894HrOc9t+otD8FMgKV6h8djed0UDAQBXaz1fb/bXL0f9iYtG9omf5+oO9utv3997W203+xToq3HU+G3P7rOe5zr3DXKdUTRn8zMeyy0OKwRBgMSrgpS/Nkw2My6buaf29MYLpyz729/mRvp/RdYUn7NRGuL9+p6/X4NZQ3sDyPDJVdekggmD0vrhkOHCgWZKXBKWnlgJCSQYlTHc40DO1Ubjf1eN5bW//WT2s73ru/8euZV50CrjcUWH0R6XHrWU975ZWjSg9kyxQkggwWXtL23wMojmxNzQ+Oz3/fZ6vfc6dqfDPTHi7/X+irH6y52G+P8bbPr1/t/bwD6XvPPQtY2Wj9Xer62/70KlpftLTPz1wd+y1mD28343tj/97v8GYm/s86XRmDo91OQ6sc4pOGH1+s4RyLgSC/znWvi/SwaiLsbvfj/QvUxsMRI1pdXObMjNzYVWq8ULL7yADRs24JVXXsFTTz0FjUaD+fPn49FHH8WOHTtgt/uviB/LshOyPK49lUCC0RnDIxhRZHVP7IJ0Tar7sVQixch2w9yPeyV39zj9Wi6R4dJ2Q8Mel/cp9SPaDfE4MBqU1h/x8gu1NtTyOAxJHwAA6JHUFWmaC7+sSiVSXJpxoU8yqcyjj3XL3v7tP1i470O8uOufMNtrMDpjuMcvwV30ndz1Fbzj65bY2eeUZ3/7bnTGcI8ijh20GRjSdiAGpvXzuDYwThaHobX9qTMqY5jH6a1t49PRNbGz+/GwtoM8Tj9OUOrQv/bU9VFefcnSZaKnV3HHMZkjMCi9PzT1Lt1Qy9UYlTHM53TPMZkj0D+1j0fhRaVMiUFpnpeijM7wf2mE9/4bnTHcZ6IBcNU48L7bxOnKs3h//8d4fc9CvL//Y/fykd77R5OGbrX7p3dyd6T45HHzT+H0zoVOCR3RvvYAenSm53PJcUl4fe+7WHT4K3TWZ2NwWn+MbDcMZTXlOFqWgyNlx/Hhoc/QK9mz3kRDl5HUGZB6iUetDqVM6b5lmPffR5IqEZM7jvN5z8dkXopZva/HH7r+DokqfbP735gxXu/xkPQBeHzYQ3hkyF/x9KWP4Pru05q9rT4pPZFc7ywIuVSOEQ28T92TfMeuURmef9fexRG7JXXB1oKdOFqag2FtB3r8veiUWkzKvtzPeNf8PBnebjAU0gtn2ySq9OjbpleTr+ukz/I4VVcCCUZ69aUpQ9sORJzsQn0JnUKLAal9A9pGfWMyPQvqDkjrG/Lrl4ekD/CosxGv0GBgWnT9Cj46Y4TH35n3d4zW1C2xM9pqLnwOSSXSRvPI37hxSUpPv+tektLLowiuopG/TfKkkCkwoq3nvvIeN2PdkHTP8UmriA9qfAoH7+8bdT8MEEUTiSAIQtOrBW/NmjX44osvsHDhQiiVShiNRkyfPh1lZWVYv349tFot5syZg8zMTNx3330YP348li9fDrW6+QWpDAYjnM5W6U7ImWxmpH7YC044ceD6TUEV0IoFRms1Nudvh9FmxLC2g3wKxlVaq7AlfztMNjOGtxvcal+kdhf+hmNlOchKaI8RbYf4XPdcYi7F3vK9qK62YGTGMI8Jhro+FZuLYXXYoJApMLLdMHdhRKfgxPZzu5FbeQZSiQyb8j1Plb6++zSMbT8Sx8pysPPcXiTG6TEh6zJ3TQjAdcr3r8X7kaJOxuiMEX4LydXtu/KaCpyoOI3zpiIoJHKMzBiOvm16oXtSF3e/DOZSbMj7GRPiFyBV3QbWpCU+2ztVcQa7CvciQanF6MwRPl/+z1cXYmvBLiikcozOHOFxrXlO+SnsKfoNiSo9xmSOgEwiw5aCHThTmY8u+myMaT+idr8asCV/BwDXJEWqJgU2px1bC3bidOVZ6BTxGNJ2ALJ07VFW4zrN3SbYMbKd6z3Ydm4XTlecQaXViHPV55Ecl4Tp3a5Clq49bvvhjwCADyZ/gl8Kf8Xx2kJmBcbzSFDpcE3nKe73qI7ZXoMt+dtRWlOOKqsRe4v3YeuCvwAARj70Hh4efC866V1fEHIrz2L7uV8gCALGZV3mkROV1ipszt8Os92M4W2H4MmfHwEAfHjlpz772Z/jZSewp2g/kuMS8clTkyCTSPHhh65fPYqEc1h/bDuUMqXPZVkzul4Fq9OOZSd/8Fh+dafJ0CjUyK8+j97JPdwTQ41x72+nHSMzhqJtvVoz+cZz2H7uF6hkKozJHAG9KsHnPW+qWFxL/VZ8EIdKjyIzvh2mJrwFqUSKSl3z9qu3CksVtuRvg9lRgxFth7gndfxpauwCgH3FB3Gw9CjMthrsLvrVvXxqp4kYnNbP5++lymrE5vxtLR7vCoznsTl/O6QS161OmzupY7KZsDl/OyqslRiSPhCd9R0DahcACquLsLf8V1hrnBiVMdzvnWwCUbfvMuLbYmTGsJCcCeOtyFSCrQU7IZG4vtg3VlRWrI6XncSeon1IjkvE6MwRfguVthajrRpb8rej0mrEsLYDfSZrvfkbNxpSYanE5vztsDgsGNFuSJPXsqem6mD56fcAgMr+LRsPYoXD6cD2c7/gTFUeeiR386hldLEoNBVja8FO993Cgh2fmis1VYfi4qqmV0Tt2UE3/x42pw2F7/3H5/sIUUtJpRKkpPjeGS3UWm2yAQAWLlyIVatWQaPRQBAE3Hnnndi1axe2b98OtVqNNm3aIDExEfPmzcOcOXNQUFCAjz/+2O+vi/5E82QDACR85irgVHnTlxGOhILR2IeI2V6DZ7a97L6OXyqR4qFBs9HJ60t8/WKRda7qNBlXZo/DkuPfY3P+NgiCgMHp/XFLrxtaVC39i6NLPSY05BIZ5o163OPMgHVnNuH7k6txZcoupKnboFf2B2H/0vrF0W+xOX87BAjolNAR9wz4c4MHpCfKT+PtX9+H1WkDAEzqeAV+32WK33XrFz8EXGdZPDfyH/j3b/8CANwz8D4ArloXi49+614vTqbCvFGPNRjDJ4e/xPZzv+DosgkAgB5X/4T/6387LqktrJhvPId3fv0vKqyVUEjluLHH9AZ/fXtn75sesQTinXdcv17fc49rX9Tl4e7C3/DBwUUe645oOwS9U3r4LL+jzywMTBPXLzuhoDa79qtZHfh+Dacnt74IQ82FO5moZEq8MuaZkN/9YGPeVizNWQGr04bO+mzc1e9PrVrRPJAv1kThlJqqg3HXfACAOVtc4wFdPAIdE9Xv1H6G3cOcpdBprcmGVr315ezZszF79myPZRMmTPC77ksvvdQaIYkKJxli3yHDEY+CgU7BiV2Fe30mGwak9cWyk6vdxfSUMiWGpA/A0bIcbKxXWPKXwl9xSUpP96nrgahfGAlwFQQsMZe6JxsM5lJ8k7PCVSyxeAAAYIp0E67qPCngtprrVMUZj2KfpypzsTlvOyZlX+F3/VWnf3JPNADA2jObMD7rMr8HUkfKjnk8rrRWId94zufA3rsYWY3DgpMVZ9yTB94ubTcUO8/vQY+rXcUU26hT0COpi/v5pSdWosJaCcB1S72vjn+PQWn9PW4RWaclkwzu195j87u8a2JnKKRy2OrVY+iV3A0D0/piSMkA/FJbxHRI+oBmnckQjcQ2yVDHu0ZJOOb+KyyV+Or49+7iticrTmPN6fWY3u2qkLdFFA04yUDRhpMMFM1adbKB6GKnU/rekkun8F2WoNTh70P+ii352+EQHBidOQKpmhSPO1rUqV85PRB92/TG0XpV9hNVemTVOz37vKnY52CopW01V2m9X3nrlPhZVse7GJhDcMDqsAJ+JhsytRnIKT/lfqyUKjwuabiwXjuPitRSiRQZjdyGtmtiJzw46G78nL8DWqUW47Mug7zeqd2l5jKP9c32GpjsJihloalP0BS9Soe7+t2KFSfXoNpuwqiM4RjS1lVs6rZLbkLPpG44WpaDjgkd4HA6IJW1Wimfi96ErLH4st4ZTFd0GBPysxqKTCUed9EBgHOm8P4dExEREQGcbBCV5A9ct3wr/XNOE2tStOqW2BkDUvvi1+L9AFwFA+vqEnhL07Tx+fWxd0oPSHOk7oMHCSTNKvbmz+XtR8HutGN30W9IjkvC1Z0nexzodNZ3hFquhtluxiPZqwAABerw3qu9Z3J3qOVxHhXMG7uOdFTGcI9bL/ZO7uFRzK++qZ0m4Hx1IY6W5UCriMf13adBLVdj1sobAACfTP0CADA+ayzOVhVgf8khxMnj8IcuUz3qTHgTBAG7zv+K1/42DIAE9n+uw7XdrnFf/jUwrR9Wnb5wC8nO+o4NXjPvHUsgZs1yXebxySe+dy9QSBVQyJRQOe1QSi8UINySvx2fH/0GALCrcC+OlZ3AXf3+FHDbYpdQ6dqvlQmB79dwGtt+JDLi2+JY+Ql01LVHnxb+LTcmO6EDdAqtxxlVfVN6h7wdomiRsLd2PBgorvGAqCEJs2pz9hPmLEUfTjaIiF0TWKVvij4SiQR39p2FM5V5qHHUoIu+U0C/ZKZrUnF3v1uxJnc97E4HrugwGp312S2OZWLHyzGx4+V+n1fL43DvgNux/OQanLWdRpauQ0BV8FsiXqHBAwPvxprc9TDZzRidMRw9k7s1uP6lGUOhU2qxr+QQ0jWpPpX+69Mq4nHfwL/AZDNBJVO59/uYzLEe66lkStzV708w281QSBUeZyn4s6/kEDblb0XaJa5inBvyfkav5O7uA8epnSZAJVPioOEI2sW3xdRO/i8d8xdLIMaM8X8nH6O1Gu/89l/XGR8Avjj2LRKUWgxI64stBTu8+nIQFZYq6FW+Z9tEM5ui5fs13LoldQ5rwS+FTIF7B9yBZSd/QJmlAkPTBzb6d0IU62wp4h0PiPyxjWHOUvRq1QKR4RbtBSIpNrAY2sXFu/AkAPy+85QG60y0lro83FO0D/894Fl1fUS7IZjV63q8seddHC8/6V4ul8jw4pgnw3aHCLo4cUwksWAukhgwD0kMWqtAJC/OJSIKQq+Ubh73tJdAgp4pDZ+N0drq3+Pee9nUThM9bh04sePlnGggIiIiopDgZRQikvJBJwCA4c+nmliTqHXpK6cDACoSvolwJKF343JX3xZf1bK+ZSdk4U+9b8Q9t2UAAJ7+1/4G60aEM5Ybb3RNEixe7FmzIUPbFld1moQfctfB7rSjT0pPjG0/EgDQPakLnrn0URwty0Hb+DRk6dq3KG6xi+X8JaLA6PfUjgeDOB5QdNDfWJuzi5mzFH042SAiVi2vySJxsiinRDqEsJmUHXzfhrYdiBuuqcamvK1YcepHrM5dh5t6zMDwdoNbLZZJk/zXbACAKZ0m4PIOo2B12KBXJXg8p1cltOjWqdEklvOXiAJjSeV4QNHFMok5S9GLNRuIQozX4l2c3tr7Po6UHXc/VsvVeGH0XI/LFFoT85DEgrlIYsFcJDFgHpIYsGYDEVEUKbWUeTw2282oqXcLTyIiIiKiiwknG0Qk5cMspHyYFekwiHzoK6+BvvKaSIcRFjO+vwYzvg++b+uevRcb593vftwtsTN0ysBmjIOJZcYMNWbMYHFHf2I5f4koMPrd10C/m+MBRQ/9jGugn8GcpejEmg0iYtVdGekQiPyyKKdHOoSwmdY1NH27/UYdjpQVom1SV2Ro2+LK7PGtGsu0aQ3XbLjYxXL+ElFgLOkcDyi6WKYxZyl6sWYDUYjxWjwSA+YhiQVzkcSCuUhiwDwkMWDNBiIiIiIiIiKKSpxsEJGUj9oj5aPYvM89RTd9xVToK6ZGOoywmLZ0KqYtDb5v06apMW1acDUTgoklFO3HqljOXyIKjP6XqdD/wvGAood+2lTopzFnKTqxZoOIWPTTIh0CkV81qpsjHULY3NgzNH278UZb8NsIIpZQtB+rYjl/iSgwNRkcDyi61NzInKXoxZoNRCHGa/FIDJiHJBbMRRIL5iKJAfOQxIA1Gy5GFpPrH5HYCDbXvxhkc9hgcwTfN5vN9S9SsYSi/ZgVw/lLRAFy2lz/iKIFP+ApivEyChFJ+bw7AMBwa16EIyHypK/8PQCgQr8ywpGE3nXLXH1bOi24vl13natewtKl5ojEEor2Y1Us5y8RBUa/p3Y8GMLxgKKD/rranF3KnKXow8kGEbEkXhvpEIj8qom7JdIhhM3NvULTt5tvDv5Xh2BiCUX7sSqW85eIAlOTyfGAokvNzcxZil6s2UAUYrwWj8SAeUhiwVwksWAukhgwD0kMWLPhYlRV4vpHJDaCyfUvBplsJphswffNZHL9i1QsoWg/ZsVw/hJRgBwm1z+iaMEPeIpivIxCRFK+HgCANRtIfPSVrkt8YvGa95tWuPoWbM2Gm24KvmZCMLGEov1YFcv5S0SB0e+tHQ9Ys4GihP6m2pxlzQaKQpxsEJGalJsiHQKRXzVxt0c6hLC59ZLQ9O3WW4OvmRBMLKFoP1bFcv4SUWBq2nM8oOhScytzlqIXazYQhRivxSMxYB6SWDAXSSyYiyQGzEMSA9ZsuAhJS89CWno20mEQ+ZA4KyBxVkQ6jLCotFSg0hJ83yorXf8iFUso2o9VsZy/RBQYia0CEhvHA4oeksoKSCqZsxSdeBmFiCR9fykA1mwg8UmomgkgNq95v2WVq2/B1my45ZbgayYEE0so2o9VsZy/RBSYhN9qxwPWbKAokXBLbc6yZgNFIU42iIg57bZIh0Dklznu7kiHEDZ39A1N3+64I/iaCcHEEor2Y1Us5y8RBcbcgeMBRRfzHcxZil6s2UAUYrwWj8SAeUhiwVwksWAukhgwD0kMWLPhIiQtPA5p4fFIh0HkQ+I0QOI0RDqMsDCYDTCYg++bwSCBwSCJWCyhaD9WxXL+ElFgJFYDJFaOBxQ9JAYDJAbmLEUnXkYhIkmrrgDAmg0kPglVswDE5jXvt6929S3Ymg233x7n2k4QNROCiSUU7ceqWM5fIgpMwr7a8YA1GyhKJNxem7Os2UBRiJMNImJux2uySJzM6r9GOoSwmT0gNH2bPdsa/DaCiCUU7ceqWM5fIgqMuSPHA4ou5tnMWYperNlAFGK8Fo/EgHlIYsFcJLFgLpIYMA9JDFiz4SIkzTsAad6BSIdB5EPiLITEWRjpMMKi0FSIQlPwfSsslKCwMLiaCcHEEor2Y1Us5y8RBUZiKYTEwvGAooeksBCSQuYsRSdeRiEiST9dCYA1G0h8Eqpct2WNxWve71rj6luwNRvuuiv4mgnBxBKK9mNVLOcvEQUmYX/teMCaDRQlEu6qzVnWbKAoxMkGETF1uC/SIRD5ZVI/GOkQwua+QaHp2333BV8zIZhYQtF+rIrl/CWiwJiyOR5QdDHdx5yl6MWaDUQhxmvxSAyYhyQWzEUSC+YiiQHzkMSANRsuQvLTuyA/vSvSYRD5kDryIHXE5uU9+VV5yK8Kvm/5+RLk5wdXMyGYWELRfqyK5fwlosBIa/IgreF4QNFDmp8HaT5zlqITL6MQEf2GPwBgzQYSH53xLwBi85r3e9a6+hZszYZ77gm+ZkIwsYSi/VgVy/lLRIHRHagdD1izgaKE7p7anGXNBopCnGwQEVPHv0U6BCK/TOq/RzqEsHlwcGj69uCDwddMCCaWULQfq2I5f4koMKZOHA8oupgeZM5S9GLNBqIQ47V4JAbMQxIL5iKJBXORxIB5SGLAmg0XIfnxzZAf3xzpMIh8SB2nIHWcinQYYXG64hROVwTft9OnJTh9OriaCcHEEor2Y1Us5y8RBUZqOgWpieMBRQ/p6VOQnmbOUnTiZRQiov95JgDA0I01G0hcdMZ7AMTmNe8PrHf1LdiaDQ88EHzNhGBiCUX7sSqW85eIAqM7VDsesGYDRQndA7U5y5oNFIU42SAi1V0ej3QIRH6ZNI9FOoSweWRoaPr2yCPB10wIJpZQtB+rYjl/iSgwps4cDyi6mB5hzlL0Ys0GohDjtXgkBsxDEgvmIokFc5HEgHlIYsCaDRchxaEfoTj0Y6TDIPIhcxyHzHE80mGERU7ZceSUBd+3nBwJcnKCq5kQTCyhaD9WxXL+ElFgZNXHIavmeEDRQ5ZzHLIc5ixFJ15GISIJO28DABh6s2YDiYvWeD+A2Lzm/eGNrr4FW7Ph4YeDr5kQTCyhaD9WxXL+ElFgtIdrxwPWbKAooX24NmdZs4GiECcbRMTY/dlIh0DkV7XmqUiHEDaPDQ9N3x57zBL8NoKIJRTtx6pYzl8iCkx1V44HFF2qH2POUvRizQaiEOO1eCQGzEMSC+YiiQVzkcSAeUhiwJoNFyHlvmVQ7lsW6TCIfMjshyCzH4p0GGFx2HAIhw3B9+3wYSkOHw5uSA0mllC0H6tiOX+JKDAy4yHIjBwPKHrIDh+C7DBzlqITL6MQEd2e2QAAQ7+rIxwJkSdt9cMAYvOa939sdvUt2JoN//iHyrWdIGomBBNLKNqPVbGcv0QUGO2R2vGANRsoSmj/UZuzrNlAUYiTDSJi7P1SpEMg8qs6/rlIhxA2T10aWN/K1v6I8h/XAHIZUn53NRIuHeXazlPB10wINBaP14ag/VgVy/lLRIGp7sbxgKJL9VPMWYperNlAFGK8Fi92VR88gPzXX72wQCJBxyefhapDh8gF1QDmIYkFc5HEgrlIYsA8JDFgzYaLkHLP11Du+TrSYRD5kNn3QWbfF+kwwmJ/yT7sL2le30xHDnsuEASYjrqW7d8vxf79wQ2pgcTi89oQtB+rYjl/iSgwsqp9kFVxPKDoIdu/D7L9zFmKTryMQkR0+1z30TUMmhHhSKgpTpsVNSdOQJGWDkVycoPrmU+ehOnwQag6ZEHbr38rRhha2upHAYTvmnfziRxY8vKg6dUbyrS0kG/fUpAPp9mMuE6dIZF6HpDP3eLqW2N1EmylpTAd2A+J3HfIjOuY7drO3OBrJjQnlgZfG0T7TosFpiOHIU9KQlxWx2a/zpKfD2eNGXGdu0AikQTcbnMITifMR48AMhnU3bq3qJ2G8rf6wH5Y8s5C0/uSgPpNTROcTtScPAGZVguk6vyuYz1XgJrTp6Hu2g2K1NRWjlB8zCdyYDpyGHEdOyK+T79IhxOztEdrxwPWbKAooZ1bm7Os2UBRiJMNIlLV75+RDoGawZJ3FnkLXoGjshKQSpF67fVImnSlz3qVW3/G+Q/edz9OmnQlUq+/sTVDbVDVzh0o+e4bOM1m6MdegZRrpjV6EGeMf7HJbVb8vBnl69ZCqlQi+XdXI75P32bFUvLdtyhd9p3rgUyGjNn3QjtgYLNe2xzn/vseqrZtBQCoOmSh/cNzIIuPdz//3OgLfbNXVaJi/TrYq6qQcOlIqDt3gfn4ceS9/goEqxUAoMxsD1vheUAmR/KUqVB36+7aznMXaiZU7twO85HDUGV1hH7MWEhksmbFWj+WQNVvPxDWoiKcfel5OCrKAQD6yy5H+i23Nvm6c+//G1U7tgEAVFkd0f7hRyDTxDfxqsA4a8w4+/KLsJzJBQCou/dA+4f+7nfSpzH+8rf4i89R9uNq1wOJBO3uvBu6YcNbFKfDVI2KDethKy2FbshQaHr2atF2YoW9qhJ5r7wEa0E+AMA8aQL01//RY53y9etQ9NkngCAAUina/eVu6IYMC0n7NadOomzNDxDsDiSOGw9Nr94h2W44VWzaiMKPP3Q/Tp56FdpMvzaCEcUuY4+Wj7NEkWB8jjlL0YuTDSJi5RkNUaHku29dEw0A4HSi5JuvkDB6jM+BVukPnjPQ5et+Qsrv/wCpStVaofplLS7Cuf/8G3A6AQCly76Dsm1bJAy/tMHXOOSN/8pmOnwIhR/+1/04/6030Gnei03+Wum0WFBWfz85HDAs/z5kkw3m48fcEw0AYDl7BuXr1yLlqmvcy/q2cfVNsNtx9sXnXRMJACo2rkeHvz+K0lUr3BMNAGAtyEf2/JegSE72OOjt29e1Pw0rlsHw7YXLoWpOn0LbW29vVrx1sbREXfuBKlu9yj3RAAAVmzYgaeIkKNtlNPga09Ej7okGALCcyUXFhvVInnpVi2JoSOW2re6JBgAwHzsK4697Aj4o9c5fZ40Z5evXXlggCCj9YWWLJhsEQUDegldhOX0KgCtvMu69H9r+AwLeVqwo/+lH90QDABSu+QmqYaMRl50NwHXWQ8l337gmGgDXOPrtNyGZbLCVluLsKy+6/2aN+35F1uNPiv7MldLVnp8XZT+tcU0CBzixRk1z6HjWCEUXR1/mLEUvXuArIqqdi6DauSjSYVAT7GVlHo8Fux0OY3WEoglcTc5x90RDHfPRo42+Rm7fDbl9d4PPG/f95rnA4UD1oYNNxiI4HBDsds9l9Q7sg+X9XgGAvbzc4/Hewt3YW7gbpqNH3BMNAACnExWbN0Gw2Tw3IAiAIPgcBOzdK8XevVJUbNzgsbxy21Y4m9mnulhaoq79QDmMvkWqHEZjo6+xl/vbr77LguWo8hNbVeOx+eOdv6630LOYsOBs2WSNJTfXPdFQt/GKzRtbtK1Y4f/vrt4yQYBQU+PxvLMmNLdsrf7tV88xxOGA8ZddIdk2xQZ5xW7IK1o2zhJFgnzvbsj3MmcpOnGyQUS0h+ZAe2hOpMOgJiSM8DwDIK5zZ791BpImT/F4nHjF+Iif1QAAcdmdAK9LJuI6dWr0NZqyOVCevgvFS76AtajI53lVhu+v4KqMzCZjkWk0SLh0pMey+L79ULjoYxiWfef3YDMQmj59INXWq7Qrkfj8ev3Mtrl4ZttcSNVqn9dL1Wrorxjvsb80ffpCmZ7us+4zz6jwzDMqn+1IlcpmX0ZRF0tL1LUfqISRoz0eK9u2g62sDHmvv4pz770LS36ez2vi+/SDtN6lKJBIoBs6IuC2m6IbNhwShcL9WKrRQDtoUMDbia+ei/jqC/tVplZDf9lYj3WSJ/teCtUcfvMmLq5F24oVuuGeuaBITPS4lEEikyFh9GUe6+gvuzwkbcv91NCRp6SEZNvh5PN5MX4iz2oIk/jjcxF/vGXjLFEkxD8zF/HPMGcpOoX9k+y9997D1q1bYbfbIZFIMGfOHPTp0yfczUalqkELIx2CqFgLC+EwVvkt6hcKgiDAcvoUpGo1lG3bNft1uqHDYS8vhyUvD6qMDCRP+Z1rW7mnXZMJqT0AAPpRoyHVaGDa9xs0fftBOzDwg6SwkMqQNOlKVGzZDMFSg4QxY5EwaozHKoLDgZqTJyFPTgIAHH43FUKNDqbCVajYvAnZz82HXJ/oWtfphCK9LeL79Uf1/n2AVIqkiZOh7tbNp2nBbkfNqZOQp7RxF9ZMveEmyPSJcJpMULRpg5JvvnKfXl21awc6Pj3P/f7XnMmFRCJ132rSXlEBa+F5xGV3glSp9O1qnBppN/0Rxt27AQjQX3Y5lOltYTp21P2aF8a8CsFhByqc0FzSB6aDBwAAMr0eSRMmQd6mDdJm/Qk1OTmI69QZCaNG+7QDAC+8YIGtpAQJ1aNQ8u1XgMMBAEj5/XT3ZENdnkiUKr8TNC+MedVnmT/W8+fhMJkQ16kTJBIJnDYbnp59BrLEZACB3cZI07s32lx3A2pOnYQiNQ2qzEycf+/CWFR96AA6vfAKZPUOqqVqNdJumgXj3t2A4Nqv/t7vOk6bDTWnTkKZlgZ5YlKzY1OkpSPtj39C9YH9kGm1SBo33p139dkMJbCXlbnGCpkMTqsVNadPQZmeDrk+EcZ43/2aeuPNUKS0gc1gQMKIS6Hu0tXjeX+56qiqguVcAeI6ZkOqUkFwOuEwVkE7ZKj713OpJh7JU37X7D76YzMYYC8tdb2/YT7gtFdVwnrunLtPoaDu0gUpM65DzfFjkCcmostN18Eo99x23SVl9qpKxPe+BLpGLuNqLsHphFSjgaZPP5gOuCq3q3v0RMKlo/yubzl7BoCrlos/1vPn4DSbocruFLYCqHUSL7scsngtqg/sh3bAwEYvw3FUV8OSdxaqDlmQaTRhjSuUrIWFcFQbEZfdKSyf6c1l7Ol/nHXv16yOHuMdNc5hqnZ9H2rfPuR1e8LJXl4Oa1Eh4jp1glTh+/1BTIwvNO+7AZEYhfVbTE5ODtatW4fPP/8cEokEhw8fxpw5c/D999+Hs9moZe13daRDEI2izz5F+bqfAADKjEy0f3gO5AkJIdu+w1SNvNdegSX3NAAgYeQotP3znU2+rmLTRhQu+hhwOCDT6tBm2nRALsfZ559DzamTAIDqsZch8Y+3oXT59zB8vxQQBFQfOgBVhw5Qpob+TguBKFz0MSrWrwMAKDIy0f5v86DwOnizGUqQ9+pLsBUXAxIJ1D16wpyrAuA6WHCaqlH1yy4kjZ8Ie0W5qxDc+XOARIKEMWOReu11fr9wWM+fQ95rr8BeVgpIpWgz/Vqou3RF/ltvwGkyQSKXQ9Ux+8J13ACsBQUwHzuKuC5dUfDm6zAdPgQAiO/XH/F9+6No8SLXe6HTIfOBv7nvDAG4JiLyXnsJ1oICAEDiuAmwGwzIf/N19/uX+cDf0CW+DfIWvIyzJSUAgIRRoxHftx/i+/SF4BRwZv6z7tPkBcGJxCvG+d23STveR+WWzSiBK2cTx02Aunt39xkezhoz8ha8gpqTrjzRDRuBtnfe5XEQ0yul6UJ25//3ASo3bwLgOkhKu/kWFLz7NjTl5YBUitLy65Ds9StpQ2rO5CL/9dfgqKoEZDKkzbwZpkOHPNZxGo0wHzkE7cDBtfu1HHmvvgzruQJAIkHi+ImIv6ThCWRLfr6roGpFOSCTuQqqTpzcZGw+79/4iX7rSJR89y1Kl38PCAIUbVKROvNmFH70X9dZMTIZ0m76IxLHXuHxGofZjPwFr7j/Zp2mao87aljPn0feay9fyNU/XAt5UiIKP/oAgt0OqSYebW+7AyVff+nOfe3QYdAOHIT4S/p6FCANlGHZd+5xQ56SgvYPzwnbuFG5bSsK/3ehT5n3P+gz6RIo0+FDKPjXW3CazZAolWh7+51Qt2sHY717yht/3Ytz7y2EYLVCoopDwrARQR/M20pLXeNWUWHtWHQZksZN8DuRINjtyH/rDffEoqZPX2Tee7/HxM75D/6Dyq1bAISvAGp9JUu/QemKZYAgwHzkEFTt20OR0sZnPe99lzH7nmYX442kwk8/RsUG12ePMrM92j/8COS60H2mB8Kh9R1njXv34Nz770KwWiGNi0O72fc2Oq6Ri3Hfbzj3739BsFggUanQ7q7/i4o7b5Wt+wnFX3zu+i6g16P9gw9D1b5DpMNqkCMKitwSNSSsU8s6nQ4FBQX46quvUFhYiF69euGrr77CrFmzcOLECQDA559/jrfeegt5eXm44YYbcP/992P69Ol46qmnwhmaKKm2fgDV1g8iHUbEWc6edU80AK6CfO6q8SFSsWG9e6IBcN05wnz8WKOvcVqtKF6y2P2LtcNYhZJvlqBi0wb3QQsAFG/cBOPuXTAs+8594Gw3GFC6fFlI+xComjO57okGALAV5KNi3Vqf9UpXLHdNNAC1X3wPQ9fRAF1Hg3sdmdr1a1rZmh9cB1u161Zu2oCKzZuQ+8xcnH7yMY9r1w3fL3UdvAGA0wnD0m9QtPgzOE0m18vtdo9igHWkGg2qdm53TzQAQPW+31D85ecX3ouqKtcZEfWU/bjafaAKuAp0Fn3xmc/7t+67N7HXfKFmReW2rVB37QZpnBoVG9d7XI9ftW0rTMd861uYT+Tg5++LsL/UdVaLtSAf1nMFKP5yMU4+8jcUfvoxytatdU80AEBV7R0r6tt5bgd2ntvhs313OydPuCcaANcvs4UffwhHeTn2l/bA/pJuMHz7dZM1F+oYvv3aNdEAAA4Hipd8CXlios968noHPWVrfnBNNACAIKD8pzWw1CsG6NPGd99cKEDpcKDkm6/gMDVd48Tn/Vv7Iyx5Zz3WsZUa3BMNAGArKUbRp/+7cPmNw4HiL7+AzLQZctuF/er9N1u1Y7vr9pp1MXvlasm3X6Ho88/c9UWcpmoUfvo/j9w37toJVfusoCYa7OVlrTZuCHY7ir7w7FPJV18Gvd3iLz+H0+yqvyBYrShe/JlPfYyixYvcdRUES43rS3+Qyn5Y4ZpoAFxj0ZbNkKj8X85StWune6IBAEwH9qNqzy/ux+bjx9wTDcCFAqjhYjMY3BMNAGArLkbpyuV+1w3Hvgu3mjO57okGALDm56F87Y8Ri0devgPycs9xtujzC/vVWVOD4i8XRyK0qFO8+DMIFtedkASLBcVffBbhiJrmMJtdY13dd4GKCpQs/SbCUTVOvnMH5Dsb/m5AJGZhnWxIT0/HwoULsWfPHtxwww248sorsX59wx/Yp0+fxvz587FkyRJs2rQJxXUHPBcJ7bEnoT32ZKTDiDhb3Zf8eux+loW6DVtp4204zWb3l2h3XKWlfmOznivwKcJob2L74eavfb/L/PQn++pj6DjZVfBRldUR2iFDG3x9yZIvYDl7FtaCAhT+70P3wbn3/hXsdt9imzYbZDqd+7F2yDDEZXX0W3DOu3Cjd9z++lH3pejCOmX4Z813+HdGvWKWTifs5RUNbsPvstJS/PvwTfj34Zvcyyq3boHpwH7YSw2o2LDOb5E6733y/I5n8PyOZ3zWa6ztugKPde27CpY2r9aFz3tiqYF22AiosmtreEgkSJww0aOSv9/if36WNfScYLM1q8ijv74af/sNJd9+DePe3RAEwVXs0+tA1lE7eeVuz1KDePNziDdd2K8NvYcNPu90wuk1QeI0e7bT0HYDYS+v8B03Qjz21XFarXB6TUrZSg0NrN18Nq/3215RAaH2Sz3gupTIOydC0Uef8VsQGixa2tT735LPh2DYy8t88tjf2BqufRduzf3saS3xOc8gPufCeCA4nbDXuyMPANhD8LdwMfD93A19oeBQc1YbfQpRR/r7WVPin38G8c83/N2ASMzCOtmQm5sLrVaLF154ARs2bMArr7yCp556CuX1qsHX/8UjKysLWq0WMpkMqampsFhadt/4aFU57ENUDvuw6RVjnKZHT8j0eo9lumGhLT6nGzrco+ifVBPf5Kmocr0e6p69PLczfITPtmTxGugvu8KnDoR30bTWpunVGzKvS1F0w31v9ee9rxVp6bD2/AZVmteRcd8DyHr8SXd9BO91/RXLq/sFMcGr/6oOWb7FIQcMRPbzL6PdXf+H9o/8Axl3/x8AQDtoiMcpzhKlEnGdOzcat/djmT4R6u49vNYZjud7PoZHzly41aYivS0gk8Jps/m8t5K4OBj37kX+m6/DuHePe7nmkj6YM+JjPNL/3+5l3hNTjupqz5xTqxHfz/N2Vq+O/SdeHftPNETTuw9k2guTMZBIoBvsmvh5pP+/8Uj/f0OV1bHZNUi83xNFWjoK3lwAu8EA/bjx6PTiq0i78WaPdXz2a2Ii1N27N9iGd0FOVXYnvwU2fV/n2Y4kTg3Dt1+hdMUyFLzzFkq++hJx2Z2g8NqW99+xunsPVCe+A6P2wn71+ftXqxFf79Zi3m0r23dAvNepwZpLPNuRJyU1uh+aQ5WV5TtuhHjsqyPTaHz61Njtb5srwev91g0eAmn9v10/RVpD0Ufv2OVt2kDduYvfdbWDBnuOJwqF+zIhAIi/pK9vAdQW3Ba1ueI6dYYizTOPVR2zYdy7G85634PCte/CTdOrN2Rel0xEMm5jr3/C2OvCeCCRSn1uuxqKGiIXA9/P3fD9nYSKok0q4rzGhkh/P2uK8dV/wvhqw98NiMRMInif3xhCa9aswRdffIGFCxdCqVTCaDRi+vTpSE9Pxz333IMRI0bgiSeeQHp6Ov7whz/goYcewpdfuk7jvP7667FgwQK0b9++2e0ZDEY4nWHrDrUia+F5lK5aCYexCgkjR0M3aHDTLwpQ9f59qNi0EVJ1HJImT4Uqs+m7Jziqq1G6chks+fmI79MPiePGQyKVovrgAVRsWA9JnApdbrwWpvhk2MrKULpyOWzFhYi/pG+zrlMPN+v58yj9YQUcRiP0o0Z7fMGur3L7VlTt3AF5cgqSp/wOikaquVft3oXKrT9DlpAAdfeeKPzvex7Pt7v7/9xf5Co2b4Rxz24o0tKRPPV3kGl1KPtpDUyHDyEuqyOSp/4O0jj/hbnMx4+hbO1PkEglSJwwCcq0dJSuWu56L/r2Q+IV432KjlXt2Y3KrVsg0+qQPGUqZFqd3/evcuvPqPplJyCTwXzsGJzVRsh0OrSbfS8EqwUVGzdCIpej+uB+92UfAJD50N8R3/sSAIClIB9lP6yCw2xCwshRKPr4I4+7aeiGDUfCqDGo2LgeEpUKyZOmuAtdBsJSUICyH1bCYaqGfsxYaPsPQPmmDTDu2QNlejqSp14FuV6P1FQdiosbP8NBEARUrF8L4759kGnjUbV9m8fzGffeD+2AgT6vq/+eJ0+5yu/dWOor37gBxr17oGzb1hVfM+uvVO3+BZXbfoZMp4PpwAGPX9EkCgW6vrUQ9soKlK5cAXupAbqhw6EbPgLlG9ahet9vUGVkInnqVZBpfYtmVh88gIqN6yEASBwz1mOyAaiXq6lpSJ56FaRxKpSuXIGaM7nQ9OqNpAmTYPx1Dyq3/gy5Xo+kK3/X5H5ojrpxw24ogW7IMCSM9F/cMBQcZjNKVy6H5ewZxPe+BIkTJgVduE+w21G25geYjh5BXKfOSJ7yO6S3b+ORi06rFWU/rIT5RA7U3bojafIUSOvddaSlKnduR9X2bZAnJbnGrTapDa5rzjmOsp9+hEQCJE6Y5FOrwpKfj7LVK+Ewm5F42eU++RFqNoMBpatceWyvrHRfviVPSkKHR59wj8Hh2nfh5vnZMyZiBZMbGhedVitKV61AzckTUHfvgeTJU3g3kGZw2qwo+2EVzDnHoe7aDUlXThF9sUXAVRi3dOUKWM+dg7b/AOgvvyLsRWDra87nM1G4SaUSpKQEVlS8JcI62QAACxcuxKpVq6DRaCAIAu68804oFAq8+OKLyMjIQFpaGjIyMjjZACBus6sCfM2Y2RGOhIJR/0OkfMM6FC/5AoLFAnW37si45z6/Bz5ip7C5rl+2KfzfiaG+4q+XoPzH1RAEAfrLxiJt5h8jWnm8KVvzXX0bmTkap598HNZ69QeUGZnIfnY+ANcB9rmF73i8NmHMZWj7pz+7trPVdceJkSNdp4xXH9iH8x99AEd5OZQdOkA3bAQ03Xs0WoCvfiwB98Or/UC/zJSt/RHFny/yWJY0eQpSr7sh4FjC4dTjc2ArLHQ/lqji0PWfbzfrgMBf/gpOJwr/96Hr2nxBgHbgYLS7azYPMMKAX6ybz3zyBM4+/5zHsqSJk5F6w8wIRRRbUlN1KD+6CgBgSw58nCUKhUDHREVtDRnbSOYshU5rTTaE/VvV7NmzMXu278Hz2LFjfZbVTTR4///FIv6E66CGkw2xwV5RjqLPF7mLEJmPH0PpimVR+aVRY3oeAFChX9nkuqkzrkPKVdcAggBpnP8CbWLy8i5X35ZmrrxQYK5W/ceKZN+zO+ove/ll1685S5e6Lp+I79MPnV9eAOPuX3DuP/+G4eslMABInnoV2ky/tslYAu6HV/uB8nfKufelKpGUPPUqFH70gfva9uQrm//Lo7/8rT6wH5U/b3Y/Nu7djaqdO8J6JgFRU7xrgwC+dUgoOJqTteNBcuDjLFEkaF6uzdmlzFmKPvwJR0QqRom/qjQ1n62oyD3RUMdyrqCBtcWtSvtO0yvVI1WpwhRJ6L1xxYW+aQcOQtWunR6P68R16gz92MtRsXEDAFehzMRxEy5s540an21LpFKU/bTGIw/K1vyApCunQqbRNBpLwP3w034g4jp1RuqNN8Gw7DsIdgeSxk9w14MQA/2oMVB1yIL5yGGoOmZD06Nns1/rL3+9J5YAwFp0PqgYiYKl6dkbitQ02IqLXAukUiSM4q+ZoVTVu+XjLFEkVL3BnKXoxckGEbF3GxPpECiEVNnZkCUkwFFZ6V7mXZAtWjhlnSIdQthk6y/0Lf1Pt0Gm18OckwN1165oM226x7rps25F0uSpcJpMUHXs6HGNZ3a2/0u4vKteCw6HzySUv1gC1VD7gUiaMAlJEyZBEIRWvX61ueKyOnrcGaO5/OVvfN/+KPnqS/etHyGRQDsgMteRE9WRyOXo8OhjKF+3Fo6qKiSMHAV1126RDiumODWx+3lGscmZzZyl6MXJBhFRr38dAGC+4sEIR0KhIFUokfnA32D49mvYSkuRMHwEEi8fF+mwWkRhdd2y1qa8IsKRhN7Gs66+je1wBaRxap+7L3hrqAjgxo2umgljx3pOJCSOG4/C/124y4xu6DCP23s2FEugGmq/JcQ40RAMf/mrTE9H5v0PoXT1Kgh2O5ImTEIcv9CRCMj1iWjzhxmRDiNmKQy140FK7H2eUWxSbKzN2bHMWYo+nGwQEU3uawAAMzjZECtkag0glcJpNsNaXATBaoGkgbstiJnG/AoAoCIGJxte3+3qW0sO8D2287qrZsLYsZ41E/RjxkKenILq/fugyshstCZAMLE01D41nL+aXr2h6dU7EiERUYRoTtWOB5xsoCiheb02ZznZQFEo7HejaE3RfjcK+eldAAB7tniuk6bA1a8ynPvsU7CcyXU/V//uBdFE6sgDADhlzb87TLTIr3L1LVMXXN/y811nA2RmtnwMCiYW7/Z5B4ALYjl/owFzkcQiNVUHw9nDAABnHMcDioxAx0Rpfu1nWCZzlkInZu5GQc3HSYbY4jAaPSYaAMB08ECEoglOLB+kBTvJ4N5OEJMM7m0EEUso2o9VsZy/RBQYTjJQtOEkA0UzaaQDoAvUa1+Geu3LkQ6DQkSq0UCenOyxTNW+Q4SiCY7C+iMU1h8jHUZYrDvzI9adCb5v69bJsG6dLGKxhKL9WBXL+UtEgVGU/AhFCccDih6KdT9CsY45S9GJZzaIiObsmwAAMx6JcCQUChKpFG3/fCfOf/A+7KWlUHXIQurMxosPipXG7CpeWqGcGOFIQu/NPa6+jcsKrm9vvumqmTBuXMtrJgQTSyjaj1WxnL9EFBjN6drxoA3HA4oOmjdrc3Ycc5aiD2s2iIg0z3WKvbN9nwhHQsHwvhZPcDrhqDZCrkuIYFTBkTgLAQCCND3CkYReocnVt3RNcH0rLHTVTEhPb/kYFEws3u3zOvkLYjl/owFzkcQiNVWHkrwcAICg4nhAkRHomCgprP0MS2fOUuiwZsNFiJMMsUkilUb1RAMQ2wdpwU4yuLcTxCSDextBxBKK9mNVLOcvEQWGkwwUbTjJQNGMNRtERLN6HjSr50U6DCIfSusqKK2rIh1GWKw+vQqrTwfft9WrZVi9OriaCcHEEor2Y1Us5y8RBUZZvArKYo4HFD2Uq1dBuZo5S9GJZzaIiPrcuwAAE56IcCREntTmtwAAVuWUCEcSegt/dfVtcnZwfVu40FUzYfLkltdMCCaWULQfq2I5f4koMOrc2vEgleMBRQf1wtqcncycpejDmg0iIi08DgBwpneLcCQUjFi8PlniNAAABGlKhCMJPYPZ1bcUdXB9MxhcNRNSUlo+BgUTi3f7sZiHLRXL+RsNmIskFqmpOpTknwYACEqOBxQZAddsMNR+hqUwZyl0WLPhIsRJBhKrWD5IC3aSwb2dICYZ3NsIIpZQtB+rYjl/iSgwnGSgaMNJBopmrNkgIpqVc6FZOTfSYRD5UFq+h9LyfaTDCIvlJ77H8hPB9235cjmWLw9u/jaYWELRfqyK5fwlosAoC7+HspDjAUUP5fLvoVzOnKXoxG+mIqIu+hAAYMJzEY6EyJO6xlVPxKq6JsKRhN5/9rv6dlWX4Pr2n/8oXNu5yh6RWELRfqyK5fwlosCoz9aOB+kcDyg6qP9Tm7NXMWcp+rBmg4hIS88CAJzJHSIcCQUjFq9PljgrAACCVB/hSEKv0uLqW4IquL5VVrr+mxDEXU6DicW7/VjMw5aK5fyNBsxFEovUVB1KCvIAAIKC4wFFRsA1GyprP8MSmLMUOqzZcBHiJAOJVSwfpAU7yeDeThCTDO5tBBFLKNqPVbGcv0QUGE4yULThJANFM9ZsEJH4ZY8gftkjkQ6DyIfK8jVUlq8jHUZYLD3+NZYeD75vS5fKsXRpcPO3wcQSivZjVSznLxEFRnX+a6jOczyg6KFa+jVUS5mzFJ34zVRE4gyfAQCq8XKEIyHyFFfzXwCARTUjwpGE3kcHXX2b1i24vn30katmwrRpLa+ZEEwsoWg/VsVy/hJRYOLyaseDthwPKDrEfVSbs9OYsxR9WLNBTKpKXP/VtYlsHBSUmLw+WTC5/ivRRDaOMDDZXH3TKILrm6l2F2mC2EwwsXi3H5N52FIxnL/RgLlIYpGaqkPx+ULXAxnHA4qMgMfEUHzBIPLCmg0XI04ykFjF8EFasJMM7u2EYDPBxMLvII2I4fwlogBxkoGiDT/gKYqxZoOIaJc+AO3SByIdBpEPlWUxVJbFkQ4jLJYcXYwlR4Pv25IlcixZEtz8bTCxhKL9WBXL+UtEgVGdWwzVOY4HFD1USxZDtYQ5S9GJ30xFRFX+FQDAiDciGwiRl7iajwEAFtWNEY4k9BYddvXtuh7B9W3RIlfNhOuua3nNhGBiCUX7sSqW85eIAhOXXzsetON4QNEhblFtzl7HnKXow5oNYmKpvSZLxdOlollMXp8s2Fz/lSgiG0cY2ByuvilkwfXNVruLFEFsJphYvNuPyTxsqRjO32jAXCSxSE3Vobiw1PVAyvGAIiPgMTEUXzCIvLBmw8WIkwwkVjF8kBbsJIN7OyHYTDCx8DtII2I4f4koQJxkoGjDD3iKYqzZICLab++F9tt7Ix0GkQ9VzSKoahZFOoywWHxkERYfCb5vixfLsXhxcPO3wcQSivZjVSznLxEFRlWwCKoCjgcUPVSLF0G1mDlL0SmmvplKpZJIhxAUlbAHAGCK8n5Q9OeitzjHWgCATfrHCEcSehvyXH27qXdwfduwwfXLw003OSISi7/2Yy0PWyqW8zdaMBdJLOLKaseD9hwPKHICGRPjNtTm7E3MWQqd1vpcjqmaDUREREREREQUebyMgoiIiIiIiIhCipMNRERERERERBRSnGwgIiIiIiIiopDiZAMRERERERERhRQnG4iIiIiIiIgopDjZQEREREREREQhxckGIiIiIiIiIgopTjYQERERERERUUhxsoGIiIiIiIiIQkoe6QDq27FjBx544AF07doVAFBdXY327dvj1VdfhVKp9Fk/NzcXjz76KCQSCbp164annnoKUumF+ZOamhr8/e9/h8FgQHx8PF566SUkJydj3bp1eOeddyCXyzFjxgxcf/31rdZHEq9A86/O888/j06dOmHmzJkAgC+//BKLFy+GXC7H7NmzccUVV3is/+uvv2L+/PmQyWQYPXo07r33XjidTjz99NM4evQolEol5s2bh44dO4avsyRagebh4cOH8dxzz0Emk0GpVOKll15CmzZtmIcUtEBzMScnB3PnzoUgCMjOzsa8efMgl8uZixS0ln4+L1u2DJ9++im++OILAPx8puAEmoeHDh3CXXfdhezsbADAzJkzMXXqVLz99tvYsGED5HI5HnvsMfTr18/jdf6OUxo6pqGLU6C5aDAY8MQTT6CyshIOhwMvv/wysrKyWmdMFERk+/btwgMPPOCx7KGHHhJWrVrld/277rpL2L59uyAIgjB37lxhzZo1Hs9/8MEHwptvvikIgiAsX75ceO655wSr1SpMmDBBKC8vFywWizB9+nShuLg4DL2haBNo/hkMBuH2228Xxo8fL3z22WeCIAhCUVGRcNVVVwkWi0WorKx0/39911xzjZCbmys4nU7hjjvuEA4ePCisXr1amDNnjiAIgrB3717h7rvvDkMPKRoEmoc333yzcOjQIUEQBOHzzz8Xnn/+eeYhhUSguTh79mxh586dgiAIwpw5c4Q1a9YwFykkAs1FQRCEgwcPCrfccotw3XXXCYLAz2cKXqB5+OWXXwr//e9/PZYdOHBAmDVrluB0OoX8/Hxh+vTpHs83dJzi75iGLl6B5uKcOXOEFStWCIIgCNu2bRPWr1/famOiqM5s8Ga1WlFUVAS9Xo/bbrsNUqkUxcXFuOGGG3DzzTfj4MGDGDZsGADgsssuw88//4yJEye6X797927ccccd7uf/9a9/4cSJE8jKyoJerwcADB48GLt27cKUKVNav4Mkak3lX3V1Nf76179i06ZN7tfs27cPAwcOhFKphFKpRFZWFo4cOeKetTYajbBarcjKygIAjB49Glu3bkVxcTHGjBkDABgwYAAOHDjQ+h0mUWoqDxcsWIC0tDQAgMPhgEqlYh5SWDSVi2+99RZkMhmsViuKi4uh1WqZixQWTeViWVkZFixYgMceewxz584FwM9nCr2m8vDAgQM4deoU1q5di44dO+Kxxx7D7t27MXr0aEgkEmRkZMDhcKC0tNR9lkJDxyn+jmmI6jSVi3v27EGPHj1w6623IjMzE48//ji2bdvWKmOi6CYbtm/fjlmzZsFgMEAqleL666+HVCpFYWEhli5dCqfTiauvvhpXXnklBEGARCIBAMTHx6OqqspjW0ajETqdzuP5+svqlhuNxtbrIIlaIPnXoUMHdOjQwWOyoan8MhqN0Gq1Hs+fPXvWZ7lMJoPdbodcLro/UWoFgeRh3UTDnj178Omnn2LRokXYvHkz85BCIpBcTElJQX5+Pm677TZotVr07NkTmzZtYi5SSDQ3FydPnownn3wS//jHP6BSqdyv5+czhUIgY2K/fv1w3XXXoU+fPli4cCHeeecd6HQ6JCYmurdXd3xSN9nQUJ76O6ahi1sguZifn4+EhAR89NFHePvtt/H+++8jOzu7VcZE0RWIHDFiBD755BMsWrQICoUC7du3BwD3zEtcXBy6deuGM2fOeNRnqK6uRkJCgse2tFotqqurPZ6vv6xuef0dTRe3QPLPn6byy9/z/vLS6XTyi8xFLNA8XLlyJZ566im89957SE5OZh5SyASai5mZmVizZg1mzpyJF198kblIIdPcXDx58iRyc3Px9NNP46GHHkJOTg7mz5/PXKSQCGRMnDhxIvr06QMAmDhxIg4dOtSiPNTpdH6PaejiFkguJiYmYty4cQCAcePG4cCBA602JopusqFOUlISXnnlFTzxxBMoLi7G4cOH4XA4YDabkZOTg44dO6J3797YsWMHAGDTpk0YMmSIxzYGDRqEjRs3up8fPHgwunTpgtzcXJSXl8NqteKXX37BwIEDW71/JG7NyT9/+vXrh927d8NisaCqqgonTpxA9+7d3c9rtVooFAqcOXMGgiBgy5YtGDJkCAYNGuQ+Q+LXX3/1eA1dvJqTh9999x0+/fRTfPLJJ+jQoQMA5iGFXnNy8e6778bp06cBuH4BkUqlzEUKuaZysWvXrlixYgU++eQTLFiwAF27dsXjjz/OXKSQas6YePvtt2Pfvn0AgG3btuGSSy7BoEGDsGXLFjidThQUFMDpdHoUemzoOMXfMQ0R0LxcHDx4sDt/du3aha5du7bamCjqqdmuXbti1qxZmDdvHtLS0nDnnXeivLwcs2fPRnJyMubMmYO5c+diwYIF6Ny5MyZPngwAmDVrFj755BPMnDkTc+bMwcyZM6FQKPDaa69BoVDg0Ucfxe233w5BEDBjxgykp6dHuKckRk3lnz+pqamYNWsWbrrpJgiCgAcffBAqlQqbNm3CkSNH8Je//AXPPPMMHn74YTgcDowePRr9+/dH37598fPPP+PGG2+EIAh4/vnnW7m3JFaN5aFer8f8+fPRrl07/PWvfwUADB06FPfddx/zkEKuqTHxL3/5Cx599FEoFAqo1WrMmzePYyKFBT+fSQyaysOnn34azz33HBQKBdq0aYPnnnsOWq0WQ4YMwQ033ACn04knn3wSAPDNN98AAKZPn+73OMXfMQ1RneYcMz/xxBNYvHgxtFotXnvtNej1+lYZEyWCIAittB9abMeOHVi8eDFef/31Zq0/f/58PP7442GOii4WgeafPwaDAUuWLMHdd98dwsjoYsI8JLFgLpJYMBdJDEKRh0eOHMGBAwdw7bXXhjAyutiIcUwU7WUUwfjzn/8c6RCIPAiCwLykiGMeklgwF0ksmIskBomJiZgxY0akwyAK+ZgYFWc2EBEREREREVH0iMkzG4iIiIiIiIgocjjZQEREREREREQhxckGIiIiIiIiIgopTjYQERERERERUUhxsoGIiIh8WCwWLFmypMHnd+3ahSNHjjT4/DfffINXX321weffeustfP755z7L7733XgDArFmzcOLEiQbXIyIiInHjZAMRERH5KC4ubnSy4euvv0ZRUVHI23377bdDvk0iIiJqffJIB0BERETi8+677yInJwdvv/029u/fD6PRCIfDgfvvvx86nQ6bN2/GwYMH0bVrV6xbtw5r1qyB2WxGUlJSsycMfvrpJ6xatQo1NTV44okn0K9fP4waNQo///xzmHtHRERE4cbJBiIiIvJx991349ixY6iursbIkSPxpz/9CYWFhZg5cybWrl2LMWPGYOrUqWjbti3Ky8vx0UcfQSqV4vbbb8f+/fub1UZmZiaeffZZHD9+HI888gi+/fbbMPeKiIiIWgsnG4iIiKhBJ06cwNVXXw0ASE9Ph1arhcFgcD8vlUqhUCjw0EMPQaPR4Pz587Db7c3a9tChQwEA3bp1Q3FxceiDJyIioohhzQYiIiLyIZVK4XQ60aVLF/zyyy8AgMLCQlRWViIxMRESiQSCIODIkSP46aef8MYbb2Du3LlwOp0QBKFZbezbtw8AcPToUWRkZIStL0RERNT6eGYDERER+UhJSYHNZkNVVRVyc3OxevVq1NTU4Nlnn4VcLkf//v3x6quvYsGCBVCr1bjxxhsBAKmpqc0uHJmXl4dbbrkFVqsVzz77bDi7Q0RERK1MIjT35wciIiIiIiIiombgmQ1EREQUNvfeey8qKio8lmm1WixcuDBCEREREVFr4JkNRERERERERBRSLBBJRERERERERCHFyQYiIiIiIiIiCilONhARERERERFRSHGygYiIiIiIiIhCipMNRERERERERBRS/w8vgvJvB9hzSwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -5150,13 +5284,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='swarmplot', \n", + "ax = plot2d(plot='swarmplot', \n", " df=tips,\n", " x='total_bill',\n", " y='day',\n", @@ -5169,13 +5303,13 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 21, "id": "3fdf0604", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -5185,13 +5319,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='boxplot+swarmplot', \n", + "ax = plot2d(plot='boxplot+swarmplot', \n", " df=tips,\n", " x='total_bill',\n", " y='day',\n", @@ -5204,13 +5338,13 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 22, "id": "e69e7ce8", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl4AAAFDCAYAAADrgQBeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd3gc1dWH35ntVaveu+WCewHbVAOhGTAlmG4gODgxNZTQHdN7CWCaA4TeAgkQwkcvNgab4t4tF/Xet5eZ749ZrbRWsSTLlmTmfZ717szcO3P36nr2N+eee44gy7KMioqKioqKiorKPkcc6AaoqKioqKioqPxWUIWXioqKioqKisp+QhVeKioqKioqKir7CVV4qaioqKioqKjsJ1ThpaKioqKioqKyn1CFl4qKioqKiorKfkIVXioqKv3K4sWLueSSS7jwwguZM2cO69evB2DLli38/PPPHcr/+9//5quvvur1da699lpWrFix1+3tDe+88w6BQKDL4+Xl5Xz99dddHi8tLeXss8/u8viKFSu49tprO+y/9957KS8v56mnnuKtt97qspyKisrgRzvQDVBRUTlwKCws5Ouvv+att95CEAQ2bdrETTfdxEcffcTnn39OQkICBx98cFSdM888c4Ba23uef/55Tj/99C6PL1++nB07dnDMMcf063Vvu+22fj2fiorKwKEKLxUVlX7DZrNRXl7Oe++9x5FHHsmoUaN47733qKqq4j//+Q86nY7Ro0dz6623kpOTg06nIy8vj4SEBPLy8njuuecQRZGamhrOOeccLrjggqjzv/HGG/zrX/8iMTGRuro6AJxOJ7fddhstLS1UV1dz/vnnc+qpp3LGGWfw2WefodFoePjhhxk9ejQzZ84E4KuvvuLLL7/k/vvvB+CMM87ghRde4JFHHqGoqAiv18tFF10UJbL+9a9/UVNTw7XXXsszzzzDAw88wK+//grAKaecwoUXXsjixYvxer1MnDgRm83GokWLkGUZl8vFo48+ik6n22MfFhUVMXfuXBoaGjjvvPOYPXs2c+bM4Y477uiHv5CKispAo041qqio9BvJyck8++yzrFy5knPOOYcTTzyRb775huTkZM444wwuueQSxo0bh9vt5vLLL+fxxx+Pql9VVcWzzz7Lu+++y8svvxwRVwC1tbW8+uqrvPvuuzzzzDORKb+ioiJOPvlkXnrpJV588UVefvllbDYbkydP5vvvvycUCrFkyRJ+97vfRc41Y8YMVq1ahdvtZu3atWRmZmIwGPj5559ZtGgRL7zwAhqNJqpts2fPJjExkccff5xvvvmG0tJS3n33Xd58800+/vhjCgsLmTdvHqeccgrHHnss27Zt4+GHH+a1117j+OOP59NPP+1RHwYCAZ599lnefPNNXnjhBerr6/v651BRURmEqBYvFRWVfqOoqAir1RqxJK1bt47LLruMqVOndiibm5vbYd/EiRPR6/UAFBQUUFxcTHx8PADFxcUMGzYscnzcuHEAJCQk8Morr/D5559jtVoJBoOAIpRee+01JEni0EMPjdQD0Gg0nHDCCXz++eesXr2a2bNnY7VaufXWW1mwYAFOp5NZs2Z1+T23b9/OlClTEAQBnU7H+PHj2b59e1SZ5ORk7r33XsxmM1VVVUyaNKlHfThhwoRIW/Pz8yktLe1RPRUVlaGBavFSUVHpN7Zs2cJdd92F3+8HFHFlt9vRaDQIgoAkSZGyotjx9rNp0yZCoRAej4fCwkKys7Mjx3JycigsLMTr9RIKhdi0aRMAL730EhMmTOCRRx7hxBNPpDX97JQpUygpKeG9997jrLPO6nCts846i48++oi1a9dy2GGHUV1dzYYNG3j66adZvHgxDz/8cETEtdL6HfLz8yPTjIFAgFWrVpGdnY0oipHvuGDBAu677z4eeOABkpKS6Gla3I0bNxIMBnG73Wzfvp2srKwe1VNRURkaqBYvFRWVfuP4449n+/btnHXWWZjNZmRZ5sYbb8RmszFmzBgeeugh8vPzu6wfDAa57LLLaGxsZP78+cTFxUWOxcXFcdlll3HuuecSFxeHyWQC4Oijj+aee+7hk08+wWazodFo8Pv96PV6Tj31VD799FMKCgo6XCszMxOAY445BlEUSUxMpKamhnPPPRdRFLn00kvRaqNvkVOmTGHevHm8+uqr/PTTT5xzzjkEAgFOPPFERo8ejSAIPPvss4wePZpZs2ZxwQUXYDKZSEhIoLq6ukd9aDAYuOyyy2hubuaqq67C4XD0qJ6KisrQQJB7+himoqKisg9ZsWIFb7/9dge/r73hhRdewOFwdGrxUlFRURkIVIuXiorKAcnNN99MdXU1zz333EA3pQOLFi3qNAbZfffdF7HEqaioHJioFi8VFRUVFRUVlf2E6lyvoqKioqKiorKfUIWXioqKioqKisp+QhVeKioqKioqKir7CVV4qaioqKioqKjsJw6oVY0NDS4k6be1ViA+3kpdnXOfnNv0grIazPPHP++T8w8k+7LfWjF5wv1nGvj+e+EFJUfgH/8Y2Ku6+6PfumIw9WdvGch+G8qo/dY3Ouu3A/l+3l/0ZbyJokBsrKVXdQ6oVY11dc7fnPBKTLRRU9My0M0Ycqj91jfUfusbar/1DbXf+obab32jL/0migLx8dbe1elVaRUVFRUVFRUVlT6jCi+VLrHNuwTbvEsGuhlDFlvLJdhaLhnoZgAwb56RefOM+71ufzKY+lNFZaih3s8HDweUj5dK/xIcM26gmzCkCWoHT/+NGSPtudA+qNufDKb+VFEBCIWCNDTUEAz6B7opUVRXi1EJ6QGqbrgeALmyaCCaNCTorN/ao9XqiY1NRKPZO+mk+ngNcdS5/L6xr/pNlmVaWpqpqamhsbGBpqZGGhsbaGlpxuPx4PG48Xg8+Px+JEmKvDSiiE6nQ6/Xo9PpMJlMWCxWLBYrVquVmBgHcXHxxMbGERsbh16v7/e29wR1vPUNtd/6xmDvt9raCoxGMxaLHUEQBro5EbRakWBwcDwwDSW66zdZlnG5mvF63SQkpEb298XHS7V4qaj0kaamJkpKdlFUVERZWTEVFRVUVVXi9XqiCwoCGq0BRD2IWhC0IGoREEAQAA0gI0tekF0gSwhyEDnkRwp6keWONwK73UFqairJySmkpKSSnp5JZmYWMTGOQfUDoKJyIBMM+rFYUtT/c78BBEHAYrHjdDbu9blU4aXSJfY/XAhA8z9fH+CWDDyhUIji4iIKC7ewdesWtm3bSnNzY+S4Rm8BnRXRlIEhxoqos3L9KW+CqOHvX/8FQeibO6UsyyAHkQMepKAHOeBGCrpx+1soLK5h2/adSEFvpLzFYiUrK5vc3Hxyc/PJy8snNjaOP/xB8dH65z+9XV2qS/ambn9ibwmPR5s6HlUGD0NFdIk7dwAg5eYNcEuGLv31t1aFl0qXBKYcMtBNGDBkWaaqqpING9aybv1aNm/aiN/vA0CjtyIY4zEk5SAaY9EYYxE0Haf+CusOAuiz6FLqCiDoEAw6RIO987aGfIS8TUi+Rvy+RrbuqmDz5k0RS1lMTCyBwMUkJiZRWiqSlpaBKPa8TVOmhPrc/v4koP3tjkcVlb1FtvQ81lRzcxPLl//I8cef2GWZd955gy+//ByA6dMP49JL50WOFRXtYt68i/noo88xGAyR/a+++hLbt2/jzjvv78M3OHBQhZdKl3iuuHqgm7BfCYVCbN26mVWrfmXlyl+or68FQGOwIZozMSYmoTElIOrMPTrf/9afvC+bG0HQGNBaksCSFNknSyEkXwMhTz0uTy0my2Kamtz87W9gMls4aNRoDjpoDAcdNIakpORun+SuuKL3QVf3BR7Tb2s8qqj0J3JSco/LFhZuY9my77oUXmVlpXz++acsXvwyoihy+eVzOfLIoxk2rACXy8miRY+j00U/jP744zJ+/PF7knrRjgMVVXip/KYJBoNs3Lien39ezspVv+JxuxBEDaI5GUPKFLSWFER97xwnBwOCqEFjSkBjSgCGI8sycsBFyF1DwF3N6rXr+fXXnwCIjYtn/LgJjB07npEjR2MymQa28SoqKj3C5/Ny3313UllZSSAQ4LrrbmTkyIO4++47KSsrIxQKce65F3Dsscdz5ZXz+OtfbyU7O4cPPniPuro6Zs48lTvuuI2kpGTKyko56KDR3HDDLbz66ksUFm7jww//TUZGJmvXruYPf7gsct3k5BQeffQpNBoNoNxH9Xo9sizz0EP3Mm/eFdxyy/WR8qWlJXz00b+59NI/8fHHH+zvbhp0qMJLpUvsc84BoPm1dwa4Jf2LJEmsW7eOzz77kp9/XoHb7ULU6BGtaRjTJ6C1piCIur2+zvW/exSAR7+8fg8l9z1L/zMDgCPP/A6dI1cRYv4Wgq4qWlyVLFm6hG+//QpRo2HE8JGMHz+J8eMnkpycwpw5ihB77TVPN1fY99ibw+PRfmCNRxWVvvLBB++TkpLGnXfeT0lJMT/++D1btmwiNjaWBQvuxu12cemlFzJ58iEIXi9CSTFk50Sdo6SkmMcfX4TBYOTss0+jrq6Wiy66lA8/fJ/TTjsTgMmTD46qo9VqcTgcyLLM008/QUHBCLKysnnxxeeZPv1wCgqGR8q63W4ee+xBbr/9Tnbt2rnP+2QooAovlS4JHHHUQDehX6msrOCHH5aybNlSGhrqEEQtGms6poxJaCwpCKKmX6+3oXx0v55vb0jOrozaFgQBwWBHb7BDXAGyHCLkriXkqmDrzlI2bdrA22+/RlJyClbrJaSnZyJJMQPUeoWA7sAajyoqe0txcRHTph0KQGZmFpmZ5/Poow8ydepUAMxmCzk5uZSVlYJGA2E/r/ZBpNLTMzCblf3x8Qn4/T2LSebz+bj//rswm81cf/3NAHz++f+RmJjExx9/SH19HddddyVnn30edXV1/O1vt+B0OqmtreG1115mzpxL+qkXhh6q8FLpEs+8ywe6CXuN1+vl55+X892Sb9ixfRsgoLEkY0ybjtaWjiDuu/8Cn27s2jF1fzNi8pZujwuCBq0lGa0lGZiA5HcSdJZT5yxD8j/Ejh0S11xjZdq0qYwaNY7Ro8diMOzfaPYe09Afjyoq/Ul2di6bNm3kiCNmUFZWyj/+8Sxjx45j9epVHH74DNxuF9u3byctLQ2dxUqtLJMFbN26mYSERKDzlXqiKHYbE1OWZW655XomTZrChRdeEtn/zjsfRD6fddapPPbYIgwGA0cddQwAK1f+wocfvv+bFl2gCi+VAxBZltmxo5AlS75hxYof8ft9aAx2DEnj0dpzEHWqD9OeEPVW9HHD0ccNRw4FCLoq8LWU8c13S/nqq6/QanWMHj2WiRMnM2HCJOz2gbWGqaj8FjnttDO5//67uPLKeYRCIa655nry8wt4+OF7mT9/Lj6fj0svvYzY2Dhmzz6HRx99gOTklIjo6or09Ax27Cjk3XffJD+/oIOP15Il37J69Ur8fj/Ll/8AwJ//fCVj1GwnPUKNXD/E2ZeRnWPOVeb3m97+9z45f3/jdrv48cfv+ebbrygvK0UQtWhtmegc+Yim+P0eb+fG4x8C4KHPb9yv1+2Mb987GoAZZ32zV3VlWSLkriHYUorkKifkdwEC+fnDmDRpChMmTCY1Na0/mx4hpjk8Hu1DYzy2Z7BHYB+sDPZ+q6wsIiUle6Cb0YHOIrBrthcCEMofNhBNGhL0JOL/7n9zNXK9Sr/iO/6kgW7CHmm1bn377Ves+OlHgoEAGlMchpQp6OzZCJq9d5LvKQFPEzWFS/A5a7HE5/Dr8PEIvYiXtS9Jzy/tl7qCIEamJGV5EpKvkWBLGbvKyti+/S3+9a+3SExMjljChg0bjlbbP7cZn37wj0cVlcGKFKNapQcLqsVriDPYnwj3FW63m+XLl/HNN19SVlaCqNGhsWWhc+SjMcUNSJuKfnodn7Mmsu3ImEDS8KP36TWbyjfgrNmG1mgnPucQtIaBC30hBVwEW8oJOsuQ3NXIsoTRZGbsmLGMGzeRMWPGE/Mbvfn/Vv+f7i2Dvd+GksVLZc+oFi8Vld1QrFvb+e67r1ix4kcCAT8aY+yAWLd2J+hzRokuAFfdrn16zcaydVRv+TKy7WksJfuQOQOWwkTUWdDHFaCPK0CWAgSdVQSdZaxcvZaff14BQFZWDmPHjuOgg8YybNhwdLqB+5upqKioDASq8FLpkpjfzwKg6f2PBrQdTqeT5cuX8d13X1NWVqL4btmzMDvyEY1xgyJXmkZnQqM3E/K7I/ueumEdRtv93PfpLfvkmi1V0SsV/a46/M5aDLaOjrNfv6OsKjrmnK97fZ2+1BVEHTp7Bjp7BrIsK1OSznLKaisp/uRj/ve/j9Dp9IwYMZJRo0YzYsQosrNzIwEZOyOmOTwe7QM7HlVUhiKawm0AhIYVDHBLVFThpdIlvtPPHLBrS5LE5s0bWbr0G3759WdCweCA+W71BEHUkDLqBCo3fUbI70ZvTeCX8uFoepheqC9ojbuZtwURjaHz62WNLOp0v7u+mOpt3xLwNGFLGk7SiGMRNdoe1e0pgiCgCee0JGE0cihAyF1N0FXJpm27WL9+LQAGg5GC4SMoGDaCgoLh5ObmR+V58+kHbjyqqAx1pNjYgW6CShhVeKl0iXcAYq3sHuRU1OjR2HMxOPKUH+5BjMGagD3lIIJ+N46M8SzZmbJPrxefMw1PQylBXwsgEJ87Ha2+80S4w8Zv77BPCgUoX/8xUlBJ/t1cuRGtwUpC/mF7rLs3CBodWls6Wlu60o6gh5C7hpCrWhFi69YASiyhjIws8vLyyc3NJzf3GCXBd7+2RkXlt4EcnzDQTVAJowovlQGnqamJn39ezo8/LmPnzkL2Z5DTnhL0OanbuRy/uwFrYj6OjIlRU5xSKEjxr+8Q9DYD0FK1mcxJZ2OKSe33tkihIDXbvsVZsx2tyU58zlTM8TnojLZencfnqouIrlY8TWX92dQeIWpNiPYsdPYsAOSQj5CnjpC7lrLaWkrLlHRGAFqdjvT0TLKzssnMzCYjI5O0tHRsNvt+b7eKisrAUllZSWHhVg4//Mguyzz99BOsXbuaUCjErFlnMGvWGZFjq1b9yt13/41///t/UXUefPBe7HY78+dftU/aPfC/aCqDlpjTZwLQ9MEn/X5up7OFVat+ZfnyH9i8eQOyLKMxOtAnjUc3CIOclq35IOI872ksRZZCxGW35S9zNxRFRBcAssTCWY+gN8dyz//d3q9tqdv5I03l6wAIBdzUelvISz2o2zpfvf07AI49t80Z32COQ9QaosSX0d5RKHZWd18iaAxorWlorUo8sNa8kgtOeQhZCnL7S7GUlP6AFGyLSWax2EhPTyclJZWUlFSSk1NISkohMTEJvV6/X9qtojKYORB9vFau/Jmiol1dCq+VK3+htLSE55//J36/nzlzzmbGjGOx2+1UVVXyzjtvEAwGo+p88MH77NhRyIQJk/ZZu1XhpdIl3nMv6NfzNTQ0sGrVL/z6609s3rwJWZbQ6K3o4kahtWehMTp6fU6fs5aG4l+RpACOtHGY47L2XMdVR8DTjDk2A7EHvmJ+d0OHFYst1duwp46muWIDUiiA3twxhMUXq0ZhSxreYb+zdgeNJSsBgdisKVjie7cc3d1QErUd8rvwuxswWNumEnyuOhpLVyNLEo70ceSO2dHhPKJWT+rok6ne+jUBbzO2pALic6d1KNdZ3f1Ja17JpTuPB8CcfaQixoJuJF8zkq8Jv6+Z7SW1FO7Y2cGKZ7XZSUxIJDExkbi4eGJj44mLiyMuLp6YGAd2ewzbtm3hgw/eQ5ZlZs36PWPGjB2Ir6qi0is++eS//PjjMnw+L2VlpVxwwcXMnHkqW7Zs5pFHHkSj0aDX67nxxtsh4GfhIw+QlJZOWVkpBx00mhtuiF74c/PN1+F0OgFYt24Nf//7M9jtMfz97w8jyzIxMTHccstCtm7dzLPPPoVOp2PWrDOIj49n8eJnMRgM2O0x3HLL37DZ2izwDQ0N3HvvQpxOJ7Isc/vtd+JwxHL33QtwuVyEQiEuu2w+kycfzFlnncobb7yHwWDg2WefIjs7h5SUVN5441V0Oi3l5WUce+zxXHjhJbz++st4vV7Gjh2H2+3B43FHEnsDjB6trJ4G5T4iSRJarRafz8cjj9zPjTfexty5cyLl165dw8aN6znttDMpKtq1z/5uqvBS6RLfXgovSZLYsaOQtWtXs2bNKkpKFCdtjcGOLm4kWlsGojG2z6sSQ34PJSvfjfzQOmsKyZx8LiZ7175VNYVLaSj+RWmHzkzGpLMwWOI7Let31eNprsBgjkcQtchS25OR1mCl+Je3IlYuQdRhcmTgaVSCjWr0Fr5aPyEs8LZhS1KeMr0t1ZSv+yiSpdbdWErOIXPQW/YceyzodxEKeDHak/G1VEX2i1oDOlNbfKygz0XJr+9E+qWlahPZB+s6XMPTVE5D8c8IopbE/MOJzZoMKKKtavOX+FqqMcdmkjXquC59x/YnSwrbnmoFQUDQWRB1FrBGW+nkkB/J36K8Ai58ARfFVU6Ky6uRAm5kKRRVPhgMUVtbQ2tIw2XLljJr1hlkZGRhs9mwWq3YbHasVisWixWz2dJvQWFVVPYWl8vJY48toqSkmJtuupaZM0/l/vvv5qabbqegYARLl37LokWPccUVf6GkopzHn3oOg8HI2WefRl1dLfHtfL8eeOAxAJ57bhFjx45n4sTJzJt3Cbfc8jdyc/P4+OMPeOONVzj44Kn4/X7+8Y9XkGWZs88+jWeeeYHExCTeffctXnnlRa688i+R877yyoscfviRnH76Waxbt4ZNmzawdesWpkyZytlnn0dNTTWXX/5H3n33wy6/Z1VVBS+//BaBQIDTTz+Riy+ey4UXXhK2eB3VaR2DwYDBYCAYDHLPPQuZNesMzGYzDzxwN+edN4fExKRI2draWl588XnuvfcRvv76i736m+wJ9e6h0jWBgPLew1hLsixTUVHOpk3r2bRpA5s2bcTjcYMgoDEloE8ch9aWjsbQP0E0nXU7oq0bsoyzakuXwivgbaGh+NfIdijgpn7XT6SO7hgRval8A1WbP49s21JG4azaiiyH0BrtmGLScNW2OZ3LUgCjPYX43GmEgj5cNdtp2LlEOVfZGgLDjiAuawqu2h0R0RWuiLN2B3F7EF61O36gvugnkGUM1iRMsZl4GkrQGmzhlYhtfyNnTWFUv8hSiMaKbSTkTkPUKNcOBX2Urf4PUsgPQE3hEjQ6E/bUg6hY/wl+Vy0ArrqdVG5aQtqYmZG6A4VGUIRvSO7+tiVo9GhM8WhMHQW1LMvIIR9ywI0c9CAFPXgqNiPL1ZEykiTx1ddfYrV0vSLVYDBiMpuxWKxYLBYsZgtmsxmTyYTJZA6/TJhMJoxGIykp8Xi9MkajEaNR2afT6QYsFMry5T+wevWv5OcXcMwxx3UbxkNlcNNq0UlKSsbvV/4/19bWUFAwAoDx4yfx3HOLQJJIT8/AbFYeouLjEyLl2/Pmm6/R2NjAzTcvAKCoaCePPvoAAKFQkIwMZVYhK0ux1Dc2NmI2WyIiZsKEiTz//DNR5ywuLuLkk5VwMGPHjmfs2PF88cWnHH/8iQAkJiZhNltoaKiPqtc+vnte3jC0Wi1arRaDwdjj/mlubmbBgpuYOHEyc+b8gdraGtasWUVpaQkvvbSY5uYmFi68hTFjxtPY2MgNN1xNfX0dXq+X7OwcZs48tcfX6imq8FLpkpjZpwFd+3j5/X6KinZSWLiVwsJtbNu2BadTiTKt0VsQTckYY1PQWlMRNP3vZ9NZlHZNN5HbQwEPEC0eQn43AU8TLTXb0OotWJMKEEUttTuWRZXzNJSQd9hlBLxNGKxJOOs6mbrT6DDHZiKFglSs/x/P37oVgD/dO4Km0jXEZU1BZ3J0qKc3d9zXHp+rjvpdK9q2ndXE5UwlfdzpCKKmw4+3Rt/RP27VsmvQ/mKN+Gl5GssioqsVV91OLIn5EdHVyurl17NlU9p+8/HqiltOVG7+e+MzJwgCgtYI2rYbt9EfgsptUeUs6dOwJg9XRFrQp7yHfMihAHLIhyT5cYb8OBsDyPW1IFWAFEAOBTr0a5dtEUUMekP4qdwYFmXKSx/ZrxwzGAxR+6KP775t7NYi95//vMfixU9Htjdt2sDVV1/fy55UGSx0Jt4TEhIpLNzGsGEFrF69kszMLDTFxYg+XydnaOPjjz9g3brV3HPPQ5F9WVnZ3H77XaSkpLB27Wrq6pT7gygq13U4HLjdLmpra0lISIhcrz05OTls3ryRgoLhrF69kh9++J7s7FzWrFnN8OEjqamppqWlGbs9Br1eT11dLampaRQWbiUnJzf8PTv/7rLcdaR5n8/LX/4yn3PPvZDjwynwEhISeeuttnyvs2adwJ133g/AeeedTzAo8ckn/6WoaNc+EV2gCi+VbvBecBGgPHU0NzdTXl5KaWkxRUW72LVrJxUV5ZFBrzHYEIzxGFJGorUkI+r3feoac2wW1qQCnNXKj6bBlkxM2pguyxusiRisiVH+WiZHBrtWvBqZRjSVrydz0mzkUCCqrhT0o9GbIqLGGp+LwdY25ac1WCPXFgQBUdTywbdtJnxBqwhPW9JwnLXbcVYrosyWMgpLQn633zPgaepkX2OHeFutWBPyMTky8TSWhL93EgWTSqNWh3Y2tam3xKPRGtCb4/C7254807K/JzYz2tHUWbuDxtLVCKKWuOwpmGL2TWLs9nyzdcZubdiOu74Eoy0JW8pIBKFvgSZsicNoic/FVbcTAHNcNrbkEYqoFbWg6900qyzLIAWRpQCyFFA+h/zKGIvsVz6HpCBuKYDLE0R2+UB2gRwCKQRyEFlqfYX2fOF2iBoNep2+TbgZjZjCom7p0iVRZT/77BOGDRuO1WqNEn2dCcCBtNKp9JxbblnAY489pCxa0mi4+eYFSM3NyN0I8rq6Wh5++H7Gjh3PX/5yedjf8Uyuv/4W7rnnb4RCIQRB4OabF1Bb23YPFQSBG2+8jdtu+yuiKGCz2bn11juizj1nzqXcf/9dfPbZJ5Fz2Gw27r//Lr799it8Ph833ngbWq2W88+/iL/+9RpSUtKi/MQ6Iz9/GK+++hLDh49EkuQOPl4ffPA+5eVlfPTRf/joo/8AcOutC0lLS+9Dr/Yf/Z6r8YEHHmDDhg3U1NTg9XrJzMxk27ZtTJ8+nccff7w/L9UBNVdj35EkiZaWFurra6murqK6upqamioqKysoKy/D43ZFymp0JjAoATFFYywaUwKituem394QCvpoLF0TDvBZgCU+J3LM01ROc+UmZEnCmpiPJT63yx8Fv7uBxrI1SKEgAiCF/FiThuOq2U5z5caospmTz8VZUxjxBQOIzZpC4rAjACWcQ1PZGrzOGjQ6EwZrAtbEYcihAI2lawgFvYBIU9lqpbIgkjrmZGyJwwj4nDSVribgbcGWPAJrQl6n7ZVlmeaKDXgay9DbkqjftRwp4I0cTx55HEGfk6CvBVvSiKhFBS3V23DW7kDU6LDE52GJz4qIkpDfQ0PpakJ+FwgizRUbkKVgRGx4GsvQaI24G4rxOWswOtIxxaQR8nuwJuZjTcjD01RBya/v0Go9FEQtOdMuIehz0ly5EY3WiCNj/B7zRkqhAI1la/C76rEm5GFNHNZl2ZaaQly1O9Bb4nCkj6epbC01hW0CIiZ9HMkjju32el3RfhzZkkdg6WaBhrN2B86a7ehNMTgyJiBqO7fkSkE/jaWr8XuaIv22N8iyBFIIWQriaSyhpXobGq0Re3K+IsBbxZkURJZbBV74FfLjbKzC73ViMJppaawhGGizygmCQHJycs8ElSCg1+nR6fTo9Xr0BgN6vR6DXtnW6XTodMq7Mi2kQ6fTotEoU0QajQaNpvVdRBQ1aDQaRFGMeikPLyIxMWZaWnxh64oQ3i8gCCIej5tly5bS3NzEpEkHM2LEyKi6oth23tZrKNfV4Ha7+PzzT2loqGfGjGOZOHFyn/4uaq7GA4v9latxnyXJ/ve//82OHTu44YYbWLFiBW+//bYqvPYBXQmvYDCI1+vF6/XgcrlwuZy4XE6cTictLc00NzfR3NxEY1Mj9fX1NDU2EgpFL6s1CTrQWQma4xANMYgGO6I+Zr+Geij+9W28TRWR7dTRMxWB0FROycp3I/5SOqOd7GkXI3YS8yvgc1K04tWI35Oo0ZM9dQ46o53KjZ91EF5p408n6HXic9WCFMIUk4YtZVTkh6ls7UdR/l2Jw48mJnUMu1a80hZSQhDJGjMDZBnRloPe5EAKBdi1/GWCPmdbmcnnYrQnd2hzzbYlNJS0+aPZkkYiyyFCAQ+2lFE0la6OstyljTsNa0IejaVrqN7altrHkpBH+rjTCAY0yLJE2apX8Lvq2vpzzCxMMSm0VG+hZtt3kf3WxAJSx5xM6er3cdUp/k+i6CN51PH4XfVRohQgNmsyDSWrIGwB1Rrt5Ey9uEurHCghOlqtTABJI47FkT6uQ7nGsrVUb/kKgz58bls+flcdgfbhOwSRYUde0e31OsPTWEbJqn/1aBw1V2ykctNnkW2TI4PMSbM7PW/Jyn9FFloApIw6AfseQn70BFd9EWWr/0Or6NWb48ieOqdba1/lpi9orlgf2bYmFeCsKYx85/jc6cRlTYwINdq/y6Gw1S4UtQ8pFBZ44f1yKPy3DyHIkiIU5RBIknIOWeq11a47ZFmmtrY2KhRAbGwsRuOeHwA7qxsXH4/FYkGraRWLOrQ6rSIwdTpFYOp0UcJSr9dz6KHTiItLUaawBbGdMBSi9u3p1d90KiBC4f5X/fm65IBLkl1UVMQf//hH6uvrOfroo7nqqquYM2cOd9xxB/n5+bz11lvU1tZyxhlnMH/+fBwOB0ceeSSXXXbZ/mriAcGTTz7K+vVrCQYD3ZYTtQbF10XUI2gtaByJaLUmBJ0ZUWdF1FtZ8G7Yp+bc/o1D1VN8rroo0QXQVL4OW/IImso3RDmpB7zNuOuLO7UsOKu2RjmbSyE/LVVbicuegiNjAi3VWyNTjQZbMlUbPwv7g4HJkU7SiGMjN8eg3x0lulrbpDPYOsTx+ttZr0bF8XLV7WoTXeEyzZUbOxVerXG6It+htpCCGUowP09zZYfwFk3l67Em5HWo56rdQdDv4rt/n0Yo6CMn7bGo4y3Vm7Al5Xe8Xs02fC01eBpK2LbteQBGjPgTTeXrsaeM6tBen6s+IroAgt5m3PVFWBM7n0YN+JxRoqv1O3cmvFrb9uRflSnlP90rojNHZzEQRW2ffsCaKjZ2Mo5KsCbkdtKO9VHbnsZS/O7GDj56fndjlOhqrdsfwqu5fAPt/RT97no8jeWYYzM6LS9LoQ4PFp7GcnKmXoK7oQSjLRFjeDGKoDF0dop+Q3nGl5VxIsuApOwLfyZyXEZu/Y6t+3b77G2pIVj5f1Hn92EmNvOI6HPsdk0ZCa+zjmBlZVRdb0DEassnJIcIyRJeKQReCdwhZNkDshPkEEJYRCIrgnPipPE0NTXuZc/sLsRa/bY6F2U9GeY6nR6HIzbK10+zU/FLPZDieA1V9pvw8vl8PPPMM4RCIWbMmMFVV3UdEbampob3339fDXzYBwq3b+sgugSNEVFvRdBbEfU2RL0dUWdG0BoRNEYEsfMnoC8n/G5/NLlLRI0eEGj/Q9M6panRdfyR0Og6f9oVtR3LSkEvxb+8RcDThCUhF4MlEZ3RhrelmsZ2oRo8jWV4GkoiU3miqEUQNVFP7xqtEbGT9nz881jsySPbletYprO2AYg6Y5STtkZnxO+qx+es6XQBQeu5dz9fq5/SsAnbCHqbCdXvXs/YRT2t8p0EkcTE96KuY085CGdNIe56JTyIPeUgNHoz7t2EVGd9EjkmahEEjWI92a0tXX23975Ukn8Lgoa4rClUbf6S1rERl3NIl+O4Ozr7m3Q2tqCT7yMIiNqOK35FrU75dWwn6Lrri97Q2Xm6am+kjRo9UtDbrrwRvdmxx0Ud/U2rmKCdda6vth6d3NHCpzXEoLXuOVOErHMA0YtntJZkjMkTOi8vtwq3UDtrn/IuaIwIOhsRcRcl+qLFJHRlSZGV1bb9OFnj8/kwGo1YrW0+UpKaMmjQsN+EV0FBQURIdbbipv2MZ0ZGhiq6+sgpJ5/Gli0b8Xg8eDwe3G638vLUI3tqO62jWL/MoDUhas2KSNNZWZYzUvm8n79DKzqjDUfGBBpLV0XaGZdzCACOjIm0VG2JWJAsCfldOnjbkofTWLYaX4syZaa3JNJUsYGQ3w2As3obumwH9tSD8DRXdqgfCvpw1mxH0Ggxx2YRlzONuvCqR0HUEp87DVNMOpaEPCVcBKA12FjTcBY6d5tIMsVmYo7LwV2/C1AWJOgt8bjqdmGOzUIQ235MEvIOo3LTp+EbthBeBPBK+JoazHHZEeGj0ZmIzZ4CKNNGZWv+E7HgxWVPRaM1kB1OdF2xcRQtlZvC9cyR2F0JuYdStvaDiKCMz52G3hSjONXLX4Svq0OjN7Nj2T8QNTri8w7DnjwCnSmGgM8Z/nu0hP8eeZgdnVthlGsbic0+mPpdy5Vza3SdBm9t/U6epgq+WBEX3j6YmLQxmBzpYatNUsRq01scmRNpqe7ZOIrPmYqnoTQiiGMzJ3ca30yrtxCbOTkyHStq9MTnTO1T+3YnNnMyzupCQgFl7NqSR2KwJnZZXhBEEvIPpXpLePpZEEnIO6zL8n0l4oMmhyLTjrIUnn6MTD2GP7dat2SJVkuXHCVQ2n8m2nKlXAyQscam4WwoB5QVxRarFW/Vqo5iZ3chJEuYbfG4W5Qpd1HUYNJ4ce/8NNLGVpElS6Fup0jl4FjkQPc+toIgIIgigqDt0bRj2/Rjm/Wr/ZRk+2NdvWu1GrS7+R/KapLsQcN+E16dmUz1ej01NTXk5+ezceNGkpOVKRdRVNPg9pXjjz8psmy2PbIs4/V6cbmcYf8uxc+rqamJhoY6Ghrqqauro66uHE+jclM3BwJIgM/iAJ0d0WBHY4hBNMYhGux9XkXWG5KGz8Acl42rbgfWhHyMNiVWjM5oI2faJThrCvE0lSNq9PictVHR21sRNTqyJp+Hu6EYkNHozBT/8mZUGU84GrwjbSzNFesjN1udyUHt9u8JeBoBxa8nY8LvsSbk4azeRjDgxu+ux2hPJW3sLNwNpbjqtgMCukA5JmsGnoASD0oQBNLHn46nsYyQ30198S9UblBCdRisSWROPjsSj8ueMhJTTCqe5kqM1kSKf3kr0lZZChEKeEmfcCYtVVvRGm1h6yCYYzPIPXQunoYS9Jb4SH/4fcp5Uw86EbMjA29LDbEZ49GHp+zMcVnkTp+Lp7EUvTUhElQ2cdgRGB1jCXga0WhawlYmxWJYt2MZtrBDvM5gJWfaxbjrixC1RkyOPa8aSsibjjkuk5aqLZgc6Ri7EDwmRzq5h85FcG9Db44jpM8EQG+OjbS/r7SOI3d9EaLO2K1YNNpTyD10Lu6GYnQmR2QsdkbisCOwJY8g4G7AHJfdpTW2t+jNDnKn/wFXfRFag6VHq0kd6eMxOTLxNVdhtCeh1RsJ+ZqifbmkQJfO+ZFycqsvVyiy8lKWgkitAms/YzMJGDUJSJKE0WRC46+EgIgY5VwvKO/tnPl1Wi1pccPxeNwEAkGSkpIwGo2RBQC6sC9Xq69Xqz+XVqsNLyDQR97t9hiSklI7+HK1LgAYqBWgnft4hX3aeukHqdL/DOhf4KKLLuLOO+8kLS2NpKSub2Iqe48gCJGAjgkJXT8hgxIJubq6mvy5F+H3+3hxzsWUlZVSUbmdQNghVRA1YYf7ODTmBDSmBASdpd9vNO6GUirW/xdZCtFUthZH5iSSCo4KfycN9UU/R5zFG0tWkTn57E6tH4IoRlZESqFAhxyFBlty+D2RrIMvoKVyszLdF/RHrDKg+PW46nciSxJ17fa7aneSPv50nNWbI75AD160BZ05lge+ur+tHYKAOTaDpooNUdHnfc5qmis340hvS1WjM8WgM8UgBf1Iu4W3CPk91Gz9NhL2obFkJVlTzkdvdqDVm7Elj4gqv/Q/Sp+NP+TuyPdprlhH2rjTsMQpjqJag6VDPYCfvjwLgDETb+1wzNNUHglNIWp03a5M3B2/u4Hydf9FCnhpKltLS+Vm0sef3mlZrd7M7af9F9i7OF6d0Zt2a3TGTtNAdYbRltStONudyJRWWPxEO7qH2gmiEHpNEPx1eKuqdjumvEf8kcL7JCmIIEv4GqH7SE7h76nRojcYMOgN6M0GjAYDRmNMJGaYXq8Pf24vRNocz/trVWNCgo36endEyACR44MhrEVlZRFG4+DKK9sVmp2KK4Dq4zXw7DPhdeaZbbE0pk6dytSpbab2ZcuUaZqjjjqKo47qGOr/3Xff3VfNUukBFouV3Fwr2utuRAv86RQl4rAkSVRVVVBUVERx8U527trJrp078DYWAiDqTIjGBDSWJLTmZAS9ba9vjvVFP0WZ+htLVxGXfTBavRl3Y0nUCj1ZDtFYto6UPUw7iRodqaNPomrzVwR9LVjic0nIOzRy3GCJx5CvTMfUFC7tUF8K+BSn7Ha46nbibamO2v/2Z0lojTboZNZ893yCyj5vx4IoORVtySNoqdoc2WeKSaWlekvU+Zor1pOQf3in5xg+aQtyKEhD8c+RfbIUon7n8ojw6orhk5TrmOypNJWtiTrW1yk+gIaSVVEhMlx1O/E0V3aZeeCzjSf0+Vr7EmU6yq/Efgu/y+FgqtHxvALtrEiBsNVIsSTJoSCSFKC3jj5anU6JtaU3YDAZMBjNGNsFZG0fgys6RpcpKlZXa+DWVmE1WFIimc1mXK7+Ww35W6ZGo+Gfb73G9bcuHOim9Ijm5iaWL/8xEt2+M9555w2+/FLJMDJ9+mFceuk8nE4nd921ALfbRSAQ4KqrrmXMmHH89NNynn32SYxGE1OnTueSS/64v75KBwbH/y6VQYk/LLhaEUWR1NR0UlPTmTZNESqSJFFWVhqOXr+VTZs20lj5Kz4UHyLBnIzWmorWktKn6PW7W3qQ5Yj/UmdL/nsaTsAUk4499SB8zlqsCbldOrnbUw+isXRVRPxp9GYsCXm0hAOgtkfQ6MKRlJXtb36JxWBLIvvgjue1JhZQt3N5RIAJGh22pI7WplaSRx2H0Z6Mp7ECS0IuokYXJbyUk3Q99Zs5vISQ38P2iugfsQ7920VdAFkeic9ZQ2PZWkRRR3ze9E6ndnvK7kFqu9rXys9FnXRkP6IEPg0gB71IIR9y0BuOVu9vF7neDyE/yAEI+ZFC/h6FSVAsRG3pgkwme/izAb3eGBFB7SPVtxdNnUWq1+v1qluGSo+Jy80bMqILoLBwG8uWfdel8CorK+Xzzz9l8eKXEUWRyy+fy5FHHs13333NlCkHc/bZ51NcvIs77riNF154jQceuJunnnqe9PQM7rprAWvWrGb8+An790uFUYWXSpcIdYo1SY7vPIk0KGIsMzOLzMwsjj76d8iyTHV1VThX43rWr1+Hp2wnCCIaUwJaazpaW3qPI9s70sdT2VQe2bbE56Iz2gEwxqRhjs0K+24pKwEdGRN7dN7y9f+LOLm7arcT8nsijvvtMVjiyZp8Hk0V6xFELY6M8Wh0RuKyD8bdUBz50Y1JG4vBHEts5mQlpyIQYwuSVDCcgM+JbreViDqjjazJ59JYthaQiUkfh85k77K9QU8zTeXr8bvq8DZXkDzqOPTWBPxOZcGERmfqNmq/z20ADFGR/kFxgq/f9RM6UwzWxIIoB//oumAw+0gcdiSJw47sUKYvxKSPpblqc8Q/SG9J6NY3zGZQnJhbfN1Hs+4MWQ4hB9xKkuygJ/zuVsRV0AMhL1LA02X6Eb3egMVsweqwYrXGYrVaMJst4aTZZsxmCyaTGbO5s1yNJpKTY/ol0LGKSntaU9vMn38VPp+PCy44i/fe+y/z51/GsGHD2bFjO263k7vvfhA5EGDhXQtY/I9X+OabL3nllZeIiXFgs1k59NAjSElJ5cMP34+kz5k16wQ++ugzqqoqeeih+/D5vBgMRm688VaSk9us0j6fl/vuu5PKykoCgQDXXXcjI0cexH333Ul5eRmhUIhzz72AY489niuvnMdf/3or2dk5fPDBe9TV1TFz5qncccdtJCUlU1ZWykEHjeaGG27h1VdforBwGx9++G8yMjJZu3Y1f/hDW3ip5OQUHn30qUie0WAwiF6v5+yzz0ev14X3hdDrDTQ1NWKz2UlPV3w4x44dz9q1qvBSGYTY584Bus7V2BlKFOwUkpNTmDHjWEKhENu3b2PdutWsWr2S8rJV+KpXoTHFobGmo7NnIeq7/iG1p4xEozcpUcvNsdhTx0RdK33CGbjqdoUjq+cpUfX3QNDvjoiuVporN3UqvEDx+0qyHR21z+RIJ2faH5TYXN5mmqs2U7jkWRzp48iYeBY+Zy33X/g6If9L/One4Vjic0kdc3JUMmu9JY6k4TP22F6A6q3fRKZVg74Wqjd/RdYhF+Ks2YYcCmBNGo5W33VS5+8/UqLuH322i2ZHBj5XHVqDlbqdyyPCx5KQT/q4WV3W7e9cjaaYNLKmnEtL5RY0ejMxaWO6XbBxzTFPAF37eMmhAJK/RXkFnEj+FuSAC4Lu8ArW6Gk8k8mMwxFLbGwqMTEOYmIc2O0xxMTEYLPZwy8bVqtNXWWtMuQYNWo011xzPc8//zRffPEZJwwbjuDzEQwGeeqpx/nnP9/AZrNzww3XdHuep59+grPOOofp0w/jl19+4rnnFrFw4T2R4x988D4pKWnceef9lJQU8+OP37NlyyYcDgd/+9vduN0uLr30QiZP7vz+ClBSUszjjy/CYDBy9tmnUVdXy0UXXcqHH74fSQE0eXK0xVur1eJwOJBlmaeffoKCghGRxN2gpEC6++4FXH319Tgcsfh8XoqKdpGRkcmPPy6joKBnvpr7AlV4qXSJZ37XsdZ6ikajYfjwkQwfPpLf//5cqqur+PXXn/jll5/ZuXMd/pp1aExxaG1ZaO1ZiLqO4sESl92lH5IgiL1OxyJqdAgaXdS0lqaTsAB7Qme0YY7NZNfyl2n9Ua8v+gm9JQ6TI51XPrACiqXLVbeTprK1kfANvcXnjA4FEvA2IQAxqaN7VH/kFCWEhChqcWRMAKBs7YdRq9Fctdvxuxs6rBRsrbsvMNqSMdo6BpDtjE/WzwRQnMV9zYR8DUi+JiRfMwSaI+FBWolxxJKckUxCwkgSEhKJj08gPj6BuLh4YmNjMRj2TZorFZWBIfrBYvhwxXUhOTmZuro6pPh4ZJ2O5uYmYmJiiIlxADBx4qTdT6ScLewzsWNHIa+99k/eeEMJZ6PZzZ2juLgo4nqizH6cz6OPPsiUKYrQMpst5OTkUlYWHVS4vTtjenoGZrNyD46PT8Dv71mieZ/Px/3334XZbOb662+O7N++vZCFC2/liiuuiaSDuv32u3jkkfvR6fTk5eVHvv9AoAovlS7xn9AxLMXekpSUzEknncpJJ51KfX0dP/20nOXLl1FcvBpf9Wo0lmR09hy09syopM79iajRkZh/ONXbvlVS+mgNJOQfusd6neFtKmf3G56nsQwQWLrREbW/feLp3mKJz6a5sk0AGWPSCPqcCAENOlPMHuunDyvr87X3pu7eIktBJG8jIW8dy8p8yP5GQr7321L86PSkp6aRnj6MtLR0UlJSSU5OITExGYNh30ZiV1EZaPR6PXV1ykPZli2bo47tvrBJttlAoyE2Ng6Px0N9fR1xcfFs3ryRww47Er3eQF3YvaSysoLm5iYAsrJyOO+8Cxk7djxFRbtYterXqPNmZ+eyadNGjjhiBmVlpfzjH88yduw41q5dxVFHHY3b7WL79u2kpaWFr1FLdnYOW7dujqyw72wRliiK3aYAlGWZW265nkmTpnDhhZdE9u/cuYMFC27izjvvj7Jq/fTTjzz22CK0Wi233vpXZs48dU/du89QhZdKlwhVSrgDOblnFoneEhcXz4knnsyJJ55MZWUFK1b8wPfLllBXsQKh6lc0tgx0jjw0psR+XzruyJiAJSEPv6seY0xqpxHMe0Jnq/qM9lTMcVkkxCpBJOualOlFy14kSk4cfjQIIu6GEgzWBEIBbySgqj11NMkjj+u2jzxOxbpjsratIozNnISrblfUVGNncbE6q7uvkAIuQu5aQp5aJG8dIW9DRGRlphrIGpVNXNIxZGZmk5WVTUJCoupgrvKbZerUQ/ngg/eZP38uI0aMwmLpxnIfDIIsIwgCN9xwCzfddB1mswW/X/l/PXLkKKxWK5dddjE5Obmkpir+lldccQ2PPvoAfr8fn8/LNdfcEHXa0047k/vvv4srr5xHKBTimmuuJz+/gAcfvIf58+fi8/m49NLLiI2NY/bsc3j00QdITk7ZY1ij9PQMduwo5N133yQ/v6CDj9eSJd+yevVK/H4/y5f/AMCf/3wlr7/+Mn6/nyeeeAQAq9XKAw88RkJCIpdddjEGg4Hjjz+RvLzO05ntD/ZZkuyBQE2S3b/EnK5M7fTGx2tvkWWZbdu2sGzZEn76aTk+nxeNwY7GnovOkYOoHXwxc5rK11O7YxlS0E9M+lgShx2FIAjcetwCAt4WrnzsEBzpY4lJG7vnk/WA3RNhA6RPOLPbsBBfva2kf9rdT8vnqsNVs71b5/qu6vYHUsBFyFVN0F2N7Kkh5FciyCvTAcMYNqyAvLx8cnLyyREvAKApZv+Nx/5iX/4/PZAZ7P22e8LkwUJnAVQ1hcqimt3jeD377FNkZ+cMqAVosHDAJclWGXq4r752v19TEISIT9j551/EL7/8xHdLvqFw2xr8tWvRWtPROfLRWFIGRQBFgJi0McSkjUEOP0228vFGJfBo9sHj+/V6AW9Tx32e5k5KtjFq6oZO9xss8ZEo9b2t2xfkkJ+gu5qQqxLJXUUonGLIZLYwaswohg8fRUHBCDIzszrEknL79/94VFE5UJCS9s3MhUrvUS1eQ5zB/kTYX1RUlLN06bcs/f47XM4WNHoLmpg8dDF5iD1YyXgg4Wkqp+TXdyLbgqglZ/ofOoSsGAzIsozkayLoLCfkqiDkqQVZRq83MGLEKEaPHsPIkaPJyMg8oKcMfyv/T/ubwd5vQ8nipbJnVIuXyoAjhlehSOld56/bX6SmpnH22edz5plns2rVL3z77dds2rQOf+36QWkFA4izKI6q9a7uLUq9xRSTRtq402gsXY0gaonLPniPosvVrKwWtdjd3Zbrj7qyFCTkqiLoLEdyVUQSOmdmZjNu3KmMGTOe/PyCXkdHF0Ph8agZ+PGoojLkaF0pqIZGGXBU4aXSJbYr5gH718drT2i1Wg4+eBoHHzyNqqpKliz5hiVLvsFV8h0avVWxgjlyB4Uv2OVHPgv0f25BAGtCXq/CaCz/RFm12Rc/rZ7UlYJegi1lBJ1lSO5qZCmIXm9g/NhxjB8/kTFjxhMbu3cJrW3O8Hgcgj5eKioDjaa4CFBzNQ4GVOGl0iXua/860E3oluTkFGbPPo/TTz+LlSt/5ttvv2LLlrVhK1ha2AqW3G1Qzn3JB2tOH5Drdsboaev7vW7I10ywpYyQs0yZQgRi4+KZNPUYxo+fxIgRo9DpdJ3W7Qtu0+AejyoqgxlpH61OV+k9qo/XEGew+0DsbyorK1iy5BuWLv0Wl8up+ILZc9DF5PY4TZFK58iyhOSpJ+gsJeQsJ+RTHPozs3KYPGkKEyZMJjMza1BN9w4W1P+nfWOw95vq43Vgofp4qQw44q6dAEg5uQPckp6TkpLK2WefzxlnzGbNmpV8993XbNiwHn/tBiU4a0wOWlsGgth/lpiuSLJVA1DdkrTPr7UnnI3KjcHqcPaqniwFaarwEnJWYtSsRwp4EUWRkSMPYuLEKUycOJm4uP71YesKMRQej5qhMx5VVAaCf/3rbc444+yofb6WZi645Hzee//jTutUVJRz8cXnRSLe+/1+TCYzd9/9AHZ753lkKysrueeevyHLMna7nYUL78VojM4I8fe/P8K6dWswmUzMn381o0ePobS0hHvvvQNBEMjLy+e66246oBfX7I4qvFS6xPaXK4DB5ePVU3Q6HVOmTGXKlKnU1dXy/fffKcFZy1cgiOHgrPYcNJakfTYVOe/wxcC+8fHqLSs+nQb0zMdLCrgIOisU53h3FSu+vxtRFLn6ah1HHXU42dnDI+k99ic2Z3g8qj5eKird8s9/vthBeGlKSpQgqt2Qk5PLokWLI9vPPbeIjz/+kPPPn9Np+XfffYNjjjmOM8+czfPPP83HH3/AWWedGzm+bNlSiouL+Mc/XqG5uZnrr7+KF198jaeeeozLLpvPpElTePjh+1i69DuOOuroTq9xIKIKL5Uucd9460A3oV+Ij0/gtNN+z6xZZ7Jt2xZ++GEpP/20HE/JLkStEY0tA609q98j5L+36vf9dq69Zexha7s8JssSIXcNIVelEvLB2whAfHwiE6cdxzFHC2RlZXHEEVcN6NSP23xgjEcVlf6iuLiI+++/E41GiyRJLFx4D59++j+am5t45JEHuPzyq7nrrttpaWkhIzkZNBoAPv/8UzwedyQBdWfIskx1dRUZGRlUVJSzYMHNxMfHU1NTzdSph/KnP11BQcEIqquVDCdut4vk3fzIdu3awdSp0xBFEYfDgSiK1NXVsmXL5kgOxWnTDuWnn1aowktFBSBw6OED3YR+pX1w1quvvoJvvlnGTz/9wKrVK/E0FCLqTGgsqWhtGWjMyQiiZq+ut7lyVD+1fO9JyqyOfJZlGcnfTMhVRchVheSpRgoFEEWRYQUjGD/uJMaPn0Rqatqg8tcK6A6s8aiisrf8/PMKRo0azeWXX8OaNatwuZxcfPFc3n//XW644WbefPM1cnPz+dOfrmDDhvX8unYNAMcff2Kn59u1aydXXjmPlpZmfD4fxx13IieeeAo1NdVUVpbz2GNPYbFYufzyP7Jly2YSE5N47rmn+OKLzwgE/Fx66byo8xUUjODtt1/n978/h6qqSnbt2oHX640KNm02W3C5eucCMdRRhZdKl3SVYuJAwGAwMHnywUyefDBer5fVq1eyatXPrFmzGk/jDkSNDtGUhMaSgtaagqi39foaqfZyACqa0/q7+b1ClmUaKwUkbz1m/WYlNU/AAyhWrTGTj2Ds2PGMGjUak8ncoX5hoXKDHDZsYBeuaELh8ag58MajikpfOOWU03jjjVe4/vqrsFis/OlPV0QdLykp5tBDDwNgdP4wtJruHyZbpxp9Pi833ngdcXHxkXh7+fnDsdtjADjooDEUF+/irbde49Zb72Dq1On88MP33HPPQh5++InI+Q45ZBqbNm3gqqvmkZOTz4gRo7DbY6L8udxuF1brb2vhkyq8VLrEesM1wND08eoNRqORadMOZdq0QwkEAmzatIHVq39lzdrVNFT9iq8KNHorgikRrTkRjSkBQW/bozVo7mEvAfvfx0sK+pQE0556Qp46ZF89Py1ZCMCJJ65g5MTxHHTQWEaNGk1i4p4d/2+4QXGW/eADzz5t956wOsPjUfXxUlEB4Pvvv2P8+Ilceuk8vvjiU9544xVuvXUhrcEKcnNzWb9+HUccMYPCZUsIenuW6N5gMLJw4d384Q/nM2bMOKxWK0VFO/F6veh0OjZuXM/Mmadis9mxWBTRlJCQQEtLtBtCcXERSUnJPPvsS1RVVXLPPQux2WwUFIxg5cpfmDRpCsuX/8CkSVP6t2MGOarwUukS160LB7oJ+x2dTse4cRMYN25C2MehkvXr17Jhwzq2bt2Cu0JZWSdqjQgGBxpjLKIxFo3BgaC3Rjnqv/Pr2V1dpl+QQwEkf4vy8jUqvlmBJkL+1gjzAqlp6eTnTWfaIc1kZmZz/PHP9Hr68NZbff3e9r7gMv/2xqOKSneMHHkQ99yzkFdeeRFJkrjqqusAyM3N4667FnDTTbdzzz0LmT9/Ltnp6ehMSmDpnvh4xcXFc8UVf+Hhh+9j4cJ70Ol0LFhwE/X19cyYcSwFBcP5y1/+yuOPP4QkSciyzHXX3QjAE088ysyZp5CVlcPzzy/iP/95D71ez3XX3QTAlVf+hYceupfnn3+a7OwcZsw4dh/31OBCjeM1xBnscW4GK33pN1mWqawsZ9u2rRQWbmXXrp2UV5QhhUJKAUFAo7eC1oqotyJoTYhaE4LWhKA1IIg6BI0ORF2nKymV/4oySCFkKYAc8iOHfMp70IMUcCMH3cgBNwRdkelCAFEUSUlJIzs7h4yMTPLyhpGVlYPJ1L8R/NXx1jfUfusbg73ffitxvCoqylm48FYWL365R+Xfe+9tpk07jIyMzH5rw/5AjeOlMuBoNm0EIDTqoAFuyeBAEARSU9NJTU3nyCOVFTjBYJDy8lJKSoqpqqqkqqqSysoKampKSYqpAgmKSzqJgSOIYcuTgCAIyLKMLIWArh8cNBotDkcs8SkJJCWNJjk5leTkFFJSUkhJSes29+GmTYrQGzWq9zfjvanbn2iC4fGoVcejikqv8YQf1Pr5YawzDj98BikpKfv8OkMVVXipdIn1lhuAA9/Ha2/QarVkZeWQlZXT4Zi94USCoSCr6x+hubkZr9eDx+PG4/EQCPiRJBlJkpAkCY1GRKvVodPp0Gq1mExmrFYbFosFi8WKw+HAZrP3eZXhLbcYgL75ae1N3f7E6gqPR9XHS0Wl12jKlCTzfVkslZqa1mNrF6CKrj2gCi+VLnEtvHugmzCkcdvuBWB4wsgBbgksXNh3P629qdufuCzqeFRR6SuhtIFdXa3Shiq8VLokGA5wp9I3gtrB038TJ/Z9mnBv6vYng6k/VVSGHAOQbUKlc347yZFUeo1m3Vo067qOeK7SPZrgWjTBwdF/69aJrFvXt//ue1O3PxlM/amiMuRwu5WXyoCjWrxUusS64GZA9fHqK1ZXuP8GgU/SggV999Pam7r9yWDqTxWVoYamvAw4MANiDzVU4aXSJc67HxjoJgxpnJbB03933913P629qdufDKb+VFEZaoTS0vv9nDNmTGPMmHHK+UNBQiGJO+64l7Q9XKuoaBfz5l3MRx99jsFg4Mor21INFRcXcdJJpzB//lWRfU888Sjbtm0BoL6+DqvVFnH2lySJv/71LxxxxJGcfvpZ/fwN9w2q8FLpktDYcQPdhCFNSDt4+m/s2L77ae1N3f5kMPWnisqQw9wxHdjeYrfHsGjR4sj2Bx+8z9tvvx4JlNoZLpeTRYseR6fTR/a1nqOsrJS//e0WLr54blSda665HlDC98yfP5ebbmrLBvKPfzxLS0tzv3yf/YUqvFS6RLvqV0B1su8r2mC4/waBU/iqVYqPVl8c5fembn8ymPpTRWUw8Mkn/+V///sISZKYO/dPFBXt5LvvvsHr9RITE8N99z3CF198yo8/LsPndlFWXsYFc/7AzJmnsnHjeh577CHMZjOxsbHo9QZuu+0O3nvvbb744jMEQeDYY49n9uxz+fXXn1m7djV/+MNl3banqqoSm02JWzh79mkcdNBoystLyc3N5+abFyAIAg89dC/z5l3BLbdc36H+k08+yvz5V2HuQiS+997bHHLINPLzhwHwzTdfIggCU6dO38ue3L+owkulSyx3LgBUH6++YnGF+28Q+CTdeWff/bT2pm5/Mpj6U0VlsGCz2XjggceQJIm1a1fz978/g16v5eqrL2fTpg2AYmV64vJrKKms4IZnnmDmzFN55JH7uf32u8jLy+f555+mtraGnTt38NVXX/DMMy8AcO21VzB16jQmTz6YyZMP7nDt5uYmrrxyHm63i+bmZo466mjmzv0zADU1VVx22SIyMjJZsOBmli79lsLCbUyffjgFBcM7nKuwcBsul4spUw7p9HsGAgE+/PDf/OMfrwKwY0chX3zxGffc8yD//Oc/+qEn9x+q8FLpEuf9jwx0E4Y0Tsvg6b/77++7n9be1O1PBlN/qqgMFrKylPQ1oiii0+m4447bsFjMVFdXEwwGARg2bDih9AziExPx+/0A1NbWkpeXD8D48RP56qvP2bFjO1VVlVxzzXwAWlpaKCkp6TRANLRNNYZCIe677w60Wl3EWpWcnBJJGTR27DiKi4v4/PP/IzExiY8//pD6+jquu+5Knn5aEU2ff/4Js2ad0eX3/OWXFUyYMAmrVUnP8+mn/6Omppqrr/4zlZUVaLU6UlLSmDbt0L3pzv2CKrxUukRNFbR3DKbUNnuT7megUwW1Mpj6U0VlsNCa97WwcBtLlnzLP/7xCsGgj4svvqBdGUFJFSS2hYVJSkpm584d5ObmsWHDOkARcTk5eTz66JMIgsA777xBfv6eV0FqNBpuvPE2LrnkfMaPn8ihhx5OTU0NdXW1xMcnsHbtGk48cSbvvPNBpM5ZZ53KY48timz/8svPXHDBxV1e45dffooSVZdffk3k84svPk98fPyQEF2gCi+VbtD+tAKA4CFTB7glQxNtINx/uoHvv59+Um64hxzSexG1N3X7k8HUnyoqg42MjExMJhPz518KCMTHJ1BbW9NWwOUEf5v1+vrrb+L+++/CZDKj02lJTEyioGA4U6YczOWXz8XvDzBq1GgSExN75ONlMBi5+eYF3HPPHUycOBm9Xsfjjz9EVVUVo0eP5bDDjuy2/fX1dcTEOCLbdXW1PPnko9x55/2AstrxxBNP7lPfDDYEWZa7zso7xKircyJJB8zX6RGJiTZqalr2ybljTp8JHJg+Xvuy31qJaQr33yDwSTr9dCUxbl/8tNrX3R/91hWDqT97y0D221BmsPdbZWURKSnZA92MDmi1IsFg9IOSpnAb0BbH6/333+WYY44jNjaWxYufQafT7dF5vjfMmnUCH330WZ/rB4NBnn32Ka666tp+a9Oe6Kzfdmf3v7koCsTHW3t3nT61TuU3gfORJwa6CUMap3Xw9N8jj3gHpG5/Mpj6U0VlqBEK+1u1EhcXx3XXXYHJZMZqtXLbbXcMTMO64fzz5wx0E/YJqvBS6RI1wvHeEdIMnv4bNqzvluC9qdufDKb+VFEZchiNUZtHH/07jj76d/vscntj7QLQarXExyf0U2sGF6rwUukS3Q/fAxA49PABbsngxefz0dTUSEtLC16vB4/Hjcfjwev1kmBehyzLlDcOR5ZlNBoNWq0OrVaLTqfDZDJhMpmxWCyYzRZsNjsmk2mftPOHHzQAHHpoaL/W7U90gfB41KnjUUWltwhOZcpWttoGuCUqqvBS6RLzQ/cBB6aPV08JBoNUVVVSWVlBTU0V1dXKq76uhsamJrzerqfh7vvzDwAs+nfPV9oY9HpiYhw4YuOIi4snISGRxMQkEhISSUpKJjY2DlHsfcLqhx5SokT3xcdrb+r2J2Z3eDwOQR8vFZWBRqysBCA0TBVeA40qvFS6pOXvTw90E/YrbreLnTt3sGvXTkpLiyktLaaysoJQqM3SY9JpiDOKxBlEsuJEbHorVr2IRSdi0AgYtQIGjYheI+DbdgyiALcfpkRylmQISTJBWSYkgS8k4QnKeIMS3qCM0y/h9Eu0+JtoqWxgc3EhTd4g7Sf69DodKSmppKSmk5aWTnp6BhkZmSQmJncryP7+9777ae1N3f6kxfrbGo8qKv1JKDNroJugEkYVXipdIuXkDnQT9hmSJFFaWsK2bVsoLNzKju3bqKquihx3GLUkmkWmpxpIsmhJMGmJNWkwaXthbfLHIANRVTRC+409niIkyTT5QjR6Q9R5Q9S5Q9Q6K9m2roKff/oxIsp0Oh3paRlkZeeQlZVDVlY2mZlZGAyKX0dOTt/9tPambn8iaQ7c8aiiss8xGAa6BSphVOGl0iW6774BIHDU0QPckr2nVWht2rSezZs3sb1wC06XCwCrQUO6VcvobCvpNi1pVh0mXe+n83bHllAGQEttep/PoREF4kxa4kxa8nY75g/J1LiDVLmCVLuCVDWV8fOPxSxZovzdBAFSklPJyc2npWUqycmp/P73cRh3c7LdE999pwjEo44aYB8vf3g86of+eFRR2V/ceutfue++hxHCiaTlcC7F7njxxef54ovPSEhQnNubm5s49tjjOySvbs+3337F66+/giDAccedxNlnnxd1vLGxkTvvvA2fz0dCQiK33rqQkpIinnji0UiZjRvXc999jwyZQKh9RRVeKl1ifvxhAJqGqPCqr69j/fq1bNiwlk0b10eEVpxJS4FdS1a6nWy7jlijRons3M+kDl8N7J3w6g69RiDdpiPdpovsk2WZJp9EpStApTNIubOO9Str+OybmYCfr7+eS2pKKrl5w8jJySUnJ5+srCx0On2X13n8ceXYUUcNsI+XJzweVeGlotJj7rtP+X8jVikW/VAPhBfAueeez+mnnwWA3+/nwgtnM2vWGcTGxnUoGwqFeO65RbzwwmuYTCYuvHA2xx9/Eg6HI1Lm5Zf/wXHHncjMmafy2msv8+GH73POORewaNFiAL7++ksSE5MOeNEFqvBS6YaWpxcPdBN6RSAQYOvWzaxbt4b161ZTXlEOgM2gJS9GS166nVyHnhjDnqf4+oOdK4/aL9dpjyAIOIwaHEYNI+Pb9p+e+zJVziB+0UyZs5bVP1exbNkSQMnxlp6eQW5uPjk5eeTk5JKRkYVWq9wenn56sPh4Da3xqPLbI+b0mXjPvQDfuRdAIEDM7NPwXnARvtnngttNzPln4b1kLr7Tf4/Q3IT9ovPw/PHP+E+ZhVBXh33uHDzzr8J/wkkIVVXIycndXu+TT/7LsmVL8Pl81NXVMnv2eSxd+h07d27niiuu4YgjZkQCmc5//CEK8gvYUbQLt9vJ3Xc/SEpKKnff/Tcuu+xyUlJSurxOc3MTwWAQg8HAiy8+T3HxLhoaGmhpaeYvf7mR8eMn8Prr/0Kr1dLQUI8kSeh00fJi7drVzJnzBwCmTTuUxYuf5pxzlLRGHo+Hl156nkWLhlay676iCi+VLpHSMwa6CXukoaGBdetWs2bNKjZuWIvP70cjCmTbdRyfayU/1kCSed9YtPZEwNu7aMb7kvzEJvITAZQ2ybJMs1+ivCVAuTNIWUslP/9YFpmm1Go0ZGRkkpObT1ZWDtnZuQQCAzseJM3gH48qKvsbt9vN448/zZdffsY777zJ4sUvs3btSt5++02OOGJGW0FBYNSYcVxz3Y08//zTfPHFZ8yZcwkLFtzV6XnffvtNvvzyc6qqqkhMTOTmmxdgNlsAJT3Qk08+x44d27nzztt55ZW30Gq1fPfd1zz22INMn344RmN0aByXyxVJcG02m3E6nZFjH3/8IUcf/bsoC9mBjCq8VLpE9/UXAASOOW6AW9KGLMsUFe1k9eqVrFm9kqLiXQDEGLWMjdNREOcg16FHr9n/Qmt37ImlADTXDLxg+GHLaAAOHbEBUCxjMQYNMQYNo8IxCmVZpsEbotwZpMIZoLypnOXLSnj33fHAKlJSVpOVmUFaenbYeV95td5M9zU6f3g86gfPeFRRaU9U6B2dLnrbbI7alu0x0dvx8dHbe7B2tVJQMAIAq9VGTk4ugiBgs9nx+fxR5YRQiBFpittDcnIydXV13Z63dapx8+ZN3HHHrWS2WxU5efLBAOTl5VNf33aeo446hiOOmMG9997Bp5/+j5NPnhU5ZrFYcLvdGAxG3G43NltbWIvPP/8/7rnnwR593wMBVXipdIn5yccBaBpg4eX3+9m4cT1r1qxkzepfaWxqQgAy7HqOzbEyPE5Pklk7IFat7kgpWAMMDuH18rdKnsNW4dUZgtDmyD8mUXHAl2WZuc+dhz8k8/vJW6hormRdZTk//LA0Ui/W4SAjM5uMjCwyMjJJT88gJSUNvb5rv7G+YPaEx6MqvFRUIvT4vuf3I9Z3L7Y6Y+TIUVx44cUsXHgrzz33EgBbtmzihBNmsmNHIYmJibhcTm666Toee2wRer0ek8nUIbzN2LHj+fHHZcyceSrLl//AuHETAHA6nQQCAZKTu57qPNBQhZdKlzQ//88Bu3ZDQwNr165i9epf2bhxPYFAAL1GJN+hY8ZwOwWxBiz6vV95uC/Z8evgcQK/7/zn+1RPEAQeulDxrUqwtVm2nH6JKleASleQKpeX6p0b2bhhLaFwknpBEEhMSCAtPZO0tAxSU9NISUkjNTU1Ml3RW5ptAzceVVSGOrLRiJTecaFPT3y8TjnldL766gv+85/3ANi6dQvXXDMfj8fDjTfejsVi5bjjTuSKKy5Dq9WSn1/A8cefRF1dLU8++Sh33nk/F188l3vuuYP//vc/xMQ4WLjwXgBKSopITU3dN196kCLIsjw4gvT0A3V1TiTpgPk6PSIx0UZNTctAN2OvkSSJoqJditha9WtkCtFh1DI8VsfweAM5MXq04uCyaqm0EZJk6jwhatxBqt1BatxBatwSdZ4gUrvbjN1mIzklleTkNJKTU0hJSSExMZmkpOReh7oYKhwo/0/3N4O93yori0hJyR7oZnRAqxUJBqV9cu4XX3ye+Pj4yIrH7ggGgzz77FNcddW1+6Qt/U1P+m33v7koCsTH987dQrV4qXSJ/rP/A8B/wkn75Pxut5uNG9exZs0q1q1dRXNLy25TiAPnGN8fxCQXA9BUNfARo5dsHA/AkQet2Wd1NaJAkkVLkkXL6Hb7Q5LiO1brCVLrDlHnCVBXtYvVRTtw+oNR57DbbCQlpZCYlBxJldT6nmxZgSiK+PX7ZjyqqBzICE1NAMgxMfv1uuefP2e/Xm8ooAovlS4xPfsU0H/Cq9WqtX79GtavW8P2HduQJBmTTkO+Q0dBmp1hjsE/hdhTkvPXAYNDeL2+9Higb8Jrb+qCIsgSzFoSzFqIjz7mDUrUe0M0eELUe0PUewLU1+5iY9lOmndLl3Tfn39Ep9Py4hcXEx+f0OEVFxfXbTwyFZXfMmJNNQChvRRec+f+qcdltVot8fEJe3W9AxF1qnGIsy9N8UJ41YscH7+Hkl1TW1vDhg3r2LhxHRs3rscVDmKaZtOR79AzLFZPhl2HZohatbpDo1fiX4X8Az991uhSTOEOi3MPJfu37t4QlGSafSEavErKJJ/gockXoqxRS7NPpsUXLcwAbFYr8fGJxMUnEBcX3+4VR3x8AjExjj4lGd9bBvuU2WBlsPfbkJpqDAZbD+7/Bg0R1KlGlQGnL4Krvr6OLVs2sXnzRjZvWk9NbS0AdoOWYTFa8jPs5B9AVq3u2FeCq7DGyaebqwmEJI4uSGBCumOPdfZGNO1vwdWKtl26JAWz8ha+57UKsyafRJMv1PZqLqO4ppT1vhD+UPRNVBRFHDExxMUnRgRZbGy0QLPZ7AMizlRU9imq4Bo0qH8JlS7Rf/wRAP5TZnV6XJIkKirKKSzcyrZtW9i2dVNEaJl0GrLsWqbk2ciL1ZNgGrq+Wrvz4656Nle1kOEwMWNYAjpNxx9ptz9IkbSGGpcfZ1UuJ4xMRtMPCwPqXX7+vmQ7gZBi69lS7eSvxxSQn9D9SsGv108C4JgxK3t9zb2puycqm73Uuf0UJFjR7yEBuSN1FwCNFTlAe2HWeXlZlvEGZZr8IZrD4kx599Bcs4vCcmU6M7iblVyj0eCIcURZzWJj44iLiwt/jsdms6niTGVIITQ2AiD/RoKUDmZU4aXSJaYXngPahFdLSzM7d25nx47t7NhRyM4dhbjcbgAseg2ZNi2T82zkxOhIsmgRDxCh1Z5PNlbx4foKZaOogaJ6N3+cntOh3Isrirnq0kJGAX+614TTH+LsCXufs3F9ZXNEdAHIwOqypj0Kr7eXHQv0TTztTd3u+M/acj7drPid2I1arp8xjBR711bCpFwlBlmr8NoTgiBg0gmYdCIpXXSPLMu4A63irL1Ac9Fc3czW0h00e4OEdvPI0Go0OBwOYuMSiI9XxFhsbByxsbHh97gBm9ZUUekMsbYGgJAqvAYcVXipdECWZRoa6ll/4y2UlhRTuOgxinbtpC4cfE8QIMmsY7hNQ1a6nawYHXH7KNH0YGPZzugAhL+UNnJhIIRR15b/0RsIsb6imeseGxbZ92tJY78Ir0SroZN9e3Yof+yiRX2+5t7U7YoGt5/PtlRHtpu9QT7ZVMWlU7v2lyn8qf8DpwqCgEUvYNGLpFl1nZaRZBl3QKLZJ9HsV6Y2m9uJsy2lO2j2BSMxzFoRRRG7zUZsbDzJKUmYzTZiY+NwOGIjr5gYBxaL5Tfxf0dl//Pkk4+SlZXN6aefRSg3t9MyL774PF988RkJCYoTfHNzE8ceezwXXzy323N7vV6uvfZybr75b2Rn5xAKhXjwwXsoKSkCBP7611vIyxsWVefbb7/i9ddfQRDguONO4uyzzwPg0ksviMT3S0tL59ZbF+7lNx/cqMLrN4wsyzQ2NlJZWU5FRTllZaWUlhZTVlqM2+OJlIs360gxi0zMsZJh05Fq02LoZHrtt4DVoKXW1ZaKw6AVO8QW02tE7EYtzW1dSLxl71fbVbX4cPmCHJLl4OfiRmRgTKqd6Tlxe263ybPHMvuiblc4fUF2X9bT7A12XjiMFByYFYuiIGDVa7DqNaTRuTiTZRlXQKYlPK3ZHH5v8ftobixlR00JzX4JbyDUoa5Wo8Fut+NwxBHjcGC3x2Cz2YmJiYl8Vl42rFZ1ilNlzzQ0NHDHHQsoKSlqC+eg6frnvjU9ECiZQi68cDazZp1BbGzn95bNmzfy8MP3U1PT9vC0bJmSzeLZZ19i5cpfWLz4GR544LHI8VAoxHPPLeKFF17DZDJx4YWzOf74kzCZTMiyzKJFi/f2aw8ZVOF1gBMKhWhoqKeurpbq6ipqaqqprq6kuqqKyspyvD5fpKxBK5Jk1jAqRktymo1JRaU4DCLOScO6ucJvi9PGpPDMsp0EQjICcPqYVLS7iVBRFDh3YgYlrCIoyfy4OpGzxqft1XW/3lbDu6vKkFF8my45JIu8eAtJto4WsM74fI2SW+348T/3+tp7U7crMhwmMhxGShu9kX3Tc2K7rRObtgOAhvK8fmtHfyEIAla9gFUvktrNAid/SMbpD9Hil8KvEE6/hNPvoaWhhPKaYrb6Jdz+UIcVm63XMRmNWK1WrFY7VpsNs9mC2WwOvyufjUYTJpPyMhqN6PUGjEYjBoMRvV6vWtj2ETFNM/EaLsBnvADkADHNp+E1XoTPcC7IbmKaz8JrnIvP8HsEqQl7y3l4jH/Gb5iFINVhb5mDx3QVfv1JCFIVsth9vka3282dd95GS0sLubl5rF+/lldeeRuPx82ll85j+fJlkbJCQwN3P/Ygf7ziL91GqW9ubiIYDGIwGHjxxecpLt5FQ0MDLS3N/OUvNzJ+/AT8fj/33fcwd9/9t0i9I4+cwaGHHg5AVVUlVqst6rwajYbXX/8XWq2WhoZ6JElCp9NSWLgtbD27glAoxLx5VzBmzNi+dP+QYcCEV2lpKbNmzWL06LZQi1OnTuXKK6+MbF977bU8+OCD/Z7z7UBAlmXcbhdebyNFRRU0NTXS0FBPY6Py3tBQT11tNY1NTUhS28ouUYAYo45Yg8C4OA0JZhsJJg0JZi02vRh1Qx7+320AbO0n4bW12snWGic5cWbGpNr75ZwAu+rdbKhoJjXGyIT0mD36lq0tb6K4wcPIZCvDEjr/lQyGJH4pbaTe5WdCuoO0GMX3SK8VOXpYAqIgcFhufJfCZ3Kmg1MmN+P2hxhjnEJefO/S5JQ3eVhd1kS8Rc+E9Bg+XF8R+SEOSjJfb6thWg8sXa28t3wG0Dfx1JO6JY0e1pY3kWQ1MCnD0e1CgkBI4peSRsak2MmJNeMNSkzOdDApw9FtOxJzNgH7Tnj1dhwB1Dh9/FrSiNWg5ZCs2D0uENBrul8Q0Err9KYrIOEKtH12h1+eYDPuhiZqamS8ISUemjfQuVjrDJ1Wi06nQ6/Xo9Pp0eq06HR6dDodWq0OrVaLRqOJvERRRBRb35WXIAgIghD5DAJKlwnhY22fgQ7boDyktJWPfkmSTFnZLurqGsjPH0ZiYjKiKKLRiAiC2K5tGrTa1rZqI23XarWR76INf1+tVocu/F01mqHvHvGf//yLvLxh/OlPV7Bu3RpWrPgRUKbrkpJSo4SXWFfLwovnEupEdL399pt8+eXnVFVVkZiYyM03L4hM/RkMRp588jl27NjOnXfeziuvvBXJs7g7Wq2We+5ZyJIl33aa9Fqr1fLdd1/z2GMPMn364RiNyoPBeefN4dRTT6ekpJgbbriaN998H+0BvApzQL/ZsGHDeO2117o8/vjjj+/H1uxfZFnG7/fj8/nw+314vR48HuXl9Xpwu9243a7Iu9PpVF4tTTidLTidToKhTqYtRAG7QYtVBxlGDaPTTTgMIjFGDbFGDQ6Dpser67b94YR++75fb6vhnVVlke2TD0pm1pi9z8/1S0kDL/xYFPnBOTwvnjlTMrss//6acj4P+xb9dwNcODmTI/I7hs147oddrKtoBuDjjVVcc2Qe1S1+Xv+1JFJGkuH3XViy3ltTxpIPlHb4/DuYMyWTw/N6Fp5jc1ULTyzZTqvL0JgUG77dYsu4/B3/9t3x5B+e6FX53tRdW97EM8t2RqYOD85q4o/Tcros//T3O9hUpYSo0IoC187I71IAt2fbiv4bj7vT23EEUNro4aGvt0X+Nkt31HHTsQX9sqik/fRmT5FkGX9IxheS8QVlfCEJb1DZF5CU99bPAUkmGJIJSD6Cko+gXybkkwlK4JVkQijjOyQr760vWZaRAFlWFnbIshwZp3L4Hznci+2nkls/tg8b2b68LEeXA6ivr8cXtsj/+OMy4uLiMBh6ZuHtCYIgKIIsLMqUlx6dXo9eb4gSpnq9vt1nXWTfiBHDaGlpiYhFt+49RAQEnxdBEKg1f4AgiAihIIJgoNH+P+XagCzG0BTzSVt/iPG7bXdv7QKoqChn6tTpgJKEujsjRSi36weW1qnGzZs3cccdt5KZ2Rb0efJkxeKdl5dPfQ+SbN9++53U1dUyb94lvP76vzCZop8yjjrqGI44Ygb33nsHn376P4477kQyMjIQBIGsrGxiYmKoq6s9oJNmDypJuWLFCh555BF0Oh1nn302Tz75JP/3f//Xr//Z9jXr1q3hu+++JhDwEwgECAYC+AN+/D4fgYAfvz/8CgToSexaUVBWZZm0IiYtWLQiCUYBi82ARSdi1YuRd5teg0kr9NtTnKzvv+HxeTtHaoAvt9ZwykEp4SfevvPFlpqom/UPO+s4Y2wqVkPHtgdCEt8U1nRo1+7Cq6LZGxFdoKS8+WprDRXNvqhy3xTWMGtMSodwEoGQxDfbaglKbfs/31LdY+H11bYa2vtpr69sYWyqPapNh+X2LsaaUe/fc6E+1v1ya03Uj+zPxY38fpyfWHPHH4GSBndEdEHYere1tkfCSw7tu9tVZ+PozLGpWDoZR618V1gbJYh31bvZVuNkRJKtyzr7ElEQMGoFjFpg6Nwyo5BlRbZVtni589OKqGOp+gBzp2VExJ4iDFs/y4pIlJR9IUnZDobfQ5JMUJYJScq+YOu7LIe3AwQlP8Ggk4BfJhgCnywTkCAooQhVSSYQkglKUuT/53XXXY8g1HT8IntAQICwVTDK0hfZ395S2PXnlJRUfvppOdOnH0ZRURF+fzf/VzV7FvEjR47iwgsvZuHCW3nuuZcA2LJlEyecMJMdOwpJTEzssu6nn/6Pmppq5sz5A0ajMWwZbbu/u1xObrrpOh57bBF6vR6TyYQoivzvfx+xfXshN9xwM7W1NbhcrgM+2v2ACq/CwkLmzGnL4zR79mx8Ph//+te/AHjyyScHqml9ZtmyJaxc2bPpHK0IFp0inOwGDXa9iC387jBqcBg1WPXigEV1j1tZCEB9P0w17j4B01/fqLPz9ObcnXVtp+eMTJ30/LwnHaY8Hf7fsvjetamTfWeMTWVkkpWSRg9GnYaKZi8fb6jk2OGJmHR7vqF+snIaADMnLe9FS3pWd/f2dvddO3so6Gm/xmWEx2Np//scdtqEPbSr87EztKeuBhpFfIBG6DhlqxUFLLqBX1ggyYpV0RuUselFYo0aZIgIQMUyGP5Mu89yO8sfSqG9zRszbdqhvPDCc1xxxTwyMjK6LSvU13P34w/t0cfrlFNO56uvvuA//3kPgK1bt3DNNfPxeDzceOPtXdY76qhjuO++O7niissIBoNcffV1GAxGPvnkvwDMnHkqxx13IldccRlarZb8/AKOP/4kJEni3nvvYP78uQiCwC23/O2AnmaEQTbVuGLFCnK7WPI6VDjiiBmATCAQVCxewQB+f9ja5VOsXYGAH59fsYgpUbclyp1dr+gyaBWLl1knYNIKmLUi5t2sXVadiM2gbPdX/KyEn7cA/SO8ThiZzJsrSyPbx49I2mtrF8DxI5NY/OOuyA3siLyELq0UOo3I74Yn8X+bqiL7ThyZ1KFcil3x8VldpiSV1YoCvxueSI3Txys/t001Ts2O4z9rK9BpBI7KTyAuvHJRpxE5tiCR02dsBhThdUIn1+mK3w1PYkNlSySw56SMGNIdJtIdJpZsr+WNX9v6cUt1C9cfXbDHc37w8xFA34TXnuoeNyKJrTXOiBVganZsp9YuUJzqx6TYWF+ppIHRaQSOHd71U3R7ErLC43EfCK9Ox9EeLL4zhiWwoqgBb9jqlR9vYVhi73z5fsu0Wreg/bSjIlRizXrGp9lZU65YeTWiwGF58TT7QlECJ8raJbdZt3Z/78zaFYpYu9osWkGp1coVLicT2Q6EJIIhOSqm23VHSMje3k37t/eB687a1ZWVa/d9N910OzabnVAoxAUXnBV1pfZ5FcX6uk59vDrLvfj4408DSqiJ3/3u+MiKx91pvxLRZDJx990PdCgzfPhINm/eCMBpp53JaaedGXVco9Fwxx33dnr+A5UBy9VYWlrKddddx7vvvhvZt2LFCt5+++2Ib9cxxxzTq6nGoZarUZIkfD4fPp8Xn8/bqY+Xy+WKvDudLbS0NEfefb6OZmVRUEIe2HQCMQYRh0FDTNi3Kzbs56XT9FDwtKZb6afQETvqXGytVpzrRyb333RMaaOH9RXNpMUYGZtq3+NU68bK5rBzvY2cOHOnZUKSzOqyJupcfsanx5AcdqLfVe9mc1ULNoOGt1eVR1LS2I1a7jhxZNSP9aaqRkoaPQxPjOnyOl1R1eJldVkzCWHn+la/vAe+2srOOndU2XtnjiKhk/he7QmGFKuYVtPbH4me1S1v8rKuoolkm4Fxad07pockmZWljTR6AkxIj+k0NlmnCOHxKO8bq0dJo4cNvRhHAPVuPytLGrEatUzOcHSaxWB/EZIUK4w3JEX5ebX6dnXw8ZIIT51FC5NWv65o/y7FetPq5yXLhK05csTfC9p8uNoLKbrw4doTsizj9XoJhUIYjcZ+t4JotVr0EYf7sNO93hD25TKE/bra/LlaFx8YDG3+X/n5OSQkpHe6OKBt8UHHBQT7Ap/PxwUXnMV77/2385yDrYusehGO5MUXnyc+Pr5L4dUTqqurSExMGhILGdRcjb8BRFGMLPnuCz6fD50uxM6d5TQ3N9LQ0EBjY0NkVWNtTTVbq+oJBqOtaTaDljijQLxJG1nRmGBSpjajfjD7+UckL97S69V9PUEJTdDzPjwoxc5BKd2vqtSIApMzHR3258SZyYkz88G6iqg8gM3eIGvKmji0ne/VqGQHo5I7nqMnJNuMnDCyYxR3625WGI0oRAVv7Yq+CK7e1E2LMUZWfu4JjShwcFb3oSM6ZR8JrlYyHSYyezGOAOLMen43oufWzJ4SlGSc/raVjO3fPUFllaMnIOEJgTck4w1IHfJSdoVWowkLCZ3iRK7XoQ07l5varQLUaFpXNrauaNQgikK7VY1iRFgonyF6FWNnKxujhUe0NUdsJ1KU+6PNZsLt9odXMbatZmxtg9JGMbK6UafTRa1ujF7RqI1atdkfQqCysgirtXc/uvsKg8HAe+/9t+sCfYj/1pk1rLckJe15kcBvjQETXhkZGVHWLlDCSUydOjWy/fXXX+/vZg0pDAYDiYk2RLFra4okSbS0NFNbWxOO4aXE8qqqqmBbZQUrK9scnXUakUSThkSzhmSLlqnbi4gxanBOHbE/vs6QojO/qt0FUHzmVgDqSob323VPGZ1CYa0TT0D5kT1pVHKnCwl257+/HArAqVN+6PU196Zuf7Iv+nN/0po7sjV+V2ssL2c4lleLX8IVVFasert46tZoNFjMFiWOV7ydOIsVi8WK2WzGYlFieJlMrS9lqb7RaMJgMGIwGDAYDGh64GQ9WEhMtFFT0zLQzTggEMIrEuW43i3MUel/VIvXAY4oisTEOIiJcZCf39EXyOlsobKygvLyMsrLyygtLWZnaTFrqpuZsXwLfuBxMYEUi4Y0q5Z0m450qw7TIHByHUgOy43j+x11VDuVlY75CRbGp8VElYnPVOKg9adQyIkzc//Jo9la4yTJZiC1m9yG7fnvr4cBfRRee1G3P9kX/dlfhGTFQtWa77Gl9XOryArQaUJuAKPBQExMDDEpsSTHxGK3KxHrY2JiIhHrW6PXm0ymITFlozL4EOvrAQipwmvAGTAfr33BUPPx6g/21RNhS0szJSXFFBXtpLi4iKJd26mqror4asSbdaRbNWTadWTZ9SSaNQdkUuzuCIQkNlQ2o9OIjEqy9ctiAZXBR0iWaWmXBqjZ1y5fo1+iJSDT4g128F/SabU4HLHExsWRkpKMyWQjNjY6T6PD4cBg6Jl4/i0y2C1eu/v7DBZ64quk0hHVx0tlQLHZ7Bx00BgOOmhMZJ/b7WbXrh3s3Lmd7dsL2bF9K2urlZuiUach06ohO0ZPjkNPqlU7YGEw9hc6jciEdMdAN0NlL2hvqWpLfi3RFBZVzX5ZySu5Wz2DXk9sbCxxyYnkxsUTGxtHbGwccXFxOBzKu8VijVinBruAUFFR2X+owkulS4yvvQyAd84lAJjN5igxJssyNTXVbNu2RXlt3cyXu5Sgh3qNSJZdS65DT55DT7JF+5uziCVkKeEkaotHDnBL4D8rlJAQZ0xdul/r9ie97U9JlnEFpDYhFXkP0RQWVZ1ZqhRRFUdccgK5cfHERQkrZVud8lMZagh1tQDIuwUnLSraxcMP38eiRYtZuPAWbr/9LnS6zpPB94Yrr5yHz+fFYDAiyzItLc3Mn38106cf1m290tISbr31Bl599R0AnnjiUbZtC4eSqa/DarWxePHLkfLBYJB77llIZWUFoihy0023k52dQ2lpCffeeweCIJCXl8911900aBLMq8JLpUsMH/wbaBNeuyMIAklJySQlJXPYYUcC0NTUxNatm9i8eRObN63ni52KEDPrNeTateTHGhgWq8duGDoOvn0lNn0nMDiE1xdrlbQffRFPe1O3P9m9P/0hmSZfSHl5Q+GYeOF3v0yzL0hoN9cDnVarCKi0BLLjE9qJqfaiyqyKKpUDDrGhAYBQN1Hh77zz/n695u2330V2dg4AxcW7uO22G7sVXp9++j/+9a+3aWxsjOy75prrAUVgzZ8/l5tuig7i+uOP3xMKhXjuuZf4+eflLF78NPfe+zBPPfUYl102n0mTpvDww/exdOl3HHXU0f36/fqKKrxUuqTp/Y96XScmJoaDD57GwQcr0c4bGurZuHG98tqwlg3blICISRYdwxw6hsUZyLLr0B6A/lHbfjxpoJsQ4ZnLHhuQunuDPyTT6A3R4A3R6Avx2RuH0+gN0eSvp9En4d4tX6UoijhiYohPTGR4fEJESLW94rBabaqoUtlnnH66iXPPDXDuuUECAZg928QFFwSYPTuI2w3nn2/ikksCnH56kOZmuOgiE3/8Y4BTTglSVycwd66R+fP9nHBCiKoqgeTk7n2WP/nkvyxbtgSfz0ddXS2zZ5/H0qXfsXPndq644hqOOGIGX3/9Je+88waiKDJu3ATmDyugtraWu+66HVmWiWvnbH/WWafyxhvvUVZWwlNPPY4kSTQ2NnLDDTczdux4zj33DMaOHU9xcRFxcXHcc89DuFxOHnjgHu677+Fu21pZWYnNpoTxufLKeWRn51BUtAuAO++8j/j4BGw2O4sWLeacc07vUP+9997mkEOmkZ8fHUA5MzObUCiEJEm4XK5IvLctWzYzceJkQInw/9NPK1ThpfLbIDY2jsMOO5LDDjsSWZYpKyth3bo1rFu3hp+2beGHMjd6jUieQ8fwuN+ONUxFmap2B2TqvEEaPCHqwyKr3hui0af4VrVHp9USH59AQmoSwxMSiQ+Lq/j4BOLjE3A4YodUqAQVlf7A7Xbz+ONP8+WXn/HOO2+yePHLrF27krfffpPx4yfy0kvP88ILr2E0Grn77gX8/PNyli79jt/97gRmzTqDr776PJIeqJWdO3dw5ZXXkp8/jM8//5RPPvkvY8eOp7y8jCeeeJbk5BTmz7+UTZs2MmbM2C5F1z33/A2NRktVVSWjR4/l1lsXRo6NGTOOv/71Vv7973/x2mv/5C9/+SuHHXZEp+cJBAJ8+OG/+cc/Xu1wzGQyUVlZzvnnn0VTUyMPPaQEYJdlOfKQZTZbcLmcHeoOFKrwUukS40v/AMB76WX9cj5BEMjIyCIjI4uTTjoVr9fL5s0bWLt2NWtW/8rmbY0ApNl0FMTqGR5nINU6dH3DEnOUNBk1uw4a4JbAv36cAcDs6d/u17qgpGOp9wSpdYeoDb/XeUPUeyW8gTarlSAIxMXGkpiWQl5SMgkJiSQkJJGYqLwn698BQcBr7J/xqKLS33zwgSfyWaeL3jabo7ft9ujt+Hg5antP1q5WCgqUOItWq42cnFwEQcBms+Pz+SktLaGxsYEbbrgaIRDA7fFQNraUkpJiTj31DADGjh3fQXglJCTx8ssvYDAYcLvdWCxK4OuYGAfJyUrKoaSkZPx+X7dta51q/OCD9/nyy88idQEmTz44fP1xfP/9d92e55dfVjBhwqROg9W+++6bHHLIdP785yupqqrkmmvm88orb0f5c7ndrkET6BZU4aXSDYbP/w/oP+G1O0ajkQkTJjNhwmTkOZdSVlbCmjWrWLP6V5bsKOS7Yhc2gyYswvTkOQzoe5ruaBAQk6zkdRwMwmvpxvFA38RTT+sGJJlad5Bqd5AaV5Aad4gaj0SDJxDlwB4bG0tqZjojklNJTk4hOTmFpLDQ6s6p19D8KYAqvFRU2tHd1HlqajpJScn8/e/PYCjaxf+Wfkv+6LEUFRWxYcNaCgqGs2nTxg71nnjiYf72t3vIycnlxRefp6KifI/X6o7TT/8969atZvHiZ7jiimsA2LJlE0lJyaxdu4bc3Lxu6//yy09Mm3Zop8dsNjsajSJl7PYYgsEgkiRRUDCClSt/YdKkKSxf/gOTJk3pU9v3BarwUumSprf/vd+u1d4advLJp9HS0sy6dWtYvXol69etZmVlE1pRiExJDo8zDPopycIVJwx0EyI8OfeJfqsryzJNPokqV5BKV4AqV5Bqt0S9JxBJlK3RaEhOSiYvL5O0tHRSU9NITU0jOTmlz3Grmuz7bzyqqBwIxMbGcs45F3DllfMIhUKkpqYx49wLufjiudx11+18+eXnpKWld6h3/PEnsWDBTdhsdhITk2hqauzyGs3NTT3y8brmmhu4+OLzOP54xff1k08+5p133sRoNLJgwV3d1i0uLuLEE0+O2rdw4S1cffX1nH32+dx//11cfvkfCQQCzJt3BSaTiSuv/AsPPXQvzz//NNnZOcyYcWy319ifqAFUhzi/hfhAwWCQLVs2sXr1Slav/oW6OiX1xYEyJTmYkWSZOk+ICmeACmeQCmeQKncIT7spwoSEBDIzc8jIyCQjI5P09EySkpL7PanxUOa38P90XzDY+00NoNo3rrxyHn/9662RFY994fnnn+aiiy7tc67jzlADqKoMOKbFzwDgmXf5gLZDq9UyevRYRo8ey/nnX0RZWSlr1qxkdbspSatBw7CwNSzPoceoHfh4LUm56wGo3jlmDyX3PW99rzztnXf4V12WaRVZ5S0Byp0Byp0hKl1BtmxTnjSHD/8/cnNyOCQ9i6ysbDIzs0lPz+zXG193mDzh8Wga2PGoojIUEWqqAZAT+z+p+0Bw2mm/32/3nv5GFV4qXaJbqjg8DrTwao8yJalYVk4++TSam5tZv34Na9asYsP6NayuakIUBDLsOoY59AyL05MyQMFbbYlKDLPBILx+KhwFtAkvWZap97aKrCDlYWuWP6Q87el1OrKyczgyO4/S8tMwmUw888xsUlNjB8wCoQuEx6MqvFRUeo3Qovy/HQzCa9GixXt9jpSUlD0XGqSoU41DnMFuit+fhEIhtm/fFg5XsZri4iKgLXhraxT9WKPmNxXLSZZlGn0S5S0BKpwBypxBKlyhyIpCnVZLZlY2ubnDyMnJJScnj9TUtE6jPKvjrW+o/dY3Bnu/qVONBxbqVKOKSi/RaDQMHz6S4cNH8vvfn0NTUxMbN65jw4Z1bNywjg2FjQDEGLVk2bRkx7Ql+D5QhJgkyzR4Q1Q4g1Q6FWtWhavNJ0sURTIyMpk2YRg5OXnk5OSSlpah+mOpqKio7CfUu61Kl5iefhIAzxVXD3BL+kZMTAzTpx/O9OmHI8sylZUVbNq0gU2bNrC9cDPrCpUo+iadhnSrhjSrjnSbjjSbFpt+71dMJuevA6Bq+9i9PldneIIS1a4g1a4gVe4gVa4gVa5QZLpQFEXS0zOYMjaPdeuOJzY2jptvNqLT6Xt1naefVkI8XHFFoN+/Q28wecLj0TQ0x6OKykAiVFcBICclD3BLVFThpdIlul9+AsCzh3JDAUEQIiENjjnmOBISrGzYUMjWrZvZtm0rO3cWsrS0jNaZd6teS5JZJMmiJcmsJcGsIc6owaITe2wds8RW73W7W9PmNPpC1HtC1LqD1HpC1HklWtpFdjcajWRk5HB4Vg5ZWTlkZ+eQlpYRiYv1hz8YaWgAnc7b6zb88kurCB1Y4aULHjjjUUVlfyO4XAAdksKr7H9UH68hzmD3gRisdNZvPp+XoqJd7Nq1g9LSEkpLiigrLyMQaBMceo1IrElDjF7Aqtdg04vY9CJmnYhRI2DQihg0AnqNgCgIiAKIAggChCQIyTIhCYKSjC8k4w1KeIMynqCEKyDR4ldeTr+S6Hn3tDlmk4mU1DRSU5XYWMpCgyxiY+P2y3SpOt76htpvfWOw99tv2cfr3nvvYOvWzZH8i01NjZx77oWcfPKsbus1NDQwf/5cXnnlLQwGA83NTdx11wJcLhcxMTHcdNPtxMbGRcovX/4Dr7/+cmR77drVvPrqO/h8Ph555D50Oj0FBcO55pobOvVL7Q2qj5eKyn7GYDBGfMRakSSJmpoqqqoqqa6uprq6iurqSurraqloaqTF2b/5vyxmMw5HAjHJseTGJYTT5SSSmJhEYmIydrv9gPFHU1FRGdrMn391JKJ8c3MTc+aczcyZp3Z5j1qx4keee+4p6uvrIvteffWfjBs3gYsuupSff17B888/zc03L4gcnzbt0Mg13nzzVcaOHU9OTi5z587hL3+5gbFjx7N48TN88cWnnHDCzH34bfsPVXipdInpyccA8Fx93QC3ZOAQRZHk5FSSk1M7PR4MBmlubsLpbMHj8YRfbnw+H8MT3kOWZNZXnIokSWi1WrRaXfhdi8lkxmw2YzZbMJvN2Gz2blPm7A1PPqn4dV19tX+/1u1PTJ7weDT9dsejyuDm9NNNnHtugHPPDRIIwOzZJi64IMDs2UHcbjj/fBOXXBLg9NODNDfDRReZ+OMfA5xySpC6OoG5c43Mn+/nhBNCVFUJe8zX+Mkn/2XZsiX4fD7q6mqZPfs8li79jp07t3PFFddwxBEz+PrrL3nnnTfQhEKMG3kQf77hZqqrq3jkkQfw+5V6l112OUceOYOLLz6XCRMmsX17IQAPPPAYVquVa6+9goce+nu396e6ujr0egOCIHDvvXcgyzLV1VV4PO5IzkZRFPj7359h7tw5kXq7du1gXjhk0bhx43n88Yc6PX91dRWfffZJJFF2TU01Y8cq6czGjh3P999/pwovlaGPdv3agW7CoEer1RIXF09cXHyHY7aW1wBIH3dyh2P7m/Xr+26C35u6/Yk2qI5HFZXdcbvdPP7403z55We8886bLF78MmvXruTtt99k/PiJvPTS87zwwmuYKyu489kn+fnn5YDAuedewKRJU1i3bg0vvvg8Rx45A5fLxe9+dwLXXnsjd955O8uXL+N3vzuBxx9/utNrP/vsk7z66ktUVlaQk5PH3Xc/EDmWnp7B7bffyY8/fs8zzzzBgw8+zsEHT+twjoKCEXz//RKGDx/J998vwevt3A/1nXfe4Oyzz0evVx4E09LSWbXqVyZOnMyyZUvxeoeO96cqvFS6pGXxywPdhCFNi+3lgW5ChMWLe+9U3x91+5PB1J8qKp3xwQdtP/46XfS22Ry9bbdHb8fHy1Hbe7J2tVJQMAIAq9VGTk4ugiBgs9nx+fyUlpbQ2NjADTcoK4HdbjdlZaWMGzeRV155kf/970NAIBhs8yUdPlw5X1JSMn5/91bu1qnGH3/8nmeffYq0tIzIsUmTDgZgzJjxPBmePemMOXMu4e9/f4QrrriM6dMPIzm546pLSZJYtuz7iGUM4NZb/8bf//4oL7/8AuPGTUCv3zezBfuCHj3K7qnzVVRUVFRUVPY/3fl8pqamk5SUzN///gyLFi3mrLPOYfTosbzwwnOceOLJLFhwN5MmTdn9jL1uw/Tph3PEETN46KF7I/u2bNkEwLp1a8jNze+y7urVqzj11NN5+ul/kJGRGZk+bM+OHdvJzs7GYDBG9v3ww/csXHg3TzzxLM3NTRx88NRet3ug6JHF6/e//z3Tpk1j9uzZDB8+fF+3SWWQYH70QQDc1980wC0Zmpjd4f4zD3z/PfqoYp6//vreP0TtTd3+ZDD1p4rKUCA2NpZzzrmAK6+ch+T1kpqUxDHHHMfRRx/L008/weuvv0xiYhKNjY3dnqcnPl6XXPJH/vCHC/jhh+8BZTXi999/hyRJ3Hrrwi7rZWVlc889yvGEhERuuUVxrH/iiUeZOfMUCgpGUFxcFGVNA8jIyOKaay7HaDQyceJkpk8/vCddMijoUTgJSZJYunQp77//Pg0NDcyaNYuZM2disVj2Rxt7jBpOon+xzf8jAC3PvrBPzj+Q7I9l6raWcP/ZBr7/5s9XnhSffbb304bt6w7k8v7B1J+9ZbCHRRisDPZ+G0rhJMSiXQBI2Tn7/Pr33nsHxx57fGQ1Yl947723mTbtMDIyMvuxZd0zqMJJiKLIkUceCcB7773Ha6+9xvvvv88pp5zChRde2KsLqgwdDkTBtT8ZTAKhL4KrP+r2J4OpP1VUhhr7Q3D1J4cfPmNIJ8Lujh4Jr4ceeoivvvqKQw45hMsuu4xx48YhSRJnnnmmKrxUVFRUVFRUItx22x17fY4DVXRBD4VXTk4O//73v6OmFsX/b++8wySpyv3/qdA5d09PDpuXXWCRKCBBEUwXFEEUREwIyMV89S4/BCWLAfQqiOHi1QsqKIoXFRURkZzD5jC7Ozmnns6hqn5/VE/P9KSdmZ3Z6YHzeZ5+qiuc6lNvV5/69nve8x5Z5vbbb1+wigkWH+ctNwKQuPLqRa7J0sSZyNvPufj2u+UWM07ryitnH6d1IGXnk1Kyp0Cw1JA7OwDQq6oXuSaCGQmv4447jnvuuacwdUpPTw/XX389tbW1+ykpWMooHe2LXYUljaKXjv06Ouaei+tAys4npWRPgWDJkV3cuVYFo8xIeH35y1/mjDPO4OWXX6a8vJxEIrHQ9RKUANHv37nYVVjSRN2lY7/vf3/ucVoHUnY+KSV7CgRLDb2+9AYBvFGZ0V9Zp9PJZZddRkVFBbfccgt9fX0LXS+BQCAQCASC1x0z8nhJkkRvby/xeJxEIiE8Xm8QXDdeC0D86msXtR5LFVf8WgDirmsXtR4AN95oxmldffXs47QOpOx8Ukr2FAhKmX379nLzzTcABrW19WzceDXWnh4A9OriGK+77voxf//73ygrKwPMya7f/vZ38LGPXTzl+f/+97/ym9/8GlVVWLFiFf/xH1ciy6YfZ3BwgIsvvojvfvcOGiYZSZlKpfjiF/+dK6/8Gg0Ny9A0jW9+80ZaW5sBia985f+xYsWqebFDqTIjj9dnPvMZHnnkEd73vvdxxhlncMIJJyx0vQQlgDQ4gDQ4sNjVWLJIxgCSURr2GxyUGBycfUbqAy07n5SSPQWCUubOO2/nssuu4M47fwbAU089AVrOfE3C+ed/mNtv/wm33/4T/vu/7+bPf36QwSna/nQ6xU9/eic/+MGPufPOnxGLxXj66ScAyOVyfOtbN2O12iYtu2PHNq644hLa20fjNZ966ol8nX/GJZdczk9+8sM5X/dSYVqP12mnnVaYjsAwDCwWCzabjccee4yNG0X26Nc7sVu/v9hVWNLE3KVjv1tvTS9K2fmklOwpEEyGL/IeUrYLSdsvBCOLb/h9pOwfJW07H4wEvuEPkLJfTNp2LpIewRu9gKT902Rs70XS+/FGLyLp+CwZ67uR9G4MeeK8hWNJJBJcd91XiUajLF++gi1bNvGLX9zLN77xbQxDIpvN0t/fj9vtRq+r54YbvsYll/z7tKkahocj5HI5bDYbd931Y1pamhgcHCQaHeYLX/hPDj98Az/60c+w283EypqmFYTW7bd/j7PPPpe77/6fSc+dyWS4+eZvc8MNXytsO+WUt3LiiWbW+e7uLtxuz6xsvhSZVnj99a9/xTAMrrvuOs4//3w2bNjAtm3b+PWvf32w6icQCAQCgWASHnjgt6xYsYrLLruCzZtf47nnngFAURTa2tr5whf+HZfLzapVqwG45prrJz3Pvff+ikceeZju7m7C4TBXXnkNTqeZPspms/P97/+IvXv3cN11V/OLX/yaYDAEmNnlk8kkxx77Zh566I/4/X7e/OYTphReGza8adLtqqpy441f5/HHH+PGG795ICZZEkwrvKxWM7ajtbWVDRs2ALB+/Xr27t278DUTLDqur38VgPh1N+3nSMFkuOJ5+7kW335f/7r5j/S662bvvTqQsvNJKdlTIJiMiO+h0RXJMm7dWbRuyL5x66Fx69N7uwA6Ozt485vN0J/DDz+i8MwGqKys4t57H+CPf/wDP/jBd/naJy4FQK+pmXCe88//MGef/QF27NjOtddeRV1dfWHf0UcfC8CKFSsZGOg3z6Hr/PCH36e1tZmbbvoWkiTx5z8/iCRJvPji8zQ27uLGG7/GLbfcRihUtt/rALj66uvo7+/j0ks/zj33/BaHwzGjckuRGcV4eTwevve97/Hoo49y6623Eg6HF7peghJASiWRUsnFrsaSRTKSSEZp2C+VMl8Hu+x8Ukr2FAhKgZUrV7Np02sA7NnTSCZjDoD58pe/QGtrC2BmJZBlGQzdfE3DIYes4yMf+Rhf//pV6Lp57M6d2wHYu7ex8Oz/9rdvJpNJ841v3Frocrzjjp8W4sRWrVrD1VdfPyPR9de//rngIbPb7ciyjCwvfkzpQjKjUY3f+c53uPfee3nsscdYuXIln/3sZxe6XoISIPbN2xa7CkuamLt07PfNb87dW3UgZeeTUrKnQFAKnHXW2XzjG9dzxRWXFMVtffSjn+Dmm69FVS3Y7XY2brwGvaxsRjFeZ555Nv/4x9954IH7Adi1ayef//zlJJNJ/vM/r2bnzh386U//xxFHHMnnPvdpAM477wJOPfVtk57voYf+CMB73nPWpPtPPfU0br75Oq644hJyuRyf+9yXsNnsc7LHUkEyDMNY7ErMF/39MXT9dXM5MyIc9tDbG13saiw5lordNE0jkYiTSMRJpVJks9n8K0M2m0XTdCQJJElGkiQkCRRFxWazYbPZsFrNpd3uGP3newAsFbuVGsJuc6PU7dbV1UxlZWkkJk2n01x44Qe4//4/oqoyudz03q2ZcNddPyYUCnH22R+Y8zkaG3ezY8c2zjzzfQdcn4VmJnYb/53LskQo5J7d58ypdoI3BK6rzZGr8TdAsONC4Irn7eeaaD/DMBgejtDd3UVfXy+Dg4MMDQ0wNDTIwMAAkeEh4vE46Xnq49u69VOAxHFv/jVutxuPx4vP68PvDxIIBAgEggQCQYLBEMFgCFUdbRquvtqM8brxxomer2QyiaIoRbElC8V09hQIBNMjt7cBoNcc3Kn+vF4v//Zv7z2on1nqCOElECwghm7Q0dFOW1srbW0tdHZ20N3dSU9PdyEeYwTZoiA7VCS7jORSkP1WHFYHklVGtshIqgyKhKRIIEtIsrlkxMmbd14bugGagZHTMfJLtcsOukEuLDGYidI/OATdBnoyh57ViuohyTKBQICK8krC4XKamt6D0+mmszNOILASgGw2y3/917f55z//gc1m56KLPs7733/eQptTIBBMgc1m4/77/ziv57z44ssO+Bzl5fsfJPBGQ3Q1LnFK3RVfqiyE3bLZLG1trTQ17WHfvr00Ne+js7MDLZdPWiiB6rYiuVQUl4rstqC4LOZ7h2oKq0XAyOroqRx6UkNLZNHjObR4Fj2hYcRzaOnRpIuyIhMOl5PN5Ni6dXPReX70o/+ZNFO1QPxO50qp262UuhrHMl9djW80RFejQFDiDA4Osnv3Tnbv3klj4y7a2lrQNNN7pNhUZJ8Fy3IXDq8VxWdF8ViQlMURV9MhWWQUixXFAxYmDuHWszpaNIMezaJFswzGhulr7Z5w3De/dQNHvulo6urqqatroK6uHq/XdzAuQSAQCJYMQngJpsS98UuAGN04Qm9vD9u3b2Xnzu3s3LWDgX5zsnhZlVECNiwr3TgCNlS/Ddmp8tEVjwFw977JR/scTJ692wyOPf6i+2dd9vl7PzihrB5SiD+8a/QgSSJtz/H8q8/xzDNPFjZ7vF4aGpbTUN9Aff0y6usbCIcr5hTk747l70cxulEgmDVyWysAem3dItdEIISXYEoM++s3gd1MGBwcZPv2LezYsY2t2zYzOGDOXabYVZSgDeeGEJaQHcVnNeOtxpHRS+fnpVizAORSWXqeayHZE8NV46P82DpkizKjsmPxriwjfGySyM5eZJtCxXH1eJYFAdDTGlokQy6SJhPJsKNlB1u3bGIkqsFqs1FXV8+yhuXU1TXQ0LCM6upaLBbLtPUwpDf2/SgQHBBS6Xnb36iIGK8lTqnHQJQqk9ktnU6ze/cOtmzZzJYtr9HRYU7kKlsV1DIblrADNewwuwylpZngr+mP24i1DBbWA+srqHnbqlmdY3hvP+2P7UFLZnFWe6l/51pU5/SjGg1NRxvOkouk0YYyaBHzpefjKWRZprKqmoa8V6y+fhl1dfWvm3nbxO90bpS63d4IMV6f+cylpNMpbDY7hmEQjQ5z+eWf44QT3jJlmSuv/BKRyFA+tY2dW2/9Pm1trdx007VIksSKFSv50pc2Fnm+Y7EYX//6VSSTCSwWK1/72mgCVk3T+PrX/x9nnnk2xx9/4rxc12SIGC+BYIExDIPOzg42b36VzZtfY+euHWi5HJIioYbsOA8LYil3mB6tJSq0xqJrepHoAlNEzUZ46VmNtn/sRs+YsWyJjmG6n2vZ7zkkRUYN2FADtsI2wzDQ4zlyQ6YY64300/1qd1FXpc/vp76uoRAzVltbT0VFZVG6C4FAsLBcffX1hYEzLS1NfPWr/zmt8Gpra+Xuu39T1G7+4Ae3cckll3PUUcfw7W/fzBNP/Kso6epDD/2RlStX8u///nkefPABfvWru/nsZ79Ie3sbN974NXp6ejjzzLMX6hIPKqL1EkyJ+z8+B0Ds1u8vck3mj2QyyY4dW9m9exvPPf98oftQ9dqQq23Yq4PYyp3zMsLw4yv+AcDP9779gM91oDz98w8BBiHPy2Sjo/m4rL79d9+ZZeHEj99HZjhdEF0jpPric6qTJEkobguK2wJjUgvpKc30jEUyJCMZtrfsYPOWTVxxzmt09cG1fziSyqoq6mrrqampp6amhurqWsrKwgecIFYgOBB8Z7+H1PkXkj7/Qshm8Z33PlIXfpT0eedDIoHvwx8g9fGLSZ99LtJwBO9HLyD5qU+TOfO9SP39eC++iOTlnyXzzncjdXdjVEyfiuGhh/7IU089Tjqdpr+/j/POu4AnnvgX+/bt4YorPs/JJ7+V3/3uPv71r3+SikTweTzc/N07ePDBB9i06VWuu+5mbrzx66xffxinn/4ObrnlRm6++dvTfmZXVxcejxcwvWENDctobm4C4LrrbkaSJKLRKBs3fpFoNMpHPvJx3vKWk9m5cwdHHnk0AMcffyLPP/9ckfBauXIVLS3meeLxeOHPVSKRYOPGa/jlL38xl6+kJBHCSzAlRiC42FU4YAzDzKO1efNrbNr0Crt270TXNGSLglJmw3VkGZJPpf1fe0jsHEa2KVSdtILAIeVz/sxsPEPvi620pWLYfKZ7frE9ZrIxQCaaxn98OQObOtHSOVSnhaqTl++3rM09KqxsAQcWt41sbFS8uev881tXu4LV7oQKZ2GboRtkwq0YaQ3LSjc9kX66N3Xz7LNPF46xWC1UVdVQU11LdXUt1dXVVFXVEA6XoyjTx7EJBEuVRCLBd797B4888jfuu+9X/OQnP2fTppe5995f8Za3nEIkEuF73/shalcXX7jp62zfvpVzz/0gL774HDfddC3ZbJZzzjFz8E0lum688Wsoikp3dxeHHno4V1319cK+ww7bwFe+chW///1vufvu/+GCCy7i/PM/wnnnnZ/vlryY9esPLWoHnU4X8Xis6DO8Xh/PP/8sH/nIeQwPD3PHHT8FYPXqNQthtkVFCC/BlMSvvnaxqzAnkskE27dvNcXW5ldHvVo+G9YVbqyVTtSQvRAQ3/H4XhIdw4AZGN7x2B48ywKo9umDvaei+c/bSPXG+d4WMz6h4oR2wkfNLlt0onOYWHsER5kLz7IghmHQ9dQ+BrZ2o1gUKo5vILB+ZokJ+zd34k5cCwr0vgChI6oJrCvH5nfMKL3F0R/4U+G9JEs0nLmOzqeayAwl8a4IEj524UdJSbLE73tOAcB12Oh2PaOhRbNowxm0aIbO4W7aX21HG9NdqSgK5RUVVFfVUllZRWVlFVVV1VRWVuN0Osd/lEAwZyJ/eGh0xWIpXnc6i9YNr694PRQqXt+Pt2uE1avXAuB2e1i2bDmSJOHxeEmnM8iyjMVi4dprv4rD4aAnEiGXzyt44YUf59Of/gR33XXPfj9jpKvxD3/4HY888jcqKkbnejz66GMBOPzwDTz55L8Ihco4++xzUVWVQCDI6tVraWlpLvJGJxJx3O7iuKj/+Z+f8uEPf5Szzz6XxsbdXH31f/KLX9w7IxssNYTwEix5dF2ntbWZLVs2s3nzqzQ27kLXdWSLgho2vVqWCieKc/LbPT2QKFo3NJ1MJDUn4ZWJpEj1Fne9RRr7ZiW8BrZ20fHYnsJ62VE12PwO+l/rBCCX02n/ZyPOai82//67CvtebZ9w/ooTGuaUU6x/Uwc9L7RiaAahDVVUHL+4gcWyVUEOKVhCxZPqjuQe06JZtGiGvugQvbv6eOnlFwoZ/gHcHg9VldVUVFRRWVlJRUUVFRWVlJdXHJRpkASCA2U6b3pj424ef/wxfvrTX5BKpbj44o8AZrLn73//Vr7ylau49dZbuOOOn+53VDHA2Wefy+bNr/KTn/yQK674PAA7d26nvLyCTZteY/nyFbzwwnP87nf38Z3vfJ9EIsG+fXtoaFjO6tVrefnlFznqqGN49tmnOeqoY4rO7fF4CmIsEAgQj88thGEpIISXYEo8n7scgOj371zkmkxkYKCfbdu2sHXrJrZs2VT4kao+G9ZVHqwVxV6t6XDX+4m3RwrrqtOCvcw147rkEhn6Xu0gM5zCsyyIpMoYOZ2vXdoEwPceOXpW19b3SrFQ6n+tE9+asgnHJbujMxJeEhJNTV8DYNmy65GA2XR8PnnXhwE4+qyf0PnEvsL23pfasIfd+FaGZnG2uXPxyr8DcNeeM/Z7rGyRkYN2LMFiQWboBnrcTASrxbJko1maBpvZ27oHLTWaoR9Jwu/3U1lhesjKyyupqKigPD+NkhBlgqVAbW0dDoeDyy//JKTThFxu+vp6ufPO73PiiSfxvvedQ19fLz/60Q/42McunlGM1+c//2U+9rELeMc73g3AQw/9ifvu+xV2u51rrrken8/P888/y6WXfhxZlrn00ivw+/185jNf4Fvfuokf//gOGhqW8da3mrGvn/nMpdx++0+45JLLueWWG3jggfvJ5XJs3PjVBbfPYiHSSSxxFnK4tfOWGwFIXHn1gpx/NgwPR9ixYzs7dmxl67bN9Pb0APmcWuV2rOUOLOUOZPvs/0sYukHPCy1EGvuxem1UHN+AIzyz4cGGYbDnvldJ9Y96zfyHhIns6uPS97cjW2X+zruxB2fepbXrly+RGRqdHFtSZapOWUHHo42jB0mw5sKjsfrsk5yhmMFt3bzwS7ORq67+MeXH1lF+XP2M6/PKA2YDW7/yZ3Q+sbdoX9mbqql8y/7jxOaD99c9C8ADrccvyPn1rI4eMwXZyEuP5zBiObRMruhYn99PRfmIEKugvLyc8vIKwuEKXC7XBC9EqadFKFVK3W5LKZ2E3NkBgF5VPW+f85nPXMpXvnLVAU0V9l//dSuf//x/zFudDgSRTkKw6Cym4Orr62X37p3s2rWDnbt20JVvNGSLghLKJy8N21G8B5bqIZfK0v5oI7HmQWwBJ+XH1c9YdIE5om+s6ALIxjKs/OAR/GZzBapDJbB+5oHduVSW0BHVdP5rVOAED6/C5ncQOLSS4cY+ZKtC+Ogaoq2DGHt1fGvKsLhsU57TUeHmiLP+jKEbuOsPxV3rn3F9AFYfdy/pvjiqa6KXx1ntndW55oJhGAzt6OH2f5bhrPLiXzv5YIXMcIqBrd2AQWBdxYy8gWORLTLyuJQXI+gZzZzDMpZFi2dJxbLs7W9mT8tetFRxglm73U44XF7wjoXDYVasqMdqdVNWFsZiEd4ywcFnPgXXfHL++RcudhUOOsLjtcQp9X+EMyGTydDS0sTevY3s2dPI7sadDA2a+aZki4IStGIps6OGHah+24y6D2dK+6O7GdzeU1i3uK2sueiYwmdoqRx9r7WTiaTwriyb0K2WjaXZ+b8vwpjbzrMyRLJzmFzCfCArNpVV578Ji3tqcaTnNNr+vovhvQPIFhn/+gpUuwWL20bvi61kIimQIHxULeGja2n8zWtkhpKF86/84BFYvXYykRSSIhU+q39zJ52P50WcBLWnr8G/Jjxj+3Q900zfy22F8oH1FUSbBjE0ndAR1ZQfM/PA+lR/gvRgAletb1bxc51P7qP/tY7CetmRNVSeuKzomFwiw+5fv1LoLpStCqvOPxKrZ2qbzxdGTkeL58wuzHi28N5I6mjxDIZW3CZ5vF7CZWHKysKEQmGCwRChUBmhUBmBQHBSj9kblVJv35aSx0uwf4THS7DoeC7/FADRO/973s6ZTqdpa2uhpaWJlpZm9jXtpa21BV03b3bFaUEJWHHWhbCU2QvJSxPdUTqfb0LP6YQOqyxMTzNbDMMg2jxIdjiNZ1mARFdxo56NZcjG0li9Zhde05+2kuw2hz1Hdvehv311UaoJi9tG+Khael8yxYnqtOAIOonu6ef6y814qK/duZyhnb2Ej546wL5/UyfDe83Rl3pWZ+C1TlZfeBT9mzpM0QVgmHFVisNSEF0AWjrHwNZuUn3xQoLUwKEVVJ+6kp7nWwDYt+96AKzP3Txj4aVnNfpfay+UXb78ayR7Yhzy8WNnVH4sPS+20vOcWRdZlWl476G4qmbmLRvc2gVQsOe1dykThFeksb8oRkvPaER2904Y1JBLZBje249it+BZHkSeh0nLJVVG9VnBN9GTZRgGekpDT+SFWSJHJp6jNdpBS08rWiKLMe7PosVqIRAIEgqWEQyG8Pv9+P0B/P4APp/53uv1iTgzwayQ87m29APoFhTMD0J4CaZEW7V6zmVzuRzd3V10dLTR0dFOR0c7ra3NdHd3Febsk60Kis+CdZUXS9Ds4pEdE2/JbDxD0x+2FKaXibUMsuKcDTgrZz+dTNvfdxHZbU5u3fW0jLvOR3pwVMRY3NaCtyg1kCiIrhEGt3cXCa/McArDMAisK8dR5cW/uoxIYz8AzZ2j8VeSKpOJpBjc0Y0kywTWlxd1D47vrgRztOXYZKcjaOnchG2p/nhRVvrBrd14V5WhZ02b2e3NgCmmZophGBjGaFlggvdmJmjpHL0vthbW9ZxOz/MtLH/fYdOUGkW2qei5TMGesnVi1+1MtqWHkuy9f1PBfs5qL8vPPmxBvUuSJKE4VBSHCqGJ8XiGYWCkNbREDj2ZMwVaUmMoGWOgOwLNu8kls0UjMUew2Wx4vF78PlOIud1uPB4PHo8Xt9uDy+XG5XLhdLoKy5mMXBPMjlLI0zcjbAvv/X29M18dhEJ4CaYk8R8bp92fSqXo7++jv7+X7u5uenq66enporOrk4H+voIXC0B1W5E8Kva1PlS/DcVvRXaoM2qwos0DBdEFgAGRPX2zFl7poWRBdIGZNgIDPMuDhRiv6reuLHQzKjbVHP435remOkYfXLlEhj2/fa3gaYns6cdd68e3MkTfK+3c9YcqACxeG65qL42/ebWQ9X1gSyerLzgKJT8YwFPvJ7Krt3BuSZVxVnnRczrRplFBZfHYKDuiiuHGvoJgVBwWLJPEX2UjKYKHVtC/qZOqqrsACB4+865BxaqaIlO/q7AtcFglgzt7MDQd34qyQv2nQ89pEwTbZOJxKiqOb6D90d2mPSWoefvErh3fyhD9r3UUsujbAo4Jnr2BzZ1Fn5voGCbeMYy7xjfjusw3kiQh2dVpB4UYhoGR0U1hltLQUzmMtIae0hhOJ4gMRaHXQE/raOls0f06HlVVsdvt2B0OHA4nTocTh8OBzWbHZrONWdqwWq1YrSNLKxaLFYvFkn9ZsVotqKr5sljU/HsVRVGWhhCZB1TVSjw+jMvlLflr1iurFrsKSxrDMIjHh1HVA/c0H1Th9ZOf/ISnn36aXC6HJEls3LiRww6b/F/vfffdxznnnCP+oS0C2WyGpqYmXn75eTweHy6Xi0hkiKGhQYaGhujr76W/v49kothLI1sUZJeK7FKxrfaieCwoXqs5qfQcunTiHcNkoylTAI3D6tn/aD7I/1g6hsnFM4Xuw/E0vGfdhG3JvjipvjjBwyoZ2Gx2dSl2Ff/aMIM7enBWeoi1DE3s3tpldilWnrSc6N5+bEEn/rVh+jd1Fk21k0tkieztI7i+kmw8gwEED68k1hpBdaiUH1ePrMpIskToTTWkB+Jmt+bRtUiqQviYOhJdw1i9dvxrwqSHUgxu6y6cX1JkXLU+FLtqPoc1HVetH++KEMNNAxiagachgDzN1EiGbuBZFkDK18NV56f7qaZC3rOe51tZed4RKHaVWPMgSOCpDxS+a0M3iLUMoms67jo/sdahwrlnmvwVwL8mjKEbpPpiBA+txB6amOpDtijUvn0VA9t7zIEI6yuQFRktlSPaMojFZZ3UW2dopqDXMjlizYModguuWt+Eh2iqP06yN46r2jvhPkp0DZOJpHDX+SedLDzRHSU9lMRd659UIIMpRKPNg6gu6wQhKEkSkk1Bto168HRNN23uteCpD4/a3DAwsrop1DIaRkbPr2voWR0jp5PN6mSyCSKZOEZcB82AnIGhGRg5HT2rkc1myWaz2Gy22Wf9lyQURUHXNHK5HG6PB4fDYYoyWSYWjyNLCuXlZloORVFJJOLEYjEqKirwen15Aafi9TpJpzVUVS2IOkVRUVVzWbyuIMtKftvIujxmu4wkycjyxJckSUiSjCRR9L6zs4OdO3ewdu0h1NTUTbgvHA4P8fgQ0ejgZE7JOTHyEZpmfg8WiwVFUYv27Q9Zlov++IKZuyuXy2G12lDmoYv99chkdhuLqloJBGYeIzvleQ74DDOksbGRRx99lF//+tdIksT27dvZuHEjDz744KTH//jHP+bss88+WNV73aDrOul0mnQ6lV+mSaWSJJPJomU8HieRiBeWsViU4egwsViM6PAwAwMD3LzXDMq+ecMGPB4Pik1FsitIDgW5UsXpDCI7VGSniuK2IFnlefvX1/bobobyQe+SRcazLFDw/LhqvATWzWxKn7aHdxFpNL1cil3FWekZjeuSzBF/7Y/uxupzEDy8EsWq0vtyG93PmN1rkixRdcoKLB4b2Wialod2FM49mXiQrUqh7jdfsRdkibt63j+pwJFVhVh7hOY/bisIgPDRtVQc31AIFh/panRWe6k+dSV6TmPPb14riB97yEXw0Epc1V5qT1/N4LZuZItC8PAqWv68veAVa27/Jq4aH3UVXy50n1p9dlZ8YMOkge66prPvgS0ku6Ps3XszskXmxIt+WpRsNhfPMLCli+E9o943e5mLFeccDrLEvj9sIZm3tcVjI3xMHdlYGlmVibUMkY2kKDuqtsiLOB5DN9j3f1tIdAxz8xV7kVSZn0fOmyBgipLOSqa30hF2sfd3mwteLne9v5BjzbSdE3etn0w0zd7fbSIXzxSOazhzfeFe7nu1na6nmvJfmkT9O9fiXWEOsuh4fC8Dm83EtrJFZtn7DsNZMeqJ7Xqmib6Xzbxskiqz7Kz1uKqLhVV6MMHe328uiHjfqjLq3rl2Spto6Rx7f7dp1OZhFyvO2WAKdUlCsipgVVCY25/Wnhdb6XvOvCZJlqg9bTWuCq8Zi6YZo8uR97pRvE83GGzqY7DV9OD29PYQXl2F3eage3sbmYRp58Z9u6lYXk18IMpQz0Dh88sqy7A7HIXzG7o+rRdvoUgkEkQio/n9fD7fQZvpYMrPliRkSUKSZZQR4ThOZCqKit1mBaSCF7K5uYnL/vkoANesXs1b3nIyVVXVeS+mmvdajvVoFns2R/eNHmN6Qc33qmopeY/fTDhYgzkOmvDyeDx0dHRw//33c8opp7Bu3Truv/9+nn/+eW6//fa8Gy/Orbfeyosvvkhvby9f/OIX+eEPf3iwqjgthmHQ0tJMNBqZ8p+N2f9roOt6/jX63jDMpaZpY5Yamjbxlcvl0LRc4X0ul8v/W8kW/olmsxnSmQyaliWVSpPNZshmsoXpIPaLZHYlSVYZVBnJIiE5FeSAjfgms0HfmW9k4skEdecfOqnnaSFIDyULogvAyJpZ6Nd85Gj0nI49NLPGL9kXL4guMEcoWv0O/OvKyQ6nkSwyPc+2FPZHmwdZ9t5D6X1hNB7J0M1UBivPO4Id//N80fmjzQPYy1xF3VvOKk9hFOHOFrOefTvaqDplBf2bu8gOm4Hy9pAL74ogzX/aXhBdYCZPLXtTDQNbu4riuxIdw8RaBsnGMkXiJ9UfZ2hnD/GOYSKNfShWlYoTGshEU0WxazZlGxbDUxSzlomkGNrRQ9mbaibYLrpvgGS32QA5nTsBiLdFJhyX7I0VfU6qL05kTz+yRS6ILoBsNI1skXFUuAupMqKYXs2V5x0x4bwjxFoGC9M5jdhzsKtrQh6y7udGv0cMc91d4y3qWoy1DFH/nkNI9MTQUzlsQSdaKsvA5s6C6Bo5LtE5jKvah6Hp9Iy5H9ANep5vwbsiRDaeZmBL5+iurE7vS20FD2oulaX/1dHRmEbOPNfy9xULr75XO4o8p5HGPsLH1E7q2QMY2tlTbPPeOMN7+vCvnfv8oqPXoBUGioB5//dt7sS3dub/8vWcTuSJnaMbDIgODmOtdxdEF0AunUUrkxneM1RUPpZLUvmeYuFpGAbojIo8w8DQMWPf9NH35r78cSNljPw+I7+vsJ4vP7KN/PZ8nXv/1VdUh1gyTtlxkwyQmanemEqYjH+gGND7xMTPDh1VXairweh1agZougFGDkPPgZEiouVtkjbIZXJ0tLQU2nNN03juhWcJV5VjaLopcLUDHwGpKAqqxRR6lqKlBWtesI0IQVVVxrwf67lUizyWo57LUXE5IjCLvZfSGO+lXGRqj8d3QHnGFoKDJrwqKiq48847ueeee7jjjjuw2+188YtfpK+vj29/+9tUVFTwox/9iL/+9a9cfvnl3HnnnXz3u989WNXbL11dHVx33VWLXY0pkSwykk1G9dqQ7Uqha0K2KWYslV0xu4wssul9UaWp/6FsNR80v6jMz8el6fMWVDgTJgsA17PajJKFFpXJTDyPkdMJrjeva98fthTtS3QOkx6Io49rhEaSZ46vl57VWXnRBoZ29ZLsieFZHiwaofaLP5qf427IEW+L4GnwI8kSzkpvYUTd+HMauoGuaWiT1F3LahMSeYIpGEe8gVo6R8e/9kwQU5WVv8C3uozI7nHnnORzxl9rZeUvAFA91QXPH5heJXvQaXZ5jS2byYExsXtKz2hE9w0UbUv2xEgPJrAFJhfTY+sxYs/QEeNsZhgTvms9k0Ob5D5S7Rayw+lCPF33M8246/0Tjhuxi2EYxfGFY/bp2YmemLH1MHL6hBGLk92Tk22b6nuZat9k1zoXDH3iQ1if5J7b3znG/4b0jDb5tadzE+w72XGSJIECKNKsZl04EIzHxn13uo5jjf+gfLb+eLFNDF3HuX5uI7mzsTRsbxltzwHZo+J/92i8Z0GUjngZTTVXeG9k9eJXRje7rrNa0fZMNks6mYZYaaV1+ta3/ouysgPvIpwvDprwam5uxu12841vfAOAzZs3c8kll7Bx40ZuuukmnE4n3d3dHHXUUQerSrOivLyS97//PHbtMruaRkTLyIiW+RAmhmEUeblyuSw5LVfomx/70rVxD5/8ja/Hp2gkJbNrS7aYHi4skinWrDKyRUayKshWGcmm4GsI0TPGq+JbVTbnCaPngiPsxlHhLvLOBA6tnKbE5DirPNhDztERg5KZZmEExTZOHEigumz414QZ2jka6B7Mf3bw0Er6xngwgodVkuyL0/n4XvSczsCWLvyHlE+ou6QotP5t1AOgOqyFNAbBQytp7xnNSO9ZFsTishE4pJyBzV2Fh6DqtuJpCJojBF9uQ09r+WtQJ/6TNsxuRNmqFB5iil0lfEwd8baIOUoOkFQJWZVpe2QX9rCb4GGVhXp5l4fodjYXcpHJqozN58C32hwpqTotBQ/LwNauos/xrixDVuSi8pIq4z+knPSYNBhgdmUp03Q1uhuCWNxWsrFM3pbyhG5mSZIKgwjGfjeuah/De/oL4sgeciHb1KJBDHpezEqyVBBJVq8dd50/f90KgbXholxvwcPM+8Hmd+Cq8RVNNxUcc59a3LaiLvKxZccSWF9BZE9fUT2nGzjiXxOm75X2Ipv7Vk6cUmouKDYV36qyokEok9V52nNYlYm/ocMq8a0M0fN8S1GuNf8h5WSiaYZ2TLTvXBn1dI3xgE3m4SpsY9TrZIyew7eyjIFtXYXz+leWke1PMWv2pxTHPzoM8K8oY2D7aMymb0WITHditK7GuOvMe79MTx9jPIOAZuAMukkMjLZJTqeT4We6xnQTg6Sb5xvbbazn9HnxhkmShJL3bqmKkn9vGfV8KSqKqmBRLTManDHyzB37HJ7qmDVr1hEMHpxpzWbKQUug+vDDD3Pfffdx5513YrVaicVinHPOOQwODvLPf/4Tt9vNxo0bqamp4XOf+xxvf/vb+dOf/oTDMfPs02+kBKq6rpPNZvB4rHR1DZJOm92NI3Fd6XSaTCZNKpWaEOOVTCbNuK54jHg8RiKRIJ0qblBSqRRXv/IKkixz66lvQXbkvWh2xYzpcpqxXbLDfM1nUlMwvUwDW7rIxtL4VpVNiIuZ8XlSObPbLp7Bv6YMZ+Vo7qhkb4x9f9hSeICFjqim6qTlGJrO4PZuUn0JUGSi+/rR0jn868pxhFwkuqO4qrz41oRp/etOhvf2F33myg+9iVjLIFee/jQWl5XPXl1RiCsCc2TkIZ88rrAebRog2jyIpMoke2Lk4hl8a8J4VwQZ2tFrxmwdVlFIP5EeSpqB9BIE11cSax+i45+jk2pLiszajx2Dls4xuK0bLZNj8xNXo9hUTvn0fzO0rRtD09E1vTBwAMC/Nkzt6WsK65lomsGtXbz88H9iaAb15Z8v7Ks5bRWBdRUT63NoZSH4PBtLm6IspxNYV4E9aIrgpv/bYoo/CSre3DBtfjMw04kMbOniqnc9A5LETX86Dv/acFFX3Eh2+0R3FFe1D9/qMjP/W+cwQ7v7sLisBA+tJBNNsec3rxWd37M8SPmxdQzt6EGxqwQPrSwKkjd0g4FtXcQ7hvEuCxaNltSzGgNbu8wEuytCBcFW2J/TGNzaTbI3hqvOT2CK7sDx9dzfaNFRm5uic6qBI3NBz9//6b4E7np/IZ5t5EFvPpj1iTFfY7oCjZxOpKmf9FACR8iNu8KHoRtk42mGWwfMgRuVfix2K3pOJ9Y9RCaWxuZx4PK7x3QnjnQxglTUvUhh/9g4s4LnZh4wDINUKkUmk8FiseBwOA5aHJNhGCSTSTKZDKqqHlBS3ZEuuP94+ml0w+C7b3kLgWAIi0U1Y7hGugOtxXFcqqpitVoL8V8jo1jHHzc2Hmyke3Fs7NdSGuk6lxivuSRQPaiZ6++8807+8pe/4HQ6MQyDSy65hBdeeIFnn30Wh8NBWVkZfr+fG2+8kY0bN9LR0cH//u//zvgLeyMJrxHmKxhQ0zRisRixWJRodJhodJiqX91NKpni8ePeTCQyyMDgAEODAxNnjZckVJfFjBFzW1BcZrC94rUiO2eWMmKx0FI5+jZ1YOgGwfXFD7DMcIpd97xU1JBXv20VwTFB9U1/3EqsZajonKsuOBJ70Mm7ql4GDL57Q64o1sjisbHinMNJDyZxVnqQLQp6VmPnL14sOq7q5OVYPDa6n21BS+cIrKug/LiJI6sMw6DnhVaGtnejOCxUHN+Apz4AYAbvP7iVzg5zWo5D3vowtW8387Pt/MULBU8SABKsv/R4ZLXYE7j5obfS81wLFeV3F7bZAg6qT11J97PN5JJZ/IeUmyMuZ/Bd6zmNWHuE4cZ+Ep3D2AJOKt+ybNopfnRN59ieP6GlstzzUCWSIrPi3MNnNb3TCHt/t6logEXDmesL9pqM1ECClr9sJzOUQnVYqD1jzQSBNRWGptP6912m5w0IrCun+m2rDspvwjAMjJyBkdEK3UPmqEVzaRSW+e7FnG4erxlI2kh3k7mcL8/HWJQx3o+RWB5zBN9o/I/DbsMwpHGxQOPjgdR8GRVZlgvL4vggGVlWxo1kHI0PMt+b08eboxpHXzDiVJ4mPIOxXhdjzLbx+4oZf/6RbYZhcN99v+Sll14A4PjjT+SCCy4quoaRayoewWnaorLSz+BgsrAdwHHH9wFIXvG5WX9XbxRel8JroRHC6+CQyWTo7+9jYKCf/v4++vp66enppru7i+7uTlJjvGeSIqN4LMgeC6rXiuKzovqtc5rMeiEYOypNkiUazlpfmMtwaHcvbQ/vKjref0h5QbgADO8boOWh7YV1V42P5WcXp0jpe62Drif3FdZ9a8JEdveCYXbtNJy1Hj2n0zQu5sxZ4yPZOVwUJzTW0zQTmv64rSixKsCajx6D1WOj8d5XSfWPimjFpnLIJ4+b4L3Uczrb//u5ogevxWtHS2SK4nPGi9LpGD8NkC3gYPWHpw4zGN7XXzSiFMw5LKtPWTGjzxuLltEY3N5dyP6vZzU8DUF8qyfvrtv34FbiY1JhWNxW1nz0mBmJp6GdPbQ9UhxY1/Bv6+Y088JIqgg9pRXyeOlpDSNlxk/paTN9BNl8UtZMbr/eH0VVsdts2Ox2bDY7dlt+aR/N42V6O6xFo9jGejtGRNKIl2Rs0PToa6RbSS2Ig5nYr9SnDFooHn/8n3zjG9cXbbv22pt585tPmFH5N6rdDpSDJbxK4+knWFJYrVaqqqqpmmTSVcMwiMWidHV10tnZQUdHG+0dbbS1tRJpHQ2sVhwWZK+K6jcz1qtB20EXY7lEpmhUmqEb9L7UVhBezgrPhASq42NvvMuDrDjncCJ7+jE0HYvHRmoggT04GixedkQ1rioPie4YjrCbpge3FM6ppXN0P9tM7elriuKMwIyVGR+cHW+PzEp4GZPlpMn/16o4vp6Wv+4o5LcqP75+0i5jWZUJbaii75X20etuCNC/ubPouFjL4IyF13gxmB5MkhlOTdllNt4LB2b6hrmgWBXKjqim6U/bCgMDhnb2mhOUHz4xyeTYUaRgTiulZ7QZjfIdH9MGkI6kGB/BZRgGelIzk6QWvUyBRVpHS+Ym9TrJsozL7cbjCeAN+3C7PbjdbtxuT1HWenPpxG534MgnUFVV8QgoRVpbWybZ1jxj4SUobcSvTjAl3os+BMDw3ffNuIwkSXg8XjweL6tXFw8JTyTitLa20NzcREtLE80t++jY3VEQB6rLguy3ogZtWMoc5jyN8xw7NpZC8OnYbWMebFavnZq3r6b7mWa0dI7g+opJRY+zyktkTx8DW8x4qe5nm6l/9yFc866nAfivnWfhKPfgKPeQS2QK0/iMkItnsLisVJ26kq6n9qFnNNx1fsqPrZswCtBRPrt/VqEN1cTbIzTuvg2AI8+4sSBuPMuCrLnoGBKdw9jDLmy+ybv6/vF9c87O4977LWLtEWRVxlHhoX9LZ5H97GWTpz+YDFvIWZQSQbGrqFMkFwVw1fr4r6ua0VJZvnTbKlSnheBhc8/EnY1nJozGHNzWPanw8jQEipLTOqs8M06t4lkWNNMzjNhJkrDKFhJbB9DyUwSR1MklMhPuRYvVgt8fJFgWJBAIFM3X6PX68Hp9+fxOrkJ3kuD1wXHHHc+vfvW/hWSesixz7LFvPqBzzqU9FywMQngJpiR78qnzej6n08XatetYu3Y0U3wmk6G5eR979zayZ08je/bsZrDdFBuyKqMEbaghO5YyO2rQNqcM+FNhcdvwrggWJqcGcNcH6H6uGavPgX91GYG15VMGRI+gpXP0jwlSx4Del9vZdsLE6XlUpxVXra8oJ5YvH6wdXF+Bf20YPaMVkopWv9WMo9IzGr614aJRczPBuzzIinMPJ/q77ahOy4TEnBaXFd+q6UfEVa0zu8oMAwY2dRa8cJ5lQeIdEfSMhmd5kLIjJnpAp6LyhGVkIilSvXEUh4Wa01ZNO2G1JEnss68jk0xSe/oqPMuCB5RXTrbISIpcJLSnCmivOmk5kiITbxvCXuaaMEE3jJlzMT46GbYez6LFc4QqyogOmLnI3G432d1RcrKMz+cjXFZDaFUZoZD5CgSCBIMhgsEgTufcA6oFS5vVq9dy1VXX8sADv0WSJD7wgfNpaFh+QOec7/ZcMHdEjNcS5/XYlz84OMju3TvYtWsHO3dtp73d9BhIiowatKGG7VjKHah+2wF7xHRNZ2hnD5nBJLJdpee5loLnwbsyRP27DtnvOXKpLDt+9nyx9yfsYtUH3zTp8Vo6R98r7aT6E3ga/AQOrZz2ARvvGKbvlTZ0zSB0WGVhlNlMyCUyNP1xm5nkVZYoP7aO8mNmPl/jWBp/8yqp3tGYMFmVWfPxY5FgziIoG8+g2tV5FdQzpefFVvP7xryWhvceiqvKO+XxZndgDj2WQ4tl0eJZ9HgWPa6Zy3H5qHx+P+XhCsrKwjQ01OJ0+igrC1NWFiYQCM5+Kp43IK/H9u1gIOw2N0SMl+ANSyAQ4LjjTuC448x4hng8xq5dO9mxYxvbtm+mfVsbyW2DyBYFpcyGtdyBpcKJ7Jr9CEpZkYsTqo4RT8N7+qeNOxpBtZs5rcbmIprO+6PYVCqOb5hR/bLxNE1/3FpIRxFvHWL5+w/HVT21QBhL78vthcz6I1nX/WvCc0o/MCFJqaYj5WdAmCtTzV14MCg/pg7vihDpwQSuGh+q3WKKq4QprPS8uNJiOYy4hhbPFMfgqSplZWEql1USDldQXl5BOFxOeXk5ZWVhLJbRaxMPQoFAMIIQXoIp8Z1/DgCRe3+/qPVwudwceeTRHHnk0QAMDw+za9d2tm7dzOYtrzHwWj/Qj+qyoJTbsVY4sYQdSLMNvp7EezZTj1rN21bhrvOTHkjgrg/gqvbypUP+D4DbdrxvdvUYQ7R5qCgHGMDw3v4ZC69MxBxhunv3fwGwevXnyUTTsxJej9x2GQBvOu1ro3MWYibyPBDRNVvmw54w0i2oo8UyEMuhJiUSr/Sb4ipWLK4sVgvl5RVUrqmivLySiopKystNkeX3B0RslWDJUCrtuUAIL8E0pN/x7sWuwqR4vV6OOebNHHPMm80cVj3dbN26mS1bNrFt+xai+6JIkoRaZsdS4cBS4UDxWvfrDQsfWUOiPVJ48PoPKcfits2oTpIsFSXWBHh18MBiMgCs3omfPxvR5F0ZIto0gM/3BACqyzptVvTJqH3TVgDK3lSD1Wsn1jpUGO05sKUL/7ryaeOz5ovZ2tPQDTPOKjryyqDFcuixbJH3TlEUwuUVVK2spqKisujl9wdEnJXgdUGptudvRESM1xJHdGEUk8vlaGzcxebNr/HaplfoaDcn/FUcFtQKO5YKJ5Zyx5SpCNJDSaLNg9h8dtwNpfHQbf9nY2FUnavWR8N71iFbZh4fNLC1i6FdvahOCxXH1U85L+KMz7eli45/jWbK960uo+4da6cpsbAYujEqrIYzaMPZfBxWsffK6/NRXVVDVVU1lZVVVFVVU1FRRShUtuCeK/E7nRvCbnND2G1uiASqc0AIL8F4BgcH2Lz5NTZvfpUtWzaRTqfn5A1bbDLRNIamT5vdfbqybY/sItFhpo2offvqoul2Zkvjva+Mzn8JIMEhnzxuwefzNAwDPZ5DG86QG86gRTLo0RxaNFPIDC5JEmXhMDXVdVRX1xTyzVVVVeNwHJjgPBDE73RuCLvNDWG3uSGC6wWLju/c9wIQ+d2Di1yTuRMIBDnllLdxyilvI5fLsWfPbjZtepWtW1+jZUsLbMl7w8rtWCodWMIOZOv8jDb7yroHAPj29vcf8Lmsnpl1eU5Gx7/28Opj5uT0a7iC1r/vYvX5R864/MPf/ncA3vGVHwIgjfO2SbI07/nW9Kxueq+G0nmRleXa8x7DMOCanxwPQKisjLoV9dTU1FFTU0t1dS1VVVVFQe0CgcDk9dCev14QwkswJemzz1nsKswrqqoW8oj9+79fyq5dzWzZsikvxDYRa46CBJaA3UxZUeFADdrnLCqe71+9/4MOAsmuKIHA3wvr6f4EelabcXflsuNeKVovP6aOloe2F7rxyo6snXOQ/UjGdi2SJhfJoA1l0Iez5MbMIelwOmmoXUZv+nQCgRBf/erF1NTUYrfP38TQAsHrnddbe76UEV2NSxzhUp4b4+2maRp79zaaQfpbN7Fv7x4MwzCTuIZsWMKmN0zxl3635HiaH9pelAHfHnax7KxDkRRpzoIpM5wi3hbBFnKaUyvNAMPIx2JFMuSG0mZXYSQ7OjG4JBEOh2moX059fQN1dQ3U1dUTCASXnM3HI36nc0PYbW4Iu80N0dUoEBxEFEVh9eq1rF69lrPP/gCJRJzt27eybdsWtm3fQnd+OiDZqphCLGRHLbPPSxLXhab61JV0GAaxtgj2sAvFqrDjZ88jyRKhN9VQecLMcoqNxeq1Y10/tcfJyOlmF+FQhlwkjTaURRvOFDLFK4pCTW0dyw5ZTl1dA/X1DdTW1uNwzD6GTSAQCJYSQngJpsR39nsAiPzhoUWuycHH6XRx9NHHcfTRxwFmNv0dO7ayY8c2tu/YSt+WXiCfTT9gRQ3aUQLmhN+yQ0GSJK5c/zsAbtl27qJdB5hJSrdvMeOzjjv5ajr+aY5INHSDvpfb8C4P4KycOi/YX7/5GQDetfH2CfuKAt4j+YD3SboKl9Uvp+HYZXmRtYyqqupZT9Dsi+TvR98b734UCA6UN3J7XmoI4SWYktT5Fy52FUqGQCDACSecxAknnARAJDJEY+Mudu/eyc5dO2htbC5MaKvYVWS/lX9kG5AdClosO6es+vPJqrc8D5jxXeNJDSSmFV6r3vJ8vpswY3YVxkzvlRbNog1nR+c7lCRzepy1y6irqy90FYZCZfNy7SmbuB8Fgrki2vPSQcR4LXFEX/7cmG+7ZTIZWlub2bdvL/v27WHvvka6u7vNmaUxPWOK14riUZHdFhSXBcVtQXZbpswpthBEWwZp/uO2wrokS6y+8CisXjtGTs9P7pxDS2QLkzxPltHd4/VSV1tPbW1d0ahCEfA+OeJ3OjeE3eaGsNvcEDFegsUnmzWXloXNz/R6wGq1snLlalauHB3JmE5F6exsp7Wti7a2VtraWmjvaGO4ZbCorGJTke0K2GRkh4rsUJDtKpJFRrLKyBYZyaogqTKSIoEigcSUXiTDMEA3MHIGhqZj5Ay0NBhpA4uhEl5fTaSlH0mS8Jb5ST7fTzyVmzAXo9VqJRwup2xZNdXVVdTUVLFu3Srsdh9O59zzgM0ZI38/SuJ+FAhmjWjPSwYhvART4jvPnBNPxATMjfL0hygPwrLlxfZLp1P09vbQ3d1NT08XfX29DA4OMjDYz+DgANGWSMFTNh2SIpuB/QaAkS9imJ6pccWffvpmAE488SpUIOwrw+V2EwyGCAZCBINB/P4gwWCwMNmzx+NFkiTOPtsMeP/DH5KL+k/aN5y/H0WMl0Awa0R7XjoI4SWYktSFH13sKixpUvbJ7Wez2amtrae2tn7S/ZqmEY0OE4/HSSTixONx4vEYqVSSbDZHNpslm82Qy2XRNB1JkpBlCZCQJAlFUbDZ7NhstsLrsMMs2Gx2zjvvu7jdHhwOx4zjri68MDtXE8wrU9lTIBDsH9Gelw4ixmuJI/ry54aw29wQdpsbwm5zQ9htbgi7zY2DFeN18KJ6BUuPRMJ8CeaGkTBfJcCBfJUlcxuUkD0FgiVHyfyQBaKrUTAlvg9/ABAxAXPFN5y3XwnEJH34w6NxWgez7HxSSvYUCJYaoj0vHYTwEkxJ6uMXL3YVljQpe+nY7+Mfn3uc1oGUnU9KyZ4CwVJDtOelgxBegilJn724GdeXOmlb6djv7LNzi1J2PiklewoESw3RnpcOIsZLMCXScARpOLLY1ViySHoESS8N+w0Pm6+DXXY+KSV7CgRLDdGelw7C4yWYEu9HLwBETMBc8Ubz9iuBmKSPfnTucVoHUnY+KSV7CgRLDdGelw5CeAmmJPmpTy92FZY0SXvp2O9Tn5p7nNaBlJ1PSsmeAsFSQ7TnpYMQXoIpyZz53sWuwpImYysd+5155tzjtA6k7HxSSvYUCJYaoj0vHUSMl2BKpP5+pP7+xa7GkkXS+5H00rBff79Ef//MMtXPZ9n5pJTsKRAsNUR7XjoIj5dgSrwXXwSImIC54o3m7VcCMUkXX2wH5handSBl55NSsqdAsNQQ7XnpIISXYEqSl392sauwpEk6Ssd+l1+eWZSy80kp2VMgWGqI9rx0EMJLMCWZd757sauwpMlYS8d+73yntihl55NSsqdAsNQQ7XnpIGK8BFMidXcjdXcvdjWWLJLejaSXhv26uyW6u+cWp3UgZeeTUrKnQLDUEO156SA8XoIp8V72CUDEBMwVbzRvvxKISbrssrnHaR1I2fmklOwpECw1RHteOgjhJZiSxOe+uNhVWNIkHKVjv899bu5xWgdSdj4pJXsKBEsN0Z6XDkJ4CaYke9oZi12FJU3WWjr2O+20ucdpHUjZ+aSU7CkQLDVEe146iBgvwZTI7W3I7W2LXY0li6y1IWulYb/2don29rnFaR1I2fmklOwpECw1RHteOgiPl2BKPFdcCoiYgLniieXtVwIxSVdcMfc4rQMpO5+Ukj0FgqWGaM9LByG8BFOS+OJXFrsKS5qEo3Ts98Uvzj1O60DKzielZE+BYKkh2vPSQQgvwZRkT33bYldhSZO1lo79Tj117nFaB1J2PiklewoESw3RnpcOQngJpkRu2geAvmz5ItdkaSJrefspc7efrutEo1Gi0QjRaJR4PEY0GiWRiJNKpUin06TT5lLTcui6jq7raJoOgKLIyLJCJBJEUVQqKxNYrTZsNvNltztwuVw4nS5cLhculxuv14vT6UKWzRDQpiYzvmvZMuMALXJgzIc9BYI3KqI9Lx2E8BJMiecLVwAiJmCueGJ5+00Tk6TrOkNDg/T0dNPT001vbze9vT0MDAww0N9HJBJB0yf3OEmAVZZRJRmLJCHnt40sAQxAB/76xPUYwNtOuoacoZPVDXSmFlKyJON2myLszw99BVVV+c//fJi6uioUxUEwGCIYDOH1epGkgxN4PxN7CgSCyRHteekghJdgShL/edViV2FJk3CO2s8wDPr7+2htbaGjo42OjnY62tvo7Gwnk80WjpORcKsKbiTKZJkGixWXLOOUZeyShD2/tEkyCsxY9Kw7+k8AHO71F7ZphkHGMEgbBmlDJ20YpAydlG6QNHSS6TTJnh4Oa/gZaQMe+vNrE6SaoigEA0FCZWHKysKEQmWU5d+XlYUJBIIFz9mBMtaeAoFgdoj2vHQQwkswJdkTT1rsKixJdF2nq6uTpiaDpqZ9tLQ8SmtLM8nU6KhAt6ISkCQOURT8TiteWcEnK7hlGXkBPEiHV+ycsE2RJByShMNcm7qwux0A3QiRMgziuk5M14jpuvmKRBgcGqJ19y7iWq74M2SFYDBIuLyC8vIKwuFywuEKysvNpcPhmPE1ZC3ifhQI5opoz0sHIbwEU6I07gZAW7V6kWtS2gwODrJ372727Glk795Gmpv2ks5kqAnHUCSZ9ICP5bJCmdNFSFEJKgpW6eCm0GuLVAJQ6+s6oLJOScIpy4SnaDo0wyCm6wzrGtGRZSRC39AQe3duJ6UVd5t63G7KK6qoqKikvLwiv6ykoqISp9NZdKyi5e9HRdyPAsFsEe156SCEl2BK3F/+PCBiAsaiaRotLc00Nu5k9+5d7GncxeDQIGB6kEKKympFIex0c+EHn0eVJJ775bsXudZw+3MfA+CWd3xzQcsqkoRPUfApk3vQ0obOsGYKsoiuMZzJEmluYlPTPmLjvGVul5vKyioqKquorKzirCO+jdVqJeH7CzabbdbXIRC8kRHteekghJdgSuJXfX2xq7Cg9PR009LSzLp1h+JyuSY9JpVKsWfPbnbv3smuXTvYu7eRTMbMa+VWVCplmXUOFxWqSlhRUcZ0E+751zEH5Tpmwkff9LtFKTsemyQTVif3mGUNwxRkminKIllTlL3atJe4prH1RTcAO5o/QcAfoLKq2hRmeY9ZZWUloVAYVRXNmkAwntd7e76UkAzDWNwx4vNIf38MXX/dXM6MCIc99PZGF7saS45HH32IW2+9FV3XcTpd3HDDLaxffxixWKwgsnbu2EZLSxO6YSABIdVClaJQqVqoVFXc8jRxUSVAfzpNbyZNg9OFYwoP1FIhY+hENN0UZJrGkK4R0XWGdI20rheOk2WZslAZFZUjoqyy0I0ZDIZQFskO4nc6N4Td5oaw29yYi91kWSIUcs+qjPhrKJgSZfs2ALR16xe5JvNLKpXijjvuQM8/sBOJON/61k3U19XR3t6GgdllVqGovMlmpyovtGYbl+UOm12Qsd7AfF/Cfnmir5dHerowAJssc5rvZKrsDpYF2kloOf7S1UlTPE6Nw8F7KqvxWixTnqtpsAaAZYH2KY9J6xrN8Tghq43QAnQDWiWZ5VURoNiehmGQMgwiusbQiCAbGqJjcJDtWzaRMyYTZVX5IP/yQsB/KBSeVaC/QLDUeL2250sRIbwEU+L+f18GXl8xAUNDg7z88oskEomi7f39fdRbrRxrd1KlWihXVdQDHF146DueBTjoMV5pTeOx3u5C6oe0rvPjFy6i0m7nlnd8kz92drB12BQxkWiWpKbxiWUrpjzfj174CDB1jFdnKsnPm/eRzAfOnxYu563hivm7oDyT2VMaGZkpy1SqxeLRMAzi+ZiyyEhM2dAQnYOD7Ny6mcwYTxmA0+E002CEywmFyggGg4V8ZYFAEJ/Pv2geM4HgQHk9tudLFSG8BFMS//oNi12FA2ZgoJ+dO7ezc+d2dmzfSk9vDwB2m41UOl047tRAiFM9vnn97B2PHjuv59sfkWyWoWwGr6qSHRdBsKb+dj5QWw/AnlixK31fIo5mGEXxaWP55FG/mfZz/9nbUxBdAP/q7eW4QAjnAcRa6YbBy0ODNCXi1DkcHBMIzdqekiThlhTcskI1E0VZOh9TNqzrRPOjMKOdHTR1drBJ04q8ZQASEh6PB78/QCBoCjGv14fP5yu893g8uN0eXC73vOUvEwjmg9dDe/56QQgvwZTkjjx6saswKwzDoKeni127dppia8c2+gf6AbO7rVJROcHhpFq14PH4eXqgj550mjVuD0f55787MNJZNu/nnIon+nr5R08XOuBVVeodTlqSo169t9V1syZkiqMKu4PmRLywL2yzTSm6ANaU7Zv2s+O54tGIGgZJXcN5AM3L33u6eKq/D4BNkSG602neK5ldnlld5+89XeyORSm32XlnRRVBq3VW55ckqZCQtnyS/UY+uWxM14kZZt6yuK4TT6dJdHbQ3tnBbkMnoU0xq4Ak4XK68Lg9uDweQqEAFosdt9uNy2W+RqdpcuW3ubDbHUKwCRaEpdaev54RwkswJcrmTQBoh29Y5JpMjqZptLW1sGvXDnbt2sHunTsYzntzHIpClaxwiMNFtWohqChFiUn/1t3JcwP9SJjCYyGmvfGUm6Iv2hOa93OPJZ7L8WhPNyP+meFcjlqHk7eHK+hJp1jr8eLSDmfPANT6mzgpFCKh5ehNpwlYrLy/unba8+8ZqANgZbB10v1v8vtpHSPy6h1OQtYDi/N6JZ+iY4RXhwb58BF2JOA3m9I8mxfU/ZkMA5kMV6yc39xEkiRhkyRsssx0356ejzFL6joJQyeZz/yfMnSS2RypgX4S/X0MNu0zZwbQNXLTjGeSJAlHfv5Ml8uN2+MpiDLTk2YuR14jHjbbAt3DgtcPpd6ev5EQwkswJe5rrgRKJyYgkYizd28ju3fvYvfunUWpHTyKSpWicKTTTZWq4peVwoNIMwy2R4cZzmZZ5/HSnU4VvCkAj/f1sszpYpXbM6d6daWStCYT1DtcVNjthe3rz3geMGOScrrO0wN9tCUS1DtdnBAqm9bLNB7DMKZ8sMZzObRxk/nEcjlODY/6cq58+MPEcjmqVnyStK4Tslq5dNlKahyO/T6wf/rih4HJY7z602kyus4JwRDDuRxlVhsnhubm6WtNJGhKmAH/DkUp8ibZFYVD8/bc/fTKonLd6RSRbBafZWJ34kKLEVmSCkllxws03TDYHYvSl8mwxu0hbDPvjVx+iqaUYZDWR6drGpm6KaXrpCPD9Hd3057LYbXbyEky6Snm7ARQFRWPx4PX68Pr85nLfDeouTS7Qp1OB88//xyRSISTTz6VqqrqBbSOoJQotfb8jYwQXoIpid1wy6J9tqZptLe3sXevmQ1+T+MuOrs6AQqpHdYoCpUuD1X7Se3wq9YmdsdiADzS08URvondih2p5JyE1wsD/fyxq6NQr/dW1XB0IAjAtr8fVzjuT10dvJz34uyIRRnKZjizyuw62xIZ4vG+XjQMTgyWFcqD6el5uKeLlKZxlD/AuyurUSSJrlSSBzvb6UqlWOlyU26z0TMmZm2Dz19Uz08c9Ut+0bK3kHqhP5Phyf5ezq9rmPb6nu7vw1p2U/79UJGoaorH+UXLPrS8B2e9x8vby+cWVP/i4AAPdo6OmjzM62Uok0XDQAbeUV7Jtr+bQrLcFqMvM3qtLkXBpY5+/1uHI/y1q5NYLscGn5+zqqpRF6H77sHO9sJ3/vfuLi6sX8ZqtwdVklAlBRdMOVPTX7s62TZg/jmwSBIfa1hOrcNJJu9hS+UFWsrIz6upG6QSCZKxGN0d7ezDIKlphe8GRuYL7Sebnxv0F7/4b0466VSWLVuO3+8nEAiOeQWwWGbXfSsobRazPRcUI4SXYEoOlkta0zS6ujppaWli37497Nu3h5bmZrI58wFhlxUqFJnj7E4qVJXyWaR26EwlC6ILzCSdg9nMhONWuGaXh2WER/PB+gAG8M/e7oJwivaE8l4XeC0yVFTutcgQZ1bV0J1K8dv21oK/6v862wlarSx3uRnMZHigo62w7/nBAcptdo4NBLmvrYX+vLdvZyzKeo+XFS43/ZkMh3q8HDVGvAFUePei2ovnaxwrXiajKR7nr92dYDcF71+7ocpuZ3neVs8M9BU92LdFh+lLpymbQzqJJ/p6itZ3xWJ8ftUa2lNJauwO/FYr0fwh76zwMJDJ0JVO4VJUzq6uQc3fD7Fcjt+1txa6816JDBKyWTmlbLJIroUjms0WdZfqwJN9vayegbiP5bI8OzDqkc0aBo/39fKR+mVmXBoACjujw7QmEtQ5nRzp8U44z0icWsLQSeg6+xJxHh4zIbuu62x66QWa9uwiO26EJ4DL6TRFWNAc4VkszExx5nA4RRfnEkF0MZYOQngJpkR95SVgfoMyY7EY7e2ttLe30draTHPTPtrbW8nmA7RVSSasKKxTFMI2G+WKBZ8sz7lx1yeJp3EqCu+tquGp/l4ATg6FqXU4Jxw3E8aPfMvmE/huiQyxz9lIUtOwDdTgVlQiudGHnjs/4m9vPMb4GjbGYix3uWlPJibsa0smWO/1FkTXCB2pZMF71RiL8mRfLytdbqryual6htfiyDpIWl4tlDlkkof1WEYC8ONxM++Py7WN5kSiILwmy71sTKjxzBhfyjAMPBYLh44JmvdVmWJksNnLcpeLcrud4wJB6p2jsw50ppITYqjakkkONgYTr2mitJmcrG5MOHZ8N+O/env4R2+3udIPby0r57Rx3sZCnBoyAQWyapbxrLJaOcsbIIs5+Xk8P/F5XNeJ5XTiPd10dnezZ4qBBFaLJT/K00y54fcHCAQC+HwB/H4/Pp8fv9+PzWafUFZwcFmI9lwwN4TwEkyJ67prgNnHBBiGwdDQIJ2dHXR1deaXHbS1thDJ548Cc6RhSFZYr6iErHbKVJWAXBwEf6DUOJwsc7poyosIRZI4LhiiwenimHFeoblwXCDEE3kBB3BcMEQ0l+V37W388KtNAFx2k5MjvH62RiPkDAOLJPGuiioAKu0TH0gj2+qcTmSKH9gNThcuRSVosTIwxnNXlxeOD3d38mQ+fk0Czq2pY4PPz50vnEtK13nrhs8zmM2yxu0pigGbjLr8JNVtbeYcb2vXXlb4HIDjQ2XsikUL9RsbxzRb3hIq48/5rmRg0hi4Q057Ad2Aq77eQDwvArYOR7hs+Uoq7abArLE7sEhSUTqNBufcRPWB4LVYONzrY3P+fpeAE4MzG2QRsFpZ6XKzJz7qqR1/rz4zxiM2sj5eeI2nweksGu1qlWXeHAghSRLRTAZVkqidpntRM/LizBgRaPmRnkNDRAYH6cQgPq57cwSb1ZqPPzOFmJl6wzvmZQ4UcLncuN1u0c25AMy1PRfMPwsuvH7yk5/w9NNPk8vlkCSJjRs3cthhhy30xwrmgdg3vjPpdsMwiMWiDAwMMDDQR39/P729PfT0dNPT3UlfX1+hmxDAIsv4ZZkKWWGdw0lQUQkpCi5pek/WUDZDJJul1uGcUSB6XzpNWteothcHjJ9fW8+TeXF0pD9A2GZHNwzak0mcqnJAI/BOzguEWC7LSreHQ70+dkaH0TD41i/qC8dlDZ3/WH0Inakk1Q4HTkUlZ+jIksSbAyFeGhrAMOCoQIBDvWY+sZSmc3p5JS8ODZDUNI72BzjSH2Aom+XksjDPDvTTkzZjvN5dWUVG1wuj/cD0uDzR10tnKolafj1uYFcsyscalhd5iSZDNwwsksyJwTK0hm8DcHp5BSvdo12yK1xuPlzXwPZolHqnk8N9o3nQUppGZypJpd1RNF3RYCZDNGd+p2MF9puDZaiSRHsyyVqPl7VjvHFZXac9mUR+6BhaEwni2nBhn2YYvBYZKgivuJbj7eUVvDg4SCyX5QhfgOODUwf7T1XP6UhrGp2pFOU227S5yt5XXUPIaiOtaxzhC1A9i8z4766o4oXBfjQD1nu9rHJ7yOg6HckkZZOk/5jJ70PKx4o93d9HUstxfKgMl6Jyd0sTu2NRJOBN/gBnV9VM+rtUJAmvouCdKjCN0ZkEEoZOXNNoTSbRJFAkmUQkQmJoiMFmSBg6qSlScYDpSXM6XXi9Hmx2Jy6XC8MAw9CpqanD5XLhcDiw2x1YrTbsdjs2mw2bzY7Vai16qaplwbpDc7kcO3Zsp6KiknA4PK/n3blze2F2hflgqvZccPBZUOHV2NjIo48+yq9//WskSWL79u1s3LiRBx98cCE/VjAHstksiUSceDxOLBYlGo0SjQ4TjUYZfvkFIpFBhoaGGBocIBKJFAkrMLsIvYqCV5JYryh4LVb8ioJ/BgJrMh7t6eZffT0YQMBi4eMNKwhMk6vpgfY2XomYMTVVdjsfb1iBQ1FoTSS4p7WJpKahSBJhmx2novI/zXsLwejHBYKFQPfZsC8e49etzaR0HVWSWJGP36lxOFEliT1tow/aBqcLiywXAvj70ml+3ryP4VwWGXhbuILjQyFssoJuGPyqtZkdUVNgLHO6uGLFaiyyzN+6O3m6vw8DCFmt/MfqQwrT/WR0nfHOhpyh80x/Hw6H6SHJGvBYbw8fbVg+5XXFcln+p2kfvfkYsLdUG7ynshooFg4PdXUUhF5LIs5qtxu3KrM7FuW+thYyuo5FkvhgbT1rPd4Jdf9Ewwq8Fgs5Q+dXLc005j08Q9ksK91uVEmmM5nkf1v2Edc0lGaJowMTB0Y4FRXDMPhdRxub8rF0NXYHl64+BPs0Ymqqek7HvniMX7U2k85/5+fW1BWE8ljGf78e1TJj4fX37i6e7O8t2OnUcDltyQT3tDSRyN/Hh3q9bIqMeo9nEsOmGQb3tbWwK59ypSudYr3Hy+78uoGZxuNwr2/OI3xHZhJAM/hNWwudqRQAR/oCvL+mOG1JIRXHmIECKUMnrZvb08kk6USCuGGwPTJE77D5e1AUhVBodvNuqoqKqqpYLCqqakFVFFTVgqKa2wtLRUGWFVRVQZJkFEVGlhVkWc6/FGRZQlEUotEo//jH30kk4kiSxFFHHcuRRx415tjJXkr+M8x1RVEKnznyWYODA/zkJz9kcHAASZI466yzOeuss1EUs37qmLqaS/P9/tpYMVVQ6bCgwsvj8dDR0cH999/PKaecwrp167j//vu56KKLuPbaa1m5ciW//vWv6evr4/3vfz//8R//QWVlJa2trRx++OFcd911C1m9JU1PTzd9fb24XBYGBmJoWo5sNksuZy6z2QyZTJZMJk0mkyksU6kkyWSKVDKRf58kkUhMEFIAhwwMALC3rAynLONEIiDL1CgqbosVtyzjkRVcsoxDkubtX2UkmymILoDBbJbH+3p43xT5ppoT8YLoAuhMpXhhsJ9Tysp5uKerkFVdMwz+2tVJTyBVNALw+cEBjgkEC16TmfK37i5S+aDknGHwl64O1nu86IbBO8oriQabSGo50l3VvDQ0wF+6O6m2Ozivpo5/9nYznLe5DjzW18MxgSA2GXZGhwuiC6ApEWdTZIgGp6soDUZ/JsNT/b0c6Q/wwuAAEnCor/iBfLQ/wMM93cRiZmCt272paFLpyXiqv68gugAeaanBl6vlLbWjebx6Uqki71pvJs3T/X28o6KKv3R1FqbjyRoGf+nqJGS1TVr3d1dWs214uCC6ABrjMbYND7PB5+fvPV2FbsVDV0fJSTGWp8vZl+86LrPaODoQYF/eRiO0p5K8NDTAW0JTeyHG1/Ohrs79Cq+/dncW7JczDB7Kf+fj7/3x3+8/ers50h/AtZ9s/gOZdEF0jdjpyb5eutOpQoyVZhjsikb5VMMK2lJJ6hzOQrfwdGyPDhdEF8DeeBxlkkEqA5mJg09my/MD/QXRBeYgh6MCARrGeFoLqTiQpxzdCTCUyfDd4ZbCuqZp1GVynF4ZJmcYZA2DLPmlYaAZBjnM7ydnGGgYaAbkMNAyObRMFh3TjiPLLKBjYCChY35nI3F6emFfft0w33cPDBSmHjMMg5deep621ibkA5xWamhoiGQ+LtEwDB588AGeffapaYWmhJQXYqaQs1qtyJKCalHzQs3Cqt5eFEWhvaFhjHhTC+/Hro+KOmXMa/z6eNE4KiwlSZpUeEqSjCxLhfdS/rnh8XjeUHGACyq8KioquPPOO7nnnnu44447sNvtfPGLX5zy+KamJu666y4cDgenn346vb298+q+fT1x9Ve/Qk7L7f/AKVABlyzjkhWqZBmP3Yk9nzDSLkk4JJl3Pf8CMvD8yjXzVu+ZEM3lJgQmR7ITheEIw5PsGzl+/L6krjE0xfGzFV7j6xTL5fhbdyfPDvRjAP9zaQuVNgefuDFUEHodqST/19k+IehfMwziWg6XWhyEP/azhifZ3ptO89N9ewoxTTZJ4n1VNfSm0xgY2BSF5U4Xf915BWDGaR27n9i28TZrb7+C+/rtvKV2tKtiqjqay+IHdyQ3ed1Hj5/m+xtT7ooPmukmdt13FNujUQYyaU4IleFU1GnvgakYX2ayOu6vTCyXQzOMCfN6jv9szTDoSiUL8VVH+QP4JoljGs5Ocu9PYr+UrlNms1Hvmr7LuLhOEwWVV1WRGB0IoEoSazxz83aNZTJbTvYdzfRc420SzWVxLXKG/58NDBIft+1ct5dKuwMjL+pGxZthdpUyIuoMdGPMe8ivG/xfJELbuPMeZ7UTsNsLYlE3DLT8eU3xSUF4ZrM5MplsPl+cQSy//bKnnwLgqhNPXEizzAmPx8t//dePFrsaB40FFV7Nzc243W6+8Y1vALB582YuueSSIjE1dmRUfX097nwMSTgcJp2efrj7G5mTT3kbTzzxz/xavuk0Rt6O2lTTRv6rFZMDIrpORNfpyG+zyrIpvDCHrHcccQQ2SSKeTOCUZVyybC4lGds8erjGU213ELJai0bujc9LNZZVbg8OWSGZH/klAYd7zeMP9/l4vG80+H2Vy82RvkBhkmgAt6IWRurNhg0+H8+M8fqscLqK1q/97zqO9QfoShWPqutIJXlHeWXRlD6VNjvl+X98h3i8/L27qyCmFCQO9foI2az4VEuR6LErSlEgedowiOeybB4eIpofKRpQLZz/ph8T03IcX7lsvykNDvf5C0HhAOtXfJOPjeuaXOZ04VHVwmeMlDPt4uelMakUNnj91DudE+o+cvx6j5d/9nYXRiOqksT6vOfpcK+/MHrv5p81UGN3oEf6Ct62F4cG+Gj9cla7PdhlueCBlPJ13B2LUudwTtrleLjPV1TPwyfpMpzMNmM9feu9vklzhG3w+Yu+37DNxm/bWwteq+cH+rli5Wrc4yb2rnM68VssRX8ONnh9dKft/GtMyo2VLves58Jc5/HxaE/36H0lSZwYKmOtx8tzA/0oksTJZWH88xDYfpjXx4uDA4WWx6Eoc+6+rHE4Jwwmma49GIuRFyja+GVe+GgFAVQsfgqeLsMoEkuGMeoN8zsdMGbqLY/FQrOu0ZSMF0SWMeZcxrhzj4iz8UJMttkgMXrv2FSV3RgY6eSYOpuevckGMkzFHRtmnk5ClmQkWWJ8Cz/20yRJKkpSPPZZPvpskBg/vnd8YmNZVnjPe86acd1eDyyo8Nq5cyf33Xcfd955J1arleXLl+P1evH7/fT29rJy5Uq2bdtGRYUZPCjywcyciy76BBdd9AnCYQ+9vdEpjzMMg1wuRzqdJpNJk0qlSKWShaXZ1WjGdhXFeA0Ps2N4mGg8SiaVmHBeVZJwKypuKHQ5ehUZn6zglRXsByDMZEni4w3LeaKvl6FslsO8Pt40zVyKDkXh4mUreLK/l7Suc7Q/yLK8J+C0cAVORaUxFsVrsZDUNB7r6+ZIX4BE3sN0ciiMdQ7/nt9RUYVbtbAvHqPa4aDCZmfPmIa4udNOIGGjwSnRPKYhXe50cVwwhCJJbIsO41ZVUprGfzXuZIXLzTvKK/nkshU809+HBrw5ECpkxP/kshU80dfLcDbDET4/KV1nyxiRBNCTThcJosFcllPD3azz+uhKSaQ0bdrYp0M8Xs6vrefVoUFcqspJZSoha3GeLYss88llK3iyr5doNku1w0kg/8D+t8pqfBYrzfEYtU4np5SVo0pyoe7RXJYjfP5CbFTIZuPjDct5dqAfzTCottuJazlC2Di5LIxdkdkZjVKeLuNoZ4DbB3YX6pEzDB7vM2PWLl62kif7e8noOh5V5b62FgzALst8pH7ZhAEFI/VsScSpczo5aZpuyRHeWVGFJ/+d1zgcnDxFbNXY7zdoteJUFP45JudbXNPYEolw/Lgs/4ok8YmGFTzR38tw1rTTYT4/6w0Dp6KwOxal0m6f8nOnI2i18vGGFTw70EfOMFjt9hCwWAnb7PtNLTJblrvcXFjXwEtDg9hkmZNC4RkPXtALWfzNTP4Zw+Ct1TW8Nthvzr7gcjFsUXk0Hh318mCQQxrtYsQgp+vTTs90wFgs+Hw+UqkUiqLgcLt5JZ1GkiXkMV1qsiznhcxozJgyEi+myIUuPIuiICsKKxQFd08Pvb3dOJ1OVq9ei8fjGdPVZ8aqjY/5GulSVFUVv99FMpkrrE98WSaUHRszJuYLXVgkY7JkPPPInXfeyV/+8hecTieGYXDJJZdgsVi45ZZbqK6upry8nOrqat7//vfzpS99id/85jcAfPCDH+S2226jtnb6eeTG0t8fQ9cX9HJKjv0JrwPB8vSTAMSOPoahoSEikSEzwH5okMHBAfr7+xjo76Ovr5fhMTFJYHrP/LKCf2SpKAQVBd88p4uYKZph8L3dO4s8LmdWVnPcDIf4z4SUpvHdxp2FmLKjDolyenkFuY46/tjVTlvSjMc52h9guctdED93Ne0tmrR6skDkEXKGzoMd7WyKDGFXFE4rK+elyGAhnqbe4WSN28MjIzme8tTyVnbHojjcL2GVZD5YWz/jLqXN3WsBOLxi54R9w9ksP2vaW/BGHOUPcHZ1LS8M9PNIbzcZTedNfj9nVtXsd+RdfybNXfv2Est3oW/w+flATV1hf7C+i1guy5WPDBWVq3c4+dTy0WmEsrrON3dtL8RvgSl2P7FsxYyudyEYO8PBCO+tqpmXlCazZdtwhN+3t5ExdFyKyoX1DXPOYzcTxs9nmdBH57RMjsxvaUAKw5wuaT8xiJIkYbfZsdtHXg5s+fdWqy3/suSXViwWKxaLisViKQgRi8VSFM9UHMckF8TH2ED4yeOVxm8rDefBZM+FkfY8e+JJi1GlJcFcnqeyLBEKza7HZMHTSVx++eVcfvnlE7afeuqpE7aNiK7x7wWLg/NbNwOQ/cNDVFRUUlFROeWx6XSavr5eenu76e3tobu7i67OTjo72tg1JuhZkST8ikpQlgkpCmWKSpmi4ljgf1gdyeSEuKTt0eF5FV52ReGTDSt4vK+HuJbj6guacKkRnvvlSi6qX86uaJTftJujyqyyzAdr6lnmchWJLqAoAHo8zw3082renglN48/dnXx+5Rq60yka4zEcskKD04VbVYnlvV5+i4V/bf0wOcNg7drLyBg6f+nuYI1n7Yyu65evnQ1MPlfjMwN9RV1ALw8Nstbt4U9dHYUOhpeGBqmyO/Zr66f7+wqiC2BTZIiTQmWF2LvVJ78CwJpn1xXZaLnLxe/aW3EqCieGylAluUh0AQVbLBaH+/w8PdBX6D4vs9o4bAZdm/ONbhj8qauDTD7xb1zL8deuziLhOlNGUkeMze0Vz+f2Shg6CQMShkFCmxi3BuboRI/bjcfjJZTP6+V2u/OTgpv5vKqqyshmJZxOF06nE4fDKSYEnyMj7bnI47X4iASqgimJfu+OGR9rs9moqamlZhJPTSqVoqurg/b2tvyrlbbWFnaPia9xKQplskxYUSlXLYQVFec8irGA1TIhGWlomvQUc6XCbue8WjN/156/FXdd/aW7oyAIMropfj63cg0Bi4XBMTE95dNMudMxLgu7gRkz9s/ensJIxGcG+riwvoGuVBpFktjg83ND/PqieJDZBDp//oSfTblvMkHTkpiYcb8jtf/s8ZPldUqO2bbpz+Y/9Q/VunhlaJC+TBqfxcLD3V2Fz9sWHeZzK9ewyuUuGil5hN+/389fSOyKwuUrVvPS4ABD2QzHBkLTdvcuFFlDn/CdDU0SdK+N5OIal80+rmvEDIPEFMlSJcDtduP3B6gMBMdksB+dqNvn8+Hx+HDMYIL2hfTov9GYTXsuWFiE8BJMib5s6lxPs8Fut7Ns2QqWjevqicVi5rRBzU20tjbTtG8PL3V1YmA+pN2KSrksU6GqVOTF2PjRYzPFrVp4V0UVD/d0kTMMym02rLLMA+1trPN65z3GBSA5VNyVN36kWySbRZIkzq6u5f72VqK5HCGrlX+rrJ7ynMtd7qLAd1WS0AyjKP1D1jDYPhzl36pGz3NsuDjlxuEzDE4GqPL0TrnvCJ+fTZGhgvDxqRaODgR5ZqCvSOQu30/CVoCj/EG2DEcK5wpbbUXpB0bsaZEpeM8eaG8rEnmRbJZ98Rgfqq3nqf4+etIpVrs9HDVNjODBYutwhL92d2IAzw8McF5tHesPstfLKsmscLnZO0aUljldPJ6I5T1XBvEppgeyqBb8fj/BUBnLxs3Z6PebS6/XhzrLoH/BwWG+2nPBgSN+IYIpsfzLHDWZPfVtC3J+t9vNunWHsm7doYVtqVSK5uZ9NDXtZd++vext3MXe/CgyGYkyVaVCUahULVSqKm555l6D40NlHOEPEM/l+ENHW2FqnVcig5xTXTttAP9cCC0zY3r6m0wBdLjPXzRx8oj4We5y86XVh/DK0ADPDwxwb1sLbw6GePMkXXNH+QMMZTO8MjSIU1E5vbyiMEH0WMbHU9VxOhEpgux8Gr/FSrnNRk8qRfkkUxaN55VOM/HikVXbJuxb5fbwkfplhUD8E0Nl+C1WPlRbzz96u0lqGscEgjMahbbS7eYTDSvYFBnCraq8ORgqigccb08Apzrx+3epKjZF2e8UOgcTwzCKPHMaBo/0dM+L8DLygehJQyc5Jm4qoZvrCUMnmfdSJTSNrNuF09DJ5XJYrVYSTgf7ZBl/MERFKDRhIuxAwNzmcrlEF98SZqHbc8HMEcJLMCXO75pTxUQO4g/Vbrezdu061q5dV9gWiUTYu7eRvXt3s3v3Lnbs3cPmtBlM7lFUKhWFKlWlSrUQkKfP4OxQFOK5XNFQfzDjkOZbeK16y2vAqFA4s7Iav8VCSyJB/bhRdIOZDH/q7Ch4if7c1UHQap2Q+kGWJE4vr+T08tF4O90waHA6CyMnnYrC4T4/WV3Hku+uvX/r+8w6HLWJh3u6ALNb6JzqWo7Yz3Xft9kc6j2Z8AJY7fZMqOc6r491cxAVy1yuwojU8Yy3J8AJwTK2DUcKXbUbfH5qFjBQfK4YQGrcRNfJcXn4jHziz7ShmyP6dHNUXyGju2EUMrynDYMUkDJ0kpo2aQyVhITL5cLn8xHyB1jh8+P3B/ITV5tdgOYygHUBut0FpcVitOeCyVnwUY0HEzGqcX6R2800fvoUI+wWi1wuR2trM42Nu9i1aye7d+0ojKq0ywqVikK1aqFKNQP3x4+ijOay3LprR1FX2DqPlwvqGua1nnaPGTSfiu6/m22yUW8nBst4V2XVjD5LMwx2RocZzmbZGRtmTzyOTZZ5R3klxwZD9MaD6IbBf7c9WTRqLGS18vlV0wfZ98bNkXdh18CM6rJQTGXPnKGzLx7Hpaizmg9xIcmOEUmpvHh6qruLvWNG/1Z7vVT4/KTJiy1dnzYvkyIrOJ1O3G43Hq8Pj8eD222+PB7PhImnvV7vrKbVKUVEjNfcmMxupdqelxKvm1GNgqVLqf5AVVVl+fKVLF++kjPOeDeGYdDT082uXTvYvXsnu3Zs4+l80lSLLJtCTLFQbTHjxDyqhRNDZYWuRrssc+oc8iLtj5kIrhEmy5pfOYNuwBEUSWK910yQuSduCpS0rvPnrg7WeLyEXQOTJlzMzeCPymILrhGmsqcqyftNCjsfZA2DRD7IfCTw3Ozey3frYaZESGrapPmjDJcTrwS6puH1+qipqcHt8eZH8blwudw4nS5cLhdu98j70X12u1109QnmTKm2529EhPASTInl0b8DkD3tjEWuyfRIklRId3HyyW8FYHBwkN27d7Bz5w527tjKc50dkDKD0SsUlWqvj/NcbiRNY6XbM+PkjrOhbIX5D7Nv7/4bvDqnk7eFy3myrxfNMDjSH5hxdu6xdKdTRes60JtOsbvnSACODXQWZdefLI5sPC+2HwbAMTVbZl2f+WQ29pwtej6oPKrpRHWNWH4kX0zXiAFxXZs0v5QiK3g8bny+AJU+H16vr+CBMtMjeHC5XNTXV5JOm11/IvhcsBgslfb8jYBoAQRT4vz+dwGILMEfaiAQ4LjjTuC4404AYHh4OC/EtrNj+zZe7GjDMAwUSWJPIkZ1PkasQrVgmSevwsoTNgMzFwpvC1dwUiiMjoFtFoMGxrLK7Wb7mO4suyxT53Dy30//GwA3n7GZGoeTjmSS5S7XfieFBrh/q1l2sYXXbO05noyhE9F0hnXNfI28xyCW09DHRUq5XS6CwXLqQ2GCQTPYfCQmaiRWaqYB56LLTLDYLOX2/PWGiPFa4ixkgy51m9nPjYrSGR02X9jt8MwzLxaEWGtbC4ZhIEsS5YpaCNavVFVsk4wanAlWlxnsnokfvGBvwzD4V18vr0UGcasWziivoN7pYiBpCqygY3g/Z5jIgZSdT2ZizxFxFdE1IprGkK4R0XWG80HoY3G73JSXV1AWLiccLicUKqOsLEwoVEYoVDavAedCeM0NYbe5MZndXs/t+XxxsGK8hPBa4oiGaW6Mt1sikaCxcWe+a3IbTc370HUdCQipKlXKqBBzzdEbJZgfNMNgWNcYGhFWmsaQrhOZJP9UwOenvLKq0BVdXl5BOFxBOFyO4yAG4ovf6dwQdpsbwm5zQwTXCxYd69/+AkDmne9e5JosPE6nkw0bjmTDBjMWKp1OsWdPI7t27WDXrh3s2LObzXEzfsqbT2FRqapUKBaCyuTzT5avagWgp7Fuwr6DzXOtRwDw5rrXDmrZuaIbBjFdLwiriK5Rt7qNOAaPbwkXdQp63G4qK6tZWVlNRUUllZWmyAqHK7BNMwuAQPBG4o3Unpc6QngJpsRx5w+AN+YP1Wazs379YaxfbwaW53I5WlqaCiksGnftKMwXaJFlwrJiZthXVMKqikuSWf5mMyaqFITXA9vfBcxNPB1I2enQDYOobsZZjYiriK4RMQyGNQ19jDPebrPx8be3YLVa8a24LC+wTE+WcwZZ8QWCNzpv5Pa81BBdjUucBY3x6jdHvxmh+ZtIulQ4ULsZhkFvbw979uxm795GGht30dragp4f+eZUFJa5c4QUFVfaSZmi4pblRUsHEEmZrnCfPbafI+e3bMbQR4PYdY1hXWdYMwPao+MC2q0WC+XlFVRUVpvLMeLK6/UhG2ZaC0Neevej6PqZG8Juc2PSGK/XcXs+X4iuRsGiI36gUyNJEuXlFZSXV3DCCebkzZlMhpaWJpqa9rFv3x6a9u1he1cnBuYP2SbLBGWFoKIQlBUCikJAUXFI0oILsrmIpv2VNQyDTL5LcDifgiGqm+kYonlv1vhs7U6Hg3BlDWvKKwv2M1+V+P3+ae1gSOJ+FAjmimjPSwchvARTYv3TgwBkznzvItdkaWC1Wlm1ag2rVq0x19MPks1m2N21gdbWFlpbm2lpbmJPRztbk/FCOZss45UVvJKEV1HwyQpuWcaVf1k5cGH2VMvRALyl/qX9HjsydU0ynyj06Zajyeg6y2ueMydS1nXimIIrOy63lUVVCQZDVJRXcGhZmHC4nLKyMGVl5ZSXl+Nyze6f4Vis6fz9aBP3o0AwW0R7XjoI4SWYEsd//wgQP9S54kj9CAewatVDBTEGprAZGhqko6Odjo52uro66e3tprurk30D/YXuyhEssoxTlrEjYZfAJsnYJQlL/qViLmVMT5yMOQ+jhJlAVQfu23YaBuAtf5IcBlnDIJef8y+TX6aB9CSZ15/efjoAJ5U9TsDvw+sLsCJURjAYyue3ClFWVkYoFMbr9S6Y986Ryt+PQngJBLNGtOelg4jxWuIsaIzXcAQAYw6THZc6ByN2RNLz9pNnbj9N0xgcHGBgoJ/BwQEGBwcZHBwgGo0QjUaJDg8Ti0WJx2NkMlmMSadHnkg2a+a+sljMXFgSEharBYfNjtPlwpXPsO5yufF6R+b6M+cDVJQQPp+f6mo3FRW+RYu5mYs9SwURqzQ3hN3mxqQxXq/j9ny+EDFegkVH/EAPjLkIBEVR8l1z4f2f3zDIZrOkUinS6RSapqHrev6lYRjm+RRFRpYVFEXBarVhs9mwWq1Lbt6/pSi4BIJSQbTnpYMQXoIpsf3hdwCkzz53kWuyNLGl8/azLYz9JEnCarXmM6xPP/XPH/5g/tTPPjs36885kLLzyULbUyB4PSPa89JBCC/BlNh/fhcgfqhzxZ7K268EhMLPf24B5iaeDqTsfFJK9hQIlhqiPS8dhPASTEnkV/cvdhWWNBFv6djvV79KLkrZ+aSU7CkQLDVEe146COElmBrnwZvc+XWJVDr2O5CvsmRugxKyp0Cw5CiZH7JAXuwKCEoX22/vxfbbexe7GksWW/pebOnSsN9vf6vy29/O7X/WgZSdT0rJngLBUkO056XD4remgpLF/sv/BSB93vmLXJOliT2Vt59t8e33y1+acVrnnTf7OK0DKTuflJI9BYKlhmjPSwchvARTEvnt/y12FZY0EW/p2O+3v517nNaBlJ1PSsmeAsFSQ7TnpYMQXoKpsVgWuwZLG6l07HcgX2XJ3AYlZE+BYMlRMj9kgYjxEkyJ7d5fYrv3l4tdjSWLLfVLbKnSsN+996rce+/c/mcdSNn5pJTsKRAsNUR7Xjosfms6j8jy0srEPV8s1HXbH/sHANkPf2RBzr/YLPT9Ytfy9pMX336PPWb+2/3wh7UDLrtYv7NSsudceKO2TweKsNvcGG+313t7Pl/M9n6by/35upqrUSAQCAQCgaCUEV2NAoFAIBAIBAcJIbwEAoFAIBAIDhJCeAkEAoFAIBAcJITwEggEAoFAIDhICOElEAgEAoFAcJAQwksgEAgEAoHgICGEl0AgEAgEAsFBQggvgUAgEAgEgoOEEF4CgUAgEAgEB4nX1ZRBS5HnnnuOL3zhC6xatQqAeDxObW0t3/nOd7BarROOb25u5sorr0SSJFavXs3Xv/51ZHlUP6dSKb7yla/Q39+Py+Xim9/8JsFgkEcffZQ77rgDVVU599xz+eAHP3jQrnE+ma29Rrj55ptZvnw5F1xwAQC/+c1vuPfee1FVlcsvv5y3ve1tRce/+uqr3HTTTSiKwkknncRnPvMZdF3n2muvZefOnVitVm688UYaGhoW7mLnkdnabfv27dxwww0oioLVauWb3/wmZWVlwm77sVtjYyPXXHMNhmGwbNkybrzxRlRVFXab4e/0j3/8I/fccw/33XcfIH6n+7Pbtm3buOyyy1i2bBkAF1xwAe95z3u4/fbbeeyxx1BVlauuuooNGzYUlZvseTDVs2MpMFu79ff3c/XVVzM8PIymaXzrW9+ivr7+4N1vhmBRefbZZ40vfOELRdu+9KUvGX/5y18mPf6yyy4znn32WcMwDOOaa64xHn744aL9P/vZz4zvf//7hmEYxp/+9CfjhhtuMDKZjHH66acbQ0NDRjqdNs455xyjt7d3Aa5m4Zmtvfr7+42LL77YePvb32786le/MgzDMHp6eowzzzzTSKfTxvDwcOH9WN773vcazc3Nhq7rxqc+9Slj69atxt/+9jdj48aNhmEYxiuvvGJ8+tOfXoArXBhma7cLL7zQ2LZtm2EYhvHrX//auPnmm4Xd8kxnt8svv9x4/vnnDcMwjI0bNxoPP/ywsFue6exmGIaxdetW46Mf/ahx3nnnGYYhfqcjTGe33/zmN8Zdd91VtG3Lli3GRRddZOi6brS3txvnnHNO0f6pngeTPTuWCrO128aNG40///nPhmEYxjPPPGP885//PKj3m/B4lRiZTIaenh58Ph+f+MQnkGWZ3t5ePvShD3HhhReydetWjjvuOABOOeUUnnrqKc4444xC+ZdeeolPfepThf0//OEP2bNnD/X19fh8PgCOPvpoXnjhBd797ncf/AucZ/Znr3g8zmc/+1kef/zxQplNmzZx5JFHYrVasVqt1NfXs2PHjsK/wlgsRiaTob6+HoCTTjqJp59+mt7eXk4++WQA3vSmN7Fly5aDf8HzxP7sdtttt1FeXg6ApmnYbDZhN/Zvtx/84AcoikImk6G3txe32y3sxv7tNjg4yG233cZVV13FNddcA4jfKezfblu2bGHfvn384x//oKGhgauuuoqXXnqJk046CUmSqK6uRtM0BgYGCt6rqZ4Hkz07lir7s9vLL7/M2rVr+fjHP05NTQ1f/epXeeaZZw7a/SaEVwnw7LPPctFFF9Hf348sy3zwgx9ElmW6u7v5wx/+gK7rnHXWWbzrXe/CMAwkyZwN3eVyEY1Gi84Vi8XweDxF+8duG9kei8UO3gXOM7OxV11dHXV1dUXCa3/2iMViuN3uov2tra0TtiuKQi6XQ1WXxs9oNnYbEV0vv/wy99xzD7/85S954oknhN32Y7dQKER7ezuf+MQncLvdHHLIITz++OPCbtPY7Z3vfCdf+9rX+H//7/9hs9kK5cXvdP/324YNGzjvvPM47LDDuPPOO7njjjvweDz4/f7C+UaeAyPCayq7TvbsWErMxm7t7e14vV5+/vOfc/vtt/PTn/6UZcuWHbT7TQTXlwDHH388d999N7/85S+xWCzU1tYCFNS33W5n9erVtLS0FMVzxeNxvF5v0bncbjfxeLxo/9htI9vH3mBLjdnYazL2Z4/J9k9mR13Xl0xjDrO320MPPcTXv/51fvKTnxAMBoXdZmi3mpoaHn74YS644AJuueUWYbf92G3v3r00Nzdz7bXX8qUvfYnGxkZuuukmYbcZ3G9nnHEGhx12GABnnHEG27Ztm5PdPB7PpM+OpcRs7Ob3+znttNMAOO2009iyZctBvd+E8CohAoEA3/72t7n66qvp7e1l+/btaJpGMpmksbGRhoYG1q9fz3PPPQfA448/zjHHHFN0jqOOOop//etfhf1HH300K1eupLm5maGhITKZDC+++CJHHnnkQb+++WYm9pqMDRs28NJLL5FOp4lGo+zZs4c1a9YU9rvdbiwWCy0tLRiGwZNPPskxxxzDUUcdVfCcvfrqq0VllhIzsdv//d//cc8993D33XdTV1cHCLvNxG6f/vSnaWpqAsx/xLIsC7vtx26rVq3iz3/+M3fffTe33XYbq1at4qtf/aqw2wzut4svvphNmzYB8Mwzz3DooYdy1FFH8eSTT6LrOh0dHei6XhQkP9XzYLJnx1JkJnY7+uijC9f6wgsvsGrVqoN6vy2dvwFvEFatWsVFF13EjTfeSHl5OZdccglDQ0NcfvnlBINBNm7cyDXXXMNtt93GihUreOc73wnARRddxN13380FF1zAxo0bueCCC7BYLNx6661YLBauvPJKLr74YgzD4Nxzz6Wii+mKuwAABAVJREFUomKRr3R+2J+9JiMcDnPRRRfx4Q9/GMMw+OIXv4jNZuPxxx9nx44dXHrppVx33XV8+ctfRtM0TjrpJI444ggOP/xwnnrqKc4//3wMw+Dmm28+yFc7f0xnN5/Px0033URVVRWf/exnATj22GP53Oc+J+y2n/vt0ksv5corr8RiseBwOLjxxhvF/Yb4nc6V/dnt2muv5YYbbsBisVBWVsYNN9yA2+3mmGOO4UMf+hC6rvO1r30NgN///vcAnHPOOZM+DyZ7dixVZvIcvfrqq7n33ntxu93ceuut+Hy+g3e/7X+8gGAxmGyUxnTceOONC1ib0me29pqMvr4+484775ynGi0NhN3mhrDb3BB2mxvzYbft27cbv/3tb+epRkuDUr3fRFfj64RPfvKTi12FJY9hGMKOc0DYbW4Iu80NYbe54ff7Offccxe7GkuOhbjfJMMwjHk9o0AgEAgEAoFgUoTHSyAQCAQCgeAgIYSXQCAQCAQCwUFCCC+BQCAQCASCg4QQXgKBQCAQCAQHCSG8BALBkiWdTvPb3/52yv0vvPACO3bsmHL/73//e77zne9Muf8HP/gBv/71ryds/8xnPgOY+fP27Nkz5XECgUAwHiG8BALBkqW3t3da4fW73/2Onp6eef/c22+/fd7PKRAI3hiIzPUCgWDJ8qMf/YjGxkZuv/12Nm/eTCwWQ9M0Pv/5z+PxeHjiiSfYunUrq1at4tFHH+Xhhx8mmUwSCARmLJ4eeeQR/vKXv5BKpbj66qvZsGEDb3nLW3jqqacW+OoEAsHrESG8BALBkuXTn/40u3btIh6Pc+KJJ/Kxj32M7u5uLrjgAv7xj39w8skn8573vIfKykqGhob4+c9/jizLXHzxxWzevHlGn1FTU8P111/P7t27+c///E8eeOCBBb4qgUDwekYIL4FAsOTZs2cPZ511FgAVFRW43W76+/sL+2VZxmKx8KUvfQmn00lXVxe5XG5G5z722GMBWL16Nb29vfNfeYFA8IZCxHgJBIIliyzL6LrOypUrefHFFwHo7u5meHgYv9+PJEkYhsGOHTt45JFH+N73vsc111yDruvMdNKOTZs2AbBz506qq6sX7FoEAsEbA+HxEggES5ZQKEQ2myUajdLc3Mzf/vY3UqkU119/PaqqcsQRR/Cd73yH2267DYfDwfnnnw9AOByecdB9W1sbH/3oR8lkMlx//fULeTkCgeANgJirUSAQCAQCgeAgITxeAoHgDc9nPvMZIpFI0Ta3282dd965SDUSCASvV4THSyAQCAQCgeAgIYLrBQKBQCAQCA4SQngJBAKBQCAQHCSE8BIIBAKBQCA4SAjhJRAIBAKBQHCQEMJLIBAIBAKB4CDx/wFROTj/6Rl5AAAAAABJRU5ErkJggg==\n", + "image/png": "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", "text/plain": [ "
" ] @@ -5220,13 +5354,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='violinplot+swarmplot', \n", + "ax = plot2d(plot='violinplot+swarmplot', \n", " df=tips,\n", " x='total_bill',\n", " y='day',\n", @@ -5668,13 +5802,13 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 23, "id": "faf02ad5", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -5684,13 +5818,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='boxplot', \n", + "ax = plot2d(plot='boxplot', \n", " df=tips, \n", " x='total_bill',\n", " y='day',\n", @@ -5703,13 +5837,13 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 24, "id": "562f5252", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABCgAAAFDCAYAAAD4Yz/CAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAChDElEQVR4nOzdd3iTVRvH8W9G9wJKaVllL5mykSniYokKikwRQUEEB8gWUMCBigMVUFBEFBWVJQ5wIHvvPctsgUL3ynr/CNa3tqVtBidPuD/X5QVP8+Tkl3Bs0zvn3I/OZrPZEEIIIYQQQgghhFBIrzqAEEIIIYQQQgghhBQohBBCCCGEEEIIoZwUKIQQQgghhBBCCKGcFCiEEEIIIYQQQgihnBQohBBCCCGEEEIIoZwUKIQQQgghhBBCCKGcFCiEEEIIIYQQQgihnBQohBBCCOERvvnmG0wmU763X7hwgT/++CPf28+dO8cjjzyS7+1btmzh+eefz/X1adOmceHCBT744AO+/vrrfM8TQgghhHtJgUIIIYQQHmHOnDlYrdZ8b9+8eTM7d+50+eOOHz+eMmXKuHxcIYQQQhSNFCiEEEIIAcCpU6fo2bMnffr0oVevXly8eBGAt99+m8cee4xHH32Un3/+GbPZTM+ePVm3bh1XrlyhU6dO2ecC/P7774wdOzb7+MEHHyQ+Pp6xY8fSq1cvHnroIZYuXZrjsb/77jsuX76cvXLh9ddfp0ePHvTo0YMFCxZgsViYO3cuK1eu5Pfff2fr1q3069ePvn378tBDD3Hq1KlCPceYmBgGDhzIQw89xHfffQdA3759OXHihDMvnRBCCCFcwKg6gBBCCCE8w8aNG6lXrx6jRo1i+/btJCcnc/ToUc6dO8fXX39NZmYmjzzyCC1btuStt97i6aefJiIigpdeeonSpUtnj9OuXTtmzJhBWloax48fp3z58vj5+bFt2za+/fZbADZs2JDjsXv06MHHH3/MzJkz+fPPPzl37hzffvstZrOZXr160bx5cwYPHszJkye56667WLRoETNmzCAyMpLZs2fzyy+/0KVLlwKfo8lk4uOPP8ZqtfLAAw9w1113ufZFFEIIIYTDpEAhhBBCCAC6d+/OJ598wpNPPklISAjPP/88R48e5cCBA/Tt2xcAs9nM+fPnqVWrFg0bNmT37t20adMmxzgGg4F7772X3377jd27d9OjRw+Cg4MZN24cEydOJCUlha5du+ab48SJEzRu3BidToePjw/169fPtcIhMjKSadOmERgYSFxcHA0bNizUc2zQoAG+vr4AVKlShXPnzhXlJRJCCCGEG8kWDyGEEEIA9q0ZjRo1YsGCBdx33318+umnVK5cmWbNmrFw4UIWLFjA/fffT/ny5dm9ezfHjh2jSZMmzJ8/P9dY3bt3Z/ny5ezdu5eWLVty6dIlDhw4wIcffsjcuXOZMWMGZrM5x310Oh1Wq5UqVaqwY8cOwL7iYdeuXVSoUAG9Xp/do2LixIlMnz6d119/nVKlSmGz2Qr1HA8ePIjZbCYtLY0TJ04QHR3t5KsmhBBCCFeRFRRCCCGEAKBOnTqMHj06ewvE2LFjue2229i6dSu9evUiLS2NDh06YLPZGD9+PLNmzaJMmTL06NGDpk2bUrdu3eyxypcvD0D79u3R6/VERERw+fJlevbsiV6v54knnsBozPk2pHHjxgwePJgvvviCrVu38uijj2IymbjvvvuoXbs2Op2Ojz/+mNq1a9O1a1d69+5NQEAAJUuW5NKlS4V6jn5+fgwaNIikpCSeffZZihUr5rLXTwghhBDO0dkK+5GDEEIIIYQQQgghhJvICgohhBBCeJVZs2axZcuWXF+fPn169soOIYQQQngeWUEhhBBCCCGEEEII5aRJphBCCCGEEEIIIZSTAoUQQgghhBBCCCGUkwKFEEIIIYQQQgghlLvlm2Reu5aK1ardNhwhPw4EIPnBeYqTuMfPO5JUR3Crcyf3AeDjo8dksipO41rNynwFwLpDrRUncb1dhnXojX40pIPDY+zcUguAhs0OOZVlJ2vs4ziQ5b8ZjL56zFlWjEElncrk6QIiqt7w9qYRnwOw9fLj7g/jYqVCfFRHcAmj0YDZbFEd46YqU9x7PzNKydDm+6x/5mHV1PkAHA96Is/zIkK899/O2yVnaOO9V1G/J1ZYMp/SJXxJf/JpN6YStxK9Xkfx4kE35bFu+SaZ8fEpmi5QeLslGxNUR3Cr00e2A+DrYyDL5F1vxjOvnVIdwa2M/sVUR3A5H18DpiwLxuBI1VHcKiiqluoIblM6zFd1BJfw8TFg8rLviQWJDvfeX3KT0rX5Pquw8zAqzHv/7bxdYro2ChSOfE9sWiPUTWnErUiv1xEeHnxzHuumPIoQQgghhBBCCCHEDUiBQuNKzLuNEvNuUx1DiFz6tVlIvzYLVcdwi599FrKS2U6NsfK7dqz8rp3TWVYy2+EsrsrgbR6qNJyHKg1XHUMI4SGaJQylWcJQ1TGEKLTbJw0lZPDjqmMI4ZBbvgeF1pn9a6iOIESezl8tozqC25S0lkFvCHBqjIioqy7JEkG08gzeJjZNir5CiH8lGOV7gtCWpGq3ERrhrzqGEA6RHhTSg8KjSQ8K7ZIeFNojPSi0T3pQaJf0oPA80oPC+0kPCiEKR3pQCCGEEEIIIYQQ4pYiBQqNKzGvBiXmyTYP4XkGtPucAe0+Vx3DLVb6fM5yPnRqjOXftGf5N+2dzrKcDx3O4qoM3qZ75aF0ryz7zYUQds2vDaL5tUGqYwhRaA0nDCJ0QB/VMYRwiPSg0DhzQH3VEYTI0+nLFVRHcJvS1gpO96AoXe6Sa7JQRXkGb3Mu9XbVEYQQHuSqbyPVEYQokoTajQiRHhRCo6QHhfSg8GjSg0K7pAeF9kgPCu2THhTaJT0oPI/0oPB+0oNCiMKRHhRCCCGEEEIIIYS4pcgWD40rMb8qAFefOK44iRA5Pdl+HgCf/jGwwHPj4uLIzMxwdySX2VRmBbo0I62u9HR4jPWrewHQ6u6v8j3HnB4PgDEgPP9xSi62j+NAlv9m0Ol02Gw2jMHpRR5LS4KyAm94+zPNxwPw4eZpBY7l5+dPZKR3rzgR4lZ3x7UBAGws/pniJEIUTuMxAwgNNpK08BvVUYQoMilQaJw5sKnqCELk6ejFaoU+NzMzg7S0dHQGbXxLKpZUBr2PP+mZJofHKF7qGMCNx0i7AoBJn/8yzeKp0QWPU8QMRh/Hn5cW6Ap4rfZetPf2SSvoNbWaXRVJCOHBLvm2VB1BiCK50qglQaWkB4XQJulBIT0oPJr0oNCuovSgOHMmhvRME3q/4m5M5FrGgDC3P4b16l4A9CXquf2x/p+Pl/egCIy8zSXjWDKvEejnQ3S05zSElR4U2iU9KDyP9KDwftKDQojCkR4UQgghhBBCCCGEuKVIgULjwudXInx+JdUxhMjlqbs+4am7PlEdwy22lV3M5pLznBpj86/d2fxrd6ezbC45z+EsrsrgbV5sMYIXW4xQHUMI4SFaXe1Dq6t9VMcQotCajOxDWM+HVMcQwiHa2PAt8pUV3FZ1BCHytP+ca5bRe6JSKdXQ+wY4NUZkedc0to3McPx1dlUGb7M7trXqCEIID3LB/27VEYQokkst7yZAelAIjZIeFNKDwqNJDwrtkh4UzpMeFO4hPSg8n/Sg8C7Sg0J4KulBIUThSA8KIYQQQgghhBBC3FKkQKFx4Z9FE/5ZtOoYQuQy5O7ZDLl7tuoYbrGl7FdsjHCuv8bGnx9h48+POJ1lY8QnDmdxVQZvM7rlM4xu+YzqGEIID9H6ak9aX+2pOoYQhdbsuZ6EPdxVdQwhHCI9KDQuK+Q+1RGEyNOu0w1UR3Cb0im1MPg414OibKXDLslSNs3x7R+uyuBttpyX/eZCiH+d8++iOoIQRXKhfRf8opx7nyKEKlKg0Ljk7nNVRxAiT5uPNVcdwW2iE293ugdFhZp7XZKlQmoz5Rm8zV+nu6mOIITwIKcCe6uOIESRnO3am9LSg0JolGzxEEIIIYQQQgghhHJSoNC48M/LEf55OdUxhMhl2L0fMezej1THcIvN5b5kQ8Qcp8bY8FNPNvzk/J7mDRFzHM7iqgzeZmyrpxnb6mnVMYQQHqJtfHfaxndXHUOIQmv+bHfCunVUHUMIh8gWD43LDOumOoIQedp6vLHqCG5TLqkeeid7UJSvtt8lWcqnNlKewdusO9NZdQQhhAc5HSDNhIW2nLv/ESqVlh4UQpukQKFxKQ/OUh1BiDxtPdFUdQS3KZdUz+keFNHVXVMciE5zvBDkqgzeZr0UKIQQ/ycmUAoUQlvOdXyEMtKDQmiUbPHQusw0+39CeBi9zoJeZ1Edwy2sWLDi3HOzWvVYrc5/C3Ymi6syeBuDzoxBZ1YdQwjhIXQ2EzqbSXUMIQpNZzaBSeas0CZ5Z6px4V9XJ/zr6qpjCJHL0HvmMPQe5/o0eKqt5b5mU8SnTo2x6edH2PSz85/KbYr41OEsrsrgbV5qOYyXWg5THUMI4SHaXH2MNlcfUx1DiEJr9vxjhPV4QHUMIRwiWzw0LrOYNG0SnmnTMccvf+npyic2QO/r3N7O6BquucRndGoT5Rm8zdoYeVMnhPjXqUApTghtOdv5MSpLDwqhUVKg0LiUbu+qjiBEnnacdLx5o6crm1zH6R4U5asedEmW8mkNlWfwNhvP3q86ghDCg5wJeFh1BCGK5Py9D1NWelAIjZItHlqXfMX+nxAexseQhY8hS3UMt7DoTJh1zj03s9mI2ex8jdisy3I4i6syeBtfQwa+hgzVMYQQHsJgS8dgS1cdQ4hC02ekQ5r0qBPaJAUKjQv/vgHh3zdQHUOIXJ7q8ClPdXCuT4On2lb2G7aU/MypMbb82p0tvzq/RWtLyc8czuKqDN7mxRbP8WKL51THEEJ4iFZX+9Lqal/VMYQotKaj+hLWS36+C22Sj840LiO8l+oIQuRpw5EWqiO4TXRCQwy+gU6NUbHWbpdkqZjSXHkGb/PHKVnOLYT414nAfqojCFEkMd36UbWM9KAQ2iQFCo1L7fKm6ghC5GnX6dtVR3CbMim3Od2Domzlwy7JUja9vvIM3mbL+btVRxBCeJBzAV1VRxCiSC7e1ZXy0oNCaJRs8dA4/dWz6K+eVR1DiFz8fdLx9/HOPbsmfQYmnXPPzZTliynL1/ksunSHs7gqg7cJMKYQYExRHUMI4SGM1iSM1iTVMYQoNGNKErqkRNUxhHCIFCg0rvjyFhRf7r1L6YV2Pdn+M55s71yfBk+1o8wStpb8wqkxtq5+iK2rH3I6y9aSXzicxVUZvM1zzUfyXPORqmMIITxEy2tP0PLaE6pjCFFojcc+QWg/uTyu0CbZ4qFx6aUGqI4gRJ7+PtRKdQS3qZjQGL1vkFNjVKq9wyVZKqW0VJ7B26w++ajqCEIID3IsSIoTQltOd3+CqmWc65UlhCpSoNC4tI6vqo7gUc4d2wxAuWqONw4UrrH3TD3VEdwmKqWm0z0oylQ85pIsZdLrKM/gbbZfuFN1BCGEB7ng3zHPr584aH/PEdXijpsZR4gCxbbtSLT0oBAaJVs8NE4fdwx9nPyS8Y9zRzZx7sgm1TEEEOSXQpCfd+7jz9KnkalPdWqMzIwAMjOc77CdqU91OIurMnibYN8Egn0TVMcQQngIX+tVfK1Xc3392IENHDuwQUEiIW7MJ+Equvh41TGEcIgUKDSu+M93Uvxn+bRPeJ4B7b5gQDvn+jR4qp1lfmB7+JdOjbH99wfY/vsDTmfZHv6lw1lclcHbPNt0DM82HaM6hhDCQ7S4NpgW1warjiFEoTWaOJjQgX1VxxDCIbLFQ+PSSz+tOoIQefrzQFvVEdym0rVmGHyd29tZpe42l2SpktxaeQZv8/Px3qojCCE8yNGgp1RHEKJITvZ8iuplpQeF0CYpUGhc2r0TVEcQIk8HztVWHcFtIlOrYbQ614MiKvqES7JEZdymPIO32R3reNFHCOF9LvrfrTqCEEVyqeXdVJQeFEKjZIuHxunP7Ud/br/qGELkEuKfRIi/d143PtOQQoY+2akxMtKCyEhz7kogABn6ZIezuCqDtwnzu0KY3xXVMYQQHsLPcgk/yyXVMYQoNL/4S+ji4lTHEMIhUqDQuOJr7qP4mvtUxxAil/5tv6R/W+f6NHiqXaWXsiP8K6fG2PFnF3b82cXpLDvCv3I4i6syeJuhTSYwtImsThNC2DVPGErzhKGqYwhRaLdPHkroUwNUxxDCIbLFQ+PSyg9XHUGIPK3Z1151BLepcrUFBj/nVh5Uq7/FJVmqJbdTnsHbrDzaX3UEIYQHORz8jOoIQhTJiT7PUL2c9KAQ2iQFCo1Lv+sl1RGEyNPhCzVVR3CbiLQqGG3O9aAoVe6US7KUyqihPIO32XepheoIQggPEucnV0sT2nK52Z1Ukh4UQqNki4fGGU9vw3haOvELz1Ms8BrFAq+pjuEW6cYk0g0Jzo2REkJ6SojzWQwJDmdxVQZvUyIgjhIBsndXCGEXYLlAgOWC6hhCFJp/3AX058+pjiGEQ6RAoXFhfz1I2F8Pqo4hRC59Wn9Nn9Zfq47hFnuilrOzxDdOjbFzbSd2ru3kdJadJb5xOIurMnibpxpN4qlGk1THEEJ4iKYJw2maIFtqhXY0mDqckGcGq44hhENki4fGpVV4UXUEIfL0294OqiO4TdWrLTH4OteDonqDTS7JUj3J8V4frsrgbZYfeUJ1BCGEBzkUPEJ1BCGK5Fj/EdSUHhRCo6RAoXHpdz6vOoIQeTp6sbrqCG5TMq2S0z0oIsrGuCRLRGY15Rm8zYHLTVVHEEJ4kEt+rVVHEKJI4hu3xiQ9KIRGyRYPjTMeW4fx2DrVMYTIJTw4nvDgeNUx3CLN5xqpBueeW2pSGKlJzhU5AFIN8Q5ncVUGbxMReJ6IwPOqYwghPESQOYYgsxR0hXYEXIhBf1oaYQttkgKFxoVteIywDY+pjiFELo+1/IbHWjrXp8FT7Y38id0lljg1xu5197N73f1OZ9ldYonDWVyVwds82fBVnmz4quoYQggP0TjxRRonypZaoR31X3uRkOfk8rhCm2SLh8alVhmvOoIQefp5972qI7hNtfjWGPyCnRqjRsMNLslSI+lu5Rm8zQ+HpLGYEOJfB0KkOCG05egTL1Ir2rleWUKoIgUKjctoPUR1BCHydCKuiuoIbhOeXgEjzm2NKFn6rEuylMysrDyDtzkS31B1BCGEB7ni20J1BCGK5OrtLaQHhdAs2eKhcT4HV+NzcLXqGELkUir0EqVCL6mO4RYpPvGkGC87N0ZCCVISSjifxXjZ4SyuyuBtooJjiAqW/eZCCLtg8wmCzSdUxxCi0ILOnMBw/JjqGEI4RAoUGhe6dQChWweojiFELo+0WMIjLZzr0+Cp9kf+zJ7iPzg1xp4N97Bnwz1OZ9lT/AeHs7gqg7cZ0OA1BjR4TXUMIYSHaJQ4mkaJo1XHEKLQ6s4YTfBIuTyu0CbZ4qFxKdVfUR1BiDyt3Om9zRdrXGmHwc+5vZ21Gv/tkiy1Eh3v9eGqDN7mu4NDVUcQQniQ/SFjVEcQokiODB4jPSiEZkmBQuMy73hCdQQh8nT6ciXVEdymeEY5jDrnelCUiLzgkiwlsioqz+Btjl+tpzqCEMKDxPs2Vh1BiCK5VrcxZulBITRKtnhonO/eFfjuXaE6hhC5RBW7SFSxi6pjuEWy7yWSfGKdGiPpakmSrpZ0OkuST6zDWVyVwduUDTlB2RDZby6EsAs1HSbUdFh1DCEKLfjkYQyHDqqOIYRDpEChcSE7hxCyU67kITxP92Y/0r3Zj6pjuMWBUr+xr9gyp8bYt6kD+zZ1cDrLvmLLHM7iqgzepl/9GfSrP0N1DCGEh7g9aQK3J01QHUOIQqszcwLBY0eqjiGEQ2SLh8al3PaG6ghC5GnZ9s6qI7hNzcvtMfgHOzXGbU3/ckmW2xI7Ks/gbRbvH646ghDCg+wNleKE0JZDQydQu4L0oBDaJAUKjcts2lt1BCHydDY+WnUEtymWWQaj3rkeFMUjnNsikj1OVnnlGbzNqYTbVEcQQniQaz4NnB4jJTmB5Us+oWv3wQSHOPfzQ+u0+lqkpiSyZvmntLzrUf7+bREA9z34NIHBnvccLpSvxI+/fsaQylUICyumOo4QReIRWzy2bNlCjRo1+Omnn3J8vUuXLowZk3fn5B9++IG33nrrZsTzaL47v8d35/eqYwiRS9ni5ylb/LzqGG6R5BdHoo9zDSYT40uRGF/K6SyJPhcczuKqDN4mOuwo0WFHVccQQniIMNMBwkwHnBpjw9qfOHvmOBvXrnRRKu3S6muxY8NPXDx7nN9XzOPShVNcunCKHRtXqY6Vpwvff4J5+1aWL3fukuhCqOARBQqAypUr5yhQHDlyhPT0dIWJtCFk7whC9sp1joXnebDpMh5s6lyfBk91MGI1+4s515x2/+b27N/c3uks+4utcDiLqzJ4m95136F33XdUxxBCeIgGSZNokDTJ4funJCewf/dGsNnYt3sjKcmJLkynLVp9LVJTEjmyfxNg41r8vw3AD+/dSFqKZz2H1JREOvz4JU/u38/69X+TmJigOpIQReIxWzxq1qzJqVOnSE5OJiQkhOXLl9OlSxcuXrzIl19+yW+//UZ6ejrFixdn1qxZOe67cOFCVq5ciU6no2PHjvTr10/Rs7j5kuu9pzqCR8lMTyIzLYnNK2eqjlIoGenJAOh0Omw2m+I0rjXnfA0AzsfuKvBcc2YGOl0gUNzNqVzjtst3Y/BzrgdFneZ/uCRLnYQuyjN4m0X7XijUeVnxh0i/epjUY/5uTlR4J4w61RFcwhu/JxbE38c7/u3yYrZq89/yn3l4IKgKAGdT385x+9VL5wgIKvhSjhvW/oTNZgXAZrOyce1K7ul8a27R1eprsWPDv7n/n8VqZsfGVbS+5zEFqfK2Y8NPbKxbB6vFgtVqZfnyH+jb9wnVsYQoNI9ZQQFwzz338Ntvv2Gz2di7dy+33347VquVhIQEPv/8c7777jssFgv79u3Lvs/x48dZtWoVX331FYsWLWLNmjWcPHlS4bO4ubIaPkxWw4dVxxAil9OxJTgdW0J1DLcIzYwkzFTGqTHCwi8RFn7J6SxhpjIOZ3FVBm9zJrE6ZxKrq44hhPAQZ1NLcTbV8e1wB/dtwWKxAGCxWDiwb4urommOVl+LYwe3Yr2eOwebjaMHPOs5HDu4lRPBwZwKC8NiMbNp0wbVkYQoEo9ZQQH2nhOTJ0+mfPnyNG7cGAC9Xo+Pjw8vvPACgYGBxMbGYjabs+9z9OhRLly4wOOPPw5AYmIiMTExVK5cWcVTuOn8ttqb9EizTDu/gFD8AkJp3vl51VEK5fSR7QD4+hjIMuXxg0/DSunXAoVrlnnmTAymTBNa+fwwwe8CBt8kpxpUXrscBTjfqPKa71n7OA5kcVUGb1OpmP3a8QU1y/QNr0VgmXpER1e4GbEKpXSYr+oILuHjY8DkZd8TCxId7lGfGblUUro2V1D8Mw+Lm3YDuZtl/vLd27nvlIfb6jZj3671WCwWDAYDtes2c3FS7dDqa1HttqYc3rchd5FCp6N6bc96DtVua4r575XYrFZOhpekRYuWqiMJUSQe9dOwfPnypKWlsXDhQrp27QpASkoKa9as4d1332XixIlYrdYcyz4rV65M1apV+eKLL1i4cCEPPfQQNWrUUPUUbrrgg6MJPjhadQwhcnmg8UoeaKytBliFdTjiDw6GOdcY6+DWdhzc2s7pLAfDVjmcxVUZvE3POu/Ts877qmMIITxEvaSp1Eua6vD9W7bthE5nf8ut0+m5o633Xoa7IFp9LRq1/Df3/zPojTS6w/HLfbtDo5adGHDgIAMOHkSv19O160OqIwlRJB61ggKgY8eOLFu2jEqVKnH27FkMBgMBAQH07NkTgIiICC5d+ndJcs2aNWnRogWPPfYYWVlZ1KtXj8jISFXxb7rkhh+rjiBEnpZseVB1BLepfekeDP4hTo1Rt8Ual2Spm/CA8gze5os9o1RHEEJ4kF2hjhcnAIJDilGnwR3s3vE3dRvcoalLa7qaVl+LoOAwatRpwcHd6ygeHpXdKLNmvTs87jKjQcFh/PZwP04e2UGrVm3kMqNCczyiQNGsWTOaNbMvj+rbty99+/YFoE2bNrRp06bA+z/55JM8+eSTbs3oqbLqOd4gTwh3ik0orTqC24RklcJocO4NSWiJKy7JEmqKUp7B25xPrqI6ghDCgyT51HR6jJZtOxF/+YJmVgy4k1Zfi0YtO3Et/iIt73qUv3+zb7H2tNUT/yj34EDOr5bVE0KbPKJAIRznt3E+AJl3SHde4VkqRpwC4PTlSoqTuN41/3MYfK9RIquiw2NcjbM3tiwRecGpLFd9T9vHcSCLqzJ4m6ol9gJw/Go9xUmEEJ4gPMveLyret7HDYwSHFKPXAFmdBdp9LYKCw3ig14sAPNTXs7dXlzt1jLvb34tZVk8IDfKoHhSi6IKPvkzw0ZdVxxAil84Nf6Zzw59Vx3CLIyX/4lDYr06NcWh7Gw5tL3iFWIHjhP3qcBZXZfA2PW77iB63faQ6hhDCQ9RJfp06ya+rjiFEodWY+zpB06eojiGEQ2QFhcYlNf1MdQQh8vTtpu6qI7hNnbj7MTrZg6J+y99ckqX+NceXb7oqg7f5bPdY1RGEEB5kR9gbqiMIUST7Rr1BvUrBqmMI4RApUGic6ba7VUcQIk+Xkhy/ZrynCzaFYzQ614MiuNhV12QxRyjP4G1iUzznsqFCCPVSjNKXRmhLanQVLFVDVccQwiGyxUPj/Nd9jP86uZKH8DxVIk9QJfKE6hhuER8QwxW/k06NceViea5cLO90lit+Jx3O4qoM3qZG+E5qhO9UHUMI4SFKZm2iZNYm1TGEKLQSuzbhs3G96hhCOEQKFBoXdGIaQSemqY4hRC73N/iV+xs416fBUx0LX8eR0NVOjXFkZ0uO7GzpdJYjoasdzuKqDN7moVpzeajWXNUxhBAeonby29ROflt1DCEKrfr8twl8c7rqGEI4RLZ4aFxiy69VRxAiT19veFR1BLepF9cJg59zPSgatHZNA9EGVx3v9eGqDN7m050TVUcQQniQ7WFSnBDasmfs29SXHhRCo6RAoXHmaq1VRxAiT/Ep4aojuE2gqbjTPSiCQhNdkiXI4vjr7KoM3uZyWlnVEYQQHiTVKH1phLakl6mAtaL0oBDaJFs8NC7gz5kE/DlTdQwhcqle+ijVSx9VHcMtrgSe4rLfMafGuHy+ApfPO/+m97LfMYezuCqDt6kdsZXaEVtVxxBCeIhSmesolblOdQwhCi18+zp81v6pOoYQDpEVFBoXGGNfdpjO84qTCJHTPfXWAHD0YnXFSVzveIkN6PRGIi5Xc3iMo7tbABBRNsapLEdD/7CP40AWV2XwNl1rzAfgwOWmipMIITxBrZT3ALjkJ6tWhTZUW/AegYFGEtveqTqKEEUmBQqNS2z3o+oIQuTpy3WPqY7gNvVju2L0d64HRcO2P7kkS8Orjvf6cFUGbzNnxxTVEYQQHmRrsfdVRxCiSHZPeJ8GVaQHhdAmKVBonLliE9URhMhTQlpx1RHcJsAcitHiXA+KgOBk12SxFFOewdtcTY9UHUEI4UHSDWVURxCiSDIiy2AtKz0ohDZJDwqNC/j9TQJ+f1N1DCFyqVnmMDXLHFYdwy0uB57gkv8Rp8a4dK4Sl85VcjrLJf8jDmdxVQZvU7fUJuqW2qQ6hhDCQ0Rm/klkpuznF9oRseVPfP5w7nLoQqgiKyg0LvCsfdlhOi8pTiJETh3q2nsjHL5QU3ES1ztRYhM6vZFSGTUcHuPYnmYAlCp3yqksx0L+so/jQBZXZfA2nasvAGDfpRaKkwghPEHNlA8BiPOT/fxCG6p8+aG9B0X7u1VHEaLIpEChcdc6/KI6ghB5WrC2j+oIbnP7xW4Y/J1bOtnozhUuydIovpfyDN7mo21TVUcQQniQzcU+Uh1BiCLZNfkjGlRxrleWEKpIgULjrOXqqI4gRJ6SM7x376OfJRij1bkf/P6BqS7J4u9EDldl8DaJmSVVRxBCeJBMQynVEYQokszwUtgivfd9mPBu0oNC4wJ/nUrgr/Jpn/A8tcsdoHa5A6pjuEVc0DFi/Q86NUbsmSrEnqnidJZY/4MOZ3FVBm/TIGodDaLWqY4hhPAQpTNWUzpD9vML7Si1YTW+v/6sOoYQDpEVFBoXcHE2AGlMUJxEiJzurL0WgAPnaitO4nqnim9BpzcSlXGbw2Oc2Ge/Ak9U9AmnspwIsf8i7UgWV2XwNvdXXQTA7tjWipMIITxB9dQ5AFz0l/38QhsqL55DQKCRrHvvVx1FiCKTAoXGXbtfukoLz/TZX/1UR3CbhhcewhDg3NLJxnctc0mWxvGO9/pwVQZv88HW11VHEEJ4kE3F56qOIESR7Hh1Lg2rSg8KoU1SoNA4a2Q11RGEyFNqZrDqCG7jaw3EaA1yagw//3SXZPFzIoerMniblKxiqiMIITxIlr6E6ghCFImpWAls4dKDQmiT9KDQuMBVEwlcNVF1DCFyqRe9l3rRe1XHcIvY4MNcCNjv1BgXTlfjwmnnC4wXAvY7nMVVGbxN4zJ/0riMrE4TQtiVyVhFmYxVqmMIUWhRa1fhu3K56hhCOERWUGhcwKXPAEjjVcVJPEO5Gi1URxDXtam1HoC9Z+opTuJ6p4ttR6c3Uibd8avonDrQCIAyFY85leVU8Ab7OA5kcVUGb3N35W8A2H7hTsVJhBCeoFrqfAAu+HfM+fXaLVXEEaJAFZfMt/eg6NxVdRQhikxns9lsqkOoFB+fgtWq3ZdAf/UsANYS5RUncY8lGxNUR3Cr00e2A+DrYyDLZFGcxrV0KfYrS2SYAgo898yZGNIzTej9irs7lkuY9BkY/UPxsRX83PIdI8sXAB/frHzPsV61r0DRl8i/yGPS2bdpOJIlvww+wZFFHktLAiNv3FA0wJgCQLr5xtuULJnXCPTzITq6gsuyOat0mK/qCC7h42PA5GXfEwsSHe69i1qT0rX5PuufeWi0JgFg1ue9ZD4qzHv/7bxdYrpVdYRCKer3RGNKEo2qhWALDXNjKnEr0et1hIffnO3bsoJC47y1MCG0rzCFCa3ysfpjdKI4ATcuTBRpHCdyuCqDtymoMCGEuLXkV5gQwlOZg0Oxhcq8FdokJV+NC1rxEkErXlIdQ4hcbq+4i9sr7lIdwy0uBB/kfMAep8Y4f7Im50/WdDrL+YA9DmdxVQZv06zsapqVXa06hhDCQ5RLX065dNnPL7Sj9O/L8Vv6veoYQjhEVlBonH/8VwCk8qbiJELk1LLGJgB2nb5dcRLXO1NsJzq9kbLp9R0e4/ShBgCUrXzYqSyngzfbx3Egi6syeJv2lexv6racv1txEiGEJ6iS9gUA5wJkP7/QhgpLv8A/0Ehmt4dVRxGiyKQHhcZ7UJB8xf5nSEm1OdxEelBolzXpCAAmS8F74rXWg8KiM2EICMVoc3y/v9lsrw8bjeZ8zylMDwqzzr5Nw5Es+WW41XtQ+BoyAMiy+N/wPOlB4T7Sg8K7aL0HhcFm7/Vj0eW9pU56UGiXt/ag0Gek07haCAQGujGVuJVIDwpReF5amBDaV5jChFYZbD5OFSfgxoWJIo3jRA5XZfA2BRUmhBC3lvwKE0J4Kqt/gBQnhGZJyVfjgpc+R/DS51THECKXRpV30KjyDtUx3OJ8yH7OBu50aoyzx2/j7PEbf5JfqHECdzqcxVUZvM0d5X/mjvI/q44hhPAQ0enfE50u+/mFdpT99Xv8vlusOoYQDpEVFBrnl7AEgBTeVRtEiP9oUW0LADtONlKcxPXOhu1GpzdSPq2hw2OcOWLftlG+6kGnspwJ2mYfx4EsrsrgbdpWWAbAxrP3K04ihPAEldK+BuBMgOznF9pQfuXX9h4UPXqqjiJEkUkPCq33oMhMs//p553LuKQHhXaZEo4DYLUZCjxXaz0orFgwBoShp+Dnlu8YVvsCNr0+//2vhelBYcU+bxzJkl+GW70HhUFn3/pisd24hi89KNxHelB4F633oNDZTADYdD55nic9KLTLW3tQ6MwmmlQPBZ+856wQRSU9KETheWlhQmhfYQoTWqXH4FRxAm5cmChqFtUZvE1BhQkhxK0lv8KEEJ7KZvSR4oTQLCn5alzwj8MI/nGY6hhC5NK0ylaaVtmqOoZbnAvdy5nA7U6NceZoHc4creN0ljOB2x3O4qoM3qZV9EpaRa9UHUMI4SEqpH1LhbRvVccQotDKrfoWv8WLVMcQwiFSoNA4v8Sl+CUuVR1DiFyaVt1O06rO/RLvqc6F7uVskHMNQM8eq8PZY84XB84G7XA4i6syeJvW0StpLQUKIcR1FdO/pWK6FCiEdpT7+Vv8pUAhNEp6UGi9B4WXkx4U2pV57VShz9VaDwoAY0CY2x+jMD0o3OFW70FRWNKDwn2kB4V30XoPioJIDwrt8tYeFABNa4S6KY24Fd3MHhTyHVUIIYQQQgghhBDKSYFC40KWDCZkyWDVMYTIpXm1zTSvtll1DLc4E7aLmKAtTo0Rc7geMYedXxkRE7TF4SyuyuBt2lVcSruKS1XHEEJ4iEppi6iUJsvlhXaUX74I/4Wfq44hhEOkQKFxvsm/4Jv8i+oYQuRye8Xd3F5xt+oYbnEx+BDnA/c6Ncb5UzU5f6qm01nOB+51OIurMnibZmVX06zsatUxhBAeolzGCsplrFAdQ4hCK/PHCvyW/qA6hhAOkR4U0oPCo0kPCu2SHhTOkx4U7iE9KDyf9KDwLtKDQngq6UEhROFIDwohhBBCCCGEEELcUqRAoXEh3z5OyLePq44hRC4ta2ygZY0NqmO4RUzYDk4Fb3JqjFMHG3DqYAOns5wK3uRwFldl8DZ3VVrCXZWWqI4hhPAQldMWUDltgeoYQhRahR8X4D//E9UxhHCIFCg0zjdlLb4pa1XHECKXOuUOUqfcQdUx3OJS8DHi/J17bnFnqxJ3tqrTWeL8DzqcxVUZvE2DqHU0iFqnOoYQwkOUyVhNmQzpSyO0o9SG1fj99rPqGEI4RHpQSA8KjyY9KLRLelA4T3pQuIf0oPB80oPCu0gPCuGppAeFEIUjPSiEEEIIIYQQQghxS5EChcaFLu5F6OJeqmMIkUubWn/TptbfqmO4xaliWzkZvN6pMU7ub8TJ/Y2cznIyeL3DWVyVwdvcU2Ux91RZrDqGEMJDVE39lKqpn6qOIUShVfzuUwLmfqQ6hhAOMaoOIJxjTNuqOoIQeape+hgAfx9qoziJ68UHxqAzGKmc0srhMS5ftG8LqFxnh1NZLvsft4/jQBZXZfA2t0VsA+C3Ez0VJxFCeIJSWfaGz8eDnlScRIjCKbljAz7BRtIHDwXAYjFz7dplzOYsxcmEFhiNvhQvHoHBoKZUID0opAeFR5MeFNolPSicJz0o3EN6UHg+6UHhXaQHhfBUt0oPiitXLuLvH0hQUCg6nc7V8YQXsdlspKYmkZGRRsmSpbO/fjN7UMgKCiGER7BZzFgzr6mOUWhW3U14U2M12f/IuLmvi8XoHb/k5sfiqnlmNQM+rhlLCCGEcBOzOYugoCgpTogC6XQ6goJCSUlJUJZBChQaF/rVIwAk9fpWcRIhcrqz9p8A/HngzgLP9fPzd3cclzpWfCd6oz81kls4PMaRfS0BqFF3Q77nmK0lATD65f9L8JGQTfZxHMjy3ww6nQ6bzXbDx/MGgQU8v3uqfgPAb8cfLWAkH83NXSFE0VVPnQ3A0aCnFScRonAqfz2bgAh/0p8Znv01KU6IwlI9V6RAoXHG9D2qIwiRp4oRMYU+NzJSW1sK9vr8id6QRnTxig6PsXtTDQCio8/f4KyCx9/NT/ZxHMjy3ww+vgZMWRaMXr7FIyjqxlsy6pQ7DcDhLM/ZuiGEUKdE1vU+PUFqcwhRWMUO7MAn2Id01UGEcID0oJAeFB5NelBoV1F6UGiR0b+Y6ggud+sUKGqpjuA20oNCu6QHheeRHhTe71bpQREbG0NUAcV51caNG8X06TOKdJ958+awevWvlCxpX3GalJTIXXfdQ//+A/O9z19//c6XXy5Ap4O7776fRx55LMftCQkJTJkynszMTEqWjGDcuEmcPRvDe++9nX3OwYP7mT79LZo3v6NIebXkv3NGelAIIYQQQgghhLglFLU48Y+ePXvRrVt3ALKysujTpwdduz5I8eIlcp1rsViYPXsWn366kICAAPr06cE999xPsWLFss/5/PNPuPvu++jYsQsLF37OsmXf8+ijvZk1ay4Af/yxhoiIUl5dnFBNSr4aF7roQUIXPag6hhC53FXnd+6q87vqGG6xzfA7W1jl1Bhb1tVjyzrnr86xhVUOZ3FVBm9zR+Rs7oicrTqGEMJD1EiZRY2UWapjCFFoVb6cRcD77+R7e1i3jvgtXmQ/MJnsx98tth+npdmPl34PgC4pkbBuHfFdudx+HB9vP/71Z/txXFyBeVatWsH48aMYOXI4Awb0YtWqFYwdO5KePR9k3bq/AOja9V4Ahg0bzHvvvc2IEUMZNKgfsbEXAXj11ZeJjY294eMkJSViNpvx8/Nj3rw5TJo0luHDn2bAgF7s2bMbg8HAl19+R3BwMElJiVitVnx8cn5ev3fvbpo1s/f1at78DrZv35p9W3p6OvPnz2HEiJEFPmfhOFlBoXHGjCOqIwiRp7IlLqiO4DZX9BfQOXn1hsuxuSv7Do3DGeUZvE1U4EHVEYQQHqSYWb4nCG0JPXYQY5xn/ZqXlpbGzJkfsmbNr3zzzVfMnfs5u3bt4LvvvqZ163Y5zq1VqzYjRrzInDkfsnr1r/Tt+zgTJ76S57iLF3/FmjW/ERcXR0REBGPGTCQw0N4wxs/Pn/ffn83JkyeYMmUCCxZ8jdFoZO3aP3jnnTdo0aIV/v4BOcZLTU0lONi+lSEwMJCUlJTs21auXMadd3bIseJCuJ5nzVxRZFcHyg9N4Zm++Luv6ghuc7+pL0ZDMafG6NzjL5dk6YzjXeVdlcHb/HDqfdURhBAeZEuxj1RHEKJIdk35KEcPiv9KXPp/Ky99fHIeBwbmOLaFhuU8Dg/PeVzIRufVqtkbcwcHh1CxYiV0Oh0hISFkZmblOrd6dfu5kZGRxMfH33Dcf7Z4HD58iMmTx1G+fHT2bY0aNQGgcuUqXL367zht27andet2TJs2mV9++YlOnbpm3xYUFERaWhp+fv6kpaUREhKSfdtvv/3M1KlvFOr5CscVaotH3H+W7hw4cMAtYYQQQgghhBBCeJeiXLrSkctc1qxZiz59+jNp0jisVnvz0yNHDgFw8uRxIiIiSE1NYdiwwWRlZaHX6wkICECvz/nrcN269dm0yX759c2bN1KvXgMAUlJSMJlMREZGFTmbKJpCFSgGDhzI+vXrAZg/fz7jx493ayhReGELOxO2sLPqGELkck+91dxTb7XqGG6xxbCaTaxwaoxNa+uzaW19p7NsYoXDWVyVwdu0jvqA1lEfqI4hhPAQtVLepVbKu6pjCFFoVT9/l8C3veuT/sL0oOjcuRtBQUH8+OMSAI4ePcKIEUN4/fWpvPTSBIKCgrn77vt45plBDBkyENBxzz33Ex9/hUmTxgLQv/9A1qz5jSFDnuDAgb08/PCjAJw9G0Pp0qXd+hyFXaG2eCxYsIBRo0bx1ltv0bhxY7799lt35xKFZMg6rTqCEHkqFXpJdQS3uaa/hB7nLud47UqYa7Jw4x/WNyODtwn39+5L5AohiibYfEJ1BCGKJPjMCQwJzvXKcqWOHbtk/7158zuyr4BRrVoN3nnH/oHA8uW/AmRfLQPIvjoHkGcPioEDn8r1tZkzPwTslyDt0OGeHGMAPPDAQzzwwEM5vhYWVoySJUsBUKJEeHam/1erVm1ee+3tXF8XrleoAsXhw4e5fPkyDRs25NChQ8TGxhIdHV3wHYXbXR24X3UEIfL05freqiO4zX2m3k73oOj48N8uydKRQcozeJulp/PvfC6EuPVsKyYrqoS27H75gxv2oBC59erlvb3TtKZQBYoPPviAOXPmUKZMGXbv3s0zzzzDihXOLW8WQgghhBBCCCFcLa/VFfkxGo2Eh5d0YxpRFIXqQbFo0SJCQ0M5fPgw1atX5+uvv3Z3LlFIYQvuJWzBvapjCJHL/Q1+4f4Gv6iO4RabjL+wgaVOjbHhj9vZ8MftTmfZwFKHs7gqg7dpW3ombUvPVB1DCOEhbkuewW3JM1THEKLQqn86g8DXp6qOIYRDCrWCYs2aNXz88cdYLBbuu+8+dDodQ4cOdXc2UQh6cxxkpWM9uFZ1FLd4yC9RdQS3Wp+5DQAfqwGTyaI4jWvVKX4eAH2xs4qTuN4h03kCffQ8EXbE4TFOmOoB8ESk42MAnEi090twJMt/M/j6GMgyWYgIPedUJo9nPHTDm0P8NwNQy+eHm5HGpWymgIJP0gAfcn9P1LXqpyjNzWHdsVx1BLfRN+pa8EkeKCIihMuXkwk5cMV+XDvvJfOWo5tuZizhQoYaLVRHKJR/5mJhhWRegQtuDCSEG+lsNputoJN69uzJF198wcCBA/niiy94+OGH+eEH7b1xy0t8fApWa4EvgUfz1uIEAOleXqDYdr1A4eN9BYpQ36JfIkpLyoY51yTTE/1boAhSHcW9jIGqE7iNzcdLChR5fE+UAoV2ab1AURApUGiXobp3Fij+KzY2hqioCi5MJLzdf+eMXq8jPDz4pjx2obZ4GAwGfH190el06HQ6AgK84w2QEEIIIYQQQgghPEOhtng0atSIF198kbi4OF5++WXq1q3r7lyikIotuAtbWhLX2r6lOooQOVSttR6A44daKU7ievNM6wlJNvB8SFuHx5i59D4Anu/mXJ+Omcn2FVSOZHFVBm8TFLUKgNTYjoqTCCE8QdCxyQCkVpusNIcQhRU0dTIAqRMmK83xj1WrVhATc5ohQ571yByTJo1lwoRX8PHJfWnWefPmEB4enutypY5q1645derYt9haLGYsFiuTJ0+jTJmyeZ6fnp7OlCnjSU5Oxmj0YcKEyURElMpxzvLlP7Js2Q8YDAb69x9Iy5atee+9tzl2zL6F9+rVeIKDQ5g793OXPAd3K1SBolevXqxZs4bKlSvzww8/8MEHcrklT6GzJKIjTXUMIXLx8c1QHcFtksjAYivUArR8JaS6ZptBgi1deQZvozPI91QhxL90pquqIwhRJLprMmeLYsqU127aY4WGhjFr1tzs46VLv2fx4i954YXReZ6/YsWP1KhRiwEDBrFq1QoWLfqC554bmX17fPwVlixZzKefLiQrK4uhQwfSpEkzRox4EQCz2cyQIQMZPXqCe5+YCxWqQDFy5EiGDRvGV199xQsvvMBrr73GwoUL3Z1NFMK1J7Z7dw8KoVmH9nRQHcFtnvfpQNlQ53pQTOntmj4+U0LvU57B26Scd82nJEII75By2/uqIwhRJClv33jOhm3vSEaZ3mSW6Q1WE2E7HyCjbD8yS/cESxphu7qTUW4gmVEPozMlErrnMdLLP01WZFd0WfGE7u1LeoVnyYq4H11mHDa/yEJn+/rrL/n9998wGAzUr387Tz31DL16PcyiRUtISEjgoYc6smLFbwQEBPL00wOYP38Rs2fPYs+eXVitVh59tDft23dg2LDBFC9egqSkJN555wMMBgOJiQmMGDGUzz//iv379zFy5HBWrfqdK1cu8/rrr9Khw70cOLCP559/hoSEa3Tr1p0HHniI7t27sGjREjZv3sCXXy7AaDRSsmQEU6ZMz8597txZpkwZz+jRE4mKKs3rr79CYqK9V95zz42iSpWqPPxwZypUqEjFipVo2bINe/fuZsCAQTd8PeLiYgkJsTfg7dHjAW67rTYXLpyjUqUqjBkzkUce6YXFYvm/c0Ny3P/QoQPUrVsfX19ffH19KVu2PCdOHKNWrdoALFmymKZNm1OlStVC/xupVqgChU6no0mTJsyePZtOnTrx7bffujuXEEIIIYQQQggvceLEcf74YzWzZ8/HYDAwfvxLbN68kfr1b+fAgX2cO3eWSpWqsH37NgIDA2jSpDmbNm3g4sXzfPzxPDIzM3nqqQE0adIMgA4d7qVt2zuzxw8LK0ZYWBhxcbFs2bKRyMgoDh8+yOHDh2jTph0ARqORd96ZRWzsRUaNGsEDDzyUff/Vq3+lV6++3HlnB37+eSWpqakAnDkTw08/Lefll6dSvnw0H330Po0aNeXBB7tz9uwZpk+fwscfz+PSpTjmz/+SsLBiADRq1CTXa5CUlMiwYYNJS0slKSmJtm3vZODApwG4fDmOQYNmUa5ceSZOHMO6dX/Rtm17DAYDw4c/zcmTx5k588Mc46WmphIU9G/zysDAQFJSUgAwmUwsW/YDn3zyhVP/bjdboQoUZrOZGTNm0LhxYzZv3ozJZHJ3LlFIxT5rCxnJXG07U3UUIXKoVvtvAI4daKM4ievNNf1NcLKBUSF3FnxyPmZ83wmAUQ//5FSWGcl/2sdxIIurMniboNIrAEi92EVxEiGEJwg6Oh6A1OrTFCcRonCCJl2fs1PynrOJjVf9e6D3yXlsCMxxbPMJy3nsG57zuAirJ2JiTlO7dl2MRvuvoPXrN+DUqRO0bds+uxAxePBQ1q9fi16vp3PnB9i5cztHjhxm2LDBgP330thY+zVUo6NzX5mkTZt2bNq0gX379tCnT3+2bdvC/v17GTv2ZTZv3kj16jXR6XSUKBFORkbO7cjPPvs8Cxd+zvfff0uFChWzixqbN2/EYDCg19u39548eZydO7fz+++/AZCcnAT8UyApdsPX4J8tHhaLhenTJ2M0+hAYaN9yGxkZRbly5QGoW7ceZ87EZN/v/fdnExNzmlGjRvDtt8uyvx4UFERa2r9bU9PS0rJXWWzfvoUGDRoSHHxzrr7hKoXaRP3aa69Rvnx5Bg8ezNWrV3njjTfcnUsUks6WAWSpjiFELgaDGYPBrDqGW2RiJsPm3HPLyDKSkVWoGvGNx7E5nsVVGbyNTmdCp5NCvBDCTmdJR2dxvN+PEDebLiMdXYbnzdkKFSpy8OB+zGYzNpuN3bt3Ub58BZo0acbu3TtJSEikRYuWHDlyiGPHjlKrVm0qVKjI7bc3Ztasubz//mzat+9A2bLlALILBv+vdet2rFnzK0FBQTRrdgfr1q0lK8tEiRLhgH1nQH6WL/+RgQMHM2vWXGw2G3///RcAjzzyGMOHv8C0aZOxWCxUqFCRRx7pxaxZc3n11de55577882TH4PBwEsvjefvv/9k40Z7Y/nLly8TH38FgL1791CpUmUWLvyMX36xf5AUEBCAXm/IMU6tWrXZu3cXmZmZpKSkEBNzikqVqgCwfftWmje/o9CZPEWh3plWrFiRihUrAtCxo3Q19yTXntgiPSiERzq8t73qCG7zrE97p3tQTHxsWcEnFWac0LuVZ/A2KRceKvgkIcQtI6XWO6ojCFEkKW945pytUqUq7dt3YMiQgdhsNurVq0+bNu3Q6XSUKhVJVFQUer2e8uUrULx4CQBatmzDrl07GDr0SdLT02jT5k4CA4PyfYxSpSLJzMykUaOmhIaGYjAYuOOOloXKV6tWbV566TkCA4MICAjgjjtasWTJNwA0adKcP//8nUWLFtCv3xO8/vqrLF/+A2lpqTzxxOBcY+3Ysa3AHhR+fv6MGTORqVMnc/vtjfD19WHmzDeJi4ujdu26tGzZhttuq8PUqZNZuXIZVquVceNeBmDhws+pVq06zZvfQffuPXnmmUFYrVYGDx6Kn58fYN+act99nQr13D2Jzmaz2VSHUCk+PgWrVdsvgVcXKNITVSdwq/XbtgHg42PAZLIoTuNaob75V6i9Qdkw5woUnsjXx0CWyUJEaP4/+L2C0XuvXmLzCVAdwSXy+p6oa9VPUZqbw7pjueoIbqNv1FV1BIdERIRw+XJygedZjm66CWmEOxiqt1AdoVAKOxfzExsbQ1RU7u0QwrN07Xovy5f/Wqhz169fS0BAYJ59Llzhv3NGr9cRHn5ztorI2l6NK/ZZS8hI5Wrb91RHESKH6nX+AuDo/nZKc7jDx6a/CEo2MDbkLofHeO1be3+DsY+scCrLa8m/28dxIIurMniboNL2lSWpFx9QnEQI4QmCjtgv/5daQ7Y4C20ImnB9zk6VOeutqlatQVRUlOoYbiEFCiFEkcTFxZKRmVHgeTWq2Sv9/9/gR4vOpFgBiA7+d19hcnAy1kw9Z66ednjcfxoqnYlxfAyAZOP1cRzI8t8MOr0Om9VGWpj7KuT+fv5ERha+oZYQQgghxK2gsKsnAK8tToAUKDQvYcAG797iITxORmYGGWlp+BpuvIVj0+/Vrv/N85o0FUVMsr0ZUTnff5ebP3K1GmVDfbA68dwGt5kNgNXJHreDs2rax3EgS34ZrFmGPM52XpZFG9vpZOWEEOL/ycoJoTWyckJomRQohBBF5mvQUTrY54bnhPp5Rw8K3wT7n1HBOb9dlg723m+fJYPc89wupnrnVV2EEEIIIYRrFP5aKMIjFZ/fjBJrn1EdQ4hc6rTaR51W+1THcIvZAft4TbfbqTFeWzWI11bl39m50OPodjucxVUZvE1wmR8ILvOD6hhCCA8RfOgFgg+9oDqGEIUWPPoFgkfLnBXa5L0fAd4ibDp/wKQ6hhC5WM3u2SbgCXxtBvydrO/6G53c2/HPODj+Orsqg7ex2W68OkgIcWuxGbzj6jji1mHzlzkrtEsKFBqXMGCt9KAQHung5ttUR3CbJzJuo5yvc7/EPn/PApdked5WV3kGb5N6sYvqCEIID5JafZrqCEIUSeoUbc3Z999/m+joCnTr1j3fc+bNm8Pq1b9SsmRJAJKSErnrrnvo33/gDcfOyMjg+eeHMmbMy1SoUBGLxcIbb0zl7NkYQMeoUWOpXLlqjvv89dfvfPnlAnQ6uPvu+3nkkccAeOKJ3gQG2i/FXqZMWcaNm+TEsxb5kQKFEEIIIYQQQoib6tq1a0ydOomzZ2Po1atvgef37Nkru4iRlZVFnz496Nr1QYoXL5Hn+YcPH2TGjNe4fPlS9tc2bFgHwMcfz2fnzu3MnfsRr7/+TvbtFouF2bNn8emnCwkICKBPnx7cc8/9BAQEYLPZmDVrrjNPWRSC9KDQuOLzGxO+dojqGELkUq/NXuq12as6hlvMCtjLq7pdTo3x6sqneXXl005neVW3y+EsrsrgbYLLLiG47BLVMYQQHiL44HCCDw5XHUOIQgt+cTjBL+Y/Z8MSO+KXsch+YDPZjzMXXz9Ou378PQA6ayJhiR3xzVx+/Tjefpz18/XjuALzpKWlMXr08wwd+iQzZkynf/+eAKSnp/HEE4O5996OOc5/9dWXiY2NveGYSUmJmM1m/Pz8mDdvDpMmjWX48KcZMKAXe/bsBuxFjOnTZxAdXSH7fm3atOOll8YDEBcXS3BwSI5xDQYDX375HcHBwSQlJWK1WvHxMXL8+LHrqzGeYfjwp9m/3zv7rHkCWUGhcTZDGDa842oJwrtkZXjvPv4Qmw+hTvR+ACgWkOySLMXwVZ7B29gsgaojCCE8iM0n709nhfBUtnxWFKjy44/fUblyVZ566hn27dvDli2bAPs2iTJlyrJ584Yc50+c+Eqe4yxe/BVr1vxGXFwcERERjBkzMXvLhZ+fP++/P5uTJ08wZcoEFiz4mnr1GuQ5jtFoZOrUSfz9919MzeOSrEajkbVr/+Cdd96gRYtW+PsH4O/vz2OP9aVLl26cPXuGkSOH89VX32M0yq/TriavqMYl9P9delAIj3R4ay3VEdymf0Ytp3tQPHvXIpdkedZWW3kGb5Ma27Hgk4QQt4zUapNVRxCiSFInTL7h7Ylhq/490Pn85zgwx7FNH/af4/D/HEcWmOfixQs0a9YCgLp16+Pr69iHK/9s8Th8+BCTJ4+jfPno7NsaNWoCQOXKVbh6Nb7AsSZMmEJ8/BUGD36cL7/8joCAnI1F27ZtT+vW7Zg2bTK//PITd999H+XKlUOn0xEdXYGwsDDi468QGRnl0HMR+ZMtHkIIIYQQQggh3KJKlWrs3bsHgBMnjpOV5dxVxGrWrEWfPv2ZNGkcVqsVgCNHDgFw8uRxIiIi8r3vL7/8xMKFnwHg7++PXq9Hr/93NXpqagrDhg0mKysLvV5PQEAAer2en35azgcfvAvAlSuXSU1NJTy8pFPPQ+RNVlBoXPF5DSArnfi20rBFeJb67XYDsOevBkpzuMN7AbsJ1OmZYmvk8BiTlg0DYMoDs5zKMkm3wz6OA1lclcHbhJT7BoDkc48qTiKE8AQhB+y9vpJrf6w4iRCFEzL8+px93zPmbJcu3XjttVd45plBREUVvOLg1VdfZtCgoTc8t3Pnbvz++2p+/NHeM+ro0SOMGDGE9PR0XnppQr73a9u2PdOnT+GZZwZhNpsZPvwF/Pz8WbVqBQAdO3bh7rvv45lnBmE0GqlSpRr33HM/VquVadMmM2TIQHQ6HWPHvizbO9xEXlWNsxojwZSoOoYQuWSkeO81uEvaAgh1cgFaVOgVl2SJwvHX2VUZvI3FVEx1BCGEB7H4lVUdQYgisZTxrDlrNBqz+0pkZmbSu3fOy4kOHPhUjuO8elD89xyAmTM/BOyXIO3Q4Z58L1P6/1feCAgI4NVXX891TvXqNTl8+CAADzzwEA888FCO2w0GA5Mna+vyrVolBQqNS+z/q/SgEB7pyPYaqiO4Te+MGk73oBhy52KXZBliu015Bm+TFnev6ghCCA+SVjX/T2OF8ERpY2TOFlVoaCidOnVVHUMgBQohhBBCCCGEEDeBn58fS5ascOmYea2uKKpSpQpu9iluDmmSqXEl5tUh/O+BqmMIkcvt7Xdxe/tdqmO4xduBuxiv2+7UGON/HMH4H0c4nWW8brvDWVyVwduElP+KkPJfqY4hhPAQIfueJGTfk6pjCFFoIUOeJGSIzFmhTbKCQuMsvhWxmRJUxxAil5SEINUR3KasJYgwo8GpMSqGX3BJloq2YOUZvI0lM//u30KIW48lqJrqCEIUiaWqzFmhXVKg0LjEviulB4XwSMd2VlcdwW16ZlannJ9zPSgGtfnOJVkGUVN5Bm+Tdulu1RGEEB4krfJo1RGEKJK0F2XOCu2SLR5CCCGEEEIIIYRQTlZQaFyJebeBKYMrbT5THUWIHBretROAnb83VJzE9WYE7iRAp+N1W1OHxxjz/QsAvP7wO05lGaPbah/HgSyuyuBtQqK/BCD5TB/FSYQQniBk7+MAJNf7XGkOIQorZPDjACTP/Vxpjn9kZWUxffoULlw4T1BQEC+8MJry5aNZu/ZPPvzw3ewGlQMHPkWNGrUYM+YFMjMzGTVqHFWrVmPPnt3s27ebPn0ez3P8Zct+4Lfffkan02GxmBk0aCgNGzZm1aoVxMScZsiQZ7PP3blzO8uWfc+UKa+57PnNmzeH1at/pWTJkgAkJSVy11330L//jfsEZmRk8PzzQxkz5mUqVKgIwMKFn7F+/d+YTCYeeqg7nTt3yz4/Pv4KkyaNyz4+fvwoTz89LPvyqmvX/smff67R/OVQpUChcWb/GmC+qjqGELkkxYeqjuA2lSyhhBmdW4BWI/KUS7LUsIUpz+BtzOllVEcQQngQc0g91RGEKBJzHc+asytW/EhAQCBz537OmTOnmTnzTd55ZxZHjhxi6NDhtGt3V/a5a9f+QatWbWjQoCErVy5jxIgX+e67r5k48ZU8x16z5le2bdvCe+99jNFo5MKF8wwbNpj58xfdrKcHQM+evbILBVlZWfTp04OuXR+kePESeZ5/+PBBZsx4jcuXL2V/befO7ezbt5ePP55HRkYGX3+9MMd9wsNLMmvWXAD279/L3Lkf0aXLgwC8++5bbN26iWrVtL/FWrZ4aFxS7x9JaJ33/7BCqHR8d1WO766qOoZbdM+sygBqODXGgFY/MqDVj05nGUANh7O4KoO3Sb/cnvTL7VXHEEJ4iPRKL5Be6QXVMYQotPThL5A+PP85221pRxYftv8Cb7KY6La0I98dWQxAmimNbks7svTY9wAkZSbSbWlHVp5YDkB8ejzdlnbk19M/AxCXFldgnlOnTtG8+R0AREdX5PRp+wckR44c5qefljN06JN88MFMzGYzAQGBZGZmkpmZSUBAAKtX/0KbNnfi5+eX59jLlv1Av34DMBrtn7uXKVOWzz5bRLFixQrM9dtvP/Pkk/0YMmQg06dPwWw288QTfbh27Spms5l77mnLkSOHAXjiid5kZWXx6qsvExsbe8Nxk5ISMZvN+Pn5MW/eHCZNGsvw4U8zYEAv9uzZDfyzqmQG0dEVsu+3detmqlSpyrhxIxk9+nlatmyd5/g2m42ZM2cwcuQYDAZ70/a6desxcuTYAp+zFsgKCiGEEEIIIYQQblGtWnU2blxHmzbtOHBgP1euXMZisdCkSVNat25HmTJlmTFjOsuWfc+DD/Zg06YNLFv2AwMHPsWHH77LE088xZtvTqNs2XL07t0/x9hXrlymTJlyOb4WFlaswEyJiQnMmzeHzz5bRGBgEO+//zbLln1P69Zt2bJlE6VKRVK6dBm2b9+Cr68v5ctH4+vrm+9KjsWLv2LNmt+Ii4sjIiKCMWMmEhhov6Kdn58/778/m5MnTzBlygQWLPiaevUa5JkpNvYib775Lhcvnmf06Bf46qvv0el0Oc7bsOFvKlWqTHR0xeyv3XXXPezc6dhl5z2NFCg0rsS8GmDO5ErrBaqjCJFD47vt3yS3r26sOInrvRa4nQCdnrdszRweY+S3owB465EZTmUZqdtiH8eBLK7K4G1CK9i/nybF9C/gTCHErSB0j70fTVL9LxUnEaJwQgdcn7Of5T1nl3Zblf13H4NPjuNAn8Acx6F+YTmOwwPCcxxHBkYWmKdTp67ExJxi6NAnqVu3PjVq1MRgMNCp0wOEhIQA0Lp1W/766w/0ej0jRrwI2Psx9OjxGAsWzOP5519i/vw5nDkTk2PVQVRUaS5diiU4+N9Vu1u2bKJKlRtfavXChfNUqlQ5u4hQv35Dtm3bzEMP9WDBgvlERkYxePBQlixZjNVqo23bu2443j9bPA4fPsTkyeMoXz46+7ZGjZoAULlyFa5ejc93jNDQMKKjK+Lj40N0dEV8ff1ISLiWa5vIr7/+TI8ePW+YR8tki4fGmQPqY6Ky6hhC5HI1rjhX44qrjuEWNS3FqWfLe09hYdUrd5R65Y46naWerYTDWVyVwduYUitgSq1Q8IlCiFuCKawppjDHmyILcbOZGjfF1Nhz5uzhwwdp1KgpH388j/btO1CmTFlsNhv9+/fk0iX7FpHt27dRo0at7Ptcu3aVM2diqF//djIzM9Dr9eh0OjIy0nOM3alTVz7/fB5msxmAM2dieOONqRgMN/41t3Tpspw+fYr0dPt4u3fvpHz5aCpXrsqFC+c5dOgALVq0JD09nfXr19KiRctCPdeaNWvRp09/Jk0ah9VqBeDIkUMAnDx5nIiIiHzvW69eA7Zs2YjNZuPKlctkZKQTGpq719jhw4eoW7d+ofJokayg0LikXt9iPbhWdQwhcjm5t4rqCG7zYGYVyvn5ODVGvzuWuSRLP278CcHNyOBt0q+0Ux1BCOFB0isOVx1BiCJJf8az5my5ctF88sk4vvhiPsHBIYwdOxGdTseYMRMZP34Ufn7+VKxYia5dH8y+z4IF87KvgvHggz148cVhREZGUbVqziaQHTrcS3z8FYYOfRIfHx+sVgsTJ76Sb3PKfxQrVownnniK4cOfQqfTU65ceZ5+ehgAt9/eiIsXL6DX62nQoCGnT58kICAAgFdffZlBg4YSFRWV79idO3fj999X8+OPSwA4evQII0YMIT09nZdempDv/Vq2bM2ePTsZNKg/VquVF14YjcFgYNWqFQB07NiFa9euERQUlGvbhzfR2Ww2m+oQKsXHp2C1avsl8OoCRXqi6gRutX7bNgB8fAyYTBbFaQon5sxprJnplA6+8S/ooX7e8Y1zxTn7n11ybm+kXKhzBQpPVjI02C3jXkw1o/cNoEK04tUJxkC1j+9GNp8A1RFcIq/vibpW/RSluTmsO5arjuA2+kZdVUdwSERECJcvJxd4nuXoppuQRriDoXoL1REKpbBzMT+xsTFERcnKQBXmzZtDeHh49hU+HHH8+DEOHz5I584PuDDZjf13zuj1OsLD3fP+8L9ki4fGhcyOJuyvx1THECKXJvduo8m921THcIupQdt4TufcG9LnFo/lucXOd1t+TrfJ4SyuyuBtQit+RmjFz1THuOVtPHaejcfOq44hBKG7HiV016OqYwhRaKF9HyW0r8xZbxEaGkqnTtos9DpCtnho3NFLEWA2UXB7GiFurivnw1VHcJt6pnCKXb+sk6OaVtrrkixNbfnvZbxZGbyNKdk7L4+rNeuP2Zcv3VGtrOIk4lZnCm+rOoIQRWJqLXPWUwwc+JTTY5QqdWv9picFCo37wq8bNnMCL6kOIsR/nNrvvc1bu2ZVppy/c1s8ejX7ySVZeuH4L9OuyuBt0uPzvu64EOLWlB49VHUEIYokfbDMWaFdssVDCCGEEEIIIYQQyskKCo2bHDwLgqykcuvsSxLa0Oz+LQBs+bmZ4iSuNzloC/46PbNsdzg8xrBF9i7Os3pPdSrLMN1G+zgOZHFVBm8TVvFTABJPP6k4iRDCE4TtfAiAxIY/KE4iROGE9bw+ZxfLnBXaIwUKjTt+JRqb2UQZ1UGE+I/YGO/dL9fUFOl0D4o21be7JEsbW/6XubpZGbxNZvJtqiMIITxIZsT9qiMIUSSZ98icFdolBQqN+9K/K7ZU6UEhPE/MwYqqI7hNx6yKTvegeKTJLy7J8giO9/pwVQZvkxHv+MoYIYT3ySg/SHUEIYok4wnvm7MxMaeZMWM6s2bNZdKksUyY8Ao+Ps5f8n3YsMFkZmbg5+ePzWYjOTmJIUOG06JFyxve79y5s4wbN5IvvvgGgPfee5tjx44AcPVqPMHBIcyd+3n2+WazmalTJxEbexG9Xs/o0ROoUKEi586dZdq0yeh0OipXrsILL4xGr7+1uzBIgUIIIYQQQgghhCZMmfKaS8ebMOEVKlSoCMCZM6cZP/6lGxYofvnlJ777bjEJCQnZXxsx4kXAXogYMmQgo0dPyHGfTZvWY7FYmD17Ptu2bWbu3A+ZNm0GH3zwDoMGDaFhw8bMmDGddevW0rbtnS59flojBQqNmxL6PoTYSJEeFMLDNO+0GYDNPzVXnMT1JgZtxk+nY7atlcNjPL1wEgCz+05xKsvTuvX2cRzI4qoM3ias0hwAEk85f2kwIYT2he2wv8dKbLRccRIhCifs4etz9vu852y3bgH07GmiZ08zJhP06BFA794mevQwk5YGvXoF8PjjJrp1M5OUBP36BfDkkyY6dzYTH69j4EB/hgzJ4t57LcTF6YiMtN0wz6pVK9iw4W8yMzOJj79Cjx6PsW7dWk6dOsEzz4ygdet2/PHHGr75ZhF6vZ569RowZMizXLlyhVdemYDNZqNEiX8vX9+9excWLVrC+fNn+eCDmVitVhISEhg5cgx169anZ88HqVu3PmfOxFCiRAmmTn2T1NQUXn99KtOnz7hh1tjYWEJCQgH76ooKFSoSE3MagClTphMeXpKQkFBmzZrLo492y3X/JUsW07Rpc6pUyXmVtfLlK2CxWLBaraSmpmI02n8NP3LkMLff3giA5s3vYOvWLVKgUB1AOOdQXBUwZ1FedRAh/uPCidKqI7hNK1NpijvZg+Ke2htckuUeW1nlGbxNZmID1RGEEB4kM/Ih1RGEKJLMbp43Z9PS0pg580PWrPmVb775irlzP2fXrh18993X1K9/O/Pnz+HTTxfi7+/Pq69OZNu2zaxbt5YOHe6la9cH+f333/jxxyU5xjx16iTDhj1PlSpV+e23X1i1agV169bnwoXzvPfex0RGRjFkyBMcOnSQOnXq5lucmDr1ZQwGI3FxsdSuXZdx4yZl31anTj1GjRrHDz98x8KFn/Hcc6No2TLvy5GbTCaWLfuBTz75ItdtAQEBxMZeoFev7iQmJvDmmzMBsNls6HQ6AAIDg0hNTXHo9fUmUqDQuMUBnaQHhfBIZw5XUB3Bbe7NquB0D4qHGq5xSZaHqKQ8g7fJuOp9V54RQjguo9zjqiMIUSQZfR+/4e1Ll6Zn/93HJ+dxYGDO49DQnMfh4bYcxwWtnvhHtWo1AAgODqFixUrodDpCQkLIzMzi3LmzJCRcY+TI4YC9mHH+/DnOnj1Dly4PAlC3bv1cBYqSJUvx+eef4ufnR1paGkFBQQCEhRUjMtLeRLxUqUiysjJvmO2fLR5Ll37PmjW/Zt8XoFGjJtcfvx7r16+94Tjbt2+hQYOGBAcH57rt22+/omnTFjz99DDi4mIZMWIICxYsztFvIi0tNc/73mpu7Q4cQgghhBBCCCHc6p9VAnkpXbospUpF8u67HzFr1ly6d3+U2rXrUrFiZQ4c2AvAoUMHc93vvfdmMHDgU0yYMIUqVapis9kKfKwb6dbtYSIjI5k796Psrx05cgiAvXv3UKnSjRuTb9++lebN8260HRISSlCQvfgQGhqG2WzGarVSrVoNdu60X1Vt8+aN1K9/u0PZvYkUKDTu1bD3mVpmgeoYQuTSostGWnTZqDqGW4wL3sgg3Tqnxhi04BUGLXjF6SyDdOsczuKqDN4mrPLHhFX+WHUMIYSHCNvekbDtHVXHEKLQwrp1JKybduZs8eLFefTR3gwbNphBg/qzefNGypevQP/+A/n7778YNmwwGzb8net+99xzPxMnjmbo0Cc5cyaGK1cu5/sYSUmJjBs3qsAsI0aMZM2aXzl27CgAq1atZNiwwWzatJ5+/Z644X3PnImhTJmcW28nTRpLfPwVHnmkF0ePHmbo0CcZPvxpBg9+hoCAAIYNe4758+fy1FMDMJlMtGt3V4EZvZ3O9k+p6RYVH5+C1ardl+Dk5JZgyqJi77dUR3GP9ETVCdxq/bZtAPj4GDCZLIrTFE7MmdNYM9MpHXzjLQ631T0HwLmj2u6QssL+NOhS7t+v/e57luL+Brri+DaW5bvtDZC6NvjTmXgsJ8Y+jgNZ8stQMtQ9ywsvpprR+wZQIVrx9h9j4A1v9itu//8y81qTm5HGpWw+AaojuISPj4Fpy+wFzpc62rfc6Fr1UxnJ7aw7vLcBo76RNht5R0SEcPlyMn4XFgGQWaZ3nudZjm66mbGECxmqt1AdoVD+mYuF5bf4+pztaZ+zsbExREV579Zbdxk2bDCjRo3LvsKHI+bM+ZB+/Z4gIEBbP5//O2f0eh3h4Tdn+4n0oNC47wLuw2aVHhTC82i9MHEjd2WVd7oHhbOFiexxnCiSuCqDt9FiYUII4T75FSaE8FT/FCaEeg888LDmihOqSYFC44zWLGxWs+oYQuSi01sBsFm9byeZGSsmrPg4sUvOZLFfBcTH4NzKGRP219mRLK7K4H3+eT2cu1KLEMJLWE32P/XOFaaFuGlM1+esj8xZZ8yaNdfpMaKiogo+SeQgBQqNm1R8NhS3kYTnXU5I3Nqad9oMwKYVeTcL0rKXgzfjp9PziS3vy0wVxtAv7Zew+qT/y05lGaqzXyrUkSyuyuBtwirb35AknhyiOIkQwhOE7XwAgMTGqxQnEaJwwnpcn7NLZc4K7ZEChcbtiq2JzZRJVdVBhPiPM4ejVUdwm7szoykR4Nyn691ud80lPrvZHN/i4aoM3ibjalPVEYQQHiSjrHf3PxHeJ6O3zFmhXVKg0LgfAu6RHhTCI50/Vq7gkzTqTlM5ygU4t2yyU73c3agdGgfHC0GuyuBtMhMaqY4ghPAgmaV7qo4gRJFk9pA5K7TL+zaH32ICLWkEWjJUxxAiF4PRgsHonb0NMrGQjnO9X9JNvqSbfJ3Oko7Z4SyuyuB1dFn2/4QQAsCSZv9PCK1IS7P/J4QGyQoKjRtb4lMoYSOJR1RHESKHpvdvAbyzB8WU4C1O96AY/tUEwPn+D8N19svbOZLFVRm8TVileYD0oBBC2IXt6g5IDwqhHWG9rs9Z6UHBtGmTOXr0MCEhoQAkJibQs2cfOnW68eWPr127xpAhA1mw4Gv8/PxISkrklVcmkpqaSlhYGKNHT6B48RLZ52/evJEvv/w8+3jv3t188cU3ZGZm8tZb0/Hx8aVateqMGDESvV7WCNyIFCg0btvF2mDOpIbqIEL8R8zBiqojuM39mRWd7kHRvfGvLsnS3VZJeQZvkxHfQnUEIYQHySg3UHUEIYok43GZs/9vyJDhNG9u/8AsKSmRvn0foWPHLuh0ujzP37JlE7Nnf8DVq/HZX/vii8+oV68B/fo9wbZtW5gz50PGjJmYfXvz5ndkP8ZXX31B3br1qVixEgMH9uW550ZSt2595s79iNWrf+Heezu68dlqnxQoNG554F3YUqUHhfA8F06UUR3BbVqbyjjdg+Le2htckuVeHO/14aoM3iYzsYHqCEIID5IZ9bDqCEIUSWa3G8/Zbt0C6NnTRM+eZkwm6NEjgN69TfToYSYtDXr1CuDxx01062YmKQn69QvgySdNdO5sJj5ex8CB/gwZksW991qIi9MRGWm74eOtWrWCDRv+JjMzk/j4K/To8Rjr1q3l1KkTPPPMCFq3bscff6zhm28WodfrqVevAUOGPMulS3G89dbrZGXZ7zdo0FDatGlH//49adCgISdOHAfg9dffITg4mOeff4Y333wXnxtcXjU+Ph5fXz90Oh3Tpk3GZrNx6VIc6elpTJjwChUqVESv1/Huux8xcGDf7PudPn2SwYOHAlCvXn1mznwzz/EvXYrj119X8cknXwBw+fIl6tatD0DduvVZv36tFCgKIOtLNC7MnESYOUV1DCFyMfqaMPqaVMdwi1RMJOPcc0vOCCQ5I9DpLMlOZHFVBm+j06ej06erjiFEkZy5fI1nP/mes5ev5botITWdN3/8ncTU/Od1Yc65VelMiehMiapjOCwhJZU3F31PYkqqR40l3EeXlIguybPmbFpaGm+99T69e/fnxx+XMH36DF56aTyrVq0gKSmR+fPn8N57H/Pxx/O4cuUS27ZtJibmND179ubddz/ipZfG88MP3wKQmppKhw73MmvWXCIiSrF5s/0Dl5kzP8yzOPHxx+8zdOiTPPRQJz74YCavvvp69m1ly5bj/fdn88QTg/noo/cAaNKkOWFhxXKMUa1aDdavtzcXX7/+bzIy8u4B+M03i3jkkV74+tp7fJUpU5Zdu3YAsGHDOjIy5HtsQdxSoDh37hwNGzakb9++2f/NmjXLpY/Rt29fTpw44dIxtWhk+OeMiv5edQwhcmly7zaa3LtNdQy3mBa8jRd0m50a44VvxvDCN2OczvKCbrPDWVyVwduEVvyc0Iqfq44hRJF8smYT6VkmPlmzKddtK7cf4NiFy6zYfiDf+xfmnFtV6J7HCN3zmOoYDlu5YSvHz15g5Qbnfya7cizhPqH9HiO0X/5zdunSdHr2tDfY9vGxH/foYT8ODLQfd+tmPw4NtR937mw/Dg+3sXRpOvfea2+EXtDqiX9Uq2bfkB4cHELFipXQ6XSEhISQmZnFuXNnSUi4xsiRwxk2bDCnTp3i/PlzhIeXZNmyH3j11YksXfo9ZvO/TcGrV7ePV6pUJFlZN25sPWTIcD766FNGjRrLlSuXKFPm39WnDRs2AaBOnfqcOROT7xh9+z5ObOxFnnlmEBcvXiAyMjLXOVarlQ0b1tOhwz3ZXxs37mUWLvycESOGULx48VyFD5Gb27Z4VK1alYULF7preHHdpov1wJRJbdVBhPiPU/sd743g6TpnViLcyR4UPZv+5JIsPW2VlWfwNulXWqmOIESRnLl8jYtXkwC4cDWJs5evUT6iOGBfGbHh0ClswIZDp+jSuDZhQQE57l+Yc25l6eWfVh3BYQkpqWzcd8j+b7vvIJ1bNiEsOEj5WMK90p/0vDmbX78HgNKly1KqVCTvvvsRRqORVatWUK1adT79dDZdunSjRYuW/PTTcn7+eeX/j1jkDC1atGL//n28+eY0pk59A4AjRw5Rv34D9u3bQ6VKVfK97+7du+jSpRt169bnr79+z9628f9OnjxBhQoV8PPzz/7axo3rmTTpVcLCijFz5pvZfSpE/m5qD4q3336b7du3Y7Vaefzxx7n//vvp27cvNWrU4NixYwQGBtK4cWPWr19PUlIS8+fPx2AwMH78eJKTk7l06RK9evWiV69e2WMmJyczfvx4rl2zL2mcMGECNWrcOi0jvzY1IPFqPOUXL1cdxT2szl3K0dMlJicDoNfpsNoKV4FWLTPDQqSPntLBNz4v9lTpmxNIgTtMpZ3uQXFXrS0uyXIXZZVnKKw9V0zsic/A/5ji5Y26wi4e3O3OFO5R6Ofm2XQ6HWfikwkL9FMdRRP+u2rikzWbeOUx+x7nldsPZP98sdpsrNh+gD5tG+c4vzDn3MqyIm/c7d+TrdywNce/7coN2+h9bzvlYwn3yuqsrTlbvHhxHn20N8OGDcZisVC6dBnat7+bO++8iw8/fI8vv/yciIhSJCQk3HCcwvSgePzxJxkwoDcbN64H7FffWL9+LVarlXHjJuV7v+joCkydar+9ZMkIxo61N8h877236dixM9Wq1eDMmZgcqzMAypWLZsSIofj7+3P77Y1o0UI+BCmI2woUx48fp2/ffxuL9OjRg3PnzvH111+TmZnJI488QsuWLQGoV68eEyZMYODAgfj7+/PZZ58xevRotm3bRunSpenUqRP33HMPcXFx9O3bN0eBYvbs2TRv3pxevXpx+vRpxo4dy9dff+2up+VxIi0JBJIMhKuOIkQOvv725XZZGb6Kk7heki6La1gpjuO/PF1LCwGgeGCyU1mukWkfx4EsrsrgbQID7PtK09L9CzhTCM/wz+qJf1z4v+PNR05jsVoBsFitbD5yOlfxoTDn3Mp0WfZO/jZf7b3X2nLgKBbL9X9bi5XNB444XFRw5VjCvXTx1+dsuGfM2Y4du2T//f+vdlGtWg3eeecDAO69t2Ou5pF3330fd999X67xlixZkf33IUOezf77zJkf5jp3/PjJOY59fHz48kt7L4s//1zDI488lu+qhv9/nHLlyjN79vxc55QtW5aAAHs/r/btO9C+fYcct7dq1YZWrdrkOb7I203b4vHJJ59w4MCB7KKF2Wzm/PnzANSubd+gEBoaStWqVbP/npmZScmSJVmwYAG//fYbwcHBOfYeARw9epTNmzfz888/A5CY6FkNYdxtfKXlgI2kNsNVR3GPdO/+91y/zb6H08fHgMlkUZymcGLOnMaamQXceItDo7u3A7BphfctZXs9aDt+Oj2f2Fo7PMZL340C4JP+LzuV5SXdVvs4DmRxVYbCql/Sh9vLhFIhusJNebx8GW/cGDSs8scAJJ4ccjPSuJTNxzuW5fv4GJi2bKPqGJpRukRojiJFmRKh2X9vXqMi6w6exGK1YtDraV6jYq77F+acW1noXvt718TGqxQnKbpmtauzfu9BLBYrBoOe5rUdX2XsyrGEe4Vev/pE4lLtzVmtadWqHVFRUapjeJWbtsWjcuXKNGvWjFdffRWr1cpHH31E+fLlC7zf/PnzadCgAb169WLz5s2sXbs217hdu3alS5cuxMfH891337nrKXik9Rdvx2bKIPcuKCHUOrk3/318Wtctowrhgc71oOjT3DXbsvrYqirP4G3SL7dVHUGIIhnUoQWvfPtrjuN/dG5cmw2HTmHBvp2wS+PcXasKc86tLL3CswWf5KE6t2zKxn2Hsv9tO7ds4hFjCfdKH6LdOXsz/Xd1hSOkOOF6N61A0b59e7Zu3UqvXr1IS0ujQ4cOBAcXsIkduPPOO5k6dSqrVq0iJCQEg8GQo1Pr008/zfjx4/n2229JSUlh2LBh7nwaHufXwNbYUhOkQCE8TlxM7u7G3qKpOZJyONeDom2N7S7J0hbHe324KoO3yUq+TXUEIYokOqJ49iqKMiVCsxtkAhQLCqBlrUqs3X+clrUq5dn8sjDn3MqyIu5XHcFhxYKDuKNuLf7etZ+WdW9zqqmlK8cS7pV1r3bnrBBuKVCUK1eOb7/9NsfXdDodY8eOzXXu/28DmTlzZvbfx48fn/33lStX8l//f7+PPvrIqbxaFpV1Ccyyf1x4Hr/r+/gzvXAf/zVdBv5YKInjz+1KSjEASgYnOJXlCvbX2ZEsrsrgbXRG+1J5mzm0gDOF8ByDOrRgxtI/cqye+EfnxrW5cDXxhisjCnPOrUqXGQeAzU+bhffOLZty4cpVl6x4cOVYwn10cdfnbB6XwhTC093Uq3gI13smYjFgI4kBqqMIkUPDDjsB7+xBMSNop9M9KMZ+/wLgfP+HsTp7HxNHsrgqg7cJjV4EaLMHhbh1RUcU54NBD+d5W7GgAF568K4b3r8w59yqQvfZ32NpsQcF2Fc+vNQ777mhcizhPqFPXZ+z0oNCaJAUKDTur4tNsGWl00h1ECH+4/hux3sjeLqHM6pSMtC5b5+Pt/zRJVket1VXnsHbpF26U3UEIYQHSav4vOoIQhRJ2nCZs0K7pEChcb8HtsBmS5AChfA4l8+WUh3BbRqZSzndg6Jl1V0uydISx5dvuiqDtzGl1FQdQQjhQUwl71YdQYgiMbX3rDmblZXF9OlTuHDhPEFBQbzwwmjKl49m7do/+fDDdylVyv5eZuDAp6hRoxZjxrxAZmYmo0aNo2rVauzZs5t9+3bTp8/jeY6/bNkP/Pbbz+h0OiwWM4MGDaVhw8asWrWCmJjTOS5FunPndpYt+54pU17LMcZ7773No4/2zrfpZffuXYiMjEKn02G1WklPT2P06AnUrHnjvlUHDuzn44/fZ9asuQAcO3aEGTNew2AwUL58NGPGTESv12efbzabmTp1ErGxF9Hr9YwePYEKFSoWeD9vIgUKjSufeUF6UAiP5B+UDkBGqvc1W7usS8eIiShufLnKG4lNtF+bPCos3qkssaTZx3Egi6syeBu9TwIAVlMxpTmEEJ5Bn3EOAKt/OcVJhCgc/fnrc7asZ8zZFSt+JCAgkLlzP+fMmdPMnPkm77wziyNHDjF06HDatft3e9natX/QqlUbGjRoyMqVyxgx4kW+++5rJk58Jc+x16z5lW3btvDeex9jNBq5cOE8w4YNZv78RUXKOGLEiwWe8847s/Dz8wNgy5ZNzJ8/lzfffDff8xctWsCvv67C3//f98Lz53/CgAFP0qJFK6ZMmcDGjetp1apN9u2bNq3HYrEwe/Z8tm3bzNy5HzJt2owC7+dNvLPscgsZXGoJg6N/UR1DiFxub7+L29t75yf0M4N2MVG3w6kxJi4dwcSlI5zOMlG3w+EsrsrgbULKf01I+a9VxxBCeIiQ/YMJ2T9YdQwhCi3kmcGEPJP/nO22tCOLD9t/gTdZTHRb2pHvjiwGIM2URrelHVl67HsAkjIT6ba0IytP2C9NHp8eT7elHfn19M8AxKXFFZjn1KlTNG9u70kWHV2R06dPAXDkyGF++mk5Q4c+yQcfzMRsNhMQEEhmZiaZmZkEBASwevUvtGlzZ3Zh4L+WLfuBfv0GYDTaP3cvU6Ysn322iGLFiuWb5+zZs7z44nCeeKIP8+bNAWDYsMHExJzm1KmTvPXW6wU+p9jYi4SEhADQp08P3nxzGkOGDGT06OdJT7d/SFe2bDmmTZuR437Vq9cgKSkJm81GWlpqdu5/lC9fAYvFgtVqJTX139sLup838d5ndov4/WIzbFkZNFUdRIj/OLazmuoIbvNIRjUinOxB8WTrJS7J8qSthvIM3ibtkjQKFEL8K63SKNURhCiStOc9a85Wq1adjRvX0aZNOw4c2M+VK5exWCw0adKU1q3bUaZMWWbMmM6yZd/z4IM92LRpA8uW/cDAgU/x4Yfv8sQTT/Hmm9MoW7YcvXv3zzH2lSuXKVMm50qRsLBiN8yTlZXFa6+9hdVq5eGHOzFw4FPZt1WqVJmRI8fkeb8XXhhGVlYmV65coVmzFjzzzHMAZGRkcM8999OgQUM++ug9li37np49+9Cu3V1cvHghxxjlypXnnXfeZMGCeQQFBXP77Tk36gcEBBAbe4FevbqTmJjAm2/OLNT9vIkUKDTur8Bm2GwJUqAQHufK+QjVEdymgTnC6R4UzSrvdUmWZjje68NVGbyNKcXxxqNCCO9jCpfGuUJbTG1vPGeXdvv36h4+Bp8cx4E+gTmOQ/3CchyHB4TnOI4MLLgXVqdOXYmJOcXQoU9St259atSoicFgoFOnB7JXIbRu3Za//voDvV6fvd1i4cLP6NHjMRYsmMfzz7/E/PlzOHMmhujoCtljR0WV5tKlWIKD/23OvmXLJqpUyf+DssqVq+Dr6wuAwVD4X4f/2eIxZ86HXLhwnuLFSwBgNBpp0KAhAHXq1Gfz5g35jvHee2/z4YefULlyFb7//ltmzXqXF18cnX37t99+RdOmLXj66WHExcUyYsQQFixYXOD9vIls8dC4yhlnqGy6UPCJQtxkgSGpBIakqo7hFrH6VM7h3HM7dy2Sc9ecvz75ORzP4qoM3kbvG4/eV/pyCCHs9Gmn0KedUh1DiELTnz6F/rTnzNnDhw/SqFFTPv54Hu3bd6BMmbLYbDb69+/JpUv2LSLbt2+jRo1a2fe5du0qZ87EUL/+7WRmZqDX69HpdGRkpOcYu1Onrnz++TzMZjMAZ87E8MYbUzEY8v81V6dz7vkMGjSE+Pgr/PDDd4C9seWxY0cB2LdvD5UqVcn3vqGhoQQFBQFQsmQEyclJOW4PCQklKCj4+rlhmM1mrFZrgffzJrKCQuMGRC4FbCTxtOooQuRQv90eADatuENxEtd7P3APfjo9n9haOzzGlOXPAPBJ/5edyjJFt9M+jgNZXJXB24SU+xaAxJNDFCcRQniCkIP275WJjVcVcKYQniHkuetzdqlnzNly5aL55JNxfPHFfIKDQxg7diI6nY4xYyYyfvwo/Pz8qVixEl27Pph9nwUL5tG//0AAHnywBy++OIzIyCiqVs25yrFDh3uJj7/C0KFP4uPjg9VqYeLEV7JXNxTVqVMn+f77b/Pd5gFkX11j2LBBtL2+WmXRogXExcUSGRnFoEH5v38YPXoikyePw2AwYjQaGT16AgCTJo1l+PAXeeSRXrz22isMHfokJpOJwYOfISAgIN/7eSOdzWazqQ6hUnx8Clardl+CDZO6YctK546+41RHcY/0RNUJ3Gr9tm0A+PgYMJksitMUTsyZ01gz0ykdfOMtDpUqXgUg/mL4zYjlNivsjbDp8n/bG/cb4okIMtKIkg6Pu+O0/bJUjSoedCYeO7hiH8eBLPllKBka7FSm/FxMNaP3DaDC/y3NVMJ44yue+ASdAMCUmv8nIJ7K5uMdV83x8TEwbdlGAF7q2AwAXat+KiO5nXXHctUR3EbfqKvqCA6JiAjh8uVkfK6uB8BUolWe51mObrqZsYQLGaq3UB2hUP6Zi4Xls/H6nL3DPmdjY2OIilL8s9eLde/ehUWLluTbyLMw5sz5kH79niAgwDN+jv93zuj1OsLD3fP+8L9kBYXGrQ9shM2WgPd9Ri20TuuFiRupYwl3ugeFs4WJ7HGcKJK4KoO30WJhQgjhPvkVJoTwVP8UJoR2PPDAwx5TnFBNChQaVyPjJDaTd+7zF9oWFJYCQGrizam23kzn9CmYMVKREIfHOH2lDAAVSzrXQ+Y09k9UHMniqgzexuB3CQBLpuMNSIUQ3sOQegwAS5D3Xp1KeBfD8etztqrM2ZthyZIVTo8RFRXlgiTeQQoUGtcnciX2HhTPqI4iRA712tivEOGNPSg+CtzrdA+KaT/Z+8Y42/9hmm63fRwHsrgqg7cJLmu/9rv0oBBCAAQfGgFIDwqhHcEjr89ZD+lBIURRSIFC41ZebANZ6bRRHUSI/zi8tabqCG7TN70mpYKc+/Y5rP0il2QZZrtNeQZvkxp7v+oIQggPklp1kuoIQhRJ6jiZs0K7pEChcVsCG2CzJUiBQnica3GOdU/WglqWEk73oKhf/ohLstTH8V4frsrgbcxpFVVHEEJ4EHOxZqojCFEk5qYyZ4V2SYFC4+pkHJUeFMIjhRS3X585+Vqo4iSuF6NPIgMfquL4czt+KRqAqqXOOJXlOPbX2ZEsrsrgbQx+sQBYMmU/qBACDCn2hsKWYMdXrAlxMxkOXZ+ztWTOCu2RAoXGPRr5C/YeFCNURxEihzqt9gPe2YNiTuB+p3tQvPHzk4Dz/R/e0O2xj+NAFldl8DbBZX8EpAeFEMIu+PBIQHpQCO0IHnt9znp4D4pTp07y5pvTABvlykUzevQEjMa8fz2dN28Oq1f/SsmS9quXJSUlctdd99C//8B8x1+9+he+/fZrjEYDlStX5cUXx6DX6wG4du0qAwf2ZebMD6lQoWKu+2ZkZPD880MZM+ZlKlSoiMVi4Y03pnL2bAygY9SosVSuXNXZl0DkQQoUGrcs9k5smem0Vx1EiP84uNl7q/YD0m9zugfFcx2+cEmW52x1lGfwNqkXO6uOIITwIKnVXlUdQYgiSZ2kjTk7d+6HPPXUMzRo0JBp0yazYcM62ra9M9/ze/bsRbdu3QHIysqiT58edO36IMWL595WnJmZwSeffMwXX3yDv78/kyaNY+PGdbRq1Raz2cybb07H19cvz8c5fPggM2a8xuXLl7K/tmHDOgA+/ng+O3duZ+7cj3j99XecefoiH1Kg0LjtAXWxWROkQCE8TuLlYqojuE01SzGne1DULnvcJVlqU1x5Bm9jTi+vOoIQwoOYwxqpjiBEkZhvv/GcDUvsSIZfbzL9e4PNRFjSA2T49yPTryfY0ghL6k6G/0Ay/R5GZ00kNPkx0v2fJsuvKzprPKHJfUkPeJYs3/vRWeOw6SNv+HhpaWlMmTKe5ORkKlWqzP79e1mwYDFTp76JwWDAZDIRHx9PcLD90vSvvvoygwYNveGlN5OSEjGbzfj5+TFv3hzOnDnNtWvXSE5O4rnnXqJu3XrMnj0ff39/ACwWS3ZBYtasd+nW7WEWLvwsz7GzsrKYPn0Gr7767wrTNm3acccdrQCIi4slONjxS82LG5MChcbVTz+EzZSmOoYQuYSGJwKQFB+mOInrnTQkkoqRGhRzeIwjsRUBqBF12qksR0iwj+NAFldl8DYG//MAWDLKKk4ihPAEhmT7ZbMtIfUUJxGicAz7rs/Zup4xZ3/88TsqV67KU089w759e9iyZRMABoOB2NiLPPfcUIKCgqlatRoAEye+kuc4ixd/xZo1vxEXF0dERARjxkwkMDAIAD8/f95/fzYnT55gypQJLFjwNSVK2BuJL1mymPT0dJo0acaqVSsoVqwYzZq1yLdAUa9egzy/bjQamTp1En///RdTp77hzEsibkAKFBrXPWo19h4Uz6uOIkQOte84AHhnD4pPAw443YPirV+fAJzv//CWbp99HAeyuCqDtwkusxyQHhRCCLvgI2MA6UEhtCN44vU5m08PisSw//u6zuc/x4E5jm36sP8ch//n+MarJwAuXrxAs2YtAKhbtz6+vr7Zt0VFlWbx4h9ZsWIpH3wwkwkTpuQ7zj9bPA4fPsTkyeMoXz46+7ZGjZoAULlyFa5ejQfAarXy0Ufvc/ZsDNOmvYlOp+Onn5aj0+nYvn0rx48fZerUl3n99XcIDy9Z4PMAmDBhCvHxVxg8+HG+/PI7AgICCnU/UXhSoNC4JbF3Y8tM417VQYT4jwMba6uO4DZPptcm0skeFCPvne+SLCNtdZVn8DYpF7qqjiCE8CApNV5XHUGIIkl51bPmbJUq1di7dw+tW7fjxInjZGVlATB69PMMG/Y85ctHExgYmN3AsiA1a9aiT5/+TJo0jtmz7e9ljhw5xL33duTkyeNEREQAMGPGdHx8fHjttbezx/7ww0+yxxk2bDCjRo0rVHHil19+4vLlS/TtOwB/f3/0ej16va5Ir4MoHClQaFzI3U9ju3BEdQwhcvHGrR3/qGwJc7oHhau2VTizzUS2duRNtnZ4hlbVyqmOIAQgWzuE9njK1o5/dOnSjddee4VnnhmUo69Enz6PM336ZIxGH/z9/Rk9eiJQuB4UnTt34/ffV/Pjj0sAOHr0CCNGDCE9PZ2XXprAkSOHWblyGfXr387w4U8D0KPHY/k24Vy1agUAHTt2yfP2tm3bM336FJ55ZhBms5nhw1/Az8+/6C+GKJDOZrPZVIdQKT4+BatVuy+B39ZFWC8cJrN6B9VR3CM9UXUCt1q/bRsAPj4GTCaL4jSFE3PmNNbMdEoH3/gX9PLl7P92Wm+WueKc/c8u//e70jFDAqWCjE41qDxw3n5pKmcbVR7gmn0cB7Lkl6FkaLBTmfJzMdWM3jeACtEV3DJ+oRkDb3xzwFlAm80ybT7esdQ0r++Julb9FKW5Oaw7lquO4Db6RtpclRQREcLly8kYE3cA+TfLtBzddDNjCRcyVG+hOkKh/DMXC8u46/qcvd4sMzY2hqgoxT97r8vMzKR37+4sWbLCZWPOmzeH8PDw7Ct8OOL48WMcPnyQzp0fcFkuLfvvnNHrdYSHu+f94X8Vbh2N8FjBB0cTGv9JwScKcZPd1vwgtzU/qDqGW3wWcJB3dfudGuPdNf14d43zv3C9q9vvcBZXZfA2QaVXElR6peoYQggPEXRsIkHHJqqOIUShBU2ZSNAUmbNFERoaSqdO2iymehvZ4qFxyQ0/xnr2gOoYQuSyf30d1RHc5qm0OkQWsIKkIKPv/9QlWUbb6ivP4G1Szj+oOoIQwoOk1HxLdQQhiiTlNc+ds35+fi5dPQEwcOBTTo9RqlTBzT7FzSEFCo3LqtcFqzFUdQwhckm+5r3zsoI11OkeFFVLnXFJlqo4/jq7KoO3sWTmv+dVCHHrsQTfpjqCEEViqSVzVmiXbPHQOL+N8wk49LPqGELkUjzyKsUjr6qO4RaHDFfZQ7xTY+w5W4M9Z2s4nWUP8Q5ncVUGb2MMPI0x8LTqGEIID2FM2IIxYYvqGEIUmnHrFoxbZc4KbZIChcYFH32Z4ITPVccQIpeaTQ9Ts+lh1THcYmHAYWbpnOuvMeuP3sz6o7fTWWbpDjqcxVUZvE1Q1M8ERUnhVwhhF3R8CkHHp6iOIUShBU2fQtB0mbNCm2SLh8YlNf0M25m9qmMIkcvevz3rEleuNDStHlHBzn37HN9ptkuyjLc1UJ7B26Scf1h1BCGEB0mp9Z7qCEIUScpbMmeFdkmBQuNMt92NFV/VMYTIJTXx5lyKSIVy1mCne1BULHnBJVkqEqI8g7exZJZSHUEI4UEsQdVURxCiSCxVZc7eSPfuXVi0aAl+fn7ZX9u8eSNxcbE88MBDed6na9d7Wb78V5c8/rx5c1i9+ldKliwJQFJSInfddQ/9+w8s8L5vvDGN0NBQhgx5FqvVyttvv87x48fw8fFhzJiJlCuX+xLp165dY8iQgSxY8DV+fn4sXPg5W7ZsBCAlJYWrV+Nd9txcQQoUGue/7mNsscdIry3X7BWeJby0vS9C/MVwxUlcb78hnjiMNKKkw2PsOG1vYNWoonNbRXZwxT6OA1lclcHb+ASdAMCUWkVxEiGEJ/C5uh4AU4lWipMIUTg+G6/P2TtkzhZW8+Z33NTH69mzF926dQcgKyuLPn160LXrgxQvXiLf+yxd+j0nTx6nQYOGAKxb9xdZWVnMmfMZ+/fvY9asmbz++js57rNlyyZmz/6Aq1f/7VfWt+/j9O37OAAvvfQcQ4cOd+lzc5YUKDQu6MQ0sJhJRwoUwrNUb3wEgE0rbu43/Jvhq4Aj+On0fGJr7fAYs9f2BOCTii87lWW27pB9HAeyuCqDtwmM/A2AxJNDFCcRQniCwJPTAUgssUpxEiEKJ/DN63N2ad5zNmx7RzLK9CazTG+wmgjb+QAZZfuRWbonWNII29WdjHIDyYx6GJ0pkdA9j5Fe/mmyIruiy4ondG9f0is8S1bE/egy47D53fgSnatWrSAm5jRDhjxLZmYmvXt3Z8mSFQwbNpgKFSoSE3MagClTphMTc5ovvpiPXq8nPj6erl0f5OGHH+HEieO8++4MbDYbYWFhjB07iaNHD/Pxxx/g4+ND164Pct99nQB4//23qVu3Pnfe2YEXXniWpk2b0bNnH954YyodO3YB4O23X+fChfMATJ/+FuvXryUm5jRPPDGYl18eQ2pqKhkZGQwePJSmTZtnP5c5cz4kJSWFF154iT///J1vvlmEXq+nXr0GDBnyLPPmzWH//r2kp6czZsxEFi78jEGDhhIVlf8VwpKSEjGbzfj5+TFv3hzOnDnNtWvXSE5O4rnnXqJ+/Qbs27eHgwf388ADD2W/Xnv37qZZsxYA1KlTl8OHD+UaW6/X8e67HzFwYN9ct61d+wchISE5np8nkAKFxiW2/Brb6T2qYwiRy56/6quO4DbD0+oTFezcFo9JXT90SZZJtobKM3ib5HOPqI4ghPAgybfJ90qhLcnvamfO1qlTj1GjxvHDD9+xcOFntGlzJ1euXGb+/EXYbFb69etJ+/YdeOONqYwd+zKVKlVm5cqlLFq0gCZNmpGVlcUnnyzIMWabNnfy888rueOOViQnJ7FjxzYefbQ3R44c4qWXxgPQqdMD1K/fgGnTJrNt279XPDl//hyJiYm8/fb7XLt2jbNnY7JvmzXrXfR6HS++OJqkpETmz5/Dp58uxN/fn1dfnci2bZsBqFChEs89NxKAiRNfyfN5L178FWvW/EZcXBwRERGMGTORwMAgAPz8/Hn//dmcPHmCKVMm8PbbH/DZZ58wffpb/PHH6uwxUlNTCQr6d0u1Xq/HbDZjNP77K36TJvkXHxYu/JzJk6fd+B9IASlQaJy5WmusJqvqGELkkpYcpDqC20RZg5zuQVGueJxLspTD8dfZVRm8jTXL+7YlCSEcZw2spDqCEEVirXjjOZvY+P9WVuh9ch4bAnMc23zCch77huc8LmD1RG62HEeNGjUBoG7deqxfvxawFy18fe099ipXrsL58+eIiTnF22+/DoDFYqZcuWgAoqMr5HqEevUa8N57b7Fz53batWvPX3/9zp49u6hdux46nQ6AmjVrAlCiRDiZmRnZ961cuQoPPPAQkyePx2w20727fbXp1avxnDhxjLJl7T0ezp07S0LCNUaOtG+PSEtL4/z5c/lm+q9/tngcPnyIyZPHUb58dK7XpHLlKly9Gs+ff64hISGBkSOHc/VqPBkZGVSoUJGgoCDS0tL+fWVtthzFiRs5deokwcHBefasUE0uM6pxAX/OJHDv96pjCJFLybKXKVn2suoYbrHbeJktXHJqjC0n67HlpPNXOtnCJYezuCqDt/EJPopP8FHVMYQQHsIn/k984v9UHUOIQvNZ+yc+az1nzvr6+hIfb++ZdeRIzkvQHzli35awd+8eKlWqDMCxY0exWCxkZGRw6tRJypWLJjq6AhMmvMKsWXMZMmQ4d1zvr6HX63I9nl6vp2bN21i06AuaNm1OvXoN+Oij92nb9s7/Oyv3/QBOnDhOWloqM2a8x/jxU3j33RmAvZDxzjuzOH36JJs3b6R06bKUKhXJu+9+xKxZc+ne/VFq166bb6b81KxZiz59+jNp0jisVmuO1+TkyeNERETQo0dP5s//klmz5tKnz+Pcffd9dOzYhbp167N58wYA9u/fR+XKVQv9uNu3b73pfTcKS1ZQaFxgzNtgMZOGXBZPeJZqDY8BcOV8hOIkrvet/zH8dHqa2Ry/2sOn6+yNkZpVdu4ywZ/q7L0+HMniqgzeJrDU7wAkplRXnEQI4QkCT9l/QUkMv7OAM4XwDIEzr8/Ztp4xZ5s1u4OlS79nyJCB1KhRi6Cgf1d/rlq1km+++Qp/f38mTnyFEyeOYzabGTlyOImJifTvP5BixYrx4otjmTr1ZSwWCzqdjjFjJnLlSv4fhLVpcyfTp0+hatXqNG16lV9++Sm7ueSNlCtXns8+m8sff6zBarUycOBT2bf987gvvvgsc+d+zqOP9mbYsMFYLBZKly5D+/Z35xrv1VdfLrAHRefO3fj999X8+OMSAI4ePcKIEUNIT0/npZcm3PA5btu2haeffgKbzca4cZMA+9aNatWq37AAceZMDE2aNCvw9VBBZ7PZbAWf5r3i41OwWrX7EhhPb8N6ahfmyBqqo7hHeqLqBG61fts2AHx8DJhMFsVpCifmzGmsmemULqAHQ6kS9uVyGakBNyOW26ywr9ajS7l/v3ZZl07pECNRBDo8bmyifRtBVFh8AWcWMA72pX2OZMkvQ8lQ91wi9mKqGb1vABUKsfTRrYw3fq30PgkAWE3F3J/FxWw+2v7/7R95fU/UteqnKM3NYd2xXHUEt9E36qo6gkMiIkK4fDkZfYb9B4HVv1ye51mObrqZsYQLGaq3UB2hUP6Zi4Wlv77VwFrWPmdjY2OIilL8szcPw4YNZtSocVSoUDH7azt3bmfZsu+ZMuU1dcEUmjdvDuHh4dlX+HDE+vVrCQgIzN4q4oj/zhm9Xkd4uHveH/6XrKDQOHPFJlj/b++REJ5C64WJG4mwBRDlZA8KZwsT2eM4USRxVQZvo8XChBDCffIrTAjhqf4pTIhbU9WqNW64YsPTSYFC4wJ+fxNb3CnSGvRUHUWIHCLK2/siXD7r+DYIT7XDeIkYjLSkqI2h/rXh+O0AtKy6y6ksG7A3unQki6syeBufYPv+WFNKTcVJhBCewOeKvWu+qWTu5dtCeCKf61d6MOWx5cCTzJo1N9fXGjZsTMOGjRWk8Qz/v6XEUVouToAUKDQv8Oz713tQSIFCeJaqDY4D3lmg+N7/OH46PS1tjhcoPt/wIOB8ceBznb2ZoyNZXJXB2wSWsjcWS5QChRACCDw9E4BEKVAIjQh8//qc9fAChRB5kQKFxl3r8Au2k9tVxxAil51rCm5EpFWjUhtSOsS5LR6vPfyOS7K8ZnN8f6GrMnibpDO9VUcQQniQpLqfqY4gRJEkzZE5K7RLChQaZy1XB2uS7CMXnicz3V91BLcpbvOnpJM9KEoGJ7gkS0kcf51dlcHb2MyhqiMIITyIzc/x1XJCqGCLlDkrtEuvOoBwTuCvUwna9aXqGELkElkhjsgKcapjuMVWYxxruejUGGuPNGbtEef3WK7losNZXJXB2/iGHMQ35KDqGEIID+F7+Wd8L/+sOoYQheb768/4/ipzVmiTrKDQuICLs8FiJpU+qqMIkUPleicAiIvxvir+Uv8T+On0tLWVdniMLzfbL7vXtoZzW7S+1Nl7fTiSxVUZvE1AxFoAspJvU5xECOEJAmI+ACAr4n7FSYQonICPr8/Ze2+dOTts2GAyMzPw8/PHZrORnJzEkCHDadGiZb73GTPmBRITEzAYjPj5+fP22+9z7txZpk2bjE6no3LlKrzwwmj0+n8/009JSWHSpHGkp6fh4+PLyy+/Qnh4SQAsFguTJo2lc+duNG9+h9ufs7eSAoXGXbv/T6zHt6qOIUQuO1Z77yfzY1IbUzrEuW+fb/aY4ZIsb9qaKs/gbZJi+qmOIITwIEn1FqqOIESRJM27NefshAmvUKFCRQDOnDnN+PEv3bBAce7cWRYu/BadTpf9tQ8+eIdBg4bQsGFjZsyYzrp1a2nb9s7s21etWkGVKlUYOnQEy5f/yFdfLeTZZ5/n/PlzTJ36MpcuXaJz527ueoq3BNnioXHWyGpYi8u1joXnycrwJSvDV3UMtwi1+VIcP6fGKB6YTPHAZKezFMfP4SyuyuBtbJYgbJYg1TGEEB7C5huOzTdcdQwhCs0WHo4tPP85G9atI36LF9kPTCb78XeL7cdpafbjpd8DoEtKJKxbR3xXLrcfx8fbj69vIdHFFbydd9WqFYwfP4qRI4czYEAvVq1awdixI+nZ80HWrfsLgO+//4bhw59m0KD+jBo1ApPJxPfff8ukSeMAmDp1Ej/88B1JSYmMGzeqwMeMjY0lJMTeU2rYsMHMmDGdYcMGM2zYYOLjr3D1ajzJycmMHv08Q4YMZMOGdQAcOXKY229vBEDz5newfXvOD4KrVKlKWloaAKmpqRiNxusvWxqjR0+8pS+R6iqygkLjAldNhPizpDQaoDqKuIVkWWxcTDHd8JxSFS4BcPq4tq/FnGUxABCbYsn+2k7/WEpkGGlpdnyLx4ZjLQBoWW2TU/k2GO39JxzJkl8Gk8HsVKb8ZFlsTrT0vHl8Q/cBkJVUV3ESIYQn8I2z/2KWFdlVcRIhCuefYkJWZ8+Zs2lpacyc+SFr1vzKN998xdy5n7Nr1w6+++5rWrZsQ2JiIu+++xF6vZ4XXhjGoUMHePjhR9i+fQvTpk3GZDLx0EM9AJg+Pe8VoFOnvozBYCQuLpbatesybtyk7Nvq1KnHqFHj+OGH71i48DMee6wvPXv2oUePnte3gwzktttqY7PZsldUBAYGkZqakuMxQkPD2Lp1M3369CApKYkPP/wEgGrVqrvjZbslSYFC4wIufQYWMylIgULcHP5+hfsVs06jc8D/2rv3sKjKfQ/g31nMBXSGq3e5WZCdLpii7U7hfnaW3Z5s+0ia6MFLmOITpXkyTEFNwEdLqa2YbT22bauJuk07Vh551Ao1QdTcCIoGFZalTiQiyHXmPX+MkKMgc2XNDN/PPzZrzaz5LfqyhvWbd70LOHeunzPLcbownREAIKn/GA2y3/dnaJQKDG24w+bt7jph+qNh6L0n7Kpvl7rctB0barm5BoWkgDAKSGofu2pqizcsz4+cfLodBMAGBRGZ+Pz0AQA2KMh9+PzP9cy20aC4svOLPx6oVOaPu3Qxeyx8/cwfBwWZP7bwjiGRkf0BAFqtDuHh/aBQKKDT6VBf3wBJkqBSqbBw4Tz4+Pjg0qVLaGoyfVkyfvwkJCZOxrp17d8UoPkSj507t2Pv3j3o2fOPL8mio023Zb///igcPPg1goK6YeTIWCiVSgQEBCIysj/OnSs3m2/i2rUaaLVas/f4xz/WYty4CRg5Mhalpd8hJeUNfPRRtkU/A7IMGxRu7vJzh2H8Ll/uMqgTufFgfzsl/+4DAAgNte9SCLmFtrJsqeiF3r5q6CTb923ta1sBADqfcJu3AQBrjeNM27GhlptrUKu80NBoQHffzn15Q9WPk+QugYhcSNWAzXKXQGSVqn+6XmZvnOfhZqWl3yE39yusXfsR6urqkJBgmvy/sbERK1Ysx+zZc7F8+RKsWrUWKlX7t3kfOTIWJ0+ewJo17+Pll2cAAM6cOY0ePXqisPDf6NfvDhQU5GP79i1YtmwFrl27hh9+KENYWD9ERvbH8eNHMWjQYOTlfXPLJRs6na6laREQEICamhpbfyTUBjYo3JwxMARG3fdyl0F0i6Ym925M3E5XhQY6yb75NXQ+dQ6pxZ4miaNq8DTC6JwRJETknoTKT+4SiKwifN0rs8HBIfDx8cH06S8CAIKCuuG33/RYvXoFHn44Bn/96yj89pseH3ywEhMnJmDJkvQ2L/NoNmPG65g4MQ5PPGG6k8kXX3yGLVs+hre3N1JTF8HPzx9HjuRh6tRJkCQJU6e+DH9/fyQlzcTbb2fg739fhbCwcPzlL48BMM1jkZW1Bi+9NB1LlqRhx45/oampCcnJ85z7w+mEFEIIIXcRcqqoqIbR6L4/gq673oD4/Tyqh0yVuxTnqL0idwVOdbCgAACgUnmhsdHQzrPdS2T4WQDAxV/6y1yJ431lOIPALko87f0fNm9j99EoAMDTgwvtqmV33WnTdmyo5eYaOs0ICmWX267W+J0AANRfecD5tTiYUHlGc6W1Y6IixrPvrmI89r9yl+A0UrR7XhrRvbsOev1VaC6YJgus7xXb6vMMZ+2bS4jk43XXf8pdgkWas2ip5gku60eaMnvhQjl69QpzSm3uIClpKmbPnttyhw9b/O1vyzFjxn87rigXd3NmJEmBoCDtbV7hOBxB4ea8Kz6+PgeFhzYoyG0F9zOd9Hpig+KzpkJorkl2NSi25D4EwP4GxZZrJ0zbsaEWR9XgabyDTCcb7tigICLH8/55HYC2GxRErsZ7/fXMjmRmHWXs2PFyl9BpcASFm4+gwNXfYDz7DeDjXkO5LMYRFG7L38c0uZHR0P61gu6mTjSij58aPgrb9622wfRaH/Xt74bS7naE6fW21HJzDRxBcZ2iwfSvcL/b5HIEhfviCArX0/KttcF0S0F4tX7s4AgK9+WpIyhw/TaY6GLKbGcfQUHW4wgKsp2um+c2J8iteWJjopm3QmVXcwKwvzHRsh076nBUDR7HDRsTROREbTQmiFxWl1sze+PtM4luR+7xC1L7TyFXpt05E7r8VXKXQXSLXsGn0Sv4tNxlOMVew2nsqi22axu78gdiV/5Au2vZVVtscy2OqsHTaPyPQeN/TO4yiMhFaH7NhuZX3kaQ3IdmWzY02/7IrFKpRk1NlewnnuT6hBCoqamCUinflzUcQeHmNJX/AoxNuIqX5S6FyEzfsCIAwIWfbZ+nwVX9X1MRNLUSRvjca/M2th8y3Y97xJ++tauW7bWm+SNsqcVRNXga78AjAID6ymiZKyEiV+B9/p8AgPreY2WuhMgy3puuZ3a0KbMBAd1x+bIe1dWVMlZF7kKpVCMgoLts7885KNx9Dor6azCWHABU3nJX4hycg8Jt+WmMAAAhvGSuxPGahAF9/NRQKWzft0aDaQCbystoVy2NwpQbW2q5uQbOQdGs+XfR/bLLOSjcF+egcD0t1/0br18OJ7V+SR3noHBfHjsHReP1zKo893Jb6licg4Isp+niuc0Jcmue2JhoplR42dWcAOxvTLRsx446HFWD5/Hc7BKRDdpoTBC5LDYmyI1xDgo3p92RBF3eCrnLILpF75Bi9A6xb54GV5XTVIwdtSft2saOw9HYcdj+Swh21J60uRZH1eBpNAEF0AQUyF0GEbkIzS+boPllk9xlEFlMk70JmmxmltxTpx9BIUnuPZutRhwHfJtQo/GMYb23apK7AKfq4hcIAFCqJKgaPevb7ODIKgDA5SsBMlfieEUNVVArJYzR2b5vR879CQAw5onv7arliKHStB0barm5BqVSgmgyQurqqceT67xuv3/ePX8FADTW+3ZENQ4lPGREnaT0gqS66RIPN/+8bpeP515a5c5/a0mSAt6X9wEAGoP/q/UnaTzj964zcqdsWlOr91fXMzuujcwSWakjf1c6/RwURERERERERCQ/XuJBRERERERERLJjg4KIiIiIiIiIZMcGBRERERERERHJjg0KIiIiIiIiIpIdGxREREREREREJDs2KIiIiIiIiIhIdmxQEBEREREREZHs2KAgIiIiIiIiItmxQUFEREREREREslPKXYC98vPzMXPmTERERAAAampqEBwcjGXLlkGtVt/y/PLycsyZMwcKhQKRkZFYsGABJOmPPk1dXR1mz56NiooKdO3aFUuXLkVgYCD279+PVatWQalUIjY2FmPGjOmwfSTXZW3+mi1evBj9+vVDXFwcAGDr1q3Izs6GUqnE9OnT8eijj5o9/8SJE8jIyICXlxdiYmKQlJQEo9GIhQsX4syZM1Cr1UhPT0dYWJjzdpZclrU5PH36NNLS0uDl5QW1Wo2lS5eiW7duzCHZzdoslpaWIjU1FUIIhIeHIz09HUqlklkku9j62bxr1y5s3LgRW7ZsAcDPZrKftVk8deoUpk2bhvDwcABAXFwcnnnmGWRlZeGrr76CUqnE3LlzERUVZfa61s5T2jqnoc7H2hxWVFQgJSUFVVVVMBgMePvttxEaGtpxx0Th5vLy8sTMmTPNls2aNUvs3r271edPmzZN5OXlCSGESE1NFTk5OWbrP/zwQ7FixQohhBCfffaZSEtLEw0NDeLxxx8XlZWVor6+XowaNUro9Xon7A25G2vzV1FRIRISEsRjjz0mPv74YyGEEJcuXRLPPvusqK+vF1VVVS3/faPnnntOlJeXC6PRKKZMmSKKi4vFnj17RHJyshBCiG+//VYkJiY6YQ/JHVibw/Hjx4tTp04JIYTYvHmzWLx4MXNIDmFtFqdPny6OHDkihBAiOTlZ5OTkMItkN2tzKIQQxcXFYsKECWL06NFCCH42k2NYm8WtW7eKdevWmS0rKioS8fHxwmg0ivPnz4tRo0aZrW/rPKW1cxrqnKzNYXJysvj888+FEEIcPnxYfPnllx16THT7ERQ3a2howKVLl+Dn54fJkydDkiTo9Xq88MILGD9+PIqLi/Hggw8CAP785z/j0KFDGD58eMvrjx07hilTprSsf//991FWVobQ0FD4+fkBAKKjo1FQUICnn36643eQXFp7+aupqcErr7yC3NzcltcUFhZi4MCBUKvVUKvVCA0NRUlJSUt3vLq6Gg0NDQgNDQUAxMTE4JtvvoFer8fQoUMBAA888ACKioo6fofJJbWXw8zMTPTo0QMAYDAYoNFomENyivayuHLlSnh5eaGhoQF6vR5arZZZJIdrL4eXL19GZmYm5s6di9TUVAD8bCbnaC+LRUVF+OGHH7Bv3z6EhYVh7ty5OHbsGGJiYqBQKNCnTx8YDAb8/vvvLaMh2jpPae2chghoP4fHjx9H//79MWnSJPTt2xfz5s3D4cOHO+yY6BENiry8PMTHx6OiogKSJGHMmDGQJAkXL17Ezp07YTQaMWLECDz11FMQQkChUAAAunbtiqtXr5ptq7q6Gjqdzmz9jcual1dXV3fcDpJLsyZ/ISEhCAkJMWtQtJev6upqaLVas/U//fTTLcu9vLzQ1NQEpdIjfq3JStbksLk5cfz4cWzcuBGbNm3CgQMHmENyCGuyGBQUhPPnz2Py5MnQarW4++67kZubyyyS3SzN4ZNPPon58+fjzTffhEajaXk9P5vJUaw5JkZFRWH06NG47777sHr1aqxatQo6nQ7+/v4t22s+P2luULSV1dbOaajzsiaH58+fh6+vL9avX4+srCysXbsW4eHhHXZM9IhJMh966CFs2LABmzZtgkqlQnBwMAC0dHm8vb0RGRmJc+fOmc03UVNTA19fX7NtabVa1NTUmK2/cVnz8hv/B1HnZk3+WtNevlpb31oujUYj/wDqxKzN4RdffIEFCxZgzZo1CAwMZA7JYazNYt++fZGTk4O4uDgsWbKEWSSHsDSH33//PcrLy7Fw4ULMmjULpaWlyMjIYA7JYaw5Jg4fPhz33XcfAGD48OE4deqUTVnU6XStntNQ52VNDv39/TFs2DAAwLBhw1BUVNShx0SPaFA0CwgIwDvvvIOUlBTo9XqcPn0aBoMBtbW1KC0tRVhYGO655x7k5+cDAHJzczF48GCzbQwaNAhff/11y/ro6GjceeedKC8vR2VlJRoaGnD06FEMHDiww/ePXJsl+WtNVFQUjh07hvr6ely9ehVlZWW46667WtZrtVqoVCqcO3cOQggcPHgQgwcPxqBBg1pGYpw4ccLsNdR5WZLDTz/9FBs3bsSGDRsQEhICgDkkx7Mki4mJifjxxx8BmL5tkSSJWSSHai+HERER+Pzzz7FhwwZkZmYiIiIC8+bNYw7J4Sw5JiYkJKCwsBAAcPjwYdx7770YNGgQDh48CKPRiF9++QVGo9Fsssu2zlNaO6chsiSH0dHRLdkpKChAREREhx4TPa6lGxERgfj4eKSnp6NHjx546aWXUFlZienTpyMwMBDJyclITU1FZmYm7rjjDjz55JMAgPj4eGzYsAFxcXFITk5GXFwcVCoVli9fDpVKhTlz5iAhIQFCCMTGxqJnz54y7ym5ovby15ru3bsjPj4e48aNgxACr732GjQaDXJzc1FSUoKpU6firbfewuuvvw6DwYCYmBgMGDAA999/Pw4dOoSxY8dCCIHFixd38N6Sq7pdDv38/JCRkYHevXvjlVdeAQAMGTIEr776KnNIDtfeMXHq1KmYM2cOVCoVfHx8kJ6ezmMiORw/m8lVtJfFhQsXIi0tDSqVCt26dUNaWhq0Wi0GDx6MF154AUajEfPnzwcAfPLJJwCAUaNGtXqe0to5DRFg2flySkoKsrOzodVqsXz5cvj5+XXYMVEhhBAd8HPocPn5+cjOzsa7775r0fMzMjIwb948J1dFnYW1+WtNRUUFtm3bhsTERAdWRp0Jc0iuglkkV8AckqtwRBZLSkpQVFSE559/3oGVUWfiqsdEj7rEwx4vvvii3CUQmRFCMJckO+aQXAWzSK6AOSRX4e/vj9jYWLnLoE7OGcdEjx1BQURERERERETugyMoiIiIiIiIiEh2bFAQERERERERkezYoCAiIiIiIiIi2bFBQURERERERESyY4OCiIiI7FZfX49t27a1ub6goAAlJSVtrv/kk0+wbNmyNtevXLkSmzdvvmV5UlISACA+Ph5lZWVtPo+IiIhcHxsUREREZDe9Xn/bBsX27dtx6dIlh79vVlaWw7dJRERE8lDKXQARERG5vw8++AClpaXIysrCyZMnUV1dDYPBgBkzZkCn0+HAgQMoLi5GREQE9u/fj5ycHNTW1iIgIMDiJsPevXuxe/du1NXVISUlBVFRUXjkkUdw6NAhJ+8dERERdQQ2KIiIiMhuiYmJOHv2LGpqavDwww9j4sSJuHjxIuLi4rBv3z4MHToUzzzzDHr16oXKykqsX78ekiQhISEBJ0+etOg9+vbti0WLFuG7777DG2+8gR07djh5r4iIiKgjsUFBREREDlNWVoYRI0YAAHr27AmtVouKioqW9ZIkQaVSYdasWejSpQsuXLiApqYmi7Y9ZMgQAEBkZCT0er3jiyciIiJZcQ4KIiIispskSTAajbjzzjtx9OhRAMDFixdRVVUFf39/KBQKCCFQUlKCvXv34r333kNqaiqMRiOEEBa9R2FhIQDgzJkz6NOnj9P2hYiIiOTBERRERERkt6CgIDQ2NuLq1asoLy/Hnj17UFdXh0WLFkGpVGLAgAFYtmwZMjMz4ePjg7FjxwIAunfvbvHkmT///DMmTJiAhoYGLFq0yJm7Q0RERDJQCEu/tiAiIiIiIiIichKOoCAiIiKXkZSUhCtXrpgt02q1WL16tUwVERERUUfhCAoiIiIiIiIikh0nySQiIiIiIiIi2bFBQURERERERESyY4OCiIiIiIiIiGTHBgURERERERERyY4NCiIiIiIiIiKS3f8Dow8+7ecsqgEAAAAASUVORK5CYII=\n", + "image/png": "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", "text/plain": [ "
" ] @@ -5719,7 +5853,13 @@ } ], "source": [ - "ax = grplot(plot='histplot+boxplot', \n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", + "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", + "\n", + "\n", + "tips = sns.load_dataset('tips')\n", + "ax = plot2d(plot='histplot+boxplot', \n", " df=tips, \n", " x='total_bill', \n", " y='sex', \n", @@ -6185,13 +6325,13 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 25, "id": "3a10cde5", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -6201,13 +6341,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='violinplot', \n", + "ax = plot2d(plot='violinplot', \n", " df=tips, \n", " x='total_bill',\n", " y='day',\n", @@ -6657,13 +6797,13 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 26, "id": "3abf2657", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -6673,13 +6813,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='boxenplot', \n", + "ax = plot2d(plot='boxenplot', \n", " df=tips, \n", " x='total_bill',\n", " y='day',\n", @@ -7149,13 +7289,13 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 27, "id": "18775e3d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -7165,13 +7305,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='pointplot', \n", + "ax = plot2d(plot='pointplot', \n", " df=tips, \n", " x='time',\n", " y='total_bill',\n", @@ -7184,7 +7324,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 28, "id": "5dbb753f", "metadata": { "scrolled": true @@ -7192,7 +7332,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -7202,15 +7342,15 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "import pandas as pd\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "iris = sns.load_dataset('iris')\n", "iris = pd.melt(iris, 'species', var_name='measurement')\n", - "ax = grplot(plot='stripplot+pointplot',\n", + "ax = plot2d(plot='stripplot+pointplot',\n", " df=iris,\n", " x='value', \n", " y='measurement',\n", @@ -7699,13 +7839,13 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 29, "id": "81c333e6", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -7715,13 +7855,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='barplot', \n", + "ax = plot2d(plot='barplot', \n", " df=tips, \n", " x='day',\n", " y='total_bill',\n", @@ -7734,13 +7874,13 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 30, "id": "71274ffb", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdsAAAFDCAYAAAByT6QaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAA7K0lEQVR4nO3deWBU9b3//+eZLTNJJhtJCIEAYd9EDKhUcSkqWi8ooqig4E9R1P5QS7+94m3rrQvi2tqrKNZqbxUUF/Sr1ipQxYqKgIJL2ElYAyQZAmTPrOf7R2owJew5mUnyevzlzNnen0+HvvI5c+bzMUzTNBERERHL2KJdgIiISFunsBUREbGYwlZERMRiClsRERGLKWxFREQsprAVERGxmMJW5ASsWLGCn/zkJ0yaNInrr7+eq6++mnXr1p30eadPn86KFSuaocJj9/rrrxMMBg+7fffu3SxZsuSw24uKirj66qsPu33FihVMnz79kPcfeughdu/ezdNPP838+fMPu59IW6CwFTlBw4cPZ+7cucybN48777yT//mf/4l2SSfkT3/6E5FI5LDbly9fzurVq5v9ur/5zW/Izs5u9vOKxCJHtAsQaQsqKipIS0sDYOXKlcyePRvTNKmurub3v/89TqeT22+/nZSUFM4991xuueWWhmNfeeUV3nzzTTIyMigrKwOgqqqK3/zmN1RWVlJaWsrEiRMZM2YMV1xxBYsWLcJut/P4448zcOBALr30UgA+/vhjPvroIx5++GEArrjiCl544QWeeOIJtm/fTl1dHZMnT2bs2LEN137zzTfx+XxMnz6dZ599lkceeYRVq1YBMHr0aK6//nqef/556urqOO200/B6vU227Wi2b9/OlClT2L9/PxMmTGD8+PFMmjSJ++67rzm6XyTmKWxFTtDy5cuZNGkSgUCADRs28MwzzwCwefNmHn/8cTp27Mhzzz3HwoULGTNmDD6fj7feeguXy9Vwjr179/Lyyy/zt7/9DcMwGDduHFAfTv/xH//BqFGjKCkpYdKkSUycOJGhQ4fy+eefM2LECJYuXcpdd93VcK7zzz+fxx9/nJqaGgoKCsjJySEuLo6vvvqKN954A4AvvviiURvGjx/PnDlzePLJJ/nkk08oKirijTfeIBQKMXHiRIYPH87UqVPZsmULF1xwAa+88kqTbTuaYDDInDlziEQiXH755VxwwQUn3f8irYnCVuQEDR8+nCeffBKALVu2cO2117J06VI6duzIQw89RHx8PCUlJeTl5QHQpUuXRkELsGPHDnr16tXw/uDBgwFIT0/npZdeYvHixSQmJhIKhYD6cJw7dy6RSISzzjqr0fnsdjsXX3wxixcv5ttvv2X8+PEkJiby61//mnvvvZeqqiouu+yyw7ansLCQYcOGYRgGTqeTU089lcLCwkb7HK5tRzNkyJCGWnv27ElRUdExHSfSVug7W5FmkJ6e3vDf9957L7NmzeKRRx4hMzOTH6Yft9kO/efWvXt3CgoKqKurIxwOs379egD+8pe/MGTIEJ544gkuueSShnMMGzaMnTt3smDBAq666qpDznfVVVfx3nvv8f3333P22WdTWlrK2rVreeaZZ3j++ed5/PHHG4L7B4ZhEIlE6NmzZ8Mt5GAwyDfffEO3bt2w2WwN3+kerm1Hs27dOkKhEDU1NRQWFtK1a9djOk6krdDIVuQE/XAb2WazUV1dzT333IPb7eayyy7juuuuw+PxkJ6eTmlp6WHPkZaWxi233MK1115LWloaHo8HgJ/+9KfMnDmTDz74AK/Xi91uJxAI4HK5GDNmDAsXLqR3796HnC8nJweAkSNHYrPZyMjIwOfzce2112Kz2bjppptwOBr/sx82bBhTp07l5ZdfZuXKlVxzzTUEg0EuueQSBg4ciGEYzJkzh4EDBx5X234sLi6OW265hYqKCu644w5SUlKOsZdF2gZDq/6ItC4vvPACKSkpTY5sRSQ2aWQr0orcc889lJaW8txzz0W7lEPMnj27yd8Iz5o1q2HELdJeaWQrIiJiMT0gJSIiYjGFrYiIiMUUtiIiIhZT2IqIiFisTT2NvH9/NZGInvfq0CGRsrKqaJcRdeqHg9QXB6kv6qkf6tlsBqmpCZZfp02FbSRiKmz/Rf1QT/1wkPriIPVFPfVDy9FtZBEREYspbEVERCzWpm4ji4hIvXA4xP79PkKhQJPbS0sPLjDRXjgcLlJTM7DbWz76NIOUiLQKdf4glRV1J32ejAwvPl9lM1QU2/bu3YPbHU9CQhKGYRyy3eGwEQq1n7A1TZPq6grq6mpIT+/U8L7NZtChQ6Ll129TI9s7H36Hvfuro12GiFjg1ceuo5KTD9v2IhQKkJCQ1WTQtkeGYZCQkERV1YGoXF/f2YqItFEK2sai2R9tamQrIiJN8ya5ccc5m+18x3Jbf/Xqr7nzztu4776HuPDCixvev+GGa+nTpx+/+c19hxzzwQd/Y/v2bdx++x3NVmssUNiKiLQD7jgnE+9+pdnOd6y39bt1687HHy9uCNvCwgJqa2ubrY7WQmErIiKW6dWrNzt2bKeqqorExEQWLfqAUaN+RklJMW+99TqffvoJtbW1pKSkMGvWE42OXbDgNf7xj0UYhsEFF4xi/Phro9SKk6fvbEVExFLnnTeSTz9dgmmarF+/lkGDBhOJRCgvL+ePf3yWP//5JcLhMOvXr204ZuvWLXz88T949tkXeOaZP/PZZ/9kx45t0WrCSdPIVkRELHXRRZfw+98/QnZ2Z0499TQAbDYbTqeT++77DR6Ph9LSUkKhUMMxW7YUUlJSzF133Q5AZWUlO3fupGvX7tFowklT2IqIiKU6d+5CbW0tCxa8xq23TmP37l1UV1ezdOk/+fOfX6Kuro4pU65vdEzXrt3o3r0Hv//9UxiGweuvv0LPnr2j1IKTp7AVERHLXXDBRSxa9AFdu3Zj9+5d2O12PB4Pt99+EwAdOqSzd6+vYf/evfswbNjp/PznUwgEgvTvP5CMjIxolX/S2tQMUprUonWo3LuNLV8twO3NAAMiwQCuhBRyh47DZrMf9rid+YtwJ3YgI3cYACUFX7KvaA0YBlm9R5Ca3a/R/lu+fotgXf0SYoGaAySkdaHHsCsBqKvaR+HKNxg48jaLWinN7dXHrmuWmZ/aywxSxcXbycrq1vA6Gj/9iUX/3i+aQUraNG9GbkPwAWz5+m3KizeSmj3gkH2D/mq2rX6Huqp9ZPX6CQChYB0lW1Yw6MI7iIQCrP/n84eE7Q/nDwVq2fTFy+QMGgVA2c7vKS1cQSigP8yk/aisqGv0U532Nl1jtClsJeoikTBBfyV2p5tNy+ZiYBD0V5PeLY/MHqcTCQXI7nse5aUFDcfY7U7iPMlEQgEi4SAcYWaY3Rs+JbPHGTjd3vpjnW76jLiBNR89bXnbRERAYStRUunbysbPXyLkrwbDIKNbHoZhI1hbSf/zpwIm6z55jtTOA4hLSCUuIbVR2AI4PcmsXTIHzAhZfUY0eZ2gv5rKvVvJOWVUw3spWX2sbFqb4S/fSdXu1ZjhYLRLAWDy5EWEwyf/rZfdbjTLeX7M43EzfvxE8vKGNet5pe1Q2EpU/HAbORSoYdOyebgSUgBISMvB9q/lr9zeTPzV+3DGJRxyfHlJAUF/JadcdCcAm7+cR2JaDgmpnRvtt3/3OtI6D8Iw9JPy41VdnE+opizaZTTYtasi2iUc0fvvv6OwlcNS2EpUOVzx5OZdwaZlL5Mz6GJqy4sxzQhmOExdpQ93Qocmj7O73NhsTgybHcMwsDvdhIOHPqxR6dtKpz7nWN2MNikh6xSqdgdjZmSble6N6ZHt6NFjm/Wc0rYobCXqPEkZZOaewc78hTjdXjZ/+SrhQC2d+pyDIy6+yWO8HbpRmbqVDUtfxDAMEjt0xZvRg5ryYsp2fEfOKfXzsNZVleFKSG3J5rQZcck5xCXnRLuMBi/raWRpxRS20uK86d3xpndv9F6nvueQ2CEH37ZVjZ5S/rHsfucf8vrf34tLSMNmP/jzhoEjbz9sHade8n+Oq26R1iw12YXDFdds5wsF/OwvDxxxnz17dnPDDRPo06dvw3tDh57OjTfe0mx1TJs2lf/8z1/TrVv3ZjunFRS20raYEbJ6nx3tKkRijsMVx6rHbm628w29+wXgyGEL0L17LrNnP99s122tFLYSM5oa8R4vu9PdPMWIiGWee2423333DZFIhGuuuY6RIy9k2rSp9OrVh61bC/F4PAwefBorV35JVVUVf/jDbOx2G488MpOqqkr27vUxbtzVXHHFVQ3nrKqq4pFHHqC8vByAX/ziP+nZs1e0mngIha2IiFhm27atTJs2teH1ZZddwZ49u5gz50X8fj+33nojp59+JgADBgzkF7/4Fb/85R243W7++MdnmTnzd3z77Wo6dsziwgtHcd55I9m718e0aVMbhe3LL/+FoUPP4IorrmLnzh3MmnU/c+a82OLtPRyFrYiIWObfbyO/8spLbNy4oSGAQ6EQxcW7AejTp34WOK83ke7dc//130kEAn7S0tJ4441X+fTTT4iPT2i0QhDAli0FrF79NR9/vBiAysrY+qmYwlZERFpMt27dOe20YcyY8RsikQh//esLdO7cBQDjCDPBvfbaPAYNGswVV1zF6tVf8+WXnx9y3lGjBjBq1CXs37+Pv/3tHSubcdwUtiIi0mLOPvtcvvlmFT//+c3U1tZw7rk/JT7+0IlrmjruyScf4+OPF5OYmIjdbicQOPiA1uTJN/HIIw/y3ntvU1NTzU03TT3C2Vpes6/688gjj7B27Vp8Ph91dXXk5OSwefNmfvKTn/Dkk08256UOoVV/RNourfpzfP59dZto/PQnFrWZVX/uueceAN5++222bNnCr371K1asWMFrr73W3JcSEZFjVB+MB8NRq/60rBabMHb79u3cfPPNjBs3jqefrl9tZdKkSRQWFgIwf/58nn76aYqKihgzZgyTJk3iz3/+c0uVJyIiYpkW+87W7/fz7LPPEg6HOf/887njjjsOu6/P5+Ott97C5XId1zWe+q+xJ1mliByvSCiIzdF8i5IfTp0/NuZoFjkRLRa2vXv3bghPh+PQy/74q+MuXbocd9AC5D83g0BF7KxSItIeDL37hXbxHWhrZJrmEZ/wbW+a+RGl49Jit5Gb+h/c5XLh8/kAWLdu3cGibFoOTUTkZDgcLqqrK6IaMLHENE2qqytwOI5/INccovrTn8mTJ3P//feTnZ1NZmZmNEsREWlTUlMz2L/fR1XVgSa322w2IpH29YCUw+EiNTUjKtdu9p/+RJNuI4u0vNZ2G7m9/PTnaNQP9Vrqpz+6XysiImIxha2IiIjFFLYiIiIWU9iKiIhYTAsRyAlbt+cATy3ZQOeUeAwDagJhMr1upp3fF4f98H/HzV1eSKfkeC7s3wmAb3fu4+1vdmACuR0SufGsno1+KvbUkvWU19ZPaOCrqqNXhpc7R/bnlZVb2FhcQcQ0Gdk3i5H9OlnaXhGRE6WwlZMyoFMyd47s3/B69icbWLWjjDNzD328vqI2wJylm9hTXsvoU+IBqA2EeHXlVn77H4NJcjv52/c7qawLkuQ5+Fu4H85f5Q/y0Af5TBrek7W7D1BSUccDlw0hGI5w91urOCM3ncQ462cyEhE5XgpbaTahcIQDtQES4hzM+jAfw4Dy2iAj+2YxakA2daEIV57WlW+L9jccs6m0kpy0BF5ZsYXSyjp+2jerUdD+2FurdzBqQDap8S4SXA66dahflssAIqaJQ5OhiEiMUtjKSVm3p5wH//49FXUBDAxG9svCZhjsr/Eza2wepmky4+3VnJmbTqbXTabX3ShsK+uCrNtzgIfH5uF22rn//e/onemlU3J8o+uU1wZYs/sAk87sAYDLYcPlsBGKRJizdBMj+3XC7bS3aNtjxXpfDYsL9uOP0goucWsmEw7H3s/1PR4348dPJC9vWLRLEVHYysn54TZyZV2Qhxfmk+F1A9A7Mwnnv7637ZKaQElFHclNjFi9bgc90r2kxNdv65eVzPay6kPCduXWvZzdMwOb7eB3uVX+IP/z8Xr6d0rh8lNzrGpizPt0azm7KqK4rmjNruhd+yjef/8dha3EBIWtNAuv28nPz+vLzA/ymTy8B9v3VROJmAQjEYoOVJOV7GnyuO4dEinaX01FXZAEl4MCXyUj+2Ydst+a3QcYO6Rrw+tAKMysD/O5dFAXRvRq31N9npebjD8cid7INrVjzI5sR48eG+0yRACFrTSjLqkJXDIwm5eWF5IaH8eji9ZQ6Q9xxZCuJLmbfnAp2ePimmHdeWThGgCG56aTk5bAtrIqlm4uYfLwngDsLq8l81+jZoCPNhRTWlnHJxuL+WRjMQC3ntun0T7tRf+MePpnxB99R4u0tukaRaJBcyNLs1u35wAfrd/T6Cnl41UXDPPudzu5Zlj35itMLNHawlZzAtdTP9TT3MjSrkVMkzGDu0S7DBGRZqHbyNLsBnRKYUCnlJM6R7xLH00RaTs0shUREbGYwlZERMRiClsRERGLKWxFREQsprAVERGxmMJWRETEYgpbERERi7WpHzOectuj0S5BpN0JBfzRLkEk5rWpsC0rqyISaTOzT54wTcNWT/1wkPpCJLp0G1lERMRiClsRERGLKWxFREQsprAVERGxmMJWRETEYgpbERERiylsRURELKawFRERsZjCVkRExGIKWxEREYspbEVERCymsBUREbFYm1qIoEOHxGiXEDMyMrzRLiEmqB8Oau99UecPUllRF+0ypJ1qU2F758PvsHd/dbTLEJEY9Opj11GJwlaiQ7eRRURELKawFRERsZjCVkRExGIKWxEREYspbEVERCymsBUREbGYwlZERMRibep3ttL6Ve7dxpavFuD2ZoABkWAAV0IKuUPHYbPZD3vczvxFuBM7kJE7DIDizV+wr2gNdmccHXudRUpWn0b7V5RuYde6jzFsNrwZuXTuPxKAvTu+xbf1azBNUjr1pVPfc61rrIi0GwpbiTnejFx6DLuy4fWWr9+mvHgjqdkDDtk36K9m2+p3qKvaR1avnwBQW1HCvqI19Dt3CgAbPvsLSem52BzOhuOK1n1Ebt4VuL3pbPz8r9RWlGCzO/Ft/Zq+I27AsDnYveGfmJEwxhFCXkTkWChsJaZFImGC/krsTjebls3FwCDorya9Wx6ZPU4nEgqQ3fc8yksLGo6prdyLN70bNnv9x9udkEZNRQmJaV0a9olPziIcrMU0I5jhEGCjwreVhJRstq1+l2BdJVl9zlHQikizUNhKzKn0bWXj5y8R8leDYZDRLQ/DsBGsraT/+VMBk3WfPEdq5wHEJaQSl5DaKGw9SZkUb/6CcNCPaYap2ldEevdAo2t4kjIpWD4fuyue+KRM3N50DuzZQGXZDvqdcyORSIiNn/0vCWk343C6W7gHjo+/fCdVu1djhoPRLiWmTZ68iHDYxG43CIfNaJcTdVb0g8fjZvz4ieTlDWvW87YFCluJOT/cRg4Fati0bB6uhBQAEtJyDo5WvZn4q/fhjEs45HiPN4PM3NPZvPwVXJ5kElI743DFN2wPBeso3vQ5A0bejsuTRNHaf1BS8CUOlwdvejfszjjsxOH2puOvKsOR2rlF2n2iqovzCdWURbuMmLdrV0W0S2gX3n//HYVtExS2ErMcrnhy865g07KXyRl0MbXlxf+67RumrtKHO6FDk8cF/dWEQ376nXMT4WAdm5bNw5OU2bDdZnNgc7iwO1wAON1eQv5qkjv2pHTr10TCIUwzQl3lXuIS0lqkrScjIesUqnYHNbI9iqx0r0a2P2LVyHb06LHNes62QmErMc2TlEFm7hnszF+I0+1l85evEg7U0qnPOTji4ps8xuGKp65yL+s/fQHDZqPLwIswDBvlJQXUlheT1WcEXQaOYtOyedjsDuxON91PuxyHy0N6tyFs/Ox/MTHrr+HytHCLj19ccg5xyTnRLiPmvfzYdfh8lWRkePH5KqNdTtSpH1qWwlZiije9O9707o3e69T3HBI75ODbtqrRU8o/lt3v/Ib/NgyDbkNGH7JPfEonasr3AJCa3Y/U7H6H7NOx53A69hx+4g0QEWmCJrWQ9sM06djrrGhXISLtkEa20io0NeI9Xk53YvMUIyJynDSyFRERsZjCVkRExGIKWxEREYspbEVERCwWtQekioqKuOyyyxg4cGDDe2eeeSbTpk1reD19+nQeffRRXC5XNEoUERFpFlF9GrlXr17MnTv3sNuffPLJFqxGRETEGjF1G3nFihWMHz+eiRMn8s477zBy5Ej8fn+0yxIRETkpUR3ZFhQUMGnSpIbX48ePx+/38+abbwLw1FNPHdf5nvqvsc1ZnkhMi4SCjdbolSOr82vuaImemLqNvGLFCnJzc0/4fPnPzSBQodVPpH0YevcLxzy3rebBFYmumLqNDGCzxVxJIiIiJ0XJJiIiYrGo3Ubu0qULb7zxRqP3zjzzTM4888yG10uWLGnpskRERJqdRrYiIiIWU9iKiIhYTGErIiJiMYWtiIiIxbR4fDu1bs8Bnlqygc4p8RgG1ATCZHrdTDu/Lw774f8Gm7u8kE7J8VzYv1PDexHT5PHFaxnatUOj94903EtfFrKxpAKP0w7A/7loAPEufRxFpG3S/7u1YwM6JXPnyP4Nr2d/soFVO8o4MzfjkH0ragPMWbqJPeW1jD4lvtG2N1Ztp9ofavIahztua1kV91wyiCS3ZkASkbZPYSsAhMIRDtQGSIhzMOvDfAwDymuDjOybxagB2dSFIlx5Wle+Ldrf6LgVW33YgMFdUps8b1PHRUyT4vJaXvx8M+W1Qc7v25Hz+2RZ2TwRkahS2LZj6/aU8+Dfv6eiLoCBwch+WdgMg/01fmaNzcM0TWa8vZozc9PJ9LrJ9LobhebOfdUsK/Rx1wX9efubHU1eo6nj/MEwFw/I5tJTOhOJmMz8MJ8e6V66piVY3uZjsd5Xw+KC/fhDkWiXckRxayYTDpvHtK/dbhzzvs3F43EzfvxE8vKGteh1RWKRwrYd++E2cmVdkIcX5pPhdQPQOzMJ57++t+2SmkBJRR3JnkPXFP6soJR9NQEe+iAfX1UdDpuNDG8cp3ZJO+J14xx2LhmYTZyj/vvagZ1S2F5WFTNh++nWcnZVBKJdxtHV7Ip2BUf1/vvvKGxFUNgK4HU7+fl5fZn5QT6Th/dg+75qIhGTYCRC0YFqspI9TR438YyDi0YsWL2dFI/rqEELsKeilqeWrOfhsXlEMNlYUs65vTObrT0n67zcZPzhSOyPbFM7xvzIdvTosS16TZFYpbAVoH4Ee8nAbF5aXkhqfByPLlpDpT/EFUO6HvdDTNvKqli6uYTJw3s2ub1zSjwjenXkv//2LXabwTm9OtIlNTZGtQD9M+LpnxF/9B2jTKv+iLQeCtt2akCnFAZ0Smn03tghXenTMYmP1u9p9JTyj12V1+2o72cleRpuER/uuDGDuzBmcJcTqFxEpPXRpBbS7CKmqSAVEfkRjWylkaZGvMdLk1OIiDSmka2IiIjFFLYiIiIWU9iKiIhYTGErIiJiMYWtiIiIxRS2IiIiFlPYioiIWKxN/SDylNsejXYJIi0mFPBHuwQROUbHFLaBQACX69BVX2JNWVkVkUjLTrYeizQPbj31g4jEimO6jXzllVfy0EMPsWnTJqvrERERaXOOaWT77rvv8tlnnzF79mz279/PZZddxqWXXkpCQuys1CIiIhKrjmlka7PZOPfcc7nyyitJSUlh7ty5TJkyhXnz5lldn4iISKt3TCPbxx57jI8//pgzzjiDW265hcGDBxOJRBg3bhzXX3+91TWKiIi0ascUtt27d+ftt99udNvYZrMxe/ZsywoTERFpK44pbM844wzmzZtHMBgEoLS0lAceeIAuXbRmqYiIyNEc03e2v/rVrwBYvXo1RUVFHDhwwMqaRERE2pRjCtv4+HhuvfVWOnbsyCOPPMLevXutrktERKTNOKawNQwDn89HdXU1NTU11NTUWF2XiIhIm3FMYTtt2jQ++ugjLr/8ci666CJ+8pOfWF2XiIhIm3HEB6RGjhyJYRgAmKaJ0+kkLi6Of/7zn8yYMaNFChQREWntjhi2CxcuxDRN7r//fq699loGDx7MunXrmD9/fkvVJyIi0uodMWx/WHxg586dDB48GIABAwawZcsW6ys7AR06JEa7hJiRkeGNdgkxQf1wkPrioGPpizp/kMqKuhaoRtqDY/qdrdfr5Y9//CODBw/mm2++ISMjw+q6TsidD7/D3v3V0S5DRNqAVx+7jkoUttI8jukBqSeeeIKkpCT++c9/kp6ezmOPPWZ1XSIiIm3GMY1s4+Pjuemmm6yuRUREpE06ppGtiIiInDiFrYiIiMUUtiIiIhZT2IqIiFhMYSsiImKxY3oaWSQWVO7dxpavFuD2ZoABkWAAV0IKuUPHYbPZD9m/pryYnd9/CIYNm81O97yxON2J+LatZu+2VRg2G1l9ziElq0+j4ypKt7Br3ccYNhvejFw69x8JwO4Nn1JeshnDsJFzysUkpHZukXaLSOunsJVWxZuRS49hVza83vL125QXbyQ1e8Ah++7MX0jO4J8Rn5yFb9sqigu+IKvX2ZRuWUn/827GjITY8NlfScrogc1+8J9C0bqPyM27Arc3nY2f/5XaihLMSISqsu30O3cKwdoKCr96k/7n3dwibRaR1k9hK61WJBIm6K/E7nSzadlcDAyC/mrSu+WR2eN0egy7Eqe7flo+MxLBZnNQvX8XiR1y6sPV7sCdkEptRUmjUWp8chbhYC2mGcEMhwAbVWXbSMrogWEYuOKTMc0IQX81zriEKLVeRFoTha20KpW+rWz8/CVC/mowDDK65WEYNoK1lfQ/fypgsu6T50jtPKAhaKv27cS39Sv6jLiBitJC7I64hvPZHHGEg/5G1/AkZVKwfD52VzzxSZm4vekc2LMehyu+YR+7w0U46FfYNjN/+U6qdq/GDAejXQqTJy8iHDajXQYej5vx4yeSlzcs2qXISVDYSqvyw23kUKCGTcvm4UpIASAhLafhVrDbm4m/eh/OuAT27VpL8abP6DV8As64BOyOOCKhQMP5IiE/dqe74XUoWEfxps8ZMPJ2XJ4kitb+g5KCL7E74giHDoZyOBTA8aPjpHlUF+cTqimLdhkA7NpVEe0SGrz//jsK21ZOYSutksMVT27eFWxa9jI5gy6mtrz4X7d9w9RV+nAndKBs5/fs3baKPmffgMPlASAhtTO71n9CJBzCjISordqLJymz4bw2mwObw4XdUb/ildPtJeSvxpvdn11rP6Jjr7MI1laAaeKIi2+yNjlxCVmnULU7GBMj26x0b8yMbEePHhvtMuQkKWyl1fIkZZCZewY78xfidHvZ/OWrhAO1dOpzDnaXm535C3F5kilc+QYA3vRuZPc7n8weZ7Dx87+CadK5/0hsdgflJQXUlheT1WcEXQaOYtOyedjsDuxON91PuxyHy0Nih65sWPoiAF0H/yyKLW+74pJziEvOiXYZALz82HX4fJXRLkPaCMM0zej/6dZMtMRe+1S5dxu+basaPaV8vIL+avZuX02nPuc0Y2XSmr3axsM2I8Pbptt3rGw2o0XWQtekFiIApknHXmdFuwoRaaN0G1laPW96d7zp3U/qHE639X/Zikj7pZGtiIiIxRS2IiIiFlPYioiIWExhKyIiYrEWfUDq+eefZ9myZYRCIQzDYMaMGQwaNKjJfV9//XXGjRuH0+lsyRJFRESaXYuFbUFBAUuWLGH+/PkYhsH69euZMWMG7733XpP7/+lPf2Ls2LEtVZ6IiIhlWuw2stfrZffu3SxYsICSkhL69+/PggULWLlyJZMnT2bSpEmMGzeOrVu38uabb+Lz+Zg+fXpLlSciImKZFp1Bau3atcybN48vv/wSt9vN9OnT2bt3LxdeeCEdO3bkueeewzRNbr/9dkaOHMmHH35IXFzc0U8sItKESCiIzXFiX0XV+YNUVtQ1c0WxQzNI1WupGaRa7Dby9u3bSUxM5OGHHwYgPz+fW265hRkzZvDQQw8RHx9PSUkJeXl5J3yN/OdmEKiIjRVDRCT6ht79wiGBopCRaGixsN24cSOvv/46c+bMweVykZubS1JSErNmzeKTTz4hMTGRGTNm8MNA2zAMIpFIS5UnIiJimRYL21GjRlFYWMhVV11FfHw8pmly991389VXX3Hdddfh8XhIT0+ntLQUgGHDhjF16lRefvllDMNoqTJFRESaXZta9Ue3kUXkx3Qb+fDUD/W06o+IiEgbobAVERGxmMJWRETEYgpbERERi2nxeIkZ6/Yc4KklG+icEo9hQE0gTKbXzbTz++KwH/7vwrnLC+mUHM+F/TsB8N53O/lyiw+P087owV3I69qh0f7FFbW8+EUB4XAEh93GHT/th9ftZO7yLWwsKcdmGFx3Zi59OyZb2l4RaT8UthJTBnRK5s6R/Rtez/5kA6t2lHFmbsYh+1bUBpizdBN7ymsZfUo8ADv2VbNsi48HxgwB4L73v2VgdgpxDnvDcS98vplrhnWnd2YSK7fuZU95Lfuq/WwureDBy4ZQXFHH059sYNbY06xtrIi0GwpbiVmhcIQDtQES4hzM+jAfw4Dy2iAj+2YxakA2daEIV57WlW+L9jccs/tADf2zknE56kfCWUkeduyrpndmEgCBUJiK2iCrd+zjta+20SM9kQmn51IVCOFy2AiGTWqDIRw2/bZbRJqPwlZiyro95Tz49++pqAtgYDCyXxY2w2B/jZ9ZY/MwTZMZb6/mzNx0Mr1uMr3uRmGbk5bAu9/tpDYQIhQx2VRawchQVsP2Kn+IogM13PCTnlw9tBt//nwzSwtKOL1bOoZh8Ku3vqYmEOaWEb2i0fxWZ72vhsUF+/GHYnO2t7g1kwmHG08lYLcbh7wXazweN+PHTyQvb1i0S5FmorCVmPLDbeTKuiAPL8wnw+sGoHdmEs5/fW/bJTWBkoo6kj2uQ47vnBLPqAHZPLpoLR0S4+iV4cUbd3Ai+sQ4Bx6nnYHZKQCclpNG/q4D1AXDpHic/NfFg6gNhrn//e/olZlEhwQthHEkn24tZ1dFINplHF7NrmhXcMLef/8dhW0borCVmOR1O/n5eX2Z+UE+k4f3YPu+aiIRk2AkQtGBarKSPU0eV1EboC4Y5r4xp1ITCPHwwjXkpCY0bHc57GQle9hQXE6/rGQ2FJfTJTUej9OO22nHZjPwOO047Db8wXBLNbfVOi83GX84Ersj29SOrXZkO3r02GiXIc1IYSsxq0tqApcMzOal5YWkxsfx6KI1VPpDXDGkK0nuppdN87qd7DpQw2/f/QaHzcbE03Ox2Qy+K9rH9rJqLjs1h6kjevO/XxYSiZhkeN1MOD0Xm2GwqbSC3/3tWyImnN0zg+yU+BZucevTPyOe/hmx20+arlFiheZGlpi3bs8BPlq/p9FTyservDbAJxuLGTukazNWJrFOYXt46od6mhtZpJmNPqVLtEsQkXZKt5El5g3olMKATikndY6mHqYSEWkpGtmKiIhYTGErIiJiMYWtiIiIxRS2IiIiFlPYioiIWExhKyIiYjGFrYiIiMUUtiIiIhZrU5NanHLbo9EuQURiSCjgj3YJIkAbC9uysioikTYz1fMJ05yn9dQPB6kvRKJLt5FFREQsprAVERGxmMJWRETEYgpbERERiylsRURELKawFRERsZjCVkRExGIKWxEREYspbEVERCymsBUREbGYwlZERMRihmmamkxYRKQZ1fmDVFbURbuMI9J82fVsNoMOHRItv06bWojgzoffYe/+6miXISLt3KuPXUclsR220rJ0G1lERMRiClsRERGLKWxFREQsprAVERGxmMJWRETEYgpbERERiylsRURELNamfmcr7Vfl3m1s+WoBbm8GGBAJBnAlpJA7dBw2m/2Q/WvKi9n5/Ydg2LDZ7HTPG4vTXf/D9qC/mo2f/S8DfnobNrvjkON2fPd3MGy4EzvQbcgYDMOgePMX7Ctag90ZR8deZ5GS1adF2i0irYPCVtoMb0YuPYZd2fB6y9dvU168kdTsAYfsuzN/ITmDf0Z8cha+basoLviCnEEXU15awK51Swj6q5q8xp4Nn9Kp77kkd+zN1lVvU16yibj4FPYVraHfuVMA2PDZX0hKz8XmcFrTUBFpdRS20iZFImGC/krsTjebls3FwCDorya9Wx6ZPU6nx7Arcbq9AJiRCDZb/T8FA4M+Z13P+n/+ucnzelKyCAVqMU2TcCiAYdiprdyLN71bwyjYnZBGTUUJiWldWqaxIhLzFLbSZlT6trLx85cI+avBMMjolodh2AjWVtL//KmAybpPniO184CGoK3atxPf1q/oM+IGAJIyex7xGu6EDuz4/gP2bPoMuyMOb3p3/DX7Kd78BeGgH9MMU7WviPTuAaubK0fgL99J1e7VmOFgVK4/efIiwuHoTjvv8bgZP34ieXnDolqH1FPYSpvxw23kUKCGTcvm4UpIASAhLefgqNObib96H864BPbtWkvxps/oNXwCzriEY7rGzvyF9B3x/+FJyqR0y1cUrVlM11MvJTP3dDYvfwWXJ5mE1M44XPFWNVOOQXVxPqGasqhdf9euiqhd+8fef/8dhW2MUNhKm+NwxZObdwWblr1MzqCLqS0vxjQjmOEwdZU+3AkdKNv5PXu3raLP2TfgcHmO+dx2lwe7Mw4Ap9tL1b6dBP3VhEN++p1zE+FgHZuWzcOTlGlV8+QYJGSdQtXuYNRGtlnp3pgY2Y4ePTaqNchBCltpkzxJGWTmnsHO/IU43V42f/kq4UAtnfqcg93lZmf+QlyeZApXvgGAN70b2f3Ob/JcNeXFlO34jpxTLqb7kDFs+fotDMOGYbPTbcgYHK546ir3sv7TFzBsNroMvAjD0K/qoikuOYe45JyoXf/lx67T8nXSSJtaz1ZL7Mm/q9y7Dd+2VY2eUj5e4VCA4k2f03nAyGasTNqyV1tB2Go923ottZ6t/vwWORozQlbvs6NdhYi0YrqNLG2aN7073vTuJ3UOu9PdPMWISLulka2IiIjFFLYiIiIWU9iKiIhYTGErIiJiMcsfkHr++edZtmwZoVAIwzCYMWMGgwYNsvqyIiIiMcPSsC0oKGDJkiXMnz8fwzBYv349M2bM4L333rPysiIiIjHF0tvIXq+X3bt3s2DBAkpKSujfvz8LFixg0qRJFBYWAjB//nyefvppioqKuOaaa7jrrrsYN24cv/vd76wsTUREpMVYOrLt2LEjc+bMYd68eTzzzDO43W6mT59+2P23bdvGiy++iMfj4cILL8Tn85GRkXHM13vqv8Y2Q9Ui0hZFQsEWW2O4zh+dOZkldlkattu3bycxMZGHH34YgPz8fG655ZZGAfrj2SK7du1KYmL9tFkZGRn4/f7jul7+czMIVERvpQ8RiV1D734Bn69S0xRKVFh6G3njxo088MADBAL1a3vm5uaSlJRESkoKPp8PgHXr1jXsbxiGleWIiIhEhaUj21GjRlFYWMhVV11FfHw8pmly991343Q6uf/++8nOziYzU0uRiYhI29amVv3RbWQRORzdRm5M/VBPq/6IiIi0EQpbERERiylsRURELKawFRERsZgWj5eYs27PAZ5asoHOKfEYBtQEwmR63Uw7vy8O++H/Ppy7vJBOyfFc2L8TAO99t5Mvt/jwOO2MHtyFvK4dGu2fv2s/r329DbthMCg7hauHdee7on28910RACYmG0sqeGzcUDqnxFvXYBFp8xS2EpMGdErmzpH9G17P/mQDq3aUcWbuoTOKVdQGmLN0E3vKaxl9Sn0o7thXzbItPh4YMwSA+97/loHZKcQ57A3HvbpyK///+X3pnBLP/X//nh37qjm1SxqndkkD4G/fF9GnY7KCVkROmsJWYl4oHOFAbYCEOAezPszHMKC8NsjIvlmMGpBNXSjClad15dui/Q3H7D5QQ/+sZFyO+pFwVpKHHfuq6Z2Z1LBP9w6JVPlDhCMmwXAE24/mVCmr9vN5QQkzLz+txdopIm2XwlZi0ro95Tz49++pqAtgYDCyXxY2w2B/jZ9ZY/MwTZMZb6/mzNx0Mr1uMr3uRmGbk5bAu9/tpDYQIhQx2VRawchQVqNr5KQl8MQ/1pIY56RrWgLZPxrBfpC/i58N6ozzCLet24P1vhoWF+zHH4pEu5STFrdmMuGwid1uEA63rukFPB4348dPJC9vWLRLkROksJWY9MNt5Mq6IA8vzCfD6wagd2ZSQwB2SU2gpKKOZI/rkOM7p8QzakA2jy5aS4fEOHplePHGHZyEvtof4r3vdvLYuKGkJcTx6sqt/D1/F2MGdyFimnyzcx/XDOvWMo2NYZ9uLWdXRSDaZTSPml3RruCkvP/+OwrbVkxhKzHN63by8/P6MvODfCYP78H2fdVEIibBSISiA9VkJXuaPK6iNkBdMMx9Y06lJhDi4YVryElNaNjuctiIc9pxO+u/w02Jd1FRV79SS9H+GrJTPLh+9P1ue3VebjL+cKRtjGxTO7bqke3o0WOjXYacBIWtxLwuqQlcMjCbl5YXkhofx6OL1lDpD3HFkK4kuZteMs3rdrLrQA2/ffcbHDYbE0/PxWYz+K5oH9vLqrns1ByuPyOXhxeuwWk3SHA5uPXcPgDsLq8h818j6fauf0Y8/TPaxgNimq5RoklzI0ursW7PAT5av6fRU8rHq7w2wCcbixk7pGszViatgcK2MfVDPc2NLGKR0ad0iXYJItLO6DaytBoDOqUwoFPKSZ2jqYepRESsppGtiIiIxRS2IiIiFlPYioiIWExhKyIiYjGFrYiIiMUUtiIiIhZT2IqIiFhMYSsiImKxNjWpxSm3PRrtEkQkRoUC/miXIO1YmwrbsrIqIpE2M9XzCdOcp/XUDwepL0SiS7eRRURELKawFRERsZjCVkRExGJt6jtbm82IdgkxQ31RT/1wkPriIPVFPfVDy/VBm1o8XkREJBbpNrKIiIjFFLYiIiIWU9iKiIhYTGErIiJiMYWtiIiIxRS2IiIiFlPYioiIWExhKyIiYjGFrYiIiMViarrGFStW8Itf/IJevXoBUF1dTZcuXXjiiSdwuVyH7L99+3buueceDMOgd+/e/O53v8NmO/j3Q11dHf/5n/9JWVkZCQkJPProo6SlpbFkyRKeeeYZHA4HV155JVdffXWLtfFYHW9frFu3jltvvZXu3bsDMGHCBC699NKG7a2pL4637T+YNWsWubm5TJgwAYA33niD1157DYfDwe23385Pf/rTRvt/++23PPTQQ9jtdkaMGMG0adOIRCLcd999bNy4EZfLxcyZM+nWrZt1jT2K5uqLmTNnsnr1ahISEgB49tln8Xq9Dfu3xb5Yv349Dz74IHa7HZfLxaOPPkp6enqr/1w0Vz+0x89EQUEB9957L6Zp0r17d2bOnInD4WiZz4QZQ5YvX27+4he/aPTeL3/5S/PDDz9scv9bb73VXL58uWmapnnvvfeaixcvbrT9L3/5i/nUU0+Zpmma77//vvnggw+agUDAvPDCC80DBw6Yfr/fHDdunOnz+Sxozck53r544403zBdffPGw52tNfXG8bS8rKzOnTJliXnDBBearr75qmqZplpaWmqNHjzb9fr9ZUVHR8N8/dtlll5nbt283I5GIefPNN5tr1641Fy1aZM6YMcM0TdP85ptvzNtuu82CFh675ugL0zTNa6+91iwrKzvsddpiX1x33XXmunXrTNM0zfnz55uzZs1qE5+L5ugH02yfn4nbb7/dXLlypWmapjljxgxz8eLFLfaZiKmR7b8LBAKUlpaSnJzMjTfeiM1mw+fzcc0113Ddddexdu1azjjjDADOPfdcvvjiCy666KKG41etWsXNN9/csP3ZZ5+lsLCQrl27kpycDMDQoUP56quv+NnPftbyDTwOR+uLNWvWsHXrVj7++GO6devGr3/9axITExuOb819cbS2V1dXc8cdd7B06dKGY77//ntOO+00XC4XLpeLrl27smHDBgYPHgxAVVUVgUCArl27AjBixAiWLVuGz+fjnHPOAWDIkCGsWbOm5Rt8BCfSF5FIhO3bt/Pf//3f7N27l6uuuoqrrrqqYXtb7Ys//OEPZGZmAhAOh4mLi2uTn4sT6Yf2+pl4+umnsdvtBAIBfD4fiYmJLfaZiLmwXb58OZMmTaKsrAybzcbVV1+NzWajpKSEd955h0gkwpgxY7jkkkswTRPDqF+xISEhgcrKykbnqqqqargt8sP2H7/3w/tVVVUt18DjcDx9MXjwYMaPH8+gQYOYM2cOzzzzDDNmzGg4V2vri+Npe05ODjk5OY0C5mhtq6qqavTHSEJCAjt37jzkfbvdTigUwuGI3j+Vk+2Lmpoarr/+em688UbC4TCTJ09m0KBB9OvXD2i7ffFDwKxevZp58+bxyiuv8Nlnn7WJz8XJ9kN7/Ux06NCBXbt2ceONN5KYmEi/fv1YunRpi3wmYu4BqeHDhzN37lxeeeUVnE4nXbp0AWj4y8PtdtO7d2927NjR6PvZ6upqkpKSGp0rMTGR6urqRtt//N4P7/+4o2PJ8fTFRRddxKBBgwC46KKLWLduXaNztba+OJ62N+VobWtqe1N9EolEovp/JHDyfeHxeJg8eTIej4fExESGDx/Ohg0bGra35b744IMP+N3vfsfzzz9PWlpam/lcnGw/tOfPROfOnVm8eDETJkzgkUceabHPRMyF7Q9SU1N5/PHH+e1vf4vP52P9+vWEw2Fqa2spKCigW7duDBgwgBUrVgCwdOlShg0b1ugceXl5fPrppw3bhw4dSs+ePdm+fTsHDhwgEAjw9ddfc9ppp7V4+47HsfTFlClT+P777wH48ssvGThwYKNztNa+OJa2N2Xw4MGsWrUKv99PZWUlhYWF9OnTp2F7YmIiTqeTHTt2YJomn3/+OcOGDSMvL69hVPjtt982OibaTrQvtm3bxoQJEwiHwwSDQVavXt3o89FW++Ldd99l3rx5zJ07l5ycHKDtfS5OtB/a62fitttuY9u2bUD9CNVms7XYZyLmbiP/WK9evZg0aRIzZ84kMzOTW265hQMHDnD77beTlpbGjBkzuPfee/nDH/5Ajx49uPjiiwGYNGkSc+fOZcKECcyYMYMJEybgdDr5/e9/j9Pp5J577mHKlCmYpsmVV15Jx44do9zSoztaX9x33308+OCDOJ1O0tPTefDBB4G20RdHa3tTMjIymDRpEhMnTsQ0TaZPn05cXBxLly5lw4YNTJ06lfvvv59f/epXhMNhRowYwamnnsopp5zCF198wbXXXotpmsyaNauFW3tkJ9IXPXv25PLLL+fqq6/G6XRy+eWX07t37zbdF8nJyTz00EN06tSJO+64A4DTTz+dO++8s819Lk60H9rbZyItLY2pU6dyzz334HQ68Xg8zJw5s+X+v+JYn/qKpqaeODuSmTNnWlhNdLXnvjjetjdl79695pw5c5qpouhRXxykvqinfjgoFvsiZm8jn4ybbrop2iXEDPVFY6Zpqk/+RX1xkPqinvrhoObuC8M0TbPZziYiIiKHaJMjWxERkViisBUREbGYwlZERMRiClsRERGLKWxFYpjf7+fNN9887Pavvvqq0cw//+7tt9/miSeeOOz2p59+mvnz5x/y/rRp04D632kXFhYedj8ROTYKW5EY5vP5jhi2b731FqWlpc1+3dmzZzf7OUXas5ieQUqkvXvuuecoKChg9uzZ5OfnU1VVRTgc5q677sLr9fLZZ5+xdu1aevXqxZIlS1i8eDG1tbWkpqYec2B+9NFHfPjhh9TV1fHb3/6WwYMHc/bZZ/PFF19Y3DqR9kNhKxLDbrvtNjZt2kR1dTVnnXUWN9xwAyUlJUyYMIGPP/6Yc845h0svvZSsrCwOHDjAX//6V2w2G1OmTCE/P/+YrtG5c2ceeOABNm/ezN13383//b//1+JWibQ/CluRVqCwsJAxY8YA0LFjRxITEykrK2vYbrPZcDqd/PKXvyQ+Pp7i4mJCodAxnfv0008HoHfv3vh8vuYvXkT0na1ILLPZbEQiEXr27MnXX38NQElJCRUVFaSkpGAYBqZpsmHDBj766CP++Mc/cu+99xKJRDjWyeF+WC1q48aNZGdnW9YWkfZMI1uRGNahQweCwSCVlZVs376dRYsWUVdXxwMPPIDD4eDUU0/liSee4A9/+AMej4drr70WqF/16FgfnCoqKmLy5MkEAgEeeOABK5sj0m5pbmQRERGLaWQr0g5MmzaN8vLyRu8lJiYyZ86cKFUk0r5oZCsiImIxPSAlIiJiMYWtiIiIxRS2IiIiFlPYioiIWExhKyIiYrH/BxSN1xjDA3sAAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -7750,13 +7890,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='barplot', \n", + "ax = plot2d(plot='barplot', \n", " df=tips, \n", " y='day',\n", " x='total_bill',\n", @@ -8192,13 +8332,13 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 31, "id": "63122732", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -8208,13 +8348,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='histplot', \n", + "ax = plot2d(plot='histplot', \n", " df=tips, \n", " x='day',\n", " sep='.',\n", @@ -8689,13 +8829,13 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 32, "id": "fc8cd515", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgkAAAFDCAYAAACwSZ1vAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABrKUlEQVR4nO3deVxU9f7H8dcMMGzDjiAKIgruK5pooqVWUvdqmYaiF71qWhj2o8w0y6XcMk0rt7ZbEWqoaWb7opVpikuXSsUFN9AQkEVggBlm5vz+4Do5gYrKIvh5Ph4+Hsz3nO+Z7zkC8+Z7vuf7VSmKoiCEEEII8Tfqum6AEEIIIW5NEhKEEEIIUSkJCUIIIYSolIQEIYQQQlRKQoIQQgghKiUhQQghhBCVkpAgRA1KSkqiV69eREdHEx0dTWRkJAkJCTd93DVr1lR53++++47MzMwrbs/Pz+ezzz676jF69+59xW1nz54lMjKyQvnbb7/N77//zubNm1myZMkV97tZV2ubEOLmSEgQoob17NmThIQEEhISWLNmDe+//z4FBQU3dczVq1dXed8PP/yQoqKiK24/evQo27dvv6n2VGbixIl06tSp2o8rhKg9tnXdACFuJ0VFRajVamxsbNi7dy8rVqxAURR0Oh2vvvoqdnZ2xMTE4O7uTt++fenbty/z5s0DwN3dnQULFrBmzRouXrzInDlzeP7553nuuec4e/YsJpOJsWPH8sADD1je78cffyQlJYVp06axbt061qxZwxdffIGtrS3du3dn6tSpvPnmmxw5coT169fTtWtXXn75ZUwmE3l5ecyZM4fQ0NBrnldubi6PP/44OTk53H333TzxxBNMnz7dqi2V+fDDDykoKCA2NhaDwcDgwYP5+OOPeeaZZygqKqKkpISnnnqK8PBwSx2TycTMmTNJTU0lICAAg8EAwLFjxyq0vbi4mA0bNvDGG28AMGLECF5//XV8fX2v+/9OiNuRhAQhatiePXuIjo5GpVJhZ2fHzJkzcXZ25vjx4yxevBhfX1/efPNNvv76awYNGkR2djabNm1Co9EQGRnJggULCA4OZuPGjbz77rs89dRTrFmzhjlz5rBmzRo8PT1ZsmQJRUVFPPzww/Ts2RNPT08A7r77btq2bcucOXM4deoUX331FYmJidja2jJ58mR++OEHHn/8cRITExk+fDhffvkl06ZNo3Xr1nz22Wds3ry5SiGhuLiYxYsX4+TkxKhRoxgwYECVrs2DDz7IyJEjeeKJJ9i2bRv9+vUjIyOD/Px83n33XXJycjh9+rRVne+++w69Xs+GDRv4888/+eabbwBITU2t0Pa5c+cyb948Ll68SFZWFh4eHhIQhLgOEhKEqGE9e/Zk2bJlFcp9fX2ZP38+Tk5OZGZmWj6M/f390Wg0AJw4cYIXX3wRgLKyMpo3b251jBMnTnDnnXcCoNVqadmyJenp6ZaQcLmTJ0/SuXNn7OzsAOjevTvHjx+nc+fOln18fHxYtWoVDg4O6HQ6tFptlc6xTZs2uLi4ANCxY0dOnTpVpXpubm60bduWAwcO8MknnzBt2jRatmzJ8OHDefrppzEajURHR1vVOX36tOU2RpMmTfDz87ti21UqFYMHD+bzzz/n7NmzDBs2rErtEkKUkzEJQtSRmTNnsmDBAl5++WV8fHy4tIyKWv3Xj2VQUBCLFi0iISGBqVOncvfddwNY9m3ZsiX79+8Hym9lHDt2DH9/f6v3UalUKIpCixYt+P333zEajSiKwr59+wgKCkKtVmM2mwGYP38+Tz75JIsWLaJVq1ZUdWmXEydOoNPpMBqN/P7774SEhFT5OkRGRhIfH09paSktW7bk6NGj6HQ63n77bV5++WXmzp1rtX9wcDDJyckAZGZmWgZlXqntQ4cO5euvv2bfvn3cddddVW6XEEJ6EoSoM4MHD2bUqFE4Ojri7e1NVlZWhX3mzJnDtGnTMBqNqFQq5s+fD5SHg2eeeYYFCxYwc+ZMoqKi0Ov1xMbG4uXlZXWMrl278uyzz/Lee+9x//33ExUVhdlsplu3btxzzz1kZWVx7NgxPvjgAwYPHsz//d//4erqSuPGjcnLy6vSubi5ufHUU0+Rm5vLAw88QHBwcJWvQ48ePZg5cyYxMTEANG/enJUrV/LVV19hNpt58sknrfYfMGAAu3bt4pFHHqFJkyZ4eHhYrmdlbff19cXZ2ZkuXbpgayu/8oS4HipZBVII0dA99thjzJgxg8DAwLpuihD1isRqIUSVrF+/ns8//7xC+dNPP03Xrl3roEXXVlpaysiRIwkLC5OAIMQNkJ4EIYQQQlSqRnoSkpKSiIuLs9yX1Ol0+Pv7s2TJEsuo7culpKQwd+5cbGxs0Gg0LFq0CG9vbz744AO++OILAO666y5iY2Ot6h0+fJjHHnvMMuI7KiqKBx54gBUrVvDjjz9ia2vLjBkzZEIXIYQQ4gbU2O2Gvz/2NWXKFLZv305ERESFfefPn8/MmTNp27YtiYmJvPPOO/zrX/9i69atbNy4EbVaTVRUFPfccw9t2rSx1Dt06BBjx45l3LhxVmV79+5l48aNZGRkMHnyZDZt2lRTpymEEEI0WLUyJsFgMJCVlYWbmxtjx45FrVaTnZ3N8OHDGTVqFEuXLsXHxwcon03N3t6exo0b8+6772JjYwOA0WjE3t7e6rgHDx7k1KlTbNu2jcDAQGbMmMGBAwcIDw9HpVLRpEkTTCYTubm5Vs+NFxQUVDotrqenJ05OTjV4JYQQQoj6o8ZCwqVZ5nJyclCr1URGRqJWq8nMzGTLli2YzWYGDRpERESEJSD8+uuvrFmzhrVr12JnZ4enpyeKovDKK6/Qrl07goKCrN6jU6dOPPLII3To0IHVq1ezcuVKXFxccHd3t+zj7OxMYWGhVUiIj49nxYoVVscaMWKEZdIaIYQQQtTC7Ya8vDzGjRtnmeCla9eulnEJISEhpKWl4eXlxZdffsnq1at5++23LR/oer2eGTNm4OzszOzZsyu8x7333ourq6vl67lz5zJgwAB0Op1lH51OZ5kJ7pIxY8YwZMgQq7JLbSooKMFkMlfTVRBCCNHQ2diocXV1rOtm1Igav93g4eHB4sWLGT16NDNmzCAlJQWTyYTBYCA1NZXAwEA+/fRT1q9fT0JCgqUXQFEUJk2aRFhYGBMnTqz02OPHj2fmzJl06tSJ3bt30759e0JDQ1m8eDHjx4/n/PnzmM3mClPUurq6WsLF35lMZoxGCQlCCCFErYxJCA4OJjo6mnnz5uHj48OECRPIz88nJiYGNzc35s+fj5+fH5MnTwbgjjvuoG3btuzduxeDwcDPP/8MlD+P7eDgwObNm3n++eeZM2cOc+fOxc7ODm9vb+bOnYtWq6V79+4MHz4cs9nMrFmzauMUhRBCiAanVudJSEpKIjExsdLFbqqquLiYt956i6eeeqoaW/aXvDyd9CQIIYSoMltbNR4eznXdjBpR7xZ4MplMTJgwoa6bIYQQQjR4MuPi30hPghBCiOshPQlCCCHE3xw6dJDY2PKB5WfPphMTM55Jkx5lyZKFluXH33vvbSZMGM3jj4/j8OGDAOzZ8wsTJozmhReetey3dOkiMjL+rJsTEVckIUEIIcR1W7s2nkWL5mIwGABYvnwpEybEsGrVuyiKws8//8TRo0dITv6Vt9+OZ86cBSxd+goAn3yykaVLV+Lt7UNq6jFSU4/j7KzFz69JXZ6SqISEBCGEENetaVN/5s9fbHl99OgRunbtBkDPnneyf/9efv89mTvu6IlKpaJx48aYTEby8vJwdHRCr9ej1+txcHBkzZoPGDVqTF2dirgKCQlCCCGu2913D8DW9q+n6BVFQaVSAeDk5IxOV4ROV4RWq7Xsc6n83/9+lOXLX8XPz49z59Lp2LEz33//NYsXL+Dgwd9r/VzElUlIEEIIcdPU6r8+ToqLdWi1WpydtRQX6/5W7kLz5kG8+OJCRo0aw+eff8q990aQlLSHp556lg8+eLcumi+uQEKCEEKImxYS0ppff90PlA9M7Ny5Kx07dmbv3j2Yzeb/zYCrWK2ts3XrJ9x//yAAFMWMSqWitLS0LpovrqBWZly83bi4OuBgb1fXzahXSvVlFBbILwch6qvY2DheeWU+b721ksDA5tx99wBsbGzo1KkLjz02FkVRePrpaZb9dboi/vvfA7z00kIAPD29iIkZz5Ahw+rqFEQlZJ6Ev6mOeRIaNXJh5LNrq6lFt4d1r4wiO7uwrpshhBDXTeZJEEIIIcRtR0KCEEIIISolIUEIIYQQlZKQIIQQQohKSUgQQghRYw4d+oPY2AkcOvRHXTdF3AAJCUIIIWrEoUN/sGjRPC5cyGbRonkSFOohCQlCCCGq3aWAYDDoATAY9BIU/ue3334jOjoagDNnzhAVFcXIkSOZPXu2ZVXMFStWMGzYMEaMGMHvv5dPVb1jxw6GDRvGk08+adnvpZde4uzZszXWVgkJQgghqtXfA8IlEhTgnXfe4YUXXkCvL782CxcuJC4ujnXr1qEoCtu2bePQoUPs3buXjRs3snTpUl588UUA1q1bx3vvvYePjw9HjhzhyJEjaLVa/P39a6y9EhKEEEJUmysFhEsaclDIyMjg7NmzVv8KCgqs9mnWrBnLly+3vD506BA9evQAoG/fvvzyyy8cOHCA8PBwVCoVTZo0wWQykZubi7OzM6Wlpej1ehwdHXnnnXeYMGFCjZ6TTMssGhwPNw22Gvu6bka9YTToybtoqOtmiAZi9eo3rhgQLjEY9Kxe/QYrVrxTS62qHaNGjeLcuXNWZbGxsUyePNnyeuDAgVa3By5fPdPZ2ZnCwkKKioqs1ri4VD5p0iQWLlxI69atSUtLIzQ0lM8//5yUlBSGDBlC165dq/2cJCSIBsdWY8+BVx6t62bUG92efReQkCBunqIo3HVXfzZtWn/V/TQae2JinqylVtWetWvXYjKZrMpcXV2vWufy1TN1Oh2urq5otVp0Op1VuYuLC56enixbtgyTyURcXBzz5s1jxowZvP7668TExPDOO9UfumokJCQlJREXF0dwcDBQfoL+/v4sWbIEjUZTYf+UlBTmzp2LjY0NGo2GRYsW4e3tzYYNG0hMTMTW1paYmBj69etnVS85OZn58+djY2NDeHg4sbGxmM1m5syZw9GjR9FoNMybN4/AwMCaOE0hhBD/k5p6jA8/fI9jx47g4+NLbm4uRmNZhf00GnumTXuB9u071kEra5afn99112nXrh1JSUmEhYWxY8cOevbsSbNmzVi8eDHjx4//3+qZZjw9PS111q9fz5AhQwAwm8tXzywpKam287hcjfUk9OzZk2XLllleT5kyhe3btxMREVFh3/nz5zNz5kzatm1LYmIi77zzDo8++igJCQls2rQJvV7PyJEj6d27t1XImD17NsuXLycgIICJEydy+PBhzp49i8FgYP369SQnJ/Pyyy+zevXqmjpNIYS4rV24kE1i4hp27vwJNzc3JkyYRL9+A0hJOVxhbEJDDgg3atq0acycOZOlS5fSokULBg4ciI2NDd27d2f48OGYzWZmzZpl2b+oqIi9e/fy2muvAdCoUSPL0xE1oVZuNxgMBrKysnBzc2Ps2LGo1Wqys7MZPnw4o0aNYunSpfj4+ABgMpmwt7fn999/p2vXrmg0GjQaDc2aNePIkSN06tQJKL9QBoOBZs2aARAeHs4vv/xCdnY2ffr0AaBLly4cPHiwQnsKCgoqDCbRaDSWNgghhLi6kpIStm7dzOeffwooPPTQMB58cCiOjo4AtG/fkWnTXrAEBQkIf/H392fDhg0ABAUFsWbNmgr7TJ482WoswyVardYSEKD8EciaVGMhYc+ePURHR5OTk4NarSYyMhK1Wk1mZiZbtmzBbDYzaNAgIiIiLB/Ov/76K2vWrGHt2rX8/PPPuLi4WI7n7OxMUVGR5XVRURFardZqe3p6eoVyGxsbjEYjtrZ/nWp8fDwrVqywam9oaCgfffRRg13usz5o1Mjl2juJGiHXXlSVyWTi66+/5v333ycvL48BAwYwfvx4fH19K+x799134uY2n8WLFzN16tQaGVgnalaN327Iy8tj3Lhxluc4L/UOAISEhJCWloaXlxdffvklq1ev5u2338bT0/OKAzcuqWy7q6srpaWlVuVms9kqIACMGTPGcj/nkkttysvTYTSab+rc5RfujcnOLqyW48j1v37Vde1Fw/bHH7+RkPAeaWlnaNWqDU8//RwhIa2AK38P+fsH8/rrb111n/rO1lbdYP/ArPHbDR4eHixevJjRo0czY8YMUlJSMJlMGAwGUlNTCQwM5NNPP2X9+vUkJCRYHvvo1KkTr732Gnq9HoPBwIkTJ2jVqpXluFqtFjs7O9LS0ggICGDnzp3ExsZy/vx5fvjhBx544AGSk5Ot6lzi6up6zRGnQgghyp07d5a1az/g11/306iRD//3f8/Qs2dvy6N7ouGqlTEJwcHBREdHM2/ePHx8fJgwYQL5+fnExMTg5ubG/Pnz8fPzs9x/ueOOO3jyySeJjo5m5MiRKIrCU089hb29PTt27ODIkSNMnDiRF198kWeeeQaTyUR4eDidO3emY8eO7Nq1ixEjRqAoCgsWLKiNUxRCiAanoKCATZsS+e67r7G3d2DkyNFERPyz0qfURMOkUhRFqa03S0pKIjEx0eqph+uVk5PDxo0befzxx6uxZX+prtsNI59dW00tuj2se2VUtd5ukHkSqq7bs+822G5gcWPKysr45psv2Lx5AyUlpdxzz30MGzYCNzf3um7aLUluN9xCFEVh3Lhxdd0MIYRocBRFYe/e3axdG09WViZduoQyatS/CQhoVtdNE3WkVkNCWFgYYWFhN3UMb2/vamqNEEKIS06cOM6HH77H0aMp+Ps347nnZtO5szyNcLurdz0JQgghqs/fJ0N69NEY+vW7Bxsbm7pumrgFSEgQQojbUGlpCVu3fsLnn29BURQefHAoDz44FCcnp7pumriFSEgQQojbiNls4qeffmD9+rXk5+dx5519GDHiX/j4VJwMSQgJCUIIcZs4ePB3EhLe48yZ04SEtObpp6fRqlWbum6WuIVJSBBCiAbuzz/PsXbtBxw4sA9v70Y8+eQz9OolkyGJa5OQIIQQDVRhYQGbNq3nu+++RqPREBU1mvvvl8mQRNVJSBBCiAbGaCzjm2++YvPm9RQXlzBgwL0MGxZlmfZeiKqSkCCEEA2Eoijs25fEunXxnD+fQadOXYiOHktAQGBdN03UUxIShBCiATh5MpWEhPdJSTmEv38A06fPokuX0LpulqjnJCQIIUQ9lpubQ2LiGnbs+AFXVzfGj3+c/v3vlcmQRLWQkCCEEPVQaWkpn332CZ999glms5lBg4YwZMgwnJwa5kJDom5ISBBCiHrEbDazY8cPrF+/hry8PHr27M3IkaNlMiRRIyQkCCFEPXHo0B8kJLzP6dMnadkyhLi4abRuLZMhiZojIUEIIW5xGRl/sm5dPPv2JeHt3YjJk5+mV69w1Gp1XTdNNHASEoQQ4hZVVFTIpk0b+PbbL7Gzs2PEiH/xwAOD0Gjs67pp4jYhIUEIIW4xRmMZ3377NZs2rae4uJh+/QYQGTkSd3ePum6auM1ISBBCiFuEoigcOLCXNWviOX/+Tzp27My//jWWwMDmdd00cZuSkCCEELeAU6dOkpDwHocPH6RJE3+mTXuBLl26ySJMok5JSBBCiDqUm5vL+vXlkyFptVrGjZtI//73YWsrv55F3auR78KkpCTi4uIIDg4GQKfT4e/vz5IlS666+tiCBQsICgoiKiqKlJQUFixYYNmWnJzMypUr6du3r6Xsu+++Y9GiRfj5+QEwefJkunfvzpw5czh69CgajYZ58+YRGCjzlgshbi2lpaV8/vkWPvvsE0wmE//854M89NAwnJ21dd00ISxqLKr27NmTZcuWWV5PmTKF7du3ExERUWHf3Nxcnn32WU6fPs348eMBaNu2LQkJCQB89dVX+Pj4WAUEgIMHDzJ16lQGDhxoKfv2228xGAysX7+e5ORkXn75ZVavXl0TpyiEqISrmz32shTxFZnNZr7//nv+85//cOHCBcLDwxk2bBSNG/vVddOEqKBW+rMMBgNZWVm4ubkxduxY1Go12dnZDB8+nFGjRqHT6Zg8eTI7duyoULe4uJjly5ezZs2aCtsOHTpESkoK8fHxdOrUiWeeeYYDBw7Qp08fALp06cLBgwdr/PyEEH+x12j49/v/V9fNuCWVZurIP5BBWW4pdp6O+NwXxIvTXiQ7u7CumyZEpWosJOzZs4fo6GhycnJQq9VERkaiVqvJzMxky5Yt/5trfBAREREEBAQQEBBQaUj4+OOPiYiIwNPTs8K23r17c8899+Dv78/s2bNJTEykqKgIrfav7jobGxuMRqPV/b2CggIKCgqsjqXRaPDx8anGKyCEEOXKCvVc/DWTkvQCbJxs8eztj1NzNxmUKG55NX67IS8vj3HjxuHv7w9A165dLeMSQkJCSEtLw8vL64rH+eyzz3jjjTcq3TZ06FBcXV0BGDBgAN988w0uLi7odDrLPmazucIAoPj4eFasWGFVFhoaykcffYSHhyyOUlcaNXKp6ybctuTa1wyz3sTFP7IoOpaLSq3CrbMP2rbeqG2tZ0qU6y9uVTV+u8HDw4PFixczevRoZsyYQUpKCiaTCYPBQGpq6lUHFRYWFmIwGCwDEy+nKAqDBw8mMTGRxo0bs3v3btq3b4+3tzc//PADDzzwAMnJybRq1apC3TFjxjBkyBCrskvBJS9Ph9Fovqlzlh/4G1NdXa5y/a9fdXZ3y/UHxaxQdCyXgt+zMBtMOAd74NbJBxsnu0r3l9sN9ZutrbrB/oFZK2MSgoODiY6OZt68efj4+DBhwgTy8/OJiYmp9DbCJadOnaJp06ZWZTt27ODIkSNMnDiRefPmERsbi4ODAy1btiQyMhIbGxt27drFiBEjUBTF6gmJS1xdXS09EEIIUV0URaH0XCH5B85jLDRg39gZ926N0Xg41nXThLghNRISwsLCCAsLsyqLiYkhNDSUxMREq6ceLjd58mSr1506dWLVqlVWZe3bt+fw4cMAhIeHEx4eXuE4L7300s00XwhxC8v6/SzZf5wDwGwyo8ssxNHLGVv78l9nJbk6GnVsSuDdrS11TAYjJ785jP5iCYrJTPN72+LSxJ30nankn8zGI9gH/ztbopjNHPv0N1o92AWV+vrGCxhyS8j/9Tz68zpsXTV4390Mh6YuMu5A1Gv1brYORVEYN25cXTdDCFFHfDr549OpfIzTyW8P49PJH98uAQCU5hdzbEsy/ne2tKrzZ9IpnBppCRnUCV1WIcVZBbg0cefi6Rw6ju7FwTVJ+N/Zksz/puPTyf+6AoKpuIyLv2WiO5GPWmOD+x1+aEM8rztkVAd3Fw12DrL4U1WVlerJLzTUdTNuabUaEirrYbhe3t7e1dQaIUR9VpRxkZLsQlrc185Sdvr7FALvbo2NxvpXW/6pC3i39ePw+n3YaGwtdVRqFYpZQaVWYSwto/BcPo27VW3yNbPRTGHKBQoPXUAxK7i09cK1gw9qe5vqO8nrZOdgz5ejx9bZ+9c3D3z4PkhIuKp615MghBAA53afxD882PJal1WISW/ErXnFp6WMJWUYS8toN/wOsv84x+ntRwkZ1InG3QI59mkyfnc059yekzTpEcSZH45iKjPh37slGueKf5UrikLxqYtcTD6PqdiIY4Ar7qG+2LrIX/Ci4ZGQIISod4ylZZTk6nAL/CsQXDj0Jz7/u+3wd7aOdniElM+D4hHiw7k9JwHwau2LV2tfSvOLyT91gbJiPXZOGryaeXJ+/xma3WX9dJQ+S0fe/vOU5ZZg5+mAZ+8AHHwb5qh2IUBCghCiHipIz8Mt0PrJqIunc2jSM6jS/V38Pcg/kY22sRsFabk4eluvj3D2lxM06xtC4bmLoFKBCkwGk2W7sVBP/n8zKUn732RIdzbFKchdBiWKBk9CghCi3inJ1eHg7mRVZtDpsXP8a80IQ5Ge09tSaPVgF5r2asHJrw7xx4e7UanVBP+zo2W/wnN52Ls6otE64B5ky5GPfyXnSAYtIjpgNpgo+CObwqM5qFTg2skHl3YVJ0MSoqGSkCCEqHeahlXsMege28/qtZ2THRqtQ/nXjhpaP9y10mO5NPXApakHADYaW9qP7FE+GdLxXDJ+OotZb8K5pTtunX2vOBmSEFVVVlbG9OnTOXfuHGq1mrlz52Jra8v06dNRqVSEhIQwe/ZsAGJjY8nOziYuLo7evXuTnp5OfHw8L7zwQq21V0KCEKJBUhRoUkmYuHodhdJzReT/eh5jgR573/9NhuQpkyGJ6vHTTz9hNBpJTExk165dvPbaa5SVlREXF0dYWBizZs1i27ZtNGnShKZNm7Jw4UKmT59O7969WbVqFVOmTKnV9kpIEEI0SGobNRpt1Z84MOSVkn8go3wyJBcN3nc1w8FfJkMSVZeRkYHJZLIq+/sMv0FBQZhMJsxmM0VFRdja2pKcnEyPHj0A6Nu3L7t27WL06NHo9XpKS0txcnLiwIEDNG/evNanAZCQIIS4rZlKyrj4Wxa6E3mo7Wxw7+6HNsQDlY2MOxDXZ9SoUZw7d86qLDY21mo2YScnJ86dO8f9999PXl4eb775Jvv27bOEUWdnZwoLCwkKCsLX15dXXnmFSZMm8frrrzN16lRmz56Nm5sbcXFxqNU1/z0qIUEI0eCVni8id/c5PHs1xaFx+ZMNZqOZopQLFBy6gGIyo23thWvHRtjYy69FcWPWrl1baU/C5T744APCw8OZMmUKGRkZjBkzhrKyMst2nU5nqfPEE08A5ashDxgwgA0bNjBs2DD27t3L7t276d27dw2fkYQEIUQDV3q+iAs/nEExKVz44QxedwdiLjVy8b+ZmIrLcAxwxa2rL3auMhmSuDmVrVj8d66urtjZlQ+AdXNzw2g00q5dO5KSkggLC2PHjh307NnTsr9er+fbb7/ljTfeYP78+djY2KBSqSguLq6x87ichAQhRIN1eUAAyoPCttMA2Hk44HnnXz0LQtSGf//738yYMYORI0dSVlbGU089RYcOHZg5cyZLly6lRYsWDBw40LJ/fHw80dHRqFQqhg4dyqxZs9BqtaxcubJW2ishQQjRIP09IFhRq3ALbSwBQdQ6Z2dnXn/99Qrla9asqXT/iRMnWr5u27YtGzdurLG2VUZG5gghGpyrBgQAs0LOj2coPV9Uuw0Top6RkCCEaHByd5+7ckD4H8WkkLv73FX3EeJ2JyFBCNGg6C8Uo7K59twGKhsVnr2a1kKLhKi/ZEyCEKJBMBWXkZ+cSfHJfNQOtri086boaE6lPQoqGxXe/QJlTIIQ1yAhQQhRrykmM4VHcij4IxvFrODSzhvXDo1Qa2xwaKKtMDZBAoIQVSchQQhRL5Wvs1BI/oHzGAsNODR1wb1bY6v5Dhwaa/HuF2gJChIQxO0qMzOTxYsXk5ubS0REBK1bt6Zz587XrCdjEoQQ9U7ZxVIubD/DhR/TQKXCu38gjfoFVjoh0qWgYONsJwFB3LZmzpzJ0KFDKSsro3v37syfP79K9SQkCCHqDbPBRN7+DM5/nor+QjHu3RrT+J/BODZxuWo9h8ZamgxpLQFB3LZKS0vp1asXKpWKFi1aYG9ftRlGa+R2Q1JSEnFxcQQHBwPlc1H7+/uzZMkSNBrNFestWLCAoKAgoqKiAJg3bx6//vorzs7OAKxatQoXl79+GSQnJ1umqQwPDyc2Nhaz2cycOXM4evQoGo2GefPmERgYWBOnKYSoJYpZQXcij4vJmZj1JpyDPXDr4ouNg9wxFaIq7O3t+fnnnzGbzSQnJ1/1s/hyNfYT1rNnT5YtW2Z5PWXKFLZv305ERESFfXNzc3n22Wc5ffo048ePt5QfOnSId999F09Pz0rfY/bs2SxfvpyAgAAmTpzI4cOHOXv2LAaDgfXr15OcnMzLL7/M6tWrq/8EhRC1Qp+lI29fBmV5pdj7OOHe3Q+Np2NdN0uIemXu3LksWrSIvLw83nvvPebMmVOlerUSww0GA1lZWbi5uTF27FjUajXZ2dkMHz6cUaNGodPpmDx5Mjt27LDUMZvNnDlzhlmzZnHhwgWGDRvGsGHDLNuLioowGAw0a9YMgPDwcH755Reys7Pp06cPAF26dOHgwYMV2lNQUEBBQYFVmUajwcfHpyZOXwhxA4w6A/m/ZlJy5iI2TnZ4hQfgGOhqWVJXCFF1ZrOZqVOnWl7b2tpSVlZmWWzqSmosJOzZs4fo6GhycnJQq9VERkaiVqvJzMxky5YtmM1mBg0aREREBAEBAQQEBFiFhOLiYv71r38xduxYTCYTo0ePpkOHDrRp0wYoDwla7V/3F52dnUlPT69QbmNjg9FoxNb2r1ONj49nxYoVVu0NDQ3lo48+wsPDuaYuibiGRo2ufl9Z1Jxb6dqbjWYKD1+g8FA2AK4dG+HSvhFq24Y7hOpWuv63m9vl2j/22GNkZmbSokULTp06haOjI0ajkalTp/Lggw9esV6N327Iy8tj3Lhx+Pv7A9C1a1fLvZCQkBDS0tLw8vKqUN/R0ZHRo0fj6OhoOd6RI0csIUGr1aLT6Sz7X1qDu7S01KrcbDZbBQSAMWPGMGTIEKuyS23Ky9NhNJpv6txvl2+66padXVgtx5Hrf/2q69rDjV9/RVEoSSsg/9fzmHRlOAa64t61Mbbaqt07rc/ke7/uVMe1t7VV3/J/YPr7+xMfH4+npycXL17khRdeYO7cuUyYMOGqIaHGo7mHhweLFy/mhRdeIDs7m5SUFEwmEyUlJaSmpl5xUOHp06eJiorCZDJRVlbGr7/+Svv27S3btVotdnZ2pKWloSgKO3fupHv37oSGhlp6JJKTk2nVqlWFY7u6uuLv72/1T241CFF3DLklZH93ipyf01FrbGh0bxDefZrdFgFBiNqQk5NjGd/n5ubGhQsXcHd3R62+egyolTEJwcHBREdHM2/ePHx8fJgwYQL5+fnExMRccVBiy5YtefDBB4mMjMTOzo4HH3yQkJAQduzYwZEjR5g4cSIvvvgizzzzDCaTifDwcDp37kzHjh3ZtWsXI0aMQFEUFixYUBunKIS4AaZSIxd/y0SXmodaY4NHjyY4B3ugUsu4AyGqU/v27Xn66afp0qULycnJtG3bli+//LLSnvzL1UhICAsLIywszKosJiaG0NBQEhMTrZ56uNzkyZOtXj/66KM8+uijVmXt27fn8OHDQPnAxA0bNlhtV6vVvPTSSzd7CkKIGqSYFYqO5XDx9yyUMjPa1l64dfRBbW9T100TokGaPXs227Zt48SJEwwePJi7776bkydP0q9fv6vWq3cPGSuKwrhx4+q6GUKIG1T6ZyF5B85jvKjH3s8Zj25+2Lk71HWzhGjQ8vPzKSkpwcfHh7y8PN566y0ee+yxa9ar1ZBQWQ/D9fL29q6m1gghalNZoZ78A+cpPVuIrVaD913NcPB3kUcahagFsbGxtGjRgmPHjmFvb295KOBaGu4zRUKIW4K5zET+f89z/rNU9Od1uHX1pfGgYBwDZM4DIWqLoii89NJLBAUF8f7775Ofn1+levXudoMQon5QFIXik/nk/zcTc6kRpxbuuHfxxcbp6pO3CCGqn42NDXq9npKSElQqFSaTqUr1JCQIIaqd/kIx+fsyMOSUoPFyxP3uZth7O9V1s4S4bY0aNYr4+Hh69+7NXXfdRbdu3apUT0KCEKLa5OXl8p//rCTru5OoHWzxvLMpTkHucltBiDrWpEkTBg4cCMD9999veUrwWiQkCCFuWllZGV9+uZVPPtmIyWTCpb03rh0aobaTRxqFqEv79+8nNTWVDz74gLFjxwLlMxGvXbuWzz///Jr1JSQIIW6YoigcOLCXhIT3ycw8T/fuPXjyyVie//aVum6aEILyGYYvXLiAwWAgO7t8PRSVSmW12NPVSEgQQtyQs2fTiY9/lz/++I2mTf2ZMWMOnTp1kfUDhLiFtGrVilatWvHII4/g6+t73fUlJAghrktRUREff5zIt99+iaOjI2PGPMq990ZUWEhNCHHr2L17N2+99RYGgwFFUVCpVGzbtu2a9eSnWghRJWaziW3bvmPDhrUUFekYMOA+IiOjcHV1q+umCSGu4Z133uHNN9/Ez8/vuupJSBBCXNPhwweJj3+XM2dO07Zte8aMGU/z5i3qullCiCoKCAi44qrLVyMhQQhxRdnZWaxd+wF79vyCt3cj4uKmEhZ2pzzSKEQ94+DgwKOPPkrbtm0tP79PP/30NetJSBBCVKDX69m6dTNbt36CSgWPPBLFP//5EPb29nXdNCHEDbjrrrtuqJ6EBCGEhaIo7N69kzVrPiA3N4c77+zDyJGj8fZuVNdNE0LchEGDBvHJJ5/w559/0rNnT0JCQqpUT0KCEAKAU6dO8sEH73D0aArNm7dg8uSnadu2fV03SwhRDWbPno2Pjw+//PILHTt2ZNq0abzzzjvXrCchQYjbXH5+Pm+//SY//PA9Wq0LEyZMol+/AajVMluiEA1FWloa8+fPZ//+/fTv35+33367SvUkJAhxmzKZFXalFfDi6NGUlpZy//2DGDo0EmdnbV03TQhRzUwmE7m5uahUKoqKilCr1VWqJyFBiNvQ0exiPjuaS5aujDvuuIMRI0bTtGlAXTdLCFFD4uLiiIqKIjs7m+HDhzNjxowq1ZOQIMRtJFtXxudHc0jJLsHLyZZ/d/XlXwsXcuFCUV03TQhRg3r06MH777+Pg4MDZ8+epVOnTlWqV7X+BiFEvVZqNPPF0VyW7jrLydxSHmjlwZTe/rTzcZI5D4S4DcyaNYuvvvoKT09Ptm7dyrx586pUr0Z6EpKSkoiLiyM4OBgAnU6Hv78/S5YsQaPRXLHeggULCAoKIioqCoAPPviAL774Aih/xjM2NtZq/8OHD/PYY4/RvHlzAKKionjggQdYsWIFP/74I7a2tsyYMaPKiUmIhsasKBz4s4ivjuVRZDDRvamW+0M8cLGXTkQhbieHDx/mpZdeAuCFF15g1KhRVapXY78pevbsybJlyyyvp0yZwvbt24mIiKiwb25uLs8++yynT59m/PjxAKSnp7N161Y2btyIWq0mKiqKe+65hzZt2ljqHTp0iLFjxzJu3Dirsr1797Jx40YyMjKYPHkymzZtqqnTFOKWdSa/lK0pOaQXGGjmZs/YUF8C3GQyJCFuV3l5eXh4eFBQUIDJZKpSnauGhPXr119x2/Dhw6vcMIPBQFZWFm5ubowdOxa1Wm0ZPDFq1Ch0Oh2TJ09mx44dljqNGzfm3Xffxcam/DEso9FYYba3gwcPcurUKbZt20ZgYCAzZszgwIEDhIeHo1KpaNKkiWVEp6enp6VeQUEBBQUFVsfSaDT4+PhU+ZyEuFVdLDXy1bFcfs3Q4Wpvw4iOjeji54xabisIcduKjY1l6NChuLu7U1BQwOzZs6tU76ohITs7+4YbtGfPHqKjo8nJyUGtVhMZGYlarSYzM5MtW7ZgNpsZNGgQERERBAQEEBAQYBUS7Ozs8PT0RFEUXnnlFdq1a0dQUJDVe3Tq1IlHHnmEDh06sHr1alauXImLiwvu7u6WfZydnSksLLQKCfHx8axYscLqWKGhoXz00Ud4eDjf8DmLm9OokUtdN6HKZmz5FUe78h+fRi4OPN63FQBbktNIy9XxZP+2VvubzQoJSSc5daGIMrOZoV2bEdrMix+OnueHo+dp7qVlXO/y23MrfjjCuN7BOGmur6OvzGTm5zMFbD+Zj8ms0L+FG/2C3LG3vfbQo/p07Rsiuf51py6u/VtvvcX27dspKysjKiqKHj16MH36dFQqFSEhIZYP8NjYWLKzs4mLi6N3796kp6cTHx/PCy+8cN3vWVBQwHfffUdeXh5eXl5VHot01d9C//jHP667IZdcut2Ql5fHuHHj8Pf3B6Br166WcQkhISGkpaXh5eVV6TH0ej0zZszA2dm50tRz77334urqavl67ty5DBgwAJ1OZ9lHp9Ph4mL9TTBmzBiGDBliVXapTXl5OoxG8w2edTn5gb8x2dmF1XKcmr7+BqMZRYGZ/7Ae65Kcnktyeh6ezhXH3fycmoXJrDBnUGdydXqSTl34X3kmcwZ1Ztn3hynSl3E8s5DWjV2vKyAoisKhrGI+P5pLbomRDj5O/KO1J15OdlU+RnVde5Dv/xtRX773G6LquPa2tuoq/4GZlJTEf//7Xz766CNKSkp47733WLhwIXFxcYSFhTFr1iy2bdtGkyZNaNq0KQsXLmT69On07t2bVatWMWXKlBtq44YNGxg8eDDe3t7XVe+qv4lmzZqFSqVCURSrcpVKxYcfflilN/Dw8GDx4sWMHj2aGTNmkJKSgslkwmAwkJqaesWlKxVFYdKkSYSFhTFx4sRK9xk/fjwzZ86kU6dO7N69m/bt2xMaGsrixYsZP34858+fx2w2W/UiALi6ulrChRDXKy23CIPJzMKv/sCkKAzv3hwXBzu2HTnP0NBm/HD0fIU6v5/LI8DDiVe+OYgC/LtXSwDsbW0wmhRMZgW1SsWPx8/zZL+2FepfyfkiA1tTckjNLcVXa8eE7o0J8XKsrlMVQlyHjIyMCvf6//55s3PnTlq1asUTTzxBUVERzz77LBs2bKBHjx4A9O3bl127djF69Gj0ej2lpaU4OTlx4MABmjdvft0f8pcYDAYeeughgoKCLBMpvfrqq9esd9WQkJCQcEON+bvg4GCio6OZN28ePj4+TJgwgfz8fGJiYip8gF/y/fffs3fvXgwGAz///DNQvqylg4MDmzdv5vnnn2fOnDnMnTsXOzs7vL29mTt3Llqtlu7duzN8+HDMZjOzZs2qlnMQ4hKNrQ3/6NCUfq0bc76ghEXfHKKR1p7Yfm04l19caZ3C0jLOF5Qy9b72HDl/kbd2HGPWPzvzYOcAVu84yh3NvdmVmsXdIY357Pd0cnR67m/flCbuTpUer9hg4tsT+exJL8DeRs2DbbzoGeCCjVrGHQhRV0aNGsW5c+esymJjY5k8ebLldV5eHn/++SdvvvkmZ8+eJSYmBkVRLN3/l26RBwUF4evryyuvvMKkSZN4/fXXmTp1KrNnz8bNzY24uLgqz5oI8Mwzz9zQOV01JDz55JO88cYbhIeHV9i2c+fOK9YLCwsjLCzMqiwmJobQ0FASExOtnnq43OUX8t577+WPP/6osE9xcTFOTuW/ONu3b09iYmKlx7n8WEJUJz83Rxq7OqBSqfBzc0KtUpFdpOeN7UcoNhjJKzaw9bd0Bnf+awZDrb0toQGeqFQq2vq5k1FwBIA2jd1o09iNYoOR/+xKZWgTd5LP5vJIt+Z8uOcEsXe3sXpvk1kh6Wwh36bmUVJmpmeAC/cFe+CskXUWhKhra9eurbQn4XLu7u60aNECjUZDixYtsLe35/z5v3ofdTqdpc4TTzwBwGeffcaAAQPYsGEDw4YNY+/evezevZvevXtXuW3t2rXjnXfeISsri379+tG6desq1btqSHjjjTeAqweC2mYymZgwYUJdN0Pcxn48dp703GLG9Q4mT6dHpYJXh3bHRq3icEY+36dkWAUEgNaN3Ug+m0uPIG/O5BTh5Wz9pM7W39IZ3Mkfg9GMWqVCBejLrH/ZpOaUsPVIDueLymjh4cCDbb3wc7nyvCNCiNrl5+d3zX26devGhx9+yNixY8nKyqKkpIRevXqRlJREWFgYO3bsoGfPnpb99Xo93377LW+88Qbz58/HxsYGlUpFcXHlvZZXMmPGDPr27cu+ffvw9vbm+eefZ82aNdesV6XRUX/88QezZ8/mwoULNGnShJdeeolWrVpdVwOh8h6G6/X3QYhC1LZ+rRrz5o5jzPn8N1TAY31aXbGbf+4XvzPzH53o37ox7+1KZdbWZBRgfO+/1nLPLixFZzAS6KXFrCjkJOt55dtDRHYrH6+TW1LGF0dz+SOzGA8HW6I7+9DBV2ZKFKI+6tevH/v27WPYsGEoisKsWbPw9/dn5syZLF26lBYtWjBw4EDL/vHx8URHR6NSqRg6dCizZs1Cq9WycuXK63rf/Px8hg0bxtatWwkNDcVsrtoA/SqFhPnz5/PKK68QHBzM0aNHmTNnDuvWrbuuBgrRUNjaqInt16bSbe383Gnn5255HehVPuLZzkbNY30rD9aNXBwsoUGtUvH0Pe2A8qcovjmex0+nL6JSwcBgd/o2d8PORmZTF6I+e/bZZyuUXemv+ssH7rdt25aNGzfe8PueOHECgPPnz1vmILqWKoUEe3t7yxTLrVu3xs6u6o9WCXE7+0cH/+uuoygKyRk6vjyWy0W9iS5+zjzQyhN3B5lKWQhxY55//nlmzJjBiRMnePLJJ6tnMqVLMy7a2toyZ84c7rjjDn7//Xe0WllvXoiq8NJe3zTIZy/q2Xokh9P5epq6ahjV2YfmHg411DohxO2gqKiIZs2aXXUW5Sup0oyLXbt2BeDUqVO4uLjQtm3Vn+MWQlxbkd7EV8dz2X+uCGeNmmHtveneVCtTKQshbsqaNWt47733sLW1ZebMmfTp0+e66l81JPx91cW/e+KJJ6578IQQt6PUnBI2HMwmskMjgi+b7MhoVtiVVsC2E3kYTAp9mrsyoIUHjnYy7kAIcfM+//xzvv76a8vETdUaEq7l74skCSEqSs0p4f1fMykzK7z/ayZjQ30J9nLkSHYxnx3NJVtXRmtvRwa18cSnkimdhRDiRmk0GjQaDZ6enpSVlV13/ZsKCfIIlhBXd3lAACgzK7z3ayZ+WjvSCwx4O9kxNtSXto0qn1lRCCGqy9+XWKgKGS4tRA35e0C4xGhWSC8wEBbgwoNtvLCVqZSFEDUkNTWVKVOmoCiK5etLbnrtBiHEjblSQLjcr+eK6OzrbDVGQQghqtNrr71m+XrEiBHXXf+mQoKbm9vNVBeiwdpwMPuqAQHKbz1sOJjNjLua1VKrhBC3m0urS96oq4aEV1999YrjDp5++mmWL19+U28uqqbwwmlO7vsYB5dGoAJzmQGNsztB3R5Gra44a1bxxfOk//4VqNSo1TY0D30IO4fyuS3K9DqO/vw+7fo9jtqm8v/+3LN/kHVyL236jreUVaWe+EtkB2/+cyAT01Vygp1aRWSHRrXXKCGEuE5X/W3fokWL2mqHuAaXRkG06D7U8vrk/s1cPH8UjybtKuyb/sfXBHS6Hye3xmSfPsD51F0EdBjIxaxUzh3eTpm+6IrvU5yfwYUz/7Uqq0o98ZcivYnd6YWYFFABleUEO7XK8pSDEELcqq4aEoYMGQKA0Wjkjz/+wGg0oigKWVlZtdI4UTmz2USZvhAbOweO/ZKAChVleh3egaH4tLiDFt2HYudQvhCWYjajVpf/N6tQ0erOf5Hy4zuVHtdoKOZcynYCOg7kTPLnlvJr1RN/+f28jk8OX6DUaOb+EA+aumqI/2+W1a0HCQhCiNqWmZnJ4sWLyc3NJSIigtatW9O5c+dr1qtSv3FsbCxlZWVkZWVhMpnw8fHhn//85003WlRdYfYpju6Mx6jXgUpFo8BQVCo1ZSWFtL17IqBw+Ic38WjazhIQinLTyT61j1bhYwBw9Wl5xeMripnT//0M/w73obaxXpvjavVEOZ3BxJaUHH47r8PfVUNkx0Y01pbPeTA21NcyiFECghCiLsycOZOxY8eyatUqunfvzvTp09mwYcM161VpWre8vDz+85//0KlTJzZv3oxer7/pBovr49IoiNbhY2jd59+o1DZonN0BcPYMQG1ji9rGDgcXH/S6XAByzx0i7bcvCO4ZhZ298zWPX5yfgV6XS9pvX3Jq/yZKCrNJ/+ObmjylBuNgpo5Xd53lYKaOiBAPnghrYgkIAMFejowN9cXdwUYCghCiTpSWltKrVy9UKhUtWrTA3r5q68pUqSfBwaF8gZmSkhIcHBxkEqU6ZKtxIih0CMd++ZCADgMpuXgeRTGjmEyUFmbj4OxFTvrvXDh9gFa9x2CrqdoHkrNHU9r3jwFAX5zPqf2bCOg48Bq1bm86g4lPj+SQnKGjqauGCd0b4edS+YyJwV6O8hSDEKLO2Nvb8/PPP2M2m0lOTkajqdrsrlUKCffddx8rV66kTZs2REZG4uQks8PVJUfXRvgE9SD9j6+xc3Dh+O51mAwl+LXqg43GgfQ/vkbj6MaJveVdSS7egTRpc3elxyq+eJ6ctN8kEFzF4Yx83th+hKbuTqhUUGww4ersRJmtI7oyE/cFu9MvyB2b/02KdDqniPjdJ1CrVNjaqJh0V2vcHDVsP5LBtqPnsVGpeKhLAKHNvCp9vy3JaaTl6niy/18LqemNJuZ89hsj7mhOZ3/PWjlvIUTDMXfuXBYtWkReXh7vvfcec+bMqVK9KoWEAQMG4Ovri0ql4q677sLWVh6Bq00u3s1x8W5uVebXug9arwCyTx+weuoBoMsDz171eB3v+z/L1/bOnhXGINg7uVs9/lhZvdtNOz83nuzfluIyE1uP5PLrn0W4qRSe7NmEJq7W3XYf7jnBmF4tae6lZduRDLb+dpZBnfz55vCfzHuwK2UmMy9+/hsdm3pgZ2N9xy85PZfk9Dw8/7aGw/u/nKjxcxRCNFzffPMNc+bMue75ja76aX/s2DEyMzNZsmQJU6dOBcBkMrF06VI+/fTTG2+tuHUoZhqH9K7rVtQLKdnFfHzoAjqDCY1Zzz+Dffhg1zFUKrhYUkb/1o25r10TJvdri4dT+Ye8yaxgZ6vmRHYhrXxdsbNRY2ejxtfVkbRcHS0buViOf76ghG1HzjM0tBk/HD1vKf/8j7O08nGh8ocphRDi2kwmE2PHjiUoKIjIyEjCwsKqVO+qAxcLCgr48ssvycnJ4YsvvuCLL77gm2++YeTIkdXSaHFzXLybV+hFuF42dg7Y2FVtAMvtSm8yc7KwfAXHgmI9Zt1Fwpu5YGejJq9YzzP3tuelQZ356uA5LpYYLAHhWGYB3x7+kwfaN6GkzIST3V+Z3MHOhmKD0fK6tMzE+7+k8mh4sOW2BcDBP/M4f7GE/m38au+EhRANzrhx49i8eTNjxoxh3bp1DBxYtVvMV+1J6N69O927d+fQoUO0b9+e3Nxc3N3dUauv/lBEUlIScXFxBAcHA6DT6fD392fJkiVXHSyxYMECgoKCiIqKAmDDhg0kJiZia2tLTEwM/fr1s9o/OTmZ+fPnY2NjQ3h4OLGxsZjNZubMmcPRo0fRaDTMmzePwMDAKl0MIf7uaHYxnx4rQOPgQP8WboQ11bL424M0cikfzBvi42q5ZeDv4UxmQSlujhp2n8xmS3IaU+9rj6ujBkc7G0rKTJbjlpaZcNb89eP3+7k8LpaU8cb2IxQbjOQVG9j6WzppuTouFOmZ+8Xv/HmxmFMXinBz1NDcS1u7F0IIUa+VlpbyzTffsGXLFhRFYfLkyVWqV6XBBYWFhQwYMAAXFxcKCgqYO3cuvXtfvYu6Z8+eLFu2zPJ6ypQpbN++nYiIiAr75ubm8uyzz3L69GnGjy+/F56dnU1CQgKbNm1Cr9czcuRIevfubRUyZs+ezfLlywkICGDixIkcPnyYs2fPYjAYWL9+PcnJybz88susXr26ShdDiEtKysx8fjSHfeeKcLdXo7UxEBFSPmBw0l2tmfflH4zu2YIzuTrMZoUys5mz+ToauzmyMzWLbUcymPmPTmjty8d7tGzkwoYDpzEYzRjNZs7lF+Pv8dejqT2ae9OjuTdQPlDy+5QMBncOsGrTmzuO0qtFIwkIQojrNnjwYAYOHMicOXOu6w/nKoWE119/nXXr1uHr60tmZiaxsbHXDAmXMxgMZGVl4ebmxtixY1Gr1WRnZzN8+HBGjRqFTqdj8uTJ7Nixw1Ln999/p2vXrmg0GjQaDc2aNePIkSN06tQJgKKiIgwGA82alT9WFh4ezi+//EJ2djZ9+vQBoEuXLhw8eLBCewoKCigoKLAq02g0+Pj4VPmcRMN17EIJHx/K5mKpiX5BbjR1VvHj0WLLdn8PZyLaNyF+zwk8nOxZ9M1BCvVGhnRphlZjS/zuE3hr7Vn2fQoAbf3cGBYayMB2TXjpi98wKzC8W3M0tmp+O5vLmRxdhUAghBDVwWg0YmtryyeffIKdXfkfLQaDAaBKj0FWKSTY2Njg6+sLgK+vb5UmYdizZw/R0dHk5OSgVquJjIxErVaTmZnJli1bMJvNDBo0iIiICAICAggICLAKCUVFRbi4/DWoy9nZmaKiIqvtWq3Want6enqFchsbG8tFuiQ+Pp4VK1ZYtTc0NJSPPvoID49rTzwkakajywbx1YVSo5kvjuaSdLYQH2c7ngjzoZl7+W2FTk09rPZ9qEszWvm68n1KhtWjigDvRPeq9Pj92/hVGFvQ3EvLqQvWa2K083OnnZ97hfqP9219vadUZXV97W93cv3rTkO/9tOmTePVV19l0KBBqFQqFKV8ALRKpWLbtm3XrF+lkKDVaklISOCOO+5g3759uLu7X7POpdsNeXl5jBs3Dn9/fwBL7wBASEgIaWlpeHlVfF5cq9Wi0+ksr3U6nVVoqGy7q6srpaWlVuVms7nCI5tjxoyxrEtxyaU25eXpMBrN1zy/q2no33Q1JTu7sFqOcyPXPzWnhI0HL5BfaqRvczcGBrtXeDyxpvyzo3+tvM/VVNe1B/n+vxF1+b1/u6uOa29rq75l/8B89dVXAXjttdcsPfFQPnawKqoUEjp27EhGRgavvfYaLVq0wNOz6pO5eHh4sHjxYkaPHs2MGTNISUnBZDJhMBhITU294r2RTp068dprr6HX6zEYDJw4cYJWrVpZtmu1Wuzs7EhLSyMgIICdO3cSGxvL+fPn+eGHH3jggQdITk62qnOJq6srrq6uVT4H0XDpjWa+PJbL7vRCvJ1sienhR3MPhyrVvdJf/NfDzbFqs54JIcSN2L9/P6mpqXzwwQeMHTsWKP/jee3atXz++efXqH2NkLBx40Y+/vhjTpw4QcuW5Yv87Nu3D6PReLVqFQQHBxMdHc28efPw8fFhwoQJ5OfnExMTc8XA0ahRI6Kjoxk5ciSKovDUU09hb2/Pjh07OHLkCBMnTuTFF1/kmWeewWQyER4eTufOnenYsSO7du1ixIgRKIrCggULrqut4vZxIre89yCvxEifQFcGhnigqaXeAyGEqA2urq5cuHABg8FAdnY2UH6r4dLcR9dy1ZDw4IMP0qtXL9566y0ef/xxANRqdaW3By4XFhZWYaKGmJgYQkNDSUxMtHrq4XJ/fyQjMjKSyMhIq7L27dtz+PBhoHxg4t9XsVKr1bz00ktXbZ+4vRmMZr46nseutAK8HG15vIcfQVXsPRBCiPqkVatWtGrVikceecQythCgrKysSvWvGhI0Gg3+/v7MnTv35lpZjRRFYdy4cXXdDFFPncorZcMf2eSUGOndzJX7QzzQ2ErvgRCiYfvhhx94//33MRqNKIqCnZ0d33xz7ZV+a3URhsp6GK6Xt7d3NbVG3E4MJjPfHM9j55kCPBxteeyOxrT0lCWbhRC3h7Vr15KQkMDq1auJiIggPj6+SvXkTyjR4J3OK+W1X87x85kCegW48NSdTSUgCCFuKz4+Pvj4+KDT6QgLC6OwsGpPdchyjqLBKjOZ+SY1n59PX8TdwZaJ3RsT7CXhQAhx+3FxceH7779HpVKRmJhIfn5+lepJSBANUlp+KRsOXiBLV0aYvwv/aO2Jg4w9qJcunsnh2Ke/4eTlDCoVJr0Re3dHQgZ3Rn2Vp1FOf5+Cg5czjbs2Q5dZwOn/zYAJUPjnRVoP7YpHi0aWspI8Hae+PozZZEZtqybkwc7YOWo4vS2FgrP5qFQQ2L8Nrv4elb2dELe0efPmkZaWxtNPP83777/PCy+8UKV6EhJEg2IwGHjnnXdYn5SBm4MNj3ZrTCtv6T2o79wCPWn1YBfL62NbfyPveBZebRpX2Les2EDq579TkqujiVcQAM6+rrQfVT4eKufIeTQumVYBAeDkV4dodlcrXJq6k3PkPKW5Ogy2pRSey6fj6J6U5hVz/NPf6DT2zpo7USGq2c6dO61e5+bmEh4eXj1PNwhRn5w4cZzVq9/g7Nl0ejTV8o/WXjjaSe9BQ2M2mSkr0mPrYMfhxH2ggrIiA75d/GncLRCTwYh/eDD5J7Ir1DUZjKT/fNwSGCzlZSbKig3kpWaR9uNRnP3cCLy7NcbSMtS2NigmMyaDEZWNqsIxhbiVffHFF1fcFh4efs36EhJEvVdWVsbmzRv49NNNuLt7sHDhQmx+fLuumyWq0cUzuRxam0RZsQFUKny7+IMKDIWldBrbG0VR+O0/u/Bq0xgHdycc3J0qDQlZv5/Fq01j7JysZ7o0lpZRcqEIt3vbEtA3hBNfHST7j3N4tvZFpVKR/PbPGPVGWt7fobZO+ZaQWnCR+ONH8XV0QgWUmkx4OTjwr5Yh2KqvHMA/OXMKHwdHevs25pxOxydnTlm2nSkqZFyrNrR1t75tY1YU4o8fpaePr2Xbf46mUGQ0YqNSYadW81ibdjVyng3ZwoULb6q+hARRr506dYJVq14nPT2Nu+7qz+jR42je3I8DEhIalEu3G8pKDKQk7sfezQkAl6YeqP831sSpkZbS/GLsnK+8AN2FQxm0GtKlQrmtgx02GhvcAssnivNo6cPF0xcwlRmx02poO7w7JoORg2uS0DZxx9719pl8K8TVjdEhfy0ulpB6jIN5uXTxqvg4elFZGWtPHCe7tAQfv6YANHV2JrZdebhKzrmAm0ZTISBcKC1l7YnjXDTo6clfE/5kl5YyrVMXVCrpwblZl/ca5OfnExAQwFdffXXNehISRL1kNJbxyScf88knG3Fzc+PZZ18gNLR7XTdL1DA7Rw3BgzpxeN1emt/TBl1WAYpZwWwyU3KhCIerLLJjLC3DbDJj71pxjIqNnQ0Ons4UpOfiGuBJYXouTt5abOxtsbGzRaVWYaOxRW2jxlx2fdPSNyRGs5kCgwEnW1tWpxxCpVJRWGagVyNfwhv7oTeZiPAPICU/r0JdvcnE12fTLYHh79tGtGjJtj/PWcoKywyUmIy8e+wIJUYjA5o0pb1H1dcNEtYuH5tw7ty5CishX4mEBFHvnDlzilWrXufMmdP06XM3Y8Y8arU8uGjYnLy1NO4eyKnvUtBoHUjZsB9jSRlN72xZ4TbC5UrzirF3sw4IeSezKc4spGmvFrS8vwOnvjuMYlawd3OkWb/W5R+CZ/P5I2EPmBW82/vh6HV7fa8dL7jIisMHKSorQ6WCXj6NUatUXDQYeKZjZ8woLP79Nzp7eeHl4IAXDpWGhKTsLDp7eaG1s6uwralzxXBnNCvc7deEvo2bUGws441DB2mm1eJiJ4ui3aymTZty8uTJKu0rIUHUG0ajkU8/3cTmzRtwcXHlmWdm0L17j7pulqhhboFeltsAl/jf2RKXpu5kJqdbPfVwuYA+IVavtX5utBkaal3m64rufAFQ/gREh3/1rHCcFhHtb6L19d+l2w26sjJWHzmMp3357ZzmLi6WcQmNnZzIKdVf9QP8wIVs/n3ZbYtrcbWz406fxtioVLjYaWjq7ExWSamEhBv09NNPW27bZGVlXXMNpkskJIh6IS3tNKtWvcHp0yfp3bsv//73o7i4yHLf4uYoQJOwoLpuRr3gbGfHv1qGsDLlEEMCm3OuWIdZUTCazZwvLsbb4crjNEqMRoyKGQ/7K48X+btjBRf5+XwGE9u0Q28ycb64GF9HeZz5Ro0YMcLytb29PR06VG0QroQEcUszmUxs3bqZjz9ej1brzNNPT6dHj4p/7YnbT2U9DNdLc5VBjqKixk5O9G3sx+Yzp3DTaHjryGGKjUbubepf6W2ES7JLS/C0tw4RKfl5nCvWcU8T/0rrtHX34MjFfF47+DsqlYp/BDS76nvUJzk5OTz88MO899572NraMn36dFQqFSEhIcyePRuA2NhYsrOziYuLo3fv3qSnpxMfH1/lSZD+zs/Pjx9++AG9Xg/A3r17mTBhwjXrSUgQt6z09DRWr36DkydT6dUrnLFjJ+LqKr0HQtSWYFc3gl3drMrubepPkIsLv2Set3rq4XIR/s2sXjfTujC+VRurMn9nZ87qdFZlI1ta3yIaEtjwennKysqYNWsWDv/reVm4cCFxcXGEhYUxa9Ystm3bRpMmTWjatCkLFy5k+vTp9O7dm1WrVjFlypQbft9JkyZx3333XffvUAkJ4pZjMpn4/PNP2bhxHY6OTsTFTaVnz9513SwhRDXr59ekrptQrTIyMjCZTFZlrq6uVh/MixYtYsSIEbz9dvlj2ocOHaJHj/KxVX379mXXrl2MHj0avV5PaWkpTk5OHDhwgObNm9/UKsh+fn5Mnjz5uutJSBC3lHPnzrJ69Rukph6jR49ejB//GG5u7nXdLCHEZSrrYbheDXEA4qhRozh37pxVWWxsrOXDefPmzXh6etKnTx9LSFAUxTKg0NnZmcLCQoKCgvD19eWVV15h0qRJvP7660ydOpXZs2fj5uZGXFwc6qtMZlWZfv36sWTJEoKDgy1lDz300DXrSUgQtwSTycRnn21hw4a12Ns78OSTU+jVK1wmURFC1Btr166ttCfhkk2bNqFSqdi9ezcpKSlMmzaN3Nxcy3adTmfZ/4knngDgs88+Y8CAAWzYsIFhw4axd+9edu/eTe/e19e7+uWXX9KiRQtOnDgBUOXfrRISRJ0zll4kLi6Ow4cP0717Dx59NAZ3d1lpTwhRv/j5+V11+9q1ay1fR0dHM2fOHBYvXkxSUhJhYWHs2LGDnj3/Gpit1+v59ttveeONN5g/fz42NjaoVCqKi4uvu20ajYYXX3zxuutJSBB1RlHMFGcdpujcAQxaJ2Jjn6J3777SeyCEuG1MmzaNmTNnsnTpUlq0aMHAgQMt2+Lj44mOjkalUjF06FBmzZqFVqtl5cqV1/0+TZo04a233qJdu3aW37GywJO4ZRlLCyg48zNlRZlo3AL4zzuvYjY3vHuUQghRmYSEBMvXa9asqXSfiRMnWr5u27YtGzduvOH3MxqNnD59mtOnT1vKbrmQkJSURFxcnGXghE6nw9/fnyVLlqDRVPyAeOqpp7hw4QJQPtd0586dWbZsmWW7oij07duX5s2bA9ClSxemTJnC9u3bWblyJba2tgwdOpTIyMiaPzlRJYqiUJKdQuHZfajUNrg274ODZzBeXl5kZxfWdfOEEKJButHVIGu9J6Fnz55WH/SXPtQjIiIq7Htpv4sXLzJ69Giee+45q+1paWm0b9+eN99801JWVlbGwoUL+fjjj3F0dCQqKor+/fvf1KMjonoY9QUUnN5JWdF5NK7+uAb2xkZz5QV5hBBCVI96uQqkwWAgKysLNzc3xo4di1qtJjs7m+HDhzNq1CjLfsuXL+df//oXPj4+VvUPHTpEZmYm0dHRODg48Nxzz2EwGGjWrBlubuWP53Tr1o19+/Zx//33W+oVFBRQUFBgdSyNRlPh+KJ6lPceHKHo3D5AhWtgOA5eITL2QAghakm9WQVyz549REdHk5OTg1qtJjIyErVaTWZmJlu2bMFsNjNo0CAiIiLw8vIiJyeH3bt3V+hFAGjUqBETJ07k/vvvZ//+/UydOpXnnnsOFxcXyz7Ozs4UFRVZ1YuPj69wgUJDQ/noo4/wuMpSs+L6mfSFFJzZiaEwA41r0//1HlS+il6jRi6VlouaJ9e+bsn1rzu347W/pVeBvHS7IS8vj3HjxuHvXz5vd9euXS3jEkJCQkhLS8PLy4uvv/6af/7zn9jY2FQ4VocOHSzl3bt3JysrC61Wi+6yqT51Op1VaAAYM2YMQ4YMsSq79N55eTqMRvNNnePt+E33d4qiUHLhKEVn9wIqXAJ74+jV6qq9B9U1JkGu//WrzvEgcv2vn3zv153quPa2tupb/g/MercKpIeHB4sXL2b06NHMmDGDlJQUTCYTBoOB1NRUAgMDAdi9ezcxMTGVHmPFihW4u7szYcIEjhw5gp+fHy1btuTMmTPk5+fj5OTE/v37GT9+vFW9v0+TKaqXyVBEwemdGAr/ROPih2tgH2zsK+89EEIIUfPq5SqQwcHBREdHM2/ePHx8fJgwYQL5+fnExMTg6ekJwKlTpwgICLCqFx0dTUJCAhMnTmTq1Kn89NNP2NjYsHDhQuzs7Jg+fTrjx49HURSGDh2Kr69vXZzebUdRFEpyjlGUvhdQcGl2J47erWXsgRBC1KH169czdOhQbG1t2b9/P4cPH6Zz585VqlurISEsLIywsDCrspiYGEJDQ0lMTLR66uGSL774okJZmzblq4m5ublZ5r++XP/+/enfv381tVpUhcmgKx97UHAOOxc/3ALDsbGXrk8hhKhLy5cv5/jx4wwePBhbW1saN27MBx98QE5ODrGxsdesXy8nUxo3blxdN6HOKWYTp/+7FUNxPmazCb9Wfcg9d5Cy0vJBmobifJw9/WnRfailjtFQwqkDn2Ay6rHVOBLYZRB29s78eeQnCrJScWvcCr9WfVDMZk7u30SLO4aiUl19ERFFUSjNOU7h2b0oihmXgJ44NmorvQdCCHEL2LFjBxs2bLD8Tvb392fZsmWMGDGi/oSEynoYruZa82PfDnLS/8BW40RQtyEYDSUc/vEtOt0XB5SHgWO7PiSgw31Wdc4f+xmtVwB+rfpQkHWSc4e307zrIAqzT9Km73iO7vwAv1Z9yD59AO/ALtcMCCZD8f96D85ip/XFtXkfbO1lrIcQQtwqnJycKvzRZmdnh7Nz1QZaXt9ak+KW4dG0HU3a3P2/V4rVB/qfR37Cp0UP7Bysu/tLCi/g5lM+26XWK4Ci3DQAVGobFMUMKhWmslJ0eem4+YZc8b3Lxx6kknN4M4bCDFwCwvBo9YAEBCGEuMU4ODiQnp5uVZaeni6rQDZ0Nrblj2yayvSc2LeRpm37AVCm11F44RQBHe+rUMfJzZf888dwcvcj//wxzKYyABoF9eDk/k34tujJ+eO78G3Zi7OHvsdsNODXui92Dn89mWAqK6bwzC/oL6Zh5+xT3nvgcHPrygshhKgZzzzzDJMmTaJXr14EBATw559/snPnThYtWlSl+tKTUI8ZSi5ybNeHePl3wtO/IwB5fx7Gs2mHSm8VNA4Jx1Ccz9GdH2AozkfjWP6Xv0eTNrS84xEcXX0wlekpM+iwtXfCq1kXsk7uBf7Xe5B7gpxDn6AvOIfWvwcerR+QgCCEELewkJAQ1q1bR7t27SgpKaF9+/Z89NFHtGvXrkr1pSehniorLeL4L2sJ6BSBa6MWlvLC7FP4tepTaZ2inDN4Nw9F6xlA3p8paD2tHy3NOPYzTdv2oyj3XHnIUIHZZMBUVkJh2i/o889g59wI1+Z9JRwIIUQ94eLiwkMPPXRDdSUk1FPnj+/EWFZCxtGfyTj6MwAhvUZSWpSDxtnDat+jO+NpHT4Ge603p3/dAoCdowvNuwy27FOUm47GyQ07BxdcfVpwIimRvHOHaBzUhZxDm1HMRrRN78DJt/01BzQKIYRoGCQk1FMBHSMI6Fhx5cz2/SvOTunk1hgAB60nbfpW/vio1jPA0rNgY6shuMcjFKTvRp/1G7ZO3rg174uto3v1nYAQQohbnoSE24BvcM/r2r807zQFab+gmAxom3bDybej9B4IIcRtSELCbUDjWLXxA2ZjKQVpu9HnncLWyQu35vdj6+hx7YpCCCEaJAkJAoDS/DMUntmF2WTAuUkozo07Se+BEELc5iQk3EYMhRlcPL0Dt+Z90biUz1ppNuopTN9Dae4JbB09cQ+JwM7Js45bKoQQ4lYgIeE2YSjMIC/1WzCbyEv9Fo/g+1BMZRSc2YXZWIqzX1ec/TpL74EQQggLCQm3gcsDAlAeFI59DSjYOnrgHnIfdk5eddpGIYQQtx75s7GBqxAQLBRAhbbpHRIQhBBCVEpCQgN25YBwiUL+yW0YCjNqtV1CCCHqBwkJDdjF0zuuEhD+x2wq308IIYT4GwkJDZhb876gtrn6Tmqb8v2EEEKIv5GQ0IBpXPzwCL7vykFBbYNH8H2WxyGFEEKIy0lIaOCuGBQkIAghhLgGCQm3gQpBQQKCEEKIKqjVeRKSkpKIi4sjODgYAJ1Oh7+/P0uWLEGj0VTY//Dhwzz22GM0b94cgKioKB544AHL9tLSUqZOnUpOTg7Ozs4sWrQIT09Ptm/fzsqVK7G1tWXo0KFERkbWyvndyi4Fhb/PuCiEEEJcSa1PptSzZ0+WLVtmeT1lyhS2b99ORETFZY8PHTrE2LFjGTeu8uWNP/roI1q1asXkyZP54osvWLVqFdOmTWPhwoV8/PHHODo6EhUVRf/+/fH29q6xc6ovNC5+NOo4vK6bIYQQop6o09sNBoOBrKws3NzcGDt2LOPHj2fw4MGsXbsWgIMHD/Ljjz8yatQoZsyYQVFRkVX9AwcO0KdPHwD69u3L7t27OXHiBM2aNcPNzQ2NRkO3bt3Yt29frZ+bEEIIUd/Vek/Cnj17iI6OJicnB7VaTWRkJGq1mszMTLZs2YLZbGbQoEFERETQqVMnHnnkETp06MDq1atZuXIl06ZNsxyrqKgIFxcXAJydnSksLLQqu1T+93BRUFBAQUGBVZlGo8HHx6cGz1wIIYSoX+rsdkNeXh7jxo3D398fgK5du1rGJYSEhJCWlsa9996Lq6srAPfeey9z5861OpZWq0Wn0wHl4xtcXV2tyi6VXx4aAOLj41mxYoVVWWhoKB999BEeHs7Ve8Kiyho1crn2TqJGyLWvW3L9645c+6urswWePDw8WLx4MaNHj2bGjBmkpKRgMpkwGAykpqYSGBjI+PHjmTlzJp06dWL37t20b9/e6hihoaH89NNPdOrUiR07dtCtWzdatmzJmTNnyM/Px8nJif379zN+/HiremPGjGHIkCFWZZcCSl6eDqPRfFPnJt90NyY7u7BajiPX//pV17UHuf43Qr736051XHtbW3WD/QOzTleBDA4OJjo6mnnz5uHj48OECRPIz88nJiYGT09P5syZw9y5c7Gzs8Pb29vSkxAdHU1CQgJRUVFMmzaNqKgo7OzsePXVV7Gzs2P69OmMHz8eRVEYOnQovr6+Vu/r6upq6aEQQgghROVqNSSEhYURFhZmVRYTE0NoaCiJiYlWTz0AtG/fnsTExArHadOmDQCOjo688cYbFbb379+f/v37V2PLhRBCiNtPvZxM6UqPRAohhBCi+tTp7YZLKuthuBo/P5kISAghhKhp9bInQQghhBA1T0KCEEIIUQvKysqYOnUqI0eOZNiwYWzbto0zZ84QFRXFyJEjmT17NmazGbPZzKRJk3jkkUfYtWsXAOnp6cybN6/W2ywhQQghhKgFW7duxd3dnXXr1vHuu+8yd+5cFi5cSFxcHOvWrUNRFLZt20ZKSgpNmzbl3XffZc2aNQCsWrWKxx9/vNbbfEuMSRBCCCHqu4yMDEwmk1XZ5Y/cR0REMHDgQAAURcHGxoZDhw7Ro0cPoHx5gV27djF69Gj0ej2lpaU4OTlx4MABmjdvXidrEElPghBCCFENRo0axYABA6z+xcfHW7Y7Ozuj1WopKiriySefJC4uDkVRUKlUlu2FhYUEBQXh6+vLK6+8wqRJk4iPj+eBBx5g9uzZLF26FLP55ib8ux7SkyCEEEJUg7Vr11bak3C5jIwMnnjiCUaOHMmgQYNYvHixZdul5QUAnnjiCQA+++wzBgwYwIYNGxg2bBh79+5l9+7d9O7du4bPppz0JAghhBDVwM/PD39/f6t/l4eECxcuMG7cOKZOncqwYcMAaNeuHUlJSQDs2LGD7t27W/bX6/V8++23DB48mJKSEmxsbFCpVBQXF9faOUlIEEIIIWrBm2++SUFBAatWrSI6Opro6Gji4uJYvnw5w4cPp6yszDJmAcoXI4yOjkalUjF06FBmz57Nzz//XGu9CCC3G4QQQoha8cILL/DCCy9UKL/0BMPfTZw40fJ127Zt2bhxY4217UqkJ0EIIYQQlZKQIIQQQohKSUgQQgghRKUkJAghhBCiUhIShBBCCFEpCQlCCCGEqJSEBCGEEEJUSkKCEEIIISolIUEIIYQQlZKQIIQQQohKSUgQQgghRKVqde2GpKQk4uLiCA4OBsqXxfT392fJkiVoNJoK+6ekpDB37lxsbGzQaDQsWrQIb29vq32GDBmCVqsFwN/fn4ULF5KcnMz8+fOxsbEhPDyc2NjYmj85IYQQooGp9QWeevbsybJlyyyvp0yZwvbt24mIiKiw7/z585k5cyZt27YlMTGRd955h+eee86yXa/XoygKCQkJVvVmz57N8uXLCQgIYOLEiRw+fJh27drV3EkJIYQQDVCdrgJpMBjIysrCzc2NsWPHolaryc7OZvjw4YwaNYqlS5fi4+MDgMlkwt7e3qr+kSNHKCkpYdy4cRiNRp5++mmCg4MxGAw0a9YMgPDwcH755RerkFBQUEBBQYHVsTQajeW9hBBCCFEHIWHPnj1ER0eTk5ODWq0mMjIStVpNZmYmW7ZswWw2M2jQICIiIiwf2r/++itr1qxh7dq1VsdycHBg/PjxPPLII5w+fZoJEyawZs0ay+0HAGdnZ9LT063qxcfHs2LFCquy0NBQPvroIzw8nGvozMW1NGrkUtdNuG3Jta9bcv3rjlz7q6uz2w15eXmMGzcOf39/ALp27WoZlxASEkJaWhpeXl58+eWXrF69mrfffhtPT0+rYwUFBREYGIhKpSIoKAh3d3dMJhM6nc6yj06nw9XV1aremDFjGDJkiFXZpffOy9NhNJpv6hzlm+7GZGcXVstx5Ppfv+q69iDX/0bI937dqY5rb2urbrB/YNbZ0w0eHh4sXryYF154gezsbFJSUjCZTJSUlJCamkpgYCCffvopa9asISEhgYCAgArH+Pjjj3n55ZcByMzMpKioCF9fX+zs7EhLS0NRFHbu3En37t2t6rm6uuLv72/1T241CCGEENbqdExCcHAw0dHRzJs3Dx8fHyZMmEB+fj4xMTG4ubkxf/58/Pz8mDx5MgB33HEHTz75JE899RQzZsxg2LBhPPfcc0RFRaFSqViwYAG2tra8+OKLPPPMM5hMJsLDw+ncuXNdnqYQQghRL9VqSAgLCyMsLMyqLCYmhtDQUBITE62eegDYu3dvpccJCAjA2dkZjUbDq6++WmF7ly5d2LBhQ/U1XAghhLgN1cvJlEaMGIGTk1NdN0MIIYRo0Or0dsMllfUwXE2TJk1qsDVCCCGEgHrakyCEEEKImichQQghhBCVkpAghBBCiEpJSBBCCCFEpSQkCCGEEKJSEhKEEEIIUSkJCUIIIYSolIQEIYQQQlRKQoIQQgghKiUhQQghhBCVkpAghBBCiEpJSBBCCCFEpSQkCCGEEKJSEhKEEEIIUSkJCUIIIYSolIQEIYQQQlRKQoIQQgghKiUhQQghhBCVkpAghBBCiErZ1uabJSUlERcXR3BwMAA6nQ5/f3+WLFmCRqOpsP+ZM2eYPn06KpWKkJAQZs+ejVr9V64pLS1l6tSp5OTk4OzszKJFi/D09GT79u2sXLkSW1tbhg4dSmRkZK2doxBCCHElZrOZOXPmcPToUTQaDfPmzWPv3r1s3LiRdu3aMWfOHACmTJnCiy++iFarrdP21npPQs+ePUlISCAhIYHNmzdjZ2fH9u3bK9134cKFxMXFsW7dOhRFYdu2bVbbP/roI1q1asW6det46KGHWLVqFWVlZSxcuJD33nuPhIQE1q9fz4ULF2rj1IQQQoir+v777zEYDKxfv54pU6bw8ssv8+mnn5KYmEhmZiYXL17kxx9/pFu3bnUeEKCWexL+zmAwkJWVhZubG2PHjkWtVpOdnc3w4cMZNWoUhw4dokePHgD07duXXbt2ce+991rqHzhwgEcffdSyfdWqVZw4cYJmzZrh5uYGQLdu3di3bx/333+/pV5BQQEFBQVWbdFoNPj4+GBjUz25qVXzRtVynNuJrW31ZVbnpsHVdqzbQXVee4AQn6BqPV5DV53X3yNEvvevR3Vc+0ufGxkZGZhMJqttrq6uuLq6Wl4fOHCAPn36ANClSxcOHjxI69atKSsrw2QyoVar2bRpE8uWLbvpdlWHWg8Je/bsITo6mpycHNRqNZGRkajVajIzM9myZQtms5lBgwYRERGBoiioVCoAnJ2dKSwstDpWUVERLi4uVtsvL7tUXlRUZFUvPj6eFStWWJWNGDGCF198EVdXx2o5zzmT7quW49xOPDycq+1YbUZNr7Zj3Q6q89oDPP+PuGo9XkNXnde/18znq+1Yt4PqvPZPP/00v/76q1VZbGwskydPtrwuKiqy6iGwsbHh8ccf59lnn+Xee+9l69atDB06lHfffZeMjAzGjBlDixYtqq2N16vWQ0LPnj1ZtmwZeXl5jBs3Dn9/fwC6du1qGZcQEhJCWlqa1fgDnU5nlcYAtFotOp3OavvlZZfKLw8NAGPGjGHIkCEV2lZcXIyTk1P1nKgQQojbRlFREYsXL65QfrXPLSgfo9C9e3e6d+9OYWEhs2fPplevXuzYsYP/+7//Y/78+bz66qs13v4rqbOnGzw8PFi8eDEvvPAC2dnZpKSkYDKZKCkpITU1lcDAQNq1a0dSUhIAO3bsoHv37lbHCA0N5aeffrJs79atGy1btuTMmTPk5+djMBjYv38/Xbt2tarn6uqKv79/hX8SEIQQQtwIrVZb6efK30NCaGgoO3bsACA5OZlWrVpZtr399ttMnDiR0tJS1Go1KpWK4uLiWj2Pv6vTMQnBwcFER0czb948fHx8mDBhAvn5+cTExODp6cm0adOYOXMmS5cupUWLFgwcOBCA6OhoEhISiIqKYtq0aURFRWFnZ8err76KnZ0d06dPZ/z48SiKwtChQ/H19a3L0xRCCCEAuPfee9m1axcjRoxAURQWLFgAwNmzZykoKKBNmzaYzWYyMjKYOHEicXFxddpelaIoSp22gPJHIxMTE6s8UGP+/Pk8/7zcdxNCCCFqUr2cTGncuHF13QQhhBCiwbslehKEEEIIceuplz0JQgghhKh5EhKEEEIIUSkJCUIIIYSoVJ0+Aimq39tvv80vv/yC0WhEpVIxbdo0OnToUNfNuq1cz//B+vXrefjhh7Gzs6vlVjYcL7/8MocOHSI7O5vS0lICAgI4fvw4vXr1umWmtr2dnD17lsGDB9O+fXtLWVhYGLGxsZbXTz31FIsWLap0YT9xi1FEg3H8+HFl+PDhitlsVhRFUQ4fPqwMGjSojlt1e7ne/4N+/foppaWltdW8Bm3Tpk3K4sWLFUVRlD179ihxcXF13KLbU3p6uvLII4/UdTNENZHbDQ2Ii4sLf/75Jx9//DGZmZm0bduWjz/+mOjoaE6cOAGUr5y5fPlyzp49y/Dhw/m///s/Hn74YWbPnl3HrW8YrvR/sHfvXkaPHk10dDQPP/wwp06dYuPGjWRnZ/PUU0/VdbMbpDNnzvDoo4/y8MMPs3z5coAr/iwMGjSI6Oho3nnnnbpscoOVlJTEI488wsiRI9myZQv9+/dHr9fXdbNEFcjthgbE19eX1atXs2bNGlauXImDg8NVP4BOnz7Nf/7zHxwdHbnnnnvIzs6mUSNZvfJmXOn/4MKFCyxevBhfX1/efPNNvv76a2JiYli9erV0idcQvV7PqlWrMJlM3H333VaL7PxddnY2mzZtku7vapKamkp0dLTl9SOPPIJer2fjxo0AvPHGG3XVNHGdJCQ0IGfOnEGr1bJw4UIA/vjjDyZMmGD1wa9cNi1Gs2bNLKuRNWrUSJJ9NbjS/8G0adOYP38+Tk5OZGZmEhoaWsctbfhCQkIsH/q2thV/1V3+s+Dv7y8BoRoFBweTkJBgeZ2UlERQkCwfXh/J7YYG5OjRo7z00ksYDAYAgoKCcHV1xd3dnezsbAAOHz5s2f/SMtyi+lzp/2DBggUsWLCAl19+GR8fH8sHlEqlwmw212WTG6zKvr81Gk2lPwuXrzgraoZc4/pJehIakPvuu48TJ04wbNgwnJycUBSFZ599Fjs7O1588UWaNGmCj49PXTezQbvS/8G+ffsYNWoUjo6OeHt7k5WVBUD37t2ZOHEiH374oYS2WjB69Gj5WRDiOsi0zEIIIYSolPT/CCGEEKJSEhKEEEIIUSkJCUIIIYSolIQEIYQQQlRKQoIQQgghKiUhQQhRgV6vp3///nXdDCFEHZOQIIQQQohKyWRKQggAdDodzzzzDAUFBTRr1gyAvXv3smLFChRFQafT8eqrr7J3715Onz7NtGnTMJlMPPTQQ3z88cfY29vX8RkIIaqb9CQIIQBITEykVatWrF27lhEjRgBw/PhxFi9eTEJCAvfddx9ff/01//jHP9i2bRsmk4mff/6ZsLAwCQhCNFDSkyCEAMpXBb3rrrsA6Ny5M7a2tvj6+lZYmEqr1XLHHXewc+dONm/ezKRJk+q45UKImiI9CUIIAFq2bElycjJQvviR0Whk5syZlS5MFRkZycaNG8nJyaFNmzZ12GohRE2SngQhBABRUVE8++yzREVF0aJFC+zs7Lj33nsrXZiqc+fOnDlzhlGjRtVxq4UQNUkWeBJCXDez2UxUVBT/+c9/0Gq1dd0cIUQNkdsNQojrkp6ezpAhQ3jggQckIAjRwElPghBCCCEqJT0JQgghhKiUhAQhhBBCVEpCghBCCCEqJSFBCCGEEJWSkCCEEEKISklIEEIIIUSl/h/fa0vdVhME+AAAAABJRU5ErkJggg==\n", + "image/png": "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", "text/plain": [ "
" ] @@ -8705,13 +8845,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='paretoplot', \n", + "ax = plot2d(plot='paretoplot', \n", " df=tips, \n", " x='day',\n", " y='total_bill',\n", @@ -9223,13 +9363,13 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 33, "id": "f6479452", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -9239,13 +9379,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='regplot', \n", + "ax = plot2d(plot='regplot', \n", " df=tips, \n", " x='tip', \n", " y='total_bill', \n", @@ -9257,13 +9397,13 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 34, "id": "791fb6f1", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAFDCAYAAAAeSfYfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABZnklEQVR4nO3deWBU5b34//esySSThKxsWVACouwQDK1B64KltkhbNYAY7iUIhd8Xe1HwiyIIlgTxgmCLSr/drt9GFMT2S2+vtnVBTdlSFiOyBA0ISViSYUggM5n9nN8fQwZiAgTIJJPJ5/UP5pwzZ54Pg/PJ85zneT4aVVVVhBBCCBFytB3dACGEEEK0TJK0EEIIEaIkSQshhBAhSpK0EEIIEaIkSQshhBAhSpK0EEIIEaIkSQvRwVwuF5s2bbriNbt27aKsrOyy5//85z+zatWqy55fu3Ytb7/9drPjc+bMASAvL48jR45c9rprdfLkSbZs2QJAYWEhJ0+evOF7NnrzzTfb7F5ChDpJ0kJ0MIvFctUk/ac//Ymampo2f+9XX321ze8JsHPnTvbu3QvAc889R69evdrs3uvWrWuzewkR6vQd3QAhurpf//rXlJeX8+qrrzJ16lSefvppbDYbPp+P//iP/yAmJoZ//vOfHDhwgMzMTLZs2cIHH3yAw+EgPj6+1Yn2o48+4m9/+xtOp5NFixYxZMgQ7rjjDrZt23bF1/30pz/lV7/6Fampqfz9739n9+7d/OAHP+Cll15Cr9djMpn45S9/idlsBsDn8/Gb3/wGp9PJ8OHDeeONN1i6dCnvv/8+R48exWq1cv78eRYtWkRWVlbgfUpKSli1ahUGg4Hc3FwiIyNZv349Xq8XjUbDq6++ysaNGzl37hxLly7lueeeY8mSJRw/fhxFUZg7dy7Z2dnX/0EIEYKkJy1EB5s1axaZmZnMmTOHdevW8d3vfpf169fzy1/+kueee46BAwcyZswYnn76aXr06EFdXR1vvPEGmzZtwufz8eWXX7bqfXr37s0f//hHCgsLWbJkSavb9/DDD7N582bAP6yem5vLRx99xA9+8APefPNNJk+ezPnz5wPX63Q6Zs6cyY9+9CPuvffeJveKjIzkj3/8IytXruQXv/hFs/dyuVy89dZb/PjHP+bYsWP85je/4e233yYzM5OtW7cye/Zs4uLiWLp0KZs2bSI+Pp7169fz+uuvt3g/ITo76UkLEUKOHDnC+PHjAejevTtmsxmr1Ro4r9VqMRgMPPXUU0RFRXH69Gm8Xm+r7j1q1CgA+vXrh8ViaXWbxo8fz6OPPsojjzyCzWajf//+zJo1i1//+tf827/9G927d2fIkCGtutfo0aMDbThz5kyz8zfddFPgvxMTE1mwYAHR0dEcPXqUYcOGNbn2q6++Ys+ePezbtw8Ar9fL2bNnSUhIaHVsQoQ66UkL0cG0Wi2KogDQt29fdu/eDUB1dTXnz5+nW7duaDQaVFWlrKyMjz76iFdeeYXFixejKAqt3X6/MZkdPnz4mp4Rx8TEMGjQIF588UV++tOfAvDf//3f/OQnP6GoqIh+/frxzjvvXDamSx04cADwJ9ju3bs3O6/V+r+S6uvr+dWvfsWaNWsoKCggIiIiEGfjnzfffDM//OEPKSoq4re//S3jxo2jW7durY5LiM5AetJCdLDExEQ8Hg8rV67kZz/7GQsXLuQf//gHTqeTX/ziF+j1eoYOHcqqVatYvXo1JpOJSZMmAZCcnNzqCWVVVVVMnToVt9t9zUPDjzzyCI8//jjLly8HYMiQISxatAiTyYRWq212v/79+7Nu3ToGDhzY5PihQ4f4t3/7NxwOB8uWLbvs+5nNZkaMGMHEiRPR6/XExsYG4uzbty/z589n+fLlLFq0iMceewybzcajjz4aSPJChAuNVMESQrSHtWvXkpSUxOTJkzu6KUJ0GtKTFiKMzJkzh3PnzjU5ZjabZdmSEJ2U9KSFEEKIEBWUnnRJSQlz584lMzMTALvdTmpqKqtWrcJoNDa7/uDBg/zsZz+jT58+AEyePJkHHniAV199lU8//RS9Xs/ChQubzSDdsmULr732Gnq9noceeojc3FycTidPP/00VquV6OhoXnrpJZntKYQQolMK2nD36NGjWbNmTeDnefPmsWXLFsaNG9fs2gMHDjBt2jTy8/ObHPvXv/7Fpk2bOHXqFE888QR/+tOfAuc9Hg8vvvgi7777LiaTicmTJ3PPPffw17/+lf79+/PEE0/w3nvv8frrr7No0aJghSmEEEIETbs8k3a73dTU1BAXF8e0adPQarVYLBYmTpzIlClT2L9/P9988w0ff/wxGRkZLFy4kD179pCTk4NGo6FXr174fL4mayCPHDlCeno6cXFxAIwcOZJdu3axZ88eHn/8cQDuvPNOXn/99fYIUQghhGhzQUvSO3fuJC8vD6vVilarJTc3F61WS3V1NZs3b0ZRFMaPH8+4ceMYMmQIjzzyCIMGDWLdunW89tprxMTENFnzGB0dTX19fSBJ22w2YmJimpy32WxNjje+RgghhOiMgj7cXVtbS35+PqmpqQAMHz488Fy6X79+VFRUMHbsWGJjYwEYO3Ysy5Yt495778VutwfuZ7fbmyRls9nc4vlLj9vt9sB9W6u21o6ihO9cusREM1arraObEVQSY3iQGMNDV4hRq9UQHx8dlHsHfbg7Pj6elStXMnXqVBYuXMihQ4fw+Xy43W7Ky8vJyMhg+vTpLF68mCFDhrBjxw4GDhzIiBEjWLlyJdOnT+f06dMoitJkAljfvn05fvw4dXV1REVFsXv3bqZPn87Jkyf57LPPGDJkCMXFxYwcOfKa2qsoalgnaSDs4wOJMVxIjOGhK8QYLO3yTDozM5O8vDwKCgpISUlhxowZ1NXVMXv2bBISEli6dCnLli3DYDCQlJTEsmXLMJvNZGVlMXHiRBRF4fnnnwf8G/yDvzLPM888w/Tp01FVlYceeoju3bszefJkFixYwOTJkzEYDLz88svtEaIQQgjR5tp1nXRJSQkbNmxoMuv7WpWVlbF//34efvjhNmzZRVarLax/60tOjsFiCe/n9BJjeJAYw0NXiFGr1ZCYaA7OvYNy1yDq1q0bDz30UEc3QwghhAi6dt0WNDs7+4aLsvfo0aONWiOEEEKEtk7XkxZCCCG6CknSQgghRIiSJC2EEEKEKEnSQgghRIiSJC2EEEKEKEnSQgghRIiSJC2EEEKEKEnSQgghRIiSJC2EEEKEKEnSQgghRIiSJC2EEEKEKEnSQgghRIiSJC2EEEKEKEnSQgghRIiSJC2EEEKEKEnSQgghRIjSB+OmJSUlzJ07l8zMTADsdjupqamsWrUKo9F42df99a9/5c0332Tjxo0AFBQUsHfvXqKjowF4/fXXiYmJCVxfWlpKYWEhOp2OnJwc5syZg6IoLF26lMOHD2M0GikoKCAjIyMYYQohhBBBFZQkDTB69GjWrFkT+HnevHls2bKFcePGtXj9wYMHeffdd1FVNXDswIED/O53vyMhIaHF1yxZsoS1a9eSlpbGzJkzOXjwIFVVVbjdbjZu3EhpaSkrVqxg3bp1bRucEEII0Q7aZbjb7XZTU1NDXFwc06ZNY/r06Tz44IOsX78egNraWlavXs3ChQsDr1EUhePHj/P8888zadIk3n333Sb3tNlsuN1u0tPT0Wg05OTksH37dvbs2cOYMWMAGDZsGPv372+PEIUQQog2F7Se9M6dO8nLy8NqtaLVasnNzUWr1VJdXc3mzZtRFIXx48fz/e9/n+eff55nn32WiIiIwOsbGhp47LHHmDZtGj6fj6lTpzJo0CAGDBgA+JO02WwOXB8dHU1lZWWz4zqdDq/Xi17fulATE81Xv6iTS06OufpFnZzEGB4kxvDQFWIMlqAPd9fW1pKfn09qaioAw4cPDzyX7tevH0ePHuX48eMsXboUl8tFeXk5hYWFPPPMM0ydOhWTyRS4X1lZWSBJm81m7HZ74P3sdjuxsbE4nc4mxxVFaXWCBrBabSiKevULO6nk5BgslvqObkZQSYzhQWIMD10hRq1WE7QOXtCHu+Pj41m5ciWLFi3CYrFw6NAhfD4fDoeD8vJyMjMzee+99ygqKmL16tVkZmby3HPPcezYMSZPnozP58Pj8bB3714GDhwYuK/ZbMZgMFBRUYGqqmzdupWsrCxGjBhBcXEx4J9Y1r9//2CHKIQQQgRF0HrSl8rMzCQvL4+CggJSUlKYMWMGdXV1zJ49+7KTwvr27cuECRPIzc3FYDAwYcIE+vXrR3FxMWVlZcycOZMXXniB+fPn4/P5yMnJYejQoQwePJht27YxadIkVFVl+fLl7RGiEEII0eY06qXTqYOspKSEDRs2NJn1fa2sViubNm1i1qxZbdiyS+8vw92dncQYHiTG8NAVYuzUw91tTVVV8vPzO7oZQgghRNC1y3B3o+zsbLKzs2/oHklJSW3UGiGEEMEWziOT7aHT9aSFEEJ0Dl8cOcOiX2/j0PGzHd2UTqtde9JCCCHCn4qKzeHlL//8hmOn63G6vNya0fIkYXFlkqSFEEK0CY0GXG4f5x1uvF4Vl8cHgNPt6+CWdV6SpIUQQtwwRVWxNXhwuLy035qh8CdJWgghxA1QcXoU6u1ufDJJrM1JkhZCCHFdfIpCfYNHhrODSJK0EEKIa6ICDpcXm8MjS6yCTJK0EEKIVvP4/L1nt0d6z+1BkrQQQoirUlGxO73YHR6ZGNaOJEkLIYS4LP+yKoXzDhder2Tn9iZJWgghRItkWVXHkyQthBDiW/zLqmx2N16ZGNahJEkLIYQIUBSF8w4PLpcPSc8dT5K0EEII/7IqtxdbgyyrCiWSpIUQoovz+lTqG9yBvbZF6JAkLYQQXZjN6aHB4UWRmWEhSZK0EEJ0QW6vQn2DG49X6eimiCsISpIuKSlh7ty5ZGZmAmC320lNTWXVqlUYjcbLvu6vf/0rb775Jhs3bgTgnXfeYcOGDej1embPns3dd9/d5PrS0lIKCwvR6XTk5OQwZ84cFEVh6dKlHD58GKPRSEFBARkZGcEIUwghOh1FVbE5ZFlVZxG0nvTo0aNZs2ZN4Od58+axZcsWxo0b1+L1Bw8e5N1330W98K/GYrFQVFTEn/70J1wuF48++ih33HFHkyS/ZMkS1q5dS1paGjNnzuTgwYNUVVXhdrvZuHEjpaWlrFixgnXr1gUrTCGE6BQ0Gn9d53pZVtWpaNvjTdxuNzU1NcTFxTFt2jSmT5/Ogw8+yPr16wGora1l9erVLFy4MPCaffv2MXz4cIxGIzExMaSnp1NWVhY4b7PZcLvdpKeno9FoyMnJYfv27ezZs4cxY8YAMGzYMPbv398eIQohRMjyKSp1Njd1Npck6E4maD3pnTt3kpeXh9VqRavVkpubi1arpbq6ms2bN6MoCuPHj+f73/8+zz//PM8++ywRERGB19tsNmJiYgI/R0dHY7PZmpw3m81NzldWVjY7rtPp8Hq96PWtCzUx0Xz1izq55OSYq1/UyUmM4UFivDGqqmJrcGNzeDBFR2CKjrj6i9qQTufvB+r12i7xWQZD0Ie7a2tryc/PJzU1FSDQOwbo168fR48e5fjx4yxduhSXy0V5eTmFhYWMHj0au90euJ/dbm+StM1mc7PzsbGxOJ3OJscVRWl1ggawWm1hvUYwOTkGi6W+o5sRVBJjeJAYb4xXUam3d+yyKp/PPynN61XC+rPUajVB6+AFfbg7Pj6elStXsmjRIiwWC4cOHcLn8+FwOCgvLyczM5P33nuPoqIiVq9eTWZmJs899xxDhgxhz549uFwu6uvrOXLkCP379w/c12w2YzAYqKioQFVVtm7dSlZWFiNGjKC4uBjwTyy79DVCCBHuVBXsTg9nzzll3XMYaJclWJmZmeTl5VFQUEBKSgozZsygrq6O2bNnk5CQ0OJrkpOTycvL49FHH0VVVZ588kkiIiIoLi6mrKyMmTNn8sILLzB//nx8Ph85OTkMHTqUwYMHs23bNiZNmoSqqixfvrw9QhRCiA4ny6rCj0ZV228SfklJCRs2bGgy6/taWa1WNm3axKxZs9qwZZfeX4a7OzuJMTxIjK2nomJzeGlwhk6t56Mnz/N//16Gx6uQGBvByv/vjo5uUtAEc7i7021moqoq+fn5Hd0MIYTocP5azz7ON7jx+kIjO1fV2PhgVyXlJ84FjoVGyzqndk3S2dnZZGdn39A9kpKS2qg1QgjReSmqSr3dg9MdGpuSnD7bwIe7Kjl0vDZwzKDX4vEqREcaOrBlnVun60kLIUTX5q/1XG934wuBR3Nnzjn4aHcVXx6xBnrMPROjGJuVxge7Kjh91tGh7evsJEkLIUQn4VMU6hs8ON0dP2u7zuZiy54q9n5lofF3heRukdyXlcbAmxLQajR8uLuyYxsZBiRJCyFEiFNVaHB7sTs6vtZzfYObT0tP8q+D1YGefHxMBPeOTGVoZhI6raZD2xduJEkLIUSI0mjA5QmNZVUNTi/FX5xkx4HTgbbERhn43ojeZN2Sgl7XLrtMdzmSpIUQIgQpqoqtoeOrVTndXrZ9eZqt+04FNkeJitBz1/BejL6tBwa9JOdgkiQthBAhxuH2YmvwdOjEMI9XYeeB03xWepIGlxeACIOOMUN7csegnkQYdR3Wtq5EkrQQQoQIr0+lvqFj99v2+hR2l9XwyecnqG/wAP6lVN8d1IMxQ3oRFSlpoz3J37YQQnSwUNgxzKeolH5t4eM9VdTZ3ADotBpuv6073xvWi5goY8c0rIuTJC2EEB1EVVWcHh+2DtwxTFFV9h89y0e7KzlzzgmAVgMjbknhnhG96WZu3/KWoilJ0kII0QF8isKZOifn6l0dsm2mqqocrqjjw92VnLI2AKABBvdN5L6sVJLiTB3QKvFtkqSFEKKd2Z0e7A4v3eJ1HZKgj5w4x4e7K6motgWO3dYnnvuy0uiRENUBLRKXI0laCCHagb8YhkK9w4XHq1JedY6SD78i+9YUMnvHtUsbKqrr+WBXJUdPng8c65cax9isNFJTglPFSdwYSdJCCBFkPkXF7my65vnjvVUcP12PrcEd9CR98oydj3ZXUlZRFziW0SOGsVlp3NwrNqjvLW6MJGkhhAgSFf+aZ3sLa57dF5ZZuYO43KqmzsHHuyv58ujZwLHeSdGMHZVGv9Q4NBrZwjPUSZIWQogg8Pj8xTCCmYQv5+x5J1v2VvH512cCPfeUeJO/+EWfeEnOnYgkaSGEaEOKqmJ3dsya5/N2N598foLdZTWBnntCTAT3ZqUytG8SWil+0ekEJUmXlJQwd+5cMjMzAbDb7aSmprJq1SqMxuYL4svLy1m8eDGqqtKnTx8KCgrQ6/UUFBSwd+9eoqOjAXj99deJiYkJvK60tJTCwkJ0Oh05OTnMmTMHRVFYunQphw8fxmg0UlBQQEZGRjDCFEKIAI0GnG4f9XY33nbeztPu9PBZ6Ul2HjgdWG8dF23k7hG9GXlLMjpt+++v7XR7aXB6A+1zuLyYIqRfeK2C9jc2evRo1qxZE/h53rx5bNmyhXHjxjW7dvXq1Tz11FOMGjWKZ555hk8++YSxY8dy4MABfve735GQkNDieyxZsoS1a9eSlpbGzJkzOXjwIFVVVbjdbjZu3EhpaSkrVqxg3bp1wQpTCCHwKSo2hweny9uuS6qcbi//3HeKbV+ewu3xV6aKNhn43rBe3H5r9w4rfnHs1Hn++I8yPF7/30adzc2817Yx95Gh9E/r1iFt6qza5dcat9tNTU0NcXFxTJs2Da1Wi8ViYeLEiUyZMoW1a9ei0+lwu91YLBbMZjOKonD8+HGef/55zpw5w8MPP8zDDz8cuKfNZsPtdpOeng5ATk4O27dvx2KxMGbMGACGDRvG/v372yNEIUQXpNGA40LvuT2LYbg9PnYcOE3xFydxuPzPvCONOu4c2ovvDOpBhKHjil+4PF7+/M+jdIuJpKbWAYCiqDjdPl7Z9AWr59xBpFF61K0VtL+pnTt3kpeXh9VqRavVkpubi1arpbq6ms2bN6MoCuPHj2fcuHEkJiZy4sQJpk2bhtlsZsCAATQ0NPDYY48xbdo0fD4fU6dOZdCgQQwYMADwJ2mz+eK6vujoaCorK5sd1+l0eL1e9PrWhZqYGP5rBZOTY65+UScnMYaHUI7R41U4Z3OhVTXEdbv2r1LdhfrLOp2WhIToVr/nP0tP8Pcdxzhv9++vHWHQce+oNO67PZ2oSMM1t6OtaACjXkdpuQVFVampdaB86xcXFThUdZ77s+URZGsFfbi7traW/Px8UlNTARg+fHjguXS/fv2oqKggMTGR3r1788EHH7Bp0yZWrFjB8uXLmTp1KiaTKXC/srKyQJI2m83Y7fbA+9ntdmJjY3E6nU2OK4rS6gQNYLXamv3DCifJyTFYLPUd3YygkhjDQ6jG2FbPnn0+JfDn2bP2K1+rKOz96gxb9lRx7kJy1us0jL6tB3cO64XZZMDZ4MbZ4L7u9lwvrVaDKUKPKUIHPpWvvrFy9pyrxWtdbh9HKs5iubnlR5idlVarCVoHL+gPLOLj41m5ciWLFi3CYrFw6NAhfD4fDoeD8vJyMjIymDVrFseOHQP8PWKtVsuxY8eYPHkyPp8Pj8fD3r17GThwYOC+ZrMZg8FARUUFqqqydetWsrKyGDFiBMXFxYB/Yln//v2DHaIQootQVJU6m5s6m6tdJocpqkpp+RleeWcf/6/4KOfsbrQaDbffmsK8ScN54DsZmE3t33vWAAa9hlizkaS4SGJMBvRaLaoK3ROiiDC0nFoiDFpS4mXb0WvRLg8GMjMzycvLo6CggJSUFGbMmEFdXR2zZ88mISGBmTNn8swzz2AwGDCZTIHrJkyYQG5uLgaDgQkTJtCvXz+Ki4spKytj5syZvPDCC8yfPx+fz0dOTg5Dhw5l8ODBbNu2jUmTJqGqKsuXL2+PEIUQYay9Z26rqsqh47V8uKuS6gvPdTUaGJaZxL0jU0mIjQx6G1qi1WgwGrRERRgwXiYRjxqQwoaPv27xnObCLxii9TSq2n4r+UpKStiwYUOTWd/Xymq1smnTJmbNmtWGLbv0/jLc3dlJjOEhVGJUVP/M7Uu39GwLa/+0j1PWBnomRvHEQ0MAf3L+uspf/OKE5eIQ+KCbE7hvZBop8R1TmUqv1RAZqcdk1KHXaa/69/BVZR2vbPoCl9uHir/nHWHUhe3s7mAOd3e6KXaqqpKfn9/RzRBChDl/QQwf59up1vM3p87z4a5Kjp2++IvJLendGJuVRq+k1k0sa0saDRj0OqIi9UQYtGjwb4TSml9U+qd1Y/WcO3jutyXU1rvoFhNB4YxsmdV9Hdr1byw7O5vs7OwbukdSUlIbtUYIIVqmonLe3va955a4vT7+6/1DfF11LnDspp6x3D8qjYwe7T+7XavVEGnUEWnUY9RrgOvbpSzSqMdsMlBb78JsMkiCvk7ytyaEEJdwexTOO1x4vcHNzh6vf3a39ZwL64XZ0KnJ0dw/Kp2+vWPbfX9tvVaDKVJPpFGPTrYPDRmSpIUQAn/v2eYI/p7b1nNOPt5TxZlzzsCxHglRjB2VxoD0bu2anC8d0o7swA1QxOVJkhZCdGn+Z8/B7z3X2Vx8svcEew7XcOnc1G5mI3MeGoy2HZOzVqMhwqjDFHFjQ9oi+CRJCyG6LEVVsTUE99lzfYObz0pPUnKwOrB1aDezEVWFc3Y3pgh9uyVo3YUhbZNR1yFFN8S1kyQthOiCVJweBVsQ1z07XF6KvzjJ9v2nA8+fY0wGvjeiN6MGpLBu8/7A7mHBpAH0eq1/SNuoC8zSFp2DJGkhRJfiVRRsdg9Ojy8o93e5fWzbf4qt+07hdPvfIypCz53DejF6YHeM+vZ59qvR+Pf1vtLGIyL0SZIWQnQJKip2p5cGhxclCGPbHq9CycFqPi09EaijHGHQkTOkJ3cM7tFuS5Au3Uvb0IqNR0RokyQthAhrgU1JHO6gTAzz+hR2H67h070nON/gAcCg0/KdQd25c2ivdqtMpddqMJkMmIy6wDNuSdCdnyRpIUTYUhSF8w6Pf3vKNk5YiuIvfvHxnipq6/3rnHVaDbff2p3vDe9FTJSxbd+wBRqN/xeCKJOBCL2Odl5aLdqBJGkhRFiyu7zYHZ4234tfUVUOfHOWj3ZXYqnzr3XWamBE/2TuGZlKN3NEm75fSwLPmyMNsoQqzEmSFkKEnAPHzvLp5v3cPawXt/Vpfe3hxjXP9Q4XnjYe2lZVlcOVdXy4q5JT1gb/+wGD+yZy38hUkroFv/iFPG/ueiRJCyFCzn9v/Yavq85x3uZqdZL2Kf5qVU532695PnLyHB/uqqSi2hY4dmtGPGNHpdEjIfj1kfU6DaZIed7cFUmSFkKEnMalS41/XomKf02yLQhD25U19Xywq5IjJ84HjmX2jmPsqDTSUoJTmrBRkypU8ry5y5IkLYTotNxeBZvDg7uN1zyfstr5cFclZRV1gWMZ3WMYOyqNm3vFtul7fVvjkHakUYdRL0PaXZ0kaSFEp6Oo/qHttt7O01Ln4KPdlXx59GzgWK+kaMZmpdI/LXjFLzQa0Ou0F2o3y5C2uEiStBCiEwnOdp619U4+3nOCz7+2BBJjSryJ+7LSGNgnvs2Ts9PtDWx44nT7iIrQt8uSLdH5SJIWQnQKXkXFZne36Xae5+1uPvn8BLvLagLFLxJiIrh3ZCpDM5PQBqGu8rFT59n02ZFAkj5nd7Pg1zuY+8hQ+qd1a/P3E51bUJJ0SUkJc+fOJTMzEwC73U5qaiqrVq3CaGz+22J5eTmLFy9GVVX69OlDQUEBer2ed955hw0bNqDX65k9ezZ33313k9eVlpZSWFiITqcjJyeHOXPmoCgKS5cu5fDhwxiNRgoKCsjIyAhGmEKIdhCM7TztTg/FpSfZceA0Xp//nrHRRu4Z0ZuRtyQHpUKUBv8M9H/sqkBVwePzF91QFBWn28crm75g9Zw72m37UNE5BO1fw+jRo1mzZk3g53nz5rFlyxbGjRvX7NrVq1fz1FNPMWrUKJ555hk++eQThg0bRlFREX/6059wuVw8+uij3HHHHU2S/JIlS1i7di1paWnMnDmTgwcPUlVVhdvtZuPGjZSWlrJixQrWrVsXrDCFEEGkqirW8842287T6faydd8ptn15GteFHnl0pJ7vDe/N7bd2x6APQnLWQITev/HInq+qqTnbgMOtNLtOVVX+daiGO4f2avM2iM6rXX5lc7vd1NTUEBcXx7Rp09BqtVgsFiZOnMiUKVNYu3YtOp0Ot9uNxWLBbDazb98+hg8fjtFoxGg0kp6eTllZGUOGDAHAZrPhdrtJT08HICcnh+3bt2OxWBgzZgwAw4YNY//+/e0RohCiTfmTsk9R2yRBuz0+dhw4TfEXp3C4/MPMkUYdY4b04ruDexBhaPvKVFqthkijvwqVQa9BVaGqxt5iggZweRRqahvavB2icwtakt65cyd5eXlYrVa0Wi25ublotVqqq6vZvHkziqIwfvx4xo0bR2JiIidOnGDatGmYzWYGDBhAcXExMTExgftFR0djs13cSMBms2E2m5ucr6ysbHZcp9Ph9XrR61sXamJicNc+hoLk5JirX9TJSYydk6qq2BrcqBe2udTptCQkRF/3/Txeha2lJ/jbjmOcv1C7OcKg4+6sNMZmpxMdhOIXWg1ERRiIMukxfKssZd/0BCI+P4GrhfXfEUYdfdMTwupz1V8YmdDrtWEVV3sK+nB3bW0t+fn5pKamAgR6xwD9+vWjoqKCxMREevfuzQcffMCmTZtYsWIF999/P3a7PXA/u93eJGmbzeZm52NjY3E6nU2OK4rS6gQNYLXa2nxDhFCSnByDxVLf0c0IKomxc/IpCvUX6jz7Ljyv9fkUzp61X+WVLd1LZe9XFrbsqeLcheSs12nIvq07dw3rjdlkwNXgxtXgbpO2a/AnoqhIPQajDrfTjdvZ/N63psZedpdtzYXz4fS5er1K4M9wiuvbtFpN0Dp4Qa8EHh8fz8qVK1m0aBEWi4VDhw7h8/lwOByUl5eTkZHBrFmzOHbsGODvEWu1WoYMGcKePXtwuVzU19dz5MgR+vfvH7iv2WzGYDBQUVGBqqps3bqVrKwsRowYQXFxMeCfWHbpa4QQoUcFGlxerOddNzxzW1H9laleeecL/l/xUc7Z3Wg1GkYNSGHexGH88Dt9MJvarves0fiHzeNjIkmMjcRk1KO5QrELU4SeuY8MJdKoC1ylwX8P/3GZNCaaapd/EZmZmeTl5VFQUEBKSgozZsygrq6O2bNnk5CQwMyZM3nmmWcwGAyYTCYKCgpITk4mLy+PRx99FFVVefLJJ4mIiKC4uJiysjJmzpzJCy+8wPz58/H5fOTk5DB06FAGDx7Mtm3bmDRpEqqqsnz58vYIUQhxHbyKSr3dHZjEBU3XEDc4vTjd3qsmL1VVOXS8lo92V3H67MXiF0Mzk7g3K5XE2Mg2bfeNFLron9aN1XPu4LnfllBb76JbTASFM7IlQYsWaVS1/fa0KSkpYcOGDU1mfV8rq9XKpk2bmDVrVhu27NL7y3B3Zycxhj4VaHB6sH9rWdWxU+d54+9luD0XJ1cZDVr+fdwA+vRsvh2nqqqUn/AXv6iyXBwWH3hTAvdlpdI9vm2LX+i1GkympoUurteSP/yLyhobaSlmXsi/vY1aGFq6QowQ3OHuTverm6qq5Ofnd3QzhBDXyeNTqG9ovt+20+1tlqAB3B6FN/5exrOPjSDCcPEr6/jpej7YVcE3py7+stI/rRtjs1Lpndx2X5iNW3ZGmwxEBmEWuBBX0q5JOjs7m+zs7Bu6R1JSUhu1RgjR3mxOD3aHp8Xh4S+PnuVyA3uqqrLvyFlGDUjhxBl/8YuvKusC52/q6S9+0adH2xW/0Gj8M8GjIg0Y9Rq4wrNmIYKl0/WkhRCdj9urUN/gxuNteY0wgLXOgecya6I9XpWK6vN8VVnHgW8uFr9ITY5m7Kg0MnvHtdn+2jfyvFmItiZJWggRNCoqNoeXBmfLvedLJXYzYdBrWkzUGg3sOXwm8HOPhCjuy0rl1oy2K36h12uIijAQaZQqVG0l0qhr8qe4dpKkhRBtTqPxV3eqb3AH9sa+msE3J/DejmM07jZ2qcZkmRgXyX0jUxncN/GGJ241ttOo1xEVqcdo0MmAdhubkHMTn5Se5O5hstXp9bpikt64ceNlz02cOLHNGyOE6PwUReG8w4PL5Wsh3V5epFHPv48bwH/97VCz3rTZZOD+UWkM75+Mrg0qUwWGtI36wJadou3d1ieBu0ZldOqVCB3tiknaYrG0VzuEEJ2cCjhcXmwOz3UtY3S4vBcmg2lo7E1rNPD929P47qCe6HU3vveSDGmLzuaKSfqHP/xhe7VDCNGJeX0q5xvczZZVtYbL42PH/tMUf3ES54U9rTUaf/JMiTdx59DeN9S2i1Wo9BhkSFt0MldM0s8//zwajabZsgiNRsMf//jHoDZMCNE5XGlZ1ZV4vAolB6v5rPQE9gs7jEUYdNwxuAcHvjlLda3jhp47t1SFSojO5opJuqioqL3aIYToZFqzrKolPkVhd5mFTz4/EahMZdBpGT2wO3cO60V0pIFDx2uvu12Nu4JFGnSB59eSoEVndcUk/fOf/5xf/epX5OTkNDu3devWoDVKCBG6rmVZ1aUUReWL8jN8vKeKs/UuAHRaf/GL743oTWyU8brbpNGA4cKQtuwKJsLJFZP0r371K0ASshDCnwhdboXzDhfey2w60hJVVTnwzVk+2lNFTa0jcK8R/ZK5Z2Rv4mOuv/iF7Aomwl2r1kl/+eWXLFmyhDNnztCrVy9+8YtfSAlIIboQRVWxNXhwuLyt7j2rqspXlXV8uKuSk9aGwPHBNydyX1Yqyd1M192exiVUURE69LIrmAhjrUrShYWF/Od//ieZmZkcPnyYpUuX8tZbbwW7bUKIFhw4dpZPN+/n7mG9uK1PQpDfTcXpUbDZ3XivYVnV0ZPn+HBXFcerL66PHZAez9hRqfRMjL7u1rRUhUoStAhnrUrSERERZGZmAnDLLbdgMLRd0XQhxLX5763f8HXVOc7bXEFN0j5Fpd7hvqZNSSprbHy4q5LyE+cCxzJ7xzF2VCppKTHX1Q4NoNdLFSrRNbVqxzG9Xs/SpUsZNWoU+/btw2wOTt1MIcTVNa4lbvyzramAw+3F3uDB18re8ymrnY92VzWZlZ3e3czYUWn07RV33W3RoCE+JgKjJGfRRbVqx7Hhw4cD8M033xATE8Ott94a/JYJIdrd5Wo9X86ZOgcf7aniyyPWQG+7V2IUY0el0T+t23UVv9BqNYGhbJ1OIwladGlXTNJz5sy54ov/1//6X7z22mtt2iAhRPtTVBW7s/XLqmrrXXyyt4q9X1lo7Gwnd4vkvqw0Bt6UcF2bkFz6vDkq0v/VJNWTRFd3Q1Wwzp8/3+LxkpIS5s6dG3iObbfbSU1NZdWqVRiNzddCHjp0iGXLlqHT6TAajbz00kskJSVRUFDA3r17iY72TzR5/fXXiYm5+FyrtLSUwsJCdDodOTk5zJkzB0VRWLp0KYcPH8ZoNFJQUEBGRsaNhClEGLu2iWH1DW4++fwEuw7VBIbC42MiuHdkKsMyk9BeR/ELg15DVKQBk/Hi15FUTxLC74aS9JWGskaPHs2aNWsCP8+bN48tW7Ywbty4ZtcWFhayePFibr31VjZs2MBvf/tbnn32WQ4cOMDvfvc7EhJanhyzZMkS1q5dS1paGjNnzuTgwYNUVVXhdrvZuHEjpaWlrFixgnXr1t1ImEKEpWupVtXg9FD8xUl27K/G4/PvMBYbZeDuEamMvCX5motfXLqfdkvD2VI9SQi/dqkn7Xa7qampIS4ujmnTpqHVarFYLEycOJEpU6awevVqUlJSAPD5fERERKAoCsePH+f555/nzJkzPPzwwzz88MOBe9psNtxuN+np6QDk5OSwfft2LBYLY8aMAWDYsGHs37+/PUIUotNonBhma7h6tSqn28u2L0+zdd8pXBeeU0dF6vnesN5k39Ydg/7akrPsp31R41C+DOmLKwlakt65cyd5eXlYrVa0Wi25ublotVqqq6vZvHkziqIwfvx4xo0bF0jQe/fu5c0332T9+vU0NDTw2GOPMW3aNHw+H1OnTmXQoEEMGDAA8CfpS2eZR0dHU1lZ2ey4TqfD6/Wi17cu1MTE8J+5npx8fUthOpNwjlF/ITHq9dprjtPh8lBv96A3auhmvPxSSrfHx6d7q/jHzuPYHR4ATBF6xt6ezj1ZaURGXNtXh04DpkgDUZGGa0rs4fw5/tsPB/L/PivnJ3dlhnWcEN6fY7DdUJKOi7v80orG4e7a2lry8/NJTU0F/DPFG59L9+vXj4qKChITE3n//fdZt24dv/nNb0hISAgkZpPJFLhfWVlZIEmbzWbsdnvg/ex2O7GxsTidzibHFUVpdYIGsFpt11ULt7NITo4J+yHEcI/Re6GghdertDpORVWxOa6+Y5jXp7CrrIZP956g/kJyNui1fHdQD8YM6UVUpJ4Gu4sGu+uq76nRgPHCkLbWoMPtcON2uFvVXgj/z7FXfCRLZ3wHi6U+rOMM988R/CNEwergXTF7vfzyy5d97vzUU0+xdu3aq75BfHw8K1euZOrUqSxcuJBDhw7h8/lwu92Ul5eTkZHBX/7yFzZu3EhRURHdunUD4NixY8ydOzfQ6967dy8/+clPAvc1m80YDAYqKipIS0tj69atzJkzh9OnT/PJJ5/wwAMPUFpaKtuXii6ttWuefYpK6dcWPt5TRZ3Nn0h1Wg3Zt3XnrmG9iLmG4hdajYbICB2mCD1GvWzZKcSNuGKSvvnmm9vkTTIzM8nLy6OgoICUlBRmzJhBXV0ds2fPJi4ujsLCQnr27MkTTzwBwKhRo/j5z3/OhAkTyM3NxWAwMGHCBPr160dxcTFlZWXMnDmTF154gfnz5+Pz+cjJyWHo0KEMHjyYbdu2MWnSJFRVZfny5W0SgxCdjdencr7BfcU1z4qq8uURKx/vqeLMOScAWg2MvCWFu0f0pps5otXvp9VqiIrUYzLq0Gn9Q9qSoIW4MRpVvfr/Rl6vly+//BKv14uqqtTU1PCjH/3omt+spKSEDRs2NJn1fa2sViubNm1i1qxZ132PK99fhrs7u3CPcckf/kVljY20FDMv5N/e4jU2pwe74/JrnlVVpex4LR/uruL0WX/xCw0wNDOJe0emkhjX+spUep1/CVXkJftpt4Vw/xxBYgwXHTbc3WjOnDl4PB5qamrw+XykpKRcV5JuC6qqkp+f3yHvLURHc7i82C48K258xmy6MInLX0rSR73DjecypSRVVeXIifN8uLuSyhpb4PjAPgncl5VK94SoVrXj0v20I/Q62jA3CyEu0aokXVtby8aNG3nuuedYvHgx06ZNu643y87OJjs7+7pe2ygpKemGXi9EZ/VVZR2vbPoC14U9u+vqXcx7bRtP5g7l5l6x1Ds8uNy+y/aej5+u54NdlXxz6uImRP3T4rgvK43U5Nb1Ahong0VHGjAarm35lRDi2rUqSUdG+oe+HA4HkZGR17UfrxDi+jlcXl7Z9EWTohoqEBmh580Pv+LxH92KQdfyetuTZ+x8uKuSw5V1gWN9esYwNiuNm3rGtur9tRoNEUb/ZLAIg0wGE6K9tCpJ33///bz22msMGDCA3NxcoqJaNyQmhGgbu8pq+Pb0Eb1Og6KoVJ+1U/q1lVEDUpqcr6l18NHuSvZ/czZwrHdyNGOz0uiXGteqX7a1Wg2mCD1RETr0On9ylgQtRPtpVZK+99576d69OxqNhrvuuuua1h0LIW5c9dkGXB4Fvc6/S5dPUf2zt+3+5VLWc47AtWfPO/l4TxWl5WcCCbV7vImxo9K4NSO+Vcm5pclgkpyFaH9XzLZfffUV1dXVrFq1iqeffhrwb9u5evVq/vKXv7RLA4UQ0D0hiqS4CPR6HTUXZmM3Mug1JMaZOGd388neKnaXWVAuZNTE2EjuzUplyM2JVy1+odGA4cLmIzIZTIjQcMUkff78ed5//32sVivvvfce4C+q8eijj7ZL44QQ/uQ5vF8S7+88Tk2tg5ZWCJ6y2vnrtm/w+vwn46KN3DMylRH9kwJrlq90/wiDjqhIA0a9Bv/cbSFEKLhiks7KyiIrK4sDBw4wcOBAzp49S7du3dBe5X96IUTbUBSFeocXp9vLj3Nu4o2/l+G+JEtrtYCqYeeBagCiTQbuHt6LUQOuXvwiUOwiUo9BJ5PBhAhFrXq4XF9fz7333ktMTAznz59n2bJl3HHHHcFumxBdlopKg9OL3ekNbK7Tp2cszz42gjUbv+B8g3+ttKKAgoIpQsedQ3vxnYE9Wiz9eCmdVoMpUo/JqEenlefNQoSyViXpX/7yl7z11lt0796d6upq5syZI0laiCBxenzYGtyBoetGHq/C7jJLYDMTAKNByx2De5IzuGdgU5PL0ev9k8FMRh0aGdIWolNoVZLW6XR0794dgO7duxMR0fr9fIUQV6fRgMujYHN4mu217VMU9hy28MneE5yzX6wiFR2p5z8eGYrZdPmSk5dWojIadJKahehkWpWkzWYzRUVFjBo1il27dgUqVQkhbpxX8Sfnb+8WpigqXxw5w8d7qjh73l8aUqfVEGHQ0eDyEhttvGyCbqxEFWmUzUeE6MxalaQHDx7MqVOneOWVV7j55ptJSEgIdruECHuKqmJ3enE4vYElU+DfX/vgsVo+3F1JTa1//bN/hncy94zozfoPv6LB5W3xnhefN0slKiHCwRWT9KZNm3j33Xc5cuQIffv2BWDXrl14vS1/QQghWqexxrNXaZqcv646x4e7Kjlxxh44PujmBO7LSiOlm+my95PnzUKEpysm6QkTJvCd73yH//N//k+gNKRWqyUxMbFdGidEuPH4FGwNHlzfeu78zanzfLCrkuOnL5b0uyW9G2Oz0uiVFH3Z+xkNOqLlebMQYeuKSdpoNJKamsqyZcvaqz1ChKXGoe0GZ9Maz1UWGx/uquTrqnOBYzf3iuX+UWmkd4+54j11Wg0JMUZk8xEhwpdswi1EkDW4vNgdHnyXDG2fPtvAR7srOXisNnAsLcXM/aPS6Ns7rsX7NO4M1ri22b8HtyRoIcKZJGkhgkAFnG5/cr50vfOZcw4+2l3Fl0esNB7tmRjF2Kw0bknv1mLxC40GIo16oiMNGPQaKRUrRBcSlCRdUlLC3LlzyczMBMBut5OamsqqVaswGo3Nrj906BDLli1Dp9NhNBp56aWXSEpK4p133mHDhg3o9Xpmz57N3Xff3eR1paWlFBYWotPpyMnJYc6cOSiKwtKlSzl8+DBGo5GCggIyMjKCEaYQLVBxehRsDjde78XkXGdzsWVPFXu/sgT23k6Ki+S+rDQG3ZwQqDR1qcZlVJdu2ykztYXoWoLWkx49ejRr1qwJ/Dxv3jy2bNnCuHHjml1bWFjI4sWLufXWW9mwYQO//e1vefzxxykqKuJPf/oTLpeLRx99lDvuuKNJkl+yZAlr164lLS2NmTNncvDgQaqqqnC73WzcuJHS0lJWrFjBunXrghWmEMDFzUjsjqaTwuob3Hz6+Un+dag6MNwdHxPBPSN6M6xfcmDo+lKX1nBuaRlVpFHX5E8hRPhql+Fut9tNTU0NcXFxTJs2Da1Wi8ViYeLEiUyZMoXVq1eTkuIvWO/z+YiIiGDfvn0MHz4co9GI0WgkPT2dsrIyhgwZAoDNZsPtdpOeng5ATk4O27dvx2KxMGbMGACGDRvG/v372yNE0YV5FRWbw91kM5IGp5d/7jvJ9v2n8XgVAGKiDNw9vDdZA1LQ65oXv7iYnPUtJu9GE3Ju4pPSk9w9rFdQ4hFChI6gJemdO3eSl5eH1WpFq9WSm5uLVqulurqazZs3oygK48ePZ9y4cYEEvXfvXt58803Wr1/PP//5T2JiLs5ujY6OxmazBX622WyYzeYm5ysrK5sd1+l0eL1e9Hp5/C7alk9RsTs9OFzeQHJ2uX1s23+Kf35xKtCjjorQc9fwXoy+rUeLlan0Wg0mk3+Nc0vD3t92W58E7hqVgcVSf9VrhRCdW9CHu2tra8nPzyc1NRUg0DsG6NevHxUVFSQmJvL++++zbt06fvOb35CQkIDZbMZuv7ihg91ub5K0WzofGxuL0+lsclxRlGtK0ImJ5qtf1MklJ195aU84CGaMvgtrne0uD5FREURGReD2+Ph0bxX/2Hkc+4UCGJEROsbensG9WWlEtlD8QqeF6EgDUZEGdC30rK9GPsfwIDGKKwl69zI+Pp6VK1cydepUFi5cyKFDh/D5fLjdbsrLy8nIyOAvf/kLGzdupKioKLAv+JAhQ3jllVdwuVy43W6OHDlC//79A/c1m80YDAYqKipIS0tj69atzJkzh9OnT/PJJ5/wwAMPUFpa2uQ1rWG12gKlAcNRcnJM2PfAghljg9tLwyU7hXl9CrvLavjk8xPUXygfadBr+e6gHowZ0ouoSD0NdhcNdlfgHga9hmiTEYNeh7PBjbPB3eJ7XYl8juFBYgwPWq0maB28dhkDzszMJC8vj4KCAlJSUpgxYwZ1dXXMnj2buLg4CgsL6dmzJ0888QQAo0aN4uc//zl5eXk8+uijqKrKk08+SUREBMXFxZSVlTFz5kxeeOEF5s+fj8/nIycnh6FDhzJ48GC2bdvGpEmTUFWV5cuXt0eIIoy1tJzKp6iUfm1hy94T1NZfLH5x+23d+d6wXsRENV/FYNBrMZsMsjuYEKLVNKrafos6SkpK2LBhQ5NZ39fKarWyadOmwDalbU160p1f28WoXigf6cZzYTmVoqrsP3qWj3ZXcuacEwCtBkbcksI9I3rTzdy8jGtjco4wtN1sbPkcw4PEGB46fU+6LamqSn5+fkc3Q4SxS5dTuT0+VPz/7g5X1PHh7kpOWRv81wFDMhO5d2QqSXHNi18Y9FqiLyRn6TkLIa5Huybp7OxssrOzb+geSUlJbdQaIZrz+i4sp/JcXE515MQ5PtxdSUX1xdUFt/WJ576sNHokRDV5vQYwSNELIUQb6XQ9aSGCwaco/trOlyynqqiu54NdlRw9eT5wXb/UOMZmpZGa0nRoS6OBCL2OqEgDRoPsqS2EaBuSpEWX5lNUGlz+5Nw4F+HkGTsf7a6krKIucF1GjxjuH5XGTT1jm93DaNBdeOaslW07hRBtSpK06JIU1Z+cG5wXk3NNnYOPd1fy5dGzget6J0UzdlQa/VLjmhW2aFxKFXlhQpgkaCFEW5MkLbqUlpJzbb2Tj/ec4POvLYFEmxJv4r6sNAb2iW8hOctSKiFE+5AkLboERVGwu3xNhrXP29188vkJdpfVBIpfJMRGcN/INIb0TUR7yf7ZjRPCzBcmhAkhRHuQJC3CWuOEMKfLh3Khm2x3evis9CQ7D5wObE4SF23k7hG9GXlLcqDyFPgnhBn1OqJlQpgQogNIkhZh5cCxs3y6eT93De1JRo9YHE5vIDk73V627jvF1i9P4fb4K1NFmwx8b1gvbr+1e5PiF5KchRChQJK0CBsaDfzln99QfuIc1joHMx8cCIDb42PHgdMUf3ESh8tfmSrSqOPOob34zqAeTXYC0+CfrS3JWQgRCiRJizCg4vaq1NY7sZxzAFBb78LmcLPviJVPPz+J7UJlKqNey3cH92TMkJ6YvlWZymjQYZbkLIQIIZKkRael4u8l251eyivr+MPfDgWGsc/Z3Swv2hu4Vq/TMPq2Htw5rBdmk6HJfb69lEoIIUKFJGnRKTncXuxOD16vitPtbZKgv23kLcncl5VGXHTTylR6nYZok4FIo176zUKIkCRJWnQaKioOl48Gx8V6zgD7jljx+VpO0HodpHePaZKg9VoNUSYDURHyz18IEdrkW0qEPEVVcbh9OL6VnFVV5euqc3y0u4rL5Gi8PrBeeE6t1WqIitQTFaFHq5G+sxAi9EmSFiFJowGPT6HB6cXp9jWr8f3NqfN8uKuSY6evXKfWoNeQHB9FZISOGJOhyRpoIYQIdZKkRYjxz9RucHqalItsVGWx8eGuSr6uOhc4ltEjhhMWW2BjkkZaDXSLieCuoT2JiTLK3tpCiE5HkrQICZfO1PZ4myfn6rMNfLi7koPHagPHUpOjuX9UOn17x3L8dD1v/L0sMHlMq9WQmhxN3vdvwWySBC2E6JwkSYsOpaLidPsCM7W/zXrOycd7qvii/AyNZ3skRDE2K5UBGReLX/TpGcuzj43glU37OGdzE2+O4JkpI4g0yj9xIUTnFZRvsJKSEubOnUtmZiYAdrud1NRUVq1ahdFovOzrli9fzk033cTkyZMBKCgoYO/evURHRwPw+uuvExMTE7i+tLSUwsJCdDodOTk5zJkzB0VRWLp0KYcPH8ZoNFJQUEBGRkYwwhQ3wKf4l045nN4mk8Ea1dlcfLL3BHsO19B4OikukvuyUhl0c2KziV8aIDYqguQ4E+dsbhJiIyRBCyE6vaB9i40ePZo1a9YEfp43bx5btmxh3Lhxza49e/Ys//t//2+OHTvG9OnTA8cPHDjA7373OxISElp8jyVLlrB27VrS0tKYOXMmBw8epKqqCrfbzcaNGyktLWXFihWsW7eu7QMU1+xqk8EA6hvcfFZ6kpKD1YHKVN3MRu4dmcqwfsnotM1nZRv0WmJMBowGLT8ecxOflJ7k7mG9gh6PEEIEW7t0NdxuNzU1NcTFxTFt2jS0Wi0Wi4WJEycyZcoU7HY7TzzxBMXFxYHXKIrC8ePHef755zlz5gwPP/wwDz/8cOC8zWbD7XaTnp4OQE5ODtu3b8disTBmzBgAhg0bxv79+9sjRHFFV54MBuBweSn+4iTb95/G4/U/V44xGfjeiN6MGpCCXtd8VrZeqyE6qulmJLf1SeCuURlYLFee9S2EEJ1B0JL0zp07ycvLw2q1otVqyc3NRavVUl1dzebNm1EUhfHjxzNu3DjS0tJIS0trkqQbGhp47LHHmDZtGj6fj6lTpzJo0CAGDBgA+JO02WwOXB8dHU1lZWWz4zqdDq/Xi17fulATE81Xv6iTS06OufpFbUBRVBwuD3aHF1CIMuuI+tY1TpeXj3dX8tG/KnC4vABER+r5/nf68L0RqS3WbtYApgg9MdHGFpM3tF+MHUliDA8So7iSoA9319bWkp+fT2pqKgDDhw8PPJfu168fFRUVJCYmNnu9yWRi6tSpmEymwP3KysoCSdpsNmO32wPX2+12YmNjcTqdTY4ritLqBA1gtdpaHIYNF8nJMUHvZV5tMhiAx6tQcrCaT0tP0OD0J+cIg46cIT25Y3APIo16bPXOJq/RABFGHeYoI16Xh1qXp8V7t0eMHU1iDA8SY3jQajVB6+AFfWeH+Ph4Vq5cyaJFi7BYLBw6dAifz4fD4aC8vPyyk7qOHTvG5MmT8fl8eDwe9u7dy8CBAwPnzWYzBoOBiooKVFVl69atZGVlMWLEiECPvLS0lP79+wc7RHGBT1GxOz1Y65ycs7lbTNBen8LOg6d5ecPnvL/zOA1OLwadljuH9uTpycO4d2RqixO+9HoN3WIi6GY2om/hubQQQoSjdnkmnZmZSV5eHgUFBaSkpDBjxgzq6uqYPXv2ZSeF9e3blwkTJpCbm4vBYGDChAn069eP4uJiysrKmDlzJi+88ALz58/H5/ORk5PD0KFDGTx4MNu2bWPSpEmoqsry5cvbI8QuzacoNLh8OFzey45CKIpKafkZPt5TRW29CwCdVsOoW1P43vDexEa1POtfq/UXwYiWfbaFEF2QRlXbb5uHkpISNmzY0GTW97WyWq1s2rSJWbNmtWHLLr2/DHe3hkYDbq+Cw+XF6fKhXOafkaKqHPjmLB/trsRS5x++1mpgeP9k7hmRSnxMxGXvb4rQEx1paHFG95V0heE1iTE8SIzhIZjD3Z2ue6KqKvn5+R3djC7N7VH8M7Vb2BmskaqqHK6s46NdlZy0NgSOD+mbyH0jU0nqZmrxdRqN/9m02WREr5NhbSFE19auSTo7O5vs7OwbukdSUlIbtUZci8bJYA0XJoNdaazh6MlzfLCrkopqW+DYrRnx3JeVSs/E6Mu+Tq/TEBNlJNKok208hRCCTtiTFu3Lpyg43D6cl9kZ7FIV1fV8uLuSIyfOB45l9o5j7Kg00lIuPxSk0UBUpAGzSY8GjSRoIYS4QJK0aKa1z5sbnbLa+XBXJWUVdYFj6d3N3D8qnZt7xV7xtREGHTFRMrQthBAtkSQtmmisROW+wvPmRmfqHHy4u4ovj1oDx3olRTM2K5X+ad0CxS9aotdqMEcbiTRoAUnQQgjREknSAgCH20uD04PnMpuPXKq23smWPSfY+7UlkMiTu5kYm5XKwJsSrpicG2dtm02GZkUyhBBCNCVJugtTVBWH24fD4bnq82aA83Y3n35+gl1lNYHiFwkxEdw7MpWhmUlor7JUyqDXEhNlJMKglefOQgjRCpKku6DWbD5yqQanh89KT7LjwGm8Pv/1sdFG7h7em6wByei0V964rnFDkiijHo0GSdBCCNFKkqS7GJfHh/W8q1XJ2en2snXfKbZ9eRqXxwf4i198b3hvbr+1Owb9lZOzRgORRj0xJj3aqyRyIYQQzUmS7mJUVeVqm8y5vT527q/msy9OBipTRRp1jBnSi+8O7kFEC5Wpvs1o0GE2GWRoWwghboAkaRHg9SnsOlTDp5+foN7hrzBl1Gv57qAejBnaC1Mr9s/WajWYTQZMEf4az5KghRDi+kmSFvgUlc+/srBlbxV1Njfg3/0r+9bu3DW8N2aT4ar3kKFtIYRoe5KkuzBFVfnyiJWP9lRhPddY/EJD1oBk7h7emzhzy8Uvvk2v1xBrMhIh23kKIUSbkiTdBamqysFjtXy0u4rTZ/3FLzTAsH5J3DMylcTYyFbdR6vVEB3pr1Tlv2+wWiyEEF2TJOkuRFVVvvjawhv/c4CqGnvg+MCbErgvK5Xu8VGtuo9GAxFGHTEmw1WXXwkhhLh+kqS7kI1byvlgV2Xg5/5p3Rg7Ko3eSZevTPVtBr2WGJORCKPM2hZCiGCTJN2FNA5t39QzhvtHpZPRI6bVr9VpNURHGTAZZda2EEK0F0nSXcisCQPxarTY6h20tqiF7LUthBAdJyhJuqSkhLlz55KZmQmA3W4nNTWVVatWYTQaL/u65cuXc9NNNzF58mQA3nnnHTZs2IBer2f27NncfffdTa4vLS2lsLAQnU5HTk4Oc+bMQVEUli5dyuHDhzEajRQUFJCRkRGMMDudSKOemDgT5TZnq3rCjRuSGK+ys5gQQojgCNq37+jRoykqKqKoqIg///nPGAwGtmzZ0uK1Z8+e5fHHH29y3mKxUFRUxIYNG/j973/P6tWrcbvdTV63ZMkSXn75Zd5++22++OILDh48yEcffYTb7Wbjxo3MmzePFStWBCvEsKXVaoiNNhIfEyEJWgghOlC7DHe73W5qamqIi4tj2rRpaLVaLBYLEydOZMqUKdjtdp544gmKi4sDr9m3bx/Dhw/HaDRiNBpJT0+nrKyMIUOGAGCz2XC73aSnpwOQk5PD9u3bsVgsjBkzBoBhw4axf//+9ggxLGiAiAgdsSaDbEgihBAhIGhJeufOneTl5WG1WtFqteTm5qLVaqmurmbz5s0oisL48eMZN24caWlppKWlNUnSNpuNmJiLE5uio6Ox2WxNzpvN5ibnKysrmx3X6XR4vV70+taFmphovvpFnZjT7SU+vvlsbq0GYqKNREcarlgPurNITm79pLjOSmIMDxKjuJKgJenRo0ezZs0aamtryc/PJzU1FSDQOwbo168fFRUVJCYmNnu92WzGbr+4ltdutzdJ2i2dj42Nxel0NjmuKEqrEzSA1WprVYWoziomzkRtrT3wTFqjgahIA9GRehw2Fw6bq2Mb2AaSk2OwWOo7uhlBJTGGB4kxPGi1mqB18II+phkfH8/KlStZtGgRFouFQ4cO4fP5cDgclJeXX3ZS15AhQ9izZw8ul4v6+nqOHDlC//79A+fNZjMGg4GKigpUVWXr1q1kZWUxYsSIQI+8tLS0yWtEU0a9lviYSGJk5rYQQoSkdnkmnZmZSV5eHgUFBaSkpDBjxgzq6uqYPXs2CQkJLb4mOTmZvLw8Hn30UVRV5cknnyQiIoLi4mLKysqYOXMmL7zwAvPnz8fn85GTk8PQoUMZPHgw27ZtY9KkSaiqyvLly9sjxE7hwLGzbNl7gqxbkhmSmUTUhUpVQgghQpNGvVpx4TZUUlLChg0bWLNmzXXfw2q1smnTJmbNmtWGLbv0/uE73P3im3v4uuocmalxLHxsZEc3J2i6wvCaxBgeJMbw0KmHu9uaqqrk5+d3dDM6JafbB4Drwp9CCCFCW7vuOJadnU12dvYN3SMpKamNWiOEEEKEtk7XkxZCCCG6CknSQgghRIiSJC2EEEKEKEnSQgghRIiSJN1FOFxebA4PADaHB4fL28EtEkIIcTWSpLuAryrrmPfaNurq/Vt+1tW7mPfaNr6qrOvYhgkhhLgiSdJhzuHy8sqmL3C6fTRu0aLiXzPtPy49aiGECFWSpMPcrrIaLrepnKqq/OtQTTu3SAghRGtJkg5z1WcbcHmUFs+5PAo1tQ3t3CIhhBCtJUk6zHVPiCLC0PLHHGHQkhIf1c4tEkII0VqSpMPcqAEpaC5ThlKj0XD7rSnt3CIhhBCtJUk6zJki9Mx9ZCiRRl2gLKUGiDTqLhxv1+3bhRBCXANJ0l1A/7RurJ5zB91iIgDoFhPB6jl30D+tW8c2TAghxBVJku4iIo16zCYDAGaTQXrQQgjRCUiSFkIIIUKUJGkhhBAiREmSFkIIIUJUuz6YLCkpYe7cuWRmZgJgt9tJTU1l1apVGI3GZtcfPHiQn/3sZ/Tp0weAyZMn88ADDwTOO51Onn76aaxWK9HR0bz00kskJCSwZcsWXnvtNfR6PQ899BC5ubntEp8QQgjRltp99tDo0aNZs2ZN4Od58+axZcsWxo0b1+zaAwcOMG3aNPLz81u819tvv03//v154okneO+993j99ddZsGABL774Iu+++y4mk4nJkydzzz33kJSUFLSYhBBCiGDo0OFut9tNTU0NcXFxTJs2jenTp/Pggw+yfv16APbv38+nn37KlClTWLhwITabrcnr9+zZw5gxYwC488472bFjB0eOHCE9PZ24uDiMRiMjR45k165d7R6bEEIIcaPavSe9c+dO8vLysFqtaLVacnNz0Wq1VFdXs3nzZhRFYfz48YwbN44hQ4bwyCOPMGjQINatW8drr73GggULAvey2WzExMQAEB0dTX19fZNjjce/ndyvJDHR3HbBhhi9Xhv4Mzk55ipXd27hHh9IjOFCYhRX0mHD3bW1teTn55OamgrA8OHDA8+l+/XrR0VFBWPHjiU2NhaAsWPHsmzZsib3MpvN2O12wP98OzY2tsmxxuOXJu2rsVptKErLVaM6O69XCfxpsdR3cGuCJzk5JqzjA4kxXEiM4UGr1QStg9dhw93x8fGsXLmSRYsWYbFYOHToED6fD4fDQXl5ORkZGUyfPp19+/YBsGPHDgYOHNjkHiNGjOCzzz4DoLi4mJEjR9K3b1+OHz9OXV0dbreb3bt3M3z48HaPTwghhLhRHbrtVGZmJnl5eRQUFJCSksKMGTOoq6tj9uzZJCQksHTpUpYtW4bBYCApKSnQk87Ly6OoqIjJkyezYMECJk+ejMFg4OWXX8ZgMPDMM88wffp0VFXloYceonv37h0ZZsiINOqa/CmEECK0aVRV7fCx3ZKSEjZs2NBk1veVFBYW8txzzwWlLeE83H3w2Fk+KT3J3cN6cVufhI5uTtB0heE1iTE8SIzhIZjD3Z1yA+fLLckSV3ZbnwTuGpUR9v/DCCFEuAiJJJ2dnU12dnarr+/Zs2cQWyOEEEKEBtkWVAghhAhRkqSFEEKIECVJWgghhAhRkqSFEEKIECVJWgghhAhRkqSFEEKIECVJWgghhAhRkqSFEEKIECVJWgghhAhRkqSFEEKIECVJWgghhAhRkqSFEEKIECVJWgghhAhRkqSFEEKIECVJWgghhAhRkqSFEEKIEKVvzzcrKSlh7ty5ZGZmAmC320lNTWXVqlUYjcZm1x8/fpxnnnkGjUZDv379WLJkCVrtxd8rnE4nTz/9NFarlejoaF566SUSEhLYsmULr732Gnq9noceeojc3Nx2i1EIIYRoK+3ekx49ejRFRUUUFRXx5z//GYPBwJYtW1q89sUXX2Tu3Lm89dZbqKrKxx9/3OT822+/Tf/+/Xnrrbf48Y9/zOuvv47H4+HFF1/kD3/4A0VFRWzcuJEzZ860R2hCCCFEm2rXnvS3ud1uampqiIuLY9q0aWi1WiwWCxMnTmTKlCkcOHCA22+/HYA777yTbdu2MXbs2MDr9+zZw+OPPx44//rrr3PkyBHS09OJi4sDYOTIkezatYsf/OAHrWqTVqtp4yhDj8QYHiTG8CAxdn7BjK/dk/TOnTvJy8vDarWi1WrJzc1Fq9VSXV3N5s2bURSF8ePHM27cOFRVRaPxBx8dHU19fX2Te9lsNmJiYpqcv/RY43Gbzdbq9sXHR7dBlKEtMdHc0U0IOokxPEiM4aErxBgsHTbcvX79egwGA6mpqQAMHz4co9FIZGQk/fr1o6KiosnzZ7vdTmxsbJN7mc1m7HZ7k/OXHms8fmnSFkIIITqLDpvdHR8fz8qVK1m0aBEWi4VDhw7h8/lwOByUl5eTkZHBbbfdRklJCQDFxcVkZWU1uceIESP47LPPAudHjhxJ3759OX78OHV1dbjdbnbv3s3w4cPbPT4hhBDiRmlUVVXb681KSkrYsGEDa9asCRxbt24d//f//l9SUlJISkqirq6OvLw8fvKTn/DNN9+wePFiPB4PN998MwUFBeh0OvLy8igqKsLhcLBgwQIsFgsGg4GXX36Z5OTkwOxuVVV56KGHmDJlSnuFKIQQQrSZdk3Sl9NS8r6SwsJCnnvuuSC3SgghhOhYnXIzk/z8/I5ughBCCBF0IdGTFkIIIURznbInLYQQQnQFkqSFEEKIECVJWgghhAhRHbotaDB0hSIe1xpjo+XLl3PTTTcxefLkJscVRWHp0qUcPnwYo9FIQUEBGRkZlJaWUlhYiE6nIycnhzlz5gQ1rktda4yHDh1i2bJl6HQ6jEYjL730EklJSWEVY3l5OYsXL0ZVVfr06UNBQQF6/cX/hcMhxkZ//etfefPNN9m4cWOT4+EQ48GDB/nZz35Gnz59AJg8eTIPPPBA4Hw4fOdYrVYWLVrE+fPn8fl8/Od//ifp6emB8+HwOT755JOBuhAnTpxg6NChTVYotdnnqIaZnTt3qnPnzm1y7KmnnlL/9re/tXj9z372M3Xnzp2qqqrq4sWL1Q8++KDJ+T/84Q/qr371K1VVVfV//ud/1GXLlqlut1u977771Lq6OtXlcqk//elPVYvFEoRoWnatMVqtVnX69Onqvffeq7711lvNzv/jH/9QFyxYoKqqqn7++efqrFmzVFVV1QcffFA9fvy4qiiK+vjjj6sHDhxo40gu71pjnDJlinrw4EFVVVX17bffVpcvX97kfDjEOHv2bPVf//qXqqqqumDBgmb/VsMhRlVV1QMHDqhTp05VH3nkkWbnwiHGd955R/39739/2fuFw3fOggUL1Pfee09VVVXdsWOH+sknnzQ5Hw6fY6O6ujr1wQcfVKurq5scb6vPMeyHu79dxGP69Ok8+OCDrF+/HqBZEY/t27c3ef2ePXsYM2ZM4PyOHTuaFPEwGo2BIh4d5Wox2u12nnjiCSZMmNDi6y+NcdiwYezfvx+bzYbb7SY9PR2NRkNOTk6zv5v2dLUYV69eza233gqAz+cjIiKiyevDIca1a9cyatQo3G43FosFs7npfsjhEGNtbS2rV69m4cKFLb4+HGLcv38/n376KVOmTGHhwoXNaguEw3fO3r17qa6u5t///d/561//GviObRQOn2OjtWvX8thjj5GSktLkeFt9jmE33A2hX8SjLVxLjGlpaaSlpVFcXNzivWw2W5MvfJ1O1+xYdHQ0lZWVQY/rUtcSY+P/IHv37uXNN99s9j9SOMSYmJjIiRMnmDZtGmazmQEDBjS5V2eP8fvf/z7PP/88zz77bLNfshp19hjHjRvHkCFDeOSRRxg0aBDr1q3jtddeY8GCBU1i7OzfOSdOnCA2NpY33niDV199ld/+9rf8x3/8R5MYO/vnmJiYiNVqZceOHTz77LPN7tVWn2NY9qS7QhGPa4nxar4dj6IoLcb47b+bYLvWGN9//32WLFnCb37zGxISEprcK1xi7N27Nx988AGTJ09mxYoVTe7V2WM8evQox48fZ+nSpTz11FOUl5dTWFjY5F6dPcaKigrGjh3LoEGDABg7diwHDx5scq9w+M7p1q0b99xzDwD33HMP+/fvb3KvcPgcAf7+97/zox/9CJ1O1+xebfU5hmWSbtQVini0JsarGTFiRKCXXVpaSv/+/TGbzRgMBioqKlBVla1btzb7u2kvrYnxL3/5C2+++SZFRUWkpaU1u0c4xDhr1iyOHTsG+H8Dv/QXTOj8MWZmZvLee+9RVFTE6tWryczMbLb9b2ePMSMjg+nTp7Nv3z4AduzYwcCBA5vcIxy+c0aOHBmIYdeuXYHJWI3C4XME/+d35513tniPtvocw3K4+1KZmZnk5eVRUFBASkoKM2bMoK6ujtmzZ5OQkMCCBQtYvHgxq1ev5uabb+b73/8+QKCIx+TJk1mwYAGTJ08OFPEwGAw888wzTJ8+PVDEo3v37iEb4+U8+eSTLFy4kLFjx7Jt2zYmTZqEqqosX74cgBdeeIH58+fj8/nIyclh6NCh7RVSM1eKMS4ujsLCQnr27MkTTzwBwKhRo/j5z38eNjEmJCQwc+ZMnnnmGQwGAyaTiYKCAiB8Pseu8G81ISGBpUuXsmzZMgwGA0lJSSxbtgwIr++cBQsWsGjRIjZs2IDZbObll18GwutzBPjmm2+adQra/HNs1bS3MNDSzL0rKSgoCGJrguNaY3z55ZdVu90exBa1PYmxOYkxNMl3TnPyOV67sB7uvhFdoYjHpEmTiIqK6uhmBJXEGB66QozynRMe2vpzlAIbQgghRIiSnrQQQggRoiRJCyGEECFKkrQQQggRoiRJCyGaOXToEK+++mpHN0OILk8mjgkhhBAhKuw3MxFCXN0333zDs88+i16vR1EUcnNz+eyzz3jqqacCxS7sdjtHjx5lx44dfPrpp7zxxhtotVpGjhzJ/PnzOzgCIcKTDHcLIdi+fTtDhgzhv/7rv3jiiScCm/6npaVRVFTE73//e7p168Yvf/lLXC4Xa9eu5Y033uDtt9+murqabdu2dXAEQoQnSdJCCB5++GFiY2N5/PHHWb9+fZOCAV6vlyeffJIHH3yQu+66i4qKCs6ePcvMmTPJy8vjyJEjrSrkIoS4djLcLYTg448/ZuTIkcyZM4f/+Z//YfXq1QwdOhRVVXnuuecYPnw4P/7xjwFITU2lZ8+e/OEPf8BgMPDnP/85UMtbCNG2ZOKYEIKKigoWLFiAwWBAURTuvfde9u3bx/3338/ChQsZOnQoPp8PgCVLlnDgwAHefvttfD4fvXv35sUXX8RkMnVwFEKEH0nSQgghRIiSZ9JCCCFEiJIkLYQQQoQoSdJCCCFEiJIkLYQQQoQoSdJCCCFEiJIkLYQQQoQoSdJCCCFEiJIkLYQQQoSo/x+5+AWkkt168QAAAABJRU5ErkJggg==\n", + "image/png": "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", "text/plain": [ "
" ] @@ -9273,14 +9413,14 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "import numpy as np\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='regplot', \n", + "ax = plot2d(plot='regplot', \n", " df=tips, \n", " x='size', \n", " y='total_bill', \n", @@ -9709,7 +9849,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 35, "id": "8f87664f", "metadata": { "scrolled": true @@ -9717,7 +9857,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -9727,13 +9867,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot='residplot', \n", + "ax = plot2d(plot='residplot', \n", " df=tips.head(10), \n", " x='tip', \n", " y='total_bill', \n", @@ -9762,13 +9902,13 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 36, "id": "456843ce", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -9778,8 +9918,8 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "import pandas as pd\n", "\n", @@ -9787,7 +9927,7 @@ "flights = flights.replace({'month':dict(zip(pd.unique(flights['month']).to_list(), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]))})\n", "flights['date'] = pd.to_datetime(flights[['year', 'month']].assign(DAY=1))\n", "flights = flights.drop(labels=['year', 'month'], axis=1)\n", - "ax = grplot(plot={'[1]':'lineplot+scatterplot', '[2]':'histplot'},\n", + "ax = plot2d(plot={'[1]':'lineplot+scatterplot', '[2]':'histplot'},\n", " Nx=2,\n", " Ny=1,\n", " df=flights, \n", @@ -9814,7 +9954,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 37, "id": "8264c168", "metadata": { "scrolled": false @@ -9822,7 +9962,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABK8AAASMCAYAAABOPK58AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd3gUVRfA4d+2bHohBJKQAKEYehNFpKkgIoIgTURBBEW6iIL0Ir0pHQRFlCKodAVU9KMjFgQEBOmQAAECKZu67fsjZCWQQMoms9mc93l4yOzO3Dk7yc1Ozt57rspqtVoRQgghhBBCCCGEEMIBqZUOQAghhBBCCCGEEEKIrEjySgghhBBCCCGEEEI4LEleCSGEEEIIIYQQQgiHJckrIYQQQgghhBBCCOGwJHklhBBCCCGEEEIIIRyWJK+EEEIIIYQQQgghhMOS5JUQTiA8PJxbt25leGz9+vW8/fbbAMyZM4eNGzc+sI358+ezY8eO/ArRLlJSUpg9ezZt27alTZs2tG7dmiVLlmC1WvPlfDt37mTOnDl2b/fo0aOMGTPGbvsNGzaMzz777IH73P3zcK+RI0eyf/9+IiIiqF27NgDz5s3jww8/fOi5hRBCCJF2L9a6dWvatGmT4V9ERAQAZrOZzz//nHbt2tGmTRtatmzJjBkzSE1NBdLed5944gnbcS+88AK9e/fm/PnztnN07dqVZ5555r5z3OvgwYPUqFGDNm3a2O6Z2rVrxy+//FIwF+Med9/P/P333wwcOFCROO4l92NCFC5apQMQQuS/d95556H7HDx4kAoVKhRANLljtVrp27cvYWFhrF27Fr1ez+3bt3n77bdJTExk0KBBdj/n33//TWxsrN3bPXPmDFFRUXbbL68mTZoEYLvBFkIIIUTOffHFFxQrVizT58aNG0dsbCxffPEFXl5eJCYm8v777zNy5EhmzJgBQMuWLTMkSTZu3Ej37t35/vvv8fT0BGDo0KG0aNHiobGULl2aTZs22bZPnjzJK6+8ws8//5xljPnl7vuZ6tWrM3fu3AI9f1bkfkyIwkWSV0IUAcOGDaNixYr07NmTuXPn8tNPP6HT6fDz82PKlCn89NNPHDt2jOnTp6PRaHjiiScYP348J0+eRKVS0ahRIwYPHoxWq2XXrl3MnDkTtVpN5cqV2b9/P6tXr+a3337j22+/JSkpCU9PTz755BPGjRvHhQsXiI2NxcPDg5kzZ1KuXDm6du1K1apV+fXXX4mOjqZbt25ER0fz22+/kZSUxOzZswkPD8/wGn7//XfOnTvHkiVL0Gg0APj5+TF9+nQiIyMBuHbtGuPGjSMyMhKr1Urbtm158803iYiIoHXr1vz1118AGbbXr1/PTz/9hFqt5uLFi+h0OqZNm0ZSUhJr1qzBbDbj5eXFu+++a4tl7dq1/PLLL3zyyScAnD17lu7du7Nz504WLFhw3/UtUaKE7dirV68yd+5c4uPjGT58OFOmTGHt2rWsWLECtVpN8eLFGT16NK6urhn2mzRpEpMnT+bIkSMkJCRgtVqZOHEijz76aLZ/Dm7cuEHPnj25fv06pUqVYsKECQQEBNC1a1deffVVqlWrlrsfMCGEEEJk6fLly2zZsoW9e/faklDu7u6MHz/edm+SmbZt27J582a2bNnCK6+8kqcYKlWqhKurK5GRkaxatYrDhw9z/fp1wsPDmTJlClOnTuXAgQNoNBpq1KjB8OHD8fT05JlnnqFZs2b88ccfxMfH88Ybb9ClSxeATO9fwsLCGDZsGDExMVy+fJmaNWuyf/9+2/1M27ZtmTBhAt999x3x8fFZ3m9Wr16dXr16sW/fPq5fv063bt3o3r17htck92NCFC0ybVAIJ/H6669nGEKe2adaV69e5YsvvmDdunWsX7+eBg0acPToUdsb5dChQ3n22WeZOHEivr6+bNmyhXXr1nHq1CmWLVvG7du3GTp0KDNmzGDTpk3Uq1cvwydRZ86cYcWKFaxYsYLdu3fj7e3N119/zQ8//EC1atVYtWqVbd/IyEg2btzI/PnzmTlzJo8//jjr16+nUaNGrFy58r7Yjx07Ro0aNWyJq3Rly5alQYMGALz//vvUq1ePLVu28NVXX7F582a+//77h16733//ndGjR/Pdd99Rp04dPvvsM2rWrEnnzp1p2bJlhsQVwAsvvMCff/7JjRs3gLQh4O3ateP69euZXt+7BQUFMXDgQOrWrcuUKVM4cOAAn376KV9++SWbN2+mVatW9OvXj8DAwAz7HTlyhOvXr7N27Vq2bt3KSy+9xNKlSx/62u52/vx5xowZw5YtW3jkkUdsn/AJIYQQIu/uvRfr168fACdOnKBChQq2xFW6gIAAmjdv/sA2w8PD+ffff23b06dPz3COXbt2ZSu2H3/8EbVabRtlHxkZyYYNG5g5cyaLFi3i+vXrbNq0iU2bNmGxWJg+fbrt2OTkZNatW8eKFSuYO3cup06dyvL+Jb2UQ3JyMt9//z2TJ0/OcD9zt6zuNwFSU1Px8/NjzZo1zJ07l1mzZpGSkpLheLkfE6JokZFXQjiJe4eqr1+/nh9++CHDPiVLlqRSpUq89NJLNG7cmMaNG1O/fv372tq9ezdfffUVKpUKFxcXOnfuzBdffEFYWBjly5enUqVKALz00ktMnDjRdlx4eLjtxqxFixaEhoayYsUKLl68yG+//Wabvw/w7LPPAhAaGgpAo0aNgLRh7r/99tt9ManV6gfWtkpMTOTQoUO2mx4vLy/atWvH7t27qVmz5gOuHFStWpXAwEAAqlSpwk8//fTA/T09PXnuuefYvHkz3bt3Z/PmzaxevTrb1/due/bsoWXLlrbvXbt27Zg0adJ9Q8Zr166Nj48Pa9as4fLlyxw8eBAPD48Htn2vJ598kjJlygDQoUMHOnTokKPjhRBCCJG1rKYNqtVqLBZLrtpUqVS4urratrM7bfDSpUu2elgmk4nAwEAWLlyIm5sbALVq1UKrTftTcPfu3bz77rvodDogrbZWeuINoEuXLqhUKgIDA2nUqBH79u3j5s2bD7x/yc5IpKzuN3v16gVA06ZNgbT7tNTUVBITE9Hr9bbj5X5MiKJFRl4JUYSo1WpWrlzJlClT8PX1ZfLkyRmST+nuvcGyWCyYTCY0Gs19CSS1+r9fI+7u7ravV69ezciRI3F1daV169a0atUqw7EuLi4Z2km/YcpKzZo1+fvvvzGbzRkeP3r0KEOGDMFisdwXW3rcKpUqw3NGozHDfnffFN67b1Y6duzIxo0b2bNnDxUqVCA0NDTb1/dumZ3LarViMpkyPLZz505bgc+mTZvmavrA3aPWrFar7aZVCCGEEPmnRo0anDt3DoPBkOHxqKgoevXqRXJycpbH/v333/eVUsiO9JpXmzZt4vvvv7eNKk939z1bZvd9d98r3X2/YLFYsvxA8e77l7vbz0pW95vp0hNVKpXK1v695H5MiKJDkldCFCEnT56kVatWlC9fnrfffpvu3btz6tQpIO2NNP0NumHDhqxatQqr1Upqaipff/01Tz75JHXq1OHChQucPHkSgB9++IG4uDjbTcXd9u7dy0svvUTHjh0JCwvjl19+uS/xlBO1a9emXLlyTJkyxTZs/ObNm0ycOJGQkBA8PT2pWbOmbWpifHw8Gzdu5Mknn8Tb2xuj0ciZM2cAHjqyKt3d1+RetWrVAmDBggV07NgRePD1zardhg0bsnXrVttqkevWrcPX15cyZcpk2G/fvn08/fTTdOnSherVq7Njx44cX8+DBw9y5coVAL766isaN26co+OFEEIIkXMlS5akdevWjBgxwpbAMhgMjBs3Dl9f3wwfot3tm2++ISIigueffz5f42vUqBFr1qzBaDRisVhYtWqVrSQDYFux+sqVK+zbt4/GjRs/8P7lXlndT2V1v5kTcj8mRNEhaV4hipBKlSrx/PPP0759e9zd3XF1dWXUqFEAPP3000ybNg2j0cioUaOYOHEirVu3xmg00qhRI3r37o2LiwsfffQRH3zwAWq1mmrVqqHVam1D0O/Wo0cPxowZw/r169FoNFStWjVDzYbcmDt3Lh9//DHt2rVDo9FgsVho27YtPXv2BGDmzJl8+OGHrF+/ntTUVFq3bk27du1QqVQMGTKEt956i2LFimVruD1A/fr1GTBgADqdjtGjR9/3fMeOHVm4cCHNmjUDHnx971a7dm1mz55Nv379WLBgAd27d+f111/HYrFQrFgxPvnkE9RqdYb9Bg8ezPvvv0/r1q3RaDTUrVuXH3/8MUfTEB555BFGjBjBzZs3KVeunCy9LIQQQtjR66+/nmFEOsDgwYNp0qQJY8eOZeHChXTu3BmNRkNqairNmjVjwIABtn23bt3Kn3/+iUqlwmKxEBYWxpdffplhqlx+6NOnD9OmTaNt27aYTCZq1KiR4b4nIiKCdu3akZyczKhRoyhXrhzlypXL8v7lXnffz3Tr1s32eFb3mzkl92NCFA0qa3bmxwghBGmfEi5cuJABAwbg5ubG8ePHefvtt9mzZ0+mo6+EEEIIIUTh9cwzzzBnzhyqV6+udChCiCJORl4JIbLN09MTnU5Hhw4d0Gq1aLVaZs+eLYkrB9GlSxcSEhIyfW7VqlX3rXIkhBBCCCHsS+7HhMgfMvJKCCGEEEIowmq1Mnz4cCpWrGibAi6EEEIIcS8p2C6EEEIIIQrc2bNnef3119m2bZvSoQghhBDCwUnySogc2LFjB3Xq1LFtz5s3j+eff55WrVrxwQcf2FbBE0IIIcSDrVq1inbt2uX7SmpCCCGEKPycOnk1depUnnrqKdq0aUObNm0YNGgQAIsXL6ZFixY8++yzzJs3D5k5KbLjwoULTJs2zfbzcvDgQb7//ns2bNjAli1bMBgMrFixQuEohRBCiMJhzJgxtG3bVukwhBBCCFEIOHXB9r/++ouPPvoow0iZXbt2sX37dtavX49Go6Fnz56UL1+eli1bKhipcHRJSUkMGTKEYcOG8f777wNgsVhITU0lOTkZtVpNSkpKvi9lLIQQQgghhBBCFDVOm7xKTU3lxIkTLFu2jHHjxlGmTBmGDx/OTz/9RKtWrXB3dwegXbt2bN68OUfJq9u3E7BY7Dday3PIuwAYZnxstzYLG39/T6KjDQV+Xs+EO9fe48HXfvz40bRq1ZaSJUOxWq1ERxt45JHq1KnzGE899RRarY7Spcvw7LOt7P46hgxJS4jNmJG3KYl3t6PU9X6Q7H4vCiNHvN7OTK53wXnQtc6v9za1WoWfn4dd2xSFj73vxYoa+T2ZN3L98k6uYd7I9UuzeNMxrtxMJLi4e46O0+o0mIzmTJ+rVTGAJ6qUtEd4TkupezGnTV5FRUXxxBNPMHjwYMLCwvjss8/o27cv/v7+1K9f37ZfYGAgUVFROWrb7t+oZUsBKOpjdvz9FVg21v/h137VqlV4eLjy+uuvEhERgUqlwt/fk2+//ZabN6PYu3cvLi4uDB8+nKVL5zN69Gi7hrhsWfpXOru2o8j1fpBsfC8KM4e73k5OrnfByfJay3ubyEcWi1WSV3kk1y9v5PrlnVzDvCnq12/n4Uh+PR5FeKgvvVpXzdGxAQFe3LgRn+XzRf3aOiqnTV6FhoaydOlS23bPnj1ZuHAhfn5+9+2rVues9Fd0tEF+oO3sYb9AlPTNN9+SnJzMCy+0xmQy2r729vbmuedakpRkJSkphebNW/Hxx9Md9nXczZGvtzOS612w5HoXHCWutVqtkuSkEEIIUcQdPJ42AKVeVRklVVQ4bfLq5MmTnDx5MkMhUKvVSnBwMDdu3LA9FhUVRWBgoAIR/sdt7kcAJA0crGgcRZFb0p1r75b1tV+69Evb11evXqFbt5dZvnw1n366mF27/sdzz7VEo9Gwe/f/qFq1ut1jnDvXBYCBA1Mdop38kp3vhRC5YTabuH37BiaTY/7sF2bXr6uxWCyZPqeKiwPA6u2dp3N4e/vj7i7JKmc2depUpUMQQgiRD3YejrQlmezt0nUD4aG+PFWrVL60LxyP0yav1Go1kyZN4tFHHyU0NJTVq1cTHh5O06ZNmT9/Pp06dUKr1bJ+/XratWunaKzaY0cVPX9RpjXl/tp37foG8+Z9zGuvdcLFRUeFCo8wePAHdowuzbFj9lkU1F7t5Je8fC+EeJDbt2/g6uqOh0cgKpVK6XCcilarxmTKPHmlTj4PgCWwTK7bT01NISbmpiSvhBBCCAf0sOTUqcsxAISH+tr93KVLeMqoqyJGZbVanXb+26ZNm1i6dClms5nAwEAmTZpEcHAwixcvZsuWLRiNRpo2bcrQoUNz9AeNTBu0P5nmU7Dkehcsud4F697rfe3aRUqWLC2Jq3zwoOSVPVitVqKiLhF4VwJMpg0KkHuxvJL3pbyR65d3cg3zJr+vX3ZHTGUnOVWvakmHGx0lP395o9S9mNOOvAJo06YNbdq0ue/x3r1707t3bwUiEkIIoQRJXBVO8n0TQgghcicvU/ayO2IqPNTXIZNTwjk5dfKqsHCfNQ2AxPfsP+VMPJh74p1r7+64137WrLRaVe+9l7d6PfZqJ78Uhu+FEEo5dOgPgoNLERgYdN9zVquVqVMnEBFxGZVKxYgRYwkOTruJPHbsb2bPnsGnn/5Xuy+zx/KD+tpVACyZxCyEEEKI/HXweBSXrhsoXSLnI2QkKSUckSSvHIDmzGmlQyiyNGbHv/ZnztinVpW92skvheF7IYRStm37jk6dXsk0efX77wfR6/UsWLCU338/yKpVXzBkyAgSEgysWbMSk8lk2zezx/JNSkr+n0MIIYQo4rIaYZWeuPrg1ToKRCWE/UnyygHEL/pU6RCKrHgvx7/2ixYlO1Q7+aUwfC+EyK6EBAPjx48mJuY2/v7+jB8/he++28S2bVsAFV27vkHjxk/RvXsXli9fDWD7+p13+lKuXHmOH/+bypWr0L59Jw4ePMCFC+eZM2cRs2ZNZfToD23nqlmzNlWrVgPAbDaj1aa9tc+fP4devfowZswI276ZPZZfLGXK5vs5hBBCiKJo+4EL7Dh4Ech6ip8UNBfORpJXQgghhJ1t2PAt9erVp337Tmzf/j3//HOcH37YyuLFn5OamkqvXq/TsGHjTI81m0089VRTBg4czGuvdaRPn4HUq1efTp1ewd3dPUPiCkCv16PX64mOvsknn8xn0qQZbN/+PeHh4ZQuXda2X2aPCSGEEMJxZTWq6u6ElUzxE0WFJK8cgPvUiQAkDhulcCRFj3vinWvv7rjXfurUtFpVw4blrVaVvdrJL4XheyFEdl25EskLL6QtGNKixQscP36MChUqotFocHNzIyCgJLdv38pwzN2L/4aFlUOlUuHnVwyj0fjQ8127dpURI4YwaNAQgoNLMXv2DBITE9mx40ciIy+zZMlCzpz5977HevXqa98Xfhf11SsAWIKC8+0cQgghhLPILFGV1aiqauX9qVOxuCSsRJEiySsHoLkSqXQIRZbG4vjX/soV+9Sqslc7+aUwfC+EyK7Q0DKcPn2KqlWrsWbNSgICSnD27BnMZjOpqalcv34NHx9frFYLCQkGUlNTiYn5L5l17yp7KpUqQ3LrbomJCQwb9h5Dh46gSpW06YPTp8+2Pd+9e5f7klSZPWZ32Ui6CSGEECJNZgXWsxpVFRDgxY0b8QUdohCKkuSVA4ifu0jpEIosVanl6F20uCp0/pRUE3GxSQ/cZ+5c+9Sqslc7+SXeU/qBcB5t2rzEhAlj2LHjB4oV82fMmM7ExMTQp09PzGYzb7zRC61WS9u2Hejb9y3Klg0jKCjrT0/DwyszdepE5s5dzMcfT88wdXDTpg3cvh3NwoVzAahWrQa9e/fP99f4MJbSZZQOQQghhHBImY2ykgLrQjyYyprVR7kiS9HRBiwWuWz2pNSnBwEBXgyZs6vAz5tuxjtNFHvd8mlNwZHrXbDuvd7Xrl0kMFASKflBq1VjMlny9Rz3fv/UahX+/jlf9ls4F7kXyxt5X8obuX55V5Sv4c7DkXy5/RRw/3TA7NauKsrXzx7k+uWNUvdiMvLKAXhMHAdAwqhxisZRJF0fzvMVL7HtdC+lI8nSxIlptapGjcpbrSp7tZNfPBLGAZDgMU7ROIQQ9qG+cqfmVbDUvBJCCOEcsiqgnhPpday6tQiXmlVC5IAkrxyA6p6iveLBdu/eycSJY/nxx7QRUz16vEZqagparQ6A5s1b0KVLt+w1Zo7GXReXX6Haxe3bqofvVIDt5BeVVfqBEE7FbFI6AiGEECLXclJAPSdkdUAhckeSVw7AMGuu0iEUGpcvX2LBgtlYrWnTVJKSkrhyJYLvvtuBVpuLH+egJaz7Wrlpg9kxa1aKQ7WTXwye0g+EcCaW0NJKhyCEEELkWk4KqAsh8p8kr0ShkZyczIcfjmbAgHcZP34UAP/8cxw3N3eGDHmH6Oib1K37OG+/3Q+9XqkS7EIIIYQQQojC5t6RVlJAXQjHolY6AAEeY0fiMXak0mE4vBkzJtGmTTvKl69oeywxMYE6dR5l4sRpLF36JVFR11i8eEH2G73+Pq0eWZgP0drP2LF6xo7VO0w7+cUjYSQeCdIPhHAW6shI1JGRSochhBBCZEv6SKt0pUt4Uq9qSQUjEkLcTUZeOQBVcpLSITi89eu/QaPR0qpVG65evWJ7vGHDJjRs2MS23bVrD0aOHMI777yXvYYtSeg0jlnAPF1ysmO1k19UVukHQjgVa/6uQiiEEELYy87DkZy6HEN4qK+MtBLCQUnyygEYpn2kdAgOb9u2LSQnJ9O9exdMJiMpKSl0796Fl1/uQlBQMLVqpb/JWHNW+ypwARvWOnbNq2nT7FOryl7t5BeDp/QDIQqb777bRIsWrTN97oLFzPTpkzGbzZQvX5H33x9me+6jj6YREhJKp05dHviYEEIIURDSpwvKSCshHJdMGxSFwtKlX7JixdcsX76aGTPmoNfrWb58NcnJySxYMJuUlGTMZjNr1qzimWeeVTpcIYQoEtau/SrL55YtW0r//oNYtOgzEhMTOHbsbwD27t3N8ePHMuyb2WNCCCFEQQoP9ZVC7EI4MBl55QA8Rn0AQMLEaQpHUvi0adOOK1ci6dHjNcxmM7Vr1+WNN97KfgNRg3ixUgSbTw7IvyDzaNSotDpVEyfmbeSUvdrJLx4Jd/qBh/QDUfht3bqFAwf2kZBgID4+jilTZqFWq/nww9GYTCZ8fHwYNepD/ve/HfftV7x4AACXLl1g+vTJAERFXaNBg8b06dOfyZPHEx0djZeXF6NGjefUqZMsWjQPjUbDkCEjWLp0IQaDARcXPSNHjsXfv7gtrj///J3Fi+dhMplo27YDLVq0ZOzYERn2v3jxAnv27OKdd97j0KE/2LNnF506vcLkyePx8PAgIiKCd98dwtmzZ4iIuMzq1V8SFBSM0WiiefMWtnO9+3IXfD29sAJmswmtVsvNmzf56afttGvXkYSEtLoimT0mhBBC5Le7C7Tfu6qgEMLxSPJKFDpBQcH89NMeANRqNf36vUO/fu8oHJUQQmTk4eHBhAlTWbHic/bu3cWFCxdo164TjRs/xddff8WmTevw9va5b7+2bTsAULp0WebPX8K1a9eYOHEMb77Zm82bN1KjRi3at3+Zn37azrffrqV69Zp4eXnz0UfzWLt2FXXq1KVTpy7s2bOTFSs+Z9CgIbaYFi6cy8yZc/D29mH58k/ZuHHdffs3bvx0pq/n5s0bzJ69kH/+Oc4333zF+PFT2LZtC126dMt0fz9vHwB2/PwjycnJhIdXYty4EfTv/y6//34QAKvVyrx5szI8JoQQQuTWvSsGPsipyzFA2ogrKc4uhOOT5JUDkBFXCio5m80nHbvmlb1GSjnqiKt0MuJKOJuwsHIA+PsXx2CI5/LlS3Tt2h2AKlWqsW3bFqpWrX7ffndLTExk4sQxDBkyAk9PTy5evMCJE8f43/9+xmw2ER5eGYDSpUsDcPnyJVq0aGU7x4YN6zK0Zzab8fMrBkDPnm8zc+aUB+5/tzJlyqLRaPD3L05q6sMXurCUCmH79u/ZunULU6fO4tKli5w7d5bx40dx61Y0ZrOZ8PAqmT5Ws2ath7YvhBBC3G3n4Ui+3H4KSEtIPUx4qC/1qpaUqYJCFBKSvBJCCCHygUqlyrAdEhLCP/8cp2HDJpw48TfBwaUy3S+dxWJhwoQxdOnSjTJlygJQqlQI1apVp0WLFzhx4hi3bkXfaUN95/lQ/vnnONWqVef48WO2c6RzcXEhLi4WDw9PRo4cQs2ade7b38VFz61bNwE4d+5Mlq/nYfbu3c22bd8zffpsXF1dKVPGgxUrvgbSplUaDPHUrFkr08eEEEKInLg7cdWtRbgkpIRwQpK8cgCeHwwGZNVBRVzrx0uVr7Dhn0FKR5KlDz5Iq1WV19UC7dVOfvE03OkHsuqgcFJdu77B5MnjWb16BV5eXowdO5GdO3/Jcv///e9njh79i8TEBFav/pLy5Svw9tv9mTx5HFu2bMRisTBq1Hiioq7ZjmnTph0TJoxh586f0Wq1jB79YYY2e/fuz9Ch72KxWHjppQ40afLMffv7+voRH2+gX7+3KFOmLHq9a5Yxenp68vnnSylbNuy+mldLFsxGo9Hw/vsDgbSRXrVrP5rbyyeEEEJkKX2qoCSuhHBeKqvValU6iMImOtqAxWK/y+YxdiQACeMn2a3NwiYgwIsbN+IfvqO9z2sdz64/L/Pdv30L/NwAM95p8tDXPXZsWtJp/Pi8JZ3ubkep6/0gHgl3+oGH8/UDR7zezuze633t2kUCA8soGJHz0mrVmEyWTJ9TR0YCYCmVtz8i7v3+qdUq/P2lqG5RZ+97saJG3pfyRq5f3tnrGqbXuEovuP7Bq3XsEJ3jk5/BvJHrlzdK3YvJyCsHUJSTVoorMZPv/nXsmld5TVrZu5384oxJKyGKsrwmrYQQQoh73VuQ/e6i61JwXQjnJskrIYQQQgghhBAOKz1pdXeyKv1/KbouRNEgySsH4PleWj0Qw6y5CkeiDG8fNyBt+GaBu9qL9lWusu7E+wV/7mx677206X6zZuVt5JS92skvnoY7/cCzaPYDIZyN+vIlACyhpRWORAghRGF09yire0dYSbJKiKJHklcOwHpn2fKiSu+iZcTCfRiNpgI/94xX/Ek0JhT4eXPCz88+NT3s1U5+saqKdj8Qwulo5BZDCCFE7t1dy0qSVkIIubN0AAmjxikdQtFVYgrbTjt2zatRo1Idqp38kuAxTukQhBB2ZAkOVjoEIYQQDu7eGlZ3K2pF2IUQDybJKyHsyGyxYrVaUalArVKhUqmUDkkI4cBOnz7F0aOHad/+ZaVDydShQ38QHFyKwMCg+56zWq1MmjSeS5cuoVKpGDFiLEFBwUydOoGIiMu2xwIDg5g0aRyRkREEBgYxfPgY9Hq9Aq9GCCGEo7l7dNW9SpfwlCLsQggbSV45AK+BfQCIn7tI4UiKoKtv0KnaNb4+NixXh6cazcQnGTEkGUk1WjDftWy3CtC7aHBz0eDl4YKbiyZXyayBA10BmDs3OVcx2rud/OJluNMPPKUfiKKjYsVwKlYMVzqMLG3b9h2dOr2SafLq998PotfrWbBgKb//fpBVq76gSZNnbI/9+f1mVn+ygMeeeRa9Xs/ixcvYtu07vvtuo8Mm64QQQhSM7QcusOPgRRldJYTINkleOQBzsMzdVow2lJhkS44PS0w2ER2XTEJyWp0uvU6Dl7sOnVaNWqXCarViMltJTjUTk5DKbUMqOq0af289Ph4uOUpiBQfnPL78bCe/mNXSD4Tz2Lp1CwZDPJ06dbF9XaHCI6xduwqTyczNm9cZM2YisbEx7Nmzi759BzJu3AhiY2MJCgrG09OLTp1eYe7cWUyZMourV6/Yvv7uu418991mAHr16kudOnVt501IMDB+/GhiYm7j7+/P+PFT+O67TWzbtgVQ0bXrGzRu/BTdu3dh+fLVALav33mnL+XKlef48b+pXLkK7dt34uDBA1y4cJ45cxYxa9ZURo/+0HaumjVrU7NmDQDMZjNarZaaNWtTtWq1tMdUKrQ6HZcvX7TFWKVKNb78chnt2xfEd0EIIYQj2nk4ki+3nwL+K8AuhBAPI8krB5A4bJTSIRRdAR/y45ns17wymS1cu5WEIcmIRq2iuI8rPh4u6LTqLI+xWKzEJxq5bUjh2q0kbsWlUMLPDU83XbbOOWyYfWpV2aud/JLoLv1AOL/k5BTmzFnITz9t58cft1GvXn0A9u3bTalSIUyaNIO1a1dx7dq1TI+PiYlh27bvWbjwU5KTk3j33f588snntuc3bPiWevXq0759J7Zv/55//jnODz9sZfHiz0lNTaVXr9dp2LBxpm2bzSaeeqopAwcO5rXXOtKnz0Dq1atPp06v4O7uniFxBaDX69Fq1URFXeeTT+YzadIM9Ho9er2e6OibLPrmKyZNmsH58+fYtesXmjV7jt9//5WUFMdc8VQIIUTBSK9x1a1FuBRgF0JkW9Z/cQshMohLSOXclXgSkowU93GlfLA3xX1cH5i4AlCrVfh4ulCmpCelinsAEHEjgWu3EklOLfgVFoUQBctq/W86cVhYOQD8/YuTmvpfQjkyMoLw8MpA2oimrNq4ciWCyMgIBg7szdCh7xIfH5ehnStXIqlUqQoALVq8gFaro0KFimg0Gtzc3AgIKMnt27ceGJ9KpcLPrxhGo/Ghr+3q1SsMGTKIQYOGEHxnFPG1a1czPPbkkw3x8fGlb983SUhIwNvb+6HtCiGEcE47D0dy6nIM1cr7S+JKCJEjkrxyAF593sSrz5tKh1E0XXmNV6pPfOAuVquV67eTuBKdiF6nJizIi+I+rqjVOatfpVKp8HLXUTbICz8vPTGGVN6fs5ubsUkPPK5PH1f69HHN0bnys5384hX/Jl7x0g+Ec3BxcSE6OhqAc+fO2h7PaspwmTJlOXHiOACnT/+bZRuBgUGUK1eB+fOX8PHHC3j22Ra4uLjY2gkNLcPp02lTMdasWcm1a1c4e/YMZrOZpKQkrl+/ho+PL1arhYQEA7dv3yIm5r9k1r3xqe5Mg85MYmICQ4cO5v33h9kSbomJCQwb9h7vvz+M2r5+qC9e4MKF89SsWZuFCz/Fx8cn0+ScEEII53f3dMEmtUMUjkYIUdjItEEHYK5QUekQii6XcG4kZL3qlcVq5crNBAxJJnw9XSjp55bnFQTVKhUl/dzwdNVyMyaJiV/+ycD2NSgXnPlohAoV7FOryl7t5BezRvqBcB6PP/4E69atZeDA3pQoUZKSJR9cz6NBg8bs2bOL/v174erqSmhoGfz9i1O6dBnefvsNqlRJqyNVrJg/DRs2pk+fniQnJ91X+LxNm5eYMGEMO3b8QLFi/owZ05mYmBj69OmJ2WzmjTd6odVqadu2A337vkXZsmEEBWX9yXd4eGWmTp3I3LmL+fjj6RmmDm7atIFbt26xcOFcAKpVq4GPjy+3b0ezcOFcVKmpVAuvRLe+7zB//mxWrPicMmXKMnToyNxeViGEEIXY3dMFW9Qvy40b8QpHJIQoTFTWrD5SFVmKjjZgschls5eAAC9GLNyH0VjwU+hmvNOEIXMyr3llsViJvJlAQrKJkn5u+HnZf2n3gZ3rMOaT/cQlpvJux5qEl/az+zkyExDgJTcMBUiud8G693pfu3aRwMAyCkaUM4cO/cGePbt45533lA7lobRaNSZT/ibG7/3+qdUq/P3vX1JdFC1yL5Y38r6UN3L9Hmzn4Uhboupud68sKNcwb+T65Y1cv7xR6l5Mpg0KkQmL1UrEncRVYLH8SVwBhJb0YmS3uhT3cePjb45w6tLtfDmPEEIIIYQQBeHg8SguXTfc93jpEp6ysqAQItdk2qAD8OrVHYD4JcsVjaNIiuzMqzWus+roWNtDVquVa9GJJN5JXPl65k/iKp2PhwtDXqnN9NWH+PibI3zQpQ5hQf9NIezVK61O1ZIlyXk6j73ayS9e8d0BiPdarmgcQiitTp261KlTV+kw8kx94TwAlrJhCkcihBCioKQXZA8P9eWDV+soHY4QwolI8soBmKrVUDqEosu1Flfiz2V46GZsMnGJaSsK5nfiKp2PhwtDX6nNpBV/Mufbo4zq+ijFfd0AqFbNPlNy7NVOfjFppR8I4Uysbm5KhyCEEKIA3D1N8NTlGAAZYSWEsDtJXjmApIGDlQ6h6PIfxv/O/1fzKi4hlei4FHw8XPD3LpjEVTofTz2DOtZk8oo/+fibI4zo+igerjoGDky1S/v2aie/JLlJPxDCmVhLBiodghBCiHx29wqC4aG+hIf6Uq9qSZ6qlfViIEIIkRuSvBLijhSjmWu3EnFz0RBYLO+rCuZGcHEPBrSvzsw1h/l0ywkGdKiBWoE4hBBCCCGEyEr6aKv0kVbdWoRLwkoIka+kYLsD8H7jNbzfeE3pMIqmiPZ0qzUGi8XKlZsJqFQqgot7KJK4Shde2o/OTSty5Gw03x+4yBtvuPLGG655btde7eQX7/jX8I6XfiCEs1CfP4f6/LmH7yiEEKLQSS/KHh7qK4krIUSBkJFXDsBY93GlQyi63OpzMeYs12OSSDFaCA3wQKdVPqf7TJ1SnI2MZePuc4SWD6GkX95rx9Sta7ZDZPnHqJV+IJzbzz//xJNPNsTtrlpQn332CRUrhtO48VP37X/o0B9MmDCGUqVCADAYDLz1Vh8aNGiUaft79+5i2bKlaDQa+vQZkKHoe2JiIuPGjSQ+Po4KFR5h8OChmM1mxo8fRXT0TcqWDWPIkBF2TdxbPTzs1pYQQgjHU7qEpxRlF0IUGEleOYCkfgOVDqHo8n+frf/sIMaQgJ+XHg83ndIRAaBSqXi9RSUuXTcQn/QrQ954HHDJU5v9+hntE1w+SXKTfiCc24YN3/D440/k6JinnmrKO++8B8CtW9F88MG7WSavli//jI8/no/FYmHEiPdZtGiZ7bktWzZQvXoNunZ9g2XLlrB//16SkhIJCyvHhAlTmT17Jn/88RuPPVYv9y/wHtYSUqxXCCEKs7sLsd/r0nUDpUt4FnBEQoiiTPkhJkIoKCHJyNVbibho1QT4ONaUOr2Lhl6tq5CQbOSL7aewWq1KhySEyKZDh/6gV6/uvP32G6xdu4q//vqTM2f+ZcaMyVy7dpU+fXrwzjt9OHToDwAiIi6zcOGcB7YZHR2Nu3vaaKa3336DsWOH06PHq6xbtxaAChUqkpCQQFJSEq6uGUdrXr58idq100ZiValSjX/+Oc6JE8dso7Pq1n2co0cP2/MSCCGEKMTSC7Gn17S6V+kSnrKioBCiQMnIKwfg3fVlAOJWrFU4kqLn+t/NGNY0iRVHpqBWO15h9NIlvbi46ykOrEugRvmrNK4ZnOu2unZN+2N2xYokO0VnX95xd/qBt/QDUfjt27eHl1/uwtNPN2P79u+pXftRKlR4hCFDRvD550t4441ePP74E4wYMQSAkJBQ+vZ95752du78mdOnTxEVFUXp0mV4771hAMTE3Gb06A8JDAzizTe78eKL7QgOLkWvXt0BK+++OzRDO2Fh5fjttwNUq1ad338/iFqtJiEhAXd3dwDc3NxITEy06zVQnzsLgKVcebu2K4QQIv+lj7iSelZCCEchySsHYGzUROkQiqSkFBM/HauIu6sWN73jdoV2rV3Y/NNnjB+2gZLF3CkdGsoHH4xCo9Ewc+ZUTp8+hZubGy1btqZDh85ZttOokakAo845o076gXAer73Wnc8/X8KGDd9Sv36DDM9dvHiR117rDkCVKlUf2E76tMEjR/5i7tyPKHFnKp6/f3FCQkIBKFOmDP/+e4pt277j6683YbFY6N+/Fw0bNkavTxtR2qpVWz76aBr9+/eiRo1auLm5YTabSEpKS2YnJSXiYecaVVYvL7u2J4QQomCFh/pK4koI4TAc9y/2IiSpV1+lQyhyrFYr124lkpDckWJeetQOPIG2SZOjbP9hI8GN+1O1QjDaqF9YunQRqampuLm5sXLlN1gsFoYPf4+goFJZ1sPp1cvRa15JPxDO4+eff6Bjx1cIDS1Njx6v8dJLHVCpVFitVoKDS3Hy5D88+WRDzpw5TenSZR/aXs2atXn88SdYunQRAwa8y+3bt7h58ya+vr5cvnyZcuXK4+bmhk6nQ61Wo1arMJsttuNPnvyHF154kRo1arFo0Txq1KhNVNQ1/vrrT2rWrM0ff/x+X5Itr6wBJezanhBCiIKx83Akpy7HEB7qq3QoQghh48B/sguRf27Hp5BitPBW2+oOOV3wbpUqVeabrzfSsWlVDv97jZNnL+Pj48upU//w3HMt0Wg06HQ66tdvyM6dPysdrhACqFgxnNGjh9G/fy9q166Du7sHlStXZfz4Ubz+eg9Wr/6SgQN7ExsbA2Sv5tXrr/dk377dRERcRqPRMnv2dHr37kGHDi/j5uZGx46v0LdvT/r06UmbNu1xd3fn88+Xcvr0KUqVCmHx4vn07t0DgJo1a/HMM804f/4cvXv3IDExIcfF5IUQQjif9FpXgNS0EkI4FBl55QB8OrcDIHbNeoUjKRpMZgs3Y5PxcNVS368nxerc4rND05UOK0udO6fVqurT5ywXf5kMKi0D+vbn1q1ofvhhKzVq1CI1NZVdu35Bq826S6e3s2aNY9a88om70w+8pR+Iwq9mzdosX746w2N9+/63oub8+UvuO+bemld16tS1FVQHcHV1Zc2aDQBotVomTsz4e+v551vx/POtMjwWFBSMXq+nePHiLFz4aYbntFot48dPzsGryhnN2TMAmMtXyLdzCCGEsJ+7E1dS60oI4WgkeeUAUpo/r3QIRcrN2GQsVijh54bKszUnbpxWOqQHat48rVZVkyZPs+Krxxg0bj6D3u3H2tVrWLhwLm+80QV//+I89lg9/v776EPbcVQpLtIPhLC3Rx99jACFpu9ZfHwUOa8QQoic2Xk4koPHo2wrC0riSgjhiCR55QCSe7yldAhFRorRTIwhFV9PF/Q6Dfj15cDlXUqH9UDNm58jOjoaqEVICU/avfQSC8ev4+T5KPr2HYi3d9ofiCtXLickJCTLdnr0cOyaV8mu0g+EyK57R3VlRanEFYC1eIBi5xbK2rlzJ7NmzSI1NZXw8HAmT56Mp6dnhn3++OMPJk+ejNlsRq/XM3r0aKpXr65QxEIUXXePtgoP9aVe1ZKSuBJCOKQiUfNqx44d1KlTx7a9ePFiWrRowbPPPsu8efOwWq0KRicK0o2YZNQqKO7jqnQo2RYdfZNx40YQExMDgGfyKdx8g5i75AuWLl0MwK1b0WzZspFnn22hYKRCCCGKulu3bjF8+HDmzZvHDz/8QGhoKDNnzrxvv6FDhzJkyBA2bdrEW2+9xbBhwxSIVghx8HgUkDba6oNX60jiSgjhsJx+5NWFCxeYNm2aLUG1a9cutm/fzvr169FoNPTs2ZPy5cvTsmVLxWL0af8iALHrNisWQ1GQlGLCkGSkuI8rWs2dvO2lZvSqe5slf3ykbHAP8OGHT5Kc/DYDBvRCo9FSvHhx3h06ga93R3Ly7Pd07doJqxV69OhF5cpVs2ynffu0mlfr1jlqzas7/cBb+oEQzkBzJm1KtrlCRYUjEQVp7969VK9enbJlywLwyiuv0KZNG8aOHYtK9d8CKWazmbi4OAASEhLQ6/U5Oo+/v+fDdxIPFBDgpXQIhVphvX7bD1xg118Rtu2IGwaqlfen47OVCjyWwnoNHYVcv7yR61f4OHXyKikpiSFDhjBs2DDef/99AH766SdatWqFu7s7AO3atWPz5s2KJq9S2rZT7NxFyY3YZDRqFcW87rpB9n6Zw9f+VS6obGjb1gR0oGvXNrbHrFYrf100ctP3Feb1egJXl4d35bR2HFeKi/QDIZyJxc9P6RCEAq5du0ZgYKBtOzAwEIPBQEJCQoapg5MnT6Zfv35MmjSJ+Ph4li1blqPzREcbsFhk5HxuBQR4ceNGvNJhFFqF8frdW9cqPNQXgJAAT+pULF7gr6cwXkNHItcvb+T65Y1arVLkQySnTl6NGTOGl19+mfDwcNtjV69epX79+rbtwMBAoqKictSu3b9RgwcAUNRzvzpd/v04JiQZSUw2Eejvjl6v++8J37f4K2ofOl3Wx+a3h2X9Bw9O/yrjVMfe7WoyZN4e9hyLostzD/+07N52HO/TBufuB453vZ3b3df7+nU1Wq3zz5J/+ukGVKpUBZVKhcFgoHHjJrz55tsPPGbmzKmEhITSufOrTJ8+hfPnzwFw5sy/jBnzIY0aNQHg+PFjzJ8/B4CEBAMqlYovvkiruxUVdYV+/XqxcePWjI2XtE+9LbVaLf2nELFYLJk+rlb/1wdv3rzJ6NGjWbFiBdWrV2fHjh0MHDiQH374wfbhohDCfqSulRDCGTht8mrVqlVotVo6dOhARMR/Q2Mzq2919w1VdsinffaV/keJ0Zg/I4OsVitXow1o1Cq83XT3nSe/zptduc36+3voqFupBOv+d5q6FYvj55X9KRfyaUPBkutdsO693haLBZMp8z+onUmpUqHMm/cJkPaa33yzK+3bd8bLK/PEz969u/n7778JDg7BZLIwePAHAJw9e4bFi+fxxBMNbdctPLyKre1x40by0ksd7zxnYf78uWi1Lvl2jS0WS4bvp1Kf9onsCQoK4siRI7btqKgofHx8MiSl/vjjD4KDg20F2ps1a8bkyZM5e/asFG0Xwo5kFUEhhDNx2uTVhg0bSE5Opk2bNhiNRtvXVapU4caNG7b9oqKiMgxvV4JP27Qpi7H3fmot7CIxxURSipkSfm6o1aqMT158it6PxbD49zmKxJYdbdum1arauPH+WlUdnirP4dM32LDnHD1aVs51O47AJ/ZOP/CRfiAKv61bt7B16xbMZhNjx05izpyZJCYmkZiYwPjxk7l27Spr167CZDJz8+Z1xoyZSGBgIKNHD8NoNOLp6UmFCo/Qo0cvZs2ayoUL59HpdAwfPoYSJUoyYsQQJk+ekeX5ExMTMZlMuLjomDRpHFarlcjICIKDSzFq1Hiio6P56afttGvXkYQEQ4ZjP/lkAX36DMxQnyjdP/8cx2KxULNmLQCWLVtKu3YdmTNn1n37Ss2roqlhw4ZMmzaNCxcuULZsWdasWUPTpk0z7BMeHs7p06c5f/48YWFhHDlyhKSkJMLCwhSKWgjndPB4FJeuG2S0lRDCKTht8urbb7+1fR0REUHr1q3ZtGkTv/zyC/Pnz6dTp05otVrWr19Pu3bK1tpJ7vyqoud3dtFxKWjUKnw9Xe5/0qc7f/x2suCDyoHOnY1ZPlfC142mj4bw42+XebZuKKElsh6N8KB2HEGyXvqBcC5lypRlyJARnDhxjI4dX6FOnbp8/fVq9u/fQ7lyFUhOTmHOnIX89NN2fvxxGwEBATRs2IR27Toyb97HAOzbtxtXVzfmz1/CsWNH+fzzpXzwwahME1eRkZfp378XMTG30etd6dNnAHp92jThOnXqMmrUeKZM+ZDDhw+xceO39O//Lr//fjBDGxERl1GpoFy58pm+pm+/XUOXLl0B+OuvPzGbzdSu/Wim+1qKFcv1tROFl7+/P1OmTGHgwIEYjUZKly7NtGnT+Pvvvxk1ahSbNm0iLCyMcePGMXDgQADc3NyYN29ehppYQgj7KF3Ckw9erfPwHYUQwsE5bfIqK8888wz//vsvHTt2xGg00rRpU9q2batoTCmSvMo3SSkmEpNNBPi6os5kFAG+3fnjyq6CDywHOnd+8LTGVk+WZe/Rq3z9y2kGv1wr09ES2WlHaSmu0g+EcwkNLQ2An18xlixZyNatW7h16xZPPJFWdzEsrBwA/v7FOXHiOBcvXqRFixcAqFKlKhcunOfixQv8+ut+Tp48AYC3t0+W5ytVKpT585dw61Y0gwb1JTAw2PZczZq1AahcuQqnT//LuXNnGT9+FLduRWM2mwkPr0LNmrXYtesXmjd/PtP2TSYTly5dolKlKgDs2PED58+fo3//XkRGXmbq1AkMGzbatr+1mH+urpso/Jo0aUKTJk0yPObr60vJkiVt288//zzPP5/5z5oQIu92Ho7k1OUYW2F2IYQo7IpE8iokJIS//vrLtt27d2969+6tYET3MN4ZEaNk1XAnFR2Xglqlwtczi3pQViNqlQmL1XG7wsN+PDxcdbzYIIyvfj7N3+duUaN85n8wOvyPmfVOgCpHDVCInEmvp/j111/RsGFjmjZtzscfT7fVXrw30VyqVCn+/fckVatW49Spk+j1ekqVCqFZs+Z07/4mkZERHD586KHnLVbMn/7932XSpHEsXfoFkFaAvVSpEE6e/IfmzZ9nxYqvgbTpjQZDvG0a4JEjh2nW7LlM2z1z5nSGEVlDhoxAq1VjMlno3r1LhsQVAOmFu3NYV1I4p6ioKLp06aJ0GEI4vXvrXNWrWvLBBwghRCHhuH+xFyE+HdsAUvPK3lKMZgxJRvy99WjurXWV7tKz9KqrXM0ro8ny0FW0nnoq7f+dO7Pep2PzSuw8fIXN+y7w9ONl7q/tlUk73j5uxMU6Tv0rn7g7/UBqXgknU79+Az7+eDrr1n2Nt7c3er0rFTMpA9W6dVvGjRvJzp0/A1C79qM0bvw0Bw7so3//XiQnJ/Pee2lF1R9W8+rxx59g8+b1bN/+PQDff7+FNWtWUaHCI9SpUzfL46KirlK8eIBte+/eXcTFxdGyZWsiIyMoWTL7NSI1584CUvNKpClZsmSGkVdCCPu6N2klda6EEM5GZc1s+T3xQPZebVD/zRoAUjp2tlubhUlAgBcjFu6z+6p/V6MTiUtMpXywN1pN5p/8z+h+ma9++IdDV5vb9dzZNeOdJgyZ8+Bpiyf+SFtuvkrd6w/cLzYhlavRiQQXd8fb/f76Xne3o9Npmdy3gUOtgKdPudMP9M7XD2S1wYJ17/W+du0igYFlFIwoe44cOYxer6dSpcosWDCHsLBytGzZOs/tTpo0jk6dXqFixfAcH3vt2jV+++0AL774UqbPp4+8yozq1i0ArHmsfXXv909WGxQgKz/nlbwv5Y0jXr9pqw5x6bqB0iU8C0XSyhGvYWEi1y9v5PrljVL3YjLyygEU1aRVfjKZLcQlpOLj6ZJl4goAn9c4dNWxa149LGmVzttdR3SsmpuxyXi56e6bkpTddpTijEkrIXKiZMlAxo8fgdFowt/fn54931Y6JHQ6LS+88GKujs1r0koIIUT23F3fSoqzCyGclSSvHEFiYtr/7u7KxuFEYgypWAE/ryxqXaWzJKJTJ2O0uBZIXLlhTE1LvulcMh/dkE6lUlHcx5Ur0YnEJRrx8cg4+iq77SjGeqcfqKQfiKIpMDCQRYuW2b3dkSPH5fpYf//iuT+x2Zz2v0aT+zaEEEI81MHjUYDUtxJCODepouoAfLp0wKdLB6XDcBoWq5Xb8Sl4uGrR6x7yR9PllvR89IOCCSyX1n1SnXWfVM/Wvl7uOvS6tNFX984Izkk7SvCJ64BPnPQDIZyF5vw5NOfPKR2GEEIUCeGhvg4/VVAIIfJCRl45gOTuPZUOwanEJaRitlgp5v2QUVcAfn048OuJ/A8qD2o1uJLtfdNHX0XeTCQ2ITXDKos5aUcJya7SD4RwJpa8jNoSQgjxUOlF2tNrXQkhhDOT5JUDSGnbXukQnIbVauV2fCp6nRp3fTZ+vL1f5sg1x655VanOjRzt7+mmw9VFQ3RsCj4eLrbaVzltp6Cl6KUfCOFMrH5+SocghBBO7e7ElUwZFEI4O0leOQBVXCwAVm8fhSMp/JJTzaQYzZT0c7uvYHmmzLG4ag0kmxz306qUpLSpj3o3c7b2Tx99FXEjgRhDqq3uV07bKWgqy51+oJZ+IIRTMN9ZQVYjtxpCCGFP9464kiLtQoiiQO4oHYB3t1cAiN24VeFICr/b8SmoVdxXrDxLEW3oXjuGxb/Pyd/A8mDDp9UA6DzgSLaP8XDV4uaiITouGR9PF9QqVa7aKUje8Xf6gY/0A+H8pk6dwLBho7O9f//+vTCbzWg0GoxGI8WK+fPhh1PQ6XT37Zuamsq4cSO5ffsW4eGVeOed9zMk83/77VeWLl2IWq1h0KD3qVDhEd59t5/t+RMnjrFhw1Z8fHzz9Bo1588DYK5QMU/tCCGEyEhGXAkhiiJJXjmApDd7Kx2CUzCZLcQnGtOSNepsjLoCKDaQvfuP529geVSncWSOj0kffXX5RgJxd2pf5aadgpTkKv1AFB05SVylmz59Nl5eXgB8/PF0Dh7cT8OGTe7b7+eff6Ry5Sp07foGU6Z8yKlT/1CpUhXb80uXLuLjjxeSnJzMhAljmDNnIfPnLwFg48Z1PPZYvTwnrgAsxQPy3IYQQojMyYgrIURRI8krB5Da6kWlQ3AKsQmpWME2TS5bvNpx7Lp/vsVkD4/UvJmr49xdtRlqX+W2nYKSqpd+IAqGT9uWJHd+lZTOr4LRiE/HNiS/2o2Ujp0hMRGfLh1I7t6TlLbtUcXF4t3tFZLe7E1qqxdRRUfj3bMrSX0GkPrc81meY+vWLezfv4eEhARcXV2pWDGcAwf2UadOXfr0GUD37l1Yvnw1ffr0JDS0NGfO/MszzzzLa691Z8mShTz7bAvCwspl2rbVaiU6+iZeXt5s3bqF3bv/h8FgwGq1MnHiNJ5/vhVmsxmz2czt27dxd/ewHWswGHBzc8PT0xNPT08SEw2YTCa0Wi3Jycls2bKRRYs+s8t1tvr62qUdIYQQ/9l5OJJTl2MID/VVOhQhhChQaqUDEKCKjkYVHa10GIWa1WolJj4Vd70WvU6T/QNNN3HXxeRbXPaQaNCSaMh5nlmlUuHv7YrRbCEu0ZjrdgqKyhKNyiL9QDgPT08vPv54ASqVmrCwcixevIz9+/dk2OfmzRv07Pk2ixd/znffbQKgV6++mSauhg4dRI8er/LKK+2oUqU6NWvWBsDLy5v585fQunVbNmz4FgC1Wk337q8QGxtD8eL/rfqXkGDA3d3dtu3ioic1NQWAHTu207Rpc1xcsjnt+mFMprR/Qggh7Obg8SgAmS4ohChyHPcv2SLEu2dXQGpe5UViigmj2UKAr2vODozsQLdajl3zavPnVYHc1arydNOi16mJjk3mt3WP5bqdguAdf6cfSM0rkc8y/K7V6TJuu7tn2LZ6+2Tc9vfP9u/q9ASUh4cHISGhaDQaNPcUL3d396BkyUAAXF3dHtje9OmzcXNzY+TIIRQrVsz2eM2atQCoXLkqBw7sA9KS1ytWfM3mzRtYsWI5b7/dz3a+pKQk27GpqSno9Wm/N3fv3snQoaOy9dqyQ3NBal4JIYS93F2kPTzUl6dqlVI6JCGEKFCSvHIASX0GKB1CoRdrSEWtUuHpdn/x4gcq9h679h3Ln6Ds5LGnI3J9bProqyvRiVR98jzu+hxenwKU5Cb9QDiX7Kx4mq1VUe+i1WoZNmw0PXt2pW7degCcOXMagJMnT1C6dBk2bvwWd3cPmjd/HldXNzSa/0ajenl5kZiYiMFgICUlGb3eFY1Gg9Vq5caN6xlGaeWVJaCE3doSQoiiKD1hBXDqcgwA4aG+MupKCFEkSfLKATyobop4OLPFQnySER+PHBRqT+fVmn9ueOdPYHZSvlreptJ5uetwiVWjD46kbKAnkMNrVEBSXaQfCAE8tOaVn18xXn21G0uWLKBWrTqcOnWSgQN7o9XqGDduElarhfHjR7Nly0Y8PDwYOXI8165dY+3aVbzzznv06tWXd9/th9VqZdCg9wGIibmNp6eXXV+H1cfHru0JIURRsvNwJF9uPwWkJazSk1Yy4koIUVSprFarVekgCpvoaAMWi/0umyoq7RMVa8mi+SlKQIAXIxbuw2jMXW2U2/EpRN1OomygJ64uOcvHzugXzodL9xOfqkzR9hnvNGHInF0P3CchLm20lIe3MdfniTGkcOGyhWB/d0qUsKLTaZnctwE3bsTnuk17U1nu9AO18/WDgAAvh7rWzu7e633t2kUCA8soGFH+2bp1CwZDPJ06dXngfiaTiS+/XEaPHr3sen6tVo3JZMn8SeOd31m6vI34vPf7p1ar8Pf3zFObovCz971YUSPvS3mT39fv7sRVtxbhTpmwkp/BvJHrlzdy/fJGqXsxKdjuALzffgPvt99QOoxCKzYhFb1OnbNC7ekiO/NqzQ/tH5QdbfmiClu+qPLwHR/Ax8OFv7bWZeuKqjhqvto7/g2846UfCJEfzGYz7dt3KtBzai5eQHPxQoGeUwghnEH6VEFnTVwJIURuyLRBB5A48F2lQyi0klPNJKeaKeHrluPaMQD4D+N/e4/aPzA7qtfsUp7bUKlU1H36IrfjU0lMMeHi4ni1rxLdpB8IkVMtW7bO1n56vR69Xp/P0WRkKeF8oyiFECI/SVF2IYTImiSvHIDxmWeVDqHQik1IBcDbI5fJGM8WnLr54BW+lBZW+bZd2qlaO55zV+KIjtXg6+V4r9noIv1ACGdi9XbseoJCCOFI7q1xJUXZhRAiI0leOQB1ZNpqcpZSIQpHUrhYrVbiElLxctOh1eRyBqzxMj6u14lNdtxVseJup42W8PZLyVM7hhhXXCwqElNiSEjOff2s/KI23+kHGukHQjiF1LQPF3BxUTYOIYQoBGSqoBBCPJjUvHIAXv164dXPvkV0iwJDkhGzxYqPZx7+MLrSlVeqT7JfUPlg68pKbF1ZyS7t7N9YE41axY3biXaIzL68DL3wMkg/EMJZaC5dRHPpotJhCCFEoSFTBYUQImsy8soBJL47ROkQCqUYQypajQoP1zz8GBcfxc+7j9gvqHxQv7l9/vhLb8fDS8/N2GTORsTgrc9Fkft8kugm/UAUDd98swar1ZLlCoFXr17hzTe7EhZWHgCDwUD79p1o3bptlm3GxcXx7rv9+OyzFQCcOHGMOXNmYbFYeOutPjz++BO2fa1WK9OnT+LixQsEBJRg5MhxuLi48OqrHfDzKwZAly7dePLJhnl6nZYiuoKuEEIIIYSwP0leOQBjk6eVDqHQMZosJCSb8PfW565QezqPZpy+5XjFy+9WJjzGru2YLXpuxafwzc+n6dky7yO67MXoIv1AOL958z5iz55ddOjw8gP3q1GjFlOmzAIgOTmZHj1ezTJ5dfr0v0yfPonbt2/ZHluyZCETJkzF29uHQYP6ZkheHTnyFyqVioULP2X58k/Zt283jz76GCEhoUyb9nHeX+QdVi+peSWEEA9zd5H20iUKful5IYQoLCR55QDUF84DYCkbpnAkhUdcYlotFR+PPNZSST1HMbcr3EoKtkNU+SPmpisAvsWT7daOv7cr+/++Qst6oQT5e+Q5RntQm+/0A430A1H4xcXFMWbMMCwWC35+flStWp1OnbpQq1YdypeviMEQD0BiYiKzZk1l9OgPs2wrPj4OnS7td13//r0oXboMp0+f4tFHH6d37/6YTEamTJnJ+++/Yztm1qx5aDQarl69ct8qg7Vq1aF69ZoA3Lx5g6pVq3HmzGmuXbtG//69CA4uxeDBH+Dq6pq3i5Byp05fAa9yKIQQhcndiSsp0i6EEFmTmlcOwGtQP7wG9VM6jEIlPtGIq4sGF10ep71d7UGnatPsE1Q+2f5VONu/CrdrO8V93NBp1Gw7eCnP7dqLl6EfXgbpByL/+cS2RJ+8Km3DakzbTllzZzvxzvY6AFSWWHxiW+KSsvnOdnTaduq2B57j++8307jx08yduxg/P3/b440aPZVhP3d390wTV0ePHqZ//1507tyOsWNHMHToSNtzzZo9x5IlX3Dy5AmuXr1C5cpVKV48IMPxGo2GAwf20qtXd+rVq39f+xqNhvfeG8iff/5OWFgFvLy86NatB/PnLyEsrDxff736ga8vOzSXL6G57Di/Y4QQwpHsPBzJtFWHbImrD16tI/WuhBDiASR55QASh44gcegIpcMoNFKNZpJTzXi722G6X8B4fjzzRt7byUcNnr9Ag+cv2LUdrVbNs/XKcODYNW7F5W1El70kuo8g0V36gXAOkZERhIdXBqBmzVo5Pr5GjVrMn7+E6dM/Ii4ujqCgIABUKhU1atRCpVIRHl6ZSw8oiF6/fkM2bNjK/v17M91v1qy5DB48lAULZlO6dFkaNWpy57gGnDt3Nscx38sSGIglMDDP7QghhLPZeTiSL7ef4tTlGBlxJYQQ2STJKwdgfLIhxjwWxi1K4hKNAHi522H5dfcmnLtdK+/t5KPQCrGEVoi1ezsvPVUBqxV++O1yntu2B6OuIUad9AOR/2J9tpLi+mrahkqXtq3vfGfb/c52ewCsah9ifbaSqn/xzrZ/2rbL8w88R5kyZfnnn2NAWk2q3CpduiydOr3CrFlT085vtXL27Jk77Z4iJCQ00+OGDh2EwWBAq9Xi4qJHo/lvlOq+fXtYuXI5AK6ubqjVajZv3sDatWmj0Q4fPkT58hVzHXM6q6cXVk+vPLcjhBDO5uDxKAC6tQiXEVdCCJFNUvPKAWjOnAbAXCHvfyw4O6vVSlxCKm56DTqtHXKvKacIcL/EjcTSeW8rn9yKcgOgWMkku7ZTspg79aqUZNeRSFo9WcY+ycA80Jjv9AON9ANR+LVu3ZYPPxzNnj27sFgstlFN98pOzatWrdqwZcsG/vrrTwBWrlxOVNQ1GjZsTKlSIZke89JLHRg8uD9qtZomTZ6hVKkQNm1aT8mSgTz2WD22b/+e/v17odPp+OCDUfj6+jF27HD69+9FsWL+DB8+Ju8XIfnOqM681s4SQggnkF6YHeDSdQPhob6StBJCiByQ5JUD8LxTZDd241aFI3F8KUYzqSYLgd5u9mnw2tu0rxrD4t/n2Ke9fPDj148A0HnAEbu307J+GQ4cv8aOPyJ4qXG5PLWfV56GO/3AR/qBKPxcXV2ZPHkGAFu3brEVaAdo2bK17evMal4FBQXbVhoEUKvVLF36pW176NCReHndP6Jp+fL/6lTVr9+Q+vUzjmQsWzaM5ORkXFxcmDBh6n3H23OlQQBNRNqoTvlgRghR1KVPEwQID/WVqYJCCJELkrxyAAkjxiodQqERl3BnyqCbHepdAQRMZtvOv+zTVj5p1Op8vrVTqrgHtSsW5+c/I2hRrzRueuV+JSS4Sz8QIj8FB5ciIKBEgZ3PfKdOlxBCFGV3J666tQiX0VZCCJFLkrxyAKbH6ykdQqFgtVqJS0zFw1WLRmOncm3uT3IxxmiftvJJqbC4fG3nhfpl+ev0H+w6fIUW9ZSbPmnSST8QzunukVZ5NX/+klwfW5CJKwA8PAv2fEII4UDSpwmeuhwDSOJKCCHySgq2OwDNPyfQ/HNC6TAcXlKKGZPZireHHWszpRyjpOc5+7WXD25cdefGVfd8a6dcsDeVy/jxw++XMJoseT5PbmlMJ9CYpB8I4TSSktL+CSFEEXTweJSttpUkroQQIu8keeUAPIe/j+fw95UOw+HFJaaiUtlxyiDAtf68VNlx610B/PxtRX7+Nu81Yx7UTsv6ZYg1pLLv2NU8nye3PBPexzNB+oEQzkITGYEmMkLpMIQQokDtPBzJtFWHuHTdQOkSnrKaoBBC2IlMG3QACWMnKB2Cw7NarcQnGvF006FWq+zXcIkZfPfLIfu1lw+atLHPyLAHtVOljB9lA73Y/uslGtUIQqMu+Lx2gof0AyGciTk4WOkQhBCiwKWPuJKi7EIIYV+SvHIAptqPKh2Cw0tINmG2WPF2t+OUQQC3x4iIS7Rvm3YWVDr+4TvlsR2VSsUL9cuwYMMx/jh5g3pVCv5my6SVfiCEU3H3UDoCIYRQRPqIKyGEEPYjySsHoPn7KADm6jUUjsRxxSWkolap8HCz849s8mGCvU5zJd5xl3K/HpH2B2CJkIR8baf2IwEE+buz9deLPF65BCqVHUe4ZYPGdKcfaKUfCNG9exeWL1/NnDmzeOutPri7577u3WeffcLOnT/j4+OL1WrFaDQyduxESpUKyfKYPXt28tdffzJw4HucOHGMhQvnApCQYEClUrNs2UrbvhERl5k0aSxms4WmTZ/l5ZdfJSrqGuPHjsBiMfP8C21o06ZdruMXQgghhBBCal45AM/Rw/AcPUzpMByW1WrFkGTEy12H2t4JlahBvFhpvn3btLNfNlTglw0V8r0dtUrF8/XKcPm6gb/PRef5fDnlmTAMzwTpB0Lc7Z133stT4irdW2/1Zf78JSxYsJQuXbqyfv3XWe67Zs1KFi6ci9Watl2lSjXmz1/C/PlLKFMmjHfeyVibbt26r3n11df55JPP+fHH7SQmJvLll8t4u1UbFr8/gh9/3IbBYMjzaxBCCCGEEEWXjLxyAIYJU5UOwaElJJuwWMHL3Y6F2tOVnM3mn/+wf7t29MxLZwqsnSeqlmTj3nN8f+AiNcoXt8t5s8vgIf1AFIy2bd3o3NlI584mjEbo2NGNV1810rGjicRE6NLFje7djbRtayIuDrp1c+PNN420amUiOlpFz56u9OmTynPPmbM8x9atW9i/fw8JCQm4urpSsWI4Bw7so06duvTpM4D9+/fy5ZfLsFqtdOzYmWbNnmPr1i18++1agoODSU5OBqB//15MmTKLY8eO8tVXK0hNTaVMmbIMHz6GSZPGodfruXDhPN7ePkyaNJ2dO3/GaDTRvHmLLGO7ceMGXl7eXL16hQkTxqDTuRAXF8OgQUOpWbMWoaFleO+9YezbtyfDcf/8cxyLxULNmrUyPP7II+HEx8djNBqxWq3odDr+/fck7/UZCGo1lSpV4d9/T1KnTt3cf9OEEMLB7TwcmaHelRBCCPuSkVcOwFy9hkwZfID4RCNqFbi75kOu1bWWQ08ZhLRpfnmdMpjddrQaNc89XprTEbH8ezkmz+fMCbO2hkwZFE7F09OLjz9egEqlJiysHIsXL2P//j1YLBY+/XQRc+YsZMGCpXz77VpSUpL55puv+OSTzxk8+AOSkjLW4rtyJYLp02ezaNFnnD59isTEtL5cvXpN5s9fQnJyEpcuXeTpp5tlmrhaunQhvXv34KWXWnLx4nk6deoCwO3bt5gxYzaTJ89k2bIlADRo0Ah1Jos2fPvtGrp06Xrf435+xVi4cC6vvtqRKlWqodPpMJvNqD09wd0dNzc3EhMdu7agEELklRRqF0KI/CUjrxyA9q8/ASncnpn0KYOebvkwZRAg6XdCvE8SEVfJ/m3bydVLXkDeC7dnt53GNYPZsu8C3x+4yCOhvgCsW7eWDRvWoVJBqVIhfPDBKLy9fZg372N+++0AZrOZV155jbZtO+Q6Pq3pTj+Qwu0in23cmGT7WqfLuO3unnHb2zvjtr+/NcP2g4SFlQPAw8ODkJBQNBoNGo2W2NgYrl27xnvvDQTAYDBw5swZihUrjk6no1gxfwIDgzK05ePjy6RJ43B3dycuLg6z2ZLhHP7+xUlNTckylrfe6kvjxk+xYsVyIiMv4+7uTmxsDFWqVMXFxYWgoGDi4mKyPN5kMnHp0iUqVapy33NLlixk7tzFlClTljFjhnP06GE0Gg0WQzxqtZqkpEQ8PKR4uxDC+UmhdiGEyD8y8soBeIwfjcf40UqH4ZASU9JWGcyXKYMA14fQKnxR/rRtJ7s2lWPXpnIF1o5ep+HZx0L5+1w0l6LiOXnyH776aiWLFy9jxYqvCQkpzdKli9i0aT0REZf48su1LF36JV9//RUnThzLdXweCaPxSJB+IJxHVoseeHv7EBISyuzZC5k37xOaN29BWFgYN25EkZKSQlxcLNevR2U4ZuHCuYwdO5GBAwdjMpmw3ilIldOFFV577XUuXrzA3r27ATh37iwWi4Vr167i5eWd5XFnzpymXLnymT7n6emJm5s7arUaP79iJCQkUKFCOMd37YSICE6cOEaFCo/kKE4hhChMdh6O5FQBj1gXQoiiRkZeOQDDlJlKh+Cw4hONqFTg4ZpPyavA+WzY8Xv+tG0nTTucLvB2mtYpxbZfL7L114v0blONNWs2oNVqSUlJ4caN6wQHl2L37v/x4ovt0Gq1eHt707Rpc378cRtVqlTLVXwGD+kHomjQaDS8+mo3BgzoRUpKKo0bP4W7uwevv96TPn16EhgYhLe3T4Zj6tdvwJtvdsPDw4OAgABu3cp8UYX//W/HA2teqVQqBg/+gPHjRzJlyiyMRiODB/cnISGB997LesGEyMgISpYMzPDYiBFDmD59Fn37DmT8+BGoVGrKlAmjXr36hIWVZ9KE0SQmJtLqxZfw8vLK4VUSQojC4+DxtA8cZLqgEELkH0leOQBz5funYYi0KYPxiUY8XXWo1fkwZRBAX40oQ8GvrJcTAUH2qRWTk3bcXXU8XbsU23+7xEuNEynp587u3TuZNm0COp0Lb77Zm127fqFEif9u0kqUKMnZs7kvLm/WSj8QzqNly9a2r0eOHGf7evny1QA0afIMTZo8k+GYpk2b07Rp8wyPzZ+fVodqyJAR953j7nbTv65YMfy+/Xr2fDvDdsWKj7By5TdcvXqF0NDSTJky675j6tSpm6HAetOmz963T9myYQBUqlSFRYuWZXguMDCQeQuW3neMEEI4q/BQX56qVUrpMIQQwmnJtEEHoP3tINrfDiodhsNJSjHn75RBgMT9lPHN/VS3ghB53pvI81lP58mvdpo/FopGrWbbr5cAaNz4Kb7//md69OjF4MEDsFis9x2TWZHn7NIaD6I1Sj8QorB46aWH1LhLMKT9E0IIJyZTBoUQomBI8soBeEwej8fk8UqH4XDik4yoAA+3fExe3RjB8xUde3TAnu/C2PNdWIG34+Opp2GNIHb++jd7D/xme/yFF14kKuoqAQEBREfftD1+48Z1SpQokev4PBLH45Eo/UCIghIUFJzpqKvsCgh4cH/XXL2K5urVXLcvhBCFgUwZFEKIgiHTBh2AYeYcpUNwOGlTBlPxcNOiya8pgwCBn7Dux98evp+Cmnf6V7F2WtQrzbaf9zJhwijWrv4aX19ffvxxG2Fh5WnS5Gm+/34zDRo0IikpiZ9//pH33x+e6/gMntIPhHAm5pBQpUMQQoh8lT7qSqYMCiFE/pPklQMwV6iodAgOJznVjMlsxcvNJX9PpA/nRuK1/D1HHhUrmaRYOyV83Xi64RPsSLhOv/690Gm1FC9enClTZlKiREkiIyPp3r0LJpORF19sR+3aj+Y6PrNG+oEQTsXVVekIhBAiX8moKyGEKDiSvHIAuv17ATA+2VDhSBxHfJIRAE/3fP4RTdxFOb/DnLtdK3/PkweXz6StOhZaIVaRdlo+UYZfT9Sj7SudebFhxmmH77zzXp5iupvOeKcf6KQfCOEMVIZ4AKyestKgEMJ5yagrIYQoGJK8cgDu0ycDELtxq8KROIb0VQY9XLVo8lAAPFtujKV5hRgW/+64U9b2bSsLQOcBRxRpJ6SEJzXL+/PTH5dp/ngori7582vDPfFOP/CRfiBETn322Sfs3PkzPj6+WK1WjEYjY8dOpFSpkCyP2bNnJ3/99ScDB6YloRctmsehQ7/j5+fPiBFj8fX1te07c+ZULlw4B8CZM6cZNWo8ISGhTJkyHrVazQsvvEirVm0ztK++ljaq1VxBkldCCOdz95RBIYQQ+U+SVw4gfvYCpUNwKClGC0aThWJe+vw/WdAyvv7BsVe4a/HKKcXbeaF+WSav/JPdh6/Q/PHSdonnXvGe0g+EyIu33upL48ZPAbBz58+sX/81AwYMznTfNWtWsmnTep54ogEA//57kjNnTrNkyRccPnyIlSuX07//INv+778/DICzZ8+wePE8GjRoxPDh7zFo0HtUqlSN999/h0aNnsLHx9d2jDk0f35XCCGEI5Apg0IIUbAkeeUALGXzvpKcMzHcmTLo5Z6PqwymcynHraTL+X+ePPAtnqx4OxVCfAgP9WX7b5d4uk4pdFqNXWK6m0Uj/UA4j61bt7B//x4SEhJwdXWlYsVwDhzYR506denTZwD79+/lyy+XYbVa6dixM82aPceBA/v46qsVpKamUqZMWYYPH8OkSePQ6/VcuHAeb28fJk2azs6dP2M0mmjevEWW579x4wZeXt5cvXqFCRPGoNO5EBcXw6BBQ6lZsxahoWV4771h7Nu3B4DLly9Rq1YdVCoVVapU49NPF2fa7iefLKBPn4GoVCqioq5RvXpNTCYLFSpU5MyZ0zz66GP/7awvgA8ghEPauXMns2bNIjU1lfDwcCZPnoynp2eGfa5cucL48eOJiorCbDYzdOhQGjVqpFDEQuTM9gMXpFC7EEIUsHyek6WslStX8sILL9CqVSv69OlDdHQ0ZrOZiRMn0qJFC5599lm++uorpcNEt+t/6Hb9T+kwHIYhyYiriwatpgB+PBN2ULHYH/l/njy4eMqXi6d8FW+ndYOyxBhS2X3kap5jyYwu9X/oUqUfiPzXtq0ba9akfXZjNKZtf/NN2nZiYtr2xo1p23FxadvffZe2HR2tom1bN3744eEJXE9PLz7+eAEqlZqwsHIsXryM/fv3YLFY+PTTRcyZs5AFC5by7bdrSUlJ5sqVCKZPn82iRZ9x+vQpEhMTAKhevSbz5y8hOTmJS5cu8vTTzTJNXC1dupDevXvw0kstuXjxPJ06dQHg9u1bzJgxm8mTZ7Js2RIAGjRohPquadlhYeU4dOh3TCYTv/9+kJSUlPvaj4i4jEoF5cqVB6BUqRAOHfoTo9HI4cOH7jtGFR+HKj7uoddJOJdbt24xfPhw5s2bxw8//EBoaCgzZ868b7/evXvTpEkTNm7cyLRp0xg8eDCpqakKRCxEzu36KwKQUVdCCFGQnHbk1bFjx1i2bBmbNm3Cy8uLadOmMWfOHMLDw7l48SLfffcdCQkJvPzyy1StWpUaNWooFqv7xzMAiG3ytGIxOAqjyUJyqpkAnwJapermRJqWj+H0rboFc75cOPBjGQDKhMco2k7lMn5UDPFh668XaVwzyO6jr9yT7vQDF+kHwjmEhZUDwMPDg5CQUDQaDRqNltjYGK5du8Z77w0EwGAwcPPmTXx8fJk0aRzu7u7ExcVhNlsytOPvX5zU1PuTSunSpw2uWLGcyMjLuLu7ExsbQ5UqVXFxcSEoKJi4uJhMjy1XrgKPP16fAQPepl69+gQElLhvn127fqF58+dt2/36DWLWrCmAinLlyuPt7Z1hf3VU2pQas1fGx4Vz27t3L9WrV6ds2bIAvPLKK7Rp04axY8eiUqkA+Oeff4iNjaVLl7QEa5UqVVi9erXteSEc1c7DkRw8HkXEDYOMuhJCiALmtMmratWq8cMPP6DT6UhJSSEqKoqQkBB27NhBp06d0Gq1+Pj48MILL7B582ZFk1fxC5Yodm5Hkz5l0NOtAKYMAgSv4KvtvxbMuXKp5WsnHaIdlUpFm4ZhzFxzmN1HrtL00awLQedGvKf0A1EwNm5Msn2t02XcdnfPuO3tnXHb39+aYftBsvpD3Nvbh5CQUGbPXohGo2HFis8pXjyAhQvn8vXXm0hJSebVVztitVof2E5WXnvtdfr2fZO9e3dTvnwFzp07i8Vi4fr1KLyySCRFR9/E19eXRYs+49df92e6z5Ejh2nW7Dnb9p9//sa4cRNxc/Pkgw/epUKFRzLsby5dJkdxC+dw7do1AgMDbduBgYEYDAYSEhJsUwfPnz9PqVKlmDJlCocOHUKj0TBw4EAqVqyY7fP4+3s+fCfxQAEBsphCTh06fZOIGwbCSvnQpHaIXMM8kuuXN3L98kauX+HjtMkrAJ1Ox44dOxg5ciQuLi4MHDiQH3/8kaCgINs+gYGBnDpln4LYuWV5wGpQRY0hyYhOq8ZFV0AzWnWhxCafK5hz5ZK3X9YjLQq6ncpl/KhgG30VjE5rv++TRSP9QBQNGo2GV1/txoABvUhJSaVx46fQ6/XUr9+AN9/shoeHBwEBAdy6FZ3p8f/7344H1rxSqVQMHvwB48ePZMqUWRiNRgYP7k9CQgLvvTcs02P8/Ipx8OABNmz4Fn//4owe/SEAI0YMYfLktFGRUVFXKV48wHZMcHAIAwf2Q6fT8fLLr+Lqes+IWReXnF4a4QQsFkumj989TdVkMnHo0CF69OjB8OHDOXr0KG+99RabN2+mZMnsTcOKjjZgsVjtEnNRFBDgxY0b8UqHUajsPBzJsbPRhIf6MqVvQ27ciJdrmAfyM5g3cv3yRq5f3qjVKkU+RHLq5BVAs2bNaNasGV9//TU9e/ZEq73/Jd99Q5Uddv9Gbd+e9n+LrIvvFgVqjZrEZBP+Pq64uBTQyCvDdqqUPM7pW08UzPkyodM9uBuePe4LQPmqMXk6z73tGE2WXH3i8PoLVRj9yQH+OneLFxrkrsi60WS5P/FluNMPPJ2zH8inOwXr7ut9/boarR0Trdnx4ottbF+PHfuh7euVK9cA0LRpM5o2bZbhmOHDR93Xzt3Hpn9duXLl+/Z7++0+GbYrV67EmjXruHLlCqVLl2H69I/uO+bxxx/n8ccfv7OlZuLEKfftU65cOdu1W7Xq6/uO//LL1fcdYxN7p96VT96mDarVauk/hUhQUBBHjhyxbUdFReHj44O7u7vtsRIlSuDt7U2zZml9oEaNGoSEhHDy5MlsJ6+EKEg7D0fy5fa0D7ulzpUQQijDaZNXFy9e5MaNG9Stm1bLqH379owdO5a6dety48YN235RUVEZhrdnh70/7fOZMAmA2Ecb2K3NwiT9j5KY+GSsgLtei9FoKpiTR0+lcekYTkQpV/PqYa91/w9p9RRKP3IzT+e5ux2dTotOq2bInF05bsdqteLmouHTTX/zy+8XUeeiRsmMd5rc92mHT+ydfuDjfP1APt0pWPdeb4vFgsmU+WgQZ2c2W7Barbl+/W3atH/gsVqtOsvnNVfTFncwe+TtAx+LxZLh+6nUp30iexo2bMi0adO4cOECZcuWZc2aNTRt2jTDPnXq1MHFxYVffvmFZ555hrNnz3L58mUqVaqkUNRCZO3uxFW3FuFS50oIIRTitMmrGzduMHjwYDZu3EixYsXYsmULFStWpHnz5qxbt46nn36axMREvv/+e8aPH69orHGffK7o+R2FIdGIRq3CTW/fQuAPVGoNq7ZmXt/FUbR+/YRDtaNSqSju48rlGwnEGlLx89Lbpd04L+kHQthbUFAwU6bMyvXxmRVuzy5zmbK5PlYUXv7+/kyZMoWBAwdiNBopXbo006ZN4++//2bUqFFs2rQJFxcXPvvsMyZOnMhHH6WNCpw8ebKMuhIO6eDxtMUnJHElhBDKctrkVd26denduzfdunVDo9FQokQJFixYQFBQEJcuXaJNmzYYjUZefvnlu6ZNKMMqN2tYrVYMySY83bQFu9qQNpD4VP+CO18ueHgbHaodAHdXLW4uGqLjkvHxdMnV6Kt7WdXSD4RwKroCmv4tHE6TJk1o0qRJhsd8fX0zJKfCw8NZsWJFQYcmRK7IyoJCCKE8p01eAXTp0sW2DPPdRo4cqUA0WXP5YRsAqc89/5A9nVdCshGLxYpXQa0ymC5+C5UDjvHPjScL9rw5cPZYWnKtfLXMizcXdDuQP6OvXFLv9AOXotsPhHAmqthYAKw+PgpHIvIiMjKS2NhY2+qXAFWrVs1xO1FRUZnekwnhiHYejrSNuLp03UDpEjJVWQghlObUyavCwm3RPKBoJ6/iElJRAR6uBZy8ujWLJmVjHDp59fv/0lbhy2vSyV7tpHN31eJqx9FXbkl3+oEkr4RwCuob1wEwS/Kq0JoxYwYrV67E3/+/EcoqlYqff/45x22VLFlSpgUKh3Z3wurU5RggbcRV6RKeUqRdCCEcgCSvHEDcZ0V72LzVaiUuIRV3Vy1qdQFOGQQo9S1ffr+vYM+ZQy++cdyh2kmXPvoqwk6jr+K8inY/EMLZmMvmbjVS4Ti2bdvGjz/+KEknUSQcPB5lG2UVHupLvaolZaqgEEI4EEleOQCrv2PXXMpvF6/FYzRZ8Pe2T+HvHNEWJ9HoW/DnzQF3T/usvGivdu7mcdfoK19PlzzVK7Oqi3Y/EM7ParUyffokLl68QEBACUaOHIeLi8t9+129eoU33+xKWFh5AAwGA+3bd6J167aZtvv330dYsGAOFouFhg0b061bD9tzQ4e+S6tWbWjc+Kn7jvvmmzVYrRY6deqS7dhyRCu3GIVdUFCQJK5EkVK6hCcfvFpH6TCEEEJkQq10AAJcvtuMy3eblQ5DMQePpy2n7lnQ9a4A4tdTrcTugj9vDvx7pDj/HinuMO3cLX30lclsJcaQmqe2XFI245JSdPuBcH5HjvyFSqVi4cJPCQsrx759Wf/uqVGjFvPnL2H+/CUsXryMr77KemTi4sXzmTRpOp988jkHDx7g5s2bAKxbt5abN29kesy8eR/xzTdf5Sq27FLFxKCKiclzO0I59evXZ/r06fz5558cP37c9k8IIYQQoqDJx6IOwO3TxQCktnpR4UiU8fuJKNz0WrQaBXKpt+bSsEwMx643LvhzZ9Oh3WlD1h+pedMh2rmXh6sWN/2d2lceLrme+umWfKcf6ItmPxAFxye2Jcn6V0lxfRWsRnzi2pDs2o0UfWewJuIT14Fk156k6NujssTiHf8KSa69SdW/iMoSjXd8V5LcBjywPltcXBxjxgzDYrHg5+dH1arV6dSpC9Wr1wTg5s0bVK1ajcTERGbNmsro0R9m2VZ8fBw6XdooqP79e1G6dBlOnz7Fo48+Tu/e/ZkwYSrFiqWNXDSbzWg0Gs6ePcOFCxdo0KBRpm3WqlWH8uUrYjDE27bvjS2v1HcSZ2Zf3zy3JZSxfv16ALZv3257LLc1r4RwZDsPR3Lqcgzhob5KhyKEECILkrxyAHFffvXwnZxUXGIq/166TYCvuzIBhGxi+Xd7lTl3Nr305jGHaudeKpWKAB83Ll03cNuQgr+3a67aifMquv1AOJ/vv99M48ZP065dR2bPnml7XKPR8N57A7lyJYLu3d/C3d0908TV0aOH6d+/Fzdv3qRYsWIMHfrfKrnNmj3HkCEjePfdfly9eoWgoGAAVq36gvDwSri7uzN9+kRGj56Q5YitRo2eYuvWLRkeuze2vDKHSc2rwu6XX35ROgQh8t3Ow5F8uf0UgBRmF0IIBybTBh2A1dsHq3fRXI3p77PRWK3g7ZHH2iq5pfEh2eTYyx/r3czo3cwO005m3F21eLhqiY5LwWyxPvyATFjVPljVRbMfiIIV67M1bdQVgEqXtq3vfGfb/c52eyDt5zLWZ6ttRKBV7Z+2/ZBVMSMjIwgPrwxAzZq1Mjw3a9ZcBg8eyoIFs7M8Pn3a4PTpHxEXF0dQUFBaeCoVNWrUQqVSER5emUuXLgLw5ZfLOHnyHwYMGMzRo4e5evUqQ4cOYtu271i6dCEREZezdW2yE1u2abRp/0ShlZiYyLhx43jmmWdo3Lgxw4cPx2AwKB2WEHZzd+KqW4twKdAuhBAOTJJXDkC/cR36jeuUDkMRR89G4+elx9VFo0wAcWupGejYnyyfPBTAyUMBDtNOVgJ8XbFYrNyKS87V8fqUdehTimY/EM6nTJmy/PNP2mjH06f/BWDfvj2sXLkcAFdXN9Tqh78Fly5dlk6dXmHWrKlAWtH3s2fP3Gn3FCEhoaxb9zXnz59j3LhJaLVaHnusHsuXr2b+/CU8/3wr3nqrLyEhoQ88T25iexjV7duobt/OcztCOVOmTCE1NZUFCxawcOFCVCoVEyZMUDosIezm4PEoQBJXQghRGEjyygG4Lv8M1+WfKR1GgTOZLRw7f4u6lUvmaZW6PLm9iPqhm5Q5dzYd3hfM4X3BDtNOVlxdtHi567gVn4LJbMn58cmf4Zpc9PqBcE6tW7fl0KE/eeedPvz99xEAHnusHqdOnaR//14sW7aEt97qQ2JiIhMmjHlgW61ateH69Sj++utPAFauXE6vXt2pVasOgYFBLF26kCtXInnnnT7079+LS5cuZNrOpk3r+fXX/Zk+l1lseaWOvok62r419kTBOnLkCJMnT6Zy5cpUq1aNiRMncvToUaXDEsKuwkN9JXElhBCFgIzndwCxq79VOgRFnImIJSnFxGNVSrJlz3llggjdymeb9yhz7mxq//bfDtXOgxT3cSU+0Uh0XAol/dxydGysd9HsB8I5ubq6MnnyDAC2bt2CwRCPi4sLEyZMvW/fe2teBQUFM2XKLNu2Wq1m6dIvbdtDh47Ey8vLtr19+84s4+jZ823b12XLhpGc/N/IyJYtW9u+ziq2vDCHlbNre6Lgmc1mLBaLbSSexWJBo1FopLQQQgghirRCMfJqxIgR9z02YMAABSLJJ+7uaf+KmKNno9GoVdSsmH9T2R5K7Y7RkrsC4wVF52JB55LzkUz51c6D6HUafDxciIlPwWjK4blU7mn/hBD5Iji4FPXq1S+4E2o0af9EoVW/fn0GDRrEgQMHOHDgAIMHD6ZevXpKhyWEXaSvMCiEEKJwcOiRV2PHjiUqKoo///yTW7du2R43mUycO3dOwcjsS//NGgBSOnZWOJKCdeTsTcJL++LuqlMuiNiV1An6h0NXmysXw0Oc+KMEAFXqXneIdh6muI8rcQmp3IxNJsg/+8kofcqdfqAvWv1AOL+7Rzjl1fz5S3J9bEBACbvFkR2qO+/b1mLFCvS8wn6GDRvGwoUL+eijj7BYLDRs2JC+ffsqHZYQdpFe70pWGBRCiMLBoZNXHTp04PTp05w6dYrnnnvO9rhGo6F27doKRmZfrqvSpoMUpeTV9ZgkrkYnKl9jIOZTHg+Jcejk1dEDaauM5TXpZK92HkanVePrped2fArFvPTos1mM3zX5Tj+Q5JUQTkF9KxoAsySvCi2tVsvAgQMZOHCg0qEIkS+k3pUQQhQeDp28ql69OtWrV+fJJ58kMDBQ6XDyTew3jl0wPD8cPZNWxLdGBX9lAyn9E0s27VY2hofo2Nc+xXHt1U52FPfWE2tI5XpMEqElPLN1TKx30esHQjgzc7nySocgcumVV17hq6++onbt2pkuqHLo0CEFohJCCCFEUebQyat0ly5dYsiQIcTGxmK1Wm2Pb9myRcGo7Ein4LQ5hRw5G03JYu6U9FO4xpFKh8Xq2N1Ao7E+fKcCbCd751Lj76PnRkwyCclGPLIzNVRV9PqBEE5NXSjKaopMzJkzB4Dvvvvuvufuvg8TorBKr3cVHuqrdChCCCGyybH/ar/jww8/pH379lSpUiXTTwALO/2aVQCkdH5V4UgKRnKqiVOXbvNMnRClQ4GY5dQNPskfV55XOpIsHTuYVouhWr0oh2gnu/y89MTEp3L9dhJlA7UP7bv65Dv9wLVo9AMhcuPq1Su8+WZXwsLSRjUZDAbat+9E69ZtM93/u+82snbtanx8fPH19WPixGn89tuvLF26ELVaw6BB71O5clXb/qmpqYwZM4y4uDhKlCjJmDETbCvNzZv3ETVr1qFx46eyFavqzrRBazGFR9iKHCtRIq0+2tixY/n0008zPNepUye+/vprJcISwm6k3pUQQhQ+hSJ5pdPpeOONN5QOI9+4FrHk1T8XbmMyW6lZ3gH+oIldTt1SMY6dvPotbcpsnpNXdmonu9QqFQG+rlyJTiQuwYiPp8sD93dNkeSVENlRo0YtpkyZBUBycjI9eryaZfLqzJnTjBw5nkqVKtseW7p0ER9/vJDk5GQmTBjDnDkLbc/9+ut+SpUKYerUwcyePYPffvuVunUfZ8KEMZw4cYyaNetkO071nYLtZkleFToDBw7k/PnzXL58mdat/1twwGQy2ZKZQhRWd4+6knpXQghReBSK5FXFihU5deoU4eHhSoeSL2I3blU6hAJ15OxNXF00VHSEodpldrJ44y6lo3igzgOOOFQ7OeHlrsM1XsON2CS83HWo1VmPvor1KVr9QDi3rVu3sH//HhISEnB1daVixXAOHNhHnTp16dNnAFu3bmH79u9JSkrkiSca0K1bD95+uzvjx0/h339PcejQ7/TrN4hZs6YyevSHWZ4nPj4OnS4tMdy/fy9Kly7D6dOnePTRx+nduz9nzpzmiy8+IzY2hq5d36B69Zq4ubnh6emJp6cniYkGTCYTWm3a7UDZsmH89tsBABITE3Fzc8doNNKqVRtKly6To2tgrlAxl1dPKG3o0KFERkYyevRoRo8ebXtco9FQsaJ8X0XhJqOuhBCicCoUH59dvnyZ9u3b07x5c1q3bm37Jwofq9XK0bPRVAsrhlZTKH78RB6oVCpK+LphMlu5FZ+idDhCAODTtqVtujZGY9r2N2vSthMT07Y3rgNAFReLT9uWuHy3OW07Ojpt+4dtDz2Pp6cXH3+8AJVKTVhYORYvXsb+/XsAiImJYfbshSxatIyff/4RnU7He+8NZ+bMKaxdu4p+/Qbh7u6eaeLq6NHD9O/fi86d2zF27AiGDh1pe65Zs+dYsuQLTp48wdWrV2jYsDHDho1i6tSPWLx4HgkJBtzd/6s16OKiJzX1v76p0+k4dOgPunRpz7//nqJKlaq4ubnx2GP1cnaRRaEWEhJCvXr1qF69Oo8//rjt36OPPoq3t7fS4QmRZzLqSgghCp9CMfLq3XffVTqEfOW6YjkAyV27KxpHQbgUZSDGkEqN8sWVDiVNzFIeD/mX3yJaKR1Jlo4eSJvuV6P+NYdoJ6fcXbV4uum4FZeMr6dLlklL1+TlACS7di+44ITIR2Fh5QDw8PAgJCQUjUaDRpP2tqvT6Rg3biSenp4YjUYAqlatRnJyMvXq1c+QYLpX+rTBS5cuMGLEUIKCgoC0ZHGNGrVQqVSEh1fm0qWLtG7dFg+PtBU/y5QJIzr6JklJSba2UlNT0OtdbdvffruGTp1eoW3bDnzzzRq++moF3br1yNXrV0WnrSpr9XeQ3/cix86cOYPVanXKeqOiaJJC7UIIUXgViuTVI488onQI+Uq/cT1QNJJXR86m/TFT3RHqXQHEraVW4G2HTl6d/CutcG5ek072aic3Svi6cu6qkRsxyQT5Z/5HuT71Tj+Q5JXIZxmmaut0Gbfd3TNsW719Mm77+2d7qndWf/DHx8ezadM6Vq78hhs3rrN7904A/ve/HZQvX4Hffz/ICy+8SGBg0APbL126LJ06vcKsWVOZNGkGVquVs2fPEB5eidOnT/Hiiy/x5pvd+OyzlWg0aiIiLlG+fEUSExMxGAykpCSj17ui0WjuevkeuLt7AODvX5yTJ09k67VmRn37NgBmSV4VWsWLF+eFF16gZs2aeHh42B4fNWqUglEJkXsyZVAIIQqvQpG8euKJJ1CpVBk+/QsICGD37t0KR2Yfses2Kx1CgTl6NpqwIG98PB5cvLvAlN7Bkg2OXfOqU9+jDtVObrjoNBTz0nMrPgXfLAq3x3oXnX4gijYPDw+Cg0N4881ueHh44Ofnx7Vr1/jii2XMn7+E8+fPMn36ZCZOnPbQmletWrVhy5YN/PXXnwCsXLmcqKhrNGzYmFKlQnj77X68805vtFotb7zxFnq9nl69+vLuu/2wWq0MGvQ+AJ9/vpSGDRvTsWNnJk4cy+bNG3Bx0TN69Phcv06peVX41a5dm9q1aysdhhB2JVMGhRCicCoUyauTJ0/avjYajfz4448ZHhOFQ1xCKuevxNGmYZjSoQgF+Pu4EpuQStTtJCwWq9LhCJGvWrb8ry7jyJHjbF8vX74agOnTP77vmPTnqlevyUcfzQO4L3EVFBRsW2kQQK1Ws3Tpl7btoUNH4uXlZdt+6qmmPPVU0wxtPPZYvftqWAUFBaPX6/H29mH69NmZvqaePd/O9HHhvPr3709CQgLHjx/HZDJRo0YNPD09lQ5LCCGEEEVQoauYrdPpeOGFF9i3b5/SodiN67KluC5bqnQY+e7vc9FYgRoVHGTKIMDthdQP3ah0FA/0195g/tob7DDt5JZGrSLA15XkVDM7D0Xc97xr8lJck52/HwjhiB599DFKly5r1zZVN2+gunnDrm2KgnX06FGee+45Jk+ezJQpU3jmmWc4dOiQ0mEJkSvp9a6EEEIUToUieRUTE2P7d/v2bfbs2UNcXJzSYdmN/sdt6H98+MpVhd2Rs9H4eLpQuqTXw3cuKIYtVAnYr3QUD3T2mD9nj+U94WevdvLCx8MFVxcNy787TlKKKcNz+tRt6FOdvx8IkV/mz1+SYdRVTgQElLBzNKCOjUUdG2v3dkXBmTZtGjNnzmTjxo1s2bKFOXPmMHXqVKXDEiLHdh6O5MvtpwCpdyWEEIVVoZg2eHfNKwB/f39Gjhz5kKMKj9g165UOId+ZzBaOn4+mbngJ1I60alHoNj5b79g1rzr0/tuh2skLlUpFST83LkYZ+O7ABTo+VcH2XKy38/cDIYoSc/kKD99JODSDwcATTzxh265fvz6TJ09WMCIhcu7uxFW3FuFS70oIIQqpQpG8kvpWhd/piFiSUszUrCCrThV1bnotz9QN5affL9O4RjAli2W++qAQ9pSamoJO55LlCoDCMVksZqVDKNLUajWRkZGUKpX2x35ERESG1SmFKAzSVxiUxJUQQhRuhSJ5ZbFY+Oyzz9i9ezcmk4kGDRrQu3fa6knOwG3JQgCSevVVOJL8c/TsTbQaFVXK+ikdSka35tCw9Bn2XuqgdCRZ+nNX2o3Wo00iHaIde+j+QhX2H73C6h2nGdSxBiqVCrekO/3AzXn7gVCGt7c/MTE3sVhMD99Z5IharcZisWT6nCo+HgBrLqcypnN3987T8SL3+vXrx8svv0z9+vWxWq3s37+fsWPHKh2WEDkmKwwKIUThVyiyP7NmzeLkyZO8/vrrWCwW1q5dy/Tp0xkxYoTSodmFbk/atDVnTl4dORNNeKgvri4O9iOX+DMV/KMdOnl16V9fIO9JJ3u1Yw9+3q60bVSONT+f5s9TN6hbqQQ6451+IMkrYWfu7p64u8sKafkhIMCLGzfiM33Oe8jLAMStWFuQIQk7atasGeXKlePXX3/FarXSp08fypcvr3RYQgghhCiCHCyTkLk9e/awbt06dDodAE899RQvvvii0ySvnP3G/vrtRK7dSuTpOg74iVfIZpavc+yaVy+9ddyh2rGXpo+WYv/fV1m941+qhhUDb+fuB0IUNc7+3lZUXL58mXPnzqHRaKhQoYIkr0Shkr7CYHior9KhCCGEyKNCsdqg1Wq1Ja4AXFxcMmwLx3bkbDQANcsru9KdcCwatZpuLSoRa0hlw55zSocjhBDiHvPmzWPq1Kl4eXnh6urKmDFj+PLLL5UOS4hskRUGhRDCuRSKkVeVKlVi8uTJvPbaawCsXLmSRx55ROGo7MdtwVwAkvoNVDiS/HH0zE0Ci7lTws8BC3NHz6RJ2bPsutBZ6Uiy9PsvIQA89kyEQ7RjT+WCvXmqTil+/jOCdjU24eelJ8nNOfuBEEWNs7+3FQWbN29m/fr1eN2pW9ajRw86d+5Mt27dFI5MiIeTQu1CCOFcCkXyauzYsUycOJHOnTtjsVho1KgRo0ePVjosu9H98RsASQrHkR+SUkycuhxD00dDlA4lc0kHKON7U+koHujKBfsUK7ZXO/bWvnE5Dp26QfT1nQS4+oKb0hEJIezBmd/bigpfX188PDxs297e3ri7O+AHUUJkQQq1CyGE83Do5FVqaiqjR4/m2WefZerUqQD06tULjUaDp6fzFN+N+3yl0iHkmxMXbmMyW6lRvrjSoWQuZB1fOnjNqzY9TjhUO/bm7qqjc9OKjN78Hq8++whNH834/A8/bGX16hWoVCpcXV0ZNOh9KlWqAkB8fDz9+7/F8OFjbI8JIRyDM7+3FRXVqlWjb9++vPzyy2g0GjZv3kxwcDA//vgjAM2bN1c4QiEyJ7WuhBDC+Th0zau5c+diMBioXbu27bEJEyYQFxfHvHnzFIxMZNfRszdx02uoGOKjdCjCgT1euQRVy/qxfvdZbsUl2x6/dOkCCxfOYdaseSxfvprXX+/BiBFDADhwYC9vvfU6Fy9eUChqIYRwbmfOnCEhIYFly5axdOlSoqKiiImJYcWKFaxcKclJ4Zik1pUQQjgnhx55tXPnTr799ltcXV1tj5UsWZLp06fz8ssv8+677yoYnf24zf0IgKSBgxWOxL4sVitHz0VTNcwfrcZB86TRU3k67Bz/O/+q0pFk6eCOUADqNbvsEO3kB5VKxbvNf+Sn3y+z4gdfBnaogUqlQqdz4YMPRlO8eNrIvUqVqnDrVjRGo5FvvlnLqFHjGDdupMLRCyEy46zvbUXJihUrADCZTPctniOEo5JaV0II4ZwcOnml0+kyJK7SeXp64uLiokBE+UN77KjSIeSLS1HxxBpSHXuVweTDBHtdVzqKB7oeaZ8psvZqJ7/46P6hYXgia9dEc/BEFE9UDSQoKJigoGAgbdXRefM+pmHDxuh0Oj76SEZfCuHInPW9rSiJjo7mgw8+4Ndff8VsNvPYY48xY8YMSpaU0SzCsUmtKyGEcD4OnbxSq9UYDIb76lsZDAZMJpNCUdlf/JLlSoeQL46eiUYFVC/nwMmrUmtY9a1j17xq/fo/DtVOfon3Wo6bh5XywX+yesdpqpQthrdHWpI6KSmJSZPGcf16FLNmSdJKiMLAWd/bipIPP/yQWrVq8dFHH2E2m1mxYgXjxo1j0aJFSocmhBBCiCLGQedypWnVqhWjRo0iMTHR9lhiYiKjRo2SIqGFwJGz0YQFe9sSEEI8jFqt4o2WlUlONbHqp38BuHbtGr1790CjUTNv3mLbku1CCCHy14ULF+jfvz/e3t74+fkxcOBALl26pHRYQmQpvVC7EEII5+PQyavXX38dLy8vGjRoQKdOnejQoQMNGjTA29ubfv36KR2e3bjPmob7rGlKh2FXsQmpnL8aRw1HnjIIcHMCzcp9qXQUD3Tgh9Ic+KG0w7STX9wTp+GeOI3g4h60bhDG7yevs/vPcwwY0IsmTZ5m/Pgp6PX3TyMWQjgmZ3xvK2pMJhMpKSm27aSkJFQqlYIRCZG5nYcjmbbqkBRqF0IIJ+bw0wYnTJjA22+/zYkTJ1Cr1VSvXt3pai1ozpxWOgS7+/tsNAA1yxdXOJKHSD1FgEeU0lE80K3r7g7VTn7RmP/rB8/XK82fJ6+z4NPlREVdY/funezevdP2/Jw5C/Hx8S34IIUQ2eaM721FTcuWLenevTvt2rUDYP369Tz33HMKRyXE/Q4ej+LSdQPhob7Uq1pS6l0JIYQTcujkVbqQkBBCQkKUDiPfxC/6VOkQ7O7I2Zv4eLpQuqRjFwkneCVffePYNa9e6HrSodrJL/Fe//UDrUZNjxcqM+FmAk2ff5leL1bN8rhvv91SEOEJIXLIGd/bipp+/foRGBjInj17sFgstGvXjg4dOigdlhAZpE8VDA/15YNX6ygdjhBCiHxSKJJXonAxmS0cO3+LepVLyvQCkWulS3rR+smybNx7nloVi/N4ZecacSmEEI7u9ddf54svvqB9+/ZKhyJElg4eTxtBL1MFhRDCuTl0zauiwn3qRNynTlQ6DLs5dTmGlFQztSo4+JRBgBtjaF5hmdJRPNDerWXZu7Wsw7STX9wTJ+KemLEfvPBkGcKCvFnxwylux6dkcaQQwhE523tbURQfH59h0RwhHFV4qK9MFRRCCCcnI68cgOZKpNIh2NWRMzfRadVULuundCgPZ7qMr+t1paN4oPgYvUO1k180lvv7gUat5q3WVRi37Dc+3/oP73aqKaP5hCgknO29rShyc3Pj6aefJjw8HHf3/+omLl68WMGohBBCCFEUSfLKAcTPXaR0CHZjtVo5cuYmlcv4oddplA7n4YI+5+uvHbvm1fNdTjlUO/kl3jPzfhBYzJ2OT1dg1U//svOvSJ6u47z174RwJs703lYU/fvvvzRt2pSGDRsSGBiodDhCCCGEKOIkeSXs6tqtRG7EJNPi8dJKhyKcyDN1SnH4zE3W/u8MVcoWo2Qxx145UQghCrN169Yxbdo0ypQpw6VLl5g5cyaNGjVSOiwh7nN3sXYhhBDOTWpeOQCPiePwmDhO6TDs4siZaABqlC8E9a4Arg/n+YpLlI7igXZvCWP3ljCHaSe/eCSMwyNhXKbPqVQqerSsjE6jZsmWE5jMloINTgiRY8703lbUrFixgi1btvDNN9+wePFili5dqnRIQmRKirULIUTRIckrB6C6fQvV7VtKh2EXR87cJCTAE38fV6VDyR5zNO66OKWjeKDkRC3JiXkfJGmvdvKLynoLlTXrfuDnpadbi0qcvxrHxj3nCzAyIURuONN7W1FUsmRaMqB27drcvn1b4WiEyJoUaxdCiKLBcf+SLUIMs+YqHYJdJCQbOR0Ry/NPFKIpg0FLWOfgNa+av3zaodqxB6PJQkCAV8YHAz4HwO0Bx7UM8OLctXi2HbxI/ZrB1HqkRK7On5JqIi42KVfHCiGyx1ne24qiexfG0GgKQQ1LIYQQQjg1SV4Juzl27hYWq5WaFQrJlEGhGJ1WzZA5uUsaWixWdFo145b+SliQF1pNzgeQzninSa7OLYQQRZGs8iockdS7EkKIokWmDToAj7Ej8Rg7Uukw8uzImZt4uesoF+StdCjZd/19Wj2yUOkoHmjnpnLs3FTOYdrJL60eWZit74VarSLY3wOLxcrV6ESsVmsBRCeEyClneW8rik6dOkWdOnVs/9K3a9euTZ06dR56/M6dO2ndujXPPfccAwcOxGAwZLnv0aNHqVatGrduyRRTkTNS70oIIYoWpx55tWnTJj777DNUKhVubm6MHDmS6tWrs3jxYjZu3IjZbObFF1+kf//+in6qqEou/NOXzBYLf5+LplaF4qjVhegTWksSOk2q0lE8kMlonxyzvdrJLzn5Pri6aCjh50bU7SRuxafg711IaqwJUYQ4w3tbUfXTTz/l+thbt24xfPhwvvrqK8qWLcuMGTOYOXMm48aNy3TfcePGYTQa8xCtKMqk3pX4P3v3HR5Ftb8B/J1t6b0HCJ3QmyDSpCMgRbqg2MB2vdaf4LVcsSuCBbl2URSRIh2RjqEo0gk91JC+6WWzfWd+f0QiCISU3Z3Z5P08Dw/J7uyZd2cmO5NvzjlDRHVHrS1eXbhwAbNnz8bKlSsRGRmJHTt24Mknn8Trr7+OjRs3YuXKlVCr1Zg6dSqaNm2KYcOGyZbVMOtD2dbtLOfTi1FqtnvekMHoT7FqqbLnvBo47pyi2nGVVaeeqdLywf46lJrtyCk0w9dLAx+vWvtxRuSRasO5ra6qV6/6xYDdu3ejXbt2aNSoEQBg0qRJGDVqFGbOnHnVHwpFUcT06dPx7LPPYtq0aTWNTERERLVcrf1tT6fT4a233kJkZNmEzm3btkVubi42btyI4cOHw9fXFwAwZswYrF27VtbiVW2QeC4XapWANo1D5Y5CdYQgCIgJ9cHFLDvSc0vRKLp6818REZHzZGVlITo6uvz76OhoGAwGlJaWwt/fv/zxuXPnon379ujdu3e11hMW5n/zhahC19w4xUNs3JOMHYfTkJZjQON6QbK9D0/dfkrCbVgz3H41w+3neWpt8ap+/fqoX78+AECSJLz77rvo378/srOz0atXr/LloqOjodfrq9S20y+Ynnmm7P+PP3Zuu250PLkAbZuGIa5+SLXb0GplOBz1z+Cu1hlYf/Zp96/7Lzd731uWNwYADBp3sUbruV47smzzG6z7zuZzAaBK+0KrBRpGB+JCehGy8k1oFBNY6SHA7j5h8QTpXtze7nPDbV0Lzm1UdaIoXvdxlervPy4kJCTg6NGjmD9/frXXk5dngChyzsPqiogIQE5OidwxqmXr3ktIyTYgLtIfnZuHy/I+PHn7KQW3Yc1w+9UMt1/NqFSCLH9EqrXFq8uMRiP+85//ICsrC9988w2euXwxfYUrL6gqw9kXTH6msrl+Sj30Byi70IRUfQl6to2u1ofA5V98bDa7s6NViiiKsq0buPn7Fh1ipZa7mSvbuVw4UtL7vvwLT1UzadVC+fxXWXmlCA+q3PxX7jxh8QTpXtze7lPRtnbVuU2uCyaqnJiYGCQmJpZ/r9frERQUVN7jHQBWrFiBrKwsjB49uvyx+++/H++88w7atWvn1rzkmeIi/fHCPTe/eQAREdUetbp4lZGRgcceewxNmzbFDz/8AG9vb8TExCAnJ6d8Gb1ef1X3djmUvjVL1vXX1NFzuQCADs3CZE5SDVEfY+1pZc951X/MeUW14yprTz9Z7dcG++tgstqRW2SGt04Nfx+tE5MRUXV4+rmNqqdXr16YNWsWkpOT0ahRIyxZsgQDBgy4apl58+Zd9X18fDy+//57hIZy6gEiIiK6vlo7QUxhYSHuvfdeDB48GB999BG8vct6YwwYMABr166F0WiE1WrFypUrMXDgQJnTerbE83mIDvVFVIjvzRcmcgFBEBAd4gsvrQoZeUbY7NcftkJERK4VFhaGd999F0899RSGDh2KM2fO4IUXXsCxY8cwatQoueMRERGRh6q1Pa8WL16MzMxMbNmy5apbPi9YsACDBw/G+PHjYbPZMGDAANx1113yBQXg/8JzADzzzkwmix1JKQUYeEsDuaNUT9YTGN0qo8p3unOnrcubAaj53QKd1Y6rjG71MYCq33XwMpVKQL1wPyRnlSA9txRxkf5QqSo3/xUROZ8nn9uoZvr06YM+ffpc9VhwcDCioqKuu3xSUpI7YhEREZEHq7XFq8cffxyPP/74dZ977LHH8Nhjj7k50Y1J3j5yR6i2k8kFsDskzxwyCAAqH9gcOrlTVEijdU4vIme14yrO2A86rRoxYX5Izy1FVr4RMWG+lZ7AnYicy5PPbeR8er0ekydPljsGebiEI+lISi1EfINguaMQEZGb1drilScpff1tuSNUW+L5XPh6adC0XpDcUaoncg5+OaPsOa/6jrqgqHZc5Zcz/3JKOwG+WoQHeSO3yAwvnQVhgZWbwJ2InMuTz23kfFFRUTfseUVUGQlH0vHDxrJeet3a8FgiIqprau2cV+R6oiTh6Pk8tG0SCo2ahxIpR1igFwJ8tMgpNMNgsskdh4iIiGpo7wk9AOC+IfHo27GezGmIiMjdWHFQAP//ewr+//eU3DGq7GJmMYpLrejQLFzuKNWX+QjGtp4jd4oKbV7aHJuXNldMO64ytvUcp+0LQRAQE/bXBO65RlhtDqe0S0SV56nnNiJSrvgGwSxcERHVURw2qABSiGfeGvrwmVyoVQLaN/XQ+a4AQB0Go61U7hQV8va1K6odVzHaAp3ankoloF6EHy5lGZCWU4qG0QFQcwJ3Irfx1HMbERERESkPi1cKUPrKa3JHqJbDZ3PQokEw/Ly1ckepvsh3seGssue8un3ERUW14yobzj7i9DZ1GjViw32Rml2K9NxSNIjw4wTuRG7iqec2IlKWhCPp2HtCj5RsA+Ii/eWOQ0REMuGwQaqWzLxSZOYZ0blFhNxRiCrk561FdKgPjGY79AUmSJIkdyQiIiKqpCsLV5yonYio7mLPKwUIeOpxAEDJJ5/LnKTyjpzNBQB09OT5rgAg80FMaJuFZcf/I3eSG9rwUzwAYOjkJEW04yoT2r4HAC7ZF8H+XrDZReQVW6DVsGZP5A6eeG4jImVJOJKOpNRCxDcIxgv3dJY7DhERyYjFKwVwxHrexJOHz+aiYVQAwoK85Y5SM5oGKDSLcqeoUECwRVHtuEqhOdKl7YcHecNqF5FTaMaeYxloFh3g0vUR1XWeeG4jImW5fIdB9rgiIiIWrxTA+J9X5I5QJUWlVpxPL8KoXo3ljlJzEW9g8zllz3nVa1iyotpxlc3nHnJp+4IgICbUFza7AXMWHcILkzuhcczNJ4mXJAnvvPM6GjduismTpwAAhg8fiPDwv4ttkydPweDBQ12WncgTedq5jYiUiXcYJCIigMUrqobEc7mQAHTifFfkYVQqAfUj/FBssuPjnxPx0r23ICrU94bLJydfxIcfzsKJE8cwdWpTAEBKSjL8/QOxYMFP7opNRERERERUp3HyFwUIeHwaAh6fJneMSjt0JgfhQd6oH+End5Say7gXk9q9JXeKCq1f2BLrF7ZUTDuuMqndW27ZFxq1Cm880h2SBHyw9AiKDDceTrly5TIMGzYC/fsPKn/s2LGjUKtVePLJR3H//Xfju+++hsPhcHluIk/jaec2IlKOhCPpmLXoEFKyDXJHISIihWDPKwVwNGsud4RKM1vtOJlcgH6d6kEQBLnj1JwuHjmlXnKnqFBopFFR7bhKTmmc29ZVL8Ifz4zvgPcXH8JHPyfihcmd4eN17cfhc8+9AAA4eHB/+WMOhwNdu3bDv/71NCwWC2bMeBp+fn6YMGGy2/ITeQJPOrcRkXIkHEnHDxvLbi4T3yCY810REREAFq8Uwfh/L8gdodKOX8iH3SGicwsPv8vgZeH/xdYLyp7zqvsdKYpqx1W2XrjPretrEhuIf93VDp8sP4r/rTyGZyd0gEZ9886oI0eOLv9ap9Nh4sR7sHz5UhaviP7Bk85tRKQclydpv29IPOe6IiKichw2SFVy+GwO/Lw1aFY/SO4oRDXWvmkYHhzWEqcuFeCbX05CFKWbvmbjxvU4d+5s+feSJEGt5t8BiIiInIWTtBMR0T+xeKUAAY88gIBHHpA7xk3ZHSKOns9Dh6ZheO/dN/DTTwuvWeall6bjww9nyZCumtLvxj3tX5c7RYXWfd8K675vpZh2XOWe9q/Lsi96tovB+L5Nse9UNn7YlARJqriAdeHCecyf/wUcDgcsFjNWrFiGAQMGVfgaorrIU85tRKQcCUfSkZRaKHcMIiJSIHYXUAB72/ZyR6iUs6mFyM9Jx+/Hv0fKxdPld1+7bNGi73H06OGrJrdWPO+OyCi5IHeKCkXWc85kpc5qx1UySprJtu6htzWE0WLH+j2X4K1TY2L/Zjec0+2hhx7Bhx/Owv333w273Y5+/QZixIi73BuYyAN4yrmNiJThyrmuOM8VERH9E4tXCmB66jm5I1TKoTO5KEnZg0cm3oXExINXP3foAPbu3YNRo8aipKRYpoTVEPYf/HZR2XNedRuYqqh2XOW3i/fIuv4xtzeB2eLA5v2p8PXSYGSvxuXPvfzya+Vfe3t746WXZsqQkMizeMq5jYiUgXNdERFRRThskCpFlCQcOJONwaMfxvDhI656Ljc3B3PnzsGrr74FlYqHFHkmQRAwaVBz9GwbjdW7L2LzPmVPcE9ERFTbcK4rIiK6EVYaFCDwwXsR+OC9cseo0Pn0IhQZrOjSMuKqx+12O2bOfAlPPfV/CA/3wDsQpo3FfR1flTtFhdZ82xprvm2tmHZc5b6Or8q+L1SCgAeGtcQt8RFYsv0cfjuUJmseIk/mCec2IpJfwpF0zFp0CCnZyp7egIiI5MVhgwpg63Kr3BFuav/pbGjUKnRoenWB6vTpk8jMzMC8eR8BAPLz8yCKDlitVvznP/+VI2rV+HTHpcLzcqeoUGwj5wzDdFY7rnKpUBmFNbVKhUdHtsGnK49h4eYzEAQBfTvxr8BEVeUJ5zYikt/eE3qkZBsQF+nPua6IiOiGWLxSANMTT8kdoUKiJOFgUg7aNg6Fj9fVh0zbtu2xcuX68u/nz/8SRUWFeO65F9wds3rCnseOZGXPedW1v3N6/zirHVfZkXy33BHKadQq/Gt0O3y66hh+2JQECOAwBqIqUvq5jYjkd/nugvENgvHCPZ3ljkNERArGYYN0UxczilFQYkHXlpFyRyFyG61GhSdGt0P7pmH4YWMSdiZmyB2JiIio1uDdBYmIqCrY80oBAqdMBAAUL1wqc5LrO5CUDbVKQIdmfw8ZvPLua1eaOvVRN6VykrSReKBTHhYcfkfuJDe06us2AIDRD59QRDuu8kCnlwBAUfuirIDVFv9beRwLNpwGANzeIVbmVESeQennNiKSF+8uSEREVcHilQLYeveRO8INSZKEA6dz0KZxKHy9a+Hh4jsA5/LOyZ2iQnEtChXVjqucy1PmcAGtRo1/j/m7gGW2OjC4awO5YxEpnpLPbUQkryuHC7JwRURElVELqxGex/TIv+SOcEPJWSXIKzZjVK/GckdxjdCnsTtF2XNe3dInXVHtuMrulHFuW5fNLiIiIqBKr3n90R6Ys+gAlmw7C7VWjYkDW0AQhEq//vL6LFY7iotMVVo3kSdS8rmNiOR1udcVhwsSEVFlsXhFFTpwumzIYKcW4TdfmMhDaDUqTJ9b9aKlJEkI9NNi0cbT2PD7RUQEe1eqgKXVamCz2QEAs59mbxQiIqq72OuKiIiqgxO2K0DQ3WMQdPcYuWNcQ5IkHEjKRqtGIfDz1sodxzVSh2Jq5xlyp6jQ8i/aYfkX7RTTjqtM7TxD8ftCEATEhPoi2F+H/BIL9AUmSJIkdywiRVLquY2I5MVeV0REVB3seaUAlsFD5Y5wXSl6A3IKzbizeyO5o7iO/wiczDkrd4oKNW2bp6h2XOVkTg+5I1SKIAiICvGBWiUgr9gCUZQQE+ZbpSGERHWBUs9tRCQ/9roiIqKqYvFKAcwPPSx3hOs6kJQNlSCgU/NaPGQw5F/Yk6rsOa869cpQVDuusif1LrkjVJogCIgI9oFKEJBTZIYolSI23A8qFrCIyin13EZE8rlyyCAREVFVcNggXVfZXQaz0aphMAJ8dXLHIVKksCBvRIX4wGCyIzXbAIcoyh2JiIhIsThkkIiIqos9rxQgaOxIAEDRirWyZQgM8oGX7u/D4WxqAfQFJowfGF/lu7J5lJSBeKRLAb468KHcSW5o2WftAQAT/nVUEe24yiNdngMARe+L6wkJ8IJaJSAzz4hLegMaRPhDq+HfBYiUcG4jIvklHEkvL1qlZBs4ZJCIiKqFxSsFsNwl/4S2XjrNVXdf0xeYIADYtOcCtu5Ndum6Zb37WuBEHMk6I9/6K6Flp2xFteMqR7L6yx2h2gL9dFCrBaTnlOKSvgT1I/zhrVPLHYtIVko4txGRvBKOpOOHjUkAyua5iov0Z68rIiKqFhavFMA85QG5I1xFkiQUl1rh56OFWlXLe5AEP4x9acqe86p99yxFteMq+9KGyx2hRvy8tWgYFYDUHANS9CWoF+FXe+/SSVQJSju3EZH7Xe5xdd+QePa2IiKiGqnllQmqDqPFDocoIdCPv3gTVYWXTo2GUQHQalRIzS5FUalV7khERESy4jBBIiJyBhavFCDormEIumuY3DHKFZfaoBIAf586ULy61BePdX1a7hQVWjKvA5bM66CYdlzlsa5PK35fVIZWo0JcVAB8vTTIzDMit8gMSZLkjkXkdko7txERERGR5+KwQQUw332P3BHKiaKEEqMVAb46qARB7jiuF/QADuw7LXeKCrW91TnD/ZzVjqscSB8idwSnUasENIj0Ky9e2R0SIkO868bPFNFflHRuIyIiIiLPxuKVAlgUdIFvMNsgSqg7QwaDH8CBDGXPedW2m15R7bjKgYyhckdwKkEQEBPmC53WgtwiM8xWO+pH+Mkdi8htlHRuIyIiIiLPxmGDSmCzlf1TgOJSGzRqAb5edaSuKdmgEuxyp6iQwyHA4ah5jx1nteMqKsGu+H1RVYIgIDzIG3FRAbDYHEjOKsGF9CK5YxG5h4LObURERETk2Vi8UoCg8aMQNH6U3DHgEEWUmmwI8NVBqCvDm1IG4ZEu/yd3igr9/Fl7/PxZe8W04yqPdPk/xe+L6gry90LDKH8AwIz/7cLBpGyZExG5nlLObUQkj4Qj6UhKLZQ7BhER1RJ1pHuNspnvuU/uCACAEqMNEoCgujJkEACCp2Hf3lNyp6hQ++6ZimrHVfal3Sl3BJfy1mnQKDoAarUan646jtG3N8Hw7g3rTqGY6hylnNuISB57T5RNV9CtTZTMSYiIqDZg8UoBLOPvljsCgLIhgzqNCl5atdxR3CfoXhzKVPacV627OKeXjrPacZVDmYPljuByGrUKb/2rJ+b8sB+rdl5AWrYBDw5rCW8dP4qp9lHKuY2I3O9yr6v4BsHo27Ge3HGIiKgW4G9MSmA0lv3v6ytbhNxCE4wWO8KDvOtWTxDRCK3KDJvoLXeSG7JZy0b3anWiItpxFa3KDACK3hfO4KVV4+ERrVE/0h8rdpxHRm4p/j2mHaJC5fv5J3IJBZzbiEge7HVFRETOxjmvFCBo8jgETR4na4bfDqYCAAJ969CQQQBIHYapt7wgd4oKrfiyHVZ82U4x7bjK1FteUPy+cBZBEDDstoZ4bkJHFJVa8cb3+3H4bI7csYicSgnnNiKSD3tdERGRM7HnlQKYH5gq6/pFScKWvSnw8VJDV5eGDAJAyOPY8+dJuVNUqGPPDEW14yp7UuvexM5tGofi1Qe64NOVxzFvxTEM79EId/VqDJWqDvV+pFpL7nMbEcnjyiGDREREzsLilQJY7hor6/qTUgqRmVeKmLA6OLQjcCISs5Q951XLzs7pkeOsdlwlMau/3BFkER7kgxfv7YyFm5Pwyx/JSM4qxiMj2sDfp471gqRaR+5zGxHJg0MGiYjIFThsUAGE4iIIxUWyrX/X0Qz4eWsQUBd/WXYUwVtjkDtFhSwmNSymmveIc1Y7ruKtMSh+X7iKTqvGQ8NaYcod8TiVXIA3FuxHclbxVcssX74EkyaNwQMPTMbMmS+hWMbPDKLKkPvcRkTy4ZBBIiJyNhavFCDwvkkIvG+SLOsuNdtw4HQO+nSuXzeHKqWNwgOdXpY7RYVWfdMWq75pq5h2XOWBTi8rfl+4kiAI6NepHv5zT2eIkoR3Fh7EtoNpkCQJhw4dwKJFP2Du3M+xYMFP6N69J95//225IxNVSM5zGxHJ4/KQQSIiImfjsEEFME17TLZ1/3lCD7tDxOBuDfFFWqFsOWQT+hR2/3FC7hQV6nx7uqLacZXdlzjECACa1gvCaw/eim9+OYlFW87gdEoB/EtOoEuXWxEZWTYEo0+f/pg16y3YbDZotXWwxyR5BDnPbUQkDw4ZJCIiV2HxSgGsw0fKsl5JkrAzMQMNowLQtH6wLBlkFzAGx7PD5E5RoRYdchXVjqscz75d7giK4e+jxVPj2mPzvlQsTzgPjVlA5qF9yMrKRHR0DH79dS1sNhuKiooQHh4ud1yi65Lr3EZE8rhyonYOGSQiImfjsEEFEPLyIOTluX29l/QlSM02oHeHGLevWzHsufDVFsqdokJGgwZGQ83rzM5qx1V8tYWK3xfupBIEDOkWh//c0xn+EU2hq98H/37maUydOgWCoEJgYBC0WuXuTyK5zm1EJA/2uiIiIldi8UoBAqdOQeDUKW5f787ETGg1KtzWug5fZKSPw30dZ8qdokJrv2uDtd+1UUw7rnJfx5mK3xdyaFY/CDMmtkGHjp0Q2PExdLpzBrreVtZLLTAwSOZ0RDcm17mNiOTDXldEROQqtf7P9pIk4cUXX0Tz5s0xdepUOBwOvPvuu9i9ezccDgceeughTJok74SypsefdPs6LTYH9p7MQpf4SPh61+E5c0L/Dzt+Py53igp17ZemqHZcZUfyRLkjKJa5tBAHf/0YDzzzIX7Zm4nf1n2LW7r1gSDUwZsskMeQ49xGypCQkIAPPvgAVqsV8fHxeOedd+Dv73/VMrt27cJHH30Eh8MBlUqF5557Dr1795YpMdXUlUMGiYiIXKFWF6/Onz+P119/HYmJiWjevDkAYMmSJbh06RJ++eUXlJaWYuLEiWjTpg3at28vW07rHUPdvs4Dp7Nhsjhwe10eMggAASNwKidQ7hQVatrWOcNunNWOq5zK6SF3BMWKi2uEe++9H8u+egVWmwPwrY80TTcs++0cxtzeBBo1O9GS8shxbiP55efn48UXX8TixYvRqFEjzJ49G3PmzMFrr71WvkxJSQmef/55/Pjjj2jevDlOnz6Ne++9FwkJCdcUucgzcMggERG5Wq3+jWfRokUYM2YMhg79+wJ669atGDNmDDQaDYKCgnDnnXdi7dq1MqYEBL0egl7v1nXuSMxAZIgPWtT1v5DZsxCgU3ZRp7RYi9LimveOc1Y7rhKgy1P8vpDT2LETsWjRcvy8bBV++vpj9OvSCBv3puCtHw4gM69U7nhE15Dj3Eby2717N9q1a4dGjRoBACZNmoR169ZBkqTyZWw2G2bOnFn+h8VmzZpBkiQUFBTIEZmchEMGiYjIlWp1z6tXX30VAPDnn3+WP5aZmYmYmL97G0VHRyMpKalK7YaFOfmvguNHlP2fkODcdm/gQnoRzqUVYerINoiM/LvXkdyTP8uy/vS7cW/HInxz+H/uX/dfbva+1y8sm6fqnmdqNrzxeu3Iuc//ue57O74JAG7bF+5+71euLyIioMbt/d+9XdCzYz18svQIXl9wANNGtcWQ2xpyKOFfnLGNqXJuuK3dfG4jZcjKykJ0dHT599HR0TAYDCgtLS3vVRUaGophw4aVL/PJJ5+gUaNGaNCgQaXX4/RrsTrIWZ+TG/ckIym1EG2bhtWpz9669F5dhduwZrj9aobbz/PU6uLV9Vz5l7/LVKqqdUDLyzNAFK9tp7q0jz8FALDllDitzYqs2JYEnUaFjk1CkfPXOiMiAmCz2d2y/huRZf1h/8H23Udlfe83W3fX/pcqtdzNXNnO5UKKkt739guTrvu4u9bvSlqt5qr15TjpZ71plD9ef6gr5q8/hc+WJ2JPYjoeGNoSAb46p7TvqSIiApy2jaliFW1rV53bVCqBhQsFE0Xxuo9f71rLbrfjvffew86dO7FgwYIqrcfZ12J1jTM/J7fuLbu+6Nw8vM589vI8U3PchjXD7Vcz3H41I9e1WJ0rXsXExCAnJ6f8e71ef9VfCOVg6z/IbesymGz484Qet7WJhl9dnqj9Mv8hSMr1kTtFhRq3cs4wCme14ypJud3kjuCRgv298OyEDth6IA3LE87h1W/3YeqwVmjbJEzuaFTHufPcRsoRExODxMTE8u/1ej2CgoLg6+t71XJFRUV46qmnIEkSli5dipCQEHdHJSfikEEiInK1Wj3n1fUMGDAAK1asgN1uR3FxMdavX4+BAwfKmkmVngZVunvuBLf7aCasdhH9O/MCAwBgS0WQd7bcKSpUXOCF4gIvxbTjKkHe2YrfF0qlEgQM7toAr9zXBf7eWny4LBELNpyGyVLz3mUbNvyCBx6YXP5v/PiR6NOnG/LzOT8ZVcyd5zZSjl69eiExMRHJyckAym6UM2DAgKuWsVqteOihh1C/fn18++23LFwRERHRTdW5nleTJk1CSkoKRo0aBZvNhokTJ+LWW2+VNVPAE48AAIpW/+rS9YiihO2H0tCifhDiojjGFwCQMQWT2hXii/1z5U5yQ7/+2BIAcPeTiTdZ0j3tuMqkdm8DgKL3hdLFRQXg1Qe6YPXui9i4NwUnLubjwWEt0bpRaLXbHDp0OIYOHQ6gbIjPE088jHvuuR+hoezZRRVz17mNlCUsLAzvvvsunnrqKdhsNsTFxWHWrFk4duwYXnnlFaxZswYbN27E8ePHYbVaMXbs2PLXvv/++4iPj5cxPVVVwpF0JKUWIr6u3wCIiIhcrk4Ur957773yrzUaDV5++WUZ01zL+Ox0t6zn8Nkc5BaZMaFfM7eszyOEv4JtO5VZzLms++BLimrHVbadnyJ3hFpBq1FjfN9m6Nw8AvPXn8KcJUfQr3M9jO/bFN66mn3k//jjAoSEhOCuu8befGGq89x1biPl6dOnD/r06XPVY8HBwYiKigIAjBw5EiNHjpQjGjlRwpF0/LCx7KZH3dpEyZyGiIhquzpRvFI6W59+blnPpn2pCA/yRucWEW5Zn0fwG4iz+cqe+6thfKGi2nGVs/ld5I7gFja76Ja7m0REBKBTmxj8uOEU1uw8j5PJBfjX2PZoEOZ78xdfR2FhIZYsWYRvv/3RyUmptnLXuY08g16vx+TJk+WOQU5yZeHqviHxnO+KiIhcjsUrBVAlXwQAiI0au2wd59OLcC69CJMGNodKJbhsPR7HegGhPhnIN8XKneSGCnO9AQDB4WZFtOMqoT4ZAKDofeEMWo0K0+fucOs6G0T4IzPfiJlf/4mBXepjbJ+m8NKqq9TG2rUr0bt3H8TG8hcUqhx3nNvIc0RFRZX3vCLPxsIVERHJoc5N2K5EAc88gYBnnnDpOjbtT4Wvlwa928e4dD0eJ/MhTGg7S+4UFdq4OB4bF9d8DhBnteMqE9rOUvy+8FS+3ho0jg7A8F6NsfVAGmZ+uw9JKVW7++S2bVswbNgIFyWk2sgd5zYicr+9J/QAWLgiIiL3Ys8rBTDOeMml7WcXmnAwKRtDusXVeM6bWifidWzecUTuFBXqOTRZUe24yuZzD8odoVZTqQQ8Oro9WjcIxre/nsKsnw7j9g6xGN+vKfy8Kx46W1xcjPT0VLRr18FNaf92/vw5fPTR+ygtNUClUmP69JfQsmUrt+egqnP1uY2I5BPfIJiFKyIicitWMhTA1qOXS9vfuDcFapWAgbc0cOl6PJJvH1yoWgcUt2vQrEhR7bjKhYKOckeoE1o2DMGbU7thze8XsXlfKo6cy8Xkgc3RtWUkBOH6Q4rT01MRFhYOjca9pwyz2YznnnsC//nPf9G9ey/s2pWAN954BT/9tMKtOah6XH1uIyL3490FiYhILixeKYD63FkAgKNZc6e3XVBiwe6jGejVLgYhAV5Ob9/jWZIQ4ZuCHGOc3EluKF/vAwAIjTIpoh1XifBNAQBF74vawkunxoR+zdCtVRQWbDyNL9acwJ7jWbh3cDzCgryvWb5VqzZYunS123Pu2/cnYmPro3v3siJIr159EBPDv/R7Clee24jIvRKOpGPvCT2SUgsB8O6CRETkfpzzSgH8n38a/s8/7ZK2N+9PgSgCQ25r6JL2PV7Woxjb5gO5U1Ro87IW2LyshWLacZWxbT5Q/L6obRpGB+CV+27B3f2b4VRKAV75Zi8270+FQxTljgYASE29hLCwMLz77huYOnUKnnnmCTgcDrljUSW58txGRO6194QeKdkGxDcI5lxXREQkC/a8UoDSl2a6pF2DyYaEwxno1joSkcE+LlmHx4t4BxsSDsudokK9h19UVDuusuHsw3JHqJPUKhUG3xqHzi0isHDzGSzZdha7j2bgnkEtEB8XIms2u92OPXt+xyeffIk2bdpi164ETJ/+NJYvXwedTidrNro5V53biEgecZH+eOGeznLHICKiOoo9rxTAfms32G/t5vR2N+1LgdXmwDD2urox3x64VNhW7hQVqte4GPUaFyumHVe5VNhW8fuiNgsP9sEz49vjidHtYLI4MOunw/hy7QkUlFjkyxQegYYNG6FNm7LjonfvvhBFBzIy0mXLRJXnqnMbEREREdU9LF4pgPrUSahPnXRqm8VGK7YeSEPXVpGoF+Hv1LZrFctxRPlfkDtFhXIyfZGT6auYdlwlyv+C4vdFbScIAm6Jj8BbD3fDyJ6NcDApBy999Sd+/fMS7A73DyW87bYeyMzMxOnTpwAAR44cAiAgJibW7Vmo6lxxbiMi90o4ko5Ziw4hJdsgdxQiIqrjOGxQAfxffB4AULT6V6e1ueHPS7DaHRjVq7HT2qyVsv6N0a0K8cX+uXInuaFty8smO777yURFtOMqo1uV7QMl74u6wkurxl29m6BHuxgs3XYWyxPOY9fRTNzdvxnaNw274V0JnS0sLBzvvjsHH3zwHsxmE7RaHd5+eza8vHjzCU/ginMbEbnX5bmu4iL9OUk7ERHJisUrBSid+aZT2ys0WLD9UDpuax2NmDA/p7Zd60TOxi/bD8mdokJ9RjmnN5Kz2nGVX5IelzsC/UNksA+eHNseR8/nYfHWM5i7/CjiGwRjfL9maBIb6JYMHTt2xtdff++WdZFzOfvcRkTulXAkHUmphYhvEMy5roiISHYsXimAvdMtTm3vlz+S4XBIGNmrkVPbrZV8uiKt2Ch3igrFxJUoqh1XSStuKXeEWs9mFxEREVDl1w2ICECfrnHYtCcZi7ck4a0fDqBXh1hMGdYKseGVH5ZssdpRXGSq8vrJMzn73EZE7pNwJB0/bEwCAPa4IiIiRWDxSgHUx44CABzt2te4rax8I3YcycDtHWMRFaLc+Y0Uw3wEsQFnkVHSXO4kN5SdVtZ7LrJ+qSLacZXYgLMAoOh94em0GhWmz91RozYig32gUQn4/WgGdidmINhfh/Agb2jUN59CcfbTfWq0bvIszjy3EZF77T2hBwDcNyQefTvWkzkNERERJ2xXBP///gf+//2PU9pakXAeGrWKc11Vlv4ZjGz5P7lTVGj7qmbYvqqZYtpxlZEt/6f4fUGAWiUgItgHTWMDEeyvQ6HBigsZxcgpNMEhw6TupFzOPLcRkftcOVyQhSsiIlIK9rxSAMOb7zmlnbNphTh4Jgd39WqMID+dU9qs9aI+xtptB+ROUaH+o88pqh1XWXv633JHoCrQqFWIDvVFSIAXcovMyCu2oKDEgpAAL4QGeEFdiZ5YpHw7dybgrbdmYvPmqvfYc9a5jYjcI+FIOvae0CMptRAAhwsSEZGysHilAM4YUiFKEpZuP4cgfx3uuDXOCanqCO+OyCgpkjtFhZw1zE+pwwUv43BBz+SlVaNeuB8sVgdyi/8uYgX7eyEkwAtaDYtYnio1NQWffvoxJKl6Peo4XJDIc1w5x1V8g2B0axPFXldERKQo/K1CATSHD0Jz+GCN2vj9WCYuZBRjXJ+m8NKpnZSsDjDtR/3A03KnqFBmSgAyU6o+ybar2nGV+oGnFb8v6Ma8dGVFrMYxAfD30SK/xILzGcXIzDPCYnPIHY+qyGw24403/osnn3y22m0449xGRO5x5RxXL9zTmYUrIiJSHPa8UgC/1/8LACha/Wu1Xm8027A84Tya1QtC97bRzoxW+2VPx/D4Qnyxf67cSW5ox5omAIC7n0xURDuuMjz+cwBQ9L6gm/PSqhEb7odwuwP5xRYUlVpRVGqFn7cGe49nomvraKhUgstz/POuirzTYdXMnv02Ro0ag6ZNq98jsqbnNiJyL85xRURESsbilQIY3p1To9ev3nURBqMNz01oAZXg+l8Ka5Xo/2HV1v1yp6jQgHFnFdWOq6w69bTcEciJdBo1okN9ER7kjUKDFQUlFrz13T5oNSoE++sQ5Ker1B0Kq0Or1cBms1/1GO90WHkrV/4MtVqD4cNHITMzo9rt1PTcRkRERER0GYtXCuBo1brar72YWYxth9LQt1M9NIxW7pAwxfJqC70hT+4UFYqIMSqqHVfRG5rIHYFcQKNWITzIG2GBXhjVpznm/XwYOYVm5BaaEeCnRYi/F7x1aggsvCvGhg3rYDab8cADk2G322CxWPDAA5MxZ85chIdHVLqdmpzbiMh9rry7IBERkVKxeKUAmn17AQD2W7tV6XV2h4jvfj2NID8dxvZp6opotZ/xDzQMPo5LhW3lTnJD6RcDAQD1Ghcroh1XaRh8HAAUvS+o+gRBQO9O9bB25zlYrA4UGCwoLrWiuNQGL60KgX46BPrqOMG7Anz99Q/lX2dmZuC++yZiwYKfqtxOdc9tROQ+V07UzrsLEhGRkvG3BAXwe+d1+L3zepVft3FvCtJyDJgyOB6+3qxDVkvOSxja/Gu5U1Ro1y+NseuXxoppx1WGNv9a8fuCnMNLVzaksGm9IESF+EAQBOQUmnE+oxgp2QYUlVohipLcMamGqntuIyL3uXKids53RURESsaKhwIY5lR9gur03FKs/T0ZXeIj0KlF5Ydx0D9Ef4kVm/fJnaJCgyecUVQ7rrLixP/JHYHcTK0SEBLghZAAL1htDhT91RMrM8+ILAEI8NEi0E8HX28N5/OTSUxMLLZs2VWt11bn3EZE7seJ2omIyBOweKUAjmZVu5uT3SHi67Un4OOlxj2D412Uqo7wikeOMUvuFBUKjXLOHdKc1Y6r5Bjj5I5AMtJp1YgI9kF4kDdMlrJCVonRhmKjDSoB8PfRIsBXCz9vrVvuVkg1V9VzGxERERHRjbB4pQDaP3YDAGw9elVq+dW7LiIl24Anx7ZDkJ/OldFqP+MONAk5ggsFHeVOckOp54IAAA2aFSmiHVdpEnIEABS9L8j1BEGAr7cGvt4aRIdKKDXbUWK0wWAqK2QJlwtZPlr4+WigVnH0u1JV9dxGRERERHQjvOpXAN/334Hv++9UatmklAJs+PMSbu8Qi07NOVywxnJmYnCz7+ROUaHfNzTC7xsaKaYdVxnc7DvF7wtyL0EQ4O+jRUyYL5rVC0SDSD8E+elgNNuRkWfE2bRipOgNyC82w2pzyB2X/qEq5zYicr/LdxkkIiLyBOx5pQAlH39aqeWKDBZ8seYEokJ9cfeAZgCATZt+xU8/LYQgCPD29sYzzzyPli15e/JKi/kWyzbtlTtFhYZMSlJUO66y7PgLckcgBRMEAX7eZcMGo0IkmKwOlJrKemRlF5qRXWiGTqOCn48WwQFe0KkFCE6YJ0vOz1hP/3yv7LmNiORxebJ23mWQiIg8AYtXCiA2uvkd4ByiiC/XnoDJasfzd3eEt06DlJRkfPbZXMyfvwjh4eHYs2c3XnppOlauXO+G1LWErgnyTalyp6hQcLhZUe24Sr4pVu4I5CEEQYCvlwa+XhpEBPvAaneg1GSHwWRDYYkFBSUWqASUFbt8NPDz1lZrPXJ+xtaGz/fKnNuISF6crJ2IiDwFi1cKoN3xGwDA1qffDZdZkXABp1MKMW14K9SL8C97nVaHF174L8LDwwEALVu2Rn5+Hmw2G7Ta6v2yVueUbkXz0EScze8id5IbupQUDABoGF+oiHZcpXnoAQBQ9L4gZdJp1NAFqBES4AVRlGC2iygqsaDUbEOJyQbAhMdnbUPLuGC0bRyK+AYh8NKpb9qunJ+xteHzvTLnNiKSx8Y9yUhKLUR8g2C5oxAREVUKi1cK4PvRbABA0Q0u8HcdzcDGfSno37keerSNKX88JiYWMTFlvVUkScK8eR+hV6/bPeYXG0XIfQsDmhYqumCyZ3NDADUvOjmrHVcZ0HQhABavqGZUKgFBfl7w1akhSRKsNhGlZhsiQ3yx40gGth5Ig0YtoHn9YLRpHIpWDUPQMCrguncwlPMz1pnrDgzygZfOdaf7iIiA6z/xvw8hShLyWLwiUpSEI+n4YWPZVAIcMkhERJ6CxSsFKPn0qxs+l5RSgB82JqF1oxBMGnj9246bTCa8/fZryM7W44MP5rkqZu0UuxCLN/4pd4oKDbv3tKLacZXFx16WOwLVMoIgwEunhpdOjdcf6Y6MzEKcSS3CiYv5OH4xD8sTzgMAfLzUaFE/GPFxIWjZMBhxkVcXs+T8jHXGur10Gkyfu8PJycpotRrYbPbrPhfU9wm8MvU2l6yXiKrv8lxX9w2J55BBIiLyGCxeKYBYr/51H0/LNmDeimOICPbB43e1ve4t4bOysvDCC8+iUaNGmDfvC3h5ebs6bu2ibYAi8wW5U1QoMMSiqHZcpcgcKXcEquW0GjXaNA5Fm8ahmIBmKDRYcDqlAEkphTidUojE83kAri5mhftaMG/Of9GoUWO3f8Z6+ud7UUgk0KABkFMidxQi+svlOwy2bRrGwhUREXkUFq8UQLt9CwDA1n9Q+WPZhSZ8sOwIdFoVnpvQ4boTDhcXF+HJJx/B0KHD8dBDj7gtb61i2Ij48KNIyu0md5IbungqBADQuFWBItpxlfjwsrs+KnlfUO0S7O+F21pH47bW0QCAghILklL/LmYdOpWKS7vmIrRhV/i0GIe1f6Shab0gNI0NRJC/l0uz1YbP9/hTe4GNJuCWnnJHIaK/XO511afT9f9wSkREpFQsXimA7ycfAQCK/ipe5RWZ8cGSw7DbRfznns4ID/a57utWrVoOvT4LO3cmYOfOhPLH5879DEFBwa6OXTvkvYd+jQsVXTDZuzUOQM2LTs5qx1X6Nf4JAItXJJ+QgKuLWV989RUumIvgKEjCjqVvYIvdAQCof9sjiAwPQ+PYQDSI9EdcpD8aRPojJMALgnDt3FnVURs+3/tt/Qk4/Svw8zq5oxAR/u51Fd8gGEO6N0IOe0USEZEHYfFKAYq//K7869xCE95ffBilZhuem9ix/M6C13P//VNx//1T3RGx9qq3BIt+/UPuFBUacf9JRbXjKosSX5U7AtFVHnvkETz2yN+9nmx2By7pDbiQXoTzGcVIzirGgdPZ5c/7eWvQINIfDSIDEBvui6gQX0SF+iLYX1flolZt+HxfdP+rePXhHnLHICJwknYiIvJ8LF4pgBRVdhGRlW/EB0sOw2Rx4Pm7O6FxTKDMyeoATTRKrGFyp6iQX6BNUe24itL3A5FWo0azekFoVi+o/DGTxY7UbMMV/0qw40g6rHaxfBkvrRqRIT6ICvVFVIgPQgO8EBLoXfZ/gBf8fbRO67GlJCWBYUB0NOe8IlIATtJORESejsUrBdBt2oDMvFK8kxMFQQCmT+qEhtE3uPU4OVfJOrSKOI5TOcrtHXD+eFlRp2nbPEW04yqtIsp6wCl5XxD9k4+XBi0aBKNFg+Dyx0RRQn6xGfoCE/QFRmTlG5FdYEKqvgSHknIgStJVbWg1KoQEeCHIT4cAXx0CfLUI8NXC3+fvrwOu+FqrUbv5XVZPq+N/AOuKgdv6yh2FqE67crggC1dEROSpWLxSAPUnH8OeVQLfRz7AcxM6IDLEV+5IdUf+B+jTqFDRBZP9v5VNqlrTopOz2nGVPo2WAmDxijyfSiUgPNgH4cE+aNM49KrnRFFCUakVBSUW5BebUVBiKfu6xIwigxVZ+UacS7OixGTDP2pc5by0avj7aMv++WoRcMXXlx8P8NHC31cHfx8tQkL93PCur9Xnt6XA2U3Az31lWT8Rlbnc64rDBYmIyJOxeKUAWZ99hz2H0vDSHR0R6KuTO07dUm85flj/u9wpKjTywROKasdVfjjyutwRiFxOpRIQ8tdwwSaxNx4aLkoSjGY7SoxWlBhtZf9MVhiMNhhMf/8rMdqQU2BCickGk8V+3bYEAVAJArQaFTRqFbRqARqNClq1ClqNCjqtCmqVyunv9YcHX8frj/YEblCEIyLnSjiSXl6oulJKtoG9roiIyOOxeKUAQQ1jcVfDWLlj1E2acBhtwXKnqJCv//V/IZWrHVdR+n4gcieVIJT3ooqp5HRwdoeI0n8UtgwmG+wSsP73i7A7RFjtDhjNIsR/FJTUKgE6rQo6jbr8f2+dGhq1UO35uIz+wUB4OOe8InKxy0WrpNRCAED8FcOYASAu0p+9roiIyOOxeKUAul/WAgCsw0fKnKQOKlmJtpEncDz7drmT3NCZxHAAQIsOuYpox1XaRu4EAEXvCyIl06hVCPL3QpC/11WPR0QE4NDpq3tjOEQJdrsIq72soGW1lf1vMNngKP27sqVSCfDWquGlU5f/76VVVaqg1TZxJ7AyD+g9yDlvkIiua+8JfXnvqm5totjDioiIaiUWrxTA55svALB4JYv8T9CrYaGiCyaHdpZdhNa06OSsdlylV8MVAFi8InIHtUqAWldWjAK0Vz3nECVYbQ6YrQ5Y/vq/0GApn4NLEAAfnQY+Xmr4++rKhiGqrx122GvnCuDCNhaviNwgLtIfL9zTWe4YRERELsPilQIU/7AYAYE+iIjgHQbdrv4aLPhlt9wpKjR62nFFteMqCw6/LXcEqsVsdlG2z1ib3eExdwgEygpbPl4a+Hj9fYkgSRKsdhFmqwNmix0mqwN5xRbkFVsAlN0x0cdLDV8vDXy9NNBqVFgw7W28+XgvwCrXOyEiIiKi2oLFKwWQAoPgFRGA6XN3yJZh9tN9ZFu3rNRBMNv95U5RIS8fh6LacRWl7wfybFqNSrbP2NlP9/H4z3dBEOClVcNLq0aQX9mNRURRgl0ESowWmCx2lJrsKC61ASgrgPl6a5BsFODHKw0il0k4ko6k1MJr5rkiIiKqbXhJqQBeq1cAgT4AouWOUvcUL0WH6JNIzOovd5IbOn0oAgDQsnOOItpxlQ7R2wFA0fuCiP6mUgnw89JApymb/+py7yyj2Q6TxY7OiQkomn8Bfo/eL3NSotrhencTvDxJOydkJyKi2o7FKwXwXjAf0KqB0a/LHaXuKfgc3RsUKrpgcuT3sjtR1rTo5Kx2XKV7gzUAWLwi8lRX9s4KCfDCXSc3o2lxMHJYvCKqkYruJshJ2omIqK5g8UoBin5aXjYXy9f75Y5S9zT4FfPX7pI7RYXGPnpMUe24yvyDs+SOQERONP/RWXjnid5AqbKHLBMpHe8mSERExOKVMvj6lv0j91P5wiZ6y52iQlqdqKh2XEXp+4GIqsam8y47t5WWyB2FyOPxboJERFTXsXilAF4/L/lrzqsGckepe4p+ROeYUziUOVjuJDd08kAkAKB1l2xFtOMqnWM2A4Ci9wURVV7nA5uBH1OBO0bJHYXII10eLpiSbUBcJG9qQkREdZtK7gAEeC/6AfjmG7lj1E2F3+DW+uvlTlGho3ticHRPjGLacZVb669X/L4gosq7dc96ntuIauDKwhUnZCciorquzva8SkhIwAcffACr1Yr4+Hi888478PeX569aRT+vKZvz6rM/ZFl/nRa3BV+t2Sl3igqN/9dRRbXjKl8d+EDuCETkRF/96wPMevJ2oNAsdxRSKCVdi7nD9e4WWJHLhSsOFyQiIqqjxav8/Hy8+OKLWLx4MRo1aoTZs2djzpw5eO211+QJpNWW/SP3E7QQJWX/GKjVkqLacRWl7wciqhpRrfnr3MbiFV1LcddiV6hqkamyrne3wIqwxxUREdHf6uRvi7t370a7du3QqFEjAMCkSZMwatQozJw5E4IguD2P15JFQIA3gMZuX3edV7gAXWJP40DGULmT3NDxvWUXrm271exC2lntuEqX2A0AoOh9QUSV12XvBmDBReDOsXJHIQVS2rXYlVw1zxTvFkhERFR9dbJ4lZWVhejo6PLvo6OjYTAYUFpaWqnu6iqVcy+qvBO2AVo1QgY/49R2qyokwEu2dQcHeMFuU7t/xYaNuK1JMc6X3OX+df/lZtu9MD32r+UKa7SeK9vRaDWVWrcr/XPdtzUpG9born3hzveu0WquOr6VtN1r4/r/ub3due4bqa3b/UbbGgBuSz8KbEyGasQ4p67T2edgkofSrsWuFBLohZBALzw2qq3L1qEE/FmqGW6/muM2rBluv5rh9qs+ubadIEmSsscSucAXX3yBjIwMvPHGGwAAu92ONm3a4PDhw/D19ZU5HREREVHtxmsxIiIiqoo6ebfBmJgY5OTklH+v1+sRFBTEiyUiIiIiN+C1GBEREVVFnSxe9erVC4mJiUhOTgYALFmyBAMGDJA3FBEREVEdwWsxIiIiqoo6OWwQAHbs2IEPPvgANpsNcXFxmDVrFoKDg+WORURERFQn8FqMiIiIKqvOFq+IiIiIiIiIiEj56uSwQSIiIiIiIiIi8gwsXhERERERERERkWKxeEVERERERERERIrF4hURERERERERESkWi1dERERERERERKRYGrkDkGeJj49HixYtoFKpIAgCTCYT/P398dprr6Fdu3aVamP37t2YPXs21qxZU/5YQkICPvjgA1itVsTHx+Odd96Bv7//Na9NTEzE66+/DpPJhMjISMyePRuRkZEAgC+++AKrV6+Gw+HAyJEj8e9//xuCIDjnjcukJtv70qVLeO2115Cfnw+bzYZx48bhoYceAlDxdrxScnIyXnrpJRQWFsLX1xezZs1C06ZNAQDLly/H/Pnz4XA40L17d7zyyivQarXO3whuVJPtffr0abz22mswmUwQBAHPPvss+vTpA4DH94044/OkqKgIY8aMwfTp0zFkyBAAPL5vpCbbOykpCXfffTfi4uLKH/voo4/QpEkTbm+qtJocg/n5+ZgxYwYyMjKgUqnwxhtvoHPnztcsZzKZ8Morr+DkyZMQRRHTp0/HwIEDAVT+s0FJeN1Vc7yWqhleG9UMr3VqjtcvNVOT7Wc2m/H+++/j0KFDMJlMGD9+PKZNmwZApmNQIqqCFi1aSHl5eVc99s0330gTJky46WtNJpP04YcfSrfccot05513lj+el5cn3XbbbdLFixclSZKk999/X5o5c+Y1r7dYLNLtt98uHThwQJIkSVq0aJE0bdo0SZIkKSEhQRo1apRUWloqmc1m6Z577pHWr19fzXepHDXZ3nfffbe0bNkySZIkqbi4WBo8eLD0xx9/VLgd/2ns2LHS2rVrJUkq28bDhg2TRFGUkpKSpNtvv13Ky8uTHA6H9Oyzz0pfffVVTd6qItRkew8fPlzasmWLJEmSlJSUJHXs2FGyWCw8vitQk+0tSZIkiqL06KOPSrfeequ0YcMGSZIq3o7/xOO78tt78eLF0iuvvHLN49zeVBU1OQafeuop6fPPP5ckSZJOnjwp9erVSzIajdcsN2vWrPJjNT09XerZs6eUmZlZpWNVSXjdVXO8lqoZXhvVDK91ao7XLzVTk+335ptvSs8995xkt9ul4uJiqV+/ftLhw4dl234cNkg1YrfbkZmZiaCgIADAvHnz8NRTT2Hy5Mm444478PTTT8NgMAAo+8ufyWTCO++8c1Ubu3fvRrt27dCoUSMAwKRJk7Bu3TpIknTVcseOHYO/vz9uueUWAMC4ceOwZ88eFBQUYMuWLRg+fDh8fX3h5eWFMWPGYO3atS5+9+5Xle09btw4DB8+HAAQEBCAuLg4ZGRkVLgdr6TX63HhwgXceeedAIA+ffrAZDLh5MmT2LZtG/r374/Q0FCoVCpMnDixzm/vVatWYcCAAQCAlJQUBAYGQq1W8/iugqpsbwD47LPPyv+adBmP78qryvY+fPgwzp8/j3HjxmHcuHHYvHkzAG5vqpnKHoN2ux0JCQmYMGECAKBVq1Zo1KgRdu3adU2bW7duxfjx4wEAsbGx6NWrFzZs2FDpY1XpeN1Vc7yWqhleG9UMr3VqjtcvNVPZ7SdJEtasWYOnnnoKarUaAQEB+P7779GkSRPZth+LV1Rl999/P0aOHIlevXrhjjvuAAC8++675c8nJibik08+wYYNG6DRaPDpp58CAAYOHIiXXnqp/AflsqysLERHR5d/Hx0dDYPBgNLS0gqX0+l0CA0NhV6vR2ZmJmJiYq5qQ6/XO+9Ny6i623vs2LHw8fEBAOzcuROHDx9G7969K9yOV8rMzERkZCRUqr8/JqKiopCVlcXtfZ3trdGUjcIeOHAgnnzySTz88MNQq9U8vm+iutt79+7d2L9/P5566qmr2uPxXbHqbm8fHx8MHz4cy5cvx6xZs/Daa6/h+PHj3N5UZdU5BgsKCiCKIkJDQ8uXu3z8/NM/j6fLy1X2WFUiXnfVHK+laobXRjXDa52a4/VLzVRn++Xn56O0tBR//PEHpkyZglGjRmH79u0IDAyUbfuxeEVV9v3332Pt2rX46quvYDab0alTJ4SFhZU/P2TIEISHh0OlUmHcuHHYvXt3he2Jonjdx688yCtaTq1WX/OXmuu93lPVdHuvWrUK06dPxyeffILIyMgKt+OVuL2rvr0FQcDWrVuxefNmfPXVV9izZw+P75uozvbOyMjArFmzMHv27Codt5Vdjtv72uP7tddew+TJkwEATZs2xdChQ7F9+3Zub6qy6hyDlT3OANzweKpKG0rD666a47VUzfDaqGZ4rVNzvH6pmepsP7vdDofDgZSUFHz//feYP38+lixZgq1bt8q2/ZS5dckjtG7dGi+++CJeeeUVpKWllT9+5UEriuJND8KYmBjk5OSUf6/X6xEUFARfX98Kl7PZbCgoKEBUVNR127iyGlwbVHV7S5KE9957D5988gkWLFiAHj16AKh4O14pNjYWubm5V32wXN6uMTExyM7Ovubx2qQq29tqtWL9+vXlH9ANGjRAjx49cOrUKR7flVSV7b1x40aYTCZMmzYNo0aNwvHjx/H+++9j8eLFPL4rqSrb2+Fw4PPPP79qGIMkSdBoNNzeVG1VOQYvX2AXFRWVP6fX6685zoBrP0uzs7PLj7PKHKtKxuuumuO1VM3w2qhmeK1Tc7x+qZmqbL+QkBBotVqMGjUKKpUK4eHh6Nu3Lw4fPizb9mPximpk+PDh6Nix41XzKWzbtg0lJSUQRRHLli1Dv379KmyjV69eSExMRHJyMgBgyZIl5ePjr9ShQwcUFhbi0KFDAIAVK1agY8eOCAwMxIABA7B27VoYjUZYrVasXLmy/O5CtUlVtvfbb7+N/fv3Y8WKFWjVqlX58hVtxytFR0cjLi4Ov/76KwBg165dUKlUaNGiBfr374/t27cjLy8PkiRh6dKldXp763Q6fPzxx1i/fj2Asg/fvXv3omvXrjy+q6Cy2/uhhx7C1q1bsWbNGqxZswZt27bFjBkzMGnSJB7fVVDZ7a1Wq7F9+3YsW7YMAJCeno7Nmzfjjjvu4PamGqnsMajRaNC3b18sXboUQNkdzM6fP49u3bpd0+aAAQPKl8vKysKuXbvQr1+/Sh+rSsfrrprjtVTN8NqoZnitU3O8fqmZqvwM9+vXr/xOtZeHELZr106+7XfTKeaJrnC9uxWcP39eatOmjbRz507pk08+kSZPnixNnDhRGjx4sPTyyy9LJpPpquX//PPPq+56I0lldx4YMWKENGTIEOmRRx6RCgoKJEmSpKNHj0ojR44sXy4xMVEaO3asNGzYMGny5MlSampq+XOff/65NGzYMGnQoEHSe++9J4mi6OR3737V3d4ZGRlSfHy81K9fP2nkyJHl/5YvXy5J0o23Y1ZWljRy5EgpKytLkiRJunjxonTvvfdKd955pzR69Gjp+PHj5TmWL18u3XnnndLgwYOl6dOnS2az2U1bxXVqcnyfPn1amjx5sjRy5EjprrvuuuqONzy+r88ZnyeSJEn33ntv+R14JInH943UZHsnJydL999/vzR8+HBp6NChVx3f3N5UWTU5BnNycqRHH31UuvPOO6Xhw4dLu3btKm9j2rRp0tatWyVJkiSDwSA9//zz0rBhw6Q77rhDWr16dflyFX3GKhWvu2qO11I1w2ujmuG1Ts3x+qVmarL9CgoKpOeff14aOnSoNHjwYGnevHnlbcix/QRJus5gQ6JqmjdvHgoKCvDqq686rc1HHnkEX331ldPaq01csb2nT5+Ol156CSEhIU5rs7bg8e1ePL7di9ub5FbdY3DZsmUICQnBoEGDXJRMuXheqjl+9tUMj8Ga4fFXc9yGNeNJ24/DBknR9Hp9+SR75Homkwm9evWqEx/USsDj2714fLsXtze5i1qtRt++feWOUSvwvFRz/OyrGR6DNcPjr+a4DWvGlduPPa+IiIiIiIiIiEix2POKiIiIiIiIiIgUi8UrIiIiIiIiIiJSLBaviIiIiIiIiIhIsVi8IiIiIiIiIiIixWLxiogU7aGHHkJ+fn6Nl9m7dy+GDx9+0/XFx8dft61t27bhrbfeAgBMmTIFGzduRFpaGjp16nTTNomIiIg8Fa/FiEgJNHIHICKqyO+//+6UZWpqwIABGDBggMvXQ0RERKQkvBYjIiVgzysiUqwXX3wRAHD//fdj3759mDJlCkaMGIGRI0di9erV1yyTmZmJ3377DXfffTfGjBmDvn374uOPP67yej/++GOMHj0ao0aNwm+//QYAWLlyJR599FGnvC8iIiIiT8BrMSJSCva8IiLFevfdd7Fy5Up8//33mDBhAmbMmIHBgwdDr9dj/PjxaNiw4VXLhISEYMaMGXjvvffQqFEj6PV69OvXD/fdd1+V1lu/fn288cYbOHPmDKZMmYINGza46B0SERERKRevxYhIKVi8IiLFO3/+PCwWCwYPHgwAiIqKwuDBg7Fr166r5jkQBAFffPEFEhIS8Msvv+D8+fOQJAkmk6lK65s0aRIAoEWLFmjatCkOHz7svDdDRERE5GF4LUZEcuOwQSJSPEEQrnlMkiTY7farHjMajRg9ejROnDiB1q1bY8aMGdBoNJAkqUrrU6n+/miUJAkaDev8REREVHfxWoyI5MbiFREpmlqtRr169aDVarF582YAgF6vx6ZNm9CjR4/yZex2Oy5dugSDwYBnnnkG/fv3x759+2C1WiGKYpXWuWrVKgDAiRMncOnSJXTo0MG5b4qIiIjIQ/BajIiUgCVsIlK0QYMGYcqUKfjss8/w1ltvYd68eXA4HHjiiSdw2223lS8zefJk/O9//0Pfvn0xdOhQBAYGIi4uDs2aNcOlS5eg0+kqvc7U1FTcddddEAQBH374IYKDg1307oiIiIiUjddiRKQEglTVPpxERERERERERERuwp5XRFSnfPPNN1i3bt11n5s6dSpGjhzp5kREREREdQevxYioOtjzioiIiIiIiIiIFIsTthMRERERERERkWKxeEVERERERERERIrF4hURERERERERESkWi1dERERERERERKRYLF4REREREREREZFisXhFRERERERERESKxeIVEREREREREREpFotXRERERERERESkWCxeERERERERERGRYrF4RUREREREREREisXiFRERERERERERKRaLV0REREREREREpFgsXhERERERERERkWKxeEVERERERERERIrF4hURERERERERESkWi1dERERERERERKRYLF4REREREREREZFisXhFRERERERERESKxeIVEREREREREREpFotXRERERERERESkWCxeERERERERERGRYrF4RUREREREREREisXiFRERERERERERKRaLV0REREREREREpFgsXhERERERERERkWKxeEVERERERERERIrF4hURERERERERESkWi1dERERERERERKRYLF4REREREREREZFisXhFRERERERERESKxeIVEREREREREREpFotXRERERERERESkWCxeERERERERERGRYrF4RUREREREREREisXiFRERERERERERKRaLV0REREREREREpFgsXhERERERERERkWKxeEVERERERERERIrF4hURERERERERESkWi1dERERERERERKRYLF4REREREREREZFisXhFRERERERERESKxeIVEREREREREREpFotXRERERERERESkWCxeERERERERERGRYrF4RUREREREREREiqWROwAReba33noL+/fvBwCcP38e9erVg7e3NwBg6dKl5V/XVqdOncKTTz6JgIAAzJs3D/Xr17/ucvn5+ejevTuSkpLcnJCIiIjo5tLS0jBo0CC0aNGi/DFJknDfffdh3Lhx2LZtG/bs2YNXXnnFKetbuXIlPvnkEzRt2hTz58+/4XIbN27EokWLsHDhQqesl4g8E4tXRFQjV17A9O/fH3PmzEG7du1kTORe27ZtQ7du3fD222/LHYWIiIioRry9vbFmzZry7/V6PYYPH462bdtiwIABGDBggNPWtXr1ajz77LMYNWqU09okotqLxSsicpl58+bhyJEjyM7ORnx8PObMmYPPP/8cmzdvhiiKqFevHmbOnImoqCiUlJTg7bffxpkzZ2Cz2dC9e3fMmDEDGo0G7dq1wwMPPICEhAQYDAZMnz4dGzduxJkzZxAZGYkvvvgCvr6+WL58OZYuXQqbzYaioiI8/PDDmDx5MlauXIn169dDFEXo9XpERUXhvffeQ1RUFDZv3ozPP/8cgiBArVZjxowZ6Nq16zXv5dNPP8X69euhVqvRuHFj/Pe//8WePXuwePFiOBwOmM1mfPDBB1e9ZvPmzfjoo4/g4+ODtm3blj9uNBrx2muvITk5GUVFRfDz88OcOXPg7e2NO++8Ezt37kRAQAAkScKQIUMwd+5ctGzZ0uX7i4iIiOhKUVFRaNiwIZKTk3Hy5Els2rQJX375ZYXXbVcqKSnB66+/jtOnT0MQBPTu3RvPPfcc3n//fRw7dgxpaWkoKCjAAw88cNXr5s6di3Xr1iE4OBgNGzYsf/zixYt44403YDQakZ2djZYtW+Ljjz/Gpk2b8NNPP2HJkiUAgIyMDEyYMAHbt2+HTqdz+XYiItfjnFdE5FLp6elYtWoV5syZg9WrV+PMmTP4+eefsWbNGvTp06e859Y777yDNm3aYOXKlVi9ejUKCgrw3XffAQCsVisiIiKwbt06TJo0Ca+88gpefvll/PrrrzAYDNi2bRtKS0vx888/46uvvsLq1avx0UcfYfbs2eU5Dh06hFdffRW//vor2rRpU95T6v3338fMmTOxcuVKPP3009i7d+8172HFihXYtWsXli9fjnXr1qF58+b4z3/+g5EjR+Luu+/GsGHDrilc5ebm4qWXXsK8efOwcuVK1KtXr/y5nTt3IjAwEMuWLcOmTZvQtm1bLFq0CLGxsejevTvWrl0LAPjzzz8RHBzMwhURERHJ4vDhw0hJSUGHDh2ueryi67YrvfXWWwgODsa6deuwYsUKJCUl4dtvv8VLL72Etm3bYsaMGdcUrrZu3YrNmzdj9erVWLJkCQwGQ/lzy5Ytw1133YWlS5di8+bNSEtLQ0JCAoYMGYKUlBScO3cOAPDzzz9j9OjRLFwR1SLseUVELtWxY8fyv8L99ttvOHbsGMaOHQsAEEURJpMJAJCQkIBjx45h+fLlAACz2XxVO3fccQcAIC4uDi1atEBUVBQAoH79+uW9l7744gvs2LEDycnJOH36NIxGY/nre/bsicaNGwMAJkyYUN5F/c4778S///1v9OnTBz179sTDDz98zXvYuXMnxowZA19fXwDAfffdhy+++AJWq/WG7/vgwYNo0aIFmjVrBgCYOHEiPvzwQwDAkCFD0KBBAyxcuBCXLl3Cvn370KlTJwDAPffcg9mzZ+Oee+7B0qVLMWnSpMptaCIiIqIaMpvN5ddIDocDISEhmD17NmJiYq5a7mbXbZft3LkTixcvhiAI0Ol0uPvuu/H999/jkUceuWGGPXv2YNCgQfD39wcAjB07tny+q+nTp+P333/H119/jeTkZGRnZ8NoNEKn02H8+PFYtmwZXnjhBaxatQo//vhjjbcHESkHi1dE5FKXCz5AWbFq2rRpmDx5MoCyHlVFRUXlz82dOxdNmzYFABQXF0MQhPLXarXa6359WVZWFiZOnIgJEybglltuwZAhQ/Dbb7+VP69Wq6/Kcfn7Z599FuPGjcPu3buxcuVKfPXVV1i5ciVUqr87pkqSdNW6RFGE3W6v8H0LgnDV667sRv/TTz9h2bJluOeeezBixAgEBwcjLS0NANCjRw+YTCbs2bMHBw4cwKxZsypcDxEREZGz/HPOqxu52XXblcv98/uqXkNdeQ333HPPweFwYOjQoejbty8yMzPLl504cSLGjx+PW2+9Fc2bN7/hTXSIyDNx2CARuU2vXr2wfPny8u7fc+fOxYwZM8qfW7BgASRJgtVqxeOPP16lv5gdP34coaGh+Ne//oXevXuXF64cDgeAsiF4er0eALBkyRL069cPdrsd/fv3h9FoxKRJkzBz5kycP3/+mouqXr16YeXKleU9uRYuXIiuXbtW2BW9S5cuOHfuHE6fPg2g7I46l+3evRujR4/G+PHj0bhxY2zfvr08pyAImDx5Ml5++WUMHz4cXl5eld4GRERERO5Q2eu2Xr16YdGiReXLLVu2DD169Kiw7d69e2Pjxo0oLi6GKIpXFdN2796NJ554AsOGDYMgCEhMTCy/hoqNjUXHjh3xzjvvsOc6US3EnldE5Dbjx4+HXq/HhAkTIAgCYmJi8N577wEAXn75Zbz99tsYMWIEbDYbevTogWnTplW67Z49e2L58uUYMmQIfHx80L59e4SGhuLSpUsAyiYcnT59OnJyctCsWTO88cYb0Gg0eOmll/D8889Do9FAEAS888471xSlxo0bh8zMTIwfPx6iKKJhw4aYM2dOhXlCQ0MxZ84cPP/889BqtVdNAv/QQw/h1VdfxcqVK6FWq9GmTRucOXOm/PnRo0dj1qxZmDhxYqXfPxEREZG7VPa67ZVXXsFbb71Vvlzv3r3x2GOPVdh2nz59kJSUhLFjxyIwMBAtW7ZEQUEBgLIe80888QSCgoLg4+ODrl27IiUlpfy1Y8aMwZtvvok+ffo49w0TkewE6Z/jYYiIapmVK1eW3x3HE6xfvx6rVq3CN998I3cUIiIiIo8giiLeeOMNxMbGVjinFhF5Jva8IiJSkClTpiA3Nxfz5s2TOwoRERGRRzAYDOjXrx/at29fPiUFEdUu7HlFRERERERERESKxQnbiYiIiIiIiIhIsVi8IiIiIiIiIiIixWLxqopEu1XuCEQez2HlzxERERERERFVDue8qoYLb4+VOwKRR2vy8gr8Poo/R0RUPT3XrJA7AhERERG5EXteERERERERERGRYrF4RUREREREREREisXiFRERERERERERKRaLV0REREREREREpFgsXhERERERERERkWKxeEVERERERERERIrF4hURERERERERESkWi1dERERERERERKRYLF4REREREREREZFisXhFRERERERERESKxeIVEREREREREREpFotXRERERERERESkWCxeERERERER0TWOHDmCKVOmYMSIERg+fDimTZuGs2fPVviao0eP4tVXX3VTQiKqKzRyByAiIiIiIiJlsVqtePTRR/Htt9+iTZs2AIA1a9bg4YcfxrZt26BWq6/7unPnzkGv17szKhHVASxeERERERER0VVMJhNKSkpgNBrLHxs5ciT8/f3hcDjw7rvvIjExEaWlpZAkCW+99RZiY2PxySefoKSkBC+++CLeffddGd8BEdUmLF4RERERERHRVYKCgjB9+nRMmzYN4eHh6Ny5M7p164Y777wTJ06cQHZ2NpYuXQqVSoWvvvoKX3/9Nb744gs89dRT2LRpEwtXRORULF4RERERERHRNR588EGMHz8e+/fvx/79+/H111/j66+/xvLly/HMM89gyZIlSE1Nxd69e+Hn5yd3XCKqxThhOxEREREREV3l4MGD+Oabb+Dv749+/fphxowZWL9+PVQqFbZu3YpHH30UADBgwABMmjRJ5rREVNuxeEVERERERERXCQ0Nxeeff44DBw6UP5aTkwOTyYT169ejX79+mDx5Mtq1a4etW7fC4XAAANRqNex2u1yxiaiW4rBBIiIiIiIiukrjxo3x6aef4qOPPkJWVha8vLwQEBCAN954A/Xq1cPzzz+PESNGQK1Wo0uXLti8eTNEUUSnTp3w8ccf44knnsCnn34q99sgolpCkCRJkjuEp7nw9li5IxB5tCYvr8Dvo/hzRETV03PNCrkjEBEREZEbcdggEREREREREREpFotXRERERERERESkWCxeERERERERERGRYrF4RUREREREREREisXiFRERERERERERKRaLV0REREREREREpFgsXhERERERERERkWJp5A5AREREREREnkuSREg2GyTRDgAQIAAqARDUEFQqQKUGIAGiCEhS2feCAIgOSJJY/rgEqex5AIJKDUGrgyCwvwURsXhFREREREREFZAkEZLFDAiAoNECEuAwlcBekgd7YQ5sBZmwF+XAUZIPh9kAyWqGaDFBtJog2SyQHHZAEq9uVFBB0Gj/+qeDoNZC0Oqg0uig8g2EJiAUav9QaEOioAmKhDogFGrfQKh0PpDsVkiiAyqtFwQ1f6Ulqgv4k05EREREREQAAPGvYpNK6wXRYoQ1Nw3mtNOwZl2ENTcNjuJciBZjzVckiWWFLZulaq8TVNAERUAX0QC6yIbwim0OXWRDaAJCIdltACQIOm/22CKqZVi8IiIiIiIiqoMkSYJoMUGl0cJuKIA59TQsGWdg1V+CNecSRHOp3BGvJYmwF+phL9TDePbA34+rNNCGxkAXGQev6CbwadoJurBYSDZb2fBD9tAi8mj8CSYiIiIiIqoDJEmCZDVBUGvhMBbBeOEITOcPw5RyEqKxWO54NSPaYctNhS03FaUnfwe2L4Sg0cGrXgv4NGoH32adoQtvANFug4rFLCKPw59YIiIiIiKiWkpy2CE5bJDsNhjPHYLx/CGYL52Ao7RQ7mguJ9mtMF86DvOl4yjYsRiCWguv2ObwbtQO/m16QhMYAUCCSusld1QiugkWr4iIiIiIiGqRywUr0WqB4fhOGE7uhjXzvNyxZCc5bDCnnoQ59SQKdy2FJjACvi27IaB9X2jD6gGiCJXOW+6YRHQdLF4RERERERF5OMlhg+RwQLQYYTi2A4aTv8Oqvyh3LEWzF+egeN8vKN73C9R+QfBtcSsC2veDV3STsrsZspBFpBgsXhEREREREXmoy3f+Kz6yDYajv8GafUnmRJ7JUVqEksNbUHJ4C1Te/vBvdzuCbh0BtW8ABI0XBBXvXkgkJxaviIiIiIiIPIgkOiA57LDlZaBwz2qUJv0JOOxyx6o1RLMBxft/RfH+X+FVLx5Btw6Hb4suHFZIJCMWr4iIiIiIiDyAaDUBggqG47tQtP8X2HJS5Y5U61nSk5C9Kgkqbz/4t+uLoG4joPbxh6D1giCwNxaRu7B4RUREREREpGCixQSH2YDC31fAcHwXJJtZ7kh1jmguRfH+9Sjevx7eDVojpM/d8IppBkGj5ZBCIjdg8YqIiIiIiEiBRKsJDmMx8rctROnpPwFIckciAObUk8j88VXoopsgtO9keMe1hqDWQFCp5Y5GVGuxeEVERERERKQgotUEh6EQedsXwpi0DyxaKZM16wKylrwFbUQDhPaZBJ8mHVnEInIRFq+IiIiIiIgUQLSYYDfkI3/7QhjP7Jc7DlWSLScV+uXvQxMSg9DbJ8I3vhsElRqCmkUsImdh8YqIiIiIiEhGotUM0WxA7savYTx7QO44VE32gkxkr/kYmpAYhN8xFd4NWvHuhEROwuIVERERERGRDCS7DZLoQMHOZSjavx4Q7XJHIiewF2Qia8lb8G7QGuHDHoUmMJxFLKIaYvGKiIiIiIjIjSRJgmS3wpi0D3lbv4OjtEjuSOQC5tSTSPvyGfi364OwwQ9BUGuh0urkjkXkkVi8IiIiIiIichPRaoa9UI+cXz6FJfO83HHI5SQYjiWg9Mw+hPadjIAO/SGotRBUKrmDEXkUFq+IiIiIiIhcTLLbINqtyNs0H4bjO8E7CNYtksWIvE3foPjgJkSN+T9ogiI4lJCoCljuJSIiIiIiciHRaobx/GGkfvYEDMd3gIWrusuWm4q0r59D4Z7VEG0WSJIodyQij8CeV0RERERERC5wubdVzi+fwpi0V+44pBSSiMLdP6M0aS+ixj4PTUAYe2ER3QR7XhERERERETmZaDXDdOkEUj//NwtXdF22nBSkffUsivauYy8soptgzysiIiIiIiInkUQHJLsNeZu/RUniNrnjkNKJDhTsXILSpD8RNeZ5qANCodJ6yZ2KSHHY84qIiIiIiMgJRJsFtvxMpH39HAtXVCVWfTLSvnoWpaf+gGg1yx2HSHFYvCIiIiIiIqoh0WqG8cw+pH/zPOyFernjkAeSHDbkrPsfcjfP/2sYISf2J7qMwwaJiIiIiIhqQLRZkLftB5Qc2iR3FKoFDInbYc26iOi7X4bK2x8qjVbuSESyY88rIiIiIiKiapAcdjhMJchc9BoLV+RUVv1FpH35NCzpSRxGSAQWr4iIiIiIiKpMtJphzb6EtC+fgSX9jNxxqBYSzaXI/PG18rsREtVlHDZIREQutUifgTNGIwAgw2JBuE4LnVD2t5NUixlzm7VEgIanIyIi8hyi1QzDiV3I3fg1IDrkjkO1moSCnUtgyTyHyNHP8U6EVGfxtwUiInKpe6Jiy7+efi4Jj8Q0QGMfHwDAQ6ePyxWLiIioWkSbGYW7l6Nwzyq5o1AdYjx7AJmLXkfMpFcg6LwhCBxERXULi1dERCSr1bnZuGAywuBwYEhYOAaEhGF3YQEOlBTjmQYNAeCq7+dnpKFUdCDbakUH/wCMj4yW+R0QEVFdIdosyN34DQxHf5M7CtVBlvQkpH/3H8ROeROCtx9Uav46T3UHy7VERCSrCK0OMxs3w7/rx2FpdhbslbgttEUU8VaT5ixcERGR24g2M7JXfsDCFcnKlpeOtPnPw1GcC9FulTsOkduweEVERLK6LSgIABDn5Q27JMFciblDmvv4ujoWERERAECSRIgWIzIXvQHjuYNyxyGCoyQf6fOnw5qdwoncqc5g8YqIiGSlhgAAEISy/yUJKPvy7x5YdlzdG8tbpXZXPCIiqsMk0QHRVIr071+CJT1J7jhE5USLEZk/vALTpeMQrWa54xC5HItXRESkOAFqDdItFthEEQ5JQmJJidyRiIiojpFEBxzGYqTPnw5bTqrccYiuITls0C97D6aUE+yBRbUei1dERKQ4bfz80cLXDy9dOIv3Ll1AfW/eFpqIiNxHEkWIZiMyFrwEe3GO3HGIbkwSof/5fZjTkljAolpNkKRKzIxLV7nw9li5IxB5tCYvr8Dvo/hzRETV03PNCrkjEFEtJkkSRIsRGQtehC0vXe44RJWj1iBm8kx4xTSFSss/+lHtw55XREREREREf5GsJmQu/C8LV+RZHHZkLX4T1uxLEG28CyHVPhq5AxARUd2VZjZjkT4DJlGEIAD3R9dDnJc3lufocdRQAkEAorReuC86FoEanrKIiMi1RKsZmT+9Dmv2JbmjEFWZZLcic9HriL3vTWjD60Ol0ckdichp2POKiIhkYRFFfJCajKFhEXitcTOMDIvEVxmp2F1UgEtmE2Y2aoo3GzdHpE6HpdlZcsclIqJaTrRZkLXkbVgyzskdhajaJJsZGQtfhb0gC5LDJnccIqdh8YqIiGRxotSACJ0O7f0DAAAd/QPweGwcYr28MSEyGlpV2SmqkbcP8tj9nYiIXEi0WaBf/j7MqSfljkJUY5LVhIwfZ8JhKoUkiXLHIXIKFq+IiEgWeqsFQRoNvs1Mw+vJ5zAnNRkiJDTz8UVDbx8AQKnDgXW52egaGCRzWiIiqq1Eqxn52xfCdOGI3FGInEY0FiNz0WuQeAdCqiVYvCIiIlnYJQnHDCXoExyKmY2aYWBIGD5KvQSbWPYXwmyrBe+lXEBzX1/0Dw6VOS0REdVGos0Mw8nfUXxgg9xRiJzOlpsK/Yo5EFnAolqAxSsiIpJFsEaLaJ0Xmvr4AgA6BQRChIQcmxWnSg14+9IF9AwMwX3R9SAIgsxpiYiotpHsNlizU5C74Uu5oxC5jOnCEeT/9hNEq1nuKEQ1wls3ERGRLNr7+2NZdhaSzSY08vZBkrEUAgCjQ8T/0lPwWGwDtPtrPiwiIiJnkiQRDlMJspa+DYgOueN4hLWn87A+KR+CAMT46/B093oI9tFg4tJTCPfVli83tk04+jcJvuq1y47lYEdyUfn3RWY7jHYRKye1xukcI+buSQcAPNg5GrfWLzv3Lz6ajRAfDYY0Z+/rmire/wt0kXHwb90TKp233HGIqoXFKyIikkWQRot/14/DwqwMWEURGkHAE/XisDpXDwBYnqPH8pyyr8O1WjxZv6GccYmIqBaRbBZkLnoNoskgdxSPcDbPhBUncvHZiGbw06nx9YFM/HBEjzGtwxGgU+PTEc0qfP2EdhGY0C4CAGCwOvDM+vN4ukc9AMDPJ3LxVPd6iPLX4rXtl3Br/QBkG6w4nGnArMGNXf7e6orcDV9CF14PuuimUGm0N38BkcKweEVERLKJ9/XDfxs1veqx5+N4oUpERK4j2izQr/wAtrx0uaN4jOZhPpg/ugU0KgFWh4g8ox3R/lqczDFCpRLwwqaLKLbY0athEO5uFwG16sbD/b85kIUu9QLQtV5ZDyutSoDFLsJsF6H563XfHMzC1FuiOW2AM4kOZC15G/Uf+wQq/xC50xBVGee8IiIiIiKiOkG0mlG0dx1M5w/LHcXjaFQC/kgpxpTlSTiuL8WgZiFwiBI6xfjhzYENMXtIExzKMGDt6bwbtnGp0Iw9qcWY0jGy/LFJ7SPwY2I23t+Vhmm3xOBwhgE+WhXiw33d8bbqFNFihP7nWZzAnTwSe14REREREVGtJzkcsOVnoGDnUrmjeKwecYHoEReIDWfy8crWZMwf3QKqv3pH6dTA6NZhWHM6D6Nbh1/39atP5WFEfCj8dOryxxoGe2POkCYAALsoYcamC3i1b0NsOpuPP1JLEO6rwaNdY6BTs9+FM1gyzqJw9woE9xzD+a/Io/ATgIiIiIiIaj3JYYX+5/cBSZQ7isfJKLbguL60/PvBzUKQXWrDtguFuFjw913sJACaGwz1c4gSfr9UjEHNbjxkbfWpPPRpFAwvjYCVJ/Mws18cwn21+O1CobPeCgEo/GMlrNnJkBx2uaMQVRqLV0REREREVKuJVjNy1n8Be3GO3FE8Ur7Jjvd2paLIXFbs+O1iIRoGeyOl0IKFR/RwiBIsdhHrTufh9kZB120judAMfy81ovx111+H0YY9KcUYHh8KUSorhAkAVIIAs11y0TurqyToV8zm8EHyKBw2SEREREREtZZos8J49gBKT+6WO4rHahvlh7vbReCFzRehFgSE+mrwat84BPto8NneDDy+7hwcooTeDQMxpHlZz6r1Sfk4m2fCM3/dVTCj2Ioovxvf5W7+oSzc3ykSapUAP50aPRoE4PF15xDsrcHLfeLc8j7rEoehENmrP0LU2OlQab3kjkN0U4IkSSxjV9GFt8fKHYHIozV5eQV+H8WfIyKqnp5rVsgdgYg8iL0kH6lfPAnJar75wuQ0RpsDc/9Ix4ssPCla2B1TEdC+P+e/IsXjsEEiIiIiIqqVRJsF+uWzWLiSwYV8M+7tGCV3DLqJvC3fw2EsljsG0U2xeEVERERERLWOaLOg+OAmWDLOyR2lTmob5YcGQRyOpniiHdlr5nL+K1I8Fq+IiIiIiKjWEa0mFOxYLHcMIsWzpJ1G6ek9EG1WuaMQ3RCLV0REREREVKuIVjNyfvkUkp2/jBNVRt7mbyE5bHLHILohFq+IiIiIiKjWEB12mFNPwXTukNxRiDyGaC5F7oavIHJ+OFIoFq+IiIiIiKj2cNiRs/5zuVMQeZzSk7thyboISXTIHYXoGixeERERERFRrSBazSjYuQyOkjy5oxB5pJx18yA57HLHILoGi1dERERERFQrOAwFKNq3Tu4YRB7LXqhH0Z7VHD5IisPiFREREREReTzRai4bLiiJckch8miFe1Zz8nZSHBaviIiIiIjIo0mSCIs+GeaUE3JHIfJ4kt2KvK0/QLSa5I5CVI7FKyIiIiIi8miS3Ya8Ld/KHYOo1ig9uRuSyF6MpBwauQMQERERERFVlyQ6YE45CWvmebmjEHk+QQX/dn0R2n8KzDYRKsEOHy+WDUh+PAqJiIiIiMhjSQ478rYukDsGkcfzbXErwgY9CLvGF1/8eg6b/ryE/z3fDw1jAuWORsTiFREREREReSbJYYfx7EHYctPkjkLksbzjWiPsjmkQAiKwbMclLNmyp/y5r9Ycw38f7AZv9r4imfEIJCIiIiIijySJIvK3L5Q7BpFH0kU1Rtjgh6CNaoxN+zPx1Zot+Oc0V0fP5iIt24BmDYJlyUh0GYtXRERERETkcSSHHYaTu2EvypY7CpFH0YREI2zA/fBp3AF/nMzB3M+3wmy98eTsP248hRfu68q5r0hWPPqIiIiIiMjjSKKIwt3L5Y5B5DHU/sEI6TMZ/m164fjFQsx+ezsKDdabvu7g6WyUGK0sXpGsePQREREREZFHkUQR5kvHYS/Uyx2FSPFUXr4I7jkOgV2GIDnTgOkf7EJGTmmV2vhpUxIeHd2OBSySDY88IiIiIiLyKJLdioJdy+SOQaRogkaHwK7DENJzHLKLzHjzsz9xJqWwWm3tOJSGaSPbODcgURWweEVERERERJ5Fq0Pw2P+Dac9aFB/4Ve40RMoiqBDQoT9C+92LEouENxcewYFTNZsbzu4QsTLhHCYMbAFvHcsI5H486oiIiIiIyGOYbGYsOLwMGrUWY3qPQXSfibCf2oPcrQsAq1nueESy8mt5G0IHPgibyhv/W3sWW/enOK3tX3+/iIkDWzitPaKqYPGKiIiIiIg8hkNyYGfyXjgkEVvP7UL76FYY23ooGj/7LWzpZ1Gw6RvYclLljknkVt6N2iF88DTAPxSLtyfj5+1nnb6OUrMdOw6lYUDXOKjVKqe3T1QRFq+IiIiIiMgjWB02bDq7Aw5JBABIkJCYdRKJWSdRLzAao1oORo+H3oetOBeGhMUoPfWHzImJXEsX3QRhd0yDNiIO6/dm4Nt1WyCKrlvf+j+ScXun+ixekduxeEVERERERB5jy/ld1308vTgLn+37AT8cWYFBTXtjxJ2PIWDINFgOb0PBzqWAaHdzUiLX0YbGIHTgg/Bu2Ba7j2fjk3lbYbW7sGr1lwvpRSgoMSPGy9/l6yK6EotXRERERETkES4VpiHfVFjhMgZrKVad2oi1pzfj1vqdMLbNUMTeOhS284nI2zQfoiHfPWGJXEAdEIrQvvfAr1V3JJ4rwJy3tqO41OrWDGt3XcD9w1rD24vlBHIfHm1ERERERKR4JpsZm87tqPTyDknEntSD2JN6EM3DGuOuVnegwxOfwpabhqItC2BOOeHCtETOpfL2R3CvcQjsPBgX0kvw3vs7oc83ypIl4WAaHhzeRpZ1U93F4hURERERESmeWqXC3rQj1Xrt2byLmL37C4T5hGBYi34YePdLEM0GmP5ch+J9vzg3KJETCRodAruNQEiP0cjKN+O1eXtwPr1I1kwGkw2Hz+Tg1tZREARB1ixUd7B4RUREREREiiZKIg5nnIDFbqlRO3mmAixMXImlx9ehT6PbMLrHKETfPgH2U38if8sCiFZ5erIQXUOlRkDHgQjtOxlFJgdeX3AEh5Ky5U5V7pfdF9CuaRh8vbVyR6E6gsUrIiIiIiJSNLPdgs3ndzqtPavDhi3nd2HL+V1oH9UKY1sPRZNnv4Et4xwKNn4DW06K09ZFVDUC/Fp1R9igB2GBFnNXncFvB1PlDnWNo2dzIElyp6C6hMUrIiIiIiJSNFGScDw7ySVtH9WfwlH9KcQGRGFUy8Ho8dAs2ItzYdi5FKUndrtknUTX49O4A8LumArJJxgLtyVjZcI5uSPdkCgB+05koU/n+lCpOHSQXI/FKyIiIiIiUixRFLE39TAkF3fzyCjR4/P9C/FD4goMatIbw4c+jIDBD8FyZDsKdiwBRLtL1091l1dsc4QNngpNWH2s/TMN3607IHekStlxOA23to2GH4cOkhuweEUe6VSOEQsO6VFssUMCEOGrxbQu0WgY7H3D1yTlGrH5XAGevK2e+4ISERERUY2Y7Rb8mXbQbesrtRqx+vQmrEvaglvrd8SY1kMR23UobBeOIm/TNxBL8tyWhWo3bVg9hA16EF4NWmFHoh7zPtkKu12UO1alJZ7NhUatqvbr4+Pj0aJFC6hUf7fRtm1bvP3229csO2rUKCxcuBCBgYHVXh95NhavyONYHSJe234Jbw9shGZhPgCA7RcK8d+tl/DdmBZQ36DbakqhBbml/IsZERERkSfRqDU4mX3W7et1SCL2pB7CntRDaBraEKNbDUHHf/0Ptrx0FG39Aebko27PRLWDOiAMof2nwC/+Vhw+m485r2+Dwex5v6fYHSISz+Tg1jbR1W7j+++/R2ho6E2XW7NmTbXXQbUDi1fkcSx2CQarA6Yr/irRr3EQfLUqiJKEr/dl4XSuEUZb2fNPd49FpJ8WC49ko9TmwIe/p+G5nvXlik9EREREVXA65xxsMg/ZO59/CXN+/xIhPkEY1rw/Bk94AaK5FKa9v6B471pZs5HnUPn4I6T3RAR0HICzacWY9V4CcgrNcseqkd8OpaKtC+462LZtWwwYMACnT5/GnDlzMG7cOOzZs6dShS6qnVi8Io8T4KXG1Fui8d+tyQjx0aB1pC/aR/mjT+MgnMs3I89kw4dDm0AlCFh2LAfLjufi9f4NMaVjJHZfKmbhioiIiMhDmG1m/J6inPl/CkxFWHR0FX4+8Qt6N+yGMd2HI6b3ONhP70Pe1u8gmkvljkgKJGi9EXTbSATfNgoZuUa8MvcPJGcWyx3LKQ6eyoZWU/2hg/fff/9Vwwa//fZbhIWFwWazoV+/fpg7d64zYlItwOIVeaQxrcMxpHkIjulLcVxvxM8ncvDziRzMHdYU93eMwq9n8pFZYsUxfSl8NGq54xIRERFRNahVahzOPC53jGtYHTZsu7Ab2y7sRruolhjTeiiaPf01bBkXULj5G1j1yXJHJCVQaRDYeRBC+kxCYakd/51/EEfP5cqdyqlMFjsuZhSjRVxItV5f0bDBLl261CQa1TIsXpHHOZFdilPZRoxrG4Fu9QPRrX4gHugUhcfXncMfqcVYfDQHY1qHoXuDQDQI8sL2C4VyRyYiIiKiasgpzUehWdk9VI7pT+OY/jRiAqIwMn4gej3wLuwleTDs/Bmlx3fIHY9kIcC/TS+EDnwAZlGND5efws7D6XKHcpk/j2eicWwgtE7uNODr6+vU9sizsXhFHifIW4PFx3LQMsIXbaP8AAD5JhvMNhE7LxahW/0ADI8Pg9Uh4ufjuRD/uquyWiXALrr2FstERERE5ByiKOJAhudMip5ZoseXBxbhx8RVGNC0J0be8SD8Bz8AW+JvyP/tJ0DmebvIPXyadkbY4KmQvALw3ZYLWLvrgtyRXO7ImRyM69/c6cUroiuxeEUep36gF17tF4fvD+uRa7RBq1bBT6vCU91jEeWvw6xdqXh87VmoBAHtovywO6UIoiShZYQPvj+sxxu/XcKr/RrK/TaIiIiIqAImuxknss/IHaPKSm1GrD29Bb8kbUPXeh0wtvVQxN5yB2wXj6Ng8zewF+XIHZFcwKtePMLumAp1SAzW/J6G73/dK3cktzmfVgi1qvrzXhFVhiBJEruiVNGFt8fKHYHIozV5eQV+H8WfIyKqnp5rVsgdgYjcwOaw45E1L6DUZpQ7So01CYnDXa2GoHNMG9jyM1C89QeYLibKHYucQBvRAGGDHoJXvRbYfjgLn608BvsVd0WvK957ohfaNAmTOwbVYux5RUREREREilNoLq4VhSsAuFCQgg//+Aoh3kEY2qIf7hg/A4EWI8z71qNoz2q541E1aAIjEDpgCnybd8GBpFx88Po2GM11d2jogVNZaBEXzKGD5DIsXpFH+z2lGD8e0UMlCPDXqfF0j1h8e1CPzBJr+TJZBivaRfnhtf4cKkhERETkKU5kJ8kdwekKzEX46ehq/HxiPXrH3Yoxtw5FdM8xsCftR/6WbyGaS+WOSDeh8g1EyO0TEdC+H5JSijDr3QTkFZnljiW74xfyYLWLLF6Ry7B4RR7LYhcxe3cqPhveDLGBXlh1Mhdf7MvEGwMalS+TlGvEOztS8US3GPmCEhEREVGVmGxmHNOfljuGy9gcNmy/+Du2X/wdbSLjMbb1EDR/+hvYMi+gcPN8WLNq/yTfnkbQeSO4+2gE3TocablGvPTR70jRl8gdSzHOpRbBS8vCFbkOi1fksURJAiSg1FY2ptxkF6FT/z1RoM0h4oPf0/FI1xhE+OnkiklEREREVaQSVDide17uGG5xIjsJJ7KTEO0fgRHxg3D7/W/DbshH6a6fYTiaIHc8UmsQeMsQhPSeiHyDFS99fQAnLuTJnUpx7A4RuYUmRIf5yR2FaikWr8hj+WjV+PdtsXhuwwUEeqkhShI+GNKk/PlN5woQ5qNBz7hAGVMSERERUVWJkoic0rpVIMgy5ODrgz9h0dFVGNCkJ0YOegB+A++H7egO5G//ERDr7nxKshBU8G/bG6ED7ofRLmD20uP4/Wim3KkU7XxaEYtX5DIsXpHHulhgxk9Hc/DlUvlAnwABAABJREFUqGaIDfDCmlN5eGtHKj4d3hSCIGD1yTw81T1W7phEREREVEVZhmy5I8jGaDNhXdJWrD+zHV1i22Nsm6GI7TwI9uQTyN88H/ZCvdwRaz3f5l0QNvghOLR++Hrjefz6R7LckTzCqeQ8dG0dBR2HD5ILsHhFHutghgGtI3wRG+AFABgeH4qvDmSi2OJATqkNDklCuyhW/omIiIg8zYX8VLkjyE6UROxLP4J96UfQOKQB7mp5B2557GPY8jJRvH0hTOcPyx2x1vFu0Aphd0yDKjASK3alYNGmP6vdVnHaQRRc2Fn+vcNmht1chCYDX4bGK6D8cVP+RWSfWAtIIgSVFpFtR8E7uAEc1lJkHPgBDpsJATHtEdZiYPnyhZf2IqbT3dV/oy5yMaMYNrvI4hW5BItX5LGahXpj3ek8FJjsCPHRYE9qMaL8dQjy1mD7hUJ0iPaHIAhyxyQiIiKiKrDYrbhQkCJ3DEW5WJCKj/Z8gyDvQAxt3hdDxv4fAi0mmPdvQNEfK+WO5/F0kQ0ROvgheEU3w5ZDmfhy5RbYxZq1GVj/FgTWvwUAIIkOpP7xOUKb9buqcAUAmYeXILrDePiGN0NJ5nFkHVmGRn3/D8Xph+EX2RIhTfvi0o4PEdy4F1QaHXJPb0BM53trFs5FLmYUsXBFLsPiFXmsjjH+GNcmHC9svgiNSkCATo2Z/eIAABklVkT5a2VOSERERERVZRftSC3KkDuGIhWZi7Hk2FqsOPErejbsirFdhiKmx2jYzuxH/uZvIZoNckf0KJrgKIQOuA++TTph76kcfPjFNpitzp9bLP98AtRe/ghueNu1T0oiHDZT2ZcOCwR12a/ogkoDh7UUkERIkgOCoEJh8h74RbWGxluZc/qWGG0wW+zQanizLHI+Fq/Io41oGYYRLcOuefyJbpzrioiIiMgT6dQ6pBazeFURm2hHwsU9SLi4B20iW2BMqyGIf/pr2LIuomDzfFgz68adGqtL7ReEkD6T4N/2dpy8VIj33/kNBSUWl6zLYS1FwYWdaNj76es+H9VhPDIOfI+cE2vhsJlQ/7aHAQCB9Toj68gSpOyeh5Amt0MSbSjJOIIG3R9zSU5nSdGXoE2Ta38/I6opFq+IiIiIiEgxrA4bSq1GuWN4jBPZZ3Ai+wyi/MIxouUg9LnvLdgNBSjdvRyGxO1yx1MUwcsXwT3GIKjLMKRkG/DCh7uRlu3a3mqFl/bCP6o1tL6h1zxnt5RAf3QFGnR/DN7BDWDIOo6MAwvRuN8MqDQ6xHa5r3zZrMTlCGsxCOaidOSf3QpBrUNEq2HXbVdOqSxekYuo5A5ARERERER0mb40R+4IHklfmotvDi7GI2tfwPKLu6AbMAXRzy1A6KCHgDo+jEtQaxHUbSTinvwS1ub98J8v9+LJj1xfuAKAkoxEBDboct3nTHkXofUJhndwAwCAf3RbCCo1rIar7yhpLkyFaDPBL6IFck6uQ2S7MQhp3Au5SZtdnr+q0nMMsNkdcsegWog9r4iIiIiISDGyDblyR/BoJpsZ689sw69nt6NLbHuMbT0UsZ2+gz3lFPI3fQ17gf7mjdQWggr+7foidMAUlFqBd386hr3Hs9y2eofVCJsxFz4hja77vFdgDCwlelgNOdD5R8BUkALJYYXWL6J8GUmSkHNyPaI7Tij7XrRDENSAIEByWN3xNqoku8AIq02EVsOJ28m5WLwiIrdzWK3ouWaF3DGIiIhIYSRJQqaBPa+cQZIk7E9PxP70RDQMro/Rre5Al0c/hi1fj+LtC2E6d1DuiC7lG38rwgY9BLvaB1+sP4dNf15yewabMQ8ar0AIqr8LOebCVOiPLkfD25+Fzj8CUe3GIOPgQgCASl02VFCt9S5fvjh1H3zDm5YPDwxtNgBpf34FQaVGVPux7n1DlZCdb5I7AtVSLF4RkdupdTpMWPq43DGIyEMtm/i53BGIyEWsDhvyjPlyx6h1LhWm4eM98xHkFYAhzfti6OhnEWgzw3JgIwp3rwQgyh3Rabzj2iDsjmkQAsKxbMclLNlyRr4swQ3QuP8L1zym8Q4q/z4gtj0CYtvfsI2guG5XfR8Q0xYBMW2dG9SJsguM0Go4OxE5H4tXRERERESkCHbRgXxjodwxaq0iSwmWHl+HFSc3oGdcF4zpPBQx3UfBfuYg8rZ8C9FYLHfEatNFN0bYoKnQRjXCpv2Z+GrNFogKrMnZTEUIathd7hguU1xqhSAIcsegWojFKyIiIiIiUgQBQL6pUO4YtZ5dtGNH8p/YkfwnWkU0x5jWQ9DqyS9h1SejcPO3sGaclTtipWlCohE28AH4NGqPP07mYO7nW2G2KrBq9RetTxC0PkE3X9CDFRksCA/2kTsG1TIsXhERERERkSJoVGrksXjlVqdyzuLtHWcR6ReO4fED0HfK63CUFsG4eyVKjmyRO94Nqf2DEdL3Hvi37onjFwsw++3tKDQobwLzuqi41MriFTkdi1dERERERKQIapUGxeYSuWPUSdmlufj20FIsProG/Zr0wKj+kxA94B7Yju9C3rYfAbtF7ogAAJWXL4J7jkNglyFIzjRg+ge7kJFTKncsuoLByCIiOR+LV0REREREpAg20QYJktwx6jST3Yxfz2zHhrO/oXNMO4xtPRQN/u872FJOIX/jN7AXZMqSS9DoENj1ToT0HIvsIjPe/OxPnEkplCULVayExStyARaviIiIiIhIEawOm9wR6C+SJOFgxlEczDiKuKB6uKvVHbj1kQ9hK9SjePsimM7ud08QQYWADgMQ2v8elJglvLnwCA6cynbPuqlaijh8k1yAxSsiIiIiIlIEq4O/9CpRSlE6PvnzWwR6BeCOZrdj2F1PIdBmgeXgZhTuWg7ANROk+7XsjtBBD8ImeOF/a85i6/4Ul6yHnKuo1AJJknjXQXIqFq+IiIiIiEgRLHYWr5Ss2FKCn0+sx6pTm9C9QWeM6zgMMbeNhP3cIeRtmg/RWOSU9fg0ao+wO6YCfiH4aXsylm8/55R2yT1KTTbYHSK0GrXcUagWYfGKiIiIiIgUwaKQScGpYnbRjl2X9mHXpX1oGd4MY1oPQesnv4At+xIKt3wHS1pStdrVxTRF2OCp0EbEYf3eDHy7bitE13TqIhcymOywOyRoWW0gJ+LhREREREREimBm8crjnM49h3d2/g8RvqEYHj8Q/e6ZCUdpEYx/rEbJoU2VakMbGovQgQ/Au2Fb7D6mxyfztsJqZ9XKU5ktdogSb7xAzsXiFRERERERKYLJZpY7AlVTjjEf3x1ehsXH1qBv4+4Y3XcCovtNhu3EbuRt/QG4TmFSHRCK0H73wK9ldySeK8CcN7ejmHeq83iiJIE3DSVnY/GKiIiIiIgUwSba5Y5ANWS2W7DxbAI2nd2BTjFtMLb1MMT933ewpSYhf9M3sOelQ+Xtj+De4xHYaRAupJfgvfd3Qp9vlDs6OYkosnJFzsfiFRERERERKYJKUMkdgZxEgoRDmcdxKPM4GgTF4q6Wd6DbtDkQTQbofAIgQUCy3oBSq4Qnx3eUOy45UYCfDir+KJOTsXhFRERERESKoFb9P3v3Hd9U9f9x/JWb1d1SWkbZe+8loGxUEJApCCJDQRFcKMPNVMCvOEBUEBeKgDJU5OdARRFQARFEBAHZlF3obtMkvz8qwdrSMtomLe/n4+HD3pt7zvncdJB8cs7naHeywujQuaPM+vlt3vktiNdvnMDxr78lLS4OKxDu7eAk1/lHRWENqwd2q7dDkUJEySsREREREfEJZpOSV4VZXEo8JpPBkWXLSTlx0tvhSB4Jv64pYQ3qeTsMKWQ0mU9ERERERHyCRWuNCj+TCXeaapsVZibDDCaTt8OQQkb/OoiIiIiIiE8wtGyw0DMZBi6Hw9thSB4yWfR7LLlPySsREREREfEJWjZY+JkMQzOvCjmT2YxJM68klyl5JSIiIiIiPsGimVeFXvrMKyWvCjOTfo8lDyh5JSIiIiIiPiHA6uftECQPGRiaeXUNMAf4YzIrgSW5S8krERERERHxCf5Wf2+HIHnIbrHhdjq9HYbkMXtkJIbN5u0wpJBR8kpERERERHyCn8Xu7RAkD/lZ7UpeXQP8ihfzdghSCCl5JSIiIiIiPsFmtqrQcyHmZ/FT8uoaYIuI8HYIUggpeSUiIiIiIj4hzeUkyBbo7TAkj/hb7LiUvCr0bGFh3g5BCiElr0RERERExCekudII8wvxdhiSR+wWO+40Ja8KO0twkLdDkEJIySsREREREfEJbrebEHuwt8OQPOJntuF2aqfBwsyw2TAsFm+HIYWQklciIiIiIuITDJNBREARb4checRuteNKU/KqMLOFF8GVmurtMKQQUvJKRERERER8gp/FTolg7VRWWNnNNtxKXhVqtvBw3C6Xt8OQQkjJKxERERER8Qkmk4lyoaW8HYbkEbvZruRVIWcLLwLaMVTygJJXIiIiIiLiM6KCi3s7BMkjdosVl0PJq8LMWqQIhsXq7TCkEFLySkREREREfEZ4QJi3Q5A8YjNbcTsc3g5D8pA9MhLDpuSV5D4lr0RERERExGeYTWYCbQHeDkPygM1sw6XkVaEWWL6ct0OQQkrJKxERERER8RkOp4MSQZHeDkPygJJXhV9gxQreDkEKKSWvRERERETEZ5hMJtW9KqRsFouWDRZi1tBQzH5+3g5DCiklr0RERERExGfYLTaqFNXsjcLIamjmVWEWVLkSrtRUb4chhZSSVyIiIiIi4jMMk0H1yMreDkPygM1swZWi5EZhFVSlsmZeSZ5R8kpERERERHxKVHBxTCaTt8OQXGY1LJqZU4iF1K6FyWz2dhhSSCl5JSIiIiIiPsXpchIVpLpXhY3FbFXyqhALqlDe2yFIIabklYiIiIiI+JyK4WW9HYLkMs28Krxs4UUwbDZvhyGFmJJXIiIiIiLiU/wsdqpFVPJ2GJLLrCazkleFVGClSirGL3lKySsREREREfEpJpOJmpFVvB2G5DKryYw7Lc3bYUgeCK5aRcXaJU8peSUiIiIiIj6nRFAkfha7t8OQXGQxmTU7p5AKqVVTxdolTyl5JSIiIiIiPifF6aCGZl8VKhbNvCq0AlWsXfKYklciIiIiIuJz/C12GkbV9nYYkossJkMzrwqhgHJlMRlKLUje0k+YiIiIiIj4HMMwaFiyjrfDkFxkxtDMq0Ko6HXXacmg5Dklr0RERERExCeF+gUT5hfi7TAklxiaeVUoRbS+HsNq9XYYUsgpeSUiIiIiIj7J6XJSp3h1b4chucRsMuFyaOZVYWILD8cvMtLbYcg1QMkrERERERHxSf5WP5qUquftMCSXGCYtGyxswps2we1yeTsMuQZYvB2AiIiIiIjIxdQvUQuzycDp9s03yKd+PsypX45gMoEt3J/S3apjDbIBkHoumd1zN1HtvqZYAm0X7cOZ5GDPW79SpnsNAkqlL5M8t/MU0V/vxbCYKN2tuuf8oU/+JKx2cYIrhef9zeUyA5OWDRYykW1aYfbz83YYcg3QzCsREREREfFZLlzULl7N22FkKfFoLCfWHaTKsEZUG9UMe7g/x779G4Azv0WzZ/6vpMWlZttH7F+n+GvuJlJOJWY4f/y7v6k0uD6lulTjxNoD6eMdicWZ7CyQiSsAk2ZeFSpmf3+CKlfydhhyjVDySkREREREfJafxU6r8td5O4wsBUSFUOPB6zD7WXA5nDjiUrD4W3HEphD75ykq3pHzksdTPx2mbI+aWILtGc6bzAYuhwtXqhOT2cDtdnP0yz1E3VRwkwWGSTOvCpOwhg30/ZR8o2WDIiIiIiLiswyTQZNS9Xx26aDJbHDuz5Mc+mQnJrOJykMrYg2xU/72OpfUvuKd9bM8X/LGyhz4aDuGxUzpbtU482s0wRWLYAvzz8Xo85fJZOBWsqPQiGx9A5aAAG+HIdcIJa9ERERERMSnudzpSwe3HvvT26FkKbRGJKE1Ijm96Qh/v/cb1R9sjskwXVWfQeXDqHpPEwDSkhyc2XyUSkMacPz7/SQejsUeGUDUjZVzI/x8YzJMuLRssFAwmc2E1dNmCpJ/tGxQRERERER8mq8uHUw5nUj8gbOe4/CGUaSeTcaZnLsJmmPf/E2xVuVwnEsh/u8YKgyoizPJQdzeM7k6Tl5Ln3ml5FVhEFKrJm6X09thyDVEySsREREREfFpnqWDhtnboWTgiEvl4Ed/kJaQXpQ9Ztsx/IoFYQmw5toYScficJxNJrR6JC6nC5P5nxldJhMuh+8to8yOyWTClaZlg4VBZKvrMez2nC8UySVaNigiIiIiIj7P7XbTOKouPx/e4u1QPILKh1GsVTn2vr0FDBPWYDvl+2df6+rYN+m7EZZoX/GSxjj6xR5Kd0nfbdG/eBCWQBu7Xv0ZWxF/QqoUsF0HDc28KgwMm42IG67HMPtWMlkKNyWvRERERETE5/lb/eharYNPJa8AIpqWJqJp6Ys+Xm9SuwzHReqX4NTPhzNdV3N0iyzbVxrcIMNx2V41ryBK32AyDNW8KgQibmgJbre3w5BrjJYNioiIiIhIgVA+rDTFgyK9HcZVSTmVSLHry3k7DK8wGdptsDAo1f1WzP4Fd9dLKZiUvBIRERERkQLBZDK4qXJrb4dxVUKqRWANufZqBRmGASYTbqeKfBdkAeXLYS9WzNthyDVIySsRERERESkQrGYL7Sq28LnC7ZIzP7MfblfBKjAvmUV1vQWTVdWHJP8peSUiIiIiIgWGCWhaqr63w5DL5G+xa9ZVAWcOCFChdvEapUxFRERERKTA8Lf6c2v1G9lwaLO3Q5HL4OejyasN587yf2dOYQJshon+xaKo4O/PxH17SHW7sZhMAFwXEkqnohevt/ZrXCxvRh9mTtX0gvrxzjRmHz5IgstJk+BQukWkL7X7KzGB78+eYVhUmTy/t9xW4qaOKtQuXqPklYiIiIiIFChRIcWpFF6OvWcOeDsUuUT+Fj+fS15Fp6Sw5MQxnqlQiTCLlW3xcbx65CBTK1bhhCOVl6vU8CSvsnM8Nb2ff+d1Npw7R52gYDqHR/DUvj10LFIUu2Gw9ORxRpQqeIkrDINSPbpj9vPzdiRyjdKyQRERERERKVBshpV+dbp5Owy5DHaLFXdamrfDyMBqMjG4ZCnCLFYAyvv5cy4tjd2JCfgZBi8f2s9T+3bz4fFoUi9SryvF5WLu0cP0LVYiU9+pLhdOwIkbw2Tiu7NnqB8U7BmvICl6XTNM1oIXtxQeSl6JiIiIiEiBYhgG1SMqUzqkpLdDkUtkt/ressEIm416QcEAuN1uFp2Ipn5wMA63m+oBgdxXqixPl6vEGYeDj08ez7KP944doU1YOGXsGWckNQ8N42hKClP27+WmIhGkulz8FHuWjuEReX5feaFM3z5YAvy9HYZcw5S8EhERERGRAsdimOlTu4u3w5BLZDfbcTl8a+bVeSkuF68dPcSJ1FSGlChFg+AQhkWVwd9sxmoY3BIRyZa42Eztvo05jWEycUNYkUyP2Q2DkaXLMqFCZdoUCWfpyePcGlGMA8lJvHToAHOOHORkamp+3N5VC65WFb8Sxb0dhlzjlLwSEREREZECx2yYaVSyNpGBRb0dilwCu9mG2+l7yavTjlSmHvgbAxNjy1YgwGzmt7hYdiUmeK5xu8GcRe2rdefOsj8piWf27eHFwwdIdbt4Zt8eYhyODNftS0okweWkdmAwi05Ec2eJknQsUpQVp7KezeVrKg6/G8Nu93YYco1T8kpERERERAokwzDoXbOzt8OQS+BnteH6T1LH2+KdaUw/uI9GwSHcW6oMNiP97XFMmoMlJ46R6nLhcrv5KuYUTUJCM7V/qnwlJleswsQKlXm4dDlsJoOJFSpT5F+1odxuN0tOHKNvZHpNrDSXG7PJhMlkItXl+zv3FWncCP9SpTBdQuF6kbyk3QZFRERERKRAshgWWpZrzJLtKzmdFOPtcCQbNrMNt48tG/wu5gynHQ5+jYvl138tCxxTtjwnHQ4m7t+L85/6V92KRgKwJS6WNWfP8HCZ8pc0xtpzMVQPDCLCZgOgS0Qxnj+4H4vJxKASpXL9nnKVYVDxnrsx+2uHQfE+Ja9ERERERKTAMkwGd9bvxYsb3vR2KJINm9mGK823Zl51jShG14hiWT52W7ES3PafHQQB6gYFs/Zc5kRphM3Ga9VqZjrfKiw8w3Gj4BAaBYdcYcT5q1j7tlgLSKxS+GnZoIiIiIiIFFgWw0LDqDqUDyvt7VAkGzazBVeqbyWvrkR0Sgqd/5mFVZgZNhvlBw3UrCvxGUpeiYiIiIhIgWY1W7i7UX9vhyHZsBl23Gm+tWzwSpT286Oyf4C3w8hzUT1uxfhX7S4Rb9OyQRERyTcJh84R/fVenEkOcIM1xE7UzZXxKxbk7dBERKQAM0wGZcOiqF+iFr8d+8Pb4UgWbBYrrtRUb4chl8ASHEzpnt0x+2nWlfgOzbwSEZF84Upzse+DbUTdXIVqI5tRbVQzitQrwd8LtuIuALvtiIiIb/Oz2Lm78e0YJr3F8UVWw+Jzuw1K1soOuB2Tod8j8S2aeSUiIvnC5XDiTE7DlXphyUBY3eIYdjPxf5/h6Bd7qDaqGQDx+2I48vlfVBvVjGPf/k3q2WQccak4ziVjCbBS7rbaWEPs3roVERHxUSG2INpWbME3e3/0dijyH1azFXdqgrfDkBzYixenWLs2GP/sjijiK5S8EhGRfGHxtxLVsRJ/L9iKNchGYNlQAisUoUjt4iQeic22bcKBs1Qd0RSzn4V9H2zj9KYjlGhXMZ8iFxGRgsLPamdgvZ78fGgL8UqU+BSrYcGZomWDvq7CXYMxmc3eDkMkE80FFBGRfBPZsiy1xl5Pqc5VsQTZObn2IH+9thFncvYFXIMqFMHsl/55i3/JINKSCn7BVxERyRtWw8LQhn29HYb8h9VsUc0rHxdSuxZh9ethWDTHRXyPklciIpIvEg6c5cSPBzDbLYRUiyDqpspUG9UUTJB0LB73v8peuZ2uDG1Nlv/8c+VWjSwREcma1WylSam61Iis7O1Q5F+sZiuulBRvhyEXYfb3o9qY0ZjtKssgvknJKxERyReWQBvHv99P/IGznnOO+FRcDiehNSJwnEvGEZ+K2+3m3J+nvBeoiIgUeHaLnfuvG4rV0AwSX2ExmXGnaea0r6p473AsAQHeDkPkovTXXERE8oU9IoAKt9fl2Oq9OGJTMFkMzHYLpbtVx79EMEUbR7H7jY1Yg+yEVCvq7XBFRKSAC7YF0LdON97fuszboQhgw6zdBn1UkUYNKXpdMxVpF5+m5JWIiOSboIpFqFyxUZaPRd1chaibq3iOi7epAJCpMLsKtYuIFCy//fYbL7zwAmfPnsXtdlOiRAnGjRtHlSpVcm58FewWOzdVbs26gxvZF3MoT8eSnFlMBg4lr3yOJTiIqqMfxOzn5+1QRLKlZYMiIiIiIpInUlNTueeeexg/fjyfffYZK1eupGvXrgwbNgyn05nn49vMVka3GI7VbM3zsSR7FpMZl5YN+pzK94/EUJ0rKQA080pERLzizG/RnFx/4ZNwV3IaqbEp1Hy0Jed2nODM5qO4HC78o4Ip070Gxn+LtouIiM9LSkoiLi6OxMREz7lu3boRFBTEhg0bmDZtGitXrgTg559/ZvLkyaxcuZJZs2Zx5MgRTp48yZEjRwgPD+fFF1+kePHilzW+yWQizC+Euxr25fWN7+fqvcnlMZsM3A4lr3xJ0ZYtCKtXF8Oq5K74PiWvRETEK8LrlyS8fkkgfXfBPfN/pdgN5Ug4eJZTPx2m8t2NMPtZOLBkOyfXH6R4q/LeDVhERC5baGgoY8aM4e677yYiIoKGDRvSrFkzbrnlFrZt25Zt202bNrFixQqCgoK49957Wbx4MQ888MBlx2C32GhRtjGbjmxj09Hsx5S8YzYZuNK0bNBXWIuEUXnUCC0XlAJDH2OLiIjXnVh7AEuQjaJNShHz2zEiW5bFEmDFZJgo3bWaJ8klIiIFz5AhQ1i3bh1PPvkkkZGRzJs3j+7duxMXF5dtu6ZNmxIUFARAzZo1OXfu3BXH4Gexc/91Qwj3D7viPuTqmNHMK19SdfRDKtAuBYqSVyIi4lVpCamcXH+IqE7phXtTTieSFp/K3+/9xq5Xf+bYd/sw/DRRWESkINq8eTNvvvkmQUFBtG3blrFjx/L5559jGAY7d+7E7XZ7rv1vMW+/f80IMZlMGa69ElazlUevvweTyXRV/ciVMUyGdhv0EcU6tie4ahUMi15fScGh5JWIiHjV6U1HCakegb2IPwBup5u4vWcod1ttqtzTBGeSg2Or93o5ShERuRLh4eG89tprbNq0yXPu5MmTJCUl0aFDB44ePcrp06dxu92sXr06T2OxGGZKh5Skd83OeTqOZM0wmXCrYLvXBZQrS8W7h2q5oBQ4SrWKiIhXnd1+glKdL2yXbg22E1ozEvM/s62K1C3B8TX7vRSdiIhcjQoVKvDqq6/y4osvcuzYMex2O8HBwUyaNInq1avTr18/evXqRWRkJG3atMnzePwsdrpVv5Gdp/by+/GdeT6eXKCZV95nDQ2h1qRntLugFEhKXomIiNekJTlIPZNIYNlQz7nQWpGc236Coo2iMFkMzu08iX+pYC9GKSIiV+O6667juuuuy/KxcePGMW7cOM/xyJEjAbj//vszXPff46tht9h4tOU9jP/qOaLjT+Rav5I9A8288iaT1Uqtic9gCQrS0lkpkLRsUEREvCb1TBKWYDsm84V/jiKaliaoUjh/vb6RXa/8jCvVSckOlbwYpYiIFDZ2s42n2j5IgNXf26FcM0yaeeVVVUc/iF9USdW5kgJLP7kiIuI1AaVCqPFQ8wznTIaJEm0rUKJtBS9FJSIihZ1hGITYgxl7/QgmrnnxqovBS85MqnnlNWX69qFIwwaYtVxQCjDNvBIRERERkWuOzWylYnhZBjfo4+1Qrgkmw8DlUPIqvxVtcR2levZQgXYp8JS8EhERERGRa5KfxU67Ci1oW6F5zhfLVTGZTFo2mM8CK1WkyoP3Y/bTjCsp+JS8EhERERGRa5bdYmdow340KFnb26EUaibD0LLBfGQLD6fWhKc140oKDSWvRERERETkmma32Hi4xd3UiKzs7VAKrfRlg5p5lR8Mm41ak57BHKANCaTwUPJKRERERESueX4WO+NvGEmFImW8HUrhpILt+cJkNlP9sbHYi0VqZ0EpVJS8EhERERERAfytfjzd5iFKBhf3diiFjskwa+ZVHktPXI0jpGYN7SwohY6SVyIiIiIiIv/wt/gxud0jFA0o4u1QCg2zYQbc4HJ5O5TCyzCo/thYQuvUUp0rKZSUvBIREREREfmHYRgE2gKY2n6sEli5xN9ix63EVd4xDKqPH0NondpKXEmhpeSViIiIiIjIv5gNM6F+wUzr+BjFgyK9HU6B52/xx+10ejuMwskwqD7uUcLq1VXiSgo1Ja9ERERERET+w2yYCbYF8lzHcZQJjfJ2OAWa3WLD7dTMq9xmslio+fQThNWvp8SVFHpKXomIiIiIiGTBMAwCrP5Mbv8oFYuU9XY4BZaf1Y7bqZ0Gc5Nht1N7yoT04uxKXMk1QMkrERERERGRizBM6QmsCW0fpnpEZW+HUyD5me2407RsMLeYAwOoM20qgRUraVdBuWYoeSUiIiIiIpIDP6sfT7QeReOout4OpcCxW+y4NPMqV1hDQ6j3/HQCSpfGbLd5OxyRfGPxdgAiIiIiIiIFgd1i58Hmd7FsxyqW//mlt8MpMPzMNtxpSl5drcBKFan1zJOYAwIwrNbLajtlyhQ2btwIwN69eylVqhR+/yw33LlzJxs2bCA8PDzXYxbJLUpeiYiIiIiIXCK7xUaPmp0oE1qKV395F6dLy+FyYrcoeXW1Itu3pdI9w654meCTTz7p+bpdu3b873//o06dOgBUq1YtV2IUyUtaNigiIiIiInIZ/Cx2mpSqx5T2Ywi2BXo7HJ9ns9hxOZS8uhIms5lK991LpeF352l9q1mzZtGzZ0/atWvHBx98AMCyZcu45557PNf8+3j8+PHce++93HLLLTz//PN5FpfIeZp5JSIiIiIicpnsFhtlQ0vxv5ufYtJ3L3Ek7pi3Q/JZdrMVd5rD22EUONbQUGo+/QT+pUvl+Y6CZcqU4ZlnnmHHjh307duX2267Lcc2ycnJfP7553kal8h5mnklIiIiIiJyBaxmC6F+wTx343halmns7XB8ls1s1cyryxRUtQoNZr9MQPlyeZ64AujSpQsANWrUIDU1lfj4+BzbNGrUKK/DEvFQ8kpEREREROQKGSYDP4ude5rewX1NB2E1X14h7WuBzWzD5Uj1dhgFRrGOHag9eSLWkGAMS/4slrL8M47JZALA7XZjMplwu92eaxyOjLPnAgIC8iU2EdCywcvmcqRS8Yml3g5DRERERER8iJ/FTvMyDakRWZlpa1/lSKyWEZ5nM1txO7RsMCcmi4VKI+4h4voWmP3yrr7VpQoPD2f37t2kpKRgNpv57rvvvB2SXMOUvLpMhtVG10c+8XYYIgXaZy/c6u0QRERERHKd3WIjMiCc5zqO561fF7Nm3wZvh+QTbGYrrlQlr7LjXyqKamMfxa9ECZ9IXAG0bNmSJk2a0KlTJyIjI2nWrBm7du3ydlhyjVLySkREREREJJcYhoGfYWdow740iqrD6xvfJyE10dtheZXVbMXlSPF2GD7JZDZTqndPSvfqgWG1YjLyvrLPt99+m+H4vwmpfx/PmDEjyz6mTZuW+4GJZEM1r0RERERERHKZn8VOg5K1mX3LZJqVbuDtcLzKarbiSlHNq/8KrFSRBrNfpnTP7pjt9nxJXIkUVJp5JSIiIiIikgdsZis2s5WRzQbRrmILXvtlAWeTY70dVr6zGhZcqUpenWfYbJQbOIDiN3XEsNk8RdJF5OKU2hUREREREclDfhY7dYpV5+XOE2lbobm3w8l36ckrLRsECK1Tm0ZvvErxmzqmz7ZS4krkkmjmlYiIiIiISB6zmC1YzBaGNOhLuwotmbNxAdFxx70dVr6wGpZrftmgOTCAisPvpmjz6zDbfaMgu0hBoplXIiIiIiIi+cTPaqdy0fLMuPFxhjS4DX+rn7dDynNWkxl3Wpq3w/Ca8Oua0njuaxRt0VyJK5ErpJlXIiIiIiIi+chsmDEbZtpVbEmr8s34YNtyvv17PS63y9uh5QmrYcblcHg7jHwXUqsmFe4agn+pKMx+hT9JKZKXlLwSERERERHxArvFhh0bA+v1okeNTry5+UO2RG/3dli5zoKZFMe1M/MquFpVKtw1hIByZTFU10okVyh5JSIiIiIi4kX+Vj/8rX483OJujsYd54Oty/n9+E5vh5VrzCbjmlg2GFipIhWGDiaociUlrURymZJXIiIiIiIiPsDPYqdikbKMaXkPJxLP8MHW5YViJpbFZBTqZYMB5cpRfsidhNSsgWG1YjJUWloktyl5JSIiIiIi4kP8rH6UDY3ioeZ3EZN0jg+2LWfTkW24cXs7tCtSWGde+ZcuRfnBdxJat46SViJ5TMkrERERERERH3R+OeGoZoOJS4ln6Y5VrDu4iVRnwZrFZKZwzbwKqlqF0j27E9awASaLBcNs9nZIIoWeklciIiIiIiI+7HwSa3CD2xjSsC/f7VvP//31HcfiT3o7tEtiFIKZV4bdTmSr6ynVswe28CIYNptmWonkIyWvRERERERECgB/qx8AHSvdQLsKLdl/9hCf/PkVv0Zvx+V2eTm6izNMpgI788q/TBlKdulEsTatcbvdWPz9vR2SyDVJySsREREREZECxGJYsBhQLaISo64bgtOVxpp9P/HDgZ85cPawt8PLxGQycDsKzswrS3Awka1voGTnTtiKFsVkMWNY9NZZxJv0GygiIiIiIlJABfwzG6tT1bZ0rHwDCamJrNm3gbUHfuFo3HEvR5fOMJlwpfn2zCuT1UqRBvUp0flmQmvVxO1yYfbz83ZYIvIPJa+kwPpr5VhswSUwmUyec/bQ0pSo1yfTtQd+eJHSze/FbNU0XxEREREpfCyGGYthxs9ip1v1G+lSrQNnk8/x3d/r2Xh0G4fOHfVabL4688q/VBRhDRsQ0aI5QZUr40pzYAkI8HZYIpIFJa+kQCvT/B7MtsAcryvX6uF8iEZERERExPus5vS3ecWDIulZqzPda95MmiuNrdF/8suR3/j9+E7iUxPyLR6TyYTLBwq2m/39CK1Th/DrmlKkcSPMdjuYTOn/Bwyb1csRisjFKHklhdLuVY8RWLwWKbFHKdngdg7+OItKNz5zSYkuEREREZHCwmY+n5Cx07JcYxpE1cJqWDmRcIpfDv/G9hO72HvmAImOpDyLIX3mlXeWDQZWKE9Yo4ZEtGhOQNkyuBwOzH5+2ilQpIBR8koKtEMb3siwbLBUs2FY7EG4XU6CitcgqtEdXoxORERERMS3BPxTRqNUSAm6Vu/IjZVbYTfbiE2JZ/fpfWw/sYs9Z/Zz4OwR0ly5M1vKZOR9zSvDbiegbBkCypYlqHJFgqpUIaB0qfTxzRbPrCrDqtlVIgWRkldSoGW3bNA/vEI+RyMiIiIiUnBYDDMWW3qNp/CAMJoFNKB+yVo43U5sZiunE2M4EnuMfTGHOBp33PNfkiP5ssbJ1ZpXhoF/yZIElCtLYMXyBFetSkDZslhCgnElp2AyDAw/e4YPuEWk4FPySgotw2L3dggiIiIiIgWK3WLzfF08KJLiQZHUL1mLlLRU3G43NouVVKeD04kxxCSd40zSWU4lnuFsciznkuOITYnjbHIcyY5kUpyppDodmAzj4jOvDANLYACW4GCswcFYQkLS/x8chDU0FFt4EaxhYVhDQrCEBGMrUgS3w4Hb7cZst2Mymy90Fahi6yKFlZJXIiIiIiIiclGGycDf6uc5thgWAkL9KRMaBYDb7SbV6cDpcuLGjWEyPP+ZDQN3airN3n8X3G7cbjec/w8wWSy409JwpTnB7Uo/ZxiYLJaLL/Gz6G2syLVGv/UiIiIiIiJyxUwmU4YZW5nYLyS+slrMZ7LZMLJpLiKi5JUUWFW7zLjkx7K7VkRERERERER8l/YHFRERERERERERn6WZV1Lgud1ujm9dgi24BOGVWuNMTeT478tIiT2KYbYRUqYJRSq09HaYIiIiIiIiInIFlLySAi0l7jgntq8gOeYgRauVAODkjs8wLHbKt3kU3C6ObHwXa0ARgorX9HK0IiIiIiIiInK5tGxQCrSz+zcQWqYxwVF1PeeSzx0mpFRDTCYDk2EhqHgN4qN/92KUIiIiIiIiInKllLySAq14ne6ElG6U4ZxfWFlij/yK2+XElZZCXPTvpKXEeSlCEREREREREbkaSl5JoRNZswsAB9a+xNFN7xEYWQWTyezlqERERERERETkSqjmlRQ6rrRkImvcgtkWAMCZPd9hDSzq5ahERERERERE5Epo5pUUOucO/MSpXV8BkJYSx7mDvxBSqoGXoxIRERERERGRK6GZV1LohFduS/SWxez//gVwQ9GqHfELK+PtsERERERERETkCih5JYVCifp9PV8bFj9KNRnkxWhEREREREREJLdo2aCIiIiIiIiIiPgsJa9ERERERERERMRnKXklIiIiIiIiIiI+S8krERERERERERHxWUpeiYiIiIiIiIiIz1LySkREREREREREfJaSVyIiIiIiIiIi4rOUvBIREREREREREZ+l5JWIiIiIiIiIiPgsJa9ERERERERERMRnKXklIiIiIiIiIiI+S8krERERERERERHxWUpeiYiIiIiIiIiIz1LySkREREREREREfJaSVyIiIiIiIiIi4rOUvBIREREREREREZ+l5JWIiIiIiIiIiPgsJa9ERERERERERMRnmdxut9vbQYiIiIiIiIiIiGRFM69ERERERERERMRnKXklIiIiIiIiIiI+S8krERERERERERHxWUpeiYiIiIiISK774osvGDhwoLfDEJFCQMkrERERERERERHxWUpeiYiIiIiISK54+eWX6dChA7179+brr78GYN++fQwZMoS+ffvStm1bRowYQUpKCp9++in9+vXztD169CjXX389qamp3gpfRHyUklciIiIiIiJy1VavXs1XX33FihUrWLRoEfHx8QAsWbKE7t27s3jxYr766isOHz7MmjVruPnmmzl48CB79uwB4KOPPqJHjx7YbDZv3oaI+CAlr0REREREROSqbdiwgY4dOxIUFITFYqFXr14AjBkzhvDwcObNm8eECRM4ceIEiYmJ2Gw2+vTpw5IlS3A6nSxfvpy+fft6+S5ExBdZvB2AiIiIiIiIFHwmkwm32+05NpvNAIwePRqn00mnTp1o06YN0dHRnuv69u1Lnz59aNq0KVWqVKF06dJeiV1EfJtmXomIiIiIiMhVu+GGG/jiiy+IjY3F5XLxySefAPDjjz8ycuRIOnfujMlkYuvWrTidTgCioqKoX78+zz77LLfffrs3wxcRH6aZVyIiIiIiInLVWrduza5du+jVqxchISFUr16dmJgYHn74YUaOHEloaCj+/v40adKEgwcPetr17NmTyZMn07p1ay9GLyK+zOT+97xOERERERERkXzicrmYNGkSUVFRDB8+3NvhiIiP0rJBERERERERyXfx8fE0a9aMQ4cOcccdd3g7HBHxYZp5JSIiIiIiIiIiPkszr0RERERERERExGcpeSUiIiIiIiIiIj5LySsREREREREREfFZSl6JiIiIiIiIiIjPUvJKRERERERERER8lpJXIiIiIiIiIiLis5S8EhERERERERERn6XklYiIiIiIiIiI+Cwlr0RERERERERExGcpeSUiIiIiIiIiIj5LySsREREREREREfFZSl6JiIiIiIiIiIjPUvJKRERERERERER8lpJXIiIiIiIiIiLis5S8EhERERERERERn6XklYiIiIiIiIiI+Cwlr0RERERERERExGcpeSUiIiIiIiIiIj5LySsREREREREREfFZSl6JiIiIiIiIiIjPUvJKRERERERERER8lpJXIiIiIiIiIiLis5S8EhERERERERERn6XklYiIiIiIiIiI+Cwlr0RERERERERExGcpeSUiIiIiIiIiIj5LySsREREREREREfFZSl6JiIiIiIiIiIjPUvJKRERERERERER8lpJXIiIiIiIiIiLis5S8EhERERERERERn6XklYiIiIiIiIiI+Cwlr0RERERERERExGcpeSUiIiIiIiIiIj5LySsREREREREREfFZSl6JiIiIiIiIiIjPUvJKRERERERERER8lpJXIiIiIiIiIiLis5S8EhERERERERERn6XklYiIiIiIiIiI+Cwlr0RERERERERExGcpeSUiIiIiIiIiIj5LySsREREREREREfFZSl6JiIiIiIiIiIjPUvJKRERERERERER8lpJXIiIiIiIiIiLis5S8EhERERERERERn6XklYiIiIiIiIiI+Cwlr0RERERERERExGcpeSUiIiIiIiIiIj5LySsREREREREREfFZSl6JiIiIiIiIiIjPUvJKRERERERERER8lpJXIiIiIiIiIiLis5S8EhERERERERERn6XklYiIiIiIiIiI+Cwlr0RERERERERExGcpeSUiIiIiIiIiIj5LySsREREREREREfFZSl6JiIiIiIiIiIjPUvJKRERERERERER8lpJXIiIiIiIiIiLis5S8EhERERERERERn6XklYiIiIiIiIiI+Cwlr0RERERERERExGcpeSUiIiIiIiIiIj5LySsREREREREREfFZSl6JXOMOHz5MjRo1uPXWWz3/devWjY8//jhXx5k9ezarV6++rDbbtm3j6aefzrXrxo8fz/z587O9ZtmyZdxzzz1ZPvbEE0+wfv16Dh8+TIMGDQCYNWsWkyZNynHsq/H777/Trl27PB1DREREfNN/X6t17dqVPn36sHnz5jwZ74svvmDgwIF50vflGjp0KGfOnMmV637++We6dOmSY1/VqlXLsq9vvvmGKVOmADBw4EC++OKLDK8JRSRvWbwdgIh4n5+fH5988onn+Pjx43Tp0oXatWtTvXr1XBnj559/pnLlypfVZs+ePRw/fjzXrrtaU6dOBdJfRIqIiIjkl/++Vlu1ahWPPfYYX331lRejynvr1q3L1euuRvv27Wnfvn2ejyMiWdPMKxHJpHjx4pQrV479+/eTmJjI2LFjue2227jpppvo2bMnf//9N5D+qdOoUaPo3LkzCxYsIC4ujvHjx9OzZ0+6du3Ks88+S1paGh988AHbt29nxowZfP3118TFxfHoo4/SpUsXunbtyowZM0hLS8sQQ3R0NK+88gqbNm3iscceA2Dx4sV06dKFbt26MXToUPbt25fpOpfLxZQpU+jTpw+dO3emU6dOl/3J5MmTJ7nrrrvo2rUr9957LydPnvTc7xdffJFje5fLRevWrfn999895x5++GEWLlzI3r176devHz179qRHjx588MEHWfaxcOFCbrrpJnr16sXChQs950+dOsV9991H3759adeuHQMHDuT06dNs3ryZ1q1b43K5AEhKSqJ58+acPn36su5dREREfN/Zs2eJjIz0HGf1GsnlcjFo0CBmzJgBwPr162nVqhWnTp3K1N/LL79Mhw4d6N27N19//bXn/L59+xgyZAh9+/albdu2jBgxgpSUFD799FP69evnue7o0aNcf/31pKames7FxcXRsGFDz+sogNtuu43vv/+eTZs20bt3b3r27EnPnj358ssvM8V0/vXfoEGDiI6OZvfu3QwcOJCuXbvSrVs3VqxYkeV13333nee1Vps2bXjppZcu+/l96aWX6NGjB7feeivfffcdkP3sfBHJe0peiUgmW7Zs4eDBg9SrV48ffviBkJAQlixZwpdffknt2rUzJFxCQkJYtWoVAwcO5Nlnn6VWrVosW7aMFStWEBMTw9tvv82AAQOoXbs2Y8eOpWPHjkyZMoWwsDA+++wzli5dyq5du3jrrbcyxFCyZEkeeOABGjduzHPPPceGDRt48803ee+99/j000/p0qULI0eOpESJEhmu27p1KydOnGDx4sWsWrWKHj16MG/evMu6/3379vH000/z2WefUbVqVc+Mq0tlGAa9evVi+fLlAJw7d47169fTtWtX5s+fT7t27Vi2bBlz585l06ZNnoTTeX/++SezZ8/m/fffZ+nSpVitVs9jn3/+OfXr12fx4sV88803nk9iGzVqRFhYGGvXrvVc17x5c4oWLXpZsYuIiIjvSU5O9iwbbNu2Lc8++yzDhw8HuOhrJJPJxPPPP88nn3zC6tWreeyxx3jhhReIiIjI0Pfq1av56quvWLFiBYsWLSI+Pt7z2JIlS+jevTuLFy/mq6++4vDhw6xZs4abb76ZgwcPsmfPHgA++ugjevTogc1m87QNDg6mY8eOfPrppwDs3buXkydPcsMNNzBr1iyGDBnCsmXLePbZZ/npp58y3fNzzz0HwLvvvktkZCQjRoxg4MCBfPbZZ8ybN4+ZM2eyZcuWDNeVKFGCt956i2nTprFs2TIWL17M3LlzL2np4b+VLl2a5cuX8/zzzzN+/PjLbi8iuU/LBkXE84IIwOl0UqRIEZ5//nlKlixJyZIlKVOmDAsWLODAgQP88ssvGdb2N27c2PP1mjVr+P333z31spKTk7Mc74cffuDDDz/EZDJhs9no168f7777rudFWFbWrl1L586dCQ8PB6Bnz55MnTo10xK+Bg0aEBoayqJFizh06BA///wzgYGBl/V8tGjRgnLlygHQu3dvevfufVntAXr16kXv3r0ZP348K1eupG3btp4XcePGjWPbtm00b96cJ598EsPI+DnChg0baNmypecT1b59+/Ljjz8C6Z8qbtq0ibfffpv9+/eze/du6tWrB8CAAQNYsmQJrVu3ZvHixYwdO/ay4xYRERHf899lg7/++ivDhg1jxYoV2b5GKlOmDJMnT+a+++7j/vvvp0mTJpn63rBhAx07diQoKAhIfw2zYMECAMaMGcO6deuYN28e+/fv58SJEyQmJmKz2ejTpw9Llixh3LhxLF++nPfffz9T33369GHixIncddddLF26lJ49e2IYBp06dWLSpEl8++23tGjRgtGjR2d7//v37yclJYUbb7wRSF8lcOONN7J27doMr0tNJhOvv/46a9asYeXKlezduxe3201SUtJlPd+33347AFWrVqVSpUps2bLlstqLSO5T8kpEMr0g+reFCxeyZMkSBgwYQNeuXQkLC8uQMAoICPB87XK5ePnll6lUqRIAsbGxmEymTH3+d6aRy+XKtGzwv9xud5bn/ttuzZo1TJ06lSFDhtC+fXsqVqzo+cTvUpnN5gxjWCyX/6eyVKlS1KxZkzVr1rBs2TIef/xxANq2bcuXX37J+vXr2bBhA6+++iqLFi2ibNmynrYmkynD/f47nueff55t27bRq1cvmjVrRlpamufarl27MnPmTH766ScSExOzfIEqIiIiBV/Dhg2pUKECv//+e46vkfbs2UNERESGcgb/lt3rjtGjR+N0OunUqRNt2rQhOjrac23fvn3p06cPTZs2pUqVKpQuXTpT340bNyYtLY1t27axcuVKFi1aBEC/fv1o27Yt69atY+3atcyePZtPP/2U4ODgLGP872vH/97jeYmJifTo0YMOHTrQuHFjevXqxerVq7N8jrLz7w8Wr/S1oIjkLi0bFJFs/fjjj/To0YM+ffpQoUIFvv32W5xOZ5bXXn/99bzzzju43W5SU1MZMWKE51M4s9nseYFx/fXX88EHH3iuW7JkCS1atMjU33/brFq1yjNte+nSpYSFhVGuXLkM161bt462bdvSv39/6tSpw+rVqy8a78X8/PPPHD16FIAPP/yQVq1aXVb782677TbmzZtHcnIyjRo1AuCRRx5h1apV3HLLLTzzzDMEBQURHR2doV2LFi1Yt24dx44dA/AsP4T078egQYPo3r07RYsWZf369Z778/f3p1u3bjz++OMZ6lCIiIhI4bJv3z72799PjRo1sn2NtG3bNt577z2WLl1KbGws7777bqa+brjhBr744gtiY2NxuVwZPtD88ccfGTlyJJ07d8ZkMrF161bP646oqCjq16/Ps88+65mplJU+ffowefJkqlWrRlRUFJCevPrzzz/p2bMnkydPJjY2lnPnzmVqe/41XoUKFbBarZ4C9cePH+fLL7/0vH48f92BAweIj4/noYceol27dvzyyy+kpqZmmfzKzvnXXn/88QcHDhzwzHIXEe9RCllEsjV06FCefvppli1bhtlsplatWvz1119ZXvvEE08wdepUunbtisPhoEWLFtx9991A+oyj6dOn43A4ePLJJ5kyZYrnuhtuuIF77703U38NGjTgpZdeYuTIkbz66qsMHjyYQYMG4XK5CA8P54033sAwjAzXjR49mkcffZSuXbtiNptp3LgxX3311WW9aKlatSqPP/44p06domLFikyaNOmKnrt27doxceJEhg0b5jl333338cQTT7B48WLMZjMdOnSgadOmGdpVq1aNMWPGMGjQIAIDA6lbt67nsZEjRzJjxgzmzJmD2WymYcOGHDx40PN4z549PfUpREREpHD4d4kHSJ+JNGnSJCpUqECFChWyfI2UmJjI6NGjefLJJylevDjTpk2jT58+NGnShJo1a3r6at26Nbt27aJXr16EhIRQvXp1YmJigPQNZ0aOHEloaCj+/v40adIk0+uOyZMn07p164vG3r17d2bOnMnMmTM95x599FGeffZZXnrpJQzDYNSoUVnO3OrYsSP9+/dnzpw5zJkzhylTpjBr1iycTicjR47kuuuuy3Dd7NmzadOmDZ06dSIkJISyZctSuXJlDhw4kKEeV04OHTpE9+7dMZlMzJw5k7CwsEtuKyJ5w+S+3DmUIiLik9xuN/PmzePIkSNMnDjR2+GIiIhIIXY+gRYVFZVt3VIRkdygmVcics3p378/CQkJWT72wQcfeAqWFjTt27cnPDyc1157zduhiIiISCEWHx9P27ZtqVu3boHbIObNN9/ks88+y/Kxu+66i27duuVzRCJyKfJs5lW1atWoWrUqhmFgMplISkoiKCiICRMmUKdOnWzbHjhwgAkTJnDmzBkcDge9e/dm6NChQPqOYy+++CJOpxPDMBg9ejQ33HBDpj527dpFv379MhRBfvHFF6lYsSJbt25l4sSJJCUlUaxYMZ5//nmKFSuWu0+AiIiIiIiIiIhctTxNXm3YsMGzZSvA/Pnz+eqrr1i8eHG2bW+//XZ69uxJnz59iIuLo3fv3kyYMIHatWvToUMH3n//fapUqcLOnTu54447WLNmTaaZEosWLeKPP/5g8uTJGc6npqbSsWNHZs6cSaNGjVi4cCHfffcd8+bNy72bFxERERERERGRXJFvywbT0tKIjo4mNDQUgFmzZrF7925OnTrF6dOnqV69OlOnTiUoKIjevXvTuXNnAIKDgylbtixHjx6lWrVqPPPMM1SpUgWAypUr43a7iYmJyZS82rJlC4cOHaJ3794ADB8+nBtvvJHff/+doKAgz85fvXv35tlnnyUmJoYiRYp42sfGxhIbG5vpPsLDwwkICMj9J0hERERERERERDLJ0+TVoEGDMJlMnDlzBrvdTtu2bXnuuec8j2/dupWlS5cSHh7OmDFjePXVVxk3bhy9evXyXPPDDz+wZcsWpk6dSnh4uCepBfDKK69Qvnx5ypQpk2lsf39/unTpQv/+/dm7dy8DBw4kKiqKY8eOUaJECc91NpuN8PBwjh8/niF59e677zJ79uwMffbr109FkEVERERERERE8lGeJq/effddwsPD2bFjB8OGDaNBgwYULVrU8/jNN99MREQEcGEG1Lhx4zyPL1++nGnTpvHKK69kqEmVlpbGtGnT+OGHH3jnnXeyHHvChAmerytVqkSnTp349ttvqVChQpbXm83mDMeDBg2iR48eGc6d3141NjYJp9OV8xMgIiIiucpsNggJ8fd2GOJlMTEJuFx5s2F22JJ2AJy97ds86d8XFC0axOnT8Xk+TlDCwwDEB76Y52ON+T59rOdbX3ysMWPs6dc8n3JFfZxv/9Zb1nx5/i4mP5/XvJJfP4OFVdG9j5KS6iS+RsH9GfCmi/38BY3553freT2v2TEME0WKBOb7uPmybLBmzZo89thjPPnkk9SrV4/SpUsDGRNGLpcLwzCA9O3ep0+fzpdffsk777xDjRo1PNedO3eOBx54ALfbzeLFizPMljrP6XQyd+5cBg4c6FlO6Ha7sVgslCxZkpMnT3qudTgcxMTEULx48Qx9hISEEBISkuX9OJ0u0tKUvBIRERHxBpfLnWfJqzO9v/lnkLzp31fk1fP3b7H+M/8ZLO/Hmn5D+ljZ3df06cn/XHNlfZxvD9Z8ef4uJj+f17zkzeewwGv6OrEn4wr8z4A3ZfXzFzu9cPxuFVZGfg3UpUsX6tevz7PPPus598033xAXF4fL5WLJkiW0bdsWgKlTp7Jx40aWLl2aIXGVmprK0KFDKV26NG+99VaWiStIT4p9++23LFmyBIAjR47w1VdfcdNNN1GvXj3Onj3Lr7/+CsDSpUupX7/+RRNVIiIiIiIiIiLiPflWsB3gqaeeolu3bqxduxaAiIgIhg0bRkxMDE2aNOHee+8lOjqa999/n6ioKIYMGeJpe+edd2K1Wtm+fTupqakZ6mLNmDGDatWqceuttzJlyhTq1KnD//73P5555hmWL1+O0+nk8ccfp1KlSgDMnj2bSZMmkZSURFhYGNOnT8/Pp0FEREREfFTIB+llI2IHLPdyJAWff1L6LIYk/9F5PtYrv6aP9UDDi4/1yivpJUAeeCD1ivo43/4/m5nnu/x8XsVH/TEN/4QUkiroZyA3+b/yz+/WA3pefVGeJa927dqV6VzFihXZvn07AL/99hvVqlXj6aefznBNyZIl2blz50X77dat20Ufa9OmjWcpYrly5S5aD6tu3bp8/PHHOd2CiIiIiFxjLMmZX8PKlbGkbcu3sbafynms7duzX3SSUx85tc8v+fm8io+K+Q1LiiNfh0xMjCc29nS+jplXTpwwcGWxftjUvg0A7mMH8jki3xYSUpSAgCBvh5G/M6/yktvtplSpUtSsWdPboYiIiIhIAXXmrh3eDqHQiAt+J9/GmntjzmPNnZuc/eM59HGhvfXSgsoj+fm8io+6fhFxJ+Pydcj4+HOEh5fAZrPn67h5wWIxsq5hXaJc/gfj41JTUzh79tS1nby6//77c7U/k8nEbbfdlqt9ioiIiIiIiFzrXK40rFabt8OQfGa12nC50rwdBpCPBdtFREQkfabw1KkTWLhwAZC+Q+5LL/2P/v170bdvd1asuLCs/dChg9x3393ccUcfhg27kwMH9gPpO+WOHfsQgwbdzowZUz3XHzlymIceui9f70eksAld0IXQBV28HUahEJA4nYDE/Kkt+8Km6bywKfuxXnjBxgsvXPzNd0595NQ+v+Tn8yo+6vfJBPyd/z8DJpMp38fMT8axaIxj0d4Ow6f40ve80CwbFBER8XX79+9j5szp/PHH79x1V/omIp98sozDhw/y3nuLSUxM5N57h1C1anVq1qzNpElP0qdPf2688WY2bFjHE0+MZcGCxfz883oiI4sxY8ZLjB59P3//vYeKFSsze/aLjBz5kHdvUqSAM6fu93YIhYbZuTvfxtoTk/NYe/Zk/7l9Tn3k1D6/5OfzKj4qbhfm5PyteeVrpk2bzPjxT13y9aNGDcfpdGI2m0lLc1CkSFEmTXoOq/Vfy4BTUgBITU1lwoQniIk5Q7Vq1XnwwUczJHF++eUn5s2bg2GYeeihR6lcuSoPPzzS8/iOHdtZvnwVoaFhV32fcoGSVyIiIvlk2bIldO7cleLFS3jO/fDDd3Tr1hOLxUJISAjt29/IV1/9H5GRxThw4AAdOtwIQPPmLXnhhWn89dcurFYbycnJuN1uUlNTsFisrFu3loiIYlSpUtVbtydSKJy5a7u3Qyg04oLfzLexXuuY81ivvZZ9zauc+rjQ3ts1r/LveRUf1eL9fK955WsuJ3F13owZLxEcHIzFYvD889P4+ef1XH99a8/jrnLlAfjm/1ZSo0ZNBg4cwnPPTWLXrj+pXv1Cbe15817jxRfnkJyczOTJT/Pyy3OYPXsuACtWLKVJk2ZKXOUB3/j4QERE5BowevQ4br75lgznTpw4TrFixT3HxYoV58SJExw/fpyIiAgM48I/1ZGRxTh58jhNmjTDarUyZMgAGjRoRIkSJXn33fkMGzYi3+5FRERErk2h3TtjX/RB+oHDkX780aL048TE9OMVSwEwxZ4jtHtnbCs/TT8+fTr9+Mv/y3aMVas+48knx/LwwyN57LFHeOutuQwbNojXXpsFwODB/QEYMeIunn12IkOHDuD9998BYO7cOezb9/dF+3a73Zw+fYrg4BBWrfqM8eNHM2rUcEaOHEZMzBk6depC//534nQ6iYmJISAg0NM2Pj4ef39/goKCiIiIIDExnrS09JpQycnJfPbZCm6/feDlPaFySZS8EhER8SKXy53pnGEYuN1Z7IIDGIYZwzAYP/4p3nlnIXfddQ8LF77HLbd049y5szz22KM89tij/PXXzrwOXaRQCn33JkLfvcnbYRQKAYlTCEicki9jTftlCtN+yX6sadNsTJt28ZpVOfWRU/v8kp/Pq/iobU8TsKfw/wwEBQXz4ouvYjIZVKhQkddff4v169dmuObUqZPcddc9vP7626xc+QkAw4ffR4UKFTP1N3bsQwwdOoA+fbpTs2Yd6tVrAEBwcAizZ8+l2w1tWLHgbSD9tdjgwbdz7txZIiIiPH0kJMQTEBDgObbZ7KSmpi83XL36C9q3vxGbzft/JwojLRsUERHxouLFS3D69CnP8cmTJyhWrBjFi5fgzJnTuN1uT52FU6dOEhlZLEP7Y8eOsXHjz8ya9QaTJj1Fv34DiIoqxTPPPM6cOVpaInK5jLTj3g6h0DC7juTbWEfjcx7r6NHsP7fPqY+c2ueX/HxexUclHsKc4r2aV+dWrLpwYLVmPA4IyHDsDgnNeFy0aMbrs3E+ARUYGEjp0mUwm82YzRlTGAEBgZ5yDH5+/tn2N2PGS/j7+/Pkk2MJDw/3nK9Xrz4ANcqVZ8PmX4D0QuULFizh00+Xs2DBO9xzz0jPeElJSZ62qakp2O1+APzwwxrGjn3yku5NLp+SVyIiIl50ww2t+PzzT2nZ8gaSkpL45puvePTRxyhWrDhRUaX55puv6NDhJn7+eQMmk4lKlSpnaP/qqy8xYsQDGIaBw5GK2WzBZDJITs6+touIZC3mrt+8HUKhERf0Wr6N9Uq7nMd65ZXs/y7m1MeF9l6ueZWPz6v4qOveviZqXl3KTneXuxuexWLh8cefZvDgATRu3AyAPXvSN0H4M/YcZarXZMWKjwkICOTGGzvh5+eP2Wz2tA8ODiYxMZH4+HhSUpKx2/0wm8243W5OnjyRYZaW5C4lr3xEcIgffnbv/kN4rUlOcRAXqzd3IuJd3bv35siRIwwe3J+0NAfduvWkQYNGAEyc+CzTp0/h3XfnY7PZmTx5eoYaWBs3/oy/vz+1a9cBoF+/O3j++akA3HvvqPy/GRG55ixc+B6HDh3I93HPnTsL4JWiyFarGYfDSZky5ejf/858H19Esjd37hw6drw5y6WDAOHh4QwYcCdz575K/foN2bVrJw88cC8Wi5UJE6bidruYOPEpPvtsBYGBgTzxxESOHTvG4sUf8OCDjzB8+H08/PBI3G43Dz30KABnz8YQFBScn7d5zTG53e7MxTYkWzExCaSlZV2L5EpFRgbTf+wHudqnZG/hjAGcvAY+sRARKUwsFoMiRQJzvlAKtdOn47OsF5cbwt5tD8DZQd/kSf++IDIyONdeA02fPpldu/dg9gvL9NgdHTYB8P7qxrky1r85k88CeMbdUSx9rJonLj7Wjm290q+puzTrx3Po49/tnclnqValMuPGXf6OZ1crMGECAAmBE/J97NySmz+D16LII8+SmJhKQpUJ+TbmsWMHKFGiXL6Nl5csFsPzfn7Vqs+Ij4/jttv6Yxw9CoArKipTm7S0NN577y2GDh2er7H6gv9+7w3DRNGiQfkeh2ZeiYiIiIj8w+Q85+0QChyzXxgB5dpnOh9ebD9Alo9drcQD32To22X7Zyz/i4/l2lk123hy6uPf7c+P7w0m9xmvjS0+IuU0Jof3al4VWs60iz/kdNKr1235GIz8l5JXIiIiIiL/iBm6ydshFBpvrrsr38ZqmprzWE1v+uWq+sipfX6JD3rF2yGItzWbS7xmruWKzp27er52lSl70evsdjt2uz0/QpKL8I0tM0RERERERERERLKg5JWIiIiIyD/C3m5N2NutvR1GodC/yUL6N1mYL2NtsS1kiy37sbZ814At3zW44j5yap9fAhOeIDDhCW+HId7066ME/qWfgdxmHDmCceSIt8OQi9CyQRERERGRf5jc2ok4t9gsqfk2lpOcx3KmZf/WJ6c+cmqfX0zuJG+HIN7mTMLkzL/fr2uGO3c3ZZPc5Rt/gUVEREREfEDM0J+9HUKh8c6Gwfk2VuPUnMdq3HHjVfWRU/v8Eh8009shiLc1eVU1r/KAq3QZb4cg2dCyQRERER/2xx+/M2rUMP7443dvhyIiIiKSL1at+owlS/Jn2fF/TZ06gd27d2U4t2DBOxw+fCjTtdHRR3nssUeuesxVqz6jb9/ujBo1nFGjhjN06B3s2LH9otd/+ulyhg27k1GjhnPs2LEMj8XHxzN69ChGjBjK/PlvAPD22/M8fd966018/PGiq445vyl5JSIi4qP++ON3pk+fwqlTJ5k+fYoSWCL5IOztloS93dLbYRQKA5stYGCzBfky1mbbAjbbsh9r87eN2PxtoyvuI6f2+SUwYRyBCeO8HYZ40+aHCNyln4HcZhw5jHHkcJaPDRw4mNJ5PDOrV6/bmD17LrNnz2Xs2Cd4//13s7wuJSWFTz9dzuuvv82wYSNYuDDjdcuXf0zHjjfz2mtvsWfPbg4dOsiQIcOYPXsuEyc+S1RUaW69tVee3kteUPJKRETEB51PXKWmpgCQmpqiBNYVcrvdjB8/nvnz5wPgdDqZMmUKN998Mx07duTDDz/0XLt//3769+9P586d6d27N3v37gUgNTWVe+65h27duvH00097rj948CBDhgzJ3xsSERHxotBNnbEf/SD9wOVIP47+ZyaPMzH9+NhSAEyOc4Ru6ozt+Kfpx6mn049P/t8ljZWSksz48aMZNWo4o0ffz+nTpxg79mFOnTrFgQP7ufXWmwH46qv/Y9myj9ixYzv33Xc3I0YMZdGi94H0mVTjx49m8uQL/37PnDmd7du3kZiYSPv2LUlKSmLbzj959f13AHj33fmMGjWcZ555DJfL5ZmNtWjR+9x771CGDRvEli2bPf3Fxp5j1Kjh/P33Hg4fPsSDD45g5MhhzJr1IgDz57/B6NGjGD16FFu3bvHEdjGnTp0gODgYgDvv7MvYsQ8xeHB/1qz5BrvdzhtvvI3ZbObkyRMEBgZlaLtjx3YaNGgMQKNGjdm27TfPY+++O5877xyK1Wq9pOffl6jmlYiIiI/5b+LqvPMJrHHjnqRWrTpeiq5g2bt3LxMnTmTr1q1UqVIFgEWLFnHgwAFWrlxJQkICffv2pVatWtStW5dHH32UQYMG0bVrV77//nseeOABVq5cydq1aylevDhvvPEGd911F3/99RdVq1Zl2rRpjBunT78Lk7ND1nk7hAzWrfsBgJYtW3k5ksu34OeB+TZWo9Scx2rUbnP2j+fQR07t80tC4HRvhyDe1uglEvKw5pUv/d1ZsWIpDRs25rbb+rN27RoWLHibZs2a8+uvG0lISCA4OJjDhw/xyy8/cffdI5g06UmmTp1BWFgRxo59iDZtOgDQocNNdOhwk6ff665ryebNG4mLi6NkySi2b9/G1n17aX5TZz7//FNatmxFp05dGDPmQQ4fPuhpt2bNt0yYMBWz2czevXsASEpK4qmnHmPUqIepWLEyjz8+hgcffISKFSszY8ZUT/KoQYPGDBw4GIB69TLvXLp06RK+//47oqOPUqdOPR58MH054smTJ5k9ey6GYeaBB+6lTZv2mM1m3n57HosXL2T69Ix18BITEwgICADAz8+fpKREABIS4tm5809Gjy6Yr1s080pERMSHXCxxdZ5mYKWLjo7m8OHDGf6LjY3NdN0HH3xAz5496dSpk+fc6tWr6dmzJxaLhdDQUG655RY+/fRTjh8/zt9//80tt9wCQOvWrUlKSmLHjh3YbDaSk5Nxu92kpKRgtVr57rvvKF68ONWrV8+3+5Zrz48/fs+PP37v7TBE5BqS09+dc41XkRI1IP3AsKYfl+yXfmwOSD8ukb4szW0N5VzjVaQW75Z+bCuafhzZKauuMzl06CA1a6Z/YFezZm0OHjzIdde1YPPmjWzfvpV+/Qbw22+bOX36FCVKlODAgX089dR47r//Hk6cOMGxY0cBKFOmXIZ+GzZszPbt29iyZTMDBgxi69Yt/PnnDmrXrgtA5crpH3iFhRUhJeXCa7KHHx7La6+9wtSpE3C50ncn/OOP30lMTMD9z26Fhw4dYObMGYwaNZydO//01KQqW7Zstvfaq9dtvPrqPO677wHi4mIJCysCQIUKFQkJCSUoKAir1UpqavpOk0OGDOPDD5fyv/89l6GfgIBAT8IqKSnJMzPrp5820KpVm0t63n2RZl6J5IEioTYsNru3w7hmpKWmEHNO2wVL4fDaa69cNHF1XmpqCq+99gqzZ8/Lp6h8z4ABAzhy5EiGc6NGjeL+++/PcO78Er+ffvrJcy46OpqSJUt6jkuUKMGuXbuIjo6mWLFiGMaFz/aKFy/OsWPHaNu2LV988QXdu3enffv2lCpVinHjxjFv3rX7PSisirzVDNCug7lhcPN3gPzZdXCTLX2s7HYM3PR1k/RrOm7E7XbjTE3CYg+45D7+3d6bguJHA9p18Jq2cSRBSanE1yj8PwOlSpXhzz//oHbtOvzxx3aiokpRqlRpTp48iZ+fH82bX8+YMQ/RpEn63+7y5SsyffpMAgODWLp0MWXKpCeMDMOUoV8/Pz8sFgv79u1l+PD7uP/+eygZEortWHS28Xz11SqeemoyiYmJPPLIKCZNmkbjxk0ZOfIhJk9+mjlz3qRUqdI89NAYSpQoyVdffUGVKlU5dOgAJtOlzR3q0OEm1q1by7JlS+jdux+HDx8iOTkZpzON1NQUEhLimTRpGlOmzMBms2GxZEzr1KhRky1bNnPzzbfw668buffe9NdG27ZtoV27jpcUgy9S8kokD1hsdjbPuNvbYVwzGo19E1DySgq++Ph4qlatzqlTJ7O9zmazM2LEA/kUlW/64IMPcDqdGc6FhIRcUlu3253pnGEYnk9Q/8tsNmMYBlOnTvWcmzNnDr169SImJobHH38cgJEjR1KzZs1LvQXxUW6Tn7dDyHUOh4NVqz4lISGBzp27EhkZnC/jpqbZLv5Y0llcaan4BRe7or5dzjROHz+E8/CbWAPCSKp4CKt/GPwzpNvlIs2RiMUagOmfhLTZkgZA0tmjHNryEbhdmG0BlL9uyD9fXzzef7f3NrfJ39shFHgJCQm89dYbnDhxnFtv7UXjxk29HdLlMfvjNpu9HUW+uPXWnkye/DRr1nyDxWLhqacmAVCuXHnsdjtFi0aQnJxEixbXAzB8+H2MHfswqakpVKtWk549i1607wYNGvHHH9uxWCz4+wfQrH5DyCHBVLJkFHfdNZDAwED69OnvOV+6dBmaNr2OJUs+5J57RvHssxNJSUmhWLHitG7dNkMfW7f+xp9/bqdfvzsuOs7IkQ8xYsRQbryxM2azmaeeGkdMTAz33DOKIkXCqVy5KvfcMwTDMHHffQ8C8L//TWPIkLvp0aMPkyY9ydKlS2jSpBnlypUH4MiRwxQvXiLb+/NlJndWr+AkWzExCaSlZf0C90pFRgbTf+wHudqnZG/hjAGczKO14pGRwUpe5aNGY9/Ms++lSH5ITU3hiy8+55NPlpKYmEitWnXYtWsnDkfmpKzNZr+ma15ZLAZFigRedrvx48dTpUoV7rrrLgYPHsyAAQPo2DH908fZs2cTGxvL0KFD6dKlCxs3bsRkSv+Etl27dsyZMyfD0sCjR48yZswYFixYwJgxY7j99tspU6YMDz/8MAsXemdb72vN6dPxuFzXxkvY6dMnAzBu3FNX3MfMmdP5+usvAChbthwff/wRp08n5Fp8ew6dIqBcewDSUhNxpiZiCyzq+T36r3NHt3N852rATUiJGpSoefNlj3t08wLiz53KdL50wz7YA4pyaMsSUhPOYA0sSpn6vbDYL/zd2P/ze6QmnPYcG2YbLmcqgRGViKrT5aKzI9wulycRlnjgGyqXibiq78u1LDIy2Kuv3V555QX+7/9WAmCz2Xj77YWEh188yeFr8vr5y+rvzrFjByhRotzFmhQoFouR6+/n89Lgwf15552cX18sWPAOvXrd5ql3lVv++703DBNFiwZl0yJv5NnMq2rVqlG1alUMw8BkMpGUlERQUBATJkygTp3sX3AfOHCACRMmcObMGRwOB71792bo0KEAbN26lYkTJ5KUlESxYsV4/vnnKVYs8yc2+/fv5/HHH+fs2bMEBAQwffp0KlWqBMDHH3/M/PnzcTqdNG/enCeffLJAVtsXEZGCzel08v333/Lxx4s4c+Y09es35PbbB1KuXIUsa19d64mr3NK+fXuWLl1K27ZtSUxM5PPPP2fixImUKFGCsmXLsmrVKm655RbWrl2LYRhUrVo1Q/vp06czZswYDMMgNTUVi8WCyWQiOTnZS3ckkr0dO7Z7vj548MA/9eFyf9ZGwpkDHN32KW5XGoFFKxBVt1uWiaCYQ78C6cnH2GN/ElG5FRbb5b3Zcl9kpqQj8RzJ546RmnAm/TjhNH+vf5Oo2rcQFFkZAJM54+t+lzP9g4KEU3tJPHOQwKLlM/V74q81nD38GxZ7EKXq97isWPPDsWPRxMfHU6lS5YsmDeWC48ePeb5OTU0lJiamQCWvRLJy882dcz1x5UvydNngu+++S3h4uOd4/vz5TJkyhcWLF2fbbvz48fTs2ZM+ffoQFxdH7969qVGjBo0aNeKBBx5g5syZNGrUiIULF/LEE09kWW/iYrsF7d69m1mzZrF8+XLCwsJ49NFHeeeddxg2bFiu37+IiEhW3G43Gzf+xKJFH3D06GEqV67KqFEPU7Nmbc81tWrVYdy4Jz0JLCWucs/tt9/OwYMHufXWW3E4HPTt25emTdOXjMycOZOnnnqK1157DZvNxssvv5yhBtb69esJCAigfv36AAwZMoSnnkr/ZPrRRx/N93uR3FfkrfTtxWOGbvJyJLmnSZPrOHLkYwCqV69JaGgop07FX1WfqampzJo1k19++QmzLYiAculJKbcrfWldwul9DGk6B4vNnzfX3ZWhrdUvxDPzybD4YZizX66XleAikSQnxeNMSwWTwYE6+zCZrVQMrEDCqb8zXux2cXL39+z4NX2JT/1W5zi0eRHO1CTMtgCcqemz0A7UPcCpop/SgozLslPiTnL28BYOHEhfIuwXsoSwEO+9QQyKT48vPugVAL7++gteeul5XC4Xbdt2YOzYJ6647/j4eD7//BOsViu33HIrdvvFa7geOLCfmTOnk5AQz+DBd3P99a2veNz8duutPfn99604HA4aNWpC+fIVvB3S5fl5OEHJDuJrvuLtSAoV41D6roKuMtkXVs9vlzLrCiAy8sqWYRcU+VbzKi0tjejoaEJDQwGYNWsWu3fv5tSpU5w+fZrq1aszdepUgoKC6N27N507dwYgODiYsmXLcvToUWw2G0FBQTRq1AiA3r178+yzzxITE0ORIkU8Y2W1W9DEiRPZsWMHP/zwA+3atfMk1fr27cuUKVMyJa9iY2Mz7Vpks9mynOUlIiJyqf7443c+/HABe/b8RVRUaUaPHk+TJs2y/KT8fALrtddeYcSIB5S4ugrTpk3zfG2xWHjiiazf3JUvX54FCxZctJ8WLVrQokULz3HDhg357LPPci9Q8Tq3OdTbIeTI7Xbz6qsv8f3331G5chUef3wCwcEXr2M1fPh91KhRk4SEBNq0aZ8rM3MWLXqf1au/TD9ITCT41N9Y7ReWkZhMZhIcoRiuzImp4jVu5NSeH3A6kgmvcB2G+dLfkjgdyRgWG2ZL+uY4zrRU7EERhIXasfiFYHEGEFKyJslxJzh3ZOuFeMxWbP7pM6xs/qFUuv4eT3/H/vyK1IRTBAeUw89aHBz/GfSfBLbFci69L8N7tYb27fub479vIs2ZRmD5zTRo0Ijlyz/y1Oz77rvV3H33vVc8i+ipp8axc+cOIH3G3pNPTrrota+88gJ//bUTgBkzptK4cVP8/ApGPa6mTZvz1lsfcPZsDBUqVMJc0OpH2Yvidqrea667jL9Fkv/y9LszaNAgTCYTZ86cwW6307ZtW5577sI2jlu3bmXp0qWEh4czZswYXn31VcaNG0evXr081/zwww9s2bKFqVOnsnHjRkqUuFBgzGazER4ezvHjxzMkr7LbLSg6OprSpUt7zpcoUYLjx49niv3dd99l9uzZGc41bNiQDz/88IpqbYhvyq+CpZL39L0UX7d3717mzZvHxo0biYiI4JFHHuGmm27K8QVzmzYtaNOmRbbXiEjuOTvoG2+HkKONG3/m888/BeC3335l6dJFDB588VUEJpOJVq3aXvTxy/XFF5+zaNH7Gc6lJsYQUbkVzrRUEk7vB9y8+lE5cLtwOb8ivFwTbAHpr9cttoDLrnPldrs5tuML4o7vxGwLIDAohJTE9Jo/KXEnqHDoOiIqNgfAZDIoXq0dQREVOPHXGgyzleLVO1I+5LdM/ZqtfpSq2w2ACpA5cQXYA4sSUel6zLa3sfqFElGpMynRPxEfH09KSkq2s5Ny2wsvTGPvXjtgJyDgGT766FOKFy/Bvn3ps82CgoIJDLyyWjRpaWmexBXA9u2/Z3t9cnJShrYORxp+BWi/g4iISCIiIr0dxpWp/xwJeVjzyul0Zrm5SWHniorydgiSjXxZNrhjxw6GDRtGgwYNKFr0wqcAN998MxEREcCFWVTjxo3zPL58+XKmTZvGK6+8QrFixbLdBejfsrvuYjsM/degQYPo0SPjenbbPzuQ5FXBdsl/eVmwXfKXCraLrzp+/BgfffQh69b9QEBAIAMGDOKmmzpjs9k5cybR2+EVOFdasF1yx5QpU9i4cSOQnpAtVaoUfv+8W925cycbNmzIUDJC8obTmXHXu7Q050WuvNpxnJhMJk6cOM6ePX9RrVpNIiMjWbDg7UyvqRPPHCC8bCMMw+KZEXL20OZ/PX6QCi2GXvJW8f+VHBtN3PH0WT7O1ESS//Pn05TF6/nAohWo0Dzn5WBxJ/7i5O4fMCxWStS4Gb+Q4pmuCS/XhPByTQBwJJ3j2MFdHN2XxqhRw3jhhVmEhOTPjL2EhAvLPZOTk0hLS+PBB8cQFPQ6sbGx9Ot3xxUn0ywWCw0bNubXX9OXzDZtel221w8deg9Tpz5DcnIyd945NNvZf1JwrFnzLT/++ANut5vlyz+iR48+3g5JBMinZYM1a9bkscce48knn6RevXqemU//Tjq5XC5PEsntdjN9+nS+/PJL3nnnHWrUqAFAyZIlOXnywvbhDoeDmJgYihfP+A9MVFQUp06dwu12e6ZFHz9+nBIlSlCyZElOnDjhufb8+f8KCQm55C23RURE/uvcubMsW7aE1au/wmw26NatJ1279iAoKP93ZxHJLU8++aTn63bt2vG///3PsxFPtWrVvBVWrioyvz4AMXf95tU4stO0aXNat27H2rVrqFixEr163XZJ7RwOB6+++hK7du2gceNmDB16z0WXEH777de8/PL/MJlMuN1uUlNTCQoK5uWXXyMsLIwzZ05nuN79T0LN5bqQSHt6+H4AJs0tT1pKHC6nA7PlyhIr/62LZbHYsQTbSUpMwGIPYkfZH7DafuO61Hsu2sdP/5eejLmu00+ecy5nGsd2fIHb5WR/9f3sYQcdmJ5t+8rVZuL6534PHz7Ejz/+QOfOXa/ovs5zOp3ExcUSEhKa5Qfr5w0dOhzb6btwu10cdj6HzWbDZrPxyCPjr2r88555Zirfffc1VquN1q3bZXtto0ZN+Oijz3A4HJ4ktuSTn4YQnOwgrtZrud71W2+94UlOz5//Bt269fS5ZZUffbQIt9vFbbf1z/Lx6Oij3H33QCpUSN+wLT4+nl69bqNr1+4X7TM2NpbRI4fx1tQZuMqWY8eO7bz88gu4XC6GDRuRIZnrdruZMWMqBw7sJzKyGE88MQGbzcaAAb0pUiT9A5z+/e+kRYvrc++mJf9qXnXp0oWlS5fy7LPPMmfOHAC++eYbRowYQWBgIEuWLKFt2/TpzFOnTmXLli2eJYXn1atXj7Nnz/Lrr7/SsGFDli5dSv369TMlmXLaLei+++5jxIgRhIeHs3jxYjp06JBPz4KIiBR2SUlJrFy5gpUrP8HhSKVt2w706tVPs1HkmjBr1iy2bt3K2bNnueuuuxgwYADLli3jyy+/5I033gDIcDx+/HjOnj3LoUOHaNOmDWPGjPHyHYDLknnWjTedO3eWc+fOebauP89kghtuSC+Q/cYbsy+pjtXhw4fYs2c3kL4z9+eff0qRIuFUrlwlU8Jk7drvcTozzuiKj4/juecmUrRoBGfOnCEpKZGUlBRMhkFEpZbEHt9Fwqk95yPkRIw/7n+SWUGRlS87ceV2u0mMOYhhWPAPK0Vk5dacPbIVa0AYocEBGCYDx/EjOBLP4Iw+gb2IH2RTRz0gOKvZrm7PzoW2ZBuG04bDFothWDHb/LNsb7Fn/BBizZpv+P333y7r3v4tNTWV3377lcTERIKDg6lXrwEWy8XfpnVsUBHcsPe33Zl+LnLTxo0/5XzRJXK73Zw4cRyXy0WxYsXx87PhcOTNjMFrQadSf+FyuflyZe5//xMTEzxf+/v7Z5tM9YZZs2aydu339O7dN9vr6tatz3PPvQBAcnIyQ4cOuGjyavfuv5gxYypnYs+BNX030rlz5zB58jRCQkJ56KH7MiSvtm7dgslkYs6cN3nnnTdZt+4HGjVqQunSZZg+/cXcuVHJJF8rkj311FN069aNtWvXAhAREcGwYcOIiYmhSZMm3HvvvURHR/P+++8TFRXFkCFDPG3vvPNOevXqxezZs5k0aRJJSUmEhYUxfXr6JyPHjx9n+PDhzJ07l+LFi190t6Dq1aszcuRIBg0ahMPhoF69etppUERErprD4WD16i9ZvvwjYmPP0axZC/r2HUBUVClvhyaSb8qUKcMzzzzDjh076Nu3L7fdlvOMoOTkZD7//PN8iO7SnBv0pbdDuGRHjx5hz57dmM1matasnWOSPC0t43LDpKQkkpKOYLfbKVeufIbHLpYMs9vtBAYGUr9+AwD2799Hiis9uXTkhzmeZJXJMHj9owuJwJCoy99w4nyNK4Dwck2JqNSSImUbApB44BtSU5JwJMYAELUrCv+wktDw4v3VvX5bpnOG2Upk1Tac3P09pfdWwL9IafZtnw8mg5I1bya4eLVM7d3uOiRGbyEtNZFSpUpnKItyJaKjj5KYmJ4Yi4uL48SJ49n+2/H1llZXNZ437Nq1k2PHogE4ceI4jRs39nJEBdvqE63yLPlXvXpNtm/fhmEYPPHExCz/FoSe60yyfQApfgPA7SA09laS/e4kxd4P3ImExvYm2e8uUuy9MLnOERJ3O0l+95Jq74bJdZqQuIEk+d9Pqq3TReOIjY3l6afH43K5KFKkCLVq1eG22/pTv35DKlWqQnx8esmQxMREXnhhGk89dfHNBeLiYrFa02dvjho1nPLly7Nr104aNWrKvfeOIi3NwXPP/Y9HH30QV8n0ulcvvDALs9lMdPTRTEtx69dvSJ069QA4deoktWrVZs+e3Rw7doxRo4YTFVWK0aPHaUZiLsuz5NWuXbsynatYsSLbt28H4LfffqNatWo8/fTTGa4pWbIkO3fuvGi/devW5eOPP850vnjx4lStWtVTlyq73YJ69eqVoSi8iIjIlXK5XKxb9wNLlizk5MkT1KpVh9tvH0jlylW9HZpIvuvSpQsANWrUIDU1lfj4+Bxa4NlFWrIWGhpGaGgY48Y9leF8cnIyvXrdgtvtJi0tjbNnY3L8xP/MmTOMG/cQhw8fynC+bt363Hvv/RnOdejwC7Nnv4RhGLRq1YZffvmJv//ey86df9KpU1fat78RgOnTJ7Pn0CkATIYFSPmnh/+84XVl/UY7OfYYjpR4AsPLYZitFy53pXkSVwDnov8golLLDG0tVhtmWyDO1PSZIv5hV1ZsuUjp+oRF1cWZlsLfP76eftLt4vT+nzMkr84zmUyERZamcpmITN+XK/HZZ8uZM+cVz3HXrj3o0OGmq+7Xl/Tv39PzdUxMDJMmTeLs2WQvRlSwRUYG52m91/Mz+urXzyYbnMc+//xTWrVqS8+efXjppf95zt9wQxtWrbqwy29AQECWiatt235j1KjhnDp1ivDwcMaOvbDLcMeON/PII4/x8MMjiY4+So0atTK1N5vNbNjwI88+O4nbb78jy8cfeeQBjh49zODBw4iJOc2ddw6lffuOfPjh+yxZspA77xx6tU+D/ItvzQG8CklJSVx//fUZdh0UERHJK263my1bNjF+/GheffUlAgMDeeyxZ3jyyUlKXMk16/xSp/Of1J+vP/rv4t4OR8bt3AICslnn5QXh82sTPr+2t8MA4IcfvuOnnzawefNGDh48kOExwzAy1KE5P6sgO+Hh4bz++tt8+umnVKuWXlO2SJFwunTpnunaRo2a8vbbC5k//3369r2Dv//eC6TXZnr//Xez7L9kzZux+odh9Q+jeI0bmTLqCJNG7CMwoiKBRTMXTj93dDsHN31I9O+fcejXjzyzttLvz4LVP8xzbA/MPLvJmebAP6QE9uDiHG2VwF/Vf8v2/tevbMH6lRffvfUn/7nsa3jheTbbMv5s/re9y+Vi0qSn6NbtRh5/fEyG3fcuR6dOXQkNvVDwfcOGH7O9PjjuboLj7r6isbylZs0LM++qVq2O1WrN5mrJ0fo7CP7dez8D50JXpc+6AjBZ04/t/f45DvjnOH2yiNsI5VzoKlLt3f45Lpp+nM2sK4AjRw57/k7Vq1f/smOsW7c+s2fPZcaMmcTGxlKyZMn08Ewm6tWrj8lkolq1Ghn+tppSUzEO7PccN29+PcuXr2L9+h8z/Q0GeOGFVxg9eiyvvvoSZcuW9yzlbt68pedvpuSefF02+G/3339/zhddBn9/f2699dZc7VNERCQru3fvYuHC9/jzzz8oVqw4998/mubNr/e5uhAiviA8PJzdu3eTkpKC2Wzmu+++83ZI2XLayns7BAASEhJ4/vnnSEtzkJycXufl+edf9jxus9l49NHHmDfvNfz9A3jwwUcuqV+z2UyJElG0b38j/v5+VKxYhTlzXiYhIYHBg++mQYPMM+GsVitBQUGemXQX+7A4ILwsFZpfKPsRZ22J2+KiVN2sX6PHHrswsyol7jipiWewB0V6zpWu35MzBzZiMswUrZBebyYl4TQmk4Hb7ebk0b89hdNt58yE+JfM9t5DwmOzPJ+WmsjhXz/CWeoIAdYQ7CElsFj9CStdnxN/fYfFHkyRMg0ytT9+/Bi7dqXfw5Ytm1i58tMc6/BczLlz5zxf//nnH9le6zRXuaIxvGnMmMepUaMWqampdOmSN+/Z/r1ZV6EXXA2nOSXn6wqwcuXK8+ef26lVqza7d/9FWFjYFfVTtmx5brvtdl54YRpTpz6P2+1mz57dVK5cjd27d9GtW48LFxsm+GeJ4NixD/H001MICgrCZrNn+LBg3bq17Nu3lzvuGIyfX3pdsE8/XU5ychIDBw7ht99+pVKlgvd76uu8lrwSEREpaI4cOcSiRe+zcePPhIaGMmTIcNq374jFok+QRS6mZcuWNGnShE6dOhEZGUmzZs2yLC/hK84NXOntEABwOtNIS7swSy2rWT2tWrWlVau2l933unXrmDMnPRH2229bPOcnT36KRYtWeMpwnGc2m3nmmam8/fY8/P39ue++BzP1mZJwGkdSLDGHNgNQrHJrlm/tkek6gPhTf+NIjsXqH0rS2fQljIbFD4s9OMN1Vv9Qile/sLHSyT0/EHMwvf+QsGKexBVAyb9KUKFo1uOdV7vF9izPnzv6O6mJZyi5Oz35FVq1JsHFq7Fvw9u40tKXtjkdidRukf2Oa+dnGc6dO4e1a9dQtWp1xox5HH9//2zbWSwWGjVqwubNG4H03SSzkxgwLtvHfZHdbr/kXTEv1759fzNx4hOcPn2afv0GMGDAoDwZx6fUeYrEbJYNnjlzmq1bt1C+fEUqVKiYj4Hlnq5duzNp0lOsXfs9LpfLM6vpvy6l5lWXLrfy2WfL2bIl/e/HggXvEB0dzfXXt6JUqdKe69wWK64S6X8HevTozejRozAMg9at21GqVGk++WQZxYuXoEmTZnzxxeeMGjUcq9XKuHFPEhZWhGeeeYxRo4YTHl6Uxx57OstY5MopeSUiIpKDU6dO8vHHi/j+++/w87PTp8/t3HJLN/z8sn9DIlKYffvttxmO/5uQ+vfxjBkzsuxj2rRpuR9YIRESEsoddwzm/fffwWQy0bHjzZmuSV++vBmTyZTljKmLOXToUJbnk5KScDhSiY4+yrFj0dSpU8+zrLN27bq88MKsLNudPXWE+L0Zi6Ef3b4ywyys82IO/crJ3d8DYPELIbx8M5ypiYSWqovZevHixm63y5O4AoiLPY1/YChJCekzlkJLXX5B+PPMlozjmq1+OJJjPYkrgJS4E5naFS9egoiIYmza9DO1a9flllu68ssvP7FiRXp93g0bfmTZsiWXlEx5+ukpfP/9t1itNlq1anPF95JbfvppPefOneWGG9r43NLe/3rrrbkcP34MgPfff4d27TpSsuTl1z/bsWM7v/++lbp162dZA6mgOHPmDKNGDScm5gxms5nJk6df1t8HX+Hn58ezzz4PwKpVn3kKtAN07tzV83VWNa9Klozy7DQI6cus5817z3M8fvyT+PsHZhrznXcWer5u3vx6mje/PsPj5ctXIDk5GZvNxuTJmf/90k6DeUvJKxERkYuIj49jxYqlfPnl57jdbm6++RZ69OhNSEhozo1FpEAKn18TgDN37fByJBd2B3S73bzzzptcf32bDDsKvvLKC3zxRfpOjV279uC++x64pH7btWvHO++8y6lTJ/H3DyA1NRWnM42+fQewbdtvTJnyDC6Xi/LlK/Dii69mm6hPS0sj/tzpzOdTE7i/zWwAZq0Z5TmfcHr/hWuSYwmMqIh/SIkcYzaZDExmK27nP7PR3C6KFCtD0bCOGBYbmyM+An6iZcqoi/ax7rP0gu8tu67LcD40qg4p8SfZWvr/sNgCqWKtitvlxB4USUr8SQCCilXL1N4wDB577JkMfaWkZCxCnpx8aUXJbTZblgnKrATHDQYgLvidS7r+cr3//jt88EF6XbPPP/+EF1+ck2HJlK/595J9k8l0RUv4d+zYzpgxD+JyuTCbzTz//CvUqFEzN8PMXT/2IzjFQVzddzI99PvvvxETcwZIr1G3bt0PBTJ55Q3G/n0AuMpnrtEHEBVVisjIYvkZkvyLklciIiL/kZKSwhdfrOSTT5aSlJTEDTe0oXfvfhQrVjznxiJSoKX5Zd5dzlv27fvb83VSUhLHjh3NkLxavfrLDF9favKqWLFivPbaW+zf/zdlypTDbDaTmppKeHi4J3EFsH//Pv76axd169a/aF9msxnDMOP6z26CERVasP/M4UzX+4eVJvFMeuFjsy0A27+KsufEbPUn7Z/kldvtxu12EVCkDABFXGVzbF+kWEyW502GQfHqHShtTUw/dpgwmS2UaXgbCaf3YfELxj80iiKHs27/b82bX0+TJs3YuPFnypYtR48evS/19i5ZmqVurvf5bxs2XEju7d79F6dOnaR48ZwTjN4ybNi9nDhxnFOnTtKv3x1XFOv27ds8P/dOp5Pt27f6dvKqSH3SErKueVW+fEUsFosn+V0YNpH590yrqzV79lwsFoO0NFemx9w5LPFV4sq7lLwSERH5h9Pp5LvvVrN06WJiYs7QsGFj+vW7g7Jly3s7NBHJJ7EDlns7BI+2bdvz88/rgfQ3pBUrVs7wePnyFdizZzcAFSpkPVPgYoKCgqhdO3MSpFy58qxb9wOQXqeoRInsi6CbTCYiSlYgPikNw2KlSNnGWO1BWOxBfLatYabri5ZvitUehCM5luAS1bNdKvhfAUXKEBudXszcYrVjGBdmA9V0dMuxfc1m2c+m+28fhsVGcPELycyc2kN6cftJk6aRnJyMn9+l39vlSPIfnSf9nlezZi3+/nsPACVKlKRIkfAcWnhX6dJlee21+VfVR9269TGbzTidTiwWS7YJW59QazxJF6l5Va5ceaZOfZ4ff/yBSpUqc9NNnfM5uILL7cNJWlHySkREBLfbzc8/b2Dx4veJjj5KlSrVeOCBRwp0zQsRKfhat27H119/QXJyMpMmTcuUDJk48TkWLfoAwzDo129ArozZv/+dWK1Wjh49QseON1/SjFObXwClq7W/5DFCSl7ZjJbi1dpjD4rElZaCzXXWp3eWy6vEVX64555RlCpVmtjYWDp16pqpgH9hVL16Tf73v1fYvn0bderUo1q1Gt4O6arUrVvf9xNwIpdJySsREbmmbd++jQ8/XMDevbspXboMjz76OI0aNfHpN0UiknfC56fPtDlzl2/siBgcHExwcHCWRbPDw4te8lLBS2U2m+nX745c6euhduk7Gr70bebdCa+EyTBTpEwDABIPfJPhsbX29LFuSLn4WGtX3JB+Tfe1WT+eQx85tc8vIXHp35/Y4PfzpH+LxUL37rm/3NHXVa9ek+rVfXip4L+t7UVIShqx9fLmZ+BaZfyzVNtVQHdoLOyUvBIRkWvSvn1/8+GH77Ft228ULRrBvffeT6tWbTIsQxGRa0+afz1vh1Bo7D5ROeeLckmEM+exIqJOXVUfObXPLw5LU2+HIN4W0RxHfNY1r+TKuQMz70AovkPJKxERuaYcOxbNkiULWb9+LUFBwdxxx2BuvLHzNbEsQkRyFtt/ibdDyOD661t7O4Qr9vn2W/JtrBppOY9Vo+mfV9VHTu3zS5J/7s62kwKoxqMXrXmVG3zh705iYiITJjxBXFwslStXZfTosTgcDnr37krZsuUAGDXqYVwuJzNnzqBSpco89tjTJCUl8eqrL/Hoo49l6jM+Pp4XX5zBiRPHSE5OpkuX7tx6a09+/XUTa9d+z4MPPuK5dv78N6hSpRqtWrW56nsZNWo4TqcTs9mMw+EgPLwokyY9h9VqvWibWbNmUq9eQ8/4r7zyArt27cRkMjFx4rMULRoBgMPh4OGHR3ra7dixneXLVxEaGkZ09FGee24Sr7zy+lXfgy9Q8kpERK4JZ8/GsGzZEr755ivMZjPdu/emW7ceBAToUzYR8V0tW7bydggico3xhb87n322nDp16jJw4BDeemsu69f/SEREJG3btufhh8d6rps5czqPPfY08+e/QWzsOVau/ISePftk2ef//vccN93UmRtuuIHk5FTuv/8eatbMn/qmM2a8RHBwMAAvvjiDn39en2WSMC0tjcmTn2bHju3Uq5e+6cWGDT/idsOrr85j8+aNHD58yJO8slqtzJ49F4AVK5bSpEkzQkPD2LTpF95441UcDke+3F9+MLwdgIiISF5KTExk8eIPePDBEaxe/SVt23bk5Zdfp1+/O5S4EpFMwt+qTPhb+bfcrTB7pMMLPNLhhXwZ6wf7C/xgz36sH5a15odlF59RklMfObXPLyGxfQmJ7evtMMSbvu9GyBbv/Qx0X9GZRTs/AMDhdNB9RWc+2rUIgERHIt1XdGbF7qUAxKaco/uKzqzc+ykAp5NO031FZ77c/3/ZjnHo0EEaNGgMQM2atfnzzz/Yu3c3O3b8wciRw5g1ayYul4uAgEAcjlSczjQcDgfHjx/LtDMrQEpKCvv376N585ZAem23559/mUqVqniuMf7ei/H33gztzpw5zUMP3ceoUcN54okxJCUlcc89Q0hLS+Onn9Zz771DAXj33fls2PAjc+fOYd8/tbOy4na7OX36FMHBIaxa9Rnjx49m1KjhjBw5jJiYMzgcDrp0uZWbb74wE3TLll8JCAjg4YdH8tVX/5flhkLJycl89tkKbr99IJBev3DmzNnZPscFjWZeiYhIoeRwOPj66/9j+fKPiYuL5brrWtK37wBKlozydmgi4sPSAlRPKLf8cTT/dmwt7sx5rOLljl1VHzm1zy8Oq/cTaOJlxdvjSEj2dhR5qkKFivzyywZq167Dxo0/YxgGJUqUZPjwETRpch0vvjiD1au/okeP3rz22iyaNr2O//u/ldx88y3MnDkdPz9/7r13FIaRPl8nLi6W8PDwDGMEBQVlOHb/MzPq395772169ryNVq3asGTJh3zyyVLq1q3Pjh3b+fXXTSQnJ5OSksy2bVvp1+8Omje/Psv7GTv2IVJSkklMTKRbt57Uq9eAI0cOExwcwrRpM/nii89Zvvxjhg4dTpMmzdi27TdP29jYc7hcLl588VXeemtulrPLVq/+gvbtb/SUwWjQoNFlP+e+TskrEREpVFwuJz/++ANLlizk1KmT1KlTj379BlKpkmZSiEjOYvst9HYIhcYXO27Ot7GqpeU8VrVG2e8gmVMfObXPL0n+93k7BPG26g/mac2rnKzovsrztdVszXAcYA3IcBxiD81wXNS/aIbji+nSpTszZ05n1Kjh1K1bH39/f2rWrI3Fkp7CuO66lmzb9hs33ngzEyZMJSEhnrfemseuXX/SqFETjh49yqZNv9C06XUAhIaGcfp0xk0Xdu/ehZ+fv+fYHVksUxyHDh1k4MDBQPoMsP/7v89o164jv/66icOHD9G+/Y388stP2O127Hb7Re9nxoyX8Pf354knxmRIotWrVx+AGjVqsWHDuizbBgeHUKVK+k64TZs254svVma65ocf1jB27JMXHb8w0LJBEREpFNxuN5s3b2TcuIeZM+dlQkJCeOKJiTzxxEQlrkREREQKkJ07/+SWW7oxe/ZcnE4ndes2YN68OXz33WoAtm7dkuH13bJlH9Or122kpKRgGAaGYSIpKdHzuNVqpXz5ivzyy08ApKQk88IL00lISMg2jtKlS/Pnn38AsGPH70RFlaJu3fr8+usm/P39adCgEW+/PY+mTZvleE8Wi4Xx459i7tw5nDqVnkjbs2f3P/e7w1OI/r9q1qzFr79u/CeG7Zmuc7vdnDx5goiIiBxjKMiUvBIRkQJv166dTJjwOM8/PxWHw8GDDz7KlCnPU6eOtrwXkctT9K0KFH2rgrfDKBTG3jiDsTfOyJex1thnsMae/VhrPm7Lmo/bXnEfObXPL6GxPQmN7entMMSbvutE6K+F+2egVKnSvP76bE9NqXr16nP77XeycuUnjBo1nNjYc7Rt2wFI30UwLi6WqKhStG7dng8+eI/163+kSZPrMvQ5evRYVqxYyogRd3PffcPo0qUb1avX8Dxu3rsH8949GdoMHDiEZcs+4r777mbz5o306NEbq9VKYGAgderUo3r1Ghw6dMizXDCnmldFioQzYMCdzJ37KpD+GvaBB+7lyy//jz59bs+yTatW6X937rlnCJs2/UzXrj04duwYL7+cXqPv7NkYgoIyL3ksbExut9vt7SAKmpiYBNLSXLnaZ2RkMP3HfpCrfUr2Fs4YwMk8mm4bGRnM5hl350nfklmjsW/m2fdSfNuhQwdZtOh9Nm/+hbCwIvTq1Ze2bTt4ppRL4WOxGBQpokL717rTp+NxufLmJWzwksEAxN32Tp707wsiI4Nz7d/N6dMns+fQKQLKtc/0WIfqXwOwemfHXBnr3xIPfAPgGXe3JX2sKmkXH2v3lvTCzFUa7M768Rz6+Hf7xAPfULlMBOPGPXUF0V8dv+R5ACT7Dcv3sXNLbv4MXosiYxYQF59Mcpn8+xk4duwAJUpkPTOooLFYjCzfz5tOnQTAHRGZL3GsWvUZ8fFx3HZb/8tum5aWxnvvvcXQocPzILKM/vu9NwwTRYsGZdMib+jVvYiIFDinTp3ko48+5Icf1uDn50ffvgPo1Kkrfn5+3g5NRAq4wpy0ym95kbS6mOySVp5rLpK0utQ+cmqfXwpy0kpySdX7SFbyL9flV9IqNzidTnr1us3bYeQrJa9ERKTAiIuLZcWKj/nqq//D7XbTuXMXunfvTXBwiLdDExERERG5ZJ07d73itjkViC+MlLwSERGfl5yczP/932d8+ulykpOTadWqDX363E5EAfqETEQKhqJvlwXg9JCDXo6k4HAmn/Us4/u3iXd+AcAz7+X+roPO5LPAheWD68qmj9Xy4MXHWrfm0fRr2vwv68dz6OPf7dPH905x5NDYbgCcC/nUK+OLD/imA6EOJ+ca6WcgN5n/KZ7urFzFy5FIVpS8EhERn5WWlsa3337NsmVLOHs2hkaNmtKv3x2UKVPW26GJSCGVGpz7iZbCrEyZi9fA+etoHQAql8n9JM+5c+lvY0JDwwBItOQ8VmK9Hdlek1Mf59vXqFgchyMi23vPSym2wl2oWy5Bub6kxCV7O4pCx1WkiLdDkGwoeSUiIj7H5XLx00/rWbLkA44di6ZatRo8/PBYqlWrkXNjEZGrENd7rrdDKFD6978zx2va5H0Yl+mmq2odGdnbq8XGk/0Ge21s8RGVh6nmVR5wF/XObEq5NEpeiYiIT/n99618+OF7/P33XsqUKcuYMU/QsGFjTCaTt0MTERERkQJg8OD+vPPOQl5++QWGDRtBQEDAFfc1f/4brFnzDaGhYbjdbhwOB888M4VSpUpftM3atWvYsmUzDzzwCDt2bGfOnFcASEiIx2QyeOut9z3XHj58iKlTn8HpdNG+fUf69h3A8ePHmDjxSVwuF506deHWWzXjMs+SV9WqVaNq1aoYhoHJZCIpKYmgoCAmTJhAnTp1LqmPH3/8keeff55PPvkEgBUrVvD22297Ho+Li+P48eN8//33RERkzJIuWLCA119/3XM+MDCQhQsXAvDxxx8zf/58nE4nzZs358knn8RqtebGbYuIyBX6++89fPjhAn7/fSsREZHcd9+DXH99KwzD7O3QROQaUvSd9Dcjpwcf9nIkBV/ouc4AnAtdledjdV+RPtaK7hcfq3t3//RrViRdUR/n269bd8Vh5or8fF7FR61uk17zqrF+BnLy4IOPXPK12dW8GjbsPlq1agPAmjXfsGzZEu6/f3SW/Sxa9D6ffLKM665rCUDNmrWZPTt9Vu+ECU/Qo0efDNcvXbqEAQMG0bJlK+6++066du3Be++9xbBhI6hbtz4PPHAv7dvfSFBQ0CXfS2GUpzOv3n33XcLDwz3H8+fPZ8qUKSxevDjbdsnJybz22mt88MEHlChRwnO+e/fudO/eHQCHw8Edd9zB8OHDMyWuALZs2cL48ePp2jVjBf+//vqLWbNmsXz5csLCwnj00Ud55513GDZMW86KSGYhoXbsNpu3wyjUDh8+zNtvv82aNWsICQnhzjuH0rFjJ32oICJekRLa3dshFBrJ9gH5Nla/6jmP1a+f46r6uNDeu4tX8vN5FR9VcTDJXqx51b27P/36OejXLw2HA/r08WfAAAd9+qSRmAj9+/szeLCD7t3TiI2FO+/05+67HXTpksbp0ybuusuPESNSuekm50XHWLXqM9avX0tCQgJ+fn5UqVKNDRvW0bBhY0aMuJ/163/kvffewu1206dPPzp0uIlVqz7j448XExUVRXJy+vMzatRwnnvuBbZv38aHHy4gNTWVChUqMG7cU0ydOgG73c7+/fsICQnl2UfGsWb9j6T+vZcbb7x4/cOTJ08SHBxCdPRRJk9+GqvVRmzsWR56aCz16tWnTJlyPPLIeNatW5uh3Z9//oHL5aJevfoZzletWo24uDgcDgdutxur1cpff+3kkUfGYxgG1avX5K+/dtKwYeMr/6YVAvn2lzctLY3o6GhCQ0MBmDVrFrt37+bUqVOcPn2a6tWrM3XqVIKCgvjxxx9JSkri2Wef5ZVXXsmyv3nz5hEeHk6/fv2yfHzLli0kJCQwf/58ihYtytixY6lWrRrffPMN7dq18yTV+vbty5QpU5S8EpEs2W02Br/9oLfDKJSciQ7O/X6ShD1nMJkNQupE8v7U+SQmurwdmohcw+J7zPZ2CIVGip+vJa/SrqqPnNrnl/x8XsVHVRxMyjVQ8yooKJgpU2bw+ONjqFChIoMG3cXgwbdzzz0jefPN13jttfmY/5+9+w5vsmoDOPxL0qQ73YtSKGWUvadsQUFkiExBQEWWAg6WKCDKFMTB9AMREBmyBEFAEAEBUUT2KpRRVvceSTO/PyKB0JFS2qSUc1+Xl82b95zz5E1akifnPEfmwMiRQ2nZsjUbN65j6dJVpKen8frrlr8nd+/eZs6cr3B0dGTw4AFkZWUCUKtWHcaOncj7748kKiODNl1eyjWWZcsWs3bt98TGxtC8eUveeusdUlNTSE5OYtWq9SQmJjB79nS+/noxzZu35MSJ4zn62LRpPf36Dchx3MvLmxkzpvLdd8to0qQZcrkcvV6PVCoFwNnZmaysrMe8mk++Yk1eDRo0CIlEQlJSEo6OjrRt25ZZs2aZ7z99+jSbN2/G29ubcePGsWjRIiZMmED79u1p3749f//9d679JiUlsWLFCrZs2ZLr/VlZWYSFhTFs2DDq16/Pzp07GTJkCLt27SI6OpqyZe+vTQ0MDCQ2NjZHH2lpaaSlpVkcUygU+Pv7F+ZSCIIgCP8xaPSkXUgg42ICRoMRt8reKGv5I3N2wNXVlays0v9mTBCEEiz7vw8IjoWvjyL8x/jfTCVJ8c+k1epNY8lleY+l/S+cvCb2WutDm//ELdux4XUVSiiD1vSf1D6vgQeX3srllrddXCxvK5WWt318jHku3X1YhQphgKkEUNmyIchkMmQyB1JTU4iJiWHMmNEAZGRkEBkZibe3L3K5HG9vHwIDgyz68vDwZMaMqbi4uJCWlopeb7AYw8fHF41aDQYD/Jc0etC9ZYOrV6/kzp1buLi4kJqaQvXqNVAoFAQFlSEtLSXPx6LT6bh58yZVq1bPcd/SpYuZP/8bypcPZcqUiZw5cwqZTIbBYEAqlaJSZeHq6lqga1aa2WTZ4IULFxgyZAj16tXDx8fHfH/Hjh3NS/569uzJzJkzmTBhgtV+N2zYQLt27QgJCcn1fhcXF5YvX26+3alTJ5YsWcLZs2cxGo05zpfm8uJctWoVCxdafvNWv3591q1bh5eXeOGUFn5+7vYOQSgi4rks+Yx6A+kRSaSfi8eg0eNS3gNlXX/k7o4W54nnUhAEe/JZVwUQNa+KgkdaN8A2tZl6bTeNlV/Nq1698q95Za2Pe+3tXvPKhtdVKKF+f+6pqHmV12Y9SqUHZcuG8NVXi5HJZKxevYIKFSoQHx9LdnY22dlq4uIsJ6gsXjyfDRu2kZ2t5tVXe5nzAg+OIb19C5lMlmvNq3tefXUQb731JocP/0HFipW4du0qBoOBuLhY3N2VebaLjLxCWFjFXO9zc3PD2dkFqVSKl5c3mZmZVKoUztmzp6lZszYXLpzjtdfESjGbLBusXr06EydOZNKkSdSpU8c880kmu1+E915WsSB27tzJpEmT8rz/zp07/P777wwYcH9KntFoxMHBgaCgIOLi4szHY2NjLepq3TNo0CC6d+9ucUzxX92b5ORMdLqiXdYiPqzZR3FtcyyeT9sTz2XJZTQYybyeQtrpOPRZWpyC3PCoG4DCxznX8+25/bhQ8jk4SMWXSEKxyvbsae8QSg2100CbjdW/mvWx+vfPf+qUtT7ut7dzzSsbXlehhKr4Jur0gs1eKo1kMhn9+w9k1KihZGdraNWqDS4urgwaNJgRIwYTGBiEUulh0aZZs+a8+eZAXF1d8fPzJykpMUe/Bg9P9l08n2/NK4lEwvvvT+CTTz5i1qx5aLVa3n9/JJmZmYwZ80GeMd+5c5uAAMu8w4cfjmPmzLm89dZoPvnkQyQSKeXLV6BJk2ZUqFCRGTM+Jisri86du+HuLj6TSIy5TUUqAuHh4Rw9etSiYPvrr7+Os7MzixcvZsGCBezYsYNNmzbh6urKe++9R4UKFXj33XfN5//9999MmzaNHTt2mI+lpqbSunVr/vnnnzyL+SYlJfHcc8+xYsUKateuzcGDB/n000/ZtWsX165d46233mLjxo14e3szduxYKlSowMiRIwv82IoredVv/Joi7VPI39o5/Ys14fHvnDeLpW8hpwbjvy3W59IeNa/iz97h7j83zLf12To06Wrcy3qhU99/852dqkIZ4kXVng1y9JF4KYY7R69h0Btw9HCmUudayJ0VpN9N4dqucwCUaxOOV0U/AG4fuYrcTUFAndxntT4qo9GI+nY6Kadi0aVmo/BxxqNeAE6Bee+UsvL1r0XySsiXSF4JAImJGRgMxfIW9qng5+cu/tY+BnH9Hp+4ho/HHtcvJiaKwMDyNh2zuDg4SIvk83x09F3mz5/HrFnzCtV+6dLFDB361mPHUdwefu6lUgk+Prbf+dCmXxtMnjyZrl27cuiQqeq+r68vQ4YMITk5mUaNGjF8+HCrfURFReHn55cjcXX27FkmTZrEtm3b8Pb25quvvmLKlClotVrc3NxYtGgRCoWCqlWr8vbbbzNo0CC0Wi116tQRxdoFQShx/GoF41crGACD3sD5NX8T3LQCAfXKmc/JiE4l4qeTVHg+59r5jOhUru+9SM0BTXDydOHGbxe5dfAKYR1rcPev64R1rImjhzOXNv2LV0U/slNVpN5IoHq/xkUSf3ZcJiknY9HEZ+HgrsCnZQjO5ZR5Tv8WBEEoMdITTP93z7mbtfCIjP/VD5MUf/2wLK1pLBd53mPdq3fskscp1vooMfWSbXhdhRJKlwX6LJCJ10CR0v+3++EDK8SKU/fuYqbvoyi25FVERESOY2FhYZw7Z/q2/9SpU4SHhzNlypQ8+2jSpInFrCuA2rVrs3fv3hzn1qpVi4CAAPPtli1b0rJly1z77dGjBz169CjQ4xAEQbC3u39dR+7iaJG4MugNRO44Q2i7ajgqcy6/iz9/F/86wTh5mt7UlG1RyTxjSyKTYNDqMWj1SGSm5dpR+yMo1zb8sZNLmmQ1qadiUd9JR+rsgFeTMrhW9EIiFUkrQRCeDD6b6wKi5lVR8EgzfTCzRW2mfr+Yxsqv5lW/fvnXvLLWx7329q95ZbvrKpRQBzo9FTWvbE12/RpAvjWvHhQUVKbQs64A/PzEZnCPwr4LtotQbGws/fr1s3cYgiAIRUqbpeHusevUfv0Zi+Nxp2+jcHPCJzwg13bqpExc/N25tOkE2akqXPzdCG1XDYCyzStxbfd5jAYDoc9WJeVGAlKFDPcynoWOU5ehIfVMHFnXUpDIpXjUDcCtqg9Sh4LVMrQVT3cFcidH6ycKRUKrziYlXWPvMAThkah9xPvJoqJ2GmyzsV6rYX2s117Lv+aVtT7ut7d3zSvbXVehhKo8AnXa01vzqrgYfMSM25LMbn95R40aVaT9BQQEWMy8EgRBKA1iT93Cu7K/eQbVPdH/3CCsY4082xkNRpIj46netxFyVwVR+yO4uuscVXvUx8XXjZqvNgH+W5K49hhVX65H7OnbJF+OReHuRGj7agVKPOnVOtLOxZNxOQkA9+q+uNfwReZYMr8bkTs5snPg6/YO46nR6fsVIJJXwhMms8sce4dQamQ72m6lw0uVrY/10ku6x+rDWntbseV1FUqo8n3IFjXDipzRy8veIQj5KFlfiQuCIAgWEi/G4Fe7rMWxzJg0jAYjynLeebQChZsjnhV8ULg5IpFI8K8VTMadlBznxRyPwrdaIFK5jOh/bhDesz4KpRPx5+/mG5dBqyf1TBzR2y6TEZGIawVPgrpVwbN+YIlNXAmCIBSENOkW0qRb9g6jVJAYUpEYUm0yVlp2KmnZ+Y+Vlmb6r7B9WGtvK7a8rkIJpUlFohWvgSKn15n+E0ok8QlDEAShhNKptahTsnAP9rQ4nnYrCY/yPvnWp/IODyRq/yWCn6mI3FlB0uVYXIMstwzWZKhJuhxLjf6N0WsN8N/msxKJKTmVG6PeQEZkMmln4zGodTiHuONRNwC5h9PjPVhBEIQSwuvnZoCoeVUUlOmvALapzTRwl2ms/GpeDRyYf80ra33ca2/vmle2vK5CCfVHN5Si5lWRk12/DhS85pVgWyJ5JQiCUEKpk7OQuzoilVlOklUlZ+HokbNI+80/rgBQrlVlvCv7o0lXc37NMTAacfRwpuILNS3Oj9p/mZBWlZFIpTg4SvGuEsDp5UeQuygIf7mexblGo5GsG6mkno5Fn6HF0d8Fj9blcPQTu9wIglC6qPzF0uKionKyvpN4UXmzlvWx3nwz/5pX1vq4396+H6FseV2FEip8NKpUUfOqKC1f/j8O7NuLp1KJQSZDq9Xy8cfTCQ4um2ebQ4cOcPLkv4wePQaAJUsWcOLEP3h5+fDhhx/j6elpPvfzz2dz44apIHxk5BUmTfqEsmVDmDnzE2QyKS++2JXOnV8qvgdYCojklSAIQgnlFuRB/eGtchwPe756ruf71SxDzL83zbcD65cjsH65XM8FqNyltsXtcq2rUK51FYtjRqMRdXQGqSdj0SarkXs64dW2DE5l3B57Z0JBEISSKKvTNHuHUGpoHLvabKzOFa2P1blz/suBrPVhrb2t2PK6CiVUyMtonETNq6I2ZPhIWrVqA8CBA/vYsmUDo0a9n+u569f/wLZtW2jatDkAly9fIjLyCkuXruLUqRP88MNKRo5813z+2LEfAHD1aiTffLOA5s1bMnHiGEaPfp8aNWoxduw7tGzZBg8Pz+J8iE80kbwSBEEoJdRJmQQ3rVBk/WUnZJF6KpbsmExkrnK8nymLSwUPkbQSBKFUk8aaZrEaAsSykcclMSQCYJT6FPtYiSrTWD7OeY+VmGj698vHx1ioPu619/MrdJhFwpbXVSih1AlINBkYFfZ5Dbz0kjN9+2rp21eHVgu9ejnTv7+WXr10ZGVBv37OvPaalpde0pGWZlpy++abWjp31pGYKGHwYCdGjNDQoUPuZSoAdu7czp9/HiIzMxMnJycqVw7n6NEj1K/fkBEjRvHnn4f5/vvvMBqN9OrVl/btO3D06BHWrVuNRqOhfPlQJk6cwowZU3F0dOTGjesolR7MmDGH33//DbVaw/PPd7QcVK8HnQ4cHIiPj8fdXUl09F2mTZuCXK4gLS2Fd98dT506dQkJKc+YMR9w5MghAG7duknduvWRSCRUr16Tb7/9JtfH9b//LWLEiNFIJBJiY2OoWdP0ZXKlSpWJjLxCgwaNiuZJKoVEwXZBEIRSwquSPwr3x689pU3NJuGPm8TtvoY2WY1nwyCCulbGNcxTJK6EJ87evXvp0qUL3bp1Y8CAAdy8eRO9Xs/06dPp2LEjzz33HOvWrTOfv379ejp16kSfPn24det+0e4hQ4Zw9epVezwEwca8drXFa1dbe4dRKijTB6BMH2CTsQb/OoDBv+Y/1uDBTgwenPe/k9b6sNbeVmx5XYUS6nBPlGdK/2vAzc2dL79chEQipUKFML755jv+/PMQBoOBb79dwtdfL2bRomVs2vQj2dlq7t69zZw5X7FkyXKuXIkgKysTgFq16rBw4VLUahU3b0bx7LPtcyaugG+/WcDwNwfQvXsnoqKu07t3PwCSk5OYO/crZs78nO++WwpA8+YtkUrvp1MqVAjjxIl/0Ol0/PPP32RnZ+fo//btW0gkEBZWEYDg4LKcPPkvWq2WU6dO5NpGuE/MvBIEQRAA0GVpSTsTR+bVZCQyKcpafrhX90Uql9k7NEEoFLVazbhx49i2bRvly5dn5cqVTJ8+ndatWxMVFcWOHTvIzMykT58+1KhRg9q1a7N06VJ2797N3r17Wbt2LRMmTGD37t1UqlSJihUr2vshCTagChL1hIqKynmUzcYaUdf6WCNGaB6rj/vt7VzzyobXVSihqo5BlWa/mlcPbnogl1vednGxvK1UWt728THmuWnCwypUCAPA1dWVsmVDkMlkyGQOpKamEBMTw5gxowHIyMggISEBDw9PZsyYiouLC2lpaej1Bot+fHx80WjyThANeX0IrZq14Puff+LOnVu4uLiQmppC9eo1UCgUBAWVIS0tJde2YWGVaNy4GaNGDaNJk2b4+fnnOOfgwd95/vkXzLfffvtd5s6dhVQqISysIkqlskDX5WklkleCIAhPOYNGT9r5eDIuJWI0glsVb5S1/JE5iX8ihJIrOjoavd5yuYFSqbR446fX6zEajaSnm+qCZGZm4ujoyG+//Ubv3r1xcHDAw8ODF198kZ9//pnatWsjl8vRaDRkZWUhl8tRqVR89913fPfddzZ9fIL9ZHWYZO8QSg2N4gXrJxWRDqHWx8pviVJB+rDW3lZseV2FEqpsFzTxpb/mVV4z/pVKD8qWDeGrrxYjk8lYvXoFvr5+LF48nw0btpGdraZ//14YzTtpF2zlgNHFFaOHB6++Ooi33nqTw4f/oGLFSly7dhWDwUBcXCzu7rknmBITE/D09GTJkuX89defuZ5z+vQp2rfvYL7977/HmDJlGu7u7kyY8B6VKlXJtZ1gIj6ZCIIgPKUMOgMZEYmkn0/AoNHjEuqBR50AHNwV9g5NEKzq378/d+7csTg2cuRIRo26PyPB1dWVTz75hL59++Lp6YnBYGDdunUMGzaMoKAg83mBgYFEREQA8P777zNgwAB8fHyYPXs233zzDf369cPNzc02D0ywO+ntcwAYyta0cqZgjcQQC4BRGlDsY8VmmcYKcMl7rNhY0wfYgIDca15Z6+Nee/vXvLLddRVKKFUMkuwMjI5P52tAJpPRv/9ARo0aSna2hlat2uDo6EizZs15882BuLq64ufnR1JSYq7t8655pQOtFolczvvvT+CTTz5i1qx5aLVa3n9/JJmZmYwZ80GufXp5efP330f56adN+Pj4MnnypwB8+OE4Zs6cC0BsbDS+vvf/gJQpU5b3338buVxBnz79cXKy/7LkkkwkrwRBEJ4yRoORzGvJpJ2JQ5+lw6mMGx71AlB4Ods7NEEosDVr1uQ68+pBERERLFq0iJ07d1KuXDm+//57Ro0ahcFgyNHfvboVHTp0oEMH07eiN2/e5NSpU4wePZoZM2Zw+/ZtGjduzOuvv15Mj0ooCbx+M32YSXzttp0jefIp002/K6keO4t9rGF7TGNtfSnvsYYNM30wzGvJkrU+7rU/cqTQYRYJW15XoYQ60helVk9qw9L7GujUqYv5548+mmr+eeXKtQC0bv0srVs/a9Fm3LgPc/TzYNt7P1erVg2dzvK9wODBw5BFXoGoG+grVaZy5Sr88MNGoqPvEhJSjlmz5uXou379htSv3xAwvY+YOnVGjnNCQ+9vprRq1foc7b/7bk2ONkLuRPJKEAShlFHHZJB09A7ezYJxCrw/W8RoNKK6lU7q6Vh0qdkofJ3xbh6CU4CrHaMVhMJ5cOZUXg4fPkz9+vUpV64cYJqtNWvWLJo0aUJ8fLz5vNjYWAIDA3O0nzVrFhMmTODo0aNkZmayZMkS3njjDZ599lnKly9fdA9GKFGyQkbbO4RSI8v5PZuNNbq+9bFGj86/5pW1Pu63t+9HKFteV6GEqv4BWalZ9o6i1DH4F/1Mtu7dexZ5n08rkbwSBEEoRdQxGSTsj8KoN5KwPwrftuVxCnRDHZtJ6skYNAkqHJSO+LQqh3OIu9g9UCjVqlevzpo1a0hISMDX15fffvuNsmXL0q5dOzZv3kzbtm3Jysril19+4ZNPPrFou3//fvz9/alevTq///47Dg6mt0wSiQS1Wm2PhyPYiKrdeHuHUGpoFc/ZbKxny1kf69ln869ZZa0Pa+1txZbXVSihynREKy/9Na9szZhLwfSgoDK5zroqqNwKtwuFI5JXgiAIpcSDiSsAo95I/P4o5J6OaBPVyFwc8GpSBteKXkikImkllH7NmjVj8ODBDBgwALlcjoeHB4sXL6ZChQrcvHmTbt26odVq6dOnD40bNza302g0LF68mGXLlgHQokUL1q5dS9euXalbty7h4eH2ekiCDTjc+AcAXWgjO0fy5JPqTUsvDbKyxT7WnXTTWMHueY91547p377g4NxrXlnr4157e9e8suV1FUqozFtI1RkYnMRroEhp/ptdqRD1X0sikbwSBEEoBR5OXJnpjWgT1bhW8sKzYRBSB6l9AhQEO+nfvz/9+/fPcfyjjz7Ks41CoWDjxo0Wt7/99ttiiU8oeTwOdAdEzaui4J4xFLBNbaa395nGyq/m1dtv51/zylof99rbu+aVLa+rUEIdHYB7Ka95ZQ+ym1EA6CtVtnMkQm5E8koQBOEJl2fi6gFZ11NwCfWwqIElCIIg5JRVfoy9Qyg1spzH2Wys9xpYH+u99/KveWWtj/vt7V3zynbXVSihak4iK0XUvCpqhoCnc/fGJ4VIXgmCIDzhko7eyTdxBaYlhElH71Cmu1juJAiCkB9VW1EMu6hoFW1tNlbrEOtjtW6df80qa31Ya28rtryuQgkV2B6trHTXvMrKymLq1I9IT0+jUqUqvP/+eLRaLT17dqFcOdOmKSNHvofBoOeLL+ZQsWIlJk6cgkqlYtGirxg7dmKOPjMyMvjyyznExcWgVqvp3PklunV7mRMnjnPo0EHeeef+lxfLl/+PypXDadWqjfnYzp3bCQ4OoU6dujn63rlzO6tWLTfXuMrKymLs2A+oXr1mno/x0qULrF27mk8/nQXAtm1b+Pnnn1Ao5Iwb9yFhYZXM56akpDBlygdotRqqV6/FqFHv5XqsNBPJK0EQhCeY0WjEJdSD9PMJ+Z4nkUnwbhZso6gEQchNTEwMERERtGjRgri4uALtmCjYnsOVQwDoKre0cyQl19q133PrVpTV87zdUwBISvcs1Dipqab2Hh7W26dITOd6GvM+NyXF23SOZ1Kh+rjX3s8vFa320RNZISHl6ddv4CO3e5hUfx0Ag6zCY/clPKEyriHNysDgUnpfA9u3/0StWrUZMOB1vvtuKX/+eRhfXz/atm3He+/d31jjiy8+Y+LEKSxf/j/S0lLZsWMbL7/cK9c+P/98Fh06dKJly5ao1RpGjRpG9eo17p+QnW36v6Njru07deqSb8w9evSmd+9+AFy6dJHvv/+OmTPn5nru3r27+eGHlZQpc//9+Y8/rmHVqvVcu3aVVauW88kns8z37dmzk5Yt29CrV18mTHiPqKgb/P33nzmOlS8fmm+MTzKRvBIEQXhCqWMySDkRgzZJjcxNjj5LB4acM7AkMol510FBEOzjwIEDTJ06FalUyvr16+nUqRNz586lffv29g5NeIjHkVcASKwsal7l5datKG5EXiLQLf+PEr2eMyUCv15duERgcoYOAEdV/l/QAOwKNo3V/U7eY+3a+6npnOemFKoPa+3zE/PfYykK7hlvA6Lm1VPtrzfsWvPqpa2d6Fu1P32r9ker19Jrezf6VxtIr/C+ZGmz6PdLT16rMZiXKvcgLTuVgbte4c1aw+lcsSuJqkQG/zqAEXVH0SH0hTzHuHXrJh07dgagevWanDt3hjJlgrlw4Txvvz2EqlWr8fbb7+Li4opWq0Gv16HVaomNjbGYsXRPdnY2N25cp1mz5gA4ODgwd+7XuLi4cOrUCQBkt24C92te7dixlY0b1yGXy5kxYy5r135P5crheHh4cvHiOfr2fTXP+BMS4nB3dwdg4MA+BAYGERcXx2uvDaZNm3Z4eHjy6aez+eabBeY2YWEVUavVqFRZODu7WPRXqVIVzpw5hcFgIDs7Gycnp1yPlWYieSUIgvCE0aaqSTkRi/pOOjIXOd7PBONSwZPs2Mwcta9E4koQSoaFCxeyYcMGhg4dir+/P2vXrmXChAkieVUCZVbMu5i/cF+gmwOv1/bO9xzDbdMuntbOy8uKM0kFbl9bbxqrgU/e59Z2M33QbxCW+znW+rDWPj/3HktRyHL5sMj6Ep5QtT4p9TWvKlQI49ixo9SsWYt//vkbqVRKYGAQQ4eOoFGjpnz55Rx++20P3bv3ZMmSBTRu3JRdu3bQseOLfPHFZzg5OTN8+EikUtNmRenpaXh7W/7uurlZvj82BAZa3K5atTpvvDGUefM+48yZU+bjderUzXXp4ObNGzh4cD/R0XepVauOeRlifHw8CxcuRSqVMXr0cNq0aUfjxk2Jjr5r0V6p9GDgwD5kZ2cza9Y8i/tcXFz5+eef2L17JyEhIQQEBJKcnJzjWGkmkleCIAhPCL1KR+qZODIjk5A4SPGoG4BbVR/zDoJOgW74ti1vTmCJxJUglBwGgwF/f3/z7WrVqiGRSOwYkZAXdcsR9g6h1MhItN3S2AYy62M1CLv8WH1Ya28rWnkLe4cg2FtAa7RS+9W8enBHTrlMbnHbRe5icVvp6GFx28fZJ99dQe/p3PklvvjiM0aOHErt2nVxdnamevWaODiYUhhNmzbnzJlTPP98R6ZOnUFmZgbffbeMiIiLNGjQiLt373L8+DEaN24KmJYfJyZazuK8ciUCJydn822jm7vF/ZUqVQHA09OT7HtLCvNxb9ngb7/9ys6d2/H09AJMiTil0sN0veRyNBoNCoXCom1k5BWiom6wYcM2kpOTmDhxLMuXrzbf//333zF+/Ec0bfoMCxZ8yZ49uzlwYF+OY88/39FqnE8qsWe6IAhCCWfQGUg9E0f0tstkRibhVsWboG5VUNb0Myeu7rmXwJK5ykXiShBKEGdnZ+7evWtOWB0/fhzHPGpqCPYlv7AX+YW99g6jVHB0TcHRNcUmY90wpHDDkP9YN+IDuBGf925i1vqw1t5WZPoryPRX7B2GYE9pEcgyS/dr4NKli7z4YlcWLlyKXq+ndu16LFu2mP37fwPg9OmTVKx4f3ngli2b6NGjN9nZ2UilUqRSCSrV/dlpcrmc0NAwjh37C4DsbDXz5n1GZmbm/UHVatN/j6l9+w54eHiyZcsGAG7fvoVarSYzMwONJjtH4gpM7xMcHR1xcHDA3V2JVmu5O6qLiwsuLqalhD4+PmRmZuR6rDQTM68EQRBKKKPBSOa1ZNJOx6FX6XAOUeJRLwC5Mv8PvE6BbmJXQUEoYcaMGcMbb7xBfHw8ffr04caNGyxYsMB6Q8HmlMdeByCxuqh59bjK1zkCwOU/Xyz2sWZqTWMtdcx7rJlbTMXSlw7LvYCytT6stbcVt4x3AFHz6ql2bBhudqx5ZQvBwWWZMuUDDAYDderUo06dugQHl2XatMls27aFcuXK07atael9RkYG6elplCkTTOvW7Zg69UMcHR1zLL17//3xfPbZDFav/o6sLBXdu/egatVqnDhxHADZ7VvA/ZpXeTl9+pTVmldvv/0uI0a8wfPPd0ImkzF58gSSk5MZNmxkno+3Xr0GDBv2OhKJhCFDTLOAP/98Nq+//iavvz6Ezz6bjsFgwNPTk8mTP6Vx46Y5jpVmEqPRmP/+6kIOycmZ6HSGIu3Tz8+dfuPXFGmfQv7WzulPfHzxTLf183Pn3zlvFkvfQk4Nxn9brM/layveKZa+86O6m07qiRi0KdkofJ3xrB+Io7+rzeOwtZWvf11szyWYns+dA18vtv4FS52+X1Hkz6eDgxQvryfzdyEtLY2TJ0/+90a8To7aG0LBJSZmYMhlg4qi4PjndwBkP/NGsfRfEvj5uT/W7+Znn01DHRNptRaVq1csAJnJhZut9Cg1r07rTWPVkeU91ukbFU3nhF4tVB/W2udnxZkknAIrMWHC5Edu+zAH7d8A6ORNHrsve3nc1+DTzo+zJKdkofO03WsgJiaKwMDyNhuvODk4SHP/PH9v5pJr0a5ceO21fqxcubZQbVevXkmPHr3NM6zs4eHnXiqV4ONj+9UdxTbzKjw8nCpVqiCVSpFIJKhUKtzc3Jg6dSq1atUqUB+HDx9m7ty5bNu2zXxs9uzZ7N69Gw8P05rRChUq8NVXX+Voe+PGDT788ENSUlJwcXHhs88+o2JF0z84mzZtYvny5ej1epo1a8akSZOQy+WP/6AFQRAekyZZRcqJGLKjM5G5yfFpGYJzOaWojSMIT7itW7da3P7jjz9wdnamUqVK5vcnQslQmpNWtlbYpFVh5Je0Mp9jJelkrY/CJK2Kw5OctBKKiN8z6BDJvyJXxEmrotCxYye7Jq5KkmJdNrhq1SqLbxWXL1/O9OnT+fHHH/Ntp1arWbJkCWvWrCHwoYr/J0+e5IsvvqB+/fr59jF27FgGDRpEly5dOHjwIKNHj2bHjh1cuXKFBQsW8NNPP+Hp6cnYsWNZuXIlQ4YMKfwDFQRBeEy6TC2pp2PJupaCVCHDs2EgbpW9kchEaUJBKA22bdvGqVOnaNq0KTKZjKNHjxISEkJaWhrDhg2jT58+9g5R+I/izHYANLW72DmSJ5+Tu2nmlDq9+GcZRhpMY1WS5j1WZEwZ0zmBd3O/30of1trbikx3AQC9Q3W7xiHYUco5ZBmZ6N3Ea6BIqVSm/zs753/eIyrsrCsAPz9/6yc9JWz2qUin0xEdHW2eMbVgwQJGjx5Nv3796NChA++88w4ZGaZpeocPH0alUjFz5kyLPjQaDRcuXOC7776ja9eujBo1irt3c/7jERsby7Vr13jxRdN69datW6NSqbhw4QL79u3j2WefxdvbG6lUSp8+ffj555+L+dELgiDkzqDRk3IqlpifL5N1IxX36r4EvVQF96q+InElCKWIRCJh06ZNLFmyhIULF7J161YCAgL4+eefWbNGlA0oSdxPjMD9hNhxsCiUq3WUcrWO2mSsOdqjzNHmP9acbf2Zs61/ofuw1t5W3DLH4pY51t5hCPZ0fCRul8RroKjJ7txGdkfUOyypinXm1aBBg5BIJCQlJeHo6Ejbtm2ZNWuW+f7Tp0+zefNmvL29GTduHIsWLWLChAm0b9+e9u3b8/fff1v0FxsbS9OmTXn//fepUKECy5cv56233uKnn36yWFITHR2Nv78/Uun9D34BAQHExMQQHR1N2bJlzccDAwOJjY3NEXtaWhppaWkWxxQKhcU214IgCIVlNBjJuJJE2pk4DNl6XEI98KgbgINbzt1HBEF48sXHx1ssDwwJCSE2NhY3NzdkMpkdIxMellH9M3uHUGrcvtDYZmO9I7c+1judNj5WH9ba20qm6zR7hyDYW725ZCZnWj9PeCT6MmXsHYKQD5ssG7xw4QJDhgyhXr16+Pj4mO/v2LEjvr6+APTs2ZOZM2cyYcKEPPsLCQlh2bJl5tuDBw9m8eLF3L59m5CQEPNxgyH3YuoymYzc6tM/mOR6MPaFCxdaHKtfvz7r1q17YgvFCjn5+bnbOwShiDwpz6XRaER121SMXZeuwTHAFc/6gSh8inZ68pPsSXkuhYIRz6eJh4cHP/74Iz179sRoNLJ582Y8PT25fv16nu9bBPvIblw8M2uOHPkDgObNWxVL/yVRVoqfzcaqIbU+Vo2QG4/Vh7X2tqJzaGDvEAQ7+/10OmlpKpo3t3ckpYyL+JxfkhVr8uqe6tWrM3HiRCZNmkSdOnXMM58e/KbRYDDkmkR60KVLl7h06RIvvfSS+ZjRaMxRbL1MmTIkJCRgNBrNM7JiY2MJDAwkKCiIuLg487n3jj9s0KBBdO/e3eKYQmGaEVFcuw0KtlecO9QJtvUkPJfZCVmknoghOy4LB6Ujvm3K4RTsLoqxP6S4dxsUbEvsNmgyc+ZMxo8fzyeffIJEIqF+/frMnj2b7du3M2KEWKJWkihObAZAU79HkfZ7+PBB4OlKXjkrEwFQpflYOfPxRRhMY4VL8x4r4q7py+7wMrcK1Ye19rYi050BQO9Q265xCPZz7tAP6HT6p+rviU1kZZn+Lwqkl0g2SV4BdO7cmc2bNzNz5kwWL14MwL59+xgxYgSurq5s2LCBtm3b5tuHVCplxowZNGjQgJCQENauXUt4eHiO5FNgYCDlypVj586dvPjiixw6dAipVEqVKlUAeOuttxgxYgTe3t78+OOPtG/fPsdYSqUSpVJZRI9eEISnmS5dQ8qpWFRRqUidZHg1LoNrJS8kUpG0EoSnRbly5Vi/fj1paWlIpVLc3Ew7Gg0fPtzOkQkPcz/zDgCJRZy8ehqF1PwLgMt/vljsY83TmsZa6pj3WPO29zWdM2xuofqw1t5W3DI/ACDVY6dd4xDsp3PQb+SyoKjUMxqNzJkzg6ioG/j5+fPRR1PNE0weFB19lzffHECFCqbl+hkZGfTo0ZsuXV7Ktd+zZ0+zaNHXGLOyaFGvAQPeG2e+b/z49+jcuRutWrXJ0W7jxvUYjQZ69+5X4NiEwrNZ8gpg8uTJdO3alUOHDgHg6+vLkCFDSE5OplGjRlbfwFWpUoVJkyYxYsQI9Ho9gYGBfPHFF4BpBtXQoUNZunQpAQEBfPHFF0yePJklS5agUCj4+uuvkUqlVK1albfffptBgwah1WqpU6eO2GlQEIRioc/WkXY2nozLSUgkoKzlh3t1X6RyUd9GEJ42N27c4IcffiArKwuj0YjBYCAqKor169fbOzThIem1v7Z3CKXGrXNNbTbWGLn1scZ0yf/3zVof1trbSobrbHuHINjZjuj26HR6Btg7EBs7ffokEomExYu/ZeXKbzly5A/ats05EQWgdu26zJo1DwC1Ws0bb/TPM3n1zTcLmTFjDt5OzowcM4oXEhLw9fVl8+YfSUiIz7XNggVfcOjQQXr27PPIsQmFU2zJq4iIiBzHwsLCOHfuHACnTp0iPDycKVOm5NlHkyZN2LFjh8Wxbt260a1btxznBgQEUKVKFXN2MzQ0lNWrV+fab48ePejRQ3ybJghC8TDqDaRHJJF2Lg6jxoBrRU+UdQJwcJFbbywIQqk0ZswYatasycmTJ3nxxRfZv38/NWrUsHdYQi6Kerng08wWywXvyW+5oPkcK8v9rPVRkOWCF2PTiUrKolYZJcEexVPP0hbLBWNjY9izZxc+Pj507NjZankXwbai1QFotXq7je+R2gm1Y3+ynfqDUYtHWjfUTgPJduwLxiw80nqidhpMtmMPJIZUlOmvoHIajsaxKxJDIsr0AaicR6FRvJDnGGlpaUyZ8gEGgwEvLy9q1KhF7979qFWrDgAJCfHUqFGTrKws5s2bzeTJn+bZV3p6GnK5KU8wcuRQQkNDiYi4RIMGjRk+fCTTps3G29v0+6/HVN7o6tVIbty4QfPmLXPts27d+lSsWJmMjHTz7YdjE4pWqfkrpFKpaNGiBV5eXvYORRCEp5TRaCTrRgrR26+QeiIGR18XAl6shHezsiJxJQhPuczMTD755BNatGhBq1atWLFiBefPn7d3WEIuHI+twfHYGnuHUSq4eMbj4pn7rIWCyFRrSMtSYyjA+qjzhnjOG/If6/ytUM7fCi10H9ban7qTylcHr/LT2Wg+23eFuPRsa2EXioPuXxx0/xZL3wBqtYqxY0ezdu33LFjwJStXfltsYwmFU9Y5mhCXaHuHUax++eVnWrVqy/z53+DldT+xLJPJGDNmNP/++w8VKlTCxcUl18TVmTOnGDlyKH37vszHH3/I+PEfme977rmOLF26ikuXLhAdfdecuFqzchnhFSvi4uLCt98uYcSIUXnG17JlmxzHHo5NKFo2XTb4oFGj8n4hFIazs3OuM7IEQRBsQR2bSeqJGDSJKuReTni3C8YpyM3eYQmCUEJ4enoCUL58ea5cuULt2rXFLoMllNsF087XxbXrYGliNBpJz9bhqnBAlksdx7LVjwGFq3m1/0o8Z2/EAPA/fTYjmlfI9/yvtaax8qt59fXOXqZz8qhZZa0Pa+0vxd7foCJbZ+BaUib+7o55xmM0Gvnll23cvn2bdu2eo3Ll8DzPfZBr5mSg+GpexcbGWiyVOn/+bLGMIxTeC4G/27XmlcVrTyJ/6LaLxW2j1OOh2z4Feu3euXObF17oDECdOnWJj7+/6dq8efP555+/WLToKz7+eHqu7e8tG7x58wYffjieoKAgU3gSCXXq1AUkhIdX4+bNKIKCyvD9998RefoUnwwfxfEzp4iOjmb8+HeJiYnmwIF9hIVVpGzZEKtxFyQ2oXDslrwSBEEoDbSp2aSejEF1Ox2ZiwPezYJxqeApirELgmChfPnyzJgxg+7du/PRRx+RlZWFRqOxd1hCLtLrL7F3CMXq/PmznD79D8HBobRu/Wyh+zEajSw8fJ1z0Wl4Ost5r3VFApVOFufcPNus0P3/cTXR/POpO6mkqbUonfKexTxebn2s8d3yn1FnrQ9r7asGuLM/MgEARwcpYd7574y6ceM6VqxYBsCePbtYtmwVPj6++bYByHD93Oo5jyMoqAwhIeW5dSsKgCZNCv88CsXj57vPo9PpGWTvQIpR+fKhXLx4jho1anLlymU8PT05cuQQ169f5dVXX8PJyblAy1nLlQuld+9XmDdvNjNmzMVoNBIZeYVKlcK5ciWCrl27s3nzBq5fv8bH0z5DIpPRyNmZlSvXArB8+f+oXDncauKqMLEJj0YkrwRBEApBr9aRdiaOjCtJSBykeNT1x62qL1IH8Q+VIAg5TZ06lT/++IPq1avTq1cvjhw5wrRp0+wdlpALTe0uRd6nWq0mKSkJJycn6ycXo6io63zwwRh0Oi0ABoOh0AWFUzPVXIpOAyBFpWXv5XgGNLT8cKdO9y50rAHujtxNUwPg7uiA8wObnRiNRo5cTyI2PZum5b0I9nSmktT6WJUC7+Z/v5U+rLWvG+zBu60rcjM5i5pBynxnXQFcvny/RrBKlcXt27cKlLzSO1S3es7jUCgUzJs3n0OHDuDj4yeSVyVQbLafXWte2UKXLi/x6aeTOXToIAaDgZYtW9OoURN27/6FkSOHIpfLmTBhUoFqXnXu3I3t23/i5EnTctvVq1cSHR1NixatCAwMYtmyxZQvX4F3PngfgPHjP6RcudAc/WzbtoWAgECaNn0mx325xSYULZG8EgRBeAQGnYGMiwmkXUjAqDPgVtkbZW1/ZE7iz6kgCHn73//+x7vvvgtAv3796NevH9OnT6d+/fr2DawYhYeHU6VKFYtvn2vWrMmMGTNynNutWzdWr16NUqm0ZYi5cvzzOwCyn3mjSPrLzs5m7NjRXL16BYlEwrFjR2nc2D7JgKtXI82JK4BLly4UOnklk1l+WeOSy066rl6xAGQmBzxy/wMahXA3U4/OYOCtpiHIHxhvT0Q8W86YEkmHriXwScdq3FAkAVBHlvdYp29UNJ0TejX3+/Wx+fZhrT1AtQB3qgW453n/g1q0aM2ffx7CaDQSGFiGSpUqF6idg/ZvAHTyJgU6vzDc3ZV06tS12PoXHk85l9vodKV76bmTkxMzZ5qW6O7cuZ2MjHQUCgXTpuXcbfPhxFVQUBnzToMAUqmUZcu+N9/+4INJODvfnxm5e/cB0w+ZGab/u94v/TF48DDzz6GhFVCr1ebbnTrd/7Ijr9iEoiM+bQmCIBSA0WAk63oKqadj0WfpcA5xx6NuIHKP/L9VFQTh6TZ//nzS0tLYuXMnGRkZ5uNarZbff/+dSZNK9zezq1atwtvb+oyYbdu22SCagnG7bNoJu6iSVxERF7l69QpgmjG0Z88uuyWvatasjbu7kvT0NKRSKU2a5Jw9UFDuzo68XDuIozeSKOPhTKfqORM+wdWOYzAaiTza+ZH7d1U4UCHQ9Nop62m5a9/1xEzzzyqtgZh0NYs8jgOwVJZ3zatFv75sOiePmlWLdPn3Ya39o2rT5lkCAwO5e/cODRo0xtW1YLUyXbM+AYqv5pVQ8nUIOGjXmlellSzaVARfn0ciuUyZYPz8/G0ZkvAAkbwSBEGwQn03nZQTsWhT1Ch8nPFpEYKjf/51LARBEADq1KnD2bNnkUql5qLtYNqRaMGCBfYLzM5q1qxJu3btuHTpEp9//jk9e/bk6NGjBUp0Fbe0xiuKtL+AgEAUCoW5xtmtWzf57DP7LRmtXr0G6empODu7snfvLvbu3fXIfdy8GYULBjrUDqBD1dxnKSVlaXh/QRBJWRqUXGNE8wq5FnUvjLrBHpy8kwqAj4ucEE9nPnRobrXdhy9/n//98vz7sNY+PxkaA3E3o/J87v/55y+MRiMSifVr5OdhKuwen/rkLj2Wy2WlftlbcdIl18DN1Z13XrZ3JLbx4Aynx7Vw4VIcHKS5zlzTW6lrJRJX9iWSV4IgCHmIirrBvHlriP8nCpmbHJ8WITiXVxbojaUgCAJA69atad26Na1ataJ27dr2DsfmBg0aZLFs8LvvvsPHxwetVkvbtm35+uuv7Rhd7rTVnyvS/gICApk6dSZz587AaDQtOykqRqOR69evkZKSgo+PD+XLh1pt4+zsjFLpVujEgdFoJD09jXStmrh09zzrOu2NiOPkVSngBKRxNjqVusGehRrzYU1DvfF2VRCfnk2tMkpcFA6EYr3vUL/Y/O+X5t+HtfaFpdFoOHPmNBkZGfj7+1OtWvV832vEp9o/ySvYV3SGEqXUw95hlD52rkso5E8krwRBEB6SlJTIhg1rOXjwd9zc3PCsH4hbuDcSmSjGLghC4bi4uDBx4kRSUlIwPrDW45tvvrFjVMUvv2WDDRs2tHE0BeN0yLTboLrliCLrs169BtSpUw+ACRMmF1m/v/76CwcP7gcgLS2V/v1fo3nzllbb+fm5Ex+fXqgx1637wTzm3P1X+KRjVVwUOT9SODrIqF/VNMaJS+44OuSsifWo7qaq2XYuGplUwsu1g6jid3+Z3b9603KfBrKgPNv/e62K6Zywy7nfb6UPa+3z46aQ4htYPtfnf/nyb/jzz8MAxMXFMmLEKJo2zXsWmFxrOlcrb/HIcdiCTqfDwSH/j5mP8xoU4Kf/DUenE9evqEkyTNfU6FawunWCbYnklSAIwn9UKhU//7yFX37ZhsFgoFOnrgwZ8jqjNpXumjSCIBS/8ePHU79+fRo1aiRmb/7HxcXF3iHkyvWqqaB8USaviktiYqLF7aSkhGIf8/z5M+af09Q6YtOzqeCT8yNFh6r++NX9E7VOz8aNFQtcxDw/Cw9dJTHLVHA+MVPDxPZVzPf9T3cCyL/m1f/2djOdk0fNKmt9WGtfWFKp7KHb+X9Z5pI1Eyh5Na+SkpL46KNx3LhxjebNWzJx4sfIZI+ftBRyau9/SNS8KgbSmBgA9JVE8qokEskrQRCeenq9nn379rB583pSU1N55pmW9O37Kv7+Abi7i3+8BEF4fFqtttQXZy8tUpuvs3cIBfbccx359dedxMXFUrZsCK1bP1vsYzZq1JR///0HAF9XBUHK3JfZGI1Glq4PJzpNTVmXx98VzWAwkqS6v1NiYqbG4v4pcuszzqb0zL+embU+rLUvrJ49+5oL+7dq9SyNGjXN9/x0t0XFEsfj2rJlAzduXAPgyJFD/PXXnwWaCSg8uk23X0Sn0zPE3oGUMvqQcuafo6PvMn/+PItdCxMTE9i8eQNDh76Vo+2MGVPp3fsVKlcOf6wY+vR5CT8/fyQSCSqViipVwhk//qN826xdu5r4+DjeeWcMGRkZTJnyASpVFg0bNrHYLfGeS5cusHbtaj79dBYxMTFMn27aqESr1XLr1k127tz3WI+huIjklSAITy2j0ci///7D2rXfc/fubapVq8H48ZOoWLFgW1ULgiAUVPny5YmLi8PfXxR7Lel0lZ+cD9t+fv78738riY2NISioDAqFotjH7NbtZY4c+YP0uJu83aQMTvLcZ9b8eimOg5d0gAOXSaBmkJIagcpCjyuVSmhf2Y+9l+MBKOPhxPtbzxKodGJYs1DKOlvvu6xP/jPTykrz78Na+8Jyd3dn9uwvCny+QVZ0ddOKklwut7hti9fj0ypZ6ykK3hcHx/x3Effx8c01cVWUnJ1dWLhwqfn2+PHvERl5hUp57IAYEXGJP/7YT7VqNQD46adNPPdcR154oTMTJ47l1q2bhDyQlNu7dzc//LCSMmWCAQgMDDSP9803C+nRo3dxPbTHJpJXgiA8la5evcIPP6zk4sXzlCkTzNixE2nQoLFYziMIQrEwGAx07tyZGjVq4PjAm+PSXPMqIiKiwPfld66tOe//EgBV2/fsHEnBODk5FahQe2FoNJpcExBeXl64apNROslzaWWiNRhpXCMNgGPnlej0j7/GqWfdYJpV8CY6Vc2yv6IAuJqQyY7zMVSqZ1pq10QWnGf7v69UM51T+WLu9+vv5NuHtfa2IteYao5pFW3tGsfDevbsQ2TkFa5evUyrVm1p1KiJvUMqtQI5T0Z2Brdv36KslR3yioPH8U6oy/Qnu0x/MGjxONENdfBAsoP6gj4Lj5M9UZcdTHZgDyTaVJSnX0EVMhxNQFckmkSUZwagKj8Kjd8LeY6xc+d2MjLS6d27n/nnSpWq8MMPq9BoslGr1UyZ8ikJCQk5joWElGfevNncuHEduVzOxIlT0Ov1TJw4FmdnZ0aMGEnt2vVITk5m+vSPmTdvPkuWLECq0zL8tTcZ88kkhg0byd27dxgzZjTJyYmMHPkeQUFlmD9/HuPGfciUKRMxGAwEBAQyZcr9nT+3bdvClSsRjB07kRUrlnHs2F/IZDLee288FStWom/fl/H19eWll3pw/Pgx3nprNEpl7sX3tVot6empuLq6snz5/7hx4zrJyUk4OTkxffocjEYjq1Yt57XX3uTvv48CcOHCOd55ZywADRo05MyZUxbJKw8PTz79dDbffGO543FcXCznzp1h+PCRhX5dFDeRvBIE4akSFxfL+vU/8Oefh1AqPXjjjWE8++xzVguLCoIgPI7nnnuO554r2l3shOLhEmVaIqLiyUheFZeFC7/kl19+xtfXj+nT51C+fChXrkTw8ccfkpycRLCPEsh717sO4f741fsTjd6APrUctYIKP+vqQcEezqg0ljNOdAYjy3WngPyTV8t/72w6J4/kk7U+rLW3FReVqeZWaglLXrm6ujFt2mx7h1HqnT59khae+8ETRo8ezoIF/yM4uKy9w7IZnU7LggX/48yZU/zwwyo6dnwxx7FWrdrg5OTMwoVLOXfuDCtWLGPgwDfQajWsXLkWBwcpOp0BLy8vsrPV6HQ6bt6MQp+WiubWLQDc3NzQarXMnj2PyMjLrF+/xpzYuXDhPGFhFXnnnbEcPLgflSoLgN9//424uBgmTfr0v0RuJEuWLCc2NoY5c2Yyb958kpMT+f779SgUCtq375Dj8alUWYwcOZT09DQMBgP9+g0kKKgMYNqtdtq02axc+S379//G+fPneP31IaSnp5nbZ2VlmmtKOjk5m2O7p3HjpkRH380x7rZtW0r0rCsQyStBEJ4SGRkZbN26id27dyCVSunevRddunQvsQWDBUEoXbp3705MTAwRERG0aNGCuLg4goLy3hVNsJ/UNj/ZOwS7u3Ilgl9++RmAhIR4fvhhJR99NJUVK74lOTkJgDuJacRnZOPnlvsyGw9nOcYbLyAzGhn6TNHWj6zk50bLMB8OX08kwM2RF6sH0EGedyLtnk/7fJv//fLWj9XeVtLdllo/SSi1jh//m0O7TUtHVaoszp07bfPkVWrDBzYLkMotb8tcLG4b5R6WtxU+lucXwIO79NaqVQeJRELVqtVZvHh+rseiom7w119/cunSBQDzzKbcZqnVrVuff/75C1dXVzL0Oo7G3KVBg8YAlC8filwux9PTC40m29ymWbPmXL9+lfffH0mZMmVp1sy0O+jZs6dxd3dHIpEQFXWDy5cvMXLkUMA0kxUgMDAo3yW195YNqlQq3n33LQICAs333du1tmrV6hw7dpQTJ/7hxo1rZGRkkJqaQu3adXBxcUWlykKpVKJSqXBzc8trKAvHjx/jtdfeLNC59iKSV4IglGparZY9e3axZcsGsrIyad36WXr1egUfH197hyYIwlPk4MGDfPzxx0ilUtavX0+nTp2YO3cu7du3t3dowkN0oY3sHYLdKRSWCal7S10frmnkIM1/qb1WXbAPTYXxasMQ+jUoi9S83D//WjUAgZ7J+d8vzT9ea+1txSB7embZCDlVr16TTZtMyQ8HBweqVKlq54iKh0KhMO+oeu3aVQICAgCIjLwMwKVLF83L4R4+Fhxclvbtn+e1197kzp3bnDpl2kk0t508mzZ9hoULv+KFFzqTlpbGyh9W8vHHM/KN7fTpk5QvX4EBA15nwYIvzJtYvPPOGDZv3sCBA/sIDi5LvXoNmDhxCmlpaeYvBCSS/HcTvcfZ2ZkJEyYxYcL7rF79o/lxNmzYmEuXLlCxYmVGjx4DwIkTxzl06CBt27bn1q2bnDz5Lx07vsiJE/8wfPgoq2Olpqbg5OSU4298SVOwKycIgvCEMRqNHD16mDFjRrJ69XdUrFiJ2bO/YPjwUSJxJQiCzS1YsIANGzagVCrx9/dn7dq1zJ8/395hCblw3jcH531z7B2GXZUvH8rgwcPw8fGlZs3a5m/jhw17m8qVw1EoFIQGeOHlkn9BbqXfbZR+t4stTukDdSr/1N/mT33+Y/0ZUYM/I2rkfb+VPqy1txW5Zi9yzV57hyHYSbNmLej/rC/dGjny2WdfUqFCRXuHVCwaN27KmTMnGT16OKmpKebjiYmJjB49nKVLF5l30nv4WKtWbYmOvsvIkUP5+OMPCQvL+xpVq1aDmzejqFevPvXDq5KRlma1jmCFCmGsX/8Db789hDt3blOvXn3zfcOHj2LFimWEhITg7e3D228P4d13R+Ta5+zZ00hLS81znLCwirRu3Za1a78H4OjRPxk5cihXr0by/PO51wvr3r0X+/btYciQQVSoUJHy5UO5cOEcq1evzHOcO3duW8zwKqnEzCtBEEqdS5cu8MMPK4mMvEy5cuWZOPFj8zRbQRAEezAYDBY7DVarVk1sEFFCudwyJRVVjLdzJPbVs2dfevbsa3GsTJlg5s//hs8+m4Y6JtJqH4GVTwOQFl/8M4VW6kxjPZPPrKSVBzqZzgk/X6g+rLW3FReVaVOBVIWoo/e06lbpAkYjKKvXtHcoxUap9GDJku8sjp04cZxaterwzjtjzMeio+/mOAYwceKUHH3OmjUvxzGZTMbOnftMP2u0bJ79BXogKKiM+fwHf773/8WLLZcRf/TRVPPPq1atB0wJ/4etXLnW/PMHH0zO936AkSPfBWD58v/Ro0dvWrVqk6NN/foNqV+/IWDavXTu3K8t7i9fPpSTJ/81337w8YBpNl/1J+C1JJJXgiCUGnfv3mHdutX8889feHl5M3z4KFq1aoNUmvs23oIgCLbi7OzM3bt3zQmr48ePW+w6KJQcye132zuEUuPav7YrKD6zAMXLZ/b732P1Ya29raS5r7B3CIKdrbvVDZ1Wz1v2DqSU0RfTzq32ptcb6Nmzj73DeGwieSUIwhMvJSWF775bzr59vyKXy+nTpz+dOnUVHwwFQSgxxowZwxtvvEF8fDx9+vThxo0bLFiwwHpDweYMZYvn2+cWLfIvBl4a6bJttymKr8T6WL7uafnfb6UPa+1txSgNsHcIgp01a9udtDSVvcOwuQdnGOV3rNBKcM2ne0skC0OpLJrdXu1NJK8EQXhiafUGDkWlMXXAANRqNe3aPU+PHn3x9PS0d2iCIAgW6tevz4YNGzh58iQGg4G6devi5eVl77CEXLj8Oh2ArA6TirTf5s1bFWl/TwKPgJsApMaWK/ax/tCbxmoly3usPy7UMZ1T/XSh+rDW3lYUml0AaBS517wRSr9nq2SSmqZCY+9AShlJqqn+lNHDw86RCLkRyStBEJ44BqORk3cz+DUymRS1nmeeeYYePfrZfJtgQRCEgrp06RJffPEFS5cuJSIigtdee40vv/ySsLAwe4cmPMQ5+hsAsija5NXTKKDiWcA2yasfdKax8kte/XDoedM5eSSfrPVhrb2tOKtMszZF8uopdmkezlo9Gj/xGihK0vg4APQieVUiieSVIAhPlCuJKn6JSOJuuoYQpYI+tfzoPW0a8fHp9g5NEAQhT1OnTmXw4MEAhIeHM2rUKD7++GNWr15t58iEhyW/sN/eIZQaV4+3s9lYcxTWx5rz6pLH6sNae1tJcxd/N556LTaRlphh7yhKHX1oBXuHIORDJK8EQXgixKRr+OVyEhEJKrycHXilth91Al0ttskWBEEoqVQqFc89d39nsPbt27No0SI7RiTkxRBQ2d4hlBp6jZPNxvKUWB/L0zX/D/vW+rDW3laMUh97hyDYm5MvRoWo7VrkHER6pCQTz44gCCVaqlrHnshkjt/JwMlByovh3jQvp8RBKpJWgiA8OSQSCREREYSHhwNw9epVpFKpnaMScuOy07R1eVanaXaO5MnnGXQDgJTo0GIf63e9aaxnZXmP9fu5+qZzap4oVB/W2tuKIvtnADSOXe0ah2BHt7agSFWhCRCvgUcVHX2XN98cSIUKpmX7GRkZ9OjRmy5dXkKSkgKA8YH6uTt2bOXHH9fi4eGJp6cX06d/xrFjf7Fs2WKkUhnvvjuWatVqmM/XaDRMmfIBaWlp+PsHMGXKNPO/9wsWfEGdOvVp1aqNrR5uqVJsyavw8HCqVKmCVCpFIpGgUqlwc3Nj6tSp1KpVq0B9HD58mLlz57Jt2zbzsW3btrF8+XIkEgnOzs589NFHufb3+++/88EHHxAUFGQ+tmbNGtzc3Dhw4ADz5s1Do9EQHh7OzJkzcXNze/wHLQhCkcnWGTh4I5WDN1IxGIy0KK/k2TBPXBUye4cmCILwyN555x1effVVqlSpgkQi4erVq3z++ef2DkvIhXPcCgCyEMmrx+Vf4Txgm+TVep1prPySV+uPmJYF5pV8staHtfa24qw21WUTyaunWMR8U80rkbwqlDp16jJzpunfYLVazRtv9KdLl5eQJsQDoH8geRUZeYWPPvqEqlWrmY8tW7aEL79cjFqtZtq0KXz99WLzfX/99SfBwWWZPft9vvpqLseO/UXDho2ZNm0KFy6co06d+rZ5kKVQsc68WrVqFd7e3ubby5cvZ/r06fz444/5tlOr1SxZsoQ1a9YQGBhoPn7t2jXmzp3Lli1b8Pf35+DBg4waNYoDBw7k6OPkyZO88cYbDB8+3OJ4UlISEydOZN26dYSGhjJ37lw+//xzpk6d+liPVRCEoqE3GPnnTjp7IlPI0OipHejKC5W98HEpuVvXCoIgWFOrVi12797NiRMnkMlk1KlTBx8fsfSnJEruetTeIZQakcees35SEflCYX2sLwYufKw+rLW3lTT3dfYOQbC3VttIS7BfvVePlzqh7tuf7L79QavFo1c31P0Hkt2rL2Rl4dGvJ+rXBpP9Ug8kaakoB76C6s3haDp3RZKYiHLwAFQjRqHpkHfB+Z07t/Pnn4fIzMzEycmJypXDOXr0CPXrN2TEiFHs3Lmd3bt/QaXKomnT5gwc+AbDhr3GJ5/M4vLlCE6c+Ie3336XefNmM3nyp3mOk56ehlyuAGDEV3MoF1KeK5GXadCgMcOHjyQy8gqrVi0nNTWFAQNep1atOjg7O+Pm5oabmxtZWRnodDoc/ltyGBpagWPHTP+OZGVl4ezsglarpXPnbpQrV74In4WnT77Jq3r16iHJpZ6M0WhEIpFw4kTBv3XQ6XRER0fj8V/l/gULFnDlyhUSEhJITEykatWqzJgxAzc3Nw4fPoxKpWLmzJnMnz/f3IdCoWD69On4+/sDULNmTRISEtBoNCgUCovxTp48iYODA3v27MHJyYn33nuPRo0acfjwYWrVqkVoaCgAr7zyCt26dePjjz+2eKxpaWmkpaVZ9KlQKMxjC0JJ9MPf1/j7egJujqZf7SAPZ0Y/e/9bgtV/XSUmTc2452vk2v5mUiarjl4lS6NDKpUwuHklwnzdSVdr+fK3C2RqdDSp4MfL9Uy78FyKSeX3SzG81Sb8sWM3Go1cjFex83IScZlaQj0dea2eP+U8bVcvQxAEobi8+uqr7N6926LulVAyGbxD7B1CqWHQKayfVETcJNbHcnNWPVYf1trbilEqdkJ76ik8MMpL/9JzNzd3pk+fw4cfjqNChTAGDRrMa6+9wogRo0hJSeGrrxZjMBgYOLAPgwcPY8yYiXz++SxUKhVffbUYFxeXXBNXp0+fYuTIoSQkJODt7c348R/9d4+E9s91ZNz4j3jvvbeJjr5LixateOGFzkgkUkaNGsqcOV/h4uJi7kuhcESjyTYnr+RyOSdOHKdfvx4oFI6MG1cDuVxOo0ZNOHPmlA2uWumVb/Jqx44dj9X5oEGDkEgkJCUl4ejoSNu2bZk1a5b5/tOnT7N582a8vb0ZN24cixYtYsKECbRv35727dvz999/W/RXtmxZypYtC5g+6M6aNYtnn302R+IKwNPTk27duvHcc89x/Phx3n77bbZt20ZMTIzFbK7AwEAyMjLIzMy0WDq4atUqFi60/Halfv36rFu3Di8v18e6LkLJ4efnbu8QitTl2DRGta1KlQBljvv+uhbP4atxVPLLeR9Atk7P7N1nGdKyCvVCvDkelciiAxHM69mQI1fjqBviTZfaZRm/5QQda5TByUHGj8dvWCTHCut2ajY7IpK4lqzG18WBgXX9qeHvkmvyPC+l7bl8monnsnSx9/MZERHB9OnTSU9PRyqV8umnn1KzZk2++eYbtm7dil6vp2vXrowcORKJRMLvv//OvHnzUCgUfPrpp+bSBJMmTaJTp04888wzhYojODiYEydOULduXVHrqoRz3T4egMwuc+wcyZPPq8w1AJLvhhX7WHt0prGed8h7rD2nG5nOqfNPofqw1t5WHLM3A5Dt2MOucQh2FPUjjmkqsgPt8xpI3brz/g253PK2i4vFbaPSw/K2j4/l+fm4V5fK1dWVsmVDkMlkyGT3k0RTp36Em5sbWq0WgBo1aqJWq2nSpJlFgulh95YN3rx5gw8/HG8uNSTR66lTLhSJREJ4eDVu3oyiS5eXcHU15QnKl69AYmICKtX9RLZGk42j4/0v2zdtWk/v3q/w0ks92bhxPevWrWbgwDcK9HiF/OWbvDp//ny+jYODg/O9/96ywQsXLjBkyBDq1atnMUW+Y8eO+Pr6AtCzZ09mzpzJhAkTrAadlZXFBx98QExMDN9++22u5zyYeGrYsCH16tXjyJEjGAyGXM9/+I3koEGD6N69u8Wxe0my5ORMdLrc+ykse7+5f1rFxxfPdFt7PJ9avYGopAx+OXub7/5UE6B0YkCTMHzdnLiTksX2s7d5uW45ztxJybX9mdvJ+CudqRdiWurboJw3/u6mP8RymZR0tRa90YjBaEQqkbD3UjT1y/ng5VL4b1WTVVp2X0nmZHQmrnIpL1XzoUlZd2SFKMZemp7Lp11xPZcgnk97KOrn08FBWuAvkVQqFYMHD2bGjBm0bt2a3377jbFjxzJx4kR2797Nli1bkMlkDB48mIoVK9KpUycWLFjAypUruXPnDsuWLWP+/PmcOXOG9PT0QieuwFSgvV+/fjg4OKBQKAo1i12wDafEtQBkIpJX+YnJ0LHiTFK+57xT5ywAK3Z7FnoMwOo4AD8Fm8a6cyfvsX76rbnpHMmvherDWvv8xGToCH3kVrlzUi8HRPLqqXZlCU5avd2SV7aS1xfZ6enpbNu2mR9+2Eh8fBx//HEAgP37f6NixUr888/fvPhiVwIDg3Jtf0+5cqH07v0K8+bNZsaMuaDRcP3UCSq1f54rVyLo2rU7b745kOXLf0Amk3L79k0qVqxMVlYWGRkZZGercXR0Qia7X5PXxcUVFxfT+xQfH18uXbpQNBdDyD95tXr16jzvk0gkPP/88wUapHr16kycOJFJkyZRp04d8+ypB59kg8FQoG8i7969y/Dhw6lYsSLff/89Tk45lxSlpaWxdu1ahg0bZn7BG41GHBwcCAoK4vTp0+ZzY2Nj8fDwyJGZVSqVKJW5z1ARhJIoOUtD9SBP+jQMJcjDmR1n7zBv7wWmvFibxQcjGN6yCtcS8t7iOSZNhaeznKWHLhOVlImLwoF+jSoA0LyiP0v+iGDytlN0qhmMRm/gz6txTH6xdqFiVWn17L+WyuGbpqW5bSt40KaCJ85PwfRnQRBs58iRI4SEhNC6dWsA2rVrR9myZfnhhx/o3Lmz+d/+l19+mZ9//plOnTqhUChQq9WoVCrkcjlGo5G5c+cye/bsx4plzZo1j/14BNtI7HHK3iGUeCEhBavb8t3vpvOcAgtXt9IrNcXU3sPT6rk99aax5PmM1bOvqVaUXF6pUH3ca+/iEo5Wq7ca04NCKfh1syZVualI+hGeYG12kmrHmlf25urqSpkyZXnzzYG4urri5eVFTEwMq1Z9x8KFS7l+/Spz5sxk+vTPrNa86ty5G9u3/8TJk/9idHZm1YF9xG5YS4sWrQgOLsuwYW/zzjvDcXBw4PXXh+Do6MjQoW/x3ntvYzQaeffdsQCsWLGMFi1a0atXX6ZP/5iff/4JhcKRyZM/sdVlKfUKnbx6VJ07d2bz5s3MnDmTxYtN1fj37dvHiBEjcHV1ZcOGDbRt2zbfPlJSUnj11Vd5+eWXGTlyZJ7nubq6smbNGipUqECHDh24cOECZ86cYdasWRiNRj777DNu3LhBaGgo69evp127dkX2OAXBXvzdnZjQoab5dudawWw9dZNlh6/QoXoZQrxd801e6Q1GTt1KZlKnWlTyV3I8KpE5e84xv09jnOQy3mtX3XzuskNX6FGvPDcSMvjp1C0UDlJeaVTBPFMrLzqDkb9upfHb1RRUWgP1y7jRoZIXns7FuneEIAilUHR0NHq95YfHh794un79On5+fnz44YdcunQJpVLJuHHjiI6OplmzZubzAgMDiY2NBWDcuHG89957ODk58cknn7Bp0yaaNm1qdba5NcHBwezevZuLFy8yfPhw9u3bR+fOnR+rT6GYuPvaO4ISr1+/gfYOwa78/NyLdZawVZK8l0MJTwkHF5A9WgL1SdOpUxfzzx99NNX888qVptmxc+Z8maPNvftq1arDF18sAMiRuAoKKsOcOV+YV1JJpVKWLfvefP/4CZNwd78/U79Nm3a0aWOZL2jUqAmNGjXJ0a+joyNKpQdz5nyV62MaPHhYrseFgsn3E+OMGTP46KOPcuzYd88333zzSINNnjyZrl27cujQIQB8fX0ZMmQIycnJNGrUKM9x7lm3bh3R0dHs3buXvXv3mo+vXLkSjUbD0KFDWbp0KQEBASxevJjp06ezYMECZDIZX375pXnnw1mzZjF69Gi0Wi3lypXjs88+e6THIQgl0c2kTKISM2hZOcB8TKXV8/f1BKJTVew6d4eMbB1ZGh2f/XrOItEF4OmioIynM5X8TR/8Gpb3Ydnhy8Slqwn2vP8m6Wp8OpkaLbXLevHx9lOMbluNhEw1m/6NyrNwu9Fo5GxsFrsuJ5Go0lHZx4kXq3hTRulYDFdCEISnQf/+/blz547FsZEjRzJq1CjzbZ1Ox8GDB/n++++pU6cOv/32G0OHDiUsLGc9m3uzvxs2bMimTaZZDampqWzcuJHVq1fzzTffcOrUKSpVqsTYsWMfOd6lS5dy5MgRYmJieO2111i4cCFRUVG8/fbbj9yXULzctr4LQMZLX9k1jtLAMXs9ANmOfYt9rI0RprF6hec91saNpo8+vXrpCtXHvfZvvVXoMIuELa+rUEJd/wHHdBXZQeI1UJQkOh2S5GRwf/QyEw0aNMLPT2zuVpzyTV7d+1ayQ4cOj9xxREREjmNhYWGcO3cOgFOnThEeHs6UKVPy7KNJkyYWReNHjBjBiBEj8jy/SpUq5rpUtWrV4scff8z1vNatW5uXEAhCaSEBVv11jfBAD/zdnfjtYjRV/JVM7VLHfM7By7Ecu5GQ626Ddct6s+bv61xLSCfM152L0alIkODndn82ldFoZO2x6wxvVQUArd6ITCpBgoRsfe7f/txIVvPL5SSiUrIJdJMzuH4AVXydH6kYuyAIwsPWrFmT68yrB/n7+xMWFkadOqa/g+3bt2fSpElIpVLi4+PN58XGxlps5nLP119/zbBhw7h79y5Hjx5l1apVTJo0iaNHj1rM3CqIX375hY0bN9K7d2+8vLzYsGEDffr0EcmrEsgxxZS8zOAr+wZSCjipTbMZbJFkWXPRNFZ+yas1a0zLAfNKXlnr4157eyevbHldhRLq6remmlcieVWkFo+dCJpsCjOnTSSuil++yatnn30WgO7du5OcnMypU6dwcHCgTp06Ja4elEqlokWLFnh5edk7FEGwixBvV15rVpHP95zHYDTi7erIyLa5z4S659+oRH67FM2EDjXxdFHwfvvqrPjzKtlaPQ4yKe+2q4bC4X4dqgOXY6ke5IHff8sDu9cNYcaus8hlEt5sXtmi74RMLbuuJHE2Ngt3Rxk9a/jSMNgNqUhaCYJQBO7tDJSfVq1a8dlnn3Hu3Dlq1qzJP//8g0QiYdCgQSxcuJDevXvj4ODAli1bePnlly3aXrp0ibt379KuXTsiIiLMW2BLpVKLXYYK6l6h9nuUSqW5T6FkSXzlsr1DKDVSldtsNtbGLtbH2rgx/99da33cb2/fzT9seV2FEurZvaTaYenqvc1GSit9WEV7h1DiGI1Ge4dgVqB3TQcOHGDChAlUrlwZg8HAzZs3+fLLL2nUqFGhB35wWn9RcHZ2plu3bkXapyA8aVpU8qdFpbyz/q2rBNC6yv1lhXVDvDlwOcZ8u1qQB9O61s2zfdtwy5kJjUJ9aRRqWRskU6Pnt6spHL2VhoNUwnMVPWkd6mGRBBMEQbAFPz8/Fi1axCeffIJKpUKhULBgwQIaNmzI5cuX6dWrF1qtlnbt2vHSSy9ZtJ09ezYff/wxAOHh4fj4+NClSxdCQkJo2bLlI8cSFBTEgQMHkEgkaDQali9f/th1tIRi4ijqCRUZSeEKtReGXGZ9LLmVU6z1Ya29zdjwugollFRu+s+WQ0od0Go1KBSluOxHATaQe9potRqk0pLxZVuBovj666/54YcfqFzZNLPi/PnzTJ48mS1bthRrcIIgFK87KVl0qR1SJH1p9QYOR6Wx/3oK2Tojjcu683wlT9wdS8YfO0EQnk6NGjVi48aNOY4PHz4831qbK1eutLg9Z86cx4pj8uTJjB8/noiICOrWrUudOnWYN2/eY/UpFA+3n0ybAmV0X2jnSJ58jmrTLpvZTv2Lfaz1l0xj9a2a91jr15vek/Ttm/uyQWt93GtfxN/BPzJbXlehhLq2Esd0NdllbPcacHPzICkpFig5M3EKSyqVYjAYct6RmWn6v6urbQMq0SQold72DgIoYPJKIpGYE1cANWrUKFHTxwRBKJxy3o//h9lgNHIqOpPdV5JIUeup5udMpyreBLgprDcWBEF4SgQEBLBq1SpUKhV6vR43Nzd7hyTkwTF1KwAZiOTV43LKLmnJK9NMlcInr0zt7Z28suV1FUqoaytNNa9smLxycXHDxaV0/NuV146hHi91AiB1605bhyQUQL7Jq5SUFABq1qzJ8uXL6du3L1KplC1bttC0aVNbxCcIQgkWmajil8tJ3EnTEKxU0KeWHxW9ne0dliAIQomRlJTE1KlTuX79Ok2bNuX9998vMYkrnU4n6m7lIvG12/YOodRI9bDdB8CtL1kfa+vW/GteWevjfns717yy4XUVSqj2B+xS86q0E0mrki3fdyxNmzZFIpGYZ1nNnTvXfFsikTBhwgSbBCkIQskSm6Hhl8tJXIpX4ekko28tP+oGuYpi7IIgCA+ZPHky5cqVo0ePHmzbto3PP/+cyZMn2zssANq2bcvLL79Mnz59KFOmjL3DEQRBEARByFO+yatLly5Z7WDHjh107ty5yAISBKHkSsvWsScyhX9up+PoIKVTFS+al1Mil4nihoIgCLm5efMmixYtAqBJkyb06tXLzhHdt2HDBjZu3Ej//v2pUqUKr7zyCq1bty7VO0kVhPumoQCk91xq50iefE7qlQConV4r9rFWXzCNNaB63mOtXm1a9jdggLZQfdxr//77hQqxyNjyugolVOQynNLVqMu+Zu9IShWn1SsBUA94za5xCLl77E+cy5cvL4o4BEEowbJ1BvZGJjPn0G3+vZNO83JKJrQsS5sKniJxJQiCkA/5A9uTOTk5IZPJ7BiNpaCgIEaPHs2+ffvo1asX06ZNo127dnz77beo1Wp7h2c3ivTdKNJ32zuMUsFRswVHjW02eNoauYWtkfmPtXWrA1u35v3dvbU+rLW3FVteV6GEivoRx1jxGihqjlu34LhVXNeS6rH/+orC7YJQOkQmqthwLp7eNf2o5GOqW2UwGvnnTgZ7riSTrtFTK8CFFyp74+sqtmgWBEEoiIffJ5W0WU1Xr15l48aN7Nixg7p16/Lyyy9z6NAhRo0axbJly+wdnl0kvn7T3iGUGqnKn2021uau1sfavDn/mlfW+rjf3s41r2x4XYUSqt1vouZVMUjdLH63SrLHTl6VtDdhgiA8ushEFStOxKI1GFlxIpbX6/ujNcDOy0nEZmgp7+nIwHr+lPd0sneogiAIT5TExERWrFiR5+3XX3/dHmEB0LdvX27fvk2PHj3YuHEjQUFBALRp00ZszCMIgiAIQoli/3mvgiDY1YOJKwCtwciy47EYAR8XBwbU8admgItIVAuCIBRC8+bNuXz5cp637al///507NjRYmkjgFQqZf/+/XaKyv7cN7wGQHrvlXaNozRwUptm76mdhhT7WN+dM431Rs28x/ruO9Nr/Y03cq95Za2Pe+3tvWeVLa+rUEJdXoxThhp1iHgNFCWn7/773XpDXNeSSCSvBOEp9nDi6h4jIJPAS9V8CPd1sU9wgiAIpcCsWbPsHUKeOnTowIEDB8jMzARAr9dz8+ZN3nvvPVxdXe0cnf0oMg7aO4RSw1GzC7BNkmXPDdNY+SWv9uwxffTJK3llrY977e2dvLLldRVKqDvbcdToRPKqiDnu+e93SySvSiRR80oQnlJ5Ja7u0Rvh+5NxvF4/wFwDSxAEQSg93nvvPW7dukV8fDzVq1fn9OnTNG7c2N5h2V3iG9ftHUKpkaq0XeHj9Z2tj7V+ff41r6z1cb+9vWteiYLST722u0TNq2KQul78bpVkj71NWJcuXYoiDkEQbGzDufg8E1f3aA1GNpyLt1FEgiAIgi1dvHiRLVu20K5dOz788EPWr19Perr4MCQIgiAIQsmT78wra4mp7du3M3jw4CINSCg+/277FCd3f1PtIokEg06LTO5IudqdcPUqk29bdUYSN8/8gi47C6NBj2/5egRUamZxzt2L+9Fp1ZSr/UK+fWVnJnPx4DIqN3vVYlyj0UjUyZ9xUvoRWOmZwj9QwSqt3kCopxOnYjLzPU8uldC7pp+NohIEQRBsyd/fHwcHB0JDQ7l8+TIvvPACKlX+M1OeBsr1/QBI67vWzpE8+ZxViwFQOb9V7GMtPW0aa2idvMdautRUs2ro0NyXDVrr4177jz4qdJhFwpbXVSihLn2Nc6YaVTnxGihKzkv/+90aKq5rSZRv8mry5Mm2ikOwkfDmA3FwvF/DKCbyT26d3UXVVvknIW+c3IZvuTr4lq+PXqvm4sFvcfYIROlXAY0qjVtnfyU17gq+5erl249Br+P6iZ8wGvQWx1Xp8dw6s4uM5NuUUbYp9OMTrItMVLH5QgKJWTqq+DpxPSk71xlYcqlELBkUBEEoQrt37+bixYsMHz6cffv20blzZ7vG4+Liwvbt26latSobNmwgLCyMlJQUu8ZUEjhkHbN3CKWGXGuqH2aLJMuhO6ax8kteHTpk+uiTV/LKWh/32tubLa+rUELF7kOerRPJqyImP/Tf75ZIXpVI+f4FfrDuQUpKCiqVCqPRaC7oKTzZjAYDmqw0ZApTcuLupQOo0uPRqTPQZmfi4hFI+bpdkMkd8S1XD+/gGgDI5E44unqjyUoFICHqJG4+5XBy90WvVec75s0zO/EJqUuM6pDF8fjrx/EpVxeFs0cxPFIBIEur55eIJP65k4GPswNDGgZS2cc519pXInElCIJQtJYuXcqRI0eIiYnhtddeY+HChURFRfH222/bLaYpU6awceNGxo0bx+bNmxkwYADvvfee3eIpKZLeiLR3CKVGmvJHm421upP1sVavzn9mobU+7re3b80rW15XoYRq/TNpouZVkUtbLX63SrICfX3w9ddfs3TpUgBkMhlarZZKlSqxffv2Yg1OKHoRR75HIpGgy85EInPAI6AKofW6me/PTLpDtdZv4uDoyvV/fyI64iBlaz6Pb/m65nNSYyPJTLpFaD3TstIyVVsDpuRXfhKiTmA0GPALrU/MZcvk1b2lhunxokhqUTMajZyJzWTbxSSytHraVPCgfUVPFDJTybtKPs68Xj/AnMASiStBEISi98svv7Bx40Z69+6Nl5cXGzZsoE+fPnZJXg0YMMBUQuA/AwcOxGg0Eh4ezq5du3jllVdsHpMgCIIgCEJ+CpS82rZtG/v372f27NmMHz+ev//+mwMHDhRzaEJxuLdsMCslmit/rcXNuyxyx/vbYXsFV0Pu5AaAb/m63Dq7h7IPtE+8eZpb5/cQ1qgXcqeCf+uUlRJN/PV/CW/xWhE9EqEgUlQ6frqYyMX4LIKVCgY3CCBY6ZjjvHsJrA3n4uld008krgRBEIqYg4MDCoXCfFupVOLgYJ8lSK+++ioAe/fuJSMjgx49eiCTydi2bRtKpdIuMZUkyrW9AUjrt8HOkTz5nFXzAVA5jy72sRadNI31dr28x1q0yFSz6u23c182aK2Pe+2nTi1slEXDltdVKKEufo5zRjaqUPEaKErOi/773XpbXNeSqEDvmry9vfH39ycsLIxLly7RrVs3Vq1aVdyxCcXIxTOIkJodiDq1HVfvsji6eAIgkTywAaXRaP5m1mg0cvv8XlLuXqTKMwNw8Qh8pPESb51Br8vm0qHvANCq07n+70+UrdEez6DwInlMwn0Go5G/bqWz83ISRuDFcG9alFMik0rybFPJx5kPW5ezXZCCIAhPkaCgIA4cOIBEIkGj0bB8+XKCg4PtEkuHDh0AWL58OevXr0cqNf3b36ZNG/r06WOXmEoSB9Vpe4dQash1pvphttgG4His9Vplx4/L/vsp9+SVtT7ut7cvW15XoYRKOGqqeWXvOEoZ+XHxu1WSFSh55eDgwM2bNwkLC+P48eO0aNGCtLS04o5NKGbeZWuScPMkt87+SqUmpjerKdGXCarSEqmDIwlRJ/EIrALArbO/kpl8m6qt37SYqVVQIbU6EFKrg/n22T1fU6FBd6u7HAqPLiZDw+bzCUSlZFPFx5mXq/vg7SK3d1iCIAhPtcmTJzN+/HgiIiKoW7cuderUYd68eXaNKTk5mezsbJydTbNtMzMzSU1NtWtMJUHS4Ah7h1BqpLn/YLOxVnS0PtaKFfnXZrXWx/329n1fZcvrKpRQLTeLmlfFIG2F+N0qyQqUvBo2bBiTJ09myZIlfP3112zdupU2bdoUc2iCLZSr9QIXDvyP1DhTcVK5kytX/lqLLluFu285gqq0QKNKJf76MRQunlz58/4vtH9YE4taWA/TqNKJ/GstlZr2Q+Fs38KWpU2/5YcI8XJB+t/MOI3egJNcRu3QIE7FqnB0kNK3lh/1glwt6poAxKSp+O5IJOlqLTqDgTZVAnmxlmlxaGRcGiuOXiVbq8fLRcFbbari5aLIMf49celqPtp6kokdaxLmZ/kc/3MjgW/+uMzygc8U8aMXBEF48ri4uLBq1SpUKhV6vR43Nzd7h0Tnzp3p3bs3zz33HEajkd27d9O7d297hyUIgiAIgpBDgZJX1atXNy8T3Lp1K1FRUeYp5sKTo0G3KTmOObn7Ur/LRwBkJt3GWRlgLp5+j8LZI9e2DytTtc1D7dxxVvojleWcYl3r+Xdy7SO0frdcjws5fdSpNkon0zd/15PVrDwRzb8xKuoHudK5qg9uityntn/zx2VaVw6gbXggWRodk7adItTHjfAAJV/9fpFRbasSHuDB3ot3WXroMhM61My1H43OwOIDEegMhhz3RaeqWHvsOgajMZeWgiAIT5927drRpk0bevfuTcOGDe0dDgDvvPMONWrU4K+//gLggw8+oHXr1naOyv6Ua7oDkNb/JztH8uRzVn0BgMr5/WIfa/4J01ij6+c91vz5pi/kRo/WFKqPe+2nTSt0mEXCltdVKKHOz8Y5MxtVBfEaKErO8//73RotrmtJlG/yKiUlBYAhQ4awevVqjP/VQPL19aVfv37s2bPHFjEKTyiDTovSvyIOChd7h1JqqbQGdl1J4q9b6cglRpRk07d2BTadiOJ2chapKg2pKi3lfVwZ0qIyLgoH2lQJoFmYHwAuCgcClE7EZ6hxkElwljsQHuABQNsqgaz+6xrpai3uTjmnx688Gkmryv5sPZ1tcTxbp2fxwQhebRLGwgOXiv8iCIIgPAH27dvHjh07+Oyzz0hPT6dXr150794db29vu8bVvn172rdvb9cYShoHtVg2WFQcdGdsNta5BOtjnTuX/5fv1vqw1t5WbHldhRIq+RQO2bnXbhMKz+Gc+N0qyfJNXo0ZM4YjR44A0KRJk/uNHBzEG51S6OGZU49L6iDHJ6R2kfYp3Df914ugcMUokaDXqKnm68jL9Sqa74+MT2NGt3q4O8lZfCCCn07epH+TMNpUuV9s//TtJK7EpTG0ZRUuRqfg43p/J0IHmRSlk5zkLE2O5NX+iBh0BiPPVg1i6+lbFvctPxxJu6qBlPN+9NpogiAIpZW7uzuvvPIKr7zyCpcuXWLKlCl89dVXnD171t6hCQ9JGnzB3iGUGunuK2021tLnrY+1dGn+Na+s9XG/vX1rXtnyugolVIv1pIuaV0UufelKe4cg5CPf5NXy5csBmDhxIrNmzXrkzsPDw6lSpQpSqRSJRIJKpcLNzY2pU6dSq1atAvVx+PBh5s6dy7Zt28zHDhw4wLx589BoNISHhzNz5sxca0ecPn2aTz75BJVKhb+/P3PnzsXf3x+Ab775hq1bt6LX6+natSsjR47MURtIEEqiVLXO9E29kwtB7gqaB7uw4kgE4TXC8HC+X5+qSaif+Xab8ABW/3WN/g/088eVWH74+xrvPFsNLxcFeS3we3iDwusJGfx2KZopL+ZMTO69cBepVEKbKoHEp+f/BlEQBOFpc/78eX766Sd27dpFrVq1+Prrr+0dkiAIgiAIwhOhQDWvZs2axenTpzl06BBarZYWLVrQqFGjAg2watUqiynxy5cvZ/r06fz444/5tlOr1SxZsoQ1a9YQGHh/pkhSUhITJ05k3bp1hIaGMnfuXD7//HOmTp1q0V6j0TB69Gi++OILGjRowNq1a/noo49YtmwZBw8eZPfu3WzZsgWZTMbgwYOpWLEinTp1KtBjEgR7MBiNHLudzs7LyTg7O/NsBSXPVfJGJpWg04Wx7PAVKvsr8XN3AkD2QNbJaMRc3N1oNLLm2HWOXU/gwxdqEepjSvz6uDqSorpfA0JnMJCercXLxZEHHYqMRaXRM3W7aSvx5CwNiw5G0K9RBQ5eiUWjMzDxpxPoDAY0etPP45+vgZerZT+CIAhPky5duqBSqejRowdbtmwhICDA3iEJefBY3RmA1AE77BzJk88l6zMAslwmALB27ffcuhVVLGMdVfwJQDNN3hvFHD3aznROs32kpqYA4OHhWeA+7rVv1eoAWq3+cUMutPZ1TXH+dsoyzpCQ8vTrN9AeIQm2dnYaLlnZZIVNsHckpYrLvP/+Zo0R17UkKlDyauvWrXz55Zc8//zzGI1G3n//fUaNGvXIO9LodDqio6Px8DDV1FmwYAFXrlwhISGBxMREqlatyowZM3Bzc+Pw4cOoVCpmzpzJ/PnzzX0cPnyYWrVqERoaCsArr7xCt27d+Pjjjy1mTp09exY3NzcaNGgAQM+ePZk5cybJycns3buXzp074+JiqsX08ssv8/PPP1skr9LS0khLS7OIX6FQmGduCYItxWVo2HwhgevJ2VT0duLw+es80ybEnKB6pqI/By7H8v1f1xjzXHUA/r2ZyEt1Q3CSy/g9IoZ65UxJ5O//usaVuDSmd6uL8oGZWpX83clQa7kcm0aVACUHL8dS2V+Jq6Pln4mBTSsysOn926N/PMbbrcMJ83OnQXkf8/H4dDXjt/zLrO71i+uyCIIgPDE++OADmjdvbu8whAKQaW7YO4RSQ6a/YnH71q0oLl+LQOaR907GhXXT11TGwD/xet7nxDibz9GlmGp2JuiSC9zHvfaXYiIfP+DH0MXZFOfVB+LUp+ZehF4opdIjkKlFzauiJou8Yv0kwW4KlLxauXIlGzduNCduhgwZwuDBgwuUvBo0aBASiYSkpCQcHR1p27atxRLE06dPs3nzZry9vRk3bhyLFi1iwoQJ5gKif//9t0V/MTExFjOxAgMDycjIIDMz02Lp4MPnKRQKvL29iY2NJTo6mmbNmln0ERsbazHOqlWrWLhwocWx+vXrs27dOry8RC2f0sLPz93eIeRLZzBy4HoK+66moJBJ6VXTl4Zl3Dh4JuebpteaVeSDn05w+rbpTZiHk5w5v54nPVtL1QAPXqoTQmJGNnsu3MXXzZFZu8+Z23aoUYY2VQJ5t311Vv4ZSbbOgLujAyNahwOQnJnNnD3nS/QMqpL+XAoFJ57L0uVpfz6XLVvGkCFD+P3339m/f3+O+ydNmmSHqIT8JA0+Z/0koUDS3b/NcUzmocCjVZkiH6sdL1k/p9Xm/34qQ+ofdwEsYrHWx4Pt7WlF2ksAeLS6f+ze4xGeEs/8IGpeFYP0JTn/ZgklR4GSVwaDwWLGUUBAAFJpwXbbuLds8MKFCwwZMoR69erh43N/dkbHjh3x9fUF7s+OmjAh72l6BoMh1+MPx5PXeTKZDKMxZ3Wfh9sPGjSI7t27WxxTKEzfEiUnZ6LT5d5/YT3tb+7tJb6Y/ugXxfMZlaJm0/kEYjO01Al0pWtVH9wdZQCsHdwyx/llPF34/vUWAFyJSyPE25XXn6lkcY6Pm4w1ubS9p5KfO9O71ctx3MvVkRAvVxxkOX/v5/dpnGtffu5OrBhku1kGJfm5FB5NcT2XIJ5Peyjq59PBQfpEfYnk7m56zXl5edk5EkEQBEEQhCdXgZJXnp6e/Pbbb+YdBn/77Tfz0r+Cql69OhMnTmTSpEnUqVOHsmXLAqZk0j0Gg8FqUiwoKIjTp0+bb8fGxuLh4WFeAvjgefHx8ebbWq2W5ORkAgICctwXGxtrMUsLQKlUolQqH+kxCkJRUOsM/HolmT9vpqF0kvFavQCq+7tYb1iMsnV6apf1yrHroCAIgpC/vn37AuDt7U2/fv0s7lu6dKk9QhKs8FjVAYDUQb/aOZInn0vWdACyXIp/huHJlL8AqOfZNO9zfnrBdE73XYXqw1p7W+keYorzp1t5P1ahlDszBZfMbLIqidm7Rcll9n9/sz4Q17UkKlDyatSoUXz44YdMmzYNo9GIQqFg0aJFjzxY586d2bx5MzNnzmTx4sUA7Nu3jxEjRuDq6sqGDRto27Ztvn20aNGCzz77jBs3bhAaGsr69etp165djvPq1KlDSkoKJ06coH79+mzevJm6deuiVCpp164dCxcupHfv3jg4OLBlyxZefvnlR348glDULsRlsfViAqlqPc+UU9KhshdODgWb5fignvXLF2lcjg4yWlQS9d4EQRAe1bp161Cr1axcuZLs7Gzzca1Wy+rVqxk6dKgdoxNyI9XFWj9JKBCZ4Y7NxsrUW5/lmZmU/wxIa31Ya28r3gqxXOypl3ULWbaoeVXUZHdt9zdLeHT5Jq9SUlIAmDZtGhs3biQyMhKpVEqZMmUYOHAge/bseeQBJ0+eTNeuXTl06BAAvr6+DBkyhOTkZBo1asTw4cPzbe/j48OsWbMYPXo0Wq2WcuXK8dlnpl0Bzp49y6RJk9i2bRtyuZyFCxfy6aefolKp8PT0NJ/37LPPcvnyZXr16oVWq6Vdu3a89NJLj/xYBKGopGfr+flSIqdjMglwk/NWE3/KezrZOyxBEAThMTk4OHD58mXUajWXL182H5fJZEyePNmOkQl5SR58yt4hlBrpbktsNlYLn+esnzN47WP1Ya29rSy/av2xCqVc0xWi5lUxSJ9vu79ZwqPLN3k1ZswYjhw5AmAucG40GnFwcDAvIcxPREREjmNhYWGcO2cqhHnq1CnCw8OZMmVKnn00adKEHTsst4y8Nc0AAIaOSURBVCpu3bo1rVu3znFurVq1LLaerl27Nps2bcq13+HDh1tNlAlCcTMajRy/k8GOiCQ0egMdKnnSuoInDlKJ9caCIAhCiderVy969eplUX5BEARBEARBeDT5Jq+WL18OwMSJEy12CCypYmNjc9STEISSKiFTy5YLCUQmqang5UiP6r74uxX91tGCIAiC/dWvX5+VK1eSmZmJ0WjEYDAQFRXFvHnz7B2a8BDPVaZyFCmD9tk5kiefa+ZUADJdpxb7WP+mmL5wb+CZ92Yx/27qbDqn547c77fSh7X2ttKznCnOTTdttzGOUMKcmohrlobMylPtHUmp4jp9KgCZk6baNQ4hdwWqeVVciatRo0YVaX8BAQEWM68EoSTSG4z8cSOVvVdTcJDCy9V9aFzWHalEzLYSBEEord59912cnJyIjIzkmWee4c8//6RBgwb2DkvIhUSfau8QSg2JMclmY2Xr1dbPych/p1JrfVhrbytuDtYfq1DKZSci0YqaV0VNkmy7v1nCoytQ8koQhKJxKzWbTecTiE7XUNPfhW7VfPBwEr+GgiAIpd3du3f57bffmDp1Kn379mXUqFGMHj3a3mEJuUh+47i9Qyg1Mtzm22ysZ3xybuCU45zXfnysPqy1t5WV16w/VqGUa7KUDFHzqshlzLPd3yzh0YlPzYJgAxqdgV8jkzkclYabo4yBdf2pGVAyvr0TBEEQip+vry8AoaGhXL58ma5du6LT6ewclZCbI0f+AKB581Z2jkQQBEGwJfH3v2QTyStBKGYRCVlsuZBIskpH0xB3XqjsjbNcau+wBEEQBBvy8fHh22+/pW7duixYsAA3NzcyMjLsHZaQiwZ/DDb90PyKfQMpBVwzPwIg03VGsY/1T7JpJ/NGXi3zPufHbqZz+mwrVB/W2ttKn/KmOH+MyvuxCqXcibG4qjRkVin+362nied/Na/Y9btd4xByJ5JXglBMMjR6tl9K5GR0Jv6uckY0DqKCl5O9wxJKoKOzd+Ps54bkv7pnBp0emcKBsA41cAvyKFAfKdcTiNofQZ03TMVb48/e4e4/N8z367N1aNLV1H+7DQpXR4u22akqru25gCZdjdFoJLRtOJ5hfgDEnrxJ9PEoJFIJjh4uVOxUE7mL2FhAEB7Vp59+yi+//ELDhg2pWbMm8+fPZ+zYsfYOS8iFg1Rv7xBKDYlRZbOx9EbrMxn1Gvlj9WGt/aMw6A1IZYX7MlMhFbM2n3p6FRK9xt5RlDpyMSO6RBPJK0EoYkajkb179zL/8G2ydQbaV/Tk2TBPHKSiILuQtxqvNLZICt39+zrX916g1sBm+bbTa/XcOXqVmH9vonC/nxz1qxWMX61gwPQG+fyavwluWiFH4grg0qYTBNQLIbB+OTJj0ji/7hgNRz2LJkPNzT+uUHdoS+TOCq7vvcitw5GEPV+9iB61IDw9fHx8GDhwIADjxo1j3Lhxdo5IyMs8Xgdggp3jsJW0tFR+/vkn5HI53bq9jJOTc6H6OXv2NBpNNvXqNUQqNSVlMty+KLI4M++mkX4jCecANzwq+ua4v6l321zbqRMyiTt+C6lCRsMea3HI5wuYvPq4p3HfH5HIpEDh39NpUtXc+Pk8mjQ1nlX9CX62kvnLq4JafT3/OIXSISsri88/n8nlyxG0atWGoUPfvn9no0Wi5lUx+Kn9c8DT8/f/SSOSV4JQhOLiYvn22yWcOXOK8p6O9KjhS6CbmKUiPBqjwUB2mgoHZ9Nr59ahK2QlZKDN1KDNzMY1QEnYCzVxcHQg9XoCBo2eip1qcutQZK793f3rOnIXRwLqlctxX2ZsGjq1lsD6pvtcA5XUfLUJSEyJWKPBiD5bh4OT3DwjTBCEgqtXr16+H0xPnDhhw2gEa+Lj4zlz5jRarYa//jpC06bN7R1SsZs0aTxXrlwGICLiIlOmTH/kPlau/JYff1wDQKtWbZk4cUqRxqhOzOTGtnMYDUbTgQ7gUSlnAuthRoORGz+fR6cy7cqmy9QQ2qVGoWKI/SuK+H9vI3WUUb5TNVzLFGxm9MPi/r2FJs20W2DKpTi8qvrjGly4voTSbcuWDRw9egSAn37aRN26DWjcuKmdoxIE+xGfQgShCOj1enbt2s7GjeuQSCSMGjWK4IjtSB/xmzTh6XV+3TEkSNCqNEhlUrwq+VGpU03z/Rl3U6n1WjPkLgqubD/D7SORhD5bFe8qAXhXCSA1KjHXfrVZGu4eu07t15/J9X5VUiaOHs7c2HeR9NspSKQSyrashIufO85erpRpXIFTyw7h4ChH5uhAzYHiTZMgPIodO3bYOwThESxa9BXzK5jqCb0+8xPWrNmEu7vS5nHcvn2LPXt24e/vT6dOXc0zmYra9etXzYkrgIsXLzxyHwaDgd27fzHf/uOP/YwZ8wEKhQLXTNP8hUzXzx4rzvSbyfcTV0BWTHqO5NWxZFOh5fCEaiSei8HR0xn/RiHmxBVAxD9DiUvzo3H/rbmOc6+Pxl6WxZq1GdnE/3ubW7feB8Dpr2WEvVy7UI8lx1LBQrxV7BdqinPtDVFUujTLzlY/dDv7/o1/3zXVvAp/vN8twVLX/f/Vupow2b6BCLkSyStBeEzXr19j2bJFXLt2lQYNGvH660OpVi2Mf+eIDyxCwd1bNpgZk8bFjcdxD/ZC/sASP5+qAeYlfwG1y3J938UC9Rt76hbelf1x8nTJ9X6jwUj67WTKNA4ltF010u+mcGnDv9QZ3JyshAwSI2Jo8FYbHFwURO2P4OqOs1Tt1eDxH3Ap9d7ffxLk7IJEAhIkaAx6nGQyeoZWpJybW4H6uJSSwvZbNxhXqy4A/8THcSDmrvl+tV5PikbD1HoNcJfnPrNz1+2bZOl09AgNMx+bd/Y0WoMB2X9LmBv4+PFsmeBCPlKhoIKDTdf4/Pnz+d4vlAypqSnw32bAWq0WlUpl8+RVZmYG48a9Q0pKMgAJCQk0bNiYPXt2UaZMML16vYJMJnusMe59CJ4+/WOL482a5Zxpdv36VQ4f/oPQ0Aq0bNnG4j6DwcD06VNM1+0/ZcoEo1AouHo1En/jXXz9/Ascl0GrJ/7EbXQqLT61y+Dkbfq3K+tumsV5eo0OTXo2CnfLpfCZd1O5deCyuY3UQYpnuB8pEfGm/jU6ki7Ekp2chV6nJz0hFdWfGnzrBePgnHc9q9QrCRa3pXIZ2SkqMm6l4OzniktgwV8j/o1CyE5WkZ2chYObgus/nUPu7khol+o4euX+b3VJo9PpuHDhHN7e3pQtm3NWt1A0unfvxbFjf3HzZhSNGzfN9ffzaWcwGIo0ua/RZCN5jGXBQvESyStBKKTs7Gw2bVrPL79sw91dybvvjqNJk2ceuW6BIDzINVBJaLuqXN11DrcyHuakk+SBf5iNRmOBX2eJF2MIfa5anvcr3ByROcnxrhIAgHsZTxw9ncmMSyf5ajzelf3NSbTA+uU4vfxIYR/aU+OtajVwk9//ELQ/+g5boq7xbo38v6XXGPT8ducOh2Kj8VTcT0o18vOn0X8f/vQGAwsunqNdUHCuiauU7Gx+irrOxdQUmjzwgTFbrychW830+o2QFdMMDiF/o0aNMv+s1WqJj4+nZs2abNq0yY5RCQ/r338QAz++hMFg4MUXu+LvH2DzGKKjo82JK4AzZ06xdesmc8JJq9UyYMDrheo7PT2NDz8cS2TkFerVa0BMTIzF/R07dra4HRcXy5gxo1GpsgB4551MOnZ80Xz/zZtR5mVNAD4+vsyc+Tn79//G55/PwmAwEBbmxJdfalAorJdRuPvHNVIuxZlivZ5ElQENkDrIMGgti+inXIwj/VoSFXvXQaE01XusnlGbGwcsk8TaTA0hHcJReLkQ91cUISGmGly3f3NDn6FFk5VNenwqmdFpVOxRO8eMK4DUyARi/rwBQEjIFyi8nPGtF8bVjacxaPQggfIvVse9vBd3/7hG8sVYnLxdKNepqsWXUPc4uCio8FJNVHEZXN142hRnejaxx25SrkNVq9cI7DvjSq/XM2nSeE6fPolUKmXs2Im0bdvebvGUZt7ePvzvfyvJzs7G0fGh11KDr8h8imteaTQapk2bwr//HqNatRp8+uksXF0L9iVhXhYv/prt/13n/j+s5NVXXyuCSIWiJN7BCkIhnD17mvHj32H79p9o3fpZ5s1bSNOmzUXiSigSvtXL4B7syY19l8zHkq7EolNrMRqNxJ2+jVcl699k69Ra1ClZuAd75nmOe7AXUgcpSVdMHxZUiRmoU1S4+LvjFqAk+Wo8eo1p55WkiFjcy+Tdl5CT3mgkOTsbFwfTd0W7b99k5ZUI5l84y8zTJ1h5JQL1fzvbRKSkkG3Q80pYpTz72xd9B3cHOc8EBOZ6/1/xcYQplbQJLGNx/GZGBo5SGUsjLjLnzCl+irqOxiB2VLOl33//3fzfoUOHWL9+PVWrFuyDqmA7DRs25plnWtCsWXNGjnzPLjGEhJQjJOT+bJbKlcMtlgtFRV0vdN/bt28lMvIKACdP/ktYWEWL+/fu3WVx+9q1q+bEFcC5c2cs7vfw8LBIStWr14CAgEB+//03DAbDf31Ecv361QLFp07MNP+sy9Kiy9KiTswiMzrnh3R9to6MWynm5YS6LMud1yRSCT61yyCRSHLMqtKptGhV989XxaVzfes57vx+xfxvnjmmpCyL2z61gtBlakyJKwAjpEclk3k3laSz0Rh1BlRxGcQfv53vY5XILN8zquMziT9x22J5ZFE7f/4sS5cuYt++PYXu4/btm5w+fRIwzXrZtUusNCgqen3u/y7nSFwJ7N//G8eP/43RaOTChXP88svPj9WfXq+36GP79q2PGaFQHMTMK0F4BOnpafzww0oOHvydwMAyTJ48jRo1atk7LKEUqvBcNU5/d4SUa6alDnIXRy5t/BetSoMyxJvgZmFWegB1chZyV8cc9TUyolO5uuscdd5ojtRBSrXeDbmx9wI3D5qWWlTqVBNHdyf8agejTlVxZuWfSGVSHJXOVHxRvN6tWXzxPBIJZGi1OEil1PD0skhIRWWk837N2rg6yFlz9Qq/3rlNt/Kh1PL2oZa3D5Fpqbn2m6HVciD6LmNq1slz7I5lQwBTkuxB2QY9lZQe9AytgEwq5YfIy/xy6ybdy1cogkcsFEbdunX55JNP7B1GkTt16hTz5s0jJSUFo9FIYGAgEyZMoHLlynm2OXPmDJs2beLTTz+1YaR5m+Cw+r93yI9euLwoODo6Mm/eAo4ePYKfnz/VqlXnzJmT3LhxHalUyrPPPl/ovhUKyw/BzzzTgqtXr2A0mhImAQFBFvdXqVIVDw9P87LARo2aWNzv5eXNpEmf8tNPG/H19WPIkLcACAw0JdjHD7qJTCYjII+E+z3JEXHEHLqOkfuJG9dgJXJ3R9IiEyC3hI4EMm6ncvfgVeTujsQ/m0RW4zTKHAtC5uxAaOcaOPubZmIow7yJ/kNC1HXTLp91XliF5m4mmckZpr4MkHknlYteN7l0+QLtanYzD+NR0YfE03cxaPTcujuRtH98aNB9DRKZFKPelKBzDVLCI+acnHxcCWhanoTTd9CrdWhS1cQejcKg0RPQtHye7fQaPX19dyORSvgx6QUk+exmrdVqkf83E/jWrZtMnDgGrdZUA8xgMPDccx0fLWhMs4GcnV3MSc3g4LKP3EdxyMzMYNq0KVy6dJHmzVvy/vsTHnt5rS1t2LCO779fjpubO1OmTKN69Zr5N/jnbdxUGjKqFd2Onk8SB4eiTWPIZDICA4N49a+jAGzv8EKR9i8UDZG8EoQCMBqNHD16mJUrvyUzM4Nu3XrQo0fvHG8CBaEwmn2Q882js48bTcd1ACD9Tgou/u6EPV89zz48yvtQ980WFsfcgjyoPzzn0gK3IA8U7k7m267+7tTo3yTHeRKJhHKtKlOuVd4fOoWc7i0bvJ2ZwdKIi4S6Ky2W+NXx9jHfbuLnz9aoGwXq92hcLDW9vPFxcrJ+8kNqenlT08vbfLt9cFlWXL4kklc29GDNK6PRyLlz51Cr1fm0ePJoNBqGDRvGd999R40aph3dtm3bxpAhQ9i3b1+eHyQjIyOJjY21Zaj50hlMcdrzTbK7u5Lnn7//4WnevIWcPXuawMBAyj/C7+29mTExMXdp164DXbq8RETERSIiLtCwYRP69OmPn58/Bw/up2LFSnTv3tOivbe3N19/vYRjx45SvnwFateum2OMRo2a5EhqxcebZvNma6RIpSCT5X01DToDd3+PNM84Ung4Edg8FLdyXqY+UlRIHKQYdQbTbKq6ZTBo9Th6OhN9yDQLTZuWjSZOhVfFAKqEN8DBRY7U4f7rLS0yAaPeiFRqmsGWfCEWv9BAnJWuyIKdif1vWaDUIIVsyyyUk48rlV+phzohk6zDSiRyA45eLvg1CiH1chyOPi64lvfEQeGAd60g87JBv4b3kzqq+Azi/r6JxEFK4DOh5qWOfg3K4hqs5Nrms+ZzH5x9lpsb28+T1NaUdLt7+irBbXOfrbtgwRfs2rUDPz9/pk+fw7VrkebEFZh2lixM8srdXcmnn85m1apv8fT0Ytiwtx+5j6SkJH79dRuOju7/b+++w5us2geOf5M0neketKXsUUD2EgGVUhmypwxFBAXxRXG8AoqIiIggKgoo/kR84fVFAZlOtiggIipDZW9oS6F7pW3G8/sjJVA60pmEcn+ui8s2fc4593OSJ7Z3zrkfunTpWur2hdm4cZ11RdjOndvo0KET9957f4X0XdlSUpJZvnwpiqKQmprC0qVLWLDgw+IbaTxQbqPkXEXr0iWaFSuWWd9rDh36k4ceGlmuPt94Yx6nB/ZChYpp016z3UDYnSSvhLAhIeEay5Z9zMGDf1CvXgNeeWVmqX5xFMLZ5KRnE9qqhqPDqPIivHQMqFmb1WdPU1unI8DN8sfKzXchVYCS7jY+lJRQ5mTT38lJeGg01POx3I5dUUCjksoB9nRzzSuVSkVAQAAzZ850XECVQK/Xk56eTlbWjW1W/fr1Q6fTYTKZeOuttzh8+DCZmZkoisLs2bMJDw9n4cKFpKen8/LLL/PWW2858AwsZqX3IzU1lZrz3nB0KOV2/vw5zp+3JHg2blxH+/YdcHV1pWXLluj1Wcyf/yYAOp0X8fFxvPPOnCL7Onr0b3744Zsif56drefYsWPk5uZYV3J98KUlgfPF9vE0btyEixcvYNYU3Bp1c7pIpVHjUycQgIRDMVz97VLeD1TUeLARPrUtifhbkzwNEhpTo1XDQmPLTbckrSIiPrAOmJOhxzc0AJ8WYWReTiHjYgo1TtakVu+CdSK1Oje0Ojfa17ZskdNfTefq/guWfpL0pJ1OpEbPRoTfV5fw+wqujL7w3TGMmZZtioaMHOoNubGC1j3QC7cAT3KSskAFvg2CCz0HsBSq119Jt86rVpdi/Zk528TFixeYN+8N0tLS+PPP3wFL3bLp0ydTr14DtFptXgJLxaVLlmPBsmXKZDKVqC4ZwNGj/3D1qiXhfP78WerXL/mHXCaTiQMH9luT96tX/4/atcv/e/W5c2fzfb9x41f88svP5e7XHgwGA8pNF0FcXKz1uSmK5blUA7f/+1RZJSXduNP2wYN/MnfurBKXcNFqNRgMBd+LLrZth6+vL/cGFX0dCseR5JUQRTCbTWzZ8gOrVv0PUHj00bH07NkbtfrO/ZRDOEaNeyt25ZObtztu3qVfvSNKr3VQMPuvXWXDhfM83tBS3+jv5CS6hUfgptGw72o8d/kF2OgFsoxGErKzqaPzLlMcqbm5bLt2lYlN7sJFpeanK7G0DAwsU1+3o+3btzNlyhT+/PNPAD7++GM2btyIyWSiX79+PP3006hUKnbu3Mm7776Lq6srs2bNolkzyzbZ6dOn06tXLzp27FjmGHbu3Fkh5+LMfH19mTx5Mk888QRBQUG0bt2au+++m969e/PPP/9w9epVVq9ejVqt5pNPPmHp0qV8/PHHTJo0iS1btjhF4qqqSU+/cZc+o9GIXq8vNkGRmZnJqVMnMJlM1K1bH39//xKNYzabOX78eL67Dt4sMdFytz5FUchMTcd8JA63QE/0V9LxDPOh+v31iNtzFrVWQ/j9N5I/2Yk31ZtSlHxZLvdAL0LurknikThcfdyL3WrnFxlC0t9XbtSpwtJVUkwCymkttXo3sdz9z0OLi6ftBE5Osj5/xk2BSz8cJ7VeIDW6R+bbyqeYzNbEFYAhI39tLrVWQ93Bzci8nIrW2w2P4KKLTmtcXXAP9iL7miVx5xXhW+hxt959Ta1W4+bmRps27UhOTkan0+Ht7Y3JZCIm5hIXLlzAZDIREBBAQEAgAQEBeHp6Fdq32Wy2Jq4A4uOvlCp5pdfr8606TU5OqpDkVUREDVJSkklLSyMoKJjgUtzl0tG0Wi2RkY04d+4MWq0rDRsWnoQV+fn7+5OQkJD3tZ/UHr4DSPJKiEJcvHieTz75iNOnT9KiRWsef/xJh9xxSAhx+xtcuy5v/3WI43l3D/PWuvLJiWNkGg3U8/bhgerVbfaRkK3HR+ta4E6BFzMyWH3uNJObtSy2/T0h1UjMyebdv45gVhTq+/jSo/qdsfru/PnzzJs3z7oS5KeffmLz5s2sX78ejUbD448/Tr169ejVqxeLFi1i+fLlxMTEsHTpUhYuXMiRI0dIT08vV+IK4Nq1a2zYsIGUlJR8j0+ZMqVc/TqbMWPGMHToUA4cOMCBAwdYunQpS5cuZe3atTz33HOsWrWKS5cusX//fry8Cv/j2NFm+68Df1BPPu/oUMpty5bvef/9+QCEhYUzffosPD09CQ725tpNdyozm83s3bubzz77P+tr9PTpk6xevclm3aCUlGRefPHZfHdIBAgPr85jPX8B4Ovf+jJ16qs8+ugwUq4lk3L1pmNVUKd/U5qMv8f6kCnXiMbVBd8GQaSevIZiVtD6uFlqS90kpG0NQtpa3st+SdwBidAxMLpAjO4BnjQc1YZd7/fDmGXgrns/IvWkpaZk5rZ01FrLaq9fEneAvvA+AH5ZPgyA9sP+h4vOFeMtiai0M4nE7jpD9a43tvKpNGqCWoaTcCgWgOBWBd/zNa4u+NQt2QcKdfo35eHg70Gt4svEG3OmdtdQM7AWU6e+CsCaNV/w9dcbCAsL56WXXiUwMChfP0ajkRdffIazZ2+sWEpKSiIpKQkPDw8WLfqkyHpW58+f4+LFCwDcdVcz65glkZ2dzfjxo63bvfr2HcjDD48ucXthEXz23+izDWQ0WejoUBwmNzeXLVu+w2w206NHb9xLUVbh1vfA685Edy7kaOEsJHklxE1yc3PZsOErvv56PZ6eXjz99PN06nSfZPKFECWy4O6CCY4QDw/eaW/5A+N8Rjrhnp4Mrl10wf36Pr5Mbd4q32M1dd680rJ1gWNr6nT4FrKKomdEzXzfq1Uq+tWsTb+atUtyGlWGXq9n8uTJvPTSS7z44osAbNu2jT59+uDp6QnAoEGD+Prrr+nVqxeurq5kZ2ej1+vRarUoisL8+fOZO3duuWN56qmnCA0NpUaNqps0/OOPPzh48CBPPPEEUVFRREVF8cILL9C3b1+2b9/ORx99xJgxY4iOjqZu3bp8/XX57g5VWfQGSz1L50ytlU6PHr0ID6/OlStxtG9/j/V1f6uPPvqgwN26srKyMBqNNpNXP/64nZiYS/keGzhwCIMHDyPh2GOoVCpeecVyc4Lk5KSCHSiWYule1X0xG01c+PYomTFpuPq54x7kha6WP961/PGpF4jGveg/Xdw0xf/hmpuSjSktDhVYE1fXZSdk4VMn0GYfbrpMFJOZ1FPXCG5VnaSj8eQk5r8bYcbllALtQjvVwb9JNVQatbXeVVlp3Fww+lkSXaqUord/P/TQyGJrAMXGxnDixPFCf6bX69m9+0c6d+5CRETB96zZs+fz1VdfoNVqGTbs4VLFf+DAr9btXs2bt5TEVVm5BaKYcm0fV4W5urrSt+/ACu0z08OjQvsTFUuSV0LkOXr0b5Yu/Yi4uFjuuy+KRx4Zg4+Pj+2GQgjhICm5OXQKKf4uXlVVXFxcgduK+/j45HvfnjFjBsOGDSMyMjJfu3vuubFaITQ01FosfPLkyTz//PO4u7vz+uuvs3btWjp06ED1EqyOs8VgMLB48eJy9+PMAgICWLJkCS1btqRt27aAZcWZXq/nu+++IyoqipEjR5KTk8PSpUutz59Go8FoNDoy9HwWax4BYKqD46gozZq1oFmzou9SCvDrr78UeOzhh0fj5ubGP//8xbp1q/Hz82fMmPHExFwiMzODli3boNFo8PfPv/X5mWdeoFevvgAEdv7W+rjJZMLX15fExMR8x6O6sf0t9VQCmTGWrY65Kdnkpli2lxmzcgm4K/97Xfr5JFLPJOIRrCOweRht/DoVe476axlUr35TEWyVChQFtYsanzqWc7DVR5sh33Jm3RHidltWbPg2CMLVx530czeSctfvcHgrN//CE4dlsfZi8XGWRFBQcL47SXp4eKDX6wHLNsMVKz5jxYrPePTRsYwYMSpf2+DgYP71r2fLNO7q1V9Yr/0jRw6RmJhQYFUYwN69P7N8+ad4eel44YWp1KxZ9LbQO1LLt8gsZOWQPWVn6zlz5jRhYdUJCLBdAuF28MO9lhsdNXdwHKJwkrwSd7zMzAxWrlzBzp3bCAmpxrRpMwu9m44QQpTXrSuiysvP1Q2/O/Supw8//DAxMTH5Hnv66aethdFXrlyJi4sLQ4YM4fLly9ZjFCX/ncTgRn2Ytm3bsnbtWgBSU1P56quv+Pzzz/n44485dOgQ9evXt67gKq277rqLkydPVulaJnXq1OHDDz9kwYIFXLlyBTc3N7y9vZk1axbVq1fnxRdfpG/fvmg0Gtq2bcvWrVsxm820atWK999/n4kTJ/LhhzbusCUqRePGd7Fnz08A1KpVh7lz38XPz5/MzExmzHiZrCxLjaUTJ45x9uwZANq3v4fXX5/D/fd35eLFC/z55++0bNmKBx/sU6D/9PR0pk59jsTERNQuaoLaRuAV5kPWlXS8wnzwzNsOePMdAm92PYl1nf5aBhe+PwYKpBy/ikqjKpDcupWuhh9qV42l7pUK3HXuKGaF0Oi6uAeVbJ2dKdeE/sqNhEHauSTqDW5OUMtwrv0Zg1bnSug9tUvUV1kl/R1HxqVUvCJ8CWwWVvgxSYl89NEHpKamMmLEKFq3blvgGE9PT+bNe49vv91EQEAQgwc/xKFDf3D8+DHWrl2F2WwG4KuvviyQvLLl3LmzeHl5FVpyIzAwkDNnTgGWhFlhtbWys/XMmzfbenfEhQvf5Z137tztcc4oMzOD559/mkuXLuDh4cncue/RsGGk7YZClIMkr8QdS1EU9u//hf/8Zympqan06TOAIUOGl2q/tBBCCMdYuXJloSuvrtuwYQPZ2dn0798fg8Fg/bpJkyZcu3Zjy1B8fDyhoQX/6P3ggw948skniY2NZd++faxYsYLp06ezb9++fCu3Sqp169YMGDCA4OBgXFxu/Pq1Y8eOUvflzDp06ECHDh0K/dmGDRvyfT99+nQAatasyY8//ljpsZXUVM3SvK9KXsfndvfiiy/TsGEkOTk59O07EK1Wy5Yt32MyGa2JK4DLl29sD/ztt32kpKTg5+fHo4+O5dFHxxbo1zvjKQA27oi23g3ObDSjUqnwCvfFKzx/wXGf+oEExIWRfj4JlVpFbqolaRXQNP81emvB9OzELPYkbgOgc2C3Qs/Rzc+DBNN7GHMM1Kn/BpmXUgGI2XGayFFtUGnUNvvY9/ko0q/0pkao5bWhGM2c+/ofIke3pXafJoW2qUhp55KI/eksM8afB+D9H1rjFxlSoF7WwoXvsX+/ZTXdrFmvsnLl2kJrzNWqVYeJE5+zft++/T20b38Pu3fvsj7XpS18/t5789i2bTNqtZrnn5/CAw/0yPfzSZP+zccfL0avz2DIkJF4FLJNy2AwWhNXAHp9VoFjHGHHjq38/vt+mjZtQe/e/crcz4UL5zEYcqlfvxwfZvw6Bu9sA+l3LSl7H+Xw55+/c+mSpe6ZXp/Ftm0/VInk1bDNP1i+KEUdN2E/krwSdyRTbiYzZszgl19+oXbtukyZ8gp169a33VAIIYRTCAsrfMXBdddXUAFcvnyZvn37smnTJnbu3MnixYt56KGHcHFxYf369QwaNChf2+PHjxMbG0t0dDQnTpywJpvUarV1W01pLV68mHfeeYeaNSt29Z2oeOk5lj/yy3Zvz9uTm5sbQ4eOACzb+55/fiKnTp0AoHr1CGJiLqNWq6lVq4718cDAIHS6ou+MB2BSW7bcenvnL8OgcdcWerxKpSL8vrpwn6UuYNaVdFRq8AjJ/2zoInytBdNVGjW+DYLw0ly1eZ7e1Syrpm4utG7MzMWUa8LFQ42Xpvhn3SsgGU9fBU2aFpPeklwx6Q2Yc02oPYquP1VRclMs7z/xiZZah2lnk0g7m0SNHvmTBtdrSgHk5GSTlZVZqhskzJgxm//85xMAxo4dX+J2yclJbNu2GbDcBGDdujUFkleBgUG88srMIgtmA3h7e/Poo2P5/PP/4O7uXqoYKsuff/7OO+9Y7oi6a9dOvL29ue++qFL3s2bNl9a57dt3QJm3X+JZA5OSU7a2FaBatTBUKpV1NXNoaLjDYqlIKd530jv/7UeSV+KOoigK+oTjZFz+nT+0ah5+eDS9evWzWYxUCCFE1dC1a1dOnjzJ0KFDMRgMREdHM2DAgHzHzJ07l9deew2AyMhIAgMD6du3LzVq1ODee+8t07i+vr706tWrvOELO/jIxVLkuqrUvCqtpKREa4IKLEWR33//I3x8fPHx8eXLLz8nMzODwYMfyreKsDBZnpbVdVFRZs6cOcWWLT+g9tDg36hkq3k8Qwv/Q9LF05X6D7Uk60oabv6euPl50IrCV/zdrNVAy6qKhIPVuPLLeQC8a/vj4mFJprXyK76P6+0Tj0QQt/scAD71Aq3tK5tPvUASDsbwf+vyJwqy4tLw5MbOgWHDHmbu3DcwGg307Nm71KunatSoyYwZs0sdn6enFzqdjoyMDABCQko37s1GjBjFwIFD0Ghc0GrtM7/FuXTpYrHfl9SmTeusX3/77SbGj59o8zoqVPNZZDmw5lXDhpFMnjyNn376kXr16jNgwGCHxVKRtnSy3G2wpWPDEEWQ5JW4Yxj1yaRd2Ish8yqu3uF8+tE8tFrJrgshRFUXERHBwYMHrd9PmDCBCRMmFHn88uXL833/9ttvlzuGLl26MG/ePLp3747rTXeIvOuuu8rdtxAVyc/Pn9DQcK5ciQWgceOmREY2tv78iSeKvnaKolarGT9+IsnJSZxJPIdKXf67OLt4aPGpE2j7wEIEtaqOOT4XxWQi5MF6pW4f2Dwcr+q+mHJMeIbZ73dJVx936o9sRcbFFGJ2nUYxmEEFulr+mM/fWBXaqdO9fP75GrKyMgkPL/8NJ0rKzc2NWbPm8sUX/0Wn82bcuH+Vqz93d+e581uHDh1Ztep/pKQko9Pp6Nz5/jL1ExYWbl0ZFxwcUrbElZOIinqAqKgHHB2GuIPcvleLECWkmE1kXjlC5pXDqNRafGrfi3tAfcLDw4tcriyEEEJUpG+++QaALVu2WB9TqVRVruZVVfCy9v8AMN9BNa9uptVqmT//fb7//ht8fX3p3bt/mfvyTn8CgHTvTysqvCLtTrBcW/cG9Sj6mE8shcfvHf85bp6Wm13cnEiz1cfN7d0DS74NryK5uGuZ0utPzA+YmPd9KzyCdHiGepN6Pv+WZj8/P/z8/OweX+PGd/HGG/PsPm5lq1YtlCVLPuP06ZPUqVO30DsklsRLL73K8uVLyc3N5ZFHxpQ9oF8esdS8alb519adZMT3eXdIlZpXTskhyavIyEgaNmyIWq1GpVKh1+vR6XTMnDmTZs2aFdkuLS2NUaPy3+3i5MmTTJkyhTFj8l/86enpdOzYkbp161ofe/nll+nQoQPnz59n2rRppKSk5N1pYx716pX+Uxfh/HIz4km7sBdTdgru/nXxrnE3aq3zfIojhBDizrBz505HhyBKKCnLDwA/h0bhWEFBwYUWYC8tk6ZBBURTMj5af9vHhMaXqw9b7e3lit4SZ2DT4mv/iYrl5+dH27bty9VHUFAwL744rfzBeEdi0jiu5lVVdc0/AACpTumcHLbyasWKFQQEBFi/X7ZsGbNnz2b16tVFtvHx8WHTpk3W7z///HO2bNnCI488UuDYQ4cO0a5dOz777LMCP3vxxRcZPXo0ffv25aeffmLSpEl8++23qFTlX8IsnIPZlEtGzO/orx1H7eqFX/1uuPnWcHRYQggh7lD/+c9/Cn381g/fhOP9n3YYcOfWvKpIWZ72m8UWvraTCi36bS1XH7ba28vXMeVLoIgqoNmrDq15VVVtv6cjAG0cHIconFNsGzQajcTFxeHra7ld7qJFizh16hQJCQkkJibSqFEj3nzzzXx3NLlw4QJLlixh7dq1hRbxO3jwICkpKYwYMQK9Xs9DDz3EyJEjiY+P5+zZs/Tu3RuA+++/n9dff52jR4/mqzuRlpZGWlpavj5dXV3LVXhQ2Ed2ygXSL+7DbMjCM6QJXuFtUGscX+hRCCHEnevkyZPWr3Nzc/njjz+4++67HRiRKEpZa9kIIYS4vcn7v3NzWPJq9OjRqFQqkpKScHNzIyoqirfeesv688OHD7Nu3ToCAgKYPHkyH374IVOn3vj0ZsGCBTzyyCOEhxd+W06NRkPXrl156qmnSEhI4NFHHyUkJISgoCBCQkJQq2/czrZatWpcuXIlX/JqxYoVLF68OF+frVu35ssvv8Tf3zF73EXxTIYs0i/+Sk7KeVw8/PGrF43WK7jYNsHBUrC9qpDnsuqQ57JqkefT4ubfcQCSkpKYMmWKg6IRxel73FKQPKnTUQdHcvvzTn8MgHTv5ZU+1k8JljsB3h/0YNHHfDzacsyEFWXqw1Z7e3mqgSXOJaeKPldRxe0ZjneOgfTmyx0dSZXSc4Vl11Z6p/scHIkojMO3DR49epRx48bRqlUrAgNv3DGkZ8+eBAVZCuENGTKEOXPmWJNXcXFx7Nmzh9mzi76F68SJE61fV6tWjWHDhrFt2zaGDRtW6PEajSbf96NHj2bgwIH5Hrt+d6Dk5EyMRnMpztY2+eW+7BRFQZ94kozLB1DMJnThbfAMbYZKpbbZtrIKtsvzaX/yXFYdlXkjBXk+7a+in08XF3WV+BApICCAmJgYR4chCmF0j3R0CFWG0aW53cYK0Bb/gSVAQI3irzlbfdhqby8XM22fq6ji/FtizJSaVxXN2NR+71mi9By+bbBJkya8/PLLTJ8+nRYtWhAREQHkTyaZzeZ8K6W2bNlCt27d8m0jvNXnn39OdHS0dWWWoii4uLgQHh5OQkICiqJYa1zFx8cTGhqar72Pjw8+Pj4Vdp6ichizU0m7sBdDxhW0ulB8anXCxd3X0WEJIYQQ+dxc80pRFP7+++98H9oJ55H28AZHh1Bl6D1esNtYzXzb2j6m9/Zy9WGrvb18F2v7XEUVd9dL6KXmVYXTT7Lfe5YoPdtLU+ygT58+tGzZkjlz5lgf27FjB+np6ZjNZtasWUNUVJT1Z7/99hsdOnQots8//viDZcuWAZCSksLatWvp1asXoaGh1KxZk++//x6A3bt3o1aradiwYSWcmagsitlERtwhEo9uxKhPwrtWJ/wbPiiJKyGEEE7p5MmT1n+nTp0iLCyMd955x9FhCSGEEELcFhy+8uq6V199lX79+rF7924AgoKCGDduHMnJybRr144JEyZYj71w4QLVq1cv0Me4ceMYPnw40dHRzJgxgxkzZtC7d2+MRiMPP/wwnTp1AuC9997j1VdfZcmSJbi6uvLBBx/kW9klnJsh8yppF/Zi1Cfj5lcb75od0Gg9HR2WEEIIUaSba17l5uZaSxEI5xOwzLJtMOnxEw6O5Pbnk265I3ia9/8qfawfr30HQFRw76KP+XCs5ZiJBe9GXpI+bLW3l6cbWuJcfLLocxVV3O7B+OQYSWtR+dfWncRnTN571n9kXp2RQ5JXJ04U/GWgbt26/P333wAcOnSIyMhIZsyYUWj77777rtDHu3XrhtlsqUUVEBBQoOD6dbVr1+bzzz8vS+hVUuKlI8Sf3geAWqOlRrOeJF46QkbiBesxhux0tO46mkRNyNdWURRij/9IcsxR1BotuoAaRDTtjlrjQmbSZS4c/haA6k2i8a3WAIC4Ez+jddcRVKt1qeI0mwxkxv5B1tWjqLWe+NZ7AHe/muU5dSGEEKJS5ebm8uqrr9KtWzceeOABAJ555hkCAgJ44403cHFxms8RRR6jRwtHh1BlGFza222sYLcw28fUO1euPmy1t5fT6bbPVVRxQfdgyJCaVxXN0NZ+71mi9KrUb0wajYYuXbo4OozbSnZ6Apf/2U6TLuPQunuTGn+KMwfW0Lz7c9ZjcrJSOLF7ObVbDyjQPvHiYVKvnKLR/U/gonUn7sTPxB7bSUTT7lw5/Qs1W/TBzdOP079+iW+1BuRmpZJ27RwNOz1aqjhzUi+RdvEXzLmZeAQ3Qle9LWqNfGothBDCuS1cuJCMjAxatWplfWzWrFm8/vrrLFq0iOeff96B0YnCpI1c4+gQqgy9xyS7jdXUx/aHok17/liuPmy1t5fNcaX7AFhUQY1flJpXlUA/0X7vWaL0nDJ59cwzz5Sp3eDBgys4kqpPpXGhdss+aN0td+Dy9AvHmJ2B2WxCrbYUzb9w6Buq1e+Ap29ogfZZqXH4hUXionUHwC+sEad//ZKIpt1RqTWYTQbMplxUeX1d/mcbEXc9YC2Wb4vZoCf90n6yk8+icffDP7I3rrpqFXHqQgghRKXbtWsXa9euxd3d3fpYtWrVePvttxk2bJgkr4QQQgghSsApk1fCftw8/XDz9AMsWwAv/70V39BIa+IqNf4Uufo0QuoWvoTSy7868Wd+JaROezSuHiReOoIhJwOAsIb3cfHwtyiKmYim3Um7eha1iyte/gXrld1KURSyE0+Tfvk3FLMBr7BWeIU2tybBhBBCiNuBVqvNl7i6TqfTSd0rJxXwWX0AksaednAktz+ftGEApPmsrvSxdlz7BoDo4L5FH7PwCcsxkz4tUx+22tvLs5GWOD84UfS5iirup36WmletKv/aupP4jMp7z/pc5tUZSfJKAGAy5nL+4CYM+jTq3/Ow9fH4M/sJbdAJlarwgvaBNZqTq0/j5C//Ra3RElSrDSqVJcHk4RNM5L1jAMvdAU/sWUG9u4eRcOEgKXHH0Xr4UKNpD9Sa/C9DY04a6Rf2kpseh9YrBJ9anXDx8K+kMxdCCCEqj1qtJiMjA51Ol+/xjIwMjEajg6ISxTF6Ss2TimLQ3l/gMVNqLqk/x1b4WP7ePgCkHiu6b3/X3y3H/ByLMSXH+nVJ+7i5vSP9mZkX5x834jCl5kKgoyISdlctGkNmtqOjqHIM9xZ8zxLOQ5JXgtysVE7vX4W7dxANOz2KWqMFwJCTSWZyDPXaP1RkW2OunoCIpoQ17AxAZtJl3HQBBY6LP7ufgOp3odZoiT/zK02iJnDl5B6SLv9FUC1LHRBFMZMV/zcZsQdRqdR417wHj6BGJd5iKIQQQjibPn36MH36dObMmYOnp+XOuFlZWUyfPp3u3bs7ODpRmLThXzg6hCpD7/GvfN/XqFGr0saqRx3LF8UkcOrdeyzvqzqkuqQA4OvrV+I+rrfXautjMJjKHmw5HTtvibPezXEGVu78CifT6FmpeVUJ9OP/Zfsg4TCSvLrDGXP1nNi7gsAaLQhvlD/TnJl0CS+/cDQuRW9ryEqJ5fLRHTS+73FARdypvQRENM13jCE7nZS440R2egyzyQCKYvmBSmX5HjBkJZB2fi9GfSJuvjXxrnkPGlevCj1XIYQQwt5Gjx7Na6+9RqdOnWjQoAFms5kzZ87Qt29fJk6c6OjwhLCrkSNLd8MeZxUc7M01SRwIIYRdSfLqDnft3O/kZqWSEneclLjj1scbdhpFdkYSrnn1sG5tk5kSR+1WffEJqYdvwgWO/vh/KIqCX1gk1ep1yHf85X+2U71xV1RqNRq1G35hkRz98WO0bl7UaT2A9Mu/kRX/D2oXd3zrdsXNr5asthJCCFElqNVq3njjDZ588kmOHj2KWq2mWbNmVKsmNx9xVoGfWVa1JI495+BIbn++aYMASPVZX+ljDf/WMtaqPkWPNXy4h+WYVfoy9XG9/Y4dZQ6zQthzXoWT+vFBfHONpLaW10BF8h2ed22tknl1RpK8usOFRd5LWOS9hf4stEHHQh8PiGhGesJ56/fVm3SlepOuRY5Rp83AfN9XbxJN9SbR5KTFkHp6M6bcDDyCGqKr3g61i1vpT0IIIYRwchEREURERDg6DFECuTqpeVJRclwftNtY3WvbHqt79+LrzNnq40Z7x/4JZc95FU6qel9yMqTmVUXL6S7XljOT5JUotay0K4Q36lLm9mZjNumX9pOddAaNmw/+DR/E1Tus4gIUQgghhCij9IeWOzqEKiPbfZzdxhrb1PZYY8caytXHjfYF7yBqT/acV+GkGv6LbNm6WuGyx8q15cwkeSVKzTuwbMUgFUUhO+ks6Zf3oxhz8AptgVdYC1RqeRkKIYQQQgghhBCicJI1EHZhykkn7eIv5KbFoPUKxrthT7QeBe9KKIQQQgjhSIH/qQlA4piLDo7k9ueb1g+AVJ+vK32swV9bxlrXr+ixBg+21Kxat67wmle2+rje/uefyxxmhbDnvAonteMBfA0mUtvIa6Ai+Q7Ou7bWybw6I0leiUqlKGayrh4lI/ZPVIB3jbvxCG6MSqV2dGhCCCGEEAXkevd0dAhVRo7rILuNNaC+7bEGDCi+5pWtPm60d3TNK/vNq3BStYaRky41rypazgC5tpyZJK9EpTFkJZJ2YS/GrARcfSLwqdURjavO0WEJIYQQQhQpfcgnjg6hysh2f8xuY41qYnusUaOKr3llq48b7R1d8+oxh44vnED9cVLzqhJkj3rM0SGIYkjySpRLbnocqed/xrf2fdai64rZSEbcIbKu/IXKxQ3fOl1w86+DSqVybLBCCCGEEEIIIYS47UjySpRZbnocyae3gtlE8umt+NfvDkDahb2YctJwD2yAd0Q71C6O/XRKCCGEEKKkApdHAJD42GUHR3L7803tBUCq7/eVPtaAjZaxNg4oeqwBAyw1qzZuLLzmla0+rrffu7fMYVYIe86rcFLbu1hqXrWV10BF8h2Qd21tlHl1RpK8EmVyc+IKsCSwTm4GFDRu3vg16ImbT7hDYxRCCCGEKK0c3wGODqHKyHZ72G5jDW9ke6zhw4vfNmirjxvtHfsnlD3nVTipuo+RLTWvKlz2cLm2nJkkr0SpFUhcWSmACu8a90jiSgghhBC3pYyBix0dQpWR4+5syaviC7bbTl4V395e7DmvwknVfYwcqXlV4XIkeeXU5JZvolSKTlxdp5Bydge56XF2jUsIIYQQokLkZFn+ifJTDJZ/dmAwGTCYih/LYLD8K2sfttrbjR3nVTgps8HyT1Qsp7nIRWEkeSVKJfX8z8UkrvKYTZbjhBBCCCFuM4FfNiTwy4aODqNK8E3rj29af7uMNfSb/gz9pvixhg71YOhQjzL3Yau9vdhzXoWT2tkN3z/lNVDRfIf2x3eozKuzkm2DolR8a99nY+UVoNbgW/s++wUlhBBCCFFBcvyGODqEKiPb/VG7jfVwY9tjPfxw8SsqbPVxo72Da17ZcV6Fk6r3BNnphd94QJRd9sNybTkzSV6JUnH1DsO/fveiE1hqDf71u+PqHWb/4IQQQgghyiljwPuODqHKyHEbbrexhkbaHmvo0OJrVtnqw1Z7e7HnvAonVecRqXlVCXKGyrXlzGTboCi16wks1Jr8P5DElRBCCCFud+kJln+i/JQsyz87yDJkkWUofqysLMu/svZhq73d2HFehZMyZoFJXgMVzmkuclEYWXklyqTACixJXAkhhBCiCghc1xKAxMcuOzaQKsA3zbIFM9X3+0ofa+R3lrE2Dih6rJEjLfWqNm4sfLuVrT6ut9+7t8xhVgh7zqtwUrt64WswkdpWXgMVyXdk3rW1UebVGUnySpTZ9QRW6vmf8a19nySuhBBCCHHbyw4c6egQqoxs98ftNtZjd9ke67HHiq95ZauPG+0dXfPKfvMqnFSDp8hOk5pXFS37Mbm2nJlD3nkjIyNp2LAharUalUqFXq9Hp9Mxc+ZMmjVrVmzbEydOMHz4cGrWrGl9bMGCBdStWzffcSaTibfeeos9e/ZgMpkYO3YsI0aMAOD8+fNMmzaNlJQUPD09mTdvHvXq1av4E70DuHqHEdxsmKPDEEIIIYSoEJl933Z0CFVGjttgu401oIHtsQYMKL5mla0+bLW3F3vOq3BStYZJzatKkDNAri1n5rCPDVasWEFAQID1+2XLljF79mxWr15dbLuDBw/Sp08f3njjjWKPW7VqFRcuXODbb78lMzOTYcOGcdddd9G8eXNefPFFRo8eTd++ffnpp5+YNGkS3377LSqVqkLOTQghhBBC3J7USZcAMAfUcHAktz+VORUARe1b6WOl5VjG8nEreqy0NMt/fXzK1sf19sHBZYuxothzXoWTyk1FZUhH0cproCKp0vKuLR+ZV2fkFNsGjUYjcXFx+PpaXiSLFi3i1KlTJCQkkJiYSKNGjXjzzTfR6XQcPHiQS5cuMWSIZT/q+PHj6d69e4E+t2/fzkMPPYSLiwu+vr707t2br7/+mmrVqnH27Fl69+4NwP3338/rr7/O0aNHueuuu+x30kIIIYQQwun4f30PIDWvKoJPumXXgz1qMz36g2Ws4mpePfpo8TWvbPVxvb2ja17Zc16Fk/q5Pz5S86rC+Tyad21JzSun5LDk1ejRo1GpVCQlJeHm5kZUVBRvvfWW9eeHDx9m3bp1BAQEMHnyZD788EOmTp2Kh4cHffr0YeTIkZw5c4ZRo0YRHh5O06ZN8/UfFxdHWNiNGkyhoaGcOHGCuLg4QkJCUKtv3GixWrVqXLlyJV/yKi0tjbTrH6/kcXV1JSQkpKKnQgghhBBCOAl9yBhHh1Bl6N0n2G2sJ5rZHuuJJ4qveWWrjxvtHfv5vz3nVTipyEnoU6XmVUXTPyHXljNz+LbBo0ePMm7cOFq1akVgYKD15z179iQoKAiAIUOGMGfOHKZOncrMmTOtx9SrV48HH3yQnTt3FkheKYpSYEy1Wo3ZbC40Ho1GUyC+xYsX53usdevWfPnll/j7e5XqXIXzCg72dnQIooLIc1l1yHNZtcjzKW43Wb2KL00hSi7XrZ/dxupTz/ZYffoUX7PKVh+22tuLPedVOKkag8h1l5pXFS23j1xbzszh2wabNGnCyy+/zPTp02nRogURERFA/mSS2WxGrVZjMpn45JNPGDVqFDqdDrAkqVxcCp5GWFgY165ds34fHx9PaGgo4eHhJCQkoCiKtcbV9Z/dbPTo0QwcODDfY66urgAkJ2diNBaeBCsr+eXeMa5VUqFDeT7tT57LqqOynkuQ59MRKvr5dHFRy4dIolKp408BYK7WwMGR3P5U5kQAFHWgjSPLL1FvGSvQo+ixEhMtv/sHBhb8kLskfVxv7/iaV/abV+GkshNQ5WaguMproCKpEvOurUCZV2ektn1I5evTpw8tW7Zkzpw51sd27NhBeno6ZrOZNWvWEBUVhUajYefOnaxZswaAmJgYtm7dSo8ePQr0GR0dzbp16zAajaSlpfHdd9/xwAMPEBoaSs2aNfn+e8s+1t27d6NWq2nYsGG+9j4+PkREROT7J1sGhRBCCCGqNv8fovD/IcrRYVQJPumj8EkfZZexHt8yise3FD/W44+78/jj7mXuw1Z7e7HnvAontWcIPkfkNVDRfB4fhc/jMq/OyuErr6579dVX6devH7t37wYgKCiIcePGkZycTLt27ZgwwbL/9J133uG1115jw4YNmEwmpk2bRr169QB45ZVXaNq0KSNGjGDEiBFcvHiR/v37YzAYGDZsGO3btwfgvffe49VXX2XJkiW4urrywQcf5KuBJYQQQggh7kz6MKl5UlH0Hs/YbaynWtoe66mncsvVx432Dq55Zcd5FU6q0b/Rp0nNq4qmf0quLWfmkHfeEydOFHisbt26/P333wAcOnSIyMhIZsyYUeC4WrVqsXz58kL77dWrF6dOWZZ6u7i48MorrxR6XO3atfn888/LGL0QQgghhKiqsnpMd3QIVUau64N2G6tHbdtj9ehhKlcfttrbiz3nVTipiL7kVmKZhTtVbg+5tpxZlVpulJKSwpAhQxwdhhBCCCGEuE2pL/+N+vLfjg6jSlCZ41GZ4+0yVnxWPPFZxY8VH68iPl5V5j5stbcXe86rcFL6K6hy5DVQ0VTx8ajiZV6dldNsG7zZM8+Ubble7969KzgSIYQQQghxJ/Hf3hOAxMcuOziS259P+hgAUn2/L3GbL774L5cuXSj1WKs9VgEwTD+86GNWP2k5Ztj/laqP1NQUADZvngrAI4+8icHguFVYT/W2xLnku6LP9VY1atRi5MhHKyskYW97h+NjMJHatuTXlrDN58m896yNMq/OyCmTV0IIIYQQQjhCVo1Jjg6hysjyeL7UbS5dusC5k8cJuunO4yXRzNtyx/L09FNFH1NjpeWYM4UfU1QfSUZjvvZJx4+XKraK9t3mvDiLOI9bJZicY7ujqEBNXiIrNcvRUVQ5WZNK/54l7EeSV0IIIYQQQuTRR09xdAhVhsG1W5naBWk09Pf2K2WrvOO9iznE+1z+Y0vYx6b0FAD617fV3k7iLOPXL+5cb3I9flGFhPfEoJWaVxXN0LVs71nCPqpUzSshhBBCiJtt2rSJfv360b9/f4YPH85ff/0FwMcff0zPnj3p1q0bixYtQlEUAHbu3Env3r0ZOHCg9ViA6dOn88svvzjkHIR9uZw/gMv5A44Oo0pQmy6jNtln++U1TSbXNJnFH5MZwLXMgDL3Yau9vbh7Z+LuXfy5iiou8xLqbNnaXNHUMZdRx8i8OitZeSWEEEKIKuns2bPMnz+f9evXExISwk8//cQzzzzD66+/zubNm1m/fj0ajYbHH3+cevXq0atXLxYtWsTy5cuJiYlh6dKlLFy4kCNHjpCenk7Hjh0dfUrCDnx3DQSk5lVF8M4YD5Su5lVZvVvtZwDmxhZ9t7B3946zHNN9Xpn6sNXeXlr0s8S5f6XcGe2OtW8U3lLzqsJ5T8x7z5KaV05JkldCCCGEuO3ExcVhuqWOi4+PDz4+PtbvXV1dmT17NiEhIQA0bdqUhIQENm/eTJ8+ffD09ARg0KBBfP311/Tq1QtXV1eys7PR6/VotVoURWH+/PnMnTvXficnHCqr1r8dHUKVkeUx2W5jDUtuYfuYZt+Uqw9b7e3l9F7b5yqquKbTyUqRmlcVLet5+71nidKT5JUQQgghbjsPP/wwMTEx+R57+umn892xOCIigogIS2FjRVF466236Nq1K1evXqVz587W40JDQ4nPuzX25MmTef7553F3d+f1119n7dq1dOjQgerVq9vhrIQz0EdJwd6KYnCNsttYrfThto8JO1quPmy1t5fE87bPVVRxoQ9g0EjNq4pmuN9+71mi9CR5JYQQQojbzsqVKwtdeVWYrKwsXnrpJa5cucKnn37Kc889V+AYtdpSBrRt27asXbsWgNTUVL766is+//xzPv74Yw4dOkT9+vV58cUXK/ZkhFNxObUbAGODex0cye1PbbIUODdr6lT6WHEulj/kw4xFVzGPSw+2HON9rUx92GpvLx5+ljj1KSWs2C6qnoyzqLMyMHtW/rV1J1Gfz3vPqi3z6oykYLsQQgghbjthYWHWlVXX/xWWvIqNjWX48OFoNBr++9//4uPjQ1hYGNeu3fjjMz4+ntDQ0AJtP/jgA5588kliY2PZt28fH3/8MSkpKezbt69Sz004lu/eEfjuHeHoMKoE74yJeGdMtMtYH4Ts4YOQPcUfs28sH+wbW+Y+bLW3l+a999C8d/HnKqq4X8fifdQ+19adxPu5iXg/J/PqrGTllRBCCCGqpJSUFB555BEGDRrE008/bX08OjqaxYsX89BDD+Hi4sL69esZNGhQvrbHjx8nNjaW6OhoTpw4gYuL5VcmtVqNXq+363kI+8qs94qjQ6gysjyn2W2sh5Na2T6mxcZy9WGrvb2c2m37XEUV1+x1qXlVCbKm2O89S5SeJK+EEEIIUSV9+eWXxMXFsW3bNrZt22Z9fPny5XTv3p2hQ4diMBiIjo5mwIAB+drOnTuX1157DYDIyEgCAwPp27cvNWrU4N57ZTtZVZZ971OODqHKMGg72z6ogjTLLrh6ssAx1U6Uqw9b7e0l6aLtcxVVXLX7Mail5lVFM3S033uWKD1JXgkhhBCiSnrqqad46qnCExETJkxgwoQJRbZdvnx5vu/ffvvtigxNODHtUUui09Ckm0Pj2Lv3ZwA6dbrPoXGUh8Z0CgCTpkGlj3VZmwpAhMG36GNSLUmfCN8rZerDVnt78QqwxJmZVPS5iiou7QSazExMXpV/bTmryniP1JzOe8+qf+fOqzOTmldCCCGEEELk8fltDD6/jXF0GOzZ8xN79vzk6DDKRZfxLLqMZ+0y1uLgX1gc/Evxx+wfzeL9o8vch6329tL0wV9o+mDx5yqquN+eRHfMPteWs6qM90jdi8+ie/HOnldnJiuvhBBCCCGEyJPRcJajQ6gyMj1fs9tYjya2sX1My3Xl6sNWe3s5scv2uYoqrsUcMqXmVYXLnGa/9yxRepK8EkIIIYQQIk9OR8ffTa6qMGrvtttYTXJCbB8Tcrpcfdhqby8pMTfiTDca+D4ulgyTkfuCQmig83ZgZJUvNzcXV1dXR4fheMEdMeLcNa8uXDjPhx++T25uDo8/PoFmzVo4OiSbjO3t954lSk+2DQohhBBCCJHH9cg3uB75xtFhVAka41E0xqN2Geu8azLnXZOt3+eazVzMyiTdYLhxTHJ1zidXJ8to5LI+i1yzudg+rjObzZxJSGDmoRxWnNKiKErlnUgRzDeNqQtORhdsifPbuFj+SU/jQlYWqy5dQG8y2T02e8jJyeGll16gf/8ePPvsU6SnO3fiptKl/I0mwz7XVlnNnz+Hv/46zIkTx3njjRkOuW5KS3PsKJpjzj2vdzJZeSWEEEIIIUQe7z8tRf4Tm/d1cCSVJyYmhilTXiIh4RrDho2kb9+BlTKOLvNFAFJ9v6+U/m/2cdCvAMyNfZAck4lPz58lPicbV7Wa0TXrUMPTk48PPEKu2UxwnTHoTSY8NRr6h1WnsY9vgT5udjUjgxS9nhPn/s0xoF21N2niY79i6XsSrrHjajzuGjXDa9Tioe6WOPevfJB0443knEFRyDaZ8NBoCvRx9Wo8mzato0uXB/D1vf0Kve/cuY3Dhw8CcPLkcb7//muGDXvYwVE50O9PozOYSG1b+ddWWaWnp1m/zszMwGg0otVqHRiRbbqX896zNjrvvN7JJHklhBBCCCFEnowm8xwdQqVbsGABJ04cA2DJkkXcfXdHQkKqVfg4mV5vlLpNdnY2adnZ6D0LT8IUZWxiO3JNJsyKwtmsTOJzsgHLCqw/U5Ko4enJ6Far2JN4jUt5q5OyTCa+vHyRx2rVoa6XjrGJ7Qrt+/qqp4iIDwAw3LJiqzJlGY1su3oFBcg0mdh8JY7mO2/EeV9QCGsuX8SoKLTy9cfbxYWk3Bx8tFpcVGpMisLpa9dIvXSJo0f/4bvvvmbx4qVOsfUuJuYy69evwdPTi+HDH8HLy6vIY93c3Ir9/o7Taj6ZyZmOjqJYo0c/zoIFb2M0Ghk1aozTJ64AMl8r/XuWsB9JXgkhhBBCCJEnp71zrOYwGAxoSpG8KY2cnBzr14qiYLhpa11FMrqUrrD4iRPH+e23/ZjNJpakpPBknfp4ajR8eyWWI6kphLl7MLxGTTw1+f+EURSFI2f1HElNwVWdQKROhwq4vknJ39WV+OxsvknaTIbZWGDci1mZ1PXS0TAnqNC4gnU6UvR68DpKPS8dd/nUKtV5lVam0YjeZCLQ1RWVSpXvXDQqFalxN+Js5O3Dvxs0IttsQqtSs+jMKZINuYS4uTG2dl02xcaQmp1tPf7SpYtcu3aV6tUjKvUcbDEajbz00gskJFwD4J9//uK99xYXefz993flyJFDHDiwn6ZNm9OrVz97hVrhzp07y+HDf9K48V1ERjYuWyeB7TCanXvrZNeu3Wjf/h6MRiN+fn6ODqdEjK3kZgjOTJJXQgghhBBC5HH903JHudzWgx0WwwcfvMPevbtxcXHh2LGjNG7cpEL7HzJkCL/++iuKoqDRaMjJybbdqAgpKSksWPA2V67E0r//oHxJBY3xCAAml+Yl6uvHH7djNltWRaUYDJzOTMdD7cKB5CQAzmdlsifhGt2rheVrd0mfxa9KLPgAaZ78lZZGDQ8P3NUaMkxGzmdmciYjg6vpdQHw9DxpbasG6nrpADjjmghAvdxAwLLi6vfkJK5lZVA/KIjmppa4qFW4qC8VGr+iKOxJTCBWn8VdPr409fUr9Ljk3FzWxVwi3WjgvqAQ2vgHWH92Ij2N1XkrqZr5+DI0oib9wyPYdvUKnhoNfcLC8Q6xxJl+1RKnl4sLXrjw07WrJBtyAbiak8ORlBSO37R1CyAsLJzgYNvF7StbRkaGNXEFcOzYP5w7d5Y6deoWerxGo+G55ybbK7xKc/78OZ577ilyc3NRq9XMm7eApk1Ldn3kk3wITXomJu8ytLUjnU5XKf3u3v0TBw/+iYeHB5mZmcWu2isNzV9571nNnHte71SSvBJCCCGEEGVy6NAh3n33XVJSUlAUhdDQUKZOnUqDBg0cHVqZeR95FoBEByWvLlw4x+bN3wGW1SlffLGCN96o2K2McXFx1uLJJpOJffv2Urdu/TL19Z//fMJvv+0DYPHi92nevBURETUA0GW+BNiueWUymdiw4StOnjxufUwFBLm6kWHMv1LKnLcEyWg2czEriz2J19CbTFxqZUkoRe6LBCDNaCTUy4NTmRnW/i5d+rflmMgn6RgQiJ/WlRqenlT38ARgadBvwI2aV1vi49iXZEkUJWZmcuD8SNQqFXO7F/58HEhOYtvVKwAcTU/D39UVtUrFlvgrqIGeoWGEuLnzQ3wcF/VZAHwTF0MDnTc+eVuq9iRew5j33PyVlkpUTg6t/Pxp5edvHadJt12ApebVzbxc8v9p563VEuHhyaW8sapXr8Hbb7/vsC2DSUlJfPbZ/6HX6/nXv54kODiEa9euWn8eE3OpyOTVwYN/cOLEMdq2vZv69W/f95cjRw6Rm2tJMJrNZg4e/KNsyas/nnP6mleV5cqVOObNewOTyURqagrLly9l4sTnKqRv3at571lS88opSfJKCCGEEEKUWm5uLk8++SSfffYZd911FwCbNm1i3Lhx7Nixo9K2vFW29OYfOHR8Dw9P1Go15ry6Sl5eFb9yoUGDBqhUKmsCq27demXuKzMvOQSWlUeZmTfq8GR4zS1RH1999SUrViwDQKVS4e3qSs/galT38MSsKLTw9eOv1BRC3T3oHBREqsHAZ+fPkHzTdse6R2th5sbdzBrpvDmSmnojNqBVvUUk5CUOfklKZFTN2tbEFcC4hPb54rqYlWX9OtdkYkTL/1qTTIVJyL1pOyaQmJvLtqtXSM2Lc83lizxdryG55ht3BDQDBuVGDS1vlxv9u6hUhdb9OrqtfYHHAFr7+ZOQk8OFrEzq67y5y8eXul46VsRdxi0wiHffXYyHh0eR8Ve2d955i4MHfwfg2LG/mTJlOjNmvITBYCA8vDotWrQutN3+/fuYOXMaAKtW/Y9Fiz6hRo2aBY47cuQQS5YsRKVS8cwz/y7xisXk5CS+//4bvLy86N27f6XWZmrS5C5cXFwwGo2oVKqyJa4A2rxPRl7Nq4SEa5w9e5r69SMJCAiw0fD2l5KSjOmmu2revIKvvDLeKNl7lnAMSV4JIYQQQohS0+v1pKenk3XTH/j9+vVDp9Oxb98+5s6dy7fffgvA/v37eeONN/j2229ZtGgRMTExXLt2jZiYGAICAliwYAHVqlV8wfCycOR2QYCQkGo8++yL1j/Cc3NzmDevYosIa7UamjS5i6SkJHx9/fj55x/5+ecfy9RXdrYerVaLwWAgJKQaGzasQaVS3XLUJutXGRkZJCUl4u3tjZeXjri42HyrbxRFwVeno2ne3fzUKhWDq9dgUHiEtd+dV+PzJa4AXFPdmRbZhGNeabiq1YS7e7A/b7shgKtKTafwa2y7Gm99LFavp4HO2/r99e2C1zX09iYmWw+Ah1ZL85A4NAXO7YYWvn78mZJMrtmMv9aVup5e+VaOpRssX0cHh3Il+zxZJhMdA4IIdL1RfLx3aDhGReFqdjYt/fwKrKaCG9sFr8sxmXBVq1GrVPQMzb+l0kOjwdfbmxyVioUL3ykydns4fvwf69fJycl8990mWrdui16fhY+PLx999H6h7U6fPmX9Oicnh3fffYuwsPACx+3duwdD3rbJadP+TYcOHW3GpCgKBw7st76Pbdq0nkaNyliHqoSaNWtBcnISvr6+bN36PVu3ln6Vj1arwWAwkZn5BQcP/mG9k1/r1m0dmqC0B0VRCAgIICkpCbVazcCBQyusb9ku6NwkeSWEEEIIIUrN19eXyZMn88QTTxAUFETr1q25++676d27N0eOHCm27e+//87GjRvR6XRMmDCB1atXM2nSJDtFXjy331YCji3c3r37g+zatZ3U1NRKu6tacHBIhdQ+8vb24Z57OmE0GgtsR6sRFAfApQRLQiUrK4s///zDWtfKzc29QL0trVaLRyHb2m5OiLkUkkBqWMuVC57JtNRYipkbzWZ8XLSkGS1Jrsbe3mgNLcnNuoyr5z9oVSoaenvn6+OkW4Klr7zC7VHB1Qh192BvRhr+np6cSbRsaWsYdK7Quaju4cmkeg1JyM0h3N0Dd42GLkEh7LgWjwqIypvvGp6eTGnYGKOi4KpW5+vDRa0iPjubZEMuO69dxV2joUNA/kLyvmGWOJNiA/ni0nlOZWQQ6OrKmFp1rSvD4rOz2Z+ciLeLC2atc/zJFxFRg1OnLPXGwsPDcXFxwcXFxWayxd8/gMuXLdtC1Wo1vkXUEjOZjDd9bSr0mFsZDIZ8CfjExASys7Nxd3cvUfuy8PX1xdfXt1x9RHjEYdSa2HMhB2NegtRgMJCQkECNGjUqIkynpVKpaNasBWfOnMbf35/mzVtWWN8uB/8ApHC7s3LIO1lkZCQNGzZErVajUqnQ6/XodDpmzpxJs2bNim174cIFZs6cSVJSEgaDgSFDhjB27NhCj+3QoUO+T/Eef/xx+vXrR1JSElOmTCE2Nha1Ws2sWbNo3brwZapCCCGEEKJwY8aMYejQoRw4cIADBw6wdOlSli5dyuTJxRdWbt++vbWQb5MmTUi9aXuXo+mOTgUcf9dBX18/fH39mDr11QrvOzjYm2vXKudOZYmJCXz++X/IzMykV7sfURSFK67raNz4Lnbs2Mpvv/1qPfbmxJWvry8RETVJS0tFd9M2OoPZjPamBI/BbOaPlBsrqqq7ezAsoiZza+/goPkMbQ/chUExc19gCEOqR/BPWhqeLho6BQYzY/soDGYzwztMI8LDk6BbEoOfBR4AbtS8Amjs7cNJLPF89udDlp8XUvMq12wm3WjAT+uab2vh/cEhtPDzQ40q3+NqlQrXQpJwCTk51qLrACfS0wskrxp1tcT52ZKOnMqwbNtMzM3ll8QEeoaGkW0y8Z8LZ8nKS+AE63Tc1bBRpbyWjh07ykcfvY+iwL/+NYkmTZoWeWxsbAz79+8jIiKCXr26leo1eOTIIU6dOkmbNu2oXbtOoce0aNGaxYsXoFKpeO65yXTt2s1mv4qi8O9/P8OxY5ZVYQaDgRMnjvHhh5/i7++8W/CCD/cl12CidptpvPHGjed1zJhxtGnTzoGR2U9Fr0gF8HrdMpdS88o5OSwNv2LFinx7cpctW8bs2bNZvXp1se1eeuklBg0axNChQ0lPT2fIkCE0btyYe+65J99xZ8+exdfXl02bNhXo4/XXX6dt27ZMmDCBY8eOMX78eLZu3Vrll1gKIYQQQlSUP/74g4MHD/LEE08QFRVFVFQUL7zwAn379uX48ePWekpg+YPwZjevari59pIzSG+9xNEhlJqiKPzxxwFUKmjdul0h2/YKHv/LL3uIjb3MAw/0wO+mYuCldeLEMWJiLtOmTXt8fX2ZM+d1jh79G4C485bVJfEpL/H5519x5MihfM93REQN64qa9PR0/vnnLwAMPj5keXmz4sI54rKzqePpxSM1a6NVq0kx5ObbMqhWqfBzdWVCQgfWX77E0by7611P6jT18aVXaBgqlYoJ7f4HQO0izndCQodiz/V6+1udy8jgf5fOY1AUqru7M6Z2PVzVarKMRr6KucTVnGxa+/kTHRJqcz4DXN3QaVzIuGkVUbbJhLtGQ6xezzdxMXy/LJx7g4ILrNq6/n260WBNXAHoc3OpLHPnzuJq3lbMOXNe53//+6rQ406fPsWLL04iJycbnc6b5s0b4+ZW8tVHzZu3tLnCpmfP3kRFPYBKpSpxUXqVSsXMmW/yzDNPWs8jOTmZkydPcPfd99ho7UBtF5ORnElHXROee24yR44cok2bdndM4qqyZLzl2K21onhOsYbUaDQSFxdnXT65aNEiTp06RUJCAomJiTRq1Ig333wTnU7HkCFD6NWrFwDe3t7UrFmT2NjYAn0ePHgQtVrNqFGjSElJoUePHjz11FMoisKuXbt47bXXAGjcuDG1a9dm9+7ddO/e3X4nLYQQQghxGwsICGDJkiW0bNmStm3bAnDt2jX0ej0PPPAAy5YtIzExkYCAALZv3+7gaEsut3lfR4dQau+/P5+tW38AoFevvjzzzAvWnyUnJzF37htcunSRXr368sgjj/HWW2+xfv16AJYvX8aiRR9Tp07pi7b//POPzJ37Rt6dJsNYtOgTazIK4Mzl6x8MZ/DNNxutMVri7McTT0zgxx+3k5BwjS+//Nz6s2yDgQNJScRlW1ZmncvK5EhqCm38A/DTuhKgdSUpb3VSvbyC9rVz/VFS4oH8idK/01K5NzCYMA8PavvH5PvZqYx0/kpNoZq7O/cEBFE7t/gk3q3twbISbOXlCxjyEnIx2dl8ExfD4Oo12JVwlTN5Be1/SrhGA503NT29ih3DQ6Ph8Tp1WXnxPAm5uZzJzOB/F8/zRJ16fBVzkcTcXGLOqvn7YipTGobTxs+fv9NS8dVq6ZC3MCDA1Y0IDw8u6y31ugK8ih/zusuXL3Hw4O80aBBJo0YlK3aelZVZ6Ne32rdvj3WlXUZGOnv37qVr114lGqM0yrLNduHC96yJKwAPD48iV3c5Db+mmAyWlWs9evSiR4+Kn8s7kamERf6FYzgseTV69GhUKhVJSUm4ubkRFRXFW2+9Zf354cOHWbduHQEBAUyePJkPP/yQqVOnMnjwjSKaP//8MwcPHuTNN98s0L/JZKJTp05MmTKF7Oxsxo8fj06no3fv3pjN5nyrvqpVq8aVK1fytU9LSyMtLS3fY66uroSElL82gBBCCCHE7a5OnTp8+OGHLFiwgCtXruDm5oa3tzezZs2iUaNGDB8+nMGDBxMcHEyXLl0cHW6Juf3yGQA5HQsvS+GMdu7cftPX2/Ilr/773/9w5MghAFauXMHFixc4cODG1j2Tycj3339TplvN79nzk3UV1ZUrcZw6dYLevftZE1EtGmaiKApeQT1YuXJFvrb+/v54eHjQq1dfsrOz2b9/H2fPnkalUhHk5YWLOv/qsetbB7VqNU/Uqcvh1BS8XbQ0z6t/dNTtKrVrazhy2sDN6/jUgHveHfuOXq0PQJOQ01zLyeaLixcwoUAqqFDhF27ZHtgkp/Df929uf12awUCu2ZzvuMOpKTTy9sFwy+MGc8lWGAa6uuVbOXVJn4VZUcjOe6x5gww0KhUGk4nTmRnkmM1czclh29V4+odHoFGpGFOrLqcz0vHWavnDaHvlVWxsDJMmTUCvz0KtVjN79tu0KkHdnyeeeIpFi95DURTGjftXkcfVq9fA+rVKpaJhw4Y2+y6JCxfO4+LiQvXqEWXu46+/Duf7ft689wFYuPBdtFotI0Y8ip+fXzmirATXfsElJQuj392OjqRKcfltPwDG9jKvzsjh2waPHj3KuHHjaNWqFYGBN+6c0bNnT4KCLPu7hwwZwpw5c5g6dar15xs2bGDu3LksXLiw0ITSQw89ZP3a1dWVMWPG8Pnnn/Pggw8WOBYocDvnFStWsHjx4nyPtW7dmi+//BJ//5J9eiGcX3Cwt+2DxG1BnsuqQ57LqkWez6qtQ4cOdOhQ+FarqVOn5vvdbeLEiQA888wz+Y679XtH052cAdxeyat69epx4sRxAOrWvbGCKjc3l3379uQ7dvfuXQW2FYaGFrxzW0k0aBDJ7t0/AZbVKhERNWnVqg0dOnTCaDTQNuQ5TCYTX+xpzr59e63tfH196d27n/V7d3d33n13EceO/cPGjWsxxcXQ3suHGL2eC1mZROp8rHcfBNC5aOkUGJwvlv8G/gGBMJVo0o0GfklMINmQS8eAIPzztpD995DlQ/C53eeRkJtrSVzluZqTzdeBlm2LN9e8yjfGTe2t5+KqJcTNjas5OfmOTcrN5b6gEM5lZZKUm0tzH1/qlHAFFEB9nTdHUlMAqOulQ61S0b1aGJtiLzPxoRgCXF359X8mUm/aQhmTt9IKLEm+xnlz9ke67eTVX38dRq+3FC43m838/vtvJUpe9ejRi/vvj0JRKLYES8eOnZk8eRr//PMXbdq0p1WrVuWuu7Zs2f+xdu0qAMaOHc/QoSPK1E+7du3ZsWMbAK1ataVBg4aMHz+aS5cuAnD+/DnmzVtQrlgr3OFpeBlMpLaV2kwVyWvO64DUvHJWDt822KRJE15++WWmT59OixYtiIiwZM1vTiaZzWbUeZ+2KIrCvHnz2LJlC8uXL6dx48JvZbpx40YaNWpEo0aNrO1cXFysCbLU1FTrNsX4+PgCt2cePXo0AwcOzPfY9b3TycmZGI35P0kpL/nl3jEqq1ipPJ/2J89l1VFZzyXI8+kIFf18urio5UMkUanS2v/H0SGU2muvvclXX32JSqVi6NCR1scPHz5Ial4C5GaKolC3bj0yMjK4++57GDBgcIFjSmLIkOF4enpx+fIloqIeIDjYklBq2DASgByTpX5Y7drJ+do9++yLBYphu7u706pVG7Zu/Z50LMmXhyJqljiWp691BMDf1RV/V9dCt+c9ffeN1V+1Pb2s2w81KhXNff1om9dHkWPcvaLAYy4qNY/XrseB5ET2JiagN5nQubjQ1McXf1dXnqsfidFsxuWW+lS2DAyPoJ6XDpOi0CJvdVkrP3+aePuQ+GN1MtQavF201PDw5FJe0qmJj0+pxrhZZGRjXFy0GPPuzlhc4fVbubuXrG5w167dSlREvSTMZjPr16+xfr9u3ZoyJ6+ef34qLVq0xmg0Eh3dHZPJlG/764UL58sbbsVr/39kJBW9TVOUTcY7Hzg6BFEMhyevAPr06cO6deuYM2cOH330EQA7duzgqaeewsvLizVr1hAVFQXAm2++ycGDB61bCoty6tQptm7dyqJFizAYDKxcuZK+ffvi4uJCly5dWL16NePHj+f48eOcOXOGu+/OvzTQx8cHn3L8D0AIIYQQQtx+DE0q5o9re/L3D2D8+IkFHg8MDMxXIP361/7+/syc+ZY12VRWKpUq3wqqW5k0lq1ibdrA5MnTOHjwD1q0aMU993Qu17iFiTDYLv4d4XujTIiHRsOTdetzMSuTIFc3At3cbi2XVWz7m3loNNwXFEI7/0Cu5mQT4uaOx00fxJc2cQWgUaloVUhheTeNBmNKAEZArYLRtepwPD0NT42G+rqyf0BTu3Yd5s9/n99++5XIyMbOXawcUKvVBAUFW2tVhYRUs9GiaBqNhm7deuZ7LDq6O9u3bwGge/fCV+I5lE8kppzK+7DvTmWq38D2QcJhnCJ5BfDqq6/Sr18/du/eDUBQUBDjxo0jOTmZdu3aMWHCBOLi4vjf//5HeHg4Y8aMsbZ99NFHGTx4MK+88gpNmzZlxIgRPP3008yaNYu+fftiNBrp2bMnQ4cOBeC1115j+vTp9OnTB5VKxdtvv423t3waL4QQQghxp3PfbVktlH3vUw6OpPzq1q3P889PYdu2zdSqVZtu3R7k8uWLdOnSCbXas9LH1xosWxYN2s4VuuqmMH+5WxJLzbKLvqPfX/GWFWHNqp0ALEmnSO8bH1bb6uPW9rfy0GioZaMge0UIqGmJM+liKK5qtbXuV3k1atSkxIXancGsWW+xYsUyXFxcGDv2yQrt+4UXptK1aze0WleaNm1WoX1XiPif0KZkYQio+ETwnUz7S957VkeZV2fkkOTViRMF3/Dr1q3L339bbqt76NAhIiMjmTFjRr5jwsLCOH78eJH99urVi1OnTgGWPdc3F4C/WVBQEB9//HFZwxdCCCGEEFWU1xnLjYCqQvIKoFu3nvlWlTRsGElwsHelbtG+zjNrDgCpvpVfP2ZlwEGg6HpVACsPD7Acc1PNqtL0Yau9vTS41xLn/pVOuCLIjmrVqsOMGbMrpW+VSlWiml8O89dreBpMpAZIbaaK5Pl23nuW1LxySk6z8qoipKSkMGTIEEeHIYQQQgghblOpnb50dAhVRrruQ7uN9exV2yslnr3ns3L1Yau9vRz5TlaF3PE6fEZ6Yoajo6hy0t+333uWKD2nTF6V9a4zvXv3ruBIhBBCCCHEncTY4F5Hh1BlmDV17DZWmNF2CZAw72vl6sNWe3vRp0i5kzueri5mvdS8qmjm2vZ7zxKl55TJKyGEEEIIIRzB48cFAOijnndoHJ073+/Q8SuCNvdHAAyuUZU+1kGPWABa6cOLPibOUs+pVdjRMvVhq729BNa2xJl4vuhzFVXcle2WmleBlX9tOavKeI/U/pT3nnX/nTuvzkySV0IIIYQQQuTxvPAuAHocm7zq1Ok+h45fETz18wFItUPyarX/YaD45NXqv/pajiki+WSrD1vt7aV+J0uckry6g/0921Lz6g5OXlXGe6Tngrz3LEleOSVJXgkhhBBCCJEntcsGR4dQZaTrPrHbWP+Ot/2H7L87LS1XH7ba28vhr2//xKYop3s+Jz1Jal5VtPQP7feeJUpPkldCCCGEEELkMdZu5+gQqgyzJsJuYwWbvGwf45VUrj5stbeX7HTb5yqqOK8amLOk5lVFM1e333uWKD21owMQQgghhBDCWXjseBuPHW87OowqQZu7DW3uNruM9bvHZX73uFz8MTFN+T2maZn7sNXeXoLqXiaobvHnKqq42M1oE+xzbd1JtDu3od0p8+qsZOWVEEIIIYQQeTwvLQRAzxQHR3L789Rbit+nunar9LHW+v8FQFt90Ssn1v5juTN52+p/l6kPW+3tpd49ljgTzsoqkTvW0bmWmldBlX9t3Uk8F+a9Z3WVeXVGkrwSQgghhBAiT/IDmx0dQpWR5v0fu401Jd72ncem3LukXH3Yam8vBzfe/neiFOXUaRVpiVLzqqKl/Z/93rNE6UnySgghhBBCiDzmCMdvC6sqFHU1u40VYPK0fYxHWrn6sNXeXnIzbZ+rqOI8QlHcpOZVRVOq2e89S5Se1LwSQgghhBAij+eW2Xhume3oMKoE19wfcM39wS5j7fe8xH7PS8Ufc6kF+y+1KHMfttrbS0j9S4TUL/5cRRV3+Rtcr9nn2rqTuG75AdctMq/OSlZeCSGEEEIIkccj7mMAspju4Ehufx76RQDkuj5Y6WNt8LPUobo7q0bRxxzraTmmxuEy9WGrvb3UudsS59XTRZ+rqOKOv4uHwURucOVfW3cSjyV571k9ZF6dkSSvhBBCCCGEyJP84I+ODqHKSPP+vEztEkwmNqWnlKpNq9OtAdhkKrpdq9ZzLMekF77dqqg+EozGErW3l+3/tcSZmZVSouMTTCa8KzEe4QCd10rNq0qQtqxs71nCPiR5JYQQQgghRB5ztQaODqHKUNSBpW5To0atMo1VkuTMjWNCS9WHOTUFAF9fPwC02uoYDKaSB1dJSpqQ8qbs8yqclHsQiqubo6OocpTA0r9nCfuR5JUQQgghhBB5PL9/FYCsXm84OJLbn2vO1wDkuvUrcZuRIx8t01jfnrGM1ade0WN9+63lT58+fYxl6uN6+zFjPLh2zXGrr8oyr6KKubQe11Q9udXkNVCRXL/Nu7b6yLw6I0leCSGEEEIIkcfjquVW6VlI8qq8PLIt9cPskWT59C/LWMUlrz79VGs5pojkla0+rrcfM6bMYVYIe86rcFInFlpqXknyqkJ5fJp3bUnyyilJ8koIIYQQQog8yf32OTqEKiPN+0u7jfXfB22P9d//6svVx432jq0gZc95FU7qvk2kJTi29lpVlPZfubacmSSvhBBCCCGEyGMOkDu4VRRF7Wu3sXzcbI/l41O+Pmy1txd7zqtwUq6+KFq1o6OochQfubacmbzihRBCCCGEyOP1zRS8vpni6DCqBLecdbjlrLPLWBtPrWPjqeLH2rjRhY0bi/7s3lYfttrbiz3nVTipC6txuyKvgYrmtnEdbhtlXp2V4999hRBCCCGEcBLuiV8AkMnbDo7k9ueevQyAHLfBlT7W8n8sYw1oUPRYy5dbalYNGFB4zStbfVxvP25cmcOsEPacV+GkTi3B3WAiJ1ReAxXJfXnetTVA5tUZSfJKCCGEEEKIPImDDzk6hCoj1Wet3cb6orftsb74oviaV7b6uNHesTWv7Dmvwkl1+Z5UqXlV4VK/kGvLmUnySgghhBBCiOu8gxwdQdWh8rTbUJ5a22N52jjEVh+22tuNHedVOCkXT9CYHB1F1eM0F7kojNS8EkIIIYQQIo9u43PoNj7n6DCqBLecVbjlrLLLWF+dWMVXJ4of66uvXPjqq6I/u7fVh6329mLPeRVO6tz/cIuT10BFc/tqFW5fybw6K8e/+wohhBBCCOEk3FIs20YyeN+xgVQB7tn/BSDHbXilj7XymGWsoZFFj7VypaVm1dChhde8stXH9fb/+leZw6wQ9pxX4aTOfGqpeRUmr4GK5L4y79oaKvPqjCR5JYQQQgghRJ7EEScdHUKVkeqzyW5jfdXX9lhffVV8zStbfdxo7+iaV/abV+Gkum4j9ZrUvKpoqV/JteXMHJK8ioyMpGHDhqjValQqFXq9Hp1Ox8yZM2nWrFmxbZOSkpgyZQqxsbGo1WpmzZpF69atCxyn1+uZPn06R48exWw2M3nyZB544AEADh8+zOuvv45eryckJIT58+cTEhJSKecqhBBCCMfZtWsX7777Lrm5uURGRjJnzhySkpJ4/vnnycnJ4bHHHmPIkCEAbNq0ibNnz/L88887OGrhUG5S86TCqLR2G0qrsT2W1sYhtvqw1d5u7DivwkmptZZ/omI5zUUuCuOwlVcrVqwgICDA+v2yZcuYPXs2q1evLrbd66+/Ttu2bZkwYQLHjh1j/PjxbN26FQ8Pj3zHLVq0CE9PT3744QdiY2N56KGHaNq0KQEBAUyaNIn33nuPNm3a8MUXX/DKK6+wdOnSSjlPIYQQQjhGUlISL7/8Ml9++SW1a9dm/vz5vPPOO7i5uTF27Fi6detGr169GDJkCBkZGaxcuZIVK1Y4OmzhYLoNTwOQMXCxgyO5/bllrwQgx/3hSh9r1XHLWMMbFT3WqlWWP32GDy9826CtPq63f+aZModZIew5r8JJnV2OW3o2OeHyGqhIbqvyrq3hMq/OyCm2DRqNRuLi4vD19QUsiadTp06RkJBAYmIijRo14s0338Td3Z1du3bx2muvAdC4cWNq167N7t276d69e74+t2/fzjvvvANAeHg4nTt35ocffqB58+bodDratGkDwJAhQ5gzZw7Jycn4+/tb26elpZGWlpavT1dXV0JCQtBoKqfOfcPawZXSryiai0vl3bPAq3r9SutbFFSZz2WDkDqV1rcoqDKfSwD/BnJt2lNFP5/X/x8cFxeHyZT/Tks+Pj74+PhYv9+zZw/NmjWjdu3aAIwYMYL+/fszcuRI9Ho9OTk5qNWW/j788EPGjBlT4MMw4ZzUalWl9e2m/AlAViWO4Qwqcw6vczftAMCgfqTSx9p12TLWyCZFj7Vrl2VVxciRhd+lzVYf19s/84x95q8o9pzXyuTIObztxW7G3WjCEHF7vwYcqbDXn/uuvGtrpMxrcRx17aoURVHsPej1bYMqlYqkpCTc3NyIioriqaeeIjAwkEWLFrF27VrWrVtHQEAAkydPJiQkhLFjx9K1a1f++usva18vvvgizZs359FHH803RrNmzdi5cyfBwZaE0IIFC8jOzqZ58+asX7+eZcuWWY+97777+OSTT2jUqJH1sUWLFrF4cf5P3IYPH87rr79eGVMihBBCiFIYMWIEf/75Z77Hnn76aZ65aUnEJ598wuXLl5k1axZg+bDsrrvuYufOnbz66qukpKTwr3/9izp16jBnzpx8vxsIIYQQQgjn4fBtg0ePHmXcuHG0atWKwMBA68979uxJUFAQcGN11GOPPVZoXxqNpsBjheXk1Go1ZrO5RH2MHj2agQMHFjguKysLT0+phSCEEEI4SkZGBvPnzy/w+M2rroAi/5/v7+/PZ599Zv1+3LhxvPzyy+zatYsvvvgCPz8/pk2bhp+fX4XGLYQQQgghysbh2wabNGnCyy+/zPTp02nRogURERFA/mSS2WxGrVZbk1upqanWLYbx8fFUq1atQL9hYWFcu3bNuvLq6tWrNGrUyPr4dQaDgeTk5AJ93Lr1QAghhBDOQafTodPpbB4XFhbG4cOHrd/Hx8fj6+ub70OozZs3U7duXerXr8/EiRPZuHEj27ZtY/ny5Tz33HOVEb4QQgghhCilyi0sUkJ9+vShZcuWzJkzx/rYjh07SE9Px2w2s2bNGqKionBxcaFLly7Wou7Hjx/nzJkz3H333QX6jI6Oth535coVdu/eTVRUFC1atCAlJcW61WDdunW0bNlSElVCCCFEFdO5c2cOHz7M+fPnAVi1ahXR0dHWn+v1epYtW2bdamg0GtFoNKjVarKzsx0RshBCCCGEKITDal7t27cv390Gz549S79+/ViyZAmHDh3i119/xWQykZycTLt27Zg+fTru7u4kJCQwffp0Ll++jEqlYurUqXTu3BmwLPsfPnw40dHRZGZmMnPmTI4ePYrJZOKpp56if//+ABw5coRZs2ah1+vx8/Nj3rx51hVfQgghhKg6fvrpJ959910MBgM1a9Zk3rx51u2ACxYsoHbt2tYyAStXrmTlypXodDreffddatSo4cDIhRBCCCHEdQ5JXtmyaNEikpOTmTFjRqnarVmzBn9/f7p161ZJkQkhhBBCCCGEEEIIe3KKbYMVRaPR0KVLF0eHIYQQQgghhBBCCCEqiFOuvBJCCCGEEEIIIYQQAqrYyishhBBCCCGEEEIIUbVI8koIIYQQQgghhBBCOC0XRwcgnNehQ4d49913SUlJQVEUQkNDmTp1Kg0aNHB0aKKMyvKcHjlyhLVr1zJr1iw7RipuNXv2bA4cOADAmTNnqF69Ou7u7gAcP368wB1cxe0pMjKShg0bolbf+GypadOmvPnmmwWO7d+/P59//jk+Pj72DFGIMrv59a1SqdDr9eh0OmbOnEmzZs2KbZuUlMSUKVOIjY1FrVYza9YsWrduXeA4vV7P9OnTOXr0KGazmcmTJ/PAAw8AcPjwYV5//XX0ej0hISHMnz+fkJCQSjnXilKeObtuz549zJ8/n02bNlkf27VrF++++y65ublERkYyZ84cdDpdgbbFzdnHH3/Mxo0bMZlM9OvXj6effhqVSlUxJ16ByjOHFy5cYObMmSQlJWEwGBgyZAhjx44FSv56On/+PNOmTSMlJQVPT0/mzZtHvXr1AFi7di3Lli3DZDJxzz33MH36dLRabcVPQjmUZ/6OHz/OzJkz0ev1qFQqnn/+ee6//37gznkNVsQ1nJqayqBBg5g8eTI9e/YE7pzXH5RvDk+cOMHw4cOpWbOm9bEFCxZQt27dO2YOyzN/2dnZvP322/z555/o9XqGDh3KE088ATjoNagIUYicnBylffv2yt9//219bOPGjcr999+vGI1GB0Ymyqqsz+m6deuU8ePH2yNEUUJRUVHKkSNHrN83bNhQSUxMdGBEoqLIcymqssJe359++qny0EMP2Ww7adIkZcmSJYqiKMrRo0eVzp07K1lZWQWOmzdvnjJ9+nRFURQlJiZG6dSpkxIXF6fk5OQo9913n/L7778riqIoK1euVJ544onynlKlK8+c6fV65b333lPatGmj9O7d2/p4YmKi0qFDB+XcuXOKoijK22+/rbz22msF2hc3Z7t27VL69++vZGZmKtnZ2crDDz+sfPfdd2U8y8pVnjkcPny4smbNGkVRFCUtLU3p3r278ssvv5Tq9TR48GDl66+/VhTFMm+9evVSzGazcuLECeW+++5TEhMTFZPJpDz//PPKJ598Up5TrRTlmb8+ffoo27ZtUxRFUU6cOKG0bNlSycnJuaNeg+WZP0VRFLPZrDz55JNK+/btlR9++EFRlOLn5Va3++tPUco3h19++aX1/wk3u5PmsDzz98YbbygvvPCCYjQalbS0NCUqKko5ePCgw+ZPtg2KQun1etLT08nKyrI+1q9fP1599VX27dtHnz59rI/v37/f+v2iRYt46aWXePzxx+nZsycjR44kPj7e7vGLgop7Tk0mE7Nnz2bo0KH06tWLBx98kD/++IO4uDgWLlzI77//zssvv+zA6IUtixYtYtCgQXTt2pWVK1cCsH79ep588knrMTd//9JLLzFhwgR69+7N/PnzHRKzKJ2mTZvy7LPP0qNHD/766y8iIyNJSkpydFhClJnRaCQuLg5fX1/A8j42adIkRo4cSY8ePXj22WfJyMjAaDSya9cuHnroIQAaN25M7dq12b17d4E+t2/fztChQwEIDw+nc+fO/PDDD/z111/odDratGkDwJAhQ9i3bx/Jycl2OtuKUdI5A8uKK71ez5w5c/L1sWfPHpo1a0bt2rUBGDFiBN988w3KLfdwKm7Otm3bRp8+ffD09MTNzY1Bgwbx9ddfV/LZV4zSzOGQIUOsv+N6e3tTs2ZNYmNjS/x6io+P5+zZs/Tu3RuA+++/H71ez9GjR9mxYwddu3YlICAAtVrNsGHDbos5LM38bdiwgejoaAAuXryIj48PGo3mjn4Nlmb+AD766CPrypnr7uTXH5RuDg8ePMiZM2cYMmQIQ4YMYevWrcCdPYclnT9FUdi0aROTJk1Co9Hg7e3NihUrqFu3rsPmT5JXolC+vr5MnjyZJ554gujoaCZPnsy6devo2LGjzaWQv//+Ox988AGbN2/Gx8eH1atX2ylqUZzintN//vmHq1evsnr1ar7//nsGDhzI0qVLCQsLY9KkSbRt25a33nrL0acgilGjRg3Wr1/P4sWLmTt3LgaDwWab7OxsvvvuOyZPnmyHCEVJjR49mv79+1v/JSYmAmAwGIiKimLLli0l3moghLMZPXo0/fr1o3PnzvTo0QMg3/9fDh8+zMKFC/nhhx9wcXHhww8/JDk5GbPZnG9rdLVq1bhy5UqB/uPi4ggLCytw3JUrVwgNDbU+7urqSkBAwG3xAVtZ5gzggQceYNq0adY/UK67dS5CQ0PJyMggMzOz2ONunrNb5zk0NNSp57Ksczh48GA8PDwA+Pnnnzl48CD33ntviV9PcXFxhISE5NsKfv01eTvNYVnnz8XFUqHmgQce4JlnnmHcuHFoNJo77jVY1vnbs2cPBw4cYNKkSfn6u9Nef1D2OfTw8KBPnz6sXbuWefPmMXPmTP7+++87bg7LMn9JSUlkZmbyyy+/MGrUKPr378/OnTvx8fFx2PxJ8koUacyYMezdu5fp06cTHBzM0qVLGTBgAOnp6cW2a9++vXXPepMmTUhNTbVHuKIEinpO69evz3PPPceqVauYN28emzdvLvALhHBu1z8Zbty4Mbm5ufk+tSvK9U9LhHNZsWIFmzZtsv4LDAy0/qxt27YOjEyI8luxYgVff/01n3zyCdnZ2bRq1Srfa7xnz54EBQWhVqsZMmQIe/bswWw2F9qXRqMp8NitKzcA1Gp1qfpwNmWZs+IUNRc3/3FR3HEajabIeXZW5Z3DDRs2MHnyZBYuXEhISEiJX09VZQ7LM38qlYrt27ezdetWPvnkE/bt23fHvQbLMn+xsbHMmzeP+fPnl+p1VdLjbqf5g7K/BmfOnMnIkSMBqFevHg8++CA7d+684+awLPNnNBoxmUxcvHiRFStWsGzZMlatWsX27dsdNn/OObvC4f744w8+/fRTdDodUVFRTJkyhe+++w61Ws3x48fzvdhuXeFxvYg0WP6HVdgLU9hfcc/p9u3brdvJoqOjGTFihIOjFaV1/dPN64VKFUUpcP3deq16enraL0BRIeQ5E1VFkyZNePnll5k+fTqXL1+2Pn7zL75msxm1Wm39BfvmD8Pi4+OpVq1agX7DwsK4du2a9furV68SGhpa4HGDwUBycnKhfTir0sxZcW6di/j4eHx9fQu8vxQ3Z4X1cfOn8M6qtHOoKApz585l4cKFLF++nI4dOwLFz83NwsPDSUhIyPf/4utzFRYWxtWrVws87sxKM3+5ubl899131j9ea9SoQceOHTl27Ngd+xoszfxt3rwZvV7PE088Qf/+/fn77795++23+fLLL+/Y1x+Ubg5NJhNLlizJ94Guoii4uLjcsXNYmvnz9/dHq9XSv39/1Go1QUFBdOnShYMHDzps/iR5JQoVEBDAkiVL+P33362PXbt2Db1ezwMPPEBsbCyJiYkoisL27dsdGKkoqeKe0++++46oqChGjhxJs2bN2L59OyaTCbC8mRmNRkeFLcohICCAU6dOkZOTg9Fo5Mcff3R0SEIIYdWnTx9atmyZrybTjh07SE9Px2w2s2bNGqKionBxcaFLly7WMgTHjx/nzJkz3H333QX6jI6Oth535coVdu/eTVRUFC1atCAlJYU///wTgHXr1tGyZcvb7m6dJZ2z4nTu3JnDhw9z/vx5AFatWmWtS3Sz4uYsOjqar7/+mqysLHJzc1m/fr31ro7OrjRz+Oabb3LgwAHWrVtH48aNrceX9PUUGhpKzZo1+f777wHYvXs3arWahg0b0rVrV3bu3Gn9fXr16tW3xRyWdP5cXV15//33+e677wDLH6b79++nXbt2d/RrsKTzN3bsWLZv325dhd20aVOmTJnCiBEj7ujXH5R8DjUaDTt37mTNmjUAxMTEsHXrVnr06HFHz2FpruGoqCjrnWqvbyFs1qyZw+bPpSInQlQdderU4cMPP2TBggVcuXIFNzc3vL29mTVrFo0aNWL48OEMHjyY4OBgunTp4uhwRQkU95xWr16dF198kb59+6LRaGjbti1bt27FbDbTqlUr3n//fSZOnGjdPy5uD506daJdu3Y8+OCDBAcHc/fdd3PixAlHhyWEEFavvvoq/fr1sxZfDwoKYty4cSQnJ9OuXTsmTJgAwGuvvcb06dPp06cPKpWKt99+G29vbwDGjRvH8OHDiY6O5plnnmHmzJn07t0bk8nE5MmTrbdIX7x4MbNmzUKv1+Pn58e8efMcc9LlVNI5K0pgYCBvvfUWkyZNwmAwULNmTetc/PXXX0yfPp1Nmzah1WqLnLOuXbty8uRJhg4disFgIDo6mgEDBlTqeVekksxhXFwc//vf/wgPD2fMmDHWto8++iiDBw8ucm7i4+MZP348n3zyCdWqVeO9997j1VdfZcmSJbi6uvLBBx+gVqtp1KgREydOZPTo0RgMBlq0aMG4ceMcMh+lVdLX4PU5+vTTT1Gr1UyePNlas/FOfg2W9xoubl7uhNcflHwO33nnHV577TU2bNiAyWRi2rRp1KtXDyj6/wl3whyWdP7eeOMN3nzzTXr16oXJZKJv37707NkTcMz8qRTZ0yWEEEIIIRxs0aJFJCcnM2PGjFK1W7NmDf7+/nTr1q2SInNeZZ2z4lz/o+NOURlzOHnyZKZNm4a/v3+F9ems5DVYPvL6Kz+Zw/K5neZPtg0KIYQQQojblkajkVXgFSQ+Pt5a3FiUjV6vp3PnznfEH72VQV6D5SOvv/KTOSyfypw/WXklhBBCCCGEEEIIIZyWrLwSQgghhBBCCCGEEE5LkldCCCGEEEIIIYQQwmlJ8koIIYQQQgghhBBCOC1JXgkhqqzNmzczatQoR4chhBBCCCGEEKIcJHklhBBCCCGEEKJQY8eOJSkpqdzH7N+/nz59+tgcLzIystC+duzYwezZswEYNWoUmzdv5vLly7Rq1cpmn0KI25+LowMQQoiK9MEHH/DNN9/g5+dHrVq1ADh37hyzZs0iKyuLq1ev0qhRI95//322bNnCF198wapVqwCIjY3loYceYufOnbi6ujryNIQQQgghnMLevXsr5Jjyio6OJjo6utLHEUI4J1l5JYSoMrZv387WrVvZuHEjq1atIiMjA4A1a9YwYMAAVq9ezdatW7l8+TK7du2iZ8+eXLx4kdOnTwPw1VdfMXDgQElcCSGEEEIAL7/8MgCjR4/mt99+Y9SoUfTt25d+/fqxcePGAsfExcXx448/Mnz4cAYNGkSXLl14//33Sz3u+++/z8CBA+nfvz8//vgjAOvXr+fJJ5+skPMSQtx+JHklhKgy9u3bR7du3dDpdLi4uDB48GAAJk+eTEBAAEuXLmXmzJlcvXqVrKwsXF1dGTp0KGvWrMFkMrFhwwaGDRvm4LMQQgghhHAOb731FgArVqxg2rRpjBo1im+++YalS5fy3nvvcfDgwXzHhIaG8tlnnzF37lzWr1/P6tWr+eSTT2xuKbxVREQEGzZsYP78+bz00kulbi+EqHpk26AQospQqVQoimL9XqPRAPDCCy9gMpl48MEH6dKlC3Fxcdbjhg0bxtChQ2nfvj0NGjQgIiLCIbELIYQQQjirM2fOkJOTQ/fu3QGoVq0a3bt3Z/fu3flqTqlUKj7++GN27drFt99+y5kzZ1AUBb1eX6rxRowYAUDDhg2pV68eBw8erLiTEULclmTllRCiyrj33nvZvHkzaWlpmM1mNm3aBMCePXuYOHEivXr1QqVScfjwYUwmEwDh4eG0bNmSOXPmWH9REkIIIYQQN6hUqgKPKYqC0WjM91hWVhYDBw7kn3/+oUmTJkyZMgUXF5d8Hy6WhFp9489URVFwcZE1F0Lc6SR5JYSoMu6//34GDx7M4MGDGTp0KN7e3gA8//zzTJw4kUGDBvHaa6/Rrl07Ll68aG03aNAgzGYz999/v6NCF0IIIYRwShqNhurVq6PVatm6dSsA8fHxbNmyhY4dO1qPMRqNXLhwgYyMDJ577jm6du3Kb7/9Rm5uLmazuVRjbtiwAYB//vmHCxcu0KJFi4o9KSHEbUdS2EKIKmX8+PGMHz++wOMPP/xwocebzWZ2797NyJEjrdsMhRBCCCGERbdu3Rg1ahQfffQRs2fPZtGiRZhMJiZOnEiHDh2sx4wcOZLFixfTpUsXHnzwQXx8fKhZsyb169fnwoULpbohzqVLlxgwYAAqlYr33nsPPz+/Sjo7IcTtQqWUdg2nEEJUERkZGURFRdG8eXMWLVqEp6eno0MSQgghhBBCCHELSV4JIYQQQgghhLCLTz/9lG+++abQnz3++OP069fPzhEJIW4HkrwSQgghhBBCCCGEEE5LCrYLIYQQQgghhBBCCKclySshhBBCCCGEEEII4bQkeSWEEEIIIYQQQgghnJYkr4QQQgghhBBCCCGE05LklRBCCCGEEEIIIYRwWv8PCJhYPbDlXLAAAAAASUVORK5CYII=\n", + "image/png": "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", "text/plain": [ "
" ] @@ -9832,13 +9972,13 @@ } ], "source": [ - "from grplot import grplot\n", - "import seaborn as sns\n", + "from grplot import plot2d\n", + "import grplot_seaborn as sns\n", "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", "\n", "\n", "tips = sns.load_dataset('tips')\n", - "ax = grplot(plot={'[1,1]':'histplot', '[1,2]':'ecdfplot', '[2,1]':'treemapsplot', '[2,2]':'pieplot', '[3,1]':'paretoplot', '[3,2]':'boxplot+stripplot'}, \n", + "ax = plot2d(plot={'[1,1]':'histplot', '[1,2]':'ecdfplot', '[2,1]':'treemapsplot', '[2,2]':'pieplot', '[3,1]':'paretoplot', '[3,2]':'boxplot+stripplot'}, \n", " Nx=2,\n", " Ny=3,\n", " df=tips, \n", @@ -9857,6 +9997,339 @@ " alpha={'[1,1]':0.75},\n", " kde=True)" ] + }, + { + "cell_type": "markdown", + "id": "1ee9a5cd", + "metadata": {}, + "source": [ + "# Analytic" + ] + }, + { + "cell_type": "markdown", + "id": "26e15cd7", + "metadata": {}, + "source": [ + "## Cohort" + ] + }, + { + "cell_type": "markdown", + "id": "907d0f73", + "metadata": {}, + "source": [ + "Parameters:\n", + "
\n", + "
\n", + "
\n", + "df: pandas dataframe, dictionary-list, dictionary-numpy.array\n", + "
\n", + "ordinary argument\n", + "
\n", + "Input data structure.\n", + "
\n", + "
\n", + "signup_date: str\n", + "
\n", + "ordinary argument\n", + "
\n", + "Signup date.\n", + "
\n", + "
\n", + "last_active_date: str\n", + "
\n", + "ordinary argument\n", + "
\n", + "Last active date.\n", + "
\n", + "
\n", + "figsize: [float, float], default: [8, 6]\n", + "
\n", + "ordinary argument\n", + "
\n", + "Width, height in inches.\n", + "
\n", + "
\n", + "title: str or None, default: None\n", + "
\n", + "ordinary argument\n", + "
\n", + "Plot title.\n", + "
\n", + "
\n", + "fontsize: float, default: 10\n", + "
\n", + "ordinary argument\n", + "
\n", + "Font size.\n", + "
\n", + "
\n", + "tick_fontsize: float or None, default: fontsize\n", + "
\n", + "ordinary argument\n", + "
\n", + "Font size for tick.\n", + "
\n", + "
\n", + "legend_fontsize: float or None, default: fontsize\n", + "
\n", + "ordinary argument\n", + "
\n", + "Font size for legend.\n", + "
\n", + "
\n", + "label_fontsize: float or None, default: fontsize\n", + "
\n", + "ordinary argument\n", + "
\n", + "Font size for label.\n", + "
\n", + "
\n", + "title_fontsize: float or None, default: fontsize\n", + "
\n", + "ordinary argument\n", + "
\n", + "Font size for title.\n", + "
\n", + "
\n", + "sep: str or None, default: ','\n", + "
\n", + "ordinary argument with the return is '.', ',', '.c', ',c', '.L', ',L', '.cL', or ',cL'\n", + "
\n", + "Numerical thousand separator. c stands for currency. L stands for large number abbreviation using K, M, B, T, and Q.\n", + "
\n", + "
\n", + "saveas: str or None, default: None\n", + "
\n", + "ordinary argument\n", + "
\n", + "Save figure as png, pdf, svg, or eps file. The format is inferred from the file name.\n", + "
\n", + "
\n", + "display_summary: boolean or None, default: False\n", + "
\n", + "ordinary argument\n", + "
\n", + "To show cohort table summary.\n", + "
\n", + "
\n", + "
\n", + "Returns: matplotlib.axes.Axes\n", + "
The matplotlib axes containing the plot." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "6581be52", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
MetricTotal Account
Cohort GroupCohort Period
2019-0702019-07574
12019-08399
22019-09394
32019-10375
42019-11313
52019-12251
2019-0802019-08614
12019-09394
22019-10366
32019-11310
42019-12240
2019-0902019-09515
12019-10343
22019-11301
32019-12229
2019-1002019-10905
12019-11448
22019-12352
2019-1102019-11985
12019-12352
2019-1202019-121407
\n", + "
" + ], + "text/plain": [ + " Metric Total Account\n", + "Cohort Group Cohort Period \n", + "2019-07 0 2019-07 574\n", + " 1 2019-08 399\n", + " 2 2019-09 394\n", + " 3 2019-10 375\n", + " 4 2019-11 313\n", + " 5 2019-12 251\n", + "2019-08 0 2019-08 614\n", + " 1 2019-09 394\n", + " 2 2019-10 366\n", + " 3 2019-11 310\n", + " 4 2019-12 240\n", + "2019-09 0 2019-09 515\n", + " 1 2019-10 343\n", + " 2 2019-11 301\n", + " 3 2019-12 229\n", + "2019-10 0 2019-10 905\n", + " 1 2019-11 448\n", + " 2 2019-12 352\n", + "2019-11 0 2019-11 985\n", + " 1 2019-12 352\n", + "2019-12 0 2019-12 1407" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from grplot.analytic import cohort\n", + "import grplot_seaborn as sns\n", + "sns.set_theme(context='notebook', style='darkgrid', palette='deep')\n", + "import pandas as pd\n", + "\n", + "\n", + "df = pd.read_csv('https://dqlab-dataset.s3-ap-southeast-1.amazonaws.com/retail_raw_reduced.csv', parse_dates=['order_date'])\n", + "df['last_active_date'] = df.groupby('customer_id')['order_date'].transform('max')\n", + "ax = cohort(df=df,\n", + " signup_date='order_date',\n", + " last_active_date='last_active_date',\n", + " figsize=[16,12],\n", + " fontsize=16,\n", + " display_summary=True\n", + " )" + ] } ], "metadata": { diff --git a/grplot/__init__.py b/grplot/__init__.py index de56ffe..b240a00 100644 --- a/grplot/__init__.py +++ b/grplot/__init__.py @@ -10,7 +10,7 @@ from grplot.utils.strtoarray import strtoarray -def grplot(plot, # default general value +def plot2d(plot, # default general value df, x=None, y=None, @@ -195,14 +195,14 @@ def grplot(plot, # default general value by ghiffary rifqialdi based on numpy, scipy, matplotlib, seaborn, squarify, and pandas - version = '0.10.4' + version = '0.11' release date - 25/08/2022 + 11/09/2022 ----------------------------------------------- documentation is available at https://github.com/ghiffaryr/grplot - ''' + ''' # initialization # creating figure Nx, Ny = check_axes(x, y, Nx, Ny) diff --git a/grplot/analytic/__init__.py b/grplot/analytic/__init__.py new file mode 100644 index 0000000..51c2d7e --- /dev/null +++ b/grplot/analytic/__init__.py @@ -0,0 +1,136 @@ +import numpy as np +import pandas as pd +import grplot_seaborn as sns +import matplotlib +from matplotlib import pyplot as plt +import matplotlib.dates as mdates +from grplot.features.optimizer.optimizer_data import optimizer_data +from grplot.features.saveas.check_saveas import check_saveas +from grplot.features.sep.statdesc_sep.statdesc_sep_def import statdesc_sep_def + + +def cohort(df, + signup_date, + last_active_date, + figsize=[8,6], + fontsize=10, + tick_fontsize=None, + legend_fontsize=None, + text_fontsize=None, + label_fontsize=None, + title_fontsize=None, + sep=',', + saveas=None, + display_summary=False): + ''' + ----------------------------------------------- + grplot: lazy statistical data visualization + + by ghiffary rifqialdi + based on numpy, scipy, matplotlib, seaborn, squarify, and pandas + + version = '0.11' + + release date + 11/09/2022 + ----------------------------------------------- + + documentation is available at https://github.com/ghiffaryr/grplot + ''' + if type(signup_date) == str and type(last_active_date) == str: + # preprocessing + preprocessing = optimizer_data(plot='heatmap', + df=df, + x=signup_date, + y=last_active_date, + hue=None, + size=None, + style=None, + units=None, + axes=None, + mode='perf') \ + .copy(deep=True) + preprocessing['Customer ID'] = np.arange(len(preprocessing)) + 1 + preprocessing['Signup Date'] = pd.to_datetime(preprocessing[signup_date]).dt.tz_localize(None).dt.to_period('M').dt.to_timestamp() + preprocessing['Last Active Date'] = pd.to_datetime(preprocessing[last_active_date]).dt.tz_localize(None).dt.to_period('M').dt.to_timestamp() + preprocessing = preprocessing[['Customer ID', 'Signup Date', 'Last Active Date']] + preprocessing.set_index('Customer ID', inplace=True) + preprocessing['Metric'] = [pd.period_range(s, e, freq='m') for s, e in zip(preprocessing['Signup Date'], preprocessing['Last Active Date'])] + preprocessing = preprocessing.explode('Metric') + preprocessing['Cohort Group'] = preprocessing.groupby(level=0)['Metric'].min().dt.strftime('%Y-%m') + preprocessing.reset_index(inplace=True) + cohort = preprocessing.groupby(['Cohort Group', 'Metric']).agg({'Customer ID':pd.Series.nunique}) + cohort.rename(columns={'Customer ID': 'Total Account'}, inplace=True) + def cohort_period(df): + df['Cohort Period'] = np.arange(len(df)) + return df + cohort = cohort.groupby(level=0).apply(cohort_period) + cohort.reset_index(inplace=True) + cohort.set_index(['Cohort Group', 'Cohort Period'], inplace=True) + # summary + if display_summary == True: + display(cohort) + else: + pass + cohort_group_size = cohort['Total Account'].groupby(level=0).first() + user_retention = cohort['Total Account'].unstack(0).divide(cohort_group_size, axis=1) + user_retention = user_retention.iloc[0:,:len(user_retention)] + user_retention = user_retention * 100 + # plotting + # creating figure + fig, ax = plt.subplots(figsize=(figsize[0], + figsize[1])) + # check fontsize + if tick_fontsize is None: + tick_fontsize = fontsize + else: + pass + if legend_fontsize is None: + legend_fontsize = fontsize + else: + pass + if text_fontsize is None: + text_fontsize = fontsize + else: + pass + if label_fontsize is None: + label_fontsize = fontsize + else: + pass + if title_fontsize is None: + title_fontsize = fontsize + else: + pass + sns.heatmap(user_retention.T, mask=user_retention.T.isnull(), annot=True, annot_kws={"size":text_fontsize}, fmt='.2f', cmap='RdYlGn', xticklabels=list(range(0, len(user_retention))), ax=ax) + # fontsize + ax.set_title(label="Monthly Retention Rate", fontsize=title_fontsize) + ax.set_xlabel('Periods in Month', fontsize=label_fontsize) + ax.set_ylabel('Cohort Group (Signup Month)', fontsize=label_fontsize) + ax.tick_params(axis='both', labelsize=tick_fontsize) + cbar = ax.collections[0].colorbar + cbar.ax.tick_params(labelsize=legend_fontsize) + # rot + for label in ax.get_yticklabels(): + label.set_rotation(0) + # sep + # sep cbar + yticks = [] + for num in cbar.ax.get_yticks(): + num = round(float(num), 2) + num = statdesc_sep_def(num, sep) + yticks.append(num + '%') + cbar.ax.set_yticks(cbar.ax.get_yticks()) + cbar.ax.set_yticklabels(yticks) + # sep text + for child in ax.get_children(): + if isinstance(child, matplotlib.text.Text) and (child.get_text().replace('.', '', 1).isdigit() == True): + num = float(child.get_text()) + num = statdesc_sep_def(num, sep) + child.set_text(num + '%') + else: + pass + # save image as + check_saveas(fig, saveas) + else: + raise Exception('Wrong data type of axis!') + return ax \ No newline at end of file diff --git a/grplot/features/plot/plot_single_def.py b/grplot/features/plot/plot_single_def.py index bf32bf3..e029d9c 100644 --- a/grplot/features/plot/plot_single_def.py +++ b/grplot/features/plot/plot_single_def.py @@ -1,5 +1,5 @@ import numpy -import seaborn as sns +import grplot_seaborn as sns from matplotlib.ticker import PercentFormatter from pandas.api.types import is_numeric_dtype, is_object_dtype, is_categorical_dtype from grplot.features.plot.packedbubbles import plot as pb diff --git a/grplot/features/sep/text_sep/text_sep_type.py b/grplot/features/sep/text_sep/text_sep_type.py index 0acfcc2..e576caf 100644 --- a/grplot/features/sep/text_sep/text_sep_type.py +++ b/grplot/features/sep/text_sep/text_sep_type.py @@ -1,4 +1,4 @@ -from pandas.api.types import is_numeric_dtype +from pandas.api.types import is_float_dtype from grplot.features.sep.text_sep.text_sep_data_def import text_sep_data_def from grplot.utils.arg_ax_type import arg_ax_type from grplot.utils.arg_axis_ax_type import arg_axis_ax_type @@ -10,7 +10,7 @@ def text_sep_type(plot, df, num, sep, axislabel, axes): else: sep = arg_axis_ax_type(arg=sep, axislabel=axislabel, axes=axes) if sep is None: - if is_numeric_dtype(type(num)) == True: + if is_float_dtype(type(num)) == True: if num.is_integer() == True: num = '{}'.format(int(num)) else: diff --git a/grplot_seaborn/__init__.py b/grplot_seaborn/__init__.py new file mode 100644 index 0000000..a578c3d --- /dev/null +++ b/grplot_seaborn/__init__.py @@ -0,0 +1,21 @@ +# import grplot_seaborn objects +from .rcmod import * # noqa: F401,F403 +from .utils import * # noqa: F401,F403 +from .palettes import * # noqa: F401,F403 +from .relational import * # noqa: F401,F403 +from .regression import * # noqa: F401,F403 +from .categorical import * # noqa: F401,F403 +from .distributions import * # noqa: F401,F403 +from .matrix import * # noqa: F401,F403 +from .miscplot import * # noqa: F401,F403 +from .axisgrid import * # noqa: F401,F403 +from .widgets import * # noqa: F401,F403 +from .colors import xkcd_rgb, crayons # noqa: F401 +from . import cm # noqa: F401 + +# Capture the original matplotlib rcParams +import matplotlib as mpl +_orig_rc_params = mpl.rcParams.copy() + +# Define the seaborn version +__version__ = "0.11.2" diff --git a/grplot_seaborn/_core.py b/grplot_seaborn/_core.py new file mode 100644 index 0000000..34f80fc --- /dev/null +++ b/grplot_seaborn/_core.py @@ -0,0 +1,1491 @@ +import warnings +import itertools +from copy import copy +from functools import partial +from collections.abc import Iterable, Sequence, Mapping +from numbers import Number +from datetime import datetime +from distutils.version import LooseVersion + +import numpy as np +import pandas as pd +import matplotlib as mpl + +from ._decorators import ( + share_init_params_with_map, +) +from .palettes import ( + QUAL_PALETTES, + color_palette, +) +from .utils import ( + get_color_cycle, + remove_na, +) + + +class SemanticMapping: + """Base class for mapping data values to plot attributes.""" + + # -- Default attributes that all SemanticMapping subclasses must set + + # Whether the mapping is numeric, categorical, or datetime + map_type = None + + # Ordered list of unique values in the input data + levels = None + + # A mapping from the data values to corresponding plot attributes + lookup_table = None + + def __init__(self, plotter): + + # TODO Putting this here so we can continue to use a lot of the + # logic that's built into the library, but the idea of this class + # is to move towards semantic mappings that are agnositic about the + # kind of plot they're going to be used to draw. + # Fully achieving that is going to take some thinking. + self.plotter = plotter + + def map(cls, plotter, *args, **kwargs): + # This method is assigned the __init__ docstring + method_name = "_{}_map".format(cls.__name__[:-7].lower()) + setattr(plotter, method_name, cls(plotter, *args, **kwargs)) + return plotter + + def _lookup_single(self, key): + """Apply the mapping to a single data value.""" + return self.lookup_table[key] + + def __call__(self, key, *args, **kwargs): + """Get the attribute(s) values for the data key.""" + if isinstance(key, (list, np.ndarray, pd.Series)): + return [self._lookup_single(k, *args, **kwargs) for k in key] + else: + return self._lookup_single(key, *args, **kwargs) + + +@share_init_params_with_map +class HueMapping(SemanticMapping): + """Mapping that sets artist colors according to data values.""" + # A specification of the colors that should appear in the plot + palette = None + + # An object that normalizes data values to [0, 1] range for color mapping + norm = None + + # A continuous colormap object for interpolating in a numeric context + cmap = None + + def __init__( + self, plotter, palette=None, order=None, norm=None, + ): + """Map the levels of the `hue` variable to distinct colors. + + Parameters + ---------- + # TODO add generic parameters + + """ + super().__init__(plotter) + + data = plotter.plot_data.get("hue", pd.Series(dtype=float)) + + if data.notna().any(): + + map_type = self.infer_map_type( + palette, norm, plotter.input_format, plotter.var_types["hue"] + ) + + # Our goal is to end up with a dictionary mapping every unique + # value in `data` to a color. We will also keep track of the + # metadata about this mapping we will need for, e.g., a legend + + # --- Option 1: numeric mapping with a matplotlib colormap + + if map_type == "numeric": + + data = pd.to_numeric(data) + levels, lookup_table, norm, cmap = self.numeric_mapping( + data, palette, norm, + ) + + # --- Option 2: categorical mapping using seaborn palette + + elif map_type == "categorical": + + cmap = norm = None + levels, lookup_table = self.categorical_mapping( + data, palette, order, + ) + + # --- Option 3: datetime mapping + + else: + # TODO this needs actual implementation + cmap = norm = None + levels, lookup_table = self.categorical_mapping( + # Casting data to list to handle differences in the way + # pandas and numpy represent datetime64 data + list(data), palette, order, + ) + + self.map_type = map_type + self.lookup_table = lookup_table + self.palette = palette + self.levels = levels + self.norm = norm + self.cmap = cmap + + def _lookup_single(self, key): + """Get the color for a single value, using colormap to interpolate.""" + try: + # Use a value that's in the original data vector + value = self.lookup_table[key] + except KeyError: + # Use the colormap to interpolate between existing datapoints + # (e.g. in the context of making a continuous legend) + try: + normed = self.norm(key) + except TypeError as err: + if np.isnan(key): + value = (0, 0, 0, 0) + else: + raise err + else: + if np.ma.is_masked(normed): + normed = np.nan + value = self.cmap(normed) + return value + + def infer_map_type(self, palette, norm, input_format, var_type): + """Determine how to implement the mapping.""" + if palette in QUAL_PALETTES: + map_type = "categorical" + elif norm is not None: + map_type = "numeric" + elif isinstance(palette, (dict, list)): + map_type = "categorical" + elif input_format == "wide": + map_type = "categorical" + else: + map_type = var_type + + return map_type + + def categorical_mapping(self, data, palette, order): + """Determine colors when the hue mapping is categorical.""" + # -- Identify the order and name of the levels + + levels = categorical_order(data, order) + n_colors = len(levels) + + # -- Identify the set of colors to use + + if isinstance(palette, dict): + + missing = set(levels) - set(palette) + if any(missing): + err = "The palette dictionary is missing keys: {}" + raise ValueError(err.format(missing)) + + lookup_table = palette + + else: + + if palette is None: + if n_colors <= len(get_color_cycle()): + colors = color_palette(None, n_colors) + else: + colors = color_palette("husl", n_colors) + elif isinstance(palette, list): + if len(palette) != n_colors: + err = "The palette list has the wrong number of colors." + raise ValueError(err) + colors = palette + else: + colors = color_palette(palette, n_colors) + + lookup_table = dict(zip(levels, colors)) + + return levels, lookup_table + + def numeric_mapping(self, data, palette, norm): + """Determine colors when the hue variable is quantitative.""" + if isinstance(palette, dict): + + # The presence of a norm object overrides a dictionary of hues + # in specifying a numeric mapping, so we need to process it here. + levels = list(sorted(palette)) + colors = [palette[k] for k in sorted(palette)] + cmap = mpl.colors.ListedColormap(colors) + lookup_table = palette.copy() + + else: + + # The levels are the sorted unique values in the data + levels = list(np.sort(remove_na(data.unique()))) + + # --- Sort out the colormap to use from the palette argument + + # Default numeric palette is our default cubehelix palette + # TODO do we want to do something complicated to ensure contrast? + palette = "ch:" if palette is None else palette + + if isinstance(palette, mpl.colors.Colormap): + cmap = palette + else: + cmap = color_palette(palette, as_cmap=True) + + # Now sort out the data normalization + if norm is None: + norm = mpl.colors.Normalize() + elif isinstance(norm, tuple): + norm = mpl.colors.Normalize(*norm) + elif not isinstance(norm, mpl.colors.Normalize): + err = "``hue_norm`` must be None, tuple, or Normalize object." + raise ValueError(err) + + if not norm.scaled(): + norm(np.asarray(data.dropna())) + + lookup_table = dict(zip(levels, cmap(norm(levels)))) + + return levels, lookup_table, norm, cmap + + +@share_init_params_with_map +class SizeMapping(SemanticMapping): + """Mapping that sets artist sizes according to data values.""" + # An object that normalizes data values to [0, 1] range + norm = None + + def __init__( + self, plotter, sizes=None, order=None, norm=None, + ): + """Map the levels of the `size` variable to distinct values. + + Parameters + ---------- + # TODO add generic parameters + + """ + super().__init__(plotter) + + data = plotter.plot_data.get("size", pd.Series(dtype=float)) + + if data.notna().any(): + + map_type = self.infer_map_type( + norm, sizes, plotter.var_types["size"] + ) + + # --- Option 1: numeric mapping + + if map_type == "numeric": + + levels, lookup_table, norm, size_range = self.numeric_mapping( + data, sizes, norm, + ) + + # --- Option 2: categorical mapping + + elif map_type == "categorical": + + levels, lookup_table = self.categorical_mapping( + data, sizes, order, + ) + size_range = None + + # --- Option 3: datetime mapping + + # TODO this needs an actual implementation + else: + + levels, lookup_table = self.categorical_mapping( + # Casting data to list to handle differences in the way + # pandas and numpy represent datetime64 data + list(data), sizes, order, + ) + size_range = None + + self.map_type = map_type + self.levels = levels + self.norm = norm + self.sizes = sizes + self.size_range = size_range + self.lookup_table = lookup_table + + def infer_map_type(self, norm, sizes, var_type): + + if norm is not None: + map_type = "numeric" + elif isinstance(sizes, (dict, list)): + map_type = "categorical" + else: + map_type = var_type + + return map_type + + def _lookup_single(self, key): + + try: + value = self.lookup_table[key] + except KeyError: + normed = self.norm(key) + if np.ma.is_masked(normed): + normed = np.nan + value = self.size_range[0] + normed * np.ptp(self.size_range) + return value + + def categorical_mapping(self, data, sizes, order): + + levels = categorical_order(data, order) + + if isinstance(sizes, dict): + + # Dict inputs map existing data values to the size attribute + missing = set(levels) - set(sizes) + if any(missing): + err = f"Missing sizes for the following levels: {missing}" + raise ValueError(err) + lookup_table = sizes.copy() + + elif isinstance(sizes, list): + + # List inputs give size values in the same order as the levels + if len(sizes) != len(levels): + err = "The `sizes` list has the wrong number of values." + raise ValueError(err) + + lookup_table = dict(zip(levels, sizes)) + + else: + + if isinstance(sizes, tuple): + + # Tuple input sets the min, max size values + if len(sizes) != 2: + err = "A `sizes` tuple must have only 2 values" + raise ValueError(err) + + elif sizes is not None: + + err = f"Value for `sizes` not understood: {sizes}" + raise ValueError(err) + + else: + + # Otherwise, we need to get the min, max size values from + # the plotter object we are attached to. + + # TODO this is going to cause us trouble later, because we + # want to restructure things so that the plotter is generic + # across the visual representation of the data. But at this + # point, we don't know the visual representation. Likely we + # want to change the logic of this Mapping so that it gives + # points on a normalized range that then gets un-normalized + # when we know what we're drawing. But given the way the + # package works now, this way is cleanest. + sizes = self.plotter._default_size_range + + # For categorical sizes, use regularly-spaced linear steps + # between the minimum and maximum sizes. Then reverse the + # ramp so that the largest value is used for the first entry + # in size_order, etc. This is because "ordered" categories + # are often though to go in decreasing priority. + sizes = np.linspace(*sizes, len(levels))[::-1] + lookup_table = dict(zip(levels, sizes)) + + return levels, lookup_table + + def numeric_mapping(self, data, sizes, norm): + + if isinstance(sizes, dict): + # The presence of a norm object overrides a dictionary of sizes + # in specifying a numeric mapping, so we need to process it + # dictionary here + levels = list(np.sort(list(sizes))) + size_values = sizes.values() + size_range = min(size_values), max(size_values) + + else: + + # The levels here will be the unique values in the data + levels = list(np.sort(remove_na(data.unique()))) + + if isinstance(sizes, tuple): + + # For numeric inputs, the size can be parametrized by + # the minimum and maximum artist values to map to. The + # norm object that gets set up next specifies how to + # do the mapping. + + if len(sizes) != 2: + err = "A `sizes` tuple must have only 2 values" + raise ValueError(err) + + size_range = sizes + + elif sizes is not None: + + err = f"Value for `sizes` not understood: {sizes}" + raise ValueError(err) + + else: + + # When not provided, we get the size range from the plotter + # object we are attached to. See the note in the categorical + # method about how this is suboptimal for future development. + size_range = self.plotter._default_size_range + + # Now that we know the minimum and maximum sizes that will get drawn, + # we need to map the data values that we have into that range. We will + # use a matplotlib Normalize class, which is typically used for numeric + # color mapping but works fine here too. It takes data values and maps + # them into a [0, 1] interval, potentially nonlinear-ly. + + if norm is None: + # Default is a linear function between the min and max data values + norm = mpl.colors.Normalize() + elif isinstance(norm, tuple): + # It is also possible to give different limits in data space + norm = mpl.colors.Normalize(*norm) + elif not isinstance(norm, mpl.colors.Normalize): + err = f"Value for size `norm` parameter not understood: {norm}" + raise ValueError(err) + else: + # If provided with Normalize object, copy it so we can modify + norm = copy(norm) + + # Set the mapping so all output values are in [0, 1] + norm.clip = True + + # If the input range is not set, use the full range of the data + if not norm.scaled(): + norm(levels) + + # Map from data values to [0, 1] range + sizes_scaled = norm(levels) + + # Now map from the scaled range into the artist units + if isinstance(sizes, dict): + lookup_table = sizes + else: + lo, hi = size_range + sizes = lo + sizes_scaled * (hi - lo) + lookup_table = dict(zip(levels, sizes)) + + return levels, lookup_table, norm, size_range + + +@share_init_params_with_map +class StyleMapping(SemanticMapping): + """Mapping that sets artist style according to data values.""" + + # Style mapping is always treated as categorical + map_type = "categorical" + + def __init__( + self, plotter, markers=None, dashes=None, order=None, + ): + """Map the levels of the `style` variable to distinct values. + + Parameters + ---------- + # TODO add generic parameters + + """ + super().__init__(plotter) + + data = plotter.plot_data.get("style", pd.Series(dtype=float)) + + if data.notna().any(): + + # Cast to list to handle numpy/pandas datetime quirks + if variable_type(data) == "datetime": + data = list(data) + + # Find ordered unique values + levels = categorical_order(data, order) + + markers = self._map_attributes( + markers, levels, unique_markers(len(levels)), "markers", + ) + dashes = self._map_attributes( + dashes, levels, unique_dashes(len(levels)), "dashes", + ) + + # Build the paths matplotlib will use to draw the markers + paths = {} + filled_markers = [] + for k, m in markers.items(): + if not isinstance(m, mpl.markers.MarkerStyle): + m = mpl.markers.MarkerStyle(m) + paths[k] = m.get_path().transformed(m.get_transform()) + filled_markers.append(m.is_filled()) + + # Mixture of filled and unfilled markers will show line art markers + # in the edge color, which defaults to white. This can be handled, + # but there would be additional complexity with specifying the + # weight of the line art markers without overwhelming the filled + # ones with the edges. So for now, we will disallow mixtures. + if any(filled_markers) and not all(filled_markers): + err = "Filled and line art markers cannot be mixed" + raise ValueError(err) + + lookup_table = {} + for key in levels: + lookup_table[key] = {} + if markers: + lookup_table[key]["marker"] = markers[key] + lookup_table[key]["path"] = paths[key] + if dashes: + lookup_table[key]["dashes"] = dashes[key] + + self.levels = levels + self.lookup_table = lookup_table + + def _lookup_single(self, key, attr=None): + """Get attribute(s) for a given data point.""" + if attr is None: + value = self.lookup_table[key] + else: + value = self.lookup_table[key][attr] + return value + + def _map_attributes(self, arg, levels, defaults, attr): + """Handle the specification for a given style attribute.""" + if arg is True: + lookup_table = dict(zip(levels, defaults)) + elif isinstance(arg, dict): + missing = set(levels) - set(arg) + if missing: + err = f"These `{attr}` levels are missing values: {missing}" + raise ValueError(err) + lookup_table = arg + elif isinstance(arg, Sequence): + if len(levels) != len(arg): + err = f"The `{attr}` argument has the wrong number of values" + raise ValueError(err) + lookup_table = dict(zip(levels, arg)) + elif arg: + err = f"This `{attr}` argument was not understood: {arg}" + raise ValueError(err) + else: + lookup_table = {} + + return lookup_table + + +# =========================================================================== # + + +class VectorPlotter: + """Base class for objects underlying *plot functions.""" + + _semantic_mappings = { + "hue": HueMapping, + "size": SizeMapping, + "style": StyleMapping, + } + + # TODO units is another example of a non-mapping "semantic" + # we need a general name for this and separate handling + semantics = "x", "y", "hue", "size", "style", "units" + wide_structure = { + "x": "@index", "y": "@values", "hue": "@columns", "style": "@columns", + } + flat_structure = {"x": "@index", "y": "@values"} + + _default_size_range = 1, 2 # Unused but needed in tests, ugh + + def __init__(self, data=None, variables={}): + + self.assign_variables(data, variables) + + for var, cls in self._semantic_mappings.items(): + + # Create the mapping function + map_func = partial(cls.map, plotter=self) + setattr(self, f"map_{var}", map_func) + + # Call the mapping function to initialize with default values + getattr(self, f"map_{var}")() + + self._var_levels = {} + + @classmethod + def get_semantics(cls, kwargs, semantics=None): + """Subset a dictionary` arguments with known semantic variables.""" + # TODO this should be get_variables since we have included x and y + if semantics is None: + semantics = cls.semantics + variables = {} + for key, val in kwargs.items(): + if key in semantics and val is not None: + variables[key] = val + return variables + + @property + def has_xy_data(self): + """Return True at least one of x or y is defined.""" + return bool({"x", "y"} & set(self.variables)) + + @property + def var_levels(self): + """Property interface to ordered list of variables levels. + + Each time it's accessed, it updates the var_levels dictionary with the + list of levels in the current semantic mappers. But it also allows the + dictionary to persist, so it can be used to set levels by a key. This is + used to track the list of col/row levels using an attached FacetGrid + object, but it's kind of messy and ideally fixed by improving the + faceting logic so it interfaces better with the modern approach to + tracking plot variables. + + """ + for var in self.variables: + try: + map_obj = getattr(self, f"_{var}_map") + self._var_levels[var] = map_obj.levels + except AttributeError: + pass + return self._var_levels + + def assign_variables(self, data=None, variables={}): + """Define plot variables, optionally using lookup from `data`.""" + x = variables.get("x", None) + y = variables.get("y", None) + + if x is None and y is None: + self.input_format = "wide" + plot_data, variables = self._assign_variables_wideform( + data, **variables, + ) + else: + self.input_format = "long" + plot_data, variables = self._assign_variables_longform( + data, **variables, + ) + + self.plot_data = plot_data + self.variables = variables + self.var_types = { + v: variable_type( + plot_data[v], + boolean_type="numeric" if v in "xy" else "categorical" + ) + for v in variables + } + + return self + + def _assign_variables_wideform(self, data=None, **kwargs): + """Define plot variables given wide-form data. + + Parameters + ---------- + data : flat vector or collection of vectors + Data can be a vector or mapping that is coerceable to a Series + or a sequence- or mapping-based collection of such vectors, or a + rectangular numpy array, or a Pandas DataFrame. + kwargs : variable -> data mappings + Behavior with keyword arguments is currently undefined. + + Returns + ------- + plot_data : :class:`pandas.DataFrame` + Long-form data object mapping seaborn variables (x, y, hue, ...) + to data vectors. + variables : dict + Keys are defined seaborn variables; values are names inferred from + the inputs (or None when no name can be determined). + + """ + # Raise if semantic or other variables are assigned in wide-form mode + assigned = [k for k, v in kwargs.items() if v is not None] + if any(assigned): + s = "s" if len(assigned) > 1 else "" + err = f"The following variable{s} cannot be assigned with wide-form data: " + err += ", ".join(f"`{v}`" for v in assigned) + raise ValueError(err) + + # Determine if the data object actually has any data in it + empty = data is None or not len(data) + + # Then, determine if we have "flat" data (a single vector) + if isinstance(data, dict): + values = data.values() + else: + values = np.atleast_1d(np.asarray(data, dtype=object)) + flat = not any( + isinstance(v, Iterable) and not isinstance(v, (str, bytes)) + for v in values + ) + + if empty: + + # Make an object with the structure of plot_data, but empty + plot_data = pd.DataFrame() + variables = {} + + elif flat: + + # Handle flat data by converting to pandas Series and using the + # index and/or values to define x and/or y + # (Could be accomplished with a more general to_series() interface) + flat_data = pd.Series(data).copy() + names = { + "@values": flat_data.name, + "@index": flat_data.index.name + } + + plot_data = {} + variables = {} + + for var in ["x", "y"]: + if var in self.flat_structure: + attr = self.flat_structure[var] + plot_data[var] = getattr(flat_data, attr[1:]) + variables[var] = names[self.flat_structure[var]] + + plot_data = pd.DataFrame(plot_data) + + else: + + # Otherwise assume we have some collection of vectors. + + # Handle Python sequences such that entries end up in the columns, + # not in the rows, of the intermediate wide DataFrame. + # One way to accomplish this is to convert to a dict of Series. + if isinstance(data, Sequence): + data_dict = {} + for i, var in enumerate(data): + key = getattr(var, "name", i) + # TODO is there a safer/more generic way to ensure Series? + # sort of like np.asarray, but for pandas? + data_dict[key] = pd.Series(var) + + data = data_dict + + # Pandas requires that dict values either be Series objects + # or all have the same length, but we want to allow "ragged" inputs + if isinstance(data, Mapping): + data = {key: pd.Series(val) for key, val in data.items()} + + # Otherwise, delegate to the pandas DataFrame constructor + # This is where we'd prefer to use a general interface that says + # "give me this data as a pandas DataFrame", so we can accept + # DataFrame objects from other libraries + wide_data = pd.DataFrame(data, copy=True) + + # At this point we should reduce the dataframe to numeric cols + numeric_cols = wide_data.apply(variable_type) == "numeric" + wide_data = wide_data.loc[:, numeric_cols] + + # Now melt the data to long form + melt_kws = {"var_name": "@columns", "value_name": "@values"} + use_index = "@index" in self.wide_structure.values() + if use_index: + melt_kws["id_vars"] = "@index" + try: + orig_categories = wide_data.columns.categories + orig_ordered = wide_data.columns.ordered + wide_data.columns = wide_data.columns.add_categories("@index") + except AttributeError: + category_columns = False + else: + category_columns = True + wide_data["@index"] = wide_data.index.to_series() + + plot_data = wide_data.melt(**melt_kws) + + if use_index and category_columns: + plot_data["@columns"] = pd.Categorical(plot_data["@columns"], + orig_categories, + orig_ordered) + + # Assign names corresponding to plot semantics + for var, attr in self.wide_structure.items(): + plot_data[var] = plot_data[attr] + + # Define the variable names + variables = {} + for var, attr in self.wide_structure.items(): + obj = getattr(wide_data, attr[1:]) + variables[var] = getattr(obj, "name", None) + + # Remove redundant columns from plot_data + plot_data = plot_data[list(variables)] + + return plot_data, variables + + def _assign_variables_longform(self, data=None, **kwargs): + """Define plot variables given long-form data and/or vector inputs. + + Parameters + ---------- + data : dict-like collection of vectors + Input data where variable names map to vector values. + kwargs : variable -> data mappings + Keys are seaborn variables (x, y, hue, ...) and values are vectors + in any format that can construct a :class:`pandas.DataFrame` or + names of columns or index levels in ``data``. + + Returns + ------- + plot_data : :class:`pandas.DataFrame` + Long-form data object mapping seaborn variables (x, y, hue, ...) + to data vectors. + variables : dict + Keys are defined seaborn variables; values are names inferred from + the inputs (or None when no name can be determined). + + Raises + ------ + ValueError + When variables are strings that don't appear in ``data``. + + """ + plot_data = {} + variables = {} + + # Data is optional; all variables can be defined as vectors + if data is None: + data = {} + + # TODO should we try a data.to_dict() or similar here to more + # generally accept objects with that interface? + # Note that dict(df) also works for pandas, and gives us what we + # want, whereas DataFrame.to_dict() gives a nested dict instead of + # a dict of series. + + # Variables can also be extraced from the index attribute + # TODO is this the most general way to enable it? + # There is no index.to_dict on multiindex, unfortunately + try: + index = data.index.to_frame() + except AttributeError: + index = {} + + # The caller will determine the order of variables in plot_data + for key, val in kwargs.items(): + + # First try to treat the argument as a key for the data collection. + # But be flexible about what can be used as a key. + # Usually it will be a string, but allow numbers or tuples too when + # taking from the main data object. Only allow strings to reference + # fields in the index, because otherwise there is too much ambiguity. + try: + val_as_data_key = ( + val in data + or (isinstance(val, (str, bytes)) and val in index) + ) + except (KeyError, TypeError): + val_as_data_key = False + + if val_as_data_key: + + # We know that __getitem__ will work + + if val in data: + plot_data[key] = data[val] + elif val in index: + plot_data[key] = index[val] + variables[key] = val + + elif isinstance(val, (str, bytes)): + + # This looks like a column name but we don't know what it means! + + err = f"Could not interpret value `{val}` for parameter `{key}`" + raise ValueError(err) + + else: + + # Otherwise, assume the value is itself data + + # Raise when data object is present and a vector can't matched + if isinstance(data, pd.DataFrame) and not isinstance(val, pd.Series): + if np.ndim(val) and len(data) != len(val): + val_cls = val.__class__.__name__ + err = ( + f"Length of {val_cls} vectors must match length of `data`" + f" when both are used, but `data` has length {len(data)}" + f" and the vector passed to `{key}` has length {len(val)}." + ) + raise ValueError(err) + + plot_data[key] = val + + # Try to infer the name of the variable + variables[key] = getattr(val, "name", None) + + # Construct a tidy plot DataFrame. This will convert a number of + # types automatically, aligning on index in case of pandas objects + plot_data = pd.DataFrame(plot_data) + + # Reduce the variables dictionary to fields with valid data + variables = { + var: name + for var, name in variables.items() + if plot_data[var].notnull().any() + } + + return plot_data, variables + + def iter_data( + self, grouping_vars=None, reverse=False, from_comp_data=False, + ): + """Generator for getting subsets of data defined by semantic variables. + + Also injects "col" and "row" into grouping semantics. + + Parameters + ---------- + grouping_vars : string or list of strings + Semantic variables that define the subsets of data. + reverse : bool, optional + If True, reverse the order of iteration. + from_comp_data : bool, optional + If True, use self.comp_data rather than self.plot_data + + Yields + ------ + sub_vars : dict + Keys are semantic names, values are the level of that semantic. + sub_data : :class:`pandas.DataFrame` + Subset of ``plot_data`` for this combination of semantic values. + + """ + # TODO should this default to using all (non x/y?) semantics? + # or define groupping vars somewhere? + if grouping_vars is None: + grouping_vars = [] + elif isinstance(grouping_vars, str): + grouping_vars = [grouping_vars] + elif isinstance(grouping_vars, tuple): + grouping_vars = list(grouping_vars) + + # Always insert faceting variables + facet_vars = {"col", "row"} + grouping_vars.extend( + facet_vars & set(self.variables) - set(grouping_vars) + ) + + # Reduce to the semantics used in this plot + grouping_vars = [ + var for var in grouping_vars if var in self.variables + ] + + if from_comp_data: + data = self.comp_data + else: + data = self.plot_data + + if grouping_vars: + + grouped_data = data.groupby( + grouping_vars, sort=False, as_index=False + ) + + grouping_keys = [] + for var in grouping_vars: + grouping_keys.append(self.var_levels.get(var, [])) + + iter_keys = itertools.product(*grouping_keys) + if reverse: + iter_keys = reversed(list(iter_keys)) + + for key in iter_keys: + + # Pandas fails with singleton tuple inputs + pd_key = key[0] if len(key) == 1 else key + + try: + data_subset = grouped_data.get_group(pd_key) + except KeyError: + continue + + sub_vars = dict(zip(grouping_vars, key)) + + yield sub_vars, data_subset + + else: + + yield {}, data + + @property + def comp_data(self): + """Dataframe with numeric x and y, after unit conversion and log scaling.""" + if not hasattr(self, "ax"): + # Probably a good idea, but will need a bunch of tests updated + # Most of these tests should just use the external interface + # Then this can be re-enabled. + # raise AttributeError("No Axes attached to plotter") + return self.plot_data + + if not hasattr(self, "_comp_data"): + + comp_data = ( + self.plot_data + .copy(deep=False) + .drop(["x", "y"], axis=1, errors="ignore") + ) + for var in "yx": + if var not in self.variables: + continue + + # Get a corresponding axis object so that we can convert the units + # to matplotlib's numeric representation, which we can compute on + # This is messy and it would probably be better for VectorPlotter + # to manage its own converters (using the matplotlib tools). + # XXX Currently does not support unshared categorical axes! + # (But see comment in _attach about how those don't exist) + if self.ax is None: + ax = self.facets.axes.flat[0] + else: + ax = self.ax + axis = getattr(ax, f"{var}axis") + + # Use the converter assigned to the axis to get a float representation + # of the data, passing np.nan or pd.NA through (pd.NA becomes np.nan) + with pd.option_context('mode.use_inf_as_null', True): + orig = self.plot_data[var].dropna() + comp_col = pd.Series(index=orig.index, dtype=float, name=var) + comp_col.loc[orig.index] = pd.to_numeric(axis.convert_units(orig)) + + if axis.get_scale() == "log": + comp_col = np.log10(comp_col) + comp_data.insert(0, var, comp_col) + + self._comp_data = comp_data + + return self._comp_data + + def _get_axes(self, sub_vars): + """Return an Axes object based on existence of row/col variables.""" + row = sub_vars.get("row", None) + col = sub_vars.get("col", None) + if row is not None and col is not None: + return self.facets.axes_dict[(row, col)] + elif row is not None: + return self.facets.axes_dict[row] + elif col is not None: + return self.facets.axes_dict[col] + elif self.ax is None: + return self.facets.ax + else: + return self.ax + + def _attach(self, obj, allowed_types=None, log_scale=None): + """Associate the plotter with an Axes manager and initialize its units. + + Parameters + ---------- + obj : :class:`matplotlib.axes.Axes` or :class:'FacetGrid` + Structural object that we will eventually plot onto. + allowed_types : str or list of str + If provided, raise when either the x or y variable does not have + one of the declared seaborn types. + log_scale : bool, number, or pair of bools or numbers + If not False, set the axes to use log scaling, with the given + base or defaulting to 10. If a tuple, interpreted as separate + arguments for the x and y axes. + + """ + from .axisgrid import FacetGrid + if isinstance(obj, FacetGrid): + self.ax = None + self.facets = obj + ax_list = obj.axes.flatten() + if obj.col_names is not None: + self.var_levels["col"] = obj.col_names + if obj.row_names is not None: + self.var_levels["row"] = obj.row_names + else: + self.ax = obj + self.facets = None + ax_list = [obj] + + if allowed_types is None: + allowed_types = ["numeric", "datetime", "categorical"] + elif isinstance(allowed_types, str): + allowed_types = [allowed_types] + + for var in set("xy").intersection(self.variables): + # Check types of x/y variables + var_type = self.var_types[var] + if var_type not in allowed_types: + err = ( + f"The {var} variable is {var_type}, but one of " + f"{allowed_types} is required" + ) + raise TypeError(err) + + # Register with the matplotlib unit conversion machinery + # Perhaps cleaner to manage our own transform objects? + # XXX Currently this does not allow "unshared" categorical axes + # We could add metadata to a FacetGrid and set units based on that. + # See also comment in comp_data, which only uses a single axes to do + # its mapping, meaning that it won't handle unshared axes well either. + for ax in ax_list: + axis = getattr(ax, f"{var}axis") + seed_data = self.plot_data[var] + if var_type == "categorical": + seed_data = categorical_order(seed_data) + axis.update_units(seed_data) + + # For categorical y, we want the "first" level to be at the top of the axis + if self.var_types.get("y", None) == "categorical": + for ax in ax_list: + try: + ax.yaxis.set_inverted(True) + except AttributeError: # mpl < 3.1 + if not ax.yaxis_inverted(): + ax.invert_yaxis() + + # Possibly log-scale one or both axes + if log_scale is not None: + # Allow single value or x, y tuple + try: + scalex, scaley = log_scale + except TypeError: + scalex = log_scale if "x" in self.variables else False + scaley = log_scale if "y" in self.variables else False + + for axis, scale in zip("xy", (scalex, scaley)): + if scale: + for ax in ax_list: + set_scale = getattr(ax, f"set_{axis}scale") + if scale is True: + set_scale("log") + else: + if LooseVersion(mpl.__version__) >= "3.3": + set_scale("log", base=scale) + else: + set_scale("log", **{f"base{axis}": scale}) + + def _log_scaled(self, axis): + """Return True if specified axis is log scaled on all attached axes.""" + if self.ax is None: + axes_list = self.facets.axes.flatten() + else: + axes_list = [self.ax] + + log_scaled = [] + for ax in axes_list: + data_axis = getattr(ax, f"{axis}axis") + log_scaled.append(data_axis.get_scale() == "log") + + if any(log_scaled) and not all(log_scaled): + raise RuntimeError("Axis scaling is not consistent") + + return any(log_scaled) + + def _add_axis_labels(self, ax, default_x="", default_y=""): + """Add axis labels if not present, set visibility to match ticklabels.""" + # TODO ax could default to None and use attached axes if present + # but what to do about the case of facets? Currently using FacetGrid's + # set_axis_labels method, which doesn't add labels to the interior even + # when the axes are not shared. Maybe that makes sense? + if not ax.get_xlabel(): + x_visible = any(t.get_visible() for t in ax.get_xticklabels()) + ax.set_xlabel(self.variables.get("x", default_x), visible=x_visible) + if not ax.get_ylabel(): + y_visible = any(t.get_visible() for t in ax.get_yticklabels()) + ax.set_ylabel(self.variables.get("y", default_y), visible=y_visible) + + +def variable_type(vector, boolean_type="numeric"): + """ + Determine whether a vector contains numeric, categorical, or datetime data. + + This function differs from the pandas typing API in two ways: + + - Python sequences or object-typed PyData objects are considered numeric if + all of their entries are numeric. + - String or mixed-type data are considered categorical even if not + explicitly represented as a :class:`pandas.api.types.CategoricalDtype`. + + Parameters + ---------- + vector : :func:`pandas.Series`, :func:`numpy.ndarray`, or Python sequence + Input data to test. + boolean_type : 'numeric' or 'categorical' + Type to use for vectors containing only 0s and 1s (and NAs). + + Returns + ------- + var_type : 'numeric', 'categorical', or 'datetime' + Name identifying the type of data in the vector. + """ + # If a categorical dtype is set, infer categorical + if pd.api.types.is_categorical_dtype(vector): + return "categorical" + + # Special-case all-na data, which is always "numeric" + if pd.isna(vector).all(): + return "numeric" + + # Special-case binary/boolean data, allow caller to determine + # This triggers a numpy warning when vector has strings/objects + # https://github.com/numpy/numpy/issues/6784 + # Because we reduce with .all(), we are agnostic about whether the + # comparison returns a scalar or vector, so we will ignore the warning. + # It triggers a separate DeprecationWarning when the vector has datetimes: + # https://github.com/numpy/numpy/issues/13548 + # This is considered a bug by numpy and will likely go away. + with warnings.catch_warnings(): + warnings.simplefilter( + action='ignore', category=(FutureWarning, DeprecationWarning) + ) + if np.isin(vector, [0, 1, np.nan]).all(): + return boolean_type + + # Defer to positive pandas tests + if pd.api.types.is_numeric_dtype(vector): + return "numeric" + + if pd.api.types.is_datetime64_dtype(vector): + return "datetime" + + # --- If we get to here, we need to check the entries + + # Check for a collection where everything is a number + + def all_numeric(x): + for x_i in x: + if not isinstance(x_i, Number): + return False + return True + + if all_numeric(vector): + return "numeric" + + # Check for a collection where everything is a datetime + + def all_datetime(x): + for x_i in x: + if not isinstance(x_i, (datetime, np.datetime64)): + return False + return True + + if all_datetime(vector): + return "datetime" + + # Otherwise, our final fallback is to consider things categorical + + return "categorical" + + +def infer_orient(x=None, y=None, orient=None, require_numeric=True): + """Determine how the plot should be oriented based on the data. + + For historical reasons, the convention is to call a plot "horizontally" + or "vertically" oriented based on the axis representing its dependent + variable. Practically, this is used when determining the axis for + numerical aggregation. + + Parameters + ---------- + x, y : Vector data or None + Positional data vectors for the plot. + orient : string or None + Specified orientation, which must start with "v" or "h" if not None. + require_numeric : bool + If set, raise when the implied dependent variable is not numeric. + + Returns + ------- + orient : "v" or "h" + + Raises + ------ + ValueError: When `orient` is not None and does not start with "h" or "v" + TypeError: When dependant variable is not numeric, with `require_numeric` + + """ + + x_type = None if x is None else variable_type(x) + y_type = None if y is None else variable_type(y) + + nonnumeric_dv_error = "{} orientation requires numeric `{}` variable." + single_var_warning = "{} orientation ignored with only `{}` specified." + + if x is None: + if str(orient).startswith("h"): + warnings.warn(single_var_warning.format("Horizontal", "y")) + if require_numeric and y_type != "numeric": + raise TypeError(nonnumeric_dv_error.format("Vertical", "y")) + return "v" + + elif y is None: + if str(orient).startswith("v"): + warnings.warn(single_var_warning.format("Vertical", "x")) + if require_numeric and x_type != "numeric": + raise TypeError(nonnumeric_dv_error.format("Horizontal", "x")) + return "h" + + elif str(orient).startswith("v"): + if require_numeric and y_type != "numeric": + raise TypeError(nonnumeric_dv_error.format("Vertical", "y")) + return "v" + + elif str(orient).startswith("h"): + if require_numeric and x_type != "numeric": + raise TypeError(nonnumeric_dv_error.format("Horizontal", "x")) + return "h" + + elif orient is not None: + raise ValueError(f"Value for `orient` not understood: {orient}") + + elif x_type != "numeric" and y_type == "numeric": + return "v" + + elif x_type == "numeric" and y_type != "numeric": + return "h" + + elif require_numeric and "numeric" not in (x_type, y_type): + err = "Neither the `x` nor `y` variable appears to be numeric." + raise TypeError(err) + + else: + return "v" + + +def unique_dashes(n): + """Build an arbitrarily long list of unique dash styles for lines. + + Parameters + ---------- + n : int + Number of unique dash specs to generate. + + Returns + ------- + dashes : list of strings or tuples + Valid arguments for the ``dashes`` parameter on + :class:`matplotlib.lines.Line2D`. The first spec is a solid + line (``""``), the remainder are sequences of long and short + dashes. + + """ + # Start with dash specs that are well distinguishable + dashes = [ + "", + (4, 1.5), + (1, 1), + (3, 1.25, 1.5, 1.25), + (5, 1, 1, 1), + ] + + # Now programatically build as many as we need + p = 3 + while len(dashes) < n: + + # Take combinations of long and short dashes + a = itertools.combinations_with_replacement([3, 1.25], p) + b = itertools.combinations_with_replacement([4, 1], p) + + # Interleave the combinations, reversing one of the streams + segment_list = itertools.chain(*zip( + list(a)[1:-1][::-1], + list(b)[1:-1] + )) + + # Now insert the gaps + for segments in segment_list: + gap = min(segments) + spec = tuple(itertools.chain(*((seg, gap) for seg in segments))) + dashes.append(spec) + + p += 1 + + return dashes[:n] + + +def unique_markers(n): + """Build an arbitrarily long list of unique marker styles for points. + + Parameters + ---------- + n : int + Number of unique marker specs to generate. + + Returns + ------- + markers : list of string or tuples + Values for defining :class:`matplotlib.markers.MarkerStyle` objects. + All markers will be filled. + + """ + # Start with marker specs that are well distinguishable + markers = [ + "o", + "X", + (4, 0, 45), + "P", + (4, 0, 0), + (4, 1, 0), + "^", + (4, 1, 45), + "v", + ] + + # Now generate more from regular polygons of increasing order + s = 5 + while len(markers) < n: + a = 360 / (s + 1) / 2 + markers.extend([ + (s + 1, 1, a), + (s + 1, 0, a), + (s, 1, 0), + (s, 0, 0), + ]) + s += 1 + + # Convert to MarkerStyle object, using only exactly what we need + # markers = [mpl.markers.MarkerStyle(m) for m in markers[:n]] + + return markers[:n] + + +def categorical_order(vector, order=None): + """Return a list of unique data values. + + Determine an ordered list of levels in ``values``. + + Parameters + ---------- + vector : list, array, Categorical, or Series + Vector of "categorical" values + order : list-like, optional + Desired order of category levels to override the order determined + from the ``values`` object. + + Returns + ------- + order : list + Ordered list of category levels not including null values. + + """ + if order is None: + if hasattr(vector, "categories"): + order = vector.categories + else: + try: + order = vector.cat.categories + except (TypeError, AttributeError): + + try: + order = vector.unique() + except AttributeError: + order = pd.unique(vector) + + if variable_type(vector) == "numeric": + order = np.sort(order) + + order = filter(pd.notnull, order) + return list(order) diff --git a/grplot_seaborn/_decorators.py b/grplot_seaborn/_decorators.py new file mode 100644 index 0000000..d1c24b8 --- /dev/null +++ b/grplot_seaborn/_decorators.py @@ -0,0 +1,62 @@ +from inspect import signature, Parameter +from functools import wraps +import warnings + + +# This function was adapted from scikit-learn +# github.com/scikit-learn/scikit-learn/blob/master/sklearn/utils/validation.py +def _deprecate_positional_args(f): + """Decorator for methods that issues warnings for positional arguments. + + Using the keyword-only argument syntax in pep 3102, arguments after the + * will issue a warning when passed as a positional argument. + + Parameters + ---------- + f : function + function to check arguments on + + """ + sig = signature(f) + kwonly_args = [] + all_args = [] + + for name, param in sig.parameters.items(): + if param.kind == Parameter.POSITIONAL_OR_KEYWORD: + all_args.append(name) + elif param.kind == Parameter.KEYWORD_ONLY: + kwonly_args.append(name) + + @wraps(f) + def inner_f(*args, **kwargs): + extra_args = len(args) - len(all_args) + if extra_args > 0: + plural = "s" if extra_args > 1 else "" + article = "" if plural else "a " + warnings.warn( + "Pass the following variable{} as {}keyword arg{}: {}. " + "From version 0.12, the only valid positional argument " + "will be `data`, and passing other arguments without an " + "explicit keyword will result in an error or misinterpretation." + .format(plural, article, plural, + ", ".join(kwonly_args[:extra_args])), + FutureWarning + ) + kwargs.update({k: arg for k, arg in zip(sig.parameters, args)}) + return f(**kwargs) + return inner_f + + +def share_init_params_with_map(cls): + """Make cls.map a classmethod with same signature as cls.__init__.""" + map_sig = signature(cls.map) + init_sig = signature(cls.__init__) + + new = [v for k, v in init_sig.parameters.items() if k != "self"] + new.insert(0, map_sig.parameters["cls"]) + cls.map.__signature__ = map_sig.replace(parameters=new) + cls.map.__doc__ = cls.__init__.__doc__ + + cls.map = classmethod(cls.map) + + return cls diff --git a/grplot_seaborn/_docstrings.py b/grplot_seaborn/_docstrings.py new file mode 100644 index 0000000..2ab210b --- /dev/null +++ b/grplot_seaborn/_docstrings.py @@ -0,0 +1,198 @@ +import re +import pydoc +from .external.docscrape import NumpyDocString + + +class DocstringComponents: + + regexp = re.compile(r"\n((\n|.)+)\n\s*", re.MULTILINE) + + def __init__(self, comp_dict, strip_whitespace=True): + """Read entries from a dict, optionally stripping outer whitespace.""" + if strip_whitespace: + entries = {} + for key, val in comp_dict.items(): + m = re.match(self.regexp, val) + if m is None: + entries[key] = val + else: + entries[key] = m.group(1) + else: + entries = comp_dict.copy() + + self.entries = entries + + def __getattr__(self, attr): + """Provide dot access to entries for clean raw docstrings.""" + if attr in self.entries: + return self.entries[attr] + else: + try: + return self.__getattribute__(attr) + except AttributeError as err: + # If Python is run with -OO, it will strip docstrings and our lookup + # from self.entries will fail. We check for __debug__, which is actually + # set to False by -O (it is True for normal execution). + # But we only want to see an error when building the docs; + # not something users should see, so this slight inconsistency is fine. + if __debug__: + raise err + else: + pass + + @classmethod + def from_nested_components(cls, **kwargs): + """Add multiple sub-sets of components.""" + return cls(kwargs, strip_whitespace=False) + + @classmethod + def from_function_params(cls, func): + """Use the numpydoc parser to extract components from existing func.""" + params = NumpyDocString(pydoc.getdoc(func))["Parameters"] + comp_dict = {} + for p in params: + name = p.name + type = p.type + desc = "\n ".join(p.desc) + comp_dict[name] = f"{name} : {type}\n {desc}" + + return cls(comp_dict) + + +# TODO is "vector" the best term here? We mean to imply 1D data with a variety +# of types? + +# TODO now that we can parse numpydoc style strings, do we need to define dicts +# of docstring components, or just write out a docstring? + + +_core_params = dict( + data=""" +data : :class:`pandas.DataFrame`, :class:`numpy.ndarray`, mapping, or sequence + Input data structure. Either a long-form collection of vectors that can be + assigned to named variables or a wide-form dataset that will be internally + reshaped. + """, # TODO add link to user guide narrative when exists + xy=""" +x, y : vectors or keys in ``data`` + Variables that specify positions on the x and y axes. + """, + hue=""" +hue : vector or key in ``data`` + Semantic variable that is mapped to determine the color of plot elements. + """, + palette=""" +palette : string, list, dict, or :class:`matplotlib.colors.Colormap` + Method for choosing the colors to use when mapping the ``hue`` semantic. + String values are passed to :func:`color_palette`. List or dict values + imply categorical mapping, while a colormap object implies numeric mapping. + """, # noqa: E501 + hue_order=""" +hue_order : vector of strings + Specify the order of processing and plotting for categorical levels of the + ``hue`` semantic. + """, + hue_norm=""" +hue_norm : tuple or :class:`matplotlib.colors.Normalize` + Either a pair of values that set the normalization range in data units + or an object that will map from data units into a [0, 1] interval. Usage + implies numeric mapping. + """, + color=""" +color : :mod:`matplotlib color ` + Single color specification for when hue mapping is not used. Otherwise, the + plot will try to hook into the matplotlib property cycle. + """, + ax=""" +ax : :class:`matplotlib.axes.Axes` + Pre-existing axes for the plot. Otherwise, call :func:`matplotlib.pyplot.gca` + internally. + """, # noqa: E501 +) + + +_core_returns = dict( + ax=""" +:class:`matplotlib.axes.Axes` + The matplotlib axes containing the plot. + """, + facetgrid=""" +:class:`FacetGrid` + An object managing one or more subplots that correspond to conditional data + subsets with convenient methods for batch-setting of axes attributes. + """, + jointgrid=""" +:class:`JointGrid` + An object managing multiple subplots that correspond to joint and marginal axes + for plotting a bivariate relationship or distribution. + """, + pairgrid=""" +:class:`PairGrid` + An object managing multiple subplots that correspond to joint and marginal axes + for pairwise combinations of multiple variables in a dataset. + """, +) + + +_seealso_blurbs = dict( + + # Relational plots + scatterplot=""" +scatterplot : Plot data using points. + """, + lineplot=""" +lineplot : Plot data using lines. + """, + + # Distribution plots + displot=""" +displot : Figure-level interface to distribution plot functions. + """, + histplot=""" +histplot : Plot a histogram of binned counts with optional normalization or smoothing. + """, + kdeplot=""" +kdeplot : Plot univariate or bivariate distributions using kernel density estimation. + """, + ecdfplot=""" +ecdfplot : Plot empirical cumulative distribution functions. + """, + rugplot=""" +rugplot : Plot a tick at each observation value along the x and/or y axes. + """, + + # Categorical plots + stripplot=""" +stripplot : Plot a categorical scatter with jitter. + """, + swarmplot=""" +swarmplot : Plot a categorical scatter with non-overlapping points. + """, + violinplot=""" +violinplot : Draw an enhanced boxplot using kernel density estimation. + """, + pointplot=""" +pointplot : Plot point estimates and CIs using markers and lines. + """, + + # Multiples + jointplot=""" +jointplot : Draw a bivariate plot with univariate marginal distributions. + """, + pairplot=""" +jointplot : Draw multiple bivariate plots with univariate marginal distributions. + """, + jointgrid=""" +JointGrid : Set up a figure with joint and marginal views on bivariate data. + """, + pairgrid=""" +PairGrid : Set up a figure with joint and marginal views on multiple variables. + """, +) + + +_core_docs = dict( + params=DocstringComponents(_core_params), + returns=DocstringComponents(_core_returns), + seealso=DocstringComponents(_seealso_blurbs), +) diff --git a/grplot_seaborn/_statistics.py b/grplot_seaborn/_statistics.py new file mode 100644 index 0000000..a0acd36 --- /dev/null +++ b/grplot_seaborn/_statistics.py @@ -0,0 +1,441 @@ +"""Statistical transformations for visualization. + +This module is currently private, but is being written to eventually form part +of the public API. + +The classes should behave roughly in the style of scikit-learn. + +- All data-independent parameters should be passed to the class constructor. +- Each class should impelment a default transformation that is exposed through + __call__. These are currently written for vector arguements, but I think + consuming a whole `plot_data` DataFrame and return it with transformed + variables would make more sense. +- Some class have data-dependent preprocessing that should be cached and used + multiple times (think defining histogram bins off all data and then counting + observations within each bin multiple times per data subsets). These currently + have unique names, but it would be good to have a common name. Not quite + `fit`, but something similar. +- Alternatively, the transform interface could take some information about grouping + variables and do a groupby internally. +- Some classes should define alternate transforms that might make the most sense + with a different function. For example, KDE usually evaluates the distribution + on a regular grid, but it would be useful for it to transform at the actual + datapoints. Then again, this could be controlled by a parameter at the time of + class instantiation. + +""" +from distutils.version import LooseVersion +from numbers import Number +import numpy as np +import scipy as sp +from scipy import stats + +from .utils import _check_argument + + +class KDE: + """Univariate and bivariate kernel density estimator.""" + def __init__( + self, *, + bw_method=None, + bw_adjust=1, + gridsize=200, + cut=3, + clip=None, + cumulative=False, + ): + """Initialize the estimator with its parameters. + + Parameters + ---------- + bw_method : string, scalar, or callable, optional + Method for determining the smoothing bandwidth to use; passed to + :class:`scipy.stats.gaussian_kde`. + bw_adjust : number, optional + Factor that multiplicatively scales the value chosen using + ``bw_method``. Increasing will make the curve smoother. See Notes. + gridsize : int, optional + Number of points on each dimension of the evaluation grid. + cut : number, optional + Factor, multiplied by the smoothing bandwidth, that determines how + far the evaluation grid extends past the extreme datapoints. When + set to 0, truncate the curve at the data limits. + clip : pair of numbers or None, or a pair of such pairs + Do not evaluate the density outside of these limits. + cumulative : bool, optional + If True, estimate a cumulative distribution function. + + """ + if clip is None: + clip = None, None + + self.bw_method = bw_method + self.bw_adjust = bw_adjust + self.gridsize = gridsize + self.cut = cut + self.clip = clip + self.cumulative = cumulative + + self.support = None + + def _define_support_grid(self, x, bw, cut, clip, gridsize): + """Create the grid of evaluation points depending for vector x.""" + clip_lo = -np.inf if clip[0] is None else clip[0] + clip_hi = +np.inf if clip[1] is None else clip[1] + gridmin = max(x.min() - bw * cut, clip_lo) + gridmax = min(x.max() + bw * cut, clip_hi) + return np.linspace(gridmin, gridmax, gridsize) + + def _define_support_univariate(self, x, weights): + """Create a 1D grid of evaluation points.""" + kde = self._fit(x, weights) + bw = np.sqrt(kde.covariance.squeeze()) + grid = self._define_support_grid( + x, bw, self.cut, self.clip, self.gridsize + ) + return grid + + def _define_support_bivariate(self, x1, x2, weights): + """Create a 2D grid of evaluation points.""" + clip = self.clip + if clip[0] is None or np.isscalar(clip[0]): + clip = (clip, clip) + + kde = self._fit([x1, x2], weights) + bw = np.sqrt(np.diag(kde.covariance).squeeze()) + + grid1 = self._define_support_grid( + x1, bw[0], self.cut, clip[0], self.gridsize + ) + grid2 = self._define_support_grid( + x2, bw[1], self.cut, clip[1], self.gridsize + ) + + return grid1, grid2 + + def define_support(self, x1, x2=None, weights=None, cache=True): + """Create the evaluation grid for a given data set.""" + if x2 is None: + support = self._define_support_univariate(x1, weights) + else: + support = self._define_support_bivariate(x1, x2, weights) + + if cache: + self.support = support + + return support + + def _fit(self, fit_data, weights=None): + """Fit the scipy kde while adding bw_adjust logic and version check.""" + fit_kws = {"bw_method": self.bw_method} + if weights is not None: + if LooseVersion(sp.__version__) < "1.2.0": + msg = "Weighted KDE requires scipy >= 1.2.0" + raise RuntimeError(msg) + fit_kws["weights"] = weights + + kde = stats.gaussian_kde(fit_data, **fit_kws) + kde.set_bandwidth(kde.factor * self.bw_adjust) + + return kde + + def _eval_univariate(self, x, weights=None): + """Fit and evaluate a univariate on univariate data.""" + support = self.support + if support is None: + support = self.define_support(x, cache=False) + + kde = self._fit(x, weights) + + if self.cumulative: + s_0 = support[0] + density = np.array([ + kde.integrate_box_1d(s_0, s_i) for s_i in support + ]) + else: + density = kde(support) + + return density, support + + def _eval_bivariate(self, x1, x2, weights=None): + """Fit and evaluate a univariate on bivariate data.""" + support = self.support + if support is None: + support = self.define_support(x1, x2, cache=False) + + kde = self._fit([x1, x2], weights) + + if self.cumulative: + + grid1, grid2 = support + density = np.zeros((grid1.size, grid2.size)) + p0 = grid1.min(), grid2.min() + for i, xi in enumerate(grid1): + for j, xj in enumerate(grid2): + density[i, j] = kde.integrate_box(p0, (xi, xj)) + + else: + + xx1, xx2 = np.meshgrid(*support) + density = kde([xx1.ravel(), xx2.ravel()]).reshape(xx1.shape) + + return density, support + + def __call__(self, x1, x2=None, weights=None): + """Fit and evaluate on univariate or bivariate data.""" + if x2 is None: + return self._eval_univariate(x1, weights) + else: + return self._eval_bivariate(x1, x2, weights) + + +class Histogram: + """Univariate and bivariate histogram estimator.""" + def __init__( + self, + stat="count", + bins="auto", + binwidth=None, + binrange=None, + discrete=False, + cumulative=False, + ): + """Initialize the estimator with its parameters. + + Parameters + ---------- + stat : str + Aggregate statistic to compute in each bin. + + - `count`: show the number of observations in each bin + - `frequency`: show the number of observations divided by the bin width + - `probability`: or `proportion`: normalize such that bar heights sum to 1 + - `percent`: normalize such that bar heights sum to 100 + - `density`: normalize such that the total area of the histogram equals 1 + + bins : str, number, vector, or a pair of such values + Generic bin parameter that can be the name of a reference rule, + the number of bins, or the breaks of the bins. + Passed to :func:`numpy.histogram_bin_edges`. + binwidth : number or pair of numbers + Width of each bin, overrides ``bins`` but can be used with + ``binrange``. + binrange : pair of numbers or a pair of pairs + Lowest and highest value for bin edges; can be used either + with ``bins`` or ``binwidth``. Defaults to data extremes. + discrete : bool or pair of bools + If True, set ``binwidth`` and ``binrange`` such that bin + edges cover integer values in the dataset. + cumulative : bool + If True, return the cumulative statistic. + + """ + stat_choices = [ + "count", "frequency", "density", "probability", "proportion", "percent", + ] + _check_argument("stat", stat_choices, stat) + + self.stat = stat + self.bins = bins + self.binwidth = binwidth + self.binrange = binrange + self.discrete = discrete + self.cumulative = cumulative + + self.bin_kws = None + + def _define_bin_edges(self, x, weights, bins, binwidth, binrange, discrete): + """Inner function that takes bin parameters as arguments.""" + if binrange is None: + start, stop = x.min(), x.max() + else: + start, stop = binrange + + if discrete: + bin_edges = np.arange(start - .5, stop + 1.5) + elif binwidth is not None: + step = binwidth + bin_edges = np.arange(start, stop + step, step) + else: + bin_edges = np.histogram_bin_edges( + x, bins, binrange, weights, + ) + return bin_edges + + def define_bin_params(self, x1, x2=None, weights=None, cache=True): + """Given data, return numpy.histogram parameters to define bins.""" + if x2 is None: + + bin_edges = self._define_bin_edges( + x1, weights, self.bins, self.binwidth, self.binrange, self.discrete, + ) + + if isinstance(self.bins, (str, Number)): + n_bins = len(bin_edges) - 1 + bin_range = bin_edges.min(), bin_edges.max() + bin_kws = dict(bins=n_bins, range=bin_range) + else: + bin_kws = dict(bins=bin_edges) + + else: + + bin_edges = [] + for i, x in enumerate([x1, x2]): + + # Resolve out whether bin parameters are shared + # or specific to each variable + + bins = self.bins + if not bins or isinstance(bins, (str, Number)): + pass + elif isinstance(bins[i], str): + bins = bins[i] + elif len(bins) == 2: + bins = bins[i] + + binwidth = self.binwidth + if binwidth is None: + pass + elif not isinstance(binwidth, Number): + binwidth = binwidth[i] + + binrange = self.binrange + if binrange is None: + pass + elif not isinstance(binrange[0], Number): + binrange = binrange[i] + + discrete = self.discrete + if not isinstance(discrete, bool): + discrete = discrete[i] + + # Define the bins for this variable + + bin_edges.append(self._define_bin_edges( + x, weights, bins, binwidth, binrange, discrete, + )) + + bin_kws = dict(bins=tuple(bin_edges)) + + if cache: + self.bin_kws = bin_kws + + return bin_kws + + def _eval_bivariate(self, x1, x2, weights): + """Inner function for histogram of two variables.""" + bin_kws = self.bin_kws + if bin_kws is None: + bin_kws = self.define_bin_params(x1, x2, cache=False) + + density = self.stat == "density" + + hist, *bin_edges = np.histogram2d( + x1, x2, **bin_kws, weights=weights, density=density + ) + + area = np.outer( + np.diff(bin_edges[0]), + np.diff(bin_edges[1]), + ) + + if self.stat == "probability" or self.stat == "proportion": + hist = hist.astype(float) / hist.sum() + elif self.stat == "percent": + hist = hist.astype(float) / hist.sum() * 100 + elif self.stat == "frequency": + hist = hist.astype(float) / area + + if self.cumulative: + if self.stat in ["density", "frequency"]: + hist = (hist * area).cumsum(axis=0).cumsum(axis=1) + else: + hist = hist.cumsum(axis=0).cumsum(axis=1) + + return hist, bin_edges + + def _eval_univariate(self, x, weights): + """Inner function for histogram of one variable.""" + bin_kws = self.bin_kws + if bin_kws is None: + bin_kws = self.define_bin_params(x, weights=weights, cache=False) + + density = self.stat == "density" + hist, bin_edges = np.histogram( + x, **bin_kws, weights=weights, density=density, + ) + + if self.stat == "probability" or self.stat == "proportion": + hist = hist.astype(float) / hist.sum() + elif self.stat == "percent": + hist = hist.astype(float) / hist.sum() * 100 + elif self.stat == "frequency": + hist = hist.astype(float) / np.diff(bin_edges) + + if self.cumulative: + if self.stat in ["density", "frequency"]: + hist = (hist * np.diff(bin_edges)).cumsum() + else: + hist = hist.cumsum() + + return hist, bin_edges + + def __call__(self, x1, x2=None, weights=None): + """Count the occurrences in each bin, maybe normalize.""" + if x2 is None: + return self._eval_univariate(x1, weights) + else: + return self._eval_bivariate(x1, x2, weights) + + +class ECDF: + """Univariate empirical cumulative distribution estimator.""" + def __init__(self, stat="proportion", complementary=False): + """Initialize the class with its paramters + + Parameters + ---------- + stat : {{"proportion", "count"}} + Distribution statistic to compute. + complementary : bool + If True, use the complementary CDF (1 - CDF) + + """ + _check_argument("stat", ["count", "proportion"], stat) + self.stat = stat + self.complementary = complementary + + def _eval_bivariate(self, x1, x2, weights): + """Inner function for ECDF of two variables.""" + raise NotImplementedError("Bivariate ECDF is not implemented") + + def _eval_univariate(self, x, weights): + """Inner function for ECDF of one variable.""" + sorter = x.argsort() + x = x[sorter] + weights = weights[sorter] + y = weights.cumsum() + + if self.stat == "proportion": + y = y / y.max() + + x = np.r_[-np.inf, x] + y = np.r_[0, y] + + if self.complementary: + y = y.max() - y + + return y, x + + def __call__(self, x1, x2=None, weights=None): + """Return proportion or count of observations below each sorted datapoint.""" + x1 = np.asarray(x1) + if weights is None: + weights = np.ones_like(x1) + else: + weights = np.asarray(weights) + + if x2 is None: + return self._eval_univariate(x1, weights) + else: + return self._eval_bivariate(x1, x2, weights) diff --git a/grplot_seaborn/_testing.py b/grplot_seaborn/_testing.py new file mode 100644 index 0000000..20b11eb --- /dev/null +++ b/grplot_seaborn/_testing.py @@ -0,0 +1,108 @@ +import numpy as np +import matplotlib as mpl +from matplotlib.colors import to_rgb, to_rgba +from numpy.testing import assert_array_equal + + +LINE_PROPS = [ + "alpha", + "color", + "linewidth", + "linestyle", + "xydata", + "zorder", +] + +COLLECTION_PROPS = [ + "alpha", + "edgecolor", + "facecolor", + "fill", + "hatch", + "linestyle", + "linewidth", + "paths", + "zorder", +] + +BAR_PROPS = [ + "alpha", + "edgecolor", + "facecolor", + "fill", + "hatch", + "height", + "linestyle", + "linewidth", + "xy", + "zorder", +] + + +def assert_colors_equal(a, b, check_alpha=True): + + def handle_array(x): + + if isinstance(x, np.ndarray): + if x.ndim > 1: + x = np.unique(x, axis=0).squeeze() + if x.ndim > 1: + raise ValueError("Color arrays must be 1 dimensional") + return x + + a = handle_array(a) + b = handle_array(b) + + f = to_rgba if check_alpha else to_rgb + assert f(a) == f(b) + + +def assert_artists_equal(list1, list2, properties): + + assert len(list1) == len(list2) + for a1, a2 in zip(list1, list2): + prop1 = a1.properties() + prop2 = a2.properties() + for key in properties: + v1 = prop1[key] + v2 = prop2[key] + if key == "paths": + for p1, p2 in zip(v1, v2): + assert_array_equal(p1.vertices, p2.vertices) + assert_array_equal(p1.codes, p2.codes) + elif isinstance(v1, np.ndarray): + assert_array_equal(v1, v2) + elif key == "color": + v1 = mpl.colors.to_rgba(v1) + v2 = mpl.colors.to_rgba(v2) + assert v1 == v2 + else: + assert v1 == v2 + + +def assert_legends_equal(leg1, leg2): + + assert leg1.get_title().get_text() == leg2.get_title().get_text() + for t1, t2 in zip(leg1.get_texts(), leg2.get_texts()): + assert t1.get_text() == t2.get_text() + + assert_artists_equal( + leg1.get_patches(), leg2.get_patches(), BAR_PROPS, + ) + assert_artists_equal( + leg1.get_lines(), leg2.get_lines(), LINE_PROPS, + ) + + +def assert_plots_equal(ax1, ax2, labels=True): + + assert_artists_equal(ax1.patches, ax2.patches, BAR_PROPS) + assert_artists_equal(ax1.lines, ax2.lines, LINE_PROPS) + + poly1 = ax1.findobj(mpl.collections.PolyCollection) + poly2 = ax2.findobj(mpl.collections.PolyCollection) + assert_artists_equal(poly1, poly2, COLLECTION_PROPS) + + if labels: + assert ax1.get_xlabel() == ax2.get_xlabel() + assert ax1.get_ylabel() == ax2.get_ylabel() diff --git a/grplot_seaborn/algorithms.py b/grplot_seaborn/algorithms.py new file mode 100644 index 0000000..06a1e71 --- /dev/null +++ b/grplot_seaborn/algorithms.py @@ -0,0 +1,129 @@ +"""Algorithms to support fitting routines in seaborn plotting functions.""" +import numbers +import numpy as np +import warnings + + +def bootstrap(*args, **kwargs): + """Resample one or more arrays with replacement and store aggregate values. + + Positional arguments are a sequence of arrays to bootstrap along the first + axis and pass to a summary function. + + Keyword arguments: + n_boot : int, default 10000 + Number of iterations + axis : int, default None + Will pass axis to ``func`` as a keyword argument. + units : array, default None + Array of sampling unit IDs. When used the bootstrap resamples units + and then observations within units instead of individual + datapoints. + func : string or callable, default np.mean + Function to call on the args that are passed in. If string, tries + to use as named method on numpy array. + seed : Generator | SeedSequence | RandomState | int | None + Seed for the random number generator; useful if you want + reproducible resamples. + + Returns + ------- + boot_dist: array + array of bootstrapped statistic values + + """ + # Ensure list of arrays are same length + if len(np.unique(list(map(len, args)))) > 1: + raise ValueError("All input arrays must have the same length") + n = len(args[0]) + + # Default keyword arguments + n_boot = kwargs.get("n_boot", 10000) + func = kwargs.get("func", np.mean) + axis = kwargs.get("axis", None) + units = kwargs.get("units", None) + random_seed = kwargs.get("random_seed", None) + if random_seed is not None: + msg = "`random_seed` has been renamed to `seed` and will be removed" + warnings.warn(msg) + seed = kwargs.get("seed", random_seed) + if axis is None: + func_kwargs = dict() + else: + func_kwargs = dict(axis=axis) + + # Initialize the resampler + rng = _handle_random_seed(seed) + + # Coerce to arrays + args = list(map(np.asarray, args)) + if units is not None: + units = np.asarray(units) + + # Allow for a function that is the name of a method on an array + if isinstance(func, str): + def f(x): + return getattr(x, func)() + else: + f = func + + # Handle numpy changes + try: + integers = rng.integers + except AttributeError: + integers = rng.randint + + # Do the bootstrap + if units is not None: + return _structured_bootstrap(args, n_boot, units, f, + func_kwargs, integers) + + boot_dist = [] + for i in range(int(n_boot)): + resampler = integers(0, n, n, dtype=np.intp) # intp is indexing dtype + sample = [a.take(resampler, axis=0) for a in args] + boot_dist.append(f(*sample, **func_kwargs)) + return np.array(boot_dist) + + +def _structured_bootstrap(args, n_boot, units, func, func_kwargs, integers): + """Resample units instead of datapoints.""" + unique_units = np.unique(units) + n_units = len(unique_units) + + args = [[a[units == unit] for unit in unique_units] for a in args] + + boot_dist = [] + for i in range(int(n_boot)): + resampler = integers(0, n_units, n_units, dtype=np.intp) + sample = [[a[i] for i in resampler] for a in args] + lengths = map(len, sample[0]) + resampler = [integers(0, n, n, dtype=np.intp) for n in lengths] + sample = [[c.take(r, axis=0) for c, r in zip(a, resampler)] for a in sample] + sample = list(map(np.concatenate, sample)) + boot_dist.append(func(*sample, **func_kwargs)) + return np.array(boot_dist) + + +def _handle_random_seed(seed=None): + """Given a seed in one of many formats, return a random number generator. + + Generalizes across the numpy 1.17 changes, preferring newer functionality. + + """ + if isinstance(seed, np.random.RandomState): + rng = seed + else: + try: + # General interface for seeding on numpy >= 1.17 + rng = np.random.default_rng(seed) + except AttributeError: + # We are on numpy < 1.17, handle options ourselves + if isinstance(seed, (numbers.Integral, np.integer)): + rng = np.random.RandomState(seed) + elif seed is None: + rng = np.random.RandomState() + else: + err = "{} cannot be used to seed the randomn number generator" + raise ValueError(err.format(seed)) + return rng diff --git a/grplot_seaborn/apionly.py b/grplot_seaborn/apionly.py new file mode 100644 index 0000000..aa35069 --- /dev/null +++ b/grplot_seaborn/apionly.py @@ -0,0 +1,9 @@ +import warnings +from grplot_seaborn import * # noqa +reset_orig() # noqa + +msg = ( + "As seaborn no longer sets a default style on import, the grplot_seaborn.apionly " + "module is deprecated. It will be removed in a future version." +) +warnings.warn(msg, UserWarning) diff --git a/grplot_seaborn/axisgrid.py b/grplot_seaborn/axisgrid.py new file mode 100644 index 0000000..cc9e929 --- /dev/null +++ b/grplot_seaborn/axisgrid.py @@ -0,0 +1,2386 @@ +from itertools import product +from inspect import signature +import warnings +from textwrap import dedent +from distutils.version import LooseVersion + +import numpy as np +import pandas as pd +import matplotlib as mpl +import matplotlib.pyplot as plt + +from ._core import VectorPlotter, variable_type, categorical_order +from . import utils +from .utils import _check_argument, adjust_legend_subtitles, _draw_figure +from .palettes import color_palette, blend_palette +from ._decorators import _deprecate_positional_args +from ._docstrings import ( + DocstringComponents, + _core_docs, +) + + +__all__ = ["FacetGrid", "PairGrid", "JointGrid", "pairplot", "jointplot"] + + +_param_docs = DocstringComponents.from_nested_components( + core=_core_docs["params"], +) + + +class _BaseGrid: + """Base class for grids of subplots.""" + + def set(self, **kwargs): + """Set attributes on each subplot Axes.""" + for ax in self.axes.flat: + if ax is not None: # Handle removed axes + ax.set(**kwargs) + return self + + @property + def fig(self): + """DEPRECATED: prefer the `figure` property.""" + # Grid.figure is preferred because it matches the Axes attribute name. + # But as the maintanace burden on having this property is minimal, + # let's be slow about formally deprecating it. For now just note its deprecation + # in the docstring; add a warning in version 0.13, and eventually remove it. + return self._figure + + @property + def figure(self): + """Access the :class:`matplotlib.figure.Figure` object underlying the grid.""" + return self._figure + + def savefig(self, *args, **kwargs): + """ + Save an image of the plot. + + This wraps :meth:`matplotlib.figure.Figure.savefig`, using bbox_inches="tight" + by default. Parameters are passed through to the matplotlib function. + + """ + kwargs = kwargs.copy() + kwargs.setdefault("bbox_inches", "tight") + self.figure.savefig(*args, **kwargs) + + +class Grid(_BaseGrid): + """A grid that can have multiple subplots and an external legend.""" + _margin_titles = False + _legend_out = True + + def __init__(self): + + self._tight_layout_rect = [0, 0, 1, 1] + self._tight_layout_pad = None + + # This attribute is set externally and is a hack to handle newer functions that + # don't add proxy artists onto the Axes. We need an overall cleaner approach. + self._extract_legend_handles = False + + def tight_layout(self, *args, **kwargs): + """Call fig.tight_layout within rect that exclude the legend.""" + kwargs = kwargs.copy() + kwargs.setdefault("rect", self._tight_layout_rect) + if self._tight_layout_pad is not None: + kwargs.setdefault("pad", self._tight_layout_pad) + self._figure.tight_layout(*args, **kwargs) + + def add_legend(self, legend_data=None, title=None, label_order=None, + adjust_subtitles=False, **kwargs): + """Draw a legend, maybe placing it outside axes and resizing the figure. + + Parameters + ---------- + legend_data : dict + Dictionary mapping label names (or two-element tuples where the + second element is a label name) to matplotlib artist handles. The + default reads from ``self._legend_data``. + title : string + Title for the legend. The default reads from ``self._hue_var``. + label_order : list of labels + The order that the legend entries should appear in. The default + reads from ``self.hue_names``. + adjust_subtitles : bool + If True, modify entries with invisible artists to left-align + the labels and set the font size to that of a title. + kwargs : key, value pairings + Other keyword arguments are passed to the underlying legend methods + on the Figure or Axes object. + + Returns + ------- + self : Grid instance + Returns self for easy chaining. + + """ + # Find the data for the legend + if legend_data is None: + legend_data = self._legend_data + if label_order is None: + if self.hue_names is None: + label_order = list(legend_data.keys()) + else: + label_order = list(map(utils.to_utf8, self.hue_names)) + + blank_handle = mpl.patches.Patch(alpha=0, linewidth=0) + handles = [legend_data.get(l, blank_handle) for l in label_order] + title = self._hue_var if title is None else title + if LooseVersion(mpl.__version__) < LooseVersion("3.0"): + try: + title_size = mpl.rcParams["axes.labelsize"] * .85 + except TypeError: # labelsize is something like "large" + title_size = mpl.rcParams["axes.labelsize"] + else: + title_size = mpl.rcParams["legend.title_fontsize"] + + # Unpack nested labels from a hierarchical legend + labels = [] + for entry in label_order: + if isinstance(entry, tuple): + _, label = entry + else: + label = entry + labels.append(label) + + # Set default legend kwargs + kwargs.setdefault("scatterpoints", 1) + + if self._legend_out: + + kwargs.setdefault("frameon", False) + kwargs.setdefault("loc", "center right") + + # Draw a full-figure legend outside the grid + figlegend = self._figure.legend(handles, labels, **kwargs) + + self._legend = figlegend + figlegend.set_title(title, prop={"size": title_size}) + + if adjust_subtitles: + adjust_legend_subtitles(figlegend) + + # Draw the plot to set the bounding boxes correctly + _draw_figure(self._figure) + + # Calculate and set the new width of the figure so the legend fits + legend_width = figlegend.get_window_extent().width / self._figure.dpi + fig_width, fig_height = self._figure.get_size_inches() + self._figure.set_size_inches(fig_width + legend_width, fig_height) + + # Draw the plot again to get the new transformations + _draw_figure(self._figure) + + # Now calculate how much space we need on the right side + legend_width = figlegend.get_window_extent().width / self._figure.dpi + space_needed = legend_width / (fig_width + legend_width) + margin = .04 if self._margin_titles else .01 + self._space_needed = margin + space_needed + right = 1 - self._space_needed + + # Place the subplot axes to give space for the legend + self._figure.subplots_adjust(right=right) + self._tight_layout_rect[2] = right + + else: + # Draw a legend in the first axis + ax = self.axes.flat[0] + kwargs.setdefault("loc", "best") + + leg = ax.legend(handles, labels, **kwargs) + leg.set_title(title, prop={"size": title_size}) + self._legend = leg + + if adjust_subtitles: + adjust_legend_subtitles(leg) + + return self + + def _update_legend_data(self, ax): + """Extract the legend data from an axes object and save it.""" + data = {} + + # Get data directly from the legend, which is necessary + # for newer functions that don't add labeled proxy artists + if ax.legend_ is not None and self._extract_legend_handles: + handles = ax.legend_.legendHandles + labels = [t.get_text() for t in ax.legend_.texts] + data.update({l: h for h, l in zip(handles, labels)}) + + handles, labels = ax.get_legend_handles_labels() + data.update({l: h for h, l in zip(handles, labels)}) + + self._legend_data.update(data) + + # Now clear the legend + ax.legend_ = None + + def _get_palette(self, data, hue, hue_order, palette): + """Get a list of colors for the hue variable.""" + if hue is None: + palette = color_palette(n_colors=1) + + else: + hue_names = categorical_order(data[hue], hue_order) + n_colors = len(hue_names) + + # By default use either the current color palette or HUSL + if palette is None: + current_palette = utils.get_color_cycle() + if n_colors > len(current_palette): + colors = color_palette("husl", n_colors) + else: + colors = color_palette(n_colors=n_colors) + + # Allow for palette to map from hue variable names + elif isinstance(palette, dict): + color_names = [palette[h] for h in hue_names] + colors = color_palette(color_names, n_colors) + + # Otherwise act as if we just got a list of colors + else: + colors = color_palette(palette, n_colors) + + palette = color_palette(colors, n_colors) + + return palette + + @property + def legend(self): + """The :class:`matplotlib.legend.Legend` object, if present.""" + try: + return self._legend + except AttributeError: + return None + + +_facet_docs = dict( + + data=dedent("""\ + data : DataFrame + Tidy ("long-form") dataframe where each column is a variable and each + row is an observation.\ + """), + rowcol=dedent("""\ + row, col : vectors or keys in ``data`` + Variables that define subsets to plot on different facets.\ + """), + rowcol_order=dedent("""\ + {row,col}_order : vector of strings + Specify the order in which levels of the ``row`` and/or ``col`` variables + appear in the grid of subplots.\ + """), + col_wrap=dedent("""\ + col_wrap : int + "Wrap" the column variable at this width, so that the column facets + span multiple rows. Incompatible with a ``row`` facet.\ + """), + share_xy=dedent("""\ + share{x,y} : bool, 'col', or 'row' optional + If true, the facets will share y axes across columns and/or x axes + across rows.\ + """), + height=dedent("""\ + height : scalar + Height (in inches) of each facet. See also: ``aspect``.\ + """), + aspect=dedent("""\ + aspect : scalar + Aspect ratio of each facet, so that ``aspect * height`` gives the width + of each facet in inches.\ + """), + palette=dedent("""\ + palette : palette name, list, or dict + Colors to use for the different levels of the ``hue`` variable. Should + be something that can be interpreted by :func:`color_palette`, or a + dictionary mapping hue levels to matplotlib colors.\ + """), + legend_out=dedent("""\ + legend_out : bool + If ``True``, the figure size will be extended, and the legend will be + drawn outside the plot on the center right.\ + """), + margin_titles=dedent("""\ + margin_titles : bool + If ``True``, the titles for the row variable are drawn to the right of + the last column. This option is experimental and may not work in all + cases.\ + """), + facet_kws=dedent("""\ + facet_kws : dict + Additional parameters passed to :class:`FacetGrid`. + """), +) + + +class FacetGrid(Grid): + """Multi-plot grid for plotting conditional relationships.""" + @_deprecate_positional_args + def __init__( + self, data, *, + row=None, col=None, hue=None, col_wrap=None, + sharex=True, sharey=True, height=3, aspect=1, palette=None, + row_order=None, col_order=None, hue_order=None, hue_kws=None, + dropna=False, legend_out=True, despine=True, + margin_titles=False, xlim=None, ylim=None, subplot_kws=None, + gridspec_kws=None, size=None + ): + + super(FacetGrid, self).__init__() + + # Handle deprecations + if size is not None: + height = size + msg = ("The `size` parameter has been renamed to `height`; " + "please update your code.") + warnings.warn(msg, UserWarning) + + # Determine the hue facet layer information + hue_var = hue + if hue is None: + hue_names = None + else: + hue_names = categorical_order(data[hue], hue_order) + + colors = self._get_palette(data, hue, hue_order, palette) + + # Set up the lists of names for the row and column facet variables + if row is None: + row_names = [] + else: + row_names = categorical_order(data[row], row_order) + + if col is None: + col_names = [] + else: + col_names = categorical_order(data[col], col_order) + + # Additional dict of kwarg -> list of values for mapping the hue var + hue_kws = hue_kws if hue_kws is not None else {} + + # Make a boolean mask that is True anywhere there is an NA + # value in one of the faceting variables, but only if dropna is True + none_na = np.zeros(len(data), bool) + if dropna: + row_na = none_na if row is None else data[row].isnull() + col_na = none_na if col is None else data[col].isnull() + hue_na = none_na if hue is None else data[hue].isnull() + not_na = ~(row_na | col_na | hue_na) + else: + not_na = ~none_na + + # Compute the grid shape + ncol = 1 if col is None else len(col_names) + nrow = 1 if row is None else len(row_names) + self._n_facets = ncol * nrow + + self._col_wrap = col_wrap + if col_wrap is not None: + if row is not None: + err = "Cannot use `row` and `col_wrap` together." + raise ValueError(err) + ncol = col_wrap + nrow = int(np.ceil(len(col_names) / col_wrap)) + self._ncol = ncol + self._nrow = nrow + + # Calculate the base figure size + # This can get stretched later by a legend + # TODO this doesn't account for axis labels + figsize = (ncol * height * aspect, nrow * height) + + # Validate some inputs + if col_wrap is not None: + margin_titles = False + + # Build the subplot keyword dictionary + subplot_kws = {} if subplot_kws is None else subplot_kws.copy() + gridspec_kws = {} if gridspec_kws is None else gridspec_kws.copy() + if xlim is not None: + subplot_kws["xlim"] = xlim + if ylim is not None: + subplot_kws["ylim"] = ylim + + # --- Initialize the subplot grid + + # Disable autolayout so legend_out works properly + with mpl.rc_context({"figure.autolayout": False}): + fig = plt.figure(figsize=figsize) + + if col_wrap is None: + + kwargs = dict(squeeze=False, + sharex=sharex, sharey=sharey, + subplot_kw=subplot_kws, + gridspec_kw=gridspec_kws) + + axes = fig.subplots(nrow, ncol, **kwargs) + + if col is None and row is None: + axes_dict = {} + elif col is None: + axes_dict = dict(zip(row_names, axes.flat)) + elif row is None: + axes_dict = dict(zip(col_names, axes.flat)) + else: + facet_product = product(row_names, col_names) + axes_dict = dict(zip(facet_product, axes.flat)) + + else: + + # If wrapping the col variable we need to make the grid ourselves + if gridspec_kws: + warnings.warn("`gridspec_kws` ignored when using `col_wrap`") + + n_axes = len(col_names) + axes = np.empty(n_axes, object) + axes[0] = fig.add_subplot(nrow, ncol, 1, **subplot_kws) + if sharex: + subplot_kws["sharex"] = axes[0] + if sharey: + subplot_kws["sharey"] = axes[0] + for i in range(1, n_axes): + axes[i] = fig.add_subplot(nrow, ncol, i + 1, **subplot_kws) + + axes_dict = dict(zip(col_names, axes)) + + # --- Set up the class attributes + + # Attributes that are part of the public API but accessed through + # a property so that Sphinx adds them to the auto class doc + self._figure = fig + self._axes = axes + self._axes_dict = axes_dict + self._legend = None + + # Public attributes that aren't explicitly documented + # (It's not obvious that having them be public was a good idea) + self.data = data + self.row_names = row_names + self.col_names = col_names + self.hue_names = hue_names + self.hue_kws = hue_kws + + # Next the private variables + self._nrow = nrow + self._row_var = row + self._ncol = ncol + self._col_var = col + + self._margin_titles = margin_titles + self._margin_titles_texts = [] + self._col_wrap = col_wrap + self._hue_var = hue_var + self._colors = colors + self._legend_out = legend_out + self._legend_data = {} + self._x_var = None + self._y_var = None + self._dropna = dropna + self._not_na = not_na + + # --- Make the axes look good + + self.tight_layout() + if despine: + self.despine() + + if sharex in [True, 'col']: + for ax in self._not_bottom_axes: + for label in ax.get_xticklabels(): + label.set_visible(False) + ax.xaxis.offsetText.set_visible(False) + ax.xaxis.label.set_visible(False) + + if sharey in [True, 'row']: + for ax in self._not_left_axes: + for label in ax.get_yticklabels(): + label.set_visible(False) + ax.yaxis.offsetText.set_visible(False) + ax.yaxis.label.set_visible(False) + + __init__.__doc__ = dedent("""\ + Initialize the matplotlib figure and FacetGrid object. + + This class maps a dataset onto multiple axes arrayed in a grid of rows + and columns that correspond to *levels* of variables in the dataset. + The plots it produces are often called "lattice", "trellis", or + "small-multiple" graphics. + + It can also represent levels of a third variable with the ``hue`` + parameter, which plots different subsets of data in different colors. + This uses color to resolve elements on a third dimension, but only + draws subsets on top of each other and will not tailor the ``hue`` + parameter for the specific visualization the way that axes-level + functions that accept ``hue`` will. + + The basic workflow is to initialize the :class:`FacetGrid` object with + the dataset and the variables that are used to structure the grid. Then + one or more plotting functions can be applied to each subset by calling + :meth:`FacetGrid.map` or :meth:`FacetGrid.map_dataframe`. Finally, the + plot can be tweaked with other methods to do things like change the + axis labels, use different ticks, or add a legend. See the detailed + code examples below for more information. + + .. warning:: + + When using seaborn functions that infer semantic mappings from a + dataset, care must be taken to synchronize those mappings across + facets (e.g., by defing the ``hue`` mapping with a palette dict or + setting the data type of the variables to ``category``). In most cases, + it will be better to use a figure-level function (e.g. :func:`relplot` + or :func:`catplot`) than to use :class:`FacetGrid` directly. + + See the :ref:`tutorial ` for more information. + + Parameters + ---------- + {data} + row, col, hue : strings + Variables that define subsets of the data, which will be drawn on + separate facets in the grid. See the ``{{var}}_order`` parameters to + control the order of levels of this variable. + {col_wrap} + {share_xy} + {height} + {aspect} + {palette} + {{row,col,hue}}_order : lists + Order for the levels of the faceting variables. By default, this + will be the order that the levels appear in ``data`` or, if the + variables are pandas categoricals, the category order. + hue_kws : dictionary of param -> list of values mapping + Other keyword arguments to insert into the plotting call to let + other plot attributes vary across levels of the hue variable (e.g. + the markers in a scatterplot). + {legend_out} + despine : boolean + Remove the top and right spines from the plots. + {margin_titles} + {{x, y}}lim: tuples + Limits for each of the axes on each facet (only relevant when + share{{x, y}} is True). + subplot_kws : dict + Dictionary of keyword arguments passed to matplotlib subplot(s) + methods. + gridspec_kws : dict + Dictionary of keyword arguments passed to + :class:`matplotlib.gridspec.GridSpec` + (via :meth:`matplotlib.figure.Figure.subplots`). + Ignored if ``col_wrap`` is not ``None``. + + See Also + -------- + PairGrid : Subplot grid for plotting pairwise relationships + relplot : Combine a relational plot and a :class:`FacetGrid` + displot : Combine a distribution plot and a :class:`FacetGrid` + catplot : Combine a categorical plot and a :class:`FacetGrid` + lmplot : Combine a regression plot and a :class:`FacetGrid` + + Examples + -------- + + .. note:: + + These examples use seaborn functions to demonstrate some of the + advanced features of the class, but in most cases you will want + to use figue-level functions (e.g. :func:`displot`, :func:`relplot`) + to make the plots shown here. + + .. include:: ../docstrings/FacetGrid.rst + + """).format(**_facet_docs) + + def facet_data(self): + """Generator for name indices and data subsets for each facet. + + Yields + ------ + (i, j, k), data_ijk : tuple of ints, DataFrame + The ints provide an index into the {row, col, hue}_names attribute, + and the dataframe contains a subset of the full data corresponding + to each facet. The generator yields subsets that correspond with + the self.axes.flat iterator, or self.axes[i, j] when `col_wrap` + is None. + + """ + data = self.data + + # Construct masks for the row variable + if self.row_names: + row_masks = [data[self._row_var] == n for n in self.row_names] + else: + row_masks = [np.repeat(True, len(self.data))] + + # Construct masks for the column variable + if self.col_names: + col_masks = [data[self._col_var] == n for n in self.col_names] + else: + col_masks = [np.repeat(True, len(self.data))] + + # Construct masks for the hue variable + if self.hue_names: + hue_masks = [data[self._hue_var] == n for n in self.hue_names] + else: + hue_masks = [np.repeat(True, len(self.data))] + + # Here is the main generator loop + for (i, row), (j, col), (k, hue) in product(enumerate(row_masks), + enumerate(col_masks), + enumerate(hue_masks)): + data_ijk = data[row & col & hue & self._not_na] + yield (i, j, k), data_ijk + + def map(self, func, *args, **kwargs): + """Apply a plotting function to each facet's subset of the data. + + Parameters + ---------- + func : callable + A plotting function that takes data and keyword arguments. It + must plot to the currently active matplotlib Axes and take a + `color` keyword argument. If faceting on the `hue` dimension, + it must also take a `label` keyword argument. + args : strings + Column names in self.data that identify variables with data to + plot. The data for each variable is passed to `func` in the + order the variables are specified in the call. + kwargs : keyword arguments + All keyword arguments are passed to the plotting function. + + Returns + ------- + self : object + Returns self. + + """ + # If color was a keyword argument, grab it here + kw_color = kwargs.pop("color", None) + + # How we use the function depends on where it comes from + func_module = str(getattr(func, "__module__", "")) + + # Check for categorical plots without order information + if func_module == "seaborn.categorical": + if "order" not in kwargs: + warning = ("Using the {} function without specifying " + "`order` is likely to produce an incorrect " + "plot.".format(func.__name__)) + warnings.warn(warning) + if len(args) == 3 and "hue_order" not in kwargs: + warning = ("Using the {} function without specifying " + "`hue_order` is likely to produce an incorrect " + "plot.".format(func.__name__)) + warnings.warn(warning) + + # Iterate over the data subsets + for (row_i, col_j, hue_k), data_ijk in self.facet_data(): + + # If this subset is null, move on + if not data_ijk.values.size: + continue + + # Get the current axis + modify_state = not func_module.startswith("seaborn") + ax = self.facet_axis(row_i, col_j, modify_state) + + # Decide what color to plot with + kwargs["color"] = self._facet_color(hue_k, kw_color) + + # Insert the other hue aesthetics if appropriate + for kw, val_list in self.hue_kws.items(): + kwargs[kw] = val_list[hue_k] + + # Insert a label in the keyword arguments for the legend + if self._hue_var is not None: + kwargs["label"] = utils.to_utf8(self.hue_names[hue_k]) + + # Get the actual data we are going to plot with + plot_data = data_ijk[list(args)] + if self._dropna: + plot_data = plot_data.dropna() + plot_args = [v for k, v in plot_data.iteritems()] + + # Some matplotlib functions don't handle pandas objects correctly + if func_module.startswith("matplotlib"): + plot_args = [v.values for v in plot_args] + + # Draw the plot + self._facet_plot(func, ax, plot_args, kwargs) + + # Finalize the annotations and layout + self._finalize_grid(args[:2]) + + return self + + def map_dataframe(self, func, *args, **kwargs): + """Like ``.map`` but passes args as strings and inserts data in kwargs. + + This method is suitable for plotting with functions that accept a + long-form DataFrame as a `data` keyword argument and access the + data in that DataFrame using string variable names. + + Parameters + ---------- + func : callable + A plotting function that takes data and keyword arguments. Unlike + the `map` method, a function used here must "understand" Pandas + objects. It also must plot to the currently active matplotlib Axes + and take a `color` keyword argument. If faceting on the `hue` + dimension, it must also take a `label` keyword argument. + args : strings + Column names in self.data that identify variables with data to + plot. The data for each variable is passed to `func` in the + order the variables are specified in the call. + kwargs : keyword arguments + All keyword arguments are passed to the plotting function. + + Returns + ------- + self : object + Returns self. + + """ + + # If color was a keyword argument, grab it here + kw_color = kwargs.pop("color", None) + + # Iterate over the data subsets + for (row_i, col_j, hue_k), data_ijk in self.facet_data(): + + # If this subset is null, move on + if not data_ijk.values.size: + continue + + # Get the current axis + modify_state = not str(func.__module__).startswith("seaborn") + ax = self.facet_axis(row_i, col_j, modify_state) + + # Decide what color to plot with + kwargs["color"] = self._facet_color(hue_k, kw_color) + + # Insert the other hue aesthetics if appropriate + for kw, val_list in self.hue_kws.items(): + kwargs[kw] = val_list[hue_k] + + # Insert a label in the keyword arguments for the legend + if self._hue_var is not None: + kwargs["label"] = self.hue_names[hue_k] + + # Stick the facet dataframe into the kwargs + if self._dropna: + data_ijk = data_ijk.dropna() + kwargs["data"] = data_ijk + + # Draw the plot + self._facet_plot(func, ax, args, kwargs) + + # For axis labels, prefer to use positional args for backcompat + # but also extract the x/y kwargs and use if no corresponding arg + axis_labels = [kwargs.get("x", None), kwargs.get("y", None)] + for i, val in enumerate(args[:2]): + axis_labels[i] = val + self._finalize_grid(axis_labels) + + return self + + def _facet_color(self, hue_index, kw_color): + + color = self._colors[hue_index] + if kw_color is not None: + return kw_color + elif color is not None: + return color + + def _facet_plot(self, func, ax, plot_args, plot_kwargs): + + # Draw the plot + if str(func.__module__).startswith("seaborn"): + plot_kwargs = plot_kwargs.copy() + semantics = ["x", "y", "hue", "size", "style"] + for key, val in zip(semantics, plot_args): + plot_kwargs[key] = val + plot_args = [] + plot_kwargs["ax"] = ax + func(*plot_args, **plot_kwargs) + + # Sort out the supporting information + self._update_legend_data(ax) + + def _finalize_grid(self, axlabels): + """Finalize the annotations and layout.""" + self.set_axis_labels(*axlabels) + self.set_titles() + self.tight_layout() + + def facet_axis(self, row_i, col_j, modify_state=True): + """Make the axis identified by these indices active and return it.""" + + # Calculate the actual indices of the axes to plot on + if self._col_wrap is not None: + ax = self.axes.flat[col_j] + else: + ax = self.axes[row_i, col_j] + + # Get a reference to the axes object we want, and make it active + if modify_state: + plt.sca(ax) + return ax + + def despine(self, **kwargs): + """Remove axis spines from the facets.""" + utils.despine(self._figure, **kwargs) + return self + + def set_axis_labels(self, x_var=None, y_var=None, clear_inner=True, **kwargs): + """Set axis labels on the left column and bottom row of the grid.""" + if x_var is not None: + self._x_var = x_var + self.set_xlabels(x_var, clear_inner=clear_inner, **kwargs) + if y_var is not None: + self._y_var = y_var + self.set_ylabels(y_var, clear_inner=clear_inner, **kwargs) + + return self + + def set_xlabels(self, label=None, clear_inner=True, **kwargs): + """Label the x axis on the bottom row of the grid.""" + if label is None: + label = self._x_var + for ax in self._bottom_axes: + ax.set_xlabel(label, **kwargs) + if clear_inner: + for ax in self._not_bottom_axes: + ax.set_xlabel("") + return self + + def set_ylabels(self, label=None, clear_inner=True, **kwargs): + """Label the y axis on the left column of the grid.""" + if label is None: + label = self._y_var + for ax in self._left_axes: + ax.set_ylabel(label, **kwargs) + if clear_inner: + for ax in self._not_left_axes: + ax.set_ylabel("") + return self + + def set_xticklabels(self, labels=None, step=None, **kwargs): + """Set x axis tick labels of the grid.""" + for ax in self.axes.flat: + curr_ticks = ax.get_xticks() + ax.set_xticks(curr_ticks) + if labels is None: + curr_labels = [l.get_text() for l in ax.get_xticklabels()] + if step is not None: + xticks = ax.get_xticks()[::step] + curr_labels = curr_labels[::step] + ax.set_xticks(xticks) + ax.set_xticklabels(curr_labels, **kwargs) + else: + ax.set_xticklabels(labels, **kwargs) + return self + + def set_yticklabels(self, labels=None, **kwargs): + """Set y axis tick labels on the left column of the grid.""" + for ax in self.axes.flat: + curr_ticks = ax.get_yticks() + ax.set_yticks(curr_ticks) + if labels is None: + curr_labels = [l.get_text() for l in ax.get_yticklabels()] + ax.set_yticklabels(curr_labels, **kwargs) + else: + ax.set_yticklabels(labels, **kwargs) + return self + + def set_titles(self, template=None, row_template=None, col_template=None, + **kwargs): + """Draw titles either above each facet or on the grid margins. + + Parameters + ---------- + template : string + Template for all titles with the formatting keys {col_var} and + {col_name} (if using a `col` faceting variable) and/or {row_var} + and {row_name} (if using a `row` faceting variable). + row_template: + Template for the row variable when titles are drawn on the grid + margins. Must have {row_var} and {row_name} formatting keys. + col_template: + Template for the row variable when titles are drawn on the grid + margins. Must have {col_var} and {col_name} formatting keys. + + Returns + ------- + self: object + Returns self. + + """ + args = dict(row_var=self._row_var, col_var=self._col_var) + kwargs["size"] = kwargs.pop("size", mpl.rcParams["axes.labelsize"]) + + # Establish default templates + if row_template is None: + row_template = "{row_var} = {row_name}" + if col_template is None: + col_template = "{col_var} = {col_name}" + if template is None: + if self._row_var is None: + template = col_template + elif self._col_var is None: + template = row_template + else: + template = " | ".join([row_template, col_template]) + + row_template = utils.to_utf8(row_template) + col_template = utils.to_utf8(col_template) + template = utils.to_utf8(template) + + if self._margin_titles: + + # Remove any existing title texts + for text in self._margin_titles_texts: + text.remove() + self._margin_titles_texts = [] + + if self.row_names is not None: + # Draw the row titles on the right edge of the grid + for i, row_name in enumerate(self.row_names): + ax = self.axes[i, -1] + args.update(dict(row_name=row_name)) + title = row_template.format(**args) + text = ax.annotate( + title, xy=(1.02, .5), xycoords="axes fraction", + rotation=270, ha="left", va="center", + **kwargs + ) + self._margin_titles_texts.append(text) + + if self.col_names is not None: + # Draw the column titles as normal titles + for j, col_name in enumerate(self.col_names): + args.update(dict(col_name=col_name)) + title = col_template.format(**args) + self.axes[0, j].set_title(title, **kwargs) + + return self + + # Otherwise title each facet with all the necessary information + if (self._row_var is not None) and (self._col_var is not None): + for i, row_name in enumerate(self.row_names): + for j, col_name in enumerate(self.col_names): + args.update(dict(row_name=row_name, col_name=col_name)) + title = template.format(**args) + self.axes[i, j].set_title(title, **kwargs) + elif self.row_names is not None and len(self.row_names): + for i, row_name in enumerate(self.row_names): + args.update(dict(row_name=row_name)) + title = template.format(**args) + self.axes[i, 0].set_title(title, **kwargs) + elif self.col_names is not None and len(self.col_names): + for i, col_name in enumerate(self.col_names): + args.update(dict(col_name=col_name)) + title = template.format(**args) + # Index the flat array so col_wrap works + self.axes.flat[i].set_title(title, **kwargs) + return self + + def refline(self, *, x=None, y=None, color='.5', linestyle='--', **line_kws): + """Add a reference line(s) to each facet. + + Parameters + ---------- + x, y : numeric + Value(s) to draw the line(s) at. + color : :mod:`matplotlib color ` + Specifies the color of the reference line(s). Pass ``color=None`` to + use ``hue`` mapping. + linestyle : str + Specifies the style of the reference line(s). + line_kws : key, value mappings + Other keyword arguments are passed to :meth:`matplotlib.axes.Axes.axvline` + when ``x`` is not None and :meth:`matplotlib.axes.Axes.axhline` when ``y`` + is not None. + + Returns + ------- + :class:`FacetGrid` instance + Returns ``self`` for easy method chaining. + + """ + line_kws['color'] = color + line_kws['linestyle'] = linestyle + + if x is not None: + self.map(plt.axvline, x=x, **line_kws) + + if y is not None: + self.map(plt.axhline, y=y, **line_kws) + + # ------ Properties that are part of the public API and documented by Sphinx + + @property + def axes(self): + """An array of the :class:`matplotlib.axes.Axes` objects in the grid.""" + return self._axes + + @property + def ax(self): + """The :class:`matplotlib.axes.Axes` when no faceting variables are assigned.""" + if self.axes.shape == (1, 1): + return self.axes[0, 0] + else: + err = ( + "Use the `.axes` attribute when facet variables are assigned." + ) + raise AttributeError(err) + + @property + def axes_dict(self): + """A mapping of facet names to corresponding :class:`matplotlib.axes.Axes`. + + If only one of ``row`` or ``col`` is assigned, each key is a string + representing a level of that variable. If both facet dimensions are + assigned, each key is a ``({row_level}, {col_level})`` tuple. + + """ + return self._axes_dict + + # ------ Private properties, that require some computation to get + + @property + def _inner_axes(self): + """Return a flat array of the inner axes.""" + if self._col_wrap is None: + return self.axes[:-1, 1:].flat + else: + axes = [] + n_empty = self._nrow * self._ncol - self._n_facets + for i, ax in enumerate(self.axes): + append = ( + i % self._ncol + and i < (self._ncol * (self._nrow - 1)) + and i < (self._ncol * (self._nrow - 1) - n_empty) + ) + if append: + axes.append(ax) + return np.array(axes, object).flat + + @property + def _left_axes(self): + """Return a flat array of the left column of axes.""" + if self._col_wrap is None: + return self.axes[:, 0].flat + else: + axes = [] + for i, ax in enumerate(self.axes): + if not i % self._ncol: + axes.append(ax) + return np.array(axes, object).flat + + @property + def _not_left_axes(self): + """Return a flat array of axes that aren't on the left column.""" + if self._col_wrap is None: + return self.axes[:, 1:].flat + else: + axes = [] + for i, ax in enumerate(self.axes): + if i % self._ncol: + axes.append(ax) + return np.array(axes, object).flat + + @property + def _bottom_axes(self): + """Return a flat array of the bottom row of axes.""" + if self._col_wrap is None: + return self.axes[-1, :].flat + else: + axes = [] + n_empty = self._nrow * self._ncol - self._n_facets + for i, ax in enumerate(self.axes): + append = ( + i >= (self._ncol * (self._nrow - 1)) + or i >= (self._ncol * (self._nrow - 1) - n_empty) + ) + if append: + axes.append(ax) + return np.array(axes, object).flat + + @property + def _not_bottom_axes(self): + """Return a flat array of axes that aren't on the bottom row.""" + if self._col_wrap is None: + return self.axes[:-1, :].flat + else: + axes = [] + n_empty = self._nrow * self._ncol - self._n_facets + for i, ax in enumerate(self.axes): + append = ( + i < (self._ncol * (self._nrow - 1)) + and i < (self._ncol * (self._nrow - 1) - n_empty) + ) + if append: + axes.append(ax) + return np.array(axes, object).flat + + +class PairGrid(Grid): + """Subplot grid for plotting pairwise relationships in a dataset. + + This object maps each variable in a dataset onto a column and row in a + grid of multiple axes. Different axes-level plotting functions can be + used to draw bivariate plots in the upper and lower triangles, and the + the marginal distribution of each variable can be shown on the diagonal. + + Several different common plots can be generated in a single line using + :func:`pairplot`. Use :class:`PairGrid` when you need more flexibility. + + See the :ref:`tutorial ` for more information. + + """ + @_deprecate_positional_args + def __init__( + self, data, *, + hue=None, hue_order=None, palette=None, + hue_kws=None, vars=None, x_vars=None, y_vars=None, + corner=False, diag_sharey=True, height=2.5, aspect=1, + layout_pad=.5, despine=True, dropna=False, size=None + ): + """Initialize the plot figure and PairGrid object. + + Parameters + ---------- + data : DataFrame + Tidy (long-form) dataframe where each column is a variable and + each row is an observation. + hue : string (variable name) + Variable in ``data`` to map plot aspects to different colors. This + variable will be excluded from the default x and y variables. + hue_order : list of strings + Order for the levels of the hue variable in the palette + palette : dict or seaborn color palette + Set of colors for mapping the ``hue`` variable. If a dict, keys + should be values in the ``hue`` variable. + hue_kws : dictionary of param -> list of values mapping + Other keyword arguments to insert into the plotting call to let + other plot attributes vary across levels of the hue variable (e.g. + the markers in a scatterplot). + vars : list of variable names + Variables within ``data`` to use, otherwise use every column with + a numeric datatype. + {x, y}_vars : lists of variable names + Variables within ``data`` to use separately for the rows and + columns of the figure; i.e. to make a non-square plot. + corner : bool + If True, don't add axes to the upper (off-diagonal) triangle of the + grid, making this a "corner" plot. + height : scalar + Height (in inches) of each facet. + aspect : scalar + Aspect * height gives the width (in inches) of each facet. + layout_pad : scalar + Padding between axes; passed to ``fig.tight_layout``. + despine : boolean + Remove the top and right spines from the plots. + dropna : boolean + Drop missing values from the data before plotting. + + See Also + -------- + pairplot : Easily drawing common uses of :class:`PairGrid`. + FacetGrid : Subplot grid for plotting conditional relationships. + + Examples + -------- + + .. include:: ../docstrings/PairGrid.rst + + """ + + super(PairGrid, self).__init__() + + # Handle deprecations + if size is not None: + height = size + msg = ("The `size` parameter has been renamed to `height`; " + "please update your code.") + warnings.warn(UserWarning(msg)) + + # Sort out the variables that define the grid + numeric_cols = self._find_numeric_cols(data) + if hue in numeric_cols: + numeric_cols.remove(hue) + if vars is not None: + x_vars = list(vars) + y_vars = list(vars) + if x_vars is None: + x_vars = numeric_cols + if y_vars is None: + y_vars = numeric_cols + + if np.isscalar(x_vars): + x_vars = [x_vars] + if np.isscalar(y_vars): + y_vars = [y_vars] + + self.x_vars = x_vars = list(x_vars) + self.y_vars = y_vars = list(y_vars) + self.square_grid = self.x_vars == self.y_vars + + if not x_vars: + raise ValueError("No variables found for grid columns.") + if not y_vars: + raise ValueError("No variables found for grid rows.") + + # Create the figure and the array of subplots + figsize = len(x_vars) * height * aspect, len(y_vars) * height + + # Disable autolayout so legend_out works + with mpl.rc_context({"figure.autolayout": False}): + fig = plt.figure(figsize=figsize) + + axes = fig.subplots(len(y_vars), len(x_vars), + sharex="col", sharey="row", + squeeze=False) + + # Possibly remove upper axes to make a corner grid + # Note: setting up the axes is usually the most time-intensive part + # of using the PairGrid. We are foregoing the speed improvement that + # we would get by just not setting up the hidden axes so that we can + # avoid implementing fig.subplots ourselves. But worth thinking about. + self._corner = corner + if corner: + hide_indices = np.triu_indices_from(axes, 1) + for i, j in zip(*hide_indices): + axes[i, j].remove() + axes[i, j] = None + + self._figure = fig + self.axes = axes + self.data = data + + # Save what we are going to do with the diagonal + self.diag_sharey = diag_sharey + self.diag_vars = None + self.diag_axes = None + + self._dropna = dropna + + # Label the axes + self._add_axis_labels() + + # Sort out the hue variable + self._hue_var = hue + if hue is None: + self.hue_names = hue_order = ["_nolegend_"] + self.hue_vals = pd.Series(["_nolegend_"] * len(data), + index=data.index) + else: + # We need hue_order and hue_names because the former is used to control + # the order of drawing and the latter is used to control the order of + # the legend. hue_names can become string-typed while hue_order must + # retain the type of the input data. This is messy but results from + # the fact that PairGrid can implement the hue-mapping logic itself + # (and was originally written exclusively that way) but now can delegate + # to the axes-level functions, while always handling legend creation. + # See GH2307 + hue_names = hue_order = categorical_order(data[hue], hue_order) + if dropna: + # Filter NA from the list of unique hue names + hue_names = list(filter(pd.notnull, hue_names)) + self.hue_names = hue_names + self.hue_vals = data[hue] + + # Additional dict of kwarg -> list of values for mapping the hue var + self.hue_kws = hue_kws if hue_kws is not None else {} + + self._orig_palette = palette + self._hue_order = hue_order + self.palette = self._get_palette(data, hue, hue_order, palette) + self._legend_data = {} + + # Make the plot look nice + for ax in axes[:-1, :].flat: + if ax is None: + continue + for label in ax.get_xticklabels(): + label.set_visible(False) + ax.xaxis.offsetText.set_visible(False) + ax.xaxis.label.set_visible(False) + + for ax in axes[:, 1:].flat: + if ax is None: + continue + for label in ax.get_yticklabels(): + label.set_visible(False) + ax.yaxis.offsetText.set_visible(False) + ax.yaxis.label.set_visible(False) + + self._tight_layout_rect = [.01, .01, .99, .99] + self._tight_layout_pad = layout_pad + self._despine = despine + if despine: + utils.despine(fig=fig) + self.tight_layout(pad=layout_pad) + + def map(self, func, **kwargs): + """Plot with the same function in every subplot. + + Parameters + ---------- + func : callable plotting function + Must take x, y arrays as positional arguments and draw onto the + "currently active" matplotlib Axes. Also needs to accept kwargs + called ``color`` and ``label``. + + """ + row_indices, col_indices = np.indices(self.axes.shape) + indices = zip(row_indices.flat, col_indices.flat) + self._map_bivariate(func, indices, **kwargs) + + return self + + def map_lower(self, func, **kwargs): + """Plot with a bivariate function on the lower diagonal subplots. + + Parameters + ---------- + func : callable plotting function + Must take x, y arrays as positional arguments and draw onto the + "currently active" matplotlib Axes. Also needs to accept kwargs + called ``color`` and ``label``. + + """ + indices = zip(*np.tril_indices_from(self.axes, -1)) + self._map_bivariate(func, indices, **kwargs) + return self + + def map_upper(self, func, **kwargs): + """Plot with a bivariate function on the upper diagonal subplots. + + Parameters + ---------- + func : callable plotting function + Must take x, y arrays as positional arguments and draw onto the + "currently active" matplotlib Axes. Also needs to accept kwargs + called ``color`` and ``label``. + + """ + indices = zip(*np.triu_indices_from(self.axes, 1)) + self._map_bivariate(func, indices, **kwargs) + return self + + def map_offdiag(self, func, **kwargs): + """Plot with a bivariate function on the off-diagonal subplots. + + Parameters + ---------- + func : callable plotting function + Must take x, y arrays as positional arguments and draw onto the + "currently active" matplotlib Axes. Also needs to accept kwargs + called ``color`` and ``label``. + + """ + if self.square_grid: + self.map_lower(func, **kwargs) + if not self._corner: + self.map_upper(func, **kwargs) + else: + indices = [] + for i, (y_var) in enumerate(self.y_vars): + for j, (x_var) in enumerate(self.x_vars): + if x_var != y_var: + indices.append((i, j)) + self._map_bivariate(func, indices, **kwargs) + return self + + def map_diag(self, func, **kwargs): + """Plot with a univariate function on each diagonal subplot. + + Parameters + ---------- + func : callable plotting function + Must take an x array as a positional argument and draw onto the + "currently active" matplotlib Axes. Also needs to accept kwargs + called ``color`` and ``label``. + + """ + # Add special diagonal axes for the univariate plot + if self.diag_axes is None: + diag_vars = [] + diag_axes = [] + for i, y_var in enumerate(self.y_vars): + for j, x_var in enumerate(self.x_vars): + if x_var == y_var: + + # Make the density axes + diag_vars.append(x_var) + ax = self.axes[i, j] + diag_ax = ax.twinx() + diag_ax.set_axis_off() + diag_axes.append(diag_ax) + + # Work around matplotlib bug + # https://github.com/matplotlib/matplotlib/issues/15188 + if not plt.rcParams.get("ytick.left", True): + for tick in ax.yaxis.majorTicks: + tick.tick1line.set_visible(False) + + # Remove main y axis from density axes in a corner plot + if self._corner: + ax.yaxis.set_visible(False) + if self._despine: + utils.despine(ax=ax, left=True) + # TODO add optional density ticks (on the right) + # when drawing a corner plot? + + if self.diag_sharey and diag_axes: + # This may change in future matplotlibs + # See https://github.com/matplotlib/matplotlib/pull/9923 + group = diag_axes[0].get_shared_y_axes() + for ax in diag_axes[1:]: + group.join(ax, diag_axes[0]) + + self.diag_vars = np.array(diag_vars, np.object_) + self.diag_axes = np.array(diag_axes, np.object_) + + if "hue" not in signature(func).parameters: + return self._map_diag_iter_hue(func, **kwargs) + + # Loop over diagonal variables and axes, making one plot in each + for var, ax in zip(self.diag_vars, self.diag_axes): + + plot_kwargs = kwargs.copy() + if str(func.__module__).startswith("seaborn"): + plot_kwargs["ax"] = ax + else: + plt.sca(ax) + + vector = self.data[var] + if self._hue_var is not None: + hue = self.data[self._hue_var] + else: + hue = None + + if self._dropna: + not_na = vector.notna() + if hue is not None: + not_na &= hue.notna() + vector = vector[not_na] + if hue is not None: + hue = hue[not_na] + + plot_kwargs.setdefault("hue", hue) + plot_kwargs.setdefault("hue_order", self._hue_order) + plot_kwargs.setdefault("palette", self._orig_palette) + func(x=vector, **plot_kwargs) + ax.legend_ = None + + self._add_axis_labels() + return self + + def _map_diag_iter_hue(self, func, **kwargs): + """Put marginal plot on each diagonal axes, iterating over hue.""" + # Plot on each of the diagonal axes + fixed_color = kwargs.pop("color", None) + + for var, ax in zip(self.diag_vars, self.diag_axes): + hue_grouped = self.data[var].groupby(self.hue_vals) + + plot_kwargs = kwargs.copy() + if str(func.__module__).startswith("seaborn"): + plot_kwargs["ax"] = ax + else: + plt.sca(ax) + + for k, label_k in enumerate(self._hue_order): + + # Attempt to get data for this level, allowing for empty + try: + data_k = hue_grouped.get_group(label_k) + except KeyError: + data_k = pd.Series([], dtype=float) + + if fixed_color is None: + color = self.palette[k] + else: + color = fixed_color + + if self._dropna: + data_k = utils.remove_na(data_k) + + if str(func.__module__).startswith("seaborn"): + func(x=data_k, label=label_k, color=color, **plot_kwargs) + else: + func(data_k, label=label_k, color=color, **plot_kwargs) + + self._add_axis_labels() + + return self + + def _map_bivariate(self, func, indices, **kwargs): + """Draw a bivariate plot on the indicated axes.""" + # This is a hack to handle the fact that new distribution plots don't add + # their artists onto the axes. This is probably superior in general, but + # we'll need a better way to handle it in the axisgrid functions. + from .distributions import histplot, kdeplot + if func is histplot or func is kdeplot: + self._extract_legend_handles = True + + kws = kwargs.copy() # Use copy as we insert other kwargs + for i, j in indices: + x_var = self.x_vars[j] + y_var = self.y_vars[i] + ax = self.axes[i, j] + if ax is None: # i.e. we are in corner mode + continue + self._plot_bivariate(x_var, y_var, ax, func, **kws) + self._add_axis_labels() + + if "hue" in signature(func).parameters: + self.hue_names = list(self._legend_data) + + def _plot_bivariate(self, x_var, y_var, ax, func, **kwargs): + """Draw a bivariate plot on the specified axes.""" + if "hue" not in signature(func).parameters: + self._plot_bivariate_iter_hue(x_var, y_var, ax, func, **kwargs) + return + + kwargs = kwargs.copy() + if str(func.__module__).startswith("seaborn"): + kwargs["ax"] = ax + else: + plt.sca(ax) + + if x_var == y_var: + axes_vars = [x_var] + else: + axes_vars = [x_var, y_var] + + if self._hue_var is not None and self._hue_var not in axes_vars: + axes_vars.append(self._hue_var) + + data = self.data[axes_vars] + if self._dropna: + data = data.dropna() + + x = data[x_var] + y = data[y_var] + if self._hue_var is None: + hue = None + else: + hue = data.get(self._hue_var) + + kwargs.setdefault("hue", hue) + kwargs.setdefault("hue_order", self._hue_order) + kwargs.setdefault("palette", self._orig_palette) + func(x=x, y=y, **kwargs) + + self._update_legend_data(ax) + + def _plot_bivariate_iter_hue(self, x_var, y_var, ax, func, **kwargs): + """Draw a bivariate plot while iterating over hue subsets.""" + kwargs = kwargs.copy() + if str(func.__module__).startswith("seaborn"): + kwargs["ax"] = ax + else: + plt.sca(ax) + + if x_var == y_var: + axes_vars = [x_var] + else: + axes_vars = [x_var, y_var] + + hue_grouped = self.data.groupby(self.hue_vals) + for k, label_k in enumerate(self._hue_order): + + kws = kwargs.copy() + + # Attempt to get data for this level, allowing for empty + try: + data_k = hue_grouped.get_group(label_k) + except KeyError: + data_k = pd.DataFrame(columns=axes_vars, + dtype=float) + + if self._dropna: + data_k = data_k[axes_vars].dropna() + + x = data_k[x_var] + y = data_k[y_var] + + for kw, val_list in self.hue_kws.items(): + kws[kw] = val_list[k] + kws.setdefault("color", self.palette[k]) + if self._hue_var is not None: + kws["label"] = label_k + + if str(func.__module__).startswith("seaborn"): + func(x=x, y=y, **kws) + else: + func(x, y, **kws) + + self._update_legend_data(ax) + + def _add_axis_labels(self): + """Add labels to the left and bottom Axes.""" + for ax, label in zip(self.axes[-1, :], self.x_vars): + ax.set_xlabel(label) + for ax, label in zip(self.axes[:, 0], self.y_vars): + ax.set_ylabel(label) + if self._corner: + self.axes[0, 0].set_ylabel("") + + def _find_numeric_cols(self, data): + """Find which variables in a DataFrame are numeric.""" + numeric_cols = [] + for col in data: + if variable_type(data[col]) == "numeric": + numeric_cols.append(col) + return numeric_cols + + +class JointGrid(_BaseGrid): + """Grid for drawing a bivariate plot with marginal univariate plots. + + Many plots can be drawn by using the figure-level interface :func:`jointplot`. + Use this class directly when you need more flexibility. + + """ + + @_deprecate_positional_args + def __init__( + self, *, + x=None, y=None, + data=None, + height=6, ratio=5, space=.2, + dropna=False, xlim=None, ylim=None, size=None, marginal_ticks=False, + hue=None, palette=None, hue_order=None, hue_norm=None, + ): + # Handle deprecations + if size is not None: + height = size + msg = ("The `size` parameter has been renamed to `height`; " + "please update your code.") + warnings.warn(msg, UserWarning) + + # Set up the subplot grid + f = plt.figure(figsize=(height, height)) + gs = plt.GridSpec(ratio + 1, ratio + 1) + + ax_joint = f.add_subplot(gs[1:, :-1]) + ax_marg_x = f.add_subplot(gs[0, :-1], sharex=ax_joint) + ax_marg_y = f.add_subplot(gs[1:, -1], sharey=ax_joint) + + self._figure = f + self.ax_joint = ax_joint + self.ax_marg_x = ax_marg_x + self.ax_marg_y = ax_marg_y + + # Turn off tick visibility for the measure axis on the marginal plots + plt.setp(ax_marg_x.get_xticklabels(), visible=False) + plt.setp(ax_marg_y.get_yticklabels(), visible=False) + plt.setp(ax_marg_x.get_xticklabels(minor=True), visible=False) + plt.setp(ax_marg_y.get_yticklabels(minor=True), visible=False) + + # Turn off the ticks on the density axis for the marginal plots + if not marginal_ticks: + plt.setp(ax_marg_x.yaxis.get_majorticklines(), visible=False) + plt.setp(ax_marg_x.yaxis.get_minorticklines(), visible=False) + plt.setp(ax_marg_y.xaxis.get_majorticklines(), visible=False) + plt.setp(ax_marg_y.xaxis.get_minorticklines(), visible=False) + plt.setp(ax_marg_x.get_yticklabels(), visible=False) + plt.setp(ax_marg_y.get_xticklabels(), visible=False) + plt.setp(ax_marg_x.get_yticklabels(minor=True), visible=False) + plt.setp(ax_marg_y.get_xticklabels(minor=True), visible=False) + ax_marg_x.yaxis.grid(False) + ax_marg_y.xaxis.grid(False) + + # Process the input variables + p = VectorPlotter(data=data, variables=dict(x=x, y=y, hue=hue)) + plot_data = p.plot_data.loc[:, p.plot_data.notna().any()] + + # Possibly drop NA + if dropna: + plot_data = plot_data.dropna() + + def get_var(var): + vector = plot_data.get(var, None) + if vector is not None: + vector = vector.rename(p.variables.get(var, None)) + return vector + + self.x = get_var("x") + self.y = get_var("y") + self.hue = get_var("hue") + + for axis in "xy": + name = p.variables.get(axis, None) + if name is not None: + getattr(ax_joint, f"set_{axis}label")(name) + + if xlim is not None: + ax_joint.set_xlim(xlim) + if ylim is not None: + ax_joint.set_ylim(ylim) + + # Store the semantic mapping parameters for axes-level functions + self._hue_params = dict(palette=palette, hue_order=hue_order, hue_norm=hue_norm) + + # Make the grid look nice + utils.despine(f) + if not marginal_ticks: + utils.despine(ax=ax_marg_x, left=True) + utils.despine(ax=ax_marg_y, bottom=True) + for axes in [ax_marg_x, ax_marg_y]: + for axis in [axes.xaxis, axes.yaxis]: + axis.label.set_visible(False) + f.tight_layout() + f.subplots_adjust(hspace=space, wspace=space) + + def _inject_kwargs(self, func, kws, params): + """Add params to kws if they are accepted by func.""" + func_params = signature(func).parameters + for key, val in params.items(): + if key in func_params: + kws.setdefault(key, val) + + def plot(self, joint_func, marginal_func, **kwargs): + """Draw the plot by passing functions for joint and marginal axes. + + This method passes the ``kwargs`` dictionary to both functions. If you + need more control, call :meth:`JointGrid.plot_joint` and + :meth:`JointGrid.plot_marginals` directly with specific parameters. + + Parameters + ---------- + joint_func, marginal_func : callables + Functions to draw the bivariate and univariate plots. See methods + referenced above for information about the required characteristics + of these functions. + kwargs + Additional keyword arguments are passed to both functions. + + Returns + ------- + :class:`JointGrid` instance + Returns ``self`` for easy method chaining. + + """ + self.plot_marginals(marginal_func, **kwargs) + self.plot_joint(joint_func, **kwargs) + return self + + def plot_joint(self, func, **kwargs): + """Draw a bivariate plot on the joint axes of the grid. + + Parameters + ---------- + func : plotting callable + If a seaborn function, it should accept ``x`` and ``y``. Otherwise, + it must accept ``x`` and ``y`` vectors of data as the first two + positional arguments, and it must plot on the "current" axes. + If ``hue`` was defined in the class constructor, the function must + accept ``hue`` as a parameter. + kwargs + Keyword argument are passed to the plotting function. + + Returns + ------- + :class:`JointGrid` instance + Returns ``self`` for easy method chaining. + + """ + kwargs = kwargs.copy() + if str(func.__module__).startswith("seaborn"): + kwargs["ax"] = self.ax_joint + else: + plt.sca(self.ax_joint) + if self.hue is not None: + kwargs["hue"] = self.hue + self._inject_kwargs(func, kwargs, self._hue_params) + + if str(func.__module__).startswith("seaborn"): + func(x=self.x, y=self.y, **kwargs) + else: + func(self.x, self.y, **kwargs) + + return self + + def plot_marginals(self, func, **kwargs): + """Draw univariate plots on each marginal axes. + + Parameters + ---------- + func : plotting callable + If a seaborn function, it should accept ``x`` and ``y`` and plot + when only one of them is defined. Otherwise, it must accept a vector + of data as the first positional argument and determine its orientation + using the ``vertical`` parameter, and it must plot on the "current" axes. + If ``hue`` was defined in the class constructor, it must accept ``hue`` + as a parameter. + kwargs + Keyword argument are passed to the plotting function. + + Returns + ------- + :class:`JointGrid` instance + Returns ``self`` for easy method chaining. + + """ + seaborn_func = ( + str(func.__module__).startswith("seaborn") + # deprecated distplot has a legacy API, special case it + and not func.__name__ == "distplot" + ) + func_params = signature(func).parameters + kwargs = kwargs.copy() + if self.hue is not None: + kwargs["hue"] = self.hue + self._inject_kwargs(func, kwargs, self._hue_params) + + if "legend" in func_params: + kwargs.setdefault("legend", False) + + if "orientation" in func_params: + # e.g. plt.hist + orient_kw_x = {"orientation": "vertical"} + orient_kw_y = {"orientation": "horizontal"} + elif "vertical" in func_params: + # e.g. sns.distplot (also how did this get backwards?) + orient_kw_x = {"vertical": False} + orient_kw_y = {"vertical": True} + + if seaborn_func: + func(x=self.x, ax=self.ax_marg_x, **kwargs) + else: + plt.sca(self.ax_marg_x) + func(self.x, **orient_kw_x, **kwargs) + + if seaborn_func: + func(y=self.y, ax=self.ax_marg_y, **kwargs) + else: + plt.sca(self.ax_marg_y) + func(self.y, **orient_kw_y, **kwargs) + + self.ax_marg_x.yaxis.get_label().set_visible(False) + self.ax_marg_y.xaxis.get_label().set_visible(False) + + return self + + def refline( + self, *, x=None, y=None, joint=True, marginal=True, + color='.5', linestyle='--', **line_kws + ): + """Add a reference line(s) to joint and/or marginal axes. + + Parameters + ---------- + x, y : numeric + Value(s) to draw the line(s) at. + joint, marginal : bools + Whether to add the reference line(s) to the joint/marginal axes. + color : :mod:`matplotlib color ` + Specifies the color of the reference line(s). + linestyle : str + Specifies the style of the reference line(s). + line_kws : key, value mappings + Other keyword arguments are passed to :meth:`matplotlib.axes.Axes.axvline` + when ``x`` is not None and :meth:`matplotlib.axes.Axes.axhline` when ``y`` + is not None. + + Returns + ------- + :class:`JointGrid` instance + Returns ``self`` for easy method chaining. + + """ + line_kws['color'] = color + line_kws['linestyle'] = linestyle + + if x is not None: + if joint: + self.ax_joint.axvline(x, **line_kws) + if marginal: + self.ax_marg_x.axvline(x, **line_kws) + + if y is not None: + if joint: + self.ax_joint.axhline(y, **line_kws) + if marginal: + self.ax_marg_y.axhline(y, **line_kws) + + return self + + def set_axis_labels(self, xlabel="", ylabel="", **kwargs): + """Set axis labels on the bivariate axes. + + Parameters + ---------- + xlabel, ylabel : strings + Label names for the x and y variables. + kwargs : key, value mappings + Other keyword arguments are passed to the following functions: + + - :meth:`matplotlib.axes.Axes.set_xlabel` + - :meth:`matplotlib.axes.Axes.set_ylabel` + + Returns + ------- + :class:`JointGrid` instance + Returns ``self`` for easy method chaining. + + """ + self.ax_joint.set_xlabel(xlabel, **kwargs) + self.ax_joint.set_ylabel(ylabel, **kwargs) + return self + + +JointGrid.__init__.__doc__ = """\ +Set up the grid of subplots and store data internally for easy plotting. + +Parameters +---------- +{params.core.xy} +{params.core.data} +height : number + Size of each side of the figure in inches (it will be square). +ratio : number + Ratio of joint axes height to marginal axes height. +space : number + Space between the joint and marginal axes +dropna : bool + If True, remove missing observations before plotting. +{{x, y}}lim : pairs of numbers + Set axis limits to these values before plotting. +marginal_ticks : bool + If False, suppress ticks on the count/density axis of the marginal plots. +{params.core.hue} + Note: unlike in :class:`FacetGrid` or :class:`PairGrid`, the axes-level + functions must support ``hue`` to use it in :class:`JointGrid`. +{params.core.palette} +{params.core.hue_order} +{params.core.hue_norm} + +See Also +-------- +{seealso.jointplot} +{seealso.pairgrid} +{seealso.pairplot} + +Examples +-------- + +.. include:: ../docstrings/JointGrid.rst + +""".format( + params=_param_docs, + returns=_core_docs["returns"], + seealso=_core_docs["seealso"], +) + + +@_deprecate_positional_args +def pairplot( + data, *, + hue=None, hue_order=None, palette=None, + vars=None, x_vars=None, y_vars=None, + kind="scatter", diag_kind="auto", markers=None, + height=2.5, aspect=1, corner=False, dropna=False, + plot_kws=None, diag_kws=None, grid_kws=None, size=None, +): + """Plot pairwise relationships in a dataset. + + By default, this function will create a grid of Axes such that each numeric + variable in ``data`` will by shared across the y-axes across a single row and + the x-axes across a single column. The diagonal plots are treated + differently: a univariate distribution plot is drawn to show the marginal + distribution of the data in each column. + + It is also possible to show a subset of variables or plot different + variables on the rows and columns. + + This is a high-level interface for :class:`PairGrid` that is intended to + make it easy to draw a few common styles. You should use :class:`PairGrid` + directly if you need more flexibility. + + Parameters + ---------- + data : `pandas.DataFrame` + Tidy (long-form) dataframe where each column is a variable and + each row is an observation. + hue : name of variable in ``data`` + Variable in ``data`` to map plot aspects to different colors. + hue_order : list of strings + Order for the levels of the hue variable in the palette + palette : dict or seaborn color palette + Set of colors for mapping the ``hue`` variable. If a dict, keys + should be values in the ``hue`` variable. + vars : list of variable names + Variables within ``data`` to use, otherwise use every column with + a numeric datatype. + {x, y}_vars : lists of variable names + Variables within ``data`` to use separately for the rows and + columns of the figure; i.e. to make a non-square plot. + kind : {'scatter', 'kde', 'hist', 'reg'} + Kind of plot to make. + diag_kind : {'auto', 'hist', 'kde', None} + Kind of plot for the diagonal subplots. If 'auto', choose based on + whether or not ``hue`` is used. + markers : single matplotlib marker code or list + Either the marker to use for all scatterplot points or a list of markers + with a length the same as the number of levels in the hue variable so that + differently colored points will also have different scatterplot + markers. + height : scalar + Height (in inches) of each facet. + aspect : scalar + Aspect * height gives the width (in inches) of each facet. + corner : bool + If True, don't add axes to the upper (off-diagonal) triangle of the + grid, making this a "corner" plot. + dropna : boolean + Drop missing values from the data before plotting. + {plot, diag, grid}_kws : dicts + Dictionaries of keyword arguments. ``plot_kws`` are passed to the + bivariate plotting function, ``diag_kws`` are passed to the univariate + plotting function, and ``grid_kws`` are passed to the :class:`PairGrid` + constructor. + + Returns + ------- + grid : :class:`PairGrid` + Returns the underlying :class:`PairGrid` instance for further tweaking. + + See Also + -------- + PairGrid : Subplot grid for more flexible plotting of pairwise relationships. + JointGrid : Grid for plotting joint and marginal distributions of two variables. + + Examples + -------- + + .. include:: ../docstrings/pairplot.rst + + """ + # Avoid circular import + from .distributions import histplot, kdeplot + + # Handle deprecations + if size is not None: + height = size + msg = ("The `size` parameter has been renamed to `height`; " + "please update your code.") + warnings.warn(msg, UserWarning) + + if not isinstance(data, pd.DataFrame): + raise TypeError( + "'data' must be pandas DataFrame object, not: {typefound}".format( + typefound=type(data))) + + plot_kws = {} if plot_kws is None else plot_kws.copy() + diag_kws = {} if diag_kws is None else diag_kws.copy() + grid_kws = {} if grid_kws is None else grid_kws.copy() + + # Resolve "auto" diag kind + if diag_kind == "auto": + if hue is None: + diag_kind = "kde" if kind == "kde" else "hist" + else: + diag_kind = "hist" if kind == "hist" else "kde" + + # Set up the PairGrid + grid_kws.setdefault("diag_sharey", diag_kind == "hist") + grid = PairGrid(data, vars=vars, x_vars=x_vars, y_vars=y_vars, hue=hue, + hue_order=hue_order, palette=palette, corner=corner, + height=height, aspect=aspect, dropna=dropna, **grid_kws) + + # Add the markers here as PairGrid has figured out how many levels of the + # hue variable are needed and we don't want to duplicate that process + if markers is not None: + if kind == "reg": + # Needed until regplot supports style + if grid.hue_names is None: + n_markers = 1 + else: + n_markers = len(grid.hue_names) + if not isinstance(markers, list): + markers = [markers] * n_markers + if len(markers) != n_markers: + raise ValueError(("markers must be a singleton or a list of " + "markers for each level of the hue variable")) + grid.hue_kws = {"marker": markers} + elif kind == "scatter": + if isinstance(markers, str): + plot_kws["marker"] = markers + elif hue is not None: + plot_kws["style"] = data[hue] + plot_kws["markers"] = markers + + # Draw the marginal plots on the diagonal + diag_kws = diag_kws.copy() + diag_kws.setdefault("legend", False) + if diag_kind == "hist": + grid.map_diag(histplot, **diag_kws) + elif diag_kind == "kde": + diag_kws.setdefault("fill", True) + diag_kws.setdefault("warn_singular", False) + grid.map_diag(kdeplot, **diag_kws) + + # Maybe plot on the off-diagonals + if diag_kind is not None: + plotter = grid.map_offdiag + else: + plotter = grid.map + + if kind == "scatter": + from .relational import scatterplot # Avoid circular import + plotter(scatterplot, **plot_kws) + elif kind == "reg": + from .regression import regplot # Avoid circular import + plotter(regplot, **plot_kws) + elif kind == "kde": + from .distributions import kdeplot # Avoid circular import + plot_kws.setdefault("warn_singular", False) + plotter(kdeplot, **plot_kws) + elif kind == "hist": + from .distributions import histplot # Avoid circular import + plotter(histplot, **plot_kws) + + # Add a legend + if hue is not None: + grid.add_legend() + + grid.tight_layout() + + return grid + + +@_deprecate_positional_args +def jointplot( + *, + x=None, y=None, + data=None, + kind="scatter", color=None, height=6, ratio=5, space=.2, + dropna=False, xlim=None, ylim=None, marginal_ticks=False, + joint_kws=None, marginal_kws=None, + hue=None, palette=None, hue_order=None, hue_norm=None, + **kwargs +): + # Avoid circular imports + from .relational import scatterplot + from .regression import regplot, residplot + from .distributions import histplot, kdeplot, _freedman_diaconis_bins + + # Handle deprecations + if "size" in kwargs: + height = kwargs.pop("size") + msg = ("The `size` parameter has been renamed to `height`; " + "please update your code.") + warnings.warn(msg, UserWarning) + + # Set up empty default kwarg dicts + joint_kws = {} if joint_kws is None else joint_kws.copy() + joint_kws.update(kwargs) + marginal_kws = {} if marginal_kws is None else marginal_kws.copy() + + # Handle deprecations of distplot-specific kwargs + distplot_keys = [ + "rug", "fit", "hist_kws", "norm_hist" "hist_kws", "rug_kws", + ] + unused_keys = [] + for key in distplot_keys: + if key in marginal_kws: + unused_keys.append(key) + marginal_kws.pop(key) + if unused_keys and kind != "kde": + msg = ( + "The marginal plotting function has changed to `histplot`," + " which does not accept the following argument(s): {}." + ).format(", ".join(unused_keys)) + warnings.warn(msg, UserWarning) + + # Validate the plot kind + plot_kinds = ["scatter", "hist", "hex", "kde", "reg", "resid"] + _check_argument("kind", plot_kinds, kind) + + # Raise early if using `hue` with a kind that does not support it + if hue is not None and kind in ["hex", "reg", "resid"]: + msg = ( + f"Use of `hue` with `kind='{kind}'` is not currently supported." + ) + raise ValueError(msg) + + # Make a colormap based off the plot color + # (Currently used only for kind="hex") + if color is None: + color = "C0" + color_rgb = mpl.colors.colorConverter.to_rgb(color) + colors = [utils.set_hls_values(color_rgb, l=l) # noqa + for l in np.linspace(1, 0, 12)] + cmap = blend_palette(colors, as_cmap=True) + + # Matplotlib's hexbin plot is not na-robust + if kind == "hex": + dropna = True + + # Initialize the JointGrid object + grid = JointGrid( + data=data, x=x, y=y, hue=hue, + palette=palette, hue_order=hue_order, hue_norm=hue_norm, + dropna=dropna, height=height, ratio=ratio, space=space, + xlim=xlim, ylim=ylim, marginal_ticks=marginal_ticks, + ) + + if grid.hue is not None: + marginal_kws.setdefault("legend", False) + + # Plot the data using the grid + if kind.startswith("scatter"): + + joint_kws.setdefault("color", color) + grid.plot_joint(scatterplot, **joint_kws) + + if grid.hue is None: + marg_func = histplot + else: + marg_func = kdeplot + marginal_kws.setdefault("warn_singular", False) + marginal_kws.setdefault("fill", True) + + marginal_kws.setdefault("color", color) + grid.plot_marginals(marg_func, **marginal_kws) + + elif kind.startswith("hist"): + + # TODO process pair parameters for bins, etc. and pass + # to both jount and marginal plots + + joint_kws.setdefault("color", color) + grid.plot_joint(histplot, **joint_kws) + + marginal_kws.setdefault("kde", False) + marginal_kws.setdefault("color", color) + + marg_x_kws = marginal_kws.copy() + marg_y_kws = marginal_kws.copy() + + pair_keys = "bins", "binwidth", "binrange" + for key in pair_keys: + if isinstance(joint_kws.get(key), tuple): + x_val, y_val = joint_kws[key] + marg_x_kws.setdefault(key, x_val) + marg_y_kws.setdefault(key, y_val) + + histplot(data=data, x=x, hue=hue, **marg_x_kws, ax=grid.ax_marg_x) + histplot(data=data, y=y, hue=hue, **marg_y_kws, ax=grid.ax_marg_y) + + elif kind.startswith("kde"): + + joint_kws.setdefault("color", color) + joint_kws.setdefault("warn_singular", False) + grid.plot_joint(kdeplot, **joint_kws) + + marginal_kws.setdefault("color", color) + if "fill" in joint_kws: + marginal_kws.setdefault("fill", joint_kws["fill"]) + + grid.plot_marginals(kdeplot, **marginal_kws) + + elif kind.startswith("hex"): + + x_bins = min(_freedman_diaconis_bins(grid.x), 50) + y_bins = min(_freedman_diaconis_bins(grid.y), 50) + gridsize = int(np.mean([x_bins, y_bins])) + + joint_kws.setdefault("gridsize", gridsize) + joint_kws.setdefault("cmap", cmap) + grid.plot_joint(plt.hexbin, **joint_kws) + + marginal_kws.setdefault("kde", False) + marginal_kws.setdefault("color", color) + grid.plot_marginals(histplot, **marginal_kws) + + elif kind.startswith("reg"): + + marginal_kws.setdefault("color", color) + marginal_kws.setdefault("kde", True) + grid.plot_marginals(histplot, **marginal_kws) + + joint_kws.setdefault("color", color) + grid.plot_joint(regplot, **joint_kws) + + elif kind.startswith("resid"): + + joint_kws.setdefault("color", color) + grid.plot_joint(residplot, **joint_kws) + + x, y = grid.ax_joint.collections[0].get_offsets().T + marginal_kws.setdefault("color", color) + histplot(x=x, hue=hue, ax=grid.ax_marg_x, **marginal_kws) + histplot(y=y, hue=hue, ax=grid.ax_marg_y, **marginal_kws) + + return grid + + +jointplot.__doc__ = """\ +Draw a plot of two variables with bivariate and univariate graphs. + +This function provides a convenient interface to the :class:`JointGrid` +class, with several canned plot kinds. This is intended to be a fairly +lightweight wrapper; if you need more flexibility, you should use +:class:`JointGrid` directly. + +Parameters +---------- +{params.core.xy} +{params.core.data} +kind : {{ "scatter" | "kde" | "hist" | "hex" | "reg" | "resid" }} + Kind of plot to draw. See the examples for references to the underlying functions. +{params.core.color} +height : numeric + Size of the figure (it will be square). +ratio : numeric + Ratio of joint axes height to marginal axes height. +space : numeric + Space between the joint and marginal axes +dropna : bool + If True, remove observations that are missing from ``x`` and ``y``. +{{x, y}}lim : pairs of numbers + Axis limits to set before plotting. +marginal_ticks : bool + If False, suppress ticks on the count/density axis of the marginal plots. +{{joint, marginal}}_kws : dicts + Additional keyword arguments for the plot components. +{params.core.hue} + Semantic variable that is mapped to determine the color of plot elements. +{params.core.palette} +{params.core.hue_order} +{params.core.hue_norm} +kwargs + Additional keyword arguments are passed to the function used to + draw the plot on the joint Axes, superseding items in the + ``joint_kws`` dictionary. + +Returns +------- +{returns.jointgrid} + +See Also +-------- +{seealso.jointgrid} +{seealso.pairgrid} +{seealso.pairplot} + +Examples +-------- + +.. include:: ../docstrings/jointplot.rst + +""".format( + params=_param_docs, + returns=_core_docs["returns"], + seealso=_core_docs["seealso"], +) diff --git a/grplot_seaborn/categorical.py b/grplot_seaborn/categorical.py new file mode 100644 index 0000000..64cdb63 --- /dev/null +++ b/grplot_seaborn/categorical.py @@ -0,0 +1,4023 @@ +from textwrap import dedent +from numbers import Number +import colorsys +import numpy as np +from scipy import stats +import pandas as pd +import matplotlib as mpl +from matplotlib.collections import PatchCollection +import matplotlib.patches as Patches +import matplotlib.pyplot as plt +import warnings +from distutils.version import LooseVersion + +from ._core import variable_type, infer_orient, categorical_order +from . import utils +from .utils import remove_na +from .algorithms import bootstrap +from .palettes import color_palette, husl_palette, light_palette, dark_palette +from .axisgrid import FacetGrid, _facet_docs +from ._decorators import _deprecate_positional_args + + +__all__ = [ + "catplot", "factorplot", + "stripplot", "swarmplot", + "boxplot", "violinplot", "boxenplot", + "pointplot", "barplot", "countplot", +] + + +class _CategoricalPlotter(object): + + width = .8 + default_palette = "light" + require_numeric = True + + def establish_variables(self, x=None, y=None, hue=None, data=None, + orient=None, order=None, hue_order=None, + units=None): + """Convert input specification into a common representation.""" + # Option 1: + # We are plotting a wide-form dataset + # ----------------------------------- + if x is None and y is None: + + # Do a sanity check on the inputs + if hue is not None: + error = "Cannot use `hue` without `x` and `y`" + raise ValueError(error) + + # No hue grouping with wide inputs + plot_hues = None + hue_title = None + hue_names = None + + # No statistical units with wide inputs + plot_units = None + + # We also won't get a axes labels here + value_label = None + group_label = None + + # Option 1a: + # The input data is a Pandas DataFrame + # ------------------------------------ + + if isinstance(data, pd.DataFrame): + + # Order the data correctly + if order is None: + order = [] + # Reduce to just numeric columns + for col in data: + if variable_type(data[col]) == "numeric": + order.append(col) + plot_data = data[order] + group_names = order + group_label = data.columns.name + + # Convert to a list of arrays, the common representation + iter_data = plot_data.iteritems() + plot_data = [np.asarray(s, float) for k, s in iter_data] + + # Option 1b: + # The input data is an array or list + # ---------------------------------- + + else: + + # We can't reorder the data + if order is not None: + error = "Input data must be a pandas object to reorder" + raise ValueError(error) + + # The input data is an array + if hasattr(data, "shape"): + if len(data.shape) == 1: + if np.isscalar(data[0]): + plot_data = [data] + else: + plot_data = list(data) + elif len(data.shape) == 2: + nr, nc = data.shape + if nr == 1 or nc == 1: + plot_data = [data.ravel()] + else: + plot_data = [data[:, i] for i in range(nc)] + else: + error = ("Input `data` can have no " + "more than 2 dimensions") + raise ValueError(error) + + # Check if `data` is None to let us bail out here (for testing) + elif data is None: + plot_data = [[]] + + # The input data is a flat list + elif np.isscalar(data[0]): + plot_data = [data] + + # The input data is a nested list + # This will catch some things that might fail later + # but exhaustive checks are hard + else: + plot_data = data + + # Convert to a list of arrays, the common representation + plot_data = [np.asarray(d, float) for d in plot_data] + + # The group names will just be numeric indices + group_names = list(range((len(plot_data)))) + + # Figure out the plotting orientation + orient = "h" if str(orient).startswith("h") else "v" + + # Option 2: + # We are plotting a long-form dataset + # ----------------------------------- + + else: + + # See if we need to get variables from `data` + if data is not None: + x = data.get(x, x) + y = data.get(y, y) + hue = data.get(hue, hue) + units = data.get(units, units) + + # Validate the inputs + for var in [x, y, hue, units]: + if isinstance(var, str): + err = "Could not interpret input '{}'".format(var) + raise ValueError(err) + + # Figure out the plotting orientation + orient = infer_orient( + x, y, orient, require_numeric=self.require_numeric + ) + + # Option 2a: + # We are plotting a single set of data + # ------------------------------------ + if x is None or y is None: + + # Determine where the data are + vals = y if x is None else x + + # Put them into the common representation + plot_data = [np.asarray(vals)] + + # Get a label for the value axis + if hasattr(vals, "name"): + value_label = vals.name + else: + value_label = None + + # This plot will not have group labels or hue nesting + groups = None + group_label = None + group_names = [] + plot_hues = None + hue_names = None + hue_title = None + plot_units = None + + # Option 2b: + # We are grouping the data values by another variable + # --------------------------------------------------- + else: + + # Determine which role each variable will play + if orient == "v": + vals, groups = y, x + else: + vals, groups = x, y + + # Get the categorical axis label + group_label = None + if hasattr(groups, "name"): + group_label = groups.name + + # Get the order on the categorical axis + group_names = categorical_order(groups, order) + + # Group the numeric data + plot_data, value_label = self._group_longform(vals, groups, + group_names) + + # Now handle the hue levels for nested ordering + if hue is None: + plot_hues = None + hue_title = None + hue_names = None + else: + + # Get the order of the hue levels + hue_names = categorical_order(hue, hue_order) + + # Group the hue data + plot_hues, hue_title = self._group_longform(hue, groups, + group_names) + + # Now handle the units for nested observations + if units is None: + plot_units = None + else: + plot_units, _ = self._group_longform(units, groups, + group_names) + + # Assign object attributes + # ------------------------ + self.orient = orient + self.plot_data = plot_data + self.group_label = group_label + self.value_label = value_label + self.group_names = group_names + self.plot_hues = plot_hues + self.hue_title = hue_title + self.hue_names = hue_names + self.plot_units = plot_units + + def _group_longform(self, vals, grouper, order): + """Group a long-form variable by another with correct order.""" + # Ensure that the groupby will work + if not isinstance(vals, pd.Series): + if isinstance(grouper, pd.Series): + index = grouper.index + else: + index = None + vals = pd.Series(vals, index=index) + + # Group the val data + grouped_vals = vals.groupby(grouper) + out_data = [] + for g in order: + try: + g_vals = grouped_vals.get_group(g) + except KeyError: + g_vals = np.array([]) + out_data.append(g_vals) + + # Get the vals axis label + label = vals.name + + return out_data, label + + def establish_colors(self, color, palette, saturation): + """Get a list of colors for the main component of the plots.""" + if self.hue_names is None: + n_colors = len(self.plot_data) + else: + n_colors = len(self.hue_names) + + # Determine the main colors + if color is None and palette is None: + # Determine whether the current palette will have enough values + # If not, we'll default to the husl palette so each is distinct + current_palette = utils.get_color_cycle() + if n_colors <= len(current_palette): + colors = color_palette(n_colors=n_colors) + else: + colors = husl_palette(n_colors, l=.7) # noqa + + elif palette is None: + # When passing a specific color, the interpretation depends + # on whether there is a hue variable or not. + # If so, we will make a blend palette so that the different + # levels have some amount of variation. + if self.hue_names is None: + colors = [color] * n_colors + else: + if self.default_palette == "light": + colors = light_palette(color, n_colors) + elif self.default_palette == "dark": + colors = dark_palette(color, n_colors) + else: + raise RuntimeError("No default palette specified") + else: + + # Let `palette` be a dict mapping level to color + if isinstance(palette, dict): + if self.hue_names is None: + levels = self.group_names + else: + levels = self.hue_names + palette = [palette[l] for l in levels] + + colors = color_palette(palette, n_colors) + + # Desaturate a bit because these are patches + if saturation < 1: + colors = color_palette(colors, desat=saturation) + + # Convert the colors to a common representations + rgb_colors = color_palette(colors) + + # Determine the gray color to use for the lines framing the plot + light_vals = [colorsys.rgb_to_hls(*c)[1] for c in rgb_colors] + lum = min(light_vals) * .6 + gray = mpl.colors.rgb2hex((lum, lum, lum)) + + # Assign object attributes + self.colors = rgb_colors + self.gray = gray + + @property + def hue_offsets(self): + """A list of center positions for plots when hue nesting is used.""" + n_levels = len(self.hue_names) + if self.dodge: + each_width = self.width / n_levels + offsets = np.linspace(0, self.width - each_width, n_levels) + offsets -= offsets.mean() + else: + offsets = np.zeros(n_levels) + + return offsets + + @property + def nested_width(self): + """A float with the width of plot elements when hue nesting is used.""" + if self.dodge: + width = self.width / len(self.hue_names) * .98 + else: + width = self.width + return width + + def annotate_axes(self, ax): + """Add descriptive labels to an Axes object.""" + if self.orient == "v": + xlabel, ylabel = self.group_label, self.value_label + else: + xlabel, ylabel = self.value_label, self.group_label + + if xlabel is not None: + ax.set_xlabel(xlabel) + if ylabel is not None: + ax.set_ylabel(ylabel) + + group_names = self.group_names + if not group_names: + group_names = ["" for _ in range(len(self.plot_data))] + + if self.orient == "v": + ax.set_xticks(np.arange(len(self.plot_data))) + ax.set_xticklabels(group_names) + else: + ax.set_yticks(np.arange(len(self.plot_data))) + ax.set_yticklabels(group_names) + + if self.orient == "v": + ax.xaxis.grid(False) + ax.set_xlim(-.5, len(self.plot_data) - .5, auto=None) + else: + ax.yaxis.grid(False) + ax.set_ylim(-.5, len(self.plot_data) - .5, auto=None) + + if self.hue_names is not None: + leg = ax.legend(loc="best", title=self.hue_title) + if self.hue_title is not None: + if LooseVersion(mpl.__version__) < "3.0": + # Old Matplotlib has no legend title size rcparam + try: + title_size = mpl.rcParams["axes.labelsize"] * .85 + except TypeError: # labelsize is something like "large" + title_size = mpl.rcParams["axes.labelsize"] + prop = mpl.font_manager.FontProperties(size=title_size) + leg.set_title(self.hue_title, prop=prop) + + def add_legend_data(self, ax, color, label): + """Add a dummy patch object so we can get legend data.""" + rect = plt.Rectangle([0, 0], 0, 0, + linewidth=self.linewidth / 2, + edgecolor=self.gray, + facecolor=color, + label=label) + ax.add_patch(rect) + + +class _BoxPlotter(_CategoricalPlotter): + + def __init__(self, x, y, hue, data, order, hue_order, + orient, color, palette, saturation, + width, dodge, fliersize, linewidth): + + self.establish_variables(x, y, hue, data, orient, order, hue_order) + self.establish_colors(color, palette, saturation) + + self.dodge = dodge + self.width = width + self.fliersize = fliersize + + if linewidth is None: + linewidth = mpl.rcParams["lines.linewidth"] + self.linewidth = linewidth + + def draw_boxplot(self, ax, kws): + """Use matplotlib to draw a boxplot on an Axes.""" + vert = self.orient == "v" + + props = {} + for obj in ["box", "whisker", "cap", "median", "flier"]: + props[obj] = kws.pop(obj + "props", {}) + + for i, group_data in enumerate(self.plot_data): + + if self.plot_hues is None: + + # Handle case where there is data at this level + if group_data.size == 0: + continue + + # Draw a single box or a set of boxes + # with a single level of grouping + box_data = np.asarray(remove_na(group_data)) + + # Handle case where there is no non-null data + if box_data.size == 0: + continue + + artist_dict = ax.boxplot(box_data, + vert=vert, + patch_artist=True, + positions=[i], + widths=self.width, + **kws) + color = self.colors[i] + self.restyle_boxplot(artist_dict, color, props) + else: + # Draw nested groups of boxes + offsets = self.hue_offsets + for j, hue_level in enumerate(self.hue_names): + + # Add a legend for this hue level + if not i: + self.add_legend_data(ax, self.colors[j], hue_level) + + # Handle case where there is data at this level + if group_data.size == 0: + continue + + hue_mask = self.plot_hues[i] == hue_level + box_data = np.asarray(remove_na(group_data[hue_mask])) + + # Handle case where there is no non-null data + if box_data.size == 0: + continue + + center = i + offsets[j] + artist_dict = ax.boxplot(box_data, + vert=vert, + patch_artist=True, + positions=[center], + widths=self.nested_width, + **kws) + self.restyle_boxplot(artist_dict, self.colors[j], props) + # Add legend data, but just for one set of boxes + + def restyle_boxplot(self, artist_dict, color, props): + """Take a drawn matplotlib boxplot and make it look nice.""" + for box in artist_dict["boxes"]: + box.update(dict(facecolor=color, + zorder=.9, + edgecolor=self.gray, + linewidth=self.linewidth)) + box.update(props["box"]) + for whisk in artist_dict["whiskers"]: + whisk.update(dict(color=self.gray, + linewidth=self.linewidth, + linestyle="-")) + whisk.update(props["whisker"]) + for cap in artist_dict["caps"]: + cap.update(dict(color=self.gray, + linewidth=self.linewidth)) + cap.update(props["cap"]) + for med in artist_dict["medians"]: + med.update(dict(color=self.gray, + linewidth=self.linewidth)) + med.update(props["median"]) + for fly in artist_dict["fliers"]: + fly.update(dict(markerfacecolor=self.gray, + marker="d", + markeredgecolor=self.gray, + markersize=self.fliersize)) + fly.update(props["flier"]) + + def plot(self, ax, boxplot_kws): + """Make the plot.""" + self.draw_boxplot(ax, boxplot_kws) + self.annotate_axes(ax) + if self.orient == "h": + ax.invert_yaxis() + + +class _ViolinPlotter(_CategoricalPlotter): + + def __init__(self, x, y, hue, data, order, hue_order, + bw, cut, scale, scale_hue, gridsize, + width, inner, split, dodge, orient, linewidth, + color, palette, saturation): + + self.establish_variables(x, y, hue, data, orient, order, hue_order) + self.establish_colors(color, palette, saturation) + self.estimate_densities(bw, cut, scale, scale_hue, gridsize) + + self.gridsize = gridsize + self.width = width + self.dodge = dodge + + if inner is not None: + if not any([inner.startswith("quart"), + inner.startswith("box"), + inner.startswith("stick"), + inner.startswith("point")]): + err = "Inner style '{}' not recognized".format(inner) + raise ValueError(err) + self.inner = inner + + if split and self.hue_names is not None and len(self.hue_names) != 2: + msg = "There must be exactly two hue levels to use `split`.'" + raise ValueError(msg) + self.split = split + + if linewidth is None: + linewidth = mpl.rcParams["lines.linewidth"] + self.linewidth = linewidth + + def estimate_densities(self, bw, cut, scale, scale_hue, gridsize): + """Find the support and density for all of the data.""" + # Initialize data structures to keep track of plotting data + if self.hue_names is None: + support = [] + density = [] + counts = np.zeros(len(self.plot_data)) + max_density = np.zeros(len(self.plot_data)) + else: + support = [[] for _ in self.plot_data] + density = [[] for _ in self.plot_data] + size = len(self.group_names), len(self.hue_names) + counts = np.zeros(size) + max_density = np.zeros(size) + + for i, group_data in enumerate(self.plot_data): + + # Option 1: we have a single level of grouping + # -------------------------------------------- + + if self.plot_hues is None: + + # Strip missing datapoints + kde_data = remove_na(group_data) + + # Handle special case of no data at this level + if kde_data.size == 0: + support.append(np.array([])) + density.append(np.array([1.])) + counts[i] = 0 + max_density[i] = 0 + continue + + # Handle special case of a single unique datapoint + elif np.unique(kde_data).size == 1: + support.append(np.unique(kde_data)) + density.append(np.array([1.])) + counts[i] = 1 + max_density[i] = 0 + continue + + # Fit the KDE and get the used bandwidth size + kde, bw_used = self.fit_kde(kde_data, bw) + + # Determine the support grid and get the density over it + support_i = self.kde_support(kde_data, bw_used, cut, gridsize) + density_i = kde.evaluate(support_i) + + # Update the data structures with these results + support.append(support_i) + density.append(density_i) + counts[i] = kde_data.size + max_density[i] = density_i.max() + + # Option 2: we have nested grouping by a hue variable + # --------------------------------------------------- + + else: + for j, hue_level in enumerate(self.hue_names): + + # Handle special case of no data at this category level + if not group_data.size: + support[i].append(np.array([])) + density[i].append(np.array([1.])) + counts[i, j] = 0 + max_density[i, j] = 0 + continue + + # Select out the observations for this hue level + hue_mask = self.plot_hues[i] == hue_level + + # Strip missing datapoints + kde_data = remove_na(group_data[hue_mask]) + + # Handle special case of no data at this level + if kde_data.size == 0: + support[i].append(np.array([])) + density[i].append(np.array([1.])) + counts[i, j] = 0 + max_density[i, j] = 0 + continue + + # Handle special case of a single unique datapoint + elif np.unique(kde_data).size == 1: + support[i].append(np.unique(kde_data)) + density[i].append(np.array([1.])) + counts[i, j] = 1 + max_density[i, j] = 0 + continue + + # Fit the KDE and get the used bandwidth size + kde, bw_used = self.fit_kde(kde_data, bw) + + # Determine the support grid and get the density over it + support_ij = self.kde_support(kde_data, bw_used, + cut, gridsize) + density_ij = kde.evaluate(support_ij) + + # Update the data structures with these results + support[i].append(support_ij) + density[i].append(density_ij) + counts[i, j] = kde_data.size + max_density[i, j] = density_ij.max() + + # Scale the height of the density curve. + # For a violinplot the density is non-quantitative. + # The objective here is to scale the curves relative to 1 so that + # they can be multiplied by the width parameter during plotting. + + if scale == "area": + self.scale_area(density, max_density, scale_hue) + + elif scale == "width": + self.scale_width(density) + + elif scale == "count": + self.scale_count(density, counts, scale_hue) + + else: + raise ValueError("scale method '{}' not recognized".format(scale)) + + # Set object attributes that will be used while plotting + self.support = support + self.density = density + + def fit_kde(self, x, bw): + """Estimate a KDE for a vector of data with flexible bandwidth.""" + kde = stats.gaussian_kde(x, bw) + + # Extract the numeric bandwidth from the KDE object + bw_used = kde.factor + + # At this point, bw will be a numeric scale factor. + # To get the actual bandwidth of the kernel, we multiple by the + # unbiased standard deviation of the data, which we will use + # elsewhere to compute the range of the support. + bw_used = bw_used * x.std(ddof=1) + + return kde, bw_used + + def kde_support(self, x, bw, cut, gridsize): + """Define a grid of support for the violin.""" + support_min = x.min() - bw * cut + support_max = x.max() + bw * cut + return np.linspace(support_min, support_max, gridsize) + + def scale_area(self, density, max_density, scale_hue): + """Scale the relative area under the KDE curve. + + This essentially preserves the "standard" KDE scaling, but the + resulting maximum density will be 1 so that the curve can be + properly multiplied by the violin width. + + """ + if self.hue_names is None: + for d in density: + if d.size > 1: + d /= max_density.max() + else: + for i, group in enumerate(density): + for d in group: + if scale_hue: + max = max_density[i].max() + else: + max = max_density.max() + if d.size > 1: + d /= max + + def scale_width(self, density): + """Scale each density curve to the same height.""" + if self.hue_names is None: + for d in density: + d /= d.max() + else: + for group in density: + for d in group: + d /= d.max() + + def scale_count(self, density, counts, scale_hue): + """Scale each density curve by the number of observations.""" + if self.hue_names is None: + if counts.max() == 0: + d = 0 + else: + for count, d in zip(counts, density): + d /= d.max() + d *= count / counts.max() + else: + for i, group in enumerate(density): + for j, d in enumerate(group): + if counts[i].max() == 0: + d = 0 + else: + count = counts[i, j] + if scale_hue: + scaler = count / counts[i].max() + else: + scaler = count / counts.max() + d /= d.max() + d *= scaler + + @property + def dwidth(self): + + if self.hue_names is None or not self.dodge: + return self.width / 2 + elif self.split: + return self.width / 2 + else: + return self.width / (2 * len(self.hue_names)) + + def draw_violins(self, ax): + """Draw the violins onto `ax`.""" + fill_func = ax.fill_betweenx if self.orient == "v" else ax.fill_between + for i, group_data in enumerate(self.plot_data): + + kws = dict(edgecolor=self.gray, linewidth=self.linewidth) + + # Option 1: we have a single level of grouping + # -------------------------------------------- + + if self.plot_hues is None: + + support, density = self.support[i], self.density[i] + + # Handle special case of no observations in this bin + if support.size == 0: + continue + + # Handle special case of a single observation + elif support.size == 1: + val = support.item() + d = density.item() + self.draw_single_observation(ax, i, val, d) + continue + + # Draw the violin for this group + grid = np.ones(self.gridsize) * i + fill_func(support, + grid - density * self.dwidth, + grid + density * self.dwidth, + facecolor=self.colors[i], + **kws) + + # Draw the interior representation of the data + if self.inner is None: + continue + + # Get a nan-free vector of datapoints + violin_data = remove_na(group_data) + + # Draw box and whisker information + if self.inner.startswith("box"): + self.draw_box_lines(ax, violin_data, support, density, i) + + # Draw quartile lines + elif self.inner.startswith("quart"): + self.draw_quartiles(ax, violin_data, support, density, i) + + # Draw stick observations + elif self.inner.startswith("stick"): + self.draw_stick_lines(ax, violin_data, support, density, i) + + # Draw point observations + elif self.inner.startswith("point"): + self.draw_points(ax, violin_data, i) + + # Option 2: we have nested grouping by a hue variable + # --------------------------------------------------- + + else: + offsets = self.hue_offsets + for j, hue_level in enumerate(self.hue_names): + + support, density = self.support[i][j], self.density[i][j] + kws["facecolor"] = self.colors[j] + + # Add legend data, but just for one set of violins + if not i: + self.add_legend_data(ax, self.colors[j], hue_level) + + # Handle the special case where we have no observations + if support.size == 0: + continue + + # Handle the special case where we have one observation + elif support.size == 1: + val = support.item() + d = density.item() + if self.split: + d = d / 2 + at_group = i + offsets[j] + self.draw_single_observation(ax, at_group, val, d) + continue + + # Option 2a: we are drawing a single split violin + # ----------------------------------------------- + + if self.split: + + grid = np.ones(self.gridsize) * i + if j: + fill_func(support, + grid, + grid + density * self.dwidth, + **kws) + else: + fill_func(support, + grid - density * self.dwidth, + grid, + **kws) + + # Draw the interior representation of the data + if self.inner is None: + continue + + # Get a nan-free vector of datapoints + hue_mask = self.plot_hues[i] == hue_level + violin_data = remove_na(group_data[hue_mask]) + + # Draw quartile lines + if self.inner.startswith("quart"): + self.draw_quartiles(ax, violin_data, + support, density, i, + ["left", "right"][j]) + + # Draw stick observations + elif self.inner.startswith("stick"): + self.draw_stick_lines(ax, violin_data, + support, density, i, + ["left", "right"][j]) + + # The box and point interior plots are drawn for + # all data at the group level, so we just do that once + if not j: + continue + + # Get the whole vector for this group level + violin_data = remove_na(group_data) + + # Draw box and whisker information + if self.inner.startswith("box"): + self.draw_box_lines(ax, violin_data, + support, density, i) + + # Draw point observations + elif self.inner.startswith("point"): + self.draw_points(ax, violin_data, i) + + # Option 2b: we are drawing full nested violins + # ----------------------------------------------- + + else: + grid = np.ones(self.gridsize) * (i + offsets[j]) + fill_func(support, + grid - density * self.dwidth, + grid + density * self.dwidth, + **kws) + + # Draw the interior representation + if self.inner is None: + continue + + # Get a nan-free vector of datapoints + hue_mask = self.plot_hues[i] == hue_level + violin_data = remove_na(group_data[hue_mask]) + + # Draw box and whisker information + if self.inner.startswith("box"): + self.draw_box_lines(ax, violin_data, + support, density, + i + offsets[j]) + + # Draw quartile lines + elif self.inner.startswith("quart"): + self.draw_quartiles(ax, violin_data, + support, density, + i + offsets[j]) + + # Draw stick observations + elif self.inner.startswith("stick"): + self.draw_stick_lines(ax, violin_data, + support, density, + i + offsets[j]) + + # Draw point observations + elif self.inner.startswith("point"): + self.draw_points(ax, violin_data, i + offsets[j]) + + def draw_single_observation(self, ax, at_group, at_quant, density): + """Draw a line to mark a single observation.""" + d_width = density * self.dwidth + if self.orient == "v": + ax.plot([at_group - d_width, at_group + d_width], + [at_quant, at_quant], + color=self.gray, + linewidth=self.linewidth) + else: + ax.plot([at_quant, at_quant], + [at_group - d_width, at_group + d_width], + color=self.gray, + linewidth=self.linewidth) + + def draw_box_lines(self, ax, data, support, density, center): + """Draw boxplot information at center of the density.""" + # Compute the boxplot statistics + q25, q50, q75 = np.percentile(data, [25, 50, 75]) + whisker_lim = 1.5 * stats.iqr(data) + h1 = np.min(data[data >= (q25 - whisker_lim)]) + h2 = np.max(data[data <= (q75 + whisker_lim)]) + + # Draw a boxplot using lines and a point + if self.orient == "v": + ax.plot([center, center], [h1, h2], + linewidth=self.linewidth, + color=self.gray) + ax.plot([center, center], [q25, q75], + linewidth=self.linewidth * 3, + color=self.gray) + ax.scatter(center, q50, + zorder=3, + color="white", + edgecolor=self.gray, + s=np.square(self.linewidth * 2)) + else: + ax.plot([h1, h2], [center, center], + linewidth=self.linewidth, + color=self.gray) + ax.plot([q25, q75], [center, center], + linewidth=self.linewidth * 3, + color=self.gray) + ax.scatter(q50, center, + zorder=3, + color="white", + edgecolor=self.gray, + s=np.square(self.linewidth * 2)) + + def draw_quartiles(self, ax, data, support, density, center, split=False): + """Draw the quartiles as lines at width of density.""" + q25, q50, q75 = np.percentile(data, [25, 50, 75]) + + self.draw_to_density(ax, center, q25, support, density, split, + linewidth=self.linewidth, + dashes=[self.linewidth * 1.5] * 2) + self.draw_to_density(ax, center, q50, support, density, split, + linewidth=self.linewidth, + dashes=[self.linewidth * 3] * 2) + self.draw_to_density(ax, center, q75, support, density, split, + linewidth=self.linewidth, + dashes=[self.linewidth * 1.5] * 2) + + def draw_points(self, ax, data, center): + """Draw individual observations as points at middle of the violin.""" + kws = dict(s=np.square(self.linewidth * 2), + color=self.gray, + edgecolor=self.gray) + + grid = np.ones(len(data)) * center + + if self.orient == "v": + ax.scatter(grid, data, **kws) + else: + ax.scatter(data, grid, **kws) + + def draw_stick_lines(self, ax, data, support, density, + center, split=False): + """Draw individual observations as sticks at width of density.""" + for val in data: + self.draw_to_density(ax, center, val, support, density, split, + linewidth=self.linewidth * .5) + + def draw_to_density(self, ax, center, val, support, density, split, **kws): + """Draw a line orthogonal to the value axis at width of density.""" + idx = np.argmin(np.abs(support - val)) + width = self.dwidth * density[idx] * .99 + + kws["color"] = self.gray + + if self.orient == "v": + if split == "left": + ax.plot([center - width, center], [val, val], **kws) + elif split == "right": + ax.plot([center, center + width], [val, val], **kws) + else: + ax.plot([center - width, center + width], [val, val], **kws) + else: + if split == "left": + ax.plot([val, val], [center - width, center], **kws) + elif split == "right": + ax.plot([val, val], [center, center + width], **kws) + else: + ax.plot([val, val], [center - width, center + width], **kws) + + def plot(self, ax): + """Make the violin plot.""" + self.draw_violins(ax) + self.annotate_axes(ax) + if self.orient == "h": + ax.invert_yaxis() + + +class _CategoricalScatterPlotter(_CategoricalPlotter): + + default_palette = "dark" + require_numeric = False + + @property + def point_colors(self): + """Return an index into the palette for each scatter point.""" + point_colors = [] + for i, group_data in enumerate(self.plot_data): + + # Initialize the array for this group level + group_colors = np.empty(group_data.size, int) + if isinstance(group_data, pd.Series): + group_colors = pd.Series(group_colors, group_data.index) + + if self.plot_hues is None: + + # Use the same color for all points at this level + # group_color = self.colors[i] + group_colors[:] = i + + else: + + # Color the points based on the hue level + + for j, level in enumerate(self.hue_names): + # hue_color = self.colors[j] + if group_data.size: + group_colors[self.plot_hues[i] == level] = j + + point_colors.append(group_colors) + + return point_colors + + def add_legend_data(self, ax): + """Add empty scatterplot artists with labels for the legend.""" + if self.hue_names is not None: + for rgb, label in zip(self.colors, self.hue_names): + ax.scatter([], [], + color=mpl.colors.rgb2hex(rgb), + label=label, + s=60) + + +class _StripPlotter(_CategoricalScatterPlotter): + """1-d scatterplot with categorical organization.""" + def __init__(self, x, y, hue, data, order, hue_order, + jitter, dodge, orient, color, palette): + """Initialize the plotter.""" + self.establish_variables(x, y, hue, data, orient, order, hue_order) + self.establish_colors(color, palette, 1) + + # Set object attributes + self.dodge = dodge + self.width = .8 + + if jitter == 1: # Use a good default for `jitter = True` + jlim = 0.1 + else: + jlim = float(jitter) + if self.hue_names is not None and dodge: + jlim /= len(self.hue_names) + self.jitterer = stats.uniform(-jlim, jlim * 2).rvs + + def draw_stripplot(self, ax, kws): + """Draw the points onto `ax`.""" + palette = np.asarray(self.colors) + for i, group_data in enumerate(self.plot_data): + if self.plot_hues is None or not self.dodge: + + if self.hue_names is None: + hue_mask = np.ones(group_data.size, bool) + else: + hue_mask = np.array([h in self.hue_names + for h in self.plot_hues[i]], bool) + # Broken on older numpys + # hue_mask = np.in1d(self.plot_hues[i], self.hue_names) + + strip_data = group_data[hue_mask] + point_colors = np.asarray(self.point_colors[i][hue_mask]) + + # Plot the points in centered positions + cat_pos = np.ones(strip_data.size) * i + cat_pos += self.jitterer(len(strip_data)) + kws.update(c=palette[point_colors]) + if self.orient == "v": + ax.scatter(cat_pos, strip_data, **kws) + else: + ax.scatter(strip_data, cat_pos, **kws) + + else: + offsets = self.hue_offsets + for j, hue_level in enumerate(self.hue_names): + hue_mask = self.plot_hues[i] == hue_level + strip_data = group_data[hue_mask] + + point_colors = np.asarray(self.point_colors[i][hue_mask]) + + # Plot the points in centered positions + center = i + offsets[j] + cat_pos = np.ones(strip_data.size) * center + cat_pos += self.jitterer(len(strip_data)) + kws.update(c=palette[point_colors]) + if self.orient == "v": + ax.scatter(cat_pos, strip_data, **kws) + else: + ax.scatter(strip_data, cat_pos, **kws) + + def plot(self, ax, kws): + """Make the plot.""" + self.draw_stripplot(ax, kws) + self.add_legend_data(ax) + self.annotate_axes(ax) + if self.orient == "h": + ax.invert_yaxis() + + +class _SwarmPlotter(_CategoricalScatterPlotter): + + def __init__(self, x, y, hue, data, order, hue_order, + dodge, orient, color, palette): + """Initialize the plotter.""" + self.establish_variables(x, y, hue, data, orient, order, hue_order) + self.establish_colors(color, palette, 1) + + # Set object attributes + self.dodge = dodge + self.width = .8 + + def could_overlap(self, xy_i, swarm, d): + """Return a list of all swarm points that could overlap with target. + + Assumes that swarm is a sorted list of all points below xy_i. + """ + _, y_i = xy_i + neighbors = [] + for xy_j in reversed(swarm): + _, y_j = xy_j + if (y_i - y_j) < d: + neighbors.append(xy_j) + else: + break + return np.array(list(reversed(neighbors))) + + def position_candidates(self, xy_i, neighbors, d): + """Return a list of (x, y) coordinates that might be valid.""" + candidates = [xy_i] + x_i, y_i = xy_i + left_first = True + for x_j, y_j in neighbors: + dy = y_i - y_j + dx = np.sqrt(max(d ** 2 - dy ** 2, 0)) * 1.05 + cl, cr = (x_j - dx, y_i), (x_j + dx, y_i) + if left_first: + new_candidates = [cl, cr] + else: + new_candidates = [cr, cl] + candidates.extend(new_candidates) + left_first = not left_first + return np.array(candidates) + + def first_non_overlapping_candidate(self, candidates, neighbors, d): + """Remove candidates from the list if they overlap with the swarm.""" + + # IF we have no neighbours, all candidates are good. + if len(neighbors) == 0: + return candidates[0] + + neighbors_x = neighbors[:, 0] + neighbors_y = neighbors[:, 1] + + d_square = d ** 2 + + for xy_i in candidates: + x_i, y_i = xy_i + + dx = neighbors_x - x_i + dy = neighbors_y - y_i + + sq_distances = np.power(dx, 2.0) + np.power(dy, 2.0) + + # good candidate does not overlap any of neighbors + # which means that squared distance between candidate + # and any of the neighbours has to be at least + # square of the diameter + good_candidate = np.all(sq_distances >= d_square) + + if good_candidate: + return xy_i + + # If `position_candidates` works well + # this should never happen + raise Exception('No non-overlapping candidates found. ' + 'This should not happen.') + + def beeswarm(self, orig_xy, d): + """Adjust x position of points to avoid overlaps.""" + # In this method, ``x`` is always the categorical axis + # Center of the swarm, in point coordinates + midline = orig_xy[0, 0] + + # Start the swarm with the first point + swarm = [orig_xy[0]] + + # Loop over the remaining points + for xy_i in orig_xy[1:]: + + # Find the points in the swarm that could possibly + # overlap with the point we are currently placing + neighbors = self.could_overlap(xy_i, swarm, d) + + # Find positions that would be valid individually + # with respect to each of the swarm neighbors + candidates = self.position_candidates(xy_i, neighbors, d) + + # Sort candidates by their centrality + offsets = np.abs(candidates[:, 0] - midline) + candidates = candidates[np.argsort(offsets)] + + # Find the first candidate that does not overlap any neighbours + new_xy_i = self.first_non_overlapping_candidate(candidates, + neighbors, d) + + # Place it into the swarm + swarm.append(new_xy_i) + + return np.array(swarm) + + def add_gutters(self, points, center, width): + """Stop points from extending beyond their territory.""" + half_width = width / 2 + low_gutter = center - half_width + off_low = points < low_gutter + if off_low.any(): + points[off_low] = low_gutter + high_gutter = center + half_width + off_high = points > high_gutter + if off_high.any(): + points[off_high] = high_gutter + + gutter_prop = (off_high + off_low).sum() / len(points) + if gutter_prop > .05: + msg = ( + "{:.1%} of the points cannot be placed; you may want " + "to decrease the size of the markers or use stripplot." + ).format(gutter_prop) + warnings.warn(msg, UserWarning) + + return points + + def swarm_points(self, ax, points, center, width, s, **kws): + """Find new positions on the categorical axis for each point.""" + # Convert from point size (area) to diameter + default_lw = mpl.rcParams["patch.linewidth"] + lw = kws.get("linewidth", kws.get("lw", default_lw)) + dpi = ax.figure.dpi + d = (np.sqrt(s) + lw) * (dpi / 72) + + # Transform the data coordinates to point coordinates. + # We'll figure out the swarm positions in the latter + # and then convert back to data coordinates and replot + orig_xy = ax.transData.transform(points.get_offsets()) + + # Order the variables so that x is the categorical axis + if self.orient == "h": + orig_xy = orig_xy[:, [1, 0]] + + # Do the beeswarm in point coordinates + new_xy = self.beeswarm(orig_xy, d) + + # Transform the point coordinates back to data coordinates + if self.orient == "h": + new_xy = new_xy[:, [1, 0]] + new_x, new_y = ax.transData.inverted().transform(new_xy).T + + # Add gutters + if self.orient == "v": + self.add_gutters(new_x, center, width) + else: + self.add_gutters(new_y, center, width) + + # Reposition the points so they do not overlap + points.set_offsets(np.c_[new_x, new_y]) + + def draw_swarmplot(self, ax, kws): + """Plot the data.""" + s = kws.pop("s") + + centers = [] + swarms = [] + + palette = np.asarray(self.colors) + + # Set the categorical axes limits here for the swarm math + if self.orient == "v": + ax.set_xlim(-.5, len(self.plot_data) - .5) + else: + ax.set_ylim(-.5, len(self.plot_data) - .5) + + # Plot each swarm + for i, group_data in enumerate(self.plot_data): + + if self.plot_hues is None or not self.dodge: + + width = self.width + + if self.hue_names is None: + hue_mask = np.ones(group_data.size, bool) + else: + hue_mask = np.array([h in self.hue_names + for h in self.plot_hues[i]], bool) + # Broken on older numpys + # hue_mask = np.in1d(self.plot_hues[i], self.hue_names) + + swarm_data = np.asarray(group_data[hue_mask]) + point_colors = np.asarray(self.point_colors[i][hue_mask]) + + # Sort the points for the beeswarm algorithm + sorter = np.argsort(swarm_data) + swarm_data = swarm_data[sorter] + point_colors = point_colors[sorter] + + # Plot the points in centered positions + cat_pos = np.ones(swarm_data.size) * i + kws.update(c=palette[point_colors]) + if self.orient == "v": + points = ax.scatter(cat_pos, swarm_data, s=s, **kws) + else: + points = ax.scatter(swarm_data, cat_pos, s=s, **kws) + + centers.append(i) + swarms.append(points) + + else: + offsets = self.hue_offsets + width = self.nested_width + + for j, hue_level in enumerate(self.hue_names): + hue_mask = self.plot_hues[i] == hue_level + swarm_data = np.asarray(group_data[hue_mask]) + point_colors = np.asarray(self.point_colors[i][hue_mask]) + + # Sort the points for the beeswarm algorithm + sorter = np.argsort(swarm_data) + swarm_data = swarm_data[sorter] + point_colors = point_colors[sorter] + + # Plot the points in centered positions + center = i + offsets[j] + cat_pos = np.ones(swarm_data.size) * center + kws.update(c=palette[point_colors]) + if self.orient == "v": + points = ax.scatter(cat_pos, swarm_data, s=s, **kws) + else: + points = ax.scatter(swarm_data, cat_pos, s=s, **kws) + + centers.append(center) + swarms.append(points) + + # Autoscale the valus axis to set the data/axes transforms properly + ax.autoscale_view(scalex=self.orient == "h", scaley=self.orient == "v") + + # Update the position of each point on the categorical axis + # Do this after plotting so that the numerical axis limits are correct + for center, swarm in zip(centers, swarms): + if swarm.get_offsets().size: + self.swarm_points(ax, swarm, center, width, s, **kws) + + def plot(self, ax, kws): + """Make the full plot.""" + self.draw_swarmplot(ax, kws) + self.add_legend_data(ax) + self.annotate_axes(ax) + if self.orient == "h": + ax.invert_yaxis() + + +class _CategoricalStatPlotter(_CategoricalPlotter): + + require_numeric = True + + @property + def nested_width(self): + """A float with the width of plot elements when hue nesting is used.""" + if self.dodge: + width = self.width / len(self.hue_names) + else: + width = self.width + return width + + def estimate_statistic(self, estimator, ci, n_boot, seed): + + if self.hue_names is None: + statistic = [] + confint = [] + else: + statistic = [[] for _ in self.plot_data] + confint = [[] for _ in self.plot_data] + + for i, group_data in enumerate(self.plot_data): + + # Option 1: we have a single layer of grouping + # -------------------------------------------- + + if self.plot_hues is None: + + if self.plot_units is None: + stat_data = remove_na(group_data) + unit_data = None + else: + unit_data = self.plot_units[i] + have = pd.notnull(np.c_[group_data, unit_data]).all(axis=1) + stat_data = group_data[have] + unit_data = unit_data[have] + + # Estimate a statistic from the vector of data + if not stat_data.size: + statistic.append(np.nan) + else: + statistic.append(estimator(stat_data)) + + # Get a confidence interval for this estimate + if ci is not None: + + if stat_data.size < 2: + confint.append([np.nan, np.nan]) + continue + + if ci == "sd": + + estimate = estimator(stat_data) + sd = np.std(stat_data) + confint.append((estimate - sd, estimate + sd)) + + else: + + boots = bootstrap(stat_data, func=estimator, + n_boot=n_boot, + units=unit_data, + seed=seed) + confint.append(utils.ci(boots, ci)) + + # Option 2: we are grouping by a hue layer + # ---------------------------------------- + + else: + for j, hue_level in enumerate(self.hue_names): + + if not self.plot_hues[i].size: + statistic[i].append(np.nan) + if ci is not None: + confint[i].append((np.nan, np.nan)) + continue + + hue_mask = self.plot_hues[i] == hue_level + if self.plot_units is None: + stat_data = remove_na(group_data[hue_mask]) + unit_data = None + else: + group_units = self.plot_units[i] + have = pd.notnull( + np.c_[group_data, group_units] + ).all(axis=1) + stat_data = group_data[hue_mask & have] + unit_data = group_units[hue_mask & have] + + # Estimate a statistic from the vector of data + if not stat_data.size: + statistic[i].append(np.nan) + else: + statistic[i].append(estimator(stat_data)) + + # Get a confidence interval for this estimate + if ci is not None: + + if stat_data.size < 2: + confint[i].append([np.nan, np.nan]) + continue + + if ci == "sd": + + estimate = estimator(stat_data) + sd = np.std(stat_data) + confint[i].append((estimate - sd, estimate + sd)) + + else: + + boots = bootstrap(stat_data, func=estimator, + n_boot=n_boot, + units=unit_data, + seed=seed) + confint[i].append(utils.ci(boots, ci)) + + # Save the resulting values for plotting + self.statistic = np.array(statistic) + self.confint = np.array(confint) + + def draw_confints(self, ax, at_group, confint, colors, + errwidth=None, capsize=None, **kws): + + if errwidth is not None: + kws.setdefault("lw", errwidth) + else: + kws.setdefault("lw", mpl.rcParams["lines.linewidth"] * 1.8) + + for at, (ci_low, ci_high), color in zip(at_group, + confint, + colors): + if self.orient == "v": + ax.plot([at, at], [ci_low, ci_high], color=color, **kws) + if capsize is not None: + ax.plot([at - capsize / 2, at + capsize / 2], + [ci_low, ci_low], color=color, **kws) + ax.plot([at - capsize / 2, at + capsize / 2], + [ci_high, ci_high], color=color, **kws) + else: + ax.plot([ci_low, ci_high], [at, at], color=color, **kws) + if capsize is not None: + ax.plot([ci_low, ci_low], + [at - capsize / 2, at + capsize / 2], + color=color, **kws) + ax.plot([ci_high, ci_high], + [at - capsize / 2, at + capsize / 2], + color=color, **kws) + + +class _BarPlotter(_CategoricalStatPlotter): + """Show point estimates and confidence intervals with bars.""" + + def __init__(self, x, y, hue, data, order, hue_order, + estimator, ci, n_boot, units, seed, + orient, color, palette, saturation, errcolor, + errwidth, capsize, dodge): + """Initialize the plotter.""" + self.establish_variables(x, y, hue, data, orient, + order, hue_order, units) + self.establish_colors(color, palette, saturation) + self.estimate_statistic(estimator, ci, n_boot, seed) + + self.dodge = dodge + + self.errcolor = errcolor + self.errwidth = errwidth + self.capsize = capsize + + def draw_bars(self, ax, kws): + """Draw the bars onto `ax`.""" + # Get the right matplotlib function depending on the orientation + barfunc = ax.bar if self.orient == "v" else ax.barh + barpos = np.arange(len(self.statistic)) + + if self.plot_hues is None: + + # Draw the bars + barfunc(barpos, self.statistic, self.width, + color=self.colors, align="center", **kws) + + # Draw the confidence intervals + errcolors = [self.errcolor] * len(barpos) + self.draw_confints(ax, + barpos, + self.confint, + errcolors, + self.errwidth, + self.capsize) + + else: + + for j, hue_level in enumerate(self.hue_names): + + # Draw the bars + offpos = barpos + self.hue_offsets[j] + barfunc(offpos, self.statistic[:, j], self.nested_width, + color=self.colors[j], align="center", + label=hue_level, **kws) + + # Draw the confidence intervals + if self.confint.size: + confint = self.confint[:, j] + errcolors = [self.errcolor] * len(offpos) + self.draw_confints(ax, + offpos, + confint, + errcolors, + self.errwidth, + self.capsize) + + def plot(self, ax, bar_kws): + """Make the plot.""" + self.draw_bars(ax, bar_kws) + self.annotate_axes(ax) + if self.orient == "h": + ax.invert_yaxis() + + +class _PointPlotter(_CategoricalStatPlotter): + + default_palette = "dark" + + """Show point estimates and confidence intervals with (joined) points.""" + def __init__(self, x, y, hue, data, order, hue_order, + estimator, ci, n_boot, units, seed, + markers, linestyles, dodge, join, scale, + orient, color, palette, errwidth=None, capsize=None): + """Initialize the plotter.""" + self.establish_variables(x, y, hue, data, orient, + order, hue_order, units) + self.establish_colors(color, palette, 1) + self.estimate_statistic(estimator, ci, n_boot, seed) + + # Override the default palette for single-color plots + if hue is None and color is None and palette is None: + self.colors = [color_palette()[0]] * len(self.colors) + + # Don't join single-layer plots with different colors + if hue is None and palette is not None: + join = False + + # Use a good default for `dodge=True` + if dodge is True and self.hue_names is not None: + dodge = .025 * len(self.hue_names) + + # Make sure we have a marker for each hue level + if isinstance(markers, str): + markers = [markers] * len(self.colors) + self.markers = markers + + # Make sure we have a line style for each hue level + if isinstance(linestyles, str): + linestyles = [linestyles] * len(self.colors) + self.linestyles = linestyles + + # Set the other plot components + self.dodge = dodge + self.join = join + self.scale = scale + self.errwidth = errwidth + self.capsize = capsize + + @property + def hue_offsets(self): + """Offsets relative to the center position for each hue level.""" + if self.dodge: + offset = np.linspace(0, self.dodge, len(self.hue_names)) + offset -= offset.mean() + else: + offset = np.zeros(len(self.hue_names)) + return offset + + def draw_points(self, ax): + """Draw the main data components of the plot.""" + # Get the center positions on the categorical axis + pointpos = np.arange(len(self.statistic)) + + # Get the size of the plot elements + lw = mpl.rcParams["lines.linewidth"] * 1.8 * self.scale + mew = lw * .75 + markersize = np.pi * np.square(lw) * 2 + + if self.plot_hues is None: + + # Draw lines joining each estimate point + if self.join: + color = self.colors[0] + ls = self.linestyles[0] + if self.orient == "h": + ax.plot(self.statistic, pointpos, + color=color, ls=ls, lw=lw) + else: + ax.plot(pointpos, self.statistic, + color=color, ls=ls, lw=lw) + + # Draw the confidence intervals + self.draw_confints(ax, pointpos, self.confint, self.colors, + self.errwidth, self.capsize) + + # Draw the estimate points + marker = self.markers[0] + colors = [mpl.colors.colorConverter.to_rgb(c) for c in self.colors] + if self.orient == "h": + x, y = self.statistic, pointpos + else: + x, y = pointpos, self.statistic + ax.scatter(x, y, + linewidth=mew, marker=marker, s=markersize, + facecolor=colors, edgecolor=colors) + + else: + + offsets = self.hue_offsets + for j, hue_level in enumerate(self.hue_names): + + # Determine the values to plot for this level + statistic = self.statistic[:, j] + + # Determine the position on the categorical and z axes + offpos = pointpos + offsets[j] + z = j + 1 + + # Draw lines joining each estimate point + if self.join: + color = self.colors[j] + ls = self.linestyles[j] + if self.orient == "h": + ax.plot(statistic, offpos, color=color, + zorder=z, ls=ls, lw=lw) + else: + ax.plot(offpos, statistic, color=color, + zorder=z, ls=ls, lw=lw) + + # Draw the confidence intervals + if self.confint.size: + confint = self.confint[:, j] + errcolors = [self.colors[j]] * len(offpos) + self.draw_confints(ax, offpos, confint, errcolors, + self.errwidth, self.capsize, + zorder=z) + + # Draw the estimate points + n_points = len(remove_na(offpos)) + marker = self.markers[j] + color = mpl.colors.colorConverter.to_rgb(self.colors[j]) + + if self.orient == "h": + x, y = statistic, offpos + else: + x, y = offpos, statistic + + if not len(remove_na(statistic)): + x = y = [np.nan] * n_points + + ax.scatter(x, y, label=hue_level, + facecolor=color, edgecolor=color, + linewidth=mew, marker=marker, s=markersize, + zorder=z) + + def plot(self, ax): + """Make the plot.""" + self.draw_points(ax) + self.annotate_axes(ax) + if self.orient == "h": + ax.invert_yaxis() + + +class _CountPlotter(_BarPlotter): + require_numeric = False + + +class _LVPlotter(_CategoricalPlotter): + + def __init__(self, x, y, hue, data, order, hue_order, + orient, color, palette, saturation, + width, dodge, k_depth, linewidth, scale, outlier_prop, + trust_alpha, showfliers=True): + + self.width = width + self.dodge = dodge + self.saturation = saturation + + k_depth_methods = ['proportion', 'tukey', 'trustworthy', 'full'] + if not (k_depth in k_depth_methods or isinstance(k_depth, Number)): + msg = (f'k_depth must be one of {k_depth_methods} or a number, ' + f'but {k_depth} was passed.') + raise ValueError(msg) + self.k_depth = k_depth + + if linewidth is None: + linewidth = mpl.rcParams["lines.linewidth"] + self.linewidth = linewidth + + scales = ['linear', 'exponential', 'area'] + if scale not in scales: + msg = f'scale must be one of {scales}, but {scale} was passed.' + raise ValueError(msg) + self.scale = scale + + if ((outlier_prop > 1) or (outlier_prop <= 0)): + msg = f'outlier_prop {outlier_prop} not in range (0, 1]' + raise ValueError(msg) + self.outlier_prop = outlier_prop + + if not 0 < trust_alpha < 1: + msg = f'trust_alpha {trust_alpha} not in range (0, 1)' + raise ValueError(msg) + self.trust_alpha = trust_alpha + + self.showfliers = showfliers + + self.establish_variables(x, y, hue, data, orient, order, hue_order) + self.establish_colors(color, palette, saturation) + + def _lv_box_ends(self, vals): + """Get the number of data points and calculate `depth` of + letter-value plot.""" + vals = np.asarray(vals) + # Remove infinite values while handling a 'object' dtype + # that can come from pd.Float64Dtype() input + with pd.option_context('mode.use_inf_as_null', True): + vals = vals[~pd.isnull(vals)] + n = len(vals) + p = self.outlier_prop + + # Select the depth, i.e. number of boxes to draw, based on the method + if self.k_depth == 'full': + # extend boxes to 100% of the data + k = int(np.log2(n)) + 1 + elif self.k_depth == 'tukey': + # This results with 5-8 points in each tail + k = int(np.log2(n)) - 3 + elif self.k_depth == 'proportion': + k = int(np.log2(n)) - int(np.log2(n * p)) + 1 + elif self.k_depth == 'trustworthy': + point_conf = 2 * stats.norm.ppf((1 - self.trust_alpha / 2)) ** 2 + k = int(np.log2(n / point_conf)) + 1 + else: + k = int(self.k_depth) # allow having k as input + # If the number happens to be less than 1, set k to 1 + if k < 1: + k = 1 + + # Calculate the upper end for each of the k boxes + upper = [100 * (1 - 0.5 ** (i + 1)) for i in range(k, 0, -1)] + # Calculate the lower end for each of the k boxes + lower = [100 * (0.5 ** (i + 1)) for i in range(k, 0, -1)] + # Stitch the box ends together + percentile_ends = [(i, j) for i, j in zip(lower, upper)] + box_ends = [np.percentile(vals, q) for q in percentile_ends] + return box_ends, k + + def _lv_outliers(self, vals, k): + """Find the outliers based on the letter value depth.""" + box_edge = 0.5 ** (k + 1) + perc_ends = (100 * box_edge, 100 * (1 - box_edge)) + edges = np.percentile(vals, perc_ends) + lower_out = vals[np.where(vals < edges[0])[0]] + upper_out = vals[np.where(vals > edges[1])[0]] + return np.concatenate((lower_out, upper_out)) + + def _width_functions(self, width_func): + # Dictionary of functions for computing the width of the boxes + width_functions = {'linear': lambda h, i, k: (i + 1.) / k, + 'exponential': lambda h, i, k: 2**(-k + i - 1), + 'area': lambda h, i, k: (1 - 2**(-k + i - 2)) / h} + return width_functions[width_func] + + def _lvplot(self, box_data, positions, + color=[255. / 256., 185. / 256., 0.], + widths=1, ax=None, **kws): + + vert = self.orient == "v" + x = positions[0] + box_data = np.asarray(box_data) + + # If we only have one data point, plot a line + if len(box_data) == 1: + kws.update({ + 'color': self.gray, 'linestyle': '-', 'linewidth': self.linewidth + }) + ys = [box_data[0], box_data[0]] + xs = [x - widths / 2, x + widths / 2] + if vert: + xx, yy = xs, ys + else: + xx, yy = ys, xs + ax.plot(xx, yy, **kws) + else: + # Get the number of data points and calculate "depth" of + # letter-value plot + box_ends, k = self._lv_box_ends(box_data) + + # Anonymous functions for calculating the width and height + # of the letter value boxes + width = self._width_functions(self.scale) + + # Function to find height of boxes + def height(b): + return b[1] - b[0] + + # Functions to construct the letter value boxes + def vert_perc_box(x, b, i, k, w): + rect = Patches.Rectangle((x - widths * w / 2, b[0]), + widths * w, + height(b), fill=True) + return rect + + def horz_perc_box(x, b, i, k, w): + rect = Patches.Rectangle((b[0], x - widths * w / 2), + height(b), widths * w, + fill=True) + return rect + + # Scale the width of the boxes so the biggest starts at 1 + w_area = np.array([width(height(b), i, k) + for i, b in enumerate(box_ends)]) + w_area = w_area / np.max(w_area) + + # Calculate the medians + y = np.median(box_data) + + # Calculate the outliers and plot (only if showfliers == True) + outliers = [] + if self.showfliers: + outliers = self._lv_outliers(box_data, k) + hex_color = mpl.colors.rgb2hex(color) + + if vert: + box_func = vert_perc_box + xs_median = [x - widths / 2, x + widths / 2] + ys_median = [y, y] + xs_outliers = np.full(len(outliers), x) + ys_outliers = outliers + + else: + box_func = horz_perc_box + xs_median = [y, y] + ys_median = [x - widths / 2, x + widths / 2] + xs_outliers = outliers + ys_outliers = np.full(len(outliers), x) + + boxes = [box_func(x, b[0], i, k, b[1]) + for i, b in enumerate(zip(box_ends, w_area))] + + # Plot the medians + ax.plot( + xs_median, + ys_median, + c=".15", + alpha=0.45, + solid_capstyle="butt", + linewidth=self.linewidth, + **kws + ) + + # Plot outliers (if any) + if len(outliers) > 0: + ax.scatter(xs_outliers, ys_outliers, marker='d', + c=self.gray, **kws) + + # Construct a color map from the input color + rgb = [hex_color, (1, 1, 1)] + cmap = mpl.colors.LinearSegmentedColormap.from_list('new_map', rgb) + # Make sure that the last boxes contain hue and are not pure white + rgb = [hex_color, cmap(.85)] + cmap = mpl.colors.LinearSegmentedColormap.from_list('new_map', rgb) + collection = PatchCollection( + boxes, cmap=cmap, edgecolor=self.gray, linewidth=self.linewidth + ) + + # Set the color gradation, first box will have color=hex_color + collection.set_array(np.array(np.linspace(1, 0, len(boxes)))) + + # Plot the boxes + ax.add_collection(collection) + + def draw_letter_value_plot(self, ax, kws): + """Use matplotlib to draw a letter value plot on an Axes.""" + for i, group_data in enumerate(self.plot_data): + + if self.plot_hues is None: + + # Handle case where there is data at this level + if group_data.size == 0: + continue + + # Draw a single box or a set of boxes + # with a single level of grouping + box_data = remove_na(group_data) + + # Handle case where there is no non-null data + if box_data.size == 0: + continue + + color = self.colors[i] + + self._lvplot(box_data, + positions=[i], + color=color, + widths=self.width, + ax=ax, + **kws) + + else: + # Draw nested groups of boxes + offsets = self.hue_offsets + for j, hue_level in enumerate(self.hue_names): + + # Add a legend for this hue level + if not i: + self.add_legend_data(ax, self.colors[j], hue_level) + + # Handle case where there is data at this level + if group_data.size == 0: + continue + + hue_mask = self.plot_hues[i] == hue_level + box_data = remove_na(group_data[hue_mask]) + + # Handle case where there is no non-null data + if box_data.size == 0: + continue + + color = self.colors[j] + center = i + offsets[j] + self._lvplot(box_data, + positions=[center], + color=color, + widths=self.nested_width, + ax=ax, + **kws) + + # Autoscale the values axis to make sure all patches are visible + ax.autoscale_view(scalex=self.orient == "h", scaley=self.orient == "v") + + def plot(self, ax, boxplot_kws): + """Make the plot.""" + self.draw_letter_value_plot(ax, boxplot_kws) + self.annotate_axes(ax) + if self.orient == "h": + ax.invert_yaxis() + + +_categorical_docs = dict( + + # Shared narrative docs + categorical_narrative=dedent("""\ + This function always treats one of the variables as categorical and + draws data at ordinal positions (0, 1, ... n) on the relevant axis, even + when the data has a numeric or date type. + + See the :ref:`tutorial ` for more information.\ + """), + main_api_narrative=dedent("""\ + + Input data can be passed in a variety of formats, including: + + - Vectors of data represented as lists, numpy arrays, or pandas Series + objects passed directly to the ``x``, ``y``, and/or ``hue`` parameters. + - A "long-form" DataFrame, in which case the ``x``, ``y``, and ``hue`` + variables will determine how the data are plotted. + - A "wide-form" DataFrame, such that each numeric column will be plotted. + - An array or list of vectors. + + In most cases, it is possible to use numpy or Python objects, but pandas + objects are preferable because the associated names will be used to + annotate the axes. Additionally, you can use Categorical types for the + grouping variables to control the order of plot elements.\ + """), + + # Shared function parameters + input_params=dedent("""\ + x, y, hue : names of variables in ``data`` or vector data, optional + Inputs for plotting long-form data. See examples for interpretation.\ + """), + string_input_params=dedent("""\ + x, y, hue : names of variables in ``data`` + Inputs for plotting long-form data. See examples for interpretation.\ + """), + categorical_data=dedent("""\ + data : DataFrame, array, or list of arrays, optional + Dataset for plotting. If ``x`` and ``y`` are absent, this is + interpreted as wide-form. Otherwise it is expected to be long-form.\ + """), + long_form_data=dedent("""\ + data : DataFrame + Long-form (tidy) dataset for plotting. Each column should correspond + to a variable, and each row should correspond to an observation.\ + """), + order_vars=dedent("""\ + order, hue_order : lists of strings, optional + Order to plot the categorical levels in, otherwise the levels are + inferred from the data objects.\ + """), + stat_api_params=dedent("""\ + estimator : callable that maps vector -> scalar, optional + Statistical function to estimate within each categorical bin. + ci : float or "sd" or None, optional + Size of confidence intervals to draw around estimated values. If + "sd", skip bootstrapping and draw the standard deviation of the + observations. If ``None``, no bootstrapping will be performed, and + error bars will not be drawn. + n_boot : int, optional + Number of bootstrap iterations to use when computing confidence + intervals. + units : name of variable in ``data`` or vector data, optional + Identifier of sampling units, which will be used to perform a + multilevel bootstrap and account for repeated measures design. + seed : int, numpy.random.Generator, or numpy.random.RandomState, optional + Seed or random number generator for reproducible bootstrapping.\ + """), + orient=dedent("""\ + orient : "v" | "h", optional + Orientation of the plot (vertical or horizontal). This is usually + inferred based on the type of the input variables, but it can be used + to resolve ambiguity when both `x` and `y` are numeric or when + plotting wide-form data.\ + """), + color=dedent("""\ + color : matplotlib color, optional + Color for all of the elements, or seed for a gradient palette.\ + """), + palette=dedent("""\ + palette : palette name, list, or dict, optional + Color palette that maps either the grouping variable or the hue + variable. If the palette is a dictionary, keys should be names of + levels and values should be matplotlib colors.\ + """), + saturation=dedent("""\ + saturation : float, optional + Proportion of the original saturation to draw colors at. Large patches + often look better with slightly desaturated colors, but set this to + ``1`` if you want the plot colors to perfectly match the input color + spec.\ + """), + capsize=dedent("""\ + capsize : float, optional + Width of the "caps" on error bars. + """), + errwidth=dedent("""\ + errwidth : float, optional + Thickness of error bar lines (and caps).\ + """), + width=dedent("""\ + width : float, optional + Width of a full element when not using hue nesting, or width of all the + elements for one level of the major grouping variable.\ + """), + dodge=dedent("""\ + dodge : bool, optional + When hue nesting is used, whether elements should be shifted along the + categorical axis.\ + """), + linewidth=dedent("""\ + linewidth : float, optional + Width of the gray lines that frame the plot elements.\ + """), + ax_in=dedent("""\ + ax : matplotlib Axes, optional + Axes object to draw the plot onto, otherwise uses the current Axes.\ + """), + ax_out=dedent("""\ + ax : matplotlib Axes + Returns the Axes object with the plot drawn onto it.\ + """), + + # Shared see also + boxplot=dedent("""\ + boxplot : A traditional box-and-whisker plot with a similar API.\ + """), + violinplot=dedent("""\ + violinplot : A combination of boxplot and kernel density estimation.\ + """), + stripplot=dedent("""\ + stripplot : A scatterplot where one variable is categorical. Can be used + in conjunction with other plots to show each observation.\ + """), + swarmplot=dedent("""\ + swarmplot : A categorical scatterplot where the points do not overlap. Can + be used with other plots to show each observation.\ + """), + barplot=dedent("""\ + barplot : Show point estimates and confidence intervals using bars.\ + """), + countplot=dedent("""\ + countplot : Show the counts of observations in each categorical bin.\ + """), + pointplot=dedent("""\ + pointplot : Show point estimates and confidence intervals using scatterplot + glyphs.\ + """), + catplot=dedent("""\ + catplot : Combine a categorical plot with a :class:`FacetGrid`.\ + """), + boxenplot=dedent("""\ + boxenplot : An enhanced boxplot for larger datasets.\ + """), + +) + +_categorical_docs.update(_facet_docs) + + +@_deprecate_positional_args +def boxplot( + *, + x=None, y=None, + hue=None, data=None, + order=None, hue_order=None, + orient=None, color=None, palette=None, saturation=.75, + width=.8, dodge=True, fliersize=5, linewidth=None, + whis=1.5, ax=None, + **kwargs +): + + plotter = _BoxPlotter(x, y, hue, data, order, hue_order, + orient, color, palette, saturation, + width, dodge, fliersize, linewidth) + + if ax is None: + ax = plt.gca() + kwargs.update(dict(whis=whis)) + + plotter.plot(ax, kwargs) + return ax + + +boxplot.__doc__ = dedent("""\ + Draw a box plot to show distributions with respect to categories. + + A box plot (or box-and-whisker plot) shows the distribution of quantitative + data in a way that facilitates comparisons between variables or across + levels of a categorical variable. The box shows the quartiles of the + dataset while the whiskers extend to show the rest of the distribution, + except for points that are determined to be "outliers" using a method + that is a function of the inter-quartile range. + + {main_api_narrative} + + {categorical_narrative} + + Parameters + ---------- + {input_params} + {categorical_data} + {order_vars} + {orient} + {color} + {palette} + {saturation} + {width} + {dodge} + fliersize : float, optional + Size of the markers used to indicate outlier observations. + {linewidth} + whis : float, optional + Proportion of the IQR past the low and high quartiles to extend the + plot whiskers. Points outside this range will be identified as + outliers. + {ax_in} + kwargs : key, value mappings + Other keyword arguments are passed through to + :meth:`matplotlib.axes.Axes.boxplot`. + + Returns + ------- + {ax_out} + + See Also + -------- + {violinplot} + {stripplot} + {swarmplot} + {catplot} + + Examples + -------- + + Draw a single horizontal boxplot: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns + >>> sns.set_theme(style="whitegrid") + >>> tips = sns.load_dataset("tips") + >>> ax = sns.boxplot(x=tips["total_bill"]) + + Draw a vertical boxplot grouped by a categorical variable: + + .. plot:: + :context: close-figs + + >>> ax = sns.boxplot(x="day", y="total_bill", data=tips) + + Draw a boxplot with nested grouping by two categorical variables: + + .. plot:: + :context: close-figs + + >>> ax = sns.boxplot(x="day", y="total_bill", hue="smoker", + ... data=tips, palette="Set3") + + Draw a boxplot with nested grouping when some bins are empty: + + .. plot:: + :context: close-figs + + >>> ax = sns.boxplot(x="day", y="total_bill", hue="time", + ... data=tips, linewidth=2.5) + + Control box order by passing an explicit order: + + .. plot:: + :context: close-figs + + >>> ax = sns.boxplot(x="time", y="tip", data=tips, + ... order=["Dinner", "Lunch"]) + + Draw a boxplot for each numeric variable in a DataFrame: + + .. plot:: + :context: close-figs + + >>> iris = sns.load_dataset("iris") + >>> ax = sns.boxplot(data=iris, orient="h", palette="Set2") + + Use ``hue`` without changing box position or width: + + .. plot:: + :context: close-figs + + >>> tips["weekend"] = tips["day"].isin(["Sat", "Sun"]) + >>> ax = sns.boxplot(x="day", y="total_bill", hue="weekend", + ... data=tips, dodge=False) + + Use :func:`swarmplot` to show the datapoints on top of the boxes: + + .. plot:: + :context: close-figs + + >>> ax = sns.boxplot(x="day", y="total_bill", data=tips) + >>> ax = sns.swarmplot(x="day", y="total_bill", data=tips, color=".25") + + Use :func:`catplot` to combine a :func:`boxplot` and a + :class:`FacetGrid`. This allows grouping within additional categorical + variables. Using :func:`catplot` is safer than using :class:`FacetGrid` + directly, as it ensures synchronization of variable order across facets: + + .. plot:: + :context: close-figs + + >>> g = sns.catplot(x="sex", y="total_bill", + ... hue="smoker", col="time", + ... data=tips, kind="box", + ... height=4, aspect=.7); + + """).format(**_categorical_docs) + + +@_deprecate_positional_args +def violinplot( + *, + x=None, y=None, + hue=None, data=None, + order=None, hue_order=None, + bw="scott", cut=2, scale="area", scale_hue=True, gridsize=100, + width=.8, inner="box", split=False, dodge=True, orient=None, + linewidth=None, color=None, palette=None, saturation=.75, + ax=None, **kwargs, +): + + plotter = _ViolinPlotter(x, y, hue, data, order, hue_order, + bw, cut, scale, scale_hue, gridsize, + width, inner, split, dodge, orient, linewidth, + color, palette, saturation) + + if ax is None: + ax = plt.gca() + + plotter.plot(ax) + return ax + + +violinplot.__doc__ = dedent("""\ + Draw a combination of boxplot and kernel density estimate. + + A violin plot plays a similar role as a box and whisker plot. It shows the + distribution of quantitative data across several levels of one (or more) + categorical variables such that those distributions can be compared. Unlike + a box plot, in which all of the plot components correspond to actual + datapoints, the violin plot features a kernel density estimation of the + underlying distribution. + + This can be an effective and attractive way to show multiple distributions + of data at once, but keep in mind that the estimation procedure is + influenced by the sample size, and violins for relatively small samples + might look misleadingly smooth. + + {main_api_narrative} + + {categorical_narrative} + + Parameters + ---------- + {input_params} + {categorical_data} + {order_vars} + bw : {{'scott', 'silverman', float}}, optional + Either the name of a reference rule or the scale factor to use when + computing the kernel bandwidth. The actual kernel size will be + determined by multiplying the scale factor by the standard deviation of + the data within each bin. + cut : float, optional + Distance, in units of bandwidth size, to extend the density past the + extreme datapoints. Set to 0 to limit the violin range within the range + of the observed data (i.e., to have the same effect as ``trim=True`` in + ``ggplot``. + scale : {{"area", "count", "width"}}, optional + The method used to scale the width of each violin. If ``area``, each + violin will have the same area. If ``count``, the width of the violins + will be scaled by the number of observations in that bin. If ``width``, + each violin will have the same width. + scale_hue : bool, optional + When nesting violins using a ``hue`` variable, this parameter + determines whether the scaling is computed within each level of the + major grouping variable (``scale_hue=True``) or across all the violins + on the plot (``scale_hue=False``). + gridsize : int, optional + Number of points in the discrete grid used to compute the kernel + density estimate. + {width} + inner : {{"box", "quartile", "point", "stick", None}}, optional + Representation of the datapoints in the violin interior. If ``box``, + draw a miniature boxplot. If ``quartiles``, draw the quartiles of the + distribution. If ``point`` or ``stick``, show each underlying + datapoint. Using ``None`` will draw unadorned violins. + split : bool, optional + When using hue nesting with a variable that takes two levels, setting + ``split`` to True will draw half of a violin for each level. This can + make it easier to directly compare the distributions. + {dodge} + {orient} + {linewidth} + {color} + {palette} + {saturation} + {ax_in} + + Returns + ------- + {ax_out} + + See Also + -------- + {boxplot} + {stripplot} + {swarmplot} + {catplot} + + Examples + -------- + + Draw a single horizontal violinplot: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns + >>> sns.set_theme(style="whitegrid") + >>> tips = sns.load_dataset("tips") + >>> ax = sns.violinplot(x=tips["total_bill"]) + + Draw a vertical violinplot grouped by a categorical variable: + + .. plot:: + :context: close-figs + + >>> ax = sns.violinplot(x="day", y="total_bill", data=tips) + + Draw a violinplot with nested grouping by two categorical variables: + + .. plot:: + :context: close-figs + + >>> ax = sns.violinplot(x="day", y="total_bill", hue="smoker", + ... data=tips, palette="muted") + + Draw split violins to compare the across the hue variable: + + .. plot:: + :context: close-figs + + >>> ax = sns.violinplot(x="day", y="total_bill", hue="smoker", + ... data=tips, palette="muted", split=True) + + Control violin order by passing an explicit order: + + .. plot:: + :context: close-figs + + >>> ax = sns.violinplot(x="time", y="tip", data=tips, + ... order=["Dinner", "Lunch"]) + + Scale the violin width by the number of observations in each bin: + + .. plot:: + :context: close-figs + + >>> ax = sns.violinplot(x="day", y="total_bill", hue="sex", + ... data=tips, palette="Set2", split=True, + ... scale="count") + + Draw the quartiles as horizontal lines instead of a mini-box: + + .. plot:: + :context: close-figs + + >>> ax = sns.violinplot(x="day", y="total_bill", hue="sex", + ... data=tips, palette="Set2", split=True, + ... scale="count", inner="quartile") + + Show each observation with a stick inside the violin: + + .. plot:: + :context: close-figs + + >>> ax = sns.violinplot(x="day", y="total_bill", hue="sex", + ... data=tips, palette="Set2", split=True, + ... scale="count", inner="stick") + + Scale the density relative to the counts across all bins: + + .. plot:: + :context: close-figs + + >>> ax = sns.violinplot(x="day", y="total_bill", hue="sex", + ... data=tips, palette="Set2", split=True, + ... scale="count", inner="stick", scale_hue=False) + + Use a narrow bandwidth to reduce the amount of smoothing: + + .. plot:: + :context: close-figs + + >>> ax = sns.violinplot(x="day", y="total_bill", hue="sex", + ... data=tips, palette="Set2", split=True, + ... scale="count", inner="stick", + ... scale_hue=False, bw=.2) + + Draw horizontal violins: + + .. plot:: + :context: close-figs + + >>> planets = sns.load_dataset("planets") + >>> ax = sns.violinplot(x="orbital_period", y="method", + ... data=planets[planets.orbital_period < 1000], + ... scale="width", palette="Set3") + + Don't let density extend past extreme values in the data: + + .. plot:: + :context: close-figs + + >>> ax = sns.violinplot(x="orbital_period", y="method", + ... data=planets[planets.orbital_period < 1000], + ... cut=0, scale="width", palette="Set3") + + Use ``hue`` without changing violin position or width: + + .. plot:: + :context: close-figs + + >>> tips["weekend"] = tips["day"].isin(["Sat", "Sun"]) + >>> ax = sns.violinplot(x="day", y="total_bill", hue="weekend", + ... data=tips, dodge=False) + + Use :func:`catplot` to combine a :func:`violinplot` and a + :class:`FacetGrid`. This allows grouping within additional categorical + variables. Using :func:`catplot` is safer than using :class:`FacetGrid` + directly, as it ensures synchronization of variable order across facets: + + .. plot:: + :context: close-figs + + >>> g = sns.catplot(x="sex", y="total_bill", + ... hue="smoker", col="time", + ... data=tips, kind="violin", split=True, + ... height=4, aspect=.7); + + """).format(**_categorical_docs) + + +@_deprecate_positional_args +def boxenplot( + *, + x=None, y=None, + hue=None, data=None, + order=None, hue_order=None, + orient=None, color=None, palette=None, saturation=.75, + width=.8, dodge=True, k_depth='tukey', linewidth=None, + scale='exponential', outlier_prop=0.007, trust_alpha=0.05, showfliers=True, + ax=None, **kwargs +): + + plotter = _LVPlotter(x, y, hue, data, order, hue_order, + orient, color, palette, saturation, + width, dodge, k_depth, linewidth, scale, + outlier_prop, trust_alpha, showfliers) + + if ax is None: + ax = plt.gca() + + plotter.plot(ax, kwargs) + return ax + + +boxenplot.__doc__ = dedent("""\ + Draw an enhanced box plot for larger datasets. + + This style of plot was originally named a "letter value" plot because it + shows a large number of quantiles that are defined as "letter values". It + is similar to a box plot in plotting a nonparametric representation of a + distribution in which all features correspond to actual observations. By + plotting more quantiles, it provides more information about the shape of + the distribution, particularly in the tails. For a more extensive + explanation, you can read the paper that introduced the plot: + + https://vita.had.co.nz/papers/letter-value-plot.html + + {main_api_narrative} + + {categorical_narrative} + + Parameters + ---------- + {input_params} + {categorical_data} + {order_vars} + {orient} + {color} + {palette} + {saturation} + {width} + {dodge} + k_depth : {{"tukey", "proportion", "trustworthy", "full"}} or scalar,\ + optional + The number of boxes, and by extension number of percentiles, to draw. + All methods are detailed in Wickham's paper. Each makes different + assumptions about the number of outliers and leverages different + statistical properties. If "proportion", draw no more than + `outlier_prop` extreme observations. If "full", draw `log(n)+1` boxes. + {linewidth} + scale : {{"exponential", "linear", "area"}}, optional + Method to use for the width of the letter value boxes. All give similar + results visually. "linear" reduces the width by a constant linear + factor, "exponential" uses the proportion of data not covered, "area" + is proportional to the percentage of data covered. + outlier_prop : float, optional + Proportion of data believed to be outliers. Must be in the range + (0, 1]. Used to determine the number of boxes to plot when + `k_depth="proportion"`. + trust_alpha : float, optional + Confidence level for a box to be plotted. Used to determine the + number of boxes to plot when `k_depth="trustworthy"`. Must be in the + range (0, 1). + showfliers : bool, optional + If False, suppress the plotting of outliers. + {ax_in} + kwargs : key, value mappings + Other keyword arguments are passed through to + :meth:`matplotlib.axes.Axes.plot` and + :meth:`matplotlib.axes.Axes.scatter`. + + Returns + ------- + {ax_out} + + See Also + -------- + {violinplot} + {boxplot} + {catplot} + + Examples + -------- + + Draw a single horizontal boxen plot: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns + >>> sns.set_theme(style="whitegrid") + >>> tips = sns.load_dataset("tips") + >>> ax = sns.boxenplot(x=tips["total_bill"]) + + Draw a vertical boxen plot grouped by a categorical variable: + + .. plot:: + :context: close-figs + + >>> ax = sns.boxenplot(x="day", y="total_bill", data=tips) + + Draw a letter value plot with nested grouping by two categorical variables: + + .. plot:: + :context: close-figs + + >>> ax = sns.boxenplot(x="day", y="total_bill", hue="smoker", + ... data=tips, palette="Set3") + + Draw a boxen plot with nested grouping when some bins are empty: + + .. plot:: + :context: close-figs + + >>> ax = sns.boxenplot(x="day", y="total_bill", hue="time", + ... data=tips, linewidth=2.5) + + Control box order by passing an explicit order: + + .. plot:: + :context: close-figs + + >>> ax = sns.boxenplot(x="time", y="tip", data=tips, + ... order=["Dinner", "Lunch"]) + + Draw a boxen plot for each numeric variable in a DataFrame: + + .. plot:: + :context: close-figs + + >>> iris = sns.load_dataset("iris") + >>> ax = sns.boxenplot(data=iris, orient="h", palette="Set2") + + Use :func:`stripplot` to show the datapoints on top of the boxes: + + .. plot:: + :context: close-figs + + >>> ax = sns.boxenplot(x="day", y="total_bill", data=tips, + ... showfliers=False) + >>> ax = sns.stripplot(x="day", y="total_bill", data=tips, + ... size=4, color=".26") + + Use :func:`catplot` to combine :func:`boxenplot` and a :class:`FacetGrid`. + This allows grouping within additional categorical variables. Using + :func:`catplot` is safer than using :class:`FacetGrid` directly, as it + ensures synchronization of variable order across facets: + + .. plot:: + :context: close-figs + + >>> g = sns.catplot(x="sex", y="total_bill", + ... hue="smoker", col="time", + ... data=tips, kind="boxen", + ... height=4, aspect=.7); + + """).format(**_categorical_docs) + + +@_deprecate_positional_args +def stripplot( + *, + x=None, y=None, + hue=None, data=None, + order=None, hue_order=None, + jitter=True, dodge=False, orient=None, color=None, palette=None, + size=5, edgecolor="gray", linewidth=0, ax=None, + **kwargs +): + + if "split" in kwargs: + dodge = kwargs.pop("split") + msg = "The `split` parameter has been renamed to `dodge`." + warnings.warn(msg, UserWarning) + + plotter = _StripPlotter(x, y, hue, data, order, hue_order, + jitter, dodge, orient, color, palette) + if ax is None: + ax = plt.gca() + + kwargs.setdefault("zorder", 3) + size = kwargs.get("s", size) + if linewidth is None: + linewidth = size / 10 + if edgecolor == "gray": + edgecolor = plotter.gray + kwargs.update(dict(s=size ** 2, + edgecolor=edgecolor, + linewidth=linewidth)) + + plotter.plot(ax, kwargs) + return ax + + +stripplot.__doc__ = dedent("""\ + Draw a scatterplot where one variable is categorical. + + A strip plot can be drawn on its own, but it is also a good complement + to a box or violin plot in cases where you want to show all observations + along with some representation of the underlying distribution. + + {main_api_narrative} + + {categorical_narrative} + + Parameters + ---------- + {input_params} + {categorical_data} + {order_vars} + jitter : float, ``True``/``1`` is special-cased, optional + Amount of jitter (only along the categorical axis) to apply. This + can be useful when you have many points and they overlap, so that + it is easier to see the distribution. You can specify the amount + of jitter (half the width of the uniform random variable support), + or just use ``True`` for a good default. + dodge : bool, optional + When using ``hue`` nesting, setting this to ``True`` will separate + the strips for different hue levels along the categorical axis. + Otherwise, the points for each level will be plotted on top of + each other. + {orient} + {color} + {palette} + size : float, optional + Radius of the markers, in points. + edgecolor : matplotlib color, "gray" is special-cased, optional + Color of the lines around each point. If you pass ``"gray"``, the + brightness is determined by the color palette used for the body + of the points. + {linewidth} + {ax_in} + kwargs : key, value mappings + Other keyword arguments are passed through to + :meth:`matplotlib.axes.Axes.scatter`. + + Returns + ------- + {ax_out} + + See Also + -------- + {swarmplot} + {boxplot} + {violinplot} + {catplot} + + Examples + -------- + + Draw a single horizontal strip plot: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns + >>> sns.set_theme(style="whitegrid") + >>> tips = sns.load_dataset("tips") + >>> ax = sns.stripplot(x=tips["total_bill"]) + + Group the strips by a categorical variable: + + .. plot:: + :context: close-figs + + >>> ax = sns.stripplot(x="day", y="total_bill", data=tips) + + Use a smaller amount of jitter: + + .. plot:: + :context: close-figs + + >>> ax = sns.stripplot(x="day", y="total_bill", data=tips, jitter=0.05) + + Draw horizontal strips: + + .. plot:: + :context: close-figs + + >>> ax = sns.stripplot(x="total_bill", y="day", data=tips) + + Draw outlines around the points: + + .. plot:: + :context: close-figs + + >>> ax = sns.stripplot(x="total_bill", y="day", data=tips, + ... linewidth=1) + + Nest the strips within a second categorical variable: + + .. plot:: + :context: close-figs + + >>> ax = sns.stripplot(x="sex", y="total_bill", hue="day", data=tips) + + Draw each level of the ``hue`` variable at different locations on the + major categorical axis: + + .. plot:: + :context: close-figs + + >>> ax = sns.stripplot(x="day", y="total_bill", hue="smoker", + ... data=tips, palette="Set2", dodge=True) + + Control strip order by passing an explicit order: + + .. plot:: + :context: close-figs + + >>> ax = sns.stripplot(x="time", y="tip", data=tips, + ... order=["Dinner", "Lunch"]) + + Draw strips with large points and different aesthetics: + + .. plot:: + :context: close-figs + + >>> ax = sns.stripplot(x="day", y="total_bill", hue="smoker", + ... data=tips, palette="Set2", size=20, marker="D", + ... edgecolor="gray", alpha=.25) + + Draw strips of observations on top of a box plot: + + .. plot:: + :context: close-figs + + >>> import numpy as np + >>> ax = sns.boxplot(x="tip", y="day", data=tips, whis=np.inf) + >>> ax = sns.stripplot(x="tip", y="day", data=tips, color=".3") + + Draw strips of observations on top of a violin plot: + + .. plot:: + :context: close-figs + + >>> ax = sns.violinplot(x="day", y="total_bill", data=tips, + ... inner=None, color=".8") + >>> ax = sns.stripplot(x="day", y="total_bill", data=tips) + + Use :func:`catplot` to combine a :func:`stripplot` and a + :class:`FacetGrid`. This allows grouping within additional categorical + variables. Using :func:`catplot` is safer than using :class:`FacetGrid` + directly, as it ensures synchronization of variable order across facets: + + .. plot:: + :context: close-figs + + >>> g = sns.catplot(x="sex", y="total_bill", + ... hue="smoker", col="time", + ... data=tips, kind="strip", + ... height=4, aspect=.7); + + """).format(**_categorical_docs) + + +@_deprecate_positional_args +def swarmplot( + *, + x=None, y=None, + hue=None, data=None, + order=None, hue_order=None, + dodge=False, orient=None, color=None, palette=None, + size=5, edgecolor="gray", linewidth=0, ax=None, + **kwargs +): + + if "split" in kwargs: + dodge = kwargs.pop("split") + msg = "The `split` parameter has been renamed to `dodge`." + warnings.warn(msg, UserWarning) + + plotter = _SwarmPlotter(x, y, hue, data, order, hue_order, + dodge, orient, color, palette) + if ax is None: + ax = plt.gca() + + kwargs.setdefault("zorder", 3) + size = kwargs.get("s", size) + if linewidth is None: + linewidth = size / 10 + if edgecolor == "gray": + edgecolor = plotter.gray + kwargs.update(dict(s=size ** 2, + edgecolor=edgecolor, + linewidth=linewidth)) + + plotter.plot(ax, kwargs) + return ax + + +swarmplot.__doc__ = dedent("""\ + Draw a categorical scatterplot with non-overlapping points. + + This function is similar to :func:`stripplot`, but the points are adjusted + (only along the categorical axis) so that they don't overlap. This gives a + better representation of the distribution of values, but it does not scale + well to large numbers of observations. This style of plot is sometimes + called a "beeswarm". + + A swarm plot can be drawn on its own, but it is also a good complement + to a box or violin plot in cases where you want to show all observations + along with some representation of the underlying distribution. + + Arranging the points properly requires an accurate transformation between + data and point coordinates. This means that non-default axis limits must + be set *before* drawing the plot. + + {main_api_narrative} + + {categorical_narrative} + + Parameters + ---------- + {input_params} + {categorical_data} + {order_vars} + dodge : bool, optional + When using ``hue`` nesting, setting this to ``True`` will separate + the strips for different hue levels along the categorical axis. + Otherwise, the points for each level will be plotted in one swarm. + {orient} + {color} + {palette} + size : float, optional + Radius of the markers, in points. + edgecolor : matplotlib color, "gray" is special-cased, optional + Color of the lines around each point. If you pass ``"gray"``, the + brightness is determined by the color palette used for the body + of the points. + {linewidth} + {ax_in} + kwargs : key, value mappings + Other keyword arguments are passed through to + :meth:`matplotlib.axes.Axes.scatter`. + + Returns + ------- + {ax_out} + + See Also + -------- + {boxplot} + {violinplot} + {stripplot} + {catplot} + + Examples + -------- + + Draw a single horizontal swarm plot: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns + >>> sns.set_theme(style="whitegrid") + >>> tips = sns.load_dataset("tips") + >>> ax = sns.swarmplot(x=tips["total_bill"]) + + Group the swarms by a categorical variable: + + .. plot:: + :context: close-figs + + >>> ax = sns.swarmplot(x="day", y="total_bill", data=tips) + + Draw horizontal swarms: + + .. plot:: + :context: close-figs + + >>> ax = sns.swarmplot(x="total_bill", y="day", data=tips) + + Color the points using a second categorical variable: + + .. plot:: + :context: close-figs + + >>> ax = sns.swarmplot(x="day", y="total_bill", hue="sex", data=tips) + + Split each level of the ``hue`` variable along the categorical axis: + + .. plot:: + :context: close-figs + + >>> ax = sns.swarmplot(x="day", y="total_bill", hue="smoker", + ... data=tips, palette="Set2", dodge=True) + + Control swarm order by passing an explicit order: + + .. plot:: + :context: close-figs + + >>> ax = sns.swarmplot(x="time", y="total_bill", data=tips, + ... order=["Dinner", "Lunch"]) + + Plot using larger points: + + .. plot:: + :context: close-figs + + >>> ax = sns.swarmplot(x="time", y="total_bill", data=tips, size=6) + + Draw swarms of observations on top of a box plot: + + .. plot:: + :context: close-figs + + >>> ax = sns.boxplot(x="total_bill", y="day", data=tips, whis=np.inf) + >>> ax = sns.swarmplot(x="total_bill", y="day", data=tips, color=".2") + + Draw swarms of observations on top of a violin plot: + + .. plot:: + :context: close-figs + + >>> ax = sns.violinplot(x="day", y="total_bill", data=tips, inner=None) + >>> ax = sns.swarmplot(x="day", y="total_bill", data=tips, + ... color="white", edgecolor="gray") + + Use :func:`catplot` to combine a :func:`swarmplot` and a + :class:`FacetGrid`. This allows grouping within additional categorical + variables. Using :func:`catplot` is safer than using :class:`FacetGrid` + directly, as it ensures synchronization of variable order across facets: + + .. plot:: + :context: close-figs + + >>> g = sns.catplot(x="sex", y="total_bill", + ... hue="smoker", col="time", + ... data=tips, kind="swarm", + ... height=4, aspect=.7); + + """).format(**_categorical_docs) + + +@_deprecate_positional_args +def barplot( + *, + x=None, y=None, + hue=None, data=None, + order=None, hue_order=None, + estimator=np.mean, ci=95, n_boot=1000, units=None, seed=None, + orient=None, color=None, palette=None, saturation=.75, + errcolor=".26", errwidth=None, capsize=None, dodge=True, + ax=None, + **kwargs, +): + + plotter = _BarPlotter(x, y, hue, data, order, hue_order, + estimator, ci, n_boot, units, seed, + orient, color, palette, saturation, + errcolor, errwidth, capsize, dodge) + + if ax is None: + ax = plt.gca() + + plotter.plot(ax, kwargs) + return ax + + +barplot.__doc__ = dedent("""\ + Show point estimates and confidence intervals as rectangular bars. + + A bar plot represents an estimate of central tendency for a numeric + variable with the height of each rectangle and provides some indication of + the uncertainty around that estimate using error bars. Bar plots include 0 + in the quantitative axis range, and they are a good choice when 0 is a + meaningful value for the quantitative variable, and you want to make + comparisons against it. + + For datasets where 0 is not a meaningful value, a point plot will allow you + to focus on differences between levels of one or more categorical + variables. + + It is also important to keep in mind that a bar plot shows only the mean + (or other estimator) value, but in many cases it may be more informative to + show the distribution of values at each level of the categorical variables. + In that case, other approaches such as a box or violin plot may be more + appropriate. + + {main_api_narrative} + + {categorical_narrative} + + Parameters + ---------- + {input_params} + {categorical_data} + {order_vars} + {stat_api_params} + {orient} + {color} + {palette} + {saturation} + errcolor : matplotlib color + Color for the lines that represent the confidence interval. + {errwidth} + {capsize} + {dodge} + {ax_in} + kwargs : key, value mappings + Other keyword arguments are passed through to + :meth:`matplotlib.axes.Axes.bar`. + + Returns + ------- + {ax_out} + + See Also + -------- + {countplot} + {pointplot} + {catplot} + + Examples + -------- + + Draw a set of vertical bar plots grouped by a categorical variable: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns + >>> sns.set_theme(style="whitegrid") + >>> tips = sns.load_dataset("tips") + >>> ax = sns.barplot(x="day", y="total_bill", data=tips) + + Draw a set of vertical bars with nested grouping by a two variables: + + .. plot:: + :context: close-figs + + >>> ax = sns.barplot(x="day", y="total_bill", hue="sex", data=tips) + + Draw a set of horizontal bars: + + .. plot:: + :context: close-figs + + >>> ax = sns.barplot(x="tip", y="day", data=tips) + + Control bar order by passing an explicit order: + + .. plot:: + :context: close-figs + + >>> ax = sns.barplot(x="time", y="tip", data=tips, + ... order=["Dinner", "Lunch"]) + + Use median as the estimate of central tendency: + + .. plot:: + :context: close-figs + + >>> from numpy import median + >>> ax = sns.barplot(x="day", y="tip", data=tips, estimator=median) + + Show the standard error of the mean with the error bars: + + .. plot:: + :context: close-figs + + >>> ax = sns.barplot(x="day", y="tip", data=tips, ci=68) + + Show standard deviation of observations instead of a confidence interval: + + .. plot:: + :context: close-figs + + >>> ax = sns.barplot(x="day", y="tip", data=tips, ci="sd") + + Add "caps" to the error bars: + + .. plot:: + :context: close-figs + + >>> ax = sns.barplot(x="day", y="tip", data=tips, capsize=.2) + + Use a different color palette for the bars: + + .. plot:: + :context: close-figs + + >>> ax = sns.barplot(x="size", y="total_bill", data=tips, + ... palette="Blues_d") + + Use ``hue`` without changing bar position or width: + + .. plot:: + :context: close-figs + + >>> tips["weekend"] = tips["day"].isin(["Sat", "Sun"]) + >>> ax = sns.barplot(x="day", y="total_bill", hue="weekend", + ... data=tips, dodge=False) + + Plot all bars in a single color: + + .. plot:: + :context: close-figs + + >>> ax = sns.barplot(x="size", y="total_bill", data=tips, + ... color="salmon", saturation=.5) + + Use :meth:`matplotlib.axes.Axes.bar` parameters to control the style. + + .. plot:: + :context: close-figs + + >>> ax = sns.barplot(x="day", y="total_bill", data=tips, + ... linewidth=2.5, facecolor=(1, 1, 1, 0), + ... errcolor=".2", edgecolor=".2") + + Use :func:`catplot` to combine a :func:`barplot` and a :class:`FacetGrid`. + This allows grouping within additional categorical variables. Using + :func:`catplot` is safer than using :class:`FacetGrid` directly, as it + ensures synchronization of variable order across facets: + + .. plot:: + :context: close-figs + + >>> g = sns.catplot(x="sex", y="total_bill", + ... hue="smoker", col="time", + ... data=tips, kind="bar", + ... height=4, aspect=.7); + + """).format(**_categorical_docs) + + +@_deprecate_positional_args +def pointplot( + *, + x=None, y=None, + hue=None, data=None, + order=None, hue_order=None, + estimator=np.mean, ci=95, n_boot=1000, units=None, seed=None, + markers="o", linestyles="-", dodge=False, join=True, scale=1, + orient=None, color=None, palette=None, errwidth=None, + capsize=None, ax=None, + **kwargs +): + + plotter = _PointPlotter(x, y, hue, data, order, hue_order, + estimator, ci, n_boot, units, seed, + markers, linestyles, dodge, join, scale, + orient, color, palette, errwidth, capsize) + + if ax is None: + ax = plt.gca() + + plotter.plot(ax) + return ax + + +pointplot.__doc__ = dedent("""\ + Show point estimates and confidence intervals using scatter plot glyphs. + + A point plot represents an estimate of central tendency for a numeric + variable by the position of scatter plot points and provides some + indication of the uncertainty around that estimate using error bars. + + Point plots can be more useful than bar plots for focusing comparisons + between different levels of one or more categorical variables. They are + particularly adept at showing interactions: how the relationship between + levels of one categorical variable changes across levels of a second + categorical variable. The lines that join each point from the same ``hue`` + level allow interactions to be judged by differences in slope, which is + easier for the eyes than comparing the heights of several groups of points + or bars. + + It is important to keep in mind that a point plot shows only the mean (or + other estimator) value, but in many cases it may be more informative to + show the distribution of values at each level of the categorical variables. + In that case, other approaches such as a box or violin plot may be more + appropriate. + + {main_api_narrative} + + {categorical_narrative} + + Parameters + ---------- + {input_params} + {categorical_data} + {order_vars} + {stat_api_params} + markers : string or list of strings, optional + Markers to use for each of the ``hue`` levels. + linestyles : string or list of strings, optional + Line styles to use for each of the ``hue`` levels. + dodge : bool or float, optional + Amount to separate the points for each level of the ``hue`` variable + along the categorical axis. + join : bool, optional + If ``True``, lines will be drawn between point estimates at the same + ``hue`` level. + scale : float, optional + Scale factor for the plot elements. + {orient} + {color} + {palette} + {errwidth} + {capsize} + {ax_in} + + Returns + ------- + {ax_out} + + See Also + -------- + {barplot} + {catplot} + + Examples + -------- + + Draw a set of vertical point plots grouped by a categorical variable: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns + >>> sns.set_theme(style="darkgrid") + >>> tips = sns.load_dataset("tips") + >>> ax = sns.pointplot(x="time", y="total_bill", data=tips) + + Draw a set of vertical points with nested grouping by a two variables: + + .. plot:: + :context: close-figs + + >>> ax = sns.pointplot(x="time", y="total_bill", hue="smoker", + ... data=tips) + + Separate the points for different hue levels along the categorical axis: + + .. plot:: + :context: close-figs + + >>> ax = sns.pointplot(x="time", y="total_bill", hue="smoker", + ... data=tips, dodge=True) + + Use a different marker and line style for the hue levels: + + .. plot:: + :context: close-figs + + >>> ax = sns.pointplot(x="time", y="total_bill", hue="smoker", + ... data=tips, + ... markers=["o", "x"], + ... linestyles=["-", "--"]) + + Draw a set of horizontal points: + + .. plot:: + :context: close-figs + + >>> ax = sns.pointplot(x="tip", y="day", data=tips) + + Don't draw a line connecting each point: + + .. plot:: + :context: close-figs + + >>> ax = sns.pointplot(x="tip", y="day", data=tips, join=False) + + Use a different color for a single-layer plot: + + .. plot:: + :context: close-figs + + >>> ax = sns.pointplot(x="time", y="total_bill", data=tips, + ... color="#bb3f3f") + + Use a different color palette for the points: + + .. plot:: + :context: close-figs + + >>> ax = sns.pointplot(x="time", y="total_bill", hue="smoker", + ... data=tips, palette="Set2") + + Control point order by passing an explicit order: + + .. plot:: + :context: close-figs + + >>> ax = sns.pointplot(x="time", y="tip", data=tips, + ... order=["Dinner", "Lunch"]) + + Use median as the estimate of central tendency: + + .. plot:: + :context: close-figs + + >>> from numpy import median + >>> ax = sns.pointplot(x="day", y="tip", data=tips, estimator=median) + + Show the standard error of the mean with the error bars: + + .. plot:: + :context: close-figs + + >>> ax = sns.pointplot(x="day", y="tip", data=tips, ci=68) + + Show standard deviation of observations instead of a confidence interval: + + .. plot:: + :context: close-figs + + >>> ax = sns.pointplot(x="day", y="tip", data=tips, ci="sd") + + Add "caps" to the error bars: + + .. plot:: + :context: close-figs + + >>> ax = sns.pointplot(x="day", y="tip", data=tips, capsize=.2) + + Use :func:`catplot` to combine a :func:`pointplot` and a + :class:`FacetGrid`. This allows grouping within additional categorical + variables. Using :func:`catplot` is safer than using :class:`FacetGrid` + directly, as it ensures synchronization of variable order across facets: + + .. plot:: + :context: close-figs + + >>> g = sns.catplot(x="sex", y="total_bill", + ... hue="smoker", col="time", + ... data=tips, kind="point", + ... dodge=True, + ... height=4, aspect=.7); + + """).format(**_categorical_docs) + + +@_deprecate_positional_args +def countplot( + *, + x=None, y=None, + hue=None, data=None, + order=None, hue_order=None, + orient=None, color=None, palette=None, saturation=.75, + dodge=True, ax=None, **kwargs +): + + estimator = len + ci = None + n_boot = 0 + units = None + seed = None + errcolor = None + errwidth = None + capsize = None + + if x is None and y is not None: + orient = "h" + x = y + elif y is None and x is not None: + orient = "v" + y = x + elif x is not None and y is not None: + raise ValueError("Cannot pass values for both `x` and `y`") + + plotter = _CountPlotter( + x, y, hue, data, order, hue_order, + estimator, ci, n_boot, units, seed, + orient, color, palette, saturation, + errcolor, errwidth, capsize, dodge + ) + + plotter.value_label = "count" + + if ax is None: + ax = plt.gca() + + plotter.plot(ax, kwargs) + return ax + + +countplot.__doc__ = dedent("""\ + Show the counts of observations in each categorical bin using bars. + + A count plot can be thought of as a histogram across a categorical, instead + of quantitative, variable. The basic API and options are identical to those + for :func:`barplot`, so you can compare counts across nested variables. + + {main_api_narrative} + + {categorical_narrative} + + Parameters + ---------- + {input_params} + {categorical_data} + {order_vars} + {orient} + {color} + {palette} + {saturation} + {dodge} + {ax_in} + kwargs : key, value mappings + Other keyword arguments are passed through to + :meth:`matplotlib.axes.Axes.bar`. + + Returns + ------- + {ax_out} + + See Also + -------- + {barplot} + {catplot} + + Examples + -------- + + Show value counts for a single categorical variable: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns + >>> sns.set_theme(style="darkgrid") + >>> titanic = sns.load_dataset("titanic") + >>> ax = sns.countplot(x="class", data=titanic) + + Show value counts for two categorical variables: + + .. plot:: + :context: close-figs + + >>> ax = sns.countplot(x="class", hue="who", data=titanic) + + Plot the bars horizontally: + + .. plot:: + :context: close-figs + + >>> ax = sns.countplot(y="class", hue="who", data=titanic) + + Use a different color palette: + + .. plot:: + :context: close-figs + + >>> ax = sns.countplot(x="who", data=titanic, palette="Set3") + + Use :meth:`matplotlib.axes.Axes.bar` parameters to control the style. + + .. plot:: + :context: close-figs + + >>> ax = sns.countplot(x="who", data=titanic, + ... facecolor=(0, 0, 0, 0), + ... linewidth=5, + ... edgecolor=sns.color_palette("dark", 3)) + + Use :func:`catplot` to combine a :func:`countplot` and a + :class:`FacetGrid`. This allows grouping within additional categorical + variables. Using :func:`catplot` is safer than using :class:`FacetGrid` + directly, as it ensures synchronization of variable order across facets: + + .. plot:: + :context: close-figs + + >>> g = sns.catplot(x="class", hue="who", col="survived", + ... data=titanic, kind="count", + ... height=4, aspect=.7); + + """).format(**_categorical_docs) + + +def factorplot(*args, **kwargs): + """Deprecated; please use `catplot` instead.""" + + msg = ( + "The `factorplot` function has been renamed to `catplot`. The " + "original name will be removed in a future release. Please update " + "your code. Note that the default `kind` in `factorplot` (`'point'`) " + "has changed `'strip'` in `catplot`." + ) + warnings.warn(msg) + + if "size" in kwargs: + kwargs["height"] = kwargs.pop("size") + msg = ("The `size` parameter has been renamed to `height`; " + "please update your code.") + warnings.warn(msg, UserWarning) + + kwargs.setdefault("kind", "point") + + return catplot(*args, **kwargs) + + +@_deprecate_positional_args +def catplot( + *, + x=None, y=None, + hue=None, data=None, + row=None, col=None, # TODO move in front of data when * is enforced + col_wrap=None, estimator=np.mean, ci=95, n_boot=1000, + units=None, seed=None, order=None, hue_order=None, row_order=None, + col_order=None, kind="strip", height=5, aspect=1, + orient=None, color=None, palette=None, + legend=True, legend_out=True, sharex=True, sharey=True, + margin_titles=False, facet_kws=None, + **kwargs +): + + # Handle deprecations + if "size" in kwargs: + height = kwargs.pop("size") + msg = ("The `size` parameter has been renamed to `height`; " + "please update your code.") + warnings.warn(msg, UserWarning) + + # Determine the plotting function + try: + plot_func = globals()[kind + "plot"] + except KeyError: + err = "Plot kind '{}' is not recognized".format(kind) + raise ValueError(err) + + # Alias the input variables to determine categorical order and palette + # correctly in the case of a count plot + if kind == "count": + if x is None and y is not None: + x_, y_, orient = y, y, "h" + elif y is None and x is not None: + x_, y_, orient = x, x, "v" + else: + raise ValueError("Either `x` or `y` must be None for kind='count'") + else: + x_, y_ = x, y + + # Check for attempt to plot onto specific axes and warn + if "ax" in kwargs: + msg = ("catplot is a figure-level function and does not accept " + "target axes. You may wish to try {}".format(kind + "plot")) + warnings.warn(msg, UserWarning) + kwargs.pop("ax") + + # Determine the order for the whole dataset, which will be used in all + # facets to ensure representation of all data in the final plot + plotter_class = { + "box": _BoxPlotter, + "violin": _ViolinPlotter, + "boxen": _LVPlotter, + "bar": _BarPlotter, + "point": _PointPlotter, + "strip": _StripPlotter, + "swarm": _SwarmPlotter, + "count": _CountPlotter, + }[kind] + p = _CategoricalPlotter() + p.require_numeric = plotter_class.require_numeric + p.establish_variables(x_, y_, hue, data, orient, order, hue_order) + if ( + order is not None + or (sharex and p.orient == "v") + or (sharey and p.orient == "h") + ): + # Sync categorical axis between facets to have the same categories + order = p.group_names + elif color is None and hue is None: + msg = ( + "Setting `{}=False` with `color=None` may cause different levels of the " + "`{}` variable to share colors. This will change in a future version." + ) + if not sharex and p.orient == "v": + warnings.warn(msg.format("sharex", "x"), UserWarning) + if not sharey and p.orient == "h": + warnings.warn(msg.format("sharey", "y"), UserWarning) + + hue_order = p.hue_names + + # Determine the palette to use + # (FacetGrid will pass a value for ``color`` to the plotting function + # so we need to define ``palette`` to get default behavior for the + # categorical functions + p.establish_colors(color, palette, 1) + if kind != "point" or hue is not None: + palette = p.colors + + # Determine keyword arguments for the facets + facet_kws = {} if facet_kws is None else facet_kws + facet_kws.update( + data=data, row=row, col=col, + row_order=row_order, col_order=col_order, + col_wrap=col_wrap, height=height, aspect=aspect, + sharex=sharex, sharey=sharey, + legend_out=legend_out, margin_titles=margin_titles, + dropna=False, + ) + + # Determine keyword arguments for the plotting function + plot_kws = dict( + order=order, hue_order=hue_order, + orient=orient, color=color, palette=palette, + ) + plot_kws.update(kwargs) + + if kind in ["bar", "point"]: + plot_kws.update( + estimator=estimator, ci=ci, n_boot=n_boot, units=units, seed=seed, + ) + + # Initialize the facets + g = FacetGrid(**facet_kws) + + # Draw the plot onto the facets + g.map_dataframe(plot_func, x=x, y=y, hue=hue, **plot_kws) + + if p.orient == "h": + g.set_axis_labels(p.value_label, p.group_label) + else: + g.set_axis_labels(p.group_label, p.value_label) + + # Special case axis labels for a count type plot + if kind == "count": + if x is None: + g.set_axis_labels(x_var="count") + if y is None: + g.set_axis_labels(y_var="count") + + if legend and (hue is not None) and (hue not in [x, row, col]): + hue_order = list(map(utils.to_utf8, hue_order)) + g.add_legend(title=hue, label_order=hue_order) + + return g + + +catplot.__doc__ = dedent("""\ + Figure-level interface for drawing categorical plots onto a FacetGrid. + + This function provides access to several axes-level functions that + show the relationship between a numerical and one or more categorical + variables using one of several visual representations. The ``kind`` + parameter selects the underlying axes-level function to use: + + Categorical scatterplots: + + - :func:`stripplot` (with ``kind="strip"``; the default) + - :func:`swarmplot` (with ``kind="swarm"``) + + Categorical distribution plots: + + - :func:`boxplot` (with ``kind="box"``) + - :func:`violinplot` (with ``kind="violin"``) + - :func:`boxenplot` (with ``kind="boxen"``) + + Categorical estimate plots: + + - :func:`pointplot` (with ``kind="point"``) + - :func:`barplot` (with ``kind="bar"``) + - :func:`countplot` (with ``kind="count"``) + + Extra keyword arguments are passed to the underlying function, so you + should refer to the documentation for each to see kind-specific options. + + Note that unlike when using the axes-level functions directly, data must be + passed in a long-form DataFrame with variables specified by passing strings + to ``x``, ``y``, ``hue``, etc. + + As in the case with the underlying plot functions, if variables have a + ``categorical`` data type, the levels of the categorical variables, and + their order will be inferred from the objects. Otherwise you may have to + use alter the dataframe sorting or use the function parameters (``orient``, + ``order``, ``hue_order``, etc.) to set up the plot correctly. + + {categorical_narrative} + + After plotting, the :class:`FacetGrid` with the plot is returned and can + be used directly to tweak supporting plot details or add other layers. + + Parameters + ---------- + {string_input_params} + {long_form_data} + row, col : names of variables in ``data``, optional + Categorical variables that will determine the faceting of the grid. + {col_wrap} + {stat_api_params} + {order_vars} + row_order, col_order : lists of strings, optional + Order to organize the rows and/or columns of the grid in, otherwise the + orders are inferred from the data objects. + kind : str, optional + The kind of plot to draw, corresponds to the name of a categorical + axes-level plotting function. Options are: "strip", "swarm", "box", "violin", + "boxen", "point", "bar", or "count". + {height} + {aspect} + {orient} + {color} + {palette} + legend : bool, optional + If ``True`` and there is a ``hue`` variable, draw a legend on the plot. + {legend_out} + {share_xy} + {margin_titles} + facet_kws : dict, optional + Dictionary of other keyword arguments to pass to :class:`FacetGrid`. + kwargs : key, value pairings + Other keyword arguments are passed through to the underlying plotting + function. + + Returns + ------- + g : :class:`FacetGrid` + Returns the :class:`FacetGrid` object with the plot on it for further + tweaking. + + Examples + -------- + + Draw a single facet to use the :class:`FacetGrid` legend placement: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns + >>> sns.set_theme(style="ticks") + >>> exercise = sns.load_dataset("exercise") + >>> g = sns.catplot(x="time", y="pulse", hue="kind", data=exercise) + + Use a different plot kind to visualize the same data: + + .. plot:: + :context: close-figs + + >>> g = sns.catplot(x="time", y="pulse", hue="kind", + ... data=exercise, kind="violin") + + Facet along the columns to show a third categorical variable: + + .. plot:: + :context: close-figs + + >>> g = sns.catplot(x="time", y="pulse", hue="kind", + ... col="diet", data=exercise) + + Use a different height and aspect ratio for the facets: + + .. plot:: + :context: close-figs + + >>> g = sns.catplot(x="time", y="pulse", hue="kind", + ... col="diet", data=exercise, + ... height=5, aspect=.8) + + Make many column facets and wrap them into the rows of the grid: + + .. plot:: + :context: close-figs + + >>> titanic = sns.load_dataset("titanic") + >>> g = sns.catplot(x="alive", col="deck", col_wrap=4, + ... data=titanic[titanic.deck.notnull()], + ... kind="count", height=2.5, aspect=.8) + + Plot horizontally and pass other keyword arguments to the plot function: + + .. plot:: + :context: close-figs + + >>> g = sns.catplot(x="age", y="embark_town", + ... hue="sex", row="class", + ... data=titanic[titanic.embark_town.notnull()], + ... orient="h", height=2, aspect=3, palette="Set3", + ... kind="violin", dodge=True, cut=0, bw=.2) + + Use methods on the returned :class:`FacetGrid` to tweak the presentation: + + .. plot:: + :context: close-figs + + >>> g = sns.catplot(x="who", y="survived", col="class", + ... data=titanic, saturation=.5, + ... kind="bar", ci=None, aspect=.6) + >>> (g.set_axis_labels("", "Survival Rate") + ... .set_xticklabels(["Men", "Women", "Children"]) + ... .set_titles("{{col_name}} {{col_var}}") + ... .set(ylim=(0, 1)) + ... .despine(left=True)) #doctest: +ELLIPSIS + + + """).format(**_categorical_docs) diff --git a/grplot_seaborn/cm.py b/grplot_seaborn/cm.py new file mode 100644 index 0000000..4e39fe7 --- /dev/null +++ b/grplot_seaborn/cm.py @@ -0,0 +1,1585 @@ +from matplotlib import colors, cm as mpl_cm + + +_rocket_lut = [ + [ 0.01060815, 0.01808215, 0.10018654], + [ 0.01428972, 0.02048237, 0.10374486], + [ 0.01831941, 0.0229766 , 0.10738511], + [ 0.02275049, 0.02554464, 0.11108639], + [ 0.02759119, 0.02818316, 0.11483751], + [ 0.03285175, 0.03088792, 0.11863035], + [ 0.03853466, 0.03365771, 0.12245873], + [ 0.04447016, 0.03648425, 0.12631831], + [ 0.05032105, 0.03936808, 0.13020508], + [ 0.05611171, 0.04224835, 0.13411624], + [ 0.0618531 , 0.04504866, 0.13804929], + [ 0.06755457, 0.04778179, 0.14200206], + [ 0.0732236 , 0.05045047, 0.14597263], + [ 0.0788708 , 0.05305461, 0.14995981], + [ 0.08450105, 0.05559631, 0.15396203], + [ 0.09011319, 0.05808059, 0.15797687], + [ 0.09572396, 0.06050127, 0.16200507], + [ 0.10132312, 0.06286782, 0.16604287], + [ 0.10692823, 0.06517224, 0.17009175], + [ 0.1125315 , 0.06742194, 0.17414848], + [ 0.11813947, 0.06961499, 0.17821272], + [ 0.12375803, 0.07174938, 0.18228425], + [ 0.12938228, 0.07383015, 0.18636053], + [ 0.13501631, 0.07585609, 0.19044109], + [ 0.14066867, 0.0778224 , 0.19452676], + [ 0.14633406, 0.07973393, 0.1986151 ], + [ 0.15201338, 0.08159108, 0.20270523], + [ 0.15770877, 0.08339312, 0.20679668], + [ 0.16342174, 0.0851396 , 0.21088893], + [ 0.16915387, 0.08682996, 0.21498104], + [ 0.17489524, 0.08848235, 0.2190294 ], + [ 0.18065495, 0.09009031, 0.22303512], + [ 0.18643324, 0.09165431, 0.22699705], + [ 0.19223028, 0.09317479, 0.23091409], + [ 0.19804623, 0.09465217, 0.23478512], + [ 0.20388117, 0.09608689, 0.23860907], + [ 0.20973515, 0.09747934, 0.24238489], + [ 0.21560818, 0.09882993, 0.24611154], + [ 0.22150014, 0.10013944, 0.2497868 ], + [ 0.22741085, 0.10140876, 0.25340813], + [ 0.23334047, 0.10263737, 0.25697736], + [ 0.23928891, 0.10382562, 0.2604936 ], + [ 0.24525608, 0.10497384, 0.26395596], + [ 0.25124182, 0.10608236, 0.26736359], + [ 0.25724602, 0.10715148, 0.27071569], + [ 0.26326851, 0.1081815 , 0.27401148], + [ 0.26930915, 0.1091727 , 0.2772502 ], + [ 0.27536766, 0.11012568, 0.28043021], + [ 0.28144375, 0.11104133, 0.2835489 ], + [ 0.2875374 , 0.11191896, 0.28660853], + [ 0.29364846, 0.11275876, 0.2896085 ], + [ 0.29977678, 0.11356089, 0.29254823], + [ 0.30592213, 0.11432553, 0.29542718], + [ 0.31208435, 0.11505284, 0.29824485], + [ 0.31826327, 0.1157429 , 0.30100076], + [ 0.32445869, 0.11639585, 0.30369448], + [ 0.33067031, 0.11701189, 0.30632563], + [ 0.33689808, 0.11759095, 0.3088938 ], + [ 0.34314168, 0.11813362, 0.31139721], + [ 0.34940101, 0.11863987, 0.3138355 ], + [ 0.355676 , 0.11910909, 0.31620996], + [ 0.36196644, 0.1195413 , 0.31852037], + [ 0.36827206, 0.11993653, 0.32076656], + [ 0.37459292, 0.12029443, 0.32294825], + [ 0.38092887, 0.12061482, 0.32506528], + [ 0.38727975, 0.12089756, 0.3271175 ], + [ 0.39364518, 0.12114272, 0.32910494], + [ 0.40002537, 0.12134964, 0.33102734], + [ 0.40642019, 0.12151801, 0.33288464], + [ 0.41282936, 0.12164769, 0.33467689], + [ 0.41925278, 0.12173833, 0.33640407], + [ 0.42569057, 0.12178916, 0.33806605], + [ 0.43214263, 0.12179973, 0.33966284], + [ 0.43860848, 0.12177004, 0.34119475], + [ 0.44508855, 0.12169883, 0.34266151], + [ 0.45158266, 0.12158557, 0.34406324], + [ 0.45809049, 0.12142996, 0.34540024], + [ 0.46461238, 0.12123063, 0.34667231], + [ 0.47114798, 0.12098721, 0.34787978], + [ 0.47769736, 0.12069864, 0.34902273], + [ 0.48426077, 0.12036349, 0.35010104], + [ 0.49083761, 0.11998161, 0.35111537], + [ 0.49742847, 0.11955087, 0.35206533], + [ 0.50403286, 0.11907081, 0.35295152], + [ 0.51065109, 0.11853959, 0.35377385], + [ 0.51728314, 0.1179558 , 0.35453252], + [ 0.52392883, 0.11731817, 0.35522789], + [ 0.53058853, 0.11662445, 0.35585982], + [ 0.53726173, 0.11587369, 0.35642903], + [ 0.54394898, 0.11506307, 0.35693521], + [ 0.5506426 , 0.11420757, 0.35737863], + [ 0.55734473, 0.11330456, 0.35775059], + [ 0.56405586, 0.11235265, 0.35804813], + [ 0.57077365, 0.11135597, 0.35827146], + [ 0.5774991 , 0.11031233, 0.35841679], + [ 0.58422945, 0.10922707, 0.35848469], + [ 0.59096382, 0.10810205, 0.35847347], + [ 0.59770215, 0.10693774, 0.35838029], + [ 0.60444226, 0.10573912, 0.35820487], + [ 0.61118304, 0.10450943, 0.35794557], + [ 0.61792306, 0.10325288, 0.35760108], + [ 0.62466162, 0.10197244, 0.35716891], + [ 0.63139686, 0.10067417, 0.35664819], + [ 0.63812122, 0.09938212, 0.35603757], + [ 0.64483795, 0.0980891 , 0.35533555], + [ 0.65154562, 0.09680192, 0.35454107], + [ 0.65824241, 0.09552918, 0.3536529 ], + [ 0.66492652, 0.09428017, 0.3526697 ], + [ 0.67159578, 0.09306598, 0.35159077], + [ 0.67824099, 0.09192342, 0.3504148 ], + [ 0.684863 , 0.09085633, 0.34914061], + [ 0.69146268, 0.0898675 , 0.34776864], + [ 0.69803757, 0.08897226, 0.3462986 ], + [ 0.70457834, 0.0882129 , 0.34473046], + [ 0.71108138, 0.08761223, 0.3430635 ], + [ 0.7175507 , 0.08716212, 0.34129974], + [ 0.72398193, 0.08688725, 0.33943958], + [ 0.73035829, 0.0868623 , 0.33748452], + [ 0.73669146, 0.08704683, 0.33543669], + [ 0.74297501, 0.08747196, 0.33329799], + [ 0.74919318, 0.08820542, 0.33107204], + [ 0.75535825, 0.08919792, 0.32876184], + [ 0.76145589, 0.09050716, 0.32637117], + [ 0.76748424, 0.09213602, 0.32390525], + [ 0.77344838, 0.09405684, 0.32136808], + [ 0.77932641, 0.09634794, 0.31876642], + [ 0.78513609, 0.09892473, 0.31610488], + [ 0.79085854, 0.10184672, 0.313391 ], + [ 0.7965014 , 0.10506637, 0.31063031], + [ 0.80205987, 0.10858333, 0.30783 ], + [ 0.80752799, 0.11239964, 0.30499738], + [ 0.81291606, 0.11645784, 0.30213802], + [ 0.81820481, 0.12080606, 0.29926105], + [ 0.82341472, 0.12535343, 0.2963705 ], + [ 0.82852822, 0.13014118, 0.29347474], + [ 0.83355779, 0.13511035, 0.29057852], + [ 0.83850183, 0.14025098, 0.2876878 ], + [ 0.84335441, 0.14556683, 0.28480819], + [ 0.84813096, 0.15099892, 0.281943 ], + [ 0.85281737, 0.15657772, 0.27909826], + [ 0.85742602, 0.1622583 , 0.27627462], + [ 0.86196552, 0.16801239, 0.27346473], + [ 0.86641628, 0.17387796, 0.27070818], + [ 0.87079129, 0.17982114, 0.26797378], + [ 0.87507281, 0.18587368, 0.26529697], + [ 0.87925878, 0.19203259, 0.26268136], + [ 0.8833417 , 0.19830556, 0.26014181], + [ 0.88731387, 0.20469941, 0.25769539], + [ 0.89116859, 0.21121788, 0.2553592 ], + [ 0.89490337, 0.21785614, 0.25314362], + [ 0.8985026 , 0.22463251, 0.25108745], + [ 0.90197527, 0.23152063, 0.24918223], + [ 0.90530097, 0.23854541, 0.24748098], + [ 0.90848638, 0.24568473, 0.24598324], + [ 0.911533 , 0.25292623, 0.24470258], + [ 0.9144225 , 0.26028902, 0.24369359], + [ 0.91717106, 0.26773821, 0.24294137], + [ 0.91978131, 0.27526191, 0.24245973], + [ 0.92223947, 0.28287251, 0.24229568], + [ 0.92456587, 0.29053388, 0.24242622], + [ 0.92676657, 0.29823282, 0.24285536], + [ 0.92882964, 0.30598085, 0.24362274], + [ 0.93078135, 0.31373977, 0.24468803], + [ 0.93262051, 0.3215093 , 0.24606461], + [ 0.93435067, 0.32928362, 0.24775328], + [ 0.93599076, 0.33703942, 0.24972157], + [ 0.93752831, 0.34479177, 0.25199928], + [ 0.93899289, 0.35250734, 0.25452808], + [ 0.94036561, 0.36020899, 0.25734661], + [ 0.94167588, 0.36786594, 0.2603949 ], + [ 0.94291042, 0.37549479, 0.26369821], + [ 0.94408513, 0.3830811 , 0.26722004], + [ 0.94520419, 0.39062329, 0.27094924], + [ 0.94625977, 0.39813168, 0.27489742], + [ 0.94727016, 0.4055909 , 0.27902322], + [ 0.94823505, 0.41300424, 0.28332283], + [ 0.94914549, 0.42038251, 0.28780969], + [ 0.95001704, 0.42771398, 0.29244728], + [ 0.95085121, 0.43500005, 0.29722817], + [ 0.95165009, 0.44224144, 0.30214494], + [ 0.9524044 , 0.44944853, 0.3072105 ], + [ 0.95312556, 0.45661389, 0.31239776], + [ 0.95381595, 0.46373781, 0.31769923], + [ 0.95447591, 0.47082238, 0.32310953], + [ 0.95510255, 0.47787236, 0.32862553], + [ 0.95569679, 0.48489115, 0.33421404], + [ 0.95626788, 0.49187351, 0.33985601], + [ 0.95681685, 0.49882008, 0.34555431], + [ 0.9573439 , 0.50573243, 0.35130912], + [ 0.95784842, 0.51261283, 0.35711942], + [ 0.95833051, 0.51946267, 0.36298589], + [ 0.95879054, 0.52628305, 0.36890904], + [ 0.95922872, 0.53307513, 0.3748895 ], + [ 0.95964538, 0.53983991, 0.38092784], + [ 0.96004345, 0.54657593, 0.3870292 ], + [ 0.96042097, 0.55328624, 0.39319057], + [ 0.96077819, 0.55997184, 0.39941173], + [ 0.9611152 , 0.5666337 , 0.40569343], + [ 0.96143273, 0.57327231, 0.41203603], + [ 0.96173392, 0.57988594, 0.41844491], + [ 0.96201757, 0.58647675, 0.42491751], + [ 0.96228344, 0.59304598, 0.43145271], + [ 0.96253168, 0.5995944 , 0.43805131], + [ 0.96276513, 0.60612062, 0.44471698], + [ 0.96298491, 0.6126247 , 0.45145074], + [ 0.96318967, 0.61910879, 0.45824902], + [ 0.96337949, 0.6255736 , 0.46511271], + [ 0.96355923, 0.63201624, 0.47204746], + [ 0.96372785, 0.63843852, 0.47905028], + [ 0.96388426, 0.64484214, 0.4861196 ], + [ 0.96403203, 0.65122535, 0.4932578 ], + [ 0.96417332, 0.65758729, 0.50046894], + [ 0.9643063 , 0.66393045, 0.5077467 ], + [ 0.96443322, 0.67025402, 0.51509334], + [ 0.96455845, 0.67655564, 0.52251447], + [ 0.96467922, 0.68283846, 0.53000231], + [ 0.96479861, 0.68910113, 0.53756026], + [ 0.96492035, 0.69534192, 0.5451917 ], + [ 0.96504223, 0.7015636 , 0.5528892 ], + [ 0.96516917, 0.70776351, 0.5606593 ], + [ 0.96530224, 0.71394212, 0.56849894], + [ 0.96544032, 0.72010124, 0.57640375], + [ 0.96559206, 0.72623592, 0.58438387], + [ 0.96575293, 0.73235058, 0.59242739], + [ 0.96592829, 0.73844258, 0.60053991], + [ 0.96612013, 0.74451182, 0.60871954], + [ 0.96632832, 0.75055966, 0.61696136], + [ 0.96656022, 0.75658231, 0.62527295], + [ 0.96681185, 0.76258381, 0.63364277], + [ 0.96709183, 0.76855969, 0.64207921], + [ 0.96739773, 0.77451297, 0.65057302], + [ 0.96773482, 0.78044149, 0.65912731], + [ 0.96810471, 0.78634563, 0.66773889], + [ 0.96850919, 0.79222565, 0.6764046 ], + [ 0.96893132, 0.79809112, 0.68512266], + [ 0.96935926, 0.80395415, 0.69383201], + [ 0.9698028 , 0.80981139, 0.70252255], + [ 0.97025511, 0.81566605, 0.71120296], + [ 0.97071849, 0.82151775, 0.71987163], + [ 0.97120159, 0.82736371, 0.72851999], + [ 0.97169389, 0.83320847, 0.73716071], + [ 0.97220061, 0.83905052, 0.74578903], + [ 0.97272597, 0.84488881, 0.75440141], + [ 0.97327085, 0.85072354, 0.76299805], + [ 0.97383206, 0.85655639, 0.77158353], + [ 0.97441222, 0.86238689, 0.78015619], + [ 0.97501782, 0.86821321, 0.78871034], + [ 0.97564391, 0.87403763, 0.79725261], + [ 0.97628674, 0.87986189, 0.8057883 ], + [ 0.97696114, 0.88568129, 0.81430324], + [ 0.97765722, 0.89149971, 0.82280948], + [ 0.97837585, 0.89731727, 0.83130786], + [ 0.97912374, 0.90313207, 0.83979337], + [ 0.979891 , 0.90894778, 0.84827858], + [ 0.98067764, 0.91476465, 0.85676611], + [ 0.98137749, 0.92061729, 0.86536915] +] + + +_mako_lut = [ + [ 0.04503935, 0.01482344, 0.02092227], + [ 0.04933018, 0.01709292, 0.02535719], + [ 0.05356262, 0.01950702, 0.03018802], + [ 0.05774337, 0.02205989, 0.03545515], + [ 0.06188095, 0.02474764, 0.04115287], + [ 0.06598247, 0.0275665 , 0.04691409], + [ 0.07005374, 0.03051278, 0.05264306], + [ 0.07409947, 0.03358324, 0.05834631], + [ 0.07812339, 0.03677446, 0.06403249], + [ 0.08212852, 0.0400833 , 0.06970862], + [ 0.08611731, 0.04339148, 0.07538208], + [ 0.09009161, 0.04664706, 0.08105568], + [ 0.09405308, 0.04985685, 0.08673591], + [ 0.09800301, 0.05302279, 0.09242646], + [ 0.10194255, 0.05614641, 0.09813162], + [ 0.10587261, 0.05922941, 0.103854 ], + [ 0.1097942 , 0.06227277, 0.10959847], + [ 0.11370826, 0.06527747, 0.11536893], + [ 0.11761516, 0.06824548, 0.12116393], + [ 0.12151575, 0.07117741, 0.12698763], + [ 0.12541095, 0.07407363, 0.1328442 ], + [ 0.12930083, 0.07693611, 0.13873064], + [ 0.13317849, 0.07976988, 0.14465095], + [ 0.13701138, 0.08259683, 0.15060265], + [ 0.14079223, 0.08542126, 0.15659379], + [ 0.14452486, 0.08824175, 0.16262484], + [ 0.14820351, 0.09106304, 0.16869476], + [ 0.15183185, 0.09388372, 0.17480366], + [ 0.15540398, 0.09670855, 0.18094993], + [ 0.15892417, 0.09953561, 0.18713384], + [ 0.16238588, 0.10236998, 0.19335329], + [ 0.16579435, 0.10520905, 0.19960847], + [ 0.16914226, 0.10805832, 0.20589698], + [ 0.17243586, 0.11091443, 0.21221911], + [ 0.17566717, 0.11378321, 0.21857219], + [ 0.17884322, 0.11666074, 0.2249565 ], + [ 0.18195582, 0.11955283, 0.23136943], + [ 0.18501213, 0.12245547, 0.23781116], + [ 0.18800459, 0.12537395, 0.24427914], + [ 0.19093944, 0.1283047 , 0.25077369], + [ 0.19381092, 0.13125179, 0.25729255], + [ 0.19662307, 0.13421303, 0.26383543], + [ 0.19937337, 0.13719028, 0.27040111], + [ 0.20206187, 0.14018372, 0.27698891], + [ 0.20469116, 0.14319196, 0.28359861], + [ 0.20725547, 0.14621882, 0.29022775], + [ 0.20976258, 0.14925954, 0.29687795], + [ 0.21220409, 0.15231929, 0.30354703], + [ 0.21458611, 0.15539445, 0.31023563], + [ 0.21690827, 0.15848519, 0.31694355], + [ 0.21916481, 0.16159489, 0.32366939], + [ 0.2213631 , 0.16471913, 0.33041431], + [ 0.22349947, 0.1678599 , 0.33717781], + [ 0.2255714 , 0.1710185 , 0.34395925], + [ 0.22758415, 0.17419169, 0.35075983], + [ 0.22953569, 0.17738041, 0.35757941], + [ 0.23142077, 0.18058733, 0.3644173 ], + [ 0.2332454 , 0.18380872, 0.37127514], + [ 0.2350092 , 0.18704459, 0.3781528 ], + [ 0.23670785, 0.190297 , 0.38504973], + [ 0.23834119, 0.19356547, 0.39196711], + [ 0.23991189, 0.19684817, 0.39890581], + [ 0.24141903, 0.20014508, 0.4058667 ], + [ 0.24286214, 0.20345642, 0.4128484 ], + [ 0.24423453, 0.20678459, 0.41985299], + [ 0.24554109, 0.21012669, 0.42688124], + [ 0.2467815 , 0.21348266, 0.43393244], + [ 0.24795393, 0.21685249, 0.4410088 ], + [ 0.24905614, 0.22023618, 0.448113 ], + [ 0.25007383, 0.22365053, 0.45519562], + [ 0.25098926, 0.22710664, 0.46223892], + [ 0.25179696, 0.23060342, 0.46925447], + [ 0.25249346, 0.23414353, 0.47623196], + [ 0.25307401, 0.23772973, 0.48316271], + [ 0.25353152, 0.24136961, 0.49001976], + [ 0.25386167, 0.24506548, 0.49679407], + [ 0.25406082, 0.2488164 , 0.50348932], + [ 0.25412435, 0.25262843, 0.51007843], + [ 0.25404842, 0.25650743, 0.51653282], + [ 0.25383134, 0.26044852, 0.52286845], + [ 0.2534705 , 0.26446165, 0.52903422], + [ 0.25296722, 0.2685428 , 0.53503572], + [ 0.2523226 , 0.27269346, 0.54085315], + [ 0.25153974, 0.27691629, 0.54645752], + [ 0.25062402, 0.28120467, 0.55185939], + [ 0.24958205, 0.28556371, 0.55701246], + [ 0.24842386, 0.28998148, 0.56194601], + [ 0.24715928, 0.29446327, 0.56660884], + [ 0.24580099, 0.29899398, 0.57104399], + [ 0.24436202, 0.30357852, 0.57519929], + [ 0.24285591, 0.30819938, 0.57913247], + [ 0.24129828, 0.31286235, 0.58278615], + [ 0.23970131, 0.3175495 , 0.5862272 ], + [ 0.23807973, 0.32226344, 0.58941872], + [ 0.23644557, 0.32699241, 0.59240198], + [ 0.2348113 , 0.33173196, 0.59518282], + [ 0.23318874, 0.33648036, 0.59775543], + [ 0.2315855 , 0.34122763, 0.60016456], + [ 0.23001121, 0.34597357, 0.60240251], + [ 0.2284748 , 0.35071512, 0.6044784 ], + [ 0.22698081, 0.35544612, 0.60642528], + [ 0.22553305, 0.36016515, 0.60825252], + [ 0.22413977, 0.36487341, 0.60994938], + [ 0.22280246, 0.36956728, 0.61154118], + [ 0.22152555, 0.37424409, 0.61304472], + [ 0.22030752, 0.37890437, 0.61446646], + [ 0.2191538 , 0.38354668, 0.61581561], + [ 0.21806257, 0.38817169, 0.61709794], + [ 0.21703799, 0.39277882, 0.61831922], + [ 0.21607792, 0.39736958, 0.61948028], + [ 0.21518463, 0.40194196, 0.62059763], + [ 0.21435467, 0.40649717, 0.62167507], + [ 0.21358663, 0.41103579, 0.62271724], + [ 0.21288172, 0.41555771, 0.62373011], + [ 0.21223835, 0.42006355, 0.62471794], + [ 0.21165312, 0.42455441, 0.62568371], + [ 0.21112526, 0.42903064, 0.6266318 ], + [ 0.21065161, 0.43349321, 0.62756504], + [ 0.21023306, 0.43794288, 0.62848279], + [ 0.20985996, 0.44238227, 0.62938329], + [ 0.20951045, 0.44680966, 0.63030696], + [ 0.20916709, 0.45122981, 0.63124483], + [ 0.20882976, 0.45564335, 0.63219599], + [ 0.20849798, 0.46005094, 0.63315928], + [ 0.20817199, 0.46445309, 0.63413391], + [ 0.20785149, 0.46885041, 0.63511876], + [ 0.20753716, 0.47324327, 0.63611321], + [ 0.20722876, 0.47763224, 0.63711608], + [ 0.20692679, 0.48201774, 0.63812656], + [ 0.20663156, 0.48640018, 0.63914367], + [ 0.20634336, 0.49078002, 0.64016638], + [ 0.20606303, 0.49515755, 0.6411939 ], + [ 0.20578999, 0.49953341, 0.64222457], + [ 0.20552612, 0.50390766, 0.64325811], + [ 0.20527189, 0.50828072, 0.64429331], + [ 0.20502868, 0.51265277, 0.64532947], + [ 0.20479718, 0.51702417, 0.64636539], + [ 0.20457804, 0.52139527, 0.64739979], + [ 0.20437304, 0.52576622, 0.64843198], + [ 0.20418396, 0.53013715, 0.64946117], + [ 0.20401238, 0.53450825, 0.65048638], + [ 0.20385896, 0.53887991, 0.65150606], + [ 0.20372653, 0.54325208, 0.65251978], + [ 0.20361709, 0.5476249 , 0.6535266 ], + [ 0.20353258, 0.55199854, 0.65452542], + [ 0.20347472, 0.55637318, 0.655515 ], + [ 0.20344718, 0.56074869, 0.65649508], + [ 0.20345161, 0.56512531, 0.65746419], + [ 0.20349089, 0.56950304, 0.65842151], + [ 0.20356842, 0.57388184, 0.65936642], + [ 0.20368663, 0.57826181, 0.66029768], + [ 0.20384884, 0.58264293, 0.6612145 ], + [ 0.20405904, 0.58702506, 0.66211645], + [ 0.20431921, 0.59140842, 0.66300179], + [ 0.20463464, 0.59579264, 0.66387079], + [ 0.20500731, 0.60017798, 0.66472159], + [ 0.20544449, 0.60456387, 0.66555409], + [ 0.20596097, 0.60894927, 0.66636568], + [ 0.20654832, 0.61333521, 0.66715744], + [ 0.20721003, 0.61772167, 0.66792838], + [ 0.20795035, 0.62210845, 0.66867802], + [ 0.20877302, 0.62649546, 0.66940555], + [ 0.20968223, 0.63088252, 0.6701105 ], + [ 0.21068163, 0.63526951, 0.67079211], + [ 0.21177544, 0.63965621, 0.67145005], + [ 0.21298582, 0.64404072, 0.67208182], + [ 0.21430361, 0.64842404, 0.67268861], + [ 0.21572716, 0.65280655, 0.67326978], + [ 0.21726052, 0.65718791, 0.6738255 ], + [ 0.21890636, 0.66156803, 0.67435491], + [ 0.220668 , 0.66594665, 0.67485792], + [ 0.22255447, 0.67032297, 0.67533374], + [ 0.22458372, 0.67469531, 0.67578061], + [ 0.22673713, 0.67906542, 0.67620044], + [ 0.22901625, 0.6834332 , 0.67659251], + [ 0.23142316, 0.68779836, 0.67695703], + [ 0.23395924, 0.69216072, 0.67729378], + [ 0.23663857, 0.69651881, 0.67760151], + [ 0.23946645, 0.70087194, 0.67788018], + [ 0.24242624, 0.70522162, 0.67813088], + [ 0.24549008, 0.70957083, 0.67835215], + [ 0.24863372, 0.71392166, 0.67854868], + [ 0.25187832, 0.71827158, 0.67872193], + [ 0.25524083, 0.72261873, 0.67887024], + [ 0.25870947, 0.72696469, 0.67898912], + [ 0.26229238, 0.73130855, 0.67907645], + [ 0.26604085, 0.73564353, 0.67914062], + [ 0.26993099, 0.73997282, 0.67917264], + [ 0.27397488, 0.74429484, 0.67917096], + [ 0.27822463, 0.74860229, 0.67914468], + [ 0.28264201, 0.75290034, 0.67907959], + [ 0.2873016 , 0.75717817, 0.67899164], + [ 0.29215894, 0.76144162, 0.67886578], + [ 0.29729823, 0.76567816, 0.67871894], + [ 0.30268199, 0.76989232, 0.67853896], + [ 0.30835665, 0.77407636, 0.67833512], + [ 0.31435139, 0.77822478, 0.67811118], + [ 0.3206671 , 0.78233575, 0.67786729], + [ 0.32733158, 0.78640315, 0.67761027], + [ 0.33437168, 0.79042043, 0.67734882], + [ 0.34182112, 0.79437948, 0.67709394], + [ 0.34968889, 0.79827511, 0.67685638], + [ 0.35799244, 0.80210037, 0.67664969], + [ 0.36675371, 0.80584651, 0.67649539], + [ 0.3759816 , 0.80950627, 0.67641393], + [ 0.38566792, 0.81307432, 0.67642947], + [ 0.39579804, 0.81654592, 0.67656899], + [ 0.40634556, 0.81991799, 0.67686215], + [ 0.41730243, 0.82318339, 0.67735255], + [ 0.4285828 , 0.82635051, 0.6780564 ], + [ 0.44012728, 0.82942353, 0.67900049], + [ 0.45189421, 0.83240398, 0.68021733], + [ 0.46378379, 0.83530763, 0.6817062 ], + [ 0.47573199, 0.83814472, 0.68347352], + [ 0.48769865, 0.84092197, 0.68552698], + [ 0.49962354, 0.84365379, 0.68783929], + [ 0.5114027 , 0.8463718 , 0.69029789], + [ 0.52301693, 0.84908401, 0.69288545], + [ 0.53447549, 0.85179048, 0.69561066], + [ 0.54578602, 0.8544913 , 0.69848331], + [ 0.55695565, 0.85718723, 0.70150427], + [ 0.56798832, 0.85987893, 0.70468261], + [ 0.57888639, 0.86256715, 0.70802931], + [ 0.5896541 , 0.8652532 , 0.71154204], + [ 0.60028928, 0.86793835, 0.71523675], + [ 0.61079441, 0.87062438, 0.71910895], + [ 0.62116633, 0.87331311, 0.72317003], + [ 0.63140509, 0.87600675, 0.72741689], + [ 0.64150735, 0.87870746, 0.73185717], + [ 0.65147219, 0.8814179 , 0.73648495], + [ 0.66129632, 0.8841403 , 0.74130658], + [ 0.67097934, 0.88687758, 0.74631123], + [ 0.68051833, 0.88963189, 0.75150483], + [ 0.68991419, 0.89240612, 0.75687187], + [ 0.69916533, 0.89520211, 0.76241714], + [ 0.70827373, 0.89802257, 0.76812286], + [ 0.71723995, 0.90086891, 0.77399039], + [ 0.72606665, 0.90374337, 0.7800041 ], + [ 0.73475675, 0.90664718, 0.78615802], + [ 0.74331358, 0.90958151, 0.79244474], + [ 0.75174143, 0.91254787, 0.79884925], + [ 0.76004473, 0.91554656, 0.80536823], + [ 0.76827704, 0.91856549, 0.81196513], + [ 0.77647029, 0.921603 , 0.81855729], + [ 0.78462009, 0.92466151, 0.82514119], + [ 0.79273542, 0.92773848, 0.83172131], + [ 0.8008109 , 0.93083672, 0.83829355], + [ 0.80885107, 0.93395528, 0.84485982], + [ 0.81685878, 0.9370938 , 0.85142101], + [ 0.82483206, 0.94025378, 0.8579751 ], + [ 0.83277661, 0.94343371, 0.86452477], + [ 0.84069127, 0.94663473, 0.87106853], + [ 0.84857662, 0.9498573 , 0.8776059 ], + [ 0.8564431 , 0.95309792, 0.88414253], + [ 0.86429066, 0.95635719, 0.89067759], + [ 0.87218969, 0.95960708, 0.89725384] +] + + +_vlag_lut = [ + [ 0.13850039, 0.41331206, 0.74052025], + [ 0.15077609, 0.41762684, 0.73970427], + [ 0.16235219, 0.4219191 , 0.7389667 ], + [ 0.1733322 , 0.42619024, 0.73832537], + [ 0.18382538, 0.43044226, 0.73776764], + [ 0.19394034, 0.4346772 , 0.73725867], + [ 0.20367115, 0.43889576, 0.73685314], + [ 0.21313625, 0.44310003, 0.73648045], + [ 0.22231173, 0.44729079, 0.73619681], + [ 0.23125148, 0.45146945, 0.73597803], + [ 0.23998101, 0.45563715, 0.7358223 ], + [ 0.24853358, 0.45979489, 0.73571524], + [ 0.25691416, 0.4639437 , 0.73566943], + [ 0.26513894, 0.46808455, 0.73568319], + [ 0.27322194, 0.47221835, 0.73575497], + [ 0.28117543, 0.47634598, 0.73588332], + [ 0.28901021, 0.48046826, 0.73606686], + [ 0.2967358 , 0.48458597, 0.73630433], + [ 0.30436071, 0.48869986, 0.73659451], + [ 0.3118955 , 0.49281055, 0.73693255], + [ 0.31935389, 0.49691847, 0.73730851], + [ 0.32672701, 0.5010247 , 0.73774013], + [ 0.33402607, 0.50512971, 0.73821941], + [ 0.34125337, 0.50923419, 0.73874905], + [ 0.34840921, 0.51333892, 0.73933402], + [ 0.35551826, 0.51744353, 0.73994642], + [ 0.3625676 , 0.52154929, 0.74060763], + [ 0.36956356, 0.52565656, 0.74131327], + [ 0.37649902, 0.52976642, 0.74207698], + [ 0.38340273, 0.53387791, 0.74286286], + [ 0.39025859, 0.53799253, 0.7436962 ], + [ 0.39706821, 0.54211081, 0.744578 ], + [ 0.40384046, 0.54623277, 0.74549872], + [ 0.41058241, 0.55035849, 0.74645094], + [ 0.41728385, 0.55448919, 0.74745174], + [ 0.42395178, 0.55862494, 0.74849357], + [ 0.4305964 , 0.56276546, 0.74956387], + [ 0.4372044 , 0.56691228, 0.75068412], + [ 0.4437909 , 0.57106468, 0.75183427], + [ 0.45035117, 0.5752235 , 0.75302312], + [ 0.45687824, 0.57938983, 0.75426297], + [ 0.46339713, 0.58356191, 0.75551816], + [ 0.46988778, 0.58774195, 0.75682037], + [ 0.47635605, 0.59192986, 0.75816245], + [ 0.48281101, 0.5961252 , 0.75953212], + [ 0.4892374 , 0.60032986, 0.76095418], + [ 0.49566225, 0.60454154, 0.76238852], + [ 0.50206137, 0.60876307, 0.76387371], + [ 0.50845128, 0.61299312, 0.76538551], + [ 0.5148258 , 0.61723272, 0.76693475], + [ 0.52118385, 0.62148236, 0.76852436], + [ 0.52753571, 0.62574126, 0.77013939], + [ 0.53386831, 0.63001125, 0.77180152], + [ 0.54020159, 0.63429038, 0.7734803 ], + [ 0.54651272, 0.63858165, 0.77521306], + [ 0.55282975, 0.64288207, 0.77695608], + [ 0.55912585, 0.64719519, 0.77875327], + [ 0.56542599, 0.65151828, 0.78056551], + [ 0.57170924, 0.65585426, 0.78242747], + [ 0.57799572, 0.6602009 , 0.78430751], + [ 0.58426817, 0.66456073, 0.78623458], + [ 0.590544 , 0.66893178, 0.78818117], + [ 0.59680758, 0.67331643, 0.79017369], + [ 0.60307553, 0.67771273, 0.79218572], + [ 0.60934065, 0.68212194, 0.79422987], + [ 0.61559495, 0.68654548, 0.7963202 ], + [ 0.62185554, 0.69098125, 0.79842918], + [ 0.62810662, 0.69543176, 0.80058381], + [ 0.63436425, 0.69989499, 0.80275812], + [ 0.64061445, 0.70437326, 0.80497621], + [ 0.6468706 , 0.70886488, 0.80721641], + [ 0.65312213, 0.7133717 , 0.80949719], + [ 0.65937818, 0.71789261, 0.81180392], + [ 0.66563334, 0.72242871, 0.81414642], + [ 0.67189155, 0.72697967, 0.81651872], + [ 0.67815314, 0.73154569, 0.81892097], + [ 0.68441395, 0.73612771, 0.82136094], + [ 0.69068321, 0.74072452, 0.82382353], + [ 0.69694776, 0.7453385 , 0.82633199], + [ 0.70322431, 0.74996721, 0.8288583 ], + [ 0.70949595, 0.75461368, 0.83143221], + [ 0.7157774 , 0.75927574, 0.83402904], + [ 0.72206299, 0.76395461, 0.83665922], + [ 0.72835227, 0.76865061, 0.8393242 ], + [ 0.73465238, 0.7733628 , 0.84201224], + [ 0.74094862, 0.77809393, 0.84474951], + [ 0.74725683, 0.78284158, 0.84750915], + [ 0.75357103, 0.78760701, 0.85030217], + [ 0.75988961, 0.79239077, 0.85313207], + [ 0.76621987, 0.79719185, 0.85598668], + [ 0.77255045, 0.8020125 , 0.85888658], + [ 0.77889241, 0.80685102, 0.86181298], + [ 0.78524572, 0.81170768, 0.86476656], + [ 0.79159841, 0.81658489, 0.86776906], + [ 0.79796459, 0.82148036, 0.8707962 ], + [ 0.80434168, 0.82639479, 0.87385315], + [ 0.8107221 , 0.83132983, 0.87695392], + [ 0.81711301, 0.8362844 , 0.88008641], + [ 0.82351479, 0.84125863, 0.88325045], + [ 0.82992772, 0.84625263, 0.88644594], + [ 0.83634359, 0.85126806, 0.8896878 ], + [ 0.84277295, 0.85630293, 0.89295721], + [ 0.84921192, 0.86135782, 0.89626076], + [ 0.85566206, 0.866432 , 0.89959467], + [ 0.86211514, 0.87152627, 0.90297183], + [ 0.86857483, 0.87663856, 0.90638248], + [ 0.87504231, 0.88176648, 0.90981938], + [ 0.88151194, 0.88690782, 0.91328493], + [ 0.88797938, 0.89205857, 0.91677544], + [ 0.89443865, 0.89721298, 0.9202854 ], + [ 0.90088204, 0.90236294, 0.92380601], + [ 0.90729768, 0.90749778, 0.92732797], + [ 0.91367037, 0.91260329, 0.93083814], + [ 0.91998105, 0.91766106, 0.93431861], + [ 0.92620596, 0.92264789, 0.93774647], + [ 0.93231683, 0.9275351 , 0.94109192], + [ 0.93827772, 0.9322888 , 0.94432312], + [ 0.94404755, 0.93686925, 0.94740137], + [ 0.94958284, 0.94123072, 0.95027696], + [ 0.95482682, 0.9453245 , 0.95291103], + [ 0.9597248 , 0.94909728, 0.95525103], + [ 0.96422552, 0.95249273, 0.95723271], + [ 0.96826161, 0.95545812, 0.95882188], + [ 0.97178458, 0.95793984, 0.95995705], + [ 0.97474105, 0.95989142, 0.96059997], + [ 0.97708604, 0.96127366, 0.96071853], + [ 0.97877855, 0.96205832, 0.96030095], + [ 0.97978484, 0.96222949, 0.95935496], + [ 0.9805997 , 0.96155216, 0.95813083], + [ 0.98152619, 0.95993719, 0.95639322], + [ 0.9819726 , 0.95766608, 0.95399269], + [ 0.98191855, 0.9547873 , 0.95098107], + [ 0.98138514, 0.95134771, 0.94740644], + [ 0.98040845, 0.94739906, 0.94332125], + [ 0.97902107, 0.94300131, 0.93878672], + [ 0.97729348, 0.93820409, 0.93385135], + [ 0.9752533 , 0.933073 , 0.92858252], + [ 0.97297834, 0.92765261, 0.92302309], + [ 0.97049104, 0.92200317, 0.91723505], + [ 0.96784372, 0.91616744, 0.91126063], + [ 0.96507281, 0.91018664, 0.90514124], + [ 0.96222034, 0.90409203, 0.89890756], + [ 0.9593079 , 0.89791478, 0.89259122], + [ 0.95635626, 0.89167908, 0.88621654], + [ 0.95338303, 0.88540373, 0.87980238], + [ 0.95040174, 0.87910333, 0.87336339], + [ 0.94742246, 0.87278899, 0.86691076], + [ 0.94445249, 0.86646893, 0.86045277], + [ 0.94150476, 0.86014606, 0.85399191], + [ 0.93857394, 0.85382798, 0.84753642], + [ 0.93566206, 0.84751766, 0.84108935], + [ 0.93277194, 0.8412164 , 0.83465197], + [ 0.92990106, 0.83492672, 0.82822708], + [ 0.92704736, 0.82865028, 0.82181656], + [ 0.92422703, 0.82238092, 0.81541333], + [ 0.92142581, 0.81612448, 0.80902415], + [ 0.91864501, 0.80988032, 0.80264838], + [ 0.91587578, 0.80365187, 0.79629001], + [ 0.9131367 , 0.79743115, 0.78994 ], + [ 0.91041602, 0.79122265, 0.78360361], + [ 0.90771071, 0.78502727, 0.77728196], + [ 0.90501581, 0.77884674, 0.7709771 ], + [ 0.90235365, 0.77267117, 0.76467793], + [ 0.8997019 , 0.76650962, 0.75839484], + [ 0.89705346, 0.76036481, 0.752131 ], + [ 0.89444021, 0.75422253, 0.74587047], + [ 0.89183355, 0.74809474, 0.73962689], + [ 0.88923216, 0.74198168, 0.73340061], + [ 0.88665892, 0.73587283, 0.72717995], + [ 0.88408839, 0.72977904, 0.72097718], + [ 0.88153537, 0.72369332, 0.71478461], + [ 0.87899389, 0.7176179 , 0.70860487], + [ 0.87645157, 0.71155805, 0.7024439 ], + [ 0.8739399 , 0.70549893, 0.6962854 ], + [ 0.87142626, 0.6994551 , 0.69014561], + [ 0.8689268 , 0.69341868, 0.68401597], + [ 0.86643562, 0.687392 , 0.67789917], + [ 0.86394434, 0.68137863, 0.67179927], + [ 0.86147586, 0.67536728, 0.665704 ], + [ 0.85899928, 0.66937226, 0.6596292 ], + [ 0.85654668, 0.66337773, 0.6535577 ], + [ 0.85408818, 0.65739772, 0.64750494], + [ 0.85164413, 0.65142189, 0.64145983], + [ 0.84920091, 0.6454565 , 0.63542932], + [ 0.84676427, 0.63949827, 0.62941 ], + [ 0.84433231, 0.63354773, 0.62340261], + [ 0.84190106, 0.62760645, 0.61740899], + [ 0.83947935, 0.62166951, 0.61142404], + [ 0.8370538 , 0.61574332, 0.60545478], + [ 0.83463975, 0.60981951, 0.59949247], + [ 0.83221877, 0.60390724, 0.593547 ], + [ 0.82980985, 0.59799607, 0.58760751], + [ 0.82740268, 0.59209095, 0.58167944], + [ 0.82498638, 0.5861973 , 0.57576866], + [ 0.82258181, 0.5803034 , 0.56986307], + [ 0.82016611, 0.57442123, 0.56397539], + [ 0.81776305, 0.56853725, 0.55809173], + [ 0.81534551, 0.56266602, 0.55222741], + [ 0.81294293, 0.55679056, 0.5463651 ], + [ 0.81052113, 0.55092973, 0.54052443], + [ 0.80811509, 0.54506305, 0.53468464], + [ 0.80568952, 0.53921036, 0.52886622], + [ 0.80327506, 0.53335335, 0.52305077], + [ 0.80084727, 0.52750583, 0.51725256], + [ 0.79842217, 0.5216578 , 0.51146173], + [ 0.79599382, 0.51581223, 0.50568155], + [ 0.79355781, 0.50997127, 0.49991444], + [ 0.79112596, 0.50412707, 0.49415289], + [ 0.78867442, 0.49829386, 0.48841129], + [ 0.7862306 , 0.49245398, 0.48267247], + [ 0.7837687 , 0.48662309, 0.47695216], + [ 0.78130809, 0.4807883 , 0.47123805], + [ 0.77884467, 0.47495151, 0.46553236], + [ 0.77636283, 0.46912235, 0.45984473], + [ 0.77388383, 0.46328617, 0.45416141], + [ 0.77138912, 0.45745466, 0.44849398], + [ 0.76888874, 0.45162042, 0.44283573], + [ 0.76638802, 0.44577901, 0.43718292], + [ 0.76386116, 0.43994762, 0.43155211], + [ 0.76133542, 0.43410655, 0.42592523], + [ 0.75880631, 0.42825801, 0.42030488], + [ 0.75624913, 0.42241905, 0.41470727], + [ 0.7536919 , 0.41656866, 0.40911347], + [ 0.75112748, 0.41071104, 0.40352792], + [ 0.74854331, 0.40485474, 0.3979589 ], + [ 0.74594723, 0.39899309, 0.39240088], + [ 0.74334332, 0.39312199, 0.38685075], + [ 0.74073277, 0.38723941, 0.3813074 ], + [ 0.73809409, 0.38136133, 0.37578553], + [ 0.73544692, 0.37547129, 0.37027123], + [ 0.73278943, 0.36956954, 0.36476549], + [ 0.73011829, 0.36365761, 0.35927038], + [ 0.72743485, 0.35773314, 0.35378465], + [ 0.72472722, 0.35180504, 0.34831662], + [ 0.72200473, 0.34586421, 0.34285937], + [ 0.71927052, 0.33990649, 0.33741033], + [ 0.71652049, 0.33393396, 0.33197219], + [ 0.71375362, 0.32794602, 0.32654545], + [ 0.71096951, 0.32194148, 0.32113016], + [ 0.70816772, 0.31591904, 0.31572637], + [ 0.70534784, 0.30987734, 0.31033414], + [ 0.70250944, 0.30381489, 0.30495353], + [ 0.69965211, 0.2977301 , 0.2995846 ], + [ 0.6967754 , 0.29162126, 0.29422741], + [ 0.69388446, 0.28548074, 0.28887769], + [ 0.69097561, 0.2793096 , 0.28353795], + [ 0.68803513, 0.27311993, 0.27821876], + [ 0.6850794 , 0.26689144, 0.27290694], + [ 0.682108 , 0.26062114, 0.26760246], + [ 0.67911013, 0.2543177 , 0.26231367], + [ 0.67609393, 0.24796818, 0.25703372], + [ 0.67305921, 0.24156846, 0.25176238], + [ 0.67000176, 0.23511902, 0.24650278], + [ 0.66693423, 0.22859879, 0.24124404], + [ 0.6638441 , 0.22201742, 0.2359961 ], + [ 0.66080672, 0.21526712, 0.23069468] +] + + +_icefire_lut = [ + [ 0.73936227, 0.90443867, 0.85757238], + [ 0.72888063, 0.89639109, 0.85488394], + [ 0.71834255, 0.88842162, 0.8521605 ], + [ 0.70773866, 0.88052939, 0.849422 ], + [ 0.69706215, 0.87271313, 0.84668315], + [ 0.68629021, 0.86497329, 0.84398721], + [ 0.67543654, 0.85730617, 0.84130969], + [ 0.66448539, 0.84971123, 0.83868005], + [ 0.65342679, 0.84218728, 0.83611512], + [ 0.64231804, 0.83471867, 0.83358584], + [ 0.63117745, 0.827294 , 0.83113431], + [ 0.62000484, 0.81991069, 0.82876741], + [ 0.60879435, 0.81256797, 0.82648905], + [ 0.59754118, 0.80526458, 0.82430414], + [ 0.58624247, 0.79799884, 0.82221573], + [ 0.57489525, 0.7907688 , 0.82022901], + [ 0.56349779, 0.78357215, 0.81834861], + [ 0.55204294, 0.77640827, 0.81657563], + [ 0.54052516, 0.76927562, 0.81491462], + [ 0.52894085, 0.76217215, 0.81336913], + [ 0.51728854, 0.75509528, 0.81194156], + [ 0.50555676, 0.74804469, 0.81063503], + [ 0.49373871, 0.7410187 , 0.80945242], + [ 0.48183174, 0.73401449, 0.80839675], + [ 0.46982587, 0.72703075, 0.80747097], + [ 0.45770893, 0.72006648, 0.80667756], + [ 0.44547249, 0.71311941, 0.80601991], + [ 0.43318643, 0.70617126, 0.80549278], + [ 0.42110294, 0.69916972, 0.80506683], + [ 0.40925101, 0.69211059, 0.80473246], + [ 0.3976693 , 0.68498786, 0.80448272], + [ 0.38632002, 0.67781125, 0.80431024], + [ 0.37523981, 0.67057537, 0.80420832], + [ 0.36442578, 0.66328229, 0.80417474], + [ 0.35385939, 0.65593699, 0.80420591], + [ 0.34358916, 0.64853177, 0.8043 ], + [ 0.33355526, 0.64107876, 0.80445484], + [ 0.32383062, 0.63356578, 0.80467091], + [ 0.31434372, 0.62600624, 0.8049475 ], + [ 0.30516161, 0.618389 , 0.80528692], + [ 0.29623491, 0.61072284, 0.80569021], + [ 0.28759072, 0.60300319, 0.80616055], + [ 0.27923924, 0.59522877, 0.80669803], + [ 0.27114651, 0.5874047 , 0.80730545], + [ 0.26337153, 0.57952055, 0.80799113], + [ 0.25588696, 0.57157984, 0.80875922], + [ 0.248686 , 0.56358255, 0.80961366], + [ 0.24180668, 0.55552289, 0.81055123], + [ 0.23526251, 0.54739477, 0.8115939 ], + [ 0.22921445, 0.53918506, 0.81267292], + [ 0.22397687, 0.53086094, 0.8137141 ], + [ 0.21977058, 0.52241482, 0.81457651], + [ 0.21658989, 0.51384321, 0.81528511], + [ 0.21452772, 0.50514155, 0.81577278], + [ 0.21372783, 0.49630865, 0.81589566], + [ 0.21409503, 0.48734861, 0.81566163], + [ 0.2157176 , 0.47827123, 0.81487615], + [ 0.21842857, 0.46909168, 0.81351614], + [ 0.22211705, 0.45983212, 0.81146983], + [ 0.22665681, 0.45052233, 0.80860217], + [ 0.23176013, 0.44119137, 0.80494325], + [ 0.23727775, 0.43187704, 0.80038017], + [ 0.24298285, 0.42261123, 0.79493267], + [ 0.24865068, 0.41341842, 0.78869164], + [ 0.25423116, 0.40433127, 0.78155831], + [ 0.25950239, 0.39535521, 0.77376848], + [ 0.2644736 , 0.38651212, 0.76524809], + [ 0.26901584, 0.37779582, 0.75621942], + [ 0.27318141, 0.36922056, 0.746605 ], + [ 0.27690355, 0.3607736 , 0.73659374], + [ 0.28023585, 0.35244234, 0.72622103], + [ 0.28306009, 0.34438449, 0.71500731], + [ 0.28535896, 0.33660243, 0.70303975], + [ 0.28708711, 0.32912157, 0.69034504], + [ 0.28816354, 0.32200604, 0.67684067], + [ 0.28862749, 0.31519824, 0.66278813], + [ 0.28847904, 0.30869064, 0.6482815 ], + [ 0.28770912, 0.30250126, 0.63331265], + [ 0.28640325, 0.29655509, 0.61811374], + [ 0.28458943, 0.29082155, 0.60280913], + [ 0.28233561, 0.28527482, 0.58742866], + [ 0.27967038, 0.2798938 , 0.57204225], + [ 0.27665361, 0.27465357, 0.55667809], + [ 0.27332564, 0.2695165 , 0.54145387], + [ 0.26973851, 0.26447054, 0.52634916], + [ 0.2659204 , 0.25949691, 0.511417 ], + [ 0.26190145, 0.25458123, 0.49668768], + [ 0.2577151 , 0.24971691, 0.48214874], + [ 0.25337618, 0.24490494, 0.46778758], + [ 0.24890842, 0.24013332, 0.45363816], + [ 0.24433654, 0.23539226, 0.4397245 ], + [ 0.23967922, 0.23067729, 0.4260591 ], + [ 0.23495608, 0.22598894, 0.41262952], + [ 0.23018113, 0.22132414, 0.39945577], + [ 0.22534609, 0.21670847, 0.38645794], + [ 0.22048761, 0.21211723, 0.37372555], + [ 0.2156198 , 0.20755389, 0.36125301], + [ 0.21074637, 0.20302717, 0.34903192], + [ 0.20586893, 0.19855368, 0.33701661], + [ 0.20101757, 0.19411573, 0.32529173], + [ 0.19619947, 0.18972425, 0.31383846], + [ 0.19140726, 0.18540157, 0.30260777], + [ 0.1866769 , 0.1811332 , 0.29166583], + [ 0.18201285, 0.17694992, 0.28088776], + [ 0.17745228, 0.17282141, 0.27044211], + [ 0.17300684, 0.16876921, 0.26024893], + [ 0.16868273, 0.16479861, 0.25034479], + [ 0.16448691, 0.16091728, 0.24075373], + [ 0.16043195, 0.15714351, 0.23141745], + [ 0.15652427, 0.15348248, 0.22238175], + [ 0.15277065, 0.14994111, 0.21368395], + [ 0.14918274, 0.14653431, 0.20529486], + [ 0.14577095, 0.14327403, 0.19720829], + [ 0.14254381, 0.14016944, 0.18944326], + [ 0.13951035, 0.13723063, 0.18201072], + [ 0.13667798, 0.13446606, 0.17493774], + [ 0.13405762, 0.13188822, 0.16820842], + [ 0.13165767, 0.12950667, 0.16183275], + [ 0.12948748, 0.12733187, 0.15580631], + [ 0.12755435, 0.1253723 , 0.15014098], + [ 0.12586516, 0.12363617, 0.1448459 ], + [ 0.12442647, 0.12213143, 0.13992571], + [ 0.12324241, 0.12086419, 0.13539995], + [ 0.12232067, 0.11984278, 0.13124644], + [ 0.12166209, 0.11907077, 0.12749671], + [ 0.12126982, 0.11855309, 0.12415079], + [ 0.12114244, 0.11829179, 0.1212385 ], + [ 0.12127766, 0.11828837, 0.11878534], + [ 0.12284806, 0.1179729 , 0.11772022], + [ 0.12619498, 0.11721796, 0.11770203], + [ 0.129968 , 0.11663788, 0.11792377], + [ 0.13410011, 0.11625146, 0.11839138], + [ 0.13855459, 0.11606618, 0.11910584], + [ 0.14333775, 0.11607038, 0.1200606 ], + [ 0.148417 , 0.11626929, 0.12125453], + [ 0.15377389, 0.11666192, 0.12268364], + [ 0.15941427, 0.11723486, 0.12433911], + [ 0.16533376, 0.11797856, 0.12621303], + [ 0.17152547, 0.11888403, 0.12829735], + [ 0.17797765, 0.11994436, 0.13058435], + [ 0.18468769, 0.12114722, 0.13306426], + [ 0.19165663, 0.12247737, 0.13572616], + [ 0.19884415, 0.12394381, 0.1385669 ], + [ 0.20627181, 0.12551883, 0.14157124], + [ 0.21394877, 0.12718055, 0.14472604], + [ 0.22184572, 0.12893119, 0.14802579], + [ 0.22994394, 0.13076731, 0.15146314], + [ 0.23823937, 0.13267611, 0.15502793], + [ 0.24676041, 0.13462172, 0.15870321], + [ 0.25546457, 0.13661751, 0.16248722], + [ 0.26433628, 0.13865956, 0.16637301], + [ 0.27341345, 0.14070412, 0.17034221], + [ 0.28264773, 0.14277192, 0.1743957 ], + [ 0.29202272, 0.14486161, 0.17852793], + [ 0.30159648, 0.14691224, 0.1827169 ], + [ 0.31129002, 0.14897583, 0.18695213], + [ 0.32111555, 0.15103351, 0.19119629], + [ 0.33107961, 0.1530674 , 0.19543758], + [ 0.34119892, 0.15504762, 0.1996803 ], + [ 0.35142388, 0.15701131, 0.20389086], + [ 0.36178937, 0.1589124 , 0.20807639], + [ 0.37229381, 0.16073993, 0.21223189], + [ 0.38288348, 0.16254006, 0.2163249 ], + [ 0.39359592, 0.16426336, 0.22036577], + [ 0.40444332, 0.16588767, 0.22434027], + [ 0.41537995, 0.16745325, 0.2282297 ], + [ 0.42640867, 0.16894939, 0.23202755], + [ 0.43754706, 0.17034847, 0.23572899], + [ 0.44878564, 0.1716535 , 0.23932344], + [ 0.4601126 , 0.17287365, 0.24278607], + [ 0.47151732, 0.17401641, 0.24610337], + [ 0.48300689, 0.17506676, 0.2492737 ], + [ 0.49458302, 0.17601892, 0.25227688], + [ 0.50623876, 0.17687777, 0.255096 ], + [ 0.5179623 , 0.17765528, 0.2577162 ], + [ 0.52975234, 0.17835232, 0.2601134 ], + [ 0.54159776, 0.17898292, 0.26226847], + [ 0.55348804, 0.17956232, 0.26416003], + [ 0.56541729, 0.18010175, 0.26575971], + [ 0.57736669, 0.180631 , 0.26704888], + [ 0.58932081, 0.18117827, 0.26800409], + [ 0.60127582, 0.18175888, 0.26858488], + [ 0.61319563, 0.1824336 , 0.2687872 ], + [ 0.62506376, 0.18324015, 0.26858301], + [ 0.63681202, 0.18430173, 0.26795276], + [ 0.64842603, 0.18565472, 0.26689463], + [ 0.65988195, 0.18734638, 0.26543435], + [ 0.67111966, 0.18948885, 0.26357955], + [ 0.68209194, 0.19216636, 0.26137175], + [ 0.69281185, 0.19535326, 0.25887063], + [ 0.70335022, 0.19891271, 0.25617971], + [ 0.71375229, 0.20276438, 0.25331365], + [ 0.72401436, 0.20691287, 0.25027366], + [ 0.73407638, 0.21145051, 0.24710661], + [ 0.74396983, 0.21631913, 0.24380715], + [ 0.75361506, 0.22163653, 0.24043996], + [ 0.7630579 , 0.22731637, 0.23700095], + [ 0.77222228, 0.23346231, 0.23356628], + [ 0.78115441, 0.23998404, 0.23013825], + [ 0.78979746, 0.24694858, 0.22678822], + [ 0.79819286, 0.25427223, 0.22352658], + [ 0.80630444, 0.26198807, 0.22040877], + [ 0.81417437, 0.27001406, 0.21744645], + [ 0.82177364, 0.27837336, 0.21468316], + [ 0.82915955, 0.28696963, 0.21210766], + [ 0.83628628, 0.2958499 , 0.20977813], + [ 0.84322168, 0.30491136, 0.20766435], + [ 0.84995458, 0.31415945, 0.2057863 ], + [ 0.85648867, 0.32358058, 0.20415327], + [ 0.86286243, 0.33312058, 0.20274969], + [ 0.86908321, 0.34276705, 0.20157271], + [ 0.87512876, 0.3525416 , 0.20064949], + [ 0.88100349, 0.36243385, 0.19999078], + [ 0.8866469 , 0.37249496, 0.1997976 ], + [ 0.89203964, 0.38273475, 0.20013431], + [ 0.89713496, 0.39318156, 0.20121514], + [ 0.90195099, 0.40380687, 0.20301555], + [ 0.90648379, 0.41460191, 0.20558847], + [ 0.9106967 , 0.42557857, 0.20918529], + [ 0.91463791, 0.43668557, 0.21367954], + [ 0.91830723, 0.44790913, 0.21916352], + [ 0.92171507, 0.45922856, 0.22568002], + [ 0.92491786, 0.4705936 , 0.23308207], + [ 0.92790792, 0.48200153, 0.24145932], + [ 0.93073701, 0.49341219, 0.25065486], + [ 0.93343918, 0.5048017 , 0.26056148], + [ 0.93602064, 0.51616486, 0.27118485], + [ 0.93850535, 0.52748892, 0.28242464], + [ 0.94092933, 0.53875462, 0.29416042], + [ 0.94330011, 0.5499628 , 0.30634189], + [ 0.94563159, 0.56110987, 0.31891624], + [ 0.94792955, 0.57219822, 0.33184256], + [ 0.95020929, 0.5832232 , 0.34508419], + [ 0.95247324, 0.59419035, 0.35859866], + [ 0.95471709, 0.60510869, 0.37236035], + [ 0.95698411, 0.61595766, 0.38629631], + [ 0.95923863, 0.62676473, 0.40043317], + [ 0.9615041 , 0.6375203 , 0.41474106], + [ 0.96371553, 0.64826619, 0.42928335], + [ 0.96591497, 0.65899621, 0.44380444], + [ 0.96809871, 0.66971662, 0.45830232], + [ 0.9702495 , 0.6804394 , 0.47280492], + [ 0.9723881 , 0.69115622, 0.48729272], + [ 0.97450723, 0.70187358, 0.50178034], + [ 0.9766108 , 0.712592 , 0.51626837], + [ 0.97871716, 0.72330511, 0.53074053], + [ 0.98082222, 0.73401769, 0.54520694], + [ 0.9829001 , 0.74474445, 0.5597019 ], + [ 0.98497466, 0.75547635, 0.57420239], + [ 0.98705581, 0.76621129, 0.58870185], + [ 0.98913325, 0.77695637, 0.60321626], + [ 0.99119918, 0.78771716, 0.61775821], + [ 0.9932672 , 0.79848979, 0.63231691], + [ 0.99535958, 0.80926704, 0.64687278], + [ 0.99740544, 0.82008078, 0.66150571], + [ 0.9992197 , 0.83100723, 0.6764127 ] +] + + +_flare_lut = [ + [0.92907237, 0.68878959, 0.50411509], + [0.92891402, 0.68494686, 0.50173994], + [0.92864754, 0.68116207, 0.4993754], + [0.92836112, 0.67738527, 0.49701572], + [0.9280599, 0.67361354, 0.49466044], + [0.92775569, 0.66983999, 0.49230866], + [0.9274375, 0.66607098, 0.48996097], + [0.927111, 0.66230315, 0.48761688], + [0.92677996, 0.6585342, 0.485276], + [0.92644317, 0.65476476, 0.48293832], + [0.92609759, 0.65099658, 0.48060392], + [0.925747, 0.64722729, 0.47827244], + [0.92539502, 0.64345456, 0.47594352], + [0.92503106, 0.6396848, 0.47361782], + [0.92466877, 0.6359095, 0.47129427], + [0.92429828, 0.63213463, 0.46897349], + [0.92392172, 0.62835879, 0.46665526], + [0.92354597, 0.62457749, 0.46433898], + [0.9231622, 0.6207962, 0.46202524], + [0.92277222, 0.61701365, 0.45971384], + [0.92237978, 0.61322733, 0.45740444], + [0.92198615, 0.60943622, 0.45509686], + [0.92158735, 0.60564276, 0.45279137], + [0.92118373, 0.60184659, 0.45048789], + [0.92077582, 0.59804722, 0.44818634], + [0.92036413, 0.59424414, 0.44588663], + [0.91994924, 0.5904368, 0.44358868], + [0.91952943, 0.58662619, 0.4412926], + [0.91910675, 0.58281075, 0.43899817], + [0.91868096, 0.57899046, 0.4367054], + [0.91825103, 0.57516584, 0.43441436], + [0.91781857, 0.57133556, 0.43212486], + [0.9173814, 0.56750099, 0.4298371], + [0.91694139, 0.56366058, 0.42755089], + [0.91649756, 0.55981483, 0.42526631], + [0.91604942, 0.55596387, 0.42298339], + [0.9155979, 0.55210684, 0.42070204], + [0.9151409, 0.54824485, 0.4184247], + [0.91466138, 0.54438817, 0.41617858], + [0.91416896, 0.54052962, 0.41396347], + [0.91366559, 0.53666778, 0.41177769], + [0.91315173, 0.53280208, 0.40962196], + [0.91262605, 0.52893336, 0.40749715], + [0.91208866, 0.52506133, 0.40540404], + [0.91153952, 0.52118582, 0.40334346], + [0.91097732, 0.51730767, 0.4013163], + [0.910403, 0.51342591, 0.39932342], + [0.90981494, 0.50954168, 0.39736571], + [0.90921368, 0.5056543, 0.39544411], + [0.90859797, 0.50176463, 0.39355952], + [0.90796841, 0.49787195, 0.39171297], + [0.90732341, 0.4939774, 0.38990532], + [0.90666382, 0.49008006, 0.38813773], + [0.90598815, 0.486181, 0.38641107], + [0.90529624, 0.48228017, 0.38472641], + [0.90458808, 0.47837738, 0.38308489], + [0.90386248, 0.47447348, 0.38148746], + [0.90311921, 0.4705685, 0.37993524], + [0.90235809, 0.46666239, 0.37842943], + [0.90157824, 0.46275577, 0.37697105], + [0.90077904, 0.45884905, 0.37556121], + [0.89995995, 0.45494253, 0.37420106], + [0.89912041, 0.4510366, 0.37289175], + [0.8982602, 0.44713126, 0.37163458], + [0.89737819, 0.44322747, 0.37043052], + [0.89647387, 0.43932557, 0.36928078], + [0.89554477, 0.43542759, 0.36818855], + [0.89458871, 0.4315354, 0.36715654], + [0.89360794, 0.42764714, 0.36618273], + [0.89260152, 0.42376366, 0.36526813], + [0.8915687, 0.41988565, 0.36441384], + [0.89050882, 0.41601371, 0.36362102], + [0.8894159, 0.41215334, 0.36289639], + [0.888292, 0.40830288, 0.36223756], + [0.88713784, 0.40446193, 0.36164328], + [0.88595253, 0.40063149, 0.36111438], + [0.88473115, 0.39681635, 0.3606566], + [0.88347246, 0.39301805, 0.36027074], + [0.88217931, 0.38923439, 0.35995244], + [0.880851, 0.38546632, 0.35970244], + [0.87947728, 0.38172422, 0.35953127], + [0.87806542, 0.37800172, 0.35942941], + [0.87661509, 0.37429964, 0.35939659], + [0.87511668, 0.37062819, 0.35944178], + [0.87357554, 0.36698279, 0.35955811], + [0.87199254, 0.3633634, 0.35974223], + [0.87035691, 0.35978174, 0.36000516], + [0.86867647, 0.35623087, 0.36033559], + [0.86694949, 0.35271349, 0.36073358], + [0.86516775, 0.34923921, 0.36120624], + [0.86333996, 0.34580008, 0.36174113], + [0.86145909, 0.3424046, 0.36234402], + [0.85952586, 0.33905327, 0.36301129], + [0.85754536, 0.33574168, 0.36373567], + [0.855514, 0.33247568, 0.36451271], + [0.85344392, 0.32924217, 0.36533344], + [0.8513284, 0.32604977, 0.36620106], + [0.84916723, 0.32289973, 0.36711424], + [0.84696243, 0.31979068, 0.36806976], + [0.84470627, 0.31673295, 0.36907066], + [0.84240761, 0.31371695, 0.37010969], + [0.84005337, 0.31075974, 0.37119284], + [0.83765537, 0.30784814, 0.3723105], + [0.83520234, 0.30499724, 0.37346726], + [0.83270291, 0.30219766, 0.37465552], + [0.83014895, 0.29946081, 0.37587769], + [0.82754694, 0.29677989, 0.37712733], + [0.82489111, 0.29416352, 0.37840532], + [0.82218644, 0.29160665, 0.37970606], + [0.81942908, 0.28911553, 0.38102921], + [0.81662276, 0.28668665, 0.38236999], + [0.81376555, 0.28432371, 0.383727], + [0.81085964, 0.28202508, 0.38509649], + [0.8079055, 0.27979128, 0.38647583], + [0.80490309, 0.27762348, 0.3878626], + [0.80185613, 0.2755178, 0.38925253], + [0.79876118, 0.27347974, 0.39064559], + [0.79562644, 0.27149928, 0.39203532], + [0.79244362, 0.2695883, 0.39342447], + [0.78922456, 0.26773176, 0.3948046], + [0.78596161, 0.26594053, 0.39617873], + [0.7826624, 0.26420493, 0.39754146], + [0.77932717, 0.26252522, 0.39889102], + [0.77595363, 0.2609049, 0.4002279], + [0.77254999, 0.25933319, 0.40154704], + [0.76911107, 0.25781758, 0.40284959], + [0.76564158, 0.25635173, 0.40413341], + [0.76214598, 0.25492998, 0.40539471], + [0.75861834, 0.25356035, 0.40663694], + [0.75506533, 0.25223402, 0.40785559], + [0.75148963, 0.2509473, 0.40904966], + [0.74788835, 0.24970413, 0.41022028], + [0.74426345, 0.24850191, 0.41136599], + [0.74061927, 0.24733457, 0.41248516], + [0.73695678, 0.24620072, 0.41357737], + [0.73327278, 0.24510469, 0.41464364], + [0.72957096, 0.24404127, 0.4156828], + [0.72585394, 0.24300672, 0.41669383], + [0.7221226, 0.24199971, 0.41767651], + [0.71837612, 0.24102046, 0.41863486], + [0.71463236, 0.24004289, 0.41956983], + [0.7108932, 0.23906316, 0.42048681], + [0.70715842, 0.23808142, 0.42138647], + [0.70342811, 0.2370976, 0.42226844], + [0.69970218, 0.23611179, 0.42313282], + [0.69598055, 0.2351247, 0.42397678], + [0.69226314, 0.23413578, 0.42480327], + [0.68854988, 0.23314511, 0.42561234], + [0.68484064, 0.23215279, 0.42640419], + [0.68113541, 0.23115942, 0.42717615], + [0.67743412, 0.23016472, 0.42792989], + [0.67373662, 0.22916861, 0.42866642], + [0.67004287, 0.22817117, 0.42938576], + [0.66635279, 0.22717328, 0.43008427], + [0.66266621, 0.22617435, 0.43076552], + [0.65898313, 0.22517434, 0.43142956], + [0.65530349, 0.22417381, 0.43207427], + [0.65162696, 0.22317307, 0.4327001], + [0.64795375, 0.22217149, 0.43330852], + [0.64428351, 0.22116972, 0.43389854], + [0.64061624, 0.22016818, 0.43446845], + [0.63695183, 0.21916625, 0.43502123], + [0.63329016, 0.21816454, 0.43555493], + [0.62963102, 0.2171635, 0.43606881], + [0.62597451, 0.21616235, 0.43656529], + [0.62232019, 0.21516239, 0.43704153], + [0.61866821, 0.21416307, 0.43749868], + [0.61501835, 0.21316435, 0.43793808], + [0.61137029, 0.21216761, 0.4383556], + [0.60772426, 0.2111715, 0.43875552], + [0.60407977, 0.21017746, 0.43913439], + [0.60043678, 0.20918503, 0.43949412], + [0.59679524, 0.20819447, 0.43983393], + [0.59315487, 0.20720639, 0.44015254], + [0.58951566, 0.20622027, 0.44045213], + [0.58587715, 0.20523751, 0.44072926], + [0.5822395, 0.20425693, 0.44098758], + [0.57860222, 0.20328034, 0.44122241], + [0.57496549, 0.20230637, 0.44143805], + [0.57132875, 0.20133689, 0.4416298], + [0.56769215, 0.20037071, 0.44180142], + [0.5640552, 0.19940936, 0.44194923], + [0.56041794, 0.19845221, 0.44207535], + [0.55678004, 0.1975, 0.44217824], + [0.55314129, 0.19655316, 0.44225723], + [0.54950166, 0.19561118, 0.44231412], + [0.54585987, 0.19467771, 0.44234111], + [0.54221157, 0.19375869, 0.44233698], + [0.5385549, 0.19285696, 0.44229959], + [0.5348913, 0.19197036, 0.44222958], + [0.53122177, 0.1910974, 0.44212735], + [0.52754464, 0.19024042, 0.44199159], + [0.52386353, 0.18939409, 0.44182449], + [0.52017476, 0.18856368, 0.44162345], + [0.51648277, 0.18774266, 0.44139128], + [0.51278481, 0.18693492, 0.44112605], + [0.50908361, 0.18613639, 0.4408295], + [0.50537784, 0.18534893, 0.44050064], + [0.50166912, 0.18457008, 0.44014054], + [0.49795686, 0.18380056, 0.43974881], + [0.49424218, 0.18303865, 0.43932623], + [0.49052472, 0.18228477, 0.43887255], + [0.48680565, 0.1815371, 0.43838867], + [0.48308419, 0.18079663, 0.43787408], + [0.47936222, 0.18006056, 0.43733022], + [0.47563799, 0.17933127, 0.43675585], + [0.47191466, 0.17860416, 0.43615337], + [0.46818879, 0.17788392, 0.43552047], + [0.46446454, 0.17716458, 0.43486036], + [0.46073893, 0.17645017, 0.43417097], + [0.45701462, 0.17573691, 0.43345429], + [0.45329097, 0.17502549, 0.43271025], + [0.44956744, 0.17431649, 0.4319386], + [0.44584668, 0.17360625, 0.43114133], + [0.44212538, 0.17289906, 0.43031642], + [0.43840678, 0.17219041, 0.42946642], + [0.43469046, 0.17148074, 0.42859124], + [0.4309749, 0.17077192, 0.42769008], + [0.42726297, 0.17006003, 0.42676519], + [0.42355299, 0.16934709, 0.42581586], + [0.41984535, 0.16863258, 0.42484219], + [0.41614149, 0.16791429, 0.42384614], + [0.41244029, 0.16719372, 0.42282661], + [0.40874177, 0.16647061, 0.42178429], + [0.40504765, 0.16574261, 0.42072062], + [0.401357, 0.16501079, 0.41963528], + [0.397669, 0.16427607, 0.418528], + [0.39398585, 0.16353554, 0.41740053], + [0.39030735, 0.16278924, 0.41625344], + [0.3866314, 0.16203977, 0.41508517], + [0.38295904, 0.16128519, 0.41389849], + [0.37928736, 0.16052483, 0.41270599], + [0.37562649, 0.15974704, 0.41151182], + [0.37197803, 0.15895049, 0.41031532], + [0.36833779, 0.15813871, 0.40911916], + [0.36470944, 0.15730861, 0.40792149], + [0.36109117, 0.15646169, 0.40672362], + [0.35748213, 0.15559861, 0.40552633], + [0.353885, 0.15471714, 0.40432831], + [0.35029682, 0.15381967, 0.4031316], + [0.34671861, 0.1529053, 0.40193587], + [0.34315191, 0.15197275, 0.40074049], + [0.33959331, 0.15102466, 0.3995478], + [0.33604378, 0.15006017, 0.39835754], + [0.33250529, 0.14907766, 0.39716879], + [0.32897621, 0.14807831, 0.39598285], + [0.3254559, 0.14706248, 0.39480044], + [0.32194567, 0.14602909, 0.39362106], + [0.31844477, 0.14497857, 0.39244549], + [0.31494974, 0.14391333, 0.39127626], + [0.31146605, 0.14282918, 0.39011024], + [0.30798857, 0.1417297, 0.38895105], + [0.30451661, 0.14061515, 0.38779953], + [0.30105136, 0.13948445, 0.38665531], + [0.2975886, 0.1383403, 0.38552159], + [0.29408557, 0.13721193, 0.38442775] +] + + +_crest_lut = [ + [0.6468274, 0.80289262, 0.56592265], + [0.64233318, 0.80081141, 0.56639461], + [0.63791969, 0.7987162, 0.56674976], + [0.6335316, 0.79661833, 0.56706128], + [0.62915226, 0.7945212, 0.56735066], + [0.62477862, 0.79242543, 0.56762143], + [0.62042003, 0.79032918, 0.56786129], + [0.61606327, 0.78823508, 0.56808666], + [0.61171322, 0.78614216, 0.56829092], + [0.60736933, 0.78405055, 0.56847436], + [0.60302658, 0.78196121, 0.56864272], + [0.59868708, 0.77987374, 0.56879289], + [0.59435366, 0.77778758, 0.56892099], + [0.59001953, 0.77570403, 0.56903477], + [0.58568753, 0.77362254, 0.56913028], + [0.58135593, 0.77154342, 0.56920908], + [0.57702623, 0.76946638, 0.56926895], + [0.57269165, 0.76739266, 0.5693172], + [0.56835934, 0.76532092, 0.56934507], + [0.56402533, 0.76325185, 0.56935664], + [0.55968429, 0.76118643, 0.56935732], + [0.55534159, 0.75912361, 0.56934052], + [0.55099572, 0.75706366, 0.56930743], + [0.54664626, 0.75500662, 0.56925799], + [0.54228969, 0.75295306, 0.56919546], + [0.53792417, 0.75090328, 0.56912118], + [0.53355172, 0.74885687, 0.5690324], + [0.52917169, 0.74681387, 0.56892926], + [0.52478243, 0.74477453, 0.56881287], + [0.52038338, 0.74273888, 0.56868323], + [0.5159739, 0.74070697, 0.56854039], + [0.51155269, 0.73867895, 0.56838507], + [0.50711872, 0.73665492, 0.56821764], + [0.50267118, 0.73463494, 0.56803826], + [0.49822926, 0.73261388, 0.56785146], + [0.49381422, 0.73058524, 0.56767484], + [0.48942421, 0.72854938, 0.56751036], + [0.48505993, 0.72650623, 0.56735752], + [0.48072207, 0.72445575, 0.56721583], + [0.4764113, 0.72239788, 0.56708475], + [0.47212827, 0.72033258, 0.56696376], + [0.46787361, 0.71825983, 0.56685231], + [0.46364792, 0.71617961, 0.56674986], + [0.45945271, 0.71409167, 0.56665625], + [0.45528878, 0.71199595, 0.56657103], + [0.45115557, 0.70989276, 0.5664931], + [0.44705356, 0.70778212, 0.56642189], + [0.44298321, 0.70566406, 0.56635683], + [0.43894492, 0.70353863, 0.56629734], + [0.43493911, 0.70140588, 0.56624286], + [0.43096612, 0.69926587, 0.5661928], + [0.42702625, 0.69711868, 0.56614659], + [0.42311977, 0.69496438, 0.56610368], + [0.41924689, 0.69280308, 0.56606355], + [0.41540778, 0.69063486, 0.56602564], + [0.41160259, 0.68845984, 0.56598944], + [0.40783143, 0.68627814, 0.56595436], + [0.40409434, 0.68408988, 0.56591994], + [0.40039134, 0.68189518, 0.56588564], + [0.39672238, 0.6796942, 0.56585103], + [0.39308781, 0.67748696, 0.56581581], + [0.38949137, 0.67527276, 0.56578084], + [0.38592889, 0.67305266, 0.56574422], + [0.38240013, 0.67082685, 0.56570561], + [0.37890483, 0.66859548, 0.56566462], + [0.37544276, 0.66635871, 0.56562081], + [0.37201365, 0.66411673, 0.56557372], + [0.36861709, 0.6618697, 0.5655231], + [0.36525264, 0.65961782, 0.56546873], + [0.36191986, 0.65736125, 0.56541032], + [0.35861935, 0.65509998, 0.56534768], + [0.35535621, 0.65283302, 0.56528211], + [0.35212361, 0.65056188, 0.56521171], + [0.34892097, 0.64828676, 0.56513633], + [0.34574785, 0.64600783, 0.56505539], + [0.34260357, 0.64372528, 0.5649689], + [0.33948744, 0.64143931, 0.56487679], + [0.33639887, 0.6391501, 0.56477869], + [0.33334501, 0.63685626, 0.56467661], + [0.33031952, 0.63455911, 0.564569], + [0.3273199, 0.63225924, 0.56445488], + [0.32434526, 0.62995682, 0.56433457], + [0.32139487, 0.62765201, 0.56420795], + [0.31846807, 0.62534504, 0.56407446], + [0.3155731, 0.62303426, 0.56393695], + [0.31270304, 0.62072111, 0.56379321], + [0.30985436, 0.61840624, 0.56364307], + [0.30702635, 0.61608984, 0.56348606], + [0.30421803, 0.61377205, 0.56332267], + [0.30143611, 0.61145167, 0.56315419], + [0.29867863, 0.60912907, 0.56298054], + [0.29593872, 0.60680554, 0.56280022], + [0.29321538, 0.60448121, 0.56261376], + [0.2905079, 0.60215628, 0.56242036], + [0.28782827, 0.5998285, 0.56222366], + [0.28516521, 0.59749996, 0.56202093], + [0.28251558, 0.59517119, 0.56181204], + [0.27987847, 0.59284232, 0.56159709], + [0.27726216, 0.59051189, 0.56137785], + [0.27466434, 0.58818027, 0.56115433], + [0.2720767, 0.58584893, 0.56092486], + [0.26949829, 0.58351797, 0.56068983], + [0.26693801, 0.58118582, 0.56045121], + [0.26439366, 0.57885288, 0.56020858], + [0.26185616, 0.57652063, 0.55996077], + [0.25932459, 0.57418919, 0.55970795], + [0.25681303, 0.57185614, 0.55945297], + [0.25431024, 0.56952337, 0.55919385], + [0.25180492, 0.56719255, 0.5589305], + [0.24929311, 0.56486397, 0.5586654], + [0.24678356, 0.56253666, 0.55839491], + [0.24426587, 0.56021153, 0.55812473], + [0.24174022, 0.55788852, 0.55785448], + [0.23921167, 0.55556705, 0.55758211], + [0.23668315, 0.55324675, 0.55730676], + [0.23414742, 0.55092825, 0.55703167], + [0.23160473, 0.54861143, 0.5567573], + [0.22905996, 0.54629572, 0.55648168], + [0.22651648, 0.54398082, 0.5562029], + [0.22396709, 0.54166721, 0.55592542], + [0.22141221, 0.53935481, 0.55564885], + [0.21885269, 0.53704347, 0.55537294], + [0.21629986, 0.53473208, 0.55509319], + [0.21374297, 0.53242154, 0.5548144], + [0.21118255, 0.53011166, 0.55453708], + [0.2086192, 0.52780237, 0.55426067], + [0.20605624, 0.52549322, 0.55398479], + [0.20350004, 0.5231837, 0.55370601], + [0.20094292, 0.52087429, 0.55342884], + [0.19838567, 0.51856489, 0.55315283], + [0.19582911, 0.51625531, 0.55287818], + [0.19327413, 0.51394542, 0.55260469], + [0.19072933, 0.51163448, 0.5523289], + [0.18819045, 0.50932268, 0.55205372], + [0.18565609, 0.50701014, 0.55177937], + [0.18312739, 0.50469666, 0.55150597], + [0.18060561, 0.50238204, 0.55123374], + [0.178092, 0.50006616, 0.55096224], + [0.17558808, 0.49774882, 0.55069118], + [0.17310341, 0.49542924, 0.5504176], + [0.17063111, 0.49310789, 0.55014445], + [0.1681728, 0.49078458, 0.54987159], + [0.1657302, 0.48845913, 0.54959882], + [0.16330517, 0.48613135, 0.54932605], + [0.16089963, 0.48380104, 0.54905306], + [0.15851561, 0.48146803, 0.54877953], + [0.15615526, 0.47913212, 0.54850526], + [0.15382083, 0.47679313, 0.54822991], + [0.15151471, 0.47445087, 0.54795318], + [0.14924112, 0.47210502, 0.54767411], + [0.1470032, 0.46975537, 0.54739226], + [0.14480101, 0.46740187, 0.54710832], + [0.14263736, 0.46504434, 0.54682188], + [0.14051521, 0.46268258, 0.54653253], + [0.13843761, 0.46031639, 0.54623985], + [0.13640774, 0.45794558, 0.5459434], + [0.13442887, 0.45556994, 0.54564272], + [0.1325044, 0.45318928, 0.54533736], + [0.13063777, 0.4508034, 0.54502674], + [0.12883252, 0.44841211, 0.5447104], + [0.12709242, 0.44601517, 0.54438795], + [0.1254209, 0.44361244, 0.54405855], + [0.12382162, 0.44120373, 0.54372156], + [0.12229818, 0.43878887, 0.54337634], + [0.12085453, 0.4363676, 0.54302253], + [0.11949938, 0.43393955, 0.54265715], + [0.11823166, 0.43150478, 0.54228104], + [0.11705496, 0.42906306, 0.54189388], + [0.115972, 0.42661431, 0.54149449], + [0.11498598, 0.42415835, 0.54108222], + [0.11409965, 0.42169502, 0.54065622], + [0.11331533, 0.41922424, 0.5402155], + [0.11263542, 0.41674582, 0.53975931], + [0.1120615, 0.4142597, 0.53928656], + [0.11159738, 0.41176567, 0.53879549], + [0.11125248, 0.40926325, 0.53828203], + [0.11101698, 0.40675289, 0.53774864], + [0.11089152, 0.40423445, 0.53719455], + [0.11085121, 0.4017095, 0.53662425], + [0.11087217, 0.39917938, 0.53604354], + [0.11095515, 0.39664394, 0.53545166], + [0.11110676, 0.39410282, 0.53484509], + [0.11131735, 0.39155635, 0.53422678], + [0.11158595, 0.38900446, 0.53359634], + [0.11191139, 0.38644711, 0.5329534], + [0.11229224, 0.38388426, 0.53229748], + [0.11273683, 0.38131546, 0.53162393], + [0.11323438, 0.37874109, 0.53093619], + [0.11378271, 0.37616112, 0.53023413], + [0.11437992, 0.37357557, 0.52951727], + [0.11502681, 0.37098429, 0.52878396], + [0.11572661, 0.36838709, 0.52803124], + [0.11646936, 0.36578429, 0.52726234], + [0.11725299, 0.3631759, 0.52647685], + [0.1180755, 0.36056193, 0.52567436], + [0.1189438, 0.35794203, 0.5248497], + [0.11984752, 0.35531657, 0.52400649], + [0.1207833, 0.35268564, 0.52314492], + [0.12174895, 0.35004927, 0.52226461], + [0.12274959, 0.34740723, 0.52136104], + [0.12377809, 0.34475975, 0.52043639], + [0.12482961, 0.34210702, 0.51949179], + [0.125902, 0.33944908, 0.51852688], + [0.12699998, 0.33678574, 0.51753708], + [0.12811691, 0.33411727, 0.51652464], + [0.12924811, 0.33144384, 0.51549084], + [0.13039157, 0.32876552, 0.51443538], + [0.13155228, 0.32608217, 0.51335321], + [0.13272282, 0.32339407, 0.51224759], + [0.13389954, 0.32070138, 0.51111946], + [0.13508064, 0.31800419, 0.50996862], + [0.13627149, 0.31530238, 0.50878942], + [0.13746376, 0.31259627, 0.50758645], + [0.13865499, 0.30988598, 0.50636017], + [0.13984364, 0.30717161, 0.50511042], + [0.14103515, 0.30445309, 0.50383119], + [0.14222093, 0.30173071, 0.50252813], + [0.14339946, 0.2990046, 0.50120127], + [0.14456941, 0.29627483, 0.49985054], + [0.14573579, 0.29354139, 0.49847009], + [0.14689091, 0.29080452, 0.49706566], + [0.1480336, 0.28806432, 0.49563732], + [0.1491628, 0.28532086, 0.49418508], + [0.15028228, 0.28257418, 0.49270402], + [0.15138673, 0.27982444, 0.49119848], + [0.15247457, 0.27707172, 0.48966925], + [0.15354487, 0.2743161, 0.48811641], + [0.15459955, 0.27155765, 0.4865371], + [0.15563716, 0.26879642, 0.4849321], + [0.1566572, 0.26603191, 0.48330429], + [0.15765823, 0.26326032, 0.48167456], + [0.15862147, 0.26048295, 0.48005785], + [0.15954301, 0.25770084, 0.47845341], + [0.16043267, 0.25491144, 0.4768626], + [0.16129262, 0.25211406, 0.4752857], + [0.1621119, 0.24931169, 0.47372076], + [0.16290577, 0.24649998, 0.47217025], + [0.16366819, 0.24368054, 0.47063302], + [0.1644021, 0.24085237, 0.46910949], + [0.16510882, 0.2380149, 0.46759982], + [0.16579015, 0.23516739, 0.46610429], + [0.1664433, 0.2323105, 0.46462219], + [0.16707586, 0.22944155, 0.46315508], + [0.16768475, 0.22656122, 0.46170223], + [0.16826815, 0.22366984, 0.46026308], + [0.16883174, 0.22076514, 0.45883891], + [0.16937589, 0.21784655, 0.45742976], + [0.16990129, 0.21491339, 0.45603578], + [0.1704074, 0.21196535, 0.45465677], + [0.17089473, 0.20900176, 0.4532928], + [0.17136819, 0.20602012, 0.45194524], + [0.17182683, 0.20302012, 0.45061386], + [0.17227059, 0.20000106, 0.44929865], + [0.17270583, 0.19695949, 0.44800165], + [0.17313804, 0.19389201, 0.44672488], + [0.17363177, 0.19076859, 0.44549087] +] + + +_lut_dict = dict( + rocket=_rocket_lut, + mako=_mako_lut, + icefire=_icefire_lut, + vlag=_vlag_lut, + flare=_flare_lut, + crest=_crest_lut, + +) + +for _name, _lut in _lut_dict.items(): + + _cmap = colors.ListedColormap(_lut, _name) + locals()[_name] = _cmap + + _cmap_r = colors.ListedColormap(_lut[::-1], _name + "_r") + locals()[_name + "_r"] = _cmap_r + + mpl_cm.register_cmap(_name, _cmap) + mpl_cm.register_cmap(_name + "_r", _cmap_r) + +del colors, mpl_cm \ No newline at end of file diff --git a/grplot_seaborn/colors/__init__.py b/grplot_seaborn/colors/__init__.py new file mode 100644 index 0000000..3d0bf1d --- /dev/null +++ b/grplot_seaborn/colors/__init__.py @@ -0,0 +1,2 @@ +from .xkcd_rgb import xkcd_rgb # noqa: F401 +from .crayons import crayons # noqa: F401 diff --git a/grplot_seaborn/colors/crayons.py b/grplot_seaborn/colors/crayons.py new file mode 100644 index 0000000..548af1f --- /dev/null +++ b/grplot_seaborn/colors/crayons.py @@ -0,0 +1,120 @@ +crayons = {'Almond': '#EFDECD', + 'Antique Brass': '#CD9575', + 'Apricot': '#FDD9B5', + 'Aquamarine': '#78DBE2', + 'Asparagus': '#87A96B', + 'Atomic Tangerine': '#FFA474', + 'Banana Mania': '#FAE7B5', + 'Beaver': '#9F8170', + 'Bittersweet': '#FD7C6E', + 'Black': '#000000', + 'Blue': '#1F75FE', + 'Blue Bell': '#A2A2D0', + 'Blue Green': '#0D98BA', + 'Blue Violet': '#7366BD', + 'Blush': '#DE5D83', + 'Brick Red': '#CB4154', + 'Brown': '#B4674D', + 'Burnt Orange': '#FF7F49', + 'Burnt Sienna': '#EA7E5D', + 'Cadet Blue': '#B0B7C6', + 'Canary': '#FFFF99', + 'Caribbean Green': '#00CC99', + 'Carnation Pink': '#FFAACC', + 'Cerise': '#DD4492', + 'Cerulean': '#1DACD6', + 'Chestnut': '#BC5D58', + 'Copper': '#DD9475', + 'Cornflower': '#9ACEEB', + 'Cotton Candy': '#FFBCD9', + 'Dandelion': '#FDDB6D', + 'Denim': '#2B6CC4', + 'Desert Sand': '#EFCDB8', + 'Eggplant': '#6E5160', + 'Electric Lime': '#CEFF1D', + 'Fern': '#71BC78', + 'Forest Green': '#6DAE81', + 'Fuchsia': '#C364C5', + 'Fuzzy Wuzzy': '#CC6666', + 'Gold': '#E7C697', + 'Goldenrod': '#FCD975', + 'Granny Smith Apple': '#A8E4A0', + 'Gray': '#95918C', + 'Green': '#1CAC78', + 'Green Yellow': '#F0E891', + 'Hot Magenta': '#FF1DCE', + 'Inchworm': '#B2EC5D', + 'Indigo': '#5D76CB', + 'Jazzberry Jam': '#CA3767', + 'Jungle Green': '#3BB08F', + 'Laser Lemon': '#FEFE22', + 'Lavender': '#FCB4D5', + 'Macaroni and Cheese': '#FFBD88', + 'Magenta': '#F664AF', + 'Mahogany': '#CD4A4C', + 'Manatee': '#979AAA', + 'Mango Tango': '#FF8243', + 'Maroon': '#C8385A', + 'Mauvelous': '#EF98AA', + 'Melon': '#FDBCB4', + 'Midnight Blue': '#1A4876', + 'Mountain Meadow': '#30BA8F', + 'Navy Blue': '#1974D2', + 'Neon Carrot': '#FFA343', + 'Olive Green': '#BAB86C', + 'Orange': '#FF7538', + 'Orchid': '#E6A8D7', + 'Outer Space': '#414A4C', + 'Outrageous Orange': '#FF6E4A', + 'Pacific Blue': '#1CA9C9', + 'Peach': '#FFCFAB', + 'Periwinkle': '#C5D0E6', + 'Piggy Pink': '#FDDDE6', + 'Pine Green': '#158078', + 'Pink Flamingo': '#FC74FD', + 'Pink Sherbert': '#F78FA7', + 'Plum': '#8E4585', + 'Purple Heart': '#7442C8', + "Purple Mountains' Majesty": '#9D81BA', + 'Purple Pizzazz': '#FE4EDA', + 'Radical Red': '#FF496C', + 'Raw Sienna': '#D68A59', + 'Razzle Dazzle Rose': '#FF48D0', + 'Razzmatazz': '#E3256B', + 'Red': '#EE204D', + 'Red Orange': '#FF5349', + 'Red Violet': '#C0448F', + "Robin's Egg Blue": '#1FCECB', + 'Royal Purple': '#7851A9', + 'Salmon': '#FF9BAA', + 'Scarlet': '#FC2847', + "Screamin' Green": '#76FF7A', + 'Sea Green': '#93DFB8', + 'Sepia': '#A5694F', + 'Shadow': '#8A795D', + 'Shamrock': '#45CEA2', + 'Shocking Pink': '#FB7EFD', + 'Silver': '#CDC5C2', + 'Sky Blue': '#80DAEB', + 'Spring Green': '#ECEABE', + 'Sunglow': '#FFCF48', + 'Sunset Orange': '#FD5E53', + 'Tan': '#FAA76C', + 'Tickle Me Pink': '#FC89AC', + 'Timberwolf': '#DBD7D2', + 'Tropical Rain Forest': '#17806D', + 'Tumbleweed': '#DEAA88', + 'Turquoise Blue': '#77DDE7', + 'Unmellow Yellow': '#FFFF66', + 'Violet (Purple)': '#926EAE', + 'Violet Red': '#F75394', + 'Vivid Tangerine': '#FFA089', + 'Vivid Violet': '#8F509D', + 'White': '#FFFFFF', + 'Wild Blue Yonder': '#A2ADD0', + 'Wild Strawberry': '#FF43A4', + 'Wild Watermelon': '#FC6C85', + 'Wisteria': '#CDA4DE', + 'Yellow': '#FCE883', + 'Yellow Green': '#C5E384', + 'Yellow Orange': '#FFAE42'} diff --git a/grplot_seaborn/colors/xkcd_rgb.py b/grplot_seaborn/colors/xkcd_rgb.py new file mode 100644 index 0000000..0f775cf --- /dev/null +++ b/grplot_seaborn/colors/xkcd_rgb.py @@ -0,0 +1,949 @@ +xkcd_rgb = {'acid green': '#8ffe09', + 'adobe': '#bd6c48', + 'algae': '#54ac68', + 'algae green': '#21c36f', + 'almost black': '#070d0d', + 'amber': '#feb308', + 'amethyst': '#9b5fc0', + 'apple': '#6ecb3c', + 'apple green': '#76cd26', + 'apricot': '#ffb16d', + 'aqua': '#13eac9', + 'aqua blue': '#02d8e9', + 'aqua green': '#12e193', + 'aqua marine': '#2ee8bb', + 'aquamarine': '#04d8b2', + 'army green': '#4b5d16', + 'asparagus': '#77ab56', + 'aubergine': '#3d0734', + 'auburn': '#9a3001', + 'avocado': '#90b134', + 'avocado green': '#87a922', + 'azul': '#1d5dec', + 'azure': '#069af3', + 'baby blue': '#a2cffe', + 'baby green': '#8cff9e', + 'baby pink': '#ffb7ce', + 'baby poo': '#ab9004', + 'baby poop': '#937c00', + 'baby poop green': '#8f9805', + 'baby puke green': '#b6c406', + 'baby purple': '#ca9bf7', + 'baby shit brown': '#ad900d', + 'baby shit green': '#889717', + 'banana': '#ffff7e', + 'banana yellow': '#fafe4b', + 'barbie pink': '#fe46a5', + 'barf green': '#94ac02', + 'barney': '#ac1db8', + 'barney purple': '#a00498', + 'battleship grey': '#6b7c85', + 'beige': '#e6daa6', + 'berry': '#990f4b', + 'bile': '#b5c306', + 'black': '#000000', + 'bland': '#afa88b', + 'blood': '#770001', + 'blood orange': '#fe4b03', + 'blood red': '#980002', + 'blue': '#0343df', + 'blue blue': '#2242c7', + 'blue green': '#137e6d', + 'blue grey': '#607c8e', + 'blue purple': '#5729ce', + 'blue violet': '#5d06e9', + 'blue with a hint of purple': '#533cc6', + 'blue/green': '#0f9b8e', + 'blue/grey': '#758da3', + 'blue/purple': '#5a06ef', + 'blueberry': '#464196', + 'bluegreen': '#017a79', + 'bluegrey': '#85a3b2', + 'bluey green': '#2bb179', + 'bluey grey': '#89a0b0', + 'bluey purple': '#6241c7', + 'bluish': '#2976bb', + 'bluish green': '#10a674', + 'bluish grey': '#748b97', + 'bluish purple': '#703be7', + 'blurple': '#5539cc', + 'blush': '#f29e8e', + 'blush pink': '#fe828c', + 'booger': '#9bb53c', + 'booger green': '#96b403', + 'bordeaux': '#7b002c', + 'boring green': '#63b365', + 'bottle green': '#044a05', + 'brick': '#a03623', + 'brick orange': '#c14a09', + 'brick red': '#8f1402', + 'bright aqua': '#0bf9ea', + 'bright blue': '#0165fc', + 'bright cyan': '#41fdfe', + 'bright green': '#01ff07', + 'bright lavender': '#c760ff', + 'bright light blue': '#26f7fd', + 'bright light green': '#2dfe54', + 'bright lilac': '#c95efb', + 'bright lime': '#87fd05', + 'bright lime green': '#65fe08', + 'bright magenta': '#ff08e8', + 'bright olive': '#9cbb04', + 'bright orange': '#ff5b00', + 'bright pink': '#fe01b1', + 'bright purple': '#be03fd', + 'bright red': '#ff000d', + 'bright sea green': '#05ffa6', + 'bright sky blue': '#02ccfe', + 'bright teal': '#01f9c6', + 'bright turquoise': '#0ffef9', + 'bright violet': '#ad0afd', + 'bright yellow': '#fffd01', + 'bright yellow green': '#9dff00', + 'british racing green': '#05480d', + 'bronze': '#a87900', + 'brown': '#653700', + 'brown green': '#706c11', + 'brown grey': '#8d8468', + 'brown orange': '#b96902', + 'brown red': '#922b05', + 'brown yellow': '#b29705', + 'brownish': '#9c6d57', + 'brownish green': '#6a6e09', + 'brownish grey': '#86775f', + 'brownish orange': '#cb7723', + 'brownish pink': '#c27e79', + 'brownish purple': '#76424e', + 'brownish red': '#9e3623', + 'brownish yellow': '#c9b003', + 'browny green': '#6f6c0a', + 'browny orange': '#ca6b02', + 'bruise': '#7e4071', + 'bubble gum pink': '#ff69af', + 'bubblegum': '#ff6cb5', + 'bubblegum pink': '#fe83cc', + 'buff': '#fef69e', + 'burgundy': '#610023', + 'burnt orange': '#c04e01', + 'burnt red': '#9f2305', + 'burnt siena': '#b75203', + 'burnt sienna': '#b04e0f', + 'burnt umber': '#a0450e', + 'burnt yellow': '#d5ab09', + 'burple': '#6832e3', + 'butter': '#ffff81', + 'butter yellow': '#fffd74', + 'butterscotch': '#fdb147', + 'cadet blue': '#4e7496', + 'camel': '#c69f59', + 'camo': '#7f8f4e', + 'camo green': '#526525', + 'camouflage green': '#4b6113', + 'canary': '#fdff63', + 'canary yellow': '#fffe40', + 'candy pink': '#ff63e9', + 'caramel': '#af6f09', + 'carmine': '#9d0216', + 'carnation': '#fd798f', + 'carnation pink': '#ff7fa7', + 'carolina blue': '#8ab8fe', + 'celadon': '#befdb7', + 'celery': '#c1fd95', + 'cement': '#a5a391', + 'cerise': '#de0c62', + 'cerulean': '#0485d1', + 'cerulean blue': '#056eee', + 'charcoal': '#343837', + 'charcoal grey': '#3c4142', + 'chartreuse': '#c1f80a', + 'cherry': '#cf0234', + 'cherry red': '#f7022a', + 'chestnut': '#742802', + 'chocolate': '#3d1c02', + 'chocolate brown': '#411900', + 'cinnamon': '#ac4f06', + 'claret': '#680018', + 'clay': '#b66a50', + 'clay brown': '#b2713d', + 'clear blue': '#247afd', + 'cloudy blue': '#acc2d9', + 'cobalt': '#1e488f', + 'cobalt blue': '#030aa7', + 'cocoa': '#875f42', + 'coffee': '#a6814c', + 'cool blue': '#4984b8', + 'cool green': '#33b864', + 'cool grey': '#95a3a6', + 'copper': '#b66325', + 'coral': '#fc5a50', + 'coral pink': '#ff6163', + 'cornflower': '#6a79f7', + 'cornflower blue': '#5170d7', + 'cranberry': '#9e003a', + 'cream': '#ffffc2', + 'creme': '#ffffb6', + 'crimson': '#8c000f', + 'custard': '#fffd78', + 'cyan': '#00ffff', + 'dandelion': '#fedf08', + 'dark': '#1b2431', + 'dark aqua': '#05696b', + 'dark aquamarine': '#017371', + 'dark beige': '#ac9362', + 'dark blue': '#00035b', + 'dark blue green': '#005249', + 'dark blue grey': '#1f3b4d', + 'dark brown': '#341c02', + 'dark coral': '#cf524e', + 'dark cream': '#fff39a', + 'dark cyan': '#0a888a', + 'dark forest green': '#002d04', + 'dark fuchsia': '#9d0759', + 'dark gold': '#b59410', + 'dark grass green': '#388004', + 'dark green': '#033500', + 'dark green blue': '#1f6357', + 'dark grey': '#363737', + 'dark grey blue': '#29465b', + 'dark hot pink': '#d90166', + 'dark indigo': '#1f0954', + 'dark khaki': '#9b8f55', + 'dark lavender': '#856798', + 'dark lilac': '#9c6da5', + 'dark lime': '#84b701', + 'dark lime green': '#7ebd01', + 'dark magenta': '#960056', + 'dark maroon': '#3c0008', + 'dark mauve': '#874c62', + 'dark mint': '#48c072', + 'dark mint green': '#20c073', + 'dark mustard': '#a88905', + 'dark navy': '#000435', + 'dark navy blue': '#00022e', + 'dark olive': '#373e02', + 'dark olive green': '#3c4d03', + 'dark orange': '#c65102', + 'dark pastel green': '#56ae57', + 'dark peach': '#de7e5d', + 'dark periwinkle': '#665fd1', + 'dark pink': '#cb416b', + 'dark plum': '#3f012c', + 'dark purple': '#35063e', + 'dark red': '#840000', + 'dark rose': '#b5485d', + 'dark royal blue': '#02066f', + 'dark sage': '#598556', + 'dark salmon': '#c85a53', + 'dark sand': '#a88f59', + 'dark sea green': '#11875d', + 'dark seafoam': '#1fb57a', + 'dark seafoam green': '#3eaf76', + 'dark sky blue': '#448ee4', + 'dark slate blue': '#214761', + 'dark tan': '#af884a', + 'dark taupe': '#7f684e', + 'dark teal': '#014d4e', + 'dark turquoise': '#045c5a', + 'dark violet': '#34013f', + 'dark yellow': '#d5b60a', + 'dark yellow green': '#728f02', + 'darkblue': '#030764', + 'darkgreen': '#054907', + 'darkish blue': '#014182', + 'darkish green': '#287c37', + 'darkish pink': '#da467d', + 'darkish purple': '#751973', + 'darkish red': '#a90308', + 'deep aqua': '#08787f', + 'deep blue': '#040273', + 'deep brown': '#410200', + 'deep green': '#02590f', + 'deep lavender': '#8d5eb7', + 'deep lilac': '#966ebd', + 'deep magenta': '#a0025c', + 'deep orange': '#dc4d01', + 'deep pink': '#cb0162', + 'deep purple': '#36013f', + 'deep red': '#9a0200', + 'deep rose': '#c74767', + 'deep sea blue': '#015482', + 'deep sky blue': '#0d75f8', + 'deep teal': '#00555a', + 'deep turquoise': '#017374', + 'deep violet': '#490648', + 'denim': '#3b638c', + 'denim blue': '#3b5b92', + 'desert': '#ccad60', + 'diarrhea': '#9f8303', + 'dirt': '#8a6e45', + 'dirt brown': '#836539', + 'dirty blue': '#3f829d', + 'dirty green': '#667e2c', + 'dirty orange': '#c87606', + 'dirty pink': '#ca7b80', + 'dirty purple': '#734a65', + 'dirty yellow': '#cdc50a', + 'dodger blue': '#3e82fc', + 'drab': '#828344', + 'drab green': '#749551', + 'dried blood': '#4b0101', + 'duck egg blue': '#c3fbf4', + 'dull blue': '#49759c', + 'dull brown': '#876e4b', + 'dull green': '#74a662', + 'dull orange': '#d8863b', + 'dull pink': '#d5869d', + 'dull purple': '#84597e', + 'dull red': '#bb3f3f', + 'dull teal': '#5f9e8f', + 'dull yellow': '#eedc5b', + 'dusk': '#4e5481', + 'dusk blue': '#26538d', + 'dusky blue': '#475f94', + 'dusky pink': '#cc7a8b', + 'dusky purple': '#895b7b', + 'dusky rose': '#ba6873', + 'dust': '#b2996e', + 'dusty blue': '#5a86ad', + 'dusty green': '#76a973', + 'dusty lavender': '#ac86a8', + 'dusty orange': '#f0833a', + 'dusty pink': '#d58a94', + 'dusty purple': '#825f87', + 'dusty red': '#b9484e', + 'dusty rose': '#c0737a', + 'dusty teal': '#4c9085', + 'earth': '#a2653e', + 'easter green': '#8cfd7e', + 'easter purple': '#c071fe', + 'ecru': '#feffca', + 'egg shell': '#fffcc4', + 'eggplant': '#380835', + 'eggplant purple': '#430541', + 'eggshell': '#ffffd4', + 'eggshell blue': '#c4fff7', + 'electric blue': '#0652ff', + 'electric green': '#21fc0d', + 'electric lime': '#a8ff04', + 'electric pink': '#ff0490', + 'electric purple': '#aa23ff', + 'emerald': '#01a049', + 'emerald green': '#028f1e', + 'evergreen': '#05472a', + 'faded blue': '#658cbb', + 'faded green': '#7bb274', + 'faded orange': '#f0944d', + 'faded pink': '#de9dac', + 'faded purple': '#916e99', + 'faded red': '#d3494e', + 'faded yellow': '#feff7f', + 'fawn': '#cfaf7b', + 'fern': '#63a950', + 'fern green': '#548d44', + 'fire engine red': '#fe0002', + 'flat blue': '#3c73a8', + 'flat green': '#699d4c', + 'fluorescent green': '#08ff08', + 'fluro green': '#0aff02', + 'foam green': '#90fda9', + 'forest': '#0b5509', + 'forest green': '#06470c', + 'forrest green': '#154406', + 'french blue': '#436bad', + 'fresh green': '#69d84f', + 'frog green': '#58bc08', + 'fuchsia': '#ed0dd9', + 'gold': '#dbb40c', + 'golden': '#f5bf03', + 'golden brown': '#b27a01', + 'golden rod': '#f9bc08', + 'golden yellow': '#fec615', + 'goldenrod': '#fac205', + 'grape': '#6c3461', + 'grape purple': '#5d1451', + 'grapefruit': '#fd5956', + 'grass': '#5cac2d', + 'grass green': '#3f9b0b', + 'grassy green': '#419c03', + 'green': '#15b01a', + 'green apple': '#5edc1f', + 'green blue': '#06b48b', + 'green brown': '#544e03', + 'green grey': '#77926f', + 'green teal': '#0cb577', + 'green yellow': '#c9ff27', + 'green/blue': '#01c08d', + 'green/yellow': '#b5ce08', + 'greenblue': '#23c48b', + 'greenish': '#40a368', + 'greenish beige': '#c9d179', + 'greenish blue': '#0b8b87', + 'greenish brown': '#696112', + 'greenish cyan': '#2afeb7', + 'greenish grey': '#96ae8d', + 'greenish tan': '#bccb7a', + 'greenish teal': '#32bf84', + 'greenish turquoise': '#00fbb0', + 'greenish yellow': '#cdfd02', + 'greeny blue': '#42b395', + 'greeny brown': '#696006', + 'greeny grey': '#7ea07a', + 'greeny yellow': '#c6f808', + 'grey': '#929591', + 'grey blue': '#6b8ba4', + 'grey brown': '#7f7053', + 'grey green': '#789b73', + 'grey pink': '#c3909b', + 'grey purple': '#826d8c', + 'grey teal': '#5e9b8a', + 'grey/blue': '#647d8e', + 'grey/green': '#86a17d', + 'greyblue': '#77a1b5', + 'greyish': '#a8a495', + 'greyish blue': '#5e819d', + 'greyish brown': '#7a6a4f', + 'greyish green': '#82a67d', + 'greyish pink': '#c88d94', + 'greyish purple': '#887191', + 'greyish teal': '#719f91', + 'gross green': '#a0bf16', + 'gunmetal': '#536267', + 'hazel': '#8e7618', + 'heather': '#a484ac', + 'heliotrope': '#d94ff5', + 'highlighter green': '#1bfc06', + 'hospital green': '#9be5aa', + 'hot green': '#25ff29', + 'hot magenta': '#f504c9', + 'hot pink': '#ff028d', + 'hot purple': '#cb00f5', + 'hunter green': '#0b4008', + 'ice': '#d6fffa', + 'ice blue': '#d7fffe', + 'icky green': '#8fae22', + 'indian red': '#850e04', + 'indigo': '#380282', + 'indigo blue': '#3a18b1', + 'iris': '#6258c4', + 'irish green': '#019529', + 'ivory': '#ffffcb', + 'jade': '#1fa774', + 'jade green': '#2baf6a', + 'jungle green': '#048243', + 'kelley green': '#009337', + 'kelly green': '#02ab2e', + 'kermit green': '#5cb200', + 'key lime': '#aeff6e', + 'khaki': '#aaa662', + 'khaki green': '#728639', + 'kiwi': '#9cef43', + 'kiwi green': '#8ee53f', + 'lavender': '#c79fef', + 'lavender blue': '#8b88f8', + 'lavender pink': '#dd85d7', + 'lawn green': '#4da409', + 'leaf': '#71aa34', + 'leaf green': '#5ca904', + 'leafy green': '#51b73b', + 'leather': '#ac7434', + 'lemon': '#fdff52', + 'lemon green': '#adf802', + 'lemon lime': '#bffe28', + 'lemon yellow': '#fdff38', + 'lichen': '#8fb67b', + 'light aqua': '#8cffdb', + 'light aquamarine': '#7bfdc7', + 'light beige': '#fffeb6', + 'light blue': '#95d0fc', + 'light blue green': '#7efbb3', + 'light blue grey': '#b7c9e2', + 'light bluish green': '#76fda8', + 'light bright green': '#53fe5c', + 'light brown': '#ad8150', + 'light burgundy': '#a8415b', + 'light cyan': '#acfffc', + 'light eggplant': '#894585', + 'light forest green': '#4f9153', + 'light gold': '#fddc5c', + 'light grass green': '#9af764', + 'light green': '#96f97b', + 'light green blue': '#56fca2', + 'light greenish blue': '#63f7b4', + 'light grey': '#d8dcd6', + 'light grey blue': '#9dbcd4', + 'light grey green': '#b7e1a1', + 'light indigo': '#6d5acf', + 'light khaki': '#e6f2a2', + 'light lavendar': '#efc0fe', + 'light lavender': '#dfc5fe', + 'light light blue': '#cafffb', + 'light light green': '#c8ffb0', + 'light lilac': '#edc8ff', + 'light lime': '#aefd6c', + 'light lime green': '#b9ff66', + 'light magenta': '#fa5ff7', + 'light maroon': '#a24857', + 'light mauve': '#c292a1', + 'light mint': '#b6ffbb', + 'light mint green': '#a6fbb2', + 'light moss green': '#a6c875', + 'light mustard': '#f7d560', + 'light navy': '#155084', + 'light navy blue': '#2e5a88', + 'light neon green': '#4efd54', + 'light olive': '#acbf69', + 'light olive green': '#a4be5c', + 'light orange': '#fdaa48', + 'light pastel green': '#b2fba5', + 'light pea green': '#c4fe82', + 'light peach': '#ffd8b1', + 'light periwinkle': '#c1c6fc', + 'light pink': '#ffd1df', + 'light plum': '#9d5783', + 'light purple': '#bf77f6', + 'light red': '#ff474c', + 'light rose': '#ffc5cb', + 'light royal blue': '#3a2efe', + 'light sage': '#bcecac', + 'light salmon': '#fea993', + 'light sea green': '#98f6b0', + 'light seafoam': '#a0febf', + 'light seafoam green': '#a7ffb5', + 'light sky blue': '#c6fcff', + 'light tan': '#fbeeac', + 'light teal': '#90e4c1', + 'light turquoise': '#7ef4cc', + 'light urple': '#b36ff6', + 'light violet': '#d6b4fc', + 'light yellow': '#fffe7a', + 'light yellow green': '#ccfd7f', + 'light yellowish green': '#c2ff89', + 'lightblue': '#7bc8f6', + 'lighter green': '#75fd63', + 'lighter purple': '#a55af4', + 'lightgreen': '#76ff7b', + 'lightish blue': '#3d7afd', + 'lightish green': '#61e160', + 'lightish purple': '#a552e6', + 'lightish red': '#fe2f4a', + 'lilac': '#cea2fd', + 'liliac': '#c48efd', + 'lime': '#aaff32', + 'lime green': '#89fe05', + 'lime yellow': '#d0fe1d', + 'lipstick': '#d5174e', + 'lipstick red': '#c0022f', + 'macaroni and cheese': '#efb435', + 'magenta': '#c20078', + 'mahogany': '#4a0100', + 'maize': '#f4d054', + 'mango': '#ffa62b', + 'manilla': '#fffa86', + 'marigold': '#fcc006', + 'marine': '#042e60', + 'marine blue': '#01386a', + 'maroon': '#650021', + 'mauve': '#ae7181', + 'medium blue': '#2c6fbb', + 'medium brown': '#7f5112', + 'medium green': '#39ad48', + 'medium grey': '#7d7f7c', + 'medium pink': '#f36196', + 'medium purple': '#9e43a2', + 'melon': '#ff7855', + 'merlot': '#730039', + 'metallic blue': '#4f738e', + 'mid blue': '#276ab3', + 'mid green': '#50a747', + 'midnight': '#03012d', + 'midnight blue': '#020035', + 'midnight purple': '#280137', + 'military green': '#667c3e', + 'milk chocolate': '#7f4e1e', + 'mint': '#9ffeb0', + 'mint green': '#8fff9f', + 'minty green': '#0bf77d', + 'mocha': '#9d7651', + 'moss': '#769958', + 'moss green': '#658b38', + 'mossy green': '#638b27', + 'mud': '#735c12', + 'mud brown': '#60460f', + 'mud green': '#606602', + 'muddy brown': '#886806', + 'muddy green': '#657432', + 'muddy yellow': '#bfac05', + 'mulberry': '#920a4e', + 'murky green': '#6c7a0e', + 'mushroom': '#ba9e88', + 'mustard': '#ceb301', + 'mustard brown': '#ac7e04', + 'mustard green': '#a8b504', + 'mustard yellow': '#d2bd0a', + 'muted blue': '#3b719f', + 'muted green': '#5fa052', + 'muted pink': '#d1768f', + 'muted purple': '#805b87', + 'nasty green': '#70b23f', + 'navy': '#01153e', + 'navy blue': '#001146', + 'navy green': '#35530a', + 'neon blue': '#04d9ff', + 'neon green': '#0cff0c', + 'neon pink': '#fe019a', + 'neon purple': '#bc13fe', + 'neon red': '#ff073a', + 'neon yellow': '#cfff04', + 'nice blue': '#107ab0', + 'night blue': '#040348', + 'ocean': '#017b92', + 'ocean blue': '#03719c', + 'ocean green': '#3d9973', + 'ocher': '#bf9b0c', + 'ochre': '#bf9005', + 'ocre': '#c69c04', + 'off blue': '#5684ae', + 'off green': '#6ba353', + 'off white': '#ffffe4', + 'off yellow': '#f1f33f', + 'old pink': '#c77986', + 'old rose': '#c87f89', + 'olive': '#6e750e', + 'olive brown': '#645403', + 'olive drab': '#6f7632', + 'olive green': '#677a04', + 'olive yellow': '#c2b709', + 'orange': '#f97306', + 'orange brown': '#be6400', + 'orange pink': '#ff6f52', + 'orange red': '#fd411e', + 'orange yellow': '#ffad01', + 'orangeish': '#fd8d49', + 'orangered': '#fe420f', + 'orangey brown': '#b16002', + 'orangey red': '#fa4224', + 'orangey yellow': '#fdb915', + 'orangish': '#fc824a', + 'orangish brown': '#b25f03', + 'orangish red': '#f43605', + 'orchid': '#c875c4', + 'pale': '#fff9d0', + 'pale aqua': '#b8ffeb', + 'pale blue': '#d0fefe', + 'pale brown': '#b1916e', + 'pale cyan': '#b7fffa', + 'pale gold': '#fdde6c', + 'pale green': '#c7fdb5', + 'pale grey': '#fdfdfe', + 'pale lavender': '#eecffe', + 'pale light green': '#b1fc99', + 'pale lilac': '#e4cbff', + 'pale lime': '#befd73', + 'pale lime green': '#b1ff65', + 'pale magenta': '#d767ad', + 'pale mauve': '#fed0fc', + 'pale olive': '#b9cc81', + 'pale olive green': '#b1d27b', + 'pale orange': '#ffa756', + 'pale peach': '#ffe5ad', + 'pale pink': '#ffcfdc', + 'pale purple': '#b790d4', + 'pale red': '#d9544d', + 'pale rose': '#fdc1c5', + 'pale salmon': '#ffb19a', + 'pale sky blue': '#bdf6fe', + 'pale teal': '#82cbb2', + 'pale turquoise': '#a5fbd5', + 'pale violet': '#ceaefa', + 'pale yellow': '#ffff84', + 'parchment': '#fefcaf', + 'pastel blue': '#a2bffe', + 'pastel green': '#b0ff9d', + 'pastel orange': '#ff964f', + 'pastel pink': '#ffbacd', + 'pastel purple': '#caa0ff', + 'pastel red': '#db5856', + 'pastel yellow': '#fffe71', + 'pea': '#a4bf20', + 'pea green': '#8eab12', + 'pea soup': '#929901', + 'pea soup green': '#94a617', + 'peach': '#ffb07c', + 'peachy pink': '#ff9a8a', + 'peacock blue': '#016795', + 'pear': '#cbf85f', + 'periwinkle': '#8e82fe', + 'periwinkle blue': '#8f99fb', + 'perrywinkle': '#8f8ce7', + 'petrol': '#005f6a', + 'pig pink': '#e78ea5', + 'pine': '#2b5d34', + 'pine green': '#0a481e', + 'pink': '#ff81c0', + 'pink purple': '#db4bda', + 'pink red': '#f5054f', + 'pink/purple': '#ef1de7', + 'pinkish': '#d46a7e', + 'pinkish brown': '#b17261', + 'pinkish grey': '#c8aca9', + 'pinkish orange': '#ff724c', + 'pinkish purple': '#d648d7', + 'pinkish red': '#f10c45', + 'pinkish tan': '#d99b82', + 'pinky': '#fc86aa', + 'pinky purple': '#c94cbe', + 'pinky red': '#fc2647', + 'piss yellow': '#ddd618', + 'pistachio': '#c0fa8b', + 'plum': '#580f41', + 'plum purple': '#4e0550', + 'poison green': '#40fd14', + 'poo': '#8f7303', + 'poo brown': '#885f01', + 'poop': '#7f5e00', + 'poop brown': '#7a5901', + 'poop green': '#6f7c00', + 'powder blue': '#b1d1fc', + 'powder pink': '#ffb2d0', + 'primary blue': '#0804f9', + 'prussian blue': '#004577', + 'puce': '#a57e52', + 'puke': '#a5a502', + 'puke brown': '#947706', + 'puke green': '#9aae07', + 'puke yellow': '#c2be0e', + 'pumpkin': '#e17701', + 'pumpkin orange': '#fb7d07', + 'pure blue': '#0203e2', + 'purple': '#7e1e9c', + 'purple blue': '#632de9', + 'purple brown': '#673a3f', + 'purple grey': '#866f85', + 'purple pink': '#e03fd8', + 'purple red': '#990147', + 'purple/blue': '#5d21d0', + 'purple/pink': '#d725de', + 'purpleish': '#98568d', + 'purpleish blue': '#6140ef', + 'purpleish pink': '#df4ec8', + 'purpley': '#8756e4', + 'purpley blue': '#5f34e7', + 'purpley grey': '#947e94', + 'purpley pink': '#c83cb9', + 'purplish': '#94568c', + 'purplish blue': '#601ef9', + 'purplish brown': '#6b4247', + 'purplish grey': '#7a687f', + 'purplish pink': '#ce5dae', + 'purplish red': '#b0054b', + 'purply': '#983fb2', + 'purply blue': '#661aee', + 'purply pink': '#f075e6', + 'putty': '#beae8a', + 'racing green': '#014600', + 'radioactive green': '#2cfa1f', + 'raspberry': '#b00149', + 'raw sienna': '#9a6200', + 'raw umber': '#a75e09', + 'really light blue': '#d4ffff', + 'red': '#e50000', + 'red brown': '#8b2e16', + 'red orange': '#fd3c06', + 'red pink': '#fa2a55', + 'red purple': '#820747', + 'red violet': '#9e0168', + 'red wine': '#8c0034', + 'reddish': '#c44240', + 'reddish brown': '#7f2b0a', + 'reddish grey': '#997570', + 'reddish orange': '#f8481c', + 'reddish pink': '#fe2c54', + 'reddish purple': '#910951', + 'reddy brown': '#6e1005', + 'rich blue': '#021bf9', + 'rich purple': '#720058', + 'robin egg blue': '#8af1fe', + "robin's egg": '#6dedfd', + "robin's egg blue": '#98eff9', + 'rosa': '#fe86a4', + 'rose': '#cf6275', + 'rose pink': '#f7879a', + 'rose red': '#be013c', + 'rosy pink': '#f6688e', + 'rouge': '#ab1239', + 'royal': '#0c1793', + 'royal blue': '#0504aa', + 'royal purple': '#4b006e', + 'ruby': '#ca0147', + 'russet': '#a13905', + 'rust': '#a83c09', + 'rust brown': '#8b3103', + 'rust orange': '#c45508', + 'rust red': '#aa2704', + 'rusty orange': '#cd5909', + 'rusty red': '#af2f0d', + 'saffron': '#feb209', + 'sage': '#87ae73', + 'sage green': '#88b378', + 'salmon': '#ff796c', + 'salmon pink': '#fe7b7c', + 'sand': '#e2ca76', + 'sand brown': '#cba560', + 'sand yellow': '#fce166', + 'sandstone': '#c9ae74', + 'sandy': '#f1da7a', + 'sandy brown': '#c4a661', + 'sandy yellow': '#fdee73', + 'sap green': '#5c8b15', + 'sapphire': '#2138ab', + 'scarlet': '#be0119', + 'sea': '#3c9992', + 'sea blue': '#047495', + 'sea green': '#53fca1', + 'seafoam': '#80f9ad', + 'seafoam blue': '#78d1b6', + 'seafoam green': '#7af9ab', + 'seaweed': '#18d17b', + 'seaweed green': '#35ad6b', + 'sepia': '#985e2b', + 'shamrock': '#01b44c', + 'shamrock green': '#02c14d', + 'shit': '#7f5f00', + 'shit brown': '#7b5804', + 'shit green': '#758000', + 'shocking pink': '#fe02a2', + 'sick green': '#9db92c', + 'sickly green': '#94b21c', + 'sickly yellow': '#d0e429', + 'sienna': '#a9561e', + 'silver': '#c5c9c7', + 'sky': '#82cafc', + 'sky blue': '#75bbfd', + 'slate': '#516572', + 'slate blue': '#5b7c99', + 'slate green': '#658d6d', + 'slate grey': '#59656d', + 'slime green': '#99cc04', + 'snot': '#acbb0d', + 'snot green': '#9dc100', + 'soft blue': '#6488ea', + 'soft green': '#6fc276', + 'soft pink': '#fdb0c0', + 'soft purple': '#a66fb5', + 'spearmint': '#1ef876', + 'spring green': '#a9f971', + 'spruce': '#0a5f38', + 'squash': '#f2ab15', + 'steel': '#738595', + 'steel blue': '#5a7d9a', + 'steel grey': '#6f828a', + 'stone': '#ada587', + 'stormy blue': '#507b9c', + 'straw': '#fcf679', + 'strawberry': '#fb2943', + 'strong blue': '#0c06f7', + 'strong pink': '#ff0789', + 'sun yellow': '#ffdf22', + 'sunflower': '#ffc512', + 'sunflower yellow': '#ffda03', + 'sunny yellow': '#fff917', + 'sunshine yellow': '#fffd37', + 'swamp': '#698339', + 'swamp green': '#748500', + 'tan': '#d1b26f', + 'tan brown': '#ab7e4c', + 'tan green': '#a9be70', + 'tangerine': '#ff9408', + 'taupe': '#b9a281', + 'tea': '#65ab7c', + 'tea green': '#bdf8a3', + 'teal': '#029386', + 'teal blue': '#01889f', + 'teal green': '#25a36f', + 'tealish': '#24bca8', + 'tealish green': '#0cdc73', + 'terra cotta': '#c9643b', + 'terracota': '#cb6843', + 'terracotta': '#ca6641', + 'tiffany blue': '#7bf2da', + 'tomato': '#ef4026', + 'tomato red': '#ec2d01', + 'topaz': '#13bbaf', + 'toupe': '#c7ac7d', + 'toxic green': '#61de2a', + 'tree green': '#2a7e19', + 'true blue': '#010fcc', + 'true green': '#089404', + 'turquoise': '#06c2ac', + 'turquoise blue': '#06b1c4', + 'turquoise green': '#04f489', + 'turtle green': '#75b84f', + 'twilight': '#4e518b', + 'twilight blue': '#0a437a', + 'ugly blue': '#31668a', + 'ugly brown': '#7d7103', + 'ugly green': '#7a9703', + 'ugly pink': '#cd7584', + 'ugly purple': '#a442a0', + 'ugly yellow': '#d0c101', + 'ultramarine': '#2000b1', + 'ultramarine blue': '#1805db', + 'umber': '#b26400', + 'velvet': '#750851', + 'vermillion': '#f4320c', + 'very dark blue': '#000133', + 'very dark brown': '#1d0200', + 'very dark green': '#062e03', + 'very dark purple': '#2a0134', + 'very light blue': '#d5ffff', + 'very light brown': '#d3b683', + 'very light green': '#d1ffbd', + 'very light pink': '#fff4f2', + 'very light purple': '#f6cefc', + 'very pale blue': '#d6fffe', + 'very pale green': '#cffdbc', + 'vibrant blue': '#0339f8', + 'vibrant green': '#0add08', + 'vibrant purple': '#ad03de', + 'violet': '#9a0eea', + 'violet blue': '#510ac9', + 'violet pink': '#fb5ffc', + 'violet red': '#a50055', + 'viridian': '#1e9167', + 'vivid blue': '#152eff', + 'vivid green': '#2fef10', + 'vivid purple': '#9900fa', + 'vomit': '#a2a415', + 'vomit green': '#89a203', + 'vomit yellow': '#c7c10c', + 'warm blue': '#4b57db', + 'warm brown': '#964e02', + 'warm grey': '#978a84', + 'warm pink': '#fb5581', + 'warm purple': '#952e8f', + 'washed out green': '#bcf5a6', + 'water blue': '#0e87cc', + 'watermelon': '#fd4659', + 'weird green': '#3ae57f', + 'wheat': '#fbdd7e', + 'white': '#ffffff', + 'windows blue': '#3778bf', + 'wine': '#80013f', + 'wine red': '#7b0323', + 'wintergreen': '#20f986', + 'wisteria': '#a87dc2', + 'yellow': '#ffff14', + 'yellow brown': '#b79400', + 'yellow green': '#c0fb2d', + 'yellow ochre': '#cb9d06', + 'yellow orange': '#fcb001', + 'yellow tan': '#ffe36e', + 'yellow/green': '#c8fd3d', + 'yellowgreen': '#bbf90f', + 'yellowish': '#faee66', + 'yellowish brown': '#9b7a01', + 'yellowish green': '#b0dd16', + 'yellowish orange': '#ffab0f', + 'yellowish tan': '#fcfc81', + 'yellowy brown': '#ae8b0c', + 'yellowy green': '#bff128'} diff --git a/grplot_seaborn/conftest.py b/grplot_seaborn/conftest.py new file mode 100644 index 0000000..731fdda --- /dev/null +++ b/grplot_seaborn/conftest.py @@ -0,0 +1,235 @@ +import numpy as np +import pandas as pd +import datetime +import matplotlib as mpl +import matplotlib.pyplot as plt + +import pytest + + +def has_verdana(): + """Helper to verify if Verdana font is present""" + # This import is relatively lengthy, so to prevent its import for + # testing other tests in this module not requiring this knowledge, + # import font_manager here + import matplotlib.font_manager as mplfm + try: + verdana_font = mplfm.findfont('Verdana', fallback_to_default=False) + except: # noqa + # if https://github.com/matplotlib/matplotlib/pull/3435 + # gets accepted + return False + # otherwise check if not matching the logic for a 'default' one + try: + unlikely_font = mplfm.findfont("very_unlikely_to_exist1234", + fallback_to_default=False) + except: # noqa + # if matched verdana but not unlikely, Verdana must exist + return True + # otherwise -- if they match, must be the same default + return verdana_font != unlikely_font + + +@pytest.fixture(scope="session", autouse=True) +def remove_pandas_unit_conversion(): + # Prior to pandas 1.0, it registered its own datetime converters, + # but they are less powerful than what matplotlib added in 2.2, + # and we rely on that functionality in seaborn. + # https://github.com/matplotlib/matplotlib/pull/9779 + # https://github.com/pandas-dev/pandas/issues/27036 + mpl.units.registry[np.datetime64] = mpl.dates.DateConverter() + mpl.units.registry[datetime.date] = mpl.dates.DateConverter() + mpl.units.registry[datetime.datetime] = mpl.dates.DateConverter() + + +@pytest.fixture(autouse=True) +def close_figs(): + yield + plt.close("all") + + +@pytest.fixture(autouse=True) +def random_seed(): + seed = sum(map(ord, "seaborn random global")) + np.random.seed(seed) + + +@pytest.fixture() +def rng(): + seed = sum(map(ord, "seaborn random object")) + return np.random.RandomState(seed) + + +@pytest.fixture +def wide_df(rng): + + columns = list("abc") + index = pd.Int64Index(np.arange(10, 50, 2), name="wide_index") + values = rng.normal(size=(len(index), len(columns))) + return pd.DataFrame(values, index=index, columns=columns) + + +@pytest.fixture +def wide_array(wide_df): + + # Requires panads >= 0.24 + # return wide_df.to_numpy() + return np.asarray(wide_df) + + +@pytest.fixture +def flat_series(rng): + + index = pd.Int64Index(np.arange(10, 30), name="t") + return pd.Series(rng.normal(size=20), index, name="s") + + +@pytest.fixture +def flat_array(flat_series): + + # Requires panads >= 0.24 + # return flat_series.to_numpy() + return np.asarray(flat_series) + + +@pytest.fixture +def flat_list(flat_series): + + # Requires panads >= 0.24 + # return flat_series.to_list() + return flat_series.tolist() + + +@pytest.fixture(params=["series", "array", "list"]) +def flat_data(rng, request): + + index = pd.Int64Index(np.arange(10, 30), name="t") + series = pd.Series(rng.normal(size=20), index, name="s") + if request.param == "series": + data = series + elif request.param == "array": + try: + data = series.to_numpy() # Requires pandas >= 0.24 + except AttributeError: + data = np.asarray(series) + elif request.param == "list": + try: + data = series.to_list() # Requires pandas >= 0.24 + except AttributeError: + data = series.tolist() + return data + + +@pytest.fixture +def wide_list_of_series(rng): + + return [pd.Series(rng.normal(size=20), np.arange(20), name="a"), + pd.Series(rng.normal(size=10), np.arange(5, 15), name="b")] + + +@pytest.fixture +def wide_list_of_arrays(wide_list_of_series): + + # Requires pandas >= 0.24 + # return [s.to_numpy() for s in wide_list_of_series] + return [np.asarray(s) for s in wide_list_of_series] + + +@pytest.fixture +def wide_list_of_lists(wide_list_of_series): + + # Requires pandas >= 0.24 + # return [s.to_list() for s in wide_list_of_series] + return [s.tolist() for s in wide_list_of_series] + + +@pytest.fixture +def wide_dict_of_series(wide_list_of_series): + + return {s.name: s for s in wide_list_of_series} + + +@pytest.fixture +def wide_dict_of_arrays(wide_list_of_series): + + # Requires pandas >= 0.24 + # return {s.name: s.to_numpy() for s in wide_list_of_series} + return {s.name: np.asarray(s) for s in wide_list_of_series} + + +@pytest.fixture +def wide_dict_of_lists(wide_list_of_series): + + # Requires pandas >= 0.24 + # return {s.name: s.to_list() for s in wide_list_of_series} + return {s.name: s.tolist() for s in wide_list_of_series} + + +@pytest.fixture +def long_df(rng): + + n = 100 + df = pd.DataFrame(dict( + x=rng.uniform(0, 20, n).round().astype("int"), + y=rng.normal(size=n), + z=rng.lognormal(size=n), + a=rng.choice(list("abc"), n), + b=rng.choice(list("mnop"), n), + c=rng.choice([0, 1], n, [.3, .7]), + t=rng.choice(np.arange("2004-07-30", "2007-07-30", dtype="datetime64[Y]"), n), + s=rng.choice([2, 4, 8], n), + f=rng.choice([0.2, 0.3], n), + )) + + a_cat = df["a"].astype("category") + new_categories = np.roll(a_cat.cat.categories, 1) + df["a_cat"] = a_cat.cat.reorder_categories(new_categories) + + df["s_cat"] = df["s"].astype("category") + df["s_str"] = df["s"].astype(str) + + return df + + +@pytest.fixture +def long_dict(long_df): + + return long_df.to_dict() + + +@pytest.fixture +def repeated_df(rng): + + n = 100 + return pd.DataFrame(dict( + x=np.tile(np.arange(n // 2), 2), + y=rng.normal(size=n), + a=rng.choice(list("abc"), n), + u=np.repeat(np.arange(2), n // 2), + )) + + +@pytest.fixture +def missing_df(rng, long_df): + + df = long_df.copy() + for col in df: + idx = rng.permutation(df.index)[:10] + df.loc[idx, col] = np.nan + return df + + +@pytest.fixture +def object_df(rng, long_df): + + df = long_df.copy() + # objectify numeric columns + for col in ["c", "s", "f"]: + df[col] = df[col].astype(object) + return df + + +@pytest.fixture +def null_series(flat_series): + + return pd.Series(index=flat_series.index, dtype='float64') diff --git a/grplot_seaborn/distributions.py b/grplot_seaborn/distributions.py new file mode 100644 index 0000000..39234c7 --- /dev/null +++ b/grplot_seaborn/distributions.py @@ -0,0 +1,2723 @@ +"""Plotting functions for visualizing distributions.""" +from numbers import Number +from functools import partial +import math +import warnings + +import numpy as np +import pandas as pd +import matplotlib as mpl +import matplotlib.pyplot as plt +import matplotlib.transforms as tx +from matplotlib.colors import to_rgba +from matplotlib.collections import LineCollection +from scipy import stats + +from ._core import ( + VectorPlotter, +) +from ._statistics import ( + KDE, + Histogram, + ECDF, +) +from .axisgrid import ( + FacetGrid, + _facet_docs, +) +from .utils import ( + remove_na, + _kde_support, + _normalize_kwargs, + _check_argument, + _assign_default_kwargs, +) +from .palettes import color_palette +from .external import husl +from ._decorators import _deprecate_positional_args +from ._docstrings import ( + DocstringComponents, + _core_docs, +) + + +__all__ = ["displot", "histplot", "kdeplot", "ecdfplot", "rugplot", "distplot"] + +# ==================================================================================== # +# Module documentation +# ==================================================================================== # + +_dist_params = dict( + + multiple=""" +multiple : {{"layer", "stack", "fill"}} + Method for drawing multiple elements when semantic mapping creates subsets. + Only relevant with univariate data. + """, + log_scale=""" +log_scale : bool or number, or pair of bools or numbers + Set axis scale(s) to log. A single value sets the data axis for univariate + distributions and both axes for bivariate distributions. A pair of values + sets each axis independently. Numeric values are interpreted as the desired + base (default 10). If `False`, defer to the existing Axes scale. + """, + legend=""" +legend : bool + If False, suppress the legend for semantic variables. + """, + cbar=""" +cbar : bool + If True, add a colorbar to annotate the color mapping in a bivariate plot. + Note: Does not currently support plots with a ``hue`` variable well. + """, + cbar_ax=""" +cbar_ax : :class:`matplotlib.axes.Axes` + Pre-existing axes for the colorbar. + """, + cbar_kws=""" +cbar_kws : dict + Additional parameters passed to :meth:`matplotlib.figure.Figure.colorbar`. + """, +) + +_param_docs = DocstringComponents.from_nested_components( + core=_core_docs["params"], + facets=DocstringComponents(_facet_docs), + dist=DocstringComponents(_dist_params), + kde=DocstringComponents.from_function_params(KDE.__init__), + hist=DocstringComponents.from_function_params(Histogram.__init__), + ecdf=DocstringComponents.from_function_params(ECDF.__init__), +) + + +# ==================================================================================== # +# Internal API +# ==================================================================================== # + + +class _DistributionPlotter(VectorPlotter): + + semantics = "x", "y", "hue", "weights" + + wide_structure = {"x": "@values", "hue": "@columns"} + flat_structure = {"x": "@values"} + + def __init__( + self, + data=None, + variables={}, + ): + + super().__init__(data=data, variables=variables) + + @property + def univariate(self): + """Return True if only x or y are used.""" + # TODO this could go down to core, but putting it here now. + # We'd want to be conceptually clear that univariate only applies + # to x/y and not to other semantics, which can exist. + # We haven't settled on a good conceptual name for x/y. + return bool({"x", "y"} - set(self.variables)) + + @property + def data_variable(self): + """Return the variable with data for univariate plots.""" + # TODO This could also be in core, but it should have a better name. + if not self.univariate: + raise AttributeError("This is not a univariate plot") + return {"x", "y"}.intersection(self.variables).pop() + + @property + def has_xy_data(self): + """Return True at least one of x or y is defined.""" + # TODO see above points about where this should go + return bool({"x", "y"} & set(self.variables)) + + def _add_legend( + self, + ax_obj, artist, fill, element, multiple, alpha, artist_kws, legend_kws, + ): + """Add artists that reflect semantic mappings and put then in a legend.""" + # TODO note that this doesn't handle numeric mappings like the relational plots + handles = [] + labels = [] + for level in self._hue_map.levels: + color = self._hue_map(level) + handles.append(artist( + **self._artist_kws( + artist_kws, fill, element, multiple, color, alpha + ) + )) + labels.append(level) + + if isinstance(ax_obj, mpl.axes.Axes): + ax_obj.legend(handles, labels, title=self.variables["hue"], **legend_kws) + else: # i.e. a FacetGrid. TODO make this better + legend_data = dict(zip(labels, handles)) + ax_obj.add_legend( + legend_data, + title=self.variables["hue"], + label_order=self.var_levels["hue"], + **legend_kws + ) + + def _artist_kws(self, kws, fill, element, multiple, color, alpha): + """Handle differences between artists in filled/unfilled plots.""" + kws = kws.copy() + if fill: + kws.setdefault("facecolor", to_rgba(color, alpha)) + if multiple in ["stack", "fill"] or element == "bars": + kws.setdefault("edgecolor", mpl.rcParams["patch.edgecolor"]) + else: + kws.setdefault("edgecolor", to_rgba(color, 1)) + elif element == "bars": + kws["facecolor"] = "none" + kws["edgecolor"] = to_rgba(color, alpha) + else: + kws["color"] = to_rgba(color, alpha) + return kws + + def _quantile_to_level(self, data, quantile): + """Return data levels corresponding to quantile cuts of mass.""" + isoprop = np.asarray(quantile) + values = np.ravel(data) + sorted_values = np.sort(values)[::-1] + normalized_values = np.cumsum(sorted_values) / values.sum() + idx = np.searchsorted(normalized_values, 1 - isoprop) + levels = np.take(sorted_values, idx, mode="clip") + return levels + + def _cmap_from_color(self, color): + """Return a sequential colormap given a color seed.""" + # Like so much else here, this is broadly useful, but keeping it + # in this class to signify that I haven't thought overly hard about it... + r, g, b, _ = to_rgba(color) + h, s, _ = husl.rgb_to_husl(r, g, b) + xx = np.linspace(-1, 1, int(1.15 * 256))[:256] + ramp = np.zeros((256, 3)) + ramp[:, 0] = h + ramp[:, 1] = s * np.cos(xx) + ramp[:, 2] = np.linspace(35, 80, 256) + colors = np.clip([husl.husl_to_rgb(*hsl) for hsl in ramp], 0, 1) + return mpl.colors.ListedColormap(colors[::-1]) + + def _default_discrete(self): + """Find default values for discrete hist estimation based on variable type.""" + if self.univariate: + discrete = self.var_types[self.data_variable] == "categorical" + else: + discrete_x = self.var_types["x"] == "categorical" + discrete_y = self.var_types["y"] == "categorical" + discrete = discrete_x, discrete_y + return discrete + + def _resolve_multiple(self, curves, multiple): + """Modify the density data structure to handle multiple densities.""" + + # Default baselines have all densities starting at 0 + baselines = {k: np.zeros_like(v) for k, v in curves.items()} + + # TODO we should have some central clearinghouse for checking if any + # "grouping" (terminnology?) semantics have been assigned + if "hue" not in self.variables: + return curves, baselines + + if multiple in ("stack", "fill"): + + # Setting stack or fill means that the curves share a + # support grid / set of bin edges, so we can make a dataframe + # Reverse the column order to plot from top to bottom + curves = pd.DataFrame(curves).iloc[:, ::-1] + + # Find column groups that are nested within col/row variables + column_groups = {} + for i, keyd in enumerate(map(dict, curves.columns.tolist())): + facet_key = keyd.get("col", None), keyd.get("row", None) + column_groups.setdefault(facet_key, []) + column_groups[facet_key].append(i) + + baselines = curves.copy() + for cols in column_groups.values(): + + norm_constant = curves.iloc[:, cols].sum(axis="columns") + + # Take the cumulative sum to stack + curves.iloc[:, cols] = curves.iloc[:, cols].cumsum(axis="columns") + + # Normalize by row sum to fill + if multiple == "fill": + curves.iloc[:, cols] = (curves + .iloc[:, cols] + .div(norm_constant, axis="index")) + + # Define where each segment starts + baselines.iloc[:, cols] = (curves + .iloc[:, cols] + .shift(1, axis=1) + .fillna(0)) + + if multiple == "dodge": + + # Account for the unique semantic (non-faceting) levels + # This will require rethiniking if we add other semantics! + hue_levels = self.var_levels["hue"] + n = len(hue_levels) + for key in curves: + level = dict(key)["hue"] + hist = curves[key].reset_index(name="heights") + hist["widths"] /= n + hist["edges"] += hue_levels.index(level) * hist["widths"] + + curves[key] = hist.set_index(["edges", "widths"])["heights"] + + return curves, baselines + + # -------------------------------------------------------------------------------- # + # Computation + # -------------------------------------------------------------------------------- # + + def _compute_univariate_density( + self, + data_variable, + common_norm, + common_grid, + estimate_kws, + log_scale, + warn_singular=True, + ): + + # Initialize the estimator object + estimator = KDE(**estimate_kws) + + all_data = self.plot_data.dropna() + + if set(self.variables) - {"x", "y"}: + if common_grid: + all_observations = self.comp_data.dropna() + estimator.define_support(all_observations[data_variable]) + else: + common_norm = False + + densities = {} + + for sub_vars, sub_data in self.iter_data("hue", from_comp_data=True): + + # Extract the data points from this sub set and remove nulls + sub_data = sub_data.dropna() + observations = sub_data[data_variable] + + observation_variance = observations.var() + if math.isclose(observation_variance, 0) or np.isnan(observation_variance): + msg = ( + "Dataset has 0 variance; skipping density estimate. " + "Pass `warn_singular=False` to disable this warning." + ) + if warn_singular: + warnings.warn(msg, UserWarning) + continue + + # Extract the weights for this subset of observations + if "weights" in self.variables: + weights = sub_data["weights"] + else: + weights = None + + # Estimate the density of observations at this level + density, support = estimator(observations, weights=weights) + + if log_scale: + support = np.power(10, support) + + # Apply a scaling factor so that the integral over all subsets is 1 + if common_norm: + density *= len(sub_data) / len(all_data) + + # Store the density for this level + key = tuple(sub_vars.items()) + densities[key] = pd.Series(density, index=support) + + return densities + + # -------------------------------------------------------------------------------- # + # Plotting + # -------------------------------------------------------------------------------- # + + def plot_univariate_histogram( + self, + multiple, + element, + fill, + common_norm, + common_bins, + shrink, + kde, + kde_kws, + color, + legend, + line_kws, + estimate_kws, + **plot_kws, + ): + + # -- Default keyword dicts + kde_kws = {} if kde_kws is None else kde_kws.copy() + line_kws = {} if line_kws is None else line_kws.copy() + estimate_kws = {} if estimate_kws is None else estimate_kws.copy() + + # -- Input checking + _check_argument("multiple", ["layer", "stack", "fill", "dodge"], multiple) + _check_argument("element", ["bars", "step", "poly"], element) + + if estimate_kws["discrete"] and element != "bars": + raise ValueError("`element` must be 'bars' when `discrete` is True") + + auto_bins_with_weights = ( + "weights" in self.variables + and estimate_kws["bins"] == "auto" + and estimate_kws["binwidth"] is None + and not estimate_kws["discrete"] + ) + if auto_bins_with_weights: + msg = ( + "`bins` cannot be 'auto' when using weights. " + "Setting `bins=10`, but you will likely want to adjust." + ) + warnings.warn(msg, UserWarning) + estimate_kws["bins"] = 10 + + # Simplify downstream code if we are not normalizing + if estimate_kws["stat"] == "count": + common_norm = False + + # Now initialize the Histogram estimator + estimator = Histogram(**estimate_kws) + histograms = {} + + # Do pre-compute housekeeping related to multiple groups + # TODO best way to account for facet/semantic? + if set(self.variables) - {"x", "y"}: + + all_data = self.comp_data.dropna() + + if common_bins: + all_observations = all_data[self.data_variable] + estimator.define_bin_params( + all_observations, + weights=all_data.get("weights", None), + ) + + else: + common_norm = False + + # Estimate the smoothed kernel densities, for use later + if kde: + # TODO alternatively, clip at min/max bins? + kde_kws.setdefault("cut", 0) + kde_kws["cumulative"] = estimate_kws["cumulative"] + log_scale = self._log_scaled(self.data_variable) + densities = self._compute_univariate_density( + self.data_variable, + common_norm, + common_bins, + kde_kws, + log_scale, + warn_singular=False, + ) + + # First pass through the data to compute the histograms + for sub_vars, sub_data in self.iter_data("hue", from_comp_data=True): + + # Prepare the relevant data + key = tuple(sub_vars.items()) + sub_data = sub_data.dropna() + observations = sub_data[self.data_variable] + + if "weights" in self.variables: + weights = sub_data["weights"] + else: + weights = None + + # Do the histogram computation + heights, edges = estimator(observations, weights=weights) + + # Rescale the smoothed curve to match the histogram + if kde and key in densities: + density = densities[key] + if estimator.cumulative: + hist_norm = heights.max() + else: + hist_norm = (heights * np.diff(edges)).sum() + densities[key] *= hist_norm + + # Convert edges back to original units for plotting + if self._log_scaled(self.data_variable): + edges = np.power(10, edges) + + # Pack the histogram data and metadata together + orig_widths = np.diff(edges) + widths = shrink * orig_widths + edges = edges[:-1] + (1 - shrink) / 2 * orig_widths + index = pd.MultiIndex.from_arrays([ + pd.Index(edges, name="edges"), + pd.Index(widths, name="widths"), + ]) + hist = pd.Series(heights, index=index, name="heights") + + # Apply scaling to normalize across groups + if common_norm: + hist *= len(sub_data) / len(all_data) + + # Store the finalized histogram data for future plotting + histograms[key] = hist + + # Modify the histogram and density data to resolve multiple groups + histograms, baselines = self._resolve_multiple(histograms, multiple) + if kde: + densities, _ = self._resolve_multiple( + densities, None if multiple == "dodge" else multiple + ) + + # Set autoscaling-related meta + sticky_stat = (0, 1) if multiple == "fill" else (0, np.inf) + if multiple == "fill": + # Filled plots should not have any margins + bin_vals = histograms.index.to_frame() + edges = bin_vals["edges"] + widths = bin_vals["widths"] + sticky_data = ( + edges.min(), + edges.max() + widths.loc[edges.idxmax()] + ) + else: + sticky_data = [] + + # --- Handle default visual attributes + + # Note: default linewidth is determined after plotting + + # Default color without a hue semantic should follow the color cycle + # Note, this is fairly complicated and awkward, I'd like a better way + # TODO and now with the ax business, this is just super annoying FIX!! + if "hue" not in self.variables: + if self.ax is None: + default_color = "C0" if color is None else color + else: + if fill: + if self.var_types[self.data_variable] == "datetime": + # Avoid drawing empty fill_between on date axis + # https://github.com/matplotlib/matplotlib/issues/17586 + scout = None + default_color = plot_kws.pop("facecolor", color) + if default_color is None: + default_color = "C0" + else: + artist = mpl.patches.Rectangle + plot_kws = _normalize_kwargs(plot_kws, artist) + scout = self.ax.fill_between([], [], color=color, **plot_kws) + default_color = tuple(scout.get_facecolor().squeeze()) + else: + artist = mpl.lines.Line2D + plot_kws = _normalize_kwargs(plot_kws, artist) + scout, = self.ax.plot([], [], color=color, **plot_kws) + default_color = scout.get_color() + if scout is not None: + scout.remove() + + # Default alpha should depend on other parameters + if fill: + # Note: will need to account for other grouping semantics if added + if "hue" in self.variables and multiple == "layer": + default_alpha = .5 if element == "bars" else .25 + elif kde: + default_alpha = .5 + else: + default_alpha = .75 + else: + default_alpha = 1 + alpha = plot_kws.pop("alpha", default_alpha) # TODO make parameter? + + hist_artists = [] + + # Go back through the dataset and draw the plots + for sub_vars, _ in self.iter_data("hue", reverse=True): + + key = tuple(sub_vars.items()) + hist = histograms[key].rename("heights").reset_index() + bottom = np.asarray(baselines[key]) + + ax = self._get_axes(sub_vars) + + # Define the matplotlib attributes that depend on semantic mapping + if "hue" in self.variables: + color = self._hue_map(sub_vars["hue"]) + else: + color = default_color + + artist_kws = self._artist_kws( + plot_kws, fill, element, multiple, color, alpha + ) + + if element == "bars": + + # Use matplotlib bar plotting + + plot_func = ax.bar if self.data_variable == "x" else ax.barh + artists = plot_func( + hist["edges"], + hist["heights"] - bottom, + hist["widths"], + bottom, + align="edge", + **artist_kws, + ) + for bar in artists: + if self.data_variable == "x": + bar.sticky_edges.x[:] = sticky_data + bar.sticky_edges.y[:] = sticky_stat + else: + bar.sticky_edges.x[:] = sticky_stat + bar.sticky_edges.y[:] = sticky_data + + hist_artists.extend(artists) + + else: + + # Use either fill_between or plot to draw hull of histogram + if element == "step": + + final = hist.iloc[-1] + x = np.append(hist["edges"], final["edges"] + final["widths"]) + y = np.append(hist["heights"], final["heights"]) + b = np.append(bottom, bottom[-1]) + + if self.data_variable == "x": + step = "post" + drawstyle = "steps-post" + else: + step = "post" # fillbetweenx handles mapping internally + drawstyle = "steps-pre" + + elif element == "poly": + + x = hist["edges"] + hist["widths"] / 2 + y = hist["heights"] + b = bottom + + step = None + drawstyle = None + + if self.data_variable == "x": + if fill: + artist = ax.fill_between(x, b, y, step=step, **artist_kws) + else: + artist, = ax.plot(x, y, drawstyle=drawstyle, **artist_kws) + artist.sticky_edges.x[:] = sticky_data + artist.sticky_edges.y[:] = sticky_stat + else: + if fill: + artist = ax.fill_betweenx(x, b, y, step=step, **artist_kws) + else: + artist, = ax.plot(y, x, drawstyle=drawstyle, **artist_kws) + artist.sticky_edges.x[:] = sticky_stat + artist.sticky_edges.y[:] = sticky_data + + hist_artists.append(artist) + + if kde: + + # Add in the density curves + + try: + density = densities[key] + except KeyError: + continue + support = density.index + + if "x" in self.variables: + line_args = support, density + sticky_x, sticky_y = None, (0, np.inf) + else: + line_args = density, support + sticky_x, sticky_y = (0, np.inf), None + + line_kws["color"] = to_rgba(color, 1) + line, = ax.plot( + *line_args, **line_kws, + ) + + if sticky_x is not None: + line.sticky_edges.x[:] = sticky_x + if sticky_y is not None: + line.sticky_edges.y[:] = sticky_y + + if element == "bars" and "linewidth" not in plot_kws: + + # Now we handle linewidth, which depends on the scaling of the plot + + # We will base everything on the minimum bin width + hist_metadata = pd.concat([ + # Use .items for generality over dict or df + h.index.to_frame() for _, h in histograms.items() + ]).reset_index(drop=True) + thin_bar_idx = hist_metadata["widths"].idxmin() + binwidth = hist_metadata.loc[thin_bar_idx, "widths"] + left_edge = hist_metadata.loc[thin_bar_idx, "edges"] + + # Set initial value + default_linewidth = math.inf + + # Loop through subsets based only on facet variables + for sub_vars, _ in self.iter_data(): + + ax = self._get_axes(sub_vars) + + # Needed in some cases to get valid transforms. + # Innocuous in other cases? + ax.autoscale_view() + + # Convert binwidth from data coordinates to pixels + pts_x, pts_y = 72 / ax.figure.dpi * abs( + ax.transData.transform([left_edge + binwidth] * 2) + - ax.transData.transform([left_edge] * 2) + ) + if self.data_variable == "x": + binwidth_points = pts_x + else: + binwidth_points = pts_y + + # The relative size of the lines depends on the appearance + # This is a provisional value and may need more tweaking + default_linewidth = min(.1 * binwidth_points, default_linewidth) + + # Set the attributes + for bar in hist_artists: + + # Don't let the lines get too thick + max_linewidth = bar.get_linewidth() + if not fill: + max_linewidth *= 1.5 + + linewidth = min(default_linewidth, max_linewidth) + + # If not filling, don't let lines dissapear + if not fill: + min_linewidth = .5 + linewidth = max(linewidth, min_linewidth) + + bar.set_linewidth(linewidth) + + # --- Finalize the plot ---- + + # Axis labels + ax = self.ax if self.ax is not None else self.facets.axes.flat[0] + default_x = default_y = "" + if self.data_variable == "x": + default_y = estimator.stat.capitalize() + if self.data_variable == "y": + default_x = estimator.stat.capitalize() + self._add_axis_labels(ax, default_x, default_y) + + # Legend for semantic variables + if "hue" in self.variables and legend: + + if fill or element == "bars": + artist = partial(mpl.patches.Patch) + else: + artist = partial(mpl.lines.Line2D, [], []) + + ax_obj = self.ax if self.ax is not None else self.facets + self._add_legend( + ax_obj, artist, fill, element, multiple, alpha, plot_kws, {}, + ) + + def plot_bivariate_histogram( + self, + common_bins, common_norm, + thresh, pthresh, pmax, + color, legend, + cbar, cbar_ax, cbar_kws, + estimate_kws, + **plot_kws, + ): + + # Default keyword dicts + cbar_kws = {} if cbar_kws is None else cbar_kws.copy() + + # Now initialize the Histogram estimator + estimator = Histogram(**estimate_kws) + + # Do pre-compute housekeeping related to multiple groups + if set(self.variables) - {"x", "y"}: + all_data = self.comp_data.dropna() + if common_bins: + estimator.define_bin_params( + all_data["x"], + all_data["y"], + all_data.get("weights", None), + ) + else: + common_norm = False + + # -- Determine colormap threshold and norm based on the full data + + full_heights = [] + for _, sub_data in self.iter_data(from_comp_data=True): + sub_data = sub_data.dropna() + sub_heights, _ = estimator( + sub_data["x"], sub_data["y"], sub_data.get("weights", None) + ) + full_heights.append(sub_heights) + + common_color_norm = not set(self.variables) - {"x", "y"} or common_norm + + if pthresh is not None and common_color_norm: + thresh = self._quantile_to_level(full_heights, pthresh) + + plot_kws.setdefault("vmin", 0) + if common_color_norm: + if pmax is not None: + vmax = self._quantile_to_level(full_heights, pmax) + else: + vmax = plot_kws.pop("vmax", max(map(np.max, full_heights))) + else: + vmax = None + + # Get a default color + # (We won't follow the color cycle here, as multiple plots are unlikely) + if color is None: + color = "C0" + + # --- Loop over data (subsets) and draw the histograms + for sub_vars, sub_data in self.iter_data("hue", from_comp_data=True): + + sub_data = sub_data.dropna() + + if sub_data.empty: + continue + + # Do the histogram computation + heights, (x_edges, y_edges) = estimator( + sub_data["x"], + sub_data["y"], + weights=sub_data.get("weights", None), + ) + + # Check for log scaling on the data axis + if self._log_scaled("x"): + x_edges = np.power(10, x_edges) + if self._log_scaled("y"): + y_edges = np.power(10, y_edges) + + # Apply scaling to normalize across groups + if estimator.stat != "count" and common_norm: + heights *= len(sub_data) / len(all_data) + + # Define the specific kwargs for this artist + artist_kws = plot_kws.copy() + if "hue" in self.variables: + color = self._hue_map(sub_vars["hue"]) + cmap = self._cmap_from_color(color) + artist_kws["cmap"] = cmap + else: + cmap = artist_kws.pop("cmap", None) + if isinstance(cmap, str): + cmap = color_palette(cmap, as_cmap=True) + elif cmap is None: + cmap = self._cmap_from_color(color) + artist_kws["cmap"] = cmap + + # Set the upper norm on the colormap + if not common_color_norm and pmax is not None: + vmax = self._quantile_to_level(heights, pmax) + if vmax is not None: + artist_kws["vmax"] = vmax + + # Make cells at or below the threshold transparent + if not common_color_norm and pthresh: + thresh = self._quantile_to_level(heights, pthresh) + if thresh is not None: + heights = np.ma.masked_less_equal(heights, thresh) + + # Get the axes for this plot + ax = self._get_axes(sub_vars) + + # pcolormesh is going to turn the grid off, but we want to keep it + # I'm not sure if there's a better way to get the grid state + x_grid = any([l.get_visible() for l in ax.xaxis.get_gridlines()]) + y_grid = any([l.get_visible() for l in ax.yaxis.get_gridlines()]) + + mesh = ax.pcolormesh( + x_edges, + y_edges, + heights.T, + **artist_kws, + ) + + # pcolormesh sets sticky edges, but we only want them if not thresholding + if thresh is not None: + mesh.sticky_edges.x[:] = [] + mesh.sticky_edges.y[:] = [] + + # Add an optional colorbar + # Note, we want to improve this. When hue is used, it will stack + # multiple colorbars with redundant ticks in an ugly way. + # But it's going to take some work to have multiple colorbars that + # share ticks nicely. + if cbar: + ax.figure.colorbar(mesh, cbar_ax, ax, **cbar_kws) + + # Reset the grid state + if x_grid: + ax.grid(True, axis="x") + if y_grid: + ax.grid(True, axis="y") + + # --- Finalize the plot + + ax = self.ax if self.ax is not None else self.facets.axes.flat[0] + self._add_axis_labels(ax) + + if "hue" in self.variables and legend: + + # TODO if possible, I would like to move the contour + # intensity information into the legend too and label the + # iso proportions rather than the raw density values + + artist_kws = {} + artist = partial(mpl.patches.Patch) + ax_obj = self.ax if self.ax is not None else self.facets + self._add_legend( + ax_obj, artist, True, False, "layer", 1, artist_kws, {}, + ) + + def plot_univariate_density( + self, + multiple, + common_norm, + common_grid, + warn_singular, + fill, + legend, + estimate_kws, + **plot_kws, + ): + + # Handle conditional defaults + if fill is None: + fill = multiple in ("stack", "fill") + + # Preprocess the matplotlib keyword dictionaries + if fill: + artist = mpl.collections.PolyCollection + else: + artist = mpl.lines.Line2D + plot_kws = _normalize_kwargs(plot_kws, artist) + + # Input checking + _check_argument("multiple", ["layer", "stack", "fill"], multiple) + + # Always share the evaluation grid when stacking + subsets = bool(set(self.variables) - {"x", "y"}) + if subsets and multiple in ("stack", "fill"): + common_grid = True + + # Check if the data axis is log scaled + log_scale = self._log_scaled(self.data_variable) + + # Do the computation + densities = self._compute_univariate_density( + self.data_variable, + common_norm, + common_grid, + estimate_kws, + log_scale, + warn_singular, + ) + + # Adjust densities based on the `multiple` rule + densities, baselines = self._resolve_multiple(densities, multiple) + + # Control the interaction with autoscaling by defining sticky_edges + # i.e. we don't want autoscale margins below the density curve + sticky_density = (0, 1) if multiple == "fill" else (0, np.inf) + + if multiple == "fill": + # Filled plots should not have any margins + sticky_support = densities.index.min(), densities.index.max() + else: + sticky_support = [] + + # Handle default visual attributes + if "hue" not in self.variables: + if self.ax is None: + color = plot_kws.pop("color", None) + default_color = "C0" if color is None else color + else: + if fill: + if self.var_types[self.data_variable] == "datetime": + # Avoid drawing empty fill_between on date axis + # https://github.com/matplotlib/matplotlib/issues/17586 + scout = None + default_color = plot_kws.pop( + "color", plot_kws.pop("facecolor", None) + ) + if default_color is None: + default_color = "C0" + else: + scout = self.ax.fill_between([], [], **plot_kws) + default_color = tuple(scout.get_facecolor().squeeze()) + plot_kws.pop("color", None) + else: + scout, = self.ax.plot([], [], **plot_kws) + default_color = scout.get_color() + if scout is not None: + scout.remove() + + plot_kws.pop("color", None) + if fill: + if multiple == "layer": + default_alpha = .25 + else: + default_alpha = .75 + else: + default_alpha = 1 + alpha = plot_kws.pop("alpha", default_alpha) # TODO make parameter? + + # Now iterate through the subsets and draw the densities + # We go backwards so stacked densities read from top-to-bottom + for sub_vars, _ in self.iter_data("hue", reverse=True): + + # Extract the support grid and density curve for this level + key = tuple(sub_vars.items()) + try: + density = densities[key] + except KeyError: + continue + support = density.index + fill_from = baselines[key] + + ax = self._get_axes(sub_vars) + + # Modify the matplotlib attributes from semantic mapping + if "hue" in self.variables: + color = self._hue_map(sub_vars["hue"]) + else: + color = default_color + + artist_kws = self._artist_kws( + plot_kws, fill, False, multiple, color, alpha + ) + + # Either plot a curve with observation values on the x axis + if "x" in self.variables: + + if fill: + artist = ax.fill_between( + support, fill_from, density, **artist_kws + ) + else: + artist, = ax.plot(support, density, **artist_kws) + + artist.sticky_edges.x[:] = sticky_support + artist.sticky_edges.y[:] = sticky_density + + # Or plot a curve with observation values on the y axis + else: + if fill: + artist = ax.fill_betweenx( + support, fill_from, density, **artist_kws + ) + else: + artist, = ax.plot(density, support, **artist_kws) + + artist.sticky_edges.x[:] = sticky_density + artist.sticky_edges.y[:] = sticky_support + + # --- Finalize the plot ---- + + ax = self.ax if self.ax is not None else self.facets.axes.flat[0] + default_x = default_y = "" + if self.data_variable == "x": + default_y = "Density" + if self.data_variable == "y": + default_x = "Density" + self._add_axis_labels(ax, default_x, default_y) + + if "hue" in self.variables and legend: + + if fill: + artist = partial(mpl.patches.Patch) + else: + artist = partial(mpl.lines.Line2D, [], []) + + ax_obj = self.ax if self.ax is not None else self.facets + self._add_legend( + ax_obj, artist, fill, False, multiple, alpha, plot_kws, {}, + ) + + def plot_bivariate_density( + self, + common_norm, + fill, + levels, + thresh, + color, + legend, + cbar, + warn_singular, + cbar_ax, + cbar_kws, + estimate_kws, + **contour_kws, + ): + + contour_kws = contour_kws.copy() + + estimator = KDE(**estimate_kws) + + if not set(self.variables) - {"x", "y"}: + common_norm = False + + all_data = self.plot_data.dropna() + + # Loop through the subsets and estimate the KDEs + densities, supports = {}, {} + + for sub_vars, sub_data in self.iter_data("hue", from_comp_data=True): + + # Extract the data points from this sub set and remove nulls + sub_data = sub_data.dropna() + observations = sub_data[["x", "y"]] + + # Extract the weights for this subset of observations + if "weights" in self.variables: + weights = sub_data["weights"] + else: + weights = None + + # Check that KDE will not error out + variance = observations[["x", "y"]].var() + if any(math.isclose(x, 0) for x in variance) or variance.isna().any(): + msg = ( + "Dataset has 0 variance; skipping density estimate. " + "Pass `warn_singular=False` to disable this warning." + ) + if warn_singular: + warnings.warn(msg, UserWarning) + continue + + # Estimate the density of observations at this level + observations = observations["x"], observations["y"] + density, support = estimator(*observations, weights=weights) + + # Transform the support grid back to the original scale + xx, yy = support + if self._log_scaled("x"): + xx = np.power(10, xx) + if self._log_scaled("y"): + yy = np.power(10, yy) + support = xx, yy + + # Apply a scaling factor so that the integral over all subsets is 1 + if common_norm: + density *= len(sub_data) / len(all_data) + + key = tuple(sub_vars.items()) + densities[key] = density + supports[key] = support + + # Define a grid of iso-proportion levels + if thresh is None: + thresh = 0 + if isinstance(levels, Number): + levels = np.linspace(thresh, 1, levels) + else: + if min(levels) < 0 or max(levels) > 1: + raise ValueError("levels must be in [0, 1]") + + # Transform from iso-proportions to iso-densities + if common_norm: + common_levels = self._quantile_to_level( + list(densities.values()), levels, + ) + draw_levels = {k: common_levels for k in densities} + else: + draw_levels = { + k: self._quantile_to_level(d, levels) + for k, d in densities.items() + } + + # Get a default single color from the attribute cycle + if self.ax is None: + default_color = "C0" if color is None else color + else: + scout, = self.ax.plot([], color=color) + default_color = scout.get_color() + scout.remove() + + # Define the coloring of the contours + if "hue" in self.variables: + for param in ["cmap", "colors"]: + if param in contour_kws: + msg = f"{param} parameter ignored when using hue mapping." + warnings.warn(msg, UserWarning) + contour_kws.pop(param) + else: + + # Work out a default coloring of the contours + coloring_given = set(contour_kws) & {"cmap", "colors"} + if fill and not coloring_given: + cmap = self._cmap_from_color(default_color) + contour_kws["cmap"] = cmap + if not fill and not coloring_given: + contour_kws["colors"] = [default_color] + + # Use our internal colormap lookup + cmap = contour_kws.pop("cmap", None) + if isinstance(cmap, str): + cmap = color_palette(cmap, as_cmap=True) + if cmap is not None: + contour_kws["cmap"] = cmap + + # Loop through the subsets again and plot the data + for sub_vars, _ in self.iter_data("hue"): + + if "hue" in sub_vars: + color = self._hue_map(sub_vars["hue"]) + if fill: + contour_kws["cmap"] = self._cmap_from_color(color) + else: + contour_kws["colors"] = [color] + + ax = self._get_axes(sub_vars) + + # Choose the function to plot with + # TODO could add a pcolormesh based option as well + # Which would look something like element="raster" + if fill: + contour_func = ax.contourf + else: + contour_func = ax.contour + + key = tuple(sub_vars.items()) + if key not in densities: + continue + density = densities[key] + xx, yy = supports[key] + + label = contour_kws.pop("label", None) + + cset = contour_func( + xx, yy, density, + levels=draw_levels[key], + **contour_kws, + ) + + if "hue" not in self.variables: + cset.collections[0].set_label(label) + + # Add a color bar representing the contour heights + # Note: this shows iso densities, not iso proportions + # See more notes in histplot about how this could be improved + if cbar: + cbar_kws = {} if cbar_kws is None else cbar_kws + ax.figure.colorbar(cset, cbar_ax, ax, **cbar_kws) + + # --- Finalize the plot + ax = self.ax if self.ax is not None else self.facets.axes.flat[0] + self._add_axis_labels(ax) + + if "hue" in self.variables and legend: + + # TODO if possible, I would like to move the contour + # intensity information into the legend too and label the + # iso proportions rather than the raw density values + + artist_kws = {} + if fill: + artist = partial(mpl.patches.Patch) + else: + artist = partial(mpl.lines.Line2D, [], []) + + ax_obj = self.ax if self.ax is not None else self.facets + self._add_legend( + ax_obj, artist, fill, False, "layer", 1, artist_kws, {}, + ) + + def plot_univariate_ecdf(self, estimate_kws, legend, **plot_kws): + + estimator = ECDF(**estimate_kws) + + # Set the draw style to step the right way for the data varible + drawstyles = dict(x="steps-post", y="steps-pre") + plot_kws["drawstyle"] = drawstyles[self.data_variable] + + # Loop through the subsets, transform and plot the data + for sub_vars, sub_data in self.iter_data( + "hue", reverse=True, from_comp_data=True, + ): + + # Compute the ECDF + sub_data = sub_data.dropna() + if sub_data.empty: + continue + + observations = sub_data[self.data_variable] + weights = sub_data.get("weights", None) + stat, vals = estimator(observations, weights=weights) + + # Assign attributes based on semantic mapping + artist_kws = plot_kws.copy() + if "hue" in self.variables: + artist_kws["color"] = self._hue_map(sub_vars["hue"]) + + # Return the data variable to the linear domain + # This needs an automatic solution; see GH2409 + if self._log_scaled(self.data_variable): + vals = np.power(10, vals) + vals[0] = -np.inf + + # Work out the orientation of the plot + if self.data_variable == "x": + plot_args = vals, stat + stat_variable = "y" + else: + plot_args = stat, vals + stat_variable = "x" + + if estimator.stat == "count": + top_edge = len(observations) + else: + top_edge = 1 + + # Draw the line for this subset + ax = self._get_axes(sub_vars) + artist, = ax.plot(*plot_args, **artist_kws) + sticky_edges = getattr(artist.sticky_edges, stat_variable) + sticky_edges[:] = 0, top_edge + + # --- Finalize the plot ---- + ax = self.ax if self.ax is not None else self.facets.axes.flat[0] + stat = estimator.stat.capitalize() + default_x = default_y = "" + if self.data_variable == "x": + default_y = stat + if self.data_variable == "y": + default_x = stat + self._add_axis_labels(ax, default_x, default_y) + + if "hue" in self.variables and legend: + artist = partial(mpl.lines.Line2D, [], []) + alpha = plot_kws.get("alpha", 1) + ax_obj = self.ax if self.ax is not None else self.facets + self._add_legend( + ax_obj, artist, False, False, None, alpha, plot_kws, {}, + ) + + def plot_rug(self, height, expand_margins, legend, **kws): + + kws = _normalize_kwargs(kws, mpl.lines.Line2D) + + if self.ax is None: + kws["color"] = kws.pop("color", "C0") + else: + scout, = self.ax.plot([], [], **kws) + kws["color"] = kws.pop("color", scout.get_color()) + scout.remove() + + for sub_vars, sub_data, in self.iter_data(from_comp_data=True): + + ax = self._get_axes(sub_vars) + + kws.setdefault("linewidth", 1) + + if expand_margins: + xmarg, ymarg = ax.margins() + if "x" in self.variables: + ymarg += height * 2 + if "y" in self.variables: + xmarg += height * 2 + ax.margins(x=xmarg, y=ymarg) + + if "hue" in self.variables: + kws.pop("c", None) + kws.pop("color", None) + + if "x" in self.variables: + self._plot_single_rug(sub_data, "x", height, ax, kws) + if "y" in self.variables: + self._plot_single_rug(sub_data, "y", height, ax, kws) + + # --- Finalize the plot + self._add_axis_labels(ax) + if "hue" in self.variables and legend: + # TODO ideally i'd like the legend artist to look like a rug + legend_artist = partial(mpl.lines.Line2D, [], []) + self._add_legend( + ax, legend_artist, False, False, None, 1, {}, {}, + ) + + def _plot_single_rug(self, sub_data, var, height, ax, kws): + """Draw a rugplot along one axis of the plot.""" + vector = sub_data[var] + n = len(vector) + + # Return data to linear domain + # This needs an automatic solution; see GH2409 + if self._log_scaled(var): + vector = np.power(10, vector) + + # We'll always add a single collection with varying colors + if "hue" in self.variables: + colors = self._hue_map(sub_data["hue"]) + else: + colors = None + + # Build the array of values for the LineCollection + if var == "x": + + trans = tx.blended_transform_factory(ax.transData, ax.transAxes) + xy_pairs = np.column_stack([ + np.repeat(vector, 2), np.tile([0, height], n) + ]) + + if var == "y": + + trans = tx.blended_transform_factory(ax.transAxes, ax.transData) + xy_pairs = np.column_stack([ + np.tile([0, height], n), np.repeat(vector, 2) + ]) + + # Draw the lines on the plot + line_segs = xy_pairs.reshape([n, 2, 2]) + ax.add_collection(LineCollection( + line_segs, transform=trans, colors=colors, **kws + )) + + ax.autoscale_view(scalex=var == "x", scaley=var == "y") + + +class _DistributionFacetPlotter(_DistributionPlotter): + + semantics = _DistributionPlotter.semantics + ("col", "row") + + +# ==================================================================================== # +# External API +# ==================================================================================== # + +def histplot( + data=None, *, + # Vector variables + x=None, y=None, hue=None, weights=None, + # Histogram computation parameters + stat="count", bins="auto", binwidth=None, binrange=None, + discrete=None, cumulative=False, common_bins=True, common_norm=True, + # Histogram appearance parameters + multiple="layer", element="bars", fill=True, shrink=1, + # Histogram smoothing with a kernel density estimate + kde=False, kde_kws=None, line_kws=None, + # Bivariate histogram parameters + thresh=0, pthresh=None, pmax=None, cbar=False, cbar_ax=None, cbar_kws=None, + # Hue mapping parameters + palette=None, hue_order=None, hue_norm=None, color=None, + # Axes information + log_scale=None, legend=True, ax=None, + # Other appearance keywords + **kwargs, +): + + p = _DistributionPlotter( + data=data, + variables=_DistributionPlotter.get_semantics(locals()) + ) + + p.map_hue(palette=palette, order=hue_order, norm=hue_norm) + + if ax is None: + ax = plt.gca() + + # Check for a specification that lacks x/y data and return early + if not p.has_xy_data: + return ax + + # Attach the axes to the plotter, setting up unit conversions + p._attach(ax, log_scale=log_scale) + + # Default to discrete bins for categorical variables + if discrete is None: + discrete = p._default_discrete() + + estimate_kws = dict( + stat=stat, + bins=bins, + binwidth=binwidth, + binrange=binrange, + discrete=discrete, + cumulative=cumulative, + ) + + if p.univariate: + + p.plot_univariate_histogram( + multiple=multiple, + element=element, + fill=fill, + shrink=shrink, + common_norm=common_norm, + common_bins=common_bins, + kde=kde, + kde_kws=kde_kws, + color=color, + legend=legend, + estimate_kws=estimate_kws, + line_kws=line_kws, + **kwargs, + ) + + else: + + p.plot_bivariate_histogram( + common_bins=common_bins, + common_norm=common_norm, + thresh=thresh, + pthresh=pthresh, + pmax=pmax, + color=color, + legend=legend, + cbar=cbar, + cbar_ax=cbar_ax, + cbar_kws=cbar_kws, + estimate_kws=estimate_kws, + **kwargs, + ) + + return ax + + +histplot.__doc__ = """\ +Plot univariate or bivariate histograms to show distributions of datasets. + +A histogram is a classic visualization tool that represents the distribution +of one or more variables by counting the number of observations that fall within +disrete bins. + +This function can normalize the statistic computed within each bin to estimate +frequency, density or probability mass, and it can add a smooth curve obtained +using a kernel density estimate, similar to :func:`kdeplot`. + +More information is provided in the :ref:`user guide `. + +Parameters +---------- +{params.core.data} +{params.core.xy} +{params.core.hue} +weights : vector or key in ``data`` + If provided, weight the contribution of the corresponding data points + towards the count in each bin by these factors. +{params.hist.stat} +{params.hist.bins} +{params.hist.binwidth} +{params.hist.binrange} +discrete : bool + If True, default to ``binwidth=1`` and draw the bars so that they are + centered on their corresponding data points. This avoids "gaps" that may + otherwise appear when using discrete (integer) data. +cumulative : bool + If True, plot the cumulative counts as bins increase. +common_bins : bool + If True, use the same bins when semantic variables produce multiple + plots. If using a reference rule to determine the bins, it will be computed + with the full dataset. +common_norm : bool + If True and using a normalized statistic, the normalization will apply over + the full dataset. Otherwise, normalize each histogram independently. +multiple : {{"layer", "dodge", "stack", "fill"}} + Approach to resolving multiple elements when semantic mapping creates subsets. + Only relevant with univariate data. +element : {{"bars", "step", "poly"}} + Visual representation of the histogram statistic. + Only relevant with univariate data. +fill : bool + If True, fill in the space under the histogram. + Only relevant with univariate data. +shrink : number + Scale the width of each bar relative to the binwidth by this factor. + Only relevant with univariate data. +kde : bool + If True, compute a kernel density estimate to smooth the distribution + and show on the plot as (one or more) line(s). + Only relevant with univariate data. +kde_kws : dict + Parameters that control the KDE computation, as in :func:`kdeplot`. +line_kws : dict + Parameters that control the KDE visualization, passed to + :meth:`matplotlib.axes.Axes.plot`. +thresh : number or None + Cells with a statistic less than or equal to this value will be transparent. + Only relevant with bivariate data. +pthresh : number or None + Like ``thresh``, but a value in [0, 1] such that cells with aggregate counts + (or other statistics, when used) up to this proportion of the total will be + transparent. +pmax : number or None + A value in [0, 1] that sets that saturation point for the colormap at a value + such that cells below is constistute this proportion of the total count (or + other statistic, when used). +{params.dist.cbar} +{params.dist.cbar_ax} +{params.dist.cbar_kws} +{params.core.palette} +{params.core.hue_order} +{params.core.hue_norm} +{params.core.color} +{params.dist.log_scale} +{params.dist.legend} +{params.core.ax} +kwargs + Other keyword arguments are passed to one of the following matplotlib + functions: + + - :meth:`matplotlib.axes.Axes.bar` (univariate, element="bars") + - :meth:`matplotlib.axes.Axes.fill_between` (univariate, other element, fill=True) + - :meth:`matplotlib.axes.Axes.plot` (univariate, other element, fill=False) + - :meth:`matplotlib.axes.Axes.pcolormesh` (bivariate) + +Returns +------- +{returns.ax} + +See Also +-------- +{seealso.displot} +{seealso.kdeplot} +{seealso.rugplot} +{seealso.ecdfplot} +{seealso.jointplot} + +Notes +----- + +The choice of bins for computing and plotting a histogram can exert +substantial influence on the insights that one is able to draw from the +visualization. If the bins are too large, they may erase important features. +On the other hand, bins that are too small may be dominated by random +variability, obscuring the shape of the true underlying distribution. The +default bin size is determined using a reference rule that depends on the +sample size and variance. This works well in many cases, (i.e., with +"well-behaved" data) but it fails in others. It is always a good to try +different bin sizes to be sure that you are not missing something important. +This function allows you to specify bins in several different ways, such as +by setting the total number of bins to use, the width of each bin, or the +specific locations where the bins should break. + +Examples +-------- + +.. include:: ../docstrings/histplot.rst + +""".format( + params=_param_docs, + returns=_core_docs["returns"], + seealso=_core_docs["seealso"], +) + + +@_deprecate_positional_args +def kdeplot( + x=None, # Allow positional x, because behavior will not change with reorg + *, + y=None, + shade=None, # Note "soft" deprecation, explained below + vertical=False, # Deprecated + kernel=None, # Deprecated + bw=None, # Deprecated + gridsize=200, # TODO maybe depend on uni/bivariate? + cut=3, clip=None, legend=True, cumulative=False, + shade_lowest=None, # Deprecated, controlled with levels now + cbar=False, cbar_ax=None, cbar_kws=None, + ax=None, + + # New params + weights=None, # TODO note that weights is grouped with semantics + hue=None, palette=None, hue_order=None, hue_norm=None, + multiple="layer", common_norm=True, common_grid=False, + levels=10, thresh=.05, + bw_method="scott", bw_adjust=1, log_scale=None, + color=None, fill=None, + + # Renamed params + data=None, data2=None, + + # New in v0.12 + warn_singular=True, + + **kwargs, +): + + # Handle deprecation of `data2` as name for y variable + if data2 is not None: + + y = data2 + + # If `data2` is present, we need to check for the `data` kwarg being + # used to pass a vector for `x`. We'll reassign the vectors and warn. + # We need this check because just passing a vector to `data` is now + # technically valid. + + x_passed_as_data = ( + x is None + and data is not None + and np.ndim(data) == 1 + ) + + if x_passed_as_data: + msg = "Use `x` and `y` rather than `data` `and `data2`" + x = data + else: + msg = "The `data2` param is now named `y`; please update your code" + + warnings.warn(msg, FutureWarning) + + # Handle deprecation of `vertical` + if vertical: + msg = ( + "The `vertical` parameter is deprecated and will be removed in a " + "future version. Assign the data to the `y` variable instead." + ) + warnings.warn(msg, FutureWarning) + x, y = y, x + + # Handle deprecation of `bw` + if bw is not None: + msg = ( + "The `bw` parameter is deprecated in favor of `bw_method` and " + f"`bw_adjust`. Using {bw} for `bw_method`, but please " + "see the docs for the new parameters and update your code." + ) + warnings.warn(msg, FutureWarning) + bw_method = bw + + # Handle deprecation of `kernel` + if kernel is not None: + msg = ( + "Support for alternate kernels has been removed. " + "Using Gaussian kernel." + ) + warnings.warn(msg, UserWarning) + + # Handle deprecation of shade_lowest + if shade_lowest is not None: + if shade_lowest: + thresh = 0 + msg = ( + "`shade_lowest` is now deprecated in favor of `thresh`. " + f"Setting `thresh={thresh}`, but please update your code." + ) + warnings.warn(msg, UserWarning) + + # Handle `n_levels` + # This was never in the formal API but it was processed, and appeared in an + # example. We can treat as an alias for `levels` now and deprecate later. + levels = kwargs.pop("n_levels", levels) + + # Handle "soft" deprecation of shade `shade` is not really the right + # terminology here, but unlike some of the other deprecated parameters it + # is probably very commonly used and much hard to remove. This is therefore + # going to be a longer process where, first, `fill` will be introduced and + # be used throughout the documentation. In 0.12, when kwarg-only + # enforcement hits, we can remove the shade/shade_lowest out of the + # function signature all together and pull them out of the kwargs. Then we + # can actually fire a FutureWarning, and eventually remove. + if shade is not None: + fill = shade + + # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # + + p = _DistributionPlotter( + data=data, + variables=_DistributionPlotter.get_semantics(locals()), + ) + + p.map_hue(palette=palette, order=hue_order, norm=hue_norm) + + if ax is None: + ax = plt.gca() + + # Check for a specification that lacks x/y data and return early + if not p.has_xy_data: + return ax + + # Pack the kwargs for statistics.KDE + estimate_kws = dict( + bw_method=bw_method, + bw_adjust=bw_adjust, + gridsize=gridsize, + cut=cut, + clip=clip, + cumulative=cumulative, + ) + + p._attach(ax, allowed_types=["numeric", "datetime"], log_scale=log_scale) + + if p.univariate: + + plot_kws = kwargs.copy() + if color is not None: + plot_kws["color"] = color + + p.plot_univariate_density( + multiple=multiple, + common_norm=common_norm, + common_grid=common_grid, + fill=fill, + legend=legend, + warn_singular=warn_singular, + estimate_kws=estimate_kws, + **plot_kws, + ) + + else: + + p.plot_bivariate_density( + common_norm=common_norm, + fill=fill, + levels=levels, + thresh=thresh, + legend=legend, + color=color, + warn_singular=warn_singular, + cbar=cbar, + cbar_ax=cbar_ax, + cbar_kws=cbar_kws, + estimate_kws=estimate_kws, + **kwargs, + ) + + return ax + + +kdeplot.__doc__ = """\ +Plot univariate or bivariate distributions using kernel density estimation. + +A kernel density estimate (KDE) plot is a method for visualizing the +distribution of observations in a dataset, analagous to a histogram. KDE +represents the data using a continuous probability density curve in one or +more dimensions. + +The approach is explained further in the :ref:`user guide `. + +Relative to a histogram, KDE can produce a plot that is less cluttered and +more interpretable, especially when drawing multiple distributions. But it +has the potential to introduce distortions if the underlying distribution is +bounded or not smooth. Like a histogram, the quality of the representation +also depends on the selection of good smoothing parameters. + +Parameters +---------- +{params.core.xy} +shade : bool + Alias for ``fill``. Using ``fill`` is recommended. +vertical : bool + Orientation parameter. + + .. deprecated:: 0.11.0 + specify orientation by assigning the ``x`` or ``y`` variables. + +kernel : str + Function that defines the kernel. + + .. deprecated:: 0.11.0 + support for non-Gaussian kernels has been removed. + +bw : str, number, or callable + Smoothing parameter. + + .. deprecated:: 0.11.0 + see ``bw_method`` and ``bw_adjust``. + +gridsize : int + Number of points on each dimension of the evaluation grid. +{params.kde.cut} +{params.kde.clip} +{params.dist.legend} +{params.kde.cumulative} +shade_lowest : bool + If False, the area below the lowest contour will be transparent + + .. deprecated:: 0.11.0 + see ``thresh``. + +{params.dist.cbar} +{params.dist.cbar_ax} +{params.dist.cbar_kws} +{params.core.ax} +weights : vector or key in ``data`` + If provided, weight the kernel density estimation using these values. +{params.core.hue} +{params.core.palette} +{params.core.hue_order} +{params.core.hue_norm} +{params.dist.multiple} +common_norm : bool + If True, scale each conditional density by the number of observations + such that the total area under all densities sums to 1. Otherwise, + normalize each density independently. +common_grid : bool + If True, use the same evaluation grid for each kernel density estimate. + Only relevant with univariate data. +levels : int or vector + Number of contour levels or values to draw contours at. A vector argument + must have increasing values in [0, 1]. Levels correspond to iso-proportions + of the density: e.g., 20% of the probability mass will lie below the + contour drawn for 0.2. Only relevant with bivariate data. +thresh : number in [0, 1] + Lowest iso-proportion level at which to draw a contour line. Ignored when + ``levels`` is a vector. Only relevant with bivariate data. +{params.kde.bw_method} +{params.kde.bw_adjust} +{params.dist.log_scale} +{params.core.color} +fill : bool or None + If True, fill in the area under univariate density curves or between + bivariate contours. If None, the default depends on ``multiple``. +{params.core.data} +warn_singular : bool + If True, issue a warning when trying to estimate the density of data + with zero variance. +kwargs + Other keyword arguments are passed to one of the following matplotlib + functions: + + - :meth:`matplotlib.axes.Axes.plot` (univariate, ``fill=False``), + - :meth:`matplotlib.axes.Axes.fill_between` (univariate, ``fill=True``), + - :meth:`matplotlib.axes.Axes.contour` (bivariate, ``fill=False``), + - :meth:`matplotlib.axes.contourf` (bivariate, ``fill=True``). + +Returns +------- +{returns.ax} + +See Also +-------- +{seealso.displot} +{seealso.histplot} +{seealso.ecdfplot} +{seealso.jointplot} +{seealso.violinplot} + +Notes +----- + +The *bandwidth*, or standard deviation of the smoothing kernel, is an +important parameter. Misspecification of the bandwidth can produce a +distorted representation of the data. Much like the choice of bin width in a +histogram, an over-smoothed curve can erase true features of a +distribution, while an under-smoothed curve can create false features out of +random variability. The rule-of-thumb that sets the default bandwidth works +best when the true distribution is smooth, unimodal, and roughly bell-shaped. +It is always a good idea to check the default behavior by using ``bw_adjust`` +to increase or decrease the amount of smoothing. + +Because the smoothing algorithm uses a Gaussian kernel, the estimated density +curve can extend to values that do not make sense for a particular dataset. +For example, the curve may be drawn over negative values when smoothing data +that are naturally positive. The ``cut`` and ``clip`` parameters can be used +to control the extent of the curve, but datasets that have many observations +close to a natural boundary may be better served by a different visualization +method. + +Similar considerations apply when a dataset is naturally discrete or "spiky" +(containing many repeated observations of the same value). Kernel density +estimation will always produce a smooth curve, which would be misleading +in these situations. + +The units on the density axis are a common source of confusion. While kernel +density estimation produces a probability distribution, the height of the curve +at each point gives a density, not a probability. A probability can be obtained +only by integrating the density across a range. The curve is normalized so +that the integral over all possible values is 1, meaning that the scale of +the density axis depends on the data values. + +Examples +-------- + +.. include:: ../docstrings/kdeplot.rst + +""".format( + params=_param_docs, + returns=_core_docs["returns"], + seealso=_core_docs["seealso"], +) + + +def ecdfplot( + data=None, *, + # Vector variables + x=None, y=None, hue=None, weights=None, + # Computation parameters + stat="proportion", complementary=False, + # Hue mapping parameters + palette=None, hue_order=None, hue_norm=None, + # Axes information + log_scale=None, legend=True, ax=None, + # Other appearance keywords + **kwargs, +): + + p = _DistributionPlotter( + data=data, + variables=_DistributionPlotter.get_semantics(locals()) + ) + + p.map_hue(palette=palette, order=hue_order, norm=hue_norm) + + # We could support other semantics (size, style) here fairly easily + # But it would make distplot a bit more complicated. + # It's always possible to add features like that later, so I am going to defer. + # It will be even easier to wait until after there is a more general/abstract + # way to go from semantic specs to artist attributes. + + if ax is None: + ax = plt.gca() + + # We could add this one day, but it's of dubious value + if not p.univariate: + raise NotImplementedError("Bivariate ECDF plots are not implemented") + + # Attach the axes to the plotter, setting up unit conversions + p._attach(ax, log_scale=log_scale) + + estimate_kws = dict( + stat=stat, + complementary=complementary, + ) + + p.plot_univariate_ecdf( + estimate_kws=estimate_kws, + legend=legend, + **kwargs, + ) + + return ax + + +ecdfplot.__doc__ = """\ +Plot empirical cumulative distribution functions. + +An ECDF represents the proportion or count of observations falling below each +unique value in a dataset. Compared to a histogram or density plot, it has the +advantage that each observation is visualized directly, meaning that there are +no binning or smoothing parameters that need to be adjusted. It also aids direct +comparisons between multiple distributions. A downside is that the relationship +between the appearance of the plot and the basic properties of the distribution +(such as its central tendency, variance, and the presence of any bimodality) +may not be as intuitive. + +More information is provided in the :ref:`user guide `. + +Parameters +---------- +{params.core.data} +{params.core.xy} +{params.core.hue} +weights : vector or key in ``data`` + If provided, weight the contribution of the corresponding data points + towards the cumulative distribution using these values. +{params.ecdf.stat} +{params.ecdf.complementary} +{params.core.palette} +{params.core.hue_order} +{params.core.hue_norm} +{params.dist.log_scale} +{params.dist.legend} +{params.core.ax} +kwargs + Other keyword arguments are passed to :meth:`matplotlib.axes.Axes.plot`. + +Returns +------- +{returns.ax} + +See Also +-------- +{seealso.displot} +{seealso.histplot} +{seealso.kdeplot} +{seealso.rugplot} + +Examples +-------- + +.. include:: ../docstrings/ecdfplot.rst + +""".format( + params=_param_docs, + returns=_core_docs["returns"], + seealso=_core_docs["seealso"], +) + + +@_deprecate_positional_args +def rugplot( + x=None, # Allow positional x, because behavior won't change + *, + height=.025, axis=None, ax=None, + + # New parameters + data=None, y=None, hue=None, + palette=None, hue_order=None, hue_norm=None, + expand_margins=True, + legend=True, # TODO or maybe default to False? + + # Renamed parameter + a=None, + + **kwargs +): + + # A note: I think it would make sense to add multiple= to rugplot and allow + # rugs for different hue variables to be shifted orthogonal to the data axis + # But is this stacking, or dodging? + + # A note: if we want to add a style semantic to rugplot, + # we could make an option that draws the rug using scatterplot + + # A note, it would also be nice to offer some kind of histogram/density + # rugplot, since alpha blending doesn't work great in the large n regime + + # Handle deprecation of `a`` + if a is not None: + msg = "The `a` parameter is now called `x`. Please update your code." + warnings.warn(msg, FutureWarning) + x = a + del a + + # Handle deprecation of "axis" + if axis is not None: + msg = ( + "The `axis` variable is no longer used and will be removed. " + "Instead, assign variables directly to `x` or `y`." + ) + warnings.warn(msg, FutureWarning) + + # Handle deprecation of "vertical" + if kwargs.pop("vertical", axis == "y"): + x, y = None, x + msg = ( + "Using `vertical=True` to control the orientation of the plot " + "is deprecated. Instead, assign the data directly to `y`. " + ) + warnings.warn(msg, FutureWarning) + + # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # + + weights = None + p = _DistributionPlotter( + data=data, + variables=_DistributionPlotter.get_semantics(locals()), + ) + p.map_hue(palette=palette, order=hue_order, norm=hue_norm) + + if ax is None: + ax = plt.gca() + p._attach(ax) + + p.plot_rug(height, expand_margins, legend, **kwargs) + + return ax + + +rugplot.__doc__ = """\ +Plot marginal distributions by drawing ticks along the x and y axes. + +This function is intended to complement other plots by showing the location +of individual observations in an unobstrusive way. + +Parameters +---------- +{params.core.xy} +height : number + Proportion of axes extent covered by each rug element. +axis : {{"x", "y"}} + Axis to draw the rug on. + + .. deprecated:: 0.11.0 + specify axis by assigning the ``x`` or ``y`` variables. + +{params.core.ax} +{params.core.data} +{params.core.hue} +{params.core.palette} +{params.core.hue_order} +{params.core.hue_norm} +expand_margins : bool + If True, increase the axes margins by the height of the rug to avoid + overlap with other elements. +legend : bool + If False, do not add a legend for semantic variables. +kwargs + Other keyword arguments are passed to + :meth:`matplotlib.collections.LineCollection` + +Returns +------- +{returns.ax} + +Examples +-------- + +.. include:: ../docstrings/rugplot.rst + +""".format( + params=_param_docs, + returns=_core_docs["returns"], + seealso=_core_docs["seealso"], +) + + +def displot( + data=None, *, + # Vector variables + x=None, y=None, hue=None, row=None, col=None, weights=None, + # Other plot parameters + kind="hist", rug=False, rug_kws=None, log_scale=None, legend=True, + # Hue-mapping parameters + palette=None, hue_order=None, hue_norm=None, color=None, + # Faceting parameters + col_wrap=None, row_order=None, col_order=None, + height=5, aspect=1, facet_kws=None, + **kwargs, +): + + p = _DistributionFacetPlotter( + data=data, + variables=_DistributionFacetPlotter.get_semantics(locals()) + ) + + p.map_hue(palette=palette, order=hue_order, norm=hue_norm) + + _check_argument("kind", ["hist", "kde", "ecdf"], kind) + + # --- Initialize the FacetGrid object + + # Check for attempt to plot onto specific axes and warn + if "ax" in kwargs: + msg = ( + "`displot` is a figure-level function and does not accept " + "the ax= paramter. You may wish to try {}plot.".format(kind) + ) + warnings.warn(msg, UserWarning) + kwargs.pop("ax") + + for var in ["row", "col"]: + # Handle faceting variables that lack name information + if var in p.variables and p.variables[var] is None: + p.variables[var] = f"_{var}_" + + # Adapt the plot_data dataframe for use with FacetGrid + grid_data = p.plot_data.rename(columns=p.variables) + grid_data = grid_data.loc[:, ~grid_data.columns.duplicated()] + + col_name = p.variables.get("col", None) + row_name = p.variables.get("row", None) + + if facet_kws is None: + facet_kws = {} + + g = FacetGrid( + data=grid_data, row=row_name, col=col_name, + col_wrap=col_wrap, row_order=row_order, + col_order=col_order, height=height, + aspect=aspect, + **facet_kws, + ) + + # Now attach the axes object to the plotter object + if kind == "kde": + allowed_types = ["numeric", "datetime"] + else: + allowed_types = None + p._attach(g, allowed_types=allowed_types, log_scale=log_scale) + + # Check for a specification that lacks x/y data and return early + if not p.has_xy_data: + return g + + kwargs["legend"] = legend + + # --- Draw the plots + + if kind == "hist": + + hist_kws = kwargs.copy() + + # Extract the parameters that will go directly to Histogram + estimate_defaults = {} + _assign_default_kwargs(estimate_defaults, Histogram.__init__, histplot) + + estimate_kws = {} + for key, default_val in estimate_defaults.items(): + estimate_kws[key] = hist_kws.pop(key, default_val) + + # Handle derivative defaults + if estimate_kws["discrete"] is None: + estimate_kws["discrete"] = p._default_discrete() + + hist_kws["estimate_kws"] = estimate_kws + hist_kws.setdefault("color", color) + + if p.univariate: + + _assign_default_kwargs(hist_kws, p.plot_univariate_histogram, histplot) + p.plot_univariate_histogram(**hist_kws) + + else: + + _assign_default_kwargs(hist_kws, p.plot_bivariate_histogram, histplot) + p.plot_bivariate_histogram(**hist_kws) + + elif kind == "kde": + + kde_kws = kwargs.copy() + + # Extract the parameters that will go directly to KDE + estimate_defaults = {} + _assign_default_kwargs(estimate_defaults, KDE.__init__, kdeplot) + + estimate_kws = {} + for key, default_val in estimate_defaults.items(): + estimate_kws[key] = kde_kws.pop(key, default_val) + + kde_kws["estimate_kws"] = estimate_kws + kde_kws["color"] = color + + if p.univariate: + + _assign_default_kwargs(kde_kws, p.plot_univariate_density, kdeplot) + p.plot_univariate_density(**kde_kws) + + else: + + _assign_default_kwargs(kde_kws, p.plot_bivariate_density, kdeplot) + p.plot_bivariate_density(**kde_kws) + + elif kind == "ecdf": + + ecdf_kws = kwargs.copy() + + # Extract the parameters that will go directly to the estimator + estimate_kws = {} + estimate_defaults = {} + _assign_default_kwargs(estimate_defaults, ECDF.__init__, ecdfplot) + for key, default_val in estimate_defaults.items(): + estimate_kws[key] = ecdf_kws.pop(key, default_val) + + ecdf_kws["estimate_kws"] = estimate_kws + ecdf_kws["color"] = color + + if p.univariate: + + _assign_default_kwargs(ecdf_kws, p.plot_univariate_ecdf, ecdfplot) + p.plot_univariate_ecdf(**ecdf_kws) + + else: + + raise NotImplementedError("Bivariate ECDF plots are not implemented") + + # All plot kinds can include a rug + if rug: + # TODO with expand_margins=True, each facet expands margins... annoying! + if rug_kws is None: + rug_kws = {} + _assign_default_kwargs(rug_kws, p.plot_rug, rugplot) + rug_kws["legend"] = False + if color is not None: + rug_kws["color"] = color + p.plot_rug(**rug_kws) + + # Call FacetGrid annotation methods + # Note that the legend is currently set inside the plotting method + g.set_axis_labels( + x_var=p.variables.get("x", g.axes.flat[0].get_xlabel()), + y_var=p.variables.get("y", g.axes.flat[0].get_ylabel()), + ) + g.set_titles() + g.tight_layout() + + if data is not None and (x is not None or y is not None): + if not isinstance(data, pd.DataFrame): + data = pd.DataFrame(data) + g.data = pd.merge( + data, + g.data[g.data.columns.difference(data.columns)], + left_index=True, + right_index=True, + ) + else: + wide_cols = { + k: f"_{k}_" if v is None else v for k, v in p.variables.items() + } + g.data = p.plot_data.rename(columns=wide_cols) + + return g + + +displot.__doc__ = """\ +Figure-level interface for drawing distribution plots onto a FacetGrid. + +This function provides access to several approaches for visualizing the +univariate or bivariate distribution of data, including subsets of data +defined by semantic mapping and faceting across multiple subplots. The +``kind`` parameter selects the approach to use: + +- :func:`histplot` (with ``kind="hist"``; the default) +- :func:`kdeplot` (with ``kind="kde"``) +- :func:`ecdfplot` (with ``kind="ecdf"``; univariate-only) + +Additionally, a :func:`rugplot` can be added to any kind of plot to show +individual observations. + +Extra keyword arguments are passed to the underlying function, so you should +refer to the documentation for each to understand the complete set of options +for making plots with this interface. + +See the :doc:`distribution plots tutorial <../tutorial/distributions>` for a more +in-depth discussion of the relative strengths and weaknesses of each approach. +The distinction between figure-level and axes-level functions is explained +further in the :doc:`user guide <../tutorial/function_overview>`. + +Parameters +---------- +{params.core.data} +{params.core.xy} +{params.core.hue} +{params.facets.rowcol} +kind : {{"hist", "kde", "ecdf"}} + Approach for visualizing the data. Selects the underlying plotting function + and determines the additional set of valid parameters. +rug : bool + If True, show each observation with marginal ticks (as in :func:`rugplot`). +rug_kws : dict + Parameters to control the appearance of the rug plot. +{params.dist.log_scale} +{params.dist.legend} +{params.core.palette} +{params.core.hue_order} +{params.core.hue_norm} +{params.core.color} +{params.facets.col_wrap} +{params.facets.rowcol_order} +{params.facets.height} +{params.facets.aspect} +{params.facets.facet_kws} +kwargs + Other keyword arguments are documented with the relevant axes-level function: + + - :func:`histplot` (with ``kind="hist"``) + - :func:`kdeplot` (with ``kind="kde"``) + - :func:`ecdfplot` (with ``kind="ecdf"``) + +Returns +------- +{returns.facetgrid} + +See Also +-------- +{seealso.histplot} +{seealso.kdeplot} +{seealso.rugplot} +{seealso.ecdfplot} +{seealso.jointplot} + +Examples +-------- + +See the API documentation for the axes-level functions for more details +about the breadth of options available for each plot kind. + +.. include:: ../docstrings/displot.rst + +""".format( + params=_param_docs, + returns=_core_docs["returns"], + seealso=_core_docs["seealso"], +) + + +# =========================================================================== # +# DEPRECATED FUNCTIONS LIVE BELOW HERE +# =========================================================================== # + + +def _freedman_diaconis_bins(a): + """Calculate number of hist bins using Freedman-Diaconis rule.""" + # From https://stats.stackexchange.com/questions/798/ + a = np.asarray(a) + if len(a) < 2: + return 1 + h = 2 * stats.iqr(a) / (len(a) ** (1 / 3)) + # fall back to sqrt(a) bins if iqr is 0 + if h == 0: + return int(np.sqrt(a.size)) + else: + return int(np.ceil((a.max() - a.min()) / h)) + + +def distplot(a=None, bins=None, hist=True, kde=True, rug=False, fit=None, + hist_kws=None, kde_kws=None, rug_kws=None, fit_kws=None, + color=None, vertical=False, norm_hist=False, axlabel=None, + label=None, ax=None, x=None): + """DEPRECATED: Flexibly plot a univariate distribution of observations. + + .. warning:: + This function is deprecated and will be removed in a future version. + Please adapt your code to use one of two new functions: + + - :func:`displot`, a figure-level function with a similar flexibility + over the kind of plot to draw + - :func:`histplot`, an axes-level function for plotting histograms, + including with kernel density smoothing + + This function combines the matplotlib ``hist`` function (with automatic + calculation of a good default bin size) with the seaborn :func:`kdeplot` + and :func:`rugplot` functions. It can also fit ``scipy.stats`` + distributions and plot the estimated PDF over the data. + + Parameters + ---------- + a : Series, 1d-array, or list. + Observed data. If this is a Series object with a ``name`` attribute, + the name will be used to label the data axis. + bins : argument for matplotlib hist(), or None, optional + Specification of hist bins. If unspecified, as reference rule is used + that tries to find a useful default. + hist : bool, optional + Whether to plot a (normed) histogram. + kde : bool, optional + Whether to plot a gaussian kernel density estimate. + rug : bool, optional + Whether to draw a rugplot on the support axis. + fit : random variable object, optional + An object with `fit` method, returning a tuple that can be passed to a + `pdf` method a positional arguments following a grid of values to + evaluate the pdf on. + hist_kws : dict, optional + Keyword arguments for :meth:`matplotlib.axes.Axes.hist`. + kde_kws : dict, optional + Keyword arguments for :func:`kdeplot`. + rug_kws : dict, optional + Keyword arguments for :func:`rugplot`. + color : matplotlib color, optional + Color to plot everything but the fitted curve in. + vertical : bool, optional + If True, observed values are on y-axis. + norm_hist : bool, optional + If True, the histogram height shows a density rather than a count. + This is implied if a KDE or fitted density is plotted. + axlabel : string, False, or None, optional + Name for the support axis label. If None, will try to get it + from a.name if False, do not set a label. + label : string, optional + Legend label for the relevant component of the plot. + ax : matplotlib axis, optional + If provided, plot on this axis. + + Returns + ------- + ax : matplotlib Axes + Returns the Axes object with the plot for further tweaking. + + See Also + -------- + kdeplot : Show a univariate or bivariate distribution with a kernel + density estimate. + rugplot : Draw small vertical lines to show each observation in a + distribution. + + Examples + -------- + + Show a default plot with a kernel density estimate and histogram with bin + size determined automatically with a reference rule: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns, numpy as np + >>> sns.set_theme(); np.random.seed(0) + >>> x = np.random.randn(100) + >>> ax = sns.distplot(x) + + Use Pandas objects to get an informative axis label: + + .. plot:: + :context: close-figs + + >>> import pandas as pd + >>> x = pd.Series(x, name="x variable") + >>> ax = sns.distplot(x) + + Plot the distribution with a kernel density estimate and rug plot: + + .. plot:: + :context: close-figs + + >>> ax = sns.distplot(x, rug=True, hist=False) + + Plot the distribution with a histogram and maximum likelihood gaussian + distribution fit: + + .. plot:: + :context: close-figs + + >>> from scipy.stats import norm + >>> ax = sns.distplot(x, fit=norm, kde=False) + + Plot the distribution on the vertical axis: + + .. plot:: + :context: close-figs + + >>> ax = sns.distplot(x, vertical=True) + + Change the color of all the plot elements: + + .. plot:: + :context: close-figs + + >>> sns.set_color_codes() + >>> ax = sns.distplot(x, color="y") + + Pass specific parameters to the underlying plot functions: + + .. plot:: + :context: close-figs + + >>> ax = sns.distplot(x, rug=True, rug_kws={"color": "g"}, + ... kde_kws={"color": "k", "lw": 3, "label": "KDE"}, + ... hist_kws={"histtype": "step", "linewidth": 3, + ... "alpha": 1, "color": "g"}) + + """ + + if kde and not hist: + axes_level_suggestion = ( + "`kdeplot` (an axes-level function for kernel density plots)." + ) + else: + axes_level_suggestion = ( + "`histplot` (an axes-level function for histograms)." + ) + + msg = ( + "`distplot` is a deprecated function and will be removed in a future version. " + "Please adapt your code to use either `displot` (a figure-level function with " + "similar flexibility) or " + axes_level_suggestion + ) + warnings.warn(msg, FutureWarning) + + if ax is None: + ax = plt.gca() + + # Intelligently label the support axis + label_ax = bool(axlabel) + if axlabel is None and hasattr(a, "name"): + axlabel = a.name + if axlabel is not None: + label_ax = True + + # Support new-style API + if x is not None: + a = x + + # Make a a 1-d float array + a = np.asarray(a, float) + if a.ndim > 1: + a = a.squeeze() + + # Drop null values from array + a = remove_na(a) + + # Decide if the hist is normed + norm_hist = norm_hist or kde or (fit is not None) + + # Handle dictionary defaults + hist_kws = {} if hist_kws is None else hist_kws.copy() + kde_kws = {} if kde_kws is None else kde_kws.copy() + rug_kws = {} if rug_kws is None else rug_kws.copy() + fit_kws = {} if fit_kws is None else fit_kws.copy() + + # Get the color from the current color cycle + if color is None: + if vertical: + line, = ax.plot(0, a.mean()) + else: + line, = ax.plot(a.mean(), 0) + color = line.get_color() + line.remove() + + # Plug the label into the right kwarg dictionary + if label is not None: + if hist: + hist_kws["label"] = label + elif kde: + kde_kws["label"] = label + elif rug: + rug_kws["label"] = label + elif fit: + fit_kws["label"] = label + + if hist: + if bins is None: + bins = min(_freedman_diaconis_bins(a), 50) + hist_kws.setdefault("alpha", 0.4) + hist_kws.setdefault("density", norm_hist) + + orientation = "horizontal" if vertical else "vertical" + hist_color = hist_kws.pop("color", color) + ax.hist(a, bins, orientation=orientation, + color=hist_color, **hist_kws) + if hist_color != color: + hist_kws["color"] = hist_color + + if kde: + kde_color = kde_kws.pop("color", color) + kdeplot(a, vertical=vertical, ax=ax, color=kde_color, **kde_kws) + if kde_color != color: + kde_kws["color"] = kde_color + + if rug: + rug_color = rug_kws.pop("color", color) + axis = "y" if vertical else "x" + rugplot(a, axis=axis, ax=ax, color=rug_color, **rug_kws) + if rug_color != color: + rug_kws["color"] = rug_color + + if fit is not None: + + def pdf(x): + return fit.pdf(x, *params) + + fit_color = fit_kws.pop("color", "#282828") + gridsize = fit_kws.pop("gridsize", 200) + cut = fit_kws.pop("cut", 3) + clip = fit_kws.pop("clip", (-np.inf, np.inf)) + bw = stats.gaussian_kde(a).scotts_factor() * a.std(ddof=1) + x = _kde_support(a, bw, gridsize, cut, clip) + params = fit.fit(a) + y = pdf(x) + if vertical: + x, y = y, x + ax.plot(x, y, color=fit_color, **fit_kws) + if fit_color != "#282828": + fit_kws["color"] = fit_color + + if label_ax: + if vertical: + ax.set_ylabel(axlabel) + else: + ax.set_xlabel(axlabel) + + return ax diff --git a/grplot_seaborn/external/__init__.py b/grplot_seaborn/external/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/grplot_seaborn/external/docscrape.py b/grplot_seaborn/external/docscrape.py new file mode 100644 index 0000000..d655285 --- /dev/null +++ b/grplot_seaborn/external/docscrape.py @@ -0,0 +1,718 @@ +"""Extract reference documentation from the NumPy source tree. + +Copyright (C) 2008 Stefan van der Walt , Pauli Virtanen + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + +THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, +INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING +IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. + +""" +import inspect +import textwrap +import re +import pydoc +from warnings import warn +from collections import namedtuple +from collections.abc import Callable, Mapping +import copy +import sys + + +def strip_blank_lines(l): + "Remove leading and trailing blank lines from a list of lines" + while l and not l[0].strip(): + del l[0] + while l and not l[-1].strip(): + del l[-1] + return l + + +class Reader(object): + """A line-based string reader. + + """ + def __init__(self, data): + """ + Parameters + ---------- + data : str + String with lines separated by '\n'. + + """ + if isinstance(data, list): + self._str = data + else: + self._str = data.split('\n') # store string as list of lines + + self.reset() + + def __getitem__(self, n): + return self._str[n] + + def reset(self): + self._l = 0 # current line nr + + def read(self): + if not self.eof(): + out = self[self._l] + self._l += 1 + return out + else: + return '' + + def seek_next_non_empty_line(self): + for l in self[self._l:]: + if l.strip(): + break + else: + self._l += 1 + + def eof(self): + return self._l >= len(self._str) + + def read_to_condition(self, condition_func): + start = self._l + for line in self[start:]: + if condition_func(line): + return self[start:self._l] + self._l += 1 + if self.eof(): + return self[start:self._l+1] + return [] + + def read_to_next_empty_line(self): + self.seek_next_non_empty_line() + + def is_empty(line): + return not line.strip() + + return self.read_to_condition(is_empty) + + def read_to_next_unindented_line(self): + def is_unindented(line): + return (line.strip() and (len(line.lstrip()) == len(line))) + return self.read_to_condition(is_unindented) + + def peek(self, n=0): + if self._l + n < len(self._str): + return self[self._l + n] + else: + return '' + + def is_empty(self): + return not ''.join(self._str).strip() + + +class ParseError(Exception): + def __str__(self): + message = self.args[0] + if hasattr(self, 'docstring'): + message = "%s in %r" % (message, self.docstring) + return message + + +Parameter = namedtuple('Parameter', ['name', 'type', 'desc']) + + +class NumpyDocString(Mapping): + """Parses a numpydoc string to an abstract representation + + Instances define a mapping from section title to structured data. + + """ + + sections = { + 'Signature': '', + 'Summary': [''], + 'Extended Summary': [], + 'Parameters': [], + 'Returns': [], + 'Yields': [], + 'Receives': [], + 'Raises': [], + 'Warns': [], + 'Other Parameters': [], + 'Attributes': [], + 'Methods': [], + 'See Also': [], + 'Notes': [], + 'Warnings': [], + 'References': '', + 'Examples': '', + 'index': {} + } + + def __init__(self, docstring, config={}): + orig_docstring = docstring + docstring = textwrap.dedent(docstring).split('\n') + + self._doc = Reader(docstring) + self._parsed_data = copy.deepcopy(self.sections) + + try: + self._parse() + except ParseError as e: + e.docstring = orig_docstring + raise + + def __getitem__(self, key): + return self._parsed_data[key] + + def __setitem__(self, key, val): + if key not in self._parsed_data: + self._error_location("Unknown section %s" % key, error=False) + else: + self._parsed_data[key] = val + + def __iter__(self): + return iter(self._parsed_data) + + def __len__(self): + return len(self._parsed_data) + + def _is_at_section(self): + self._doc.seek_next_non_empty_line() + + if self._doc.eof(): + return False + + l1 = self._doc.peek().strip() # e.g. Parameters + + if l1.startswith('.. index::'): + return True + + l2 = self._doc.peek(1).strip() # ---------- or ========== + return l2.startswith('-'*len(l1)) or l2.startswith('='*len(l1)) + + def _strip(self, doc): + i = 0 + j = 0 + for i, line in enumerate(doc): + if line.strip(): + break + + for j, line in enumerate(doc[::-1]): + if line.strip(): + break + + return doc[i:len(doc)-j] + + def _read_to_next_section(self): + section = self._doc.read_to_next_empty_line() + + while not self._is_at_section() and not self._doc.eof(): + if not self._doc.peek(-1).strip(): # previous line was empty + section += [''] + + section += self._doc.read_to_next_empty_line() + + return section + + def _read_sections(self): + while not self._doc.eof(): + data = self._read_to_next_section() + name = data[0].strip() + + if name.startswith('..'): # index section + yield name, data[1:] + elif len(data) < 2: + yield StopIteration + else: + yield name, self._strip(data[2:]) + + def _parse_param_list(self, content, single_element_is_type=False): + r = Reader(content) + params = [] + while not r.eof(): + header = r.read().strip() + if ' : ' in header: + arg_name, arg_type = header.split(' : ')[:2] + else: + if single_element_is_type: + arg_name, arg_type = '', header + else: + arg_name, arg_type = header, '' + + desc = r.read_to_next_unindented_line() + desc = dedent_lines(desc) + desc = strip_blank_lines(desc) + + params.append(Parameter(arg_name, arg_type, desc)) + + return params + + # See also supports the following formats. + # + # + # SPACE* COLON SPACE+ SPACE* + # ( COMMA SPACE+ )+ (COMMA | PERIOD)? SPACE* + # ( COMMA SPACE+ )* SPACE* COLON SPACE+ SPACE* + + # is one of + # + # COLON COLON BACKTICK BACKTICK + # where + # is a legal function name, and + # is any nonempty sequence of word characters. + # Examples: func_f1 :meth:`func_h1` :obj:`~baz.obj_r` :class:`class_j` + # is a string describing the function. + + _role = r":(?P\w+):" + _funcbacktick = r"`(?P(?:~\w+\.)?[a-zA-Z0-9_\.-]+)`" + _funcplain = r"(?P[a-zA-Z0-9_\.-]+)" + _funcname = r"(" + _role + _funcbacktick + r"|" + _funcplain + r")" + _funcnamenext = _funcname.replace('role', 'rolenext') + _funcnamenext = _funcnamenext.replace('name', 'namenext') + _description = r"(?P\s*:(\s+(?P\S+.*))?)?\s*$" + _func_rgx = re.compile(r"^\s*" + _funcname + r"\s*") + _line_rgx = re.compile( + r"^\s*" + + r"(?P" + # group for all function names + _funcname + + r"(?P([,]\s+" + _funcnamenext + r")*)" + + r")" + # end of "allfuncs" + r"(?P[,\.])?" + # Some function lists have a trailing comma (or period) '\s*' + _description) + + # Empty elements are replaced with '..' + empty_description = '..' + + def _parse_see_also(self, content): + """ + func_name : Descriptive text + continued text + another_func_name : Descriptive text + func_name1, func_name2, :meth:`func_name`, func_name3 + + """ + + items = [] + + def parse_item_name(text): + """Match ':role:`name`' or 'name'.""" + m = self._func_rgx.match(text) + if not m: + raise ParseError("%s is not a item name" % text) + role = m.group('role') + name = m.group('name') if role else m.group('name2') + return name, role, m.end() + + rest = [] + for line in content: + if not line.strip(): + continue + + line_match = self._line_rgx.match(line) + description = None + if line_match: + description = line_match.group('desc') + if line_match.group('trailing') and description: + self._error_location( + 'Unexpected comma or period after function list at index %d of ' + 'line "%s"' % (line_match.end('trailing'), line), + error=False) + if not description and line.startswith(' '): + rest.append(line.strip()) + elif line_match: + funcs = [] + text = line_match.group('allfuncs') + while True: + if not text.strip(): + break + name, role, match_end = parse_item_name(text) + funcs.append((name, role)) + text = text[match_end:].strip() + if text and text[0] == ',': + text = text[1:].strip() + rest = list(filter(None, [description])) + items.append((funcs, rest)) + else: + raise ParseError("%s is not a item name" % line) + return items + + def _parse_index(self, section, content): + """ + .. index: default + :refguide: something, else, and more + + """ + def strip_each_in(lst): + return [s.strip() for s in lst] + + out = {} + section = section.split('::') + if len(section) > 1: + out['default'] = strip_each_in(section[1].split(','))[0] + for line in content: + line = line.split(':') + if len(line) > 2: + out[line[1]] = strip_each_in(line[2].split(',')) + return out + + def _parse_summary(self): + """Grab signature (if given) and summary""" + if self._is_at_section(): + return + + # If several signatures present, take the last one + while True: + summary = self._doc.read_to_next_empty_line() + summary_str = " ".join([s.strip() for s in summary]).strip() + compiled = re.compile(r'^([\w., ]+=)?\s*[\w\.]+\(.*\)$') + if compiled.match(summary_str): + self['Signature'] = summary_str + if not self._is_at_section(): + continue + break + + if summary is not None: + self['Summary'] = summary + + if not self._is_at_section(): + self['Extended Summary'] = self._read_to_next_section() + + def _parse(self): + self._doc.reset() + self._parse_summary() + + sections = list(self._read_sections()) + section_names = set([section for section, content in sections]) + + has_returns = 'Returns' in section_names + has_yields = 'Yields' in section_names + # We could do more tests, but we are not. Arbitrarily. + if has_returns and has_yields: + msg = 'Docstring contains both a Returns and Yields section.' + raise ValueError(msg) + if not has_yields and 'Receives' in section_names: + msg = 'Docstring contains a Receives section but not Yields.' + raise ValueError(msg) + + for (section, content) in sections: + if not section.startswith('..'): + section = (s.capitalize() for s in section.split(' ')) + section = ' '.join(section) + if self.get(section): + self._error_location("The section %s appears twice" + % section) + + if section in ('Parameters', 'Other Parameters', 'Attributes', + 'Methods'): + self[section] = self._parse_param_list(content) + elif section in ('Returns', 'Yields', 'Raises', 'Warns', 'Receives'): + self[section] = self._parse_param_list( + content, single_element_is_type=True) + elif section.startswith('.. index::'): + self['index'] = self._parse_index(section, content) + elif section == 'See Also': + self['See Also'] = self._parse_see_also(content) + else: + self[section] = content + + def _error_location(self, msg, error=True): + if hasattr(self, '_obj'): + # we know where the docs came from: + try: + filename = inspect.getsourcefile(self._obj) + except TypeError: + filename = None + msg = msg + (" in the docstring of %s in %s." + % (self._obj, filename)) + if error: + raise ValueError(msg) + else: + warn(msg) + + # string conversion routines + + def _str_header(self, name, symbol='-'): + return [name, len(name)*symbol] + + def _str_indent(self, doc, indent=4): + out = [] + for line in doc: + out += [' '*indent + line] + return out + + def _str_signature(self): + if self['Signature']: + return [self['Signature'].replace('*', r'\*')] + [''] + else: + return [''] + + def _str_summary(self): + if self['Summary']: + return self['Summary'] + [''] + else: + return [] + + def _str_extended_summary(self): + if self['Extended Summary']: + return self['Extended Summary'] + [''] + else: + return [] + + def _str_param_list(self, name): + out = [] + if self[name]: + out += self._str_header(name) + for param in self[name]: + parts = [] + if param.name: + parts.append(param.name) + if param.type: + parts.append(param.type) + out += [' : '.join(parts)] + if param.desc and ''.join(param.desc).strip(): + out += self._str_indent(param.desc) + out += [''] + return out + + def _str_section(self, name): + out = [] + if self[name]: + out += self._str_header(name) + out += self[name] + out += [''] + return out + + def _str_see_also(self, func_role): + if not self['See Also']: + return [] + out = [] + out += self._str_header("See Also") + out += [''] + last_had_desc = True + for funcs, desc in self['See Also']: + assert isinstance(funcs, list) + links = [] + for func, role in funcs: + if role: + link = ':%s:`%s`' % (role, func) + elif func_role: + link = ':%s:`%s`' % (func_role, func) + else: + link = "`%s`_" % func + links.append(link) + link = ', '.join(links) + out += [link] + if desc: + out += self._str_indent([' '.join(desc)]) + last_had_desc = True + else: + last_had_desc = False + out += self._str_indent([self.empty_description]) + + if last_had_desc: + out += [''] + out += [''] + return out + + def _str_index(self): + idx = self['index'] + out = [] + output_index = False + default_index = idx.get('default', '') + if default_index: + output_index = True + out += ['.. index:: %s' % default_index] + for section, references in idx.items(): + if section == 'default': + continue + output_index = True + out += [' :%s: %s' % (section, ', '.join(references))] + if output_index: + return out + else: + return '' + + def __str__(self, func_role=''): + out = [] + out += self._str_signature() + out += self._str_summary() + out += self._str_extended_summary() + for param_list in ('Parameters', 'Returns', 'Yields', 'Receives', + 'Other Parameters', 'Raises', 'Warns'): + out += self._str_param_list(param_list) + out += self._str_section('Warnings') + out += self._str_see_also(func_role) + for s in ('Notes', 'References', 'Examples'): + out += self._str_section(s) + for param_list in ('Attributes', 'Methods'): + out += self._str_param_list(param_list) + out += self._str_index() + return '\n'.join(out) + + +def indent(str, indent=4): + indent_str = ' '*indent + if str is None: + return indent_str + lines = str.split('\n') + return '\n'.join(indent_str + l for l in lines) + + +def dedent_lines(lines): + """Deindent a list of lines maximally""" + return textwrap.dedent("\n".join(lines)).split("\n") + + +def header(text, style='-'): + return text + '\n' + style*len(text) + '\n' + + +class FunctionDoc(NumpyDocString): + def __init__(self, func, role='func', doc=None, config={}): + self._f = func + self._role = role # e.g. "func" or "meth" + + if doc is None: + if func is None: + raise ValueError("No function or docstring given") + doc = inspect.getdoc(func) or '' + NumpyDocString.__init__(self, doc, config) + + if not self['Signature'] and func is not None: + func, func_name = self.get_func() + try: + try: + signature = str(inspect.signature(func)) + except (AttributeError, ValueError): + # try to read signature, backward compat for older Python + if sys.version_info[0] >= 3: + argspec = inspect.getfullargspec(func) + else: + argspec = inspect.getargspec(func) + signature = inspect.formatargspec(*argspec) + signature = '%s%s' % (func_name, signature) + except TypeError: + signature = '%s()' % func_name + self['Signature'] = signature + + def get_func(self): + func_name = getattr(self._f, '__name__', self.__class__.__name__) + if inspect.isclass(self._f): + func = getattr(self._f, '__call__', self._f.__init__) + else: + func = self._f + return func, func_name + + def __str__(self): + out = '' + + func, func_name = self.get_func() + + roles = {'func': 'function', + 'meth': 'method'} + + if self._role: + if self._role not in roles: + print("Warning: invalid role %s" % self._role) + out += '.. %s:: %s\n \n\n' % (roles.get(self._role, ''), + func_name) + + out += super(FunctionDoc, self).__str__(func_role=self._role) + return out + + +class ClassDoc(NumpyDocString): + + extra_public_methods = ['__call__'] + + def __init__(self, cls, doc=None, modulename='', func_doc=FunctionDoc, + config={}): + if not inspect.isclass(cls) and cls is not None: + raise ValueError("Expected a class or None, but got %r" % cls) + self._cls = cls + + if 'sphinx' in sys.modules: + from sphinx.ext.autodoc import ALL + else: + ALL = object() + + self.show_inherited_members = config.get( + 'show_inherited_class_members', True) + + if modulename and not modulename.endswith('.'): + modulename += '.' + self._mod = modulename + + if doc is None: + if cls is None: + raise ValueError("No class or documentation string given") + doc = pydoc.getdoc(cls) + + NumpyDocString.__init__(self, doc) + + _members = config.get('members', []) + if _members is ALL: + _members = None + _exclude = config.get('exclude-members', []) + + if config.get('show_class_members', True) and _exclude is not ALL: + def splitlines_x(s): + if not s: + return [] + else: + return s.splitlines() + for field, items in [('Methods', self.methods), + ('Attributes', self.properties)]: + if not self[field]: + doc_list = [] + for name in sorted(items): + if (name in _exclude or + (_members and name not in _members)): + continue + try: + doc_item = pydoc.getdoc(getattr(self._cls, name)) + doc_list.append( + Parameter(name, '', splitlines_x(doc_item))) + except AttributeError: + pass # method doesn't exist + self[field] = doc_list + + @property + def methods(self): + if self._cls is None: + return [] + return [name for name, func in inspect.getmembers(self._cls) + if ((not name.startswith('_') + or name in self.extra_public_methods) + and isinstance(func, Callable) + and self._is_show_member(name))] + + @property + def properties(self): + if self._cls is None: + return [] + return [name for name, func in inspect.getmembers(self._cls) + if (not name.startswith('_') and + (func is None or isinstance(func, property) or + inspect.isdatadescriptor(func)) + and self._is_show_member(name))] + + def _is_show_member(self, name): + if self.show_inherited_members: + return True # show all class members + if name not in self._cls.__dict__: + return False # class member is inherited, we do not show it + return True \ No newline at end of file diff --git a/grplot_seaborn/external/husl.py b/grplot_seaborn/external/husl.py new file mode 100644 index 0000000..5ba2d2c --- /dev/null +++ b/grplot_seaborn/external/husl.py @@ -0,0 +1,313 @@ +import operator +import math + +__version__ = "2.1.0" + + +m = [ + [3.2406, -1.5372, -0.4986], + [-0.9689, 1.8758, 0.0415], + [0.0557, -0.2040, 1.0570] +] + +m_inv = [ + [0.4124, 0.3576, 0.1805], + [0.2126, 0.7152, 0.0722], + [0.0193, 0.1192, 0.9505] +] + +# Hard-coded D65 illuminant +refX = 0.95047 +refY = 1.00000 +refZ = 1.08883 +refU = 0.19784 +refV = 0.46834 +lab_e = 0.008856 +lab_k = 903.3 + + +# Public API + +def husl_to_rgb(h, s, l): + return lch_to_rgb(*husl_to_lch([h, s, l])) + + +def husl_to_hex(h, s, l): + return rgb_to_hex(husl_to_rgb(h, s, l)) + + +def rgb_to_husl(r, g, b): + return lch_to_husl(rgb_to_lch(r, g, b)) + + +def hex_to_husl(hex): + return rgb_to_husl(*hex_to_rgb(hex)) + + +def huslp_to_rgb(h, s, l): + return lch_to_rgb(*huslp_to_lch([h, s, l])) + + +def huslp_to_hex(h, s, l): + return rgb_to_hex(huslp_to_rgb(h, s, l)) + + +def rgb_to_huslp(r, g, b): + return lch_to_huslp(rgb_to_lch(r, g, b)) + + +def hex_to_huslp(hex): + return rgb_to_huslp(*hex_to_rgb(hex)) + + +def lch_to_rgb(l, c, h): + return xyz_to_rgb(luv_to_xyz(lch_to_luv([l, c, h]))) + + +def rgb_to_lch(r, g, b): + return luv_to_lch(xyz_to_luv(rgb_to_xyz([r, g, b]))) + + +def max_chroma(L, H): + hrad = math.radians(H) + sinH = (math.sin(hrad)) + cosH = (math.cos(hrad)) + sub1 = (math.pow(L + 16, 3.0) / 1560896.0) + sub2 = sub1 if sub1 > 0.008856 else (L / 903.3) + result = float("inf") + for row in m: + m1 = row[0] + m2 = row[1] + m3 = row[2] + top = ((0.99915 * m1 + 1.05122 * m2 + 1.14460 * m3) * sub2) + rbottom = (0.86330 * m3 - 0.17266 * m2) + lbottom = (0.12949 * m3 - 0.38848 * m1) + bottom = (rbottom * sinH + lbottom * cosH) * sub2 + + for t in (0.0, 1.0): + C = (L * (top - 1.05122 * t) / (bottom + 0.17266 * sinH * t)) + if C > 0.0 and C < result: + result = C + return result + + +def _hrad_extremum(L): + lhs = (math.pow(L, 3.0) + 48.0 * math.pow(L, 2.0) + 768.0 * L + 4096.0) / 1560896.0 + rhs = 1107.0 / 125000.0 + sub = lhs if lhs > rhs else 10.0 * L / 9033.0 + chroma = float("inf") + result = None + for row in m: + for limit in (0.0, 1.0): + [m1, m2, m3] = row + top = -3015466475.0 * m3 * sub + 603093295.0 * m2 * sub - 603093295.0 * limit + bottom = 1356959916.0 * m1 * sub - 452319972.0 * m3 * sub + hrad = math.atan2(top, bottom) + # This is a math hack to deal with tan quadrants, I'm too lazy to figure + # out how to do this properly + if limit == 0.0: + hrad += math.pi + test = max_chroma(L, math.degrees(hrad)) + if test < chroma: + chroma = test + result = hrad + return result + + +def max_chroma_pastel(L): + H = math.degrees(_hrad_extremum(L)) + return max_chroma(L, H) + + +def dot_product(a, b): + return sum(map(operator.mul, a, b)) + + +def f(t): + if t > lab_e: + return (math.pow(t, 1.0 / 3.0)) + else: + return (7.787 * t + 16.0 / 116.0) + + +def f_inv(t): + if math.pow(t, 3.0) > lab_e: + return (math.pow(t, 3.0)) + else: + return (116.0 * t - 16.0) / lab_k + + +def from_linear(c): + if c <= 0.0031308: + return 12.92 * c + else: + return (1.055 * math.pow(c, 1.0 / 2.4) - 0.055) + + +def to_linear(c): + a = 0.055 + + if c > 0.04045: + return (math.pow((c + a) / (1.0 + a), 2.4)) + else: + return (c / 12.92) + + +def rgb_prepare(triple): + ret = [] + for ch in triple: + ch = round(ch, 3) + + if ch < -0.0001 or ch > 1.0001: + raise Exception("Illegal RGB value %f" % ch) + + if ch < 0: + ch = 0 + if ch > 1: + ch = 1 + + # Fix for Python 3 which by default rounds 4.5 down to 4.0 + # instead of Python 2 which is rounded to 5.0 which caused + # a couple off by one errors in the tests. Tests now all pass + # in Python 2 and Python 3 + ret.append(int(round(ch * 255 + 0.001, 0))) + + return ret + + +def hex_to_rgb(hex): + if hex.startswith('#'): + hex = hex[1:] + r = int(hex[0:2], 16) / 255.0 + g = int(hex[2:4], 16) / 255.0 + b = int(hex[4:6], 16) / 255.0 + return [r, g, b] + + +def rgb_to_hex(triple): + [r, g, b] = triple + return '#%02x%02x%02x' % tuple(rgb_prepare([r, g, b])) + + +def xyz_to_rgb(triple): + xyz = map(lambda row: dot_product(row, triple), m) + return list(map(from_linear, xyz)) + + +def rgb_to_xyz(triple): + rgbl = list(map(to_linear, triple)) + return list(map(lambda row: dot_product(row, rgbl), m_inv)) + + +def xyz_to_luv(triple): + X, Y, Z = triple + + if X == Y == Z == 0.0: + return [0.0, 0.0, 0.0] + + varU = (4.0 * X) / (X + (15.0 * Y) + (3.0 * Z)) + varV = (9.0 * Y) / (X + (15.0 * Y) + (3.0 * Z)) + L = 116.0 * f(Y / refY) - 16.0 + + # Black will create a divide-by-zero error + if L == 0.0: + return [0.0, 0.0, 0.0] + + U = 13.0 * L * (varU - refU) + V = 13.0 * L * (varV - refV) + + return [L, U, V] + + +def luv_to_xyz(triple): + L, U, V = triple + + if L == 0: + return [0.0, 0.0, 0.0] + + varY = f_inv((L + 16.0) / 116.0) + varU = U / (13.0 * L) + refU + varV = V / (13.0 * L) + refV + Y = varY * refY + X = 0.0 - (9.0 * Y * varU) / ((varU - 4.0) * varV - varU * varV) + Z = (9.0 * Y - (15.0 * varV * Y) - (varV * X)) / (3.0 * varV) + + return [X, Y, Z] + + +def luv_to_lch(triple): + L, U, V = triple + + C = (math.pow(math.pow(U, 2) + math.pow(V, 2), (1.0 / 2.0))) + hrad = (math.atan2(V, U)) + H = math.degrees(hrad) + if H < 0.0: + H = 360.0 + H + + return [L, C, H] + + +def lch_to_luv(triple): + L, C, H = triple + + Hrad = math.radians(H) + U = (math.cos(Hrad) * C) + V = (math.sin(Hrad) * C) + + return [L, U, V] + + +def husl_to_lch(triple): + H, S, L = triple + + if L > 99.9999999: + return [100, 0.0, H] + if L < 0.00000001: + return [0.0, 0.0, H] + + mx = max_chroma(L, H) + C = mx / 100.0 * S + + return [L, C, H] + + +def lch_to_husl(triple): + L, C, H = triple + + if L > 99.9999999: + return [H, 0.0, 100.0] + if L < 0.00000001: + return [H, 0.0, 0.0] + + mx = max_chroma(L, H) + S = C / mx * 100.0 + + return [H, S, L] + + +def huslp_to_lch(triple): + H, S, L = triple + + if L > 99.9999999: + return [100, 0.0, H] + if L < 0.00000001: + return [0.0, 0.0, H] + + mx = max_chroma_pastel(L) + C = mx / 100.0 * S + + return [L, C, H] + + +def lch_to_huslp(triple): + L, C, H = triple + + if L > 99.9999999: + return [H, 0.0, 100.0] + if L < 0.00000001: + return [H, 0.0, 0.0] + + mx = max_chroma_pastel(L) + S = C / mx * 100.0 + + return [H, S, L] diff --git a/grplot_seaborn/external/six.py b/grplot_seaborn/external/six.py new file mode 100644 index 0000000..c374474 --- /dev/null +++ b/grplot_seaborn/external/six.py @@ -0,0 +1,869 @@ +"""Utilities for writing code that runs on Python 2 and 3""" + +# Copyright (c) 2010-2015 Benjamin Peterson +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +from __future__ import absolute_import + +import functools +import itertools +import operator +import sys +import types + +__author__ = "Benjamin Peterson " +__version__ = "1.10.0" + + +# Useful for very coarse version differentiation. +PY2 = sys.version_info[0] == 2 +PY3 = sys.version_info[0] == 3 +PY34 = sys.version_info[0:2] >= (3, 4) + +if PY3: + string_types = str, + integer_types = int, + class_types = type, + text_type = str + binary_type = bytes + + MAXSIZE = sys.maxsize +else: + string_types = basestring, + integer_types = (int, long) + class_types = (type, types.ClassType) + text_type = unicode + binary_type = str + + if sys.platform.startswith("java"): + # Jython always uses 32 bits. + MAXSIZE = int((1 << 31) - 1) + else: + # It's possible to have sizeof(long) != sizeof(Py_ssize_t). + class X(object): + + def __len__(self): + return 1 << 31 + try: + len(X()) + except OverflowError: + # 32-bit + MAXSIZE = int((1 << 31) - 1) + else: + # 64-bit + MAXSIZE = int((1 << 63) - 1) + del X + + +def _add_doc(func, doc): + """Add documentation to a function.""" + func.__doc__ = doc + + +def _import_module(name): + """Import module, returning the module after the last dot.""" + __import__(name) + return sys.modules[name] + + +class _LazyDescr(object): + + def __init__(self, name): + self.name = name + + def __get__(self, obj, tp): + result = self._resolve() + setattr(obj, self.name, result) # Invokes __set__. + try: + # This is a bit ugly, but it avoids running this again by + # removing this descriptor. + delattr(obj.__class__, self.name) + except AttributeError: + pass + return result + + +class MovedModule(_LazyDescr): + + def __init__(self, name, old, new=None): + super(MovedModule, self).__init__(name) + if PY3: + if new is None: + new = name + self.mod = new + else: + self.mod = old + + def _resolve(self): + return _import_module(self.mod) + + def __getattr__(self, attr): + _module = self._resolve() + value = getattr(_module, attr) + setattr(self, attr, value) + return value + + +class _LazyModule(types.ModuleType): + + def __init__(self, name): + super(_LazyModule, self).__init__(name) + self.__doc__ = self.__class__.__doc__ + + def __dir__(self): + attrs = ["__doc__", "__name__"] + attrs += [attr.name for attr in self._moved_attributes] + return attrs + + # Subclasses should override this + _moved_attributes = [] + + +class MovedAttribute(_LazyDescr): + + def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None): + super(MovedAttribute, self).__init__(name) + if PY3: + if new_mod is None: + new_mod = name + self.mod = new_mod + if new_attr is None: + if old_attr is None: + new_attr = name + else: + new_attr = old_attr + self.attr = new_attr + else: + self.mod = old_mod + if old_attr is None: + old_attr = name + self.attr = old_attr + + def _resolve(self): + module = _import_module(self.mod) + return getattr(module, self.attr) + + +class _SixMetaPathImporter(object): + + """ + A meta path importer to import six.moves and its submodules. + + This class implements a PEP302 finder and loader. It should be compatible + with Python 2.5 and all existing versions of Python3 + """ + + def __init__(self, six_module_name): + self.name = six_module_name + self.known_modules = {} + + def _add_module(self, mod, *fullnames): + for fullname in fullnames: + self.known_modules[self.name + "." + fullname] = mod + + def _get_module(self, fullname): + return self.known_modules[self.name + "." + fullname] + + def find_module(self, fullname, path=None): + if fullname in self.known_modules: + return self + return None + + def __get_module(self, fullname): + try: + return self.known_modules[fullname] + except KeyError: + raise ImportError("This loader does not know module " + fullname) + + def load_module(self, fullname): + try: + # in case of a reload + return sys.modules[fullname] + except KeyError: + pass + mod = self.__get_module(fullname) + if isinstance(mod, MovedModule): + mod = mod._resolve() + else: + mod.__loader__ = self + sys.modules[fullname] = mod + return mod + + def is_package(self, fullname): + """ + Return true, if the named module is a package. + + We need this method to get correct spec objects with + Python 3.4 (see PEP451) + """ + return hasattr(self.__get_module(fullname), "__path__") + + def get_code(self, fullname): + """Return None + + Required, if is_package is implemented""" + self.__get_module(fullname) # eventually raises ImportError + return None + get_source = get_code # same as get_code + +_importer = _SixMetaPathImporter(__name__) + + +class _MovedItems(_LazyModule): + + """Lazy loading of moved objects""" + __path__ = [] # mark as package + + +_moved_attributes = [ + MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"), + MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"), + MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"), + MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"), + MovedAttribute("intern", "__builtin__", "sys"), + MovedAttribute("map", "itertools", "builtins", "imap", "map"), + MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"), + MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"), + MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"), + MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"), + MovedAttribute("reduce", "__builtin__", "functools"), + MovedAttribute("shlex_quote", "pipes", "shlex", "quote"), + MovedAttribute("StringIO", "StringIO", "io"), + MovedAttribute("UserDict", "UserDict", "collections"), + MovedAttribute("UserList", "UserList", "collections"), + MovedAttribute("UserString", "UserString", "collections"), + MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"), + MovedAttribute("zip", "itertools", "builtins", "izip", "zip"), + MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"), + MovedModule("builtins", "__builtin__"), + MovedModule("configparser", "ConfigParser"), + MovedModule("copyreg", "copy_reg"), + MovedModule("dbm_gnu", "gdbm", "dbm.gnu"), + MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"), + MovedModule("http_cookiejar", "cookielib", "http.cookiejar"), + MovedModule("http_cookies", "Cookie", "http.cookies"), + MovedModule("html_entities", "htmlentitydefs", "html.entities"), + MovedModule("html_parser", "HTMLParser", "html.parser"), + MovedModule("http_client", "httplib", "http.client"), + MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"), + MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"), + MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"), + MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"), + MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"), + MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"), + MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"), + MovedModule("cPickle", "cPickle", "pickle"), + MovedModule("queue", "Queue"), + MovedModule("reprlib", "repr"), + MovedModule("socketserver", "SocketServer"), + MovedModule("_thread", "thread", "_thread"), + MovedModule("tkinter", "Tkinter"), + MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"), + MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"), + MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"), + MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"), + MovedModule("tkinter_tix", "Tix", "tkinter.tix"), + MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"), + MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"), + MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"), + MovedModule("tkinter_colorchooser", "tkColorChooser", + "tkinter.colorchooser"), + MovedModule("tkinter_commondialog", "tkCommonDialog", + "tkinter.commondialog"), + MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"), + MovedModule("tkinter_font", "tkFont", "tkinter.font"), + MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"), + MovedModule("tkinter_tksimpledialog", "tkSimpleDialog", + "tkinter.simpledialog"), + MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"), + MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"), + MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"), + MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"), + MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"), + MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"), +] +# Add windows specific modules. +if sys.platform == "win32": + _moved_attributes += [ + MovedModule("winreg", "_winreg"), + ] + +for attr in _moved_attributes: + setattr(_MovedItems, attr.name, attr) + if isinstance(attr, MovedModule): + _importer._add_module(attr, "moves." + attr.name) +del attr + +_MovedItems._moved_attributes = _moved_attributes + +moves = _MovedItems(__name__ + ".moves") +_importer._add_module(moves, "moves") + + +class Module_six_moves_urllib_parse(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_parse""" + + +_urllib_parse_moved_attributes = [ + MovedAttribute("ParseResult", "urlparse", "urllib.parse"), + MovedAttribute("SplitResult", "urlparse", "urllib.parse"), + MovedAttribute("parse_qs", "urlparse", "urllib.parse"), + MovedAttribute("parse_qsl", "urlparse", "urllib.parse"), + MovedAttribute("urldefrag", "urlparse", "urllib.parse"), + MovedAttribute("urljoin", "urlparse", "urllib.parse"), + MovedAttribute("urlparse", "urlparse", "urllib.parse"), + MovedAttribute("urlsplit", "urlparse", "urllib.parse"), + MovedAttribute("urlunparse", "urlparse", "urllib.parse"), + MovedAttribute("urlunsplit", "urlparse", "urllib.parse"), + MovedAttribute("quote", "urllib", "urllib.parse"), + MovedAttribute("quote_plus", "urllib", "urllib.parse"), + MovedAttribute("unquote", "urllib", "urllib.parse"), + MovedAttribute("unquote_plus", "urllib", "urllib.parse"), + MovedAttribute("urlencode", "urllib", "urllib.parse"), + MovedAttribute("splitquery", "urllib", "urllib.parse"), + MovedAttribute("splittag", "urllib", "urllib.parse"), + MovedAttribute("splituser", "urllib", "urllib.parse"), + MovedAttribute("uses_fragment", "urlparse", "urllib.parse"), + MovedAttribute("uses_netloc", "urlparse", "urllib.parse"), + MovedAttribute("uses_params", "urlparse", "urllib.parse"), + MovedAttribute("uses_query", "urlparse", "urllib.parse"), + MovedAttribute("uses_relative", "urlparse", "urllib.parse"), +] +for attr in _urllib_parse_moved_attributes: + setattr(Module_six_moves_urllib_parse, attr.name, attr) +del attr + +Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes + +_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"), + "moves.urllib_parse", "moves.urllib.parse") + + +class Module_six_moves_urllib_error(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_error""" + + +_urllib_error_moved_attributes = [ + MovedAttribute("URLError", "urllib2", "urllib.error"), + MovedAttribute("HTTPError", "urllib2", "urllib.error"), + MovedAttribute("ContentTooShortError", "urllib", "urllib.error"), +] +for attr in _urllib_error_moved_attributes: + setattr(Module_six_moves_urllib_error, attr.name, attr) +del attr + +Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes + +_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"), + "moves.urllib_error", "moves.urllib.error") + + +class Module_six_moves_urllib_request(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_request""" + + +_urllib_request_moved_attributes = [ + MovedAttribute("urlopen", "urllib2", "urllib.request"), + MovedAttribute("install_opener", "urllib2", "urllib.request"), + MovedAttribute("build_opener", "urllib2", "urllib.request"), + MovedAttribute("pathname2url", "urllib", "urllib.request"), + MovedAttribute("url2pathname", "urllib", "urllib.request"), + MovedAttribute("getproxies", "urllib", "urllib.request"), + MovedAttribute("Request", "urllib2", "urllib.request"), + MovedAttribute("OpenerDirector", "urllib2", "urllib.request"), + MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"), + MovedAttribute("ProxyHandler", "urllib2", "urllib.request"), + MovedAttribute("BaseHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"), + MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"), + MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"), + MovedAttribute("FileHandler", "urllib2", "urllib.request"), + MovedAttribute("FTPHandler", "urllib2", "urllib.request"), + MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"), + MovedAttribute("UnknownHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"), + MovedAttribute("urlretrieve", "urllib", "urllib.request"), + MovedAttribute("urlcleanup", "urllib", "urllib.request"), + MovedAttribute("URLopener", "urllib", "urllib.request"), + MovedAttribute("FancyURLopener", "urllib", "urllib.request"), + MovedAttribute("proxy_bypass", "urllib", "urllib.request"), +] +for attr in _urllib_request_moved_attributes: + setattr(Module_six_moves_urllib_request, attr.name, attr) +del attr + +Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes + +_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"), + "moves.urllib_request", "moves.urllib.request") + + +class Module_six_moves_urllib_response(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_response""" + + +_urllib_response_moved_attributes = [ + MovedAttribute("addbase", "urllib", "urllib.response"), + MovedAttribute("addclosehook", "urllib", "urllib.response"), + MovedAttribute("addinfo", "urllib", "urllib.response"), + MovedAttribute("addinfourl", "urllib", "urllib.response"), +] +for attr in _urllib_response_moved_attributes: + setattr(Module_six_moves_urllib_response, attr.name, attr) +del attr + +Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes + +_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"), + "moves.urllib_response", "moves.urllib.response") + + +class Module_six_moves_urllib_robotparser(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_robotparser""" + + +_urllib_robotparser_moved_attributes = [ + MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"), +] +for attr in _urllib_robotparser_moved_attributes: + setattr(Module_six_moves_urllib_robotparser, attr.name, attr) +del attr + +Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes + +_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"), + "moves.urllib_robotparser", "moves.urllib.robotparser") + + +class Module_six_moves_urllib(types.ModuleType): + + """Create a six.moves.urllib namespace that resembles the Python 3 namespace""" + __path__ = [] # mark as package + parse = _importer._get_module("moves.urllib_parse") + error = _importer._get_module("moves.urllib_error") + request = _importer._get_module("moves.urllib_request") + response = _importer._get_module("moves.urllib_response") + robotparser = _importer._get_module("moves.urllib_robotparser") + + def __dir__(self): + return ['parse', 'error', 'request', 'response', 'robotparser'] + +_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"), + "moves.urllib") + + +def add_move(move): + """Add an item to six.moves.""" + setattr(_MovedItems, move.name, move) + + +def remove_move(name): + """Remove item from six.moves.""" + try: + delattr(_MovedItems, name) + except AttributeError: + try: + del moves.__dict__[name] + except KeyError: + raise AttributeError("no such move, %r" % (name,)) + + +if PY3: + _meth_func = "__func__" + _meth_self = "__self__" + + _func_closure = "__closure__" + _func_code = "__code__" + _func_defaults = "__defaults__" + _func_globals = "__globals__" +else: + _meth_func = "im_func" + _meth_self = "im_self" + + _func_closure = "func_closure" + _func_code = "func_code" + _func_defaults = "func_defaults" + _func_globals = "func_globals" + + +try: + advance_iterator = next +except NameError: + def advance_iterator(it): + return it.next() +next = advance_iterator + + +try: + callable = callable +except NameError: + def callable(obj): + return any("__call__" in klass.__dict__ for klass in type(obj).__mro__) + + +if PY3: + def get_unbound_function(unbound): + return unbound + + create_bound_method = types.MethodType + + def create_unbound_method(func, cls): + return func + + Iterator = object +else: + def get_unbound_function(unbound): + return unbound.im_func + + def create_bound_method(func, obj): + return types.MethodType(func, obj, obj.__class__) + + def create_unbound_method(func, cls): + return types.MethodType(func, None, cls) + + class Iterator(object): + + def next(self): + return type(self).__next__(self) + + callable = callable +_add_doc(get_unbound_function, + """Get the function out of a possibly unbound function""") + + +get_method_function = operator.attrgetter(_meth_func) +get_method_self = operator.attrgetter(_meth_self) +get_function_closure = operator.attrgetter(_func_closure) +get_function_code = operator.attrgetter(_func_code) +get_function_defaults = operator.attrgetter(_func_defaults) +get_function_globals = operator.attrgetter(_func_globals) + + +if PY3: + def iterkeys(d, **kw): + return iter(d.keys(**kw)) + + def itervalues(d, **kw): + return iter(d.values(**kw)) + + def iteritems(d, **kw): + return iter(d.items(**kw)) + + def iterlists(d, **kw): + return iter(d.lists(**kw)) + + viewkeys = operator.methodcaller("keys") + + viewvalues = operator.methodcaller("values") + + viewitems = operator.methodcaller("items") +else: + def iterkeys(d, **kw): + return d.iterkeys(**kw) + + def itervalues(d, **kw): + return d.itervalues(**kw) + + def iteritems(d, **kw): + return d.iteritems(**kw) + + def iterlists(d, **kw): + return d.iterlists(**kw) + + viewkeys = operator.methodcaller("viewkeys") + + viewvalues = operator.methodcaller("viewvalues") + + viewitems = operator.methodcaller("viewitems") + +_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.") +_add_doc(itervalues, "Return an iterator over the values of a dictionary.") +_add_doc(iteritems, + "Return an iterator over the (key, value) pairs of a dictionary.") +_add_doc(iterlists, + "Return an iterator over the (key, [values]) pairs of a dictionary.") + + +if PY3: + def b(s): + return s.encode("latin-1") + + def u(s): + return s + unichr = chr + import struct + int2byte = struct.Struct(">B").pack + del struct + byte2int = operator.itemgetter(0) + indexbytes = operator.getitem + iterbytes = iter + import io + StringIO = io.StringIO + BytesIO = io.BytesIO + _assertCountEqual = "assertCountEqual" + if sys.version_info[1] <= 1: + _assertRaisesRegex = "assertRaisesRegexp" + _assertRegex = "assertRegexpMatches" + else: + _assertRaisesRegex = "assertRaisesRegex" + _assertRegex = "assertRegex" +else: + def b(s): + return s + # Workaround for standalone backslash + + def u(s): + return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape") + unichr = unichr + int2byte = chr + + def byte2int(bs): + return ord(bs[0]) + + def indexbytes(buf, i): + return ord(buf[i]) + iterbytes = functools.partial(itertools.imap, ord) + import StringIO + StringIO = BytesIO = StringIO.StringIO + _assertCountEqual = "assertItemsEqual" + _assertRaisesRegex = "assertRaisesRegexp" + _assertRegex = "assertRegexpMatches" +_add_doc(b, """Byte literal""") +_add_doc(u, """Text literal""") + + +def assertCountEqual(self, *args, **kwargs): + return getattr(self, _assertCountEqual)(*args, **kwargs) + + +def assertRaisesRegex(self, *args, **kwargs): + return getattr(self, _assertRaisesRegex)(*args, **kwargs) + + +def assertRegex(self, *args, **kwargs): + return getattr(self, _assertRegex)(*args, **kwargs) + + +if PY3: + exec_ = getattr(moves.builtins, "exec") + + def reraise(tp, value, tb=None): + if value is None: + value = tp() + if value.__traceback__ is not tb: + raise value.with_traceback(tb) + raise value + +else: + def exec_(_code_, _globs_=None, _locs_=None): + """Execute code in a namespace.""" + if _globs_ is None: + frame = sys._getframe(1) + _globs_ = frame.f_globals + if _locs_ is None: + _locs_ = frame.f_locals + del frame + elif _locs_ is None: + _locs_ = _globs_ + exec("""exec _code_ in _globs_, _locs_""") + + exec_("""def reraise(tp, value, tb=None): + raise tp, value, tb +""") + + +if sys.version_info[:2] == (3, 2): + exec_("""def raise_from(value, from_value): + if from_value is None: + raise value + raise value from from_value +""") +elif sys.version_info[:2] > (3, 2): + exec_("""def raise_from(value, from_value): + raise value from from_value +""") +else: + def raise_from(value, from_value): + raise value + + +print_ = getattr(moves.builtins, "print", None) +if print_ is None: + def print_(*args, **kwargs): + """The new-style print function for Python 2.4 and 2.5.""" + fp = kwargs.pop("file", sys.stdout) + if fp is None: + return + + def write(data): + if not isinstance(data, basestring): + data = str(data) + # If the file has an encoding, encode unicode with it. + if (isinstance(fp, file) and + isinstance(data, unicode) and + fp.encoding is not None): + errors = getattr(fp, "errors", None) + if errors is None: + errors = "strict" + data = data.encode(fp.encoding, errors) + fp.write(data) + want_unicode = False + sep = kwargs.pop("sep", None) + if sep is not None: + if isinstance(sep, unicode): + want_unicode = True + elif not isinstance(sep, str): + raise TypeError("sep must be None or a string") + end = kwargs.pop("end", None) + if end is not None: + if isinstance(end, unicode): + want_unicode = True + elif not isinstance(end, str): + raise TypeError("end must be None or a string") + if kwargs: + raise TypeError("invalid keyword arguments to print()") + if not want_unicode: + for arg in args: + if isinstance(arg, unicode): + want_unicode = True + break + if want_unicode: + newline = unicode("\n") + space = unicode(" ") + else: + newline = "\n" + space = " " + if sep is None: + sep = space + if end is None: + end = newline + for i, arg in enumerate(args): + if i: + write(sep) + write(arg) + write(end) +if sys.version_info[:2] < (3, 3): + _print = print_ + + def print_(*args, **kwargs): + fp = kwargs.get("file", sys.stdout) + flush = kwargs.pop("flush", False) + _print(*args, **kwargs) + if flush and fp is not None: + fp.flush() + +_add_doc(reraise, """Reraise an exception.""") + +if sys.version_info[0:2] < (3, 4): + def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS, + updated=functools.WRAPPER_UPDATES): + def wrapper(f): + f = functools.wraps(wrapped, assigned, updated)(f) + f.__wrapped__ = wrapped + return f + return wrapper +else: + wraps = functools.wraps + + +def with_metaclass(meta, *bases): + """Create a base class with a metaclass.""" + # This requires a bit of explanation: the basic idea is to make a dummy + # metaclass for one level of class instantiation that replaces itself with + # the actual metaclass. + class metaclass(meta): + + def __new__(cls, name, this_bases, d): + return meta(name, bases, d) + return type.__new__(metaclass, 'temporary_class', (), {}) + + +def add_metaclass(metaclass): + """Class decorator for creating a class with a metaclass.""" + def wrapper(cls): + orig_vars = cls.__dict__.copy() + slots = orig_vars.get('__slots__') + if slots is not None: + if isinstance(slots, str): + slots = [slots] + for slots_var in slots: + orig_vars.pop(slots_var) + orig_vars.pop('__dict__', None) + orig_vars.pop('__weakref__', None) + return metaclass(cls.__name__, cls.__bases__, orig_vars) + return wrapper + + +def python_2_unicode_compatible(klass): + """ + A decorator that defines __unicode__ and __str__ methods under Python 2. + Under Python 3 it does nothing. + + To support Python 2 and 3 with a single code base, define a __str__ method + returning text and apply this decorator to the class. + """ + if PY2: + if '__str__' not in klass.__dict__: + raise ValueError("@python_2_unicode_compatible cannot be applied " + "to %s because it doesn't define __str__()." % + klass.__name__) + klass.__unicode__ = klass.__str__ + klass.__str__ = lambda self: self.__unicode__().encode('utf-8') + return klass + + +# Complete the moves implementation. +# This code is at the end of this module to speed up module loading. +# Turn this module into a package. +__path__ = [] # required for PEP 302 and PEP 451 +__package__ = __name__ # see PEP 366 @ReservedAssignment +if globals().get("__spec__") is not None: + __spec__.submodule_search_locations = [] # PEP 451 @UndefinedVariable +# Remove other six meta path importers, since they cause problems. This can +# happen if six is removed from sys.modules and then reloaded. (Setuptools does +# this for some reason.) +if sys.meta_path: + for i, importer in enumerate(sys.meta_path): + # Here's some real nastiness: Another "instance" of the six module might + # be floating around. Therefore, we can't use isinstance() to check for + # the six meta path importer, since the other six instance will have + # inserted an importer with different class. + if (type(importer).__name__ == "_SixMetaPathImporter" and + importer.name == __name__): + del sys.meta_path[i] + break + del i, importer +# Finally, add the importer to the meta path import hook. +sys.meta_path.append(_importer) + diff --git a/grplot_seaborn/linearmodels.py b/grplot_seaborn/linearmodels.py new file mode 100644 index 0000000..ad5e039 --- /dev/null +++ b/grplot_seaborn/linearmodels.py @@ -0,0 +1,7 @@ +import warnings +from .regression import * # noqa + +msg = ( + "The `linearmodels` module has been renamed `regression`." +) +warnings.warn(msg) diff --git a/grplot_seaborn/matrix.py b/grplot_seaborn/matrix.py new file mode 100644 index 0000000..d513d25 --- /dev/null +++ b/grplot_seaborn/matrix.py @@ -0,0 +1,1410 @@ +"""Functions to visualize matrices of data.""" +import warnings + +import matplotlib as mpl +from matplotlib.collections import LineCollection +import matplotlib.pyplot as plt +from matplotlib import gridspec +import numpy as np +import pandas as pd +from scipy.cluster import hierarchy + +from . import cm +from .axisgrid import Grid +from .utils import ( + despine, + axis_ticklabels_overlap, + relative_luminance, + to_utf8, + _draw_figure, +) +from ._decorators import _deprecate_positional_args + + +__all__ = ["heatmap", "clustermap"] + + +def _index_to_label(index): + """Convert a pandas index or multiindex to an axis label.""" + if isinstance(index, pd.MultiIndex): + return "-".join(map(to_utf8, index.names)) + else: + return index.name + + +def _index_to_ticklabels(index): + """Convert a pandas index or multiindex into ticklabels.""" + if isinstance(index, pd.MultiIndex): + return ["-".join(map(to_utf8, i)) for i in index.values] + else: + return index.values + + +def _convert_colors(colors): + """Convert either a list of colors or nested lists of colors to RGB.""" + to_rgb = mpl.colors.to_rgb + + try: + to_rgb(colors[0]) + # If this works, there is only one level of colors + return list(map(to_rgb, colors)) + except ValueError: + # If we get here, we have nested lists + return [list(map(to_rgb, l)) for l in colors] + + +def _matrix_mask(data, mask): + """Ensure that data and mask are compatible and add missing values. + + Values will be plotted for cells where ``mask`` is ``False``. + + ``data`` is expected to be a DataFrame; ``mask`` can be an array or + a DataFrame. + + """ + if mask is None: + mask = np.zeros(data.shape, bool) + + if isinstance(mask, np.ndarray): + # For array masks, ensure that shape matches data then convert + if mask.shape != data.shape: + raise ValueError("Mask must have the same shape as data.") + + mask = pd.DataFrame(mask, + index=data.index, + columns=data.columns, + dtype=bool) + + elif isinstance(mask, pd.DataFrame): + # For DataFrame masks, ensure that semantic labels match data + if not mask.index.equals(data.index) \ + and mask.columns.equals(data.columns): + err = "Mask must have the same index and columns as data." + raise ValueError(err) + + # Add any cells with missing data to the mask + # This works around an issue where `plt.pcolormesh` doesn't represent + # missing data properly + mask = mask | pd.isnull(data) + + return mask + + +class _HeatMapper: + """Draw a heatmap plot of a matrix with nice labels and colormaps.""" + + def __init__(self, data, vmin, vmax, cmap, center, robust, annot, fmt, + annot_kws, cbar, cbar_kws, + xticklabels=True, yticklabels=True, mask=None): + """Initialize the plotting object.""" + # We always want to have a DataFrame with semantic information + # and an ndarray to pass to matplotlib + if isinstance(data, pd.DataFrame): + plot_data = data.values + else: + plot_data = np.asarray(data) + data = pd.DataFrame(plot_data) + + # Validate the mask and convet to DataFrame + mask = _matrix_mask(data, mask) + + plot_data = np.ma.masked_where(np.asarray(mask), plot_data) + + # Get good names for the rows and columns + xtickevery = 1 + if isinstance(xticklabels, int): + xtickevery = xticklabels + xticklabels = _index_to_ticklabels(data.columns) + elif xticklabels is True: + xticklabels = _index_to_ticklabels(data.columns) + elif xticklabels is False: + xticklabels = [] + + ytickevery = 1 + if isinstance(yticklabels, int): + ytickevery = yticklabels + yticklabels = _index_to_ticklabels(data.index) + elif yticklabels is True: + yticklabels = _index_to_ticklabels(data.index) + elif yticklabels is False: + yticklabels = [] + + if not len(xticklabels): + self.xticks = [] + self.xticklabels = [] + elif isinstance(xticklabels, str) and xticklabels == "auto": + self.xticks = "auto" + self.xticklabels = _index_to_ticklabels(data.columns) + else: + self.xticks, self.xticklabels = self._skip_ticks(xticklabels, + xtickevery) + + if not len(yticklabels): + self.yticks = [] + self.yticklabels = [] + elif isinstance(yticklabels, str) and yticklabels == "auto": + self.yticks = "auto" + self.yticklabels = _index_to_ticklabels(data.index) + else: + self.yticks, self.yticklabels = self._skip_ticks(yticklabels, + ytickevery) + + # Get good names for the axis labels + xlabel = _index_to_label(data.columns) + ylabel = _index_to_label(data.index) + self.xlabel = xlabel if xlabel is not None else "" + self.ylabel = ylabel if ylabel is not None else "" + + # Determine good default values for the colormapping + self._determine_cmap_params(plot_data, vmin, vmax, + cmap, center, robust) + + # Sort out the annotations + if annot is None or annot is False: + annot = False + annot_data = None + else: + if isinstance(annot, bool): + annot_data = plot_data + else: + annot_data = np.asarray(annot) + if annot_data.shape != plot_data.shape: + err = "`data` and `annot` must have same shape." + raise ValueError(err) + annot = True + + # Save other attributes to the object + self.data = data + self.plot_data = plot_data + + self.annot = annot + self.annot_data = annot_data + + self.fmt = fmt + self.annot_kws = {} if annot_kws is None else annot_kws.copy() + self.cbar = cbar + self.cbar_kws = {} if cbar_kws is None else cbar_kws.copy() + + def _determine_cmap_params(self, plot_data, vmin, vmax, + cmap, center, robust): + """Use some heuristics to set good defaults for colorbar and range.""" + + # plot_data is a np.ma.array instance + calc_data = plot_data.astype(float).filled(np.nan) + if vmin is None: + if robust: + vmin = np.nanpercentile(calc_data, 2) + else: + vmin = np.nanmin(calc_data) + if vmax is None: + if robust: + vmax = np.nanpercentile(calc_data, 98) + else: + vmax = np.nanmax(calc_data) + self.vmin, self.vmax = vmin, vmax + + # Choose default colormaps if not provided + if cmap is None: + if center is None: + self.cmap = cm.rocket + else: + self.cmap = cm.icefire + elif isinstance(cmap, str): + self.cmap = mpl.cm.get_cmap(cmap) + elif isinstance(cmap, list): + self.cmap = mpl.colors.ListedColormap(cmap) + else: + self.cmap = cmap + + # Recenter a divergent colormap + if center is not None: + + # Copy bad values + # in mpl<3.2 only masked values are honored with "bad" color spec + # (see https://github.com/matplotlib/matplotlib/pull/14257) + bad = self.cmap(np.ma.masked_invalid([np.nan]))[0] + + # under/over values are set for sure when cmap extremes + # do not map to the same color as +-inf + under = self.cmap(-np.inf) + over = self.cmap(np.inf) + under_set = under != self.cmap(0) + over_set = over != self.cmap(self.cmap.N - 1) + + vrange = max(vmax - center, center - vmin) + normlize = mpl.colors.Normalize(center - vrange, center + vrange) + cmin, cmax = normlize([vmin, vmax]) + cc = np.linspace(cmin, cmax, 256) + self.cmap = mpl.colors.ListedColormap(self.cmap(cc)) + self.cmap.set_bad(bad) + if under_set: + self.cmap.set_under(under) + if over_set: + self.cmap.set_over(over) + + def _annotate_heatmap(self, ax, mesh): + """Add textual labels with the value in each cell.""" + mesh.update_scalarmappable() + height, width = self.annot_data.shape + xpos, ypos = np.meshgrid(np.arange(width) + .5, np.arange(height) + .5) + for x, y, m, color, val in zip(xpos.flat, ypos.flat, + mesh.get_array(), mesh.get_facecolors(), + self.annot_data.flat): + if m is not np.ma.masked: + lum = relative_luminance(color) + text_color = ".15" if lum > .408 else "w" + annotation = ("{:" + self.fmt + "}").format(val) + text_kwargs = dict(color=text_color, ha="center", va="center") + text_kwargs.update(self.annot_kws) + ax.text(x, y, annotation, **text_kwargs) + + def _skip_ticks(self, labels, tickevery): + """Return ticks and labels at evenly spaced intervals.""" + n = len(labels) + if tickevery == 0: + ticks, labels = [], [] + elif tickevery == 1: + ticks, labels = np.arange(n) + .5, labels + else: + start, end, step = 0, n, tickevery + ticks = np.arange(start, end, step) + .5 + labels = labels[start:end:step] + return ticks, labels + + def _auto_ticks(self, ax, labels, axis): + """Determine ticks and ticklabels that minimize overlap.""" + transform = ax.figure.dpi_scale_trans.inverted() + bbox = ax.get_window_extent().transformed(transform) + size = [bbox.width, bbox.height][axis] + axis = [ax.xaxis, ax.yaxis][axis] + tick, = axis.set_ticks([0]) + fontsize = tick.label1.get_size() + max_ticks = int(size // (fontsize / 72)) + if max_ticks < 1: + return [], [] + tick_every = len(labels) // max_ticks + 1 + tick_every = 1 if tick_every == 0 else tick_every + ticks, labels = self._skip_ticks(labels, tick_every) + return ticks, labels + + def plot(self, ax, cax, kws): + """Draw the heatmap on the provided Axes.""" + # Remove all the Axes spines + despine(ax=ax, left=True, bottom=True) + + # setting vmin/vmax in addition to norm is deprecated + # so avoid setting if norm is set + if "norm" not in kws: + kws.setdefault("vmin", self.vmin) + kws.setdefault("vmax", self.vmax) + + # Draw the heatmap + mesh = ax.pcolormesh(self.plot_data, cmap=self.cmap, **kws) + + # Set the axis limits + ax.set(xlim=(0, self.data.shape[1]), ylim=(0, self.data.shape[0])) + + # Invert the y axis to show the plot in matrix form + ax.invert_yaxis() + + # Possibly add a colorbar + if self.cbar: + cb = ax.figure.colorbar(mesh, cax, ax, **self.cbar_kws) + cb.outline.set_linewidth(0) + # If rasterized is passed to pcolormesh, also rasterize the + # colorbar to avoid white lines on the PDF rendering + if kws.get('rasterized', False): + cb.solids.set_rasterized(True) + + # Add row and column labels + if isinstance(self.xticks, str) and self.xticks == "auto": + xticks, xticklabels = self._auto_ticks(ax, self.xticklabels, 0) + else: + xticks, xticklabels = self.xticks, self.xticklabels + + if isinstance(self.yticks, str) and self.yticks == "auto": + yticks, yticklabels = self._auto_ticks(ax, self.yticklabels, 1) + else: + yticks, yticklabels = self.yticks, self.yticklabels + + ax.set(xticks=xticks, yticks=yticks) + xtl = ax.set_xticklabels(xticklabels) + ytl = ax.set_yticklabels(yticklabels, rotation="vertical") + plt.setp(ytl, va="center") # GH2484 + + # Possibly rotate them if they overlap + _draw_figure(ax.figure) + + if axis_ticklabels_overlap(xtl): + plt.setp(xtl, rotation="vertical") + if axis_ticklabels_overlap(ytl): + plt.setp(ytl, rotation="horizontal") + + # Add the axis labels + ax.set(xlabel=self.xlabel, ylabel=self.ylabel) + + # Annotate the cells with the formatted values + if self.annot: + self._annotate_heatmap(ax, mesh) + + +@_deprecate_positional_args +def heatmap( + data, *, + vmin=None, vmax=None, cmap=None, center=None, robust=False, + annot=None, fmt=".2g", annot_kws=None, + linewidths=0, linecolor="white", + cbar=True, cbar_kws=None, cbar_ax=None, + square=False, xticklabels="auto", yticklabels="auto", + mask=None, ax=None, + **kwargs +): + """Plot rectangular data as a color-encoded matrix. + + This is an Axes-level function and will draw the heatmap into the + currently-active Axes if none is provided to the ``ax`` argument. Part of + this Axes space will be taken and used to plot a colormap, unless ``cbar`` + is False or a separate Axes is provided to ``cbar_ax``. + + Parameters + ---------- + data : rectangular dataset + 2D dataset that can be coerced into an ndarray. If a Pandas DataFrame + is provided, the index/column information will be used to label the + columns and rows. + vmin, vmax : floats, optional + Values to anchor the colormap, otherwise they are inferred from the + data and other keyword arguments. + cmap : matplotlib colormap name or object, or list of colors, optional + The mapping from data values to color space. If not provided, the + default will depend on whether ``center`` is set. + center : float, optional + The value at which to center the colormap when plotting divergant data. + Using this parameter will change the default ``cmap`` if none is + specified. + robust : bool, optional + If True and ``vmin`` or ``vmax`` are absent, the colormap range is + computed with robust quantiles instead of the extreme values. + annot : bool or rectangular dataset, optional + If True, write the data value in each cell. If an array-like with the + same shape as ``data``, then use this to annotate the heatmap instead + of the data. Note that DataFrames will match on position, not index. + fmt : str, optional + String formatting code to use when adding annotations. + annot_kws : dict of key, value mappings, optional + Keyword arguments for :meth:`matplotlib.axes.Axes.text` when ``annot`` + is True. + linewidths : float, optional + Width of the lines that will divide each cell. + linecolor : color, optional + Color of the lines that will divide each cell. + cbar : bool, optional + Whether to draw a colorbar. + cbar_kws : dict of key, value mappings, optional + Keyword arguments for :meth:`matplotlib.figure.Figure.colorbar`. + cbar_ax : matplotlib Axes, optional + Axes in which to draw the colorbar, otherwise take space from the + main Axes. + square : bool, optional + If True, set the Axes aspect to "equal" so each cell will be + square-shaped. + xticklabels, yticklabels : "auto", bool, list-like, or int, optional + If True, plot the column names of the dataframe. If False, don't plot + the column names. If list-like, plot these alternate labels as the + xticklabels. If an integer, use the column names but plot only every + n label. If "auto", try to densely plot non-overlapping labels. + mask : bool array or DataFrame, optional + If passed, data will not be shown in cells where ``mask`` is True. + Cells with missing values are automatically masked. + ax : matplotlib Axes, optional + Axes in which to draw the plot, otherwise use the currently-active + Axes. + kwargs : other keyword arguments + All other keyword arguments are passed to + :meth:`matplotlib.axes.Axes.pcolormesh`. + + Returns + ------- + ax : matplotlib Axes + Axes object with the heatmap. + + See Also + -------- + clustermap : Plot a matrix using hierachical clustering to arrange the + rows and columns. + + Examples + -------- + + Plot a heatmap for a numpy array: + + .. plot:: + :context: close-figs + + >>> import numpy as np; np.random.seed(0) + >>> import grplot_seaborn as sns; sns.set_theme() + >>> uniform_data = np.random.rand(10, 12) + >>> ax = sns.heatmap(uniform_data) + + Change the limits of the colormap: + + .. plot:: + :context: close-figs + + >>> ax = sns.heatmap(uniform_data, vmin=0, vmax=1) + + Plot a heatmap for data centered on 0 with a diverging colormap: + + .. plot:: + :context: close-figs + + >>> normal_data = np.random.randn(10, 12) + >>> ax = sns.heatmap(normal_data, center=0) + + Plot a dataframe with meaningful row and column labels: + + .. plot:: + :context: close-figs + + >>> flights = sns.load_dataset("flights") + >>> flights = flights.pivot("month", "year", "passengers") + >>> ax = sns.heatmap(flights) + + Annotate each cell with the numeric value using integer formatting: + + .. plot:: + :context: close-figs + + >>> ax = sns.heatmap(flights, annot=True, fmt="d") + + Add lines between each cell: + + .. plot:: + :context: close-figs + + >>> ax = sns.heatmap(flights, linewidths=.5) + + Use a different colormap: + + .. plot:: + :context: close-figs + + >>> ax = sns.heatmap(flights, cmap="YlGnBu") + + Center the colormap at a specific value: + + .. plot:: + :context: close-figs + + >>> ax = sns.heatmap(flights, center=flights.loc["Jan", 1955]) + + Plot every other column label and don't plot row labels: + + .. plot:: + :context: close-figs + + >>> data = np.random.randn(50, 20) + >>> ax = sns.heatmap(data, xticklabels=2, yticklabels=False) + + Don't draw a colorbar: + + .. plot:: + :context: close-figs + + >>> ax = sns.heatmap(flights, cbar=False) + + Use different axes for the colorbar: + + .. plot:: + :context: close-figs + + >>> grid_kws = {"height_ratios": (.9, .05), "hspace": .3} + >>> f, (ax, cbar_ax) = plt.subplots(2, gridspec_kw=grid_kws) + >>> ax = sns.heatmap(flights, ax=ax, + ... cbar_ax=cbar_ax, + ... cbar_kws={"orientation": "horizontal"}) + + Use a mask to plot only part of a matrix + + .. plot:: + :context: close-figs + + >>> corr = np.corrcoef(np.random.randn(10, 200)) + >>> mask = np.zeros_like(corr) + >>> mask[np.triu_indices_from(mask)] = True + >>> with sns.axes_style("white"): + ... f, ax = plt.subplots(figsize=(7, 5)) + ... ax = sns.heatmap(corr, mask=mask, vmax=.3, square=True) + """ + # Initialize the plotter object + plotter = _HeatMapper(data, vmin, vmax, cmap, center, robust, annot, fmt, + annot_kws, cbar, cbar_kws, xticklabels, + yticklabels, mask) + + # Add the pcolormesh kwargs here + kwargs["linewidths"] = linewidths + kwargs["edgecolor"] = linecolor + + # Draw the plot and return the Axes + if ax is None: + ax = plt.gca() + if square: + ax.set_aspect("equal") + plotter.plot(ax, cbar_ax, kwargs) + return ax + + +class _DendrogramPlotter(object): + """Object for drawing tree of similarities between data rows/columns""" + + def __init__(self, data, linkage, metric, method, axis, label, rotate): + """Plot a dendrogram of the relationships between the columns of data + + Parameters + ---------- + data : pandas.DataFrame + Rectangular data + """ + self.axis = axis + if self.axis == 1: + data = data.T + + if isinstance(data, pd.DataFrame): + array = data.values + else: + array = np.asarray(data) + data = pd.DataFrame(array) + + self.array = array + self.data = data + + self.shape = self.data.shape + self.metric = metric + self.method = method + self.axis = axis + self.label = label + self.rotate = rotate + + if linkage is None: + self.linkage = self.calculated_linkage + else: + self.linkage = linkage + self.dendrogram = self.calculate_dendrogram() + + # Dendrogram ends are always at multiples of 5, who knows why + ticks = 10 * np.arange(self.data.shape[0]) + 5 + + if self.label: + ticklabels = _index_to_ticklabels(self.data.index) + ticklabels = [ticklabels[i] for i in self.reordered_ind] + if self.rotate: + self.xticks = [] + self.yticks = ticks + self.xticklabels = [] + + self.yticklabels = ticklabels + self.ylabel = _index_to_label(self.data.index) + self.xlabel = '' + else: + self.xticks = ticks + self.yticks = [] + self.xticklabels = ticklabels + self.yticklabels = [] + self.ylabel = '' + self.xlabel = _index_to_label(self.data.index) + else: + self.xticks, self.yticks = [], [] + self.yticklabels, self.xticklabels = [], [] + self.xlabel, self.ylabel = '', '' + + self.dependent_coord = self.dendrogram['dcoord'] + self.independent_coord = self.dendrogram['icoord'] + + def _calculate_linkage_scipy(self): + linkage = hierarchy.linkage(self.array, method=self.method, + metric=self.metric) + return linkage + + def _calculate_linkage_fastcluster(self): + import fastcluster + # Fastcluster has a memory-saving vectorized version, but only + # with certain linkage methods, and mostly with euclidean metric + # vector_methods = ('single', 'centroid', 'median', 'ward') + euclidean_methods = ('centroid', 'median', 'ward') + euclidean = self.metric == 'euclidean' and self.method in \ + euclidean_methods + if euclidean or self.method == 'single': + return fastcluster.linkage_vector(self.array, + method=self.method, + metric=self.metric) + else: + linkage = fastcluster.linkage(self.array, method=self.method, + metric=self.metric) + return linkage + + @property + def calculated_linkage(self): + + try: + return self._calculate_linkage_fastcluster() + except ImportError: + if np.product(self.shape) >= 10000: + msg = ("Clustering large matrix with scipy. Installing " + "`fastcluster` may give better performance.") + warnings.warn(msg) + + return self._calculate_linkage_scipy() + + def calculate_dendrogram(self): + """Calculates a dendrogram based on the linkage matrix + + Made a separate function, not a property because don't want to + recalculate the dendrogram every time it is accessed. + + Returns + ------- + dendrogram : dict + Dendrogram dictionary as returned by scipy.cluster.hierarchy + .dendrogram. The important key-value pairing is + "reordered_ind" which indicates the re-ordering of the matrix + """ + return hierarchy.dendrogram(self.linkage, no_plot=True, + color_threshold=-np.inf) + + @property + def reordered_ind(self): + """Indices of the matrix, reordered by the dendrogram""" + return self.dendrogram['leaves'] + + def plot(self, ax, tree_kws): + """Plots a dendrogram of the similarities between data on the axes + + Parameters + ---------- + ax : matplotlib.axes.Axes + Axes object upon which the dendrogram is plotted + + """ + tree_kws = {} if tree_kws is None else tree_kws.copy() + tree_kws.setdefault("linewidths", .5) + tree_kws.setdefault("colors", tree_kws.pop("color", (.2, .2, .2))) + + if self.rotate and self.axis == 0: + coords = zip(self.dependent_coord, self.independent_coord) + else: + coords = zip(self.independent_coord, self.dependent_coord) + lines = LineCollection([list(zip(x, y)) for x, y in coords], + **tree_kws) + + ax.add_collection(lines) + number_of_leaves = len(self.reordered_ind) + max_dependent_coord = max(map(max, self.dependent_coord)) + + if self.rotate: + ax.yaxis.set_ticks_position('right') + + # Constants 10 and 1.05 come from + # `scipy.cluster.hierarchy._plot_dendrogram` + ax.set_ylim(0, number_of_leaves * 10) + ax.set_xlim(0, max_dependent_coord * 1.05) + + ax.invert_xaxis() + ax.invert_yaxis() + else: + # Constants 10 and 1.05 come from + # `scipy.cluster.hierarchy._plot_dendrogram` + ax.set_xlim(0, number_of_leaves * 10) + ax.set_ylim(0, max_dependent_coord * 1.05) + + despine(ax=ax, bottom=True, left=True) + + ax.set(xticks=self.xticks, yticks=self.yticks, + xlabel=self.xlabel, ylabel=self.ylabel) + xtl = ax.set_xticklabels(self.xticklabels) + ytl = ax.set_yticklabels(self.yticklabels, rotation='vertical') + + # Force a draw of the plot to avoid matplotlib window error + _draw_figure(ax.figure) + + if len(ytl) > 0 and axis_ticklabels_overlap(ytl): + plt.setp(ytl, rotation="horizontal") + if len(xtl) > 0 and axis_ticklabels_overlap(xtl): + plt.setp(xtl, rotation="vertical") + return self + + +@_deprecate_positional_args +def dendrogram( + data, *, + linkage=None, axis=1, label=True, metric='euclidean', + method='average', rotate=False, tree_kws=None, ax=None +): + """Draw a tree diagram of relationships within a matrix + + Parameters + ---------- + data : pandas.DataFrame + Rectangular data + linkage : numpy.array, optional + Linkage matrix + axis : int, optional + Which axis to use to calculate linkage. 0 is rows, 1 is columns. + label : bool, optional + If True, label the dendrogram at leaves with column or row names + metric : str, optional + Distance metric. Anything valid for scipy.spatial.distance.pdist + method : str, optional + Linkage method to use. Anything valid for + scipy.cluster.hierarchy.linkage + rotate : bool, optional + When plotting the matrix, whether to rotate it 90 degrees + counter-clockwise, so the leaves face right + tree_kws : dict, optional + Keyword arguments for the ``matplotlib.collections.LineCollection`` + that is used for plotting the lines of the dendrogram tree. + ax : matplotlib axis, optional + Axis to plot on, otherwise uses current axis + + Returns + ------- + dendrogramplotter : _DendrogramPlotter + A Dendrogram plotter object. + + Notes + ----- + Access the reordered dendrogram indices with + dendrogramplotter.reordered_ind + + """ + plotter = _DendrogramPlotter(data, linkage=linkage, axis=axis, + metric=metric, method=method, + label=label, rotate=rotate) + if ax is None: + ax = plt.gca() + + return plotter.plot(ax=ax, tree_kws=tree_kws) + + +class ClusterGrid(Grid): + + def __init__(self, data, pivot_kws=None, z_score=None, standard_scale=None, + figsize=None, row_colors=None, col_colors=None, mask=None, + dendrogram_ratio=None, colors_ratio=None, cbar_pos=None): + """Grid object for organizing clustered heatmap input on to axes""" + + if isinstance(data, pd.DataFrame): + self.data = data + else: + self.data = pd.DataFrame(data) + + self.data2d = self.format_data(self.data, pivot_kws, z_score, + standard_scale) + + self.mask = _matrix_mask(self.data2d, mask) + + self._figure = plt.figure(figsize=figsize) + + self.row_colors, self.row_color_labels = \ + self._preprocess_colors(data, row_colors, axis=0) + self.col_colors, self.col_color_labels = \ + self._preprocess_colors(data, col_colors, axis=1) + + try: + row_dendrogram_ratio, col_dendrogram_ratio = dendrogram_ratio + except TypeError: + row_dendrogram_ratio = col_dendrogram_ratio = dendrogram_ratio + + try: + row_colors_ratio, col_colors_ratio = colors_ratio + except TypeError: + row_colors_ratio = col_colors_ratio = colors_ratio + + width_ratios = self.dim_ratios(self.row_colors, + row_dendrogram_ratio, + row_colors_ratio) + height_ratios = self.dim_ratios(self.col_colors, + col_dendrogram_ratio, + col_colors_ratio) + + nrows = 2 if self.col_colors is None else 3 + ncols = 2 if self.row_colors is None else 3 + + self.gs = gridspec.GridSpec(nrows, ncols, + width_ratios=width_ratios, + height_ratios=height_ratios) + + self.ax_row_dendrogram = self._figure.add_subplot(self.gs[-1, 0]) + self.ax_col_dendrogram = self._figure.add_subplot(self.gs[0, -1]) + self.ax_row_dendrogram.set_axis_off() + self.ax_col_dendrogram.set_axis_off() + + self.ax_row_colors = None + self.ax_col_colors = None + + if self.row_colors is not None: + self.ax_row_colors = self._figure.add_subplot( + self.gs[-1, 1]) + if self.col_colors is not None: + self.ax_col_colors = self._figure.add_subplot( + self.gs[1, -1]) + + self.ax_heatmap = self._figure.add_subplot(self.gs[-1, -1]) + if cbar_pos is None: + self.ax_cbar = self.cax = None + else: + # Initialize the colorbar axes in the gridspec so that tight_layout + # works. We will move it where it belongs later. This is a hack. + self.ax_cbar = self._figure.add_subplot(self.gs[0, 0]) + self.cax = self.ax_cbar # Backwards compatibility + self.cbar_pos = cbar_pos + + self.dendrogram_row = None + self.dendrogram_col = None + + def _preprocess_colors(self, data, colors, axis): + """Preprocess {row/col}_colors to extract labels and convert colors.""" + labels = None + + if colors is not None: + if isinstance(colors, (pd.DataFrame, pd.Series)): + + # If data is unindexed, raise + if (not hasattr(data, "index") and axis == 0) or ( + not hasattr(data, "columns") and axis == 1 + ): + axis_name = "col" if axis else "row" + msg = (f"{axis_name}_colors indices can't be matched with data " + f"indices. Provide {axis_name}_colors as a non-indexed " + "datatype, e.g. by using `.to_numpy()``") + raise TypeError(msg) + + # Ensure colors match data indices + if axis == 0: + colors = colors.reindex(data.index) + else: + colors = colors.reindex(data.columns) + + # Replace na's with white color + # TODO We should set these to transparent instead + colors = colors.astype(object).fillna('white') + + # Extract color values and labels from frame/series + if isinstance(colors, pd.DataFrame): + labels = list(colors.columns) + colors = colors.T.values + else: + if colors.name is None: + labels = [""] + else: + labels = [colors.name] + colors = colors.values + + colors = _convert_colors(colors) + + return colors, labels + + def format_data(self, data, pivot_kws, z_score=None, + standard_scale=None): + """Extract variables from data or use directly.""" + + # Either the data is already in 2d matrix format, or need to do a pivot + if pivot_kws is not None: + data2d = data.pivot(**pivot_kws) + else: + data2d = data + + if z_score is not None and standard_scale is not None: + raise ValueError( + 'Cannot perform both z-scoring and standard-scaling on data') + + if z_score is not None: + data2d = self.z_score(data2d, z_score) + if standard_scale is not None: + data2d = self.standard_scale(data2d, standard_scale) + return data2d + + @staticmethod + def z_score(data2d, axis=1): + """Standarize the mean and variance of the data axis + + Parameters + ---------- + data2d : pandas.DataFrame + Data to normalize + axis : int + Which axis to normalize across. If 0, normalize across rows, if 1, + normalize across columns. + + Returns + ------- + normalized : pandas.DataFrame + Noramlized data with a mean of 0 and variance of 1 across the + specified axis. + """ + if axis == 1: + z_scored = data2d + else: + z_scored = data2d.T + + z_scored = (z_scored - z_scored.mean()) / z_scored.std() + + if axis == 1: + return z_scored + else: + return z_scored.T + + @staticmethod + def standard_scale(data2d, axis=1): + """Divide the data by the difference between the max and min + + Parameters + ---------- + data2d : pandas.DataFrame + Data to normalize + axis : int + Which axis to normalize across. If 0, normalize across rows, if 1, + normalize across columns. + + Returns + ------- + standardized : pandas.DataFrame + Noramlized data with a mean of 0 and variance of 1 across the + specified axis. + + """ + # Normalize these values to range from 0 to 1 + if axis == 1: + standardized = data2d + else: + standardized = data2d.T + + subtract = standardized.min() + standardized = (standardized - subtract) / ( + standardized.max() - standardized.min()) + + if axis == 1: + return standardized + else: + return standardized.T + + def dim_ratios(self, colors, dendrogram_ratio, colors_ratio): + """Get the proportions of the figure taken up by each axes.""" + ratios = [dendrogram_ratio] + + if colors is not None: + # Colors are encoded as rgb, so ther is an extra dimention + if np.ndim(colors) > 2: + n_colors = len(colors) + else: + n_colors = 1 + + ratios += [n_colors * colors_ratio] + + # Add the ratio for the heatmap itself + ratios.append(1 - sum(ratios)) + + return ratios + + @staticmethod + def color_list_to_matrix_and_cmap(colors, ind, axis=0): + """Turns a list of colors into a numpy matrix and matplotlib colormap + + These arguments can now be plotted using heatmap(matrix, cmap) + and the provided colors will be plotted. + + Parameters + ---------- + colors : list of matplotlib colors + Colors to label the rows or columns of a dataframe. + ind : list of ints + Ordering of the rows or columns, to reorder the original colors + by the clustered dendrogram order + axis : int + Which axis this is labeling + + Returns + ------- + matrix : numpy.array + A numpy array of integer values, where each indexes into the cmap + cmap : matplotlib.colors.ListedColormap + + """ + try: + mpl.colors.to_rgb(colors[0]) + except ValueError: + # We have a 2D color structure + m, n = len(colors), len(colors[0]) + if not all(len(c) == n for c in colors[1:]): + raise ValueError("Multiple side color vectors must have same size") + else: + # We have one vector of colors + m, n = 1, len(colors) + colors = [colors] + + # Map from unique colors to colormap index value + unique_colors = {} + matrix = np.zeros((m, n), int) + for i, inner in enumerate(colors): + for j, color in enumerate(inner): + idx = unique_colors.setdefault(color, len(unique_colors)) + matrix[i, j] = idx + + # Reorder for clustering and transpose for axis + matrix = matrix[:, ind] + if axis == 0: + matrix = matrix.T + + cmap = mpl.colors.ListedColormap(list(unique_colors)) + return matrix, cmap + + def plot_dendrograms(self, row_cluster, col_cluster, metric, method, + row_linkage, col_linkage, tree_kws): + # Plot the row dendrogram + if row_cluster: + self.dendrogram_row = dendrogram( + self.data2d, metric=metric, method=method, label=False, axis=0, + ax=self.ax_row_dendrogram, rotate=True, linkage=row_linkage, + tree_kws=tree_kws + ) + else: + self.ax_row_dendrogram.set_xticks([]) + self.ax_row_dendrogram.set_yticks([]) + # PLot the column dendrogram + if col_cluster: + self.dendrogram_col = dendrogram( + self.data2d, metric=metric, method=method, label=False, + axis=1, ax=self.ax_col_dendrogram, linkage=col_linkage, + tree_kws=tree_kws + ) + else: + self.ax_col_dendrogram.set_xticks([]) + self.ax_col_dendrogram.set_yticks([]) + despine(ax=self.ax_row_dendrogram, bottom=True, left=True) + despine(ax=self.ax_col_dendrogram, bottom=True, left=True) + + def plot_colors(self, xind, yind, **kws): + """Plots color labels between the dendrogram and the heatmap + + Parameters + ---------- + heatmap_kws : dict + Keyword arguments heatmap + + """ + # Remove any custom colormap and centering + # TODO this code has consistently caused problems when we + # have missed kwargs that need to be excluded that it might + # be better to rewrite *in*clusively. + kws = kws.copy() + kws.pop('cmap', None) + kws.pop('norm', None) + kws.pop('center', None) + kws.pop('annot', None) + kws.pop('vmin', None) + kws.pop('vmax', None) + kws.pop('robust', None) + kws.pop('xticklabels', None) + kws.pop('yticklabels', None) + + # Plot the row colors + if self.row_colors is not None: + matrix, cmap = self.color_list_to_matrix_and_cmap( + self.row_colors, yind, axis=0) + + # Get row_color labels + if self.row_color_labels is not None: + row_color_labels = self.row_color_labels + else: + row_color_labels = False + + heatmap(matrix, cmap=cmap, cbar=False, ax=self.ax_row_colors, + xticklabels=row_color_labels, yticklabels=False, **kws) + + # Adjust rotation of labels + if row_color_labels is not False: + plt.setp(self.ax_row_colors.get_xticklabels(), rotation=90) + else: + despine(self.ax_row_colors, left=True, bottom=True) + + # Plot the column colors + if self.col_colors is not None: + matrix, cmap = self.color_list_to_matrix_and_cmap( + self.col_colors, xind, axis=1) + + # Get col_color labels + if self.col_color_labels is not None: + col_color_labels = self.col_color_labels + else: + col_color_labels = False + + heatmap(matrix, cmap=cmap, cbar=False, ax=self.ax_col_colors, + xticklabels=False, yticklabels=col_color_labels, **kws) + + # Adjust rotation of labels, place on right side + if col_color_labels is not False: + self.ax_col_colors.yaxis.tick_right() + plt.setp(self.ax_col_colors.get_yticklabels(), rotation=0) + else: + despine(self.ax_col_colors, left=True, bottom=True) + + def plot_matrix(self, colorbar_kws, xind, yind, **kws): + self.data2d = self.data2d.iloc[yind, xind] + self.mask = self.mask.iloc[yind, xind] + + # Try to reorganize specified tick labels, if provided + xtl = kws.pop("xticklabels", "auto") + try: + xtl = np.asarray(xtl)[xind] + except (TypeError, IndexError): + pass + ytl = kws.pop("yticklabels", "auto") + try: + ytl = np.asarray(ytl)[yind] + except (TypeError, IndexError): + pass + + # Reorganize the annotations to match the heatmap + annot = kws.pop("annot", None) + if annot is None or annot is False: + pass + else: + if isinstance(annot, bool): + annot_data = self.data2d + else: + annot_data = np.asarray(annot) + if annot_data.shape != self.data2d.shape: + err = "`data` and `annot` must have same shape." + raise ValueError(err) + annot_data = annot_data[yind][:, xind] + annot = annot_data + + # Setting ax_cbar=None in clustermap call implies no colorbar + kws.setdefault("cbar", self.ax_cbar is not None) + heatmap(self.data2d, ax=self.ax_heatmap, cbar_ax=self.ax_cbar, + cbar_kws=colorbar_kws, mask=self.mask, + xticklabels=xtl, yticklabels=ytl, annot=annot, **kws) + + ytl = self.ax_heatmap.get_yticklabels() + ytl_rot = None if not ytl else ytl[0].get_rotation() + self.ax_heatmap.yaxis.set_ticks_position('right') + self.ax_heatmap.yaxis.set_label_position('right') + if ytl_rot is not None: + ytl = self.ax_heatmap.get_yticklabels() + plt.setp(ytl, rotation=ytl_rot) + + tight_params = dict(h_pad=.02, w_pad=.02) + if self.ax_cbar is None: + self._figure.tight_layout(**tight_params) + else: + # Turn the colorbar axes off for tight layout so that its + # ticks don't interfere with the rest of the plot layout. + # Then move it. + self.ax_cbar.set_axis_off() + self._figure.tight_layout(**tight_params) + self.ax_cbar.set_axis_on() + self.ax_cbar.set_position(self.cbar_pos) + + def plot(self, metric, method, colorbar_kws, row_cluster, col_cluster, + row_linkage, col_linkage, tree_kws, **kws): + + # heatmap square=True sets the aspect ratio on the axes, but that is + # not compatible with the multi-axes layout of clustergrid + if kws.get("square", False): + msg = "``square=True`` ignored in clustermap" + warnings.warn(msg) + kws.pop("square") + + colorbar_kws = {} if colorbar_kws is None else colorbar_kws + + self.plot_dendrograms(row_cluster, col_cluster, metric, method, + row_linkage=row_linkage, col_linkage=col_linkage, + tree_kws=tree_kws) + try: + xind = self.dendrogram_col.reordered_ind + except AttributeError: + xind = np.arange(self.data2d.shape[1]) + try: + yind = self.dendrogram_row.reordered_ind + except AttributeError: + yind = np.arange(self.data2d.shape[0]) + + self.plot_colors(xind, yind, **kws) + self.plot_matrix(colorbar_kws, xind, yind, **kws) + return self + + +@_deprecate_positional_args +def clustermap( + data, *, + pivot_kws=None, method='average', metric='euclidean', + z_score=None, standard_scale=None, figsize=(10, 10), + cbar_kws=None, row_cluster=True, col_cluster=True, + row_linkage=None, col_linkage=None, + row_colors=None, col_colors=None, mask=None, + dendrogram_ratio=.2, colors_ratio=0.03, + cbar_pos=(.02, .8, .05, .18), tree_kws=None, + **kwargs +): + """ + Plot a matrix dataset as a hierarchically-clustered heatmap. + + Parameters + ---------- + data : 2D array-like + Rectangular data for clustering. Cannot contain NAs. + pivot_kws : dict, optional + If `data` is a tidy dataframe, can provide keyword arguments for + pivot to create a rectangular dataframe. + method : str, optional + Linkage method to use for calculating clusters. See + :func:`scipy.cluster.hierarchy.linkage` documentation for more + information. + metric : str, optional + Distance metric to use for the data. See + :func:`scipy.spatial.distance.pdist` documentation for more options. + To use different metrics (or methods) for rows and columns, you may + construct each linkage matrix yourself and provide them as + `{row,col}_linkage`. + z_score : int or None, optional + Either 0 (rows) or 1 (columns). Whether or not to calculate z-scores + for the rows or the columns. Z scores are: z = (x - mean)/std, so + values in each row (column) will get the mean of the row (column) + subtracted, then divided by the standard deviation of the row (column). + This ensures that each row (column) has mean of 0 and variance of 1. + standard_scale : int or None, optional + Either 0 (rows) or 1 (columns). Whether or not to standardize that + dimension, meaning for each row or column, subtract the minimum and + divide each by its maximum. + figsize : tuple of (width, height), optional + Overall size of the figure. + cbar_kws : dict, optional + Keyword arguments to pass to `cbar_kws` in :func:`heatmap`, e.g. to + add a label to the colorbar. + {row,col}_cluster : bool, optional + If ``True``, cluster the {rows, columns}. + {row,col}_linkage : :class:`numpy.ndarray`, optional + Precomputed linkage matrix for the rows or columns. See + :func:`scipy.cluster.hierarchy.linkage` for specific formats. + {row,col}_colors : list-like or pandas DataFrame/Series, optional + List of colors to label for either the rows or columns. Useful to evaluate + whether samples within a group are clustered together. Can use nested lists or + DataFrame for multiple color levels of labeling. If given as a + :class:`pandas.DataFrame` or :class:`pandas.Series`, labels for the colors are + extracted from the DataFrames column names or from the name of the Series. + DataFrame/Series colors are also matched to the data by their index, ensuring + colors are drawn in the correct order. + mask : bool array or DataFrame, optional + If passed, data will not be shown in cells where `mask` is True. + Cells with missing values are automatically masked. Only used for + visualizing, not for calculating. + {dendrogram,colors}_ratio : float, or pair of floats, optional + Proportion of the figure size devoted to the two marginal elements. If + a pair is given, they correspond to (row, col) ratios. + cbar_pos : tuple of (left, bottom, width, height), optional + Position of the colorbar axes in the figure. Setting to ``None`` will + disable the colorbar. + tree_kws : dict, optional + Parameters for the :class:`matplotlib.collections.LineCollection` + that is used to plot the lines of the dendrogram tree. + kwargs : other keyword arguments + All other keyword arguments are passed to :func:`heatmap`. + + Returns + ------- + :class:`ClusterGrid` + A :class:`ClusterGrid` instance. + + See Also + -------- + heatmap : Plot rectangular data as a color-encoded matrix. + + Notes + ----- + The returned object has a ``savefig`` method that should be used if you + want to save the figure object without clipping the dendrograms. + + To access the reordered row indices, use: + ``clustergrid.dendrogram_row.reordered_ind`` + + Column indices, use: + ``clustergrid.dendrogram_col.reordered_ind`` + + Examples + -------- + + Plot a clustered heatmap: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns; sns.set_theme(color_codes=True) + >>> iris = sns.load_dataset("iris") + >>> species = iris.pop("species") + >>> g = sns.clustermap(iris) + + Change the size and layout of the figure: + + .. plot:: + :context: close-figs + + >>> g = sns.clustermap(iris, + ... figsize=(7, 5), + ... row_cluster=False, + ... dendrogram_ratio=(.1, .2), + ... cbar_pos=(0, .2, .03, .4)) + + Add colored labels to identify observations: + + .. plot:: + :context: close-figs + + >>> lut = dict(zip(species.unique(), "rbg")) + >>> row_colors = species.map(lut) + >>> g = sns.clustermap(iris, row_colors=row_colors) + + Use a different colormap and adjust the limits of the color range: + + .. plot:: + :context: close-figs + + >>> g = sns.clustermap(iris, cmap="mako", vmin=0, vmax=10) + + Use a different similarity metric: + + .. plot:: + :context: close-figs + + >>> g = sns.clustermap(iris, metric="correlation") + + Use a different clustering method: + + .. plot:: + :context: close-figs + + >>> g = sns.clustermap(iris, method="single") + + Standardize the data within the columns: + + .. plot:: + :context: close-figs + + >>> g = sns.clustermap(iris, standard_scale=1) + + Normalize the data within the rows: + + .. plot:: + :context: close-figs + + >>> g = sns.clustermap(iris, z_score=0, cmap="vlag") + """ + plotter = ClusterGrid(data, pivot_kws=pivot_kws, figsize=figsize, + row_colors=row_colors, col_colors=col_colors, + z_score=z_score, standard_scale=standard_scale, + mask=mask, dendrogram_ratio=dendrogram_ratio, + colors_ratio=colors_ratio, cbar_pos=cbar_pos) + + return plotter.plot(metric=metric, method=method, + colorbar_kws=cbar_kws, + row_cluster=row_cluster, col_cluster=col_cluster, + row_linkage=row_linkage, col_linkage=col_linkage, + tree_kws=tree_kws, **kwargs) diff --git a/grplot_seaborn/miscplot.py b/grplot_seaborn/miscplot.py new file mode 100644 index 0000000..46d507e --- /dev/null +++ b/grplot_seaborn/miscplot.py @@ -0,0 +1,48 @@ +import numpy as np +import matplotlib as mpl +import matplotlib.pyplot as plt +import matplotlib.ticker as ticker + +__all__ = ["palplot", "dogplot"] + + +def palplot(pal, size=1): + """Plot the values in a color palette as a horizontal array. + + Parameters + ---------- + pal : sequence of matplotlib colors + colors, i.e. as returned by grplot_seaborn.color_palette() + size : + scaling factor for size of plot + + """ + n = len(pal) + f, ax = plt.subplots(1, 1, figsize=(n * size, size)) + ax.imshow(np.arange(n).reshape(1, n), + cmap=mpl.colors.ListedColormap(list(pal)), + interpolation="nearest", aspect="auto") + ax.set_xticks(np.arange(n) - .5) + ax.set_yticks([-.5, .5]) + # Ensure nice border between colors + ax.set_xticklabels(["" for _ in range(n)]) + # The proper way to set no ticks + ax.yaxis.set_major_locator(ticker.NullLocator()) + + +def dogplot(*_, **__): + """Who's a good boy?""" + try: + from urllib.request import urlopen + except ImportError: + from urllib2 import urlopen + from io import BytesIO + + url = "https://github.com/mwaskom/seaborn-data/raw/master/png/img{}.png" + pic = np.random.randint(2, 7) + data = BytesIO(urlopen(url.format(pic)).read()) + img = plt.imread(data) + f, ax = plt.subplots(figsize=(5, 5), dpi=100) + f.subplots_adjust(0, 0, 1, 1) + ax.imshow(img) + ax.set_axis_off() diff --git a/grplot_seaborn/palettes.py b/grplot_seaborn/palettes.py new file mode 100644 index 0000000..d28d98d --- /dev/null +++ b/grplot_seaborn/palettes.py @@ -0,0 +1,1038 @@ +import colorsys +from itertools import cycle + +import numpy as np +import matplotlib as mpl + +from .external import husl + +from .utils import desaturate, get_color_cycle +from .colors import xkcd_rgb, crayons + + +__all__ = ["color_palette", "hls_palette", "husl_palette", "mpl_palette", + "dark_palette", "light_palette", "diverging_palette", + "blend_palette", "xkcd_palette", "crayon_palette", + "cubehelix_palette", "set_color_codes"] + + +SEABORN_PALETTES = dict( + deep=["#4C72B0", "#DD8452", "#55A868", "#C44E52", "#8172B3", + "#937860", "#DA8BC3", "#8C8C8C", "#CCB974", "#64B5CD"], + deep6=["#4C72B0", "#55A868", "#C44E52", + "#8172B3", "#CCB974", "#64B5CD"], + muted=["#4878D0", "#EE854A", "#6ACC64", "#D65F5F", "#956CB4", + "#8C613C", "#DC7EC0", "#797979", "#D5BB67", "#82C6E2"], + muted6=["#4878D0", "#6ACC64", "#D65F5F", + "#956CB4", "#D5BB67", "#82C6E2"], + pastel=["#A1C9F4", "#FFB482", "#8DE5A1", "#FF9F9B", "#D0BBFF", + "#DEBB9B", "#FAB0E4", "#CFCFCF", "#FFFEA3", "#B9F2F0"], + pastel6=["#A1C9F4", "#8DE5A1", "#FF9F9B", + "#D0BBFF", "#FFFEA3", "#B9F2F0"], + bright=["#023EFF", "#FF7C00", "#1AC938", "#E8000B", "#8B2BE2", + "#9F4800", "#F14CC1", "#A3A3A3", "#FFC400", "#00D7FF"], + bright6=["#023EFF", "#1AC938", "#E8000B", + "#8B2BE2", "#FFC400", "#00D7FF"], + dark=["#001C7F", "#B1400D", "#12711C", "#8C0800", "#591E71", + "#592F0D", "#A23582", "#3C3C3C", "#B8850A", "#006374"], + dark6=["#001C7F", "#12711C", "#8C0800", + "#591E71", "#B8850A", "#006374"], + colorblind=["#0173B2", "#DE8F05", "#029E73", "#D55E00", "#CC78BC", + "#CA9161", "#FBAFE4", "#949494", "#ECE133", "#56B4E9"], + colorblind6=["#0173B2", "#029E73", "#D55E00", + "#CC78BC", "#ECE133", "#56B4E9"] +) + + +MPL_QUAL_PALS = { + "tab10": 10, "tab20": 20, "tab20b": 20, "tab20c": 20, + "Set1": 9, "Set2": 8, "Set3": 12, + "Accent": 8, "Paired": 12, + "Pastel1": 9, "Pastel2": 8, "Dark2": 8, +} + + +QUAL_PALETTE_SIZES = MPL_QUAL_PALS.copy() +QUAL_PALETTE_SIZES.update({k: len(v) for k, v in SEABORN_PALETTES.items()}) +QUAL_PALETTES = list(QUAL_PALETTE_SIZES.keys()) + + +class _ColorPalette(list): + """Set the color palette in a with statement, otherwise be a list.""" + def __enter__(self): + """Open the context.""" + from .rcmod import set_palette + self._orig_palette = color_palette() + set_palette(self) + return self + + def __exit__(self, *args): + """Close the context.""" + from .rcmod import set_palette + set_palette(self._orig_palette) + + def as_hex(self): + """Return a color palette with hex codes instead of RGB values.""" + hex = [mpl.colors.rgb2hex(rgb) for rgb in self] + return _ColorPalette(hex) + + def _repr_html_(self): + """Rich display of the color palette in an HTML frontend.""" + s = 55 + n = len(self) + html = f'' + for i, c in enumerate(self.as_hex()): + html += ( + f'' + ) + html += '' + return html + + +def color_palette(palette=None, n_colors=None, desat=None, as_cmap=False): + """Return a list of colors or continuous colormap defining a palette. + + Possible ``palette`` values include: + - Name of a seaborn palette (deep, muted, bright, pastel, dark, colorblind) + - Name of matplotlib colormap + - 'husl' or 'hls' + - 'ch:' + - 'light:', 'dark:', 'blend:,', + - A sequence of colors in any format matplotlib accepts + + Calling this function with ``palette=None`` will return the current + matplotlib color cycle. + + This function can also be used in a ``with`` statement to temporarily + set the color cycle for a plot or set of plots. + + See the :ref:`tutorial ` for more information. + + Parameters + ---------- + palette : None, string, or sequence, optional + Name of palette or None to return current palette. If a sequence, input + colors are used but possibly cycled and desaturated. + n_colors : int, optional + Number of colors in the palette. If ``None``, the default will depend + on how ``palette`` is specified. Named palettes default to 6 colors, + but grabbing the current palette or passing in a list of colors will + not change the number of colors unless this is specified. Asking for + more colors than exist in the palette will cause it to cycle. Ignored + when ``as_cmap`` is True. + desat : float, optional + Proportion to desaturate each color by. + as_cmap : bool + If True, return a :class:`matplotlib.colors.Colormap`. + + Returns + ------- + list of RGB tuples or :class:`matplotlib.colors.Colormap` + + See Also + -------- + set_palette : Set the default color cycle for all plots. + set_color_codes : Reassign color codes like ``"b"``, ``"g"``, etc. to + colors from one of the seaborn palettes. + + Examples + -------- + + .. include:: ../docstrings/color_palette.rst + + """ + if palette is None: + palette = get_color_cycle() + if n_colors is None: + n_colors = len(palette) + + elif not isinstance(palette, str): + palette = palette + if n_colors is None: + n_colors = len(palette) + else: + + if n_colors is None: + # Use all colors in a qualitative palette or 6 of another kind + n_colors = QUAL_PALETTE_SIZES.get(palette, 6) + + if palette in SEABORN_PALETTES: + # Named "seaborn variant" of matplotlib default color cycle + palette = SEABORN_PALETTES[palette] + + elif palette == "hls": + # Evenly spaced colors in cylindrical RGB space + palette = hls_palette(n_colors, as_cmap=as_cmap) + + elif palette == "husl": + # Evenly spaced colors in cylindrical Lab space + palette = husl_palette(n_colors, as_cmap=as_cmap) + + elif palette.lower() == "jet": + # Paternalism + raise ValueError("No.") + + elif palette.startswith("ch:"): + # Cubehelix palette with params specified in string + args, kwargs = _parse_cubehelix_args(palette) + palette = cubehelix_palette(n_colors, *args, **kwargs, as_cmap=as_cmap) + + elif palette.startswith("light:"): + # light palette to color specified in string + _, color = palette.split(":") + reverse = color.endswith("_r") + if reverse: + color = color[:-2] + palette = light_palette(color, n_colors, reverse=reverse, as_cmap=as_cmap) + + elif palette.startswith("dark:"): + # light palette to color specified in string + _, color = palette.split(":") + reverse = color.endswith("_r") + if reverse: + color = color[:-2] + palette = dark_palette(color, n_colors, reverse=reverse, as_cmap=as_cmap) + + elif palette.startswith("blend:"): + # blend palette between colors specified in string + _, colors = palette.split(":") + colors = colors.split(",") + palette = blend_palette(colors, n_colors, as_cmap=as_cmap) + + else: + try: + # Perhaps a named matplotlib colormap? + palette = mpl_palette(palette, n_colors, as_cmap=as_cmap) + except ValueError: + raise ValueError("%s is not a valid palette name" % palette) + + if desat is not None: + palette = [desaturate(c, desat) for c in palette] + + if not as_cmap: + + # Always return as many colors as we asked for + pal_cycle = cycle(palette) + palette = [next(pal_cycle) for _ in range(n_colors)] + + # Always return in r, g, b tuple format + try: + palette = map(mpl.colors.colorConverter.to_rgb, palette) + palette = _ColorPalette(palette) + except ValueError: + raise ValueError(f"Could not generate a palette for {palette}") + + return palette + + +def hls_palette(n_colors=6, h=.01, l=.6, s=.65, as_cmap=False): # noqa + """Get a set of evenly spaced colors in HLS hue space. + + h, l, and s should be between 0 and 1 + + Parameters + ---------- + + n_colors : int + number of colors in the palette + h : float + first hue + l : float + lightness + s : float + saturation + + Returns + ------- + list of RGB tuples or :class:`matplotlib.colors.Colormap` + + See Also + -------- + husl_palette : Make a palette using evenly spaced hues in the HUSL system. + + Examples + -------- + + Create a palette of 10 colors with the default parameters: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns; sns.set_theme() + >>> sns.palplot(sns.hls_palette(10)) + + Create a palette of 10 colors that begins at a different hue value: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.hls_palette(10, h=.5)) + + Create a palette of 10 colors that are darker than the default: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.hls_palette(10, l=.4)) + + Create a palette of 10 colors that are less saturated than the default: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.hls_palette(10, s=.4)) + + """ + if as_cmap: + n_colors = 256 + hues = np.linspace(0, 1, int(n_colors) + 1)[:-1] + hues += h + hues %= 1 + hues -= hues.astype(int) + palette = [colorsys.hls_to_rgb(h_i, l, s) for h_i in hues] + if as_cmap: + return mpl.colors.ListedColormap(palette, "hls") + else: + return _ColorPalette(palette) + + +def husl_palette(n_colors=6, h=.01, s=.9, l=.65, as_cmap=False): # noqa + """Get a set of evenly spaced colors in HUSL hue space. + + h, s, and l should be between 0 and 1 + + Parameters + ---------- + + n_colors : int + number of colors in the palette + h : float + first hue + s : float + saturation + l : float + lightness + + Returns + ------- + list of RGB tuples or :class:`matplotlib.colors.Colormap` + + See Also + -------- + hls_palette : Make a palette using evently spaced circular hues in the + HSL system. + + Examples + -------- + + Create a palette of 10 colors with the default parameters: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns; sns.set_theme() + >>> sns.palplot(sns.husl_palette(10)) + + Create a palette of 10 colors that begins at a different hue value: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.husl_palette(10, h=.5)) + + Create a palette of 10 colors that are darker than the default: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.husl_palette(10, l=.4)) + + Create a palette of 10 colors that are less saturated than the default: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.husl_palette(10, s=.4)) + + """ + if as_cmap: + n_colors = 256 + hues = np.linspace(0, 1, int(n_colors) + 1)[:-1] + hues += h + hues %= 1 + hues *= 359 + s *= 99 + l *= 99 # noqa + palette = [_color_to_rgb((h_i, s, l), input="husl") for h_i in hues] + if as_cmap: + return mpl.colors.ListedColormap(palette, "hsl") + else: + return _ColorPalette(palette) + + +def mpl_palette(name, n_colors=6, as_cmap=False): + """Return discrete colors from a matplotlib palette. + + Note that this handles the qualitative colorbrewer palettes + properly, although if you ask for more colors than a particular + qualitative palette can provide you will get fewer than you are + expecting. In contrast, asking for qualitative color brewer palettes + using :func:`color_palette` will return the expected number of colors, + but they will cycle. + + If you are using the IPython notebook, you can also use the function + :func:`choose_colorbrewer_palette` to interactively select palettes. + + Parameters + ---------- + name : string + Name of the palette. This should be a named matplotlib colormap. + n_colors : int + Number of discrete colors in the palette. + + Returns + ------- + list of RGB tuples or :class:`matplotlib.colors.Colormap` + + Examples + -------- + + Create a qualitative colorbrewer palette with 8 colors: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns; sns.set_theme() + >>> sns.palplot(sns.mpl_palette("Set2", 8)) + + Create a sequential colorbrewer palette: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.mpl_palette("Blues")) + + Create a diverging palette: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.mpl_palette("seismic", 8)) + + Create a "dark" sequential palette: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.mpl_palette("GnBu_d")) + + """ + if name.endswith("_d"): + sub_name = name[:-2] + if sub_name.endswith("_r"): + reverse = True + sub_name = sub_name[:-2] + else: + reverse = False + pal = color_palette(sub_name, 2) + ["#333333"] + if reverse: + pal = pal[::-1] + cmap = blend_palette(pal, n_colors, as_cmap=True) + else: + cmap = mpl.cm.get_cmap(name) + + if name in MPL_QUAL_PALS: + bins = np.linspace(0, 1, MPL_QUAL_PALS[name])[:n_colors] + else: + bins = np.linspace(0, 1, int(n_colors) + 2)[1:-1] + palette = list(map(tuple, cmap(bins)[:, :3])) + + if as_cmap: + return cmap + else: + return _ColorPalette(palette) + + +def _color_to_rgb(color, input): + """Add some more flexibility to color choices.""" + if input == "hls": + color = colorsys.hls_to_rgb(*color) + elif input == "husl": + color = husl.husl_to_rgb(*color) + color = tuple(np.clip(color, 0, 1)) + elif input == "xkcd": + color = xkcd_rgb[color] + + return mpl.colors.to_rgb(color) + + +def dark_palette(color, n_colors=6, reverse=False, as_cmap=False, input="rgb"): + """Make a sequential palette that blends from dark to ``color``. + + This kind of palette is good for data that range between relatively + uninteresting low values and interesting high values. + + The ``color`` parameter can be specified in a number of ways, including + all options for defining a color in matplotlib and several additional + color spaces that are handled by seaborn. You can also use the database + of named colors from the XKCD color survey. + + If you are using the IPython notebook, you can also choose this palette + interactively with the :func:`choose_dark_palette` function. + + Parameters + ---------- + color : base color for high values + hex, rgb-tuple, or html color name + n_colors : int, optional + number of colors in the palette + reverse : bool, optional + if True, reverse the direction of the blend + as_cmap : bool, optional + If True, return a :class:`matplotlib.colors.Colormap`. + input : {'rgb', 'hls', 'husl', xkcd'} + Color space to interpret the input color. The first three options + apply to tuple inputs and the latter applies to string inputs. + + Returns + ------- + list of RGB tuples or :class:`matplotlib.colors.Colormap` + + See Also + -------- + light_palette : Create a sequential palette with bright low values. + diverging_palette : Create a diverging palette with two colors. + + Examples + -------- + + Generate a palette from an HTML color: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns; sns.set_theme() + >>> sns.palplot(sns.dark_palette("purple")) + + Generate a palette that decreases in lightness: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.dark_palette("seagreen", reverse=True)) + + Generate a palette from an HUSL-space seed: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.dark_palette((260, 75, 60), input="husl")) + + Generate a colormap object: + + .. plot:: + :context: close-figs + + >>> from numpy import arange + >>> x = arange(25).reshape(5, 5) + >>> cmap = sns.dark_palette("#2ecc71", as_cmap=True) + >>> ax = sns.heatmap(x, cmap=cmap) + + """ + rgb = _color_to_rgb(color, input) + h, s, l = husl.rgb_to_husl(*rgb) + gray_s, gray_l = .15 * s, 15 + gray = _color_to_rgb((h, gray_s, gray_l), input="husl") + colors = [rgb, gray] if reverse else [gray, rgb] + return blend_palette(colors, n_colors, as_cmap) + + +def light_palette(color, n_colors=6, reverse=False, as_cmap=False, input="rgb"): + """Make a sequential palette that blends from light to ``color``. + + This kind of palette is good for data that range between relatively + uninteresting low values and interesting high values. + + The ``color`` parameter can be specified in a number of ways, including + all options for defining a color in matplotlib and several additional + color spaces that are handled by seaborn. You can also use the database + of named colors from the XKCD color survey. + + If you are using the IPython notebook, you can also choose this palette + interactively with the :func:`choose_light_palette` function. + + Parameters + ---------- + color : base color for high values + hex code, html color name, or tuple in ``input`` space. + n_colors : int, optional + number of colors in the palette + reverse : bool, optional + if True, reverse the direction of the blend + as_cmap : bool, optional + If True, return a :class:`matplotlib.colors.Colormap`. + input : {'rgb', 'hls', 'husl', xkcd'} + Color space to interpret the input color. The first three options + apply to tuple inputs and the latter applies to string inputs. + + Returns + ------- + list of RGB tuples or :class:`matplotlib.colors.Colormap` + + See Also + -------- + dark_palette : Create a sequential palette with dark low values. + diverging_palette : Create a diverging palette with two colors. + + Examples + -------- + + Generate a palette from an HTML color: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns; sns.set_theme() + >>> sns.palplot(sns.light_palette("purple")) + + Generate a palette that increases in lightness: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.light_palette("seagreen", reverse=True)) + + Generate a palette from an HUSL-space seed: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.light_palette((260, 75, 60), input="husl")) + + Generate a colormap object: + + .. plot:: + :context: close-figs + + >>> from numpy import arange + >>> x = arange(25).reshape(5, 5) + >>> cmap = sns.light_palette("#2ecc71", as_cmap=True) + >>> ax = sns.heatmap(x, cmap=cmap) + + """ + rgb = _color_to_rgb(color, input) + h, s, l = husl.rgb_to_husl(*rgb) + gray_s, gray_l = .15 * s, 95 + gray = _color_to_rgb((h, gray_s, gray_l), input="husl") + colors = [rgb, gray] if reverse else [gray, rgb] + return blend_palette(colors, n_colors, as_cmap) + + +def diverging_palette(h_neg, h_pos, s=75, l=50, sep=1, n=6, # noqa + center="light", as_cmap=False): + """Make a diverging palette between two HUSL colors. + + If you are using the IPython notebook, you can also choose this palette + interactively with the :func:`choose_diverging_palette` function. + + Parameters + ---------- + h_neg, h_pos : float in [0, 359] + Anchor hues for negative and positive extents of the map. + s : float in [0, 100], optional + Anchor saturation for both extents of the map. + l : float in [0, 100], optional + Anchor lightness for both extents of the map. + sep : int, optional + Size of the intermediate region. + n : int, optional + Number of colors in the palette (if not returning a cmap) + center : {"light", "dark"}, optional + Whether the center of the palette is light or dark + as_cmap : bool, optional + If True, return a :class:`matplotlib.colors.Colormap`. + + Returns + ------- + list of RGB tuples or :class:`matplotlib.colors.Colormap` + + See Also + -------- + dark_palette : Create a sequential palette with dark values. + light_palette : Create a sequential palette with light values. + + Examples + -------- + + Generate a blue-white-red palette: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns; sns.set_theme() + >>> sns.palplot(sns.diverging_palette(240, 10, n=9)) + + Generate a brighter green-white-purple palette: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.diverging_palette(150, 275, s=80, l=55, n=9)) + + Generate a blue-black-red palette: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.diverging_palette(250, 15, s=75, l=40, + ... n=9, center="dark")) + + Generate a colormap object: + + .. plot:: + :context: close-figs + + >>> from numpy import arange + >>> x = arange(25).reshape(5, 5) + >>> cmap = sns.diverging_palette(220, 20, as_cmap=True) + >>> ax = sns.heatmap(x, cmap=cmap) + + """ + palfunc = dict(dark=dark_palette, light=light_palette)[center] + n_half = int(128 - (sep // 2)) + neg = palfunc((h_neg, s, l), n_half, reverse=True, input="husl") + pos = palfunc((h_pos, s, l), n_half, input="husl") + midpoint = dict(light=[(.95, .95, .95)], dark=[(.133, .133, .133)])[center] + mid = midpoint * sep + pal = blend_palette(np.concatenate([neg, mid, pos]), n, as_cmap=as_cmap) + return pal + + +def blend_palette(colors, n_colors=6, as_cmap=False, input="rgb"): + """Make a palette that blends between a list of colors. + + Parameters + ---------- + colors : sequence of colors in various formats interpreted by ``input`` + hex code, html color name, or tuple in ``input`` space. + n_colors : int, optional + Number of colors in the palette. + as_cmap : bool, optional + If True, return a :class:`matplotlib.colors.Colormap`. + + Returns + ------- + list of RGB tuples or :class:`matplotlib.colors.Colormap` + + """ + colors = [_color_to_rgb(color, input) for color in colors] + name = "blend" + pal = mpl.colors.LinearSegmentedColormap.from_list(name, colors) + if not as_cmap: + rgb_array = pal(np.linspace(0, 1, int(n_colors)))[:, :3] # no alpha + pal = _ColorPalette(map(tuple, rgb_array)) + return pal + + +def xkcd_palette(colors): + """Make a palette with color names from the xkcd color survey. + + See xkcd for the full list of colors: https://xkcd.com/color/rgb/ + + This is just a simple wrapper around the ``grplot_seaborn.xkcd_rgb`` dictionary. + + Parameters + ---------- + colors : list of strings + List of keys in the ``grplot_seaborn.xkcd_rgb`` dictionary. + + Returns + ------- + palette : seaborn color palette + Returns the list of colors as RGB tuples in an object that behaves like + other seaborn color palettes. + + See Also + -------- + crayon_palette : Make a palette with Crayola crayon colors. + + """ + palette = [xkcd_rgb[name] for name in colors] + return color_palette(palette, len(palette)) + + +def crayon_palette(colors): + """Make a palette with color names from Crayola crayons. + + Colors are taken from here: + https://en.wikipedia.org/wiki/List_of_Crayola_crayon_colors + + This is just a simple wrapper around the ``grplot_seaborn.crayons`` dictionary. + + Parameters + ---------- + colors : list of strings + List of keys in the ``grplot_seaborn.crayons`` dictionary. + + Returns + ------- + palette : seaborn color palette + Returns the list of colors as rgb tuples in an object that behaves like + other seaborn color palettes. + + See Also + -------- + xkcd_palette : Make a palette with named colors from the XKCD color survey. + + """ + palette = [crayons[name] for name in colors] + return color_palette(palette, len(palette)) + + +def cubehelix_palette(n_colors=6, start=0, rot=.4, gamma=1.0, hue=0.8, + light=.85, dark=.15, reverse=False, as_cmap=False): + """Make a sequential palette from the cubehelix system. + + This produces a colormap with linearly-decreasing (or increasing) + brightness. That means that information will be preserved if printed to + black and white or viewed by someone who is colorblind. "cubehelix" is + also available as a matplotlib-based palette, but this function gives the + user more control over the look of the palette and has a different set of + defaults. + + In addition to using this function, it is also possible to generate a + cubehelix palette generally in seaborn using a string-shorthand; see the + example below. + + Parameters + ---------- + n_colors : int + Number of colors in the palette. + start : float, 0 <= start <= 3 + The hue at the start of the helix. + rot : float + Rotations around the hue wheel over the range of the palette. + gamma : float 0 <= gamma + Gamma factor to emphasize darker (gamma < 1) or lighter (gamma > 1) + colors. + hue : float, 0 <= hue <= 1 + Saturation of the colors. + dark : float 0 <= dark <= 1 + Intensity of the darkest color in the palette. + light : float 0 <= light <= 1 + Intensity of the lightest color in the palette. + reverse : bool + If True, the palette will go from dark to light. + as_cmap : bool + If True, return a :class:`matplotlib.colors.Colormap`. + + Returns + ------- + list of RGB tuples or :class:`matplotlib.colors.Colormap` + + See Also + -------- + choose_cubehelix_palette : Launch an interactive widget to select cubehelix + palette parameters. + dark_palette : Create a sequential palette with dark low values. + light_palette : Create a sequential palette with bright low values. + + References + ---------- + Green, D. A. (2011). "A colour scheme for the display of astronomical + intensity images". Bulletin of the Astromical Society of India, Vol. 39, + p. 289-295. + + Examples + -------- + + Generate the default palette: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns; sns.set_theme() + >>> sns.palplot(sns.cubehelix_palette()) + + Rotate backwards from the same starting location: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.cubehelix_palette(rot=-.4)) + + Use a different starting point and shorter rotation: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.cubehelix_palette(start=2.8, rot=.1)) + + Reverse the direction of the lightness ramp: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.cubehelix_palette(reverse=True)) + + Generate a colormap object: + + .. plot:: + :context: close-figs + + >>> from numpy import arange + >>> x = arange(25).reshape(5, 5) + >>> cmap = sns.cubehelix_palette(as_cmap=True) + >>> ax = sns.heatmap(x, cmap=cmap) + + Use the full lightness range: + + .. plot:: + :context: close-figs + + >>> cmap = sns.cubehelix_palette(dark=0, light=1, as_cmap=True) + >>> ax = sns.heatmap(x, cmap=cmap) + + Use through the :func:`color_palette` interface: + + .. plot:: + :context: close-figs + + >>> sns.palplot(sns.color_palette("ch:2,r=.2,l=.6")) + + """ + def get_color_function(p0, p1): + # Copied from matplotlib because it lives in private module + def color(x): + # Apply gamma factor to emphasise low or high intensity values + xg = x ** gamma + + # Calculate amplitude and angle of deviation from the black + # to white diagonal in the plane of constant + # perceived intensity. + a = hue * xg * (1 - xg) / 2 + + phi = 2 * np.pi * (start / 3 + rot * x) + + return xg + a * (p0 * np.cos(phi) + p1 * np.sin(phi)) + return color + + cdict = { + "red": get_color_function(-0.14861, 1.78277), + "green": get_color_function(-0.29227, -0.90649), + "blue": get_color_function(1.97294, 0.0), + } + + cmap = mpl.colors.LinearSegmentedColormap("cubehelix", cdict) + + x = np.linspace(light, dark, int(n_colors)) + pal = cmap(x)[:, :3].tolist() + if reverse: + pal = pal[::-1] + + if as_cmap: + x_256 = np.linspace(light, dark, 256) + if reverse: + x_256 = x_256[::-1] + pal_256 = cmap(x_256) + cmap = mpl.colors.ListedColormap(pal_256, "seaborn_cubehelix") + return cmap + else: + return _ColorPalette(pal) + + +def _parse_cubehelix_args(argstr): + """Turn stringified cubehelix params into args/kwargs.""" + + if argstr.startswith("ch:"): + argstr = argstr[3:] + + if argstr.endswith("_r"): + reverse = True + argstr = argstr[:-2] + else: + reverse = False + + if not argstr: + return [], {"reverse": reverse} + + all_args = argstr.split(",") + + args = [float(a.strip(" ")) for a in all_args if "=" not in a] + + kwargs = [a.split("=") for a in all_args if "=" in a] + kwargs = {k.strip(" "): float(v.strip(" ")) for k, v in kwargs} + + kwarg_map = dict( + s="start", r="rot", g="gamma", + h="hue", l="light", d="dark", # noqa: E741 + ) + + kwargs = {kwarg_map.get(k, k): v for k, v in kwargs.items()} + + if reverse: + kwargs["reverse"] = True + + return args, kwargs + + +def set_color_codes(palette="deep"): + """Change how matplotlib color shorthands are interpreted. + + Calling this will change how shorthand codes like "b" or "g" + are interpreted by matplotlib in subsequent plots. + + Parameters + ---------- + palette : {deep, muted, pastel, dark, bright, colorblind} + Named seaborn palette to use as the source of colors. + + See Also + -------- + set : Color codes can be set through the high-level seaborn style + manager. + set_palette : Color codes can also be set through the function that + sets the matplotlib color cycle. + + Examples + -------- + + Map matplotlib color codes to the default seaborn palette. + + .. plot:: + :context: close-figs + + >>> import matplotlib.pyplot as plt + >>> import grplot_seaborn as sns; sns.set_theme() + >>> sns.set_color_codes() + >>> _ = plt.plot([0, 1], color="r") + + Use a different seaborn palette. + + .. plot:: + :context: close-figs + + >>> sns.set_color_codes("dark") + >>> _ = plt.plot([0, 1], color="g") + >>> _ = plt.plot([0, 2], color="m") + + """ + if palette == "reset": + colors = [(0., 0., 1.), (0., .5, 0.), (1., 0., 0.), (.75, 0., .75), + (.75, .75, 0.), (0., .75, .75), (0., 0., 0.)] + elif not isinstance(palette, str): + err = "set_color_codes requires a named seaborn palette" + raise TypeError(err) + elif palette in SEABORN_PALETTES: + if not palette.endswith("6"): + palette = palette + "6" + colors = SEABORN_PALETTES[palette] + [(.1, .1, .1)] + else: + err = "Cannot set colors with palette '{}'".format(palette) + raise ValueError(err) + + for code, color in zip("bgrmyck", colors): + rgb = mpl.colors.colorConverter.to_rgb(color) + mpl.colors.colorConverter.colors[code] = rgb + mpl.colors.colorConverter.cache[code] = rgb diff --git a/grplot_seaborn/rcmod.py b/grplot_seaborn/rcmod.py new file mode 100644 index 0000000..395c376 --- /dev/null +++ b/grplot_seaborn/rcmod.py @@ -0,0 +1,550 @@ +"""Control plot style and scaling using the matplotlib rcParams interface.""" +import warnings +import functools +from distutils.version import LooseVersion +import matplotlib as mpl +from cycler import cycler +from . import palettes + + +__all__ = ["set_theme", "set", "reset_defaults", "reset_orig", + "axes_style", "set_style", "plotting_context", "set_context", + "set_palette"] + + +_style_keys = [ + + "axes.facecolor", + "axes.edgecolor", + "axes.grid", + "axes.axisbelow", + "axes.labelcolor", + + "figure.facecolor", + + "grid.color", + "grid.linestyle", + + "text.color", + + "xtick.color", + "ytick.color", + "xtick.direction", + "ytick.direction", + "lines.solid_capstyle", + + "patch.edgecolor", + "patch.force_edgecolor", + + "image.cmap", + "font.family", + "font.sans-serif", + + "xtick.bottom", + "xtick.top", + "ytick.left", + "ytick.right", + + "axes.spines.left", + "axes.spines.bottom", + "axes.spines.right", + "axes.spines.top", + +] + +_context_keys = [ + + "font.size", + "axes.labelsize", + "axes.titlesize", + "xtick.labelsize", + "ytick.labelsize", + "legend.fontsize", + + "axes.linewidth", + "grid.linewidth", + "lines.linewidth", + "lines.markersize", + "patch.linewidth", + + "xtick.major.width", + "ytick.major.width", + "xtick.minor.width", + "ytick.minor.width", + + "xtick.major.size", + "ytick.major.size", + "xtick.minor.size", + "ytick.minor.size", + +] + +if LooseVersion(mpl.__version__) >= "3.0": + _context_keys.append("legend.title_fontsize") + + +def set_theme(context="notebook", style="darkgrid", palette="deep", + font="sans-serif", font_scale=1, color_codes=True, rc=None): + """ + Set aspects of the visual theme for all matplotlib and seaborn plots. + + This function changes the global defaults for all plots using the + :ref:`matplotlib rcParams system `. + The themeing is decomposed into several distinct sets of parameter values. + + The options are illustrated in the :doc:`aesthetics <../tutorial/aesthetics>` + and :doc:`color palette <../tutorial/color_palettes>` tutorials. + + Parameters + ---------- + context : string or dict + Scaling parameters, see :func:`plotting_context`. + style : string or dict + Axes style parameters, see :func:`axes_style`. + palette : string or sequence + Color palette, see :func:`color_palette`. + font : string + Font family, see matplotlib font manager. + font_scale : float, optional + Separate scaling factor to independently scale the size of the + font elements. + color_codes : bool + If ``True`` and ``palette`` is a seaborn palette, remap the shorthand + color codes (e.g. "b", "g", "r", etc.) to the colors from this palette. + rc : dict or None + Dictionary of rc parameter mappings to override the above. + + Examples + -------- + + .. include:: ../docstrings/set_theme.rst + + """ + set_context(context, font_scale) + set_style(style, rc={"font.family": font}) + set_palette(palette, color_codes=color_codes) + if rc is not None: + mpl.rcParams.update(rc) + + +def set(*args, **kwargs): + """ + Alias for :func:`set_theme`, which is the preferred interface. + + This function may be removed in the future. + """ + set_theme(*args, **kwargs) + + +def reset_defaults(): + """Restore all RC params to default settings.""" + mpl.rcParams.update(mpl.rcParamsDefault) + + +def reset_orig(): + """Restore all RC params to original settings (respects custom rc).""" + from . import _orig_rc_params + with warnings.catch_warnings(): + warnings.simplefilter('ignore', mpl.cbook.MatplotlibDeprecationWarning) + mpl.rcParams.update(_orig_rc_params) + + +def axes_style(style=None, rc=None): + """ + Get the parameters that control the general style of the plots. + + The style parameters control properties like the color of the background and + whether a grid is enabled by default. This is accomplished using the + :ref:`matplotlib rcParams system `. + + The options are illustrated in the + :doc:`aesthetics tutorial <../tutorial/aesthetics>`. + + This function can also be used as a context manager to temporarily + alter the global defaults. See :func:`set_theme` or :func:`set_style` + to modify the global defaults for all plots. + + Parameters + ---------- + style : None, dict, or one of {darkgrid, whitegrid, dark, white, ticks} + A dictionary of parameters or the name of a preconfigured style. + rc : dict, optional + Parameter mappings to override the values in the preset seaborn + style dictionaries. This only updates parameters that are + considered part of the style definition. + + Examples + -------- + + .. include:: ../docstrings/axes_style.rst + + """ + if style is None: + style_dict = {k: mpl.rcParams[k] for k in _style_keys} + + elif isinstance(style, dict): + style_dict = style + + else: + styles = ["white", "dark", "whitegrid", "darkgrid", "ticks"] + if style not in styles: + raise ValueError("style must be one of %s" % ", ".join(styles)) + + # Define colors here + dark_gray = ".15" + light_gray = ".8" + + # Common parameters + style_dict = { + + "figure.facecolor": "white", + "axes.labelcolor": dark_gray, + + "xtick.direction": "out", + "ytick.direction": "out", + "xtick.color": dark_gray, + "ytick.color": dark_gray, + + "axes.axisbelow": True, + "grid.linestyle": "-", + + + "text.color": dark_gray, + "font.family": ["sans-serif"], + "font.sans-serif": ["Arial", "DejaVu Sans", "Liberation Sans", + "Bitstream Vera Sans", "sans-serif"], + + + "lines.solid_capstyle": "round", + "patch.edgecolor": "w", + "patch.force_edgecolor": True, + + "image.cmap": "rocket", + + "xtick.top": False, + "ytick.right": False, + + } + + # Set grid on or off + if "grid" in style: + style_dict.update({ + "axes.grid": True, + }) + else: + style_dict.update({ + "axes.grid": False, + }) + + # Set the color of the background, spines, and grids + if style.startswith("dark"): + style_dict.update({ + + "axes.facecolor": "#EAEAF2", + "axes.edgecolor": "white", + "grid.color": "white", + + "axes.spines.left": True, + "axes.spines.bottom": True, + "axes.spines.right": True, + "axes.spines.top": True, + + }) + + elif style == "whitegrid": + style_dict.update({ + + "axes.facecolor": "white", + "axes.edgecolor": light_gray, + "grid.color": light_gray, + + "axes.spines.left": True, + "axes.spines.bottom": True, + "axes.spines.right": True, + "axes.spines.top": True, + + }) + + elif style in ["white", "ticks"]: + style_dict.update({ + + "axes.facecolor": "white", + "axes.edgecolor": dark_gray, + "grid.color": light_gray, + + "axes.spines.left": True, + "axes.spines.bottom": True, + "axes.spines.right": True, + "axes.spines.top": True, + + }) + + # Show or hide the axes ticks + if style == "ticks": + style_dict.update({ + "xtick.bottom": True, + "ytick.left": True, + }) + else: + style_dict.update({ + "xtick.bottom": False, + "ytick.left": False, + }) + + # Remove entries that are not defined in the base list of valid keys + # This lets us handle matplotlib <=/> 2.0 + style_dict = {k: v for k, v in style_dict.items() if k in _style_keys} + + # Override these settings with the provided rc dictionary + if rc is not None: + rc = {k: v for k, v in rc.items() if k in _style_keys} + style_dict.update(rc) + + # Wrap in an _AxesStyle object so this can be used in a with statement + style_object = _AxesStyle(style_dict) + + return style_object + + +def set_style(style=None, rc=None): + """ + Set the parameters that control the general style of the plots. + + The style parameters control properties like the color of the background and + whether a grid is enabled by default. This is accomplished using the + :ref:`matplotlib rcParams system `. + + The options are illustrated in the + :doc:`aesthetics tutorial <../tutorial/aesthetics>`. + + See :func:`axes_style` to get the parameter values. + + Parameters + ---------- + style : dict, or one of {darkgrid, whitegrid, dark, white, ticks} + A dictionary of parameters or the name of a preconfigured style. + rc : dict, optional + Parameter mappings to override the values in the preset seaborn + style dictionaries. This only updates parameters that are + considered part of the style definition. + + Examples + -------- + + .. include:: ../docstrings/set_style.rst + + """ + style_object = axes_style(style, rc) + mpl.rcParams.update(style_object) + + +def plotting_context(context=None, font_scale=1, rc=None): + """ + Get the parameters that control the scaling of plot elements. + + This affects things like the size of the labels, lines, and other elements + of the plot, but not the overall style. This is accomplished using the + :ref:`matplotlib rcParams system `. + + The base context is "notebook", and the other contexts are "paper", "talk", + and "poster", which are version of the notebook parameters scaled by different + values. Font elements can also be scaled independently of (but relative to) + the other values. + + This function can also be used as a context manager to temporarily + alter the global defaults. See :func:`set_theme` or :func:`set_context` + to modify the global defaults for all plots. + + Parameters + ---------- + context : None, dict, or one of {paper, notebook, talk, poster} + A dictionary of parameters or the name of a preconfigured set. + font_scale : float, optional + Separate scaling factor to independently scale the size of the + font elements. + rc : dict, optional + Parameter mappings to override the values in the preset seaborn + context dictionaries. This only updates parameters that are + considered part of the context definition. + + Examples + -------- + + .. include:: ../docstrings/plotting_context.rst + + """ + if context is None: + context_dict = {k: mpl.rcParams[k] for k in _context_keys} + + elif isinstance(context, dict): + context_dict = context + + else: + + contexts = ["paper", "notebook", "talk", "poster"] + if context not in contexts: + raise ValueError("context must be in %s" % ", ".join(contexts)) + + # Set up dictionary of default parameters + texts_base_context = { + + "font.size": 12, + "axes.labelsize": 12, + "axes.titlesize": 12, + "xtick.labelsize": 11, + "ytick.labelsize": 11, + "legend.fontsize": 11, + + } + + if LooseVersion(mpl.__version__) >= "3.0": + texts_base_context["legend.title_fontsize"] = 12 + + base_context = { + + "axes.linewidth": 1.25, + "grid.linewidth": 1, + "lines.linewidth": 1.5, + "lines.markersize": 6, + "patch.linewidth": 1, + + "xtick.major.width": 1.25, + "ytick.major.width": 1.25, + "xtick.minor.width": 1, + "ytick.minor.width": 1, + + "xtick.major.size": 6, + "ytick.major.size": 6, + "xtick.minor.size": 4, + "ytick.minor.size": 4, + + } + base_context.update(texts_base_context) + + # Scale all the parameters by the same factor depending on the context + scaling = dict(paper=.8, notebook=1, talk=1.5, poster=2)[context] + context_dict = {k: v * scaling for k, v in base_context.items()} + + # Now independently scale the fonts + font_keys = texts_base_context.keys() + font_dict = {k: context_dict[k] * font_scale for k in font_keys} + context_dict.update(font_dict) + + # Override these settings with the provided rc dictionary + if rc is not None: + rc = {k: v for k, v in rc.items() if k in _context_keys} + context_dict.update(rc) + + # Wrap in a _PlottingContext object so this can be used in a with statement + context_object = _PlottingContext(context_dict) + + return context_object + + +def set_context(context=None, font_scale=1, rc=None): + """ + Set the parameters that control the scaling of plot elements. + + This affects things like the size of the labels, lines, and other elements + of the plot, but not the overall style. This is accomplished using the + :ref:`matplotlib rcParams system `. + + The base context is "notebook", and the other contexts are "paper", "talk", + and "poster", which are version of the notebook parameters scaled by different + values. Font elements can also be scaled independently of (but relative to) + the other values. + + See :func:`plotting_context` to get the parameter values. + + Parameters + ---------- + context : dict, or one of {paper, notebook, talk, poster} + A dictionary of parameters or the name of a preconfigured set. + font_scale : float, optional + Separate scaling factor to independently scale the size of the + font elements. + rc : dict, optional + Parameter mappings to override the values in the preset seaborn + context dictionaries. This only updates parameters that are + considered part of the context definition. + + Examples + -------- + + .. include:: ../docstrings/set_context.rst + + """ + context_object = plotting_context(context, font_scale, rc) + mpl.rcParams.update(context_object) + + +class _RCAesthetics(dict): + def __enter__(self): + rc = mpl.rcParams + self._orig = {k: rc[k] for k in self._keys} + self._set(self) + + def __exit__(self, exc_type, exc_value, exc_tb): + self._set(self._orig) + + def __call__(self, func): + @functools.wraps(func) + def wrapper(*args, **kwargs): + with self: + return func(*args, **kwargs) + return wrapper + + +class _AxesStyle(_RCAesthetics): + """Light wrapper on a dict to set style temporarily.""" + _keys = _style_keys + _set = staticmethod(set_style) + + +class _PlottingContext(_RCAesthetics): + """Light wrapper on a dict to set context temporarily.""" + _keys = _context_keys + _set = staticmethod(set_context) + + +def set_palette(palette, n_colors=None, desat=None, color_codes=False): + """Set the matplotlib color cycle using a seaborn palette. + + Parameters + ---------- + palette : seaborn color paltte | matplotlib colormap | hls | husl + Palette definition. Should be something that :func:`color_palette` + can process. + n_colors : int + Number of colors in the cycle. The default number of colors will depend + on the format of ``palette``, see the :func:`color_palette` + documentation for more information. + desat : float + Proportion to desaturate each color by. + color_codes : bool + If ``True`` and ``palette`` is a seaborn palette, remap the shorthand + color codes (e.g. "b", "g", "r", etc.) to the colors from this palette. + + Examples + -------- + >>> set_palette("Reds") + + >>> set_palette("Set1", 8, .75) + + See Also + -------- + color_palette : build a color palette or set the color cycle temporarily + in a ``with`` statement. + set_context : set parameters to scale plot elements + set_style : set the default parameters for figure style + + """ + colors = palettes.color_palette(palette, n_colors, desat) + cyl = cycler('color', colors) + mpl.rcParams['axes.prop_cycle'] = cyl + mpl.rcParams["patch.facecolor"] = colors[0] + if color_codes: + try: + palettes.set_color_codes(palette) + except (ValueError, TypeError): + pass diff --git a/grplot_seaborn/regression.py b/grplot_seaborn/regression.py new file mode 100644 index 0000000..2af7dd9 --- /dev/null +++ b/grplot_seaborn/regression.py @@ -0,0 +1,1121 @@ +"""Plotting functions for linear models (broadly construed).""" +import copy +from textwrap import dedent +import warnings +import numpy as np +import pandas as pd +from scipy.spatial import distance +import matplotlib as mpl +import matplotlib.pyplot as plt + +try: + import statsmodels + assert statsmodels + _has_statsmodels = True +except ImportError: + _has_statsmodels = False + +from . import utils +from . import algorithms as algo +from .axisgrid import FacetGrid, _facet_docs +from ._decorators import _deprecate_positional_args + + +__all__ = ["lmplot", "regplot", "residplot"] + + +class _LinearPlotter(object): + """Base class for plotting relational data in tidy format. + + To get anything useful done you'll have to inherit from this, but setup + code that can be abstracted out should be put here. + + """ + def establish_variables(self, data, **kws): + """Extract variables from data or use directly.""" + self.data = data + + # Validate the inputs + any_strings = any([isinstance(v, str) for v in kws.values()]) + if any_strings and data is None: + raise ValueError("Must pass `data` if using named variables.") + + # Set the variables + for var, val in kws.items(): + if isinstance(val, str): + vector = data[val] + elif isinstance(val, list): + vector = np.asarray(val) + else: + vector = val + if vector is not None and vector.shape != (1,): + vector = np.squeeze(vector) + if np.ndim(vector) > 1: + err = "regplot inputs must be 1d" + raise ValueError(err) + setattr(self, var, vector) + + def dropna(self, *vars): + """Remove observations with missing data.""" + vals = [getattr(self, var) for var in vars] + vals = [v for v in vals if v is not None] + not_na = np.all(np.column_stack([pd.notnull(v) for v in vals]), axis=1) + for var in vars: + val = getattr(self, var) + if val is not None: + setattr(self, var, val[not_na]) + + def plot(self, ax): + raise NotImplementedError + + +class _RegressionPlotter(_LinearPlotter): + """Plotter for numeric independent variables with regression model. + + This does the computations and drawing for the `regplot` function, and + is thus also used indirectly by `lmplot`. + """ + def __init__(self, x, y, data=None, x_estimator=None, x_bins=None, + x_ci="ci", scatter=True, fit_reg=True, ci=95, n_boot=1000, + units=None, seed=None, order=1, logistic=False, lowess=False, + robust=False, logx=False, x_partial=None, y_partial=None, + truncate=False, dropna=True, x_jitter=None, y_jitter=None, + color=None, label=None): + + # Set member attributes + self.x_estimator = x_estimator + self.ci = ci + self.x_ci = ci if x_ci == "ci" else x_ci + self.n_boot = n_boot + self.seed = seed + self.scatter = scatter + self.fit_reg = fit_reg + self.order = order + self.logistic = logistic + self.lowess = lowess + self.robust = robust + self.logx = logx + self.truncate = truncate + self.x_jitter = x_jitter + self.y_jitter = y_jitter + self.color = color + self.label = label + + # Validate the regression options: + if sum((order > 1, logistic, robust, lowess, logx)) > 1: + raise ValueError("Mutually exclusive regression options.") + + # Extract the data vals from the arguments or passed dataframe + self.establish_variables(data, x=x, y=y, units=units, + x_partial=x_partial, y_partial=y_partial) + + # Drop null observations + if dropna: + self.dropna("x", "y", "units", "x_partial", "y_partial") + + # Regress nuisance variables out of the data + if self.x_partial is not None: + self.x = self.regress_out(self.x, self.x_partial) + if self.y_partial is not None: + self.y = self.regress_out(self.y, self.y_partial) + + # Possibly bin the predictor variable, which implies a point estimate + if x_bins is not None: + self.x_estimator = np.mean if x_estimator is None else x_estimator + x_discrete, x_bins = self.bin_predictor(x_bins) + self.x_discrete = x_discrete + else: + self.x_discrete = self.x + + # Disable regression in case of singleton inputs + if len(self.x) <= 1: + self.fit_reg = False + + # Save the range of the x variable for the grid later + if self.fit_reg: + self.x_range = self.x.min(), self.x.max() + + @property + def scatter_data(self): + """Data where each observation is a point.""" + x_j = self.x_jitter + if x_j is None: + x = self.x + else: + x = self.x + np.random.uniform(-x_j, x_j, len(self.x)) + + y_j = self.y_jitter + if y_j is None: + y = self.y + else: + y = self.y + np.random.uniform(-y_j, y_j, len(self.y)) + + return x, y + + @property + def estimate_data(self): + """Data with a point estimate and CI for each discrete x value.""" + x, y = self.x_discrete, self.y + vals = sorted(np.unique(x)) + points, cis = [], [] + + for val in vals: + + # Get the point estimate of the y variable + _y = y[x == val] + est = self.x_estimator(_y) + points.append(est) + + # Compute the confidence interval for this estimate + if self.x_ci is None: + cis.append(None) + else: + units = None + if self.x_ci == "sd": + sd = np.std(_y) + _ci = est - sd, est + sd + else: + if self.units is not None: + units = self.units[x == val] + boots = algo.bootstrap(_y, + func=self.x_estimator, + n_boot=self.n_boot, + units=units, + seed=self.seed) + _ci = utils.ci(boots, self.x_ci) + cis.append(_ci) + + return vals, points, cis + + def fit_regression(self, ax=None, x_range=None, grid=None): + """Fit the regression model.""" + # Create the grid for the regression + if grid is None: + if self.truncate: + x_min, x_max = self.x_range + else: + if ax is None: + x_min, x_max = x_range + else: + x_min, x_max = ax.get_xlim() + grid = np.linspace(x_min, x_max, 100) + ci = self.ci + + # Fit the regression + if self.order > 1: + yhat, yhat_boots = self.fit_poly(grid, self.order) + elif self.logistic: + from statsmodels.genmod.generalized_linear_model import GLM + from statsmodels.genmod.families import Binomial + yhat, yhat_boots = self.fit_statsmodels(grid, GLM, + family=Binomial()) + elif self.lowess: + ci = None + grid, yhat = self.fit_lowess() + elif self.robust: + from statsmodels.robust.robust_linear_model import RLM + yhat, yhat_boots = self.fit_statsmodels(grid, RLM) + elif self.logx: + yhat, yhat_boots = self.fit_logx(grid) + else: + yhat, yhat_boots = self.fit_fast(grid) + + # Compute the confidence interval at each grid point + if ci is None: + err_bands = None + else: + err_bands = utils.ci(yhat_boots, ci, axis=0) + + return grid, yhat, err_bands + + def fit_fast(self, grid): + """Low-level regression and prediction using linear algebra.""" + def reg_func(_x, _y): + return np.linalg.pinv(_x).dot(_y) + + X, y = np.c_[np.ones(len(self.x)), self.x], self.y + grid = np.c_[np.ones(len(grid)), grid] + yhat = grid.dot(reg_func(X, y)) + if self.ci is None: + return yhat, None + + beta_boots = algo.bootstrap(X, y, + func=reg_func, + n_boot=self.n_boot, + units=self.units, + seed=self.seed).T + yhat_boots = grid.dot(beta_boots).T + return yhat, yhat_boots + + def fit_poly(self, grid, order): + """Regression using numpy polyfit for higher-order trends.""" + def reg_func(_x, _y): + return np.polyval(np.polyfit(_x, _y, order), grid) + + x, y = self.x, self.y + yhat = reg_func(x, y) + if self.ci is None: + return yhat, None + + yhat_boots = algo.bootstrap(x, y, + func=reg_func, + n_boot=self.n_boot, + units=self.units, + seed=self.seed) + return yhat, yhat_boots + + def fit_statsmodels(self, grid, model, **kwargs): + """More general regression function using statsmodels objects.""" + import statsmodels.genmod.generalized_linear_model as glm + X, y = np.c_[np.ones(len(self.x)), self.x], self.y + grid = np.c_[np.ones(len(grid)), grid] + + def reg_func(_x, _y): + try: + yhat = model(_y, _x, **kwargs).fit().predict(grid) + except glm.PerfectSeparationError: + yhat = np.empty(len(grid)) + yhat.fill(np.nan) + return yhat + + yhat = reg_func(X, y) + if self.ci is None: + return yhat, None + + yhat_boots = algo.bootstrap(X, y, + func=reg_func, + n_boot=self.n_boot, + units=self.units, + seed=self.seed) + return yhat, yhat_boots + + def fit_lowess(self): + """Fit a locally-weighted regression, which returns its own grid.""" + from statsmodels.nonparametric.smoothers_lowess import lowess + grid, yhat = lowess(self.y, self.x).T + return grid, yhat + + def fit_logx(self, grid): + """Fit the model in log-space.""" + X, y = np.c_[np.ones(len(self.x)), self.x], self.y + grid = np.c_[np.ones(len(grid)), np.log(grid)] + + def reg_func(_x, _y): + _x = np.c_[_x[:, 0], np.log(_x[:, 1])] + return np.linalg.pinv(_x).dot(_y) + + yhat = grid.dot(reg_func(X, y)) + if self.ci is None: + return yhat, None + + beta_boots = algo.bootstrap(X, y, + func=reg_func, + n_boot=self.n_boot, + units=self.units, + seed=self.seed).T + yhat_boots = grid.dot(beta_boots).T + return yhat, yhat_boots + + def bin_predictor(self, bins): + """Discretize a predictor by assigning value to closest bin.""" + x = self.x + if np.isscalar(bins): + percentiles = np.linspace(0, 100, bins + 2)[1:-1] + bins = np.c_[np.percentile(x, percentiles)] + else: + bins = np.c_[np.ravel(bins)] + + dist = distance.cdist(np.c_[x], bins) + x_binned = bins[np.argmin(dist, axis=1)].ravel() + + return x_binned, bins.ravel() + + def regress_out(self, a, b): + """Regress b from a keeping a's original mean.""" + a_mean = a.mean() + a = a - a_mean + b = b - b.mean() + b = np.c_[b] + a_prime = a - b.dot(np.linalg.pinv(b).dot(a)) + return np.asarray(a_prime + a_mean).reshape(a.shape) + + def plot(self, ax, scatter_kws, line_kws): + """Draw the full plot.""" + # Insert the plot label into the correct set of keyword arguments + if self.scatter: + scatter_kws["label"] = self.label + else: + line_kws["label"] = self.label + + # Use the current color cycle state as a default + if self.color is None: + lines, = ax.plot([], []) + color = lines.get_color() + lines.remove() + else: + color = self.color + + # Ensure that color is hex to avoid matplotlib weirdness + color = mpl.colors.rgb2hex(mpl.colors.colorConverter.to_rgb(color)) + + # Let color in keyword arguments override overall plot color + scatter_kws.setdefault("color", color) + line_kws.setdefault("color", color) + + # Draw the constituent plots + if self.scatter: + self.scatterplot(ax, scatter_kws) + + if self.fit_reg: + self.lineplot(ax, line_kws) + + # Label the axes + if hasattr(self.x, "name"): + ax.set_xlabel(self.x.name) + if hasattr(self.y, "name"): + ax.set_ylabel(self.y.name) + + def scatterplot(self, ax, kws): + """Draw the data.""" + # Treat the line-based markers specially, explicitly setting larger + # linewidth than is provided by the seaborn style defaults. + # This would ideally be handled better in matplotlib (i.e., distinguish + # between edgewidth for solid glyphs and linewidth for line glyphs + # but this should do for now. + line_markers = ["1", "2", "3", "4", "+", "x", "|", "_"] + if self.x_estimator is None: + if "marker" in kws and kws["marker"] in line_markers: + lw = mpl.rcParams["lines.linewidth"] + else: + lw = mpl.rcParams["lines.markeredgewidth"] + kws.setdefault("linewidths", lw) + + if not hasattr(kws['color'], 'shape') or kws['color'].shape[1] < 4: + kws.setdefault("alpha", .8) + + x, y = self.scatter_data + ax.scatter(x, y, **kws) + else: + # TODO abstraction + ci_kws = {"color": kws["color"]} + ci_kws["linewidth"] = mpl.rcParams["lines.linewidth"] * 1.75 + kws.setdefault("s", 50) + + xs, ys, cis = self.estimate_data + if [ci for ci in cis if ci is not None]: + for x, ci in zip(xs, cis): + ax.plot([x, x], ci, **ci_kws) + ax.scatter(xs, ys, **kws) + + def lineplot(self, ax, kws): + """Draw the model.""" + # Fit the regression model + grid, yhat, err_bands = self.fit_regression(ax) + edges = grid[0], grid[-1] + + # Get set default aesthetics + fill_color = kws["color"] + lw = kws.pop("lw", mpl.rcParams["lines.linewidth"] * 1.5) + kws.setdefault("linewidth", lw) + + # Draw the regression line and confidence interval + line, = ax.plot(grid, yhat, **kws) + if not self.truncate: + line.sticky_edges.x[:] = edges # Prevent mpl from adding margin + if err_bands is not None: + ax.fill_between(grid, *err_bands, facecolor=fill_color, alpha=.15) + + +_regression_docs = dict( + + model_api=dedent("""\ + There are a number of mutually exclusive options for estimating the + regression model. See the :ref:`tutorial ` for more + information.\ + """), + regplot_vs_lmplot=dedent("""\ + The :func:`regplot` and :func:`lmplot` functions are closely related, but + the former is an axes-level function while the latter is a figure-level + function that combines :func:`regplot` and :class:`FacetGrid`.\ + """), + x_estimator=dedent("""\ + x_estimator : callable that maps vector -> scalar, optional + Apply this function to each unique value of ``x`` and plot the + resulting estimate. This is useful when ``x`` is a discrete variable. + If ``x_ci`` is given, this estimate will be bootstrapped and a + confidence interval will be drawn.\ + """), + x_bins=dedent("""\ + x_bins : int or vector, optional + Bin the ``x`` variable into discrete bins and then estimate the central + tendency and a confidence interval. This binning only influences how + the scatterplot is drawn; the regression is still fit to the original + data. This parameter is interpreted either as the number of + evenly-sized (not necessary spaced) bins or the positions of the bin + centers. When this parameter is used, it implies that the default of + ``x_estimator`` is ``numpy.mean``.\ + """), + x_ci=dedent("""\ + x_ci : "ci", "sd", int in [0, 100] or None, optional + Size of the confidence interval used when plotting a central tendency + for discrete values of ``x``. If ``"ci"``, defer to the value of the + ``ci`` parameter. If ``"sd"``, skip bootstrapping and show the + standard deviation of the observations in each bin.\ + """), + scatter=dedent("""\ + scatter : bool, optional + If ``True``, draw a scatterplot with the underlying observations (or + the ``x_estimator`` values).\ + """), + fit_reg=dedent("""\ + fit_reg : bool, optional + If ``True``, estimate and plot a regression model relating the ``x`` + and ``y`` variables.\ + """), + ci=dedent("""\ + ci : int in [0, 100] or None, optional + Size of the confidence interval for the regression estimate. This will + be drawn using translucent bands around the regression line. The + confidence interval is estimated using a bootstrap; for large + datasets, it may be advisable to avoid that computation by setting + this parameter to None.\ + """), + n_boot=dedent("""\ + n_boot : int, optional + Number of bootstrap resamples used to estimate the ``ci``. The default + value attempts to balance time and stability; you may want to increase + this value for "final" versions of plots.\ + """), + units=dedent("""\ + units : variable name in ``data``, optional + If the ``x`` and ``y`` observations are nested within sampling units, + those can be specified here. This will be taken into account when + computing the confidence intervals by performing a multilevel bootstrap + that resamples both units and observations (within unit). This does not + otherwise influence how the regression is estimated or drawn.\ + """), + seed=dedent("""\ + seed : int, numpy.random.Generator, or numpy.random.RandomState, optional + Seed or random number generator for reproducible bootstrapping.\ + """), + order=dedent("""\ + order : int, optional + If ``order`` is greater than 1, use ``numpy.polyfit`` to estimate a + polynomial regression.\ + """), + logistic=dedent("""\ + logistic : bool, optional + If ``True``, assume that ``y`` is a binary variable and use + ``statsmodels`` to estimate a logistic regression model. Note that this + is substantially more computationally intensive than linear regression, + so you may wish to decrease the number of bootstrap resamples + (``n_boot``) or set ``ci`` to None.\ + """), + lowess=dedent("""\ + lowess : bool, optional + If ``True``, use ``statsmodels`` to estimate a nonparametric lowess + model (locally weighted linear regression). Note that confidence + intervals cannot currently be drawn for this kind of model.\ + """), + robust=dedent("""\ + robust : bool, optional + If ``True``, use ``statsmodels`` to estimate a robust regression. This + will de-weight outliers. Note that this is substantially more + computationally intensive than standard linear regression, so you may + wish to decrease the number of bootstrap resamples (``n_boot``) or set + ``ci`` to None.\ + """), + logx=dedent("""\ + logx : bool, optional + If ``True``, estimate a linear regression of the form y ~ log(x), but + plot the scatterplot and regression model in the input space. Note that + ``x`` must be positive for this to work.\ + """), + xy_partial=dedent("""\ + {x,y}_partial : strings in ``data`` or matrices + Confounding variables to regress out of the ``x`` or ``y`` variables + before plotting.\ + """), + truncate=dedent("""\ + truncate : bool, optional + If ``True``, the regression line is bounded by the data limits. If + ``False``, it extends to the ``x`` axis limits. + """), + xy_jitter=dedent("""\ + {x,y}_jitter : floats, optional + Add uniform random noise of this size to either the ``x`` or ``y`` + variables. The noise is added to a copy of the data after fitting the + regression, and only influences the look of the scatterplot. This can + be helpful when plotting variables that take discrete values.\ + """), + scatter_line_kws=dedent("""\ + {scatter,line}_kws : dictionaries + Additional keyword arguments to pass to ``plt.scatter`` and + ``plt.plot``.\ + """), +) +_regression_docs.update(_facet_docs) + + +@_deprecate_positional_args +def lmplot( + *, + x=None, y=None, + data=None, + hue=None, col=None, row=None, # TODO move before data once * is enforced + palette=None, col_wrap=None, height=5, aspect=1, markers="o", + sharex=None, sharey=None, hue_order=None, col_order=None, row_order=None, + legend=True, legend_out=None, x_estimator=None, x_bins=None, + x_ci="ci", scatter=True, fit_reg=True, ci=95, n_boot=1000, + units=None, seed=None, order=1, logistic=False, lowess=False, + robust=False, logx=False, x_partial=None, y_partial=None, + truncate=True, x_jitter=None, y_jitter=None, scatter_kws=None, + line_kws=None, facet_kws=None, size=None, +): + + # Handle deprecations + if size is not None: + height = size + msg = ("The `size` parameter has been renamed to `height`; " + "please update your code.") + warnings.warn(msg, UserWarning) + + if facet_kws is None: + facet_kws = {} + + def facet_kw_deprecation(key, val): + msg = ( + f"{key} is deprecated from the `lmplot` function signature. " + "Please update your code to pass it using `facet_kws`." + ) + if val is not None: + warnings.warn(msg, UserWarning) + facet_kws[key] = val + + facet_kw_deprecation("sharex", sharex) + facet_kw_deprecation("sharey", sharey) + facet_kw_deprecation("legend_out", legend_out) + + if data is None: + raise TypeError("Missing required keyword argument `data`.") + + # Reduce the dataframe to only needed columns + need_cols = [x, y, hue, col, row, units, x_partial, y_partial] + cols = np.unique([a for a in need_cols if a is not None]).tolist() + data = data[cols] + + # Initialize the grid + facets = FacetGrid( + data, row=row, col=col, hue=hue, + palette=palette, + row_order=row_order, col_order=col_order, hue_order=hue_order, + height=height, aspect=aspect, col_wrap=col_wrap, + **facet_kws, + ) + + # Add the markers here as FacetGrid has figured out how many levels of the + # hue variable are needed and we don't want to duplicate that process + if facets.hue_names is None: + n_markers = 1 + else: + n_markers = len(facets.hue_names) + if not isinstance(markers, list): + markers = [markers] * n_markers + if len(markers) != n_markers: + raise ValueError(("markers must be a singeton or a list of markers " + "for each level of the hue variable")) + facets.hue_kws = {"marker": markers} + + def update_datalim(data, x, y, ax, **kws): + xys = np.asarray(data[[x, y]]).astype(float) + ax.update_datalim(xys, updatey=False) + ax.autoscale_view(scaley=False) + + facets.map_dataframe(update_datalim, x=x, y=y) + + # Draw the regression plot on each facet + regplot_kws = dict( + x_estimator=x_estimator, x_bins=x_bins, x_ci=x_ci, + scatter=scatter, fit_reg=fit_reg, ci=ci, n_boot=n_boot, units=units, + seed=seed, order=order, logistic=logistic, lowess=lowess, + robust=robust, logx=logx, x_partial=x_partial, y_partial=y_partial, + truncate=truncate, x_jitter=x_jitter, y_jitter=y_jitter, + scatter_kws=scatter_kws, line_kws=line_kws, + ) + facets.map_dataframe(regplot, x=x, y=y, **regplot_kws) + facets.set_axis_labels(x, y) + + # Add a legend + if legend and (hue is not None) and (hue not in [col, row]): + facets.add_legend() + return facets + + +lmplot.__doc__ = dedent("""\ + Plot data and regression model fits across a FacetGrid. + + This function combines :func:`regplot` and :class:`FacetGrid`. It is + intended as a convenient interface to fit regression models across + conditional subsets of a dataset. + + When thinking about how to assign variables to different facets, a general + rule is that it makes sense to use ``hue`` for the most important + comparison, followed by ``col`` and ``row``. However, always think about + your particular dataset and the goals of the visualization you are + creating. + + {model_api} + + The parameters to this function span most of the options in + :class:`FacetGrid`, although there may be occasional cases where you will + want to use that class and :func:`regplot` directly. + + Parameters + ---------- + x, y : strings, optional + Input variables; these should be column names in ``data``. + {data} + hue, col, row : strings + Variables that define subsets of the data, which will be drawn on + separate facets in the grid. See the ``*_order`` parameters to control + the order of levels of this variable. + {palette} + {col_wrap} + {height} + {aspect} + markers : matplotlib marker code or list of marker codes, optional + Markers for the scatterplot. If a list, each marker in the list will be + used for each level of the ``hue`` variable. + {share_xy} + + .. deprecated:: 0.12.0 + Pass using the `facet_kws` dictionary. + + {{hue,col,row}}_order : lists, optional + Order for the levels of the faceting variables. By default, this will + be the order that the levels appear in ``data`` or, if the variables + are pandas categoricals, the category order. + legend : bool, optional + If ``True`` and there is a ``hue`` variable, add a legend. + {legend_out} + + .. deprecated:: 0.12.0 + Pass using the `facet_kws` dictionary. + + {x_estimator} + {x_bins} + {x_ci} + {scatter} + {fit_reg} + {ci} + {n_boot} + {units} + {seed} + {order} + {logistic} + {lowess} + {robust} + {logx} + {xy_partial} + {truncate} + {xy_jitter} + {scatter_line_kws} + facet_kws : dict + Dictionary of keyword arguments for :class:`FacetGrid`. + + See Also + -------- + regplot : Plot data and a conditional model fit. + FacetGrid : Subplot grid for plotting conditional relationships. + pairplot : Combine :func:`regplot` and :class:`PairGrid` (when used with + ``kind="reg"``). + + Notes + ----- + + {regplot_vs_lmplot} + + Examples + -------- + + These examples focus on basic regression model plots to exhibit the + various faceting options; see the :func:`regplot` docs for demonstrations + of the other options for plotting the data and models. There are also + other examples for how to manipulate plot using the returned object on + the :class:`FacetGrid` docs. + + Plot a simple linear relationship between two variables: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns; sns.set_theme(color_codes=True) + >>> tips = sns.load_dataset("tips") + >>> g = sns.lmplot(x="total_bill", y="tip", data=tips) + + Condition on a third variable and plot the levels in different colors: + + .. plot:: + :context: close-figs + + >>> g = sns.lmplot(x="total_bill", y="tip", hue="smoker", data=tips) + + Use different markers as well as colors so the plot will reproduce to + black-and-white more easily: + + .. plot:: + :context: close-figs + + >>> g = sns.lmplot(x="total_bill", y="tip", hue="smoker", data=tips, + ... markers=["o", "x"]) + + Use a different color palette: + + .. plot:: + :context: close-figs + + >>> g = sns.lmplot(x="total_bill", y="tip", hue="smoker", data=tips, + ... palette="Set1") + + Map ``hue`` levels to colors with a dictionary: + + .. plot:: + :context: close-figs + + >>> g = sns.lmplot(x="total_bill", y="tip", hue="smoker", data=tips, + ... palette=dict(Yes="g", No="m")) + + Plot the levels of the third variable across different columns: + + .. plot:: + :context: close-figs + + >>> g = sns.lmplot(x="total_bill", y="tip", col="smoker", data=tips) + + Change the height and aspect ratio of the facets: + + .. plot:: + :context: close-figs + + >>> g = sns.lmplot(x="size", y="total_bill", hue="day", col="day", + ... data=tips, height=6, aspect=.4, x_jitter=.1) + + Wrap the levels of the column variable into multiple rows: + + .. plot:: + :context: close-figs + + >>> g = sns.lmplot(x="total_bill", y="tip", col="day", hue="day", + ... data=tips, col_wrap=2, height=3) + + Condition on two variables to make a full grid: + + .. plot:: + :context: close-figs + + >>> g = sns.lmplot(x="total_bill", y="tip", row="sex", col="time", + ... data=tips, height=3) + + Use methods on the returned :class:`FacetGrid` instance to further tweak + the plot: + + .. plot:: + :context: close-figs + + >>> g = sns.lmplot(x="total_bill", y="tip", row="sex", col="time", + ... data=tips, height=3) + >>> g = (g.set_axis_labels("Total bill (US Dollars)", "Tip") + ... .set(xlim=(0, 60), ylim=(0, 12), + ... xticks=[10, 30, 50], yticks=[2, 6, 10]) + ... .fig.subplots_adjust(wspace=.02)) + + + + """).format(**_regression_docs) + + +@_deprecate_positional_args +def regplot( + *, + x=None, y=None, + data=None, + x_estimator=None, x_bins=None, x_ci="ci", + scatter=True, fit_reg=True, ci=95, n_boot=1000, units=None, + seed=None, order=1, logistic=False, lowess=False, robust=False, + logx=False, x_partial=None, y_partial=None, + truncate=True, dropna=True, x_jitter=None, y_jitter=None, + label=None, color=None, marker="o", + scatter_kws=None, line_kws=None, ax=None +): + + plotter = _RegressionPlotter(x, y, data, x_estimator, x_bins, x_ci, + scatter, fit_reg, ci, n_boot, units, seed, + order, logistic, lowess, robust, logx, + x_partial, y_partial, truncate, dropna, + x_jitter, y_jitter, color, label) + + if ax is None: + ax = plt.gca() + + scatter_kws = {} if scatter_kws is None else copy.copy(scatter_kws) + scatter_kws["marker"] = marker + line_kws = {} if line_kws is None else copy.copy(line_kws) + plotter.plot(ax, scatter_kws, line_kws) + return ax + + +regplot.__doc__ = dedent("""\ + Plot data and a linear regression model fit. + + {model_api} + + Parameters + ---------- + x, y: string, series, or vector array + Input variables. If strings, these should correspond with column names + in ``data``. When pandas objects are used, axes will be labeled with + the series name. + {data} + {x_estimator} + {x_bins} + {x_ci} + {scatter} + {fit_reg} + {ci} + {n_boot} + {units} + {seed} + {order} + {logistic} + {lowess} + {robust} + {logx} + {xy_partial} + {truncate} + {xy_jitter} + label : string + Label to apply to either the scatterplot or regression line (if + ``scatter`` is ``False``) for use in a legend. + color : matplotlib color + Color to apply to all plot elements; will be superseded by colors + passed in ``scatter_kws`` or ``line_kws``. + marker : matplotlib marker code + Marker to use for the scatterplot glyphs. + {scatter_line_kws} + ax : matplotlib Axes, optional + Axes object to draw the plot onto, otherwise uses the current Axes. + + Returns + ------- + ax : matplotlib Axes + The Axes object containing the plot. + + See Also + -------- + lmplot : Combine :func:`regplot` and :class:`FacetGrid` to plot multiple + linear relationships in a dataset. + jointplot : Combine :func:`regplot` and :class:`JointGrid` (when used with + ``kind="reg"``). + pairplot : Combine :func:`regplot` and :class:`PairGrid` (when used with + ``kind="reg"``). + residplot : Plot the residuals of a linear regression model. + + Notes + ----- + + {regplot_vs_lmplot} + + + It's also easy to combine combine :func:`regplot` and :class:`JointGrid` or + :class:`PairGrid` through the :func:`jointplot` and :func:`pairplot` + functions, although these do not directly accept all of :func:`regplot`'s + parameters. + + Examples + -------- + + Plot the relationship between two variables in a DataFrame: + + .. plot:: + :context: close-figs + + >>> import grplot_seaborn as sns; sns.set_theme(color_codes=True) + >>> tips = sns.load_dataset("tips") + >>> ax = sns.regplot(x="total_bill", y="tip", data=tips) + + Plot with two variables defined as numpy arrays; use a different color: + + .. plot:: + :context: close-figs + + >>> import numpy as np; np.random.seed(8) + >>> mean, cov = [4, 6], [(1.5, .7), (.7, 1)] + >>> x, y = np.random.multivariate_normal(mean, cov, 80).T + >>> ax = sns.regplot(x=x, y=y, color="g") + + Plot with two variables defined as pandas Series; use a different marker: + + .. plot:: + :context: close-figs + + >>> import pandas as pd + >>> x, y = pd.Series(x, name="x_var"), pd.Series(y, name="y_var") + >>> ax = sns.regplot(x=x, y=y, marker="+") + + Use a 68% confidence interval, which corresponds with the standard error + of the estimate, and extend the regression line to the axis limits: + + .. plot:: + :context: close-figs + + >>> ax = sns.regplot(x=x, y=y, ci=68, truncate=False) + + Plot with a discrete ``x`` variable and add some jitter: + + .. plot:: + :context: close-figs + + >>> ax = sns.regplot(x="size", y="total_bill", data=tips, x_jitter=.1) + + Plot with a discrete ``x`` variable showing means and confidence intervals + for unique values: + + .. plot:: + :context: close-figs + + >>> ax = sns.regplot(x="size", y="total_bill", data=tips, + ... x_estimator=np.mean) + + Plot with a continuous variable divided into discrete bins: + + .. plot:: + :context: close-figs + + >>> ax = sns.regplot(x=x, y=y, x_bins=4) + + Fit a higher-order polynomial regression: + + .. plot:: + :context: close-figs + + >>> ans = sns.load_dataset("anscombe") + >>> ax = sns.regplot(x="x", y="y", data=ans.loc[ans.dataset == "II"], + ... scatter_kws={{"s": 80}}, + ... order=2, ci=None) + + Fit a robust regression and don't plot a confidence interval: + + .. plot:: + :context: close-figs + + >>> ax = sns.regplot(x="x", y="y", data=ans.loc[ans.dataset == "III"], + ... scatter_kws={{"s": 80}}, + ... robust=True, ci=None) + + Fit a logistic regression; jitter the y variable and use fewer bootstrap + iterations: + + .. plot:: + :context: close-figs + + >>> tips["big_tip"] = (tips.tip / tips.total_bill) > .175 + >>> ax = sns.regplot(x="total_bill", y="big_tip", data=tips, + ... logistic=True, n_boot=500, y_jitter=.03) + + Fit the regression model using log(x): + + .. plot:: + :context: close-figs + + >>> ax = sns.regplot(x="size", y="total_bill", data=tips, + ... x_estimator=np.mean, logx=True) + + """).format(**_regression_docs) + + +@_deprecate_positional_args +def residplot( + *, + x=None, y=None, + data=None, + lowess=False, x_partial=None, y_partial=None, + order=1, robust=False, dropna=True, label=None, color=None, + scatter_kws=None, line_kws=None, ax=None +): + """Plot the residuals of a linear regression. + + This function will regress y on x (possibly as a robust or polynomial + regression) and then draw a scatterplot of the residuals. You can + optionally fit a lowess smoother to the residual plot, which can + help in determining if there is structure to the residuals. + + Parameters + ---------- + x : vector or string + Data or column name in `data` for the predictor variable. + y : vector or string + Data or column name in `data` for the response variable. + data : DataFrame, optional + DataFrame to use if `x` and `y` are column names. + lowess : boolean, optional + Fit a lowess smoother to the residual scatterplot. + {x, y}_partial : matrix or string(s) , optional + Matrix with same first dimension as `x`, or column name(s) in `data`. + These variables are treated as confounding and are removed from + the `x` or `y` variables before plotting. + order : int, optional + Order of the polynomial to fit when calculating the residuals. + robust : boolean, optional + Fit a robust linear regression when calculating the residuals. + dropna : boolean, optional + If True, ignore observations with missing data when fitting and + plotting. + label : string, optional + Label that will be used in any plot legends. + color : matplotlib color, optional + Color to use for all elements of the plot. + {scatter, line}_kws : dictionaries, optional + Additional keyword arguments passed to scatter() and plot() for drawing + the components of the plot. + ax : matplotlib axis, optional + Plot into this axis, otherwise grab the current axis or make a new + one if not existing. + + Returns + ------- + ax: matplotlib axes + Axes with the regression plot. + + See Also + -------- + regplot : Plot a simple linear regression model. + jointplot : Draw a :func:`residplot` with univariate marginal distributions + (when used with ``kind="resid"``). + + """ + plotter = _RegressionPlotter(x, y, data, ci=None, + order=order, robust=robust, + x_partial=x_partial, y_partial=y_partial, + dropna=dropna, color=color, label=label) + + if ax is None: + ax = plt.gca() + + # Calculate the residual from a linear regression + _, yhat, _ = plotter.fit_regression(grid=plotter.x) + plotter.y = plotter.y - yhat + + # Set the regression option on the plotter + if lowess: + plotter.lowess = True + else: + plotter.fit_reg = False + + # Plot a horizontal line at 0 + ax.axhline(0, ls=":", c=".2") + + # Draw the scatterplot + scatter_kws = {} if scatter_kws is None else scatter_kws.copy() + line_kws = {} if line_kws is None else line_kws.copy() + plotter.plot(ax, scatter_kws, line_kws) + return ax diff --git a/grplot_seaborn/relational.py b/grplot_seaborn/relational.py new file mode 100644 index 0000000..82de653 --- /dev/null +++ b/grplot_seaborn/relational.py @@ -0,0 +1,1157 @@ +import warnings + +import numpy as np +import pandas as pd +import matplotlib as mpl +import matplotlib.pyplot as plt + +from ._core import ( + VectorPlotter, +) +from .utils import ( + ci_to_errsize, + locator_to_legend_entries, + adjust_legend_subtitles, + ci as ci_func +) +from .algorithms import bootstrap +from .axisgrid import FacetGrid, _facet_docs +from ._decorators import _deprecate_positional_args +from ._docstrings import ( + DocstringComponents, + _core_docs, +) + + +__all__ = ["relplot", "scatterplot", "lineplot"] + + +_relational_narrative = DocstringComponents(dict( + + # --- Introductory prose + main_api=""" +The relationship between ``x`` and ``y`` can be shown for different subsets +of the data using the ``hue``, ``size``, and ``style`` parameters. These +parameters control what visual semantics are used to identify the different +subsets. It is possible to show up to three dimensions independently by +using all three semantic types, but this style of plot can be hard to +interpret and is often ineffective. Using redundant semantics (i.e. both +``hue`` and ``style`` for the same variable) can be helpful for making +graphics more accessible. + +See the :ref:`tutorial ` for more information. + """, + + relational_semantic=""" +The default treatment of the ``hue`` (and to a lesser extent, ``size``) +semantic, if present, depends on whether the variable is inferred to +represent "numeric" or "categorical" data. In particular, numeric variables +are represented with a sequential colormap by default, and the legend +entries show regular "ticks" with values that may or may not exist in the +data. This behavior can be controlled through various parameters, as +described and illustrated below. + """, +)) + +_relational_docs = dict( + + # --- Shared function parameters + data_vars=""" +x, y : names of variables in ``data`` or vector data + Input data variables; must be numeric. Can pass data directly or + reference columns in ``data``. + """, + data=""" +data : DataFrame, array, or list of arrays + Input data structure. If ``x`` and ``y`` are specified as names, this + should be a "long-form" DataFrame containing those columns. Otherwise + it is treated as "wide-form" data and grouping variables are ignored. + See the examples for the various ways this parameter can be specified + and the different effects of each. + """, + palette=""" +palette : string, list, dict, or matplotlib colormap + An object that determines how colors are chosen when ``hue`` is used. + It can be the name of a seaborn palette or matplotlib colormap, a list + of colors (anything matplotlib understands), a dict mapping levels + of the ``hue`` variable to colors, or a matplotlib colormap object. + """, + hue_order=""" +hue_order : list + Specified order for the appearance of the ``hue`` variable levels, + otherwise they are determined from the data. Not relevant when the + ``hue`` variable is numeric. + """, + hue_norm=""" +hue_norm : tuple or :class:`matplotlib.colors.Normalize` object + Normalization in data units for colormap applied to the ``hue`` + variable when it is numeric. Not relevant if it is categorical. + """, + sizes=""" +sizes : list, dict, or tuple + An object that determines how sizes are chosen when ``size`` is used. + It can always be a list of size values or a dict mapping levels of the + ``size`` variable to sizes. When ``size`` is numeric, it can also be + a tuple specifying the minimum and maximum size to use such that other + values are normalized within this range. + """, + size_order=""" +size_order : list + Specified order for appearance of the ``size`` variable levels, + otherwise they are determined from the data. Not relevant when the + ``size`` variable is numeric. + """, + size_norm=""" +size_norm : tuple or Normalize object + Normalization in data units for scaling plot objects when the + ``size`` variable is numeric. + """, + dashes=""" +dashes : boolean, list, or dictionary + Object determining how to draw the lines for different levels of the + ``style`` variable. Setting to ``True`` will use default dash codes, or + you can pass a list of dash codes or a dictionary mapping levels of the + ``style`` variable to dash codes. Setting to ``False`` will use solid + lines for all subsets. Dashes are specified as in matplotlib: a tuple + of ``(segment, gap)`` lengths, or an empty string to draw a solid line. + """, + markers=""" +markers : boolean, list, or dictionary + Object determining how to draw the markers for different levels of the + ``style`` variable. Setting to ``True`` will use default markers, or + you can pass a list of markers or a dictionary mapping levels of the + ``style`` variable to markers. Setting to ``False`` will draw + marker-less lines. Markers are specified as in matplotlib. + """, + style_order=""" +style_order : list + Specified order for appearance of the ``style`` variable levels + otherwise they are determined from the data. Not relevant when the + ``style`` variable is numeric. + """, + units=""" +units : vector or key in ``data`` + Grouping variable identifying sampling units. When used, a separate + line will be drawn for each unit with appropriate semantics, but no + legend entry will be added. Useful for showing distribution of + experimental replicates when exact identities are not needed. + """, + estimator=""" +estimator : name of pandas method or callable or None + Method for aggregating across multiple observations of the ``y`` + variable at the same ``x`` level. If ``None``, all observations will + be drawn. + """, + ci=""" +ci : int or "sd" or None + Size of the confidence interval to draw when aggregating with an + estimator. "sd" means to draw the standard deviation of the data. + Setting to ``None`` will skip bootstrapping. + """, + n_boot=""" +n_boot : int + Number of bootstraps to use for computing the confidence interval. + """, + seed=""" +seed : int, numpy.random.Generator, or numpy.random.RandomState + Seed or random number generator for reproducible bootstrapping. + """, + legend=""" +legend : "auto", "brief", "full", or False + How to draw the legend. If "brief", numeric ``hue`` and ``size`` + variables will be represented with a sample of evenly spaced values. + If "full", every group will get an entry in the legend. If "auto", + choose between brief or full representation based on number of levels. + If ``False``, no legend data is added and no legend is drawn. + """, + ax_in=""" +ax : matplotlib Axes + Axes object to draw the plot onto, otherwise uses the current Axes. + """, + ax_out=""" +ax : matplotlib Axes + Returns the Axes object with the plot drawn onto it. + """, + +) + + +_param_docs = DocstringComponents.from_nested_components( + core=_core_docs["params"], + facets=DocstringComponents(_facet_docs), + rel=DocstringComponents(_relational_docs), +) + + +class _RelationalPlotter(VectorPlotter): + + wide_structure = { + "x": "@index", "y": "@values", "hue": "@columns", "style": "@columns", + } + + # TODO where best to define default parameters? + sort = True + + def add_legend_data(self, ax): + """Add labeled artists to represent the different plot semantics.""" + verbosity = self.legend + if isinstance(verbosity, str) and verbosity not in ["auto", "brief", "full"]: + err = "`legend` must be 'auto', 'brief', 'full', or a boolean." + raise ValueError(err) + elif verbosity is True: + verbosity = "auto" + + legend_kwargs = {} + keys = [] + + # Assign a legend title if there is only going to be one sub-legend, + # otherwise, subtitles will be inserted into the texts list with an + # invisible handle (which is a hack) + titles = { + title for title in + (self.variables.get(v, None) for v in ["hue", "size", "style"]) + if title is not None + } + if len(titles) == 1: + legend_title = titles.pop() + else: + legend_title = "" + + title_kws = dict( + visible=False, color="w", s=0, linewidth=0, marker="", dashes="" + ) + + def update(var_name, val_name, **kws): + + key = var_name, val_name + if key in legend_kwargs: + legend_kwargs[key].update(**kws) + else: + keys.append(key) + + legend_kwargs[key] = dict(**kws) + + # Define the maximum number of ticks to use for "brief" legends + brief_ticks = 6 + + # -- Add a legend for hue semantics + brief_hue = self._hue_map.map_type == "numeric" and ( + verbosity == "brief" + or (verbosity == "auto" and len(self._hue_map.levels) > brief_ticks) + ) + if brief_hue: + if isinstance(self._hue_map.norm, mpl.colors.LogNorm): + locator = mpl.ticker.LogLocator(numticks=brief_ticks) + else: + locator = mpl.ticker.MaxNLocator(nbins=brief_ticks) + limits = min(self._hue_map.levels), max(self._hue_map.levels) + hue_levels, hue_formatted_levels = locator_to_legend_entries( + locator, limits, self.plot_data["hue"].infer_objects().dtype + ) + elif self._hue_map.levels is None: + hue_levels = hue_formatted_levels = [] + else: + hue_levels = hue_formatted_levels = self._hue_map.levels + + # Add the hue semantic subtitle + if not legend_title and self.variables.get("hue", None) is not None: + update((self.variables["hue"], "title"), + self.variables["hue"], **title_kws) + + # Add the hue semantic labels + for level, formatted_level in zip(hue_levels, hue_formatted_levels): + if level is not None: + color = self._hue_map(level) + update(self.variables["hue"], formatted_level, color=color) + + # -- Add a legend for size semantics + brief_size = self._size_map.map_type == "numeric" and ( + verbosity == "brief" + or (verbosity == "auto" and len(self._size_map.levels) > brief_ticks) + ) + if brief_size: + # Define how ticks will interpolate between the min/max data values + if isinstance(self._size_map.norm, mpl.colors.LogNorm): + locator = mpl.ticker.LogLocator(numticks=brief_ticks) + else: + locator = mpl.ticker.MaxNLocator(nbins=brief_ticks) + # Define the min/max data values + limits = min(self._size_map.levels), max(self._size_map.levels) + size_levels, size_formatted_levels = locator_to_legend_entries( + locator, limits, self.plot_data["size"].infer_objects().dtype + ) + elif self._size_map.levels is None: + size_levels = size_formatted_levels = [] + else: + size_levels = size_formatted_levels = self._size_map.levels + + # Add the size semantic subtitle + if not legend_title and self.variables.get("size", None) is not None: + update((self.variables["size"], "title"), + self.variables["size"], **title_kws) + + # Add the size semantic labels + for level, formatted_level in zip(size_levels, size_formatted_levels): + if level is not None: + size = self._size_map(level) + update( + self.variables["size"], + formatted_level, + linewidth=size, + s=size, + ) + + # -- Add a legend for style semantics + + # Add the style semantic title + if not legend_title and self.variables.get("style", None) is not None: + update((self.variables["style"], "title"), + self.variables["style"], **title_kws) + + # Add the style semantic labels + if self._style_map.levels is not None: + for level in self._style_map.levels: + if level is not None: + attrs = self._style_map(level) + update( + self.variables["style"], + level, + marker=attrs.get("marker", ""), + dashes=attrs.get("dashes", ""), + ) + + func = getattr(ax, self._legend_func) + + legend_data = {} + legend_order = [] + + for key in keys: + + _, label = key + kws = legend_kwargs[key] + kws.setdefault("color", ".2") + use_kws = {} + for attr in self._legend_attributes + ["visible"]: + if attr in kws: + use_kws[attr] = kws[attr] + artist = func([], [], label=label, **use_kws) + if self._legend_func == "plot": + artist = artist[0] + legend_data[key] = artist + legend_order.append(key) + + self.legend_title = legend_title + self.legend_data = legend_data + self.legend_order = legend_order + + +class _LinePlotter(_RelationalPlotter): + + _legend_attributes = ["color", "linewidth", "marker", "dashes"] + _legend_func = "plot" + + def __init__( + self, *, + data=None, variables={}, + estimator=None, ci=None, n_boot=None, seed=None, + sort=True, err_style=None, err_kws=None, legend=None + ): + + # TODO this is messy, we want the mapping to be agnoistic about + # the kind of plot to draw, but for the time being we need to set + # this information so the SizeMapping can use it + self._default_size_range = ( + np.r_[.5, 2] * mpl.rcParams["lines.linewidth"] + ) + + super().__init__(data=data, variables=variables) + + self.estimator = estimator + self.ci = ci + self.n_boot = n_boot + self.seed = seed + self.sort = sort + self.err_style = err_style + self.err_kws = {} if err_kws is None else err_kws + + self.legend = legend + + def aggregate(self, vals, grouper, units=None): + """Compute an estimate and confidence interval using grouper.""" + func = self.estimator + ci = self.ci + n_boot = self.n_boot + seed = self.seed + + # Define a "null" CI for when we only have one value + null_ci = pd.Series(index=["low", "high"], dtype=float) + + # Function to bootstrap in the context of a pandas group by + def bootstrapped_cis(vals): + + if len(vals) <= 1: + return null_ci + + boots = bootstrap(vals, func=func, n_boot=n_boot, seed=seed) + cis = ci_func(boots, ci) + return pd.Series(cis, ["low", "high"]) + + # Group and get the aggregation estimate + grouped = vals.groupby(grouper, sort=self.sort) + est = grouped.agg(func) + + # Exit early if we don't want a confidence interval + if ci is None: + return est.index, est, None + + # Compute the error bar extents + if ci == "sd": + sd = grouped.std() + cis = pd.DataFrame(np.c_[est - sd, est + sd], + index=est.index, + columns=["low", "high"]).stack() + else: + cis = grouped.apply(bootstrapped_cis) + + # Unpack the CIs into "wide" format for plotting + if cis.notnull().any(): + cis = cis.unstack().reindex(est.index) + else: + cis = None + + return est.index, est, cis + + def plot(self, ax, kws): + """Draw the plot onto an axes, passing matplotlib kwargs.""" + + # Draw a test plot, using the passed in kwargs. The goal here is to + # honor both (a) the current state of the plot cycler and (b) the + # specified kwargs on all the lines we will draw, overriding when + # relevant with the data semantics. Note that we won't cycle + # internally; in other words, if ``hue`` is not used, all elements will + # have the same color, but they will have the color that you would have + # gotten from the corresponding matplotlib function, and calling the + # function will advance the axes property cycle. + + scout, = ax.plot([], [], **kws) + + orig_color = kws.pop("color", scout.get_color()) + orig_marker = kws.pop("marker", scout.get_marker()) + orig_linewidth = kws.pop("linewidth", + kws.pop("lw", scout.get_linewidth())) + + # Note that scout.get_linestyle() is` not correct as of mpl 3.2 + orig_linestyle = kws.pop("linestyle", kws.pop("ls", None)) + + kws.setdefault("markeredgewidth", kws.pop("mew", .75)) + kws.setdefault("markeredgecolor", kws.pop("mec", "w")) + + scout.remove() + + # Set default error kwargs + err_kws = self.err_kws.copy() + if self.err_style == "band": + err_kws.setdefault("alpha", .2) + elif self.err_style == "bars": + pass + elif self.err_style is not None: + err = "`err_style` must be 'band' or 'bars', not {}" + raise ValueError(err.format(self.err_style)) + + # Set the default artist keywords + kws.update(dict( + color=orig_color, + marker=orig_marker, + linewidth=orig_linewidth, + linestyle=orig_linestyle, + )) + + # Loop over the semantic subsets and add to the plot + grouping_vars = "hue", "size", "style" + for sub_vars, sub_data in self.iter_data(grouping_vars, from_comp_data=True): + + if self.sort: + sort_vars = ["units", "x", "y"] + sort_cols = [var for var in sort_vars if var in self.variables] + sub_data = sub_data.sort_values(sort_cols) + + # TODO + # How to handle NA? We don't want NA to propagate through to the + # estimate/CI when some values are present, but we would also like + # matplotlib to show "gaps" in the line when all values are missing. + # This is straightforward absent aggregation, but complicated with it. + sub_data = sub_data.dropna() + + # Due to the original design, code below was written assuming that + # sub_data always has x, y, and units columns, which may be empty. + # Adding this here to avoid otherwise disruptive changes, but it + # could get removed if the rest of the logic is sorted out + null = pd.Series(index=sub_data.index, dtype=float) + + x = sub_data.get("x", null) + y = sub_data.get("y", null) + u = sub_data.get("units", null) + + if self.estimator is not None: + if "units" in self.variables: + err = "estimator must be None when specifying units" + raise ValueError(err) + x, y, y_ci = self.aggregate(y, x, u) + else: + y_ci = None + + if "hue" in sub_vars: + kws["color"] = self._hue_map(sub_vars["hue"]) + if "size" in sub_vars: + kws["linewidth"] = self._size_map(sub_vars["size"]) + if "style" in sub_vars: + attributes = self._style_map(sub_vars["style"]) + if "dashes" in attributes: + kws["dashes"] = attributes["dashes"] + if "marker" in attributes: + kws["marker"] = attributes["marker"] + + line, = ax.plot([], [], **kws) + line_color = line.get_color() + line_alpha = line.get_alpha() + line_capstyle = line.get_solid_capstyle() + line.remove() + + # --- Draw the main line + + x, y = np.asarray(x), np.asarray(y) + + if "units" in self.variables: + for u_i in u.unique(): + rows = np.asarray(u == u_i) + ax.plot(x[rows], y[rows], **kws) + else: + line, = ax.plot(x, y, **kws) + + # --- Draw the confidence intervals + + if y_ci is not None: + + low, high = np.asarray(y_ci["low"]), np.asarray(y_ci["high"]) + + if self.err_style == "band": + + ax.fill_between(x, low, high, color=line_color, **err_kws) + + elif self.err_style == "bars": + + y_err = ci_to_errsize((low, high), y) + ebars = ax.errorbar(x, y, y_err, linestyle="", + color=line_color, alpha=line_alpha, + **err_kws) + + # Set the capstyle properly on the error bars + for obj in ebars.get_children(): + try: + obj.set_capstyle(line_capstyle) + except AttributeError: + # Does not exist on mpl < 2.2 + pass + + # Finalize the axes details + self._add_axis_labels(ax) + if self.legend: + self.add_legend_data(ax) + handles, _ = ax.get_legend_handles_labels() + if handles: + legend = ax.legend(title=self.legend_title) + adjust_legend_subtitles(legend) + + +class _ScatterPlotter(_RelationalPlotter): + + _legend_attributes = ["color", "s", "marker"] + _legend_func = "scatter" + + def __init__( + self, *, + data=None, variables={}, + x_bins=None, y_bins=None, + estimator=None, ci=None, n_boot=None, + alpha=None, x_jitter=None, y_jitter=None, + legend=None + ): + + # TODO this is messy, we want the mapping to be agnoistic about + # the kind of plot to draw, but for the time being we need to set + # this information so the SizeMapping can use it + self._default_size_range = ( + np.r_[.5, 2] * np.square(mpl.rcParams["lines.markersize"]) + ) + + super().__init__(data=data, variables=variables) + + self.alpha = alpha + self.legend = legend + + def plot(self, ax, kws): + + # Draw a test plot, using the passed in kwargs. The goal here is to + # honor both (a) the current state of the plot cycler and (b) the + # specified kwargs on all the lines we will draw, overriding when + # relevant with the data semantics. Note that we won't cycle + # internally; in other words, if ``hue`` is not used, all elements will + # have the same color, but they will have the color that you would have + # gotten from the corresponding matplotlib function, and calling the + # function will advance the axes property cycle. + + scout_size = max( + np.atleast_1d(kws.get("s", [])).shape[0], + np.atleast_1d(kws.get("c", [])).shape[0], + ) + scout_x = scout_y = np.full(scout_size, np.nan) + scout = ax.scatter(scout_x, scout_y, **kws) + s = kws.pop("s", scout.get_sizes()) + c = kws.pop("c", scout.get_facecolors()) + scout.remove() + + kws.pop("color", None) # TODO is this optimal? + + # --- Determine the visual attributes of the plot + + data = self.plot_data[list(self.variables)].dropna() + if not data.size: + return + + # Define the vectors of x and y positions + empty = np.full(len(data), np.nan) + x = data.get("x", empty) + y = data.get("y", empty) + + # Apply the mapping from semantic variables to artist attributes + if "hue" in self.variables: + c = self._hue_map(data["hue"]) + + if "size" in self.variables: + s = self._size_map(data["size"]) + + # Set defaults for other visual attributes + kws.setdefault("linewidth", .08 * np.sqrt(np.percentile(s, 10))) + + if "style" in self.variables: + # Use a representative marker so scatter sets the edgecolor + # properly for line art markers. We currently enforce either + # all or none line art so this works. + example_level = self._style_map.levels[0] + example_marker = self._style_map(example_level, "marker") + kws.setdefault("marker", example_marker) + + # Conditionally set the marker edgecolor based on whether the marker is "filled" + # See https://github.com/matplotlib/matplotlib/issues/17849 for context + m = kws.get("marker", mpl.rcParams.get("marker", "o")) + if not isinstance(m, mpl.markers.MarkerStyle): + m = mpl.markers.MarkerStyle(m) + if m.is_filled(): + kws.setdefault("edgecolor", "w") + + # TODO this makes it impossible to vary alpha with hue which might + # otherwise be useful? Should we just pass None? + kws["alpha"] = 1 if self.alpha == "auto" else self.alpha + + # Draw the scatter plot + args = np.asarray(x), np.asarray(y), np.asarray(s), np.asarray(c) + points = ax.scatter(*args, **kws) + + # Update the paths to get different marker shapes. + # This has to be done here because ax.scatter allows varying sizes + # and colors but only a single marker shape per call. + if "style" in self.variables: + p = [self._style_map(val, "path") for val in data["style"]] + points.set_paths(p) + + # Finalize the axes details + self._add_axis_labels(ax) + if self.legend: + self.add_legend_data(ax) + handles, _ = ax.get_legend_handles_labels() + if handles: + legend = ax.legend(title=self.legend_title) + adjust_legend_subtitles(legend) + + +@_deprecate_positional_args +def lineplot( + *, + x=None, y=None, + hue=None, size=None, style=None, + data=None, + palette=None, hue_order=None, hue_norm=None, + sizes=None, size_order=None, size_norm=None, + dashes=True, markers=None, style_order=None, + units=None, estimator="mean", ci=95, n_boot=1000, seed=None, + sort=True, err_style="band", err_kws=None, + legend="auto", ax=None, **kwargs +): + + variables = _LinePlotter.get_semantics(locals()) + p = _LinePlotter( + data=data, variables=variables, + estimator=estimator, ci=ci, n_boot=n_boot, seed=seed, + sort=sort, err_style=err_style, err_kws=err_kws, legend=legend, + ) + + p.map_hue(palette=palette, order=hue_order, norm=hue_norm) + p.map_size(sizes=sizes, order=size_order, norm=size_norm) + p.map_style(markers=markers, dashes=dashes, order=style_order) + + if ax is None: + ax = plt.gca() + + if not p.has_xy_data: + return ax + + p._attach(ax) + + p.plot(ax, kwargs) + return ax + + +lineplot.__doc__ = """\ +Draw a line plot with possibility of several semantic groupings. + +{narrative.main_api} + +{narrative.relational_semantic} + +By default, the plot aggregates over multiple ``y`` values at each value of +``x`` and shows an estimate of the central tendency and a confidence +interval for that estimate. + +Parameters +---------- +{params.core.xy} +hue : vector or key in ``data`` + Grouping variable that will produce lines with different colors. + Can be either categorical or numeric, although color mapping will + behave differently in latter case. +size : vector or key in ``data`` + Grouping variable that will produce lines with different widths. + Can be either categorical or numeric, although size mapping will + behave differently in latter case. +style : vector or key in ``data`` + Grouping variable that will produce lines with different dashes + and/or markers. Can have a numeric dtype but will always be treated + as categorical. +{params.core.data} +{params.core.palette} +{params.core.hue_order} +{params.core.hue_norm} +{params.rel.sizes} +{params.rel.size_order} +{params.rel.size_norm} +{params.rel.dashes} +{params.rel.markers} +{params.rel.style_order} +{params.rel.units} +{params.rel.estimator} +{params.rel.ci} +{params.rel.n_boot} +{params.rel.seed} +sort : boolean + If True, the data will be sorted by the x and y variables, otherwise + lines will connect points in the order they appear in the dataset. +err_style : "band" or "bars" + Whether to draw the confidence intervals with translucent error bands + or discrete error bars. +err_kws : dict of keyword arguments + Additional paramters to control the aesthetics of the error bars. The + kwargs are passed either to :meth:`matplotlib.axes.Axes.fill_between` + or :meth:`matplotlib.axes.Axes.errorbar`, depending on ``err_style``. +{params.rel.legend} +{params.core.ax} +kwargs : key, value mappings + Other keyword arguments are passed down to + :meth:`matplotlib.axes.Axes.plot`. + +Returns +------- +{returns.ax} + +See Also +-------- +{seealso.scatterplot} +{seealso.pointplot} + +Examples +-------- + +.. include:: ../docstrings/lineplot.rst + +""".format( + narrative=_relational_narrative, + params=_param_docs, + returns=_core_docs["returns"], + seealso=_core_docs["seealso"], +) + + +@_deprecate_positional_args +def scatterplot( + *, + x=None, y=None, + hue=None, style=None, size=None, data=None, + palette=None, hue_order=None, hue_norm=None, + sizes=None, size_order=None, size_norm=None, + markers=True, style_order=None, + x_bins=None, y_bins=None, + units=None, estimator=None, ci=95, n_boot=1000, + alpha=None, x_jitter=None, y_jitter=None, + legend="auto", ax=None, **kwargs +): + + variables = _ScatterPlotter.get_semantics(locals()) + p = _ScatterPlotter( + data=data, variables=variables, + x_bins=x_bins, y_bins=y_bins, + estimator=estimator, ci=ci, n_boot=n_boot, + alpha=alpha, x_jitter=x_jitter, y_jitter=y_jitter, legend=legend, + ) + + p.map_hue(palette=palette, order=hue_order, norm=hue_norm) + p.map_size(sizes=sizes, order=size_order, norm=size_norm) + p.map_style(markers=markers, order=style_order) + + if ax is None: + ax = plt.gca() + + if not p.has_xy_data: + return ax + + p._attach(ax) + + p.plot(ax, kwargs) + + return ax + + +scatterplot.__doc__ = """\ +Draw a scatter plot with possibility of several semantic groupings. + +{narrative.main_api} + +{narrative.relational_semantic} + +Parameters +---------- +{params.core.xy} +hue : vector or key in ``data`` + Grouping variable that will produce points with different colors. + Can be either categorical or numeric, although color mapping will + behave differently in latter case. +size : vector or key in ``data`` + Grouping variable that will produce points with different sizes. + Can be either categorical or numeric, although size mapping will + behave differently in latter case. +style : vector or key in ``data`` + Grouping variable that will produce points with different markers. + Can have a numeric dtype but will always be treated as categorical. +{params.core.data} +{params.core.palette} +{params.core.hue_order} +{params.core.hue_norm} +{params.rel.sizes} +{params.rel.size_order} +{params.rel.size_norm} +{params.rel.markers} +{params.rel.style_order} +{{x,y}}_bins : lists or arrays or functions + *Currently non-functional.* +{params.rel.units} + *Currently non-functional.* +{params.rel.estimator} + *Currently non-functional.* +{params.rel.ci} + *Currently non-functional.* +{params.rel.n_boot} + *Currently non-functional.* +alpha : float + Proportional opacity of the points. +{{x,y}}_jitter : booleans or floats + *Currently non-functional.* +{params.rel.legend} +{params.core.ax} +kwargs : key, value mappings + Other keyword arguments are passed down to + :meth:`matplotlib.axes.Axes.scatter`. + +Returns +------- +{returns.ax} + +See Also +-------- +{seealso.lineplot} +{seealso.stripplot} +{seealso.swarmplot} + +Examples +-------- + +.. include:: ../docstrings/scatterplot.rst + +""".format( + narrative=_relational_narrative, + params=_param_docs, + returns=_core_docs["returns"], + seealso=_core_docs["seealso"], +) + + +@_deprecate_positional_args +def relplot( + *, + x=None, y=None, + hue=None, size=None, style=None, data=None, + row=None, col=None, + col_wrap=None, row_order=None, col_order=None, + palette=None, hue_order=None, hue_norm=None, + sizes=None, size_order=None, size_norm=None, + markers=None, dashes=None, style_order=None, + legend="auto", kind="scatter", + height=5, aspect=1, facet_kws=None, + units=None, + **kwargs +): + + if kind == "scatter": + + plotter = _ScatterPlotter + func = scatterplot + markers = True if markers is None else markers + + elif kind == "line": + + plotter = _LinePlotter + func = lineplot + dashes = True if dashes is None else dashes + + else: + err = "Plot kind {} not recognized".format(kind) + raise ValueError(err) + + # Check for attempt to plot onto specific axes and warn + if "ax" in kwargs: + msg = ( + "relplot is a figure-level function and does not accept " + "the `ax` parameter. You may wish to try {}".format(kind + "plot") + ) + warnings.warn(msg, UserWarning) + kwargs.pop("ax") + + # Use the full dataset to map the semantics + p = plotter( + data=data, + variables=plotter.get_semantics(locals()), + legend=legend, + ) + p.map_hue(palette=palette, order=hue_order, norm=hue_norm) + p.map_size(sizes=sizes, order=size_order, norm=size_norm) + p.map_style(markers=markers, dashes=dashes, order=style_order) + + # Extract the semantic mappings + if "hue" in p.variables: + palette = p._hue_map.lookup_table + hue_order = p._hue_map.levels + hue_norm = p._hue_map.norm + else: + palette = hue_order = hue_norm = None + + if "size" in p.variables: + sizes = p._size_map.lookup_table + size_order = p._size_map.levels + size_norm = p._size_map.norm + + if "style" in p.variables: + style_order = p._style_map.levels + if markers: + markers = {k: p._style_map(k, "marker") for k in style_order} + else: + markers = None + if dashes: + dashes = {k: p._style_map(k, "dashes") for k in style_order} + else: + dashes = None + else: + markers = dashes = style_order = None + + # Now extract the data that would be used to draw a single plot + variables = p.variables + plot_data = p.plot_data + plot_semantics = p.semantics + + # Define the common plotting parameters + plot_kws = dict( + palette=palette, hue_order=hue_order, hue_norm=hue_norm, + sizes=sizes, size_order=size_order, size_norm=size_norm, + markers=markers, dashes=dashes, style_order=style_order, + legend=False, + ) + plot_kws.update(kwargs) + if kind == "scatter": + plot_kws.pop("dashes") + + # Add the grid semantics onto the plotter + grid_semantics = "row", "col" + p.semantics = plot_semantics + grid_semantics + p.assign_variables( + data=data, + variables=dict( + x=x, y=y, + hue=hue, size=size, style=style, units=units, + row=row, col=col, + ), + ) + + # Define the named variables for plotting on each facet + # Rename the variables with a leading underscore to avoid + # collisions with faceting variable names + plot_variables = {v: f"_{v}" for v in variables} + plot_kws.update(plot_variables) + + # Pass the row/col variables to FacetGrid with their original + # names so that the axes titles render correctly + grid_kws = {v: p.variables.get(v, None) for v in grid_semantics} + + # Rename the columns of the plot_data structure appropriately + new_cols = plot_variables.copy() + new_cols.update(grid_kws) + full_data = p.plot_data.rename(columns=new_cols) + + # Set up the FacetGrid object + facet_kws = {} if facet_kws is None else facet_kws.copy() + g = FacetGrid( + data=full_data.dropna(axis=1, how="all"), + **grid_kws, + col_wrap=col_wrap, row_order=row_order, col_order=col_order, + height=height, aspect=aspect, dropna=False, + **facet_kws + ) + + # Draw the plot + g.map_dataframe(func, **plot_kws) + + # Label the axes + g.set_axis_labels( + variables.get("x", None), variables.get("y", None) + ) + + # Show the legend + if legend: + # Replace the original plot data so the legend uses + # numeric data with the correct type + p.plot_data = plot_data + p.add_legend_data(g.axes.flat[0]) + if p.legend_data: + g.add_legend(legend_data=p.legend_data, + label_order=p.legend_order, + title=p.legend_title, + adjust_subtitles=True) + + # Rename the columns of the FacetGrid's `data` attribute + # to match the original column names + orig_cols = { + f"_{k}": f"_{k}_" if v is None else v for k, v in variables.items() + } + grid_data = g.data.rename(columns=orig_cols) + if data is not None and (x is not None or y is not None): + if not isinstance(data, pd.DataFrame): + data = pd.DataFrame(data) + g.data = pd.merge( + data, + grid_data[grid_data.columns.difference(data.columns)], + left_index=True, + right_index=True, + ) + else: + g.data = grid_data + + return g + + +relplot.__doc__ = """\ +Figure-level interface for drawing relational plots onto a FacetGrid. + +This function provides access to several different axes-level functions +that show the relationship between two variables with semantic mappings +of subsets. The ``kind`` parameter selects the underlying axes-level +function to use: + +- :func:`scatterplot` (with ``kind="scatter"``; the default) +- :func:`lineplot` (with ``kind="line"``) + +Extra keyword arguments are passed to the underlying function, so you +should refer to the documentation for each to see kind-specific options. + +{narrative.main_api} + +{narrative.relational_semantic} + +After plotting, the :class:`FacetGrid` with the plot is returned and can +be used directly to tweak supporting plot details or add other layers. + +Note that, unlike when using the underlying plotting functions directly, +data must be passed in a long-form DataFrame with variables specified by +passing strings to ``x``, ``y``, and other parameters. + +Parameters +---------- +{params.core.xy} +hue : vector or key in ``data`` + Grouping variable that will produce elements with different colors. + Can be either categorical or numeric, although color mapping will + behave differently in latter case. +size : vector or key in ``data`` + Grouping variable that will produce elements with different sizes. + Can be either categorical or numeric, although size mapping will + behave differently in latter case. +style : vector or key in ``data`` + Grouping variable that will produce elements with different styles. + Can have a numeric dtype but will always be treated as categorical. +{params.core.data} +{params.facets.rowcol} +{params.facets.col_wrap} +row_order, col_order : lists of strings + Order to organize the rows and/or columns of the grid in, otherwise the + orders are inferred from the data objects. +{params.core.palette} +{params.core.hue_order} +{params.core.hue_norm} +{params.rel.sizes} +{params.rel.size_order} +{params.rel.size_norm} +{params.rel.style_order} +{params.rel.dashes} +{params.rel.markers} +{params.rel.legend} +kind : string + Kind of plot to draw, corresponding to a seaborn relational plot. + Options are {{``scatter`` and ``line``}}. +{params.facets.height} +{params.facets.aspect} +facet_kws : dict + Dictionary of other keyword arguments to pass to :class:`FacetGrid`. +{params.rel.units} +kwargs : key, value pairings + Other keyword arguments are passed through to the underlying plotting + function. + +Returns +------- +{returns.facetgrid} + +Examples +-------- + +.. include:: ../docstrings/relplot.rst + +""".format( + narrative=_relational_narrative, + params=_param_docs, + returns=_core_docs["returns"], + seealso=_core_docs["seealso"], +) diff --git a/grplot_seaborn/tests/__init__.py b/grplot_seaborn/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/grplot_seaborn/tests/test_algorithms.py b/grplot_seaborn/tests/test_algorithms.py new file mode 100644 index 0000000..f4fe38c --- /dev/null +++ b/grplot_seaborn/tests/test_algorithms.py @@ -0,0 +1,202 @@ +import numpy as np +import numpy.random as npr + +import pytest +from numpy.testing import assert_array_equal +from distutils.version import LooseVersion + +from .. import algorithms as algo + + +@pytest.fixture +def random(): + np.random.seed(sum(map(ord, "test_algorithms"))) + + +def test_bootstrap(random): + """Test that bootstrapping gives the right answer in dumb cases.""" + a_ones = np.ones(10) + n_boot = 5 + out1 = algo.bootstrap(a_ones, n_boot=n_boot) + assert_array_equal(out1, np.ones(n_boot)) + out2 = algo.bootstrap(a_ones, n_boot=n_boot, func=np.median) + assert_array_equal(out2, np.ones(n_boot)) + + +def test_bootstrap_length(random): + """Test that we get a bootstrap array of the right shape.""" + a_norm = np.random.randn(1000) + out = algo.bootstrap(a_norm) + assert len(out) == 10000 + + n_boot = 100 + out = algo.bootstrap(a_norm, n_boot=n_boot) + assert len(out) == n_boot + + +def test_bootstrap_range(random): + """Test that boostrapping a random array stays within the right range.""" + a_norm = np.random.randn(1000) + amin, amax = a_norm.min(), a_norm.max() + out = algo.bootstrap(a_norm) + assert amin <= out.min() + assert amax >= out.max() + + +def test_bootstrap_multiarg(random): + """Test that bootstrap works with multiple input arrays.""" + x = np.vstack([[1, 10] for i in range(10)]) + y = np.vstack([[5, 5] for i in range(10)]) + + def f(x, y): + return np.vstack((x, y)).max(axis=0) + + out_actual = algo.bootstrap(x, y, n_boot=2, func=f) + out_wanted = np.array([[5, 10], [5, 10]]) + assert_array_equal(out_actual, out_wanted) + + +def test_bootstrap_axis(random): + """Test axis kwarg to bootstrap function.""" + x = np.random.randn(10, 20) + n_boot = 100 + + out_default = algo.bootstrap(x, n_boot=n_boot) + assert out_default.shape == (n_boot,) + + out_axis = algo.bootstrap(x, n_boot=n_boot, axis=0) + assert out_axis.shape, (n_boot, x.shape[1]) + + +def test_bootstrap_seed(random): + """Test that we can get reproducible resamples by seeding the RNG.""" + data = np.random.randn(50) + seed = 42 + boots1 = algo.bootstrap(data, seed=seed) + boots2 = algo.bootstrap(data, seed=seed) + assert_array_equal(boots1, boots2) + + +def test_bootstrap_ols(random): + """Test bootstrap of OLS model fit.""" + def ols_fit(X, y): + XtXinv = np.linalg.inv(np.dot(X.T, X)) + return XtXinv.dot(X.T).dot(y) + + X = np.column_stack((np.random.randn(50, 4), np.ones(50))) + w = [2, 4, 0, 3, 5] + y_noisy = np.dot(X, w) + np.random.randn(50) * 20 + y_lownoise = np.dot(X, w) + np.random.randn(50) + + n_boot = 500 + w_boot_noisy = algo.bootstrap(X, y_noisy, + n_boot=n_boot, + func=ols_fit) + w_boot_lownoise = algo.bootstrap(X, y_lownoise, + n_boot=n_boot, + func=ols_fit) + + assert w_boot_noisy.shape == (n_boot, 5) + assert w_boot_lownoise.shape == (n_boot, 5) + assert w_boot_noisy.std() > w_boot_lownoise.std() + + +def test_bootstrap_units(random): + """Test that results make sense when passing unit IDs to bootstrap.""" + data = np.random.randn(50) + ids = np.repeat(range(10), 5) + bwerr = np.random.normal(0, 2, 10) + bwerr = bwerr[ids] + data_rm = data + bwerr + seed = 77 + + boots_orig = algo.bootstrap(data_rm, seed=seed) + boots_rm = algo.bootstrap(data_rm, units=ids, seed=seed) + assert boots_rm.std() > boots_orig.std() + + +def test_bootstrap_arglength(): + """Test that different length args raise ValueError.""" + with pytest.raises(ValueError): + algo.bootstrap(np.arange(5), np.arange(10)) + + +def test_bootstrap_string_func(): + """Test that named numpy methods are the same as the numpy function.""" + x = np.random.randn(100) + + res_a = algo.bootstrap(x, func="mean", seed=0) + res_b = algo.bootstrap(x, func=np.mean, seed=0) + assert np.array_equal(res_a, res_b) + + res_a = algo.bootstrap(x, func="std", seed=0) + res_b = algo.bootstrap(x, func=np.std, seed=0) + assert np.array_equal(res_a, res_b) + + with pytest.raises(AttributeError): + algo.bootstrap(x, func="not_a_method_name") + + +def test_bootstrap_reproducibility(random): + """Test that bootstrapping uses the internal random state.""" + data = np.random.randn(50) + boots1 = algo.bootstrap(data, seed=100) + boots2 = algo.bootstrap(data, seed=100) + assert_array_equal(boots1, boots2) + + with pytest.warns(UserWarning): + # Deprecatd, remove when removing random_seed + boots1 = algo.bootstrap(data, random_seed=100) + boots2 = algo.bootstrap(data, random_seed=100) + assert_array_equal(boots1, boots2) + + +@pytest.mark.skipif(LooseVersion(np.__version__) < "1.17", + reason="Tests new numpy random functionality") +def test_seed_new(): + + # Can't use pytest parametrize because tests will fail where the new + # Generator object and related function are not defined + + test_bank = [ + (None, None, npr.Generator, False), + (npr.RandomState(0), npr.RandomState(0), npr.RandomState, True), + (npr.RandomState(0), npr.RandomState(1), npr.RandomState, False), + (npr.default_rng(1), npr.default_rng(1), npr.Generator, True), + (npr.default_rng(1), npr.default_rng(2), npr.Generator, False), + (npr.SeedSequence(10), npr.SeedSequence(10), npr.Generator, True), + (npr.SeedSequence(10), npr.SeedSequence(20), npr.Generator, False), + (100, 100, npr.Generator, True), + (100, 200, npr.Generator, False), + ] + for seed1, seed2, rng_class, match in test_bank: + rng1 = algo._handle_random_seed(seed1) + rng2 = algo._handle_random_seed(seed2) + assert isinstance(rng1, rng_class) + assert isinstance(rng2, rng_class) + assert (rng1.uniform() == rng2.uniform()) == match + + +@pytest.mark.skipif(LooseVersion(np.__version__) >= "1.17", + reason="Tests old numpy random functionality") +@pytest.mark.parametrize("seed1, seed2, match", [ + (None, None, False), + (npr.RandomState(0), npr.RandomState(0), True), + (npr.RandomState(0), npr.RandomState(1), False), + (100, 100, True), + (100, 200, False), +]) +def test_seed_old(seed1, seed2, match): + rng1 = algo._handle_random_seed(seed1) + rng2 = algo._handle_random_seed(seed2) + assert isinstance(rng1, np.random.RandomState) + assert isinstance(rng2, np.random.RandomState) + assert (rng1.uniform() == rng2.uniform()) == match + + +@pytest.mark.skipif(LooseVersion(np.__version__) >= "1.17", + reason="Tests old numpy random functionality") +def test_bad_seed_old(): + + with pytest.raises(ValueError): + algo._handle_random_seed("not_a_random_seed") diff --git a/grplot_seaborn/tests/test_axisgrid.py b/grplot_seaborn/tests/test_axisgrid.py new file mode 100644 index 0000000..52ce774 --- /dev/null +++ b/grplot_seaborn/tests/test_axisgrid.py @@ -0,0 +1,1784 @@ +import numpy as np +import pandas as pd +import matplotlib as mpl +import matplotlib.pyplot as plt + +import pytest +import numpy.testing as npt +from numpy.testing import assert_array_equal +try: + import pandas.testing as tm +except ImportError: + import pandas.util.testing as tm + +from .._core import categorical_order +from .. import rcmod +from ..palettes import color_palette +from ..relational import scatterplot +from ..distributions import histplot, kdeplot, distplot +from ..categorical import pointplot +from .. import axisgrid as ag +from .._testing import ( + assert_plots_equal, + assert_colors_equal, +) + +rs = np.random.RandomState(0) + + +class TestFacetGrid: + + df = pd.DataFrame(dict(x=rs.normal(size=60), + y=rs.gamma(4, size=60), + a=np.repeat(list("abc"), 20), + b=np.tile(list("mn"), 30), + c=np.tile(list("tuv"), 20), + d=np.tile(list("abcdefghijkl"), 5))) + + def test_self_data(self): + + g = ag.FacetGrid(self.df) + assert g.data is self.df + + def test_self_figure(self): + + g = ag.FacetGrid(self.df) + assert isinstance(g.figure, plt.Figure) + assert g.figure is g._figure + + def test_self_axes(self): + + g = ag.FacetGrid(self.df, row="a", col="b", hue="c") + for ax in g.axes.flat: + assert isinstance(ax, plt.Axes) + + def test_axes_array_size(self): + + g = ag.FacetGrid(self.df) + assert g.axes.shape == (1, 1) + + g = ag.FacetGrid(self.df, row="a") + assert g.axes.shape == (3, 1) + + g = ag.FacetGrid(self.df, col="b") + assert g.axes.shape == (1, 2) + + g = ag.FacetGrid(self.df, hue="c") + assert g.axes.shape == (1, 1) + + g = ag.FacetGrid(self.df, row="a", col="b", hue="c") + assert g.axes.shape == (3, 2) + for ax in g.axes.flat: + assert isinstance(ax, plt.Axes) + + def test_single_axes(self): + + g = ag.FacetGrid(self.df) + assert isinstance(g.ax, plt.Axes) + + g = ag.FacetGrid(self.df, row="a") + with pytest.raises(AttributeError): + g.ax + + g = ag.FacetGrid(self.df, col="a") + with pytest.raises(AttributeError): + g.ax + + g = ag.FacetGrid(self.df, col="a", row="b") + with pytest.raises(AttributeError): + g.ax + + def test_col_wrap(self): + + n = len(self.df.d.unique()) + + g = ag.FacetGrid(self.df, col="d") + assert g.axes.shape == (1, n) + assert g.facet_axis(0, 8) is g.axes[0, 8] + + g_wrap = ag.FacetGrid(self.df, col="d", col_wrap=4) + assert g_wrap.axes.shape == (n,) + assert g_wrap.facet_axis(0, 8) is g_wrap.axes[8] + assert g_wrap._ncol == 4 + assert g_wrap._nrow == (n / 4) + + with pytest.raises(ValueError): + g = ag.FacetGrid(self.df, row="b", col="d", col_wrap=4) + + df = self.df.copy() + df.loc[df.d == "j"] = np.nan + g_missing = ag.FacetGrid(df, col="d") + assert g_missing.axes.shape == (1, n - 1) + + g_missing_wrap = ag.FacetGrid(df, col="d", col_wrap=4) + assert g_missing_wrap.axes.shape == (n - 1,) + + g = ag.FacetGrid(self.df, col="d", col_wrap=1) + assert len(list(g.facet_data())) == n + + def test_normal_axes(self): + + null = np.empty(0, object).flat + + g = ag.FacetGrid(self.df) + npt.assert_array_equal(g._bottom_axes, g.axes.flat) + npt.assert_array_equal(g._not_bottom_axes, null) + npt.assert_array_equal(g._left_axes, g.axes.flat) + npt.assert_array_equal(g._not_left_axes, null) + npt.assert_array_equal(g._inner_axes, null) + + g = ag.FacetGrid(self.df, col="c") + npt.assert_array_equal(g._bottom_axes, g.axes.flat) + npt.assert_array_equal(g._not_bottom_axes, null) + npt.assert_array_equal(g._left_axes, g.axes[:, 0].flat) + npt.assert_array_equal(g._not_left_axes, g.axes[:, 1:].flat) + npt.assert_array_equal(g._inner_axes, null) + + g = ag.FacetGrid(self.df, row="c") + npt.assert_array_equal(g._bottom_axes, g.axes[-1, :].flat) + npt.assert_array_equal(g._not_bottom_axes, g.axes[:-1, :].flat) + npt.assert_array_equal(g._left_axes, g.axes.flat) + npt.assert_array_equal(g._not_left_axes, null) + npt.assert_array_equal(g._inner_axes, null) + + g = ag.FacetGrid(self.df, col="a", row="c") + npt.assert_array_equal(g._bottom_axes, g.axes[-1, :].flat) + npt.assert_array_equal(g._not_bottom_axes, g.axes[:-1, :].flat) + npt.assert_array_equal(g._left_axes, g.axes[:, 0].flat) + npt.assert_array_equal(g._not_left_axes, g.axes[:, 1:].flat) + npt.assert_array_equal(g._inner_axes, g.axes[:-1, 1:].flat) + + def test_wrapped_axes(self): + + null = np.empty(0, object).flat + + g = ag.FacetGrid(self.df, col="a", col_wrap=2) + npt.assert_array_equal(g._bottom_axes, + g.axes[np.array([1, 2])].flat) + npt.assert_array_equal(g._not_bottom_axes, g.axes[:1].flat) + npt.assert_array_equal(g._left_axes, g.axes[np.array([0, 2])].flat) + npt.assert_array_equal(g._not_left_axes, g.axes[np.array([1])].flat) + npt.assert_array_equal(g._inner_axes, null) + + def test_axes_dict(self): + + g = ag.FacetGrid(self.df) + assert isinstance(g.axes_dict, dict) + assert not g.axes_dict + + g = ag.FacetGrid(self.df, row="c") + assert list(g.axes_dict.keys()) == g.row_names + for (name, ax) in zip(g.row_names, g.axes.flat): + assert g.axes_dict[name] is ax + + g = ag.FacetGrid(self.df, col="c") + assert list(g.axes_dict.keys()) == g.col_names + for (name, ax) in zip(g.col_names, g.axes.flat): + assert g.axes_dict[name] is ax + + g = ag.FacetGrid(self.df, col="a", col_wrap=2) + assert list(g.axes_dict.keys()) == g.col_names + for (name, ax) in zip(g.col_names, g.axes.flat): + assert g.axes_dict[name] is ax + + g = ag.FacetGrid(self.df, row="a", col="c") + for (row_var, col_var), ax in g.axes_dict.items(): + i = g.row_names.index(row_var) + j = g.col_names.index(col_var) + assert g.axes[i, j] is ax + + def test_figure_size(self): + + g = ag.FacetGrid(self.df, row="a", col="b") + npt.assert_array_equal(g.figure.get_size_inches(), (6, 9)) + + g = ag.FacetGrid(self.df, row="a", col="b", height=6) + npt.assert_array_equal(g.figure.get_size_inches(), (12, 18)) + + g = ag.FacetGrid(self.df, col="c", height=4, aspect=.5) + npt.assert_array_equal(g.figure.get_size_inches(), (6, 4)) + + def test_figure_size_with_legend(self): + + g = ag.FacetGrid(self.df, col="a", hue="c", height=4, aspect=.5) + npt.assert_array_equal(g.figure.get_size_inches(), (6, 4)) + g.add_legend() + assert g.figure.get_size_inches()[0] > 6 + + g = ag.FacetGrid(self.df, col="a", hue="c", height=4, aspect=.5, + legend_out=False) + npt.assert_array_equal(g.figure.get_size_inches(), (6, 4)) + g.add_legend() + npt.assert_array_equal(g.figure.get_size_inches(), (6, 4)) + + def test_legend_data(self): + + g = ag.FacetGrid(self.df, hue="a") + g.map(plt.plot, "x", "y") + g.add_legend() + palette = color_palette(n_colors=3) + + assert g._legend.get_title().get_text() == "a" + + a_levels = sorted(self.df.a.unique()) + + lines = g._legend.get_lines() + assert len(lines) == len(a_levels) + + for line, hue in zip(lines, palette): + assert line.get_color() == hue + + labels = g._legend.get_texts() + assert len(labels) == len(a_levels) + + for label, level in zip(labels, a_levels): + assert label.get_text() == level + + def test_legend_data_missing_level(self): + + g = ag.FacetGrid(self.df, hue="a", hue_order=list("azbc")) + g.map(plt.plot, "x", "y") + g.add_legend() + + c1, c2, c3, c4 = color_palette(n_colors=4) + palette = [c1, c3, c4] + + assert g._legend.get_title().get_text() == "a" + + a_levels = sorted(self.df.a.unique()) + + lines = g._legend.get_lines() + assert len(lines) == len(a_levels) + + for line, hue in zip(lines, palette): + assert line.get_color() == hue + + labels = g._legend.get_texts() + assert len(labels) == 4 + + for label, level in zip(labels, list("azbc")): + assert label.get_text() == level + + def test_get_boolean_legend_data(self): + + self.df["b_bool"] = self.df.b == "m" + g = ag.FacetGrid(self.df, hue="b_bool") + g.map(plt.plot, "x", "y") + g.add_legend() + palette = color_palette(n_colors=2) + + assert g._legend.get_title().get_text() == "b_bool" + + b_levels = list(map(str, categorical_order(self.df.b_bool))) + + lines = g._legend.get_lines() + assert len(lines) == len(b_levels) + + for line, hue in zip(lines, palette): + assert line.get_color() == hue + + labels = g._legend.get_texts() + assert len(labels) == len(b_levels) + + for label, level in zip(labels, b_levels): + assert label.get_text() == level + + def test_legend_tuples(self): + + g = ag.FacetGrid(self.df, hue="a") + g.map(plt.plot, "x", "y") + + handles, labels = g.ax.get_legend_handles_labels() + label_tuples = [("", l) for l in labels] + legend_data = dict(zip(label_tuples, handles)) + g.add_legend(legend_data, label_tuples) + for entry, label in zip(g._legend.get_texts(), labels): + assert entry.get_text() == label + + def test_legend_options(self): + + g = ag.FacetGrid(self.df, hue="b") + g.map(plt.plot, "x", "y") + g.add_legend() + + g1 = ag.FacetGrid(self.df, hue="b", legend_out=False) + g1.add_legend(adjust_subtitles=True) + + g1 = ag.FacetGrid(self.df, hue="b", legend_out=False) + g1.add_legend(adjust_subtitles=False) + + def test_legendout_with_colwrap(self): + + g = ag.FacetGrid(self.df, col="d", hue='b', + col_wrap=4, legend_out=False) + g.map(plt.plot, "x", "y", linewidth=3) + g.add_legend() + + def test_legend_tight_layout(self): + + g = ag.FacetGrid(self.df, hue='b') + g.map(plt.plot, "x", "y", linewidth=3) + g.add_legend() + g.tight_layout() + + axes_right_edge = g.ax.get_window_extent().xmax + legend_left_edge = g._legend.get_window_extent().xmin + + assert axes_right_edge < legend_left_edge + + def test_subplot_kws(self): + + g = ag.FacetGrid(self.df, despine=False, + subplot_kws=dict(projection="polar")) + for ax in g.axes.flat: + assert "PolarAxesSubplot" in str(type(ax)) + + def test_gridspec_kws(self): + ratios = [3, 1, 2] + + gskws = dict(width_ratios=ratios) + g = ag.FacetGrid(self.df, col='c', row='a', gridspec_kws=gskws) + + for ax in g.axes.flat: + ax.set_xticks([]) + ax.set_yticks([]) + + g.figure.tight_layout() + + for (l, m, r) in g.axes: + assert l.get_position().width > m.get_position().width + assert r.get_position().width > m.get_position().width + + def test_gridspec_kws_col_wrap(self): + ratios = [3, 1, 2, 1, 1] + + gskws = dict(width_ratios=ratios) + with pytest.warns(UserWarning): + ag.FacetGrid(self.df, col='d', col_wrap=5, gridspec_kws=gskws) + + def test_data_generator(self): + + g = ag.FacetGrid(self.df, row="a") + d = list(g.facet_data()) + assert len(d) == 3 + + tup, data = d[0] + assert tup == (0, 0, 0) + assert (data["a"] == "a").all() + + tup, data = d[1] + assert tup == (1, 0, 0) + assert (data["a"] == "b").all() + + g = ag.FacetGrid(self.df, row="a", col="b") + d = list(g.facet_data()) + assert len(d) == 6 + + tup, data = d[0] + assert tup == (0, 0, 0) + assert (data["a"] == "a").all() + assert (data["b"] == "m").all() + + tup, data = d[1] + assert tup == (0, 1, 0) + assert (data["a"] == "a").all() + assert (data["b"] == "n").all() + + tup, data = d[2] + assert tup == (1, 0, 0) + assert (data["a"] == "b").all() + assert (data["b"] == "m").all() + + g = ag.FacetGrid(self.df, hue="c") + d = list(g.facet_data()) + assert len(d) == 3 + tup, data = d[1] + assert tup == (0, 0, 1) + assert (data["c"] == "u").all() + + def test_map(self): + + g = ag.FacetGrid(self.df, row="a", col="b", hue="c") + g.map(plt.plot, "x", "y", linewidth=3) + + lines = g.axes[0, 0].lines + assert len(lines) == 3 + + line1, _, _ = lines + assert line1.get_linewidth() == 3 + x, y = line1.get_data() + mask = (self.df.a == "a") & (self.df.b == "m") & (self.df.c == "t") + npt.assert_array_equal(x, self.df.x[mask]) + npt.assert_array_equal(y, self.df.y[mask]) + + def test_map_dataframe(self): + + g = ag.FacetGrid(self.df, row="a", col="b", hue="c") + + def plot(x, y, data=None, **kws): + plt.plot(data[x], data[y], **kws) + # Modify __module__ so this doesn't look like a seaborn function + plot.__module__ = "test" + + g.map_dataframe(plot, "x", "y", linestyle="--") + + lines = g.axes[0, 0].lines + assert len(g.axes[0, 0].lines) == 3 + + line1, _, _ = lines + assert line1.get_linestyle() == "--" + x, y = line1.get_data() + mask = (self.df.a == "a") & (self.df.b == "m") & (self.df.c == "t") + npt.assert_array_equal(x, self.df.x[mask]) + npt.assert_array_equal(y, self.df.y[mask]) + + def test_set(self): + + g = ag.FacetGrid(self.df, row="a", col="b") + xlim = (-2, 5) + ylim = (3, 6) + xticks = [-2, 0, 3, 5] + yticks = [3, 4.5, 6] + g.set(xlim=xlim, ylim=ylim, xticks=xticks, yticks=yticks) + for ax in g.axes.flat: + npt.assert_array_equal(ax.get_xlim(), xlim) + npt.assert_array_equal(ax.get_ylim(), ylim) + npt.assert_array_equal(ax.get_xticks(), xticks) + npt.assert_array_equal(ax.get_yticks(), yticks) + + def test_set_titles(self): + + g = ag.FacetGrid(self.df, row="a", col="b") + g.map(plt.plot, "x", "y") + + # Test the default titles + assert g.axes[0, 0].get_title() == "a = a | b = m" + assert g.axes[0, 1].get_title() == "a = a | b = n" + assert g.axes[1, 0].get_title() == "a = b | b = m" + + # Test a provided title + g.set_titles("{row_var} == {row_name} \\/ {col_var} == {col_name}") + assert g.axes[0, 0].get_title() == "a == a \\/ b == m" + assert g.axes[0, 1].get_title() == "a == a \\/ b == n" + assert g.axes[1, 0].get_title() == "a == b \\/ b == m" + + # Test a single row + g = ag.FacetGrid(self.df, col="b") + g.map(plt.plot, "x", "y") + + # Test the default titles + assert g.axes[0, 0].get_title() == "b = m" + assert g.axes[0, 1].get_title() == "b = n" + + # test with dropna=False + g = ag.FacetGrid(self.df, col="b", hue="b", dropna=False) + g.map(plt.plot, 'x', 'y') + + def test_set_titles_margin_titles(self): + + g = ag.FacetGrid(self.df, row="a", col="b", margin_titles=True) + g.map(plt.plot, "x", "y") + + # Test the default titles + assert g.axes[0, 0].get_title() == "b = m" + assert g.axes[0, 1].get_title() == "b = n" + assert g.axes[1, 0].get_title() == "" + + # Test the row "titles" + assert g.axes[0, 1].texts[0].get_text() == "a = a" + assert g.axes[1, 1].texts[0].get_text() == "a = b" + assert g.axes[0, 1].texts[0] is g._margin_titles_texts[0] + + # Test provided titles + g.set_titles(col_template="{col_name}", row_template="{row_name}") + assert g.axes[0, 0].get_title() == "m" + assert g.axes[0, 1].get_title() == "n" + assert g.axes[1, 0].get_title() == "" + + assert len(g.axes[1, 1].texts) == 1 + assert g.axes[1, 1].texts[0].get_text() == "b" + + def test_set_ticklabels(self): + + g = ag.FacetGrid(self.df, row="a", col="b") + g.map(plt.plot, "x", "y") + + ax = g.axes[-1, 0] + xlab = [l.get_text() + "h" for l in ax.get_xticklabels()] + ylab = [l.get_text() + "i" for l in ax.get_yticklabels()] + + g.set_xticklabels(xlab) + g.set_yticklabels(ylab) + got_x = [l.get_text() for l in g.axes[-1, 1].get_xticklabels()] + got_y = [l.get_text() for l in g.axes[0, 0].get_yticklabels()] + npt.assert_array_equal(got_x, xlab) + npt.assert_array_equal(got_y, ylab) + + x, y = np.arange(10), np.arange(10) + df = pd.DataFrame(np.c_[x, y], columns=["x", "y"]) + g = ag.FacetGrid(df).map_dataframe(pointplot, x="x", y="y", order=x) + g.set_xticklabels(step=2) + got_x = [int(l.get_text()) for l in g.axes[0, 0].get_xticklabels()] + npt.assert_array_equal(x[::2], got_x) + + g = ag.FacetGrid(self.df, col="d", col_wrap=5) + g.map(plt.plot, "x", "y") + g.set_xticklabels(rotation=45) + g.set_yticklabels(rotation=75) + for ax in g._bottom_axes: + for l in ax.get_xticklabels(): + assert l.get_rotation() == 45 + for ax in g._left_axes: + for l in ax.get_yticklabels(): + assert l.get_rotation() == 75 + + def test_set_axis_labels(self): + + g = ag.FacetGrid(self.df, row="a", col="b") + g.map(plt.plot, "x", "y") + xlab = 'xx' + ylab = 'yy' + + g.set_axis_labels(xlab, ylab) + + got_x = [ax.get_xlabel() for ax in g.axes[-1, :]] + got_y = [ax.get_ylabel() for ax in g.axes[:, 0]] + npt.assert_array_equal(got_x, xlab) + npt.assert_array_equal(got_y, ylab) + + for ax in g.axes.flat: + ax.set(xlabel="x", ylabel="y") + + g.set_axis_labels(xlab, ylab) + for ax in g._not_bottom_axes: + assert not ax.get_xlabel() + for ax in g._not_left_axes: + assert not ax.get_ylabel() + + def test_axis_lims(self): + + g = ag.FacetGrid(self.df, row="a", col="b", xlim=(0, 4), ylim=(-2, 3)) + assert g.axes[0, 0].get_xlim() == (0, 4) + assert g.axes[0, 0].get_ylim() == (-2, 3) + + def test_data_orders(self): + + g = ag.FacetGrid(self.df, row="a", col="b", hue="c") + + assert g.row_names == list("abc") + assert g.col_names == list("mn") + assert g.hue_names == list("tuv") + assert g.axes.shape == (3, 2) + + g = ag.FacetGrid(self.df, row="a", col="b", hue="c", + row_order=list("bca"), + col_order=list("nm"), + hue_order=list("vtu")) + + assert g.row_names == list("bca") + assert g.col_names == list("nm") + assert g.hue_names == list("vtu") + assert g.axes.shape == (3, 2) + + g = ag.FacetGrid(self.df, row="a", col="b", hue="c", + row_order=list("bcda"), + col_order=list("nom"), + hue_order=list("qvtu")) + + assert g.row_names == list("bcda") + assert g.col_names == list("nom") + assert g.hue_names == list("qvtu") + assert g.axes.shape == (4, 3) + + def test_palette(self): + + rcmod.set() + + g = ag.FacetGrid(self.df, hue="c") + assert g._colors == color_palette(n_colors=len(self.df.c.unique())) + + g = ag.FacetGrid(self.df, hue="d") + assert g._colors == color_palette("husl", len(self.df.d.unique())) + + g = ag.FacetGrid(self.df, hue="c", palette="Set2") + assert g._colors == color_palette("Set2", len(self.df.c.unique())) + + dict_pal = dict(t="red", u="green", v="blue") + list_pal = color_palette(["red", "green", "blue"], 3) + g = ag.FacetGrid(self.df, hue="c", palette=dict_pal) + assert g._colors == list_pal + + list_pal = color_palette(["green", "blue", "red"], 3) + g = ag.FacetGrid(self.df, hue="c", hue_order=list("uvt"), + palette=dict_pal) + assert g._colors == list_pal + + def test_hue_kws(self): + + kws = dict(marker=["o", "s", "D"]) + g = ag.FacetGrid(self.df, hue="c", hue_kws=kws) + g.map(plt.plot, "x", "y") + + for line, marker in zip(g.axes[0, 0].lines, kws["marker"]): + assert line.get_marker() == marker + + def test_dropna(self): + + df = self.df.copy() + hasna = pd.Series(np.tile(np.arange(6), 10), dtype=float) + hasna[hasna == 5] = np.nan + df["hasna"] = hasna + g = ag.FacetGrid(df, dropna=False, row="hasna") + assert g._not_na.sum() == 60 + + g = ag.FacetGrid(df, dropna=True, row="hasna") + assert g._not_na.sum() == 50 + + def test_categorical_column_missing_categories(self): + + df = self.df.copy() + df['a'] = df['a'].astype('category') + + g = ag.FacetGrid(df[df['a'] == 'a'], col="a", col_wrap=1) + + assert g.axes.shape == (len(df['a'].cat.categories),) + + def test_categorical_warning(self): + + g = ag.FacetGrid(self.df, col="b") + with pytest.warns(UserWarning): + g.map(pointplot, "b", "x") + + def test_refline(self): + + g = ag.FacetGrid(self.df, row="a", col="b") + g.refline() + for ax in g.axes.ravel(): + assert not ax.lines + + refx = refy = 0.5 + hline = np.array([[0, refy], [1, refy]]) + vline = np.array([[refx, 0], [refx, 1]]) + g.refline(x=refx, y=refy) + for ax in g.axes.ravel(): + assert ax.lines[0].get_color() == '.5' + assert ax.lines[0].get_linestyle() == '--' + assert len(ax.lines) == 2 + npt.assert_array_equal(ax.lines[0].get_xydata(), vline) + npt.assert_array_equal(ax.lines[1].get_xydata(), hline) + + color, linestyle = 'red', '-' + g.refline(x=refx, color=color, linestyle=linestyle) + npt.assert_array_equal(g.axes[0, 0].lines[-1].get_xydata(), vline) + assert g.axes[0, 0].lines[-1].get_color() == color + assert g.axes[0, 0].lines[-1].get_linestyle() == linestyle + + +class TestPairGrid: + + rs = np.random.RandomState(sum(map(ord, "PairGrid"))) + df = pd.DataFrame(dict(x=rs.normal(size=60), + y=rs.randint(0, 4, size=(60)), + z=rs.gamma(3, size=60), + a=np.repeat(list("abc"), 20), + b=np.repeat(list("abcdefghijkl"), 5))) + + def test_self_data(self): + + g = ag.PairGrid(self.df) + assert g.data is self.df + + def test_ignore_datelike_data(self): + + df = self.df.copy() + df['date'] = pd.date_range('2010-01-01', periods=len(df), freq='d') + result = ag.PairGrid(self.df).data + expected = df.drop('date', axis=1) + tm.assert_frame_equal(result, expected) + + def test_self_figure(self): + + g = ag.PairGrid(self.df) + assert isinstance(g.figure, plt.Figure) + assert g.figure is g._figure + + def test_self_axes(self): + + g = ag.PairGrid(self.df) + for ax in g.axes.flat: + assert isinstance(ax, plt.Axes) + + def test_default_axes(self): + + g = ag.PairGrid(self.df) + assert g.axes.shape == (3, 3) + assert g.x_vars == ["x", "y", "z"] + assert g.y_vars == ["x", "y", "z"] + assert g.square_grid + + @pytest.mark.parametrize("vars", [["z", "x"], np.array(["z", "x"])]) + def test_specific_square_axes(self, vars): + + g = ag.PairGrid(self.df, vars=vars) + assert g.axes.shape == (len(vars), len(vars)) + assert g.x_vars == list(vars) + assert g.y_vars == list(vars) + assert g.square_grid + + def test_remove_hue_from_default(self): + + hue = "z" + g = ag.PairGrid(self.df, hue=hue) + assert hue not in g.x_vars + assert hue not in g.y_vars + + vars = ["x", "y", "z"] + g = ag.PairGrid(self.df, hue=hue, vars=vars) + assert hue in g.x_vars + assert hue in g.y_vars + + @pytest.mark.parametrize( + "x_vars, y_vars", + [ + (["x", "y"], ["z", "y", "x"]), + (["x", "y"], "z"), + (np.array(["x", "y"]), np.array(["z", "y", "x"])), + ], + ) + def test_specific_nonsquare_axes(self, x_vars, y_vars): + + g = ag.PairGrid(self.df, x_vars=x_vars, y_vars=y_vars) + assert g.axes.shape == (len(y_vars), len(x_vars)) + assert g.x_vars == list(x_vars) + assert g.y_vars == list(y_vars) + assert not g.square_grid + + def test_corner(self): + + plot_vars = ["x", "y", "z"] + g = ag.PairGrid(self.df, vars=plot_vars, corner=True) + corner_size = sum([i + 1 for i in range(len(plot_vars))]) + assert len(g.figure.axes) == corner_size + + g.map_diag(plt.hist) + assert len(g.figure.axes) == (corner_size + len(plot_vars)) + + for ax in np.diag(g.axes): + assert not ax.yaxis.get_visible() + assert not g.axes[0, 0].get_ylabel() + + plot_vars = ["x", "y", "z"] + g = ag.PairGrid(self.df, vars=plot_vars, corner=True) + g.map(scatterplot) + assert len(g.figure.axes) == corner_size + + def test_size(self): + + g1 = ag.PairGrid(self.df, height=3) + npt.assert_array_equal(g1.fig.get_size_inches(), (9, 9)) + + g2 = ag.PairGrid(self.df, height=4, aspect=.5) + npt.assert_array_equal(g2.fig.get_size_inches(), (6, 12)) + + g3 = ag.PairGrid(self.df, y_vars=["z"], x_vars=["x", "y"], + height=2, aspect=2) + npt.assert_array_equal(g3.fig.get_size_inches(), (8, 2)) + + def test_empty_grid(self): + + with pytest.raises(ValueError, match="No variables found"): + ag.PairGrid(self.df[["a", "b"]]) + + def test_map(self): + + vars = ["x", "y", "z"] + g1 = ag.PairGrid(self.df) + g1.map(plt.scatter) + + for i, axes_i in enumerate(g1.axes): + for j, ax in enumerate(axes_i): + x_in = self.df[vars[j]] + y_in = self.df[vars[i]] + x_out, y_out = ax.collections[0].get_offsets().T + npt.assert_array_equal(x_in, x_out) + npt.assert_array_equal(y_in, y_out) + + g2 = ag.PairGrid(self.df, hue="a") + g2.map(plt.scatter) + + for i, axes_i in enumerate(g2.axes): + for j, ax in enumerate(axes_i): + x_in = self.df[vars[j]] + y_in = self.df[vars[i]] + for k, k_level in enumerate(self.df.a.unique()): + x_in_k = x_in[self.df.a == k_level] + y_in_k = y_in[self.df.a == k_level] + x_out, y_out = ax.collections[k].get_offsets().T + npt.assert_array_equal(x_in_k, x_out) + npt.assert_array_equal(y_in_k, y_out) + + def test_map_nonsquare(self): + + x_vars = ["x"] + y_vars = ["y", "z"] + g = ag.PairGrid(self.df, x_vars=x_vars, y_vars=y_vars) + g.map(plt.scatter) + + x_in = self.df.x + for i, i_var in enumerate(y_vars): + ax = g.axes[i, 0] + y_in = self.df[i_var] + x_out, y_out = ax.collections[0].get_offsets().T + npt.assert_array_equal(x_in, x_out) + npt.assert_array_equal(y_in, y_out) + + def test_map_lower(self): + + vars = ["x", "y", "z"] + g = ag.PairGrid(self.df) + g.map_lower(plt.scatter) + + for i, j in zip(*np.tril_indices_from(g.axes, -1)): + ax = g.axes[i, j] + x_in = self.df[vars[j]] + y_in = self.df[vars[i]] + x_out, y_out = ax.collections[0].get_offsets().T + npt.assert_array_equal(x_in, x_out) + npt.assert_array_equal(y_in, y_out) + + for i, j in zip(*np.triu_indices_from(g.axes)): + ax = g.axes[i, j] + assert len(ax.collections) == 0 + + def test_map_upper(self): + + vars = ["x", "y", "z"] + g = ag.PairGrid(self.df) + g.map_upper(plt.scatter) + + for i, j in zip(*np.triu_indices_from(g.axes, 1)): + ax = g.axes[i, j] + x_in = self.df[vars[j]] + y_in = self.df[vars[i]] + x_out, y_out = ax.collections[0].get_offsets().T + npt.assert_array_equal(x_in, x_out) + npt.assert_array_equal(y_in, y_out) + + for i, j in zip(*np.tril_indices_from(g.axes)): + ax = g.axes[i, j] + assert len(ax.collections) == 0 + + def test_map_mixed_funcsig(self): + + vars = ["x", "y", "z"] + g = ag.PairGrid(self.df, vars=vars) + g.map_lower(scatterplot) + g.map_upper(plt.scatter) + + for i, j in zip(*np.triu_indices_from(g.axes, 1)): + ax = g.axes[i, j] + x_in = self.df[vars[j]] + y_in = self.df[vars[i]] + x_out, y_out = ax.collections[0].get_offsets().T + npt.assert_array_equal(x_in, x_out) + npt.assert_array_equal(y_in, y_out) + + def test_map_diag(self): + + g = ag.PairGrid(self.df) + g.map_diag(plt.hist) + + for var, ax in zip(g.diag_vars, g.diag_axes): + assert len(ax.patches) == 10 + assert pytest.approx(ax.patches[0].get_x()) == self.df[var].min() + + g = ag.PairGrid(self.df, hue="a") + g.map_diag(plt.hist) + + for ax in g.diag_axes: + assert len(ax.patches) == 30 + + g = ag.PairGrid(self.df, hue="a") + g.map_diag(plt.hist, histtype='step') + + for ax in g.diag_axes: + for ptch in ax.patches: + assert not ptch.fill + + def test_map_diag_rectangular(self): + + x_vars = ["x", "y"] + y_vars = ["x", "z", "y"] + g1 = ag.PairGrid(self.df, x_vars=x_vars, y_vars=y_vars) + g1.map_diag(plt.hist) + g1.map_offdiag(plt.scatter) + + assert set(g1.diag_vars) == (set(x_vars) & set(y_vars)) + + for var, ax in zip(g1.diag_vars, g1.diag_axes): + assert len(ax.patches) == 10 + assert pytest.approx(ax.patches[0].get_x()) == self.df[var].min() + + for j, x_var in enumerate(x_vars): + for i, y_var in enumerate(y_vars): + + ax = g1.axes[i, j] + if x_var == y_var: + diag_ax = g1.diag_axes[j] # because fewer x than y vars + assert ax.bbox.bounds == diag_ax.bbox.bounds + + else: + x, y = ax.collections[0].get_offsets().T + assert_array_equal(x, self.df[x_var]) + assert_array_equal(y, self.df[y_var]) + + g2 = ag.PairGrid(self.df, x_vars=x_vars, y_vars=y_vars, hue="a") + g2.map_diag(plt.hist) + g2.map_offdiag(plt.scatter) + + assert set(g2.diag_vars) == (set(x_vars) & set(y_vars)) + + for ax in g2.diag_axes: + assert len(ax.patches) == 30 + + x_vars = ["x", "y", "z"] + y_vars = ["x", "z"] + g3 = ag.PairGrid(self.df, x_vars=x_vars, y_vars=y_vars) + g3.map_diag(plt.hist) + g3.map_offdiag(plt.scatter) + + assert set(g3.diag_vars) == (set(x_vars) & set(y_vars)) + + for var, ax in zip(g3.diag_vars, g3.diag_axes): + assert len(ax.patches) == 10 + assert pytest.approx(ax.patches[0].get_x()) == self.df[var].min() + + for j, x_var in enumerate(x_vars): + for i, y_var in enumerate(y_vars): + + ax = g3.axes[i, j] + if x_var == y_var: + diag_ax = g3.diag_axes[i] # because fewer y than x vars + assert ax.bbox.bounds == diag_ax.bbox.bounds + else: + x, y = ax.collections[0].get_offsets().T + assert_array_equal(x, self.df[x_var]) + assert_array_equal(y, self.df[y_var]) + + def test_map_diag_color(self): + + color = "red" + + g1 = ag.PairGrid(self.df) + g1.map_diag(plt.hist, color=color) + + for ax in g1.diag_axes: + for patch in ax.patches: + assert_colors_equal(patch.get_facecolor(), color) + + g2 = ag.PairGrid(self.df) + g2.map_diag(kdeplot, color='red') + + for ax in g2.diag_axes: + for line in ax.lines: + assert_colors_equal(line.get_color(), color) + + def test_map_diag_palette(self): + + palette = "muted" + pal = color_palette(palette, n_colors=len(self.df.a.unique())) + g = ag.PairGrid(self.df, hue="a", palette=palette) + g.map_diag(kdeplot) + + for ax in g.diag_axes: + for line, color in zip(ax.lines[::-1], pal): + assert_colors_equal(line.get_color(), color) + + def test_map_diag_and_offdiag(self): + + vars = ["x", "y", "z"] + g = ag.PairGrid(self.df) + g.map_offdiag(plt.scatter) + g.map_diag(plt.hist) + + for ax in g.diag_axes: + assert len(ax.patches) == 10 + + for i, j in zip(*np.triu_indices_from(g.axes, 1)): + ax = g.axes[i, j] + x_in = self.df[vars[j]] + y_in = self.df[vars[i]] + x_out, y_out = ax.collections[0].get_offsets().T + npt.assert_array_equal(x_in, x_out) + npt.assert_array_equal(y_in, y_out) + + for i, j in zip(*np.tril_indices_from(g.axes, -1)): + ax = g.axes[i, j] + x_in = self.df[vars[j]] + y_in = self.df[vars[i]] + x_out, y_out = ax.collections[0].get_offsets().T + npt.assert_array_equal(x_in, x_out) + npt.assert_array_equal(y_in, y_out) + + for i, j in zip(*np.diag_indices_from(g.axes)): + ax = g.axes[i, j] + assert len(ax.collections) == 0 + + def test_diag_sharey(self): + + g = ag.PairGrid(self.df, diag_sharey=True) + g.map_diag(kdeplot) + for ax in g.diag_axes[1:]: + assert ax.get_ylim() == g.diag_axes[0].get_ylim() + + def test_map_diag_matplotlib(self): + + bins = 10 + g = ag.PairGrid(self.df) + g.map_diag(plt.hist, bins=bins) + for ax in g.diag_axes: + assert len(ax.patches) == bins + + levels = len(self.df["a"].unique()) + g = ag.PairGrid(self.df, hue="a") + g.map_diag(plt.hist, bins=bins) + for ax in g.diag_axes: + assert len(ax.patches) == (bins * levels) + + def test_palette(self): + + rcmod.set() + + g = ag.PairGrid(self.df, hue="a") + assert g.palette == color_palette(n_colors=len(self.df.a.unique())) + + g = ag.PairGrid(self.df, hue="b") + assert g.palette == color_palette("husl", len(self.df.b.unique())) + + g = ag.PairGrid(self.df, hue="a", palette="Set2") + assert g.palette == color_palette("Set2", len(self.df.a.unique())) + + dict_pal = dict(a="red", b="green", c="blue") + list_pal = color_palette(["red", "green", "blue"]) + g = ag.PairGrid(self.df, hue="a", palette=dict_pal) + assert g.palette == list_pal + + list_pal = color_palette(["blue", "red", "green"]) + g = ag.PairGrid(self.df, hue="a", hue_order=list("cab"), + palette=dict_pal) + assert g.palette == list_pal + + def test_hue_kws(self): + + kws = dict(marker=["o", "s", "d", "+"]) + g = ag.PairGrid(self.df, hue="a", hue_kws=kws) + g.map(plt.plot) + + for line, marker in zip(g.axes[0, 0].lines, kws["marker"]): + assert line.get_marker() == marker + + g = ag.PairGrid(self.df, hue="a", hue_kws=kws, + hue_order=list("dcab")) + g.map(plt.plot) + + for line, marker in zip(g.axes[0, 0].lines, kws["marker"]): + assert line.get_marker() == marker + + def test_hue_order(self): + + order = list("dcab") + g = ag.PairGrid(self.df, hue="a", hue_order=order) + g.map(plt.plot) + + for line, level in zip(g.axes[1, 0].lines, order): + x, y = line.get_xydata().T + npt.assert_array_equal(x, self.df.loc[self.df.a == level, "x"]) + npt.assert_array_equal(y, self.df.loc[self.df.a == level, "y"]) + + plt.close("all") + + g = ag.PairGrid(self.df, hue="a", hue_order=order) + g.map_diag(plt.plot) + + for line, level in zip(g.axes[0, 0].lines, order): + x, y = line.get_xydata().T + npt.assert_array_equal(x, self.df.loc[self.df.a == level, "x"]) + npt.assert_array_equal(y, self.df.loc[self.df.a == level, "x"]) + + plt.close("all") + + g = ag.PairGrid(self.df, hue="a", hue_order=order) + g.map_lower(plt.plot) + + for line, level in zip(g.axes[1, 0].lines, order): + x, y = line.get_xydata().T + npt.assert_array_equal(x, self.df.loc[self.df.a == level, "x"]) + npt.assert_array_equal(y, self.df.loc[self.df.a == level, "y"]) + + plt.close("all") + + g = ag.PairGrid(self.df, hue="a", hue_order=order) + g.map_upper(plt.plot) + + for line, level in zip(g.axes[0, 1].lines, order): + x, y = line.get_xydata().T + npt.assert_array_equal(x, self.df.loc[self.df.a == level, "y"]) + npt.assert_array_equal(y, self.df.loc[self.df.a == level, "x"]) + + plt.close("all") + + def test_hue_order_missing_level(self): + + order = list("dcaeb") + g = ag.PairGrid(self.df, hue="a", hue_order=order) + g.map(plt.plot) + + for line, level in zip(g.axes[1, 0].lines, order): + x, y = line.get_xydata().T + npt.assert_array_equal(x, self.df.loc[self.df.a == level, "x"]) + npt.assert_array_equal(y, self.df.loc[self.df.a == level, "y"]) + + plt.close("all") + + g = ag.PairGrid(self.df, hue="a", hue_order=order) + g.map_diag(plt.plot) + + for line, level in zip(g.axes[0, 0].lines, order): + x, y = line.get_xydata().T + npt.assert_array_equal(x, self.df.loc[self.df.a == level, "x"]) + npt.assert_array_equal(y, self.df.loc[self.df.a == level, "x"]) + + plt.close("all") + + g = ag.PairGrid(self.df, hue="a", hue_order=order) + g.map_lower(plt.plot) + + for line, level in zip(g.axes[1, 0].lines, order): + x, y = line.get_xydata().T + npt.assert_array_equal(x, self.df.loc[self.df.a == level, "x"]) + npt.assert_array_equal(y, self.df.loc[self.df.a == level, "y"]) + + plt.close("all") + + g = ag.PairGrid(self.df, hue="a", hue_order=order) + g.map_upper(plt.plot) + + for line, level in zip(g.axes[0, 1].lines, order): + x, y = line.get_xydata().T + npt.assert_array_equal(x, self.df.loc[self.df.a == level, "y"]) + npt.assert_array_equal(y, self.df.loc[self.df.a == level, "x"]) + + plt.close("all") + + def test_nondefault_index(self): + + df = self.df.copy().set_index("b") + + plot_vars = ["x", "y", "z"] + g1 = ag.PairGrid(df) + g1.map(plt.scatter) + + for i, axes_i in enumerate(g1.axes): + for j, ax in enumerate(axes_i): + x_in = self.df[plot_vars[j]] + y_in = self.df[plot_vars[i]] + x_out, y_out = ax.collections[0].get_offsets().T + npt.assert_array_equal(x_in, x_out) + npt.assert_array_equal(y_in, y_out) + + g2 = ag.PairGrid(df, hue="a") + g2.map(plt.scatter) + + for i, axes_i in enumerate(g2.axes): + for j, ax in enumerate(axes_i): + x_in = self.df[plot_vars[j]] + y_in = self.df[plot_vars[i]] + for k, k_level in enumerate(self.df.a.unique()): + x_in_k = x_in[self.df.a == k_level] + y_in_k = y_in[self.df.a == k_level] + x_out, y_out = ax.collections[k].get_offsets().T + npt.assert_array_equal(x_in_k, x_out) + npt.assert_array_equal(y_in_k, y_out) + + @pytest.mark.parametrize("func", [scatterplot, plt.scatter]) + def test_dropna(self, func): + + df = self.df.copy() + n_null = 20 + df.loc[np.arange(n_null), "x"] = np.nan + + plot_vars = ["x", "y", "z"] + + g1 = ag.PairGrid(df, vars=plot_vars, dropna=True) + g1.map(func) + + for i, axes_i in enumerate(g1.axes): + for j, ax in enumerate(axes_i): + x_in = df[plot_vars[j]] + y_in = df[plot_vars[i]] + x_out, y_out = ax.collections[0].get_offsets().T + + n_valid = (x_in * y_in).notnull().sum() + + assert n_valid == len(x_out) + assert n_valid == len(y_out) + + g1.map_diag(histplot) + for i, ax in enumerate(g1.diag_axes): + var = plot_vars[i] + count = sum([p.get_height() for p in ax.patches]) + assert count == df[var].notna().sum() + + def test_histplot_legend(self): + + # Tests _extract_legend_handles + g = ag.PairGrid(self.df, vars=["x", "y"], hue="a") + g.map_offdiag(histplot) + g.add_legend() + + assert len(g._legend.legendHandles) == len(self.df["a"].unique()) + + def test_pairplot(self): + + vars = ["x", "y", "z"] + g = ag.pairplot(self.df) + + for ax in g.diag_axes: + assert len(ax.patches) > 1 + + for i, j in zip(*np.triu_indices_from(g.axes, 1)): + ax = g.axes[i, j] + x_in = self.df[vars[j]] + y_in = self.df[vars[i]] + x_out, y_out = ax.collections[0].get_offsets().T + npt.assert_array_equal(x_in, x_out) + npt.assert_array_equal(y_in, y_out) + + for i, j in zip(*np.tril_indices_from(g.axes, -1)): + ax = g.axes[i, j] + x_in = self.df[vars[j]] + y_in = self.df[vars[i]] + x_out, y_out = ax.collections[0].get_offsets().T + npt.assert_array_equal(x_in, x_out) + npt.assert_array_equal(y_in, y_out) + + for i, j in zip(*np.diag_indices_from(g.axes)): + ax = g.axes[i, j] + assert len(ax.collections) == 0 + + g = ag.pairplot(self.df, hue="a") + n = len(self.df.a.unique()) + + for ax in g.diag_axes: + assert len(ax.collections) == n + + def test_pairplot_reg(self): + + vars = ["x", "y", "z"] + g = ag.pairplot(self.df, diag_kind="hist", kind="reg") + + for ax in g.diag_axes: + assert len(ax.patches) + + for i, j in zip(*np.triu_indices_from(g.axes, 1)): + ax = g.axes[i, j] + x_in = self.df[vars[j]] + y_in = self.df[vars[i]] + x_out, y_out = ax.collections[0].get_offsets().T + npt.assert_array_equal(x_in, x_out) + npt.assert_array_equal(y_in, y_out) + + assert len(ax.lines) == 1 + assert len(ax.collections) == 2 + + for i, j in zip(*np.tril_indices_from(g.axes, -1)): + ax = g.axes[i, j] + x_in = self.df[vars[j]] + y_in = self.df[vars[i]] + x_out, y_out = ax.collections[0].get_offsets().T + npt.assert_array_equal(x_in, x_out) + npt.assert_array_equal(y_in, y_out) + + assert len(ax.lines) == 1 + assert len(ax.collections) == 2 + + for i, j in zip(*np.diag_indices_from(g.axes)): + ax = g.axes[i, j] + assert len(ax.collections) == 0 + + def test_pairplot_reg_hue(self): + + markers = ["o", "s", "d"] + g = ag.pairplot(self.df, kind="reg", hue="a", markers=markers) + + ax = g.axes[-1, 0] + c1 = ax.collections[0] + c2 = ax.collections[2] + + assert not np.array_equal(c1.get_facecolor(), c2.get_facecolor()) + assert not np.array_equal( + c1.get_paths()[0].vertices, c2.get_paths()[0].vertices, + ) + + def test_pairplot_diag_kde(self): + + vars = ["x", "y", "z"] + g = ag.pairplot(self.df, diag_kind="kde") + + for ax in g.diag_axes: + assert len(ax.collections) == 1 + + for i, j in zip(*np.triu_indices_from(g.axes, 1)): + ax = g.axes[i, j] + x_in = self.df[vars[j]] + y_in = self.df[vars[i]] + x_out, y_out = ax.collections[0].get_offsets().T + npt.assert_array_equal(x_in, x_out) + npt.assert_array_equal(y_in, y_out) + + for i, j in zip(*np.tril_indices_from(g.axes, -1)): + ax = g.axes[i, j] + x_in = self.df[vars[j]] + y_in = self.df[vars[i]] + x_out, y_out = ax.collections[0].get_offsets().T + npt.assert_array_equal(x_in, x_out) + npt.assert_array_equal(y_in, y_out) + + for i, j in zip(*np.diag_indices_from(g.axes)): + ax = g.axes[i, j] + assert len(ax.collections) == 0 + + def test_pairplot_kde(self): + + f, ax1 = plt.subplots() + kdeplot(data=self.df, x="x", y="y", ax=ax1) + + g = ag.pairplot(self.df, kind="kde") + ax2 = g.axes[1, 0] + + assert_plots_equal(ax1, ax2, labels=False) + + def test_pairplot_hist(self): + + f, ax1 = plt.subplots() + histplot(data=self.df, x="x", y="y", ax=ax1) + + g = ag.pairplot(self.df, kind="hist") + ax2 = g.axes[1, 0] + + assert_plots_equal(ax1, ax2, labels=False) + + def test_pairplot_markers(self): + + vars = ["x", "y", "z"] + markers = ["o", "X", "s"] + g = ag.pairplot(self.df, hue="a", vars=vars, markers=markers) + m1 = g._legend.legendHandles[0].get_paths()[0] + m2 = g._legend.legendHandles[1].get_paths()[0] + assert m1 != m2 + + with pytest.raises(ValueError): + g = ag.pairplot(self.df, hue="a", vars=vars, markers=markers[:-2]) + + def test_corner_despine(self): + + g = ag.PairGrid(self.df, corner=True, despine=False) + g.map_diag(histplot) + assert g.axes[0, 0].spines["top"].get_visible() + + def test_corner_set(self): + + g = ag.PairGrid(self.df, corner=True, despine=False) + g.set(xlim=(0, 10)) + assert g.axes[-1, 0].get_xlim() == (0, 10) + + def test_legend(self): + + g1 = ag.pairplot(self.df, hue="a") + assert isinstance(g1.legend, mpl.legend.Legend) + + g2 = ag.pairplot(self.df) + assert g2.legend is None + + +class TestJointGrid: + + rs = np.random.RandomState(sum(map(ord, "JointGrid"))) + x = rs.randn(100) + y = rs.randn(100) + x_na = x.copy() + x_na[10] = np.nan + x_na[20] = np.nan + data = pd.DataFrame(dict(x=x, y=y, x_na=x_na)) + + def test_margin_grid_from_lists(self): + + g = ag.JointGrid(x=self.x.tolist(), y=self.y.tolist()) + npt.assert_array_equal(g.x, self.x) + npt.assert_array_equal(g.y, self.y) + + def test_margin_grid_from_arrays(self): + + g = ag.JointGrid(x=self.x, y=self.y) + npt.assert_array_equal(g.x, self.x) + npt.assert_array_equal(g.y, self.y) + + def test_margin_grid_from_series(self): + + g = ag.JointGrid(x=self.data.x, y=self.data.y) + npt.assert_array_equal(g.x, self.x) + npt.assert_array_equal(g.y, self.y) + + def test_margin_grid_from_dataframe(self): + + g = ag.JointGrid(x="x", y="y", data=self.data) + npt.assert_array_equal(g.x, self.x) + npt.assert_array_equal(g.y, self.y) + + def test_margin_grid_from_dataframe_bad_variable(self): + + with pytest.raises(ValueError): + ag.JointGrid(x="x", y="bad_column", data=self.data) + + def test_margin_grid_axis_labels(self): + + g = ag.JointGrid(x="x", y="y", data=self.data) + + xlabel, ylabel = g.ax_joint.get_xlabel(), g.ax_joint.get_ylabel() + assert xlabel == "x" + assert ylabel == "y" + + g.set_axis_labels("x variable", "y variable") + xlabel, ylabel = g.ax_joint.get_xlabel(), g.ax_joint.get_ylabel() + assert xlabel == "x variable" + assert ylabel == "y variable" + + def test_dropna(self): + + g = ag.JointGrid(x="x_na", y="y", data=self.data, dropna=False) + assert len(g.x) == len(self.x_na) + + g = ag.JointGrid(x="x_na", y="y", data=self.data, dropna=True) + assert len(g.x) == pd.notnull(self.x_na).sum() + + def test_axlims(self): + + lim = (-3, 3) + g = ag.JointGrid(x="x", y="y", data=self.data, xlim=lim, ylim=lim) + + assert g.ax_joint.get_xlim() == lim + assert g.ax_joint.get_ylim() == lim + + assert g.ax_marg_x.get_xlim() == lim + assert g.ax_marg_y.get_ylim() == lim + + def test_marginal_ticks(self): + + g = ag.JointGrid(marginal_ticks=False) + assert not sum(t.get_visible() for t in g.ax_marg_x.get_yticklabels()) + assert not sum(t.get_visible() for t in g.ax_marg_y.get_xticklabels()) + + g = ag.JointGrid(marginal_ticks=True) + assert sum(t.get_visible() for t in g.ax_marg_x.get_yticklabels()) + assert sum(t.get_visible() for t in g.ax_marg_y.get_xticklabels()) + + def test_bivariate_plot(self): + + g = ag.JointGrid(x="x", y="y", data=self.data) + g.plot_joint(plt.plot) + + x, y = g.ax_joint.lines[0].get_xydata().T + npt.assert_array_equal(x, self.x) + npt.assert_array_equal(y, self.y) + + def test_univariate_plot(self): + + g = ag.JointGrid(x="x", y="x", data=self.data) + g.plot_marginals(kdeplot) + + _, y1 = g.ax_marg_x.lines[0].get_xydata().T + y2, _ = g.ax_marg_y.lines[0].get_xydata().T + npt.assert_array_equal(y1, y2) + + def test_univariate_plot_distplot(self): + + bins = 10 + g = ag.JointGrid(x="x", y="x", data=self.data) + with pytest.warns(FutureWarning): + g.plot_marginals(distplot, bins=bins) + assert len(g.ax_marg_x.patches) == bins + assert len(g.ax_marg_y.patches) == bins + for x, y in zip(g.ax_marg_x.patches, g.ax_marg_y.patches): + assert x.get_height() == y.get_width() + + def test_univariate_plot_matplotlib(self): + + bins = 10 + g = ag.JointGrid(x="x", y="x", data=self.data) + g.plot_marginals(plt.hist, bins=bins) + assert len(g.ax_marg_x.patches) == bins + assert len(g.ax_marg_y.patches) == bins + + def test_plot(self): + + g = ag.JointGrid(x="x", y="x", data=self.data) + g.plot(plt.plot, kdeplot) + + x, y = g.ax_joint.lines[0].get_xydata().T + npt.assert_array_equal(x, self.x) + npt.assert_array_equal(y, self.x) + + _, y1 = g.ax_marg_x.lines[0].get_xydata().T + y2, _ = g.ax_marg_y.lines[0].get_xydata().T + npt.assert_array_equal(y1, y2) + + def test_space(self): + + g = ag.JointGrid(x="x", y="y", data=self.data, space=0) + + joint_bounds = g.ax_joint.bbox.bounds + marg_x_bounds = g.ax_marg_x.bbox.bounds + marg_y_bounds = g.ax_marg_y.bbox.bounds + + assert joint_bounds[2] == marg_x_bounds[2] + assert joint_bounds[3] == marg_y_bounds[3] + + @pytest.mark.parametrize( + "as_vector", [True, False], + ) + def test_hue(self, long_df, as_vector): + + if as_vector: + data = None + x, y, hue = long_df["x"], long_df["y"], long_df["a"] + else: + data = long_df + x, y, hue = "x", "y", "a" + + g = ag.JointGrid(data=data, x=x, y=y, hue=hue) + g.plot_joint(scatterplot) + g.plot_marginals(histplot) + + g2 = ag.JointGrid() + scatterplot(data=long_df, x=x, y=y, hue=hue, ax=g2.ax_joint) + histplot(data=long_df, x=x, hue=hue, ax=g2.ax_marg_x) + histplot(data=long_df, y=y, hue=hue, ax=g2.ax_marg_y) + + assert_plots_equal(g.ax_joint, g2.ax_joint) + assert_plots_equal(g.ax_marg_x, g2.ax_marg_x, labels=False) + assert_plots_equal(g.ax_marg_y, g2.ax_marg_y, labels=False) + + def test_refline(self): + + g = ag.JointGrid(x="x", y="y", data=self.data) + g.plot(scatterplot, histplot) + g.refline() + assert not g.ax_joint.lines and not g.ax_marg_x.lines and not g.ax_marg_y.lines + + refx = refy = 0.5 + hline = np.array([[0, refy], [1, refy]]) + vline = np.array([[refx, 0], [refx, 1]]) + g.refline(x=refx, y=refy, joint=False, marginal=False) + assert not g.ax_joint.lines and not g.ax_marg_x.lines and not g.ax_marg_y.lines + + g.refline(x=refx, y=refy) + assert g.ax_joint.lines[0].get_color() == '.5' + assert g.ax_joint.lines[0].get_linestyle() == '--' + assert len(g.ax_joint.lines) == 2 + assert len(g.ax_marg_x.lines) == 1 + assert len(g.ax_marg_y.lines) == 1 + npt.assert_array_equal(g.ax_joint.lines[0].get_xydata(), vline) + npt.assert_array_equal(g.ax_joint.lines[1].get_xydata(), hline) + npt.assert_array_equal(g.ax_marg_x.lines[0].get_xydata(), vline) + npt.assert_array_equal(g.ax_marg_y.lines[0].get_xydata(), hline) + + color, linestyle = 'red', '-' + g.refline(x=refx, marginal=False, color=color, linestyle=linestyle) + npt.assert_array_equal(g.ax_joint.lines[-1].get_xydata(), vline) + assert g.ax_joint.lines[-1].get_color() == color + assert g.ax_joint.lines[-1].get_linestyle() == linestyle + assert len(g.ax_marg_x.lines) == len(g.ax_marg_y.lines) + + g.refline(x=refx, joint=False) + npt.assert_array_equal(g.ax_marg_x.lines[-1].get_xydata(), vline) + assert len(g.ax_marg_x.lines) == len(g.ax_marg_y.lines) + 1 + + g.refline(y=refy, joint=False) + npt.assert_array_equal(g.ax_marg_y.lines[-1].get_xydata(), hline) + assert len(g.ax_marg_x.lines) == len(g.ax_marg_y.lines) + + g.refline(y=refy, marginal=False) + npt.assert_array_equal(g.ax_joint.lines[-1].get_xydata(), hline) + assert len(g.ax_marg_x.lines) == len(g.ax_marg_y.lines) + + +class TestJointPlot: + + rs = np.random.RandomState(sum(map(ord, "jointplot"))) + x = rs.randn(100) + y = rs.randn(100) + data = pd.DataFrame(dict(x=x, y=y)) + + def test_scatter(self): + + g = ag.jointplot(x="x", y="y", data=self.data) + assert len(g.ax_joint.collections) == 1 + + x, y = g.ax_joint.collections[0].get_offsets().T + assert_array_equal(self.x, x) + assert_array_equal(self.y, y) + + assert_array_equal( + [b.get_x() for b in g.ax_marg_x.patches], + np.histogram_bin_edges(self.x, "auto")[:-1], + ) + + assert_array_equal( + [b.get_y() for b in g.ax_marg_y.patches], + np.histogram_bin_edges(self.y, "auto")[:-1], + ) + + def test_scatter_hue(self, long_df): + + g1 = ag.jointplot(data=long_df, x="x", y="y", hue="a") + + g2 = ag.JointGrid() + scatterplot(data=long_df, x="x", y="y", hue="a", ax=g2.ax_joint) + kdeplot(data=long_df, x="x", hue="a", ax=g2.ax_marg_x, fill=True) + kdeplot(data=long_df, y="y", hue="a", ax=g2.ax_marg_y, fill=True) + + assert_plots_equal(g1.ax_joint, g2.ax_joint) + assert_plots_equal(g1.ax_marg_x, g2.ax_marg_x, labels=False) + assert_plots_equal(g1.ax_marg_y, g2.ax_marg_y, labels=False) + + def test_reg(self): + + g = ag.jointplot(x="x", y="y", data=self.data, kind="reg") + assert len(g.ax_joint.collections) == 2 + + x, y = g.ax_joint.collections[0].get_offsets().T + assert_array_equal(self.x, x) + assert_array_equal(self.y, y) + + assert g.ax_marg_x.patches + assert g.ax_marg_y.patches + + assert g.ax_marg_x.lines + assert g.ax_marg_y.lines + + def test_resid(self): + + g = ag.jointplot(x="x", y="y", data=self.data, kind="resid") + assert g.ax_joint.collections + assert g.ax_joint.lines + assert not g.ax_marg_x.lines + assert not g.ax_marg_y.lines + + def test_hist(self, long_df): + + bins = 3, 6 + g1 = ag.jointplot(data=long_df, x="x", y="y", kind="hist", bins=bins) + + g2 = ag.JointGrid() + histplot(data=long_df, x="x", y="y", ax=g2.ax_joint, bins=bins) + histplot(data=long_df, x="x", ax=g2.ax_marg_x, bins=bins[0]) + histplot(data=long_df, y="y", ax=g2.ax_marg_y, bins=bins[1]) + + assert_plots_equal(g1.ax_joint, g2.ax_joint) + assert_plots_equal(g1.ax_marg_x, g2.ax_marg_x, labels=False) + assert_plots_equal(g1.ax_marg_y, g2.ax_marg_y, labels=False) + + def test_hex(self): + + g = ag.jointplot(x="x", y="y", data=self.data, kind="hex") + assert g.ax_joint.collections + assert g.ax_marg_x.patches + assert g.ax_marg_y.patches + + def test_kde(self, long_df): + + g1 = ag.jointplot(data=long_df, x="x", y="y", kind="kde") + + g2 = ag.JointGrid() + kdeplot(data=long_df, x="x", y="y", ax=g2.ax_joint) + kdeplot(data=long_df, x="x", ax=g2.ax_marg_x) + kdeplot(data=long_df, y="y", ax=g2.ax_marg_y) + + assert_plots_equal(g1.ax_joint, g2.ax_joint) + assert_plots_equal(g1.ax_marg_x, g2.ax_marg_x, labels=False) + assert_plots_equal(g1.ax_marg_y, g2.ax_marg_y, labels=False) + + def test_kde_hue(self, long_df): + + g1 = ag.jointplot(data=long_df, x="x", y="y", hue="a", kind="kde") + + g2 = ag.JointGrid() + kdeplot(data=long_df, x="x", y="y", hue="a", ax=g2.ax_joint) + kdeplot(data=long_df, x="x", hue="a", ax=g2.ax_marg_x) + kdeplot(data=long_df, y="y", hue="a", ax=g2.ax_marg_y) + + assert_plots_equal(g1.ax_joint, g2.ax_joint) + assert_plots_equal(g1.ax_marg_x, g2.ax_marg_x, labels=False) + assert_plots_equal(g1.ax_marg_y, g2.ax_marg_y, labels=False) + + def test_color(self): + + g = ag.jointplot(x="x", y="y", data=self.data, color="purple") + + purple = mpl.colors.colorConverter.to_rgb("purple") + scatter_color = g.ax_joint.collections[0].get_facecolor()[0, :3] + assert tuple(scatter_color) == purple + + hist_color = g.ax_marg_x.patches[0].get_facecolor()[:3] + assert hist_color == purple + + def test_palette(self, long_df): + + kws = dict(data=long_df, hue="a", palette="Set2") + + g1 = ag.jointplot(x="x", y="y", **kws) + + g2 = ag.JointGrid() + scatterplot(x="x", y="y", ax=g2.ax_joint, **kws) + kdeplot(x="x", ax=g2.ax_marg_x, fill=True, **kws) + kdeplot(y="y", ax=g2.ax_marg_y, fill=True, **kws) + + assert_plots_equal(g1.ax_joint, g2.ax_joint) + assert_plots_equal(g1.ax_marg_x, g2.ax_marg_x, labels=False) + assert_plots_equal(g1.ax_marg_y, g2.ax_marg_y, labels=False) + + def test_hex_customise(self): + + # test that default gridsize can be overridden + g = ag.jointplot(x="x", y="y", data=self.data, kind="hex", + joint_kws=dict(gridsize=5)) + assert len(g.ax_joint.collections) == 1 + a = g.ax_joint.collections[0].get_array() + assert a.shape[0] == 28 # 28 hexagons expected for gridsize 5 + + def test_bad_kind(self): + + with pytest.raises(ValueError): + ag.jointplot(x="x", y="y", data=self.data, kind="not_a_kind") + + def test_unsupported_hue_kind(self): + + for kind in ["reg", "resid", "hex"]: + with pytest.raises(ValueError): + ag.jointplot(x="x", y="y", hue="a", data=self.data, kind=kind) + + def test_leaky_dict(self): + # Validate input dicts are unchanged by jointplot plotting function + + for kwarg in ("joint_kws", "marginal_kws"): + for kind in ("hex", "kde", "resid", "reg", "scatter"): + empty_dict = {} + ag.jointplot(x="x", y="y", data=self.data, kind=kind, + **{kwarg: empty_dict}) + assert empty_dict == {} + + def test_distplot_kwarg_warning(self, long_df): + + with pytest.warns(UserWarning): + g = ag.jointplot(data=long_df, x="x", y="y", marginal_kws=dict(rug=True)) + assert g.ax_marg_x.patches diff --git a/grplot_seaborn/tests/test_categorical.py b/grplot_seaborn/tests/test_categorical.py new file mode 100644 index 0000000..a0b0393 --- /dev/null +++ b/grplot_seaborn/tests/test_categorical.py @@ -0,0 +1,3024 @@ +import numpy as np +import pandas as pd +from scipy import stats, spatial +import matplotlib as mpl +import matplotlib.pyplot as plt +from matplotlib.colors import rgb2hex + +import pytest +from pytest import approx +import numpy.testing as npt +from distutils.version import LooseVersion + +from .. import categorical as cat +from .. import palettes + + +class CategoricalFixture: + """Test boxplot (also base class for things like violinplots).""" + rs = np.random.RandomState(30) + n_total = 60 + x = rs.randn(int(n_total / 3), 3) + x_df = pd.DataFrame(x, columns=pd.Series(list("XYZ"), name="big")) + y = pd.Series(rs.randn(n_total), name="y_data") + y_perm = y.reindex(rs.choice(y.index, y.size, replace=False)) + g = pd.Series(np.repeat(list("abc"), int(n_total / 3)), name="small") + h = pd.Series(np.tile(list("mn"), int(n_total / 2)), name="medium") + u = pd.Series(np.tile(list("jkh"), int(n_total / 3))) + df = pd.DataFrame(dict(y=y, g=g, h=h, u=u)) + x_df["W"] = g + + +class TestCategoricalPlotter(CategoricalFixture): + + def test_wide_df_data(self): + + p = cat._CategoricalPlotter() + + # Test basic wide DataFrame + p.establish_variables(data=self.x_df) + + # Check data attribute + for x, y, in zip(p.plot_data, self.x_df[["X", "Y", "Z"]].values.T): + npt.assert_array_equal(x, y) + + # Check semantic attributes + assert p.orient == "v" + assert p.plot_hues is None + assert p.group_label == "big" + assert p.value_label is None + + # Test wide dataframe with forced horizontal orientation + p.establish_variables(data=self.x_df, orient="horiz") + assert p.orient == "h" + + # Test exception by trying to hue-group with a wide dataframe + with pytest.raises(ValueError): + p.establish_variables(hue="d", data=self.x_df) + + def test_1d_input_data(self): + + p = cat._CategoricalPlotter() + + # Test basic vector data + x_1d_array = self.x.ravel() + p.establish_variables(data=x_1d_array) + assert len(p.plot_data) == 1 + assert len(p.plot_data[0]) == self.n_total + assert p.group_label is None + assert p.value_label is None + + # Test basic vector data in list form + x_1d_list = x_1d_array.tolist() + p.establish_variables(data=x_1d_list) + assert len(p.plot_data) == 1 + assert len(p.plot_data[0]) == self.n_total + assert p.group_label is None + assert p.value_label is None + + # Test an object array that looks 1D but isn't + x_notreally_1d = np.array([self.x.ravel(), + self.x.ravel()[:int(self.n_total / 2)]], + dtype=object) + p.establish_variables(data=x_notreally_1d) + assert len(p.plot_data) == 2 + assert len(p.plot_data[0]) == self.n_total + assert len(p.plot_data[1]) == self.n_total / 2 + assert p.group_label is None + assert p.value_label is None + + def test_2d_input_data(self): + + p = cat._CategoricalPlotter() + + x = self.x[:, 0] + + # Test vector data that looks 2D but doesn't really have columns + p.establish_variables(data=x[:, np.newaxis]) + assert len(p.plot_data) == 1 + assert len(p.plot_data[0]) == self.x.shape[0] + assert p.group_label is None + assert p.value_label is None + + # Test vector data that looks 2D but doesn't really have rows + p.establish_variables(data=x[np.newaxis, :]) + assert len(p.plot_data) == 1 + assert len(p.plot_data[0]) == self.x.shape[0] + assert p.group_label is None + assert p.value_label is None + + def test_3d_input_data(self): + + p = cat._CategoricalPlotter() + + # Test that passing actually 3D data raises + x = np.zeros((5, 5, 5)) + with pytest.raises(ValueError): + p.establish_variables(data=x) + + def test_list_of_array_input_data(self): + + p = cat._CategoricalPlotter() + + # Test 2D input in list form + x_list = self.x.T.tolist() + p.establish_variables(data=x_list) + assert len(p.plot_data) == 3 + + lengths = [len(v_i) for v_i in p.plot_data] + assert lengths == [self.n_total / 3] * 3 + + assert p.group_label is None + assert p.value_label is None + + def test_wide_array_input_data(self): + + p = cat._CategoricalPlotter() + + # Test 2D input in array form + p.establish_variables(data=self.x) + assert np.shape(p.plot_data) == (3, self.n_total / 3) + npt.assert_array_equal(p.plot_data, self.x.T) + + assert p.group_label is None + assert p.value_label is None + + def test_single_long_direct_inputs(self): + + p = cat._CategoricalPlotter() + + # Test passing a series to the x variable + p.establish_variables(x=self.y) + npt.assert_equal(p.plot_data, [self.y]) + assert p.orient == "h" + assert p.value_label == "y_data" + assert p.group_label is None + + # Test passing a series to the y variable + p.establish_variables(y=self.y) + npt.assert_equal(p.plot_data, [self.y]) + assert p.orient == "v" + assert p.value_label == "y_data" + assert p.group_label is None + + # Test passing an array to the y variable + p.establish_variables(y=self.y.values) + npt.assert_equal(p.plot_data, [self.y]) + assert p.orient == "v" + assert p.group_label is None + assert p.value_label is None + + # Test array and series with non-default index + x = pd.Series([1, 1, 1, 1], index=[0, 2, 4, 6]) + y = np.array([1, 2, 3, 4]) + p.establish_variables(x, y) + assert len(p.plot_data[0]) == 4 + + def test_single_long_indirect_inputs(self): + + p = cat._CategoricalPlotter() + + # Test referencing a DataFrame series in the x variable + p.establish_variables(x="y", data=self.df) + npt.assert_equal(p.plot_data, [self.y]) + assert p.orient == "h" + assert p.value_label == "y" + assert p.group_label is None + + # Test referencing a DataFrame series in the y variable + p.establish_variables(y="y", data=self.df) + npt.assert_equal(p.plot_data, [self.y]) + assert p.orient == "v" + assert p.value_label == "y" + assert p.group_label is None + + def test_longform_groupby(self): + + p = cat._CategoricalPlotter() + + # Test a vertically oriented grouped and nested plot + p.establish_variables("g", "y", hue="h", data=self.df) + assert len(p.plot_data) == 3 + assert len(p.plot_hues) == 3 + assert p.orient == "v" + assert p.value_label == "y" + assert p.group_label == "g" + assert p.hue_title == "h" + + for group, vals in zip(["a", "b", "c"], p.plot_data): + npt.assert_array_equal(vals, self.y[self.g == group]) + + for group, hues in zip(["a", "b", "c"], p.plot_hues): + npt.assert_array_equal(hues, self.h[self.g == group]) + + # Test a grouped and nested plot with direct array value data + p.establish_variables("g", self.y.values, "h", self.df) + assert p.value_label is None + assert p.group_label == "g" + + for group, vals in zip(["a", "b", "c"], p.plot_data): + npt.assert_array_equal(vals, self.y[self.g == group]) + + # Test a grouped and nested plot with direct array hue data + p.establish_variables("g", "y", self.h.values, self.df) + + for group, hues in zip(["a", "b", "c"], p.plot_hues): + npt.assert_array_equal(hues, self.h[self.g == group]) + + # Test categorical grouping data + df = self.df.copy() + df.g = df.g.astype("category") + + # Test that horizontal orientation is automatically detected + p.establish_variables("y", "g", hue="h", data=df) + assert len(p.plot_data) == 3 + assert len(p.plot_hues) == 3 + assert p.orient == "h" + assert p.value_label == "y" + assert p.group_label == "g" + assert p.hue_title == "h" + + for group, vals in zip(["a", "b", "c"], p.plot_data): + npt.assert_array_equal(vals, self.y[self.g == group]) + + for group, hues in zip(["a", "b", "c"], p.plot_hues): + npt.assert_array_equal(hues, self.h[self.g == group]) + + # Test grouped data that matches on index + p1 = cat._CategoricalPlotter() + p1.establish_variables(self.g, self.y, hue=self.h) + p2 = cat._CategoricalPlotter() + p2.establish_variables(self.g, self.y[::-1], self.h) + for i, (d1, d2) in enumerate(zip(p1.plot_data, p2.plot_data)): + assert np.array_equal(d1.sort_index(), d2.sort_index()) + + def test_input_validation(self): + + p = cat._CategoricalPlotter() + + kws = dict(x="g", y="y", hue="h", units="u", data=self.df) + for var in ["x", "y", "hue", "units"]: + input_kws = kws.copy() + input_kws[var] = "bad_input" + with pytest.raises(ValueError): + p.establish_variables(**input_kws) + + def test_order(self): + + p = cat._CategoricalPlotter() + + # Test inferred order from a wide dataframe input + p.establish_variables(data=self.x_df) + assert p.group_names == ["X", "Y", "Z"] + + # Test specified order with a wide dataframe input + p.establish_variables(data=self.x_df, order=["Y", "Z", "X"]) + assert p.group_names == ["Y", "Z", "X"] + + for group, vals in zip(["Y", "Z", "X"], p.plot_data): + npt.assert_array_equal(vals, self.x_df[group]) + + with pytest.raises(ValueError): + p.establish_variables(data=self.x, order=[1, 2, 0]) + + # Test inferred order from a grouped longform input + p.establish_variables("g", "y", data=self.df) + assert p.group_names == ["a", "b", "c"] + + # Test specified order from a grouped longform input + p.establish_variables("g", "y", data=self.df, order=["b", "a", "c"]) + assert p.group_names == ["b", "a", "c"] + + for group, vals in zip(["b", "a", "c"], p.plot_data): + npt.assert_array_equal(vals, self.y[self.g == group]) + + # Test inferred order from a grouped input with categorical groups + df = self.df.copy() + df.g = df.g.astype("category") + df.g = df.g.cat.reorder_categories(["c", "b", "a"]) + p.establish_variables("g", "y", data=df) + assert p.group_names == ["c", "b", "a"] + + for group, vals in zip(["c", "b", "a"], p.plot_data): + npt.assert_array_equal(vals, self.y[self.g == group]) + + df.g = (df.g.cat.add_categories("d") + .cat.reorder_categories(["c", "b", "d", "a"])) + p.establish_variables("g", "y", data=df) + assert p.group_names == ["c", "b", "d", "a"] + + def test_hue_order(self): + + p = cat._CategoricalPlotter() + + # Test inferred hue order + p.establish_variables("g", "y", hue="h", data=self.df) + assert p.hue_names == ["m", "n"] + + # Test specified hue order + p.establish_variables("g", "y", hue="h", data=self.df, + hue_order=["n", "m"]) + assert p.hue_names == ["n", "m"] + + # Test inferred hue order from a categorical hue input + df = self.df.copy() + df.h = df.h.astype("category") + df.h = df.h.cat.reorder_categories(["n", "m"]) + p.establish_variables("g", "y", hue="h", data=df) + assert p.hue_names == ["n", "m"] + + df.h = (df.h.cat.add_categories("o") + .cat.reorder_categories(["o", "m", "n"])) + p.establish_variables("g", "y", hue="h", data=df) + assert p.hue_names == ["o", "m", "n"] + + def test_plot_units(self): + + p = cat._CategoricalPlotter() + p.establish_variables("g", "y", hue="h", data=self.df) + assert p.plot_units is None + + p.establish_variables("g", "y", hue="h", data=self.df, units="u") + for group, units in zip(["a", "b", "c"], p.plot_units): + npt.assert_array_equal(units, self.u[self.g == group]) + + def test_default_palettes(self): + + p = cat._CategoricalPlotter() + + # Test palette mapping the x position + p.establish_variables("g", "y", data=self.df) + p.establish_colors(None, None, 1) + assert p.colors == palettes.color_palette(n_colors=3) + + # Test palette mapping the hue position + p.establish_variables("g", "y", hue="h", data=self.df) + p.establish_colors(None, None, 1) + assert p.colors == palettes.color_palette(n_colors=2) + + def test_default_palette_with_many_levels(self): + + with palettes.color_palette(["blue", "red"], 2): + p = cat._CategoricalPlotter() + p.establish_variables("g", "y", data=self.df) + p.establish_colors(None, None, 1) + npt.assert_array_equal(p.colors, + palettes.husl_palette(3, l=.7)) # noqa + + def test_specific_color(self): + + p = cat._CategoricalPlotter() + + # Test the same color for each x position + p.establish_variables("g", "y", data=self.df) + p.establish_colors("blue", None, 1) + blue_rgb = mpl.colors.colorConverter.to_rgb("blue") + assert p.colors == [blue_rgb] * 3 + + # Test a color-based blend for the hue mapping + p.establish_variables("g", "y", hue="h", data=self.df) + p.establish_colors("#ff0022", None, 1) + rgba_array = np.array(palettes.light_palette("#ff0022", 2)) + npt.assert_array_almost_equal(p.colors, + rgba_array[:, :3]) + + def test_specific_palette(self): + + p = cat._CategoricalPlotter() + + # Test palette mapping the x position + p.establish_variables("g", "y", data=self.df) + p.establish_colors(None, "dark", 1) + assert p.colors == palettes.color_palette("dark", 3) + + # Test that non-None `color` and `hue` raises an error + p.establish_variables("g", "y", hue="h", data=self.df) + p.establish_colors(None, "muted", 1) + assert p.colors == palettes.color_palette("muted", 2) + + # Test that specified palette overrides specified color + p = cat._CategoricalPlotter() + p.establish_variables("g", "y", data=self.df) + p.establish_colors("blue", "deep", 1) + assert p.colors == palettes.color_palette("deep", 3) + + def test_dict_as_palette(self): + + p = cat._CategoricalPlotter() + p.establish_variables("g", "y", hue="h", data=self.df) + pal = {"m": (0, 0, 1), "n": (1, 0, 0)} + p.establish_colors(None, pal, 1) + assert p.colors == [(0, 0, 1), (1, 0, 0)] + + def test_palette_desaturation(self): + + p = cat._CategoricalPlotter() + p.establish_variables("g", "y", data=self.df) + p.establish_colors((0, 0, 1), None, .5) + assert p.colors == [(.25, .25, .75)] * 3 + + p.establish_colors(None, [(0, 0, 1), (1, 0, 0), "w"], .5) + assert p.colors == [(.25, .25, .75), (.75, .25, .25), (1, 1, 1)] + + +class TestCategoricalStatPlotter(CategoricalFixture): + + def test_no_bootstrappig(self): + + p = cat._CategoricalStatPlotter() + p.establish_variables("g", "y", data=self.df) + p.estimate_statistic(np.mean, None, 100, None) + npt.assert_array_equal(p.confint, np.array([])) + + p.establish_variables("g", "y", hue="h", data=self.df) + p.estimate_statistic(np.mean, None, 100, None) + npt.assert_array_equal(p.confint, np.array([[], [], []])) + + def test_single_layer_stats(self): + + p = cat._CategoricalStatPlotter() + + g = pd.Series(np.repeat(list("abc"), 100)) + y = pd.Series(np.random.RandomState(0).randn(300)) + + p.establish_variables(g, y) + p.estimate_statistic(np.mean, 95, 10000, None) + + assert p.statistic.shape == (3,) + assert p.confint.shape == (3, 2) + + npt.assert_array_almost_equal(p.statistic, + y.groupby(g).mean()) + + for ci, (_, grp_y) in zip(p.confint, y.groupby(g)): + sem = stats.sem(grp_y) + mean = grp_y.mean() + stats.norm.ppf(.975) + half_ci = stats.norm.ppf(.975) * sem + ci_want = mean - half_ci, mean + half_ci + npt.assert_array_almost_equal(ci_want, ci, 2) + + def test_single_layer_stats_with_units(self): + + p = cat._CategoricalStatPlotter() + + g = pd.Series(np.repeat(list("abc"), 90)) + y = pd.Series(np.random.RandomState(0).randn(270)) + u = pd.Series(np.repeat(np.tile(list("xyz"), 30), 3)) + y[u == "x"] -= 3 + y[u == "y"] += 3 + + p.establish_variables(g, y) + p.estimate_statistic(np.mean, 95, 10000, None) + stat1, ci1 = p.statistic, p.confint + + p.establish_variables(g, y, units=u) + p.estimate_statistic(np.mean, 95, 10000, None) + stat2, ci2 = p.statistic, p.confint + + npt.assert_array_equal(stat1, stat2) + ci1_size = ci1[:, 1] - ci1[:, 0] + ci2_size = ci2[:, 1] - ci2[:, 0] + npt.assert_array_less(ci1_size, ci2_size) + + def test_single_layer_stats_with_missing_data(self): + + p = cat._CategoricalStatPlotter() + + g = pd.Series(np.repeat(list("abc"), 100)) + y = pd.Series(np.random.RandomState(0).randn(300)) + + p.establish_variables(g, y, order=list("abdc")) + p.estimate_statistic(np.mean, 95, 10000, None) + + assert p.statistic.shape == (4,) + assert p.confint.shape == (4, 2) + + mean = y[g == "b"].mean() + sem = stats.sem(y[g == "b"]) + half_ci = stats.norm.ppf(.975) * sem + ci = mean - half_ci, mean + half_ci + npt.assert_almost_equal(p.statistic[1], mean) + npt.assert_array_almost_equal(p.confint[1], ci, 2) + + npt.assert_equal(p.statistic[2], np.nan) + npt.assert_array_equal(p.confint[2], (np.nan, np.nan)) + + def test_nested_stats(self): + + p = cat._CategoricalStatPlotter() + + g = pd.Series(np.repeat(list("abc"), 100)) + h = pd.Series(np.tile(list("xy"), 150)) + y = pd.Series(np.random.RandomState(0).randn(300)) + + p.establish_variables(g, y, h) + p.estimate_statistic(np.mean, 95, 50000, None) + + assert p.statistic.shape == (3, 2) + assert p.confint.shape == (3, 2, 2) + + npt.assert_array_almost_equal(p.statistic, + y.groupby([g, h]).mean().unstack()) + + for ci_g, (_, grp_y) in zip(p.confint, y.groupby(g)): + for ci, hue_y in zip(ci_g, [grp_y[::2], grp_y[1::2]]): + sem = stats.sem(hue_y) + mean = hue_y.mean() + half_ci = stats.norm.ppf(.975) * sem + ci_want = mean - half_ci, mean + half_ci + npt.assert_array_almost_equal(ci_want, ci, 2) + + def test_bootstrap_seed(self): + + p = cat._CategoricalStatPlotter() + + g = pd.Series(np.repeat(list("abc"), 100)) + h = pd.Series(np.tile(list("xy"), 150)) + y = pd.Series(np.random.RandomState(0).randn(300)) + + p.establish_variables(g, y, h) + p.estimate_statistic(np.mean, 95, 1000, 0) + confint_1 = p.confint + p.estimate_statistic(np.mean, 95, 1000, 0) + confint_2 = p.confint + + npt.assert_array_equal(confint_1, confint_2) + + def test_nested_stats_with_units(self): + + p = cat._CategoricalStatPlotter() + + g = pd.Series(np.repeat(list("abc"), 90)) + h = pd.Series(np.tile(list("xy"), 135)) + u = pd.Series(np.repeat(list("ijkijk"), 45)) + y = pd.Series(np.random.RandomState(0).randn(270)) + y[u == "i"] -= 3 + y[u == "k"] += 3 + + p.establish_variables(g, y, h) + p.estimate_statistic(np.mean, 95, 10000, None) + stat1, ci1 = p.statistic, p.confint + + p.establish_variables(g, y, h, units=u) + p.estimate_statistic(np.mean, 95, 10000, None) + stat2, ci2 = p.statistic, p.confint + + npt.assert_array_equal(stat1, stat2) + ci1_size = ci1[:, 0, 1] - ci1[:, 0, 0] + ci2_size = ci2[:, 0, 1] - ci2[:, 0, 0] + npt.assert_array_less(ci1_size, ci2_size) + + def test_nested_stats_with_missing_data(self): + + p = cat._CategoricalStatPlotter() + + g = pd.Series(np.repeat(list("abc"), 100)) + y = pd.Series(np.random.RandomState(0).randn(300)) + h = pd.Series(np.tile(list("xy"), 150)) + + p.establish_variables(g, y, h, + order=list("abdc"), + hue_order=list("zyx")) + p.estimate_statistic(np.mean, 95, 50000, None) + + assert p.statistic.shape == (4, 3) + assert p.confint.shape == (4, 3, 2) + + mean = y[(g == "b") & (h == "x")].mean() + sem = stats.sem(y[(g == "b") & (h == "x")]) + half_ci = stats.norm.ppf(.975) * sem + ci = mean - half_ci, mean + half_ci + npt.assert_almost_equal(p.statistic[1, 2], mean) + npt.assert_array_almost_equal(p.confint[1, 2], ci, 2) + + npt.assert_array_equal(p.statistic[:, 0], [np.nan] * 4) + npt.assert_array_equal(p.statistic[2], [np.nan] * 3) + npt.assert_array_equal(p.confint[:, 0], + np.zeros((4, 2)) * np.nan) + npt.assert_array_equal(p.confint[2], + np.zeros((3, 2)) * np.nan) + + def test_sd_error_bars(self): + + p = cat._CategoricalStatPlotter() + + g = pd.Series(np.repeat(list("abc"), 100)) + y = pd.Series(np.random.RandomState(0).randn(300)) + + p.establish_variables(g, y) + p.estimate_statistic(np.mean, "sd", None, None) + + assert p.statistic.shape == (3,) + assert p.confint.shape == (3, 2) + + npt.assert_array_almost_equal(p.statistic, + y.groupby(g).mean()) + + for ci, (_, grp_y) in zip(p.confint, y.groupby(g)): + mean = grp_y.mean() + half_ci = np.std(grp_y) + ci_want = mean - half_ci, mean + half_ci + npt.assert_array_almost_equal(ci_want, ci, 2) + + def test_nested_sd_error_bars(self): + + p = cat._CategoricalStatPlotter() + + g = pd.Series(np.repeat(list("abc"), 100)) + h = pd.Series(np.tile(list("xy"), 150)) + y = pd.Series(np.random.RandomState(0).randn(300)) + + p.establish_variables(g, y, h) + p.estimate_statistic(np.mean, "sd", None, None) + + assert p.statistic.shape == (3, 2) + assert p.confint.shape == (3, 2, 2) + + npt.assert_array_almost_equal(p.statistic, + y.groupby([g, h]).mean().unstack()) + + for ci_g, (_, grp_y) in zip(p.confint, y.groupby(g)): + for ci, hue_y in zip(ci_g, [grp_y[::2], grp_y[1::2]]): + mean = hue_y.mean() + half_ci = np.std(hue_y) + ci_want = mean - half_ci, mean + half_ci + npt.assert_array_almost_equal(ci_want, ci, 2) + + def test_draw_cis(self): + + p = cat._CategoricalStatPlotter() + + # Test vertical CIs + p.orient = "v" + + f, ax = plt.subplots() + at_group = [0, 1] + confints = [(.5, 1.5), (.25, .8)] + colors = [".2", ".3"] + p.draw_confints(ax, at_group, confints, colors) + + lines = ax.lines + for line, at, ci, c in zip(lines, at_group, confints, colors): + x, y = line.get_xydata().T + npt.assert_array_equal(x, [at, at]) + npt.assert_array_equal(y, ci) + assert line.get_color() == c + + plt.close("all") + + # Test horizontal CIs + p.orient = "h" + + f, ax = plt.subplots() + p.draw_confints(ax, at_group, confints, colors) + + lines = ax.lines + for line, at, ci, c in zip(lines, at_group, confints, colors): + x, y = line.get_xydata().T + npt.assert_array_equal(x, ci) + npt.assert_array_equal(y, [at, at]) + assert line.get_color() == c + + plt.close("all") + + # Test vertical CIs with endcaps + p.orient = "v" + + f, ax = plt.subplots() + p.draw_confints(ax, at_group, confints, colors, capsize=0.3) + capline = ax.lines[len(ax.lines) - 1] + caplinestart = capline.get_xdata()[0] + caplineend = capline.get_xdata()[1] + caplinelength = abs(caplineend - caplinestart) + assert caplinelength == approx(0.3) + assert len(ax.lines) == 6 + + plt.close("all") + + # Test horizontal CIs with endcaps + p.orient = "h" + + f, ax = plt.subplots() + p.draw_confints(ax, at_group, confints, colors, capsize=0.3) + capline = ax.lines[len(ax.lines) - 1] + caplinestart = capline.get_ydata()[0] + caplineend = capline.get_ydata()[1] + caplinelength = abs(caplineend - caplinestart) + assert caplinelength == approx(0.3) + assert len(ax.lines) == 6 + + # Test extra keyword arguments + f, ax = plt.subplots() + p.draw_confints(ax, at_group, confints, colors, lw=4) + line = ax.lines[0] + assert line.get_linewidth() == 4 + + plt.close("all") + + # Test errwidth is set appropriately + f, ax = plt.subplots() + p.draw_confints(ax, at_group, confints, colors, errwidth=2) + capline = ax.lines[len(ax.lines) - 1] + assert capline._linewidth == 2 + assert len(ax.lines) == 2 + + plt.close("all") + + +class TestBoxPlotter(CategoricalFixture): + + default_kws = dict(x=None, y=None, hue=None, data=None, + order=None, hue_order=None, + orient=None, color=None, palette=None, + saturation=.75, width=.8, dodge=True, + fliersize=5, linewidth=None) + + def test_nested_width(self): + + kws = self.default_kws.copy() + p = cat._BoxPlotter(**kws) + p.establish_variables("g", "y", hue="h", data=self.df) + assert p.nested_width == .4 * .98 + + kws = self.default_kws.copy() + kws["width"] = .6 + p = cat._BoxPlotter(**kws) + p.establish_variables("g", "y", hue="h", data=self.df) + assert p.nested_width == .3 * .98 + + kws = self.default_kws.copy() + kws["dodge"] = False + p = cat._BoxPlotter(**kws) + p.establish_variables("g", "y", hue="h", data=self.df) + assert p.nested_width == .8 + + def test_hue_offsets(self): + + p = cat._BoxPlotter(**self.default_kws) + p.establish_variables("g", "y", hue="h", data=self.df) + npt.assert_array_equal(p.hue_offsets, [-.2, .2]) + + kws = self.default_kws.copy() + kws["width"] = .6 + p = cat._BoxPlotter(**kws) + p.establish_variables("g", "y", hue="h", data=self.df) + npt.assert_array_equal(p.hue_offsets, [-.15, .15]) + + p = cat._BoxPlotter(**kws) + p.establish_variables("h", "y", "g", data=self.df) + npt.assert_array_almost_equal(p.hue_offsets, [-.2, 0, .2]) + + def test_axes_data(self): + + ax = cat.boxplot(x="g", y="y", data=self.df) + assert len(ax.artists) == 3 + + plt.close("all") + + ax = cat.boxplot(x="g", y="y", hue="h", data=self.df) + assert len(ax.artists) == 6 + + plt.close("all") + + def test_box_colors(self): + + ax = cat.boxplot(x="g", y="y", data=self.df, saturation=1) + pal = palettes.color_palette(n_colors=3) + for patch, color in zip(ax.artists, pal): + assert patch.get_facecolor()[:3] == color + + plt.close("all") + + ax = cat.boxplot(x="g", y="y", hue="h", data=self.df, saturation=1) + pal = palettes.color_palette(n_colors=2) + for patch, color in zip(ax.artists, pal * 2): + assert patch.get_facecolor()[:3] == color + + plt.close("all") + + def test_draw_missing_boxes(self): + + ax = cat.boxplot(x="g", y="y", data=self.df, + order=["a", "b", "c", "d"]) + assert len(ax.artists) == 3 + + def test_missing_data(self): + + x = ["a", "a", "b", "b", "c", "c", "d", "d"] + h = ["x", "y", "x", "y", "x", "y", "x", "y"] + y = self.rs.randn(8) + y[-2:] = np.nan + + ax = cat.boxplot(x=x, y=y) + assert len(ax.artists) == 3 + + plt.close("all") + + y[-1] = 0 + ax = cat.boxplot(x=x, y=y, hue=h) + assert len(ax.artists) == 7 + + plt.close("all") + + def test_unaligned_index(self): + + f, (ax1, ax2) = plt.subplots(2) + cat.boxplot(x=self.g, y=self.y, ax=ax1) + cat.boxplot(x=self.g, y=self.y_perm, ax=ax2) + for l1, l2 in zip(ax1.lines, ax2.lines): + assert np.array_equal(l1.get_xydata(), l2.get_xydata()) + + f, (ax1, ax2) = plt.subplots(2) + hue_order = self.h.unique() + cat.boxplot(x=self.g, y=self.y, hue=self.h, + hue_order=hue_order, ax=ax1) + cat.boxplot(x=self.g, y=self.y_perm, hue=self.h, + hue_order=hue_order, ax=ax2) + for l1, l2 in zip(ax1.lines, ax2.lines): + assert np.array_equal(l1.get_xydata(), l2.get_xydata()) + + def test_boxplots(self): + + # Smoke test the high level boxplot options + + cat.boxplot(x="y", data=self.df) + plt.close("all") + + cat.boxplot(y="y", data=self.df) + plt.close("all") + + cat.boxplot(x="g", y="y", data=self.df) + plt.close("all") + + cat.boxplot(x="y", y="g", data=self.df, orient="h") + plt.close("all") + + cat.boxplot(x="g", y="y", hue="h", data=self.df) + plt.close("all") + + cat.boxplot(x="g", y="y", hue="h", order=list("nabc"), data=self.df) + plt.close("all") + + cat.boxplot(x="g", y="y", hue="h", hue_order=list("omn"), data=self.df) + plt.close("all") + + cat.boxplot(x="y", y="g", hue="h", data=self.df, orient="h") + plt.close("all") + + def test_axes_annotation(self): + + ax = cat.boxplot(x="g", y="y", data=self.df) + assert ax.get_xlabel() == "g" + assert ax.get_ylabel() == "y" + assert ax.get_xlim() == (-.5, 2.5) + npt.assert_array_equal(ax.get_xticks(), [0, 1, 2]) + npt.assert_array_equal([l.get_text() for l in ax.get_xticklabels()], + ["a", "b", "c"]) + + plt.close("all") + + ax = cat.boxplot(x="g", y="y", hue="h", data=self.df) + assert ax.get_xlabel() == "g" + assert ax.get_ylabel() == "y" + npt.assert_array_equal(ax.get_xticks(), [0, 1, 2]) + npt.assert_array_equal([l.get_text() for l in ax.get_xticklabels()], + ["a", "b", "c"]) + npt.assert_array_equal([l.get_text() for l in ax.legend_.get_texts()], + ["m", "n"]) + + plt.close("all") + + ax = cat.boxplot(x="y", y="g", data=self.df, orient="h") + assert ax.get_xlabel() == "y" + assert ax.get_ylabel() == "g" + assert ax.get_ylim() == (2.5, -.5) + npt.assert_array_equal(ax.get_yticks(), [0, 1, 2]) + npt.assert_array_equal([l.get_text() for l in ax.get_yticklabels()], + ["a", "b", "c"]) + + plt.close("all") + + +class TestViolinPlotter(CategoricalFixture): + + default_kws = dict(x=None, y=None, hue=None, data=None, + order=None, hue_order=None, + bw="scott", cut=2, scale="area", scale_hue=True, + gridsize=100, width=.8, inner="box", split=False, + dodge=True, orient=None, linewidth=None, + color=None, palette=None, saturation=.75) + + def test_split_error(self): + + kws = self.default_kws.copy() + kws.update(dict(x="h", y="y", hue="g", data=self.df, split=True)) + + with pytest.raises(ValueError): + cat._ViolinPlotter(**kws) + + def test_no_observations(self): + + p = cat._ViolinPlotter(**self.default_kws) + + x = ["a", "a", "b"] + y = self.rs.randn(3) + y[-1] = np.nan + p.establish_variables(x, y) + p.estimate_densities("scott", 2, "area", True, 20) + + assert len(p.support[0]) == 20 + assert len(p.support[1]) == 0 + + assert len(p.density[0]) == 20 + assert len(p.density[1]) == 1 + + assert p.density[1].item() == 1 + + p.estimate_densities("scott", 2, "count", True, 20) + assert p.density[1].item() == 0 + + x = ["a"] * 4 + ["b"] * 2 + y = self.rs.randn(6) + h = ["m", "n"] * 2 + ["m"] * 2 + + p.establish_variables(x, y, hue=h) + p.estimate_densities("scott", 2, "area", True, 20) + + assert len(p.support[1][0]) == 20 + assert len(p.support[1][1]) == 0 + + assert len(p.density[1][0]) == 20 + assert len(p.density[1][1]) == 1 + + assert p.density[1][1].item() == 1 + + p.estimate_densities("scott", 2, "count", False, 20) + assert p.density[1][1].item() == 0 + + def test_single_observation(self): + + p = cat._ViolinPlotter(**self.default_kws) + + x = ["a", "a", "b"] + y = self.rs.randn(3) + p.establish_variables(x, y) + p.estimate_densities("scott", 2, "area", True, 20) + + assert len(p.support[0]) == 20 + assert len(p.support[1]) == 1 + + assert len(p.density[0]) == 20 + assert len(p.density[1]) == 1 + + assert p.density[1].item() == 1 + + p.estimate_densities("scott", 2, "count", True, 20) + assert p.density[1].item() == .5 + + x = ["b"] * 4 + ["a"] * 3 + y = self.rs.randn(7) + h = (["m", "n"] * 4)[:-1] + + p.establish_variables(x, y, hue=h) + p.estimate_densities("scott", 2, "area", True, 20) + + assert len(p.support[1][0]) == 20 + assert len(p.support[1][1]) == 1 + + assert len(p.density[1][0]) == 20 + assert len(p.density[1][1]) == 1 + + assert p.density[1][1].item() == 1 + + p.estimate_densities("scott", 2, "count", False, 20) + assert p.density[1][1].item() == .5 + + def test_dwidth(self): + + kws = self.default_kws.copy() + kws.update(dict(x="g", y="y", data=self.df)) + + p = cat._ViolinPlotter(**kws) + assert p.dwidth == .4 + + kws.update(dict(width=.4)) + p = cat._ViolinPlotter(**kws) + assert p.dwidth == .2 + + kws.update(dict(hue="h", width=.8)) + p = cat._ViolinPlotter(**kws) + assert p.dwidth == .2 + + kws.update(dict(split=True)) + p = cat._ViolinPlotter(**kws) + assert p.dwidth == .4 + + def test_scale_area(self): + + kws = self.default_kws.copy() + kws["scale"] = "area" + p = cat._ViolinPlotter(**kws) + + # Test single layer of grouping + p.hue_names = None + density = [self.rs.uniform(0, .8, 50), self.rs.uniform(0, .2, 50)] + max_before = np.array([d.max() for d in density]) + p.scale_area(density, max_before, False) + max_after = np.array([d.max() for d in density]) + assert max_after[0] == 1 + + before_ratio = max_before[1] / max_before[0] + after_ratio = max_after[1] / max_after[0] + assert before_ratio == after_ratio + + # Test nested grouping scaling across all densities + p.hue_names = ["foo", "bar"] + density = [[self.rs.uniform(0, .8, 50), self.rs.uniform(0, .2, 50)], + [self.rs.uniform(0, .1, 50), self.rs.uniform(0, .02, 50)]] + + max_before = np.array([[r.max() for r in row] for row in density]) + p.scale_area(density, max_before, False) + max_after = np.array([[r.max() for r in row] for row in density]) + assert max_after[0, 0] == 1 + + before_ratio = max_before[1, 1] / max_before[0, 0] + after_ratio = max_after[1, 1] / max_after[0, 0] + assert before_ratio == after_ratio + + # Test nested grouping scaling within hue + p.hue_names = ["foo", "bar"] + density = [[self.rs.uniform(0, .8, 50), self.rs.uniform(0, .2, 50)], + [self.rs.uniform(0, .1, 50), self.rs.uniform(0, .02, 50)]] + + max_before = np.array([[r.max() for r in row] for row in density]) + p.scale_area(density, max_before, True) + max_after = np.array([[r.max() for r in row] for row in density]) + assert max_after[0, 0] == 1 + assert max_after[1, 0] == 1 + + before_ratio = max_before[1, 1] / max_before[1, 0] + after_ratio = max_after[1, 1] / max_after[1, 0] + assert before_ratio == after_ratio + + def test_scale_width(self): + + kws = self.default_kws.copy() + kws["scale"] = "width" + p = cat._ViolinPlotter(**kws) + + # Test single layer of grouping + p.hue_names = None + density = [self.rs.uniform(0, .8, 50), self.rs.uniform(0, .2, 50)] + p.scale_width(density) + max_after = np.array([d.max() for d in density]) + npt.assert_array_equal(max_after, [1, 1]) + + # Test nested grouping + p.hue_names = ["foo", "bar"] + density = [[self.rs.uniform(0, .8, 50), self.rs.uniform(0, .2, 50)], + [self.rs.uniform(0, .1, 50), self.rs.uniform(0, .02, 50)]] + + p.scale_width(density) + max_after = np.array([[r.max() for r in row] for row in density]) + npt.assert_array_equal(max_after, [[1, 1], [1, 1]]) + + def test_scale_count(self): + + kws = self.default_kws.copy() + kws["scale"] = "count" + p = cat._ViolinPlotter(**kws) + + # Test single layer of grouping + p.hue_names = None + density = [self.rs.uniform(0, .8, 20), self.rs.uniform(0, .2, 40)] + counts = np.array([20, 40]) + p.scale_count(density, counts, False) + max_after = np.array([d.max() for d in density]) + npt.assert_array_equal(max_after, [.5, 1]) + + # Test nested grouping scaling across all densities + p.hue_names = ["foo", "bar"] + density = [[self.rs.uniform(0, .8, 5), self.rs.uniform(0, .2, 40)], + [self.rs.uniform(0, .1, 100), self.rs.uniform(0, .02, 50)]] + + counts = np.array([[5, 40], [100, 50]]) + p.scale_count(density, counts, False) + max_after = np.array([[r.max() for r in row] for row in density]) + npt.assert_array_equal(max_after, [[.05, .4], [1, .5]]) + + # Test nested grouping scaling within hue + p.hue_names = ["foo", "bar"] + density = [[self.rs.uniform(0, .8, 5), self.rs.uniform(0, .2, 40)], + [self.rs.uniform(0, .1, 100), self.rs.uniform(0, .02, 50)]] + + counts = np.array([[5, 40], [100, 50]]) + p.scale_count(density, counts, True) + max_after = np.array([[r.max() for r in row] for row in density]) + npt.assert_array_equal(max_after, [[.125, 1], [1, .5]]) + + def test_bad_scale(self): + + kws = self.default_kws.copy() + kws["scale"] = "not_a_scale_type" + with pytest.raises(ValueError): + cat._ViolinPlotter(**kws) + + def test_kde_fit(self): + + p = cat._ViolinPlotter(**self.default_kws) + data = self.y + data_std = data.std(ddof=1) + + # Test reference rule bandwidth + kde, bw = p.fit_kde(data, "scott") + assert isinstance(kde, stats.gaussian_kde) + assert kde.factor == kde.scotts_factor() + assert bw == kde.scotts_factor() * data_std + + # Test numeric scale factor + kde, bw = p.fit_kde(self.y, .2) + assert isinstance(kde, stats.gaussian_kde) + assert kde.factor == .2 + assert bw == .2 * data_std + + def test_draw_to_density(self): + + p = cat._ViolinPlotter(**self.default_kws) + # p.dwidth will be 1 for easier testing + p.width = 2 + + # Test verical plots + support = np.array([.2, .6]) + density = np.array([.1, .4]) + + # Test full vertical plot + _, ax = plt.subplots() + p.draw_to_density(ax, 0, .5, support, density, False) + x, y = ax.lines[0].get_xydata().T + npt.assert_array_equal(x, [.99 * -.4, .99 * .4]) + npt.assert_array_equal(y, [.5, .5]) + plt.close("all") + + # Test left vertical plot + _, ax = plt.subplots() + p.draw_to_density(ax, 0, .5, support, density, "left") + x, y = ax.lines[0].get_xydata().T + npt.assert_array_equal(x, [.99 * -.4, 0]) + npt.assert_array_equal(y, [.5, .5]) + plt.close("all") + + # Test right vertical plot + _, ax = plt.subplots() + p.draw_to_density(ax, 0, .5, support, density, "right") + x, y = ax.lines[0].get_xydata().T + npt.assert_array_equal(x, [0, .99 * .4]) + npt.assert_array_equal(y, [.5, .5]) + plt.close("all") + + # Switch orientation to test horizontal plots + p.orient = "h" + support = np.array([.2, .5]) + density = np.array([.3, .7]) + + # Test full horizontal plot + _, ax = plt.subplots() + p.draw_to_density(ax, 0, .6, support, density, False) + x, y = ax.lines[0].get_xydata().T + npt.assert_array_equal(x, [.6, .6]) + npt.assert_array_equal(y, [.99 * -.7, .99 * .7]) + plt.close("all") + + # Test left horizontal plot + _, ax = plt.subplots() + p.draw_to_density(ax, 0, .6, support, density, "left") + x, y = ax.lines[0].get_xydata().T + npt.assert_array_equal(x, [.6, .6]) + npt.assert_array_equal(y, [.99 * -.7, 0]) + plt.close("all") + + # Test right horizontal plot + _, ax = plt.subplots() + p.draw_to_density(ax, 0, .6, support, density, "right") + x, y = ax.lines[0].get_xydata().T + npt.assert_array_equal(x, [.6, .6]) + npt.assert_array_equal(y, [0, .99 * .7]) + plt.close("all") + + def test_draw_single_observations(self): + + p = cat._ViolinPlotter(**self.default_kws) + p.width = 2 + + # Test vertical plot + _, ax = plt.subplots() + p.draw_single_observation(ax, 1, 1.5, 1) + x, y = ax.lines[0].get_xydata().T + npt.assert_array_equal(x, [0, 2]) + npt.assert_array_equal(y, [1.5, 1.5]) + plt.close("all") + + # Test horizontal plot + p.orient = "h" + _, ax = plt.subplots() + p.draw_single_observation(ax, 2, 2.2, .5) + x, y = ax.lines[0].get_xydata().T + npt.assert_array_equal(x, [2.2, 2.2]) + npt.assert_array_equal(y, [1.5, 2.5]) + plt.close("all") + + def test_draw_box_lines(self): + + # Test vertical plot + kws = self.default_kws.copy() + kws.update(dict(y="y", data=self.df, inner=None)) + p = cat._ViolinPlotter(**kws) + + _, ax = plt.subplots() + p.draw_box_lines(ax, self.y, p.support[0], p.density[0], 0) + assert len(ax.lines) == 2 + + q25, q50, q75 = np.percentile(self.y, [25, 50, 75]) + _, y = ax.lines[1].get_xydata().T + npt.assert_array_equal(y, [q25, q75]) + + _, y = ax.collections[0].get_offsets().T + assert y == q50 + + plt.close("all") + + # Test horizontal plot + kws = self.default_kws.copy() + kws.update(dict(x="y", data=self.df, inner=None)) + p = cat._ViolinPlotter(**kws) + + _, ax = plt.subplots() + p.draw_box_lines(ax, self.y, p.support[0], p.density[0], 0) + assert len(ax.lines) == 2 + + q25, q50, q75 = np.percentile(self.y, [25, 50, 75]) + x, _ = ax.lines[1].get_xydata().T + npt.assert_array_equal(x, [q25, q75]) + + x, _ = ax.collections[0].get_offsets().T + assert x == q50 + + plt.close("all") + + def test_draw_quartiles(self): + + kws = self.default_kws.copy() + kws.update(dict(y="y", data=self.df, inner=None)) + p = cat._ViolinPlotter(**kws) + + _, ax = plt.subplots() + p.draw_quartiles(ax, self.y, p.support[0], p.density[0], 0) + for val, line in zip(np.percentile(self.y, [25, 50, 75]), ax.lines): + _, y = line.get_xydata().T + npt.assert_array_equal(y, [val, val]) + + def test_draw_points(self): + + p = cat._ViolinPlotter(**self.default_kws) + + # Test vertical plot + _, ax = plt.subplots() + p.draw_points(ax, self.y, 0) + x, y = ax.collections[0].get_offsets().T + npt.assert_array_equal(x, np.zeros_like(self.y)) + npt.assert_array_equal(y, self.y) + plt.close("all") + + # Test horizontal plot + p.orient = "h" + _, ax = plt.subplots() + p.draw_points(ax, self.y, 0) + x, y = ax.collections[0].get_offsets().T + npt.assert_array_equal(x, self.y) + npt.assert_array_equal(y, np.zeros_like(self.y)) + plt.close("all") + + def test_draw_sticks(self): + + kws = self.default_kws.copy() + kws.update(dict(y="y", data=self.df, inner=None)) + p = cat._ViolinPlotter(**kws) + + # Test vertical plot + _, ax = plt.subplots() + p.draw_stick_lines(ax, self.y, p.support[0], p.density[0], 0) + for val, line in zip(self.y, ax.lines): + _, y = line.get_xydata().T + npt.assert_array_equal(y, [val, val]) + plt.close("all") + + # Test horizontal plot + p.orient = "h" + _, ax = plt.subplots() + p.draw_stick_lines(ax, self.y, p.support[0], p.density[0], 0) + for val, line in zip(self.y, ax.lines): + x, _ = line.get_xydata().T + npt.assert_array_equal(x, [val, val]) + plt.close("all") + + def test_validate_inner(self): + + kws = self.default_kws.copy() + kws.update(dict(inner="bad_inner")) + with pytest.raises(ValueError): + cat._ViolinPlotter(**kws) + + def test_draw_violinplots(self): + + kws = self.default_kws.copy() + + # Test single vertical violin + kws.update(dict(y="y", data=self.df, inner=None, + saturation=1, color=(1, 0, 0, 1))) + p = cat._ViolinPlotter(**kws) + + _, ax = plt.subplots() + p.draw_violins(ax) + assert len(ax.collections) == 1 + npt.assert_array_equal(ax.collections[0].get_facecolors(), + [(1, 0, 0, 1)]) + plt.close("all") + + # Test single horizontal violin + kws.update(dict(x="y", y=None, color=(0, 1, 0, 1))) + p = cat._ViolinPlotter(**kws) + + _, ax = plt.subplots() + p.draw_violins(ax) + assert len(ax.collections) == 1 + npt.assert_array_equal(ax.collections[0].get_facecolors(), + [(0, 1, 0, 1)]) + plt.close("all") + + # Test multiple vertical violins + kws.update(dict(x="g", y="y", color=None,)) + p = cat._ViolinPlotter(**kws) + + _, ax = plt.subplots() + p.draw_violins(ax) + assert len(ax.collections) == 3 + for violin, color in zip(ax.collections, palettes.color_palette()): + npt.assert_array_equal(violin.get_facecolors()[0, :-1], color) + plt.close("all") + + # Test multiple violins with hue nesting + kws.update(dict(hue="h")) + p = cat._ViolinPlotter(**kws) + + _, ax = plt.subplots() + p.draw_violins(ax) + assert len(ax.collections) == 6 + for violin, color in zip(ax.collections, + palettes.color_palette(n_colors=2) * 3): + npt.assert_array_equal(violin.get_facecolors()[0, :-1], color) + plt.close("all") + + # Test multiple split violins + kws.update(dict(split=True, palette="muted")) + p = cat._ViolinPlotter(**kws) + + _, ax = plt.subplots() + p.draw_violins(ax) + assert len(ax.collections) == 6 + for violin, color in zip(ax.collections, + palettes.color_palette("muted", + n_colors=2) * 3): + npt.assert_array_equal(violin.get_facecolors()[0, :-1], color) + plt.close("all") + + def test_draw_violinplots_no_observations(self): + + kws = self.default_kws.copy() + kws["inner"] = None + + # Test single layer of grouping + x = ["a", "a", "b"] + y = self.rs.randn(3) + y[-1] = np.nan + kws.update(x=x, y=y) + p = cat._ViolinPlotter(**kws) + + _, ax = plt.subplots() + p.draw_violins(ax) + assert len(ax.collections) == 1 + assert len(ax.lines) == 0 + plt.close("all") + + # Test nested hue grouping + x = ["a"] * 4 + ["b"] * 2 + y = self.rs.randn(6) + h = ["m", "n"] * 2 + ["m"] * 2 + kws.update(x=x, y=y, hue=h) + p = cat._ViolinPlotter(**kws) + + _, ax = plt.subplots() + p.draw_violins(ax) + assert len(ax.collections) == 3 + assert len(ax.lines) == 0 + plt.close("all") + + def test_draw_violinplots_single_observations(self): + + kws = self.default_kws.copy() + kws["inner"] = None + + # Test single layer of grouping + x = ["a", "a", "b"] + y = self.rs.randn(3) + kws.update(x=x, y=y) + p = cat._ViolinPlotter(**kws) + + _, ax = plt.subplots() + p.draw_violins(ax) + assert len(ax.collections) == 1 + assert len(ax.lines) == 1 + plt.close("all") + + # Test nested hue grouping + x = ["b"] * 4 + ["a"] * 3 + y = self.rs.randn(7) + h = (["m", "n"] * 4)[:-1] + kws.update(x=x, y=y, hue=h) + p = cat._ViolinPlotter(**kws) + + _, ax = plt.subplots() + p.draw_violins(ax) + assert len(ax.collections) == 3 + assert len(ax.lines) == 1 + plt.close("all") + + # Test nested hue grouping with split + kws["split"] = True + p = cat._ViolinPlotter(**kws) + + _, ax = plt.subplots() + p.draw_violins(ax) + assert len(ax.collections) == 3 + assert len(ax.lines) == 1 + plt.close("all") + + def test_violinplots(self): + + # Smoke test the high level violinplot options + + cat.violinplot(x="y", data=self.df) + plt.close("all") + + cat.violinplot(y="y", data=self.df) + plt.close("all") + + cat.violinplot(x="g", y="y", data=self.df) + plt.close("all") + + cat.violinplot(x="y", y="g", data=self.df, orient="h") + plt.close("all") + + cat.violinplot(x="g", y="y", hue="h", data=self.df) + plt.close("all") + + order = list("nabc") + cat.violinplot(x="g", y="y", hue="h", order=order, data=self.df) + plt.close("all") + + order = list("omn") + cat.violinplot(x="g", y="y", hue="h", hue_order=order, data=self.df) + plt.close("all") + + cat.violinplot(x="y", y="g", hue="h", data=self.df, orient="h") + plt.close("all") + + for inner in ["box", "quart", "point", "stick", None]: + cat.violinplot(x="g", y="y", data=self.df, inner=inner) + plt.close("all") + + cat.violinplot(x="g", y="y", hue="h", data=self.df, inner=inner) + plt.close("all") + + cat.violinplot(x="g", y="y", hue="h", data=self.df, + inner=inner, split=True) + plt.close("all") + + +class TestCategoricalScatterPlotter(CategoricalFixture): + + def test_group_point_colors(self): + + p = cat._CategoricalScatterPlotter() + + p.establish_variables(x="g", y="y", data=self.df) + p.establish_colors(None, "deep", 1) + + point_colors = p.point_colors + n_colors = self.g.unique().size + assert len(point_colors) == n_colors + + for i, group_colors in enumerate(point_colors): + for color in group_colors: + assert color == i + + def test_hue_point_colors(self): + + p = cat._CategoricalScatterPlotter() + + hue_order = self.h.unique().tolist() + p.establish_variables(x="g", y="y", hue="h", + hue_order=hue_order, data=self.df) + p.establish_colors(None, "deep", 1) + + point_colors = p.point_colors + assert len(point_colors) == self.g.unique().size + + for i, group_colors in enumerate(point_colors): + group_hues = np.asarray(p.plot_hues[i]) + for point_hue, point_color in zip(group_hues, group_colors): + assert point_color == p.hue_names.index(point_hue) + # hue_level = np.asarray(p.plot_hues[i])[j] + # palette_color = deep_colors[hue_order.index(hue_level)] + # assert tuple(point_color) == palette_color + + def test_scatterplot_legend(self): + + p = cat._CategoricalScatterPlotter() + + hue_order = ["m", "n"] + p.establish_variables(x="g", y="y", hue="h", + hue_order=hue_order, data=self.df) + p.establish_colors(None, "deep", 1) + deep_colors = palettes.color_palette("deep", self.h.unique().size) + + f, ax = plt.subplots() + p.add_legend_data(ax) + leg = ax.legend() + + for i, t in enumerate(leg.get_texts()): + assert t.get_text() == hue_order[i] + + for i, h in enumerate(leg.legendHandles): + rgb = h.get_facecolor()[0, :3] + assert tuple(rgb) == tuple(deep_colors[i]) + + +class TestStripPlotter(CategoricalFixture): + + def test_stripplot_vertical(self): + + pal = palettes.color_palette() + + ax = cat.stripplot(x="g", y="y", jitter=False, data=self.df) + for i, (_, vals) in enumerate(self.y.groupby(self.g)): + + x, y = ax.collections[i].get_offsets().T + + npt.assert_array_equal(x, np.ones(len(x)) * i) + npt.assert_array_equal(y, vals) + + npt.assert_equal(ax.collections[i].get_facecolors()[0, :3], pal[i]) + + def test_stripplot_horiztonal(self): + + df = self.df.copy() + df.g = df.g.astype("category") + + ax = cat.stripplot(x="y", y="g", jitter=False, data=df) + for i, (_, vals) in enumerate(self.y.groupby(self.g)): + + x, y = ax.collections[i].get_offsets().T + + npt.assert_array_equal(x, vals) + npt.assert_array_equal(y, np.ones(len(x)) * i) + + def test_stripplot_jitter(self): + + pal = palettes.color_palette() + + ax = cat.stripplot(x="g", y="y", data=self.df, jitter=True) + for i, (_, vals) in enumerate(self.y.groupby(self.g)): + + x, y = ax.collections[i].get_offsets().T + + npt.assert_array_less(np.ones(len(x)) * i - .1, x) + npt.assert_array_less(x, np.ones(len(x)) * i + .1) + npt.assert_array_equal(y, vals) + + npt.assert_equal(ax.collections[i].get_facecolors()[0, :3], pal[i]) + + def test_dodge_nested_stripplot_vertical(self): + + pal = palettes.color_palette() + + ax = cat.stripplot(x="g", y="y", hue="h", data=self.df, + jitter=False, dodge=True) + for i, (_, group_vals) in enumerate(self.y.groupby(self.g)): + for j, (_, vals) in enumerate(group_vals.groupby(self.h)): + + x, y = ax.collections[i * 2 + j].get_offsets().T + + npt.assert_array_equal(x, np.ones(len(x)) * i + [-.2, .2][j]) + npt.assert_array_equal(y, vals) + + fc = ax.collections[i * 2 + j].get_facecolors()[0, :3] + assert tuple(fc) == pal[j] + + def test_dodge_nested_stripplot_horizontal(self): + + df = self.df.copy() + df.g = df.g.astype("category") + + ax = cat.stripplot(x="y", y="g", hue="h", data=df, + jitter=False, dodge=True) + for i, (_, group_vals) in enumerate(self.y.groupby(self.g)): + for j, (_, vals) in enumerate(group_vals.groupby(self.h)): + + x, y = ax.collections[i * 2 + j].get_offsets().T + + npt.assert_array_equal(x, vals) + npt.assert_array_equal(y, np.ones(len(x)) * i + [-.2, .2][j]) + + def test_nested_stripplot_vertical(self): + + # Test a simple vertical strip plot + ax = cat.stripplot(x="g", y="y", hue="h", data=self.df, + jitter=False, dodge=False) + for i, (_, group_vals) in enumerate(self.y.groupby(self.g)): + + x, y = ax.collections[i].get_offsets().T + + npt.assert_array_equal(x, np.ones(len(x)) * i) + npt.assert_array_equal(y, group_vals) + + def test_nested_stripplot_horizontal(self): + + df = self.df.copy() + df.g = df.g.astype("category") + + ax = cat.stripplot(x="y", y="g", hue="h", data=df, + jitter=False, dodge=False) + for i, (_, group_vals) in enumerate(self.y.groupby(self.g)): + + x, y = ax.collections[i].get_offsets().T + + npt.assert_array_equal(x, group_vals) + npt.assert_array_equal(y, np.ones(len(x)) * i) + + def test_three_strip_points(self): + + x = np.arange(3) + ax = cat.stripplot(x=x) + facecolors = ax.collections[0].get_facecolor() + assert facecolors.shape == (3, 4) + npt.assert_array_equal(facecolors[0], facecolors[1]) + + def test_unaligned_index(self): + + f, (ax1, ax2) = plt.subplots(2) + cat.stripplot(x=self.g, y=self.y, ax=ax1) + cat.stripplot(x=self.g, y=self.y_perm, ax=ax2) + for p1, p2 in zip(ax1.collections, ax2.collections): + y1, y2 = p1.get_offsets()[:, 1], p2.get_offsets()[:, 1] + assert np.array_equal(np.sort(y1), np.sort(y2)) + assert np.array_equal(p1.get_facecolors()[np.argsort(y1)], + p2.get_facecolors()[np.argsort(y2)]) + + f, (ax1, ax2) = plt.subplots(2) + hue_order = self.h.unique() + cat.stripplot(x=self.g, y=self.y, hue=self.h, + hue_order=hue_order, ax=ax1) + cat.stripplot(x=self.g, y=self.y_perm, hue=self.h, + hue_order=hue_order, ax=ax2) + for p1, p2 in zip(ax1.collections, ax2.collections): + y1, y2 = p1.get_offsets()[:, 1], p2.get_offsets()[:, 1] + assert np.array_equal(np.sort(y1), np.sort(y2)) + assert np.array_equal(p1.get_facecolors()[np.argsort(y1)], + p2.get_facecolors()[np.argsort(y2)]) + + f, (ax1, ax2) = plt.subplots(2) + hue_order = self.h.unique() + cat.stripplot(x=self.g, y=self.y, hue=self.h, + dodge=True, hue_order=hue_order, ax=ax1) + cat.stripplot(x=self.g, y=self.y_perm, hue=self.h, + dodge=True, hue_order=hue_order, ax=ax2) + for p1, p2 in zip(ax1.collections, ax2.collections): + y1, y2 = p1.get_offsets()[:, 1], p2.get_offsets()[:, 1] + assert np.array_equal(np.sort(y1), np.sort(y2)) + assert np.array_equal(p1.get_facecolors()[np.argsort(y1)], + p2.get_facecolors()[np.argsort(y2)]) + + +class TestSwarmPlotter(CategoricalFixture): + + default_kws = dict(x=None, y=None, hue=None, data=None, + order=None, hue_order=None, dodge=False, + orient=None, color=None, palette=None) + + def test_could_overlap(self): + + p = cat._SwarmPlotter(**self.default_kws) + neighbors = p.could_overlap((1, 1), [(0, 0), (1, .5), (.5, .5)], 1) + npt.assert_array_equal(neighbors, [(1, .5), (.5, .5)]) + + def test_position_candidates(self): + + p = cat._SwarmPlotter(**self.default_kws) + xy_i = (0, 1) + neighbors = [(0, 1), (0, 1.5)] + candidates = p.position_candidates(xy_i, neighbors, 1) + dx1 = 1.05 + dx2 = np.sqrt(1 - .5 ** 2) * 1.05 + npt.assert_array_equal(candidates, + [(0, 1), (-dx1, 1), (dx1, 1), + (dx2, 1), (-dx2, 1)]) + + def test_find_first_non_overlapping_candidate(self): + + p = cat._SwarmPlotter(**self.default_kws) + candidates = [(.5, 1), (1, 1), (1.5, 1)] + neighbors = np.array([(0, 1)]) + + first = p.first_non_overlapping_candidate(candidates, neighbors, 1) + npt.assert_array_equal(first, (1, 1)) + + def test_beeswarm(self): + + p = cat._SwarmPlotter(**self.default_kws) + d = self.y.diff().mean() * 1.5 + x = np.zeros(self.y.size) + y = np.sort(self.y) + orig_xy = np.c_[x, y] + swarm = p.beeswarm(orig_xy, d) + dmat = spatial.distance.cdist(swarm, swarm) + triu = dmat[np.triu_indices_from(dmat, 1)] + npt.assert_array_less(d, triu) + npt.assert_array_equal(y, swarm[:, 1]) + + def test_add_gutters(self): + + p = cat._SwarmPlotter(**self.default_kws) + + points = np.zeros(10) + assert np.array_equal(points, p.add_gutters(points, 0, 1)) + + points = np.array([0, -1, .4, .8]) + msg = r"50.0% of the points cannot be placed.+$" + with pytest.warns(UserWarning, match=msg): + new_points = p.add_gutters(points, 0, 1) + assert np.array_equal(new_points, np.array([0, -.5, .4, .5])) + + def test_swarmplot_vertical(self): + + pal = palettes.color_palette() + + ax = cat.swarmplot(x="g", y="y", data=self.df) + for i, (_, vals) in enumerate(self.y.groupby(self.g)): + + x, y = ax.collections[i].get_offsets().T + npt.assert_array_almost_equal(y, np.sort(vals)) + + fc = ax.collections[i].get_facecolors()[0, :3] + npt.assert_equal(fc, pal[i]) + + def test_swarmplot_horizontal(self): + + pal = palettes.color_palette() + + ax = cat.swarmplot(x="y", y="g", data=self.df, orient="h") + for i, (_, vals) in enumerate(self.y.groupby(self.g)): + + x, y = ax.collections[i].get_offsets().T + npt.assert_array_almost_equal(x, np.sort(vals)) + + fc = ax.collections[i].get_facecolors()[0, :3] + npt.assert_equal(fc, pal[i]) + + def test_dodge_nested_swarmplot_vertical(self): + + pal = palettes.color_palette() + + ax = cat.swarmplot(x="g", y="y", hue="h", data=self.df, dodge=True) + for i, (_, group_vals) in enumerate(self.y.groupby(self.g)): + for j, (_, vals) in enumerate(group_vals.groupby(self.h)): + + x, y = ax.collections[i * 2 + j].get_offsets().T + npt.assert_array_almost_equal(y, np.sort(vals)) + + fc = ax.collections[i * 2 + j].get_facecolors()[0, :3] + assert tuple(fc) == pal[j] + + def test_dodge_nested_swarmplot_horizontal(self): + + pal = palettes.color_palette() + + ax = cat.swarmplot(x="y", y="g", hue="h", data=self.df, + orient="h", dodge=True) + for i, (_, group_vals) in enumerate(self.y.groupby(self.g)): + for j, (_, vals) in enumerate(group_vals.groupby(self.h)): + + x, y = ax.collections[i * 2 + j].get_offsets().T + npt.assert_array_almost_equal(x, np.sort(vals)) + + fc = ax.collections[i * 2 + j].get_facecolors()[0, :3] + assert tuple(fc) == pal[j] + + def test_nested_swarmplot_vertical(self): + + ax = cat.swarmplot(x="g", y="y", hue="h", data=self.df) + + pal = palettes.color_palette() + hue_names = self.h.unique().tolist() + grouped_hues = list(self.h.groupby(self.g)) + + for i, (_, vals) in enumerate(self.y.groupby(self.g)): + + points = ax.collections[i] + x, y = points.get_offsets().T + sorter = np.argsort(vals) + npt.assert_array_almost_equal(y, vals.iloc[sorter]) + + _, hue_vals = grouped_hues[i] + for hue, fc in zip(hue_vals.values[sorter.values], + points.get_facecolors()): + + assert tuple(fc[:3]) == pal[hue_names.index(hue)] + + def test_nested_swarmplot_horizontal(self): + + ax = cat.swarmplot(x="y", y="g", hue="h", data=self.df, orient="h") + + pal = palettes.color_palette() + hue_names = self.h.unique().tolist() + grouped_hues = list(self.h.groupby(self.g)) + + for i, (_, vals) in enumerate(self.y.groupby(self.g)): + + points = ax.collections[i] + x, y = points.get_offsets().T + sorter = np.argsort(vals) + npt.assert_array_almost_equal(x, vals.iloc[sorter]) + + _, hue_vals = grouped_hues[i] + for hue, fc in zip(hue_vals.values[sorter.values], + points.get_facecolors()): + + assert tuple(fc[:3]) == pal[hue_names.index(hue)] + + def test_unaligned_index(self): + + f, (ax1, ax2) = plt.subplots(2) + cat.swarmplot(x=self.g, y=self.y, ax=ax1) + cat.swarmplot(x=self.g, y=self.y_perm, ax=ax2) + for p1, p2 in zip(ax1.collections, ax2.collections): + assert np.allclose(p1.get_offsets()[:, 1], + p2.get_offsets()[:, 1]) + assert np.array_equal(p1.get_facecolors(), + p2.get_facecolors()) + + f, (ax1, ax2) = plt.subplots(2) + hue_order = self.h.unique() + cat.swarmplot(x=self.g, y=self.y, hue=self.h, + hue_order=hue_order, ax=ax1) + cat.swarmplot(x=self.g, y=self.y_perm, hue=self.h, + hue_order=hue_order, ax=ax2) + for p1, p2 in zip(ax1.collections, ax2.collections): + assert np.allclose(p1.get_offsets()[:, 1], + p2.get_offsets()[:, 1]) + assert np.array_equal(p1.get_facecolors(), + p2.get_facecolors()) + + f, (ax1, ax2) = plt.subplots(2) + hue_order = self.h.unique() + cat.swarmplot(x=self.g, y=self.y, hue=self.h, + dodge=True, hue_order=hue_order, ax=ax1) + cat.swarmplot(x=self.g, y=self.y_perm, hue=self.h, + dodge=True, hue_order=hue_order, ax=ax2) + for p1, p2 in zip(ax1.collections, ax2.collections): + assert np.allclose(p1.get_offsets()[:, 1], + p2.get_offsets()[:, 1]) + assert np.array_equal(p1.get_facecolors(), + p2.get_facecolors()) + + +class TestBarPlotter(CategoricalFixture): + + default_kws = dict( + x=None, y=None, hue=None, data=None, + estimator=np.mean, ci=95, n_boot=100, units=None, seed=None, + order=None, hue_order=None, + orient=None, color=None, palette=None, + saturation=.75, errcolor=".26", errwidth=None, + capsize=None, dodge=True + ) + + def test_nested_width(self): + + kws = self.default_kws.copy() + + p = cat._BarPlotter(**kws) + p.establish_variables("g", "y", hue="h", data=self.df) + assert p.nested_width == .8 / 2 + + p = cat._BarPlotter(**kws) + p.establish_variables("h", "y", "g", data=self.df) + assert p.nested_width == .8 / 3 + + kws["dodge"] = False + p = cat._BarPlotter(**kws) + p.establish_variables("h", "y", "g", data=self.df) + assert p.nested_width == .8 + + def test_draw_vertical_bars(self): + + kws = self.default_kws.copy() + kws.update(x="g", y="y", data=self.df) + p = cat._BarPlotter(**kws) + + f, ax = plt.subplots() + p.draw_bars(ax, {}) + + assert len(ax.patches) == len(p.plot_data) + assert len(ax.lines) == len(p.plot_data) + + for bar, color in zip(ax.patches, p.colors): + assert bar.get_facecolor()[:-1] == color + + positions = np.arange(len(p.plot_data)) - p.width / 2 + for bar, pos, stat in zip(ax.patches, positions, p.statistic): + assert bar.get_x() == pos + assert bar.get_width() == p.width + assert bar.get_y() == 0 + assert bar.get_height() == stat + + def test_draw_horizontal_bars(self): + + kws = self.default_kws.copy() + kws.update(x="y", y="g", orient="h", data=self.df) + p = cat._BarPlotter(**kws) + + f, ax = plt.subplots() + p.draw_bars(ax, {}) + + assert len(ax.patches) == len(p.plot_data) + assert len(ax.lines) == len(p.plot_data) + + for bar, color in zip(ax.patches, p.colors): + assert bar.get_facecolor()[:-1] == color + + positions = np.arange(len(p.plot_data)) - p.width / 2 + for bar, pos, stat in zip(ax.patches, positions, p.statistic): + assert bar.get_y() == pos + assert bar.get_height() == p.width + assert bar.get_x() == 0 + assert bar.get_width() == stat + + def test_draw_nested_vertical_bars(self): + + kws = self.default_kws.copy() + kws.update(x="g", y="y", hue="h", data=self.df) + p = cat._BarPlotter(**kws) + + f, ax = plt.subplots() + p.draw_bars(ax, {}) + + n_groups, n_hues = len(p.plot_data), len(p.hue_names) + assert len(ax.patches) == n_groups * n_hues + assert len(ax.lines) == n_groups * n_hues + + for bar in ax.patches[:n_groups]: + assert bar.get_facecolor()[:-1] == p.colors[0] + for bar in ax.patches[n_groups:]: + assert bar.get_facecolor()[:-1] == p.colors[1] + + positions = np.arange(len(p.plot_data)) + for bar, pos in zip(ax.patches[:n_groups], positions): + assert bar.get_x() == approx(pos - p.width / 2) + assert bar.get_width() == approx(p.nested_width) + + for bar, stat in zip(ax.patches, p.statistic.T.flat): + assert bar.get_y() == approx(0) + assert bar.get_height() == approx(stat) + + def test_draw_nested_horizontal_bars(self): + + kws = self.default_kws.copy() + kws.update(x="y", y="g", hue="h", orient="h", data=self.df) + p = cat._BarPlotter(**kws) + + f, ax = plt.subplots() + p.draw_bars(ax, {}) + + n_groups, n_hues = len(p.plot_data), len(p.hue_names) + assert len(ax.patches) == n_groups * n_hues + assert len(ax.lines) == n_groups * n_hues + + for bar in ax.patches[:n_groups]: + assert bar.get_facecolor()[:-1] == p.colors[0] + for bar in ax.patches[n_groups:]: + assert bar.get_facecolor()[:-1] == p.colors[1] + + positions = np.arange(len(p.plot_data)) + for bar, pos in zip(ax.patches[:n_groups], positions): + assert bar.get_y() == approx(pos - p.width / 2) + assert bar.get_height() == approx(p.nested_width) + + for bar, stat in zip(ax.patches, p.statistic.T.flat): + assert bar.get_x() == approx(0) + assert bar.get_width() == approx(stat) + + def test_draw_missing_bars(self): + + kws = self.default_kws.copy() + + order = list("abcd") + kws.update(x="g", y="y", order=order, data=self.df) + p = cat._BarPlotter(**kws) + + f, ax = plt.subplots() + p.draw_bars(ax, {}) + + assert len(ax.patches) == len(order) + assert len(ax.lines) == len(order) + + plt.close("all") + + hue_order = list("mno") + kws.update(x="g", y="y", hue="h", hue_order=hue_order, data=self.df) + p = cat._BarPlotter(**kws) + + f, ax = plt.subplots() + p.draw_bars(ax, {}) + + assert len(ax.patches) == len(p.plot_data) * len(hue_order) + assert len(ax.lines) == len(p.plot_data) * len(hue_order) + + plt.close("all") + + def test_unaligned_index(self): + + f, (ax1, ax2) = plt.subplots(2) + cat.barplot(x=self.g, y=self.y, ci="sd", ax=ax1) + cat.barplot(x=self.g, y=self.y_perm, ci="sd", ax=ax2) + for l1, l2 in zip(ax1.lines, ax2.lines): + assert approx(l1.get_xydata()) == l2.get_xydata() + for p1, p2 in zip(ax1.patches, ax2.patches): + assert approx(p1.get_xy()) == p2.get_xy() + assert approx(p1.get_height()) == p2.get_height() + assert approx(p1.get_width()) == p2.get_width() + + f, (ax1, ax2) = plt.subplots(2) + hue_order = self.h.unique() + cat.barplot(x=self.g, y=self.y, hue=self.h, + hue_order=hue_order, ci="sd", ax=ax1) + cat.barplot(x=self.g, y=self.y_perm, hue=self.h, + hue_order=hue_order, ci="sd", ax=ax2) + for l1, l2 in zip(ax1.lines, ax2.lines): + assert approx(l1.get_xydata()) == l2.get_xydata() + for p1, p2 in zip(ax1.patches, ax2.patches): + assert approx(p1.get_xy()) == p2.get_xy() + assert approx(p1.get_height()) == p2.get_height() + assert approx(p1.get_width()) == p2.get_width() + + def test_barplot_colors(self): + + # Test unnested palette colors + kws = self.default_kws.copy() + kws.update(x="g", y="y", data=self.df, + saturation=1, palette="muted") + p = cat._BarPlotter(**kws) + + f, ax = plt.subplots() + p.draw_bars(ax, {}) + + palette = palettes.color_palette("muted", len(self.g.unique())) + for patch, pal_color in zip(ax.patches, palette): + assert patch.get_facecolor()[:-1] == pal_color + + plt.close("all") + + # Test single color + color = (.2, .2, .3, 1) + kws = self.default_kws.copy() + kws.update(x="g", y="y", data=self.df, + saturation=1, color=color) + p = cat._BarPlotter(**kws) + + f, ax = plt.subplots() + p.draw_bars(ax, {}) + + for patch in ax.patches: + assert patch.get_facecolor() == color + + plt.close("all") + + # Test nested palette colors + kws = self.default_kws.copy() + kws.update(x="g", y="y", hue="h", data=self.df, + saturation=1, palette="Set2") + p = cat._BarPlotter(**kws) + + f, ax = plt.subplots() + p.draw_bars(ax, {}) + + palette = palettes.color_palette("Set2", len(self.h.unique())) + for patch in ax.patches[:len(self.g.unique())]: + assert patch.get_facecolor()[:-1] == palette[0] + for patch in ax.patches[len(self.g.unique()):]: + assert patch.get_facecolor()[:-1] == palette[1] + + plt.close("all") + + def test_simple_barplots(self): + + ax = cat.barplot(x="g", y="y", data=self.df) + assert len(ax.patches) == len(self.g.unique()) + assert ax.get_xlabel() == "g" + assert ax.get_ylabel() == "y" + plt.close("all") + + ax = cat.barplot(x="y", y="g", orient="h", data=self.df) + assert len(ax.patches) == len(self.g.unique()) + assert ax.get_xlabel() == "y" + assert ax.get_ylabel() == "g" + plt.close("all") + + ax = cat.barplot(x="g", y="y", hue="h", data=self.df) + assert len(ax.patches) == len(self.g.unique()) * len(self.h.unique()) + assert ax.get_xlabel() == "g" + assert ax.get_ylabel() == "y" + plt.close("all") + + ax = cat.barplot(x="y", y="g", hue="h", orient="h", data=self.df) + assert len(ax.patches) == len(self.g.unique()) * len(self.h.unique()) + assert ax.get_xlabel() == "y" + assert ax.get_ylabel() == "g" + plt.close("all") + + +class TestPointPlotter(CategoricalFixture): + + default_kws = dict( + x=None, y=None, hue=None, data=None, + estimator=np.mean, ci=95, n_boot=100, units=None, seed=None, + order=None, hue_order=None, + markers="o", linestyles="-", dodge=0, + join=True, scale=1, + orient=None, color=None, palette=None, + ) + + def test_different_defualt_colors(self): + + kws = self.default_kws.copy() + kws.update(dict(x="g", y="y", data=self.df)) + p = cat._PointPlotter(**kws) + color = palettes.color_palette()[0] + npt.assert_array_equal(p.colors, [color, color, color]) + + def test_hue_offsets(self): + + kws = self.default_kws.copy() + kws.update(dict(x="g", y="y", hue="h", data=self.df)) + + p = cat._PointPlotter(**kws) + npt.assert_array_equal(p.hue_offsets, [0, 0]) + + kws.update(dict(dodge=.5)) + + p = cat._PointPlotter(**kws) + npt.assert_array_equal(p.hue_offsets, [-.25, .25]) + + kws.update(dict(x="h", hue="g", dodge=0)) + + p = cat._PointPlotter(**kws) + npt.assert_array_equal(p.hue_offsets, [0, 0, 0]) + + kws.update(dict(dodge=.3)) + + p = cat._PointPlotter(**kws) + npt.assert_array_equal(p.hue_offsets, [-.15, 0, .15]) + + def test_draw_vertical_points(self): + + kws = self.default_kws.copy() + kws.update(x="g", y="y", data=self.df) + p = cat._PointPlotter(**kws) + + f, ax = plt.subplots() + p.draw_points(ax) + + assert len(ax.collections) == 1 + assert len(ax.lines) == len(p.plot_data) + 1 + points = ax.collections[0] + assert len(points.get_offsets()) == len(p.plot_data) + + x, y = points.get_offsets().T + npt.assert_array_equal(x, np.arange(len(p.plot_data))) + npt.assert_array_equal(y, p.statistic) + + for got_color, want_color in zip(points.get_facecolors(), + p.colors): + npt.assert_array_equal(got_color[:-1], want_color) + + def test_draw_horizontal_points(self): + + kws = self.default_kws.copy() + kws.update(x="y", y="g", orient="h", data=self.df) + p = cat._PointPlotter(**kws) + + f, ax = plt.subplots() + p.draw_points(ax) + + assert len(ax.collections) == 1 + assert len(ax.lines) == len(p.plot_data) + 1 + points = ax.collections[0] + assert len(points.get_offsets()) == len(p.plot_data) + + x, y = points.get_offsets().T + npt.assert_array_equal(x, p.statistic) + npt.assert_array_equal(y, np.arange(len(p.plot_data))) + + for got_color, want_color in zip(points.get_facecolors(), + p.colors): + npt.assert_array_equal(got_color[:-1], want_color) + + def test_draw_vertical_nested_points(self): + + kws = self.default_kws.copy() + kws.update(x="g", y="y", hue="h", data=self.df) + p = cat._PointPlotter(**kws) + + f, ax = plt.subplots() + p.draw_points(ax) + + assert len(ax.collections) == 2 + assert len(ax.lines) == len(p.plot_data) * len(p.hue_names) + len(p.hue_names) + + for points, numbers, color in zip(ax.collections, + p.statistic.T, + p.colors): + + assert len(points.get_offsets()) == len(p.plot_data) + + x, y = points.get_offsets().T + npt.assert_array_equal(x, np.arange(len(p.plot_data))) + npt.assert_array_equal(y, numbers) + + for got_color in points.get_facecolors(): + npt.assert_array_equal(got_color[:-1], color) + + def test_draw_horizontal_nested_points(self): + + kws = self.default_kws.copy() + kws.update(x="y", y="g", hue="h", orient="h", data=self.df) + p = cat._PointPlotter(**kws) + + f, ax = plt.subplots() + p.draw_points(ax) + + assert len(ax.collections) == 2 + assert len(ax.lines) == len(p.plot_data) * len(p.hue_names) + len(p.hue_names) + + for points, numbers, color in zip(ax.collections, + p.statistic.T, + p.colors): + + assert len(points.get_offsets()) == len(p.plot_data) + + x, y = points.get_offsets().T + npt.assert_array_equal(x, numbers) + npt.assert_array_equal(y, np.arange(len(p.plot_data))) + + for got_color in points.get_facecolors(): + npt.assert_array_equal(got_color[:-1], color) + + def test_draw_missing_points(self): + + kws = self.default_kws.copy() + df = self.df.copy() + + kws.update(x="g", y="y", hue="h", hue_order=["x", "y"], data=df) + p = cat._PointPlotter(**kws) + f, ax = plt.subplots() + p.draw_points(ax) + + df.loc[df["h"] == "m", "y"] = np.nan + kws.update(x="g", y="y", hue="h", data=df) + p = cat._PointPlotter(**kws) + f, ax = plt.subplots() + p.draw_points(ax) + + def test_unaligned_index(self): + + f, (ax1, ax2) = plt.subplots(2) + cat.pointplot(x=self.g, y=self.y, ci="sd", ax=ax1) + cat.pointplot(x=self.g, y=self.y_perm, ci="sd", ax=ax2) + for l1, l2 in zip(ax1.lines, ax2.lines): + assert approx(l1.get_xydata()) == l2.get_xydata() + for p1, p2 in zip(ax1.collections, ax2.collections): + assert approx(p1.get_offsets()) == p2.get_offsets() + + f, (ax1, ax2) = plt.subplots(2) + hue_order = self.h.unique() + cat.pointplot(x=self.g, y=self.y, hue=self.h, + hue_order=hue_order, ci="sd", ax=ax1) + cat.pointplot(x=self.g, y=self.y_perm, hue=self.h, + hue_order=hue_order, ci="sd", ax=ax2) + for l1, l2 in zip(ax1.lines, ax2.lines): + assert approx(l1.get_xydata()) == l2.get_xydata() + for p1, p2 in zip(ax1.collections, ax2.collections): + assert approx(p1.get_offsets()) == p2.get_offsets() + + def test_pointplot_colors(self): + + # Test a single-color unnested plot + color = (.2, .2, .3, 1) + kws = self.default_kws.copy() + kws.update(x="g", y="y", data=self.df, color=color) + p = cat._PointPlotter(**kws) + + f, ax = plt.subplots() + p.draw_points(ax) + + for line in ax.lines: + assert line.get_color() == color[:-1] + + for got_color in ax.collections[0].get_facecolors(): + npt.assert_array_equal(rgb2hex(got_color), rgb2hex(color)) + + plt.close("all") + + # Test a multi-color unnested plot + palette = palettes.color_palette("Set1", 3) + kws.update(x="g", y="y", data=self.df, palette="Set1") + p = cat._PointPlotter(**kws) + + assert not p.join + + f, ax = plt.subplots() + p.draw_points(ax) + + for line, pal_color in zip(ax.lines, palette): + npt.assert_array_equal(line.get_color(), pal_color) + + for point_color, pal_color in zip(ax.collections[0].get_facecolors(), + palette): + npt.assert_array_equal(rgb2hex(point_color), rgb2hex(pal_color)) + + plt.close("all") + + # Test a multi-colored nested plot + palette = palettes.color_palette("dark", 2) + kws.update(x="g", y="y", hue="h", data=self.df, palette="dark") + p = cat._PointPlotter(**kws) + + f, ax = plt.subplots() + p.draw_points(ax) + + for line in ax.lines[:(len(p.plot_data) + 1)]: + assert line.get_color() == palette[0] + for line in ax.lines[(len(p.plot_data) + 1):]: + assert line.get_color() == palette[1] + + for i, pal_color in enumerate(palette): + for point_color in ax.collections[i].get_facecolors(): + npt.assert_array_equal(point_color[:-1], pal_color) + + plt.close("all") + + def test_simple_pointplots(self): + + ax = cat.pointplot(x="g", y="y", data=self.df) + assert len(ax.collections) == 1 + assert len(ax.lines) == len(self.g.unique()) + 1 + assert ax.get_xlabel() == "g" + assert ax.get_ylabel() == "y" + plt.close("all") + + ax = cat.pointplot(x="y", y="g", orient="h", data=self.df) + assert len(ax.collections) == 1 + assert len(ax.lines) == len(self.g.unique()) + 1 + assert ax.get_xlabel() == "y" + assert ax.get_ylabel() == "g" + plt.close("all") + + ax = cat.pointplot(x="g", y="y", hue="h", data=self.df) + assert len(ax.collections) == len(self.h.unique()) + assert len(ax.lines) == ( + len(self.g.unique()) * len(self.h.unique()) + len(self.h.unique()) + ) + assert ax.get_xlabel() == "g" + assert ax.get_ylabel() == "y" + plt.close("all") + + ax = cat.pointplot(x="y", y="g", hue="h", orient="h", data=self.df) + assert len(ax.collections) == len(self.h.unique()) + assert len(ax.lines) == ( + len(self.g.unique()) * len(self.h.unique()) + len(self.h.unique()) + ) + assert ax.get_xlabel() == "y" + assert ax.get_ylabel() == "g" + plt.close("all") + + +class TestCountPlot(CategoricalFixture): + + def test_plot_elements(self): + + ax = cat.countplot(x="g", data=self.df) + assert len(ax.patches) == self.g.unique().size + for p in ax.patches: + assert p.get_y() == 0 + assert p.get_height() == self.g.size / self.g.unique().size + plt.close("all") + + ax = cat.countplot(y="g", data=self.df) + assert len(ax.patches) == self.g.unique().size + for p in ax.patches: + assert p.get_x() == 0 + assert p.get_width() == self.g.size / self.g.unique().size + plt.close("all") + + ax = cat.countplot(x="g", hue="h", data=self.df) + assert len(ax.patches) == self.g.unique().size * self.h.unique().size + plt.close("all") + + ax = cat.countplot(y="g", hue="h", data=self.df) + assert len(ax.patches) == self.g.unique().size * self.h.unique().size + plt.close("all") + + def test_input_error(self): + + with pytest.raises(ValueError): + cat.countplot(x="g", y="h", data=self.df) + + +class TestCatPlot(CategoricalFixture): + + def test_facet_organization(self): + + g = cat.catplot(x="g", y="y", data=self.df) + assert g.axes.shape == (1, 1) + + g = cat.catplot(x="g", y="y", col="h", data=self.df) + assert g.axes.shape == (1, 2) + + g = cat.catplot(x="g", y="y", row="h", data=self.df) + assert g.axes.shape == (2, 1) + + g = cat.catplot(x="g", y="y", col="u", row="h", data=self.df) + assert g.axes.shape == (2, 3) + + def test_plot_elements(self): + + g = cat.catplot(x="g", y="y", data=self.df, kind="point") + assert len(g.ax.collections) == 1 + want_lines = self.g.unique().size + 1 + assert len(g.ax.lines) == want_lines + + g = cat.catplot(x="g", y="y", hue="h", data=self.df, kind="point") + want_collections = self.h.unique().size + assert len(g.ax.collections) == want_collections + want_lines = (self.g.unique().size + 1) * self.h.unique().size + assert len(g.ax.lines) == want_lines + + g = cat.catplot(x="g", y="y", data=self.df, kind="bar") + want_elements = self.g.unique().size + assert len(g.ax.patches) == want_elements + assert len(g.ax.lines) == want_elements + + g = cat.catplot(x="g", y="y", hue="h", data=self.df, kind="bar") + want_elements = self.g.unique().size * self.h.unique().size + assert len(g.ax.patches) == want_elements + assert len(g.ax.lines) == want_elements + + g = cat.catplot(x="g", data=self.df, kind="count") + want_elements = self.g.unique().size + assert len(g.ax.patches) == want_elements + assert len(g.ax.lines) == 0 + + g = cat.catplot(x="g", hue="h", data=self.df, kind="count") + want_elements = self.g.unique().size * self.h.unique().size + assert len(g.ax.patches) == want_elements + assert len(g.ax.lines) == 0 + + g = cat.catplot(x="g", y="y", data=self.df, kind="box") + want_artists = self.g.unique().size + assert len(g.ax.artists) == want_artists + + g = cat.catplot(x="g", y="y", hue="h", data=self.df, kind="box") + want_artists = self.g.unique().size * self.h.unique().size + assert len(g.ax.artists) == want_artists + + g = cat.catplot(x="g", y="y", data=self.df, + kind="violin", inner=None) + want_elements = self.g.unique().size + assert len(g.ax.collections) == want_elements + + g = cat.catplot(x="g", y="y", hue="h", data=self.df, + kind="violin", inner=None) + want_elements = self.g.unique().size * self.h.unique().size + assert len(g.ax.collections) == want_elements + + g = cat.catplot(x="g", y="y", data=self.df, kind="strip") + want_elements = self.g.unique().size + assert len(g.ax.collections) == want_elements + + g = cat.catplot(x="g", y="y", hue="h", data=self.df, kind="strip") + want_elements = self.g.unique().size + self.h.unique().size + assert len(g.ax.collections) == want_elements + + def test_bad_plot_kind_error(self): + + with pytest.raises(ValueError): + cat.catplot(x="g", y="y", data=self.df, kind="not_a_kind") + + def test_count_x_and_y(self): + + with pytest.raises(ValueError): + cat.catplot(x="g", y="y", data=self.df, kind="count") + + def test_plot_colors(self): + + ax = cat.barplot(x="g", y="y", data=self.df) + g = cat.catplot(x="g", y="y", data=self.df, kind="bar") + for p1, p2 in zip(ax.patches, g.ax.patches): + assert p1.get_facecolor() == p2.get_facecolor() + plt.close("all") + + ax = cat.barplot(x="g", y="y", data=self.df, color="purple") + g = cat.catplot(x="g", y="y", data=self.df, + kind="bar", color="purple") + for p1, p2 in zip(ax.patches, g.ax.patches): + assert p1.get_facecolor() == p2.get_facecolor() + plt.close("all") + + ax = cat.barplot(x="g", y="y", data=self.df, palette="Set2") + g = cat.catplot(x="g", y="y", data=self.df, + kind="bar", palette="Set2") + for p1, p2 in zip(ax.patches, g.ax.patches): + assert p1.get_facecolor() == p2.get_facecolor() + plt.close("all") + + ax = cat.pointplot(x="g", y="y", data=self.df) + g = cat.catplot(x="g", y="y", data=self.df) + for l1, l2 in zip(ax.lines, g.ax.lines): + assert l1.get_color() == l2.get_color() + plt.close("all") + + ax = cat.pointplot(x="g", y="y", data=self.df, color="purple") + g = cat.catplot(x="g", y="y", data=self.df, color="purple") + for l1, l2 in zip(ax.lines, g.ax.lines): + assert l1.get_color() == l2.get_color() + plt.close("all") + + ax = cat.pointplot(x="g", y="y", data=self.df, palette="Set2") + g = cat.catplot(x="g", y="y", data=self.df, palette="Set2") + for l1, l2 in zip(ax.lines, g.ax.lines): + assert l1.get_color() == l2.get_color() + plt.close("all") + + def test_ax_kwarg_removal(self): + + f, ax = plt.subplots() + with pytest.warns(UserWarning): + g = cat.catplot(x="g", y="y", data=self.df, ax=ax) + assert len(ax.collections) == 0 + assert len(g.ax.collections) > 0 + + def test_factorplot(self): + + with pytest.warns(UserWarning): + g = cat.factorplot(x="g", y="y", data=self.df) + + assert len(g.ax.collections) == 1 + want_lines = self.g.unique().size + 1 + assert len(g.ax.lines) == want_lines + + def test_share_xy(self): + + # Test default behavior works + g = cat.catplot(x="g", y="y", col="g", data=self.df, sharex=True) + for ax in g.axes.flat: + assert len(ax.collections) == len(self.df.g.unique()) + + g = cat.catplot(x="y", y="g", col="g", data=self.df, sharey=True) + for ax in g.axes.flat: + assert len(ax.collections) == len(self.df.g.unique()) + + # Test unsharing works + with pytest.warns(UserWarning): + g = cat.catplot(x="g", y="y", col="g", data=self.df, sharex=False) + for ax in g.axes.flat: + assert len(ax.collections) == 1 + + with pytest.warns(UserWarning): + g = cat.catplot(x="y", y="g", col="g", data=self.df, sharey=False) + for ax in g.axes.flat: + assert len(ax.collections) == 1 + + # Make sure no warning is raised if color is provided on unshared plot + with pytest.warns(None) as record: + g = cat.catplot( + x="g", y="y", col="g", data=self.df, sharex=False, color="b" + ) + assert not len(record) + + with pytest.warns(None) as record: + g = cat.catplot( + x="y", y="g", col="g", data=self.df, sharey=False, color="r" + ) + assert not len(record) + + # Make sure order is used if given, regardless of sharex value + order = self.df.g.unique() + g = cat.catplot(x="g", y="y", col="g", data=self.df, sharex=False, order=order) + for ax in g.axes.flat: + assert len(ax.collections) == len(self.df.g.unique()) + + g = cat.catplot(x="y", y="g", col="g", data=self.df, sharey=False, order=order) + for ax in g.axes.flat: + assert len(ax.collections) == len(self.df.g.unique()) + + +class TestBoxenPlotter(CategoricalFixture): + + default_kws = dict(x=None, y=None, hue=None, data=None, + order=None, hue_order=None, + orient=None, color=None, palette=None, + saturation=.75, width=.8, dodge=True, + k_depth='tukey', linewidth=None, + scale='exponential', outlier_prop=0.007, + trust_alpha=0.05, showfliers=True) + + def ispatch(self, c): + + return isinstance(c, mpl.collections.PatchCollection) + + def ispath(self, c): + + return isinstance(c, mpl.collections.PathCollection) + + def edge_calc(self, n, data): + + q = np.asanyarray([0.5 ** n, 1 - 0.5 ** n]) * 100 + q = list(np.unique(q)) + return np.percentile(data, q) + + def test_box_ends_finite(self): + + p = cat._LVPlotter(**self.default_kws) + p.establish_variables("g", "y", data=self.df) + box_ends = [] + k_vals = [] + for s in p.plot_data: + b, k = p._lv_box_ends(s) + box_ends.append(b) + k_vals.append(k) + + # Check that all the box ends are finite and are within + # the bounds of the data + b_e = map(lambda a: np.all(np.isfinite(a)), box_ends) + assert np.sum(list(b_e)) == len(box_ends) + + def within(t): + a, d = t + return ((np.ravel(a) <= d.max()) + & (np.ravel(a) >= d.min())).all() + + b_w = map(within, zip(box_ends, p.plot_data)) + assert np.sum(list(b_w)) == len(box_ends) + + k_f = map(lambda k: (k > 0.) & np.isfinite(k), k_vals) + assert np.sum(list(k_f)) == len(k_vals) + + def test_box_ends_correct_tukey(self): + + n = 100 + linear_data = np.arange(n) + expected_k = max(int(np.log2(n)) - 3, 1) + expected_edges = [self.edge_calc(i, linear_data) + for i in range(expected_k + 1, 1, -1)] + + p = cat._LVPlotter(**self.default_kws) + calc_edges, calc_k = p._lv_box_ends(linear_data) + + npt.assert_array_equal(expected_edges, calc_edges) + assert expected_k == calc_k + + def test_box_ends_correct_proportion(self): + + n = 100 + linear_data = np.arange(n) + expected_k = int(np.log2(n)) - int(np.log2(n * 0.007)) + 1 + expected_edges = [self.edge_calc(i, linear_data) + for i in range(expected_k + 1, 1, -1)] + + kws = self.default_kws.copy() + kws["k_depth"] = "proportion" + p = cat._LVPlotter(**kws) + calc_edges, calc_k = p._lv_box_ends(linear_data) + + npt.assert_array_equal(expected_edges, calc_edges) + assert expected_k == calc_k + + @pytest.mark.parametrize( + "n,exp_k", + [(491, 6), (492, 7), (983, 7), (984, 8), (1966, 8), (1967, 9)], + ) + def test_box_ends_correct_trustworthy(self, n, exp_k): + + linear_data = np.arange(n) + kws = self.default_kws.copy() + kws["k_depth"] = "trustworthy" + p = cat._LVPlotter(**kws) + _, calc_k = p._lv_box_ends(linear_data) + + assert exp_k == calc_k + + def test_outliers(self): + + n = 100 + outlier_data = np.append(np.arange(n - 1), 2 * n) + expected_k = max(int(np.log2(n)) - 3, 1) + expected_edges = [self.edge_calc(i, outlier_data) + for i in range(expected_k + 1, 1, -1)] + + p = cat._LVPlotter(**self.default_kws) + calc_edges, calc_k = p._lv_box_ends(outlier_data) + + npt.assert_array_equal(calc_edges, expected_edges) + assert calc_k == expected_k + + out_calc = p._lv_outliers(outlier_data, calc_k) + out_exp = p._lv_outliers(outlier_data, expected_k) + + npt.assert_equal(out_calc, out_exp) + + def test_showfliers(self): + + ax = cat.boxenplot(x="g", y="y", data=self.df, k_depth="proportion", + showfliers=True) + ax_collections = list(filter(self.ispath, ax.collections)) + for c in ax_collections: + assert len(c.get_offsets()) == 2 + + # Test that all data points are in the plot + assert ax.get_ylim()[0] < self.df["y"].min() + assert ax.get_ylim()[1] > self.df["y"].max() + + plt.close("all") + + ax = cat.boxenplot(x="g", y="y", data=self.df, showfliers=False) + assert len(list(filter(self.ispath, ax.collections))) == 0 + + plt.close("all") + + def test_invalid_depths(self): + + kws = self.default_kws.copy() + + # Make sure illegal depth raises + kws["k_depth"] = "nosuchdepth" + with pytest.raises(ValueError): + cat._LVPlotter(**kws) + + # Make sure illegal outlier_prop raises + kws["k_depth"] = "proportion" + for p in (-13, 37): + kws["outlier_prop"] = p + with pytest.raises(ValueError): + cat._LVPlotter(**kws) + + kws["k_depth"] = "trustworthy" + for alpha in (-13, 37): + kws["trust_alpha"] = alpha + with pytest.raises(ValueError): + cat._LVPlotter(**kws) + + @pytest.mark.parametrize("power", [1, 3, 7, 11, 13, 17]) + def test_valid_depths(self, power): + + x = np.random.standard_t(10, 2 ** power) + + valid_depths = ["proportion", "tukey", "trustworthy", "full"] + kws = self.default_kws.copy() + + for depth in valid_depths + [4]: + kws["k_depth"] = depth + box_ends, k = cat._LVPlotter(**kws)._lv_box_ends(x) + + if depth == "full": + assert k == int(np.log2(len(x))) + 1 + + def test_valid_scales(self): + + valid_scales = ["linear", "exponential", "area"] + kws = self.default_kws.copy() + + for scale in valid_scales + ["unknown_scale"]: + kws["scale"] = scale + if scale not in valid_scales: + with pytest.raises(ValueError): + cat._LVPlotter(**kws) + else: + cat._LVPlotter(**kws) + + def test_hue_offsets(self): + + p = cat._LVPlotter(**self.default_kws) + p.establish_variables("g", "y", hue="h", data=self.df) + npt.assert_array_equal(p.hue_offsets, [-.2, .2]) + + kws = self.default_kws.copy() + kws["width"] = .6 + p = cat._LVPlotter(**kws) + p.establish_variables("g", "y", hue="h", data=self.df) + npt.assert_array_equal(p.hue_offsets, [-.15, .15]) + + p = cat._LVPlotter(**kws) + p.establish_variables("h", "y", "g", data=self.df) + npt.assert_array_almost_equal(p.hue_offsets, [-.2, 0, .2]) + + def test_axes_data(self): + + ax = cat.boxenplot(x="g", y="y", data=self.df) + patches = filter(self.ispatch, ax.collections) + assert len(list(patches)) == 3 + + plt.close("all") + + ax = cat.boxenplot(x="g", y="y", hue="h", data=self.df) + patches = filter(self.ispatch, ax.collections) + assert len(list(patches)) == 6 + + plt.close("all") + + def test_box_colors(self): + + ax = cat.boxenplot(x="g", y="y", data=self.df, saturation=1) + pal = palettes.color_palette(n_colors=3) + for patch, color in zip(ax.artists, pal): + assert patch.get_facecolor()[:3] == color + + plt.close("all") + + ax = cat.boxenplot(x="g", y="y", hue="h", data=self.df, saturation=1) + pal = palettes.color_palette(n_colors=2) + for patch, color in zip(ax.artists, pal * 2): + assert patch.get_facecolor()[:3] == color + + plt.close("all") + + def test_draw_missing_boxes(self): + + ax = cat.boxenplot(x="g", y="y", data=self.df, + order=["a", "b", "c", "d"]) + + patches = filter(self.ispatch, ax.collections) + assert len(list(patches)) == 3 + plt.close("all") + + def test_unaligned_index(self): + + f, (ax1, ax2) = plt.subplots(2) + cat.boxenplot(x=self.g, y=self.y, ax=ax1) + cat.boxenplot(x=self.g, y=self.y_perm, ax=ax2) + for l1, l2 in zip(ax1.lines, ax2.lines): + assert np.array_equal(l1.get_xydata(), l2.get_xydata()) + + f, (ax1, ax2) = plt.subplots(2) + hue_order = self.h.unique() + cat.boxenplot(x=self.g, y=self.y, hue=self.h, + hue_order=hue_order, ax=ax1) + cat.boxenplot(x=self.g, y=self.y_perm, hue=self.h, + hue_order=hue_order, ax=ax2) + for l1, l2 in zip(ax1.lines, ax2.lines): + assert np.array_equal(l1.get_xydata(), l2.get_xydata()) + + def test_missing_data(self): + + x = ["a", "a", "b", "b", "c", "c", "d", "d"] + h = ["x", "y", "x", "y", "x", "y", "x", "y"] + y = self.rs.randn(8) + y[-2:] = np.nan + + ax = cat.boxenplot(x=x, y=y) + assert len(ax.lines) == 3 + + plt.close("all") + + y[-1] = 0 + ax = cat.boxenplot(x=x, y=y, hue=h) + assert len(ax.lines) == 7 + + plt.close("all") + + def test_boxenplots(self): + + # Smoke test the high level boxenplot options + + cat.boxenplot(x="y", data=self.df) + plt.close("all") + + cat.boxenplot(y="y", data=self.df) + plt.close("all") + + cat.boxenplot(x="g", y="y", data=self.df) + plt.close("all") + + cat.boxenplot(x="y", y="g", data=self.df, orient="h") + plt.close("all") + + cat.boxenplot(x="g", y="y", hue="h", data=self.df) + plt.close("all") + + for scale in ("linear", "area", "exponential"): + cat.boxenplot(x="g", y="y", hue="h", scale=scale, data=self.df) + plt.close("all") + + for depth in ("proportion", "tukey", "trustworthy"): + cat.boxenplot(x="g", y="y", hue="h", k_depth=depth, data=self.df) + plt.close("all") + + order = list("nabc") + cat.boxenplot(x="g", y="y", hue="h", order=order, data=self.df) + plt.close("all") + + order = list("omn") + cat.boxenplot(x="g", y="y", hue="h", hue_order=order, data=self.df) + plt.close("all") + + cat.boxenplot(x="y", y="g", hue="h", data=self.df, orient="h") + plt.close("all") + + cat.boxenplot(x="y", y="g", hue="h", data=self.df, orient="h", + palette="Set2") + plt.close("all") + + cat.boxenplot(x="y", y="g", hue="h", data=self.df, + orient="h", color="b") + plt.close("all") + + def test_axes_annotation(self): + + ax = cat.boxenplot(x="g", y="y", data=self.df) + assert ax.get_xlabel() == "g" + assert ax.get_ylabel() == "y" + assert ax.get_xlim() == (-.5, 2.5) + npt.assert_array_equal(ax.get_xticks(), [0, 1, 2]) + npt.assert_array_equal([l.get_text() for l in ax.get_xticklabels()], + ["a", "b", "c"]) + + plt.close("all") + + ax = cat.boxenplot(x="g", y="y", hue="h", data=self.df) + assert ax.get_xlabel() == "g" + assert ax.get_ylabel() == "y" + npt.assert_array_equal(ax.get_xticks(), [0, 1, 2]) + npt.assert_array_equal([l.get_text() for l in ax.get_xticklabels()], + ["a", "b", "c"]) + npt.assert_array_equal([l.get_text() for l in ax.legend_.get_texts()], + ["m", "n"]) + + plt.close("all") + + ax = cat.boxenplot(x="y", y="g", data=self.df, orient="h") + assert ax.get_xlabel() == "y" + assert ax.get_ylabel() == "g" + assert ax.get_ylim() == (2.5, -.5) + npt.assert_array_equal(ax.get_yticks(), [0, 1, 2]) + npt.assert_array_equal([l.get_text() for l in ax.get_yticklabels()], + ["a", "b", "c"]) + + plt.close("all") + + @pytest.mark.parametrize("size", ["large", "medium", "small", 22, 12]) + def test_legend_titlesize(self, size): + + if LooseVersion(mpl.__version__) >= LooseVersion("3.0"): + rc_ctx = {"legend.title_fontsize": size} + else: # Old matplotlib doesn't have legend.title_fontsize rcparam + rc_ctx = {"axes.labelsize": size} + if isinstance(size, int): + size = size * .85 + exp = mpl.font_manager.FontProperties(size=size).get_size() + + with plt.rc_context(rc=rc_ctx): + ax = cat.boxenplot(x="g", y="y", hue="h", data=self.df) + obs = ax.get_legend().get_title().get_fontproperties().get_size() + assert obs == exp + + plt.close("all") + + @pytest.mark.skipif( + LooseVersion(pd.__version__) < "1.2", + reason="Test requires pandas>=1.2") + def test_Float64_input(self): + data = pd.DataFrame( + {"x": np.random.choice(["a", "b"], 20), "y": np.random.random(20)} + ) + data['y'] = data['y'].astype(pd.Float64Dtype()) + _ = cat.boxenplot(x="x", y="y", data=data) + + plt.close("all") diff --git a/grplot_seaborn/tests/test_core.py b/grplot_seaborn/tests/test_core.py new file mode 100644 index 0000000..da0f2d0 --- /dev/null +++ b/grplot_seaborn/tests/test_core.py @@ -0,0 +1,1284 @@ +import itertools +import numpy as np +import pandas as pd +import matplotlib as mpl +import matplotlib.pyplot as plt + +import pytest +from numpy.testing import assert_array_equal +from pandas.testing import assert_frame_equal + +from ..axisgrid import FacetGrid +from .._core import ( + SemanticMapping, + HueMapping, + SizeMapping, + StyleMapping, + VectorPlotter, + variable_type, + infer_orient, + unique_dashes, + unique_markers, + categorical_order, +) + +from ..palettes import color_palette + + +try: + from pandas import NA as PD_NA +except ImportError: + PD_NA = None + + +class TestSemanticMapping: + + def test_call_lookup(self): + + m = SemanticMapping(VectorPlotter()) + lookup_table = dict(zip("abc", (1, 2, 3))) + m.lookup_table = lookup_table + for key, val in lookup_table.items(): + assert m(key) == val + + +class TestHueMapping: + + def test_init_from_map(self, long_df): + + p_orig = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a") + ) + palette = "Set2" + p = HueMapping.map(p_orig, palette=palette) + assert p is p_orig + assert isinstance(p._hue_map, HueMapping) + assert p._hue_map.palette == palette + + def test_plotter_default_init(self, long_df): + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y"), + ) + assert isinstance(p._hue_map, HueMapping) + assert p._hue_map.map_type is None + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a"), + ) + assert isinstance(p._hue_map, HueMapping) + assert p._hue_map.map_type == p.var_types["hue"] + + def test_plotter_reinit(self, long_df): + + p_orig = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a"), + ) + palette = "muted" + hue_order = ["b", "a", "c"] + p = p_orig.map_hue(palette=palette, order=hue_order) + assert p is p_orig + assert p._hue_map.palette == palette + assert p._hue_map.levels == hue_order + + def test_hue_map_null(self, flat_series, null_series): + + p = VectorPlotter(variables=dict(x=flat_series, hue=null_series)) + m = HueMapping(p) + assert m.levels is None + assert m.map_type is None + assert m.palette is None + assert m.cmap is None + assert m.norm is None + assert m.lookup_table is None + + def test_hue_map_categorical(self, wide_df, long_df): + + p = VectorPlotter(data=wide_df) + m = HueMapping(p) + assert m.levels == wide_df.columns.tolist() + assert m.map_type == "categorical" + assert m.cmap is None + + # Test named palette + palette = "Blues" + expected_colors = color_palette(palette, wide_df.shape[1]) + expected_lookup_table = dict(zip(wide_df.columns, expected_colors)) + m = HueMapping(p, palette=palette) + assert m.palette == "Blues" + assert m.lookup_table == expected_lookup_table + + # Test list palette + palette = color_palette("Reds", wide_df.shape[1]) + expected_lookup_table = dict(zip(wide_df.columns, palette)) + m = HueMapping(p, palette=palette) + assert m.palette == palette + assert m.lookup_table == expected_lookup_table + + # Test dict palette + colors = color_palette("Set1", 8) + palette = dict(zip(wide_df.columns, colors)) + m = HueMapping(p, palette=palette) + assert m.palette == palette + assert m.lookup_table == palette + + # Test dict with missing keys + palette = dict(zip(wide_df.columns[:-1], colors)) + with pytest.raises(ValueError): + HueMapping(p, palette=palette) + + # Test dict with missing keys + palette = dict(zip(wide_df.columns[:-1], colors)) + with pytest.raises(ValueError): + HueMapping(p, palette=palette) + + # Test list with wrong number of colors + palette = colors[:-1] + with pytest.raises(ValueError): + HueMapping(p, palette=palette) + + # Test hue order + hue_order = ["a", "c", "d"] + m = HueMapping(p, order=hue_order) + assert m.levels == hue_order + + # Test long data + p = VectorPlotter(data=long_df, variables=dict(x="x", y="y", hue="a")) + m = HueMapping(p) + assert m.levels == categorical_order(long_df["a"]) + assert m.map_type == "categorical" + assert m.cmap is None + + # Test default palette + m = HueMapping(p) + hue_levels = categorical_order(long_df["a"]) + expected_colors = color_palette(n_colors=len(hue_levels)) + expected_lookup_table = dict(zip(hue_levels, expected_colors)) + assert m.lookup_table == expected_lookup_table + + # Test missing data + m = HueMapping(p) + assert m(np.nan) == (0, 0, 0, 0) + + # Test default palette with many levels + x = y = np.arange(26) + hue = pd.Series(list("abcdefghijklmnopqrstuvwxyz")) + p = VectorPlotter(variables=dict(x=x, y=y, hue=hue)) + m = HueMapping(p) + expected_colors = color_palette("husl", n_colors=len(hue)) + expected_lookup_table = dict(zip(hue, expected_colors)) + assert m.lookup_table == expected_lookup_table + + # Test binary data + p = VectorPlotter(data=long_df, variables=dict(x="x", y="y", hue="c")) + m = HueMapping(p) + assert m.levels == [0, 1] + assert m.map_type == "categorical" + + for val in [0, 1]: + p = VectorPlotter( + data=long_df[long_df["c"] == val], + variables=dict(x="x", y="y", hue="c"), + ) + m = HueMapping(p) + assert m.levels == [val] + assert m.map_type == "categorical" + + # Test Timestamp data + p = VectorPlotter(data=long_df, variables=dict(x="x", y="y", hue="t")) + m = HueMapping(p) + assert m.levels == [pd.Timestamp(t) for t in long_df["t"].unique()] + assert m.map_type == "datetime" + + # Test excplicit categories + p = VectorPlotter(data=long_df, variables=dict(x="x", hue="a_cat")) + m = HueMapping(p) + assert m.levels == long_df["a_cat"].cat.categories.tolist() + assert m.map_type == "categorical" + + # Test numeric data with category type + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue="s_cat") + ) + m = HueMapping(p) + assert m.levels == categorical_order(long_df["s_cat"]) + assert m.map_type == "categorical" + assert m.cmap is None + + # Test categorical palette specified for numeric data + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue="s") + ) + palette = "deep" + levels = categorical_order(long_df["s"]) + expected_colors = color_palette(palette, n_colors=len(levels)) + expected_lookup_table = dict(zip(levels, expected_colors)) + m = HueMapping(p, palette=palette) + assert m.lookup_table == expected_lookup_table + assert m.map_type == "categorical" + + def test_hue_map_numeric(self, long_df): + + # Test default colormap + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue="s") + ) + hue_levels = list(np.sort(long_df["s"].unique())) + m = HueMapping(p) + assert m.levels == hue_levels + assert m.map_type == "numeric" + assert m.cmap.name == "seaborn_cubehelix" + + # Test named colormap + palette = "Purples" + m = HueMapping(p, palette=palette) + assert m.cmap is mpl.cm.get_cmap(palette) + + # Test colormap object + palette = mpl.cm.get_cmap("Greens") + m = HueMapping(p, palette=palette) + assert m.cmap is mpl.cm.get_cmap(palette) + + # Test cubehelix shorthand + palette = "ch:2,0,light=.2" + m = HueMapping(p, palette=palette) + assert isinstance(m.cmap, mpl.colors.ListedColormap) + + # Test specified hue limits + hue_norm = 1, 4 + m = HueMapping(p, norm=hue_norm) + assert isinstance(m.norm, mpl.colors.Normalize) + assert m.norm.vmin == hue_norm[0] + assert m.norm.vmax == hue_norm[1] + + # Test Normalize object + hue_norm = mpl.colors.PowerNorm(2, vmin=1, vmax=10) + m = HueMapping(p, norm=hue_norm) + assert m.norm is hue_norm + + # Test default colormap values + hmin, hmax = p.plot_data["hue"].min(), p.plot_data["hue"].max() + m = HueMapping(p) + assert m.lookup_table[hmin] == pytest.approx(m.cmap(0.0)) + assert m.lookup_table[hmax] == pytest.approx(m.cmap(1.0)) + + # Test specified colormap values + hue_norm = hmin - 1, hmax - 1 + m = HueMapping(p, norm=hue_norm) + norm_min = (hmin - hue_norm[0]) / (hue_norm[1] - hue_norm[0]) + assert m.lookup_table[hmin] == pytest.approx(m.cmap(norm_min)) + assert m.lookup_table[hmax] == pytest.approx(m.cmap(1.0)) + + # Test list of colors + hue_levels = list(np.sort(long_df["s"].unique())) + palette = color_palette("Blues", len(hue_levels)) + m = HueMapping(p, palette=palette) + assert m.lookup_table == dict(zip(hue_levels, palette)) + + palette = color_palette("Blues", len(hue_levels) + 1) + with pytest.raises(ValueError): + HueMapping(p, palette=palette) + + # Test dictionary of colors + palette = dict(zip(hue_levels, color_palette("Reds"))) + m = HueMapping(p, palette=palette) + assert m.lookup_table == palette + + palette.pop(hue_levels[0]) + with pytest.raises(ValueError): + HueMapping(p, palette=palette) + + # Test invalid palette + with pytest.raises(ValueError): + HueMapping(p, palette="not a valid palette") + + # Test bad norm argument + with pytest.raises(ValueError): + HueMapping(p, norm="not a norm") + + +class TestSizeMapping: + + def test_init_from_map(self, long_df): + + p_orig = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", size="a") + ) + sizes = 1, 6 + p = SizeMapping.map(p_orig, sizes=sizes) + assert p is p_orig + assert isinstance(p._size_map, SizeMapping) + assert min(p._size_map.lookup_table.values()) == sizes[0] + assert max(p._size_map.lookup_table.values()) == sizes[1] + + def test_plotter_default_init(self, long_df): + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y"), + ) + assert isinstance(p._size_map, SizeMapping) + assert p._size_map.map_type is None + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", size="a"), + ) + assert isinstance(p._size_map, SizeMapping) + assert p._size_map.map_type == p.var_types["size"] + + def test_plotter_reinit(self, long_df): + + p_orig = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", size="a"), + ) + sizes = [1, 4, 2] + size_order = ["b", "a", "c"] + p = p_orig.map_size(sizes=sizes, order=size_order) + assert p is p_orig + assert p._size_map.lookup_table == dict(zip(size_order, sizes)) + assert p._size_map.levels == size_order + + def test_size_map_null(self, flat_series, null_series): + + p = VectorPlotter(variables=dict(x=flat_series, size=null_series)) + m = HueMapping(p) + assert m.levels is None + assert m.map_type is None + assert m.norm is None + assert m.lookup_table is None + + def test_map_size_numeric(self, long_df): + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", size="s"), + ) + + # Test default range of keys in the lookup table values + m = SizeMapping(p) + size_values = m.lookup_table.values() + value_range = min(size_values), max(size_values) + assert value_range == p._default_size_range + + # Test specified range of size values + sizes = 1, 5 + m = SizeMapping(p, sizes=sizes) + size_values = m.lookup_table.values() + assert min(size_values), max(size_values) == sizes + + # Test size values with normalization range + norm = 1, 10 + m = SizeMapping(p, sizes=sizes, norm=norm) + normalize = mpl.colors.Normalize(*norm, clip=True) + for key, val in m.lookup_table.items(): + assert val == sizes[0] + (sizes[1] - sizes[0]) * normalize(key) + + # Test size values with normalization object + norm = mpl.colors.LogNorm(1, 10, clip=False) + m = SizeMapping(p, sizes=sizes, norm=norm) + assert m.norm.clip + for key, val in m.lookup_table.items(): + assert val == sizes[0] + (sizes[1] - sizes[0]) * norm(key) + + # Test bad sizes argument + with pytest.raises(ValueError): + SizeMapping(p, sizes="bad_sizes") + + # Test bad sizes argument + with pytest.raises(ValueError): + SizeMapping(p, sizes=(1, 2, 3)) + + # Test bad norm argument + with pytest.raises(ValueError): + SizeMapping(p, norm="bad_norm") + + def test_map_size_categorical(self, long_df): + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", size="a"), + ) + + # Test specified size order + levels = p.plot_data["size"].unique() + sizes = [1, 4, 6] + order = [levels[1], levels[2], levels[0]] + m = SizeMapping(p, sizes=sizes, order=order) + assert m.lookup_table == dict(zip(order, sizes)) + + # Test list of sizes + order = categorical_order(p.plot_data["size"]) + sizes = list(np.random.rand(len(levels))) + m = SizeMapping(p, sizes=sizes) + assert m.lookup_table == dict(zip(order, sizes)) + + # Test dict of sizes + sizes = dict(zip(levels, np.random.rand(len(levels)))) + m = SizeMapping(p, sizes=sizes) + assert m.lookup_table == sizes + + # Test specified size range + sizes = (2, 5) + m = SizeMapping(p, sizes=sizes) + values = np.linspace(*sizes, len(m.levels))[::-1] + assert m.lookup_table == dict(zip(m.levels, values)) + + # Test explicit categories + p = VectorPlotter(data=long_df, variables=dict(x="x", size="a_cat")) + m = SizeMapping(p) + assert m.levels == long_df["a_cat"].cat.categories.tolist() + assert m.map_type == "categorical" + + # Test sizes list with wrong length + sizes = list(np.random.rand(len(levels) + 1)) + with pytest.raises(ValueError): + SizeMapping(p, sizes=sizes) + + # Test sizes dict with missing levels + sizes = dict(zip(levels, np.random.rand(len(levels) - 1))) + with pytest.raises(ValueError): + SizeMapping(p, sizes=sizes) + + # Test bad sizes argument + with pytest.raises(ValueError): + SizeMapping(p, sizes="bad_size") + + +class TestStyleMapping: + + def test_init_from_map(self, long_df): + + p_orig = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", style="a") + ) + markers = ["s", "p", "h"] + p = StyleMapping.map(p_orig, markers=markers) + assert p is p_orig + assert isinstance(p._style_map, StyleMapping) + assert p._style_map(p._style_map.levels, "marker") == markers + + def test_plotter_default_init(self, long_df): + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y"), + ) + assert isinstance(p._style_map, StyleMapping) + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", style="a"), + ) + assert isinstance(p._style_map, StyleMapping) + + def test_plotter_reinit(self, long_df): + + p_orig = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", style="a"), + ) + markers = ["s", "p", "h"] + style_order = ["b", "a", "c"] + p = p_orig.map_style(markers=markers, order=style_order) + assert p is p_orig + assert p._style_map.levels == style_order + assert p._style_map(style_order, "marker") == markers + + def test_style_map_null(self, flat_series, null_series): + + p = VectorPlotter(variables=dict(x=flat_series, style=null_series)) + m = HueMapping(p) + assert m.levels is None + assert m.map_type is None + assert m.lookup_table is None + + def test_map_style(self, long_df): + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", style="a"), + ) + + # Test defaults + m = StyleMapping(p, markers=True, dashes=True) + + n = len(m.levels) + for key, dashes in zip(m.levels, unique_dashes(n)): + assert m(key, "dashes") == dashes + + actual_marker_paths = { + k: mpl.markers.MarkerStyle(m(k, "marker")).get_path() + for k in m.levels + } + expected_marker_paths = { + k: mpl.markers.MarkerStyle(m).get_path() + for k, m in zip(m.levels, unique_markers(n)) + } + assert actual_marker_paths == expected_marker_paths + + # Test lists + markers, dashes = ["o", "s", "d"], [(1, 0), (1, 1), (2, 1, 3, 1)] + m = StyleMapping(p, markers=markers, dashes=dashes) + for key, mark, dash in zip(m.levels, markers, dashes): + assert m(key, "marker") == mark + assert m(key, "dashes") == dash + + # Test dicts + markers = dict(zip(p.plot_data["style"].unique(), markers)) + dashes = dict(zip(p.plot_data["style"].unique(), dashes)) + m = StyleMapping(p, markers=markers, dashes=dashes) + for key in m.levels: + assert m(key, "marker") == markers[key] + assert m(key, "dashes") == dashes[key] + + # Test excplicit categories + p = VectorPlotter(data=long_df, variables=dict(x="x", style="a_cat")) + m = StyleMapping(p) + assert m.levels == long_df["a_cat"].cat.categories.tolist() + + # Test style order with defaults + order = p.plot_data["style"].unique()[[1, 2, 0]] + m = StyleMapping(p, markers=True, dashes=True, order=order) + n = len(order) + for key, mark, dash in zip(order, unique_markers(n), unique_dashes(n)): + assert m(key, "dashes") == dash + assert m(key, "marker") == mark + obj = mpl.markers.MarkerStyle(mark) + path = obj.get_path().transformed(obj.get_transform()) + assert_array_equal(m(key, "path").vertices, path.vertices) + + # Test too many levels with style lists + with pytest.raises(ValueError): + StyleMapping(p, markers=["o", "s"], dashes=False) + + with pytest.raises(ValueError): + StyleMapping(p, markers=False, dashes=[(2, 1)]) + + # Test too many levels with style dicts + markers, dashes = {"a": "o", "b": "s"}, False + with pytest.raises(ValueError): + StyleMapping(p, markers=markers, dashes=dashes) + + markers, dashes = False, {"a": (1, 0), "b": (2, 1)} + with pytest.raises(ValueError): + StyleMapping(p, markers=markers, dashes=dashes) + + # Test mixture of filled and unfilled markers + markers, dashes = ["o", "x", "s"], None + with pytest.raises(ValueError): + StyleMapping(p, markers=markers, dashes=dashes) + + +class TestVectorPlotter: + + def test_flat_variables(self, flat_data): + + p = VectorPlotter() + p.assign_variables(data=flat_data) + assert p.input_format == "wide" + assert list(p.variables) == ["x", "y"] + assert len(p.plot_data) == len(flat_data) + + try: + expected_x = flat_data.index + expected_x_name = flat_data.index.name + except AttributeError: + expected_x = np.arange(len(flat_data)) + expected_x_name = None + + x = p.plot_data["x"] + assert_array_equal(x, expected_x) + + expected_y = flat_data + expected_y_name = getattr(flat_data, "name", None) + + y = p.plot_data["y"] + assert_array_equal(y, expected_y) + + assert p.variables["x"] == expected_x_name + assert p.variables["y"] == expected_y_name + + # TODO note that most of the other tests that exercise the core + # variable assignment code still live in test_relational + + @pytest.mark.parametrize("name", [3, 4.5]) + def test_long_numeric_name(self, long_df, name): + + long_df[name] = long_df["x"] + p = VectorPlotter() + p.assign_variables(data=long_df, variables={"x": name}) + assert_array_equal(p.plot_data["x"], long_df[name]) + assert p.variables["x"] == name + + def test_long_hierarchical_index(self, rng): + + cols = pd.MultiIndex.from_product([["a"], ["x", "y"]]) + data = rng.uniform(size=(50, 2)) + df = pd.DataFrame(data, columns=cols) + + name = ("a", "y") + var = "y" + + p = VectorPlotter() + p.assign_variables(data=df, variables={var: name}) + assert_array_equal(p.plot_data[var], df[name]) + assert p.variables[var] == name + + def test_long_scalar_and_data(self, long_df): + + val = 22 + p = VectorPlotter(data=long_df, variables={"x": "x", "y": val}) + assert (p.plot_data["y"] == val).all() + assert p.variables["y"] is None + + def test_wide_semantic_error(self, wide_df): + + err = "The following variable cannot be assigned with wide-form data: `hue`" + with pytest.raises(ValueError, match=err): + VectorPlotter(data=wide_df, variables={"hue": "a"}) + + def test_long_unknown_error(self, long_df): + + err = "Could not interpret value `what` for parameter `hue`" + with pytest.raises(ValueError, match=err): + VectorPlotter(data=long_df, variables={"x": "x", "hue": "what"}) + + def test_long_unmatched_size_error(self, long_df, flat_array): + + err = "Length of ndarray vectors must match length of `data`" + with pytest.raises(ValueError, match=err): + VectorPlotter(data=long_df, variables={"x": "x", "hue": flat_array}) + + def test_wide_categorical_columns(self, wide_df): + + wide_df.columns = pd.CategoricalIndex(wide_df.columns) + p = VectorPlotter(data=wide_df) + assert_array_equal(p.plot_data["hue"].unique(), ["a", "b", "c"]) + + def test_iter_data_quantitites(self, long_df): + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y"), + ) + out = p.iter_data("hue") + assert len(list(out)) == 1 + + var = "a" + n_subsets = len(long_df[var].unique()) + + semantics = ["hue", "size", "style"] + for semantic in semantics: + + p = VectorPlotter( + data=long_df, + variables={"x": "x", "y": "y", semantic: var}, + ) + out = p.iter_data(semantics) + assert len(list(out)) == n_subsets + + var = "a" + n_subsets = len(long_df[var].unique()) + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue=var, style=var), + ) + out = p.iter_data(semantics) + assert len(list(out)) == n_subsets + + # -- + + out = p.iter_data(semantics, reverse=True) + assert len(list(out)) == n_subsets + + # -- + + var1, var2 = "a", "s" + + n_subsets = len(long_df[var1].unique()) + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue=var1, style=var2), + ) + out = p.iter_data(["hue"]) + assert len(list(out)) == n_subsets + + n_subsets = len(set(list(map(tuple, long_df[[var1, var2]].values)))) + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue=var1, style=var2), + ) + out = p.iter_data(semantics) + assert len(list(out)) == n_subsets + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue=var1, size=var2, style=var1), + ) + out = p.iter_data(semantics) + assert len(list(out)) == n_subsets + + # -- + + var1, var2, var3 = "a", "s", "b" + cols = [var1, var2, var3] + n_subsets = len(set(list(map(tuple, long_df[cols].values)))) + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue=var1, size=var2, style=var3), + ) + out = p.iter_data(semantics) + assert len(list(out)) == n_subsets + + def test_iter_data_keys(self, long_df): + + semantics = ["hue", "size", "style"] + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y"), + ) + for sub_vars, _ in p.iter_data("hue"): + assert sub_vars == {} + + # -- + + var = "a" + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue=var), + ) + for sub_vars, _ in p.iter_data("hue"): + assert list(sub_vars) == ["hue"] + assert sub_vars["hue"] in long_df[var].values + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", size=var), + ) + for sub_vars, _ in p.iter_data("size"): + assert list(sub_vars) == ["size"] + assert sub_vars["size"] in long_df[var].values + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue=var, style=var), + ) + for sub_vars, _ in p.iter_data(semantics): + assert list(sub_vars) == ["hue", "style"] + assert sub_vars["hue"] in long_df[var].values + assert sub_vars["style"] in long_df[var].values + assert sub_vars["hue"] == sub_vars["style"] + + var1, var2 = "a", "s" + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue=var1, size=var2), + ) + for sub_vars, _ in p.iter_data(semantics): + assert list(sub_vars) == ["hue", "size"] + assert sub_vars["hue"] in long_df[var1].values + assert sub_vars["size"] in long_df[var2].values + + semantics = ["hue", "col", "row"] + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue=var1, col=var2), + ) + for sub_vars, _ in p.iter_data("hue"): + assert list(sub_vars) == ["hue", "col"] + assert sub_vars["hue"] in long_df[var1].values + assert sub_vars["col"] in long_df[var2].values + + def test_iter_data_values(self, long_df): + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y"), + ) + + p.sort = True + _, sub_data = next(p.iter_data("hue")) + assert_frame_equal(sub_data, p.plot_data) + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a"), + ) + + for sub_vars, sub_data in p.iter_data("hue"): + rows = p.plot_data["hue"] == sub_vars["hue"] + assert_frame_equal(sub_data, p.plot_data[rows]) + + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a", size="s"), + ) + for sub_vars, sub_data in p.iter_data(["hue", "size"]): + rows = p.plot_data["hue"] == sub_vars["hue"] + rows &= p.plot_data["size"] == sub_vars["size"] + assert_frame_equal(sub_data, p.plot_data[rows]) + + def test_iter_data_reverse(self, long_df): + + reversed_order = categorical_order(long_df["a"])[::-1] + p = VectorPlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a") + ) + iterator = p.iter_data("hue", reverse=True) + for i, (sub_vars, _) in enumerate(iterator): + assert sub_vars["hue"] == reversed_order[i] + + def test_axis_labels(self, long_df): + + f, ax = plt.subplots() + + p = VectorPlotter(data=long_df, variables=dict(x="a")) + + p._add_axis_labels(ax) + assert ax.get_xlabel() == "a" + assert ax.get_ylabel() == "" + ax.clear() + + p = VectorPlotter(data=long_df, variables=dict(y="a")) + p._add_axis_labels(ax) + assert ax.get_xlabel() == "" + assert ax.get_ylabel() == "a" + ax.clear() + + p = VectorPlotter(data=long_df, variables=dict(x="a")) + + p._add_axis_labels(ax, default_y="default") + assert ax.get_xlabel() == "a" + assert ax.get_ylabel() == "default" + ax.clear() + + p = VectorPlotter(data=long_df, variables=dict(y="a")) + p._add_axis_labels(ax, default_x="default", default_y="default") + assert ax.get_xlabel() == "default" + assert ax.get_ylabel() == "a" + ax.clear() + + p = VectorPlotter(data=long_df, variables=dict(x="x", y="a")) + ax.set(xlabel="existing", ylabel="also existing") + p._add_axis_labels(ax) + assert ax.get_xlabel() == "existing" + assert ax.get_ylabel() == "also existing" + + f, (ax1, ax2) = plt.subplots(1, 2, sharey=True) + p = VectorPlotter(data=long_df, variables=dict(x="x", y="y")) + + p._add_axis_labels(ax1) + p._add_axis_labels(ax2) + + assert ax1.get_xlabel() == "x" + assert ax1.get_ylabel() == "y" + assert ax1.yaxis.label.get_visible() + + assert ax2.get_xlabel() == "x" + assert ax2.get_ylabel() == "y" + assert not ax2.yaxis.label.get_visible() + + @pytest.mark.parametrize( + "variables", + [ + dict(x="x", y="y"), + dict(x="x"), + dict(y="y"), + dict(x="t", y="y"), + dict(x="x", y="a"), + ] + ) + def test_attach_basics(self, long_df, variables): + + _, ax = plt.subplots() + p = VectorPlotter(data=long_df, variables=variables) + p._attach(ax) + assert p.ax is ax + + def test_attach_disallowed(self, long_df): + + _, ax = plt.subplots() + p = VectorPlotter(data=long_df, variables={"x": "a"}) + + with pytest.raises(TypeError): + p._attach(ax, allowed_types="numeric") + + with pytest.raises(TypeError): + p._attach(ax, allowed_types=["datetime", "numeric"]) + + _, ax = plt.subplots() + p = VectorPlotter(data=long_df, variables={"x": "x"}) + + with pytest.raises(TypeError): + p._attach(ax, allowed_types="categorical") + + _, ax = plt.subplots() + p = VectorPlotter(data=long_df, variables={"x": "x", "y": "t"}) + + with pytest.raises(TypeError): + p._attach(ax, allowed_types=["numeric", "categorical"]) + + def test_attach_log_scale(self, long_df): + + _, ax = plt.subplots() + p = VectorPlotter(data=long_df, variables={"x": "x"}) + p._attach(ax, log_scale=True) + assert ax.xaxis.get_scale() == "log" + assert ax.yaxis.get_scale() == "linear" + assert p._log_scaled("x") + assert not p._log_scaled("y") + + _, ax = plt.subplots() + p = VectorPlotter(data=long_df, variables={"x": "x"}) + p._attach(ax, log_scale=2) + assert ax.xaxis.get_scale() == "log" + assert ax.yaxis.get_scale() == "linear" + assert p._log_scaled("x") + assert not p._log_scaled("y") + + _, ax = plt.subplots() + p = VectorPlotter(data=long_df, variables={"y": "y"}) + p._attach(ax, log_scale=True) + assert ax.xaxis.get_scale() == "linear" + assert ax.yaxis.get_scale() == "log" + assert not p._log_scaled("x") + assert p._log_scaled("y") + + _, ax = plt.subplots() + p = VectorPlotter(data=long_df, variables={"x": "x", "y": "y"}) + p._attach(ax, log_scale=True) + assert ax.xaxis.get_scale() == "log" + assert ax.yaxis.get_scale() == "log" + assert p._log_scaled("x") + assert p._log_scaled("y") + + _, ax = plt.subplots() + p = VectorPlotter(data=long_df, variables={"x": "x", "y": "y"}) + p._attach(ax, log_scale=(True, False)) + assert ax.xaxis.get_scale() == "log" + assert ax.yaxis.get_scale() == "linear" + assert p._log_scaled("x") + assert not p._log_scaled("y") + + _, ax = plt.subplots() + p = VectorPlotter(data=long_df, variables={"x": "x", "y": "y"}) + p._attach(ax, log_scale=(False, 2)) + assert ax.xaxis.get_scale() == "linear" + assert ax.yaxis.get_scale() == "log" + assert not p._log_scaled("x") + assert p._log_scaled("y") + + def test_attach_converters(self, long_df): + + _, ax = plt.subplots() + p = VectorPlotter(data=long_df, variables={"x": "x", "y": "t"}) + p._attach(ax) + assert ax.xaxis.converter is None + assert isinstance(ax.yaxis.converter, mpl.dates.DateConverter) + + _, ax = plt.subplots() + p = VectorPlotter(data=long_df, variables={"x": "a", "y": "y"}) + p._attach(ax) + assert isinstance(ax.xaxis.converter, mpl.category.StrCategoryConverter) + assert ax.yaxis.converter is None + + def test_attach_facets(self, long_df): + + g = FacetGrid(long_df, col="a") + p = VectorPlotter(data=long_df, variables={"x": "x", "col": "a"}) + p._attach(g) + assert p.ax is None + assert p.facets == g + + def test_get_axes_single(self, long_df): + + ax = plt.figure().subplots() + p = VectorPlotter(data=long_df, variables={"x": "x", "hue": "a"}) + p._attach(ax) + assert p._get_axes({"hue": "a"}) is ax + + def test_get_axes_facets(self, long_df): + + g = FacetGrid(long_df, col="a") + p = VectorPlotter(data=long_df, variables={"x": "x", "col": "a"}) + p._attach(g) + assert p._get_axes({"col": "b"}) is g.axes_dict["b"] + + g = FacetGrid(long_df, col="a", row="c") + p = VectorPlotter( + data=long_df, variables={"x": "x", "col": "a", "row": "c"} + ) + p._attach(g) + assert p._get_axes({"row": 1, "col": "b"}) is g.axes_dict[(1, "b")] + + def test_comp_data(self, long_df): + + p = VectorPlotter(data=long_df, variables={"x": "x", "y": "t"}) + + # We have disabled this check for now, while it remains part of + # the internal API, because it will require updating a number of tests + # with pytest.raises(AttributeError): + # p.comp_data + + _, ax = plt.subplots() + p._attach(ax) + + assert_array_equal(p.comp_data["x"], p.plot_data["x"]) + assert_array_equal( + p.comp_data["y"], ax.yaxis.convert_units(p.plot_data["y"]) + ) + + p = VectorPlotter(data=long_df, variables={"x": "a"}) + + _, ax = plt.subplots() + p._attach(ax) + + assert_array_equal( + p.comp_data["x"], ax.xaxis.convert_units(p.plot_data["x"]) + ) + + def test_comp_data_log(self, long_df): + + p = VectorPlotter(data=long_df, variables={"x": "z", "y": "y"}) + _, ax = plt.subplots() + p._attach(ax, log_scale=(True, False)) + + assert_array_equal( + p.comp_data["x"], np.log10(p.plot_data["x"]) + ) + assert_array_equal(p.comp_data["y"], p.plot_data["y"]) + + def test_comp_data_category_order(self): + + s = (pd.Series(["a", "b", "c", "a"], dtype="category") + .cat.set_categories(["b", "c", "a"], ordered=True)) + + p = VectorPlotter(variables={"x": s}) + _, ax = plt.subplots() + p._attach(ax) + assert_array_equal( + p.comp_data["x"], + [2, 0, 1, 2], + ) + + @pytest.fixture( + params=itertools.product( + [None, np.nan, PD_NA], + ["numeric", "category", "datetime"] + ) + ) + @pytest.mark.parametrize( + "NA,var_type", + ) + def comp_data_missing_fixture(self, request): + + # This fixture holds the logic for parametrizing + # the following test (test_comp_data_missing) + + NA, var_type = request.param + + if NA is None: + pytest.skip("No pandas.NA available") + + comp_data = [0, 1, np.nan, 2, np.nan, 1] + if var_type == "numeric": + orig_data = [0, 1, NA, 2, np.inf, 1] + elif var_type == "category": + orig_data = ["a", "b", NA, "c", NA, "b"] + elif var_type == "datetime": + # Use 1-based numbers to avoid issue on matplotlib<3.2 + # Could simplify the test a bit when we roll off that version + comp_data = [1, 2, np.nan, 3, np.nan, 2] + numbers = [1, 2, 3, 2] + + orig_data = mpl.dates.num2date(numbers) + orig_data.insert(2, NA) + orig_data.insert(4, np.inf) + + return orig_data, comp_data + + def test_comp_data_missing(self, comp_data_missing_fixture): + + orig_data, comp_data = comp_data_missing_fixture + p = VectorPlotter(variables={"x": orig_data}) + ax = plt.figure().subplots() + p._attach(ax) + assert_array_equal(p.comp_data["x"], comp_data) + + def test_var_order(self, long_df): + + order = ["c", "b", "a"] + for var in ["hue", "size", "style"]: + p = VectorPlotter(data=long_df, variables={"x": "x", var: "a"}) + + mapper = getattr(p, f"map_{var}") + mapper(order=order) + + assert p.var_levels[var] == order + + +class TestCoreFunc: + + def test_unique_dashes(self): + + n = 24 + dashes = unique_dashes(n) + + assert len(dashes) == n + assert len(set(dashes)) == n + assert dashes[0] == "" + for spec in dashes[1:]: + assert isinstance(spec, tuple) + assert not len(spec) % 2 + + def test_unique_markers(self): + + n = 24 + markers = unique_markers(n) + + assert len(markers) == n + assert len(set(markers)) == n + for m in markers: + assert mpl.markers.MarkerStyle(m).is_filled() + + def test_variable_type(self): + + s = pd.Series([1., 2., 3.]) + assert variable_type(s) == "numeric" + assert variable_type(s.astype(int)) == "numeric" + assert variable_type(s.astype(object)) == "numeric" + # assert variable_type(s.to_numpy()) == "numeric" + assert variable_type(s.values) == "numeric" + # assert variable_type(s.to_list()) == "numeric" + assert variable_type(s.tolist()) == "numeric" + + s = pd.Series([1, 2, 3, np.nan], dtype=object) + assert variable_type(s) == "numeric" + + s = pd.Series([np.nan, np.nan]) + # s = pd.Series([pd.NA, pd.NA]) + assert variable_type(s) == "numeric" + + s = pd.Series(["1", "2", "3"]) + assert variable_type(s) == "categorical" + # assert variable_type(s.to_numpy()) == "categorical" + assert variable_type(s.values) == "categorical" + # assert variable_type(s.to_list()) == "categorical" + assert variable_type(s.tolist()) == "categorical" + + s = pd.Series([True, False, False]) + assert variable_type(s) == "numeric" + assert variable_type(s, boolean_type="categorical") == "categorical" + s_cat = s.astype("category") + assert variable_type(s_cat, boolean_type="categorical") == "categorical" + assert variable_type(s_cat, boolean_type="numeric") == "categorical" + + s = pd.Series([pd.Timestamp(1), pd.Timestamp(2)]) + assert variable_type(s) == "datetime" + assert variable_type(s.astype(object)) == "datetime" + # assert variable_type(s.to_numpy()) == "datetime" + assert variable_type(s.values) == "datetime" + # assert variable_type(s.to_list()) == "datetime" + assert variable_type(s.tolist()) == "datetime" + + def test_infer_orient(self): + + nums = pd.Series(np.arange(6)) + cats = pd.Series(["a", "b"] * 3) + + assert infer_orient(cats, nums) == "v" + assert infer_orient(nums, cats) == "h" + + assert infer_orient(nums, None) == "h" + with pytest.warns(UserWarning, match="Vertical .+ `x`"): + assert infer_orient(nums, None, "v") == "h" + + assert infer_orient(None, nums) == "v" + with pytest.warns(UserWarning, match="Horizontal .+ `y`"): + assert infer_orient(None, nums, "h") == "v" + + infer_orient(cats, None, require_numeric=False) == "h" + with pytest.raises(TypeError, match="Horizontal .+ `x`"): + infer_orient(cats, None) + + infer_orient(cats, None, require_numeric=False) == "v" + with pytest.raises(TypeError, match="Vertical .+ `y`"): + infer_orient(None, cats) + + assert infer_orient(nums, nums, "vert") == "v" + assert infer_orient(nums, nums, "hori") == "h" + + assert infer_orient(cats, cats, "h", require_numeric=False) == "h" + assert infer_orient(cats, cats, "v", require_numeric=False) == "v" + assert infer_orient(cats, cats, require_numeric=False) == "v" + + with pytest.raises(TypeError, match="Vertical .+ `y`"): + infer_orient(cats, cats, "v") + with pytest.raises(TypeError, match="Horizontal .+ `x`"): + infer_orient(cats, cats, "h") + with pytest.raises(TypeError, match="Neither"): + infer_orient(cats, cats) + + def test_categorical_order(self): + + x = ["a", "c", "c", "b", "a", "d"] + y = [3, 2, 5, 1, 4] + order = ["a", "b", "c", "d"] + + out = categorical_order(x) + assert out == ["a", "c", "b", "d"] + + out = categorical_order(x, order) + assert out == order + + out = categorical_order(x, ["b", "a"]) + assert out == ["b", "a"] + + out = categorical_order(np.array(x)) + assert out == ["a", "c", "b", "d"] + + out = categorical_order(pd.Series(x)) + assert out == ["a", "c", "b", "d"] + + out = categorical_order(y) + assert out == [1, 2, 3, 4, 5] + + out = categorical_order(np.array(y)) + assert out == [1, 2, 3, 4, 5] + + out = categorical_order(pd.Series(y)) + assert out == [1, 2, 3, 4, 5] + + x = pd.Categorical(x, order) + out = categorical_order(x) + assert out == list(x.categories) + + x = pd.Series(x) + out = categorical_order(x) + assert out == list(x.cat.categories) + + out = categorical_order(x, ["b", "a"]) + assert out == ["b", "a"] + + x = ["a", np.nan, "c", "c", "b", "a", "d"] + out = categorical_order(x) + assert out == ["a", "c", "b", "d"] diff --git a/grplot_seaborn/tests/test_decorators.py b/grplot_seaborn/tests/test_decorators.py new file mode 100644 index 0000000..ab9ebad --- /dev/null +++ b/grplot_seaborn/tests/test_decorators.py @@ -0,0 +1,108 @@ +import inspect +import pytest +from .._decorators import ( + _deprecate_positional_args, + share_init_params_with_map, +) + + +# This test was adapted from scikit-learn +# github.com/scikit-learn/scikit-learn/blob/master/sklearn/utils/tests/test_validation.py +def test_deprecate_positional_args_warns_for_function(): + + @_deprecate_positional_args + def f1(a, b, *, c=1, d=1): + return a, b, c, d + + with pytest.warns( + FutureWarning, + match=r"Pass the following variable as a keyword arg: c\." + ): + assert f1(1, 2, 3) == (1, 2, 3, 1) + + with pytest.warns( + FutureWarning, + match=r"Pass the following variables as keyword args: c, d\." + ): + assert f1(1, 2, 3, 4) == (1, 2, 3, 4) + + @_deprecate_positional_args + def f2(a=1, *, b=1, c=1, d=1): + return a, b, c, d + + with pytest.warns( + FutureWarning, + match=r"Pass the following variable as a keyword arg: b\.", + ): + assert f2(1, 2) == (1, 2, 1, 1) + + # The * is placed before a keyword only argument without a default value + @_deprecate_positional_args + def f3(a, *, b, c=1, d=1): + return a, b, c, d + + with pytest.warns( + FutureWarning, + match=r"Pass the following variable as a keyword arg: b\.", + ): + assert f3(1, 2) == (1, 2, 1, 1) + + +def test_deprecate_positional_args_warns_for_class(): + + class A1: + @_deprecate_positional_args + def __init__(self, a, b, *, c=1, d=1): + self.a = a, b, c, d + + with pytest.warns( + FutureWarning, + match=r"Pass the following variable as a keyword arg: c\." + ): + assert A1(1, 2, 3).a == (1, 2, 3, 1) + + with pytest.warns( + FutureWarning, + match=r"Pass the following variables as keyword args: c, d\." + ): + assert A1(1, 2, 3, 4).a == (1, 2, 3, 4) + + class A2: + @_deprecate_positional_args + def __init__(self, a=1, b=1, *, c=1, d=1): + self.a = a, b, c, d + + with pytest.warns( + FutureWarning, + match=r"Pass the following variable as a keyword arg: c\.", + ): + assert A2(1, 2, 3).a == (1, 2, 3, 1) + + with pytest.warns( + FutureWarning, + match=r"Pass the following variables as keyword args: c, d\.", + ): + assert A2(1, 2, 3, 4).a == (1, 2, 3, 4) + + +def test_share_init_params_with_map(): + + @share_init_params_with_map + class Thingie: + + def map(cls, *args, **kwargs): + return cls(*args, **kwargs) + + def __init__(self, a, b=1): + """Make a new thingie.""" + self.a = a + self.b = b + + thingie = Thingie.map(1, b=2) + assert thingie.a == 1 + assert thingie.b == 2 + + assert "a" in inspect.signature(Thingie.map).parameters + assert "b" in inspect.signature(Thingie.map).parameters + + assert Thingie.map.__doc__ == Thingie.__init__.__doc__ diff --git a/grplot_seaborn/tests/test_distributions.py b/grplot_seaborn/tests/test_distributions.py new file mode 100644 index 0000000..737d6cc --- /dev/null +++ b/grplot_seaborn/tests/test_distributions.py @@ -0,0 +1,2284 @@ +import itertools +from distutils.version import LooseVersion + +import numpy as np +import matplotlib as mpl +import matplotlib.pyplot as plt +from matplotlib.colors import to_rgb, to_rgba +import scipy +from scipy import stats, integrate + +import pytest +from numpy.testing import assert_array_equal, assert_array_almost_equal + +from .. import distributions as dist +from ..palettes import ( + color_palette, + light_palette, +) +from .._core import ( + categorical_order, +) +from .._statistics import ( + KDE, + Histogram, +) +from ..distributions import ( + _DistributionPlotter, + displot, + distplot, + histplot, + ecdfplot, + kdeplot, + rugplot, +) +from ..axisgrid import FacetGrid +from .._testing import ( + assert_plots_equal, + assert_legends_equal, +) + + +class TestDistPlot(object): + + rs = np.random.RandomState(0) + x = rs.randn(100) + + def test_hist_bins(self): + + fd_edges = np.histogram_bin_edges(self.x, "fd") + with pytest.warns(FutureWarning): + ax = distplot(self.x) + for edge, bar in zip(fd_edges, ax.patches): + assert pytest.approx(edge) == bar.get_x() + + plt.close(ax.figure) + n = 25 + n_edges = np.histogram_bin_edges(self.x, n) + with pytest.warns(FutureWarning): + ax = distplot(self.x, bins=n) + for edge, bar in zip(n_edges, ax.patches): + assert pytest.approx(edge) == bar.get_x() + + def test_elements(self): + + with pytest.warns(FutureWarning): + + n = 10 + ax = distplot(self.x, bins=n, + hist=True, kde=False, rug=False, fit=None) + assert len(ax.patches) == 10 + assert len(ax.lines) == 0 + assert len(ax.collections) == 0 + + plt.close(ax.figure) + ax = distplot(self.x, + hist=False, kde=True, rug=False, fit=None) + assert len(ax.patches) == 0 + assert len(ax.lines) == 1 + assert len(ax.collections) == 0 + + plt.close(ax.figure) + ax = distplot(self.x, + hist=False, kde=False, rug=True, fit=None) + assert len(ax.patches) == 0 + assert len(ax.lines) == 0 + assert len(ax.collections) == 1 + + plt.close(ax.figure) + ax = distplot(self.x, + hist=False, kde=False, rug=False, fit=stats.norm) + assert len(ax.patches) == 0 + assert len(ax.lines) == 1 + assert len(ax.collections) == 0 + + def test_distplot_with_nans(self): + + f, (ax1, ax2) = plt.subplots(2) + x_null = np.append(self.x, [np.nan]) + + with pytest.warns(FutureWarning): + distplot(self.x, ax=ax1) + distplot(x_null, ax=ax2) + + line1 = ax1.lines[0] + line2 = ax2.lines[0] + assert np.array_equal(line1.get_xydata(), line2.get_xydata()) + + for bar1, bar2 in zip(ax1.patches, ax2.patches): + assert bar1.get_xy() == bar2.get_xy() + assert bar1.get_height() == bar2.get_height() + + +class TestRugPlot: + + def assert_rug_equal(self, a, b): + + assert_array_equal(a.get_segments(), b.get_segments()) + + @pytest.mark.parametrize("variable", ["x", "y"]) + def test_long_data(self, long_df, variable): + + vector = long_df[variable] + vectors = [ + variable, vector, np.asarray(vector), vector.tolist(), + ] + + f, ax = plt.subplots() + for vector in vectors: + rugplot(data=long_df, **{variable: vector}) + + for a, b in itertools.product(ax.collections, ax.collections): + self.assert_rug_equal(a, b) + + def test_bivariate_data(self, long_df): + + f, (ax1, ax2) = plt.subplots(ncols=2) + + rugplot(data=long_df, x="x", y="y", ax=ax1) + rugplot(data=long_df, x="x", ax=ax2) + rugplot(data=long_df, y="y", ax=ax2) + + self.assert_rug_equal(ax1.collections[0], ax2.collections[0]) + self.assert_rug_equal(ax1.collections[1], ax2.collections[1]) + + def test_wide_vs_long_data(self, wide_df): + + f, (ax1, ax2) = plt.subplots(ncols=2) + rugplot(data=wide_df, ax=ax1) + for col in wide_df: + rugplot(data=wide_df, x=col, ax=ax2) + + wide_segments = np.sort( + np.array(ax1.collections[0].get_segments()) + ) + long_segments = np.sort( + np.concatenate([c.get_segments() for c in ax2.collections]) + ) + + assert_array_equal(wide_segments, long_segments) + + def test_flat_vector(self, long_df): + + f, ax = plt.subplots() + rugplot(data=long_df["x"]) + rugplot(x=long_df["x"]) + self.assert_rug_equal(*ax.collections) + + def test_datetime_data(self, long_df): + + ax = rugplot(data=long_df["t"]) + vals = np.stack(ax.collections[0].get_segments())[:, 0, 0] + assert_array_equal(vals, mpl.dates.date2num(long_df["t"])) + + def test_empty_data(self): + + ax = rugplot(x=[]) + assert not ax.collections + + def test_a_deprecation(self, flat_series): + + f, ax = plt.subplots() + + with pytest.warns(FutureWarning): + rugplot(a=flat_series) + rugplot(x=flat_series) + + self.assert_rug_equal(*ax.collections) + + @pytest.mark.parametrize("variable", ["x", "y"]) + def test_axis_deprecation(self, flat_series, variable): + + f, ax = plt.subplots() + + with pytest.warns(FutureWarning): + rugplot(flat_series, axis=variable) + rugplot(**{variable: flat_series}) + + self.assert_rug_equal(*ax.collections) + + def test_vertical_deprecation(self, flat_series): + + f, ax = plt.subplots() + + with pytest.warns(FutureWarning): + rugplot(flat_series, vertical=True) + rugplot(y=flat_series) + + self.assert_rug_equal(*ax.collections) + + def test_rug_data(self, flat_array): + + height = .05 + ax = rugplot(x=flat_array, height=height) + segments = np.stack(ax.collections[0].get_segments()) + + n = flat_array.size + assert_array_equal(segments[:, 0, 1], np.zeros(n)) + assert_array_equal(segments[:, 1, 1], np.full(n, height)) + assert_array_equal(segments[:, 1, 0], flat_array) + + def test_rug_colors(self, long_df): + + ax = rugplot(data=long_df, x="x", hue="a") + + order = categorical_order(long_df["a"]) + palette = color_palette() + + expected_colors = np.ones((len(long_df), 4)) + for i, val in enumerate(long_df["a"]): + expected_colors[i, :3] = palette[order.index(val)] + + assert_array_equal(ax.collections[0].get_color(), expected_colors) + + def test_expand_margins(self, flat_array): + + f, ax = plt.subplots() + x1, y1 = ax.margins() + rugplot(x=flat_array, expand_margins=False) + x2, y2 = ax.margins() + assert x1 == x2 + assert y1 == y2 + + f, ax = plt.subplots() + x1, y1 = ax.margins() + height = .05 + rugplot(x=flat_array, height=height) + x2, y2 = ax.margins() + assert x1 == x2 + assert y1 + height * 2 == pytest.approx(y2) + + def test_matplotlib_kwargs(self, flat_series): + + lw = 2 + alpha = .2 + ax = rugplot(y=flat_series, linewidth=lw, alpha=alpha) + rug = ax.collections[0] + assert np.all(rug.get_alpha() == alpha) + assert np.all(rug.get_linewidth() == lw) + + def test_axis_labels(self, flat_series): + + ax = rugplot(x=flat_series) + assert ax.get_xlabel() == flat_series.name + assert not ax.get_ylabel() + + def test_log_scale(self, long_df): + + ax1, ax2 = plt.figure().subplots(2) + + ax2.set_xscale("log") + + rugplot(data=long_df, x="z", ax=ax1) + rugplot(data=long_df, x="z", ax=ax2) + + rug1 = np.stack(ax1.collections[0].get_segments()) + rug2 = np.stack(ax2.collections[0].get_segments()) + + assert_array_almost_equal(rug1, rug2) + + +class TestKDEPlotUnivariate: + + @pytest.mark.parametrize( + "variable", ["x", "y"], + ) + def test_long_vectors(self, long_df, variable): + + vector = long_df[variable] + vectors = [ + variable, vector, np.asarray(vector), vector.tolist(), + ] + + f, ax = plt.subplots() + for vector in vectors: + kdeplot(data=long_df, **{variable: vector}) + + xdata = [l.get_xdata() for l in ax.lines] + for a, b in itertools.product(xdata, xdata): + assert_array_equal(a, b) + + ydata = [l.get_ydata() for l in ax.lines] + for a, b in itertools.product(ydata, ydata): + assert_array_equal(a, b) + + def test_wide_vs_long_data(self, wide_df): + + f, (ax1, ax2) = plt.subplots(ncols=2) + kdeplot(data=wide_df, ax=ax1, common_norm=False, common_grid=False) + for col in wide_df: + kdeplot(data=wide_df, x=col, ax=ax2) + + for l1, l2 in zip(ax1.lines[::-1], ax2.lines): + assert_array_equal(l1.get_xydata(), l2.get_xydata()) + + def test_flat_vector(self, long_df): + + f, ax = plt.subplots() + kdeplot(data=long_df["x"]) + kdeplot(x=long_df["x"]) + assert_array_equal(ax.lines[0].get_xydata(), ax.lines[1].get_xydata()) + + def test_empty_data(self): + + ax = kdeplot(x=[]) + assert not ax.lines + + def test_singular_data(self): + + with pytest.warns(UserWarning): + ax = kdeplot(x=np.ones(10)) + assert not ax.lines + + with pytest.warns(UserWarning): + ax = kdeplot(x=[5]) + assert not ax.lines + + with pytest.warns(None) as record: + ax = kdeplot(x=[5], warn_singular=False) + assert not record + + def test_variable_assignment(self, long_df): + + f, ax = plt.subplots() + kdeplot(data=long_df, x="x", fill=True) + kdeplot(data=long_df, y="x", fill=True) + + v0 = ax.collections[0].get_paths()[0].vertices + v1 = ax.collections[1].get_paths()[0].vertices[:, [1, 0]] + + assert_array_equal(v0, v1) + + def test_vertical_deprecation(self, long_df): + + f, ax = plt.subplots() + kdeplot(data=long_df, y="x") + + with pytest.warns(FutureWarning): + kdeplot(data=long_df, x="x", vertical=True) + + assert_array_equal(ax.lines[0].get_xydata(), ax.lines[1].get_xydata()) + + def test_bw_deprecation(self, long_df): + + f, ax = plt.subplots() + kdeplot(data=long_df, x="x", bw_method="silverman") + + with pytest.warns(FutureWarning): + kdeplot(data=long_df, x="x", bw="silverman") + + assert_array_equal(ax.lines[0].get_xydata(), ax.lines[1].get_xydata()) + + def test_kernel_deprecation(self, long_df): + + f, ax = plt.subplots() + kdeplot(data=long_df, x="x") + + with pytest.warns(UserWarning): + kdeplot(data=long_df, x="x", kernel="epi") + + assert_array_equal(ax.lines[0].get_xydata(), ax.lines[1].get_xydata()) + + def test_shade_deprecation(self, long_df): + + f, ax = plt.subplots() + kdeplot(data=long_df, x="x", shade=True) + kdeplot(data=long_df, x="x", fill=True) + fill1, fill2 = ax.collections + assert_array_equal( + fill1.get_paths()[0].vertices, fill2.get_paths()[0].vertices + ) + + @pytest.mark.parametrize("multiple", ["layer", "stack", "fill"]) + def test_hue_colors(self, long_df, multiple): + + ax = kdeplot( + data=long_df, x="x", hue="a", + multiple=multiple, + fill=True, legend=False + ) + + # Note that hue order is reversed in the plot + lines = ax.lines[::-1] + fills = ax.collections[::-1] + + palette = color_palette() + + for line, fill, color in zip(lines, fills, palette): + assert line.get_color() == color + assert tuple(fill.get_facecolor().squeeze()) == color + (.25,) + + def test_hue_stacking(self, long_df): + + f, (ax1, ax2) = plt.subplots(ncols=2) + + kdeplot( + data=long_df, x="x", hue="a", + multiple="layer", common_grid=True, + legend=False, ax=ax1, + ) + kdeplot( + data=long_df, x="x", hue="a", + multiple="stack", fill=False, + legend=False, ax=ax2, + ) + + layered_densities = np.stack([ + l.get_ydata() for l in ax1.lines + ]) + stacked_densities = np.stack([ + l.get_ydata() for l in ax2.lines + ]) + + assert_array_equal(layered_densities.cumsum(axis=0), stacked_densities) + + def test_hue_filling(self, long_df): + + f, (ax1, ax2) = plt.subplots(ncols=2) + + kdeplot( + data=long_df, x="x", hue="a", + multiple="layer", common_grid=True, + legend=False, ax=ax1, + ) + kdeplot( + data=long_df, x="x", hue="a", + multiple="fill", fill=False, + legend=False, ax=ax2, + ) + + layered = np.stack([l.get_ydata() for l in ax1.lines]) + filled = np.stack([l.get_ydata() for l in ax2.lines]) + + assert_array_almost_equal( + (layered / layered.sum(axis=0)).cumsum(axis=0), + filled, + ) + + @pytest.mark.parametrize("multiple", ["stack", "fill"]) + def test_fill_default(self, long_df, multiple): + + ax = kdeplot( + data=long_df, x="x", hue="a", multiple=multiple, fill=None + ) + + assert len(ax.collections) > 0 + + @pytest.mark.parametrize("multiple", ["layer", "stack", "fill"]) + def test_fill_nondefault(self, long_df, multiple): + + f, (ax1, ax2) = plt.subplots(ncols=2) + + kws = dict(data=long_df, x="x", hue="a") + kdeplot(**kws, multiple=multiple, fill=False, ax=ax1) + kdeplot(**kws, multiple=multiple, fill=True, ax=ax2) + + assert len(ax1.collections) == 0 + assert len(ax2.collections) > 0 + + def test_color_cycle_interaction(self, flat_series): + + color = (.2, 1, .6) + C0, C1 = to_rgb("C0"), to_rgb("C1") + + f, ax = plt.subplots() + kdeplot(flat_series) + kdeplot(flat_series) + assert to_rgb(ax.lines[0].get_color()) == C0 + assert to_rgb(ax.lines[1].get_color()) == C1 + plt.close(f) + + f, ax = plt.subplots() + kdeplot(flat_series, color=color) + kdeplot(flat_series) + assert to_rgb(ax.lines[0].get_color()) == color + assert to_rgb(ax.lines[1].get_color()) == C0 + plt.close(f) + + f, ax = plt.subplots() + kdeplot(flat_series, fill=True) + kdeplot(flat_series, fill=True) + assert ( + to_rgba(ax.collections[0].get_facecolor().squeeze()) + == to_rgba(C0, .25) + ) + assert ( + to_rgba(ax.collections[1].get_facecolor().squeeze()) + == to_rgba(C1, .25) + ) + plt.close(f) + + @pytest.mark.parametrize("fill", [True, False]) + def test_color(self, long_df, fill): + + color = (.2, 1, .6) + alpha = .5 + + f, ax = plt.subplots() + + kdeplot(long_df["x"], fill=fill, color=color) + if fill: + artist_color = ax.collections[-1].get_facecolor().squeeze() + else: + artist_color = ax.lines[-1].get_color() + default_alpha = .25 if fill else 1 + assert to_rgba(artist_color) == to_rgba(color, default_alpha) + + kdeplot(long_df["x"], fill=fill, color=color, alpha=alpha) + if fill: + artist_color = ax.collections[-1].get_facecolor().squeeze() + else: + artist_color = ax.lines[-1].get_color() + assert to_rgba(artist_color) == to_rgba(color, alpha) + + @pytest.mark.skipif( + LooseVersion(np.__version__) < "1.17", + reason="Histogram over datetime64 requires numpy >= 1.17", + ) + def test_datetime_scale(self, long_df): + + f, (ax1, ax2) = plt.subplots(2) + kdeplot(x=long_df["t"], fill=True, ax=ax1) + kdeplot(x=long_df["t"], fill=False, ax=ax2) + assert ax1.get_xlim() == ax2.get_xlim() + + def test_multiple_argument_check(self, long_df): + + with pytest.raises(ValueError, match="`multiple` must be"): + kdeplot(data=long_df, x="x", hue="a", multiple="bad_input") + + def test_cut(self, rng): + + x = rng.normal(0, 3, 1000) + + f, ax = plt.subplots() + kdeplot(x=x, cut=0, legend=False) + + xdata_0 = ax.lines[0].get_xdata() + assert xdata_0.min() == x.min() + assert xdata_0.max() == x.max() + + kdeplot(x=x, cut=2, legend=False) + + xdata_2 = ax.lines[1].get_xdata() + assert xdata_2.min() < xdata_0.min() + assert xdata_2.max() > xdata_0.max() + + assert len(xdata_0) == len(xdata_2) + + def test_clip(self, rng): + + x = rng.normal(0, 3, 1000) + + clip = -1, 1 + ax = kdeplot(x=x, clip=clip) + + xdata = ax.lines[0].get_xdata() + + assert xdata.min() >= clip[0] + assert xdata.max() <= clip[1] + + def test_line_is_density(self, long_df): + + ax = kdeplot(data=long_df, x="x", cut=5) + x, y = ax.lines[0].get_xydata().T + assert integrate.trapz(y, x) == pytest.approx(1) + + def test_cumulative(self, long_df): + + ax = kdeplot(data=long_df, x="x", cut=5, cumulative=True) + y = ax.lines[0].get_ydata() + assert y[0] == pytest.approx(0) + assert y[-1] == pytest.approx(1) + + def test_common_norm(self, long_df): + + f, (ax1, ax2) = plt.subplots(ncols=2) + + kdeplot( + data=long_df, x="x", hue="c", common_norm=True, cut=10, ax=ax1 + ) + kdeplot( + data=long_df, x="x", hue="c", common_norm=False, cut=10, ax=ax2 + ) + + total_area = 0 + for line in ax1.lines: + xdata, ydata = line.get_xydata().T + total_area += integrate.trapz(ydata, xdata) + assert total_area == pytest.approx(1) + + for line in ax2.lines: + xdata, ydata = line.get_xydata().T + assert integrate.trapz(ydata, xdata) == pytest.approx(1) + + def test_common_grid(self, long_df): + + f, (ax1, ax2) = plt.subplots(ncols=2) + + order = "a", "b", "c" + + kdeplot( + data=long_df, x="x", hue="a", hue_order=order, + common_grid=False, cut=0, ax=ax1, + ) + kdeplot( + data=long_df, x="x", hue="a", hue_order=order, + common_grid=True, cut=0, ax=ax2, + ) + + for line, level in zip(ax1.lines[::-1], order): + xdata = line.get_xdata() + assert xdata.min() == long_df.loc[long_df["a"] == level, "x"].min() + assert xdata.max() == long_df.loc[long_df["a"] == level, "x"].max() + + for line in ax2.lines: + xdata = line.get_xdata().T + assert xdata.min() == long_df["x"].min() + assert xdata.max() == long_df["x"].max() + + def test_bw_method(self, long_df): + + f, ax = plt.subplots() + kdeplot(data=long_df, x="x", bw_method=0.2, legend=False) + kdeplot(data=long_df, x="x", bw_method=1.0, legend=False) + kdeplot(data=long_df, x="x", bw_method=3.0, legend=False) + + l1, l2, l3 = ax.lines + + assert ( + np.abs(np.diff(l1.get_ydata())).mean() + > np.abs(np.diff(l2.get_ydata())).mean() + ) + + assert ( + np.abs(np.diff(l2.get_ydata())).mean() + > np.abs(np.diff(l3.get_ydata())).mean() + ) + + def test_bw_adjust(self, long_df): + + f, ax = plt.subplots() + kdeplot(data=long_df, x="x", bw_adjust=0.2, legend=False) + kdeplot(data=long_df, x="x", bw_adjust=1.0, legend=False) + kdeplot(data=long_df, x="x", bw_adjust=3.0, legend=False) + + l1, l2, l3 = ax.lines + + assert ( + np.abs(np.diff(l1.get_ydata())).mean() + > np.abs(np.diff(l2.get_ydata())).mean() + ) + + assert ( + np.abs(np.diff(l2.get_ydata())).mean() + > np.abs(np.diff(l3.get_ydata())).mean() + ) + + def test_log_scale_implicit(self, rng): + + x = rng.lognormal(0, 1, 100) + + f, (ax1, ax2) = plt.subplots(ncols=2) + ax1.set_xscale("log") + + kdeplot(x=x, ax=ax1) + kdeplot(x=x, ax=ax1) + + xdata_log = ax1.lines[0].get_xdata() + assert (xdata_log > 0).all() + assert (np.diff(xdata_log, 2) > 0).all() + assert np.allclose(np.diff(np.log(xdata_log), 2), 0) + + f, ax = plt.subplots() + ax.set_yscale("log") + kdeplot(y=x, ax=ax) + assert_array_equal(ax.lines[0].get_xdata(), ax1.lines[0].get_ydata()) + + def test_log_scale_explicit(self, rng): + + x = rng.lognormal(0, 1, 100) + + f, (ax1, ax2, ax3) = plt.subplots(ncols=3) + + ax1.set_xscale("log") + kdeplot(x=x, ax=ax1) + kdeplot(x=x, log_scale=True, ax=ax2) + kdeplot(x=x, log_scale=10, ax=ax3) + + for ax in f.axes: + assert ax.get_xscale() == "log" + + supports = [ax.lines[0].get_xdata() for ax in f.axes] + for a, b in itertools.product(supports, supports): + assert_array_equal(a, b) + + densities = [ax.lines[0].get_ydata() for ax in f.axes] + for a, b in itertools.product(densities, densities): + assert_array_equal(a, b) + + f, ax = plt.subplots() + kdeplot(y=x, log_scale=True, ax=ax) + assert ax.get_yscale() == "log" + + def test_log_scale_with_hue(self, rng): + + data = rng.lognormal(0, 1, 50), rng.lognormal(0, 2, 100) + ax = kdeplot(data=data, log_scale=True, common_grid=True) + assert_array_equal(ax.lines[0].get_xdata(), ax.lines[1].get_xdata()) + + def test_log_scale_normalization(self, rng): + + x = rng.lognormal(0, 1, 100) + ax = kdeplot(x=x, log_scale=True, cut=10) + xdata, ydata = ax.lines[0].get_xydata().T + integral = integrate.trapz(ydata, np.log10(xdata)) + assert integral == pytest.approx(1) + + @pytest.mark.skipif( + LooseVersion(scipy.__version__) < "1.2.0", + reason="Weights require scipy >= 1.2.0" + ) + def test_weights(self): + + x = [1, 2] + weights = [2, 1] + + ax = kdeplot(x=x, weights=weights) + + xdata, ydata = ax.lines[0].get_xydata().T + + y1 = ydata[np.argwhere(np.abs(xdata - 1).min())] + y2 = ydata[np.argwhere(np.abs(xdata - 2).min())] + + assert y1 == pytest.approx(2 * y2) + + def test_sticky_edges(self, long_df): + + f, (ax1, ax2) = plt.subplots(ncols=2) + + kdeplot(data=long_df, x="x", fill=True, ax=ax1) + assert ax1.collections[0].sticky_edges.y[:] == [0, np.inf] + + kdeplot( + data=long_df, x="x", hue="a", multiple="fill", fill=True, ax=ax2 + ) + assert ax2.collections[0].sticky_edges.y[:] == [0, 1] + + def test_line_kws(self, flat_array): + + lw = 3 + color = (.2, .5, .8) + ax = kdeplot(x=flat_array, linewidth=lw, color=color) + line, = ax.lines + assert line.get_linewidth() == lw + assert to_rgb(line.get_color()) == color + + def test_input_checking(self, long_df): + + err = "The x variable is categorical," + with pytest.raises(TypeError, match=err): + kdeplot(data=long_df, x="a") + + def test_axis_labels(self, long_df): + + f, (ax1, ax2) = plt.subplots(ncols=2) + + kdeplot(data=long_df, x="x", ax=ax1) + assert ax1.get_xlabel() == "x" + assert ax1.get_ylabel() == "Density" + + kdeplot(data=long_df, y="y", ax=ax2) + assert ax2.get_xlabel() == "Density" + assert ax2.get_ylabel() == "y" + + def test_legend(self, long_df): + + ax = kdeplot(data=long_df, x="x", hue="a") + + assert ax.legend_.get_title().get_text() == "a" + + legend_labels = ax.legend_.get_texts() + order = categorical_order(long_df["a"]) + for label, level in zip(legend_labels, order): + assert label.get_text() == level + + legend_artists = ax.legend_.findobj(mpl.lines.Line2D)[::2] + palette = color_palette() + for artist, color in zip(legend_artists, palette): + assert to_rgb(artist.get_color()) == to_rgb(color) + + ax.clear() + + kdeplot(data=long_df, x="x", hue="a", legend=False) + + assert ax.legend_ is None + + +class TestKDEPlotBivariate: + + def test_long_vectors(self, long_df): + + ax1 = kdeplot(data=long_df, x="x", y="y") + + x = long_df["x"] + x_values = [x, np.asarray(x), x.tolist()] + + y = long_df["y"] + y_values = [y, np.asarray(y), y.tolist()] + + for x, y in zip(x_values, y_values): + f, ax2 = plt.subplots() + kdeplot(x=x, y=y, ax=ax2) + + for c1, c2 in zip(ax1.collections, ax2.collections): + assert_array_equal(c1.get_offsets(), c2.get_offsets()) + + def test_singular_data(self): + + with pytest.warns(UserWarning): + ax = dist.kdeplot(x=np.ones(10), y=np.arange(10)) + assert not ax.lines + + with pytest.warns(UserWarning): + ax = dist.kdeplot(x=[5], y=[6]) + assert not ax.lines + + with pytest.warns(None) as record: + ax = kdeplot(x=[5], y=[7], warn_singular=False) + assert not record + + def test_fill_artists(self, long_df): + + for fill in [True, False]: + f, ax = plt.subplots() + kdeplot(data=long_df, x="x", y="y", hue="c", fill=fill) + for c in ax.collections: + if fill: + assert isinstance(c, mpl.collections.PathCollection) + else: + assert isinstance(c, mpl.collections.LineCollection) + + def test_common_norm(self, rng): + + hue = np.repeat(["a", "a", "a", "b"], 40) + x, y = rng.multivariate_normal([0, 0], [(.2, .5), (.5, 2)], len(hue)).T + x[hue == "a"] -= 2 + x[hue == "b"] += 2 + + f, (ax1, ax2) = plt.subplots(ncols=2) + kdeplot(x=x, y=y, hue=hue, common_norm=True, ax=ax1) + kdeplot(x=x, y=y, hue=hue, common_norm=False, ax=ax2) + + n_seg_1 = sum([len(c.get_segments()) > 0 for c in ax1.collections]) + n_seg_2 = sum([len(c.get_segments()) > 0 for c in ax2.collections]) + assert n_seg_2 > n_seg_1 + + def test_log_scale(self, rng): + + x = rng.lognormal(0, 1, 100) + y = rng.uniform(0, 1, 100) + + levels = .2, .5, 1 + + f, ax = plt.subplots() + kdeplot(x=x, y=y, log_scale=True, levels=levels, ax=ax) + assert ax.get_xscale() == "log" + assert ax.get_yscale() == "log" + + f, (ax1, ax2) = plt.subplots(ncols=2) + kdeplot(x=x, y=y, log_scale=(10, False), levels=levels, ax=ax1) + assert ax1.get_xscale() == "log" + assert ax1.get_yscale() == "linear" + + p = _DistributionPlotter() + kde = KDE() + density, (xx, yy) = kde(np.log10(x), y) + levels = p._quantile_to_level(density, levels) + ax2.contour(10 ** xx, yy, density, levels=levels) + + for c1, c2 in zip(ax1.collections, ax2.collections): + assert_array_equal(c1.get_segments(), c2.get_segments()) + + def test_bandwidth(self, rng): + + n = 100 + x, y = rng.multivariate_normal([0, 0], [(.2, .5), (.5, 2)], n).T + + f, (ax1, ax2) = plt.subplots(ncols=2) + + kdeplot(x=x, y=y, ax=ax1) + kdeplot(x=x, y=y, bw_adjust=2, ax=ax2) + + for c1, c2 in zip(ax1.collections, ax2.collections): + seg1, seg2 = c1.get_segments(), c2.get_segments() + if seg1 + seg2: + x1 = seg1[0][:, 0] + x2 = seg2[0][:, 0] + assert np.abs(x2).max() > np.abs(x1).max() + + @pytest.mark.skipif( + LooseVersion(scipy.__version__) < "1.2.0", + reason="Weights require scipy >= 1.2.0" + ) + def test_weights(self, rng): + + import warnings + warnings.simplefilter("error", np.VisibleDeprecationWarning) + + n = 100 + x, y = rng.multivariate_normal([1, 3], [(.2, .5), (.5, 2)], n).T + hue = np.repeat([0, 1], n // 2) + weights = rng.uniform(0, 1, n) + + f, (ax1, ax2) = plt.subplots(ncols=2) + kdeplot(x=x, y=y, hue=hue, ax=ax1) + kdeplot(x=x, y=y, hue=hue, weights=weights, ax=ax2) + + for c1, c2 in zip(ax1.collections, ax2.collections): + if c1.get_segments() and c2.get_segments(): + seg1 = np.concatenate(c1.get_segments(), axis=0) + seg2 = np.concatenate(c2.get_segments(), axis=0) + assert not np.array_equal(seg1, seg2) + + def test_hue_ignores_cmap(self, long_df): + + with pytest.warns(UserWarning, match="cmap parameter ignored"): + ax = kdeplot(data=long_df, x="x", y="y", hue="c", cmap="viridis") + + color = tuple(ax.collections[0].get_color().squeeze()) + assert color == mpl.colors.colorConverter.to_rgba("C0") + + def test_contour_line_colors(self, long_df): + + color = (.2, .9, .8, 1) + ax = kdeplot(data=long_df, x="x", y="y", color=color) + + for c in ax.collections: + assert tuple(c.get_color().squeeze()) == color + + def test_contour_fill_colors(self, long_df): + + n = 6 + color = (.2, .9, .8, 1) + ax = kdeplot( + data=long_df, x="x", y="y", fill=True, color=color, levels=n, + ) + + cmap = light_palette(color, reverse=True, as_cmap=True) + lut = cmap(np.linspace(0, 1, 256)) + for c in ax.collections: + color = c.get_facecolor().squeeze() + assert color in lut + + def test_colorbar(self, long_df): + + ax = kdeplot(data=long_df, x="x", y="y", fill=True, cbar=True) + assert len(ax.figure.axes) == 2 + + def test_levels_and_thresh(self, long_df): + + f, (ax1, ax2) = plt.subplots(ncols=2) + + n = 8 + thresh = .1 + plot_kws = dict(data=long_df, x="x", y="y") + kdeplot(**plot_kws, levels=n, thresh=thresh, ax=ax1) + kdeplot(**plot_kws, levels=np.linspace(thresh, 1, n), ax=ax2) + + for c1, c2 in zip(ax1.collections, ax2.collections): + assert_array_equal(c1.get_segments(), c2.get_segments()) + + with pytest.raises(ValueError): + kdeplot(**plot_kws, levels=[0, 1, 2]) + + ax1.clear() + ax2.clear() + + kdeplot(**plot_kws, levels=n, thresh=None, ax=ax1) + kdeplot(**plot_kws, levels=n, thresh=0, ax=ax2) + + for c1, c2 in zip(ax1.collections, ax2.collections): + assert_array_equal(c1.get_segments(), c2.get_segments()) + for c1, c2 in zip(ax1.collections, ax2.collections): + assert_array_equal(c1.get_facecolors(), c2.get_facecolors()) + + def test_quantile_to_level(self, rng): + + x = rng.uniform(0, 1, 100000) + isoprop = np.linspace(.1, 1, 6) + + levels = _DistributionPlotter()._quantile_to_level(x, isoprop) + for h, p in zip(levels, isoprop): + assert (x[x <= h].sum() / x.sum()) == pytest.approx(p, abs=1e-4) + + def test_input_checking(self, long_df): + + with pytest.raises(TypeError, match="The x variable is categorical,"): + kdeplot(data=long_df, x="a", y="y") + + +class TestHistPlotUnivariate: + + @pytest.mark.parametrize( + "variable", ["x", "y"], + ) + def test_long_vectors(self, long_df, variable): + + vector = long_df[variable] + vectors = [ + variable, vector, np.asarray(vector), vector.tolist(), + ] + + f, axs = plt.subplots(3) + for vector, ax in zip(vectors, axs): + histplot(data=long_df, ax=ax, **{variable: vector}) + + bars = [ax.patches for ax in axs] + for a_bars, b_bars in itertools.product(bars, bars): + for a, b in zip(a_bars, b_bars): + assert_array_equal(a.get_height(), b.get_height()) + assert_array_equal(a.get_xy(), b.get_xy()) + + def test_wide_vs_long_data(self, wide_df): + + f, (ax1, ax2) = plt.subplots(2) + + histplot(data=wide_df, ax=ax1, common_bins=False) + + for col in wide_df.columns[::-1]: + histplot(data=wide_df, x=col, ax=ax2) + + for a, b in zip(ax1.patches, ax2.patches): + assert a.get_height() == b.get_height() + assert a.get_xy() == b.get_xy() + + def test_flat_vector(self, long_df): + + f, (ax1, ax2) = plt.subplots(2) + + histplot(data=long_df["x"], ax=ax1) + histplot(data=long_df, x="x", ax=ax2) + + for a, b in zip(ax1.patches, ax2.patches): + assert a.get_height() == b.get_height() + assert a.get_xy() == b.get_xy() + + def test_empty_data(self): + + ax = histplot(x=[]) + assert not ax.patches + + def test_variable_assignment(self, long_df): + + f, (ax1, ax2) = plt.subplots(2) + + histplot(data=long_df, x="x", ax=ax1) + histplot(data=long_df, y="x", ax=ax2) + + for a, b in zip(ax1.patches, ax2.patches): + assert a.get_height() == b.get_width() + + @pytest.mark.parametrize("element", ["bars", "step", "poly"]) + @pytest.mark.parametrize("multiple", ["layer", "dodge", "stack", "fill"]) + def test_hue_fill_colors(self, long_df, multiple, element): + + ax = histplot( + data=long_df, x="x", hue="a", + multiple=multiple, bins=1, + fill=True, element=element, legend=False, + ) + + palette = color_palette() + + if multiple == "layer": + if element == "bars": + a = .5 + else: + a = .25 + else: + a = .75 + + for bar, color in zip(ax.patches[::-1], palette): + assert bar.get_facecolor() == to_rgba(color, a) + + for poly, color in zip(ax.collections[::-1], palette): + assert tuple(poly.get_facecolor().squeeze()) == to_rgba(color, a) + + def test_hue_stack(self, long_df): + + f, (ax1, ax2) = plt.subplots(2) + + n = 10 + + kws = dict(data=long_df, x="x", hue="a", bins=n, element="bars") + + histplot(**kws, multiple="layer", ax=ax1) + histplot(**kws, multiple="stack", ax=ax2) + + layer_heights = np.reshape([b.get_height() for b in ax1.patches], (-1, n)) + stack_heights = np.reshape([b.get_height() for b in ax2.patches], (-1, n)) + assert_array_equal(layer_heights, stack_heights) + + stack_xys = np.reshape([b.get_xy() for b in ax2.patches], (-1, n, 2)) + assert_array_equal( + stack_xys[..., 1] + stack_heights, + stack_heights.cumsum(axis=0), + ) + + def test_hue_fill(self, long_df): + + f, (ax1, ax2) = plt.subplots(2) + + n = 10 + + kws = dict(data=long_df, x="x", hue="a", bins=n, element="bars") + + histplot(**kws, multiple="layer", ax=ax1) + histplot(**kws, multiple="fill", ax=ax2) + + layer_heights = np.reshape([b.get_height() for b in ax1.patches], (-1, n)) + stack_heights = np.reshape([b.get_height() for b in ax2.patches], (-1, n)) + assert_array_almost_equal( + layer_heights / layer_heights.sum(axis=0), stack_heights + ) + + stack_xys = np.reshape([b.get_xy() for b in ax2.patches], (-1, n, 2)) + assert_array_almost_equal( + (stack_xys[..., 1] + stack_heights) / stack_heights.sum(axis=0), + stack_heights.cumsum(axis=0), + ) + + def test_hue_dodge(self, long_df): + + f, (ax1, ax2) = plt.subplots(2) + + bw = 2 + + kws = dict(data=long_df, x="x", hue="c", binwidth=bw, element="bars") + + histplot(**kws, multiple="layer", ax=ax1) + histplot(**kws, multiple="dodge", ax=ax2) + + layer_heights = [b.get_height() for b in ax1.patches] + dodge_heights = [b.get_height() for b in ax2.patches] + assert_array_equal(layer_heights, dodge_heights) + + layer_xs = np.reshape([b.get_x() for b in ax1.patches], (2, -1)) + dodge_xs = np.reshape([b.get_x() for b in ax2.patches], (2, -1)) + assert_array_almost_equal(layer_xs[1], dodge_xs[1]) + assert_array_almost_equal(layer_xs[0], dodge_xs[0] - bw / 2) + + def test_hue_as_numpy_dodged(self, long_df): + # https://github.com/mwaskom/seaborn/issues/2452 + + ax = histplot( + long_df, + x="y", hue=np.asarray(long_df["a"]), + multiple="dodge", bins=1, + ) + # Note hue order reversal + assert ax.patches[1].get_x() < ax.patches[0].get_x() + + def test_multiple_input_check(self, flat_series): + + with pytest.raises(ValueError, match="`multiple` must be"): + histplot(flat_series, multiple="invalid") + + def test_element_input_check(self, flat_series): + + with pytest.raises(ValueError, match="`element` must be"): + histplot(flat_series, element="invalid") + + def test_count_stat(self, flat_series): + + ax = histplot(flat_series, stat="count") + bar_heights = [b.get_height() for b in ax.patches] + assert sum(bar_heights) == len(flat_series) + + def test_density_stat(self, flat_series): + + ax = histplot(flat_series, stat="density") + bar_heights = [b.get_height() for b in ax.patches] + bar_widths = [b.get_width() for b in ax.patches] + assert np.multiply(bar_heights, bar_widths).sum() == pytest.approx(1) + + def test_density_stat_common_norm(self, long_df): + + ax = histplot( + data=long_df, x="x", hue="a", + stat="density", common_norm=True, element="bars", + ) + bar_heights = [b.get_height() for b in ax.patches] + bar_widths = [b.get_width() for b in ax.patches] + assert np.multiply(bar_heights, bar_widths).sum() == pytest.approx(1) + + def test_density_stat_unique_norm(self, long_df): + + n = 10 + ax = histplot( + data=long_df, x="x", hue="a", + stat="density", bins=n, common_norm=False, element="bars", + ) + + bar_groups = ax.patches[:n], ax.patches[-n:] + + for bars in bar_groups: + bar_heights = [b.get_height() for b in bars] + bar_widths = [b.get_width() for b in bars] + bar_areas = np.multiply(bar_heights, bar_widths) + assert bar_areas.sum() == pytest.approx(1) + + @pytest.fixture(params=["probability", "proportion"]) + def height_norm_arg(self, request): + return request.param + + def test_probability_stat(self, flat_series, height_norm_arg): + + ax = histplot(flat_series, stat=height_norm_arg) + bar_heights = [b.get_height() for b in ax.patches] + assert sum(bar_heights) == pytest.approx(1) + + def test_probability_stat_common_norm(self, long_df, height_norm_arg): + + ax = histplot( + data=long_df, x="x", hue="a", + stat=height_norm_arg, common_norm=True, element="bars", + ) + bar_heights = [b.get_height() for b in ax.patches] + assert sum(bar_heights) == pytest.approx(1) + + def test_probability_stat_unique_norm(self, long_df, height_norm_arg): + + n = 10 + ax = histplot( + data=long_df, x="x", hue="a", + stat=height_norm_arg, bins=n, common_norm=False, element="bars", + ) + + bar_groups = ax.patches[:n], ax.patches[-n:] + + for bars in bar_groups: + bar_heights = [b.get_height() for b in bars] + assert sum(bar_heights) == pytest.approx(1) + + def test_percent_stat(self, flat_series): + + ax = histplot(flat_series, stat="percent") + bar_heights = [b.get_height() for b in ax.patches] + assert sum(bar_heights) == 100 + + def test_common_bins(self, long_df): + + n = 10 + ax = histplot( + long_df, x="x", hue="a", common_bins=True, bins=n, element="bars", + ) + + bar_groups = ax.patches[:n], ax.patches[-n:] + assert_array_equal( + [b.get_xy() for b in bar_groups[0]], + [b.get_xy() for b in bar_groups[1]] + ) + + def test_unique_bins(self, wide_df): + + ax = histplot(wide_df, common_bins=False, bins=10, element="bars") + + bar_groups = np.split(np.array(ax.patches), len(wide_df.columns)) + + for i, col in enumerate(wide_df.columns[::-1]): + bars = bar_groups[i] + start = bars[0].get_x() + stop = bars[-1].get_x() + bars[-1].get_width() + assert start == wide_df[col].min() + assert stop == wide_df[col].max() + + def test_weights_with_missing(self, missing_df): + + ax = histplot(missing_df, x="x", weights="s", bins=5) + + bar_heights = [bar.get_height() for bar in ax.patches] + total_weight = missing_df[["x", "s"]].dropna()["s"].sum() + assert sum(bar_heights) == pytest.approx(total_weight) + + def test_discrete(self, long_df): + + ax = histplot(long_df, x="s", discrete=True) + + data_min = long_df["s"].min() + data_max = long_df["s"].max() + assert len(ax.patches) == (data_max - data_min + 1) + + for i, bar in enumerate(ax.patches): + assert bar.get_width() == 1 + assert bar.get_x() == (data_min + i - .5) + + def test_discrete_categorical_default(self, long_df): + + ax = histplot(long_df, x="a") + for i, bar in enumerate(ax.patches): + assert bar.get_width() == 1 + + def test_categorical_yaxis_inversion(self, long_df): + + ax = histplot(long_df, y="a") + ymax, ymin = ax.get_ylim() + assert ymax > ymin + + def test_discrete_requires_bars(self, long_df): + + with pytest.raises(ValueError, match="`element` must be 'bars'"): + histplot(long_df, x="s", discrete=True, element="poly") + + @pytest.mark.skipif( + LooseVersion(np.__version__) < "1.17", + reason="Histogram over datetime64 requires numpy >= 1.17", + ) + def test_datetime_scale(self, long_df): + + f, (ax1, ax2) = plt.subplots(2) + histplot(x=long_df["t"], fill=True, ax=ax1) + histplot(x=long_df["t"], fill=False, ax=ax2) + assert ax1.get_xlim() == ax2.get_xlim() + + @pytest.mark.parametrize("stat", ["count", "density", "probability"]) + def test_kde(self, flat_series, stat): + + ax = histplot( + flat_series, kde=True, stat=stat, kde_kws={"cut": 10} + ) + + bar_widths = [b.get_width() for b in ax.patches] + bar_heights = [b.get_height() for b in ax.patches] + hist_area = np.multiply(bar_widths, bar_heights).sum() + + density, = ax.lines + kde_area = integrate.trapz(density.get_ydata(), density.get_xdata()) + + assert kde_area == pytest.approx(hist_area) + + @pytest.mark.parametrize("multiple", ["layer", "dodge"]) + @pytest.mark.parametrize("stat", ["count", "density", "probability"]) + def test_kde_with_hue(self, long_df, stat, multiple): + + n = 10 + ax = histplot( + long_df, x="x", hue="c", multiple=multiple, + kde=True, stat=stat, element="bars", + kde_kws={"cut": 10}, bins=n, + ) + + bar_groups = ax.patches[:n], ax.patches[-n:] + + for i, bars in enumerate(bar_groups): + bar_widths = [b.get_width() for b in bars] + bar_heights = [b.get_height() for b in bars] + hist_area = np.multiply(bar_widths, bar_heights).sum() + + x, y = ax.lines[i].get_xydata().T + kde_area = integrate.trapz(y, x) + + if multiple == "layer": + assert kde_area == pytest.approx(hist_area) + elif multiple == "dodge": + assert kde_area == pytest.approx(hist_area * 2) + + def test_kde_default_cut(self, flat_series): + + ax = histplot(flat_series, kde=True) + support = ax.lines[0].get_xdata() + assert support.min() == flat_series.min() + assert support.max() == flat_series.max() + + def test_kde_hue(self, long_df): + + n = 10 + ax = histplot(data=long_df, x="x", hue="a", kde=True, bins=n) + + for bar, line in zip(ax.patches[::n], ax.lines): + assert to_rgba(bar.get_facecolor(), 1) == line.get_color() + + def test_kde_yaxis(self, flat_series): + + f, ax = plt.subplots() + histplot(x=flat_series, kde=True) + histplot(y=flat_series, kde=True) + + x, y = ax.lines + assert_array_equal(x.get_xdata(), y.get_ydata()) + assert_array_equal(x.get_ydata(), y.get_xdata()) + + def test_kde_line_kws(self, flat_series): + + lw = 5 + ax = histplot(flat_series, kde=True, line_kws=dict(lw=lw)) + assert ax.lines[0].get_linewidth() == lw + + def test_kde_singular_data(self): + + with pytest.warns(None) as record: + ax = histplot(x=np.ones(10), kde=True) + assert not record + assert not ax.lines + + with pytest.warns(None) as record: + ax = histplot(x=[5], kde=True) + assert not record + assert not ax.lines + + def test_element_default(self, long_df): + + f, (ax1, ax2) = plt.subplots(2) + histplot(long_df, x="x", ax=ax1) + histplot(long_df, x="x", ax=ax2, element="bars") + assert len(ax1.patches) == len(ax2.patches) + + f, (ax1, ax2) = plt.subplots(2) + histplot(long_df, x="x", hue="a", ax=ax1) + histplot(long_df, x="x", hue="a", ax=ax2, element="bars") + assert len(ax1.patches) == len(ax2.patches) + + def test_bars_no_fill(self, flat_series): + + alpha = .5 + ax = histplot(flat_series, element="bars", fill=False, alpha=alpha) + for bar in ax.patches: + assert bar.get_facecolor() == (0, 0, 0, 0) + assert bar.get_edgecolor()[-1] == alpha + + def test_step_fill(self, flat_series): + + f, (ax1, ax2) = plt.subplots(2) + + n = 10 + histplot(flat_series, element="bars", fill=True, bins=n, ax=ax1) + histplot(flat_series, element="step", fill=True, bins=n, ax=ax2) + + bar_heights = [b.get_height() for b in ax1.patches] + bar_widths = [b.get_width() for b in ax1.patches] + bar_edges = [b.get_x() for b in ax1.patches] + + fill = ax2.collections[0] + x, y = fill.get_paths()[0].vertices[::-1].T + + assert_array_equal(x[1:2 * n:2], bar_edges) + assert_array_equal(y[1:2 * n:2], bar_heights) + + assert x[n * 2] == bar_edges[-1] + bar_widths[-1] + assert y[n * 2] == bar_heights[-1] + + def test_poly_fill(self, flat_series): + + f, (ax1, ax2) = plt.subplots(2) + + n = 10 + histplot(flat_series, element="bars", fill=True, bins=n, ax=ax1) + histplot(flat_series, element="poly", fill=True, bins=n, ax=ax2) + + bar_heights = np.array([b.get_height() for b in ax1.patches]) + bar_widths = np.array([b.get_width() for b in ax1.patches]) + bar_edges = np.array([b.get_x() for b in ax1.patches]) + + fill = ax2.collections[0] + x, y = fill.get_paths()[0].vertices[::-1].T + + assert_array_equal(x[1:n + 1], bar_edges + bar_widths / 2) + assert_array_equal(y[1:n + 1], bar_heights) + + def test_poly_no_fill(self, flat_series): + + f, (ax1, ax2) = plt.subplots(2) + + n = 10 + histplot(flat_series, element="bars", fill=False, bins=n, ax=ax1) + histplot(flat_series, element="poly", fill=False, bins=n, ax=ax2) + + bar_heights = np.array([b.get_height() for b in ax1.patches]) + bar_widths = np.array([b.get_width() for b in ax1.patches]) + bar_edges = np.array([b.get_x() for b in ax1.patches]) + + x, y = ax2.lines[0].get_xydata().T + + assert_array_equal(x, bar_edges + bar_widths / 2) + assert_array_equal(y, bar_heights) + + def test_step_no_fill(self, flat_series): + + f, (ax1, ax2) = plt.subplots(2) + + histplot(flat_series, element="bars", fill=False, ax=ax1) + histplot(flat_series, element="step", fill=False, ax=ax2) + + bar_heights = [b.get_height() for b in ax1.patches] + bar_widths = [b.get_width() for b in ax1.patches] + bar_edges = [b.get_x() for b in ax1.patches] + + x, y = ax2.lines[0].get_xydata().T + + assert_array_equal(x[:-1], bar_edges) + assert_array_equal(y[:-1], bar_heights) + assert x[-1] == bar_edges[-1] + bar_widths[-1] + assert y[-1] == y[-2] + + def test_step_fill_xy(self, flat_series): + + f, ax = plt.subplots() + + histplot(x=flat_series, element="step", fill=True) + histplot(y=flat_series, element="step", fill=True) + + xverts = ax.collections[0].get_paths()[0].vertices + yverts = ax.collections[1].get_paths()[0].vertices + + assert_array_equal(xverts, yverts[:, ::-1]) + + def test_step_no_fill_xy(self, flat_series): + + f, ax = plt.subplots() + + histplot(x=flat_series, element="step", fill=False) + histplot(y=flat_series, element="step", fill=False) + + xline, yline = ax.lines + + assert_array_equal(xline.get_xdata(), yline.get_ydata()) + assert_array_equal(xline.get_ydata(), yline.get_xdata()) + + def test_weighted_histogram(self): + + ax = histplot(x=[0, 1, 2], weights=[1, 2, 3], discrete=True) + + bar_heights = [b.get_height() for b in ax.patches] + assert bar_heights == [1, 2, 3] + + def test_weights_with_auto_bins(self, long_df): + + with pytest.warns(UserWarning): + ax = histplot(long_df, x="x", weights="f") + assert len(ax.patches) == 10 + + def test_shrink(self, long_df): + + f, (ax1, ax2) = plt.subplots(2) + + bw = 2 + shrink = .4 + + histplot(long_df, x="x", binwidth=bw, ax=ax1) + histplot(long_df, x="x", binwidth=bw, shrink=shrink, ax=ax2) + + for p1, p2 in zip(ax1.patches, ax2.patches): + + w1, w2 = p1.get_width(), p2.get_width() + assert w2 == pytest.approx(shrink * w1) + + x1, x2 = p1.get_x(), p2.get_x() + assert (x2 + w2 / 2) == pytest.approx(x1 + w1 / 2) + + def test_log_scale_explicit(self, rng): + + x = rng.lognormal(0, 2, 1000) + ax = histplot(x, log_scale=True, binwidth=1) + + bar_widths = [b.get_width() for b in ax.patches] + steps = np.divide(bar_widths[1:], bar_widths[:-1]) + assert np.allclose(steps, 10) + + def test_log_scale_implicit(self, rng): + + x = rng.lognormal(0, 2, 1000) + + f, ax = plt.subplots() + ax.set_xscale("log") + histplot(x, binwidth=1, ax=ax) + + bar_widths = [b.get_width() for b in ax.patches] + steps = np.divide(bar_widths[1:], bar_widths[:-1]) + assert np.allclose(steps, 10) + + @pytest.mark.parametrize( + "fill", [True, False], + ) + def test_auto_linewidth(self, flat_series, fill): + + get_lw = lambda ax: ax.patches[0].get_linewidth() # noqa: E731 + + kws = dict(element="bars", fill=fill) + + f, (ax1, ax2) = plt.subplots(2) + histplot(flat_series, **kws, bins=10, ax=ax1) + histplot(flat_series, **kws, bins=100, ax=ax2) + assert get_lw(ax1) > get_lw(ax2) + + f, ax1 = plt.subplots(figsize=(10, 5)) + f, ax2 = plt.subplots(figsize=(2, 5)) + histplot(flat_series, **kws, bins=30, ax=ax1) + histplot(flat_series, **kws, bins=30, ax=ax2) + assert get_lw(ax1) > get_lw(ax2) + + f, ax1 = plt.subplots(figsize=(4, 5)) + f, ax2 = plt.subplots(figsize=(4, 5)) + histplot(flat_series, **kws, bins=30, ax=ax1) + histplot(10 ** flat_series, **kws, bins=30, log_scale=True, ax=ax2) + assert get_lw(ax1) == pytest.approx(get_lw(ax2)) + + f, ax1 = plt.subplots(figsize=(4, 5)) + f, ax2 = plt.subplots(figsize=(4, 5)) + histplot(y=[0, 1, 1], **kws, discrete=True, ax=ax1) + histplot(y=["a", "b", "b"], **kws, ax=ax2) + assert get_lw(ax1) == pytest.approx(get_lw(ax2)) + + def test_bar_kwargs(self, flat_series): + + lw = 2 + ec = (1, .2, .9, .5) + ax = histplot(flat_series, binwidth=1, ec=ec, lw=lw) + for bar in ax.patches: + assert bar.get_edgecolor() == ec + assert bar.get_linewidth() == lw + + def test_step_fill_kwargs(self, flat_series): + + lw = 2 + ec = (1, .2, .9, .5) + ax = histplot(flat_series, element="step", ec=ec, lw=lw) + poly = ax.collections[0] + assert tuple(poly.get_edgecolor().squeeze()) == ec + assert poly.get_linewidth() == lw + + def test_step_line_kwargs(self, flat_series): + + lw = 2 + ls = "--" + ax = histplot(flat_series, element="step", fill=False, lw=lw, ls=ls) + line = ax.lines[0] + assert line.get_linewidth() == lw + assert line.get_linestyle() == ls + + +class TestHistPlotBivariate: + + def test_mesh(self, long_df): + + hist = Histogram() + counts, (x_edges, y_edges) = hist(long_df["x"], long_df["y"]) + + ax = histplot(long_df, x="x", y="y") + mesh = ax.collections[0] + mesh_data = mesh.get_array() + + assert_array_equal(mesh_data.data, counts.T.flat) + assert_array_equal(mesh_data.mask, counts.T.flat == 0) + + edges = itertools.product(y_edges[:-1], x_edges[:-1]) + for i, (y, x) in enumerate(edges): + path = mesh.get_paths()[i] + assert path.vertices[0, 0] == x + assert path.vertices[0, 1] == y + + def test_mesh_with_hue(self, long_df): + + ax = histplot(long_df, x="x", y="y", hue="c") + + hist = Histogram() + hist.define_bin_params(long_df["x"], long_df["y"]) + + for i, sub_df in long_df.groupby("c"): + + mesh = ax.collections[i] + mesh_data = mesh.get_array() + + counts, (x_edges, y_edges) = hist(sub_df["x"], sub_df["y"]) + + assert_array_equal(mesh_data.data, counts.T.flat) + assert_array_equal(mesh_data.mask, counts.T.flat == 0) + + edges = itertools.product(y_edges[:-1], x_edges[:-1]) + for i, (y, x) in enumerate(edges): + path = mesh.get_paths()[i] + assert path.vertices[0, 0] == x + assert path.vertices[0, 1] == y + + def test_mesh_with_hue_unique_bins(self, long_df): + + ax = histplot(long_df, x="x", y="y", hue="c", common_bins=False) + + for i, sub_df in long_df.groupby("c"): + + hist = Histogram() + + mesh = ax.collections[i] + mesh_data = mesh.get_array() + + counts, (x_edges, y_edges) = hist(sub_df["x"], sub_df["y"]) + + assert_array_equal(mesh_data.data, counts.T.flat) + assert_array_equal(mesh_data.mask, counts.T.flat == 0) + + edges = itertools.product(y_edges[:-1], x_edges[:-1]) + for i, (y, x) in enumerate(edges): + path = mesh.get_paths()[i] + assert path.vertices[0, 0] == x + assert path.vertices[0, 1] == y + + def test_mesh_with_col_unique_bins(self, long_df): + + g = displot(long_df, x="x", y="y", col="c", common_bins=False) + + for i, sub_df in long_df.groupby("c"): + + hist = Histogram() + + mesh = g.axes.flat[i].collections[0] + mesh_data = mesh.get_array() + + counts, (x_edges, y_edges) = hist(sub_df["x"], sub_df["y"]) + + assert_array_equal(mesh_data.data, counts.T.flat) + assert_array_equal(mesh_data.mask, counts.T.flat == 0) + + edges = itertools.product(y_edges[:-1], x_edges[:-1]) + for i, (y, x) in enumerate(edges): + path = mesh.get_paths()[i] + assert path.vertices[0, 0] == x + assert path.vertices[0, 1] == y + + def test_mesh_log_scale(self, rng): + + x, y = rng.lognormal(0, 1, (2, 1000)) + hist = Histogram() + counts, (x_edges, y_edges) = hist(np.log10(x), np.log10(y)) + + ax = histplot(x=x, y=y, log_scale=True) + mesh = ax.collections[0] + mesh_data = mesh.get_array() + + assert_array_equal(mesh_data.data, counts.T.flat) + + edges = itertools.product(y_edges[:-1], x_edges[:-1]) + for i, (y_i, x_i) in enumerate(edges): + path = mesh.get_paths()[i] + assert path.vertices[0, 0] == 10 ** x_i + assert path.vertices[0, 1] == 10 ** y_i + + def test_mesh_thresh(self, long_df): + + hist = Histogram() + counts, (x_edges, y_edges) = hist(long_df["x"], long_df["y"]) + + thresh = 5 + ax = histplot(long_df, x="x", y="y", thresh=thresh) + mesh = ax.collections[0] + mesh_data = mesh.get_array() + + assert_array_equal(mesh_data.data, counts.T.flat) + assert_array_equal(mesh_data.mask, (counts <= thresh).T.flat) + + def test_mesh_sticky_edges(self, long_df): + + ax = histplot(long_df, x="x", y="y", thresh=None) + mesh = ax.collections[0] + assert mesh.sticky_edges.x == [long_df["x"].min(), long_df["x"].max()] + assert mesh.sticky_edges.y == [long_df["y"].min(), long_df["y"].max()] + + ax.clear() + ax = histplot(long_df, x="x", y="y") + mesh = ax.collections[0] + assert not mesh.sticky_edges.x + assert not mesh.sticky_edges.y + + def test_mesh_common_norm(self, long_df): + + stat = "density" + ax = histplot( + long_df, x="x", y="y", hue="c", common_norm=True, stat=stat, + ) + + hist = Histogram(stat="density") + hist.define_bin_params(long_df["x"], long_df["y"]) + + for i, sub_df in long_df.groupby("c"): + + mesh = ax.collections[i] + mesh_data = mesh.get_array() + + density, (x_edges, y_edges) = hist(sub_df["x"], sub_df["y"]) + + scale = len(sub_df) / len(long_df) + assert_array_equal(mesh_data.data, (density * scale).T.flat) + + def test_mesh_unique_norm(self, long_df): + + stat = "density" + ax = histplot( + long_df, x="x", y="y", hue="c", common_norm=False, stat=stat, + ) + + hist = Histogram() + bin_kws = hist.define_bin_params(long_df["x"], long_df["y"]) + + for i, sub_df in long_df.groupby("c"): + + sub_hist = Histogram(bins=bin_kws["bins"], stat=stat) + + mesh = ax.collections[i] + mesh_data = mesh.get_array() + + density, (x_edges, y_edges) = sub_hist(sub_df["x"], sub_df["y"]) + assert_array_equal(mesh_data.data, density.T.flat) + + @pytest.mark.parametrize("stat", ["probability", "proportion", "percent"]) + def test_mesh_normalization(self, long_df, stat): + + ax = histplot( + long_df, x="x", y="y", stat=stat, + ) + + mesh_data = ax.collections[0].get_array() + expected_sum = {"percent": 100}.get(stat, 1) + assert mesh_data.data.sum() == expected_sum + + def test_mesh_colors(self, long_df): + + color = "r" + f, ax = plt.subplots() + histplot( + long_df, x="x", y="y", color=color, + ) + mesh = ax.collections[0] + assert_array_equal( + mesh.get_cmap().colors, + _DistributionPlotter()._cmap_from_color(color).colors, + ) + + f, ax = plt.subplots() + histplot( + long_df, x="x", y="y", hue="c", + ) + colors = color_palette() + for i, mesh in enumerate(ax.collections): + assert_array_equal( + mesh.get_cmap().colors, + _DistributionPlotter()._cmap_from_color(colors[i]).colors, + ) + + def test_color_limits(self, long_df): + + f, (ax1, ax2, ax3) = plt.subplots(3) + kws = dict(data=long_df, x="x", y="y") + hist = Histogram() + counts, _ = hist(long_df["x"], long_df["y"]) + + histplot(**kws, ax=ax1) + assert ax1.collections[0].get_clim() == (0, counts.max()) + + vmax = 10 + histplot(**kws, vmax=vmax, ax=ax2) + counts, _ = hist(long_df["x"], long_df["y"]) + assert ax2.collections[0].get_clim() == (0, vmax) + + pmax = .8 + pthresh = .1 + f = _DistributionPlotter()._quantile_to_level + + histplot(**kws, pmax=pmax, pthresh=pthresh, ax=ax3) + counts, _ = hist(long_df["x"], long_df["y"]) + mesh = ax3.collections[0] + assert mesh.get_clim() == (0, f(counts, pmax)) + assert_array_equal( + mesh.get_array().mask, + (counts <= f(counts, pthresh)).T.flat, + ) + + def test_hue_color_limits(self, long_df): + + _, (ax1, ax2, ax3, ax4) = plt.subplots(4) + kws = dict(data=long_df, x="x", y="y", hue="c", bins=4) + + hist = Histogram(bins=kws["bins"]) + hist.define_bin_params(long_df["x"], long_df["y"]) + full_counts, _ = hist(long_df["x"], long_df["y"]) + + sub_counts = [] + for _, sub_df in long_df.groupby(kws["hue"]): + c, _ = hist(sub_df["x"], sub_df["y"]) + sub_counts.append(c) + + pmax = .8 + pthresh = .05 + f = _DistributionPlotter()._quantile_to_level + + histplot(**kws, common_norm=True, ax=ax1) + for i, mesh in enumerate(ax1.collections): + assert mesh.get_clim() == (0, full_counts.max()) + + histplot(**kws, common_norm=False, ax=ax2) + for i, mesh in enumerate(ax2.collections): + assert mesh.get_clim() == (0, sub_counts[i].max()) + + histplot(**kws, common_norm=True, pmax=pmax, pthresh=pthresh, ax=ax3) + for i, mesh in enumerate(ax3.collections): + assert mesh.get_clim() == (0, f(full_counts, pmax)) + assert_array_equal( + mesh.get_array().mask, + (sub_counts[i] <= f(full_counts, pthresh)).T.flat, + ) + + histplot(**kws, common_norm=False, pmax=pmax, pthresh=pthresh, ax=ax4) + for i, mesh in enumerate(ax4.collections): + assert mesh.get_clim() == (0, f(sub_counts[i], pmax)) + assert_array_equal( + mesh.get_array().mask, + (sub_counts[i] <= f(sub_counts[i], pthresh)).T.flat, + ) + + def test_colorbar(self, long_df): + + f, ax = plt.subplots() + histplot(long_df, x="x", y="y", cbar=True, ax=ax) + assert len(ax.figure.axes) == 2 + + f, (ax, cax) = plt.subplots(2) + histplot(long_df, x="x", y="y", cbar=True, cbar_ax=cax, ax=ax) + assert len(ax.figure.axes) == 2 + + +class TestECDFPlotUnivariate: + + @pytest.mark.parametrize("variable", ["x", "y"]) + def test_long_vectors(self, long_df, variable): + + vector = long_df[variable] + vectors = [ + variable, vector, np.asarray(vector), vector.tolist(), + ] + + f, ax = plt.subplots() + for vector in vectors: + ecdfplot(data=long_df, ax=ax, **{variable: vector}) + + xdata = [l.get_xdata() for l in ax.lines] + for a, b in itertools.product(xdata, xdata): + assert_array_equal(a, b) + + ydata = [l.get_ydata() for l in ax.lines] + for a, b in itertools.product(ydata, ydata): + assert_array_equal(a, b) + + def test_hue(self, long_df): + + ax = ecdfplot(long_df, x="x", hue="a") + + for line, color in zip(ax.lines[::-1], color_palette()): + assert line.get_color() == color + + def test_line_kwargs(self, long_df): + + color = "r" + ls = "--" + lw = 3 + ax = ecdfplot(long_df, x="x", color=color, ls=ls, lw=lw) + + for line in ax.lines: + assert to_rgb(line.get_color()) == to_rgb(color) + assert line.get_linestyle() == ls + assert line.get_linewidth() == lw + + @pytest.mark.parametrize("data_var", ["x", "y"]) + def test_drawstyle(self, flat_series, data_var): + + ax = ecdfplot(**{data_var: flat_series}) + drawstyles = dict(x="steps-post", y="steps-pre") + assert ax.lines[0].get_drawstyle() == drawstyles[data_var] + + @pytest.mark.parametrize( + "data_var,stat_var", [["x", "y"], ["y", "x"]], + ) + def test_proportion_limits(self, flat_series, data_var, stat_var): + + ax = ecdfplot(**{data_var: flat_series}) + data = getattr(ax.lines[0], f"get_{stat_var}data")() + assert data[0] == 0 + assert data[-1] == 1 + sticky_edges = getattr(ax.lines[0].sticky_edges, stat_var) + assert sticky_edges[:] == [0, 1] + + @pytest.mark.parametrize( + "data_var,stat_var", [["x", "y"], ["y", "x"]], + ) + def test_proportion_limits_complementary(self, flat_series, data_var, stat_var): + + ax = ecdfplot(**{data_var: flat_series}, complementary=True) + data = getattr(ax.lines[0], f"get_{stat_var}data")() + assert data[0] == 1 + assert data[-1] == 0 + sticky_edges = getattr(ax.lines[0].sticky_edges, stat_var) + assert sticky_edges[:] == [0, 1] + + @pytest.mark.parametrize( + "data_var,stat_var", [["x", "y"], ["y", "x"]], + ) + def test_proportion_count(self, flat_series, data_var, stat_var): + + n = len(flat_series) + ax = ecdfplot(**{data_var: flat_series}, stat="count") + data = getattr(ax.lines[0], f"get_{stat_var}data")() + assert data[0] == 0 + assert data[-1] == n + sticky_edges = getattr(ax.lines[0].sticky_edges, stat_var) + assert sticky_edges[:] == [0, n] + + def test_weights(self): + + ax = ecdfplot(x=[1, 2, 3], weights=[1, 1, 2]) + y = ax.lines[0].get_ydata() + assert_array_equal(y, [0, .25, .5, 1]) + + def test_bivariate_error(self, long_df): + + with pytest.raises(NotImplementedError, match="Bivariate ECDF plots"): + ecdfplot(data=long_df, x="x", y="y") + + def test_log_scale(self, long_df): + + ax1, ax2 = plt.figure().subplots(2) + + ecdfplot(data=long_df, x="z", ax=ax1) + ecdfplot(data=long_df, x="z", log_scale=True, ax=ax2) + + # Ignore first point, which either -inf (in linear) or 0 (in log) + line1 = ax1.lines[0].get_xydata()[1:] + line2 = ax2.lines[0].get_xydata()[1:] + + assert_array_almost_equal(line1, line2) + + +class TestDisPlot: + + # TODO probably good to move these utility attributes/methods somewhere else + @pytest.mark.parametrize( + "kwargs", [ + dict(), + dict(x="x"), + dict(x="t"), + dict(x="a"), + dict(x="z", log_scale=True), + dict(x="x", binwidth=4), + dict(x="x", weights="f", bins=5), + dict(x="x", color="green", linewidth=2, binwidth=4), + dict(x="x", hue="a", fill=False), + dict(x="y", hue="a", fill=False), + dict(x="x", hue="a", multiple="stack"), + dict(x="x", hue="a", element="step"), + dict(x="x", hue="a", palette="muted"), + dict(x="x", hue="a", kde=True), + dict(x="x", hue="a", stat="density", common_norm=False), + dict(x="x", y="y"), + ], + ) + def test_versus_single_histplot(self, long_df, kwargs): + + ax = histplot(long_df, **kwargs) + g = displot(long_df, **kwargs) + assert_plots_equal(ax, g.ax) + + if ax.legend_ is not None: + assert_legends_equal(ax.legend_, g._legend) + + if kwargs: + long_df["_"] = "_" + g2 = displot(long_df, col="_", **kwargs) + assert_plots_equal(ax, g2.ax) + + @pytest.mark.parametrize( + "kwargs", [ + dict(), + dict(x="x"), + dict(x="t"), + dict(x="z", log_scale=True), + dict(x="x", bw_adjust=.5), + dict(x="x", weights="f"), + dict(x="x", color="green", linewidth=2), + dict(x="x", hue="a", multiple="stack"), + dict(x="x", hue="a", fill=True), + dict(x="y", hue="a", fill=False), + dict(x="x", hue="a", palette="muted"), + dict(x="x", y="y"), + ], + ) + def test_versus_single_kdeplot(self, long_df, kwargs): + + if "weights" in kwargs and LooseVersion(scipy.__version__) < "1.2": + pytest.skip("Weights require scipy >= 1.2") + + ax = kdeplot(data=long_df, **kwargs) + g = displot(long_df, kind="kde", **kwargs) + assert_plots_equal(ax, g.ax) + + if ax.legend_ is not None: + assert_legends_equal(ax.legend_, g._legend) + + if kwargs: + long_df["_"] = "_" + g2 = displot(long_df, kind="kde", col="_", **kwargs) + assert_plots_equal(ax, g2.ax) + + @pytest.mark.parametrize( + "kwargs", [ + dict(), + dict(x="x"), + dict(x="t"), + dict(x="z", log_scale=True), + dict(x="x", weights="f"), + dict(y="x"), + dict(x="x", color="green", linewidth=2), + dict(x="x", hue="a", complementary=True), + dict(x="x", hue="a", stat="count"), + dict(x="x", hue="a", palette="muted"), + ], + ) + def test_versus_single_ecdfplot(self, long_df, kwargs): + + ax = ecdfplot(data=long_df, **kwargs) + g = displot(long_df, kind="ecdf", **kwargs) + assert_plots_equal(ax, g.ax) + + if ax.legend_ is not None: + assert_legends_equal(ax.legend_, g._legend) + + if kwargs: + long_df["_"] = "_" + g2 = displot(long_df, kind="ecdf", col="_", **kwargs) + assert_plots_equal(ax, g2.ax) + + @pytest.mark.parametrize( + "kwargs", [ + dict(x="x"), + dict(x="x", y="y"), + dict(x="x", hue="a"), + ] + ) + def test_with_rug(self, long_df, kwargs): + + ax = rugplot(data=long_df, **kwargs) + g = displot(long_df, rug=True, **kwargs) + g.ax.patches = [] + + assert_plots_equal(ax, g.ax, labels=False) + + long_df["_"] = "_" + g2 = displot(long_df, col="_", rug=True, **kwargs) + g2.ax.patches = [] + + assert_plots_equal(ax, g2.ax, labels=False) + + @pytest.mark.parametrize( + "facet_var", ["col", "row"], + ) + def test_facets(self, long_df, facet_var): + + kwargs = {facet_var: "a"} + ax = kdeplot(data=long_df, x="x", hue="a") + g = displot(long_df, x="x", kind="kde", **kwargs) + + legend_texts = ax.legend_.get_texts() + + for i, line in enumerate(ax.lines[::-1]): + facet_ax = g.axes.flat[i] + facet_line = facet_ax.lines[0] + assert_array_equal(line.get_xydata(), facet_line.get_xydata()) + + text = legend_texts[i].get_text() + assert text in facet_ax.get_title() + + @pytest.mark.parametrize("multiple", ["dodge", "stack", "fill"]) + def test_facet_multiple(self, long_df, multiple): + + bins = np.linspace(0, 20, 5) + ax = histplot( + data=long_df[long_df["c"] == 0], + x="x", hue="a", hue_order=["a", "b", "c"], + multiple=multiple, bins=bins, + ) + + g = displot( + data=long_df, x="x", hue="a", col="c", hue_order=["a", "b", "c"], + multiple=multiple, bins=bins, + ) + + assert_plots_equal(ax, g.axes_dict[0]) + + def test_ax_warning(self, long_df): + + ax = plt.figure().subplots() + with pytest.warns(UserWarning, match="`displot` is a figure-level"): + displot(long_df, x="x", ax=ax) + + @pytest.mark.parametrize("key", ["col", "row"]) + def test_array_faceting(self, long_df, key): + + a = np.asarray(long_df["a"]) # .to_numpy on pandas 0.24 + vals = categorical_order(a) + g = displot(long_df, x="x", **{key: a}) + assert len(g.axes.flat) == len(vals) + for ax, val in zip(g.axes.flat, vals): + assert val in ax.get_title() + + def test_legend(self, long_df): + + g = displot(long_df, x="x", hue="a") + assert g._legend is not None + + def test_empty(self): + + g = displot(x=[], y=[]) + assert isinstance(g, FacetGrid) + + def test_bivariate_ecdf_error(self, long_df): + + with pytest.raises(NotImplementedError): + displot(long_df, x="x", y="y", kind="ecdf") + + def test_bivariate_kde_norm(self, rng): + + x, y = rng.normal(0, 1, (2, 100)) + z = [0] * 80 + [1] * 20 + + g = displot(x=x, y=y, col=z, kind="kde", levels=10) + l1 = sum(bool(c.get_segments()) for c in g.axes.flat[0].collections) + l2 = sum(bool(c.get_segments()) for c in g.axes.flat[1].collections) + assert l1 > l2 + + g = displot(x=x, y=y, col=z, kind="kde", levels=10, common_norm=False) + l1 = sum(bool(c.get_segments()) for c in g.axes.flat[0].collections) + l2 = sum(bool(c.get_segments()) for c in g.axes.flat[1].collections) + assert l1 == l2 + + def test_bivariate_hist_norm(self, rng): + + x, y = rng.normal(0, 1, (2, 100)) + z = [0] * 80 + [1] * 20 + + g = displot(x=x, y=y, col=z, kind="hist") + clim1 = g.axes.flat[0].collections[0].get_clim() + clim2 = g.axes.flat[1].collections[0].get_clim() + assert clim1 == clim2 + + g = displot(x=x, y=y, col=z, kind="hist", common_norm=False) + clim1 = g.axes.flat[0].collections[0].get_clim() + clim2 = g.axes.flat[1].collections[0].get_clim() + assert clim1[1] > clim2[1] + + def test_facetgrid_data(self, long_df): + + g = displot( + data=long_df.to_dict(orient="list"), + x="z", + hue=long_df["a"].rename("hue_var"), + col=np.asarray(long_df["c"]), + ) + expected_cols = set(long_df.columns.tolist() + ["hue_var", "_col_"]) + assert set(g.data.columns) == expected_cols + assert_array_equal(g.data["hue_var"], long_df["a"]) + assert_array_equal(g.data["_col_"], long_df["c"]) diff --git a/grplot_seaborn/tests/test_docstrings.py b/grplot_seaborn/tests/test_docstrings.py new file mode 100644 index 0000000..ae78d9d --- /dev/null +++ b/grplot_seaborn/tests/test_docstrings.py @@ -0,0 +1,58 @@ +from .._docstrings import DocstringComponents + + +EXAMPLE_DICT = dict( + param_a=""" +a : str + The first parameter. + """, +) + + +class ExampleClass: + def example_method(self): + """An example method. + + Parameters + ---------- + a : str + A method parameter. + + """ + + +def example_func(): + """An example function. + + Parameters + ---------- + a : str + A function parameter. + + """ + + +class TestDocstringComponents: + + def test_from_dict(self): + + obj = DocstringComponents(EXAMPLE_DICT) + assert obj.param_a == "a : str\n The first parameter." + + def test_from_nested_components(self): + + obj_inner = DocstringComponents(EXAMPLE_DICT) + obj_outer = DocstringComponents.from_nested_components(inner=obj_inner) + assert obj_outer.inner.param_a == "a : str\n The first parameter." + + def test_from_function(self): + + obj = DocstringComponents.from_function_params(example_func) + assert obj.a == "a : str\n A function parameter." + + def test_from_method(self): + + obj = DocstringComponents.from_function_params( + ExampleClass.example_method + ) + assert obj.a == "a : str\n A method parameter." diff --git a/grplot_seaborn/tests/test_matrix.py b/grplot_seaborn/tests/test_matrix.py new file mode 100644 index 0000000..21674ef --- /dev/null +++ b/grplot_seaborn/tests/test_matrix.py @@ -0,0 +1,1311 @@ +import tempfile +import copy + +import numpy as np +import matplotlib as mpl +import matplotlib.pyplot as plt +import pandas as pd +from scipy.spatial import distance +from scipy.cluster import hierarchy + +import numpy.testing as npt +try: + import pandas.testing as pdt +except ImportError: + import pandas.util.testing as pdt +import pytest + +from .. import matrix as mat +from .. import color_palette +from .._testing import assert_colors_equal + +try: + import fastcluster + + assert fastcluster + _no_fastcluster = False +except ImportError: + _no_fastcluster = True + + +# Copied from master onto v0.11 here to fix break introduced by +# cherry pick commit 49fbd353 + +class TestHeatmap: + rs = np.random.RandomState(sum(map(ord, "heatmap"))) + + x_norm = rs.randn(4, 8) + letters = pd.Series(["A", "B", "C", "D"], name="letters") + df_norm = pd.DataFrame(x_norm, index=letters) + + x_unif = rs.rand(20, 13) + df_unif = pd.DataFrame(x_unif) + + default_kws = dict(vmin=None, vmax=None, cmap=None, center=None, + robust=False, annot=False, fmt=".2f", annot_kws=None, + cbar=True, cbar_kws=None, mask=None) + + def test_ndarray_input(self): + + p = mat._HeatMapper(self.x_norm, **self.default_kws) + npt.assert_array_equal(p.plot_data, self.x_norm) + pdt.assert_frame_equal(p.data, pd.DataFrame(self.x_norm)) + + npt.assert_array_equal(p.xticklabels, np.arange(8)) + npt.assert_array_equal(p.yticklabels, np.arange(4)) + + assert p.xlabel == "" + assert p.ylabel == "" + + def test_df_input(self): + + p = mat._HeatMapper(self.df_norm, **self.default_kws) + npt.assert_array_equal(p.plot_data, self.x_norm) + pdt.assert_frame_equal(p.data, self.df_norm) + + npt.assert_array_equal(p.xticklabels, np.arange(8)) + npt.assert_array_equal(p.yticklabels, self.letters.values) + + assert p.xlabel == "" + assert p.ylabel == "letters" + + def test_df_multindex_input(self): + + df = self.df_norm.copy() + index = pd.MultiIndex.from_tuples([("A", 1), ("B", 2), + ("C", 3), ("D", 4)], + names=["letter", "number"]) + index.name = "letter-number" + df.index = index + + p = mat._HeatMapper(df, **self.default_kws) + + combined_tick_labels = ["A-1", "B-2", "C-3", "D-4"] + npt.assert_array_equal(p.yticklabels, combined_tick_labels) + assert p.ylabel == "letter-number" + + p = mat._HeatMapper(df.T, **self.default_kws) + + npt.assert_array_equal(p.xticklabels, combined_tick_labels) + assert p.xlabel == "letter-number" + + @pytest.mark.parametrize("dtype", [float, np.int64, object]) + def test_mask_input(self, dtype): + kws = self.default_kws.copy() + + mask = self.x_norm > 0 + kws['mask'] = mask + data = self.x_norm.astype(dtype) + p = mat._HeatMapper(data, **kws) + plot_data = np.ma.masked_where(mask, data) + + npt.assert_array_equal(p.plot_data, plot_data) + + def test_mask_limits(self): + """Make sure masked cells are not used to calculate extremes""" + + kws = self.default_kws.copy() + + mask = self.x_norm > 0 + kws['mask'] = mask + p = mat._HeatMapper(self.x_norm, **kws) + + assert p.vmax == np.ma.array(self.x_norm, mask=mask).max() + assert p.vmin == np.ma.array(self.x_norm, mask=mask).min() + + mask = self.x_norm < 0 + kws['mask'] = mask + p = mat._HeatMapper(self.x_norm, **kws) + + assert p.vmin == np.ma.array(self.x_norm, mask=mask).min() + assert p.vmax == np.ma.array(self.x_norm, mask=mask).max() + + def test_default_vlims(self): + + p = mat._HeatMapper(self.df_unif, **self.default_kws) + assert p.vmin == self.x_unif.min() + assert p.vmax == self.x_unif.max() + + def test_robust_vlims(self): + + kws = self.default_kws.copy() + kws["robust"] = True + p = mat._HeatMapper(self.df_unif, **kws) + + assert p.vmin == np.percentile(self.x_unif, 2) + assert p.vmax == np.percentile(self.x_unif, 98) + + def test_custom_sequential_vlims(self): + + kws = self.default_kws.copy() + kws["vmin"] = 0 + kws["vmax"] = 1 + p = mat._HeatMapper(self.df_unif, **kws) + + assert p.vmin == 0 + assert p.vmax == 1 + + def test_custom_diverging_vlims(self): + + kws = self.default_kws.copy() + kws["vmin"] = -4 + kws["vmax"] = 5 + kws["center"] = 0 + p = mat._HeatMapper(self.df_norm, **kws) + + assert p.vmin == -4 + assert p.vmax == 5 + + def test_array_with_nans(self): + + x1 = self.rs.rand(10, 10) + nulls = np.zeros(10) * np.nan + x2 = np.c_[x1, nulls] + + m1 = mat._HeatMapper(x1, **self.default_kws) + m2 = mat._HeatMapper(x2, **self.default_kws) + + assert m1.vmin == m2.vmin + assert m1.vmax == m2.vmax + + def test_mask(self): + + df = pd.DataFrame(data={'a': [1, 1, 1], + 'b': [2, np.nan, 2], + 'c': [3, 3, np.nan]}) + + kws = self.default_kws.copy() + kws["mask"] = np.isnan(df.values) + + m = mat._HeatMapper(df, **kws) + + npt.assert_array_equal(np.isnan(m.plot_data.data), + m.plot_data.mask) + + def test_custom_cmap(self): + + kws = self.default_kws.copy() + kws["cmap"] = "BuGn" + p = mat._HeatMapper(self.df_unif, **kws) + assert p.cmap == mpl.cm.BuGn + + def test_centered_vlims(self): + + kws = self.default_kws.copy() + kws["center"] = .5 + + p = mat._HeatMapper(self.df_unif, **kws) + + assert p.vmin == self.df_unif.values.min() + assert p.vmax == self.df_unif.values.max() + + def test_default_colors(self): + + vals = np.linspace(.2, 1, 9) + cmap = mpl.cm.binary + ax = mat.heatmap([vals], cmap=cmap) + fc = ax.collections[0].get_facecolors() + cvals = np.linspace(0, 1, 9) + npt.assert_array_almost_equal(fc, cmap(cvals), 2) + + def test_custom_vlim_colors(self): + + vals = np.linspace(.2, 1, 9) + cmap = mpl.cm.binary + ax = mat.heatmap([vals], vmin=0, cmap=cmap) + fc = ax.collections[0].get_facecolors() + npt.assert_array_almost_equal(fc, cmap(vals), 2) + + def test_custom_center_colors(self): + + vals = np.linspace(.2, 1, 9) + cmap = mpl.cm.binary + ax = mat.heatmap([vals], center=.5, cmap=cmap) + fc = ax.collections[0].get_facecolors() + npt.assert_array_almost_equal(fc, cmap(vals), 2) + + def test_cmap_with_properties(self): + + kws = self.default_kws.copy() + cmap = copy.copy(mpl.cm.get_cmap("BrBG")) + cmap.set_bad("red") + kws["cmap"] = cmap + hm = mat._HeatMapper(self.df_unif, **kws) + npt.assert_array_equal( + cmap(np.ma.masked_invalid([np.nan])), + hm.cmap(np.ma.masked_invalid([np.nan]))) + + kws["center"] = 0.5 + hm = mat._HeatMapper(self.df_unif, **kws) + npt.assert_array_equal( + cmap(np.ma.masked_invalid([np.nan])), + hm.cmap(np.ma.masked_invalid([np.nan]))) + + kws = self.default_kws.copy() + cmap = copy.copy(mpl.cm.get_cmap("BrBG")) + cmap.set_under("red") + kws["cmap"] = cmap + hm = mat._HeatMapper(self.df_unif, **kws) + npt.assert_array_equal(cmap(-np.inf), hm.cmap(-np.inf)) + + kws["center"] = .5 + hm = mat._HeatMapper(self.df_unif, **kws) + npt.assert_array_equal(cmap(-np.inf), hm.cmap(-np.inf)) + + kws = self.default_kws.copy() + cmap = copy.copy(mpl.cm.get_cmap("BrBG")) + cmap.set_over("red") + kws["cmap"] = cmap + hm = mat._HeatMapper(self.df_unif, **kws) + npt.assert_array_equal(cmap(-np.inf), hm.cmap(-np.inf)) + + kws["center"] = .5 + hm = mat._HeatMapper(self.df_unif, **kws) + npt.assert_array_equal(cmap(np.inf), hm.cmap(np.inf)) + + def test_tickabels_off(self): + kws = self.default_kws.copy() + kws['xticklabels'] = False + kws['yticklabels'] = False + p = mat._HeatMapper(self.df_norm, **kws) + assert p.xticklabels == [] + assert p.yticklabels == [] + + def test_custom_ticklabels(self): + kws = self.default_kws.copy() + xticklabels = list('iheartheatmaps'[:self.df_norm.shape[1]]) + yticklabels = list('heatmapsarecool'[:self.df_norm.shape[0]]) + kws['xticklabels'] = xticklabels + kws['yticklabels'] = yticklabels + p = mat._HeatMapper(self.df_norm, **kws) + assert p.xticklabels == xticklabels + assert p.yticklabels == yticklabels + + def test_custom_ticklabel_interval(self): + + kws = self.default_kws.copy() + xstep, ystep = 2, 3 + kws['xticklabels'] = xstep + kws['yticklabels'] = ystep + p = mat._HeatMapper(self.df_norm, **kws) + + nx, ny = self.df_norm.T.shape + npt.assert_array_equal(p.xticks, np.arange(0, nx, xstep) + .5) + npt.assert_array_equal(p.yticks, np.arange(0, ny, ystep) + .5) + npt.assert_array_equal(p.xticklabels, + self.df_norm.columns[0:nx:xstep]) + npt.assert_array_equal(p.yticklabels, + self.df_norm.index[0:ny:ystep]) + + def test_heatmap_annotation(self): + + ax = mat.heatmap(self.df_norm, annot=True, fmt=".1f", + annot_kws={"fontsize": 14}) + for val, text in zip(self.x_norm.flat, ax.texts): + assert text.get_text() == "{:.1f}".format(val) + assert text.get_fontsize() == 14 + + def test_heatmap_annotation_overwrite_kws(self): + + annot_kws = dict(color="0.3", va="bottom", ha="left") + ax = mat.heatmap(self.df_norm, annot=True, fmt=".1f", + annot_kws=annot_kws) + for text in ax.texts: + assert text.get_color() == "0.3" + assert text.get_ha() == "left" + assert text.get_va() == "bottom" + + def test_heatmap_annotation_with_mask(self): + + df = pd.DataFrame(data={'a': [1, 1, 1], + 'b': [2, np.nan, 2], + 'c': [3, 3, np.nan]}) + mask = np.isnan(df.values) + df_masked = np.ma.masked_where(mask, df) + ax = mat.heatmap(df, annot=True, fmt='.1f', mask=mask) + assert len(df_masked.compressed()) == len(ax.texts) + for val, text in zip(df_masked.compressed(), ax.texts): + assert "{:.1f}".format(val) == text.get_text() + + def test_heatmap_annotation_mesh_colors(self): + + ax = mat.heatmap(self.df_norm, annot=True) + mesh = ax.collections[0] + assert len(mesh.get_facecolors()) == self.df_norm.values.size + + plt.close("all") + + def test_heatmap_annotation_other_data(self): + annot_data = self.df_norm + 10 + + ax = mat.heatmap(self.df_norm, annot=annot_data, fmt=".1f", + annot_kws={"fontsize": 14}) + + for val, text in zip(annot_data.values.flat, ax.texts): + assert text.get_text() == "{:.1f}".format(val) + assert text.get_fontsize() == 14 + + def test_heatmap_annotation_with_limited_ticklabels(self): + ax = mat.heatmap(self.df_norm, fmt=".2f", annot=True, + xticklabels=False, yticklabels=False) + for val, text in zip(self.x_norm.flat, ax.texts): + assert text.get_text() == "{:.2f}".format(val) + + def test_heatmap_cbar(self): + + f = plt.figure() + mat.heatmap(self.df_norm) + assert len(f.axes) == 2 + plt.close(f) + + f = plt.figure() + mat.heatmap(self.df_norm, cbar=False) + assert len(f.axes) == 1 + plt.close(f) + + f, (ax1, ax2) = plt.subplots(2) + mat.heatmap(self.df_norm, ax=ax1, cbar_ax=ax2) + assert len(f.axes) == 2 + plt.close(f) + + @pytest.mark.xfail(mpl.__version__ == "3.1.1", + reason="matplotlib 3.1.1 bug") + def test_heatmap_axes(self): + + ax = mat.heatmap(self.df_norm) + + xtl = [int(l.get_text()) for l in ax.get_xticklabels()] + assert xtl == list(self.df_norm.columns) + ytl = [l.get_text() for l in ax.get_yticklabels()] + assert ytl == list(self.df_norm.index) + + assert ax.get_xlabel() == "" + assert ax.get_ylabel() == "letters" + + assert ax.get_xlim() == (0, 8) + assert ax.get_ylim() == (4, 0) + + def test_heatmap_ticklabel_rotation(self): + + f, ax = plt.subplots(figsize=(2, 2)) + mat.heatmap(self.df_norm, xticklabels=1, yticklabels=1, ax=ax) + + for t in ax.get_xticklabels(): + assert t.get_rotation() == 0 + + for t in ax.get_yticklabels(): + assert t.get_rotation() == 90 + + plt.close(f) + + df = self.df_norm.copy() + df.columns = [str(c) * 10 for c in df.columns] + df.index = [i * 10 for i in df.index] + + f, ax = plt.subplots(figsize=(2, 2)) + mat.heatmap(df, xticklabels=1, yticklabels=1, ax=ax) + + for t in ax.get_xticklabels(): + assert t.get_rotation() == 90 + + for t in ax.get_yticklabels(): + assert t.get_rotation() == 0 + + plt.close(f) + + def test_heatmap_inner_lines(self): + + c = (0, 0, 1, 1) + ax = mat.heatmap(self.df_norm, linewidths=2, linecolor=c) + mesh = ax.collections[0] + assert mesh.get_linewidths()[0] == 2 + assert tuple(mesh.get_edgecolor()[0]) == c + + def test_square_aspect(self): + + ax = mat.heatmap(self.df_norm, square=True) + obs_aspect = ax.get_aspect() + # mpl>3.3 returns 1 for setting "equal" aspect + # so test for the two possible equal outcomes + assert obs_aspect == "equal" or obs_aspect == 1 + + def test_mask_validation(self): + + mask = mat._matrix_mask(self.df_norm, None) + assert mask.shape == self.df_norm.shape + assert mask.values.sum() == 0 + + with pytest.raises(ValueError): + bad_array_mask = self.rs.randn(3, 6) > 0 + mat._matrix_mask(self.df_norm, bad_array_mask) + + with pytest.raises(ValueError): + bad_df_mask = pd.DataFrame(self.rs.randn(4, 8) > 0) + mat._matrix_mask(self.df_norm, bad_df_mask) + + def test_missing_data_mask(self): + + data = pd.DataFrame(np.arange(4, dtype=float).reshape(2, 2)) + data.loc[0, 0] = np.nan + mask = mat._matrix_mask(data, None) + npt.assert_array_equal(mask, [[True, False], [False, False]]) + + mask_in = np.array([[False, True], [False, False]]) + mask_out = mat._matrix_mask(data, mask_in) + npt.assert_array_equal(mask_out, [[True, True], [False, False]]) + + def test_cbar_ticks(self): + + f, (ax1, ax2) = plt.subplots(2) + mat.heatmap(self.df_norm, ax=ax1, cbar_ax=ax2, + cbar_kws=dict(drawedges=True)) + assert len(ax2.collections) == 2 + + +class TestDendrogram: + rs = np.random.RandomState(sum(map(ord, "dendrogram"))) + + x_norm = rs.randn(4, 8) + np.arange(8) + x_norm = (x_norm.T + np.arange(4)).T + letters = pd.Series(["A", "B", "C", "D", "E", "F", "G", "H"], + name="letters") + + df_norm = pd.DataFrame(x_norm, columns=letters) + try: + import fastcluster + + x_norm_linkage = fastcluster.linkage_vector(x_norm.T, + metric='euclidean', + method='single') + except ImportError: + x_norm_distances = distance.pdist(x_norm.T, metric='euclidean') + x_norm_linkage = hierarchy.linkage(x_norm_distances, method='single') + x_norm_dendrogram = hierarchy.dendrogram(x_norm_linkage, no_plot=True, + color_threshold=-np.inf) + x_norm_leaves = x_norm_dendrogram['leaves'] + df_norm_leaves = np.asarray(df_norm.columns[x_norm_leaves]) + + default_kws = dict(linkage=None, metric='euclidean', method='single', + axis=1, label=True, rotate=False) + + def test_ndarray_input(self): + p = mat._DendrogramPlotter(self.x_norm, **self.default_kws) + npt.assert_array_equal(p.array.T, self.x_norm) + pdt.assert_frame_equal(p.data.T, pd.DataFrame(self.x_norm)) + + npt.assert_array_equal(p.linkage, self.x_norm_linkage) + assert p.dendrogram == self.x_norm_dendrogram + + npt.assert_array_equal(p.reordered_ind, self.x_norm_leaves) + + npt.assert_array_equal(p.xticklabels, self.x_norm_leaves) + npt.assert_array_equal(p.yticklabels, []) + + assert p.xlabel is None + assert p.ylabel == '' + + def test_df_input(self): + p = mat._DendrogramPlotter(self.df_norm, **self.default_kws) + npt.assert_array_equal(p.array.T, np.asarray(self.df_norm)) + pdt.assert_frame_equal(p.data.T, self.df_norm) + + npt.assert_array_equal(p.linkage, self.x_norm_linkage) + assert p.dendrogram == self.x_norm_dendrogram + + npt.assert_array_equal(p.xticklabels, + np.asarray(self.df_norm.columns)[ + self.x_norm_leaves]) + npt.assert_array_equal(p.yticklabels, []) + + assert p.xlabel == 'letters' + assert p.ylabel == '' + + def test_df_multindex_input(self): + + df = self.df_norm.copy() + index = pd.MultiIndex.from_tuples([("A", 1), ("B", 2), + ("C", 3), ("D", 4)], + names=["letter", "number"]) + index.name = "letter-number" + df.index = index + kws = self.default_kws.copy() + kws['label'] = True + + p = mat._DendrogramPlotter(df.T, **kws) + + xticklabels = ["A-1", "B-2", "C-3", "D-4"] + xticklabels = [xticklabels[i] for i in p.reordered_ind] + npt.assert_array_equal(p.xticklabels, xticklabels) + npt.assert_array_equal(p.yticklabels, []) + assert p.xlabel == "letter-number" + + def test_axis0_input(self): + kws = self.default_kws.copy() + kws['axis'] = 0 + p = mat._DendrogramPlotter(self.df_norm.T, **kws) + + npt.assert_array_equal(p.array, np.asarray(self.df_norm.T)) + pdt.assert_frame_equal(p.data, self.df_norm.T) + + npt.assert_array_equal(p.linkage, self.x_norm_linkage) + assert p.dendrogram == self.x_norm_dendrogram + + npt.assert_array_equal(p.xticklabels, self.df_norm_leaves) + npt.assert_array_equal(p.yticklabels, []) + + assert p.xlabel == 'letters' + assert p.ylabel == '' + + def test_rotate_input(self): + kws = self.default_kws.copy() + kws['rotate'] = True + p = mat._DendrogramPlotter(self.df_norm, **kws) + npt.assert_array_equal(p.array.T, np.asarray(self.df_norm)) + pdt.assert_frame_equal(p.data.T, self.df_norm) + + npt.assert_array_equal(p.xticklabels, []) + npt.assert_array_equal(p.yticklabels, self.df_norm_leaves) + + assert p.xlabel == '' + assert p.ylabel == 'letters' + + def test_rotate_axis0_input(self): + kws = self.default_kws.copy() + kws['rotate'] = True + kws['axis'] = 0 + p = mat._DendrogramPlotter(self.df_norm.T, **kws) + + npt.assert_array_equal(p.reordered_ind, self.x_norm_leaves) + + def test_custom_linkage(self): + kws = self.default_kws.copy() + + try: + import fastcluster + + linkage = fastcluster.linkage_vector(self.x_norm, method='single', + metric='euclidean') + except ImportError: + d = distance.pdist(self.x_norm, metric='euclidean') + linkage = hierarchy.linkage(d, method='single') + dendrogram = hierarchy.dendrogram(linkage, no_plot=True, + color_threshold=-np.inf) + kws['linkage'] = linkage + p = mat._DendrogramPlotter(self.df_norm, **kws) + + npt.assert_array_equal(p.linkage, linkage) + assert p.dendrogram == dendrogram + + def test_label_false(self): + kws = self.default_kws.copy() + kws['label'] = False + p = mat._DendrogramPlotter(self.df_norm, **kws) + assert p.xticks == [] + assert p.yticks == [] + assert p.xticklabels == [] + assert p.yticklabels == [] + assert p.xlabel == "" + assert p.ylabel == "" + + def test_linkage_scipy(self): + p = mat._DendrogramPlotter(self.x_norm, **self.default_kws) + + scipy_linkage = p._calculate_linkage_scipy() + + from scipy.spatial import distance + from scipy.cluster import hierarchy + + dists = distance.pdist(self.x_norm.T, + metric=self.default_kws['metric']) + linkage = hierarchy.linkage(dists, method=self.default_kws['method']) + + npt.assert_array_equal(scipy_linkage, linkage) + + @pytest.mark.skipif(_no_fastcluster, reason="fastcluster not installed") + def test_fastcluster_other_method(self): + import fastcluster + + kws = self.default_kws.copy() + kws['method'] = 'average' + linkage = fastcluster.linkage(self.x_norm.T, method='average', + metric='euclidean') + p = mat._DendrogramPlotter(self.x_norm, **kws) + npt.assert_array_equal(p.linkage, linkage) + + @pytest.mark.skipif(_no_fastcluster, reason="fastcluster not installed") + def test_fastcluster_non_euclidean(self): + import fastcluster + + kws = self.default_kws.copy() + kws['metric'] = 'cosine' + kws['method'] = 'average' + linkage = fastcluster.linkage(self.x_norm.T, method=kws['method'], + metric=kws['metric']) + p = mat._DendrogramPlotter(self.x_norm, **kws) + npt.assert_array_equal(p.linkage, linkage) + + def test_dendrogram_plot(self): + d = mat.dendrogram(self.x_norm, **self.default_kws) + + ax = plt.gca() + xlim = ax.get_xlim() + # 10 comes from _plot_dendrogram in scipy.cluster.hierarchy + xmax = len(d.reordered_ind) * 10 + + assert xlim[0] == 0 + assert xlim[1] == xmax + + assert len(ax.collections[0].get_paths()) == len(d.dependent_coord) + + @pytest.mark.xfail(mpl.__version__ == "3.1.1", + reason="matplotlib 3.1.1 bug") + def test_dendrogram_rotate(self): + kws = self.default_kws.copy() + kws['rotate'] = True + + d = mat.dendrogram(self.x_norm, **kws) + + ax = plt.gca() + ylim = ax.get_ylim() + + # 10 comes from _plot_dendrogram in scipy.cluster.hierarchy + ymax = len(d.reordered_ind) * 10 + + # Since y axis is inverted, ylim is (80, 0) + # and therefore not (0, 80) as usual: + assert ylim[1] == 0 + assert ylim[0] == ymax + + def test_dendrogram_ticklabel_rotation(self): + f, ax = plt.subplots(figsize=(2, 2)) + mat.dendrogram(self.df_norm, ax=ax) + + for t in ax.get_xticklabels(): + assert t.get_rotation() == 0 + + plt.close(f) + + df = self.df_norm.copy() + df.columns = [str(c) * 10 for c in df.columns] + df.index = [i * 10 for i in df.index] + + f, ax = plt.subplots(figsize=(2, 2)) + mat.dendrogram(df, ax=ax) + + for t in ax.get_xticklabels(): + assert t.get_rotation() == 90 + + plt.close(f) + + f, ax = plt.subplots(figsize=(2, 2)) + mat.dendrogram(df.T, axis=0, rotate=True) + for t in ax.get_yticklabels(): + assert t.get_rotation() == 0 + plt.close(f) + + +class TestClustermap: + rs = np.random.RandomState(sum(map(ord, "clustermap"))) + + x_norm = rs.randn(4, 8) + np.arange(8) + x_norm = (x_norm.T + np.arange(4)).T + letters = pd.Series(["A", "B", "C", "D", "E", "F", "G", "H"], + name="letters") + + df_norm = pd.DataFrame(x_norm, columns=letters) + try: + import fastcluster + + x_norm_linkage = fastcluster.linkage_vector(x_norm.T, + metric='euclidean', + method='single') + except ImportError: + x_norm_distances = distance.pdist(x_norm.T, metric='euclidean') + x_norm_linkage = hierarchy.linkage(x_norm_distances, method='single') + x_norm_dendrogram = hierarchy.dendrogram(x_norm_linkage, no_plot=True, + color_threshold=-np.inf) + x_norm_leaves = x_norm_dendrogram['leaves'] + df_norm_leaves = np.asarray(df_norm.columns[x_norm_leaves]) + + default_kws = dict(pivot_kws=None, z_score=None, standard_scale=None, + figsize=(10, 10), row_colors=None, col_colors=None, + dendrogram_ratio=.2, colors_ratio=.03, + cbar_pos=(0, .8, .05, .2)) + + default_plot_kws = dict(metric='euclidean', method='average', + colorbar_kws=None, + row_cluster=True, col_cluster=True, + row_linkage=None, col_linkage=None, + tree_kws=None) + + row_colors = color_palette('Set2', df_norm.shape[0]) + col_colors = color_palette('Dark2', df_norm.shape[1]) + + def test_ndarray_input(self): + cg = mat.ClusterGrid(self.x_norm, **self.default_kws) + pdt.assert_frame_equal(cg.data, pd.DataFrame(self.x_norm)) + assert len(cg.fig.axes) == 4 + assert cg.ax_row_colors is None + assert cg.ax_col_colors is None + + def test_df_input(self): + cg = mat.ClusterGrid(self.df_norm, **self.default_kws) + pdt.assert_frame_equal(cg.data, self.df_norm) + + def test_corr_df_input(self): + df = self.df_norm.corr() + cg = mat.ClusterGrid(df, **self.default_kws) + cg.plot(**self.default_plot_kws) + diag = cg.data2d.values[np.diag_indices_from(cg.data2d)] + npt.assert_array_equal(diag, np.ones(cg.data2d.shape[0])) + + def test_pivot_input(self): + df_norm = self.df_norm.copy() + df_norm.index.name = 'numbers' + df_long = pd.melt(df_norm.reset_index(), var_name='letters', + id_vars='numbers') + kws = self.default_kws.copy() + kws['pivot_kws'] = dict(index='numbers', columns='letters', + values='value') + cg = mat.ClusterGrid(df_long, **kws) + + pdt.assert_frame_equal(cg.data2d, df_norm) + + def test_colors_input(self): + kws = self.default_kws.copy() + + kws['row_colors'] = self.row_colors + kws['col_colors'] = self.col_colors + + cg = mat.ClusterGrid(self.df_norm, **kws) + npt.assert_array_equal(cg.row_colors, self.row_colors) + npt.assert_array_equal(cg.col_colors, self.col_colors) + + assert len(cg.fig.axes) == 6 + + def test_categorical_colors_input(self): + kws = self.default_kws.copy() + + row_colors = pd.Series(self.row_colors, dtype="category") + col_colors = pd.Series( + self.col_colors, dtype="category", index=self.df_norm.columns + ) + + kws['row_colors'] = row_colors + kws['col_colors'] = col_colors + + exp_row_colors = list(map(mpl.colors.to_rgb, row_colors)) + exp_col_colors = list(map(mpl.colors.to_rgb, col_colors)) + + cg = mat.ClusterGrid(self.df_norm, **kws) + npt.assert_array_equal(cg.row_colors, exp_row_colors) + npt.assert_array_equal(cg.col_colors, exp_col_colors) + + assert len(cg.fig.axes) == 6 + + def test_nested_colors_input(self): + kws = self.default_kws.copy() + + row_colors = [self.row_colors, self.row_colors] + col_colors = [self.col_colors, self.col_colors] + kws['row_colors'] = row_colors + kws['col_colors'] = col_colors + + cm = mat.ClusterGrid(self.df_norm, **kws) + npt.assert_array_equal(cm.row_colors, row_colors) + npt.assert_array_equal(cm.col_colors, col_colors) + + assert len(cm.fig.axes) == 6 + + def test_colors_input_custom_cmap(self): + kws = self.default_kws.copy() + + kws['cmap'] = mpl.cm.PRGn + kws['row_colors'] = self.row_colors + kws['col_colors'] = self.col_colors + + cg = mat.clustermap(self.df_norm, **kws) + npt.assert_array_equal(cg.row_colors, self.row_colors) + npt.assert_array_equal(cg.col_colors, self.col_colors) + + assert len(cg.fig.axes) == 6 + + def test_z_score(self): + df = self.df_norm.copy() + df = (df - df.mean()) / df.std() + kws = self.default_kws.copy() + kws['z_score'] = 1 + + cg = mat.ClusterGrid(self.df_norm, **kws) + pdt.assert_frame_equal(cg.data2d, df) + + def test_z_score_axis0(self): + df = self.df_norm.copy() + df = df.T + df = (df - df.mean()) / df.std() + df = df.T + kws = self.default_kws.copy() + kws['z_score'] = 0 + + cg = mat.ClusterGrid(self.df_norm, **kws) + pdt.assert_frame_equal(cg.data2d, df) + + def test_standard_scale(self): + df = self.df_norm.copy() + df = (df - df.min()) / (df.max() - df.min()) + kws = self.default_kws.copy() + kws['standard_scale'] = 1 + + cg = mat.ClusterGrid(self.df_norm, **kws) + pdt.assert_frame_equal(cg.data2d, df) + + def test_standard_scale_axis0(self): + df = self.df_norm.copy() + df = df.T + df = (df - df.min()) / (df.max() - df.min()) + df = df.T + kws = self.default_kws.copy() + kws['standard_scale'] = 0 + + cg = mat.ClusterGrid(self.df_norm, **kws) + pdt.assert_frame_equal(cg.data2d, df) + + def test_z_score_standard_scale(self): + kws = self.default_kws.copy() + kws['z_score'] = True + kws['standard_scale'] = True + with pytest.raises(ValueError): + mat.ClusterGrid(self.df_norm, **kws) + + def test_color_list_to_matrix_and_cmap(self): + # Note this uses the attribute named col_colors but tests row colors + matrix, cmap = mat.ClusterGrid.color_list_to_matrix_and_cmap( + self.col_colors, self.x_norm_leaves, axis=0) + + for i, leaf in enumerate(self.x_norm_leaves): + color = self.col_colors[leaf] + assert_colors_equal(cmap(matrix[i, 0]), color) + + def test_nested_color_list_to_matrix_and_cmap(self): + # Note this uses the attribute named col_colors but tests row colors + colors = [self.col_colors, self.col_colors[::-1]] + matrix, cmap = mat.ClusterGrid.color_list_to_matrix_and_cmap( + colors, self.x_norm_leaves, axis=0) + + for i, leaf in enumerate(self.x_norm_leaves): + for j, color_row in enumerate(colors): + color = color_row[leaf] + assert_colors_equal(cmap(matrix[i, j]), color) + + def test_color_list_to_matrix_and_cmap_axis1(self): + matrix, cmap = mat.ClusterGrid.color_list_to_matrix_and_cmap( + self.col_colors, self.x_norm_leaves, axis=1) + + for j, leaf in enumerate(self.x_norm_leaves): + color = self.col_colors[leaf] + assert_colors_equal(cmap(matrix[0, j]), color) + + def test_color_list_to_matrix_and_cmap_different_sizes(self): + colors = [self.col_colors, self.col_colors * 2] + with pytest.raises(ValueError): + matrix, cmap = mat.ClusterGrid.color_list_to_matrix_and_cmap( + colors, self.x_norm_leaves, axis=1) + + def test_savefig(self): + # Not sure if this is the right way to test.... + cg = mat.ClusterGrid(self.df_norm, **self.default_kws) + cg.plot(**self.default_plot_kws) + cg.savefig(tempfile.NamedTemporaryFile(), format='png') + + def test_plot_dendrograms(self): + cm = mat.clustermap(self.df_norm, **self.default_kws) + + assert len(cm.ax_row_dendrogram.collections[0].get_paths()) == len( + cm.dendrogram_row.independent_coord + ) + assert len(cm.ax_col_dendrogram.collections[0].get_paths()) == len( + cm.dendrogram_col.independent_coord + ) + data2d = self.df_norm.iloc[cm.dendrogram_row.reordered_ind, + cm.dendrogram_col.reordered_ind] + pdt.assert_frame_equal(cm.data2d, data2d) + + def test_cluster_false(self): + kws = self.default_kws.copy() + kws['row_cluster'] = False + kws['col_cluster'] = False + + cm = mat.clustermap(self.df_norm, **kws) + assert len(cm.ax_row_dendrogram.lines) == 0 + assert len(cm.ax_col_dendrogram.lines) == 0 + + assert len(cm.ax_row_dendrogram.get_xticks()) == 0 + assert len(cm.ax_row_dendrogram.get_yticks()) == 0 + assert len(cm.ax_col_dendrogram.get_xticks()) == 0 + assert len(cm.ax_col_dendrogram.get_yticks()) == 0 + + pdt.assert_frame_equal(cm.data2d, self.df_norm) + + def test_row_col_colors(self): + kws = self.default_kws.copy() + kws['row_colors'] = self.row_colors + kws['col_colors'] = self.col_colors + + cm = mat.clustermap(self.df_norm, **kws) + + assert len(cm.ax_row_colors.collections) == 1 + assert len(cm.ax_col_colors.collections) == 1 + + def test_cluster_false_row_col_colors(self): + kws = self.default_kws.copy() + kws['row_cluster'] = False + kws['col_cluster'] = False + kws['row_colors'] = self.row_colors + kws['col_colors'] = self.col_colors + + cm = mat.clustermap(self.df_norm, **kws) + assert len(cm.ax_row_dendrogram.lines) == 0 + assert len(cm.ax_col_dendrogram.lines) == 0 + + assert len(cm.ax_row_dendrogram.get_xticks()) == 0 + assert len(cm.ax_row_dendrogram.get_yticks()) == 0 + assert len(cm.ax_col_dendrogram.get_xticks()) == 0 + assert len(cm.ax_col_dendrogram.get_yticks()) == 0 + assert len(cm.ax_row_colors.collections) == 1 + assert len(cm.ax_col_colors.collections) == 1 + + pdt.assert_frame_equal(cm.data2d, self.df_norm) + + def test_row_col_colors_df(self): + kws = self.default_kws.copy() + kws['row_colors'] = pd.DataFrame({'row_1': list(self.row_colors), + 'row_2': list(self.row_colors)}, + index=self.df_norm.index, + columns=['row_1', 'row_2']) + kws['col_colors'] = pd.DataFrame({'col_1': list(self.col_colors), + 'col_2': list(self.col_colors)}, + index=self.df_norm.columns, + columns=['col_1', 'col_2']) + + cm = mat.clustermap(self.df_norm, **kws) + + row_labels = [l.get_text() for l in + cm.ax_row_colors.get_xticklabels()] + assert cm.row_color_labels == ['row_1', 'row_2'] + assert row_labels == cm.row_color_labels + + col_labels = [l.get_text() for l in + cm.ax_col_colors.get_yticklabels()] + assert cm.col_color_labels == ['col_1', 'col_2'] + assert col_labels == cm.col_color_labels + + def test_row_col_colors_df_shuffled(self): + # Tests if colors are properly matched, even if given in wrong order + + m, n = self.df_norm.shape + shuffled_inds = [self.df_norm.index[i] for i in + list(range(0, m, 2)) + list(range(1, m, 2))] + shuffled_cols = [self.df_norm.columns[i] for i in + list(range(0, n, 2)) + list(range(1, n, 2))] + + kws = self.default_kws.copy() + + row_colors = pd.DataFrame({'row_annot': list(self.row_colors)}, + index=self.df_norm.index) + kws['row_colors'] = row_colors.loc[shuffled_inds] + + col_colors = pd.DataFrame({'col_annot': list(self.col_colors)}, + index=self.df_norm.columns) + kws['col_colors'] = col_colors.loc[shuffled_cols] + + cm = mat.clustermap(self.df_norm, **kws) + assert list(cm.col_colors)[0] == list(self.col_colors) + assert list(cm.row_colors)[0] == list(self.row_colors) + + def test_row_col_colors_df_missing(self): + kws = self.default_kws.copy() + row_colors = pd.DataFrame({'row_annot': list(self.row_colors)}, + index=self.df_norm.index) + kws['row_colors'] = row_colors.drop(self.df_norm.index[0]) + + col_colors = pd.DataFrame({'col_annot': list(self.col_colors)}, + index=self.df_norm.columns) + kws['col_colors'] = col_colors.drop(self.df_norm.columns[0]) + + cm = mat.clustermap(self.df_norm, **kws) + + assert list(cm.col_colors)[0] == [(1.0, 1.0, 1.0)] + list(self.col_colors[1:]) + assert list(cm.row_colors)[0] == [(1.0, 1.0, 1.0)] + list(self.row_colors[1:]) + + def test_row_col_colors_df_one_axis(self): + # Test case with only row annotation. + kws1 = self.default_kws.copy() + kws1['row_colors'] = pd.DataFrame({'row_1': list(self.row_colors), + 'row_2': list(self.row_colors)}, + index=self.df_norm.index, + columns=['row_1', 'row_2']) + + cm1 = mat.clustermap(self.df_norm, **kws1) + + row_labels = [l.get_text() for l in + cm1.ax_row_colors.get_xticklabels()] + assert cm1.row_color_labels == ['row_1', 'row_2'] + assert row_labels == cm1.row_color_labels + + # Test case with only col annotation. + kws2 = self.default_kws.copy() + kws2['col_colors'] = pd.DataFrame({'col_1': list(self.col_colors), + 'col_2': list(self.col_colors)}, + index=self.df_norm.columns, + columns=['col_1', 'col_2']) + + cm2 = mat.clustermap(self.df_norm, **kws2) + + col_labels = [l.get_text() for l in + cm2.ax_col_colors.get_yticklabels()] + assert cm2.col_color_labels == ['col_1', 'col_2'] + assert col_labels == cm2.col_color_labels + + def test_row_col_colors_series(self): + kws = self.default_kws.copy() + kws['row_colors'] = pd.Series(list(self.row_colors), name='row_annot', + index=self.df_norm.index) + kws['col_colors'] = pd.Series(list(self.col_colors), name='col_annot', + index=self.df_norm.columns) + + cm = mat.clustermap(self.df_norm, **kws) + + row_labels = [l.get_text() for l in cm.ax_row_colors.get_xticklabels()] + assert cm.row_color_labels == ['row_annot'] + assert row_labels == cm.row_color_labels + + col_labels = [l.get_text() for l in cm.ax_col_colors.get_yticklabels()] + assert cm.col_color_labels == ['col_annot'] + assert col_labels == cm.col_color_labels + + def test_row_col_colors_series_shuffled(self): + # Tests if colors are properly matched, even if given in wrong order + + m, n = self.df_norm.shape + shuffled_inds = [self.df_norm.index[i] for i in + list(range(0, m, 2)) + list(range(1, m, 2))] + shuffled_cols = [self.df_norm.columns[i] for i in + list(range(0, n, 2)) + list(range(1, n, 2))] + + kws = self.default_kws.copy() + + row_colors = pd.Series(list(self.row_colors), name='row_annot', + index=self.df_norm.index) + kws['row_colors'] = row_colors.loc[shuffled_inds] + + col_colors = pd.Series(list(self.col_colors), name='col_annot', + index=self.df_norm.columns) + kws['col_colors'] = col_colors.loc[shuffled_cols] + + cm = mat.clustermap(self.df_norm, **kws) + + assert list(cm.col_colors) == list(self.col_colors) + assert list(cm.row_colors) == list(self.row_colors) + + def test_row_col_colors_series_missing(self): + kws = self.default_kws.copy() + row_colors = pd.Series(list(self.row_colors), name='row_annot', + index=self.df_norm.index) + kws['row_colors'] = row_colors.drop(self.df_norm.index[0]) + + col_colors = pd.Series(list(self.col_colors), name='col_annot', + index=self.df_norm.columns) + kws['col_colors'] = col_colors.drop(self.df_norm.columns[0]) + + cm = mat.clustermap(self.df_norm, **kws) + assert list(cm.col_colors) == [(1.0, 1.0, 1.0)] + list(self.col_colors[1:]) + assert list(cm.row_colors) == [(1.0, 1.0, 1.0)] + list(self.row_colors[1:]) + + def test_row_col_colors_ignore_heatmap_kwargs(self): + + g = mat.clustermap(self.rs.uniform(0, 200, self.df_norm.shape), + row_colors=self.row_colors, + col_colors=self.col_colors, + cmap="Spectral", + norm=mpl.colors.LogNorm(), + vmax=100) + + assert np.array_equal( + np.array(self.row_colors)[g.dendrogram_row.reordered_ind], + g.ax_row_colors.collections[0].get_facecolors()[:, :3] + ) + + assert np.array_equal( + np.array(self.col_colors)[g.dendrogram_col.reordered_ind], + g.ax_col_colors.collections[0].get_facecolors()[:, :3] + ) + + def test_row_col_colors_raise_on_mixed_index_types(self): + + row_colors = pd.Series( + list(self.row_colors), name="row_annot", index=self.df_norm.index + ) + + col_colors = pd.Series( + list(self.col_colors), name="col_annot", index=self.df_norm.columns + ) + + with pytest.raises(TypeError): + mat.clustermap(self.x_norm, row_colors=row_colors) + + with pytest.raises(TypeError): + mat.clustermap(self.x_norm, col_colors=col_colors) + + def test_mask_reorganization(self): + + kws = self.default_kws.copy() + kws["mask"] = self.df_norm > 0 + + g = mat.clustermap(self.df_norm, **kws) + npt.assert_array_equal(g.data2d.index, g.mask.index) + npt.assert_array_equal(g.data2d.columns, g.mask.columns) + + npt.assert_array_equal(g.mask.index, + self.df_norm.index[ + g.dendrogram_row.reordered_ind]) + npt.assert_array_equal(g.mask.columns, + self.df_norm.columns[ + g.dendrogram_col.reordered_ind]) + + def test_ticklabel_reorganization(self): + + kws = self.default_kws.copy() + xtl = np.arange(self.df_norm.shape[1]) + kws["xticklabels"] = list(xtl) + ytl = self.letters.loc[:self.df_norm.shape[0]] + kws["yticklabels"] = ytl + + g = mat.clustermap(self.df_norm, **kws) + + xtl_actual = [t.get_text() for t in g.ax_heatmap.get_xticklabels()] + ytl_actual = [t.get_text() for t in g.ax_heatmap.get_yticklabels()] + + xtl_want = xtl[g.dendrogram_col.reordered_ind].astype(" g1.ax_col_dendrogram.get_position().height) + + assert (g2.ax_col_colors.get_position().height + > g1.ax_col_colors.get_position().height) + + assert (g2.ax_heatmap.get_position().height + < g1.ax_heatmap.get_position().height) + + assert (g2.ax_row_dendrogram.get_position().width + > g1.ax_row_dendrogram.get_position().width) + + assert (g2.ax_row_colors.get_position().width + > g1.ax_row_colors.get_position().width) + + assert (g2.ax_heatmap.get_position().width + < g1.ax_heatmap.get_position().width) + + kws1 = self.default_kws.copy() + kws1.update(col_colors=self.col_colors) + kws2 = kws1.copy() + kws2.update(col_colors=[self.col_colors, self.col_colors]) + + g1 = mat.clustermap(self.df_norm, **kws1) + g2 = mat.clustermap(self.df_norm, **kws2) + + assert (g2.ax_col_colors.get_position().height + > g1.ax_col_colors.get_position().height) + + kws1 = self.default_kws.copy() + kws1.update(dendrogram_ratio=(.2, .2)) + + kws2 = kws1.copy() + kws2.update(dendrogram_ratio=(.2, .3)) + + g1 = mat.clustermap(self.df_norm, **kws1) + g2 = mat.clustermap(self.df_norm, **kws2) + + assert (g2.ax_row_dendrogram.get_position().width + == g1.ax_row_dendrogram.get_position().width) + + assert (g2.ax_col_dendrogram.get_position().height + > g1.ax_col_dendrogram.get_position().height) + + def test_cbar_pos(self): + + kws = self.default_kws.copy() + kws["cbar_pos"] = (.2, .1, .4, .3) + + g = mat.clustermap(self.df_norm, **kws) + pos = g.ax_cbar.get_position() + assert pytest.approx(tuple(pos.p0)) == kws["cbar_pos"][:2] + assert pytest.approx(pos.width) == kws["cbar_pos"][2] + assert pytest.approx(pos.height) == kws["cbar_pos"][3] + + kws["cbar_pos"] = None + g = mat.clustermap(self.df_norm, **kws) + assert g.ax_cbar is None + + def test_square_warning(self): + + kws = self.default_kws.copy() + g1 = mat.clustermap(self.df_norm, **kws) + + with pytest.warns(UserWarning): + kws["square"] = True + g2 = mat.clustermap(self.df_norm, **kws) + + g1_shape = g1.ax_heatmap.get_position().get_points() + g2_shape = g2.ax_heatmap.get_position().get_points() + assert np.array_equal(g1_shape, g2_shape) + + def test_clustermap_annotation(self): + + g = mat.clustermap(self.df_norm, annot=True, fmt=".1f") + for val, text in zip(np.asarray(g.data2d).flat, g.ax_heatmap.texts): + assert text.get_text() == "{:.1f}".format(val) + + g = mat.clustermap(self.df_norm, annot=self.df_norm, fmt=".1f") + for val, text in zip(np.asarray(g.data2d).flat, g.ax_heatmap.texts): + assert text.get_text() == "{:.1f}".format(val) + + def test_tree_kws(self): + + rgb = (1, .5, .2) + g = mat.clustermap(self.df_norm, tree_kws=dict(color=rgb)) + for ax in [g.ax_col_dendrogram, g.ax_row_dendrogram]: + tree, = ax.collections + assert tuple(tree.get_color().squeeze())[:3] == rgb diff --git a/grplot_seaborn/tests/test_miscplot.py b/grplot_seaborn/tests/test_miscplot.py new file mode 100644 index 0000000..323cdf7 --- /dev/null +++ b/grplot_seaborn/tests/test_miscplot.py @@ -0,0 +1,34 @@ +import matplotlib.pyplot as plt + +from .. import miscplot as misc +from ..palettes import color_palette +from .test_utils import _network + + +class TestPalPlot: + """Test the function that visualizes a color palette.""" + def test_palplot_size(self): + + pal4 = color_palette("husl", 4) + misc.palplot(pal4) + size4 = plt.gcf().get_size_inches() + assert tuple(size4) == (4, 1) + + pal5 = color_palette("husl", 5) + misc.palplot(pal5) + size5 = plt.gcf().get_size_inches() + assert tuple(size5) == (5, 1) + + palbig = color_palette("husl", 3) + misc.palplot(palbig, 2) + sizebig = plt.gcf().get_size_inches() + assert tuple(sizebig) == (6, 2) + + +class TestDogPlot: + + @_network(url="https://github.com/mwaskom/seaborn-data") + def test_dogplot(self): + misc.dogplot() + ax = plt.gca() + assert len(ax.images) == 1 diff --git a/grplot_seaborn/tests/test_palettes.py b/grplot_seaborn/tests/test_palettes.py new file mode 100644 index 0000000..152a244 --- /dev/null +++ b/grplot_seaborn/tests/test_palettes.py @@ -0,0 +1,423 @@ +import colorsys +import numpy as np +import matplotlib as mpl + +import pytest +import numpy.testing as npt + +from .. import palettes, utils, rcmod +from ..external import husl +from ..colors import xkcd_rgb, crayons + + +class TestColorPalettes: + + def test_current_palette(self): + + pal = palettes.color_palette(["red", "blue", "green"]) + rcmod.set_palette(pal) + assert pal == utils.get_color_cycle() + rcmod.set() + + def test_palette_context(self): + + default_pal = palettes.color_palette() + context_pal = palettes.color_palette("muted") + + with palettes.color_palette(context_pal): + assert utils.get_color_cycle() == context_pal + + assert utils.get_color_cycle() == default_pal + + def test_big_palette_context(self): + + original_pal = palettes.color_palette("deep", n_colors=8) + context_pal = palettes.color_palette("husl", 10) + + rcmod.set_palette(original_pal) + with palettes.color_palette(context_pal, 10): + assert utils.get_color_cycle() == context_pal + + assert utils.get_color_cycle() == original_pal + + # Reset default + rcmod.set() + + def test_palette_size(self): + + pal = palettes.color_palette("deep") + assert len(pal) == palettes.QUAL_PALETTE_SIZES["deep"] + + pal = palettes.color_palette("pastel6") + assert len(pal) == palettes.QUAL_PALETTE_SIZES["pastel6"] + + pal = palettes.color_palette("Set3") + assert len(pal) == palettes.QUAL_PALETTE_SIZES["Set3"] + + pal = palettes.color_palette("husl") + assert len(pal) == 6 + + pal = palettes.color_palette("Greens") + assert len(pal) == 6 + + def test_seaborn_palettes(self): + + pals = "deep", "muted", "pastel", "bright", "dark", "colorblind" + for name in pals: + full = palettes.color_palette(name, 10).as_hex() + short = palettes.color_palette(name + "6", 6).as_hex() + b, _, g, r, m, _, _, _, y, c = full + assert [b, g, r, m, y, c] == list(short) + + def test_hls_palette(self): + + pal1 = palettes.hls_palette() + pal2 = palettes.color_palette("hls") + npt.assert_array_equal(pal1, pal2) + + cmap1 = palettes.hls_palette(as_cmap=True) + cmap2 = palettes.color_palette("hls", as_cmap=True) + npt.assert_array_equal(cmap1([.2, .8]), cmap2([.2, .8])) + + def test_husl_palette(self): + + pal1 = palettes.husl_palette() + pal2 = palettes.color_palette("husl") + npt.assert_array_equal(pal1, pal2) + + cmap1 = palettes.husl_palette(as_cmap=True) + cmap2 = palettes.color_palette("husl", as_cmap=True) + npt.assert_array_equal(cmap1([.2, .8]), cmap2([.2, .8])) + + def test_mpl_palette(self): + + pal1 = palettes.mpl_palette("Reds") + pal2 = palettes.color_palette("Reds") + npt.assert_array_equal(pal1, pal2) + + cmap1 = mpl.cm.get_cmap("Reds") + cmap2 = palettes.mpl_palette("Reds", as_cmap=True) + cmap3 = palettes.color_palette("Reds", as_cmap=True) + npt.assert_array_equal(cmap1, cmap2) + npt.assert_array_equal(cmap1, cmap3) + + def test_mpl_dark_palette(self): + + mpl_pal1 = palettes.mpl_palette("Blues_d") + mpl_pal2 = palettes.color_palette("Blues_d") + npt.assert_array_equal(mpl_pal1, mpl_pal2) + + mpl_pal1 = palettes.mpl_palette("Blues_r_d") + mpl_pal2 = palettes.color_palette("Blues_r_d") + npt.assert_array_equal(mpl_pal1, mpl_pal2) + + def test_bad_palette_name(self): + + with pytest.raises(ValueError): + palettes.color_palette("IAmNotAPalette") + + def test_terrible_palette_name(self): + + with pytest.raises(ValueError): + palettes.color_palette("jet") + + def test_bad_palette_colors(self): + + pal = ["red", "blue", "iamnotacolor"] + with pytest.raises(ValueError): + palettes.color_palette(pal) + + def test_palette_desat(self): + + pal1 = palettes.husl_palette(6) + pal1 = [utils.desaturate(c, .5) for c in pal1] + pal2 = palettes.color_palette("husl", desat=.5) + npt.assert_array_equal(pal1, pal2) + + def test_palette_is_list_of_tuples(self): + + pal_in = np.array(["red", "blue", "green"]) + pal_out = palettes.color_palette(pal_in, 3) + + assert isinstance(pal_out, list) + assert isinstance(pal_out[0], tuple) + assert isinstance(pal_out[0][0], float) + assert len(pal_out[0]) == 3 + + def test_palette_cycles(self): + + deep = palettes.color_palette("deep6") + double_deep = palettes.color_palette("deep6", 12) + assert double_deep == deep + deep + + def test_hls_values(self): + + pal1 = palettes.hls_palette(6, h=0) + pal2 = palettes.hls_palette(6, h=.5) + pal2 = pal2[3:] + pal2[:3] + npt.assert_array_almost_equal(pal1, pal2) + + pal_dark = palettes.hls_palette(5, l=.2) # noqa + pal_bright = palettes.hls_palette(5, l=.8) # noqa + npt.assert_array_less(list(map(sum, pal_dark)), + list(map(sum, pal_bright))) + + pal_flat = palettes.hls_palette(5, s=.1) + pal_bold = palettes.hls_palette(5, s=.9) + npt.assert_array_less(list(map(np.std, pal_flat)), + list(map(np.std, pal_bold))) + + def test_husl_values(self): + + pal1 = palettes.husl_palette(6, h=0) + pal2 = palettes.husl_palette(6, h=.5) + pal2 = pal2[3:] + pal2[:3] + npt.assert_array_almost_equal(pal1, pal2) + + pal_dark = palettes.husl_palette(5, l=.2) # noqa + pal_bright = palettes.husl_palette(5, l=.8) # noqa + npt.assert_array_less(list(map(sum, pal_dark)), + list(map(sum, pal_bright))) + + pal_flat = palettes.husl_palette(5, s=.1) + pal_bold = palettes.husl_palette(5, s=.9) + npt.assert_array_less(list(map(np.std, pal_flat)), + list(map(np.std, pal_bold))) + + def test_cbrewer_qual(self): + + pal_short = palettes.mpl_palette("Set1", 4) + pal_long = palettes.mpl_palette("Set1", 6) + assert pal_short == pal_long[:4] + + pal_full = palettes.mpl_palette("Set2", 8) + pal_long = palettes.mpl_palette("Set2", 10) + assert pal_full == pal_long[:8] + + def test_mpl_reversal(self): + + pal_forward = palettes.mpl_palette("BuPu", 6) + pal_reverse = palettes.mpl_palette("BuPu_r", 6) + npt.assert_array_almost_equal(pal_forward, pal_reverse[::-1]) + + def test_rgb_from_hls(self): + + color = .5, .8, .4 + rgb_got = palettes._color_to_rgb(color, "hls") + rgb_want = colorsys.hls_to_rgb(*color) + assert rgb_got == rgb_want + + def test_rgb_from_husl(self): + + color = 120, 50, 40 + rgb_got = palettes._color_to_rgb(color, "husl") + rgb_want = tuple(husl.husl_to_rgb(*color)) + assert rgb_got == rgb_want + + for h in range(0, 360): + color = h, 100, 100 + rgb = palettes._color_to_rgb(color, "husl") + assert min(rgb) >= 0 + assert max(rgb) <= 1 + + def test_rgb_from_xkcd(self): + + color = "dull red" + rgb_got = palettes._color_to_rgb(color, "xkcd") + rgb_want = mpl.colors.to_rgb(xkcd_rgb[color]) + assert rgb_got == rgb_want + + def test_light_palette(self): + + n = 4 + pal_forward = palettes.light_palette("red", n) + pal_reverse = palettes.light_palette("red", n, reverse=True) + assert np.allclose(pal_forward, pal_reverse[::-1]) + + red = mpl.colors.colorConverter.to_rgb("red") + assert pal_forward[-1] == red + + pal_f_from_string = palettes.color_palette("light:red", n) + assert pal_forward[3] == pal_f_from_string[3] + + pal_r_from_string = palettes.color_palette("light:red_r", n) + assert pal_reverse[3] == pal_r_from_string[3] + + pal_cmap = palettes.light_palette("blue", as_cmap=True) + assert isinstance(pal_cmap, mpl.colors.LinearSegmentedColormap) + + pal_cmap_from_string = palettes.color_palette("light:blue", as_cmap=True) + assert pal_cmap(.8) == pal_cmap_from_string(.8) + + pal_cmap = palettes.light_palette("blue", as_cmap=True, reverse=True) + pal_cmap_from_string = palettes.color_palette("light:blue_r", as_cmap=True) + assert pal_cmap(.8) == pal_cmap_from_string(.8) + + def test_dark_palette(self): + + n = 4 + pal_forward = palettes.dark_palette("red", n) + pal_reverse = palettes.dark_palette("red", n, reverse=True) + assert np.allclose(pal_forward, pal_reverse[::-1]) + + red = mpl.colors.colorConverter.to_rgb("red") + assert pal_forward[-1] == red + + pal_f_from_string = palettes.color_palette("dark:red", n) + assert pal_forward[3] == pal_f_from_string[3] + + pal_r_from_string = palettes.color_palette("dark:red_r", n) + assert pal_reverse[3] == pal_r_from_string[3] + + pal_cmap = palettes.dark_palette("blue", as_cmap=True) + assert isinstance(pal_cmap, mpl.colors.LinearSegmentedColormap) + + pal_cmap_from_string = palettes.color_palette("dark:blue", as_cmap=True) + assert pal_cmap(.8) == pal_cmap_from_string(.8) + + pal_cmap = palettes.dark_palette("blue", as_cmap=True, reverse=True) + pal_cmap_from_string = palettes.color_palette("dark:blue_r", as_cmap=True) + assert pal_cmap(.8) == pal_cmap_from_string(.8) + + def test_diverging_palette(self): + + h_neg, h_pos = 100, 200 + sat, lum = 70, 50 + args = h_neg, h_pos, sat, lum + + n = 12 + pal = palettes.diverging_palette(*args, n=n) + neg_pal = palettes.light_palette((h_neg, sat, lum), int(n // 2), + input="husl") + pos_pal = palettes.light_palette((h_pos, sat, lum), int(n // 2), + input="husl") + assert len(pal) == n + assert pal[0] == neg_pal[-1] + assert pal[-1] == pos_pal[-1] + + pal_dark = palettes.diverging_palette(*args, n=n, center="dark") + assert np.mean(pal[int(n / 2)]) > np.mean(pal_dark[int(n / 2)]) + + pal_cmap = palettes.diverging_palette(*args, as_cmap=True) + assert isinstance(pal_cmap, mpl.colors.LinearSegmentedColormap) + + def test_blend_palette(self): + + colors = ["red", "yellow", "white"] + pal_cmap = palettes.blend_palette(colors, as_cmap=True) + assert isinstance(pal_cmap, mpl.colors.LinearSegmentedColormap) + + colors = ["red", "blue"] + pal = palettes.blend_palette(colors) + pal_str = "blend:" + ",".join(colors) + pal_from_str = palettes.color_palette(pal_str) + assert pal == pal_from_str + + def test_cubehelix_against_matplotlib(self): + + x = np.linspace(0, 1, 8) + mpl_pal = mpl.cm.cubehelix(x)[:, :3].tolist() + + sns_pal = palettes.cubehelix_palette(8, start=0.5, rot=-1.5, hue=1, + dark=0, light=1, reverse=True) + + assert sns_pal == mpl_pal + + def test_cubehelix_n_colors(self): + + for n in [3, 5, 8]: + pal = palettes.cubehelix_palette(n) + assert len(pal) == n + + def test_cubehelix_reverse(self): + + pal_forward = palettes.cubehelix_palette() + pal_reverse = palettes.cubehelix_palette(reverse=True) + assert pal_forward == pal_reverse[::-1] + + def test_cubehelix_cmap(self): + + cmap = palettes.cubehelix_palette(as_cmap=True) + assert isinstance(cmap, mpl.colors.ListedColormap) + pal = palettes.cubehelix_palette() + x = np.linspace(0, 1, 6) + npt.assert_array_equal(cmap(x)[:, :3], pal) + + cmap_rev = palettes.cubehelix_palette(as_cmap=True, reverse=True) + x = np.linspace(0, 1, 6) + pal_forward = cmap(x).tolist() + pal_reverse = cmap_rev(x[::-1]).tolist() + assert pal_forward == pal_reverse + + def test_cubehelix_code(self): + + color_palette = palettes.color_palette + cubehelix_palette = palettes.cubehelix_palette + + pal1 = color_palette("ch:", 8) + pal2 = color_palette(cubehelix_palette(8)) + assert pal1 == pal2 + + pal1 = color_palette("ch:.5, -.25,hue = .5,light=.75", 8) + pal2 = color_palette(cubehelix_palette(8, .5, -.25, hue=.5, light=.75)) + assert pal1 == pal2 + + pal1 = color_palette("ch:h=1,r=.5", 9) + pal2 = color_palette(cubehelix_palette(9, hue=1, rot=.5)) + assert pal1 == pal2 + + pal1 = color_palette("ch:_r", 6) + pal2 = color_palette(cubehelix_palette(6, reverse=True)) + assert pal1 == pal2 + + pal1 = color_palette("ch:_r", as_cmap=True) + pal2 = cubehelix_palette(6, reverse=True, as_cmap=True) + assert pal1(.5) == pal2(.5) + + def test_xkcd_palette(self): + + names = list(xkcd_rgb.keys())[10:15] + colors = palettes.xkcd_palette(names) + for name, color in zip(names, colors): + as_hex = mpl.colors.rgb2hex(color) + assert as_hex == xkcd_rgb[name] + + def test_crayon_palette(self): + + names = list(crayons.keys())[10:15] + colors = palettes.crayon_palette(names) + for name, color in zip(names, colors): + as_hex = mpl.colors.rgb2hex(color) + assert as_hex == crayons[name].lower() + + def test_color_codes(self): + + palettes.set_color_codes("deep") + colors = palettes.color_palette("deep6") + [".1"] + for code, color in zip("bgrmyck", colors): + rgb_want = mpl.colors.colorConverter.to_rgb(color) + rgb_got = mpl.colors.colorConverter.to_rgb(code) + assert rgb_want == rgb_got + palettes.set_color_codes("reset") + + with pytest.raises(ValueError): + palettes.set_color_codes("Set1") + + def test_as_hex(self): + + pal = palettes.color_palette("deep") + for rgb, hex in zip(pal, pal.as_hex()): + assert mpl.colors.rgb2hex(rgb) == hex + + def test_preserved_palette_length(self): + + pal_in = palettes.color_palette("Set1", 10) + pal_out = palettes.color_palette(pal_in) + assert pal_in == pal_out + + def test_html_rep(self): + + pal = palettes.color_palette() + html = pal._repr_html_() + for color in pal.as_hex(): + assert color in html diff --git a/grplot_seaborn/tests/test_rcmod.py b/grplot_seaborn/tests/test_rcmod.py new file mode 100644 index 0000000..b1cbec5 --- /dev/null +++ b/grplot_seaborn/tests/test_rcmod.py @@ -0,0 +1,281 @@ +from distutils.version import LooseVersion + +import pytest +import numpy as np +import matplotlib as mpl +import matplotlib.pyplot as plt +import numpy.testing as npt + +from .. import rcmod, palettes, utils +from ..conftest import has_verdana + + +class RCParamTester: + + def flatten_list(self, orig_list): + + iter_list = map(np.atleast_1d, orig_list) + flat_list = [item for sublist in iter_list for item in sublist] + return flat_list + + def assert_rc_params(self, params): + + for k, v in params.items(): + # Various subtle issues in matplotlib lead to unexpected + # values for the backend rcParam, which isn't relevant here + if k == "backend": + continue + if isinstance(v, np.ndarray): + npt.assert_array_equal(mpl.rcParams[k], v) + else: + assert mpl.rcParams[k] == v + + def assert_rc_params_equal(self, params1, params2): + + for key, v1 in params1.items(): + # Various subtle issues in matplotlib lead to unexpected + # values for the backend rcParam, which isn't relevant here + if key == "backend": + continue + + v2 = params2[key] + if isinstance(v1, np.ndarray): + npt.assert_array_equal(v1, v2) + else: + assert v1 == v2 + + +class TestAxesStyle(RCParamTester): + + styles = ["white", "dark", "whitegrid", "darkgrid", "ticks"] + + def test_default_return(self): + + current = rcmod.axes_style() + self.assert_rc_params(current) + + def test_key_usage(self): + + _style_keys = set(rcmod._style_keys) + for style in self.styles: + assert not set(rcmod.axes_style(style)) ^ _style_keys + + def test_bad_style(self): + + with pytest.raises(ValueError): + rcmod.axes_style("i_am_not_a_style") + + def test_rc_override(self): + + rc = {"axes.facecolor": "blue", "foo.notaparam": "bar"} + out = rcmod.axes_style("darkgrid", rc) + assert out["axes.facecolor"] == "blue" + assert "foo.notaparam" not in out + + def test_set_style(self): + + for style in self.styles: + + style_dict = rcmod.axes_style(style) + rcmod.set_style(style) + self.assert_rc_params(style_dict) + + def test_style_context_manager(self): + + rcmod.set_style("darkgrid") + orig_params = rcmod.axes_style() + context_params = rcmod.axes_style("whitegrid") + + with rcmod.axes_style("whitegrid"): + self.assert_rc_params(context_params) + self.assert_rc_params(orig_params) + + @rcmod.axes_style("whitegrid") + def func(): + self.assert_rc_params(context_params) + func() + self.assert_rc_params(orig_params) + + def test_style_context_independence(self): + + assert set(rcmod._style_keys) ^ set(rcmod._context_keys) + + def test_set_rc(self): + + rcmod.set_theme(rc={"lines.linewidth": 4}) + assert mpl.rcParams["lines.linewidth"] == 4 + rcmod.set_theme() + + def test_set_with_palette(self): + + rcmod.reset_orig() + + rcmod.set_theme(palette="deep") + assert utils.get_color_cycle() == palettes.color_palette("deep", 10) + rcmod.reset_orig() + + rcmod.set_theme(palette="deep", color_codes=False) + assert utils.get_color_cycle() == palettes.color_palette("deep", 10) + rcmod.reset_orig() + + pal = palettes.color_palette("deep") + rcmod.set_theme(palette=pal) + assert utils.get_color_cycle() == palettes.color_palette("deep", 10) + rcmod.reset_orig() + + rcmod.set_theme(palette=pal, color_codes=False) + assert utils.get_color_cycle() == palettes.color_palette("deep", 10) + rcmod.reset_orig() + + rcmod.set_theme() + + def test_reset_defaults(self): + + rcmod.reset_defaults() + self.assert_rc_params(mpl.rcParamsDefault) + rcmod.set_theme() + + def test_reset_orig(self): + + rcmod.reset_orig() + self.assert_rc_params(mpl.rcParamsOrig) + rcmod.set_theme() + + def test_set_is_alias(self): + + rcmod.set_theme(context="paper", style="white") + params1 = mpl.rcParams.copy() + rcmod.reset_orig() + + rcmod.set_theme(context="paper", style="white") + params2 = mpl.rcParams.copy() + + self.assert_rc_params_equal(params1, params2) + + rcmod.set_theme() + + +class TestPlottingContext(RCParamTester): + + contexts = ["paper", "notebook", "talk", "poster"] + + def test_default_return(self): + + current = rcmod.plotting_context() + self.assert_rc_params(current) + + def test_key_usage(self): + + _context_keys = set(rcmod._context_keys) + for context in self.contexts: + missing = set(rcmod.plotting_context(context)) ^ _context_keys + assert not missing + + def test_bad_context(self): + + with pytest.raises(ValueError): + rcmod.plotting_context("i_am_not_a_context") + + def test_font_scale(self): + + notebook_ref = rcmod.plotting_context("notebook") + notebook_big = rcmod.plotting_context("notebook", 2) + + font_keys = ["axes.labelsize", "axes.titlesize", "legend.fontsize", + "xtick.labelsize", "ytick.labelsize", "font.size"] + + if LooseVersion(mpl.__version__) >= "3.0": + font_keys.append("legend.title_fontsize") + + for k in font_keys: + assert notebook_ref[k] * 2 == notebook_big[k] + + def test_rc_override(self): + + key, val = "grid.linewidth", 5 + rc = {key: val, "foo": "bar"} + out = rcmod.plotting_context("talk", rc=rc) + assert out[key] == val + assert "foo" not in out + + def test_set_context(self): + + for context in self.contexts: + + context_dict = rcmod.plotting_context(context) + rcmod.set_context(context) + self.assert_rc_params(context_dict) + + def test_context_context_manager(self): + + rcmod.set_context("notebook") + orig_params = rcmod.plotting_context() + context_params = rcmod.plotting_context("paper") + + with rcmod.plotting_context("paper"): + self.assert_rc_params(context_params) + self.assert_rc_params(orig_params) + + @rcmod.plotting_context("paper") + def func(): + self.assert_rc_params(context_params) + func() + self.assert_rc_params(orig_params) + + +class TestPalette: + + def test_set_palette(self): + + rcmod.set_palette("deep") + assert utils.get_color_cycle() == palettes.color_palette("deep", 10) + + rcmod.set_palette("pastel6") + assert utils.get_color_cycle() == palettes.color_palette("pastel6", 6) + + rcmod.set_palette("dark", 4) + assert utils.get_color_cycle() == palettes.color_palette("dark", 4) + + rcmod.set_palette("Set2", color_codes=True) + assert utils.get_color_cycle() == palettes.color_palette("Set2", 8) + + +class TestFonts: + + _no_verdana = not has_verdana() + + @pytest.mark.skipif(_no_verdana, reason="Verdana font is not present") + def test_set_font(self): + + rcmod.set_theme(font="Verdana") + + _, ax = plt.subplots() + ax.set_xlabel("foo") + + assert ax.xaxis.label.get_fontname() == "Verdana" + + rcmod.set_theme() + + def test_set_serif_font(self): + + rcmod.set_theme(font="serif") + + _, ax = plt.subplots() + ax.set_xlabel("foo") + + assert ax.xaxis.label.get_fontname() in mpl.rcParams["font.serif"] + + rcmod.set_theme() + + @pytest.mark.skipif(_no_verdana, reason="Verdana font is not present") + def test_different_sans_serif(self): + + rcmod.set_theme() + rcmod.set_style(rc={"font.sans-serif": ["Verdana"]}) + + _, ax = plt.subplots() + ax.set_xlabel("foo") + + assert ax.xaxis.label.get_fontname() == "Verdana" + + rcmod.set_theme() diff --git a/grplot_seaborn/tests/test_regression.py b/grplot_seaborn/tests/test_regression.py new file mode 100644 index 0000000..63768a5 --- /dev/null +++ b/grplot_seaborn/tests/test_regression.py @@ -0,0 +1,673 @@ +from distutils.version import LooseVersion +import numpy as np +import matplotlib as mpl +import matplotlib.pyplot as plt +import pandas as pd + +import pytest +import numpy.testing as npt +try: + import pandas.testing as pdt +except ImportError: + import pandas.util.testing as pdt + +try: + import statsmodels.regression.linear_model as smlm + _no_statsmodels = False +except ImportError: + _no_statsmodels = True + +from .. import regression as lm +from ..palettes import color_palette + +rs = np.random.RandomState(0) + + +class TestLinearPlotter: + + rs = np.random.RandomState(77) + df = pd.DataFrame(dict(x=rs.normal(size=60), + d=rs.randint(-2, 3, 60), + y=rs.gamma(4, size=60), + s=np.tile(list("abcdefghij"), 6))) + df["z"] = df.y + rs.randn(60) + df["y_na"] = df.y.copy() + df.loc[[10, 20, 30], 'y_na'] = np.nan + + def test_establish_variables_from_frame(self): + + p = lm._LinearPlotter() + p.establish_variables(self.df, x="x", y="y") + pdt.assert_series_equal(p.x, self.df.x) + pdt.assert_series_equal(p.y, self.df.y) + pdt.assert_frame_equal(p.data, self.df) + + def test_establish_variables_from_series(self): + + p = lm._LinearPlotter() + p.establish_variables(None, x=self.df.x, y=self.df.y) + pdt.assert_series_equal(p.x, self.df.x) + pdt.assert_series_equal(p.y, self.df.y) + assert p.data is None + + def test_establish_variables_from_array(self): + + p = lm._LinearPlotter() + p.establish_variables(None, + x=self.df.x.values, + y=self.df.y.values) + npt.assert_array_equal(p.x, self.df.x) + npt.assert_array_equal(p.y, self.df.y) + assert p.data is None + + def test_establish_variables_from_lists(self): + + p = lm._LinearPlotter() + p.establish_variables(None, + x=self.df.x.values.tolist(), + y=self.df.y.values.tolist()) + npt.assert_array_equal(p.x, self.df.x) + npt.assert_array_equal(p.y, self.df.y) + assert p.data is None + + def test_establish_variables_from_mix(self): + + p = lm._LinearPlotter() + p.establish_variables(self.df, x="x", y=self.df.y) + pdt.assert_series_equal(p.x, self.df.x) + pdt.assert_series_equal(p.y, self.df.y) + pdt.assert_frame_equal(p.data, self.df) + + def test_establish_variables_from_bad(self): + + p = lm._LinearPlotter() + with pytest.raises(ValueError): + p.establish_variables(None, x="x", y=self.df.y) + + def test_dropna(self): + + p = lm._LinearPlotter() + p.establish_variables(self.df, x="x", y_na="y_na") + pdt.assert_series_equal(p.x, self.df.x) + pdt.assert_series_equal(p.y_na, self.df.y_na) + + p.dropna("x", "y_na") + mask = self.df.y_na.notnull() + pdt.assert_series_equal(p.x, self.df.x[mask]) + pdt.assert_series_equal(p.y_na, self.df.y_na[mask]) + + +class TestRegressionPlotter: + + rs = np.random.RandomState(49) + + grid = np.linspace(-3, 3, 30) + n_boot = 100 + bins_numeric = 3 + bins_given = [-1, 0, 1] + + df = pd.DataFrame(dict(x=rs.normal(size=60), + d=rs.randint(-2, 3, 60), + y=rs.gamma(4, size=60), + s=np.tile(list(range(6)), 10))) + df["z"] = df.y + rs.randn(60) + df["y_na"] = df.y.copy() + + bw_err = rs.randn(6)[df.s.values] * 2 + df.y += bw_err + + p = 1 / (1 + np.exp(-(df.x * 2 + rs.randn(60)))) + df["c"] = [rs.binomial(1, p_i) for p_i in p] + df.loc[[10, 20, 30], 'y_na'] = np.nan + + def test_variables_from_frame(self): + + p = lm._RegressionPlotter("x", "y", data=self.df, units="s") + + pdt.assert_series_equal(p.x, self.df.x) + pdt.assert_series_equal(p.y, self.df.y) + pdt.assert_series_equal(p.units, self.df.s) + pdt.assert_frame_equal(p.data, self.df) + + def test_variables_from_series(self): + + p = lm._RegressionPlotter(self.df.x, self.df.y, units=self.df.s) + + npt.assert_array_equal(p.x, self.df.x) + npt.assert_array_equal(p.y, self.df.y) + npt.assert_array_equal(p.units, self.df.s) + assert p.data is None + + def test_variables_from_mix(self): + + p = lm._RegressionPlotter("x", self.df.y + 1, data=self.df) + + npt.assert_array_equal(p.x, self.df.x) + npt.assert_array_equal(p.y, self.df.y + 1) + pdt.assert_frame_equal(p.data, self.df) + + def test_variables_must_be_1d(self): + + array_2d = np.random.randn(20, 2) + array_1d = np.random.randn(20) + with pytest.raises(ValueError): + lm._RegressionPlotter(array_2d, array_1d) + with pytest.raises(ValueError): + lm._RegressionPlotter(array_1d, array_2d) + + def test_dropna(self): + + p = lm._RegressionPlotter("x", "y_na", data=self.df) + assert len(p.x) == pd.notnull(self.df.y_na).sum() + + p = lm._RegressionPlotter("x", "y_na", data=self.df, dropna=False) + assert len(p.x) == len(self.df.y_na) + + @pytest.mark.parametrize("x,y", + [([1.5], [2]), + (np.array([1.5]), np.array([2])), + (pd.Series(1.5), pd.Series(2))]) + def test_singleton(self, x, y): + p = lm._RegressionPlotter(x, y) + assert not p.fit_reg + + def test_ci(self): + + p = lm._RegressionPlotter("x", "y", data=self.df, ci=95) + assert p.ci == 95 + assert p.x_ci == 95 + + p = lm._RegressionPlotter("x", "y", data=self.df, ci=95, x_ci=68) + assert p.ci == 95 + assert p.x_ci == 68 + + p = lm._RegressionPlotter("x", "y", data=self.df, ci=95, x_ci="sd") + assert p.ci == 95 + assert p.x_ci == "sd" + + @pytest.mark.skipif(_no_statsmodels, reason="no statsmodels") + def test_fast_regression(self): + + p = lm._RegressionPlotter("x", "y", data=self.df, n_boot=self.n_boot) + + # Fit with the "fast" function, which just does linear algebra + yhat_fast, _ = p.fit_fast(self.grid) + + # Fit using the statsmodels function with an OLS model + yhat_smod, _ = p.fit_statsmodels(self.grid, smlm.OLS) + + # Compare the vector of y_hat values + npt.assert_array_almost_equal(yhat_fast, yhat_smod) + + @pytest.mark.skipif(_no_statsmodels, reason="no statsmodels") + def test_regress_poly(self): + + p = lm._RegressionPlotter("x", "y", data=self.df, n_boot=self.n_boot) + + # Fit an first-order polynomial + yhat_poly, _ = p.fit_poly(self.grid, 1) + + # Fit using the statsmodels function with an OLS model + yhat_smod, _ = p.fit_statsmodels(self.grid, smlm.OLS) + + # Compare the vector of y_hat values + npt.assert_array_almost_equal(yhat_poly, yhat_smod) + + def test_regress_logx(self): + + x = np.arange(1, 10) + y = np.arange(1, 10) + grid = np.linspace(1, 10, 100) + p = lm._RegressionPlotter(x, y, n_boot=self.n_boot) + + yhat_lin, _ = p.fit_fast(grid) + yhat_log, _ = p.fit_logx(grid) + + assert yhat_lin[0] > yhat_log[0] + assert yhat_log[20] > yhat_lin[20] + assert yhat_lin[90] > yhat_log[90] + + @pytest.mark.skipif(_no_statsmodels, reason="no statsmodels") + def test_regress_n_boot(self): + + p = lm._RegressionPlotter("x", "y", data=self.df, n_boot=self.n_boot) + + # Fast (linear algebra) version + _, boots_fast = p.fit_fast(self.grid) + npt.assert_equal(boots_fast.shape, (self.n_boot, self.grid.size)) + + # Slower (np.polyfit) version + _, boots_poly = p.fit_poly(self.grid, 1) + npt.assert_equal(boots_poly.shape, (self.n_boot, self.grid.size)) + + # Slowest (statsmodels) version + _, boots_smod = p.fit_statsmodels(self.grid, smlm.OLS) + npt.assert_equal(boots_smod.shape, (self.n_boot, self.grid.size)) + + @pytest.mark.skipif(_no_statsmodels, reason="no statsmodels") + def test_regress_without_bootstrap(self): + + p = lm._RegressionPlotter("x", "y", data=self.df, + n_boot=self.n_boot, ci=None) + + # Fast (linear algebra) version + _, boots_fast = p.fit_fast(self.grid) + assert boots_fast is None + + # Slower (np.polyfit) version + _, boots_poly = p.fit_poly(self.grid, 1) + assert boots_poly is None + + # Slowest (statsmodels) version + _, boots_smod = p.fit_statsmodels(self.grid, smlm.OLS) + assert boots_smod is None + + def test_regress_bootstrap_seed(self): + + seed = 200 + p1 = lm._RegressionPlotter("x", "y", data=self.df, + n_boot=self.n_boot, seed=seed) + p2 = lm._RegressionPlotter("x", "y", data=self.df, + n_boot=self.n_boot, seed=seed) + + _, boots1 = p1.fit_fast(self.grid) + _, boots2 = p2.fit_fast(self.grid) + npt.assert_array_equal(boots1, boots2) + + def test_numeric_bins(self): + + p = lm._RegressionPlotter(self.df.x, self.df.y) + x_binned, bins = p.bin_predictor(self.bins_numeric) + npt.assert_equal(len(bins), self.bins_numeric) + npt.assert_array_equal(np.unique(x_binned), bins) + + def test_provided_bins(self): + + p = lm._RegressionPlotter(self.df.x, self.df.y) + x_binned, bins = p.bin_predictor(self.bins_given) + npt.assert_array_equal(np.unique(x_binned), self.bins_given) + + def test_bin_results(self): + + p = lm._RegressionPlotter(self.df.x, self.df.y) + x_binned, bins = p.bin_predictor(self.bins_given) + assert self.df.x[x_binned == 0].min() > self.df.x[x_binned == -1].max() + assert self.df.x[x_binned == 1].min() > self.df.x[x_binned == 0].max() + + def test_scatter_data(self): + + p = lm._RegressionPlotter(self.df.x, self.df.y) + x, y = p.scatter_data + npt.assert_array_equal(x, self.df.x) + npt.assert_array_equal(y, self.df.y) + + p = lm._RegressionPlotter(self.df.d, self.df.y) + x, y = p.scatter_data + npt.assert_array_equal(x, self.df.d) + npt.assert_array_equal(y, self.df.y) + + p = lm._RegressionPlotter(self.df.d, self.df.y, x_jitter=.1) + x, y = p.scatter_data + assert (x != self.df.d).any() + npt.assert_array_less(np.abs(self.df.d - x), np.repeat(.1, len(x))) + npt.assert_array_equal(y, self.df.y) + + p = lm._RegressionPlotter(self.df.d, self.df.y, y_jitter=.05) + x, y = p.scatter_data + npt.assert_array_equal(x, self.df.d) + npt.assert_array_less(np.abs(self.df.y - y), np.repeat(.1, len(y))) + + def test_estimate_data(self): + + p = lm._RegressionPlotter(self.df.d, self.df.y, x_estimator=np.mean) + + x, y, ci = p.estimate_data + + npt.assert_array_equal(x, np.sort(np.unique(self.df.d))) + npt.assert_array_almost_equal(y, self.df.groupby("d").y.mean()) + npt.assert_array_less(np.array(ci)[:, 0], y) + npt.assert_array_less(y, np.array(ci)[:, 1]) + + def test_estimate_cis(self): + + seed = 123 + + p = lm._RegressionPlotter(self.df.d, self.df.y, + x_estimator=np.mean, ci=95, seed=seed) + _, _, ci_big = p.estimate_data + + p = lm._RegressionPlotter(self.df.d, self.df.y, + x_estimator=np.mean, ci=50, seed=seed) + _, _, ci_wee = p.estimate_data + npt.assert_array_less(np.diff(ci_wee), np.diff(ci_big)) + + p = lm._RegressionPlotter(self.df.d, self.df.y, + x_estimator=np.mean, ci=None) + _, _, ci_nil = p.estimate_data + npt.assert_array_equal(ci_nil, [None] * len(ci_nil)) + + def test_estimate_units(self): + + # Seed the RNG locally + seed = 345 + + p = lm._RegressionPlotter("x", "y", data=self.df, + units="s", seed=seed, x_bins=3) + _, _, ci_big = p.estimate_data + ci_big = np.diff(ci_big, axis=1) + + p = lm._RegressionPlotter("x", "y", data=self.df, seed=seed, x_bins=3) + _, _, ci_wee = p.estimate_data + ci_wee = np.diff(ci_wee, axis=1) + + npt.assert_array_less(ci_wee, ci_big) + + def test_partial(self): + + x = self.rs.randn(100) + y = x + self.rs.randn(100) + z = x + self.rs.randn(100) + + p = lm._RegressionPlotter(y, z) + _, r_orig = np.corrcoef(p.x, p.y)[0] + + p = lm._RegressionPlotter(y, z, y_partial=x) + _, r_semipartial = np.corrcoef(p.x, p.y)[0] + assert r_semipartial < r_orig + + p = lm._RegressionPlotter(y, z, x_partial=x, y_partial=x) + _, r_partial = np.corrcoef(p.x, p.y)[0] + assert r_partial < r_orig + + x = pd.Series(x) + y = pd.Series(y) + p = lm._RegressionPlotter(y, z, x_partial=x, y_partial=x) + _, r_partial = np.corrcoef(p.x, p.y)[0] + assert r_partial < r_orig + + @pytest.mark.skipif(_no_statsmodels, reason="no statsmodels") + def test_logistic_regression(self): + + p = lm._RegressionPlotter("x", "c", data=self.df, + logistic=True, n_boot=self.n_boot) + _, yhat, _ = p.fit_regression(x_range=(-3, 3)) + npt.assert_array_less(yhat, 1) + npt.assert_array_less(0, yhat) + + @pytest.mark.skipif(_no_statsmodels, reason="no statsmodels") + def test_logistic_perfect_separation(self): + + y = self.df.x > self.df.x.mean() + p = lm._RegressionPlotter("x", y, data=self.df, + logistic=True, n_boot=10) + with np.errstate(all="ignore"): + _, yhat, _ = p.fit_regression(x_range=(-3, 3)) + assert np.isnan(yhat).all() + + @pytest.mark.skipif(_no_statsmodels, reason="no statsmodels") + def test_robust_regression(self): + + p_ols = lm._RegressionPlotter("x", "y", data=self.df, + n_boot=self.n_boot) + _, ols_yhat, _ = p_ols.fit_regression(x_range=(-3, 3)) + + p_robust = lm._RegressionPlotter("x", "y", data=self.df, + robust=True, n_boot=self.n_boot) + _, robust_yhat, _ = p_robust.fit_regression(x_range=(-3, 3)) + + assert len(ols_yhat) == len(robust_yhat) + + @pytest.mark.skipif(_no_statsmodels, reason="no statsmodels") + def test_lowess_regression(self): + + p = lm._RegressionPlotter("x", "y", data=self.df, lowess=True) + grid, yhat, err_bands = p.fit_regression(x_range=(-3, 3)) + + assert len(grid) == len(yhat) + assert err_bands is None + + def test_regression_options(self): + + with pytest.raises(ValueError): + lm._RegressionPlotter("x", "y", data=self.df, + lowess=True, order=2) + + with pytest.raises(ValueError): + lm._RegressionPlotter("x", "y", data=self.df, + lowess=True, logistic=True) + + def test_regression_limits(self): + + f, ax = plt.subplots() + ax.scatter(self.df.x, self.df.y) + p = lm._RegressionPlotter("x", "y", data=self.df) + grid, _, _ = p.fit_regression(ax) + xlim = ax.get_xlim() + assert grid.min() == xlim[0] + assert grid.max() == xlim[1] + + p = lm._RegressionPlotter("x", "y", data=self.df, truncate=True) + grid, _, _ = p.fit_regression() + assert grid.min() == self.df.x.min() + assert grid.max() == self.df.x.max() + + +class TestRegressionPlots: + + rs = np.random.RandomState(56) + df = pd.DataFrame(dict(x=rs.randn(90), + y=rs.randn(90) + 5, + z=rs.randint(0, 1, 90), + g=np.repeat(list("abc"), 30), + h=np.tile(list("xy"), 45), + u=np.tile(np.arange(6), 15))) + bw_err = rs.randn(6)[df.u.values] + df.y += bw_err + + def test_regplot_basic(self): + + f, ax = plt.subplots() + lm.regplot(x="x", y="y", data=self.df) + assert len(ax.lines) == 1 + assert len(ax.collections) == 2 + + x, y = ax.collections[0].get_offsets().T + npt.assert_array_equal(x, self.df.x) + npt.assert_array_equal(y, self.df.y) + + def test_regplot_selective(self): + + f, ax = plt.subplots() + ax = lm.regplot(x="x", y="y", data=self.df, scatter=False, ax=ax) + assert len(ax.lines) == 1 + assert len(ax.collections) == 1 + ax.clear() + + f, ax = plt.subplots() + ax = lm.regplot(x="x", y="y", data=self.df, fit_reg=False) + assert len(ax.lines) == 0 + assert len(ax.collections) == 1 + ax.clear() + + f, ax = plt.subplots() + ax = lm.regplot(x="x", y="y", data=self.df, ci=None) + assert len(ax.lines) == 1 + assert len(ax.collections) == 1 + ax.clear() + + def test_regplot_scatter_kws_alpha(self): + + f, ax = plt.subplots() + color = np.array([[0.3, 0.8, 0.5, 0.5]]) + ax = lm.regplot(x="x", y="y", data=self.df, + scatter_kws={'color': color}) + assert ax.collections[0]._alpha is None + assert ax.collections[0]._facecolors[0, 3] == 0.5 + + f, ax = plt.subplots() + color = np.array([[0.3, 0.8, 0.5]]) + ax = lm.regplot(x="x", y="y", data=self.df, + scatter_kws={'color': color}) + assert ax.collections[0]._alpha == 0.8 + + f, ax = plt.subplots() + color = np.array([[0.3, 0.8, 0.5]]) + ax = lm.regplot(x="x", y="y", data=self.df, + scatter_kws={'color': color, 'alpha': 0.4}) + assert ax.collections[0]._alpha == 0.4 + + f, ax = plt.subplots() + color = 'r' + ax = lm.regplot(x="x", y="y", data=self.df, + scatter_kws={'color': color}) + assert ax.collections[0]._alpha == 0.8 + + def test_regplot_binned(self): + + ax = lm.regplot(x="x", y="y", data=self.df, x_bins=5) + assert len(ax.lines) == 6 + assert len(ax.collections) == 2 + + def test_lmplot_no_data(self): + + with pytest.raises(TypeError): + # keyword argument `data` is required + lm.lmplot(x="x", y="y") + + def test_lmplot_basic(self): + + g = lm.lmplot(x="x", y="y", data=self.df) + ax = g.axes[0, 0] + assert len(ax.lines) == 1 + assert len(ax.collections) == 2 + + x, y = ax.collections[0].get_offsets().T + npt.assert_array_equal(x, self.df.x) + npt.assert_array_equal(y, self.df.y) + + def test_lmplot_hue(self): + + g = lm.lmplot(x="x", y="y", data=self.df, hue="h") + ax = g.axes[0, 0] + + assert len(ax.lines) == 2 + assert len(ax.collections) == 4 + + def test_lmplot_markers(self): + + g1 = lm.lmplot(x="x", y="y", data=self.df, hue="h", markers="s") + assert g1.hue_kws == {"marker": ["s", "s"]} + + g2 = lm.lmplot(x="x", y="y", data=self.df, hue="h", markers=["o", "s"]) + assert g2.hue_kws == {"marker": ["o", "s"]} + + with pytest.raises(ValueError): + lm.lmplot(x="x", y="y", data=self.df, hue="h", + markers=["o", "s", "d"]) + + def test_lmplot_marker_linewidths(self): + + g = lm.lmplot(x="x", y="y", data=self.df, hue="h", + fit_reg=False, markers=["o", "+"]) + c = g.axes[0, 0].collections + assert c[1].get_linewidths()[0] == mpl.rcParams["lines.linewidth"] + + def test_lmplot_facets(self): + + g = lm.lmplot(x="x", y="y", data=self.df, row="g", col="h") + assert g.axes.shape == (3, 2) + + g = lm.lmplot(x="x", y="y", data=self.df, col="u", col_wrap=4) + assert g.axes.shape == (6,) + + g = lm.lmplot(x="x", y="y", data=self.df, hue="h", col="u") + assert g.axes.shape == (1, 6) + + def test_lmplot_hue_col_nolegend(self): + + g = lm.lmplot(x="x", y="y", data=self.df, col="h", hue="h") + assert g._legend is None + + def test_lmplot_scatter_kws(self): + + g = lm.lmplot(x="x", y="y", hue="h", data=self.df, ci=None) + red_scatter, blue_scatter = g.axes[0, 0].collections + + red, blue = color_palette(n_colors=2) + npt.assert_array_equal(red, red_scatter.get_facecolors()[0, :3]) + npt.assert_array_equal(blue, blue_scatter.get_facecolors()[0, :3]) + + @pytest.mark.skipif(LooseVersion(mpl.__version__) < "3.4", + reason="MPL bug #15967") + @pytest.mark.parametrize("sharex", [True, False]) + def test_lmplot_facet_truncate(self, sharex): + + g = lm.lmplot( + data=self.df, x="x", y="y", hue="g", col="h", + truncate=False, facet_kws=dict(sharex=sharex), + ) + + for ax in g.axes.flat: + for line in ax.lines: + xdata = line.get_xdata() + assert ax.get_xlim() == tuple(xdata[[0, -1]]) + + def test_lmplot_sharey(self): + + df = pd.DataFrame(dict( + x=[0, 1, 2, 0, 1, 2], + y=[1, -1, 0, -100, 200, 0], + z=["a", "a", "a", "b", "b", "b"], + )) + + with pytest.warns(UserWarning): + g = lm.lmplot(data=df, x="x", y="y", col="z", sharey=False) + ax1, ax2 = g.axes.flat + assert ax1.get_ylim()[0] > ax2.get_ylim()[0] + assert ax1.get_ylim()[1] < ax2.get_ylim()[1] + + def test_lmplot_facet_kws(self): + + xlim = -4, 20 + g = lm.lmplot( + data=self.df, x="x", y="y", col="h", facet_kws={"xlim": xlim} + ) + for ax in g.axes.flat: + assert ax.get_xlim() == xlim + + def test_residplot(self): + + x, y = self.df.x, self.df.y + ax = lm.residplot(x=x, y=y) + + resid = y - np.polyval(np.polyfit(x, y, 1), x) + x_plot, y_plot = ax.collections[0].get_offsets().T + + npt.assert_array_equal(x, x_plot) + npt.assert_array_almost_equal(resid, y_plot) + + @pytest.mark.skipif(_no_statsmodels, reason="no statsmodels") + def test_residplot_lowess(self): + + ax = lm.residplot(x="x", y="y", data=self.df, lowess=True) + assert len(ax.lines) == 2 + + x, y = ax.lines[1].get_xydata().T + npt.assert_array_equal(x, np.sort(self.df.x)) + + def test_three_point_colors(self): + + x, y = np.random.randn(2, 3) + ax = lm.regplot(x=x, y=y, color=(1, 0, 0)) + color = ax.collections[0].get_facecolors() + npt.assert_almost_equal(color[0, :3], + (1, 0, 0)) + + def test_regplot_xlim(self): + + f, ax = plt.subplots() + x, y1, y2 = np.random.randn(3, 50) + lm.regplot(x=x, y=y1, truncate=False) + lm.regplot(x=x, y=y2, truncate=False) + line1, line2 = ax.lines + assert np.array_equal(line1.get_xdata(), line2.get_xdata()) diff --git a/grplot_seaborn/tests/test_relational.py b/grplot_seaborn/tests/test_relational.py new file mode 100644 index 0000000..6ae6ef7 --- /dev/null +++ b/grplot_seaborn/tests/test_relational.py @@ -0,0 +1,1859 @@ +from itertools import product +import warnings +import numpy as np +import pandas as pd +import matplotlib as mpl +import matplotlib.pyplot as plt +from matplotlib.colors import same_color + +import pytest +from numpy.testing import assert_array_equal + +from ..palettes import color_palette + +from ..relational import ( + _RelationalPlotter, + _LinePlotter, + _ScatterPlotter, + relplot, + lineplot, + scatterplot +) + + +@pytest.fixture(params=[ + dict(x="x", y="y"), + dict(x="t", y="y"), + dict(x="a", y="y"), + dict(x="x", y="y", hue="y"), + dict(x="x", y="y", hue="a"), + dict(x="x", y="y", size="a"), + dict(x="x", y="y", style="a"), + dict(x="x", y="y", hue="s"), + dict(x="x", y="y", size="s"), + dict(x="x", y="y", style="s"), + dict(x="x", y="y", hue="a", style="a"), + dict(x="x", y="y", hue="a", size="b", style="b"), +]) +def long_semantics(request): + return request.param + + +class Helpers: + + # TODO Better place for these? + + def scatter_rgbs(self, collections): + rgbs = [] + for col in collections: + rgb = tuple(col.get_facecolor().squeeze()[:3]) + rgbs.append(rgb) + return rgbs + + def paths_equal(self, *args): + + equal = all([len(a) == len(args[0]) for a in args]) + + for p1, p2 in zip(*args): + equal &= np.array_equal(p1.vertices, p2.vertices) + equal &= np.array_equal(p1.codes, p2.codes) + return equal + + +class TestRelationalPlotter(Helpers): + + def test_wide_df_variables(self, wide_df): + + p = _RelationalPlotter() + p.assign_variables(data=wide_df) + assert p.input_format == "wide" + assert list(p.variables) == ["x", "y", "hue", "style"] + assert len(p.plot_data) == np.product(wide_df.shape) + + x = p.plot_data["x"] + expected_x = np.tile(wide_df.index, wide_df.shape[1]) + assert_array_equal(x, expected_x) + + y = p.plot_data["y"] + expected_y = wide_df.values.ravel(order="f") + assert_array_equal(y, expected_y) + + hue = p.plot_data["hue"] + expected_hue = np.repeat(wide_df.columns.values, wide_df.shape[0]) + assert_array_equal(hue, expected_hue) + + style = p.plot_data["style"] + expected_style = expected_hue + assert_array_equal(style, expected_style) + + assert p.variables["x"] == wide_df.index.name + assert p.variables["y"] is None + assert p.variables["hue"] == wide_df.columns.name + assert p.variables["style"] == wide_df.columns.name + + def test_wide_df_with_nonnumeric_variables(self, long_df): + + p = _RelationalPlotter() + p.assign_variables(data=long_df) + assert p.input_format == "wide" + assert list(p.variables) == ["x", "y", "hue", "style"] + + numeric_df = long_df.select_dtypes("number") + + assert len(p.plot_data) == np.product(numeric_df.shape) + + x = p.plot_data["x"] + expected_x = np.tile(numeric_df.index, numeric_df.shape[1]) + assert_array_equal(x, expected_x) + + y = p.plot_data["y"] + expected_y = numeric_df.values.ravel(order="f") + assert_array_equal(y, expected_y) + + hue = p.plot_data["hue"] + expected_hue = np.repeat( + numeric_df.columns.values, numeric_df.shape[0] + ) + assert_array_equal(hue, expected_hue) + + style = p.plot_data["style"] + expected_style = expected_hue + assert_array_equal(style, expected_style) + + assert p.variables["x"] == numeric_df.index.name + assert p.variables["y"] is None + assert p.variables["hue"] == numeric_df.columns.name + assert p.variables["style"] == numeric_df.columns.name + + def test_wide_array_variables(self, wide_array): + + p = _RelationalPlotter() + p.assign_variables(data=wide_array) + assert p.input_format == "wide" + assert list(p.variables) == ["x", "y", "hue", "style"] + assert len(p.plot_data) == np.product(wide_array.shape) + + nrow, ncol = wide_array.shape + + x = p.plot_data["x"] + expected_x = np.tile(np.arange(nrow), ncol) + assert_array_equal(x, expected_x) + + y = p.plot_data["y"] + expected_y = wide_array.ravel(order="f") + assert_array_equal(y, expected_y) + + hue = p.plot_data["hue"] + expected_hue = np.repeat(np.arange(ncol), nrow) + assert_array_equal(hue, expected_hue) + + style = p.plot_data["style"] + expected_style = expected_hue + assert_array_equal(style, expected_style) + + assert p.variables["x"] is None + assert p.variables["y"] is None + assert p.variables["hue"] is None + assert p.variables["style"] is None + + def test_flat_array_variables(self, flat_array): + + p = _RelationalPlotter() + p.assign_variables(data=flat_array) + assert p.input_format == "wide" + assert list(p.variables) == ["x", "y"] + assert len(p.plot_data) == np.product(flat_array.shape) + + x = p.plot_data["x"] + expected_x = np.arange(flat_array.shape[0]) + assert_array_equal(x, expected_x) + + y = p.plot_data["y"] + expected_y = flat_array + assert_array_equal(y, expected_y) + + assert p.variables["x"] is None + assert p.variables["y"] is None + + def test_flat_list_variables(self, flat_list): + + p = _RelationalPlotter() + p.assign_variables(data=flat_list) + assert p.input_format == "wide" + assert list(p.variables) == ["x", "y"] + assert len(p.plot_data) == len(flat_list) + + x = p.plot_data["x"] + expected_x = np.arange(len(flat_list)) + assert_array_equal(x, expected_x) + + y = p.plot_data["y"] + expected_y = flat_list + assert_array_equal(y, expected_y) + + assert p.variables["x"] is None + assert p.variables["y"] is None + + def test_flat_series_variables(self, flat_series): + + p = _RelationalPlotter() + p.assign_variables(data=flat_series) + assert p.input_format == "wide" + assert list(p.variables) == ["x", "y"] + assert len(p.plot_data) == len(flat_series) + + x = p.plot_data["x"] + expected_x = flat_series.index + assert_array_equal(x, expected_x) + + y = p.plot_data["y"] + expected_y = flat_series + assert_array_equal(y, expected_y) + + assert p.variables["x"] is flat_series.index.name + assert p.variables["y"] is flat_series.name + + def test_wide_list_of_series_variables(self, wide_list_of_series): + + p = _RelationalPlotter() + p.assign_variables(data=wide_list_of_series) + assert p.input_format == "wide" + assert list(p.variables) == ["x", "y", "hue", "style"] + + chunks = len(wide_list_of_series) + chunk_size = max(len(l) for l in wide_list_of_series) + + assert len(p.plot_data) == chunks * chunk_size + + index_union = np.unique( + np.concatenate([s.index for s in wide_list_of_series]) + ) + + x = p.plot_data["x"] + expected_x = np.tile(index_union, chunks) + assert_array_equal(x, expected_x) + + y = p.plot_data["y"] + expected_y = np.concatenate([ + s.reindex(index_union) for s in wide_list_of_series + ]) + assert_array_equal(y, expected_y) + + hue = p.plot_data["hue"] + series_names = [s.name for s in wide_list_of_series] + expected_hue = np.repeat(series_names, chunk_size) + assert_array_equal(hue, expected_hue) + + style = p.plot_data["style"] + expected_style = expected_hue + assert_array_equal(style, expected_style) + + assert p.variables["x"] is None + assert p.variables["y"] is None + assert p.variables["hue"] is None + assert p.variables["style"] is None + + def test_wide_list_of_arrays_variables(self, wide_list_of_arrays): + + p = _RelationalPlotter() + p.assign_variables(data=wide_list_of_arrays) + assert p.input_format == "wide" + assert list(p.variables) == ["x", "y", "hue", "style"] + + chunks = len(wide_list_of_arrays) + chunk_size = max(len(l) for l in wide_list_of_arrays) + + assert len(p.plot_data) == chunks * chunk_size + + x = p.plot_data["x"] + expected_x = np.tile(np.arange(chunk_size), chunks) + assert_array_equal(x, expected_x) + + y = p.plot_data["y"].dropna() + expected_y = np.concatenate(wide_list_of_arrays) + assert_array_equal(y, expected_y) + + hue = p.plot_data["hue"] + expected_hue = np.repeat(np.arange(chunks), chunk_size) + assert_array_equal(hue, expected_hue) + + style = p.plot_data["style"] + expected_style = expected_hue + assert_array_equal(style, expected_style) + + assert p.variables["x"] is None + assert p.variables["y"] is None + assert p.variables["hue"] is None + assert p.variables["style"] is None + + def test_wide_list_of_list_variables(self, wide_list_of_lists): + + p = _RelationalPlotter() + p.assign_variables(data=wide_list_of_lists) + assert p.input_format == "wide" + assert list(p.variables) == ["x", "y", "hue", "style"] + + chunks = len(wide_list_of_lists) + chunk_size = max(len(l) for l in wide_list_of_lists) + + assert len(p.plot_data) == chunks * chunk_size + + x = p.plot_data["x"] + expected_x = np.tile(np.arange(chunk_size), chunks) + assert_array_equal(x, expected_x) + + y = p.plot_data["y"].dropna() + expected_y = np.concatenate(wide_list_of_lists) + assert_array_equal(y, expected_y) + + hue = p.plot_data["hue"] + expected_hue = np.repeat(np.arange(chunks), chunk_size) + assert_array_equal(hue, expected_hue) + + style = p.plot_data["style"] + expected_style = expected_hue + assert_array_equal(style, expected_style) + + assert p.variables["x"] is None + assert p.variables["y"] is None + assert p.variables["hue"] is None + assert p.variables["style"] is None + + def test_wide_dict_of_series_variables(self, wide_dict_of_series): + + p = _RelationalPlotter() + p.assign_variables(data=wide_dict_of_series) + assert p.input_format == "wide" + assert list(p.variables) == ["x", "y", "hue", "style"] + + chunks = len(wide_dict_of_series) + chunk_size = max(len(l) for l in wide_dict_of_series.values()) + + assert len(p.plot_data) == chunks * chunk_size + + x = p.plot_data["x"] + expected_x = np.tile(np.arange(chunk_size), chunks) + assert_array_equal(x, expected_x) + + y = p.plot_data["y"].dropna() + expected_y = np.concatenate(list(wide_dict_of_series.values())) + assert_array_equal(y, expected_y) + + hue = p.plot_data["hue"] + expected_hue = np.repeat(list(wide_dict_of_series), chunk_size) + assert_array_equal(hue, expected_hue) + + style = p.plot_data["style"] + expected_style = expected_hue + assert_array_equal(style, expected_style) + + assert p.variables["x"] is None + assert p.variables["y"] is None + assert p.variables["hue"] is None + assert p.variables["style"] is None + + def test_wide_dict_of_arrays_variables(self, wide_dict_of_arrays): + + p = _RelationalPlotter() + p.assign_variables(data=wide_dict_of_arrays) + assert p.input_format == "wide" + assert list(p.variables) == ["x", "y", "hue", "style"] + + chunks = len(wide_dict_of_arrays) + chunk_size = max(len(l) for l in wide_dict_of_arrays.values()) + + assert len(p.plot_data) == chunks * chunk_size + + x = p.plot_data["x"] + expected_x = np.tile(np.arange(chunk_size), chunks) + assert_array_equal(x, expected_x) + + y = p.plot_data["y"].dropna() + expected_y = np.concatenate(list(wide_dict_of_arrays.values())) + assert_array_equal(y, expected_y) + + hue = p.plot_data["hue"] + expected_hue = np.repeat(list(wide_dict_of_arrays), chunk_size) + assert_array_equal(hue, expected_hue) + + style = p.plot_data["style"] + expected_style = expected_hue + assert_array_equal(style, expected_style) + + assert p.variables["x"] is None + assert p.variables["y"] is None + assert p.variables["hue"] is None + assert p.variables["style"] is None + + def test_wide_dict_of_lists_variables(self, wide_dict_of_lists): + + p = _RelationalPlotter() + p.assign_variables(data=wide_dict_of_lists) + assert p.input_format == "wide" + assert list(p.variables) == ["x", "y", "hue", "style"] + + chunks = len(wide_dict_of_lists) + chunk_size = max(len(l) for l in wide_dict_of_lists.values()) + + assert len(p.plot_data) == chunks * chunk_size + + x = p.plot_data["x"] + expected_x = np.tile(np.arange(chunk_size), chunks) + assert_array_equal(x, expected_x) + + y = p.plot_data["y"].dropna() + expected_y = np.concatenate(list(wide_dict_of_lists.values())) + assert_array_equal(y, expected_y) + + hue = p.plot_data["hue"] + expected_hue = np.repeat(list(wide_dict_of_lists), chunk_size) + assert_array_equal(hue, expected_hue) + + style = p.plot_data["style"] + expected_style = expected_hue + assert_array_equal(style, expected_style) + + assert p.variables["x"] is None + assert p.variables["y"] is None + assert p.variables["hue"] is None + assert p.variables["style"] is None + + def test_long_df(self, long_df, long_semantics): + + p = _RelationalPlotter(data=long_df, variables=long_semantics) + assert p.input_format == "long" + assert p.variables == long_semantics + + for key, val in long_semantics.items(): + assert_array_equal(p.plot_data[key], long_df[val]) + + def test_long_df_with_index(self, long_df, long_semantics): + + p = _RelationalPlotter( + data=long_df.set_index("a"), + variables=long_semantics, + ) + assert p.input_format == "long" + assert p.variables == long_semantics + + for key, val in long_semantics.items(): + assert_array_equal(p.plot_data[key], long_df[val]) + + def test_long_df_with_multiindex(self, long_df, long_semantics): + + p = _RelationalPlotter( + data=long_df.set_index(["a", "x"]), + variables=long_semantics, + ) + assert p.input_format == "long" + assert p.variables == long_semantics + + for key, val in long_semantics.items(): + assert_array_equal(p.plot_data[key], long_df[val]) + + def test_long_dict(self, long_dict, long_semantics): + + p = _RelationalPlotter( + data=long_dict, + variables=long_semantics, + ) + assert p.input_format == "long" + assert p.variables == long_semantics + + for key, val in long_semantics.items(): + assert_array_equal(p.plot_data[key], pd.Series(long_dict[val])) + + @pytest.mark.parametrize( + "vector_type", + ["series", "numpy", "list"], + ) + def test_long_vectors(self, long_df, long_semantics, vector_type): + + variables = {key: long_df[val] for key, val in long_semantics.items()} + if vector_type == "numpy": + # Requires pandas >= 0.24 + # {key: val.to_numpy() for key, val in variables.items()} + variables = { + key: np.asarray(val) for key, val in variables.items() + } + elif vector_type == "list": + # Requires pandas >= 0.24 + # {key: val.to_list() for key, val in variables.items()} + variables = { + key: val.tolist() for key, val in variables.items() + } + + p = _RelationalPlotter(variables=variables) + assert p.input_format == "long" + + assert list(p.variables) == list(long_semantics) + if vector_type == "series": + assert p.variables == long_semantics + + for key, val in long_semantics.items(): + assert_array_equal(p.plot_data[key], long_df[val]) + + def test_long_undefined_variables(self, long_df): + + p = _RelationalPlotter() + + with pytest.raises(ValueError): + p.assign_variables( + data=long_df, variables=dict(x="not_in_df"), + ) + + with pytest.raises(ValueError): + p.assign_variables( + data=long_df, variables=dict(x="x", y="not_in_df"), + ) + + with pytest.raises(ValueError): + p.assign_variables( + data=long_df, variables=dict(x="x", y="y", hue="not_in_df"), + ) + + @pytest.mark.parametrize( + "arg", [[], np.array([]), pd.DataFrame()], + ) + def test_empty_data_input(self, arg): + + p = _RelationalPlotter(data=arg) + assert not p.variables + + if not isinstance(arg, pd.DataFrame): + p = _RelationalPlotter(variables=dict(x=arg, y=arg)) + assert not p.variables + + def test_units(self, repeated_df): + + p = _RelationalPlotter( + data=repeated_df, + variables=dict(x="x", y="y", units="u"), + ) + assert_array_equal(p.plot_data["units"], repeated_df["u"]) + + def test_relplot_simple(self, long_df): + + g = relplot(data=long_df, x="x", y="y", kind="scatter") + x, y = g.ax.collections[0].get_offsets().T + assert_array_equal(x, long_df["x"]) + assert_array_equal(y, long_df["y"]) + + g = relplot(data=long_df, x="x", y="y", kind="line") + x, y = g.ax.lines[0].get_xydata().T + expected = long_df.groupby("x").y.mean() + assert_array_equal(x, expected.index) + assert y == pytest.approx(expected.values) + + with pytest.raises(ValueError): + g = relplot(data=long_df, x="x", y="y", kind="not_a_kind") + + def test_relplot_complex(self, long_df): + + for sem in ["hue", "size", "style"]: + g = relplot(data=long_df, x="x", y="y", **{sem: "a"}) + x, y = g.ax.collections[0].get_offsets().T + assert_array_equal(x, long_df["x"]) + assert_array_equal(y, long_df["y"]) + + for sem in ["hue", "size", "style"]: + g = relplot( + data=long_df, x="x", y="y", col="c", **{sem: "a"} + ) + grouped = long_df.groupby("c") + for (_, grp_df), ax in zip(grouped, g.axes.flat): + x, y = ax.collections[0].get_offsets().T + assert_array_equal(x, grp_df["x"]) + assert_array_equal(y, grp_df["y"]) + + for sem in ["size", "style"]: + g = relplot( + data=long_df, x="x", y="y", hue="b", col="c", **{sem: "a"} + ) + grouped = long_df.groupby("c") + for (_, grp_df), ax in zip(grouped, g.axes.flat): + x, y = ax.collections[0].get_offsets().T + assert_array_equal(x, grp_df["x"]) + assert_array_equal(y, grp_df["y"]) + + for sem in ["hue", "size", "style"]: + g = relplot( + data=long_df.sort_values(["c", "b"]), + x="x", y="y", col="b", row="c", **{sem: "a"} + ) + grouped = long_df.groupby(["c", "b"]) + for (_, grp_df), ax in zip(grouped, g.axes.flat): + x, y = ax.collections[0].get_offsets().T + assert_array_equal(x, grp_df["x"]) + assert_array_equal(y, grp_df["y"]) + + @pytest.mark.parametrize( + "vector_type", + ["series", "numpy", "list"], + ) + def test_relplot_vectors(self, long_df, vector_type): + + semantics = dict(x="x", y="y", hue="f", col="c") + kws = {key: long_df[val] for key, val in semantics.items()} + g = relplot(data=long_df, **kws) + grouped = long_df.groupby("c") + for (_, grp_df), ax in zip(grouped, g.axes.flat): + x, y = ax.collections[0].get_offsets().T + assert_array_equal(x, grp_df["x"]) + assert_array_equal(y, grp_df["y"]) + + def test_relplot_wide(self, wide_df): + + g = relplot(data=wide_df) + x, y = g.ax.collections[0].get_offsets().T + assert_array_equal(y, wide_df.values.T.ravel()) + + def test_relplot_hues(self, long_df): + + palette = ["r", "b", "g"] + g = relplot( + x="x", y="y", hue="a", style="b", col="c", + palette=palette, data=long_df + ) + + palette = dict(zip(long_df["a"].unique(), palette)) + grouped = long_df.groupby("c") + for (_, grp_df), ax in zip(grouped, g.axes.flat): + points = ax.collections[0] + expected_hues = [palette[val] for val in grp_df["a"]] + assert same_color(points.get_facecolors(), expected_hues) + + def test_relplot_sizes(self, long_df): + + sizes = [5, 12, 7] + g = relplot( + data=long_df, + x="x", y="y", size="a", hue="b", col="c", + sizes=sizes, + ) + + sizes = dict(zip(long_df["a"].unique(), sizes)) + grouped = long_df.groupby("c") + for (_, grp_df), ax in zip(grouped, g.axes.flat): + points = ax.collections[0] + expected_sizes = [sizes[val] for val in grp_df["a"]] + assert_array_equal(points.get_sizes(), expected_sizes) + + def test_relplot_styles(self, long_df): + + markers = ["o", "d", "s"] + g = relplot( + data=long_df, + x="x", y="y", style="a", hue="b", col="c", + markers=markers, + ) + + paths = [] + for m in markers: + m = mpl.markers.MarkerStyle(m) + paths.append(m.get_path().transformed(m.get_transform())) + paths = dict(zip(long_df["a"].unique(), paths)) + + grouped = long_df.groupby("c") + for (_, grp_df), ax in zip(grouped, g.axes.flat): + points = ax.collections[0] + expected_paths = [paths[val] for val in grp_df["a"]] + assert self.paths_equal(points.get_paths(), expected_paths) + + def test_relplot_stringy_numerics(self, long_df): + + long_df["x_str"] = long_df["x"].astype(str) + + g = relplot(data=long_df, x="x", y="y", hue="x_str") + points = g.ax.collections[0] + xys = points.get_offsets() + mask = np.ma.getmask(xys) + assert not mask.any() + assert_array_equal(xys, long_df[["x", "y"]]) + + g = relplot(data=long_df, x="x", y="y", size="x_str") + points = g.ax.collections[0] + xys = points.get_offsets() + mask = np.ma.getmask(xys) + assert not mask.any() + assert_array_equal(xys, long_df[["x", "y"]]) + + def test_relplot_legend(self, long_df): + + g = relplot(data=long_df, x="x", y="y") + assert g._legend is None + + g = relplot(data=long_df, x="x", y="y", hue="a") + texts = [t.get_text() for t in g._legend.texts] + expected_texts = long_df["a"].unique() + assert_array_equal(texts, expected_texts) + + g = relplot(data=long_df, x="x", y="y", hue="s", size="s") + texts = [t.get_text() for t in g._legend.texts] + assert_array_equal(texts, np.sort(texts)) + + g = relplot(data=long_df, x="x", y="y", hue="a", legend=False) + assert g._legend is None + + palette = color_palette("deep", len(long_df["b"].unique())) + a_like_b = dict(zip(long_df["a"].unique(), long_df["b"].unique())) + long_df["a_like_b"] = long_df["a"].map(a_like_b) + g = relplot( + data=long_df, + x="x", y="y", hue="b", style="a_like_b", + palette=palette, kind="line", estimator=None, + ) + lines = g._legend.get_lines()[1:] # Chop off title dummy + for line, color in zip(lines, palette): + assert line.get_color() == color + + def test_relplot_data(self, long_df): + + g = relplot( + data=long_df.to_dict(orient="list"), + x="x", + y=long_df["y"].rename("y_var"), + hue=np.asarray(long_df["a"]), + col="c", + ) + expected_cols = set(long_df.columns.tolist() + ["_hue_", "y_var"]) + assert set(g.data.columns) == expected_cols + assert_array_equal(g.data["y_var"], long_df["y"]) + assert_array_equal(g.data["_hue_"], long_df["a"]) + + def test_facet_variable_collision(self, long_df): + + # https://github.com/mwaskom/seaborn/issues/2488 + col_data = long_df["c"] + long_df = long_df.assign(size=col_data) + + g = relplot( + data=long_df, + x="x", y="y", col="size", + ) + assert g.axes.shape == (1, len(col_data.unique())) + + def test_ax_kwarg_removal(self, long_df): + + f, ax = plt.subplots() + with pytest.warns(UserWarning): + g = relplot(data=long_df, x="x", y="y", ax=ax) + assert len(ax.collections) == 0 + assert len(g.ax.collections) > 0 + + +class TestLinePlotter(Helpers): + + def test_aggregate(self, long_df): + + p = _LinePlotter(data=long_df, variables=dict(x="x", y="y")) + p.n_boot = 10000 + p.sort = False + + x = pd.Series(np.tile([1, 2], 100)) + y = pd.Series(np.random.randn(200)) + y_mean = y.groupby(x).mean() + + def sem(x): + return np.std(x) / np.sqrt(len(x)) + + y_sem = y.groupby(x).apply(sem) + y_cis = pd.DataFrame(dict(low=y_mean - y_sem, + high=y_mean + y_sem), + columns=["low", "high"]) + + p.ci = 68 + p.estimator = "mean" + index, est, cis = p.aggregate(y, x) + assert_array_equal(index.values, x.unique()) + assert est.index.equals(index) + assert est.values == pytest.approx(y_mean.values) + assert cis.values == pytest.approx(y_cis.values, 4) + assert list(cis.columns) == ["low", "high"] + + p.estimator = np.mean + index, est, cis = p.aggregate(y, x) + assert_array_equal(index.values, x.unique()) + assert est.index.equals(index) + assert est.values == pytest.approx(y_mean.values) + assert cis.values == pytest.approx(y_cis.values, 4) + assert list(cis.columns) == ["low", "high"] + + p.seed = 0 + _, _, ci1 = p.aggregate(y, x) + _, _, ci2 = p.aggregate(y, x) + assert_array_equal(ci1, ci2) + + y_std = y.groupby(x).std() + y_cis = pd.DataFrame(dict(low=y_mean - y_std, + high=y_mean + y_std), + columns=["low", "high"]) + + p.ci = "sd" + index, est, cis = p.aggregate(y, x) + assert_array_equal(index.values, x.unique()) + assert est.index.equals(index) + assert est.values == pytest.approx(y_mean.values) + assert cis.values == pytest.approx(y_cis.values) + assert list(cis.columns) == ["low", "high"] + + p.ci = None + index, est, cis = p.aggregate(y, x) + assert cis is None + + p.ci = 68 + x, y = pd.Series([1, 2, 3]), pd.Series([4, 3, 2]) + index, est, cis = p.aggregate(y, x) + assert_array_equal(index.values, x) + assert_array_equal(est.values, y) + assert cis is None + + x, y = pd.Series([1, 1, 2]), pd.Series([2, 3, 4]) + index, est, cis = p.aggregate(y, x) + assert cis.loc[2].isnull().all() + + p = _LinePlotter(data=long_df, variables=dict(x="x", y="y")) + p.estimator = "mean" + p.n_boot = 100 + p.ci = 95 + x = pd.Categorical(["a", "b", "a", "b"], ["a", "b", "c"]) + y = pd.Series([1, 1, 2, 2]) + with warnings.catch_warnings(): + warnings.simplefilter("error", RuntimeWarning) + index, est, cis = p.aggregate(y, x) + assert cis.loc[["c"]].isnull().all().all() + + def test_legend_data(self, long_df): + + f, ax = plt.subplots() + + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y"), + legend="full" + ) + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + assert handles == [] + + # -- + + ax.clear() + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a"), + legend="full", + ) + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + colors = [h.get_color() for h in handles] + assert labels == p._hue_map.levels + assert colors == p._hue_map(p._hue_map.levels) + + # -- + + ax.clear() + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a", style="a"), + legend="full", + ) + p.map_style(markers=True) + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + colors = [h.get_color() for h in handles] + markers = [h.get_marker() for h in handles] + assert labels == p._hue_map.levels + assert labels == p._style_map.levels + assert colors == p._hue_map(p._hue_map.levels) + assert markers == p._style_map(p._style_map.levels, "marker") + + # -- + + ax.clear() + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a", style="b"), + legend="full", + ) + p.map_style(markers=True) + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + colors = [h.get_color() for h in handles] + markers = [h.get_marker() for h in handles] + expected_labels = ( + ["a"] + + p._hue_map.levels + + ["b"] + p._style_map.levels + ) + expected_colors = ( + ["w"] + p._hue_map(p._hue_map.levels) + + ["w"] + [".2" for _ in p._style_map.levels] + ) + expected_markers = ( + [""] + ["None" for _ in p._hue_map.levels] + + [""] + p._style_map(p._style_map.levels, "marker") + ) + assert labels == expected_labels + assert colors == expected_colors + assert markers == expected_markers + + # -- + + ax.clear() + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a", size="a"), + legend="full" + ) + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + colors = [h.get_color() for h in handles] + widths = [h.get_linewidth() for h in handles] + assert labels == p._hue_map.levels + assert labels == p._size_map.levels + assert colors == p._hue_map(p._hue_map.levels) + assert widths == p._size_map(p._size_map.levels) + + # -- + + x, y = np.random.randn(2, 40) + z = np.tile(np.arange(20), 2) + + p = _LinePlotter(variables=dict(x=x, y=y, hue=z)) + + ax.clear() + p.legend = "full" + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + assert labels == [str(l) for l in p._hue_map.levels] + + ax.clear() + p.legend = "brief" + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + assert len(labels) < len(p._hue_map.levels) + + p = _LinePlotter(variables=dict(x=x, y=y, size=z)) + + ax.clear() + p.legend = "full" + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + assert labels == [str(l) for l in p._size_map.levels] + + ax.clear() + p.legend = "brief" + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + assert len(labels) < len(p._size_map.levels) + + ax.clear() + p.legend = "auto" + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + assert len(labels) < len(p._size_map.levels) + + ax.clear() + p.legend = True + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + assert len(labels) < len(p._size_map.levels) + + ax.clear() + p.legend = "bad_value" + with pytest.raises(ValueError): + p.add_legend_data(ax) + + ax.clear() + p = _LinePlotter( + variables=dict(x=x, y=y, hue=z + 1), + legend="brief" + ) + p.map_hue(norm=mpl.colors.LogNorm()), + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + assert float(labels[1]) / float(labels[0]) == 10 + + ax.clear() + p = _LinePlotter( + variables=dict(x=x, y=y, hue=z % 2), + legend="auto" + ) + p.map_hue(norm=mpl.colors.LogNorm()), + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + assert labels == ["0", "1"] + + ax.clear() + p = _LinePlotter( + variables=dict(x=x, y=y, size=z + 1), + legend="brief" + ) + p.map_size(norm=mpl.colors.LogNorm()) + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + assert float(labels[1]) / float(labels[0]) == 10 + + ax.clear() + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y", hue="f"), + legend="brief", + ) + p.add_legend_data(ax) + expected_labels = ['0.20', '0.22', '0.24', '0.26', '0.28'] + handles, labels = ax.get_legend_handles_labels() + assert labels == expected_labels + + ax.clear() + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y", size="f"), + legend="brief", + ) + p.add_legend_data(ax) + expected_levels = ['0.20', '0.22', '0.24', '0.26', '0.28'] + handles, labels = ax.get_legend_handles_labels() + assert labels == expected_levels + + def test_plot(self, long_df, repeated_df): + + f, ax = plt.subplots() + + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y"), + sort=False, + estimator=None + ) + p.plot(ax, {}) + line, = ax.lines + assert_array_equal(line.get_xdata(), long_df.x.values) + assert_array_equal(line.get_ydata(), long_df.y.values) + + ax.clear() + p.plot(ax, {"color": "k", "label": "test"}) + line, = ax.lines + assert line.get_color() == "k" + assert line.get_label() == "test" + + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y"), + sort=True, estimator=None + ) + + ax.clear() + p.plot(ax, {}) + line, = ax.lines + sorted_data = long_df.sort_values(["x", "y"]) + assert_array_equal(line.get_xdata(), sorted_data.x.values) + assert_array_equal(line.get_ydata(), sorted_data.y.values) + + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a"), + ) + + ax.clear() + p.plot(ax, {}) + assert len(ax.lines) == len(p._hue_map.levels) + for line, level in zip(ax.lines, p._hue_map.levels): + assert line.get_color() == p._hue_map(level) + + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y", size="a"), + ) + + ax.clear() + p.plot(ax, {}) + assert len(ax.lines) == len(p._size_map.levels) + for line, level in zip(ax.lines, p._size_map.levels): + assert line.get_linewidth() == p._size_map(level) + + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a", style="a"), + ) + p.map_style(markers=True) + + ax.clear() + p.plot(ax, {}) + assert len(ax.lines) == len(p._hue_map.levels) + assert len(ax.lines) == len(p._style_map.levels) + for line, level in zip(ax.lines, p._hue_map.levels): + assert line.get_color() == p._hue_map(level) + assert line.get_marker() == p._style_map(level, "marker") + + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a", style="b"), + ) + p.map_style(markers=True) + + ax.clear() + p.plot(ax, {}) + levels = product(p._hue_map.levels, p._style_map.levels) + expected_line_count = len(p._hue_map.levels) * len(p._style_map.levels) + assert len(ax.lines) == expected_line_count + for line, (hue, style) in zip(ax.lines, levels): + assert line.get_color() == p._hue_map(hue) + assert line.get_marker() == p._style_map(style, "marker") + + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y"), + estimator="mean", err_style="band", ci="sd", sort=True + ) + + ax.clear() + p.plot(ax, {}) + line, = ax.lines + expected_data = long_df.groupby("x").y.mean() + assert_array_equal(line.get_xdata(), expected_data.index.values) + assert np.allclose(line.get_ydata(), expected_data.values) + assert len(ax.collections) == 1 + + # Test that nans do not propagate to means or CIs + + p = _LinePlotter( + variables=dict( + x=[1, 1, 1, 2, 2, 2, 3, 3, 3], + y=[1, 2, 3, 3, np.nan, 5, 4, 5, 6], + ), + estimator="mean", err_style="band", ci=95, n_boot=100, sort=True, + ) + ax.clear() + p.plot(ax, {}) + line, = ax.lines + assert line.get_xdata().tolist() == [1, 2, 3] + err_band = ax.collections[0].get_paths() + assert len(err_band) == 1 + assert len(err_band[0].vertices) == 9 + + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a"), + estimator="mean", err_style="band", ci="sd" + ) + + ax.clear() + p.plot(ax, {}) + assert len(ax.lines) == len(ax.collections) == len(p._hue_map.levels) + for c in ax.collections: + assert isinstance(c, mpl.collections.PolyCollection) + + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a"), + estimator="mean", err_style="bars", ci="sd" + ) + + ax.clear() + p.plot(ax, {}) + n_lines = len(ax.lines) + assert n_lines / 2 == len(ax.collections) == len(p._hue_map.levels) + assert len(ax.collections) == len(p._hue_map.levels) + for c in ax.collections: + assert isinstance(c, mpl.collections.LineCollection) + + p = _LinePlotter( + data=repeated_df, + variables=dict(x="x", y="y", units="u"), + estimator=None + ) + + ax.clear() + p.plot(ax, {}) + n_units = len(repeated_df["u"].unique()) + assert len(ax.lines) == n_units + + p = _LinePlotter( + data=repeated_df, + variables=dict(x="x", y="y", hue="a", units="u"), + estimator=None + ) + + ax.clear() + p.plot(ax, {}) + n_units *= len(repeated_df["a"].unique()) + assert len(ax.lines) == n_units + + p.estimator = "mean" + with pytest.raises(ValueError): + p.plot(ax, {}) + + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a"), + err_style="band", err_kws={"alpha": .5}, + ) + + ax.clear() + p.plot(ax, {}) + for band in ax.collections: + assert band.get_alpha() == .5 + + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a"), + err_style="bars", err_kws={"elinewidth": 2}, + ) + + ax.clear() + p.plot(ax, {}) + for lines in ax.collections: + assert lines.get_linestyles() == 2 + + p.err_style = "invalid" + with pytest.raises(ValueError): + p.plot(ax, {}) + + x_str = long_df["x"].astype(str) + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y", hue=x_str), + ) + ax.clear() + p.plot(ax, {}) + + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y", size=x_str), + ) + ax.clear() + p.plot(ax, {}) + + def test_axis_labels(self, long_df): + + f, (ax1, ax2) = plt.subplots(1, 2, sharey=True) + + p = _LinePlotter( + data=long_df, + variables=dict(x="x", y="y"), + ) + + p.plot(ax1, {}) + assert ax1.get_xlabel() == "x" + assert ax1.get_ylabel() == "y" + + p.plot(ax2, {}) + assert ax2.get_xlabel() == "x" + assert ax2.get_ylabel() == "y" + assert not ax2.yaxis.label.get_visible() + + def test_matplotlib_kwargs(self, long_df): + + kws = { + "linestyle": "--", + "linewidth": 3, + "color": (1, .5, .2), + "markeredgecolor": (.2, .5, .2), + "markeredgewidth": 1, + } + ax = lineplot(data=long_df, x="x", y="y", **kws) + + line, *_ = ax.lines + for key, val in kws.items(): + plot_val = getattr(line, f"get_{key}")() + assert plot_val == val + + def test_lineplot_axes(self, wide_df): + + f1, ax1 = plt.subplots() + f2, ax2 = plt.subplots() + + ax = lineplot(data=wide_df) + assert ax is ax2 + + ax = lineplot(data=wide_df, ax=ax1) + assert ax is ax1 + + def test_lineplot_vs_relplot(self, long_df, long_semantics): + + ax = lineplot(data=long_df, **long_semantics) + g = relplot(data=long_df, kind="line", **long_semantics) + + lin_lines = ax.lines + rel_lines = g.ax.lines + + for l1, l2 in zip(lin_lines, rel_lines): + assert_array_equal(l1.get_xydata(), l2.get_xydata()) + assert same_color(l1.get_color(), l2.get_color()) + assert l1.get_linewidth() == l2.get_linewidth() + assert l1.get_linestyle() == l2.get_linestyle() + + def test_lineplot_smoke( + self, + wide_df, wide_array, + wide_list_of_series, wide_list_of_arrays, wide_list_of_lists, + flat_array, flat_series, flat_list, + long_df, missing_df, object_df + ): + + f, ax = plt.subplots() + + lineplot(x=[], y=[]) + ax.clear() + + lineplot(data=wide_df) + ax.clear() + + lineplot(data=wide_array) + ax.clear() + + lineplot(data=wide_list_of_series) + ax.clear() + + lineplot(data=wide_list_of_arrays) + ax.clear() + + lineplot(data=wide_list_of_lists) + ax.clear() + + lineplot(data=flat_series) + ax.clear() + + lineplot(data=flat_array) + ax.clear() + + lineplot(data=flat_list) + ax.clear() + + lineplot(x="x", y="y", data=long_df) + ax.clear() + + lineplot(x=long_df.x, y=long_df.y) + ax.clear() + + lineplot(x=long_df.x, y="y", data=long_df) + ax.clear() + + lineplot(x="x", y=long_df.y.values, data=long_df) + ax.clear() + + lineplot(x="x", y="t", data=long_df) + ax.clear() + + lineplot(x="x", y="y", hue="a", data=long_df) + ax.clear() + + lineplot(x="x", y="y", hue="a", style="a", data=long_df) + ax.clear() + + lineplot(x="x", y="y", hue="a", style="b", data=long_df) + ax.clear() + + lineplot(x="x", y="y", hue="a", style="a", data=missing_df) + ax.clear() + + lineplot(x="x", y="y", hue="a", style="b", data=missing_df) + ax.clear() + + lineplot(x="x", y="y", hue="a", size="a", data=long_df) + ax.clear() + + lineplot(x="x", y="y", hue="a", size="s", data=long_df) + ax.clear() + + lineplot(x="x", y="y", hue="a", size="a", data=missing_df) + ax.clear() + + lineplot(x="x", y="y", hue="a", size="s", data=missing_df) + ax.clear() + + lineplot(x="x", y="y", hue="f", data=object_df) + ax.clear() + + lineplot(x="x", y="y", hue="c", size="f", data=object_df) + ax.clear() + + lineplot(x="x", y="y", hue="f", size="s", data=object_df) + ax.clear() + + +class TestScatterPlotter(Helpers): + + def test_legend_data(self, long_df): + + m = mpl.markers.MarkerStyle("o") + default_mark = m.get_path().transformed(m.get_transform()) + + m = mpl.markers.MarkerStyle("") + null = m.get_path().transformed(m.get_transform()) + + f, ax = plt.subplots() + + p = _ScatterPlotter( + data=long_df, + variables=dict(x="x", y="y"), + legend="full", + ) + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + assert handles == [] + + # -- + + ax.clear() + p = _ScatterPlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a"), + legend="full", + ) + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + colors = [h.get_facecolors()[0] for h in handles] + expected_colors = p._hue_map(p._hue_map.levels) + assert labels == p._hue_map.levels + assert same_color(colors, expected_colors) + + # -- + + ax.clear() + p = _ScatterPlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a", style="a"), + legend="full", + ) + p.map_style(markers=True) + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + colors = [h.get_facecolors()[0] for h in handles] + expected_colors = p._hue_map(p._hue_map.levels) + paths = [h.get_paths()[0] for h in handles] + expected_paths = p._style_map(p._style_map.levels, "path") + assert labels == p._hue_map.levels + assert labels == p._style_map.levels + assert same_color(colors, expected_colors) + assert self.paths_equal(paths, expected_paths) + + # -- + + ax.clear() + p = _ScatterPlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a", style="b"), + legend="full", + ) + p.map_style(markers=True) + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + colors = [h.get_facecolors()[0] for h in handles] + paths = [h.get_paths()[0] for h in handles] + expected_colors = ( + ["w"] + p._hue_map(p._hue_map.levels) + + ["w"] + [".2" for _ in p._style_map.levels] + ) + expected_paths = ( + [null] + [default_mark for _ in p._hue_map.levels] + + [null] + p._style_map(p._style_map.levels, "path") + ) + assert labels == ( + ["a"] + p._hue_map.levels + ["b"] + p._style_map.levels + ) + assert same_color(colors, expected_colors) + assert self.paths_equal(paths, expected_paths) + + # -- + + ax.clear() + p = _ScatterPlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a", size="a"), + legend="full" + ) + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + colors = [h.get_facecolors()[0] for h in handles] + expected_colors = p._hue_map(p._hue_map.levels) + sizes = [h.get_sizes()[0] for h in handles] + expected_sizes = p._size_map(p._size_map.levels) + assert labels == p._hue_map.levels + assert labels == p._size_map.levels + assert same_color(colors, expected_colors) + assert sizes == expected_sizes + + # -- + + ax.clear() + sizes_list = [10, 100, 200] + p = _ScatterPlotter( + data=long_df, + variables=dict(x="x", y="y", size="s"), + legend="full", + ) + p.map_size(sizes=sizes_list) + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + sizes = [h.get_sizes()[0] for h in handles] + expected_sizes = p._size_map(p._size_map.levels) + assert labels == [str(l) for l in p._size_map.levels] + assert sizes == expected_sizes + + # -- + + ax.clear() + sizes_dict = {2: 10, 4: 100, 8: 200} + p = _ScatterPlotter( + data=long_df, + variables=dict(x="x", y="y", size="s"), + legend="full" + ) + p.map_size(sizes=sizes_dict) + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + sizes = [h.get_sizes()[0] for h in handles] + expected_sizes = p._size_map(p._size_map.levels) + assert labels == [str(l) for l in p._size_map.levels] + assert sizes == expected_sizes + + # -- + + x, y = np.random.randn(2, 40) + z = np.tile(np.arange(20), 2) + + p = _ScatterPlotter( + variables=dict(x=x, y=y, hue=z), + ) + + ax.clear() + p.legend = "full" + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + assert labels == [str(l) for l in p._hue_map.levels] + + ax.clear() + p.legend = "brief" + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + assert len(labels) < len(p._hue_map.levels) + + p = _ScatterPlotter( + variables=dict(x=x, y=y, size=z), + ) + + ax.clear() + p.legend = "full" + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + assert labels == [str(l) for l in p._size_map.levels] + + ax.clear() + p.legend = "brief" + p.add_legend_data(ax) + handles, labels = ax.get_legend_handles_labels() + assert len(labels) < len(p._size_map.levels) + + ax.clear() + p.legend = "bad_value" + with pytest.raises(ValueError): + p.add_legend_data(ax) + + def test_plot(self, long_df, repeated_df): + + f, ax = plt.subplots() + + p = _ScatterPlotter(data=long_df, variables=dict(x="x", y="y")) + + p.plot(ax, {}) + points = ax.collections[0] + assert_array_equal(points.get_offsets(), long_df[["x", "y"]].values) + + ax.clear() + p.plot(ax, {"color": "k", "label": "test"}) + points = ax.collections[0] + assert same_color(points.get_facecolor(), "k") + assert points.get_label() == "test" + + p = _ScatterPlotter( + data=long_df, variables=dict(x="x", y="y", hue="a") + ) + + ax.clear() + p.plot(ax, {}) + points = ax.collections[0] + expected_colors = p._hue_map(p.plot_data["hue"]) + assert same_color(points.get_facecolors(), expected_colors) + + p = _ScatterPlotter( + data=long_df, + variables=dict(x="x", y="y", style="c"), + ) + p.map_style(markers=["+", "x"]) + + ax.clear() + color = (1, .3, .8) + p.plot(ax, {"color": color}) + points = ax.collections[0] + assert same_color(points.get_edgecolors(), [color]) + + p = _ScatterPlotter( + data=long_df, variables=dict(x="x", y="y", size="a"), + ) + + ax.clear() + p.plot(ax, {}) + points = ax.collections[0] + expected_sizes = p._size_map(p.plot_data["size"]) + assert_array_equal(points.get_sizes(), expected_sizes) + + p = _ScatterPlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a", style="a"), + ) + p.map_style(markers=True) + + ax.clear() + p.plot(ax, {}) + points = ax.collections[0] + expected_colors = p._hue_map(p.plot_data["hue"]) + expected_paths = p._style_map(p.plot_data["style"], "path") + assert same_color(points.get_facecolors(), expected_colors) + assert self.paths_equal(points.get_paths(), expected_paths) + + p = _ScatterPlotter( + data=long_df, + variables=dict(x="x", y="y", hue="a", style="b"), + ) + p.map_style(markers=True) + + ax.clear() + p.plot(ax, {}) + points = ax.collections[0] + expected_colors = p._hue_map(p.plot_data["hue"]) + expected_paths = p._style_map(p.plot_data["style"], "path") + assert same_color(points.get_facecolors(), expected_colors) + assert self.paths_equal(points.get_paths(), expected_paths) + + x_str = long_df["x"].astype(str) + p = _ScatterPlotter( + data=long_df, variables=dict(x="x", y="y", hue=x_str), + ) + ax.clear() + p.plot(ax, {}) + + p = _ScatterPlotter( + data=long_df, variables=dict(x="x", y="y", size=x_str), + ) + ax.clear() + p.plot(ax, {}) + + def test_axis_labels(self, long_df): + + f, (ax1, ax2) = plt.subplots(1, 2, sharey=True) + + p = _ScatterPlotter(data=long_df, variables=dict(x="x", y="y")) + + p.plot(ax1, {}) + assert ax1.get_xlabel() == "x" + assert ax1.get_ylabel() == "y" + + p.plot(ax2, {}) + assert ax2.get_xlabel() == "x" + assert ax2.get_ylabel() == "y" + assert not ax2.yaxis.label.get_visible() + + def test_scatterplot_axes(self, wide_df): + + f1, ax1 = plt.subplots() + f2, ax2 = plt.subplots() + + ax = scatterplot(data=wide_df) + assert ax is ax2 + + ax = scatterplot(data=wide_df, ax=ax1) + assert ax is ax1 + + def test_literal_attribute_vectors(self): + + f, ax = plt.subplots() + + x = y = [1, 2, 3] + s = [5, 10, 15] + c = [(1, 1, 0, 1), (1, 0, 1, .5), (.5, 1, 0, 1)] + + scatterplot(x=x, y=y, c=c, s=s, ax=ax) + + points, = ax.collections + + assert_array_equal(points.get_sizes().squeeze(), s) + assert_array_equal(points.get_facecolors(), c) + + def test_linewidths(self, long_df): + + f, ax = plt.subplots() + + scatterplot(data=long_df, x="x", y="y", s=10) + scatterplot(data=long_df, x="x", y="y", s=20) + points1, points2 = ax.collections + assert ( + points1.get_linewidths().item() < points2.get_linewidths().item() + ) + + ax.clear() + scatterplot(data=long_df, x="x", y="y", s=long_df["x"]) + scatterplot(data=long_df, x="x", y="y", s=long_df["x"] * 2) + points1, points2 = ax.collections + assert ( + points1.get_linewidths().item() < points2.get_linewidths().item() + ) + + ax.clear() + scatterplot(data=long_df, x="x", y="y", size=long_df["x"]) + scatterplot(data=long_df, x="x", y="y", size=long_df["x"] * 2) + points1, points2, *_ = ax.collections + assert ( + points1.get_linewidths().item() < points2.get_linewidths().item() + ) + + ax.clear() + lw = 2 + scatterplot(data=long_df, x="x", y="y", linewidth=lw) + assert ax.collections[0].get_linewidths().item() == lw + + def test_size_norm_extrapolation(self): + + # https://github.com/mwaskom/seaborn/issues/2539 + x = np.arange(0, 20, 2) + f, axs = plt.subplots(1, 2, sharex=True, sharey=True) + + slc = 5 + kws = dict(sizes=(50, 200), size_norm=(0, x.max()), legend="brief") + + scatterplot(x=x, y=x, size=x, ax=axs[0], **kws) + scatterplot(x=x[:slc], y=x[:slc], size=x[:slc], ax=axs[1], **kws) + + assert np.allclose( + axs[0].collections[0].get_sizes()[:slc], + axs[1].collections[0].get_sizes() + ) + + legends = [ax.legend_ for ax in axs] + legend_data = [ + { + label.get_text(): handle.get_sizes().item() + for label, handle in zip(legend.get_texts(), legend.legendHandles) + } for legend in legends + ] + + for key in set(legend_data[0]) & set(legend_data[1]): + if key == "y": + # At some point (circa 3.0) matplotlib auto-added pandas series + # with a valid name into the legend, which messes up this test. + # I can't track down when that was added (or removed), so let's + # just anticipate and ignore it here. + continue + assert legend_data[0][key] == legend_data[1][key] + + def test_datetime_scale(self, long_df): + + ax = scatterplot(data=long_df, x="t", y="y") + # Check that we avoid weird matplotlib default auto scaling + # https://github.com/matplotlib/matplotlib/issues/17586 + ax.get_xlim()[0] > ax.xaxis.convert_units(np.datetime64("2002-01-01")) + + def test_unfilled_marker_edgecolor_warning(self, long_df): # GH2636 + + with pytest.warns(None) as record: + scatterplot(data=long_df, x="x", y="y", marker="+") + assert not record + + def test_scatterplot_vs_relplot(self, long_df, long_semantics): + + ax = scatterplot(data=long_df, **long_semantics) + g = relplot(data=long_df, kind="scatter", **long_semantics) + + for s_pts, r_pts in zip(ax.collections, g.ax.collections): + + assert_array_equal(s_pts.get_offsets(), r_pts.get_offsets()) + assert_array_equal(s_pts.get_sizes(), r_pts.get_sizes()) + assert_array_equal(s_pts.get_facecolors(), r_pts.get_facecolors()) + assert self.paths_equal(s_pts.get_paths(), r_pts.get_paths()) + + def test_scatterplot_smoke( + self, + wide_df, wide_array, + flat_series, flat_array, flat_list, + wide_list_of_series, wide_list_of_arrays, wide_list_of_lists, + long_df, missing_df, object_df + ): + + f, ax = plt.subplots() + + scatterplot(x=[], y=[]) + ax.clear() + + scatterplot(data=wide_df) + ax.clear() + + scatterplot(data=wide_array) + ax.clear() + + scatterplot(data=wide_list_of_series) + ax.clear() + + scatterplot(data=wide_list_of_arrays) + ax.clear() + + scatterplot(data=wide_list_of_lists) + ax.clear() + + scatterplot(data=flat_series) + ax.clear() + + scatterplot(data=flat_array) + ax.clear() + + scatterplot(data=flat_list) + ax.clear() + + scatterplot(x="x", y="y", data=long_df) + ax.clear() + + scatterplot(x=long_df.x, y=long_df.y) + ax.clear() + + scatterplot(x=long_df.x, y="y", data=long_df) + ax.clear() + + scatterplot(x="x", y=long_df.y.values, data=long_df) + ax.clear() + + scatterplot(x="x", y="y", hue="a", data=long_df) + ax.clear() + + scatterplot(x="x", y="y", hue="a", style="a", data=long_df) + ax.clear() + + scatterplot(x="x", y="y", hue="a", style="b", data=long_df) + ax.clear() + + scatterplot(x="x", y="y", hue="a", style="a", data=missing_df) + ax.clear() + + scatterplot(x="x", y="y", hue="a", style="b", data=missing_df) + ax.clear() + + scatterplot(x="x", y="y", hue="a", size="a", data=long_df) + ax.clear() + + scatterplot(x="x", y="y", hue="a", size="s", data=long_df) + ax.clear() + + scatterplot(x="x", y="y", hue="a", size="a", data=missing_df) + ax.clear() + + scatterplot(x="x", y="y", hue="a", size="s", data=missing_df) + ax.clear() + + scatterplot(x="x", y="y", hue="f", data=object_df) + ax.clear() + + scatterplot(x="x", y="y", hue="c", size="f", data=object_df) + ax.clear() + + scatterplot(x="x", y="y", hue="f", size="s", data=object_df) + ax.clear() diff --git a/grplot_seaborn/tests/test_statistics.py b/grplot_seaborn/tests/test_statistics.py new file mode 100644 index 0000000..11bc7b4 --- /dev/null +++ b/grplot_seaborn/tests/test_statistics.py @@ -0,0 +1,460 @@ +import numpy as np +from scipy import integrate + +try: + import statsmodels.distributions as smdist +except ImportError: + smdist = None + +import pytest +from numpy.testing import assert_array_equal, assert_array_almost_equal + +from .._statistics import ( + KDE, + Histogram, + ECDF, +) + + +class DistributionFixtures: + + @pytest.fixture + def x(self, rng): + return rng.normal(0, 1, 100) + + @pytest.fixture + def y(self, rng): + return rng.normal(0, 5, 100) + + @pytest.fixture + def weights(self, rng): + return rng.uniform(0, 5, 100) + + +class TestKDE: + + def test_gridsize(self, rng): + + x = rng.normal(0, 3, 1000) + + n = 200 + kde = KDE(gridsize=n) + density, support = kde(x) + assert density.size == n + assert support.size == n + + def test_cut(self, rng): + + x = rng.normal(0, 3, 1000) + + kde = KDE(cut=0) + _, support = kde(x) + assert support.min() == x.min() + assert support.max() == x.max() + + cut = 2 + bw_scale = .5 + bw = x.std() * bw_scale + kde = KDE(cut=cut, bw_method=bw_scale, gridsize=1000) + _, support = kde(x) + assert support.min() == pytest.approx(x.min() - bw * cut, abs=1e-2) + assert support.max() == pytest.approx(x.max() + bw * cut, abs=1e-2) + + def test_clip(self, rng): + + x = rng.normal(0, 3, 100) + clip = -1, 1 + kde = KDE(clip=clip) + _, support = kde(x) + + assert support.min() >= clip[0] + assert support.max() <= clip[1] + + def test_density_normalization(self, rng): + + x = rng.normal(0, 3, 1000) + kde = KDE() + density, support = kde(x) + assert integrate.trapz(density, support) == pytest.approx(1, abs=1e-5) + + def test_cumulative(self, rng): + + x = rng.normal(0, 3, 1000) + kde = KDE(cumulative=True) + density, _ = kde(x) + assert density[0] == pytest.approx(0, abs=1e-5) + assert density[-1] == pytest.approx(1, abs=1e-5) + + def test_cached_support(self, rng): + + x = rng.normal(0, 3, 100) + kde = KDE() + kde.define_support(x) + _, support = kde(x[(x > -1) & (x < 1)]) + assert_array_equal(support, kde.support) + + def test_bw_method(self, rng): + + x = rng.normal(0, 3, 100) + kde1 = KDE(bw_method=.2) + kde2 = KDE(bw_method=2) + + d1, _ = kde1(x) + d2, _ = kde2(x) + + assert np.abs(np.diff(d1)).mean() > np.abs(np.diff(d2)).mean() + + def test_bw_adjust(self, rng): + + x = rng.normal(0, 3, 100) + kde1 = KDE(bw_adjust=.2) + kde2 = KDE(bw_adjust=2) + + d1, _ = kde1(x) + d2, _ = kde2(x) + + assert np.abs(np.diff(d1)).mean() > np.abs(np.diff(d2)).mean() + + def test_bivariate_grid(self, rng): + + n = 100 + x, y = rng.normal(0, 3, (2, 50)) + kde = KDE(gridsize=n) + density, (xx, yy) = kde(x, y) + + assert density.shape == (n, n) + assert xx.size == n + assert yy.size == n + + def test_bivariate_normalization(self, rng): + + x, y = rng.normal(0, 3, (2, 50)) + kde = KDE(gridsize=100) + density, (xx, yy) = kde(x, y) + + dx = xx[1] - xx[0] + dy = yy[1] - yy[0] + + total = density.sum() * (dx * dy) + assert total == pytest.approx(1, abs=1e-2) + + def test_bivariate_cumulative(self, rng): + + x, y = rng.normal(0, 3, (2, 50)) + kde = KDE(gridsize=100, cumulative=True) + density, _ = kde(x, y) + + assert density[0, 0] == pytest.approx(0, abs=1e-2) + assert density[-1, -1] == pytest.approx(1, abs=1e-2) + + +class TestHistogram(DistributionFixtures): + + def test_string_bins(self, x): + + h = Histogram(bins="sqrt") + bin_kws = h.define_bin_params(x) + assert bin_kws["range"] == (x.min(), x.max()) + assert bin_kws["bins"] == int(np.sqrt(len(x))) + + def test_int_bins(self, x): + + n = 24 + h = Histogram(bins=n) + bin_kws = h.define_bin_params(x) + assert bin_kws["range"] == (x.min(), x.max()) + assert bin_kws["bins"] == n + + def test_array_bins(self, x): + + bins = [-3, -2, 1, 2, 3] + h = Histogram(bins=bins) + bin_kws = h.define_bin_params(x) + assert_array_equal(bin_kws["bins"], bins) + + def test_bivariate_string_bins(self, x, y): + + s1, s2 = "sqrt", "fd" + + h = Histogram(bins=s1) + e1, e2 = h.define_bin_params(x, y)["bins"] + assert_array_equal(e1, np.histogram_bin_edges(x, s1)) + assert_array_equal(e2, np.histogram_bin_edges(y, s1)) + + h = Histogram(bins=(s1, s2)) + e1, e2 = h.define_bin_params(x, y)["bins"] + assert_array_equal(e1, np.histogram_bin_edges(x, s1)) + assert_array_equal(e2, np.histogram_bin_edges(y, s2)) + + def test_bivariate_int_bins(self, x, y): + + b1, b2 = 5, 10 + + h = Histogram(bins=b1) + e1, e2 = h.define_bin_params(x, y)["bins"] + assert len(e1) == b1 + 1 + assert len(e2) == b1 + 1 + + h = Histogram(bins=(b1, b2)) + e1, e2 = h.define_bin_params(x, y)["bins"] + assert len(e1) == b1 + 1 + assert len(e2) == b2 + 1 + + def test_bivariate_array_bins(self, x, y): + + b1 = [-3, -2, 1, 2, 3] + b2 = [-5, -2, 3, 6] + + h = Histogram(bins=b1) + e1, e2 = h.define_bin_params(x, y)["bins"] + assert_array_equal(e1, b1) + assert_array_equal(e2, b1) + + h = Histogram(bins=(b1, b2)) + e1, e2 = h.define_bin_params(x, y)["bins"] + assert_array_equal(e1, b1) + assert_array_equal(e2, b2) + + def test_binwidth(self, x): + + binwidth = .5 + h = Histogram(binwidth=binwidth) + bin_kws = h.define_bin_params(x) + n_bins = bin_kws["bins"] + left, right = bin_kws["range"] + assert (right - left) / n_bins == pytest.approx(binwidth) + + def test_bivariate_binwidth(self, x, y): + + w1, w2 = .5, 1 + + h = Histogram(binwidth=w1) + e1, e2 = h.define_bin_params(x, y)["bins"] + assert np.all(np.diff(e1) == w1) + assert np.all(np.diff(e2) == w1) + + h = Histogram(binwidth=(w1, w2)) + e1, e2 = h.define_bin_params(x, y)["bins"] + assert np.all(np.diff(e1) == w1) + assert np.all(np.diff(e2) == w2) + + def test_binrange(self, x): + + binrange = (-4, 4) + h = Histogram(binrange=binrange) + bin_kws = h.define_bin_params(x) + assert bin_kws["range"] == binrange + + def test_bivariate_binrange(self, x, y): + + r1, r2 = (-4, 4), (-10, 10) + + h = Histogram(binrange=r1) + e1, e2 = h.define_bin_params(x, y)["bins"] + assert e1.min() == r1[0] + assert e1.max() == r1[1] + assert e2.min() == r1[0] + assert e2.max() == r1[1] + + h = Histogram(binrange=(r1, r2)) + e1, e2 = h.define_bin_params(x, y)["bins"] + assert e1.min() == r1[0] + assert e1.max() == r1[1] + assert e2.min() == r2[0] + assert e2.max() == r2[1] + + def test_discrete_bins(self, rng): + + x = rng.binomial(20, .5, 100) + h = Histogram(discrete=True) + bin_kws = h.define_bin_params(x) + assert bin_kws["range"] == (x.min() - .5, x.max() + .5) + assert bin_kws["bins"] == (x.max() - x.min() + 1) + + def test_histogram(self, x): + + h = Histogram() + heights, edges = h(x) + heights_mpl, edges_mpl = np.histogram(x, bins="auto") + + assert_array_equal(heights, heights_mpl) + assert_array_equal(edges, edges_mpl) + + def test_count_stat(self, x): + + h = Histogram(stat="count") + heights, _ = h(x) + assert heights.sum() == len(x) + + def test_density_stat(self, x): + + h = Histogram(stat="density") + heights, edges = h(x) + assert (heights * np.diff(edges)).sum() == 1 + + def test_probability_stat(self, x): + + h = Histogram(stat="probability") + heights, _ = h(x) + assert heights.sum() == 1 + + def test_frequency_stat(self, x): + + h = Histogram(stat="frequency") + heights, edges = h(x) + assert (heights * np.diff(edges)).sum() == len(x) + + def test_cumulative_count(self, x): + + h = Histogram(stat="count", cumulative=True) + heights, _ = h(x) + assert heights[-1] == len(x) + + def test_cumulative_density(self, x): + + h = Histogram(stat="density", cumulative=True) + heights, _ = h(x) + assert heights[-1] == 1 + + def test_cumulative_probability(self, x): + + h = Histogram(stat="probability", cumulative=True) + heights, _ = h(x) + assert heights[-1] == 1 + + def test_cumulative_frequency(self, x): + + h = Histogram(stat="frequency", cumulative=True) + heights, _ = h(x) + assert heights[-1] == len(x) + + def test_bivariate_histogram(self, x, y): + + h = Histogram() + heights, edges = h(x, y) + bins_mpl = ( + np.histogram_bin_edges(x, "auto"), + np.histogram_bin_edges(y, "auto"), + ) + heights_mpl, *edges_mpl = np.histogram2d(x, y, bins_mpl) + assert_array_equal(heights, heights_mpl) + assert_array_equal(edges[0], edges_mpl[0]) + assert_array_equal(edges[1], edges_mpl[1]) + + def test_bivariate_count_stat(self, x, y): + + h = Histogram(stat="count") + heights, _ = h(x, y) + assert heights.sum() == len(x) + + def test_bivariate_density_stat(self, x, y): + + h = Histogram(stat="density") + heights, (edges_x, edges_y) = h(x, y) + areas = np.outer(np.diff(edges_x), np.diff(edges_y)) + assert (heights * areas).sum() == pytest.approx(1) + + def test_bivariate_probability_stat(self, x, y): + + h = Histogram(stat="probability") + heights, _ = h(x, y) + assert heights.sum() == 1 + + def test_bivariate_frequency_stat(self, x, y): + + h = Histogram(stat="frequency") + heights, (x_edges, y_edges) = h(x, y) + area = np.outer(np.diff(x_edges), np.diff(y_edges)) + assert (heights * area).sum() == len(x) + + def test_bivariate_cumulative_count(self, x, y): + + h = Histogram(stat="count", cumulative=True) + heights, _ = h(x, y) + assert heights[-1, -1] == len(x) + + def test_bivariate_cumulative_density(self, x, y): + + h = Histogram(stat="density", cumulative=True) + heights, _ = h(x, y) + assert heights[-1, -1] == pytest.approx(1) + + def test_bivariate_cumulative_frequency(self, x, y): + + h = Histogram(stat="frequency", cumulative=True) + heights, _ = h(x, y) + assert heights[-1, -1] == len(x) + + def test_bivariate_cumulative_probability(self, x, y): + + h = Histogram(stat="probability", cumulative=True) + heights, _ = h(x, y) + assert heights[-1, -1] == pytest.approx(1) + + def test_bad_stat(self): + + with pytest.raises(ValueError): + Histogram(stat="invalid") + + +class TestECDF(DistributionFixtures): + + def test_univariate_proportion(self, x): + + ecdf = ECDF() + stat, vals = ecdf(x) + assert_array_equal(vals[1:], np.sort(x)) + assert_array_almost_equal(stat[1:], np.linspace(0, 1, len(x) + 1)[1:]) + assert stat[0] == 0 + + def test_univariate_count(self, x): + + ecdf = ECDF(stat="count") + stat, vals = ecdf(x) + + assert_array_equal(vals[1:], np.sort(x)) + assert_array_almost_equal(stat[1:], np.arange(len(x)) + 1) + assert stat[0] == 0 + + def test_univariate_proportion_weights(self, x, weights): + + ecdf = ECDF() + stat, vals = ecdf(x, weights=weights) + assert_array_equal(vals[1:], np.sort(x)) + expected_stats = weights[x.argsort()].cumsum() / weights.sum() + assert_array_almost_equal(stat[1:], expected_stats) + assert stat[0] == 0 + + def test_univariate_count_weights(self, x, weights): + + ecdf = ECDF(stat="count") + stat, vals = ecdf(x, weights=weights) + assert_array_equal(vals[1:], np.sort(x)) + assert_array_almost_equal(stat[1:], weights[x.argsort()].cumsum()) + assert stat[0] == 0 + + @pytest.mark.skipif(smdist is None, reason="Requires statsmodels") + def test_against_statsmodels(self, x): + + sm_ecdf = smdist.empirical_distribution.ECDF(x) + + ecdf = ECDF() + stat, vals = ecdf(x) + assert_array_equal(vals, sm_ecdf.x) + assert_array_almost_equal(stat, sm_ecdf.y) + + ecdf = ECDF(complementary=True) + stat, vals = ecdf(x) + assert_array_equal(vals, sm_ecdf.x) + assert_array_almost_equal(stat, sm_ecdf.y[::-1]) + + def test_invalid_stat(self, x): + + with pytest.raises(ValueError, match="`stat` must be one of"): + ECDF(stat="density") + + def test_bivariate_error(self, x, y): + + with pytest.raises(NotImplementedError, match="Bivariate ECDF"): + ecdf = ECDF() + ecdf(x, y) diff --git a/grplot_seaborn/tests/test_utils.py b/grplot_seaborn/tests/test_utils.py new file mode 100644 index 0000000..ad620c8 --- /dev/null +++ b/grplot_seaborn/tests/test_utils.py @@ -0,0 +1,607 @@ +"""Tests for seaborn utility functions.""" +import tempfile +from urllib.request import urlopen +from http.client import HTTPException + +import numpy as np +import pandas as pd +import matplotlib as mpl +import matplotlib.pyplot as plt +from cycler import cycler + +import pytest +from numpy.testing import ( + assert_array_equal, +) +from pandas.testing import ( + assert_series_equal, + assert_frame_equal, +) + +from distutils.version import LooseVersion + +from .. import utils, rcmod +from ..utils import ( + get_dataset_names, + get_color_cycle, + remove_na, + load_dataset, + _assign_default_kwargs, + _draw_figure, +) + + +a_norm = np.random.randn(100) + + +def _network(t=None, url="https://github.com"): + """ + Decorator that will skip a test if `url` is unreachable. + + Parameters + ---------- + t : function, optional + url : str, optional + + """ + if t is None: + return lambda x: _network(x, url=url) + + def wrapper(*args, **kwargs): + # attempt to connect + try: + f = urlopen(url) + except (IOError, HTTPException): + pytest.skip("No internet connection") + else: + f.close() + return t(*args, **kwargs) + return wrapper + + +def test_pmf_hist_basics(): + """Test the function to return barplot args for pmf hist.""" + with pytest.warns(FutureWarning): + out = utils.pmf_hist(a_norm) + assert len(out) == 3 + x, h, w = out + assert len(x) == len(h) + + # Test simple case + a = np.arange(10) + with pytest.warns(FutureWarning): + x, h, w = utils.pmf_hist(a, 10) + assert np.all(h == h[0]) + + # Test width + with pytest.warns(FutureWarning): + x, h, w = utils.pmf_hist(a_norm) + assert x[1] - x[0] == w + + # Test normalization + with pytest.warns(FutureWarning): + x, h, w = utils.pmf_hist(a_norm) + assert sum(h) == pytest.approx(1) + assert h.max() <= 1 + + # Test bins + with pytest.warns(FutureWarning): + x, h, w = utils.pmf_hist(a_norm, 20) + assert len(x) == 20 + + +def test_ci_to_errsize(): + """Test behavior of ci_to_errsize.""" + cis = [[.5, .5], + [1.25, 1.5]] + + heights = [1, 1.5] + + actual_errsize = np.array([[.5, 1], + [.25, 0]]) + + test_errsize = utils.ci_to_errsize(cis, heights) + assert_array_equal(actual_errsize, test_errsize) + + +def test_desaturate(): + """Test color desaturation.""" + out1 = utils.desaturate("red", .5) + assert out1 == (.75, .25, .25) + + out2 = utils.desaturate("#00FF00", .5) + assert out2 == (.25, .75, .25) + + out3 = utils.desaturate((0, 0, 1), .5) + assert out3 == (.25, .25, .75) + + out4 = utils.desaturate("red", .5) + assert out4 == (.75, .25, .25) + + +def test_desaturation_prop(): + """Test that pct outside of [0, 1] raises exception.""" + with pytest.raises(ValueError): + utils.desaturate("blue", 50) + + +def test_saturate(): + """Test performance of saturation function.""" + out = utils.saturate((.75, .25, .25)) + assert out == (1, 0, 0) + + +@pytest.mark.parametrize( + "p,annot", [(.0001, "***"), (.001, "**"), (.01, "*"), (.09, "."), (1, "")] +) +def test_sig_stars(p, annot): + """Test the sig stars function.""" + with pytest.warns(FutureWarning): + stars = utils.sig_stars(p) + assert stars == annot + + +def test_iqr(): + """Test the IQR function.""" + a = np.arange(5) + with pytest.warns(FutureWarning): + iqr = utils.iqr(a) + assert iqr == 2 + + +@pytest.mark.parametrize( + "s,exp", + [ + ("a", "a"), + ("abc", "abc"), + (b"a", "a"), + (b"abc", "abc"), + (bytearray("abc", "utf-8"), "abc"), + (bytearray(), ""), + (1, "1"), + (0, "0"), + ([], str([])), + ], +) +def test_to_utf8(s, exp): + """Test the to_utf8 function: object to string""" + u = utils.to_utf8(s) + assert type(u) == str + assert u == exp + + +class TestSpineUtils(object): + + sides = ["left", "right", "bottom", "top"] + outer_sides = ["top", "right"] + inner_sides = ["left", "bottom"] + + offset = 10 + original_position = ("outward", 0) + offset_position = ("outward", offset) + + def test_despine(self): + f, ax = plt.subplots() + for side in self.sides: + assert ax.spines[side].get_visible() + + utils.despine() + for side in self.outer_sides: + assert ~ax.spines[side].get_visible() + for side in self.inner_sides: + assert ax.spines[side].get_visible() + + utils.despine(**dict(zip(self.sides, [True] * 4))) + for side in self.sides: + assert ~ax.spines[side].get_visible() + + def test_despine_specific_axes(self): + f, (ax1, ax2) = plt.subplots(2, 1) + + utils.despine(ax=ax2) + + for side in self.sides: + assert ax1.spines[side].get_visible() + + for side in self.outer_sides: + assert ~ax2.spines[side].get_visible() + for side in self.inner_sides: + assert ax2.spines[side].get_visible() + + def test_despine_with_offset(self): + f, ax = plt.subplots() + + for side in self.sides: + pos = ax.spines[side].get_position() + assert pos == self.original_position + + utils.despine(ax=ax, offset=self.offset) + + for side in self.sides: + is_visible = ax.spines[side].get_visible() + new_position = ax.spines[side].get_position() + if is_visible: + assert new_position == self.offset_position + else: + assert new_position == self.original_position + + def test_despine_side_specific_offset(self): + + f, ax = plt.subplots() + utils.despine(ax=ax, offset=dict(left=self.offset)) + + for side in self.sides: + is_visible = ax.spines[side].get_visible() + new_position = ax.spines[side].get_position() + if is_visible and side == "left": + assert new_position == self.offset_position + else: + assert new_position == self.original_position + + def test_despine_with_offset_specific_axes(self): + f, (ax1, ax2) = plt.subplots(2, 1) + + utils.despine(offset=self.offset, ax=ax2) + + for side in self.sides: + pos1 = ax1.spines[side].get_position() + pos2 = ax2.spines[side].get_position() + assert pos1 == self.original_position + if ax2.spines[side].get_visible(): + assert pos2 == self.offset_position + else: + assert pos2 == self.original_position + + def test_despine_trim_spines(self): + + f, ax = plt.subplots() + ax.plot([1, 2, 3], [1, 2, 3]) + ax.set_xlim(.75, 3.25) + + utils.despine(trim=True) + for side in self.inner_sides: + bounds = ax.spines[side].get_bounds() + assert bounds == (1, 3) + + def test_despine_trim_inverted(self): + + f, ax = plt.subplots() + ax.plot([1, 2, 3], [1, 2, 3]) + ax.set_ylim(.85, 3.15) + ax.invert_yaxis() + + utils.despine(trim=True) + for side in self.inner_sides: + bounds = ax.spines[side].get_bounds() + assert bounds == (1, 3) + + def test_despine_trim_noticks(self): + + f, ax = plt.subplots() + ax.plot([1, 2, 3], [1, 2, 3]) + ax.set_yticks([]) + utils.despine(trim=True) + assert ax.get_yticks().size == 0 + + def test_despine_trim_categorical(self): + + f, ax = plt.subplots() + ax.plot(["a", "b", "c"], [1, 2, 3]) + + utils.despine(trim=True) + + bounds = ax.spines["left"].get_bounds() + assert bounds == (1, 3) + + bounds = ax.spines["bottom"].get_bounds() + assert bounds == (0, 2) + + def test_despine_moved_ticks(self): + + f, ax = plt.subplots() + for t in ax.yaxis.majorTicks: + t.tick1line.set_visible(True) + utils.despine(ax=ax, left=True, right=False) + for t in ax.yaxis.majorTicks: + assert t.tick2line.get_visible() + plt.close(f) + + f, ax = plt.subplots() + for t in ax.yaxis.majorTicks: + t.tick1line.set_visible(False) + utils.despine(ax=ax, left=True, right=False) + for t in ax.yaxis.majorTicks: + assert not t.tick2line.get_visible() + plt.close(f) + + f, ax = plt.subplots() + for t in ax.xaxis.majorTicks: + t.tick1line.set_visible(True) + utils.despine(ax=ax, bottom=True, top=False) + for t in ax.xaxis.majorTicks: + assert t.tick2line.get_visible() + plt.close(f) + + f, ax = plt.subplots() + for t in ax.xaxis.majorTicks: + t.tick1line.set_visible(False) + utils.despine(ax=ax, bottom=True, top=False) + for t in ax.xaxis.majorTicks: + assert not t.tick2line.get_visible() + plt.close(f) + + +def test_ticklabels_overlap(): + + rcmod.set() + f, ax = plt.subplots(figsize=(2, 2)) + f.tight_layout() # This gets the Agg renderer working + + assert not utils.axis_ticklabels_overlap(ax.get_xticklabels()) + + big_strings = "abcdefgh", "ijklmnop" + ax.set_xlim(-.5, 1.5) + ax.set_xticks([0, 1]) + ax.set_xticklabels(big_strings) + + assert utils.axis_ticklabels_overlap(ax.get_xticklabels()) + + x, y = utils.axes_ticklabels_overlap(ax) + assert x + assert not y + + +def test_locator_to_legend_entries(): + + locator = mpl.ticker.MaxNLocator(nbins=3) + limits = (0.09, 0.4) + levels, str_levels = utils.locator_to_legend_entries( + locator, limits, float + ) + assert str_levels == ["0.15", "0.30"] + + limits = (0.8, 0.9) + levels, str_levels = utils.locator_to_legend_entries( + locator, limits, float + ) + assert str_levels == ["0.80", "0.84", "0.88"] + + limits = (1, 6) + levels, str_levels = utils.locator_to_legend_entries(locator, limits, int) + assert str_levels == ["2", "4", "6"] + + locator = mpl.ticker.LogLocator(numticks=5) + limits = (5, 1425) + levels, str_levels = utils.locator_to_legend_entries(locator, limits, int) + if LooseVersion(mpl.__version__) >= "3.1": + assert str_levels == ['10', '100', '1000'] + + limits = (0.00003, 0.02) + levels, str_levels = utils.locator_to_legend_entries( + locator, limits, float + ) + if LooseVersion(mpl.__version__) >= "3.1": + assert str_levels == ['1e-04', '1e-03', '1e-02'] + + +def test_move_legend_matplotlib_objects(): + + fig, ax = plt.subplots() + + colors = "C2", "C5" + labels = "first label", "second label" + title = "the legend" + + for color, label in zip(colors, labels): + ax.plot([0, 1], color=color, label=label) + ax.legend(loc="upper right", title=title) + utils._draw_figure(fig) + xfm = ax.transAxes.inverted().transform + + # --- Test axes legend + + old_pos = xfm(ax.legend_.legendPatch.get_extents()) + + new_fontsize = 14 + utils.move_legend(ax, "lower left", title_fontsize=new_fontsize) + utils._draw_figure(fig) + new_pos = xfm(ax.legend_.legendPatch.get_extents()) + + assert (new_pos < old_pos).all() + assert ax.legend_.get_title().get_text() == title + assert ax.legend_.get_title().get_size() == new_fontsize + + # --- Test title replacement + + new_title = "new title" + utils.move_legend(ax, "lower left", title=new_title) + utils._draw_figure(fig) + assert ax.legend_.get_title().get_text() == new_title + + # --- Test figure legend + + fig.legend(loc="upper right", title=title) + _draw_figure(fig) + xfm = fig.transFigure.inverted().transform + old_pos = xfm(fig.legends[0].legendPatch.get_extents()) + + utils.move_legend(fig, "lower left", title=new_title) + _draw_figure(fig) + + new_pos = xfm(fig.legends[0].legendPatch.get_extents()) + assert (new_pos < old_pos).all() + assert fig.legends[0].get_title().get_text() == new_title + + +def test_move_legend_grid_object(long_df): + + from grplot_seaborn.axisgrid import FacetGrid + + hue_var = "a" + g = FacetGrid(long_df, hue=hue_var) + g.map(plt.plot, "x", "y") + + g.add_legend() + _draw_figure(g.figure) + + xfm = g.figure.transFigure.inverted().transform + old_pos = xfm(g.legend.legendPatch.get_extents()) + + fontsize = 20 + utils.move_legend(g, "lower left", title_fontsize=fontsize) + _draw_figure(g.figure) + + new_pos = xfm(g.legend.legendPatch.get_extents()) + assert (new_pos < old_pos).all() + assert g.legend.get_title().get_text() == hue_var + assert g.legend.get_title().get_size() == fontsize + + assert g.legend.legendHandles + for i, h in enumerate(g.legend.legendHandles): + assert mpl.colors.to_rgb(h.get_color()) == mpl.colors.to_rgb(f"C{i}") + + +def test_move_legend_input_checks(): + + ax = plt.figure().subplots() + with pytest.raises(TypeError): + utils.move_legend(ax.xaxis, "best") + + with pytest.raises(ValueError): + utils.move_legend(ax, "best") + + with pytest.raises(ValueError): + utils.move_legend(ax.figure, "best") + + +def check_load_dataset(name): + ds = load_dataset(name, cache=False) + assert(isinstance(ds, pd.DataFrame)) + + +def check_load_cached_dataset(name): + # Test the cacheing using a temporary file. + with tempfile.TemporaryDirectory() as tmpdir: + # download and cache + ds = load_dataset(name, cache=True, data_home=tmpdir) + + # use cached version + ds2 = load_dataset(name, cache=True, data_home=tmpdir) + assert_frame_equal(ds, ds2) + + +@_network(url="https://github.com/mwaskom/seaborn-data") +def test_get_dataset_names(): + names = get_dataset_names() + assert names + assert "tips" in names + + +@_network(url="https://github.com/mwaskom/seaborn-data") +def test_load_datasets(): + + # Heavy test to verify that we can load all available datasets + for name in get_dataset_names(): + # unfortunately @network somehow obscures this generator so it + # does not get in effect, so we need to call explicitly + # yield check_load_dataset, name + check_load_dataset(name) + + +@_network(url="https://github.com/mwaskom/seaborn-data") +def test_load_dataset_string_error(): + + name = "bad_name" + err = f"'{name}' is not one of the example datasets." + with pytest.raises(ValueError, match=err): + load_dataset(name) + + +def test_load_dataset_passed_data_error(): + + df = pd.DataFrame() + err = "This function accepts only strings" + with pytest.raises(TypeError, match=err): + load_dataset(df) + + +@_network(url="https://github.com/mwaskom/seaborn-data") +def test_load_cached_datasets(): + + # Heavy test to verify that we can load all available datasets + for name in get_dataset_names(): + # unfortunately @network somehow obscures this generator so it + # does not get in effect, so we need to call explicitly + # yield check_load_dataset, name + check_load_cached_dataset(name) + + +def test_relative_luminance(): + """Test relative luminance.""" + out1 = utils.relative_luminance("white") + assert out1 == 1 + + out2 = utils.relative_luminance("#000000") + assert out2 == 0 + + out3 = utils.relative_luminance((.25, .5, .75)) + assert out3 == pytest.approx(0.201624536) + + rgbs = mpl.cm.RdBu(np.linspace(0, 1, 10)) + lums1 = [utils.relative_luminance(rgb) for rgb in rgbs] + lums2 = utils.relative_luminance(rgbs) + + for lum1, lum2 in zip(lums1, lums2): + assert lum1 == pytest.approx(lum2) + + +@pytest.mark.parametrize( + "cycler,result", + [ + (cycler(color=["y"]), ["y"]), + (cycler(color=["k"]), ["k"]), + (cycler(color=["k", "y"]), ["k", "y"]), + (cycler(color=["y", "k"]), ["y", "k"]), + (cycler(color=["b", "r"]), ["b", "r"]), + (cycler(color=["r", "b"]), ["r", "b"]), + (cycler(lw=[1, 2]), [".15"]), # no color in cycle + ], +) +def test_get_color_cycle(cycler, result): + with mpl.rc_context(rc={"axes.prop_cycle": cycler}): + assert get_color_cycle() == result + + +def test_remove_na(): + + a_array = np.array([1, 2, np.nan, 3]) + a_array_rm = remove_na(a_array) + assert_array_equal(a_array_rm, np.array([1, 2, 3])) + + a_series = pd.Series([1, 2, np.nan, 3]) + a_series_rm = remove_na(a_series) + assert_series_equal(a_series_rm, pd.Series([1., 2, 3], [0, 1, 3])) + + +def test_assign_default_kwargs(): + + def f(a, b, c, d): + pass + + def g(c=1, d=2): + pass + + kws = {"c": 3} + + kws = _assign_default_kwargs(kws, f, g) + assert kws == {"c": 3, "d": 2} + + +def test_draw_figure(): + + f, ax = plt.subplots() + ax.plot(["a", "b", "c"], [1, 2, 3]) + _draw_figure(f) + assert not f.stale + # ticklabels are not populated until a draw, but this may change + assert ax.get_xticklabels()[0].get_text() == "a" diff --git a/grplot_seaborn/timeseries.py b/grplot_seaborn/timeseries.py new file mode 100644 index 0000000..354cee0 --- /dev/null +++ b/grplot_seaborn/timeseries.py @@ -0,0 +1,454 @@ +"""Timeseries plotting functions.""" +from __future__ import division +import numpy as np +import pandas as pd +from scipy import stats, interpolate +import matplotlib as mpl +import matplotlib.pyplot as plt + +import warnings + +from .external.six import string_types + +from . import utils +from . import algorithms as algo +from .palettes import color_palette + + +__all__ = ["tsplot"] + + +def tsplot(data, time=None, unit=None, condition=None, value=None, + err_style="ci_band", ci=68, interpolate=True, color=None, + estimator=np.mean, n_boot=5000, err_palette=None, err_kws=None, + legend=True, ax=None, **kwargs): + """Plot one or more timeseries with flexible representation of uncertainty. + + This function is intended to be used with data where observations are + nested within sampling units that were measured at multiple timepoints. + + It can take data specified either as a long-form (tidy) DataFrame or as an + ndarray with dimensions (unit, time) The interpretation of some of the + other parameters changes depending on the type of object passed as data. + + Parameters + ---------- + data : DataFrame or ndarray + Data for the plot. Should either be a "long form" dataframe or an + array with dimensions (unit, time, condition). In both cases, the + condition field/dimension is optional. The type of this argument + determines the interpretation of the next few parameters. When + using a DataFrame, the index has to be sequential. + time : string or series-like + Either the name of the field corresponding to time in the data + DataFrame or x values for a plot when data is an array. If a Series, + the name will be used to label the x axis. + unit : string + Field in the data DataFrame identifying the sampling unit (e.g. + subject, neuron, etc.). The error representation will collapse over + units at each time/condition observation. This has no role when data + is an array. + value : string + Either the name of the field corresponding to the data values in + the data DataFrame (i.e. the y coordinate) or a string that forms + the y axis label when data is an array. + condition : string or Series-like + Either the name of the field identifying the condition an observation + falls under in the data DataFrame, or a sequence of names with a length + equal to the size of the third dimension of data. There will be a + separate trace plotted for each condition. If condition is a Series + with a name attribute, the name will form the title for the plot + legend (unless legend is set to False). + err_style : string or list of strings or None + Names of ways to plot uncertainty across units from set of + {ci_band, ci_bars, boot_traces, boot_kde, unit_traces, unit_points}. + Can use one or more than one method. + ci : float or list of floats in [0, 100] or "sd" or None + Confidence interval size(s). If a list, it will stack the error plots + for each confidence interval. If ``"sd"``, show standard deviation of + the observations instead of boostrapped confidence intervals. Only + relevant for error styles with "ci" in the name. + interpolate : boolean + Whether to do a linear interpolation between each timepoint when + plotting. The value of this parameter also determines the marker + used for the main plot traces, unless marker is specified as a keyword + argument. + color : seaborn palette or matplotlib color name or dictionary + Palette or color for the main plots and error representation (unless + plotting by unit, which can be separately controlled with err_palette). + If a dictionary, should map condition name to color spec. + estimator : callable + Function to determine central tendency and to pass to bootstrap + must take an ``axis`` argument. + n_boot : int + Number of bootstrap iterations. + err_palette : seaborn palette + Palette name or list of colors used when plotting data for each unit. + err_kws : dict, optional + Keyword argument dictionary passed through to matplotlib function + generating the error plot, + legend : bool, optional + If ``True`` and there is a ``condition`` variable, add a legend to + the plot. + ax : axis object, optional + Plot in given axis; if None creates a new figure + kwargs : + Other keyword arguments are passed to main plot() call + + Returns + ------- + ax : matplotlib axis + axis with plot data + + Examples + -------- + + Plot a trace with translucent confidence bands: + + .. plot:: + :context: close-figs + + >>> import numpy as np; np.random.seed(22) + >>> import grplot_seaborn as sns; sns.set(color_codes=True) + >>> x = np.linspace(0, 15, 31) + >>> data = np.sin(x) + np.random.rand(10, 31) + np.random.randn(10, 1) + >>> ax = sns.tsplot(data=data) + + Plot a long-form dataframe with several conditions: + + .. plot:: + :context: close-figs + + >>> gammas = sns.load_dataset("gammas") + >>> ax = sns.tsplot(time="timepoint", value="BOLD signal", + ... unit="subject", condition="ROI", + ... data=gammas) + + Use error bars at the positions of the observations: + + .. plot:: + :context: close-figs + + >>> ax = sns.tsplot(data=data, err_style="ci_bars", color="g") + + Don't interpolate between the observations: + + .. plot:: + :context: close-figs + + >>> import matplotlib.pyplot as plt + >>> ax = sns.tsplot(data=data, err_style="ci_bars", interpolate=False) + + Show multiple confidence bands: + + .. plot:: + :context: close-figs + + >>> ax = sns.tsplot(data=data, ci=[68, 95], color="m") + + Show the standard deviation of the observations: + + .. plot:: + :context: close-figs + + >>> ax = sns.tsplot(data=data, ci="sd") + + Use a different estimator: + + .. plot:: + :context: close-figs + + >>> ax = sns.tsplot(data=data, estimator=np.median) + + Show each bootstrap resample: + + .. plot:: + :context: close-figs + + >>> ax = sns.tsplot(data=data, err_style="boot_traces", n_boot=500) + + Show the trace from each sampling unit: + + + .. plot:: + :context: close-figs + + >>> ax = sns.tsplot(data=data, err_style="unit_traces") + + """ + msg = ( + "The `tsplot` function is deprecated and will be removed in a future " + "release. Please update your code to use the new `lineplot` function." + ) + warnings.warn(msg, UserWarning) + + # Sort out default values for the parameters + if ax is None: + ax = plt.gca() + + if err_kws is None: + err_kws = {} + + # Handle different types of input data + if isinstance(data, pd.DataFrame): + + xlabel = time + ylabel = value + + # Condition is optional + if condition is None: + condition = pd.Series(1, index=data.index) + legend = False + legend_name = None + n_cond = 1 + else: + legend = True and legend + legend_name = condition + n_cond = len(data[condition].unique()) + + else: + data = np.asarray(data) + + # Data can be a timecourse from a single unit or + # several observations in one condition + if data.ndim == 1: + data = data[np.newaxis, :, np.newaxis] + elif data.ndim == 2: + data = data[:, :, np.newaxis] + n_unit, n_time, n_cond = data.shape + + # Units are experimental observations. Maybe subjects, or neurons + if unit is None: + units = np.arange(n_unit) + unit = "unit" + units = np.repeat(units, n_time * n_cond) + ylabel = None + + # Time forms the xaxis of the plot + if time is None: + times = np.arange(n_time) + else: + times = np.asarray(time) + xlabel = None + if hasattr(time, "name"): + xlabel = time.name + time = "time" + times = np.tile(np.repeat(times, n_cond), n_unit) + + # Conditions split the timeseries plots + if condition is None: + conds = range(n_cond) + legend = False + if isinstance(color, dict): + err = "Must have condition names if using color dict." + raise ValueError(err) + else: + conds = np.asarray(condition) + legend = True and legend + if hasattr(condition, "name"): + legend_name = condition.name + else: + legend_name = None + condition = "cond" + conds = np.tile(conds, n_unit * n_time) + + # Value forms the y value in the plot + if value is None: + ylabel = None + else: + ylabel = value + value = "value" + + # Convert to long-form DataFrame + data = pd.DataFrame(dict(value=data.ravel(), + time=times, + unit=units, + cond=conds)) + + # Set up the err_style and ci arguments for the loop below + if isinstance(err_style, string_types): + err_style = [err_style] + elif err_style is None: + err_style = [] + if not hasattr(ci, "__iter__"): + ci = [ci] + + # Set up the color palette + if color is None: + current_palette = utils.get_color_cycle() + if len(current_palette) < n_cond: + colors = color_palette("husl", n_cond) + else: + colors = color_palette(n_colors=n_cond) + elif isinstance(color, dict): + colors = [color[c] for c in data[condition].unique()] + else: + try: + colors = color_palette(color, n_cond) + except ValueError: + color = mpl.colors.colorConverter.to_rgb(color) + colors = [color] * n_cond + + # Do a groupby with condition and plot each trace + c = None + for c, (cond, df_c) in enumerate(data.groupby(condition, sort=False)): + + df_c = df_c.pivot(unit, time, value) + x = df_c.columns.values.astype(np.float) + + # Bootstrap the data for confidence intervals + if "sd" in ci: + est = estimator(df_c.values, axis=0) + sd = np.std(df_c.values, axis=0) + cis = [(est - sd, est + sd)] + boot_data = df_c.values + else: + boot_data = algo.bootstrap(df_c.values, n_boot=n_boot, + axis=0, func=estimator) + cis = [utils.ci(boot_data, v, axis=0) for v in ci] + central_data = estimator(df_c.values, axis=0) + + # Get the color for this condition + color = colors[c] + + # Use subroutines to plot the uncertainty + for style in err_style: + + # Allow for null style (only plot central tendency) + if style is None: + continue + + # Grab the function from the global environment + try: + plot_func = globals()["_plot_%s" % style] + except KeyError: + raise ValueError("%s is not a valid err_style" % style) + + # Possibly set up to plot each observation in a different color + if err_palette is not None and "unit" in style: + orig_color = color + color = color_palette(err_palette, len(df_c.values)) + + # Pass all parameters to the error plotter as keyword args + plot_kwargs = dict(ax=ax, x=x, data=df_c.values, + boot_data=boot_data, + central_data=central_data, + color=color, err_kws=err_kws) + + # Plot the error representation, possibly for multiple cis + for ci_i in cis: + plot_kwargs["ci"] = ci_i + plot_func(**plot_kwargs) + + if err_palette is not None and "unit" in style: + color = orig_color + + # Plot the central trace + kwargs.setdefault("marker", "" if interpolate else "o") + ls = kwargs.pop("ls", "-" if interpolate else "") + kwargs.setdefault("linestyle", ls) + label = cond if legend else "_nolegend_" + ax.plot(x, central_data, color=color, label=label, **kwargs) + + if c is None: + raise RuntimeError("Invalid input data for tsplot.") + + # Pad the sides of the plot only when not interpolating + ax.set_xlim(x.min(), x.max()) + x_diff = x[1] - x[0] + if not interpolate: + ax.set_xlim(x.min() - x_diff, x.max() + x_diff) + + # Add the plot labels + if xlabel is not None: + ax.set_xlabel(xlabel) + if ylabel is not None: + ax.set_ylabel(ylabel) + if legend: + ax.legend(loc=0, title=legend_name) + + return ax + +# Subroutines for tsplot errorbar plotting +# ---------------------------------------- + + +def _plot_ci_band(ax, x, ci, color, err_kws, **kwargs): + """Plot translucent error bands around the central tendancy.""" + low, high = ci + if "alpha" not in err_kws: + err_kws["alpha"] = 0.2 + ax.fill_between(x, low, high, facecolor=color, **err_kws) + + +def _plot_ci_bars(ax, x, central_data, ci, color, err_kws, **kwargs): + """Plot error bars at each data point.""" + for x_i, y_i, (low, high) in zip(x, central_data, ci.T): + ax.plot([x_i, x_i], [low, high], color=color, + solid_capstyle="round", **err_kws) + + +def _plot_boot_traces(ax, x, boot_data, color, err_kws, **kwargs): + """Plot 250 traces from bootstrap.""" + err_kws.setdefault("alpha", 0.25) + err_kws.setdefault("linewidth", 0.25) + if "lw" in err_kws: + err_kws["linewidth"] = err_kws.pop("lw") + ax.plot(x, boot_data.T, color=color, label="_nolegend_", **err_kws) + + +def _plot_unit_traces(ax, x, data, ci, color, err_kws, **kwargs): + """Plot a trace for each observation in the original data.""" + if isinstance(color, list): + if "alpha" not in err_kws: + err_kws["alpha"] = .5 + for i, obs in enumerate(data): + ax.plot(x, obs, color=color[i], label="_nolegend_", **err_kws) + else: + if "alpha" not in err_kws: + err_kws["alpha"] = .2 + ax.plot(x, data.T, color=color, label="_nolegend_", **err_kws) + + +def _plot_unit_points(ax, x, data, color, err_kws, **kwargs): + """Plot each original data point discretely.""" + if isinstance(color, list): + for i, obs in enumerate(data): + ax.plot(x, obs, "o", color=color[i], alpha=0.8, markersize=4, + label="_nolegend_", **err_kws) + else: + ax.plot(x, data.T, "o", color=color, alpha=0.5, markersize=4, + label="_nolegend_", **err_kws) + + +def _plot_boot_kde(ax, x, boot_data, color, **kwargs): + """Plot the kernal density estimate of the bootstrap distribution.""" + kwargs.pop("data") + _ts_kde(ax, x, boot_data, color, **kwargs) + + +def _plot_unit_kde(ax, x, data, color, **kwargs): + """Plot the kernal density estimate over the sample.""" + _ts_kde(ax, x, data, color, **kwargs) + + +def _ts_kde(ax, x, data, color, **kwargs): + """Upsample over time and plot a KDE of the bootstrap distribution.""" + kde_data = [] + y_min, y_max = data.min(), data.max() + y_vals = np.linspace(y_min, y_max, 100) + upsampler = interpolate.interp1d(x, data) + data_upsample = upsampler(np.linspace(x.min(), x.max(), 100)) + for pt_data in data_upsample.T: + pt_kde = stats.kde.gaussian_kde(pt_data) + kde_data.append(pt_kde(y_vals)) + kde_data = np.transpose(kde_data) + rgb = mpl.colors.ColorConverter().to_rgb(color) + img = np.zeros((kde_data.shape[0], kde_data.shape[1], 4)) + img[:, :, :3] = rgb + kde_data /= kde_data.max(axis=0) + kde_data[kde_data > 1] = 1 + img[:, :, 3] = kde_data + ax.imshow(img, interpolation="spline16", zorder=2, + extent=(x.min(), x.max(), y_min, y_max), + aspect="auto", origin="lower") diff --git a/grplot_seaborn/utils.py b/grplot_seaborn/utils.py new file mode 100644 index 0000000..3a4f9d0 --- /dev/null +++ b/grplot_seaborn/utils.py @@ -0,0 +1,821 @@ +"""Utility functions, mostly for internal use.""" +import os +import re +import inspect +import warnings +import colorsys +from urllib.request import urlopen, urlretrieve + +import numpy as np +from scipy import stats +import pandas as pd +import matplotlib as mpl +import matplotlib.colors as mplcol +import matplotlib.pyplot as plt +from matplotlib.cbook import normalize_kwargs + + +__all__ = ["desaturate", "saturate", "set_hls_values", "move_legend", + "despine", "get_dataset_names", "get_data_home", "load_dataset"] + + +def sort_df(df, *args, **kwargs): + """Wrapper to handle different pandas sorting API pre/post 0.17.""" + msg = "This function is deprecated and will be removed in a future version" + warnings.warn(msg) + try: + return df.sort_values(*args, **kwargs) + except AttributeError: + return df.sort(*args, **kwargs) + + +def ci_to_errsize(cis, heights): + """Convert intervals to error arguments relative to plot heights. + + Parameters + ---------- + cis : 2 x n sequence + sequence of confidence interval limits + heights : n sequence + sequence of plot heights + + Returns + ------- + errsize : 2 x n array + sequence of error size relative to height values in correct + format as argument for plt.bar + + """ + cis = np.atleast_2d(cis).reshape(2, -1) + heights = np.atleast_1d(heights) + errsize = [] + for i, (low, high) in enumerate(np.transpose(cis)): + h = heights[i] + elow = h - low + ehigh = high - h + errsize.append([elow, ehigh]) + + errsize = np.asarray(errsize).T + return errsize + + +def pmf_hist(a, bins=10): + """Return arguments to plt.bar for pmf-like histogram of an array. + + DEPRECATED: will be removed in a future version. + + Parameters + ---------- + a: array-like + array to make histogram of + bins: int + number of bins + + Returns + ------- + x: array + left x position of bars + h: array + height of bars + w: float + width of bars + + """ + msg = "This function is deprecated and will be removed in a future version" + warnings.warn(msg, FutureWarning) + n, x = np.histogram(a, bins) + h = n / n.sum() + w = x[1] - x[0] + return x[:-1], h, w + + +def _draw_figure(fig): + """Force draw of a matplotlib figure, accounting for back-compat.""" + # See https://github.com/matplotlib/matplotlib/issues/19197 for context + fig.canvas.draw() + if fig.stale: + try: + fig.draw(fig.canvas.get_renderer()) + except AttributeError: + pass + + +def desaturate(color, prop): + """Decrease the saturation channel of a color by some percent. + + Parameters + ---------- + color : matplotlib color + hex, rgb-tuple, or html color name + prop : float + saturation channel of color will be multiplied by this value + + Returns + ------- + new_color : rgb tuple + desaturated color code in RGB tuple representation + + """ + # Check inputs + if not 0 <= prop <= 1: + raise ValueError("prop must be between 0 and 1") + + # Get rgb tuple rep + rgb = mplcol.colorConverter.to_rgb(color) + + # Convert to hls + h, l, s = colorsys.rgb_to_hls(*rgb) + + # Desaturate the saturation channel + s *= prop + + # Convert back to rgb + new_color = colorsys.hls_to_rgb(h, l, s) + + return new_color + + +def saturate(color): + """Return a fully saturated color with the same hue. + + Parameters + ---------- + color : matplotlib color + hex, rgb-tuple, or html color name + + Returns + ------- + new_color : rgb tuple + saturated color code in RGB tuple representation + + """ + return set_hls_values(color, s=1) + + +def set_hls_values(color, h=None, l=None, s=None): # noqa + """Independently manipulate the h, l, or s channels of a color. + + Parameters + ---------- + color : matplotlib color + hex, rgb-tuple, or html color name + h, l, s : floats between 0 and 1, or None + new values for each channel in hls space + + Returns + ------- + new_color : rgb tuple + new color code in RGB tuple representation + + """ + # Get an RGB tuple representation + rgb = mplcol.colorConverter.to_rgb(color) + vals = list(colorsys.rgb_to_hls(*rgb)) + for i, val in enumerate([h, l, s]): + if val is not None: + vals[i] = val + + rgb = colorsys.hls_to_rgb(*vals) + return rgb + + +def axlabel(xlabel, ylabel, **kwargs): + """Grab current axis and label it. + + DEPRECATED: will be removed in a future version. + + """ + msg = "This function is deprecated and will be removed in a future version" + warnings.warn(msg, FutureWarning) + ax = plt.gca() + ax.set_xlabel(xlabel, **kwargs) + ax.set_ylabel(ylabel, **kwargs) + + +def remove_na(vector): + """Helper method for removing null values from data vectors. + + Parameters + ---------- + vector : vector object + Must implement boolean masking with [] subscript syntax. + + Returns + ------- + clean_clean : same type as ``vector`` + Vector of data with null values removed. May be a copy or a view. + + """ + return vector[pd.notnull(vector)] + + +def get_color_cycle(): + """Return the list of colors in the current matplotlib color cycle + + Parameters + ---------- + None + + Returns + ------- + colors : list + List of matplotlib colors in the current cycle, or dark gray if + the current color cycle is empty. + """ + cycler = mpl.rcParams['axes.prop_cycle'] + return cycler.by_key()['color'] if 'color' in cycler.keys else [".15"] + + +def despine(fig=None, ax=None, top=True, right=True, left=False, + bottom=False, offset=None, trim=False): + """Remove the top and right spines from plot(s). + + fig : matplotlib figure, optional + Figure to despine all axes of, defaults to the current figure. + ax : matplotlib axes, optional + Specific axes object to despine. Ignored if fig is provided. + top, right, left, bottom : boolean, optional + If True, remove that spine. + offset : int or dict, optional + Absolute distance, in points, spines should be moved away + from the axes (negative values move spines inward). A single value + applies to all spines; a dict can be used to set offset values per + side. + trim : bool, optional + If True, limit spines to the smallest and largest major tick + on each non-despined axis. + + Returns + ------- + None + + """ + # Get references to the axes we want + if fig is None and ax is None: + axes = plt.gcf().axes + elif fig is not None: + axes = fig.axes + elif ax is not None: + axes = [ax] + + for ax_i in axes: + for side in ["top", "right", "left", "bottom"]: + # Toggle the spine objects + is_visible = not locals()[side] + ax_i.spines[side].set_visible(is_visible) + if offset is not None and is_visible: + try: + val = offset.get(side, 0) + except AttributeError: + val = offset + ax_i.spines[side].set_position(('outward', val)) + + # Potentially move the ticks + if left and not right: + maj_on = any( + t.tick1line.get_visible() + for t in ax_i.yaxis.majorTicks + ) + min_on = any( + t.tick1line.get_visible() + for t in ax_i.yaxis.minorTicks + ) + ax_i.yaxis.set_ticks_position("right") + for t in ax_i.yaxis.majorTicks: + t.tick2line.set_visible(maj_on) + for t in ax_i.yaxis.minorTicks: + t.tick2line.set_visible(min_on) + + if bottom and not top: + maj_on = any( + t.tick1line.get_visible() + for t in ax_i.xaxis.majorTicks + ) + min_on = any( + t.tick1line.get_visible() + for t in ax_i.xaxis.minorTicks + ) + ax_i.xaxis.set_ticks_position("top") + for t in ax_i.xaxis.majorTicks: + t.tick2line.set_visible(maj_on) + for t in ax_i.xaxis.minorTicks: + t.tick2line.set_visible(min_on) + + if trim: + # clip off the parts of the spines that extend past major ticks + xticks = np.asarray(ax_i.get_xticks()) + if xticks.size: + firsttick = np.compress(xticks >= min(ax_i.get_xlim()), + xticks)[0] + lasttick = np.compress(xticks <= max(ax_i.get_xlim()), + xticks)[-1] + ax_i.spines['bottom'].set_bounds(firsttick, lasttick) + ax_i.spines['top'].set_bounds(firsttick, lasttick) + newticks = xticks.compress(xticks <= lasttick) + newticks = newticks.compress(newticks >= firsttick) + ax_i.set_xticks(newticks) + + yticks = np.asarray(ax_i.get_yticks()) + if yticks.size: + firsttick = np.compress(yticks >= min(ax_i.get_ylim()), + yticks)[0] + lasttick = np.compress(yticks <= max(ax_i.get_ylim()), + yticks)[-1] + ax_i.spines['left'].set_bounds(firsttick, lasttick) + ax_i.spines['right'].set_bounds(firsttick, lasttick) + newticks = yticks.compress(yticks <= lasttick) + newticks = newticks.compress(newticks >= firsttick) + ax_i.set_yticks(newticks) + + +def move_legend(obj, loc, **kwargs): + """ + Recreate a plot's legend at a new location. + + The name is a slight misnomer. Matplotlib legends do not expose public + control over their position parameters. So this function creates a new legend, + copying over the data from the original object, which is then removed. + + Parameters + ---------- + obj : the object with the plot + This argument can be either a seaborn or matplotlib object: + + - :class:`grplot_seaborn.FacetGrid` or :class:`grplot_seaborn.PairGrid` + - :class:`matplotlib.axes.Axes` or :class:`matplotlib.figure.Figure` + + loc : str or int + Location argument, as in :meth:`matplotlib.axes.Axes.legend`. + + kwargs + Other keyword arguments are passed to :meth:`matplotlib.axes.Axes.legend`. + + Examples + -------- + + .. include:: ../docstrings/move_legend.rst + + """ + # This is a somewhat hackish solution that will hopefully be obviated by + # upstream improvements to matplotlib legends that make them easier to + # modify after creation. + + from grplot_seaborn.axisgrid import Grid # Avoid circular import + + # Locate the legend object and a method to recreate the legend + if isinstance(obj, Grid): + old_legend = obj.legend + legend_func = obj.figure.legend + elif isinstance(obj, mpl.axes.Axes): + old_legend = obj.legend_ + legend_func = obj.legend + elif isinstance(obj, mpl.figure.Figure): + if obj.legends: + old_legend = obj.legends[-1] + else: + old_legend = None + legend_func = obj.legend + else: + err = "`obj` must be a seaborn Grid or matplotlib Axes or Figure instance." + raise TypeError(err) + + if old_legend is None: + err = f"{obj} has no legend attached." + raise ValueError(err) + + # Extract the components of the legend we need to reuse + handles = old_legend.legendHandles + labels = [t.get_text() for t in old_legend.get_texts()] + + # Extract legend properties that can be passed to the recreation method + # (Vexingly, these don't all round-trip) + legend_kws = inspect.signature(mpl.legend.Legend).parameters + props = {k: v for k, v in old_legend.properties().items() if k in legend_kws} + + # Delegate default bbox_to_anchor rules to matplotlib + props.pop("bbox_to_anchor") + + # Try to propagate the existing title and font properties; respect new ones too + title = props.pop("title") + if "title" in kwargs: + title.set_text(kwargs.pop("title")) + title_kwargs = {k: v for k, v in kwargs.items() if k.startswith("title_")} + for key, val in title_kwargs.items(): + title.set(**{key[6:]: val}) + kwargs.pop(key) + + # Try to respect the frame visibility + kwargs.setdefault("frameon", old_legend.legendPatch.get_visible()) + + # Remove the old legend and create the new one + props.update(kwargs) + old_legend.remove() + new_legend = legend_func(handles, labels, loc=loc, **props) + new_legend.set_title(title.get_text(), title.get_fontproperties()) + + # Let the Grid object continue to track the correct legend object + if isinstance(obj, Grid): + obj._legend = new_legend + + +def _kde_support(data, bw, gridsize, cut, clip): + """Establish support for a kernel density estimate.""" + support_min = max(data.min() - bw * cut, clip[0]) + support_max = min(data.max() + bw * cut, clip[1]) + support = np.linspace(support_min, support_max, gridsize) + + return support + + +def percentiles(a, pcts, axis=None): + """Like scoreatpercentile but can take and return array of percentiles. + + DEPRECATED: will be removed in a future version. + + Parameters + ---------- + a : array + data + pcts : sequence of percentile values + percentile or percentiles to find score at + axis : int or None + if not None, computes scores over this axis + + Returns + ------- + scores: array + array of scores at requested percentiles + first dimension is length of object passed to ``pcts`` + + """ + msg = "This function is deprecated and will be removed in a future version" + warnings.warn(msg, FutureWarning) + + scores = [] + try: + n = len(pcts) + except TypeError: + pcts = [pcts] + n = 0 + for i, p in enumerate(pcts): + if axis is None: + score = stats.scoreatpercentile(a.ravel(), p) + else: + score = np.apply_along_axis(stats.scoreatpercentile, axis, a, p) + scores.append(score) + scores = np.asarray(scores) + if not n: + scores = scores.squeeze() + return scores + + +def ci(a, which=95, axis=None): + """Return a percentile range from an array of values.""" + p = 50 - which / 2, 50 + which / 2 + return np.nanpercentile(a, p, axis) + + +def sig_stars(p): + """Return a R-style significance string corresponding to p values. + + DEPRECATED: will be removed in a future version. + + """ + msg = "This function is deprecated and will be removed in a future version" + warnings.warn(msg, FutureWarning) + + if p < 0.001: + return "***" + elif p < 0.01: + return "**" + elif p < 0.05: + return "*" + elif p < 0.1: + return "." + return "" + + +def iqr(a): + """Calculate the IQR for an array of numbers. + + DEPRECATED: will be removed in a future version. + + """ + msg = "This function is deprecated and will be removed in a future version" + warnings.warn(msg, FutureWarning) + + a = np.asarray(a) + q1 = stats.scoreatpercentile(a, 25) + q3 = stats.scoreatpercentile(a, 75) + return q3 - q1 + + +def get_dataset_names(): + """Report available example datasets, useful for reporting issues. + + Requires an internet connection. + + """ + url = "https://github.com/mwaskom/seaborn-data" + with urlopen(url) as resp: + html = resp.read() + + pat = r"/mwaskom/seaborn-data/blob/master/(\w*).csv" + datasets = re.findall(pat, html.decode()) + return datasets + + +def get_data_home(data_home=None): + """Return a path to the cache directory for example datasets. + + This directory is then used by :func:`load_dataset`. + + If the ``data_home`` argument is not specified, it tries to read from the + ``SEABORN_DATA`` environment variable and defaults to ``~/seaborn-data``. + + """ + if data_home is None: + data_home = os.environ.get('SEABORN_DATA', + os.path.join('~', 'seaborn-data')) + data_home = os.path.expanduser(data_home) + if not os.path.exists(data_home): + os.makedirs(data_home) + return data_home + + +def load_dataset(name, cache=True, data_home=None, **kws): + """Load an example dataset from the online repository (requires internet). + + This function provides quick access to a small number of example datasets + that are useful for documenting seaborn or generating reproducible examples + for bug reports. It is not necessary for normal usage. + + Note that some of the datasets have a small amount of preprocessing applied + to define a proper ordering for categorical variables. + + Use :func:`get_dataset_names` to see a list of available datasets. + + Parameters + ---------- + name : str + Name of the dataset (``{name}.csv`` on + https://github.com/mwaskom/seaborn-data). + cache : boolean, optional + If True, try to load from the local cache first, and save to the cache + if a download is required. + data_home : string, optional + The directory in which to cache data; see :func:`get_data_home`. + kws : keys and values, optional + Additional keyword arguments are passed to passed through to + :func:`pandas.read_csv`. + + Returns + ------- + df : :class:`pandas.DataFrame` + Tabular data, possibly with some preprocessing applied. + + """ + # A common beginner mistake is to assume that one's personal data needs + # to be passed through this function to be usable with seaborn. + # Let's provide a more helpful error than you would otherwise get. + if isinstance(name, pd.DataFrame): + err = ( + "This function accepts only strings (the name of an example dataset). " + "You passed a pandas DataFrame. If you have your own dataset, " + "it is not necessary to use this function before plotting." + ) + raise TypeError(err) + + url = f"https://raw.githubusercontent.com/mwaskom/seaborn-data/master/{name}.csv" + + if cache: + cache_path = os.path.join(get_data_home(data_home), os.path.basename(url)) + if not os.path.exists(cache_path): + if name not in get_dataset_names(): + raise ValueError(f"'{name}' is not one of the example datasets.") + urlretrieve(url, cache_path) + full_path = cache_path + else: + full_path = url + + df = pd.read_csv(full_path, **kws) + + if df.iloc[-1].isnull().all(): + df = df.iloc[:-1] + + # Set some columns as a categorical type with ordered levels + + if name == "tips": + df["day"] = pd.Categorical(df["day"], ["Thur", "Fri", "Sat", "Sun"]) + df["sex"] = pd.Categorical(df["sex"], ["Male", "Female"]) + df["time"] = pd.Categorical(df["time"], ["Lunch", "Dinner"]) + df["smoker"] = pd.Categorical(df["smoker"], ["Yes", "No"]) + + if name == "flights": + months = df["month"].str[:3] + df["month"] = pd.Categorical(months, months.unique()) + + if name == "exercise": + df["time"] = pd.Categorical(df["time"], ["1 min", "15 min", "30 min"]) + df["kind"] = pd.Categorical(df["kind"], ["rest", "walking", "running"]) + df["diet"] = pd.Categorical(df["diet"], ["no fat", "low fat"]) + + if name == "titanic": + df["class"] = pd.Categorical(df["class"], ["First", "Second", "Third"]) + df["deck"] = pd.Categorical(df["deck"], list("ABCDEFG")) + + if name == "penguins": + df["sex"] = df["sex"].str.title() + + if name == "diamonds": + df["color"] = pd.Categorical( + df["color"], ["D", "E", "F", "G", "H", "I", "J"], + ) + df["clarity"] = pd.Categorical( + df["clarity"], ["IF", "VVS1", "VVS2", "VS1", "VS2", "SI1", "SI2", "I1"], + ) + df["cut"] = pd.Categorical( + df["cut"], ["Ideal", "Premium", "Very Good", "Good", "Fair"], + ) + + return df + + +def axis_ticklabels_overlap(labels): + """Return a boolean for whether the list of ticklabels have overlaps. + + Parameters + ---------- + labels : list of matplotlib ticklabels + + Returns + ------- + overlap : boolean + True if any of the labels overlap. + + """ + if not labels: + return False + try: + bboxes = [l.get_window_extent() for l in labels] + overlaps = [b.count_overlaps(bboxes) for b in bboxes] + return max(overlaps) > 1 + except RuntimeError: + # Issue on macos backend raises an error in the above code + return False + + +def axes_ticklabels_overlap(ax): + """Return booleans for whether the x and y ticklabels on an Axes overlap. + + Parameters + ---------- + ax : matplotlib Axes + + Returns + ------- + x_overlap, y_overlap : booleans + True when the labels on that axis overlap. + + """ + return (axis_ticklabels_overlap(ax.get_xticklabels()), + axis_ticklabels_overlap(ax.get_yticklabels())) + + +def locator_to_legend_entries(locator, limits, dtype): + """Return levels and formatted levels for brief numeric legends.""" + raw_levels = locator.tick_values(*limits).astype(dtype) + + # The locator can return ticks outside the limits, clip them here + raw_levels = [l for l in raw_levels if l >= limits[0] and l <= limits[1]] + + class dummy_axis: + def get_view_interval(self): + return limits + + if isinstance(locator, mpl.ticker.LogLocator): + formatter = mpl.ticker.LogFormatter() + else: + formatter = mpl.ticker.ScalarFormatter() + formatter.axis = dummy_axis() + + # TODO: The following two lines should be replaced + # once pinned matplotlib>=3.1.0 with: + # formatted_levels = formatter.format_ticks(raw_levels) + formatter.set_locs(raw_levels) + formatted_levels = [formatter(x) for x in raw_levels] + + return raw_levels, formatted_levels + + +def relative_luminance(color): + """Calculate the relative luminance of a color according to W3C standards + + Parameters + ---------- + color : matplotlib color or sequence of matplotlib colors + Hex code, rgb-tuple, or html color name. + + Returns + ------- + luminance : float(s) between 0 and 1 + + """ + rgb = mpl.colors.colorConverter.to_rgba_array(color)[:, :3] + rgb = np.where(rgb <= .03928, rgb / 12.92, ((rgb + .055) / 1.055) ** 2.4) + lum = rgb.dot([.2126, .7152, .0722]) + try: + return lum.item() + except ValueError: + return lum + + +def to_utf8(obj): + """Return a string representing a Python object. + + Strings (i.e. type ``str``) are returned unchanged. + + Byte strings (i.e. type ``bytes``) are returned as UTF-8-decoded strings. + + For other objects, the method ``__str__()`` is called, and the result is + returned as a string. + + Parameters + ---------- + obj : object + Any Python object + + Returns + ------- + s : str + UTF-8-decoded string representation of ``obj`` + + """ + if isinstance(obj, str): + return obj + try: + return obj.decode(encoding="utf-8") + except AttributeError: # obj is not bytes-like + return str(obj) + + +def _normalize_kwargs(kws, artist): + """Wrapper for mpl.cbook.normalize_kwargs that supports <= 3.2.1.""" + _alias_map = { + 'color': ['c'], + 'linewidth': ['lw'], + 'linestyle': ['ls'], + 'facecolor': ['fc'], + 'edgecolor': ['ec'], + 'markerfacecolor': ['mfc'], + 'markeredgecolor': ['mec'], + 'markeredgewidth': ['mew'], + 'markersize': ['ms'] + } + try: + kws = normalize_kwargs(kws, artist) + except AttributeError: + kws = normalize_kwargs(kws, _alias_map) + return kws + + +def _check_argument(param, options, value): + """Raise if value for param is not in options.""" + if value not in options: + raise ValueError( + f"`{param}` must be one of {options}, but {value} was passed.`" + ) + + +def _assign_default_kwargs(kws, call_func, source_func): + """Assign default kwargs for call_func using values from source_func.""" + # This exists so that axes-level functions and figure-level functions can + # both call a Plotter method while having the default kwargs be defined in + # the signature of the axes-level function. + # An alternative would be to have a decorator on the method that sets its + # defaults based on those defined in the axes-level function. + # Then the figure-level function would not need to worry about defaults. + # I am not sure which is better. + needed = inspect.signature(call_func).parameters + defaults = inspect.signature(source_func).parameters + + for param in needed: + if param in defaults and param not in kws: + kws[param] = defaults[param].default + + return kws + + +def adjust_legend_subtitles(legend): + """Make invisible-handle "subtitles" entries look more like titles.""" + # Legend title not in rcParams until 3.0 + font_size = plt.rcParams.get("legend.title_fontsize", None) + hpackers = legend.findobj(mpl.offsetbox.VPacker)[0].get_children() + for hpack in hpackers: + draw_area, text_area = hpack.get_children() + handles = draw_area.get_children() + if not all(artist.get_visible() for artist in handles): + draw_area.set_width(0) + for text in text_area.get_children(): + if font_size is not None: + text.set_size(font_size) diff --git a/grplot_seaborn/widgets.py b/grplot_seaborn/widgets.py new file mode 100644 index 0000000..c75cc66 --- /dev/null +++ b/grplot_seaborn/widgets.py @@ -0,0 +1,440 @@ +import numpy as np +import matplotlib.pyplot as plt +from matplotlib.colors import LinearSegmentedColormap + +# Lots of different places that widgets could come from... +try: + from ipywidgets import interact, FloatSlider, IntSlider +except ImportError: + import warnings + # ignore ShimWarning raised by IPython, see GH #892 + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + try: + from IPython.html.widgets import interact, FloatSlider, IntSlider + except ImportError: + try: + from IPython.html.widgets import (interact, + FloatSliderWidget, + IntSliderWidget) + FloatSlider = FloatSliderWidget + IntSlider = IntSliderWidget + except ImportError: + pass + + +from .miscplot import palplot +from .palettes import (color_palette, dark_palette, light_palette, + diverging_palette, cubehelix_palette) + + +__all__ = ["choose_colorbrewer_palette", "choose_cubehelix_palette", + "choose_dark_palette", "choose_light_palette", + "choose_diverging_palette"] + + +def _init_mutable_colormap(): + """Create a matplotlib colormap that will be updated by the widgets.""" + greys = color_palette("Greys", 256) + cmap = LinearSegmentedColormap.from_list("interactive", greys) + cmap._init() + cmap._set_extremes() + return cmap + + +def _update_lut(cmap, colors): + """Change the LUT values in a matplotlib colormap in-place.""" + cmap._lut[:256] = colors + cmap._set_extremes() + + +def _show_cmap(cmap): + """Show a continuous matplotlib colormap.""" + from .rcmod import axes_style # Avoid circular import + with axes_style("white"): + f, ax = plt.subplots(figsize=(8.25, .75)) + ax.set(xticks=[], yticks=[]) + x = np.linspace(0, 1, 256)[np.newaxis, :] + ax.pcolormesh(x, cmap=cmap) + + +def choose_colorbrewer_palette(data_type, as_cmap=False): + """Select a palette from the ColorBrewer set. + + These palettes are built into matplotlib and can be used by name in + many seaborn functions, or by passing the object returned by this function. + + Parameters + ---------- + data_type : {'sequential', 'diverging', 'qualitative'} + This describes the kind of data you want to visualize. See the seaborn + color palette docs for more information about how to choose this value. + Note that you can pass substrings (e.g. 'q' for 'qualitative. + + as_cmap : bool + If True, the return value is a matplotlib colormap rather than a + list of discrete colors. + + Returns + ------- + pal or cmap : list of colors or matplotlib colormap + Object that can be passed to plotting functions. + + See Also + -------- + dark_palette : Create a sequential palette with dark low values. + light_palette : Create a sequential palette with bright low values. + diverging_palette : Create a diverging palette from selected colors. + cubehelix_palette : Create a sequential palette or colormap using the + cubehelix system. + + + """ + if data_type.startswith("q") and as_cmap: + raise ValueError("Qualitative palettes cannot be colormaps.") + + pal = [] + if as_cmap: + cmap = _init_mutable_colormap() + + if data_type.startswith("s"): + opts = ["Greys", "Reds", "Greens", "Blues", "Oranges", "Purples", + "BuGn", "BuPu", "GnBu", "OrRd", "PuBu", "PuRd", "RdPu", "YlGn", + "PuBuGn", "YlGnBu", "YlOrBr", "YlOrRd"] + variants = ["regular", "reverse", "dark"] + + @interact + def choose_sequential(name=opts, n=(2, 18), + desat=FloatSlider(min=0, max=1, value=1), + variant=variants): + if variant == "reverse": + name += "_r" + elif variant == "dark": + name += "_d" + + if as_cmap: + colors = color_palette(name, 256, desat) + _update_lut(cmap, np.c_[colors, np.ones(256)]) + _show_cmap(cmap) + else: + pal[:] = color_palette(name, n, desat) + palplot(pal) + + elif data_type.startswith("d"): + opts = ["RdBu", "RdGy", "PRGn", "PiYG", "BrBG", + "RdYlBu", "RdYlGn", "Spectral"] + variants = ["regular", "reverse"] + + @interact + def choose_diverging(name=opts, n=(2, 16), + desat=FloatSlider(min=0, max=1, value=1), + variant=variants): + if variant == "reverse": + name += "_r" + if as_cmap: + colors = color_palette(name, 256, desat) + _update_lut(cmap, np.c_[colors, np.ones(256)]) + _show_cmap(cmap) + else: + pal[:] = color_palette(name, n, desat) + palplot(pal) + + elif data_type.startswith("q"): + opts = ["Set1", "Set2", "Set3", "Paired", "Accent", + "Pastel1", "Pastel2", "Dark2"] + + @interact + def choose_qualitative(name=opts, n=(2, 16), + desat=FloatSlider(min=0, max=1, value=1)): + pal[:] = color_palette(name, n, desat) + palplot(pal) + + if as_cmap: + return cmap + return pal + + +def choose_dark_palette(input="husl", as_cmap=False): + """Launch an interactive widget to create a dark sequential palette. + + This corresponds with the :func:`dark_palette` function. This kind + of palette is good for data that range between relatively uninteresting + low values and interesting high values. + + Requires IPython 2+ and must be used in the notebook. + + Parameters + ---------- + input : {'husl', 'hls', 'rgb'} + Color space for defining the seed value. Note that the default is + different than the default input for :func:`dark_palette`. + as_cmap : bool + If True, the return value is a matplotlib colormap rather than a + list of discrete colors. + + Returns + ------- + pal or cmap : list of colors or matplotlib colormap + Object that can be passed to plotting functions. + + See Also + -------- + dark_palette : Create a sequential palette with dark low values. + light_palette : Create a sequential palette with bright low values. + cubehelix_palette : Create a sequential palette or colormap using the + cubehelix system. + + """ + pal = [] + if as_cmap: + cmap = _init_mutable_colormap() + + if input == "rgb": + @interact + def choose_dark_palette_rgb(r=(0., 1.), + g=(0., 1.), + b=(0., 1.), + n=(3, 17)): + color = r, g, b + if as_cmap: + colors = dark_palette(color, 256, input="rgb") + _update_lut(cmap, colors) + _show_cmap(cmap) + else: + pal[:] = dark_palette(color, n, input="rgb") + palplot(pal) + + elif input == "hls": + @interact + def choose_dark_palette_hls(h=(0., 1.), + l=(0., 1.), # noqa: E741 + s=(0., 1.), + n=(3, 17)): + color = h, l, s + if as_cmap: + colors = dark_palette(color, 256, input="hls") + _update_lut(cmap, colors) + _show_cmap(cmap) + else: + pal[:] = dark_palette(color, n, input="hls") + palplot(pal) + + elif input == "husl": + @interact + def choose_dark_palette_husl(h=(0, 359), + s=(0, 99), + l=(0, 99), # noqa: E741 + n=(3, 17)): + color = h, s, l + if as_cmap: + colors = dark_palette(color, 256, input="husl") + _update_lut(cmap, colors) + _show_cmap(cmap) + else: + pal[:] = dark_palette(color, n, input="husl") + palplot(pal) + + if as_cmap: + return cmap + return pal + + +def choose_light_palette(input="husl", as_cmap=False): + """Launch an interactive widget to create a light sequential palette. + + This corresponds with the :func:`light_palette` function. This kind + of palette is good for data that range between relatively uninteresting + low values and interesting high values. + + Requires IPython 2+ and must be used in the notebook. + + Parameters + ---------- + input : {'husl', 'hls', 'rgb'} + Color space for defining the seed value. Note that the default is + different than the default input for :func:`light_palette`. + as_cmap : bool + If True, the return value is a matplotlib colormap rather than a + list of discrete colors. + + Returns + ------- + pal or cmap : list of colors or matplotlib colormap + Object that can be passed to plotting functions. + + See Also + -------- + light_palette : Create a sequential palette with bright low values. + dark_palette : Create a sequential palette with dark low values. + cubehelix_palette : Create a sequential palette or colormap using the + cubehelix system. + + """ + pal = [] + if as_cmap: + cmap = _init_mutable_colormap() + + if input == "rgb": + @interact + def choose_light_palette_rgb(r=(0., 1.), + g=(0., 1.), + b=(0., 1.), + n=(3, 17)): + color = r, g, b + if as_cmap: + colors = light_palette(color, 256, input="rgb") + _update_lut(cmap, colors) + _show_cmap(cmap) + else: + pal[:] = light_palette(color, n, input="rgb") + palplot(pal) + + elif input == "hls": + @interact + def choose_light_palette_hls(h=(0., 1.), + l=(0., 1.), # noqa: E741 + s=(0., 1.), + n=(3, 17)): + color = h, l, s + if as_cmap: + colors = light_palette(color, 256, input="hls") + _update_lut(cmap, colors) + _show_cmap(cmap) + else: + pal[:] = light_palette(color, n, input="hls") + palplot(pal) + + elif input == "husl": + @interact + def choose_light_palette_husl(h=(0, 359), + s=(0, 99), + l=(0, 99), # noqa: E741 + n=(3, 17)): + color = h, s, l + if as_cmap: + colors = light_palette(color, 256, input="husl") + _update_lut(cmap, colors) + _show_cmap(cmap) + else: + pal[:] = light_palette(color, n, input="husl") + palplot(pal) + + if as_cmap: + return cmap + return pal + + +def choose_diverging_palette(as_cmap=False): + """Launch an interactive widget to choose a diverging color palette. + + This corresponds with the :func:`diverging_palette` function. This kind + of palette is good for data that range between interesting low values + and interesting high values with a meaningful midpoint. (For example, + change scores relative to some baseline value). + + Requires IPython 2+ and must be used in the notebook. + + Parameters + ---------- + as_cmap : bool + If True, the return value is a matplotlib colormap rather than a + list of discrete colors. + + Returns + ------- + pal or cmap : list of colors or matplotlib colormap + Object that can be passed to plotting functions. + + See Also + -------- + diverging_palette : Create a diverging color palette or colormap. + choose_colorbrewer_palette : Interactively choose palettes from the + colorbrewer set, including diverging palettes. + + """ + pal = [] + if as_cmap: + cmap = _init_mutable_colormap() + + @interact + def choose_diverging_palette( + h_neg=IntSlider(min=0, + max=359, + value=220), + h_pos=IntSlider(min=0, + max=359, + value=10), + s=IntSlider(min=0, max=99, value=74), + l=IntSlider(min=0, max=99, value=50), # noqa: E741 + sep=IntSlider(min=1, max=50, value=10), + n=(2, 16), + center=["light", "dark"] + ): + if as_cmap: + colors = diverging_palette(h_neg, h_pos, s, l, sep, 256, center) + _update_lut(cmap, colors) + _show_cmap(cmap) + else: + pal[:] = diverging_palette(h_neg, h_pos, s, l, sep, n, center) + palplot(pal) + + if as_cmap: + return cmap + return pal + + +def choose_cubehelix_palette(as_cmap=False): + """Launch an interactive widget to create a sequential cubehelix palette. + + This corresponds with the :func:`cubehelix_palette` function. This kind + of palette is good for data that range between relatively uninteresting + low values and interesting high values. The cubehelix system allows the + palette to have more hue variance across the range, which can be helpful + for distinguishing a wider range of values. + + Requires IPython 2+ and must be used in the notebook. + + Parameters + ---------- + as_cmap : bool + If True, the return value is a matplotlib colormap rather than a + list of discrete colors. + + Returns + ------- + pal or cmap : list of colors or matplotlib colormap + Object that can be passed to plotting functions. + + See Also + -------- + cubehelix_palette : Create a sequential palette or colormap using the + cubehelix system. + + """ + pal = [] + if as_cmap: + cmap = _init_mutable_colormap() + + @interact + def choose_cubehelix(n_colors=IntSlider(min=2, max=16, value=9), + start=FloatSlider(min=0, max=3, value=0), + rot=FloatSlider(min=-1, max=1, value=.4), + gamma=FloatSlider(min=0, max=5, value=1), + hue=FloatSlider(min=0, max=1, value=.8), + light=FloatSlider(min=0, max=1, value=.85), + dark=FloatSlider(min=0, max=1, value=.15), + reverse=False): + + if as_cmap: + colors = cubehelix_palette(256, start, rot, gamma, + hue, light, dark, reverse) + _update_lut(cmap, np.c_[colors, np.ones(256)]) + _show_cmap(cmap) + else: + pal[:] = cubehelix_palette(n_colors, start, rot, gamma, + hue, light, dark, reverse) + palplot(pal) + + if as_cmap: + return cmap + return pal diff --git a/setup.py b/setup.py index 3507401..f177c64 100644 --- a/setup.py +++ b/setup.py @@ -1,7 +1,7 @@ from setuptools import setup DISTNAME = "grplot" -VERSION = "0.10.4" +VERSION = "0.11" MAINTAINER = "Ghiffary Rifqialdi" MAINTAINER_EMAIL = "grifqialdi@gmail.com" DESCRIPTION = "grplot: lazy statistical data visualization" @@ -28,10 +28,10 @@ "numpy>=1.15", "scipy>=1.0", "matplotlib>=2.2", - "seaborn>=0.11.2", "pandas>=0.23", ] PACKAGES = ["grplot", + "grplot.analytic", "grplot.features", "grplot.features.add.label_add", "grplot.features.add.log_label_add", @@ -56,6 +56,10 @@ "grplot.features.title", "grplot.hotfix", "grplot.utils", + "grplot_seaborn", + "grplot_seaborn.colors", + "grplot_seaborn.external", + "grplot_seaborn.tests", ] if __name__ == "__main__":