From b91e6355f69151760d9de5900cc34380f9a7957e Mon Sep 17 00:00:00 2001 From: Michael Vincent Mannino Date: Fri, 12 Jul 2024 13:07:18 -0400 Subject: [PATCH 01/11] convert non numericals and color strings to valid colors --- pandas/plotting/_matplotlib/core.py | 32 ++++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/pandas/plotting/_matplotlib/core.py b/pandas/plotting/_matplotlib/core.py index 8b108346160d6..f375f0fa6b05f 100644 --- a/pandas/plotting/_matplotlib/core.py +++ b/pandas/plotting/_matplotlib/core.py @@ -1388,7 +1388,37 @@ def _get_c_values(self, color, color_by_categorical: bool, c_is_column: bool): c_values = self.data[c].values else: c_values = c - return c_values + + return self._prevalidate_c_values(c_values) + + def _prevalidate_c_values(self, c_values): + # if c_values contains strings, pre-check whether these are valid mpl colors + # should we determine c_values are valid to this point, no changes are made + # to the object + + # check if c_values contains strings. no need to check numerics as these + # will be validated for us in .Axes.scatter._parse_scatter_color_args(...) + if not ( + np.iterable(c_values) and len(c_values) > 0 and isinstance(c_values[0], str) + ): + return c_values + + try: + _ = mpl.colors.to_rgba_array(c_values) + + # similar to above, if this conversion is successful, remaining validation + # will be done in .Axes.scatter._parse_scatter_color_args(...) + return c_values + + except (TypeError, ValueError) as _: + # invalid color strings, build numerics based off this + # map N unique str to N evenly spaced values [0, 1], colors + # will be automattically assigned based off this mapping + unique = np.unique(c_values) + colors = np.linspace(0, 1, len(unique)) + color_mapping = dict(zip(unique, colors)) + + return np.array(list(map(color_mapping.get, c_values))) def _get_norm_and_cmap(self, c_values, color_by_categorical: bool): c = self.c From b4440c10e08d9ef9ba935c988c21b3d1f08d161b Mon Sep 17 00:00:00 2001 From: Michael Vincent Mannino Date: Fri, 12 Jul 2024 15:14:05 -0400 Subject: [PATCH 02/11] extract logic into different functions; add plot (WIP) --- pandas/plotting/_matplotlib/core.py | 46 +++++++++++++++++------------ 1 file changed, 27 insertions(+), 19 deletions(-) diff --git a/pandas/plotting/_matplotlib/core.py b/pandas/plotting/_matplotlib/core.py index f375f0fa6b05f..47273b670c07b 100644 --- a/pandas/plotting/_matplotlib/core.py +++ b/pandas/plotting/_matplotlib/core.py @@ -1337,6 +1337,11 @@ def _make_plot(self, fig: Figure) -> None: norm, cmap = self._get_norm_and_cmap(c_values, color_by_categorical) cb = self._get_colorbar(c_values, c_is_column) + orig_invalid_colors = not self._are_valid_colors(c_values) + if orig_invalid_colors: + unique_color_labels, c_values = self._convert_str_to_colors(c_values) + cb = False + if self.legend: label = self.label else: @@ -1367,6 +1372,15 @@ def _make_plot(self, fig: Figure) -> None: label, # type: ignore[arg-type] ) + if orig_invalid_colors: + for s in unique_color_labels: + self._append_legend_handles_labels( + # error: Argument 2 to "_append_legend_handles_labels" of + # "MPLPlot" has incompatible type "Hashable"; expected "str" + scatter, + s, # type: ignore[arg-type] + ) + errors_x = self._get_errorbars(label=x, index=0, yerr=False) errors_y = self._get_errorbars(label=y, index=0, xerr=False) if len(errors_x) > 0 or len(errors_y) > 0: @@ -1388,37 +1402,31 @@ def _get_c_values(self, color, color_by_categorical: bool, c_is_column: bool): c_values = self.data[c].values else: c_values = c + return c_values - return self._prevalidate_c_values(c_values) - - def _prevalidate_c_values(self, c_values): - # if c_values contains strings, pre-check whether these are valid mpl colors - # should we determine c_values are valid to this point, no changes are made - # to the object - + def _are_valid_colors(self, c_values): # check if c_values contains strings. no need to check numerics as these # will be validated for us in .Axes.scatter._parse_scatter_color_args(...) if not ( np.iterable(c_values) and len(c_values) > 0 and isinstance(c_values[0], str) ): - return c_values + return True try: - _ = mpl.colors.to_rgba_array(c_values) - # similar to above, if this conversion is successful, remaining validation # will be done in .Axes.scatter._parse_scatter_color_args(...) - return c_values + _ = mpl.colors.to_rgba_array(c_values) + return True except (TypeError, ValueError) as _: - # invalid color strings, build numerics based off this - # map N unique str to N evenly spaced values [0, 1], colors - # will be automattically assigned based off this mapping - unique = np.unique(c_values) - colors = np.linspace(0, 1, len(unique)) - color_mapping = dict(zip(unique, colors)) - - return np.array(list(map(color_mapping.get, c_values))) + return False + + def _convert_str_to_colors(self, c_values): + unique = np.unique(c_values) + colors = np.linspace(0, 1, len(unique)) + color_mapping = dict(zip(unique, colors)) + + return unique, np.array(list(map(color_mapping.get, c_values))) def _get_norm_and_cmap(self, c_values, color_by_categorical: bool): c = self.c From 571c0c8c8269b4b81ca37e23613db4b1d048487f Mon Sep 17 00:00:00 2001 From: Michael Vincent Mannino Date: Fri, 12 Jul 2024 19:12:30 -0400 Subject: [PATCH 03/11] create labels for custom colors --- pandas/plotting/_matplotlib/core.py | 57 ++++++++++++++++------------- 1 file changed, 31 insertions(+), 26 deletions(-) diff --git a/pandas/plotting/_matplotlib/core.py b/pandas/plotting/_matplotlib/core.py index 47273b670c07b..626c5081fe740 100644 --- a/pandas/plotting/_matplotlib/core.py +++ b/pandas/plotting/_matplotlib/core.py @@ -10,6 +10,7 @@ Iterator, Sequence, ) +from random import shuffle from typing import ( TYPE_CHECKING, Any, @@ -1337,10 +1338,12 @@ def _make_plot(self, fig: Figure) -> None: norm, cmap = self._get_norm_and_cmap(c_values, color_by_categorical) cb = self._get_colorbar(c_values, c_is_column) - orig_invalid_colors = not self._are_valid_colors(c_values) - if orig_invalid_colors: - unique_color_labels, c_values = self._convert_str_to_colors(c_values) - cb = False + # if a list of non color strings is passed in as c, generate a list + # colored by uniqueness of the strings, such same strings get same color + create_colors = not self._are_valid_colors(c_values) + if create_colors: + color_mapping, c_values = self._uniquely_color_strs(c_values) + cb = False # no colorbar; opt for legend if self.legend: label = self.label @@ -1372,14 +1375,14 @@ def _make_plot(self, fig: Figure) -> None: label, # type: ignore[arg-type] ) - if orig_invalid_colors: - for s in unique_color_labels: - self._append_legend_handles_labels( - # error: Argument 2 to "_append_legend_handles_labels" of - # "MPLPlot" has incompatible type "Hashable"; expected "str" - scatter, - s, # type: ignore[arg-type] - ) + # build legend for labeling custom colors + if create_colors: + ax.legend( + handles=[ + mpl.patches.Circle((0, 0), facecolor=color, label=string) + for string, color in color_mapping.items() + ] + ) errors_x = self._get_errorbars(label=x, index=0, yerr=False) errors_y = self._get_errorbars(label=y, index=0, xerr=False) @@ -1404,29 +1407,31 @@ def _get_c_values(self, color, color_by_categorical: bool, c_is_column: bool): c_values = c return c_values - def _are_valid_colors(self, c_values): - # check if c_values contains strings. no need to check numerics as these - # will be validated for us in .Axes.scatter._parse_scatter_color_args(...) - if not ( - np.iterable(c_values) and len(c_values) > 0 and isinstance(c_values[0], str) - ): - return True - + def _are_valid_colors(self, c_values: np.ndarray | list): + # check if c_values contains strings and if these strings are valid mpl colors + # no need to check numerics as these (and mpl colors) will be validated for us + # in .Axes.scatter._parse_scatter_color_args(...) try: - # similar to above, if this conversion is successful, remaining validation - # will be done in .Axes.scatter._parse_scatter_color_args(...) - _ = mpl.colors.to_rgba_array(c_values) + if len(c_values) and all(isinstance(c, str) for c in c_values): + mpl.colors.to_rgba_array(c_values) + return True except (TypeError, ValueError) as _: return False - def _convert_str_to_colors(self, c_values): + def _uniquely_color_strs( + self, c_values: np.ndarray | list + ) -> tuple[dict, np.ndarray]: + # well, almost uniquely color them (up to 949) + possible_colors = list(mpl.colors.XKCD_COLORS.values()) # Hex representations + shuffle(possible_colors) # TODO: find better way of getting colors + unique = np.unique(c_values) - colors = np.linspace(0, 1, len(unique)) + colors = [possible_colors[i % len(possible_colors)] for i in range(len(unique))] color_mapping = dict(zip(unique, colors)) - return unique, np.array(list(map(color_mapping.get, c_values))) + return color_mapping, np.array(list(map(color_mapping.get, c_values))) def _get_norm_and_cmap(self, c_values, color_by_categorical: bool): c = self.c From 1ca57ededeedf936fb43bb8c52efa887eaebe988 Mon Sep 17 00:00:00 2001 From: Michael Vincent Mannino Date: Fri, 12 Jul 2024 22:30:25 -0400 Subject: [PATCH 04/11] same colors for <= 7, then random --- pandas/plotting/_matplotlib/core.py | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/pandas/plotting/_matplotlib/core.py b/pandas/plotting/_matplotlib/core.py index 626c5081fe740..27cb801401207 100644 --- a/pandas/plotting/_matplotlib/core.py +++ b/pandas/plotting/_matplotlib/core.py @@ -1342,7 +1342,7 @@ def _make_plot(self, fig: Figure) -> None: # colored by uniqueness of the strings, such same strings get same color create_colors = not self._are_valid_colors(c_values) if create_colors: - color_mapping, c_values = self._uniquely_color_strs(c_values) + custom_color_mapping, c_values = self._uniquely_color_strs(c_values) cb = False # no colorbar; opt for legend if self.legend: @@ -1380,7 +1380,7 @@ def _make_plot(self, fig: Figure) -> None: ax.legend( handles=[ mpl.patches.Circle((0, 0), facecolor=color, label=string) - for string, color in color_mapping.items() + for string, color in custom_color_mapping.items() ] ) @@ -1408,7 +1408,7 @@ def _get_c_values(self, color, color_by_categorical: bool, c_is_column: bool): return c_values def _are_valid_colors(self, c_values: np.ndarray | list): - # check if c_values contains strings and if these strings are valid mpl colors + # check if c_values contains strings and if these strings are valid mpl colors. # no need to check numerics as these (and mpl colors) will be validated for us # in .Axes.scatter._parse_scatter_color_args(...) try: @@ -1424,10 +1424,16 @@ def _uniquely_color_strs( self, c_values: np.ndarray | list ) -> tuple[dict, np.ndarray]: # well, almost uniquely color them (up to 949) - possible_colors = list(mpl.colors.XKCD_COLORS.values()) # Hex representations - shuffle(possible_colors) # TODO: find better way of getting colors - unique = np.unique(c_values) + + # for up to 7, lets keep colors consistent + if len(unique) <= 7: + possible_colors = list(mpl.colors.BASE_COLORS.values()) # Hex + # explore better ways to handle this case + else: + possible_colors = list(mpl.colors.XKCD_COLORS.values()) # Hex + shuffle(possible_colors) + colors = [possible_colors[i % len(possible_colors)] for i in range(len(unique))] color_mapping = dict(zip(unique, colors)) From fb0d6e459260177083a850de251c78c65ad14954 Mon Sep 17 00:00:00 2001 From: Michael Vincent Mannino Date: Fri, 12 Jul 2024 23:05:59 -0400 Subject: [PATCH 05/11] add test --- pandas/tests/plotting/frame/test_frame_color.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/pandas/tests/plotting/frame/test_frame_color.py b/pandas/tests/plotting/frame/test_frame_color.py index 4b35e896e1a6c..31213ad627fe3 100644 --- a/pandas/tests/plotting/frame/test_frame_color.py +++ b/pandas/tests/plotting/frame/test_frame_color.py @@ -207,6 +207,21 @@ def test_scatter_with_c_column_name_with_colors(self, cmap): ax = df.plot.scatter(x=0, y=1, c="species", cmap=cmap) assert ax.collections[0].colorbar is None + def test_scatter_with_c_column_name_without_colors(self): + df = DataFrame( + { + "dataX": range(100), + "dataY": range(100), + "state": ["NY", "MD", "MA", "CA"] * 25, + } + ) + df.plot.scatter("dataX", "dataY", c="state") + + with tm.assert_produces_warning(None): + ax = df.plot.scatter(x=0, y=1, c="state") + + assert len(np.unique(ax.collections[0].get_facecolor())) == 4 # 4 states + def test_scatter_colors(self): df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3]}) with pytest.raises(TypeError, match="Specify exactly one of `c` and `color`"): From 4bcdbfccbcaaa239dfeb2a256fee0c44a7fbae9a Mon Sep 17 00:00:00 2001 From: Michael Vincent Mannino Date: Fri, 12 Jul 2024 23:28:21 -0400 Subject: [PATCH 06/11] changelog --- doc/source/whatsnew/v3.0.0.rst | 1 + zzz.ipynb | 319 +++++++++++++++++++++++++++++++++ 2 files changed, 320 insertions(+) create mode 100644 zzz.ipynb diff --git a/doc/source/whatsnew/v3.0.0.rst b/doc/source/whatsnew/v3.0.0.rst index 639655ab28199..2d0e0a9cebcb7 100644 --- a/doc/source/whatsnew/v3.0.0.rst +++ b/doc/source/whatsnew/v3.0.0.rst @@ -47,6 +47,7 @@ Other enhancements - :meth:`DataFrame.pivot_table` and :func:`pivot_table` now allow the passing of keyword arguments to ``aggfunc`` through ``**kwargs`` (:issue:`57884`) - :meth:`Series.cummin` and :meth:`Series.cummax` now supports :class:`CategoricalDtype` (:issue:`52335`) - :meth:`Series.plot` now correctly handle the ``ylabel`` parameter for pie charts, allowing for explicit control over the y-axis label (:issue:`58239`) +- :meth:`DataFrame.plot.scatter` argument ``c`` now accepts a column of strings, where rows with the same string are colored identically (:issue:`16827` and :issue:`16485`) - Restore support for reading Stata 104-format and enable reading 103-format dta files (:issue:`58554`) - Support reading Stata 110-format (Stata 7) dta files (:issue:`47176`) diff --git a/zzz.ipynb b/zzz.ipynb new file mode 100644 index 0000000000000..162610119ee67 --- /dev/null +++ b/zzz.ipynb @@ -0,0 +1,319 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+ /Users/mmannino/miniforge3/envs/pandas-dev/bin/ninja\n", + "[1/1] Generating write_version_file with a custom command\n" + ] + } + ], + "source": [ + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+ /Users/mmannino/miniforge3/envs/pandas-dev/bin/ninja\n", + "[1/1] Generating write_version_file with a custom command\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAACCGUlEQVR4nO3dd3xUVfrH8c+dkknvpEFIQkuA0JsUBaRYUawIWFB2XRcbuth+6AoWsCxY14YFXHWxoixYQJAiSC/SSwgkQEICpLdJZs7vj8BASEIJydyZyfP2lZfJvXdmvrkZZp4559xzNKWUQgghhBDCQxn0DiCEEEII0ZCk2BFCCCGER5NiRwghhBAeTYodIYQQQng0KXaEEEII4dGk2BFCCCGER5NiRwghhBAezaR3AFdgt9s5fPgwAQEBaJqmdxwhhBBCnAelFAUFBcTExGAw1N5+I8UOcPjwYWJjY/WOIYQQQog6SE9Pp1mzZrXul2IHCAgIACpPVmBgoM5phBBCCHE+8vPziY2NdbyP10aKHXB0XQUGBkqxI4QQQriZcw1BkQHKQgghhPBoUuwIIYQQwqNJsSOEEEIIj6ZrsbNs2TKGDRtGTEwMmqbx/fffV9mvlGLSpEnExMTg4+PDgAED2LZtW5VjysrKePDBBwkPD8fPz4/rrruOgwcPOvG3EEIIIYQr07XYKSoqolOnTrz99ts17n/llVeYPn06b7/9NmvXriUqKoohQ4ZQUFDgOGb8+PHMmTOH2bNn8/vvv1NYWMi1116LzWZz1q8hhBBCCBemKaWU3iGgciT1nDlzGD58OFDZqhMTE8P48eN54okngMpWnMjISF5++WX+9re/kZeXR5MmTfjPf/7DiBEjgFNz5vz4449cccUV5/XY+fn5BAUFkZeXJ1djCSGEEG7ifN+/XXbMTmpqKpmZmQwdOtSxzWKx0L9/f1auXAnA+vXrKS8vr3JMTEwMycnJjmNqUlZWRn5+fpUvIYQQQngmly12MjMzAYiMjKyyPTIy0rEvMzMTLy8vQkJCaj2mJlOnTiUoKMjxJbMnCyGEEJ7LZYudk86cKEgpdc7Jg851zFNPPUVeXp7jKz09vV6yCiGEEML1uGyxExUVBVCthSYrK8vR2hMVFYXVaiUnJ6fWY2pisVgcsyXLrMlCCCGEZ3PZYichIYGoqCgWLlzo2Ga1Wlm6dCl9+vQBoFu3bpjN5irHZGRksHXrVscxQrg6m02xcY3iPx8oPnxD8fMPimPZLnHdgPBgheVlfLJrNXf+9jm3L/6Md7ev4HhZsd6xhGgQuq6NVVhYyN69ex0/p6amsmnTJkJDQ2nevDnjx49nypQptG7dmtatWzNlyhR8fX0ZNWoUAEFBQYwdO5Z//OMfhIWFERoayoQJE+jQoQODBw/W69cS4rwppZj/LaTsOrVt51bYsx1GjFFERJ+9y1aIuiipKOfhFXNIK8zBTmVh/V3qnyw9nMK7l95MiMVX54RC1C9di51169YxcOBAx8+PPvooAHfddRczZ87k8ccfp6SkhHHjxpGTk0OvXr1YsGBBldVNX3vtNUwmE7feeislJSUMGjSImTNnYjQanf77CHGhDh6oWugAKDvYFPy+GG4crU8u4dl+TNvOgcLjnN5+aFeKY2VFfLtvM39p21u3bEI0BJeZZ0dPMs+O0MuyXxUbV4PdXsNODR7+PzAYpHVH1K/HVs1lw9GaZ5pv7h/CJwNGOjmREHXj9vPsCNEYGA1Q28cNgwbnuPBQiDoxG4xo1PzkMhukVVx4Hil2hNBR63Y1FzuaBq3aVp96QYj60D+6JYrqTzwNGBjTyvmBhGhgUuwIoaOIKI3uJ4ZHOOoaDXz94dJBusUSHm5Q09b0bNIcqCxwTj712gRHMDy+g265hGgoMmYHGbMj9KWUIi0Vtv8JZSUQ0xw6dgVvH2nVEQ3HZrezJGMvyzP2YVN2LomMZ0jTNngZdb1uRYgLcr7v31LsIMWOEEII4Y5kgLIQQgghBFLsCCGEEMLDSbEjhBBCCI8mxY4QQgghPJoMu3cxSimOFuZj0DRC/QJknhUhhBDiIkmx40K2Hz7Apyt+JSPvOADNQsIZ028orSOb6pxMCCGEcF/SjeUi0o5l8a+fvyHzRKEDcCj3GC//+BWZeTk6JhNCCCHcmxQ7LuKXretQquoE7kopbHYbC7et1y2XEEII4e6kG8tF7MvOxF7D/I52pUg9mqlDIiGEEO5OlZVi3fUntsyDaGYL5lZtMTZLaHTjQaXYcRFh/oFk5h2vVvCcHKgshBBCXAh7UQHF82ajiosABZpGxf7dmNt2xvuSgXrHcyrpxnIRl7ftVGvLzsCkzs4PJIQQwq2VrV+BKjlR6ACceI8p37EJW3aGfsF0IMWOi+ga15rhXftwesOiQdMY0bM/7ZvG6ZZLiPpWas1n/5GlHDy6Bru9Qu84woXY7HY2HzvEmqw0isqtesdxa0opKvbvdhQ4VWga5fv3OD+UjqQby4Xc0LUvl7XpwJ8HU9HQ6Ny8BcG+/nrHEqJeKKVYu/s9Vu98E5u98o3MzzuCq3q8TrPwXjqnE3pbl53OSxt/JcdaAoCXwcjdib24tWVnfYO5M3tt63xrYLc7NYrepGXHxYT5BzIwqRMDkjpKoSM8ys70H1i5/V+OQgeguPQo36+4m8ISGYTfmGUU5zNxzXxyTxQ6AFa7jfd3rGTp4b06JnNfmqZhbBYPNQ1EVnZMzRKcnklPUuwIIZxi/Z4ZQNUXXoUdmypn64Gv9QklXML8tO3YqTr1BoCGxtf7NuuSyRNYuvUFk6lawWOMbYExprlOqfQh3VhCiHqRW3iAdXve58CR3/Ey+dG2+Q10bnkXJqMFgLyiNKj2dgagkVe435lRhYs5XJSHqmFsiUJxsCjX+YE8hDEkHL/rbse6ZR0Vh9PQLBbMrdphTuool54LIcSFOl6wj9lLbqTcVoxSNgB+3/YKB7KWc0PfmRg0I8H+cWTn7aRawaMUwf7xTs8sXEdTvyA0TatW8BjQiPUL1ieUhzAEBuPdd7DeMXQn3VhCiIv2x47XqhQ6lRTp2SvZl7EIgG6t/0r1lh0DRqMX7eNudVZU4YKuad4Oo2bgzLYGO4pbZICyqAdS7AghLtr+zCVnFDqVDJqJ/UeWApAUez392j+O0WBx7Pf3juCGPjPx94l0WlbheqJ8A5na8xpCLb6ObRajiXHt+nJZdEsdkwlPId1YQoiLZjCYoHqtAyiMBrPjp+5t/kaHhFFk5mzGbPQhKrQzBs3otJzCdXUJb8Z/B9/JjpwjlNkqaBsSia/JS+9YwkNIsSOEuGhtml3L1v1fVmvdsSsbrWKurLLNYg4gLqKfM+MJN2HUDCSHRusdQ3gg6cYSQly0S5IeJtAnhpOXlmtUttYkx98mEwYKIXQnLTtCiIvm5x3OqMv/x7YDX5OetRKz2Y+kZteREHV5o7vEVQjhejRV0+QGjUx+fj5BQUHk5eURGBiodxwhhBBCnIfzff+WbiwhhBBCeDTpxhJCCCHEBTtWmM/ve7aRV1JEfFgkvVomYTGZz31DHUixI4QQQogLsjZ1F+8unodCoWkaNrud7zeuZOK1Iwnzd73hINKNJYQQQojzVlRWyvtL5mNTduxKYbPbAcgpKmDmigU6p6uZFDtCCCGEOG/r9++h3FZ9FlG7UvyZnkphaYkOqc5Oih0hhBBCnLdiaxlatZXMTimrKHdimvMjxY4QQgghzltSdCyq2qK+lUL9AgjxC3ByonOTYkcIIYQQ5y0+PJJuca2rtO6c/P7WHpdhcMGJROVqLNHgbHY7SzL2svRwChXKRs8mcVwRm4SPi16iKIQQjd2fxw7zY/oOjpcWkRQcybC49jTx8XfsH3f5MOZu+oPFOzZRUFpCbGgTru/am+7xbXRMXTuZQRmZQbkh2ZSdZ9f9zB9H9qOBo+EzISCU1/vcgL/Zomc8IYQQZ/gyZSMf7PgDo6ZhUwoDGj4mM6/3uYEWgWHVjldK6bYsjMygLFzCsowU/jiyH6BKD++Bghy+3rdZl0xCCCFqdqSkgBk7/gDAdqItxI6ixFbOW1uX1Xgbd1j/ToodN1ReUc6+zBT2ZaZQYXO9Ue+nW56xD0MNo/btKH47vEeHREIIIWqzIjO1xu12pfjzeAZ51lInJ6ofMmbHzfyZupmf182jrKIMAIvZm6u6X0uH+I46J6tZhd1e66j9ihMTUQkhhHANNmWHKoMOatrvfqRlx42kZ6fxw6pvHYUOQFl5Kd//8Q2HjqbrmKx2vSLiavwnY9A0+kUlOD2PEEKI2vVo0rzGD6ga0DIwjBAvH+eHqgdS7LiRNbtXYdCq/8kMmoE1u1frkOjchjRrQ2JQkyodWQZNI8TLhxEtu+iWSwghRHXxAaFcH5cM4HjdNmoaRs3A/e37ucX4nJpIN5YbOZZ/FHsNTYh2ZedYwVEdEp2bl9HEtN7D+S51M4sP7cVqt9E3Kp5bWnQmzNtP73hCCCHO8GDypSQGRzAvbRvHSotpFxLJbS270iooXO9odSbFjhsJDwwnOy+rWsFj0AyEB7ruk9DHZGZ06+6Mbt1d7yhCCCHOQdM0rohN4orYJL2j1BvpxnIjPRMvqbVlp2eb3jokEkIIIVyfFDtupFl4c27ofTPeZm/HNm8vH27scwsxYU11TCaEEI1TYXkZv6Tv5LvUP9mb55rDCYR0Y7md5PiOJMW24+DRNECjWXgsJqP8GYUQwtl+z9zHlA2/UmavcFysfVl0C/6vyxDMBqPe8cRppGXHDZmMJuIjWxAfmSCFjhBC6CC7pJDn1y+gzF4BnJqVZnnGPr7Ys16/YKJGUuwIIYQQF2jBwV3Ya1haUgE/HNjq/EDirKTYEUIIIS7Q8bLiWuecybOWImtsuxbpAxFCCCEuUKvA8BqXTtConJjPXSff81TSsiOEEEJcoIFNWxHh7Y/hjKJGAXe26aFPKFErKXaEEEKIC+RtNPN6nxvoGt7MsS3M4ssTnS/nsuiWOiYTNZFuLCGEEKIOIn0DeLnXMPKsJRRXlBPh44+xhvULhf6k2BFCCCEuQpCXD0Fuuhp4YyElqBBCCCE8mksXOxUVFTz99NMkJCTg4+NDixYteO6557DbT42AV0oxadIkYmJi8PHxYcCAAWzbtk3H1EIIIYRwJS5d7Lz88su89957vP322+zYsYNXXnmFV199lbfeestxzCuvvML06dN5++23Wbt2LVFRUQwZMoSCggIdkwshhBDCVbh0sfPHH39w/fXXc8011xAfH8/NN9/M0KFDWbduHVDZqvP6668zceJEbrzxRpKTk5k1axbFxcV88cUXOqcXQgghhCtw6WKnX79+LFq0iN27dwOwefNmfv/9d66++moAUlNTyczMZOjQoY7bWCwW+vfvz8qVK2u937KyMvLz86t8ubPsvCx+WjePzxbP5Kd188jKy9I7khBCCOEyXPpqrCeeeIK8vDySkpIwGo3YbDZefPFFRo4cCUBmZiYAkZGRVW4XGRnJgQMHar3fqVOnMnny5IYL7kS7D+3k6+WzAbArOwey9rNh7zpu7ncbic2SdE4nhBBC6M+lW3a+/PJLPvvsM7744gs2bNjArFmz+Ne//sWsWbOqHHfmtNxKqbNO1f3UU0+Rl5fn+EpPT2+Q/A3NZqvgf6u/x67s2E9MW37y+/+t/h6brULnhEIIIYT+XLpl57HHHuPJJ5/ktttuA6BDhw4cOHCAqVOnctdddxEVFQVUtvBER0c7bpeVlVWtted0FosFi8XSsOGd4OCxdIrLimvcV2ItJv1oOvGRCU5OJYQQ7uloaRF787IJsfjSJqiJrG/lQVy62CkuLsZgqNr4ZDQaHZeeJyQkEBUVxcKFC+nSpQsAVquVpUuX8vLLLzs9r7PZ7NUXoTud3W5zUhIhhHBfFXYbb25dzo9pO1BUrlYe7x/CpO5XEusfonM6UR9cuhtr2LBhvPjii8yfP5/9+/czZ84cpk+fzg033ABUdl+NHz+eKVOmMGfOHLZu3cqYMWPw9fVl1KhROqdveM3CY/EyedW4z8vkRbMmzZ2cSAgh3M/M3Wv5MW27o9ABSCvK5bFVcymXD40ewaVbdt566y2eeeYZxo0bR1ZWFjExMfztb3/jn//8p+OYxx9/nJKSEsaNG0dOTg69evViwYIFBAQE6JjcObxMXgzpciXz185F0zTHWCWlFIO7XFFrISSEEKKS1Wbj+9Qtp5U5lexKkV1axMrM/fSPkYU93Z2mlDrzb9zo5OfnExQURF5eHoGBgXrHuWApGXtZvWslR/OPEh4QTq+kPrSMbqV3LCFEI3XwgGLdH5B9BAKDoHMPaNOu+sUkruBoaREjfp1V4z6jpnF3Yi9Gturq5FTifJ3v+7dLt+yI89MyupUUN0IIl7Bnh2LeN6BpoBQUFcDhdDh+FHr31ztddYFmb3yMZkps5dX22ZSiqV+QDqlEfXPpMTtCCCHch92u+O3nyu9P9hmc/P/q5VBY4HodCV5GIzckdODMNieDptHE25/ekfF6xBL1TFp2dGSz29mcvo/sglyig8JIbhpX7eozIdyJLecotox0NLMXpuYt0SzeekcSTnQ8G4oKa96nFKSlQruOzs10Psa06UlBeRnzD2zH7rgaK5Rnu12B2WDUOZ2oD1Ls6CQz7ziv/PQ1xwrz0dBQKKKCQnj8qlsJ83e/cUOicVN2O6W/L6AiZcepjQYj3pdegblFon7BhFOdqy4wumjdYDQYGN+hP3e27kFK/lFCLL60DAxzyTFGom6kGUEHSineWDiHnKLKldlPXu6YlZ/Lu7/9T89oQtSJddv6qoUOgN1G6bKfsOfn6pJJOF9IWOVXTTWCyQTxLn5RU6i3Lz0imtMqKFwKHQ8jxY4OUrIOczj3OPYzLoSzK8WeI4fJyD2uUzLh8pQCu+uNeyjf+Wft+/Zsc2ISoSdN0xg6rLIF52StoJ14l7n8arB4162AOPO1UpydUgq50Loq6cbSQW5x0Tn2FxIdHOqkNMItFNhhchHMKoFCBd1N8Kw/DHaNZU9USe3P6bPtE54nJlbjzr8r/lwHR7MgIAg6dIXI6AsvdP5I2cEPG1eSkXscf28fBrftwrDOl2By1f4wnamKcso2/EH57i1QbsUQGoGla29MsS30jqY7KXZ00DwsotZ9Bk2jaUi4E9MIl2dTMCwH1lXAyclcN1TAdbnwfTAM1b/gMYRGYM/OhDOnZlMKQ2jtz3fhmYKCNS4dfHH3sWTnn3zy+y+OnwtLSyoLn7xjjLv8uotM6HmUUpQs/AHbkYOOS+Dsx7Mo+fUHvC8fhjmucU9PIt1YOogIDKZXi8RqfcIaMCCpE4E+vvoEE67pFyusPq3QAbBT+YR5tpZLX5zM0qkX1QodTUPz8cXcqq0umYT7qrDb+GbdsmrbFbB63y4OHs92figXZ8tIx5aZfupa/9OUrfu90XdrScuOTv5y2dX4e/uydOefVNhteJlMDG7XlZu699M72gXbm3WYdam7sSk7HZsl0L5pPAYZ3Fd/Vlor/6VWnLHdDmyqgFIFdRwLUV9MsQl4D7iasrXLUScG3hsjm+HddzCa14W1PNlPTMmw7fABvIwmerVIIi48supBNgULrPBrWeXvfpM3dDXX168jdJadn0dBaUmt+3dlHqRZaJOLeozU/GMsOryH0opyOoc1pXdkPEY3nvrDduQQaBp5VLDDYKVEU0TZjbS2e2HKzwFrGTTiqSCk2NGJl8nEnX0Gc2uPy8grKSLY1x+Lyb1erJVSfPbHIn7dvhGDZkADFmxdT5fmLXlg8PWYZH6K+hFkqNZo4uANuMjTxpyQiCm+DaowH0xmDHVoobRWlDPtl2/ZmZGO0WBAKcX8P9dwfZfe3NjtxAeBUgU35sJv1lOvYNOL4XE/mOxfb7+P0I+P19nX9fO9yDft/+7dwIc7V2HUNEBjzv4ttA2O5NVLrsPHzV6HT9K8LGzXSlloLq78GdhsgtX2Um4pD8Lf2Ljf7t23jPUQ3mYvIgND3K7QAdicvo9ft28EwK7s2JQdgI1pKfy2Y7Oe0TzLrd41FztGYKQ3GF2nFU3TNAwBQXUqdADm/7mGXRkHgcpJN09ehfPDxj/Yc+RQ5UFvFsNSa+X3FZxq8XqlCJZbLyK9cBXBvv60jWleYwuxxWSmS/O6X8O+Jy+bD3euAiqXgzj5urUrN4v/7FlX5/vVW0lUNAvNxShAaWA/ceryNDvLgwxoJil2hKiTFXu21dpdtXz3Fien8WBxRvh3YOVHNSOnWnLameCFAB2D1b/fd291zDt1OoNmYMXJS9hnlVR24Z3JBPy3tEHzCecZe+mVBPtWttQZNQMaGiaDkfsHXYe3+ewtP2ez6NDuEy06VdlR/Jy+o4ZbnFu2yiJV7aVCndnXXP+KSos4VnAMm91WZfvO7NTK14gzfjWlwe6yHCpqWPurMWncpZ64KCXl1lrnvyi2ljk5jYcb4wOXmWF2KeQo6G2GYRYwu06rTn2o/XmjKC0/0WqTX1OlQ2UBlFfLPuF2wv0DuTH6HhZt2kWBloWX3Z/use1IbHJxXZVF5bW3/pVUXFhBkK7285T9IVayBIBwInhMm8QthtsvJmKNCorzmbfmB/Zm7AHAx8uH/h0up0ebXgCUlpehaQaUqv5vwK7sVNgqMBndrwehvkjLjqizpOhYtGrL51VePt8uJk6HRB6uhQn+zx9eDYAbvT2u0AFoFxNXY2uhXSkSo5pV/jDAq7KF60wKuLTun/iFa1m9HNYtNxNUkEyz/MuJKOxJ+k5/fpjNRV1Z1DEsBlsNtzeg0TEs5rzvp1gVMcJ+FatZ7th2lCyeUOP4Uc2pc76a2GwVfLr4E1IyUxzbSqwl/Lx+PhtT1gMQFxGPvYZCByA8sAkWc+MdnAxS7IiLMCCxI8G+flXenAyahpfJzNUde+qYTLir67pcgtFgqPacigwMoU+rdpUbnvCr7Mo7veAxAvFGGN24X9A9RUW5Yt0f1bcrBYfT4cSwrjrpH92KhIDQqs8xNAyaxl1tepz3/fxPfUsmh7BRtTtJQ+NN+8t1D1iDXYd2crzgWI2tNsu3LkEpRVxEPAmRLap8AD35/eWdhjT65S+kG0vUmb+3D/+8/na+XruMtam7sNsVHWMTuLnHZUQFhegdz+PllxTz287N7M5Mx9/iQ9/WyXRoFu/WL2pxYZFMvHYU36xbzvbDBzAZjfRu2Y6bu/fDcnKcRrIZFofCpEJYZAUvKgdxT/aHgLN/fkvNzuS3nZs5WpBHbFgTBrXtQkRgcIP/XuLC5OfBWXqbyD4CMbF1u28vo5HpvYfzya41LDy4izJbBR3DYrgnqRftQqLO+3528CcmzFRQtetLodjNdpRS9fZvMTMnE4NmqLHlJq84D2uFFYvZwojLRrNs629sTFlPqbWU6NAYeib2Zc+xPOZu+RpfLwt9W7enU2wLt36dqAtNNfaZhoD8/HyCgoLIy8sjMFBWHK+Lk0+jxvYPSC/ZBbk8N/dzCkpLUEph0DTsSnF1x56M6Nlf73j14rzeLJSqedXJGizfvZUPl/3kOFcGTcNoMPL4VbfQ5mQXmXAJJcWK96fXOD8eAMNugVZJ9fNaU9ei5B37NKar57HXMFo+jCasNabUcKu6Wbt7NT+vn1/jPi+TF4/d9H8YzpgjSClFTnEhz/3wGbnFRShOvU4MbteFO/pc5BTXLuJ837+lG0vUC03TpNBxotmrl1J4otCBUwsl/vjnGtKOZekZrd6c1/PpPJ9zxdYyZq1YAJw6V3alqLDZ+HDZz41+dllX4+Or0Sqp+p9X08DXDxJa199j1fV160ZtJEaM1cYtamjcof21PqI5JMd1ODG4uPpjdW3VvVqhA5W/19drl5FXUuS4wvHkc//X7RtJyTpcrxldnRQ7QrgZm93OhgN7arwSzqBprNu/W4dUrm1LeirlNlu17QrFkfwcMnKP65BKnM3gayCqadVtPr4wfCQYXWBuqSgthncMn+GND3BqfMw13MjftX/U62P5WHy57bJRp7pyT2gV05oBHQbVeBulVOXwghpfJwysTW1crxMyZkcIN6NQtV7yDxo2u1x+fSZbLVepnFRhr14ICX15+2iMGKM4nF45Rsc/oLJFxxUKnZMGaVex2rCHX9WPFJBPD60PSVr7BnmshKiWjB/+GLsP7aKkrJhm4bFEh5796jG7vfYWy8b2OiHFjhBuxmQw0i6mOTsz0qsVPXZlp1NsC52Sua52J2bjralIDPb1p1lIuA6pxLlomkbT5tC0ud5JauevBTBcG+GUx/IyeZEc1+G8jtU0jQ6xCfyZvk9eJ5BuLCHc0m09B2AyGqvNSdMzIZHWkU1ruVXjFezrz/CufYFTYzQMWmXHwx29B9U45kEId3dLj8vwMpmrvU50ad6S9k0b11xocjUWcjWWcE+Hc4/x459r2HE4nQBvby5t04GBSZ3kjfss1qXuZuH2DRwtyKN5WARXdeghV2IJj3YkL4cft6xh26ED+Hp5c2mbZAa27eQxCzWf7/u3FDtIsSOEEEK4I7n0XAghhBACKXaEEEII4eGk2BFCCCGER5NiRwghhBAeTYodIYRoQDWtVC3cm1JKlhhxMzKpoBBC1DOl7GzY+zEb9n5MUekRAn2b0b3N3+gQP1LWkHNjKbsUfyytnNHZYoHkroo+/cFklr+pq5NiRwgh6tmyLVPYmPKJ4+f84oMs3vQMJWXH6ZX0gI7JRF3t2aGY9w2OtTjLymDDKsjKhJtG123ldOE80o0lhBD1qKg0i037ZtW4b82udygrL3ByInGxlFL8vujkD6dvh/RUOJSmSyxxAaTYEUKIepRxfGOt43Rs9jKy87Y7OZG4WKUlkJtT8z5Nk2LHHUixI4QQ9chiPvss7OfaL1yPyVxZ1NREKbB4OzePuHBS7AghRD1qGtYDP+9ItDNeXjUMhAa0IjwwSadkoq7MZo3WbWsueAwGaNPO+ZnEhZFiRwgdVNhsZOblkF9SrHcUUc8MBhPX9Hwbk8kH0DBoJkDDYg7kqh5vyEBWNzXgCggOrfzeYKgsfDQNrrgefP3kb+rqZCFQZCFQ4TxKKX7dvpE5G1ZQVFYKQOfYFtx96RUE+/rrnE7Up5KyHHamf09ecToh/i1Jir0OizlA71jiIlRUKPbugMzD4OMLbTtAYLAUOnqSVc8vgBQ7wll+27GJmSsWVtlm0DQiA0N44aYxmAxGnZIJIYT7kVXPhXAxSil+2PRHte12pcjIO86mtBQdUgkhhOeTSQWFcJJiaxk5RYU17jNqBtKOZdE9vo2TUwk97VLb+Vx9SKpKoaXWmtu1v9JKS9Q7lhAeR4odIZzEYjbjZTJhraiots+m7ITImJ1G5Rf1P+6334mGho0KVqllfKE+5n3DfxmoXaF3PCE8inRjCeEkJoOR/okdq12No6FhMZnp2UIuSW4sylQZT9ofQGHHRmXxazvx3+P2cZSrcp0TCuFZpNgRwolu6XEZHZrGV9nmbfbikaE34iczkzUaa1lJHjkoql4folAcI5vNrNcpmRCeSbqxhHAii8nMP668mdTsTFKyDxNg8aVzXEssJrPe0YQTnWzNqU0F0rIjRH2SYkcIHSQ0iSKhSZTeMYROunEJPvhSQvVJJQMIpDPddUglhOeSbiwhhHAyfy2AJ7XnATBQObeS8cT/J2pT8dZ8dMsmhCeSlh0hhNDBHYa/0lzF87H9Hfaxh1YkMtbwAP20gXpHE8LjSLEjhBA66a8Nob9xiN4xhPB40o0lhBBCCI8mxY4QQgghPJoUO0IIIYTwaFLsCCGEEMKjSbHjSezq3McIIYQQjYwUO+5OKXinGNpkg19W5f//XVy5XQghhBBy6bnbm1wELxed+jndDhMK4IgNngvQL5cQQgjhIqRlx50ds8P0opr3vV4MR+3OzSOEEEK4ICl23NmGcmpdL7D8xH4hhBCikXP5YufQoUPcfvvthIWF4evrS+fOnVm/fr1jv1KKSZMmERMTg4+PDwMGDGDbtm06JnaioHP8+QI15+QQQgghXJhLFzs5OTn07dsXs9nMTz/9xPbt25k2bRrBwcGOY1555RWmT5/O22+/zdq1a4mKimLIkCEUFBToF9xZupsgwciJ9QNPMQLxBuhp1iOVEEII4VI0pVz3sp0nn3ySFStWsHz58hr3K6WIiYlh/PjxPPHEEwCUlZURGRnJyy+/zN/+9rcab1dWVkZZWZnj5/z8fGJjY8nLyyMwMLD+f5ELoJTiSEkBmqYR4e2Ppp2jdWZDOVydA/mqcrh5BZUtOvNDoJsUO0IIITxXfn4+QUFB53z/dumWnblz59K9e3duueUWIiIi6NKlCzNmzHDsT01NJTMzk6FDhzq2WSwW+vfvz8qVK2u936lTpxIUFOT4io2NbdDf43xtPHqQu5f8l9GLP2PUov/w12Vfsu14xtlv1NUMO8NhegDc6wvTAmBHuBQ6QgghxAkuXezs27ePd999l9atW/PLL79w33338dBDD/Hpp58CkJmZCUBkZGSV20VGRjr21eSpp54iLy/P8ZWent5wv8R5Ssk/ypOr53GwKNexbX9BDhNWzeVgYW6ttwMg2AD3+cK/AuDvvhDi0n9WIYQQwqlcep4du91O9+7dmTJlCgBdunRh27ZtvPvuu9x5552O487s6lFKnbX7x2KxYLFYGiZ0HX2zbzMKxel9igpFhbIzZ/8WHky+VLdsQgghhDtz6SaA6Oho2rVrV2Vb27ZtSUtLAyAqKgqgWitOVlZWtdYeV7crNwtbDcOn7EqxOzdLh0RCCCGEZ3DpYqdv377s2rWryrbdu3cTFxcHQEJCAlFRUSxcuNCx32q1snTpUvr06ePUrBcrwscfA9VbowyaRhMffx0SCSGEEJ7BpYudRx55hFWrVjFlyhT27t3LF198wQcffMD9998PVHZfjR8/nilTpjBnzhy2bt3KmDFj8PX1ZdSoUTqnvzDD4pKxU3PLzrVx7XVIJIQQQngGlx6z06NHD+bMmcNTTz3Fc889R0JCAq+//jqjR492HPP4449TUlLCuHHjyMnJoVevXixYsICAAPdaF6pvVAJ3tenBp7vXOkoeg6bx16RL6BreTNdsQtSrXDusKQdfDS4xg0kmvxRCNCyXnmfHWc73On1nyCopYE1WGpqmcUlEHGHefrrmEaLeKAX/KoYXC+HkNFfRBpgVBJd66RpNCOGezvf926VbdhqjCJ8A6bYSnml2KfyzsOq2I3a4Lge2hkPTM6cCF0KI+uHSY3aEEB7ktWKqjcG3U7lo7awSHQIJIRoLKXaEEM6xz0YNY/ArpdicGkUI0bhIsSOEcI6WxppfcRTQSrqwhBANR4odIYRzjPet7LY6nQGwAHf56BBICNFYyABlIS5CqTWflIwFWCsKaRZ+CU2CkvSO5LpG+sBhO7xQCKUntkUbYGYQxEjLjhCeyFpRwca0veQWFxIXFkliVLOzLufUUKTYEaKO9hz6mV/WPUqFvYzKkbeKNk2v4Yru0zAaZNX5Gv3DD/7qA2tPzLPT0wxGmWdHCE+UkpXB9F++pbCsBA0NhaJlRAz/uOIm/CzeTs0i3VhC1EF+8SF+XPsQFXbriS2VI293H/qRdbvf1y+YOwg0wCAL9PaSQkcID2WtqGD6L99SZK1sxj25zHVqdgazViw8200bhBQ7QtTB9rTvTnx35uVFij9TP3d2HCGEG1LKjqfO67s5PYXCspJqv59dKdam7qKorLSWWzYM6cYSog6KSo6caJatrrjsmNPzCCHcx97De1iyZREZxw/jZbLQpWVXBnS4HC+zRe9o9SanqPBE5351dqUoLC1xaleWtOwIUQcRwe2xq4pq2zUMMkhZCFGrPYd28d+l/yHzeAYA1ooy1uxexedL/oNSZ16u6L7iwyNrnVbL18tCqL9z16+UYkeIOkiMvQ5/70g0repVRAo7vRIf1CmVEMLVLd78K5wYrHuSUoqDR9NIyUjRL1g9ax3ZlNaRMRhquPLqmk69MBud27EkxY64IKXWUtbuXs1P6+axcsfvFJUWnvtGHsjL5Mctl31JbPgljm3+3pFc2X06LWOG6JhMCOGqrBVWsvKOUFPnjkEzkJZ9wPmhGoimaTwy9CZ6tUhyFDy+XhZu7XEZ13Ts6fQ8F1Ra3XTTTXzwwQeEhYU1VB7hwo7kHuE/iz6hxFqMQTOglGLZlt8YOeB24iIS9I7ndEF+sdzY71OKy45RXlFMgG8MBk3mixFC1MxoMGI0GLHZqy+PopTC28u5l2M3ND+LN/cNvJY7+w6hoLSYUL8Ap7fonHRBLTsZGRm0b9+e//3vfw2VR7gopRTfr/yG0vLKBRvtyo5CUWGr4Jvfv6rxH29j4WsJI8gvVgodIcRZGQ1GkuM61jypngbJcR2cH8oJfL0sRAaG6FbowAUWOytWrOAf//gHI0aMYOzYsRQUFDRULuFijuZnk5V3pNplhApFcVkR+4/s0ymZEEK4j8FdriA8sAlQ2XWlaRoaGsN6DifQN0jndJ7rgsosTdN47LHHGDZsGHfffTcdOnTgoYcewmSqejcPPfRQvYYU+isrP/ucCKXlZU5KIoQQ7svX4stfr7iPnYd2cjA7DR+LLx3iOxHiH6J3NI9WpzalpKQkxo4dy3333cdrr71WpdjRNE2KHQ8UERyFl8kLa4W12j4NjdjwWB1SCSGE+zEaTbRvnkz75sl6R2k0LrjYOXLkCH/5y1/4/fff+eijj7jrrrsaIpdwMV4mLy5LHsCvmxZU29e9TU9pfhVCCOGyLqjYmT17Ng888ABdunThzz//JDZWPs03Jpck9cXH4svK7cs5VnCMQN9AeiX2pldib72jOUVOUSGLd2xiX/ZhAn386J/YkaRo+TdwUr7KZbaaxUq1FH/8uc5wK0O4RpcVjoUQ4nSauoCFOfz8/HjppZd48EHPmjQtPz+foKAg8vLyCAwM1DuOW1BKNao3sYPHs3lx3n8pLbdiVwqDpmFXqnLOiE699I6nu2x1hJvsgzjMQezYMWDEjo1buZOphrca1XNFCOE85/v+fUFXY23atMnjCh1RN43tzevTlb86Ch3A8f+v1y7jaEGentFcwutqKhkcwk7ldPd2Kqci+IpPWcVyPaMJIcSFdWO1bt26ys/bt28nLS0Nq7XqoNXrrrvu4pMJ92FVsLIcKhRcYgZ/z5qYu7C0hF2ZB2vZq7HhwF6GJndzaiZXM199i43qcy2ZMPGz+oHe2mU6pBL1waqsrOMPbFTQlV74af56RxLigtXpaqx9+/Zxww03sGXLFjRNc8y9cvLTvs3WeCeYa3T+Vwr35cPxE72hfsDUAPirr66x6pP9bD29GlQ04gkVT6qg+qKo57NPuLaFaj5P2MeRSw4AvvjylPYiow1jdU4mxIWp00fwhx9+mISEBI4cOYKvry/btm1j2bJldO/enSVLltRzROGytlfAqDzIOa0YKAIeKoCFnjPvToC3D81Dm6BRvetOKUWn2BY6pHItl3MlRqrPIF1BBQO1K3RIJC7WbrWDcfbbySPXsa2YYp5Rj7BM/apfMCHqoE7Fzh9//MFzzz1HkyZNMBgMGAwG+vXrx9SpU2WOncbkg+LK/5/Z8GEE3ix2dpoGo2kao3sPwmDQHAvanSx8BrXtTNOQcD3juYRHDBPxw99R8Ggn/uvH5QxEih139Ln6EKDK6twABox8ZP+3HpGEqLM6dWPZbDb8/Sv7bcPDwzl8+DCJiYnExcWxa9eueg0oXNheGzX2UNiA3Z7VdZEUHcuz19/Oj3+uZe+RQwT7+jMwqRN9W7fXO5pLSNBa8T/Dcj5Qb7BMLcKfAG7URnK79leMjWDNsMKSQv7Y+Ts703dgMBho1zyZ3kl98Pby0TtanaWqlBrHYdmxsY899f+ARQreLoLZpVCi4EoLPOoHzT3/+SMaXp2KneTkZP78809atGhBr169eOWVV/Dy8uKDDz6gRQtp0m80WhthKdULHiOQqN+Cbw0lLiySvw+8Vu8YLitWi+d57TW9YzhdUWkhHy14n4KSfMf4xRXbl7EzfTv3DL0Xi9mic8K6aaG14g+1DNsZ/8CNGGlJm/p9MKuCa47D2gpOXNAHH5XAN6WwIgzipOARF6dO3VhPP/00dnvlM/KFF17gwIEDXHrppfz444+88cYb9RpQuLB7TwxCPnMoiw14yHMGKAtxNqt2/lGl0IHKsVxH87PZlLJex2QXZ7T2F0BVG6tmw8ZYw/31+2DflMLq0wodqPwQlavg5cL6fSzRKNXp4/cVV5zqg2/RogXbt2/n+PHjhISENLr5Vxq1tib4Mhjuy4PsEy/0/hq87A+D3evTrFKK9KNpZBw/jL+3P22aJmE2mXXNtC87g71HDuNn8aZrXGt8vLx0zSNqtvvQTmqbm3X34d30Surj5ET1o7WWxHuGL3jCfj/HOQqAH/5M1KZwqTaofh/sF2tli/CZvWY2YL7nXOwg9FOnYueee+7hjTfeICAgwLEtNDSUoqIiHnzwQT7++ON6Cyhc3NUWSGkCq8uhXEEvL/B1r4K31FrK7KWfkX40DQ0NhcLby4fbLhtNbJPmTs9jrSjnrV9/4M+DqWhUjv+2mMw8OPh6OjRLcHoecXZGY80voxoaJoN7d78M0q7iD8MuNrKGcsrpSk98tAZotT1bHW92r9cT4Zrq1I01a9YsSkpKqm0vKSnh008/vehQws2YNejnBQMtblfoAPyy4UcOHksHTl15UnaiACqvYZX3hvbtut/Zcmj/iTyVrBXlvLHwewpLq/+7E/pKbp5c87QEKNp5wKrWZs1MT60vfbUBDVPoANzgXb1VBypbe271bpjHFI3KBRU7+fn55OXloZSioKCA/Px8x1dOTg4//vgjERERDZXVLZ11Qjqhu7LyMrbu/7NaN4RCUVpeys6DO52ax26389vOzTXkgQpbBX+k7HBqHnFuPdr0Ijqs6YmfNEfh0zK6NcnxHevtcS5gGUPXYT/PzFd6wYgTXd9GKscBalReBPGYXwOFE43JBXVjBQcHo2kamqbRpk310fiapjF58uR6C+eu7HY7P29dxy9b15NbXEiTgCCu7dSL/okdZUyTiymxlmBX9hr3aZpGYUm+U/NYbRWUVZTXuM+gGcgtlsGarsZs8uKuQXezZf+f7D60C4OmkRTbjvbNkzFcZDeWUoryHZuwbl2PKipA8wvAK7kb5radXfu15LMSeKUI9tggwgDjfOAffmCqJbNBg4+DYHhZ5WDlElU57u8Ob49bfkbo44KKnd9++w2lFJdffjnffvstoaGhjn1eXl7ExcURExNT7yHdzeerFvPr9o2On7ML8vjk9wUUlpVyrayQ7VICfALw8fKhxFq9e0gpRVSIc5/PFpOZcP9AjhZWL7Jsyk5cWKRT84jzYzKa6dKyG11a1u8aadYNK7H+ucbxsyoqoGz1ElRJEZZu/er1serNO8Xwj4JTV2lm2WFyEeyzwftBtd/OoMFw78ovIerZBRU7/fv3ByA1NZXY2FgMhsZVcdtsNsrLa/7UfVJucREbUnYRYqnet710+0YubdEWi1muqmlIZrMZo/H8PlEbDUb6tb+MhRt/qbJd0zSiQ2KIj3TugGBN0xjetS8fLvupynaDphERGEzX+FZOzSP0o0pLsG5dV+M+69b1mNt3w+DtYpMWlip47kTr4+k9WAr4tBQe94OWnjcHl3B9dXrWxcXFAVBcXFzjqucdO9ZfP7UrUEqRmZlJbm7uOY8tqyjnxsTaP90dOHAAcy1Xb4j6ExwcTFRU1Hk19fdK7INS8Pv2ZZRaS9A0jXax7bmq+7W6dBVc2iaZClsF361fQX5pMRrQMbYFd/cb6vZX94jzZzt2BOx2SrGz3WglT7MTpAy0tXnhYwf70SMYmsXrHbOqXRWQd5ZxOn+US7EjdFGnZ112djZ33303P/30U437PW3V85OFTkREBL6+vmd9Ayy1WjlamFfr/ojAYLx0nr/FkymlKC4uJisrC4Do6Ohz3kbTNHq37UvPNr3IK87H1+Kj+zT/A9t25rLEjhwrzMfXy4K/q32CFw1O87KQqVXwnVcBViqvJrEDq0wl3GgNoIUrzrsUfI7W/kAXHmckPFqdip3x48eTk5PDqlWrGDhwIHPmzOHIkSO88MILTJs2rb4z6spmszkKnbCwsHMeb7FYyC8vxWavPujVy2QiwM/ftQcWegAfn8rCICsri4iIiPPv0jKaCA0IPfeBTmI0GIgIDNY7htCJFhbBj5YSyhWgnZpcuFzBfEsxD4W74PitOCP0MsG6iqqXkmtAkAZD3WuyUeE56lTsLF68mB9++IEePXpgMBiIi4tjyJAhBAYGMnXqVK655pr6zqmbk2N0fH3Pb34J7cTYisy8HJRSaBooVfnG1SQgSAodJzn59yovLz/vYkcIV3L4+GHyqai2HIvSoAAbh44d0mXSy3P6MAiG5MARe+U7jI3KSQO/CAJvef0T+qhTsVNUVOSYTyc0NJTs7GzatGlDhw4d2LBhQ70GdBUXUqR4m72IDQ2nsKyUCpsNs9GEv8W70Q3o1pMUlcLdlZWXnmO/iy6j0MoEW8Lg61LYWgGxRhjpDZHyoUPop07FTmJiIrt27SI+Pp7OnTvz/vvvEx8fz3vvvXdeYyQaA6PBSJCPTIYlhKibmNCmGA1GbPbqYyCNBiMxjokMXZC/Ae6WxYCF66hTU8P48ePJyMgA4Nlnn+Xnn38mNjaWN954gylTptRrQOHaJk2aROfOnfWOIYTH8bH40qdtzXPp9G7bD98aprcQQtSsTi07o0ePdnzfpUsX9u/fz86dO2nevDnh4eH1Fs6V3fXhq059vFl/eaxOt1u5ciWXXnopQ4YM4eeff67nVEKIhtS/w+X4+wTwx44V5BblEOwXTO+2/ejWqofe0YRwK+dd7Dz66KPnfafTp0+vUxhR/z7++GMefPBBPvzwQ9LS0mje3AUHNAohaqRpGt1b96R7654nLniQsWhC1MV5d2Nt3LixyteHH37I+++/z5IlS1iyZAkffPABH330EZs2bWrAuOJCFBUV8dVXX/H3v/+da6+9lpkzZzr2LVmyBE3TmD9/Pp06dcLb25tevXqxZcsWxzEzZ84kODiY77//njZt2uDt7c2QIUNIT08/6+N+8skntG3bFm9vb5KSknjnnXcc+6xWKw888ADR0dF4e3sTHx/P1KlT6/13F8LTSKEjRN2dd7Hz22+/Ob6GDRvGgAEDOHjwIBs2bGDDhg2kp6czcOBAj7rs3N19+eWXJCYmkpiYyO23384nn3xSbeXkxx57jH/961+sXbuWiIgIrrvuuipLYhQXF/Piiy8ya9YsVqxYQX5+PrfddlutjzljxgwmTpzIiy++yI4dO5gyZQrPPPMMs2bNAuDNN99k7ty5fPXVV+zatYvPPvuM+Pj4Bvn9hRBCCKjjmJ1p06axYMECQkJCHNtCQkJ44YUXGDp0KP/4xz/qLaCou48++ojbb78dgCuvvJLCwkIWLVrE4MGDHcc8++yzDBkyBIBZs2bRrFkz5syZw6233gpUzlPz9ttv06tXL8cxbdu2Zc2aNfTs2bPaYz7//PNMmzaNG2+8EYCEhAS2b9/O+++/z1133UVaWhqtW7emX79+aJrmWHpECCGEaCh1uhorPz+fI0eOVNuelZVFQUHBRYcSF2/Xrl2sWbPG0QpjMpkYMWIEH3/8cZXjevfu7fg+NDSUxMREduzY4dhmMpno3r274+ekpCSCg4OrHHNSdnY26enpjB07Fn9/f8fXCy+8QEpKCgBjxoxh06ZNJCYm8tBDD7FgwYJ6/b2FEEKIM9WpZeeGG27g7rvvZtq0aVxyySUArFq1iscee8zxiV7o66OPPqKiooKmTU/NxaGUwmw2k5OTc9bbnjk2oKaxAjVts59YImPGjBmOlqCTTs5i3LVrV1JTU/npp5/49ddfufXWWxk8eDDffPPN+f1iQgghxAWqU7Hz3nvvMWHCBG6//XbH+A6TycTYsWN59VXnXpItqquoqODTTz9l2rRpDB06tMq+m266ic8//5zk5GSgskg9eYVWTk4Ou3fvJikpqcp9rVu3ztFltWvXLnJzc6scc1JkZCRNmzZl3759VaYnOFNgYCAjRoxgxIgR3HzzzVx55ZUcP36c0FDXWZdKVJVzTLFuJRxIBS8LtO8InXqAySSDZkXdrFOr+MD+OtvYTAzNuEO7l2HazS49EDszJ4MV25dz8Gg6fhY/urbqTpeWXdE0mR3f1dWp2PH19eWdd97h1VdfJSUlBaUUrVq1ws9PZgx2BfPmzSMnJ4exY8cSFBRUZd/NN9/MRx99xGuvvQbAc889R1hYGJGRkUycOJHw8HCGDx/uON5sNvPggw/y5ptvYjabeeCBB7jkkktqHK8DlZMMPvTQQwQGBnLVVVdRVlbGunXryMnJ4dFHH+W1114jOjqazp07YzAY+Prrr4mKiiI4OLihToe4SMeyFf/9GCrKK9d5A1j2KxzYB8NHKgwG131zEq5poZrPffZRGDBgw8YRMlivVrObHUzQ/ql3vBqlZe3nP4tnAmBXdvKL85i/di6HjqUzrNcN+oYT53RR5aifnx8dO3akU6dOUui4kI8++ojBgwdXK3SgsmVn06ZNjjXMXnrpJR5++GG6detGRkYGc+fOxcvLy3G8r68vTzzxBKNGjaJ37974+Pgwe/bsWh/7L3/5Cx9++CEzZ86kQ4cO9O/fn5kzZ5KQkACAv78/L7/8Mt27d6dHjx7s37+fH3/8UdYNc2Erfqta6Jx0YB/sT9Enk3BfdmVnkn0CALYTS6PbT6zp/q6aRoY6pFu2s1mw8WeUUtiVvcr2Tfs2kpmToVMqcb40dea1yI1Qfn4+QUFB5OXlERgYWGVfaWkpqampJCQk4O3trVPC+rdkyRIGDhxITk5Ora0qM2fOZPz48eTm5jo1W33Q6++mlMKenYEtOxPN2xdT85ZoZrPTHr8hvDlVYauovt1ggA5d4fKrpGVHnL8UtZsh9u617n9J+ze3Gu5wYqJzK7GW8K9va54PTNM0BnQYRL/2lzk5lYCzv3+frk7dWEKI6lS5lZJFc7FlnDbpotkLn0HXYYqO1S/YRTIYoPpSlCf2yULW4gKZzvG244XrfTgwnG1MjqpcmFW4Nuk7EKKelK5dji3zYNWN5eWU/PoDylqmT6h6kNgOahozardD67bOzyPcW3MSSKQ9hhrefsx4MVC7QodUZ2cxW2gR1bLGwdMKRVJsOx1SiQshxU4jNWDAAJRSZx0YPGbMGLfswtKDslVQsXdb9YEtKKgop3z/bl1y1YfeAyAgEDjxOn/y9b5Td4hpplcq4a40TeMlw1t4442RyhYRI0Y0NJ7TphOkhZzjHvRxRber8TZ7Owqek1dgXd5pMCH+rplZnOJWxc7UqVPRNI3x48c7timlmDRpEjExMfj4+DBgwAC2bdumX0jRKCmrFWy1dPZoGqq4yLmB6pF/gMboe+GyQZDQGtq0g+tvg4FXynpNom46ad35xbCWv2oPM4Ch3KrdyfeGJYww3Kl3tFqFBzbhvqsf5LLkAbSKbk3H+E7cOege+raTsTruwG3G7Kxdu5YPPviAjh07Vtn+yiuvMH36dGbOnEmbNm144YUXGDJkCLt27SIgIECntKKx0bx90Hz8UCU1FDVKYQyLcH6oeuTtrdGtN3Trfe5jhTgfTbVYHtcm6R3jgvj7+HNZ8kC9Y4g6cIuWncLCQkaPHs2MGTOqrMellOL1119n4sSJ3HjjjSQnJzNr1iyKi4v54osvdEwsGhtN0/Dq3KumHRhCwjE2jXd6JiGEEJXcoti5//77ueaaa6osYAmQmppKZmZmlVmCLRYL/fv3Z+XKlbXeX1lZGfn5+VW+hLhY5sSOWHoNAMuJS901DWPzlvhccROazCMkhBC6cflurNmzZ7NhwwbWrl1bbV9mZiZQuUzB6SIjIzlw4ECt9zl16lQmT55cv0FFo6dpGl7tumBO6ogqKkDz8kazeM7cTEII4a5c+uNmeno6Dz/8MJ999tlZJ4Y7c5CkUuqsAyefeuop8vLyHF/p6em1HivEhdIMRgwBwVLoCCGEi3DpYmf9+vVkZWXRrVs3TCYTJpOJpUuX8uabb2IymRwtOidbeE7Kysqq1tpzOovFQmBgYJUvITyVzW7nYGEux8uKz3rMoaK8sx4jRH2rsJWSU5BKqTWvwR/LarORXphLvrW0wR9LuB6X7sYaNGgQW7ZsqbLt7rvvJikpiSeeeIIWLVoQFRXFwoUL6dKlCwBWq5WlS5fy8ssvN2w4nyMNe/9nKqm9eKvNmDFjmDVrluPn0NBQevTowSuvvFLtqjbhmX5M285HO1eTay0BoFt4M/7RcSCRvqeuVPw5fScf7viDnBPHdAlryj86DSTaVz4EiIahlJ1VO99iw54PKbcVo2lGEptdy8BOk7GY6/cqWqUUs1M28t+9GyiqsKKh0S8qgUc69ifIy6deH0u4Lpdu2QkICCA5ObnKl5+fH2FhYSQnJzvm3JkyZQpz5sxh69atjBkzBl9fX0aNGqV3fJdw5ZVXkpGRQUZGBosWLcJkMnHttdfqHUs4weJDe5j25xJHoQOw8dghxv8xh7ITi10tPZzCq5sXOwodgM3HD/PIyjmUVJQ7PbNoHFbteIPVO9+i3FbZkqiUjV0H/8f/Vt1HfS/X+PW+TXy4cxVFFdbKx0Kx4kgqT66eh12Whmw0XLrYOR+PP/4448ePZ9y4cXTv3p1Dhw6xYMECmWPnBIvFQlRUFFFRUXTu3JknnniC9PR0srOzAXjiiSdo06YNvr6+tGjRgmeeeYby8lNvcpMmTaJz58785z//IT4+nqCgIG677TYKCgocx/z888/069eP4OBgwsLCuPbaa0lJObUc9v79+9E0je+++46BAwfi6+tLp06d+OOPPxzHHDt2jJEjR9KsWTN8fX3p0KED//3vf6v8Lt988w0dOnTAx8eHsLAwBg8eTFGR+07W19D+s2cdZ45csytFVkkhSw7vPXHM2hqPyS4tYvHhPU7JKRqX8opi1u/9CKhaaChl5+DRVRzJ3VLzDeugwm7ji70bqm23K8XuvGw2HXPNFdZF/XO7YmfJkiW8/vrrjp81TWPSpElkZGRQWlrK0qVLSU5O1i+gCyssLOTzzz+nVatWhIWFAZWtZzNnzmT79u288cYbzJgxg9dee63K7VJSUvj++++ZN28e8+bNY+nSpbz00kuO/UVFRTz66KOsXbuWRYsWYTAYuOGGG7Db7VXuZ+LEiUyYMIFNmzbRpk0bRo4cSUVFZQtDaWkp3bp1Y968eWzdupV7772XO+64g9WrVwOQkZHByJEjueeee9ixYwdLlizhxhtvrPdPgZ7CpuykFeZQ09kxagZS8o+ilGJ/wfHaj8k72tAxRSOUV5ROha2k1v3ZufU3A/6x0mIKymtel86Axt687Hp7LFeRnr2Sn9f9g+9W3MUfO16nqNTzfse6cOkxO+LizZs3D39/f6CyKImOjmbevHkYTsz78vTTTzuOjY+P5x//+Adffvkljz/+uGO73W5n5syZjtayO+64g0WLFvHiiy8CcNNNN1V5zI8++oiIiAi2b99epfCcMGEC11xzDQCTJ0+mffv27N27l6SkJJo2bcqECRMcxz744IP8/PPPfP311/Tq1YuMjAwqKiq48cYbiYuLA6BDhw71dp48jQGNALOlxhd6pRRh3n5omkawl0+VLqwzjxGivvl6h1G50FrNH1T8faLq7bECvbwxaQYqlL3aPjuKcG//enssV7Bq51us2vE6mmZEKRvpWSvZnPIfbu3/NaEBLfSOpyu3a9kRF2bgwIFs2rSJTZs2sXr1aoYOHcpVV13lmIfom2++oV+/fkRFReHv788zzzxDWlpalfuIj4+v0i0YHR1NVlaW4+eUlBRGjRpFixYtCAwMJCEhAaDa/Zw+KDo6OhrAcT82m40XX3yRjh07EhYWhr+/PwsWLHDcR6dOnRg0aBAdOnTglltuYcaMGeTk5NTXafI4mqZxfXxytS4qDTBoGoObtgHguhqO4cQxQ5slNnRM0Qj5WsJpGT0ETTNW2a5hwM87kuYR/ertsXxMZgY1bYPhjKlITn4Y6BMVX2+PpbecglRW7XgdqBwDBaCwU1ZRwNI/n9cxmWuQYsfD+fn50apVK1q1akXPnj356KOPKCoqYsaMGaxatYrbbruNq666innz5rFx40YmTpyI1Wqtch9ms7nKz5qmVemiGjZsGMeOHWPGjBmsXr3a0fV0tvs5OQ9SgS2fElXCtGnTeO2113j88cdZvHgxmzZt4oorrnDch9FoZOHChfz000+0a9eOt956i8TERFJTU+vvZHmY21t359Loyk9zJ1/qLUYTk7tf6Wi1GdWqK/2jW1U5xtto4tluV9DEx3U+9SqlyMrdTmrmb+QXH9Y7jrhIg7tMISL4ZKtv5TPPxxLG8D4fYTSYa79hHdzfvh/JIdGnPRL4my1M6XkN3sb6fSw97c1YgFbDW7pSNg5kLae8onFPKyHdWI2MpmkYDAZKSkpYsWIFcXFxTJw40bH/bDNP1+TYsWPs2LGD999/n0svvRSA33///ay3sSsb6arycY5wmL3s4OflPzHsumHcfvvtlcfY7ezZs4e2bdtWyd63b1/69u3LP//5T+Li4pgzZw6PPvroBWVuLMwGI892u5KU/KNsOZ6Bv6nyk6yvyctxjMlg5JluQxmd340txzPwNZnpE5mAn9nrLPfsXPnFh5i3+u9kOcZyaCQ2G8aQri9hMlp0zSbqxscSwm39v+XQsbUczduJv08UCVEDMBrq/3nnZ/Zieu/r2Z57hD252YRYfOkdGYeX0bPe/uz2ctC0WnoHFfYTrT2NlWf9tUU1ZWVljkkXc3JyePvttyksLGTYsGHk5eWRlpbG7Nmz6dGjB/Pnz2fOnDkXdP8hISGEhYXxwQcfEB0dTVpaGk8++eRZb3OIg+RTdRKxpi1j+OW7n1mxYgWhoaFMnz6dzMxMR7GzevVqFi1axNChQ4mIiGD16tVkZ2dXKYZEzVoGhtMyMPysx7QIDKNFYJiTEp0/pezMWTGG3KLTi3DF7oPzsJgDuLzzc7plExdH0zSahfekWXhPpzxW+5Ao2ofU33ggV5MQNYA/drxWbbuGgcjQTvU+f5G7kW4sD/fzzz8THR1NdHQ0vXr1Yu3atXz99dcMGDCA66+/nkceeYQHHniAzp07s3LlSp555pkLun+DwcDs2bNZv349ycnJPPLII7z66qu1Hl+hKsjlOGd+/PjbM38hqWsiV155JQMGDCAqKorhw4c79gcGBrJs2TKuvvpq2rRpw9NPP820adO46qqrLiivcC9p2SvJKdznGINwksLO1gNfUVZeUMsthWhcIoKTaR93y4mfKjvsNM2IwWCif4eJtd+wkdCUXLtLfn4+QUFB5OXlVVs6orS0lNTUVBISEs66Ppc4PyWqmL3srHV/U+II1S6+hUH+bp5h877P+W3zP2vdf+egXwgNbOXEREK4LqXsbDvwDVv2z6ak7BgxYd3p3vpewoM892KDs71/n066sYRTmfHibJedWpAxGOKUEP/4WvcZDGb8fC58GRUhPJWmGUiOv5Xk+Fv1juJypBtLOJVJMxFCKNRwUbQ3vvgic7uIU2Kb9CY0oFWNlyknx41o9OMQhBDnR4od4XQxNCOIEE4veHzxI54WjkvShYDKT6rD+3xy2mXKABpJscO5rMP/6ZZLNBK5dvhPCfy7GLbIWnHuTLqxhNMZNCPNiceqYiijFDNmvDVZfVjULNA3hpEDvuNo/i4KS44QFtiaAJ9ovWMJTzenFO7Jg1JO9bzfbIGPg8AsH8rcjRQ7QjdemhdeuM58LsK1hQcmEh7ouQMthQs5YIM78+DkRYAnhxh+Wwbti+BJ15lwU5wf6cYSQgghTvd5SWWBc+Z1FAr4oPZFTIXrkmJHCCGEOF2Gvfo1FCdlVV9UVLg+KXaEEEKI03U2QUUN2w1ARxn94Y6k2BFCCCFON8IbYgxgPGO7HXhKpsdwR1LsCCGEEKfzN8CiUOh/2gUUMQb4OBCGyYzs7kja4+qo4JPqC641pIC7H6nT7TIzM5k6dSrz58/n4MGDBAUF0bp1a26//XbuvPNOfH196zmpEEJ4gHgjzA+BbDsUKYg1gFEuOXdXUux4sH379tG3b1+Cg4OZMmUKHTp0oKKigt27d/Pxxx8TExPDddddV+125eXlmM1mHRILIYSLaWKAJnqHEBdLurE82Lhx4zCZTKxbt45bb72Vtm3b0qFDB2666Sbmz5/PsGHDANA0jffee4/rr78ePz8/XnjhBWw2G2PHjiUhIQEfHx8SExN54403qtz/mDFjGD58OJMnTyYiIoLAwED+9re/YbVaHccopXjllVdo0aIFPj4+dOrUiW+++caxPycnh9GjR9OkSRN8fHxo3bo1n3zyiXNOkBCiUTteWsyhojxsSq6w8nTSsuOhjh07xoIFC5gyZQp+fjUPqDt9aYZnn32WqVOn8tprr2E0GrHb7TRr1oyvvvqK8PBwVq5cyb333kt0dDS33npqkblFixbh7e3Nb7/9xv79+7n77rsJDw/nxRdfBODpp5/mu+++491336V169YsW7aM22+/nSZNmtC/f3+eeeYZtm/fzk8//UR4eDh79+6lpETmsRBCNJyDhblM+3MJfx4/DECYxZd72/ZhcLM2OicTDUWKHQ+1d+9elFIkJladcTY8PJzS0lIA7r//fl5++WUARo0axT333FPl2MmTJzu+T0hIYOXKlXz11VdVih0vLy8+/vhjfH19ad++Pc899xyPPfYYzz//PCUlJUyfPp3FixfTu3dvAFq0aMHvv//O+++/T//+/UlLS6NLly50794dgPj4+Ho/F0IIcVJheRnjV84hr7zUse1YWTFTN/2Kr9mLPpHx+oUTDUaKHQ935sKaa9aswW63M3r0aMrKyhzbTxYbp3vvvff48MMPOXDgACUlJVitVjp37lzlmE6dOlUZ5Ny7d28KCwtJT08nKyuL0tJShgwZUuU2VquVLl26APD3v/+dm266iQ0bNjB06FCGDx9Onz59LvbXFkKIGv16cDe51pJqkyMb0PhszzopdjyUFDseqlWrVmiaxs6dO6tsb9GiBQA+PlUX3jyzq+urr77ikUceYdq0afTu3ZuAgABeffVVVq9efV6Pr2kadntlP/j8+fNp2rRplf0WiwWAq666igMHDjB//nx+/fVXBg0axP3338+//vWv8/9lhRDiPO3Jz8agadhU1XLHjmJf/jGdUjWcUmsuW1Jnc/DoKizmQJJih5MQNbDaB2FPJ8WOhwoLC2PIkCG8/fbbPPjgg7WO26nN8uXL6dOnD+PGjXNsS0lJqXbc5s2bKSkpcRRPq1atwt/fn2bNmhESEoLFYiEtLY3+/fvX+lhNmjRhzJgxjBkzhksvvZTHHntMih0hRIMI9/av1qpzUojFp5Y97qmgJIMvl9xEUWk2CjsaRnYfmk+nFncysNOzesdzKrkay4O98847VFRU0L17d7788kt27NjBrl27+Oyzz9i5cydG45nTg57SqlUr1q1bxy+//MLu3bt55plnWLt2bbXjrFYrY8eOdQwyfvbZZ3nggQcwGAwEBAQwYcIEHnnkEWbNmkVKSgobN27k3//+N7NmzQLgn//8Jz/88AN79+5l27ZtzJs3j7Zt2zbYORFCNG5XNEuscdkrDRge38HZcRrUim3/oqjsKIrKVnZ1Yhn3zfs+JeP4Jh2TOZ+07Hiwli1bsnHjRqZMmcJTTz3FwYMHsVgstGvXjgkTJlRptTnTfffdx6ZNmxgxYgSapjFy5EjGjRvHTz/9VOW4QYMG0bp1ay677DLKysq47bbbmDRpkmP/888/T0REBFOnTmXfvn0EBwfTtWtX/u///g+oHOD81FNPsX//fnx8fLj00kuZPXt2g5wPIYSI8QtiYpehvLTpV6x2m2P7kGaJ3JzQScdk9UspxZ5DP6GUrdo+TTOy99BPRId2dn4wnWhKqdpa9BqN/Px8goKCyMvLIzAwsMq+0tJSUlNTSUhIwNtbpgk/3ZgxY8jNzeX777/XO0o18ncTQpxNYXkZfxzZT3FFOZ3CYogPCNU7Ur1SSvHWD0nYVfUVTQ2aiY4tbmdAx2d0SFa/zvb+fTpp2RFCCNHo+JstDGmWeO4D3ZSmacRF9mf/kSXVWnfsqoKEqIE6JdOHjNkRQgghPFC/9hMwGb3RtJPjMzVAo0XUIJo36atnNKeTlh1RZzNnztQ7ghBCiFqEBbZh9MC5rNszg7SsFXibA2kXdxMdEkbJpedCCCGE8AzB/vEM7vKi3jF0J91YQgghhPBo0rIjhBDCoyml2HPkEPuPHiHIx48ucS3xMpn1jlUvsjIUh9LBYoGWSWCxNK7uqfMlxY4QQgiPVWwtY/ov37LnyCE0QAF+Fm8eGXojrSObnuvmLquiQvHjd5Cy69Q2009w9Y2Klm2k4DmTdGMJIYTwWJ//sYiUrMMAjmUiissqC6CyinL9gl2k1cth3+6q2yrKYd43UFjQ6KfPq0aKHSGE0ymlcKX5TF0tj6gfJVYrf+zdgf2Mv61CUWwtY8P+PTolqzulFHa7nT/XQ01PWWWHHVvq8bGUvX7uTGfSjSUajKZpzJkzh+HDh+sdRbiIwwcVKxbDwTQwGSExWdHvcvD106fZPTtTsXwxpO0DzQBt2lbmCQiSbgBPUFRWgq2WN2tN08gpLnRyorqzlpexZMtiNqZswFpuxb9kUo3HaRoUXeSvVaZKeUO9xH/Vx+SRSxLJPGx4iiu0YRd3xzqSYqeOXnveuZ8CH3nmwl98x4wZ41hw02QyERsby4033sjkyZMveBV0IS5W5mHF17NOfBpVUFEB2zfD4TQYfa/CbHZugXH8qGL2TLBVVGZSNti1DQ4egDv+pvD2kYLH3QX7+eNn8aaorLTaPqUU8eGROqS6cErZ+e/Sz0g/mlbZAqmBzZyFoTwc7YwOGrsdIi7i11JK8Xf77SzjV+wnFhDdxTb+bh/NG9rHDDPcfDG/im6kG8vDXXnllWRkZLBv3z5eeOEF3nnnHSZMmKB3LNEIrVp2oqg47XOCUpBzHHZudX6etSvAZquep6gQtmxwfh5R/0wGI9d1vqTadoOmkdAkirbRzXVIdeH2ZaaQln2gSldreeiSE4XOqW2aBoFB0KZd3R9rI2tYwgJHoQOV3X4Ar6pJbtutJcWOh7NYLERFRREbG8uoUaMYPXo033//PUopXnnlFVq0aIGPjw+dOnXim2++cdzOZrMxduxYEhIS8PHxITExkTfeeKPa/X/88ce0b98ei8VCdHQ0DzzwQJX9R48e5YYbbsDX15fWrVszd+7cKvu3b9/O1Vdfjb+/P5GRkdxxxx0cPXrUsf+bb76hQ4cO+Pj4EBYWxuDBgykqKqrnsySc4eCBmscYaBocSjvHjQ/Z4NUiGJ8PHxdD4cW/4KbvrxzfcCal4FD6Rd+9U5Va89iYMpPfNk9iw56PKCk7rnckl3FFcndu6zkAP6/KBYENmkaPhEQmXHGz28winJZ9AINW9e26ImAbpRFzsBtP9VnFtYBb7wLTRbSSrlV/YKilNDhIGtkcqfN960m6sRoZHx8fysvLefrpp/nuu+949913ad26NcuWLeP222+nSZMm9O/fH7vdTrNmzfjqq68IDw9n5cqV3HvvvURHR3PrrbcC8O677/Loo4/y0ksvcdVVV5GXl8eKFSuqPN7kyZN55ZVXePXVV3nrrbcYPXo0Bw4cIDQ0lIyMDPr3789f//pXpk+fTklJCU888QS33norixcvJiMjg5EjR/LKK69www03UFBQwPLly2UgqZuyWKDcWn27poHlbAvT/1gGI3OhAjBS+f8XiuDXEGhR95cwiw8U5NeSx1Lnu3W6rNytfPv7HZSVF2DQjNiVjT92vsENfWYSE9ZV73i60zSNqzr2YEj7rhwrysff4oPfWZ9wrsfb7F3j615F4CZU0FbuGzIRHx8DPr4XX7wFEuRoyTmTAQO+uOcQCE3JO8dZl4gvLS0lNTWVhIQEvL1P/QNxlzE7ubm5fP/99wCsWbOGq6++moEDBzJv3jwWL15M7969Hcf/5S9/obi4mC+++KLG+7v//vs5cuSIowWoadOm3H333bzwwgs1Hq9pGk8//TTPP/88AEVFRQQEBPDjjz9y5ZVX8s9//pPVq1fzyy+/OG5z8OBBYmNj2bVrF4WFhXTr1o39+/cTFxd3Qb97bX83oZ+VSxRrfq+5dWfkWIiKqeE5XmCHhKNQrKjy+msE+prhl9A659mwWrF0Qc37bhwFcS1d/1O/UoqZCweRX5yOOq2ZSsOAn3cE91y5DINjEUjhrvKL83hz7vRqBY+maXSM78x1l9xQb4+Vo47R255EOdYqRY8RI4O5mneNn9fbY9WHs71/n066sTzcvHnz8Pf3x9vbm969e3PZZZcxYcIESktLGTJkCP7+/o6vTz/9lJSUFMdt33vvPbp3706TJk3w9/dnxowZpKVV9jdkZWVx+PBhBg0adNbH79ixo+N7Pz8/AgICyMrKAmD9+vX89ttvVTIkJSUBkJKSQqdOnRg0aBAdOnTglltuYcaMGeTk5NT3KRJO0qMvND0xRMJgqLz6CaDvwFoKHahs1Sk6o9ABsAHLyuGwrc55OnWHFm2q5+nWG5q3qPPdOlVW7hbyig5UKXQAFHYKSzM5fGy9TslEfQr0DWJYz+FoaGia5ujSCg9swuAuQ+v1sUK0MKYbZmDEiAEDphMdQM2IY5LhX/X6WM4k3VgebuDAgbz77ruYzWZiYmIwm82sXr0agPnz59O0adUZRC0n2u+/+uorHnnkEaZNm0bv3r0JCAjg1VdfddzWx8fnvB7fbK46JbumadjtlS/MdrudYcOG8fLLL1e7XXR0NEajkYULF7Jy5UoWLFjAW2+9xcSJE1m9ejUJCQkXdiKE7sxmjZtuV+xPgfRUMJuhTXsIjzhLC8q5Jke7iMnTjEaN625VpO+H/XvBYITWbSEy2vVbdE6yVpz9GmNreYGTkoiG1qlFF5pHxLNl/2ZKyopp1qQ5SU2TMBrr/238am04nQ3d+V59yVGy6EgXrtKGY9Hct5Vcih0P5+fnR6tWrapsa9euHRaLhbS0NPr371/j7ZYvX06fPn0YN26cY9vprT4BAQHEx8ezaNEiBg4cWKdsXbt25dtvvyU+Ph6TqeanoqZp9O3bl759+/LPf/6TuLg45syZw6OPPlqnxxT6Mhg0WrSGFq3P8wZ9vWrf10SDFhfXRaNpGs0ToLmb1s4RwR0wGryw2asPhjJoJqJCOzs/lGgwIf4hXJY8wCmPFaM1Y5z2D6c8ljNIN1YjFBAQwIQJE3jkkUeYNWsWKSkpbNy4kX//+9+OeXlatWrFunXr+OWXX9i9ezfPPPMMa9eurXI/kyZNYtq0abz55pvs2bOHDRs28NZbb513jvvvv5/jx48zcuRI1qxZw759+1iwYAH33HMPNpuN1atXM2XKFNatW0daWhrfffcd2dnZtG3btl7Ph3BhbU0w0htOb2w5+f1zAeDkuXlcjcUcQM/Ekx9Iqp6Lrq3G4msJc34oIVyQtOzUUV0GDLuS559/noiICKZOncq+ffsIDg6ma9eu/N///R8A9913H5s2bWLEiBFomsbIkSMZN24cP/30k+M+7rrrLkpLS3nttdeYMGEC4eHh3Hzz+U84FRMTw4oVK3jiiSe44oorKCsrIy4ujiuvvBKDwUBgYCDLli3j9ddfJz8/n7i4OKZNm8ZVV11V7+dDuLD3A6GNEd4rgSw7tDPBk35ws/s2qdennokP4GsJZ92eD8grSifAN4ZurcbSqcWdekcTwmXI1VjU7Wos4drk7+ahlKq8NlzUSCnlNnPHCFEf5GosIYTnkTfys5JCR4iaSTeWuGhKKaxWQIHZq3IQqhBCCOdTSrEvO5PCshLiwiII9vXXO5JLkGJHXJTSUkV+7qlp9zUN/AOVbqtYCyFEY3Uw5yhv/fo9mXmV85EZNI2BbTtz+yWXYzA07o6cxv3bi4tSXq7Iy6m6vpBSUJAHZaWNfiiYEEI4jbWinJd//JKs/FzHNrtSLNq+kbmbVukXzEVIsSPqrKSY6jPbnlAsa3UKIYTTrE3dTX5JMfYarjn6Zes6bHb3XK28vkg3lqgzW0Xt+yrOsk8IIerLjpwjzE7ZwK7cLMK9/bkuvj1DmiY2usHaR/JzMGoGbKp6UVNsLaPEWoa/9/nNfO+JpNgRdWY0AScGJp+plgmRhRCi3qzJSmPi2vlAZZfN0dIidmw6wt68o4xr30/ndM4VFRRaY6ED4Oflja+XxcmJXIt0Y4k68/U9yz4/5+UQQjQ+Sine3rYcpZSj6+bk565vU//kcFGefuF00D2+NUE+fhhqaNG6okN3GaCsdwBxdkopCsvLyCkrprC8DFeaA9Jk1ggOObVaNFRejRUQBBbvxtWELISof0opVqnlfGz/Nz+qOZSpUse+rJJCDhXl1ThsUAPWZKc5Lacr8DKZefLqEUQFhTq2GTSNoe27MaxTLx2TuQaX7myYOnUq3333HTt37sTHx4c+ffrw8ssvk5iY6DhGKcXkyZP54IMPyMnJoVevXvz73/+mffv2OiavH1ZbBQeL8ii32xzbvAxGmvkFYzZe3AKI9cXirdEkUlFurfxUZTbLPDtCiIuXo45xj/1mNrMeAwbsyk4oYXxs+JaOWldMZ2mpUIBZc43XSGeKCQljyk13c+BYFgWlxcSFRRDoI83s4OLFztKlS7n//vvp0aMHFRUVTJw4kaFDh7J9+3b8/Cr/gK+88grTp09n5syZtGnThhdeeIEhQ4awa9cuAgICGizb8//9Z4Pdd01uveoBAMrtNg4X5xEXEHqOWziPpmk08u5gIUQ9e9r+CFvZBICdyrEoueQy1n4LKww7CPP2Iyk4gt252djPaN8xahq9o+KdnNg1aJpGfHik3jFcjkt3Y/3888+MGTOG9u3b06lTJz755BPS0tJYv349UNmq8/rrrzNx4kRuvPFGkpOTmTVrFsXFxXzxxRe13m9ZWRn5+flVvtyFAkptFZSd7VIo4Z6UArvrdFMKoZccdYxfmIsNW5XtdmwcI5vf+AWARzoMwNtkwnBixXfjifEq49r3I9RylkGFotFx6WLnTHl5lQPOQkMrWzVSU1PJzMxk6NChjmMsFgv9+/dn5cqVtd7P1KlTCQoKcnzFxsY2bPAGUHEecyaUlZXx0EMPERERgbe3N/369WPt2rVOSCcuSJ4dHs2HiGzwy4L+x2Bxmd6phNDNcY45WnOq08hSmQC0Cgrn4/4jGdmqKz2bNGdosyTe7nsTw+M7OC+scAtuU+wopXj00Ufp168fycnJAGRmVj7hIyOrNtlFRkY69tXkqaeeIi8vz/GVnp7ecMEbgAZYzmPMzuOPP863337LrFmz2LBhA61ateKKK67g+PHjDR9SnJ8KBdfkwAclUHiiVWddBQzLlYJHNFpNicWP2tZ0UrTXOjp+auLjzz1JvZja61omdBpI2xDpwhHVuU2x88ADD/Dnn3/y3//+t9q+MyePUkqddUIpi8VCYGBglS93Eujljclw9mKnqKiId999l1dffZWrrrqKdu3aMWPGDHx8fPjoo4+clFSc049lsL6CKq31Jz/QPluoRyIhdOet+fA3bXy17UaM9KAPXejp/FDCrbn0AOWTHnzwQebOncuyZcto1qyZY3tUVBRQ2cITHR3t2J6VlVWttccTGDSNIC8fwr3PPbo+JSWF8vJy+vbt69hmNpvp2bMnO3bsaMiY4kKsKAczUH7GdjuVLTwVCkxydZunOq6OMUf9lzRSiaclN2i3Eay5zsUHehqnTcCAkffVaxSQjxEj13ELzxpebXSzI4uL59LFjlKKBx98kDlz5rBkyRISEhKq7E9ISCAqKoqFCxfSpUsXAKxWK0uXLuXll1/WI3KDSQgIxWQwYNDOrzHu5Hw8F9rqJZwsWKPWoQm+QOO7erbR2KjWcKd9OMUUYcSEjQreUFP5j2EuHbQuesfTnUEzME77B2PVA2RyiBDCCNSC9I4l3JRLd2Pdf//9fPbZZ3zxxRcEBASQmZlJZmYmJSUlQOUb+fjx45kyZQpz5sxh69atjBkzBl9fX0aNGqVz+vrlZTSdd6ED0KpVK7y8vPj9998d28rLy1m3bh1t27ZtiIiiLkZ411zsGIE7fCpnaRQex6ZsPGC/ixKKUSgqKEehKKSQB+1jXGryUL1ZNAtxWgspdMRFcemWnXfffReAAQMGVNn+ySefMGbMGKByEG5JSQnjxo1zTCq4YMGCBp1jxx34+fnx97//nccee4zQ0FCaN2/OK6+8QnFxMWPHjtU7njiphQneDICHCio/emhABdDBBJNqG6Ap3N16VpPBoWrb7dhII5U/2UAnuumQTAjP5NLFzvl8utE0jUmTJjFp0qSGD3SaZ0Y+59THq4uXXnoJu93OHXfcQUFBAd27d+eXX34hJCRE72jidH/xhYFe8GUp5CjoY4ZrLWCWVh1PVcjZ5/YqpMBJSYRoHFy62BEXx9vbmzfffJM333xT7yjiXFqa4P+kJaex6ER3TJiooPrkoF5Y6EBn54cSwoO59JgdIYTwRGFaOH/RHqqyTTsxC/DftUcJ1IJ1SCWE55KWHSEakFKK1VkHWHhwN4UVZXQKi+Ga5u0J8vLWO1qjlHlYsWUD5OdCk0jo2B2CQ/TpLnxMe5Yoopmh3uIw6cQSz73aw4zU7tYljxCeTIodIRrQv7f9zpz9WzCgYUexPvsgP+zfylt9byTCp3EPone2bZsVC+aCZgBlh/T9sGkd3DRa0bS58wseTdO4U/sbd/I3mRJCiAYm3VhCNJAdOUeYs38LgGNVZoUip6yYj3au1jNao1NWqlj0Y+X36sSl/kqB3QYL/nd+F0M0JCl0hGhYUuwI0UCWZaQ4VmE+nU0p/ji8mX0Zv5F5fLPub7SNwf4UsFUfC4xSkHscjh91fiYhhPNIN5YQDcRWUxGj7LS3/UaC2szcVZX7Q/xbcE2vtwkPTHRywsbDXtss1ee5Xwjh3qRlR4gG0jOiebWCp7V9NQlqExqntucWHeDb3++gvKLE2REbjeYJlWN1auLnD2FNnJtHCOFcUuwI0UC6hTejT2T8qQ3KTgv7Bs7s2FLKRknZMfYc/smZ8RoVP3+N3pdVfn+yZ/Hk/wdeCQaDjJkRwpNJN5YHUNYy7CVFYLOB0YjBxw/Ny6J3rEZP0zSe7XYF/zuwjV/Sd1JSnodXfmmNxxo0E3mFB5ycsHHpdalGaLhi09pTl5536wNNY6XQEcLTSbHj5uwlxaii06aWt9uxl+ei+QVg8PHVL5gAwGQwckNCR25I6Ihd2fhg/nuUludWO86uKgj2T3B+wEamdVuN1rIOrhCNjhQ7dfT6nJZOfbzxN6RU26bsdlRxYY3Hq+JCBlx1NZ07d+b1119v4HTifBg0I11b38PK7dOrbNc0Iz5eIbRueqVOyYQQwrNJsePOKsorr52tiVKnJhQRLqN7m/soKcth877/YFeV10KH+CdwTc+3MRllVmXhGZSys/9IKlm5Rwj0C6ZNTBuMRtd+u1FKkXEQMg+Drx+0TASzLMbrMVz72SfO7iwTkd3zwEMsXbacpcuW88YbbwCQmppKfHy8k8KJmhg0I/07Pk2PxPvIyt2OryWUJkHtZVI54TGKSgv5/LdPOZKbiYaGQuHv7c+oAXcSGRKld7walZUpfvgSDh0ANECBxQLX3aZopsPs2qL+ydVY7sxkrrXgeW3qi/Tu3Zu//vWvZGRkkJGRQWxsrJMDitr4WsKJj7yMiOBkKXSER5m7eg5ZeUeAyhnDAYrKipi99DPsdpue0Wq1bAEcTjvxw4nG8jIr/DAbrFaZ9NMTSLHjxjRNwxAQVOO+kKaxeHl54evrS1RUFFFRURiNRicnFEI0JgXF+ew9vKfarOBKKfJL8tmXuU+nZLUrL1ds31LDiAAF1jLYs0OXWKKeSTeWm9O8LBiCw1ClJSh7BZrBiObti2aSP60QwrkKS4vOsb/grPv1UFZauUZaTTQNimq+BkS4GXlH9ACayYTmLytoCyH0FRoQislooqKmhciAqJAYJyc6N18/8PGFkuLq+5SCCNccZiQukHRjeTAvLy9sNtfsIxdCeB6L2UKvxD7VtmuaRsuoVkS54ABlg0Gj16XVt2taZaET18L5mUT9k5YdDxYfH8/q1avZv38//v7+hIaGYjBIfSuEaDgDOlyO0WBg1c6VWCusGDQDHRM6cUXXq/WOVqvOPSpbcVYvh9KSykKnVRIMuhq5gMBDaOrMkWSNUH5+PkFBQeTl5REYGFhlX2lpKampqSQkJODt7V7zoOzevZu77rqLzZs3U1JS0qguPXfnv5sQnqDCVk5+cQF+3r5YzO7xb9BmUxTkgbcPePtIkeMOzvb+fTpp2fFgbdq04Y8//tA7hhCiETIZzYQGhOod44IYjRrB7hVZnCfp0xBCCCGER5NiRwghhBAeTYodIYQQQng0KXaEEEII4dFkgLIQwu1YywvZduBrDmQtx2iwkNjsWgxenVi6cyvHCvNpHhbBoHadaRIQrHdUIYQLkGJHCOFWSq25fLn0VnIK9wEKDQOrU9NILxqAQdOwK8WOjDQWbd/IE1ffSqvIpnpHFkLoTLqxhBBuZe3u98gt2s/J5anL7WYOFvUDwH5i2jC7UpTbbXy0/Jdqi1IKIRofKXaEEG5l18H/odSpZVDyy5ujamikVkpxOPcYWfm5TkwnhHBFUuwIIdyK/YwlqpU6+8uYzW5vyDhCCDcgxY4Qwq20jB6MphkdPweYDwI1FzRhfgFEyZS4QjR6MkC5jlrYal+DoyHsM+Y79fGEcFU9E8ex9/AvlJbnoZQNL2MRUT4byCzpjqZpKKUwaBoKuL3PYAyykKMQjZ4UO0IItxLgG8Poy//H+j0fsi9zMSajN33aDcRm7MtvJy49jwuP5OoOPapciaWUomL/bqzbN6GK8jGENMGrQ3dMUc10/G2EEM4gxY6Hio+PZ/z48YwfP96xrXPnzgwfPpxJkybplkuI+uDvE0X/jk/Tv+PTVbb3btWh1ttYN63CumkVaBooha24iJKDqXgPvAZzfJuGjiyE0JGM2RFCeDx7cSHWzasrfzh5KfqJ/5etWoKSQcxCeDQpdoQQHs+WkX6qyDmDKinCnnvMyYmEEM4kxY4QwvMZzvFSZzCefb8Qwq1JseOhDAZDtZljy8vLdUojhL5MTePBWNMQRQ0tMARDUIizIwkhnEiKHQ/VpEkTMjIyHD/n5+eTmpqqYyJRH5RSsvxBHWheFrz7DDrxg3bq/0YjPv2Gosnl6UJ4NLkay0NdfvnlzJw5k2HDhhESEsIzzzyD0ShN9e7KWqZYuQS2boJyK0TGKPoOgLiW8iZ9vsyt2mEICad81xbsRfkYg8MxJ3XEEBCkdzQhRAOTYqeOXH2Sv6eeeop9+/Zx7bXXEhQUxPPPPy8tO27Kbld89wVkHjo1xvZIBnz3BdwwUhHfSgqe82UMi8B4soVHCNFoSLHjoQIDA/nyyy+rbLvrrrt0SiMuxv69kHHwjI0nip4Vv0F8K6dHEkIItyLFjhAu7lB65cVENU0Fk5UJFRUKk0lad4Q4yXY8m4p9u1AV5Rijm2OKTUA71xV5wqNJsSOEi7N41zpFDEbTua+qFqIxKdu8GuuGlScGomuU79iEISIG36E3opnNescTOpGXSSFcXGL7mrdrGrTtAAaDtOoIAWDLzqwsdKDyE4KqbA61Z2dg/XONjsmE3qTYEcLFBQVrDL6m8ntNO9WSE9YELpWxtkI4lKfsAK2GtzWlKN+zzfmBhMuQbiwh3EByF41mcYqdW6G0FGKaQctEMBqlVUeIk1S5Fcfo/Rr3icZKih0h3ERwqMYll+mdQgjXZYpqRsXe7dV3aBrGqGbODyRchnRjCSGE8AimhES0oNBTs2RD5feahqXLJfoFE7qTlh1RO7uCHAW59sqW4SANwgwgA2KF8Ex7K+D9EtheAQlG+KsPdHKfK5g0kwnfq2/FumFl5fgdWwXGqFgs3fpgDI/SO57QkRQ7omZ2BSk2yFdwsrbJV3BMQWsjyFgRITzLEitcnwM2Kr9MwMcl8EkgjPDROdz5M3j74N1nEN59BqGUknXPBCDdWKI2OaqyuIHKVp2TX8UKsmuY3U4I4b7sCv6WBxVUFjpQ+b0CHiiAIvdcfFYKHXGStOzU0aB57zj18RZdO86pj0eOvbJF58zXOEVlIdRIW4SPlhaxNy+bEIsvbYKayIup8Ax/VkBaLR9iChX8VgbXejs300WwKxsZxzZgrSgiOrQr3l6BekcSOpNiR9TsbB/kapvO14NV2G28uXU5P6btQJ04OfH+IUzqfiWx/iE6pxPiIpVf5H4XcvDoan5a+whFpUcAMBq86JX0ID3a/F0+nDRi0o3loT799FPCwsIoKyursv2mm27izjvvPPcdBNXyoqABQY3vaTNz91p+TNvuKHQA0opyeWzVXMrttrPcUgg30MkE4bX8m/cC+ns5NU5dFZZk8v3KeygqzXZss9mtrNw+jZ3p3+sXTOiu8b1rNRK33HILNpuNuXPnOrYdPXqUefPmcffdd5/7DsIM4K2dGpwMld+bgYjG9bSx2mx8n7qlWmOXXSmyS4tYmblfj1hC1B8vDf4VUPlv3Hhi28n/T/KHUPf4N7/twNfY7FbgzC45jfV7ZugRSbgI93gGn4d33nmHhIQEvL296datG8uXL9c7kq58fHwYNWoUn3zyiWPb559/TrNmzRgwYMC578CoQaIRog3gA3gDkQZIMoG5cTUF55eXUmKruR3fqGkcLs5zciLhKRapnxhtu5a+trbcabuepWqhfmFG+MAvIXClFzQ3wKVm+DoIHvHTL9MFyi08QNVPaCcpcovSnB1HuBCPGLPz5ZdfMn78eN555x369u3L+++/z1VXXcX27dtp3ry53vF089e//pUePXpw6NAhmjZtyieffMKYMWPOv9/aqEG0sfKrEQs0e+NjNNdY8NiUoqlfkA6phLubZX+PyepxDBixYyOLTH63/8YU7U1uM4zRJ9SlXpVfbirYP76WMYUawX5xzo4jXIhHtOxMnz6dsWPH8pe//IW2bdvy+uuvExsby7vvvqt3NF116dKFTp068emnn7Jhwwa2bNnCmDFj9I7ldryMRm5I6FDt86JB02ji7U/vyHg9Ygk3VqDyeVk9C4D9xLXethP/n6ImUqKKdcvmztrH3YLRaEGr9tam6Nb6r7pkEq7B7Ysdq9XK+vXrGTp0aJXtQ4cOZeXKlTXepqysjPz8/Cpfnuovf/kLn3zyCR9//DGDBw8mNjZW70huaUybnlwb1x7DaSVPvH8o/7rkOsyGxt3yJS7celZRSkmN+wopYBPrnJzIM/j7RHJDn0/w84l0bDMaLPRt/zhJsdfrmEzoze27sY4ePYrNZiMyMrLK9sjISDIzM2u8zdSpU5k8ebIz4ulu9OjRTJgwgRkzZvDpp5/qHcdtGQ0Gxnfoz52te5CSf5QQiy8tA8PkUlZRJ2bO3lV0rv2idk3De3DPFUvJPL6JclsJUSGdsJgD9I4ldOb2xc5JZ77pnG2a8KeeeopHH33U8XN+fv4Ft3jUNsmfXdk5mrcDpapP0GUwmAkPTHTqG2RgYCA33XQT8+fPZ/jw4U57XE8V6u1LqHfjHQcm6kd3ehNMCHnkVpnOQEMjnAg6013HdO7PoBmJCeumdwzhQty+Gys8PByj0VitFScrK6taa89JFouFwMDAKl/1xaAZCPRtWn2HphHk20yXloCMjAxGjx6NxWJx+mMLIaqzaBZeMbyLAQPGE9d4GzFixMQrhncwaR7zOVQIl+D2/6K8vLzo1q0bCxcu5IYbbnBsX7hwIddfr08frbdXMEaDNyXWY9js5ZgMFnwsoZiMzi02jh8/zoIFC1i8eDFvv/22Ux9bCHF2g7Wr+dHwB1+oj9iv9tFCa81obSwttNZ6RxPC47h9sQPw6KOPcscdd9C9e3d69+7NBx98QFpaGvfdd59umcwmb8ymGlp4nKhr167k5OTw8ssvk5iYqGsWIUR1rbUkntVe1TuGEB7PI4qdESNGcOzYMZ577jkyMjJITk7mxx9/JC6ucc+rsH//fr0jCCGEELrziGIHYNy4cYwb5+SVwYUQQgjh8tx+gLKzqEa40rc7k7+XEEKIk6TYOQez2QxAcbHMaOpOTv69Tv79hBBCNF4e043VUIxGI8HBwWRlZQHg6+srE8m5MKUUxcXFZGVlERwcjNEosxsLIURjJ8XOeYiKigJwFDzC9QUHBzv+bkIIIRo3KXbOg6ZpREdHExERQXl59ZWvhWsxm83SoiOEEMJBip0LYDQa5U1UCCGEcDMyQFkIIYQQHk2KHSGEEEJ4NCl2hBBCCOHRZMwOpyagy8/P1zmJEEIIIc7Xyfftc00kK8UOUFBQAEBsbKzOSYQQQghxoQoKCggKCqp1v6ZkXn3sdjuHDx8mICCgXicMzM/PJzY2lvT0dAIDA+vtfkV1cq6dQ86zc8h5dg45z87RkOdZKUVBQQExMTEYDLWPzJGWHcBgMNCsWbMGu//AwED5h+Qkcq6dQ86zc8h5dg45z87RUOf5bC06J8kAZSGEEEJ4NCl2hBBCCOHRpNhpQBaLhWeffRaLxaJ3FI8n59o55Dw7h5xn55Dz7ByucJ5lgLIQQgghPJq07AghhBDCo0mxI4QQQgiPJsWOEEIIITyaFDtCCCGE8GhS7DSgd955h4SEBLy9venWrRvLly/XO5Jbmzp1Kj169CAgIICIiAiGDx/Orl27qhyjlGLSpEnExMTg4+PDgAED2LZtm06JPcPUqVPRNI3x48c7tsl5rh+HDh3i9ttvJywsDF9fXzp37sz69esd++U8X7yKigqefvppEhIS8PHxoUWLFjz33HPY7XbHMXKe62bZsmUMGzaMmJgYNE3j+++/r7L/fM5rWVkZDz74IOHh4fj5+XHddddx8ODB+g+rRIOYPXu2MpvNasaMGWr79u3q4YcfVn5+furAgQN6R3NbV1xxhfrkk0/U1q1b1aZNm9Q111yjmjdvrgoLCx3HvPTSSyogIEB9++23asuWLWrEiBEqOjpa5efn65jcfa1Zs0bFx8erjh07qocfftixXc7zxTt+/LiKi4tTY8aMUatXr1apqanq119/VXv37nUcI+f54r3wwgsqLCxMzZs3T6Wmpqqvv/5a+fv7q9dff91xjJznuvnxxx/VxIkT1bfffqsANWfOnCr7z+e83nfffapp06Zq4cKFasOGDWrgwIGqU6dOqqKiol6zSrHTQHr27Knuu+++KtuSkpLUk08+qVMiz5OVlaUAtXTpUqWUUna7XUVFRamXXnrJcUxpaakKCgpS7733nl4x3VZBQYFq3bq1Wrhwoerfv7+j2JHzXD+eeOIJ1a9fv1r3y3muH9dcc4265557qmy78cYb1e23366UkvNcX84sds7nvObm5iqz2axmz57tOObQoUPKYDCon3/+uV7zSTdWA7Baraxfv56hQ4dW2T506FBWrlypUyrPk5eXB0BoaCgAqampZGZmVjnvFouF/v37y3mvg/vvv59rrrmGwYMHV9ku57l+zJ07l+7du3PLLbcQERFBly5dmDFjhmO/nOf60a9fPxYtWsTu3bsB2Lx5M7///jtXX301IOe5oZzPeV2/fj3l5eVVjomJiSE5Obnez70sBNoAjh49is1mIzIyssr2yMhIMjMzdUrlWZRSPProo/Tr14/k5GQAx7mt6bwfOHDA6Rnd2ezZs9mwYQNr166ttk/Oc/3Yt28f7777Lo8++ij/93//x5o1a3jooYewWCzceeedcp7ryRNPPEFeXh5JSUkYjUZsNhsvvvgiI0eOBOT53FDO57xmZmbi5eVFSEhItWPq+71Sip0GpGlalZ+VUtW2ibp54IEH+PPPP/n999+r7ZPzfnHS09N5+OGHWbBgAd7e3rUeJ+f54tjtdrp3786UKVMA6NKlC9u2bePdd9/lzjvvdBwn5/nifPnll3z22Wd88cUXtG/fnk2bNjF+/HhiYmK46667HMfJeW4YdTmvDXHupRurAYSHh2M0GqtVpllZWdWqXHHhHnzwQebOnctvv/1Gs2bNHNujoqIA5LxfpPXr15OVlUW3bt0wmUyYTCaWLl3Km2++iclkcpxLOc8XJzo6mnbt2lXZ1rZtW9LS0gB5PteXxx57jCeffJLbbruNDh06cMcdd/DII48wdepUQM5zQzmf8xoVFYXVaiUnJ6fWY+qLFDsNwMvLi27durFw4cIq2xcuXEifPn10SuX+lFI88MADfPfddyxevJiEhIQq+xMSEoiKiqpy3q1WK0uXLpXzfgEGDRrEli1b2LRpk+Ore/fujB49mk2bNtGiRQs5z/Wgb9++1aZO2L17N3FxcYA8n+tLcXExBkPVtzqj0ei49FzOc8M4n/ParVs3zGZzlWMyMjLYunVr/Z/7eh3uLBxOXnr+0Ucfqe3bt6vx48crPz8/tX//fr2jua2///3vKigoSC1ZskRlZGQ4voqLix3HvPTSSyooKEh99913asuWLWrkyJFyCWk9OP1qLKXkPNeHNWvWKJPJpF588UW1Z88e9fnnnytfX1/12WefOY6R83zx7rrrLtW0aVPHpeffffedCg8PV48//rjjGDnPdVNQUKA2btyoNm7cqAA1ffp0tXHjRscUK+dzXu+77z7VrFkz9euvv6oNGzaoyy+/XC49dzf//ve/VVxcnPLy8lJdu3Z1XCIt6gao8euTTz5xHGO329Wzzz6roqKilMViUZdddpnasmWLfqE9xJnFjpzn+vG///1PJScnK4vFopKSktQHH3xQZb+c54uXn5+vHn74YdW8eXPl7e2tWrRooSZOnKjKysocx8h5rpvffvutxtfku+66Syl1fue1pKREPfDAAyo0NFT5+Pioa6+9VqWlpdV7Vk0ppeq3rUgIIYQQwnXImB0hhBBCeDQpdoQQQgjh0aTYEUIIIYRHk2JHCCGEEB5Nih0hhBBCeDQpdoQQQgjh0aTYEUIIIYRHk2JHCCGEEB5Nih0hhNsYMGAA48eP1zuGEMLNSLEjhPBIS5YsQdM0cnNzL+h2mzdvxmKxMHfu3Crbv/32W7y9vdm6dWs9phRCOIMUO0IIcZpOnTrxzDPPcO+993Ls2DEAsrKyuO+++5g8eTLJyck6JxRCXCgpdoQQLqmoqIg777wTf39/oqOjmTZtWpX9n332Gd27dycgIICoqChGjRpFVlYWAPv372fgwIEAhISEoGkaY8aMAeDnn3+mX79+BAcHExYWxrXXXktKSkqV+37qqado3rw5999/PwB/+9vfaN26NRMmTGjg31oI0RCk2BFCuKTHHnuM3377jTlz5rBgwQKWLFnC+vXrHfutVivPP/88mzdv5vvvvyc1NdVR0MTGxvLtt98CsGvXLjIyMnjjjTeAyiLq0UcfZe3atSxatAiDwcANN9yA3W533LfRaGTWrFn88MMPjBo1il9++YWZM2diNBqddwKEEPVGVj0XQricwsJCwsLC+PTTTxkxYgQAx48fp1mzZtx77728/vrr1W6zdu1aevbsSUFBAf7+/ixZsoSBAweSk5NDcHBwrY+VnZ1NREQEW7ZsqdZF9dRTT/HSSy/x8ssv8/jjj9fnryiEcCJp2RFCuJyUlBSsViu9e/d2bAsNDSUxMdHx88aNG7n++uuJi4sjICCAAQMGAJCWlnbO+x41ahQtWrQgMDCQhISEGm9XWFjIl19+ia+vL8uXL6+n30wIoQcpdoQQLudcDc5FRUUMHToUf39/PvvsM9auXcucOXOAyu6tsxk2bBjHjh1jxowZrF69mtWrV9d4u8ceewwvLy9WrlzJokWL+PTTTy/iNxJC6EmKHSGEy2nVqhVms5lVq1Y5tuXk5LB7924Adu7cydGjR3nppZe49NJLSUpKcgxOPsnLywsAm83m2Hbs2DF27NjB008/zaBBg2jbti05OTnVHn/hwoV8+OGHzJw5k06dOjFlyhTGjx9PRkZGQ/y6QogGJsWOEMLl+Pv7M3bsWB577DEWLVrE1q1bGTNmDAZD5UtW8+bN8fLy4q233mLfvn3MnTuX559/vsp9xMXFoWka8+bNIzs7m8LCQkJCQggLC+ODDz5g7969LF68mEcffbTK7fLz8xk7diwTJkzgkksuAeChhx6iffv23Hvvvc45AUKIeiXFjhDCJb366qtcdtllXHfddQwePJh+/frRrVs3AJo0acLMmTP5+uuvadeuHS+99BL/+te/qty+adOmTJ48mSeffJLIyEgeeOABDAYDs2fPZv369SQnJ/PII4/w6quvVrnd+PHjCQoKYvLkyY5tBoOBTz75hMWLF0t3lhBuSK7GEkIIIYRHk5YdIYQQQng0KXaEEEII4dGk2BFCCCGER5NiRwghhBAeTYodIYQQQng0KXaEEEII4dGk2BFCCCGER5NiRwghhBAeTYodIYQQQng0KXaEEEII4dGk2BFCCCGER/t/VzfjxM9N7ZYAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "import random as rand\n", + "\n", + "df = pd.DataFrame({\n", + " 'dataX': [rand.randint(0, 100) for _ in range(100)],\n", + " 'dataY': [rand.randint(0, 100) for _ in range(100)],\n", + " 'fav_fruit': [rand.choice(['Apples', 'Bananas', 'Grapes', 'Peaches']) for _ in range(100)],\n", + "})\n", + "df.plot.scatter('dataX', 'dataY', c='fav_fruit')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "df_numericals = pd.DataFrame({'dataX': [3,79,90], 'dataY': [7,9,13], 'color': [0,.5,1]})\n", + "df_numtuples = pd.DataFrame({'dataX': [3,79,90], 'dataY': [7,9,13], 'color': [(.2,.2,.2),(.1,.2,.3),(.3,.2,.1)]})\n", + "df_colors = pd.DataFrame({'dataX': [3,79,90], 'dataY': [7,9,13], 'color': ['red','green','blue']})\n", + "df_colorcodes = pd.DataFrame({'dataX': [3,79,90], 'dataY': [7,9,13], 'color': ['r','g','b']})\n", + "df_other = pd.DataFrame({'dataX': [3,79,90, 120], 'dataY': [7,9,13, 5], 'color': ['t','q','f', 't']})" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_numericals.plot.scatter('dataX', 'dataY', c='color')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAGwCAYAAABcnuQpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAkL0lEQVR4nO3deXRU9f3/8dckIRPIMpAghIEkBEXRoJiCOxYoCNUIKq0LVNmPS7EkUhFoUUDFgFpqLVWK8oNoarHKInJa2RcRhbAEWQoIRIgGDEKcSQImmNzfHx7m2wiBJExy55M8H+fcc5x778y84Wrn2Tt3ZhyWZVkCAAAwVJDdAwAAAFwMYgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARguxe4DaVl5erry8PEVGRsrhcNg9DgAAqALLslRYWCi3262goPOfe6n3MZOXl6e4uDi7xwAAADWQm5urNm3anHefeh8zkZGRkn78y4iKirJ5GgAAUBVer1dxcXG+1/Hzqfcxc+atpaioKGIGAADDVOUSES4ABgAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNFsjZl169apb9++crvdcjgcWrRoUYXtkyZNUocOHRQeHq5mzZqpV69e2rhxoz3DAgAAn6yPl2vCY/dpWMp1evq3D2jrp2tsm8XWmCkuLlanTp00Y8aMc26//PLLNWPGDO3YsUPr169X27Zt1bt3bx07dqyOJwUAAGcsmff/9NwTQ7Rzy6f69ps87di8QZN+9xstW/SOLfM4LMuybHnmn3A4HFq4cKHuvvvuSvfxer1yuVxasWKFevbsWaXHPXMfj8fDD00CAHCRThYValCfa1Va8v1Z2xqHR+itpdlyhjW+6Oepzuu3MdfMlJaWatasWXK5XOrUqVOl+5WUlMjr9VZYAACAf/x3e9Y5Q0aSThUXad/ObXU8kQExs2TJEkVERCgsLEx//vOftXz5cjVv3rzS/dPT0+VyuXxLXFxcHU4LAED9FhwSct7tIY0a1dEk/yfgY6ZHjx7Kzs7Whg0b9Mtf/lL33Xef8vPzK91//Pjx8ng8viU3N7cOpwUAoH5LSr5BEVFNJTkqrHc4HGoW00KXJyXX+UwBHzPh4eG67LLLdOONN2r27NkKCQnR7NmzK93f6XQqKiqqwgIAAPyjUahTqRP/rKDgIAUFB0uSgoKDFRwcotRJf77gmZvaUPfPeJEsy1JJSYndYwAA0GDd0K23Xv3nCn00/23lHc5Rm7aX6vZfD1LrhEttmcfWmCkqKtL+/ft9t3NycpSdna3o6GjFxMRoypQp6tevn1q1aqXjx4/rtdde01dffaV7773XxqkBAEB8u8v18Jjn7B5Dks0xs3nzZvXo0cN3e/To0ZKkwYMHa+bMmdqzZ48yMjL07bffKiYmRtddd50+/vhjJSUl2TUyAAAIMAHzPTO1he+ZAQDAPPXye2YAAADOhZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGM3WmFm3bp369u0rt9sth8OhRYsW+badPn1aY8eO1dVXX63w8HC53W4NGjRIeXl59g0MAAACjq0xU1xcrE6dOmnGjBlnbTt58qS2bt2qp59+Wlu3btWCBQu0b98+9evXz4ZJAQBAoHJYlmXZPYQkORwOLVy4UHfffXel+2RlZen666/XoUOHFB8fX6XH9Xq9crlc8ng8ioqK8tO0AACgNlXn9TukjmbyC4/HI4fDoaZNm1a6T0lJiUpKSny3vV5vHUwGAADsYswFwN9//73GjRungQMHnrfQ0tPT5XK5fEtcXFwdTgkAAOqaETFz+vRpPfDAAyovL9drr7123n3Hjx8vj8fjW3Jzc+toSgAAYIeAf5vp9OnTuu+++5STk6NVq1Zd8H0zp9Mpp9NZR9MBAAC7BXTMnAmZL774QqtXr1ZMTIzdIwEAgABja8wUFRVp//79vts5OTnKzs5WdHS03G63fv3rX2vr1q1asmSJysrKdPToUUlSdHS0QkND7RobAAAEEFs/mr1mzRr16NHjrPWDBw/WpEmTlJiYeM77rV69Wt27d6/Sc/DRbAAAzGPMR7O7d++u87VUgHwFDgAACGBGfJoJAACgMsQMAAAwGjEDAACMRswAAACjETMAAMBoxAwAADAaMQMAAIxGzAAAAKMRMwAAwGjEDAAAMBoxAwAAjEbMAAAAoxEzAADAaMQMAAAwGjEDAACMRswAAACjETMAAMBoxAwAADAaMQMAAIxGzAAAAKMRMwAAwGjEDAAAMBoxAwAAjEbMAAAAoxEzAADAaMQMAAAwGjEDAACMRswAAACjETMAAMBoxAwAADAaMQMAAIxGzAAAAKMRMwAAwGjEDAAAMBoxAwAAjEbMAAAAoxEzAADAaMQMAAAwGjEDAACMRswAAACjETMAAMBoxAwAADAaMQMAAIxGzAAAAKMRMwAAwGi2xsy6devUt29fud1uORwOLVq0qML2BQsWqE+fPmrevLkcDoeys7NtmRMAAAQuW2OmuLhYnTp10owZMyrdfsstt2jq1Kl1PBkAADBFiJ1Pfvvtt+v222+vdPtDDz0kSfryyy/raCIAAGAaW2OmNpSUlKikpMR32+v12jgNAACobfXuAuD09HS5XC7fEhcXZ/dIAACgFtW7mBk/frw8Ho9vyc3NtXskAABQi+rd20xOp1NOp9PuMQAAQB2pd2dmAABAw2LrmZmioiLt37/fdzsnJ0fZ2dmKjo5WfHy8Tpw4ocOHDysvL0+StHfvXklSbGysYmNjbZkZAAAEFlvPzGzevFnJyclKTk6WJI0ePVrJycl65plnJEmLFy9WcnKyUlJSJEkPPPCAkpOTNXPmTNtmBgAAgcVhWZZl9xC1yev1yuVyyePxKCoqyu5xAABAFVTn9ZtrZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGq1bM/OpXv9Lx48draxYAAIBqq1bMHDlyRElJSfrwww9rax4AAIBqqVbMfPLJJ/r973+v+++/X8OHD1dhYWFtzQUAAFAlDsuyrOreac+ePRo6dKiOHDmiUaNGKSQkpML2UaNG+W3Ai+X1euVyueTxeBQVFWX3OAAAoAqq8/pdo5iRpDfffFOPPvqoWrVqVSFmHA6HDh48WJOHrBXEDAAA5qnO63fIebeewzfffKMRI0Zo/fr1mj17tgYPHlzjQQEAAC5Wta6ZmTdvnpKSkvT999/r888/J2QAAIDtqhUzw4cP18SJE7V8+XLFxcXV1kwAAABVVq23mbKzs9W+ffvamgUAAKDaqhUzPw2Z3bt36/DhwyotLa2wvl+/fhc/GQAAQBVU+wJgSTp48KDuuece7dixQw6HQ2c+EOVwOCRJZWVl/psQAADgPGr020ypqalKTEzUN998oyZNmmjXrl1at26dunTpojVr1vh5RAAAgMrV6MzMp59+qlWrVumSSy5RUFCQgoKC1LVrV6Wnp2vUqFHatm2bv+cEAAA4pxqdmSkrK1NERIQkqXnz5srLy5MkJSQkaO/evVV+nHXr1qlv375yu91yOBxatGhRhe2WZWnSpElyu91q3Lixunfvrl27dtVkZAAAUE/VKGY6duyozz//XJJ0ww036MUXX9Qnn3yiZ599Vu3atavy4xQXF6tTp06aMWPGObe/+OKLmj59umbMmKGsrCzFxsbqtttu4zehAACAT41+zmDp0qUqLi5W//79dfDgQd15553as2ePYmJiNG/ePPXs2bP6gzgcWrhwoe6++25JP56VcbvdSktL09ixYyVJJSUlatmypaZNm6ZHHnmkSo/LzxkAAGCeWv05A0nq06eP75/btWun3bt368SJE2rWrJnvE00XKycnR0ePHlXv3r1965xOp7p166YNGzZUGjMlJSUqKSnx3fZ6vX6ZBwAABKYavc00bNiws97qiY6O1smTJzVs2DC/DHb06FFJUsuWLSusb9mypW/buaSnp8vlcvkWvqkYAID6rUYxk5GRoVOnTp21/tSpU3rrrbcueqj/9dMzPZZlnffsz/jx4+XxeHxLbm6uX+cBAACBpVpvM3m9XlmWJcuyVFhYqLCwMN+2srIy/fvf/1aLFi38MlhsbKykH8/QtGrVyrc+Pz//rLM1/8vpdMrpdPplBgAAEPiqFTNNmzaVw+GQw+HQ5ZdfftZ2h8OhyZMn+2WwxMRExcbGavny5UpOTpYklZaWau3atZo2bZpfngMAAJivWjGzevVqWZalX/ziF5o/f76io6N920JDQ5WQkCC3213lxysqKtL+/ft9t3NycpSdna3o6GjFx8crLS1NL7zwgtq3b6/27dvrhRdeUJMmTTRw4MDqjA0AAOqxasVMt27dJP0YHXFxcQoKqtElNz6bN29Wjx49fLdHjx4tSRo8eLDmzp2rp556SqdOndJvf/tbFRQU6IYbbtCyZcsUGRl5Uc8LAADqjxp9z8wZJ0+ePOevZl9zzTUXPZi/8D0zAACYp9a/Z+bYsWMaOnSo/vOf/5xzO7+aDQAA6kqN3idKS0tTQUGBPvvsMzVu3FgfffSRMjIy1L59ey1evNjfMwIAAFSqRmdmVq1apQ8++EDXXXedgoKClJCQoNtuu01RUVFKT09XSkqKv+cEAAA4pxqdmSkuLvZ9n0x0dLSOHTsmSbr66qu1detW/00HAABwATWKmSuuuEJ79+6VJF177bX6+9//rq+//lozZ86s8AV3AAAAta1GbzOlpaXpyJEjkqSJEyeqT58+yszMVGhoqDIyMvw6IAAAwPlc1Eezzzh58qT27Nmj+Ph4NW/e3B9z+Q0fzQYAwDy18tHsM19oVxXTp0+v8r4AAAAXo8oxs23btgq3t2zZorKyMl1xxRWSpH379ik4OFidO3f274QAAADnUeWYWb16te+fp0+frsjISGVkZKhZs2aSpIKCAg0dOlS33nqr/6cEAACoRI2umWndurWWLVumpKSkCut37typ3r17Ky8vz28DXiyumQEAwDzVef2u0UezvV6vvvnmm7PW5+fnq7CwsCYPCQAAUCM1ipl77rlHQ4cO1fvvv6+vvvpKX331ld5//30NHz5c/fv39/eMAAAAlarR98zMnDlTTz75pB588EGdPn36xwcKCdHw4cP10ksv+XVAAACA87mo75kpLi7WgQMHZFmWLrvsMoWHh/tzNr/gmhkAAMxTK98zcy7h4eG65pprLuYhAAAALkqNrpkBAAAIFMQMAAAwGjEDAACMRswAAACjETMAAMBoxAwAADAaMQMAAIxGzAAAAKMRMwAAwGjEDAAAMBoxAwAAjEbMAAAAoxEzAADAaMQMAAAwGjEDAACMRswAAACjETMAAMBoxAwAADAaMQMAAIxGzAAAAKMRMwAAwGjEDAAAMBoxAwAAjEbMAAAAoxEzAADAaMQMAAAwGjEDAACMRswAAACjETMAAMBoAR8zhYWFSktLU0JCgho3bqybb75ZWVlZdo8FAECllq3dqHsf/aO63DFUAx+fqHWfbbN7pHotxO4BLmTEiBHauXOn3n77bbndbmVmZqpXr17avXu3Wrdubfd4AABU8MY7H2jS9NkKCgpSeXm58r8t0NrPtulPT/9OD9x1m93j1UsOy7Isu4eozKlTpxQZGakPPvhAKSkpvvXXXnut7rzzTj3//PMXfAyv1yuXyyWPx6OoqKjaHBcA0MB5i4p1be9BKik9fda2qIhwbVuaoTBnqA2Tmac6r98B/TbTDz/8oLKyMoWFhVVY37hxY61fv/6c9ykpKZHX662wAABQFzZu233OkJF+DJ3tu7+o44kahoCOmcjISN1000167rnnlJeXp7KyMmVmZmrjxo06cuTIOe+Tnp4ul8vlW+Li4up4agBAQ9UoJPj82xsF/NUdRgromJGkt99+W5ZlqXXr1nI6nXr11Vc1cOBABQef+1+Y8ePHy+Px+Jbc3Nw6nhgA0FDd+LOOiooIl+Mn6x0Oh1peEq1OV15my1z1XcDHzKWXXqq1a9eqqKhIubm52rRpk06fPq3ExMRz7u90OhUVFVVhAQCgLoQ5QzV94igFBQUpOPjHl9jg4CCFhATrlYmplf4fcVwcY853hYeHKzw8XAUFBVq6dKlefPFFu0cCAOAst/e4Scv/+arenv8ffZl7RJclxmnQr29Xu3i33aPVWwH9aSZJWrp0qSzL0hVXXKH9+/drzJgxcjqdWr9+vRo1anTB+/NpJgAAzFNvPs0kSR6PRyNHjlSHDh00aNAgde3aVcuWLatSyAAAgPov4M/MXCzOzAAAYJ56dWYGAADgfIgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNECOmZ++OEHTZgwQYmJiWrcuLHatWunZ599VuXl5XaPBgAAAkSI3QOcz7Rp0zRz5kxlZGQoKSlJmzdv1tChQ+VyuZSammr3eAAAIAAEdMx8+umnuuuuu5SSkiJJatu2rf75z39q8+bNNk8GAAACRUC/zdS1a1etXLlS+/btkyRt375d69ev1x133FHpfUpKSuT1eissAACg/groMzNjx46Vx+NRhw4dFBwcrLKyMk2ZMkUDBgyo9D7p6emaPHlyHU4JAADsFNBnZt59911lZmbqnXfe0datW5WRkaGXX35ZGRkZld5n/Pjx8ng8viU3N7cOJwYAAHXNYVmWZfcQlYmLi9O4ceM0cuRI37rnn39emZmZ2rNnT5Uew+v1yuVyyePxKCoqqrZGBQAAflSd1++APjNz8uRJBQVVHDE4OJiPZgMAAJ+Avmamb9++mjJliuLj45WUlKRt27Zp+vTpGjZsmN2jAQCAABHQbzMVFhbq6aef1sKFC5Wfny+3260BAwbomWeeUWhoaJUeg7eZAAAwT3VevwM6ZvyBmAEAwDz15poZAACACyFmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYL+Jhp27atHA7HWcvIkSNtm2nz5s1KTU1VSkqKRowYoRUrVtg2CwAADV2I3QNcSFZWlsrKyny3d+7cqdtuu0333nuvLfMsXbpUEyZMUFBQkMrKynTs2DFlZ2frscce0/Dhw22ZCQCAhizgz8xccsklio2N9S1LlizRpZdeqm7dutX5LD/88INefvllWZblC6zy8nJJ0qxZs3TixIk6nwkAgIYu4GPmf5WWliozM1PDhg2Tw+E45z4lJSXyer0VFn/Zv3+/CgoKzrmtrKxMWVlZfnsuAABQNUbFzKJFi/Tdd99pyJAhle6Tnp4ul8vlW+Li4vz2/CEh539XrlGjRn57LgAAUDUOy7Isu4eoqj59+ig0NFQffvhhpfuUlJSopKTEd9vr9SouLk4ej0dRUVEX9fyWZal///766quv9NO/trCwMC1btkxNmjS5qOcAAAA/vn67XK4qvX4bc2bm0KFDWrFihUaMGHHe/ZxOp6Kioios/uJwOPTMM88oNDRUwcHBkqTg4GA5HA5NmDCBkAEAwAYB/2mmM+bMmaMWLVooJSXF1jmSk5P1r3/9S++//74OHDggt9ut/v376/LLL7d1LgAAGiojYqa8vFxz5szR4MGDL3jdSl1o3bq1UlNT7R4DAADIkLeZVqxYocOHD2vYsGF2jwIAAAKM/ac5qqB3795nXXALAAAgGXJmBgAAoDLEDAAAMBoxAwAAjEbMAAAAoxEzAADAaMQMAAAwGjEDAACMRswAAACjETMAAMBoRnwD8MU4883BXq/X5kkAAEBVnXndrsovANT7mCksLJQkxcXF2TwJAACorsLCQrlcrvPu47Dq+Y8elZeXKy8vT5GRkXI4HBW2eb1excXFKTc3V1FRUTZNiMpwfAIXxyawcXwCG8enaizLUmFhodxut4KCzn9VTL0/MxMUFKQ2bdqcd5+oqCj+hQpgHJ/AxbEJbByfwMbxubALnZE5gwuAAQCA0YgZAABgtAYdM06nUxMnTpTT6bR7FJwDxydwcWwCG8cnsHF8/K/eXwAMAADqtwZ9ZgYAAJiPmAEAAEYjZgAAgNGIGQAAYLQGGzOvvfaaEhMTFRYWps6dO+vjjz+2e6QGKT09Xdddd50iIyPVokUL3X333dq7d2+FfSzL0qRJk+R2u9W4cWN1795du3btsmnihis9PV0Oh0NpaWm+dRwbe3399dd68MEHFRMToyZNmujaa6/Vli1bfNs5Pvb54YcfNGHCBCUmJqpx48Zq166dnn32WZWXl/v24fj4kdUAzZs3z2rUqJH1xhtvWLt377ZSU1Ot8PBw69ChQ3aP1uD06dPHmjNnjrVz504rOzvbSklJseLj462ioiLfPlOnTrUiIyOt+fPnWzt27LDuv/9+q1WrVpbX67Vx8oZl06ZNVtu2ba1rrrnGSk1N9a3n2NjnxIkTVkJCgjVkyBBr48aNVk5OjrVixQpr//79vn04PvZ5/vnnrZiYGGvJkiVWTk6O9d5771kRERHWK6+84tuH4+M/DTJmrr/+euvRRx+tsK5Dhw7WuHHjbJoIZ+Tn51uSrLVr11qWZVnl5eVWbGysNXXqVN8+33//veVyuayZM2faNWaDUlhYaLVv395avny51a1bN1/McGzsNXbsWKtr166Vbuf42CslJcUaNmxYhXX9+/e3HnzwQcuyOD7+1uDeZiotLdWWLVvUu3fvCut79+6tDRs22DQVzvB4PJKk6OhoSVJOTo6OHj1a4Xg5nU5169aN41VHRo4cqZSUFPXq1avCeo6NvRYvXqwuXbro3nvvVYsWLZScnKw33njDt53jY6+uXbtq5cqV2rdvnyRp+/btWr9+ve644w5JHB9/q/c/NPlT3377rcrKytSyZcsK61u2bKmjR4/aNBWkH98/Hj16tLp27aqOHTtKku+YnOt4HTp0qM5nbGjmzZunrVu3Kisr66xtHBt7HTx4UK+//rpGjx6tP/zhD9q0aZNGjRolp9OpQYMGcXxsNnbsWHk8HnXo0EHBwcEqKyvTlClTNGDAAEn89+NvDS5mznA4HBVuW5Z11jrUrccff1yff/651q9ff9Y2jlfdy83NVWpqqpYtW6awsLBK9+PY2KO8vFxdunTRCy+8IElKTk7Wrl279Prrr2vQoEG+/Tg+9nj33XeVmZmpd955R0lJScrOzlZaWprcbrcGDx7s24/j4x8N7m2m5s2bKzg4+KyzMPn5+WcVMurO7373Oy1evFirV69WmzZtfOtjY2MlieNlgy1btig/P1+dO3dWSEiIQkJCtHbtWr366qsKCQnx/f1zbOzRqlUrXXXVVRXWXXnllTp8+LAk/tux25gxYzRu3Dg98MADuvrqq/XQQw/piSeeUHp6uiSOj781uJgJDQ1V586dtXz58grrly9frptvvtmmqRouy7L0+OOPa8GCBVq1apUSExMrbE9MTFRsbGyF41VaWqq1a9dyvGpZz549tWPHDmVnZ/uWLl266De/+Y2ys7PVrl07jo2NbrnllrO+xmDfvn1KSEiQxH87djt58qSCgiq+xAYHB/s+ms3x8TMbLz62zZmPZs+ePdvavXu3lZaWZoWHh1tffvml3aM1OI899pjlcrmsNWvWWEeOHPEtJ0+e9O0zdepUy+VyWQsWLLB27NhhDRgwgI8v2uR/P81kWRwbO23atMkKCQmxpkyZYn3xxRfWP/7xD6tJkyZWZmambx+Oj30GDx5stW7d2vfR7AULFljNmze3nnrqKd8+HB//aZAxY1mW9be//c1KSEiwQkNDrZ/97Ge+jwKjbkk65zJnzhzfPuXl5dbEiROt2NhYy+l0Wj//+c+tHTt22Dd0A/bTmOHY2OvDDz+0OnbsaDmdTqtDhw7WrFmzKmzn+NjH6/VaqampVnx8vBUWFma1a9fO+uMf/2iVlJT49uH4+I/DsizLzjNDAAAAF6PBXTMDAADqF2IGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQABoXv37kpLS7N7DAAGImYAGGfNmjVyOBz67rvvqnW/7du3y+l0avHixRXWz58/X2FhYdq5c6cfpwRQV4gZAA1Gp06d9PTTT+vhhx/W8ePHJUn5+fl69NFHNXnyZHXs2NHmCQHUBDEDoM4VFxdr0KBBioiIUKtWrfSnP/2pwvbMzEx16dJFkZGRio2N1cCBA5Wfny9J+vLLL9WjRw9JUrNmzeRwODRkyBBJ0kcffaSuXbuqadOmiomJ0Z133qkDBw5UeOzx48crPj5eI0eOlCQ98sgjat++vZ588sla/lMDqC3EDIA6N2bMGK1evVoLFy7UsmXLtGbNGm3ZssW3vbS0VM8995y2b9+uRYsWKScnxxcscXFxmj9/viRp7969OnLkiP7yl79I+jGSRo8eraysLK1cuVJBQUG65557VF5e7nvs4OBgZWRk6IMPPtDAgQO1dOlSzZ07V8HBwXX3FwDAr/jVbAB1qqioSDExMXrrrbd0//33S5JOnDihNm3a6OGHH9Yrr7xy1n2ysrJ0/fXXq7CwUBEREVqzZo169OihgoICNW3atNLnOnbsmFq0aKEdO3ac9RbS+PHjNXXqVE2bNk1PPfWUP/+IAOoYZ2YA1KkDBw6otLRUN910k29ddHS0rrjiCt/tbdu26a677lJCQoIiIyPVvXt3SdLhw4cv+NgDBw5Uu3btFBUVpcTExHPer6ioSO+++66aNGmijz/+2E9/MgB2IWYA1KkLnQwuLi5W7969FRERoczMTGVlZWnhwoWSfnz76Xz69u2r48eP64033tDGjRu1cePGc95vzJgxCg0N1YYNG7Ry5Uq99dZbF/EnAmA3YgZAnbrsssvUqFEjffbZZ751BQUF2rdvnyRpz549+vbbbzV16lTdeuut6tChg+/i3zNCQ0MlSWVlZb51x48f13//+19NmDBBPXv21JVXXqmCgoKznn/58uV68803NXfuXHXq1EkvvPCC0tLSdOTIkdr44wKoA8QMgDoVERGh4cOHa8yYMVq5cqV27typIUOGKCjox/85io+PV2hoqP7617/q4MGDWrx4sZ577rkKj5GQkCCHw6ElS5bo2LFjKioqUrNmzRQTE6NZs2Zp//79WrVqlUaPHl3hfl6vV8OHD9eTTz6pG2+8UZI0atQoJSUl6eGHH66bvwAAfkfMAKhzL730kn7+85+rX79+6tWrl7p27arOnTtLki655BLNnTtX7733nq666ipNnTpVL7/8coX7t27dWpMnT9a4cePUsmVLPf744woKCtK8efO0ZcsWdezYUU888YReeumlCvdLS0uTy+XS5MmTfeuCgoI0Z84crVq1irebAEPxaSYAAGA0zswAAACjETMAAMBoxAwAADAaMQMAAIxGzAAAAKMRMwAAwGjEDAAAMBoxAwAAjEbMAAAAoxEzAADAaMQMAAAw2v8H4RetKj68qXgAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_numtuples.plot.scatter('dataX', 'dataY', c='color')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_colors.plot.scatter('dataX', 'dataY', c='color')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAGwCAYAAABcnuQpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAj1UlEQVR4nO3de3QU9f3/8dcmIRsIyUKCEAJJCBVBg2IK3qNAwVCNINp6gSpXj5diIVIR+FYrqBBQS62lSlWEaGrxKBeR0wrhDqIQLsEABUQiRC4GAXeTAAkk8/uDw/6akmAum8x+kufjnD11Z2Z33zC1++zM7K7DsixLAAAAhgqwewAAAIDaIGYAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYLQguweoa2VlZTp8+LDCwsLkcDjsHgcAAFSBZVkqKChQdHS0AgIufeylwcfM4cOHFRMTY/cYAACgBvLy8tS+fftLbtPgYyYsLEzS+b+M8PBwm6cBAABV4fF4FBMT430fv5QGHzMXTi2Fh4cTMwAAGKYql4hwATAAADAaMQMAAIxGzAAAAKMRMwAAwGjEDAAAMBoxAwAAjEbMAAAAoxEzAADAaMQMAAAwGjEDAACMZmvMrF27Vv3791d0dLQcDocWLVpUbv2kSZPUpUsXhYaGqmXLlurbt682btxoz7AAAMBryRKpTx8pNla6/XZp6VL7ZrE1ZoqKitStWzfNnDmzwvVXXHGFZs6cqZycHK1fv14dOnRQcnKyjh07Vs+TAgCAC/76V6l/f2nNGikvT1q1SvrlL6V33rFnHodlWZY9L12ew+HQwoULNXDgwEq38Xg8crlcWr58ufr06VOl573wGLfbzQ9NAgBQSx6PFBUlnT598brwcOnoUalpU1+8TtXfv425ZqakpERvvfWWXC6XunXrVul2xcXF8ng85W4AAMA3Pv+84pCRzoeOHVeD+H3MLFmyRM2bN1dISIj+/Oc/KzMzU61atap0+7S0NLlcLu8tJiamHqcFAKBha9Lk0uuDg+tnjv/m9zHTu3dvZWdna8OGDfrlL3+p+++/X/n5+ZVuP3HiRLndbu8tLy+vHqcFAKBhu/VWKSJCcjjKL3c4zp9+uv76+p/J72MmNDRUl19+uW688UbNnj1bQUFBmj17dqXbO51OhYeHl7sBAADfcDqlOXOkwEApKOj8sqCg87e5c///svpkw0vWjmVZKi4utnsMAAAarQEDpO3bpVmzpK+/lrp0kZ54QrriCnvmsTVmCgsLtW/fPu/93NxcZWdnKyIiQpGRkZoyZYoGDBigtm3b6vjx43rjjTf03Xff6b777rNxagAAcNVV0uuv2z3FebbGzObNm9W7d2/v/bFjx0qShg4dqlmzZmn37t1KT0/XDz/8oMjISF133XVat26dEhIS7BoZAAD4Gb/5npm6wvfMAABgngb5PTMAAAAVIWYAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARrM1ZtauXav+/fsrOjpaDodDixYt8q47e/asxo8fr6uvvlqhoaGKjo7WkCFDdPjwYfsGBgAAfsfWmCkqKlK3bt00c+bMi9adOnVKW7du1XPPPaetW7dqwYIF2rt3rwYMGGDDpAAAwF85LMuy7B5CkhwOhxYuXKiBAwdWuk1WVpauv/56HThwQLGxsVV6Xo/HI5fLJbfbrfDwcB9NCwAA6lJ13r+D6mkmn3C73XI4HGrRokWl2xQXF6u4uNh73+Px1MNkAADALsZcAHzmzBlNmDBBgwcPvmShpaWlyeVyeW8xMTH1OCUAAKhvRsTM2bNn9eCDD6qsrExvvPHGJbedOHGi3G6395aXl1dPUwIAADv4/Wmms2fP6v7771dubq5Wrlz5k+fNnE6nnE5nPU0HAADs5tcxcyFkvv76a61atUqRkZF2jwQAAPyMrTFTWFioffv2ee/n5uYqOztbERERio6O1q9//Wtt3bpVS5YsUWlpqY4ePSpJioiIUHBwsF1jAwAAP2LrR7NXr16t3r17X7R86NChmjRpkuLj4yt83KpVq9SrV68qvQYfzQYAwDzGfDS7V69eulRL+clX4AAAAD9mxKeZAAAAKkPMAAAAoxEzAADAaMQMAAAwGjEDAACMRswAAACjETMAAMBoxAwAADAaMQMAAIxGzAAAAKMRMwAAwGjEDAAAMBoxAwAAjEbMAAAAoxEzAADAaMQMAAAwGjEDAACMRswAAACjETMAAMBoxAwAADAaMQMAAIxGzAAAAKMRMwAAwGjEDAAAMBoxAwAAjEbMAAAAoxEzAADAaMQMAAAwGjEDAACMRswAAACjETMAAMBoxAwAADAaMQMAAIxGzAAAAKMRMwAAwGjEDAAAMBoxAwAAjEbMAAAAoxEzAADAaMQMAAAwGjEDAACMRswAAACjETMAAMBoxAwAADAaMQMAAIxma8ysXbtW/fv3V3R0tBwOhxYtWlRu/YIFC9SvXz+1atVKDodD2dnZtswJAAD8l60xU1RUpG7dumnmzJmVrr/llls0bdq0ep4MAACYIsjOF7/jjjt0xx13VLr+4YcfliR9++239TQRAAAwja0xUxeKi4tVXFzsve/xeGycBgAA1LUGdwFwWlqaXC6X9xYTE2P3SAAAoA41uJiZOHGi3G6395aXl2f3SAAAoA41uNNMTqdTTqfT7jEAAEA9aXBHZgAAQONi65GZwsJC7du3z3s/NzdX2dnZioiIUGxsrE6cOKGDBw/q8OHDkqQ9e/ZIkqKiohQVFWXLzAAAwL/YemRm8+bNSkxMVGJioiRp7NixSkxM1B//+EdJ0uLFi5WYmKiUlBRJ0oMPPqjExETNmjXLtpkBAIB/cViWZdk9RF3yeDxyuVxyu90KDw+3exwAAFAF1Xn/5poZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGqFTO/+tWvdPz48bqaBQAAoNqqFTNHjhxRQkKCPv3007qaBwAAoFqqFTOff/65fv/73+uBBx7QyJEjVVBQUFdzAQAAVInDsiyrug/avXu3hg8friNHjmj06NEKCgoqt3706NE+G7C2PB6PXC6X3G63wsPD7R4HAABUQXXev2sUM5L0zjvv6PHHH1fbtm3LxYzD4dD+/ftr8pR1gpgBAMA81Xn/Drrk2gp8//33euSRR7R+/XrNnj1bQ4cOrfGgAAAAtVWta2bmzZunhIQEnTlzRl999RUhAwAAbFetmBk5cqSef/55ZWZmKiYmpq5mAgAAqLJqnWbKzs5Wp06d6moWAACAaqtWzPxvyOzatUsHDx5USUlJueUDBgyo/WQAAABVUO0LgCVp//79uueee5STkyOHw6ELH4hyOBySpNLSUt9NCAAAcAk1+m2mMWPGKD4+Xt9//72aNWumnTt3au3aterRo4dWr17t4xEBAAAqV6MjM1988YVWrlypyy67TAEBAQoICFBSUpLS0tI0evRobdu2zddzAgAAVKhGR2ZKS0vVvHlzSVKrVq10+PBhSVJcXJz27NlT5edZu3at+vfvr+joaDkcDi1atKjcesuyNGnSJEVHR6tp06bq1auXdu7cWZORAQBAA1WjmOnatau++uorSdINN9ygl19+WZ9//rleeOEFdezYscrPU1RUpG7dumnmzJkVrn/55Zc1Y8YMzZw5U1lZWYqKitLtt9/Ob0IBAACvGv2cwdKlS1VUVKR7771X+/fv11133aXdu3crMjJS8+bNU58+fao/iMOhhQsXauDAgZLOH5WJjo5Wamqqxo8fL0kqLi5WmzZtNH36dD322GNVel5+zgAAAPPU6c8ZSFK/fv28/9yxY0ft2rVLJ06cUMuWLb2faKqt3NxcHT16VMnJyd5lTqdTPXv21IYNGyqNmeLiYhUXF3vvezwen8wDAAD8U41OM40YMeKiUz0RERE6deqURowY4ZPBjh49Kklq06ZNueVt2rTxrqtIWlqaXC6X98Y3FQMA0LDVKGbS09N1+vTpi5afPn1a7733Xq2H+m//e6THsqxLHv2ZOHGi3G6395aXl+fTeQAAgH+p1mkmj8cjy7JkWZYKCgoUEhLiXVdaWqp//etfat26tU8Gi4qKknT+CE3btm29y/Pz8y86WvPfnE6nnE6nT2YAAAD+r1ox06JFCzkcDjkcDl1xxRUXrXc4HJo8ebJPBouPj1dUVJQyMzOVmJgoSSopKdGaNWs0ffp0n7wGAAAwX7ViZtWqVbIsS7/4xS80f/58RUREeNcFBwcrLi5O0dHRVX6+wsJC7du3z3s/NzdX2dnZioiIUGxsrFJTUzV16lR16tRJnTp10tSpU9WsWTMNHjy4OmMDAIAGrFox07NnT0nnoyMmJkYBATW65MZr8+bN6t27t/f+2LFjJUlDhw7V3Llz9cwzz+j06dP67W9/q5MnT+qGG27QsmXLFBYWVqvXBQAADUeNvmfmglOnTlX4q9nXXHNNrQfzFb5nBgAA89T598wcO3ZMw4cP17///e8K1/Or2QAAoL7U6DxRamqqTp48qS+//FJNmzbVZ599pvT0dHXq1EmLFy/29YwAAACVqtGRmZUrV+qTTz7Rddddp4CAAMXFxen2229XeHi40tLSlJKS4us5AQAAKlSjIzNFRUXe75OJiIjQsWPHJElXX321tm7d6rvpAAAAfkKNYqZz587as2ePJOnaa6/V3//+dx06dEizZs0q9wV3AAAAda1Gp5lSU1N15MgRSdLzzz+vfv36KSMjQ8HBwUpPT/fpgAAAAJdSq49mX3Dq1Cnt3r1bsbGxatWqlS/m8hk+mg0AgHnq5KPZF77QripmzJhR5W0BAABqo8oxs23btnL3t2zZotLSUnXu3FmStHfvXgUGBqp79+6+nRAAAOASqhwzq1at8v7zjBkzFBYWpvT0dLVs2VKSdPLkSQ0fPly33nqr76cEAACoRI2umWnXrp2WLVumhISEcst37Nih5ORkHT582GcD1hbXzAAAYJ7qvH/X6KPZHo9H33///UXL8/PzVVBQUJOnBAAAqJEaxcw999yj4cOH6+OPP9Z3332n7777Th9//LFGjhype++919czAgAAVKpG3zMza9YsPf3003rooYd09uzZ808UFKSRI0fqlVde8emAAAAAl1Kr75kpKirSN998I8uydPnllys0NNSXs/kE18wAAGCeOvmemYqEhobqmmuuqc1TAAAA1EqNrpkBAADwF8QMAAAwGjEDAACMRswAAACjETMAAMBoxAwAADAaMQMAAIxGzAAAAKMRMwAAwGjEDAAAMBoxAwAAjEbMAAAAoxEzAADAaMQMAAAwGjEDAACMRswAAACjETMAAMBoxAwAADAaMQMAAIxGzAAAAKMRMwAAwGjEDAAAMBoxAwAAjEbMAAAAoxEzAADAaMQMAAAwGjEDAACMRswAAACjETMAAMBofh8zBQUFSk1NVVxcnJo2baqbb75ZWVlZdo8FAEClFu9ZrF+k/0Ixf45Rv4x+yvwm0+6RGjS/j5lHHnlEmZmZev/995WTk6Pk5GT17dtXhw4dsns0AAAu8tqXr+nueXdr7YG1+s7znVbsX6HkjGS9u+1du0drsByWZVl2D1GZ06dPKywsTJ988olSUlK8y6+99lrdddddeumll37yOTwej1wul9xut8LDw+tyXABAI+c+41bUn6J05tyZi9a5nC4dffqoQoJCbJjMPNV5//brIzPnzp1TaWmpQkLK7/imTZtq/fr1FT6muLhYHo+n3A0AgPqw7uC6CkNGktzFbmUd4jKJuuDXMRMWFqabbrpJL774og4fPqzS0lJlZGRo48aNOnLkSIWPSUtLk8vl8t5iYmLqeWoAQGPVJKDJJdcHBwbX0ySNi1/HjCS9//77sixL7dq1k9Pp1Ouvv67BgwcrMDCwwu0nTpwot9vtveXl5dXzxACAxqpnh55qEdJCDjnKLXfIoeiwaPWI7mHTZA2b38fMz372M61Zs0aFhYXKy8vTpk2bdPbsWcXHx1e4vdPpVHh4eLkbAAD1ISQoRO8OeFcBjgAFBQRJkoIcQWoS2ERz756rwICK/484aifI7gGqKjQ0VKGhoTp58qSWLl2ql19+2e6RAAC4yD1X3qPtj2/XrM2ztO/kPl3Z6ko90eMJdYrsZPdoDZZff5pJkpYuXSrLstS5c2ft27dP48aNk9Pp1Pr169WkyaXPTUp8mgkAABM1mE8zSZLb7daoUaPUpUsXDRkyRElJSVq2bFmVQgYAADR8fn9kprY4MgMAgHka1JEZAACASyFmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEbz65g5d+6cnn32WcXHx6tp06bq2LGjXnjhBZWVldk9GgAA8BNBdg9wKdOnT9esWbOUnp6uhIQEbd68WcOHD5fL5dKYMWPsHg8AAPgBv46ZL774QnfffbdSUlIkSR06dNA///lPbd682ebJAACAv/Dr00xJSUlasWKF9u7dK0navn271q9frzvvvLPSxxQXF8vj8ZS7AQCAhsuvj8yMHz9ebrdbXbp0UWBgoEpLSzVlyhQNGjSo0sekpaVp8uTJ9TglAACwk18fmfnwww+VkZGhDz74QFu3blV6erpeffVVpaenV/qYiRMnyu12e295eXn1ODEAAKhvDsuyLLuHqExMTIwmTJigUaNGeZe99NJLysjI0O7du6v0HB6PRy6XS263W+Hh4XU1KgAA8KHqvH/79ZGZU6dOKSCg/IiBgYF8NBsAAHj59TUz/fv315QpUxQbG6uEhARt27ZNM2bM0IgRI+weDQAA+Am/Ps1UUFCg5557TgsXLlR+fr6io6M1aNAg/fGPf1RwcHCVnoPTTAAAmKc6799+HTO+QMwAAGCeBnPNDAAAwE8hZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABGI2YAAIDRiBkAAGA0YgYAABiNmAEAAEYjZgAAgNGIGQAAYDRiBgAAGI2YAQAARiNmAACA0YgZAABgNGIGAAAYjZgBAABG8/uY6dChgxwOx0W3UaNG2TfU6tVSSooUGyvddpv08cf2zQIAQCMXZPcAPyUrK0ulpaXe+zt27NDtt9+u++67z56B5s2TBg+WAgKk0lLp0CFp3TrppZekP/zBnpkAAGjEHJZlWXYPUR2pqalasmSJvv76azkcjp/c3uPxyOVyye12Kzw8vHYvfvas1L69lJ9/8bqgoPNh07p17V4DAABU6/3b708z/beSkhJlZGRoxIgRlYZMcXGxPB5PuZvP5ORUHDKSdO6ctHKl714LAABUiVExs2jRIv34448aNmxYpdukpaXJ5XJ5bzExMb4boEmTS68PDvbdawEAgCox6jRTv379FBwcrE8//bTSbYqLi1VcXOy97/F4FBMT45vTTJYlXXGFtH+/VFZWfl2zZtL330vNm9fuNQAAQLVOM/n9BcAXHDhwQMuXL9eCBQsuuZ3T6ZTT6aybIRwO6d13pX79pJKS8xcABwWd/8+33yZkAACwgTExM2fOHLVu3VopKSn2DnLrrdLOndKbb56/hiY+XnrsMalbN3vnAgCgkTIiZsrKyjRnzhwNHTpUQUF+MHJ8vPTyy3ZPAQAAZMgFwMuXL9fBgwc1YsQIu0cBAAB+xg8Oc/y05ORkGXSdMgAAqEdGHJkBAACoDDEDAACMRswAAACjETMAAMBoxAwAADAaMQMAAIxGzAAAAKMRMwAAwGjEDAAAMJoR3wBcGxe+Odjj8dg8CQAAqKoL79tV+QWABh8zBQUFkqSYmBibJwEAANVVUFAgl8t1yW0cVgP/0aOysjIdPnxYYWFhcjgc5dZ5PB7FxMQoLy9P4eHhNk2IyrB//Bf7xr+xf/wb+6dqLMtSQUGBoqOjFRBw6atiGvyRmYCAALVv3/6S24SHh/NfKD/G/vFf7Bv/xv7xb+yfn/ZTR2Qu4AJgAABgNGIGAAAYrVHHjNPp1PPPPy+n02n3KKgA+8d/sW/8G/vHv7F/fK/BXwAMAAAatkZ9ZAYAAJiPmAEAAEYjZgAAgNGIGQAAYLRGGzNvvPGG4uPjFRISou7du2vdunV2j9QopaWl6brrrlNYWJhat26tgQMHas+ePeW2sSxLkyZNUnR0tJo2bapevXpp586dNk3ceKWlpcnhcCg1NdW7jH1jr0OHDumhhx5SZGSkmjVrpmuvvVZbtmzxrmf/2OfcuXN69tlnFR8fr6ZNm6pjx4564YUXVFZW5t2G/eNDViM0b948q0mTJtbbb79t7dq1yxozZowVGhpqHThwwO7RGp1+/fpZc+bMsXbs2GFlZ2dbKSkpVmxsrFVYWOjdZtq0aVZYWJg1f/58Kycnx3rggQestm3bWh6Px8bJG5dNmzZZHTp0sK655hprzJgx3uXsG/ucOHHCiouLs4YNG2Zt3LjRys3NtZYvX27t27fPuw37xz4vvfSSFRkZaS1ZssTKzc21PvroI6t58+bWa6+95t2G/eM7jTJmrr/+euvxxx8vt6xLly7WhAkTbJoIF+Tn51uSrDVr1liWZVllZWVWVFSUNW3aNO82Z86csVwulzVr1iy7xmxUCgoKrE6dOlmZmZlWz549vTHDvrHX+PHjraSkpErXs3/slZKSYo0YMaLcsnvvvdd66KGHLMti//haozvNVFJSoi1btig5Obnc8uTkZG3YsMGmqXCB2+2WJEVEREiScnNzdfTo0XL7y+l0qmfPnuyvejJq1CilpKSob9++5Zazb+y1ePFi9ejRQ/fdd59at26txMREvf3229717B97JSUlacWKFdq7d68kafv27Vq/fr3uvPNOSewfX2vwPzT5v3744QeVlpaqTZs25Za3adNGR48etWkqSOfPH48dO1ZJSUnq2rWrJHn3SUX768CBA/U+Y2Mzb948bd26VVlZWRetY9/Ya//+/XrzzTc1duxY/d///Z82bdqk0aNHy+l0asiQIewfm40fP15ut1tdunRRYGCgSktLNWXKFA0aNEgS//74WqOLmQscDke5+5ZlXbQM9evJJ5/UV199pfXr11+0jv1V//Ly8jRmzBgtW7ZMISEhlW7HvrFHWVmZevTooalTp0qSEhMTtXPnTr355psaMmSIdzv2jz0+/PBDZWRk6IMPPlBCQoKys7OVmpqq6OhoDR061Lsd+8c3Gt1pplatWikwMPCiozD5+fkXFTLqz+9+9zstXrxYq1atUvv27b3Lo6KiJIn9ZYMtW7YoPz9f3bt3V1BQkIKCgrRmzRq9/vrrCgoK8v79s2/s0bZtW1111VXlll155ZU6ePCgJP7dsdu4ceM0YcIEPfjgg7r66qv18MMP66mnnlJaWpok9o+vNbqYCQ4OVvfu3ZWZmVlueWZmpm6++Wabpmq8LMvSk08+qQULFmjlypWKj48vtz4+Pl5RUVHl9ldJSYnWrFnD/qpjffr0UU5OjrKzs723Hj166De/+Y2ys7PVsWNH9o2Nbrnllou+xmDv3r2Ki4uTxL87djt16pQCAsq/xQYGBno/ms3+8TEbLz62zYWPZs+ePdvatWuXlZqaaoWGhlrffvut3aM1Ok888YTlcrms1atXW0eOHPHeTp065d1m2rRplsvlshYsWGDl5ORYgwYN4uOLNvnvTzNZFvvGTps2bbKCgoKsKVOmWF9//bX1j3/8w2rWrJmVkZHh3Yb9Y5+hQ4da7dq18340e8GCBVarVq2sZ555xrsN+8d3GmXMWJZl/e1vf7Pi4uKs4OBg6+c//7n3o8CoX5IqvM2ZM8e7TVlZmfX8889bUVFRltPptG677TYrJyfHvqEbsf+NGfaNvT799FOra9eultPptLp06WK99dZb5dazf+zj8XisMWPGWLGxsVZISIjVsWNH6w9/+INVXFzs3Yb94zsOy7IsO48MAQAA1Eaju2YGAAA0LMQMAAAwGjEDAACMRswAAACjETMAAMBoxAwAADAaMQMAAIxGzAAAAKMRMwD8Qq9evZSammr3GAAMRMwAMM7q1avlcDj0448/Vutx27dvl9Pp1OLFi8stnz9/vkJCQrRjxw4fTgmgvhAzABqNbt266bnnntOjjz6q48ePS5Ly8/P1+OOPa/LkyeratavNEwKoCWIGQL0rKirSkCFD1Lx5c7Vt21Z/+tOfyq3PyMhQjx49FBYWpqioKA0ePFj5+fmSpG+//Va9e/eWJLVs2VIOh0PDhg2TJH322WdKSkpSixYtFBkZqbvuukvffPNNueeeOHGiYmNjNWrUKEnSY489pk6dOunpp5+u4z81gLpCzACod+PGjdOqVau0cOFCLVu2TKtXr9aWLVu860tKSvTiiy9q+/btWrRokXJzc73BEhMTo/nz50uS9uzZoyNHjugvf/mLpPORNHbsWGVlZWnFihUKCAjQPffco7KyMu9zBwYGKj09XZ988okGDx6spUuXau7cuQoMDKy/vwAAPsWvZgOoV4WFhYqMjNR7772nBx54QJJ04sQJtW/fXo8++qhee+21ix6TlZWl66+/XgUFBWrevLlWr16t3r176+TJk2rRokWlr3Xs2DG1bt1aOTk5F51CmjhxoqZNm6bp06frmWee8eUfEUA948gMgHr1zTffqKSkRDfddJN3WUREhDp37uy9v23bNt19992Ki4tTWFiYevXqJUk6ePDgTz734MGD1bFjR4WHhys+Pr7CxxUWFurDDz9Us2bNtG7dOh/9yQDYhZgBUK9+6mBwUVGRkpOT1bx5c2VkZCgrK0sLFy6UdP7006X0799fx48f19tvv62NGzdq48aNFT5u3LhxCg4O1oYNG7RixQq99957tfgTAbAbMQOgXl1++eVq0qSJvvzyS++ykydPau/evZKk3bt364cfftC0adN06623qkuXLt6Lfy8IDg6WJJWWlnqXHT9+XP/5z3/07LPPqk+fPrryyit18uTJi14/MzNT77zzjubOnatu3bpp6tSpSk1N1ZEjR+rijwugHhAzAOpV8+bNNXLkSI0bN04rVqzQjh07NGzYMAUEnP+fo9jYWAUHB+uvf/2r9u/fr8WLF+vFF18s9xxxcXFyOBxasmSJjh07psLCQrVs2VKRkZF66623tG/fPq1cuVJjx44t9ziPx6ORI0fq6aef1o033ihJGj16tBISEvToo4/Wz18AAJ8jZgDUu1deeUW33XabBgwYoL59+yopKUndu3eXJF122WWaO3euPvroI1111VWaNm2aXn311XKPb9eunSZPnqwJEyaoTZs2evLJJxUQEKB58+Zpy5Yt6tq1q5566im98sor5R6Xmpoql8ulyZMne5cFBARozpw5WrlyJaebAEPxaSYAAGA0jswAAACjETMAAMBoxAwAADAaMQMAAIxGzAAAAKMRMwAAwGjEDAAAMBoxAwAAjEbMAAAAoxEzAADAaMQMAAAw2v8DUoKR12v5zD8AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_colorcodes.plot.scatter('dataX', 'dataY', c='color')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1. 0. 0. 1. ]\n", + " [0. 0.5 0. 1. ]\n", + " [0. 0. 1. 1. ]\n", + " [1. 0. 0. 1. ]]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_other.plot.scatter('dataX', 'dataY', c='color')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "949" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as mcolors\n", + "\n", + "len(mcolors.XKCD_COLORS)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(df_other.color)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pandas-dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 79721384295c1ffc5e3e459620b0893fbfe58364 Mon Sep 17 00:00:00 2001 From: Michael Vincent Mannino Date: Fri, 12 Jul 2024 23:29:22 -0400 Subject: [PATCH 07/11] remove temp file --- zzz.ipynb | 319 ------------------------------------------------------ 1 file changed, 319 deletions(-) delete mode 100644 zzz.ipynb diff --git a/zzz.ipynb b/zzz.ipynb deleted file mode 100644 index 162610119ee67..0000000000000 --- a/zzz.ipynb +++ /dev/null @@ -1,319 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "+ /Users/mmannino/miniforge3/envs/pandas-dev/bin/ninja\n", - "[1/1] Generating write_version_file with a custom command\n" - ] - } - ], - "source": [ - "import pandas as pd" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "+ /Users/mmannino/miniforge3/envs/pandas-dev/bin/ninja\n", - "[1/1] Generating write_version_file with a custom command\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import pandas as pd\n", - "import random as rand\n", - "\n", - "df = pd.DataFrame({\n", - " 'dataX': [rand.randint(0, 100) for _ in range(100)],\n", - " 'dataY': [rand.randint(0, 100) for _ in range(100)],\n", - " 'fav_fruit': [rand.choice(['Apples', 'Bananas', 'Grapes', 'Peaches']) for _ in range(100)],\n", - "})\n", - "df.plot.scatter('dataX', 'dataY', c='fav_fruit')" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "df_numericals = pd.DataFrame({'dataX': [3,79,90], 'dataY': [7,9,13], 'color': [0,.5,1]})\n", - "df_numtuples = pd.DataFrame({'dataX': [3,79,90], 'dataY': [7,9,13], 'color': [(.2,.2,.2),(.1,.2,.3),(.3,.2,.1)]})\n", - "df_colors = pd.DataFrame({'dataX': [3,79,90], 'dataY': [7,9,13], 'color': ['red','green','blue']})\n", - "df_colorcodes = pd.DataFrame({'dataX': [3,79,90], 'dataY': [7,9,13], 'color': ['r','g','b']})\n", - "df_other = pd.DataFrame({'dataX': [3,79,90, 120], 'dataY': [7,9,13, 5], 'color': ['t','q','f', 't']})" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "df_numericals.plot.scatter('dataX', 'dataY', c='color')" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "df_numtuples.plot.scatter('dataX', 'dataY', c='color')" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "df_colors.plot.scatter('dataX', 'dataY', c='color')" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "df_colorcodes.plot.scatter('dataX', 'dataY', c='color')" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[1. 0. 0. 1. ]\n", - " [0. 0.5 0. 1. ]\n", - " [0. 0. 1. 1. ]\n", - " [1. 0. 0. 1. ]]\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "df_other.plot.scatter('dataX', 'dataY', c='color')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "949" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "import matplotlib.colors as mcolors\n", - "\n", - "len(mcolors.XKCD_COLORS)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "4" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(df_other.color)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "pandas-dev", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.14" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 62427adef6be04e3f300255d2d016b6907aa3606 Mon Sep 17 00:00:00 2001 From: Michael Vincent Mannino Date: Thu, 29 Aug 2024 01:19:04 -0400 Subject: [PATCH 08/11] format --- pandas/plotting/_matplotlib/core.py | 94 +++++++++---------- .../tests/plotting/frame/test_frame_color.py | 37 ++++++-- 2 files changed, 76 insertions(+), 55 deletions(-) diff --git a/pandas/plotting/_matplotlib/core.py b/pandas/plotting/_matplotlib/core.py index ebdbeed200814..8717b70320c20 100644 --- a/pandas/plotting/_matplotlib/core.py +++ b/pandas/plotting/_matplotlib/core.py @@ -10,7 +10,6 @@ Iterator, Sequence, ) -from random import shuffle from typing import ( TYPE_CHECKING, Any, @@ -22,6 +21,10 @@ import matplotlib as mpl import numpy as np +from seaborn._base import ( + HueMapping, + VectorPlotter, +) from pandas._libs import lib from pandas.errors import AbstractMethodError @@ -1340,27 +1343,47 @@ def _make_plot(self, fig: Figure) -> None: norm, cmap = self._get_norm_and_cmap(c_values, color_by_categorical) cb = self._get_colorbar(c_values, c_is_column) - # if a list of non color strings is passed in as c, generate a list - # colored by uniqueness of the strings, such same strings get same color - create_colors = not self._are_valid_colors(c_values) - if create_colors: - custom_color_mapping, c_values = self._uniquely_color_strs(c_values) - cb = False # no colorbar; opt for legend - if self.legend: label = self.label else: label = None - scatter = ax.scatter( - data[x].values, - data[y].values, - c=c_values, - label=label, - cmap=cmap, - norm=norm, - s=self.s, - **self.kwds, - ) + + # if a list of non color strings is passed in as c, color points + # by uniqueness of the strings, such same strings get same color + create_colors = not self._are_valid_colors(c_values) + + # Plot as normal + if not create_colors: + scatter = ax.scatter( + data[x].values, + data[y].values, + c=c_values, + label=label, + cmap=cmap, + norm=norm, + s=self.s, + **self.kwds, + ) + # Have to custom color + else: + scatter = ax.scatter( + data[x].values, + data[y].values, + label=label, + cmap=cmap, + norm=norm, + s=self.s, + **self.kwds, + ) + + # set colors via Seaborn as it contains all the logic for handling color + # decision all nicely packaged + scatter.set_facecolor( + HueMapping( + VectorPlotter(data=data, variables={"x": x, "y": y, "hue": c}) + )(c_values) + ) + if cb: cbar_label = c if c_is_column else "" cbar = self._plot_colorbar(ax, fig=fig, label=cbar_label) @@ -1377,15 +1400,6 @@ def _make_plot(self, fig: Figure) -> None: label, # type: ignore[arg-type] ) - # build legend for labeling custom colors - if create_colors: - ax.legend( - handles=[ - mpl.patches.Circle((0, 0), facecolor=color, label=string) - for string, color in custom_color_mapping.items() - ] - ) - errors_x = self._get_errorbars(label=x, index=0, yerr=False) errors_y = self._get_errorbars(label=y, index=0, xerr=False) if len(errors_x) > 0 or len(errors_y) > 0: @@ -1409,38 +1423,20 @@ def _get_c_values(self, color, color_by_categorical: bool, c_is_column: bool): c_values = c return c_values - def _are_valid_colors(self, c_values: np.ndarray | list): + def _are_valid_colors(self, c_values: np.ndarray): # check if c_values contains strings and if these strings are valid mpl colors. # no need to check numerics as these (and mpl colors) will be validated for us # in .Axes.scatter._parse_scatter_color_args(...) + unique = np.unique(c_values) try: - if len(c_values) and all(isinstance(c, str) for c in c_values): - mpl.colors.to_rgba_array(c_values) + if len(c_values) and all(isinstance(c, str) for c in unique): + mpl.colors.to_rgba_array(unique) return True except (TypeError, ValueError) as _: return False - def _uniquely_color_strs( - self, c_values: np.ndarray | list - ) -> tuple[dict, np.ndarray]: - # well, almost uniquely color them (up to 949) - unique = np.unique(c_values) - - # for up to 7, lets keep colors consistent - if len(unique) <= 7: - possible_colors = list(mpl.colors.BASE_COLORS.values()) # Hex - # explore better ways to handle this case - else: - possible_colors = list(mpl.colors.XKCD_COLORS.values()) # Hex - shuffle(possible_colors) - - colors = [possible_colors[i % len(possible_colors)] for i in range(len(unique))] - color_mapping = dict(zip(unique, colors)) - - return color_mapping, np.array(list(map(color_mapping.get, c_values))) - def _get_norm_and_cmap(self, c_values, color_by_categorical: bool): c = self.c if self.colormap is not None: diff --git a/pandas/tests/plotting/frame/test_frame_color.py b/pandas/tests/plotting/frame/test_frame_color.py index 0b2a7a3c4b6ae..ae0bbf5b0ca45 100644 --- a/pandas/tests/plotting/frame/test_frame_color.py +++ b/pandas/tests/plotting/frame/test_frame_color.py @@ -217,22 +217,46 @@ def test_scatter_with_c_column_name_with_colors(self, cmap): ax = df.plot.scatter(x=0, y=1, cmap=cmap, c="species") else: ax = df.plot.scatter(x=0, y=1, c="species", cmap=cmap) + + assert len(np.unique(ax.collections[0].get_facecolor(), axis=0)) == 3 # r/g/b assert ax.collections[0].colorbar is None def test_scatter_with_c_column_name_without_colors(self): + # Given + colors = ["NY", "MD", "MA", "CA"] + color_count = 4 # 4 unique colors + + # When df = DataFrame( { "dataX": range(100), "dataY": range(100), - "state": ["NY", "MD", "MA", "CA"] * 25, + "color": (colors[i % len(colors)] for i in range(100)), } ) - df.plot.scatter("dataX", "dataY", c="state") - with tm.assert_produces_warning(None): - ax = df.plot.scatter(x=0, y=1, c="state") + # Then + ax = df.plot.scatter("dataX", "dataY", c="color") + assert len(np.unique(ax.collections[0].get_facecolor(), axis=0)) == color_count + + # Given + colors = ["r", "g", "not-a-color"] + color_count = 3 + # Also, since not all are mpl-colors, points matching 'r' or 'g' + # are not necessarily red or green + + # When + df = DataFrame( + { + "dataX": range(100), + "dataY": range(100), + "color": (colors[i % len(colors)] for i in range(100)), + } + ) - assert len(np.unique(ax.collections[0].get_facecolor())) == 4 # 4 states + # Then + ax = df.plot.scatter("dataX", "dataY", c="color") + assert len(np.unique(ax.collections[0].get_facecolor(), axis=0)) == color_count def test_scatter_colors(self): df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3]}) @@ -244,7 +268,8 @@ def test_scatter_colors_not_raising_warnings(self): # provided via 'c'. Parameters 'cmap' will be ignored df = DataFrame({"x": [1, 2, 3], "y": [1, 2, 3]}) with tm.assert_produces_warning(None): - df.plot.scatter(x="x", y="y", c="b") + ax = df.plot.scatter(x="x", y="y", c="b") + assert len(np.unique(ax.collections[0].get_facecolor(), axis=0)) == 1 # b def test_scatter_colors_default(self): df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3]}) From 6e868580565ac8414001ec7a3f6f6da031877ffe Mon Sep 17 00:00:00 2001 From: Michael Vincent Mannino Date: Fri, 30 Aug 2024 11:37:50 -0400 Subject: [PATCH 09/11] format --- pandas/plotting/_matplotlib/core.py | 66 ++++++++++++++--------------- 1 file changed, 31 insertions(+), 35 deletions(-) diff --git a/pandas/plotting/_matplotlib/core.py b/pandas/plotting/_matplotlib/core.py index 8717b70320c20..aaddd5f3615f9 100644 --- a/pandas/plotting/_matplotlib/core.py +++ b/pandas/plotting/_matplotlib/core.py @@ -21,10 +21,6 @@ import matplotlib as mpl import numpy as np -from seaborn._base import ( - HueMapping, - VectorPlotter, -) from pandas._libs import lib from pandas.errors import AbstractMethodError @@ -1351,38 +1347,28 @@ def _make_plot(self, fig: Figure) -> None: # if a list of non color strings is passed in as c, color points # by uniqueness of the strings, such same strings get same color create_colors = not self._are_valid_colors(c_values) - - # Plot as normal - if not create_colors: - scatter = ax.scatter( - data[x].values, - data[y].values, - c=c_values, - label=label, - cmap=cmap, - norm=norm, - s=self.s, - **self.kwds, - ) - # Have to custom color - else: - scatter = ax.scatter( - data[x].values, - data[y].values, - label=label, - cmap=cmap, - norm=norm, - s=self.s, - **self.kwds, + if create_colors: + color_mapping = self._get_color_mapping(c_values) + c_values = [color_mapping[s] for s in c_values] + + # build legend for labeling custom colors + ax.legend( + handles=[ + mpl.patches.Circle((0, 0), facecolor=c, label=s) + for s, c in color_mapping.items() + ] ) - # set colors via Seaborn as it contains all the logic for handling color - # decision all nicely packaged - scatter.set_facecolor( - HueMapping( - VectorPlotter(data=data, variables={"x": x, "y": y, "hue": c}) - )(c_values) - ) + scatter = ax.scatter( + data[x].values, + data[y].values, + c=c_values, + label=label, + cmap=cmap, + norm=norm, + s=self.s, + **self.kwds, + ) if cb: cbar_label = c if c_is_column else "" @@ -1423,7 +1409,7 @@ def _get_c_values(self, color, color_by_categorical: bool, c_is_column: bool): c_values = c return c_values - def _are_valid_colors(self, c_values: np.ndarray): + def _are_valid_colors(self, c_values: Series): # check if c_values contains strings and if these strings are valid mpl colors. # no need to check numerics as these (and mpl colors) will be validated for us # in .Axes.scatter._parse_scatter_color_args(...) @@ -1437,6 +1423,16 @@ def _are_valid_colors(self, c_values: np.ndarray): except (TypeError, ValueError) as _: return False + def _get_color_mapping(self, c_values: Series) -> dict[str, str]: + unique = np.unique(c_values) + n_colors = len(unique) + + # passing `None` here will default to :rc:`image.cmap` + cmap = mpl.colormaps.get_cmap(self.colormap) + colors = cmap(np.linspace(0, 1, n_colors)) # RGB tuples + + return dict(zip(unique, colors)) + def _get_norm_and_cmap(self, c_values, color_by_categorical: bool): c = self.c if self.colormap is not None: From 5223f2a659f6533e56ba99f0f6fd831b621df050 Mon Sep 17 00:00:00 2001 From: Michael Vincent Mannino Date: Fri, 30 Aug 2024 11:53:27 -0400 Subject: [PATCH 10/11] update tests --- pandas/tests/plotting/frame/test_frame_color.py | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/pandas/tests/plotting/frame/test_frame_color.py b/pandas/tests/plotting/frame/test_frame_color.py index ae0bbf5b0ca45..74ee45664e01a 100644 --- a/pandas/tests/plotting/frame/test_frame_color.py +++ b/pandas/tests/plotting/frame/test_frame_color.py @@ -219,6 +219,12 @@ def test_scatter_with_c_column_name_with_colors(self, cmap): ax = df.plot.scatter(x=0, y=1, c="species", cmap=cmap) assert len(np.unique(ax.collections[0].get_facecolor(), axis=0)) == 3 # r/g/b + assert ( + np.unique(ax.collections[0].get_facecolor(), axis=0) + == np.array( + [[0.0, 0.0, 1.0, 1.0], [0.0, 0.5, 0.0, 1.0], [1.0, 0.0, 0.0, 1.0]] + ) # r/g/b + ).all() assert ax.collections[0].colorbar is None def test_scatter_with_c_column_name_without_colors(self): @@ -269,7 +275,13 @@ def test_scatter_colors_not_raising_warnings(self): df = DataFrame({"x": [1, 2, 3], "y": [1, 2, 3]}) with tm.assert_produces_warning(None): ax = df.plot.scatter(x="x", y="y", c="b") - assert len(np.unique(ax.collections[0].get_facecolor(), axis=0)) == 1 # b + assert ( + len(np.unique(ax.collections[0].get_facecolor(), axis=0)) == 1 + ) # blue + assert ( + np.unique(ax.collections[0].get_facecolor(), axis=0) + == np.array([[0.0, 0.0, 1.0, 1.0]]) + ).all() # blue def test_scatter_colors_default(self): df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3], "c": [1, 2, 3]}) From 7e5a02a40998541ddb9743a64755c14f422ab419 Mon Sep 17 00:00:00 2001 From: Michael Vincent Mannino Date: Fri, 30 Aug 2024 12:09:27 -0400 Subject: [PATCH 11/11] update return types --- pandas/plotting/_matplotlib/core.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pandas/plotting/_matplotlib/core.py b/pandas/plotting/_matplotlib/core.py index aaddd5f3615f9..505db4b807cfc 100644 --- a/pandas/plotting/_matplotlib/core.py +++ b/pandas/plotting/_matplotlib/core.py @@ -1409,7 +1409,7 @@ def _get_c_values(self, color, color_by_categorical: bool, c_is_column: bool): c_values = c return c_values - def _are_valid_colors(self, c_values: Series): + def _are_valid_colors(self, c_values: Series) -> bool: # check if c_values contains strings and if these strings are valid mpl colors. # no need to check numerics as these (and mpl colors) will be validated for us # in .Axes.scatter._parse_scatter_color_args(...) @@ -1423,7 +1423,7 @@ def _are_valid_colors(self, c_values: Series): except (TypeError, ValueError) as _: return False - def _get_color_mapping(self, c_values: Series) -> dict[str, str]: + def _get_color_mapping(self, c_values: Series) -> dict[str, np.ndarray]: unique = np.unique(c_values) n_colors = len(unique)