From 27ac391f04dd66ec4a5112e192e5a365b060ee1e Mon Sep 17 00:00:00 2001 From: FrejaTerpPetersen Date: Tue, 5 Nov 2024 14:06:36 +0100 Subject: [PATCH 01/16] Style argument to timeseries plot --- modelskill/comparison/_comparer_plotter.py | 1 + 1 file changed, 1 insertion(+) diff --git a/modelskill/comparison/_comparer_plotter.py b/modelskill/comparison/_comparer_plotter.py index bafb8346..567c7417 100644 --- a/modelskill/comparison/_comparer_plotter.py +++ b/modelskill/comparison/_comparer_plotter.py @@ -62,6 +62,7 @@ def timeseries( ax=None, figsize: Tuple[float, float] | None = None, backend: str = "matplotlib", + style: list | None = None, **kwargs, ): """Timeseries plot showing compared data: observation vs modelled From c97268330808e68cc3e195df86ae1c67c804baeb Mon Sep 17 00:00:00 2001 From: FrejaTerpPetersen Date: Tue, 5 Nov 2024 14:12:43 +0100 Subject: [PATCH 02/16] first value is obs style --- modelskill/comparison/_comparer_plotter.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/modelskill/comparison/_comparer_plotter.py b/modelskill/comparison/_comparer_plotter.py index 567c7417..49d5ca2e 100644 --- a/modelskill/comparison/_comparer_plotter.py +++ b/modelskill/comparison/_comparer_plotter.py @@ -62,7 +62,7 @@ def timeseries( ax=None, figsize: Tuple[float, float] | None = None, backend: str = "matplotlib", - style: list | None = None, + style: list[str] | None = None, **kwargs, ): """Timeseries plot showing compared data: observation vs modelled @@ -80,6 +80,10 @@ def timeseries( backend : str, optional use "plotly" (interactive) or "matplotlib" backend, by default "matplotlib" + style: list of str, optional + containing line styles of the model results, if len(style) = num_models. + If len(style) = num_models + 1, the first argument will be used for the observations. + by default None **kwargs other keyword arguments to fig.update_layout (plotly backend) @@ -94,6 +98,10 @@ def timeseries( if title is None: title = cmp.name + if style is not None and len(style) > cmp.n_models: + obs_style = style[0] + style = style[1:] + if backend == "matplotlib": fig, ax = _get_fig_ax(ax, figsize) for j in range(cmp.n_models): From 36191907b6d10b2ab9e9a347f8533a7fc42a524e Mon Sep 17 00:00:00 2001 From: FrejaTerpPetersen Date: Tue, 5 Nov 2024 14:47:01 +0100 Subject: [PATCH 03/16] Added color argument --- modelskill/comparison/_comparer_plotter.py | 41 +++++++++++++++++----- 1 file changed, 32 insertions(+), 9 deletions(-) diff --git a/modelskill/comparison/_comparer_plotter.py b/modelskill/comparison/_comparer_plotter.py index 49d5ca2e..dd843c35 100644 --- a/modelskill/comparison/_comparer_plotter.py +++ b/modelskill/comparison/_comparer_plotter.py @@ -21,6 +21,7 @@ from .. import metrics as mtr from ..utils import _get_idx import matplotlib.colors as colors +from pandas.plotting._matplotlib.core import _color_in_style from ..plotting._misc import ( _get_fig_ax, _xtick_directional, @@ -62,7 +63,8 @@ def timeseries( ax=None, figsize: Tuple[float, float] | None = None, backend: str = "matplotlib", - style: list[str] | None = None, + style: list[str] | str | None = None, + color: list[str] | str | None = None, **kwargs, ): """Timeseries plot showing compared data: observation vs modelled @@ -81,8 +83,11 @@ def timeseries( use "plotly" (interactive) or "matplotlib" backend, by default "matplotlib" style: list of str, optional - containing line styles of the model results, if len(style) = num_models. - If len(style) = num_models + 1, the first argument will be used for the observations. + containing line styles of the model results. + by default None + color: list of str, optional + containing colors of the model results if len(colors) == num_models. + If len(colors) == num_models + 1, the first color will be used for the observations. by default None **kwargs other keyword arguments to fig.update_layout (plotly backend) @@ -91,29 +96,47 @@ def timeseries( ------- matplotlib.axes.Axes or plotly.graph_objects.Figure """ - from ._comparison import MOD_COLORS + if style is None and color is None: + from ._comparison import MOD_COLORS + + color = MOD_COLORS + + if not isinstance(style, list): + style = [style] + if isinstance(color, str) or color is None: + color = [color] cmp = self.comparer if title is None: title = cmp.name - if style is not None and len(style) > cmp.n_models: - obs_style = style[0] - style = style[1:] + if len(color) > cmp.n_models: + obs_color = color[0] + color = color[1:] + elif len(style) < cmp.n_models: + raise ValueError( + "Number of styles in 'style' argument does not match the number of models in the comparer." + ) + elif len(color) < cmp.n_models: + raise ValueError( + "Number of colors in 'color' argument does not match the number of models in the comparer." + ) + else: + obs_color = cmp.data[cmp._obs_name].attrs["color"] if backend == "matplotlib": fig, ax = _get_fig_ax(ax, figsize) for j in range(cmp.n_models): key = cmp.mod_names[j] mod = cmp.raw_mod_data[key]._values_as_series - mod.plot(ax=ax, color=MOD_COLORS[j]) + mod.plot(ax=ax, style=style[j], color=color[j]) ax.scatter( cmp.time, cmp.data[cmp._obs_name].values, marker=".", - color=cmp.data[cmp._obs_name].attrs["color"], + color=obs_color, ) ax.set_ylabel(cmp._unit_text) ax.legend([*cmp.mod_names, cmp._obs_name]) From 72d3210649e2cb86b913768b45f4c6156d1b6d31 Mon Sep 17 00:00:00 2001 From: FrejaTerpPetersen Date: Wed, 6 Nov 2024 12:36:09 +0100 Subject: [PATCH 04/16] Created function for checking inputs --- modelskill/comparison/_comparer_plotter.py | 26 ++++++--------- modelskill/plotting/_misc.py | 21 ++++++++++++ tests/test_comparer.py | 37 ++++++++++++++++++++++ 3 files changed, 67 insertions(+), 17 deletions(-) diff --git a/modelskill/comparison/_comparer_plotter.py b/modelskill/comparison/_comparer_plotter.py index dd843c35..a355221a 100644 --- a/modelskill/comparison/_comparer_plotter.py +++ b/modelskill/comparison/_comparer_plotter.py @@ -27,6 +27,7 @@ _xtick_directional, _ytick_directional, quantiles_xy, + _check_kwarg_and_convert_to_list, ) from ..plotting import taylor_diagram, scatter, TaylorPoint from ..settings import options @@ -96,33 +97,24 @@ def timeseries( ------- matplotlib.axes.Axes or plotly.graph_objects.Figure """ - if style is None and color is None: - from ._comparison import MOD_COLORS - color = MOD_COLORS + cmp = self.comparer - if not isinstance(style, list): - style = [style] - if isinstance(color, str) or color is None: - color = [color] + if style is None and color is None: # Use default values + from ._comparison import MOD_COLORS - cmp = self.comparer + color = MOD_COLORS if title is None: title = cmp.name + color, style = _check_kwarg_and_convert_to_list(color, style, cmp.n_models) + if len(color) > cmp.n_models: + # If more colors than n_models is given, the first color is used for the observations obs_color = color[0] color = color[1:] - elif len(style) < cmp.n_models: - raise ValueError( - "Number of styles in 'style' argument does not match the number of models in the comparer." - ) - elif len(color) < cmp.n_models: - raise ValueError( - "Number of colors in 'color' argument does not match the number of models in the comparer." - ) - else: + else: # use default value for observations obs_color = cmp.data[cmp._obs_name].attrs["color"] if backend == "matplotlib": diff --git a/modelskill/plotting/_misc.py b/modelskill/plotting/_misc.py index 66f985e0..b1bbe7b5 100644 --- a/modelskill/plotting/_misc.py +++ b/modelskill/plotting/_misc.py @@ -184,3 +184,24 @@ def _format_skill_line( name = name.upper() return f"{name}", " = ", f"{fvalue} {item_unit}" + + +def _check_kwarg_and_convert_to_list(color, style, n_mod): + if not isinstance(style, list): + # If style is str or None, convert to list (for looping) + style = [style] * n_mod + if isinstance(color, str) or color is None: + # Same with color + color = [color] * n_mod + + if len(color) < n_mod: # too few colors given? + raise ValueError( + "Number of colors in 'color' argument does not match the number of models in the comparer." + ) + + if len(style) < n_mod and style[0] is not None: # too few styles given? + raise ValueError( + "Number of styles in 'style' argument does not match the number of models in the comparer." + ) + + return color, style diff --git a/tests/test_comparer.py b/tests/test_comparer.py index 08b50a71..734fc03f 100644 --- a/tests/test_comparer.py +++ b/tests/test_comparer.py @@ -887,3 +887,40 @@ def test_from_matched_dfs0(): assert float( gs.data.sel(x=-0.01, y=55.1, method="nearest").rmse.values ) == pytest.approx(0.0476569069177831) + + +def test_timeseriesplot_accepts_style_input(pc): + ax = pc.plot.timeseries(color=["red", "blue"]) + with pytest.raises( + ValueError, match="'style' string with a color symbol and 'color'" + ): + ax = pc.plot.timeseries(color=["red", "blue"], style="b-") + ax = pc.plot.timeseries(color=["red"]) + plt.show() + print("Hello") + + +# ---------- + + +def pc2() -> Comparer: + """A comparer with fake point data""" + x, y = 10.0, 55.0 + df = _get_track_df().drop(columns=["x", "y"]) + + data = df.to_xarray() + data.attrs["gtype"] = "point" + data.attrs["name"] = "fake point obs" + data.coords["x"] = x + data.coords["y"] = y + data.coords["z"] = np.nan + data = _set_attrs(data) + + raw_data = {"m1": data[["m1"]], "m2": data[["m2"]]} + + data = data.dropna(dim="time") + + return Comparer(matched_data=data, raw_mod_data=raw_data) + + +test_timeseriesplot_accepts_style_input(pc2()) From dfef139eae9b23283e10dcb31367c694be4c47ea Mon Sep 17 00:00:00 2001 From: FrejaTerpPetersen Date: Wed, 6 Nov 2024 13:12:12 +0100 Subject: [PATCH 05/16] Decided to only allow color OR style input --- modelskill/comparison/_comparer_plotter.py | 29 ++++++++++++++-------- modelskill/plotting/_misc.py | 12 +++++---- tests/test_comparer.py | 13 +++++----- 3 files changed, 33 insertions(+), 21 deletions(-) diff --git a/modelskill/comparison/_comparer_plotter.py b/modelskill/comparison/_comparer_plotter.py index a355221a..36c29c2a 100644 --- a/modelskill/comparison/_comparer_plotter.py +++ b/modelskill/comparison/_comparer_plotter.py @@ -100,29 +100,38 @@ def timeseries( cmp = self.comparer - if style is None and color is None: # Use default values - from ._comparison import MOD_COLORS - - color = MOD_COLORS - if title is None: title = cmp.name + if color is not None and style is not None: + raise ValueError( + "It is not possible to pass both the color argument and the style argument. Choose one." + ) + + # Color for observations: + obs_color = cmp.data[cmp._obs_name].attrs["color"] + + if color is None and style is None: # Use default values for colors + from ._comparison import MOD_COLORS + + color = MOD_COLORS[: cmp.n_models] + color, style = _check_kwarg_and_convert_to_list(color, style, cmp.n_models) - if len(color) > cmp.n_models: - # If more colors than n_models is given, the first color is used for the observations + if color is not None and len(color) > cmp.n_models: + # If more than n_models colors is given, the first color is used for the observations obs_color = color[0] color = color[1:] - else: # use default value for observations - obs_color = cmp.data[cmp._obs_name].attrs["color"] if backend == "matplotlib": fig, ax = _get_fig_ax(ax, figsize) for j in range(cmp.n_models): key = cmp.mod_names[j] mod = cmp.raw_mod_data[key]._values_as_series - mod.plot(ax=ax, style=style[j], color=color[j]) + if style is not None: + mod.plot(ax=ax, style=style[j]) + else: + mod.plot(ax=ax, color=color[j]) ax.scatter( cmp.time, diff --git a/modelskill/plotting/_misc.py b/modelskill/plotting/_misc.py index b1bbe7b5..664e27ad 100644 --- a/modelskill/plotting/_misc.py +++ b/modelskill/plotting/_misc.py @@ -187,19 +187,21 @@ def _format_skill_line( def _check_kwarg_and_convert_to_list(color, style, n_mod): - if not isinstance(style, list): - # If style is str or None, convert to list (for looping) + if isinstance(style, str): + # If style is str, convert to list (for looping) style = [style] * n_mod - if isinstance(color, str) or color is None: + if isinstance(color, str): # Same with color color = [color] * n_mod - if len(color) < n_mod: # too few colors given? + if color is not None and len(color) < n_mod: # too few colors given? raise ValueError( "Number of colors in 'color' argument does not match the number of models in the comparer." ) - if len(style) < n_mod and style[0] is not None: # too few styles given? + if ( + style is not None and len(style) < n_mod and style[0] is not None + ): # too few styles given? raise ValueError( "Number of styles in 'style' argument does not match the number of models in the comparer." ) diff --git a/tests/test_comparer.py b/tests/test_comparer.py index 734fc03f..4a45a6da 100644 --- a/tests/test_comparer.py +++ b/tests/test_comparer.py @@ -889,14 +889,15 @@ def test_from_matched_dfs0(): ) == pytest.approx(0.0476569069177831) -def test_timeseriesplot_accepts_style_input(pc): +def test_timeseriesplot_accepts_style_color_input(pc): ax = pc.plot.timeseries(color=["red", "blue"]) - with pytest.raises( - ValueError, match="'style' string with a color symbol and 'color'" - ): - ax = pc.plot.timeseries(color=["red", "blue"], style="b-") - ax = pc.plot.timeseries(color=["red"]) plt.show() + ax = pc.plot.timeseries(style=["b-", "g--"]) + plt.show() + with pytest.raises(ValueError, match="Choose one"): + ax = pc.plot.timeseries(color=["red", "blue"], style="b-") + # ax = pc.plot.timeseries(color=["red"]) + print("Hello") From a68fcfd40e58be0bfe3ae3e5be885e5b20800762 Mon Sep 17 00:00:00 2001 From: FrejaTerpPetersen Date: Wed, 6 Nov 2024 13:29:11 +0100 Subject: [PATCH 06/16] Wrote tests --- tests/test_comparer.py | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/tests/test_comparer.py b/tests/test_comparer.py index 4a45a6da..aea53752 100644 --- a/tests/test_comparer.py +++ b/tests/test_comparer.py @@ -890,14 +890,23 @@ def test_from_matched_dfs0(): def test_timeseriesplot_accepts_style_color_input(pc): + # Check that it can take the inputs ax = pc.plot.timeseries(color=["red", "blue"]) - plt.show() ax = pc.plot.timeseries(style=["b-", "g--"]) - plt.show() + assert ax.lines[1].get_color() == "g" + + # Check that errors are raised with pytest.raises(ValueError, match="Choose one"): ax = pc.plot.timeseries(color=["red", "blue"], style="b-") - # ax = pc.plot.timeseries(color=["red"]) - + with pytest.raises(ValueError, match="'color' argument"): + ax = pc.plot.timeseries(color=["red"]) + with pytest.raises(ValueError, match="'style' argument"): + ax = pc.plot.timeseries(style=["b-"]) + + ax = pc.plot.timeseries(color=["red", "blue", "black"]) + # first line is blue (red is for observations). + assert ax.lines[0].get_color() == "blue" + plt.show() print("Hello") @@ -924,4 +933,4 @@ def pc2() -> Comparer: return Comparer(matched_data=data, raw_mod_data=raw_data) -test_timeseriesplot_accepts_style_input(pc2()) +test_timeseriesplot_accepts_style_color_input(pc2()) From 320563d36d857de75838db365ae5ed160a5fd4d0 Mon Sep 17 00:00:00 2001 From: FrejaTerpPetersen Date: Wed, 6 Nov 2024 13:29:42 +0100 Subject: [PATCH 07/16] Deleted test call --- tests/test_comparer.py | 26 -------------------------- 1 file changed, 26 deletions(-) diff --git a/tests/test_comparer.py b/tests/test_comparer.py index aea53752..47af957b 100644 --- a/tests/test_comparer.py +++ b/tests/test_comparer.py @@ -908,29 +908,3 @@ def test_timeseriesplot_accepts_style_color_input(pc): assert ax.lines[0].get_color() == "blue" plt.show() print("Hello") - - -# ---------- - - -def pc2() -> Comparer: - """A comparer with fake point data""" - x, y = 10.0, 55.0 - df = _get_track_df().drop(columns=["x", "y"]) - - data = df.to_xarray() - data.attrs["gtype"] = "point" - data.attrs["name"] = "fake point obs" - data.coords["x"] = x - data.coords["y"] = y - data.coords["z"] = np.nan - data = _set_attrs(data) - - raw_data = {"m1": data[["m1"]], "m2": data[["m2"]]} - - data = data.dropna(dim="time") - - return Comparer(matched_data=data, raw_mod_data=raw_data) - - -test_timeseriesplot_accepts_style_color_input(pc2()) From d55b4c75067c104138f2286798f26f3d6e088022 Mon Sep 17 00:00:00 2001 From: FrejaTerpPetersen Date: Wed, 6 Nov 2024 13:31:17 +0100 Subject: [PATCH 08/16] docstring update --- modelskill/comparison/_comparer_plotter.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/modelskill/comparison/_comparer_plotter.py b/modelskill/comparison/_comparer_plotter.py index 36c29c2a..0abf17ca 100644 --- a/modelskill/comparison/_comparer_plotter.py +++ b/modelskill/comparison/_comparer_plotter.py @@ -84,11 +84,12 @@ def timeseries( use "plotly" (interactive) or "matplotlib" backend, by default "matplotlib" style: list of str, optional - containing line styles of the model results. + containing line styles of the model results. Cannot be passed together with color input. by default None color: list of str, optional - containing colors of the model results if len(colors) == num_models. + containing colors of the model results. If len(colors) == num_models + 1, the first color will be used for the observations. + Cannot be passed together with style input. by default None **kwargs other keyword arguments to fig.update_layout (plotly backend) From d2d57e3239ffdf84536cf3329a592e9b70422ba7 Mon Sep 17 00:00:00 2001 From: FrejaTerpPetersen Date: Wed, 6 Nov 2024 13:34:10 +0100 Subject: [PATCH 09/16] Design decision --- modelskill/plotting/_misc.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/modelskill/plotting/_misc.py b/modelskill/plotting/_misc.py index 664e27ad..008a2d4f 100644 --- a/modelskill/plotting/_misc.py +++ b/modelskill/plotting/_misc.py @@ -189,10 +189,10 @@ def _format_skill_line( def _check_kwarg_and_convert_to_list(color, style, n_mod): if isinstance(style, str): # If style is str, convert to list (for looping) - style = [style] * n_mod + style = [style] if isinstance(color, str): # Same with color - color = [color] * n_mod + color = [color] if color is not None and len(color) < n_mod: # too few colors given? raise ValueError( From 44467096586f447ee5cd0fb76011f7943c798f4f Mon Sep 17 00:00:00 2001 From: FrejaTerpPetersen Date: Wed, 6 Nov 2024 13:41:27 +0100 Subject: [PATCH 10/16] Removed unused import --- modelskill/comparison/_comparer_plotter.py | 1 - 1 file changed, 1 deletion(-) diff --git a/modelskill/comparison/_comparer_plotter.py b/modelskill/comparison/_comparer_plotter.py index 0abf17ca..f2646c9f 100644 --- a/modelskill/comparison/_comparer_plotter.py +++ b/modelskill/comparison/_comparer_plotter.py @@ -21,7 +21,6 @@ from .. import metrics as mtr from ..utils import _get_idx import matplotlib.colors as colors -from pandas.plotting._matplotlib.core import _color_in_style from ..plotting._misc import ( _get_fig_ax, _xtick_directional, From 3a1fcbad08b3a8b34535d019324c05816040e990 Mon Sep 17 00:00:00 2001 From: FrejaTerpPetersen Date: Wed, 6 Nov 2024 13:57:14 +0100 Subject: [PATCH 11/16] Fix type error: color was not subscriptable if None --- modelskill/comparison/_comparer_plotter.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/modelskill/comparison/_comparer_plotter.py b/modelskill/comparison/_comparer_plotter.py index f2646c9f..9dd7ea06 100644 --- a/modelskill/comparison/_comparer_plotter.py +++ b/modelskill/comparison/_comparer_plotter.py @@ -122,6 +122,8 @@ def timeseries( # If more than n_models colors is given, the first color is used for the observations obs_color = color[0] color = color[1:] + elif color is None: + color = [color] if backend == "matplotlib": fig, ax = _get_fig_ax(ax, figsize) From 0f57302c4e372ad66f7e9d06c0fd2fe8d20fed66 Mon Sep 17 00:00:00 2001 From: FrejaTerpPetersen Date: Wed, 6 Nov 2024 14:02:57 +0100 Subject: [PATCH 12/16] Wrong type error ... Moved default coloring --- modelskill/comparison/_comparer_plotter.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/modelskill/comparison/_comparer_plotter.py b/modelskill/comparison/_comparer_plotter.py index 9dd7ea06..8141404a 100644 --- a/modelskill/comparison/_comparer_plotter.py +++ b/modelskill/comparison/_comparer_plotter.py @@ -111,10 +111,10 @@ def timeseries( # Color for observations: obs_color = cmp.data[cmp._obs_name].attrs["color"] - if color is None and style is None: # Use default values for colors - from ._comparison import MOD_COLORS + # if color is None and style is None: # Use default values for colors + # from ._comparison import MOD_COLORS - color = MOD_COLORS[: cmp.n_models] + # color = MOD_COLORS[: cmp.n_models] color, style = _check_kwarg_and_convert_to_list(color, style, cmp.n_models) @@ -122,8 +122,6 @@ def timeseries( # If more than n_models colors is given, the first color is used for the observations obs_color = color[0] color = color[1:] - elif color is None: - color = [color] if backend == "matplotlib": fig, ax = _get_fig_ax(ax, figsize) @@ -133,6 +131,8 @@ def timeseries( if style is not None: mod.plot(ax=ax, style=style[j]) else: + if color is None: + color = MOD_COLORS mod.plot(ax=ax, color=color[j]) ax.scatter( From 1a70efb7182f8d84e46208d23e085a361fd8a68c Mon Sep 17 00:00:00 2001 From: FrejaTerpPetersen Date: Wed, 6 Nov 2024 14:03:58 +0100 Subject: [PATCH 13/16] Import default colors --- modelskill/comparison/_comparer_plotter.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/modelskill/comparison/_comparer_plotter.py b/modelskill/comparison/_comparer_plotter.py index 8141404a..c9ec66a5 100644 --- a/modelskill/comparison/_comparer_plotter.py +++ b/modelskill/comparison/_comparer_plotter.py @@ -132,6 +132,8 @@ def timeseries( mod.plot(ax=ax, style=style[j]) else: if color is None: + from ._comparison import MOD_COLORS + color = MOD_COLORS mod.plot(ax=ax, color=color[j]) From 13a71638dd4693c984d46fae98482e991516a2c2 Mon Sep 17 00:00:00 2001 From: FrejaTerpPetersen Date: Wed, 6 Nov 2024 14:06:56 +0100 Subject: [PATCH 14/16] Allow color to be tuple --- modelskill/comparison/_comparer_plotter.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modelskill/comparison/_comparer_plotter.py b/modelskill/comparison/_comparer_plotter.py index c9ec66a5..e06b7516 100644 --- a/modelskill/comparison/_comparer_plotter.py +++ b/modelskill/comparison/_comparer_plotter.py @@ -64,7 +64,7 @@ def timeseries( figsize: Tuple[float, float] | None = None, backend: str = "matplotlib", style: list[str] | str | None = None, - color: list[str] | str | None = None, + color: list[str] | tuple | str | None = None, **kwargs, ): """Timeseries plot showing compared data: observation vs modelled From 3f941aa648b56a19275c51e8dc954d9d9acb28aa Mon Sep 17 00:00:00 2001 From: FrejaTerpPetersen Date: Wed, 6 Nov 2024 14:11:48 +0100 Subject: [PATCH 15/16] Moved import outside plot code --- modelskill/comparison/_comparer_plotter.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/modelskill/comparison/_comparer_plotter.py b/modelskill/comparison/_comparer_plotter.py index e06b7516..689674b4 100644 --- a/modelskill/comparison/_comparer_plotter.py +++ b/modelskill/comparison/_comparer_plotter.py @@ -98,6 +98,8 @@ def timeseries( matplotlib.axes.Axes or plotly.graph_objects.Figure """ + from ._comparison import MOD_COLORS + cmp = self.comparer if title is None: @@ -132,8 +134,6 @@ def timeseries( mod.plot(ax=ax, style=style[j]) else: if color is None: - from ._comparison import MOD_COLORS - color = MOD_COLORS mod.plot(ax=ax, color=color[j]) From 5cf2d03f71dbdcb032bff991595edcbce5bdcba6 Mon Sep 17 00:00:00 2001 From: Jesper Sandvig Mariegaard <34088801+jsmariegaard@users.noreply.github.com> Date: Wed, 20 Nov 2024 07:47:10 +0000 Subject: [PATCH 16/16] Example notebook with timeseries plotting --- notebooks/Plotting_timeseries.ipynb | 137 ++++++++++++++++++++++++++++ 1 file changed, 137 insertions(+) create mode 100644 notebooks/Plotting_timeseries.ipynb diff --git a/notebooks/Plotting_timeseries.ipynb b/notebooks/Plotting_timeseries.ipynb new file mode 100644 index 00000000..333f41ba --- /dev/null +++ b/notebooks/Plotting_timeseries.ipynb @@ -0,0 +1,137 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plotting timeseries\n", + "\n", + "The focus for this notebook is to show options for plotting matched data as timeseries using the Comparer object. \n", + "\n", + "Observation and ModelResults can also be plotted as timeseries with similar syntax but this is not covered in this notebook. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import modelskill as ms" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(\"../tests/testdata/matched_data.csv\", index_col='datetime', parse_dates=True)\n", + "cmp = ms.from_matched(df.loc[\"2019-01-01\"], obs_item='Station X')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Default time series plot " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHnCAYAAABE/nwcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3wb9f3/n6fT9JRkO96x4ziJs8MmrITRhl0olLbQQlrKLLSFUijfMkr5UbqgrBZKC6RllNFSyqZAAxQIYYYEsp3YzvCWbFmSte/3x93JsuMkHloOn+fj4Uds6XT6SJHu3vd+v97vl6QoioJAIBAIBALBPoIh0wsQCAQCgUAgSCYiuBEIBAKBQLBPIYIbgUAgEAgE+xQiuBEIBAKBQLBPIYIbgUAgEAgE+xQiuBEIBAKBQLBPIYIbgUAgEAgE+xQiuBEIBAKBQLBPIYIbgUAgEAgE+xQiuBEIBPsEixcvZvHixZlehkAgyAJEcCMQCMbNmjVrOPPMM6mpqcFqtVJZWcmXvvQl7r777kHb/fKXv+SZZ54Z8/OsXbuWn//85zQ1NY1vwUnkuuuuQ5Ik3njjjV3ue/zxx5EkiXvuuSf9CxMIvsBIwltKIBCMh3fffZejjz6ayZMnc95551FWVsa2bdt47733aGxsZPPmzfFt8/LyOPPMM1m2bNmYnusf//gHX/va11i+fPkuWZpQKASA2Wwe60sZE4FAgDlz5mA0Glm9enX8+Xt6epg5cybV1dW89957GAziWlIgSBfGTC9AIBBMbG655RYKCwv54IMPsNvtg+7r6OhI2zrSHdToWK1W7r33Xr785S9z6623cuONNwLw05/+lM7OTl566SUR2AgEaUZ84wQCwbhobGxk9uzZuwQ2AJMmTYr/LkkSPp+Pv/71r0iShCRJLF26FIDm5mYuvfRSZsyYgc1mo6ioiK997WuDyk/Lli3ja1/7GgBHH310fB96OWg4zU1HRwfnn38+paWlWK1W5s+fz1//+tdB2zQ1NSFJEr/73e+4//77mTp1KhaLhYMOOogPPvhgRO/Bl770Jc4++2xuvfVWNm7cyIoVK7j//vv54Q9/yIIFC0a0D4FAkDxE5kYgEIyLmpoaVqxYwWeffcacOXN2u93DDz/M9773PQ4++GAuvPBCAKZOnQrABx98wLvvvss3vvENqqqqaGpq4t5772Xx4sWsXbuWnJwcjjrqKH7wgx9w11138X//93/MnDkTIP7vUPr7+1m8eDGbN2/msssuY8qUKTz11FMsXbqUnp4efvjDHw7a/rHHHqOvr4+LLroISZL4zW9+w1e/+lW2bNmCyWTa6/tw++2389JLL3HRRRfR3d1NVVUVN91004jeQ4FAkGQUgUAgGAf/+c9/FFmWFVmWlYULFypXX3218sorryihUGiXbXNzc5Xzzjtvl9v9fv8ut61YsUIBlL/97W/x25566ikFUJYvX77L9osWLVIWLVoU//uOO+5QAOWRRx6J3xYKhZSFCxcqeXl5isfjURRFUbZu3aoASlFRkeJyueLb/vvf/1YA5bnnnhvJ26AoiqL86U9/UgAFUJ555pkRP04gECQXUZYSCATj4ktf+hIrVqzg1FNP5dNPP+U3v/kNS5YsobKykmeffXZE+7DZbPHfw+Ew3d3d1NfXY7fb+fjjj8e0rhdffJGysjK++c1vxm8zmUz84Ac/wOv18uabbw7a/utf/zoOhyP+95FHHgnAli1bRvycxcXFAOTk5HDEEUeMad0CgWD8iOBGIBCMm4MOOoinn34at9vN+++/z7XXXktfXx9nnnkma9eu3evj+/v7ueGGG6iursZisVBcXExJSQk9PT309vaOaU3Nzc1MmzZtFzGvXsZqbm4edPvkyZMH/a0HOm63e0TP19fXxw9+8ANmzJhBKBTimmuuGdO6BQLB+BHBjUAgSBpms5mDDjqIX/7yl9x7772Ew2GeeuqpvT7u8ssv55ZbbuGss87iySef5D//+Q+vvvoqRUVFxGKxNKwcZFke9nZlhNMyfvazn9HW1sZjjz3GFVdcwYMPPsg777yTzCUKBIIRIgTFAoEgJRx44IEAtLa2xm+TJGnYbf/xj39w3nnncdttt8VvCwQC9PT0DNpud48fjpqaGlavXk0sFhuUvVm/fn38/mTx4Ycf8oc//IHLL7+c/fffnxkzZvDEE09w8cUX88knn2A0ikOtQJBOROZGIBCMi+XLlw+b3XjxxRcBmDFjRvy23NzcXQIWULMmQ/dx9913E41GB92Wm5sLMOw+hnLiiSfS1tbGE088Eb8tEolw9913k5eXx6JFi/a6j5EQjUa56KKLKC8v5+abb46v8+677+azzz7j97//fVKeRyAQjBxxOSEQCMbF5Zdfjt/v5/TTT6ehoYFQKMS7777LE088QW1tLd/5znfi2x5wwAG89tpr3H777VRUVDBlyhQOOeQQTj75ZB5++GEKCwuZNWsWK1as4LXXXqOoqGjQcy1YsABZlvn1r39Nb28vFouFY445ZtA8HZ0LL7yQP/3pTyxdupSPPvqI2tpa/vGPf/DOO+9wxx13kJ+fn5TXf9ddd/Hxxx/zz3/+c9A+Tz31VE499VRuuukmvv71r++i6REIBCkkw91aAoFggvPSSy8p3/3ud5WGhgYlLy9PMZvNSn19vXL55Zcr7e3tg7Zdv369ctRRRyk2m00B4m3hbrdb+c53vqMUFxcreXl5ypIlS5T169crNTU1u7SO//nPf1bq6uoUWZYHtYUPbQVXFEVpb2+P79dsNitz585VHnrooUHb6K3gv/3tb3d5bYBy44037va1b9u2TcnLy1NOPvnkYe9vbm5WcnNzlVNPPXW3+xAIBMlHeEsJBAKBQCDYpxCaG4FAIBAIBPsUIrgRCAQCgUCwTyGCG4FAIBAIBPsUIrgRCAQCgUCwTyGCG4FAIBAIBPsUIrgRCAQCgUCwT/GFG+IXi8XYuXMn+fn5oxrlLhAIBAKBIHMoikJfXx8VFRW7GOIO5QsX3OzcuZPq6upML0MgEAgEAsEY2LZtG1VVVXvc5gsX3Ojj0bdt20ZBQUGGVyMQCAQCgWAkeDweqqurR2Sd8oULbvRSVEFBgQhuBAKBQCCYYIxEUiIExQKBQCAQCPYpRHAjEAgEAoFgn0IENwKBQCAQCPYpvnCaG4EgEyiKQiQSIRqNZnopAkHSkGUZo9EoxmoIsg4R3AgEKSYUCtHa2orf78/0UgSCpJOTk0N5eTlmsznTSxEI4ojgRiBIIbFYjK1btyLLMhUVFZjNZnGVK9gnUBSFUChEZ2cnW7duZdq0aXsdrCYQpAsR3AgEKSQUChGLxaiuriYnJyfTyxEIkorNZsNkMtHc3EwoFMJqtWZ6SQIBIATFAkFaEFe0gn0V8dkWZCMZ/VS+9dZbnHLKKVRUVCBJEs8888wet29tbeXss89m+vTpGAwGfvSjH6VlnQKBQCAQCCYOGQ1ufD4f8+fP5w9/+MOItg8Gg5SUlHDdddcxf/78FK9OIBAIBALBRCSjmpsTTjiBE044YcTb19bWcueddwLw4IMPjugxwWCQYDAY/9vj8YxukQKBIK38/Oc/55lnnmHVqlUp2f/ixYtZsGABd9xxR0r2LxAIMs8+Xyy99dZbKSwsjP8IR3CB4IvBG2+8gSRJ9PT0DLr96aef5uabb87MogQCQVrY54Oba6+9lt7e3vjPtm3bMr0kgUAwDkKh0Lge73Q6R+QqLMgu3tjQwX/Xt2d6GYIJwj4f3FgslrgDuHACF2QDiqLgD0XS/qMoyqjW6fP5OPfcc8nLy6O8vJzbbruNxYsXx4X8wzUB2O12li1bFv/7mmuuYfr06eTk5FBXV8f1119POBwe9Jhf/epXlJaWkp+fz/nnn08gEBh0/9KlSznttNO45ZZbqKioYMaMGQA8/PDDHHjggeTn51NWVsbZZ59NR0cHAE1NTRx99NEAOBwOJEli6dKlAINeA6il62uuuYbq6mosFgv19fU88MADo3qvBKmlPxTlwkc+4uJHPsYfimR6OYIJgJhzIxCkmf5wlFk3vpL251170xJyzCP/yv/kJz/hzTff5N///jeTJk3i//7v//j4449ZsGDBiPeRn5/PsmXLqKioYM2aNVxwwQXk5+dz9dVXA/Dkk0/y85//nD/84Q8cccQRPPzww9x1113U1dUN2s/rr79OQUEBr776avy2cDjMzTffzIwZM+jo6ODKK69k6dKlvPjii1RXV/PPf/6TM844gw0bNlBQUIDNZht2jeeeey4rVqzgrrvuYv78+WzdupWurq4Rv0ZB6tnu9hOKxABw+8Oj+hwLvpiIT4hAINgFr9fLAw88wCOPPMKxxx4LwF//+leqqqpGtZ/rrrsu/nttbS1XXXUVjz/+eDy4ueOOOzj//PM5//zzAfh//+//8dprr+2SvcnNzeUvf/nLoBH/3/3ud+O/19XVcdddd3HQQQfh9XrJy8vD6XQCMGnSJOx2+7Dr27hxI08++SSvvvoqxx13XHxfguxie09//Pfe/jCV9uEDVYFAJ6PBjdfrZfPmzfG/t27dyqpVq3A6nUyePJlrr72WHTt28Le//S2+jd5B4fV66ezsZNWqVZjNZmbNmpXu5QsEY8Jmkll705KMPO9IaWxsJBQKccghh8Rvczqd8ZLQSHniiSe46667aGxsxOv1EolEBpWG161bx8UXXzzoMQsXLmT58uWDbps7d+4u3kUfffQRP//5z/n0009xu93EYuqVfUtLy4iPB6tWrUKWZRYtWjSq1yVIL9vdA8GNpz+8hy0FApWMBjcffvhhvC4OcOWVVwJw3nnnsWzZMlpbW2lpaRn0mP322y/++0cffcRjjz1GTU0NTU1NaVmzQDBeJEnaJ9LqkiTtouNJ1NOsWLGCc845h5tuuoklS5ZQWFjI448/zm233Tbq58rNzR30t8/nY8mSJSxZsoRHH32UkpISWlpaWLJkyagEx7srVQmyi+3uAdPZXhHcCEZARo+wixcv3qPIMVGYqDNaUaRAIBg9U6dOxWQysXLlSiZPngyA2+1m48aN8SxHSUkJra2t8cds2rRpkPP5u+++S01NDT/72c/itzU3Nw96npkzZ7Jy5UrOPffc+G3vvffeXte3fv16uru7+dWvfhUf7/Dhhx8O2kbP9ESj0d3uZ+7cucRiMd588814WUqQfSRmbkRwIxgJ+3y3lEAgGD15eXmcf/75/OQnP+G///0vn332GUuXLh3kI3TMMcdwzz338Mknn/Dhhx9y8cUXYzKZ4vdPmzaNlpYWHn/8cRobG7nrrrv417/+Neh5fvjDH/Lggw/y0EMPsXHjRm688UY+//zzva5v8uTJmM1m7r77brZs2cKzzz67y+yampoaJEni+eefp7OzE6/Xu8t+amtrOe+88/jud7/LM888w9atW3njjTd48sknR/uWCVLIjgTNjScgghvB3hHBjUAgGJbf/va3HHnkkZxyyikcd9xxHHHEERxwwAHx+2+77Taqq6s58sgjOfvss7nqqqsGOZ+feuqpXHHFFVx22WUsWLCAd999l+uvv37Qc3z961/n+uuv5+qrr+aAAw6gubmZSy65ZK9rKykpYdmyZTz11FPMmjWLX/3qV/zud78btE1lZSU33XQTP/3pTyktLeWyyy4bdl/33nsvZ555JpdeeikNDQ1ccMEF+Hy+0bxVghQjNDeC0SIpX7A6j8fjobCwkN7eXjHzZgLQ4QmwpcvHoXVFmV7KmAgEAmzdupUpU6ZgtVozvZxxI6wLBENJ9Wc8EI7ScMPL8b/PW1jDTafOSfrzCLKf0Zy/ReZGkNX84IlP+Maf3+Oznb2ZXopAIMgAiVkbAE+/GOIn2DsiuBFkLYqi8PkO1ei0udu/l60FAsG+SKLeBoSgWDAyJn4/qmCfxeUL0RdUr9J6/OPzExIkhzfeeCPTSxB8wdDbwA0SxBQhKBaMDJG5EWQtza6BbE2PuFoTCL6Q6GWpqSV5gMjcCEaGCG4EWUtz90DHSq9fHNAEgi8ienAzu0IVkIrgRjASRHAjyFoSdTY9/aIsJRB8EdnRox4HZpWrwY0oSwlGgghuBFnLoOBGZG4Egi8keuZmVkUhAIFwjGBk91OnBQIQwY0gi2lKKEsJzY1A8MUjEI7S0RcEoKEsH0lSbxft4IK9IYIbQdbSkiAoFpobgeCLx06tDTzHLFOUaybfojb4Ct2NYG+I4CaLcftC3PtmI9tcX7wZL32BMN2+AZ2N0Nzs2yxdupTTTjsto2tQFIULL7wQp9OJJEmsWrUqo+sRDJSkKu02JEmi0KZ6l4ngRrA3RHCTxTyysplfv7yer/zxHT5qdmd6OWlFbwPX09BCcyNINS+//DLLli3j+eefp7W1lTlzMjPiv6mpKSXB1dNPP82Xv/xlioqKdrv/QCDA97//fYqKisjLy+OMM86gvb09qesYDfoAvyqHDYACLbgRomLB3hDBTRbT2hsA1GF2Z//lPV7+rDXDK0ofupi4XpttEYzECISFiDCThEL7dvassbGR8vJyDjvsMMrKyjAaRz/jVFEUIpHs1IP4fD6OOOIIfv3rX+92myuuuILnnnuOp556ijfffJOdO3fy1a9+NY2rHIw+wK/KoRqy6pkbYZ4p2BsiuMli3NpUXmeumWAkxiWPfcwDb2/N8KrSgz7jZnZFAbJBTd/sK9kbRVHoD/vT/jNaj9zFixdz2WWX8aMf/Yji4mKWLFnC7bffzty5c8nNzaW6uppLL70Ur9cbf8yyZcuw2+288sorzJw5k7y8PI4//nhaWwcC82g0ypVXXondbqeoqIirr756l7UFg0F+8IMfMGnSJKxWK0cccQQffPBB/P433ngDSZJ45ZVX2G+//bDZbBxzzDF0dHTw0ksvMXPmTAoKCjj77LPx+/de1l26dCmXX345LS0tSJJEbW3tqNbx0ksvccABB2CxWHj77beJxWLceuutTJkyBZvNxvz58/nHP/4Rf5zb7eacc86hpKQEm83GtGnTeOihhwCYMmUKAPvttx+SJLF48eIRrf+0007jd7/7HeXl5RQVFfH973+fcHjgO/Ptb3+bG264geOOO27YffT29vLAAw9w++23c8wxx3DAAQfw0EMP8e677/Lee+/tdQ2pQC9L6ZkbUZYSjBRhv5DFuDTNyQ0nzeLDZhePrGzh5hfWst3t57qTZsVP+vsieuampigXu81Ety9ET3+IssKJ76wdiPRz5GOHpP15/3f2SmymnFE95q9//SuXXHIJ77zzDgAvvfQSd911F1OmTGHLli1ceumlXH311fzxj3+MP8bv9/O73/2Ohx9+GIPBwLe+9S2uuuoqHn30UQBuu+02li1bxoMPPsjMmTO57bbb+Ne//sUxxxwT38fVV1/NP//5T/76179SU1PDb37zG5YsWcLmzZtxOp3x7X7+859zzz33kJOTw1lnncVZZ52FxWLhsccew+v1cvrpp3P33XdzzTXX7PF13nnnnUydOpX777+fDz74AFmWR7WOn/70p/zud7+jrq4Oh8PBrbfeyiOPPMJ9993HtGnTeOutt/jWt75FSUkJixYt4vrrr2ft2rW89NJLFBcXs3nzZvr71RP5+++/z8EHH8xrr73G7NmzMZvNI/q/Wr58OeXl5SxfvpzNmzfz9a9/nQULFnDBBReM6PEfffQR4XB4UPDT0NDA5MmTWbFiBYceeuiI9pNMtvcMaG4ACqyiLCUYGSK4yWL0zE1JvoWbvzKHKkcOv3p5PQ+928TO3n7uOGs/bGY5w6tMDc0uNXNTW5RDYY4W3OwjmZuJxLRp0/jNb34T/3vGjBnx32tra/l//+//cfHFFw8KbsLhMPfddx9Tp04F4LLLLuMXv/hF/P477riDa6+9Nl7uuO+++3jllVfi9/t8Pu69916WLVvGCSecAMCf//xnXn31VR544AF+8pOfxLf9f//v/3H44YcDcP7553PttdfS2NhIXV0dAGeeeSbLly/fa3BTWFhIfn4+sixTVlY26nX84he/4Etf+hKgZnt++ctf8tprr7Fw4UIA6urqePvtt/nTn/7EokWLaGlpYb/99uPAAw+Mv5c6JSUlABQVFcXXMhIcDgf33HMPsizT0NDASSedxOuvvz7i4KatrQ2z2Yzdbh90e2lpKW1tbSNeRzLZEc/cDC5LicyNYG+I4CaLcfnUL7Aj14wkSVy8aCqVDhs/fvJTXvm8nW/+5T0eOPdAivIsGV5p8tEzN5OdauYG9p1ZN1ajjf+dvTIjzztaDjjggEF/v/baa9x6662sX78ej8dDJBIhEAjg9/vJyVFPQDk5OfHABqC8vJyOjg5ALX20trZyyCEDmSuj0ciBBx4YL001NjYSDofjQQuAyWTi4IMPZt26dYPWM2/evPjvpaWl5OTkxAMb/bb3339/1K97tOvQgxSAzZs34/f748GOTigUYr/99gPgkksu4YwzzuDjjz/my1/+MqeddhqHHXbYmNapM3v27HjGCdT3fc2aNePaZyYJRqK096m6w6FlKTHnRrA3RHCTpSiKMqC5yRlIS58yr4LSfCsXPPwhq7b18NV73+WhpQdRpwlv9wUC4WhcTF1blIPdpr7+fUVEKEnSqMtDmSI3Nzf+e1NTEyeffDKXXHIJt9xyC06nk7fffpvzzz+fUCgUD25MJtOgfUiSNGq9z0hJfC5JkoZ97lgslpLnTiTxfdI1SC+88AKVlZWDtrNY1AuRE044gebmZl588UVeffVVjj32WL7//e/zu9/9bsxrGO9rLysrIxQK0dPTMyh7097ePqoMUrJo7QmgKGA1GSjKVY8BBVYx50YwMoSgOEvxBCJEY+oJwZE7+KB18BQn/7z4MKodNppdfs64710+anZlYpkpQZ/rk2cx4sw1Y8/RMjf+fbtbJ9v56KOPiMVi3HbbbRx66KFMnz6dnTt3jmofhYWFlJeXs3LlQOYqEonw0Ucfxf+eOnUqZrM5rvMBtdT1wQcfMGvWrPG/kBEy1nXMmjULi8VCS0sL9fX1g36qq6vj25WUlHDeeefxyCOPcMcdd3D//fcDxDU20Wh6uwMPOOAATCYTr7/+evy2DRs20NLSEi+vpZNEvY2kzYQoEGUpwQgRmZssRRcT51mMWIy76mrqJ+Xx9CWH872/fcCn23v55l9WcsdZCzhxbnm6l5p0muJi4hx1cJdVff37SllqolJfX084HObuu+/mlFNO4Z133uG+++4btE2XN0hMgZiiYJCGF7z/8Ic/5Fe/+hXTpk2joaGB22+/nZ6envj9ubm5XHLJJfzkJz/B6XQyefJkfvOb3+D3+zn//PNT+RIHMdZ15Ofnc9VVV3HFFVcQi8U44ogj6O3t5Z133qGgoIDzzjuPG264gQMOOIDZs2cTDAZ5/vnnmTlzJgCTJk3CZrPx8ssvU1VVhdVqpbCwcNyvx+Vy0dLSEg9IN2zYAKgZm7KyMgoLCzn//PO58sorcTqdFBQUcPnll7Nw4cKMiIl3DGkDBzHnRjByROYmS9GDG0eOabfblORb+PsFh3LczEmEIjG+//eP+cv/tqSsBJAudDFxjTMHXvwBP1m9iEl0C0Fxhpk/fz633347v/71r5kzZw6PPvoot956a/z+WEyhPxQFFIJ7mEn04x//mG9/+9ucd955LFy4kPz8fE4//fRB2/zqV7/ijDPO4Nvf/jb7778/mzdv5pVXXsHhcKTq5Q3LWNdx8803c/3113Prrbcyc+ZMjj/+eF544YV4m7fZbObaa69l3rx5HHXUUciyzOOPPw6oGqS77rqLP/3pT1RUVPCVr3wlKa/l2WefZb/99uOkk04C4Bvf+Ab77bffoAD197//PSeffDJnnHEGRx11FGVlZTz99NNJef7RMrQNHISgWDByJGWinwlHicfjobCwkN7eXgoKCjK9nN3y2rp2vve3D9mvMpd/XbZ4j9tGYwo3Pfc5f3uvGYDzFtZww8mzJ2yr+PX//oyH32vmkkVTuWbNIvB1cEH4OsyzT+cPZ++f6eWNikAgwNatW5kyZQpW68RvY98ToUiM9W0eQL3aduaOrIVZMLFJ1Wf8iidW8a9VO7jm+AYuWaQK1Bs7vRx7+5sUWI2svnFJ0p5LMDEYzflbZG6yFJcvxLGGlTzRfTwsv3GP28oGiZtOnc3PTlTT2n9d0czFj36kXUVPPPROqen5IfCpXTYOPEJzk+VEE8SrYpq0YLxs71GPA/qMGxiYc9MXjBCLfaGuywWjRAQ3WYrbH+IwaTVmJQhv/gLevW2P20uSxAVH1vGHs/fHbDTw6tp2vvHn9+jyBtO04uShTyeuNw6IVR2SR2huspxIwsmmP8uCm5aWFvLy8nb709LSkukl7pE9rf1///tfppeXEnYMU5YqsKkyUUVRAxyBYHcIQXGW4vKFaJB6B274z1WQUwwLztvj406aW05pvoXv/e1DPt3ew+l/fIdl3zmYqROkVTwcjcXN8qojTfHbHfQJzU2WE00IbgLhKIqixLtcMk1FRcUejSgrKirSt5gxsKe1D2033xcIRWK0eQbPuAGwGGWsJgOBcAxPfziuwREIhiKCmyzF5QvhlFT9AiWzoHMt/Pt8sDqg4dQ9PvbAWidPX3IYS5d9QIvLzxn3vsufzz2Qg2qde3xcNrCzp59ITMFsNFDobYzf7pA8QkSY5SRmbqIxhXBUwWzMjuDGaDRSX1+f6WWMmYm89rHQ5gkQU8BiNFAyZEhpoc1EIByktz9M9W4eLxCIslSW4vaHcKJlbr70G5h/HihReOosaHprr4+vK8nj6UsOY0G1nZ7+MOc8sJLnV49uJkkmiHtKOXOQutfHb3fQhzcYIRxN/UA2wdiIDNFACN2NYKzobuCJM250RMeUYCSI4CZLGZS5ySmBU/8CM06FaBD+fgq0rtrrPorzLPz9e4fy5VmlhCIxLvv7J/zprcasbhXX9TY1RTnQlRDcaO+FOKBlL9EhgWe26W4EEwe9DbzSsatliDDPFIwEEdxkKW5fGCdacJNbArIRznwcao6CoAceWQLdm/e6H5tZ5t5zDmDpYbUA3PrSeq7/92dEsjQDog/wq7ObwL0lfnuRoQ8gq3U3nX1Bnlu9M2vf21SjZ27MRvWwIjI3grGyfYhhZiIicyMYCSK4yVL6fR5sktbplKO6BGOywTefhdL5aov0w18Cz95LTbJB4uenzOb6k2YhSfDIyha+//ePszKD06xZL8yxtoMyECQ4UIOb3v7sbQe/9aV1XP73T3j6kx2ZXkpG0IObPIsq5ROZG8FY2R6fTrxr5mbAPFMEN4LdI4KbLCQSjWEMdAGgyBYwD5jyYS2Eb78CjqnQ06RmcPrdI9rv+UdM4d6z98ckS7zyeTvr2vpSsPrxoZelphq0AKFAlQwW0IdELKszN/rV5v82dWV4JZkhOiS4CUVigzqoBIKRovtKVdl3X5YSmRvBnhDBTRbS0x/GqbeB55bA0HbavFI491XIK4eOz+CxkyHkH9G+j59TzoJqOwAbsyy4icUUWrTMTaXeBj75cABkouTjz+pZNy5tyODKrd1ZmRUbLYsXL+ZHP/oRALW1tdxxxx173F7P3FiMMiZZlKYEY2e4GTc6wjxTMBJEcJOFJIqJJb0kNRTHFDWDY7XDtnfhyTMhOrIv+/TSfAA2dmRXcNPeFyAYiSEbJAq8mp6obAGY1Rk96pTi7D2g6ROUO/qCce3QvsIHH3zAhRdeuNv7FUWJZ2mMBgmrSTU7FcGNYLREookzbnbV3OiD/DwBMcRPsHtEcJOFuHwJbeC5uwluAErnwtnPg9EGm1+CZ74Dsb2LWadP0oKb9uwKbvQ28Cq7DUO36lhMcQPYigBwSH1Zq7mJxRTcCYHXyq3dGVxN8ikpKSEnZ9cTjU5UUeLZKlmWsJnUQ0uydTfhcPYGt4Lk0OoJEI0pmOVdZ9yAEBQLRoYIbrIQtz80UJbKKd7zxpMPh7P+AQYjrHkUXrlCnU2+B6aX6cGNNxnLTRrxNnCndaANvLgBcvTgJnszN33ByCB9ycotrt1vrCgQ8qX/ZxylsqFlKUmS+Mtf/sLpp59OTk4ODTNm8MZ/XkQ2SBgkNXOzaf1azjnzNPLy8igtLeXb3/42XV0DeqSXX36ZI444ArvdTlFRESeffDKNjQODG5uampAkiSeeeIJFixZhtVp59NFHx/waBBMDXbtWYbdi0M1/FQUeOxUeOYFCq5a5EcGNYA+ICcVZiMsXooiEGTd7Y/qJcNoyePpbsPIu9TGLrtv95pPUMk+Ly48/FCHHnB0fA71Tal6BF7b5wWACR108wHOQvf5SLt/gjNL7TXsIbsJ++GUG7DD+zztYnD5ObrrpJn7zm9/w29/+ltvvuJNrf3ARr3+wBioKCfj6uOAbX+GMb57LfffcSSAQ4JprruGss87iv//9LwA+n48rr7ySefPm4fV6ueGGGzj99NNZtWoVBsPAdddPf/pTbrvtNvbbb7993lldkKi3ScgUdq6Fjc8BULRfDwC9Ys6NYA9kx1lNMAi3P0SxlDDjZiTMOwf83fDyD2H59Wq246BLht20KM9CcZ6ZLm+ITe1e5msC40yjl6Vmm7T2dmc9yKZBZalNWZq50YOb4jwzPf4wO3r62eb2U2Lbd5OjS5cu5Zvf/CYA1//8Zu79wz2s/fQTDp1Zy5/v+yMz58zj8muuZ0ppPlaTzIMPPkh1dTUbN25k+vTpnHHGGYP29+CDD1JSUsLatWuZM2dO/PYf/ehHfPWrX03raxNkjmHbwJveiP9q1y78ROZGsCdEcJOFuHxhZuiam5FkbnQO/QH4u+Ctm+GF76tBwZyzht10emk+Xd5uNnb0ZVFwo5alprBdvaG4Qf1XL0vhyVrNjS4mrii0Ue3I4ZNtPazc4uLk2cOUFU05ahYl3Zh2r5kZC/PmzYv/brHlkJefj7tbLTutXr2aD979H4fOqMIwpNmvsbGR6dOns2nTJm644QZWrlxJV1cXMU0v1tLSMii4OfDAA5O6bkF2E28D301wU6Cox0ZPfySrzFkF2YUIbrIQt28UmpuhHH2TGuB8eK9aprLaof7Lu2w2fVI+7zZ2Z42oWFGUeOamLLRVvbFkpvqvXpbKYs2N3gbuyDUzs7xADW62dg8f3EhSUstDmcJkGnBkjsRiSJKEpA1e9Hq9HLfkRC69+gaK8syU5A+Uk8rLywE45ZRTqKmp4c9//jMVFRXEYjHmzJlDKDQ4gM3NnfjvlWDkJPpKAarepunN+P150R4gl1A0RiAcw2aW079IQdaz7+bMJzDdvhAORlmW0pEkOPFumP11iIXhidNh+8pBm2zfvh2lVy39ZIuo2OUL0RdUWzvzfVobuJ650cpSdvqyVnPj1spSjhwTh0xR3ddXbt2D7mYfQxdT6wLQ/fffn00b1lFRPZmy6inU19fHf3Jzc+nu7mbDhg1cd911HHvsscycORO3e2TDKAX7NrtobjrXgb8zfr815ELWPmfCX0qwO0Rwk4W4/SGKpDGUpXQMMpz+N5j6ZVW8+uiJ0LEWgAceeICamhp+fe0PAfhkS1uylj0udDFxWYEVObENHOKZG6fkwRMIZ+XUW5eWUXLkmDmwxoFBUgXbHX2BDK8sPUSig4Ob73//+/T0uPnpZd/jgw/ep7GxkVdeeYXvfOc7RKNRHA4HRUVF3H///WzevJn//ve/XHnllZl8CYIsIBKN0dqrz7jRMjfNbw7aRurvpkDrmBLt4ILdIYKbLKTX66dQUvUnoy5L6RjNcNY/ofIQ6HfBw1+mdd17XHjhhcRiMUJdLQB4IjLrGpuTtPKxo+ttZjqi4NUCruIGtm/fzqqN2wA1c6Mo0JeFV2u65saZaybfamJORSEAq7f1ZnJZaSOeudHkDxUVFfzvf28TjUb53jdPZ+7cufzoRz/CbrdjMBgwGAw8/vjjfPTRR8yZM4crrriC3/72txl8BYJsoL0vSCSmYJIlJumlTF1vI5vVf/1dYtaNYK8IzU020t8FEiiSAcnmHPt+LHlwzgvw4JHQtY7CZ7+G0xqjyw9K0EfE04mxoIS3V29m5tSa5K1/DOh6mwNzO9Qb8it54JEnufDCC5k/KcbHFxGf2tzjD2PPMWdqqcPi8oWQ5D46oiuIKVM5pM7J6h29rN7ew9Rp2bXWkfLGG2/Ef29qahp031B7iUhM4e3Pm6kpGtDHNMyYzh8eepRQJEZdcS55VtOgxxx33HGsXbt2t/utra3dJ2wsBCNH19uUF9rU0pOiDAQ3U5eo7eAJwY3omBLsDpG5yTIC4Si2sKo9iFjsXPif87n6jSt5YPX9vL39LboSas8jIqcIvv0fKJxMTv92XjoH8rRzbVjL3oTGmh1KInpw02BUO6UC+VPiWaYuzclAbQFVslJ34/aHyJ30Ei/t/C1PrHuMQ6aoOqFPd3wxMjcRrdPJOKQ1yqbZMPSH9z45WyDYxVOqawP4OsBopbl0lnqbv0uYZwr2isjcZBlu/4D1gsdo4uP2DwH4b/Or8W2KrEXMKGpghnMmM5zqv5X5VRik3cSqhVXw7VfhwcM5sKKLf38DTnwUIt0tUHcAnaHMfwyaXWpZqlZRS1BdFMdbg7vV4x0WKUIOgXgJKJtw+ULINtVy4V8b/8H9Xz4LSVKvRLNRI5RsEn2lErGaZHr7w8JjSjAitg8NbrSsTaTyYO7Z9BS/BQI9OyhwiuBGsGcymrl56623OOWUU6ioqECSJJ555pm9PuaNN95g//33x2KxUF9fz7Jly1K+znTi8g2IifuMaoplYcXhHD/lRKYU1mGQDHQHunl3xzs8tOYv/PTNqzj9Xydx9N8P58KXl3Lb+7/m+c3/ZpNrA5FYwhe/eDp862Uw53HMFGi5cxG/vPpyIDs8pvTMTUlQbQPPrT0gPqXWHwbdI8+JJysPaG5/GINR7Tzb0tvIdt8GZpYVABCM7NtZi1iCaaa828yNCG4Ee2d7j+4vp3VKaWLi//VAl/bRatuyhtZm1aZDmGcKdkdGL9l9Ph/z58/nu9/97ogmkG7dupWTTjqJiy++mEcffZTXX3+d733ve5SXl7NkyZI0rDj1JJpmumX1v6c6UMvZM79F1VFVBCL9bHJvZEP3eja41rHBtZ7N7k34wl4+bv+Ij9s/iu/LbDAz1VGfkOFpYMbXnsTy968wqfNNFh/h5VYyH9z0BcJ0a63UuZ5NADjqF3L//fdz0UUXEY1G6fJDVQHYpb6sm3UTiyn0+EPY5YG2+uc2P8MhU77Kf9b4CEX27RO7HthIkrRLcKO7gwcjMWKKgkEMXBPsAT1zU+mwDdLb3PPRamKL1c7RIhu88epLFBxyRlZe6AhSx44dO0a8bUaDmxNOOIETTjhhxNvfd999TJkyhdtuuw2AmTNn8vbbb/P73/9+t8FNMBgkGAzG//Z4PONbdIpx+UJx4eyOUBDI5Zaf3cK1n/+M+++/n/PPP5+5JfOZWzI//phILExT71bWu9azoXudFvRswBf2sq57Leu6B0SbBsnAQ7YCZvu6qQ2tB8ro8obo9gYpGsaBNx3obeClOSD3aAP8imdy/vnHsmTJEjZv3syk1ZeCa11W+kt5AmFihDHIA5+zl7e+yI/nfJv/rNn3Mzd6G7hskHaZFmuS1YAnGlMIhqPYssTHTJCdDNLcdG8EbxtRycT6sgImGdTPTr4JjAFVlyjm3HxxeOCBB7jgggtGvP2EOtKsWLGC4447btBtS5Ys4Uc/+tFuH3Prrbdy0003pXhlyUN1BNeCm7B6sgz3RojFYlx00UUsWbKEqqqqQY8xGkzUO6ZT75jOyVNPBSCmxNjZt4P1WnZHz/J093fxqQyzAf/2N6l2LGWbu5+NHV4WZii4adFKUgcXusEVBXM+5KtTbN2WbrYVN2EqKFWDG8mTdZobly+EQVY1Q7JkpDS3lJ3eHQRNqwAr4ahCJLrvBjjRBDGxN+QlpsQosKglOUlzCPcFI/SHY9gmZuOYIA1EYwo7exMG+G1WS1Lh0v0xT/LgNRiIoJ60nJKHAEJzk60oisKja/9GX8jDrKI5zCqeTUnOpDHvb/v27Vx44YWj6p6cUMFNW1sbpaWlg24rLS3F4/HQ39+PzWbb5THXXnvtoOFgHo+H6urqlK91rLh8YabrgmKt3THiUevK0WiUzZs37xLcDIdBMlBVUE1VQTXH1Q7YL3T1d/H0k6eCZwXRnR8xo+xytrn72dTex8K6ohS8or3TpM242c+mzbcpmalOWgZufvfnbOnZzEmGUpyAg76sO6C5/SEkrSSVa8jlqJKjedz7CP9teZ4pRecB0B+OkAEf8LQQSdDbbO/bRkyJMUWuw2ZUv482LbgRomLBnujoCxCOKhgNEqX5lnhJyl9zEHLHGyhAr0GmKBble189lnu6RHCTrazp/JQ7PvzdoNtKbJOYVTybWcVzmFU0m5lFs7Fb7SPa36ZNm+INJiNlQgU3Y8FisWCxZCYjMRYSMzc9RvW/J9ynBjeyLFNfXz+u/RfbirFUHwpbV1Dg2sy0ulxeWwcbMqi70cXEM4xaPVWbTOwP+9naowoH+4wmNbiRPGzLMs2NyxfGYFQDtLYtbVx35Y3M+c00PmhbySnl3wagP7TvZm4GgpsYQc1bqsvXSXXhZGBAdyOCG8Ge0PU25YVWtetOExN/llcE2virHtlIUSzKlw+awT0viTk32cqy5x8CGULuMFFflJxKG539Hby5rYM3ty2Pb1eZV6UGPFp2p6FoFrmmXb3kpk2bhsFgGFWAM6GCm7KyMtrb2wfd1t7eTkFBwbBZm4nIUEFxpC8CUTWw+dOf/jSirM3emFR9FAHpDqzREPvnqe3LmzLoMaW3gVdH1bk7enCz0b0BBfXE6dHq7Q7JQ0+WOYNv2dGOQcvchD0Rgp1B+tZ6yZ+dBzmrgcPxhfbdE7suKA6HA/EjSl+oj/bOdkpLSrGZ1K63/nBUuDgLdsuORDGxazP07QTZzFsx9eLHZrTRI8sQhkKlF7CK4CYL2b59O/9c/g9KjnPieq+XHU+0Ycox8tx7z9FpaGdt1+es6/6cbX0t7PBuZ4d3O682vQKAhERt4ZR4dmdW8WymOxuoqqri/vvvj88+GwkTKrhZuHAhL7744qDbXn31VRYuXJihFSWfxFbwHoPMlLI67lh+L/X19UkJbACmF89hs9nKnGA/M9gElLKhvS9jJx49c1PUv0W9oVh1A9/QvS6+jcugXv07stA8s3FbWzxzE+lTg5jOt9zkz85jc98KDss5jFAkSiQawyjve3MzD5wzg29+92LOOfdrmAq0GyVo62nDUejAYjQhSaqoOBxVMBuzO7h54403OProo3G73djt9kwv5wtDvA3ckTMwlbjqUD52qQ0Rh1YcTu8O1XdOdQYvFa3gWcimTZuwVKjiusAO1Scs7I9g6bbyrcXnxbfzBHtZ172Wtd2fs7brM9Z2f067r42tvVvY2ruFFxqfBVQdY71jGrNmzuKuV3/PZcf+cETryGhw4/V62bx5c/zvrVu3smrVKpxOJ5MnT+baa69lx44d/O1vfwPg4osv5p577uHqq6/mu9/9Lv/973958skneeGFFzL1EpJOjy8QdwR3y0Zq8stYvHhxUp+jprCW5yy5zAn2k+deiUE6ld7+MB19QUoLrEl9rr0RCEc1ozyFHK0NXM/crHcNBDddkhqt26U+erOsLGXMsyP1qJkbXR/V96mPHGMurkAXRlkNePyhKAW2iRXcbNu2jRtvvJGXX36Zrq4uysvLOe2007jhhhsoKlI1WgMSPy07pSggSRjzZQKBAAUFZixGA4FwlEA4itmYPe/B4sWLWbBgAXfccUf8tsMOO4zW1lYKCwszt7AvIPEBfnYbNKklqf7Kg2lpfRmAI6uOoufjvwJgi/QA4A1G9tmLhonKtGnTsK1RzyP9O9SmmOEkFQWWQg6pWMghFQPJia7+LtZ1fT4o4HEHXFpDzDqi/SPPgGc0uPnwww85+uij43/rwt/zzjuPZcuW0draSktLS/z+KVOm8MILL3DFFVdw5513UlVVxV/+8pd9ZsYNQMjnxqidyHtkmf2syRf5Gg1G3M4p4Oki1voBtcXfZEunj43tfWkPbrZpbeBTLT1IYR8YjOCcCgzO3HQqatDg1FrBs6m8EZEt8QF+YU8EWZa575776Jzayv+2voVBVsto3mCEAptpT7vKKrZs2cLChQuZPn06f//735kyZQqff/45P/nJT3jppZd47733cDoHvM8k7XMb9ccwWAxIRomQ9tqtJjke3Iz3PYhGo0iSFB/ymGzMZjNlZWUp2bdg9wwKbj59A4CNBWXQCnWFU5lcWMvHWnnaGnbFH+cJRHDmija8bCGvOBdTofr/FNgZHJWkothWzJHViziyehGgdl21+9r4vPsz1nZ9xqrmT1jFur3sRSWj4e7ixYtRFGWXH33q8LJlywaZ9+mP+eSTTwgGgzQ2NrJ06dK0rztVKIqCob8LgIDRQlgyUGRLUQdT2X4A5HZtZHqJ2seTCVGxPuPm0HxNMeisB9lEKBqiURMTA+yIqSdJu+QhGlPwBrMnHe32h+Ot4Fde8mOampo4//zzObX+dACiSgikGL5Q9qx5JHz/+9/HbDbzn//8h0WLFjF58mROOOEEXnvtNXbs2MHPfvYzdUMFfF4vP/vxNRxYcxDHHnIcj9z7KACecC+xWIy7f/tLlhwyh+qSQioqKvjBD34Qf55gMMhVV11FZWUlubm5HHLIIYO+98uWLcNut/Pss88ya9YsLBYLf/nLX7BarfT09Axa8w9/+EOOOeYYALq7u/nmN79JZWUlOTk5zJ07l7///e/xbZcuXcqbb77JnXfeiSSpM3qampp44403kCRp0L7/+c9/Mnv2bCwWC7W1tfFZWzq1tbX88pe/5Lvf/S75+flMnjyZ+++/Pwn/C18cdM1Nnakd+naAbGaFpF6pz5u0ALvFrmpuAEN/N3kW9QQqdDfZRWOPWo0psU7i9Zdfjx8Px4IkSZTllXNszZe4/IAr+P1x94z4sSKXl0V4gxEKYj0A+LU2WmeKghvH5COJALawj/0d6ok5E6JivQ18vrVVvUErSTX2bCKqDAQDO6Lqdg7UACybdDdun9oK/jVPN1d89iuqDGqgNrNoFjWFNYCCJAUJhKLxmTBjZfv27Sxfvpzt27cnYeW7x+Vy8corr3DppZfuItYvKyvjnHPO4YknnlAvSIC//uluZs+bxT/++xSXX3k5v73lt6x48z0CkQCPPfkY9//xbq7/1e95+Z1PeOaZZ5g7d258f5dddhkrVqzg8ccfZ/Xq1Xzta1/j+OOPZ9OmTfFt/H4/v/71r/nLX/7C559/zjnnnIPdbuef//xnfJtoNMoTTzzBOeecA0AgEOCAAw7ghRde4LPPPuPCCy/k29/+Nu+//z4Ad955JwsXLuSCCy6gtbWV1tbWYcdEfPTRR5x11ll84xvfYM2aNfz85z/n+uuv38X65bbbbuPAAw/kk08+4dJLL+WSSy5hw4YN4/2v+EIQiyns6FGDm1rPB+qNlQfzsVvV28wrmY/D6qRH097FfB0UWNXgRrSDZxdbtIvS6UUzWLx4cdK0oqNFBDdZhNsfjouJPSY1zepMQVkKYPqkBWwxqyWo/YyqkDcTmRt9gF+9YXAb+HqtJFVTUKtuF9bmyEgBLISySnfj8ocwGL0s9nkwBXrhgz8A6lXHMZPVoZOysR8F8AXH3jX1wAMPUFNTwzHHHENNTQ0PPPBAMpY/LJs2bUJRFGbOnDns/TNnzsTtdtPR0QEoLDjwYC6+4mJqp9Zy+Q8u58wzz+Sx+x8DYOOWDZSWlXHIEYspKqvggAMPik8abWlp4aGHHuKpp57iyCOPZOrUqVx11VUcccQRPPTQQ/HnC4fD/PGPf+Swww5jxowZ5Obm8o1vfIPHHnssvs3rr79OT08PZ5xxBgCVlZVcddVVLFiwgLq6Oi6//HKOP/54nnzySQAKCwsxm83k5ORQVlZGWVkZspYZSOT222/n2GOP5frrr2f69OksXbqUyy67jN/+9reDtjvxxBO59NJLqa+v55prrqG4uJjly5fvsj/BrnR6g4SiMWSDhL3jHQBiNUfyeddnAMybNJ98cz4ezW8v6uuIlzdFcJNdbNEyN3X28Y0tGS8iuMkiXL5QXEysdwelqixV75jGRrN6RV4e+ASATVrHVDpp0oKbykiTeoPeKeVaD8DCysMB6EFBkdT3xJ5lFgxuXxCD7MMZ1TJNG54F7Xe1diyhSGEkQ3jMpSl9QqfeBqlPrE51Bmdvn4eYdv+8Aw6OZ9qMBiMLFy6kcaN6BbfopEUE+vs5+fD9uOnqH/LkP/5JJKJuu2bNGqLRKNOnTycvLy/+8+abb9LYOFCWNJvNzJs3b9Bzn3POObzxxhvs3LkTgEcffZSTTjop3uEUjUa5+eabmTt3Lk6nk7y8PF555ZVBOr6RsG7dOg4//PBBtx1++OFs2rSJaHQgWE1cnyRJlJWVacGfYG9sd6vHgbJ8C4bmtwBocU4hGA1SaClkckEtBslAVB/65u+KBzfCgiG70OUEU+1Tk75vlze49400RHCTRbh8wXjmRnfATVXmxiJb6CxU04WW7g8xyRK+UDSeGk4XzVpZyuHX28AHZ27mlSwgz5QPkkTMZgfU0evZYsEQjSn0Br1IhgiOmHai83dBy9sAFFrsWI3qEElJ9o85czPchE59YnUqqK+vR5Ik1q0bXry3bt06HA4HjqJiACQgqr1+oxaYS0jkmfMoryznzY/f4Obf/h6L1cqPfnA5Rx11FOFwGK/XiyzLfPTRR6xatSr+s27dOu68887489lstl0E5AcddBBTp07l8ccfp7+/n3/961/xkhTAb3/7W+68806uueYali9fzqpVq1iyZAmhUGo+OybTYKG0JEmjnqr6RUUXE+9X4AbPNjCYeF9W/7/nlszHIKmnqliO+nmT+10UirJUVqKXpVKRuXnl9ZdGvK0IbrIIly8cH+DXrqgnilRpbgCiZar5pq1rHXXFqqg4nQ7h4WiMHT395OPD3K8NZyyeQSQWYZNb1SrMcDbgtKkdOSHNr8ieRbNuPP1hMHiRFAVHNCErs/5f8V9txhwADAY//eFIfOjdaNAndCaSjInVu6OoqIgvfelL/PGPf6S/f3DA29bWxqOPPsrXv/51dMusNZ98SDSmTdI2GHnvvfeYOXNmPDgPSkFOPPlEfvqLX/PUsy+xYsUK1qxZw3777Uc0GqWjo4P6+vpBPyPpWDrnnHN49NFHee655zAYDJx00knx+9555x2+8pWv8K1vfYv58+dTV1fHxo0bBz3ebDYPyr4Mx8yZM3nnnXcG3fbOO+8wffr0YctYgtGzXbuoOtz4uXpD5cF8oh0D5pUsiG8n56n2O4ZoiBKr+v8mZt1kD67+bnqCqqnplMIpSd13LKZgX//wiLcXwU0WkWi94DKoVy1Oq3NPDxkX+dVHEAPy+nvYv0gNFjamUVS8s6efSEwZsF3IrwBrIc29TQSjQXKMOVQXTI6fIANmdSy3I4tm3ah6Gx8FsSiDTnPr/qXOe0HNksmSEaQYGPrxj6E0pU/o1E+myZxYvTvuuecegsEgS5Ys4a233mLbtm28/PLLfOlLX6KyspJbbrklHqh98sFK/nL3gzQ1NvGnP/6Jp556ih/+8IfkmnJ5/onneerhp1i37kO2NzfxxON/x2azUVNTw/Tp0znnnHM499xzefrpp9m6dSvvv/8+t95664jmV51zzjl8/PHH3HLLLZx55pmDrFamTZvGq6++yrvvvsu6deu46KKLdplwXltby8qVK2lqaqKrq2vYTMuPf/xjXn/9dW6++WY2btzIX//6V+655x6uuuqqcb7DAh09czMvvEq9oXYRqzvV3+dNWhDfLsdWQgj12FiqTQUXmZvsQc/aVOZVYjPlJHXfH7W4mRv9dMTbi+Ami3D5BoIbt2ykwFyAWU7d/IapZfuzTRMuH2prBtKbudEnEx+cp+kShgzvm+FswCAZcGgBns+oCqDVWTfZUZZy+0IYZO+A3sacD6ZcNbW+8yNALU8UmPMBMMh+fGNsYz///PNpampi+fLl42qvHCnTpk3jww8/pK6ujrPOOoupU6dy4YUXcvTRR7NixQqcTmfcV+r8Sy/l81Wfc+YxX+OWW27h9ttvZ8mSJUiSREVJBf945J+c9uWTOfPLR/D2m8t59tln40MAH3roIc4991x+/OMfM2PGDE477TQ++OADJk+evNc11tfXc/DBB7N69epBJSmA6667jv33358lS5awePFiysrKOO200wZtc9VVVyHLMrNmzaKkpGRYPc7+++/Pk08+yeOPP86cOXO44YYb+MUvfrFPjaHINLrmptardkq5yubR7mtDlmRmF82Ob+ewOePt4JNk9VglgpvsoTGFYuI3V66kSuoc8fYTyn5hX8ftH/CV6pHllJakAGY4Z/Cu2UZNOER9bC26DUO60PU2c807oZ8EvY3a/jmjSBUX66LqPq1Twi55aM+izI2UGNwUVMKkubD2KVj3NBwxB4B8cwG9gV4kQwBvMASMzQutqqoqra2VNTU1u7Q8JxKNxXhpxWrybVH6lTYsRgtThxzYzv7aORx07EFElSixcBGxqJUZpfnx+00mEzfddBM33XTTsM+xdOnSPQYSK1euHPZ2p9PJM888s9vHAUyfPp0VK1YMuq22tnYXIfUZZ5wR78Iajqampl1uW7Vq1R6fWzDAjp5+qmgnt38HGIx8YlYzcNMc0wdlAOxWBz2ykUnRCEUGD1As5txkEQN6m+SKiUORGH3rXxvVY0TmJotQMzeaaabBmDIxsU6+uYDWfLWGbe/7EIDNHd4xaULGgj7Ar07SOn6GdEo1ONW/9cyNW9OcZJO/lNuntoE7dd1G7iSYqQ7vS9TdmI1mrNrsokCsj1ia3uNUo2duJIMmJpZ2vV4ySAbsVgcAsjbJuV84hAs0FEVhh7ufQw1r1BsqDmKVrrdJKEkB2C2O+KwbvbNUBDfZQ6rawN/a1MmCyMejeowIbrIINXOjfmF7ZGPqphMnEJqkZRZc67AYDQQjMVq0oCPV6G3gZeEm9YbiBmJKLB7czHCqmZwiLchzac0yDsmTNZobfTpxPHOTOwmmnQSyGbrWg2ugndmpneAl2Tcm3U02EolqwY1mvWA0DJ8MdlqdSIAiBZEMYQJh0UUkUOn0BglGYhxqUGfaULuY1Z2qtiJRTAzqhU6PrH7GVGdw0QqeLSiKwpbe1LSB/+vj7Sw0rB7VY0Rwk0V4vR5yJLWP3y3LKc/cAORUq/M7CnwdzFe7LNOmu2lx+TARpsCv6n0omcmOvu34wl7MBjNT7HWAWmcH6NA6yBzZpLnRBvg5YgnBjbUAphyr/t04kErNNxcgISFJEXoCvgysNvkMZPn0NvDhgxuTbCJf63YzyF4CInMj0NDFxIcZ1eAmVL0wPgpi/pDMjcM6kLlRncGF5iZb6A500xvsRUKiNomdUn2BMI3rP6ZMchEzjFyDKoKbLELyqWKpiCTjlwwp19wA1JYfSKuszuc4qkAdhpaO4CYWU2ju9jNZakNSomDOg/wKNmhi4nrHdIwGdV165qZN85dySH30ZEnmxuUbornJnaT+O/Or6r9b/hPfVjbIWGVVa+KL9KZzmSlDL0spWnAj7ya4gYGZTZLspz+SHcGpIPPs6Omnkg4qlDaQZNbl2okqEYptJZTllg/aNtFfKkdzBhfBTXagl6Qq86viJfhk8Mrn7RwYWwWAVHXIiB8ngpssIRpTMAa7AegzWUGS4if1VNLgnMkGi9qFNM+oevmkQ1Tc0aemoqcbdL1NA0hS/IptRlFDfFtdc7Mjpl7hOaQBZ/BM49ZawR1Dg5sZp4JkgI7PIBaJr9WhTViN4iOyl/kqEwHdKyvG7jU3OjmmnPhBL4qXSFSUpvYFxvs93O7u55C43uZAPnGrs4jmTVqwy+DGxLKUJaweLz2BSFYcC77opEpM/O9VOzhUK0lJNUeO+HEiuMkSevvDOBRVb9OrZVLSkbkpzimhJVd9noq4DUPqZ93ohpn729q0hajiYb0NXBcTw0C3VFtMvUJz0EcoEssK3YaquRkiKAbImwSTj8AU7IZQH36/qi8qtOaBYgQUuvt7MrLmZKJnbmJaydAkGSC6+ytp/f/SIHvpD+8buqMvOvpne+iE5pGy3e0fEBPXLh6Yb1Myf5dt7VZ7vCxlCKiZ7mhMwRea+BcKEx29DXxot+R46OgL8G5jx4DepmbRiB8rWsGzhMROKZfWFZQOzQ1AoLgBOptwetQW7C1dXsLRGCY5dbGv3gY+07QTwkBxA4qiDHRKFc2Kb5trysNkMNEjqyfDAsmHkQg9/SFs5uSlP8eCyxdAKvInlKVKB+5sOB25+S3sO/9LhyYmzsnJQY7YCNOLO9JNoTE3A6tODjFFIRJSNWLhYIiYEkPqbCKgxKCoHoYpUZkVE0pYQiFCd18XJlI3pFKQWhRFwe/309HRgd1uH/O05u3ufi7UxMRK7SLWfPwrYFe9DYDRYCJoUUu7kr8Ts2wgFI3R2x8mzyJOZ5kkFZmb5z5tZRrNFEkedX5Y+f4jfqz4NGQJ6nRi3VdKvRpOR7cUgLlqIax7Gbt3B05zBFfISFOXj2kJs0iSjd4GXss29YbiBjr87bgDLmRJpt4xLb6tJEk4bUV0RltRkJBQVAsGf5jywswGN+5+N0ZJ2bUsBWpL+CtXUPbhz2HON+Imin2BEN5IFwDh7uBuRbjZTjSm0NEbQELBYOpBAuSIlrVxR2E3E0rdfg+hmI9OXPTnTRp2G8HEwW63j8gqY3eEXU3USG0okswORw3ugAuzwcwM5/CO9EqOpt3q76bAZqTLG8LTH6bSntljwRcZRVHimpup9ml72Xrk/HvVDg6LZ22OBOPIBcUT86i6D+LyhSjSBvh165mbNAU3VRWH4DLIOGNRjnV28FRbBRva+1Ib3HT7AYVJwSb1hpKZcb3NFHsdFtkyaHun1Um7r42IJR9T0INdyvysm0g0hjfSQ2ksRp6ilcgSgxt7DZTvj9T6MeXdbzJp/lLC4TBbO31c958/YMpp4rRpZ/DtOedl5gWMk62dPn7+7w8ozA0hTbqH6kiYO9q3qnfOORsW3zDs4xo3bOXez28CKcrNR97KrOLZw24nyH5MJtO4/LUURaGq930wQGjSfqzqVU+QDUWzdjudXcopAUDu76EgTw1uhKg4s3T1d9IX6sMgGagprE3KPhs7vaze0cvlJi24qT16VI8XwU2W4PKFcGjWCz0GmVxT3i4n+FTRUDSL9RYbh/V7OdS2laeoSHnHVHO3j1K6MUe9IMngmMqGHW+o6xnmii1uwGjOxRT04MBDb4adwXv7w0iyF7veBm4wgbVw8EYzvwqtH8O6p5H3Px9ZlplRaaHTPQ3ZuIInNj3Od/f/HrJh4hkwukNedvRFMeV68IZamR01YPVqbf0b/wHH/3LYx82fXEPT8gpsjvd5bOPD/K7qjvQtWpBVdPtC7K+oehu5bhGrO1YBw5ekdIxa6degRCm3hNiCmHWTaXS9TVX+5KSdt/69agcyUQ6XPwMFmHLMqB4vBMVZgssfomjQAL/itD13RX4lW2zqDJKpMTVKTqWBpqKobeBT9cnEzqlgNLPepdkuDBvcqNoMv0lNPTu1jqlM4vaHkWTfYDHxkO6OgZbw1yCg/v8aDBIHlh5BLJJDT6iL93a+m8ZVJw+31o6flxMAoNqQcFBzbYKe5mEfV2W3IfuPAuDNbcvZ6d2R2oUKspbtCZOJjVOOSRATL9jtY/JyJ+GX1FNXhVnV7onMTWbR9TbJGt6nKArPrNrJbKmRHMUHlkIo329U+xDBTZbgTrRekGWKUugGPhSDZMBXNB2AMr8aYKQyc+P2h+kLRqiXdL2NZruglaUaioYJbob6S5H5WTf6AL9dZtwkUjITimZANASbXozfvLCujKBH/bI+u/lfuz5uAuDyqmJiq0U9wVQqQw4nW14f9nGSJNFQPJ2QbxoKMZ5c9/eUrlOQvXTvbKRWaiWKAW/5AhrdagZg7qRdO6V0HBZHfNZNmSk7ncH/vvYRrv/ftURiX4yOwGSLiT/Z1kOLy89RJn1q9SIYZXZbBDdZgssXinuluA3GtOltdOSKgwAo9m7DSISmbl/KpsjqbeBzLXobeAPugIt2fzsA050NuzxGn3XTq33AsyFz4/KFMMjDzLgZip69Wfd0/KZDpjgJ9B4AqNmLnoA7lUtNCS4tuDRpV8+l+qwRXSC9ZfdGd7PKCuh3qdOxn9n0NL7wvjGxWTBKmt8EYIe1gc/6mlBQqMyrongPmWt7wpTiSbIa3Hj6syuI+Mvq+3hpy/N82vFJppeSFpLtKfXvVWo296Q89YJ3tCUpEMFN1uD2hyhKyNykqw1cp6z6MLySAWMswgJrKzFFFXSlghbNU6rBqJUjihvY0K22gE8uqCHXtGt7tN455tLKPnb6Mq65cWuO4EV6cJNXOvyGupHmphchrJZwGsoKyJUmEwlUEolFeHnri8M/Notx+9T336CdYIr0Tqn6E9R/t7wGseFnEc0szyfsm45JKcUb7uP5zf9O+XoF2Udhu1qSbXMcyuoOzU9qD1kbGHAGB9QWYbLLPDMUDdEbVI/lm7SBhPsyiqLQmMSyVDga4/nVrZgIMz2wSr1RBDcTl15vP3ZJPUmkyzQzkYaiWfFJxYsLVC1Mqob56ZmbybEBT6k96W1gIHPTiXqydGRL5sbo3XvmpuJAKKiCsA+2vAqAbJA4eIqTQM+BAPx709MTbspqtxbcxAzqCcYeVidIM/N0tQ3c36lOaB6GWRWFgIFgzxEAPLH+MWJK5ocyCtJLVe/7APRXHDEivQ1oZSndGVzKPvNMV8AV/73RvSmDK0kPHf52fGEvsiQzuaB23Pt7e1MX3b4QR+Y0IUf7IacYSkbfUSmCmywh5lPnnsQAj0FOe1mqtnAKmyx5AMwzfg6kzoahxeUnDz+FEXXCKEUzEob3DR/c6FYU7Yo+pdiT8Tp7z3CO4MMhSdCgZW/WDehrDplSRNAzHwkjm9wb475aEwW3ljmLaOXUvKAWDBfWDEwS3U1patqkPGSDhKtjHrmmfFo8zby74+2Ur1mQRXh2UhbZRlQxINcezppOtZlh3h46pWCoM7g21T2LMjfd/V3x3zd9AYIbXW9TXTB5t+37o+EZrST1rUnqfqk9GgyjD1VEcJMtaF8Ir2wmJklpL0sZDSZ6nKqT6+RQakXFTd0+pupi4rwysNkHPKWG0dsAOLRgb6eSPeaZrrgj+BDrheHQdTcbngUtGDpkihMllkPEOweAf2+aWMJiPXPTr7kzWwOaGWh+OUz9kvr7boIbq0mmrjgXFAsHFqtlrMfWPpzS9QqyC6XpDQA+V+qI5PbjC3vJMebsdXy/3WqPa++y0Rnc1d8d/31zz6Z9PiPZmES9jS8Y4T9rVe3lQcoq9cYxlKRABDdZQTASxRZSU5k9Rs0JO82ZGwBDmTrautzfhEQsZcHNoDbw4pl4Q31s62sBhp9xA6obsIREj9YC6qAv4wc09+4cwYdj8hFgK4L+bmj5HwCzygvIsxjxutT3/eWtLxCMBlO97KSha258ETeWWAxjSPu85JVD3XHq781vQmT41zSrXB0/MEk6FoNk4P3W99j8BbjSFagEN/8XgJWxObQH1cztnJK5e53YrXZLqdtYtUnf2VSWSszcBCL97OjbnsHVpJ5ktoG/urad/nCUaQ6ZvM4P1BunjG54n44IbrKAHn94wFdKE8ymO3MDUDT5SAKShCUaolZqZZu7H18wuV0IfYEw3b5QQnDTwEbXBgDKcsuxax5MQzEajBRa7PTKeq3dQ0+GBcXdPh8GObh3zQ2AbISGr6i/a11TRtnAgTUOwv568ozF9IX6eLNleYpXnRwURcHlDwFRvOHeAVG1bFEHGU6ao74fYT9sf2/YfczUgpuWTitHTz4WgMfXPZqO5QuyAEnrlFpn3Z913WpJau4wZplDsZly8JpUfaA5qAYSmb7QSaQ70D3o731dVJzMNnC9JHXhlHakaBDyK0AbUzJaRHCTBbh8IZwMNs3MROZmRvFsNpnVg8ahNlXsu7kjuaJi3VNqpmmgU0p3At9dSUrHaXXGhYSFePGHwoQimUv5ugNuUJSRZW5gsO5G6yI6eIoTMJAXOQyYODNvfKEooUgMSfahoFCil+byy1WNkSQNZG92U5rSg5t1bR6+OevbALzY+BzuBEGmYB+lrxVL72ZiikS7/SBWd2qdUnsRE+vEtIsgU1D9rGRVcJOQuYF9O7hJ9JSqKxxfWarLG+R/m9X37jirqvtkyjG7DkYdISK4yQJU00xtxo0sk2PMwWpMvwlcvWMaGzWX7UNt6hcy2aJivQ18ukELbkpm7lVMrOO0FcUzN7IUowBfRg9qPSEXBbHogIfJ3oKbuuPAnAd9O2Dnh4AqKgbYvkPV3azcuYI2b2uKVpw89JKUzaoZoEradOK88oGN9hLc6GWprV0+phXOYVbRbEKxEE9v/EdqFi3IHprUrM1apY58p40Wj3oxNbdk3ogerptnmoLqfKhAOEYwkpq5XKNFD24q8yoB9ulSa5uvFX/EjywZmVxQM659Pb96J9GYwrzKQhztWnPBGPU2IIKbrMCVMJ24JwMD/HSsRhtd9moApqEGHMnW3TR1+zASoTyakLnp3nMbuI7D6iQiGQgb1eySU/LQ25+Z0lQkGsMf6cWhWy9YCsG4F08VkxWmnaj+vl7N0MyrKsRmkunpK2CWc38UFJ5vzP6ZL7qYuCBHbf+ullStGPkJwc0UtdTEjvdBFxsnUJJvoTjPgqKodh/fmHkOAP9Y/wThaPZciQtSgFaSei82B0uOqrerK5xKgaVwT4+KY9D8pUyhPmRJ/Q5myyA/XVB8cMVCADbvw5kbXUxcU1CDSTaNa1/PrNoJwJlzC2GnprcZpVlmIiK4yQLcvgFfqUwM8EskVqbWvCcHtgBK0j2mWlx+aqRWZCJgyiWQU0xTr+okvTsxsY5eqvOb1SF/DjwZ65jq6Q9jGKmYOJHEacWKgkk2cECNmmKvNKnt089t/nfWd1jomZtcLbgpR0sdJ2Zu7JPVerkSA60zZigzy1Xn+XVtfXyp9niKbMV09nfwevN/UrZ2QRagfR5WKnMJyVuAvbeAJ2LKKwNAUmJUmFXBeraIinXNzaEVaql5e982/GF/JpeUMpKlt2nq8rFqWw8GCU51bIFYBOxTwFE75n2K4CYL6PaF4sOo3Gk2zRxKYfURRIC8iJ9yulKSuUkUE2/u2UxUieK0OinJ2XOAoA/y8+r+UlJfxgb5ubUBfs7YKIOb+hNANkP3RuhUtUaHTFFfl7t7JrmmXHZ4t/Nx+0epWHbScGlibovmK1US0wYQJmZuYMSlqbU7ezHJJr424xuA2hY+0YYaCkZIXxt0rSeGxPux2XSH1czGvBGIiXUKc4rp0/SJVVppNFt0N91a5qbePo0iaxEKA7qUfY1k2S78+1M1a3N4fTH2tvGXpEAEN1mB2x/COcgRPHOZm+kl89miiYrnGBpp8wSSetBoGdQGnigmnom0F+GYPsjPo6U/nRnM3OiO4CPqlErEWgB12gwYrWtK19182OTly7XqzJdns3zmjUvL3BhNanDjDGvt3nlDgxvttTa+Oux+ZsVFxWoQfcaMr2E2mFnb/XlcZAqwfft2li9fzvbt+3Zb7ReC5rcA2MgUeslhm08tge/NdiERh9VJj9YyXplFzuCBSABfWLMjsRVR71A7ffZVUXEyMjeKosS9pE5bUAlbtY7RMbaA64jgJgtw+cJxX6keQ2bLUtOdM1gf75hSo/JNScreBMJRWj2BATfwkpls0PQ2exMTw0DmJu4vJXnoyZDmxjUSR/DdoXtNabqb+dWFWIwGurwh9i8+HoDXm1/FG0rNnKFkoAc3kqyusUBPu2vlgji1i0EyQPcG6N22y3704GZ9q4dYTMFhdXLC1JMB+Ls21O+BBx6gpqaGY445hpqaGh544IEUvCJB2tBKUu9G5mC07iQcC1FoKRzV6H67xR53Bi836eaZmQ9uXFpJyiJbyDXlMW0fDm5iSowtvWpJcW+DF/fEmh29bOnyYTUZWFJngdaP1TvGobcBEdxkBW5fcMARXM6coBigwFJIW756gppnUq+oktUxtd3tR1FgmpxgmKl1Su1NTAwDmptuSS1XOOijN1OZG19I09yMYDrxUGacqp7wWz8GdxMWo8x+k+0AdLtKqSucSjAa4D9NLyd/4UlCD25ikvrZyA2on99dylI2O2iO82x5fZf9TCnOxWw04AtFadHGBHxTExYvb3mdTzZ/zIUXXkhMa52PxWJcdNFFIoMzkdHFxMpc7Hb1WDC3ZD4GaeSnI4fVEc/clGgBdjYEN3qnlNNahCRJ1DvV4GZf7Jhq9e4kEOnHaDBSXVA95v3oQuLjZpaS1/oOoEBxAxRUjGt9IrjJAoJeFyZN8e+W5Xj5JVOES9W25KlhVeibLAPNpm4/oMTLUhHn1PgVzd7ExDCQuenQ/aUyaJ6pZm4SfKV25wg+HLklMPlI9ff1zwADpan3m9ycUn8aAM9tfiY5i00BuuYmpPQgKwpmvRtqaFkK9qi7McoGZpTqomI1QKp3TOegskOIKlEeXf23eGCjE41G2bx539Qw7PN4O6BTzda+H5uNLVc9Fox0vo2O3eqMZ26KDVpwE8h8t5Qe3Oi6ST1zs9m9cZ/TkOklqZqCWoyGsXVKRaIxntX0NqcvqIQmrSQ1zqwNiOAmO/CrBpI+g0xYMmQ0cwOQV3U4McAZ6aWInqRlbpq6fUzCRa7iA0lmq0EmHAuTZ8qnMr9qr493asFNlybNcZA5fyndemHUmhudxK4pBkTFK7d2c0LdyciSzJrO1fEDSLahd0v1x3pxRCNIKGo2Krdk140Tg5thDvBx3U2rJ37bN2d9C4AP+lditMqDtpdlmfr68fvYCDKAlrXpzmughwKiptF3SsEQZ3CyxzxTFxM7ber3eUphHbIk4wl56PC3Z3JpSScZnlLvNnbT5Q3iyDFx1PQS2KpacoxXTAwiuMk4iqIga9G+/mXNdOamrnQ/tpnUjqTZUiObOpIT3AwSEzvqWO9RT9wzihr2KiYGdey6zWijV0tHOzKpudHLUqPtltJpOE39t+Vt8Laz/2QHZtlAuyeI12/jiKqjgOzN3qhlqSj9EQ/F8QCvFAzyrhtXLwSjDXzt0PH5Lnfr7eBrE4KbI6qOoiq/Gl/Ey2V/uBRZH94oy/zpT3+iqmrvwbAgC9GG92227Y/B2EMIF7IkM7to9qh2Y7c6EpzB1UF+2RTc6Jkbs2ymplA1JN7XdDfJ8JTS7RZOmluOqb8LOj5T76hdPN7lieAm0/hDUfJjPYBakgIynrlpKJrJem1S8Wx5E13eEF3e8Rs6Ng3tlNqLE/hwOK0DU4odeDKmuen29yIZomPP3NgnQ8WBgAIbnsVqkplfrQ4wW7m1m1PrVdHxC43PEoll/qA9FJdPLcspKEzSy0ZD9TY6RgvUqMHacKWpuA1D60AQbZAM8aF+LY6tbNm6heXLl9PU1MT555+fvBciSC+amPgjw3yMNnV43zTHdGymnFHtJt+cH++azImoAUU2zLnRBcXFCeM86u3TgH1vmN9428D7Q1Fe+bwN0Lqk9FlYpfMgd/zjUERwk2Fc/tCAmNhgxGq0kTPKL3qyKbaV0JKrplUPtCZvUnGLy0e9YaBTSm8DH4neRsdpG/CXcmRwzk1XfzdGJUaBfmIfbXADCV5Tg1vCV251cXjVETitTlwBF+9sfzsZS04akWiMnv5wvFMqPp14OL2Nzh50N3pws6Onf9DV9yn1p5FryqPZ08R2QwuLFy8WGZuJjK8TOtXM3ZvBmZg0/7rRlqRADX7DVvViwKYFN9mRuRkQFOtMc+57HVMxJcZWbfjqWNvAX1vfji8UpcphUweZJrEkBSK4yThuX2igDVyWKdJ0JZlEkiSCJbMAmKkkR1QcicbY7u6PZ25iRdPZGPeUmjXi/QzN3PT4xp9RGgu9AfeA9YIkw27czPeIrrvZ8joEehN0Ny6MBhMnTT0VyD4zTT2glI3qZ6JK0ty1hraBJzJVm3fT9AZEBpcSC6wmqhxqpjCxNJVryuUr09QA8O9rH0nCygUZRZtvw6Q5rO01xzM3oxUT68Q0XYs13ANkS3AzuCwFiaLifadjamffDoLRACaDiar8sXVK6bNtvjK/QpUliOBm3yLRETzTbeCJWKtUX5SKSDf5+MYtKt7ZGyASU5imzbhpt9npj/Rjka3UjGK+hTNheJdJihIL9hGNpb8LoS/SkzDjpgQMY/gqlTSoLY+xMGx8gQNqHBgNEjt6+tnm9se7pt7e/hZdQ5yGM0ncesGmtm6X6c1MuytLAUyaCzklEPbBjpW73D1zGFExwNcbzsYgGVix852sFVcLRohWdghWHUVfsB+jVT25zR9D5gaIly6sIfX4mVWt4AnHcX2QX1NvE6FoZjSCyUYXE9cWTsFoMO5l611x+UK8sUFtpDltQSX0bgfXJrUpQS9hjxMR3GSYREfwTA/wS6Sm/ABatZr2LGnLuEXFTV0+cvFTJqlXNp+jBgbTndORhxOh7ganrYigwUBYaz2040n7QS0cjRGI9iYEN6NoAx+Knr1Z/y9yzEbmVGq6my0u6uxTmVsyj6gS5aXG58e56uShm2bm2FRfqbigeE9lKYMB6jQjzWFKU8N1TAFU5lexqFptC31641PjWbYg02hi4g7nIRit25GkGMW2Espy9/C52QPGHDVTaImoZrxZkbnRNTfWgcxNaU4p+eZ8okok7qM30dnSO77JxC+saSUSU5hdUcC00vyBFvDyA8A6MvPUvSGCmwzj8oWzMnMzwzmTDRZ1UvFsw2Y2tPWNa05Ds8tPnaQN78st5XOf+vto9DYwMOvGZ1IduJ0ZmHXT4w+PfTrxUHTdzaYXIdw/qCUciAuLn8sip3D3EF8pRzig3rGnzA2MSHezdkhwA3BMjfq4fUmz8IXD1wUdawBozNl/kN5mJJ2Sw2HNL0NPGtrpoy8YIZaBLK6OP+wnEFED/sTjuCRJ+9yk4vGKiQfZLUDSS1IggpuMMyhzI8uDVPaZpCq/mi029YQz17gWTyBCu2fs+pbmbt+A7UJxAxtc6iCvkUwmTkSfUuyR1VZ1ddZNelO9bn8Ig+zDERvDdOKhVBwABdUQ9kPjqxyaICoGWDxZ/bJv6dlMIBIY17qThZ650TU3eSE1yNlj5gYGgpvtKyEwOIjRMzeb2r2Eo4OH9pXnqQfANu/O8SxbkEla/qf+WzKbLf25GPXgZhRmmUMptBXjiTcXeFAU6AtmbpCfXpKyDdMUMnUf65hqHEcb+Da3nw+b3UgSnDKvQp19JYKbfY/uBEGx22DMmrKUQTLgK5oBwDxZHbQ1no6pxDZwJaENfCSeUok4tPenR9O42DOQuXH5xuErNRRJGvCaWvc0B9Y6MEjQ4vLT2tuP3eLAalTFttkyBEzX3CB7QVHI0acT7y1zY68BZz0o0fgwN50qu418i5FQNMaWTt+g+ypy1THsbb52IrHMnbwE40Bv861dxDaXH5MmJh6z3obB/lJlxsz7S+klqaJhLlCn7UM2DNFYlOZ4p9ToMzfPanYLC+uKKCu0gnsr9LaAwQSTD0/aOkVwk2HcvoRWcFnOmrIUgKnqYABqox1YCI4ruGlx+eLBjaegAk/Ig9FgHPWXQx9wqPtLOaX0z7rp8Y9zOvFQdN3NxufIN8HsigHdjSRJlOWq2oJ2X9v4nidJ6L5SUXopiEUx6AHHnrqldHZTmjIYJBriw/x6B91XnFOC0WAkqkTo0qZ5CyYY8eBmMY3uJgxGH7JkGnXmNpFhncEzOOtmuDZwnX2pLLXDu51gNIhFtlCZN7rRDIqixAf37VKSqjoEzLlJW2dWBDd/+MMfqK2txWq1csghh/D+++/vdttwOMwvfvELpk6ditVqZf78+bz8cvYaDO6NPl8fuZJabuiRjRmfTpxIZfnBdBtkZBQapCY2jlFUHIspNHf742WprZpeps5ej1krL40UXXPTiRrc2OlL+5Rilz882FdqvMHN5CMgpxj6XdD81i66G11w2eZrHd/zJAk9uAkpvQNiYqtDHda3N/akuynbdZgfqFlE/T3Y6d0xxlULMobfBe2q3oaao9juV0vSVbnTR/39T8RhdWRX5maIr1Qielmqq78Td8CV1nUlG11vU1M4ZVTNIKBq6jZ1eDEbDRw/R7sYSkFJCrIguHniiSe48sorufHGG/n444+ZP38+S5YsoaOjY9jtr7vuOv70pz9x9913s3btWi6++GJOP/10PvnkkzSvPDkoXvV1hpHwZYGvVCIzimaxwaKWROZIjWxoG9usm46+INFIiBpJPTmvUdRgbrRiYoACSwGyZByYdSOl319qwBF8DKaZw2GQYcZX1N/X/WvQMD/IwuDGr1ovBGJ9A8HN3kpSOlOOASTVPNEzOFCZVTF8xxRARZ5ammrNkvdAMAqa30J1ep4JeaW4I2ppZk7x2PU2MNgZfFIWBDeu+IybXY/hOaac+DyYiV6aGo/eRs/aHNcwiQKrSdXbJNEsM5GMBze33347F1xwAd/5zneYNWsW9913Hzk5OTz44IPDbv/www/zf//3f5x44onU1dVxySWXcOKJJ3LbbbcNu30wGMTj8Qz6ySYM/Wqa3S3LIElZo7kBqLPXscmipglnG9eyqaNvTN0ITd0+qqV2zFIETDl83K9qR0Zju6BjkAw4rA56tSsGJ+nX3HR7A0iyP3llKRjQ3az/FwfX2pEk2NLlo6MvQKnWat6WRWUpg3YymaQPMtybmFjH5tBsJ1CHFyagZ27Wtnp26czTRcWtInMz8dD1VbWL8QTCKCZVr3Fo1QHj2m2iM3iRIfPmmQOZm+GP4ftKaWqsnVLRmBJ3AP+KXpLqWg/eNjBaoerQpK4zo8FNKBTio48+4rjjjovfZjAYOO6441ixYsWwjwkGg1it1kG32Ww23n57+BH1t956K4WFhfGf6uqxTVNMBbGYglFLUbplIxbZQq4peTXH8WI0mOh1qqZvcw2b8Yei7OjtH/V+Wlz+QZ1S68YwmTgRp60obppnz4DmpsPfjUQMZzQJ3VI6U44Fcz707aTQtYoG7UT//lYX5qD6eW/ubhr/8yQB3REdoEq3Xhhp5gZ2W5qaUZaPQVJF9p19gzvzyjVR8U7RMTXxSBATb+7sQraoFzcHVew/rt3aLYXx44CDzFsw6ILi3V2g1jvU0tTED260GTeFo8vcrNzaTbsnSIHVyOIZJeqNekmq+nAwWXf/4DGQ0eCmq6uLaDRKaengtH5paSltbcNfpS5ZsoTbb7+dTZs2EYvFePXVV3n66adpbR0+XX3ttdfS29sb/9m2bVvSX8dY8QTC2BXNekEb4DfWmQ+pQq44CIAZSitGImxsG73upql7QEwccEyhq78TCYnp2pXMaHFanfHMjSMDmpvu/m5ylRhmTfdDTsn4d2qywrQT1d/XPR3X3Sx78W1+8J0fAPDeZyt44IEHxv9c48TlH8jcVKLV3EeauYHBwU1ChsZqkqkryQN2nXdTrpelRHAzseh3Q9un6u81i1i54xMkSUGOFY977IXRYCKgCVDzNWdwTyCTreC775aCgUnFjRO4LBWJDQwinDrKzE2iA7jFqB03tmolqSnJLUlBFpSlRsudd97JtGnTaGhowGw2c9lll/Gd73wHw27G31ssFgoKCgb9ZAuuQb5S2TPAL5FJlYfilQyYiVIvbWNjx+h1N80JbeDtNjsANYW1o3YC1hnkLyV50q+5CbgH9DbmPDAnyehU75pa9zSH1qpeVSs2dxHsVoM3U5GJiy66iO3btyfn+caAPxQhEI5hMKpB7l4dwYej+jA1De1thc51g+5KLE0lMqC5EcHNhKL5f4ACRTMgv4w1nasAKJSnJWX3UZv6PcmLqsFNJjM3uuZmd0GbXpZq7NlMVJ+RNcHY3reNcCyMRbZSkV854scFwlFeWqMmLOIlqVhsQG+TZDExZDi4KS4uRpZl2tsHz+9ob2+nrGz4ttKSkhKeeeYZfD4fzc3NrF+/nry8POrq6tKx5KTi9if6SmWP9UIiqqhYTRfOkRrHlLlJHOC3WYvYxyIm1kn0l3LQl/YDmifkTl6nVCLTTgDZAq7NLMxXvxOmkhoi/aqoW7YYwAqbN29O3nOOEr1TymRSW2+LItp7P5rMjckKk49Ufx9SmpqptYMP7ZiKD/LztU7YE8MXkoQWcICmPtUVvCpn7N//RBTtgjAvoh5HMxXcKIoyrK9UIpV5VViNNoLRINv6WtK5vKShl6SmFE7BII08fFi+oYO+YISKQisH12rm0O2r1Q5Rc96ADi+JZDS4MZvNHHDAAbz++oCwMBaL8frrr7Nw4cI9PtZqtVJZWUkkEuGf//wnX/nKV1K93KTj8oVxaNOJ3QbjboVomWSaYzrrzerJdba8ftTt4Iqi0JxQlvokqpotjlVvA+rBQ8/c2KQgAf/4fK9Giz/SM+AInszgxpIfd88ubH6eKU41qDSXzSLcqwZTthIL9fVjG3meDPTgxmZV/x8Lw5oGayQzbhLZje4m7jHVNjhzU2IrQZaMRGIRuvrFrJsJQ4KYOKbE6A6rJZmZRfOSsntDrloSzomox4BMdUt5w32EYup3Y3cXqbJBjpdyJuqk4rGKif/1iVqSOnVBJQaDJr3Q9TaTjwTNxzCZZLwsdeWVV/LnP/+Zv/71r6xbt45LLrkEn8/Hd77zHQDOPfdcrr322vj2K1eu5Omnn2bLli3873//4/jjjycWi3H11Vdn6iWMGbc/RBF6WUrGqc1wySZsphy67aoIe45hA5s6vKNy4Xb7w1iDXRRIPhTJwIpxdErpOK1OfJKBqKZPkvq70+YpE47GCCkeipJhmjkcDQPTio+Yru7bVjOPkFaa+uH1P6SqanSDs5KJHtyYtaFpeUEtsBxNWQoGgpumNyA6cELSg5stnV4C4YEMjWyQKdPea9EOPkHo74FWbURH7SK29DQSpZ9Y1MzcScnJ3Bi1cqUlFsRCMGOZG11vk2vKw2rcvTB2ondM6W3gozHM7O0PJziAVwzckcKSFGRBcPP1r3+d3/3ud9xwww0sWLCAVatW8fLLL8dFxi0tLYPEwoFAgOuuu45Zs2Zx+umnU1lZydtvv43dbs/QKxg7Ll+ir1R2am4AlLL9AJjFdsKRCM3dvr08YoCmhJJUzF5Ls1/9vxxPcOOwOkGS8Mjq0LhC+vCG0iMkdPtDGIy+5LaBJzLjVJAM0LaKxZNUfdN+X/4ah8xW2yTnLpyT3OcbJa4EXylrLIZJ97saTVkKoGwB2Iog1Ac7BoZ2luRbKMo1E1NgQ9vwpSnRDj5BaNH1NtMhv5zVmt4mEphMjTMvKU+Rk1uG/s130IcnQxOK9zTAL5GJ3jGlZ25GIyZ+cU0roWiMhrL8eBco0UjcJX6fDW4ALrvsMpqbmwkGg6xcuZJDDjkkft8bb7zBsmXL4n8vWrSItWvXEggE6Orq4m9/+xsVFRXD7DX7UTU3A2WpbDHNHEpR1eEEJIlcwtRKraMSFbckiIn7tKv7yrxKCixjt7XXy3dxUTHpawd3+8JIcpJ8pYYjtxhqjgLg4ID65W90BZheNRuAdn9mZ924NJNSRfZQrGdcTDlqSW00GAxQd6z6e0JpSpKk3Zam9I4p0Q4+QdBPXjWLAPhIy+JE+idT6bAl5SnsNme8Hdwpeejtz0y3lEv3ldpL9n0id0xFYmGaPU3A6DI3epdUXEgM0PqRemFjdUDZ+IY57o6sCG6+qHT7Qjil7BYUA0wvmc0ms5pqnT1KUbHaBq5mbnZa1RPg9HGIiWHAgsGllW4daTTPdPnV6cSOWIqCG4h3TeVvfZ664lwUBQIBNRhs82Y2uNFNMyN4BqYT55WrBqCjZTe6m5lacLN255DgJle0g08ohoiJP+1YBYA5WqdOp00C9oSBng48ePrDuwyATAd7awPXqddsGHZ4d+ANjW3ie6bY5tlGJBbBarTFLzT2xs6e/vik9VPnJzxGbwGvXaROaE8BIrjJIL1ePw5JDRSyuSw1wzmTDZqoeI5hw6hExS0uP1MNauZmvfZpG60T+FCccWdw9Uthp48ef3pm3bh9oeT6Sg1Hw2nqvy3vcGyV2mrd2aMGl5m2YFDLUhHCindAdzRavY2OHtxsfw+CA5+peMdU227awUVwk/0EeqFtQG/jDrho86sXOWXWsZekh+KwDPhLOaVeQtEYwUgsafsfKSMNbuxWO5Ny1GNGY0/muh7Hgr7eusK6EXdK6ROJD57ipNKekK1LkZ9UIiK4ySBhr1qnjQG9Bjkru6UACi2FtOarGqg58vpRuYMnDvD7KKo+bjxt4AAm2US+OT/hoJa+zI077giegm4pncJqqDgIUDjJ/AEAW9pUg8FsKEsZjKrmalJUO4mMVm+j45gCjjqIRTT/IZVZ5WqWal3rYLuPcjHrZuLQ8jYoMXDWQ0ElazpXAxAJTmKyI3nHuURn8CKDenzJhKh4b23gidRPUFHxljGIifWS1OmJJalIUP18gAhu9ll8qoLcY5CRZTN5plHqFtJIpHQuALNpYUunl9AIr446u7uplNTX+V5QTU/OGGfmBrRBfgnp6HQN8uv0eTHIwdRmbiDuNdXQo5ZsGtvUNH6nv4NILDO6AlAzN5KsnkSqUE8qo24DT2SY0lRdSS5m2YA3GGF7z4DdR0VcULyTmJL+q3PBKBhSklqtlaQi/TVUOZI09JKhzuCZawcfqaAYBjqmJlo7+GjbwNe3eVjf1odZNnDi3IQLoB3vQ6RfPXaWjH0kyN4QwU0GMWhfiB5ZxmnLPuuFRAqqDicCOOhnUqyDphF0THmDEQr96qjukNVJryxTbCtJinDaaXUm+Ev10ZsmC4b2vm5kRcGuD5IbryP47tB0N5Ztb+CUfUTCuRglIzElRpc/c3NeEk0z44ersZalYNjgxiQbmF66qw1DSc4kZEkmHAvHTyaCLGWImFjvlAr3T6YqSWJiALvFnuAMnrlBfgOC4pFkbiZmx9RoMzfPrFIzrItnlFBoS9BY6SWp2qPHptUbISK4yRDhaAxrWB0Z7jYYR/SlyCTTJs1jiy4qNmxhwwhKU80JYuKefDXDMV69jY7TNpC5cabRgqHT341dz9pIBrClaDZR8QwonokUi/DV3E8BA4UWdWBZJnU3bn84br1QMlpH8OGoPRqQoOMz6Bt4XbqoeF1CcGM0GJmUo826Ebqb7CXgUbthAGoXEYmF+bzrM0DN3AzSXowTmykHr2a4WGTInAXD2DI3mzIifh4L4WiYZk8zMLI28FhM4VmtJHVaYkkK0qK3ARHcZIwefzjBeiF7xcQ6M5wNrNeCmzmGjWwaUXDjp17T27Ro/kvjmW+TiJq5SRAUp6tbKuAaKEnlFKdM6Q/EszdfNrwLQK6sHjjbfJnR3URjijrnR3MEd0a0bNl4Mje5xVCuzlFiy8Ck8njH1G4MNEU7eBaz7R1Vb+OYCoXVbHBtIBgNokRziIaKk5q5AQhbVY2Wgx6AtM+6iSkxXAG15D6S43hNwRSMBiO+sDfjDQIjpcXTTFSJkGPMoSx379/3D5vd7OwNkG8xckxDQuk+5FcbCCAlZpmJiOAmQwwe4Je9beA6k3JKaclRsxRz5HUjy9y4/PHMzVpJvcpvcCanxqpmbjR/qTRmbjwhF85YCsXEiWi6mwWB97ASwKio73+mDoi9/WEUhXhZqiCklSbHk7kBqFMtJxJLU7OGydyAMNCcEOglqVq1JLWmU3UFD/dPBgxJ1dwAxDTzzAJF/ayk3Wsu6Inr4EYyZd4km5hSqHohTpTS1JZeVW8zxT51RPKJ51ar388lc8qwmhIuALe9C9EQFFSpYvMUIoKbDOHyD8y46clSX6lEJEkiNEkdJDebJja27X1GQ6Kn1Md6p1SSylKORGdwPGnT3HjDPambTjyU8v2hcDJmJcBRhk+IhtUr1PYMBTcuXxAAs8WHrCjY9OBmPJkbGKy70dL0euZmu7t/0MlqIHMjphRnLXpJqkr1B9Tn24T7a8i3GgfrL5KAlKOWawtienCTXsG9rrcptBRils0jesxE65gajd4mEo3x4hr1GHXKvCHzcBJLUinWmIrgJkO4fQO+Utk8wC8RW/WhxIAy+vC6dgzy/hmOlq5epkhqBL9ZNlJgLhhRSnMkFFmL4nNu8qV+vD5/Uva7NwLR3tR3SulIUtxraolhBf0B9YSfqbKUy6cGGWaTb2DGjcGo2iiMh8mHq27ofTugawMAhTZTXJuxPmHejT7Ir807MdL5XzgUBdpWqb9r5ca47UL/5KTqbXQM2vcwP+oDlLR3S8XbwEdxDJ9oHVO6p9RI9DbvNnarA2pzzRw+dch7kigmTjEiuMkQLn9owBF8AmhuAOom7cc2k3plMpNGNnfuOXsT6dqCWYoQNphpN5poKJqZtI4wh81Jn0FGD6+UfldS9rsnQpEYEakvfZkbiOtujjF8QK8nF4D2TAU32qBEydg3YL2QW6paKYwHkw0mH6H+nlCaGk5UrLeDi8xNltK3E/xdIMlQMps2XxvtvjYkDIT7q5JekgIw56sBr0mJkEOA3jRrbkYjJtbRO6Y2TxAbhtF4SuklqRPnlGGUE44NAQ/s/FD9PcV6GxDBTcYYlLkxyFnfLQXq8L318UnFm/coKg6EoxT41Gi/K8eJIknMGOfwvkSKrEUokkSfpruR+7tT3nnQo4lpU+YIPhyVBwHgkPoI96izXTKludFNMxVDH8WRcU4nHsowLeGz9EnFrQOfszJN39Pma50wnSZfKPSsTXEDmKys0bI2hcYaUCxJFxMD5OWWEdQumpyaBUM60acTjyVz0+xpIhgNpmRdySIUDbHN0wLsvSwVjER5+XP14uuU+UNKUi3/AyWqCs3tNSlZayIiuMkQQx3BRxP1Z4rqgslssapX07PldWxo333mZrt7QEzcbFbdu5MZ3Oj+Uj3alUFerJf+vZTJxosr7gieJkExgMmGog3JK4uoA+08IQ/+cHrKcIm4fSGQIkTxDfaVSgZ6cNO0XHUMZviOqdKcMgySgWA0GNc6CLIIPbgpWwDA6g5VTGyJqSfFVAQ36pRiTX8nedIuKO4O6JmbkQc3xbYSCi12YkqMrVrJJ1tp8TQRVaLkmvLioxh2x5sbO+kLRCgrsHJQzRBxdZpawHVEcJMh3L4gDhK6pSZAWcogGfCVzABgjrRljwaaTQlu4J+hHmySJSYGyDXlYpEt8Y4pu9SX8o4pdTpvCh3Bd4NknwJAldKDTVaH22WiNNXtG2gDn6R3jCUrc1O+n+oQHPTATtVyQu+Y2tDeR0SzejDJJko0bx4x6yYLaVODmXhwo3dK+dUr9aoUaG7sVvuAMzjpD25ccV+pkR/DJUmKZ2+yXVQ8oLfZe6fUc5+qWeWT55VjMAzZVjfLTENJCkRwkzH8XjdmST1Jeo1WCswFGV7RyDBXHgJADS52tO++PNKcENxslmVsRhuTC5KXipQkCYc29RjUg1qqZ924fGlwBB8OhxbcSO3kmfRZN+kvTbkTphNXoLV3JitzY5AHrui00lS1I4dcs0woEmNr18BE7IpcMesma0nI3AQiAdZ3rwPA5Vb/z1KhubEPydz0BdLbLTVS08yhTJTgZqS2C/5QhNfWtQPDdEn5uwc+G2kQE4MIbjKG4u0AwC8ZyM0pzmrrhURqyg6gVVZbOe29a/EFhz+QNHd5qdfKUlvNFqY7G0bsJDtSnAkdU+qsm9S2g7f19SBJkbRnbtAyN9VSO2bUq8NMBDcuzTQUoFSXuyQrcwMwdfC8G4NBomGY0lSZaAfPToJ94FJPhG9v7uPNdW8QVSIU2Uro6lWDmpSUpSwOevXMTUbKUmMLbuonSMfUSNvAX1vXQX84So0zh3lVhYPvbHoTUFQvqfxxeNGNAhHcZAjJr9ZpJ0obuM4MZwPrLboNQyObOobX3bi7tlMo+YgB24zmcTuBD4fTNuAv5UhDOrrd24lNiWHVhaxpC25qATW4IWIHMhTc+EJx64W4oDhZmRsY0N1sWwFB9XM1a5jgRh/kN1Gmu35haF8DKOzwwJHHf5Wl154LwNSCOYBEniX5M25AM8+MX+T04A1G4mXMdDCWVnCYOB1TjSMMbvQuqVPmV+x6sd6klaTSlLUBEdxkDKMW7fcYJkYbuM5Uez2bLGpL8hx5HRt30zFl6FbnlXSa8wgZDEmzXUhkkDN4GjQ3Hb5unLqY2GgDc25Kny+OVpaqpp1gUD3ZZ0Jzk2iaaQ9rbt3jcQQfiqNODeRiYbWzguFFxeWiHTwrca9XT2CrtI9m7lQ1S5MfrQKg0m5LSYY6z5xPr5ZNLpLU42q6SlPRWBS3Zr0wWkPgqfapSEi4Aq6sNYINRoNs71M7pfbUBt7bH+bNDaqh7y4lKUi7mBhEcJMR+kNRcqOaaaY8MdrAdUyyCY9TjeBnS5vZMIyoOBKNUeBV09ONRjWz0lCUfGv7wf5SqdfcdAe6B0pSeaUpn7AZxz6gufH2qen9TAzyUzVHfUiKQl6yphMnIkm7tITPLNu1HTxuwSA0N1lF/9YVAKxSZRfk1quf1f5u1R4hFSUpUBsdQhb1c1Isp9cZvDfYQ0yJISFhtzpG9Vir0Ua1pkPMVt1Nc28TMSVGvjmfYlvJbrd75fM2QtEYM0rzmaF9Z+P0tUHnWkCKW3KkAxHcZAC3P0RRQhv4RMrcAMgVBwJQTwdNbZ273L+zN8AURdXbNBplTAYTdfa6pK8j0V/KmQbNTW/QnX69DUBhNYpkwCKFMXjUzFG6SzL9oSj94SgGo5fCWBRZ0dL+yZ71MyS4aSgrwCBBlzdIR18AGJhSvNO7U8y6ySKKI2ombVUbWCaZMRUYiYVj5FlV25ZUBTcAYZtdXYNBPa6myzxTz7jYrQ6M2rFoNEzL8tJUoph4T1m3gZLUMBc7ekmqbD7kpO9cJ4KbDODyhwYcwQ0TS3MDUFF+EN0GGRkFpX31Lvc3dfmoN6jBTZPZQr1jGkZD8mvtTqszXpay05fyq7W+dPpKJSKboKAagElhdeBXh6+dmJI+XYFbCxxlo3dgxk1OMRhH5qUzYvS0dftq8LZjM8vUFqvlPz17U5pbhoREMBqgJ+hO7vMLxkY0gtm9HoA1HYZ41qbCWElfVA1qUtEppaPkqCUhfbxGujI3uph4JIaZw5HtHVMj0dt0eYO826i+DyfPHa4kpbeAp68kBSK4yQgu79ABfhMruJlRPIsNFvWAVe5fv8uBpNnlp05rA28yWVIiJgY1c6OXpdKhuemP9uBMdxu4hqTpbiqjXiQkQrFQvNafDvTpxEaTl+KI9j4nU0ysk1sSn5HCltcBmFk22IbBLJsp0cwSRTt4luDaBJEAmHJ57eOtfPPKrwPwpTlL2NGjDpxMha+UjkH7PBQqark0bcHNGNvAdbLdQHMktgsvrWklGlOYX1UYvxAZRAb0NiCCm4zgTszcTMCy1HTHDDboNgzy+l1ExTs7OqmS1HJVk8nCjBTobUDL3GjdUoV46fX3p+R5dIIxT3qnEycS75jqJM+kt4OnT3ejBzeS3DdgP5FMvU0iQ0pTsyp29ZjSRcWtQlScHegzTErnUVU9mS6TOupiXskCtrvV72Uqy1JGTdheGNPMM9MkKHaNO7hRy1JbexqJxNI7n2ckjKQN/LnVu3EAB+hpAXej6jU2+ciUrHF3iOAmA6jWC2pw0zMBy1I5phy67GqZZLZh0y7BTahDTU+7ZRO9spGGFHRKweBuKYOkEPWlLpMRCEeJSX2Z0dzAoFk3VklNgadTd+PSrBcUQ3/yrReGUpcw70ZRmFGqChQTxw6Ua+7yInOTJSQM7/OGvDS61Sv+6Y45dPSppdRUlqUs+WqwK6NQgC+NmRvNemGMx/CKvEpyjDmEY2FaPM3JXNq4CUQCbO9T5QW7G+C3s6ef95vU4+5J8/agt6k4EKzpHVQrgpsMoAqKBzI3E60sBSCV7w9AAzvZ3DY4qDC61DbwrUYTsiTHU6/JptBiRzHI9Gmu1FIKncF7/GEMRm9mNDcw0A4utWOIqV0Z6WwHd/kTrRc0rU8y28ATmXwEyGbwbIPuTUybpFpONHZ6icZUAfFA5kYEN1lBQnDzWddqFBQq86oIBtUyRY5ZxpGTfN2dTkHuJHzakFBHGs0zB3ylxpa5MUiGePYm20pTTb1bUVAotBTuNnh7YY16gXVwrZPywmEycxkqSYEIbjKCyxeKC988RjOFFntmFzQGSioPpc9gwEwU347P4rfHYkrcDbzJbKG2cApWozUla5ANMnaLPZ69kVNopOj2hzDIvvQ6gieSkLkJh+xAejM37oQBfhWK1jWRqrKUOQeqD1d/3/IaVY4cLEYDwUiM7W5VvxFvB/eJ4CYrSAhudLPMeZPms6NHLUmlasaNjsPqiOvv0jmlOO4IPo4L1GydVBzvlCrcvafUc58ODO7bBUVJCG7SN7xPRwQ3GaDP6yVPUttaySlOui1BOphRNJONZjVoyeka6Jjq6AtSG1OHPjWZLEl1Ah8Oh3VgSnFOtJdgJDXO4N2+fiTZn/HMTTmd9PvSP+um2zdgvTCQuUlRcAODdDeyQWJqiZq90UtT5cJfKnvoawNfB0gGmDSHNZpZ5tyS+WnR2wDYLQ56tFbsdDqDx8tS4whusrVjakBvM3xJamuXj9U7epENEifMGSaL62oEz3YwmAYuVtLIxDur7gNE+lSxXRgJS7ozAEmiwTmT9ZqouCa8li6vWldvdvnihplNJktSncCHY9CU4hRaMGzv7UYmhj2WIUFxXjmKbMYoxTB71NeYzrKU2z+QuXFGtHlCqcrcwEBws/W/EIvGS1O6vqtct2AQs24yj561KZpBzGRlTad6sTOvZH4805ZKvQ0MydzgSducG5fWsTieQazZGtzsrQ38eW22zWFTiyjOs+y6gZ61qV6oZmPTjAhuMoFP7STqkeUx12ozjd3qoDVfDcwSO6ZauvqYIqkdLKlsA9dx2pwJFgweelPUDt7a10lhLDrwhclJ8/+bwQCF6jTTspAaXKSzLNWtWy8oCoUh3XohhcFNxQFgKYRgL+z8kOmaqHizlrkp057bH/HTG+xN3ToEeyehJNXUuxVvuA+r0Ua9Y3r6MjfWxONAb1o0N5FYmJ6AOmdpPMdxXXPT7mujL+TZy9bpY29t4PrgvlOHK0lBRvU2IIKbjCAFdNPMidcGnki0dD4As9jOxjZNIL1jAxYpQkCSaDWamJ6iTikdp7UowTyzL2UWDO2+BOsFWxHIo59GOl4GZt2oV8Pd/V2Eoqmdyqzj9qmC4lwlhjmmvcepzNwY5IGD4pbXqJ80uCxlkS3xcfCtPtEOnlHiwc18VmslqVlFszEajIM0N6nEbimMHwechm48/alvq3YH3CgoyJI8Lt1knjmfMq37L1smFfeH/ezwqhn44TI369s8bGz3YpYNfHnWMCUpRcmIWWYiIrhJM4qiYI6bZk68NvBEHFULCUgSuYTo3rYWgGjHOgCaTRaqCmrIM+eldA2qBYM2pVjypGyQX3d/d+b0Njq6x5Tixiipk4E7fO1peWq9LBUXVJvzU28cmqC70ctSmzu8xOIdU6IdPCtIyNzoept5JeqFz0DmJrVlCaPBhF8rfTglN71pKEvpYmK71YGsHYPGSraVprb2bgVULdNwF+C6kHjRjJLhnd7fv0fVYRltUHVISte6O0Rwk2b6ghHs2gC/iTidOJHpxbPZpImKDa2fAGDuUb+czSZLSpzAh+JIMM904qGnPzWZjJ6Aa7BpZiZw6AaaHeTIahq8zZ963U0spuDWWuGLI/p7kKI28ESmavNutr3L5DwFs2ygPxxlR696wizPFe3gGSfkg27thFy2gDUdA2LiYCRKu+YHluqyFEDEWgiAU+qhtz+cci3WgJh4/CXqbJtUPOAptWvWRlGU+OC+XUpSigL/vQFe+oH698IrwDiMHicNiOAmzbgT2sDdsjxmT5JsoME5Mz6puLB3NYqi4PCrIrStaRATgyrk09PRdqkvZZobTzhDppmJJLSDG5X0DfLzBMJEYwqS3EdxNA0lKR1nPRROhmgI4453qStRM0Wb29XSlHAHzwI6PgMUyCujz2xjS6/6/Z9bMo/WngCKAlaTgaLcJHuQDUNUO5Y6JQ/RmII/lJrOSR2XloEfj5hYZ1qWtYPrYuKpwwQ3n27vpcXlx2aSObYh4VgYi8LzF8NbN6t/L74Jjvl/6VjusIjgJs24fAkD/AwTW3NTmltGc446UG46n7OurY/JMc0w02ShwZka24VEHIlCwhRqbvyRHpyZsl7QiQ/yayMaVq9S27ypD266fcOYZqZSTKwjSYNKUwO6m8EdU6IslUESSlKfd6rzrqryq3Haitiephk3ceLmmWrwm+p28GS0gevowU2je3NaDXF3R6Ib+FD0ktRxM0vJMWvaw3AAnvwafHQ/IMFJ98LiG9TvcIYQwU2aSfSV6pHlpET9mUKSJEKlcwCYTTOvft5GvaQHN2ZmFKW+LFWUoLlxSB56/KkpS6m+UpnO3NQCUCa5iPpVfUF7GjI3bl8IpDCSHBgIbtKRuYEhuhu1Y2qjPusmPshPCIozRuLwvvh8m3kA7EhTG7iOnKd+L52oz5v64Gb8A/x0qgsmYzaY8Uf87MwCv7TdeUrFYgrPrxnSJRXohUeOh/X/UieLn/UUHHRxWtc7HCK4STPdCb5SE71bCiC/ciERwEE/W9a8hV3yEgMChdU40lBySxzi5yB1wU0YT8YcwePkFBMzqaWZ3D51Le1p0NwkWi+U6NmrdGRuYKBjqm0VswvVWUqbdilLtYpZN5kibpg5f9DwPiBtbeA6Ju3zUKD0YyCa8lk3cUdw6/g1N0aDkSlaIJHp0pQ/7I9P/h7aBv5+k4t2T5B8q5GjphdDXys8tAia3wRLAXzrFZh1RiaWvQsiuEkzbl8Ip9QDQK9swm5xZHZB46S+ZC6Nmqh4TvcLAOw0mphSMictz281WolYVEM2oxQj7HMn/TkC4SgYMugrpSNJSJrupjSknujbvGkIbvQZN0B5qq0XhpJXCqVqJmBO8AMANnf0oSgKZdqUYl/Ym1XzQb4wxKLQrg7si5XNGzS8D9LXKaVjzVc/DwagEG/qMzfj9JUayrQs8ZjSszZOqxO7dfD5SZ9tc/zsMiy9W+CBw6H9U9WOZumbMGVxmle7e0Rwk2Zc/nA8cxNLQgthpmkoamCDFtycIr8F6J1SqRcT6+TmFNOv1XZj/uT7S7n9qvVAxgXFDMy6qYiqXShtvtRnLVwJvlLF6c7cQLw0NanzbYwGCV8oSmtvAKvRGhfkC91NBnBthrAfjDaaZOOg4X0A23vU8lCqZ9zo2HMm4dFMdJ2SJ+Wzblx65iZJ2feBjqnMzrrZnd4mHI3x0mfqxdTZVZ1qYNOzFRxT4fx3oHxBupe6R0Rwk2Z6vP3YtZqwIVMtxUmkOr+GRquqhSiT1FHkW9MwmTgRp7Uo7isjpSC4afP0YZCDOOKC4gz+v+nt4DE1U+GP+PGG+1L6lK4EXylHRPNES1fmBqBmEQCGHe8xpVgty8U9pjR38DZhoJl+4iWpeazuVsXE+vA+gB1pLkvZLfYBf6kUWrHoJLMVHLKnY2p3ept3Nnfh8oU4wfYZC/57Ovg7oWw/NbBxDm/RkElEcJNmQn2dGFCvtE3pvPpNEbJBpr94sHA4HZ5SiTitTnq1WTfGYPKDm+2eTiyxGLl6F0MGMze6qLiKLiwGtRyX6o4pPXNjUmLkRtRyWFrm3OjoQ8A61zFXu0jWO6YqRMdU5mhTNTbDDe8LRWK0edI34waGzLxKsXlmKBrCo5VCkzWIVQ9utnlaCET6k7LPsbCld/jMzXOrWznJ8D/uVq5DCnlVPdzSNzI392sviOAmzcR0XymDjD2nJMOrSQ62qkNIbF7szC1iUk76PvCJU4ot4R4i0eS2Uu7s6xwoSckWsOQndf+jImHWjRl91k1qdTfqdGIvRfoAP9kMtjTOZ8or1YI6hcNs6uTUzUM7pkRwk34GTSZW9Ta6mLjNEyCmgMVooGQ4U8UU4LAmOIPTm1JBsW6YaTQYKdA0f+PFaSuiyFqEghKfM5MJhptxEwhHcX5+P3cbf4NRicCsM+GcF8GanNeeCkZkkLN69epR73jWrFkYjen338l6tOCmd4K3gScyZdICtpnM1ITVTiVr2X7pmWuh4UzsmJL68AQiOJM4NKy9r2twp1QGZzcMzLppR4keAlLqB/m5NF+pgRk3Zel/D6oOhZ4m5ijrgJKBslSunrnJfPvsFw4tuPEX1bN17R+BgTZw3Q08bTNuGOIMbnDTnsLMja63cVqdGKTk5QimOqbR3drNJvdGZhenpykjEW/IS7t2sRTP3CgK25/+CT/jjyCBcuAlSCferfq/ZTEjij4WLFiAJEkjFi4aDAY2btxIXV3duBa3L2LUplpO9AF+iTQUzWS92UZNOESPQaa6dL+0Pn9i5kZvB09mcNPp78p8p5SOlrlxSh6MfhvkEj8YpQqXL4Qhvy+9A/yGUnkIfPY4Vb7VwFFsbFc7pgZm3aTPIV0AeNvB2wpIfGYABYXKvKr4MU3vlKpMU0kKwGq04TWqzQ1OQzebUpi5SbbeRmeaYzrvt76XMd3NVm3CdJGtmEJLodoR98Kl1K+7H4A3K7/PopPuzuwF3ggZcWpl5cqVlJTsvYyiKApz5qQ/4pwIRKIxLGEXGDXrhX0kuKmz1/OqJYclvl6aTJa0DO9LxGl1skVOGOSX5Cs2d9DF9ExPJ9axFhC1OpEDLvK9UXpy05O5MTu8FAfSaL0wlKpDAcjt/BDZAH2BCB19QSrydH8pkblJK7repmgaq3rU7p55k+bH7053G7hO0KJOsdb9pVJFKoMbyFw7+KCSVDgA/zwb1v+LqGLg+sglfPPEWyZEYAMjDG4WLVpEfX09drt9RDs96qijsNnSF7FPFHr7w/HpxG7ZSPk+UpYyy2Y+r9yft/vf5B8FTn6cBtuFRJzWIj7Rau12ku8v5Qn1ZE/mBq0dvNVFaSjENlKruQmEo/hCUSxygiN4JjI35fuBbEbyd3Goo5d3ugvZ1OHlgBp1LX2hPvpCHvLN2asB2KcYxglc19vAQFkqXWJinajVDoBT6k1tcBPQy1LJPYbXJ3RMKYqS1vI+DLSBN+RWqVOHm98kajBzafAqNjiO45aKifP9GlGxcPny5SMObABefPFFyssnfidQslGtF1SFfY9h38ncAJSXLuBHZbV8UlhBZX5VWp/baRvcJZFsZ3BfuCfzjuAJGLSOqUqtLTuVZakefxikMAY5OOAInonMjdECZQsAODp3CwCb2vuwmXLigzBb0+CzJdBoVwOaWOn8XYb3AXFfqao0zbjRUXLUY6qD1M65SVXmZoq9DlmS6Q320tXfmdR9j4QtPY0URcKc+8Gy+NTh20vv5JXYYZwyryLtwdZ4EN1SacTlC1OkTSfukY37jKAYoKFIzdaUGcrYuSO9nSvqnJtEzU1yr9j6Y71ZMcAvTnzWjSqq7fC3E42lxgG52xeMD/CbpD9HOtvAE9FKU/sZ1JS9LioW7uAZQMvctOeX4Q33YZGt8awDpH/GjY6Uo34/HfhSmrlJ9gA/HYtsoaagFshMaSrQvpoHWrdg72mG3FL6vvka92+bDCR4SU0QRhTcXHnllfh8vhHv9Nprr8Xlco14+z/84Q/U1tZitVo55JBDeP/99/e4/R133MGMGTOw2WxUV1dzxRVXEAgERvx8mcLlD+GUVHuAHtm4y2jriYz7XQ8dr3Tz/LUvU1NTwwMPPJC25843F+A1qe2mdqk36ZqbsOLJruBGExVXKS4kZKJKNGVXeW5/OO4rVRrTGgoyNZ+pUp13UxdYAwzTDi4G+aWHcD90rQdgtUH9TMwuHhjeF4kmzrhJr+ZG1jKrDsVPfzhKKJIah+1kOoIPZWqGbBh8zW/ymy0fUBUJE3NMgfPf5cXOUsJRhYayfKaVZnAExhgYUXBz55134vf7R7zTP/zhD/T09Ixo2yeeeIIrr7ySG2+8kY8//pj58+ezZMkSOjo6ht3+scce46c//Sk33ngj69at44EHHuCJJ57g//7v/0a8vkzh8oVwGnoACFns8YPBRGf79u18/8Lvs+3vrfibAsRiMS666CK2b9+elueXJAlJO8g4pT56fcktS0WlPhyxLBEUw0DmRurAIqkBcqp0N93eYNxXqijdjuBD0TI3hb1rMRMe6JgS7eDppeMzUGKQU8IH3hZgsN6m1RMgGlMwy+mbcaNjyVcF5gWEMBJJ2aybbm3OTbI1N5ChScWNr2F95EScsSibrXkYzl8BzjqeW62Wek+ZN7GyNjBCQbGiKEyfPn3E9bbRZHluv/12LrjgAr7zne8AcN999/HCCy/w4IMP8tOf/nSX7d99910OP/xwzj77bPj/7Z13eBzlubfv2b6qq96Le8MFDDY2zYDBkITQQhzCocUBh+CT5DgkhIRAyhecAoSEAzEQA2mUwKElITRjQwCDwdhgg7stG9lWL6vtZeb7451dSba6Vtqi974uXdLOzrzzzmh35pmn/YDq6mouv/xy3nvvvR7H9/v9+P3+6GunM34Ce63uALkIF7+WHttYbTzZvXs3qtr9CSkcDrNnzx7Ky0cn/8aQLkIlVkJ4PLH7H3v8IRRDYuhKRYl4bpR6DOE5YGgasbwboavVgUHTyA7q3tF4eW5yxkFaAQZPIzMMe9nsnUqTKyAb+Y02XZKJP27q3rwPOiulSh02DIbRzdFIyyglDBiBHDpo9wbJHwEDa6RybiAOFVPbn4OnvoxRDbLRls6Tsy7lrowiGjv8vLNXHOcXZiVfDu2AjJtHHnlk0AMXFfWfeBkIBNi0aRO33HJLdJnBYGDx4sVs2LChx20WLlzIX//6VzZu3Mi8efPYt28fL774IldeeWWP669atYqf/vSng57/SNDi8pOLeAo2xlOfKMZMmjQJg8HQzcAxGo1MnDixj61iS0Z6AQEULGiEXE0xG/eQsxWDEsKRUMZNFQCZihe734bHPnLl4C3uIAaTUEQXsiFKXFXRKZ8Pu/7JWen72Nwxld0NHV3KwaVxMyroxk2gcDr7618HuicTH4pTGTiAIy0fp8FIjhomR2nHOQJ5N76QD3dQXMfzR9C4qWnfTzAcxGw0x3wfUTrq4LlrQA2ys3gm37aF+VK+kM7597YjqBrMLndQlZc+cnMYIQZk3Fx99dUjsvOmpibC4fAxhlBRURE7duzocZuvfvWrNDU1ceqpp6JpGqFQiG984xu9hqVuueUWVq5cGX3tdDqpqKiI3UEMAo+rFQsivGHNTD43X2+Ul5fz4IMPsnz5csLhMEajkQceeGDUvDYAOfZ82o1GCsIh8MTOuDnQVk+WGu78oiSCZIbZTjitCKOnHodLpXlEjRsRlsrratwZ4xhOLT8Zdv2TeWZRsrqnwcXCqTLnZlTRjZsDdscxzfsgfmXgAA5bDm1GEzlqmNwREs9s0cvALQYL6eaMmI9flF5MhjkTV7CDA8793RK1Y84r3wV/O5TM5ffVswnWbWSC3pn4hY/E9+mC2cnntYEkrJZav349d9xxB/fffz8ffvghzzzzDP/617/4+c9/3uP6VquVrKysbj/xItQh8oi8ikJmvCpORohly5ZRU1PDunXrqKmpYdmyZaO6/64VUwbvwJPZ++OQs4uulC0HTLHrfDwclFzR/bs4IOY2UsaNSCju0p04Xvk2EfS8mymhTwBRMRUJS7X723EHBx4SlwwBVYV6EYrarAhPbdfmfQAf1bYBUJk7+p6bHGtOZ+XkCIlndg1JjURptKIoTBqNpOK9r8LWx9AUA++XXMeulohg5gQOtXn54EArigJfmJmcD+JxNW7y8/MxGo3U19d3W15fX09xcc83/x//+MdceeWVfP3rX2fmzJlcfPHF3HHHHaxateqYvI+EwyMqWlqNphFJRIs35eXlLFq0aFQ9NhGEMrjwKJhjqAxe72pKrHwbHYOeVFymq3TXu+v7Wn3INOuem266UvGk9CRAweE/RD6t7G7oIN2cLlrFI0NTI07rPgi4wGTjbZ/I8+qab9PY4efN3eLmv2TG6H9WuulLKW04fbHvddMc0ZUawT5lE0fauAn64F/fBODed1UWXP5NWgPioXC8YwL/+lh8j+ZV51KcbRuZOYwwcTVuLBYLc+fOZe3atdFlqqqydu1aFixY0OM2Ho8Hg6H7tI36h3mg2lfxwhAxbgymESkhHMt01ZeyBFtR1dh8FoSuVAJVSkXQk4rL9F43I+a5cQcxmDrID+tPwPFKJo5gy4IC0VNpjmFXZzl4ukwqHhX0kJRWeBwfN28DOsUyAf7x8WHCqsbs8mwmFMQ+ZNMfmZYs2vUclVxD04jk3IxkGXiEiSNdMfXWKmjZwyEn3Po62MqEARNoCdLW0N4lJJWcXhtIgLDUypUreeihh/jTn/7E9u3bueGGG3C73dHqqauuuqpbwvEFF1zAH/7wB5544gn279/Pq6++yo9//GMuuOCCqJGTqJj8wjJuMxpT0nMTT4QyuPj/O+igwx+bJ7Zmb0t3RfBEIeK5UYWcR7u/DV/IG/PdtHgCKEZXfLsTH0256HdzvLKDJleAFneAEj2pWJaDjzC6cePKHU9HQDTvm9QlJ+TZzeL8X3L86HtvQYR0fBaR/JpraB2RUvBIzs1INmGNVky17I794E074a1fAvDtl6AjAPYyUVHmPeTjrY92se2wE6NB4fw4eN9iRdwbrSxdupTGxkZuu+026urqmDNnDi+99FI0yfjgwYPdPDW33noriqJw6623cujQIQoKCrjgggv4xS9+Ea9DGBC+YJiMcCuYRAO/CdJzE1NybLls1/sGRWLt2fbhVxm0+1sSSlcqiu65qaARI6WE8VLnrqM6e1zMdqFpGq0eFw6jP76K4EdTfjJsfpj5lj3gFUnFJfq8pOdmhNGNm/22bHBHmveJ79nu+g62HmrHZFDi+sQftIq8ylyljZ0j4rmJdCceuXYekUZ+jd4G2nxtOHTNrGGjaSIcFQ7gLT+TZ3euBzTsuufGfzjAnkA24OXUifnkjXKfolgSd+MGYMWKFaxYsaLH99avX9/ttclk4vbbb+f2228fhZnFjjZPF9FMg/TcxJo8ex7txq4SDIGYJDR2hNoSMucGXV+qXGnArE4nbPBS5z4SU+PG6QuhGkRfpoJIE8OE8NyIpOIZ2k4MhNnV0EFpll4OLiumRhbduPlQEd+Jrvk2z+hem0VTCshNj1/ifdieCzBi1VIj2eMmQro5nbKMcg65atnTtpsTi0+KzcAf/w32vw4mG/ZL1/Cg8jrLly/Hpntuvnz2V1hfI0K9ydi4rytxD0uNFVo8AXINIizVajSRq38BJbEhx9a1SqItZvpSvlB7YubcZFegKQasShCHXzx1xbpLcYs7EJVeKAjryfqJ4LkpmA6WDOyah4nKZ+ypd8mcm9HA3QQdwoB53S8qPyPGjapqPL9FvHdxnEJSUdKE0ZGjdIxQzs3IJxTDCHQq9rTAy3pblDNug5xx0SrXsuPE9/qMhZexp8GFxWTg3BnJ3YtNGjejRKs7QJ6uK+W3ZkZduZLYYDKYCdoi7ujY6Uv5NWdnj5cEUASPYjQTzhA3kTy3SJ6uj3FScYs7IEQzNY3ckC5pkQieG4NRr5qC45WdeiO/iASDNG5GjIgSeM54tncI2YVI87539zdzuN1Hps3E2VPj+xBg0B9CcrSREc8cDc8NjEDF1NpbRMVuwXRY8N3o4oz8DDpU4aH9uEY8KJ05pYAsW3Lfo6RxM0q0eAJRRfCwPXUEMxMJTX+ScigdtHtioy8VxpmYOTeAQe91UxTtdRNbz02rJ4DB5CJDVbFocVYEP5pIUrFhZ7deN23+VrzBgevgSQaBHpJqdVQe07wvEpL6wswSbOb4FnaYdQM8R/OOaBO/kUwohs6Kqd0tMTBuDr4Dmx4Uf39hdbd+XfvaRH+b4vQSXtoqHsCTPSQF0rgZNbrqSpGeAF1uU5DIE5sDV0w8NyE1hGbwJGbODZ29bkp1r8pIeG4UY5cycGs2mEe/62yP6Hk3c5SdNHT4CYdtZFqEavGRESqLH/NEk4nFeY6UgHsDYf69VZzzuIekAFummEMaIfze2DZ19AQ9ePWqxJH23ETCUnvb9hCO5LwNhXAQ/vkN8ffxX4Oq07q9va9tLwD51ko+a/WSZjFy9tQE8lIPEWncjBLN7gA5iC+aMT0BXPspiEUXz8wgQIdr+Be1+o4WrFqYDE3PN0kw46azHFwc64jk3HRt4JcIIakIZcJzM9lwkAw87GnokOXgI41u3GxShLEbybd55dM63IEw5Tl2TqyKv1c6I7OUSCMIo78lZj2vAFr0fBubyU6aeWQ7MJdnVmA12vCHfRxy1Q59oHfvgYatYM+Dxb865u29uufG6xHXt3OmFWG3JHZblYEwdo2b+m2jujtnh4sMxBO2Va/skMQWe2ZJ9KIWdDUOe7ya9npy9B43msEEsSrHjBV6xVSZKlTQ6911MW1kGcm5Sagy8AiZxZBdhQGNmcpuEZpKl+XgI0bQB43bAXjNJ5KJI7ILnb1tykZdBbwncmx5tOndynNw4grErktxk0/PtxmFalejwRjVeRpy3k3bAVj/E/H3uXdCendvU037ft74TIif7jsimi4mc+O+roxd46Zm/ajuLtgh2uOHgIzM+LtuU5Fcu1AEBlBjIJ55qL0hWimlpBcKVepEItrrphlQ8If9tPlbYzZ8i0dUSyWk5waioanjDTvZVe+KqoPLpOIRoPET0MKEbTnsV/3R5n0NHT7e3C0eJBIhJAXgsDk6KydjXA4+WsnEESblDqNiStPgxf+GoAeqToc53QWwtzRsZtm/r6TB00C+rZSmxslk2UycNml0jm2kGbvGTd1Ho7o71SWedtqMJnJH6Ysx1si150X1pXAP37g53NFFNDM9AWPQeliqhCasqsiDiKUMQ6selsoLJYj0wtF06VS8u6EjmlRcJ3vdxB79etniqABFiTbve+Gjw6gazKlwMC4/Pc6TFDhsuVHPTa7SFlPjpiXawG90+pRNdOgVU0NJKt7xPOz6BxjMIom4y8PZazWv8M2Xv067v50Z+TOZYfoxmmrn/ONKsJqSPyQFY9i4CRz+cHR3qH8pWg1GqSs1QuTacjuVwf3DVwZvcDcnbDIxABklqAYrJkWlICCacNW5Ypd30xxNKE5sz80cwy721Mty8BFFz7fZaxV5JpF8m0hI6tLjEyfU7rBmR68DsdaXGrDnJhwCf8ew9xeVYRis58bfAf/+b/H3Kd+DgmnRt/72yZ+55Y2bCKgBzqg4k/9d/BCvfyoqDFMlJAVj2Lgxt+2BQGwz6fvCpH8p2lJUETwRyLV1dik2+4Yfnmn2JrhxYzAQzqoEIN8jvsr1ntgZNy3uDgzGQOIogh9N8fFoBjMFShtG5wGyzOJ/dEQmFMce3bj5QM8bnFkwi511HXxy2InZqPCFBCodNhnMePSqvlxDS2yNG70MvN9r+F/Ohd8UiY7AwyDS6+aQqxZ3cBD3q/U/AWct5IyH028FIKyGuWvjr/jtB79BQ+OyKV/h14t+ywc1blo9QfIzLJw8LnWay45Z40aBUQtNaZqGJaB7bozGEe9sOVbJtXUqg9uCLcNOrm3ztyZsj5sIxlwRmioOiNygOlcMw1K696sg0qE50cJSZhtK8RxA5N14PNkAtPha8IV8cZxYiqGqUePmrZDwRswsmM0zm0UFz6IpheTEUW6hJ/xWEabNVVpx+mKXUDwgRfCgFw68ASEvPPNf8PJ3hSdnCDhsORTYxbUn0o+mX45sgXd/J/7+3H1gtuML+fjBGzfx+Pa/AvCtuSv5/vwfomoKj75TA8DnZ5ZgMqaOSZA6RzIU6jaPym7cgTDZmu65MZjItaWOdZxI5No7qySyaMMTGEZvCKAj0EqumoDSC12I9roJiifqWOXcBEIq3nAbQOKGpaAzqVjZyaEWSDeLig+ZdxND2mog0IFqMLPfbKEsowyHNY/nt4hzfEkChaQiBPXKxlxDe4xzboTB36dx07QTNBV0IV823A1/PQ88zUPa56TcQXQqVsPwz+WghWH6ZTDpPNp8rXzzla+z7uBrmA1mfnH6r7nquGvxBVWW/2UTb+xqxGhQuOzEiiHNL1EZ08ZN4LMPRmU/re4AeQbxwXZb0rAYE+spJ1Wwm+y4TCL3JNfQPOxGfp5we8J7bqK9bsIiZh6rsFSkO7FVVclQE7AUPEKXiqm9jW6ZdzMS6F6b5qxiworCzILZvLuvmTqnjyybibPiLLfQE9oIiWcOKOem8RPxK/t4wpc9BeZ02L8WHjxxSNGCQXUq3vQgHNoIlkw47x5qnZ/xtX9fyceNH5FpyeS+cx5kybjzafMEuGLNu7y+swGrycAD/zWX40qzBz23RGZMGzfez94blf20dNGVCiVar5QUQlEUVP385ijttA1TgsGvtid2zg1Ey8HLNdHrJlYJxcf0uDHZwJaAFz+9Ymq6spd9dc0Up0vjJubomlJ7uiQTR+UWZpUmZHWNoneBz8EVs5wbTdMGZtw0COPmlaY8rnm3gvYr/iNyX9pq4I8LYNuTg9pvpGKq33Lwjjp47Rbx99m/YJu/mWv//V8cdB6gOL2ENef/hROKT+Rwm5cvPbCBDw+2kW0389jX57N4WgJWgw6TMW3cZLTvgpB/xPfT4gmQq4ibj5om821GkrD+xJajDP+JLURHp+cmkUQzuxLx3GjCeG7yNhIMD/9i3uoJoBhdXURDSxKvzw9AzniC1jysSgil/qOo56ZOGjexQ/fcvK+Ja+XknOP49zYR/kzEkBSAUW/dkKN5Yua5cQddBFTxwNRXQnGwbisAu9Qq/rOnic//vZUdF6yFCeeKPJynvwKv3ixCSAOgs2Jqd995hC+vBH87lMzljaJpLH/5a7T6WpiSO41HP/c3xjsmsLu+g0tXv8OeBhfFWTaeWr6AuVWpmSYxZo2bNsWAUQtDw8h3Km51B8jRdaWUNKkrNZIY0jqf2No8Q7+o+UI+NLzkhhM75ybiuSlWWrGGDWhoNHjqhz1sc1R6QT+HiZhvA6AoaGXzAChzf0yeTVR0Sc9NDNGNm60GBavRxr7D2XgCYSpz05ibAHILPWHJFEZujuaLmYhuk+61STdnYDPZel0vXP8pAIct46nKTaO21ctFj27nuRkPwSk3i5Xe/jX87fPg6b9lRXX2eIyKCVewg/revtt7X4Vtj4Ni4NWZl/C9N7+LP+xjYdkpPHTeo+SnFbDpQCtfemADR9p9TChI5/9uWMjkoszBnYQkYswaN3ss+ofzyMj3u2nxBMjVdaVMiXqTSBHMuofFoXmGlXPT6m0hU1Uxoz8pJapRmpZH2CTCBSVBUf5aHwONqdZjpBcSrAy8C5aqhYBIKiYsbrZH3LIcPCZ4WqD9IAC7rDam503n+S3iBnvx8WUoiejNA+x6iwQLKgGvMyZjDqiBX9CLtWM/AObiGbyw4lQWTS7AF1T5zlNb+anvSkKXPAYmO+x9GR46Ceq39rlfs9HMOP0hpsfQVNAH//omAFuqT+GW3Y+jaioXTrqEu8+6lzRzGq/vqOeKNe/S7g0yp8LB08sXUuZIEBHcEWLMGje7rMK4ady+bsT31eby4tBEaapVSi+MKBb9/Gbjp93lGfI4h12d3Yk1axaYe39SiyuKQjirGoAin7jRxKJiqtmtSy+EEjiZOEI0qXgHHq/IC5Kemxih59u02h24DUYmZB/HW3t0uYU5iRmSAsjKKManG16Kd/jdygGaB6Ir1bQDBY1WLZP8okqy7WbWXH0SK84UGlGPvFPDFe9W0/rVN4Q2XOs+kYfz6f/1ue8+m/m9tQpa9tBuyeDbqpjjN+as4NYFP8FkMPP0plqu+8smfEGVM6cU8NjX5ydc6f5IMGaNm51G0SrcXzvyScU+Z2P0RKdnV474/sYy6ZmdF9yAa+gXtc/aG6KimQkbktIx5o0HoNgvvEyxUAfv9NwkeFgKoOwkVBQqlXq8TSIE0extwh8e+Xy6lEcPSe22iKd8p7MMVYMTKh1UJ4jcQk/k2Du7lZt8w+9WDqKpJ9B3nzI9mXiXVsn4QtGWwGhQuOncKTzwX3PJsJp4b38Ln/u7k22fXwvjzoagG/7+JVh7a695OL1WTDXtRHvrlwDc4cjBZ7Tyk1N/wddnLwdg9Rt7uenpjwirGpccX8aDV55ImsU05HOQTIxZ42abV3xAC/0Hh9xgaaBEFKrbDUZy0xPXvZ8K5KQX4jSIj3WoY+jGzZGOpqjnRkl04yZXGDelQWGIxMJz06KXgucloiL40diycaaLJ2Pr4W2k6WG6WDY0HLPoxs1mRdx0N+0WnrFLTkhsD7TDmhPVmTP7h9Zf5miao2GpvsrARb7Nbq2SCQUZ3d5aMqOY5765kPEF6Rxp93HJn3fy1LSHYMF3xQr/+QU8/kXwth0zbMRz0y0spWn4n/8aSjjA2/YM3s0u4XeL7+MLE76Iqmr84sXt/PKlHQAsP308d102G3MKNenrj7FzpEex54gZl2LAooWgacfI7kw3btoMRim9MMIIfSlxUQsPQxm8ztWU+D1uIujx+NKwCH3GIuemye1EMQQSu4FfFwLFJwHgaNlMsV4xdUSGpoaP3pdlp8VGgb2UnYfBYjTwhZmJ/XnIseVEPTdZWhO+4PAaesLAetyoeoHKLvVY4wZgYmEmz3/zFM6ZXkQgpPK9Zz/lR96rCV34Z9FuYfeL8NA8aNzefTu9HPyAs4ZAWHgnD7/za6yfvYNPUfhj+Uz+eP6fObl0IYGQysqntvDHt0Tuz48+N41bzp+WsPlRI8WYNW6u//wydup5N9qRTSO6L8WnGzdGkxTNHGG66kspwzBumj3NXSqlErQMPEKkHFwVFXkxybnRn1Lzk8FzA9jHi6Ti8f5tFKWJuR6WScXDIxSIeiJ2WWzYVOEhPHNqAY60xM7ZsJnsdEQbesZGPLNF15XqK+cmXCfCUgeN1RRn9Zynl2kz88AVc1m5eDKKAn977yBL35tA89LXIbsSWnbDQ/OFqrdOQVoh2dZswlqY/e372Lj3ReyvC82oZ4un8cuLnmFS7hTc/hBf//MHPLflMCaDwm+/PJvrThs/7GNPRsascXPR8YvYqceR2/ZtGNF9mX2iukDqSo08ufbcqL6UcRju6BZ/S+I38IvgqAagXO91E4ucmzZ/C0ZN6/ReJbjnJmPCqQDMVnaRbhDfsSMyLDU8Gj8FNYjHaKHOZKa2XnwPLj4+sUNSEbwWkROUa2iJSa+bfj03AQ8mp/CWBPOmYTD07ikxGBS+dfYk1lx1Ipk2E5sOtHLeU262nP8qVC+CQAc8cRGs+wmoKoqiRPNuVm++j8PPXUlOOMRhu4MLrnqTovRiml1+vvrHd3lzdyN2s5E/XnVi0vyvRoIxa9yUZZWwyyyaF3kOvj1i+1FVDXtY3Gw6TDasRuuI7UsC2VYHbUYzAObA0Pu9dARak8i4EZ6bXMVFmhrGHXThCnQMeThN03AFhWioAUAxQFofeQYJgFJ4HD7FTqbipbBD3MikOvgw0fNtdlpsoCi0tpXisJs5c0qCtkU4iqAtC4BcpQ2nLwaem/4SivVKqRYti7zCgek0nTW1iBduPJXJRRk0dvi57K97+Ovkh9Dm/bdY4Y2fwpMXg88Zzbtp3/MiF3WIJOnCLz9Dhj2P2lYPlz2wgY9q28lJE12HF01J8OvWCDNmjRuAhowZAOQ6dwnl2xHA6QuSq4gPYsCaug2TEgWDYsBnFgmlaeGGIY/jDrYlT86NLYugRfR3KQsIr9VwvDcufwjN0KXHTXoRGBKvxX43DEYOpx0HQHGLMGplOfgw0Y2b7WYzBiyEfCV8YVZJQsot9EQ4KsUy/G7lqqbS7OsnobhLMvH4HvJtemNcfjrP3nAKn59ZQjCsces/dvJ9zzICFzwMRivsfAH+OJ85xnSMmsYPm4TRrs25FtO4M9lR5+TS1e+wr8lNmcPOU8sXcnxlYjZXHE3GtHGTXrwQn6JgVwPQMkA5+UHS7A6QZ9B1peyp2eY60QjqGkhZtA45kdCrtpObJKXgAOHsagCKfRHjZughmZZkKgPvgrvgBACKWz8DpDL4sOniuQl6ywBjUoU5NN3bmEvHsI0bp99JSL8e5Np6uY7rgpm7tQomFA7cuAFIt5r438uP55bzp2JQ4KlNtXxpwyQaL3sVMsugaQdnv3IrD3lVJgb9YM9DOefXbNzfwmUPbKDe6WdKUSb/942FTBzkvlOVMW3cLKw6id16p2L18MgkFbe6A+QiOmRqUldqVNDs4qllqE9smqYR1JzkJLr0QhfMeq+bokCkkd/QPTctbqErlRQN/Lpg0jsVV7nFg0qjpzFaWSIZJJoWbeC3y2LD76mkOi+NEyod8Z3XIDDo39sc3Di9w2v3EUkmzrJkYTH2kkwd6XHTS6VUfyiKwvLTJ/Cna+fhsJv5+FA75z3t44PzXoXKU1H8TmbV61VU597JyzUh/uvh9+jwhTipOoe/L19AcXaCNhuNA2PauDl7wons0JOK63a9MSL7ENILLgCMSXCTTAUU/Ykth44h6Uu5gh2YCJKtJo9xE+l1UxYUF/HhlIMfowieJJ6bgimnATAufJAcxYyGFpOy+DFJ+0HwtRFSFPZbrIS8lVx8fHlSlRObdKM8R/MO23MzkDLwcL0oA9+tVTEub+gNDk+bVMA/VpzK9JIsmt0Blj62n4cnPoR24g1ihfGLeSJ4Jjf8bROBkMriaUX85Wvzybabh7zPVGRMGzdZ1gx2m0VTPV/tOyOyj1Z3gBxNyACYdDE3ychijOhL4aHNO/gn9xZvCw7da6MpRkiGcKJeMVUa9gLDDEt5hPRCUjTw60JeSTWHKcSgaMxTReL+YZlUPDT0kNQ+s5WQYiDoreTiBFUA7w2b3q08W/PT7hlet+p+uxMHPBjaawBwZk3GbhleXlJFbhr/942FXDSnlLCq8bN/7+U7ruvw3bCT+8t+xw+e3YaqwdITK1h9xQnYzMmRBzWajGnjBqAlayYABc49whUb6/HdAXJ1XSlb1sAy6CXDw6LfjB2ad0iemxZvc/TGrtrzwZAEX5NorxvhJawfhnHTmiyK4EehKAr7bSKp+Di9OuZIDHr+jEm65NuEAznMLa+kMjctvnMaJHZd6saERtDTOqyxop4bWy+eG71SqnkQlVL9YbcY+e2X53DbF6ZjNCg8/9FhTv3jAX79mig3X3HmRH55yUxMY6jr8GAY82clu/wMQkCm6o2q38YSd0cbFkQlVrr+dC0ZWeyZ4uLi0HxDemI70qU7sZKR4A38Iujl4OVaG2jDC8c0J5Ei+NG05oik4onuNkCWgw8Z3bjZZbElpdcGwJFejEsRtzhV7xI/VKIN/Hrz3OjJxHu0SsYXxE5zS1EUvnbKOP62bD556RaaXAEUBX5ywXRuOndKUoUJR5sxb9ycMWEBe/WkYv9nG2M+fqBDlKX6FAVHRvJdIJKRDEcVAEbA2zF40bxDzk5FcENG4ufbANGwVAZ+stUw9Z56wr2I8PVHo9uJYggmXUIxgFo2D4CJnnrQNFkOPlS6GDeav5ovzEq+kLrD6qAt0q18mMrgnTk3vRg3XQQzh5JM3B8nj8/jHytO5aLj8vjWbAuLK2V+TX+MeeNmQeUMtpuFpf3Z9ldiPn5YN25aDaa+BdckMSMnvQS3/sQWcA6+kV+9q5GcJEomBsBsw28XXqbSYJCQGoo+bQ6WRncjaFpnzk2ShKUAcsbPJ6CZyAm7KAkFpb7UUPC2QVsNALssduaWzEnKZNUcWw7tus6cwTf0nlfQJeemN+mFxq6VUiOjlv7v/3uMe686hZVfOZeqqirWrFkzIvtJFca8cWM2mtlvFb0bQoffi/n4mkfE/FuNRqkrNUrk2nKj+lIh1+Cf2Bo8zcnTnbgLqt7rpjQgbkRDTSpu8TWTrYaxoOegJVFYamJZAds1EaI7zu/liOx1M3jqPwbgsMmMU7Fx+ZyT4zyhoZFpyYoqg1sCw6ua66+Bn9bQuxp4LKitreX6669H1ZvNqqrK8uXLqa2tjfm+UoUxb9wAOB2zASjs2BvzsU1+8eFrN1mxmewxH19yLDn23KgicMgz+Jtbq681eboTd8Gi97op1tOMhpp30+5v7cy3seeCKXkkQ4qzbGwzTANgpt9Do6eBYHj4rffHFHpIarfFBoEKzp6afCEpEPkqbr1buX0Y3cqhn1LwgAfaRJLvYct4CjNj/33ZvXt31LCJEA6H2bNnZJrPpgLSuAFyqs8mDOSGPdAR2+oKW0iERbzm5Ko0SGasRisdeqMtxTf4hNJ2f1ddqSRJKKaz102p3pV5qI38XKGWpCsDj6AoCvVZcwA4zu9D1VTqPSnQ62bTQ7D6eKj7eOT31aVSakL2DCym5L1N+C3Ci5KhNhNWh1YNG1bDtPlEtVWP3vem7dFKKUd+2Ygk+U6aNAnDUVWbRqORiRMnxnxfqULyfmpjyFlTTqfGLKxtZ03s+t0EwyqZqnBnBnRJAMno4NGNyaGIZ7pCSSSa2RW9HLw0JFw3QwlLBcMqAc1Jfii5ysC7Eig6EYCpAS9mTaUuFdTBN/6vMDqeugz8rhHdVfjIZkDk2yyZNH9E9zXShOziupurtNExRPHMdn8bYS2MgkKOrQfNpoaI7MLIhKQAysvLefDBBzHq4Xaj0cgDDzxAeXnyyGGMNtK4AWYUVrHTLBRk93/yYszGbfUEyFXaAFCToRFcCuGziP+nNTT4nBtvuJ3cJJJeiBIpB4/2uhm8x6LVo0svJGEZeITc8mm0aFlYNJXJAV/yN/ILB6FRb7vfvAv+dcOI9OQCIBToTI612PjitIUjs59RQtUlb4YjnhlJzM+2OjAZekis1gUzd2lVTCgcmWRigGXLllFTU8O6deuoqalh2bJlI7avVEAaNwhX9gGbaPik1b0fs3FbuuhKkSYrpUYTVVcEzggPrnlXSA0RVDvISSLRzCgRz43mRNG0IXluWt3Bo3rcJJ/nZlJRFlvUyQAc50uBpOKmnaAGhUK0YoSP/wpb/jRC+9qBUQ3iUgw4rWUUpBWMzH5GCUXPkcnR3EM2bpr6KwPvUik1Pn9kRSvLy8tZtGiR9NgMAGnc6HhydUVh1/6YjSmMGzcAxiR8Ak5mFP2JLVNzEgyr/azdSbu/jXQtjDXyZJyeRBf3rApUxYiVEHnh0JByblo8ke7EyVcGHmFiUQabtSkAHOf3JH+vG716idIT4cyfir9fvLHTmxND2vaLh7udVhvHlxwf8/FHm8h1NwcPTt/QxDMjZeC9GTdaQ6SBX8WIhaUkg0caNzpFE5YAUBxygWdo/UGOptUTJFfXlbJkygZ+o4k5UyQCC0XggT+xtfpaopVSYVMaWEbOzRxzjCb8aaKypSwUoNXXgi/kG9QQLe4ABmMHeZEKoyT03JRl2/nUMB3Qy8FTxbgpmgWn/gDGL4agB576MgS9Md3VgU9FzuFui435ZSfEdOx4YMkcvnhmi7ePMvCAG0WvlNpDFVV5snAkUZDGjc6Z08/kM5OosDm887WYjNniDuDQRHKnTdc5kYwOnRc1D22DuKi1+Fqi+TZhexJ5bXQ0vddNSUB4qxo8g0uobnb5hecmlLyeG4NBwZMvvA4VoQBuvSFd0tLVuDEY4eK/iHBpwzZ46X9ithtN01C7JBPPKpgTs7HjRUTPL0sL4HQPzRDsU1eqaYf4pWWTllMiBSwTCGnc6JRl57LT7ACgZntskoqdHS4yNXGTyJC6UqOKPVPEpLM136DEM1u8zV163CRPGXgES/4EAEoC4qs92LybBpeQXkjWUvAIJcUl7NaEt7So9QAhdWghiYSgq3EDkFkMl/wNUGDTA7Dt7zHZzSeH26kO7gJgny2LybmTYzJuPMnIEg+VBsDfMTQJhkgDvx4VwbtVSiWRl3cMII2bLtSmiYRMQ/2HMRnPp7f+DwEO/YlaMjqkZQt9KYcaGJR45hFXU/TGbsxMPuPGpDfyKwkKz81gy6DrXA3YVJUMTc9TSkLPDcCkoky2qFMBmO53DdqDlTB4WqBDr/YqPK5z+YTFcNot4u9/XAct+4a9q7XvbSJHcRMCbCUn9FwZlGQ40gpojzT0HKJ4Zp8N/BpHvgxcMjSkcdMFf/5JAJR6DsRkvIBTdCduM5rITfKqg2QjSy+LtqDh6mgb8HZ1HZ2K4Mlo3ETKwcuivW4Gl1Tc5G0iP5JvY04DS3JesCcVZrBZN25m+jzJm3fTsFX8dlSDLav7e4t+ChWngN8JTy8VZdxDJBRWqflE5NvsN1uZVpT8+TYADltOtFu56hpal+KoInhPulINXSqlpHGTUEjjpgvlkz8HQGWwg7B3cCXEPRHWjaR2g4k0k0w0G01yMsvw6Z1CXW0D73PS4G4iNxnLwCPo5eBlYZHIPtjuvC2+lu5l4CPQbXU0mFTYWTE1w+/lSEeSavAcHZLqitEEX3pcSGQc/gBe+8GQd/PWnibK/TsB2GW1M6tg9pDHSiQc1uyoMnjYM7TPQJ/VUo0yLJWoSOOmC2ccdyZ1RuGK3bntX8Mez+AXN9UOs31EWnJLeifDkhVVBHY7awa8XXOXaqmkNG703K5irQOjpg06LOUMtCR1MnGE8pw0DhjH4cFEhqbi0RNlk46+jBuA7Aq48BHx97u/hZ3/HNJuntl8iOkGoa23y2JjZmFqGDcmg5kOow0Ag3/wfZ9CaigqvXBMzk3A3ameLsNSCUdCGDf33Xcf1dXV2Gw25s+fz8aNG3tdd9GiRSiKcszP5z//+WHPI8NqY5dZfIAP7Xxp2OPZAhFdKfmhH20URYnqS4Xcnw14u/Yu1VJJadxklBA2WDChURQKDjqh2B1q7QxLJWkyMYDRoFBdkM02g+hzYj0Smzy6UUc3btqzpvGPjw+zq74D9WiNpKlfhJO/I/5+7mpoH5yHwuUP8cqndUw3CBHG5uxy8ntRv05GIuKZlsDgw1JtvlY0NAyKAYf1KOkFvc9Qk5ZN2JZHXrpl2HOVxA5TvCfw5JNPsnLlSlavXs38+fO55557WLJkCTt37qSw8NibyzPPPEMg0Blbbm5uZvbs2Vx22WUxmc/h9PHgq8PSOPwnPXtY6krFE5fJDgE3mmfgN/iOYFtSV0thMOBPryCtYy+loQDbPPVomjYgz6GmafjV9qRu4NeVSYUZbGkfxzxqyWlOQvVkNSzKvYE7PjTz5H5xTcq2mzmh0sGJVbmcUJXDnHIH9sW/hAP/gSOb4P8uh6vXibBVP9TW1vLI+u2Ygi6qrCJx1l6W3HpSR+OzZAJgDw2+f1mkO3GOLRej4agy76OSiaV3PrGIu+fm7rvv5rrrruPaa69l+vTprF69mrS0NB5++OEe18/NzaW4uDj68+qrr5KWltarceP3+3E6nd1++kItFF/scs/An/Z7whsIk6O1iRdpUlcqHkQ8ZqZBiGd6wm3JKZrZBU0PTZWGgvhCXtr97QPazhMIoxmcSV8GHmFyUWY0qbjCmYT6Uq37IOhBM9l45oAIrdjMBtq9QdbtbOQ3r+zk8ofeZeZPX+bCB97n3rz/R9CUAQffgjd+2u/wa9asoaqqivtefJ+pimhEV2c0MaFswYge1mgTGqIUCwwwmViTycSJSFyNm0AgwKZNm1i8eHF0mcFgYPHixWzYsGFAY6xZs4avfOUrpKf3nMy1atUqsrOzoz8VFRV9jjduxkUAVAc78HpaBnYgPdDiCZCrdABgyEjOm2SyE7AIj5k1OLD/oy/kRVO9ZKtJHJaia68b8XqgoakWd/JLL3RlYmEGm0Mid6TS5yLsG5iRlzDoIam29EkEVQNTijLZevsSXrjxFG77wnQ+P7OEoiwrIVXjo9p27toUZqX3BgDUN3/B/Q+v5i/vHmD7ESfho0JZtbW1XH/99SjpuVgrZzJdieTb2JmZIsnEUSJSLKoTbZCCo32XgQvBzN1qlUwmTkDiGpZqamoiHA5TVNTd/V9UVMSOHTv63X7jxo1s27aNNWvW9LrOLbfcwsqVK6OvnU5nnwbOiVMW0mwwk6cG2bzlWRYuHJryaqs7QK4mdKVMSX6TSFbCdhEjTw+3DWj9Vl8rjnAIA6ChRPWpkg2z3uumVO9SXOc+wtS8af1uJ4ybDvJDkZyb5NZDm1SYQV2okjqLmeJwkJb9a8mddkm8pzVw6kUZ+KdqNQBLZhRhNhqYVe5gVrmDr50yDk3TONTmZdOBVj440MoHBy7g8caPudz4MpcduIXzd2fQRA6ZVhPHV+YwtyqHE6tycO7fhaqqZM1YhKIYmBZ4D8ywx5rGgpwpcTzo2NMpxeLCEwiTbh34bS9SKdVjA7/GTs/NadJzk3DEPedmOKxZs4aZM2cyb968XtexWq1YrdYBj2k2m9htySfPd4T6Pa/CEI2bZneAck20+7ZkSgXXeGDUewtlqn2HIiO0+FrI0b02AWsu1qNj7MmC3uumVO97Uj/AXjfNLj8GoyupFcG7UpmbhsVo4mOLg2JvI76adZBUxo3w3LzZLv4P504/1thUFIXynDTKc9K4cI7oyNzR8STuPy6goH07j2Tdy+W+2+nwh3hzdyNv7haN7IwKlFxzD4YMETKfpldKdTgmYDYmf/O+rlgzhd5ajubF6QsO0rjpRRHc74pWSu3WKqTnJgGJa1gqPz8fo9FIfX33nIj6+nqKi/t+anS73TzxxBMsWzY046Mv6tMnApDW/NGQx2h1B8jRdaXSpK5UXLBmic9Qluo5tsKkB1p9LdF8m5AtiZsuRnvdCON6oI386lxtmJVA1MBL9rCUyWhgfEE6HxlFeNFw+IM4z2iQ6MbNx6EqSrNtzCjN6mcDQWZmNulXPA0mOzP9G/norC38879P5acXzOCCWaWUZtsIa2ApnogpIxcl6GGazQVA9rgzRuxw4oU1Sxh9Ds03aPHMqOfm6JybJlEp1ag5cBocVOZK4ybRiKtxY7FYmDt3LmvXro0uU1WVtWvXsmBB30ltTz31FH6/n//6r/+K+bwMJQsBqPQOPQmxxe0jWxVfpMzs8TGZl2RwZDiEUenQfHT4+9cW6q4rlcTGje65KdQ8WFV1wDk3h50NncnEBhP05IpPMiYWZvCxIj4HWQ2fwiBzLuKG3wWtwpuyU6vm3OnFg6vGKZwOn/tfAIzrb+O40DauXljNvZcfzzs/OJt3bj6Ley8/nqWzC7h9VjtWBdyKgaqqM0fgYOJLmq4vlamFcLrcg9o2klB8TGl8F02pqtw0LKa41+ZIjiLu/5GVK1fy0EMP8ac//Ynt27dzww034Ha7ufbaawG46qqruOWWW47Zbs2aNVx00UXk5cX+AjzpuIsAmBBw0egcfOMnAFdbLZGghiN3YmwmJhkUWQ5dX0rz0+bpvzV9SxfPjSEzifNN0vIIGsWTZHEoOOCwVJ27qUtIqhgMcb88DJtJhZlsVScSAtL8TmgfXhXkqKGXgDeSSwvZnDtjCG0Jjr8WZl4BWhievlzoVOmUOuxcMKuUX31lHl85ThhNuy02ZhbOicXsE4rM7Ap0XyTe9sHpS/WaUKwnE4tKKem1SUTifvVaunQpd955J7fddhtz5sxhy5YtvPTSS9Ek44MHD3LkSHcDY+fOnbz11lsjEpICmDxpHh2KCQsa729+ZkhjuJ1CyM5pMJJuy+lnbclIEFFid6hBWty+ftevd3XqSpmzkti4URT8GeJptTQUoH6AnptmbxN5odTIt4kwuSgDb6iAXRZRSk3tu/Gd0EDRQ1KfqtVk282UmrysW7eO2tpBNOhTFPjCHyB3Ejg/g+ev7dFz1VLzOgC16Xnkp6AGXo4tPyqe6WsfnIBqxHNzTFhKTybeo8rOxIlK3I0bgBUrVnDgwAH8fj/vvfce8+d3NpFav349jz76aLf1p0yZgqZpnHPOOSMyH4PRwB6L+JK37H99SGOE3UJXymm0yOZOcSLLIcKBdk2jrq1/4cQGd3M0LGNKRtHMrkR73QRo9DYSUvvPNWj1N6dMGXiESYUZhIMOtll1bbdkMW50wcwdajWVJicTxldz1llnUVVV1Wd16DFYM+GyJ8FogZ0vwHu/P2YVTe/eHCiYHpOpJxoOm4M2vaGhfxAaY8FwMNoj6hjPTZceN9K4SUwSwrhJRBoyRTlkVuvWIW2v+MTNtMNkj9mcJIPDZM8lhDAsWwfQobbJ20xOMksvdMFaIHrdlAZDqJpKo6d/d3xHoKv0QhJ7rrpQlZeOEs5lq00YN9qh9+I8o4Gh6Z6bHVo16/58D6qqgiJyEpcvXz44D07J8XDuXeLvV74Hhzd12ZFGdmsNAOmVp8Ro9omFzWSn3SAqwPyugwPeLuK1MSomsqxdkrn9LmgXD6+7tErG58uwVCIijZtesJSdCkC178igGz9Bp46JV2/9LYkDioJTv6i5nQf6Xb3V15LciuBdMOfpxk1AfHYHknfjCbelTBl4BLPRQJWjhK0W/QZ0eBOE+s+/iiuahnpEVGruoRrPvg8ovaSQE9bMYNrPJlB6eSH/99FTUWmAATHvRph6MahBeGop+ER7BK3jMBkhH2GgYsL5I3AwiUGHSYQlByPF0qkGnotB6XKr7FIp1UaW9NwkKNK46YUpsy4EYFLAzZ6mvYPePl3XMQlKXam44tQvagFX/5VvHYHW5FYE70pOpNeN8MQMpGLKr7alXFgKYHJhNge0QtoMRpSwv1NpO1Fx1mIMtBPUjORVTMeghChcnIdiUEirtFO4OI+/ND3MeX8/k0ue/QI/f+d2/rn3BQ67DvX+IKYocOEayK4SVVj/XA6aRsO+lwE4aLExKdU6E3fBZRLGrdE38JybSDLxMfk2XUJSuekWcqRgZkIijZteKKmeg1cxYtc03v/4hUFtq2kamWqbeJGWOuq6yYjbqOdaePv2XGiahjvUnvS6UlEijfzCIpG6P+MmFFYJKx0pl1AMMLEwk3Aoh0+seog40fNudONrr1bO506czA/+8H2MaUYCzUH2/6GW49TZTM6ZgoLCQecBnt/9DD9560d88f/O4wtPn8Otb97M0zv/zr62vd2NHXsOfOlxUIyw7Qn4cE00mbg+syTlmvd1xWcWYSVrcODimc0RXaljKqU6y8BlSCpxSeoOxSOJYjSxz1LIDP8ROg6sB1b2t0kUpy9EriZ0pZI+MTXJ8ZqzwFuH0d93zokr2IFFDWCP3AySURG8K3pCcY7mJ00N99vIr80bFNILkZybFPLcTCrKQP00h63WNE7xuoRxM39FvKfVK201H+BA9Lc5e2ohW9whqIFzxi3hf57+HuXlouO509/ORw1b2Nywic31m/i06VPqPfW8tP9FXtr/IgAOaw7HF53AnMITOKF4LpPKTsJ09i/gtR/Av/8bR5qo5AwWzojPwY4SQb1iNS04cPHMXsvAIz1uZKVUQiONmz5oyZoGjUdwtH8yqO1a3QFy8ABgzSodialJBkjQKsKCtn4uai3elmilVNBgw2xJ8icyWxY+swNbsI3SAfS6aXH5MRo6UkYRvCuiYiqHrem65ybBk4qb923CAbgc00izhnmzdj0Ay067nvL8TimXLGs2p1WcwWkVoquwN+hhW9NWPqwXxs7Wxo9p87ey7uBa1h0UjVLTzenMzp/N9wtnUN7wCSV6H6+MilNH8xBHHVVvSJkeHpgUC4imntCD9EIXTalzZI+bhEUaN31grzgdGl9ngr+BQDiAxTiw2GqLJ0COritllbpScUXV4+Vp/Yhntvpaovk2fkse5hQo3w9kVGJrbaMsGOBwP2Gpwx2tOPB3XhAyktxz1YVx+ekQzuGTSDl4yx5wN0F6YoaMLU2igV/ehBP5T+2b+EJeyjLKmZbXd6m23ZzGSSXzOalEtNIIhoNsb/6ED+s3saXhQ7bUb8YV7OCdI+9wrS3MY0YTBfpnvnLSBSN7UHHGqHtis9SBdyju0XPj74B2UXG1W6tkufTcJCzSuOmDScd9Dj78CVP9HjYf3sr8irkD2q7VHaBUFbpS6Xp4QBIfjOmipDkz3PdFrWt34pA9NRqZKTnjofVjSkMBPuzHuDnYXt+ZTJyWDymUf2E1GSmwl+AyGjloSacy4IZDG2Hy5+I9tWNobe+gJHgAFJh5/On8dq+QUDh33PmD7pdlNpqZVTiHWYVzgGWE1TB72nazWffs/Jq1rDr4MXW2LMpTtMdNhIgH3aF6B7xNjwnFjZFKqRxZKZXgSOOmD7Kr5hDAQIam8sEn/x6wcVPv7OBUvaQ40yF1peKJTVcEzlI9fa4nFMHF/0xNkS6t1oIJsE9UTHUEOnAH3aSbe3ajH+loJD8U6XGTOiGpCONzKtimwscWqzBuat9NSOPmg03vcI6i0qFkkl1cxNtv/geAJePOG/bYRoORKblTmZI7la9MuwLtDI2G2rfIy0h973JmVGfOTzCsYjb2X0vT7BNyFd3CUtGQVAVmo0JFjuxjlqjIaqm+MJo5YBXuzEDtWwPerLH9AFY9MTVDGjdxJTNHXNSyVb9ohNYLrb7mTl2pFAnJWPJFr5uSoGhM2FfeTUNXXakUSiaOML2wEk0zsNWqyzAkaN7NZztEJVdb5jTW164nqAYZnz2BCY5JMd+XoigUVZyGXW8bkMrk5Ue6lYdpd7YPaJvOsFQX4yZSBq5WUZWXjmkARpIkPsj/TD+0ZYsqgryOHQPext0udKX8igEl2RNTk5wCvVOvQw3S5Onodb0Wb0u0O7E5KzWMm2g5eFAYLX2Vgzd7m1KugV9XphRlo4ay2BotB38P+jB244E3EI6WgadVzOGV/f8G4Nxx50kJl2GSk11BUO9W7m7tv9eNL+TDHXQBR+Xc6IKZu7VKJshk4oRGGjf9kFW1CICJgeaozkh/hN0i4azdaBXNsyRxI9MhXO6OcJgDbb1f1BrcnZ4bqyNFbu56vldZ2Aea1qdx0+5vScky8AgTCzNQgznstdgImazgb4fmnfGeVjf+s6eRidp+AGwV03nvsPDinFM9/JDUWCfHnkubUYhndrT2L10RkV6wGCxkmLt0me9SKTU+X+bbJDLSuOmHqhlnAjDV7+XtA5v6WVvHK24iLlPaSE1LMkAUvYlihqZyqA/xzEZPU9S4MWWmhq5SxLhJ10Jkq+E+w1IdwdaULAOPMKFAlIOHFYX6LBGqpDaxQlOvfFrPVKUGgI2qm7AWYmruNKqyq+M6r1Qgw5xJm0GkmDp1La2+iJSB59rzOr1mR1VKyWTixEYaN/1gKzueEAq5apgtu9YOaJtOXSn54Y879hwiwYe2lppeV2vtUi2V9N2JI5hteKziWMpCgT4b+XnDreSHUjfnxmY2kmkS52J7pPolgToVh8IqH366k0KlFQ2F59pEGPycGCQSS0R+UbvRCoDH2b94ZlNPZeB6SKqJXNrJlGGpBEcaN/1htnPYInIwwkc2DGiTNF1XKqB3xZTEEYORDoPoT+Ru7108sz2VdKW6EMioAqA0GOwzLBXQnF1yblLEc3UUxenCaNuk3+QSKan4/QOtFPt2AxB2VPNO4xYAzqleEsdZpRZOo8i3Crn611nruQxcGDc71AoAxkvPTUIjjZsB4MyZCUCxa9eAFMIzIw3jpK5UQtBhEBe1oLvnsFRIDeELtuNQRUJxKhk3SlRAM9BnWCpMe2fOTQqGpUCUgwO8Z9B9efUfQ2DgTd1Gklc+qWOaoQaAIxn5aGjMKphNaUZZfCeWQriMwtOiDEA8M5Jzk99DpdRutZL8DCvZ9tTpBZWKSONmAGRVi/bmU4JOajv6TkYLhVWyVVGVY06V3I0kx2XSn7C8PV/U2vxtZKlhjJEFKWSU2gpFtVhEgkHVjq0Q8vhDZBjaO3W1UjAsBTC9sBqAzxQXWlY5aCoc/iC+k0KItnbNt9mkCbHTc8edH8dZpR5eXTzT7OtfPLPZ24NoZhfBTBmSSnykcTMASqacBsAUv5c3avq+GLZ5g+RoomFcWrZ86koEIorAJn/PF7VWb2ellMeYnVrdefVeN6XBAEE1SIvemKwrB9ubKdA7amuWTEjR9gUnlI1D0xQ0JUig5HixMAGSij894uRQm5fpuufmrWA7CgqLq86N78RSDL9FpAn0pzMHncZNbk89brRKGZJKAqRxMwDMZcejAkXhEFv3/afPdVvdAXL1J680R9UozE7SH0FLLgC2QFuP77d00ZXyWVPHawN09rrRk4Xresg3ONhWHw1JKSnqtQGYUuRADQlD93CWMPoSIan4lU/rMRJmkuEzAPZYrMwtPon8FOmUnSiEbeK7nRbsvd9VhGN0pXxOcIr/zy6tSnpukgBp3AwEayYNFpGHYWjY2Oeq9S4XOaq4UaTLEs6EQNW1otLCPV/UWn1dFMFtKWbcdMm5UTSNes+xeTeftdendBl4hDSLCZMmnsQ3G4TBS+27MIA8upHklU/rqVYOY9H8+AxGDpksnCurpGKOYheFIRn96MxBZ85NXiShuEloSjUreTjJkGXgSYA0bgaIK3c2AOWefQQjiZc9UNvegEPXKJKimYmBMa1v8UzhuRHJxKo9dZKJAciqQMWIBZW8cKhHz02dqzGlpRe6km0W/98NIRMYTOA6Au2fxW0+n7V42H7EGU0m3m22YDCYOKtycdzmlKqYdZ257AGIZx7judFDUpFKKWncJD7SuBkg2dV63k3AzY7m3qUY6tqPkKm3dTekUNVNMmPPEl2Ks1V/j4Zpq6+1s8dNRoqFAowm3DZhsIheN8caN910pVK0DDxCUbq4we1zN0KxnndTsy5u83nlU5HkflaO8KjtttiYX3oyDtlGIuakZ+s6c2F/n946T9CDNyQMoGjOTaQzcbgCi8lAmaNvwcza2lrWrVtHbW3/3ZAlI4M0bgZI7sQFAEwNeFlf03unYpeuKxVGAXmBSgjSs8XTVnY4TGsPCbWtXRTBU6Y7cReCWXqvm1CQes+xFWMtvqaUVgTvyjhdjqPRewQm6j1k9rwct/m8/KkwauZaxU1wj8XGudWySmokyMkTIVoLGgRcva4X6U5sM9lJi3SZjyYTVzE+Px2joXdZnTVr1lBVVcVZZ51FVVUVa9asidERSAaDNG4GiLH0BADKQ0E+Pdh7EmLIJS5STqMVDPL0JgJpDhFrd6ihHquFWrpUS1mzU8+4ifa6CQZ6DEu1B7pIL6R4WGp6oTgXnnAjTNCNm72vQKTH0SjS7PLzQY34PBb5RE7HfmsGiyrPGvW5jAWKcyvx6VIKQWfvPZ+afHpIytZFekFv4Cc0pXpPJq6treX6669H1b33qqqyfPly6cGJA/LuO1DScmm2iJCFtaX3cnDFKxrFuaWuVMKQrhs32eEwda7GY95v9DRHq6XsOal3c7fryui9haXcwdaUVgTvygll4wHQjC205swBaxZ4m+HIh6M+l7U7GlA1OLHIgM0lrhv5VWeSYcnsZ0vJUCjLyovqSzU37+t1vZZojxs9JNWlUqo/Tandu3dHDZsI4XCYPXv2DGfqkiEgjZtB4M2bA0CV7xAdAWeP65j9QlfKIy9QCUPEc5OphjncfuwTW4uvhVw9odiclXo3d1vBRECEpVp8zQTCgW7v+9S2MZNQPD5HhKUUQ5AtdQ0wXk/cjUNoKpJvc1lFGwB1RhOnTb541OcxVsiw2mgziB5WrX0YN8ckE+temxZDPk4yGN9HGfikSZMwHOWxNxqNTJw4cThTlwwBadwMgozqhYBo5rel7uMe10kLCTdz0Jo7avOS9I2iP4EZgdbWY0Xz2vwpKJrZFT0sVRIUeTUN7u55N5raSnYkLJPinhuL0YJJcwCw5ci+LqGp0TVuPIEQ/9ktvIjTLZsB2GdN57Ty00d1HmONNoPQFXO19x4mipSBR3WlunQmhr4rpcrLy3nwwQcxGkW/c6PRyAMPPEB5efmw5y4ZHNK4GQTZ404CYGrAx/peOhWnh9sB0FKohX/SY7LgUoR4psfZ/aLmC3kh6CY9IkuQisaN3sivKBzAqGndQlOappGjiY6tqsEM9tRPgs/Sy8F3Nh3sTCr+bAP42kdtDm/ubsIfUqnIsaM2isaggfyp2M0ynD2StBvE+fU7D/W6zjGK4Hoy8SdBYaD015142bJl1NTUsG7dOmpqali2bNlwpy0ZAtK4GQRKyVwAqoN+dtb1HKOXulKJSYd+UQsdJR7Z6utUAw9iFjkYqUZGMSHFggkoCnVXB2/zOSkIC+kFNb0IlN6rQFKFojRRDn7QWQuOKsifCloY9q0dtTm88on4HJ4zrRBzo0gmLhx39qjtf6zSYRSGieZp6HWdqCJ4tAy8M5m4KMtKhtXU737Ky8tZtGiR9NjEEWncDIbMYpzmXAxAWuvmYxTCfcEwOarQlcpwVMRhgpLecBn1HKijLmotvhZy9TJwlyk3NW/uBgMuu9A5Kz0qqfhAW10038aQNTa00Koc4jgbvfp5GOXQVCissnaH+BxOKK+n0iceiCZO/dKo7H8s4zaJhxejt3fxzBavSC3IP7rHjVYlm/clEdK4GSS+/DkATAw0c8R9uNt7jS4PuZp4Cs7OrR7lmUn6wmt2AGAOdBfNa+3SndhryTt6s5QhlCl63ZSFAtR38V4d6KIrZUjxZOII0wqqAfBrTTh9wS79bl4aFSmGjTUttHuD5KZbcLa8SIamElKMWAqPG/F9j3V8ZhF2tfSiMwdHJRT72kEPZe/RKqRxk0RI42aQZFTNB2Cq38umIx91e+9AawMO/UaZJqUXEoqAWSR424Pd8yq69rgJpJquVBcMuaIEujQYpK6LcXPI2TBmysAjTMgRiaEGUyt7GlxQdQYYrdB+EJp2jvj+X/lEJHSfOSWPI/uFt8ifMy6l1OgTlYBFF88M9Kwzp2la94RiPSTVaiwQlVJ99LiRJBbSuBkkaVXzAJgS8PHmge6dimudDTgiLv5UTExNYjSb+H+kh9zdwomiDFz8z8L2FJNe6IK9SJSiloQCHO7SyK/O3UB+aGyUgUco1o04g7mV3fUdYEmDKr1KaYRDU5qm8YrelXhiRT0let8le/n8Ed2vRKDZRC5kei86c+6gC7+eg5Zn7zRu9irC8yk9N8mDNG4GS4noVDwh4GNXw5Zubx1y1nWW1Kal7o0yGTHoSaRZahBnlx5FrV2MGyWFDVK73uumLBSk3l0XNfCaPM1jQhG8K8XpunFjDPBJvW7odQ1NjSCfHHZyuN2H3WykIbSBiUGfmEvRnBHdr0Rg1LXFskK+Ht9v1nNx0s3p2Ez2aKXU1oDI05pQKI2bZEEaN4MluwKPKRsTkOX6hJDaKcToch4kmkcvS8ETClOGMFwc4TCtvs5kQqEILm7uxsyiuMxtVNDDpKWhAL6wJ9qEstXXHM25GSueG5vJRppR5F7sbNT7HkWSimvegGDPN75YEPHanDrJwRufrWVSQN9X0awR26ekE1uWKPTIUgNwVCdh6KmBnzBudoYrsJkNlGTZRmeikmEjjZvBoij482cDMMXfwZ7WzrbaAb1Ft9tgAZMlLtOT9IwpQ1ysstVQ9OkMuntuLFkpXL6v97opCIewqmo078YZaBkziuBdKUoThtyBSDO3whmQWQYhLxz8z4jtN9KVeGLFYfy+NiqCerdoadyMCpnZIvfMCGi+1mPeb9Z1paIN/LoJZmZg6EMwU5JYSONmCKRVdTbze+9QZ78bxSdc3C6TTDpLNKzZunjmUcrgLd4WcvRQYirqSkVJy8Ov9/op7tLrxhts7ezOPEbCUgBV2aL/SFugHrc/JFoAjHBo6kCzmx11HRgNCq3ae4wP+jGCCGFnpLDXMIEocpTgUsRtz9N+bLfy5q66Ut426BDN/mSlVPIhjZshYK2IGDdeNny2Obo8qitlTsFGcEmOPUuEpbLVcDfPTXOXaqn03NK4zG1UUBTcacIl37Uc3BZsFE+xKKnZnbkXqhzCuDGaW/nLuwfEwkhoaoR0pl7VvTYnjcvgncPrmRgNSc1Mzf5KCUh+egZtRpE84G6vOeb9TuMmH5pEc8V2U2G/mlKSxEMaN0NBTyqeFPCxr3VrdLE9KNycQWvqt7BPNtIdkZybEE0e4XrWNI12X6cieCqKZnYlmFUNiIqpOvcRIb0QFl4svzUXjP13Xk0VSjJEgqjB3MovX9rBw2/vFyKaikHkWfShPTRUOkNSn+EJeZijCf0hGZIaPbLtZtqiUizHem66lYHrIakag6yUSkakcTMUciYQMKZj1TRyPPtxBVwAZER1pWSlVKKRmSvySUxAa7twNXcEnKSFA12SwFP7/2bMFXk3ZXpYyhlwkq+KnI9wemobdkdTmiG8dEU5oqP4z/75KX/a4oQy0eoh1iXhTS4/7x8QhmSH4X0ATtBvstK4GT2y7WZaFZEU7Gk/Vl8qklCcb8+PJhNv1TWlJkjPTVIhjZuhYDDgLxBJxVMDHj5pEt4bhyqMHPMYyl1IFozWdLy6GRMRzeva48alZKR8Enh6oSgHLw0GOOKqo9nbFC0DN2SmcEiuB0r0kuCg0swNZ4gk09v/8QkfWfV+MzEOTa3dXo+mwfRSCx/Uvw2aRolL3EilcTN6pFtMtCoi98zXg3HTooelcu15XcrAhXEzTjbwSyqkcTNE7JUnAiKpeEPtZoLhIA5VxNDTpK5UQuI0CLdyyC3CA6JSSiQTdxhz4zav0cJWMAEQ5eCHO45Q52qMloEbs8eYcaM/gLiDLr44WWP56cLA+cl2/bu77zWIJFrHgEhIanL1QfxhH7PTSjD52kQYrGB6zPYj6RuDQaFdvw6E3ceKZ3YrBdcb+O3WKilz2EmzjJ2wbSogjZshYioTxs0Uv5cPDm/hsLMJhy7A6MgbF8+pSXqhwyASvQ26MF6Lr4Uc/X/mNaeurlQEJUeXYAgFafE1sL/1cLQ7carnGx3N3/70GMF2ceynXXkKBYfe4eunjuMjbRJtWgb4WuHw+zHZl9sf4j97xE3TbRRjXpw9WbyZNxnM9pjsRzIwOozZACielm7LNU2jWc+5yccUrZTarVVK2YUkRBo3Q6X4eEDIMBxwfkpNW300MdWWPXb6hSQTXqMDAIsuntnq6yyD9ttS37ghRxjdDjWMXQ2yvXl7tMeNMobCUrW1tVx//fW0vNcGQOXXSvn+/d/l6lmZXL1wAm+pcwD45M2/x2R/b+5uJBBSqciDrc3vAbAgolIvQ1Kjjkdv4Gj2t3Vb7gw4CekPO7ku4WlzmovoIF0mEych0rgZKvlTCRmspGsqBYEGPm7YFlWXTvXE1GTFbxH/l/SQF1/IS2uXSqmwbQz8z6yZeHQDryQUZFfLp+SNse7EALt370ZVVWqfqKPlvTYMJgPV3yzjn9te4LYvTCc87lwA/Dv/zf99OPyqqYhQ5tRxNYTUEBNzJpHnPCzeLJw57PElg8NvFg097XohSIRISCrLkoW5eRcAB03VgEwmTkakcTNUjCaC+eLCNNXv5f26N6NhKdLHwI0yCQlZxUXNoYZp8bXQ4u3MudHSx0YTtWivm2CAz9y7xpwiOMCkSZMwGAygwv4Ha2l9vx2D2cCfm9bw3uENfPHSawCYrezm50+/xXObj008HSjBsMraHcK48Zk/AODc6vOh/mOxgvTcjDpBi/iupwc93ZZ3SybW8222h8T3Zbz03CQd0rgZBtaKzqTiAy0bsUXUpqWuVEKi6aGn7HCYFm9LN+kFQ+bYaGAXzhI9O0pDAYJhb6dxM4Y8N+Xl5Tz44IMYjUYIw4GHDlOtjieoBvnuum/xgecwWsEMjIrKKcoWVj61hee3DM3A2bi/BacvRF6mn11touHnuRVnR2+e0rgZfRRdRDcz3F1DrKlrMrFeKbXJK9aVYankIyGMm/vuu4/q6mpsNhvz589n48aNfa7f1tbGjTfeSElJCVarlcmTJ/Piiy+O0mw7MZTOBURScVbYC0BAMYJFfhESkjTduFFDtPiau5WCp7SuVBeMeZ1JxRmqijVikI8hzw3AsmXLqKmpYd26ddTsreHxq57mtPIz8If9fGftCupL5wBwTeFOVA3+5+9b+OfHhwe9n4hQ5tTxNYS1MNPzjqM84AE1CJZMcFTF8rAkA8CUVglAlhrqVhEXCUvl2vKiPW52qRWkW4wUZVlHf6KSYRF34+bJJ59k5cqV3H777Xz44YfMnj2bJUuW0NBwbJkeQCAQ4JxzzqGmpoann36anTt38tBDD1FWVjbKMyfaqXhqwBetuukwZshW6gmKQQ8XOsIiLNXaRRHc5hgbN/f0ItHrpiwUiJaBe40ZYB57asfl5eUsWrSI8vJyzEYzv1p0NwvLTsEf9vGrRlHVdGJoI5edUIaqwbef3MKLW48MeHxN06Il4AHLJgDOHXde95CUvFaMOmnZVUT0wAO6DAl0dicuM6VDhzBkd2uVjC/IQJH/p6Qj7sbN3XffzXXXXce1117L9OnTWb16NWlpaTz88MM9rv/www/T0tLCc889xymnnEJ1dTVnnHEGs2fP7nF9v9+P0+ns9hMzCmegKmay1TDT/MJzI3WlEhdLZkQZPEyLV/fc6EZpes7YqBayd2nkFwlJea0yjApgMVr49aJ7mF+ygPfMJnyKAaXjML88zcglx5cRVjW+9cRmXvqkrv/BgK2H2jnS7iPd3kFNh2j0eU71EplvE2fy0/NwGoT0hbN1b3R5xHMzTtf8clmL9UopmUycjMTVuAkEAmzatInFixdHlxkMBhYvXsyGDRt63OaFF15gwYIF3HjjjRQVFXHcccdxxx13EI5UKh3FqlWryM7Ojv5UVMSwwZ7JSjBfNOA62Ssy74PW1G8Gl6xYI+KZ4RCNngY8vhYyVfEMl5k/NoybSK+bklAwatyE08aG12og2Ew27jrrd8wqPZlNNtHJtuHjP/GbL83m4jllhFSNFY99GA039UW0cd+4fWhozCk8gaL0YmjQ9eiKZKVUPMi2W2gzmAFwd1EGj3pufOIBuNYsvisy3yY5iatx09TURDgcpqioe6VKUVERdXU9Xzz27dvH008/TTgc5sUXX+THP/4xd911F//v//2/Hte/5ZZbaG9vj/589tlnMT0GS5kITZ3kdQOg2mWlVKKSFhHPVMPsa98bLd0PYsScNkaM0myR45GuqUyIqFJnjA3DbqDYTHZ+e9a9fFY4DYBDW/7IrtZPufOy2XxxdikhVePGxz7kte31fY4TMYDC1g8BPSQF0nMTZ4R4psih8XV03g+a9GqpQlcjADvDslIqmYl7WGqwqKpKYWEhDz74IHPnzmXp0qX86Ec/YvXq1T2ub7VaycrK6vYTSxQ9qThDEx4A0xhqhpZsZDhE0rBN0/iseUc036ZNcYAh6b4KQ8Nsw2kSBvgsvyiFNYyx7sQDwW5O48LzHgBglsfJd19axp62ndx92Ww+P7OEYFjjm3/7kHU7es4N3N/kZle9C4u1hcPenRgUA2dXnQOeFnDqvXMKjxutw5F0QYhniq7QwY7OHKpIKXi2rj33oVd8L2RYKjmJ6xU9Pz8fo9FIfX33J6D6+nqKi3uuXikpKWHy5MmijFNn2rRp1NXVEQgERnS+PU/ohG4v07KkrlSikpWdSwDxuVG8zdFKqbGgK9UVT7r4jM7Q88Qsjjgk4ycB9uI5qFkVWNCY5Kzjm69cR41zD/csncP5xxUTCKss/+sm1u881sB5VffaTKjcA8CJxfP0EmM9JOWoBlv2aB2KpAtZtk7xzLDeiTishmn1CTkGW8s+AD4OlKMoUJ0njZtkJK7GjcViYe7cuaxduza6TFVV1q5dy4IFC3rc5pRTTmHPnj2oqhpdtmvXLkpKSrBY4qDqXDQLrctptDnGRklxMmIxG2lHuJgd4XDUuPGYxpZxE86uBoj2ZbLllsdxNgmMomCYdD4An9OstPvbuOGV6zjo3Mfvv3I8S2YUEQirXP/XTfxnd2O3TSP5Nlqa3ttmnBhHhqTiT7bdTKt+HdA84v/W7m8jrIXJDIcx6sK6u7VKyh12bGZjr2NJEpe4++JXrlzJQw89xJ/+9Ce2b9/ODTfcgNvt5tprrwXgqquu4pZbbomuf8MNN9DS0sK3v/1tdu3axb/+9S/uuOMObrzxxvgcgCWdcN6U6Ms0adwkNB2KCEtmq53GjW+MVQuZ9V430dfZ0nPTKxOWALA4pDE1dxqtvha++crXOeSq4d6vnMA504sIhFS+/ucPeFsXx2zs8LPpYCtGSwNN/v2YDCbOrDxbjCeNm7iTZTfTounpCZ6IiK4ISc1CTzS2leIiTSYTJzFxN26WLl3KnXfeyW233cacOXPYsmULL730UjTJ+ODBgxw50hkXraio4OWXX+b9999n1qxZfOtb3+Lb3/42P/jBD+J1CJjK5nb+nTk22vgnKy49BJUdDpOjioTikH1sGTfpRZO6L8iQBnmvjD8bFCPGlt3cP+9WJudOpdnXzDde/jpH3Ae57/ITOHtqIf6QyrI/v887e5t4esMONA1KS0QX4gWlp5Bt1UNQ9XpYSmpKxQ2z0YDToItn+tqBzu7E0zVxSzxiESKz0rhJXkzxngDAihUrWLFiRY/vrV+//phlCxYs4N133x3hWQ2CkhPg47+Kv6X0QkLjM+dACBxqKOq50caY0Gma3usmyhjrTjwobNlQsQAOvkXWZxu4/5wH+cYry9jTupsbXlnGg0se5f4rTuAbf93Eup2NXL1mA57GWsz5FbT7X8di13vbAKhqlzJw6bmJJx6juE7bdPHMSDLx5JDI29yDqCocL5OJk5a4e25Sgq5JxWPsRplsBMziiS07HI5WSyljRDQzwt9f7ZQ38aom1vzt6TjOJgnQQ1PseRmHLYf7z3mI8dkTaPA0sPyVr9HkPcIfrpjL/MpMgpoBc34lRusRLI4AakBlonGy2L51HwQ9YLJB7sTe9ycZcfwm8Z1P08Uzm3XjptInWnps8YlQrfTcJC/SuIkFxcejmjMImHOobXbHezaSPgja9LBUl5wbU/bY8VzU1tZy5Y0/JKSJdvL1wTSWf+Mb1NbWxnlmCcxE3bjZ9xqEg+Ta87h/yR+pyqqm3l3HN15eRqu/nq9NCuHdL3ramM1vAdD+UQeHa/SweiTfpmAGGBPCaT5mCVtFy44s3VMTybkp0nNw3nOLUK303CQv0riJAWv+9hTT7nEz+TetVI0bz5o1a+I9JUkvRJTBHeFQ1HNjzx47OSe7d+8mGNY45BdPpPU+K+FwmD179sR5ZglMyVwRbg50QK0Ih+fb81m9ZA2VWVUccR/mGy8vo7A6h+Zn76B13cNY0oSWVNv7HUycqHtpZDJx4mAT7RDStTDhgIcmbxOZ4TAZ/g5ACGZm2kwUZEjBzGRFGjfDpLa2luuvv55dTRoH2kUp+/Lly+WTcIKipOvGjRomV+9QnJ47djw3kyZNwmAwsK/RD0BtgxOj0dh5A5Yci8EA488Rf+95Obq4IK2QP5z7R8oyyjnkquVnH9/KXff/Eq35ZSy5CmFfmF9cv4rycr3UXho3CYM9rYyIHnhH+36avU2MD4qO3V57KW69UkoKZiYv0rgZJrt37+7WcweQT8IJjFFXBi8PBrAg+rxk5o6drtLl5eU8+OCD7G8WiuBH2gI88MADnTdgSc9EQlN7Xuq2uCi9mAeWPExpRhmfdRzkjdzX+Pq9oo3FWdWL+cayb3SuLI2bhCE7PY12gwgNutpqaPE1MyEgDP4G2wQAxufLkFQyI42bYRJ5Eu6KfBJOXCxZwrgp1WPtHZqd7BhLciQ6y5Yt44Jb/obHXsHS259k2bJl8Z5S4jPhXPH7yIfg7t6wrzijhNVL1lCcXsJBZw1v1q8H4KLpl3au5HeJhGKQgpkJQJbdTJtBNH31OA/Q7G1mXFAYN/uUagAmFMpk4mRGGjfDJPIkHJGDMBqN8kk4gbHpyuCRnqOtigOTcex9DQrmX07azQcpmHdZvKeSHGSWQNFsQIO9rx7zdmlGGavPXUNRmqjCybRkcnLpws4VGj8R22YUQ7qsqIw3Ql/KBoDXWUubr5XxupDsxwFZKZUKjL2r+giwbNkyampqWLduHTU1NfJJOIGJKINHcBrGlvSCZBj0EpqKUJ5VweolD3NS8XxuPP7bmI3mzjdlSCqh6Cqe6Wzdh4bGBN1z865LFBhMkGGppEbWI8aI8vJy6a1JArIchYQ1A0ZF5Em5zdK4kQyQiefB27+Gva+Ihnw9KMlXZFXyhyV/PHZbadwkFFm2Tn0pT/sBsrQQ+Xr15Mf+UowGhcq8tHhOUTJMpOdGMqZwpFtpo9Pd7LXIjtKSAVJxCpjTwV3faawMFGncJBRdxTND7jrG614bf3o5btKozEnDapKCmcmMNG4kYwqb2Ug7nQnEQZs0biQDxGSBcWeKv3sJTfWIpknjJsHIspto0YTel8nbxni9UqrJLgpBZPO+5EcaN5IxR4eh07jR7DK5UzIIJp4nfu99ue/1uuI8BL42UIyQP3VEpiUZHNl2M61aRIolGO1xU2OsBmQycSogjRvJmMNjzOn825AZx5lIko6IztTBt0HvZtsvEa9N/lQwyY63iUC23UyzKvLtHGo46rn5JCjyJidIz03SI40byZijJdR5g3nor/8n5TIkAydvIuSMBzUI+9cNbBsZkko47GYj7ZoISTvC4WjOzUa36FY+Xnpukh5p3EjGFLW1tdQ0eqKvj7QFpFyGZHBEvDcDDU1J4ybhUBQFv1l0Js8PB6OVUu84RasIGZZKfqRxIxlT7N69myZf58e+vs0n5TIkgyOSd7NHGjfJTNgiQlCRfijutCI82MlJM5ObbonfxCQxQRo3kjHFpEmTaPEKMbywZqCx1S3lMiSDY9yZYDBB615o7scoDvmhaYf4Wxo3CYXZlk+ATmHMlvRxgAxJpQrSuJGMKcrLy5k4cz4ALWRBwC3lMiSDw5opet5A/6Gpph2ghcGWA1llIz83yYDJTrPQZujsIn3YJB5wZDJxaiCNG8mYo3re5wDYrVWy+5OPpVyGZPAMNDQVDUnNBEXpe13JqJJlN9Fq6Cwu2KVG1MCl5yYVkMaNZMxhKJzOFwL38EPjrVRVVsR7OpJkJKIztf910BXme0Tm2yQs2XYzbbp4JsAmn0gwlsnEqYE0biRjjrx0C9u0iZizCvtfWSLpiaLZkF4IQTd89nbv60njJmER4pmd+lFvtojScBmWSg2kcSMZc5xYlcPy08fzw/OnxXsqkmTFYOgsCe8rNCWNm4Qly2amRRNemlrVREvIigGNilwpmJkKSONGMuYwGQ3ccv40zpwqPTeSYRAJTfWmM+VqAFcdoEDBjFGblmRgqD4XrZoDgF1BOwD+5lrqjxyO46wksUIaNxKJRDIUxp8jftd/BB11x77fsFX8zp0AVpnHkWi4Whp4zfsFDqvp/G33eACCzbWy51WKII0biUQiGQoZhVAyV/y995Vj36/XjZvCmaM3J8mAmVRdzmZ1Jice+iXPOhcAEGo9LHtepQjSuJFIJJKh0ldoSubbJDQTK0V1lMGWiTlP9Ln6rwsWy55XKYI0biQSiWSoRJKK970Kqtr9PWncJDRZNiG8kJlbSOmU4wG45tLz4zklSQyRxo1EIpEMlYoFYMkETxMc+bBzeTgEjZ+Iv6Vxk5Bk20V3Ym9IpdWvAbLHTSohjRuJRCIZKkYzjD9b/N01NNWyB0I+MKdBzvj4zE3SJ5k2c7fX+RmWqMEjSX6kcSORSCTDIRKa6qozFQlJFc4UPXEkCYfRoJBpNUVfS8HM1EJ+6yQSiWQ4RJKKP9sAvnbxd6QMvEhWSiUyWV08NRPyZWfiVEIaNxKJRDIccsZB3mSh/r1vrVgmk4mTgm7GjfTcpBTSuJFIJJLhcnRoSho3SUG2vTMsJY2b1EIaNxKJRDJcJnbRmfK1Q1uNeC0b+CU0XROIx0vBzJRCGjcSiUQyXKoXgdEC7Qfg06fFsqxySMuN67QkfZOlV0xZjAbKc6RgZiohjRuJRCIZLpZ0qDxN/P3OneK3DEklPBHPTXV+GkaDEufZSGKJNG4kEokkFkRCU007xG9p3CQ8jjRh3Mh8m9RDGjcSiUQSCyae1/21zLdJeD53XAmnTyrg6gXV8Z6KJMaY+l9FIpFIJP1SeBxklkLHYfFaem4SnvEFGfz5a/PiPQ3JCCA9NxKJRBILFAUmnCv+Npghf0p85yORjGGkcSORSCSxYtLnxe/i2UJ3SiKRxAUZlpJIJJJYMf1S+PwfoGJhvGcikYxppHEjkUgksUJR4KRvxHsWEsmYR4alJBKJRCKRpBTSuJFIJBKJRJJSSONGIpFIJBJJSiGNG4lEIpFIJClFQhg39913H9XV1dhsNubPn8/GjRt7XffRRx9FUZRuPzabbRRnK5FIJBKJJJGJu3Hz5JNPsnLlSm6//XY+/PBDZs+ezZIlS2hoaOh1m6ysLI4cORL9OXDgwCjOWCKRSCQSSSITd+Pm7rvv5rrrruPaa69l+vTprF69mrS0NB5++OFet1EUheLi4uhPUVFRr+v6/X6cTme3H4lEIpFIJKlLXI2bQCDApk2bWLx4cXSZwWBg8eLFbNiwodftXC4XVVVVVFRUcOGFF/LJJ5/0uu6qVavIzs6O/lRUVMT0GCQSiUQikSQWcTVumpqaCIfDx3heioqKqKur63GbKVOm8PDDD/P888/z17/+FVVVWbhwIbW1tT2uf8stt9De3h79+eyzz2J+HBKJRCKRSBKHpOtQvGDBAhYsWBB9vXDhQqZNm8YDDzzAz3/+82PWt1qtWK3W0ZyiRCKRSCSSOBJXz01+fj5Go5H6+vpuy+vr6ykuLh7QGGazmeOPP549e/aMxBQlEolEIpEkGXE1biwWC3PnzmXt2rXRZaqqsnbt2m7emb4Ih8Ns3bqVkpKSkZqmRCKRSCSSJCLuYamVK1dy9dVXc+KJJzJv3jzuuece3G431157LQBXXXUVZWVlrFq1CoCf/exnnHzyyUycOJG2tjZ+85vfcODAAb7+9a/H8zAkEolEIpEkCHE3bpYuXUpjYyO33XYbdXV1zJkzh5deeimaZHzw4EEMhk4HU2trK9dddx11dXXk5OQwd+5c3nnnHaZPnz6g/WmaBiBLwiUSiUQiSSIi9+3IfbwvFG0ga6UQ+/btY8KECfGehkQikUgkkiGwd+9exo8f3+c6cffcjDa5ubmA8AhlZ2fHeTbx46STTuL999+P9zTiylg/B2P9+EGeA5DnAOQ5SJbjb29vp7KyMnof74sxZ9xEQlzZ2dlkZWXFeTbxw2g0junjB3kOxvrxgzwHIM8ByHOQbMffNVWl13VGYR6SBOTGG2+M9xTizlg/B2P9+EGeA5DnAOQ5SMXjH3M5N06nk+zsbNrb25PKUpVIJBKJZCwzmPv3mPPcWK1Wbr/9dtm1WCKRSCSSJGIw9+8x57mRSCQSiUSS2ow5z41EIpFIJJLURho3EolEIpFIUgpp3CQh9913H9XV1dhsNubPn8/GjRuj7y1fvpwJEyZgt9spKCjgwgsvZMeOHf2O+dRTTzF16lRsNhszZ87kxRdf7Pa+pmncdtttlJSUYLfbWbx4Mbt37475sQ2Uvs4BwIYNGzjrrLNIT08nKyuL008/Ha/X2+eY69ev54QTTsBqtTJx4kQeffTRQe93tOhrHnv37uXiiy+moKCArKwsvvzlLx8jTtsTyXT8b775JhdccAGlpaUoisJzzz0XfS8YDHLzzTczc+ZM0tPTKS0t5aqrruLw4cP9jpsq5wDgmmuuQVGUbj/nnXdev+Mmyzno7/hdLhcrVqygvLwcu93O9OnTWb16db/jfvzxx5x22mnYbDYqKir49a9/fcw6/V0vR4NVq1Zx0kknkZmZSWFhIRdddBE7d+7sts6DDz7IokWLyMrKQlEU2traBjR2snwG+kSTJBVPPPGEZrFYtIcfflj75JNPtOuuu05zOBxafX29pmma9sADD2hvvPGGtn//fm3Tpk3aBRdcoFVUVGihUKjXMd9++23NaDRqv/71r7VPP/1Uu/XWWzWz2axt3bo1us4vf/lLLTs7W3vuuee0jz76SPviF7+ojRs3TvN6vSN+zEfT3zl45513tKysLG3VqlXatm3btB07dmhPPvmk5vP5eh1z3759WlpamrZy5Urt008/1e69917NaDRqL7300oD3O1r0NQ+Xy6WNHz9eu/jii7WPP/5Y+/jjj7ULL7xQO+mkk7RwONzrmMl0/JqmaS+++KL2ox/9SHvmmWc0QHv22Wej77W1tWmLFy/WnnzySW3Hjh3ahg0btHnz5mlz587tc8xUOgeapmlXX321dt5552lHjhyJ/rS0tPQ5ZjKdg/6O/7rrrtMmTJigrVu3Ttu/f7/2wAMPaEajUXv++ed7HbO9vV0rKirSrrjiCm3btm3a448/rtntdu2BBx6IrjOQ6+VosGTJEu2RRx7Rtm3bpm3ZskX73Oc+p1VWVmoulyu6zm9/+1tt1apV2qpVqzRAa21t7XfcZPoM9IU0bpKMefPmaTfeeGP0dTgc1kpLS7VVq1b1uP5HH32kAdqePXt6HfPLX/6y9vnPf77bsvnz52vLly/XNE3TVFXViouLtd/85jfR99va2jSr1ao9/vjjwzmcIdHfOZg/f7526623DmrM73//+9qMGTO6LVu6dKm2ZMmSAe93tOhrHi+//LJmMBi09vb26PttbW2aoijaq6++2uuYyXT8R9PTje1oNm7cqAHagQMHel0n1c7B1VdfrV144YWDGidZz0FPxz9jxgztZz/7WbdlJ5xwgvajH/2o13Huv/9+LScnR/P7/dFlN998szZlypTo6/6ul/GioaFBA7Q33njjmPfWrVs3YOMmWT8DR5N0Yam+XGE+n48bb7yRvLw8MjIyuPTSSwfkjk+WkEwgEGDTpk0sXrw4usxgMLB48WI2bNhwzPput5tHHnmEcePGUVFREV1eXV3NT37yk+jrDRs2dBsTYMmSJdEx9+/fT11dXbd1srOzmT9/fo/7HUn6OwcNDQ289957FBYWsnDhQoqKijjjjDN46623uo2zaNEirrnmmujr/s7BYM/9SNHfPPx+P4qidCuVtNlsGAyGbucgWY9/qLS3t6MoCg6HI7psLJyD9evXU1hYyJQpU7jhhhtobm7u9n4qn4OFCxfywgsvcOjQITRNY926dezatYtzzz03us4111zDokWLoq83bNjA6aefjsViiS5bsmQJO3fupLW1NbpOX+coXrS3twMMSJqgK6n6GUgq4+bJJ59k5cqV3H777Xz44YfMnj2bJUuW0NDQAMD//M//8I9//IOnnnqKN954g8OHD3PJJZf0OeY777zD5ZdfzrJly9i8eTMXXXQRF110Edu2bYuu8+tf/5rf//73rF69mvfee4/09HSWLFmCz+cb0eM9mqamJsLhcFQxPUJRURF1dXXR1/fffz8ZGRlkZGTw73//m1dffbXbl3XChAnk5+dHX9fV1fU5ZuR3f/sdDfo7B/v27QPgJz/5Cddddx0vvfQSJ5xwAmeffXY3g7SyspKSkpLo697OgdPpxOv1DvjcjzT9zePkk08mPT2dm2++GY/Hg9vt5qabbiIcDnPkyJHo+sl6/EPB5/Nx8803c/nll3dr/JXq5+C8887jz3/+A1k1xQAAExNJREFUM2vXruVXv/oVb7zxBueffz7hcDi6Tiqfg3vvvZfp06dTXl6OxWLhvPPO47777uP000+PrlNSUkJlZWX0dW/HH3mvr3XiefyqqvKd73yHU045heOOO25Q26bqZyCptKXuvvturrvuOq699loAVq9ezb/+9S8efvhhbrjhBtasWcNjjz3GWWedBcAjjzzCtGnTePfddzn55JN7HPN3v/sd5513Ht/73vcA+PnPf86rr77K//7v/7J69Wo0TeOee+7h1ltv5cILLwTgz3/+M0VFRTz33HN85StfGYUjHxxXXHEF55xzDkeOHOHOO+/ky1/+Mm+//TY2mw2AtWvXxnmGI4eqqoBIrI58To4//njWrl3Lww8/zKpVqwDxP0xFCgoKeOqpp7jhhhv4/e9/j8Fg4PLLL+eEE07opseSqsd/NMFgkC9/+ctomsYf/vCHbu+l+jnoem2aOXMms2bNYsKECaxfv56zzz4bSO1zcO+99/Luu+/ywgsvUFVVxZtvvsmNN95IaWlp1OsQuR4kOzfeeCPbtm07xkM9EFL1M5A0npv+XGGbNm0iGAx2e3/q1KlUVlZ2c5Ulc0gmPz8fo9F4TKitvr6e4uLibvObNGkSp59+Ok8//TQ7duzg2Wef7XXc4uLiPseM/O5vv6NBf+cg8gQyffr0bu9PmzaNgwcP9jpub+cgKysLu90+4HM/0gxkHueeey579+6loaGBpqYm/vKXv3Do0CHGjx/f67jJcvyDIWLYHDhwgFdffbXfdu2peA66Mn78ePLz89mzZ0+v66TKOfB6vfzwhz/k7rvv5oILLmDWrFmsWLGCpUuXcuedd/a6XW/HH3mvr3XidfwrVqzgn//8J+vWraO8vHzY46XKZyBpjJv+XGF1dXVYLJZuMfWu70dI5pCMxWJh7ty53Twvqqqydu1aFixY0OM2mkgax+/39zruggULjvHmvPrqq9Exx40bR3Fxcbd1nE4n7733Xq/7HSn6OwfV1dWUlpYeUxK5a9cuqqqqeh23v3MwlHM/EgxmHvn5+TgcDl5//XUaGhr44he/2Ou4yXL8AyVi2OzevZvXXnuNvLy8frdJtXNwNLW1tTQ3N3cLQRxNqpyDYDBIMBg8Rj3aaDRGvbs9sWDBAt58802CwWB02auvvsqUKVPIycmJrtPXORotNE1jxYoVPPvss7z++uuMGzcuJuOmymcgaaqlDh06pAHaO++802359773PW3evHna3/72N81isRyz3UknnaR9//vf73Vcs9msPfbYY92W3XfffVphYaGmaaLsD9AOHz7cbZ3LLrtM+/KXvzzUwxkyTzzxhGa1WrVHH31U+/TTT7Xrr79eczgcWl1dnbZ3717tjjvu0D744APtwIED2ttvv61dcMEFWm5ubrcSvbPOOku79957o6/ffvttzWQyaXfeeae2fft27fbbb++xFNzhcGjPP/98tLw4nqXgvZ0DTRPlj1lZWdpTTz2l7d69W7v11ls1m83WrWLsyiuv1H7wgx9EX0fKH7/3ve9p27dv1+67774eyx/72u9o0d88Hn74YW3Dhg3anj17tL/85S9abm6utnLlym5jJPPxa5qmdXR0aJs3b9Y2b96sAdrdd9+tbd68WTtw4IAWCAS0L37xi1p5ebm2ZcuWbqXQXatgUvkcdHR0aDfddJO2YcMGbf/+/dprr72mnXDCCdqkSZO6tURI5nPQ1/FrmqadccYZ2owZM7R169Zp+/bt0x555BHNZrNp999/f3SMH/zgB9qVV14Zfd3W1qYVFRVpV155pbZt2zbtiSee0NLS0o4pBe/vejka3HDDDVp2dra2fv36bp9xj8cTXefIkSPa5s2btYceekgDtDfffFPbvHmz1tzcHF0nmT8DfZE0xo3f79eMRuMx5X5XXXWV9sUvflFbu3Ztj6VulZWV2t13393ruBUVFdpvf/vbbstuu+02bdasWZqmadrevXs1QNu8eXO3dU4//XTtW9/61lAPZ1jce++9WmVlpWaxWLR58+Zp7777rqZpwgA8//zztcLCQs1sNmvl5eXaV7/6VW3Hjh3dtq+qqtJuv/32bsv+/ve/a5MnT9YsFos2Y8YM7V//+le391VV1X784x9rRUVFmtVq1c4++2xt586dI3qcfdHbOYiwatUqrby8XEtLS9MWLFig/ec//+n2/hlnnKFdffXV3ZatW7dOmzNnjmaxWLTx48drjzzyyKD3O1r0NY+bb75ZKyoq0sxmszZp0iTtrrvu0lRV7bZ9sh9/pLT16J+rr75a279/f4/vAdq6deuiY6TyOfB4PNq5556rFRQUaGazWauqqtKuu+66Y24+yXwO+jp+TRM39muuuUYrLS3VbDabNmXKlGO+C1dffbV2xhlndBv3o48+0k499VTNarVqZWVl2i9/+ctj9t3f9XI06O0z3vX/dfvtt/e7TjJ/BvoiqYQz58+fz7x587j33nsB4QqrrKxkxYoV3HDDDRQUFPD4449z6aWXArBz506mTp3Khg0bek0oXrp0KR6Ph3/84x/RZQsXLmTWrFnRhOLS0lJuuukmvvvd7wIiJFNYWMijjz6akAnFEolEIpGMZZKqWmrlypVcffXVnHjiicybN4977rkHt9vNtddeS3Z2NsuWLWPlypXk5uaSlZXFf//3f7NgwYJuhs3ZZ5/NxRdfzIoVKwD49re/zRlnnMFdd93F5z//eZ544gk++OADHnzwQQAUReE73/kO/+///T8mTZrEuHHj+PGPf0xpaSkXXXRRPE6DRCKRSCSSPkgq42bp0qU0NjZy2223UVdXx5w5c3jppZeiyb6//e1vMRgMXHrppfj9fpYsWcL999/fbYy9e/fS1NQUfb1w4UIee+wxbr31Vn74wx8yadIknnvuuW69Ar7//e/jdru5/vrraWtr49RTT+Wll16KllZLJBKJRCJJHJIqLCWRSCQSiUTSH0lTCi6RSCQSiUQyEKRxI5FIJBKJJKWQxo1EIpFIJJKUQho3EolEIpFIUgpp3EgkEolEIkkpksa4ue+++6iursZmszF//nw2btwYfe/BBx9k0aJFZGVloSgKbW1tAxrz0UcfPUaLSiKRSCQSSXKTFMbNk08+ycqVK7n99tv58MMPmT17NkuWLKGhoQEAj8fDeeedxw9/+MM4z1QikUgkEkm8SQrj5u677+a6667j2muvZfr06axevZq0tDQefvhhAL7zne/wgx/8oFeJhYGyd+9eLrzwQoqKisjIyOCkk07itdde67ZOdXU1d9xxB1/72tfIzMyksrIy2s1YIpFIJBJJ/El44yYQCLBp0yYWL14cXWYwGFi8eDEbNmyI6b5cLhef+9znWLt2LZs3b+a8887jggsu4ODBg93Wu+uuuzjxxBPZvHkz3/zmN7nhhhvYuXNnTOcikUgkEolkaCS8cdPU1EQ4HI5KLEQoKiqirq4upvuaPXs2y5cv57jjjmPSpEn8/Oc/Z8KECbzwwgvd1vvc5z7HN7/5TSZOnMjNN99Mfn4+69ati+lcJBKJRCKRDI2EN25iwfnnn09GRgYZGRnMmDGj1/VcLhc33XQT06ZNw+FwkJGRwfbt24/x3MyaNSv6t6IoFBcXR/N/JBKJRCKRxJeEF87Mz8/HaDRSX1/fbXl9fT3FxcUDGuOPf/wjXq8XALPZ3Ot6N910E6+++ip33nknEydOxG6386UvfYlAINBtvaPHUBQFVVUHNBeJRCKRSCQjS8IbNxaLhblz57J27VouuugiAFRVZe3ataxYsWJAY5SVlQ1ovbfffptrrrmGiy++GBCenJqamqFMWyKRSCQSSZxIeOMGYOXKlVx99dWceOKJzJs3j3vuuQe32821114LQF1dHXV1dezZsweArVu3RiuZcnNzB7yfSZMm8cwzz3DBBRegKAo//vGPpUdGIpFIJJIkIymMm6VLl9LY2Mhtt91GXV0dc+bM4aWXXoomGa9evZqf/vSn0fVPP/10AB555BGuueaaXsdVVRWTqfMU3H333Xzta19j4cKF5Ofnc/PNN+N0OkfmoCQSiUQikYwIiqZpWrwnES9++ctf8te//pVt27bFeyoSiUQikUhiRFJ4bmKNx+Nhx44dPPLII5x//vnxno5EIpFIJJIYMiZKwY/mwQcfZPHixcyePZvbbrst3tORSCQSiUQSQ8Z0WEoikUgkEknqMSY9NxKJRCKRSFIXadxIJBKJRCJJKZLSuFm1ahUnnXQSmZmZFBYWctFFFx0jXOnz+bjxxhvJy8sjIyODSy+99Jgux9/61reYO3cuVquVOXPm9Livv//978yZM4e0tDSqqqr4zW9+M1KHJZFIJBKJJAYkpXHzxhtvcOONN/Luu+/y6quvEgwGOffcc3G73dF1/ud//od//OMfPPXUU7zxxhscPnyYSy655Jixvva1r7F06dIe9/Pvf/+bK664gm984xts27aN+++/n9/+9rf87//+74gdm0QikUgkkuGREgnFjY2NFBYW8sYbb3D66afT3t5OQUEBjz32GF/60pcA2LFjB9OmTWPDhg2cfPLJ3bb/yU9+wnPPPceWLVu6Lf/qV79KMBjkqaeeii679957+fWvf83BgwdRFGXEj00ikUgkEsngSErPzdG0t7cDRKUWNm3aRDAYZPHixdF1pk6dSmVlJRs2bBjwuH6/H5vN1m2Z3W6ntraWAwcOxGDmEolEIpFIYk3SGzeqqvKd73yHU045heOOOw4QWlMWiwWHw9Ft3aKiIurq6gY89pIlS3jmmWdYu3Ytqqqya9cu7rrrLgCOHDkSs2OQSCQSiUQSO5LeuLnxxhvZtm0bTzzxRMzHvu6661ixYgVf+MIXsFgsnHzyyXzlK18BwGBI+lMnkUgkEklKktR36BUrVvDPf/6TdevWUV5eHl1eXFxMIBCgra2t2/r19fUUFxcPeHxFUfjVr36Fy+XiwIED1NXVMW/ePADGjx8fk2OQSCQSiUQSW5LSuNE0jRUrVvDss8/y+uuvM27cuG7vz507F7PZzNq1a6PLdu7cycGDB1mwYMGg92c0GikrK8NisfD444+zYMECCgoKhn0cEolEIpFIYk9SCmfeeOONPPbYYzz//PNkZmZG82iys7Ox2+1kZ2ezbNkyVq5cSW5uLllZWfz3f/83CxYs6FYptWfPHlwuF3V1dXi93mi11PTp07FYLDQ1NfH000+zaNEifD4fjzzySLS0XCKRSCQSSWKSlKXgvZVgP/LII1xzzTWAaOL33e9+l8cffxy/38+SJUu4//77u4WlFi1a1KOhsn//fqqrq2lqauKCCy5g69ataJrGggUL+MUvfsH8+fNH5LgkEolEIpEMn6Q0biQSiUQikUh6IylzbiQSiUQikUh6Qxo3EolEIpFIUgpp3EgkEolEIkkppHEjkUgkEokkpZDGjUQikUgkkpRCGjcSiUQikUhSCmncSCQSiUQiSSmkcSORSCQSiSSlkMaNRCJJCtavX4+iKMcI4kokEsnRyA7FEokkIVm0aBFz5szhnnvuASAQCNDS0kJRUVGvEiwSiUQCSSqcKZFIxh4Wi6WbNpxEIpH0hgxLSSSShOOaa67hjTfe4He/+x2KoqAoCo8++mi3sNSjjz6Kw+Hgn//8J1OmTCEtLY0vfelLeDwe/vSnP1FdXU1OTg7f+ta3CIfD0bH9fj833XQTZWVlpKenM3/+fNavXx+fA5VIJCOC9NxIJJKE43e/+x27du3iuOOO42c/+xkAn3zyyTHreTwefv/73/PEE0/Q0dHBJZdcwsUXX4zD4eDFF19k3759XHrppZxyyiksXboUgBUrVvDpp5/yxBNPUFpayrPPPst5553H1q1bmTRp0qgep0QiGRmkcSORSBKO7OxsLBYLaWlp0VDUjh07jlkvGAzyhz/8gQkTJgDwpS99ib/85S/U19eTkZHB9OnTOfPMM1m3bh1Lly7l4MGDPPLIIxw8eJDS0lIAbrrpJl566SUeeeQR7rjjjtE7SIlEMmJI40YikSQtaWlpUcMGoKioiOrqajIyMrota2hoAGDr1q2Ew2EmT57cbRy/309eXt7oTFoikYw40riRSCRJi9ls7vZaUZQel6mqCoDL5cJoNLJp0yaMRmO39boaRBKJJLmRxo1EIklILBZLt0TgWHD88ccTDodpaGjgtNNOi+nYEokkcZDVUhKJJCGprq7mvffeo6amhqampqj3ZThMnjyZK664gquuuopnnnmG/fv3s3HjRlatWsW//vWvGMxaIpEkAtK4kUgkCclNN92E0Whk+vTpFBQUcPDgwZiM+8gjj3DVVVfx3e9+lylTpnDRRRfx/vvvU1lZGZPxJRJJ/JEdiiUSiUQikaQU0nMjkUgkEokkpZDGjUQikUgkkpRCGjcSiUQikUhSCmncSCQSiUQiSSmkcSORSCQSiSSlkMaNRCKRSCSSlEIaNxKJRCKRSFIKadxIJBKJRCJJKaRxI5FIJBKJJKWQxo1EIpFIJJKUQho3EolEIpFIUor/D7BQq1dxkr4AAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmp.plot.timeseries();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Use the `color` argument to change the color of the models (and potentially also the observation)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmp.plot.timeseries(color=[\"#729456\", \"red\", \"k\"]);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also change the style of lines using the `style` argument similar to the `style` argument of pandas `df.plot()`" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmp.plot.timeseries(style=[\"--\", \"-\", \"k-.\"]);" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.11.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}