diff --git a/dabest/misc_tools.py b/dabest/misc_tools.py index 05193fe1..ff7e56d9 100644 --- a/dabest/misc_tools.py +++ b/dabest/misc_tools.py @@ -299,7 +299,7 @@ def get_kwargs(plot_kwargs, ytick_color): delta_text_kwargs, summary_bars_kwargs, swarm_bars_kwargs, contrast_bars_kwargs) -def get_color_palette(plot_kwargs, plot_data, xvar, show_pairs, idx): +def get_color_palette(plot_kwargs, plot_data, xvar, show_pairs, idx, all_plot_groups): # Create color palette that will be shared across subplots. color_col = plot_kwargs["color_col"] @@ -350,7 +350,7 @@ def get_color_palette(plot_kwargs, plot_data, xvar, show_pairs, idx): else: if isinstance(custom_pal, dict): groups_in_palette = { - k: v for k, v in custom_pal.items() if k in color_groups + k: custom_pal[k] for k in all_plot_groups if k in color_groups } names = groups_in_palette.keys() diff --git a/dabest/plot_tools.py b/dabest/plot_tools.py index ed791429..fd56323d 100644 --- a/dabest/plot_tools.py +++ b/dabest/plot_tools.py @@ -820,7 +820,7 @@ def sankeydiag( def summary_bars_plotter(summary_bars: list, results: object, ax_to_plot: object, float_contrast: bool,summary_bars_kwargs: dict, ci_type: str, - ticks_to_plot: list, color_col: str, swarm_colors: list, + ticks_to_plot: list, color_col: str, plot_palette_raw: dict, proportional: bool, is_paired: bool): """ Add summary bars to the contrast plot. @@ -843,8 +843,8 @@ def summary_bars_plotter(summary_bars: list, results: object, ax_to_plot: object List of indices of the contrast objects. color_col : str Column name of the color column. - swarm_colors : list - List of colors used in the plot. + plot_palette_raw : dict + Dictionary of colors used in the plot. proportional : bool Whether the data is proportional. is_paired : bool @@ -862,7 +862,13 @@ def summary_bars_plotter(summary_bars: list, results: object, ax_to_plot: object # End checks else: summary_xmin, summary_xmax = ax_to_plot.get_xlim() - summary_bars_colors = [summary_bars_kwargs.get('color')]*(max(summary_bars)+1) if summary_bars_kwargs.get('color') is not None else ['black']*(max(summary_bars)+1) if color_col is not None or (proportional and is_paired) or is_paired else swarm_colors + summary_bars_colors = ( + [summary_bars_kwargs.get('color')]*(max(summary_bars)+1) + if summary_bars_kwargs.get('color') is not None + else ['black']*(max(summary_bars)+1) + if color_col is not None or (proportional and is_paired) or is_paired + else list(plot_palette_raw.values()) + ) summary_bars_kwargs.pop('color') for summary_index in summary_bars: if ci_type == "bca": @@ -973,7 +979,6 @@ def swarm_bars_plotter(plot_data: object, xvar: str, yvar: str, ax: object, swarm_bars_order = pd.unique(plot_data[xvar]) swarm_means = plot_data.groupby(xvar)[yvar].mean().reindex(index=swarm_bars_order) - # swarm_bars_colors = [swarm_bars_kwargs.get('color')]*(max(swarm_bars_order)+1) if swarm_bars_kwargs.get('color') is not None else ['black']*(len(swarm_bars_order)+1) if color_col is not None or is_paired else swarm_colors swarm_bars_colors = ( [swarm_bars_kwargs.get('color')] * (max(swarm_bars_order) + 1) if swarm_bars_kwargs.get('color') is not None @@ -987,7 +992,7 @@ def swarm_bars_plotter(plot_data: object, xvar: str, yvar: str, ax: object, 0.5, swarm_bars_y, zorder=-1,color=c,**swarm_bars_kwargs)) def delta_text_plotter(results: object, ax_to_plot: object, swarm_plot_ax: object, ticks_to_plot: list, delta_text_kwargs: dict, color_col: str, - swarm_colors: list, is_paired: bool, proportional: bool, float_contrast: bool, + plot_palette_raw: dict, is_paired: bool, proportional: bool, float_contrast: bool, show_mini_meta: bool, mini_meta_delta: object, show_delta2: bool, delta_delta: object): """ Add text to the contrast plot. @@ -1006,8 +1011,8 @@ def delta_text_plotter(results: object, ax_to_plot: object, swarm_plot_ax: objec Keyword arguments for the delta text. color_col : str Column name of the color column. - swarm_colors : list - List of colors used in the plot. + plot_palette_raw : dict + Dictionary of colors used in the plot. is_paired : bool Whether the data is paired. proportional : bool @@ -1032,7 +1037,13 @@ def delta_text_plotter(results: object, ax_to_plot: object, swarm_plot_ax: objec delta_text_kwargs["va"] = 'bottom' if results.difference[0] >= 0 else 'top' delta_text_kwargs.pop('x_location') - delta_text_colors = [delta_text_kwargs.get('color')]*(max(ticks_to_plot)+1) if delta_text_kwargs.get('color') is not None else ['black']*(max(ticks_to_plot)+1) if color_col is not None or (proportional and is_paired) or is_paired else swarm_colors + delta_text_colors = ( + [delta_text_kwargs.get('color')]*(max(ticks_to_plot)+1) + if delta_text_kwargs.get('color') is not None + else ['black']*(max(ticks_to_plot)+1) + if color_col is not None or (proportional and is_paired) or is_paired + else list(plot_palette_raw.values()) + ) if show_mini_meta or show_delta2: delta_text_colors.append('black') delta_text_kwargs.pop('color') diff --git a/dabest/plotter.py b/dabest/plotter.py index 59c264d0..86e8239a 100644 --- a/dabest/plotter.py +++ b/dabest/plotter.py @@ -143,7 +143,8 @@ def effectsize_df_plotter(effectsize_df, **plot_kwargs): plot_data=plot_data, xvar=xvar, show_pairs=show_pairs, - idx=idx + idx=idx, + all_plot_groups=all_plot_groups ) # Initialise the figure. @@ -551,7 +552,7 @@ def effectsize_df_plotter(effectsize_df, **plot_kwargs): ci_type=ci_type, ticks_to_plot=ticks_to_plot, color_col=color_col, - swarm_colors=swarm_colors, + plot_palette_raw=plot_palette_raw, proportional=proportional, is_paired=is_paired ) @@ -565,7 +566,7 @@ def effectsize_df_plotter(effectsize_df, **plot_kwargs): ticks_to_plot=ticks_to_plot, delta_text_kwargs=delta_text_kwargs, color_col=color_col, - swarm_colors=swarm_colors, + plot_palette_raw=plot_palette_raw, is_paired=is_paired, proportional=proportional, float_contrast=float_contrast, diff --git a/nbs/API/misc_tools.ipynb b/nbs/API/misc_tools.ipynb index d79fcd23..6a1f40fc 100644 --- a/nbs/API/misc_tools.ipynb +++ b/nbs/API/misc_tools.ipynb @@ -352,7 +352,7 @@ " delta_text_kwargs, summary_bars_kwargs, swarm_bars_kwargs, contrast_bars_kwargs)\n", "\n", "\n", - "def get_color_palette(plot_kwargs, plot_data, xvar, show_pairs, idx):\n", + "def get_color_palette(plot_kwargs, plot_data, xvar, show_pairs, idx, all_plot_groups):\n", "\n", " # Create color palette that will be shared across subplots.\n", " color_col = plot_kwargs[\"color_col\"]\n", @@ -403,7 +403,7 @@ " else:\n", " if isinstance(custom_pal, dict):\n", " groups_in_palette = {\n", - " k: v for k, v in custom_pal.items() if k in color_groups\n", + " k: custom_pal[k] for k in all_plot_groups if k in color_groups\n", " }\n", "\n", " names = groups_in_palette.keys()\n", diff --git a/nbs/API/plot_tools.ipynb b/nbs/API/plot_tools.ipynb index 75574700..f60aaff1 100644 --- a/nbs/API/plot_tools.ipynb +++ b/nbs/API/plot_tools.ipynb @@ -871,7 +871,7 @@ "\n", "def summary_bars_plotter(summary_bars: list, results: object, ax_to_plot: object,\n", " float_contrast: bool,summary_bars_kwargs: dict, ci_type: str,\n", - " ticks_to_plot: list, color_col: str, swarm_colors: list, \n", + " ticks_to_plot: list, color_col: str, plot_palette_raw: dict, \n", " proportional: bool, is_paired: bool):\n", " \"\"\"\n", " Add summary bars to the contrast plot.\n", @@ -894,8 +894,8 @@ " List of indices of the contrast objects.\n", " color_col : str\n", " Column name of the color column.\n", - " swarm_colors : list\n", - " List of colors used in the plot.\n", + " plot_palette_raw : dict\n", + " Dictionary of colors used in the plot.\n", " proportional : bool\n", " Whether the data is proportional.\n", " is_paired : bool\n", @@ -913,7 +913,13 @@ "# End checks\n", " else:\n", " summary_xmin, summary_xmax = ax_to_plot.get_xlim()\n", - " summary_bars_colors = [summary_bars_kwargs.get('color')]*(max(summary_bars)+1) if summary_bars_kwargs.get('color') is not None else ['black']*(max(summary_bars)+1) if color_col is not None or (proportional and is_paired) or is_paired else swarm_colors\n", + " summary_bars_colors = (\n", + " [summary_bars_kwargs.get('color')]*(max(summary_bars)+1)\n", + " if summary_bars_kwargs.get('color') is not None\n", + " else ['black']*(max(summary_bars)+1)\n", + " if color_col is not None or (proportional and is_paired) or is_paired \n", + " else list(plot_palette_raw.values())\n", + " )\n", " summary_bars_kwargs.pop('color')\n", " for summary_index in summary_bars:\n", " if ci_type == \"bca\":\n", @@ -1024,7 +1030,6 @@ " swarm_bars_order = pd.unique(plot_data[xvar])\n", "\n", " swarm_means = plot_data.groupby(xvar)[yvar].mean().reindex(index=swarm_bars_order)\n", - " # swarm_bars_colors = [swarm_bars_kwargs.get('color')]*(max(swarm_bars_order)+1) if swarm_bars_kwargs.get('color') is not None else ['black']*(len(swarm_bars_order)+1) if color_col is not None or is_paired else swarm_colors\n", " swarm_bars_colors = (\n", " [swarm_bars_kwargs.get('color')] * (max(swarm_bars_order) + 1) \n", " if swarm_bars_kwargs.get('color') is not None \n", @@ -1038,7 +1043,7 @@ " 0.5, swarm_bars_y, zorder=-1,color=c,**swarm_bars_kwargs))\n", "\n", "def delta_text_plotter(results: object, ax_to_plot: object, swarm_plot_ax: object, ticks_to_plot: list, delta_text_kwargs: dict, color_col: str, \n", - " swarm_colors: list, is_paired: bool, proportional: bool, float_contrast: bool,\n", + " plot_palette_raw: dict, is_paired: bool, proportional: bool, float_contrast: bool,\n", " show_mini_meta: bool, mini_meta_delta: object, show_delta2: bool, delta_delta: object):\n", " \"\"\"\n", " Add text to the contrast plot.\n", @@ -1057,8 +1062,8 @@ " Keyword arguments for the delta text.\n", " color_col : str\n", " Column name of the color column.\n", - " swarm_colors : list\n", - " List of colors used in the plot.\n", + " plot_palette_raw : dict\n", + " Dictionary of colors used in the plot.\n", " is_paired : bool\n", " Whether the data is paired.\n", " proportional : bool\n", @@ -1083,7 +1088,13 @@ " delta_text_kwargs[\"va\"] = 'bottom' if results.difference[0] >= 0 else 'top'\n", " delta_text_kwargs.pop('x_location')\n", "\n", - " delta_text_colors = [delta_text_kwargs.get('color')]*(max(ticks_to_plot)+1) if delta_text_kwargs.get('color') is not None else ['black']*(max(ticks_to_plot)+1) if color_col is not None or (proportional and is_paired) or is_paired else swarm_colors\n", + " delta_text_colors = (\n", + " [delta_text_kwargs.get('color')]*(max(ticks_to_plot)+1)\n", + " if delta_text_kwargs.get('color') is not None\n", + " else ['black']*(max(ticks_to_plot)+1)\n", + " if color_col is not None or (proportional and is_paired) or is_paired\n", + " else list(plot_palette_raw.values())\n", + " )\n", " if show_mini_meta or show_delta2: delta_text_colors.append('black')\n", " delta_text_kwargs.pop('color')\n", "\n", diff --git a/nbs/API/plotter.ipynb b/nbs/API/plotter.ipynb index a14a71cd..d9bf2848 100644 --- a/nbs/API/plotter.ipynb +++ b/nbs/API/plotter.ipynb @@ -200,7 +200,8 @@ " plot_data=plot_data, \n", " xvar=xvar, \n", " show_pairs=show_pairs,\n", - " idx=idx\n", + " idx=idx,\n", + " all_plot_groups=all_plot_groups\n", " )\n", "\n", " # Initialise the figure.\n", @@ -608,7 +609,7 @@ " ci_type=ci_type, \n", " ticks_to_plot=ticks_to_plot, \n", " color_col=color_col,\n", - " swarm_colors=swarm_colors, \n", + " plot_palette_raw=plot_palette_raw, \n", " proportional=proportional, \n", " is_paired=is_paired\n", " )\n", @@ -622,7 +623,7 @@ " ticks_to_plot=ticks_to_plot, \n", " delta_text_kwargs=delta_text_kwargs, \n", " color_col=color_col, \n", - " swarm_colors=swarm_colors, \n", + " plot_palette_raw=plot_palette_raw, \n", " is_paired=is_paired,\n", " proportional=proportional, \n", " float_contrast=float_contrast, \n", diff --git a/nbs/tests/mpl_image_tests/baseline_images/test_207_gardner_altman_meandiff_empty_circle.png b/nbs/tests/mpl_image_tests/baseline_images/test_207_gardner_altman_meandiff_empty_circle.png index f8f4d10d..3abb704e 100644 Binary files a/nbs/tests/mpl_image_tests/baseline_images/test_207_gardner_altman_meandiff_empty_circle.png and b/nbs/tests/mpl_image_tests/baseline_images/test_207_gardner_altman_meandiff_empty_circle.png differ diff --git a/nbs/tests/mpl_image_tests/baseline_images/test_208_cummings_two_group_unpaired_meandiff_empty_circle.png b/nbs/tests/mpl_image_tests/baseline_images/test_208_cummings_two_group_unpaired_meandiff_empty_circle.png index f908be45..ea024cc7 100644 Binary files a/nbs/tests/mpl_image_tests/baseline_images/test_208_cummings_two_group_unpaired_meandiff_empty_circle.png and b/nbs/tests/mpl_image_tests/baseline_images/test_208_cummings_two_group_unpaired_meandiff_empty_circle.png differ diff --git a/nbs/tests/mpl_image_tests/baseline_images/test_211_cummings_multi_2_group_meandiff_empty_circle.png b/nbs/tests/mpl_image_tests/baseline_images/test_211_cummings_multi_2_group_meandiff_empty_circle.png index 0b324642..6c667f38 100644 Binary files a/nbs/tests/mpl_image_tests/baseline_images/test_211_cummings_multi_2_group_meandiff_empty_circle.png and b/nbs/tests/mpl_image_tests/baseline_images/test_211_cummings_multi_2_group_meandiff_empty_circle.png differ diff --git a/nbs/tests/mpl_image_tests/baseline_images/test_212_cummings_unpaired_delta_delta_meandiff_empty_circle.png b/nbs/tests/mpl_image_tests/baseline_images/test_212_cummings_unpaired_delta_delta_meandiff_empty_circle.png index 20cfda17..21667363 100644 Binary files a/nbs/tests/mpl_image_tests/baseline_images/test_212_cummings_unpaired_delta_delta_meandiff_empty_circle.png and b/nbs/tests/mpl_image_tests/baseline_images/test_212_cummings_unpaired_delta_delta_meandiff_empty_circle.png differ diff --git a/nbs/tests/mpl_image_tests/baseline_images/test_213_cummings_unpaired_mini_meta_meandiff_empty_circle.png b/nbs/tests/mpl_image_tests/baseline_images/test_213_cummings_unpaired_mini_meta_meandiff_empty_circle.png index 8bb6a91e..f34d9b4b 100644 Binary files a/nbs/tests/mpl_image_tests/baseline_images/test_213_cummings_unpaired_mini_meta_meandiff_empty_circle.png and b/nbs/tests/mpl_image_tests/baseline_images/test_213_cummings_unpaired_mini_meta_meandiff_empty_circle.png differ diff --git a/nbs/tests/mpl_image_tests/baseline_images/test_214_change_idx_order_custom_palette_original.png b/nbs/tests/mpl_image_tests/baseline_images/test_214_change_idx_order_custom_palette_original.png new file mode 100644 index 00000000..72a00bfa Binary files /dev/null and b/nbs/tests/mpl_image_tests/baseline_images/test_214_change_idx_order_custom_palette_original.png differ diff --git a/nbs/tests/mpl_image_tests/baseline_images/test_215_change_idx_order_custom_palette_new.png b/nbs/tests/mpl_image_tests/baseline_images/test_215_change_idx_order_custom_palette_new.png new file mode 100644 index 00000000..41fad519 Binary files /dev/null and b/nbs/tests/mpl_image_tests/baseline_images/test_215_change_idx_order_custom_palette_new.png differ diff --git a/nbs/tests/mpl_image_tests/test_plot_aesthetics.py b/nbs/tests/mpl_image_tests/test_plot_aesthetics.py index 3c74f069..bea92cce 100644 --- a/nbs/tests/mpl_image_tests/test_plot_aesthetics.py +++ b/nbs/tests/mpl_image_tests/test_plot_aesthetics.py @@ -9,6 +9,7 @@ mpl.use("Agg") import matplotlib.pyplot as plt import matplotlib.ticker as Ticker +import seaborn as sns from dabest._api import load @@ -146,6 +147,32 @@ def create_demo_dataset_delta(seed=9999, N=20): unpaired_mini_meta = load(df, idx=(("Control 1", "Test 1"), ("Control 2", "Test 2"), ("Control 3", "Test 3")), mini_meta=True) +multi_groups_change_idx_original = load( + df, + idx=( + ("Control 1", "Test 1", "Test 2"), + ("Control 2", "Test 3", "Test 4"), + ("Control 3", "Test 5", "Test 6"), + ), +) +multi_groups_change_idx_new = load( + df, + idx=( + ("Control 1", "Control 2", "Control 3"), + ("Test 1", "Test 3", "Test 5"), + ("Test 2", "Test 4", "Test 6"), + ), +) +palette = {"Control 1": sns.color_palette("magma")[5], + "Test 1": sns.color_palette("magma")[3], + "Test 2": sns.color_palette("magma")[1], + "Control 2": sns.color_palette("magma")[5], + "Test 3": sns.color_palette("magma")[3], + "Test 4": sns.color_palette("magma")[1], + "Control 3": sns.color_palette("magma")[5], + "Test 5": sns.color_palette("magma")[3], + "Test 6": sns.color_palette("magma")[1]} + @pytest.mark.mpl_image_compare(tolerance=8) def test_207_gardner_altman_meandiff_empty_circle(): return two_groups_unpaired.mean_diff.plot(empty_circle=True); @@ -173,3 +200,11 @@ def test_212_cummings_unpaired_delta_delta_meandiff_empty_circle(): @pytest.mark.mpl_image_compare(tolerance=8) def test_213_cummings_unpaired_mini_meta_meandiff_empty_circle(): return unpaired_mini_meta.mean_diff.plot(empty_circle=True); + +@pytest.mark.mpl_image_compare(tolerance=8) +def test_214_change_idx_order_custom_palette_original(): + return multi_groups_change_idx_original.mean_diff.plot(custom_palette=palette); + +@pytest.mark.mpl_image_compare(tolerance=8) +def test_215_change_idx_order_custom_palette_new(): + return multi_groups_change_idx_new.mean_diff.plot(custom_palette=palette); diff --git a/nbs/tutorials/07-forest_plot.ipynb b/nbs/tutorials/07-forest_plot.ipynb index 19b0c29a..76b2a2f2 100644 --- a/nbs/tutorials/07-forest_plot.ipynb +++ b/nbs/tutorials/07-forest_plot.ipynb @@ -9,7 +9,7 @@ "\n", "> Explanation of how to use forest_plot for contrast objects e.g delta-delta and mini-meta.\n", "\n", - "- order: 4" + "- order: 7" ] }, { @@ -17,17 +17,15 @@ "id": "cfdb7e31", "metadata": {}, "source": [ - "Version 20xx.xx.xx, DABEST now supports the comparison of different delta-delta or mini-meta analyses through a function called \"forest_plot\". \n", - "\n", - "As beautiful as a dabest plot is, sometimes we want to alter its appearance, be it to change the position of the legend, use different texts in the legend or the axis labels, to add or remove lines etc, or to change the color and alpha of some particular graphical elements. The rationale of using forest_plot is that we might want to move parts of the plot, especially the bootstrapped half violins onto a different axes for a meta-analysis, be it delta-delta or mini-meta." + "In DABEST version xx.xx.xx, we introduce a new function to plot separately calculated effect sizes in the same axes to allow direct visual comparisons. Currently you can make a forest plot for delta-delta and mini-meta effect sizes. " ] }, { "cell_type": "markdown", - "id": "872bbc20", + "id": "bf89df2d-dccc-4d78-86f8-e034d42a0302", "metadata": {}, "source": [ - "This tutorial notebook investigates how to conduct a meta-analysis with a forest plot of delta-delta / mini-meta bootstrapped half violins." + "# Forest plot of delta-delta effects" ] }, { @@ -35,23 +33,7 @@ "id": "6ca093af", "metadata": {}, "source": [ - "- Many experimental designs investigate the effects of two interacting independent variables on a dependent variable. The delta-delta effect size enables us to distill the net effect of the two variables. " - ] - }, - { - "cell_type": "markdown", - "id": "51b9a872", - "metadata": {}, - "source": [ - "- Consider 3 experiments where in each of the experiment we test the efficacy of 3 drugs named ``Drug1``, ``Drug2`` , and ``Drug3`` on a disease-causing mutation M based on disease metric Y. The greater the value Y has, the more severe the disease phenotype is. Phenotype Y has been shown to be caused by a gain-of-function mutation M, so we expect a difference between wild type (W) subjects and mutant subjects (M). Now, we want to know whether this effect is ameliorated by the administration of Drug treatment. We also administer a placebo as a control. In theory, we only expect Drug to have an effect on the M group, although in practice, many drugs have non-specific effects on healthy populations too." - ] - }, - { - "cell_type": "markdown", - "id": "ba696061", - "metadata": {}, - "source": [ - "- Throughout the tutorial, we will be exploring with a simulated dataset." + "First please revisit the notebook '[Delta-delta Tutorial](05-delta_delta.html)' for how to generate a delta-delta effect size. We will generate three of them plot them into the same axes. Here we test the efficacy of 3 drugs named ``Drug1``, ``Drug2`` , and ``Drug3`` on a disease-causing mutation ```M``` based on disease metric ```Tumor Size```. We want to know how the three drugs fare in ameliorating the phenotype metric ```Tumor Size```. " ] }, { @@ -61,8 +43,8 @@ "source": [ "| | Wildtype | Mutant |\n", "|-------|---------|----------|\n", - "| Drug1 | XD, W | XD, M |\n", - "| Placebo | XP, W | XP, M |" + "| Drug1 | XD1, W | XD1, M |\n", + "| Placebo | XP1, W | XP1, M |" ] }, { @@ -72,8 +54,8 @@ "source": [ "| | Wildtype | Mutant |\n", "|-------|---------|----------|\n", - "| Drug2 | XD, W | XD, M |\n", - "| Placebo | XP, W | XP, M |" + "| Drug2 | XD2, W | XD2, M |\n", + "| Placebo | XP2, W | XP2, M |" ] }, { @@ -83,8 +65,8 @@ "source": [ "| | Wildtype | Mutant |\n", "|-------|---------|----------|\n", - "| Drug3 | XD, W | XD, M |\n", - "| Placebo | XP, W | XP, M |" + "| Drug3 | XD3, W | XD3, M |\n", + "| Placebo | XP3, W | XP3, M |" ] }, { @@ -92,7 +74,7 @@ "id": "be4d9084", "metadata": {}, "source": [ - "There are two ``Treatment`` conditions, ``Placebo`` (control group) and ``Drug`` (test group). There are two ``Genotype``\\s: ``W`` (wild type population) and ``M`` (mutant population). Additionally, each experiment was conducted twice (``Rep1`` and ``Rep2``). We will perform several analyses to visualise these differences in a simulated dataset. " + "In each scenario, there are two ``Treatment`` conditions, ``Placebo`` (control group) and ``Drug`` (test group). There are two ``Genotype``\\'s: ``W`` (wild type population) and ``M`` (mutant population). Additionally, each experiment was conducted twice (``Rep1`` and ``Rep2``). We will perform several analyses to visualise these differences in a simulated dataset. We will simulate three separte datasets below. " ] }, { @@ -113,7 +95,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "We're using DABEST v2023.03.29\n" + "We're using DABEST v2024.03.29\n" ] } ], @@ -136,7 +118,7 @@ "id": "96a35aa6", "metadata": {}, "source": [ - "## Simulate datasets for the contrast objects" + "## Simulate datasets for the delta-delta contrast objects" ] }, { @@ -172,7 +154,7 @@ " 'Rep': rep,\n", " 'Genotype': genotype,\n", " 'Treatment': treatment,\n", - " 'Y': y\n", + " 'Tumor Size': y\n", " })\n", "\n", " return df\n", @@ -192,7 +174,7 @@ "id": "556f9b89", "metadata": {}, "source": [ - "### Creating contrast objects required for forest_plot" + "## Creating contrast objects required for delta-delta forest_plot" ] }, { @@ -200,54 +182,22 @@ "execution_count": null, "id": "09c54fb9", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/_dabest_object.py:668: FutureWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n", - " plot_data.loc[:, self.__xvar] = pd.Categorical(\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/_dabest_object.py:668: FutureWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n", - " plot_data.loc[:, self.__xvar] = pd.Categorical(\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/_dabest_object.py:668: FutureWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n", - " plot_data.loc[:, self.__xvar] = pd.Categorical(\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/_dabest_object.py:668: FutureWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n", - " plot_data.loc[:, self.__xvar] = pd.Categorical(\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/_dabest_object.py:668: FutureWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n", - " plot_data.loc[:, self.__xvar] = pd.Categorical(\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/_dabest_object.py:668: FutureWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n", - " plot_data.loc[:, self.__xvar] = pd.Categorical(\n" - ] - } - ], + "outputs": [], "source": [ "unpaired_delta_01 = dabest.load(data = df_delta2_drug1, \n", " x = [\"Genotype\", \"Genotype\"], \n", - " y = \"Y\", delta2 = True, \n", + " y = \"Tumor Size\", delta2 = True, \n", " experiment = \"Treatment\")\n", "unpaired_delta_02 = dabest.load(data = df_delta2_drug2, \n", " x = [\"Genotype\", \"Genotype\"], \n", - " y = \"Y\", delta2 = True, \n", + " y = \"Tumor Size\", delta2 = True, \n", " experiment = \"Treatment\")\n", "unpaired_delta_03 = dabest.load(data = df_delta2_drug3, \n", " x = [\"Genotype\", \"Genotype\"], \n", - " y = \"Y\", \n", + " y = \"Tumor Size\", \n", " delta2 = True, \n", " experiment = \"Treatment\")\n", - "paired_delta_01 = dabest.load(data = df_delta2_drug1, \n", - " paired = \"baseline\", id_col=\"ID\",\n", - " x = [\"Treatment\", \"Rep\"], y = \"Y\", \n", - " delta2 = True, experiment = \"Genotype\")\n", - "paired_delta_02 = dabest.load(data = df_delta2_drug2,\n", - " paired = \"baseline\", id_col=\"ID\",\n", - " x = [\"Treatment\", \"Rep\"], y = \"Y\", \n", - " delta2 = True, experiment = \"Genotype\")\n", - "paired_delta_03 = dabest.load(data = df_delta2_drug3,\n", - " paired = \"baseline\", id_col=\"ID\",\n", - " x = [\"Treatment\", \"Rep\"], y = \"Y\", \n", - " delta2 = True, experiment = \"Genotype\")\n", - "contrasts = [unpaired_delta_01, unpaired_delta_02, unpaired_delta_03]\n", - "paired_contrasts = [paired_delta_01, paired_delta_02, paired_delta_03]" + "contrasts = [unpaired_delta_01, unpaired_delta_02, unpaired_delta_03]" ] }, { @@ -264,7 +214,11 @@ "metadata": {}, "source": [ "To create a delta-delta plot, you simply need to set ``delta2=True`` in the \n", - "``dabest.load()`` function and ``mean_diff.plot()``" + "``dabest.load()`` function and ``mean_diff.plot()``\n", + "\n", + "In this case,``x`` needs to be declared as a list consisting of 2 elements, unlike most cases where it is a single element. \n", + "The first element in ``x`` will represent the variable plotted along the horizontal axis, and the second one will determine the \n", + "color of dots for scattered plots or the color of lines for slope graphs. We use the ``experiment`` input to specify the grouping of the data." ] }, { @@ -273,61 +227,11 @@ "id": "36a5e3fd", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/plot_tools.py:1232: UserWarning: 20.0% of the points cannot be placed. You might want to decrease the size of the markers.\n", - " warnings.warn(err)\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/plot_tools.py:1232: UserWarning: 20.0% of the points cannot be placed. You might want to decrease the size of the markers.\n", - " warnings.warn(err)\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/plot_tools.py:1232: UserWarning: 25.0% of the points cannot be placed. You might want to decrease the size of the markers.\n", - " warnings.warn(err)\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/plot_tools.py:1232: UserWarning: 35.0% of the points cannot be placed. You might want to decrease the size of the markers.\n", - " warnings.warn(err)\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/plot_tools.py:1232: UserWarning: 20.0% of the points cannot be placed. You might want to decrease the size of the markers.\n", - " warnings.warn(err)\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/plot_tools.py:1232: UserWarning: 15.0% of the points cannot be placed. You might want to decrease the size of the markers.\n", - " warnings.warn(err)\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/plot_tools.py:1232: UserWarning: 20.0% of the points cannot be placed. You might want to decrease the size of the markers.\n", - " warnings.warn(err)\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/plot_tools.py:1232: UserWarning: 30.0% of the points cannot be placed. You might want to decrease the size of the markers.\n", - " warnings.warn(err)\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/plot_tools.py:1232: UserWarning: 35.0% of the points cannot be placed. You might want to decrease the size of the markers.\n", - " warnings.warn(err)\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/plot_tools.py:1232: UserWarning: 25.0% of the points cannot be placed. You might want to decrease the size of the markers.\n", - " warnings.warn(err)\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/plot_tools.py:1232: UserWarning: 35.0% of the points cannot be placed. You might want to decrease the size of the markers.\n", - " warnings.warn(err)\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/plot_tools.py:1232: UserWarning: 45.0% of the points cannot be placed. You might want to decrease the size of the markers.\n", - " warnings.warn(err)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -335,9 +239,9 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqEAAAG1CAYAAADJDS1OAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAACWpUlEQVR4nOzdd1hUR9sG8PvsArt0UKmCdEHFihWN2CIqscYSjYo1vkmMUZO8edUY1CRqmsbEWFKsiSkmttg71th7C6iooBQLve/O9wdhP1dA+i4L9++6uJKdM2fOs8ctz86ZmSMJIQSIiIiIiHRIpu8AiIiIiKjmYRJKRERERDrHJJSIiIiIdI5JKBERERHpHJNQIiIiItI5JqFEREREpHNMQomIiIhI55iEEhEREZHOMQklIiIiIp1jEkpUDRw8eBCSJOHgwYMGGcOqVasgSRKioqIqPK6y0mVMubm5+O9//wtXV1fIZDL069ev0o9JRKRvTEKJdCQ/qcn/UyqVcHZ2RnBwML7++mukpKRU6PHWrVuHr776qkLb1KUlS5Zg1apV+g6jTEp77lesWIHPP/8cAwcOxOrVqzFlypTKCw5Ap06dNK9DmUwGKysr+Pr6YsSIEdizZ0+lHrus1Go1Vq1ahT59+sDV1RXm5ubw9/fHxx9/jMzMTH2HR0RlYKTvAIhqmjlz5sDDwwM5OTmIjY3FwYMHMXnyZCxYsABbtmxBkyZNKuQ469atw+XLlzF58uQKaU/XlixZgjp16mDUqFH6DqXUSnvu9+/fj7p162LhwoWVG9hTXFxcMG/ePABAWloaIiMjsWHDBvz0008YPHgwfvrpJxgbG+ssnuKkp6dj9OjRaNu2Lf7zn//A3t4ex48fR1hYGPbt24f9+/dDkiR9h0lEpcAklEjHevbsiZYtW2oeT5s2Dfv378dLL72EPn364Nq1azA1NdVjhKRr8fHxsLGxqbD21Go1srOzoVQqi6xjbW2N4cOHa5XNnz8fkyZNwpIlS+Du7o5PP/20XMeoSCYmJjh69CgCAwM1ZePHj4e7u7smEe3WrZtOYiGiisHL8URVQJcuXTBz5kzcuXMHP/30k9a269evY+DAgahVqxaUSiVatmyJLVu2PLe9Tp06Ydu2bbhz547msqu7uzsAIDs7Gx9++CECAgJgbW0Nc3NzvPDCCzhw4ECJ442Ojka/fv1gbm4Oe3t7TJkyBVlZWYXWPXHiBHr06AFra2uYmZkhKCgIR48efW777u7uuHLlCsLDwzXxd+rUCQDw+PFjvPvuu2jcuDEsLCxgZWWFnj174sKFCyWKXZIkTJw4ET///DN8fX2hVCoREBCAQ4cOlWj/JUuWoFGjRlAoFHB2dsabb76JxMREzfbnnftnRUVFQZIkHDhwAFeuXNHUzx9Xm5aWhnfeeQeurq5QKBTw9fXFF198ASFEkc8pP7adO3eW6Pk8TS6X4+uvv0bDhg2xePFiJCUlFXuMosYC5z+3Z4dUrF+/Hg0bNoRSqYS/vz82btyIUaNGFXmO8pmYmGgloPn69+8PALh27Vqpny8R6Rd7QomqiBEjRmD69OnYvXs3xo8fDwC4cuUK2rdvj7p16+J///sfzM3N8fvvv6Nfv374888/NV/Az5oxYwaSkpIQHR2tucRrYWEBAEhOTsYPP/yAoUOHYvz48UhJScGPP/6I4OBgnDx5Es2aNXtunBkZGejatSvu3r2LSZMmwdnZGWvXrsX+/fsL1N2/fz969uyJgIAAhIWFQSaTYeXKlejSpQsOHz6M1q1bF3qMr776Cm+99RYsLCwwY8YMAICDgwMA4NatW9i0aRMGDRoEDw8PxMXFYfny5QgKCsLVq1fh7Oxc7LkODw/Hb7/9hkmTJkGhUGDJkiXo0aMHTp48CX9//yL3mzVrFmbPno1u3brh9ddfx40bN7B06VKcOnUKR48ehbGx8XPP/bPs7Oywdu1afPLJJ0hNTdVcHm/QoAGEEOjTpw8OHDiAsWPHolmzZti1axfee+89xMTEFLh0v3//fvz++++YOHEi6tSpU2xSVxS5XI6hQ4di5syZOHLkCEJCQp57jKcT8OJs27YNQ4YMQePGjTFv3jw8efIEY8eORd26dcsUKwDExsYCAOrUqVPmNohITwQR6cTKlSsFAHHq1Kki61hbW4vmzZtrHnft2lU0btxYZGZmasrUarUIDAwUPj4+mrIDBw4IAOLAgQOaspCQEOHm5lbgGLm5uSIrK0ur7MmTJ8LBwUGMGTOm2Ofx1VdfCQDi999/15SlpaUJb29vrRjUarXw8fERwcHBQq1Wa+qmp6cLDw8P8eKLL2rK8s/N7du3NWWNGjUSQUFBBY6fmZkpVCqVVtnt27eFQqEQc+bMKTZ+AAKAOH36tKbszp07QqlUiv79+xcZU3x8vDAxMRHdu3fXOv7ixYsFALFixQpNWVHnvihBQUGiUaNGWmWbNm0SAMTHH3+sVT5w4EAhSZKIjIzUek4ymUxcuXKlzMd72saNGwUAsWjRomKPUdhrT4i8fxMAYuXKlZqyxo0bCxcXF5GSkqIpO3jwoABQqvP1tG7dugkrKyvx5MmTMu1PRPrDy/FEVYiFhYVmlvzjx4+xf/9+DB48GCkpKXj48CEePnyIR48eITg4GBEREYiJiSn1MeRyOUxMTADkjet7/PgxcnNz0bJlS5w9e7bY/bdv3w4nJycMHDhQU2ZmZobXXntNq9758+cRERGBYcOG4dGjR5r409LS0LVrVxw6dAhqtbrU8SsUCshkeR9dKpUKjx49goWFBXx9fUsUPwC0a9cOAQEBmsf16tVD3759sWvXLqhUqkL32bt3L7KzszF58mTN8YG8cYlWVlbYtm1bqZ/L82zfvh1yuRyTJk3SKn/nnXcghMCOHTu0yoOCgtCwYcMKOXZ+z+2zKzaU5xj379/HpUuXMHLkSK2e4aCgIDRu3LhMbc6dOxd79+7F/PnzK3RMLRHpBi/HE1UhqampsLe3BwBERkZCCIGZM2di5syZhdaPj48v06XM1atX48svv8T169eRk5OjKffw8ND8f0JCglZCZmFhAQsLC9y5cwfe3t4FZiL7+vpqPY6IiAAAhIaGFhlHUlISbG1tSxW7Wq3GokWLsGTJEty+fVsrxtq1a5eoDR8fnwJl9evXR3p6OhISEuDo6Fhg+507dwAUfJ4mJibw9PTUbK8od+7cgbOzMywtLbXKGzRooBVPvqf/7corNTUVAAocuzzHyI/X29u7wDZvb+8S/4DI99tvv+GDDz7A2LFj8frrr5c5LiLSHyahRFVEdHQ0kpKSNF/S+b2E7777LoKDgwvdp7Av9OL89NNPGDVqFPr164f33nsP9vb2kMvlmDdvHm7evKmp16pVK61EJywsDLNmzSrxcfLj//zzz4scZ1rUWMnnmTt3LmbOnIkxY8bgo48+Qq1atSCTyTB58uQy9axWFxW5osLly5cBFHx9FXaMopZFKqpHuSLs2bMHI0eOREhICJYtW1ZpxyGiysUklKiKWLt2LQBoEk5PT08AgLGxcZmWnikqOfjjjz/g6emJDRs2aNUJCwvTqvfzzz8jIyND8zg/Hjc3N1y+fBlCCK39b9y4obW/l5cXAMDKyqrC4+/cuTN+/PFHrfLExMQST07J76V92j///AMzMzPY2dkVuo+bmxuAvOeZfy6AvNUGbt++rfUcK2K9Sjc3N+zduxcpKSlaPZLXr1/XiqeiqVQqrFu3DmZmZujQoUOx9fN7sp+doPRsT21+vJGRkQXaKKysKCdOnED//v3RsmVL/P777zAy4tcYkaHimFCiKmD//v346KOP4OHhgVdffRUAYG9vj06dOmH58uV48OBBgX0SEhKe26a5ubnWEjv55HI5AGgt83PixAkcP35cq1779u3RrVs3zV9+4tWrVy/cv38ff/zxh6Zueno6vvvuO639AwIC4OXlhS+++EJzebe08Rc281oulxdYomj9+vWlGh97/Phxrcu/9+7dw+bNm9G9e3fN+XlWt27dYGJigq+//lrr+D/++COSkpK0ZpEXde5Lo1evXlCpVFi8eLFW+cKFCyFJEnr27Fmu9gujUqkwadIkXLt2DZMmTYKVlVWx+7i5uUEulxdY4mrJkiVaj52dneHv7481a9ZovR7Cw8Nx6dKlEsV37do1hISEwN3dHVu3buV6ukQGjj8hiXRsx44duH79OnJzcxEXF4f9+/djz549cHNzw5YtW7QW//7222/RoUMHNG7cGOPHj4enpyfi4uJw/PhxREdHP3dtzICAAPz222+YOnUqWrVqBQsLC/Tu3RsvvfQSNmzYgP79+yMkJAS3b9/GsmXL0LBhw0KTxWeNHz8eixcvxsiRI3HmzBk4OTlh7dq1MDMz06onk8nwww8/oGfPnmjUqBFGjx6NunXrIiYmBgcOHICVlRX++uuv58a/dOlSfPzxx/D29oa9vT26dOmCl156CXPmzMHo0aMRGBiIS5cu4eeff9bqnSyOv78/goODtZZoAoDZs2cXuY+dnR2mTZuG2bNno0ePHujTpw9u3LiBJUuWoFWrVloLvxd17kujd+/e6Ny5M2bMmIGoqCg0bdoUu3fvxubNmzF58mRNT3NZJSUladakTU9P19wx6ebNm3jllVfw0Ucflagda2trDBo0CN988w0kSYKXlxe2bt2K+Pj4AnXnzp2Lvn37on379hg9ejSePHmCxYsXw9/fv9jXXkpKCoKDg/HkyRO89957BSaCeXl5oV27diV89kRUJehzaj5RTZK/5E/+n4mJiXB0dBQvvviiWLRokUhOTi50v5s3b4qRI0cKR0dHYWxsLOrWrSteeukl8ccff2jqFLZMTmpqqhg2bJiwsbHRWgJHrVaLuXPnCjc3N6FQKETz5s3F1q1bRWhoaImXyblz547o06ePMDMzE3Xq1BFvv/222LlzZ6FL9Zw7d04MGDBA1K5dWygUCuHm5iYGDx4s9u3bV+DcPL1EU2xsrAgJCRGWlpYCgGa5pszMTPHOO+8IJycnYWpqKtq3by+OHz8ugoKCCl3S6VkAxJtvvil++ukn4ePjozkHz8ZdWExC5C3J5OfnJ4yNjYWDg4N4/fXXCywPVNS5L0pRSyalpKSIKVOmCGdnZ2FsbCx8fHzE559/rrXk1dPPqaSCgoK0XosWFhbCx8dHDB8+XOzevbvQfZ53jISEBPHyyy8LMzMzYWtrKyZMmCAuX75cYIkmIYT49ddfhZ+fn1AoFMLf319s2bJFvPzyy8LPz++5Mecv+VTUX2hoaImfPxFVDZIQz1zXIiKqxiRJwptvvlngMjfpT7NmzWBnZ4c9e/boOxQi0iGOCSUiIp3IyclBbm6uVtnBgwdx4cIFzW1Ziajm4JhQIiLSiZiYGHTr1g3Dhw+Hs7Mzrl+/jmXLlsHR0RH/+c9/9B0eEekYk1AiItIJW1tbBAQE4IcffkBCQgLMzc0REhKC+fPnl/hGA0RUfXBMKBERERHpHMeEEhEREZHOMQklIiIiIp1jEkpEREREOscklIiIiIh0jkkoEREREekck1AiIiIi0jkmoURERESkc0xCiYiIiEjnmIQSERERkc4xCSUiIiIinWMSSkREREQ6xySUiIiIiHSOSSgRERER6RyTUCIiIiLSOSahRERERKRzTEKJiIiISOeYhBIRERGRzjEJJSIiIiKdYxJKRERERDrHJJSIiIiIdI5JKBERERHpXI1PQh88eIBZs2bhwYMH+g6FiIiIqMZgEvrgAWbPns0klIiIiEiHanwSSkRERES6xySUqITSE+7iceRpqLIz9R0KERGRwTPSdwBEhiD+0gH8s/kLAIBprbpoOvYrGCnM9BwVERGR4WISSlSE7JTHiD23EzITJRIuH9SUZzyOQVLUBdT2bae/4IiIiAwck1CiQqhzc3Bh1TvISn4ICAFjCxtAkgFCDQBQWNXRb4BEREQGjkkoUSEyE2ORlRSveZyTnoJa3q2Q8eQBnFv1hoWTjx6jIyIiMnxMQokKobC2h7G5LXLSkwAA1vUaoeGQD/UcFRERUfXBJJSoEHJjBZqO+gL3T/8FubESddsO0HdIRERE1QqTUKIiKG0d4fnieH2HQUREVC1xnVAiIiIi0jkmoURERESkc9UqCZ0/fz4kScLkyZP1HQoRERERPUe1SUJPnTqF5cuXo0mTJvoOhYiIiIiKUS2S0NTUVLz66qv4/vvvYWtrq+9wiIiIiKgY1SIJffPNNxESEoJu3boVWzcrKwvJycmav9TUVB1ESERERERPM/glmn799VecPXsWp06dKlH9efPmYfbs2ZUcFRERERE9j0H3hN67dw9vv/02fv75ZyiVyhLtM23aNCQlJWn+wsPDKzlKqg6EEEi4cgh3Dq5F6oMIfYdDRERk8CQhhNB3EGW1adMm9O/fH3K5XFOmUqkgSRJkMhmysrK0thXm7NmzCAgIwJkzZ9CiRYvKDrncsnNzsfjPAzj3zz209HPDmwM6waiY50hlI4RAxsN7kBkr8DjiJG7tWgZIMkiSDM3Gfw1zOzd9h0hERGSwDPpyfNeuXXHp0iWtstGjR8PPzw/vv/9+sQmoIdp06Dx2/n0FAsDWY5fg5lAb/To203dY1Y4QAhF/LUT8xX0AANM69f7doIYQaiTfucQklAyOKicTyXevQGFtD7M6rvoOh4hqOINOQi0tLeHv769VZm5ujtq1axcory4eJ6dBkkkQagGZTMKjZE6sqgxZiXGaBBQAMp/cz/sfSQYIAcu6fnqKjKhsVNkZOP/jZGQ8igYA1O/3Huz9O+k3KCKq0Qx6TGhNFNymERTGeb8dTE2M0b11Qz1HVD3JTUwBScp7IEkwMrOGZ4/X4dg8GP7DPoKFk7d+AyQqpcTb5zUJKADcP7FJf8EQEUHHPaF3797F3LlzceDAASQkJGDTpk3o2LEjHj58iDlz5mD06NFo3rx5uY5x8ODBigm2ivJwqoPVM0bh1v2H8KprBxsLM32HVC0Zm1vDp/cURO1bCbmJKer3mQIrVyb8ZLgUVnX+/4Ekg8LaTn/BEBFBh0no1atX8cILL0CtVqNNmzaIjIxEbm4uAKBOnTo4cuQI0tLS8OOPP+oqJINla2mO5j5mkMkkfYdSrTk06QqHJl31HQZRhbBw8oFXzzdw/+QWKG2d4NXjdX2HREQ1nM6S0P/+97+wsbHB33//DUmSYG9vr7U9JCQEv/32m67CMVipGZn44PstuHr7Ppp4u2DO2D4wU5roOywiMgBOASFwCgjRdxhERAB0OCb00KFDeP3112FnZwdJKtiDV69ePcTExOgqHIP158FzuBb1AALAxZsx2HzkvL5DMlgtW7aEi4sLWrZsqe9QiHRCrcpFSswNZCU/1HcoRES66wlVq9UwMyt6/GJCQgIUCoWuwjFYObkqQAIg8v6TnaPSd0gGKzY2lj98qMZQ5WTh0pr3kfogApJMDr+Xp6G2bzt9h0VENZjOekJbtGiBbdu2FbotNzcXv/76K9q2baurcAxW3xeaws7GEgDgWMsKvds30XNERGQIEm+f19ztS6hVuHf0dz1HREQ1nc56QqdNm4aXXnoJr7/+Ol555RUAQFxcHPbu3Yu5c+fi2rVrWLx4sa7CMVh2NpZYNT0Uj5LSUMfaAnI5V9kiouIZm1n9/wNJBmMzG73FQkQE6DAJ7dmzJ1atWoW3334b3333HQBg+PDhEELAysoKa9asQceOHXUVjkEzksvhUMuq+IpERP+ycmkAt86huH9yM5S2jvDq8R99h0RENZxO1wkdMWIEBgwYgD179iAiIgJqtRpeXl4IDg6GpaWlLkMhIqpxXNsPhmv7wfoOg4gIgB5u22lubo5+/frp+rBEREREVIXobEChp6cn2rVrhxs3bhS6ffPmzfD09NRVOEQlplbl4uauZTiz5DXc3LkUalWuvkMiIiIyeDpLQqOionD27Fm0bt0amzZtKrA9NTUVd+7c0VU4RCUWe2Y7Hpz6CxmPY/Dg9FY8OFP4Kg9ERERUcjqdWr1gwQJ07NgRL7/8MmbOnKnLQxOVWVZyAiD9+1aRZMhOTtBvQERERNWATpNQW1tb/PXXXwgLC8O8efMQEhKCpKQkXYZAVGJCCGQ8fgBbr5aQGefdGlVmbAL7Jt30HBlR2SRGXcCNjZ/jzsG1UOVk6TscIqrhdD4xCQA+/PBDtG7dGsOHD0erVq2wceNGfYRB9FyR2xcj7txOAIBb51CYO3jAwsELJpa19BwZUellPI7BlXUzIYQaAJCTngTvXhP1HBUR1WR6W+m8R48eOHXqFMzNzdG2bVts3rxZX6EQFZCZGKdJQAEg+uh61PJuxQSUDFZafBSEWgUIAQiBlJjCJ4kSEemKXm+34+HhgePHj2PAgAH4448/9BkKkRaZsQKQpH8fSZCbKPUaD1F5Wbk0gJHSAkDe67pOg/b6DYiIajydXY4/cOAAGjRoUKBcqVRi9erVGDx4MB4+fKircIiey8TcBt693kLUvhWQmSjh2/ddfYdEVC4mFrXQbNzXeHjtCJQ2jqjtF6jvkIiohtNZEhoUFPTc7SEhITqKhKhkHJsHw7F5sL7DIKowShsHuLR7Wd9hEBEBqMQkdM2aNQDybtUpSZLm8fNIkoQRI0ZUVkhEREREVEVIQghRGQ3LZDJIkoSMjAyYmJhAJit++KkkSVCpVJURTpHOnj2LgIAAnDlzBi1atNDpsQvTsmVLxMbGwtHREadPn35uXbVa4Lsth7D39HV4OtfBtBE9YWtppqNIDZ+LiwtiYmJQt25dREdHF1lPqFW4d3Q9Uu//g9q+7eDQ7EUdRklERFQ9VVpP6O3btwEAJiYmWo/p+WJjYxETE1Oiusev3MSf4ecAABduRmPV9mOYMoRrWFa0mL834G74TwAEHkecgImlLWy9Wuo7LKICSvMjlohI3yotCXVzc3vuYyq7f+7F4ertB0hMS9eUCQEkpWXoMarqKy0uKm9CsQAACWlxt5mEUpVUmh+xRET6ppfF6gEgOzsbJ06cwIMHD+Dr64umTZvqKxSDciHyHt5bsgFCCEgA7GwskJCYCmMjOQZ20v9wguqoTsMOSLhyEAAgyY1g4eSD5OhrsHD0gszIRL/BERERGahKTUJ37dqF3377DZ999hnq1KmjKb9+/Tr69OmDmzdvasr69++PX3/9FUZGesuLDcKRizchSXk9n5JMQscmPujUwheOta1gY8HxoKXh6Oio9d9nJVwJR9S+lZCbmMK711tQq3IgyY1w5ZcPIdQqmNm5oenoLyE3MdVl2ERERNVCpS5Wv2LFCly4cEErAQWAV199FZGRkRg5ciS+/vpr9OjRAxs3bsQ333xTmeFUC57OdaBW580lU6sFfOo5wM/NkQloGZw+fRrR0dGFjp3LSU/CjU1fICs5AemP7uHe0d/g3Ko3Eq6E5911BkB6wh08jjil67CJiIiqhUrtdjx9+jQGDhyoVXbu3DmcO3cOr776KlauXAkAePPNNxEUFISff/4ZU6ZMqcyQDF6PNo2QnpmNizej0dynHrq08NV3SAbreZM4cjPTgX/vsQ0hkJORDCBvEXtIMs02Y3NrXYZMRERUbVRqEhobGwtvb2+tsp07d0KSJIwaNUqrvF+/fvjwww8rM5xqQZIkvNypBV7m+M9ye94kDqWtI+o07IiHVw8BAOq9MAwA4PHieOSkJSLjUQwcW/SEtVuTvMv0MiNIkgS1KgeqrHQYmVpB0tz2k4iIiJ5VqUmohYUF0tPTtcqOHDkCmUyGNm3aaJXb2NjofI1QoqJIkgTf/v+FS+BAyI2VUFjb4/a+FUh9EAm7Rp3g2KIHhFAjctvXiDu/G8bmtvB4cSxu7VqO3IwU2Hq3QoNBH0Am5xhnIiKiwlTqN2SDBg2wefNmvP322wCAJ0+e4NChQwgMDISFhYVW3Xv37hU5QYT+X65Khe82H8bZiHto5eeGcS91gFxeqUN7a6zslEd4dP0Y5CZK5GSkIubvDYAQSIq6AIWNAyRJQtz53QCAnPRE3Nq5DLlZaQCAJ5Gn8CTyFGr7ttPnUyAiIqqyKjUJfeedd9C3b1/07NkTgYGB+Ouvv5Ceno433nijQN2dO3eiefPmpT7G0qVLsXTpUkRFRQEAGjVqhA8//BA9e/Ysb/hV0ubDF7Dp8HkIAHdiH8G5jjV6t9de3upmTAKWbgpHrkqFsSEd0Nirrn6CNWDq3BxcWPUuslMeARAwNrP+d53QPOkP78KstovWPnmbNQuK5o0dJSIiokJV6rdk79698dlnn+H48eMICwvDlStXMHPmTAwZMkSr3t9//42///4bISEhpT6Gi4sL5s+fjzNnzuD06dPo0qUL+vbtiytXrlTU06hS4p+kQJLljTWUySTEPU4BAISf+wef/rwLmw+fxwffb8almzG4GvUAM77fhKzsXH2GbJAyE2ORnZyQNwFJCORkpCA/uZSbmMLGoylMa7mgtl+gpsyr+wSYWNgCAOz8O6GWNxe0p5olJy0JSXcuIzczTd+hEJEBqPQBa++++y6mTJmChw8fwt7evtDJGk2bNkVCQgJsbGxK3X7v3r21Hn/yySdYunQp/v77bzRq1KisYVdZL7ZugG3HLyFLnQsTIyN0a9kAp6/fwcdrtkMmSdh7+ppW/YysHKRmZEFhwrGJpaG0cYCJRS1kpyUCELBxbwK3TqFIi78NI6UlLq56D6qsdFi7N0WrSWtgbGYFmZEx7Bp3hlDlQmZkrO+nQFQpku5cRvrDO3l3DRMC909tgdxYCRuvFrjyaxjU2ZkwNrNG0zFfQWljr+9wiagK00lmIpfL4eDgUOR2U1NTmJqWf8FvlUqF9evXIy0tDe3aFT4WLysrC1lZWZrHqamp5T6uLnnXtcfK6aGIiI5HfVcH1LG2wJFLkZAkQC0EZJIE5zrWiE5IBAC0a+SJWlZcQ7S0ZEYmaDLqSzw4sxVyE1M4teqNjIS7MLd3x50Da6DKzrtFalLUBaTcv446fu0B5E1okpiAkgFQ5WQi5vgGZKc9gVOLXjB38Ci0XvylA4g+th4mlrVg69USt/d8DwCQGSshN1b8e5UAiL2wB+qcbABATkYK4i/tQ70XhurmyRCRQaoW3WOXLl1Cu3btkJmZCQsLC2zcuBENGzYstO68efMwe/ZsHUdYsexsLGGuVOCj1dtw6WYMfFztIUECJAG1EBjVMxDWFqbIUanQwqcelwoqI6WNPTy6jgEA3Nj0BRIuHwAAKGwc8fTYT966kwyFOjcbydHXobCyw53wtf8uQSYh4dIBtHzzR826t5lPHiD94T0Ym9vin81fAhBIf3gPKfcj/r+tnEyoczI1j3NSn+S9LQBAqPPW1CUieo5qkYT6+vri/PnzSEpKwh9//IHQ0FCEh4cXmohOmzYNU6dO1Tw+f/48goKCdBluhdhw6BzO3LgLIQSu3L6PPu2bwtbKHH71HBDg66bv8KqV7LRETQIKAFmJcVDaOiIzMQ4OTV+ErVeAHqMjKhlVdiYurHoH6fFRgCTBSGGed/9fCKiyM5D+8B6sza2RePsCrvwyE0KtglxhBs1EO6HO+8u/bzDw/0NWhICNZzMYKS2RfPcyatVvA4dm3fX0TInIUFSLJNTExESzKH5AQABOnTqFRYsWYfny5QXqKhQKKBQKzeNnl4oyFBmZ2f9/D3lIsDBV4NUXW+s7rGolO/UxYs/thiQ3gszIBOrcHEACjM2sEfDG9wAEJM6AJwORGHU+LwEF/v3g+Pe1K8lgZGoBcwd3AEDsuZ0Q/94RTJWVDhPLOshOeQgAqNfxVeSkJSEt/jbs/DvBxr0JYs/tgtxYCceAnpAbK3X8rIjIkFWLJPRZarVaa9ynIclfK7W4NVN7d2iCvaev4XFKOmpZmaNXu8bFtp2Ymg6ZJMHK3BSXb93H+ch78PdwRjMf1wqJvTpRq/KWaMpKSgCEgGVdX6iyMyDJjeDd841/hzhwmANVLc/7/DAxt/3/B5IMli5+qOXdGjlpT2DfpCskmRFS427BxLIWnh5u4t5tLIyVFjC2sIGFg2eBdjnuk4jKSidJaGZmJr777js0a9YMHTt2rNC2p02bhp49e6JevXpISUnBunXrcPDgQezatatCj6Mrz97DvDCnrkXh4q0YTB3yIhxqWcG5jjVMjJ//T/nznpNYtf0YJAno074pthy9ACCvQ+TjcX3RplHhkxJqqswnschKjNM8To29ifbTNukvIKISeN7nh2VdX3i8OB73T22B0tYJ3j3fhMKqDoC81/vpb8ciJy0RRmY2qO3bDukP78GuUUfYNXyB48qJqFLoJAlVKpV4//338fXXX1d4EhofH4+RI0fiwYMHsLa2RpMmTbBr1y68+OKLFXocXWnZsiViY2Ph6OhY6BfK8cu38OGPWyCTJPwqBOZN6A93p9rPbTMtIwurtx8DkJd0bjlyIe8+50JAJpNw4tptJqHPUFjbw9jcBjnpyQAAK9cGeo6o+op/kozZK7fhXvxj9GjdCK/3D2LSU0bFfX7UbdMPddv0AwBkJSUg4q+voM7NhiQ31rzWczOSYVqrLhoMnK7L0ImoBtLZ5Xh/f3/NXY0q0o8//ljhbepTbGwsYmJiitx+9p+7kMkkqNV5CeS5f+6ipV/eRKTs3FxsPXoJyWkZCG7TEBvDz2Pb8UtwqGUFSSZBqP9dbF0uQ65KDZmU104DN94u9VlyYwWahH6RtwaiiRIu7V7Wd0jV1vdbjiAyOh5qIbDx8HkE+LrxR1EZFff58bSrv81GWsIdAIBMboT/vyWYgJGSy7oRUeXTWRL6ySefYNiwYejcuTO6deumq8NWO/4ezth0+LwmEW3k4azZtvDXvdh35jokScKmw+eRlpm3Zl9MQiLcnWrj/sNESJKEd1/pjhyVCmdu3IG/Z110a8levsKY1nKCV/AEfYdR7aVmZkE8dU/UtEzDHM9tCGLP7cL9U1ugsHHMS0D/nYCkzs2GtUczpMbcgLV7Uzi16l1MS0RE5aezJHTx4sWoVasWgoOD4eHhAQ8PjwIL1EuShM2bN+sqJIMU1Lw+1ELg4s1oNPeph3b+noiMiYexkRFOXb8DAUAIoUlAAUBAwNJMiS3z3wQAzaXOrgF++ngKRFqGdWuNSzdjkJWTCx8Xe7Tz99J3SNVS6oNIRG77GgCQnnAXJpa1kJ2cN+vdwskb/kPnQJLJ9RkiEdUwOktCL168CEmSUK9ePahUKkRGRhaow3FgJdO5hS86t/AFAHzxy27sOnkVAFDPoRaS0zMhSYCZwhj1HGrjatQDmBgZYURwW57fCiKEQFrcLUgyOczt3fUdjsFr7FUXv8wah0dJaXC1t4VczmWvKkNWcsL/PxBqGJlaw73zKKhzs2HXqCMTUCLSOZ0loZUxHrQmysjKwfyfduBCZDT8PZ1x4mqUZlt0/BOMDG6L5PQMvBTYBC52trj/KBG2lmYwVyqKbpRKJXLb14g7vxsA4Np+CNw6j9RzRIbP0kwJSzOuMVmZrN2bQlnLGZmP7wMA6rbpC/vGnfUcFRHVZNVyndDqbMOhczh+5TaEEDhxNUozNlSSACtzJV7t3lqrx9PFzvY5rVFp5aQlaRJQALh3bD3qBb3KXiSq8owUZmg2dhGS716Gwtq+QC9+0t0ryM1Iho1ncyTduYy4C7thausE1xeGchF6IqoUOk9Cw8PDsW3bNty5kzcr083NDSEhIQZ560x9SP33crsQgEyS0L6xNyLuxcHYSI6pQ7rxknslkxkrIBkZQ+TmAgCMlBb/f+cZoirOSGGGWj6tIYRA9LH1SLgSDgsnH5hY1sa9w78AAEzruCLjUXTeZHkJyM1Mg3evifoNnIiqJZ0lodnZ2Rg6dCg2bdoEIQRsbGwAAImJifjyyy/Rv39//PLLLzA2NtZVSAapd/sm2HPqGpLSMmBtYYoJfV6AQy0rfYdlkEp6dyogbxzoo+vHkBobCbegkYg9ux2SzAjeIROZ+JPBeRxxAlH7VwEA0uKjIDMy0WzLeHjv/yuKvAlNRESVQWdJ6OzZs7Fx40a8++67eOedd+Dg4AAgb7H5L7/8Ep9//jnmzJmDjz76SFchGSTnOjZYO3M0ouMT4WJvC1MFk/ayKu7uVLlZ6Xh4JRwyE1OosjNwc/tiTa9nszELYeHkrYswiSpcVmK81mOZkQnUuTl5SzZJMshNTKHKSgMA1GlUsTcYISLKp7MkdN26dQgNDcVnn32mVW5vb49PP/0UcXFxWLt2LZPQEjBVmMDH1V7fYVRrQq3CxdXvIT0+CkDeHZQASbOuYuKdi0xC9UylUuPE1duQJAmtG7pDLuOwiOIk3r6AuPO7YWRqCSNTS+RmpACSBI8XX8Oj60eRk54El8BBMHfwwKMbx2Fq6wRb71b6DpuIqimdJaEPHjxAmzZtitzepk0b/Prrr7oKp1pQqdQ4fDECOblqdGzqA4UJ55lVlIwnDzQJKABkJT8EIPJ6QoUaVnW5xqq+zV61Fccv3wIAdGpeHzNG9tJzRFVbxuMYXPllJsS/P6Ts/Tujtl8gzOrUg2ntunBo0kWrft3WffURJhHVIDrLWlxcXHDw4EH85z//KXR7eHg4XFxcdBVOtTDvpx0IPx8BANj+9yUsmDiI4xMriMKyNuQKM6iyMwEA5g6ecGrRA6mxN1Hbty2sXBvqOcKaIS0jC5uPXIBKpUbvDk1w8moUjl6KhJtjbU0CCgAHz/2Dd155EUoTDk8pSlp8FIRapfW4ft939BgREdV0OktCQ0NDERYWBhsbG0yZMgXe3t6QJAkRERH46quvsH79esyePVtX4Rg8lVqNQ/8moABw+dZ9PEpOQx1rCz1GVX3ITUzReMR8RB/7A3KFKdw6DoeJZS19h1XtCSGw/fhlnP3nLhp71cWBszdw7U4sJAA7TlxBQmIKAODY5VtQGBshJzcvqbKxMIXCmFcCnsfKpSGMlBbIzUwDIFCnQXt9h0RENZzOPrWnT5+Omzdv4rvvvsP3338P2b/jt9RqNYQQCA0NxfTp03UVjsGTy2RwrmODB4+SAAAWZgpYmXMtv4pk4egFvwHv6zuMGuXguX/w1fp9kCTg0IX//5ElAE0CCgCSBPh7OkOSJEiShPEvdeBVgGKYWNii2biv8fDaEShtHFHbL1DfIRFRDaezJFQul2PVqlWYOnUqtm/frrVOaK9evdCkSRNdhWLQhBDYEH4OF29Go3MLX8QkJCJXpcKr3dvAxIg9QVT1tGzZErGxsXB0dCxyRYI7sY8Qk5CIq1H3IZMkqIWATCbBykyJ5LS8IRG1rc2RmJqBnFwVhABC2jXGC019dPlUDJ7SxgEu7V4uUJ6dlojcjGSY1nZlMk9EOqPzrKVJkyZMOMth54krWLb5EIC8S5L/G94DXQPyJslcuhmD/Wevw9W+Fvp2aMp7cFOVEBsbi5iYmCK3H74QgY9Wb4MQgLWFKcS/5UIITBrYBZExCVCp1OjXsRnSM7Nx9sZdeLvYw9/TWTdPwICUdO3b+ye3IP7Sfpg7esLa1R///LUQEGrYerdCw8EzeQcwItIJvXSdqdVqJCUlQQhRYFutWjV73F1xXyK37j/U3KpTJpNwKyYBXQP8cCf2Ed5b8gcEALVaIDk9E6N6ttNh5NVTbmYqJJkR5CYc6lBZ/jp6EfkfBUmpGRgR3AamChM08nBGQ3cn7d5Oa6CeQ83+jHie4ta+BYAnt87h1u7lAIDU2Jt4eO2IZumxJ5GnkBJzgxPviEgndJaE5uTk4NNPP8WKFStw7949qNXqQuupVKpCy2uK4r5EOjTxwuYjF/IeCCCwsRcA4MbdOKjU/5/UX7oZXWkx1hRRB1Yj+ujvkGRGqN9nCuz8O+k7pGrJsbY1ZJHRUP+biTbzcUUTL66UUVkynzz4/wdC/e/tOWWaRFSuMNNPYERU4+gsCZ0wYQJWr16Ntm3bol+/frC2ttbVoauVpt6uWDzlFVy5fR+NverC08kO1+/EwsbCFCZGcuSq1FALgVYN3PUdqkHLSkpA9NHfAQBCnYubO5cyCa0kr/XpgMzsHNyJfYSebfyZgFayWvXb4M7BtcjNSAYgoV7Qq4g9sx3ZqU/g2n4wzO3d9R0iEdUQOktC169fjxEjRmDVqlW6OmS1Vd/VAfVdHSCEwJxV23DkYt69nft2aApzUwVc7W0140SpjJ65+w7HyFUeC1Mlpo/oqVV27c4D7D19HXXrWKNvh2Yc31xB1LnZyHgUg4ZDZiErOR5mdVxhbu/OhemJSC90loSamZmhbdu2ujpctaVSq7Fu90mcj7wHH1cHTQIK5E1a2vrZRD1GV30oLGvDvcto3Dm4BpKRCbxfelvfIdUY9x8mYuo366EWAmq1wKPkNIzv/YK+wzJ4quxMXFg5FekJdwBJgm//99nrSUR6pbMkdOjQodi6dWuRd0yiktl+/BLW7PobAHDxZoxmORtJkmBrybFcFcklcCCc2/SDJJNBktgTpyv/3ItDrur/x4xfiOT45oqQGHU+LwEFACEQc/xP2DVkck9E+qOzJPSzzz7DmDFj8NJLL2HMmDFwdXWFXF7wEmeLFi10FZJBuhv3RGt2fNuGHoiKfQxThTGmDumm7/CqHZmca6/qWgM3J83dkNRCoJWfu75DqhZMzG3//4Ekg4llbf0FQ0QEHSahWVlZUKvV2LFjB3bs2FFgu/i3N6+mz44vTucW9fHX0YsABGSShFe7t0F9Vwd9h0VUISKj43E16gHef7U7/olOQN06NujeissFVQTLur7w6P4aHpzcAqWtE7x6vK7vkIiohtNZEjpmzBhs3LgRr7zyCtq0acPZ8WXU0N0Z3/13OK7fiUVDdye42NsWvxORAbh4Mxrvffsn1EJALpOw4K1BaOjOBekrUt3WfTkJiYiqDJ0lobt27cJbb72FhQsX6uqQ1VY9h1pcsJuqncMXIgEJgMhbuvLoxZtMQomIqjGdzbawsrKCt7e3rg5HRAbGw7kO1P/ecEGtFnB3qqPniIiIqDLprCd0/Pjx+OWXX/Cf//yn0AlJRFSz9WjdCGkZWbgQGY0W9V3RrSXXuiUiqs50loQ2bNgQmzdvRosWLRAaGlrk7PgBAwboKiQiqkL+uRcHW0szvPPKi1xujIioBtBZEjpkyBDN/7/77ruF1uHseKKaac+pq/hs3W4AgI2FKb7773DYWprrOSoiIqpMOktCDxw4UCntzps3Dxs2bMD169dhamqKwMBAfPrpp/D19a2U4xFRxdt54orm/xNTM3D6+l282KpBoXUfJ6dBaWIMM6WJrsIjIqJKoLMkNCgoqFLaDQ8Px5tvvolWrVohNzcX06dPR/fu3XH16lWYm7MnhUjfHB0dtf5bmHoOtXD51n2oRd7EJBd7G802tVogKycHShNjLPhtL3aeuAIjuQwzRvZChyac7EhEZKgM/nYwO3fu1Hq8atUq2Nvb48yZM+jYsaOeoiKifKdPny62Tv694e/GPUaPNo1Qt44tsrJzEfckGe8v24CHialo7FkXl27FAAByVWos23yISSgRkQHTWRLapUuXYutIkoR9+/aV6zhJSUkAgFq1uI4mUVXQsmVLxMbGwtHRsciEND0zG91aNoB3XTss33IYn63bDRMjOeq7OuBxUhoAaBJQAJAkwJirbBARGTSdJaFqtRqSJGmVqVQq3LlzB/fu3YO3tzfq1q1b7mNMnjwZ7du3h7+/f6F1srKykJWVpXmcmpparmMS0fPFxsYiJiamyO2nr9/BzB82I1elhkMtK8Q9TgYAZOeqEBEdr1X3hSbeOHb5FizNFJg6pFulxk1ERJVLZ0nowYMHi9y2detWvPbaa1iwYEG5jvHmm2/i8uXLOHLkSJF15s2bh9mzZ5frOERUcdYfOAOVSg0AmgQUyOvttDY3Ra5ajcfJaWjl54ZpI3pCLpNBklDgRy0RERmWKjEm9KWXXsLw4cMxefJkhIeHl6mNiRMnYuvWrTh06BBcXFyKrDdt2jRMnTpV8/j8+fOVNmmKiIpna2kGSZIg/p2U1Lm5L8LP/wNTpQneHdYdTbzqIiMrGxamSj1HSkREFalKJKEA4OXlhcWLF5d6PyEE3nrrLWzcuBEHDx6Eh4fHc+srFAooFArNYwsLi1Ifk4gqzmt9XsDjlDTcjX2Mnm39MbJHW7w3rDvkMhlksrzeTiagRETVT5VIQnNzc/H777+jTp3S3yv6zTffxLp167B582ZYWloiNjYWAGBtbQ1TU9OKDpWIKlgtK3N89vrLWmXGRpx0RERU3VVqEnro0CE0aNAAdnZ2GDNmTKF1EhMT8ffffyM2NrZMY0KXLl0KAOjUqZNW+cqVKzFq1KhSt0dEuqVSq/HXkYu4G/8YXVr4wt+zfBMUiYjIMFRqEtq5c2f89NNPGDp0KPbv319gIoEkSbC1tUWHDh0wbtw4dO/evdTHyB9HRkSG6efdJ7B21wnIZBK2H7+E5e8Nh5tjbX2HRURElaxSk1AhhCZJjIqKqsxDEZGBuhCZt3yTWp33WXH9biyTUCKiGkCm7wCIqGZr1cANACCTJBgbydHIw7nIupnZOTh8MRLnI+7xKggRkYGr9IlJXMuPiJ5nSJeWqG1ljrvxTxDU1AcudrZa25+kpOPBo0TUc6iF/y7dgIh7eQvYv/pia4zqFaiPkImIqAJUehI6fPhwDB8+vER1JUlCbm5uJUdERFWJJEkIal4fyWmZqG1lDgB4mJgKE2Mj3I17jPeXbUB2Ti5qW5njUXKaZr8tRy8yCSUiMmCVnoR269YN9evXr+zDEJGB+udeHN5fugGpGVlo6u0CFztbbDt+CTKZBB8Xe+TkqgAAj5LTIJNJEGoBSZLgXMdaz5ETEVF5VHoSGhoaimHDhlX2YYjIQK3Z+TfSMrMBABcio3EhMhpA3kSlW/cfQgKQP/rzlS6tcOlWDKzMlXi9H+90RkRkyKrEYvVEVHMZG8m0Es18EgArMyU869ohMjoeXVr4IrRnO81dlIiIyLAxCSUivRob0gE3Yx4i9lESugT4wcfFHiu2H4OZwhjvD++B5j6u+g6RiIgqAZNQIqpUjo6OWv99lou9LdZ8MBoqtRpyWd6qcS93aqGz+IiISD8qNQlVq9WV2TwRGYDTp0+XqF5+AkpERDUDP/WJiIiISOd4OZ6I9Co9MxvLNx/CnbjH6NGmEXq0aaTvkIiISAeYhBKRXv2w9Qh2nrgCtRC4cvs+XO1tn3vrTiIiqh54OZ6I9Ope/BOon7oPfExCov6CISIinWESSkR61fOpy+82FqZo1cBNj9EQEZGu8HI8EelVlwA/uNjbIjrhCZr71IOtpZm+QyIiIh1gEkpEelff1QH1XR30HQYREekQL8cTERERkc4xCSUiIiIinWMSSkREREQ6xySUiIiIiHSOE5OISK/UaoGdJ6/gbtxjdGpWH35ujvoOiYiIdIBJKBHp1S/7TmHV9mOQySRsPnwe3/13OFzta+k7LCIiqmS8HE9EenX2xl0AeT2iuSo1rkY90HNERESkC0xCiUivWtR3BQDIZBKM5DI0cHPSc0RERKQLvBxPRHo1tFtr2FiY4V78YwQ1r496DrwUT0RUEzAJJSK9kskkhAQ21ncYRESkY7wcT0REREQ6xySUiIiIiHSOl+MN1IMHD/DgAWcR64KTkxOcnDhZprLxNa07fE0TUVVQ45NQJycnhIWFGdQHclZWFoYOHYrw8HB9h1IjBAUFYdeuXVAoFPoOpdria1q3+JomoqpAEkIIfQdBpZOcnAxra2uEh4fDwsJC3+FUa6mpqQgKCkJSUhKsrKz0HU61xde07vA1TURVRY3vCTVkzZo145dIJUtOTtZ3CDUKX9OVj69pIqoqODGJiIiIiHSOSSgRERER6RyTUAOkUCgQFhbGSQU6wHOtGzzPusNzTURVBScmEREREZHOsSeUiIiIiHSOSSgRERER6RyTUCIiIiLSOSahVcysWbMgSZK+w9DE8fDhQ32HUilGjRoFd3d3fYeBUaNGcXF2IiKqkZiEPuX333+HJEnYuHFjgW1NmzaFJEk4cOBAgW316tVDYGDgc9seNWoUJEnS/FlZWaFp06b48ssvkZWVVWHPwdCsWrVKc06OHDlSYLsQAq6urpAkCS+99FKx7XXq1EnrPNeqVQutWrXCihUroFarK+MpVCu6fA9YWFjA09MTAwcOxJ9//llj/30q8z0gk8lgZWUFX19fjBgxAnv27KmMp0BEVCZMQp/SoUMHACjwRZCcnIzLly/DyMgIR48e1dp279493Lt3T7Pv8ygUCqxduxZr167F3LlzUatWLbz77rsIDQ2tuCdhoJRKJdatW1egPDw8HNHR0aVaTsbFxUVznmfOnInc3FyMHTsW06dPr8iQqyVdvgcWLlyIYcOGISIiAgMHDkTXrl1r9N18KuM9sGbNGnz++efo06cPjh07hu7du2PIkCHIycmpyNCJiMqEt+18irOzMzw8PAp8AR8/fhxCCAwaNKjAtvzHJfkCNjIywvDhwzWP33jjDbRp0wa//fYbFixYAGdn5wp4FoapV69eWL9+Pb7++msYGf3/y3LdunUICAgo1bAAa2trrfM8YcIE+Pr6YvHixfjoo49gbGxcobFXJ7p+DwDAxx9/jPnz52PatGkYP348fvvttyL3F0IgMzMTpqamJX1KBqMy3wMAMH/+fEyaNAlLliyBu7s7Pv300yL3V6vVyM7OhlKpLP0TISIqIfaEPqNDhw44d+4cMjIyNGVHjx5Fo0aN0LNnT/z9999alw2PHj0KSZLQvn37Uh9LJpOhU6dOAICoqKgi661cuRJdunSBvb09FAoFGjZsiKVLlxZad8eOHQgKCoKlpSWsrKzQqlWrAr0rJ06cQI8ePWBtbQ0zMzMEBQUV6N3K9/DhQwwePBhWVlaoXbs23n77bWRmZmrVyc3NxUcffQQvLy8oFAq4u7tj+vTppRpmMHToUDx69EjrcmF2djb++OMPDBs2rMTtFMbMzAxt27ZFWloaEhISiqz3xRdfIDAwELVr14apqSkCAgLwxx9/FFr3p59+QuvWrWFmZgZbW1t07NgRu3fv1qqzY8cOvPDCCzA3N4elpSVCQkJw5cqVQtu7desWgoODYW5uDmdnZ8yZMwfPLuGblpaGd955B66urlAoFPD19cUXX3xRoF556fI9kO9///sfunfvjvXr1+Off/7RlLu7u+Oll17Crl270LJlS5iammL58uWIioqCJElYtWpVgbYkScKsWbO0yg4ePIiWLVtCqVTCy8sLy5cvrzLjr/NV5nsAAORyOb7++ms0bNgQixcvRlJSkmabJEmYOHEifv75ZzRq1AgKhQI7d+7EwYMHIUkSDh48qNVWUed//fr1aNiwIZRKJfz9/bFx48YqM/6aiKoeJqHP6NChA3JycnDixAlN2dGjRxEYGIjAwEAkJSXh8uXLWtv8/PxQu3btMh3v5s2bAPDc/ZcuXQo3NzdMnz4dX375JVxdXfHGG2/g22+/1aq3atUqhISE4PHjx5g2bRrmz5+PZs2aYefOnZo6+/fvR8eOHZGcnIywsDDMnTsXiYmJ6NKlC06ePFng2IMHD0ZmZibmzZuHXr164euvv8Zrr72mVWfcuHH48MMP0aJFCyxcuBBBQUGYN28eXnnllRKfB3d3d7Rr1w6//PKLpmzHjh1ISkoqVTtFuXXrFuRyOWxsbIqss2jRIjRv3hxz5szB3LlzYWRkhEGDBmHbtm1a9WbPno0RI0bA2NgYc+bMwezZs+Hq6or9+/dr6qxduxYhISGwsLDAp59+ipkzZ+Lq1avo0KFDgR8cKpUKPXr0gIODAz777DMEBAQgLCwMYWFhmjpCCPTp0wcLFy5Ejx49sGDBAvj6+uK9997D1KlTy31+nqbr90C+ESNGQAhRYNzijRs3MHToULz44otYtGgRmjVrVqp2z507hx49euDRo0eYPXs2xo4dizlz5mDTpk3lireiVfZ7AMhLRIcOHYr09PQCPdr79+/HlClTMGTIECxatKjUieO2bdswZMgQGBsbY968eRgwYADGjh2LM2fOVEjsRFQNCdJy5coVAUB89NFHQgghcnJyhLm5uVi9erUQQggHBwfx7bffCiGESE5OFnK5XIwfP77YdkNDQ4W5ublISEgQCQkJIjIyUsydO1dIkiSaNGmiqRcWFiae/WdJT08v0F5wcLDw9PTUPE5MTBSWlpaiTZs2IiMjQ6uuWq3W/NfHx0cEBwdryvLb9/DwEC+++GKBOPr06aPV1htvvCEAiAsXLgghhDh//rwAIMaNG6dV79133xUAxP79+597XlauXCkAiFOnTonFixcLS0tLzfMdNGiQ6Ny5sxBCCDc3NxESEvLctoQQIigoSPj5+WnO87Vr18SkSZMEANG7d29NvdDQUOHm5qa177PnOTs7W/j7+4suXbpoyiIiIoRMJhP9+/cXKpVKq37+OU1JSRE2NjYFXhexsbHC2tpaqzw0NFQAEG+99ZZWOyEhIcLExEQkJCQIIYTYtGmTACA+/vhjrTYHDhwoJEkSkZGRxZ6bkqrs90BRzp07JwCIKVOmaMrc3NwEALFz506turdv3xYAxMqVKwu0A0CEhYVpHvfu3VuYmZmJmJgYTVlERIQwMjIq8F7Th8p4DzRq1KjI7Rs3bhQAxKJFizRlAIRMJhNXrlzRqnvgwAEBQBw4cECrvLDz37hxY+Hi4iJSUlI0ZQcPHhQACrzXiIiEEII9oc9o0KABateurekluHDhAtLS0jQzfwMDAzWXro8fPw6VSlWisXBA3uVUOzs72NnZwdvbG9OnT0e7du0KnYn8tKfHvyUlJeHhw4cICgrCrVu3NJfU9uzZg5SUFPzvf/8rMI4r/5Lj+fPnERERgWHDhuHRo0d4+PAhHj58iLS0NHTt2hWHDh0qMEP5zTff1Hr81ltvAQC2b9+u9d9ne+PeeecdACjQi/g8gwcPRkZGBrZu3YqUlBRs3bq1TJchr1+/rjnPDRo0wDfffIOQkBCsWLHiufs9fZ6fPHmCpKQkvPDCCzh79qymfNOmTVCr1fjwww8hk2m/ffLP8549e5CYmIihQ4dqzvHDhw8hl8vRpk2bQmeXT5w4UaudiRMnIjs7G3v37gWQd57lcjkmTZqktd8777wDIQR27NhRwrNTvMp8DzxP/lJVKSkpWuUeHh4IDg4uU5sqlQp79+5Fv379tMZce3t7o2fPnmUPtpJU1HvgeYo6z0FBQWjYsGGZ2rx//z4uXbqEkSNHai05FhQUhMaNG5c9WCKq1jgx6RmSJCEwMFCTkB09ehT29vbw9vYGkPcFvHjxYgDQfBGX9AtYqVTir7/+ApA3S9jDwwMuLi7F7nf06FGEhYXh+PHjSE9P19qWlJQEa2trzWV9f3//ItuJiIgAgOfOxk9KSoKtra3msY+Pj9Z2Ly8vyGQyzSXlO3fuQCaTac5PPkdHR9jY2ODOnTvFPr98dnZ26NatG9atW4f09HSoVCoMHDiwxPvnc3d3x/fffw9JkqBUKuHj4wN7e/ti99u6dSs+/vhjnD9/Xms869PjBm/evAmZTPbcL+v889ylS5dCt1tZWWk9lslk8PT01CqrX78+AGidZ2dnZ1haWmrVa9CggWZ7RanM98DzpKamAkCB5+jh4VHmNuPj45GRkVHg9Qmg0DJ9q6j3wPNUxnnOf/0VdZ6f/iFHRJSPSWghOnTogL/++guXLl3SjIXLFxgYiPfeew8xMTE4cuQInJ2dCyQQRZHL5ejWrVupYrl58ya6du0KPz8/LFiwAK6urjAxMcH27duxcOHCUq2tmF/3888/L3JcXXELpxc1kaOiJngMGzYM48ePR2xsLHr27PncMZxFMTc3L/V5Pnz4MPr06YOOHTtiyZIlcHJygrGxMVauXFnosjnPk3+e165dC0dHxwLbn575XFVV1nvgefLHmT6byBQ2E76o15tKpSp3HPpWEe+B5+F5JqKqoup/G+rB02slHj16FJMnT9ZsCwgIgEKhwMGDB3HixAn06tWrUmP566+/kJWVhS1btqBevXqa8mcv6Xp5eQHI+4Ipqocnv46VlVWJk7SIiAitHpLIyEio1WrNpAU3Nzeo1WpERERoeuUAIC4uDomJiXBzcyvRcfL1798fEyZMwN9///3cpXoq2p9//gmlUoldu3Zprce4cuVKrXpeXl5Qq9W4evVqkYl8/nm2t7cv0XlWq9W4deuWpvcTgGaG+NPnee/evUhJSdHqwbp+/bpme0XSx3tg7dq1kCQJL774YrF183vrExMTtcqf7RG2t7eHUqlEZGRkgTYKK6sKKvM9oFKpsG7dOpiZmZWo97qk5zn/9WdI55mI9I9jQguRv5TLzz//jJiYGK1eIIVCgRYtWuDbb79FWlpahVyGfB65XA4AWsvwJCUlFUiOunfvDktLS8ybN6/AEkr5+wYEBMDLywtffPGF5pLc0wpbvujZGfjffPMNAGjG0+UnIF999ZVWvQULFgAAQkJCnv8En2FhYYGlS5di1qxZ6N27d6n2LQ+5XA5JkrR6eKKiogrMoO7Xrx9kMhnmzJlToBc6/zwHBwfDysoKc+fOLXRR8MLOc/7l7fx2Fi9eDGNjY3Tt2hVA3nlWqVRa9QBg4cKFkCSpwsc36vo9MH/+fOzevRtDhgwpMASkMFZWVqhTpw4OHTqkVb5kyRKtx/lXHzZt2oT79+9ryiMjIyt0HG1Fqqz3gEqlwqRJk3Dt2jVMmjSpwLCQwri5uUEulxd7np2dneHv7481a9ZofbaEh4fj0qVLFfMEiKjaYU9oIUxMTNCqVSscPnwYCoUCAQEBWtsDAwPx5ZdfAqiYsXDP0717d5iYmKB3796YMGECUlNT8f3338Pe3h4PHjzQ1LOyssLChQsxbtw4tGrVCsOGDYOtrS0uXLiA9PR0rF69GjKZDD/88AN69uyJRo0aYfTo0ahbty5iYmJw4MABWFlZacas5rt9+zb69OmDHj164Pjx4/jpp58wbNgwNG3aFEDerRxDQ0Px3XffITExEUFBQTh58iRWr16Nfv36oXPnzqV+zvq4g1RISAgWLFiAHj16YNiwYYiPj8e3334Lb29vXLx4UVPP29sbM2bMwEcffYQXXngBAwYMgEKhwKlTp+Ds7Ix58+bBysoKS5cuxYgRI9CiRQu88sorsLOzw927d7Ft2za0b99eK5lUKpXYuXMnQkND0aZNG+zYsQPbtm3D9OnTYWdnBwDo3bs3OnfujBkzZiAqKgpNmzbF7t27sXnzZkyePFnT+1pRKus9kJubi59++gkAkJmZiTt37mDLli24ePEiOnfujO+++67EbY0bNw7z58/HuHHj0LJlSxw6dEhrjdF8s2bNwu7du9G+fXu8/vrrmmTe398f58+fL/HxdKm874GkpCTNeU5PT0dkZCQ2bNiAmzdv4pVXXsFHH31Uonasra0xaNAgfPPNN5AkCV5eXti6dSvi4+ML1J07dy769u2L9u3bY/To0Xjy5InmPBf2o5eISP/rk1RR06ZNEwBEYGBggW0bNmwQAISlpaXIzc0tUXvFLU+Tr7AlmrZs2SKaNGkilEqlcHd3F59++qlYsWKFACBu375doG5gYKAwNTUVVlZWonXr1uKXX37RqnPu3DkxYMAAUbt2baFQKISbm5sYPHiw2LdvX4E4rl69KgYOHCgsLS2Fra2tmDhxYoEloHJycsTs2bOFh4eHMDY2Fq6urmLatGkiMzOz2Of79PI0z1NRy9PkK2yJph9//FH4+PgIhUIh/Pz8xMqVKwv99xBCiBUrVojmzZsLhUIhbG1tRVBQkNizZ49WnQMHDojg4GBhbW0tlEql8PLyEqNGjRKnT5/WisPc3FzcvHlTdO/eXZiZmQkHBwcRFhZWYAmolJQUMWXKFOHs7CyMjY2Fj4+P+Pzzz7WW26pIlfEeAKD5MzMzE+7u7uLll18Wf/zxR4HnK8Tz/93T09PF2LFjhbW1tbC0tBSDBw8W8fHxBZZoEkKIffv2iebNmwsTExPh5eUlfvjhB/HOO+8IpVJZotgrU2W8B54+zxYWFsLHx0cMHz5c7N69u9B9AIg333yz0G0JCQni5ZdfFmZmZsLW1lZMmDBBXL58udAlsn799Vfh5+cnFAqF8Pf3F1u2bBEvv/yy8PPzKzZuIqp5JCEq+HYrREQGoF+/frhy5YpmNQOqHM2aNYOdnV2BmxAQEXFMKBFVe0/fghTIm3C3fft2zW1zqfxycnKQm5urVXbw4EFcuHCB55mICsWeUCKq9pycnDBq1Ch4enrizp07WLp0KbKysnDu3LkSTYSi4kVFRaFbt24YPnw4nJ2dcf36dSxbtgzW1ta4fPlyuW/rSkTVDycmEVG116NHD/zyyy+IjY2FQqFAu3btMHfuXCagFcjW1hYBAQH44YcfkJCQAHNzc4SEhGD+/PlMQImoUOwJJSIiIiKd45hQIiIiItI5JqFEREREpHNMQivIqlWrIEkSlEolYmJiCmzv1KkT/P39dRrTvn37MGbMGNSvXx9mZmbw9PTEuHHjtBa5f9qxY8fQoUMHmJmZwdHREZMmTaqSi0zzXOsGz7Pu8FwTUU3EJLSCZWVlYf78+foOAwDw/vvv4+DBg+jfvz++/vprvPLKK/j999/RvHlzxMbGatU9f/48unbtivT0dCxYsADjxo3Dd999h0GDBukp+uLxXOsGz7Pu8FwTUY2iz5Xyq5P8u540a9ZMKBQKERMTo7W9pHfyqUjh4eEF7kITHh4uAIgZM2Zolffs2VM4OTmJpKQkTdn3338vAIhdu3bpJN6S4rnWDZ5n3eG5JqKaiD2hFWz69OlQqVRVojejY8eOkMlkBcpq1aqFa9euacqSk5OxZ88eDB8+HFZWVprykSNHwsLCAr///rvOYi4Nnmvd4HnWHZ5rIqpJuE5oBfPw8MDIkSPx/fff43//+x+cnZ1LtX96ejrS09OLrSeXy2Fra1vq+FJTU5Gamoo6depoyi5duoTc3Fy0bNlSq66JiQmaNWuGc+fOlfo4usBzrRs8z7rDc01ENQl7QivBjBkzkJubi08//bTU+3722Wews7Mr9q958+Zliu2rr75CdnY2hgwZoinLn2jg5ORUoL6TkxPu379fpmPpAs+1bvA86w7PNRHVFOwJrQSenp4YMWIEvvvuO/zvf/8r9MO5KCNHjkSHDh2KrWdqalrquA4dOoTZs2dj8ODB6NKli6Y8/77aCoWiwD5KpbLAfberEp5r3eB51h2eayKqKZiEVpIPPvgAa9euxfz587Fo0aIS7+fp6QlPT88Kj+f69evo378//P398cMPP2hty/9CysrKKrBfZmZmmb6wdInnWjd4nnWH55qIagImoZXE09MTw4cP1/RmlFT+mKviyOVy2NnZlajNe/fuoXv37rC2tsb27dthaWmptT2/p6Ww9f8ePHhQ6nFpusZzrRs8z7rDc01ENUGNHxP64MEDzJo1q8gFmMvjgw8+KPXYri+++AJOTk7F/rVq1apE7T169Ajdu3dHVlYWdu3aVeilPX9/fxgZGeH06dNa5dnZ2Th//jyaNWtW4vj1hedaN3iedYfnmqj6qszcw5DU+J7QBw8eYPbs2ejTp0+pxl6VhJeXF4YPH47ly5fDzc0NRkbFn+6KHNOVlpaGXr16ISYmBgcOHICPj0+h9aytrdGtWzf89NNPmDlzpqanY+3atUhNTTWIBad5rnWD51l3eK6Jqq/KzD0MSY1PQivbjBkzsHbtWty4cQONGjUqtn5Fjul69dVXcfLkSYwZMwbXrl3TWtvPwsIC/fr10zz+5JNPEBgYiKCgILz22muIjo7Gl19+ie7du6NHjx4VEk9l47nWDZ5n3eG5JqJqTd+r5evbmTNnBABx5syZcrWTf8eTU6dOFdgWGhoqAOj8jidubm4CQKF/bm5uBeofPnxYBAYGCqVSKezs7MSbb74pkpOTdRpzSfBc6wbPs+7wXBPVLBWVexg6SQghKjvRrcrOnj2LgIAAnDlzBi1atNB3OERERFTNMffIU+MnJhERERGR7jEJJSKqYXJycvQdAhERk1AiopqGSSgRVQVMQomIahgmoURUFTAJJSKqYQq7xSYRka4xCSUiqmHS09P1HQIREZNQIqKapiT3lyciqmxMQomIapgnT57oOwQiIiahREQ1TWJiIrKzs/UdBhHVcExCiYhqGCEE4uLi9B0GEdVwTEKJiGqgBw8e6DsEIqrhmIQSEdVA7Aml6oQrPhgmJqFERDVQfHw8VCqVvsMgqhBMQg0Tk1AiohpIpVLh/v37+g6DqEJwop1hMtJ3AEREpDstW7ZEVFQUzM3N4e3tDVdXV32HRFRuTEIrx8WLF/HNN9/g7NmzSEpKglqt1touSRJu3rxZ5vbZE0pEVIPExsbi0aNHSE5Oxu3bt7lwPVULvBVtxTt48CBat26NrVu3wtnZGbdu3YKnpyecnZ1x584dWFhYoGPHjuU6BpNQIqIaSqVS4dixYxBC6DsUonLJzMzUdwjVzocffghPT0/cuHEDK1euBABMnz4dR44cwbFjxxAdHY3BgweX6xhMQomIarCoqCicPHmSiSgZNCahFe/s2bMYO3YsrKysIJfLAUAzmbFNmzaYMGECZs6cWa5jVKkk9NChQ+jduzecnZ0hSRI2bdpU7D4HDx5EixYtoFAo4O3tjVWrVlV6nERE1cmFCxdw6NAhzpYng1Xdk1B95EdGRkawtLQEANjY2MDY2Bjx8fGa7Z6enrh69Wqp2nxWlUpC09LS0LRpU3z77bclqn/79m2EhISgc+fOOH/+PCZPnoxx48Zh165dlRwpEVH1cuPGDezYsYMTPMggVfckVB/5kbe3NyIiIgDkTUDy8/PDxo0bNdu3bdsGR0fH0j2RZ1Sp2fE9e/ZEz549S1x/2bJl8PDwwJdffgkAaNCgAY4cOYKFCxciODi4ssIkIqqW7t+/j23btuGll16CsbGxvsMhKrGMjAx9h1Cp9JEf9erVCytWrMC8efNgZGSEqVOnYvTo0fDx8QEA3Lx5E/PmzSv9k3lKleoJLa3jx4+jW7duWmXBwcE4fvx4kftkZWUhOTlZ88eZoURE/y8hIQHh4eEcI0oGxVB7QlNTU7Vykoqa5V+W/OhZM2fOxIULFzTjQUNDQ7FmzRr4+/ujadOmWLFiBd5///1yxVmintDk5GSYm5trAqkqYmNj4eDgoFXm4OCA5ORkZGRkwNTUtMA+8+bNw+zZs3UVIhGRwbl16xZcXV3h6+ur71CISiQrKwtqtRoymWH1rQUFBWk9DgsLw6xZs8rdblnyo2cZGxujdu3aWmXDhw/H8OHDyx1fvhL9a9na2uK3337TPB4zZgxOnDhRYUHo0rRp05CUlKT5Cw8P13dIRERVztGjR7UmIRBVdYa4Vmh4eLhWTjJt2jR9h6Th6emJLVu2FLl969at8PT0LNcxSpSEmpiYaP3jrlq1qlwr5FcUR0dHxMXFaZXFxcXBysqqyCxfoVDAyspK82dhYaGLUImIDEpubi62b9+O6OhofYdCVCKGOC7UwsJCKydRKBQV0m5Z8qNnRUVFPXfIYmpqKu7cuVOuOEt0Od7Pzw8//PAD3N3dYW1trQnu7Nmzz92vRYsW5QquOO3atcP27du1yvbs2YN27dpV6nGJiGqC7Oxs7NixA82aNUOLFi2q3JAsoqelp6ejVq1a+g6jSqio/EiSpCK3nTp1CjY2NmUJT6NESei8efMwZMgQzSBXSZIwc+bMIhcpFUJAkqRSrzmXmpqKyMhIzePbt2/j/PnzqFWrFurVq4dp06YhJiYGa9asAQD85z//weLFi/Hf//4XY8aMwf79+/H7779j27ZtpTouEREVTgiBc+fOISoqCu3bt4ezs7O+QyIqVEpKir5DqDS6yo8WLVqERYsWAcjL9SZPnowZM2YUqJeUlITExEQMGzasXM+rRElojx49cPv2bZw6dQpxcXEYNWoUXnvttQrvcTx9+jQ6d+6seTx16lQAeTOyVq1ahQcPHuDu3bua7R4eHti2bRumTJmCRYsWwcXFBT/88AOXZyIiqmBPnjzB1q1b4eHhgbZt22oWsSaqKhITE/UdQqXRVX5kb2+PRo0aAci74l23bl3UrVtXq44kSTA3N0dAQADeeOONcj0vSZRgHY6LFy/Czc1Ncym+c+fO+OCDD9C1a9dyHbwqOHv2LAICAnDmzJlKHz5ARKRvLi4uiImJgY2NDT799NMytSGXy9GkSRNeoqcqY/Xq1bC1tUWfPn30HUqJGELuoYtcr0QTk5o3b85L3EREBCDv/tHnzp3Dhg0bqnXvExmWhIQE5OTk6DuMauPAgQOV3tlYosvxpqamSE9P1zwODw/H+PHjKy0oIiKq+p48eYItW7ZgwIABXGmE9E6lUiE6OhoeHh76DsUgHTp0qEz7dezYsczHLFES2rRpUyxYsAByuVxzSf7UqVNQKpXP3W/AgAFlDoyIiKq+zMxMnDt3Di+88IK+Q6EaqmXLlrh16xYsLS3h5eXFJLSMOnXqpDUbPn+SeVHKOgn9aSVKQhctWoSBAwdi7NixAPIGpT49g6ow5Q2MiIgMQ1RUFDp06PDcLyyiyhIbG4snT55ACIGoqChkZ2fDxMRE32EZnAMHDuj8mCVKQlu2bInIyEjcvHkTcXFx6NSpE2bMmFHgvqRERFR1RUREIDk5GUDewt5xcXEFbu1XFhkZGbh//36BWbREuqZSqRAZGYmGDRvqOxSD8+wtRHWhREkoABgZGcHX1xe+vr4IDQ3FSy+9hDZt2lRmbEREVEFWrlyJcePGQa1WA8i7xWFYWBhGjhyJwMDAcrd//vx5JqFUJVy9ehUNGjRgz3wFevDgAeLj4+Ht7Q1zc/MKa7dEs+OftXLlSiagREQGIiIiQisBzSeEwJo1ayrkHvExMTGIjY0tdztE5fX48WPebraCbN68GX5+fnBxcUGLFi1w4sQJAMDDhw/RvHlzbNq0qVztl6gndM6cOZAkCTNmzIBMJsOcOXOK3Sf/rkpERKRfK1asKLJXSJIkHD16FP379y/3ca5fvw5HR8dyt0NUXmfOnIGLiwt7Q8vhr7/+woABA9CuXTsMGzYMs2bN0myrU6cO6tati5UrV6Jfv35lPkaJktBZs2ZBkiS8//77MDEx0QqkKExCqbpQq9WQycp00YCoSoiKikJR9yURQuDRo0cVcpyKaoeovOLj43Hz5k14e3vrOxSDNWfOHHTs2BEHDhzAo0ePCuR+7dq1w/Lly8t1jBJ9s6rVaqhUKs1sM7VaXewfZ8ZTdcHFuMnQubu7P7cntHbt2hVyHIVCUSHtEFWEv//+G1lZWfoOw2BdvnwZgwcPLnK7g4NDuYfysHuHqBjZ2dn6DoGoXMaMGfPcntD27dtXyHHY60RVSXp6umYMI5WemZkZ0tLSitx+69atcv+ALXMSeu3aNWzduhW//PILtm7diuvXr5crEKKqir+kydD5+Pjgxx9/LDCsRJIkjBw5Evb29uU+Rp06dVC/fv1yt0NUka5fv46YmBh9h2GQOnfujNWrVyM3N7fAttjYWHz//ffo3r17uY5R6iR0+fLlqFevHvz9/dG3b18MHz4cffv2RaNGjeDh4YEffvihXAERVTXsCaXqYNSoUbhx4wYsLS0B5F06nzNnToUszySXy9GpUyeOnaYq6eDBg+xMKINPPvkE0dHRaNWqFZYvXw5JkrBr1y588MEHaNy4MYQQCAsLK9cxSrxOKAC8++67WLBgAWrVqoUxY8bA398fFhYWSE1NxaVLl7Bp0yZMmDABERER+PTTT8sVGFFVwQ8vqi68vb1hZWWFlJQUmJqaVkgPKAC0bdsWtWrVqpC2iCpaWloaDh8+jK5du3K2fCn4+vriyJEjePvttzFz5kwIIfD5558DyLvF57fffgt3d/dyHaPESejJkyexYMEC9O/fH2vWrCl0sdJFixZh+PDh+OKLLzBo0CC0bNmyXMERVQUZGRn6DoGoyqpfvz7vTkNV3q1bt+Do6Ah/f399h2JQGjVqhL179+LJkyeIjIyEWq2Gp6cn7OzsKqT9El87+fHHH+Hk5IR169YVuVq+ubk5fvnlFzg4OODHH3+skACJ9C0rK6vAIt9EBNStWxcvvPACe5fIIBw/fpzjQ8vI1tYWrVq1Qps2bSosAQVK0RN6/PhxDBo0qNglOJRKJQYNGoQDBw6UOziiqkAIgbS0NM1YOiLKS0CDg4Mhl8v1HQpRiQghsGfPHvTp04fDRwqxZs2aMu03cuTIMh+zxEnovXv30KBBgxLVbdiwYZmfDFFVlJyczCSU6F/e3t4ICgpiAkoGJzs7Gzt27ECfPn34mf6MUaNGFSjLv8rx7BJvT1/90EkSWpovYQsLC6SkpJQ5KKKq5tGjR6hbt66+wyDSK5lMhjZt2sDf35+X4MlgpaWlaRJRpVKp73CqjNu3b2s9TkxMRGhoKKytrfHWW2/B19cXQN6yV9988w1SUlKwevXqch2zxEmoEKJUHzpFLYxMZIji4uL0HQKRXllbW6NLly4VOh6MSF8SExOxa9cuhISEwMioVAsFVVtubm5aj2fNmgU7Ozvs3r1bK/9r3LgxXn75ZXTv3h0LFy7EypUry3zMUp35L774Ar/88kux9Tjwl6qbBw8elPqHGFF14evri8DAQBgbG+s7FKIKExcXh/DwcHTp0oWf7YXYtGkTPvnkk0LPjUwmw4ABA/DBBx+U6xglTkLr1auHx48f4/HjxyWuT1RdZGZm4tGjR6hTp46+QyHSGblcjg4dOmguwxFVNzdv3oSDgwOXbiqEEOK5d8O8evVqua96lzgJjYqKKteBiAzd3bt3mYRSjWFqaoru3bvDwcFB36EQVaoTJ07AxcUFNjY2+g6lSunXrx+WLl0Kd3d3/Oc//4GZmRkAID09HUuXLsXy5cvx6quvlusYvMcaUQnduXNH3yEQ6YSNjQ369u3LBJRqBJVKhcOHD3MuyzMWLVqEwMBAvPvuu7C1tYW7uzvc3d1ha2uL9957D23btsVXX31VrmNwNC7Rc7Rs2RJ3796FqakpZsyYgcTERP5apmrNyckJ3bt3L3ZNaKLq5MGDB7h9+zY8PT31HUqVYW1tjfDwcGzevBk7duzQdMT06NEDvXr1Qu/evcs9lpZJKNFzxMbGIiEhQZN4Xr16FYGBgfoNiqiSeHh4oEuXLlz/k2qkkydPws3Nja//Z/Tt2xd9+/atlLZ5OZ6oFK5fv857yVO15OXlha5du/ILmGqs5ORkXL58Wd9h1ChMQolKITc3F+fPn9d3GEQVytHREZ06dYJMxq8EqtnOnj2L1NRUfYdRY/ATh6iUrly5gidPnug7DKIycXR0RO3atWFlZQUAMDExYQ8o0b9ycnJw6NAhTlLSEY4JJSoltVqNQ4cOoU+fPlzgmAzO6dOnsWXLFsTGxgIAWrVqBXNzcz1HRVR1REdH48aNG/Dz89N3KNVemZPQXbt24ccff8StW7fw5MmTQm9uf/PmzXIHSFQVxcXF4ezZswgICNB3KERlZmtriwYNGug7DKIq5++//4arqyt/oFWyMl2O//zzz9GrVy8cOXIELi4u6NixI4KCgrT+OnbsWOagvv32W7i7u0OpVKJNmzY4efJkkXVXrVoFSZK0/pRKZZmPTVRSZ8+exe3bt/UdBlGZtWjRguNAiQqRnZ2N06dP6zsMLfrOjTIzM7FmzRrExcWVq52nlakndNGiRejSpQu2b99e4fcS/u233zB16lQsW7YMbdq0wVdffYXg4GDcuHED9vb2he5jZWWFGzduaB7zEinpghAC+/fvR69eveDk5KTvcIhKxcLCgmsiksGLiIhAcnIyACAjIwNxcXEVdpOFf/75By1btqwSvaFVITdKSkrC6NGjsWfPngo7x2X6CfzkyRMMHDiwwhNQAFiwYAHGjx+P0aNHo2HDhli2bBnMzMywYsWKIveRJAmOjo6aP97lg3RFpVJh586dSEhI0HcoRKXi5eXFH+xk0FauXAk/Pz+kpKQAALKyshAWFoZjx45VSPtCiCpztauq5EYVPWGrTElo69attbLripKdnY0zZ86gW7dumjKZTIZu3brh+PHjRe6XmpoKNzc3uLq6om/fvrhy5UqRdbOyspCcnKz541IMVF45OTnYvn07Hj16pO9QiEqsXr16+g6BqMwiIiIwbtw4qNVqrXIhBNasWYP4+PgKOU5lf66npqZq5SRZWVkF6ugiNyqpiv7hWqYkdMmSJdiwYQPWrVtXocE8fPgQKpWqQLbu4OCgmcn5LF9fX6xYsQKbN2/GTz/9BLVajcDAQERHRxdaf968ebC2ttb8BQUFVehzoJopKysL27Zt49JNZBBkMlmRl/CIDMGKFSuKTIgkScLRo0cr5Di5ubkV0k5RgoKCtHKSefPmFaiji9yopCq6J7RMY0KHDBmC3NxcjBgxAq+//jpcXFwKrDEnSRIuXLhQIUE+T7t27dCuXTvN48DAQDRo0ADLly/HRx99VKD+tGnTMHXqVM3j8+fPMxGlCpGZmYmtW7fipZdegq2trb7DISqSra0t1wUlgxYVFVVkQiSEqLAeTFNT0wpppyjh4eFo1qyZ5rFCoaiQdkubG5WEg4NDgZ7n8ipTElqrVi3Url0bPj4+FRpMnTp1IJfLC8y8iouLg6OjY4naMDY2RvPmzREZGVnodoVCofWPbGFhUfaAiZ6RkZGBLVu2oEePHhybTFWWtbW1vkMgKhd3d/fn9oTWrl27Qo5TUe0UxcLCQnPjiKLoIjfSlzIloQcPHqzgMPKYmJggICAA+/btQ79+/QDkLQy+b98+TJw4sURtqFQqXLp0Cb169aqUGImKk5WVha1bt6Jdu3Zo0KABJ39QlVMVZvsSlceYMWPw2WefFbpNCIH27dtXyHGqwson1Tk3qnILxE2dOhXff/89Vq9ejWvXruH1119HWloaRo8eDQAYOXIkpk2bpqk/Z84c7N69G7du3cLZs2cxfPhw3LlzB+PGjdPXUyCCSqXCkSNHsHfvXmRmZuo7HCItXEuZDJ2Pjw9+/PHHAuvcSpKEkSNHVsiYZysrq2J7KXWluuZG5bptZ05ODq5fv46kpKRCxwmUZcH6IUOGICEhAR9++CFiY2PRrFkz7Ny5U3Np8+7du1ovuidPnmD8+PGIjY2Fra0tAgICcOzYMTRs2LDsT4yogty+fRtxcXHo3Lkz6tatq+9wiACgUpbXI9K1UaNGoUOHDmjRogVSUlKgUCjwwQcfVNikO1dX1wpppyJU19xIEmWY6qRWqzFt2jQsWbIE6enpRdZTqVTlCk4X8m+9eObMGbRo0ULf4VAV4+LigpiYGNjY2ODTTz8tczuSJKFt27Zo3LhxBUZHVDZJSUkcF0rVRkV9Tj8rJCSk0joPmHvkKdPl+Llz5+Lzzz/H8OHDsWbNGgghMH/+fCxbtgxNmjRB06ZNsWvXroqOlchgCSFw/PhxXL9+Xd+hEMHIqFwXwYiqPaVSWSXGg1Z3ZfokWrVqFQYPHoylS5dqlkEICAhAly5dEBoainbt2mH//v1aC6sSEXD8+HF4eHhU2DIcRGXBJJTo+by8vAqMN62pjh49irNnzxY69FKSJMycObPMbZfpkyg6Ohr//e9/Afz/mlb5ky9MTEwwfPhwLFiwAHPnzi1zYETVUU5ODiIjI9GoUSN9h0I1GNcIJXo+Pz8/fYegd48fP0ZISAhOnjwJIQQkSdKszZr//+VNQsuU5teuXVtzu8v8Na5u3bqlVYd3jiEq3LPvFSJdYw8PUdFcXV0rfX1QQ/Dee+/h4sWLWLduHW7dugUhBHbt2oV//vkH//nPf9CsWTPcv3+/XMco0ydR8+bNcerUKc3jzp0746uvvsLRo0dx+PBhfP3112jatGm5AiPSt4iICCQnJwPIW4T+2YWCy+rBgwf8kUZ6xbVriQonSRJat26t7zCqhO3bt2PChAkYMmQILC0tAeT9gPX29sa3334Ld3d3TJ48uVzHKFMS+tprryErKwtZWVkAgE8++QSJiYno2LEjgoKCkJycjC+//LJcgRHp08qVK+Hn54eUlBQAeQvQh4WF4dixYxXS/tM/4oh0jUkoUeFatGjBXtB/JSYmaoaO5d9dMv8qOAB079693JPQy5SE9unTBxs2bNCMB23YsCFu3ryJDRs2YMuWLYiIiEDbtm3LFRiRvkRERGDcuHEFBmALIbBmzRrEx8eX+xhRUVGIiYkpdztERFQx6tWrV6OXS3qWs7MzYmNjAeTN/7G3t8eFCxc022NiYsr9g7bCpkhaW1ujb9++FdUckd6sWLHiufckPnr0KPr371/u45w9e5YL2BMRVQEODg7o2rUrrxI8pWPHjtizZw9mzJgBIG/B/M8++wxyuRxqtRpfffUVgoODy3WMMiehKpUK69evx4EDBxAfH485c+agcePGSEpKwr59+9C+fXvNSv5EhiQqKgpF3cNBCKFZlqy8YmNjNbMLiXSJrzui/1erVi306NGDdxJ7xtSpU7Fnzx5kZWVBoVBg1qxZuHLlimY2fMeOHfH111+X6xhlSkITExPRo0cPnDx5EhYWFkhLS8Nbb70FIG/cwKRJkzBy5Egu0UQGyd3d/bk9oRU1Xsjc3LxC2iEiorKxtLREr169uHZzIRo3bqx1lz9bW1vs3bsXiYmJkMvlmslK5VGmMaH/+9//cOXKFezatUszbT+fXC7HwIEDsX379nIHR6QPY8aMeW5PaPv27SvkOP7+/uyNIr0ow92aiaodExMT9OzZE2ZmZvoOpUqaM2cOLl++XKDcxsYGlpaWuHLlCubMmVOuY5QpCd20aRPeeustvPjii4V+idavXx9RUVHlCoxIX3x8fPDjjz8WWEtRkiSMHDkS9vb25T6GnZ0d/P39y90OERGVTadOnWBjY6PvMKqsWbNm4eLFi0Vuv3z5MmbPnl2uY5QpCU1KSoKHh0eR23NycpCbm1vmoIj0bdSoUbhx44bmcoNCocCcOXMQGBhY7rZNTEzQtWtXLhhOesPXHtV09evXh7u7u77DMGiPHz+GiYlJudoo05hQLy8vnD17tsjtu3fvRsOGDcscFFFV4O3tDSsrK6SkpMDU1LRCekCBvMHcVlZWFdIWERGVjlKp5DKSRTh06BAOHjyoebxhwwZERkYWqJeYmIjffvtNa8xoWZQpCR03bhzef/99dOrUCV27dgWQd6kyKysLc+bMwc6dO/Hdd9+VKzCi6qhRo0bw9PTUdxhERDVW27ZtoVQq9R1GlXTgwAHNJXZJkrBhwwZs2LCh0LoNGzbEN998U67jlSkJffvtt3HlyhUMHTpUM55i2LBhePToEXJzczFhwgSMHTu2XIERVTfOzs789U1EpEcuLi7w8fHRdxhV1n//+19MnDgRQgjY29tj2bJlePnll7XqSJIEMzOzCknky5SESpKE77//HqGhofjjjz8QEREBtVoNLy8vDB48GB07dix3YETViZ2dHbp37w65XK7vUIiIaiSlUomgoCCuSvIcpqamMDU1BQDcvn0bdnZ2lbp6QLnumNShQwd06NChomIhqpbs7OzQq1evcg/gJiKispEkCV27duX6zKXg5uZW6ceosNt2ElFBjo6O6NGjBxNQIiI9atu2LW+TXAwPD49S9xJLkoSbN2+W+ZglTkL79OlTqoYlScLmzZtLHRBRdeHs7Izg4GDeCo6ISI8aNGjAdZlLQB9DFUqchG7duhVKpRKOjo4lutsGx1xQTebk5IQePXrAyIgXG4iI9MXJyQnt27dnTlICq1at0vkxS/wNWbduXcTExKBOnToYNmwYXnnlFTg6OlZmbEQGqXbt2ggODmYCSkSkR6amprwxSBVX4n+Ze/fu4cCBA2jevDk++ugjuLq6olu3bli5ciVSUlIqM0Yig2FmZsYxoEREVUDHjh15X/hySk5Oxvz58xEcHIzmzZvj5MmTAPLulrRgwYJCF7IvjVL9PAgKCsLy5csRGxuLP/74A7Vr18bEiRNhb2+PAQMG4I8//kBWVla5AiIyVEZGRggODubsSyIiPfPw8NDJ7O7qLDo6Gs2bN8eHH36I6OhoXLx4EampqQCAWrVqYfny5eVerL5MfdTGxsbo27cvfvvtN8TFxWkS0yFDhuCzzz4rV0BEhih/+Q87Ozt9h0JEVKNJkoTWrVvrOwyD99577yElJQXnz59HeHh4gflA/fr1w969e8t1jHINlMjKysKuXbuwefNmnDt3DkqlEu7u7uUKiMjQSJKETp068Vc3EVEV4OnpCWtra32HYfB2796NSZMmoWHDhoVO7PL09MS9e/fKdYxSz5xQq9XYs2cPfvnlF2zatAnp6eno1q0bvv/+e/Tv35+XIqlGyU9AeRs4IiL9cHR0RHp6OiwtLQHkLclE5ZeRkfHcq3sVMR+oxEnosWPHsG7dOqxfvx6PHj1C27ZtMXfuXAwePBh16tQpdyBEhkaSJHTp0gVeXl76DoWIqMY6ffo0Vq9ejaysLJiamsLJyUnfIVULDRs2xKFDhzBhwoRCt2/atAnNmzcv1zFKnIR26NABpqam6NWrF4YOHaq57H737l3cvXu30H1atGhRruCIqiomoEREVU/dunW5JmgFmTx5MkJDQ9GkSRMMGjQIQN7V8MjISMyePRvHjx/Hn3/+Wa5jlOpyfEZGBv78809s2LDhufWEEJAkCSqVqlzBEVVVrVu3ZgJKRFTFsBe04gwfPhx37tzBBx98gBkzZgAAevToASEEZDIZ5s6di379+pXrGCVOQleuXFmuAxFVF+7u7mjSpIm+wyAiomfY29vrO4RqZcaMGRgxYgT+/PNPREZGQq1Ww8vLCwMGDICnp2e52y9xEhoaGlrugxEZOoVCgRdeeIGXe4iIqhi5XA5bW1t9h1Ht1KtXD1OmTKmUtqvkvay+/fZbuLu7Q6lUok2bNpoV+ouyfv16+Pn5QalUonHjxti+fbuOIqWapmXLljA1NdV3GERE9IzatWtX61t0VsfcqMr9a/3222+YOnUqwsLCcPbsWTRt2hTBwcGIj48vtP6xY8cwdOhQjB07FufOnUO/fv3Qr18/XL58WceRU3Xk6OgIOzs7WFlZwcLCAn5+fvoOiYiIClG7dm19h1BpdJEbyWQyyOXyUv+VhySeXQJfz9q0aYNWrVph8eLFAPJmYrm6uuKtt97C//73vwL1hwwZgrS0NGzdulVT1rZtWzRr1gzLli0r9nhnz55FQEAAzpw5w9n8VKjDhw/j2rVraNWqVbmXoyAiooq3evVqtG7d2mDWCC1t7qGL3GjWrFkFhppt3LgRV65cQXBwMHx9fQEA169fx+7du+Hv749+/fohLCysxM/7WaVerL4yZWdn48yZM5g2bZqmTCaToVu3bjh+/Hih+xw/fhxTp07VKgsODsamTZsKrZ+VlaV1f/v8+6Dm5uYiJyennM+AqqPc3FyoVCq4uLjwNUJEVAXl5ubC0tLSYD6jc3NzAeTlIMnJyZpyhUIBhUKhVVcXuRGQl4Q+7bvvvkN8fDwuX76sSUDzXbt2DV26dIGzs3OR7ZVElUpCHz58CJVKBQcHB61yBwcHXL9+vdB9YmNjC60fGxtbaP158+Zh9uzZBcrbtGlTxqippnjjjTf0HQIREVUjQUFBWo/DwsIKJIO6yI0K8/nnn2PixIkFElAg765UEydOxGeffYbx48eXuM1nVakkVBemTZum9evg/PnzCAoKwokTJ3iplQp15MgRJCUlISQkRN+hEBFRIX7//XcMHjxY32GU2Llz59CmTRuEh4ejWbNmmvJne0H1KTo6GsbGxkVuNzY2RnR0dLmOUaWS0Dp16kAulyMuLk6rPC4uDo6OjoXu4+joWKr6z3Z1W1hYAACMjIyee7Kp5jIyMkLt2rX5+iAiqqJsbW0N6jPayCgv/bKwsICVldVz6+oiNyqMv78/lixZgmHDhqFu3bpa26Kjo7FkyRI0bty4xO0VpkrNjjcxMUFAQAD27dunKVOr1di3bx/atWtX6D7t2rXTqg8Ae/bsKbI+UVkU9yFBRET6Y25uru8QKo2+cqOFCxciPj4e9evXx/DhwzFr1izMmjULr776Knx9fREfH48FCxaU7Un9q0r1hALA1KlTERoaipYtW6J169b46quvkJaWhtGjRwMARo4cibp162LevHkAgLfffhtBQUH48ssvERISgl9//RWnT5/Gd999p8+nQdWMtbW1vkMgIqIimJmZ6TuESqWP3KhDhw44ceIEZs6ciY0bNyIjIwMAYGpqiuDgYMyePbvcPaFVLgkdMmQIEhIS8OGHHyI2NhbNmjXDzp07NQNs7969q7UYbWBgINatW4cPPvgA06dPh4+PDzZt2gR/f399PQWqhmxsbPQdAhERFUGpVOo7hEqlr9zI398fGzduhFqtRkJCAgDAzs6uwm4KUOXWCdU1rhNKxTl69CjatWtXre/EQURkyP755x/Ur19f32GUGHOPPPxWJSqGubk5E1AioirMxMRE3yFQGfCblagY1XnAOxFRdWBIM+Pp/zEJJSpGVVq3jYiICmISapiYhBIVgx9uRERVW/66m2RYmIQSFYMfbkREVRs/pw0Tk1CiYrAnlIioapPL5foOgcqASShRMfgLm4ioamMSapiYhBIVo7ovgkxEZOi4jJ5h4r8aUTHYE0pEVLUxCTVM/FcjIiIig8bL8YaJSSgREREZNEmS9B0ClQGTUCIiIiLSOSahRERERKRzTEKJiIiISOc47ddAPXjwAA8ePNB3GDWCk5MTnJyc9B1GtcfXtO7wNa0bfE3rDl/ThqnGJ6FOTk4ICwszqBdvVlYWhg4divDwcH2HUiMEBQVh165dUCgU+g6l2uJrWrf4mq58fE3rlqG9pg0x96gMkhBC6DsIKp3k5GRYW1sjPDwcFhYW+g6nWktNTUVQUBCSkpJgZWWl73CqLb6mdYevad3ga1p3+Jo2XDW+J9SQNWvWjG+4SpacnKzvEGoUvqYrH1/TusXXdOXja9pwcWISEREREekck1AiIiIi0jkmoQZIoVAgLCzMYAZgGzKea93gedYdnmvd4HnWHZ5rw8WJSURERESkc+wJJSIiIiKdYxJKRERERDrHJJSIiIiIdI5JKNVIo0aNgru7u77DwKhRo7iQNREZlFmzZkGSpFLvVxU+d8sTQ6dOndCpU6cKjaemYxJKerVq1SpIkgRJknDkyJEC24UQcHV1hSRJeOmll4ptr1OnTpr2JElCrVq10KpVK6xYsQJqtboyngJRuVTme0Amk8HKygq+vr4YMWIE9uzZUxlPgahM0tPTMWvWLBw8eFDfoZTJ/fv3MWvWLJw/f17foRgsJqFUJSiVSqxbt65AeXh4OKKjo0u19IaLiwvWrl2LtWvXYubMmcjNzcXYsWMxffr0igyZqEJVxntgzZo1+Pzzz9GnTx8cO3YM3bt3x5AhQ5CTk1ORoROVSXp6OmbPnm3QSejs2bOZhJYDk1CqEnr16oX169cjNzdXq3zdunUICAiAo6NjiduytrbG8OHDMXz4cEyZMgVHjx6Fi4sLFi9ezC9fqrIq6z0wYcIEfP755/jnn3/wxhtv4Pfff8cHH3zw3P3VajUyMzPL9DyIiEqKSShVCUOHDsWjR4+0LhdmZ2fjjz/+wLBhw8rVtpmZGdq2bYu0tDQkJCQUWe+LL75AYGAgateuDVNTUwQEBOCPP/4otO5PP/2E1q1bw8zMDLa2tujYsSN2796tVWfHjh144YUXYG5uDktLS4SEhODKlSuFtnfr1i0EBwfD3Nwczs7OmDNnDp5dwjctLQ3vvPMOXF1doVAo4Ovriy+++KJAPTJMlfkeAAC5XI6vv/4aDRs2xOLFi5GUlKTZJkkSJk6ciJ9//hmNGjWCQqHAzp07cfDgQUiSVKCnKioqCpIkYdWqVVrl69evR8OGDaFUKuHv74+NGzdWiXGAVHZHjhxBq1atoFQq4eXlheXLlxda76effkJAQABMTU1Rq1YtvPLKK7h3716R7UZFRcHOzg4AMHv2bM0QklmzZgEALl68iFGjRsHT0xNKpRKOjo4YM2YMHj16VOLYN23aBH9/f63XY2HUajW++uorNGrUCEqlEg4ODpgwYQKePHlSZNsHDx5Eq1atAACjR4/WxJ//njh8+DAGDRqEevXqQaFQwNXVFVOmTEFGRkaJ468JmIRSleDu7o527drhl19+0ZTt2LEDSUlJeOWVV8rd/q1btyCXy2FjY1NknUWLFqF58+aYM2cO5s6dCyMjIwwaNAjbtm3Tqjd79myMGDECxsbGmDNnDmbPng1XV1fs379fU2ft2rUICQmBhYUFPv30U8ycORNXr15Fhw4dEBUVpdWeSqVCjx494ODggM8++wwBAQEICwtDWFiYpo4QAn369MHChQvRo0cPLFiwAL6+vnjvvfcwderUcp8f0r/Kfg8AeYno0KFDkZ6eXmD86f79+zFlyhQMGTIEixYtKnXiuG3bNgwZMgTGxsaYN28eBgwYgLFjx+LMmTMVEjvp3qVLl9C9e3fEx8dj1qxZGD16NMLCwgokc5988glGjhwJHx8fLFiwAJMnT8a+ffvQsWNHJCYmFtq2nZ0dli5dCgDo37+/ZgjVgAEDAAB79uzBrVu3MHr0aHzzzTd45ZVX8Ouvv6JXr14l+uG9e/duvPzyy5AkCfPmzUO/fv0wevRonD59ukDdCRMm4L333kP79u2xaNEijB49Gj///DOCg4OLvHrWoEEDzJkzBwDw2muvaeLv2LEjgLwfZOnp6Xj99dfxzTffIDg4GN988w1GjhxZbOw1iiDSo5UrVwoA4tSpU2Lx4sXC0tJSpKenCyGEGDRokOjcubMQQgg3NzcREhJSbHtBQUHCz89PJCQkiISEBHHt2jUxadIkAUD07t1bUy80NFS4ublp7Zt/3HzZ2dnC399fdOnSRVMWEREhZDKZ6N+/v1CpVFr11Wq1EEKIlJQUYWNjI8aPH6+1PTY2VlhbW2uVh4aGCgDirbfe0monJCREmJiYiISEBCGEEJs2bRIAxMcff6zV5sCBA4UkSSIyMrLYc0NVU2W8Bxo1alTk9o0bNwoAYtGiRZoyAEImk4krV65o1T1w4IAAIA4cOKBVfvv2bQFArFy5UlPWuHFj4eLiIlJSUjRlBw8eFAAKvNfIMPTr108olUpx584dTdnVq1eFXC4X+elDVFSUkMvl4pNPPtHa99KlS8LIyEir/NnP3YSEBAFAhIWFFTj2s5/HQgjxyy+/CADi0KFDxcberFkz4eTkJBITEzVlu3fvLvB6PHz4sAAgfv75Z639d+7cWaA8KChIBAUFaR6fOnWqwPvgefHPmzdPSJKkdT5rOvaEUpUxePBgZGRkYOvWrUhJScHWrVvLdBny+vXrsLOzg52dHRo0aIBvvvkGISEhWLFixXP3MzU11fz/kydPkJSUhBdeeAFnz57VlG/atAlqtRoffvghZDLtt0/+kiV79uxBYmIihg4diocPH2r+5HI52rRpgwMHDhQ49sSJE7XamThxIrKzs7F3714AwPbt2yGXyzFp0iSt/d555x0IIbBjx44Snh2qyirqPfA8+UuCpaSkaJUHBQWhYcOGZWrz/v37uHTpEkaOHKm15FhQUBAaN25c9mBJb1QqFXbt2oV+/fqhXr16mvIGDRogODhY83jDhg1Qq9UYPHiw1uedo6MjfHx8Cv28K4mnP48zMzPx8OFDtG3bFgC0PpML8+DBA5w/fx6hoaGwtrbWlL/44osFXuPr16+HtbU1XnzxRa34AwICYGFhUSHxp6Wl4eHDhwgMDIQQAufOnStTm9WRkb4DIMpnZ2eHbt26Yd26dUhPT4dKpcLAgQNL3Y67uzu+//57SJIEpVIJHx8f2NvbF7vf1q1b8fHHH+P8+fPIysrSlD+9Ht7Nmzchk8me+2UdEREBAOjSpUuh262srLQey2QyeHp6apXVr18fADSX7u/cuQNnZ2dYWlpq1WvQoIFmOxm+inoPPE9qaioAFHgteXh4lLnN/Neft7d3gW3e3t7FJg1U9SQkJCAjIwM+Pj4Ftvn6+mL79u0A8j7vhBCF1gMAY2PjMh3/8ePHmD17Nn799VfEx8drbcsfz5ydnY3Hjx9rbbOzs9O8HouK/enXY0REBJKSkor8jnj22CV19+5dfPjhh9iyZUuBsaVPj8eu6ZiEUpUybNgwjB8/HrGxsejZs+dzx3AWxdzcHN26dSvVPocPH0afPn3QsWNHLFmyBE5OTjA2NsbKlSsLXTbnefLXI127dm2hM5qNjPi2o6JVxHvgeS5fvgygYML4dM9NvqIWJFepVBUaExkutVoNSZKwY8cOyOXyAtvLejOOwYMH49ixY3jvvffQrFkzWFhYQK1Wo0ePHprP2GPHjqFz585a+92+fbvU8dvb2+Pnn38udHv+5KnSUKlUePHFF/H48WO8//778PPzg7m5OWJiYjBq1CiuWf0UfhtSldK/f39MmDABf//9N3777TedHffPP/+EUqnErl27tNZjXLlypVY9Ly8vqNVqXL16Fc2aNSu0LS8vLwCAvb19iZJhtVqNW7duaXo/AeCff/4BAM3kEDc3N+zduxcpKSlaPVjXr1/XbKfqoTLfAyqVCuvWrYOZmRk6dOhQbH1bW1sAKDC55Nme9/zXX2RkZIE2Ciujqs/Ozg6mpqaaKztPu3Hjhub/vby8IISAh4eH1mdYSRT1I+fJkyfYt28fZs+ejQ8//FBT/mwsTZs2LXADBkdHR81neHGx58e/d+9etG/fvtAfYmWJ/9KlS/jnn3+wevVqrYlIvFlEQRwTSlWKhYUFli5dilmzZqF37946O65cLockSVo9PFFRUdi0aZNWvX79+kEmk2HOnDkFfs2Kf2dsBgcHw8rKCnPnzi10ZmVhy0QtXrxYq53FixfD2NgYXbt2BZC3hqRKpdKqBwALFy6EJEno2bNn6Z4wVVmV9R5QqVSYNGkSrl27hkmTJhUYFlIYNzc3yOVyHDp0SKt8yZIlWo+dnZ3h7++PNWvWaC73A3kL7V+6dKlingDplFwuR3BwMDZt2oS7d+9qyq9du4Zdu3ZpHg8YMAByuRyzZ88uMGtdCPHcJZXMzMwAFPyRk9+j+mx7X331ldZjW1tbdOvWTetPqVTCyckJzZo1w+rVq7Uufe/ZswdXr17VamPw4MFQqVT46KOPCsSXm5tb5Ox+IO+qW0njF0Jg0aJFRbZVU7EnlKqc0NBQnR8zJCQECxYsQI8ePTBs2DDEx8fj22+/hbe3Ny5evKip5+3tjRkzZuCjjz7CCy+8gAEDBkChUODUqVNwdnbGvHnzYGVlhaVLl2LEiBFo0aIFXnnlFdjZ2eHu3bvYtm0b2rdvr5VMKpVK7Ny5E6GhoWjTpg127NiBbdu2Yfr06ZpLQb1790bnzp0xY8YMREVFoWnTpti9ezc2b96MyZMna3pfqXoo73sgKSkJP/30E4C8u9JERkZiw4YNuHnzJl555ZVCv3ALY21tjUGDBuGbb76BJEnw8vLC1q1bCx0nN3fuXPTt2xft27fH6NGj8eTJEyxevBj+/v5aiSkZjtmzZ2Pnzp144YUX8MYbbyA3NxfffPMNGjVqpPlc9PLywscff4xp06YhKioK/fr1g6WlJW7fvo2NGzfitddew7vvvlto+6ampmjYsCF+++031K9fH7Vq1YK/vz/8/f3RsWNHfPbZZ8jJyUHdunWxe/fuUl1qnzdvHkJCQtChQweMGTMGjx8/1sT+9OsxKCgIEyZMwLx583D+/Hl0794dxsbGiIiIwPr167Fo0aIix2V7eXnBxsYGy5Ytg6WlJczNzdGmTRv4+fnBy8sL7777LmJiYmBlZYU///zzueuO1lh6mpVPJITQXp7meSpqeZp8hS3R9OOPPwofHx+hUCiEn5+fWLlypQgLCxOFvU1WrFghmjdvLhQKhbC1tRVBQUFiz549WnUOHDgggoODhbW1tVAqlcLLy0uMGjVKnD59WisOc3NzcfPmTdG9e3dhZmYmHBwcRFhYWIEloFJSUsSUKVOEs7OzMDY2Fj4+PuLzzz/XLA1Fhqky3gMANH8WFhbCx8dHDB8+XOzevbvQfQCIN998s9BtCQkJ4uWXXxZmZmbC1tZWTJgwQVy+fLnQpWl+/fVX4efnJxQKhfD39xdbtmwRL7/8svDz8ys2bqqawsPDRUBAgDAxMRGenp5i2bJlhX4u/vnnn6JDhw7C3NxcmJubCz8/P/Hmm2+KGzduaOoU9rl77NgxTft4armm6Oho0b9/f2FjYyOsra3FoEGDxP3794tc0qkwf/75p2jQoIFQKBSiYcOGYsOGDYXGIIQQ3333nQgICBCmpqbC0tJSNG7cWPz3v/8V9+/f19R5dokmIYTYvHmzaNiwoTAyMtJ6T1y9elV069ZNWFhYiDp16ojx48eLCxcuFLmkU00lCcHbrRARUeVo1qwZ7OzsOB6OiArgmFAiIiq3nJycAve9P3jwIC5cuIBOnTrpJygiqtLYE0pEROUWFRWFbt26Yfjw4XB2dsb169exbNkyWFtb4/Lly6hdu7a+QySiKoYTk4iIqNxsbW0REBCAH374AQkJCTA3N0dISAjmz5/PBJSICsWeUCIiIiLSOY4JJSIiIiKdYxJKRERERDrHJJRqtKioKEiShFWrVuk7FKIKwdc0ERkKJqFEREREpHOcmEQ1mhACWVlZMDY21tzvl8iQ8TVNRIaCSSgRERER6Rwvx5PBmzVrFiRJwj///IPhw4fD2toadnZ2mDlzJoQQuHfvHvr27QsrKys4Ojriyy+/1Oxb2Pi5UaNGwcLCAjExMejXrx8sLCxgZ2eHd999FyrV/7V3rzFRXG0cwP8DlF3UXaQo1gsusJh6izewxpVKlSKo1ZqqqKQNGtG29marTcSkxVsAX0VsVajWFA22RnvRaKtWqxDqhuoXtNUmFRSpofWCFVAQC8vzfjA7cVxuIuxa+P8SAnPmzJkzk0PmyZlzztjUfDk5OVAUBTk5OZr61Ffm1atXMW/ePPTp0wc6nQ49e/bEyy+/jMuXL7fRXaH/MrZpIuoIGIRSuzFr1izU1dUhJSUFo0aNwpo1a7Bx40ZERkaid+/eWLt2LYKDg7F06VLk5uY2WpbNZkNUVBR8fX2xfv16hIeHIzU1Fdu2bWtR3aZPn459+/Zh3rx5SE9Px7vvvovbt2/jzz//bFF51DGwTRNRuyZE/3GJiYkCQBYuXKim1dbWSp8+fURRFElJSVHTb926JV5eXhIXFyciIkVFRQJAMjMz1TxxcXECQFatWqU5z/DhwyUkJETdzs7OFgCSnZ2tyfdwmbdu3RIAsm7duta5YGr32KaJqCNgTyi1G/Hx8erf7u7uCA0NhYhg/vz5anrXrl3x7LPP4tKlS02W98Ybb2i2n3/++WYd9zAvLy94enoiJycHt27deuTjqeNimyai9oxBKLUbffv21Wx7e3tDr9ejW7duDulNPTj1ej26d++uSfPx8WnRA1en02Ht2rU4fPgwevTogbFjx+J///sfrl69+shlUcfCNk1E7RmDUGo36luOpqElaqSJRSGas7SNoij1pj840cNu8eLFuHDhApKTk6HX6/HRRx9hwIAByM/Pb/I81HGxTRNRe8YglKiFfHx8AABlZWWa9OLi4nrzm81mLFmyBEePHsW5c+fw77//amY1E7ka2zQRORODUKIWMplMcHd3d5iVnJ6ertmuqqpCdXW1Js1sNsNgMODevXttXk+i5mKbJiJn8nB1BYj+q7y9vTFz5kxs2rQJiqLAbDbj+++/x/Xr1zX5Lly4gIiICMTExGDgwIHw8PDAvn37cO3aNcyePdtFtSdyxDZNRM7EIJToMWzatAk1NTX47LPPoNPpEBMTg3Xr1mHw4MFqHn9/f8yZMwfHjx9HVlYWPDw80L9/f+zduxfTp093Ye2JHLFNE5Gz8LOdREREROR0HBNKRERERE7HIJSIiIiInI5BKBERERE5HYNQIiIiInI6BqFERERE5HQMQqnDWrFiRYOfKXRFPUpLS11dFSIiIqdhEEousXfvXiiKgn379jnsGzp0KBRFQXZ2tsO+vn37wmKxNFr23LlzoSiK+mM0GjF06FCkpqbyay70RHBm++/SpQuCgoIwY8YMfPvtt6irq2u16yAiehwMQsklwsLCAAAnT57UpFdUVODcuXPw8PCA1WrV7Lty5QquXLmiHtsYnU6HrKwsZGVlISkpCU8//TSWLl2KuLi41rsIohZyZvtPS0tDbGwsCgoKMGPGDERERKCioqL1LoaIqIX4xSRyiV69eiEwMNDhIZyXlwcRwcyZMx322beb8xD28PDAq6++qm4vWrQIo0aNwp49e7Bhwwb06tWrFa6CqGWc3f4BYM2aNUhJSUFCQgIWLFiAPXv2NHi8iKC6uhpeXl7NvSQiokfGnlBymbCwMOTn5+Pu3btqmtVqxaBBgzBx4kT88ssvmleHVqsViqJgzJgxj3wuNzc3vPDCCwCAy5cvN5gvMzMT48ePh5+fH3Q6HQYOHIiMjIx68x4+fBjh4eEwGAwwGo0YOXIkvvrqK02eU6dOITo6Gt7e3ujUqRPCw8MderjsSktLERMTA6PRCF9fX7z33nuorq7W5KmtrcXq1athNpuh0+kQEBCA5cuXc5jBf5Az27/dsmXLMGHCBHz99de4cOGCmh4QEICXXnoJP/74I0JDQ+Hl5YWtW7fi8uXLUBQFO3bscChLURSsWLFCk5aTk4PQ0FDo9XqYzWZs3br1iRl7TURPHgah5DJhYWGoqanBqVOn1DSr1QqLxQKLxYLy8nKcO3dOs69///7w9fVt0fkuXrwIAI0en5GRAZPJhOXLlyM1NRX+/v5YtGgRtmzZosm3Y8cOTJ48Gf/88w8SEhKQkpKCYcOG4ciRI2qeEydOYOzYsaioqEBiYiKSkpJQVlaG8ePH4/Tp0w7njomJQXV1NZKTkzFp0iR8+umnWLhwoSZPfHw8Pv74Y4wYMQJpaWkIDw9HcnIyZs+e3aJ7Qq7j7PZv99prr0FEcOzYMU36H3/8gTlz5iAyMhKffPIJhg0b9kjl5ufnIzo6Gjdv3sTKlSsxf/58rFq1Cvv373+s+hJROyZELnL+/HkBIKtXrxYRkZqaGuncubPs3LlTRER69OghW7ZsERGRiooKcXd3lwULFjRZblxcnHTu3Flu3LghN27ckMLCQklKShJFUWTIkCFqvsTERHn4X6CqqsqhvKioKAkKClK3y8rKxGAwyKhRo+Tu3buavHV1dervfv36SVRUlJpmLz8wMFAiIyMd6jF16lRNWYsWLRIAcvbsWREROXPmjACQ+Ph4Tb6lS5cKADlx4kST94aeHG3d/huSn58vAOT9999X00wmkwCQI0eOaPIWFRUJAMnMzHQoB4AkJiaq21OmTJFOnTpJSUmJmlZQUCAeHh4O/2dERCIi7AkllxkwYAB8fX3VsW5nz55FZWWlOvvXYrGor67z8vJgs9maNR4OACorK9G9e3d0794dwcHBWL58OUaPHl3vbOQHPTgGrry8HKWlpQgPD8elS5dQXl4OADh27Bhu376NZcuWQa/Xa463v3Y8c+YMCgoKEBsbi5s3b6K0tBSlpaWorKxEREQEcnNzHWYpv/XWW5rtd955BwBw6NAhze8PPvhAk2/JkiUAgB9++KHpG0NPjLZs/43p0qULAOD27dua9MDAQERFRbWoTJvNhp9++gnTpk3TjLcODg7GxIkTW15ZImrXODGJXEZRFFgsFjUgs1qt8PPzQ3BwMID7D+HNmzcDgPowbu5DWK/X4+DBgwDuzxQODAxEnz59mjzOarUiMTEReXl5qKqq0uwrLy+Ht7e3+lp/8ODBDZZTUFAAAI3Oxi8vL4ePj4+63a9fP81+s9kMNzc3dQxrcXEx3Nzc1Ptj98wzz6Br164oLi5u8vroydGW7b8xd+7cAQAYDAZNemBgYIvLvH79Ou7evevQNgHUm0ZEBDAIJRcLCwvDwYMH8dtvv6nj4ewsFgs+/PBDlJSU4OTJk+jVqxeCgoKaVa67uztefPHFR6rLxYsXERERgf79+2PDhg3w9/eHp6cnDh06hLS0tEdaX9Ged926dQ2OrbP3SDWkockcnOTRfrRV+2+MfZzpw8FhfTPhG2prNpvtsetBRMQglFzqwfUSrVYrFi9erO4LCQmBTqdDTk4OTp06hUmTJrVpXQ4ePIh79+7hwIED6Nu3r5r+8KLhZrMZwP2HeUO9PPY8RqOx2cFwQUGBpjeqsLAQdXV1CAgIAACYTCbU1dWhoKAAAwYMUPNdu3YNZWVlMJlMzToPPTlc0f6zsrKgKAoiIyObzGvvqS8rK9OkP9zr7ufnB71ej8LCQocy6ksjIgI4O55czL6cy5dffomSkhJNT5BOp8OIESOwZcsWVFZWtsqryMa4u7sDuL9Gol15eTkyMzM1+SZMmACDwYDk5GSHJZTsx4aEhMBsNmP9+vXq688H3bhxwyHt4Rn4mzZtAgB1TJ09CNm4caMm34YNGwAAkydPbvwC6Ynj7PafkpKCo0ePYtasWQ7DP+pjNBrRrVs35ObmatLT09M12/Y3D/v378dff/2lphcWFuLw4cOPXW8iap/YE0ou5enpiZEjR+Lnn3+GTqdDSEiIZr/FYkFqaiqA1hkP15gJEybA09MTU6ZMweuvv447d+7g888/h5+fH/7++281n9FoRFpaGuLj4zFy5EjExsbCx8cHZ8+eRVVVFXbu3Ak3Nzds374dEydOxKBBgzBv3jz07t0bJSUlyM7OhtFoVMes2hUVFWHq1KmIjo5GXl4edu3ahdjYWAwdOhTA/c85xsXFYdu2bSgrK0N4eDhOnz6NnTt3Ytq0aRg3blyb3h9qfW3V/mtra7Fr1y4AQHV1NYqLi3HgwAH8+uuvGDduHLZt29bssuLj45GSkoL4+HiEhoYiNzdXs8ao3YoVK3D06FGMGTMGb775Jmw2GzZv3ozBgwfjzJkzzT4fEXUgrp6eT5SQkCAAxGKxOOz77rvvBIAYDAapra1tVnlNLVFjV98STQcOHJAhQ4aIXq+XgIAAWbt2rXzxxRcCQIqKihzyWiwW8fLyEqPRKM8995zs3r1bkyc/P19eeeUV8fX1FZ1OJyaTSWJiYuT48eMO9fj9999lxowZYjAYxMfHR95++22HJaBqampk5cqVEhgYKE899ZT4+/tLQkKCVFdXN+ve0JOnLdo/APWnU6dOEhAQINOnT5dvvvlGbDabwzEmk0kmT55cb3lVVVUyf/588fb2FoPBIDExMXL9+nWHJZpERI4fPy7Dhw8XT09PMZvNsn37dlmyZIno9fpm1Z2IOhZF5IF3j0RERK1o2rRpOH/+vLpiBBGRHceEEhFRq3jwE6TA/cl2hw4dUj+ZS0T0IPaEEhFRq+jZsyfmzp2LoKAgFBcXIyMjA/fu3UN+fn6zJkIRUcfCiUlERNQqoqOjsXv3bly9ehU6nQ6jR49GUlISA1Aiqhd7QomIiIjI6TgmlIiIiIicjkEoERERETkdg1AiIiIicjoGoURERETkdAxCiYiIiMjpGIQSERERkdMxCCUiIiIip2MQSkREREROxyCUiIiIiJzu/1UvCWlB/uujAAAAAElFTkSuQmCC", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -345,19 +249,9 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArgAAAG1CAYAAAAStodsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAACPkUlEQVR4nOzdd3hT1f8H8PdN2ibdezK6mWUWRFllScEyyh4iZYoKIjh+iohlKKAoiCCIg7JEBZmyV1sEUZAlmxYoo7S0QPducn5/1OZL6KA7bfp+PU8fyLnnnvu5t0nzycm550hCCAEiIiIiIj0h03UAREREREQViQkuEREREekVJrhEREREpFeY4BIRERGRXmGCS0RERER6hQkuEREREekVJrhEREREpFeY4BIRERGRXmGCS0RERER6hQkuUS0UFhYGSZIQFhZWI2NYs2YNJElCVFRUhcdVVlUZU25uLv7v//4P9erVg0wmQ2BgYKUfk4ioJmGCS1RN5SdM+T9KpRIuLi7w9/fH119/jZSUlAo93saNG/HVV19VaJtVacWKFVizZo2uwyiT0l771atXY9GiRRg8eDDWrl2L6dOnV15wALp06aJ5HspkMlhYWKBhw4Z45ZVXcPDgwUo9dnl8//338PPzg6OjIxQKBdzd3TF27Nhq9cGIiCqHga4DIKLizZ07F+7u7sjJyUFsbCzCwsIwbdo0LF68GDt37kTz5s0r5DgbN27ExYsXMW3atAppr6qtWLECdnZ2GDNmjK5DKbXSXvsjR46gTp06WLJkSeUG9oS6detiwYIFAIC0tDRERkZi69at2LBhA4YOHYoNGzbA0NCwyuIpibNnz8Ld3R39+vWDtbU1bt26he+//x67du3C+fPn4eLiousQiaiSMMElquZ69+6NNm3aaB7PmDEDR44cQZ8+fdCvXz9cuXIFxsbGOoyQqlpcXBysrKwqrD21Wo3s7Gwolcoi61haWmLUqFFaZQsXLsTUqVOxYsUKuLm54bPPPivXMSraihUrCpQFBgaiTZs2WLduHT744IMqi4WIqhaHKBDVQN26dcOsWbNw+/ZtbNiwQWvb1atXMXjwYNjY2ECpVKJNmzbYuXNnse116dIFu3fvxu3btzVfRbu5uQEAsrOz8fHHH8PX1xeWlpYwNTVFp06dEBoaWuJ47927h8DAQJiamsLBwQHTp09HVlZWoXX//vtv9OrVC5aWljAxMYGfnx+OHz9ebPtubm64dOkSwsPDNfF36dIFAPD48WO8++67aNasGczMzGBhYYHevXvj/PnzJYpdkiRMmTIFP/30Exo2bAilUglfX18cPXq0RPuvWLECTZs2hUKhgIuLCyZPnozExETN9uKu/dOioqIgSRJCQ0Nx6dIlTf38ccxpaWl45513UK9ePSgUCjRs2BBffPEFhBBFnlN+bPv27SvR+TxJLpfj66+/RpMmTbB8+XIkJSU98xhFjb3OP7enh5ls3rwZTZo0gVKphI+PD7Zt24YxY8YUeY2eJX+/J38HRKR/2INLVEO98sor+PDDD3HgwAFMnDgRAHDp0iV06NABderUwQcffABTU1Ns2rQJgYGB2LJlCwYMGFBoWzNnzkRSUhLu3bun+drbzMwMAJCcnIwffvgBI0aMwMSJE5GSkoIff/wR/v7+OHnyJFq2bFlsnBkZGejevTvu3LmDqVOnwsXFBevXr8eRI0cK1D1y5Ah69+4NX19fBAcHQyaTISQkBN26dcMff/yB5557rtBjfPXVV3jzzTdhZmaGmTNnAgAcHR0BADdv3sT27dsxZMgQuLu748GDB1i1ahX8/Pxw+fLlEn1NHR4ejl9//RVTp06FQqHAihUr0KtXL5w8eRI+Pj5F7jd79mzMmTMHPXr0wOuvv45r165h5cqVOHXqFI4fPw5DQ8Nir/3T7O3tsX79enz66adITU3VDBlo3LgxhBDo168fQkNDMX78eLRs2RL79+/He++9h+jo6ALDGY4cOYJNmzZhypQpsLOzK3PCKJfLMWLECMyaNQvHjh1DQEBAsccoTWK5e/duDBs2DM2aNcOCBQuQkJCA8ePHo06dOqWK8dGjR1CpVLhz5w7mzp0LAOjevXup2iCiGkYQUbUUEhIiAIhTp04VWcfS0lK0atVK87h79+6iWbNmIjMzU1OmVqtF+/bthbe3t6YsNDRUABChoaGasoCAAOHq6lrgGLm5uSIrK0urLCEhQTg6Oopx48Y98zy++uorAUBs2rRJU5aWlia8vLy0YlCr1cLb21v4+/sLtVqtqZueni7c3d3Fiy++qCnLvza3bt3SlDVt2lT4+fkVOH5mZqZQqVRaZbdu3RIKhULMnTv3mfEDEADEP//8oym7ffu2UCqVYsCAAUXGFBcXJ4yMjETPnj21jr98+XIBQKxevVpTVtS1L4qfn59o2rSpVtn27dsFAPHJJ59olQ8ePFhIkiQiIyO1zkkmk4lLly6V+XhP2rZtmwAgli5d+sxjFPbcEyLvdwJAhISEaMqaNWsm6tatK1JSUjRlYWFhAkCprpdCodD8Hm1tbcXXX39d4n2JqGbiEAWiGszMzEwzm8Ljx49x5MgRDB06FCkpKXj48CEePnyIR48ewd/fHxEREYiOji71MeRyOYyMjADkjaN8/PgxcnNz0aZNG5w5c+aZ++/ZswfOzs4YPHiwpszExASvvvqqVr1z584hIiICI0eOxKNHjzTxp6WloXv37jh69CjUanWp41coFJDJ8v7UqVQqPHr0CGZmZmjYsGGJ4geAF154Ab6+vprH9evXR//+/bF//36oVKpC9zl06BCys7Mxbdo0zfEBYOLEibCwsMDu3btLfS7F2bNnD+RyOaZOnapV/s4770AIgb1792qV+/n5oUmTJhVy7Pwe56dn9ijPMe7fv48LFy5g9OjRWj3afn5+aNasWana2rt3L/bs2YMvv/wS9evXR1paWpliIqKag0MUiGqw1NRUODg4AAAiIyMhhMCsWbMwa9asQuvHxcWV+utdAFi7di2+/PJLXL16FTk5OZpyd3d3zf/j4+O1kj0zMzOYmZnh9u3b8PLygiRJWm02bNhQ63FERAQAICgoqMg4kpKSYG1tXarY1Wo1li5dihUrVuDWrVtaMdra2paoDW9v7wJlDRo0QHp6OuLj4+Hk5FRg++3btwEUPE8jIyN4eHhotleU27dvw8XFBebm5lrljRs31oon35O/u/JKTU0FgALHLs8x8uP18vIqsM3Ly6vEH04AoGvXrgDybtjs378/fHx8YGZmhilTppQ5PiKq3pjgEtVQ9+7dQ1JSkiYByO/dfPfdd+Hv71/oPoUlC8+yYcMGjBkzBoGBgXjvvffg4OAAuVyOBQsW4MaNG5p6bdu21UqigoODMXv27BIfJz/+RYsWFTmut6ixqcWZP38+Zs2ahXHjxmHevHmwsbGBTCbDtGnTytQjrC8qcuaNixcvAij4/CrsGE9/0MlXVE94RfP09ESrVq3w008/McEl0mNMcIlqqPXr1wOAJpn18PAAABgaGqJHjx6lbq+oxOO3336Dh4cHtm7dqlUnODhYq95PP/2EjIwMzeP8eFxdXXHx4kUIIbT2v3btmtb+np6eAAALC4sKj79r16748ccftcoTExNhZ2dXorbze5efdP36dZiYmMDe3r7QfVxdXQHknWf+tQDyZqW4deuW1jkWFXtpuLq64tChQ0hJSdHqSb169apWPBVNpVJh48aNMDExQceOHZ9ZP78H/umbzZ7uYc6PNzIyskAbhZWVRkZGRpGzeBCRfuAYXKIa6MiRI5g3bx7c3d3x8ssvAwAcHBzQpUsXrFq1CjExMQX2iY+PL7ZNU1NTrWme8snlcgDQmmrq77//xokTJ7TqdejQAT169ND85Cd1L730Eu7fv4/ffvtNUzc9PR3fffed1v6+vr7w9PTEF198ofnKu7TxF3aHvlwuLzBN1ubNm0s1HvnEiRNaX4nfvXsXO3bsQM+ePTXX52k9evSAkZERvv76a63j//jjj0hKStKabaCoa18aL730ElQqFZYvX65VvmTJEkiShN69e5er/cKoVCpMnToVV65cwdSpU2FhYfHMfVxdXSGXywtMs/b0nLUuLi7w8fHBunXrtJ4P4eHhuHDhwjOPk5ubi4SEhALlJ0+exIULF7TmliYi/cMeXKJqbu/evbh69Spyc3Px4MEDHDlyBAcPHoSrqyt27typNXH+N998g44dO6JZs2aYOHEiPDw88ODBA5w4cQL37t0rdu5XX19f/Prrr3j77bfRtm1bmJmZoW/fvujTpw+2bt2KAQMGICAgALdu3cK3336LJk2aFJqIPm3ixIlYvnw5Ro8ejdOnT8PZ2Rnr16+HiYmJVj2ZTIYffvgBvXv3RtOmTTF27FjUqVMH0dHRCA0NhYWFBX7//fdi41+5ciU++eQTeHl5wcHBAd26dUOfPn0wd+5cjB07Fu3bt8eFCxfw008/afWqPouPjw/8/f21pgkDgDlz5hS5j729PWbMmIE5c+agV69e6NevH65du4YVK1agbdu2WosmFHXtS6Nv377o2rUrZs6ciaioKLRo0QIHDhzAjh07MG3aNE0PeVklJSVp5lxOT0/XrGR248YNDB8+HPPmzStRO5aWlhgyZAiWLVsGSZLg6emJXbt2IS4urkDd+fPno3///ujQoQPGjh2LhIQELF++HD4+Ps987qWmpqJevXoYNmwYmjZtClNTU1y4cAEhISGwtLQscpw6EekJXU7hQERFy592Kv/HyMhIODk5iRdffFEsXbpUJCcnF7rfjRs3xOjRo4WTk5MwNDQUderUEX369BG//fabpk5hUzWlpqaKkSNHCisrK61pmNRqtZg/f75wdXUVCoVCtGrVSuzatUsEBQWVeKqm27dvi379+gkTExNhZ2cn3nrrLbFv375Cp4s6e/asGDhwoLC1tRUKhUK4urqKoUOHisOHDxe4Nk9OExYbGysCAgKEubm5AKCZMiwzM1O88847wtnZWRgbG4sOHTqIEydOCD8/v0KnFXsaADF58mSxYcMG4e3trbkGT8ddWExC5E0L1qhRI2FoaCgcHR3F66+/LhISErTqFHXti1LUtF0pKSli+vTpwsXFRRgaGgpvb2+xaNEirWnXnjynkvLz89N6LpqZmQlvb28xatQoceDAgUL3Ke4Y8fHxYtCgQcLExERYW1uLSZMmiYsXLxaYJkwIIX755RfRqFEjoVAohI+Pj9i5c6cYNGiQaNSoUbExZ2Vlibfeeks0b95cWFhYCENDQ+Hq6irGjx9f4HdERPpHEuKp7+6IiEhDkiRMnjy5wFf/pDstW7aEvb09Dh48qOtQiKia4hhcIiKqlnJycpCbm6tVFhYWhvPnz2uWYiYiKgzH4BIRUbUUHR2NHj16YNSoUXBxccHVq1fx7bffwsnJCa+99pquwyOiaowJLhERVUvW1tbw9fXFDz/8gPj4eJiamiIgIAALFy4s8SIdRFQ7cQwuEREREekVjsElIiIiIr3CBJeIiIiI9AoTXCIiIiLSK0xwiYiIiEivMMElIiIiIr3CBJeIiIiI9AoTXCIiIiLSK0xwiYiIiEivMMElIiIiIr3CBJeIiIiI9AoTXCIiIiLSK0xwiYiIiEivMMElIiIiIr3CBJeIiIiI9AoTXCIiIiLSK0xwiYiIiEivMMElIiIiIr3CBJeIiIiI9AoTXCIiIiLSK0xwiYiIiEivMMElIiIiIr3CBLeUYmJiMHv2bMTExOg6FCIiIiIqBBPcUoqJicGcOXOY4BIRERFVU0xwiYiIiEivMMElqgRCrULirXNIib6m61CIiIhqHQNdB0CkL7LTEpH5+D5MHFxxdcsCJN48CwCo13E4XLu8ouPoiIiIag8muEQVICX6Gi5smAF1ThYMTa2Rk5ag2Rb993YmuERERFWIQxSIKsD9U79DnZsDAHnJrfTfS0uSQWFhp8PIiIiIah/24BJVAENTK63HLs/1R1LUecgVxvDsPVk3QREREdVSTHCJKkD9TsORmXAfKfevw65xJ7h3HwtJJtd1WERERLUSE1yiCmCgNEOToR/rOgwiIiICx+ASERERkZ5hgktEREREeoVDFIgqgSo7Ew+v/AGZgRHsGnfkeFwiIqIqxASXqAIIoUbM6T1IvR8BmwbtcO/PzUi9fx0A8DjiFBoGvqvjCImIiGoPJrhEFeD+qd9x68B3gCRD3L+HtLbFXwpHg/7vQJIkHUVHRERUu3AMLlEFSLl3FZAkQKgBADIDo7zFHiQZTOzrM7klIiKqQuzBJaoANl5t8fDy0bwkV5LBq+80PLr6J2QGRlyml4iIqIoxwSWqAA7Nu8HA2AypMZGw9moLcxdvODT103VYREREtRITXKISaNOmDWJjY+Hk5IR//vmn0Do23s/Bxvu5Ko6MiIiInsYEl6gEYmNjER0dreswiIiIqAR4kxkRERER6RX24BJVgqTbF/DwyjGY2LvCqXUvSBI/SxIREVUVJrhEFSz1wU1c2PBh3gOhRm5mKup1GKrboIiIiGqRat2tdOfOHbz22mto2LAhbGxscPToUQDAw4cPMXXqVJw9e1bHERL9T2pMJGLPHcDjiJN58+H+Nydu8p1LOo6MiIiodqm2PbiXL19Gp06doFar0a5dO0RGRiI3NxcAYGdnh2PHjiEtLQ0//vijjiMlAh5HnMTlX+cCEJAMjCDJ5BBCAEINK4+Wug6PiIioVqm2Ce7//d//wcrKCn/99RckSYKDg4PW9oCAAPz66686io5IW9yFUEACIACRmwPntn0gN1TCxN4V9j5ddB0eERFRrVJtE9yjR4/i448/hr29PR49elRge/369TltE1UbJvb1gcv5jwSsPVpzTlwiIiIdqbYJrlqthomJSZHb4+PjoVAoqjAioqLVbT8Y6pwspNy/DrtG7bWSWyHUiL8YhqykONg18YOxjbMOIyUiItJ/1TbBbd26NXbv3o033nijwLbc3Fz88ssveP7553UQGVFBMrkh3LqNKXTbnbANuHv8V0CScO/EVvi+vgpGZtZVGyAREVEtUm1nUZgxYwb27duH119/HRcvXgQAPHjwAIcOHULPnj1x5coVfPDBBzqOkuh/cjJSkBJ9DaqcTKhysvDg38OIuxiGh9dO5FUQAqqsNKTcv6bbQImIiPRcte3B7d27N9asWYO33noL3333HQBg1KhREELAwsIC69atQ+fOnUvdbnR0NN5//33s3bsX6enp8PLyQkhICNq0aVPRp0B6xMnJSevfp6XGRODf9R9AnZ0JIwsHKMxtkBJ9FQBgZOkASBIACZJMBlMH96oKm4iIqFaqtgkuALzyyisYOHAgDh48iIiICKjVanh6esLf3x/m5ualbi8hIQEdOnRA165dsXfvXtjb2yMiIgLW1vy6mIr3zz//FLs9+uROqHOyAQDZyXHITo7TbMtOikO9TiOQnfIIji1ehNLKsVJjJSIiqu2qdYILAKampggMDKyQtj777DPUq1cPISEhmjJ3d/am0bO1adMGsbGxcHJyKjTZNTTW/sAlNzKBKicTAKC0ckT9zi9DkiTNdiHUkCQZcjPTcDt0LTKT4+Hs+xKyEh/g7vFNMDKzgXvPV3E7dB3SHtyEvU8XePZ6jUv+EhERlUC1TXA9PDzg6OiINWvWoGHDhgW279ixA9OnT8fNmzdL3ObOnTvh7++PIUOGIDw8HHXq1MEbb7yBiRMnFrlPVlYWsrKyNI9TU1NLdyKkF2JjY4udlq5epxFIf3QPqfcjYNe4A5x9A3D3+K+QZHK4+o3SJLdCqBG55xs8OHcASitHGNvWRcKN04AQSIg4BUAAALJTE3D1t0+Qk54CCDViT++GlWsz2DXpVBWnS0REVKNV2wQ3KioK0dHReO6557B27doCvbipqam4fft2qdq8efMmVq5cibfffhsffvghTp06halTp8LIyAhBQUGF7rNgwQLMmTOnrKdBtYShsTl8RszVKms0MO8mSKFWIfbMPmQmxkBh4YAHZ/cBADITHyA7NUGzpK8WoYYqOwv5CS8A5GbywxUREVFJVOvvOxcvXozOnTtj0KBBmDVrVrnbU6vVaN26NebPn49WrVrh1VdfxcSJE/Htt98Wuc+MGTOQlJSk+QkPDy93HKT/stMSEXN6Nx5dO4Hb4T8hcs8y3DuxFTcPfPdELaE1XZihqTXM6zb+75GEOu0CITPIm+vZ2LYue2+JiIhKqNr24AKAtbU1fv/9d8ydOxdz587FmTNnsHHjRlhaWpapPWdnZzRp0kSrrHHjxtiyZUuR+ygUCq0FJczMzMp0bKo9crPSce6Ht5Cd8hAAYJifxAo1hFDDxN4N6fFRkBsq4d13OtQ5mchKiodNw+dhaGyO1JhIGJpYQmnthDrtApGZFAcTu/qQGRjq8KyIiIhqjmqd4Ob7+OOP8dxzz2HUqFFo27Yttm3bVqZ2OnTogGvXtOcgvX79OlxdXSsiTKrF1LnZuHVoNVKir8LUyVOT3AKAOue/MdySDJJMjsZDPoJMbgADE3PIDZUF2jKv878x5wbG5jAzLv2MIURERLVZjUhwAaBXr144deoUBg4ciOeffx69e/cudRvTp09H+/btMX/+fAwdOhQnT57Ed999p5lnl6is7h77FTGndwFCIDUmApBkgBCAJMHSrQWsXJsjIyEGDs26cqleIiKiSlZjElwgb0qvEydOYNKkSVi/fr3WtEslkd/7O2PGDMydOxfu7u746quv8PLLL1dSxFRbZCbEPPFIgmNLf+RmJMPI3AaufqNgoOTQFiIioqpSbRPc0NBQNG7cuEC5UqnE2rVrMXToUDx8+LCQPYvXp08f9OnTpyJCJNJwaPEi4i//AUBArjBGvfaDobQufNUzIiIiqlzVNsH18/MrdntAQEAVRUL0bNYerdB60jdIexAFi/pNoTC3LVAnNSYCqTE3YOnWgsMUiIiIKlG1SXDXrVsHIG95XkmSNI+LI0kSXnnllcoOjahETOzqw8SufqHbHkeewuVf5gAQkBkYoeWEpUXWJSIiovKpNgnumDFjIEkShg8fDiMjI4wZM+aZ+zDBpeouJy0JuVmpiL8YDkgSIATUuTl4dO0vJrhERESVpNokuLdu3QIAGBkZaT0mqklSYyLx6PpfMHVwg1qtwvXtXwBCDRP7+nmzKgAARN5jIiIiqhTVJsF9ei5azk1L1YmTk5PWv4VJi7+N8yHvQAg1INQwMDbXLMObHn8Hji17Iis5HrYNnodtg+erJG4iIqLaqNokuM+SnZ2Nv//+GzExMWjYsCFatGih65CoFvnnn3+eWSfp9gUIda7msVDlaoYlAECd5wfCxK5epcVIREREeWS6DuBJ+/fvx7hx4wpM/3X16lX4+PigS5cuGDFiBFq3bo3BgwcjNze3iJaIqp65S0MAUt4iDwDsm3eH0tIRciNjuHUfx+SWiIioilSrHtzVq1cjMjISdnZ2WuUvv/wyIiMjERQUhDZt2mDPnj3Ytm0bli1bhunTp+soWiJt5i7eaDpyHh5e+QOmDm5wbtMHUq/XdR0WERFRrVOtenD/+ecf9OjRQ6vs7NmzOHv2LF5++WWEhIRg8uTJ2L17Nzp27IiffvpJR5ESFfQ44iRS7l2BU6vecGnbD5JUrV5eREREtUa1egeOjY2Fl5eXVtm+ffsgSVKBacMCAwNx7dq1KoyOqGhx/x7B5V/n4M4fG3F+zTtIjb2h65CIiIhqrWqV4JqZmSE9PV2r7NixY5DJZGjXrp1WuZWVFVQqVVWGR1Skx5Gn/ndDmVqNxFvndB0SERFRrVWtEtzGjRtjx44dmscJCQk4evQo2rdvDzMzM626d+/eLXbKJqKqZF63UV5yK8kAiP9uOCMiIiJdqFY3mb3zzjvo378/evfujfbt2+P3339Heno63njjjQJ19+3bh1atWukgSqKCXNr2hSSTIzUmErYN2sHS1UfXIREREdVa1SrB7du3Lz7//HN88skn2L9/P4yNjTFr1iwMGzZMq95ff/2Fv/76Cz/88IOOIiXSJkkyuLTpo+swiIiICIAkhGb90GpDpVLh4cOHcHBwgCRJBbZnZGQgPT0dVlZWkMvlVRrbmTNn4Ovri9OnT6N169ZVemwiIiIierZq1YObTy6Xw9HRscjtxsbGMDY2rsKIiIiIiKimqFY3mRERERERlRcTXCIiIiLSK0xwiYiIiEivMMElIiIiIr1SLRPczMxMfP311zh69KiuQyEiIiKiGqZaJrhKpRLvv/8+rl27putQiIiIiKiGqZYJLgD4+PggKipK12EQERERUQ1TbRPcTz/9FKtWrcKhQ4d0HQoRERER1SDVcqEHAFi+fDlsbGzg7+8Pd3d3uLu7F1jcQZIk7NixQ0cREhEREVF1VG0T3H///ReSJKF+/fpQqVSIjIwsUKewZXyJiIiIqHartgkux98SERERUVlU2zG4RERERERlUW17cPOFh4dj9+7duH37NgDA1dUVAQEB8PPz03FkRERERFQdVdsENzs7GyNGjMD27dshhICVlRUAIDExEV9++SUGDBiAn3/+GYaGhroNlIiIiIiqlWo7RGHOnDnYtm0b3nnnHcTExODx48d4/PgxYmNj8e6772Lr1q2YO3eursMkIiIiompGEkIIXQdRGHd3d3Tp0gUhISGFbh8zZgzCwsKq/Ga0M2fOwNfXF6dPn0br1q2r9NhERERE9GzVtgc3JiYG7dq1K3J7u3btEBsbW4UREREREVFNUG0T3Lp16yIsLKzI7eHh4ahbt27VBURERERENUK1TXCDgoKwadMmvPbaa7h27RpUKhXUajWuXbuG119/HZs3b8aYMWN0HSYRERERVTPVdhaFDz/8EDdu3MB3332H77//HjJZXi6uVqshhEBQUBA+/PBDHUdJRERERNVNtU1w5XI51qxZg7fffht79uzRmgf3pZdeQvPmzXUcIRERERFVR9U2wc3XvHlzJrNEREREVGLVdgzuk9RqNRISEjRz4T75Ux4LFy6EJEmYNm1axQRKRERERDpXbXtwc3Jy8Nlnn2H16tW4e/cu1Gp1ofVUKlWZ2j916hRWrVrF3mEiIiIiPVNtE9xJkyZh7dq1eP755xEYGAhLS8sKazs1NRUvv/wyvv/+e3zyyScV1i4RERER6V61TXA3b96MV155BWvWrKnwtidPnoyAgAD06NHjmQluVlYWsrKyNI9TU1MrPB4iIiIiqjjVNsE1MTHB888/X+Ht/vLLLzhz5gxOnTpVovoLFizAnDlzKjwOXbh48z7Cz11HfUcbBLzQDDKZpOuQiIiIiCpctb3JbMSIEdi1a1eFtnn37l289dZb+Omnn6BUKku0z4wZM5CUlKT5CQ8Pr9CYqkpUzCO8+81m7Dx+Hl//dgQ/Hzqp65CIqIZIjb2BiN+/wq3Dq5GbmabrcIiInqna9uB+/vnnGDduHPr06YNx48ahXr16kMvlBeq1bt26xG2ePn0acXFxWvuoVCocPXoUy5cvR1ZWVoFjKBQKKBQKzWMzM7MynI3uXbkdA5VaaB6fj7yHl3u202FERFQT5GSk4MK696HKyRuqlf7wLpoOC9ZxVERExau2CW5WVhbUajX27t2LvXv3FtguhIAkSaWaRaF79+64cOGCVtnYsWPRqFEjvP/++4Um0PogOycXDeo5wkAug1oIqNUCvg1ddR0WEdUAmY+jocrO0DxOib6qw2iIiEqm2ia448aNw7Zt2zB8+HC0a9euQmZRMDc3h4+Pj1aZqakpbG1tC5Tri53HzmPFtjAAEoZ2bwOVSoX6jjbo2baJrkMjKpOrt2Ox89h5WJubYOSLz8HUWPHsnajMjO1cYWRuh+zUR4AQsG34gq5DIiJ6pmqb4O7fvx9vvvkmlixZoutQaqzM7Bx8sy0MarUAILD5yD/YuXAyDA30s6ea9F9CSjreXfEbcnLyvrmJfpiI2eP66jgq/ZQaewNXNs1DdupjOLToCaW1E4xMLOHQvJuuQyMieqZqm+BaWFjAy8ur0o8TFhZW6ccgoopxLy4BWdm5msdXb8fqMBr9dmPfSmSlPAKEGg/O7kXzMV/Aom5jXYdFRFQi1XYWhYkTJ+Lnn38u80plBCiNDDF5QBfIZRLkMhneHNyNvbdUo3nWsYedpRmk/2a469TCW7cB6TF1bjYghPZjIqIaotr24DZp0gQ7duxA69atERQUVOQsCgMHDtRBdDVHv44t0KtdUwCAkWG1/XUTlYiJ0gjLp4/AkTNXYW1ugq6tG+o6JL3l1m0srmyaB3VuFmwaPA/L+vp5nwIR6SdJiCc+olcjMtmzO5dLO4tCRThz5gx8fX1x+vTpUk1RRkRU06iyM5CbkQojCztIEheGIaKao9p26YWGhuo6BCLSQxlZObh4KxoO1hZwdbTRdTjVWk5aErJTH8PQzAqS3FDX4RARlVi1TXD9/Px0HQIR1VC5KhWiYh7B3soclmbGuB37CPGJqfCqY4+3l2/G3bgEAMAHo3qhu28jHUdbPcVfCse1bYsACJi5NEDz0Z9BZmCk67CIiEqk2ia4REQllZiajnX7/kJ6ZjYCXmiGZVtCcSvmIYwMDTCgU0v8euQfAICDtTniElI0+20JO8MEtwh3j/0KIG8EW+r960i6fRHWnhyWRUQ1Q7VNcLt1e/Zci5Ik4fDhw1UQDRFVF7kqFa7ejoWFqTHq/zfEYN6a3bh48z4A4I/zEcjOzRubn5Obi53Hzmv2fTK5lckkOFibV2HkNYuRmQ3SH94FhBoAYGha/sV2iIiqSrVNcNVqdYGbGlQqFW7fvo27d+/Cy8sLderU0VF0NVdaZhZiHyWjnqM1jAyq7a+farE2bdogNjYWTk5O+Oeff7S2qVRqvLdiiyaZnTq4G/p2aI7Ie/FQ/3e/bH5yCwASJJgojZCVm/vfgifAyy8+hz/+jYSLnSXeHMRFC4ri9dIUXN+5GJlJD1Dn+YEwc/LUdUhERCVWbTOc4hZg2LVrF1599VUsXry46gKqpopLBp52Izoe73zzG9IysuBia4ml04bBysykiiIlKpnY2FhER0cXuu3a3VhNcgsAvxw+hb4dmqNzS2/s+/sSAKCOnSWea+KOg6euoL6jDSYP6II1e/9E7ONkDO7qi5ee98GYl9pXxanUaEprJzQP+lzXYRARlUm1TXCL06dPH4waNQrTpk1DeHi4rsPRqeKSAQC48+AxNhz4GzJJQlZOLjIy8yZrj3mUhMP/XMWgLhxTRzXHkx/IZJIEazMTHDh5Gc0966KZRx1kZOega6uGsDBV4o0BXTR1508aUPXBVnOl+XBMRFTT1MgEFwA8PT2xfPlyXYdRranUavzfii1ISEkHACiN/vfrFgBMjRU6ioyobFzsrPDuiBex8cBJWFuYIDdXhUU/HwAAtPfxwJzx/XQcYc3xrA/HREQ1WY1McHNzc7Fp0ybY2dnpOpRqLT0zG4+S0/73OCsHzT3rIPJePDo298KLbbiuPNU8/s81hf9zTZGQko6hH3+nKf/z4k1k5+ZybDkREVWvBPfo0aNo3Lgx7O3tMW7cuELrJCYm4q+//kJsbCzH4D6DmbECLb3r4VzEXQDAc43d8OmrgboNiqictv9xDj8dOAkrM2NYmCiRmpEFAHCysYBhIct5ExFR7VOtEtyuXbtiw4YNGDFiBI4cOVJgFgVJkmBtbY2OHTtiwoQJ6Nmzp44irRkkScKnE/sj7Ox1SJIEv1bexdbPyMpBRlY2bCxM8eeFG9j1579wsrXE+IAOHM5A1cK9uAR8szUMAJCcloG6DtZo1aA+DOQyjO71PJeTJSIiANUswRVCQPw31U9UVJRug9ETRoYG6Plck0K3xSUk4+/LUXB1skFmdg7mhOxGdk4u2jV2w8mrtyGEgEySkJGZjfdH9ariyIkKSsnI1PxfLQSysnPwUdBLOoyodshKeQR1diaUNi78EEFENUK1SnCp6sQlpODVzzcg7b9ZFWwtTJGTkwsA+PtKlKaeWgjcjHmoixCJCmhQzxFtGrnin6u3IUlAUO8XSrxv+Lnr+HHXcZgojfD2sB5oUM+xEiPVHzGn9+LG3rwbeh2adYN3v7cLTXLVuTlIf3gHSksHGBgXXEBDlZ2JxFtnYWRmA1MnD9w9tgnp8VGwb9IZBiYWuB22HnIjY3j0fBUmdvUq/byISL9VuwSXvQOVJzE1Hcu2hCI6PhEeLnaa5BYA0rOyAQn5K3PC0lSJpLS83jL/InqAiaqaXCbDpxMDcTMmHhYmxs9cieyvSzdxKSoGjes7YcH6vVCpBSRJwidr92DdR2OrKOqa7XboGs3/4y4cQb2Ow2FsWwdCqPE44hRU2RmwrO+Diz99iIxH0ZAZKtFs1HyY12mIxFvnkPE4BlYeLXFl0zykx98GAFi6t0JS1DlAAI+u/glJbgihygUkCVc2z4Pv698VHgwRUQlVuwR31KhRGDVqVInqSpKE3NzcSo5IfyzfEopj5yOhFgI3ouM15ZIk4fmmHjgXcRdJaRkY2tUXAzq3wskrUXC0sUArb/amUNVxcnLS+vdpMpkErzoOmsf34hNw90ECmrq74FzEXXz/+x8wVhiia6uGWL3nT8gkSbPKGZA3FCrxv6nz6NnkChPkZqUB/11DmZESAHBj37eIPb0bAKCwcEBWchwAQJ2bhei/t8GiXlPc3P9t3j4KE6iz/nfNU+5e0rQHAEKV899/BDITH1T6ORGR/qt2CW6PHj3QoEEDXYehN6JiHmHdvhOAJOHug8dab/SD/FrjXnwCXJ1sENTrBRgayKEWAnKZDADQq11TAEB2Ti7iE1PhaGOOrJxc7P0rb8Wo3s83hamSN59RxXrWogPH/o3EL4dPwcbCFJ2be+OLXw5ApRawNDNGanoWVP8t873x0ClNcisBqOtgjbtxCQCAkT2fq4Izqd6e9UEiX8PA93Bt+yKosjPg0rYvYk7tgsLSHnHnD2rq5Ce3eSQYKM0Qd+GIpiQvuf3vKyJJBoW1EzLi7+TVNjCCmZMnUu5dAQA4+wZUyPkRUe1W7RLcoKAgjBw5Utdh1BjFvUmpVGr838otSErNAACYGhtptjnbWuKVXu0KJKhySYIQAnfiEmAoz0t0p3+9CY9T0uFiawkzEyUi7uX1sISfvY6vpw3jsBKqUMWtsBWXkIx5a3ZD/d8NkJdu3odanfehLf95DuT10uaqVHn1ZBLUaoHXAv1gYaKEsdIIro42VXpO1dGzPkiocjJx7/hmZCXHo2Hge1BaO+H0ilehyskChBoGJpZQq3IBCEhyI9j7+OHRlWMwdfRAfb9RuB22DqkxkYBQA5Dg1n0sHl7+A0YWtvD0fx0Zj6KRFh8FG6+2UFjaI/HmWcgMFbB0bV4l509E+q3aJbhUOsW9SaVnZWtWMQOAlPQsfD1tGBJS0tHCq64muU1IScOckN24ER0Pv5bekMtl2HPiIgCgsasTEtPyEof7j5KAR0ma9q7eiUVaZhbMjJWVcWpUSxW3wlZcQqrmWwi1EMjOVUH670MZADTzqIMLN/P2fcW/HeytzHHpVgyea+yG5xq7VUn8+uLGvm8R9+8hABLiL4XDs9dkqLL/9yFCbmQCK7cWUGWlo17HYbCo1wTo8xaykh8i9sw+mNjVh3ObAGQmxMKplT9sG76Aui8M0uyvsLCDlXsLzWMbb/aqE1HFYYJbwxXX22VmrIBvQ1ecvpZ3Y8cLPh5o7OoMAHiYlIpNR07D0ECO2EdJuHI7Bmq1wP6Tl7XauHonFhL+10NrZWaM5PS8m8+cbCxgouAQBao6Deo7wNPFDjfu583sMbSbL+4/TELEvTj08G2EIV19ceN+PBRGhppe2hfbat8kmZyWgT8v3oStpSnaNHSttd9AFPe3A0DekAEhAAgIlRqSXA6ZgQJqVQ4g1LD2bA2v3m9o7aPKzsD51dORnZYICDUcmndH0+Gzq+R8iIiexAS3hiuut0uSJMyd0BfH/o2ESq3G1agHmLLkZ3Tw8cTevy/iweMUCOTNmID/Dc3937hFCTA1VsDV0QZXb8eiTSM3vB7ohx3HzkGIvORCJqudyQHphpGBAb56axjOXLsDK3MTNHFzLlCnuOm/0jOz8caXG/EgIQUAMOal9nj5xdrZc1jc3w4AsG3UHveObwKkvDG1Nl5tYDpmER6cPwiFpQNc2vbVqq9W5SAt7jayUx9ryh5HnKq0+ImIilOtEly1Wq3rEPSOkYEBurVuhPX7/sLvf56HEMC1O9p3KSemZsBEYYT0rGzUd7TB0G6+CNnzJ4wMDPDO8B5o4aU9i8IbA7pU3QkQPUVpZIj2zTxLtc/lqPu4dCsGSkNDTXILAPv/vlRrE9xnce3yCkzsXZGVFAf7pn7ITIhBwo0zsPFqA4WVEy5t/Bi5mamo12kEHl09jviLYTAyt4XcyDhvnC5E3rAFIiIdqFYJLlWe6IeJkCBB/NdVa26sQFpmNgQAH3cXzJvYD/EJqahjbwVDAzn8n2uq24CJSiAxNR0KQ0MYKwyRnZuLxJR02Fma49Kt+1iz908YGRqgUwtvLPn1EIC8+/hl/43ZlSQJHi52uj2BakySZHDw6QIASIm+ivNr3s3bIASMLOyRnfIIEGpc3bLgvxvJgOzUBFjUbwoTu3owNLZAnSfG3BIRVSUmuLVEz+eaIPTMNQCAidII8yb2x9+Xb8HQQI6BnVvBVKmAqTPH01LNIITAkk2HsPevSzA0kOO1/p2xfv9fSEzNgIezHe4/SkJWTg4kSLgcFaOZSUGSJHRq4Y2MrGzYW5lhXEBHXZ9KtaXOzUb0X9uQlfy/ObMh8qb5yklN0CS1mn/zHkBuoIBX78lVGisR0dOY4Oq5sxF3sXJbGAAJ743oCQMDGXzc68DOygxN3V10HR5Rmdy4H6+ZjzknV4Ufdh1DVnbeoi9PLi0tIJCRlZ2Xl0l5My90buGNzi29dRJ3TXJj/yo8OLs/78JJkia5hVDDyqsNEiJOAgAs6jeFzECBxJtnYKA0g2uXV3QcORERE1y9lpOrQvCPO5GZnbdK0DfbwvDbJ5M0CzkQ1VSGcrnm/5KUN+zgSfUdbXDnQd7NTgHPN0N9JxtcvHkfvo1c0amFV5XGWlMl37kIQOQltgKo234IstMSYe7SEE6teyE1JgK5mWmwdG0GSSZHTnoSDJSmkMkNdR06ERETXH2WnZOLjKwczePUjCzk5qohNyqY4KpUamw9eha3Yx+hS6uGaNPItSpDJSoVVydbvPzic/j58CmYKRWYNrQ7Nhz4G7diHqK9jyf+b6Q/zkfeg5GhHK0b1IckSRjQuZWuw65RbLyfQ/Sje4Akg9zIGM5t+0JuYAQDY3Ooc3PyElqFKWTyvLcRI1Mr3QZMRPQEJrh6zNRYgd7P+2DvX3mLNvTv2AIKo//9yjcc+Bu/HDoFa3MTtG5QH3v+ugiZJOHAqctY8fZIeNV10FXoVIs9awnZCzeise2Pc7A2N8EvsyfCysxYM7ZWrRaaqete8PGospj1kVu3MTC2q4espHiYOXng7PdTkJueDGuvtsjNSEFK9FUAQP3OL6N+Z64+SUTVCxNcPTd9aHe89LwPJEl7ftCb9+Oxdu8JAMCDhBSEnc27AS1/lajrdx8wwSWdKG51vsfJafjg263IUakhAXjwOBmfTOyv2c55mUvuWR8kJJkcTi17AgAu/RyM3Iy86dUSIrXntr1/cgcTXCKqdpjg1nDPfJOSJHjUyZsKKTM7B5+s3YNzEXfhWcdeU0cIASNDA6Rn5UAmSTCQy9Dcq27lB09USvcfJiI7VwUgb22SyHtxug2oBivug0S+5LuXkZUUByHUyJtk7b8VYf672QySDApLfhAmouqHCW4N96w3qd+P/4tvtoYCkPBCUw+cunobQghcuR2ruRHHQC7DW0O6QUDC7dhH6ODjibr21lVzAkSl4FnHAY42FnjwOBkA0N23kY4j0l/RJ3fg1oHvAACG5rYwNLVETmoC7Bp3gn2zLrj7xy8wMDaHZ6/XdRwpEVFBTHD1WGZ2DpZvDYVanbee/PGLkf8t9pD3Ve4LTd3xyYT+MDVWwMJUCQDo1Jx3mFP1ZawwxDfTR+Do+euwMjdFx1KuaEYlF3tmr+b/OSmP0HjYbFi5NYfcMG++bNsGz+sqNCKiZ2KCq8f+G06rIUGClbkJHienwcbcFP06toCDtYVugiMqI0szY/Tt0ELXYeg9E7t6yHgU/d9QBAnGNs6a5JaIqLpjgqvHjBWGeD3QDyu3h0MC8OagbnixbWPEPE6Gs40FjAz566ea515cAvb+fRHW5qbo17E5jAz4PK4MXi9NgcxQiaykOLi07QcTW47LJ6Kag+8Mei6wU0v0atcUEiTNFGGujjY6joqobFLSMzF16S9Iy8yGUAvcjI7H/73sr+uw9JKhiSUa9n9H12EQEZVJrVrSasGCBWjbti3Mzc3h4OCAwMBAXLt2TddhVTqlkaHW/LdENVVUzCOkpGdBrRYQAM5cv6PrkIiIqBqqVQlueHg4Jk+ejL/++gsHDx5ETk4OevbsibS0NF2HRkQl4OZsCzNjBWQyCRKAVg3q6zokIiKqhiQhnr4VqfaIj4+Hg4MDwsPD0blz5xLtc+bMGfj6+uL06dNo3bp1JUdIRE+7G/cYe/+6BGtzE/Tv2IJjyYmIqIBa/c6QlJQEALCxKXpMalZWFrKysjSPU1NTKz0uIipaPQcbvNqvk67DICKiaqxWDVF4klqtxrRp09ChQwf4+PgUWW/BggWwtLTU/Pj5+VVhlERERERUWrU2wZ08eTIuXryIX375pdh6M2bMQFJSkuYnPDy8iiIkIiIiorKolUMUpkyZgl27duHo0aOoW7f4uR0VCgUUiv9Nbm5mZlbZ4VWKmJgYxMTE6DoMvefs7AxnZ2ddh1Er8DldNficJqKaqFYluEIIvPnmm9i2bRvCwsLg7u5e6jacnZ0RHBxco/7gZ2VlYcSIEex9rgJ+fn7Yv3+/1ociqnh8TlcdPqeJqCaqVbMovPHGG9i4cSN27NiBhg0basotLS1hbGysw8gqV3JyMiwtLREeHl5je6BrgtTUVPj5+SEpKQkWFlwCuTLxOV01+JwmopqqViW4kiQVWh4SEoIxY8ZUbTBVKD8Z4JtU5eJ1rjq81lWD15mIaqpaN0SBiIiIiPRbrZ1FgYiIiIj0ExPcWkChUCA4OJg3iVQyXueqw2tdNXidiaimqlVjcImIiIhI/7EHl4iIiIj0ChNcIiIiItIrTHCJiIiISK8wwa3hZs+eXeT8vrqI4+HDh7oOpcKNGTMGbm5uug4DY8aM4aIGREREJcAEtxw2bdoESZKwbdu2AttatGgBSZIQGhpaYFv9+vXRvn37YtseM2YMJEnS/FhYWKBFixb48ssvkZWVVWHnUJOsWbNGcz2OHTtWYLsQAvXq1YMkSejTp88z2+vSpYvWNbaxsUHbtm2xevVqqNXqyjgFvVOVrwEzMzN4eHhg8ODB2LJlS638HVXma0Amk8HCwgINGzbEK6+8goMHD1bGKRARVQkmuOXQsWNHACjwRpOcnIyLFy/CwMAAx48f19p29+5d3L17V7NvcRQKBdavX4/169dj/vz5sLGxwbvvvougoKCKO4kaSKlUYuPGjQXKw8PDce/evVJNaVS3bl3NNZ41axZyc3Mxfvx4fPjhhxUZst6qytfAkiVLMHLkSERERGDw4MHo3r07kpOTK+5kapDKeA2sW7cOixYtQr9+/fDnn3+iZ8+eGDZsGHJycioydCKiKlGrVjKraC4uLnB3dy/w5n7ixAkIITBkyJAC2/Ifl+TN3cDAAKNGjdI8fuONN9CuXTv8+uuvWLx4MVxcXCrgLGqel156CZs3b8bXX38NA4P/PYU3btwIX1/fUg2TsLS01LrGkyZNQsOGDbF8+XLMmzcPhoaGFRq7vqnq1wAAfPLJJ1i4cCFmzJiBiRMn4tdffy1yfyEEMjMzYWxsXNJTqhEq8zUAAAsXLsTUqVOxYsUKuLm54bPPPityf7VajezsbCiVytKfCBFRJWEPbjl17NgRZ8+eRUZGhqbs+PHjaNq0KXr37o2//vpL66vU48ePQ5IkdOjQodTHkslk6NKlCwAgKiqqyHohISHo1q0bHBwcoFAo0KRJE6xcubLQunv37oWfnx/Mzc1hYWGBtm3bFugZ+vvvv9GrVy9YWlrCxMQEfn5+BXrl8j18+BBDhw6FhYUFbG1t8dZbbyEzM1OrTm5uLubNmwdPT08oFAq4ubnhww8/LPHQixEjRuDRo0daX6FmZ2fjt99+w8iRI0vURlFMTEzw/PPPIy0tDfHx8UXW++KLL9C+fXvY2trC2NgYvr6++O233wqtu2HDBjz33HMwMTGBtbU1OnfujAMHDmjV2bt3Lzp16gRTU1OYm5sjICAAly5dKrS9mzdvwt/fH6ampnBxccHcuXMLLEOdlpaGd955B/Xq1YNCoUDDhg3xxRdfVMpy1VX5Gsj3wQcfoGfPnti8eTOuX7+uKXdzc0OfPn2wf/9+tGnTBsbGxli1ahWioqIgSRLWrFlToC1JkjB79mytsrCwMLRp0wZKpRKenp5YtWpVtRnvDlTuawAA5HI5vv76azRp0gTLly9HUlKSZpskSZgyZQp++uknNG3aFAqFAvv27UNYWBgkSUJYWJhWW0Vd+82bN6NJkyZQKpXw8fHBtm3bqs14dyKq+ZjgllPHjh2Rk5ODv//+W1N2/PhxtG/fHu3bt0dSUhIuXryota1Ro0awtbUt0/Fu3LgBAMXuv3LlSri6uuLDDz/El19+iXr16uGNN97AN998o1VvzZo1CAgIwOPHjzFjxgwsXLgQLVu2xL59+zR1jhw5gs6dOyM5ORnBwcGYP38+EhMT0a1bN5w8ebLAsYcOHYrMzEwsWLAAL730Er7++mu8+uqrWnUmTJiAjz/+GK1bt8aSJUvg5+eHBQsWYPjw4SW6Bm5ubnjhhRfw888/a8r27t2LpKSkErdRnJs3b0Iul8PKyqrIOkuXLkWrVq0wd+5czJ8/HwYGBhgyZAh2796tVW/OnDl45ZVXYGhoiLlz52LOnDmoV68ejhw5oqmzfv16BAQEwMzMDJ999hlmzZqFy5cvo2PHjgU+yKhUKvTq1QuOjo74/PPP4evri+DgYAQHB2vqCCHQr18/LFmyBL169cLixYvRsGFDvPfee3j77bfLfX2eVtWvgXyvvPIKhBAFxopeu3YNI0aMwIsvvoilS5eiZcuWpWr37Nmz6NWrFx49eoQ5c+Zg/PjxmDt3LrZv316ueCtSZb8GgLwkd8SIEUhPTy/QC3/kyBFMnz4dw4YNw9KlS0udlO7evRvDhg2DoaEhFixYgIEDB2L8+PE4ffp0hcRORARB5XLp0iUBQMybN08IIUROTo4wNTUVa9euFUII4ejoKL755hshhBDJyclCLpeLiRMnPrPdoKAgYWpqKuLj40V8fLyIjIwU8+fPF5IkiebNm2vqBQcHi6d/jenp6QXa8/f3Fx4eHprHiYmJwtzcXLRr105kZGRo1VWr1Zp/vb29hb+/v6Ysv313d3fx4osvFoijX79+Wm298cYbAoA4f/68EEKIc+fOCQBiwoQJWvXeffddAUAcOXKkyGsSEhIiAIhTp06J5cuXC3Nzc825DhkyRHTt2lUIIYSrq6sICAgosp18fn5+olGjRpprfOXKFTF16lQBQPTt21dTLygoSLi6umrt+/Q1zs7OFj4+PqJbt26asoiICCGTycSAAQOESqXSqp9/PVNSUoSVlVWB50RsbKywtLTUKg8KChIAxJtvvqnVTkBAgDAyMhLx8fFCCCG2b98uAIhPPvlEq83BgwcLSZJEZGTkM69NaVT2a6AoZ8+eFQDE9OnTNWWurq4CgNi3b59W3Vu3bgkAIiQkpEA7AERwcLDmcd++fYWJiYmIjo7WlEVERAgDA4MCr7WqVhmvgaZNmxa5fdu2bQKAWLp0qaYMgJDJZOLSpUtadUNDQwUAERoaqlVe2LVv1qyZqFu3rkhJSdGUhYWFCQAFXmtERGXBHtxyaty4MWxtbTU9HOfPn0daWprmDvH27dtrvs4/ceIEVCpVicYeAnlfM9vb28Pe3h5eXl748MMP8cILLxR6x/qTnhxvmJSUhIcPH8LPzw83b97UfNV48OBBpKSk4IMPPigwdi7/a9hz584hIiICI0eOxKNHj/Dw4UM8fPgQaWlp6N69O44ePVrgTvbJkydrPX7zzTcBAHv27NH69+mexHfeeQcACvSAFmXo0KHIyMjArl27kJKSgl27dpXpq9mrV69qrnHjxo2xbNkyBAQEYPXq1cXu9+Q1TkhIQFJSEjp16oQzZ85oyrdv3w61Wo2PP/4YMpn2Sy3/Gh88eBCJiYkYMWKE5vo+fPgQcrkc7dq1K3QGgilTpmi1M2XKFGRnZ+PQoUMA8q6xXC7H1KlTtfZ75513IITA3r17S3h1SqYyXwPFyZ8yLSUlRavc3d0d/v7+ZWpTpVLh0KFDCAwM1Brj7uXlhd69e5c92EpQUa+B4hR1jf38/NCkSZMytXn//n1cuHABo0eP1pr2zs/PD82aNSt7sERET+BNZuUkSRLat2+vSfaOHz8OBwcHeHl5Ach7c1++fDkAaN7kS/rmrlQq8fvvvwPIu5vc3d0ddevWfeZ+x48fR3BwME6cOIH09HStbUlJSbC0tNQMdfDx8SmynYiICAAodtaGpKQkWFtbax57e3trbff09IRMJtN81X779m3IZDLN9cnn5OQEKysr3L59+5nnBwD29vbo0aMHNm7ciPT0dKhUKgwePLhE+z7Jzc0N33//PSRJglKphLe3NxwcHJ65365du/DJJ5/g3LlzWmOHnxyjeePGDchksmITgfxr3K1bt0K3W1hYaD2WyWTw8PDQKmvQoAEAaF1jFxcXmJuba9Vr3LixZntFqszXQHFSU1MBoMB5uru7l7nNuLg4ZGRkFHh+Aii0TJcq6jVQnMq4xvnPv6Ku8ZMfEomIyooJbgXo2LEjfv/9d1y4cEEz9jBf+/bt8d577yE6OhrHjh2Di4tLgQSlKHK5HD169ChVLDdu3ED37t3RqFEjLF68GPXq1YORkRH27NmDJUuWlGru0Py6ixYtKnIc47MWHijqppyKuFln5MiRmDhxImJjY9G7d+9ix8wWxdTUtNTX+I8//kC/fv3QuXNnrFixAs7OzjA0NERISEihUzcVJ/8ar1+/Hk5OTgW2P3mHfHVWWa+B4uSP6306USpsxoSinm8qlarccehSRbwGisNrTEQ1Vc1496zmnpwL9Pjx45g2bZpmm6+vLxQKBcLCwvD333/jpZdeqtRYfv/9d2RlZWHnzp2oX7++pvzpr7o9PT0B5L2BFdUzlV/HwsKixElgRESEVu9OZGQk1Gq15iYUV1dXqNVqREREaHoUAeDBgwdITEyEq6triY4DAAMGDMCkSZPw119/FTtVVEXbsmULlEol9u/frzXfaEhIiFY9T09PqNVqXL58ucgPCPnX2MHBoUTXWK1W4+bNm5peWwCaWQSevMaHDh1CSkqKVs/b1atXNdsrmi5eA+vXr4ckSXjxxRefWTf/W4bExESt8qd7sx0cHKBUKhEZGVmgjcLKdK0yXwMqlQobN26EiYlJiXrcS3qN859/NeUaE1HNxDG4FSB/OqGffvoJ0dHRWr1XCoUCrVu3xjfffIO0tLQK+Wq2OHK5HAC0poNKSkoqkHz17NkT5ubmWLBgQYFpvPL39fX1haenJ7744gvNV5VPKmwaradnali2bBkAaMYv5ic3X331lVa9xYsXAwACAgKKP8EnmJmZYeXKlZg9ezb69u1b4v3KSy6XQ5IkrZ6pqKioAnfZBwYGQiaTYe7cuQV6zvOvsb+/PywsLDB//vxCJ9Qv7Brnf92f387y5cthaGiI7t27A8i7xiqVSqseACxZsgSSJFXKWNKqfg0sXLgQBw4cwLBhwwoMiymMhYUF7OzscPToUa3yFStWaD3O/9Zk+/btuH//vqY8MjKywscuV4TKeg2oVCpMnToVV65cwdSpUwsMlSmMq6sr5HL5M6+xi4sLfHx8sG7dOq2/K+Hh4bhw4ULFnAAR1Xrswa0ARkZGaNu2Lf744w8oFAr4+vpqbW/fvj2+/PJLABUz9rA4PXv2hJGREfr27YtJkyYhNTUV33//PRwcHBATE6OpZ2FhgSVLlmDChAlo27YtRo4cCWtra5w/fx7p6elYu3YtZDIZfvjhB/Tu3RtNmzbF2LFjUadOHURHRyM0NBQWFhaaMcL5bt26hX79+qFXr144ceIENmzYgJEjR6JFixYA8pZvDQoKwnfffYfExET4+fnh5MmTWLt2LQIDA9G1a9dSna8uVnULCAjA4sWL0atXL4wcORJxcXH45ptv4OXlhX///VdTz8vLCzNnzsS8efPQqVMnDBw4EAqFAqdOnYKLiwsWLFgACwsLrFy5Eq+88gpat26N4cOHw97eHnfu3MHu3bvRoUMHrURVqVRi3759CAoKQrt27bB3717s3r0bH374Iezt7QEAffv2RdeuXTFz5kxERUWhRYsWOHDgAHbs2IFp06Zpeo0rUmW9BnJzc7FhwwYAQGZmJm7fvo2dO3fi33//RdeuXfHdd9+VuK0JEyZg4cKFmDBhAtq0aYOjR49qzaGbb/bs2Thw4AA6dOiA119/XfNhwcfHB+fOnSvx8apKeV8DSUlJmmucnp6OyMhIbN26FTdu3MDw4cMxb968ErVjaWmJIUOGYNmyZZAkCZ6enti1axfi4uIK1J0/fz769++PDh06YOzYsUhISNBc48I+TBMRlZpO53DQIzNmzBAARPv27Qts27p1qwAgzM3NRW5ubonae9YUSfkKmyZs586donnz5kKpVAo3Nzfx2WefidWrVwsA4tatWwXqtm/fXhgbGwsLCwvx3HPPiZ9//lmrztmzZ8XAgQOFra2tUCgUwtXVVQwdOlQcPny4QByXL18WgwcPFubm5sLa2lpMmTKlwDRkOTk5Ys6cOcLd3V0YGhqKevXqiRkzZojMzMxiz/XJKZKKU1FTJOUrbJqwH3/8UXh7ewuFQiEaNWokQkJCCv1dCCHE6tWrRatWrYRCoRDW1tbCz89PHDx4UKtOaGio8Pf3F5aWlkKpVApPT08xZswY8c8//2jFYWpqKm7cuCF69uwpTExMhKOjowgODi4wDVlKSoqYPn26cHFxEYaGhsLb21ssWrRIa7q3ilYZrwEAmh8TExPh5uYmBg0aJH777bcC5yxE8b/79PR0MX78eGFpaSnMzc3F0KFDRVxcXIFpwoQQ4vDhw6JVq1bCyMhIeHp6ih9++EG88847QqlUlij2ylIZr4Enr7GZmZnw9vYWo0aNEgcOHCh0HwBi8uTJhW6Lj48XgwYNEiYmJsLa2lpMmjRJXLx4sdAp2n755RfRqFEjoVAohI+Pj9i5c6cYNGiQaNSo0TPjJiJ6FkmISljaiIhIzwQGBuLSpUuamS+o4rVs2RL29vYFFu8gIiotjsElInrKk8sOA3k3T+7Zs0ezVDaVT05ODnJzc7XKwsLCcP78eV5jIqoQ7MElInqKs7MzxowZAw8PD9y+fRsrV65EVlYWzp49W6Kb2qh4UVFR6NGjB0aNGgUXFxdcvXoV3377LSwtLXHx4sVyL+NMRMSbzIiIntKrVy/8/PPPiI2NhUKhwAsvvID58+czua0g1tbW8PX1xQ8//ID4+HiYmpoiICAACxcuZHJLRBWCPbhEREREpFc4BpeIiIiI9AoTXCIiIiLSK0xwdWTNmjWQJAlKpRLR0dEFtnfp0gU+Pj5VGtPhw4cxbtw4NGjQACYmJvDw8MCECRO0Foh40p9//omOHTvCxMQETk5OmDp1arWbpJ3XuerwWlcNXmciomdjgqtjWVlZWLhwoa7DAAC8//77CAsLw4ABA/D1119j+PDh2LRpE1q1aoXY2FituufOnUP37t2Rnp6OxYsXY8KECfjuu+8wZMgQHUVfPF7nqsNrXTV4nYmIiqHLVSZqs/wViVq2bCkUCoWIjo7W2l7SVbYqUnh4eIHVocLDwwUAMXPmTK3y3r17C2dnZ5GUlKQp+/777wUAsX///iqJtyR4nasOr3XV4HUmIno29uDq2IcffgiVSlUtemI6d+4MmUxWoMzGxgZXrlzRlCUnJ+PgwYMYNWoULCwsNOWjR4+GmZkZNm3aVGUxlxSvc9Xhta4avM5EREXjPLg65u7ujtGjR+P777/HBx98ABcXl1Ltn56ejvT09GfWk8vlsLa2LnV8qampSE1NhZ2dnabswoULyM3NRZs2bbTqGhkZoWXLljh79mypj1PZeJ2rDq911eB1JiIqGntwq4GZM2ciNzcXn332Wan3/fzzz2Fvb//Mn1atWpUptq+++grZ2dkYNmyYpiz/xhFnZ+cC9Z2dnXH//v0yHauy8TpXHV7rqsHrTERUOPbgVgMeHh545ZVX8N133+GDDz4o9I9/UUaPHo2OHTs+s56xsXGp4zp69CjmzJmDoUOHolu3bpryjIwMAIBCoSiwj1Kp1Gyvbnidqw6vddXgdSYiKhwT3Grio48+wvr167Fw4UIsXbq0xPt5eHjAw8OjwuO5evUqBgwYAB8fH/zwww9a2/Lf8LKysgrsl5mZWaY3xKrC61x1eK2rBq8zEVFBTHCrCQ8PD4waNUrTE1NS+ePcnkUul8Pe3r5Ebd69exc9e/aEpaUl9uzZA3Nzc63t+b1Ehc1xGRMTU+qxgFWJ17nq8FpXDV5nIqKCOAa3lGJiYjB79uwiJzAvj48++qjU4+m++OILODs7P/Onbdu2JWrv0aNH6NmzJ7KysrB///5Cv/L08fGBgYEB/vnnH63y7OxsnDt3Di1btixx/LrA61x1eK2rBq8zkf6qzLxDn7EHt5RiYmIwZ84c9OvXr1Tj3UrC09MTo0aNwqpVq+Dq6goDg2f/eipyHF1aWhpeeuklREdHIzQ0FN7e3oXWs7S0RI8ePbBhwwbMmjVL00uzfv16pKamVvsJ23mdqw6vddXgdSbSX5WZd+gzJrjVzMyZM7F+/Xpcu3YNTZs2fWb9ihxH9/LLL+PkyZMYN24crly5ojV/pZmZGQIDAzWPP/30U7Rv3x5+fn549dVXce/ePXz55Zfo2bMnevXqVSHxVCZe56rDa101eJ2JiJ6g65UmaprTp08LAOL06dPlaid/NaJTp04V2BYUFCQAVPlqRK6urgJAoT+urq4F6v/xxx+iffv2QqlUCnt7ezF58mSRnJxcpTE/C69z1eG1rhq8zkS1S0XlHbWNJIQQlZ1E65MzZ87A19cXp0+fRuvWrXUdDhEREekx5h1lw5vMiIiIiEivMMElqkBZWVklWv6UiIiIKg8TXKIKpFKpcPXqVV2HQUREVKtxFgWiCtKmTRvExMTA0NAQv//+O3x8fCBJkq7DIiIiqnWY4BJVkNjYWNy/fx9WVlY4ceIErl+/jqZNm8Ld3R0KhULX4REREdUaTHCJKkBERASSk5MBABkZGXjw4AEA4OjRozh27BgcHR3h7OwMBwcH2NnZwcTERJfhEhER6TUmuETlFBISggkTJkCtVgPIu9EsODgYo0ePRvv27aFWqxETE6O1zKKxsTHs7Oxga2sLGxsbWFlZwdLSEoaGhro6DSIiIr3BBJeoHCIiIrSS23xCCKxbtw5eXl5wcHAosF9GRgbu3r2Lu3fvapUrlUqYm5vDwsICNjY2qFu3Luzt7Sv1HIiIiPQNE1yicli9enWRN5JJkoTjx49jwIABJW4vMzMTmZmZiI+Px40bN3Dq1CnUqVMHDRo0gJubG3t4iYiISoDThBGVQ1RUFIpaDFAIgUePHpX7GCkpKYiJiUFKSkq52yIiIqoN2INLVA5ubm7F9uDa2tqWqj2FQgEbGxvY2dnB3t4ezs7OMDU1rYhQiYiIag0muETlMG7cOHz++eeFbhNCoEOHDkXuq1Qq4eDgAHt7e9jb28PW1hYmJiacO5eIiKicmOASlYO3tzd+/PFHjB8/XutGM0mSMHr0aM0NZqamprCzs9P0ztra2sLc3JzJLBERUSVggktUTmPGjEHHjh3RunVrpKSkQKFQ4KOPPoKvry88PDxQt25dDjMgIiKqQkxwiSqAl5cXGjRooFmqNygoCPXq1dN1WERERNXSv//+i2XLluHMmTNISkoqMN2mJEm4ceNGmdtngktUQf755x+kp6fj2rVrTG6JiIiKEBYWhl69esHa2hpt2rTB2bNn0a1bN2RmZuLEiRNo2rQpfH19y3WMGjtN2IIFC9C2bVuYm5vDwcEBgYGBuHbtWrH7rFmzBpIkaf0olcoqiphqA0mS0LhxY12HQUREtVRNyI8+/vhjeHh44Nq1awgJCQEAfPjhhzh27Bj+/PNP3Lt3D0OHDi3XMWpsghseHo7Jkyfjr7/+wsGDB5GTk4OePXsiLS2t2P0sLCw0y6bGxMTg9u3bVRQx1QbGxsb80ERERDpTE/KjM2fOYPz48bCwsIBcLgcAqFQqAEC7du0wadIkzJo1q1zHqLFDFPbt26f1eM2aNXBwcMDp06fRuXPnIveTJAlOTk6VHR4RERFRlasJ+ZGBgQHMzc0BAFZWVjA0NERcXJxmu4eHBy5fvlyuY9TYHtynJSUlAQBsbGyKrZeamgpXV1fUq1cP/fv3x6VLl4qtn5WVheTkZM1PampqhcVMREREVBKpqala+UhWVlaJ9qus/Kg8vLy8EBERASAvsW7UqBG2bdum2b579+5yJ9t6keCq1WpMmzYNHTp0gI+PT5H1GjZsiNWrV2PHjh3YsGED1Go12rdvj3v37hW5z4IFC2Bpaan58fPzq4xTICIiIiqSn5+fVj6yYMGCZ+5TmflRebz00kv4+eefkZubCwB4++23sXXrVnh7e8Pb2xs7d+7EpEmTynUMSQghKiJYXXr99dexd+9eHDt2DHXr1i3xfjk5OWjcuDFGjBiBefPmFVonKytL61PSuXPn4Ofnh9OnT6N169bljp2IiIioKGfOnIGvry/Cw8PRsmVLTblCoYBCoSh238rMj8ojJycHycnJsLGx0Sx4tGHDBmzZsgVyuRx9+vTBmDFjynWMEo3BTU5OhqmpqWYgcHUyZcoU7Nq1C0ePHi3VLw8ADA0N0apVK0RGRhZZ5+knkJmZWZljJSIiIioLMzMzWFhYlLh+ZedH5WFoaAhbW1utslGjRmHUqFEVdowSDVGwtrbGr7/+qnk8btw4/P333xUWRFkIITBlyhRs27YNR44cgbu7e6nbUKlUuHDhApydnSshQiIiIqKqVRPyIw8PD+zcubPI7bt27YKHh0e5jlGiBNfIyEjra/o1a9aUa3WJijB58mRs2LABGzduhLm5OWJjYxEbG4uMjAxNndGjR2PGjBmax3PnzsWBAwdw8+ZNnDlzBqNGjcLt27cxYcIEXZwCERERUYWqCflRVFRUsTftp6amlnuashINUWjUqBF++OEHuLm5wdLSUhPcmTNnit2vMseorly5EgDQpUsXrfKQkBDNuI07d+5AJvtfDp+QkICJEyciNjYW1tbW8PX1xZ9//okmTZpUWpxEREREVaWm5Ef5Y28Lc+rUKVhZWZWv/ZLcZLZv3z4MGzasxFNkCSEgSZJm0l59kj/YmzeZERERUWXTl7xj6dKlWLp0KQDg9u3bsLOzg6mpaYF6SUlJSExMxMiRI7F+/foyH69EPbi9evXCrVu3cOrUKTx48ABjxozBq6++ihdeeKHMByYiIiKi2sHBwQFNmzYFkDcKoE6dOqhTp45WHUmSYGpqCl9fX7zxxhvlOl6JEtx///0Xrq6u8Pf3B5DXzT1kyBB07969XAcnIiIiIv03YsQIjBgxAgDQtWtXfPTRR5WaR5boJrNWrVph9+7dlRYEEREREdUOoaGhld5JWqIeXGNjY6Snp2seh4eHY+LEiZUWFBERERHph6NHj5Zpv86dO5f5mCVKcFu0aIHFixdDLpdrZlE4deoUlEplsfsNHDiwzIERERERUc3XpUsXrVkT8icjKEpFTFZQogR36dKlGDx4MMaPHw8gbxDwk3fDFUZfZ1EgIiIiopILDQ2t8mOWKMFt06YNIiMjcePGDTx48ABdunTBzJkz0aNHj8qOj4iIiIhqMD8/vyo/ZokSXAAwMDBAw4YN0bBhQwQFBaFPnz5o165dZcZGRERERHosJiYGcXFx8PLyKnRe3LIq0SwKTwsJCWFyS0RERERlsmPHDjRq1Ah169ZF69at8ffffwMAHj58iFatWmH79u3lar9EPbhz586FJEmYOXMmZDIZ5s6d+8x9JEnCrFmzyhUcEREREemX33//HQMHDsQLL7yAkSNHYvbs2ZptdnZ2qFOnDkJCQhAYGFjmY5RoqV6ZTAZJkpCRkQEjIyOt9YuLbFhPbzLTlyXziIiIqPrTx7yjbdu2MDMzQ2hoKB49egR7e3scOnQI3bp1AwB8+umnWLVqFe7cuVPmY5RoiIJarYZKpYKRkZHm8bN+9DG5JSIiIqLyuXjxIoYOHVrkdkdHR8TFxZXrGGUag0tEREREVBYmJiZIS0srcvvNmzdha2tbrmOUeBaFp125cgU3btxASkoKzM3N4eXlhUaNGpUrGCIiIiLSb127dsXatWsxbdq0AttiY2Px/fffo0+fPuU6RqkT3FWrVuHTTz9FdHR0gW3169fHzJkzMWHChHIFRURERET66dNPP8Xzzz+Ptm3bYsiQIZAkCfv378eRI0ewatUqCCEQHBxcrmOUKsF99913sXjxYtjY2GDcuHHw8fGBmZkZUlNTceHCBWzfvh2TJk1CREQEPvvss3IFRkRERET6p2HDhjh27BjeeustzJo1C0IILFq0CEDesr7ffPMN3NzcynWMEie4J0+exOLFizFgwACsW7eu0Ml4ly5dilGjRuGLL77AkCFD0KZNm3IFR0RERET6p2nTpjh06BASEhIQGRkJtVoNDw8P2NvbV0j7JU5wf/zxRzg7O2Pjxo1QKBSF1jE1NcXPP/8MDw8P/Pjjj0xwiYiIiKhI1tbWaNu2bYW3W+IE98SJExgyZEiRyW0+pVKJIUOGIDQ0tNzBEREREVHNtm7dujLtN3r06DIfs8QJ7t27d9G4ceMS1W3SpEmZT4aIiIiI9MeYMWMKlEmSBAB4er2x/HKgihLc5ORkmJubl6iumZkZUlJSyhwUEREREemHW7duaT1OTExEUFAQLC0t8eabb6Jhw4YAgKtXr2LZsmVISUnB2rVry3XMEie4QgitrLok9YmIiIiodnN1ddV6PHv2bNjb2+PAgQNauWWzZs0waNAg9OzZE0uWLEFISEiZj1mqacK++OIL/Pzzz8+sV9gcuURERERE27dvx6efflpox6lMJsPAgQPx0UcflesYJU5w69evj8ePH+Px48clrk9ERERE9CQhBK5evVrk9suXL5d7JECJE9yoqKhyHYiIiIiIKDAwECtXroSbmxtee+01mJiYAADS09OxcuVKrFq1Ci+//HK5jlHqpXqJiIiIiMpq6dKluHXrFt59913MmDEDzs7OAICYmBjk5OSgQ4cO+Oqrr8p1DCa4RERERFRlLC0tER4ejh07dmDv3r24ffs2AKBXr1546aWX0Ldv31JNbFAYJrhERFSk3NxcGBjwrYKIKl7//v3Rv3//SmlbVimtVqFvvvkGbm5uUCqVaNeuHU6ePFls/c2bN6NRo0ZQKpVo1qwZ9uzZU0WREhHVPPHx8Xj06JGuwyCiUqrt+VGNTnB//fVXvP322wgODsaZM2fQokUL+Pv7Iy4urtD6f/75J0aMGIHx48fj7NmzCAwMRGBgIC5evFjFkRMRVX9t2rRB69at4evri5s3b3J+c6IagvkRIIka/BerXbt2aNu2LZYvXw4AUKvVqFevHt5880188MEHBeoPGzYMaWlp2LVrl6bs+eefR8uWLfHtt9+W6JhnzpyBr68vTp8+jdatW1fMiRARVTMRERHw9fVFSkoKFAoFZs6cCR8fH9SvXx92dnawsrKChYVFucfJEVHxypJ36CI/qm5q7MCq7OxsnD59GjNmzNCUyWQy9OjRAydOnCh0nxMnTuDtt9/WKvP398f27dsrM1QioholJCQEEyZMgFqtBgBkZWUhODgYo0ePRvv27TX15HI5bGxs4OTkBBcXF9ja2sLU1JRJL5EOMT/KU+YEd//+/fjxxx9x8+ZNJCQkFPjqSpIk3Lhxo9wBFuXhw4dQqVRwdHTUKnd0dCxy8uDY2NhC68fGxhZ5nKysLGRlZWkep6amAsi78SInJ6es4RMRVUsREREYP358gb/pQgisXbsW7u7ucHBwAACoVCrExsYiNjYW586dA5CX9Jqbm8PU1FTzY2JiAjMzM5ibm8PCwgIyWY0eHUdUpXJzcwHk5R/JycmacoVCAYVCUaB+VeVH1V2ZEtxFixbhgw8+gKOjI5577jk0a9asouOqNhYsWIA5c+YUKG/Xrp0OoiEi0q3Zs2frOgSiWsnPz0/rcXBwsN68HjMzM7Fp0yb4+/sXSLTLqkwJ7tKlS9GtWzfs2bMHhoaGFRJIadnZ2UEul+PBgwda5Q8ePICTk1Oh+zg5OZWqPgDMmDFDq9v+3Llz8PPzw99//41WrVqV4wyIiKqfUaNGYfPmzUXeUObr64vx48eX+zhWVlbo2bMnLCwsyt0WkT47e/Ys2rVrh/DwcLRs2VJTXljvLVB1+VFFSkpKwtixY3Hw4EHdJrgJCQkYPHiwzpJbADAyMoKvry8OHz6MwMBAAHmDqA8fPowpU6YUus8LL7yAw4cPY9q0aZqygwcP4oUXXijyOE9/BWBmZgYAMDAw0On5ExFVBg8PD8hkMqhUqgLbZDIZ7O3tIZfLS9WmoaEhrK2tYWtrC0dHRzg7O8Pc3LyiQibSa/nzUJuZmZXoA2FV5UcVraLnPChTgvvcc8/h2rVrFRpIWbz99tsICgpCmzZt8Nxzz+Grr75CWloaxo4dCwAYPXo06tSpgwULFgAA3nrrLfj5+eHLL79EQEAAfvnlF/zzzz/47rvvdHkaRETVxrhx4/D5558Xuk0IgQ4dOhS6zcDAAJaWlrC0tISFhQUsLCxgbm4OS0tL3nhGVMVqYn5U0X8jypTgrlixAr1790abNm0wcuTICg2oNIYNG4b4+Hh8/PHHiI2NRcuWLbFv3z5N9/adO3e0bmZo3749Nm7ciI8++ggffvghvL29sX37dvj4+OjqFIiIqhVvb2/8+OOPGD9+vGYWBSDvzWf06NFwcHCAjY0N7OzsYGNjA2tra1hZWcHMzIxJLFE1URPzo4ruwS3TPLjNmzfH48ePERMTAzMzM9StW7fAV1aSJOH8+fMVFmh1wXlwiag2iIyMRKdOnZCYmAgjIyN8/vnn6NKlC+rXrw9jY2Ndh0dUazDvKJsy9eDa2NjA1tYW3t7eFR0PERFVA15eXoiJiUF0dDSSkpLQpEkTXYdERFRiZUpww8LCKjgMIiKqjszMzODi4qLrMIiISoWzbRMRUZG4HC8R1UTlWqo3JycHV69eRVJSktbNCPk6d+5cnuaJiIiIiEqtTAmuWq3GjBkzsGLFCqSnpxdZr7B5FImIqOZg7y0R1URlGqIwf/58LFq0CKNGjcK6desghMDChQvx7bffonnz5mjRogX2799f0bESERERET1TmXpw16xZg6FDh2LlypV49OgRgLzlG7t164agoCC88MILOHLkCHr06FGhwRIRERGRfjh+/DjOnDlT6FBXSZIwa9asMrddpgT33r17+L//+z8A/1sLOTMzE0DeEnGjRo3C4sWLMX/+/DIHRkRERET65/HjxwgICMDJkychhIAkSZqFHvL/X94Et0xDFGxtbZGamgrgf2sj37x5U6tOQkJCmYMiIiIiIv303nvv4d9//8XGjRtx8+ZNCCGwf/9+XL9+Ha+99hpatmyJ+/fvl+sYZUpwW7VqhVOnTmked+3aFV999RWOHz+OP/74A19//TVatGhRrsCIiIiISP/s2bMHkyZNwrBhw2Bubg4AkMlk8PLywjfffAM3NzdMmzatXMcoU4L76quvIisrC1lZWQCATz/9FImJiejcuTP8/PyQnJyML7/8slyBEREREZH+SUxMRNOmTQHkjQQAoBkZAAA9e/Ys92QFZRqD269fP/Tr10/zuEmTJrhx4wbCwsIgl8vRvn172NjYlCswIiIiItI/Li4uiI2NBZB3L5eDgwPOnz+P/v37AwCio6PLPUVhuRZ6eJKlpaUmMCIiIiKiwnTu3BkHDx7EzJkzAQDDhg3D559/DrlcDrVaja+++gr+/v7lOkaZE1yVSoXNmzcjNDQUcXFxmDt3Lpo1a4akpCQcPnwYHTp0gKOjY7mCIyIiIiL98vbbb+PgwYPIysqCQqHA7NmzcenSJc2sCZ07d8bXX39drmOUKcFNTExEr169cPLkSZiZmSEtLQ1vvvkmgLyxFFOnTsXo0aM5TRgRERERaWnWrBmaNWumeWxtbY1Dhw4hMTERcrlcc+NZeZTpJrMPPvgAly5dwv79+zXTO+STy+UYPHgw9uzZU+7giIiIiEi/zJ07FxcvXixQbmVlBXNzc1y6dAlz584t1zHKlOBu374db775Jl588cVCBwE3aNAAUVFR5QqMiIiIiPTP7Nmz8e+//xa5/eLFi5gzZ065jlGmBDcpKQnu7u5Fbs/JyUFubm6ZgyIiIiKi2unx48cwMjIqVxtlGoPr6emJM2fOFLn9wIEDaNKkSZmDIiIiIiL9cfToUYSFhWkeb926FZGRkQXqJSYm4tdff9Uao1sWZUpwJ0yYgPfffx9dunRB9+7dAeStHZyVlYW5c+di3759+O6778oVGBERERHph9DQUM2wA0mSsHXrVmzdurXQuk2aNMGyZcvKdbwyJbhvvfUWLl26hBEjRsDKygoAMHLkSDx69Ai5ubmYNGkSxo8fX67AiIiIiEg//N///R+mTJkCIQQcHBzw7bffYtCgQVp1JEmCiYkJlEpluY9XpgRXkiR8//33CAoKwm+//YaIiAio1Wp4enpi6NCh6Ny5c7kDIyIiIiL9YGxsDGNjYwDArVu3YG9vDxMTk0o7XrlWMuvYsSM6duxYUbEQERERkZ5zdXWt9GNU2FK9RERERERPc3d3L3Ra2eJIkoQbN26U+ZglTnD79etXqoYlScKOHTtKHRARERER6Q8/P79SJ7jlVeIEd9euXVAqlXByctJauawoVX0iRERERFT9rFmzpsqPWeIEt06dOoiOjoadnR1GjhyJ4cOHw8nJqTJjIyIiIiIqtRKvZHb37l2EhoaiVatWmDdvHurVq4cePXogJCQEKSkplRkjEREREemR5ORkLFy4EP7+/mjVqhVOnjwJIG8Vs8WLFxe6CERplGqpXj8/P6xatQqxsbH47bffYGtriylTpsDBwQEDBw7Eb7/9hqysrHIFRERERET66969e2jVqhU+/vhj3Lt3D//++y9SU1MBADY2Nli1alW5F3ooVYKbz9DQEP3798evv/6KBw8eaJLeYcOG4fPPPy9XQCURFRWF8ePHw93dHcbGxvD09ERwcDCys7OL3a9Lly6QJEnr57XXXqv0eImIiIiqE13mUu+99x5SUlJw7tw5hIeHF7i3KzAwEIcOHSr1OT2pXNOEZWVlYf/+/dixYwfOnj0LpVIJNze3cgVUElevXoVarcaqVavg5eWFixcvYuLEiUhLS8MXX3xR7L4TJ07E3LlzNY8rc5JhIiIioupIl7nUgQMHMH36dDRp0gSPHj0qsN3DwwN3794tVZtPK3WCq1arcfDgQfz888/Yvn070tPT0aNHD3z//fcYMGAATE1NyxVQSfTq1Qu9evXSPPbw8MC1a9ewcuXKZ/5STExMeHMcERER1Wq6zKUyMjJgb29f5PaKuLerxEMU/vzzT0yZMgXOzs4ICAhAZGQk5s+fj/v372PPnj0YNWpUlSS3RUlKSoKNjc0z6/3000+ws7ODj48PZsyYgfT09GLrZ2VlITk5WfOTP0aEiIiIqKqkpqZq5SOVcc9TZeVST2vSpAmOHj1a5Pbt27ejVatWpWrzaSXuwe3YsSOMjY3x0ksvYcSIEZqhCHfu3MGdO3cK3ad169blCq6kIiMjsWzZsmd+4hg5ciRcXV3h4uKCf//9F++//z6uXbuGrVu3FrnPggULMGfOnIoOmYiIiKjE/Pz8tB4HBwdj9uzZFdZ+ZeZST5s2bRqCgoLQvHlzDBkyBEDeCIHIyEjMmTMHJ06cwJYtW8p1PhAlJEmS5kcmkxX7k1+ntN5//30BoNifK1euaO1z79494enpKcaPH1/q4x0+fFgAEJGRkUXWyczMFElJSZqf8PBwAUCcPn261McjIiIiKo3Tp08LACI8PFwrH8nMzCy0fnXMpQrzySefCAMDAyGXy4UkSUIulwuZTCYMDAzEwoULSx3H0yQhSrAsGYC1a9eWOnkOCgoqVf34+PhCBxs/ycPDA0ZGRgCA+/fvo0uXLnj++eexZs0ayGSlmxQiLS0NZmZm2LdvH/z9/Uu0z5kzZ+Dr64vTp09XWQ81ERER1U6lzTtqQi6V786dO9iyZQsiIyOhVqvh6emJgQMHwsPDo1TtFKbEQxRKm6yWhb29fbGDjp8UHR2Nrl27wtfXFyEhIaX+hQDAuXPnAADOzs6l3peIiIhqnoSEBFhbW+s6jEpTk3Kp+vXrY/r06aXeryTKNA+urkVHR6NLly6oX78+vvjiC8THxyM2NhaxsbFadRo1aqRZGePGjRuYN28eTp8+jaioKOzcuROjR49G586d0bx5c12dChEREVWh+/fvIzk5Wddh6Jy+51LlmgdXVw4ePIjIyEhERkaibt26WtvyR1zk5OTg2rVrmjv7jIyMcOjQIXz11VdIS0tDvXr1MGjQIHz00UdVHj8RERHphhACFy9eRPv27XUdik5VZS4lk8kgSVKpY1SpVKXeJ1+Jx+BSHo7BJSIiqpnatGmDu3fvwtjYGIcOHYKnp2eZEq+qpA95x+zZswtc523btuHSpUvw9/dHw4YNAeQtPnHgwAH4+PggMDAQwcHBZT5mjezBJSIiIiqt2NhYxMXFwcrKCkeOHMGlS5fQvHlz1K9fH3K5XNfh6a2npzP77rvvEBcXh4sXL2qS23xXrlxBt27d4OLiUq5j1sgxuERERETl9eDBAxw8eBAbNmxAaGgoIiMjkZGRoeuw9N6iRYswZcqUAsktADRu3BhTpkzB559/Xq5jsAeXiIiI9F5ERITm5rKMjAw8ePAAjo6OAPJWLY2IiEBERAQAwMbGBo6OjnB0dIS9vT2srKyq/VCGmuTevXswNDQscruhoSHu3btXrmMwwSUiIiK9FhISggkTJkCtVgPIS2iDg4MxevToQm82e/z4MR4/fowrV64AyEu47Ozs4OTkBBcXFzg5OXFIQzn4+PhgxYoVGDlyJOrUqaO17d69e1ixYgWaNWtWrmMwwSUiIiK9FRERoZXc5hNCYN26dfDy8oKDg0OxbeTk5CAmJgYxMTE4e/YsjIyM4OrqCjc3N9SpU0ezaAKVzJIlS+Dv748GDRpgwIAB8PLyApD3u9q+fTuEENiwYUO5jsEEl4iIiPTW6tWrixxeIEkSjh8/jgEDBpSqzezsbM2QBplMBkdHR3h5eaFRo0YcylACHTt2xN9//41Zs2Zh27ZtmnHPxsbG8Pf3x5w5c9iDS0RERFSUqKgoFDUjqhDimcvaPotarUZMTAyys7Ph6enJ3twS8vHxwbZt26BWqxEfHw8gbxW2sqymVhgmuERERKS33Nzciu3BtbW1LVf7xsbGaN68OXx8fDgutwzye8ArGhNcIiIi0lvjxo0rcsopIQQ6dOhQqvYMDQ1ha2sLBwcH1KlTBy4uLkxsqyEmuERERKS3vL298eOPP2L8+PFaN5pJkoTRo0c/8wYzY2Nj1KtXD87OznBwcOCUYTUEE1wiIiLSa2PGjEHHjh3RunVrpKSkQKFQ4KOPPio0uVUoFHBwcICTkxPq1q0LOzs7JrQ1EBNcIiIi0nteXl6wsLBASkoKjI2NNcmtgYEB6tWrh7p168LJyYk9tHqCCS4RERHVOjKZDK1bt4aPjw9nPtBDTHCJiIioVnByckJOTg6MjY3Rq1cv1K1bV9chUSVhgktERES1wj///IOLFy9CqVQyudVzTHCJiIio1jAzM4Orq6uuw6BKVjHLRRARERHVAA4ODryJrBZggktERES1hrGxsa5DoCrABJeIiIhqDfbe1g5McImIiIhIrzDBJSIiIiK9wgSXiIiIiPQKpwmrJWJiYhATE6PrMPSes7MznJ2ddR1GrcDndNXgc7rq8DldNficrh2Y4JaSs7MzgoODa9SLIysrCyNGjEB4eLiuQ9F7fn5+2L9/PxQKha5D0Wt8TlcdPqerBp/TVaemPadrYt5RHUhCCKHrIKhyJScnw9LSEuHh4TAzM9N1OHorNTUVfn5+SEpKgoWFha7D0Wt8TlcNPqerDp/TVYPP6dqDPbi1SMuWLfmCrkTJycm6DqHW4XO6cvE5XfX4nK5cfE7XHrzJjIiIiIj0ChNcIiIiItIrTHBrAYVCgeDg4BozoL6m4nWuOrzWVYPXuerwWlcNXufagzeZEREREZFeYQ8uEREREekVJrhEREREpFeY4BIRERGRXmGCS/QMY8aMgZubm67DwJgxYzgBPBHVKLNnz4YkSaXerzr83S1PDF26dEGXLl0qNB4qHSa4VGOsWbMGkiRBkiQcO3aswHYhBOrVqwdJktCnT59nttelSxdNe5IkwcbGBm3btsXq1auhVqsr4xSIyqUyXwMymQwWFhZo2LAhXnnlFRw8eLAyToGoTNLT0zF79myEhYXpOpQyuX//PmbPno1z587pOpRagwku1ThKpRIbN24sUB4eHo579+6VavqXunXrYv369Vi/fj1mzZqF3NxcjB8/Hh9++GFFhkxUoSrjNbBu3TosWrQI/fr1w59//omePXti2LBhyMnJqcjQicokPT0dc+bMqdEJ7pw5c5jgViEmuFTjvPTSS9i8eTNyc3O1yjdu3AhfX184OTmVuC1LS0uMGjUKo0aNwvTp03H8+HHUrVsXy5cv5xs7VVuV9RqYNGkSFi1ahOvXr+ONN97Apk2b8NFHHxW7v1qtRmZmZpnOg4iosjDBpRpnxIgRePTokdZXqNnZ2fjtt98wcuTIcrVtYmKC559/HmlpaYiPjy+y3hdffIH27dvD1tYWxsbG8PX1xW+//VZo3Q0bNuC5556DiYkJrK2t0blzZxw4cECrzt69e9GpUyeYmprC3NwcAQEBuHTpUqHt3bx5E/7+/jA1NYWLiwvmzp2Lp6ezTktLwzvvvIN69epBoVCgYcOG+OKLLwrUo5qpMl8DACCXy/H111+jSZMmWL58OZKSkjTbJEnClClT8NNPP6Fp06ZQKBTYt28fwsLCIElSgR62qKgoSJKENWvWaJVv3rwZTZo0gVKphI+PD7Zt21Ytxl1S2R07dgxt27aFUqmEp6cnVq1aVWi9DRs2wNfXF8bGxrCxscHw4cNx9+7dItuNioqCvb09AGDOnDmaYTWzZ88GAPz7778YM2YMPDw8oFQq4eTkhHHjxuHRo0cljn379u3w8fHRej4WRq1W46uvvkLTpk2hVCrh6OiISZMmISEhoci2w8LC0LZtWwDA2LFjNfHnvyb++OMPDBkyBPXr14dCoUC9evUwffp0ZGRklDh+KogJLtU4bm5ueOGFF/Dzzz9ryvbu3YukpCQMHz683O3fvHkTcrkcVlZWRdZZunQpWrVqhblz52L+/PkwMDDAkCFDsHv3bq16c+bMwSuvvAJDQ0PMnTsXc+bMQb169XDkyBFNnfXr1yMgIABmZmb47LPPMGvWLFy+fBkdO3ZEVFSUVnsqlQq9evWCo6MjPv/8c/j6+iI4OBjBwcGaOkII9OvXD0uWLEGvXr2wePFiNGzYEO+99x7efvvtcl8f0r3Kfg0AeUnuiBEjkJ6eXmC875EjRzB9+nQMGzYMS5cuLXVSunv3bgwbNgyGhoZYsGABBg4ciPHjx+P06dMVEjtVvQsXLqBnz56Ii4vD7NmzMXbsWAQHBxdIFD/99FOMHj0a3t7eWLx4MaZNm4bDhw+jc+fOSExMLLRte3t7rFy5EgAwYMAAzbCygQMHAgAOHjyImzdvYuzYsVi2bBmGDx+OX375BS+99FKJPtQfOHAAgwYNgiRJWLBgAQIDAzF27Fj8888/BepOmjQJ7733Hjp06IClS5di7Nix+Omnn+Dv71/kt36NGzfG3LlzAQCvvvqqJv7OnTsDyPuwl56ejtdffx3Lli2Dv78/li1bhtGjRz8zdiqGIKohQkJCBABx6tQpsXz5cmFubi7S09OFEEIMGTJEdO3aVQghhKurqwgICHhme35+fqJRo0YiPj5exMfHiytXroipU6cKAKJv376aekFBQcLV1VVr3/zj5svOzhY+Pj6iW7dumrKIiAghk8nEgAEDhEql0qqvVquFEEKkpKQIKysrMXHiRK3tsbGxwtLSUqs8KChIABBvvvmmVjsBAQHCyMhIxMfHCyGE2L59uwAgPvnkE602Bw8eLCRJEpGRkc+8NlQ9VcZroGnTpkVu37ZtmwAgli5dqikDIGQymbh06ZJW3dDQUAFAhIaGapXfunVLABAhISGasmbNmom6deuKlJQUTVlYWJgAUOC1RjVDYGCgUCqV4vbt25qyy5cvC7lcLvJTjaioKCGXy8Wnn36qte+FCxeEgYGBVvnTf3fj4+MFABEcHFzg2E//PRZCiJ9//lkAEEePHn1m7C1bthTOzs4iMTFRU3bgwIECz8c//vhDABA//fST1v779u0rUO7n5yf8/Pw0j0+dOlXgdVBc/AsWLBCSJGldTyod9uBSjTR06FBkZGRg165dSElJwa5du8r01ezVq1dhb28Pe3t7NG7cGMuWLUNAQABWr15d7H7Gxsaa/yckJCApKQmdOnXCmTNnNOXbt2+HWq3Gxx9/DJlM+6WWP23OwYMHkZiYiBEjRuDhw4eaH7lcjnbt2iE0NLTAsadMmaLVzpQpU5CdnY1Dhw4BAPbs2QO5XI6pU6dq7ffOO+9ACIG9e/eW8OpQdVZRr4Hi5E9Ll5KSolXu5+eHJk2alKnN+/fv48KFCxg9erTWtHd+fn5o1qxZ2YMlnVGpVNi/fz8CAwNRv359TXnjxo3h7++vebx161ao1WoMHTpU6++dk5MTvL29C/17VxJP/j3OzMzEw4cP8fzzzwOA1t/kwsTExODcuXMICgqCpaWlpvzFF18s8BzfvHkzLC0t8eKLL2rF7+vrCzMzswqJPy0tDQ8fPkT79u0hhMDZs2fL1CYBBroOgKgs7O3t0aNHD2zcuBHp6elQqVQYPHhwqdtxc3PD999/D0mSoFQq4e3tDQcHh2fut2vXLnzyySc4d+4csrKyNOVPzvd448YNyGSyYhOBiIgIAEC3bt0K3W5hYaH1WCaTwcPDQ6usQYMGAKAZznD79m24uLjA3Nxcq17jxo0126nmq6jXQHFSU1MBoMBzyd3dvcxt5j//vLy8Cmzz8vJ6ZkJC1U98fDwyMjLg7e1dYFvDhg2xZ88eAHl/74QQhdYDAENDwzId//Hjx5gzZw5++eUXxMXFaW3LHz+enZ2Nx48fa22zt7fXPB+Liv3J52NERASSkpKKfI94+tgldefOHXz88cfYuXNngbG8T45/p9Jhgks11siRIzFx4kTExsaid+/exY6ZLYqpqSl69OhRqn3++OMP9OvXD507d8aKFSvg7OwMQ0NDhISEFDp1U3Hy59tdv359oXe+GxjwJUpFq4jXQHEuXrwIoGAy+mSPU76iJvNXqVQVGhPVXGq1GpIkYe/evZDL5QW2l3Uhm6FDh+LPP//Ee++9h5YtW8LMzAxqtRq9evXS/I39888/0bVrV639bt26Ver4HRwc8NNPPxW6Pf9GuNJQqVR48cUX8fjxY7z//vto1KgRTE1NER0djTFjxnBO9nLguyfVWAMGDMCkSZPw119/4ddff62y427ZsgVKpRL79+/Xmm80JCREq56npyfUajUuX76Mli1bFtqWp6cnAMDBwaFEibZarcbNmzc1vbYAcP36dQDQ3Ojj6uqKQ4cOISUlRavn7erVq5rtpB8q8zWgUqmwceNGmJiYoGPHjs+sb21tDQAFbhR6+huD/OdfZGRkgTYKK6Pqz97eHsbGxppvpJ507do1zf89PT0hhIC7u7vW37CSKOoDVEJCAg4fPow5c+bg448/1pQ/HUuLFi0KLF7i5OSk+Rv+rNjz4z906BA6dOhQ6Ie8ssR/4cIFXL9+HWvXrtW6qYwLrZQfx+BSjWVmZoaVK1di9uzZ6Nu3b5UdVy6XQ5IkrZ6pqKgobN++XateYGAgZDIZ5s6dW+BTuPjvzl5/f39YWFhg/vz5hd6BW9hUZcuXL9dqZ/ny5TA0NET37t0B5M2RqlKptOoBwJIlSyBJEnr37l26E6Zqq7JeAyqVClOnTsWVK1cwderUAkNlCuPq6gq5XI6jR49qla9YsULrsYuLC3x8fLBu3TrNEAggb5GKCxcuVMwJUJWSy+Xw9/fH9u3bcefOHU35lStXsH//fs3jgQMHQi6XY86cOQVmNxBCFDutl4mJCYCCH6Dye4Kfbu+rr77SemxtbY0ePXpo/SiVSjg7O6Nly5ZYu3at1nCAgwcP4vLly1ptDB06FCqVCvPmzSsQX25ubpGzQAB53xaWNH4hBJYuXVpkW1Qy7MGlGi0oKKjKjxkQEIDFixejV69eGDlyJOLi4vDNN9/Ay8sL//77r6ael5cXZs6ciXnz5qFTp04YOHAgFAoFTp06BRcXFyxYsAAWFhZYuXIlXnnlFbRu3RrDhw+Hvb097ty5g927d6NDhw5aiapSqcS+ffsQFBSEdu3aYe/evdi9ezc+/PBDzddjffv2RdeuXTFz5kxERUWhRYsWOHDgAHbs2IFp06Zpeo1JP5T3NZCUlIQNGzYAyFstKjIyElu3bsWNGzcwfPjwQt/MC2NpaYkhQ4Zg2bJlkCQJnp6e2LVrV6HjEufPn4/+/fujQ4cOGDt2LBISErB8+XL4+PhoJb1Uc8yZMwf79u1Dp06d8MYbbyA3NxfLli1D06ZNNX8XPT098cknn2DGjBmIiopCYGAgzM3NcevWLWzbtg2vvvoq3n333ULbNzY2RpMmTfDrr7+iQYMGsLGxgY+PD3x8fNC5c2d8/vnnyMnJQZ06dXDgwIFSDT9YsGABAgIC0LFjR4wbNw6PHz/WxP7k89HPzw+TJk3CggULcO7cOfTs2ROGhoaIiIjA5s2bsXTp0iLHwXt6esLKygrffvstzM3NYWpqinbt2qFRo0bw9PTEu+++i+joaFhYWGDLli3FzqtLJaSj2RuISu3JKZKKU1FTJOUrbJqwH3/8UXh7ewuFQiEaNWokQkJCRHBwsCjsJbV69WrRqlUroVAohLW1tfDz8xMHDx7UqhMaGir8/f2FpaWlUCqVwtPTU4wZM0b8888/WnGYmpqKGzduiJ49ewoTExPh6OgogoODC0xDlpKSIqZPny5cXFyEoaGh8Pb2FosWLdJMT0Y1U2W8BgBofszMzIS3t7cYNWqUOHDgQKH7ABCTJ08udFt8fLwYNGiQMDExEdbW1mLSpEni4sWLhU6P9Msvv4hGjRoJhUIhfHx8xM6dO8WgQYNEo0aNnhk3VU/h4eHC19dXGBkZCQ8PD/Htt98W+ndxy5YtomPHjsLU1FSYmpqKRo0aicmTJ4tr165p6hT2d/fPP//UtI8npgy7d++eGDBggLCyshKWlpZiyJAh4v79+0VOK1aYLVu2iMaNGwuFQiGaNGkitm7dWmgMQgjx3XffCV9fX2FsbCzMzc1Fs2bNxP/93/+J+/fva+o8PU2YEELs2LFDNGnSRBgYGGi9Ji5fvix69OghzMzMhJ2dnZg4caI4f/58kdOKUclIQnBpIyIi0r2WLVvC3t6e4w+JqNw4BpeIiKpUTk4OcnNztcrCwsJw/vx5dOnSRTdBEZFeYQ8uERFVqaioKPTo0QOjRo2Ci4sLrl69im+//RaWlpa4ePEibG1tdR0iEdVwvMmMiIiqlLW1NXx9ffHDDz8gPj4epqamCAgIwMKFC5ncElGFYA8uEREREekVjsElIiIiIr3CBJeIiIiI9AoTXKJSiIqKgiRJWLNmja5DISo3Pp+JSF8xwSUiIiIivcKbzIhKQQiBrKwsGBoaatYQJ6qp+HwmIn3FBJeIiIiI9AqHKFCtM3v2bEiShOvXr2PUqFGwtLSEvb09Zs2aBSEE7t69i/79+8PCwgJOTk748ssvNfsWNmZxzJgxMDMzQ3R0NAIDA2FmZgZ7e3u8++67UKlUmnphYWGQJAlhYWFa8RTWZmxsLMaOHYu6detCoVDA2dkZ/fv3R1RUVCVdFaqp+HwmIiqICS7VWsOGDYNarcbChQvRrl07fPLJJ/jqq6/w4osvok6dOvjss8/g5eWFd999F0ePHi22LZVKBX9/f9ja2uKLL76An58fvvzyS3z33Xdlim3QoEHYtm0bxo4dixUrVmDq1KlISUnBnTt3ytQe6T8+n4mIniCIapng4GABQLz66quastzcXFG3bl0hSZJYuHChpjwhIUEYGxuLoKAgIYQQt27dEgBESEiIpk5QUJAAIObOnat1nFatWglfX1/N49DQUAFAhIaGatV7us2EhAQBQCxatKhiTpj0Gp/PREQFsQeXaq0JEyZo/i+Xy9GmTRsIITB+/HhNuZWVFRo2bIibN28+s73XXntN63GnTp1KtN/TjI2NYWRkhLCwMCQkJJR6f6qd+HwmIvofJrhUa9WvX1/rsaWlJZRKJezs7AqUP+uNWalUwt7eXqvM2tq6TG/oCoUCn332Gfbu3QtHR0d07twZn3/+OWJjY0vdFtUefD4TEf0PE1yqtQqbFqmoqZLEMyYbKckUS5IkFVr+5I07+aZNm4br169jwYIFUCqVmDVrFho3boyzZ88+8zhUO/H5TET0P0xwiaqItbU1ACAxMVGr/Pbt24XW9/T0xDvvvIMDBw7g4sWLyM7O1roDnkiX+HwmouqMCS5RFXF1dYVcLi9wB/uKFSu0HqenpyMzM1OrzNPTE+bm5sjKyqr0OIlKgs9nIqrODHQdAFFtYWlpiSFDhmDZsmWQJAmenp7YtWsX4uLitOpdv34d3bt3x9ChQ9GkSRMYGBhg27ZtePDgAYYPH66j6Im08flMRNUZE1yiKrRs2TLk5OTg22+/hUKhwNChQ7Fo0SL4+Pho6tSrVw8jRozA4cOHsX79ehgYGKBRo0bYtGkTBg0apMPoibTx+UxE1RWX6iUiIiIivcIxuERERESkV5jgEhEREZFeYYJLRERERHqFCS4RERER6RUmuERERESkV5jgEpXA7Nmzi1yaVBdxPHz4UNehEBERVVtMcKna27RpEyRJwrZt2wpsa9GiBSRJQmhoaIFt9evXR/v27Ytte8yYMZAkSfNjYWGBFi1a4Msvv+QqS1RtVOVrwMzMDB4eHhg8eDC2bNkCtVpdYedBRFRVmOBStdexY0cAwLFjx7TKk5OTcfHiRRgYGOD48eNa2+7evYu7d+9q9i2OQqHA+vXrsX79esyfPx82NjZ49913ERQUVHEnQVQOVfkaWLJkCUaOHImIiAgMHjwY3bt3R/L/t3f/MVHXfxzAnwfGHdgdMZKKorvjcNN0ZgI5T9alxi9Jx6ywWE6bpy2q9cPahD9CswGthH5ITHMhy3Ku1hxMNH/lqBviPweWbnoY8gf9EGx3KHAOjtf3D7/3mR+PHweK/NjzsTH2eX9en/fnx+69z3vvX5/Ozjt3M0REdwG/ZEYTXmxsLMxmc8DLvb6+HiKCF154IWCffzuYl/u0adPw8ssvK9t5eXlYuHAh9u/fj9LSUsTGxt6BuyAavbtdBgDgo48+QklJCfLz87Fhwwbs379/0ONFBF6vF+Hh4cHeEhHRmGILLk0KKSkpcDqd6OnpUdIcDgfmzJmDzMxMnDp1StWV6nA4oNFosHjx4hGfKyQkBE8//TQA4NKlS4PGVVZWYunSpYiJiYFWq8Vjjz2GioqKAWMPHToEm80GvV4Pg8GA5ORkfP/996qYhoYGZGRkIDIyEhEREbDZbAGtcn4dHR3IycmBwWBAdHQ03nrrLXi9XlVMX18ftm3bBovFAq1WC5PJhIKCAg69mKTuZhnw27x5M9LS0vDDDz/gwoULSrrJZMKzzz6Ln3/+GUlJSQgPD8fOnTtx6dIlaDQa7NmzJyAvjUaDLVu2qNJOnjyJpKQk6HQ6WCwW7Ny5c8KMdyeiyY0VXJoUUlJS0Nvbi4aGBiXN4XDAarXCarXC4/Hgjz/+UO2bNWsWoqOjR3W+ixcvAsCQx1dUVMBoNKKgoADbt29HXFwc8vLyUF5erorbs2cPsrKy8N9//yE/Px8lJSWYP38+Dh8+rMScOHECTz31FDo7O1FYWIiioiK43W4sXboUp0+fDjh3Tk4OvF4viouLsXz5cnzxxRfYuHGjKsZut+ODDz7AggULUFZWBpvNhuLiYrz44oujeiY0vu52GfBbs2YNRARHjx5VpZ8/fx4vvfQSUlNT8fnnn2P+/PkjytfpdCIjIwNXrlzB1q1bsX79enz44Yc4cODAbV0vEREAQIgmgbNnzwoA2bZtm4iI9Pb2yvTp06WqqkpERB544AEpLy8XEZHOzk4JDQ2VDRs2DJvv2rVrZfr06dLe3i7t7e3S3NwsRUVFotFoZN68eUpcYWGh3Fpcuru7A/JLT0+X+Ph4Zdvtdoter5eFCxdKT0+PKra/v1/5P3PmTElPT1fS/PmbzWZJTU0NuI6VK1eq8srLyxMA0tTUJCIijY2NAkDsdrsq7r333hMAcuLEiWGfDU0sY10GBuN0OgWAvPPOO0qa0WgUAHL48GFVbEtLiwCQysrKgHwASGFhobK9YsUKiYiIkLa2NiXN5XLJtGnTAsoaEdFIsQWXJoXZs2cjOjpaGVfY1NSErq4uZYa41WpVuvPr6+vh8/mCGnsIAF1dXZgxYwZmzJiBhIQEFBQUYNGiRQPOWL/ZzeMNPR4POjo6YLPZ8Oeff8Lj8QAAjh49iqtXr2Lz5s3Q6XSq4/3dsI2NjXC5XMjNzcWVK1fQ0dGBjo4OdHV1YdmyZairqwuYyf7666+rtt98800AQG1trer/u+++q4rbtGkTAODgwYPDPxiaUMayDAzl3nvvBQBcvXpVlW42m5Genj6qPH0+H44dO4bs7GzVGPeEhARkZmaO/mKJiP6Pk8xoUtBoNLBarUplz+FwICYmBgkJCQBuvNx37NgBAMpLPtiXu06nQ01NDYAbs8nNZjMeeeSRYY9zOBwoLCxEfX09uru7Vfs8Hg8iIyOVoQ5z584dNB+XywUAQ67a4PF4EBUVpWzPnDlTtd9isSAkJEQZM9za2oqQkBDl+fg9+OCDuO+++9Da2jrs/dHEMpZlYCjXrl0DAOj1elW62WwedZ6XL19GT09PwO8TwIBpREQjxQouTRopKSmoqanB77//row99LNarXj//ffR1taG3377DbGxsYiPjw8q39DQUDzzzDMjupaLFy9i2bJlmDVrFkpLSxEXF4ewsDDU1tairKxsRGuH+mM/+eSTQccx+lvRBjPYpBxO1plaxqoMDMU/rvfWiudAKyYM9nvz+Xy3fR1ERCPBCi5NGjevBepwOPD2228r+xITE6HVanHy5Ek0NDRg+fLlY3otNTU1uH79Oqqrq/Hoo48q6bcutm+xWADcqCQM1jLljzEYDEFXtF0ul6oFrbm5Gf39/TCZTAAAo9GI/v5+uFwuzJ49W4n7999/4Xa7YTQagzoPTSzjUQa+/fZbaDQapKamDhvr72Vwu92q9Ft7DGJiYqDT6dDc3ByQx0BpREQjxTG4NGn4lxP67rvv0NbWpmq90mq1WLBgAcrLy9HV1XVHumaHEhoaCuDG+p9+Ho8HlZWVqri0tDTo9XoUFxcHLOPlPzYxMREWiwWffvqp0h18s/b29oC0W1dq+PLLLwFAGb/or9x89tlnqrjS0lIAQFZW1tA3SBPS3S4DJSUlOHLkCFavXh0wLGYgBoMB999/P+rq6lTpX331lWrb32ty4MAB/PXXX0p6c3MzDh06dNvXTUTEFlyaNMLCwpCcnIxff/0VWq0WiYmJqv1WqxXbt28HcGfGHg4lLS0NYWFhWLFiBV599VVcu3YNX3/9NWJiYvD3338rcQaDAWVlZbDb7UhOTkZubi6ioqLQ1NSE7u5uVFVVISQkBLt370ZmZibmzJmDV155BQ8//DDa2trwyy+/wGAwKGOE/VpaWrBy5UpkZGSgvr4ee/fuRW5uLh5//HEANz7funbtWuzatQtutxs2mw2nT59GVVUVsrOzsWTJkjF9PjQ2xqoM9PX1Ye/evQAAr9eL1tZWVFdX48yZM1iyZAl27doVdF52ux0lJSWw2+1ISkpCXV2dag1dvy1btuDIkSNYvHgxXnvtNfh8PuzYsQNz585FY2Nj0OcjIhrQeC/jQDQS+fn5AkCsVmvAvp9++kkAiF6vl76+vqDyG26JJL+Blgmrrq6WefPmiU6nE5PJJB9//LF88803AkBaWloCYq1Wq4SHh4vBYJAnn3xS9u3bp4pxOp2yatUqiY6OFq1WK0ajUXJycuT48eMB13Hu3Dl5/vnnRa/XS1RUlLzxxhsBy5D19vbK1q1bxWw2yz333CNxcXGSn58vXq83qGdDE9NYlAEAyl9ERISYTCZ57rnn5McffxSfzxdwjNFolKysrAHz6+7ulvXr10tkZKTo9XrJycmRy5cvBywTJiJy/PhxeeKJJyQsLEwsFovs3r1bNm3aJDqdLqhrJyIajEbkpj5WIiKicZSdnY2zZ88qq4sQEY0Gx+ASEdG4uPmzw8CNyZO1tbXKp7KJiEaLLbhERDQuHnroIaxbtw7x8fFobW1FRUUFrl+/DqfTGdSkNiKiwXCSGRERjYuMjAzs27cP//zzD7RaLRYtWoSioiJWbonotrEFl4iIiIimFI7BJSIiIqIphRVcIiIiIppSWMElIiIioimFFVwiIiIimlJYwSUiIiKiKYUVXCIiIiKaUljBJSIiIqIphRVcIiIiIppSWMElIiIioinlf8HTHgaQ8dEMAAAAAElFTkSuQmCC", "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -365,41 +259,35 @@ } ], "source": [ - "''' \n", - "In this case,``x`` needs to be declared as a list consisting of 2 elements, unlike most cases where it is a single element. \n", - "The first element in ``x`` will represent the variable plotted along the horizontal axis, and the second one will determine the \n", - "color of dots for scattered plots or the color of lines for slope graphs. We use the ``experiment`` input to specify the grouping of the data.\n", - "'''\n", + "\n", "f1 = unpaired_delta_01.mean_diff.plot(\n", " contrast_label='Mean Diff',\n", - " fig_size = (5, 5),\n", - " raw_marker_size = 5,\n", + " fig_size = (7, 4),\n", + " raw_marker_size = 1,\n", " es_marker_size = 5,\n", " color_col='Genotype'\n", ");\n", + "f1.suptitle('Delta-delta plot for Drug 1');\n", "\n", "\n", "f2 = unpaired_delta_02.mean_diff.plot( \n", " contrast_label='Mean Diff',\n", - " fig_size = (5, 5),\n", - " raw_marker_size = 5,\n", + " fig_size = (7, 4),\n", + " raw_marker_size = 1,\n", " es_marker_size = 5,\n", " color_col='Genotype'\n", ");\n", + "f2.suptitle('Delta-delta plot for Drug 2');\n", "\n", "\n", "f3 = unpaired_delta_03.mean_diff.plot( \n", " contrast_label='Mean Diff',\n", - " fig_size = (5, 5),\n", - " raw_marker_size = 5,\n", + " fig_size = (7, 4),\n", + " raw_marker_size = 1,\n", " es_marker_size = 5,\n", " color_col='Genotype'\n", ");\n", - "\n", - "p1 = paired_delta_01.mean_diff.plot();\n", - "p2 = paired_delta_02.mean_diff.plot();\n", - "p3 = paired_delta_03.mean_diff.plot();\n", - "\n" + "f3.suptitle('Delta-delta plot for Drug 3');\n" ] }, { @@ -407,8 +295,7 @@ "id": "bb289b05", "metadata": {}, "source": [ - "# Plot all the delta-delta plots into a forest plot \n", - "### For comparisons of different ``Drug`` effects" + "## Plot all the delta-delta plots into a forest plot for comparisons of different ``Drug`` effects" ] }, { @@ -434,28 +321,20 @@ "\n", "- ``horizontal``: A boolean input (``True``/ ``False``) to adjust the plot orientation. The default is vertical orientation (``False``) \n", "\n", - "- ``custom_palette``: A list of colors, one for each contrast object. E.g., ``['gray', 'blue', 'green']``\n", + "- ``custom_palette``: A list or dictionary of colors, one for each contrast object. E.g., ``['gray', 'blue', 'green']`` or ``{'Drug1':'gray', 'Drug2':'blue', 'Drug3':'green'}``\n", "\n", - "- Additional kwargs are supported such as ``violin_kwargs``, ``fontsize``, ``marker_size``, ``ci_line_width``, ``rotation_for_xlabels``, ``alpha_violin_plot``, ``remove_spines``, and ``additional_plotting_kwargs``\n" - ] - }, - { - "cell_type": "markdown", - "id": "06b93055", - "metadata": {}, - "source": [ - "#### Vertical Layout (default)" + "- Additional kwargs are supported such as ``violin_kwargs``, ``fontsize``, ``marker_size``, ``ci_line_width``, ``rotation_for_xlabels``, ``alpha_violin_plot``, ``remove_spines``, ``desat_violin``, and ``additional_plotting_kwargs``\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "c4a7e5a4", + "id": "9a424896-05cd-4c72-a004-b40c9056b292", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -465,193 +344,17 @@ } ], "source": [ - "forest1_vertical = forest_plot(contrasts, \n", + "f_forest_delta2 = forest_plot(contrasts, \n", " contrast_labels =['Drug1', 'Drug2', 'Drug3']);" ] }, - { - "cell_type": "markdown", - "id": "b3eee52e", - "metadata": {}, - "source": [ - "#### Horizontal Layout" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d8313860", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "forest1_horizontal = forest_plot(contrasts, \n", - " contrast_labels =['Drug1', 'Drug2', 'Drug3'],\n", - " horizontal=True);\n" - ] - }, - { - "cell_type": "markdown", - "id": "4100ba2c", - "metadata": {}, - "source": [ - "#### Changing ``custom_palette`` and ``effect_size``" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "23c9446e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "forest2_vertical = forest_plot(paired_contrasts, \n", - " contrast_labels =['Drug1', 'Drug2', 'Drug3'], \n", - " custom_palette= ['gray', 'blue', 'green'], \n", - " effect_size='delta_g');" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d5f2a4dd", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "forest2_horizontal = forest_plot(paired_contrasts, \n", - " contrast_labels =['Drug1', 'Drug2', 'Drug3'], \n", - " custom_palette= ['gray', 'blue', 'green'],\n", - " horizontal=True, effect_size='delta_g');\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "829f0d03", - "metadata": {}, - "source": [ - "### A forest plot added as a subfigure with a figure with a variety of DABEST plots" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0e0d544f", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/plot_tools.py:1232: UserWarning: 5.0% of the points cannot be placed. You might want to decrease the size of the markers.\n", - " warnings.warn(err)\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/plot_tools.py:1232: UserWarning: 5.0% of the points cannot be placed. You might want to decrease the size of the markers.\n", - " warnings.warn(err)\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/plot_tools.py:1232: UserWarning: 15.0% of the points cannot be placed. You might want to decrease the size of the markers.\n", - " warnings.warn(err)\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0.0, 1.0, 'Forest plot')" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABgcAAAXPCAYAAACDZC7uAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3wUdf4/8NfMbrLpvWx6ISSk0EOJ9C4ooIJdRO8snPXkPDzUs9ydh+fpV86fHoqHIoJgCagIIiiE3pIQaggtjZBNIb3sZndnfn8srCy7CcUkmyWv5+ORBzefz8zmNXgJM/Oez+cjyLIsg4iIiIiIiIiIiIiIug3R3gGIiIiIiIiIiIiIiKhzsThARERERERERERERNTNsDhARERERERERERERNTNsDhARERERERERERERNTNsDhARERERERERERERNTNsDhARERERERERERERNTNsDhARERERERERERERNTNsDhARERERERERERERNTNsDhARERERERERERERNTNsDhA162goACCIOC111677s8QBAEPPfRQu2UiIiIiIqLrx2t8IiIiou6DxYFrkJGRAUEQzF8KhQI+Pj5ITEzEfffdh9WrV8NoNNo7poVNmzZhzpw5GDRoEFQqFQRBQEZGhr1jtWnhwoVYunTpb/oMWZaxfPly3HPPPYiLi4ObmxsiIyMxbdo07N27t32CEhEREZHDc7RrfK1Wi48//hjTp09HdHQ0XF1dERsbi3vvvRe5ubn2jtcqXuMTERERdT1KewdwRHfffTduvfVWyLKMhoYGnDx5Ej/88ANWrlyJQYMGYfXq1QgPD7d3TADAihUr8MUXXyAlJQVJSUnIycmxd6QrWrhwIaKjo3/T20Y6nQ6zZs1Cnz59cPfddyM2NhalpaX48MMPkZaWhmXLluGBBx5ov9BERERE5NAc5Rq/oKAAjz32GNLS0vDwww8jPDwcZ86cwaJFi7B69Wps2LABY8aMsXdMK7zGJyIiIup6WBy4Dv369bO66HznnXfw1ltv4S9/+QtuueUWZGVlQals/a9XkiTodDq4urp2aNY33ngDH330EVQqFd5++22HKA60B6VSic2bN1vdGD3yyCNISUnB888/j/vuuw+iyMEzREREROQ41/iBgYHIzs5G//79Ldrvv/9+9O/fH/PmzcP+/fs77PvbE6/xiYiIiNoXr5raiSAIeOGFF3DPPffg0KFD+PLLL819S5cuhSAI+Pnnn/H3v/8dPXr0gEqlMu/T2pycF4+7fBqgo0ePYsqUKfDw8ICPjw+mT5+OM2fOIDo6GqNHj7bYNywsDCqV6jef3w8//IDU1FS4uLggJCQEzzzzDBobG23uK8syFi1ahIEDB8LNzQ2enp4YM2YMtmzZ0ub3uDi/aWFhIbZu3WoxvPuiL7/8EtOmTUNkZCRUKhUCAgJw22234dChQxafpVQqbb4xpVarMXLkSJSVlaG8vPw6/iaIiIiIqLvoitf4/v7+VoUBAEhKSkJycjIOHz581efHa3wiIiKi7o0jB9rZY489hlWrVuGHH37A/fffb9H3/PPPw2Aw4NFHH4WXlxcSEhKu+fNPnz6N4cOHQ6fT4cknn0RMTAwyMjIwZswYNDU1tddpWFizZg1mzpyJsLAwvPTSS3B3d8cXX3yBnTt32tx/1qxZWLlyJWbOnImHH34YOp0OK1aswIQJE7B69WpMmzbN5nGBgYH4/PPP8dxzzyEgIAAvvfSS1T4ffPABAgMD8Yc//AGBgYE4ffo0Fi9ejGHDhiE7Oxs9e/a84vmUlJTA2dkZPj4+1/T3QERERETdkyNc40uSBI1Gg6CgoKvan9f4RERERMTiQDvr27cvAODEiRNWfVqtFgcOHPhNw4xfeukl1NTU4JdffsHYsWMBAE888QTmzp2Ld99997o/tzVGoxHPPvssPD09sW/fPqjVagDAk08+iWHDhlntv3r1aqxYsQIffvghHn/8cXP7s88+i6FDh+LZZ5/F1KlTLd4Uusjd3R0PPPAAXn75ZQQHB9ucL/THH3+Eu7u7RduDDz6Ifv364d1338V///vfNs9n3bp12LdvHx544AG4uLhc1d8BEREREXVvjnCNv2jRIpSWluLll1++4r68xiciIiIigNMKtTsvLy8AQF1dnVXfH/7wh99002A0GvHDDz9gwIAB5puGi1544YXr/ty2ZGdno7i4GA899JD5pgEAVCoV5s6da7X/ihUr4O7ujttuuw2VlZXmr5qaGkydOhUFBQU4efLkdee5eNMgyzLq6upQWVmJwMBAJCQkYO/evW0em5eXh1mzZiE0NBTvvPPOdWcgIiIiou6lq1/j79ixA3/605/Qu3dvvPjii1fcn9f4RERERARw5EC7u3jDcPEG4lJXMxy2LRUVFWhsbLQ5VDk4OLhDhtCePn0aAJCYmGjVl5SUZNWWm5uLxsZGi5uMy5WVlSE+Pv668mRnZ+OVV15BRkaG1XyoMTExrR6Xn5+PCRMmADC9mXS1w62JiIiIiLryNX5WVhZuvfVWhISEYN26dVdVqOA1PhEREREBLA60u5ycHABAr169rPrc3Nyu6bMMBoPFtizLbe5/pf7fwtYQ4dYy+Pn5WSzWdrmUlJTrylBUVISRI0fC29sbf/3rX5GQkAB3d3cIgoA//vGPaGhosHlcQUEBxowZg/r6emzatAl9+vS5ru9PRERERN1TV73Gz87OxoQJE+Dl5YXNmzcjIiLimrLwGp+IiIioe2NxoJ0tXrwYAHDrrbde9TF+fn6oqqqyaj9z5ozFdlBQENzd3XH8+HGrfcvKylBbW3uNaa+sR48eAIBjx45Z9dlqi4+PR15eHgYNGgRvb+/r+p6t3aSsWbMGjY2NWLt2LcaMGWPRd/78eahUKqtjCgsLMWbMGNTU1GDTpk1ITU29rkxERERE1H11xWv8AwcOYMKECXB3d8eWLVvafMP+crzGJyIiIiKAaw60G1mW8dZbb+HLL79Ev379cNddd131sfHx8di9ezeamprMbdXV1fj0008t9lMoFLjllltw4MABbN682aLvX//61287gVYMGDAAERER+Oyzz6DRaMztOp0O//d//2e1/6xZsyDLMubPn2/zLaeysrIrfk8PDw9UV1dbtSsUCgDWb099/PHHFtkuKiwsxOjRo1FdXY2NGzdi0KBBV/zeREREREQXddVr/AMHDmD8+PFwc3NDRkaG+WH/1eI1PhEREREBHDlwXXJycrB8+XIAQENDA06dOoW1a9fixIkTGDx4MFavXm2+yL0aTz31FB544AGMHTsWs2bNQk1NDT7++GNERUVZXRD/4x//wE8//YRbb70VTz75JGJiYpCRkYF9+/YhICDA6o2cQ4cO4fvvvwcA7Ny5EwDw+eefY8eOHQBMF/pRUVGtZlMoFPjPf/6DmTNnYvDgwXjsscfg7u6OFStW2LwxmDlzJh5++GEsWrQIOTk5mDp1KgICAnD27Fns3r0bp06dsnpb6nJDhgzBJ598gtdeew0JCQkQBAH33HMPJk+eDDc3N8yaNQtPPfUUfH19sXPnTqxfvx49evSwGKJdX1+PMWPGoKCgAE8//TROnDiBEydOWHyfCRMmIDg4uM0sRERERNQ9OMo1fmFhISZMmIDq6mo888wz2L17N3bv3m3xebfffrt5kV9beI1PRERERAAAma7ali1bZADmL1EUZS8vLzkhIUG+99575fT0dNlgMFgd9+mnn8oA5C1btrT62W+99ZYcGRkpOzs7y7169ZKXLFnS6nGHDh2SJ02aJLu5ucne3t7y7bffLhcUFMh+fn7y5MmTbX7v1r7aynSptWvXygMGDJBVKpUcHBwsP/XUU/KRI0dkAPKrr75qtf+yZcvk4cOHy56enrJKpZKjoqLk22+/XV61apXFfgDk2bNnW7SVlpbK06dPl729vc05L9q6das8bNgw2cPDQ/b29panTJkiHz58WB41apQcFRVl3i8/P7/N876WcyciIiKiG5ejXeNfntfWV35+/lWdO6/xiYiIiLo3QZY7cBVb6jSVlZUIDAzE448/jg8//NDecYiIiIiI6DfiNT4RERERdSSuOeCAmpubrdr++c9/AgAmTpzY2XGIiIiIiOg34jU+EREREXU2jhxwQAkJCRg3bhxSUlKg1WqxadMmbNiwASNHjsTmzZuvaS5UIiIiIiKyP17jExEREVFnY3HAAc2bNw9r167F2bNn0dLSgsjISMycORMvv/xymwuPERERERFR18RrfCIiIiLqbCwOEBERERERERERERF1M1xzgIiIiIiIiIiIiIiom2FxgIiIiIiIiIiIiIiom2Fx4CqUlpbitddeQ2lpqb2jEBERERFRO+A1PhERERF1dywOXIXS0lK8/vrrvHEgIiIiIrpB8BqfiIiIiLo7FgeIiIiIiIiIiIiIiLoZFgeIiIiIiIiIiIiIiLoZFgeIiIiIiIiIiIiIiLoZFgeIiIiIiIiIiIiIiLoZFgeIiIiIiIiIiIiIiLoZFgeIiIiIiIiIiIiIiLoZFgeIiIiIiIiIiIiIiLoZpb0DENG1kSUjSrPWoyxnIwzaBnhH9UH4TTPhFhBh72hERERERHQdDLomnNv7LSqOboUsGeGfMBRhQ2fA2cPX3tGIiIjoBsbiAJEDkWUZx1e/ifPHd5nbyg9vQWXudvSZ/W94qHvYMR0REREREV0rY4sWhz6bh6aKQkCWAAAle79DxdHt6Pf7hSwQEBERUYfhtEJEDqS28LBFYQAAIBshGfQo2LzULpmIiIiIiOj6lR3chKbyAnNhAAAgS2hpqELJ3jV2y0VEREQ3Po4cIOqCdLUV0BzYgKbKYrj4BEPd/2a4+oeh+nQmBFEBWTJaHiBLqMk/AFkyQhAV9glNRERERERt0taUQVtTBle/UKi8AgAAVSf3A5Ctd5YlVJ3Yi5hxv+vckERERNRtsDhA1MXUFR/DkRUvQzLqAVkGBAHn9n2HXjNfhCgqIdu6cQAgCCIgCJ2cloiIiIiIrkTfXI8T372D6lP7L7QICEgagZ63PgtRoTBdx8vW1/l88YeIiIg6EqcVIupCZFnCie/egWRsuTCsWAZkCbJkxInv/g++PQcDkmR9oCDCv9dNpgIBERERERF1KcfTF6D6dNYlLTIqc3fg5Lr3EJA4wmZhAIKAwORRnZaRiIiIuh8+SSTqQhrL8qGt0di8OTDqGmHQ1iMsbYap4WIhQBDg5O6D6LEcbkxERERE1NU0lhegtuCg5ZoCACBLqDy6DV5RKfCNG2RqEwQAptHA7sE9EDp4WueGJSIiom6F0woRdSGSoaXtfn0Losc+DJ/ovig/tBkGbT28IlOg7n8znNy8OiklERERERFdrebzZ9volaGrKUPSXX9FxdFtOH98FyTJAL+4wQjqMxYKJ1Wn5SQiIqLuh8UBoi7EQ90DCpU7jLpGqz5BVMA7KgWCIMC3x0D49hhoh4RERERERHQtXHzUbfarvIMhiAoE9R6DoN5jOikVEREREacVIupSRKUzYsb/3rRxybRBABAx4l44uXnbKRkREREREV0Pd3UPeITG/3p9f5Egwq/nYLj4BNknGBEREXV7LA4QdTHq/pOQdPer8IpIgtLVCx7qOMTf9mdEDL/H3tGIiIiIiOgaCYKApDv/Co+QOIt27+g+iJ82106piIiIiDitEFGX5NdzMPx6DrZ3DCIiIiIiagfOnn7o+/D/oVFzGtqaMrj6h8E9KNresYiIiKibY3GAiIiIiIiIqIMJggCPkDirEQRERERE9uJQ0wq99tprEATB4kutbntxp61bt2LgwIFwcXFBbGwsPvzww05KS0RERERERERERETUNTncyIHk5GT8/PPP5m2FQtHqvvn5+ZgyZQoeffRRLF++HDt37sQTTzyBwMBAzJgxozPiEhERERERERERERF1OQ5XHFAqlVccLXDRhx9+iMjISCxcuBAAkJiYiMzMTLz99tssDhARERERERERERFRt+VQ0woBwMmTJxEaGoqYmBjcc889OHPmTKv77t69GxMnTrRomzRpEjIzM6HX61s9TqfToa6uzvzV0NDQbvmJiIiIiIiIiIiIiOzNoYoDQ4YMwbJly/DTTz/h448/hkajwU033YTz58/b3F+j0SA4ONiiLTg4GAaDAZWVla1+nwULFsDb29v8NWrUqHY9DyIiIiIiIiIiIiIie3Ko4sDkyZMxY8YM9O7dG+PHj8e6desAAJ999lmrxwiCYLEty7LN9kvNnz8ftbW15q+tW7e2Q3oiIiIiIiIiIiIioq7B4dYcuJS7uzt69+6NkydP2uxXq9XQaDQWbeXl5VAqlfD392/1c1UqFVQqlXnbw8OjfQITEREREREREREREXUBDjVy4HI6nQ65ubkICQmx2Z+WloZNmzZZtG3cuBGpqalwcnLqjIhERERERERERERERF2OQxUHnn/+eWzduhX5+fnYu3cvZs6cibq6OsyePRuAaTqgBx980Lz/nDlzUFhYiLlz5yI3NxeffPIJlixZgueff95ep0BEREREREREREREZHcONa3Q2bNnce+996KyshKBgYEYOnQo9uzZg6ioKABAaWkpioqKzPvHxMRg/fr1eO655/DBBx8gNDQU7733HmbMmGGvUyAiIiIiIiIiIiIisjuHGjmwatUqnDt3Di0tLSgpKUF6ejqSkpLM/UuXLkVGRobFMaNGjUJ2djZ0Oh3y8/MxZ86cTk5NRERERERXa8GCBRAEAX/84x/b3G/r1q0YOHAgXFxcEBsbiw8//LBzAhIRERER3SAcqjhAREREREQ3rv3792Px4sXo06dPm/vl5+djypQpGDFiBA4cOIAXX3wRzzzzDNLT0zspKRERERGR42NxgIiIiIiI7K6hoQH3338/Pv74Y/j6+ra574cffojIyEgsXLgQiYmJeOSRR/C73/0Ob7/9dqvH6HQ61NXVmb8aGhra+xSIiIiIiBwKiwNEDqqloRqN5QUwtmjtHYWIiIjoN3vyySdxyy23YPz48Vfcd/fu3Zg4caJF26RJk5CZmQm9Xm/zmAULFsDb29v8NWrUqHbJTURERETkqBxqQWIiAvRNtTi57j1U5e0FIEN0UiFsyO2IHHU/BIH1PiIiInI8q1atQnZ2Nvbv339V+2s0GgQHB1u0BQcHw2AwoLKyEiEhIVbHzJ8/H3PnzjVv5+TksEBARERERN0aiwNEDkSWZRxd+SoaNKcByAAASa9D8Y5VEEQFIkfeZ9+ARERERNeouLgYzz77LDZu3AgXF5erPk4QBIttWZZttl+kUqmgUqnM2x4eHteRloiIiIjoxsHiAFEXVH/uJM7t+xZNFYVw8Q1BSOpU+ET3QV3RETSUnrR5TMme1QhLmwGFk8pmPxEREVFXlJWVhfLycgwcONDcZjQasW3bNrz//vvQ6XRQKBQWx6jVamg0Gou28vJyKJVK+Pv7d0puIiIiIiJHx+IAURdzPm83cr95A4AAyBIaywtx/vguxE15CpJRb2q/MGrgUsaWZrTUV8LVL6yzIxMRERFdt3HjxuHw4cMWbQ8//DB69eqFF154waowAABpaWlYu3atRdvGjRuRmpoKJyenDs1L1FHqz51E+eHNMGob4RWZjMCUUVA4Xf1oGiIiIqJrxeIAURciS0acWv8+IMswFwBkCQBwZuNixN3yDGwVBgAAoggnN+9OyUlERETUXjw9PZGSkmLR5u7uDn9/f3P7/PnzUVJSgmXLlgEA5syZg/fffx9z587Fo48+it27d2PJkiVYuXJlp+fvKhqatThRXA4PVxV6hge1Or0SdU3FO79C4ZbPIIgKyLKM8sO/oGR3OnrPfgvO7j72jkdEREQ3KBYHiLqQhtJT0DfW2OyTDC0QlU5wcveFvqnWXDQAAAgiApNHQenCuXOJiIjoxlNaWoqioiLzdkxMDNavX4/nnnsOH3zwAUJDQ/Hee+9hxowZdkxpH7Is4/Of9mDVL5nQG4wAgPBAH7w0ewriwoLsnI6uRmNFIQq3fAbA9LLQRc3VpSjc8hl63vqsvaIRERHRDY7FAaKu5ApveAmiAsn3/Q3HVr6KloYqc7t3VG/0uPmJjk5HRERE1CkyMjIstpcuXWq1z6hRo5Cdnd05gbqw73cewuc/7bVoO1dZi3n/TcfnL/8O7q5cj6orkGUZ5Qd/Rsm+b6GtKYObfxjCb7oTAYnDUXl0GyCKgCRddpCEiiMZiLvlGY4EISIiog7B4gBRF+Kh7mEaGdBYg8unDxKVKnhH94VS5YbUpz9FzZlstNRXwV3dA56hPe2Sl4iIiIjs66vNmVZtkiyjvkmHX7KOY9rwvnZIRZcr2rYCxdtX4uL6YQ2a0zievgCxkx6HUa+DAMHm5KGSocU0YliwXnuDqDuTZRlGXRNEpRNEpbO94xAROSwWB4i6EEFUIO6Wp5H79T8AQQQko+lPWULspMehVLkBAESFEn49B9s5LRERERHZk1GSUF5db7NPqRBRXF7dyYnIFn1jLc7u/OrC1sV1xUx/Fm5Zhp7TnsO5vWusDxREeEUkQxBZGCC6VNWpTBRs/hRN5QWAICKg1zDETHwUKk9/e0cjInI4LA4QdTH+8UPQ7/cLcW7f92iqKICLbwhCUqfCOzLZ3tGIiIiIqAtRiCICvN1RWdto1WeUJIQF+HR+KLJSW3zUYi2BSxlbmqF08YJ3VG/UFh0xFw0giBAEEdFjZ3diUqKuryb/II6teu3XBllC5fGdaCg9if6PfwCFk4vdshEROSIWB4i6IA91D8RPe87eMYiIiIioi5s5eiA+/G6bRZsoCHBROWFcai87paJLXelhpdLFDUn3vI6zu75GWc5GGHVN8IpMQeTI++AZGt9JKYkcQ9H2L0xr9cmXrNEhS9DWaFBxZCvU/SfZLxwRkQNicYCIiIiIiMhB3T6yPyprG7Bm2wEYJdNb5wE+Hvjr7Fvg6cY3aLsC7+jeULp6wdBcD4t1xQQBLj5quAfHQhAERI16AFGjHrBbTiJHUF+SZ1kYuEhUoL4kj8UBIqJrxOIAERERERGRgxJFAY9PH4m7xg7E8cIyeLiqkBQTAoUo2jsaXSAqnJBw259x7KvXIUu/PtQUnZwRP/15CIJgx3REjkXp6gF9g631VGQ4uXl1eh4iIkfH4gAREREREZGD8/V0R1pKrL1jUCt8ewzAwD98jLKcn6Ct0cAtIALB/SbC2cPP3tGIHIq6/80o3rHq1/U5LpIkBPUZa59QREQOjMUBok6WmpoKjUYDtVqNzMxMe8chIiIiIqJO4OIThKjRs+wdg8ihRQy7Cw3nTqD6dBYgKsxTDMVNfhJuAZF2TkdE5HhYHCDqZBqNBiUlJfaOQURERERERORQRKUzku55HXVFR1FbeAgKZ1cEJI2AyivA3tGIiBwSiwNEREREREQOrqahCXlFpjUHEqNCIIqcx56IbkyCIMA7KgXeUSn2jkJE5PBYHCAiIiIiInJQkiTjk3U78U1GNowXFrsN9vPCX2ffgoTIYDunIyIiIqKuTLR3ACIiIiIiIro+327PwZebM82FAQCoqK7HC4vSUd+ktWMyIiIiIurqWBwgIiIiIiJyUN9kZFm1SbKMJm0Lfsk6bodE3VNqairCw8ORmppq7yhEREREV43TChERERERETkgoyShoqbBZp9CIaKkoqZzA3VjGo0GJSUl9o5B1C0Y9VpUHN6CmgLTgsSBKaPhHdUbgsC1VoiIrhWLA0RERERERA5IIYoI8vFEeU29VZ/RKCE8yNcOqYiIOo6+qQ6HPvszms+fBQQRgiCgLOcnhA29AzHjf2/veEREDsehpxVasGABBEHAH//4x1b3ycjIgCAIVl/Hj3OILRERERERObY7xwy0ahMFAe6uKowbmGCHREREHado2wo0V50zbcgSZMkIACjZsxp1Z/mch4joWjnsyIH9+/dj8eLF6NOnz1Xtn5eXBy8vL/N2YGBgR0UjIiIiIiLqFNNH9EVNQxO+3JwJg9G0KLHazwsvz74FHq4udk5HRNS+Ko5kALJk1S6IClQe2wav8F6dH4qIyIE5ZHGgoaEB999/Pz7++GP84x//uKpjgoKC4OPj07HBiIiIiIiIOpEgCHhoyk24Y9QAnCgug4erCgmRwZx7m4huSJKhpfU+va4TkxAR3RgcclqhJ598ErfccgvGjx9/1cf0798fISEhGDduHLZs2dLmvjqdDnV1deavhgbbi3wRERERERF1BV7uLkjtFYVeUWoWBojohuUTOwAQrB9lyZIRPrH97ZCIiMixOdzIgVWrViE7Oxv79++/qv1DQkKwePFiDBw4EDqdDp9//jnGjRuHjIwMjBw50uYxCxYswOuvv96esYnaTV3xMZQf2QKjrgneUX0QmDIKCicOGSciIiIiIqIbW9ToWajJPwDJoP91eiFBgGdYL/gnpNk3HBGRA3Ko4kBxcTGeffZZbNy4ES4uV/cwNCEhAQkJvy7ElZaWhuLiYrz99tutFgfmz5+PuXPnmrdzcnIwatSo3xaeqB0UZnyO4h2rIIgKyLKMiiMZKNmzGn1mvwUnN297xyMiIiIiIiLqMO5B0ej7u3dRvH0VavJzoHB2RVCfcQhPmwFBVNg7HhGRw3Go4kBWVhbKy8sxcOBAc5vRaMS2bdvw/vvvQ6fTQaG48j8GQ4cOxfLly1vtV6lUUKlU5m0PD4/fFpyoHTSUnkTxjlUATEMmL2quOofCrcsRN/lJe0UjIiIiIiIi6hTugVHodccL9o5BRHRDcKjiwLhx43D48GGLtocffhi9evXCCy+8cFWFAQA4cOAAQkJCOiIiUYepOLrNNGLgksIAAECWUHE4g8UBIiIiIiIiIiIiumoOVRzw9PRESkqKRZu7uzv8/f3N7fPnz0dJSQmWLVsGAFi4cCGio6ORnJyMlpYWLF++HOnp6UhPT+/0/ES/haTXtd5naOnEJEREREREREREROToHKo4cDVKS0tRVFRk3m5pacHzzz+PkpISuLq6Ijk5GevWrcOUKVPsmJLo2nnH9ENp1jrrDkGET0y/Ts9DREREREREREREjsvhiwMZGRkW20uXLrXYnjdvHubNm9d5gYjaiSzLkPQ6iE7OEAQR/vFD4BWRhLqzxwFZMu0kiBBEBaJGz7JvWCIiIiIiIiIiInIoDl8cILrRyLKM0v1rcXbX12hpqILS1ROhg6YhYvjdSL7v7zi76xuUHfwZRl0TfGL6ImLEvfAIjrV3bCIiIiIiug5GvRaVR7ejQXMKTu4+COo9Fi4+wfaORURERN0AiwNEXUzx9pUo2rbCvG1orkfRthXQ1Vei5y3PIGrUA4ga9YAdExIRERERUXvQ1VXi0GfzoKstgyAqIMsyiravRML05xGYPNLe8YiIiOgGJ9o7ABH9yqBrwtldX9vsKzuwEdra8k5OREREREREHeX0jx9AV1cBAJAlo2n6UMmIE9+/A31TnZ3TERER0Y2OxQGiLqSxLB+SoaWVXhkNJXmdmoeIiIiIiDqGQduIqpP7f11P7BKy0YDzx3faIRURERF1JywOEHUhTq6ebfYrr9BPRERE5GgWLVqEPn36wMvLC15eXkhLS8OPP/7Y6v4ZGRkQBMHq6/jx452Ymui3M+q1AGTbnYIIg66pU/MQERFR98M1B4i6ENeACLire6CxLN/yDSJBgLOHH7yjetsvHBEREVEHCA8Px5tvvom4uDgAwGeffYbp06fjwIEDSE5ObvW4vLw8eHl5mbcDAwM7PCtRe3L28IXKOwg6W1OHyhK8I1M6PxQRERF1Kxw5QNSFCIKAhNvnwcndx7QtKgAACmdXJM58ybxNREREdKOYOnUqpkyZgvj4eMTHx+ONN96Ah4cH9uzZ0+ZxQUFBUKvV5i+FgtdJ5FgEQUT02IcvblzaAb+eQ+AZlmCfYEQOQJZl6BtrYWxptncUIiKHxpEDRF2Mm384Up/8GJXHdqD5fDFU3moEJo+E0sXd3tGIiIiIOpTRaMTXX3+NxsZGpKWltblv//79odVqkZSUhJdffhljxoxpc3+dTgedTmfebmhoaJfMRNdCMuhhaK6H0s0LokKJwOSREJ2cUbTtCzSWnYHS1QshAyYjYvg99o5K1GWdP7EXBb8sQfP5EnMxrcekOVB5cwQZEdG1YnGAqAtSOLkguO94e8cgIiIi6hSHDx9GWloatFotPDw8sGbNGiQlJdncNyQkBIsXL8bAgQOh0+nw+eefY9y4ccjIyMDIkSNb/R4LFizA66+/3lGnQNQmyahH4ZZlKM1aB0mvg0LlhrAhtyNi+N3wjx8K//ihkGUZwqUjCIjISvWZA8j96m8ALvysyDKqTu5DY9kZDHh8ERTOLnbNR0TkaFgcICIiIiIiu0pISEBOTg5qamqQnp6O2bNnY+vWrTYLBAkJCUhI+HW6lbS0NBQXF+Ptt99uszgwf/58zJ0717ydk5ODUaNGte+JELXi1A/vofzIFkA2LUBs1DWhaNsKGHRNiJ3wCACwMEB0FYq2fwEIouUafbIEXW05Ko5sgXrAZPuFIyJyQFxzgIiIiIiI7MrZ2RlxcXFITU3FggUL0LdvX/znP/+56uOHDh2KkydPtrmPSqWCl5eX+cvDw+O3xia6KtpqDcoPbzYXBi5VmrkW+uZ6O6QickwN505aFgYuEhWoP9f2vwNERGSNxQGibsCgbUTl8Z2ozN0Jg5bz6xIREVHXJsuyxfoAV3LgwAGEhIR0YCKi69egOd1qn2w0oKm8sBPTEDk2J1dP2x2yDCc3784NQ0R0A+C0QkQ3OE32jzizcTEkQwsAQFA4IXbiowgZeIudkxEREREBL774IiZPnoyIiAjU19dj1apVyMjIwIYNGwCYpgMqKSnBsmXLAAALFy5EdHQ0kpOT0dLSguXLlyM9PR3p6en2PA2iVjm5t/3A8kr9RPQr9YDJpqmFLh+JI8sI6jvOPqGIiBwYiwNEN7DawiM4tf59izbZqMfpH/8LV/9w+ET3tVMyIiIiIpOysjLMmjULpaWl8Pb2Rp8+fbBhwwZMmDABAFBaWoqioiLz/i0tLXj++edRUlICV1dXJCcnY926dZgyZYq9ToGoTV4RSXDxDYG2psxyOhRBhEdIHNwCIuwXjsjBhA+7Ew2lp1B1cq9p7QHIEAQRcVOehpt/uL3jERE5HBYHiG5gpZk/AKIISJfNySiIKM38gcUBIiIisrslS5a02b906VKL7Xnz5mHevHkdmIiofQmCiMQ7X8aRFS9B31hjvj5XeQei1+0v2DsekUMRFU5IvOuvqC/JQ23hISicXRGQOAzOHn72jkZE5JBYHCC6gTVXl1oXBgBAlqCt1nR+ICIiIiKibsg9KBqDnv4U5/N2Q1tTBlf/cPj1HAxRwVtyomslCAK8wnvBK7yXvaMQETk8XokQ3cDcg6LRVJ4PWTJadogKuAVF2yUTEREREVF3JCqdEZg8yt4xiIiIiMxEewcg6m7UajXCwsKgVqvb/bMNuia01FdBvrA4U+jgaZAhAxAu2UsAZBlhg6e3+/cnIiIiIiIiIiIix8CRA0SdLDMz87qO0zfWojJ3O/TNDfAKT4R3dB8Igumhv66uEqd/+hBVeXsAyFD5BCN67MMITBqBpDv/ilPr30dL/XkAgLOHL3pMeQoeIXHtdUpERERERERERETkYFgcIHIAlbk7kfftW5CNRkAQAFmCV2QKku95DRBEHF72ArS15QBMIwZ0NWXIW/0mRKUT/OOHYtDTn6KxLB8A4B4cA0FU2O9kiIiIiIiIiIiIyO5YHCDq4nT155G35i3IksHUcGHKoLriYyjYsgweIXHQ1thYXFgQULTtC/jHD4UgKjhSgIiIiKibatEbcLSgFACQHB0CZyfeBhIRERERiwNEXV7FkQzIstG6Q5ZQlrMRkCUIosJ60WFZRqPmNGRZNk8/RERERETdy+as43gvfQsam3UAAHdXFZ6ZOQZjB/SyczK6XGN5Ac7u/gZ1RUfh5OYNdf+bEdx/IgSBSwUSERFRx2BxgKiLMzTXQRBEmwUCSa+F0sXDvADx5ZSuniwMEBERETmw1NRUaDQaqNXqa1676lhBKd5csQGXXio2Nuvw5vINCPH3RmJUSDunpetVd/Y4Dn/+F9MLP7IEXW0FTpX+P9SdPYb4aXPtHY+IiIhuUHwFgaiTpaamIjw8HKmpqVe1v0dIvPWoAACAANeACAT3m2Rah8CqW4B6wOTfFpaIiIiI7Eqj0aCkpAQajY1pJK/g2205EG1cJ4qCgDXbctohHbWX/J//Zy4MmJgqOuWHfkH9uZP2C0ZEREQ3NBYHiDrZtd7g+cUPgVtgFGA1nFhG1KgH4OIThITpz0NQKAEI5v18e6QicsS97RueiIiIiBxGUXkVjJL1CFOjJONsebUdEpEtxpZm1J/NvaQwcAlBRPXpaxsxQuTIrvVlOiIi+m04rRBRFycqlOg9awHObFyMymPbIUtGuPioETXmQQQkDgcABCaPhE9MX1Tm7oRR1wivyBR4hvW65imFmqtKUJm7E7LRAN8eA+ARmmD+DFmWUVt4COdzd0KWjPCNS4Vfz8EQREW7nzMRERERXZtmnR75pZXwcFUhMtgPABAZ5IeC0kqrAoFCFBAe5GuPmGTLFdYU4PU2dScXX6YjIqLO4dDFgQULFuDFF1/Es88+i4ULF7a639atWzF37lwcPXoUoaGhmDdvHubMmdN5QYl+Iyc3byTc9mfE3fKMaZ0BVy+rB/9Obt4IGTil1c/QN9WiaOsKlB/ZAsmgh09MP0SNngUPdQ8AQPHOr1C45TPzzUnRthUISB6FhOl/AgQRp9a9h7KcjeabE82BDfCJ6Y+ku1+FqHTqoDMnIiIiorbIsoyvt2Th85/2QtuiBwDEhQXiLw/cjNtG9kVGTp7VMZIs47YR/To5KbVG4aSCb49UVJ/Jth49IEsI6DXMPsGIiIjohuew0wrt378fixcvRp8+fdrcLz8/H1OmTMGIESNw4MABvPjii3jmmWeQnp7eSUmJ2o/CSQUnN+9rHhFg1Gtx6LN5KM3+EUZdE2SjHtWns3Bo6fNoLC9AbdFRU2EAMN2QXLgpqTy6FaVZ61F1Yg/KcjZe6Daa10Coyc9BaeYP7XeCRERERHRNftx7FB+v3WEuDADAmdJKPP/BN4hWB+Av998MdxeVuc/dVYW/PHAzkqK5GHF7UqvVCAsLg1qtvq7jYyc+BqWLx6+jCC78GTnyfrj6h7VXTCIiIiILDjlyoKGhAffffz8+/vhj/OMf/2hz3w8//BCRkZHmkQWJiYnIzMzE22+/jRkzZnRCWqJrV1t0FCV716CpvBAufiEIHTQNfnHXP+dixeEMNJ8/a9koS5CMBhRtXwmlyg2CqLC58LHmwAa4+oebblCs5kGVUX7oF4QNvf26sxERERHR9Vv1836rNkmSUdPQjC3Zebjlpt4Y3icOR/LPAQBSYkLh7OSQt4FdWmbm1a0LIMsyqk7sgSZnI/QN1fCKSELooGlw9Q/DgMf/C032j6g7mwsnN28E9x0Pn5h+5uMMzfUQlc5QOLt04JkQERFRd+KQV4VPPvkkbrnlFowfP/6KxYHdu3dj4sSJFm2TJk3CkiVLoNfr4eRkPR2KTqeDTqczbzc0NLRPcKKrUHF0G/LWvAUIAiBL0NZoUHM6CzETH0PY4OnX9Zm1hYdtP9yXJdTm58ArMsVmYQAwTUek8vS3vUAaAENL83VlIiIiIqLfxihJKD1fa7NPqRBRWHYeAODspMSA+MjOjEatKNyyFGd3fWO+Nm/QnIYm5yf0efAteKh7IHLkfVbHVJ3aj/yfP0FzZREgCPCLH4oek+ZA5RVghzMgIiKiG4nDTSu0atUqZGdnY8GCBVe1v0ajQXBwsEVbcHAwDAYDKisrbR6zYMECeHt7m79GjRr1m3MTXQ3JqMfpnxYBkH99GH/hz4JfPoVBe32FKoXK1VRssNXn7ArPsATb/YII74gUeEf3bbXft8eA68pERERERL+NQhTh6+lms88oSVD7eXVyImpLU2WxqTAAWFzrS/oWnPnpI5vH1OQfxLFVr6O5svjC/jKqTuzFoc/+DCNf0iEiIqLfyKGKA8XFxXj22WexfPlyuLhc/VDKy+dnl2XZZvtF8+fPR21trflr69at1x+a6Bo0ak7D0FRns0826lFTcOi6PjcwZTRga2SAICCo73io+98MJzfvX+c4vdAniCLCh90Jdf9JUHkFXdYvQuHsivChnJ6LiIiIyF7uGNXfqk0UBKicnDBuYKIdElFrqk7us7yevkiWUFd8FAZto1VX0fYvLrykI1vsr6stR8WRjA7LSkRERN2DQxUHsrKyUF5ejoEDB0KpVEKpVGLr1q147733oFQqYTRaP/xUq9XQaDQWbeXl5VAqlfD397f5fVQqFby8vMxfHh4eHXI+RFYERdvdYtv9ACAZ9KjM3YGzu9NRdXIfZMkI78gUhN90l/kzLn6OV3giwm+aCSc3L/R96G3TugYXimaeoQno/cACeKh7QOnigb4Pvw11/5uhcHGH6OSCgKQR6Pf7d+Hie32LrhERERHRb3fnmIG49abeFoM8Pd1d8MZj0+Ht4Wq/YGRNlq+8z2Uazp2wOb2nICpQX5LXHqmIiIioG3OoNQfGjRuHw4cPW7Q9/PDD6NWrF1544QUoFNYPTtPS0rB27VqLto0bNyI1NdXmegPdkaaqFoWlVQjy9URMKOettCcPdSycPQPQUn8eFm8HARCdXeAT3bfN4xsrCnF0xctoaagyz2Pq4heKlPvfQPTY2fDvlYbKY9tg1OvgE9MP/vFDzYUCF98QJN39Kox6HSBLUDhb3kw6e/ghbsqTiJvyZLueMxERERFdP4Uo4tk7x+He8YNwNL8UHq4q9I+PgNLGvRHZl1/8YBRs/tS6QxDhFd4LShd3qy6lq+eFewNLMmQ4uXt3REwiIiLqRhyqOODp6YmUlBSLNnd3d/j7+5vb58+fj5KSEixbtgwAMGfOHLz//vuYO3cuHn30UezevRtLlizBypUrOz1/V6Nt0ePtlRuxNeekua1XlBqvPHQLAn087Zis+xJEBXre+gyOffk3ALJpkWBRAUgS4iY/BYVz69NpybKE3K/+jpbGmgsNpjeMtNUa5H37b/Sd/W94hsbDMzS+zQwKJ1U7nQ0RERERdZYgXy8E+XKNAXtJTU2FRqOBWq1GZmamzX3cAiIRNvR2lOxZY36RB4IIUemEmAmP2TxGPWAyiratsB51IEkI6jOuvU+DiIiIuhmHKg5cjdLSUhQVFZm3Y2JisH79ejz33HP44IMPEBoaivfeew8zZnCe9P+XvgXbD56yaDtZXIaXP/4OHz5/f6trMlDH8u0xEP0f+38ozVyHxopCuPioETLwFniG9jTvI8sSWuqroHB2gdLFNO1VXdExaKtLrT9QllBffAzNVSVw9QvrrNMgIiIiIuo2NBoNSkpKrrhf9LjfwzMsEZqcn6BvqIJXRDJCB0+Hq1+ozf3Db5qJhnMnUXVy74X1CmQAAuKmPAW3gMj2PQkiIiLqdhy+OJCRkWGxvXTpUqt9Ro0ahezs7M4J5CDqGpvxS2YupMveQDFKMs6cq8SRM+fQuwcfJNuLW0Aketz8B5t9Fce2o+CXT6CrLQcgwK/nIPS4+QnoG6vb/MyWhmoWB6jb09VV4nzebkiGFvjGDoB7cIy9IxEREVE3IggCAhKHISBxmM1+WTKi6fxZKJxc4OITDFHhhMS7/or6kuOoLTgI0dkVAYnDofK0vX6e1efJMupL8mBoroOHOg7Onn7teTpERETk4By+OEDXp7y6Hkap9QWxSiprWBzogs6f2Iu81W9e0iKj6lQmGpfNQ9Ldr7Z6nKBQwi0wquMDEnVh5/avxZmNH1184Q4Fv3yCoL7j0fOWZ65qsW8iIiKijlR+eDPyf14C/YVpQj1C4tBz6nNwD4qGV3givMITrY7R1paj4vAWtDTWwDOkJwKShkNUOgMAGssLkPvNG9BWnTPtLIgIGTgFsRMf47UPERERAQBEewcg+wjy9YJCbH3aoLAAn84LQ1etaPsXwOXTPckSdLXlqD93AgFJI637ISAk9VY4uXIdCeq+6s+dxJmfPrwwX69snre3/ODP0GT/aN9wRERE1O1VndyHE9+9Yy4MAECD5gwOL3sB+qZam8dUHtuOrA8eQeHW5dBkrcOJ799B9kdPQFd/HsYWLY4sfxHaas2vB8gSSjPXoXjnVx18NkREROQoWBzoprzcXTBhUBLEyx4ki6KAHqEBSIm1Pecl2Vej5oz1YmQwLWTcUHoS8dOeQ+igaea3hRTOrogYcQ9ixv2us6MSdSllBzeaFve2oTRrfSenISIi6vokScauw6ex4PMf8bdPf8C6XYehazHYO5bDM+ia0FxVAmOL1qK9eOdXNl8CMugaUXbwZ6vP0TfVIu+7tyFLRkCWTH8C0NaU4fSGRajM3WEqKsjSZUfKOLfvO/P+RERE1L1xWqFu7Mk7RkOnN2BLdp65LTFSjZdn38LFiLsAo16LlvrzcHL3hVLlBgBwcvW0+eaQLMtwdveFqHRG7MTHEDVmNgxNdXBy94GodOrs6ERdjr6xBpAuvzm+pI+IiIjMJEnGv1ZswObsPIiCABkyth86hbU7D+Gdp2fC3UVl74gOx6jXIX/Txyg7uAmy0QBR6YyQQVMRNfpBiAolGsvybb4EBAimvstU5u6CbLRRrJElVOXtgatfKARRYbMIYGiuh7GlGUoXj3Y4MyIiInJkLA50Yy7OTnhx1mQ8cuswFGqqEOjjieiQq1vYijqOLBlRmLEM5/avhaTXQVAoEdRnPGInPgr1wCko3rHK5o1DUJ9x5v+tcFJB4R3YmbGJujSPkJ44n7fbtN7ApQQRnmEJdslERERkb/nnKvFzZi7qmrRIjgnFmP4JUDkrsefYGWy+8AKRdMl1Z35pJb7enIWHptxkr8gO68T3/4fzx3eZ3+SXDC0o2b0akl6HHjf/ASqvADSfP2vzWJVXgFWbUdcICKKNkQEAIEPlGdDq6AClqycUF14+IiIiou6N0woRgny9MCgxmoWBLuLMpo9xdlc6JL0OACAbDSjL2YgT376DiGF3w6/nENOOgunHV1AokXDbn+HiE2yvyERdnrr/JChdPc0/NwDMQ/fDh91lp1RERET28+22HDz27+VI35qNTfuP4Z1Vm/D4v5ejur4R23JOQrSxPpkky/gl67gd0jq25qpzOJ+7w+YUP5rsH6FvrEXIoKm2DxaA4H4TrZq9IlNaKQwAKu8gBPUbDyd3H8trnwvCht4BwUY7ERERdT8cOUDUheib6qDJWg+r15tlCefzdkFXW46ku/6K+nMnUFt4GEqVG/x7DYOTm5dd8hI5Cic3b/SZ/W+c/nERagtyAABuAZGIGf8IvMIT7RuOiIioHTTrWnDmXCU8XFWIDPZrc5rQc5U1+GBNBgDAKP163VlaVYvF3+9Ai8EI2eYUN4DewLnqr1Vj2ZlW+2TJiKbKIoQMnILmymKUZv5g7hOdVIifNheuftbrwXmGJcA3bhCqT2f+OqpYEABZRvTYh6F0dkPvBxYgN30BmiuLTN2iAiGDpiH8ppnte4JERETksFgc6GYatTr8uOcosvIKoXJSYsyABIzo09Pmm0HU+Zoqi9pcHKyh7Axc/cPgGRoPz9D4TkxG5Pjc/MPR+4E3YNA2QDLo4eTuw/VViIjI4cmyjC9/ycTyjXuh05vmoI8NDcD8Bya3OjI448AJiIJgMWUQYFprIONAHp66Ywy2HzxpdZwoChiaHNv+J3GDc/Zse4S2s6cfBEFEj5v/gLAht6Gm8DAUTir4xg0yrz0myzKaq0oASYJrQDgEQUTizBdRtG0lNAd+hKG5Hu5B0YgceT/8E9IAAG6BkRjw+H/RqDkNfVMdPNQ94OTu3eHnS0RERI6DxYFupLahGc/+50ucO18DWQZEQcDOw6cxpn8C/vLAzSwQdAHOHle4cfDw66QkRDcuLr5HRNS1LFq0CIsWLUJBQQEAIDk5Ga+88gomT57c6jFbt27F3LlzcfToUYSGhmLevHmYM2dOJyXuWtbvPoIl63ZatBVozuP5D77BspcfhpuLs9UxzS16U4HcxugAg1HCyL498cOuQzhzrtJcQBBFAR6uKtw7flDHnMgNzDOsF1wDItB8vsRyKiBBhFd4Ilz9wsxNLr4hUPuGWBxfW3QEp9a9ZzoegLNXAHrc/AT844cgeuxsRI+dDVmWbE4VJAgCPELiOubEiOiaGfU6GJrr4eTuA1HBR3JEZH+caLAb+WLTPpRW1ZrvAS5e6G85kIf9uQX2C0Zmrn4hpvlDL7+wF0S4+oXBK4LTnxAREdGNJTw8HG+++SYyMzORmZmJsWPHYvr06Th69KjN/fPz8zFlyhSMGDECBw4cwIsvvohnnnkG6enpnZy8a1j1y36rNkmSUdvYjM3ZttcH6BcXDqNkPV+9IAiIjwiGp7sL3nnqTtw3YTBC/b0R4O2BKUNT8N+59yHYj9NZXitBEJB051+h8gq82AIAcPUPR8Lt89o8trnqHI6seBnNVefMbS1155H79d9RX/Lrf1+uIUBkf/XnTuDE9+/i0LIXcHrDIjRdmNILAIx6LU79+F/seftu7H9vNva9ez+Kd34FuZW1Q4iIOgvLlN1IxoE8SJL120EKUcD2QycxJDnGDqnocgm3/RlHV/4VTRVF5nlDVZ7+SLz7FV70E10jWZZRX5KH6tNZEBVK+CcOg5t/uL1jERHRJaZOtVyI9Y033sCiRYuwZ88eJCcnW+3/4YcfIjIyEgsXLgQAJCYmIjMzE2+//TZmzJjRGZG7DKMkQVNVZ7NPqRBRVFZls69/z0j07xmBnFNnzWsLiBem2ntk6nAAgJuLM2ZPTsPsyWkdkLz7cfUPQ+qTH6P6dBa01Rq4BkTAJ6bvFa/vSzN/ME07ajHKQwYEBc7uWYPEGfM7NjiRg5IlIwzNDVC4uEFUOLXLZxpbmlFxdBu01efg4hOCgOSR5qm/yg9txonv3wFEEZAk1J/NhSZ7A5LueQ2+sf2Rt/otVJ3abx49ZNA2oHDLZ5AMekSNur9d8hERXQ8WB7oRo43CAGBa+tZgZLW6q1B5BaD/Yx+gJv8gmiuLofIJgm+PVA45JLpGsmTEie/eQcXRraaLdBkozFiGyFEPIHLEvfaOR0RENhiNRnz99ddobGxEWprth9K7d+/GxIkTLdomTZqEJUuWQK/Xw8nJ9kMgnU4HnU5n3m5oaGi/4HaiEEX4ebmjqq7Rqs8oSVC38pa/KAr4+yPTsfLnffhx7xHUN+mQHBOKBycNRe8eYTaPod9OEBXw6znYZp8sS6gtOGx66OgXBu+oFAiCiIayM5ZTEV0kGdGoOd3BiYkcjyzLKNmzGmd3fwNDUx1EJxVCBk5B1OgHISqtp1m7Wo3lBTi8fD4MTXUQRAVkyYiCLUuRcv8bcPENwakf3zfteGFUlmktQQEnf1iIpLtfRdXJvTY/t2RPOsLTZkDh7HLd2YiIfgs+bexG0lJisXH/MavRA5IkYyhHDXQpgiDCN7Y/fGP72zsKkcMqzf7RVBgAzBfpAFC0dTm8I1PgHdXbTsmIiOhyhw8fRlpaGrRaLTw8PLBmzRokJSXZ3Fej0SA4ONiiLTg4GAaDAZWVlQgJCbF53IIFC/D666+3e3Z7u2Nkf/zvhx0WbYIgQOWkxPjURMiyjD1H87Fx/1HUNmjRu0cYpg3rC39vdzw05SY8NOUmOyWni7S15Ti68lU0XzIFiVtgFJLv/RtcvINQf+FBpAVBhMo7qJOTEnV9xdtXomjbCvO2pNehZO+30NVWoteMv1zXZ8qyjOPp/4Sh2VRUvvjzaNA24vg3/0T0+N9B0utsHYmWukqcz9vd6mdLeh2aq0rgoe5xXdmIiH4rzlHSjdw/cTA8XV0sFh4WBKB3bBiG9+EiVUR0Yyk78JPtDkFE2cGfOzcMERG1KSEhATk5OdizZw/+8Ic/YPbs2Th27Fir+wuCYLF9cWqcy9svNX/+fNTW1pq/tm7d2j7h7WzmmAGYPrwvLj11Hw9XLHj8Nni5u2Lx99vxypLvsevIGRw+U4JVP+/HY//+HGfLq+0XmsxkWcbxb/6J5vNnLdqbKotxfPWbUA+YYl0YAABZQuigqdbtRN1ES0M1Ko/vRPXpbEhGAwDTtD9nd31tvbMsozJ3O5ou+zmzpamiCKVZ61B+eDMMWtOorEbNKesFxQFAlqCt0aC5su3PVarc2+x3cvO+Yi4ioo7CkQPdiNrPG//90334eksW9uXmw8XZCeMG9sL04f2gVCjsHY+IqF3pm2ptd8gS9M2252cmIiL7cHZ2Rlyc6WWV1NRU7N+/H//5z3/w0UcfWe2rVquh0Wgs2srLy6FUKuHv79/q91CpVFCpVOZtDw+PdkpvXwpRxFMzxuDucak4VlAKD1cV+saFQ6lQ4HRJBb7JyAYA8+hhSZbR0KzDR99vw98fmW7P6ASgsTwfDaUnrTtk05zlCpUr4qY8jdM/LYJ84QEoBBFRo+6HfwLXg6DuR5ZlFG5ZirO7V5sf1ju5eSPh9hegULlBMrS0emxDyYlW1x+TJSNOrl2I8sObzW2iUoX42/4EhbNbm5lcfNQQFMpff0Yv4eTmjeD+N6NkdzpaGmssCwyCCJ+YflB5BbT5+UREHYnFgW4myNcTT94xGk9itL2jEBF1KK+IZFTm7rB+w0cQ4BWeaJ9QRER0VWRZtlgf4FJpaWlYu3atRdvGjRuRmpra6noD3UGgjydG9fO0aNt5+BREUbA5rejeY/nQG4xwUvIlIXtqqau8Yr96wM0ISByG6tNZkCUJPrH94Ozh10kJiboWTfZ6nN31jUWbvrkOx758DSmzFrR5rJN762/ol+xZjfLDWyzaJIMOeav/hb4PLzSvM2BFEOEd3QfRYx9G/qaPAUE03X+IIiDJ6HHzH6B0dkHS3a/gyMpXYGiqM+/j6h+O+KnPXf3JExF1ABYHiG5AVzO0nuhGFz7sTpzP222qDVwsEAginNy8oO4/ya7ZiIjoVy+++CImT56MiIgI1NfXY9WqVcjIyMCGDRsAmKYDKikpwbJlywAAc+bMwfvvv4+5c+fi0Ucfxe7du7FkyRKsXLnSnqfRJUmSjNauBmUZkCG30kudxS0wqo1ewdyvdPVEYMroTslE1JWV7P3WulGWIRkNqM3PgVdkCuqKj1m9oe/s7gOfmH6tfu65zB8AG78TZVnG+RO7ETrkNpTsTrfqDx00Fc4evggbchtc/cNwbv9aaKtK4R4cjbAht8MrwrR+jkdITwx6einO5+1GS10F3IKi4Rs7AILIAi0R2ReLA0Q3EG11KQq2fGZe8Miv5xBEj50NV78wOycj6nwewbHoPWsB8n9egvqzuYAgwK/nIMROeJTzehIRdSFlZWWYNWsWSktL4e3tjT59+mDDhg2YMGECAKC0tBRFRb8u1BoTE4P169fjueeewwcffIDQ0FC89957mDFjhr1OocsakhyDFZv2WbWLgoB+PSPgrOTtYGeqO5uL0swf0Fx1Dm6BUQgdNBUe6h4ISBppPdpREBCYMprTjVC3o1arLf68nK623Ga7IAjQ1pQhfvqfcGT5i9BWl5rf9leq3JB41yttPojXN9TY7hAEtDScR9yUp+Dk5o2SPauhb6yBk5s3wobejrC0X//t8YsbBL+4Qa1+D4WTCkEs8hFRF8OrQaIbREt9FXI+nQtDc4P5xuJ83m7UFhxE/8c+4I0FdUte4Yno+9DbMLZoIYgiRKWzvSMREdFllixZ0mb/0qVLrdpGjRqF7OzsDkrUtVzpQVlbekWqMWFQIjbtz4UgmEYLiKIAZ6USj04b3t5RqQ1lB3/GybXvAoICkI1o0JxG+aFfkHjnS+g59Y9QqFxRfvBnyJIRgqhEcL8JiJ34mL1jE3W6zMzMNvtd/cPRVF6Iy9/yly9M0+PiHYQBcz5E1cm9aCovhMo7CAGJw6Fwdmnzc92Do9GgOW36RXkpyQiP4FgIgojwtBkIG3oHJIMOolLFkfpEdENgcYDoBnFu/1qLwgAAQJZg0DXh3L5vETP+EfuFI7KzK90MEBERdVVXelDWFkEQ8Pw9E9GnRzg27D2K2oZm9I0Lx8wxAxAe6NuOKW2TZRkHT53FL1nH0axrQd+4CIxPTYSrqnutDWFsacbpDYtMG/KFOcslIwABp9b9Pwx+dhl63vIMYsY+DF39eai8AqB0uTEWzCZqb+FpM3Hiu7ctGwURCmcXBPcdDwAQFUoE9BoG9BrW6udIRj0gA6LS9PsoYvg9yP36H1af6+TmjcDeY39tEgQonHhvQUQ3DhYHiG4QNQU51guvAoAsoSb/YKfnISIiIiL7E0UBNw9Jxs1Dktv9s1v0BnydkY0Ne46gUatD3x7huH/iEMSFBwEAPl67A19vyYJCFCDJwNack1iz7QDeffoueHu4tnuerqq28DAkvdZGjwx9Yw0aSk/CM6wXlK6eULp62tiPiC4K6j0G+qYaFGYsN/9cufqFIOG2P1/V1KHa6lKc+XkJqk7sBWQJXpG9ETP+9/BPSEP8tD8hf/Mn0DdUAwC8IpLR89anoVS5deg5ERHZE4sDRDcIpYsHzOPFLyUIULq42ycUEREREXUao1HC9kMnsePQKRglGUOSYjB2YEKHrC0gSTJe+d/3yD5ZZL783HX0DPbmFuCdp2ZClmV8vSXLlEv69fq0pLIGy37ag6dnjGn3TF2VfPn1+TX2E5GlsCG3Q91/Mho0p6FQucI9KOaqpvjRN9Xi4NLnoW+qM79YV1d8FIeXzUPf3y9EUJ+xCEwZBW2NBgonVzh7+nX0qRAR2R2LA0Sd7LfMG9uWoD7jUHPGxty7soygPuPb9XsRERERUddiNEp49ZO12HssH6IgQIaMHYdOYf2ew3jrDzPg4ty+U/lknShE1okiizZJkgFZwic/7ERsaCAUogijJFntsznreLcqDnhH9YaoVEEy6Kz6nNy84RHS0w6pqDXl1XXYmnMSOr0BA+IjkBgVwrnluyCFswu8I69tRJQm+0fom2otX6iTJUhGA87u+gYJ0/8EQVTA1S+sndMSEXVdLA4QdbLfMm/spRrLC6Crq4BbQCRcfIIRmDwSNWeyUX7oFwiiAgAgS0YEJo9CUJ+xV/g0IiIiInJkm7OPY++xfACAdMmDr+OFGny/4yDuGpvart8vO6/I9sP/C+sMhAb6tHpsi97Qrlm6OqXKDbETH8Wp9e8Dgmh6Y1lQAJDQY/ITEBW8Le8qvt2eg/+uyQAgQBCAz37cjeF94vDSg5OhVCjsHa9bSE1NhUajgVqtvq57Z1ky4uzudJTuX4uWxhq4B0UhYvi9CEgchrriXOuR9qaDUFd4uB3SExE5Hl6FEDkYXf15HE9fgPqzuea2gMQR6Dntj+g59TkE95uI83l7AMjwjx8Kr8gUvulCRERE5KCu9kFZxoETNmeYlGVgS3bedRcHZFnG4TMlOHjqLNxUzhjZrycCfTyhclJChu3pcJRKBVITorB+9xGrPlEUkNor6rqyODL1gMlw8QvFuf1roa06B7fAKIQNmQ7PsF72jkYXnCopxwerMy5syeafpZ2HTiE94wDuHte+BTayTaPRoKSk5LqPP7H2XVQczgAu/H5qLCvA8fR/oufU50xrelws0FkQoHTzuu7vSUTkyByqOLBo0SIsWrQIBQUFAIDk5GS88sormDx5ss39MzIyMGaM9XDV3Nxc9OrFizDq2poqitB0vhgu3sFwV/eAIAiQZRnHVr2GxvICi30rj++E6OSM+Glz4R2ZAu/IFPuEJiIiIqJ2dbUPyvQGo80XYgGgxWBs9TiD0Ygdh04h+0QxVE5KjOoXj5TYUNNxegNe+2Qt9h8vNC8qvPj77Xj2rnEY1S8eKzbts/o8URQwpn88bkrpgd6xoTiSX2qeU18UBTgpFZg9Oe0qzvzG4xPdFz7Rfe0dg1qxcd8xKETBYo0MwPSIed3uwywOOICmiiJUHN5yWavpv2fB5qWIn/YcKo5c3m/aR91vYofnIyLqihyqOBAeHo4333wTcXFxAIDPPvsM06dPx4EDB5Cc3Ppcc3l5efDy+rUKHBgY2OFZia6XQduA46vfRM2ZA+Y2j9B4JN75MnQ1ZWgsO2N9kCyh/PAWxIz/PZzcvDsxLRERERF1BYOTYpBzqtiqQCAKAoYmx9g8plnXghcWrUZuoQYK0TTS9NvtOZg5egAemzYCK3/ej8w807oCFx+YygAWfvUz/vfCg3jw5qFYtmEPFKIAWTZNKRTs64Xf3zocCoWIfz5+O77ekoWN+46hWadH//gIPDBxCKLU/h3290B0veoata0W2Gobmzs3DF2RLBmhq62A6OwCZ3cfAEBtUetTA+kbq+Hio0bE8HtQvGOVaQSBIACSEQFJI6EeYPulUyKiG51DFQemTp1qsf3GG29g0aJF2LNnT5vFgaCgIPj4+HRwOqL2ceL7d1GTf9CirUFzCrlf/R3qgbe0fqAsQVdbweIA0WUkgx4NmlMQFcoLo3BEe0ciIiJqd1OGpuDHPUdwtrzavOaAKArw83THzNEDbB7z5eYs5BWVAYDF29LfZGRjaHIM1u85bH7r/1KiIGBTZi5+f8swDEyIxKb9uWho1qF3bBgmDEqEq8oZAODi7IRZk4Zi1qSh7X26RO0uITIYm7OOW7WLooCk6BA7JKLWVBzdivxfPkFLXSUAwDu6L+KmPA2Fs1ubxymcXRE1ehYCkkfifO5OyEYDfONS4RmeyKl4iajbcqjiwKWMRiO+/vprNDY2Ii2t7WGp/fv3h1arRVJSEl5++WWbUw1dSqfTQafTmbcbGhraJTPRlehqK1B1Yo91hyShofSkjbkRLyGIUHlzVAzRpcoO/oz8TR/DoDX9Hld5B6Hn1D9ySD8REd1w3FycsfCZu/D1lixkHDgBoyRheO843DU2Fb6e7jaP2bT/mMXixRcpRAGbs/JQ16ht9fvVNZjepE6KDkVSdGj7nASRHU0clISvNmehqr4R0oVimSAAkIH7Jwyxbzgyqzq5D3lr3rJoqy08jEPL5qHv796F6KSCpNdZHiSI8IpIhrOnHwDAPTAK7oHdb+0TIiJbHO71ycOHD8PDwwMqlQpz5szBmjVrkJSUZHPfkJAQLF68GOnp6Vi9ejUSEhIwbtw4bNu2rc3vsWDBAnh7e5u/Ro0a1RGnQmRFW1vWZr/o7Ar34FhAvOxHVxAR1HsMRw0QXaL6zAGcXPuuuTAAALq6Chxd+Sq01aV2TEZERNQxPN1c8LtbhmHZyw9jxSu/xx9uHwV/b9uFAQBo1ulttssy0NyiR69INUQbb9MaJRm9otTtlpuoK3B3VWHhM3dhaFIMLv7fPjYkAAsev928DgfZX9H2lcDlv5dkCfqGKlSd2IOE2/4MQVQAgmj6E4CTuw963vqMHdISEXV9DjdyICEhATk5OaipqUF6ejpmz56NrVu32iwQJCQkICEhwbydlpaG4uJivP322xg5cmSr32P+/PmYO3eueTsnJ4cFAuoUrr6hpgudVia7dAsIR9I9r+F4+gLUn801twckDkOPyU90Vkwih1CyO900l+ilI25kGbJkRGn2j4gZ9zv7hSMiIupEe46ewVebs1CoOY+QAG/cMbI/xgxIwMCESGw7eNL8lvRFkiyjX88IqP288JcPV1tcnoqigGBfL4wZkGDjOxE5tmA/L7z++2nQtuhhMBrh4epi70h0mcayMzbvlwVRgUbNaYSm3orUJ5eg7NAvaKk/D/fgWASmjIJS1faUQ0RE3ZXDFQecnZ3NCxKnpqZi//79+M9//oOPPvroqo4fOnQoli9f3uY+KpUKKpXKvO3h4XH9gYmugbOnHwKTRqHi2DbLB5oXhkF6BMcCAPo+9DYaKwqhq62AW0AkXHyC7JSYqOtqqiyyPRWXLKGpoqjzAxEREdnB+t2H8e5Xv0AUBEiyjPpiLRYs34DS87V4YOIQ7D56BnqD0VwgEAUBEcF+GDegF1TOSvz9ken4eO0OFGrOQxQEjOgThzm3jYKLs5Odz4yo45j+/83/j3dFTu6+aKmrsGqXZRnOHqZpg1TegYgccU9nRyMickgOVxy4nCzLFusDXMmBAwcQEsLFhKjrirvlaciQUXl0GwDTTZpv7ADET/+TxX6cJ5GobS4+arQ0VFsXCAQRLr6cCoGIiG4szboWnC6phIerClFqPwiCAF2LAYu/3w4A5rUFLr5wu3zjXtx6Ux/8vz/eg2Ub9iDzeCGcnRQYN7AXZk0aCpWz6VZxSFIMBidGo1Grg7NSCWcnh7+FdDiVuTtxbt930NZo4BYYhfChd8Antr+9YxHZRWjqLSjY/Bku3itfKrjv+M4PRETk4Bzqyu7FF1/E5MmTERERgfr6eqxatQoZGRnYsGEDANN0QCUlJVi2bBkAYOHChYiOjkZycjJaWlqwfPlypKenIz093Z6nQdQmhbMLet0+D7pxv0Nz1Tm4eAfxQSbRdQgdMh11xUdt9qkHTO7kNERERB1DlmV8+Usmlm/cC53eAACIDQ3A/Acmo1GrQ6O2xeZxBqOEQ2dKMKJPHF59+NY2v4cgCJxexU6Kd36Fwi2fmadKbGmoRs2ZbMRP+xOC+oy1dzyiThc29A40lheg4kgGANOK0YLSCfFT58LFly+CEhFdK4cqDpSVlWHWrFkoLS2Ft7c3+vTpgw0bNmDChAkAgNLSUhQV/TpVREtLC55//nmUlJTA1dUVycnJWLduHaZMmWKvUyC6aiqvAKi8Auwdg8hhBfQahuixD6Nw6+eQjaaHJQqVG3re+keOuiEiohvG+t1HsGTdTou2As15PP/BN1d86K9yUnRkNPqN9E21KNq6wrRxcSTkhT/PbFqMgOQREBWc+oa6F0FUIOG2PyP8pjtRW3gICmdX+McPhdLV097RiIgckkMVB5YsWdJm/9KlSy22582bh3nz5nVgIiIi6srCb5qJ4P6TUFt4GKJCCe/ovlA4qa58IBERkYNY9ct+qzZJklHb2IwCTSXUfl4oq66HfMkCngIAd1cV+sVFdGJSula1hUcgSwabfYbmejRqTsMzrFcnpyLqGtyDouEeFN3un9tUUQTNgQ3Q1pTBLTAS6gGT4eLNNf6I6MblUMUBIiKia+Xk6omAXjfZOwYREVG7M0oSNFV1NvuUChHF5dV44f5J+MuHa6A3GCHLMkRRACDgz/dN5PoBXZygaPu/j8BRA0TXRJZllGb+gJI9q6Grq4CLjxrhaaaXiQRBQOWx7Ti+5i1AEADJiKqT+3Bu73dIuf8f8IpIsnd8IqIOwatBIqLrJEkyjhWUorFZh/jIYPh6utk7EhEREXUjClGEn5c7quoarfqMkgS1nxdSYsPwyfzZWL/7MIrKqhDi743JaSkID/S1Q2K6Fj4xfaFwdoWxpdmyQxCg8gqEe3CMfYIRdWFVp/ajZHc6miqK4OIbgtAhtyEwaQQAoHDLUpzd9Y15X211KU6t/39oaaxB2JDbcOKHhaapuy4OtJIlSMYWnPj+/zDwiY8hCELnnxARUQdjcYCI6DrkFZXh75+tQ9mFt/UUooDbR/bHo1NHXHgjj4iIiKjj3TGyP/73ww6LNkEQoHJSYnxqIgAgyNcTD03hKLqOpFarLf5sDwonF/S89VkcX/OvC28yS4AgQhAViJ82F4Igttv3IroRaA78hFPr3jMv4K1vrkPe6jehrS5FcL+JOLtntc3jzu78Ei6+akgtWutOWYa2uhRNFYUdMo0REZG9sThAVgxGI/QGI1ycnVgZJ7KhoVmLFz5cjWZti7nNKMn4JiMb/t4emDl6gB3TERERUXcyc8wAVNTU4/udh8zrCvh4uOKVh26Bl7urndN1H5mZmb/5M2RZRqPmNPRNdXBXx8LZ3QcBSSPQPyACmuwfzXOghwyYDBffkHZITXTjMOp1yP/5f6YN8wLept+JRdtWQOUdZCqw2SAZWtBcWdzm50sGfbtlJSLqSlgcILOGZi0Wf78DP2fmQm8wIiLIFw/fMgwj+sTZO1q3pKurRPP5Erj4BPHiv4vZnJWHpmYdZBt932zJYnGAiIiIOo1CFPHUjDG4e1wqjhWUwsNVhb5x4VAqFPaORtegqbIYx9P/iaaKIlODICIk9VbETngE7kHR6HHzH+wbkKiLa9SchlHXZLNPNhqgrdG0ebxXZDIgijYLCEpXL7gHR7dHTCKiLofFgRtIamoqNBoN1Gr1Nb+5YpQkvLBoNU6drYB0obp+trwaf/v0B7zy8K0sEHQiY4sWJ3/4DyqPbcfFyQ59Ygcg4bbn4eTmbd9wBAA4V1kDhUKEwWh94Xi+rhEGo5E35ERERNSpAn08Maqfp71j0BXIsgRjixYKZ1fzKG3J0IIjy19ES2PNJTtKKN3/PZzcvBA54l77hCVyIFdaoNsjOBbOnv5oaaj+dWQBAAgiXHzV8Inpj8jh96Jo2wrTNF6ybJ6eKHbCoxC5ADgR3aA4SeENRKPRoKSkBBpN2xVxW/YdK8CJ4nJzYQAwPZYWACxdv6v9QtIVnVr3/1CZuwO45L30mvwc5H7zT/uFIgthgb42CwMAEODtwcIAEREREVmQJSOKtn2Bve/ciz3/vhP7Fj6Akj1rIMsyKo/vQktDleUDywtK9q6BLBntkJjIsXiE9DBNHWRjamSliwd8Yvqh1x1/gejkDAgCBFEBQIDC2RW9bn8BgiAgYsS9SLh9HjxD4+Hk7gPvqN5IvvfvCOoztvNPiIiok3DkAAEAjhWWQiGKMF42hE4GUFRWhWadHq4qVso7Wkt9FSqObgUun7BGllBXdAQNZWfgERxrl2z0q7EDEvDp+l1obNZZFNQA4K6xA+2Uqvv5LaOliIiIiDrT6Q2LoMnegIvX+frGGuT//D8YtA0QRAUEUWGzCGDUNsKgbeAIYqLLNJSeQk3hISidXeHf6yY4uXkjftpcHF35CiSjwVRsE0QIgoCe056DqHSGV0QSBj31CcoPbUZz9Tm4+ocjuPdYKF1No64EQUBg8igEJo+y89kREXUeFge6GaMkYe+xfBw4UQxnJwVG90tAz4ggeLm5WD3kvMhZqYCzkm9Cd4bm6nOwKgxc2n++hMWBLsDdVYW3nrgDb3y2HmcragAASoWIu8am4rYR/eyarTu5OFqKiIiIqCvT1VZYFAYudXZ3OnpMmtPq6ACFyh1KF48OTkhdQVVdI77ekoXdR85AqRAxZkAC7hjVH64qZ3tH61IkowF53/4b53N3mKf/Ob3hQ/Sc+kcE9R6DAXM+gib7RzSdL4aLjxrqATfDzT/cfLyTmzfCht5uxzMgIupaWBzoRnQtBry4eA0OnS6BQhQByPhqcxbunzAYU4f1xZIfdsJ4WYFAFARMGJQEhYIzUHUGFx/1b+qnzhMXFoRP5s/GieJyNDRr0TM8GF7uLvaORURERERdTP25E2jtBSDZqIfKOxhO7j7QN9VdNrWQgNDB0y9Mf0I3sqq6Rjzxzheorm8yv7T32YY92Hn4NN59+i6onPno5qKS3ek4n7vTtHHh70qWDDjx/TvwDEuAq18oosfOtmNCIiLHwie+3chXmzNx+Mw5AKYRBEbJ9A/pik37UHq+Fn95YBIUomnYnal4APQMD8KjU4fbLXN3o/IKgF9Cmmnho0sJIjxCesIjhAtDdyWCICAhMhgDE6JYGCAiIqIup7y6Dgu/+hl3vbIY973+P3z8/XbUN2ntHavbuThlSWucvfyQ8sA/4eoX8mujIEI9cAoiR9zTwemoK/hqcyaqG5os1wCUZZw8W46fM3PtmKzrKc1aB9vFNgHlB3/u7DhERA6P5edu5Kd9RyHbmDpIIQr4JSsXz945Dr1jw5FxIA91TVokRYUgNTHKXCigzhE/9Y84vuYt1JzOMrd5hsYjceZLEGwsrkREREREdLny6no88X8rUd+khXThpaBvMrKx51g+3n/uHk5V0om8I5Oh8gqErv685cgAQYR7UDTcAiIhCAIGzPkIDedOQN9UCw91HJw9/ewXmq5bQ7MW9U06BPp4QKmwHPXRrGvBriNnUNvQjF5RaiRGqSEIAnYdOWP+Ob2UAGDPsXzcclPvTkrf9emb6my2C4KAlsbqTk5DROT4WBzoRpp0LTbbZRlo1Jr6/L3dMWP0gM6MRZdRungg5d6/oamyGM3nz0LlHQQPdQ97xyIiIiIiB/L1liyLwgAASLKMorIq/LT3GG4b2c9+4boZQVSg18yXcPSLl80LEMuSEU7uPki44wXzC0CCIMAzLMHOael61TU2471vtmD7wZOQZBle7i64f8IQ3D6yHwRBQPaJIrz2yVo06/QQBAGyLGNAfCRe+91UKFubxlcQWu/rpjzUPVB/Ls88pdBFsmSER0hPO6UiInJcLA50I33jIrDryGmrNxIkWUafHmF2SkWtcQuIgFtAhL1jEBEREZED2nvM9pvIALD/eAGLA53MM7QnUp/+FJVHt0FbUwbXgHAEJA6Hwkll72h0DWRZRm5hKTRVdYgK9kePsEAAgCTJ+MuHa3D6XIV5aqC6Ri0WfbsVoiBgXGovvLrke+j0BvPnAEDOyWL874cdGN0/His27rOYVujifiP6cmrZS0WOvBdHV75q2SiIcPbwRWDKaLtkIiJyZCwOdCMPTByCvcfyAVkyX3SIooAQf2+MG5ho53RERERE1B0tWLAAq1evxvHjx+Hq6oqbbroJ//rXv5CQ0Pob1BkZGRgzZoxVe25uLnr16tWRcR2Gs9L2rZ4oCFzc1E6UKjeoB9xs7xh0ncqq6vDX/32P/NJKc1vfuHC8+vCtOFFchpNny20et2LTXogKAdoWg1WfJMvYsPcIvnjlEew8fBpnzlVCAIALIwuGJsdgVN/4Djojx+TbIxW9ZryIgl8+gbZGY2qLHYAek5+AUuVm53RERI6HV4XdSI+wQCx85i58un4XDpwogrNSibEDE/DQlJvgqnKydzwiIiIi6oa2bt2KJ598EoMGDYLBYMBLL72EiRMn4tixY3B3d2/z2Ly8PHh5eZm3AwMDOzquwxiX2gufrt9tteaYJMsY3Y9T1xBdC1mW8df/fYeisiqL9sNnSvDvlRuRFBUCURCs3vwHgJqGZpyrqIFCFGGUJKv+Fr0RgiDgP8/ejY37jmHvsXw4KRUY2bcnRvWLh4LTClkJSBwG/143oaX+PBROqisu+k1ERK1jcaCbiY8IxoLHb7d3DCIiIiIiAMCGDRsstj/99FMEBQUhKysLI0eObPPYoKAg+Pj4XNX30el00Ol05u2GhoZrzupIbh/ZH3uO5uNYQSlEQQAE09Qno/vHY3gfTlNCdC2OFZQiv/S8Vbskydh95Az69gi3WRgAAKVCRGJ0CNK3HrDZH+DtAQ9XFURRwLThfTFteN92zX6jEgQBKq8Ae8cgInJ4LA4QEREREVGXUVtbCwDw8/O74r79+/eHVqtFUlISXn75ZZtTDV20YMECvP766+2Ws6uprm9CXpEGHq4qJEWHwsXZCW8/ORNbc05g77F8KBUKjOgbh6FJsRBFwd5xiRxKWXVdm/0xof5wc3FGs05vMVpHFASMG9gLw3vHIUrtj+LyKqu1QGZNGsKfSSIishsWB4iIiIiIqEuQZRlz587F8OHDkZKS0up+ISEhWLx4MQYOHAidTofPP/8c48aNQ0ZGRqujDebPn4+5c+eat3NycjBq1Kh2P4fOJkkylqzbgfSMbBgvPHQM9vXEy7NvQa8oNcanJmJ8KtcXIwKA1NRUaDQaqNVqZGZm2tznbHk1tuacgFZvwID4SPSLC0dkcOvFSlEUEBsaiH88Mh1/XfI9Gpt1EC6sGZAcE4o/3D4KCoWIfz8xA//5+hfsOnIGsizD28MVD04aislDW/9d1x2p1WqLP9uTsaUZDaWnoHB2gbs6DoLAogwREYsDRERERETUJTz11FM4dOgQduzY0eZ+CQkJFgsWp6Wlobi4GG+//XarxQGVSgWVSmXe9vDwaJ/Qdvbt9gP4anOWRVtFTQP+8uFqfP7X38HTzeWKn9Gs0wMA1yGjG55Go0FJSUmr/V9tzsTHa3dAFAQIgoBVP+/HoF5ReO33U9E3LhyHz5RYvPkvCAImDkqCj4cbfDzcsPLVR7D7yGnUNDQhPiIYyTGh5gfQvp5ueO13U1HfpEVDkw5Bvp5cT8CG1oo2V6Opshg1+QcgKlXwjx8KJ3dvc9/ZPatRtHU5JL1pejkX3xAk3PY8PMO4iD0RdW8sDlC7KK+ux4a9R3CushYRQb6YNCQZAd43xg0XUVdVXl2HuiYtIgL9oHLmr3MiInJsTz/9NL7//nts27YN4eHh13z80KFDsXz58g5IZl9Xeov26y3ZVm2SLKNJ14JfMo/jtpH9Wv3s/HOVWPTtVhw4WQwA6NMjDH+4fRTiwoJ+e3AiB5NXVIaP15oKk5IsAxemB8rMK8LXW7Lx6sO34t8rN2L3kTMATCMGJg5KwtMzfp3OzFXlhLED237Y7OnmclVFO7p6sizh1PoPUHZgAwABgIzTP36AHpOfhLr/JJQf3oKCn5dYHKOt0eDIipcx8Mn/wdndxx6xiYi6BD5Not8s+0QR/vrxdzAYJXPbyl/2483H70BKbKgdkxHdmDRVtfj3Fxtx6LTprSc3lTPunzgYd44ZyKGxRETkcGRZxtNPP401a9YgIyMDMTEx1/U5Bw4cQEhISDuns7+23qI1ShIqa20vrKwQRZRU1rR6bFlVHf743lfQ6vXmtiNnzuG5977GR3++H6EBPtcbmcgh/ZyZC4UomKfnukiWZfy45wjunzAYf/v9NFTU1KOiph6hAT7w8XCzU1q6lCb7xwuFAQAw/feTJSNOrXsPHqE9cXb3N7hYNDCTZRj1WpQf3ITwm+7s7MhERF0GiwPdTHV9I1Zvy8H+YwVwUSkxdkAvTB6aAiel4ro+z2A0YsHnP0JvNOKSdZeg1xvx5ooNWPbSw1xciagdtRgMeP6DdFTU1JvbmnQt+HjtDriqnDB1WF87piMiIrp2Tz75JL744gt899138PT0hEajAQB4e3vD1dUVgGm9gJKSEixbtgwAsHDhQkRHRyM5ORktLS1Yvnw50tPTkZ6ebrfzsAeFKCLI1xPl1fVWfUajhIgg31aPXbPtALR6vcUUKZIso8VgwOqtB/DUjNYXdya6EdU3aS3uaS/V0KQ1/+9AH08E+nh2Uiq6GqWZ62y2C6ICZTmb0Hy+BBaFgV93QFPl2Y4NR0TUxbE40I1U1jTgyXdXoqa+CZIsQwBwNL8Uu46cwRuPTYdCvPb5Dg+fOYeahmardkmWUVZVhxPFZegV1f4LCRF1B43NOpRX18Pf2x1e7qaHIzsOnUJZVZ3N/b/YtB+33tSHoweIiMihLFq0CAAwevRoi/ZPP/0UDz30EACgtLQURUVF5r6WlhY8//zzKCkpgaurK5KTk7Fu3TpMmTKls2J3GXeOGYgPVmdYtImCADcXZ4xrY3qTI/nnLAoDF0mSjMNnWp+Tna6PLEso3f8DSvauga6uAi6+oYi46U4E9R3Pa7cuIik6BL9kHbdqF0UBKbFhdkhEV6ulocpmuyxLaGk4DxefYDSft1EEkGW4+N54I86IiK4FiwPdyIpNe1HTYCoMAL/WzbPyCrHr8GmM6Nuz1WNb9Ab8nHUce4/mQ6EQMbxPD4zqGw9di77VYwBAp2+7n6i72p9bgC83Z+LMuUoE+3ritpH9MHFQEgRBgN5gxOLvt+OHXYdgMEoQBQFjBybgmZljkV96HgqFCOMl03hdVFnbgGadHm4uznY4IyIiousjt/aq7iWWLl1qsT1v3jzMmzevgxI5lunD+6KmoRlfbc6E3mAEAIT4e+Pl2VPg7qpq9TgfDzeIgmC+N7hIFAT4cqqUdpf/y6c4t2e1eVtbVYKTPyyEvqmGU5p0ERMGJeKrLVmoqKk3F85EQYAAAQ9MHGLndNQWj5CeqMnPAWTreyQPdRx8Ywfi1Lr3LDsEAaJCieB+EzonJBFRF8XiQDey49Apm28HKUQBu4+cabU40KzTY95/03G8SANBAAQI2H7wJH7JOo7n754ApUK0WG/gIhdnJeIjgtv9PIgcRWllLU6cLYOvpxtSYsLMU2xt2p+Lt774yXxD3tCkxdsrN+FsRQ1+f8swfLA6A+v3HDYPa5ZkGZuz8tDQpMPgpBhINn7eAMDdxZkLExMREXUzgiDgoclpmDGqP04Wl8PdVYX4iKArvo1+85Bk7D2Wb9UuyTImD03pqLjdUkt9Fc7t/dZmX9H2lQhJvRUKZ9fODUVWXFXOWPjMXVj83XZsO3gSRklCryg1Hrl1OEfDd3ERw+5CzZkDsFhXQBChdHGHut8kKN28oKstx9ldX0OWTEVUJzdvJNw+DypPf7vlJiLqChzqKdKiRYuwaNEiFBQUAACSk5PxyiuvYPLkya0es3XrVsydOxdHjx5FaGgo5s2bhzlz5nRS4q6ltRsEGTD9G9qK77bnIK/YNPerLAPyhX9s9x0rQGZeEe6fOASf/bjb/M+wIJj2e2jyTXBV8Q1m6n5aDAa8s3ITNmfnmdtC/L3x+u+nIiLIFx99tw0ArEbxfPVLJsb0j8eGvUes5juVZBl7juXjvolD4KJygrZFb7GPIABTh/e9runBCGhpqEblse3QN9fDKyIJPjF9IQj2+7s0tjTj3P61qDy2HbJkhH9CGkIHT4eTm5fdMhERUdfm6eaCAQmRrfZX1TWirLoOaj9v+Hq6YVjvHpg5egC+yciGaHoDCJIkY/rwvhjZr/URxXTt6kpybb7RDACSXocGzWl4R7Ig0xUEeHvgxQcn4wXjJBhlCc5Kh3pk0m15R/VG4l0vI3/T/6CtLgUAeIUnIm7KU3By9wYARI2ehdDB01BXfAwKZzd4RSZDVPC/LxGRQ/0mDA8Px5tvvom4uDgAwGeffYbp06fjwIEDSE5Otto/Pz8fU6ZMwaOPPorly5dj586deOKJJxAYGIgZM2Z0dny7G9m3J9buOmQ1ekCSZAzvHdfqcVsO5NlcmEkQgK05J/D3R6YhyMcT32zNRmllLSKCfHHnmIEYMyChvU+ByCF8sm4Xthw4YdFWVl2Hvyxajdd+PxW1jdbrdACmAsC2g6dgtDHC56Lyqjr887Hb8Oona1HX+OvCaKP6xePBSUPb5wS6mYpj23Hi27chy0YIgghZMsIzPBHJ9/4NStVvm1ZBloyQJSNEpXWhVN9Ui/N5eyAZdPCJ6Q+3gAgAgFGvxaFlL6Cx7Awu/vJtqixGxZEM9P3duywQEBHRNWnStuDdr37G1pwTkGVcmK6wF569cywenz4SEwcnYdeRMwCAm5JjERMaYOfENx6lc9vXE4rfeL1B7U+hEKEAX7pxJP7xQ+HXcwh0tRUQlU5w9rBekN3JzRv+CWl2SEdE1HU5VHFg6tSpFttvvPEGFi1ahD179tgsDnz44YeIjIzEwoULAQCJiYnIzMzE22+/3WZxQKfTQafTmbcbGhra5wTs7L4Jg7H76BlU1DRAlmUIggBZlpGWEouhybGtHndx7tLLyTJgMBghCAImDk7CxMFJHRWdyGG06A34Yechq/mTJUlGVX0Tjuafa/N4Py/3NvsDfDyQHBOKla89gszjhahr1CIpOgSRwX6/OXt3pKs/jxPf/ts8vFiWTX/Wl+ShcMtn6HHzH67rc1saqpD/yyeoPLodsmSAR2g8osc+BJ/ovgCAsoObcGrd+5AlAy4Ofw7uNwlxtzyFspxNaNSctvxAWYK2thzn9n2HqNGzrvd0iYioG3pz+QbsPZZ/2XSFx2GUJLw4azJiQgIQE8KCQEfyju4DJ3df6JtqYDn0U4SrXyjcg2Lslo2uzplzFVj1cyaO5JfAx8MNk4cmY0pab47atSPJoEdTZREUzq5w9QsFYJotwcUnyM7JiIgci0MVBy5lNBrx9ddfo7GxEWlptiu/u3fvxsSJEy3aJk2ahCVLlkCv18PJycnmcQsWLMDrr7/e7pntzc/LHYv+dB++33kImccLoHJywtiBCRg/MBGiKOBEcRm+2pyJ3EIN/L3cMXVYH4xPTURaSixKtmRbLVYmABiSzAtZ6t60LXroWgzwcneBIAioa9RCpzfY3FcUBej1RkQF+6G4vNrqZ8pV5YQJqYnYcegUDp4qthjlI4oCIgJ9kRQdAgBwVipxU0qPjjuxbqLiSAZkW8P8ZQllBzchdtLj1zy9kFGvxaHP5kFbU2aeQqCh9CSOrHgZvWe9CaWLO06u/Q9+nVDK9GdZzk9wD45B1cl9tj9YllB5fBeLA0REZJPRKKGsug5uLs7wubCg8NmKauw+esZqX0mWkXEgD4/cOhxBvp6dHbXbEUQFet3xFxxd9QokQ8uFkYoSlCo3JNw+74rrQ5B9HSs4h+c/SIdRkiBJMiprGvDeN+U4ml+Kvzxws73jdUulWT+icMtSGLSmFznd1T0QP20u3IOi7RuMiMgBOVxx4PDhw0hLS4NWq4WHhwfWrFmDpCTbb6xrNBoEB1suiBscHAyDwYDKykqEhITYPG7+/PmYO3eueTsnJwejRo1qv5OwIy93VzwwcQgemDjEoj07rwgvLv4WgAyjJKOiph65hRqcLC7HvRMGYXNWHqrqG80PK0VBQESwH24eYj1ig+hGkJqaCo1GA7VajczMTKv+6vom/HdNBrYfPAmjJCPU3xu/u3UYbkrpAXcXZzRqW6yOkSQZUWp//Pm+ifjzf9OhazFAhmkUD2Tg+XsmwlXlhPkPTMJLi7/DybPl5mND/Lzxt0em8ebxOhlbtKg4uhX1JXlwcvNCUJ+xcAuIhKG5znSDLluPkJL0OkgGPRROKpuf2VB6Cpqcn9BSXwUPdQ+oB9wMZw8/VBzZap7r1EyWAUFA0fYvTDctoghI1t+zNHMdVD5Bvy7echmBb6cREZENG/YexSfrdqK6vgkAkJoQhefuHociTVWrx8gycLa8msWBTuIdlYLUpz5B+aFfoK3RwM0/AkG9x0Dpyr//ru6j77bDaJSs1gv7Jes4bh/ZDwmRXKy4M1Xm7sDpH9+3aGssy8fhz/+C1Cc+5s8UEdE1crjiQEJCAnJyclBTU4P09HTMnj0bW7dubbVAcPmDtItTfbT1gE2lUkGl+vVhkIeHRzsk77pkWcZ/12RAkiXzs6iLf67ZnoNpw/vig7n34qstWdh56BQUChGj+8Vj5pgBXHCYblgajQYlJSU2+/QGI57/4Bucrag2F8zOna/FPz5bj9d+dytmjBqAZT/tsThGFAWofb0wJCkGCoWIT+bPxo+7jyBfcx7Bvp6YkpaCiCDT1EC+nu74YO69OJp/DkVlVQj280L/npEQRRYGroeu/jwOffZn6GrKAFEByDLO7voacVOehkdovHlKIUsCXAMiWi0MaLJ/xKn175s+TzKi6uQ+lOz7Dn0e/BfqzuZCEBXWnytLqC8+BidXr1YXJWxpqELY0NtRczrLRiQBgUkjrvHsiYjoRpdxIA/vrNpk0ZZ9sghz/9/XeOnBKW0ey8JA53J290F4Wvdb+86RNetacKyg1GafKArYd6yAxYFOVrzjK1ycltNMlmBobkDZoV8QNuQ2OyUjInJMDlcccHZ2Ni9InJqaiv379+M///kPPvroI6t91Wo1NBqNRVt5eTmUSiX8/f07Ja8jOF/biMIy228VCQKw/3gBbh/ZH3Omj8Sc6SM7OR1R17Pz8CkU2fiZEQTgsx/3YNHz96FJ14Jvt+fAYDQ9BO4Vqcb8WTdDoTC9+R3g7YFZN7e+gLAgCEiJDUNKbFjHnEQ3cmbjYuhqK0wblzywP/XjB0h98n9wC4pGU0XRZQ/sZUSNfsDm57U01uD0hkWWnydLMOqacGr9+/AK74XWlpRWunjAQ90DlbnbrTsFER4hcQjqMxYVRzJQW3gIv974CHAPikbIoGnXcOZERNQdLP9p7+WPySBJMsqq61FcXo1ekcE4cbbcarrCPj3CEB5kvWAnEf1KFMTWBnQCMqBUclRnZ2uqLARsXG0LooimisLOD0RE5OAcrjhwOVmWLRYPvlRaWhrWrl1r0bZx40akpqa2ut5Ad3TxYaVNMqBsq5+oGzpeVAaFQoTRaPn2tywD+aWVgAw8Pn0k7h0/GIWa8/D1dOPNt50Y9TqcP76rlTf1ZZzP24XeDyxA/s8fo+LINsiSAS5+oYge/SACeg2z+ZlVJ/baHm0gS6g/m4uokQ+gZM8a635BQHD/SQjuNxFnd6eb5ki9NJcsI2L43RAVTki+728oP7QZlbk7IEtG+McPRXC/iVA4u1zfXwQREd2QjJLU6ks+ClHEqZJyvPrwVPz1f9/hVEmFuS8+Ihgvzmp7VAERASpnJYYkxmDf8QKLAhtgWrtjRN+edkrWfTl7BkBXo7Fql2UZKq9AOyQiInJsDlUcePHFFzF58mRERESgvr4eq1atQkZGBjZs2ADAtFZASUkJli1bBgCYM2cO3n//fcydOxePPvoodu/ejSVLlmDlypX2PI0Oo1arLf68Wr6ebkiKDsHxQo31osOCgDQuekpkwcfdFbJk+91wN5WzefofL3cX9O7BN/87ytX8zpON+lan8IEgwKhrhpObF+Kn/QlxU56BpNdC4eLR5tRzklEPq6HMl3DxC0HsxMdxZuNHgCBCEATIkhHeUX0RftOdUDip0Gf2v3Bq3fuoKz4KAFD5BCN2wqPwie4LABAVTlD3nwR1/0lX/osgIqJuSyGK8HRzQX2T1qpPkmX4e3kgwMcD//3Tfcgt1KD0fC3CA30QHxHMdYyIrtKc20Yh9z0N6hq1kGUZoihAkmTMnpyG8EC+ANTZQgdPQ/7GxZe1ChBEEcF9J9glExGRI3Oo4kBZWRlmzZqF0tJSeHt7o0+fPtiwYQMmTDD9A1BaWoqioiLz/jExMVi/fj2ee+45fPDBBwgNDcV7772HGTNuzHkebS2aejmjUcLOw6eRfaIQKicnjOofj6ToEDwzcyz+9P7XaNbpIckyFKIAoyTj8ekjEOB9Y6+5QHStxg7shaU/7rJ6NiwKAianpfBmu5Ncze88hcodboFRpmmDLv8PJknwju5j3hSVThCV1qPKZMkIo14HhbMrBEGAb0x/688CAAhw8VVD5R2E0MHT4Bs3CJXHtsHYooVPdB94x/Qz/3/DLSASfWa/hZaGakiGFqi8AyEIHKVFRETXbtqwPvji531W054oRAHjUnsBML3wkxQdgqToEDskJHJsYYE++N8Ls7Bu9xEcyz8Hbw9XTBqchL5xEfaO1i2FDpoKbdU5lGauw8VrcoXKFQm3z4PKmyMHiIiulSDLNmfPo0tkZ2dj4MCByMrKwoABA+wd57o16/T4y4ercaygFArR9BDKKEm4a+xAPDp1BCprGvDDrkPIKyqDv7c7Jg9NQXJMaCdnbMEXm/Zh4/5jaNLq0S8uHLNuHor4iOBOzUEUHh6OkpIShIWF4ezZs1b9GQfy8K8VP8EoSRAE09tD/eLC8fdHp8PFmdOWdSVVp/bj2KrXTYtCXBxFIAjwjR2IpHtea7WYY2xpRsHmpSjL2QjJ0AIXHzUiR96PoD5jcXrDIpRm/gDzCAJBBCAj6a5X4NdzcGedGhER/QY3yjW+3mDEPz//ETsOnTKPa3NxVuKlB6dgaHKsveMRdSlXusYHgBaDATkni6FrMSAlNgy+nm6dnJKuhramHHVFR6BQucIndgAUTip7RyIickgONXKAfpsvN2fieKFpbj6j9Os0G19tzsKQpBj06RGOh6bc1KEZjEYJa3cdwoa9R1HX2Iw+PcJx97hUxIQEwGiU8MKi1cgrKjNPb7TveAGyThTh3afvQkIkCwTUdYzun4C+cRHYdvAkGpq0SIkNRZ8e4Rw10AX5xQ1Cyv3/QNH2lagvyYOTqyeC+9+MiGF3tfrfS5ZlHPvyddQWHTUXFLQ1Gpz4/h3IkhGxkx6He3AsSrPWoaX+PDxC4xFx053wikjqzFMjIiKCk1KBVx++FadKynHk9Dm4u6pwU+9YuLvwQRnRtdqXm483l29AfZNpXUOFKOCe8YMx++ahvM7vYlx8guDiM9beMYiIHB6LA93Ipv3HrNYUAEwXPJuz8tCnR3iHfn9ZlrFg+QZszTlhbss4kIdtB0/i/566ExU19cgttFxYSJJkQJawdP0uLJhze4fmI7pWvp5umD68r1V7XWMzfsk6jvLqekSp/TG6fzxHE9iZT0w/+MT0s9nXUHoKTZXFcPEJhmd4IgRBQF3RUdQWHra5f+HWzxHUdxzXBCAioi4lLiwIcWFB9o5B5LBKz9fi1SVrYTT++iKdUZKxYuNehPh7YdLgZDumIyIi6hgsDnQjzboWm+2y3Hrf9ZIkGdoWPVycncyLsx7NL7UoDACmiy1ZlvC/H3YgMtgPClG0GNUAmBZTyzlV3K75iDrKodNn8dLi76DT6yGKIoxGCZ+u34V3nprJBcu6GH1zPXK//jvqio6a29yCopF016uoLzlumirIxmLGLfXn0VJfBZVXQGfGJSIiIqIO9OOeI5Bk2WplKQFAesYBFgeIiOiGxNUPbyCpqakIDw9Hamqqzf4B8ZHmB/WXkmQZfXte22JKZVV1yDxeiLPl1ZafJclY9ct+3PXqYkyf/1/c+cpHWPnzPhglCfuPF0DRyvc/eOosnJUK2F7kE1A5sY5FXZ/eYMTfPl2HFr0BsgzzW0c1DU14a8VPdk5347nS77wrOfn9/6GuONeiramiCMe+eh1KV0+bhQEAgCBCoeLcs0REREQ3krKqOpu3ozKAsuq6Ts9DRETUGfjE9Qai0WhQUlLSav/9E4dgz9F86GE0TdcDQBQFhAf6YtyAXlf1PZp1ery9ciO2HTxpbuvfMwIvPjgZPh5u+HjtdnyTkW3uq2vU4pN1u1Bd1wRPd5dWHv0DoiBg9IAEpG89YN0nChifmnhV+YjsKTuvCLWNzVbtkiQjt1CDc5U1CA3w6fxgN6gr/c5ri662AlUn91l3yBKaygug8gqCqFRBMrTA4i5REBGQOBxKFgeIiIiIbigRwX4220VBQGQrfURERI6OIwe6kZiQALz3x7sxJCkGKiclPFxVmDasL959+k6onK+uTvTuVz9jx6FTFm0HT5/Fa5+sRW1DM9Zsy7F53Hc7D6JfXLi5KHEpURRwU+8e6BWpxoM3DwVgWgfh4iiDyCA/PHhz2jWcKZF91Ddr2+6/sLAZdZ6myiLkfvNP7PrXHdj977twav37aGmohq6uos3jDNo69JrxFwhKJSAIEEQFAMAtIAI9Js3pjOhERERE1IkmD0mBykkJ8bKFhyVZxt1jr2+kKhERUVfHkQPdTGxoIP72+2nXdez52kZkHMjD5WsaS5JsXk/g8vUCLt2nSavHAxOHYPnGvRBFAZIkQxAEeLu74rFpIwAAsyYNxaBe0fgl6ziadC3o2yMco/vHw5nTCpEDSIoOabXPVeWEKDXfOOpMzVUlOPjJn2D8/+zdeXxU1f3/8fedLJOQQFizQiBsYd9B9oAgFgT36k9tEQFbqnWjlhaxotR+aa1atIpoZal1qQuIG6CoEEBACRD2HUJYEiAs2cg+9/cHMnVIAknI5M5kXs/HYx7t3HvuzHu4TubMfO45pyj/xymCCpS++UudO7hZHe9+ttw1BSSpTpPmCglvoT4P/VundiaqKOecQqPbqGGbPs5CAQAAAGqPRmEh+utvbtXf3lmm4xmZkqSQoEBNGD1AA7u0tjgdAADuwS+uKFdWbr5KHCWqH1pHhmEo7XRmqcLAT+XkXf6q6LohQbp3ZD91ad1Uy3/Yqazz+eoYF6Ub+nVWvZBgZ7t2zSPVrnlkdb0MoMZEN66vEX06aPkPO0tNofWLEdcoKDDAkly+6sh3H/2kMPAj06H8cyd0Zt/3Cu8yTCe3fi2XP2yGTWEtuigkvIUkKSAkTNG9q1ZQBQAAgHfp0CJKC54YpwPHT6mgsFitY8IrPMoeAABvxKccSjmcflovf/Stth64MJd3i8hG+s0tCYqNaCjDULkFgh5tY/V10i4dO3VOjp80shmGIhvVU/sff/Dv3qaZuldyAWTAU5mmKYfDlJ/fhVnaJt8xXFGNwvTxqs3Kys1XRMN6unt4b43s28nipL7n3KFN5YwMMJWZsvXCtEGGoRNbvna2axTfV21GP1KzQQEAAOAxDMNQ65hwq2MAAFAjKA7AxZmsXD32zw+Um1fo3Hb4xGk98frHeumROzWwS2t9t/WAy4//fjZDbZqGKz42Qn8ad4OmzF6oczl58vOzqaTEodA6dj01brSMS+ZuBLxZTt6Fxba/2rBTBYXFatssQveN6q9e7ZrrFyOu0T3X9VFxiUMB/kxBYxW/wOCydxg2+dmDZfMPVJvRj6jFteOUfzZNgfWayF63Uc2GBAAAAH7CNE2Z5oW1+QAAcDeKAz7INE19v/OQvvx+hzJz89QxLlo3DeymxvVD9cXabcrNK3T58d80JdOQ/vtNkh6/6zoVFzu0bsdB5/52sZF66r4LP/7HRTXWW0+OV2LyXh3LOKeYxvWV0K2tgu1Mp4Lao6TEoT+8tkj7j55yvlf2HT2hJ974WP/3q1vUq11zGYZBYcBiEV2GK+XbBdKlkzyZDjXpNMR5N6BOmALqhNVkNAAAAMDFybPZmvv5Gq3ask8Oh6ke8bGaOHqgWsU0sToaAKAWozjgg978fI0++Hajc1HgHYfS9PnabZr1yJ3ac+SES2HgIofD1K7DaQoJsmvGxBt19NRZHTlxVpEN6ykuurFL22B7gH52TceaejlAjVu/86D2Hjnpss00JcOQ5i9Zq17tmluUDD8V3edGnT24SZkpW5yLCJuOEkX2vEENWvWyOB0AAABwQVZuvh556X2dyc6Vw3Hh+/imval65OX3NXvy3YqNaGhxQgBAbUVxwMekpJ3WB99ulCRnp8NhmjpfUKg5ixPVOCxUfjZDJQ7XAoEhqWHdEOf9pk0aqGmTBjWWG/Ak2w8el5/NphKH63z2pintPXJCJSUO5xoEsI7NP1Cd7v6zzuz7QWcPbJTh56/G7QeqXrOO1TLNmWmayjqyQ5kpW+UXGKzG7QfKHsaVXQAAAJ4qMjLS5X89xZL123Q6K8dlfT+Hw1RxcYne/2aDfn/39daFAwDUahQHfMx32w84Rwz8lMNhauPuw3rugdu07PsdpY4zJY0e0KWGUgKeLTTYLrOclbntgf7MD+pBDJufGsX3U6P4fpU+Nv9smo5894HO7k+SLcCu8M7XKqbvLfILDJajuEi7PvqLzu7fINlskmnq0Ddz1epnDyqq50g3vBIAAABcraSkJKsjlGnbgWMq6+tFicNU8r6jNR8IAOAzuLTVxzguudL5p0xJ7ZpHatJNg2UYhgxDsv14de2ofp30sz5MFQRI0rU92sm8dB57XXi/jOjdgcW3vUT+uRPa+9ksrX/xLv0w65c6uPxNFZ3PkiTlnUlT8txHdWLL1yrMOaP8s2lKXf2etr39hBzFRTq69kOdPfDjl0uH48fFWUwdWPqKzp9KtfBVAQAAwJMdOHZKn6/dqtVb9qmwqFiSVLdOULkXGIXWsddkPACAj2HkgI/p26Gl3lq2vtR2m2Goc6sYBQUG6LYhPTS4Wxt9t/WAikpK1LtdC7WIamRBWsAzRTUO06M/H6ZZH34jQ4YMw1CJw6FWMU004YYBVsdDBeRnnlTy3EdVnJ8jmReKpsd/+ERn9/+gruNn6cia/6q44LxznyTJdCjn+F5l7Fqt9M3LVOblXTabTmz9WnHDxtfQKwEAAIA3KCwq1rNvLdG67Qed2+rWsevp8WM0rFc7fbNxd6ljDIn1/AAAbkVxwMe0aRauUX07acn67TIMQ6ZpymYzFODnp1/fONjZrkn9urp5cDfrggIeblS/zureJlbfbtqt7LwCdYqLVr+OLVlrwEscW7fQpTAgSTIdyjt9XCe3fK0z+39w3XeRYdPZAxtVnJdd5uMaMlT84+gDAAAA+J7C4mIdPJahwAA/xUU1do4qnrdkrb7fccilbW5eoZ781yd696kJumNoT32wYqP8bIakCxcf9evUUmOY3hcA4EYUB3zQIz8fpk4tY7R0/XZl5p5X55Yxun1ITzUNZ4FhoDKiGofpnhHXWB0DVXBm/4ayf/yXqbMHN8nmF1D2gYYhm1+AQqPjlXVkR6nHMB0lqhsTX/2BAQAA4PGWfb9Db3y6StnnCyRJ0Y3DNOXu69UuNlJfrN0mxyUjTx2mqbyCIiUm79P9Nw7SkO7xWrV1n4qLS9SnQ5y6tW7KlKUAALeiOOCDbDZD1/Vur+t6t7c6CoAqME1TS7/foU/XbNGps9lq3TRc/294b3Vv08zqaF7Dz7+cuVsNm/wC7GrSaYiOrf+4dAHBUaLGHQbJ8PPX9nem6cJgb9N5rL1eEzXpNNSd0QGg1pk5c6YWLVqk3bt3Kzg4WP3799ff/vY3xcdfvtiamJioyZMna8eOHYqOjtaUKVM0adKkGkoNwFcVl5RoT+oJmaap+NhIBfj7SZJ+2HVIL/x3uUvb9NNZ+sOcRXrlsf+n/MKiMh/Pz2bTqcwcSRdG+rdpFu7eFwAAwE8w/wUAeJk5n6zSP97/WgePnVLW+Xwl7zuiKbMXKjF5r9XRPJKjuEhZR3crJ22/zB9/7G/SeahU1lVYpkONOw5WswF3qE7ji8UWQzIufFyGdx2u+i17qH6Lrur4/55WnfDmPzaxqVF8P3W59zn5BQbVwKsCgNojMTFRDz74oNavX6/ly5eruLhYI0aMUG5ubrnHHDp0SKNGjdKgQYO0efNmPfHEE3r44Ye1cOHCGkwOwNv06tVLTZs2Va9evap0/NrtB3TX02/q0Zc/0GP//FB3Tv+XVmzaI0l6/5sk2S7pXzpMU0VFJVqxaa8a1Qsp8zFLHA61im5cpTwAAFwtRg4AQBkiIyNd/tdTpJ3O1KLEzZKc16s7hyfPWbxKA7u0lp+Nuu9FJ7Z8rUPL/3VhfQFJ9rBwtRnzmKL73KQz+zco+8hOybBdWIPFUaImnYaqUXw/GYZNXce/qJNbV+jcoc2y+QeqScfBatC6t3Nod4NWvdSgVS8V5+fI8AuQX0A5oxEAAJe1bNkyl/vz589XeHi4Nm7cqMGDB5d5zJw5cxQbG6tZs2ZJktq3b6+kpCQ9//zzuu2229wdGYCXSk9P17Fjxy7f5kymViXvU0Fhsbq3jVXHuCgZhqEDx07pmXmfu0wNlH0+XzPfXqrwBnV1OP1MqWmDpAujfo+cOKN7RvTRyx+tcNlnsxmKahimfp1aVs8LBACgkigOAEAZkpKSrI5Qps37jpS7LyMzR8dOnVNsRMMaTOS5zh7crH2f/cNlW0HmKe147yn1nPSaOv9ipk7vWqMz+5Nk+PmrcfsBatCql/PHf7+AIEX1HKmoniMv+zz+QaFuew0A4IsyMzMlSQ0blv95tm7dOo0YMcJl2/XXX6+5c+eqqKhIAQGl144pKChQQUGB835OTk41JQZQW3y8arNeW5woQ4YMQ3rry/Xq36mVnrx3lD5ZnXxh4Oklv//bDEMfr9qsiIb1lHU+T5fWBwyboYiG9TS6fxcVFpXoP19+r9z8C3+LerSN1e/uvE7+fn418wIBALgExQEfs//oSc1b8p027TmiwAA/DevZTuNG9ldYaLDV0QD8REZmjj5auUnf7zwke4C/ru0Rr5sGdpM94PJ/tq+035ccW7fwwnRALusGmDIdJUrbtFRxw8arSachatJpiFURAQCXME1TkydP1sCBA9WpU6dy26WnpysiIsJlW0REhIqLi5WRkaGoqKhSx8ycOVPPPPNMtWcGUDvsP3pSsz9OlCSZMp1FgHXbD2hh4ialpJ9WiaP0yIASh6lDaad193V99Ne3l5Xab0ga1a+TDMPQbUN6aMzALkrLyFTdOkFqWM5UQwAA1BR+RfIhB4+f0iMvva9ih0MOh6m8AoeWrN+u5H1H9Nrj9ygosPQVVgBq3qlz2XrwxfeUmZsnx49fQA4eP6V12w/qqftGK9DfT4XFJS7H2AxDrZo2UUTDelZE9kjnM1JLLygsSaZD50+l1nwgAMAV/fa3v9XWrVu1Zs2aK7Y1Lpnb2/zxct1Lt180depUTZ482Xk/OTlZCQkJV5EWQG3y5Q875WczShUATElL1m1Xx7ho7T1yotR+m81Qs/AGurZHvI6fOqd3ln/vbFPHHqjf3z1CzcL/NxIq0N9fzSMbuf31AABQERQHfMjbX37vLAxc5HCYOnrqnL5J2q0b+ne2MB3gW85m5+rd5Ru0KnmvTEkDu7TW3cP7qHH9UL339QaXwoAkmaa0/dBxbdqbqsfuHK7n3v1SNsOQwzRlyFCwPUCT7xxu3QvyQEH1I1WYc7ZUgcCw+SmofkQ5RwEArPLQQw/p008/1apVq9S0adPLto2MjFR6errLtpMnT8rf31+NGpX9o5vdbpfd/r/1YUJDmRYOwP9kn88vNSXQRZm5ebppYFd9s3FXqX0Oh6mbB3WTYRj65c/6avSALtq6/6gCA/zVvW0zLsIDAHg0r1q1cubMmerdu7fq1q2r8PBw3XzzzdqzZ89lj1m5cqUMwyh12717dw2l9hzJ+4+4/Nh4kc0wtOXAUQsSAbVf+plMHU4/rZKS//1AnZWbr4dmva9Pv9uiM9nndTb7vL5Yt02//cd7Opudq++2HSj3vbp+x0EN79Ver//+F7ppYDcN7NJGY3/WV/Om3qvWMeE1+dI8XvQ1N5U5csA0TUX2HGVBIgBAWUzT1G9/+1stWrRI3377reLi4q54TL9+/bR8+XKXbV999ZV69epV5noDAHAl7WIjnSOQfspmM9QxLkrtmkfqD/f8TMH2//2NsQf467E7hqlbm2bObQ3q1lFC97bq16klhQEAgMfzqpEDiYmJevDBB9W7d28VFxdr2rRpGjFihHbu3KmQkMvP1bdnzx7Vq/e/6TaaNGni7rgep449UNnnC0ptNwwpJCjQgkRA7XXw+Ck9/95y7Tt6UtKFLwmTbh6sa3u002ffbdHJs9kuXz4cDlNns89r0apk+dnKng5BhuRnu1DTjYtqrN/cwlQIl9O43QC1uPY+HU78j8ySYkmSn72O2ox+RCFNmlucDgBw0YMPPqh3331Xn3zyierWrescERAWFqbg4AvrYk2dOlXHjh3TW2+9JUmaNGmSXnnlFU2ePFn333+/1q1bp7lz5+q9996z7HUA8G7X9WmvD1Yk6XRWrvNCnYsLEN9z3TWSpGE922lA51baeuCoTIfUpXWMgu18lwYAeC+vKg4sW+a6uM/8+fMVHh6ujRs3avDgwZc9Njw8XPXr13djOs93fZ+O+s9X35e6GqLEYWpYz/YWpQI8U69evZSenq7IyEglJSWV2WbfkZP6OmmXsvPy1alljK7tEa+gwACdyzmv373ykc4XFDrbns0+r5n/Waa6dYK0YffhMq9KcpimNuxM0ZDu8Vq4cpMcl7RxOEwN7NK6el9oLde0/+2K6H69Mg9vlc0vQGEtusovwH7lAwEANea1116TJA0ZMsRl+/z58zVu3DhJUlpamlJT/7deTFxcnJYsWaLHHntMr776qqKjo/Xyyy/rtttuq6nYAGqZkCC7Zj18h2Z/nKh12w/KYZpqFd1E9984SB3jop3tggID1Kf9lUc4AQDgDbyqOHCpzMxMSVLDhg2v0FLq3r278vPz1aFDBz355JMaOnRouW0LCgpUUPC/K+xzcnKuPqwH+Pm1PbV53xFtO3jsx6uPTZU4TN19XR91ahl9xeMrIiXttDIyc9QiqpEahzGPK7xXenq6jh07Vu7+D75N0r8+WyM/myFT0vINu/TBN0n6x8N36Mvvdyg3v7BUAcBmGHpv+QbZA/xlGCo1p6khyR7or/83rJfWbT+gYxnnZJoXFlY0zQuFgf6dWlX/i63lAoLrqnG7AVbHAACUo6yC+aUWLFhQaltCQoI2bdrkhkQAfFV4g3p6evwYFRQWq9hRopAgLioBANRuXlscME1TkydP1sCBA9WpU6dy20VFRemNN95Qz549VVBQoP/85z8aNmyYVq5cWe5og5kzZ+qZZ55xV3TLBAUG6O8P3qbvdxzSxr2pCgrwV0L3tmrb7OoX5jx5Nkt//vcS7T58YRi4YRga0bu9Hv75tQr099r/zIAyHT5xRv/6bI2kCyNvLko7k6m5n69RQVFxmcc5TFMHj5/SpJsTtGlvaqn9pqRre7ZTvZBgvTL5Li1dv0Mbdh1SYIC/hnaPV0L3trKVN+UQql3emWPKOb5PASH1Fda8swybn9WRAAAAUAPsgf6ye+/PJQAAVJjXftr99re/1datW7VmzZrLtouPj1d8fLzzfr9+/XTkyBE9//zz5RYHpk6dqsmTJzvvJycnKyGhdszt7WezqX/nVurfuWpXH6eeOKNjp84pukl9NY+4MGLD4TD1xzkf61jGOWc70zT11YadqmMP1AO3DqmG5IDnSNy8RzabUWrRYIfD1Leb9ujmgd1kM6SSMi6EbFw/VNf1aq+12w5o3Y6Dzh/7HQ5TPdvGalTfC8XOkCC7bh/SQ7cP6eH21+OtIiMjXf63MkoK83Vq+wplHd0l/+B6Cu88VKGRF/4uOoqLtPfTF5Wxc5WzfWC9Jupwx5+cbQAAAAAAALydVxYHHnroIX366adatWqVmjZtWunj+/btq7fffrvc/Xa7XXb7/4YPhoYyPU5Wbr7+8tYSl6udu7dppifvHaW9R07qyMmzpY4xTenzdds0blR/1WHBY9Qi+YXFMvTj6mSXKCou0Yg+HbQwsexpDm4e1E1+fjZNHz9a67Yf1NptB+QwTfXr1FIDO7eWn5/Nzelrj/LWgriSwuwz2vrv3yv/XLpk2CTD0PHvP1bciF8pps9NOrzy38rYtfqSY05r+7tPqvdD8+UXEFQd8QEAAAAAACzlVcUB0zT10EMP6eOPP9bKlSsVF1e1RYA2b96sqKioak5nvau5ivZKZr69VMn7j7hs23LgqJ59a6kGXGYUQlFxiU5n5ahO0JXXhQC8Rbc2TfXhio2lttsMQx3jotQiqpGm/vJnev695S5TDN08qJtu6NdZ0oVRPAO7tGaBYQsc+vpN5WeevHDHdDhrPIe+ekP143oobePS0gtCmA4Vn8/S6d1rFd752poNDAAAgBp3+MQZvbV0nb7feUgB/n4a2iNev7y+rxrUrWN1NAAAqo1XFQcefPBBvfvuu/rkk09Ut25dpadfmN8+LCxMwcHBki5MCXTs2DG99dZbkqRZs2apRYsW6tixowoLC/X2229r4cKFWrhwoWWvw12qehXtlRw9dVZJuw+X2u5wmNq8N1VDurUp91h/P5sa1gtxSy7AKr3iW6hb66bacuCYcxFFm2HIMAyNv+HCwrdDuserd/sW+n7nIRUUFqtbm2aKahRmZWxIcpQUK2PXmgtFgUsZNp3a/q0cRfllHmvY/FRwsagAAACAWuvoqbN6+B//VX5RkRwOUwVFxfpi3TZt3H1Ysx+/m4WKAQC1hlcVB1577TVJ0pAhQ1y2z58/X+PGjZMkpaWlKTX1f1PfFBYW6vHHH9exY8cUHBysjh076osvvtCoUaNqKrbXS8vIvOz+BqEhim4cpvQzWS5zsBuGoZF9O9FxQq1jsxl69v6b9d9vNmjZ9zuUk1egzq2i9cvr+6p98/+NSgoJsuvaHu0sTIpLmY4SmY6SMvcZhiGZpvyD66o4L7vMY4Mbx7o7IgAAACz23683OAsDFzkcptJOZ+rL73fq1oTuFqYDAKD6eFVxwLx0mocyLFiwwOX+lClTNGXKFDcl8g0xTepfdn+ziAb666Rb9fS8z3TweIZz+9DubTXpprIXfQa8nT3QX/eO7Kd7R/azOgoqwS/ArtCoNspJ319q6iDTUaL6cd3lZ6+jwyv+7XqgYVNQWLgatulTg2kBAABghY17Ul0KAxeZkrbsP0JxAABQa3hVcQA142z2eR1OP63GYaFqGt5A0Y3r65oOcdqwO8Wlg2SzGerRNlZNwxtIkuY8fo/2HT2p05m5iotupMiGTKECwPO0GHaftr/7pCTjf9MLGYbqx3VXWIsuCmvRWY7CfB1dv0hmSZEkqW7Tdoq/6fey+fGxCQAAUNsF2wPK3G6zGQq2B9ZwGgAA3IdfOeBUVFyiVxet1NL12+X48YraTi2jNe2Xo/THX1yvv779pb7fecjZvld8c/3xFz9z3jcMQ22bRUjNajw64HNST5zRpj2psgf6q3+nVgoLDbY6kteo36Kruvzyb0pd/a6yjuyUf3BdRXa7Xk37//zC1EIy1HzoWMX0u03nM44ooE6YghvWvkXsAQAAULYRvTto3pK1pWYvcDhMXdsz3qJUAABUP4oDcJr7+RotWb/NZaaNXSlpmvr6x3r997/Qs/ffpLSMTB3LOKfoxmGKblzfsqyArypxOPTSh99q6frtMnRhaPPLH32rR+8Ypuv7dLQ6nkfKPZmiswc2yuYXoIbxfRUUFq56zTqo093PXvY4/6AQ1WvKmhEAAAC+5taE7tq457CS9x+Vn80myVSJw9SYAV3Uu12Lq3rsjHM52nU4TaF1gtSlZYz8/GzVkhkAgKqgOOBjTNNU8v6j2rTnsOyBAUro1kbNwhsqr6BQn3639dIpuFXiMJWSflrJ+4+oR9tYRTUOU1RjpgsCrPLZd1u1dP12SRcKA5JUXOLQC/9drvhmkWoR1ci6cB7GNB3av+QVndj8pWRc+FJ38Ks3FDd8gmL63mJ1PAAAAHiowAB//XXSrVq/86A27EpRgL+/BnVtrc4tY34caVp5JQ6HZi9K1GdrtzpHJDQOC9Wfxt2gDi0YpQoAsAbFAR9SWFysZ+Z9rh92pcjPZpMpU/9euk4TRg9Q/06tVFRcUu6xR06eVY+2sTWYFkBZPluztcztNsPQsu+3a9LNCTWcyHOd2PzVhcKA9L+1BSQd+vpN1W3aTvWatrcoGQAAADydn59NAzq31oDOrSt9bGFxsQwZCvD3c277cMVGffrdFpd2Z7JyNfX1j/X2n8arbp2gq84MAEBlURzwIQtXbtKG3SmSLly1cNHcz79TfLNI+fvZVFziKPPYqEb1aiIigCs4nZ1b5naHKZ3OKnufr0rbtFRyTr70E4ZNJ5K/ojgAAACAarX3yAn969PVSt5/VDbDUN+OcfrVjYMV3ThMixI3l2rvME3l5Rfq2017dNPArhYkBgD4Oia38yFL1+8oNW2QJPnZDK3Ztl8jeneQ7ZIhkjaboahGYeoZ37yGUgK4nDZNw0u9Ty8w1aZpeI3n8WRFuWdVqjAgSaZDhbnnajoOAAAAarHUE2c0+Z8fauuBY5Iu/PC/fuchPfLS+8o4l62z2efLPM7mZ1Pa6cyajAoAgBMjB3xI9vn8Mreb5oV9k+8crpy8Aq3ass+5r1l4Q82YMObHRZgA1BSHw9TGPYf1w64UBfj7aVDX1mrfPEr3XNdHW/YfcWlrsxkKDbbrZ9ewIPFP1Y1pp9N710mOS0ZEGTbVjWpjTSgAAAB4rBKHQ4mb9+qbjbuVX1isXu1iNbp/F+eUP4XFxVqydru+3bxbhUUl6tO+hW5N6K76oXX0wbdJKi4pkeMnV+Q5HKayz+dr6fodCq9fVyfPZZd+zhKHYiMa1thrBADgpygO+JDOLWP0/a5Dcjhcr6R1mKY6xkUrKDBAfxp3g46dOqeDaRlqHBaidrGRVV5wCUDVFBWX6Ol5nznXB5FMfbhio24Z3E2/uTlB0+8brTmLVyn9TJYkqWOLaD1yxzDVCwm2NriHadr/5zqzd73Mn04tZNjkb6+jyB4jLc0GAAAAz+JwmPq//yzVquR9MgxDpmlq28Fj+mLddv3z0TtVt06Qpr3xibbsO+Icm3roeIaWJ+3SK4/epS37j6rEUXrUqsM0tSMlTXcM66VXFq5w2WezGapbJ0hDu7etgVcIAEBpFAd8yD0jrrmw5oAh59UMNpuhJmGhuq7X/+bejmlSXzFN6lsTEvAhe1JPaM3WfSpxmOrTvoW6tm4qwzD0yZot2rArRZLr+iAfr0pW73YtNKBza/Xr2Eonz2XJHuCvBnVDLHoFnq1udBt1vOvPOrj8Xzp/8pAkKSy2k1qN/I0CQxtYnA4AAACeZMOuFK1KvjCK3vzx+7Jpmjp1LlvvfPWDOsRFKXmf6wheh2nqTFau/vvNBoWFBuvEmaxSk1rabIbqhQTpxgFdlH0+X+8t/0GFxSWSpOYRjfTEL0cq2B7o9tcHAEBZKA74kPjYCP39gdv15udrtOPQcfnZbBrctY1+deMg1QmiMwLUFNM09driRH28Kll+NkOSoQ9XbNTALq315NhR+uqHHWXNlC+bzdA3G3erd/sWstkMRTYMq+noXqd+XFd1v/+fKjqfKZvNT/7Bda2OBAAAAA+0Ztt++dmMUlf/OxymEpP3Kut8vmyG4TJt0MX9q7fs0y+v76s9qSdKPa7DYWpE7w4yDEO/GHGNbhncTQePZSi0jl0tIhsxUh8AYCmKAz6mU8tozXr4DhUWF8vPsMnPj7UEgKo6cSZLKzbtUXZevjrFxahPhxYu63McSsvQtxt3Kze/UF1axWhA59YK8PfTDztT9PGqZEn68cvHhS8Ya7bu1xfrtik3r7DM53M4TOXkFbj7ZdU6hmEoMKS+1TEAAADgwUocjjIv0JEu9MMNST+drfKnDJuhn/XtqK0Hj+rbjXvkZzNk/njc/xvWS73aNXe2DQmyq3OrmOp/AQAAVAHFAR8V6M+pB67Gsu936B/vfy3pwo/PH3y7UfGxEfrbb25VSJBdH67YqDc+Xe0cGfDZd1vVOqaJnn/wdi1P2iWbzSi1/sfFx+3etpmWJ+0qtd8wpK6tm9bEywMAAAB8St8OLbV8w65S2202QwM6t1LPds317aY9Ze5P6NpGfjab/njPz3TTwG76Yech+dlsGti1teKiGtdEfAAAqoRfiAGgktJOZ+of73/9vyHFP/7vviMnNf+LtRrdv4ve+HS1JNeRAQePZ2jB0nXKycsvszAgSdnn83XnsF5albxPBcXFznY2m6HGYaEa2beje18cAAAA4IMGdG6lHm1jtXlvqnNwgM1mqF6dIP3i+mvUKCxUfdq30A+7UmQYF74CGIah8Pp19f+G95Z04X6HFlHq0CLKuhcCAEAlUBwAgEoq64oh6cKCZF/+sFPB9oCy5ys1TS3fsFM/v7aXNu094lzo7CI/m6HubZqpWXhDvfTInZq/ZK1+2JUifz+bhnRvq3Gj+is0OMhtrwsAAACozSIjI13+96f8/Gz68/036ou12/TNxt3KLyhS7/YtdNuQHmocFipJembCGH2dtFsrNu1WQVGJ+rRvoTEDuqhuHfroAADvRHEAACop+3z+hYXDzNJX/+cXFv24ZkDZE5LmFRZpdL/O+nTNFp3LOe8yMiDQ3193XNtLkhQX3VgzJt4o0zRZpAwAAACoBklJSZfdH+jvr1sGd9ctg7uXud/fz08/u6ajfnYNo3kBALUDq9ECQCV1jItWicNRarthSG2ahatbm2Zl7rcZhjq3jFFYaLBefuRODe7aRv5+NtkMQ73aNddLj9yppuENLnlMCgMAAAAAAACofowcAIBK6t+xpVrHNNHB4xnOdQcuDiS4b2R/dW/bTG2bhWv/0VPO/TbDkGFI40b2lyRFNKynaWNHyTRNmeaFkQMAAAAAAABATWHkAACUITIyUjExMeXOR/rcA7dpZN9OCgzwkyS1jG6iv/zqJvVu30L+fn567je36eZB3RQabJefzVCXVjF6/sGfq1PLaJfHMgyDwgAAAAAAAABqnGFeuiImStm0aZN69uypjRs3qkePHlbHAeBBHA5TxY4SBfozEAsAAG9CHx8AAAC+jl+zAOAq2GyGAm38KQUAAAAAAIB3YVohAAAAAAAAAAB8DJe7AgAAAAAAn+dwmPpu2359u2mPCgqL1CO+uUb27aiQILvV0QAAcAtGDgAAAACw1KpVqzRmzBhFR0fLMAwtXrz4su1XrlwpwzBK3Xbv3l0zgQHUOqZp6rl3v9SMBV9o7bYD2rD7sN74dJUeeOE9ncs5b3U8AADcguIAAFSRaZrak3pCG/ccVlZuvtVxAADwWrm5ueratateeeWVSh23Z88epaWlOW9t2rRxU0IAtd2G3Sn6ZuOFAqPDNCVJpimln8nUu8t/sDIaAABuw7RCAFAF+4+d1LMLluhYxjlJkr+fTXdc20vjRvaTYRjWhgMAwMuMHDlSI0eOrPRx4eHhql+/fvUHAuBzVm/ZLz+boRKH6bLd4TC1YtNePXDLEEtyAQDgTl41cmDmzJnq3bu36tatq/DwcN18883as2fPFY9LTExUz549FRQUpJYtW2rOnDk1kBZAbZWbV6Apsxcq7XSmc1txiUPvLv9Bi1cnWxcMAAAf0717d0VFRWnYsGFasWLFZdsWFBQoKyvLecvJyamhlAC8QYnDcZl9JTWYBACAmuNVxYHExEQ9+OCDWr9+vZYvX67i4mKNGDFCubm55R5z6NAhjRo1SoMGDdLmzZv1xBNP6OGHH9bChQtrMDmA2uTbTXuUfb7AOdz4pz74dqMFiQAA8C1RUVF64403tHDhQi1atEjx8fEaNmyYVq1aVe4xM2fOVFhYmPOWkJBQg4kBeLo+7VuUGjUgSTabof6dWlmQCAAA9/OqaYWWLVvmcn/+/PkKDw/Xxo0bNXjw4DKPmTNnjmJjYzVr1ixJUvv27ZWUlKTnn39et912W5nHFBQUqKCgwHmfq4oA/NSxU2fl72dTcUnpq4syMnNUXFIifz8/C5IBAOAb4uPjFR8f77zfr18/HTlyRM8//3y53wumTp2qyZMnO+8nJydTIADgNLBLa3VpFaNtB4/p4jVANpuh0GC77hlxjbXhAABwE68aOXCpzMwLU3o0bNiw3Dbr1q3TiBEjXLZdf/31SkpKUlFRUZnHcFURgMuJblxfJWUUBiSpUb0QCgMAAFigb9++2rdvX7n77Xa76tWr57yFhobWYDoAns7fz08zf32LJo4eqLioxopqFKYx/bvotd/drahGYVbHAwDALbxq5MBPmaapyZMna+DAgerUqVO57dLT0xUREeGyLSIiQsXFxcrIyFBUVFSpY7iqCMDlXNszXvOWrFVefmGpqYVuH9rTolQAAPi2zZs3l9m3B4CKCgzw1x3X9tId1/ayOgoAADXCa4sDv/3tb7V161atWbPmim0Nw3C5b/74Y96l2y+y2+2y2+3O+1xVBOCnQoOD9NxvbtWMBV/oxJksSZKfzabbErrr1sHdLU4HAID3ycnJ0f79+533Dx06pOTkZDVs2FCxsbGaOnWqjh07prfeekuSNGvWLLVo0UIdO3ZUYWGh3n77bS1cuJB1xQAAAIBK8MriwEMPPaRPP/1Uq1atUtOmTS/bNjIyUunp6S7bTp48KX9/fzVq1MidMQHUYm2bReitafdp1+E05ZwvUNvYCDWoW8fqWAAAeKWkpCQNHTrUef/iKN57771XCxYsUFpamlJTU537CwsL9fjjj+vYsWMKDg5Wx44d9cUXX2jUqFE1nh0AAADwVl5VHDBNUw899JA+/vhjrVy5UnFxcVc8pl+/fvrss89ctn311Vfq1auXAgIC3BUVgA+w2Qx1jIu2OgYAAF5vyJAhztG9ZVmwYIHL/SlTpmjKlCluTgUAAADUbl61IPGDDz6ot99+W++++67q1q2r9PR0paenKy8vz9lm6tSpGjt2rPP+pEmTdPjwYU2ePFm7du3SvHnzNHfuXD3++ONWvAQAAAAAAAAAACznVcWB1157TZmZmRoyZIiioqKct/fff9/Z5tIhx3FxcVqyZIlWrlypbt266c9//rNefvll3XbbbVa8BAAAAAAAAAAALOd10wpdyaVDjiUpISFBmzZtckMiAAAAAAAAAAC8j1eNHAAAAAAAAAAAAFeP4gAAAAAAAAAAAD6G4gAAAAAAAAAAAD6G4gAAAAAAAAAAAD6G4gAAAAAAAAAAAD6G4gAAAAAAAAAAAD7G3+oAAOCNSkocWrJ+m5Z9v1PZ5/PVrXVT3XFtLzUNb2B1NAAAAABVUFhUrE/WbNHXSbuUX1ikPu3j9POhPRXeoK7V0QAAcAuKAwBQSaZp6v/eXqpVyftkSDIlnTybpRWb92rWw3eoVUwTqyMCAAAAqISSEoeeeGOxth44KtO8sO3T77bo20279cpjdymqUZi1AQEAcAOmFQKAStp64JhWJe+TdKEwIEklDlOFRcV68/M11gUDAAAAUCVrtu7Xlv3/KwxIksNhKjevQO989b11wQAAcCOKAwBQST/sOiQ/m1Fqu8M0tXHPYZU4HBakAgAAAFBV35fTxy9xmFq7/aAFiQAAcD+KAwBQSf5+fuXusxmGDJX+UgEAAADAc/nZyv955HL7AADwZnzCAUAlDezcWiUOs9R2m83QgM6tZSvjiiMAAAAAnmtQ1/L7+EO6t7UgEQAA7kdxAAAqqU2zcN0+pIckOQsBhmEoLCRY99840MpoAAAAAKqgd7sWurZHvKQLo4ElyTCkyAb1dM+IPlZGAwDAbfytDgAA3uhXNw5StzbNtHzDLmWfz1fnVjEa3b+z6ofWsToaAAAAgEoyDEN/uOdn6t+5lVZs2qOCwiL1iG+uUX07KSTYbnU8AADcguIAAFSBYRi6pkOcrukQZ3UUAAAAANXAZjOU0K2tEroxjRAAwDcwrRAAAAAAAAAAAD6G4gAAAAAAAAAAAD6G4gAAAAAAAAAAAD6G4gAAAAAAAAAAAD6G4gAAAAAAAAAAAD6G4gAAAAAAAAAAAD7G3+oAsE5aWprS0tKsjoEriIqKUlRUlNUxcBm8l7wD7yUAgC+gX+L56JN4B95L3oH3EwBcHYoDFRAVFaXp06fXqg+cgoIC3XXXXUpMTLQ6Cq4gISFBX375pex2u9VRUAbeS96D9xIA4Kfo48Mq9Ek8H+8l78H7CQCujmGapml1CNS8rKwshYWFKTExUaGhoVbHQTlycnKUkJCgzMxM1atXz+o4KAPvJe/AewkA4Avol3g++iTegfeSd+D9BABXj5EDPq5bt258iHqwrKwsqyOggngveTbeSwAAX0K/xHPRJ/EuvJc8G+8nALh6LEgMAAAAAAAAAICPoTgAAAAAAAAAAICPoTjgo+x2u6ZPn86iPR6O8+T5OEfegfMEAPAFfN55Ps6Rd+A8eQfOEwBcPRYkBgAAAAAAAADAxzByAAAAAAAAAAAAH0NxAAAAAAAAAAAAH0NxAAAAAAAAAAAAH0NxAAAAAAAAAAAAH0NxoBp99NFHMgxD77//fql9Xbt2lWEY+vLLL0vta9WqlXr06HHZxx43bpwMw3De7Ha74uPjNX36dOXn5zvbPf300zIM4+pfzFVauXKlDMPQRx99ZHWUci1YsMD577ly5cpS+03TVOvWrWUYhoYMGXLFxxsyZIjLOQoODlbXrl01a9YsORwOZ7tx48apRYsW1fdCquji609KSrI6SrWoyfdfSEiIWrRooRtvvFHz589XQUFBtb0OX+HO95/NZlPdunXVunVr/fznP9dHH33k8h4EAKAy6OP/D318+vg1jT6+d6GPDwDeh+JANbr4wbVixQqX7WfOnNG2bdsUEhJSat/Ro0d18OBBDR069IqPHxwcrHXr1mndunVavHixrrnmGs2YMUP33ntvtb4OX1O3bl3NnTu31PbExEQdOHBAdevWrfBjtWzZ0nmO3n//fcXExOixxx7T1KlTqzMyylCT77/PP/9cM2bMUEhIiO6//3717NlTR48erdbX4yvc8f5bu3atFi9erD/+8Y/Ky8vTz3/+cw0ZMkSZmZnVGR0A4CPo43sn+vi1A31870QfHwC8h7/VAWqTxo0bq1OnTqUq5ImJifL399eECRNKdVwu3q9Ix8Vms6lv377O+yNHjlRKSoo++OADvfjii4qJibn6F+GD7rzzTr3zzjt69dVXVa9ePef2uXPnql+/fsrKyqrwYwUHB5c6R+3atdMrr7yiZ599VgEBAdWaHf9T0+8/SRo7dqzuu+8+jR49WrfffrvWr19/2cfIy8tTcHBwBV6N73Dn+0+SJk6cqPnz52v8+PH61a9+VeZVZxeZpqn8/HzOEQDABX1870Qfv3agj++d6OMDgPdg5EA1Gzp0qPbs2aO0tDTntpUrV6p3794aNWqUNm7cqOzsbJd9fn5+GjRoUJWe7+KH5OHDh8tt8/7772vEiBGKiopScHCw2rdvrz/+8Y/Kzc0t1fb777/XmDFj1KhRIwUFBalVq1Z69NFHXdrs27dPd999t8LDw2W329W+fXu9+uqrZT53fn6+Jk+erMjISAUHByshIUGbN28u1e7TTz9Vv379VKdOHdWtW1fXXXed1q1bV4l/iaq76667JEnvvfeec1tmZqYWLlyo8ePHX9VjBwQEqGfPnjp//rxOnTpVbrtXX31VgwcPVnh4uEJCQtS5c2c999xzKioqKtV22bJlGjZsmMLCwlSnTh21b99eM2fOdGmTlJSkG2+8UQ0bNlRQUJC6d++uDz74oMznPnv2rO677z41bNhQISEhGjNmjA4ePFiq3bx589S1a1cFBQWpYcOGuuWWW7Rr165K/ou4V02//yRpxIgRuv/++/X9999r1apVzu0tWrTQ6NGjtWjRInXv3l1BQUF65plnlJKSIsMwtGDBglKPZRiGnn76aZdtn3zyibp06SK73a6WLVvqpZde8pipBaqDO99/F913330aNWqUPvzwQ5e/lYZh6Le//a3mzJmj9u3by26369///rdzyoRLv4SWd+7+9a9/qW3btrLb7erQoYPeffddj5laAABQPejju6KPTx+/JtHH9z708QHAe1AcqGYXr0746QfOihUrlJCQoAEDBsgwDK1evdplX48ePRQWFlal59u/f78kqUmTJuW22bdvn0aNGqW5c+dq2bJlevTRR/XBBx9ozJgxLu2+/PJLDRo0SKmpqXrxxRe1dOlSPfnkkzpx4oSzzc6dO9W7d29t375dL7zwgj7//HPdcMMNevjhh/XMM8+Ueu4nnnhCBw8e1Jtvvqk333xTx48f15AhQ1w6pu+++65uuukm1atXT++9957mzp2rs2fPasiQIVqzZk2V/l0qo169err99ts1b94857b33ntPNptNd95551U//oEDB+Tv768GDRpcts3dd9+t//znP/r88881YcIE/f3vf9evf/1rl3Zz587VqFGj5HA4NGfOHH322Wd6+OGHXYa7rlixQgMGDNC5c+c0Z84cffLJJ+rWrZvuvPPOMjurEyZMkM1m07vvvqtZs2bphx9+0JAhQ3Tu3Dlnm5kzZ2rChAnq2LGjFi1apJdeeklbt25Vv379tG/fvqv+N6ouNf3+u+jGG2+UJJcvDpK0adMm/f73v9fDDz+sZcuW6bbbbqvU4y5btky33nqrGjVqpPfff1/PPfec3nvvPf373/++qryexN3vv4tuvPFGmabpcv4lafHixXrttdf01FNPOf8GVsYbb7yhX/3qV+rSpYsWLVqkJ598Us8880yZc6wCALwXfXxX9PHp49ck+vjehz4+AHgRE9XqzJkzps1mM3/1q1+ZpmmaGRkZpmEY5rJly0zTNM0+ffqYjz/+uGmappmammpKMqdMmXLFx7333nvNkJAQs6ioyCwqKjJPnTplvvTSS6ZhGGbv3r2d7aZPn25e7rQ6HA6zqKjITExMNCWZW7Zsce5r1aqV2apVKzMvL6/c46+//nqzadOmZmZmpsv23/72t2ZQUJB55swZ0zRNc8WKFaYks0ePHqbD4XC2S0lJMQMCAsyJEyeapmmaJSUlZnR0tNm5c2ezpKTE2S47O9sMDw83+/fvf8V/m6qaP3++KcncsGGDM+/27dtN0zTN3r17m+PGjTNN0zQ7duxoJiQkXPHxEhISzI4dOzrP0fHjx80//vGPpiTz5z//ubPdvffeazZv3rzcxykpKTGLiorMt956y/Tz83P+m2ZnZ5v16tUzBw4c6PJveql27dqZ3bt3N4uKily2jx492oyKinL+O198/bfccotLu++++86UZD777LOmaZrm2bNnzeDgYHPUqFEu7VJTU0273W7efffdV/y3qSnufv+VZ9euXaYk8ze/+Y1zW/PmzU0/Pz9zz549Lm0PHTpkSjLnz59f6nEkmdOnT3fe7927t9msWTOzoKDAuS07O9ts1KjRZd/n3sBd77/yLF261JRk/u1vf3Nuk2SGhYU532MXXcyzYsUKl+2XnruSkhIzMjLSvOaaa1zaHT582AwICLjs+xwA4F3o49PHp49vHfr43oM+PgB4H0YOVLMGDRqoa9euzopyYmKi/Pz8NGDAAElSQkKCcw7EysyFKEm5ubkKCAhQQECAmjRpokcffVQjR47Uxx9/fNnjDh48qLvvvluRkZHy8/NTQECAEhISJMk5ZHTv3r06cOCAJkyYoKCgoDIfJz8/X998841uueUW1alTR8XFxc7bqFGjlJ+fX2o+xrvvvttlaGTz5s3Vv39/52vfs2ePjh8/rl/+8pey2f73n2NoaKhuu+02rV+/XufPn6/Qv8/VSEhIUKtWrTRv3jxt27ZNGzZsqNJwxx07djjPUXR0tF544QXdc889+te//nXZ4zZv3qwbb7xRjRo1cp6jsWPHqqSkRHv37pUkrV27VllZWXrggQfKHW66f/9+7d69W/fcc48klTpHaWlp2rNnj8sxF9te1L9/fzVv3tx5jtatW6e8vDyNGzfOpV2zZs107bXX6ptvvqnwv4+7ufP9dzmmaZa5vUuXLmrbtm2VHjM3N1dJSUm6+eabFRgY6NweGhpa6opAb1dd77/LKe8cXXvttZe94u9y9uzZo/T0dN1xxx0u22NjY53/zQEAagf6+PTx6eNbhz6+d6KPDwDegQWJ3WDo0KF68cUXdfz4ca1YsUI9e/ZUaGiopAsfkC+88IIyMzO1YsUK+fv7a+DAgRV63ODgYOeQRrvdrubNm7ss7lOWnJwcDRo0SEFBQXr22WfVtm1b1alTR0eOHNGtt96qvLw8SXLOldm0adNyH+v06dMqLi7WP//5T/3zn/8ss01GRobL/cjIyFJtIiMjtWXLFudjSlJUVFSpdtHR0XI4HDp79qzq1Klz2dd5tQzD0H333aeXX35Z+fn5atu2bZXmqGzVqpX++9//yjAMBQUFKS4u7orZU1NTNWjQIMXHx+ull15SixYtFBQUpB9++EEPPvhgpc7RxeHhjz/+uB5//PEy21T0HF08N1c6R8uXL7/s66tp7nr/Xc7FOS6jo6Ndtpf1b1ZRZ8+elWmaioiIKLWvrG3erLref5fjjnN08b1R3jk6dOhQlR8bAOB56OP/D318+vg1jT6+96GPDwDegeKAG1zsuKxcuVIrV67UqFGjnPsudlJWrVrlXETpYqfmSmw2m3r16lWpLN9++62OHz+ulStXOq8kkuQy16T0v/lMfzqv5aUaNGggPz8//fKXv9SDDz5YZpu4uDiX++np6aXapKenq1GjRpLk/N+fLi510fHjx2Wz2apc8a+scePG6amnntKcOXP0l7/8pUqPERQUVOlztHjxYuXm5mrRokVq3ry5c3tycrJLu4qco8aNG0uSpk6dqltvvbXMNvHx8S73yztHrVu3lnTlc3TxOT2Fu95/l/Ppp59KkoYMGeKyvayrvy5etVdQUOCy/WIn9KIGDRrIMAyX+YAvKuucebvqeP9dzqeffirDMDR48GCX7ZU5R5d+6b743vCVcwQAvo4+/v/Qx78y+vjViz6+d6KPDwCej2mF3GDw4MHy8/PTRx99pB07drh0JsLCwtStWzf9+9//VkpKSrUMd7ycix+KdrvdZfvrr7/ucr9t27bOIX+XflheVKdOHQ0dOlSbN29Wly5d1KtXr1K3ix+kF7333nsuQ/0OHz6stWvXOv9N4uPjFRMTo3fffdelXW5urhYuXKh+/fq5/Yqii2JiYvT73/9eY8aM0b333lsjzymVfY5M0yw1TLl///4KCwvTnDlzyh0+GR8frzZt2mjLli1lnp9evXqpbt26Lse88847LvfXrl2rw4cPO89Rv379FBwcrLffftul3dGjR/Xtt99q2LBhVXrd7lLT77/ly5frzTffVP/+/St0hVJERISCgoK0detWl+2ffPKJy/2QkBD16tVLixcvVmFhoXN7Tk6OPv/886vO7Wnc+f6bP3++li5dqrvuukuxsbFXbN+iRQtJKnWOLn5BvCg+Pl6RkZH64IMPXLanpqZq7dq1VxcaAOBx6OP/D338K6OPX73o43sn+vgA4PkYOeAG9erVU48ePbR48WLZbLZS89IlJCRo1qxZkqpnLsTL6d+/vxo0aKBJkyZp+vTpCggI0DvvvOMc8vtTr776qsaMGaO+ffvqscceU2xsrFJTU/Xll186O5cvvfSSBg4cqEGDBuk3v/mNWrRooezsbO3fv1+fffaZvv32W5fHPHnypG655Rbdf//9yszM1PTp0xUUFKSpU6dKunCl1HPPPad77rlHo0eP1q9//WsVFBTo73//u86dO6e//vWvbv33uVRNP58kXXfddQoMDNRdd92lKVOmKD8/X6+99prOnj3r0i40NFQvvPCCJk6cqOHDh+v+++9XRESE9u/fry1btuiVV16RdOFL4ciRI3X99ddr3LhxiomJ0ZkzZ7Rr1y5t2rRJH374ocvjJiUlaeLEifr5z3+uI0eOaNq0aYqJidEDDzwgSapfv77+9Kc/6YknntDYsWN111136fTp03rmmWcUFBSk6dOn18w/VAW56/3ncDic8+0WFBQoNTVVS5cu1QcffKD27duX6jyWxzAM/eIXv9C8efPUqlUrde3aVT/88IPefffdUm1nzJihG264Qddff70eeeQRlZSU6O9//7tCQ0N15syZCmf3Flf7/svLy3Oeo7y8PB08eFCLFy/W559/roSEBM2ZM6dCjxMZGanhw4dr5syZatCggZo3b65vvvlGixYtcmlns9n0zDPP6Ne//rVuv/12jR8/XufOndMzzzyjqKgolzmWAQDejz7+/9DHvzL6+NWLPr73oo8PAB7OilWQfcGUKVNMSWavXr1K7Vu8eLEpyQwMDDRzc3Mr9Hj33nuvGRIScsV206dPNy89rWvXrjX79etn1qlTx2zSpIk5ceJEc9OmTaYkc/78+S5t161bZ44cOdIMCwsz7Xa72apVK/Oxxx5zaXPo0CFz/PjxZkxMjBkQEGA2adLE7N+/v/nss88626xYscKUZP7nP/8xH374YbNJkyam3W43Bw0aZCYlJZX5b3LNNdeYQUFBZkhIiDls2DDzu+++q9C/TVXNnz/flGRu2LDhsu06duxoJiQkXPHxEhISzI4dO16x3b333ms2b97cZdtnn31mdu3a1QwKCjJjYmLM3//+9+bSpUtNSeaKFStc2i5ZssRMSEgwQ0JCzDp16pgdOnQw//a3v7m02bJli3nHHXeY4eHhZkBAgBkZGWlee+215pw5c5xtLr7+r776yvzlL39p1q9f3wwODjZHjRpl7tu3r1TuN9980+zSpYsZGBhohoWFmTfddJO5Y8eOK75eK7jj/SfJeQsODjZjY2PNMWPGmPPmzTMLCgpKHdO8eXPzhhtuKPPxMjMzzYkTJ5oRERFmSEiIOWbMGDMlJcWUZE6fPt2l7ccff2x27tzZDAwMNGNjY82//vWv5sMPP2w2aNCgQtk9lTvefz89RyEhIWbLli3N22+/3fzwww/NkpKSUsdIMh988MEyHy8tLc28/fbbzYYNG5phYWHmL37xCzMpKanMv5tvvPGG2bp1azMwMNBs27atOW/ePPOmm24yu3fvfsXcAADvQh+fPn556OO7H318z0cfHwC8j2Ga5YxdBAB4nKKiInXr1k0xMTH66quvrI6DMpw7d05t27bVzTffrDfeeMPqOAAAAPBw9PE9H318ALUV0woBgAebMGGCrrvuOkVFRSk9PV1z5szRrl279NJLL1kdDbqwKNlf/vIXDR06VI0aNdLhw4f1j3/8Q9nZ2XrkkUesjgcAAAAPRB/fs9HHB+BLKA4AgAfLzs7W448/rlOnTikgIEA9evTQkiVLNHz4cKujQRcWGUxJSdEDDzygM2fOqE6dOurbt6/mzJmjjh07Wh0PAAAAHog+vmejjw/AlzCtEAAAAAAAAAAAPoZl1gEAAAAAAAAA8DEUBzzIggULZBiGgoKCdPjw4VL7hwwZok6dOtVopkWLFumuu+5S69atFRwcrBYtWuiee+7Rvn37ymz/9ddfq1+/fqpTp44aN26scePG6eTJkzWa2Z04R96B8+QdOE8AAF/A553n4xx5B86Td+A8AYB3oTjggQoKCvTkk09aHUOS9Le//U3nz5/XtGnTtGzZMj377LPavHmzevTooR07dri0TUxM1MiRIxUREaFPPvlEL730kr7++msNGzZMBQUFFr0C9+AceQfOk3fgPAEAfAGfd56Pc+QdOE/egfMEAF7ChMeYP3++Kcn82c9+ZtpsNjM5Odllf0JCgtmxY8cazXTixIlS244dO2YGBASYEyZMcNneu3dvs0OHDmZRUZFz23fffWdKMmfPnu32rDWBc+QdOE/egfMEAPAFfN55Ps6Rd+A8eQfOEwB4F0YOeKApU6aoUaNG+sMf/mB1FIWHh5faFh0draZNm+rIkSPObceOHdOGDRv0y1/+Uv7+/s7t/fv3V9u2bfXxxx/XSN6awjnyDpwn78B5AgD4Aj7vPB/nyDtwnrwD5wkAvAPFAQ9Ut25dPfnkk/ryyy/17bffVvp4h8Oh4uLiK95KSkqqlO/gwYM6fPiwOnbs6Ny2fft2SVKXLl1Kte/SpYtzf23BOfIOnCfvwHkCAPgCPu88H+fIO3CevAPnCQC8A8UBDzVp0iS1bNlSf/jDH2SaZqWOnTFjhgICAq54a9WqVaVzFRcXa8KECQoNDdVjjz3m3H769GlJUsOGDUsd07BhQ+f+2oRz5B04T96B8wQA8AV83nk+zpF34Dx5B84TAHg+/ys3gRUCAwP17LPP6u6779YHH3ygO++8s8LH/upXv9Lo0aOv2M5ut1cqk2mamjBhglavXq2FCxeqWbNmpdoYhlHmseVt92acI+/AefIOnCcAgC/g887zcY68A+fJO3CeAMDzURzwYP/v//0/Pf/885o2bZpuvfXWCh8XGRlZ5px6l6rMB5tpmpo4caLefvtt/fvf/9ZNN93ksr9Ro0aSVGYl/cyZM2VW3msDzpF34Dx5B84TAMAX8Hnn+ThH3oHz5B04TwDg2ZhWyIMZhqG//e1vOnDggN54440KH1fdw+8ufoDOnz9fb775pn7xi1+UatOpUydJ0rZt20rt27Ztm3N/bcM58g6cJ+/AeQIA+AI+7zwf58g7cJ68A+cJADwbIwc83PDhw3XddddpxowZZQ53K0t1Dr8zTVP333+/5s+fr9dff1333Xdfme1iYmLUp08fvf3223r88cfl5+cnSVq/fr327NmjRx99tELZvRHnyDtwnrwD5wkA4Av4vPN8nCPvwHnyDpwnAPBgJjzG/PnzTUnmhg0bXLZv2rTJNAzDlGR27NixRjP99re/NSWZ48ePN9etW+dy27Rpk0vbFStWmP7+/uYtt9xiLl++3HznnXfMZs2amZ06dTLz8/NrNLe7cI68A+fJO3CeAAC+gM87z8c58g6cJ+/AeQIA70JxwIOU9yFqmqZ59913W/Ih2rx5c1NSmbfmzZuXav/VV1+Zffv2NYOCgsyGDRuaY8eONU+cOFGjmd2Jc+QdOE/egfMEAPAFfN55Ps6Rd+A8eQfOEwB4F8M0TbPi4wwAAAAAAAAAAIC3Y0FiAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMUBAAAAAAAAAAB8DMWBCkhLS9PTTz+ttLQ0q6MAAACgGtHP812cewAAgNqJfl7FURyogLS0ND3zzDP8BwUAAFDL0M/zXZx7AACA2ol+XsVRHAAAAAAAAAAAwMdQHAAAAAAAAAAAwMdQHAAAAAAAAAAAwMdQHAAAAAAAAAAAwMdQHAAAAAAAAAAAwMdQHAAAAAAAAAAAwMdQHAAAAAAAAAAAwMdQHAAAAAAAAAAAwMdQHAAAAAAAAAAAwMdQHAAAAAAAAAAAwMdQHAA8XF5entURAAAAAADwOMXFxVZHAACvRnEA8HDnzp2zOgIAAAAAAB6nqKjI6ggA4NUoDgAeLj8/3+oIAAAAAAB4HIfDYXUEAPBqFAcAD0dxAAAAAACA0igOAMDVoTgAeLjz589bHQEAAAAAAI9TUlJidQQA8GoUBwAPR3EAAADUdqtWrdKYMWMUHR0twzC0ePHiy7ZftGiRrrvuOjVp0kT16tVTv3799OWXX9ZMWACAx6A4AKA6+HJflOIA4OGys7OtjgAAAOBWubm56tq1q1555ZUKtV+1apWuu+46LVmyRBs3btTQoUM1ZswYbd682c1JAQCepLi42OoIAGoBX+6L+lsdAMDlZWZmyjRNGYZhdRQAAAC3GDlypEaOHFnh9rNmzXK5/3//93/65JNP9Nlnn6l79+5lHlNQUKCCggLn/ZycnCplBQB4jqKiIqsjAPBgOTk5ysrKct632+2y2+2l2tVEX9RTMXIA8HD5+fl8eQUAALgMh8Oh7OxsNWzYsNw2M2fOVFhYmPOWkJBQgwkBAO5QWFhodQQAHiwhIcGl/zdz5ky3PE9F+qKeiuIA4AWOHj1qdQQAAACP9cILLyg3N1d33HFHuW2mTp2qzMxM5y0xMbEGEwIA3IHiAIDLSUxMdOn/TZ061S3PU5G+qKdiWiHAC6SkpKh9+/ZWxwAAAPA47733np5++ml98sknCg8PL7fdpcPIQ0NDayIeAMCNfjpdHABcKjQ0VPXq1XPrc1S0L+qpGDkAeIFjx44pLy/P6hgAAAAe5f3339eECRP0wQcfaPjw4VbHAQDUsPz8fKsjAPBhtaEvSnEA8AIOh0P79++3OgYAAIDHeO+99zRu3Di9++67uuGGG6yOAwCwwPnz52WaptUxAPig2tIX9briwKpVqzRmzBhFR0fLMAwtXrz4su1XrlwpwzBK3Xbv3l0zgYFqsmvXLjo9AABYjL6oe+Tk5Cg5OVnJycmSpEOHDik5OVmpqamSLqwXMHbsWGf79957T2PHjtULL7ygvn37Kj09Xenp6crMzLQiPgDAIsXFxSoqKrI6BgAv58t9Ua8rDuTm5qpr16565ZVXKnXcnj17lJaW5ry1adPGTQmB6tOrVy/97ne/01/+8hedO3dOKSkpVkcCAMCn0Rd1j6SkJHXv3l3du3eXJE2ePFndu3fXU089JUlKS0tzfjmTpNdff13FxcV68MEHFRUV5bw98sgjluQHAFgnJyfH6ggAvJwv90W9bkHikSNHauTIkZU+Ljw8XPXr169Q24KCApdFbfiggVXS09N19uxZ54iBH374QbGxsfLz87M4GQAAtUtOTo6ysrKc9y9dvPaimuiL+qIhQ4ZcdoTkggULXO6vXLnSvYEAAF4jKytLDRs2tDoGAC/my31Rrxs5UFXdu3dXVFSUhg0bphUrVly27cyZMxUWFua8JSQk1FBK4PIyMzO1adMmq2MAAFDrJCQkuPT/Zs6cWa2PX5m+KAAAqLifFvcBAJVT64sDUVFReuONN7Rw4UItWrRI8fHxGjZsmFatWlXuMVOnTlVmZqbzlpiYWIOJgctLTk7W8ePHrY4BAECtkpiY6NL/mzp1arU8blX6ogAAoOK8cY5vAPAUXjetUGXFx8crPj7eeb9fv346cuSInn/+eQ0ePLjMYy4dRh4aGur2nEBFmaapr7/+WjfffLPq1atndRwAAGqF0NBQt3yuVqUvCgAAKo6RAwBQdbV+5EBZ+vbtq3379lkdA6iy/Px8LVmyRLm5uVZHAQAAlURfFACA6kNxAACqzieLA5s3b1ZUVJTVMYCrkpWVpU8//ZQhlAAAeBn6ogAAVJ+cnBw5HA6rYwCAV/K6aYVycnK0f/9+5/1Dhw4pOTlZDRs2VGxsrKZOnapjx47prbfekiTNmjVLLVq0UMeOHVVYWKi3335bCxcu1MKFC616CUC1yc7O1uLFizV8+HDFxMRYHQcAgFqPvigAAJ7FNE3l5uaqbt26VkcBvNbZs2fVoEEDq2PAAl5XHEhKStLQoUOd9ydPnixJuvfee7VgwQKlpaUpNTXVub+wsFCPP/64jh07puDgYHXs2FFffPGFRo0aVePZAXcoKCjQkiVLdM0116hz584yDMPqSAAA1Fr0RQEA8DzZ2dkUB4CrUFxcbHUEWMTrigNDhgyRaZrl7l+wYIHL/SlTpmjKlCluTgVYyzRNrV+/XidPnlRCQoICAgKsjgQAQK1EXxQAAM+TmZmp6Ohoq2MAXqukpMTqCLCIT645ANRWBw8e1OLFi3Xu3DmrowAAAAAAUCPOnj1rdQTAq1Ec8F0UB4Ba5uzZs/r444+1Z8+ey17ZCAAAAABAbXDmzBmrIwBejWmFfBfFAaAWKioqUmJiopYuXarMzEyr4wAAAAAA4DanT5/m4jjgKpimKYfDYXUMWIDiAFCLHT16VB9++KHWrl2rvLw8q+MAAAAAAFDtCgoKlJWVZXUMwKsxesA3ed2CxAAqx+FwaPv27dqzZ4+6dOmiLl26sGAxAAAAAMCr9erVS4cPH1adOnU0bdo0paenKywszOpYgNcqLi5WYGCg1TFQwxg5APiIoqIibdy4UR9++KGOHj1qdRwAAAAAAKosPT1dGRkZzhEDfM8Frg4jB3wTxQHAx+Tk5Gjp0qXas2eP1VEAAAAAAKgWR44cUUlJidUxAK9FccA3URwAfJBpmlq9ejWLFQMAAAAAaoXCwkIdOnTI6hiA1yoqKrI6AixAcQDwUQ6HQ1u2bLE6BgAAAAAA1WL79u0yTdPqGIBXYuSAb6I4AHioffv2OedOzMvL04kTJ9zyHLm5udX+uAAAAAAA1LSTJ08qJSXF6hiAV6I44JsoDgAeaP78+WrXrp2ys7MlSQUFBZo+fbrWrl1brc9TUlKi1atXc2UFAAAAAKBWWL9+PdOjAFXA+8Y3URwAPMy+ffs0ceJEORwOl+2maeqtt97SyZMnq/X5UlNTtXXr1mp9TAAAAAAArJCdna0NGzZYHQPwOhQHfBPFAcDDzJs3T4ZhlLnPMAx999131f6cGzZsYHFiAAAAAECtsGPHDqWlpVkdA/AqFAd8E8UBwMOkpKSUO82PaZo6ffp0tT+nw+HQ4cOHq/1xAQAAAACoaaZpauXKlfzYCVQC7xffRHEA8DAtWrS47MiBRo0aueV5Gzdu7JbHBQAAAACgpmVnZ2vTpk1WxwC8BsUB30RxAPAw48ePv+zIgQEDBlT7c7Zr107R0dHV/rgAAAAVsWrVKo0ZM0bR0dEyDEOLFy++4jGJiYnq2bOngoKC1LJlS82ZM8f9QQEAXmXbtm3KysqyOgbgFXy5OODLfVGKA4CHadOmjebOnSubzfXtaRiGxo4dq/Dw8Gp9vubNm2vgwIHV+pgAAACVkZubq65du+qVV16pUPtDhw5p1KhRGjRokDZv3qwnnnhCDz/8sBYuXOjmpAAAb+JwOLRx40arYwBeobi42OoIlvHlvqi/1QEAlDZu3DgNHDhQPXr0UHZ2tux2u5588slqLww0a9ZMw4cPL1WIAAAAqEkjR47UyJEjK9x+zpw5io2N1axZsyRJ7du3V1JSkp5//nnddtttbkoJAPBGBw4c0DXXXKM6depYHQXwaL48csCX+6L8Igh4qNatW6tevXqSpODgYLcUBkaMGCE/P79qfVwAAAB3W7dunUaMGOGy7frrr1dSUlK5X2wLCgqUlZXlvOXk5NREVACAxRwOh3bt2mV1DMDj1cbiQE5Ojkv/r6CgoFoetyp9UU9FcQDwQXFxcRQGAACA10pPT1dERITLtoiICBUXFysjI6PMY2bOnKmwsDDnLSEhoSaiAgA8wJ49e8pd2w/ABbVxWqGEhASX/t/MmTOr5XGr0hf1VBQHAB/TvXt3DR8+nMIAAADwaoZhuNy/+KPPpdsvmjp1qjIzM523xMREt2cEAHiGnJwcHT582OoYgEfztiveKyIxMdGl/zd16tRqe+zK9kU9FWsOAD4iKChIQ4YMUWxsrNVRAAAArkpkZKTS09Ndtp08eVL+/v5q1KhRmcfY7XbZ7Xbn/dDQULdmBAB4li1btqh58+Ze98MdUFNq48iB0NBQ55Td1akqfVFPxcgBwAfExMTotttuozAAAABqhX79+mn58uUu27766iv16tVLAQEBFqUCAHiyEydO6MiRI1bHADxWbRw54C61qS9KcQCoxQzDUK9evTRq1CiFhIRYHQcAAKBMOTk5Sk5OVnJysiTp0KFDSk5OVmpqqqQLUwKNHTvW2X7SpEk6fPiwJk+erF27dmnevHmaO3euHn/8cSviAwC8xLp162rl1dFAdfDl4oAv90UpDgC1VGBgoH72s5+pR48eDJsEAAAeLSkpSd27d1f37t0lSZMnT1b37t311FNPSZLS0tKcX84kKS4uTkuWLNHKlSvVrVs3/fnPf9bLL7+s2267zZL8AADvkJmZqfXr11sdA/BIxcXFPrtwty/3RVlzAKiFQkNDNXLkSDVo0MDqKAAAAFc0ZMiQy34ZXbBgQaltCQkJ2rRpkxtTAQBqo507dyoqKkqtWrWyOgrgcQoLC13WaPIVvtwXZeQAUMs0bNhQN910E4UBAAAAAADKsHLlSp08edLqGIDHKSwstDoCapjXFQdWrVqlMWPGKDo6WoZhaPHixVc8JjExUT179lRQUJBatmypOXPmuD8oYIGYmBjdeOONrC8AAICb0BcFAMD7lZSUaNmyZTp79qzVUQCPUlBQYHUE1DCvKw7k5uaqa9eueuWVVyrU/tChQxo1apQGDRqkzZs364knntDDDz+shQsXujkpULM6d+6skSNHKjAw0OooAADUWvRFAQCoHfLz87VkyRJlZWVZHQXwGHl5eVZHQA3zujUHRo4cqZEjR1a4/Zw5cxQbG6tZs2ZJktq3b6+kpCQ9//zz5S4SUVBQ4FIpy8nJuarMgDvZ7XYNHjxYcXFxVkcBAMBr5eTkuPw4YLfby5xvtSb6ogAAoGbk5ubq888/1+jRo1WvXj2r4wCWozjge7xu5EBlrVu3TiNGjHDZdv311yspKUlFRUVlHjNz5kyFhYU5bwkJCTURFai0iIgI3XbbbRQGAAC4SgkJCS79v5kzZ1bL41alLwoAAGpOTk6OPv/8c0YQALpQMINvqfXFgfT0dEVERLhsi4iIUHFxsTIyMso8ZurUqcrMzHTeEhMTayIqUCnt2rXT6NGjFRoaanUUAAC8XmJiokv/b+rUqdXyuFXpiwIAgJp1sUCQnZ1tdRTAUsye4nu8blqhqjAMw+W+aZplbr/o0mHk/PgKT9OtWzf17t273P+GAQBA5YSGhrptOoHK9kUBAEDNy8nJ0ZIlS3TjjTcqODjY6jiAJSiQ+Z5aP3IgMjJS6enpLttOnjwpf39/NWrUyKJUQNV16NCBwgAAAF6CvigAAN4jMzNTX375pUpKSqyOAlgiMzPT6gioYbW+ONCvXz8tX77cZdtXX32lXr16KSAgwKJUQNVERUWpf//+FAYAAPAS9EUBAPAuJ0+eVFJSktUxAEvk5OSouLjY6hioQV5XHMjJyVFycrKSk5MlSYcOHVJycrJSU1MlXVgvYOzYsc72kyZN0uHDhzV58mTt2rVL8+bN09y5c/X4449bER+olMjISDVo0ED16tVTQECAhg4dKpvN6962AADUGvRFAQCo/bZu3arTp09bHQOocaZp6uzZs1bHQA3yujUHkpKSNHToUOf9yZMnS5LuvfdeLViwQGlpac4vZ5IUFxenJUuW6LHHHtOrr76q6Ohovfzyy7rttttqPDtQWUlJSZo/f76KiorUpUsX1r8AAMBi9EUBAKj9TNPUtm3bNGTIEKujADXuzJkzatKkidUxUEO8rjgwZMgQ5yJuZVmwYEGpbQkJCdq0aZMbUwHuZRiGOnToYHUMAAB8Hn1RAAB8w6FDhzR48GBG78PnZGRkKD4+3uoYqCH8hQO8QHh4uIKDg62OAQAAAACATygqKmJqIfikjIwMqyOgBnndyAHAF4WHh1sdAQAAAAAAn8L0KvAFvXr10rFjxxQYGKhp06YpIyNDDoeDUTM+grMMeIFGjRpZHQEAAAAAAJ/CwqzwBenp6UpPT1dWVpYkqaSkRGfOnLE4FWoKxQHAC1AcAAAAAACgZjGtEHzViRMnrI6AGkJxAPBw/v7+atCggdUxAAAAAADwKadOnZLD4bA6BlDjKA74DooDgIdr2LAh87wBAAAAAFDDCgsLWZwVPonigO/gF0fAwzVs2NDqCAAAAAAA+KQjR45YHQGocdnZ2crOzrY6BmoAxQHAw9WrV8/qCAAAAAAAeIx9+/Y5F0/Ny8tz61XOqampbntswJOlpaVZHQE1gOIA4OGCg4OtjgAAAAAAgEeYP3++2rVr57yquaCgQNOnT9fatWvd8nwZGRnKy8tzy2MDnuzo0aNWR0ANoDgAeDi73W51BAAAAAAALLdv3z5NnDix1CLBpmnqrbfe0smTJ6v9OU3TVHp6erU/LuDpjh49KtM0rY4BN6M4AHi4gIAAqyMAAAAAAGC5efPmyTCMMvcZhqHvvvvOLc/LosTwRfn5+W4puMGzUBwAPBzFAaB6lJSUWB0BAAAAwFVISUkp90pm0zR1+vRptzzvxfUNAF9z6NAhqyPAzSgOAB6ONQeA6pGfn291BADAZcyePVtxcXEKCgpSz549tXr16su2f+edd9S1a1fVqVNHUVFRuu+++9z2oxAAwDO0aNHisiMHGjVq5Jbn5bsEfNWhQ4d8amohX+yPUhwAPFxQUJDVEYBaobCw0OoIAIByvP/++3r00Uc1bdo0bd68WYMGDdLIkSOVmppaZvs1a9Zo7NixmjBhgnbs2KEPP/xQGzZs0MSJE2s4OVB5JSUlys3NtToG4JXGjx9/2ZEDAwYMcMvzlleQAGq77Oxsn5layFf7oxQHAAA+4fz581ZHAACU48UXX9SECRM0ceJEtW/fXrNmzVKzZs302muvldl+/fr1atGihR5++GHFxcVp4MCB+vWvf62kpKQaTg5UnmmaXLQAVFGbNm00d+5c2WyuP2cZhqGxY8cqPDzcLc/LRXvwZfv377c6Qo3w1f4oxQEAgE/Izs62OgIA1IhVq1bp9ttvV8eOHdWyZUuXW6tWrayOV0phYaE2btyoESNGuGwfMWKE1q5dW+Yx/fv319GjR7VkyRKZpqkTJ07oo48+0g033FDu8xQUFCgrK8t5y8nJqdbXAVRGcXGx1REArzVu3Djt2bNHdevWlSTZ7XbNmDFD/fv3d9tzNmjQwG2PDXi6gwcPyuFwWB2jSnJyclz6fwUFBWW2q6n+6NVwVx+f4gAAwCecO3fOazs0AFBRa9as0bBhw5SZmaldu3apXbt2iomJUWpqqvz9/TV48GCrI5aSkZGhkpISRUREuGyPiIhQenp6mcf0799f77zzju68804FBgYqMjJS9evX1z//+c9yn2fmzJkKCwtz3hISEqr1dQCVQXEAuDqtW7dWvXr1JF1Yp89dIwYuioqKcuvjA54sLy9PR44csTpGlSQkJLj0/2bOnFlmu5rqj1aVO/v4FAcAAD6huLhYGRkZVscAALeaPn267rvvPi1btkyS9Oyzz2r16tXatGmTcnJydOutt1qcsHyXzudsmma5czzv3LlTDz/8sJ566ilt3LhRy5Yt06FDhzRp0qRyH3/q1KnKzMx03hITE6s1P1AZJSUlVkcAUEF2u93txQfA0+3du9fqCFWSmJjo0v+bOnXqZdu7uz9aVe7s41McAAD4jMOHD1sdAQDcavv27brlllucX2Iu/gDZpUsX/elPf9KMGTOsjFemxo0by8/Pr9RVWSdPnix19dZFM2fO1IABA/T73/9eXbp00fXXX6/Zs2dr3rx5SktLK/MYu92uevXqOW+hoaHV/lqAiqI4AHiPVq1alVrjAPA1hw8fVl5entUxKi00NNSl/2e328tsV1P90apyZx+fv24AAJ+RkpJidQQAcKvz588rNDRUNptNdrvdZcRUu3bttHPnTgvTlS0wMFA9e/bU8uXLXbYvX7683Pmjz58/X+qHGj8/P0kXrvACPB3TCgHeo23btlZHACzncDi0b98+q2O4jaf3R93Zx6c4AADwGWfPnlVmZqbVMQDAbWJjY3XixAlJUocOHfTFF1849yUmJqpRo0ZWRbusyZMn680339S8efO0a9cuPfbYY0pNTXUOy546darGjh3rbD9mzBgtWrRIr732mg4ePKjvvvtODz/8sPr06aPo6GirXgZQYRQHAO/QqFEjNWnSxOoYgEfYvXt3rb4Iw5P7o+7s4/tfdToAALxISkqKunbtanUMAHCLIUOGaOXKlbr99tt1//3364EHHtCuXbtkt9v11Vdf6Xe/+53VEct055136vTp05oxY4bS0tLUqVMnLVmyRM2bN5ckpaWlKTU11dl+3Lhxys7O1iuvvKLf/e53ql+/vq699lr97W9/s+olAJVCcQDwDu3bty93vnHA15w7d07p6em1doFuT+6PurOPT3EAAOBT9u7dqy5dutDJB1ArPfPMMzpz5owkadKkSTp//rzeeecdGYahJ598UtOmTbM4YfkeeOABPfDAA2XuW7BgQaltDz30kB566CE3pwLcg+IA4PkCAwPVpk0bq2MAHmXnzp21tjggeW5/1J19/AoVBz799FMlJCQoLCysyk8EAIBVevXqpdTUVAUHB2vatGlKSUlRXFyc1bEAoNo1btxYjRs3dt6fPHmyJk+ebGEiAGUpKiqyOgKAK4iPj1dAQIDVMQCPcujQIZ0/f1516tSxOopPcWcfv0JrDtxyyy3as2ePJKlly5basmVLtTw5AAA1IT09XadOnVJWVpYkad26dSooKLA4FQBUv2uvvVa7d+8uc9/evXt17bXX1nAiAGVh5ADg2Ww2mzp37mx1DMDjOBwO7dixw+oYPsedffwKFQeCg4N1/vx5SRfmauYHFQCAN8vJydHSpUuVl5dndRQAqFYrV650FkIvlZ2drcTExBpOBKAsjBwAPFubNm0UGhpqdQzAI+3cuZPPsRrmzj5+hYoD7du317Rp0/T8889Lkt599129+OKLZd7+8Y9/VDlMRc2ePVtxcXEKCgpSz549tXr16nLbrly5UoZhlLqVV20BAPiGkydPatGiRTpy5IjVUQB4IW/sj6alpTEEHPAQhYWFVkcAUA6bzaYePXpYHQPwWAUFBdq1a5fVMfCjq+3jV2jNgb/+9a+68847NWXKFBmGoZdffrnctoZh6LHHHqtyoCt5//339eijj2r27NkaMGCAXn/9dY0cOVI7d+5UbGxsucft2bNH9erVc95v0qSJ2zICALxDbm6uli5dqjZt2qh///6y2+1WRwLgBTytP/rJJ5/ok08+cd7/85//XOqx8/LytHLlSnXv3r1anhPA1aE4AHiu9u3bq27dulbHADza1q1b1aFDB/n7V+inZVRBTfXxK3QGhw0bpoyMDB07dkzNmjXTxx9/rG7dulX5Sa/Giy++qAkTJmjixImSpFmzZunLL7/Ua6+9ppkzZ5Z7XHh4uOrXr19DKQEA3mTfvn06fvy4hg8froiICKvjAPBwntYf3blzpz788ENJFy7U+fbbb2WzuQ4Qttvt6ty5s1566aVqf34AlUdxAPBMdrtdPXv2tDoG4PHOnz+v3bt3q1OnTlZHqbVqqo9foWmFXn75ZZ08eVIxMTGaPn26evfurebNm5d7c5fCwkJt3LhRI0aMcNk+YsQIrV279rLHdu/eXVFRURo2bJhWrFhx2bYFBQXKyspy3nJycq46OwDAs+Xm5urzzz/X0aNHrY4CwAI5OTku/b/y1tiqqf5oZUydOlXZ2dnKzs6WaZpasWKF8/7FW0ZGhlasWKEuXbpU2/MCqLr8/HyrIwAoQ69evRQUFGR1DMArbN68WcXFxVbHqLVqqo9foeLAY489ppSUFEnSjBkzLPvhJCMjQyUlJaWu6oyIiFB6enqZx0RFRemNN97QwoULtWjRIsXHx2vYsGFatWpVuc8zc+ZMhYWFOW8JCQnV+joAAJ6ppKREy5cv14kTJ6yOAqCGJSQkuPT/yhsBUFP90apyOBzq06dPtT8ugOpFcQDwPBEREerQoYPVMQCvkZeXpx07dlgdwye4s49foWmF6tatq3PnzkmSTNN0S5DKMAzD5b5pmqW2XRQfH6/4+Hjn/X79+unIkSN6/vnnNXjw4DKPmTp1qiZPnuy8n5ycTIEAAHxEUVGRlixZoiFDhiguLs7qOABqSGJiosu0mVdag8Td/VEAtVtBQYFKSkrk5+dndRQAkvz9/TVkyJByP8sBlC05OVnt27dXYGCg1VFQRRUqDnTr1k0PP/ywhg8fLkl64YUXyp2T2TAMt81l2rhxY/n5+ZW6KuvkyZOVmiO6b9++evvtt8vdb7fbXb4QhoaGVj4sAMBrFRUVafny5WrdurWuueYahYSEWB0JgJuFhoa6LBZcnprqj1ZGXFxchX/MMAxDBw4cqJbnBXB1zp8/z6KngIcYMGCAwsLCrI4BeJ2CggJt27aNtTrcoKb6+BUqDsyaNUv33Xef3njjDRmG4VwMobww7ioOBAYGqmfPnlq+fLluueUW5/bly5frpptuqvDjbN68WVFRUe6ICACoRfbv369Dhw6pQ4cO6tKlC0UCAB7ZH01ISOBKR8ALZWdnUxwAPEB8fLzatm1rdQzAa23btk2dOnW64shbVE5N9fErPHJg8+bNkiSbzab169dbNpfp5MmT9ctf/lK9evVSv3799MYbbyg1NVWTJk2SdGFKoGPHjumtt96SdKGw0aJFC3Xs2FGFhYV6++23tXDhQi1cuNCS/AAA71JSUqJt27Zpx44datWqlTp37qzGjRtbHQuAhTytP7pgwYJqeRwANSs7O9vqCIDPa9y4sQYMGECRHbgKhYWF2rp1q3r37m11lFqlpvr4FSoO/NT8+fPVqlUrd2SpkDvvvFOnT5/WjBkzlJaWpk6dOmnJkiVq3ry5JCktLU2pqanO9oWFhXr88cd17NgxBQcHq2PHjvriiy80atQoq14CAMALORwO7du3T/v27VNUVJQ6d+6s5s2b80UC8EH0RwFUh6ysLKsjAD4tKChII0aMkL9/pX8aA3CJ7du3q0uXLowe8EKV/gt47733uiNHpTzwwAN64IEHytx3aVVlypQpmjJlSg2kAgD4irS0NKWlpalhw4a65ppr1KxZM6sjAahhntwfPXXqlF588UWtXLlSGRkZWrx4sTp27KjXX39dffr0Uffu3WssC4DyZWZmWh0B8FmGYWj48OGsMQlUk6KiIm3fvp21B9zIXX38ChUHxo8frz/96U+Ki4vT+PHjL9vWMAzNnTu3SmEAAPAmZ86c0dKlS9W1a1ddc801VscBAB06dEgDBgxQZmamunbtqoMHD6qgoECStHXrVq1fv17z58+3OCUAieIAYKU+ffooOjra6hhArXJx9EBAQIDVUWodd/bxK1QcWLFihR555BFJ0rfffnvZKRSYXgEA4Gu2bNmipk2bKiYmxuooAHzclClTVL9+fSUlJSk8PFyBgYHOfQMHDtT06dMtTAfgpzIzM2WaJt+hgRoWGxurLl26WB0DqHUKCgq0b98+dejQweootY47+/gVKg4cOnTI+f9TUlKq/GQAANS0ffv2Oef0zcvL04kTJxQREVHtz7Njxw6KAwAs98033+i1115TdHS0SkpKXPZFRUXp+PHjFiUDcKni4mLl5OSobt26VkcBfEZwcLCGDBlCUQ5wkx07dqh9+/a8x6qZO/v4tqsNBwCAp5o/f77atWun7OxsSReuZJg+fbrWrl1b7c91+PBhZWRkVPvjAkBl5Ofnq2HDhmXuy83Nlc1G9x/wJGfPnrU6AuBTEhISFBQUZHUMoNY6e/asTpw4YXWMWsedffxKH3nkyBG9++67ev755/X888/r3Xff1dGjR6scAAAAd9i3b58mTpwoh8Phst00Tb311ls6efJktT6faZpKTEws9XwAUJPi4+P19ddfl7lv1apV6tSpUw0nAnA5FAeAmhMfH6/Y2FirYwC13p49e6yOUOu4s49foWmFJCk7O1u/+tWv9OGHH8o0TZmm6dxns9l0991367XXXlNISEiVwwAAUF3mzZtX7lBGwzD03Xff6ZZbbqnW5zx9+rR27Nihzp07V+vjAkBF3X///Zo8ebKio6N1zz33SJIKCwv10Ucfafbs2XrllVcsTgjgp06fPm11BMAnhISEqG/fvlbHAHzCwYMHNXDgQPn5+VkdpdZwZx+/QsUB0zQ1evRorV69WqNGjdKNN96o5s2byzRNHT58WJ988onefvttHTt2TN98802VwwAAUF1SUlJcCtk/ZZqm276MHzx4kOIAAMs88MADSk5O1mOPPabf/e53ki4sUmaapu6//37de++9FicE8FMUB4CaMXDgQNntdqtjAD6hqKhIR48eVfPmza2OUmu4s49foeLAokWLtHr1as2fP7/MJ/v1r3+t+fPna8KECfr444+r/UpMAAAqq0WLFpcdOdCoUSO3PC9XRwCw2htvvKHx48friy++0IkTJ9S4cWONHj1a/fv3tzoagEucO3dORUVFCggIsDoKUGu1bt2aHymBGnbgwAHed9XMXX38ChUH3n//fY0ePfqyVYj77rtPH3/8sf773/9SHAAAWG78+PF67rnnytxnmqYGDBjgludlPm8AnqBv375MnwB4AdM0lZGRoaioKKujALVScHAwxXHAAqmpqSopKeHiuWrmjj5+hRYk3rx5s26++eYrtrv55pu1adOmq80EAMBVa9OmjebOnSubzfWjzjAMjR07VuHh4dX+nF26dFGLFi2q/XEBAEDt0KtXL7Vo0UJ/+ctfnNvS09MtTATUbv3791dQUJDVMQCfU1hYqOPHj1sdAxVQoeLAiRMnFBcXd8V2LVu21IkTJ646FAAA1WHcuHHas2eP6tatK0my2+2aMWOGW64eatOmja655ppqf1wAuBKbzSY/P78K3zzV7NmzFRcXp6CgIPXs2VOrV6++bPuCggJNmzZNzZs3l91uV6tWrTRv3rwaSgtUTXp6uo4dO6asrCznNn48AdwjNjZWLVu2tDoG4LNSUlKsjlBpntQfrak+foWmFcrNzVVISMgV2wUHBys3N7fKYQAAqG6tW7dWvXr1lJ2dreDgYLeMGGjdurUSEhLKXeMAANzpqaeecvn7M3/+fOXk5GjMmDGKjIxUWlqaPv/8c4WEhGj8+PEWJi3f+++/r0cffVSzZ8/WgAED9Prrr2vkyJHauXOnYmNjyzzmjjvu0IkTJzR37ly1bt1aJ0+eVHFxcQ0nB67eiRMnmHoBqGZ+fn7q378//XPAQikpKRo4cKDXvA89rT9aU338ChUHTNP0mhMJAEBN6tSpk/r168fnJADLPP30087//8ILLygyMlJff/21QkNDnduzs7M1fPhw1alTx4KEV/biiy9qwoQJmjhxoiRp1qxZ+vLLL/Xaa69p5syZpdovW7ZMiYmJOnjwoBo2bChJTOsGr1VcXKz09HTFxMRYHQWoNTp16qR69epZHQPwaXl5eUpLS1N0dLTVUSrE0/qjNdXHr9C0QpJ09913q0uXLpe9/eIXv6hyEAAAvImfn58SEhK4IgmAR5k9e7amTJni8qVBkurWraspU6Zo9uzZFiUrX2FhoTZu3KgRI0a4bB8xYoTWrl1b5jGffvqpevXqpeeee04xMTFq27atHn/8ceXl5ZX7PAUFBcrKynLecnJyqvV1AFfj8OHDVkcAao2AgAB17drV6hgAJB04cMDS58/JyXHp/xUUFJTZrqb6o1Xlzj5+hUYODB48uMI/fDRt2rTKYQAA8AZNmjTRkCFD1KBBA6ujAICLY8eOyd+/7C6+v7+/Ry58mpGRoZKSEkVERLhsj4iIKDfvwYMHtWbNGgUFBenjjz9WRkaGHnjgAZ05c6bceV5nzpypZ555ptrzA9Xh8OHDjEQEqkn79u1ZhBjwEAcPHlT//v0tmzovISHB5f706dNdrsi/qKb6o1Xlzj5+hYoDK1eurPITAABQWwQFBalXr15q3749X94BeKT27dvrxRdf1MiRIxUQEODcXlhYqBdeeEHt2rWzMN3lXfp39XJTmzocDhmGoXfeeUdhYWGSLgwFv/322/Xqq68qODi41DFTp07V5MmTnfeTk5NLfWEErJKdna3Tp0+rcePGVkcBvJphGOrYsaPVMQD8qKCgQIcPH7ZscfDExER169bNed9ut1+2vbv7o1Xlzj5+hYoDAAD4Mn9/f3Xu3Fldu3ZVYGCg1XEAoFzPPvusbr75ZrVs2VK33nqrIiMjlZ6erkWLFik9PV2LFy+2OmIpjRs3lp+fX6krnk6ePFnq6q2LoqKiFBMT4/wiJl340mSapo4ePao2bdqUOsZut7t8Ibx0WDZgtQMHDlAcACohMjJSBQUFLnNtx8TEqG7duhamAnCpPXv2WFYcCA0NrdD6IzXVH60qd/bxK7zmAAAAvqht27a688471bt3bwoDADzeDTfcoGXLlikmJkavvvqqpk2bpldeeUVNmzbV0qVLdcMNN1gdsZTAwED17NlTy5cvd9m+fPly9e/fv8xjBgwYoOPHj7usG7B3717ZbDamOYXX2r9/v0zTtDoG4DWSkpL07rvvatq0ac5tbdu2tTARgLIcPXpUubm5Vse4LE/vj7qzj09xAACAMjRu3Fg333yzhgwZopCQEKvjAECFDRs2TOvXr1dWVpaOHDmi7OxsrVu3TsOHD7c6WrkmT56sN998U/PmzdOuXbv02GOPKTU1VZMmTZJ0YUqgsWPHOtvffffdatSoke677z7t3LlTq1at0u9//3uNHz++WodwAzUpNzdXx44dszoG4LX8/f3VvHlzq2MAuIRpmtq7d6/VMa7I0/uj7urjM60QAAA/4efnp549e6pLly6y2aihA/BederUcZlqwZPdeeedOn36tGbMmKG0tDR16tRJS5Yscf7Ik5aWptTUVGf70NBQLV++XA899JB69eqlRo0a6Y477tCzzz5r1UsAqsWuXbsY/QJUUbNmzVzm4gbgOfbu3atu3bp59Np93tIfre4+PsUBAAB+FBERoYSEBNWvX9/qKADgcx544AE98MADZe5bsGBBqW3t2rUrNfQb8HYpKSnKyclhTQygClq0aGF1BADlyMzMVEZGhpo0aWJ1lMvyxf4ol0QCAHyen5+f+vbtqxtvvJHCAAAAsIxpmtq+fbvVMQCvYxiGYmNjrY4B4DL2799vdQSUgeIAAMCn1a9fX7fccou6dOni0UMcAQCAb9i1a5fy8/OtjgF4lfDwcNntdqtjALiMlJQUmaZpdQxcotLFgaKiIj377LPq0KGDQkJC5Ofn53Lz92emIgCAd4iMjNRNN92khg0bWh0FAABA0oXv3Fu3brU6BuBVYmJirI4A4Aqys7N19uxZq2PgEpX+JX/q1Kn6xz/+oZEjR+rmm2+mMgsA8EpNmjTRyJEjWbQMAAB4nO3bt6tz584KDg62OgrgFaKioqyOAKAC0tPTuTjPw1S6OPDBBx/oqaee0vTp092RBwCAahcZGanCwkLnF+zg4GCNGDGCwgCAWs3hcKh169b67LPP1LFjR6vjAKiE4uJibdy4UQMHDrQ6CuDxDMPw+EVOAVyQnp6uDh06WB3Dq1V3H7/SxYGzZ89q8ODBV/3EAADUlKSkJK1Zs0Y7d+6UJCUkJCgkJMTiVADgXqZpKiUlRQUFBVZHAVAFu3fvVqdOnVS/fn2rowAerV69egoMDLQ6BoAKYFqhq1fdffxKrzkwePBgJScnV8uTV9Xs2bMVFxenoKAg9ezZU6tXr75s+8TERPXs2VNBQUFq2bKl5syZU0NJAQCeplWrVoqNjbU6BgAvR38UgLs5HA59//33VscAPB5TlADeIzs7m0WJPUyliwMvv/yy5s6dq0WLFqmwsNAdmS7r/fff16OPPqpp06Zp8+bNGjRokEaOHKnU1NQy2x86dEijRo3SoEGDtHnzZj3xxBN6+OGHtXDhwhpODgCwmmEY6tOnj9UxAHg5+qMAasrhw4eVlpZmdQzAozG6Bqi6ffv2KSsrS5KUl5enEydOuPX5CgsLVVxc7NbnQOVUujjQrVs37d+/Xz//+c9Vp04d1atXz+UWFhbmjpxOL774oiZMmKCJEyeqffv2mjVrlpo1a6bXXnutzPZz5sxRbGysZs2apfbt22vixIkaP368nn/+ebfmBAB4ntjYWNWtW9fqGAC8nLf0R202m6ZPn67o6Gi3Pg8A9/r++++5yhK4jHr16lkdAfBK8+fPV7t27ZSdnS1JKigo0PTp07V27Vq3Pm9JSYlbH7+2q+4+fqXXHLjttttkGEa1PHllFRYWauPGjfrjH//osn3EiBHl/oe7bt06jRgxwmXb9ddfr7lz56qoqKjMxSgLCgpc5m3KycmRdGFRqKKioqt9GQAACxQXF6tp06b8HQfg4uKVSzk5Oc6rpiTJbrfLbreXal9T/dHqYBiGpk+f7pbHBlBzTp48qYMHD6pVq1ZWRwE8EsUBoPL27duniRMnyuFwuGw3TVNvvfWWWrdurfDwcLc896XPicqp7j5+pYsDCxYsqLYnr6yMjAyVlJQoIiLCZXtERITS09PLPCY9Pb3M9sXFxcrIyFBUVFSpY2bOnKlnnnmm1PZrrrnmKtIDAADAUyUkJLjcnz59up5++ulS7WqqPwoAP/XDDz+oRYsW8vPzszoK4HFCQ0OtjgB4nXnz5pV78bdhGPruu+90yy23uOW5/f0r/XM03Mgrz8al//GapnnZ0QxltS9r+0VTp07V5MmTnfeTk5OVkJCg77//Xt27d69qbACAhTZt2qQePXpYHQOAh9m8ebOuueYaJSYmqlu3bs7tZY0a+Cl390cB4Keys7O1fft2de3a1eoogMepU6eO1REAr5OSklLulHWmaer06dNue253jZpF1VS5OLB9+3bt2rVLeXl5pfaNHTv2qkKVp3HjxvLz8yt1VdbJkydLXY11UWRkZJnt/f391ahRozKPuXQY+cUqtL+/P/8BA4CXatiwIX/DAZRy8cql0NDQCk1LUFP9UQC41KZNm9S6dWuFhIRYHQXwGHa7nRE1QBW0aNHisiMH3NVHDQ4O5uIYD1Pp4sD58+d144036ttvv5VhGGVe9eSu4kBgYKB69uyp5cuXuwxtWb58uW666aYyj+nXr58+++wzl21fffWVevXqxY9EAOBDgoODrY4AoBagPwrAKkVFRVq7dq2uu+46q6MAHoM+PlA148eP13PPPVfmPtM0NWDAALc8L9OAeR5bZQ/485//rJSUFCUmJso0TS1atEjLly/XrbfeqjZt2mjTpk3uyOk0efJkvfnmm5o3b5527dqlxx57TKmpqZo0aZKkC1MC/bQ4MWnSJB0+fFiTJ0/Wrl27NG/ePM2dO1ePP/64W3MCADxLYGCg1REA1BL0RwFY5dChQzpw4IDVMQCPcaVpAAGUrU2bNpo7d65sNtefhg3D0NixY922GDHFAc9T6ZEDn3zyif7whz+of//+kqTY2Fj16NFDw4YN0913363XXntNc+bMqfagF9155506ffq0ZsyYobS0NHXq1ElLlixR8+bNJUlpaWlKTU11to+Li9OSJUv02GOP6dVXX1V0dLRefvll3XbbbW7LCADwPHxxAFBd6I8CsNKaNWsUERHBDyyAuAAIuBrjxo3TwIED1aNHD2VnZ8tut+vJJ590W2FAksLCwtz22KiaShcHUlJS1K5dO/n5+ckwDJ0/f96575577tGECRPcWhyQpAceeEAPPPBAmfsWLFhQaltCQoLbRzQAADwbU3cAqE6e3B9dtWqVXn755TLXBzMMg6uOAS9XUFCg5cuX68Ybb2Sudfg8+vjA1WndurXq1aun7OxsBQcHu7UwIFEcuBru6uNXelqh+vXrKzc3V5IUHh6uffv2OfcVFRU59wEA4En44gDAF6xZs0bDhg1TZmamdu3apXbt2ikmJkapqany9/fX4MGDrY4IoBqcOnVK3333nXMNQMBX+ftX+ppXABZq0KCB1RG8kjv7+JUuDnTu3Fl79+6VJA0dOlT/93//pzVr1uiHH37QjBkz1LVr1yqHAQDAXbiyDoAvmD59uu677z4tW7ZMkvTss89q9erV2rRpk3JycnTrrbdanBBAddm9e7d27txpdQzAUhQHAO9Sv359qyN4JXf28StdHJgwYYKys7MlSX/5y190/vx5JSQkqF+/fjp8+LBeeOGFKocBAMBdDMOwOgIAuN327dt1yy23OP/mlZSUSJK6dOmiP/3pT5oxY4aV8QBUs7Vr1yotLc3qGIBlLl1MFYDnCgkJYZ2QKnJnH7/SJdY77rjD+f/j4uK0d+9effvttzIMQ/3791fDhg2rHAYAAHehOADAF5w/f16hoaGy2Wyy2+3KyMhw7mvXrh1XGQO1jGma+vrrr3XrrbcqJCTE6jhAjWN0MOA9mFKo6tzZx7/qEmtISIjGjBmj0aNHUxgAAAAALBQbG6sTJ05Ikjp06KAvvvjCuS8xMVGNGjWyKhoAN8nLy1NiYiLrD8AnURwAvAe/G1edO/v4VSoOFBQU6PXXX9ddd92l6667zrko8SeffKKDBw9WOQwAAO7CF2YAvmDIkCFauXKlJOn+++/X7NmzNWzYMI0aNUrPPvus7rrrLmsDAnCLo0ePOtcGBHwJ0woB3oOLVKrOnX38Sk8rlJGRoaFDh2rHjh2KjIzUiRMnnGsQLF68WF9++aVmz55d5UAAAAAAquaZZ57RmTNnJEmTJk3S+fPn9c4778gwDD355JOaNm2axQkBuEtSUpJat27N7Ei7dwABAABJREFUldTwKRQHAO9BcaDq3NnHr/Rf0SlTpujcuXNKSkpSamqqy5WYQ4cOVWJiYpXDAADgLg6Hw+oIAOB2jRs3Vtu2bZ33J0+erI0bNyopKUlPP/20AgICLEx3ebNnz1ZcXJyCgoLUs2dPrV69ukLHfffdd/L391e3bt3cGxDwcLm5udq/f7/VMYAaRTEM8A7/n737jo+qSv84/p20SQ8hCUloAULvvYoBEaSKKDYUQQQLllXXxloAV8XVxR9WWJSiiIirgIIKokJUioKAgCLSEUgoAUISIKSc3x+YWYYUEkhyZzKf9+s1L517z733uRPuzDPz3HOOj4+PKlWqZHUYF+Sq+WhZ5vglLg4sWrRIzz77rFq3bp1vcsfq1atr3759Fx0MAAAAgIt3xRVX6Pfffy9w3R9//KErrriinCMqnrlz5+rBBx/Uk08+qfXr16tr167q06eP9u7dW+R2qampuu2229SjR49yihRwbRQH4GkoDgDuISIiwuV7+rhyPlqWOX6J/yonTpxQXFxcgeuysrKUnZ190cEAAFBW+OIAwBMsX75cJ06cKHBdWlqay/byfeWVV3THHXdo5MiRatSokSZNmqQaNWpo8uTJRW531113aciQIerUqdMFj5GZmakTJ044Hunp6aUVPuAykpKS+E4Oj+LqPzYCOKtKlSqWHDc9Pd0p/8vMzCy0bXnkoxerLHP8Er+L1q5dW6tWrSpw3U8//aQGDRpcdDAAAAAAykZSUpICAwOtDiOfM2fO6Oeff1avXr2clvfq1UsrV64sdLsZM2Zox44dGjt2bLGOM2HCBIWFhTkeCQkJlxQ34Ipyc3N1+PBhq8MAyg3FAcA9WFUcSEhIcMr/JkyYUGC78spHy8Kl5vglnpD4lltu0b/+9S81bdpU/fr1kyTZbDatWbNGr776KpOcAQAAAOXo008/1aeffup4/s9//lNRUVFObU6dOqXly5erVatW5R3eBR05ckQ5OTmKjo52Wh4dHa3k5OQCt9m2bZueeOIJff/99/LxKd5XmjFjxujhhx92PN+wYQMFAlRIKSkpio2NtToMoFycP9w1ANdk1edSYmKi0zwAdru9wHbllY+WRHnl+CWO/PHHH9eKFSs0aNAghYeHS5KuuuoqpaSkqHfv3vrb3/520cEAAAAAKJnffvtN//3vfyWd/ZHk22+/zXcnpd1uV7NmzfTqq69aEWKxnP8DjzGmwB99cnJyNGTIEI0fP95pYrYLsdvtTl8Ig4ODLz5YwIWlpKRYHQJQbigOAK6vcuXKlvVeDQ4OVmhoaLHbl3U+WhLlleOXuDjg6+urL774QnPnztXnn3+ugwcPKjIyUv3799dNN91Ely4AAIAKLCMjQ0FBQVaHgXOMGTNGY8aMkXR2eIVly5apffv2FkdVfJGRkfL29s53V9ahQ4fy3b0lnR1Xde3atVq/fr3uu+8+SWeHUjHGyMfHR1999ZXLTrwMlIcjR45YHQJQbigOAK6vevXqVodwQa6Yj5ZXjn9RfR5sNptuuukm3XTTTaUdDwAAAFxYenq6AgICuCHEReXm5lodQon5+fmpTZs2Wrp0qQYNGuRYvnTpUg0cODBf+9DQUG3atMlp2VtvvaVvv/1WH3/8sWrXrl3mMQOu7OjRozpz5oz8/PysDgUocxQHANfnDrmZq+ejZZnjl/6ASAAAAKjQMjMzFRAQYHUYqEAefvhhDR06VG3btlWnTp00depU7d27V3fffbeks3dO7d+/X++99568vLzUtGlTp+2rVKkif3//fMsBT2SMUVJSkuLi4qwOBQDg4YKCgiybjLikPDUfLVZxoCTdIGw2m7755puLDggAAACu7dSpUxQHXEjt2rWLfeekzWbTjh07yjiikrvxxhuVkpKiZ599VklJSWratKm++OILx4+bSUlJ2rt3r8VRAu5j7969FAcAAJarX7++2/TwcbV8tLxy/GIVB5YvX67Q0FDVqFHjog4CAACAiuPUqVNWh4BzJCQkuM2XrqKMHj1ao0ePLnDdzJkzi9x23LhxGjduXOkHBbip3bt367LLLqsQ7w1AUfg3Drgum82mhg0bWh1GibhSPlpeOX6xigN16tTRzp07FRYWphEjRujGG29kIjoAAAAPlZGRYXUIOMeFvqgA8DynTp1SUlKSqlatanUoAAAPVatWLYWEhFgdhtsqrxy/WDPJbd++XcuWLVOdOnV0//33KzY2ViNHjtTKlSvLOj4AAAC4GIoDAFBy27Zt04kTJySd/fH+4MGDZXq8nTt3lun+AQAoSsuWLa0OAcVQrOKAdLYrw3vvvaekpCS99NJL2rRpky677DI1atRIL7/8cpknNgAAAHANFAdc2+HDhzVmzBh16tRJ9erV06+//ipJ+s9//qP169dbHB3gmWbMmKGGDRsqLS1N0tmJ3ceOHVumN9zt3btXxpgy2z8AAIWpUaOGoqKirA6jQimrHL/YxYE8oaGhuvvuu/Xjjz9q48aN6tGjh/7xj38UOh4TAAAAKhaKA65r165datGihV577TXZbDbt3LlTmZmZkqSNGzfqtddeszhCwPNs27ZNI0eOVG5urtNyY4zee+89HTp0qEyOm56ervT09DLZN+AqKIABrql9+/ZWh1ChlGWOX+LiQJ4tW7bo3Xff1ccffyxjjBo0aHDRQQAAAMB9UBxwXY899pgqVaqkbdu26bvvvnP60eSyyy7TihUrLIwO8EzTp08vdEJBm81Wptfl0aNHy2zfAAAUpG7duoqIiLA6jAqlLHP8Yk1InCc9PV1z5szR9OnT9eOPPyo+Pl4PPPCAhg8fzkRHAAAAHuLkyZNWh4BCfPPNN5o8ebKqVq2qnJwcp3WxsbE6cOCARZEBnmv37t2F3t1sjFFKSkqZHfvMmTNltm8AAM7n5eWldu3aWR1GhVOWOX6xigPfffedpk2bpk8++UTGGA0ePFgvvviiEhISLvrAAAAAcE+nTp1Sbm6uvLwuuhMqysjp06dVuXLlAtdlZGTwNwMsUKtWrSJ7DnB3JQCgomjcuLFCQkKsDqPCKcscv1jFgW7duik0NFS33HKLbr75ZoWGhkqS1q1bV2D71q1bX3RAAAAAcG3GGGVkZJD4u6AGDRro66+/Vs+ePfOt++6779S0aVMLogI824gRI/TSSy8VuM4Yoy5dupTZsfO+uwMVlTGm0OIbgPLl4+OjVq1aWR1GhVSWOX6xhxU6ceKE3nnnHb3zzjuFtsl7Uz6/ewMAAAAqltTUVIoDLmjUqFF6+OGHVbVqVd1yyy2Szg4r8vHHH+utt97SG2+8YXGEgOepV6+epk2bpjvuuMNpUmKbzabbbrtNVapUKZPjent7F3qXIQAApa1JkyYKCAiwOowKqSxz/GIVB2bMmHHRByhNx44d0wMPPKDPPvtMknT11Vfr9ddfV6VKlQrdZvjw4Xr33XedlnXo0EGrV68uy1ABAAAqtCNHjqh69epWh+HSrMhdR48erQ0bNuihhx7S3//+d0lnJykzxmjUqFEaNmzYxZ0MgEsyfPhwXXbZZWrdurXS0tJkt9v11FNPlVlhQDo7BrGvr2+Z7R9wBYXN5wGgfHl7e6t58+ZWh1FhlWWOX6zigKt8iRgyZIj27dunxYsXS5LuvPNODR06VAsXLixyu969ezsVOPz8/Mo0TgAAgIpu//79atmypdVhuDSrctepU6dqxIgR+vzzz3Xw4EFFRkaqf//+6ty5c8lPAkCpqVu3rkJDQ5WWlqaAgIAyLQxIZ3ssAABQHurVq0evgTJWVjl+sYcVstqWLVu0ePFirV69Wh06dJAkvf322+rUqZO2bt2qBg0aFLqt3W5XTExMsY+VmZmpzMxMx/P09PSLDxwAAKACOnDggE6dOlVhvgSkp6frxIkTjud2u112u/2i91eeuWtBOnbsqI4dO17SPgC4Lz8/P9WuXdvqMAAAHqJZs2ZWh+ARyiLHv/ipjMvZqlWrFBYW5vhyJZ19QcLCwrRy5coit12+fLmqVKmi+vXra9SoUTp06FCR7SdMmKCwsDDHIyEhoVTOAQAAoKIwxmjr1q1Wh1FqEhISnPK/CRMmXNL+yjN3BYDzNWjQQD4+bnMvIHDRvL29rQ4B8HgxMTEKDw+3OgxcJLfJFpKTkwvsdlmlShUlJycXul2fPn10/fXXKy4uTrt27dLTTz+tK664Qj///HOhd4ONGTNGDz/8sOP5hg0bKBAAAACP17ZtWx04cEC+vr568skn9euvv6pZs2YV4ot5YmKi0zBJl9JrQCrf3NXLy0s2m63YseXk5BS7LQD31LhxY6tDAAB4iKJ6xOLilVeOb3lxYNy4cRo/fnyRbdasWSNJBb4gxpgiX6gbb7zR8f9NmzZV27ZtFRcXp88//1zXXnttgduc3408ODi4yPgAAAA8QXJyspKSkhwT6mZkZGjr1q0V4keo4OBghYaGXrCdK+auzzzzjNM+Z8yYofT0dA0YMEAxMTFKSkrSokWLFBQUpBEjRhQZOwD3V6NGDYWFhVkdBgDAA/j4+KhOnTpWh1EhlVeOb3lx4L777tNNN91UZJtatWpp48aNOnjwYL51hw8fVnR0dLGPFxsbq7i4OG3btq3EsQIAAMDZunXrVK9ePfn6+lodSrlwxdx13Lhxjv+fOHGiYmJi9PXXXzvd4JKWlqYrr7xSgYGBxT42APfUpEkTq0MAAHiIuLg4j/keUN7KK8e3vDgQGRmpyMjIC7br1KmTUlNT9dNPP6l9+/aSpB9//FGpqaklmpU5JSVFf/75p2JjYy86ZgAAAJx18uRJbdiwQe3atbM6lHLh6rnrW2+9pZdffjlfz9eQkBA99thjeuSRR/Too48W+/gA3EtYWJhq1KhhdRgAAA9Rt25dq0PwCGWZ47vNhMSNGjVS7969NWrUKK1evVqrV6/WqFGj1L9/f6exrRo2bKj58+dLktLT0/XII49o1apV2r17t5YvX64BAwYoMjJSgwYNsupUAAAAKpRffvlFKSkpVofhUqzKXffv31/oJKQ+Pj5FzncAwP01adKkROMTAwBwsfz9/SlIl5OyzPHdpjggSbNnz1azZs3Uq1cv9erVS82bN9esWbOc2mzdulWpqamSzs5av2nTJg0cOFD169fXsGHDVL9+fa1atUohISFWnAIAAECFk5ubq2+++UZnzpyxOhSXYkXu2qhRI73yyivKyspyWn7mzBlNnDhRDRs2LJ2TA+By7HY7k0ICAMpNnTp15OXlVj8tu62yzPEtH1aoJCpXrqz333+/yDbGGMf/BwQEaMmSJWUdFgAAgMc7fvy4li1bpl69enHX6l+syF2fe+45XXPNNapTp46uvfZaxcTEKDk5WfPmzVNycrIWLFhwSfsH4LqaNGnCuM8AgHJDQbr8lGWO71bFAQAAALiuPXv26KefflKHDh2sDsVj9evXT4sXL9aTTz6pN998U7m5ubLZbGrfvr1mzJihK6+80uoQAZQBPz8/NW3a1OowAAAeIjw8vFjzcKF0lGWOT3EAAAAApeaXX35RcHCwmjRpYnUoHqtHjx7q0aOHTp48qWPHjik8PFyBgYFWhwWgDLVo0UL+/v5WhwEA8BCNGzemt3A5K6scn+IAAAAAStXKlSvl7++v+Ph4q0PxaIGBgRQFAA8QFBSkZs2aWR0GAMBD+Pr6qn79+laH4bFKO8dn1ggAAACUKmOMvv32W+3cudPqUOBG3nrrLdWuXVv+/v5q06aNvv/++0Lbzps3Tz179lRUVJRCQ0PVqVMn5hqDx2rfvr18fLjvDwBQPho2bFhh57jxxHyU4gAAAABKnTFG33zzjbZu3Wp1KHADc+fO1YMPPqgnn3xS69evV9euXdWnTx/t3bu3wPbfffedevbsqS+++EI///yzunfvrgEDBmj9+vXlHDlgrZiYGNWtW9fqMAAAHsLLy0vNmze3Oowy4an5KMUBAAAAlAljjBITE7Vu3ToZY6wOBy7slVde0R133KGRI0eqUaNGmjRpkmrUqKHJkycX2H7SpEl67LHH1K5dO9WrV08vvPCC6tWrp4ULF5Zz5IB1bDabunTpwpjPAIByU69ePQUFBVkdRpnw1HyU4gAAAADK1Nq1a7V8+XLl5ORYHQpc0JkzZ/Tzzz+rV69eTst79eqllStXFmsfubm5SktLU+XKlQttk5mZqRMnTjge6enplxQ3YLUmTZooIiLC6jAAAB7CZrOpZcuWVodRIunp6U75X2ZmZoHtyisfdUUUBwAAAFDmtm3bpkWLFunUqVNWhwIXc+TIEeXk5Cg6OtppeXR0tJKTk4u1j4kTJyojI0M33HBDoW0mTJigsLAwxyMhIeGS4gasFBAQoLZt21odBgDAg9SpU0dhYWFWh1EiCQkJTvnfhAkTCmxXXvmoK6I4AAAAgHJx8OBBLViwQMePH7c6FLig84dGMcYUa7iUOXPmaNy4cZo7d66qVKlSaLsxY8YoNTXV8UhMTLzkmAGrtG3bVn5+flaHAQDwIO7Wa0CSEhMTnfK/MWPGFNm+rPNRV0RxAAAAAOUmLS1Nn332mY4cOWJ1KHARkZGR8vb2zndX1qFDh/LdvXW+uXPn6o477tBHH32kK6+8ssi2drtdoaGhjkdwcPAlxw5YoXLlymrYsKHVYQAAPEjNmjXdcii74OBgp/zPbrcX2K688lFXRHEAAAAA5er06dP6/PPPdfToUatDgQvw8/NTmzZttHTpUqflS5cuVefOnQvdbs6cORo+fLg++OAD9evXr6zDBFxGhw4dmIQYAFCuWrRoYXUIZcqT81GKAwAAACh3mZmZ+vLLL5mDAJKkhx9+WO+8846mT5+uLVu26KGHHtLevXt19913Szo7JNBtt93maD9nzhzddtttmjhxojp27Kjk5GQlJycrNTXVqlMAykVMTIyqV69udRgAAA8SGRmpmJgYq8Moc56aj1IcAAAAgCUyMjL0zTffyBhjdSiw2I033qhJkybp2WefVcuWLfXdd9/piy++UFxcnCQpKSlJe/fudbT/z3/+o+zsbN17772KjY11PP72t79ZdQpAuWjbti29BgAA5apJkyYe8dnjqfmoj9UBAAAAwHMdOHBAGzZsUKtWrawOBRYbPXq0Ro8eXeC6mTNnOj1fvnx52QcEuJiYmBjFxsZaHQYAwIP4+vqqTp06VodRbjwxH6XnAAAAACy1du1aJSUlWR0GALi01q1be8SdmwAA1xEfHy9fX1+rw0AZojgAAAAASxlj9PXXXystLc3qUADAJUVFRalatWpWhwEA8DB169a1OgSUMYoDAAAAsNypU6e0ePFiZWZmWh0KALgceg0AAMpbYGAgw9l5AIoDAAAAcAnHjh3TV199pZycHKtDAQCXERERoZo1a1odBgDAw9SsWZPCtAegOAAAAACXkZSUpBUrVlgdBgC4jLZt2/LjDACg3FGY9gwUBwAAAHBB27Zt04kTJySdHQLo4MGDZXas33//XXv27Cmz/QOAu4iOjubHGQBAubPZbMx14yEoDgAAAKBIM2bMUMOGDR0TBmdmZmrs2LFauXJlmR1z7dq1ZbZvAHAXnTp1otcAAKDcRUZGytfX1+owUA4oDgAAAKBQ27Zt08iRI5Wbm+u03Bij9957T4cOHSqT46akpCgjI6NM9g0A7qBu3bqqUqWK1WEAACq4mJgYxcTEKDQ01GkZPAPFAQAAABRq+vTphd61arPZynR+gMzMzDLbNwC4Ml9fX3Xo0MHqMAAAHmDt2rVatWqVnnzySccyitOeg+IAAAAACrV7924ZYwpcZ4xRSkpKmRzXZrMpKCioTPYNAK6uVatWvAcCACwTGRlpdQgoJxQHAAAAUKhatWoV2XMgIiKiTI4bGRkpu91eJvsGAFcWFhamZs2aWR0GAMBD+fj4OA0xhIqN4gAAAAAKNWLEiCJ7DnTp0qVMjlunTp0y2S8AuLoOHTrI29vb6jAAAB6qUqVKhd4chIrHrYoDzz//vDp37qzAwEBVqlSpWNsYYzRu3DhVrVpVAQEB6tatm3799deyDRQAAKCCqFevnqZNmyYvL+e00Waz6bbbbiuT8UhtNpvq1q1b6vstb+SuAEoqOjpacXFxVocBAPBgYWFhVoeAcuRWxYEzZ87o+uuv1z333FPsbV566SW98soreuONN7RmzRrFxMSoZ8+eSktLK8NIAQAAKo7hw4dr69atCgkJkSTZ7XY9++yz6ty5c5kcr0aNGhVirG1yVwAl1a5dO+7WBABYiiGFPItbFQfGjx+vhx56qNjjLxpjNGnSJD355JO69tpr1bRpU7377rs6efKkPvjggzKOFgAAoOKoW7eu44tCQEBAmfQYyNOkSZMy23d5IncFUBLR0dGqWrWq1WEAADxc3g1B8AxuVRwoqV27dik5OVm9evVyLLPb7UpISNDKlSsL3S4zM1MnTpxwPNLT08sjXAAAAI8XERGh6tWrl/tx09PTnfK/zMzMco/hYnNXABVD8+bNrQ4BAACKAx6mQhcHkpOTJZ29A+Nc0dHRjnUFmTBhgsLCwhyPhISEMo0TAAAAZ1k1pEZCQoJT/jdhwoRyj+Fic1cA7i8oKIi5BgAALiE4ONjqEFCOLC8OjBs3TjabrcjH2rVrL+kY53/BNMYU+aVzzJgxSk1NdTwSExMv6fgAAAC4sNq1a6tmzZqWHDsxMdEp/xszZkyB7VwxdwXg/urXr59v4ncAAKxAccCz+FgdwH333aebbrqpyDa1atW6qH3HxMRIOnsXVmxsrGP5oUOH8t2RdS673S673e54zkUBAABQtkJDQ3X55Zdbdvzg4OBiTb7mirkrAPdXv359q0MAAEABAQHy9va2OgyUI8uLA5GRkYqMjCyTfdeuXVsxMTFaunSpWrVqJUk6c+aMEhMT9a9//atMjgkAAICSCQkJUb9+/ZxuznBV5K4ASltUVJTCwsKsDgMAAG6Q9kBu1W9x79692rBhg/bu3aucnBxt2LBBGzZscJowuGHDhpo/f76ks12yH3zwQb3wwguaP3++Nm/erOHDhyswMFBDhgyx6jQAAADwl4iICF199dUVcuIzclcAxVG7dm2rQwAAQJIUGBhodQgoZ5b3HCiJZ555Ru+++67jed4dVcuWLVO3bt0kSVu3blVqaqqjzWOPPaZTp05p9OjROnbsmDp06KCvvvqqQn4BBQAAcCfx8fFKSEiQj49bpaTFRu4K4Hx5w4edO2QDExEDAFwFPQc8j1t9E5s5c6ZmzpxZZBtjjNNzm82mcePGady4cWUXGAAAAIrNZrOpXbt2atGiRYWeaJfcFcD51q5dq+zsbE2fPl3S2WHVKlWqZG1QAAD8JSgoyOoQUM7cqjgAAAAA9+bl5aUrrrhCderUsToUALBc1apVK3SRFADgXigOeB63mnMAAAAA7svLy0u9evWiMIACvfXWW6pdu7b8/f3Vpk0bff/990W2T0xMVJs2beTv7686depoypQp5RQpUHqio6OtDgEAAAdPLw54Yj5KcQAAAADlIiEhQTVr1rQ6DLiguXPn6sEHH9STTz6p9evXq2vXrurTp4/27t1bYPtdu3apb9++6tq1q9avX69//OMfeuCBB/TJJ5+Uc+TApYmKirI6BAAAHDy5OOCp+SjFAQAAAJS5Fi1aqF69elaHARf1yiuv6I477tDIkSPVqFEjTZo0STVq1NDkyZMLbD9lyhTVrFlTkyZNUqNGjTRy5EiNGDFC//73v8s5cuDi2Ww25hsAALiUwMBAq0OwjKfmo8w5AAAAgDJVs2ZNtW/f3uow4KLOnDmjn3/+WU888YTT8l69emnlypUFbrNq1Sr16tXLadlVV12ladOmKSsrS76+vvm2yczMVGZmpuN5enq6JCk7O1tZWVmXehpAsWVnZysnJ0fBwcHKzc1Vbm6u1SEBADxcVlaWYw6cipAXZWdnSzqb7504ccKx3G63y26352tfXvmoK6I4AAAAgDITFRWlHj16MOEmCnXkyBHl5OTkG3s9OjpaycnJBW6TnJxcYPvs7GwdOXJEsbGx+baZMGGCxo8fn295hw4dLiF64NLcdtttVocAAIDDnXfeaXUIpSohIcHp+dixYzVu3Lh87corH3VFFAcAAABQJqKiotS3b1+3uWsG1jq/gGSMKbKoVFD7gpbnGTNmjB5++GHH8w0bNighIUE//vijWrVqdbFhAyWWnZ2tmTNnqm7duurWrZvV4QAAoN27d2vjxo26+uqrrQ6lVKxfv14dOnRQYmKiWrZs6VheUK+Bc5V1PuqKKA4AAACg1FWtWlVXXXUVhQFcUGRkpLy9vfPdlXXo0KF8d2PliYmJKbC9j4+PIiIiCtzm/G7kwcHBkiQfHx/+naJc2Ww2eXt7KzQ0lH97AACX4Ovrq+Dg4ArzueTjc/Yn7+DgYIWGhl6wfXnlo66ICYkBAABQqurUqaM+ffpUmC8XKFt+fn5q06aNli5d6rR86dKl6ty5c4HbdOrUKV/7r776Sm3btuXfHdyGv7+/1SEAAODgyZ9LnpyPUhwAAABAqWnUqJF69Oghb29vq0OBG3n44Yf1zjvvaPr06dqyZYseeugh7d27V3fffbeks0MCnTs2+9133609e/bo4Ycf1pYtWzR9+nRNmzZNjzzyiFWnAJRYQECA1SEAAOBwoSF3KjpPzUcZVggAAAClonHjxurSpYtbjbEJ13DjjTcqJSVFzz77rJKSktS0aVN98cUXiouLkyQlJSVp7969jva1a9fWF198oYceekhvvvmmqlatqtdee03XXXedVacAlJgn36EJAHA9nl4c8NR8lOIAAAAALlmtWrUoDOCSjB49WqNHjy5w3cyZM/MtS0hI0Lp168o4KqDsUBwAALgSPz8/q0OwnCfmowwrBAAAgEsSFham7t27UxgAgBJgWCEAgCuhOOCZKA4AAADgkiQkJLjVpFsA4AroOQAAcCUUBzwTxQEAAABctDp16igmJsbqMADArfj4+FBUBQC4FD6XPBNzDgAAAKBYYmJilJub6/TFoWXLltYFBABuiiGFAACuxseHn4k9EX91AAAAFMvatWt18OBBffrpp5KkiIgIRUZGWhwVALifwMBAq0MAAMAJPQc8E8MKAQAA4KLUqlXL6hAAwC0x3wAAwNXQc8AzURwAAADARalRo4bVIQCAW6I4AABwNd7e3laHAAtQHAAAAECJ+fn5KSoqyuowAMAtURwAALgaigOeieIAAAAASiw2NlY2m83qMADALfn5+VkdAgAAThhWyDNRHAAAAECJVa1a1eoQAMBtURwAALgaLy9+JvZE/NUBAABQYjExMVaHAABui+IAAMCVeHl50SvYQ1EcAAAAQIl4e3srIiLC6jAAwG0xdAMAwJXQa8Bz8ZcHAABAiURERPAFAgAuAZM+AgBcCZ9LnotvdQAAACiR8PBwq0MAALfGjzAAAFfCjT+ei788AAAASiQ0NNTqEADArVEcAAC4Ej6XPJdbFQeef/55de7cWYGBgapUqVKxthk+fLhsNpvTo2PHjmUbKAAAQAUWEhJidQhugdwVQGG4QxMA4EooDngut8pIzpw5o+uvv1733HNPibbr3bu3kpKSHI8vvviijCIEAACo+AIDA60OwS2QuwIoDD/CAABcCUVrz+VjdQAlMX78eEnSzJkzS7Sd3W5XTExMGUQEAADgeQICAqwOwS2QuwIoDD/CAABcCZ9Lnssj/vLLly9XlSpVVL9+fY0aNUqHDh0qsn1mZqZOnDjheKSnp5dTpAAAAK7Pz8/P6hBKXXp6ulP+l5mZaVksJc1dAbgffoQBALgSm81mdQiwSIXPSPr06aPZs2fr22+/1cSJE7VmzRpdccUVRX7hmzBhgsLCwhyPhISEcowYAADAtVXE4kBCQoJT/jdhwgRL4riY3BWA+2FYIQCAK6Fo7bks/8uPGzcu36Rr5z/Wrl170fu/8cYb1a9fPzVt2lQDBgzQl19+qT/++EOff/55oduMGTNGqampjkdiYuJFHx8AAKAi8fLyko+PW41MWSyJiYlO+d+YMWMKbOeKuSsA98OPMAAAV0LPAc9l+Te7++67TzfddFORbWrVqlVqx4uNjVVcXJy2bdtWaBu73S673e54HhwcXGrHBwAAcGc+Pj4V8stDcHCwQkNDL9jOFXNXAO6H4gAAwJXwueS5LC8OREZGKjIystyOl5KSoj///FOxsbHldkwAAICKwtfX1+oQLEXuCuBS+fj4VMgeWAAAwP24VVlo79692rBhg/bu3aucnBxt2LBBGzZscJowuGHDhpo/f76ksxPLPfLII1q1apV2796t5cuXa8CAAYqMjNSgQYOsOg0AAAC3xTjZxUfuCgAAAHdQEXsGo3jcqjjwzDPPqFWrVho7dqzS09PVqlUrtWrVymlc161btyo1NVXS2S+vmzZt0sCBA1W/fn0NGzZM9evX16pVqxQSEmLVaQAAALgtuhwXH7lr8Rw7dkxDhw51TAY9dOhQHT9+vND2WVlZevzxx9WsWTMFBQWpatWquu2223TgwIHyCxoAAKACoThQfBUtd3WrvowzZ87UzJkzi2xjjHH8f0BAgJYsWVLGUQEAAHgOhsIoPnLX4hkyZIj27dunxYsXS5LuvPNODR06VAsXLiyw/cmTJ7Vu3To9/fTTatGihY4dO6YHH3xQV1999SVNBg0AAOCpuAGo+Cpa7sq3OwAAABQbwwqhNG3ZskWLFy/W6tWr1aFDB0nS22+/rU6dOmnr1q1q0KBBvm3CwsK0dOlSp2Wvv/662rdvr71796pmzZrlEjsAAEBFQY5fPBUxd6UsBAAAAMASq1atUlhYmOPLlSR17NhRYWFhWrlyZbH3k5qaKpvNpkqVKhXaJjMzUydOnHA8zp37AQAAABVPenq6U/6XmZl5Sfsrz9y1vFAcAAAAAGCJ5ORkValSJd/yKlWqKDk5uVj7OH36tJ544gkNGTJEoaGhhbabMGGCY2zYsLAwJSQkXHTcAAAAcH0JCQlO+d+ECRMuaX/lmbuWF4oDAAAAAErVuHHjZLPZinzkjbFa0AR4xphiTYyXlZWlm266Sbm5uXrrrbeKbDtmzBilpqY6HomJiRd3cgAAAHALiYmJTvnfmDFjCmznirlreWHOAQAAAACl6r777tNNN91UZJtatWpp48aNOnjwYL51hw8fVnR0dJHbZ2Vl6YYbbtCuXbv07bffXvDOK7vdLrvd7ngeHBxcZHsAAAC4t+Dg4GLdne+KuWt5oTgAAAAAoFRFRkYqMjLygu06deqk1NRU/fTTT2rfvr0k6ccff1Rqaqo6d+5c6HZ5X662bdumZcuWKSIiotRiBwAAgGfx5NyVYYUAAAAAWKJRo0bq3bu3Ro0apdWrV2v16tUaNWqU+vfvrwYNGjjaNWzYUPPnz5ckZWdna/DgwVq7dq1mz56tnJwcJScnKzk5WWfOnLHqVAAAAFDBVcTcleIAAAAAAMvMnj1bzZo1U69evdSrVy81b95cs2bNcmqzdetWpaamSpL27dunzz77TPv27VPLli0VGxvreKxcudKKUwAAAICHqGi5K8MKAQAAALBM5cqV9f777xfZxhjj+P9atWo5PQcAAADKS0XLXek5AAAAAAAAAACAh6HngAdLSkpSUlKS1WHgAvK6GsF1cS25B64l98D15Pq4lgDXxvuo6+N91D1wLbkHrif3wPXk+riWPBfFgWKIjY3V2LFjK9RFkpmZqZtvvlmJiYlWh4ILSEhI0JIlS2S3260OBQXgWnIfXEuuj+vJPVS0a6ki5nkonor4t+d91D1UtPfRiohryX1wPbk+rif3UNGupYqY55UVm3HlQY9QZk6cOKGwsDAlJiYqODjY6nBQiPT0dCUkJCg1NVWhoaFWh4MCcC25B64l98D15Pq4lgDXxvuo6+N91D1wLbkHrif3wPXk+riWPBs9Bzxcy5YtufBd2IkTJ6wOAcXEteTauJbcC9eT6+JaAtwD76Oui/dR98K15Nq4ntwL15Pr4lrybExIDAAAAAAAAACAh6E4AAAAAAAAAACAh6E44KHsdrvGjh1bYSYaqaj4O7k+/kbugb+Te+Dv5Pr4GwGujWvU9fE3cg/8ndwDfyf3wN/J9fE38mxMSAwAAAAAAAAAgIeh5wAAAAAAAAAAAB6G4gAAAAAAAAAAAB6G4gAAAAAAAAAAAB6G4gAAAAAAAAAAAB6G4gA81syZM2Wz2WSz2bR8+fJ8640xqlu3rmw2m7p163bB/XXr1s2xP5vNpoCAALVo0UKTJk1Sbm6uo93w4cNVq1at0juRi5R3/mvXrrU6FHigsrz+vLy8FBISorp16+r666/Xxx9/7HQNAu5k3LhxstlsJd6uoM+aF154QQsWLCidwIrJZrNp3LhxJd5u9+7dstlsmjlzpmPZypUrNW7cOB0/frzU4gNQ8ZDjk+PDOuT4QPGQ4890LCPHtx7FAXi8kJAQTZs2Ld/yxMRE7dixQyEhIcXeV506dbRq1SqtWrVKc+fOVbVq1fTQQw9pzJgxpRkyUGGUxfW3cuVKLViwQE888YROnTql66+/Xt26dVNqampphg64HSu+OJSmlStXavz48XxxAFAs5PiAdcjxgfJDjo9LRXEAHu/GG2/UJ598ohMnTjgtnzZtmjp16qSaNWsWe18BAQHq2LGjOnbsqKuvvlqffvqp6tSpozfeeENZWVmlHTrg9srq+uvRo4dGjhypRYsWafr06fr+++915513Frm9MUanTp26qPMAAACuhRwfsA45PgC4D4oD8Hg333yzJGnOnDmOZampqfrkk080YsSIS9q3r6+v2rRpo5MnT+rw4cOFtnvzzTd1+eWXq0qVKgoKClKzZs300ksvFfhlY/HixerRo4fCwsIUGBioRo0aacKECU5t1q5dq6uvvlqVK1eWv7+/WrVqpY8++qjAYx87dky33367KleurKCgIA0YMEA7d+7M12769Olq0aKF/P39VblyZQ0aNEhbtmwp4SsCOCvL6y/P7bffrr59++q///2v9uzZ41hus9l03333acqUKWrUqJHsdrveffddLV++vMCu0AV1gZSkt99+W/Xr15fdblfjxo31wQcfuMzQAnAvn3/+uVq2bCm73a7atWvr3//+d742xhi99dZbatmypQICAhQeHq7BgwcX+L59LpvNpoyMDL377ruO7vl53fkPHz6s0aNHq3HjxgoODlaVKlV0xRVX6Pvvvy927CdOnNCoUaMUERGh4OBg9e7dW3/88UeBbbdt26YhQ4aoSpUqstvtatSokd58880i9z9u3Dg9+uijkqTatWvnG7Jg7ty56tWrl2JjYxUQEKBGjRrpiSeeUEZGRrHPAUDFQo5Pjg/rkOMD/0OOXzhyfNdAcQAeLzQ0VIMHD9b06dMdy+bMmSMvLy/deOONl7z/HTt2yMfHR+Hh4UW2GTJkiGbNmqVFixbpjjvu0Msvv6y77rrLqd20adPUt29f5ebmasqUKVq4cKEeeOAB7du3z9Fm2bJl6tKli44fP64pU6bo008/VcuWLXXjjTfmS3gk6Y477pCXl5c++OADTZo0ST/99JO6devm1KVrwoQJuuOOO9SkSRPNmzdPr776qjZu3KhOnTpp27Ztl/wawXOV9fWX5+qrr5YxJl8itGDBAk2ePFnPPPOMlixZoq5du5Zov1OnTtWdd96p5s2ba968eXrqqac0fvz4AsdYBYryzTffaODAgQoJCdGHH36ol19+WR999JFmzJjh1O6uu+7Sgw8+qCuvvFILFizQW2+9pV9//VWdO3fWwYMHC93/qlWrFBAQoL59+zqGxnjrrbckSUePHpUkjR07Vp9//rlmzJihOnXqqFu3bsX6t2yM0TXXXKNZs2bp73//u+bPn6+OHTuqT58++dr+9ttvateunTZv3qyJEydq0aJF6tevnx544AGNHz++0GOMHDlS999/vyRp3rx5jnNo3bq1pLNfRvr27atp06Zp8eLFevDBB/XRRx9pwIABF4wfQMVEjk+OD+uQ4wNnkeOT47sFA3ioGTNmGElmzZo1ZtmyZUaS2bx5szHGmHbt2pnhw4cbY4xp0qSJSUhIuOD+EhISTJMmTUxWVpbJysoyBw4cME888YSRZK6//npHu2HDhpm4uLhC95OTk2OysrLMe++9Z7y9vc3Ro0eNMcakpaWZ0NBQc9lll5nc3NxCt2/YsKFp1aqVycrKclrev39/Exsba3JycpzOf9CgQU7tVqxYYSSZ5557zhhjzLFjx0xAQIDp27evU7u9e/cau91uhgwZcsHXBjhfWV1/hfnyyy+NJPOvf/3LsUySCQsLc1xjefLiWbZsmdPyXbt2GUlmxowZxpiz12pMTIzp0KGDU7s9e/YYX1/fIq9z4HwdOnQwVatWNadOnXIsO3HihKlcubLJS9dWrVplJJmJEyc6bfvnn3+agIAA89hjjzmWFfRZExQUZIYNG3bBWLKzs01WVpbp0aNHvs+IguRdX6+++qrT8ueff95IMmPHjnUsu+qqq0z16tVNamqqU9v77rvP+Pv7O67H8683Y4x5+eWXjSSza9euIuPJzc01WVlZJjEx0Ugyv/zyywXPAUDFQY5Pjg/rkOMDzsjxyfHdAT0HAEkJCQmKj4/X9OnTtWnTJq1Zs+aiujv++uuv8vX1la+vr6pWraqJEyfqlltu0dtvv13kduvXr9fVV1+tiIgIeXt7y9fXV7fddptycnIcXbZWrlypEydOaPTo0YXOar99+3b9/vvvuuWWWyRJ2dnZjkffvn2VlJSkrVu3Om2T1zZP586dFRcXp2XLlkk6W4k+deqUhg8f7tSuRo0auuKKK/TNN98U+/UBClJa119RjDEFLr/iiiuKvOOvKFu3blVycrJuuOEGp+U1a9ZUly5dLmqf8EwZGRlas2aNrr32Wvn7+zuWh4SEON0Vs2jRItlsNt16661O7+8xMTFq0aLFJd3NNmXKFLVu3Vr+/v7y8fGRr6+vvvnmG6ehJXJycpyOm5ubK0mOz4vzP0+GDBni9Pz06dP65ptvNGjQIAUGBub7jDp9+rRWr159UfHv3LlTQ4YMUUxMjONzNCEhQZIYHgPwYOT4/0OOj/JGjg9PR45Pju8ufKwOAHAFNptNt99+u1577TWdPn1a9evXL3HXQ0mKj4/Xhx9+KJvNJn9/f9WuXVuBgYFFbrN371517dpVDRo00KuvvqpatWrJ399fP/30k+69917H5El545lWr1690H3ldTd75JFH9MgjjxTY5siRI07PY2Ji8rWJiYlRSkqKJDn+Gxsbm69d1apVtXTp0iLPD7iQ0rr+ipI3DmnVqlWdlhf077q48q6N6OjofOuio6O1a9eui943PMuxY8eUm5tb6PtxnoMHD8oYU+C/OUmqU6fORR3/lVde0d///nfdfffd+uc//6nIyEh5e3vr6aefdkq6e/ToocTERMfzYcOGaebMmUpJSZGPj48iIiIKjV06e81kZ2fr9ddf1+uvv15gLOd/RhVHenq6unbtKn9/fz333HOqX7++AgMD9eeff+raa69lEkLAg5HjK98ycnyUF3J8eDpy/P8hx3dtFAeAvwwfPlzPPPOMpkyZoueff/6i9uHv76+2bduWaJsFCxYoIyND8+bNU1xcnGP5hg0bnNpFRUVJktPYo+eLjIyUJI0ZM0bXXnttgW0aNGjg9Dw5OTlfm+TkZNWtW1eSHB8ESUlJ+dodOHDAcUzgUpTG9VeUzz77TDabTZdffrnT8oLu0Mu7qyMzM9Np+fkJTd61UdAYkAVdV0BhwsPDZbPZCn0/zhMZGSmbzabvv/9edrs9X9uClhXH+++/r27dumny5MlOy9PS0pye/+c//3Falvf+HxERoezsbKWkpDh9eTj/fMLDw+Xt7a2hQ4fq3nvvLTCW2rVrlzj+b7/9VgcOHNDy5csddxJJchpXG4DnIsd3XkaOj/JEjg9PRo7/P+T4ro1hhYC/VKtWTY8++qgGDBigYcOGldtx8xKXc9/wjTH5uil37txZYWFhmjJlSqHdJxs0aKB69erpl19+Udu2bQt8hISEOG0ze/Zsp+crV67Unj17HDPcd+rUSQEBAXr//fed2u3bt0/ffvutevTocVHnDZyrLK+/GTNm6Msvv9TNN9+smjVrXrB9rVq1JEkbN250Wv7ZZ585PW/QoIFiYmL00UcfOS3fu3evVq5ceWlBw6MEBQWpffv2mjdvnk6fPu1YnpaWpoULFzqe9+/fX8YY7d+/v8D392bNmhV5HLvdXuAdNjabLd+Xjo0bN2rVqlVOyxo0aOB0vLxrpXv37pLyf5588MEHTs8DAwPVvXt3rV+/Xs2bNy/wHM6/M+n8+CXlO4eCPkels190AIAc/yxyfFiBHB+ejByfHN9d0HMAOMeLL75Y7sfs2bOn/Pz8dPPNN+uxxx7T6dOnNXnyZB07dsypXXBwsCZOnKiRI0fqyiuv1KhRoxQdHa3t27frl19+0RtvvCHp7Btlnz59dNVVV2n48OGqVq2ajh49qi1btmjdunX673//67TftWvXauTIkbr++uv1559/6sknn1S1atU0evRoSVKlSpX09NNP6x//+Iduu+023XzzzUpJSdH48ePl7++vsWPHls8LhQrvUq+/U6dOOcYyPHXqlHbu3KkFCxZo0aJFSkhI0JQpU4q1n5iYGF155ZWaMGGCwsPDFRcXp2+++Ubz5s1zaufl5aXx48frrrvu0uDBgzVixAgdP35c48ePV2xsrLy8qL+j+P75z3+qd+/e6tmzp/7+978rJydH//rXvxQUFKSjR49Kkrp06aI777xTt99+u9auXavLL79cQUFBSkpK0g8//KBmzZrpnnvuKfQYzZo10/Lly7Vw4ULFxsYqJCREDRo0UP/+/fXPf/5TY8eOVUJCgrZu3apnn31WtWvXVnZ29gVj79Wrly6//HI99thjysjIUNu2bbVixQrNmjUrX9tXX31Vl112mbp27ap77rlHtWrVUlpamrZv366FCxfq22+/LTL+vH0MGzZMvr6+atCggTp37qzw8HDdfffdGjt2rHx9fTV79mz98ssvF4wdgGcgxyfHh3XI8eHJyPHJ8d2CVTMhA1abMWOGkWTWrFlTZLsmTZqYhISEC+4vISHBNGnS5ILtCppdfuHChaZFixbG39/fVKtWzTz66KOOmeGXLVvm1PaLL74wCQkJJigoyAQGBprGjRubf/3rX05tfvnlF3PDDTeYKlWqGF9fXxMTE2OuuOIKM2XKFEebvPP/6quvzNChQ02lSpVMQECA6du3r9m2bVu+uN955x3TvHlz4+fnZ8LCwszAgQPNr7/+esHzBQpSFtefJMcjKCjI1KlTxwwePNj897//NTk5Ofm2kWTuvffeAveXlJRkBg8ebCpXrmzCwsLMrbfeatauXWskmRkzZji1nTp1qqlbt67x8/Mz9evXN9OnTzcDBw40rVq1umDcwLk+++wzx/tszZo1zYsvvmjGjh1rzk/Xpk+fbjp06GCCgoJMQECAiY+PN7fddptZu3ato01BnzUbNmwwXbp0MYGBgUaS49rKzMw0jzzyiKlWrZrx9/c3rVu3NgsWLChwH4U5fvy4GTFihKlUqZIJDAw0PXv2NL///ruRZMaOHevUdteuXWbEiBGmWrVqxtfX10RFRZnOnTub5557zqlNQdfbmDFjTNWqVY2Xl5fTZ+TKlStNp06dTGBgoImKijIjR44069atK3AfACo2cnxyfFiHHB/IjxyfHN/V2YwppO8iAAAosePHj6t+/fq65pprNHXqVKvDAQAAAHCJyPEBVFQMKwQAwEVKTk7W888/r+7duysiIkJ79uzR//3f/yktLU1/+9vfrA4PAAAAQAmR4wPwJBQHAAC4SHa7Xbt379bo0aN19OhRBQYGqmPHjpoyZYqaNGlidXgAAAAASogcH4AnYVghAAAAAAAAAAA8DNOsAwAAAAAAAADgYSgOABbavXu3bDabZs6caXUogFvjWgIAAK6CvAQoHVxLAFD2GFYIsFBmZqbWr1+v+Ph4RUVFWR0O4La4lgAAgKsgLwFKB9cSAJQ9igMAAAAAAAAAAHgYhhUCLtG4ceNks9m0ceNGXX/99QoLC1PlypX18MMPKzs7W1u3blXv3r0VEhKiWrVq6aWXXnJsW1A3ybz9/frrr7r55psVFham6OhojRgxQqmpqUVum8dms2ncuHGO54cPH9add96pGjVqyG63KyoqSl26dNHXX39dFi8JcFG4lgAAgKsgLwFKB9cSALg2H6sDACqKG264QbfeeqvuuusuLV26VC+99JKysrL09ddfa/To0XrkkUf0wQcf6PHHH1fdunV17bXXFrm/6667TjfeeKPuuOMObdq0SWPGjJEkTZ8+vcSxDR06VOvWrdPzzz+v+vXr6/jx41q3bp1SUlIu6lyBssS1BAAAXAV5CVA6uJYAwDVRHABKyZ133qmHH35YknTllVfqq6++0htvvKF58+Zp0KBBkqRu3bpp0aJFmj179gWTnTvuuEOPPvqoY3/bt2/X9OnTNW3aNNlsthLFtmLFCo0cOVKjRo1yLBs4cGCJ9gGUF64lAADgKshLgNLBtQQArolhhYBS0r9/f6fnjRo1ks1mU58+fRzLfHx8VLduXe3Zs+eC+7v66qudnjdv3lynT5/WoUOHShxb+/btNXPmTD333HNavXq1srKySrwPoLxwLQEAAFdBXgKUDq4lAHBNFAeAUlK5cmWn535+fgoMDJS/v3++5adPn77g/iIiIpye2+12SdKpU6dKHNvcuXM1bNgwvfPOO+rUqZMqV66s2267TcnJySXeF1DWuJYAAICrIC8BSgfXEgC4JooDgJvKS6IyMzOdlhc0LmJkZKQmTZqk3bt3a8+ePZowYYLmzZun4cOHl0eogEvjWgIAAK6CvAQoHVxLAFA8FAcANxUdHS1/f39t3LjRafmnn35a5HY1a9bUfffdp549e2rdunVlGSLgFriWAACAqyAvAUoH1xIAFA8TEgNuymaz6dZbb9X06dMVHx+vFi1a6KefftIHH3zg1C41NVXdu3fXkCFD1LBhQ4WEhGjNmjVavHjxBSd5AjwB1xIAAHAV5CVA6eBaAoDioTgAuLGJEydKkl566SWlp6friiuu0KJFi1SrVi1HG39/f3Xo0EGzZs3S7t27lZWVpZo1a+rxxx/XY489ZlHkgGvhWgIAAK6CvAQoHVxLAHBhNmOMsToIAAAAAAAAAABQfphzAAAAAAAAAAAAD0NxAAAAAAAAAAAAD0NxAAAAAAAAAAAAD0NxAAAAAAAAAAAAD0NxAAAAAAAAAAAAD0NxAB7n448/ls1m09y5c/Ota9GihWw2m5YsWZJvXXx8vFq3bl3kvocPHy6bzeZ42O12NWjQQGPHjtXp06cd7caNGyebzXbpJ3OJli9fLpvNpo8//tjqUOAhyvP6CwoKUq1atXT11VdrxowZyszMLLXzAAAAroUc/3/I8VHeyPEBwH1RHIDH6datm2w2m5YtW+a0/OjRo9q0aZOCgoLyrdu3b5927typ7t27X3D/AQEBWrVqlVatWqUFCxaoQ4cOevbZZzVs2LBSPQ/AHZXn9bdo0SI9++yzCgoK0qhRo9SmTRvt27evVM8HAAC4BnJ8wDrk+ADgvnysDgAob5GRkWratKmWL1/utDwxMVE+Pj6644478iUuec+Lk7h4eXmpY8eOjud9+vTR7t279dFHH+mVV15RtWrVLv0kADdV3tefJN122226/fbb1b9/fw0ePFirV68uch+nTp1SQEBAMc4GAAC4CnJ8wDrk+ADgvug5AI/UvXt3bd26VUlJSY5ly5cvV7t27dS3b1/9/PPPSktLc1rn7e2trl27XtTx8hKZPXv2FNpm7ty56tWrl2JjYxUQEKBGjRrpiSeeUEZGRr62P/74owYMGKCIiAj5+/srPj5eDz74oFObbdu2aciQIapSpYrsdrsaNWqkN998s8Bjnz59Wg8//LBiYmIUEBCghIQErV+/Pl+7zz77TJ06dVJgYKBCQkLUs2dPrVq1qgSvBFD+158k9erVS6NGjdKPP/6o7777zrG8Vq1a6t+/v+bNm6dWrVrJ399f48eP1+7du2Wz2TRz5sx8+7LZbBo3bpzTsk8//VTNmzeX3W5XnTp19Oqrr7rM0AIAAHgKcnxn5PgoT+T4AOCeKA7AI+XdnXDunQ3Lli1TQkKCunTpIpvNpu+//95pXevWrRUWFnZRx9u+fbskKSoqqtA227ZtU9++fTVt2jQtXrxYDz74oD766CMNGDDAqd2SJUvUtWtX7d27V6+88oq+/PJLPfXUUzp48KCjzW+//aZ27dpp8+bNmjhxohYtWqR+/frpgQce0Pjx4/Md+x//+Id27typd955R++8844OHDigbt26aefOnY42H3zwgQYOHKjQ0FDNmTNH06ZN07Fjx9StWzf98MMPF/W6wDOV9/WX5+qrr5Ykpy8OkrRu3To9+uijeuCBB7R48WJdd911Jdrv4sWLde211yoiIkJz587VSy+9pDlz5ujdd9+9pHgBAEDJkOM7I8dHeSLHBwA3ZQAPdPToUePl5WXuvPNOY4wxR44cMTabzSxevNgYY0z79u3NI488YowxZu/evUaSeeyxxy6432HDhpmgoCCTlZVlsrKyzOHDh82rr75qbDabadeunaPd2LFjTVGXX25ursnKyjKJiYlGkvnll18c6+Lj4018fLw5depUodtfddVVpnr16iY1NdVp+X333Wf8/f3N0aNHjTHGLFu2zEgyrVu3Nrm5uY52u3fvNr6+vmbkyJHGGGNycnJM1apVTbNmzUxOTo6jXVpamqlSpYrp3LnzBV8bIE9ZX3+F2bJli5Fk7rnnHseyuLg44+3tbbZu3erUdteuXUaSmTFjRr79SDJjx451PG/Xrp2pUaOGyczMdCxLS0szERERRV7nAACgdJHjk+PDOuT4AOCe6DkAjxQeHq4WLVo47mpITEyUt7e3unTpIklKSEhwjIFYkrEQJSkjI0O+vr7y9fVVVFSUHnzwQfXp00fz588vcrudO3dqyJAhiomJkbe3t3x9fZWQkCBJ2rJliyTpjz/+0I4dO3THHXfI39+/wP2cPn1a33zzjQYNGqTAwEBlZ2c7Hn379tXp06fzjcc4ZMgQp66RcXFx6ty5s+Pct27dqgMHDmjo0KHy8vrf20ZwcLCuu+46rV69WidPnizW6wOU5fVXFGNMgcubN2+u+vXrX9Q+MzIytHbtWl1zzTXy8/NzLA8ODs53RyAAAChb5Pjk+LAOOT4AuCeKA/BY3bt31x9//KEDBw5o2bJlatOmjYKDgyXJMR5namqqli1bJh8fH1122WXF2m9AQIDWrFmjNWvWaOPGjTp+/Lg+//zzIicpS09PV9euXfXjjz/queee0/Lly7VmzRrNmzdP0tnJkyTp8OHDkqTq1asXuq+UlBRlZ2fr9ddfd3yByXv07dtXknTkyBGnbWJiYvLtJyYmRikpKY59SlJsbGy+dlWrVlVubq6OHTtWaEzA+crq+itK3njAVatWdVpe0L/r4jp27JiMMYqOjs63rqBlAACgbJHj/w85PsobOT4AuB8fqwMArNK9e3e98sorWr58uZYvX+5IqiU5kpTvvvvOMYlSXlJzIV5eXmrbtm2JYvn222914MABLV++3HEnkSQdP37cqV3eeKb79u0rdF/h4eHy9vbW0KFDde+99xbYpnbt2k7Pk5OT87VJTk5WRESEJDn+e+7kUnkOHDggLy8vhYeHFxoTcL6yuv6K8tlnn0mSunXr5rS8oAnF8u7ay8zMdFqe9yU6T3h4uGw2m9N4wHkKuq4AAEDZIsf/H3J8lDdyfABwP/QcgMe6/PLL5e3trY8//li//vqrUzIRFhamli1b6t1339Xu3btLpbtjUfISF7vd7rT8P//5j9Pz+vXrKz4+XtOnT8+X0OQJDAxU9+7dtX79ejVv3lxt27bN98j7IpBnzpw5Tt0x9+zZo5UrVzpekwYNGqhatWr64IMPnNplZGTok08+UadOnRQYGHjR5w/PU97X39KlS/XOO++oc+fOxbpDKTo6Wv7+/tq4caPT8k8//dTpeVBQkNq2basFCxbozJkzjuXp6elatGjRJccNAABKhhz/f8jxUd7I8QHA/dBzAB4rNDRUrVu31oIFC+Tl5eUYCzFPQkKCJk2aJKl0xkIsSufOnRUeHq67775bY8eOla+vr2bPnq1ffvklX9s333xTAwYMUMeOHfXQQw+pZs2a2rt3r5YsWaLZs2dLkl599VVddtll6tq1q+655x7VqlVLaWlp2r59uxYuXKhvv/3WaZ+HDh3SoEGDNGrUKKWmpmrs2LHy9/fXmDFjJJ29U+qll17SLbfcov79++uuu+5SZmamXn75ZR0/flwvvvhimb4+qHjK6vrLzc11jLebmZmpvXv36ssvv9RHH32kRo0a6aOPPirWfmw2m2699VZNnz5d8fHxatGihX766Sd98MEH+do+++yz6tevn6666ir97W9/U05Ojl5++WUFBwfr6NGjxY4dAABcOnL8/yHHR3kjxwcA90PPAXi07t27yxijVq1aKTQ01GldQkKCjDHy8/NT586dyzSOiIgIff755woMDNStt96qESNGKDg4WHPnzs3X9qqrrtJ3332n2NhYPfDAA+rdu7eeffZZp7EPGzdurHXr1qlp06Z66qmn1KtXL91xxx36+OOP1aNHj3z7fOGFFxQXF6fbb79dI0aMUGxsrJYtW6b4+HhHmyFDhmjBggVKSUnRjTfeqNtvv12hoaFatmxZqYwVCc9TFtffqVOn1KlTJ3Xq1El9+vTRU089pfT0dL399tv6+eefixwX+HwTJ07UrbfeqpdeekkDBw7UqlWrCrxTqHfv3vrkk08c18bDDz+sQYMGaeDAgapUqVKxjwcAAEoHOf5Z5PiwAjk+ALgXmylsancAAHBRsrKy1LJlS1WrVk1fffWV1eEAAAAAuETk+AAqIoYVAgDgEt1xxx3q2bOnYmNjlZycrClTpmjLli169dVXrQ4NAAAAwEUgxwfgCSgOAABwidLS0vTII4/o8OHD8vX1VevWrfXFF1/oyiuvtDo0AAAAABeBHB+AJ2BYIQAAAAAAAAAAPAwTEgMAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAAAAA4GEoDgAAAAAAABRDs2bNZLPZFBAQoBMnTpRo2/vvv182m002m01Lly696BiWL1/u2E9Rj+PHj1/0MVzJggULNG7cOG3YsMHqUACgwvGxOgAAAAAAAABXt2HDBm3evFmSdPr0aX388ccaMWJEsbbNysrShx9+6Hg+a9Ys9ezZ85Jj6tKlS6HrfHwqxk8+CxYs0LvvvqtatWqpZcuWVocDABVKxfikAAAAAAAAKEOzZs2SJDVs2FC///67Zs2aVeziwOLFi3XkyBHVr19f27dv17x58zR58mQFBQVdUkw//PDDJW0PAPBsDCuEi7Z7927ZbDaNGzfuovdhs9k0fPjwUosJAAAAQOkaPny4bDab1WEAlsrJydGcOXMkSdOnT1dQUJASExO1d+/eYm2fV1i49957dfnllysjI0Pz588vs3gBACgOigMlcP64ft7e3qpUqZIaNWqkIUOGaN68ecrJybE6TCdPPPGEOnfurCpVqshut6tGjRrq37+/EhMTrQ6tUJMmTdLMmTMvaR/GGL3//vu66aabVLduXQUGBqpmzZq6+uqr9eOPP5ZOoAAAAHB7Fxq7e/ny5VaHeEGlkT+XpQ0bNmjcuHHavXu31aEAF+3rr79WUlKSGjdurE6dOunqq6+WMUazZ8++4LapqalauHChvLy8dMMNN+jmm2+W9L+CQXlZuXKlrr32WkVHR8vPz0/Vq1fXbbfdpi1bthTYvlu3bo73wQ0bNmjw4MGKjo6Wl5eX03tOdna2pkyZossuu0yVKlWSv7+/GjZsqKeeeqrQeRkWLlyoq666SpGRkfL19VVUVJSaN2+u+++/3xFP3g2J7777riTp9ttvd3p/vpQbFQEAZzGs0EW48cYb1b9/fxljlJ6erm3btmnRokWaM2eO2rVrp3nz5ql69epWhylJWr16tZo3b67rrrtO4eHhSk5O1vvvv69u3bpp5syZGjZsmNUh5jNp0iTVqlXrknoUZGZmaujQoWrevLluvPFG1alTR0lJSZoyZYo6deqk9957T7feemvpBQ0AAAC3lpfjn69Ro0YWRFMypZE/l6UNGzZo/Pjx6tatm2rVqmV1OMBFee+99yTJ8cP+kCFDNGfOHM2aNUtjxowpctuPPvpIp0+fVo8ePRQTE6PBgwfr/vvv1zfffKOkpCTFxsaWefyTJ0/WvffeK2OMqlSpohYtWmj79u2aNWuW/vvf/+rjjz9Wv379Ctz2u+++0wsvvCBfX181aNBAwcHBjnUnTpzQgAED9N1338nLy0s1atRQSEiI/vjjDz3//POaN2+eli9fripVqji2eeONN3T//fdLkmJiYtSyZUulpqZq27Zt2rRpk+Lj49WoUSP5+/urS5cu2rZtmw4dOqR69eo57admzZpl9GoBgAcxKLZly5YZSWbChAn51uXm5poXX3zRSDLNmzc3WVlZRe4rJyfHnDx5sqxCLVJaWpqpUqWKqVev3iXtZ9euXUaSGTt27EXvQ5IZNmyY07K4uDiTkJBwSbFlZWWZb7/9Nt/ypKQkExERYaKjo01OTs4lHQMAAADur6gcvzSdPn36gt8RLlZp5M9FGTZsmLmUr44zZswwksyyZctKLyigHKWlpZnAwEAjyWzfvt0YY8yZM2dM5cqVjSSzdu3aIrfv2rWrkWTeeecdx7IBAwYYSebf//53iePJe98q7nW5fv164+PjYySZl156yfFd+PTp02b06NFGkgkLCzMHDhxw2i4hIcFIMt7e3ubOO+80GRkZjnV5v2fcdNNNRpLp0aOH2bFjh2P90aNHzbXXXmskmcGDBzuWZ2VlmfDwcOPj42Pmz5/vdLysrCyzcOFCk5iY6LQ87z1oxowZxTpfAEDxMaxQKbHZbHr88cd10003aePGjZo7d65j3cyZM2Wz2fT111/rn//8p+Lj42W32x1tCht3P2+787sy//rrr+rbt6+Cg4NVqVIlDRw4UDt37lStWrXUrVu3C8YaHBysyMhIHTt2rNjnt2jRIrVt21b+/v6KjY3VAw88oIyMjALbGmM0efJktWnTRoGBgQoJCVH37t21bNmyIo+R12Vwz549SkxMdOoumGfu3Lm6+uqrVbNmTdntdkVGRuqaa67Rxo0bnfbl4+Oj7t275ztGTEyMLr/8ch08eFCHDh0q9vkDAAAAK1asUO/evVWpUiUFBASoRYsWev3112WMcWqXN0b/4cOHNWLECEVHRysgIED79u2TdHaIkccff1x169aV3W5XVFSUbr75Zu3cudNpP6dPn9a4cePUsGFDBQYGKjQ0VA0bNtQDDzwgqXj5c0HyhlKaOXOmXn/9ddWvX1/+/v6qV6+eXn311WK/Hps3b9Z1112nyMhI2e12NWjQQM8++6wyMzOdXovbb79dktS9e3eGA4Fb+uSTT3Ty5Em1b99e8fHxkiRfX18NHjxYUtHDA+3evVs//PCD/Pz8dN111zmWl9bQQoUNiXbusD///ve/lZ2drYEDB+rRRx+Vl9fZn4LsdrveeOMNNWnSRKmpqZo8eXKBx2jatKkmT56swMBAx7KAgABt3LhRH374oeLi4jR//nzVqVPHsT48PFyzZs1SjRo19Mknn2jPnj2SpCNHjujYsWNq1qyZrrnmGqfj+Pj4qH///rr88ssv6TUBABQfwwqVsjvvvFMffvihFi1apFtuucVp3SOPPKLs7GyNGjVKoaGhatCgQYn3v2PHDl122WXKzMzUvffeq9q1a2v58uXq3r27Tp48Weh2R44cUW5urg4ePKhp06bpt99+K/aQQvPnz9fgwYNVrVo1PfnkkwoKCtIHH3ygFStWFNh+6NChmjNnjgYPHqzbb79dmZmZmj17tnr27Kl58+bp6quvLnC7qKgozZo1Sw899JAiIyP15JNP5mvz5ptvKioqSvfcc4+ioqK0Y8cOTZ06VV26dNG6detUr169C57P/v375efnp0qVKhXr/AEAAFDxnTx5UkeOHHFaZrfbFRISIkn64osvNHDgQEVGRurBBx9UeHi4PvnkEz3wwAPatGmTpk6dmm+fPXv2VNWqVfX0008rIyNDwcHBSk1NVefOnbV3716NGDFCTZo0UVJSkiZPnqwOHTpo7dq1iouLk3R24tLp06dr6NChevDBB5Wbm6sdO3Zo6dKlkoqXPxfl9ddfV3Jysu666y6FhIRozpw5evDBB5WSkqJnn322yG3XrVunyy+/XF5eXrr33ntVvXp1LVmyRGPHjtWqVav0+eefy8vLS3fddZfsdrumTp2qf/zjH45hmpo3b16iWAEr5f2An/eDfp4hQ4Zo6tSpmjNnjv7973/Lxyf/Tyzvv/++jDHq06eP03fQgQMHKigoSL/88os2bdqkZs2aXVRsXbp0KXB5dHS04/+/+uorSXIM5XMum82mBx54QHfddZe++uqrAq/9W2+91VFQOFfehMo33HCD473yXIGBgbryyis1Y8YMff/994qLi1NUVJTsdrv++OMP/fLLL2rRokXxThQAUDYs7rngVorT5TglJcVIMq1bt3Ysy+tG26BBgwKHElIBQ+ucu9253W9vvPFGI8l88803Tm0feughI6nA7sRpaWmOLoeSjN1uN3fccYdJS0u74DlnZ2ebGjVqmLCwMJOUlORYfvr0adOmTZt8wwp98sknRpKZMmWK036ysrJMmzZtTK1atUxubm6R515Ut+j09PR8y3777Tfj5+dn7rnnnguez6JFi4wkc+utt16wLQAAACq+c4fnOP8xcOBAY8zZnDguLs6EhISYP//807Ftdna26d27t5FkVqxY4VieNwTGbbfdlu94999/v/H39zcbNmxwWr57924TEhLilBuHh4ebvn37XvAcSjqsUN45BwcHO51PZmamadeunfH29ja7d+/Odz7n6tKli/Hy8jI///yz0/JRo0YZSWb27NmOZQwrBHe2b98+4+XlZby8vMz+/fud1uXm5prq1asbSebzzz8vcPsGDRoYSebDDz/Mt+7mm282ksyjjz5aophKMqzQsWPHHG3PHzYozw8//GAkmfDwcKflecMKLVq0qMDtrrvuOiPJ1K1b13Tp0qXAR97r8+KLLzq2e/TRR40k4+XlZbp27WqeeeYZs3TpUnPq1KkCj8OwQgBQdhhWqJSFhoZKOjspz/nuueceBQQEXPS+c3JytGjRIrVu3VpXXHGF07rHH3+80O0CAgK0dOlSffnll5oyZYo6duyo06dP69SpUxc85rp16/Tnn39q+PDhiomJcSy32+16+OGH87WfPXu2goKCdM011+jIkSOOx/HjxzVgwADt3r1b27ZtK8FZOwsKCpJ0duiiEydO6MiRI4qKilKDBg30448/Frnt1q1bNXToUFWtWlUTJ0686BgAAABQ8dxxxx1aunSp0yPvDtp169Zpz549Gj58uKpXr+7YxtvbW//4xz8kSfPmzcu3z/PzZWOMPvjgA3Xp0kXVqlVzypeDgoLUsWNHxx2+klSpUiVt3rxZmzZtKotT1i233OJ0Pn5+fnrooYeUk5OjhQsXFrrd4cOHtWLFCvXr10+tW7d2Wvf0009LKvj1ANzR7NmzlZubq27duqlq1apO62w2m2688UZJBQ8P9NNPP2nr1q0KDg7WgAED8q0fMmSIJOmDDz5Qbm5uGUQvpaenO/7/3Ml8z5XXyyAtLa3A9Xnfw8+XmpoqSdq+fbtWrFhR4CNvOLVzf3948cUXNWnSJMXHx+v777/Xs88+q549eyo6OlpjxoxxGpoMAFC2GFaolOUVBfKKBOcqzpA3RTl8+LAyMjIKHI4oOjq60GFyvL29deWVVzqejxw5Ut26ddMVV1yhdevWydfXt9Bj7tixQ5Ic3X/P1bhx43zLtmzZooyMDKdCwvkOHjyo+vXrF7q+KOvWrdMzzzyj5cuX55vzoHbt2oVut2vXLvXs2VOS9OWXXxaaFAEAAMAz1a1b1ylnPlfeXABNmjTJty5vKJDz5wuQ8uf/hw8fVkpKir755htFRUUVeKxzh+549dVXdeutt6p58+aqXbu2unfvrv79+2vgwIEFDvFRUkXl+HnfAwpS1OtRo0YNhYWFFfh6AO6osCGF8gwZMkQTJ07Up59+qhMnTjj9FvDee+9JOjuE0Lnj9ee56qqrVLlyZe3fv1/ffvttoe9BlyI4ONjx/4cOHVJsbGy+NgcPHpSkAocGKs6+3377bY0cObLY23l5eelvf/ub/va3v2n37t367rvv9OWXX2revHl68cUXlZaWpjfeeKNEsQAALg7FgVK2YcMGSVLDhg3zrSsoGShKdna203Nz3kRn57vQ+jze3t665ZZbdM899+i7775Tjx49LrjNhSY1OzeGypUrO03IfL6mTZsWa1/n27t3ry6//HKFhYXp6aefVoMGDRQUFCSbzaYHH3zQ6Y6Ic+3evVvdu3dXWlqali5dyvimAAAAKJHi5tnnOz//z9tP9+7dHT0OipLX8/bLL7/U8uXL9e2332r69Onq0KGDli1bdkm9kqWCc/y8GIvK/y/29QDczfr167V58+Z8kwmfq3Xr1mrQoIG2bt2qTz75xDEBd1ZWluN7cWGFhbxJjadOnapZs2aVSXGgUqVKioqK0uHDh/Xbb78VWBz49ddfJanEN/E1btxYCxYs0ObNmy86vlq1aqlWrVq67bbbtGTJEvXu3VvTp0/Xa6+95iiCFvf3CABAyVEcKGV5E5H179+/2NtUrlxZR48ezbf8/LttqlSpoqCgIP3+++/52h48eNDRpa848rr0FXTcc8XHx0uSfvvtt3zrClpWv359bd26Ve3atVNYWFix4zlXYR/88+fPV0ZGhhYuXKju3bs7rUtJSZHdbs+3zZ49e9S9e3cdP35cS5cuVdu2bS8qJgAAAHiuvJw47we0c+X9KJbXpihRUVGqVKmSUlNTi/0jYHh4uIYMGeIYfmT8+PEaN26cPvzwQ8ePkBf7w1lB+fyWLVskSXXq1Cl0u6Jej3379ik1NdXp9eCHPbirvF4DvXv3Vnh4eKHtbr75Zo0bN06zZs1yXJdffvmljhw5ooiICPXq1avQbfMmNZ43b54mT55c4psKi+Oqq67S+++/r9dffz3fzYHGGL3++uuOdiUxaNAgvfDCC3r//ff19NNPKyIi4pLi7Nixo6Szv1ccO3bMsb+8QmhxhkYGAJQMcw6UEmOMXnrpJc2dO1ctW7bUDTfcUOxt69evr1WrVunkyZOOZceOHdOMGTOc2nl7e6tfv35av369vv32W6d1//rXv/Lt99ixYzpz5ky+5RkZGZo2bZq8vLzUvn37ImNr3bq1atSooXfffVfJycmO5ZmZmXrllVfytR86dKiMMRozZkyBdxTldVcsSnBwsI4dO5Zvube3t6T8dyq9/fbbTrHl2bNnj7p166Zjx47pq6++Urt27S54bAAAAOB8rVu3VlxcnN59913t37/fsTw3N1cTJkyQdPZHsgvx8vLSLbfconXr1unDDz8ssM2hQ4cknZ1v7Pjx4wXGIjnf5FNY/nwhs2fPdowHLklnzpzR//3f/8nb27vA8dHzREVFqUuXLvriiy8cPafzPP/885Kka6+91ik+SRcVI2CVnJwczZkzR1Lhd/7nyVu/fPly/fnnn5L+V1gYPHhwkUP5Xn755apevbrS09M1f/780gg9n7///e/y8fHRp59+qokTJzrmNzhz5oz+9re/afPmzQoLC9M999xTov22bdtWN9xwg1JSUtSzZ0+tX7/eaX1OTo6WL1+uW265xTGPwG+//aa77rpLa9ascfpun5mZ6Xj/iIuLcyo05BUrv/vuO3ouAUApo+fARdiwYYPef/99SWcn99m+fbsWLlyoP/74Q+3bt9e8efMcP2QXx3333adbb71VV1xxhYYOHarjx4/r7bffVlxcXL4fvZ977jktWbJE/fv317333qvatWtr+fLl+umnnxQZGel0V05iYqLuuusuXXfddapbt65CQkK0a9cuzZo1S/v27dPYsWMVFxdXZGze3t569dVXNXjwYLVv31533nmngoKCNHv27AI/lAcPHqzbb79dkydP1oYNGzRgwABFRkZq3759WrVqlbZv337B8Uc7dOig6dOna9y4cWrQoIFsNptuuukm9enTR4GBgRo6dKjuu+8+hYeHa8WKFfriiy8UHx/vNAxTWlqaunfvrt27d+v+++/XH3/8oT/++MPpOHkTHgEAAABF8fb21ltvvaWBAweqXbt2uuuuuxQeHq558+YpMTFRo0aNUufOnYu1r+eff14rVqzQkCFDNH/+fHXq1El+fn7as2ePvvjiC7Vp00YzZ85UWlqaYmNjdfXVV6tly5aKjo7Wnj17NGXKFAUHBzv9+F5Y/nwh9evXV4cOHXT33XcrJCREH3zwgdasWaOnn376gt8TXnvtNV1++eVKSEjQvffeq2rVqumrr77SZ599pquuusoxSat09gdELy8vTZgwQceOHVNgYKCaNm160cONAuVh6dKlju/j999/vx588MEi29tsNhljNHv2bN19992OSb3nzJmjBQsWFLltXiFw1qxZuuWWWy419Hxatmyp1157Tffee68eeeQRvfzyy6pZs6a2bdum48ePy263a/bs2UXOHViYadOm6dixY1q6dKlat26tmjVrKjY2VidPntT27dsdd/tPmzZN0tmCxNSpUzV16lRVqlRJderUkTFGO3fuVGpqqvz8/DR58mSnYwwaNEhPPvmkPvzwQ61atUo1a9aUl5eXhg8fruHDh1/y6wMAHs2g2JYtW2YkOR5eXl4mNDTUNGjQwNx8883mk08+MdnZ2fm2mzFjhpFkli1bVui+X3rpJVOzZk3j5+dnGjZsaKZNm1bodhs3bjRXXXWVCQwMNGFhYWbQoEFm9+7dpnLlyqZPnz6Odtu3bzcjRowwDRs2NKGhocbHx8dER0eb/v37m0WLFpXo3BcuXGhat25t7Ha7iY6ONvfdd5/ZvHmzkWTGjh2br/17771nLrvsMhMSEmLsdruJi4szgwYNMh9++KFTO0lm2LBhTsuSkpLMwIEDTVhYmOO1zpOYmGi6dOligoODTVhYmOnbt6/ZtGmTSUhIMHFxcY52u3btcvpbFfQo6u8BAAAAz5CX40+YMOGCbb///nvTq1cvExoaaux2u2natKl59dVXTW5urlO7YcOGmaK+amVkZJhnn33WNG3a1Pj7+5vg4GDTsGFDM3LkSLN69WpjjDGZmZnmiSeeMO3btzeVK1c2fn5+pmbNmmbo0KHmt99+c9pfUflzUec8Y8YM8+qrr5q6desaPz8/U7duXTNp0qR87Qs7n02bNplBgwaZypUrG19fX1OvXj0zbtw4c/r06Xxtp02bZurXr298fHwK/Q4BuJIhQ4Zc8DtlQY/GjRubqVOnXtS23t7eJikp6YKxnfvbREn88MMP5pprrjFRUVHG19fXVK1a1dx6663m119/LbB9QkJCsb475+TkmNmzZ5urrrrKREZGGl9fXxMbG2s6dOhgHn/8cfPTTz852qanp5u3337bXH/99aZevXomODjYBAcHm8aNG5u7777bbN++vcBjLFmyxCQkJJjQ0FBjs9l4HwGAUmIzhj5ZFcGRI0cUFRWlu+66S1OmTLE6HAAAAAAuavny5erevbtmzJjBXbcAAAAejDkH3FBBk/C88MILklTkREcAAAAAAAAAAEjMOeCWWrZsqR49eqhp06Y6ffq0li5dqsWLF+vyyy/XwIEDrQ4PAAAAAAAAAODiKA64oYEDB2rhwoWaNWuWzpw5o5o1a+qJJ57QU089VaKJkAEAAAAAAAAAnok5BwAAAAAAAAAA8DDMOQAAAAAAAAAAgIehOAAAAADA4xhjdOLECdGRGgAAAJ6K4kAxJCUlady4cUpKSrI6FAAAAAClIC0tTWFhYUpLS7M6FAAAAMASFAeKISkpSePHj6c4AAAAAAAAAACoECgOAAAAAAAAAADgYSgOAAAAAAAAAADgYSgOAAAAAAAAAADgYSgOAAAAAAAAAADgYSgOAAAAAAAAAADgYSgOAAAAAAAAAADgYSgOAAAAAAAAAADgYXysDgBAyRhjdOS375W0dpEyUw8pKLauqne8VqE1GlsdGgAAAAAAAAA3QXEAcDN7E9/Xnz98KNlskjHKTEvR0T9Wq9H1TymifkerwwMAAAAAAADgBigOAC7o9PGDSl73hU4e2Sf/StGKad1bgZE1lXniiP78Ye7ZRsb89d9cSdLOJf9R5XrtZbMxWhgAAAAAAACAolEcAFxM6p7N+nXO08rNyT77w7+Xlw6sWaiG1z2hnNMnJZkCt8tMPaRTKfsVGFmjfAMGAAAAAAAA4Ha4xRhwIcbk6o/PJio3J8vRI0C5uZLJ1baFk2QKKQzksXlR7wMAAAAAAABwYRQHABeSkbxTmamH/jdk0DlyMk/K28cum3cBBQCbTYFVask/PKYcogQAAAAAAADg7igOAC4kNyeryPU2Hx/F9x599onXX5evzUtePn6q1+9+2Wy2Mo4QAAAAAAAAQEXAGCSACwmOqStv/yDlnM7It87m5aOwms3kGxiqoOjaSl63WJknDis4po5iWveTf6UqFkQMAAAAAAAAwB1RHABciJePr+pcOUrbFk2SbF5n5x2w2SRjVDPhFvkGhkqSQqrWV0jV+tYGCwAAAAAAAMBtecSwQrVq1ZLNZsv3uPfee60ODcgnumVPNbn5WYXFNZNvULhCqjVUw2ufUI0uN1gdGgAAAAAAAIAKwiN6DqxZs0Y5OTmO55s3b1bPnj11/fXXWxgVULjw+DYKj29jdRgAAAAAAAAAKiiPKA5ERUU5PX/xxRcVHx+vhIQEiyICAAAAAAAAAMA6HlEcONeZM2f0/vvv6+GHH5bNZiuwTWZmpjIzMx3P09PTyys8AAAAAAAAAADKnEfMOXCuBQsW6Pjx4xo+fHihbSZMmKCwsDDHgx4GAAAAAAAAAICKxOOKA9OmTVOfPn1UtWrVQtuMGTNGqampjkdiYmI5RggAAAAAAAAAQNnyqGGF9uzZo6+//lrz5s0rsp3dbpfdbnc8Dw4OLuvQAAAAAAAAAAAoNx7Vc2DGjBmqUqWK+vXrZ3UoAAAAAAAAAABYxmOKA7m5uZoxY4aGDRsmHx+P6jABAAAAAAAAAIATj/mV/Ouvv9bevXs1YsQIq0MBLtnJw3uVtO5LZR5PVkBkDcW27iv/8BirwwIAAAAAAADgJjymONCrVy8ZY6wOAyg2k5uj7MyT8rEHyubl7Vh+ZMsK/T7vRdlsNpncHGn7Wh346TM1HfKcwuKaWhgxAAAAAAAAAHfhMcUBwF0Yk6v9q+Zp36pPlH3qhLz9AhXbtr9qJtwik5utbQsnSSZXjlqXyZXJNfpj4Stqe+87stk8ZrQwAAAAAKhYMtOk3GwpINzqSAAAHoDiAOBi9i5/X3+umOt4nnPmpPat/K/OpKcostFlyjlzMv9Gxijz+EFlHNyl4Jj4cowWAAAAAFBqTqZI6YelGu2sjgQA4AG4xRhwIdmn07Vv9bwC1hgd2viNMlMPFbl9bnZW2QQGAAAAACgfJ1OsjgAA4CEoDgAuJOPQHpmcwn/gt3n7yuZVcIcfn4AQeg0AAAAAgLvLOGx1BAAAD0FxAHAhvkFhRa73D49RzYRbzj7Jm1vgr//WvnKkvHx8yzI8AAAAAEBZSz9odQQAAA/BnAOACwmMqK7gqvWVnrRdMrn/W2Hzkj0kQmE1m6pSrRYKqFxV+3/6VKePJSkwKk7VO16n8PjW1gUOAAAAACgdaUlWRwAA8BAUBwAX0+Cax7T5/THKPHFYNi9vmdwc+fgHqdENT8vm5S1Jimx0mSIbXWZxpAAAAACAUneC4gAAoHxQHABcTEDlWLUZ/bZStq7SySN/yr9SFUU26ipvP3+rQwMAAAAAlLW0JCknW/LmJxsAQNnikwZwQV4+vopqcrnVYQAAAAAAypvJPVsgqFTD6kgAABUcExID5axt27aqXr262rZta3UoAAAAAABXdHyv1REAADwAPQeAcpacnKz9+/dbHQYAAAAAwFUd3yupi9VRAAAqOHoOAAAAAHA73333nQYMGKCqVavKZrNpwYIFVocEAKWHngMAgHJAcQAAAACA28nIyFCLFi30xhtvWB0KAJS+43usjgAA4AEYVggAAACA2+nTp4/69OljdRgAUDaO75WMkWw2qyMBAFRgFAcAAAAAVHiZmZnKzMx0PD9x4oSF0QDABWSmSaePSwHhVkcCAKjAGFYIAAAAQIU3YcIEhYWFOR41atSwOiQAKNrxP62OAABQwVEcANyMyc3RkS0/aNvCSdr++es6tmOdjDFWhwUAAODSxowZo9TUVMfjzz/50Q2Ai0vdZ3UEAIAKjmGFADeSm31Gv344Tqm7f5G8vGWTlLx+sao076F6Ax6UzUa9DwAAoCB2u112u93qMACg+I7vtToCAEAFxy+JgBs5sGahUndvPPskN0cmN0eSdGjjN0rZusrCyAAAAAAAperYLqsjAABUcPQcANzIoU3fSipgCCGblw5vTlRkwy7lHhMAAIAV0tPTtX37dsfzXbt2acOGDapcubJq1qxpYWQAUEoOb5WMkWw2qyMBAFRQ9BwAXFROVqZOHU1SzplTjmW5Z04X3NjkKjerkHUAAAAV0Nq1a9WqVSu1atVKkvTwww+rVatWeuaZZyyODABKyaljzDsAAChT9BwAXIzJzdGe5bN0YM1nys3KlM3bV9Eteqp2z5EKj2+jpHVfSib3vK1sCqvd0opwAQAALNGtWzcZU0CPSgCoSPaulirVsDoKAEAFRc8BwMXsXPqO9q38WLlZmZIkk5Ol5PWL9cdnE1Wt02D52AOlcycetnnJv1K0YlpeZVHEAAAAAIAyse0rqyMAAFRgFAcAF5J18oSSf/5c+eYVMLlK2bJCJidLLUZMUlTTbvK2B8knIFSxbfqq+e0T5eMfZEnMAAAAAIAycuQPKXmT1VEAACoohhUCXMjJI3tlcnMKXZ9+cKeiGndVg4F/L8eoAAAAAACW+fldqd+/rY4CAFAB0XMAcCF+wZUvsD68nCIBAAAAALiEfWukPausjgIAUAFRHABcSEDlqgqt2cR5TgHp7LwClasqtEZjawIDAAAAAJSZ1NRU/fDDD/ph9Rr9sD1VqaeynRuseFU6c9Ka4AAAFRbFAcDFNLjmMQVEVD/7xGaTJPmFRKjxDc/Idn7RAAAAAADg9jZt2qSuXbuqa98b1PXfv2jT/gznBmlJ0k9TrQkOAFBhMecA4GLsoZFqfdebOr5zvU6m7JN/WBWF120nL+/iX67G5OrU0QOy2WzyD68q219FBgAAAACAm/p1vlSz49kHAAClgOIA4IJsNi+Fx7dReHybEm97bMdabf/yLWUePyhJCoiorrr97ldYzaalHSYAAAAAoDwte0G6bpoUHGV1JACACoAxSoAKJD1pm36dO16Zxw85lp06ul+bZz+lUyn7LYwMAAAAAHDJTqdK34yTcrKsjgQAUAFQHAAqkP2r58smmyTzv4XGyOTm6MDahZbFBQAAAAAoJcmbpR/+TzLmwm0BACgCxQGgAklP3iGTm5N/hclVevKO8g8IAAAAAFD6fv9c+nmm1VEAANwccw4A5SwmJsbpvwXJzc5Syu8r/pqQOFqRjS+Tt1+AY/3h377X/lWf6NTR/fIPj1W1jtcqqkmC7GFVdOroAcnkOu/Qy1v+YVXK5HwAAAAAABb4eabkGyC1uMnqSAAAboriAFDO1q5dW+T6U0cPaNP7/9CZE4dl8/KWyc3Rrm+mqemQ5xQcW1f7f5yvXUvfkWw2yRhlJO/UHwteVmbqIcW27afjO9fl32lujmJa9ymjMwIAAAAAWGL1ZCnrlNRm+NnviAAAlADDCgEuZuv8l3QmLUWSHEMEZZ/O0G//fU5Zp9K0Z/mssw0d40ue/e/e7z5QWI0mius2VLL979K2efmoTu97FFazabmdAwAAAACgnPw8U/r+31JOttWRAADcDD0HABdy8sifSk/aln+FydWZE4d18Jelys3KLHBbk5OlE/t/V43LblJ0i146tvNn2WzeCq/bRr6BYWUcOQAAAADAMlsWSWkHpR7PSP6hVkcDAHAT9BwAXEjWyRNFrjdZZ4pc7+VjlyT5hVRWdIueqtL8CgoDAAAAAOAJ9q2RFtwjHdttdSQAADdBzwHAhQRVqSWbt69MTlaB6yObJChp/Zdnhx1yDCskyWaTb2CYwmo2KZU40pO2Kz15h/xCKqtS7Vby8v7fW8WplP06sOYzpSfvkD0sSrGt+yosrpljfdr+37V/9QKlH9wh/0oxqtpugCrXa18qcQEAAAAAipC6T5p/j9R9jFT7cqujAQC4OI/oObB//37deuutioiIUGBgoFq2bKmff/7Z6rDgodq2bavq1aurbdu2+db5+AepesdrC9jKpiotrlRA5Vg1GPiovLx9z84r8NfD5uWjBgMfkc3L+5Jiy848qU2zn9SGaX/T9s9f028fjtPa129XevIOSVLq3s1aN/VeJf38hdL2bVHKlhXaNOsJHVjzmSQpZesq/TLzER3ZukKnjx7Q8V0b9Nvc8dq36pNLigsAAAAAUExZJ6WvnpZ+nCr9NY8dAAAFqfA9B44dO6YuXbqoe/fu+vLLL1WlShXt2LFDlSpVsjo0eKjk5GTt37+/0PU1u90qb/8g7V/1ibJOpsrbHqiqbQeoxuVDJElhcU3VZvTbSl6/RKeP7pd/eKyiW14l/0pVinX8E/u26M/vP9SJP3+VT0CIYlpdpWodr5OXj692LvmPUndvdGp/JuO4fp3zjNreN0PbP39dJjfb0Wshb8LkXUvfUWTDrtqxePLZdXm9GkyuJGnPsncV3fxK+QYxxBEAAAAAlIsNs6WDm6UeY6WgCKujAQC4oApfHPjXv/6lGjVqaMaMGY5ltWrVKnKbzMxMZWb+b9LX9PT0sgoPyMdm81L1TtepWodrlJN5Ut72wHw9AuyhkYpLuKXE+z6+e6M2f/CkZCSZXOWcOaU9ie/rxJ9bVH/QYzq8eZnjB30Hk6usjOM6uOErnUrZV+B+TW6OkjcsOTvcUSHrj+1arypNu5U4ZgAAAADARUr6Rfr4dinhcalWF6ujAQC4mAo/rNBnn32mtm3b6vrrr1eVKlXUqlUrvf3220VuM2HCBIWFhTkeCQkJ5RQt8D82L2/5BIRc8lBB59r97Yy/7uw/pwBgjI7tWKuj235y9ATIH4xNZ9IL/uG/uGy2Cv92AwAAAACu53SqtOQf0nf/ls5kWB0NAMCFVPhf63bu3KnJkyerXr16WrJkie6++2498MADeu+99wrdZsyYMUpNTXU8EhMTyzFi4NJknjiiPxa+qlUv36BVLw3W1k8n6vTxg8rJOq30A384T2T8F5uXt04d3iNvv4CCd2qMwuJayL9SjCRb/vU2L0W36Cn/8NgC19u8fRUe3/rSTgwAAAAAcPG2LJT+O1z68yerIwEAuIgKXxzIzc1V69at9cILL6hVq1a66667NGrUKE2ePLnQbex2u0JDQx2P4ODgcowYuHhZGan6ZfpDOrTxa+VkZijnzCkd3rxcv0x/SGcyUgvthWCMkbc9UNUKmgzZ5qWgmHhVqt1C8X1GS142KW8/f/UGiEu4RfbQCNXtd79s3j6O5XnHi+99j3z8uY4AAAAAwFLph6QvHpW+Hi9lXFrvcACA+6vwcw7ExsaqcePGTssaNWqkTz75xKKIgEtjjFHq7o06vHmZss+cVFjNZqrSvId87IE6sHaRzmQcP2/YoFxlnUpT8s+fK6JhZx3ZsqLAeQUiG3WVf3i0TG6O9v84X7lZZ+fdqFy3rer1f1A2m03h8W3UcsQk7f9xvtIPbJc9LEqxbfsron4HSVKlWi3U6s43lLR2kTKSd8o/PEYxrfsotHqjcnp1AAAAAAAXtONb6c8fpTa3S00GSd4V/uchAEABKvy7f5cuXbR161anZX/88Yfi4uIsigi4NLu/naH9qz45e/d+bq5StqzQgZ8+VfPh/9bxXevz//AvSSZXx3asU5Obxilt/1Zlph6SbF6y2WwyuTmq3XOkAirHSpLiug1V9c7X69SxA/ILqiS/4MpOuwqOiVeDgY8UGl9gRHXFX3V3qZ4zAAAAAKCUncmQVr0h/b5Q6nS/VKOd1REBAMpZhS8OPPTQQ+rcubNeeOEF3XDDDfrpp580depUTZ061erQgBJL27/1bGFAks6ZPPj08YPau3zW2TkDbLYC5hWwydseIHtopFrd+aYOb16mE39ukW9gqKo076HgmHin1t5+/gqOrlPGZwMAAAAAsNyxPdIXj0hxXaROo6Ww6lZHBAAoJxW+ONCuXTvNnz9fY8aM0bPPPqvatWtr0qRJuuWWW6wODSjSqaNJOpXyp/wrxSgwqqYk6ciW72Xz8pY5pzAgSTK5OvxrouL7jNbxnesK2JtRdLMrJEk+9kDFtumn2Db9yvgMAAAAAABuY8+Ks0MNNb9BajVU8gu0OiIAQBmr8MUBSerfv7/69+9vdRhAsWRnntQfC/6to9t+dCwLrdlEDa8do9zsrEK3y83JUlSTBB3dtkZHfvvOMRmwyc1R5fodFN2yV5nHDgAAAABwY7nZ0oYPpG1LpY73SPFXnO2dDgCokDyiOAC4k22LJuno9jVOy07s26ItHz+v6p2vV9LaRfk3snkpvE5r2by81WDQY4pu0VMpW1dJMqpcv4PC49vIZvMqnxMAAAAAALi3jMPSN89KfyyWLntICq1qdUQAgDJAcQBwIZknjihly4r8K3JzlbZvi/yCwhUW11ypezf9b14Bm5e8fHxVs9vQs09tNoXHt1Z4fOtyjBwAAAAAUOH8+ZP03+FSh7ulJoPoRQAAFQy3EgMu5PTx5KLXpx5Uk5vHKy5hqPwrV5VvUCVFNblcLUdMYgJhAAAAAEDpy86UVrwqffmYdPKo1dEAAEoRPQcAF+JfKUaSTZIpcH1A5ary8vFTjctuVI3LbizX2AAAAAAAHuzPn6R5d0q9/ilVaWR1NACAUkDPAcCF2EMjFdnoMun8+QFsXgqp3kjBMfHWBAYAAAAAQMZh6bP7pR3fWh0JAKAUUBwAXEzd/g8oon5Hp2VhcU3V6PqnLIoIAAAAAIC/5GSdnax48ydWRwIAuEQMKwS4GB97oBpd/6ROHz+oUyn7ZK8UrcCI6laHBQAAAADAWcZIK16TzpyUWt3KRMUA4KYoDgAuyr9StPwrRZfKvrJOpSl1z0bZvLxVqVZLefv5l8p+AQAAAAAebM070pkMqcNdFAgAwA1RHAAquH2r52nPsndlcrIlSV5+/qrX7wFFNUmwODIAAAAAgNv7ZY50Jk267GHJy9vqaAAAJcCcA0AFlvLHau3+epqjMCBJuWdOa+uCl5WevMPCyAAAAAAAFcaWRdLiMWeHGQIAuA2KA0AFduCnzyRbAZe5zUvJ674s/4AAAAAAABXTnz9Kn46WUvdbHQkAoJgoDgAV2OljSZLJzb8iN0enjyWXf0AAAAAAgIrr6C5p/l3S3h+tjgQAUAzMOQBUABkHd2n/T5/p5KFd8g+PUWzb/gqr2VSBUbWUeeJI/gKBzUuBUTWtCRYAAAAAUHFlpkmLH5fa3C61Gip5cV8qALgqigNAOYuJiXH6b3EYY3Ri769KT94uv5AIRdTvIC8fP0nS0e1r9NtHz0qySbk5yji4U0d++17xfe5TtY6DdGz7T847s9lk8/JSbNt+pXVKAAAAAIBLYIwp8rnbMUZaO1068ofU/UnJL9DqiAAABaA4AJSztWvXlqh99qk0/frhOKXt/12y2SRj5BMQoiY3jVNwbD1t//wNKddIOts7wOTmSJJ2fvUfdXhotupf86h2LvmPsk+dkCTZQyJVb8CDCqhcrVTPCwAAAABQMsePH9e7776rl156yWn5TdN+12M9a2hYp2hVCnTjn252/yB9dp/U+19ScJTV0QAAzuPGnzCAZ9i+eLLSDvxx9slfd49kn87Qrx+OV+Mbx+pM2pECtzM5WTq+a4OqNO2myEZdlJG8QzYvHwXF1JGtoEmKAQAAAADlZsmSJbruuut08uTJfD0FDhw/o4f+u0NPfrZLn9zZWFc1qWxRlKUgZYe08G9S//+TQqKtjgYAcA5+IQRcWPbpdB357fv8cwaYXGWfOqHUPZsusIezCaaXt69CqjVUcGxdCgMAAAAAYLElS5aoX79+OnXqVKFDCBlJp87kqt+bm7Xk16PlG2BpO7Ff+vJRKeuU1ZEAAM7Br4SAC8s6eSJ/YSCPzSabj4/8gitLsuVf7e2rSrVblml8AAAAAICSOX78uK677joZY5SbW8j3vb/kmrMdyK+b+puOn8wupwjLyLE90qo3rY4CAHAOigOAC7OHRsnbHlTwSmMUEltP8X3vOzsXgddfl/NfPQNq9xwpH//gcooUAAAAAFAc7777rk6ePHnBwkCeXCOdzMzVe6sPlnFk5WDrl9JJN+8FAQAVCMUBwIV5+fiqRpfr86+weSmkeiOF1miiiPod1HLE/ymqSYICq9RW5fod1PSWF1S1bf/yDxgAAAAAUChjjF5//fWL2va1ZfsLHYLIbeRmSwfWWR0FAOAvTEgMuLhqnQZLsunPlR8p53SG5OWlqMaXK773PbLZzg4nFBxbVw0GPmJtoAAAAACAIqWkpGjHjh0l3s5I2nH4tI5mZCsi2Lf0AytPp09YHQEA4C8UBwAXZ7PZVL3zYFXtMFBnThyRT0CofPwLGWoIAAAAAOCy0tPTL2n7tNM57l8cCKtudQQAgL9QHADchJe3r/zDY60OAwAAAABwkYKDL21euBB/71KKxCK+AVJ0U6ujAAD8hTkHABeVfTpD6Qd3KuskXS4BAAAAoCKIiIhQfHy8Y4jY4rJJio/yV+UgN7/Hs24PyS/Q6igAAH9x808VoOLJzcnSrqXTlLz+S5mcbMnmpagmCYrvM1o+dpIoAAAAAHBXNptN999/vx566KESb/tA92olLiq4FJuX1OJmq6MAAJyDngOAi9m55D9K+nnR2cKAJJlcHf41UVvnv2RtYAAAAACASzZs2DAFBgbKy6t4P8l42aRAu5du6xhdxpGVsfq9mW8AAFwMxYH/Z+++46Oo8z+Ov2c3vZJCEhJKIKH3Jp3QpGNBEbsCtrPLzztFPREbltNTTw8bYjsVFQRFpChdelN6772lF5Ld+f2BrIYECJBkNruv5+MRcWe+M/veHTbMzme+3y/gRvKz0nRw1XTJNAuvMJ06sXWZso/utiYYAAAAAKBUVKpUSRMmTJBhGOctENgMyTCkiXc3UKWgCjz4g4+/1GqI1SkAAGegOAC4kexjeyTTedb1WYd3lWMaAAAAAEBZ6NWrl3788UcFBgaedaggQ1Kgn01T72+kng0iyzdgaWtynRQSY3UKAMAZKA4AbsQ/NPo866PKKQkAAAAAoCz16tVLe/fu1RtvvKH4+PhC6+Ir+emN65K076W2Fb8wEBIjNbvJ6hQAgGJQHADcSEBEnMJrNjs1UdNfGTYFRldXaNX6luQCAAAAAJS+SpUq6cEHH9RXX31VaPlXw+rpwW4JCg+swEMJndb+Qck30OoUAIBiUBwA3EzdKx9VSFxSoWWBEVXUcPDTZ+1uCgAAAACouM78rucx3/2Sukk1O1mdAgBwFh5QggY8i19IhJoO/bcy9m5Q9tE9CgiPUXjNpjLO7E0AAAAAAIC7Co2TOj5idQoAwDlQHADckGEYCqvWQGHVGlgdBQAAAACAC2P3k3o8IwWEWZ0EAHAO3IoMAAAAAACA0mEYUvd/SjHMmQcA7o6eAwAAAAAAALh0Nh+p25NSzc5WJwEAlADFAQAAAAAAAFwa/9BTQwlVbWV1EgBACVEcAAAAAAAAwMWLbST1GCmFxFidBABwASgOAAAAAAAA4ML5Bkqt75AaDpRsTGsJABWNx//mfuaZZ2QYRqGfuLg4q2MBAAAAAABUXEldpUGfSI2vpTAAABWUV/QcaNiwoX7++WfXY7vdbmEaAAAAAACACqpyPan9/VJcY6uTAAAukVcUB3x8fOgtAAAAAAAAcLFC46TL7pRqdaOnAAB4CK8oDmzZskXx8fHy9/dXmzZt9OKLL6pWrVpnbZ+Xl6e8vDzX48zMzPKICQAAAAAA4F58AqQWt0iNr5N8/KxOAwAoRR5f6m3Tpo0+/fRTTZ8+XR988IEOHjyo9u3b69ixY2fdZvTo0QoPD3f9pKSklGNiAAAAAAAAN5DUVRr8mdT8ZgoDAOCBPL440KdPH11zzTVq3LixevTooR9//FGS9Mknn5x1mxEjRigtLc31M3fu3PKKCwAAAAAAYK2gSKnXi1KPZ6SQGKvTAADKiFcMK/RXwcHBaty4sbZs2XLWNv7+/vL393c9DgkJKY9oAAAAAAAA1qrRQerymBQQbnUSAEAZ8/ieA2fKy8vThg0bVKVKFaujAAAAAAAAuAfDJrW5W+r5PIUBAPASHl8cePTRRzV37lzt2LFDS5Ys0bXXXqv09HTddtttVkcDAAAAAACwnm+Q1Hu01OxGyebxl4oAAH/w+GGF9u7dqxtuuEFHjx5V5cqV1bZtWy1evFg1atSwOhoAAAAAAIC1QmJPFQaikqxOAgAoZx5fHPjqq6+sjgAAAAAAAOB+Yuqfmng4KNLqJAAAC3h8cQAAAAAAAABnqNtX6viI5ONndRIAgEUoDgAAAAAAAHgLnwCp/QNSvX6SYVidBgBgIYoDAAAAAAAA3qByPanbU1KlalYnAQC4AYoDAAAAAAAAnszuJ7UeJjUeJNnsVqcBALgJigMAAAAAAACeKqGl1Gm4FF7V6iQAADdjszrAaZ06ddKOHTusjgEAAAAAAFDxBVaSuv1T6vcahQEAQLHcpjiwdetWNW3aVO+//77VUQAAAAAAACquun2l6z6Tavdg0mEAwFm5TXFg/fr16t+/v+655x716dNHBw4csDoSAAAAAABAxRESI/V7XerymBQQZnUaAICbc5viQEREhL744gtNmDBBq1atUqNGjfTll19aHQsAAAAAAMD91ektXTtOqtrS6iQAgArC7SYkvvrqq5WSkqJ7771XN998s0aNGiU/P79CbQzD0G+//WZRQgAAAAAAADdh95M6PiLV62t1EgBABeN2xQFJyszM1JEjR2SapiIjI+Xv7291JAAAAAAAAPcSFCn1flmqXMfqJACACsjtigMffPCBHn30UYWGhmrq1Knq3bu31ZEAAAAAAADcS3hVqe+/pLAqVicBAFRQbjPnwL59+9SnTx/dfffd6tevn9asWUNhAAAAAAAA4ExhCVL/NygMAAAuidv0HGjUqJF8fHw0fvx4DRo0yOo4AAAAAAAA7icgTOr3mhRS2eokAIAKzm2KAx07dtSHH36o2NhYq6MAAAAAAAC4H8Mm9RhFjwEAQKlwm+LADz/8YHUEAAAAAAAA99XkOimhhdUpAAAewm2KAwAAAAAAAN6ocePGmj9/vpRxQJr1ghonBBdtFFxZajW0/MMBADwWxQEAAAAAAAALhYeHq2PHjtKJndLu8OIbtRoi+fiXay4AgGezWR0AAAAAAAAA5xBcWard0+oUAAAPQ3EAAAAAAADAnTW4UrL7Wp0CAOBhKA4AAAAAAAC4K8Mm1e1rdQoAgAeiOAAAAAAAAOCuqreVgqOsTgEA8EAUBwAAAAAAANxVnd5WJwAAeCiKAwAAAAAAAO7IP1Sq3s7qFAAAD0VxAAAAAECF9N///lc1a9ZUQECAWrZsqfnz51sdCQBKV3J3ycfP6hQAAA9FcQAAAABAhTN+/Hg9/PDDevLJJ7Vq1Sp16tRJffr00e7du62OBgClJ7mH1QkAAB6M4gAAAACACuf111/XsGHDdMcdd6h+/fp64403VK1aNY0ZM8bqaABQOkJipJiGVqcAAHgwH6sDAAAAAMCFOHnypFasWKHHH3+80PKePXtq4cKFxW6Tl5envLw81+P09HRJ0urVqxUSElJ2YQHgQqTvl3ZnnPr/5DbS6tWWxgGAiqpFixZWR6gQKA4AAAAAqFCOHj0qh8Oh2NjYQstjY2N18ODBYrcZPXq0Ro0aVWR5SkpKmWQEgEu3StKrVocAgArJNE2rI1QIFAcAAAAAVEiGYRR6bJpmkWWnjRgxQsOHD3c9Tk9PV7Vq1TR37lx6DgBwH+n7pZlPS3Y/qf+bko+v1YkAAB6M4gAAAACACiU6Olp2u71IL4HDhw8X6U1wmr+/v/z9/Yssb9asmcLCwsokJwBcsBOR0qZQKaGFdFkbq9MAADwcExIDAAAAqFD8/PzUsmVLzZw5s9DymTNnqn379halAoBSFMtExACAskfPAQAAAAAVzvDhw3XLLbeoVatWateund5//33t3r1b99xzj9XRAODSVa5ndQIAgBegOAAAAACgwhk8eLCOHTumZ599VgcOHFCjRo00depU1ahRw+poAHDpImtZnQAA4AUoDgAAAACokO69917de++9VscAgNJl95NC4qxOAQDwAsw5AAAAAAAA4C7Cqkg2LtcAAMoe/9oAAAAAAAC4i5BYqxMAALwExQEAAAAAAAB3ERRtdQIAgJegOAAAAAAAAOAugiKtTgAA8BJeVxwYPXq0DMPQww8/bHUUAAAAAACAwgIqWZ0AAOAlvKo4sGzZMr3//vtq0qSJ1VEAAAAAAACKCoywOgEAwEt4TXEgMzNTN910kz744ANFRPAPLQAAAAAAcEOBlaxOAADwEl5THLjvvvvUr18/9ejR47xt8/LylJ6e7vrJzMwsh4QAAAAAAMDr+YdZnQAA4CV8rA5QHr766iutXLlSy5YtK1H70aNHa9SoUWWcCgAAAAAA4Az+oVYnAAB4CY8vDuzZs0cPPfSQZsyYoYCAgBJtM2LECA0fPtz1ePXq1UpJSSmriG7B6TT1y4qNmrFsvTKyctQ0uZoGpjRXbCR3LAAAAAAAUG78gq1OAADwEh5fHFixYoUOHz6sli1bupY5HA7NmzdPb7/9tvLy8mS32wtt4+/vL39/f9fjkJCQcstrBdM09dr4mZqxdL0Mw5Bpmtpx8JimL1uvNx8arBqxkVZHBAAAAADAO/gGWp0AAOAlPL440L17d61Zs6bQsiFDhqhevXp67LHHihQGvNGGXQc0Y+l6SacKBdKpngQ5eSf14Q/z9dwdV1oZDwDKTOqO1dq7aIKyD++Uf6VYxV92paLrd5RhGFZHAwAAgDey+Uh2X6tTAAC8hMcXB0JDQ9WoUaNCy4KDgxUVFVVkubdatHa77DZDDqdZaLnTaWrp+p1yOJ2y27xm7moAXuLw2jnaPOlVybBJplMns05o08QNykm5WdU73WB1PAAAAHgjG4UBAED54YovJO6QBeBlnI4CbZ/x3qkHpvOPP08VSPfM/1Ins1KtCQYAAADv5uNndQIAgBfx+J4DxZkzZ47VEdxKh0ZJ+urnZUWW22yG2jaoSa8BAB4n+/AOFWSnF7vOdDqUtvN3VW7YuZxTAQAAwOsFRlidAADgRbjqC9WtHqu+7U4NsWT7oxeBzWYoOMBPdw7oZGU0ACgTxnnGcTXsXlk7BwAAAAAAXoSrH17G4XBq4dptWrFptwL8fJTSvI7q16iihwd1V4va1TV92TqlZ+WqaXJVXd2puaIrhVgdGQBKXVDlGgqIqKLc1IOu4YROs/kGKKJWC4uSAQAAAAAAlA+KA14kJy9fI977Tut27P9jqCBTE+au0uBurXTHgI5KaV5HKc3rWB0TqBBM09T837ZqxrL1ysjOVZPkqrqyY1NFh1NQqwgMw1DtAY9o3RdPyekoODXvgM0umU7V7v+Q7H4BVkcEAAAAAAAoUxQHvMjXs5Zrw84DkiSH0+laPn7WcrVpUFONkxKsigZUOG99O0tTFq6RzTDkNE1t3HVQUxet0ZsPDVbVyowT6m6cBSd1fMsyncw6oZC4ZIUm1FV49YZqcc97OrjyR2Uf2S3/8BjFteij4JhEq+MCAAAAAACUOYoDXmTGsvVynjF8hiTZbYZ+WbGR4gBQQht3HdSUhWskyfWZcpqmMnPyNPaHBRo5dICV8XCGjH2btG78M4UmIA6r3kgNrntaAZVilNhtiIXpAAAAAAAArMGExF4kJ+9ksctN8+zrABT169ptstuMIsudTlML122X01m0CAdrOPLztO6rkSrIySy0PH3Pem2f8Z5FqQAAAAAAAKxHccCLtKhTXbbiLmiappomV7UgEVBBmaakop+lU+skUxQH3MXxzUtUkJNxak6BvzKdOrJ2jgrysq0JBgAAAAAAYDGKA17kpp5t5Gu3FyoQ2GyGqsdGqlvLehYmAyqWNg1qFZq34zSbzdBl9RP/mPAb7uBkxjHJKL6QYzodpwoHAAAAAAAAXogrWF6kZpVovfnQYF1WP1G+PnaFBPprQPsm+vcDgxTg52t1PKDCaFizinq0qi/pz+vONpuhQD9f3TGgo4XJcKbg2Fp/9PQoyicgRH6hkeWcCAAA97V2X5rVEQAAAFCOmJDYyyQlVNZzd1xpdQygQjMMQ3+/oaea166m6UvXKT0rV81qV9M1XZorLjLc6nj4i/DEJgqpUluZB7cVGVqoavtBstkpjAIAcNqmgxlqlMC5DAAAgLegOAAAF8FmM9TzsgbqeVkDq6PgHAzDUMMbntXWn97WsY0LJdOU3T9IVdsPUkK7a6yOBwCAWzmRfdLqCAAAAChHFAcAAB7NNyhM9a95QvnZ6crPSVdAeIxsPn5WxwIAwO1k5hUo56RDgX52q6MAAACgHDDnAADAK/gGhSkoqiqFAQAAzuFIRp7VEQAAAFBOKA4AAAAAACRJhzJyrY4AAACAckJxAAAAAAAgSdqfmmN1BAAAAJQT5hwAAA9yNDVTkxes1trt+xUWHKhebRqoXcNaMgzD6miWcDrydXT9fJ3YtkKG3VfR9TsoIqmV174fAACcz4E0eg4AAAB4C4oDAOAhdh86rofeHK/s3JNymqZshqGFa7fp2i4tdPeVna2OV+4cJ3O19n9PKmPfRsmwyTAMHf5tpmIad1PtKx6RYdB5DgCAM9FzAAAAwHtQHAAAN2KapjbsOqhlG3bKx8euTk2SVT020rU+Jy9fM5at14qNu+Tna1dKszrq0DhZNpuh9ybPU3beqcKAJNef385ZqZ6tG6hmfLQlr8kq+5ZMUsb+TacemE798Xbo8JpZiqrXXlF121kXDgAAN7XvBMUBAAAAb0FxAAAuUmZOrhb8vk1ZOXlqVCtedavHXdL+HE6nXv58umav2iS7zZBpSh9PXahbe7fVLb3aKjMnVw+/9Y12HTwmQ5JhGJq7eou6tqir4YN7aNmGnTKL2a/NZmjBmq1eVxw4sna2XBWBvzJsOrJuHsUBAACKcTgjT7n5DgX42q2OAgAAgDJGcQAALsLCtdv04qc/KS+/QIZhyDRNtW1YU/+8rZ/8fC/uV+uPC9do9qpTd7o7nH9e1P502mI1SUrQsg27tOfQcUmSqVO9DCRp9spN6tg4udjCgCQZf2nrTZz5ecWvME05C06WbxgAACqQfak5SqocYnUMAAAAlDEGXAaAC3Q0LVPPffyj8vILJP154X3J+p36bPrii97v1MVri11usxmavnS9Zq/a5Boq6Mz1i9ZtV7Pa1WQrZqJdh9NU24a1LjpXRRWR3Foqdl4BU5VqNS/3PAAAVBR7jmdbHQEAAADlgOIAAFygWSs2Frqz/zTTNDVl4Zrz3qV/IiNb385ZqXcnzdW0JeuUezJfkpSWWfwYv06nqfSsXOUXOIrfoSkVOBy6+8pO8vP1kd12qkBg/FEo6N2moepUiy3py/MYVdtfK5+A4MIFAsOmwOhqim3Sw7pgAAC4ub3MOwAAAOAVGFYIAIrRqlUrHTx4UHFxcVq+fHmhdcczsmWzGXI4ihYBMnPy5HSastuL3sEvSSs379Y/P/xe+QUFstlscjic+uSnRXrt/mvVuFaC5v62Wc4zCg+GYahBYhVFhwdr2pJ1RQoTTtPUZfUTlZwQo3cfvUnfzlmh37ftU6WQQPVu01DdW9a/xHejYgqoFKtmQ/+t3QvG6/iWJbLZfVW5YYqqdbhOdr8Aq+MBAOC29qdSHAAAAPAGFAdQxJY9h7Xz4DHFRoaqca0E193HgDc5ePCg9u3bV+y62lVj5HA4iyw3JFWPjZTdXnynrLyTBXru4x+VX1Ag05RrH8czsvTqlzP0wDVdtWDNVsl0uoYPstkMhQUFqF+7xso9ma8Fv29TRk6uq4BgGIbqVotVSvM6kqSEypX00KDul/ryPUZARBXVGfCw1TEAAKhQ6DkAAADgHSgOwCUjO1ejxk3Rb1v3upZVj43U83dcqSrR4RYmA9xLpybJ+jQqXAdPpBe6y9+UdHOvNmfdbunGncrMKTpJrtNpau32/QoJ9Ne/7rtWH3w/X2t37JfNMNSmQU397coUhYcEKlyB+u//3aDxs1Zo8brt8vf1UfeW9TQwpYX8fPh1DgAASseBtByZpslNQgAAAB6Oq0ke5FzDoJTEa1/N1Jrthe+U3nfkhJ78YJLGPn4rXw6AP/j5+ui1+wfpzW9/0ZL1O2SaUnR4sIb266AuzeuedbusYgoDf5WZk6cGiVX07wevU+7JfNlsRpGL/jERYXrgmq564JqupfJaAAAAzpSb79SxrJOKDvG3OgoAAADKEMUBD3KuYVD+Kj0rR2u375e/n4+aJFWVr49dR9My9euabUXaOpym9hw+oTXb96lJUtWyiA1USNGVQvTcHVcqIztX2bknFV0pRHbbued4b1izylnXhQT6q2pMhOtxgJ9vqWX1VJdaEAUAAGe382gWxQEAAAAPR3HAi5imqS9mLtXnM5ao4I+xzsOCA/T4Tb0VGnTuyTkPHc+QksojJVCxhAYFFPv52bDrgKb8+rsOHEtXzfhoXdmxqarHRqpHy3r6ZcVGnTmV8W292zE00AUqaUEUAABcuM2HMtUqMdLqGAAAAChDXInyIr+s2KiPf1pUaFlGVq6eHvu93nr4etltNjmcRSdZlaTEuKjyiAh4hOlL1+lfX86U3WbI4TS1fud+TV20Ri/ceZX+74bLFR9dSZMX/Ka0rBzFR4frxssvU6/LGlodGwAAwGXNvlRJ1a2OAQAAgDJEccCLTJy7SoYhmX+5ZdmU5DRNzf9ti/q2baQpi34vtN5mM9S4VoJqV4sp97xARZSVm6f/fDtb0qlhuU7/aRimXhs/U589NVS39G6rm3u1kcPplI/dbmVcAACAYq0/kKG0nHyFBzLUIQAAgKc69wDZ8Cj7j6YWuvDvYkoHjqXpnqs7q3+7JoXGTW/XsJZGDulffiGBCm7l5j3Kyy8ostw0pcMnMrT9wBFJkmEYFAYAAIDbcjpNzd18xOoYAAAAKEP0HPAi1WIjtXn3ITmLqRBUi4mQn4+PHhzUTbf3ba/9R1MVXSlE0eEhFiQFKi7nWYbm+nN9cRU6AAAA9/P96n3q17iK7DbD6igAAAAoA/Qc8CLXdWtVpDBgGIZ8fezq27axa1lYcIDq1YijMACcx9Z9h/Xe5Hl67auZmrZknfJOFqh57WrysRf/qzUiNEhJ8ZXLOSUAAMDFOZSep583HLI6BgAAAMoIxQEv0qlJsu6/pqsC/f8cNzQmIlQv3XO1oitRCAAuxDezV+hv//pC381bpZnL1uu1r2bqb6/9T07T1LD+HSVJNuPUXXY2myHDMPTANV1lP0vhAAAAwB19vniXMvOKDpkIAACAio9hhbzMlR2bqtdlDbRlz2H5+fqodtUY2cqxm3B6Vo4Op2YoNiJMoUEB5fa8QGnac/i43v9+vqQ/Jx2WpH1HUzV2yq/6v+svV7WYCE2av1oHjqWpVpVoXdu1pRokVrEqMgAAwFmlpaVpzZo12r52t47vTFVofC35Bp66eSg1O1/jFuzQA91rW5wSAAAApY3igBcK8PNV46SEcn3OnLyTeuvb2Zq1YqOcpikfu0292zTU365KkZ8vfw1RscxZuVk2m1Fk/gCn09SsFRs1fHAPtWlQU20a1LQoIQAAQMmtWbNGnTp1cj1u/9A7ikxq4no8Y/0htU+OUssakVbEAwAAQBnhqixKzdxVmzV+1nLtOXxccZHhuqZLC/W6rIEMw9Doz6dpybodrjkPChxO/bhorfILHHr0hp4WJwcuTM7JfBkyJBWdXPhkgUNOpym7nYn7AACA53jj5y36zw3NVSnIz+ooAAAAKCUMfo0SK3A4NP+3Lfr4p0X64dfflZmT61r33bxVev7Tqdq677ByTxZo18Fjeu2rmfpk2mLtPXJCi9ZuLzIZsmmamrlsg46nZ5X3SwEuSdPkqnI4nUWW2wxDjWrGM68ACnEW5Ms0ixaSAACoSFKz8/XajM1Fek4CAACg4qLnAErkaFqm/v7Ot9p7JFV2m00Op1Pvfz9fz995hepUi9O4HxdKkk5f/zr9leGrn5epSmTYWffrNE3tOXxckWHBZfwKgNLTql4NNUlK0Nrt+11FL5thyDCkof06lFuOHQeOau32/QoJ9FfbhjUV6M+dfO7kyLp52j3vc+Uc2ye7X6DiWvRW9ZRbZPf1tzoaAAAXZfWeVP1vyS7d0i7R6igAAAAoBR5/e+uYMWPUpEkThYWFKSwsTO3atdNPP/1kdawK5/WvZmr/sTRJct0xnZdfoJEfTdGGnQeUczK/2O0cTqdSM3POue/o8NDSDQuUMbvNphfuukrX92ityLAg+fv6qHmdanr9gUHlMp9HgcOhFz6dqrte+VxvfTtLL372kwaP/EBLN+wo8+dGUabTUaRnwOHfZ2nTdy8r59h+SZLjZI72LZmkDd88Ty8CAECF9vXyvZqz6bDVMQAAAFAKPL7nQNWqVfXSSy8pOTlZkvTJJ5/oyiuv1KpVq9SwYUOL07kfh9OpHQeOym7YVCMuSjaboRMZ2Vq2cVeRtqZpKisnT5v3HjrnPmvFRyspPlo7Dh4r1A3ZZjPUuFaCEipXKu2XAVyyuLi4Qn+eKcDPV0P6tteQvu3LM5Yk6YuZSzV39eZCy3Lz8vXMR1P0+T+H0hOnnKTtWqudsz9Wxt4Nsvn4KaZxN9Xoept8AkO0c/Ynf7T6SyHANJW6faUy9m1UWNX6lmQGAKA0vPHzFoUG+KpljQirowAAAOASeHxxYMCAAYUev/DCCxozZowWL1581uJAXl6e8vLyXI8zMzPLNKO7WLhmm976dpaO/TEHQGxkmIZf10PRlULOuV2Qv6/io8J18Hh6oXkFDEMKCwpUs9rV9MywAXry/cnafei4a31SfGU9cUufsnkxwCVavny5pc/vdJpasn6HFq7dJqdpqm3DWmrfqJbsNpu+X/C7zrz53NSpib5/Xr5B13VrZUnmiig/O02pO36TYbOrUq3m8vEPKrQ+N/WwUrevlGH3UWTt1vINCpckpe1epzX/G+EaS81ZcFIHV89Q+p71qn/d0zqZcbT4JzRsSt+znuIAAKBCczhNvTh1g57qV1/Nq1MgAAAAqKg8vjjwVw6HQ998842ysrLUrl27s7YbPXq0Ro0aVY7JrLdx10E9M25KoeEuDp9I15MfTNLbw29QaKC/MnLyit22QWK8at8Sq8fGTFTeyQLJkGRKdrtNj9/cW74+dsVFhuuDf9yi37ft1YFjaaoWE6GGNeNlGEY5vULA/eSdLNDqLXt00uFQ06QEhQUHSjrVg+f5T6Zqwe9bZbed+ozMWLpererV0Mgh/ZWWVfxQXTaboaNp3lHMLA17F03QrtmfynQWSJJsPv5K6vM3xTa9XKZpauescdq3aIKrvWHzUVLvvymuRW/tnve/UxWZv1ZpTKeyj+5W6s7Vp6qjxQ0fZDrlE3DugisAABXByQKnnp2yXn/vVVftk6KtjgMAAICL4BXFgTVr1qhdu3bKzc1VSEiIvvvuOzVo0OCs7UeMGKHhw4e7Hq9evVopKSnlEdUy385ZKZshOQqPgCHTNPXjwjW6uVdbjZk0t9A2NsPQZQ0SlVw1RpL08RO3a9qSddpz+ITiIsPUp21DxUT8ORmxzWaoWe1qala7Wrm8JsAdHEvLUu7JfMVFhclu+3Oal1/XbNWrX85U1h9FNx+7Tbf2bqsbelymWSs2asHvWyWdujPvtOUbd2nG0vWqFhOhvYdP6MxLzw6HU7XiK5f5a/IExzYv0c5fPiq0zFmQpy0/vKGgyjWUc2xvocKAJJnOAm2d+h8FxyUpfc86yXQW2a9hsyvrwFZF1mmr45uXFGlj8/FTdL3yH4oKAICyUOAw9dJPGzWsY01d2azs510CAABA6fKK4kDdunW1evVqpaamasKECbrttts0d+7csxYI/P395e/v73ocElIx7vI83xjp57J9/5FCFyFPczhNbd9/VA9c01V+vnb9b8YSHU3LUoCfr/q1a6QhfTu42kaGBevGyy+7+BcAVEDZuSeVezJflUKCZLP92RNm7+ETen38TK3ZfmpC2qiwYN11RSd1a1lPuw8d13Mf/1joM1fgcOqjHxcqPqqSZq3cJMMwikxca0j6ZcVG3dyzjUZ/Pq3QOpvNUFRYsLo0r1N2L9bNXMrvvP3LvpcMW9EL/IZdB1ZMVc7RPcXe/W/Y7Dq0aprsfkEqyEkvsl9Tkk9giKqn3KQ1R3Yr5/g+GTa7TNMpw2ZX3YGPySeQSdgBAJ7DNKUP5+/Q3hM5uqtzLfnabeffCAAAAG7BK4oDfn5+rgmJW7VqpWXLlunNN9/Ue++9Z3Gy0nUpY6RXiQrXvqOphSYMliS7zVBcZJgMw1D/9k3Ur11jZeXmKdDPT/ZSPvHfe+SEFvy+VQ6HU63rJ6pOtVjXuqNpmfp02mLNW71ZTtNU+0ZJuq13O1WJDi/VDEBJHU/P0tsTZuvXNafmBIiNDNOwfh3UtUVdZeXk6ZH/fK307FxX+2PpWRr9+TQFBfhp1eY9xe7TZhiaOG+VbMUUBqRTF55z8vLVrWU95Z7M10dTFyot89QQQ02Sqmr44B4K8PMtk9frji7ld15e6qFi7/yX6VBe6iHlpR8pdlgg0+lQXsZRxTa7XPsWf1d0H06HKjfqKr+QSDW/+x0d27hImQe2yDckQjGNusgvJLLIPgtys3R47WzlHNkt/0qximncTX4hjN8MAKhYpq09qL0nsvVY73qqFORndRwAAACUgFcUB85kmmahCYe9SXpWjiYv+E3LNu5UoJ+vuraop8tb1deVnZpq6YadRdo7nKau6NjE9dgwDIUEBpR6rs9nLNEnPy2SzTAkQ/r4p0W6vHV9/d/1lysrJ08PvPGVjqdnuYoXs1dt0tINO/XuozcpJoK7cFG+ThYU6P/e+Vb7j6a6JuE+dDxdL372k3x87DqWmqm0zJwiw/4YhvS/GUsVFR5cbE8dp2lq/9FUXdWpmdbtPFCkQGAzDF1WP1GS1LddY/W8rIH2H01TcIC/osKDy+KleqygmETlph2SnGf2HLApKCZRdv8gHc88UUzPApuCY2upWofrlL5nvTL2bvijZ4ApmU7VvPwOBcckSpJsdl9VbthZlRt2PmuOrMM7teazESrIyZBhs8k0ndo9939qcP0zqpTY5KzbAQDgjtbuS9fD41frib71VSeWc3QAAAB35/HFgSeeeEJ9+vRRtWrVlJGRoa+++kpz5szRtGnTzr+xhzmenqUH3vhKR1Mz5TRNGYa0cvMeLVyzTSOH9tfdV3bW2CkLVOA4dTHMz8eu+67pqgaJ8WWaa/WWPfrkp0WSTl0cPX1FdeayDWqYGK/UrBwdS8sqdKHU6TSVlZunCXNW6m9Xe/Z8ELBGq1atdPDgQcXFxRW5Q/3X37dp7+ETRbYxDOnTnxapXo042WxGkQKAaUrb9h9Rs9pVZbMZRXrq2AxDiVWiNaBDE01dvFZH0zJdbWw2Q+HBgRqY0tzV3sduV/XYonei408Fedk6tHq6TmxdLsPuq+j6HRXTuKuqth2o45sWF25sGDJsdsW36q/87DQd37JErhnWJcmwyebrpyot+8nuF6gmt76s41uXK23XGtn9AlW5UYqCoqqWOJtpmto8+V8qyM2UZMp0OiRJTsdJbZw4Wpc99Klsdu/pCQIA8AzHMk/qsQm/685OtdSnUZwMwzj/RgAAALCExxcHDh06pFtuuUUHDhxQeHi4mjRpomnTpunyyy+3Olq5+9/MpacuNv5xkf30tfZF67Zr8brturZLC/VsXV8rN++WzbCpZd3qCg70P8ceCzNNU+t3HtDxjGwlx1cuNOSP02lqxrL1+nHRGqVmZKtBYhUN7t5KteIra/rS9cVeKDUkTV28VgF+PsUOseJ0mlq+adeFvxFACRw8eFD79u0rdt2mPYdkt9vkcBS+q9w0pZ0Hj6ldo1pFeg2cFhkapH7tG2vivFXKNx2FRq5xmqau69pSYcGB+s/D1+vzGUs0b/UWmTLVqUmybry8jSLD6CFQUgU5Gfrtk78r5+heSaZkGDqxdZmObligBtf9U/WuGaFt08coP/NUocc/PEa1+z+kwKgEBUYlqP6gf2r79PeUl3ZIkhQcW1O1+z0g/7BoSafmH4iq00ZRddpcVL6cY3uUdWhH0RWmqYLsdKXu+E2Rya0uat8AAFipwGFqzJxtWrc/Tfd1TVaQn8d/7QQAAKiQPP4sbezYsVZHcBvzf9tS5AK8dOqO5F/XbFOHxskKCw5Ul+Z1L3jfuw8d18iPfih0N3XXFnX16PWXy8/XR29++4umLlrrmt/zSGqG5v22Ra/ee43SMrOLzWVKSs3MVq34aNkMw1XUOM2QFOTPXbUof5VCAmUW83dWkoID/NS7TUN9Pav48fCv7NRMcZHhGn331Xrlixk6dPzUpLYhgf66+8rOav3HsEGRYcF68NpuevDabmXyGrzB3sUTlXNsn1x3/v/xO+R0gaBywxRF1W2rrMM7ZdjsCqpcXYbx51wqUXXaKLJ2a+WeOCDD5quASjEXneVkVqqOb14ipyNfEbVaKDAyXo687HNu48jLuujnAwDAHczbfFSbDmbo0V51VS8uzOo4AAAAOIPHFwe8ybmGQZFU7N330qmL7Ge9zbkEChwOPfbuRB1PL3wha86qzQoPDlSftg01ddHaPzKcWudwnhrWaMykeWrbsKZWbNpd5OK/3Waoca0EtW1YU4vXFb271pTUo3WDiw8OXKTuLevp46mLikxYazMM9W3XWPHRlTTilj565YsZOplf4Frfs3UD17BATZKq6tMnh2jbviPKdxQouWqM/Hz4lXwhzvc77+j6+cVPOmwYOrZxoSo3TJFhsyskLumsz2EYNgVGJlxSzgMrpmr79Hf/GDbo1DBFVVpfoRpdb5XdL1COkznFPbPCqvL7DQBQ8R1Kz9Nj3/6ua1pW1fWtq8vPx3b+jQAAAFAuuBLlQc41DIokdWySrKmL1xa5S9/hNNWu8dkvjrnaOZxasn6Hth84qsqVQtS5aW0F+vtp8bodOpqaWaS9aZqaumiNwkMCi73z3zRNbd5zSI/d1EuT5q9WZk7en+OrG4ZsNpuu69ZSiXHRWtJqh35evlF2myHJkMPp1GUNEtWvXaMSvDNA6apcKVRP3tpHoz+fpvwCh+vvd/Pa1XRb73aSpJRmddSqbg0tXLtdOXkn1bR2NdU4Y34Am81Q7WoXfzd6cQocDq+ZpPh8v/NOj+FfdMU51pWyjP2bte2ndwo/uaQDy75XSGwtVe98k3b8/GGR7aq06if/8MrlkhEAgLLmNKVvlu/Vku3HdX+3ZNWvQi8CAAAAd0BxwIvcdHkbLVq7XScysk9NSKxTl6la1auh9o1qnXPbo6mZ+vt/v9XeI6my/zHR6ruT5unFu6/SgWNpxV78l6STBQ6dzC84Z8eEqPBgvfngYI2ZNFfLNuyUKalujVjdc2Vn1Yo/dXHsHzf20uWtGmjBmq1yOk21bVhTl9WvKZuNCc5gjU5Na6tpclXN+22LMrPz1KhWvBrWjC806V5woL8ub12/3DL9uHCNxv20UGmZp+5Eb1a7moYP7qEqUeHn2dIzRdVtp/3Lfiim94CpiNqXlUuGQ6umy7DZiylGGDqw4kc1Hfpv+QSGau/Cr5VzbJ/8QqMV3+ZKJbS5qlzyAQBQnnYfz9Y/vv1dPRvE6rYOiQoLYIhQAAAAK1Ec8CLRlUI05tEb9d281Vq6YacC/XzVrWVd9W7TSHabTZt2H9JXPy/V+l0HVCkkSP3aNVa/9o1lt9n06pcztP9YmqRTPQ0kKTv3pJ7+8Hs9fF33YgsDkhTg56vuLevpy5+XFVlnsxlqmlRVwQH+Cg7w1wt3XaXck/lyOk0FBfgVamsYhlrUra4WdauX8rsCXLyw4ED1b9/E6hiSpFkrNuqNb34ptOz3bXv1f29/o49G3KYAP+/78l21/bU6uuFXncw8/meBwDAUGl9HMY26lkuGvIxjZ+mlYOpkxjEZhqHYpj0U27SHTNMsVFwCAMBTzVh/SIu2H9Ot7WqoZ4M4bvgBAACwCMUBLxMRGqyh/TpoaL8OhZav3rJHj7/7nUyZcjpNHU/P1n8mzNbG3Qc1pG97rdy8u8i+nKap1MwcGTKUEF1JB4+nuQoH0qmRta/q3Ew14qI0pG97jZu6UDabIafTlM0wFOTvp/sGdim0T2+8gAmUhs9nLHH1BjrN6TR1JDVTc1ZtVu82Da2KZhm/kEg1G/aG9i+dpGObl8hm91Xlhimq0rq/bD6l/7vmZOZxpe1aK5uvnyrVbCa7b4BCqiTrxLYVRXsvGDaFxNcuvIjCAADAi2TkFuid2ds0dc1B3dW5lholeGdPRwAAACtRHIAk6d3J8+Q0nWfOr6qZyzaodb3Ec26bnp2rV+4dqOc/maoNuw5Kkuw2m/q3b6zb/xh//cbLL1PDmlU0bcl6ncjIUv0aVdS/fROPHxMdKAtH0zKVkZ2rhMqV5OfjI4fTqT2HTxTb1m63afv+I+Wc0H34hUQosdsQJXYbct62jvw8ZezbKMNmV2hCPdnsf/4TmXN8n3bP+0LHty5zFRmqdbxevkFhMk1Tu+d+rj2/fu0qAtj9glTnyuGKa9FH+5dOluNk7l8KBKeKAFXbDyr11wsAQEWz42iWRkxco461ozWkfaJiwgKsjgQAAOA1KA5A6Vm52rav+IuHNsPQviMnFODnq9yT+cW2qVs9VjERYXrr4eu1+9BxncjIUo24KFUKCSrUrmlyNTVNrlbq+QFvcfhEul79cqZWb9kjSQoO8Netvdvoqk7NFBYcoPSs3CLbOJ2mosNDyjtqhXPot5naPuN9OfKyJUm+QeFK7v+gouq0Ve6JA1o99hE5TuZIplMOSfuX/aAT21ao2bA3dHTDr9qz4KtC+3OczNaGCS+q5T3vqvGtL2vrj28rc/8mSVJARJxq9bpbYVXLbz4KAADc3YItR7Vk+zENalVNA1skyN/HbnUkAAAAj0dxALLbzz6UhSkp0N9P1/dorY+nLiy0zmYYatuwpmpWiXYtqx4bqeqxkWUVFfBopmlq0drtmrLodx1NzVS96nG6pksL1YiL0smCAv3f29/qcGqGq31Wbp7GTJonf19fXdmxqT6fsaRQ7x9Dko/dph6tuAh9Lqk7f9OWH94otCw/O10bvn1Bze/4j/Yv/d5VGHAxnco5tleHfvtZh1bPkIoM6nTq4cFV01Wz+1A1G/r6qfkHHAXyD49hCCEAAIqR7zD1xZLd+mXDId2dkqTWiXyvAAAAKEsUB6DgAH+1qltDK7fsltN55sTCpjo2SVZMRKj8fX301S/LlJaZI39fH/Vt10jD+nW0JDPgrhwOp5Zt3KmDx9NVPSZSzWpXKzTJ3sn8Ai1au12HTqSrRlyUWtWrIbvNJkn6dNpifT5jiWyGIadpaveh4/p5xUa98reBOpKaqYPH04t9zv/NXKKPn7hdew6f0JxVm13LA/x99dRtfRUZxvBd57J/ySTJsJ0xL4ApyaYDy3/UiW3Li84ZIEkylLrzN+WlHVaRwsAf+zi17hT/0KhSzQ0AgKc6lJ6nZ39Yr461o3VXp1qKCPazOhIAAIBHojgASdJ9A7vo4be+Vnp2rkzTlN1myOE0ddcVnRUbGSZJurZLC13duZnSs3IVHOgnPx/++gB/tffwCT3+3nc6dDzddR95YlyURt9ztaLDQ7Rt3xE9/u5EpWbmuAoA1WMj9fI9A1XgdOjzGUsknZrsW5IcTlNO06n/TJity+onym6zyeEsepH6SGqmHE6nnry1r266vI3WbN+nkEB/tW1YS4H+TPKdm3pYqTtWybD7KDK5tXyDwgqtzz66p/iL/06Hso/tkd0vsPgdG4bsPv4KqlxD6Xs3FLMPQ0HR1UvnRQAA4IUWbDmq1btTdX+3ZHVIjj7/BgAAALggXN2FJKlqTIQ+fPwW/bR4rTbuOqhKIUHq1aaBGiTGF2pnt9kUERp0lr0A3ss0Tf1z7Pc68sewP6fvI999+Lhe+nyaXv7bQD099nvXvACnCwB7j5zQy19MV8cmycUNTCPTNLV9/1GlNKsjZzGFAUkK8veTn++pX+eJVaKUWIU71KVT793OWeO0b9FEnX5nDbuPknrfq7jmvVztAqOqKjf1UNGL+za7giIT5F+zmXbN/VxFZmw3narcKEWStH78qMLrDJtsvn6K/cvzAACAC5eZV6CXftqobvVi9LcuSQrwZS4CAACA0kJxwAvtOnRc439eplVb9igk0F+92zTUlZ2aqlJIkG7ocZnV8YAKad2OA9p7+ESR5U6nqd+27tXPyzfq8ImMYtev3rJHTZOrnnP/7Rsn6cuflykvv0DmXy5SG4ahAR2auIYmwp+OrJ2tfYsmFFpmOgq09ce3FBKXpJAqyZKkhMuu1Imty4ruwDQV16qfAiPjdXzbCmXsWS8ZNhmGIdPpUGyzXopIbi3DMJTc/yHt/HmsCnIzJUmBkVVU54rhDCUEAEApmbXxsHYczdKT/eorNizA6jgAAAAegeKAl9m677AefutrFRQ45HCaOpqWqfcmz9OqLXv07LArCo2NDqDkjqVnnnP9/qOp51xfq0p0sXPa2gxDteKjlRgXpefvvELPfDRFmTl5rvUdmyTp1j5tLzK1ZzuwfIpkGEXv+LfZdXDVNCVXuV+SVKlWcyX3vV/bZ34oZ/6pnh0+ASFK7vegQmJrSZIa3zxaxzYu1IltK2Sz+yi6fkeF12zmmlg4rllPxTTqqqzDO2Tz8VNQ5RpMOgwAQCnbcTRLj37zm0YOaKDkmFCr4wAAAFR4FAe8zNgpvyo/3+Ea0kQ6dS1yyfodWrVlt1rWrWFdOKACS0qofNZ1dptNl9VL1Bczlxa73s/Hrqa1q+q2Pu318dSFstkMOZ2n5v7wsdv1wLXdJElNk6tp/Kg7tWTDTmVk5ah+YhXVrML4u2eTl360aGFAkpyOU+v+Iq5FH1Vu1FXpe9bJsNkVVq2hbD5/ztdgs/uocsPOqtyw81mfz+bjq9D4OqWWHwAAFJWana8RE9foyX4N1KxaJavjAAAAVGgUB7yIaZpauXl3ocLAaXabTcs27qI4AFykqpUj1KFJkhat2V7oM2ZI6teusRrWileHxklatHZ7kc/gwC4tFBzgr5suv0x1qsZo6qI1OpKWqXrV43RV52aqWjnC1dbP10edmiSX18uq0IJjk3Qy80TRuQQMm6tHwF/Z/QIUkdSynNIBAICLlZvv1LM/rNNjveupTS2G8AMAALhYFAe8jN1mk9PpKGaNKV/7pY9Z7nA4tXbHPuXmFahBzSoKDWI8UFRMcXFxhf4sicdv6q13J83V9KXrVeBwyt/XR1d0bKqh/dpLkkbc3Efv/zBfPy1eq/wCh4ID/HRt15a68S9zfbSun6jW9RNL9bV4q6rtr9WJbWfMJfDHRMFxLftaEwoAAJSKfIepF3/aqEd61FaXujFWxwEAAKiQKA54EcMw1Llpbc1etUlOZ+E7lx1OU52a1r6k/a/askejP/tJJzKyJUm+Pnbd3LONbujRmrG3UeEsX778grcJ8PPVw9f10J1XdNKJ9GxFhYco0P/PoWn8/Xz0wDVddeeAjkrPylFEaLB8feylGRt/EV69oepf+6S2z3hfeWmHJUnBMYlK7veg/MNODcdkmk7lHNsrGTYFRiYU+l3ldOTryLp5OrF1uQybTdH1OyqyThsZBpM/AwDgDpxOU6/P3KyM3AINaBpvdRwAAIAKh+KAl7mjf0f9vm2vjqZlyjTlGtv8uq4tVada7Dm3zcnL1xczl2j6kvXKys1To1oJurV3WzWsGa/DJ9L11PuTlO/4s1dCfoFD46YuVExEqHq0ql/WLw0od3knC7R0405lZueqYc14VY+NlCQFB/grOMD/rNsF+PkqwM/3rOtReqLqtlNknTbKPX5Aht1HAZX+/D13fOtybfvpHVfhICAyXsl9H1ClxCZy5Odq7edPKmPfRumPYsCRtXMUVb+D6l39mAwbRR0AANyBaUrvz9uug2m5Gtaxpmw2bkoCAAAoKYoDXia6Uoje/8fN+mnxOv2+ba9CAgPUo1U9tahT/ZzbOZxOPfHed1q/84BrvPTVW/bot6179Oq912rl5t0qcDiLzP1pGNK3c1ZSHIDHWblpt5795Edl5eS5lnVvWU+P3nC5fOxcOC4PJR36yTBsCoxKKLQs88BWrf96lPSXXlS5xw9o3ZdPq/md/9GxTYuUsX/TqRV/mbPg2IZfdbTer+ecmBgAAJS/73/br70nsvVor7oKDeAmDAAAgJKgOOBBSnqhLCQwQIO6ttSgriWfeHPZhp1au2N/oWVO05RNhj768VfFRoYVu51pSvuPppb4eYCK4ERGtv459nvlFxQUWj5r5UbFR4fr1t7tLErmXS5m6KfT9i35TjKlP/7zB1Om06EDy35Q2u61KlLtlCTD0NH18ygOAADghlbuTtUj43/TE33rqVblEKvjAAAAuD0GTvYgy5cv1969ey/pgtnZrN66V3Zb0b8uTtPU2h37VSUqvNjtDEOqWjmi1PMAVpq1YqPyCwqKXDs2TWnygt9kFndRGW4l8+C2Qj0CXEynMg9tl7PgZPEbmqacBfllGw4AAFy0Q+m5+vu3v2v2xsNWRwEAAHB7FAdQyO5Dx/WvL2fo1ufH6YE3vtLURWvkcDoV6OcrU8Vf8PTz9VHfto3k62MvMvGwaUrXdSt5DwWgIjiSmiFbMcUySUrPyi0y4TfcT0B4jGsugUIMm/zDYxRZ+7Li18tQRBK/0wAAnuXMGxsq+o0OJwucen3mZo1dsIPzMgAAgHOgOOClTNMsctK/ec8h3fvaF/p5+QYdOJamTbsO6t9f/6J/fTlDXZrXKfbE2mYz1L1lPVWOCNVL91ytypX+7L7r7+uju6/srC7N65b56wHKU834aDkcxdx1Lik+Olx2O79a3YXpdOjo+vna8sMb2jr1HaXuWC3TNFWlVf+z9hyo0qKvEtoOlG9QWOECwR9zF8Q2u7z8XgAAuLmNGzfqhhtuUJUqVeTn56eVK1dKkkaNGqXZs2dbnA7nk5qaqjfffFPXX399oeUrP3lG2+d8o/zsDIuSlY5Jq/bphakbdLKg+PM2AAAAb8ecA15m0+5DGjf1V63aske+PnZ1a15XQ/p1UERokN7/fr7yCxyuCYdPlwJ+Xr5RV3Rsqruu6KT3v58vu+1U7wCH01TVyhEa1q+DJKlRrQR99tRQbdx9UHn5BapbLVZBAX5WvEygTKU0q6OPf1qk4+lZRYpmN13exqJUOJMjP0/rvnxa6bvXSjabDBk6uHKqYpv1UnK/B5TY7XbtnPOp5Dx1wcCw+ahmzzsVXqORJKnZ0De0d+E3OrZpkQybXZUbpahqu2tl9wu08mUBgNtYvXq1OnXqpNDQUHXp0kVff/21a11mZqbeffddde3a1cKEOJfp06frmmuuUXZ2dpGbhvLSjmr9xP9o05QP1HLYc4qpX3HPb5buOK4XflyvJ/s1kJ8PN3AAAAD8lWFW9D6j5WDlypVq2bKlVqxYoRYtWlgd56Jt3XdYD74xXg6H01UAsNkMVYkM15sPDda1/3yv2O3sNkPXd2+t2/u217Z9R/TLio3KyM5Vk6QEpTSrIz9fakzwPgeOpunVL2dozfZ9kqSQQH/d1qedrurUzNpgcNnz69faNefTYicWbjB4pCJrX6aTmSd0YvtKGYahiKRWp3oLAABKpHfv3srIyNDMmTPl5+cnPz8/LV++XC1atNA333yjxx57TNu3b7c65lmlp6crPDxcaWlpCgvzrt//06dPV79+/WSappzOc9xVbxgyZKj1Pa9U6AKBJPVuFKf7uiZbHQMAAMCtcFXXi/xvxlI5nH8WBiTJ6TS172iqZq/aJMMo9hqaTMk1TEpSQmUlJVQup8SA+6oSHa7XHxikwycylJWTp4SYSvLz4VeqOzn8+6zif6kZNh1ZO1eRtS+TX0iEYpt0L/9wAOABfv31V33++ecKCgqSw+EotC42NlYHDx60KBnOJTU1Vddcc835CwOSZJoyDWnF2H+qx7MT5BsUWj4hy8C0tQfVITlazapVsjoKAACA26BfpRf5beue4ucNMAyt33lAbRrUlM1mFFnvdJrq2IS7bIDixESEqmZ8NIUBN+TIzyl+hemUIz+3fMMAgAcyTVN+fsUPIXnixAn5+/uXcyKUxCeffKLs7OzzFwZOM005TuZq77LpZRusHExevc/qCAAAAG6F4oAXCfIv/subYUjBAX6658oUhQYGyGacKhCcLhRc372ValaJLrecAFAaImq1LDyhsIuhSolNyz0PAHiaJk2a6Lvvvit23bRp09SyZctyToTzMU1T//nPfy5q2x1zvy0yN0FFs/VwptURAAAA3Aq3unqRXm0a6rPpS4qc1Ducpnq0qq+EypX0wWM364dff9fa7fsVHhKonq0bqFW9GhYlBoCLV7X9IB3dsECOkzmS+cfdkYZNARFximnaw9pwAOABHnroId14440KDg7WLbfcIknavXu3Zs2apY8++kjffvutxQlxpmPHjmnbtm0XsaWp7KP7lJ+dLr/g8FLPVV7yCkrYWwIAAMBLUBzwItd1baXft+7V6q17ZbfZJJlyOE3d3LONGtaMlyRFhAbr1t7trA0KAKUgMLKKmg39t3bP/0LHtyyVYfNR5UYpqt7pBvn4B1kdDwAqvMGDB2vbtm165pln9NZbb0mSrrnmGvn4+GjUqFEaMGCAxQlxpszMS7tzviA3u0IXBxKj+PcfAADgrygOeBF/Px+99LeBWrZhp1Zu3i1/Xx+lNK+j5IQYq6MBFY7D4dTUxWs0bcl6ZWTnqllyVV3XrZWqxkRYHQ1/ERiVoLpX/d3qGADgsZ544gndeuutmj59ug4dOqTo6Gj16tVLNWrQ89QdhYSEXNL2PgEV++J6+ySGSgUAAPgrigNexm6zqW3DWmrbsJbVUYAKyzRNvfj5T5q3eosMSaakwyfSNXvVZr3x4HVKSqhsdUQAAMpN1apVNWzYMKtjoASioqKUlJSk7du3X+D8AYaCouPlGxRWZtnKmr+PTV3rclMUAADAXzEhMQBcoN+37dO81VsknSoMSKfm7jiZX6APpyywLhgAAOVoypQpevvtt4td984772jq1KnlnAjnYxiGHnjggYvatmbKtTIMo5QTlZ/ejeIUHuRrdQwAAAC3QnEAAC7Q0g07ZLcV/XLsNE2t2LRLDieT3QEAPN8LL7xw1jHss7Ky9OKLL5ZzIpTEbbfdpqCgINlsJfwqaBiy+wWoauteZRusDAX62jWoZTWrYwAAALgdigMAcIF87PazrrMZhgxV3LvqAAAoqY0bN6pFixbFrmvevLnWr19fzolQEpUqVdKECRNkGMb5CwR/nNe0Gva8fINCyydgGbimZQK9BgAAAIpBcQAALlDHxslyOIuO02uzGerQOFm2YnoVAADgafLy8nTy5MmzrsvJySnnRCipXr166ccff1RgYOA5hgoyZPcN0GX3vKrK9S8r13ylKTrET1c1T7A6BgAAgFuiOAAAF6h2tRhd2+XUnZKnCwGGYSg8OFB3XtHRymgAAJSbunXrasqUKcWumzJliurUqVNmz/3CCy+offv2CgoKUqVKlcrseTxZr169tHfvXr3xxhuKj48vtM4/PFoNr3lQPZ6bWKELA5J0Z6da8vc5e69PAAAAb+ZjdQAAqIjuuqKTmtWuppnLNigjO1eNkxLUv31jVQoJsjoaAADlYujQoXrkkUcUGxure++9V7GxsTp06JDGjBmjDz/8UK+//nqZPffJkyc1aNAgtWvXTmPHji2z5/F0lSpV0oMPPqjmzZurc+fOruUtbntGUclNLUxWOlolRqhdUpTVMQAAANyWxxcHRo8erYkTJ2rjxo0KDAxU+/bt9fLLL6tu3bpWRwNQgRmGoTYNaqpNg5pWRwEAwBL333+/li1bpueee07PP/+87Ha7HA6HTNPULbfcogcffLDMnnvUqFGSpI8//rjMnsObnDm00NmHGqo4gv3tuq9rske8FgAAgLLi8cWBuXPn6r777lPr1q1VUFCgJ598Uj179tT69esVHBxsdTwAAACgQjIMQ59++qnuvPNOTZs2TUeOHFHlypXVp08fdezofsPs5eXlKS8vz/U4PT3dwjQoaw/3qKPoEH+rYwAAALg1jy8OTJs2rdDjcePGKSYmRitWrCjUdRYAAADAhevUqZM6depkdYzzGj16tKvHATzbda2rqW0thhMCAAA4H6+bkDgtLU2SFBkZedY2eXl5Sk9Pd/1kZmaWVzwAAACgwjly5Ih2795d5OdCPPPMMzIM45w/y5cvv+iMI0aMUFpamutnz549F70vuK9u9WJ0c5vqVscAAACoEDy+58Bfmaap4cOHq2PHjmrUqNFZ23FXEQAAAHBuGRkZeuSRR/Tll18qNze32DYOh6PE+7v//vt1/fXXn7NNYmLihUQsxN/fX/7+DDPjyXo3itPfUpKYZwAAAKCEvKo4cP/99+v333/XggULztluxIgRGj58uOvx6tWrlZKSUtbxAAAAgArj4Ycf1hdffKFhw4apSZMml3zhPTo6WtHR0aWUDt7EZki3tU/U1c0TKAwAAABcAK8pDjzwwAP6/vvvNW/ePFWtWvWcbc+8qygkJKSs4wEAAAAVyo8//qiXXnpJDz30ULk/9+7du3X8+HHt3r1bDodDq1evliQlJydz7u5lYsP8NfzyumoQH2Z1FAAAgArH44sDpmnqgQce0Hfffac5c+aoZs2aVkdyGwcOHNCBAwesjoHzqFKliqpUqWJ1DJwDn6WKgc8SAJSu3NxcNW7c2JLnfvrpp/XJJ5+4Hjdv3lySNHv2bHXp0sWSTChfNkO6qnmCbrisugJ87VbHAQAAqJA8vjhw33336YsvvtDkyZMVGhqqgwcPSpLCw8MVGBhYon1UqVJFI0eO9KiLSnl5ebrhhhs0d+5cq6PgPFJSUjR9+nTGyHVTfJYqDj5LAFC6+vbtq/nz56tbt27l/twff/yxPv7443J/XriHptXCdUfHWkqMDrY6CgAAQIVmmKZpWh2iLJ1tzMlx48bp9ttvL98wbiQ9PV3h4eGaO3cuXa/dWGZmplJSUpSWlqawMLpKuyM+SxUDnyUAKH3r16/XtddeqzvuuEMDBgxQVFRUkTaRkZEWJCuZ0/+G82+DtGDBAnXq1Mn1uP1D7ygyqYmFiYoXXylAwzrWUuvECOYWAAAAKAUe33PAw2sfl6xZs2Ze/2XInaWnp1sdASXEZ8m98VkCgNLXqFEjSdLf//53/f3vfy+2jcPhKM9I8FBhgT668bIa6tUwVj52m9VxAAAAPIbHFwcAAAAAlL6nn36au7dRpmyGNKBpvG64rLqC/fnqCgAAUNo4wwIAAABwwZ555hmrI8CDNYwP071dklU9KsjqKAAAAB6L4oCX8vf318iRI5mY081xnNwfx6hi4DgBQNnKycnR8ePHFRsbKx8fvmLg4vn52HRb+0T1b1xFNhs9UwAAAMqSx09IDAAAAKBszJ49W0888YSWLVsmSVq6dKlatGih++67T927d9fAgQMtTnh2TEj8J3eZkLhaZKBG9KmvapH0FgAAACgPzOYEAAAA4ILNmjVLPXv2VG5urh599FE5nU7XuujoaH388cfWhUOF06l2tF4b1IzCAAAAQDmiOAAAAADggj399NPq27evVq1apeeff77QuqZNm2r16tXWBEOFc2Ob6vp7r7oK9LNbHQUAAMCrMCAoAAAAgAu2atUqffPNN5Ikwyg8NnzlypV1+PBhK2KhAvGxG3qoe211qRtjdRQAAACvRHEAAAAAwAXz8fFRfn5+sesOHz6s0NDQck6EiqRSkK9G9KmvBvHePd8DAACAlRhWqBR9++23MgxD48ePL7KuadOmMgxD06dPL7IuKSlJLVq0OOe+b7/9dhmG4frx9/dX3bp1NXLkSOXm5rraPfPMM0Xu3LLCnDlzZBiGvv32W6ujnNXHH3/sej/nzJlTZL1pmkpOTpZhGOrSpct599elS5dCxygwMFBNmzbVG2+8UWgM3ttvv12JiYml90Iu0unXv3z5cqujlIry/PwFBwcrMTFRV1xxhcaNG6e8vLxSex3eoiw/fzabTaGhoUpOTtagQYP07bffFvoMAgBKR+vWrfXZZ58Vu+7bb79Vu3btyjkRKoo6saH69+BmFAYAAAAsRnGgFJ2+ODV79uxCy48fP641a9YoODi4yLq9e/dq+/bt6tq163n3HxgYqEWLFmnRokWaNGmS2rRpo2effVa33XZbqb4ObxMaGqqxY8cWWT537lxt27btgu56q1WrlusYjR8/XgkJCXrkkUc0YsSI0oyMYpTn52/KlCl69tlnFRwcrDvvvFMtW7bU3r17S/X1eIuy+PwtXLhQkyZN0uOPP66cnBwNGjRIXbp0UVpaWmlGBwCv9/jjj+u7777T1Vdfre+//16GYWjJkiW6//779e233+of//iH1RHhhga2SNDogY0VHeJvdRQAAACvx7BCpSg6OlqNGjUqchfs3Llz5ePjo2HDhhW5OHn6cUkuTtpsNrVt29b1uE+fPtq5c6e+/vprvf7660pISLj0F+GFBg8erP/973965513FBb2591LY8eOVbt27ZSenl7ifQUGBhY5RvXq1dPbb7+t559/Xr6+vqWaHX8q78+fJN16660aMmSI+vfvr2uvvVaLFy8+5z5ycnIUGBhYglfjPcry8ydJd9xxh8aNG6ehQ4fqrrvuKrZnyWmmaSo3N5djBAAl1KNHD33yySd6+OGHNXnyZEnSfffdp0qVKunjjz9Wx44dLU4Id1I51F8Pdq+tZtUqWR0FAAAAf6DnQCnr2rWrNm3apAMHDriWzZkzR61bt1bfvn21YsUKZWRkFFpnt9vVqVOni3q+0xfCdu3addY248ePV8+ePVWlShUFBgaqfv36evzxx5WVlVWk7ZIlSzRgwABFRUUpICBASUlJevjhhwu12bJli2688UbFxMTI399f9evX1zvvvFPsc+fm5mr48OGKi4tTYGCgUlJStGrVqiLtvv/+e7Vr105BQUEKDQ3V5ZdfrkWLFl3AO3HxbrjhBknSl19+6VqWlpamCRMmaOjQoZe0b19fX7Vs2VLZ2dk6cuTIWdu988476ty5s2JiYhQcHKzGjRvrlVdeKXYc32nTpql79+4KDw9XUFCQ6tevr9GjRxdqs3z5cl1xxRWKjIxUQECAmjdvrq+//rrY5z5x4oSGDBmiyMhIBQcHa8CAAdq+fXuRdh999JGaNm2qgIAARUZG6uqrr9aGDRsu8B0pW+X9+ZOknj176s4779SSJUs0b9481/LExET1799fEydOVPPmzRUQEKBRo0Zp586dMgxDH3/8cZF9GYahZ555ptCyyZMnq0mTJvL391etWrX05ptvus3wYaWhLD9/pw0ZMkR9+/bVN998U+h3pWEYuv/++/Xuu++qfv368vf31yeffOIaFu3MQtPZjt0HH3ygOnXqyN/fXw0aNNAXX3zhNsOHAUBZcTgc2rx5s/r37689e/Zo5syZ+vzzzzVt2jTt2bNHN910k9UR4SYMQ+rXpIreubEFhQEAAAA3Q3GglJ2+A/mvF5Vmz56tlJQUdejQQYZhaP78+YXWtWjRQuHh4Rf1fFu3bpUkVa5c+axttmzZor59+2rs2LGaNm2aHn74YX399dcaMGBAoXbTp09Xp06dtHv3br3++uv66aef9NRTT+nQoUOuNuvXr1fr1q21du1avfbaa5oyZYr69eunBx98UKNGjSry3E888YS2b9+uDz/8UB9++KH279+vLl26FLr4/MUXX+jKK69UWFiYvvzyS40dO1YnTpxQly5dtGDBgot6Xy5EWFiYrr32Wn300UeuZV9++aVsNpsGDx58yfvftm2bfHx8FBERcc42N954oz777DNNmTJFw4YN06uvvqq77767ULuxY8eqb9++cjqdevfdd/XDDz/owQcfLDSkzezZs9WhQwelpqbq3Xff1eTJk9WsWTMNHjy42AvSw4YNk81m0xdffKE33nhDS5cuVZcuXZSamupqM3r0aA0bNkwNGzbUxIkT9eabb+r3339Xu3bttGXLlkt+j0pLeX/+TrviiiskqVBxQJJWrlypv//973rwwQc1bdo0XXPNNRe032nTpmngwIGKiorS+PHj9corr+jLL7/UJ598ckl53UlZf/5Ou+KKK2SaZqHjL0mTJk3SmDFj9PTTT7t+B16I999/X3fddZeaNGmiiRMn6qmnntKoUaOKnUcBADyJaZpq0KCBFi1apMDAQHXv3l033nijevbsqeDgYKvjwU0kRgfr5Wua6J6UJAX62a2OAwAAgDMwrFApS0lJkc1m05w5c3TDDTfo2LFjWrt2rV599VWFhISoRYsWmj17tvr27as9e/Zox44dGjRoUIn3X1BQIElKTU3VF198oUmTJql169aqXbv2Wbd56qmnXP9vmqY6dOig+vXrKyUlRb///ruaNGki6VQ38OrVq2vJkiUKCAhwbTNkyBDX/w8fPlyhoaFasGCBawiQyy+/XHl5eXrppZf04IMPFroIXrlyZX333Xeuu5w7duyo2rVra/To0frggw/kdDr197//XY0bN9ZPP/0km+1Uvapv375KSkrSY489pl9//bXE78/FGjp0qLp27ap169apYcOG+uijjzRo0KALGu/8tNPH6MiRI3rrrbe0cuVKDRo06JxDlbz++uuu/3c6nerUqZOioqI0ZMgQvfbaa4qIiFBmZqaGDx+uDh06aNasWa73tHv37oX2de+996phw4aaNWuWfHxOfcR79eqlo0eP6oknntCtt97qep8lqVWrVoXGfG/YsKE6dOigd955R08++aRSU1P13HPPqW/fvvriiy9c7bp06aLatWvrmWee0f/+978Lfp/KQll//s6mRo0akqT9+/cXWn748GGtX79ederUcS3buXNniff79NNPKyEhQdOnT5efn58kqXfv3h53R3ppfv7O5mzHKDMzU2vWrCn0e6ukF/adTqdGjhypNm3aFJp8vWPHjkpOTlZ8fPylBwcAN+Xj46O4uDgmfEex/HxsuvGy6rqyWbx87NyPBgAA4K44UytlERERatq0qevi0ty5c2W329WhQwdJpy5enh7n/ELGO5ekrKws+fr6ytfXV5UrV9bDDz+sPn366Lvvvjvndtu3b9eNN96ouLg42e12+fr6KiUlRZJcw8Js3rxZ27Zt07BhwwoVBv4qNzdXv/zyi66++moFBQWpoKDA9dO3b1/l5uYWGXP9xhtvLDT8SY0aNdS+fXvXa9+0aZP279+vW265pdAF65CQEF1zzTVavHixsrOzS/T+XIqUlBQlJSXpo48+0po1a7Rs2bKLGtJk3bp1rmMUHx+v1157TTfddJM++OCDc263atUqXXHFFYqKinIdo1tvvdXVZV+SFi5cqPT0dN17771nHVJm69at2rhxo6sr/5nH6MCBA9q0aVOhbc7s9t++fXvVqFHDdYwWLVqknJwc3X777YXaVatWTd26ddMvv/xS4venrJXl5+9cTNMsdnmTJk0KFQYuRFZWlpYvX66rrrrKVRiQTn02zuz1U9GV1ufvXM52jLp163bOXj3nsmnTJh08eFDXXXddoeXVq1d3/Z0DAE92/fXX69NPP7U6BtxMs2qV9M6NLXRNy6oUBgAAANwcPQfKQNeuXfX6669r//79mj17tlq2bKmQkBBJpy6Cvfbaa0pLS9Ps2bPl4+NT4snaAgMDXcOW+Pv7q0aNGoUm8CxOZmamOnXqpICAAD3//POqU6eOgoKCtGfPHg0cOFA5OTmS5BoPv2rVqmfd17Fjx1RQUKD//Oc/+s9//lNsm6NHjxZ6HBcXV6RNXFycfvvtN9c+JalKlSpF2sXHx8vpdOrEiRMKCgo65+u8VIZhaMiQIXrrrbeUm5urOnXqXNQ49ElJSfrqq69kGIYCAgJUs2bN82bfvXu3OnXqpLp16+rNN99UYmKiAgICtHTpUt13330XdIxODwH16KOP6tFHHy22TUmP0eljc75jNHPmzHO+vvJWVp+/czk9jv2Zd4oX956V1IkTJ2SapmJjY4usK25ZRVZan79zKYtjdPqzcbZjtGPHjoveNwBUBM2aNdP48ePVrVs3DRw4UFWqVClyA8PAgQMtSofyFuhr17BONdWzQazHzI0EAADg6SgOlIHTFyfnzJmjOXPmqG/fvq51py9Ezps3zzVR6ukLl+djs9nUqlWrC8oya9Ys7d+/X3PmzHH1FpBUaDx56c85C/46dv2ZIiIiZLfbdcstt+i+++4rtk3NmjULPT548GCRNgcPHlRUVJQkuf786wSyp+3fv182m+2i7+q9ULfffruefvppvfvuu3rhhRcuah8BAQEXfIwmTZqkrKwsTZw40TX0iSStXr26ULuSHKPo6GhJ0ogRI876Zbxu3bqFHp/tGCUnJ0s6/zE6/Zzuoqw+f+fy/fffSzo11NJfFffF+HTPnLy8vELLT19oPi0iIkKGYRSa8+O04o5ZRVcan79z+f7772UYhjp37lxo+YUcozMLa6c/G95yjADgTLfeeqskad++fcUOyWYYhhwORzmnghXqxYXq0V51FRtWfA9kAAAAuCf6eZaBzp07y26369tvv9W6desKXTAMDw9Xs2bN9Mknn2jnzp2lMqTJuZy+8OXv719o+XvvvVfocZ06dVzDepx5Qey0oKAgde3aVatWrVKTJk3UqlWrIj+nL5ad9uWXXxYazmPXrl1auHCh6z2pW7euEhIS9MUXXxRql5WVpQkTJqhdu3Zl3mvgtISEBP3973/XgAEDdNttt5XLc0rFHyPTNIsMRdS+fXuFh4fr3XffPesQKXXr1lXt2rX122+/FXt8WrVqVWQc9zPnC1i4cKF27drlOkbt2rVTYGCgPv/880Lt9u7dq1mzZhWZ88Bq5f35mzlzpj788EO1b9++RL0QYmNjFRAQoN9//73Q8smTJxd6HBwcrFatWmnSpEk6efKka3lmZqamTJlyybndTVl+/saNG6effvpJN9xwg6pXr37e9qfndDjzGJ0uAp1Wt25dxcXF6euvvy60fPfu3Vq4cOGlhQaACmD27Nnn/Jk1a5bVEVEOrmwWr9EDG1MYAAAAqIDoOVAGwsLC1KJFC02aNEk2m63I2NMpKSl64403JJXOeOfn0r59e0VEROiee+7RyJEj5evrq//973+uYX3+6p133tGAAQPUtm1bPfLII6pevbp2796t6dOnuy4gv/nmm+rYsaM6deqkv/3tb0pMTFRGRoa2bt2qH374ociXwMOHD+vqq6/WnXfeqbS0NI0cOVIBAQEaMWKEpFO9IV555RXddNNN6t+/v+6++27l5eXp1VdfVWpqql566aUyfX/OVN7PJ52a0NnPz0833HCD/vGPfyg3N1djxozRiRMnCrULCQnRa6+9pjvuuEM9evTQnXfeqdjYWG3dulW//fab3n77bUmnCj99+vRRr169dPvttyshIUHHjx/Xhg0btHLlSn3zzTeF9rt8+XLdcccdGjRokPbs2aMnn3xSCQkJuvfeeyVJlSpV0j//+U/XZManJ/odNWqUAgICNHLkyPJ5o0qorD5/TqfTNadGXl6edu/erZ9++klff/216tevX+QC8dkYhqGbb75ZH330kZKSktS0aVMtXbq00GTPpz377LPq16+fevXqpYceekgOh8M1ufLx48dLnL2iuNTPX05OjusY5eTkaPv27Zo0aZKmTJmilJQUvfvuuyXaT1xcnHr06KHRo0crIiJCNWrU0C+//KKJEycWamez2TRq1CjdfffduvbaazV06FClpqZq1KhRqlKlSqF5VADAE/21Vyq8j82Q7uuarJ4Niw5RCQAAgIqB4kAZ6dq1q5YtW6bmzZsXmRcgJSVF//73v+Xn56f27duXaY6oqCj9+OOP+r//+z/dfPPNCg4O1pVXXqnx48erRYsWhdr26tVL8+bN07PPPqsHH3xQubm5qlq1qq644gpXmwYNGmjlypV67rnn9NRTT+nw4cOqVKmSateuXWj4ltNefPFFLVu2TEOGDFF6erouu+wyffXVV0pKSnK1ufHGGxUcHKzRo0dr8ODBstvtatu2rWbPnl3m7487qFevniZMmKCnnnpKAwcOVFRUlG688UYNHz5cffr0KdR22LBhio+P18svv6w77rhDpmkqMTGx0J3WXbt21dKlS/XCCy/o4Ycf1okTJxQVFaUGDRoUmThVksaOHavPPvtM119/vfLy8tS1a1e9+eabioyMdLUZMWKEYmJi9NZbb2n8+PEKDAxUly5d9OKLL6p27dpl9+ZcpLL4/OXk5Khdu3aSTs3/UblyZTVt2lQffPCBbrrppkKTBp/Pa6+9Jkl65ZVXlJmZqW7dumnKlCmuO9ZP6927tyZMmKCnn35agwcPVlxcnO69917t379fn332WYmfz1ts377ddYyCg4MVGxurFi1a6JtvvtHAgQMv6GL9Z599pgceeECPPfaYHA6HBgwYoC+//LLIsGF33XWXDMPQK6+8oquvvlqJiYl6/PHHNXnyZO3evbtUXx8AuKu0tDQtXrxYR48eVd++fcttSEhYx8du6Im+9dU6MfL8jQEAAOC2DPNs45MAANxOfn6+mjVrpoSEBM2YMcPqOChGamqq6tSpo6uuukrvv/++1XEAoEw999xzeumll5STkyPDMLRs2TK1aNFC3bt31+WXX67HH3/c6ohnlZ6ervDwcKWlpRW5mcDbLFiwQJ06dXI9bv/QO4pMalJsW5vN0BN96qlNrahi1wMAAKDiYMwDAHBjw4YN01dffaW5c+dq/Pjx6tmzpzZs2KB//OMfVkeDTk08/MADD2jixImaO3euPv30U3Xt2lUZGRl66KGHrI4HAGXqv//9r0aNGqVhw4bpxx9/LDQnUv/+/fXjjz9amA5l5W8pSRQGAAAAPATDCgGAG8vIyNCjjz6qI0eOyNfXVy1atNDUqVPVo0cPq6NBpyYS37lzp+69914dP35cQUFBatu2rd599101bNjQ6ngAUKbefvttDR8+XK+88oocDkehdbVr19aWLVssSoay0rNBrHo3Yo4BAAAAT0FxAADcWEknOoY1IiIi9MMPP1gdAwAssX37dvXq1avYdaGhoUpNTS3fQLhojRs31vz58/X18t1asTNVofG1irSJCfXXHZ2KLgcAAEDFRXEAAAAAwAULDw/XoUOHil23c+dOxcTElHMiXKzw8HB17NhRy3M3a4f9cLFthnSoqUA/ezknAwAAQFlizgE38vHHH8swDAUEBGjXrl1F1nfp0kWNGjUq10wTJ07UDTfcoOTkZAUGBioxMVE33XTTWbuJ//zzz2rXrp2CgoIUHR2t22+/XYcPF/8FoyLiGFUMHKeKgeMEABVb9+7d9corrygrK8u1zDAMFRQUaMyYMWftVYCKp1blYHVIZp4BAAAAT0NxwA3l5eXpqaeesjqGJOnll19Wdna2nnzySU2bNk3PP/+8Vq1apRYtWmjdunWF2s6dO1d9+vRRbGysJk+erDfffFM///yzunfvrry8PIteQdngGFUMHKeKgeMEABXTs88+q127dqlBgwb6v//7PxmGobfffluXXXaZtm7dqn/+859WR0QpGdiiqgzDsDoGAAAASpsJtzFu3DhTktm7d2/TZrOZq1evLrQ+JSXFbNiwYblmOnToUJFl+/btM319fc1hw4YVWt66dWuzQYMGZn5+vmvZr7/+akoy//vf/5Z51vLAMaoYOE4VA8cJACq+devWmb169TJ9fX1NwzBMHx8f8/LLLzfXr19vdbTzSktLMyWZaWlpVkdxG/+eucns/9b8Qj83f7jYzC9wWB0NAAAAZYCeA27oH//4h6KiovTYY49ZHaXYsWLj4+NVtWpV7dmzx7Vs3759WrZsmW655Rb5+Pw5lUX79u1Vp04dfffdd+WSt7xwjCoGjlPFwHECgIrj+++/V1pamutxgwYNNG3aNGVkZGjv3r1KT0/XjBkzVL9+fQtTojR1rxcjHztfGwEAADwRZ3luKDQ0VE899ZSmT5+uWbNmXfD2TqdTBQUF5/1xOBwXlW/79u3atWuXGjZs6Fq2du1aSVKTJk2KtG/SpIlrvafgGFUMHKeKgeMEABXH1VdfrU2bNkmSatWqpd9++02S5O/vr/j4eAUGBloZD2WgR4NYqyMAAACgjFAccFP33HOPatWqpccee0ymaV7Qts8++6x8fX3P+5OUlHTBuQoKCjRs2DCFhITokUcecS0/duyYJCkyMrLINpGRka71noRjVDFwnCoGjhMAVAyBgYHKzs6WJO3cuZM5VjxcvbhQVY0IsjoGAAAAyojP+ZvACn5+fnr++ed144036uuvv9bgwYNLvO1dd92l/v37n7edv7//BWUyTVPDhg3T/PnzNWHCBFWrVq1Im7NNVOaJE5hxjCoGjlPFwHECgIqhfv36evLJJ3X11VdLkr744gstWLCg2LaGYRQqrKLi6Vav6HB7AAAA8BwUB9zY9ddfr3/961968sknNXDgwBJvFxcXV+y42We6kItXpmnqjjvu0Oeff65PPvlEV155ZaH1UVFRklTs3bLHjx8v9u5aT8Axqhg4ThUDxwkA3N9LL72kwYMH6x//+IcMw9Bbb7111rYUByo2H7uhjrWjrY4BAACAMsSwQm7MMAy9/PLL2rZtm95///0Sb1faQ2ycvkg2btw4ffjhh7r55puLtGnUqJEkac2aNUXWrVmzxrXe03CMKgaOU8XAcQIA99e9e3cdPXpUe/bskWma+u6777Rjx45if7Zv3251XFyCVjUiFBrga3UMAAAAlCF6Dri5Hj166PLLL9ezzz5b7JAWxSnNITZM09Sdd96pcePG6b333tOQIUOKbZeQkKDLLrtMn3/+uR599FHZ7XZJ0uLFi7Vp0yY9/PDDJcpeEXGMKgaOU8XAcQIA9/bWW2/p+uuvV0JCgkaOHKnWrVsrPj7e6lgoAx2S6TUAAADg6SgOVAAvv/yyWrZsqcOHD6thw4bnbR8fH19qX9IefPBBjR07VkOHDlXjxo21ePFi1zp/f381b968UM7LL79cgwYN0r333qvDhw/r8ccfV6NGjc56gc1TcIwqBo5TxcBxAgD39cgjj6ht27aKiYnRs88+qz59+lAc8EB2m6HWiQyRBwAA4OkYVqgCaN68uW644QZLnvuHH36QJH300Udq165doZ/TE9Gd1qVLF02dOlUHDhzQgAED9MADD6hr16765ZdfLngi0IqGY1QxcJwqBo4TALiv0NBQpaamSjrV2wqeqWF8mIL9uY8MAADA0xkmZ/UAAAAASqBLly46ePCgevToof/+978aNGiQYmNji21rGIbefPPNck5Ycunp6QoPD1daWprCwsKsjuMW3vh5s37ZcFi3tU/UtS2rWh0HAAAAZYziAAAAAIASWb16tYYMGaJ169bJ4XCcs/eAYRhyOBzlmO7CUBwo6nRx4NVBTVQvjvcEAADA0zGsEAAAAIASadasmVatWqWTJ0/KNE0tXrxYTqez2B93Lgzg7Ow2Q7WiQ6yOAQAAgHJAcQAAAADABRs3bpySkpKsjoFSViMqSH4+fE0EAADwBswyBQAAAOCC3XbbbVZHQBmoERlkdQQAAACUE4oDAAAAAEpk6NCh+uc//6maNWtq6NCh52xrGIbGjh1bTslQWqpGUBwAAADwFhQHAAAAAJTI7Nmz9dBDD0mSZs2aJcMwztr2XOvgvmLDA6yOAAAAgHJCcQAAAABAiezYscP1/zt37rQuCMpM5RB/qyMAAACgnDDTFAAAAABAkhQV4md1BAAAAJQTeg4AAAAAuGB79uzR/PnztX//fklSfHy8OnfurKpVq1qcDJciPNDX6ggAAAAoJxQHAAAAAJRYRkaG7rrrLn3zzTcyTVOmabrW2Ww23XjjjRozZoyCg4MtTImLEeBrV4Cv3eoYAAAAKCcUBwAAAACUiGma6t+/v+bPn6++ffvqiiuuUI0aNWSapnbt2qXJkyfr888/1759+/TLL79YHRcXiF4DAAAA3oXiAAAAAIASmThxoubPn69x48bptttuK7L+7rvv1rhx4zRs2DB99913uvrqqy1IiYsVFkBxAAAAwJsY5l/7AQMAAADAWVx33XXKzc3V999/f852V1xxhQIDAzV+/PhySnbh0tPTFR4errS0NIWFhVkdxy3M23xEnetUtjoGAAAAyonN6gAAAAAAKoZVq1bpqquuOm+7q666SitXriz7QChVIQF0LAcAAPAmFAcAAAAAlMihQ4dUs2bN87arVauWDh06VA6JUJqC/JiMGAAAwJtQHAAAAABQIllZWQoODj5vu8DAQGVlZZVDIpSmQF+KAwAAAN6E4gAAAACAEjFNU4ZhWB0DZcTfh+IAAACAN2FQSQAAAAAlduONNyowMPCcbXJycsopDUqTj53CDwAAgDehOAAAAACgRDp37lzingNVq1Yt4zQobQwrBAAA4F0M0zRNq0MAAAAAQHlKT09XeHi40tLSFBYWZnUcAAAAoNwx5wAAAAAAAAAAAF6G4gAAAAAAAAAAAF6G4gAAAAAAAAAAAF6G4gAAAAAAAAAAAF6G4gAAAAAAAAAAAF6G4gAAAAAAAAAAAF6G4gAAAAAAAAAAAF6G4gAAAACAC5afn6/nn39eDRo0UHBwsOx2e6EfHx8fqyMCAAAAOAfO2AEAAABcsBEjRujf//63+vTpo6uuukr+/v5WRwIAAABwAQzTNE2rQwAAAACoWKpXr65hw4Zp5MiRVke5KOnp6QoPD1daWprCwsKsjgMAAACUO4YVAgAAAHDBTpw4oc6dO1sdAwAAAMBFojgAAAAA4IJ17txZq1evtjoGAAAAgItEcQAAAADABXvrrbc0duxYTZw4USdPnrQ6DgAAAIALxJwDAAAAAC5YaGio8vPzlZ+fL8MwFBQUVGi9YRhKS0uzKN35MecAAAAAvJ2P1QEAAAAAVDzXXHONDMOwOgYAAACAi0TPAQAAAABeh54DAAAA8HbMOQAAAAAAAAAAgJdhWCEAAAAAF23t2rXasGGDcnJyiqy79dZbLUgEAAAAoCQYVggAAADABcvOztYVV1yhWbNmyTAMnf5a8dd5CBwOh1XxzothhQAAAODtGFYIAAAAwAV77rnntHPnTs2dO1emaWrixImaOXOmBg4cqNq1a2vlypVWRwQAAABwDhQHAAAAAFywyZMn67HHHlP79u0lSdWrV1f37t31zTffqEWLFhozZozFCQEAAACci9cVB0aPHi3DMPTwww9bHQUAAAAVnDefW+7cuVP16tWT3W6XYRjKzs52rbvppps0adIk68IBAAAAOC+vKg4sW7ZM77//vpo0aXJB2x04cEDPPPOMDhw4UEbJAAAAYIVLOc+72HNLT1GpUiVlZWVJkmJiYrRlyxbXuvz8fNc6AAAAAO7Ja4oDmZmZuummm/TBBx8oIiLigrY9cOCARo0aRXEAAADAw1zsed6lnFt6isaNG2vz5s2SpK5du+rFF1/UggULtHTpUj377LNq2rSpxQkBAAAAnIvXFAfuu+8+9evXTz169Dhv27y8PKWnp7t+MjMzyyEhAAAArJKZmVno/C8vL++c7S/k3NJTDRs2TBkZGZKkF154QdnZ2UpJSVG7du20a9cuvfbaaxYnBAAAAHAuPlYHKA9fffWVVq5cqWXLlpWo/ejRozVq1KgyTgUAAAB3kZKSUujxyJEj9cwzzxTb9kLPLT3Vdddd5/r/mjVravPmzZo1a5YMw1D79u0VGRlpYToAAAAA5+PxxYE9e/booYce0owZMxQQEFCibUaMGKHhw4e7Hq9evbrIF0YAAAB4jrlz56pZs2aux/7+/sW2u5hzS28RHBysAQMGWB0DAAAAQAl5fHFgxYoVOnz4sFq2bOla5nA4NG/ePL399tvKy8uT3W4vtI2/v3+hL4QhISHllhcAAADlLyQkRGFhYedtdzHnlp4sLy9PH3/8sebMmaOjR4/qv//9r2rXrq3JkyercePGqlWrltURAQAAAJyFxxcHunfvrjVr1hRaNmTIENWrV0+PPfaYV315AwAAwKXh3PJPR48eVdeuXbVu3TrFxcXp0KFDrjkIJk2apOnTp+u///2vxSkBAAAAnI3HFwdCQ0PVqFGjQsuCg4MVFRVVZDkAAABwLpxb/ukf//iHUlNTtXz5cjVp0kR+fn6udV27dtXLL79sYToAAAAA5+PxxQEAAAAApW/KlCl6+eWX1aJFCzkcjkLrqlatqr1791qUDAAAAEBJeGVxYM6cOVZHAAAAgIfw1nPL9PR01ahRo9h1+fn5KigoKOdEAAAAAC6EzeoAAAAAACqemjVratGiRcWuW7p0qerWrVvOiQAAAABcCIoDAAAAAC7YTTfdpJdfflmTJ0+WaZqSJMMwtGzZMr355pu65ZZbLE4IAAAA4Fy8clghoCLJyspScHCw1TEAAAAKeeyxx/Trr7/q6quvVkREhCSpV69eOnbsmHr37q2HHnrI4oQAAAAAzoXiAODmDhw4oOTkZKtjAAAAFOLr66upU6dq/Pjx+vHHH3Xo0CFFR0erf//+uv7662Wz0UkZAAAAcGcUBwA3d/jwYYoDAADALRmGoeuvv17XX3+91VEAAAAAXCBu5wHc3J49e+RwOKyOAQAAAAAAAMCD0HMAcHPZ2dlavXq1WrZsaXUUAADg5bp161bitoZh6JdffinDNAAAAAAuBcUBwI21atVK27dvV1hYmGbPnq2aNWtaHQkAAHixOXPmKCwsTNWqVbM6CgAAAIBLRHEAcGMHDx7UiRMnZJqmZs2apZSUFOYfAAAAlqlVq5a2b9+u8PBwDR06VIMHD1ZwcLDVsQAAAABcBOYcACoIh8OhWbNm6ZdfflFWVpbVcQAAgBfaunWrZs+erVq1aumBBx5QlSpVdMcdd2jhwoXllmHnzp0aNmyYatasqcDAQCUlJWnkyJE6efJkuWUAAAAAPAHFAaCC2bZtm8aPH69FixYpIyPD6jgAAMDLpKSk6NNPP9WBAwf0yiuvaM2aNerYsaPq16+vV199VYcOHSrT59+4caOcTqfee+89rVu3Tv/+97/17rvv6oknnijT5wUAAAA8DcMKARVQQUGB1qxZo7Vr1yo+Pl7JyclKTEyUv7+/1dEAAICXCAsL0z333KN77rlHa9eudV2gX7x4sSZMmFBmz9u7d2/17t3b9bhWrVratGmTxowZo3/9619l9rwAAACAp6E4AFRgpmlq37592rdvn+bPn6+qVasqKSlJNWrUkJ+fn9XxAACAF9iwYYM++eQTffvttzJNU3Xr1i33DGlpaYqMjDxnm7y8POXl5bkep6enl3UsAAAAwK1RHAA8hNPp1O7du7V7927Z7XZVqVJF1apVU3x8vCIjI2UYhtURAQCAh8jMzNSXX36pjz76SEuWLFFSUpIefPBB3X777YqPjy/XLNu2bdN//vMfvfbaa+dsN3r0aI0aNaqcUgEAAADuj+IA4Ka2bNniuqMtJydHhw4dUmxsbIm2dTgc2rt3r/bu3StJ8vPzU2xsrOLi4hQXF6fY2FjZbEw5AgAALsy8efM0duxYTZgwQaZp6tprr9VLL72klJSUS973M888c96L98uWLVOrVq1cj/fv36/evXtr0KBBuuOOO8657YgRIzR8+HDX4/T0dFWrVu3SQgMAAAAVmGGapml1CHe3cuVKtWzZUitWrFCLFi2sjgMvMG7cON1xxx1yOp2uZYZh6NZbb1X79u0vef/+/v6qXbu2WrVqxfBDAACvxnnehbHZbAoLC9PgwYN1ww03KCws7JztL+Q9PXr0qI4ePXrONomJiQoICJB0qjDQtWtXtWnTRh9//PEF3/iQnp6u8PBwpaWlnfd1AAAAAJ6IngOAm9myZUuRwoB0an6BTz/9VMnJyYqJibmk58jLy9PatWt18OBB9erVS8HBwZe0PwAA4D3S09P14Ycf6sMPPzxrG9M0ZRiGHA5HifcbHR2t6OjoErXdt2+funbtqpYtW2rcuHH0iAQAAAAuAsUBwM189NFHZ50fwDAM/frrr7r66qtL5bmOHj2qb775Rs2bN1fjxo35Yg0AAM5p3LhxVkfQ/v371aVLF1WvXl3/+te/dOTIEde6uLg4C5MBAAAAFQvFAcDN7Ny5U2cb7cs0TR07dqxUn+/kyZNasmSJgoODlZycXKr7BgAAnuW2226zOoJmzJihrVu3auvWrapatWqhdYyYCgAAAJQctwkDbiYxMfGcPQeioqJK9fmqVKmi3r17KykpqVT3CwAAUBZuv/12maZZ7A8AAACAkqPnAOBmhg4dqldeeaXYdaZpqkOHDpf8HHa7XUlJSWrUqFGJx/YFAAAAAAAA4DkoDgBupnbt2ho7dqyGDRtWaFJiwzB06623XvRkxDabTQkJCapZs6Zq1qwpf3//0ooMAAAAAAAAoILx+GGFxowZoyZNmigsLExhYWFq166dfvrpJ6tjAed0++23a9OmTQoNDZUk+fv769lnn1X79u0vaD++vr5KSkpS9+7ddeutt6pPnz6qV68ehQEAAC4S55YAAAAAPIXH9xyoWrWqXnrpJddEq5988omuvPJKrVq1Sg0bNrQ4HXB2ycnJCgsLU0ZGhgIDA0vcY8AwDMXHx6tu3bqqUaOGfH19yzgpAADeg3NLAAAAAJ7C44sDAwYMKPT4hRde0JgxY7R48eKzfoHLy8tTXl6e63FmZmaZZgRKQ0REhJKTk5WcnOzqcQAAAEomMzNT6enprsf+/v7F9rS7mHNLAAAAAHBHHl8c+CuHw6FvvvlGWVlZateu3VnbjR49WqNGjSrHZMDFqVy5shITE1WzZk1VqlTJ6jgAAFRYKSkphR6PHDlSzzzzzDm3Kem5JQAAAAC4I68oDqxZs0bt2rVTbm6uQkJC9N1336lBgwZnbT9ixAgNHz7c9Xj16tVFvjACVvH391e9evVUr149hYeHWx0HAACPMHfuXDVr1sz1+Fzz81zouSUAAAAAuCOvKA7UrVtXq1evVmpqqiZMmKDbbrtNc+fOPeuXuDO7kYeEhJRXVOCsDMNQkyZN1KxZMyYUBgCglIWEhCgsLKxEbS/03BIAAAAA3JFXFAf8/Pxck8a1atVKy5Yt05tvvqn33nvP4mTAucXFxSk7O1thYWHq27evEhISrI4EAIDX49wSAAAAgCfwiuLAmUzTLDThMOCuli9frnHjxqlOnToUBgAAcFOcWwIAAACoiDy+OPDEE0+oT58+qlatmjIyMvTVV19pzpw5mjZtmtXRgBIxDEONGze2OgYAABDnlgAAAAA8h8cXBw4dOqRbbrlFBw4cUHh4uJo0aaJp06bp8ssvtzoaUCKJiYklHgMZAACULc4tAQAAAHgKjy8OjB071uoIwCWpVq2a1REAAMAfOLcEAAAA4ClsVgcAcG70GgAAAAAAAABQ2igOAG4uIiLC6ggAAAAAAAAAPAzFAcDN+fh4/OhfAAAAAAAAAMoZxQEAAAAAAAAAALwMxQEAAAAAAAAAALwMxQEAAAAAAAAAALwMxQEAAAAAAAAAALwMxQEAAAAAAAAAALwMxQEAAAAAAAAAALwMxQEAAAAAAAAAALwMxQEAAAAAAAAAALwMxQEAAAAAAAAAALwMxQEAAAAAAAAAALwMxQEAAAAAAAAAALwMxQEAAAAAAAAAALwMxQEAAAAAAAAAALwMxQEAAAAAAAAAALwMxQEAAAAAAAAAALwMxQEAAAAAAAAAALwMxQEAAAAAAAAAALwMxQEAAAAAAAAAALyMxxcHRo8erdatWys0NFQxMTG66qqrtGnTJqtjAQAAoALi3BIAAACAp/D44sDcuXN13333afHixZo5c6YKCgrUs2dPZWVlWR0NAAAAFQznlgAAAAA8hY/VAcratGnTCj0eN26cYmJitGLFCnXu3NmiVAAAAKiIOLcEAAAA4Ck8vjhwprS0NElSZGTkWdvk5eUpLy/P9TgzM7PMcwEAAMA6mZmZSk9Pdz329/eXv7//ebcrybklAAAAALgjjx9W6K9M09Tw4cPVsWNHNWrU6KztRo8erfDwcNdPSkpKOaYEAABAeUtJSSl0/jd69OjzblPSc0sAAAAAcEde1XPg/vvv1++//64FCxacs92IESM0fPhw1+PVq1dTIAAAAPBgc+fOVbNmzVyPS9JroKTnlgAAAADgjrymOPDAAw/o+++/17x581S1atVztj2zG3lISEhZxwMAAICFQkJCFBYWVuL2F3JuCQAAAADuyOOLA6Zp6oEHHtB3332nOXPmqGbNmlZHAgAAQAXFuSUAAAAAT+HxxYH77rtPX3zxhSZPnqzQ0FAdPHhQkhQeHq7AwECL0wEAAKAi4dwSAAAAgKfw+AmJx4wZo7S0NHXp0kVVqlRx/YwfP97qaAAAAKhgOLcEAAAA4Ck8vueAaZpWRwAAAICH4NwSAAAAgKfw+J4DAAAAAAAAAACgMIoDAAAAAAAAAAB4GYoDAAAAAAAAAAB4GYoDAAAAAAAAAAB4GYoDAAAAAAAAAAB4GYoDAAAAAAAAAAB4GYoDAAAAAAAAAAB4GYoDAAAAAAAAAAB4GYoDAAAAAAAAAAB4GYoDAAAAAAAAAAB4GYoDAAAAAAAAAAB4GYoDAAAAAAAAAAB4GYoDAAAAAAAAAAB4GYoDAAAAAAAAAAB4GR+rAwAAAAAo3rx58/TWW29pw4YNysnJKbTOMAxt27bNomQAAAAAKjp6DgAAAABuaMGCBerevbvS0tK0YcMG1atXTwkJCdq9e7d8fHzUuXNnqyMCAAAAqMAoDgAAAABuaOTIkRoyZIimTZsmSXr++ec1f/58rVy5UpmZ/9/e3cfnXP///7+/jp0cO7Nhw8zZkPPzk3KazVnOlbN3qJympJJUspKNlCh90omkhIreKiK8o8JGIgmF5CQtMucnO7GZ2V6/P3x3/FqGjR177dhu18vluLTjdTyP1+t+yNOex+vxej2fSerdu7fFCQEAAAC4MooDAAAAQAG0e/du9erVS4ZhSJLS09MlSfXr19cLL7ygyZMnWxkPAAAAgIujOAAAAAAUQMnJyfLz85PNZpPdbtfp06cdr9WsWVO//fabhekAAAAAuDqKAwAAAEABVLFiRZ04cUKSVLt2ba1atcrxWkxMjAIDA62KBgAAAKAQcLc6AAAAAICrhYeHKzo6Wn379tWIESM0atQo7d27V3a7Xd98842eeuopqyMCAAAAcGFF4s6BDRs2qEePHgoJCZFhGFq2bJnVkQAAAOCC8nNcOWnSJI0ePVqSNHLkSL322ms6f/68Tp48qQkTJmjKlClOOzYAAACAws9pxYGvvvpK8fHxztp9rly4cEENGjTQ22+/bXUUAAAAuLD8HFcGBQWpevXqjudjx47Vzz//rG3btikqKkoeHh5OzwAAAACg8HJacaBXr17at2+fJKlKlSr65ZdfnHWoG+rSpYumTJmi3r17W5YBAAAAri8/x5Xt2rXT77//nu1r+/fvV7t27ZyeAQAAoCjadHST1RGAfOG0NQe8vb2VnJwsSYqNjVVqaqqzDpXnUlNTs+RNSkqyMA0AAACcLSkpSQkJCY7ndrtddrvdwkRSdHR0lkz/lJiYqJiYmHxOBAAAUDScTD5pdQQgXzitOFCrVi09//zz6tWrlyRp0aJF+v7777NtaxiGnnzySWdFybWpU6dq0qRJVscAAABAPgkLC8vyPDIyUlFRUdaEyYFjx47Jx8fH6hgAAACF0tmLZ62OAOQLpxUHXnnlFd17770aN26cDMPQm2++ec22Ba04EBERobFjxzqe79y586ovjAAAACg8YmJi1LBhQ8dzq+4aWL58uZYvX+54/uKLL6pUqVJZ2qSkpCg6OlqNGjXK73gAAABFwrmL55SekS43m5vVUQCnclpxoH379jp9+rSOHj2qChUq6Msvv8zyhasg+/dt5H5+fhamAQAAgLP5+fnJ39/f6hj67bff9Pnnn0u6cgHNunXrZLNlXSbMbrerXr16mjlzphURAQAACr10M11nL55VKZ9SN24MuDCnFQfefPNN9e/fX+XKlVNkZKRuv/12hYSEOOtwAAAAgMuLiIhQRESEJMlms2n9+vW64447LE4FAABQ9JxMOUlxAIWe7cZNbs6TTz6p2NhYSdLkyZP1999/O+tQN5SUlKSdO3dq586dkqQ///xTO3vdfj0AAFmvSURBVHfu1OHDhy3LBAAAANeTn+PKjIwMCgMAAAAWOX7huNURAKdz2p0DxYoV0/nz5yVJpmk66zA5sm3bNrVt29bxPHM9gcGDB2v+/PkWpQIAAICrYVwJAABQNFAcQFHgtOJAw4YNNXr0aHXo0EGSNGPGDJUpUybbtoZhOHXO1PDwcMsLFAAAAHB9zh5XVq5cWYZh5KitYRj6448/nJYFAACgKDuWdMzqCIDTOa048MYbb2jo0KGaM2eODMNwLKyWHWcXBwAAAABXEBYWluPiAAAAAJwn7kKc1REAp3PqnQM7duyQdGUxtS1btjBnKgAAAHAdTE0EAABQMBy/cFyXMy7L3ea006eA5Zy2IPE/zZs3T1WrVs2PQwEAAAAAAADALUk303Ui+YTVMQCnypfiwODBgxUYGJgfhwIAAAAKjVOnTikiIkItWrRQtWrVtGfPHknSe++957hLFwAAAM4Rl8TUQijcnHZfzLBhw/TCCy+ocuXKGjZs2HXbGoahuXPnOisKAAAA4HL+/PNPtWrVSvHx8WrQoIEOHTqk1NRUSdKvv/6qLVu2aN68eRanBAAAKLyOJh3V7brd6hiA0zitOLB+/Xo98cQTkqR169Zdd2E1Fl0DAAAAsho3bpyKFy+ubdu2qXTp0vL09HS81rp1a0VGRlqYDgAAoPA7duGY1REAp3JaceDPP/90/BwbG+uswwAAAACF0tq1a/Xuu+8qJCRE6enpWV4rW7as4uK4zR0AAMCZjiVRHEDhli9rDgAAAADInYsXL6pkyZLZvnbhwgXZbAzlAQAAnIk7B1DYOe3OgX86cuSINm7c6Li6KSQkRG3atFH58uXz4/AAAACAy6lRo4a+++47dezY8arXNmzYoLp161qQCgAAoOhIuJSghEsJ8vf0tzoK4BROLQ4kJibqoYce0ueffy7TNGWapuM1m82mgQMH6t1335Wvr68zYwAAAAAuZ8SIERo7dqxCQkJ03333SZIuXbqkL774QrNmzdLbb79tcUIAAIDC76/4v1SvVD2rYwBO4bTigGma6t69uzZu3KiuXbuqZ8+eqlSpkkzT1F9//aXly5frk08+0dGjR7V27VpnxQAAAABc0qhRo7Rz5049+eSTeuqppyRdWYjYNE2NGDFCgwcPtjghAABA4Xfw/EGKAyi0nFYcWLp0qTZu3Kh58+Zl+8Xl4Ycf1rx58zR8+HB9+eWX6tWrl7OiAAAAAC5pzpw5GjZsmFatWqUTJ04oKChI3bt3V8uWLa2OBgAAUCT8evpX9arGeUsUTk4rDixevFjdu3e/7hVNQ4cO1Zdffqn//ve/FAcAAACAbDRv3lzNmze3OgYAAECR9PuZ3xWfGq8Ae4DVUYA8Z3PWjnfs2KF77rnnhu3uuecebd++3VkxAAAAAAAAAOCmZChDMX/HWB0DcAqnFQdOnDihypUr37BdlSpVdOLECWfFAABA0pVFPAGgoLPZbHJzc8vxAwAAAM73v0P/U1p6mtUxgDzntGmFLly4IF9f3xu28/b21oULF5wVAwAASdK5c+dUpkwZq2MAwHVNnDhRhmE4ns+bN09JSUnq0aOHgoODdezYMa1cuVK+vr4aNmyYhUkBAACKjnOp5/R17NfqWbWn1VGAPOW04oBpmlm+2AAAYKXDhw+rZMmS8vDwsDoKAFxTVFSU4+cZM2YoODhY3333nfz8/BzbExMT1aFDB/n4+FiQEAAAoGhasn+JWoW0UqB3oNVRgDzjtOKAJA0cOFDe3t7XbZOSkuLMCAAASJJSU1O1ZcsW3XnnnVZHAYAcmTVrll599dUshQFJKlasmMaNG6enn35azzzzjEXpAAAACp/4+Hjt2rVLsb/F6tS5UwoIDZCnr6ck6WL6RX2w6wONu30cF0Sj0HBacaBNmzY57ijly5d3VgwAANS0aVMdPnxY3t7eio6OztGaOABgtaNHj8rdPfvhuru7u44fP57PiQAAAAq3Xbt2ZbmgrO0rbVWqTinH8+0ntyv6SLTaVmxrQTog7zmtOBAdHe2sXQMAkCvHjx/XqVOnVLx4ca1bt07h4eGqWrWq1bEA4Lpq1aql119/XV26dMkyJdqlS5c0Y8YM1axZ08J0AAAARdP8PfNVs2RNlfUra3UU4JY5dVohAAAKmvT0dK1du1a//fabqlevrooVK95wCjwAsMKUKVN0zz33qEqVKurdu7eCg4N1/PhxLV26VMePH9eyZcusjggAAFDkXEy/qNd/fl0vtX5Jnm6eVscBbgnFAQBAkXTs2DEdO3ZMkhQUFKQKFSqoSpUqCgxkcSkABUO3bt20evVqPf/883rnnXeUkZEhwzB0xx13aN68eerQoYPVEQEAAIqkw4mHNfuX2Xq80eOsPwCXZrM6QH6ZNWuWKleuLC8vLzVp0kQbN260OhIAoIA4ffq0duzYoSVLlmj58uX6888/lZGRYXUsAAVYfo0t27dvry1btighIUFHjhxRYmKiNm/eTGEAAADAYpviNumLA19YHQO4JUWiOLB48WKNGTNGzz//vHbs2KE777xTXbp00eHDh62OBgAoYE6cOKFvv/1WH3/8sb777jvt2bNHp0+fVnp6utXRABQQVowtfXx8VK5cOfn4+DjtGAAAAMidL/Z/odWxq62OAdy0IjGt0Ouvv67hw4frwQcflCS98cYbWrNmjd59911NnTr1qvapqalKTU11PE9KSpIkXb58WWlpafkTGgCQJw4cOKD4+HhJUnJysuLi4lSmTJkbvi85OVkHDhzQgQMHJEk2m00lS5Z0PIKCghQYGJhlkVAArufy5cuSroz3EhISHNvtdrvsdnu278nt2BJ5r2fPntq5c6dOnjypEiVKqEOHDpo2bZpCQkKsjgYAAIqYebvnyTRNdancxeooQK4V+uLApUuX9PPPP2v8+PFZtt9111364Ycfsn3P1KlTNWnSpKu2N2vWzCkZAQD549KlS9n++w4AYWFhWZ5HRkYqKirqqnY3M7ZE3mvbtq2ee+45lS1bVkePHtXTTz+tvn378v8AAABYYv6e+UpKS1Lfan1ZgwAupdAXBzKngvj3VaJlypTR8ePHs31PRESExo4d63i+c+dOhYWF6ccff1SjRo2cmhcAkDcOHDigunXryjTNbF+PiopS6dKl8+x4wcHB6tix4zWvNAZQMO3YsUPNmjVTTEyMGjZs6Nh+rb58M2NL5L0nn3zS8XOlSpU0fvx43XPPPUpLS+OOLgAAYIkv9n+hU8mnNKL+CHnYGI/ANeRLcSAtLU3Tpk3TokWL9Ndff+nixYtZXjcMw3FLt7P8u2pnmuY1K3n/vo3cz89PkuTu7s6XDQBwER9//LFsNlu2awXYbDZt2bJFvXr1yrPjnTp1SsuWLVPbtm1Vrly5PNsvAOdyd78yHPbz85O/v3+O35ebsSWc6+zZs1q4cKFatmx53bH6v6cO/ec0UgAAAHkh5u8YnUg+obFNxirAHmB1HOCG8qU4EBERof/7v/9Tly5ddM899+TrVZVBQUFyc3O76kqukydP5mjOaQCAa4qNjb3mXQOmaerMmTN5fszk5GTt3r2b4gBQiDG2LDieffZZvf3220pOTlbz5s21cuXK67a/1tShAAAAeen3s78rYmOEnm76tKoUr2J1HOC6bPlxkM8++0wTJ07UypUr9fLLLysyMvKqh7N4enqqSZMm+vbbb7Ns//bbb9WyZUunHRcAYK3Q0NBrXsVrGIYCAwPz9Hh+fn5q2bKlOnTokKf7BVCwWDW2zMjIUJUqVbRnzx6nHcNqUVFRMgzjuo9t27Y52j/zzDPasWOHvvnmG7m5uWnQoEHXLApLVy5Yio+PdzyOHDmSHx8LAAAUQWcuntHEHyZq/eH1VkcBritf7hw4d+6c2rRpkx+HytbYsWP1wAMPqGnTpmrRooXmzJmjw4cPa+TIkZZlAgA417BhwzR9+vRsXzNNU61atbrlYxiGofLly6tmzZqqVKmSbLZ8qbkDsJgVY0vTNBUbG5tlWpzC5rHHHlP//v2v2yY0NNTxc1BQkIKCglS9enXVqlVLFSpU0JYtW9SiRYts3/vvqUMBAACcKS0jTbN/na195/ZpWN1h8nTztDoScJV8KQ60adNGO3fuVNu2bfPjcFe59957debMGU2ePFnHjh1T3bp19b///U+VKlWyJA8AwPmqVaumuXPnavjw4crIyHBsNwxDgwYNuunFiO12u0JCQlShQgVVqlRJ3t7eeRUZgItgbOkcmSf7b0bmHQOFuXgCAABc0/oj63Xo/CGNbjxa5YuVtzoOkEW+FAfefPNN3X333apUqZK6d+8uT8/8r5SNGjVKo0aNyvfjAgCsM2TIELVu3VqNGzdWYmKi7Ha7JkyYkKvCgK+vr4KDgx2PkiVLsugoAMaWFtq6dau2bt2q1q1bq0SJEjp06JAmTpyoqlWrXvOuAQAAACv9lfiXIjZGaFCdQepQsQPfKVFg5EtxoGHDhkpLS1O/fv1kGIZ8fHyyvG4YhuLj4/MjCgCgiLntttvk7++vxMREeXt737Aw4OnpqXLlyql8+fIqV66cihUrxsANgOVsNpsiIyMVEhJidRTLeXt7a+nSpYqMjNSFCxdUtmxZde7cWf/973+ZNggAABRYlzIu6YNdH2jrsa16uMHDCvK+uTsmgbyUL8WBPn36cGIFAFBglSxZUhUrVlSFChVUpkwZ1g4AUOAYhqHIyEirYxQI9erV07p166yOAQAAcFN+Pf2rnop+SgNqDtBdoXfJZvD9E9bJl+LA/Pnz8+MwAADkmKenp2rVqqUaNWqoePHiVscBAAAAABQRF9Mvat6eeYr+O1oP1n1Qt5W4zepIKKLypTgAAICVgoODdenSJXl7e8swDNWpU0dNmjRh+gkAAAAAgGX+jP9Tz296XuEVwjWw5kAF2AOsjoQiJl+LA7t379bevXuVkpJy1WuDBg3KzygAgCJk27Zt+v7773Xw4EHdddddzNkNAAAAACgwoo9E68djP6pPtT7qXLmzPGweVkdCEZEvxYHk5GT17NlT69atk2EYMk1TkrKsQ0BxAADgbGFhYRQGAAAAAAAFTsrlFH2y9xOtPbxWg2oPUuMyja2OhCIgX1a8ePHFFxUbG6uYmBiZpqmlS5fq22+/Ve/evVWtWjVt3749P2IAAIqwEiVKKDQ01OoYAAAAAABc07ELxzTtp2matnWajl84bnUcFHL5UhxYvny5nn32WbVs2VKSVLFiRbVv316ff/65GjdurHfffTc/YgAAirCgoKAsd6wBAAAAAFBQbT+5XU/FPKXP9n2mtPQ0q+OgkMqX4kBsbKxq1qwpNzc3GYah5ORkx2v33Xefli1blh8xAABFmL+/v9URACDXNmzYoL59+6pOnTqqUqVKlkfVqlWtjgcAAAAnupxxWUsOLNG4DeO098xeq+OgEMqX4kDx4sV14cIFSVLp0qV14MABx2tpaWmO1wAAcBa73W51BADIle+//17t27dXfHy89u7dq5o1a6pcuXI6fPiw3N3d1aZNG6sjAgAAIB/EXYjTpM2TtHDvQu4iQJ7Kl+JAvXr1tH//fklS27Zt9fLLL+v777/X1q1bNXnyZDVo0CA/YgAAijCmFALgaiIjIzV06FCtXr1akjRlyhRt3LhR27dvV1JSknr37m1xQgAAAOQXU6a++uMrTfxhok4ln7I6DgqJfCkODB8+XImJiZKkl156ScnJyQoLC1OLFi30119/acaMGfkRAwBQhJmmaXUEAMiV3bt3q1evXo7iZnp6uiSpfv36euGFFzR58mQr4wEAAMACh+IPKWJjhPac3mN1FBQC7vlxkP/85z+OnytXrqz9+/dr3bp1MgxDLVu2VMmSJfMjBgCgCOPOAQCuJjk5WX5+frLZbLLb7Tp9+rTjtZo1a+q3336zMB0AAACskpiWqJd/fFmPNnxULcu1tDoOXFi+FAf+zdfXVz169LDi0ACAIoriAABXU7FiRZ04cUKSVLt2ba1atUpdunSRJMXExCgwMNDKeAAAALDQZfOyZu6YqcS0RHUK7WR1HLiofJlWSJJSU1P13nvvacCAAerYsaNjUeLly5fr0KFD+RUDAAAAcAnh4eGKjo6WJI0YMUKzZs1S+/bt1bVrV02ZMkUDBgywNiAAAAAs9+HuD/XVH19ZHQMuKl/uHDh9+rTatm2rPXv2KDg4WCdOnHCsQbBs2TKtWbNGs2bNyo8oAAAAgEuYNGmSzp49K0kaOXKkkpOTtXDhQhmGoQkTJuj555+3OCEAAAAKgoV7F+pC2gX1r9Gfu+aRK/lSHBg3bpzOnz+vbdu2qX79+vL09HS81rZtW02bNi0/YgAAAAAuIygoSEFBQY7nY8eO1dixYy1MBAAAgIJq2cFlOp96XiPqjZC7zZKZ5OGC8mVaoZUrV2ry5Mlq3LjxVdWr8uXL6++//86PGAAAAIDLaNeunX7//fdsX9u/f7/atWuXz4kAAABQkEUfidYrW19R0qUkq6PAReRLcSAhIUGVKlXK9rW0tDRdvnw5P2IAAAAALiM6OloJCQnZvpaYmKiYmJh8TgQAAICCbtfpXYr4PkKHEw5bHQUuIF+KA5UrV9bmzZuzfW3r1q2qUaNGfsQAAAAACoVjx47Jx8fH6hgAAAAogE4mn9SETRP0w9EfrI6CAi5fJqC67777NG3aNNWtW1fdunWTJBmGoZ9++kkzZ85kMTUAAABA0vLly7V8+XLH8xdffFGlSpXK0iYlJUXR0dFq1KhRfscDAACAi0hNT9XMHTN14PwB3V/rfrnZ3KyOhAIoX4oDzz77rDZt2qRevXqpRIkSkqROnTrpzJkz6ty5s5544gmnHfull17SqlWrtHPnTnl6eur8+fNOOxYAAACQ6WbGob/99ps+//xzSVcuplm3bp1stqw3+9rtdtWrV08zZ850RmwAAIAiyzRNqyPkuf/9+T8dSTyiMY3HyM/Tz+o4KGDyZVohDw8P/e9//9OiRYvUtWtXdejQQR06dNDHH3+sFStWXPWFJy9dunRJ/fr10yOPPOK0YwAAAAD/djPj0IiICCUmJioxMVGmaWr9+vWO55mP06dPa/369apfv74T0wMAABQd58+f18yZM9W/f/8s2zdP36z9X+3XpaRLFiXLG7tO71LU5ijFp8ZbHQUFTL7cOSBdufKpf//+V3UyZ5s0aZIkaf78+fl6XAAAABRttzoOzcjIyMM0AAAAyM6aNWvUp08fJScnX3XnwMWzF7Xzg53a9fEutYpopeDGwRalvHVHEo9o0uZJmtRykop5FrM6DgqIfLlzwNWkpqYqISHB8UhKSrI6EgAAAJwoKSkpy/gvNTXV6kgAAABwsjVr1qhbt25KSUm59pRCppSemq6Nkzbq+Pbj+Rswjx1NOqpZO2cpw+QiFFzhtDsH2rVrl+O2hmFo7dq1zoqSa1OnTnVc6QUAAIDCLywsLMvzyMhIRUVF5XuOypUryzCMHLU1DEN//PGHkxMBAAAUTufPn1efPn1kmuaN79g0JVOmNk3dpB7zesjTzzN/QjrB9pPb9fOJn3V78O1WR0EB4LTiQHR0tPz9/VWhQoU833dUVNQNT97/9NNPatq06U3tPyIiQmPHjnU837lz51VfGAEAAFB4xMTEqGHDho7ndrs923bOHoeGhYXluDgAAACAm7dgwYJspxK6pv93B0HsulhV71ndueGc7Lu/vqM4AElOLA5UqVJFhw4dUkBAgIYNG6Z7771Xvr6+ebLvxx577IZrF4SGht70/u12e5YvhH5+rOQNAABQmPn5+cnf3/+G7Zw9DmWdLAAAAOczTVNvvfXWTb33wIoDqtajmktf0HHswjGrI6CAcFpx4ODBg4qJidHcuXP1+OOPa8yYMfrPf/6jYcOGqWXLlre076CgIAUFBeVRUgAAACBnGIcCAAC4vjNnztzc9IymdOH4BV1KvCS7f/Z3mroCD5uH1RFQQDh1QeKwsDB99NFHOnbsmKZPn65du3apdevWqlWrll599VWdOHHCmYeXJB0+fFg7d+7U4cOHlZ6erp07d2rnzp0sMgwAAACnyotx6KlTpxQREaEWLVqoWrVq2rNnjyTpvffe044dO5wVHQAAoFC71fOCl1Mu51ESa1QtXtXqCCggnHbnwD/5+/tr5MiRGjlypHbv3q3Zs2frueee05YtW7RkyRKnHnvixIlasGCB43mjRo0kSevXr1d4eLhTjw0AAICi61bHoX/++adatWql+Ph4NWjQQIcOHVJqaqok6ddff9WWLVs0b948p2QHAAAozG51CnF373w5peo0rcu1tjoCCgin3jnwb3v37tWCBQv0xRdfyDRN1ahRw+nHnD9/vkzTvOpBYQAAAADOdKvj0HHjxql48eI6cOCANmzYkGWxvNatW2vTpk1OSg4AAFC4BQYGqmrVqrlfN8CQfIN95VnM0znB8kF5v/KqG1TX6hgoIJxeHEhKStL777+vFi1aqE6dOlq2bJlGjx6tw4cP6+WXX3b24QEAAACXtHbtWkVGRiokJOSqL65ly5ZVXFycRckAAABcm2EYevzxx2/qva6+GHGfan1kM/L1enEUYE77m7BhwwYNHjxYwcHBGjNmjKpXr67169frwIEDeu655xQSEuKsQwMAAAAu7+LFiypZsmS2r124cEE2G1/qAAAAbtbgwYPl4+OT8zGVIbnZ3RTaLtSpuZypkn8lNQ9pbnUMFCBOmyArPDxc/v7+uu+++zRgwAD5+/tLkrZv355t+8aNGzsrCgAAAOByatSooe+++04dO3a86rUNGzaobl1uBwcAALhZxYsX15IlS9StWzfZbDZlZGRcu7Fx5W6DVhGt5OnnulMKPVDrAe4aQBZOXT0jISFBH3zwgT744INrtjFNU4ZhKD093ZlRAAAAAJcyYsQIjR07ViEhIbrvvvskSZcuXdIXX3yhWbNm6e2337Y4IQAAgGvr1KmTVq1apT59+ig5OTnLGk8O/++OgVYRrRTcODj/Q+aRJmWaqF6pelbHQAHjtOLAvHnznLVrAAAAoNAbNWqUdu7cqSeffFJPPfWUpCsLEZumqREjRmjw4MEWJwQAAHB9nTp10t9//62PPvpI06ZNy7Kuk1dJL9XsU1Oh7UPl6eu6dwx42Dw0pM4Qq2OgAHJacYAvKwAAAMCtmTNnjoYNG6ZVq1bpxIkTCgoKUvfu3dWyZUurowEAABQaxYsX1+jRo9WoUSO1adPGsb3FuBYqVaeUhcnyxr017lVpn9JWx0AB5NRphQAAAADcmubNm6t5cxaOAwAAcDbDMKyOkOdqlKihblW6WR0DBRQrUAAAAAAAAABAIVPMo5hGNx7NIsS4Ju4cAAAAAAoIm82WqyvW0tPTnZgGAAAArsrd5q6nmj6lIO8gq6OgAKM4AAAAABQQEydOzFIcmDdvnpKSktSjRw8FBwfr2LFjWrlypXx9fTVs2DALkwIAAKCgcjPcNLrRaNUKrGV1FBRwFAcAAACAAiIqKsrx84wZMxQcHKzvvvtOfn5+ju2JiYnq0KGDfHx8LEgIAACAgszT5qmxTceqUelGVkeBC2DCKQAAAKAAmjVrlsaNG5elMCBJxYoV07hx4zRr1iyLkgEAAKAgKutbVlNaT6EwgBzjzgEAAACgADp69Kjc3bMfrru7u+v48eP5nAgAAAAFVfuK7fVA7Qfk7e5tdRS4EIoDAAAAQAFUq1Ytvf766+rSpYs8PDwc2y9duqQZM2aoZs2aFqYDAABAQVDOr5xG1BvB+gK4KRQHAAAAgAJoypQpuueee1SlShX17t1bwcHBOn78uJYuXarjx49r2bJlVkcEAACARfw8/NS3el91rNRR7jZO8eLm8DcHAAAAKIC6deum1atX6/nnn9c777yjjIwMGYahO+64Q/PmzVOHDh2sjggAAIB85m64667Qu9SnWh/5efrd+A3AdVAcAAAAAAqo9u3bq3379kpOTta5c+dUokQJ+fj4WB0LAAAAFmgW3EwDaw1UsG+w1VFQSFAcAAAAAAo4Hx8figIAAABFVHm/8hpWd5jqBNWxOgoKGYoDAAAAAAAAAFDAeNg89J8a/1HXyl1ZVwBOwd8qAAAAAAAAAChAqgZU1aONHlU5v3JWR0EhRnEAAAAAAAAAAAqIrpW7amCtgfKweVgdBYWczeoAzhQbG6vhw4ercuXK8vb2VtWqVRUZGalLly5ZHQ0AAACFGONQAAAA5JaHzUNPNHpCg+sMpjCAfFGo7xz4/ffflZGRoffee0+33Xabdu/erREjRujChQt67bXXrI4HAACAQopxKAAAAHIjwDNA424fp9tK3GZ1FBQhhbo40LlzZ3Xu3NnxvEqVKtq3b5/effddvpQBAADAaRiHAgAAIKcqFquoZ+94VkHeQVZHQRFTqIsD2YmPj1fJkiWv2yY1NVWpqamO50lJSc6OBQAAAAslJSUpISHB8dxut8tut+fpMXIyDgUAAEDR0qRMEz3W8DH5ePhYHQVFUKFec+Df/vjjD7311lsaOXLkddtNnTpVAQEBjkdYWFg+JQQAAIAVwsLCsoz/pk6dmqf7z+k4FAAAAEWDIUP9qvfT002fpjAAy7hkcSAqKkqGYVz3sW3btizviYuLU+fOndWvXz89+OCD191/RESE4uPjHY+YmBhnfhwAAABYLCYmJsv4LyIiItt2zh6HAgAAoPAL9ArUxBYT1bd6X9kMlzw9i0LCJacVeuyxx9S/f//rtgkNDXX8HBcXp7Zt26pFixaaM2fODff/79vI/fz8bjorAAAACj4/Pz/5+/vfsJ2zx6EAAAAo3MIrhGtQ7UHy9fC1OgrgmsWBoKAgBQXlbIGOo0ePqm3btmrSpInmzZsnm41qHAAAAG4O41AAAADcjNLepTWi/gjVL1Xf6iiAg0sWB3IqLi5O4eHhqlixol577TWdOnXK8VpwcLCFyQAAAFCYMQ4FAACAJLkZbupepbv6VO8ju5v9xm8A8lGhLg588803OnjwoA4ePKjy5ctnec00TYtSAQAAoLBjHAoAAIBqxavpofoPqaJ/RaujANkq1Pc2DxkyRKZpZvsAAAAAnIVxKAAAQNHl5ealoXWHanKryRQGUKAV6jsHAAAAAAAAACC/1CpZS6MajlJpn9JWRwFuiOIAAAAAAAAAANwCm2z6T43/6O7b7pbNKNSTtaAQoTgAAAAAAAAAADepmEcxjWkyRnWD6lodBcgVigMAAAAAAAAAcBPK+JTRc82eU7BvsNVRgFyjOAAAAAAAAAAAuVTOr5wiW0QqwB5gdRTgpjABFgAAAAAAAADkQmmf0nqh+QsUBuDSKA4AAAAAAAAAQA55uXlp3O3jVMKrhNVRgFtCcQAAAAAAAAAAcuih+g+pQrEKVscAbhlrDgAAAAAAAAAo8urVq6eNGzdq4W8Lte/cPgWEXj1l0O1lblfLkJYWpAPyHsUBAAAAAAAAAEVeQECAWrdurU2em3T25NmrXnc33HV/7ftlGIYF6YC8x7RCAAAAAAAAAHADbcq3UbBvsNUxgDxDcQAAAAAAAAAAbqBblW5WRwDyFMUBAAAAAAAAALiOOoF1VL5YeatjAHmK4gAAAAAAAAAAXEe7iu2sjgDkOYoDAAAAAAAAAHAN3u7euiP4DqtjAHmO4gAAAABy7NSpU0pPT7c6BgAAAJBvWoW0kqebp9UxgDxHcQAAAAA5lpGRobNnz1odAwAAAMg3bcq3sToC4BQUBwAAAJArx48ftzoCAAAAkC9Ke5dW9RLVrY4BOAXFAQAAAORKXFyc1REAAACAfNGqXCsZhmF1DMApKA4AAAAgV44fPy7TNK2OAQAAADhd87LNrY4AOA3FAQAAAORKamqqTp48aXUMAAAAwKlKeZdSJf9KVscAnIbiAAAAAHLtp59+4u4BAAAAFGoNSzdkSiEUaoW+ONCzZ09VrFhRXl5eKlu2rB544AHmyQUAALgJTZs2VaNGjfTSSy8pLi5OGzZsUEZGhtWxCizGoQAAAK6tXlA9qyMATlXoiwNt27bVZ599pn379mnJkiX6448/1LdvX6tjAQAAuJzjx4/r2LFjSkhIkCTt27dPa9asUWpqqsXJCibGoQAAAK6tZsmaVkcAnMrd6gDO9uSTTzp+rlSpksaPH6977rlHaWlp8vDwyPY9qampWb7kJiUlOT0nAACAKzpy5IiWLFmiVq1aqWLFii5723VSUpKj6CFJdrtddrv9lvZ5M+NQAAAAFAylvUsrwB5gdQzAqQr9nQP/dPbsWS1cuFAtW7a87heyqVOnKiAgwPEICwvLx5QAAACuJSkpSWvWrNHKlSt17Ngxq+PclLCwsCzjv6lTp+bp/nM6DgUAAEDBEBoQanUEwOmKRHHg2Wefla+vrwIDA3X48GEtX778uu0jIiIUHx/veMTExORTUgAAANd17NgxrVixQitWrNDhw4ddasHimJiYLOO/iIiIPNlvbsehAAAAKBjK+5W3OgLgdC5ZHIiKipJhGNd9bNu2zdH+mWee0Y4dO/TNN9/Izc1NgwYNuu6XVbvdLn9/f8fDz88vPz4WAABAoXDs2DGtXr1an332mX799VelpKRYHemG/Pz8soz/rjWlkLPHoQAAACgYyvqVtToC4HQuuebAY489pv79+1+3TWhoqOPnoKAgBQUFqXr16qpVq5YqVKigLVu2qEWLFk5OCgAAUHTFx8dry5Yt+vHHH1W+fHlVq1ZNoaGhcnd3ySGoJMahAAAARUUp71JWRwCcziW/mWV+yboZmVdq/XPBYQAAADiPaZo6cuSIjhw5Ig8PD1WtWlW1a9e+6fGclRiHAgAAFA2B3oFWRwCcziWLAzm1detWbd26Va1bt1aJEiV06NAhTZw4UVWrVuVqLQAAAAukpaXp999/1++//66QkBDdfvvtKlOmjNWx8hzjUAAAANdWwl7C6giA07nkmgM55e3traVLl6p9+/aqUaOGhg0bprp16yomJuaa88gCAADgagcOHFBCQoIkKSUlRSdOnLjlfcbFxWn58uVav369Lly4cMv7K0gYhwIAALguXw9febh5WB0DcLpCfedAvXr1tG7dOqtjAAAAuLR58+bpwQcfVEZGhqQr0+JERkZq0KBBatmy5S3v/8CBAzp06JBq166tBg0ayMfH55b3aTXGoQAAAK6rmGcxqyMA+aJQ3zkAAACAW3PgwIEshYFMpmnqo48+0smTJ/PkOOnp6dq1a5c+/fRTbd68WZcuXcqT/QIAAAC55e/pb3UEIF9QHAAAAMA1ffjhhzIMI9vXDMPQpk2b8vR4mUWCZcuWKS0tLU/3DQAAAOQExQEUFRQHAAAAcE2xsbEyTTPb10zT1JkzZ5xy3Pj4eO4eAAAAgCX8PP2sjgDkC4oDAAAAuKbQ0NDr3jkQGBjolOPecccd8vX1dcq+AQAAgOvxcXf9NbCAnKA4AAAAgGsaNmzYde8caNWqVZ4fs169eqpfv36e7xcAAADICR8PigMoGigOAAAA4JqqVaumuXPnymbLOmw0DEODBg1S6dKl8+xYhmHo9ttvV/Pmza95twIAAADgbHY3u9URgHxBcQAAAADXNWTIEO3bt0/FihWTJNntdk2ePFktW7bMs2NUqFBBvXr1UqNGjSgMIMdSU1PVsGFDGYahnTt3Wh0HAAAUEp5unlZHAPKFu9UBAAAAUPDddttt8vf3V2Jiory9vfPkjgF/f39VrVpV1atXV0BAQB6kRFEzbtw4hYSE6JdffrE6CgAAKETcDDerIwD5guIAAAAA8o2np6eqVaum6tWrKygoiLsEcNO+/vprffPNN1qyZIm+/vprq+MAAIBCxN/T3+oIQL6gOAAAAACn8/b2VsOGDVWzZk15eHhYHQcu7sSJExoxYoSWLVsmH5+cLRiYmpqq1NRUx/OEhARnxQMAAC7Ow43xKooGigMAAABwGm9vb9WrV0916tShKIA8YZqmhgwZopEjR6pp06aKjY3N0fumTp2qSZMmOTccAAAA4EJYkBgAAAB5rkyZMgoPD9fAgQPVsGFDCgO4oaioKBmGcd3Htm3b9NZbbykhIUERERG52n9ERITi4+MdjyNHjjjpkwAAAACugTsHAAAAkCfsdruqV6+uWrVqqXjx4lbHgYt57LHH1L9//+u2CQ0N1ZQpU7RlyxbZ7fYsrzVt2lT33XefFixYkO177Xb7Ve8BAAAAijKKAwAAALglnp6eatiwIVMH4ZYEBQUpKCjohu3efPNNTZkyxfE8Li5OnTp10uLFi9WsWTNnRgQAAAAKFYoDAAAAuGllypRRhw4d5Ovra3UUFBEVK1bM8tzPz0+SVLVqVZUvX96KSAAAAIBLojgAAACAHAkODlZGRobj7oBSpUqpW7ducndnSAkAAAAAroZvcgAAAMiRbdu26cSJE1q+fLlsNpvCw8MpDMByoaGhMk3T6hgAAACAy7FZHQAAAACup169eipRooTVMQAAAAAAN4niAAAAAHLF09NTjRo1sjoGAAAAAOAWUBwAAABArlSrVk2enp5WxwAAAAAA3AKKAwAAAMiVChUqWB0BAAAAAHCLikxxIDU1VQ0bNpRhGNq5c6fVcQAAAFxWYGCg1RFcCuNQAAAAAAVRkSkOjBs3TiEhIVbHAAAAcGlubm7y8fGxOoZLYRwKAAAAoCAqEsWBr7/+Wt98841ee+01q6MAAAC4NB8fHxmGYXUMl8E4FAAAAEBB5W51AGc7ceKERowYoWXLluX4KrfU1FSlpqY6niclJTkrHgAAgEux2+1WR3CKpKQkJSQkOJ7b7fZb/qw3Mw4FAAAAgPxSqO8cME1TQ4YM0ciRI9W0adMcv2/q1KkKCAhwPMLCwpyYEgAAwHW4ublZHcEpwsLCsoz/pk6dekv7u9lxKAAAAADkF5csDkRFRckwjOs+tm3bprfeeksJCQmKiIjI1f4jIiIUHx/veMTExDjpkwAAAKAgiImJyTL+u9b40dnjUAAAAADIL4ZpmqbVIXLr9OnTOn369HXbhIaGqn///lqxYkWWeXHT09Pl5uam++67TwsWLMjR8bZv364mTZro559/VuPGjW8pOwAAAAqO3I7z8nscCudJSEhQQECA4uPj5e/vb3UcAAAAIN+55JoDQUFBCgoKumG7N998U1OmTHE8j4uLU6dOnbR48WI1a9bMmREBAABQCDEOBQAAAFBYuGRxIKcqVqyY5bmfn58kqWrVqipfvrwVkQAAAFAEMA4FAAAAUNC55JoDAAAAAAAAAADg5hXqOwf+LTQ0VC64xAIAAABcHONQAAAAAAUNdw4AAAAAAAAAAFDEUBwAAAAAAAAAAKCIoTgAAAAAAAAAAEARU6TWHEBWx44d07Fjx6yOgRsoW7asypYta3UMXAd9yTXQl1wD/angoy8BAAAAQOFAcSAHypYtq8jIyEL1RTg1NVUDBgxQTEyM1VFwA2FhYVqzZo3sdrvVUZAN+pLroC8VfPQn11DY+lJhHOcBNyM1NVVTp05VREREoenfgKuhHwIFA30RRYlhmqZpdQjkv4SEBAUEBCgmJkZ+fn5Wx8E1JCUlKSwsTPHx8fL397c6DrJBX3IN9CXXQH8q+OhLKExM01RiYqKKFSsmwzCsjmO5zH+D6d+AdeiHQMFAX0RRwp0DRVzDhg35h64AS0hIsDoCcoi+VLDRl1wL/angoi+hMDEMg39rAAAAUKSxIDEAAAAAAAAAAEUMxQEAAAAAAAAAAIoYigNFlN1uV2RkJAurFHD8fyr4+H/kGvj/5Br4/1Tw8f8IKLzo34D16IdAwUBfRFHCgsQAAAAAAAAAABQx3DkAAAAAAAAAAEARQ3EAAAAAAAAAAIAihuIAAAAAAAAAAABFDMUBAAAAAAAAAACKGIoDKLLmz58vwzBkGIaio6Ovet00Td12220yDEPh4eE33F94eLhjf4ZhyNvbWw0aNNAbb7yhjIwMR7shQ4YoNDQ07z7ITcr8/Nu2bbM6CoogZ/Y/m82mYsWK6bbbblO/fv30xRdfZOmDgCuJioqSYRi5fl92v2tefvllLVu2LG+C5ZBhGIqKisr1+2JjY2UYhubPn+/Y9sMPPygqKkrnz5/Ps3wAAAAAUJRRHECRV6xYMc2dO/eq7TExMfrjjz9UrFixHO+rSpUq2rx5szZv3qzFixerXLlyevLJJxUREZGXkYFCwxn974cfftCyZcs0fvx4paSkqF+/fgoPD1d8fHxeRgdcjhXFgbz0ww8/aNKkSRQHAAAAACCPUBxAkXfvvfdqyZIlSkhIyLJ97ty5atGihSpWrJjjfXl7e6t58+Zq3ry5evbsqeXLl6tKlSp6++23lZaWltfRAZfnrP7Xvn17Pfjgg1q5cqU+/PBDbdy4UQ899NB132+aplJSUm7qcwAAAAAAALgaigMo8gYMGCBJ+vTTTx3b4uPjtWTJEg0bNuyW9u3h4aEmTZooOTlZp06duma7d955R23atFHp0qXl6+urevXqafr06dkWFFavXq327dsrICBAPj4+qlWrlqZOnZqlzbZt29SzZ0+VLFlSXl5eatSokT777LNsj33u3DkNHTpUJUuWlK+vr3r06KFDhw5d1e7DDz9UgwYN5OXlpZIlS6pXr17au3dvLv9EgKyc2f8yDR06VF27dtXnn3+uv/76y7HdMAw99thjmj17tmrVqiW73a4FCxYoOjo62+mOspvmRJLef/99Va9eXXa7XbVr19aiRYsKzPRhcC2rVq1Sw4YNZbfbVblyZb322mtXtTFNU7NmzVLDhg3l7e2tEiVKqG/fvtn+u/1PhmHowoULWrBggWMKrswpu06dOqVRo0apdu3a8vPzU+nSpdWuXTtt3Lgxx9kTEhI0YsQIBQYGys/PT507d9b+/fuzbXvgwAENHDhQpUuXlt1uV61atfTOO+9cd/9RUVF65plnJEmVK1e+alqyxYsX66677lLZsmXl7e2tWrVqafz48bpw4UKOPwMAAAAAFDUUB1Dk+fv7q2/fvvrwww8d2z799FPZbDbde++9t7z/P/74Q+7u7ipRosR12wwcOFAff/yxVq5cqeHDh+vVV1/Vww8/nKXd3Llz1bVrV2VkZGj27NlasWKFRo8erb///tvRZv369WrVqpXOnz+v2bNna/ny5WrYsKHuvffeq05qStLw4cNls9m0aNEivfHGG9q6davCw8OzTNswdepUDR8+XHXq1NHSpUs1c+ZM/frrr2rRooUOHDhwy39GKLqc3f8y9ezZU6ZpXnWyc9myZXr33Xc1ceJErVmzRnfeeWeu9jtnzhw99NBDql+/vpYuXaoJEyZo0qRJ2a6jAFzP2rVrdffdd6tYsWL673//q1dffVWfffaZ5s2bl6Xdww8/rDFjxqhDhw5atmyZZs2apT179qhly5Y6ceLENfe/efNmeXt7q2vXro7p72bNmiVJOnv2rCQpMjJSq1at0rx581SlShWFh4fn6O+yaZq655579PHHH+upp57Sl19+qebNm6tLly5Xtf3tt990++23a/fu3ZoxY4ZWrlypbt26afTo0Zo0adI1j/Hggw/q8ccflyQtXbrU8RkaN24s6UrBoWvXrpo7d65Wr16tMWPG6LPPPlOPHj1umB9A7pw6dUqJiYlWxwCKtNjYWC1fvlwRERFavny5Dh48aHUkoEjat2+fXn/9dfXv318vvviitm7danUkIPdMoIiaN2+eKcn86aefzPXr15uSzN27d5umaZq33367OWTIENM0TbNOnTpmWFjYDfcXFhZm1qlTx0xLSzPT0tLMuLg4c/z48aYks1+/fo52gwcPNitVqnTN/aSnp5tpaWnmRx99ZLq5uZlnz541TdM0ExMTTX9/f7N169ZmRkbGNd9fs2ZNs1GjRmZaWlqW7d27dzfLli1rpqenZ/n8vXr1ytJu06ZNpiRzypQppmma5rlz50xvb2+za9euWdodPnzYtNvt5sCBA2/4ZwP8m7P637V8/fXXpiRz2rRpjm2SzICAAEcfy5SZZ/369Vm2//nnn6Ykc968eaZpXumrwcHBZrNmzbK0++uvv0wPD4/r9nPg35o1a2aGhISYKSkpjm0JCQlmyZIlzczh2ubNm01J5owZM7K898iRI6a3t7c5btw4x7bsftf4+vqagwcPvmGWy5cvm2lpaWb79u2v+h2Rncz+NXPmzCzbX3rpJVOSGRkZ6djWqVMns3z58mZ8fHyWto899pjp5eXl6I//7m+maZqvvvqqKcn8888/r5snIyPDTEtLM2NiYkxJ5i+//HLDzwAgZ7Zs2WIWL17cnDZtmpmUlGR1HKBI+uGHH8y6deuaVapUMX19fU3DMMyePXuae/bssToaUKRs2rTJrFy5slmnTh0zNDTUNAzDbNOmjXn06FGrowG5wp0DgKSwsDBVrVpVH374oXbt2qWffvrppqY02bNnjzw8POTh4aGQkBDNmDFD9913n95///3rvm/Hjh3q2bOnAgMD5ebmJg8PDw0aNEjp6emOaRl++OEHJSQkaNSoUTIMI9v9HDx4UL///rvuu+8+SdLly5cdj65du+rYsWPat29flvdkts3UsmVLVapUSevXr5d05WrTlJQUDRkyJEu7ChUqqF27dlq7dm2O/3yA7ORV/7se0zSz3d6uXbvr3tVzPfv27dPx48f1n//8J8v2ihUrqlWrVje1TxRNFy5c0E8//aTevXvLy8vLsb1YsWJZrnxfuXKlDMPQ/fffn+Xf9+DgYDVo0OCW7liZPXu2GjduLC8vL7m7u8vDw0Nr167NMn1cenp6luNmZGRIkuP3xb9/nwwcODDL84sXL2rt2rXq1auXfHx8rvoddfHiRW3ZsuWm8h86dEgDBw5UcHCw4/doWFiYJDEFHpBH9u/frwceeEDx8fGaNGmS3n33XSUnJ1sdCyhStm/frm7duqldu3b673//q9OnT2vq1KlasWKFVq9eLena414Aeeenn35Sly5ddPfdd+uLL77Qn3/+qTlz5mjjxo3XvZsXKIjcrQ4AFASGYWjo0KF68803dfHiRVWvXj3X04tIUtWqVfXf//5XhmHIy8tLlStXlo+Pz3Xfc/jwYd15552qUaOGZs6cqdDQUHl5eWnr1q169NFHHQukZq5ZUL58+WvuK/OX0NNPP62nn3462zanT5/O8jw4OPiqNsHBwTpz5owkOf5btmzZq9qFhITo22+/ve7nA24kr/rf9WSuNRASEpJle3Z/r3Mqs2+UKVPmqtfKlCmjP//886b3jaLl3LlzysjIuOa/x5lOnDgh0zSz/TsnSVWqVLmp47/++ut66qmnNHLkSL344osKCgqSm5ubXnjhhSwn1tu3b6+YmBjH88GDB2v+/Pk6c+aM3N3dFRgYeM3s0pU+c/nyZb311lt66623ss3y799ROZGUlKQ777xTXl5emjJliqpXry4fHx8dOXJEvXv3ZqFxIA8kJibq1Vdf1eXLlzVr1iz99NNPGj9+vCRp1KhRNxzvArh1J0+e1AsvvKC7775bEydOdPzeffbZZ/XNN9/ok08+0RNPPCE3NzeLkwKF25EjR/TYY4+pb9++mjhxoooXLy5J6tixo2rUqCFvb28dOnRIdrtd5cqVk3SlaHetizwBq1EcAP6fIUOGaOLEiZo9e7Zeeumlm9qHl5eXmjZtmqv3LFu2TBcuXNDSpUtVqVIlx/adO3dmaVeqVClJyrK+wL8FBQVJkiIiItS7d+9s29SoUSPL8+PHj1/V5vjx47rtttskyTHoPHbs2FXt4uLiHMcEbkVe9L/r+eqrr2QYhtq0aZNle3YDtMwrt1NTU7Ns//dJy8y+kd2VIdn1K+BaSpQoIcMwrvnvcaagoCAZhqGNGzfKbrdf1Ta7bTnxySefKDw8XO+++26W7f+eU/y9997Lsi3z3//AwEBdvnxZZ86cyVIg+PfnKVGihNzc3PTAAw/o0UcfzTZL5cqVc51/3bp1iouLU3R0tONuAUlZ1s4BcGsuXLigEydOqEOHDho5cqR69uyp9PR0CgRAPtq5c6d27Niht99+2/H7Nj09XW5ubqpevbq++eYbZWRkUBwAnOzPP//Ubbfdpv79+6tEiRKOu3V++eUXHTlyRH379tX+/ftVpkwZTZw4USNGjKAwgAKN4gDw/5QrV07PPPOMfv/9dw0ePDjfjpv5S+KfJ3VM07xqKqKWLVsqICBAs2fPVv/+/bP95VKjRg1Vq1ZNv/zyi15++eUcHX/hwoXq06eP4/kPP/ygv/76Sw8++KAkqUWLFvL29tYnn3yifv36Odr9/fffWrdunfr27ZvzDwtcgzP737x58/T1119r4MCBqlix4g3bh4aGSpJ+/fVXderUybH9q6++ytKuRo0aCg4O1meffaaxY8c6th8+fFg//PDDVXcpANfi6+urO+64Q0uXLtWrr77qKFAlJiZqxYoVjnbdu3fXK6+8oqNHj141nVVO2O32bK+iNwzjqsLCr7/+qs2bN6tChQqObf8uLmdq27atpk+froULF2r06NGO7YsWLcrSzsfHR23bttWOHTtUv359eXp65jq/pKs+Q3a/R6UrxQwAeaN06dKaPHmyGjZsKOnKnXhRUVEyDCPbAgFXSAJ5r1mzZurdu7fuuecex7bMflaxYkVdvHhRFy9elIeHh0UJgaKhefPm8vDwUIsWLSRd6Yc///yzBg4cqA4dOuiee+6Ru7u7Zs+erYcffliVKlXSXXfdZXFq4NooDgD/8Morr+T7MTt27ChPT08NGDBA48aN08WLF/Xuu+/q3LlzWdr5+flpxowZevDBB9WhQweNGDFCZcqU0cGDB/XLL7/o7bfflnTlZEiXLl3UqVMnDRkyROXKldPZs2e1d+9ebd++XZ9//nmW/W7btk0PPvig+vXrpyNHjuj5559XuXLlNGrUKElS8eLF9cILL+i5557ToEGDNGDAAJ05c0aTJk2Sl5eXIiMj8+cPCoXerfa/lJQUx3zlKSkpOnTokJYtW6aVK1cqLCxMs2fPztF+goOD1aFDB02dOlUlSpRQpUqVtHbtWi1dujRLO5vNpkmTJunhhx9W3759NWzYMJ0/f16TJk1S2bJlZbOxrA9y7sUXX1Tnzp3VsWNHPfXUU0pPT9e0adPk6+urs2fPSpJatWqlhx56SEOHDtW2bdvUpk0b+fr66tixY/r+++9Vr149PfLII9c8Rr169RQdHa0VK1aobNmyKlasmGrUqKHu3bvrxRdfVGRkpMLCwrRv3z5NnjxZlStX1uXLl2+Y/a677lKbNm00btw4XbhwQU2bNtWmTZv08ccfX9V25syZat26te6880498sgjCg0NVWJiog4ePKgVK1Zo3bp1182fuY/BgwfLw8NDNWrUUMuWLVWiRAmNHDlSkZGR8vDw0MKFC/XLL7/cMDuAnLHZbI7CwOXLl+Xu7q7Q0FDHOHD8+PEyTVNPPPGEPD099fPPP+v06dPq3LmzhamBwiM9PV0BAQGO73yZBbjM8abdbldycrJSUlJUrFgxSVfu4Dt8+LDuuOMOy3IDhY1pmvL09HQUBtLT05Wenq4xY8ZowIABeu211xQQECDpykVnd911l3bu3ElxAAUaxQHAYjVr1tSSJUs0YcIE9e7dW4GBgRo4cKDGjh2rLl26ZGk7fPhwhYSEaNq0aXrwwQdlmqZCQ0OzXGndtm1bbd26VS+99JLGjBmjc+fOKTAwULVr1872StO5c+fq448/Vv/+/ZWamqq2bdtq5syZKlmypKNNRESESpcurTfffFOLFy+Wt7e3wsPD9fLLL6tatWrO+8MBcuHQoUOOQZqvr6/KlCmjxo0b6/PPP1fv3r1zdbL+448/1uOPP65nn31W6enp6tGjhz799NOrpg176KGHZBiGpk+frl69eik0NFTjx4/X8uXLdfjw4Tz9fCjcOnbsqGXLlmnChAm69957FRwcrFGjRiklJUWTJk1ytHvvvffUvHlzvffee5o1a5YyMjIUEhKiVq1a3fDL/8yZM/Xoo4+qf//+Sk5OVlhYmKKjo/X8888rOTlZc+fO1fTp01W7dm3Nnj1bX375ZY4WObbZbPrqq680duxYTZ8+XZcuXVKrVq30v//9TzVr1szStnbt2tq+fbtefPFFTZgwQSdPnlTx4sVVrVo1de3a9brHCQ8PV0REhBYsWKD3339fGRkZWr9+vcLDw7Vq1So99dRTuv/+++Xr66u7775bixcvVuPGjW+YH8C1ZU5Z8k/u7v//V8h/FggiIiIkSU2bNtUjjzyikiVLqlOnTtxBANyi7PphZr/KLBJknrD09vaWdGW9rYEDB6p06dL68ssv8z0zUBhl1xfd3Nzk5uamJUuWKCAgQHa73dEvmzdvLrvdrosXL1qUGMgZw2QpewAA8sz58+dVvXp13XPPPZozZ47VcQAAuCXJycnavXu3mjRpcs25zP/++2+98MILWrRokTw9PVW1alX99NNPTG8C5JFr9cOMjAzZbDa9+uqr+r//+z/9/vvvio+P17333quzZ89q165d9EMgD2XXF7ObSi8jI0OrV6/W448/rpkzZ6p79+5WxAVyhDkPAAC4ScePH9fjjz+upUuXKiYmRh999JHatm2rxMREPfHEE1bHAwDgpqSnpzt+HjdunMLDw7Vhw4Ys2yU5FmEsX768evbsqbS0NDVs2FDbtm2Th4dHjqYmA5C9nPTDzDtj3dzclJKSoj179mjAgAGKj493FAboh8CtuVFfzCwMZGRkSLryu3H//v168cUXVbVq1RveHQtYjeIAAAA3yW63KzY2VqNGjVLHjh01evRolSlTRtHR0apTp47V8QAAyLXLly/Lzc1NycnJWrBggWw2my5evKjHHntMMTExjpMf0pUTIhkZGdq0aZOee+45NWzYUOvXr5e7u7tjbQIAuZebfihJnp6ecnNz0+DBg3XmzBnt3LnTURigHwI3Lzd90Waz6dy5c1qxYoWGDBmilJQUrVq1Sjab7ariOlCQMK0QAAAAAMAxNUJiYqKaNWumsmXLqkaNGjp//ryio6Pl5uamBQsWKDw8PMtaPpMnT9b777+vQ4cOcUISuEU30w9nzJihZ555Rm3atNG3335LPwTyQG77ommaevjhhx0Xin3++ecUy+ESKA4AAAAAACRdmT6hb9++OnLkiD7//HNVrlxZkrRlyxY98cQTiouL04IFCxQWFuaYb/nSpUtyd3eXzWbjJAiQB3LaD9u0aSN3d3edPXtWjzzyiBYuXMjJSCAP5bYvJiQkKCYmRt26deN3IlwG0woBFoqNjZVhGJo/f77VUQCXRl8CACBvpKamau/evWrWrJkqVarkWFegefPm+r//+z9dunRJjz/+uDZs2OB4zdPTUzabTRkZGZwEAfJATvvhxo0bdenSJZUsWVKLFy+mMADksdz0xcuXL8vf3189evTgdyJcCsUBwEJly5bV5s2b1a1bN6ujAC6NvgQAwM35543kGRkZSklJUVxcnOOEf+Z2SWrZsqXatGmjvXv3asSIETpw4ECW1/851RCAnLuVfhgbGytJjoWHORkJ3Lxb6YuHDh2S9P8vYMzvRLgK/qYCFrLb7WrevLlKlSpldRTApdGXAADIvYyMDBmG4TipaLPZVLJkSXXv3l0fffSR1q1bJ8MwZBiG44RJ8eLFNWbMGPn7+2vEiBGO9wG4OXnVDykKALcmr/pi5pR7gKtgFAfcoqioKBmGoV9//VX9+vVTQECASpYsqbFjx+ry5cvat2+fOnfurGLFiik0NFTTp093vDe7qVAy97dnzx4NGDBAAQEBKlOmjIYNG6b4+PjrvjeTYRiKiopyPD916pQeeughVahQQXa7XaVKlVKrVq303XffOeOPBLgp9CUAAPKXzWbTxYsX1bNnT73wwguSrvzu69Wrl9zc3PTcc885ToZkZGTowIED2r17txo3bqy+fftq79692r9/v8WfAnBt9EOgYKAvoqiitAzkkf/85z+6//779fDDD+vbb7/V9OnTlZaWpu+++06jRo3S008/rUWLFunZZ5/Vbbfdpt69e193f3369NG9996r4cOHa9euXYqIiJAkffjhh7nO9sADD2j79u166aWXVL16dZ0/f17bt2/XmTNnbuqzAs5EXwIAIP+cOHFCp06d0qeffipfX1+NHz9e/fr1U1xcnF5++WX16dNHAwcOVGpqqn744Qd5eXnp/vvv18yZM+Xp6SkfHx+rPwLg8uiHQMFAX0RRRHEAyCMPPfSQxo4dK0nq0KGDvvnmG7399ttaunSpevXqJUkKDw/XypUrtXDhwhue0Bw+fLieeeYZx/4OHjyoDz/8UHPnzpVhGLnKtmnTJj344IOO29wk6e67787VPoD8Ql8CACB/ZGRkqFKlSlq4cKFGjx6t2bNnKyMjQ88995yeeOIJlS9fXsuXL9eiRYtUrlw5NW7cWPPnz9fly5e1atUq1a5dW/7+/lZ/DMCl0Q+BgoG+iKKK4gCQR7p3757lea1atfTLL7+oS5cujm3u7u667bbb9Ndff91wfz179szyvH79+rp48aJOnjypMmXK5CrbHXfcofnz5yswMFAdOnRQkyZN5OHhkat9APmFvgQAgHNcvnz5qnnJMzIyVL16dc2cOVNPPPGE5syZI5vNpvHjx6tPnz7q06ePzp49q5IlS0q6clXluHHjtHXrVn3//fecCAFyiX4IFAz0ReAK1hwA8kjmL4dMmbeUeXl5XbX94sWLN9xfYGBglud2u12SlJKSkutsixcv1uDBg/XBBx+oRYsWKlmypAYNGqTjx4/nel+As9GXAABwDnd3d124cEGTJk3SwYMHZbPZHHMn16hRQ2+++aYqVKigV155Ra+//rrjfQEBAZKkL7/8Ug899JC+//57xcTEqG7dulZ9FMBl0Q+BgoG+CFxBcQBwUZknSlNTU7Nsz27u86CgIL3xxhuKjY3VX3/9palTp2rp0qUaMmRIfkQFCjT6EgCgsEtPT3f8vHjxYk2aNEnTpk1TbGysDMOQYRhKT09X9erV9fbbbystLU3vvPOOnn/+eUmSm5ubJKlVq1a6++67tXbtWjVo0MCSzwK4KvohUDDQF4GsmFYIcFFlypSRl5eXfv311yzbly9fft33VaxYUY899pjWrl2rTZs2OTMi4BLoSwCAwiw9PV1ubm46c+aMpk+frmnTpunQoUN69913lZGRoRdeeEGhoaGO9hUrVnRMu7d//36ZpinDMGSapkqXLq2hQ4fmes0eoKijHwIFA30RuBrFAcBFGYah+++/Xx9++KGqVq2qBg0aaOvWrVq0aFGWdvHx8Wrbtq0GDhyomjVrqlixYvrpp5+0evXqGy7kChQF9CUAQGFlmqbc3NyUkpKi9u3bq1ixYjp8+LCmTJmi1NRUzZ07V5IUERGh2267TaZp6rffflN4eLieeeYZ1ahRw3ESJPPkBydBgNyhHwIFA30RyB7FAcCFzZgxQ5I0ffp0JSUlqV27dlq5cmWWSreXl5eaNWumjz/+WLGxsUpLS1PFihX17LPPaty4cRYlBwoW+hIAoLDJvDrSNE0dPXpUZcqU0Ztvvqng4GBJ0quvvipJmj9/vk6dOqUnnnhCly9f1uTJk1W8eHHVqlVL0pXFGW02ZqMFbgb9ECgY6IvAtRmmaZpWhwAAAAAA3Lx/XsmYKSUlRWFhYSpevLi8vb21dOlSubm56fLly3J3v3Kd2JQpU/Txxx/rwIEDCgkJUWhoqNavXy8PD49s9wng2uiHQMFAXwRyjuIAAAAAABQS/7yqcfv27br33nt17NgxdezYUV9++aXS09Nls9mUkZHhWFRx165dOnz4sCSpc+fOV50sAZA79EOgYKAvAjdGcQAAAAAAXNjRo0e1detWLV68WGfPnlXp0qXVt29fdevWTTt27NDjjz+un376SQsXLtSAAQMkXbmq0jTNbKdHyJx+AUDO0Q+BgoG+COQOxQEAAAAAcFHbtm3TM888o7///lvu7u4yDENHjx5VYmKi+vXrp/fee0+xsbEaOnSo9uzZo08//VR9+vSRlP20CwByj34IFAz0RSD3WEUDAAAAAFzQ999/r06dOqlKlSqaOXOm9u7dqx9//FE7d+5U586d9fnnn6tXr16qXLmy5syZo/r162vgwIFasmSJJHESBMgD9EOgYKAvAjeHOwcAAAAAwMV8//33ateunR599FE999xzKlWqlKSsVz4OGjRIn3zyiR544AF9+OGHiomJUUREhHbt2qU5c+bo/vvvt/IjAC6PfggUDPRF4OZx5wCKnC+++EKGYWjx4sVXvdagQQMZhqE1a9Zc9VrVqlXVuHHj6+57yJAhMgzD8bDb7apRo4YiIyN18eJFR7uoqKgCUZWOjo6WYRj64osvrI6CIiI/+5+vr69CQ0PVs2dPzZs3T6mpqXn2OQAAsNKOHTvUpk0bjRw5Ui+//PJVJ0HS09MlSR999JHatWunzz//XD///LPatWunF198UcHBwfrggw+s/AiAy6MfAgUDfRG4NRQHUOSEh4fLMAytX78+y/azZ89q165d8vX1veq1v//+W4cOHVLbtm1vuH9vb29t3rxZmzdv1rJly9SsWTNNnjxZgwcPztPPAbii/Ox/K1eu1OTJk+Xr66sRI0aoSZMm+vvvv/P08wAAkN/S09O1YsUKSZKHh4f+eSN45sUnbm5uunz5siRp2rRpunjxomPahLvuukuLFy/W2rVr8zk5UHjQD4GCgb4I3Dp3qwMA+S0oKEh169ZVdHR0lu0xMTFyd3fX8OHDrzo5mfk8JycnbTabmjdv7njepUsXxcbG6rPPPtPrr7+ucuXK3fqHAFxUfvc/6crto0OHDlX37t3Vt29fbdmy5br7SElJkbe3dw4+DQAA+c/NzU2jR49WcnKypk+fLpvNpqioKPn6+mZp5+5+5atexYoVFRAQkOUOuttvv13SlZMqbm5u+RceKCToh0DBQF8Ebh13DqBIatu2rfbt26djx445tkVHR+v2229X165d9fPPPysxMTHLa25ubrrzzjtv6niZJyv/+uuva7ZZvHix7rrrLpUtW1be3t6qVauWxo8frwsXLlzV9scff1SPHj0UGBgoLy8vVa1aVWPGjMnS5sCBAxo4cKBKly4tu92uWrVq6Z133sn22BcvXtTYsWMVHBwsb29vhYWFaceOHVe1++qrr9SiRQv5+PioWLFi6tixozZv3pyLPwkg//ufdOWKkBEjRujHH3/Uhg0bHNtDQ0PVvXt3LV26VI0aNZKXl5cmTZqk2NhYGYah+fPnX7UvwzAUFRWVZdvy5ctVv3592e12xwJYBWX6MABA4VO8eHE999xzeuqppzRjxgxFRUUpOTk5S5vMqydtNpsuXryo8uXLX7UfToIAN49+CBQM9EXg1lAcQJGUeQXyP69eXr9+vcLCwtSqVSsZhqGNGzdmea1x48YKCAi4qeMdPHhQkhxz32XnwIED6tq1q+bOnavVq1drzJgx+uyzz9SjR48s7dasWaM777xThw8f1uuvv66vv/5aEyZM0IkTJxxtfvvtN91+++3avXu3ZsyYoZUrV6pbt24aPXq0Jk2adNWxn3vuOR06dEgffPCBPvjgA8XFxSk8PFyHDh1ytFm0aJHuvvtu+fv769NPP9XcuXN17tw5hYeH6/vvv7+pPxcUTfnd/zL17NlTkrIUByRp+/bteuaZZzR69GitXr1affr0ydV+V69erd69eyswMFCLFy/W9OnT9emnn2rBggW3lBcAgOvx9/fXCy+84DgZEhkZmeVkSOY8y4sXL1a1atXUvn17C9MChRP9ECgY6IvAzWNaIRRJYWFhstlsio6O1oABA3TmzBnt3r1br776qvz8/NS4cWOtX79eXbt21ZEjR/Tnn3+qX79+Od5/5nx258+f16JFi7Rs2TLdfvvtqlat2jXfM2HCBMfPpmmqVatWqlWrlsLCwvTrr7+qfv36kqRHH31UFStW1I8//igvLy/He4YOHer4eezYsSpWrJi+//57+fv7S5I6duyo1NRUvfLKKxo9erRKlCjhaF+qVCl9+eWXjqucW7durWrVqmnq1Kl6//33lZGRoWeeeUb16tXT119/LZvtSl2xa9euqlq1qp599llt2rQpx38+KNqc3f+upVKlSpKkuLi4LNtPnjyp3377TdWrV3dsi42NzfF+J06cqHLlymnNmjXy9PSUJHXu3FmhoaG3nBkAgOvJPBkiSTNmzJCkLNMp7Nu3T5988onuuOMONWzY0KqYQKFGPwQKBvoicHMoDqBIKlGihBo0aOC4cjkmJkZubm5q1aqVpCsnL9etWycpd/OdS9KFCxfk4eHheG4Yhrp06aI5c+Zc932HDh3ShAkTtG7dOp08eTLLQjp79+5V/fr1tX//fv3xxx96+eWXsxQG/unixYtau3atHnnkEfn4+DgKFdKVk/lvv/22tmzZoi5duji2Dxw4MMv0J5UqVVLLli0dn33fvn2Ki4vTmDFjHIUBSfLz81OfPn303nvvKTk5WT4+Pjn6M0LR5sz+dz3/7FP/VL9+/SyFgdy4cOGCtm3bpscee8xRGJCu9I0ePXpkOy0RAAB56d8nQwzD0KRJk3Tq1CmNGDFCly9f1uzZs2UYhjIyMrKM5QDkDfohUDDQF4HcoziAIqtt27Z6/fXXFRcXp/Xr16tJkyby8/OTdOXk5IwZMxQfH6/169fL3d1drVu3ztF+vb29HdOW2O12VapUyXH1/rUkJSXpzjvvlJeXl6ZMmaLq1avLx8dHR44cUe/evZWSkiJJOnXqlCRlOz9epjNnzujy5ct666239NZbb2Xb5vTp01meBwcHX9UmODhYv/zyi2OfklS2bNmr2oWEhCgjI0Pnzp2jOIAcc1b/u57MNT9CQkKybM/u73VOnTt3TqZpqkyZMle9lt02AACc4d8nQxISEvTLL78oISFBO3fulLu7OwstAk5GPwQKBvoikDsUB1BkZZ6cjI6OVnR0tLp27ep4LfNE5IYNGxwLpWaeuLwRm82mpk2b5irLunXrFBcXp+joaIWFhTm2nz9/Pku7zDUL/v7772vuq0SJEnJzc9MDDzygRx99NNs2lStXzvL8+PHjV7U5fvy4AgMDJcnx338uIJspLi5ONpstyzRFwI04q/9dz1dffSVJCg8Pz7I9u0WDM+/MSU1NzbI9s1CWqUSJEjIMI8uaH5my61cAADhL5skQNzc3TZ8+XbVq1dLOnTvl4eGhy5cvy92dr36As9EPgYKBvgjkHPfPoMhq06aN3Nzc9MUXX2jPnj1ZThgGBASoYcOGWrBggWJjY/NkSpPryTw5abfbs2x/7733sjyvXr26qlatqg8//PCqk5aZfHx81LZtW+3YsUP169dX06ZNr3pknuzP9Omnn2aZcuWvv/7SDz/84PgzqVGjhsqVK6dFixZlaXfhwgUtWbJELVq04K4B5Ep+979vv/1WH3zwgVq2bJmjuxDKlCkjLy8v/frrr1m2L1++PMtzX19fNW3aVMuWLdOlS5cc25OSkrRy5cpbzg0AQG74+/vr2Wef1Zw5c/TLL79wEgSwAP0QKBjoi0DO0CNQZPn7+6tx48ZatmyZbDabY77zTGFhYXrjjTck5c1859fTsmVLlShRQiNHjlRkZKQ8PDy0cOFCx7Q+//TOO++oR48eat68uZ588klVrFhRhw8f1po1a7Rw4UJJ0syZM9W6dWvdeeedeuSRRxQaGqrExEQdPHhQK1ascMznnunkyZPq1auXRowYofj4eEVGRsrLy0sRERGSrtwNMX36dN13333q3r27Hn74YaWmpurVV1/V+fPn9corrzj1zweFj7P6X0ZGhrZs2SLpylX/hw8f1tdff63PPvtMtWrV0meffZaj/RiGofvvv18ffvihqlatqgYNGmjr1q1atGjRVW0nT56sbt26qVOnTnriiSeUnp7uWFz57NmzOc4OAEBeKFGihB588EFJ4iQIYBH6IVAw0BeBG+POARRpbdu2lWmaatSo0VXrAoSFhck0TXl6eqply5ZOzREYGKhVq1bJx8dH999/v4YNGyY/Pz8tXrz4qradOnXShg0bVLZsWY0ePVqdO3fW5MmTs8xvXrt2bW3fvl1169bVhAkTdNddd2n48OH64osv1L59+6v2+fLLL6tSpUoaOnSohg0bprJly2r9+vWqWrWqo83AgQO1bNkynTlzRvfee6+GDh0qf39/rV+/Pk/mg0fR44z+l5KSohYtWqhFixbq0qWLJkyYoKSkJL3//vv6+eefVa5cuRzva8aMGbr//vs1ffp03X333dq8eXO2dwN07txZS5YscfSNsWPHqlevXrr77rtVvHjxHB8PAIC8xkkQwHr0Q6BgoC8C2TPMf84RAgAAbllaWpoaNmyocuXK6ZtvvrE6DgAAAAAAwFUomwEAcIuGDx+ujh07qmzZsjp+/Lhmz56tvXv3aubMmVZHAwAAAAAAyBbFAQAAblFiYqKefvppnTp1Sh4eHmrcuLH+97//qUOHDlZHAwAAAAAAyBbTCgEAAAAAAAAAUMSwIDEAAAAAAAAAAEUMxQEAAAAAAAAAAIoYigMAAAAAAAAAABQxFAcAAAAAAAAAAChiKA4AAAAAAAAAAFDEUBwAAAAAAAAAAKCIoTgAAAAAAAAAAEARQ3EAAAAAAAAAAIAi5v8DDY41AxmYvcoAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "f_forest_drug_profiles, axes = plt.subplots(2, 2, figsize=[18, 18])\n", - "contrast_labels1 = ['Drug1', 'Drug2', 'Drug3']\n", - "unpaired_delta_01.mean_diff.plot( \n", - " contrast_label='Mean Diff',\n", - " fig_size = (5, 5),\n", - " raw_marker_size = 5,\n", - " es_marker_size = 5,\n", - " color_col='Genotype',\n", - " ax = axes[0,0]\n", - ")\n", - "\n", - "unpaired_delta_02.mean_diff.plot( \n", - " contrast_label='',\n", - " fig_size = (5, 5),\n", - " raw_marker_size = 5,\n", - " es_marker_size = 5,\n", - " color_col='Genotype',\n", - " ax = axes[0,1]\n", - ")\n", - "\n", - "\n", - "unpaired_delta_03.mean_diff.plot( \n", - " contrast_label='Mean Diff',\n", - " fig_size = (5, 5),\n", - " raw_marker_size = 5,\n", - " es_marker_size = 5,\n", - " color_col='Genotype',\n", - " ax = axes[1,0]\n", - ")\n", - "forest_plot(contrasts, contrast_labels = contrast_labels1 , ax = axes[1,1])\n", - "axes[0,0].set_title('Drug1 delta2', fontsize = 13, loc='left')\n", - "axes[0,0].set_ylabel('')\n", - "axes[0,1].set_ylabel('')\n", - "axes[0,1].set_title('Drug2 delta2', fontsize = 13, loc='left')\n", - "axes[1,0].set_title('Drug3 delta2', fontsize = 13, loc='left')\n", - "axes[0,1].set_ylabel('')\n", - "axes[1,1].set_title('Forest plot', fontsize = 13, loc='left') " - ] - }, { "cell_type": "markdown", "id": "964471ab", "metadata": {}, "source": [ - "## Forest plot of mini-meta:\n" + "# Forest plot of mini-meta effects:\n", + "Next we will generate a similar forest plot for mini-meta effect sizes. Please revisit the notebook '[Mini-meta Tutorial](04-mini_meta_delta.html)' on how to generate a mini-meta effect size. We will generate three mini-meta effect sizes for three separate mini-meta analyses:" ] }, { @@ -659,7 +362,7 @@ "id": "22bd3eab", "metadata": {}, "source": [ - "### Simulate the datasets for unpaired mini_meta " + "## Simulate the datasets for three unpaired mini-meta effects" ] }, { @@ -714,25 +417,20 @@ " test_scales=[0.5, 0.6, 0.9])" ] }, + { + "cell_type": "markdown", + "id": "93dd9b67-745f-45fc-8eee-fabb9c9eea6c", + "metadata": {}, + "source": [ + "## Creating contrast objects required for a mini-meta forest plot" + ] + }, { "cell_type": "code", "execution_count": null, "id": "9f68e5fe", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/_dabest_object.py:668: FutureWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n", - " plot_data.loc[:, self.__xvar] = pd.Categorical(\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/_dabest_object.py:668: FutureWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n", - " plot_data.loc[:, self.__xvar] = pd.Categorical(\n", - "/Users/wangzhuoyulucas/anaconda3/envs/dabest/lib/python3.10/site-packages/dabest/_dabest_object.py:668: FutureWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n", - " plot_data.loc[:, self.__xvar] = pd.Categorical(\n" - ] - } - ], + "outputs": [], "source": [ "contrast_mini_meta01 = dabest.load(data = df_mini_meta01,\n", " idx=((\"Control 1\", \"Test 1\"), (\"Control 2\", \"Test 2\"), (\"Control 3\", \"Test 3\")), \n", @@ -752,26 +450,88 @@ "id": "e04e1ac4", "metadata": {}, "source": [ - "## Generate the Figure" + "## Generate the mini-meta forest plot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9deb1001", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f_forest_minimeta = forest_plot(contrasts_mini_meta, contrast_type='mini_meta', contrast_labels=['mini_meta1', 'mini_meta2', 'mini_meta3']);" ] }, { "cell_type": "markdown", - "id": "c760a179", + "id": "5f9587c0-fbe8-474d-97ce-bd99d27ddf96", "metadata": {}, "source": [ - "### Vertical Layout (default)" + "# Control of aesthetics" + ] + }, + { + "cell_type": "markdown", + "id": "06b93055", + "metadata": {}, + "source": [ + "### Changing layout \n", + "Forest plot assumes a vertical layout by default, but you can change it to a horizontal layout by setting ```horizontal``` to be ```True```:" ] }, { "cell_type": "code", "execution_count": null, - "id": "9deb1001", + "id": "d8313860", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f_forest_delta2_horizontal = forest_plot(contrasts, \n", + " contrast_labels =['Drug1', 'Drug2', 'Drug3'],\n", + " horizontal=True);\n" + ] + }, + { + "cell_type": "markdown", + "id": "4100ba2c", + "metadata": {}, + "source": [ + "### Using a custom palette \n", + "You can color the half-violins with ```custom_palette```:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "23c9446e", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaYAAAGbCAYAAACPlTRwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA+Q0lEQVR4nO3dd1wUd/4/8NewwNIEBLFjw0psxBIURLBhicYWCyfWGM3dT5OLGjXGqIkllhhNMfF7EkvOlqjRxBK82GvUGKKXqCcoUUERQXZp0vbz+4NjTyLisswys+zr+XjsQ3dmZ/aNn5XXfmY+8xlJCCFARESkEnZKF0BERPQ4BhMREakKg4mIiFSFwURERKrCYCIiIlVhMBERkaowmIiISFUYTEREpCoMJiIiUhUGE9msNm3aQJIkaLVapKSklGnbqVOnQpIkSJKE77//3uwajh49atxPaY+0tDSz34PI2tgrXQCREs6fP49Lly4BAHJzc/HPf/4Tr7/+uknb5uTkYPPmzcbnX375Jfr371/umsaMGfPUdY6OjuXevxqMHTsWGzduxPr16zF27FilyyGVYjCRTYqKigIA1KlTBwkJCYiKijI5mL799lukpqaidu3auHv3Lvbu3YukpCTUqFGjXDVt2LChXNsTVRY8lEc2JysrC1u3bgUAbNy4Ea6urrh8+TLOnz9v0vZFoTZ16lSEhIQgPz8fmzZtsli9RLaGwUQ255tvvoFer0eLFi3QvXt3vPzyywD+FziliY+Px6FDh6DRaBAZGYlx48YBKDycV5Gio6Px4osvonr16nB0dETt2rUxfPhwXLhwocTXh4aGQpIkHD16FCdOnED//v3h4+MDOzu7Yj217OxsfPjhhwgMDISnpyecnJzQrFkzvPXWW089D/fNN9+gR48e8Pb2hoODA7y9veHv74+JEycaD5fGx8dDkiRs3LgRADBu3Lhi59Dmz58v678PWTlBZGO6dOkiAIilS5cKIYQ4duyYACA8PDxEVlZWqdvOnTtXABB9+vQRQgiRkZEh3NzcBABx6tSpMtdy5MgRAUCU5b/iO++8IwAISZJEUFCQGDlypGjbtq0AIDQajYiKinpim65duwoA4q9//auws7MT/v7+YsSIEaJXr15iy5YtQgghEhISRKtWrQQA4eXlJXr06CEGDRok6tevLwCIBg0aiPj4+GL7XbBggQAg7O3tRUhIiBg5cqTo27evaNmypZAkSXz00UdCCCGSk5PFmDFjhJ+fnwAggoKCxJgxY4yPb7/9tsz/dlR5MZjIply7ds34CzwxMVEIIYTBYDD+wty0adNTty0oKBC+vr4CgPj666+Ny8ePHy8AiPHjx5e5nrIG04EDBwQA4eTkJA4ePFhs3bp16wQA4eDgIP79738XW1cUTADEZ5999sR+DQaDCAoKEgDEhAkThF6vN67Ly8sT06ZNEwBEWFiYcfmjR4+Es7OzcHNzE1evXn1in/Hx8eLKlSvFlo0ZM0YAEOvXrzfp5yXbxGAimzJz5kwBQPTr16/Y8oULFwoAomvXrk/dtigUvLy8xKNHj4zLT548KQAINzc3kZ6eXqZ6Hg+mpz0e/yXevXt3AUC8+eabJe7vxRdfFADExIkTiy0vCqZu3bqV+rO1bdtW5OXlPbG+oKBAtGzZUgAQly9fFkIIcf/+fQFAtG7d2uSfl8FEpuA5JrIZ+fn5xnMcfx6qPHr0aNjZ2eH48eOIi4srcft169YBAEaOHAmtVmtcHhQUhCZNmiAjIwPbt283u74xY8aU+GjcuLGx/lOnTpVYf5EJEyYAAI4cOVLi+qFDh5a4fN++fQCAIUOGwN7+ycG6dnZ2CAkJAQCcPn0aAODj44MGDRrg0qVLmDZtGn7//XcTf1KiZ1A6GYkqyu7duwUA4e3tLXJycp5Y36tXLwFAvP3220+su3//vnBwcBAAxIULF55Yv3jxYgFAdO7cuUw1leVQ3r1794yvfVrP7NKlSwKAcHZ2Lra8qMe0f//+Erfr27fvM3tuRY+FCxcatzt+/LioXr26cZ2Xl5fo06ePWLlypUhOTn7ifdhjIlPwOiayGUWj7iIiIkq8YHXcuHE4ePAgNmzYgPfeew8ajca47quvvkJeXh5atWqFdu3aPbHt6NGj8c477+D06dO4evUqmjdvbrkfpBycnZ1LXG4wGAAAwcHB8PPzK3Ufzz33nPHvXbp0QXx8PPbt24djx47h9OnTiI6OxoEDBzBv3jx8++236N69u3w/ANkGpZORqCIkJiYKjUYjAIiLFy+W+Jrs7Gzh6ekpAIi9e/cWW+fv7y8AiJUrVz71PXr37i0AiOnTp5tcV1l6THl5eUKr1QoA4tdffy3xNUW9wsaNGxdbXtRjOnLkSInbTZw4UQAQy5cvN7n2p7l//7549dVXBQBRr169YuvYYyJT8BwT2YQNGzagoKAAbdq0QUBAQImvcXJywsiRIwEUv6bpzJkz+P333+Hg4IBRo0Y99T2Krmn66quvkJ+fL2P1hezt7REcHAzg6bNEFF1PFRYWVqZ99+nTB0DhNUlCCPOLROG5p2XLlgEAbt26hYcPHxrXFfVULfHvQ5UHg4lsQtEv7GfNz1YULnv37kVycjKA/4VU37594ePj89RtX3rpJVStWhVJSUnYu3evDFU/adq0aQCAzz//HIcOHSq2bsOGDfjuu+/g4OBg8vRKRV566SV06NAB586dw7hx44w/++MePnyIL774whgqf/zxB9atWwe9Xv/Ea4smtq1atSrc3d2Ny+vWrQsA+O2338pUH9kWSZT36xGRyh07dgyhoaEAgOeffx5VqlQp9fXHjx+HEAIrVqzApEmTUKtWLWRkZKBRo0bw9fUtddtLly7h4cOHePHFF02adfzo0aPG3o2p/xXnzp2LhQsXQpIkBAUFoV69erh69SouXrwIjUaD//u//8P48eOLbRMaGopjx47hyJEjxn+LP0tMTES/fv0QExMDV1dXtGnTBvXq1UNubi5u3LiBy5cvo6CgANnZ2XByckJMTAwCAgLg4OCAtm3bomHDhgCA69ev45dffoEkSfjHP/5hHClY9O9T1GPt1q0bfH19YWdnhwEDBmDAgAEm/fxkAxQ9kEhUASIjI00ecfb4o0WLFiIqKsqsbTUajUhISHhmbebM/CBE4XVHffv2Fd7e3sLe3l7UrFlTvPzyy+Knn34q8fXPOsdU5NGjR+KLL74QYWFhxn1Xr15dtG3bVvztb38T0dHRxtfq9XqxatUqMWjQINGkSRPh5uYmXF1dRdOmTcXo0aNLHL0ohBDffvutCAoKElWqVBGSJAkAYt68eWX6+alyY4+JiIhUheeYiIhIVRhMRESkKgwmIiJSFQYTERGpCoOJiIhUhcFERESqYtPBJISAXq8v9xQsREQkH5sOpvT0dHh4eCA9PV3pUoiI6L9sOpiIiEh9GExERKQqDCYiIlIVBhMREakKg4mIiFSFwURERKrCYCIiIlVhMBERkaowmIiISFUYTEREpCoMJiIiUhUGExERqQqDiYiIVIXBRKQCGRlKV0CkHgwmIhW4fFnpCojUg8FEpAJ37ypdAZF6WHUwHT9+HP3790ft2rUhSRJ2796tdElEZrl1S+kKiNTDqoMpMzMTbdq0wWeffaZ0KUTlcvOm0hUQqYe90gWUR58+fdCnTx+lyyAqt5QUIC0N8PRUuhIi5Vl1j6mscnJyoNfriz2I1OL6daUrIFIHmwqmJUuWwMPDw/jw9fVVuiQio9hYpSsgUgebCqbZs2dDp9MZH7dv31a6JCKjGzeUroBIHaz6HFNZabVaaLVapcsgKtG1a0pXQKQONtVjIlKza9eA9HSlqyBSnlUHU0ZGBmJiYhATEwMAuHnzJmJiYnCLF4WQFSooAA4cULoKIuVJQgihdBHmOnr0KMLCwp5YPmbMGGzYsOGZ2+v1enh4eECn08Hd3d0CFRKVTqfT4fLly3jvvcKLbOvUaYU9ezzg5qZ0ZUTKsepzTKGhobDiXCXC5cuX0aVLl8eWnMCyZcFYsACQJMXKIlKUVR/KI6qM9u8HduxQugoi5TCYiFRo+XLgxAmlqyBSBoOJSIUMBmDmTOD4caUrIap4DCYilcrNBaZPBzZvBngqlWwJg4lIxQwG4KOPCntPnNqRbAWDicgKHD4MjBgBnDundCVElsdgIrIS9+8Df/0r8MEHQGam0tUQWQ6DicjK7NgBDB1aOEuEwaB0NUTyYzARWaHkZGDuXGDsWB7eo8qHwURkxX7/vfDw3uTJwK+/Kl0NkTwYTESVwIULwIQJwOuv8064ZP0YTESVyKlTQEQEsHAhkJamdDVE5mEwEVUyQgC7dxcOkDh6VOlqiMqOwUSkoD/Pji/nbPlpaYUzR3z8MUfvkXVhMBEpIC0tDatXr8aIESOKLb95cwSSklYjPz9NtvfatKkwoLKyZNslkUVZ9Y0Cy4s3CiQlREdHY8iQIcjKynpKD0mCnZ0LGjXaCQ+PcNnet2FDYOlSoFEj2XZJZBHsMRFVoOjoaPTr1w/Z2dmlHLYTMBiyERvbDzpdtGzvffMmEBkJfPMNJ4UldWOPiT0mqiBpaWmoW7cusrOzYTDppI8d7Oyc0arVHdjbe8paS1AQMH8+ULWqrLslkgV7TEQVZOPGjcjKyjIxlADAAIMhC6mpm2Sv5dQpYPRo4I8/ZN81UbkxmIgqgBACn3zyiVnb3r//sayj9YrcvQtMnVp43yciNWEwEVWAlJQUxMXFmREwAjk5cSgoSLVIXQkJhbNGEKkJg4moAmRkZJRr+4KCdJkqeRLPM5HaMJiIKoCbm1u5ttdoqshUSXH+/kDz5hbZNZHZGExEFcDb2xt+fn6QJKmMW0rQav2g0XhZpK5p04Ayl0RkYQwmogogSRKmTJli1rbVq081I9CebfBgoE0b2XdLVG4MJqIKMmbMGLi4uMDOztT/dnaws3OBl9do2Wvx9QXeeEP23RLJgsFEVEE8PT2xc+dOSJJkQjjZAZDg57dL9otr3dyADz8EXFxk3S2RbBhMRBUoPDwc+/btg7OzcymH5yTY2TmjSZP9cHfvJev7e3kBa9ZwvjxSNwYTUQULDw/HnTt3sGrVKtSuXbvYOgeH2vD1XYXWrRNkD6XAQOCrrwpH4hGpGefK41x5pKATJ04gJCTE+Lxp0+OoUqWLrO9Rvz4wZQrQtStH4JF1sFe6ACJb9ufDeXKOvmvQAHjlFaBXL8Dk8RZEKsBgIqpkatcGJk8GevdmIJF1YjARVRIaDTBhAjB2LODoqHQ1ROZjMBFVAnXrAkuWAC1aKF0JUfmxo09k5Xr0AP75T4YSVR7sMRFZKXd34M03gX79ONqOKhcGE5GVkSRgwADgb38rvGCWqLJhMBFZkY4dC+e4a9pU6UqILIfBRGQF6tYFpk8HgoJ42I4qPwYTkcpFRBQettNqla6EqGIwmIhUyskJWLSocCohIlvCYCJSIa0W+OQTICBA6UqIKh6vYyJSodmzGUpku9hjIlJQq1atcOLECbz3HnDrFuDs3AodOhRem0Rkq6y+x/TZZ5+hQYMGcHJywgsvvIBz584pXRKRyTw8PBAcHIzq1YPh5hYMjcYDr77KkXdk26w6mLZv344333wT8+bNw8WLF9GmTRuEh4fj/v37SpdGZJbmzYG2bZWugkhZVh1MK1euxMSJEzFu3Dj4+/vjiy++gIuLC7788kulSyMyy7Bh7C0RWe05ptzcXPz888+YPXu2cZmdnR169OiBM2fOlLhNTk4OcnJyjM/1ej0AICYmBm5ubpYtmKgUqamAwQBUqwZcvKh0NUSW8/zzzz/zNVYbTA8ePEBBQQFq1KhRbHmNGjVw9erVErdZsmQJFixY8MTyrrxQhFQiKEjpCogsSwjxzNdYbTCZY/bs2XjzzTeNz/V6PXx9fXHs2DH2mEhR77wDDBoEtGundCVEyrPaYKpWrRo0Gg2SkpKKLU9KSkLNmjVL3Ear1UJbwrwubdu2hbu7u0XqJDKFtzcwYgRQpYrSlRApz2oHPzg6OqJdu3Y4dOiQcZnBYMChQ4fQqVMnBSsjKjtfX4YSURGr7TEBwJtvvokxY8agffv26NixI1atWoXMzEyMGzdO6dKIyqRePaUrIFIPqw6m4cOHIzk5Ge+++y7u3buHtm3b4ocffnhiQASR2j3l6DORTZKEKUMkKim9Xg8PDw/odDqeYyJFnTwJBAcrXQWROljtOSaiyoS3SCf6HwYTkQp4eChdAZF6MJiIVMDFRekKiNSDwUSkAk5OSldApB4MJiIVcHZWugIi9TA7mAoKCrBt2zZMmjQJgwYNwuXLlwEAOp0Ou3btemJGBiIiIlOYFUxpaWkICgpCREQEtm7diu+++w7JyckAADc3N0ydOhWrV6+WtVAiIrINZgXTrFmz8NtvvyE6Oho3btwoNlusRqPB0KFDsX//ftmKJCIi22FWMO3evRtTpkxBz549IZVwV7OmTZsiPj6+vLXZLJ1Op3QJRESKMSuYdDodGjZs+NT1eXl5yM/PN7soW5eammrSPUuIiCojs4LJz88PF0u5zebBgwfh7+9vdlG2Lj8/H9nZ2UqXQUSkCLOC6ZVXXsGXX36J7du3G7/ZS5KEnJwczJkzBz/88AMmTZoka6G2Ji0tTekSiIgUYdbs4q+//jp+++03jBw5Ep6engCAiIgIpKSkID8/H5MmTcKECRPkrNPmPHz4ELVr11a6DCKiCmdWMEmShH/84x8YM2YMduzYgevXr8NgMMDPzw/Dhg1DSEiI3HXanNTUVKVLICJSRLnuxxQcHIxgztVvEQwmIrJVZp1junnzJr7//vunrv/+++85XLycHj58yJF5RGSTzOoxTZ8+HXq9Hv379y9x/WeffQZPT09s27atXMXZstzcXGRlZcHV1VXpUoiIKpRZPaYzZ86gZ8+eT13fvXt3nDhxwuyiqFDRNE9ERLbErGB6+PAhqlSp8tT1bm5uSElJMbsoKnTr1i2lSyAiqnBmBVO9evVw6tSpp64/ceIE6tata3ZRVCguLo4X2hKRzTErmEaOHImtW7fi448/hsFgMC4vKCjA6tWrsX37dkRERMhWpK3Q6XQ4efIkLly4gNjYWOj1epw9e1bpsoiIKpQkzBj6lZOTg379+uHw4cPw8fFBs2bNAADXrl1DcnIyQkNDceDAAWi1WtkLlpNer4eHhwd0Oh3c3d2VLgcnT55Ely5djM9nzJiBxo0bo1u3bmjcuLGClRERVRyzekxarRYHDx5EVFQUOnbsiAcPHuDBgwfo2LEjvvzyS/z444+qDyVrcvz4cQ6EICKbYfYFtnZ2dhg3bhzGjRsnZz1Ugvz8fPzwww/o37+/cQooIqLKyuxbq1PFys7Oxvfff8+eExFVemb3mKKjoxEVFYUbN26UOEuBJEmIi4srd4H0P0XhFBwcjKZNmypdDhGRRZgVTMuXL8esWbNQo0YNdOzYEa1atZK7LnqK/Px8HD16FAkJCQgKCoKjo6PSJRERycqsYFq9ejW6deuG/fv3w8HBQe6ayATXr1/HvXv3EBoailq1aildDhGRbMye+WHo0KEMJYWlp6fj+++/x4kTJ5CTk6N0OUREsjCrx9SxY0dcu3ZN7lrITFeuXMHNmzfRoUMHNGvWDHZ2HNNCRNbLrN9ga9aswa5du7Blyxa56yEzPXr0CCdOnMCOHTtw48YN3jKDiKyWWT2m4cOHIz8/H5GRkXjttddQt25daDSaYq+RJAm//vqrLEWS6dLS0vDjjz/C29sb7du3R7169SBJktJlERGZzKxg8vLygre3N5o0aSJ3PSSTlJQUREdHo0aNGggMDESNGjWULomIyCRmBdPRo0dlLoMsJSkpCXv27EGTJk0QGBgIZ2dnpUsiIioVz5LbiOvXr2PHjh24c+eO0qUQEZXK7GDS6/X44IMPEB4ejoCAAJw7dw4AkJqaipUrVyI2Nla2Im3FnwcsyD2AITs7GwcOHMDly5c5OIKIVMusYLpz5w4CAgLw7rvv4s6dO7h06RIyMjIAFJ5/Wrt2LT755BNZC63M0tLSsHr1aowYMaLY8nXr1uHQoUPIysqS7b2EEDhz5gxOnDiBgoIC2fZLRCQXs84xzZgxA+np6YiJiUH16tVRvXr1YusHDhyIvXv3ylJgZRcdHY0hQ4YgKyvriV5MWloavv76a+zZsweTJk3Cc889J9v7Xr16FSkpKejevbsq7kVFRFTErB7TwYMHMXXqVPj7+5c4FLlRo0a4fft2uYur7KKjo9GvXz9kZ2eXemgtNzcXn376KX777TdZ3z85ORk7d+7EtWvXeGiPiFTDrGDKzs6Gj4/PU9enp6ebXZCtSEtLw5AhQyCEKHZ7+pIIISCEwNq1a2U9rAcAeXl5OHbsGA4dOoS8vDxZ901EZA6zgsnf3x/Hjx9/6vrdu3cjICDA7KJswcaNG5GVlfXMUCoihEBOTg7Onj1rkXpu3LiBvXv3MpyISHFmBdMbb7yBbdu2YenSpdDpdAAAg8GA2NhYREZG4syZM/j73/8ua6GViRDC7MEhhw8ftthht+TkZPz8888W2TcRkanMGvwwatQo/PHHH3jnnXcwZ84cAEDv3r0hhICdnR0WL16MgQMHyllnpZKSkmL2TRSTk5ORmZkJNzc3masq9ODBA4vsl4jIVGbfwXbOnDmIjIzEzp07ERsbC4PBAD8/PwwePBiNGjWSs8YSLVq0CPv27UNMTAwcHR2RlpZm8feUS9HQenM9evTIYsFU2rlDIqKKUOZgysrKQpcuXTBx4kRMnjxZsUN2ubm5ePnll9GpUydERUUpUoO5yhsqTk5OMlVSnIODA+9GTESKK3Mwubi44ObNm4rPWL1gwQIAwIYNGxStwxze3t7w8/Mz6/YUPj4+cHV1tUhd7dq1g4uLi0X2TURkKrMGP/Tu3RvR0dFy12IzJEnClClTzNq2W7duFvlS4OPjg5YtW8q+XyKisjIrmObOnYv//Oc/iIyMxMmTJ5GQkIDU1NQnHmqTk5MDvV5f7KGUMWPGwMXFxeS7zUqSBK1Wi8DAQNlrcXR0RLdu3XjnWyJSBbN+Ez333HP4/fffsXnzZnTt2hX16tWDj4/PE4+ymjVrFiRJKvVx9epVc0oGACxZsgQeHh7Gh6+vr9n7Ki9PT0/s3LkTkiQ9MxCKfvbJkyfLfqhNo9GgZ8+e8PDwkHW/RETmkoQZF8XMnz/fpMNJ8+bNK9N+k5OTkZKSUuprGjVqBEdHR+PzDRs24I033jBpVF5OTg5ycnKMz/V6PXx9faHT6RSbL660ufKKaLVaTJ48Gf7+/rK+t7OzM3r06IFatWrJul8iovIwa7j4/PnzZS6jkLk9LVNptVpotVqL7d8c4eHhuHPnDjZt2oSlS5ciMTHRuM7T0xPh4eHo1KmT7Df4a9y4sUX2S0RUXmZfx/Q4nU4HNzc3aDQaOXZnklu3biE1NRW3bt1CQUEBYmJiABT+wrXUNT6W4unpialTpyIgIAAhISHG5a+88orst6/39fVF+/bteb0SEamW2We7L1y4gN69e8PFxQXe3t44duwYgMKZA1566SWL33793XffRUBAAObNm4eMjAwEBAQgICAAFy5csOj7WtKfD4/KOfrO19cXAwcORJ8+fRhKRKRqZgXT6dOnERwcjOvXr2PUqFHFJiKtVq0adDod1q5dK1uRJdmwYYNx1u3HH6GhoRZ9X2vj4+OD/v37o0+fPk/cN4uISI3MOpT39ttvo0WLFjh79izS09Oxbt26YuvDwsKwceNGWQok82g0GnTs2BEtW7ZU/GJoIqKyMCuYzp8/jyVLlkCr1ZY471udOnVw7969chdH5vH09ESPHj3g5eWldClERGVmVjA5ODiUeh+hhIQEqxuAUFk0adIEwcHBcHBwULoUIiKzmHWOKTAwEDt27ChxXWZmJtavX4+uXbuWqzAqG1dXV/Tq1QthYWEMJSKyamb1mBYsWICuXbuiX79+GDlyJADg119/xY0bN7BixQokJydj7ty5shZKJbO3t0fr1q3Rpk0bBhIRVQpmBdMLL7yA/fv347XXXsPo0aMBANOmTQMA+Pn5Yf/+/WjdurV8VdITJElC06ZN0b59e4vNNk5EpASTgkmv18PV1bXYBbTdunXDtWvXEBMTg+vXrxtvFNiuXTuOArOwatWqoUuXLrweiYgqJZOCqWrVqvjqq68QEREBABg/fjwmTZqEF154AW3btkXbtm0tWSM9JiAgAO3ateNM4ERUaZn0283R0bHY5KcbNmxAXFycxYqiJ2k0GvTo0QMdOnRgKBFRpWZSj6l58+ZYt24dGjRoYLw9Qnx8PC5evFjqds8//3z5KyQAhRctN2rUSOkyiIgszqRgWrJkCYYPH44ePXoAKDzxPnfu3KeOvBNCQJIkFBQUyFepDXvuuecYSkRkM0wKpt69e+PmzZs4f/48kpKSMHbsWLz66qvo1KmTpeuzKa1atcKJEydw+/Zt/PLLL6hTpw60Wi3at2+vdGlERBXGpGC6dOkS6tevj/DwcADA+vXr8fLLL6N79+4WLc7WeHh4GCfHTU9PBwC0aNFCdfeQIiKyJJPOogcEBGDfvn2WroX+RJIk2e9aS0SkdiYFk7OzM7KysozPjx07hqSkJIsVRYXq16/POQeJyOaYdCivTZs2WLlyJTQajXFU3vnz5+Hk5FTqdoMHDy5/hTasWbNmSpdARFThJCGEeNaLLly4gKFDh+LWrVuFG0kSnrWZNYzK0+v18PDwgE6ng7u7u9LlGF2/fh2nT59GZGQkr1kiIptjUo+pffv2iI2NRVxcHJKSkhAaGoo5c+YYh4+T/OrUqcNQIiKbZPIkrvb29mjWrBmaNWuGMWPG4MUXX8QLL7xgydpsWs2aNZUugYhIEWbNLr5+/Xq566A/8fb2VroEIiJFmBRM7733HiRJwpw5c2BnZ4f33nvvmdsUzQ5B5lHTOS8ioopk0uAHOzs7SJKE7OxsODo6mnTug4MfzBcXF4dGjRrx9iFEZJNM6jEZDIZSn5O8nJycGEpEZLM47EuFnJ2dlS6BiEgxZg1+AIArV64gLi4O6enpqFKlCho3bozmzZvLWZvNcnR0VLoEIiLFlDmY1q5di0WLFiEhIeGJdfXq1cOcOXPwyiuvyFKcrXJwcFC6BCIixZQpmKZPn46VK1fCy8sL48ePR8uWLeHm5oaMjAxcvnwZu3fvxqRJk3D9+nUsXbrUUjVXegwmIrJlJo3KA4Bz584hMDAQgwYNwqZNm+Dq6vrEazIzMzFq1Ch89913+Omnn1R/HyG1jsojIrJlJg9+iIqKQq1atbBly5YSQwkAXF1dsXXrVtSoUQNRUVGyFUlERLbD5GA6c+YMXn755WfetM7JyQkvv/wyTp06Ve7iiIjI9pgcTLdv30aLFi1Meq2/vz9u375tdlFERGS7TA4mvV6PKlWqmPRaNzc3463BiYiIysLkYBJClGk2AhPHVBARERVj8qg8Ozs7BAQEoE6dOs98bUJCAmJiYjhXHhERlZnJ1zHVq1cPqampSE1NNfn1REREZWVyMMXHx1uwDCIiokKcxJWIiFSFwURERKrCYCIiIlVhMBERkaowmIiISFUYTEREpCoMJiIiUhWzb60eHR2NqKgo3LhxAw8fPnxiCiJJkhAXF1fuAomIyLaYFUzLly/HrFmzUKNGDXTs2BGtWrWSu65SxcfH4/3338fhw4dx79491K5dG6NGjcKcOXPg6OhYobUQEZG8zAqm1atXo1u3bti/f78itwG/evUqDAYD1q5di8aNG+Pf//43Jk6ciMzMTKxYsaLC6yEiIvmYPInr41xdXbFy5UpMmjTJEjWZZfny5fj8889x48YNk7fhJK5EROpj1uCHjh074tq1a3LXUi46nQ5eXl5Kl0FEROVkVjCtWbMGu3btwpYtW+SuxyyxsbH45JNPntmDy8nJgV6vL/YgIiJ1MetQXuvWrZGamoq7d+/Czc0NdevWhUajKb5jScKvv/5apv3OmjULS5cuLfU1V65cQfPmzY3PExIS0LVrV4SGhmLdunWlbjt//nwsWLDgieU8lEdEpB5mBVNoaKhJd7M9cuRImfabnJyMlJSUUl/TqFEj48i7xMREhIaGIjAwEBs2bICdXekdwJycHOTk5Bif6/V6+Pr6MpiIiFTErGBSg4SEBISFhaFdu3b45z//+USPzRQc/EBEpD5mX2CrpISEBISGhqJ+/fpYsWIFkpOTjetq1qypYGVERFRe5QqmvLw8XL16FTqdDgaD4Yn1ISEh5dn9U/3rX/9CbGwsYmNjUbdu3WLrrLQDSERE/2XWoTyDwYDZs2djzZo1yMrKeurrCgoKylWcpfFQHhGR+pg1XHzx4sVYvnw5Ro0ahU2bNkEIgQ8++ABffPEFWrdujTZt2iA6OlruWomIyAaYFUwbNmzAsGHD8Pnnn6N3794AgHbt2mHixIn46aefIEkSDh8+LGuhRERkG8wKpjt37qBbt24AAK1WCwB49OgRAMDR0RGjRo3CV199JVOJRERkS8wKJm9vb2RkZAAA3Nzc4O7u/sQcdQ8fPix/dUREZHPMGpUXEBCA8+fPG5+HhYVh1apVCAgIgMFgwMcff4w2bdrIViQREdkOs3pMr776arFZFBYtWoS0tDSEhISga9eu0Ov1+PDDD2UtlIiIbINsMz/odDocPXoUGo0GnTt3toqZvjlcnIhIfax2SiI5MJiIiNTHrEN5QOHFs9u2bcOkSZMwaNAgXL58GUBhz2nXrl1ISkqSrUgiIrIdZgVTWloagoKCEBERga1bt+K7774zzlfn5uaGqVOnYvXq1bIWSkREtsGsYJo1axZ+++03REdH48aNG8Xmp9NoNBg6dCj2798vW5FERGQ7zAqm3bt3Y8qUKejZs2eJ92Vq2rQp4uPjy1sbERHZILOCSafToWHDhk9dn5eXh/z8fLOLIiIi22VWMPn5+eHixYtPXX/w4EH4+/ubXRQREdkus4LplVdewZdffont27cbzy9JkoScnBzMmTMHP/zwAyZNmiRroUREZBvMuo5JCIFXX30VUVFR8PT0RFpaGmrUqIGUlBTk5+dj0qRJ+Pzzzy1Rr6x4HRMRkfqU6wLbkydPYseOHbh+/ToMBgP8/PwwbNgwi925Vm4MJiIi9eHMDwwmIiJVMXvmByIiIksw+bYXAwYMKNOOJUnCnj17ylwQERHZNpODae/evXByckLNmjVhytG/ki68JSIiehaTg6lOnTpISEhAtWrVEBERgREjRqBmzZqWrI2IiGyQyeeYbt++jSNHjiAgIADvv/8+fH190aNHD6xfvx7p6emWrJGIiGyIWaPy8vLysH//fmzZsgV79+6FwWBAnz59EBERgf79+0Or1VqiVtlxVB4RkfqYNSrPwcEBL730ErZv346kpCSsXbsW9+7dw/Dhw7Fs2TK5ayQiIhtSruHiOTk5iI6Oxp49e/DLL7/AyckJDRo0kKk0IiKyRWUOJoPBgOjoaIwdOxY1atTAyJEjkZ2djX/84x+4f/8+IiMjLVEnERHZCJNH5Z0+fRpbtmzBN998g5SUFAQGBmLx4sUYNmwYqlWrZskaiYjIhpg8+MHOzg7Ozs7o27cvRo4cadIhu+eff7689VkUBz8QEalPmYLJuNEzLp4VQkCSJBQUFJSvOgtjMBERqY/Jh/LWr19vyTqIiGxGZm4mXB1dlS5DtTi7OHtMRFTBLt69iJbVW8JR46h0KarE2cWJiBRwN/2u0iWoFoOJiEgBt/W3lS5BtRhMREQKuPHwhtIlqBaDiYhIAXGpcUqXoFoMJiIiBVxPva50CarFYCIiUkB8WjwKDOq+1lMpDCYiIgXkFuQiIT1B6TJUicFERKSQ/6T8R+kSVInBRESkkAuJF5QuQZUYTERECvnXjX/hUf4jpctQHQYTEVEF0el0OHnyJH756RdkxGYg9WEqvvr1K6XLUh2TJ3ElIqLyuXz5Mrp06WJ83mxGM3wZ8yW61O+C5tWaK1iZulhtj2nAgAGoV68enJycUKtWLURGRiIxMVHpsoiIyiSvIA9v/estpD1KU7oU1bDaYAoLC8PXX3+Na9euYefOnYiLi8PQoUOVLouIqMwS0xPxZvSbPN/0X1YbTH//+98RGBiI+vXro3Pnzpg1axbOnj2LvLw8pUsjIiqzS0mX8MYPbyArL0vpUhRntcH0uNTUVGzevBmdO3eGg4PDU1+Xk5MDvV5f7EFEpBYXEi9g/J7xSNDb9oW3Vh1MM2fOhKurK7y9vXHr1i3s2bOn1NcvWbIEHh4exoevr28FVUpEZJrY1Fj8ZddfcOjGIaVLUYyqgmnWrFmQJKnUx9WrV42vnzFjBn755RccPHgQGo0Go0ePRmk35J09ezZ0Op3xcfs274dCROqTkZuBmT/OxHvH3kNmbqbS5VQ4Vd1aPTk5GSkpKaW+plGjRnB0fPJ2xHfu3IGvry9Onz6NTp06mfR+vLU6EVWkkydPPjFc3K2xW6nb1KpSC3O6zEFg3UBLl6caqrqOycfHBz4+PmZtazAYABSeRyIiqizupt/F/9v//9DLrxdef+F11HCroXRJFqeqYDLVTz/9hPPnzyM4OBhVq1ZFXFwc5s6dCz8/P5N7S0RE1uRg3EEcjT+KiFYRGN1mNNy1lfcoj6rOMZnKxcUFu3btQvfu3dGsWTNMmDABrVu3xrFjx6DVapUuj4jIInILcrEhZgMGbB2AqItRlXZouarOMVU0nmMioopkzjmm0ng4eWBc23EY9twwOGqePPdurayyx0RERIDukQ6rzq7C0K+H4mj8UaXLkQ2DiYjIyiWmJ2L6wel4619vQfdIp3Q55cZgIiKqIH8+cyL3mZTDNw/jL7v+gmsPrsm634rGYCIisrC0tDSsXr0aI0aMKLb85rqbSDqUhPysfNne617GPUz4boJVH9rj4AcOfiAiC4qOjsaQIUOQlZX11B6SndYOjSY1gsdzHrK+94SACXi13avQ2Glk3a+lscdERGQh0dHR6NevH7Kzs0s9bGfINSD201jofpP3/FDUL1GYtHcSEtOt6151DCYiIgtIS0vDkCFDIIQwzkzzVKLwcWPtDVkP6wFAzL0YjNgxAgeuH5B1v5bEYCIisoCNGzciKyvr2aFURACGHANSz6bKXktWXhbmHpmLj858JPuAC0tgMBERyUwIgU8++cSsbe8fvm+x8Nh8eTO2/7bdIvuWE4OJiEhmKSkpiIuLMytgcpJzUJBZYIGqCu28stNi+5YLg4mISGYZGRnl2r7gkeWCyUMr78g/S2AwERHJzM3N/PnvAEDjZLnh3UNaDLHYvuXCYCIikpm3tzf8/PwgSVKZt9X6aKFxtUww+fv4I7xxuEX2LScGExGRzCRJwpQpU8zatnq36mYF2rNo7DR4J+Qd2Enq/7Wv/gqJiKzQmDFj4OLiAjs7E3/NSoUzQHgFelmknkntJqGpd1OL7FtuDCYiIgvw9PTEzp07IUnSs8NJKnz4TfaDvYv8Nxbv1rAbxrYdK/t+LYXBRERkIeHh4di3bx+cnZ1LPTxn52iHJlOawN1f/jk7wxqEYWG3hVZxCK8IJ3HlJK5EZGFpaWnYtGkTli5disTE/81b5+DpgJrhNeHdyRsaZ3kHPDhqHPFa+9fwl9Z/sapQAhhMDCYiqjAnTpxASEiI8XnT6U1RpUkVWd9DkiSE+4Xjbx3+hlpVasm674oi/8FMIiIq0Z8P58k5+k6SJPRs1BOvPP8KGlVtJNt+lcBgIiKycmENwvBah9esPpCKMJiIiKyUr4cv3g5+Gx3qdFC6FFkxmIiIrNDA5gMxrdM0ODs4K12K7BhMRERWxNnBGbODZ6Nvk75Kl2IxDCYiIisRUDMA73Z9F74evkqXYlEMJiIilfNy9sKUjlPQr2k/q7smyRwMJiIildLaaxHZOhKj24yGi4OL0uVUGAYTEZEKhfuF4/XA11HdtbrSpVQ4BhMRkYpUc6mGd7u+i86+nZUuRTEMJiIilWhTow2W91oOL2fL3PrCWjCYiIhUoH3t9ljdezW09lqlS1Fc5R/eQUSkcrWq1MKynssYSv/FHhMRUQVp1aoVTpw4gWsPrmH56eVwrlM4a8OMzjPgruUdDoowmIiIKoiHhweCg4PhctcFbvfdAADNqjVDl3pdFK5MXXgoj4hIQREtI2S9/UVlwGAiIlKIp5Mnevr1VLoM1WEwEREp5MWmL8JR46h0GarDYCIiUki/Jv2ULkGVGExERAqoXaU2Gns1VroMVWIwEREpoH3t9hz08BQMJiIiBbSo1kLpElSLwUREpID6nvWVLkG1GExERAqo6VZT6RJUi8FERKSAai7VlC5Btaw+mHJyctC2bVtIkoSYmBilyyEieiYneyebuiNtWVl9ML311luoXbu20mUQEZnMQ+uhdAmqZtXBdODAARw8eBArVqxQuhQiIpOxt1Q6q51dPCkpCRMnTsTu3bvh4mJaI+fk5CAnJ8f4XK/XW6o8IqKncnZwVroEVbPKHpMQAmPHjsXkyZPRvn17k7dbsmQJPDw8jA9fX18LVklEVDIneyelS1A1VQXTrFmzIElSqY+rV6/ik08+QXp6OmbPnl2m/c+ePRs6nc74uH37toV+EiIiMpckhBBKF1EkOTkZKSkppb6mUaNGGDZsGL7//vti03kUFBRAo9HgL3/5CzZu3GjS++n1enh4eECn08HdnXePJCJSA1UFk6lu3bpV7PxQYmIiwsPDsWPHDrzwwguoW7euSfthMBERqY9VDn6oV69eseduboW3KPbz8zM5lIiISJ1UdY6JiIjIKntMf9agQQNY4RFJIiIqAXtMRESkKgwmIiJSFQYTERGpCoOJiIhUhcFERESqwmAiIiJVYTCpTE5ODubPn19sFnSq3NjmtoXt/WxWOSWRXIQQSE9PR5UqVYrNu6ckTpNke9jmtoXt/WyV4gJbc0mSxA8GEZHK8FAeERGpCoOJiIhUhcGkMlqtFvPmzYNWq1W6FKogbHPbwvZ+Npse/EBEROrDHhMREakKg4mIiFSFwURERKrCYCIiIlVhMBERkaowmIiISFUYTERWRggBXuVBlRmDichKFIVRQUGBaiYdJsvJz89HdnY27t69i+zsbKXLqVAMJiv04MED/Pjjj0qXQRUoNTUVc+bMQbdu3RAQEIBly5bhP//5j9JlkYU8ePAA48ePR/v27dG4cWOMGTMGp0+fVrqsCsOZH6xMSkoK/P39kZycjB07dmDw4MFKl0QWlpSUhK5du0Kj0cDDwwP29vY4efIkRo4ciQ8++AC+vr5Kl0gySkpKQlBQEDw8PNChQwe4uLhg1apVGDhwINauXQsfHx+lS7Q4m77thbXJzs7Gm2++iaysLPj5+WHkyJH46quvMGzYMKVLIwvR6/UYPnw4vL29sXjxYgQFBcHe3h4LFizAggULMHz4cPj6+kIIwcN7lUBaWhoGDBgAHx8frFixAkFBQQCAzMxMfPvttzZzSI+H8qzIqVOnsHnzZrz44ovYsGEDwsLCEBkZia+//lrp0shCduzYgT/++AOTJ09GcHAw7O3tIYTAjBkz0LhxY0RFRcFgMChdJsnAYDBg/fr1yMjIwIwZM9C5c2fjOm9vb9SsWRMXLlxAbGwsYmNjjesq40Ev9pisiLu7OyIiIvDpp5/C3d0dc+fORUFBASIjIwGAPadKRgiBM2fOwNHR0djGQOENLl1cXODv74/4+HjY2fH7ZWXh4eGBoUOH4qWXXjL2gOPi4rBp0yYkJydj7dq1iImJQZUqVTBz5kxMnDixcvaUBVmNgoIC8fDhw2LLzpw5I3r06CEcHR3F9u3bhRBCGAwGBaojS0hLSxOHDh0SQgiRn59f7M+5c+eK6tWrC71eL3JzcxWrkeSTm5srCgoKjM8TExNF7dq1RVBQkNi7d6/Iz88Xu3btEj179hSSJImdO3cqWK3l8KuWFbGzs4OnpyeA/3XfAwMD8f777yMkJASRkZHYvn278RtUfHw8fv75Z6XKpXIqKCiAh4cHunXrBgDQaDTF/vT29kZmZiYMBgPs7QsPfuh0Oty8eVOZgqncHBwcYGdnZ/z//ejRI/Tr1w/r169H3759odFoMGjQILz11ltwdnbG3r17Fa7YMhhMKve08weSJJUYTqNHj8aePXuQkJCARYsWISQkBFevXq2Ux6Erq6I2Lwqgp7G3t0dubi7s7e0hSRJSU1OxZs0aDBw4kOFkRUr6Py5JEgwGAxo2bIg1a9agSZMmkCQJ+fn5AIAePXqgadOmuHbtGvLy8iq6ZItjMKmYEMJ4/mD8+PE4cOAACgoKjOv/HE4LFy5EWFgYIiIiMHr0aERFReGdd95B8+bNK+dx6EroWW3+OC8vL+Tn5yMzM9N4/mHOnDkYPnw4GjZsWJFlk5lKa++i5UW9YSGE8e+XLl3C/fv3ERQUBAcHBwUqtzDFDiJSqfLy8ox/T0xMFHXq1BH+/v7i8OHDxnMMRR4/Jr1z505Ro0YNIUmSWL58eYmvIXUqS5sLIcTevXuFJEni+PHjYvHixUKSJLFo0SLjep5rVLeytvfjr3377beFt7e32Lt3b0WUWuEYTCr0+IdyxowZYuDAgaJNmzZCkiTRrFkzcejQoRKDJi4uTrz66qtCkiTx0UcfGZczlNTPnDbfs2eP0Gg0YsKECUKSJLFw4ULjOra5upn7f/znn38WU6ZMEfb29mLZsmUVWXKFYjCp2MCBA0Xt2rXFW2+9JX788UcxY8YM0axZM1G3bt0SP7ibN28WkiSJxYsXG5fxF5R1KUubHz58WEiSxDa3YmVp7zVr1ggvLy9Rv359sXr1auPyytjeDCaVOnr0qHBychLLli0TWVlZQgghHj16JM6ePSvat29v/OA+/s0rOztbREdHG59Xxg9sZVbWNn/48KGoXbu2+OCDD4z7YJtbj7K2d0pKiliwYIH48ccfjfuorO3NYFKpnTt3CkmSjEFTdJ2KwWAQp06dEvXr1xf+/v5PhFORyvqBrczK0uaPHj0SQgjjn0Kwza1NWdo7OzvbuK5IZT6HyFF5KlDSqKsGDRoAAK5cuQKg8PoGg8EASZLQvn17hIaG4sqVK3jttddw5swZAMWnJuFsAOpW3jY/f/48gP8NKRePje4i9Slve1+4cAFA8f/jlXmkLT/JKlD0y2X37t3GZTVq1EBISAg++OADHD16FEDhB7GgoACOjo4ICAhA9+7d4enpicjISDx48MB47QOpn1xtXjR3XmX+JVUZyNXej198W5kxmFTi/fffx4gRI7Bs2TIAQJ06dfDKK68gNzcXM2fOxJEjRyBJEjQaDe7du4dTp06hVatWWLVqFR4+fIi///3vANhTsiZytTlDyTqwvctA0QOJZPTvf/9b9O7dWzRs2LDYCKtVq1aJatWqiapVq4p3331XrFq1SowdO1ZotVqxbds2IYQQ4eHhomXLliIlJUWp8skMbHPbwvY2HYNJAY+fpDYYDMbBC9euXRO9evUS9evXL3ah5Ndffy0GDBgg7O3thSRJonr16sUunh0yZIho0qSJzXxorRHb3LawvcuHwVTBHh9Jc//+fSFE4Ye46IN89epV4wf38W9VOp1OxMXFiUuXLokrV64Yl586dUo0atRIDB482DjklNSFbW5b2N7lx2BSSEREhBg0aJC4efOmEKLww/z4BzckJERUrVpVrFix4qn72L17twgPDxdeXl7i999/r4iyqRzY5raF7W0+BlMFKZoXq+jPadOmiapVq4oJEyaU+MH95ZdfhLOzs6hbt6547733ntjfvHnzRPPmzUXz5s3FpUuXKuaHoDJhm9sWtrd8GEwVbPDgweKdd94RQggxc+ZMUbVqVTF+/HjjBzc/P994PDo0NFQ0adJEeHl5iQsXLhTbz+3bt8W2bdvEnTt3KrR+Kju2uW1he5cfg8nCHp9B+N133xU1a9YUGzduNB6HnjFjhvGDGxsba3zttWvXROfOncWmTZvEd999V2yfvMJf3djmtoXtLT97pYerV3aP3z+lSpUqGDFiBEaMGGG8FmHZsmUQQmDjxo14+PAhFi5cCGdnZ2zevBmJiYkICwtD3bp1ARTeUMzOzo7XKqkc29y2sL0tQOFgtAnTp08XkiQJd3d3sWrVKiFE4Teix+e4W7hwoahbt66QJElUrVpVSJIkli5dqlTJVE5sc9vC9pYXe0wyEv+dGiY+Ph7A/+bC6tWrF86dO4czZ87g+vXrAAqv3i6afkSj0WDOnDno0qULfv75ZyQmJqJTp04YPHhwsf2S+rDNbQvbu4IomYqVSVpamli+fLno1KmTsLOzE5IkieDgYPHpp5+K7Oxsce7cOdGuXTshSZLYunWrcbvHR+k8vqyIrR9rVjO2uW1he1ccSQgbmBHQwpKSkjBo0CCkpKSgVq1a6NGjB65cuYKzZ8/i5s2bGDhwIKKiovDHH39g3LhxuHz5MrZv344hQ4YA4Lcla8Q2ty1s7wqmaCxWAnfv3hX16tUTgYGBYtu2bcZvP/n5+eL+/fvipZdeEpIkiZCQEJGWlibOnz8v2rVrJxwdHcWOHTuM+6nM91apbNjmtoXtXfEYTOVw9+5d4evrKwIDA8VPP/1kPNGZl5dX7EM4evRoIUmSiIyMFHl5eeLo0aOiQ4cOwsXFRWzfvl2p8skMbHPbwvZWBoPJTJmZmaJly5bC3t5enDx50rj88ePFj4/I6dmzp7C3txf79u0TQgjxww8/iLZt2wpJkkRsbCy/TVkBtrltYXsrx8YHy5svPz8fYWFh0Gg02L17N3JzcwEUvx+SRqNBfn4+AODDDz+Eq6srtmzZAgAIDw/HwoULsXXrVvj5+fH4sxVgm9sWtreClE5Ga6bT6YzXL0ybNk1kZmY+9bXJycmiWbNm4oUXXihxFA5H5lgHtrltYXsrg9cxlYO7uzvmzp0LoPDbkiRJWLBgAVxcXIyvEf8djVOtWjV4eHhAo9FACGG8wruIzV/pbSXY5raF7a0MBlM5/fmDC6DYB7eo+37kyBFcv34d8+fPN35wyTqxzW0L27viMZhkUNIHd/78+XB1dQUAJCYm4uuvv4avry+CgoIAgMebrRzb3LawvSuYYgcRK6HHj0dPnz5d5ObmipSUFLFw4ULh4uIiPv/8c6VLJJmxzW0L27tisMckoz9/q8rJyUG1atUwf/58LFq0CJMnTwbAq8ArE7a5bWF7VxCFg7FS0ul0YubMmUKSJCFJkli8eLFxHUfmVE5sc9vC9rYs9pgswN3dHbNnz0ZeXh78/Pzw17/+FQCeGKVDlQfb3LawvS2Lk7haUE5ODrRaLQB+YG0F29y2sL0tg8FERESqwngnIiJVYTAREZGqMJiIiEhVGExERKQqDCYiIlIVBhMREakKg4mIiFSFwURERKrCYCIiIlVhMBERkaowmIiISFX+P0DTCNATfQ75AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -781,28 +541,33 @@ } ], "source": [ - "forest_plot(contrasts_mini_meta, contrast_type='mini_meta', contrast_labels=['mini_meta1', 'mini_meta2', 'mini_meta3']);" + "f_forest_delta2_custom_palette= forest_plot(contrasts, \n", + " contrast_labels = ['Drug1', 'Drug2', 'Drug3'], \n", + " custom_palette = ['gray', 'blue', 'green'], # or \n", + " # custom_palette = {'Drug1':'gray', 'Drug2':'blue', 'Drug3':'green'}\n", + " );" ] }, { "cell_type": "markdown", - "id": "0eb263d3", + "id": "b781aad8-f5de-4a10-b29a-c39b5f7aac7f", "metadata": {}, "source": [ - "### Horizontal Layout" + "### Plotting other effect sizes \n", + "Forest plots can be drawn for effect sizes other than mean_difference, such as ```deltas' g```, by setting ```effect_size```:" ] }, { "cell_type": "code", "execution_count": null, - "id": "89af4a33", + "id": "d5f2a4dd", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -810,7 +575,8 @@ } ], "source": [ - "forest_plot(contrasts_mini_meta, contrast_type='mini_meta', contrast_labels=['mini_meta1', 'mini_meta2', 'mini_meta3'], horizontal=True);\n" + "f_forest_deltasg = forest_plot(contrasts, \n", + " contrast_labels =['Drug1', 'Drug2', 'Drug3'], effect_size='delta_g');" ] }, { @@ -818,15 +584,40 @@ "id": "6787aa97", "metadata": {}, "source": [ - "## Embedding forest plots into existing axes with the ``ax`` parameter\n" + "### Embedding forest plots into an existing Axes \n", + "\n", + "You can plot a forest plot into an existing Axes as a subplot by using the with the ``ax`` parameter. \n", + "\n", + "``Example 1``:" ] }, { - "cell_type": "markdown", - "id": "180cae3a", + "cell_type": "code", + "execution_count": null, + "id": "927f9dae-dc1b-419e-81c6-8b4bf85462dc", "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "### Two forest plots plotted together in one figure" + "f_two_forest_plots, axes = plt.subplots(1, 2, figsize = [8, 4])\n", + "['Drug1', 'Drug2', 'Drug3']\n", + "forest_plot(contrasts, contrast_labels = ['Drug1', 'Drug2', 'Drug3'], ax = axes[0])\n", + "\n", + "forest_plot(contrasts_mini_meta, contrast_type = \"mini_meta\", contrast_labels = ['mini_meta1', 'mini_meta2', 'mini_meta3'], ax = axes[1])\n", + "\n", + "axes[0].set_title('Delta-Delta Analysis', fontsize = 12);\n", + "axes[1].set_ylabel('');\n", + "axes[1].set_title('Mini-Meta Analysis', fontsize = 12);\n" ] }, { @@ -847,7 +638,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -865,6 +656,79 @@ "axes[1].set_ylabel('')\n", "axes[1].set_title('Mini-Meta Analysis', fontsize = 20)\n" ] + }, + { + "cell_type": "markdown", + "id": "829f0d03", + "metadata": {}, + "source": [ + "``Example 2``:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e0d544f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABR8AAASlCAYAAAAh5657AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hUVf7H8c+dSTLpIQFCQgs9NKlBBJUmVUSxoGIBXXHdXeyu+1vUFbGhuzZcXNYKroIoKtgQRBGQpqCgIEV6CQQIkJ5Mkpnz+yMwEoEAksnNJO/X88wD986Zm88chpmT75x7rmWMMQIAAAAAAACAcuawOwAAAAAAAACAqoniIwAAAAAAAAC/oPgIAAAAAAAAwC8oPgIAAAAAAADwC4qPAAAAAAAAAPyC4iMAAAAAAAAAv6D4CAAAAAAAAMAvKD4CAAAAAAAA8AuKjwAAAAAAAAD8guIjAAAAAAAAAL+g+AggYE2ZMkWWZfluoaGhqlu3rgYMGKAXX3xR2dnZtubbuHGj7rnnHnXv3l2hoaGyLEvbt2+3NRMAAEAgqOzjvA8//FDXXHONmjRpovDwcCUnJ+u+++5TRkaGrbkAoDIKsjsAAJytRx99VI0bN1ZRUZHS0tK0YMEC3X333Xruuef08ccfq127drbkWrZsmV588UW1bt1arVq10urVq23JAQAAEKgq6zjvj3/8o+rWrasbbrhBDRs21Jo1azRx4kTNnj1bP/zwg8LCwmzJBQCVEcVHAAFv0KBBSklJ8W2PGTNG8+fP1yWXXKJLL71U69evP+kAMDc3VxEREX7JdemllyojI0NRUVF65plnKD4CAACcoco6znv//ffVq1evUvs6d+6skSNHaurUqRo1apRffi4ABCJOuwZQJfXp00f/+Mc/tGPHDr399tuSpJtuukmRkZHasmWLLr74YkVFRen666+XJDVq1Eg33XTTccfp1avXcQPLHTt26NJLL1VERITi4+N1zz33aO7cubIsSwsWLPC1i4uLU1RUlL+eIgAAQLVUGcZ5v32cJF1++eWSpPXr15fL8wSAqoLiI4Aq68Ybb5QkffHFF759xcXFGjBggOLj4/XMM8/oyiuvPKNj5ubmqk+fPvryyy9155136sEHH9TSpUv1f//3f+WaHQAAACdXGcd5aWlpkqRatWqd0c8FgKqO064BVFn169dXTEyMtmzZ4tvndrs1bNgwjR8//ncd8+WXX9bWrVs1a9YsXXbZZZKk2267TR07diyXzAAAADi1yjjOe/rpp+V0OnXVVVf9rp8PAFUVMx8BVGmRkZHHXQ3xz3/+8+8+3pw5c1SvXj1deumlvn2hoaG69dZbf/cxAQAAcOYq0zhv2rRpev3113XfffepefPmvzsDAFRFFB8BVGk5OTml1l0MCgpS/fr1f/fxduzYoaZNm8qyrFL7mzVr9ruPCQAAgDNXWcZ533zzjW655RYNGDBATzzxxO/++QBQVVF8BFBl7d69W5mZmaUGjC6XSw7H8W99vx1kHuXxePyWDwAAAL9PZRnn/fjjj7r00kvVtm1bvf/++woKYmUzAPgtio8Aqqy33npLkjRgwIBTto2NjVVGRsZx+3fs2FFqOykpSVu2bJExptT+zZs3//6gAAAAOCOVYZy3ZcsWDRw4UPHx8Zo9e7YiIyNPMz0AVC8UHwFUSfPnz9djjz2mxo0b6/rrrz9l+6ZNm2r58uUqLCz07fv000+1a9euUu0GDBig1NRUffzxx759BQUFevXVV8svPAAAAE6qMozz0tLS1L9/fzkcDs2dO1e1a9c+i2cEAFUbc8IBBLzPP/9cGzZsUHFxsfbt26f58+dr3rx5SkpK0scff6zQ0NBTHmPUqFF6//33NXDgQF199dXasmWL3n77bTVt2rRUu9tuu00TJ07U8OHDdddddykxMVFTp071/YxjT+vJzMzUv//9b0nSkiVLJEkTJ05UjRo1VKNGDd1+++3l1QUAAABVUmUd5w0cOFBbt27V3/72Ny1evFiLFy/23VenTh3169evnHoAAAKfZX47pxwAAsSUKVN08803+7ZDQkIUFxenc845R5dccoluvvnmUouQ33TTTXr//feVk5NzwuM999xzeu6555Senq6UlBRNmDBB9913nyRpwYIFvnbbtm3THXfcofnz5ysyMlIjRoxQ9+7ddeWVV2r58uXq2rWrJGn79u1q3LjxCX9WUlKStm/ffpY9AAAAUDVV9nHeydaRlKSePXuWOiYAVHcUHwGgHLzwwgu65557tHv3btWrV8/uOAAAACgnjPMA4OxQfASAM5Sfn6+wsDDfdkFBgTp27CiPx6NffvnFxmQAAAA4G4zzAKD8seYjAJyhK664Qg0bNlSHDh2UmZmpt99+Wxs2bNDUqVPtjgYAAICzwDgPAMofxUcAOEMDBgzQa6+9pqlTp8rj8ah169aaPn26rrnmGrujAQAA4CwwzgOA8sdp1wAAAAAAAAD8wmF3AAAAAAAAAABVE8VHAAAAAAAAAH5B8REAAAAAAACAX1Tr4uPevXv1yCOPaO/evXZHAQAAQDlinAcAAFA5VPvi47hx4xiUAgAAVDGM8wAAACqHal18BAAAAAAAAOA/FB8BAAAAAAAA+AXFRwAAAAAAAAB+QfERAAAAAAAAgF9QfAQAAAAAAADgF0F2BwAqm4LDe7Vj0TQZT7EaXHitImon2R0JAAAA5SD/YKp2fjNNMlLDHtcprGY9uyMBAFDlUXwEjmGM0dp3HlbB4TRJUuaOn9TlzjflcPJfBQAAIJAZ49WaqQ+qMPugJClz51p1uXOyLIuTwQAA8CcqKoBKBqO5+7bJ4QxRwaE9vv1FuRkqzs9SSGScjekAAABwtjyFBSrMOuDbLsxOl8edr6DQCBtTAQBQ9VF8RLVnjNGGD8br4IalkqTw+EbK279dkhTdoI2CI2JtTAcAAICzcWjTd9o692VZDqciE5srZ+8mSVKNxh3ldIXbnA4AgKqP4iOqvfyDu32FR0lyZx5Qi8vuk/F6VKt1D1mWZWM6AAAA/F6eIrc2fDBe3uIiSZLDFabmQ+6RLEu1GecBAFAhKD6i2gsKjZAsSzJGsiwFh8co/pw+dscCAADAWTLFhfIWF/q2vYX5qt22pxzOYBtTAQBQvbC6Mqq9kMg4tRhyr0Kiaiq8ZgMlX/43uyMBAACgHASFRSmh0yDfdv1uwyg8AgBQwZj5CEiKb9dH8e2Y7QgAAFDVNB00WomdB0sOhyJqJ9kdBwCAaidgZz4+8sgjsiyr1K1ly5Z2xwIAAABQiViWpYg6jSk8AgBgk4Ce+dimTRt9+eWXvu2goIB+OgAAAAAAAECVEtDVuqCgICUkJNgdAwAAAAAAAMAJBOxp15K0adMm1a1bV02aNNH111+vnTt3ltne7XYrKyvLd8vJyamgpAAAAAAAAED1E7DFx65du2rKlCmaM2eOJk2apG3btunCCy9Udnb2SR8zfvx4xcTE+G49e/aswMQAAAAAAABA9RKwxcdBgwZp2LBhateunQYMGKDZs2crIyND77333kkfM2bMGGVmZvpuCxcurMDEAAAAAAAAQPUS0Gs+HqtGjRpq0aKFNm/efNI2LpdLLpfLtx0ZGVkR0QAAAAAAAIBqKWBnPv5WTk6OtmzZosTERLujAAAAAAAAAFAAFx//+te/auHChdq+fbuWLl2qyy+/XE6nU8OHD7c7GgAAAE7iqaeekmVZuvvuu8tsN2PGDLVs2VKhoaE655xzNHv27IoJCAAAgHIVsMXH3bt3a/jw4UpOTtbVV1+tmjVravny5apdu7bd0QAAAHACK1as0Msvv6x27dqV2W7p0qUaPny4brnlFq1atUpDhw7V0KFDtXbt2gpKCgAAgPISsMXH6dOna8+ePXK73dq9e7emT5+upk2b2h0LAAAAJ5CTk6Prr79er776qmJjY8tsO2HCBA0cOFD333+/WrVqpccee0ydOnXSxIkTKygtAAAAykvAFh8BAAAQOEaPHq3Bgwerb9++p2y7bNmy49oNGDBAy5YtO+lj3G63srKyfLecnJyzzgwAAICzV2Wudg0AAIDKafr06frhhx+0YsWK02qflpamOnXqlNpXp04dpaWlnfQx48eP17hx484qJwAAAMofMx+B38g9sEPfT/qTlv3zKu385h274wAAENB27dqlu+66S1OnTlVoaKjffs6YMWOUmZnpuy1cuNBvPwsAAACnj5mPwBHF+dmygoK1+bOJyj+UKhmvdi58W3HNuigysZnd8QAACEjff/+99u/fr06dOvn2eTweLVq0SBMnTpTb7ZbT6Sz1mISEBO3bt6/Uvn379ikhIeGkP8flcsnlcvm2IyMjy+kZAAAA4GxQfAQkbfvydaUu/1CWM0ghEbGS8fruK3bn2ZgMAIDAdtFFF2nNmjWl9t18881q2bKl/u///u+4wqMkdevWTV999ZXuvvtu37558+apW7du/o6LaqAwN0NFuRkKr9VAluP41x8AAChfFB9R7RUc3qvU5R9KkoynWMXuPFkOp4zXoxpNOimmYRubEwIAELiioqLUtm3bUvsiIiJUs2ZN3/4RI0aoXr16Gj9+vCTprrvuUs+ePfXss89q8ODBmj59ulauXKlXXnmlwvNXlENZuQoOcioq3H+npkM6+Mu32vD+EzJej6IbtFHbG56QwxlsdywAAKo0io+AVfobb2dIqFJGv6qivCyF1awny2JpVAAA/Gnnzp1yOH79vO3evbumTZumhx56SA888ICaN2+uWbNmHVfErCr+O2uhPli4Sg6HpXuv6asB5/LFZ3k7eibLzkXTZLweSVLWrp+Vuf1HxTZNsTMaAABVHsVHVHuhNeKV1GuEdix8W85gl5oNvlPB4TEKDo+xOxoAAFXSggULytyWpGHDhmnYsGEVE8hG+w9n6YOFqyRJXq/RpFmLKD6Ws93LPtD2+ZMlWQqLqytZDt8SO0GhrA0KAIC/UXwEJDW44BrV63alLIeDmY4AAKDCBP1mzcuQINYgLE/F7rySwqMxkozyD+1VRO0kubMOqO65lymqXku7IwJlKsrL0q4l78rjzle9rkMVXruh3ZEA4IxRfASOcDj57wAAACpWXHSERl/eS69+8o1cIcG6/7r+dkeqUizLkmRJMpIkh9OpDqMmcKEZBIz17z+urF3rJUkHNy5VlzumyBnC2rAAAgvVFgAAAMBGQ3t00GUXtpd0tFiG8uIMCVPTgX/R1rn/leVwqNkld1F4REDJ2bPJt0xAcX623Fn7FV6L2Y8AAgvFRwAAAMBmFB39J7HzICV0LJlRSuERgSauxXlKX7dIkqXQ2ESFxibaHQkAzhjFR1QLKSkpSktLU0JCglauXGl3HAAAAFQgio4IVC0uu1c1GrWXpzBf8e36yOEMtjsSAJwxio+oFtLS0pSammp3DAAAAAA4bQ5nsBI6DbQ7BgCcFS7rCwAAAAAAAMAvmPkIAAAA2GjF+u2aPHupwkNDdMeVvZWUUNPuSAAAAOWGmY8AAACATbLzCjT2jU+0efd+rdmSqkfe+NTuSAEnJSVF9evXV0pKit1RAADACTDzEQAAALBJZm6+ioo9kiRjjA5kZNucKPCwtjeqOmOMJMmyLJuTAMDvw8xHAAAAwCb1atVQpxYNfdtX9OxoYxoAlc3hrav07XPXaenTlyv1u4/sjgMAvwszHwEAAACbWJalJ/54mX7cvFthrhC1SkqwOxKASmTTx8+pOD9LkrTti1dUq9UFckWxLiyAwELxEQAAALBRkNOpzslJdscAUAl5iwtLbRtPsU1JAOD347RrAAAAAAAqocb9bpWskl/bE7sMUWiNOjYnAoAzx8xH4AhvcZEytv+ooNBIRddvaXccAAAAANVcnfZ9VbNFV3mLixQSFWd3HAD4XSg+ApKM16M1Ux9Q9q51kqSGPa5Xwx7X2ZwKAAAAQHUXFBZldwQAOCucdg1Iyjuw01d4lKQ9XEkOAAAAAADgrFF8BCQFR8bKcjhLNiyHXDHx9gYCAAAAAACoAig+ApJCImqo1bCHFJnYXDUatVfLK8fYHQkAAAAAACDgseYjIMkYo7Ca9dT66odZyBkAAAAAAKCcUHxEtWeM0aZPntf+n76SJDW7+A4ldBpocyoAAACUh8yda7Xty9dlOZxq0v82RdVtbnckAACqFU67RrVXcGiPr/AoSdu/nmJfGAAAqphJkyapXbt2io6OVnR0tLp166bPP//8pO2nTJkiy7JK3UJDQyswMaoSb3GR1k1/RDl7Nyk7dYPWvfuIjDF2xwIAoFph5iOqPUew69cNy5IzJNy+MAAAVDH169fXU089pebNm8sYozfffFOXXXaZVq1apTZt2pzwMdHR0dq4caNv27KsioqLKsZTmC9PYb5vuyg3Q8ZbLMsZbGMqAACqF2Y+otpzRddS00G3Kyg0Uq7o2koe+le7IwEAUGUMGTJEF198sZo3b64WLVroiSeeUGRkpJYvX37Sx1iWpYSEBN+tTp06FZgYVUlweLRqte7h207oNEgOCo8AAFQoZj4CkhI7D1Ji50F2xwAAoErzeDyaMWOGcnNz1a1bt5O2y8nJUVJSkrxerzp16qQnn3zypLMkj3K73XK73aWOAUhS8uX3K6HTQFmWU9ENy34dAQCA8kfxEQAAAH61Zs0adevWTQUFBYqMjNTMmTPVunXrE7ZNTk7WG2+8oXbt2ikzM1PPPPOMunfvrp9//ln169c/6c8YP368xo0b56+ngABmWQ7FJLU78ndO4UdgyT+0V9u+fFUed54aXHidajRqZ3ckADhjnHYNAAAAv0pOTtbq1av17bff6s9//rNGjhypdevWnbBtt27dNGLECHXo0EE9e/bUhx9+qNq1a+vll18u82eMGTNGmZmZvtvChQv98VQQgPb9OE/L/nmllv9rmNLXL7Y7DnBG1r//uA5tWqHMHWu1bvpYFRcwqxtA4GHmIwAAAPwqJCREzZo1kyR17txZK1as0IQJE05ZUJSk4OBgdezYUZs3by6zncvlksv160XkIiMjzy40qgRPYYE2f/ZvGa9HkvTLR8+pZnI3WQ6nzcmA01NweK9kvJIkb3GhCnMOKyiU9zcAgYWZj8ARniK3it15dscAAKDK83q9pdZnLIvH49GaNWuUmJjo51SoiozX4ys8lmwXyxhjYyLgzCR0+nVd+qj6rRRWs56NaQDg92HmIyDpwM+L9MvHz8p4itXggmuV1OtGuyMBAFAljBkzRoMGDVLDhg2VnZ2tadOmacGCBZo7d64kacSIEapXr57Gjx8vSXr00Ud13nnnqVmzZsrIyNC//vUv7dixQ6NGjbLzaSBABYVGqGHPG7Vz4VuSZalx31FyOPkVCIGjcd9Rim2aIk9hnuKadZFlMX8IQODhkxeQtGXOf2Q8xZKkXYunK6HTILmia9mcCgCAwLd//36NGDFCe/fuVUxMjNq1a6e5c+eqX79+kqSdO3fK4fj1l+nDhw/r1ltvVVpammJjY9W5c2ctXbr0pBeoAU6l4YXXKrHTIMmyFBwebXcc4IxYlqXYJh3tjgEAZ4XiIyBJv73yIVdCBACgXLz++utl3r9gwYJS288//7yef/55PyZCdRQcEWN3BAAAqi3mbAOSmg++U45gl2Q5lNR7pFxRNe2OBAAAAAAAEPCY+YhqISEhodSfv1UzuZu63T9DxnjlcAarKD9b+QdTFRGfJGdIWEVGBQAAAAAAqDIoPqJaWLlyZZn3Z+5Yq11L3lWQK0Lx7ftq44dPyVOYr5Commr/h+eZCQkAAAAAAPA7UHxEtVecn62f3/mHvMVFkmUpY/uP8hS5JUmFOYd0YM181e8+zOaUAACgOjDGqMjjUUgQw3QAAFA1MKpBtefOPihvcWHJhjHyuPN+vdMYBYVxVUQAAPD7paSkKC0tTQkJCWWejbFj3yGN+e+HOpCRo14dW+jvNwyU08ES7WcrL32ndn0zXXI4ldTjOoXGJtodCQCAaoXRDKqFlJQU1a9fXykpKcfdF16rgSITm/m263Tsr7jmXRQcHqM6HQeoTvu+FRkVAABUMWlpaUpNTVVaWlqZ7d74dLEOZuZKkhas+kXLf95aEfGqNOP1aM1bD+jAum90YO0CrZ32Dxlj7I4F+JT1ewoAVBVVZubjU089pTFjxuiuu+7SCy+8YHccVDJHB/0nYjmcOufGp3Xol+VyhkYotmmKLMuq4IQAAKC6K/Z4S217vRTJzlZxfo6Kcg/7tgsO75XxFMsKCrYxFfCrsn5PAYCqokrMfFyxYoVefvlltWvXzu4oCFDOkFDVbttLcc26HFd49BS5dWjTd8pO3ShJyk7dqLQf5qjgcNmzFwAAAE5XTn6Bhvc9V5HhLklSSsskndemic2pAl9QeLSiG7b1bcc17yoHhUcAACpUwM98zMnJ0fXXX69XX31Vjz/+uN1xUAUUZOzXxllPq+BwmhI7D9bBX5YrN22LJKl2u4t04KevJEmO4FB1vPXfCoura2dcAAAQ4N74bIne+XKFgpwO3XttX3Vp2UgxEWGciXGaEhISSv15LMuy1Gb4o0pft0iW5VStNhdWdDwAAKq9gJ/5OHr0aA0ePFh9+556XT63262srCzfLScnpwISIhAY41X2nl+Ud3C3tsyZpOzUX1SUm6Gdi6b6Co+SlL7uG0klvwh4iwp0aNN3NiUGAABVwf7D2XrnyxWSSk67njRzoWpEhlN4PAMrV67U7t27T3oxH2ewS3Xa91N8uz5yOIPlKSxQTtoWeQrzKzgpAADVU0DPfJw+fbp++OEHrVix4rTajx8/XuPGjfNzKgQaY4zWz3hCh35ZLkkKia4tmWPWXLIsyRjJcig4PEaFWem+u8JrJ1V0XAAAUIU4HNZvtgN+bkClk39or3YvmyHLciq+fV+tn/G4inIOKTg8Ru1uelZhcVz9GgAAfwrY0c2uXbt01113aerUqQoNDT2tx4wZM0aZmZm+28KFC/2cEoEg/+BuX+FRkorzs2Q5nJKkyMRmanHZXxWR0EyxTTur7Q1Pqn73YarRpJOaDb5TsU062hUbAABUAbViInXrkAvkdFgKcwXrvmv62R2pSjFej9a8/XftWz1PaavmaN30sSrKzZAkFeVnK+2Hz+wNCABANRCwMx+///577d+/X506dfLt83g8WrRokSZOnCi32y2n01nqMS6XSy6Xy7cdGRlZYXlReQWFRhwzu9FSSFRNnXPjUyrMPqiIOk3kcAYpvm0vX/tGfUbaFxYAAFQ5V/dJ0ZU9O8myrONmQuLsFOVnlzprpTg/W0eX0JGMnC5+HwAAwN8Ctvh40UUXac2aNaX23XzzzWrZsqX+7//+77jCI3AyIZFxanHZX7Xj6zcV5IpQ80vvkSuqpoLDorTl8/8oc+daxTU/V40vutk3IxIAAKA8OZ0Be0KS7VJSUpSWlqaEhITj1n0MDo9RZN0WytnziyQpJqm9gsIjlbF1lWKSzlG9rpfZERkAgGolYIuPUVFRatu2bal9ERERqlmz5nH7q4IPF/6gqfO+U2xUuB688WI1rlvL7khVSnzbXqVmN0pS6vKZ2rf6C0lGe76dqfBaDZTQcYAt+QAAAHBiaWlpSk1NPeF9lmWp7fVPaP9PX8lyOBTfrq+cwa4TtgUAAP7BV6wBYOe+Q5o0a5Gycgu0a99hPTN9nt2RqrTCnEPK2r1eBRn7Sk7HliTLIfcxp+wAAAAgMAS5wlW3yxAldh5M4REAABsE7MzHE1mwYIHdEfwiJ9/t+7vXGGXnFdiYpmrL2P6Tfn7nYRlPkUKia8nhDJK3uFDOkDDFn9Pb7njACeWl79KOBf+TjFHDnjcoIr6R3ZEAAKi0jDEynmI5goLlzj6o/T9+qaCwKMW376sDaxcoZ88vimt+ruKan2t3VAAAqoQqVXysqpIb1lGXVo20Yv12OSxLNw3qZnekKiv125kynmJJUmFWuhpfNEphtRsoMrGZQiJq2BsOOAFjjNZOfUiFOYckSVm71+vcu/7H+qQAAJxA3oGdWvvOP1SYla6arS5Q9u71JZ+hxmj/j18qe89GyXIo7YfP1faG8arRqJ3dkQEACHgUHwOA0+HQ46Mu0460g4qKCFWtGK7K5y8h4TG/XvlaUliteoprlmJzKuDkvMVuFWb/uiRAUW6Git15Cg6LsjEVAKC87Ug7qDnf/qy46AgNvbCDgoP4kulMFGYfkixL2+ZPLvm7pIPrF5dqk5O25cg40CvJUvbu9RQfAQAoBxQfA4TDYXGRGT/yFBXo0KYVqtGkowqyDihv/w7Vad9Xsc262B0NKJMzOFRxyd10aOMySVKNpp0VFMoXFABQlRzOztMdL0yXu6hYxmu0a/9h3XtNX7tjBYwdC9/Wrm/ekSSF1awvyfjucwSHyltcWHJf7QbK27dNshySjGIatbchLQAAVQ/FR1R7xuvRmrfGKGfPL5Kkul0v1znXP2FzKuD0tbzi7zq0cZmMMarZspusoxdKAgAErMPZeRr3xifanHpArRslKt9d5Ltv1S87bUwWWIoLcn2FR0nKP7RHQaGRKs7PVmzTFCX1Hqm0Hz5XUFik6ncfpsztPyp7zy+KbZqi6PotbUwOAEDVwdWuUe3lpe/yFR4lad+qOTamAc6cwxmkWq0vVO02PeRwBtsdBwBKmTRpktq1a6fo6GhFR0erW7du+vzzz8t8zIwZM9SyZUuFhobqnHPO0ezZsysorf1yC9zKzivQW3OXa/2ONLmLirVq0y65goPkcFiyJHVOTrI7ZsCwHM5S6yA7goLV5c4p6nrPNLW+9hFFJjRRs4tHq1HvkQpyhatmcjc16j1SMQ3b2JgaAICqhZmPAWL1pl2auWi1YqPC9YfB3RUdEWZ3pCojJKqmHEEh8hYXSZZ15HQcAABQHurXr6+nnnpKzZs3lzFGb775pi677DKtWrVKbdocX+BZunSphg8frvHjx+uSSy7RtGnTNHToUP3www9q27atDc+g4ny2dI1e/GC+vF6jpr9ZbueqXp1U5PGoVkykLunOOoSnyxkSquZD7taWOZNkWQ41H3K3nMGhcgSFKGvXOlmWpaj6rThrAJVeweE0HVi3SKE16qhW6x68ZgEEFIqPASA9I0djXp4pj9crS5bSM3P0+K2X2R2ryggOi1Lra8dp1+LpCgqNUOO+t9odCQCAKmPIkCGltp944glNmjRJy5cvP2HxccKECRo4cKDuv/9+SdJjjz2mefPmaeLEifrvf/9bIZnt4PUa/WfmAnm9JesRbtmTrvDQEOUVFKpBfKyu7NVJUeGhNqcMTPHn9FH8OX1K7dv06QTt//FLSVKdjgPVfPAddkQDTkthzmGtfv0uFbtzJWOUl75bST2vP+Xj3FnpkjFyxdRW7v7tyti6SpF1myumYdX+IgdA5UPxMQDsOZihYo9XkmRktCX1gM2Jqp4ajdpxNUMEtLyDuyXjVVjNBnwTDqDS8ng8mjFjhnJzc9WtW7cTtlm2bJnuvffeUvsGDBigWbNmlXlst9stt9vt287JyTnrvBXN4XBI8pT83bL02v/dqDx3kerVilGQk6tbl5did56v8CiVLLnTpP+tcgZT3EXllJ26QcUFv76nHdy49ITFx+KCXOWl71R4rQba+/1s7fj6TUlSnQ79tf+n+TLeYklSy6seUK2W51dMeAAQxceA0Lx+HSXERSvtUJYkqV+XVjYnAlCZbP/6Te1e8p4kqW7XoWrSj9m7ACqXNWvWqFu3biooKFBkZKRmzpyp1q1bn7BtWlqa6tSpU2pfnTp1lJaWVubPGD9+vMaNG1dumSuaw2Hpr8P76Zl3vpDH49WfL++p2jWi7I5VpRivRxnbVsnrKZbTFS5PYb4kKcgVwZrJqNQi4hvJcgTJGK8ko6h6JRdDOrR5hbZ98aosZ5AaXDhcW+b8R8V5WXK6Inyvb0nat/oLSUe+nLYsHdywjOIjgApF8TEAhLmC9dK9w7X4p82KjYrQeW0a2x0JQCXhLS7U7qUzfNt7vp2lhj2uV5Ar3MZUAFBacnKyVq9erczMTL3//vsaOXKkFi5ceNIC5O8xZsyYUjMmV69erZ49e5bb8f3p25+36fXPlijcFawX7rxGjRJryungupDl7ZePn9eBtV9LkqIbtpWnsECWZanJgNtKXZQGqGxCYxPV9oYntG/1F3LF1FH97lfJU1SgDe8/KW9xoWRZ+uXj52Q8JTMbPe48WQ6HjDlyAIdD8nolWZIxikxoattzAVA9UXwMENERYbq42zl2xwBQyVgOp5zBob5vtx1BLmZvAKh0QkJC1KxZM0lS586dtWLFCk2YMEEvv/zycW0TEhK0b9++Uvv27dunhISEMn+Gy+WSy+XybUdGRpZDcv/LzivQI5M/UbHHK4dl6bEpn2nKgzfZHavK8RS5fYVHScrauVbn3TddQWHMLkXlVpC5X9vnT5bHna8G51+tnL2b9dOUvyo0NrGk8ChJxsgUF/36IEuq1aaHMrb8IGO8ajpotExxkQ5uWq6ousmqe+6l9jwZANUWxUcACGCWw6mWVz6gzbMnSsao6aA/yxFE8RFA5eb1ekutz3isbt266auvvtLdd9/t2zdv3ryTrhEZ6DJz831re3uNUXpm4K1VGQgcQcEKjqihorxMSUdOtQ4JszkVcGrrZzyu3H3bJBllbFst4ykpMubu367QuHoqOJQqSap33hUqzDmkjK0/KKZROzW7+A45g12ljhXfrs9vDw8AFYLiI3CEOytdjmCXgvkGHAEmtmkndbnjDbtjAMAJjRkzRoMGDVLDhg2VnZ2tadOmacGCBZo7d64kacSIEapXr57Gjx8vSbrrrrvUs2dPPfvssxo8eLCmT5+ulStX6pVXXrHzafhNvVo11KVVI61Yv12SNKx3Z3sDVVGW5VCb4Y9q21dvSMaoUZ+b5HDyqxDsd3RW98lmd+cfuaigJF/hsWTDK1d0bSUPvV+W06nIOk38nhUAfi8+cVHtGWO0Zc5/lPb9bMlyqMWQe/hWEACAcrJ//36NGDFCe/fuVUxMjNq1a6e5c+eqX79+kqSdO3ceucpzie7du2vatGl66KGH9MADD6h58+aaNWuW2rZta9dTOGtlFRcsy9Jjt1yqtdtSFRoSouSGdY5rg7NzYO0CbZkzSXI41PySu1WzRVe7IwE+K1euLPP++HZ9lfb9Z5KkiPjGKsrLVGHOIUmWElMGK6pu8wpICQBnh+Ijqr2Cw3tLCo+SZLza+uVrFB8BACgnr7/+epn3L1iw4Lh9w4YN07Bhw/yUqOKdqrjgdDrUvlmD0z5eQWGRfvhlp2pEhql1o7pnG69K8xQV6JePn5fxllyIY+PMf6rb32bIsrigDwJD04F/UmzTTvK481UzuZuMp0iZO9cqLK6ewms3tDseAJwWio+o9hxBIcdsWXKW2gYAAKgYh7Jy9crH3+hwdp6u6t1JXVo2Oq5NUbFH97z4njanHpAk3XLJ+br2oi4VnDRwGI/HV3iUJG9xoYzXK8tJ8RGBwbIcqtnivGP2hKpmcje5sw9q7TsPq+Bwmup1vUyJnQfblhEAToVPXVQLCQkJqlev3glPd3JF11LjfrfKERSi4IgYNb/0HhsSAgCA6u6pqXP09Q8bteqXnXr4tY+VnlFy8Rl3YbEmzPhKf/rXVE38cIGv8ChJsxattiltYAgKjVCD86/xbTfqPZK1HlElbJn9kjK2rlLBoVRt+fw/yknbYnckADgpPnlRLZzqdKd6XYeqXtehFRMGAABUKykpKUpLS1NCQkKZY5KdaYfkNUaSVOzxat/hLNWqEal3vlqhz5atLVmnes8BWZYlY4wclqW6tWIq6mkErKTeI5TQaZDkcMgVVdPuOFXOz9v2aML78+XxePWnoT1OOGMXJ3e67w+S5C0u0v418+X1FKkgc7/vQjSSVJh9UEpo6u+4APC7UHwEfqMgY782fDheBYf2KKHTxUrqPUKWZdkdCwAABKi0tDSlpqaest2g89rq7S++lSQ1iI9VkNOh5T9vVeqBw7IkGUmWJfXt3FK79h9Sjahw3XFlb/+GryJcMbXtjlAlGWM09vVPlJVXIBmjcW98qg8e/5NcIfyaebpO9/1BkjZ8+JQO/bJckuSKri0deWcIr52kmEbt/BcSAM4SnwqAJE9hvg5uWCZnaLj2/filcvZuloxXu5e+pxqN26tG4w52RwQAAFXUrv2H9OHCVQoNCdbDNw1WYbFHuQVu3f78dElSrZiIki9CjVF4qEs3DjxPiTWZ8Qj7ebxeZecVyByZsesuKlZ+YSHFRz8wxqtDm771bbuzDqjtDU9KXq+iGrSWM9hlYzoAKBufCqj2jNejn978m3L3bZUkhUTVlI4MoCSpuCDHrmgAAKCKKygs0j0vzlB2foFkpI070/TcHVfrT89M9bVJz8zVXVf1UUxUuNo0SlRcdISNiYFfBTmdurJXJ834+ntJUv8urVUjMtzmVFWL11Os/T99JU9hvsJrNVRe+i5JUnB4tKLrt5YjKNjmhABwahQfUe3lpe/yFR4lqTg/W5bTKeMpVmRiM8U2S7ExHXBqOfu2avtXk2WMV4373KTIxOZ2RwIAnKb9h7OVmZvv296wc58kKbFmjLbtTZfXW/KFaKtGiWpaj1OHUfncOuQC9emUrGKPV8kN69gdp8r55ePnlP7zQkmWXDXiVadDfxmvR/W7XUnhEUDAoPiIas8VVVOOYJe8xYWSLEXEN1bra8bKnZ2u8NpJXBERlZoxXv087WEV5WVKMlo77R/qes9UWQ6n3dEAAKchsWaM6taK0d6DWTLGqGvrxpKkO6/qLWOM9h7M1OU9OlJ4RKVlWZaa1Y+3O0aVdWjjsiN/M3Jn7FO9rpcpvFZDWzMBwJmiqoJqLygsSm2ve1y7lrynoNAINepzs4IjYhQcwVpKqPy8xYUqyj3s2y7Oz5bHnaegsCgbUwEATldwkFMT7rpGc79dp/DQYDWtG68Rj09WRk6erut3rh75wxC7IwKwUWRic2XtXi9JCnKFyxVNoRdA4KH4CEiKbtBaba59xO4YwBlzBoeqdpueOvDzQklSzeTuFB4BIMDUiAzXNReVLPPy52emat+hLHmN0eufLlG3Nk2UlFDT5oSBzesp0qFfvpUsh2q26MrZAQgorYY9qF2L35XHnae6XYfKGRJqdyQAOGMUHwEgwLW47D7VPqe3ZIxim3a2Ow4A4AwtXP2LXvtkscJcIcrOK5D3mAvf5bkLbUwW+IwxWvfuo8rY+oMkqVbrHmp5xf/ZnAo4fcHhMWrS/492xwCAs0LxEQACnOVwKq5ZF7tjAAB+h6zcfI1/63N5vEaWZSkmIlROhyWP1+j8c5oquUGC3REDWnFelq/wKEnp6xbJe+m9XKgDAIAKRPERAAAAsElOvlueI1e0NsaooLBY7477o7LzC1SvVg1ZlmVzwsDmDI1QUFi0iguyJVkKiaopi4sJIsB5itw6vHmlnK5wRSY216ZPnlP27g2KS+6mZoP+wtICACodPnkBVIiiYo8cliWn02F3FAAAKo3EmjG6sH0zffPjZknS9f3PVUxkmGIiw2xOFjgSEhJK/XkshzNIba9/XDsWvCXL4VSjPiMp6CLgGGN0cONS5e3fodhmXbRlziTl7NkoSYqs20I5ezdLxqt9q+Yoql6yEjr0tzkxAJRG8RGA3324cJVe+XiRnA6H7hveT306tbQ7EgAAlYJlWXpoxGBt2r1foa5gJdWJsztSwFm5cmWZ90cmNOXCgghoaT/M0ZbPJ0qWQzsXT5e8Ht99uWlbfm1oWSrOy7IhIQCUjSlIAehQVq6+/Xmb0jNy7I4CnFJ2XoH++9FCebxGhcUePf/ulzLHLKQPAEB153BYSm5Yh8JjBTm06TvtXvq+8tJ32R0FOC2HNn9X8hfjlbyeI6dVW5LlkCs2Uc5glyQpJDJO8ef0sS8oAJwEMx8riZSUFKWlpSkhIaHMb2937DukO55/R/nuIrlCgjThzmvUtF7tCkxaNeXs3azU5TPldIWrYc/rFRJRw+5IVYYxJbejvEe2OeMJAABUtL3ff14yg0yWdi6apo5/nKiwuLp2xwLKFF2/lQ5v+k6yHJIxatz/Nh1c/42coZFq0neUnK5w5R/ao4j4JDlDWLIBQOVD8bGSSEtLU2pq6inbfblindyFxZJK1tCb8+3PGn1FLz+nq9qKC3K15u0x8hQWSJLy0neo3Yh/2pyq6oiOCNUtl5yvNz5bIofl0J1X9ZbDQeXxTJzulxMAAOB4OWlbtHPRVFmWQ4V5mUf2GnmL3crc/iPFR1R69btdKUewS3n7tqlW6wsU2zRFdVMGl2oTHB5tUzoAODWKjwGmdo0oeY9MIzNeo/jYKJsTBT531gF53Hm+7dy0rTamqZquvaiLLrugvSzLUmhIsN1xAs7pfjkBAABK83qKtXbaQyrOL1muyBkcqpLTVSUZo4iEprbmqyo8Xq9kxIUF/cBbXKR9q+fKFBcqqc9NnKEFICBRfAwQX/+wUdO/WqHYqHAN7NpGa7ftUcfmDTT0wg52Rwt4YTXrKaxmfeUf3C1JqtnqApsTVU1hrhC7IwAAgGrGU5Bb6gIcnsI8Nex5g/LTd6t2256KqtvCxnRVw9c/bNQz0+fJ6/XqL5f30pDz29kdqUrZ+NEzOrh+sWRZSvthjjr9+b9yOPkyH0BgofgYAPYezNT4tz+XMSULkrdpXFeTx4y0O1aV4XAGq/1Nz+jAzwvldEWodpsedkcCAADVyOHsXH2+/GeFuYI1uNs5CglmiF5egsKjVaNJR2VsXSVJqtXqQjW8cLjNqaoOj9erZ6fPU2FRybJQEz/4Wn06Jysi1GVzsqrj8KajF5sxKshIU8HhvQqv1dDeUABwhhjZBICDmTm+C3Z4vUb7DmWV/QCcsaCwKCWmXGJ3DAAAqpzx48frww8/1IYNGxQWFqbu3bvr6aefVnJy8kkfM2XKFN18882l9rlcLhUUFPg7boUrKvborgnvad+hLHmN0epNuzTulkvtjlVlWJal1teM1cGNy2VZDtVMPs/uSFWO1/vrlQWNMTLHXGkwIydPxhjFRkVo36Es/bh5t5rVr60mdblg5umKqpeszJ0/S5KCwiLliom3OREAnDmKjwEguWGCmjeI16Zd+yVJV/XqZHMiAACA07Nw4UKNHj1aXbp0UXFxsR544AH1799f69atU0RExEkfFx0drY0bN/q2LatqXqxs78FM7T2Y6dtesWGHjWmqJoczWLVbX2h3jCrJ6XBo9BW99OIH82W8Rn+45HxFhoVKkj5Y8IP++9EiSdLQC9trzrfrVFBYJMuy9MQfL1OXlo1sTB44Wl71oHYvnSGPO191z730yLqlABBYKD4GgOAgp16442r9uHm3YqPC1aw+33YBAIDAMGfOnFLbU6ZMUXx8vL7//nv16HHypU4sy1JCQoK/49muTmy0akSGKSuvQDJS60aJdkcCzsjg7ueod6dkeb1efbFine6bOEMtGtTRzEWrfG1mffOjjn5/YEn6auUGio+nKTgsSo0v+oPdMQDgrFB8DBAhwUHq0qqR3TEAAADOSmZmySy/uLi4Mtvl5OQoKSlJXq9XnTp10pNPPqk2bdqctL3b7Zbb7S71+EDgCgnSC3deo5mLVinMFayr+6TYHQk4Y+GhIVqyZrMmzSqZ6fjTllQ5HQ5JJadgOyxL3iOnYxsZNYiPtSsqAMAGFB8BAABQIbxer+6++26df/75atu27UnbJScn64033lC7du2UmZmpZ555Rt27d9fPP/+s+vXrn/Ax48eP17hx4/wV3a/q1a6h26/sbXcM4IRSUlKUlpamhIQErVy58qTtdu07LMtSyUUyLUutGyVo6550eY3R7Vf0Vk6+W0vWbFbLhgkU2QGgmqH4CAAAgAoxevRorV27VosXLy6zXbdu3dStWzffdvfu3dWqVSu9/PLLeuyxx074mDFjxujee+/1ba9evVo9e/Ysn+AVqNjj0cxFq7UnPUP9urTmNGzYLi0tTampqWW2McaoW9ummjrvOxUUFslIGt7vXKUkJ0n6dc3WK3p29HfcgHN0eYnqsMwEgOqL4iMAAAD87vbbb9enn36qRYsWnXT24skEBwerY8eO2rx580nbuFwuuVwu33ZkZOTvzmqn1z5ZrA8XrpLlsDTn25/1xt9HKrFWjN2xgJNatHqTnpn+hTxeoxsHdFXN6Ag1rccVrU9XWbNJjyrKzZSn2K3QmHilfveR9v80X5EJTdSk/x/lDAmrgJQAcHYoPlYhRcUefbZsjTJz8jWga2slxDFQReWxJz1DQU6H4mOj7Y4CAKhAxhjdcccdmjlzphYsWKDGjRuf8TE8Ho/WrFmjiy++2A8J/e9UM5sW/7RZb3y2RGGuYOW7S2aNGa+RV0a/7N5H8RGVltdr9K935qqgsFiSNHn2Us184s8KDw2xOVnVkbZqrjbP/rdkjGKbddHhzSskSbn7tsoZEqYm/f9oc0IAODWKjwHOGKOMnDxFhLo04f35+uK7dXJYlj5Z+pPefPAmRYS6Tn0QwM/+M3OBZi5aLUkadckFuuYi1vkBgOpi9OjRmjZtmj766CNFRUUpLS1NkhQTE6OwsJIZOyNGjFC9evU0fvx4SdKjjz6q8847T82aNVNGRob+9a9/aceOHRo1apRtz+NslDWzKSs3X4+/OVser1cOy/IVbRyWpZDgILVK4rRrVF5GRsUer2/b6zXyeL1lPAJnattXb5QspCn5Co+SJONV/uG9NqUCgDND8TGAeTxejZvyqZat3arw0BA5j6yl4jVGmTn52pF2UK0b1bU5Jaq7jJw8X+FRkqZ8vlTDeneWw2HZFwoAUGEmTZokSerVq1ep/ZMnT9ZNN90kSdq5c6ccDofvvsOHD+vWW29VWlqaYmNj1blzZy1dulStW7euqNgVJjvP7SvWeI1RYXGx/jq8n/amZ6p3p2TFx0bZnDDwFbvztH/NfFmWU/Ht+sgZzJfz5cXpcOhPQ3vqpQ+/ljHSyEHdFBUeanesKsUZ7JKnIFdHrxweFBal4vxsybKU0HGAveEA4DQFbPFx0qRJmjRpkrZv3y5JatOmjR5++GENGjTI3mAV4Nuft2l72kFFhru0bO1WSVK+u1BR4aGyLEuWJYWFBKt+7TibkwJScJBTTodDHq9XlqTQkGAdqZOroLBI7361UumZORrc7RxtTzuo9+avVO0aUbrv2r6cog0AVYA5MmOnLAsWLCi1/fzzz+v555/3U6LKpW6tGHVv20RLj4zprut7rgac28bmVFWHMUZrpz6knD0bJUkHNyxR2+sftzlV1XLZBe3Vp1OyvF6jmEjWHyxvLS67Txtn/kueonw17nOzarW6UJk71yisVgNF1E6yOx4AnJaALT7Wr19fTz31lJo3by5jjN58801ddtllWrVqldq0qboDtk+X/qQJM+bLkhTk/HWGgCVLDevEqXNykjKy83RJ93aKjuBbR9gvItSlv13fX5NmLlSQ06k/XdZDc779WXVio/XV9xs0b+V6WZK++n69iopLZn6kHsjQs9O/1NN/vsLe8NWQ8XpkOZzK3LlWmz5+Xp5itxr3HaX4tr3sjgYAVZJlWXr45ku0cWeawkJC1LhuLbsjVSlFeZm+wqMkZWxbJW9xkRxBwTamqnqY7eg/NRq1V9d73i61r1arC2xKAwC/T8AWH4cMGVJq+4knntCkSZO0fPnyKl18XPxTyVUejaQij1fnNKmrtVv3KC46Qrdf0VtN63FVOVQ+fTq1VJ9OLZWdV6Bbn35LB7NyJUnREaEyxshI8hb/OjPGa4z2Z2TblLb6yN2/XdvnT5aM1ODCa7Vz0TRlbP1BEXWaqjDnoIryMiVjtOnj5xTbtLOCwzj1DwD8welw+JbKyXcX6dOlP6nAXaSLu52jmjERNqcLbMFhUQqJqqXCnEOSpLC4urKcAfsrEAAAAalKfPJ6PB7NmDFDubm56tat20nbud1uud1u33ZOTk5FxCtXLRsm6IdfdkqyZIzRbZf1VLN6teVwWLIs1tCDPVJSUpSWlqaEhIQyF9VfszXVV3iUdHTpGt8C+7VrRGrb3oOSpGG9O/szcrVRcHivUr+dJUdQiBK7XKKtc19R5o6fFNO4g7J3rVNRXpYkKXPnWnmLCiRJufu3lTz4yKmSxuuRt7BAovgIAH73+JufacWG7bJkae6KdZo8ZqSCg5x2xwpYlsOpc258SruXvifL4VSD869hzFzOCgqLNPe7dfJ4PBpwbhtFhLGmJgCgtIAuPq5Zs0bdunVTQUGBIiMjNXPmzDIXIh8/frzGjRtXgQnLz4+bd2nWotWKiQzX8IvO1d5DmerdMVnJDevYHQ1QWlqaUlNTy2yTk1+gWjGRclglhXPLspTSMkmdk5OUnpmjPp2TFRcV4ZvJ2yixZgWlr7q8xUX68c2/qSg3Q5J0YN0iFWYflIzRoQ1LS7ctKpBk6WhFOKpeC2Xv3iBJim/fT64YZlUDgD+lZ+QoJNipH37ZKWNKriK871CW9h3OUv3asXbHC2hhcYlqfslddseossa+/ol++GWnLEuat2K9Xrr3Oi4sWI4ytv+kX2b9S57CAjW66CYldh5sdyQAOGMBXXxMTk7W6tWrlZmZqffff18jR47UwoULT1qAHDNmjO69917f9urVq9WzZ8+Kivu7pWfm6O//nXnkgh2Wzm3VSI/depndsYDTNnXed5oye6kcDkuXnN9Oe9MzlVAzWrcMPv+4b8c7JTe0KWXgykvfpR0L3pKMVw16XK/Dm75V+oalCq+dpKIjp5lJUmFWumQ5JBnJcigsrq7yD+6WJNVomqLC7HTl7d+ukMhYJV/2V0mWvMWFCqvVwJ4nBgDVxEsfLtCsb1bLYVmqV7uGUg9kSJYUGxmu+BrMOkflVezxHDkrq+SEic2pB5SRk6e4aJYLKC+/fPSMCnMOSzLa8vl/VDO5m0IiubAogMAS0MXHkJAQNWvWTJLUuXNnrVixQhMmTNDLL798wvYul0su16+FjsjIyArJebb2pGeo2FNyIQ4jo82pB2xOBJy+rNwCTZldMsvO6zWas3ytPnn6dr4RLydHr+J5dC2rjO0/yuPOkyTlpm1RUFi0iguyJWMU3bCt8tN3qSgvU8HhMWp9zVjlHdghSYprfq4kqTDnsIIjasjBelgAUCH2HcrSrG9WSypZ8/hgZo6G9ztXBYVFuuyC9goJ5v0YlVeQ06nGiTW1Y1/JOCQuOkIxEVzxujx5igrkW6tIkrfIffLGAFBJVanRjNfrLbWmYyBJSEgo9eexmtevozpx0dp3qGRttr5dWlVoNuBsOBwlazp6j6wf6HA4xFJLZ6as9wdvsVuF2em+bY87T7KskukHlkM1GrVXZGJTOYJcqtNxgGS8yj+0R2Fx9eQMCVVYXN1Sx3NFc5VVAKhIx67naElyhQTrpkEnX8McqGzG33aF3vnyOxV7vLqmT4qcTofdkaqUxhfdos2z/y0Zo4SOAxUam2h3JAA4YwFbfBwzZowGDRqkhg0bKjs7W9OmTdOCBQs0d+5cu6P9LmVdpCPMFayX7hmub37apLioCHVr26QCkwFnJzIsVH+5opf+O2uhnA6H/jq8Hwu9n6Gy3h+cwaGKa3GeDv2yXJIU1aCN8vZtk6cwT5ZlKaHzxarRqF2px0QmNPVrXgDA6YuLjtAdV/bWq58sVmhIkP5+/UC7IwFnpGZMhG6/srfdMaqshI4DFNeiq7xFboXWYL1/AIEpYIuP+/fv14gRI7R3717FxMSoXbt2mjt3rvr162d3NL+IiQzTJd1LCgh5BYVavWmX4mOj1Kx+/AnbFxV79NKHC7Rq0051adlIfx7ak28hYZvLLmivS7qdI1mS08HrsLy1vHKMDm1cJmOMarbspqK8LGXvXq+I+MYqLsjW3u9nq0bjjgqL45tyAKiMLr2gvS69oL3dMQBUUiERNeyOAABnJWCLj6+//rrdEWyR7y7UX56dptT0DEnSvdf01aDz2kqSCgqLNOfbn+X1epXvLtLsZWtkJH20+Ec1rBPHoBa2ovjtPw5nkGq1vtC37YqqKVerC5S+Yak2vP9ESZsglzrc+qLCa9a3KyYAAKiC1m3fq4kffK1ij1d/uqwHFw8EABwnYIuP1dWPm3f7Co+SNOub1b7i48OvfaxVm3bJsqSYiDBZDkvGa+SwLB3IzLEpMSDlFrj11coNCgpyqm9KS4UE8dZzJlJSUpSWlqaEhIQyT8E+Kmv3BnnceTrw8wKVrCBm5C1269Cm7yg+AgCAcmOM0djXP1Zmbr5kpLFvfKz3H/uTXCGM9QAAv+JToZI4VXGhsLhYa7akqrCo2LfPYVmqW6uGpJLTrFdt2iWp5DoTGTn5cgUHye0tVqgrWP25SA1s4vUa3f+fD7Rp135J0vK1W/XoqEttThVY0tLSlJqaelptdyx8W7u+eUeS5IopvS5QRO2kcs8GAACqL4/Xq8zcfB25rqAKCouVX1hI8REAUAqfCpVEWcWFomKP7nlxhn7ZtU+SdFGnltqx/5ASa0brql6d9PTUubIk1atVQ3sPZUqSakZH6IU7r9GOtINqVj9esVHhFfVUgFIOZuX4Co+StPznrfJ4vaz96Cd7vp3l+7s7c58SOg2SO/OAarbsrtimne0LBgAAqpwgp1OX9+ioDxeukiT17dxSNSL5vQMAUBrFxwCwcWear/AoSWu2pWrqw7fI6zW64bHXdTAzV5IUFx2uId3byWuMhvXurPjYKMXHRtkVG5Ak1YgMV2xUuDJz8iVJSQlxFB7LWUHGPu1aPF3GGAVHxspz2C0ZryxHkJJ63ajg8Bi7IwIAgCrqT5f1UJ9OySr2eNUqiYvbAQCOR/ExANSMjpRllZxO7bAs1TlSUMx3F+pAxq9rOaZn5uoPg89XeGiIXVGB4wQHOfXs7Vfp3a9WKsjp1A39u9odqUoxxmjt1AdVkFHyBUVweIxiGrZVsTtPSb1uoPAIAAD8yrIsJTdMsDsGAKASo/gYABJrxejv1w/UO1+uUFx0hO4adpG+/mGjMnLydE6TelqzteR07U4tGlJ4RKXUID5Ofx3e3+4YVZK32K2Cw3t920W5h9XyT5MUHMasZwAAAACA/Sg+Bog+nVuqT+eWkqSJH3ytjxb/KEmKj43SXVf1UVCQU306JdsZETip/Yez9OHCVQpyOjWsd2fFRIbZHanKcAaHKqZxB2VuWy1Jim7QRkGhkfaGAgAAAADgCIqPAWJz6n59umSNYqPCtWDVL779+w9nq2n92qyvgkqr2OPRvf+eoQOZOZKRVm/epYn3DLc7VpXS+uqHdWDtAsl4Vfuc3rIsy+5IAACgmvhl1z79Z+YCFXu8+uOlF6pd0/p2RwIAVDIUHwPA4ew83fviDLmLi2WMFBsZJseR4kJwsFN1a9awNyBQhsPZedp3ONu3vXHnPq52Xc6cwS4ldBxgdwwAAFAFJSQklPrzWMYY/ePVj3Q4J1+S0UOvfqT3H7tNIcH8mgkA+BWfCgFg575Dyi8sOmaPpUsvaK/M3Hxd3qMDp7CiUouLjlDDOnHatf+wJKP2zRpQeKwg+YdSlbnzZ0UlNpcxXm369EV5CvPUqPdNqtXqfLvjAQCAALBy5cqT3ufxenU4O0/myHa+u0i5BYUUHwEApfCpEACa1autmMgwZecWyGuMzj+nqUZf0cvuWMBpcToceu72Yfps2RoFBzl1Sfdz7I5UZbmzD2r3kvckYxTb/Fytf/9xmeIiyXIoJKKGCnMPS8Zo48ynFZP0toLDo+2ODAAAAliQ06lLzm+nT5b8JEnq0b65YqPCT9p+/+FspWdmq1n9eIUE8asoAFQXvOMHgIgwl166Z7i+XLlesdERGtCltd2RgDMSExmm6/qda3eMKs0Yo7VTH1T+wVRJ0v61C2Q8Ht/9RXmZkimZl2C8HhUX5FB8BAAAZ+2OK3urd8dkFXu9ate03knbLVu7VeMmfyKP16hJ3Vp64c5rFOYKrsCkAAC7cO5jgKgTF63r+3fVxee1ldPJPxuA0rzFhcpP3yUZr2S88rhzS/4uScarGo07+trGtThPobFcpApAxRg/fry6dOmiqKgoxcfHa+jQodq4ceMpHzdjxgy1bNlSoaGhOuecczR79uwKSAvgTFmWpXOa1lPH5scvrZOekaM3P1+m9+av1LR538njLfkidOuedK3cuMOOuAAAGzDzEYDfZeXma/bytQp2OnVxt3P4ltsPnMEuxSSdo8wdayRZikhoqtpte+nw5hWKbtBaDS8crrz0XfIUFiiqXguuiA2gwixcuFCjR49Wly5dVFxcrAceeED9+/fXunXrFBERccLHLF26VMOHD9f48eN1ySWXaNq0aRo6dKh++OEHtW3btoKfAVC9paSkKC0tTQkJCWWu/3gsj9crj9eru158V+kZOTIyqhEZLofDkvdIATKWdesBoNqg+AjArzxer+799wztPHLBmW/XbdM//3Kl3bGqnLz0XWp00S3K2r1eMl7V6dBfQa5w1T/vcl+biPhG9gUEUG3NmTOn1PaUKVMUHx+v77//Xj169DjhYyZMmKCBAwfq/vvvlyQ99thjmjdvniZOnKj//ve/J3yM2+2W2+32befk5JTTMwCqt7S0NKWmpp5W2+y8Aj306kdat32vmteP1/7D2aXua9u4nlIPHNalF7RX2yYnP0UbAFC1UHwEcNYSEhJK/XmsQ1m52rHvkG971aZd8ni9XPG6HG2fP0W7l86QJNU99zI16f9HmxMBwMllZmZKkuLi4k7aZtmyZbr33ntL7RswYIBmzZp10seMHz9e48aNK5eMAE5fekaOpn35nTwer4KDnNqwI02StGn3foW5guUuKpYxUrum9fX0n6+wOS0AwA4UHwPEwcxcLVi1UbFR4erVMVkOB6dMovIo6xSc2KhwxcdGKT0zRzJSs/rxZRYeN+7cp70HM9SpRZKiI0L9EbdK8RYXavey933be777SA173qAg18mvNAkAdvF6vbr77rt1/vnnl3n6dFpamurUqVNqX506dZSWlnbSx4wZM6ZUwXL16tXq2bPn2YcGUKa/vzxTu/aXfNHsCv7110uHZWnAua0V5HQq3BWiK3p1PNkhAABVHMXHAJBXUKjRz03ToaxcGUm/7NqnPw1lMI3AEOR06rnbh+n9BT8oOMipq/t0PmnbeSvW6Z/TvpAk1YqJ1Mv3X6/oCNYDKovlcMoZHCpPYb4kyRHkksPJmpoAKqfRo0dr7dq1Wrx4cbkf2+VyyeVy+bYjIyPL/WcAKK3Y49GOtIO+7Xx3keJjo7T/cLYSa8boun7nKjbqxGu7AgCqD4qPAWDT7v06mJXr2164ehPFRwSUOnHRGn1FrxPet3D1L3rz82WKDHOpsMjj25+emaPvN+5U707JFZQyMFkOp1pe9aC2zJ4oY4yaDvyTHEEUHwFUPrfffrs+/fRTLVq0SPXr1y+zbUJCgvbt21dq3759+064vAcA+wQ5nUppmaSVG3bIktSsQbwm3HGNMnLzFBcdwTI7AABJFB8DQoP4WLmCg1RUXFKYSU6qc4pHABXrTK+C+N36bdq4Y59aNIzXk//7XF5j5LAshbmC5bAseU3JVRDr1orxd/QqIbZJR6Xc/rrdMQDghIwxuuOOOzRz5kwtWLBAjRs3PuVjunXrpq+++kp33323b9+8efPUrVs3PyYF8Hs8cvMQfbFinTwer/qd20rBwU7VrhFldywAQCVC8TEAxEVH6J9/uVIfL/5RcdERur7/uXZHAko51VUQPV6v1mxJVZDTqf0ZWRr/1hxZliUZI3OkjdcYWZalvimttGv/IV3SvZ2SGzLDBQAC3ejRozVt2jR99NFHioqK8q3bGBMTo7CwkqU1RowYoXr16mn8+PGSpLvuuks9e/bUs88+q8GDB2v69OlauXKlXnnlFdueB4ATc4UEacj57eyOAQCoxCg+BojWjRLVulGib3vvwUwdyspVcsM6CnI6bUwGlM0Yo8fe/ExLftoiqWQm729nN+5JL7ny6bUXddE1F6XYlhUAUP4mTZokSerVq1ep/ZMnT9ZNN90kSdq5c6ccx5ye2b17d02bNk0PPfSQHnjgATVv3lyzZs0q8yI1AAAAqJwoPgag+d9v0FNT58gYqVVSgp65/SqFBPFPicrpUFaer/AoSbv3H5aRfAXI26/srdDgYEWGudS4bi37glZiR9c4O921zjJ3rNXhLd8rqn5L1WzR1Z/RAOCUjDGnbLNgwYLj9g0bNkzDhg3zQyIAAABUJCpWlcSpigurN+3ShwtXKS46XD9uSdXRcfz6HWlau2WPOiU3rKiowBmJCAtRaEiw3EVFsmQpNipc1/fvql927VPX1o3VpWUjuyNWeqdaRzN9w1Jt/uzfkvEq8dzLtGvRNMmyJONV8uV/U+02XKAKAAAAAGAPio+VRFnFhfSMHI15eaY8Xq8sWYoMd5U6bbVGVFhFxQTOWGhIsB4ddale+2SxgoMcuv2K3mpWP97uWFWG8Xr0y6xn5C12S5J2ffOOZEkyXsly6PDWVRQfAQCA3+w/nK2pX3yrYq9Xwy/qovrxsXZHAgBUMhQfA8Cegxkq9nglSUZGTodDrRol6kBGtob17qwmdWvbnBAoW8fmDfTSvcPtjlElGa9XXk/RsTtK/rQckvEqukFre4IBAIBqYczLM7X7wGHJSCs37NDUh//AmvQAgFIoPgaA5vXrKCEuWmmHsiRJg85rq5sv7m5zKgCVgSMoWEm9btSOr9+UJDW48DpFJjbV4c3fK6pesuLbXWRzQgAAUFUVezzaue+Qb/tQVq6ycgsUFx1hYyoAQGVD8TEAhLmC9dK9w7V4zRbFRYWra+vGMsbIGMnhsOyOB8BmDc6/uqTIaIxc0SUX7anZ4jybUwEAgKouyOnUua0a6bv12yVJLRsmKDYq3N5QAIBKh+JjgIiOCNPF57WVJH378zaNf/tzFRZ7dOuQC3R5j442pwPKVlhcrOVrtykoyKGurRvL6XDYHanKcUXVtDsCAACohsbefIm+/H6DPB6P+qa0kmUxOQIAUBrFxwD0z3fmKregUJL0n5kL1atjMt8wotIyxuihVz7Sqk27JEn9urTS364bYHOqqsWdfVCpyz6QMV7VP+9KuWJYBxYAAFSMkOAg3ySJshhjtGj1Jm1PO6gL2jVT03qMVwCguqD4GCA+WfKjps1bodiocBUWFZe6z3PkYjRAZXQwK9dXeJSkL1es133X9mP2Yzkxxmjt1AeVfzBVknR480p1/ssrsiz6FwAAVB4zF63WpFkL5bAsvTt/pV65/waujA0A1QTFxwCwa/8hvfj+15JKFnGOj43S/oxseb1G1/TprFo1Im1OCJxcdHioIsJcyisolCWpTlw0hcdy5C1yKz/91+JuweG9Ki7IVXBYlI2pAAAApK17DujNOcvlsCwdysqVJHmNkbfYo5+2plJ8BIBqguJjAMjKLfD93WuMJOnDx/+kIo9HNSI53RqVW0hwkJ7+0+V68/NlCg5yatSQC+yOVKU4Q0IV1aC1snetlywpMqGZgkL5QgIAANjHGCOP16u/TfpQ2Ud+lwlzBUuSHJYlIym5QR0bEwIAKhLFxwDQsmGCOjRvoNWbdsmypBsGdFVEmMvuWMBpS26YoCdvu/yU7XLyCzRhxnxt25OuAV3baFjvzhWQLvC1uXac9q2eK2OMEjoMYKF3AABQYb5bv03PTv9SHo9Xfx7aQ9+s2axla7YqqU6cMnPyfe1yCwp166UXaPf+DPXq2II1HwGgGqH4GACcToee+tPl2rx7v2Iiw5QQF2N3JKDceL1Gm3bvU0hQkD5a/KMWrd4krzF65eNv1LRebXVq0dDuiJVekCtc9bqeurgLAABQnrxeoyf+97nyCwplJP1z2he+M7W27zuoWjGRSs/MkSRd2L6Zru6dYmNaAIBdKD4GCKfDoeSGCXbHAMqVMUZPTZ2jr3/YKEmqWzPGN2CVpP2Hs+2KBgAAgFMwxshdWKSjo7djx3GWLHVoXl/ntmosp8Oh889pak9IAIDtKD4C8Lsd+w7p3S9XKCjIqev7natFP27Sql92qmm9eF/hUZLSDmfJsiwZY1SrRqS6tWliY2oAAACUxel06KaLu+v1T5dIkoZe2EFrtuzWlj3piooI1bV9z1VSnTibUwIA7EbxEYBfFRV79NeJM0ounGRJK9ZvU3pmydUOV2zYIYfDktdrZFmW4qIi9K+/XKndBw6rbZO6igwLtTk9AAAAynLtRV3Up1NLebxeJdaMkcfr1YGMbMVFRSgkmF83AQAUHwH4WWZOvjKOLjZupPTMXF/B0eGw1KVlI+0+cFiu4CDdc3Vf1Y+PVf34WHtDAwAAQJKUkJBQ6s8TiY+N8v3d6XCwRj0AoBSKjwD8Ki46QskN62jjzn2SpHOa1NW67WmSjGSkay9KUdsm9ewNCQAAgBNauXKl3REAAAGO4iMAv3I4LP3zz1dq/g8bFOR06qLOLbX7wGGt3bpHbRonqknd2nZHBAAAAAAAfkLxEcBZO9XpOOGhIbqkezvfduPEWmqcWKtCsgEAAAAAAPtQfARw1jgdBwAAAAAAnIjD7gAAAAAAAAAAqiaKjwAAAPCrRYsWaciQIapbt64sy9KsWbPKbL9gwQJZlnXcLS0trWICAzhtxhht2rVf63fslTHG7jgAgEqI064BAADgV7m5uWrfvr3+8Ic/6Iorrjjtx23cuFHR0dG+7fj4eH/EA3AWXv1ksWZ8/b0kqX+X1rr/uv42JwIAVDYBO/Nx/Pjx6tKli6KiohQfH6+hQ4dq48aNdscCcAJFxR4tWbNZ367bJq+Xb8QBoLoZNGiQHn/8cV1++eVn9Lj4+HglJCT4bg5HwA5dgSqp2OPRBwt+8G1/sWKdMnLybEwEAKiMAnYEt3DhQo0ePVrLly/XvHnzVFRUpP79+ys3N9fuaACOYYzRP177SI+88akeevUjPffuPLsjAQACRIcOHZSYmKh+/fppyZIlZbZ1u93Kysry3XJyciooJVB9OR0ORYWHyrIkS5IrOEhhISF2xwIAVDIBe9r1nDlzSm1PmTJF8fHx+v7779WjR48TPsbtdsvtdvu2GZQC/ncwK1ffb9zp2/5ixTrdc01fOZm9AgA4icTERP33v/9VSkqK3G63XnvtNfXq1UvffvutOnXqdMLHjB8/XuPGjavgpED1ZlmWxt0yRC++P1/FHq/+NLSHXCEB+ysmAMBPqswnQ2ZmpiQpLi7upG0YlAIVLzo8VBGhIcpzF8mSFB8bReERAFCm5ORkJScn+7a7d++uLVu26Pnnn9dbb711wseMGTNG9957r2979erV6tmzp9+zAtVdm8Z19fL9N9gdAwBQiVWJCoDX69Xdd9+t888/X23btj1puzFjxigzM9N3W7hwYQWmBKqnkOAgPXnb5erYvIG6tGqkx/841O5IAIAAdO6552rz5s0nvd/lcik6Otp3i4yMrMB0AAAAOJkqMfNx9OjRWrt2rRYvXlxmO5fLJZfL5dtmUApUjNaNEvX0n0//6qYAAPzW6tWrlZiYaHcMAAAAnKGALz7efvvt+vTTT7Vo0SLVr1/f7jgAAAD4jZycnFKzFrdt26bVq1crLi5ODRs21JgxY5Samqr//e9/kqQXXnhBjRs3Vps2bVRQUKDXXntN8+fP1xdffGHXUwAAAMDvFLDFR2OM7rjjDs2cOVMLFixQ48aN7Y4EAACAE1i5cqV69+7t2z66NuPIkSM1ZcoU7d27Vzt3/npxssLCQt13331KTU1VeHi42rVrpy+//LLUMQAAABAYArb4OHr0aE2bNk0fffSRoqKilJaWJkmKiYlRWFiYzekAAABwVK9evWSMOen9U6ZMKbX9t7/9TX/729/8nAoAAAAVIWAvODNp0iRlZmaqV69eSkxM9N3effddu6MBAAAAAAAAUADPfCzr23MAAAAAAAAA9gvYmY8AAAAAAAAAKjeKjwAAAAAAAAD8guIjAAAAAAAAAL+g+AigQni8Xnm9rNUKAABQ1Xi9Rh6v1+4YAIBKKmAvOAMgcHy0+Ef9d9ZCBTkd+uvw/urZoYXdkQAAAFAOvv5ho56dPk9er1d/uaKXLunezu5IAIBKhpmPAPwqJ79AL334tYo9XhUUFuuZd+ZxtXoAAIAqwOs1enb6PLmLilXk8erf73+t3AK33bEAAJUMxUcAfuX1Gh1ba/R6vaL2CAAAEPiMTKlldYwxfMkMADgOxUcAfhUdEaabLu4uSXI4LI2+srccDsvmVAAAADhbTodDf7mipxwOS5akPww+X5FhoXbHAgBUMqz5CMDvru93ri67oJ0clkPhoSF2xwEAAEA5uaR7O/XulCxjDIVHAMAJUXwEUCEYjAIAAFRNEaEuuyMAACoxTrsGAAAAAAAA4BcUHwEAAAAAAAD4BcVHAAAAAAAAAH5B8REAAAAAAACAX1B8BAAAAAAAAOAXXO06wOzdu1d79+61O0aVlZiYqMTERLtjVFm8fv2L1y8ABDY+J/2Lz0n/4vXrX7x+AQSyal18TExM1NixYwPmTdztdmv48OFauHCh3VGqrJ49e2ru3LlyuVx2R6lyeP36H69fAPgV4zz8Fp+T/sPr1/94/QIIZJYxxtgdAqcnKytLMTExWrhwoSIjI+2OU+Xk5OSoZ8+eyszMVHR0tN1xqhxev/7F6xcAAhufk/7F56R/8fr1L16/AAJdtZ75GKg6dOjAh44fZGVl2R2hWuD16x+8fgGgauBz0j/4nKwYvH79g9cvgEDHBWcAAAAAAAAA+AXFRwAAAAAAAAB+QfExgLhcLo0dO5ZFhv2E/vUv+te/6F8ACGy8j/sX/etf9K9/0b8AAh0XnAEAAAAAAADgF8x8BAAAAAAAAOAXFB8BAAAAAAAA+AXFRwAAAAAAAAB+QfGxEnjkkUdkWZbdMXw50tPT7Y5Srm666SY1atTI7hi66aabFBkZaXcMAABQwRjr+Q/jPAAAKr9qX3x87733ZFmWZs6cedx97du3l2VZ+vrrr4+7r2HDhurevXuZx77ppptkWZbvFh0drfbt2+vZZ5+V2+0ut+cQKKZMmeLri8WLFx93vzFGDRo0kGVZuuSSS055vF69epXq37i4OHXp0kVvvPGGvF6vP55ClVCRr/nIyEg1adJEV111lT744INq9e/iz9e7w+FQdHS0kpOTdeONN2revHn+eAoAUCUw1qsYjPMqB8Z5FYNxHgCcmWpffLzgggsk6bgPjaysLK1du1ZBQUFasmRJqft27dqlXbt2+R5bFpfLpbfeektvvfWWnnzyScXFxemvf/2rRo4cWX5PIsCEhoZq2rRpx+1fuHChdu/eLZfLddrHql+/vq9///GPf6i4uFi33HKLHnjggfKMXKVU5Gv++eef13XXXadNmzbpqquu0kUXXaSsrKzyezIBwB+v9//973/617/+pUsvvVRLly5V//79dc0116ioqKg8owNAlcBYr2IxzrMX47yKxTgPAE5PkN0B7Fa3bl01btz4uA/oZcuWyRijYcOGHXff0e3T+YAOCgrSDTfc4Nv+y1/+oq5du+rdd9/Vc889p7p165bDswgsF198sWbMmKEXX3xRQUG/vgSnTZumzp07n9GpQDExMaX697bbblNycrImTpyoxx57TMHBweWavSqo6Ne8JD3++ON66qmnNGbMGN1666169913T/p4Y4wKCgoUFhZ2uk+pUvPn612SnnrqKd155536z3/+o0aNGunpp58+6eO9Xq8KCwsVGhp65k8EAAIUY72KxTjPXozzKhbjPAA4PdV+5qNU8kG7atUq5efn+/YtWbJEbdq00aBBg7R8+fJSpxEsWbJElmXp/PPPP+Of5XA41KtXL0nS9u3bT9pu8uTJ6tOnj+Lj4+VyudS6dWtNmjTphG0///xz9ezZU1FRUYqOjlaXLl2O+wbu22+/1cCBAxUTE6Pw8HD17NnzuG89j0pPT9fVV1+t6Oho1axZU3fddZcKCgpKtSkuLtZjjz2mpk2byuVyqVGjRnrggQdO6xSj4cOH6+DBg6VOISgsLNT777+v66677pSPL0t4eLjOO+885ebm6sCBAydt98wzz6h79+6qWbOmwsLC1LlzZ73//vsnbPv222/r3HPPVXh4uGJjY9WjRw998cUXpdp8/vnnuvDCCxUREaGoqCgNHjxYP//88wmPt3XrVg0YMEARERGqW7euHn30URljSrXJzc3VfffdpwYNGsjlcik5OVnPPPPMce1+r4p8zR/197//Xf3799eMGTP0yy+/+PY3atRIl1xyiebOnauUlBSFhYXp5Zdf1vbt22VZlqZMmXLcsSzL0iOPPFJq34IFC5SSkqLQ0FA1bdpUL7/8cqVYY8ufr3dJcjqdevHFF9W6dWtNnDhRmZmZvvssy9Ltt9+uqVOnqk2bNnK5XJozZ44WLFggy7K0YMGCUsc6WZ/PmDFDrVu3VmhoqNq2bauZM2dWmjW2AOB0MNYrzZ9jPcZ5jPMY5zHOA4Dfoviokg/ooqIiffvtt759S5YsUffu3dW9e3dlZmZq7dq1pe5r2bKlatas+bt+3pYtWySpzMdPmjRJSUlJeuCBB/Tss8+qQYMG+stf/qKXXnqpVLspU6Zo8ODBOnTokMaMGaOnnnpKHTp00Jw5c3xt5s+frx49eigrK0tjx47Vk08+qYyMDPXp00fffffdcT/76quvVkFBgcaPH6+LL75YL774ov74xz+WajNq1Cg9/PDD6tSpk55//nn17NlT48eP17XXXnvK59+oUSN169ZN77zzjm/f559/rszMzNN6/Kls3bpVTqdTNWrUOGmbCRMmqGPHjnr00Uf15JNPKigoSMOGDdNnn31Wqt24ceN04403Kjg4WI8++qjGjRunBg0aaP78+b42b731lgYPHqzIyEg9/fTT+sc//qF169bpggsuOO6XDo/Ho4EDB6pOnTr65z//qc6dO2vs2LEaO3asr40xRpdeeqmef/55DRw4UM8995ySk5N1//3369577z3r/pEq/jV/1I033ihjzHFr12zcuFHDhw9Xv379NGHCBHXo0OGMjrtq1SoNHDhQBw8e1Lhx43TLLbfo0Ucf1axZs84qb3nw9+tdKhmYDh8+XHl5ecfNZpg/f77uueceXXPNNZowYcIZDyQ/++wzXXPNNQoODtb48eN1xRVX6JZbbtH3339fLtkBoCIw1ivNn2M9xnmM8xjnMc4DgOMYmJ9//tlIMo899pgxxpiioiITERFh3nzzTWOMMXXq1DEvvfSSMcaYrKws43Q6za233nrK444cOdJERESYAwcOmAMHDpjNmzebJ5980liWZdq1a+drN3bsWPPbf4q8vLzjjjdgwADTpEkT33ZGRoaJiooyXbt2Nfn5+aXaer1e35/Nmzc3AwYM8O07evzGjRubfv36HZfj0ksvLXWsv/zlL0aS+fHHH40xxqxevdpIMqNGjSrV7q9//auRZObPn3/C/pg8ebKRZFasWGEmTpxooqKifM9z2LBhpnfv3sYYY5KSkszgwYNPeIxj9ezZ07Rs2dLXv+vXrzd33nmnkWSGDBniazdy5EiTlJRU6rG/7d/CwkLTtm1b06dPH9++TZs2GYfDYS6//HLj8XhKtT/al9nZ2aZGjRrHvR7S0tJMTExMqf0jR440kswdd9xR6jiDBw82ISEh5sCBA8YYY2bNmmUkmccff7zUMa+66ipjWZbZvHnzKfvmVPz9mj+ZVatWGUnmnnvu8e1LSkoyksycOXNKtd22bZuRZCZPnnzccSSZsWPH+raHDBliwsPDTWpqqm/fpk2bTFBQ0HH/tyqKP17vbdq0Oen9M2fONJLMhAkTfPskGYfDYX7++edSbb/++msjyXz99del9p+oz8855xxTv359k52d7du3YMECI+m4/1cAUFkx1iudwx9jPcZ5jPMY5zHOA4CTYeajpFatWqlmzZq+b5J+/PFH5ebm+q741r17d99pK8uWLZPH4zmtNVGkktMqateurdq1a6tZs2Z64IEH1K1btxNege5Yx66DkpmZqfT0dPXs2VNbt271TbefN2+esrOz9fe///24tT2OnoKwevVqbdq0Sdddd50OHjyo9PR0paenKzc3VxdddJEWLVp03JXpRo8eXWr7jjvukCTNnj271J+//Xb2vvvuk6TjvlU+kauvvlr5+fn69NNPlZ2drU8//fR3nZqwYcMGX/+2atVK//73vzV48GC98cYbZT7u2P49fPiwMjMzdeGFF+qHH37w7Z81a5a8Xq8efvhhORyl/6sc7d958+YpIyNDw4cP9/Vtenq6nE6nunbtesKrCd5+++2ljnP77bersLBQX375paSS/nU6nbrzzjtLPe6+++6TMUaff/75afbOyfnzNV+WyMhISVJ2dnap/Y0bN9aAAQN+1zE9Ho++/PJLDR06tNS6Ws2aNdOgQYN+f9hyVF6v97KcrG979uyp1q1b/65j7tmzR2vWrNGIESN8xz96zHPOOef3hwWACsZYr2LHeozzfj0O4zzGeeWBcR6AQFftLzgjlQwMunfv7hucLVmyRPHx8WrWrJmkkg/oiRMnSpLvg/p0P6BDQ0P1ySefSCq5Olzjxo1Vv379Uz5uyZIlGjt2rJYtW6a8vLxS92VmZiomJsZ3Sk/btm1PepxNmzZJUplXXMzMzFRsbKxvu3nz5qXub9q0qRwOh+/Ukh07dsjhcPj656iEhATVqFFDO3bsOOXzq127tvr27atp06YpLy9PHo9HV1111Skf91uNGjXSq6++KsuyFBoaqubNmys+Pv6Uj/v000/1+OOPa/Xq1aXWLjp23ZgtW7bI4XCU+YF+tH/79Olzwvujo6NLbTscDjVp0qTUvhYtWkhSqf6tW7euoqKiSrVr1aqV7/6z5c/XfFlycnIk6bjn1rhx4999zP379ys/P/+416OkE+6zQ3m93svij749+lo7Wd8e+0scAFRmjPUqdqzHOO9XjPMY55UHxnkAAh3FxyMuuOACffLJJ1qzZo1vTZSjunfvrvvvv1+pqalavHix6tate9zA4mScTqf69u17Rlm2bNmiiy66SC1bttRzzz2nBg0aKCQkRLNnz9bzzz9/3LfXZTna9l//+tdJ11c59puuEznZQs5nu8Dzddddp1tvvVVpaWkaNGhQmWv3nExERMQZ9+8333yjSy+9VD169NB//vMfJSYmKjg4WJMnTz5u8fZTOdq/b731lhISEo67/9ir3lU2/nrNl+Xo+kK/HeSc6IqHJ3t9eTyes85hh/J4vZelOvctAJwOxnon54+xHuM8ezHOq1iM8wCgbJX3E7OCHf22b/HixVqyZInuvvtu332dO3eWy+XSggUL9O233+riiy/2a5ZPPvlEbrdbH3/8sRo2bOjb/9tTO5o2bSqp5MPoZN/8HW0THR192oO3TZs2lfoWbfPmzfJ6vb4FjJOSkuT1erVp0ybft7SStG/fPmVkZCgpKem0fs7ll1+u2267TcuXL9e77757Wo8pDx988IFCQ0M1d+5cuVwu3/7JkyeXate0aVN5vV6tW7fupIP5o/0bHx9/Wv3r9Xq1detW37fgknxXBDy2f7/88ktlZ2eX+nZzw4YNvvvLgx2v+bfeekuWZalfv36nbHt0hkZGRkap/b+dERAfH6/Q0FBt3rz5uGOcaJ9d/Pl693g8mjZtmsLDw09r5sLp9u3R11pl71sAOB2M9X5VEWM9xnklGOedGOO808c4D0BVwJqPR6SkpCg0NFRTp05VampqqW8HXS6XOnXqpJdeekm5ubnlclpCWZxOp6SSq+EdlZmZedygqX///oqKitL48eNVUFBQ6r6jj+3cubOaNm2qZ555xjdd/1gHDhw4bt9vr7L473//W5J866ocHaC88MILpdo999xzkqTBgweX/QSPiIyM1KRJk/TII49oyJAhp/WY8uB0OmVZVqlv/7Zv337cFfOGDh0qh8OhRx999LgZCEf7d8CAAYqOjtaTTz6poqKi437Wifr36GkuR48zceJEBQcH66KLLpJU0r8ej6dUO0l6/vnnZVlWua1vU9Gv+aeeekpffPGFrrnmmuNO9zqR6Oho1apVS4sWLSq1/z//+U+p7aMzTmbNmqU9e/b49m/evLlc1k0qL/56vXs8Ht15551av3697rzzzuNOATuRpKQkOZ3OU/Zt3bp11bZtW/3vf/8r9f6xcOFCrVmzpnyeAABUEMZ6v6qIsR7jPMZ5ZWGcd3oY5wGoKpj5eERISIi6dOmib775Ri6XS507dy51f/fu3fXss89KKp81UcrSv39/hYSEaMiQIbrtttuUk5OjV199VfHx8dq7d6+vXXR0tJ5//nmNGjVKXbp00XXXXafY2Fj9+OOPysvL05tvvimHw6HXXntNgwYNUps2bXTzzTerXr16Sk1N1ddff63o6GjfOkVHbdu2TZdeeqkGDhyoZcuW6e2339Z1112n9u3bS5Lat2+vkSNH6pVXXlFGRoZ69uyp7777Tm+++aaGDh2q3r17n/ZzLWt9In8ZPHiwnnvuOQ0cOFDXXXed9u/fr5deeknNmjXTTz/95GvXrFkzPfjgg3rsscd04YUX6oorrpDL5dKKFStUt25djR8/XtHR0Zo0aZJuvPFGderUSddee61q166tnTt36rPPPtP5559fanAZGhqqOXPmaOTIkeratas+//xzffbZZ3rggQdUu3ZtSdKQIUPUu3dvPfjgg9q+fbvat2+vL774Qh999JHuvvtu37fwZ8tfr/ni4mK9/fbbkqSCggLt2LFDH3/8sX766Sf17t1br7zyymkfa9SoUXrqqac0atQopaSkaNGiRb4ZBMd65JFH9MUXX+j888/Xn//8Z9+gvm3btlq9evVp/zx/O9vXe2Zmpq9v8/LytHnzZn344YfasmWLrr32Wj322GOndZyYmBgNGzZM//73v2VZlpo2bapPP/1U+/fvP67tk08+qcsuu0znn3++br75Zh0+fNjXtyf6JRcAKivGer+qqLEe4zzGeWVhnFca4zwAVZpdl9mujMaMGWMkme7dux9334cffmgkmaioKFNcXHxaxxs5cqSJiIg4ZbuxY8ea3/5TfPzxx6Zdu3YmNDTUNGrUyDz99NPmjTfeMJLMtm3bjmvbvXt3ExYWZqKjo825555r3nnnnVJtVq1aZa644gpTs2ZN43K5TFJSkrn66qvNV199dVyOdevWmauuuspERUWZ2NhYc/vtt5v8/PxSxysqKjLjxo0zjRs3NsHBwaZBgwZmzJgxpqCg4KTPc/LkyUaSWbFiRZn9kZSUZAYPHlxmG2OM6dmzp2nTps0p240cOdIkJSWV2vf666+b5s2bG5fLZVq2bGkmT558wn8HY4x54403TMeOHY3L5TKxsbGmZ8+eZt68eaXafP3112bAgAEmJibGhIaGmqZNm5qbbrrJrFy5slSOiIgIs2XLFtO/f38THh5u6tSpY8aOHWs8Hk+p42VnZ5t77rnH1K1b1wQHB5vmzZubf/3rX8br9Z7y+Z4Jf7zmJflu4eHhplGjRubKK68077///nHP05iy/73z8vLMLbfcYmJiYkxUVJS5+uqrzf79+40kM3bs2FJtv/rqK9OxY0cTEhJimjZtal577TVz3333mdDQ0NPKXt788Xo/tm8jIyNN8+bNzQ033GC++OKLEz5Gkhk9evQJ7ztw4IC58sorTXh4uImNjTW33XabWbt2rZFkJk+eXKrt9OnTTcuWLY3L5TJt27Y1H3/8sbnyyitNy5YtT5kbACoTxnr+G+sxzmOcxzjveIzzAKCEZcwx53sAQBUydOhQ/fzzz76rVaL8dOjQQbVr19a8efPsjgIAAKohxnn+wzgPQHljzUcAVUJ+fn6p7U2bNmn27Nnq1auXPYGqiKKiIhUXF5fat2DBAv3444/0LQAAqBCM8/yDcR6AisLMRwBVQmJiom666SY1adJEO3bs0KRJk+R2u7Vq1arTWvgcJ7Z9+3b17dtXN9xwg+rWrasNGzbov//9r2JiYrR27VrVrFnT7ogAAKCKY5znH4zzAFQULjgDoEoYOHCg3nnnHaWlpcnlcqlbt2568sknGZCepdjYWHXu3FmvvfaaDhw4oIiICA0ePFhPPfUUA1IAAFAhGOf5B+M8ABWFmY8AAAAAAAAA/II1HwEAAAAAAAD4BcVHAAAAAAAAAH5B8REAAAAAAACAX1B8PEtTpkyRZVkKDQ1Vamrqcff36tVLbdu2rdBMX331lf7whz+oRYsWCg8PV5MmTTRq1Cjt3bv3hO2XLl2qCy64QOHh4UpISNCdd96pnJycCs18MvSvf9G//kX/AkBg433cv+hf/6J//Yv+BYDTR/GxnLjdbj311FN2x5Ak/d///Z8WLFigyy+/XC+++KKuvfZavffee+rYsaPS0tJKtV29erUuuugi5eXl6bnnntOoUaP0yiuvaNiwYTalPzH617/oX/+ifwEgsPE+7l/0r3/Rv/5F/wLAaTA4K5MnTzaSTIcOHYzL5TKpqaml7u/Zs6dp06ZNhWZauHCh8Xg8x+2TZB588MFS+wcNGmQSExNNZmamb9+rr75qJJm5c+dWSN6y0L/+Rf/6F/0LAIGN93H/on/9i/71L/oXAE4fMx/LyQMPPCCPx1MpvvXq0aOHHA7Hcfvi4uK0fv16376srCzNmzdPN9xwg6Kjo337R4wYocjISL333nsVlvlU6F//on/9i/4FgMDG+7h/0b/+Rf/6F/0LAKcWZHeAqqJx48YaMWKEXn31Vf39739X3bp1z+jxeXl5ysvLO2U7p9Op2NjYM86Xk5OjnJwc1apVy7dvzZo1Ki4uVkpKSqm2ISEh6tChg1atWnXGP8df6F//on/9i/4FgMDG+7h/0b/+Rf/6F/0LAKfGzMdy9OCDD6q4uFhPP/30GT/2n//8p2rXrn3KW8eOHX9XthdeeEGFhYW65pprfPuOLjycmJh4XPvExETt2bPnd/0sf6F//Yv+9S/6FwACG+/j/kX/+hf961/0LwCUjZmP5ahJkya68cYb9corr+jvf//7Cd/MT2bEiBG64IILTtkuLCzsjHMtWrRI48aN09VXX60+ffr49ufn50uSXC7XcY8JDQ313V9Z0L/+Rf/6F/0LAIGN93H/on/9i/71L/oXAMpG8bGcPfTQQ3rrrbf01FNPacKECaf9uCZNmqhJkyblnmfDhg26/PLL1bZtW7322mul7jv6AeZ2u497XEFBwe/6gPM3+te/6F//on8BILDxPu5f9K9/0b/+Rf8CwMlRfCxnTZo00Q033OD71ut0HV2L41ScTqdq1659WsfctWuX+vfvr5iYGM2ePVtRUVGl7j/6jdzRaffH2rt37xmvV1IR6F//on/9i/4FgMDG+7h/0b/+Rf/6F/0LACfHmo9+8NBDD53xmh/PPPOMEhMTT3nr0qXLaR3v4MGD6t+/v9xut+bOnXvCqf9t27ZVUFCQVq5cWWp/YWGhVq9erQ4dOpx2/opE//oX/etf9C8ABDbex/2L/vUv+te/6F8AODFmPvpB06ZNdcMNN+jll19WUlKSgoJO3c3ludZHbm6uLr74YqWmpurrr79W8+bNT9guJiZGffv21dtvv61//OMfvm/E3nrrLeXk5GjYsGGn/Fl2oH/9i/71L/oXAAIb7+P+Rf/6F/3rX/QvAJyYZYwxdocIZFOmTNHNN9+sFStWKCUlxbd/8+bNatmypTwej9q0aaO1a9dWWKahQ4fqo48+0h/+8Af17t271H2RkZEaOnSob/uHH35Q9+7d1bp1a/3xj3/U7t279eyzz6pHjx6aO3duhWU+GfrXv+hf/6J/ASCw8T7uX/Svf9G//kX/AsAZMDgrkydPNpLMihUrjrtv5MiRRpJp06ZNhWZKSkoykk54S0pKOq79N998Y7p3725CQ0NN7dq1zejRo01WVlaFZj4Z+te/6F//on8BILDxPu5f9K9/0b/+Rf8CwOlj5iMAAAAAAAAAv+CCMwAAAAAAAAD8guIjAAAAAAAAAL+g+AgAAAAAAADALyg+AgAAAAAAAPALio8AAAAAAAAA/ILiIwAAAAAAAAC/oPgIAAAAAAAAwC8oPgIAAAAAAADwC4qPAAAAAAAAAPyC4iMAAAAAAAAAv6D4CAAAAAAAAMAvKD4CAAAAAAAA8AuKjwAAAAAAAAD8guIjAAAAAAAAAL+g+AgAAAAAAADALyg+AgAAAAAAAPALio8AAAAAAAAA/ILiIwAAAAAAAAC/qNbFx7179+qRRx7R3r177Y4CAAACBOOHwMC/EwAAOFOMH/yj2hcfx40bx4sKAACcNsYPgYF/JwAAcKYYP/hHtS4+AgAAAAAAAPAfio8AAAAAAAAA/ILiIwAAAAAAAAC/oPgIAACA323RokUaMmSI6tatK8uyNGvWrDLbf/jhh+rXr59q166t6OhodevWTXPnzi3V5pFHHpFlWaVuLVu29OOzAAAA+H0YC50axUcAAAD8brm5uWrfvr1eeuml02q/aNEi9evXT7Nnz9b333+v3r17a8iQIVq1alWpdm3atNHevXt9t8WLF/sjPgAAwFlhLHRqQXYHAAAAQOAaNGiQBg0adNrtX3jhhVLbTz75pD766CN98skn6tixo29/UFCQEhISyismAACAXzAWOjVmPgIAAMA2Xq9X2dnZiouLK7V/06ZNqlu3rpo0aaLrr79eO3fuLPM4brdbWVlZvltOTo4/YwMAgCosJyen1LjC7Xb77WeV11ioMqP4CBzD4/HYHQEAgGrlmWeeUU5Ojq6++mrfvq5du2rKlCmaM2eOJk2apG3btunCCy9Udnb2SY8zfvx4xcTE+G49e/asiPgAUCGMMXZHAKqVnj17lhpXjB8/3m8/q7zGQpUZp10Dxzh8+LBq1apldwwAAKqFadOmady4cfroo48UHx/v23/sqUvt2rVT165dlZSUpPfee0+33HLLCY81ZswY3Xvvvb7t1atXU4AEUGUUFhbK5XLZHQOoNhYuXKgOHTr4tv31/688x0KVGcVH4Bj5+fl2RwAAoFqYPn26Ro0apRkzZqhv375ltq1Ro4ZatGihzZs3n7SNy+Uq9YtBZGRkuWUFALt5vV67IwDVSmRkpKKjo/36M8p7LFSZcdo1cAyKjwAA+N8777yjm2++We+8844GDx58yvY5OTnasmWLEhMTKyAdAFQ+LA8FVC3VbSzEzEfgGLm5uXZHAAAgoOTk5JT6Fn7btm1avXq14uLi1LBhQ40ZM0apqan63//+J6nk9KKRI0dqwoQJ6tq1q9LS0iRJYWFhiomJkST99a9/1ZAhQ5SUlKQ9e/Zo7NixcjqdGj58eMU/QQCoBCg+ApUXY6FTY+YjcIycnBwWcwYA4AysXLlSHTt2VMeOHSVJ9957rzp27KiHH35YkrR3795SV2d85ZVXVFxcrNGjRysxMdF3u+uuu3xtdu/ereHDhys5OVlXX321atasqeXLl6t27doV++QAoJIoKiqyOwKAk2AsdGrMfASO4fV6lZGRodjYWLujAAAQEHr16lXmF3dTpkwptb1gwYJTHnP69OlnmQoAqhaKj0DlxVjo1Jj5CPzG3r177Y4AAAAAAD6FhYV2RwCA343iI/AbW7dutTsCAAAAAPi43W6WhwIQsCg+Ar+xd+9eZWdn2x0DAAAAACSVLA/F7EcAgYriI/AbxhitX7/e7hgAAAAA4JObm2t3BAD4XbjgDHBESkqKduzYofDwcI0bN07t27eXy+WyOxYAAAAAKDs7W3FxcXbHAIAzxsxH4Ii0tDSlp6crKytLhYWF+u677+yOBAAAAACSpKysLLsjAMDvQvEROIn169drx44ddscAAAAAAGVmZtodAQB+F4qPQBm+/vprHT582O4YAAAAAKo5io8AAhXFR6AMhYWF+uyzzyhAAgAAALAVxUcAgYriI3AKeXl5+vjjj7Vnzx67owAAAACopnJzc+XxeOyOAZwxXreg+AicBrfbrc8++0yrVq2SMcbuOAAAAACqGWMMF51BQMrOzrY7AmxG8RE4TcYYrVixQrNnz1ZeXp7dcQAAAABUM5x6jUDEzEdQfATOUGpqqj744APt2rXL7igAAAAAqhHWokcgKi4utjsCbEbxEfgd8vPz9fnnn2vRokUqKCiwOw4AAACAaiA9Pd3uCMAZ83g8LF9WzQXZHQAIZBs2bNC2bdvUoUMHtW7dWsHBwXZHAgAAAFBF7d+/X8YYWZZldxTgjHg8HgUFUYKqrviXB86S2+3Wt99+q59++knt2rVTmzZteFMFAAAAUC5SUlK0e/duuVwuPfjgg8rOzlZ0dLTdsYAzUlRUxO/J1RinXQPlJD8/X99++63ee+891oMEAAAAUC7S0tK0b98+35Wud+7caXMi4Myx7mP1RvERKGc5OTmaM2eOtm/fbncUAAAAAFXM5s2b7Y4AnDGKj9UbxUdA0qZNm3zfJObn52vfvn1ndTxjjJYsWSKPx1Me8QAAAABAUsm6j2lpaXbHAM5IUVGR3RFgI4qPqPYmT56sli1bKjs7W1LJGo5jx47V0qVLz+q4ubm52rBhQ3lEBAAAAACf5cuXc/VgBBSKj9UbxUdUa5s2bdKoUaPk9XpL7TfG6H//+5/2799/Vsf/7rvvdOjQobM6BgAAAAAca//+/Vq7dq3dMYDTRvGxeqP4iGrtjTfekGVZJ7zPsiwtWbLkrI5fVFSkL774gjdaAAAAAOXqu+++08GDB+2OAZwWfieu3ig+olrbvn37SU9XMMaUy4d5VlaWduzYcdbHAQAAAPD/7N13eBTl2gbwe7JJNr1BKiWdElpCQo+EHhBFpMNBAgJiwYblGBECKEQFEUQUCwSwcpSignQpikhHQFoCSagplPSefb8/+FhZkpC2u7Pl/l3XXseZfXfm3pxh8+TZmXforvLycvz222+8kQcZhZKSErkjkIzYfCSz5ufn98AzHxs0aFDvfVhYWGhlO0RERIZo7969ePTRR+Hj4wNJkrBhw4ZqX7N79260b98eSqUSQUFBWLlyZYUxS5cuhZ+fH2xsbNCpUyccPHhQ++GJiIzc7du3cfjwYbljEFXLlM98ZC1UPTYfyaw9+eSTDzzzsVu3bvXaviRJiIqKgqura722Q0REZKjy8/PRrl07LF26tEbjk5OTMXDgQPTs2RPHjx/HSy+9hEmTJmHr1q3qMWvWrMG0adMQFxeHo0ePol27doiOjq73XMxERKbo5MmTyMrKkjsG0QOZcvORtVD12HwksxYcHIzly5fDwkLzn4IkSRg3bhw8PDzqvG0LCwv06tULwcHB9Y1JRERksAYMGIB33nkHjz/+eI3GL1u2DP7+/vjggw/QsmVLTJ06FcOGDcOHH36oHrNw4UJMnjwZEyZMQEhICJYtWwY7OzusWLFCV2+DiMhoCSFw9OhRuWMQPZApNx9ZC1WPzUcye+PHj8e5c+fg6OgIAFAqlZgzZw66du1a520qFAr07dsXgYGB2opJRERkEvbv348+ffporIuOjsb+/fsB3JkT6siRIxpjLCws0KdPH/WYyhQXFyMnJ0f9yMvL080bICIyQBcuXODnHhk0Y2s+5uXladQVxcXFWtu2rmohQ8bmIxGAoKAgODk5AQBsbW3rdcajnZ0dHnnkEfj6+morHhERkclIS0uDp6enxjpPT0/k5OSgsLAQN27cQHl5eaVj0tLSqtxufHw8nJ2d1Y+oqCid5CciMkRCCJw5c0buGERVMrbmY1RUlEZdER8fr7Vt66oWMmRsPhJpUdOmTTF06NAKHxJERESkW7GxscjOzlY/9uzZI3ckIiK9On36NO8oTAbL2JqPe/bs0agrYmNj5Y5k1CzlDkBkCqysrNC1a1c0a9asyrtnExEREeDl5YX09HSNdenp6XBycoKtrS0UCgUUCkWlY7y8vKrcrlKphFKpVC87ODhoNzgRkYErLi7GsWPH0KlTJ7mjEFVgbM1HBwcH9dWR2qarWsiQ8cxHonry9PTEsGHD0Lx5czYeiYiIqtGlSxfs3LlTY9327dvRpUsXAIC1tTXCw8M1xqhUKuzcuVM9hoiIKnfy5ElkZmbKHYOoAmNrPuqSOdZCbD4S1UPbtm3x6KOPqm9WQ0REZG7y8vJw/PhxHD9+HACQnJyM48eP49KlSwDuXA49btw49finn34aFy9exOuvv46zZ8/ik08+wf/+9z+8/PLL6jHTpk3DF198gVWrVuHMmTN45plnkJ+fjwkTJuj1vRERGRuVSoUdO3Zo9eYYRNpgylMCsBaqnlE3H/fu3YtHH30UPj4+kCQJGzZskDsSmQmFQoEePXqgc+fOsLAw6n9GRESkY6Zerxw+fBhhYWEICwsDcKdYDgsLw8yZMwEA169fVxffAODv749NmzZh+/btaNeuHT744AN8+eWXiI6OVo8ZOXIkFixYgJkzZyI0NBTHjx/Hli1bOKcyEVEN5ObmYsuWLSgrK5M7CpGaKTcfWQtVz6jnfMzPz0e7du3w5JNPYsiQIXLHITNhZ2eHvn37Gu0/eiIi0i9Tr1d69OgBIUSVz69cubLS1xw7duyB2506dSqmTp1a33hERGYpPT0dW7duRXR0NCwtjfrPfjIRJSUlUKlUJnnyDmuh6hn1p9CAAQMwYMCAGo8vLi7WOP08Ly9PF7HIhDVp0gQ9evSAra2t3FGIiEhmeXl5yMnJUS/ff8OTu2pbrxAREWnD1atXsWXLFkRHR8PKykruOGTmhBAoKiqCnZ2d3FFIBqbXcn6A+Ph4ODs7qx9RUVFyRyIjYWlpiYceegj9+/dn45GIiAAAUVFRGnVFfHy83JGIiIg0XLt2DZs2beIckGQQCgoK5I5AMjGr5mNsbCyys7PVjz179sgdiYyAm5sbhgwZgpYtW/Ju1kREpLZnzx6NuiI2NlbuSERERBVkZGTgl19+YeOHZJebmyt3BJKJUV92XVv3Xw7l4OAgYxoyBt7e3oiOjoa1tbXcUYiIyMA4ODjAyclJ7hhERETVunXrFjZt2oRHHnmEV3KRbO6drobMi1md+UhUG+7u7ujfvz8bj0REREREZPRu376NrVu3ory8XO4oZKZu374tdwSSCZuPRP/Py8sLDRs2hJOTE5RKJfr168eJmYmIiIiIyGRkZGTg6NGjcscgM3Xr1i25I5BMjPqy67y8PCQlJamXk5OTcfz4cbi5uaFp06YyJiNjdPjwYezZswfnzp1Dhw4dYG9vL3ckIiIyAaxXiIjIkJw8eRJt2rSBjY2N3FHIzNy+fRvl5eVQKBRyRyE9M+ozHw8fPoywsDCEhYUBAKZNm4awsDDMnDlT5mRkzKysrNC8eXO5YxARkYlgvUJERIakrKwMly5dkjsGmaHy8nKe/WimjPrMxx49ekAIIXcMMjHe3t78JoaIiLSG9QoRERmatLQ0NGvWTO4YZAYiIiJw9epVWFtbY/r06cjIyIC7u7vcsUjPjLr5SKQL/CAkIiJjd+LECSxZsgRHjx5FdnY2VCqVxvOSJOHChQsypSMiIrnx7DPSl7S0NKSlpcHFxUW93KpVK3lDUaV0WT8a9WXXRLrA5iMRERmz3bt3o2PHjti4cSN8fHxw8eJFBAQEwMfHB6mpqXBwcED37t3ljklERDK6efNmhcYCkT6kpaXxihADpOv6kc1Hovt4eHjIHYGIiKjOZs6ciYCAAJw7dw4JCQkAgDfffBN//PEH/vzzT1y5cgUjRoyQOSUREcmpvLwcGRkZcscgM5Sfn4+8vDy5Y9B9dF0/svlIdA8HBwfe9Y2IiIza0aNHMXHiRDg5OannMC4vLwcAdOrUCVOmTMGMGTPkjEhERDWUmJiInJwcAEBhYSHS09O1tu3U1FStbYuoNq5duyZ3BLqPrutHNh+J7uHs7Cx3BCIionqxtLSEo6MjAMDFxQVWVlYaZ7cEBATg9OnTcsUjIqIaSkhIQIsWLZCbmwsAKC4uRlxcHP7880+tbD8lJUUr2yGqrStXrsgdge6j6/qRzUeie9jZ2ckdgYiIqF6CgoKQmJgI4M7E4C1atMD69evVz2/atAleXl5yxSMiohpITEzEpEmTKszLKITA6tWrtXLJdHZ2NrKzs+u9HaLaunLlCuccNTC6rh/ZfCS6h7W1tdwRiIiI6uXhhx/Gd999h7KyMgDAtGnTsG7dOgQHByM4OBg///wzpkyZInNKIiJ6kBUrVkCSpEqfkyQJ+/bt08p+0tLStLIdotooLi7G9evX5Y5B99B1/WipraBEpoDNRzJm5eXl6vk5iMh8zZgxAy+++KL68yAmJgYKhQJr166FQqHA9OnTMX78eHlDEhHRA6WkpFR5R2AhBG7evKmV/WRlZWllO0S1dfHiRTRq1EjuGPT/dF0/1qj5mJOTA3t7e/5RSybP1tZW7ghEdVZcXMypA4gIVlZWaNCggca6sWPHYuzYsTIlIjIMKpUKFha88IuMg5+f3wPPfLz/c76uioqKtLIdotq6ePEiunbtyj6TgdB1/Vij376urq5Ys2aNevnJJ5/EgQMHtBKAyJBYWVnJHYGozlg8EhFwZ0Lwn3/+ucrnN27ciICAAD0mIjIMd+8YTGQMnnzyyQee+ditWzet7IeNH5JLcXExLl26JHcM+n+6rh9r1Hy0trZGcXGxennlypW4cOFCnXdKRETal5eXJ3cEIjIAKSkpD/w8yMvLQ2pqqh4TERmGu/NYERmD4OBgLF++vMLZupIkYdy4cfDw8NDKfpydnbWyHaK6OHv2rNwR6P/pun6s0WXXLVq0wJdffgk/Pz/1h1NKSgqOHj36wNe1b9++zsGIiKh2bt++jUaNGvEbbCKq8lI9ADh06BBcXFz0F4bIQLD5SMZm/PjxiIyMRPv27ZGbmwulUom33npLa41HAPD29tbatohq68qVK8jLy4ODg4PcUQi6rR9r1HyMj4/HyJEj0adPH3WgGTNmYMaMGZWOF0JAkiSUl5fXORgREdVOeXk50tLSOHEzkRlavHgxFi9eDOBOnfbSSy9h+vTpFcZlZ2cjKysLY8aM0XdEItmx+UjGKCgoCE5OTsjNzYWtra1WG49OTk5amzuSqC6EEDh79iwiIiLkjmKW9Fk/1qj52L9/fyQnJ+PQoUNIT0/H+PHj8dRTT6FLly513jEREWkf7xpHZJ48PDzQqlUrAHeuTmnUqFGFzwJJkmBvb4/w8HA8++yzcsQkkhVPjCDS1Lx58wee6USkD2fPnkX79u15QzAZ6LN+rFHz8cSJE/D19UV0dDQAICEhAcOHD0fv3r3rvGMiItK+5ORkREZGspAkMjOjR4/G6NGjAQA9e/bEW2+9pdc6benSpZg/fz7S0tLQrl07LFmyBB07dqx0bI8ePbBnz54K6x9++GFs2rQJwJ1LDVetWqXxfHR0NLZs2aL98GQ2SktL5Y5AZDAUCgVatGghdwwiFBQUICUlxehvhmeMtZA+68caNR/DwsLw1Vdf8RIdIiIDV1RUhKtXr6Jx48ZyRyEimezatUuv+1uzZg2mTZuGZcuWoVOnTli0aBGio6Nx7ty5Si8PXLduHUpKStTLN2/eRLt27TB8+HCNcf3790dCQoJ6WalU6u5NkFngZddE/woKCoKtra3cMYgAACdPnjTq5qMp1EK6rh9r1Hy0tbVFQUGBennPnj2YPHmyzkIREVHtRERE4PLly7CxsUGTJk3YfCQyI3v37q3T67p3766V/S9cuBCTJ0/GhAkTAADLli3Dpk2bsGLFCrzxxhsVxru5uWksf//997Czs6tQcCuVSnh5eWklIxHA5iPRvdq2bSt3BCK19PR0ZGRkaHVOU30yxlpI3/VjjZqP7dq1w8KFC6FQKNR3uz506BBsbGwe+LohQ4bUKRQREdVOWloaMjIy4OLigsuXLyM5ORn+/v5yxyIiPejRo4fGVAt3b/xXFW3eGLCkpARHjhxBbGysep2FhQX69OmD/fv312gby5cvx6hRo2Bvb6+xfvfu3fDw8ICrqyt69eqFd95554E3RiguLkZxcbF6OS8vr5bvhkwdL7smusPPzw+urq5yxyDS8Pfff6Nv375yx1DLy8tDTk6OelmpVFZ65qEh1UK1oe/6sUbNx8WLF2PYsGGYOHEigDsTTt57V5zK8G7XRETy2bVrFyRJgp+fn9xRiEjH9H2Z9b1u3LiB8vJyeHp6aqz39PTE2bNnq339wYMHcerUKSxfvlxjff/+/TFkyBD4+/vjwoULePPNNzFgwADs378fCoWi0m3Fx8dj9uzZdX8zZPJKS0ur/eOKyNRJkoTw8HC5YxBVkJycjFu3blU4K1AuUVFRGstxcXGYNWtWhXGGVAvVhr7rxxo1HyMiIpCUlIQLFy4gPT0dPXr0wPTp09GnTx9d5yMiojooKyvDtm3bEBwcjM6dO3NOHyITdn9xbEyWL1+ONm3aVJiQfdSoUer/btOmDdq2bYvAwEDs3r27yonQY2NjMW3aNPXy8ePHjfpnQ7pRUlLC+UPJrDVr1kxrZ04RaduRI0cM5uzHPXv2IDQ0VL2sq98d2qyFakPfNVKNmo8AYGlpiebNm6N58+aIiYnBI488gk6dOukyGxER1VNiYiJSU1PRuXNnNG/enGd7EJmZ69evIyMjA0FBQRUu5dGGhg0bQqFQID09XWN9enp6tXMU5efn4/vvv8ecOXOq3U9AQAAaNmyIpKSkKgvu+y+HcnBwqME7IHPD5iOZM2tra3To0EHuGERVSk5ORmZmJtzd3eWOAgcHBzg5OVU7zpBqIW3RRf1oUZcXJSQksPFIRGQkSkpKsHfvXvzxxx8QQsgdh4j04KeffkKLFi3QuHFjtG/fHgcOHABw59KgsLAwbNiwQSv7sba2Rnh4OHbu3Klep1KpsHPnTnTp0uWBr/3hhx9QXFyMsWPHVrufK1eu4ObNm/D29q53ZjJvRUVFckcgkk3Hjh1hZ2cndwyiBzpw4IBR/c1iSrWQLuvHGp35OGfOHEiShOnTp8PCwqJGXVlJkjBjxow6ByMiIu06c+YMysvL0b17d1hY1Om7JyIyAr/88guGDBmCLl26YMyYMRrzEzVs2BCNGjVCQkICBg8erJX9TZs2DTExMYiIiEDHjh2xaNEi5Ofnq+/4OG7cODRq1Ajx8fEar1u+fDkGDx5c4fK/vLw8zJ49G0OHDoWXlxcuXLiA119/HUFBQYiOjtZKZjJfhYWFckcgkkXjxo3RsmVLuWMQVevatWu4dOkSfH195Y5SY6ZQC+m6fqxR83HWrFmQJAn//e9/YW1tXekkm/dj85GIyPCcP38e2dnZ6N69O+9ySGSi5syZg+7du2PXrl24efNmhbqtS5cu+Oyzz7S2v5EjRyIzMxMzZ85EWloaQkNDsWXLFvXE65cuXarwhce5c+fwxx9/YNu2bRW2p1AocOLECaxatQpZWVnw8fFBv3798Pbbb/NyWaq3/Px8uSMQ6Z2dnR169uzJ6XfIaBw8eBBNmjQxmhMmTKEW0nX9WKPmo0qleuAyEREZj/T0dPz4448ICgpCaGgom5BEJubUqVNYuHBhlc97enoiIyNDq/ucOnUqpk6dWulzu3fvrrCuefPmVV5SZWtri61bt2ozHpFaXl6e3BGI9EqhUKBfv368+SAZldu3b+Ps2bMICQmRO0qNGXstpOv6scY3nCEiItMhhEBiYiISExPRqFEjhISEwNfX12i+XSSiqtnZ2T3w7K6LFy/yTqdktnJycuSOQKRXUVFR8PDwkDsGUa0dOXIEwcHBsLKykjuKWdB1/VjnvzLPnDmDjRs34rvvvsPGjRtx9uzZOocgIiL5XL16Fdu3b8e3336LI0eOcDJ+IiPXs2dPrFq1CmVlZRWeS0tLwxdffIF+/frJkIxIftnZ2XJHINKbiIgIBAUFyR2DqE4KCwtx6tQpuWOYDV3Xj7U+8/Gzzz7D3LlzcfXq1QrPNW3aFNOnT8ekSZPqHIiIiORRUFCAI0eO4MSJE+jYsSNatWoldyQiqoO5c+eic+fO6NChA4YPHw5JkrB161b89ttv+OyzzyCEQFxcnNwxiWSRlZUFIQTnviOTFxwcjLCwMLljENXLiRMnEBISwjmf9UDX9WOtmo+vvvoqFi5cCDc3Nzz55JNo3bo1HBwckJeXh5MnT2LDhg2YMmUKEhMT8d5779U5FBER1VxiYqL6MrLCwkKkp6erJzeui9LSUuzbtw82NjYIDAzUVkwi0pPmzZvjjz/+wIsvvogZM2ZACIH58+cDAHr06IGlS5fCz89P3pBEMikrK0NeXh4cHR3ljkKkM+7u7ujevTub7GT0iouLcebMGYSGhsodxeTpun6scfPx4MGDWLhwIR5//HGsXr0a9vb2FcYsXrwYY8eOxYIFCzB8+HBERETUORgREVUvISEBkyZNUt8IrLi4GHFxcRg3bhy6du1ar23//fffCAgIYOFKZIRatWqFHTt24Pbt20hKSoJKpUJAQADc3d3ljkYku1u3brH5SCZLqVSiT58+UCgUckch0oqTJ0+iTZs2PKb1QJf1Y43nfFy+fDm8vb3x7bffVtp4BAB7e3t899138PT0xPLly+sdjoiIqpaYmKjReLxLCIHVq1fX+262N27c4Hy+REbO1dUVHTp0QKdOndh4JPp/t27dkjsCkc50796dzXUyKYWFhUhJSZE7hlnRRf1Y4zMf9+/fj+HDh1d7rb2NjQ2GDx+OXbt21TscERFVbcWKFVWelShJEvbt24fHH3+8XvvYv38/GjduzCKWyICtXr26Tq8bN26clpMQGYebN2/KHYFIJ1q0aAF/f3+5YxBp3ZkzZzgdlJbpu36scfPx8uXLaNmyZY3GhoSE1PmNEBFRzaSkpEAIUelzQgit/HFVVlaGpKQkTlhOZMDGjx9fYd3dLybu/4y49wsLNh/JXN24cUPuCERa5+zsjC5dusgdg0gnrl+/jry8PDg4OMgdxWTou36scfMxJyenxme+ODg4IDc3t06BiIioZvz8/B545mODBg20sp+qptogIsOQnJyssZyVlYWYmBg4Ozvj+eefR/PmzQEAZ8+exZIlS5Cbm4tVq1bJEZXIIOTk5KCwsBC2trZyRyHSCkmS0LNnT1hZWckdhUgnhBC4cOEC2rVrJ3cUk6Hv+rHGzUchRK1uOlDV2ThERKQdTz75JN5///1KnxNCoFu3bvXeR+PGjREcHFzv7RCR7vj6+mosz5o1C+7u7ti2bZtG7damTRsMHToU/fr1w4cffoiEhAR9RyWSTUREBC5dugRbW1tMnz4daWlpvDyVTEb79u3h4eEhdwwinbp48SKbj1qk7/qxxs1HAFiwYAG+++67asddvXq1TmGIiKjmgoODsXz5ckycOFHjpjOSJGHcuHH1LkK9vb3Rt29f3u2ayMhs2LABc+fOrfTfroWFBYYMGYK33npLhmRE8klLS0NmZiZcXFwA3Pl7hc1HMgXu7u6cHofMQmZmJrKzs+Hs7Cx3FJOk6/qxxs3Hpk2b4tatWzW+O1zTpk3rHIqIiGpm/PjxiIyMRPv27ZGbmwulUom33nqr3o1HX19f9O7dG5aWtfqOiogMgBDigXeqP336NK9QIbN3+fLlWl/ZRWRoJElC9+7dYWFhIXcUIr24cOEC2rdvL3cMk6Tr+rHGf1Xy1uZERIYpKCgITk5OyM3Nha2tbb0aj5IkITQ0FBEREfyDjMhIDR48GJ9++in8/Pzw9NNPw87ODgBQUFCATz/9FJ999hn+85//yJySSF65ubm4ffs23Nzc5I5CVGctW7bU2hzfRMYgMTERYWFh/DtFB3RdP/KUFiIiAnDnLondu3eHt7e33FGIqB4WL16M5ORkvPrqq4iNjVX/m75+/TpKS0vRrVs3LFq0SN6QRAYgOTmZzUcyWgqFgmeAkdnJzs5GRkYGPD095Y5icnRdP7L5SERk5mxsbBAaGopWrVpBoVDIHYeI6snZ2Rl79uzBTz/9hM2bNyM1NRUA0L9/fzz88MN49NFHecYAEf69fI//HsgYNWvWTH1mEpE5OXPmDJuPOqDr+pHNRyIiM6VUKtG2bVu0atUK1tbWcschIi177LHH8Nhjj8kdg8hgZWVlITMzk3cJJoPn5eWFsrIyKJVK9bpWrVrJmIhIPhcvXkSXLl00/j2Q9uiqfmTzkYjIzCgUCrRu3RqhoaH8pU1ERGbtzJkzbD6SwTt8+DDOnj2LvXv3AgA8PDw4ZQCZrbKyMpw/fx5t2rSROwrVAm+LRURkRpo0aYJhw4ahU6dObDwSEZHZu3DhAoqLi+WOQVQrQUFBckcgktWZM2fqdedl0j82H4mIzIC9vT369OmD/v37w9nZWe44REREBqGsrAz//POP3DGIakySJAQEBMgdg0hWWVlZSE9PlzsG1QKbj0REJi4kJATDhw9HQEAAJ9UnIiK6z8mTJ1FSUiJ3DKIa8fDw4I1miAAkJibKHYFqoc5zPm7duhXLly/HxYsXcfv27QqnvEqShAsXLtQ7IBER1Y2VlRV69uwJPz8/uaMQEREZrOLiYpw4cQIRERFyRyGqVpMmTeSOQGQQUlJSEBkZyZMrjESdmo/z58/HG2+8AU9PT3Ts2JETfRIRGRhLS0sMGDAAXl5eckchIpkVFRXhf//7H6Kjo+Hp6Sl3HCKDdOLECbRs2RL29vZyRyF6oEaNGskdgcggFBYW4tatW2jQoIHcUUyStuvHOjUfFy9ejF69euHXX3+FlZVVvUPUx9KlSzF//nykpaWhXbt2WLJkCTp27ChrJiIiffPy8kJpaSlsbGwAAD179mTjkcjAyFWzZGdnY8KECdi+fTubj0RVKCsrw4EDB9CrVy+5oxBVSaFQoGHDhnLHIDIYaWlpbD7qiLbrxzrN+Xj79m0MGzZM9sbjmjVrMG3aNMTFxeHo0aNo164doqOjkZGRIWsuIiJ9O3z4MDZv3ozp06ejVatW8Pf3lzsSEd1D7ppF13eEXLp0Kfz8/GBjY4NOnTrh4MGDVY5duXIlJEnSeNz94uTevDNnzoS3tzdsbW3Rp08fzu1EOpeUlIS0tDS5YxBVyc3NDQqFQu4YRDWWmJiInJwcAHfOVNT2TWKysrK0ur36MMVaSJv1Y52ajx07dsS5c+e0FqKuFi5ciMmTJ2PChAkICQnBsmXLYGdnhxUrVsgdjYhIFkqlEh06dJA7BhHdR+6aRZfzIdWlserk5ITr16+rH6mpqRrPv//++/joo4+wbNkyHDhwAPb29oiOjkZRUZHO3gcRAOzbt0/nzXqiunJzc5M7AlGNJSQkoEWLFsjNzQVwZ37duLg4/Pnnn1rbR15enta2VR+mWgtps36s02XXn3zyCQYMGICIiAiMGTNGa2Fqo6SkBEeOHEFsbKx6nYWFBfr06YP9+/dX+pri4mIUFxerl+8eqGVlZSgtLdVtYCIiHSstLUVQUBAkSeJnGpEOlZWVAbhTR9z9Nh+40/xXKpUVxtelZtE2XTZT7m2sAsCyZcuwadMmrFixAm+88Ualr5EkqcqpIYQQWLRoEd566y089thjAIDVq1fD09MTGzZswKhRoyp9XVV1HlFt3Lx5E2fOnEFISIjcUYgqcHZ2ljsCUY0kJiZi0qRJUKlUGuuFEFi9ejWCgoLg4eFR7/3o8m+emtZ5gOHUQtqmzfqxTs3HkSNHoqysDE888QSeeeYZNG7cuMLp35Ik4e+//9ZKyMrcuHED5eXlFa499/T0xNmzZyt9TXx8PGbPnl1hfadOnXSSkYiIiExXVFSUxnJcXBxmzZpVYVxdahZt8vT0rFD8a0tdG6t5eXnw9fWFSqVC+/btMW/ePLRq1QoAkJycjLS0NPTp00c93tnZGZ06dcL+/furLLirqvOIauvQoUMICAiocAkckdycnJzkjkBUIytWrKjyrDlJkrBv3z48/vjjek5VOzWt8wypFtImbdePdWo+urm5oUGDBggODtZaEH2IjY3FtGnT1MvHjx9HVFQUDhw4gLCwMBmTERHV38mTJ9GqVStYWNRpRg0iqqFjx46hU6dO2LNnD0JDQ9Xrq/o23JTVpbHavHlzrFixAm3btkV2djYWLFiArl274p9//kHjxo3Vc+5Vts0HzcdXVZ1HVFvFxcU4ePAgunfvLncUIg0ODg5yRyCqkZSUlCrPmhNC4ObNm1rZjy7vQ1LTOs+QaiFDVqfm4+7du7Uco/YaNmwIhUJRYcLS9PT0Kk9dvf802bsf3paWlrLfPIeIqL4aNGhgls0PIn2ztLxTPjk4ONToLJS61CymrEuXLujSpYt6uWvXrmjZsiU+++wzvP3223XeblV1HlFdnD17FsHBwfD29pY7CpGavb293BGIasTPz++BZz5q6w7VdnZ2WtlOZWpa59WFrmohQ2a0p8dYW1sjPDwcO3fuVK9TqVTYuXOnxv+JRETmwtbWVu4IRFQJU65ZtNFYtbKyQlhYGJKSkgBA/To2a0lue/fu5RzKZFA4FQAZiyeffPKBZz5269ZNK/sxhC8aWQvVTL2aj6WlpTh58iT++OMP7N27t8JD16ZNm4YvvvgCq1atwpkzZ/DMM88gPz9fPcknEZE54VmPRIbLVGsWbTRWy8vLcfLkSfUZZv7+/vDy8tLYZk5ODg4cOGD0zVoyLtnZ2fj9999592syCFZWVhXus0BkqIKDg7F8+fIK00FJkoRx48Zp5WYzAODi4qKV7dQHa6GaqdNl1yqVCrGxsfjkk09QUFBQ5bjy8vI6B6uJkSNHIjMzEzNnzkRaWhpCQ0OxZcuWCtfFExGZA2tra7kjEFEVTLlmmTZtGmJiYhAREYGOHTti0aJFGo3VcePGoVGjRoiPjwcAzJkzB507d0ZQUBCysrIwf/58pKamYtKkSQDu/GHy0ksv4Z133kFwcDD8/f0xY8YM+Pj4YPDgwXK9TTJTSUlJcHd3R5s2beSOQmaOdR4Zm/HjxyMyMhLt27dHbm4ulEol3nrrLa01HgHDaD4CrIVqok7Nx3nz5mH+/PmYMmUKIiMj8cQTT+C9996Di4sLPvnkE0iShPfff1/bWSs1depUTJ06VS/7IiIyZJy7lsiwmWrNUl1j9dKlSxpnPty+fRuTJ09GWloaXF1dER4ejj///BMhISHqMa+//jry8/Px1FNPISsrC5GRkdiyZQsvOSRZ/PXXX3BycoKvr6/cUciM3Z1vmMiYBAUFwcnJCbm5ubC1tdVq49HCwgLOzs5a2159sBaqniTqcB1BUFAQIiIi8P333+PmzZtwd3fHjh070KtXL5SUlKBLly6Ijo7GvHnzdJFZa44ePYrw8HAcOXIE7du3lzsOEVG9CCGqnNiZiLTHWOqHffv24ejRo8jOzoZKpdJ4TpIkzJgxQ6Zk+mEs/z+RfjRu3BhXr16Fi4sL3nvvvVq/3tLSEo888ohW/3Amqo3MzEy4u7vLHYOo1ur7+VsVNzc3DBs2TGvbu8vc6wdd1Y91+vrkypUreP311wH8O8dYUVERgDung48dOxYLFy40+OYjERERkam5desWBg4ciIMHD6q/lLj7XfPd/zaH5iORNpWVlWHr1q0YPHgwHB0d5Y5DZuj+ufOIzJ227phNd+i6fqzTJ1iDBg2Ql5cH4N/bj1+8eFFjzO3bt+sUiIiIiIjq7rXXXsOJEyfw7bff4uLFixBCYOvWrTh//jyefvpphIaG4tq1a3LHJDI6hYWF2LlzZ4UzQYj0gTebIdLE5qN26bp+rFPzMSwsDIcOHVIv9+zZE4sWLcK+ffvw+++/46OPPkK7du3qHIqIiIiI6ubXX3/FlClTMHLkSPUZWhYWFggKCsLSpUvh5+eHl156Sd6QREYqIyMDf//9t9wxyAyx+Uikic1H7dJ1/Vin5uNTTz2F4uJiFBcXAwDmzp2LrKwsdO/eHVFRUcjJycEHH3xQ51BERFR7dZjCl4hMUFZWFlq1agXgzhUqANRXrABAv379sHXrVlmyEZmC48ePq/8OItIXNh+J/iVJEudA1TJd1491aj4OGjQI69atU8/3GBISggsXLmDdunX4+eefkZiYiM6dO9c5FBERERHVjY+PD9LS0gDcmZvbw8ND40ytq1ev8uZURPVQWlqKCxcuyB2DzAznfCT6l4uLC6ytreWOYVJ0XT/W6YYzlXF2dsZjjz2mrc0REVEtsSglIgDo3r07tm/fjunTpwMARo4ciffffx8KhQIqlQqLFi1CdHS0zCmJjFtqaipCQkLkjkFmhGc+Ev3L09NT7ggmR9f1Y52bj+Xl5fjhhx+wa9cuZGRkYM6cOWjTpg2ys7Oxc+dOdOvWjQcEERERkZ5NmzYN27dvR3FxMZRKJWbNmoV//vlHfXfC7t2746OPPpI5JZFxS09PV9/5k0gfeKwR/cvb21vuCCZH1/VjnZqPWVlZ6N+/Pw4ePAgHBwfk5+fj+eefB3Dn2vAXXngB48aNw7x58+ocjIiIiIhqr02bNmjTpo162dXVFTt27EBWVhYUCoV6EnEiqruSkhLk5OTA2dlZ7ihkJth8JPpX48aN5Y5gcnRdP9bpGr033ngD//zzD7Zu3aq+BfddCoUCw4YNw6+//lqvYERERGQ+CgoK5I5gMubMmYNTp05VWO/i4gJHR0f8888/mDNnjgzJiExLRkaG3BHIjHB6HaI7PDw8YGtrK3cMk6Pr+rFOn2AbNmzA888/j759+1b6DUyzZs2QkpJS51BERERkXnJzc+WOYDJmzZqFEydOVPn8qVOnMHv2bD0mIjJN169flzsCEZHZCQwMlDuCSdJ1/Vin5mN2djb8/f2rfL60tBRlZWV1DkVERETmpaioSO4IZuPWrVu8QySRFly+fFnjCjAiXeJl10R3zgBm81Ee9a0f6zTnY2BgII4ePVrl89u2bePd34iIiKjGSktLUVJSwqZYHe3duxe7d+9WL69btw5JSUkVxmVlZWHNmjUac/oQUd3k5+cjLS2NNz4gItKTgIAA2NnZyR3DZOizfqxT83HSpEn473//ix49eqB3794A7nwTU1xcjDlz5mDLli34/PPP6xyKiIiIzE9+fj6bj3W0a9cu9aUwkiRh3bp1WLduXaVjQ0JCsGTJEn3GI5JVYmIicnJyAACFhYVIT0+Hp6enVradlJTE5iMRkR5IkoTQ0FC5Y5gUfdaPdWo+vvjii/jnn38wevRouLi4AADGjBmDmzdvoqysDFOmTMHEiRPrHIqIiIjMT35+PlxdXeWOYZRef/11TJ06FUIIeHh4YNmyZRg6dKjGGEmSYGdnBxsbG5lSEulfQkICJk2aBJVKBQAoLi5GXFwcxo0bh65du9Z7+8nJyejWrRtvBkJEpGMBAQFwc3OTO4ZJ0Wf9WKfmoyRJ+OKLLxATE4Mff/wRiYmJUKlUCAwMxIgRI9C9e/d6hSIiIiLzk5eXJ3cEo2Vra6u+82NycjLc3d15WRKZvcTERI3G411CCKxevRpBQUHw8PCo1z6KioqQmZmptTMpiYioIoVCgY4dO8odw+Tos36sU/PxrsjISERGRmorCxEREZkxNh+1w9fXV+4IRAZhxYoVVd6kQ5Ik7Nu3D48//ni993Pjxg02H0nnhBC86QyZrTZt2sDR0VHuGCZN1/VjvZqPRERERNqSn58vdwSj5O/vX+s/SCVJwoULF3SUiMgwpKSkVHk3aiEEbt68qZX9lJSUaGU7RERUkZ2dHcLCwuSOYXL0XT/WuPk4aNCgWm1YkiT89NNPtQ5ERERE5olnPtZNVFQUz4YhqoSfn98Dz3xs0KCBVvbDeVSJiHSnQ4cOsLKykjuGydF3/Vjj5uPGjRthY2MDLy+vKr9BvBeLYCIiIqqN7OxsuSMYpZUrV8odgcggPfnkk3j//fcrfU4IgW7dumllPw0bNtTKdogehJddkzlyc3NDs2bN5I5hkvRdP9a4+dioUSNcvXoVDRs2xJgxYzBq1Ch4eXnpMhsRERGZkby8PBQUFPBGKUSkFcHBwVi+fDkmTpyocdMZSZIwbty4et9sBgAcHBzYfCQi0pHw8HA23U2ERU0HXr58Gbt27UJYWBjefvttNGnSBH369EFCQgJyc3N1mZGIiIjMRGpqqtwRTEJOTg7effddREdHIywsDAcPHgQA3Lp1CwsXLkRSUpLMCYn0Y/z48Th37pz6RgVKpRJz5sxB165dtbL95s2b8w9jIiIdcHV1hZ+fn9wxzIou68caNx+BO9eEf/bZZ0hLS8OPP/6IBg0aYOrUqfDw8MCQIUPw448/ori4uM5hiIiIyLydOXOmRtO7UNWuXLmCsLAwzJw5E1euXMGJEyfU82m6ubnhs88+w5IlS2ROSaQ/QUFBcHJyAgDY2tpq5YxHAFAoFAgJCdHKtoiqwyY3mZs2bdrwuNcjXdePtWo+3mVlZYXHHnsMa9asQXp6urohOXLkyCrnVSEiIiKqTEREBCIjIzF37lzcuHEDV65ckTuSUXvttdeQm5uL48ePY8+ePRWauYMHD8aOHTu0us+lS5fCz88PNjY26NSpk/qb8sp88cUXeOihh+Dq6gpXV1f06dOnwvjx48dDkiSNR//+/bWamai+goKCYGtrK3cMMhNswpA5USqVCAoKkjtGrRh7LaTr+rFOzce7iouLsXXrVvz00084duwYbGxseFosERER1UpaWhrS09ORk5MDADh48CDPfqyHbdu24YUXXkBISEilf6wGBATg8uXLWtvfmjVrMG3aNMTFxeHo0aNo164doqOjkZGRUen43bt3Y/To0di1axf279+PJk2aoF+/frh69arGuP79++P69evqx3fffae1zETa0K5dO7kjEBGZpMDAQFha1vgWJbIzhVpI1/VjrZuPKpUKW7duxfjx4+Hp6YnRo0ejsLAQX3zxBTIyMvDEE0/UOQwRERHRzZs3cebMGbljGK3CwkK4u7tX+by25+peuHAhJk+ejAkTJiAkJATLli2DnZ0dVqxYUen4b775Bs8++yxCQ0PRokULfPnll1CpVNi5c6fGOKVSCS8vL/XD1dVVq7mJ6sPX1xcuLi5yxyAiMknNmzeXO0KtmEItpOv6scbNxz///BNTp06Ft7c3Bg4ciKSkJMybNw/Xrl3Dr7/+irFjx8Le3r5eYYiIiIgA4MCBA+ozIal2QkJCsHfv3iqf37BhA8LCwrSyr5KSEhw5cgR9+vRRr7OwsECfPn2wf//+Gm2joKAApaWlcHNz01i/e/dueHh4oHnz5njmmWdw8+bNB26nuLgYOTk56sfdeYqIdIFnPRIR6YabmxsaNmwodwzk5eVp1BVV3d/EkGqh+tB1/Vjj81gjIyNha2uLhx9+GKNHj1ZfXn3p0iVcunSp0te0b9++zsGIiIjIfJWWlmL79u0YNGgQrKys5I5jVF566SXExMSgbdu2GD58OIA7V64kJSVh9uzZ2L9/P9auXauVfd24cQPl5eXw9PTUWO/p6YmzZ8/WaBv//e9/4ePjo1G09+/fH0OGDIG/vz8uXLiAN998EwMGDMD+/fuhUCgq3U58fDxmz55d9zdDVEPe3t7w8vKSOwYRkUlq3ry5QcxxGhUVpbEcFxeHWbNmVRhnSLVQfei6fqzVRfSFhYVYu3Yt1q1b98BxQghIkoTy8vI6ByMiIiLzdvPmTWzfvh3R0dE6KbJM1dixY5Gamoq33noL06dPB3CngBVCwMLCAvPmzcPgwYPlDfn/3n33XXz//ffYvXs3bGxs1OtHjRql/u82bdqgbdu2CAwMxO7du9G7d+9KtxUbG4tp06apl48fP17hDwcibYiIiJA7AhGRSVIoFGjWrJncMQAAe/bsQWhoqHpZqVTqZD/arIXqQ9f1Y42bjwkJCXXeCREREVFdXLlyBbt27ULv3r0N4ltwYzF9+nQ88cQTWLt2LZKSkqBSqRAYGIghQ4YgICBAa/tp2LAhFAoF0tPTNdanp6dXe2bYggUL8O6772LHjh1o27btA8cGBASgYcOGSEpKqrLgViqVGn8YODg41PBdENWcn58fvL295Y5BRGSSgoKCdNbkqy0HBwc4OTlVO86QaqH60mX9WOPmY0xMTL12RERERFQXFy9ehEKhQFRUFCwsan2vPLPVtGlTvPzyyzrdh7W1NcLDw7Fz5071t+F3J0yfOnVqla97//33MXfuXGzdurVGZ5FduXIFN2/eZNOHZKVQKNC5c2e5YxARmazqGnCGyNRqIV3Vj6zgiYiIyOAlJiZi586dnNLFAE2bNg1ffPEFVq1ahTNnzuCZZ55Bfn4+JkyYAAAYN24cYmNj1ePfe+89zJgxAytWrICfnx/S0tKQlpamvkFMXl4eXnvtNfz1119ISUnBzp078dhjjyEoKAjR0dGyvEci4M589jU5C4aIiGrP399fp3dz1iXWQtWr1ZyPRERERHJJTk7Gxo0b0bdvX9jZ2ckdx2BYWFjU6ZJ0bTVyR44ciczMTMycORNpaWkIDQ3Fli1b1BOvX7p0SeOM1U8//RQlJSUYNmyYxnbuTuSuUChw4sQJrFq1CllZWfDx8UG/fv3w9ttvG8ylWGR+GjRowDtcExHpkDHfsNgYayF9149sPhIREZHRSE9Px/r169GnT58KdxU0VzNnzqxQPK5fvx7//PMPoqOj0bx5cwDA2bNnsW3bNrRu3VrrN5yZOnVqlZcW7d69W2M5JSXlgduytbXF1q1btZSMqP4kSUL37t057QMRkY4EBASgQYMGcseoF2OrhfRdP7L5SEREREYlPz8fv/zyC7p06YKQkBCzvxHNrFmzNJY///xzZGRk4NSpU+rC8a4zZ86gV69e8PHx0WNCIuPWunVruLu7yx2DiMgkSZKE8PBwuWOYHX3Xj/z6joiIiIyOSqXCvn378Pvvv0OlUskdx6DMnz8fU6dOrVA4AkDLli0xdepUvP/++zIkIzI+dnZ2NboRABER1U1QUJDRzvVoSnRdP7L5SEREREbr7qUgvBHNv65cuQIrK6sqn7eyssKVK1f0mIjIeHXq1OmB/56IiKjuJEky6rkeTYmu60c2H4mIiMioXbp0Cbt27YIQQu4oBqF169b45JNPcPXq1QrPXblyBZ988gnatGkjQzIi4+Lu7o6goCC5YxARmSx/f384OzvLHYOg+/qRcz4SERGR0bt48SJcXV05ZxCADz/8ENHR0WjWrBkef/xxdfMkMTERGzZsgBACX3/9tcwpiQxfp06dzH5OWSIiXWrbtq3cEej/6bp+ZPORiIiITMLRo0fh7u6Opk2byh1FVpGRkThw4ABmzJiB9evXo7CwEMCdOydGR0dj9uzZPPORqBqNGjXijZmIiHTI3d2dN/MyILquH9l8JCIiIpMghMDOnTsxaNAgNGjQQO44smrdujXWr18PlUqFzMxMAHeKfAsLzrhDVBMdOnSQOwIRkUlr3rw5zy43MLqsH1mBEhERkckoLS3Fr7/+iuzsbLmjGAQLCwt4enrC09OTjUeiGvLz84OHh4fcMYiITJaFhQUCAgLkjkFV0EX9yCqUiIiIZJOYmIicnBwAQGFhIdLT0+u9zcLCQmzatAn5+fn13hYRmRdJknjWIxGRjnl7e8PGxkbuGKRHbD4SERGRLBISEtCiRQvk5uYCAIqLixEXF4c///yz3tvOy8vDjh07eAdsIqqVFi1awNXVVe4YREQmzdfXV+4IpGdsPhIREZHeJSYmYtKkSVCpVBrrhRBYvXo1MjIy6r2P9PR0XLhwod7bISLzoFQqedYjEZEeNG7cWO4IpGdsPhIREZHerVixospJxiVJwr59+7SynytXrmhlO0Rk+jp37szLAImItMzLywteXl5wcnICcOfuyc7OzjKnIn3j3a6JiIhI71JSUqq8JFoIgZs3b2plP7zJChHVhLe3N5o1ayZ3DCIik3P48GFcu3YNGzduBAB4eHjwLtdmiBU5ERER6Z2fn98Dz3xs0KCBVvbj7e2tle0QkelSKBR46KGH+McwEZEeNGzYUO4IJAOjbT7OnTsXXbt2hZ2dHVxcXOSOQ0RERLXw5JNPPvDMx27dutV7H1ZWVvDz86v3dvSJ9Q2R/rVt25b/3oiI9MTNzU3uCCQDo20+lpSUYPjw4XjmmWfkjkJERES1FBwcjOXLl1e4LFqSJIwbNw4eHh713kdQUBCsrKzqvR19Yn1DpF92dnYIDQ2VOwYRkdnglz3myWjnfJw9ezYAYOXKlfIGISIiojoZP348IiMj0b59e+Tm5kKpVOKtt97SSuMRAFq3bq2V7egT6xsi/Wrfvr3RfUlBRGSsJElS33iGzIvRNh/rori4GMXFxerlvLw8GdMQERFRUFAQnJyckJubC1tbW601Hv39/eHq6qqVbVUlLy8POTk56mWlUgmlUqnTfRKR9tjZ2aF58+ZyxyAiMht2dnZQKBRyxyAZGO1l13URHx8PZ2dn9SMqKkruSERERKRllpaW6NSpk873ExUVpVFXxMfH63yfRKQ9ISEh/COYiEiPHB0d5Y5AMjGo5uMbb7wBSZIe+Dh79mydtx8bG4vs7Gz1Y8+ePVpMT0RERIYgMjJSL5f07NmzR6OuiI2NrXScrusbIqo9SZLQokULuWMQEZkVNh/Nl0Fddv3KK69g/PjxDxwTEBBQ5+3ffzmUg4NDnbdFREREhqdLly5o1qyZXvbl4OBQoyanrusbIqq9pk2bws7OTu4YRERmhT0Y82VQzUd3d3e4u7vLHYOIiIiMjLW1NXr06AE/Pz+5o1TA+oZIfl5eXigpKYGtrS0AIDAwUOZERETmh81H82VQzcfauHTpEm7duoVLly6hvLwcx48fB3Bn4noe0EREROajYcOG6N27N5ydneWOUm+sb4h04/Dhwzh48CCOHz8OhUKBpk2byh2JiMjs8LJr82VQcz7WxsyZMxEWFoa4uDjk5eUhLCwMYWFhOHz4sNzRiIiISE+Cg4Px2GOPmUTjETDe+mbp0qXw8/ODjY0NOnXqhIMHDz5w/A8//IAWLVrAxsYGbdq0wa+//qrxvBACM2fOhLe3N2xtbdGnTx8kJibq8i2QGfH09IS1tbXcMYiIzI69vb3cEXSGtdCDGW3zceXKlRBCVHj06NFD7mhERESkB+3atUOPHj1M6m61xljfrFmzBtOmTUNcXByOHj2Kdu3aITo6GhkZGZWO//PPPzF69GhMnDgRx44dw+DBgzF48GCcOnVKPeb999/HRx99hGXLluHAgQOwt7dHdHQ0ioqK9PW2yIR5e3vLHYGIyCyZ6lUcrIWqZ7TNRyIiIjJfISEh6NixIyRJkjuK2Vu4cCEmT56MCRMmICQkBMuWLYOdnR1WrFhR6fjFixejf//+eO2119CyZUu8/fbbaN++PT7++GMAd77pX7RoEd566y089thjaNu2LVavXo1r165hw4YNenxnZKo8PDzkjkBEZHasra1hZWUldwydYC1UPaOd85GIiIjMk6+vL7p168bGowEoKSnBkSNHEBsbq15nYWGBPn36YP/+/ZW+Zv/+/Zg2bZrGuujoaHUxnZycjLS0NPTp00f9vLOzMzp16oT9+/dj1KhRlW63uLgYxcXF6uW8vDwAQFlZGUpLS+v0/si0lJWVoby8HI6OjjwmiIj0qLS0FEql0ig+e8vKygDcqSNycnLU65VKJZRKZYXxhlQLGTI2H4mIiMhoeHt7o3fv3mw8GogbN26gvLwcnp6eGus9PT1x9uzZSl+TlpZW6fi0tDT183fXVTWmMvHx8Zg9e3aF9Z06dar+jZBZefbZZ+WOQERklsaMGSN3hBqLiorSWI6Li8OsWbMqjDOkWsiQsflIRERERsHX1xe9e/eGpSXLF6ooNjZW4yyC48ePIyoqCgcOHEBYWJiMychQHDp0CMnJyRgxYoTcUYiIzMq1a9dw/vx5g57D+q5jx46hU6dO2LNnD0JDQ9XrKzvrkWqO1TsREREZvNatW6Nz586wsOB01YakYcOGUCgUSE9P11ifnp4OLy+vSl/j5eX1wPF3/zc9PV3jxiDp6ekafwTc7/7Loe5Oam9paWmyc0xR7VhaWsLJyYnHAxGRnllZWcHBwcEoPn/vfsnt4OAAJyenascbUi1kyFjBExERkcGSJAmRkZHo2rUrG48GyNraGuHh4di5c6d6nUqlws6dO9GlS5dKX9OlSxeN8QCwfft29Xh/f394eXlpjMnJycGBAweq3CZRTdna2sodgYjILNnY2MgdQSdYC9UMz3wkIiIigyRJEnr37o2AgAC5o9ADTJs2DTExMYiIiEDHjh2xaNEi5OfnY8KECQCAcePGoVGjRoiPjwcAvPjii4iKisIHH3yAgQMH4vvvv8fhw4fx+eefA7jz//tLL72Ed955B8HBwfD398eMGTPg4+ODwYMHy/U2yUSw+UhEJA9TbT4CrIVqgs1HIiIiMkg9evRg49EIjBw5EpmZmZg5cybS0tIQGhqKLVu2qCdJv3TpksZZq127dsW3336Lt956C2+++SaCg4OxYcMGtG7dWj3m9ddfR35+Pp566ilkZWUhMjISW7ZsMek/XEg/eAwREcnDlOdMZC1UPUkIIeQOIZejR48iPDwcR44cQfv27eWOQ0REZJYaN26Mq1evwsXFBe+99x4AoFWrVujWrZvMySrH+sE48P8nut/Bgwfh4OCAkJAQuaMQEZmVa9euQaVSoXHjxnJHqRbrB93g5ElERERkUOzt7dGxY0e5YxCRCbKzs5M7AhGRWTKGm82Q7vCyayIiIpKVl5cXysrK1JfjtG3blgUqEekEm49ERPKwtraWOwLJiM1HIiIiktXhw4eRlJSE3377DRYWFggODpY7EhGZKN5whohIHpaWbD+ZM152TURERAbDy8vLaCfSJiLDxzMfiYjkweajeWPzkYiIiAxGkyZN5I5ARCbKysoKCoVC7hhERGaJn7/mjc1HIiIiMhjGcBdEIjJOd+eVJSIi/WPz0byx+UhEREQGwdbWFm5ubnLHICITxZsdEBHJx8KC7Sdzxv/3iYiIyCB4eXlBkiS5YxCRibKyspI7AhGRWVIoFKzxzBybj0RERGQQ3N3d5Y5ARCaMl/wREcmDn7/E5iMREREZBF5yTUS6xD9+iYjkwUuuiUcAERERGQQnJye5IxCRCWPzkYhIHvz8JTYfiYiIyCDY29vLHYGITBj/+CUikgfPfCQeAURERCQ7S0tL3gyCiHSKf/wSEcmDn7/EI4CIiIhkp1Qq5Y5ARCaOZz4SEcmDzUfiEUBERESys7a2ljsCEZk4/vFLRCQPfv4SjwAiIiKSHZuPRKRrnNqBiEgekiTJHYFkxuYjERERyc7S0lLuCERk4ji9AxGRPNh8JDYfiYiISHaci42IiIjINLH5SGw+EhERkex45iMRERGRaeKcj8QjgIiIiGTHopSIiIjINLHOIx4BREREREREREREpBNsPhIREREREREREZFOsPlIREREREREREREOsHmIxERERHVya1bt/Cf//wHTk5OcHFxwcSJE5GXl/fA8c8//zyaN28OW1tbNG3aFC+88AKys7M1xkmSVOHx/fff6/rtEBEREemMOddNvLUkEREREdXJf/7zH1y/fh3bt29HaWkpJkyYgKeeegrffvttpeOvXbuGa9euYcGCBQgJCUFqaiqefvppXLt2DT/++KPG2ISEBPTv31+97OLiosu3QkRERKRT5lw3sflIRERERLV25swZbNmyBYcOHUJERAQAYMmSJXj44YexYMEC+Pj4VHhN69atsXbtWvVyYGAg5s6di7Fjx6KsrAyWlv+Wpi4uLvDy8tL9GyEiIiLSMXOvm3jZNRERERHV2v79++Hi4qIuoAGgT58+sLCwwIEDB2q8nezsbDg5OWkU0ADw3HPPoWHDhujYsSNWrFgBIcQDt1NcXIycnBz140GXMRERERE9SF5enkZdUVxcXK/tGVrdpG8889HIXL9+HdevX5c7hsny9vaGt7e33DFMFo9f3eLxq1s8fnWLx6/xSUtLg4eHh8Y6S0tLuLm5IS0trUbbuHHjBt5++2089dRTGuvnzJmDXr16wc7ODtu2bcOzzz6LvLw8vPDCC1VuKz4+HrNnz679GzEg/JzRLX7O6BaPX93i8atbPH51yxiP36ioKI3luLg4zJo1q87bM7S6Se+EGbt27ZqIi4sT165dkztKjRQVFYmoqCgBgA8dPaKiokRRUZHc/1ebJB6/PH6NGY9fHr/3Mrb6obb++9//Vvv/15kzZ8TcuXNFs2bNKrze3d1dfPLJJ9XuJzs7W3Ts2FH0799flJSUPHDsjBkzROPGjR84pqioSGRnZ6sf586dE9OnTzea/5/4OcPPGWPG45fHrzHj8cvj917Xrl0T06dPF+fOndOoK6rKb6x1k75JQhjYuZhUpZycHDg7O2PPnj1wcHCQO47JycvLQ1RUlPo0ZtIuHr+6xeNXt3j86haPX8OSmZmJmzdvPnBMQEAAvv76a7zyyiu4ffu2en1ZWRlsbGzwww8/4PHHH6/y9bm5uYiOjoadnR02btwIGxubB+5v06ZNeOSRR1BUVASlUlm7N2Qk+DmjW/yc0S0ev7rF41e3ePzqlqkfv6ybaoaXXRuh0NBQk/xHK7ecnBy5I5gFHr+6weNXP3j86gaPX8Pi7u4Od3f3asd16dIFWVlZOHLkCMLDwwEAv/32G1QqFTp16lTl63JychAdHQ2lUomff/652gIaAI4fPw5XV1eDKaB1iZ8zusHPGf3g8asbPH71g8evbpj68cu6qWbYfCQiIiKiWmvZsiX69++PyZMnY9myZSgtLcXUqVMxatQo9R0br169it69e2P16tXo2LEjcnJy0K9fPxQUFODrr79WT+IO3CneFQoFfvnlF6Snp6Nz586wsbHB9u3bMW/ePLz66qtyvl0iIiKiOjP3uonNRyIiIiKqk2+++QZTp05F7969YWFhgaFDh+Kjjz5SP19aWopz586hoKAAAHD06FH1HR2DgoI0tpWcnAw/Pz9YWVlh6dKlePnllyGEQFBQEBYuXIjJkyfr740RERERaZk5101sPhoRpVKJuLg4gzp11pTw56tb/PnqFn++usWfr27x52u83Nzc8O2331b5vJ+fH+6dXrxHjx6obrrx/v37o3///lrLaCz470C3+PPVLf58dYs/X93iz1e3+PP9lznXTbzhDBEREREREREREemEhdwBiIiIiIiIiIiIyDSx+UhEREREREREREQ6weYjERERERERERER6QSbj2Tyxo8fDz8/P7ljYPz48XBwcJA7BhERZs2aBUmSav06Q/g8rU+GHj16oEePHlrNQ0TyMoTPpbs5WOcRkSFgnUeGiM1H0puVK1dCkiRIkoQ//vijwvNCCDRp0gSSJOGRRx6pdns9evRQb0+SJLi5uaFDhw5YsWIFVCqVLt4CUY3p8ni3sLCAk5MTmjdvjieeeALbt2/XxVsgqlZBQQFmzZqF3bt3yx2lTq5du4ZZs2bh+PHjckchMnqs88icsM4jc8A6j7SJzUfSOxsbm0pvL79nzx5cuXIFSqWyxttq3LgxvvrqK3z11VeYMWMGysrKMHHiRLz55pvajExUZ7o43levXo358+dj0KBB+PPPP9GvXz+MHDkSpaWl2oxOVK2CggLMnj3bqIvS2bNnsygl0iLWeWROWOeRKWOdR9rE5iPp3cMPP4wffvgBZWVlGuu//fZbhIeHw8vLq8bbcnZ2xtixYzF27Fi8/PLL2LdvHxo3boyPP/6Yv6DJIOjqeJ8yZQrmz5+P8+fP49lnn8X//vc/vPXWWw98vUqlQlFRUZ3eBxERUU2wziNzwjqPiKhm2HwkvRs9ejRu3rypcQlBSUkJfvzxR4wZM6Ze27azs0Pnzp2Rn5+PzMzMKsctWLAAXbt2RYMGDWBra4vw8HD8+OOPlY79+uuv0bFjR9jZ2cHV1RXdu3fHtm3bNMZs3rwZDz30EOzt7eHo6IiBAwfin3/+qXR7Fy9eRHR0NOzt7eHj44M5c+ZACKExJj8/H6+88gqaNGkCpVKJ5s2bY8GCBRXGkeHT5fEOAAqFAh999BFCQkLw8ccfIzs7W/2cJEmYOnUqvvnmG7Rq1QpKpRJbtmzB7t27IUlShW8xU1JSIEkSVq5cqbH+hx9+QEhICGxsbNC6dWusX7/eIOaEoZr5448/0KFDB9jY2CAwMBCfffZZpeO+/vprhIeHw9bWFm5ubhg1ahQuX75c5XZTUlLg7u4OAJg9e7b6crFZs2YBAE6cOIHx48cjICAANjY28PLywpNPPombN2/WOPuGDRvQunVrjWOvMiqVCosWLUKrVq1gY2MDT09PTJkyBbdv365y27t370aHDh0AABMmTFDnv3v8//777xg+fDiaNm0KpVKJJk2a4OWXX0ZhYWGN8xOZI9Z5rPPMCes8khvrvMqxzjM8bD6S3vn5+aFLly747rvv1Os2b96M7OxsjBo1qt7bv3jxIhQKBVxcXKocs3jxYoSFhWHOnDmYN28eLC0tMXz4cGzatElj3OzZs/HEE0/AysoKc+bMwezZs9GkSRP89ttv6jFfffUVBg4cCAcHB7z33nuYMWMGTp8+jcjISKSkpGhsr7y8HP3794enpyfef/99hIeHIy4uDnFxceoxQggMGjQIH374Ifr374+FCxeiefPmeO211zBt2rR6/3xIv3R9vAN3CtPRo0ejoKCgwrxDv/32G15++WWMHDkSixcvrnUhuWnTJowcORJWVlaIj4/HkCFDMHHiRBw5ckQr2Um3Tp48iX79+iEjIwOzZs3ChAkTEBcXV6G4mzt3LsaNG4fg4GAsXLgQL730Enbu3Inu3bsjKyur0m27u7vj008/BQA8/vjj6ksjhwwZAgDYvn07Ll68iAkTJmDJkiUYNWoUvv/+ezz88MM1+gN727ZtGDp0KCRJQnx8PAYPHowJEybg8OHDFcZOmTIFr732Grp164bFixdjwoQJ+OabbxAdHV3l2VEtW7bEnDlzAABPPfWUOn/37t0B3PljrKCgAM888wyWLFmC6OhoLFmyBOPGjas2O5E5Y53HOs+csM4jObHOY51nVASRniQkJAgA4tChQ+Ljjz8Wjo6OoqCgQAghxPDhw0XPnj2FEEL4+vqKgQMHVru9qKgo0aJFC5GZmSkyMzPFmTNnxAsvvCAAiEcffVQ9LiYmRvj6+mq89u5+7yopKRGtW7cWvXr1Uq9LTEwUFhYW4vHHHxfl5eUa41UqlRBCiNzcXOHi4iImT56s8XxaWppwdnbWWB8TEyMAiOeff15jOwMHDhTW1tYiMzNTCCHEhg0bBADxzjvvaGxz2LBhQpIkkZSUVO3PhuSni+O9VatWVT6/fv16AUAsXrxYvQ6AsLCwEP/884/G2F27dgkAYteuXRrrk5OTBQCRkJCgXtemTRvRuHFjkZubq163e/duAaDCvysyPIMHDxY2NjYiNTVVve706dNCoVCIuyVASkqKUCgUYu7cuRqvPXnypLC0tNRYf//naWZmpgAg4uLiKuz7/s9ZIYT47rvvBACxd+/earOHhoYKb29vkZWVpV63bdu2Csfe77//LgCIb775RuP1W7ZsqbA+KipKREVFqZcPHTpU4Zh/UP74+HghSZLGz5OI7mCdxzrPnLDOI0PAOo91njHhmY8kixEjRqCwsBAbN25Ebm4uNm7cWKdLE86ePQt3d3e4u7ujZcuWWLJkCQYOHIgVK1Y88HW2trbq/759+zays7Px0EMP4ejRo+r1GzZsgEqlwsyZM2FhoflPRZIkAHe+8cnKysLo0aNx48YN9UOhUKBTp07YtWtXhX1PnTpVYztTp05FSUkJduzYAQD49ddfoVAo8MILL2i87pVXXoEQAps3b67hT4cMhbaO9wdxcHAAAOTm5mqsj4qKQkhISJ22ee3aNZw8eRLjxo1Tb//uNtu0aVP3sKQX5eXl2Lp1KwYPHoymTZuq17ds2RLR0dHq5XXr1kGlUmHEiBEan2NeXl4IDg6u9HOsJu79nC0qKsKNGzfQuXNnAND4rK3M9evXcfz4ccTExMDZ2Vm9vm/fvhWO5x9++AHOzs7o27evRv7w8HA4ODhoJX9+fj5u3LiBrl27QgiBY8eO1WmbROaCdd6/22GdZ/pY55EcWOexzjM2lnIHIPPk7u6OPn364Ntvv0VBQQHKy8sxbNiwWm/Hz88PX3zxBSRJgo2NDYKDg+Hh4VHt6zZu3Ih33nkHx48fR3FxsXr93WITAC5cuAALC4sH/kJPTEwEAPTq1avS552cnDSWLSwsEBAQoLGuWbNmAKC+dCc1NRU+Pj5wdHTUGNeyZUv182RctHW8P0heXh4AVDhu/P3967zNu8daUFBQheeCgoKqLSxIXpmZmSgsLERwcHCF55o3b45ff/0VwJ3PMSFEpeMAwMrKqk77v3XrFmbPno3vv/8eGRkZGs/dnbOqpKQEt27d0njO3d1dfexVlf3eYy8xMRHZ2dlVfvbfv++aunTpEmbOnImff/65wpxC9865RUQVsc77F+s808c6j+TAOu8O1nnGg81Hks2YMWMwefJkpKWlYcCAAQ+cu6cq9vb26NOnT61e8/vvv2PQoEHo3r07PvnkE3h7e8PKygoJCQn49ttva7UtlUoF4M58QJXdzc7Skv/E6A5tHO8PcurUKQAVC8h7v9W7694/vu5VXl6u1UxkHFQqFSRJwubNm6FQKCo8f+/ZELUxYsQI/Pnnn3jttdcQGhoKBwcHqFQq9O/fX/3Z+eeff6Jnz54ar0tOTq51fg8PD3zzzTeVPn93svTaKC8vR9++fXHr1i3897//RYsWLWBvb4+rV69i/Pjx6vxEVDXWeWROWOeRoWKdVxHrPHnwNybJ5vHHH8eUKVPw119/Yc2aNXrb79q1a2FjY4OtW7dCqVSq1yckJGiMCwwMhEqlwunTpxEaGlrptgIDAwEAHh4eNSqOVSoVLl68qP4WHADOnz8PAOoJon19fbFjxw7k5uZqfLt59uxZ9fNkfHR5vJeXl+Pbb7+FnZ0dIiMjqx3v6uoKABUmmL7/bIu7x1pSUlKFbVS2jgyLu7s7bG1t1Wfu3OvcuXPq/w4MDIQQAv7+/hqfTTVR1R84t2/fxs6dOzF79mzMnDlTvf7+LO3atdO4QygAeHl5qT+bq8t+N/+OHTvQrVu3Sv8Iq0v+kydP4vz581i1apXGxOP3ZyWiqrHOu4N1nnlgnUf6xjqv7vlZ58mDcz6SbBwcHPDpp59i1qxZePTRR/W2X4VCAUmSNL79S0lJwYYNGzTGDR48GBYWFpgzZ06Fbz/E/9/BKzo6Gk5OTpg3b16ld9rKzMyssO7jjz/W2M7HH38MKysr9O7dGwDw8MMPo7y8XGMcAHz44YeQJAkDBgyo3Rsmg6Cr4728vBwvvPACzpw5gxdeeKHCJWCV8fX1hUKhwN69ezXWf/LJJxrLPj4+aN26NVavXq2+3AcA9uzZg5MnT2rnDZDOKBQKREdHY8OGDbh06ZJ6/ZkzZ7B161b18pAhQ6BQKDB79uwKdycUQuDmzZtV7sPOzg5AxT9w7n6zfv/2Fi1apLHs6uqKPn36aDxsbGzg7e2N0NBQrFq1SuPSl+3bt+P06dMa2xgxYgTKy8vx9ttvV8hXVlZW5V0cgTtnVdU0vxACixcvrnJbRKSJdR7rPHPCOo/0jXUe6zxjwzMfSVYxMTF63+fAgQOxcOFC9O/fH2PGjEFGRgaWLl2KoKAgnDhxQj0uKCgI06dPx9tvv42HHnoIQ4YMgVKpxKFDh+Dj44P4+Hg4OTnh008/xRNPPIH27dtj1KhRcHd3x6VLl7Bp0yZ069ZNo7i0sbHBli1bEBMTg06dOmHz5s3YtGkT3nzzTfUp448++ih69uyJ6dOnIyUlBe3atcO2bdvw008/4aWXXlJ/C0/Gp77He3Z2Nr7++msAQEFBAZKSkrBu3TpcuHABo0aNqvSXcmWcnZ0xfPhwLFmyBJIkITAwEBs3bqx0zpR58+bhscceQ7du3TBhwgTcvn0bH3/8MVq3bq1RqJJhmj17NrZs2YKHHnoIzz77LMrKyrBkyRK0atVK/XkXGBiId955B7GxsUhJScHgwYPh6OiI5ORkrF+/Hk899RReffXVSrdva2uLkJAQrFmzBs2aNYObmxtat26N1q1bo3v37nj//fdRWlqKRo0aYdu2bbW61CY+Ph4DBw5EZGQknnzySdy6dUud/d5jLyoqClOmTEF8fDyOHz+Ofv36wcrKComJifjhhx+wePHiKufeCgwMhIuLC5YtWwZHR0fY29ujU6dOaNGiBQIDA/Hqq6/i6tWrcHJywtq1ayvMCURED8Y6j3WeOWGdR/rGOo91nlHR5621ybwlJCQIAOLQoUMPHOfr6ysGDhxY7faioqJEq1atqh0XExMjfH19NdYtX75cBAcHC6VSKVq0aCESEhJEXFycqOyfxIoVK0RYWJhQKpXC1dVVREVFie3bt2uM2bVrl4iOjhbOzs7CxsZGBAYGivHjx4vDhw9r5LC3txcXLlwQ/fr1E3Z2dsLT01PExcWJ8vJyje3l5uaKl19+Wfj4+AgrKysRHBws5s+fL1QqVbXvlwyDLo53AOqHg4ODCA4OFmPHjhXbtm2r9DUAxHPPPVfpc5mZmWLo0KHCzs5OuLq6iilTpohTp04JACIhIUFj7Pfffy9atGghlEqlaN26tfj555/F0KFDRYsWLarNTfLbs2ePCA8PF9bW1iIgIEAsW7as0s+7tWvXisjISGFvby/s7e1FixYtxHPPPSfOnTunHlPZ5+mff/6p3j4AERcXJ4QQ4sqVK+Lxxx8XLi4uwtnZWQwfPlxcu3ZNY0x11q5dK1q2bCmUSqUICQkR69atqzSDEEJ8/vnnIjw8XNja2gpHR0fRpk0b8frrr4tr166px0RFRYmoqCiN1/30008iJCREWFpaahz/p0+fFn369BEODg6iYcOGYvLkyeLvv/+u9N8IEbHOY51nXljnkaFgncc6z1hIQtx3riwREVE1QkND4e7uzrlRiIiIiEwM6zwi0jbO+UhERFUqLS1FWVmZxrrdu3fj77//Ro8ePeQJRURERET1xjqPiPSFZz4SEVGVUlJS0KdPH4wdOxY+Pj44e/Ysli1bBmdnZ5w6dQoNGjSQOyIRERER1QHrPCLSF95whoiIquTq6orw8HB8+eWXyMzMhL29PQYOHIh3332XBSkRERGREWOdR0T6wjMfiYiIiIiIiIiISCc45yMRERERERERERHpBJuPREREREREREREpBNsPpLZSElJgSRJWLlypdxRiGqNxy8REVHV+HuSjBmPXyIydWw+EhERERERERERkU7whjNkNoQQKC4uhpWVFRQKhdxxiGqFxy8REVHV+HuSjBmPXyIydWw+EhERERERERERkU7wsmsyKrNmzYIkSTh//jzGjh0LZ2dnuLu7Y8aMGRBC4PLly3jsscfg5OQELy8vfPDBB+rXVjaXyvjx4+Hg4ICrV69i8ODBcHBwgLu7O1599VWUl5erx+3evRuSJGH37t0aeSrbZlpaGiZMmIDGjRtDqVTC29sbjz32GFJSUnT0UyFjweOXiIioavw9ScaMxy8RUdXYfCSjNHLkSKhUKrz77rvo1KkT3nnnHSxatAh9+/ZFo0aN8N577yEoKAivvvoq9u7d+8BtlZeXIzo6Gg0aNMCCBQsQFRWFDz74AJ9//nmdsg0dOhTr16/HhAkT8Mknn+CFF15Abm4uLl26VKftkenh8UtERFQ1/p4kY8bjl4ioEoLIiMTFxQkA4qmnnlKvKysrE40bNxaSJIl3331Xvf727dvC1tZWxMTECCGESE5OFgBEQkKCekxMTIwAIObMmaOxn7CwMBEeHq5e3rVrlwAgdu3apTHu/m3evn1bABDz58/Xzhsmk8Ljl4iIqGr8PUnGjMcvEVHVeOYjGaVJkyap/1uhUCAiIgJCCEycOFG93sXFBc2bN8fFixer3d7TTz+tsfzQQw/V6HX3s7W1hbW1NXbv3o3bt2/X+vVkHnj8EhERVY2/J8mY8fglIqqIzUcySk2bNtVYdnZ2ho2NDRo2bFhhfXW/XG1sbODu7q6xztXVtU6/lJVKJd577z1s3rwZnp6e6N69O95//32kpaXVeltkunj8EhERVY2/J8mY8fglIqqIzUcySgqFokbrAEBUc0P3ql53L0mSKl1/72TPd7300ks4f/484uPjYWNjgxkzZqBly5Y4duxYtfsh88Djl4iIqGr8PUnGjMcvEVFFbD4S1YCrqysAICsrS2N9ampqpeMDAwPxyiuvYNu2bTh16hRKSko07mhHpE88fomIiKrG35NkzHj8EpExYPORqAZ8fX2hUCgq3JHuk08+0VguKChAUVGRxrrAwEA4OjqiuLhY5zmJKsPjl4iIqGr8PUnGjMcvERkDS7kDEBkDZ2dnDB8+HEuWLIEkSQgMDMTGjRuRkZGhMe78+fPo3bs3RowYgZCQEFhaWmL9+vVIT0/HqFGjZEpP5o7HLxERUdX4e5KMGY9fIjIGbD4S1dCSJUtQWlqKZcuWQalUYsSIEZg/fz5at26tHtOkSROMHj0aO3fuxFdffQVLS0u0aNEC//vf/zB06FAZ05O54/FLRERUNf6eJGPG45eIDJ0kqpvlloiIiIiIiIiIiKgOOOcjERERERERERER6QSbj0RERERERERERKQTbD4SERERERERERGRTrD5SERERERERERERDrB5iMRERERERERERHpBJuPREREREREREREpBNsPpJZmDVrFiRJkjuGOseNGzfkjkJERERkEljnERERGTY2H0nn/ve//0GSJKxfv77Cc+3atYMkSdi1a1eF55o2bYquXbs+cNvjx4+HJEnqh5OTE9q1a4cPPvgAxcXFWnsPRDWlz+PdwcEBAQEBGDZsGNauXQuVSqW190FERFQTrPPInLDOIyKqGzYfSeciIyMBAH/88YfG+pycHJw6dQqWlpbYt2+fxnOXL1/G5cuX1a99EKVSia+++gpfffUV5s2bBzc3N7z66quIiYnR3psgqiF9Hu8ffvghxowZg8TERAwbNgy9e/dGTk6O9t4MERFRNVjnkTlhnUdEVDeWcgcg0+fj4wN/f/8Kv6T3798PIQSGDx9e4bm7yzX5JW1paYmxY8eql5999ll06tQJa9aswcKFC+Hj46OFd0FUM/o+3gHgnXfewbvvvovY2FhMnjwZa9asqfL1QggUFRXB1ta2pm+JiIioSqzzyJywziMiqhue+Uh6ERkZiWPHjqGwsFC9bt++fWjVqhUGDBiAv/76S+NSgn379kGSJHTr1q3W+7KwsECPHj0AACkpKVWOS0hIQK9eveDh4QGlUomQkBB8+umnlY7dvHkzoqKi4OjoCCcnJ3To0AHffvutxpgDBw6gf//+cHZ2hp2dHaKioip883nXjRs3MGLECDg5OaFBgwZ48cUXUVRUpDGmrKwMb7/9NgIDA6FUKuHn54c333yTlxkZAX0e73e98cYb6NevH3744QecP39evd7Pzw+PPPIItm7dioiICNja2uKzzz5DSkoKJEnCypUrK2xLkiTMmjVLY93u3bsREREBGxsbBAYG4rPPPjOYObaIiEherPM0sc4zbazziIhqj81H0ovIyEiUlpbiwIED6nX79u1D165d0bVrV2RnZ+PUqVMaz7Vo0QINGjSo0/4uXLgAAA98/aeffgpfX1+8+eab+OCDD9CkSRM8++yzWLp0qca4lStXYuDAgbh16xZiY2Px7rvvIjQ0FFu2bFGP+e2339C9e3fk5OQgLi4O8+bNQ1ZWFnr16oWDBw9W2PeIESNQVFSE+Ph4PPzww/joo4/w1FNPaYyZNGkSZs6cifbt2+PDDz9EVFQU4uPjMWrUqDr9TEh/9H283/XEE09ACIHt27drrD937hxGjx6Nvn37YvHixQgNDa3Vdo8dO4b+/fvj5s2bmD17NiZOnIg5c+Zgw4YN9cpLRESmgXWeJtZ5po11HhFRHQgiPfjnn38EAPH2228LIYQoLS0V9vb2YtWqVUIIITw9PcXSpUuFEELk5OQIhUIhJk+eXO12Y2JihL29vcjMzBSZmZkiKSlJzJs3T0iSJNq2baseFxcXJ+4/3AsKCipsLzo6WgQEBKiXs7KyhKOjo+jUqZMoLCzUGKtSqdT/GxwcLKKjo9Xr7m7f399f9O3bt0KOQYMGaWzr2WefFQDE33//LYQQ4vjx4wKAmDRpksa4V199VQAQv/32W7U/G5KPro/3qhw7dkwAEC+//LJ6na+vrwAgtmzZojE2OTlZABAJCQkVtgNAxMXFqZcfffRRYWdnJ65evapel5iYKCwtLSv8uyIiIvPDOk8zB+s808Y6j4io9njmI+lFy5Yt0aBBA/WcJ3///Tfy8/PVd33r2rWr+tKV/fv3o7y8vEbzogBAfn4+3N3d4e7ujqCgILz55pvo0qVLpXehu9e9c6FkZ2fjxo0biIqKwsWLF5GdnQ0A2L59O3Jzc/HGG2/AxsZG4/V3L0M4fvw4EhMTMWbMGNy8eRM3btzAjRs3kJ+fj969e2Pv3r0V7k733HPPaSw///zzAIBff/1V43+nTZumMe6VV14BAGzatKn6HwzJRpfH+4M4ODgAAHJzczXW+/v7Izo6uk7bLC8vx44dOzB48GCNebWCgoIwYMCAuoclIiKTwTqPdZ45YZ1HRFR7vOEM6YUkSejatau6QNu3bx88PDwQFBQE4M4v6Y8//hgA1L+sa/pL2sbGBr/88guAO3eI8/f3R+PGjat93b59+xAXF4f9+/ejoKBA47ns7Gw4OzurL+tp3bp1ldtJTEwEgAfedTE7Oxuurq7q5eDgYI3nAwMDYWFhoZ67KDU1FRYWFuqfz11eXl5wcXFBampqte+P5KPL4/1B8vLyAACOjo4a6/39/eu8zYyMDBQWFlY4FgFUuo6IiMwP6zzWeeaEdR4RUe2x+Uh6ExkZiV9++QUnT55Uz4tyV9euXfHaa6/h6tWr+OOPP+Dj44OAgIAabVehUKBPnz61ynLhwgX07t0bLVq0wMKFC9GkSRNYW1vj119/xYcffljhG+wHuTt2/vz5Vc6xcvebyqpUNZkzJ3k2Xro63h/k7vxC9xeLld3xsKpjq7y8vN45iIjI/LDOqxrrPNPDOo+IqHbYfCS9ufuN3x9//IF9+/bhpZdeUj8XHh4OpVKJ3bt348CBA3j44Yd1muWXX35BcXExfv75ZzRt2lS9fteuXRrjAgMDAdz5ZV/Vt393xzg5OdW4OE5MTNT4ljIpKQkqlQp+fn4AAF9fX6hUKiQmJqJly5bqcenp6cjKyoKvr2+N9kPykeN4/+qrryBJEvr27Vvt2LtnaGRlZWmsv/9sCw8PD9jY2CApKanCNipbR0RE5ol13r9Y55k+1nlERLXDOR9JbyIiImBjY4NvvvkGV69e1fiGUKlUon379li6dCny8/O1cmnCgygUCgCAEEK9Ljs7GwkJCRrj+vXrB0dHR8THx6OoqEjjubuvDQ8PR2BgIBYsWKC+HOJemZmZFdbdf6fFJUuWAIB6bpW7RcqiRYs0xi1cuBAAMHDgwAe/QZKdvo/3d999F9u2bcPIkSMrXO5VGScnJzRs2BB79+7VWP/JJ59oLN8942TDhg24du2aen1SUhI2b95c79xERGQaWOf9i3We6WOdR0RUOzzzkfTG2toaHTp0wO+//w6lUonw8HCN57t27YoPPvgAgHbmRXmQfv36wdraGo8++iimTJmCvLw8fPHFF/Dw8MD169fV45ycnPDhhx9i0qRJ6NChA8aMGQNXV1f8/fffKCgowKpVq2BhYYEvv/wSAwYMQKtWrTBhwgQ0atQIV69exa5du+Dk5KSeq+iu5ORkDBo0CP3798f+/fvx9ddfY8yYMWjXrh0AoF27doiJicHnn3+OrKwsREVF4eDBg1i1ahUGDx6Mnj176vTnQ/Wnq+O9rKwMX3/9NQCgqKgIqamp+Pnnn3HixAn07NkTn3/+eY23NWnSJLz77ruYNGkSIiIisHfvXpw/f77CuFmzZmHbtm3o1q0bnnnmGZSXl+Pjjz9G69atcfz48Rrvj4iITBfrvH+xzjN9rPOIiGpJ3pttk7mJjY0VAETXrl0rPLdu3ToBQDg6OoqysrIabS8mJkbY29tXOy4uLk7cf7j//PPPom3btsLGxkb4+fmJ9957T6xYsUIAEMnJyRXGdu3aVdja2gonJyfRsWNH8d1332mMOXbsmBgyZIho0KCBUCqVwtfXV4wYMULs3LmzQo7Tp0+LYcOGCUdHR+Hq6iqmTp0qCgsLNbZXWloqZs+eLfz9/YWVlZVo0qSJiI2NFUVFRTX62ZD8dHG8A1A/7OzshJ+fnxg6dKj48ccfRXl5eYXX+Pr6ioEDB1a6vYKCAjFx4kTh7OwsHB0dxYgRI0RGRoYAIOLi4jTG7ty5U4SFhQlra2sRGBgovvzyS/HKK68IGxubGmUnIiLTxzqPdZ45YZ1HRFRzkhD3XI9ARERUQ4MHD8Y///yjvhMoEREREZkG1nlEpE2c85GIiKpVWFiosZyYmIhff/0VPXr0kCcQEREREWkF6zwi0jWe+UhERNXy9vbG+PHjERAQgNTUVHz66acoLi7GsWPHajTxOREREREZJtZ5RKRrvOEMERFVq3///vjuu++QlpYGpVKJLl26YN68eSxIiYiIiIwc6zwi0jWe+UhEREREREREREQ6wTkfiYiIiIiIiIiISCfYfCQiIiIiIiIiIiKdYPORiIiIiIiIiIiIdILNRyIiIiIiIiIiItIJNh+JiIiIiIiIiIhIJ9h8JCIiIiIiItKi8ePHw8/PT+4YREQGgc1HIjJaK1euhCRJ6oeNjQ18fHwQHR2Njz76CLm5ubLmW79+PaKjo+Hj4wOlUonGjRtj2LBhOHXqlKy5iIiIiHTh/trs3scbb7whd7xKzZs3Dxs2bJA7hgZDzEREVB+WcgcgIqqvOXPmwN/fH6WlpUhLS8Pu3bvx0ksvYeHChfj555/Rtm1bWXKdPHkSrq6uePHFF9GwYUOkpaVhxYoV6NixI/bv34927drJkouIiIhIl+7WZvdq3bq1TGkebN68eRg2bBgGDx4sdxQ1Q8xERFQfbD4SkdEbMGAAIiIi1MuxsbH47bff8Mgjj2DQoEE4c+YMbG1tK31tfn4+7O3tdZJr5syZFdZNmjQJjRs3xqeffoply5bpZL9EREREcrq/NtMWXdZtRESkO7zsmohMUq9evTBjxgykpqbi66+/BnBn7h0HBwdcuHABDz/8MBwdHfGf//wHAODn54fx48dX2E6PHj3Qo0cPjXWpqakYNGgQ7O3t4eHhgZdffhlbt26FJEnYvXv3A3N5eHjAzs4OWVlZWniXRERERMbnt99+w0MPPQR7e3u4uLjgsccew5kzZzTGzJo1C5Ik4fTp0xgzZgxcXV0RGRmpfv7rr79GeHg4bG1t4ebmhlGjRuHy5csa20hMTMTQoUPh5eUFGxsbNG7cGKNGjUJ2djYAQJIk5OfnY9WqVerLwyurB+/avXs3JEnCmjVr8Oabb8LLywv29vYYNGhQhX1XJj8/H6+88gqaNGkCpVKJ5s2bY8GCBRBCqMfUNhMRkTHgmY9EZLKeeOIJvPnmm9i2bRsmT54MACgrK0N0dDQiIyOxYMEC2NnZ1Wqb+fn56NWrF65fv44XX3wRXl5e+Pbbb7Fr164qX5OVlaW+JHzRokXIyclB79696/XeiIiIiAxVdnY2bty4obGuYcOGAIAdO3ZgwIABCAgIwKxZs1BYWIglS5agW7duOHr0aIWbtAwfPhzBwcGYN2+eukk3d+5czJgxAyNGjMCkSZOQmZmJJUuWoHv37jh27BhcXFxQUlKC6OhoFBcX4/nnn4eXlxeuXr2KjRs3IisrC87Ozvjqq68wadIkdOzYEU899RQAIDAwsNr3N3fuXEiShP/+97/IyMjAokWL0KdPHxw/frzKq22EEBg0aBB27dqFiRMnIjQ0FFu3bsVrr72Gq1ev4sMPPwSAOmciIjJogojISCUkJAgA4tChQ1WOcXZ2FmFhYUIIIWJiYgQA8cYbb1QY5+vrK2JiYiqsj4qKElFRUerlDz74QAAQGzZsUK8rLCwULVq0EADErl27KmyjefPmAoAAIBwcHMRbb70lysvLa/5GiYiIiIzA3dqsssddoaGhwsPDQ9y8eVO97u+//xYWFhZi3Lhx6nVxcXECgBg9erTGPlJSUoRCoRBz587VWH/y5ElhaWmpXn/s2DEBQPzwww8PzGxvb19pDViZXbt2CQCiUaNGIicnR73+f//7nwAgFi9erF4XExMjfH191csbNmwQAMQ777yjsc1hw4YJSZJEUlJSnTIRERkDXnZNRCbNwcGhwl2vn3nmmTpvb8uWLWjUqBEGDRqkXmdjY6M+s7IyCQkJ2LJlCz755BO0bNkShYWFKC8vr3MGIiIiIkO2dOlSbN++XeMBANevX8fx48cxfvx4uLm5qce3bdsWffv2xa+//lphW08//bTG8rp166BSqTBixAjcuHFD/fDy8kJwcLD6ahRnZ2cAwNatW1FQUKDV9zdu3Dg4Ojqql4cNGwZvb+9K89/166+/QqFQ4IUXXtBY/8orr0AIgc2bN2s1IxGRIeFl10Rk0vLy8uDh4aFetrS0ROPGjeu8vdTUVAQGBkKSJI31QUFBVb6mS5cu6v8eNWoUWrZsCQBYsGBBnXMQERERGaqOHTtWesOZ1NRUAEDz5s0rPNeyZUts3bq1wk1l7r9rdmJiIoQQCA4OrnTfVlZW6tdNmzYNCxcuxDfffIOHHnoIgwYNwtixY9WNybq6f9+SJCEoKAgpKSlVviY1NRU+Pj4aTUsA6rrw7s+GiMgUsflIRCbrypUryM7O1mgMKpVKWFhUPOn7/mbiXeXl5VAoFFrL5Orqil69euGbb75h85GIiIioGvfPoahSqSBJEjZv3lxpjebg4KD+7w8++ADjx4/HTz/9hG3btuGFF15AfHw8/vrrr3p9GU1ERLXD5iMRmayvvvoKABAdHV3tWFdX10rvQJ2amoqAgAD1sq+vL06fPg0hhEbDMikpqca5CgsL1XdZJCIiIjIXvr6+AIBz585VeO7s2bNo2LChxlmPlQkMDIQQAv7+/mjWrFm1+2zTpg3atGmDt956C3/++Se6deuGZcuW4Z133gFQ9RfQD5KYmKixLIRAUlIS2rZtW+VrfH19sWPHDuTm5mqc/Xj27Fn183fVJRMRkSHjnI9EZJJ+++03vP322/D398d//vOfascHBgbir7/+QklJiXrdxo0bcfnyZY1x0dHRuHr1Kn7++Wf1uqKiInzxxRcVtpmRkVFhXUpKCnbu3FnppUhEREREpszb2xuhoaFYtWqVxpe+p06dwrZt2/Dwww9Xu40hQ4ZAoVBg9uzZ6rtf3yWEwM2bNwEAOTk5KCsr03i+TZs2sLCwQHFxsXqdvb19pV9AP8jq1as15hT/8ccfcf36dQwYMKDK1zz88MMoLy/Hxx9/rLH+ww8/hCRJGq+tSyYiIkPGMx+JyOht3rwZZ8+eRVlZGdLT0/Hbb79h+/bt8PX1xc8//wwbG5tqtzFp0iT8+OOP6N+/P0aMGIELFy7g66+/RmBgoMa4KVOm4OOPP8bo0aPx4osvwtvbG9988416H/d+U92mTRv07t0boaGhcHV1RWJiIpYvX47S0lK8++672v0hEBERERmB+fPnY8CAAejSpQsmTpyIwsJCLFmyBM7Ozpg1a1a1rw8MDMQ777yD2NhYpKSkYPDgwXB0dERycjLWr1+Pp556Cq+++ip+++03TJ06FcOHD0ezZs1QVlaGr776CgqFAkOHDlVvLzw8HDt27MDChQvh4+MDf39/dOrU6YEZ3NzcEBkZiQkTJiA9PR2LFi1CUFDQA29A+Oijj6Jnz56YPn06UlJS0K5dO2zbtg0//fQTXnrpJY2asy6ZiIgMmox32iYiqpeEhAQBQP2wtrYWXl5eom/fvmLx4sUiJydHY3xMTIywt7evcnsffPCBaNSokVAqlaJbt27i8OHDIioqSkRFRWmMu3jxohg4cKCwtbUV7u7u4pVXXhFr164VAMRff/2lHhcXFyciIiKEq6ursLS0FD4+PmLUqFHixIkTWv05EBERERmCu7XZoUOHHjhux44dolu3bsLW1lY4OTmJRx99VJw+fVpjTFxcnAAgMjMzK93G2rVrRWRkpLC3txf29vaiRYsW4rnnnhPnzp0TQtyp15588kkRGBgobGxshJubm+jZs6fYsWOHxnbOnj0runfvLmxtbQUAERMTU2XuXbt2CQDiu+++E7GxscLDw0PY2tqKgQMHitTUVI2xMTExwtfXV2Ndbm6uePnll4WPj4+wsrISwcHBYv78+UKlUtU5ExGRMZCEuO9cdSIiqrVFixbh5ZdfxpUrV9CoUSO54xARERGRlu3evRs9e/bEDz/8gGHDhskdh4jIaHDORyKiWiosLNRYLioqwmeffYbg4GA2HomIiIiIiIjuwTkfiYhqaciQIWjatClCQ0ORnZ2Nr7/+GmfPnsU333wjdzQiIiIiIiIig8LmIxFRLUVHR+PLL7/EN998g/LycoSEhOD777/HyJEj5Y5GREREREREZFA45yMRERERERERERHpBOd8JCIiIiIiIiIiIp1g85GIiIiIiIiIiIh0gs1HIiIiIjI5Qgjk5OSAMwwRERERycusm4/Xr1/HrFmzcP36dbmjEBEREZEW5ebmwtnZGbm5uXJHISIiIjJrZt98nD17NpuPREREREREREREOmDWzUciIiIiIiIiIiLSHTYfiYiIiIiIiIiISCfYfCQiIiIiIiIiIiKdYPORiIiIiIiIiIiIdILNRyIiIiIiIiIiItIJS7kDEBmasuICXNrzNYqy0uEVFg234I5yRyIiIiIiIiIiMkpsPhL9P6EqByQLXNz2GTJO/AYIgVuJB9B+yqewa9hE7nhEREREREREREaHzUciAFf+/BGpu1fDwtoGVjaOgFDdeUIABTcus/lIRERERERERFQHbD6S2SvKzkDKbwkAgPKifEAI9XNWds5wbtpKrmhEREREREREREaNzUcye6K8XGPZQmGFFqNnoygrHW7NOsPKzlmmZERERERERERExs1o73bt5+cHSZIqPJ577jm5o5GRsXXzhk/HxwAAkoUCAdFT4BoYAe/wgVA6NpA5HRERERERERGR8TLaMx8PHTqE8nvOWDt16hT69u2L4cOHy5iKjFVAv6fQpNtISJZWsFTayR2HiIiIiIiIiMgkGG3z0d3dXWP53XffRWBgIKKiomRKRMbOyp6XVxMRERERERERaZPRNh/vVVJSgq+//hrTpk2DJElVjisuLkZxcbF6OS8vTx/xiIiIiIiIiIiIzJLRzvl4rw0bNiArKwvjx49/4Lj4+Hg4OzurHzxLkoiIiIiIiIiISHdMovm4fPlyDBgwAD4+Pg8cFxsbi+zsbPVjz549ekpIRERERERERERkfoz+suvU1FTs2LED69atq3asUqmEUqlULzs4OOgyGhERERERERERkVkz+jMfExIS4OHhgYEDB8odhYiIiIiIiIiIiO5h1M1HlUqFhIQExMTEwNLS6E/iJCIiIiIiIiIiMilG3bHbsWMHLl26hCeffFLuKGRChFAh/dg25GemomHLSDg3bSV3JCIiIiIiIiIio2TUzcd+/fpBCCF3DDIBqvJSZKecgEJph5xLp5Dy20pAssD1IxsRNmkJ7D385I5IRERERGTebiUDLk0BC4XcSYiIqBaMuvlIpA1CqPDPtzOQnXoSAKB09f7/J1SAAHIun2HzkYiIiIhIbrnXAWsHwMFd7iRERFQLRj3nI5E2FN64om48AkBJzo07/yFZQLJQwKlpiEzJiIiIiIhIQ36m3AmIiKiWeOYjmT0re2dIFpYQqjJAsoCNmw8adx6CgsxUNGzZDfbuvnJHJCIiIiIi4M7Zj548OYCIyJiw+Uhmz8rOGS2HT0fqnm9gaWOPwAHPwq5BY7ljERERERHR/XKuyZ2AiIhqic1HIgBuwR3hFtxR7hhERERERPQg2VfkTkBERLXEOR+JiIiIiIjIOGRdkjsBERHVEpuPZBYiIiLQuHFjREREyB2FiIiIamDv3r149NFH4ePjA0mSsGHDBrkjEZEhuJ0CCCF3CiIiqgU2H8kspKWl4erVq0hLS5M7ChEREdVAfn4+2rVrh6VLl8odhYgMSWkB73hNRGRkOOcjERERERmcAQMGYMCAAXLHICJDdCsZcPCQOwUREdUQm49EREREZPSKi4tRXFysXs7JyZExDRHp1O1koGknuVMQEVEN8bJrIiIiIjJ68fHxcHZ2Vj+aNGkidyQi0pXbqXInICKiWmDzkYiIiIiMXmxsLLKzs9WPy5cvyx2JiHSFd7wmIjIqvOya6D7Zl/7B7QuH4ejTDA2ad5E7DhEREdWAUqmEUqmUOwYR6cPdO15LktxJiIioBth8JLpHzpUzOPnVfwFIgFCh2WOvwqNNT7ljERERERHRXSV5QF464OgldxIiIqoBXnZNdI/slL/v/IdQAZIFbl88Km8gIiIiM5WXl4fjx4/j+PHjAIDk5GQcP34cly7xcksiApB2Su4ERERUQ2w+Ev0/VXkZHBq1+P9LOCwAoYJzkxC5YxEREZmlw4cPIywsDGFhYQCAadOmISwsDDNnzpQ5GREZhMt/yZ2AiIhqiJddEwG4/McapO75GgprGzR5aAxK87Pg6NMMHu36yB2NiIjILPXo0QNCCLljEJGhSv4dKM4FlI5yJyEiomrwzEcye0VZGUjdvRoQKpQXFyD9+FYEPfwcPEP7QuIk1kREREREhqesCDi1Vu4URERUA2w+EolyzUVVeRUDiYiIiIjIYPy9BsjLlDsFERFVg81HMns2rt5o1HkIAEBSWCIw+mmZExERERER0V3Z2dn4448/8Mehv/FHUjayC8vuPFFaAPy+4M6c7UREZLA45yMRAP8+E9Gk2whICisorG3kjkNERERERP/v5MmTeOihh9TLv7/aDpFBzncWLv0F/LMeaD1EpnRERFQdnvlI9P8sbR3ZeCQiIiIiMjb7lwLpp+VOQUREVWDzkeg+V/avxeFPnsLpH95BaUGO3HGIiIiIiOhBVGXAtrc4/yMRkYFi85HoHlkpfyNl5woU3bqKW+cPIHnnCrkjERERERFRdQpuAlv+CxTnyZ2EiIjuw+Yj0T1Kcm7+uyBUKMnht6dEREREREbh5gXg19fYgCQiMjBsPpJZ8PLyQqNGjeDl5VXp88U5N3Bp77coykmH0tnjzkrJAt4RjyI/MxVFWel6TEtERERERHWScRr45UUg/4bcSYiI6P/xbtdkFg4fPlzlc+Wlxfg74RWU5N0ChIBbcEcEPTwVShcvXP79W2Se2g0ACIieAp8Og/SUmIiIiIiI6uRmErD+aSB6LuDeXO40RERmj2c+ktkrun0dJbk3AKECIJCdegKugeGQJEndeASA1N1fyZaRiIiIiIhqIT8T+GkqcPZXuZMQEZk9o24+Xr16FWPHjkWDBg1ga2uLNm3aPPAMN6LK2Lh4wcrOGZAsAEmCU5MQAIDC2haQpDuDJAmWNg4ypiQiIiIiolopLwH2vAfsfg8oLZQ7DRGR2TLay65v376Nbt26oWfPnti8eTPc3d2RmJgIV1dXuaORAYqIiEBaWhq8vLwqNKgV1jZoO34+rh/eBIXSDj6dHkfmP3tQcOMKmkaNxfXDG6GwtkWzQa+g4OYVqMpKYO/hj5xL/+DmuT9h7+kPj7Z9IN1tVBIRERERkeE49yuQ8Q/QOw5oECh3GiIis2O0zcf33nsPTZo0QUJCgnqdv7+/jInIkKWlpeHq1atVPm/r1ghNu4+BpLDE9cObkLJzBSBZwEJhifZTPoGNqzcu//G9+tJr16AOuH3hMAAJECqUFxfCpyPngyQiIiIiMki3U4H1U4COU4DWQwELo74IkIjIqBjtJ+7PP/+MiIgIDB8+HB4eHggLC8MXX3zxwNcUFxcjJydH/cjLy9NTWjJ0yTuW468FI/HXgpFI/3v7nZVCBVVZCbIv/QMhBC79/p16/O2kQ4AQ/z9PJJCdekKO2EREREREVFPlpcD+j4GNLwHZVZ+YQERE2mW0zceLFy/i008/RXBwMLZu3YpnnnkGL7zwAlatWlXla+Lj4+Hs7Kx+REVF6TExGaqi29dx9a91AABRXobi7Iw7T0gWgGQBB+8gSHfnfFTPAalQPw8Azn5t5YhORERERES1df1v4IfxwNGvgLISudMQEZk8o73sWqVSISIiAvPmzQMAhIWF4dSpU1i2bBliYmIqfU1sbCymTZumXj5+/DgbkHSnkfjvAhTWdmgaNRaFN66gQYsuuHboFxRkJMO9dQ/cTjoMVVkJ/PtMgpW9C26e2w8HzwC4t+kpW3wiIiIiIqql8hLg0JfA+S1A52cB367/nmhARERaZbTNR29vb4SEhGisa9myJdauXVvla5RKJZRKpXrZwYF3LybAxsUDvj2eQOqeb6CwUiL40ZfgGhgOAEje/gXSj28DhAq5V8+h9X/mwcW/nfq1zk1byRWbiIiIiIjqK/sKsPVNoFE40PkZoGGw3ImIiEyO0TYfu3XrhnPnzmmsO3/+PHx9fWVKRMasSeQoNOoyDJKFBTJO7sL+94YCkgRbNx/1vI7AnUu0cU/zkYiIiIiITMDVI8DaSUBwXyBiIuDkLXciIiKTYbRzPr788sv466+/MG/ePCQlJeHbb7/F559/jueee07uaGSkLBSWUJWVImnjYqjKiqEqLUJB5iUAdy6/sLRzgmtwB3lDEhERERGR7iRuB9aMBf5cAhRly52GiMgkGO2Zjx06dMD69esRGxuLOXPmwN/fH4sWLcJ//vMfuaORESovLcKt8wchKRQQ95zpCAi0e3Ihim6nwdmvLaztXeSKSERERERE+qAqA07+CJzbAoSNBVoPBSyt5U5FRGS0jLb5CACPPPIIHnnkEbljkJETqnKcXP1f5F1PAgA4NglB7uXTAAC/3k/C0acZHH2ayRmRiIiIiIj0rSQPOLAMOLsR6PoC0LST3ImIiIySUTcfibSh4MZldeMRAArSk9Fp2neAJMHK1lHGZEREREREJLvsK8Dm1+/MB9llKmDrInciIiKjorc5Hy9duoSnn34azZs3h5ubG/bu3QsAuHHjBl544QUcO3ZMX1GINFg7NoCFpTUACZAsYNugMazsnNh4JCIiIiKifyVuB358ErjGv12JiGpDL83H06dPIywsDGvWrIG/vz+ys7NRVlYGAGjYsCH++OMPfPzxx/qIQlSBla0jWo2eAxf/UDRo0RUthr4pdyQiIiIiIjJEBTeBjdOAEz8AQsidhojIKOjlsuvXX38dLi4u+OuvvyBJEjw8PDSeHzhwINasWaOPKESVcvZtA2ffNnLHICIiIiIiQydUwP6PgexLQLeXAQu9XVBIRGSU9PIpuXfvXjzzzDNwd3eHJEkVnm/atCmuXr2qjyhERERERERE9Xf6Z2DbW0BpkdxJiIgMml6ajyqVCnZ2dlU+n5mZCaVSqY8oRLWiKi9D5j97kXHyN5SXFssdh4iIiIiIDEnqPuCXF4H8m3InISIyWHppPrZv3x6bNm2q9LmysjJ8//33OH13ygAAvv1JREFU6Ny5sz6iENXKuQ3v49z693D+pw/wz3czITivCxERERER3SvzLLBuMpB2Su4kREQGSS/Nx9jYWGzZsgXPPPMMTp2684Gcnp6OHTt2oF+/fjhz5gzeeOMNfUQhqjFVeRluntmnXs65dAql+bdlTEREREREZH7uPwHAIE8IKLgJ/PIC8Pf3gEoldxoiIoOil+bjgAEDsHLlSqxZswa9evUCAIwdOxb9+vXD0aNHsXr1anTv3l0fUYhqTLJQwMbVG5AsAMkClnZOsLR1lDsWEREREZFZyMrKwuLFizFq1CiN9aOWn8XinVeRVVAmU7IqqMqBvz4FtrwBFNySOw0RkcGQhB6/NsrPz8f27duRmJgIlUqFwMBAREdHw9FRnobO0aNHER4ejiNHjqB9+/ayZCD9iIiIQFpaGry8vHD48OEHji0rykPiL4uRl5YE18AIlBXlQajK0fSh0bD39NdTYiIiIqqPnJwcODs7Izs7G05OTnLHIaJa2rp1K4YOHYqCgoJKz3SUANgpLbD2qRBEt3LTf8Dq2DUA+swCvNvKnYSISHZ6bT4aGjYf6a5biQeRuudrWNo4wNqxATJP7QbEncslWgybjoYtusobkIiIiGqFzUci47V161YMHDgQQgioHnAJs4UESBKw6bnWhtmAlCyAqNeB5gPkTkJEJCu9XHYdEBCALl264Ny5c5U+/9NPPyEgIEAfUYgqKM3Pxpkf5iI/7QKyU0/i1vm/APzbky/J4yUTRERERET6kJWVhaFDh1bbeAQAlQCEAIZ+ftrwLsEG7pzMsPtd/B979x0eRbm3cfye3fReCDWQkNB7E6RIaAKKIipFEASx4DliQz2CiBQVsKHY0aOgHrEhoiIaG6BioYkCClIEaaGnh5DszvsHsq8xJCQhm9lNvp/r2ktm5pnZO+MSJr88Rb9+aHUSALBUhRQfd+3apfXr16tjx45asmRJoeOZmZnavXt3RUQBCsnLTpPp/OthxXTKdDpk2OySJL/QaFVr2s3CdAAAAEDV8eqrryo7O/ushcfTnKaUnevUaz8cdHOyc7DqSenw71anAADLVEjxUZLmzJmj7t2768orr9SUKVMq6m2BswqsFqvwuP+fiyW282B1uPlltbh6ptrd9IL8giOsCwcAAABUEaZp6umnny7TuU8t3+eZq2BLpxai+Xmh1SkAwDI+FfVGkZGR+uijjzRjxgzNmDFD69ev18KFCxUeHl5REYAzMgybmo+YobRdG+UTEKTQOk0kSf5h1SxOBgAAAFQdR48e1Y4dO0p9nilpx+ETOpaVr+gQ3/IPVh6Obrc6AQBYpsJ6Pp52//33a+nSpfrxxx913nnnafPmzRUdASjEZvdVZGI7V+ERAAAAQMXKzMw8p/MzTjjKKYkbBHrggjgAUEEqvPgoSf3799eaNWsUHBys888/Xx988IEVMQAAAAAAHiIkJOSczg8NsJdTEjeIv8DqBABgGUuKj5JUv359ff/997riiiu0aNEiq2IAAAAAADxAdHS0EhMTZRhGqc4zJCXGBCgquMJmFSsd/1CpcX+rUwCAZSrku/Py5cvVtGnTQvsDAgL06quvaujQoTpy5EhFRAHO6MiW7/Tnyv/JHhCsBhePV3BMnNWRAAAAgCrFMAzdcsstuuOOO0p97q0965S6aFlh2lx9qgAJAFWUYXrskmDut379erVv317r1q1Tu3btrI4Di5zMStWaudfIdDokw6ag6Fi1u+l5q2MBAIBzkJ6ervDwcKWlpSksLMzqOABKKDU1VbGxscrJyZHT6Txre5shBfrZtHfW+YoI8sCej+Gx0uD5ko+f1UkAwDJu+e782muvSZJGjRolwzBc28UxDEOjRo1yRxygWPnZ6acKj5JkOpWbcdTaQAAAAEAVFRERoffee08DBgyQzWYrtgBpMyTDkBaPa+aZhUdJ6nobhUcAVZ5bej7abDYZhqGcnBz5+fnJZjv71JKGYcjhqNjVyej5CEkyTac2L7xfqX/8JEmK6zFKdbtdZXEqAABwLuj5CHi35ORkXXnllcrOztaZfmQ1JAX527R4XDP1beahK0k37Cv1mmx1CgCwnFt+PfTHH39Ikvz8/ApsA57IMGxqPny60v7cLB//IIXUamB1JAAAAKBK69evn/bu3avXXntNDz/8sPbv3+86VjvCT/f0ravRnWsoPNBDezyGVJe63mp1CgDwCG75Th0XF1fsNuBpDJtdEfGtrI4BAAAA4C8RERG69dZb1bZtW3Xv3t21/63rmuiChhHWBTsbu5904QMsMgMAf7Hk10QnT57Ujz/+qAMHDqhx48Zq3bq1FTEAAAAAAB7un6tYe+yq1pJk2E4Nta7exOokAOAxzj4ZYxklJydr7NixOnLkSIH9W7ZsUYsWLdSjRw8NHz5c7dq10+DBg5Wfn++uKAAAAAAAuJfdV+p1n5TQw+okAOBR3FZ8fOWVV/Tzzz+rWrVqBfZfffXV2r59u6655ho99dRT6t+/v95//309/fTT7ooCAAAAAID7BMdIA+ZIDXpbnQQAPI7bio9r165Vnz59Cuz76aef9NNPP+nqq6/W/PnzdfPNN+vjjz9Wt27d9MYbb5Tq+tOmTZNhGAVeTZrQtR0AAAAAUIEa9ZMGvyLVYg55ADgTt835mJKSogYNCq4a/Omnn8owDI0ZM6bA/kGDBun+++8v9Xs0b95cX3zxhWvbx8dDVzoDAAAAAFQuMU2kLuOlmi2tTgIAHs1t1bqQkBBlZ2cX2Pftt9/KZrOpU6dOBfZHRETI4XCU+j18fHxUs2bNc8oJAAAAAECJhcdKHW+Q6idJnrz4DQB4CLcNu27atKk++OAD1/bx48f19ddfq0uXLgoJCSnQds+ePWUqIm7btk21a9dWQkKCrr76av3555/Fts/NzVV6errrlZmZWer3BAAAAABUQaE1paR7pKGvnVpUhsIjAJSI23o+3nnnnbrssst00UUXqUuXLvroo4+UnZ2tf//734Xafvrpp2rbtm2prt+pUyctWLBAjRs31oEDBzR9+nRdcMEF2rRpk0JDQ894zqxZszR9+vQyfT0AAAAAgCrIP1RqN1pqdpnk42d1GgDwOm7r+XjppZfqkUce0ffff6+pU6dq8+bNmjJlioYNG1ag3Q8//KAffvhBAwYMKNX1L7roIg0ZMkStWrVSv379tGzZMqWmpuqdd94p8pxJkyYpLS3N9Vq5cmWZvjYAAAAAQBXQ9FLpqoVSqyEUHgGgjNy6Qstdd92lO+64Q0eOHFH16tVlnKFbeuvWrXX48GFFRESc03tFRESoUaNG2r59e5Ft/P395e/v79r+5/BvAAAAAAAUWkvqOUmq1drqJADg9dzW8/E0u92uGjVqnLHwKEmBgYGKjo6W3W4/p/fJzMzUjh07VKtWrXO6DgAAAACgCkvsKV35XwqPAFBO3Nrz0Z3uuusuXXrppYqLi9P+/fs1depU2e12DR8+3OpoAAAAAABvY9ikTjdJrYaymAwAlCOvLT7u3btXw4cP19GjRxUTE6Nu3brphx9+UExMjNXRAAAAAADeJCBc6jNVqtPe6iQAUOl4bfHxrbfesjoCAAAAAMDb1Wot9ZoihdCRBQDcwWuLjwAAAAAAlJndT+p4o9TiSsnm9uUQAKDKcvt32BMnTuipp57S119/7e63AgAAAADg7Op2kobMl1oNofAIAG7m9u+yAQEBuueee7R161Z3vxUAAAAAAEULrSX1fUC66GEpPNbqNABQJVTIsOsWLVpo165dFfFWAAAAAAAU5OMvtR0ltRom+fhZnQYAqpQK6V/+0EMPad68efriiy8q4u0AAAAAADilfndp6OtSu1EUHgHAAhXS8/GZZ55RVFSU+vXrp/r166t+/foKDAws0MYwDH3wwQcVEQcAAAAAUNkFRUndJkj1L7A6CQBUaRVSfPzll19kGIbq1asnh8Oh7du3F2pjGEZFRAEAAAAAVHZxXaWk/0iBEVYnAYAqr0KKj8z3CAAAAACoEOddL7UdKdHBBQA8QoUUHwEAAAAAcCvDJvWYJDXqa3USAMDfVGjxceXKlfr444+1e/duSVJcXJwGDBigpKSkiowBAAAAAKhsKDwCgEeqkOLjyZMnNXz4cC1ZskSmaSoiIkKSlJqaqscff1yXX3653nzzTfn6+lZEHAAAAABAZdJ2JIVHAPBQtop4k+nTp+v999/XnXfeqQMHDujYsWM6duyYUlJSdNddd2nx4sWaMWNGRUQBAAAAAHiRli1b6ptvvtE37z6nb+5qrZZ1ggs2iGkidRhrTTgAwFkZpmma7n6T+vXrq0ePHpo/f/4Zj48ZM0YrVqyo8IVp1q9fr/bt22vdunVq165dhb43AAAA3Cc9PV3h4eFKS0tTWFiY1XEAlIfd30mfTiq8//IXpOpNKz4PAKBEKqTn44EDB9SpU6cij3fq1EkpKSkVEQUAAAAAUFnU60zhEQA8XIUUH2NjY7VixYoij69cuVKxsbEVEQUAAAAAUFm0Gmp1AgDAWVRI8XH06NF65513dNNNN2nr1q1yOBxyOp3aunWr/vWvf+ndd9/VmDFjKiIKAAAAAKAyiIyXare1OgUA4CwqZLXre++9Vzt27NCLL76ol156STbbqZqn0+mUaZoaPXq07r333oqIAgAAAACoDJpeKhmG1SkAAGdRIcVHu92uBQsWaMKECVq2bJl2794tSYqLi9PFF1+sVq1aVUQMAAAAeJFnn31Wjz76qFJSUtS6dWs9/fTT6tixo9WxAHgCu5/UsK/VKQAAJVAhxcfTWrVqRaERAAAAZ/X2229rwoQJeuGFF9SpUyc9+eST6tevn7Zu3arq1atbHQ+A1ep3lwJYyR4AvEGFFh+lU0Ot09LSZJpmoWNRUVEVHQcAAAAeaM6cObrhhht07bXXSpJeeOEFffzxx3rllVc0ceLEQu1zc3OVm5vr2k5PT5ckbdiwQSEhIRUTGoB7Hdgq/Zlx6s9146T1663NA6BSateundURKp0KKT7m5eXp4Ycf1iuvvKI9e/bI6XSesZ3D4aiIOAAAAPBgJ0+e1Lp16zRp0iTXPpvNpj59+uj7778/4zmzZs3S9OnTC+1PSkpyW04AVhptdQAAldSZOsvh3FRI8XHcuHF69dVXdf7552vQoEEKDw+viLcFAACAFzpy5IgcDodq1KhRYH+NGjW0ZcuWM54zadIkTZgwwbWdnp6uunXrauXKlfR8BCqLAz9L3z0txXWTOoyxOg0AoIQqpPj47rvvatSoUVqwYEFFvB0AAACqGH9/f/n7+xfa36ZNG4WFMS8cUCnsPiHtDZV6D5ISGRYJAN7CVhFvEhQUpPPPP78i3goAAABerlq1arLb7Tp48GCB/QcPHlTNmjUtSgXAY9RqY3UCAEApVEjxcfjw4Vq6dGlFvBUAAAC8nJ+fn9q3b68vv/zStc/pdOrLL79U586dLUwGwHIhNaQgFioFAG9SIcOuH3nkEY0dO1aXXHKJxo4dq7p168putxdqx4pCAAAAkKQJEyZo9OjR6tChgzp27Kgnn3xSWVlZrtWvAVRR0YlWJwAAlFKFFB9zc3PldDr1ySef6JNPPil03DRNGYbBatcAAACQJA0bNkyHDx/W/fffr5SUFLVp00affvppoUVoAFQx4XWtTgAAKKUKKT6OHTtW77//vq666ip16tSJ1a4BAABwVuPHj9f48eOtjgHAk4Qy7ysAeJsKKT4mJyfrlltu0RNPPOG295g9e7YmTZqk2267TU8++aTb3gcAAAAAYJHgalYnAACUUoUsOBMWFqYGDRq47fpr1qzRvHnz1KpVK7e9BwAAAADAYkHRVicAAJRShRQfb7jhBr355ptumdMxMzNTV199tV566SVFRkaW+/UBAAAAAB4ikJWuAcDbVMiw62bNmumDDz5Qu3btNHr06CJXu77iiitKfe2bb75ZAwYMUJ8+ffTggw8W2zY3N1e5ubmu7czMzFK/HwAAAADAIoERVicAAJRShRQfhw0b5vrzXXfddcY2ZVnt+q233tL69eu1Zs2aErWfNWuWpk+fXqr3AAAAAAB4ALu/5BtodQoAQClVSPFx+fLl5X7NPXv26LbbbtPnn3+ugICAEp0zadIkTZgwwbW9YcMGJSUllXs2AAAAAEA58w+xOgEAoAwqpPjojgLfunXrdOjQIbVr1861z+Fw6Ouvv9Yzzzyj3NzcQkO7/f395e/v79oOCfGef7yWfb9RC79Yo6jQIP1nRD/FVmd+SwAAAABViG+Q1QkAAGVQIcVHd+jdu7c2btxYYN+1116rJk2a6J577jnjnJLeau/h43rinS8lSYePZ+iRhcl66varLE4FwFOYToeO/v6DZJqKatRJNruv1ZEAAADKn4//2dsAADxOhRQfe/XqddY2hmHoyy+/LPE1Q0ND1aJFiwL7goODFR0dXWi/t0vLzHH92WmaOpaRbWEaAJ5my+LZOrrlO0lSZIPz1PyqadYGAgAAcAd+wQoAXslWEW/idDplmmaBV35+vnbs2KEVK1Zo7969cjqdFRHFKzWpV1MtE+q4tkdc2NHCNAA8iSPvhKvwKEnHt69Rfk6GhYkAAADcJJCppwDAG1VIz8cVK1YUeWzp0qW68cYbNWfOHLe+jzez22169N9XasufKYoICVKdmAirIwHwEDYfP/mFRutk5nFJkm9gqOz+zIcEAAAAAPAMFdLzsTiXXHKJRo4cqdtvv93qKB7NYTp1Mt+hk/n5VkcB4EEMw6YWIx5UVMOOimp4nlpc/ZAMW+WZ8xYAAAAA4N08YsGZxMREPfPMM1bH8Fj5DofuemaRftudIkm65cqeGtittcWpgJI7cCRN765YJ1+7XVf16aDI0GCrI1UqQTH11GzoFKtjAAAAAABQiOXFx/z8fL3zzjuqVq2a1VE81pbdB12FR0l656u1FB/hNfIdDk145l0dy8iSTGnjzn167s4RVseqVPKy0rRv9RLJNFW740D5hURZHQkAAAAAAEluLD5+/fXXatq0qWJiYjR27NgztklNTdUPP/yglJSUcpnzsbKKCguSYUimKdkMQzERoVZHAkrseEa2jqRlura37z0kh9Mpu83yWR8qBdM0tWnhZGUd2i1JOrr1e7W76XkZBvcXAAAAAGA9txUfe/bsqf/9738aPny4vvrqKxmGUeC4YRiKjIxUt27ddP3116tv377uiuL1aleL0N3D++nNL1YrOjxYE4ZeaHUkoMSiwoJVv1a0dqUclWlK7RrXo/BYjpx5uco6+IdrO+foXuXnZMo3KMzCVAAAAAAAnOK24qNpmjJNU5K0a9cud71NlXHheU114XlNrY4BlJrdZtPj44fo0x83y9duV//zm1sdqVKx+forpHYjZR7YJkkKiomTTyC9owGgKnA6Te08kqUG1UOsjgIAAFAky+d8BFD5hQYFaEjP9lbHqJQMw1CL4TN0YN3HMk1TtdoPKNTTHABQOZmSth/KpPgIAAA8mluLj/wADADu5xMYqrrdrrI6BgDAAkcyc62OAAAAUCy3Trw2cuRI2e32Er18fOiECQAAAJTGofQTVkcAAAAollsrfn369FGjRo3c+RYAAABAlZVC8REAAHg4txYfR48erREjRrjzLQAAAIAqa19qjtURAAAAisVYZwAea+f+w/r2l+2KqxGt7m0aMo9sEZz5eTq8eaVkmqrWvLvsvv5WRwIAVJD0nHyln8hTWICv1VEAAADOiOIjAI+09/BxjX/iLTkcTjlNU/9K764rktpZHcsj/fruA0rdsU6SdGjjl2oxchaFWgCoQv48mq0WdcKtjgEAAHBGFB8BWCp59WYt+36T6laP1BXd22rOO18o5Wi6mtWvpbx8h6vdj7/uovh4Bo68E67CoySl7d6o/BOZ8g0MtTAVAKAi/XmM4iMAAPBcbis+Op1Od10agBfbvu+QZr72iY5nZOvC85rq/a83SJK27E7Ruq1/6lhGlpxOU99v2inDkAzDkNNpqnn9WtYG91A2H3/5R9RQbtphSZJfSKR8/IMsTgUAqEh/Hsu2OgIAAECR6PkIoEI9/ubn2nc4VU7TdBUeJclpmsrKyZXTabr2XdO/sw4dz1BcjSgN6t6m4sN6AcMw1GLEQ9rzzZsyTafqXTBchs1udSwAQAXafZTiIwAA8FwUHwGcsw4dOiglJUU1a9bU2rVrCx3fdeCo3vpyjXzsNqVl5chp/n+BMTw4UGlZp1bqvKhzC33wzc9yOJ1qUq+mhvZsLz9fvk2dTWBULTW6bILVMQAAFtl7nOIjAADwXPxUD+CcpaSkaN++fWc8lpfv0N3PLVJ61gnJkKJCgmQzDDlNU52bJ2jCsD7asH2PakVHqHG9GhrWq4OOpmUpoXY12e22Cv5KAADwPqnZeco4kadQVrwGAAAeiOKjhzhbz7G/W7nhdz3xzpeSaeq2Ib3Vs13jCkoJlF5aZo5SM0/1bJQpHU3P0htTr1P2iZOqVyNKhmGoR9v//wxHhQUrKizYorQAAHinPcdy1Kw2xUcAAOB56FbkIU73HEtJSSm2Xb7DoUfeSFZWTq6yTpzUowuTdTIvv4JSAqUXFRasJvVqura7tmqgmIhQxdWMlmEYFibzHh06dFBsbKw6dOhgdRQAgIfaeSTT6ggAAABnRM9HL7F93yEtXbVRYUEBynP8/0ri+U6nHH9boAPwNDaboUf+fYWW//S7fO02ndckXrsPHlNsTITsNn7/URLFDWsHAECSfjuQrkta1bY6BgAAQCEUH71Aama2Jjz9rnLz8mWaUv1a0dq5/4gkafRFXRTozxAbeLZAfz9dfH4Lbdq5X6MefEUnTuarUd0aenz8YAX48fkFAOBcrd+dqjyHU77MlwwAADwMxUcvsDvlmHJy81zb6Vkn9M6MG2SaYm48eJU3v1it3L+mCfh9z0F9t2mHerVrYnEqAAC8X2Zuvlb/cUxdG1SzOgoAAEAB/GrUCyTWqabwkEDZ/pofr3PzBEWGsigHvE+Qv58MGQW2AQBA+Xhn7R45mY4HAAB4GHo+eoGQwAA9e8dwfbH2N0WGBqlfx+ZWRwJK7cCRNA3q3kZ7j6Rqz8Fj6t+puTo2rW91LAAAKo2dh7P05ZZDurBZDaujAAAAuFB89BI1osJ0dd9OVscAyuS591fo/a83SJJuuLSbhvZi1WYAAMoqLS1NGzdulMNp6tiOjQqtnSDfwBBJ0svf7lTbehGqFuJvcUoAAIBTGHbtJU7m52v91j+1c/9hq6MApZKame0qPErS/GXfMSQMAIBzsHHjRl1wwQXqkdRd3829WRn7d7qOZeU69Phnv/NvLQAA8Bj0fPQCefkO3fn0u9ry50FJ0vgre+qybq0LtTueka3Nf+xXfK1oxcZEVnRM4Ix8feyy22xyOJ0yJAX4+cowznoaAAAoo0370vT6D7s1uku81VEAAAC8t+fj888/r1atWiksLExhYWHq3LmzPvnkE6tjucXWP1NchUdJeverta4/pxxL0x/7j+jgsTRdN/s1TZ+/VNfPfk3rf//TiqhAIcEB/vrP1X0VHhKo6PBgTb7mYhlUHwEAcKtF6/bq698ZMQMAAKzntT0fY2NjNXv2bDVs2FCmaerVV1/VZZddpp9++knNm1euBVmiwoJlGJJpSjbDUExkqCTpg29/1jPvLZckJdaJUWb2CUmS05Q++WGT2jWqZ1lm4O96tWuiXu2alPq8jOwTWrd1t6pHhqlZfC03JMPfOfNPyrD7yDBsOpl5XLnpRxRcI17Htv6gP795U75B4WowYLwCo+pYHRUAUAJPfPG7IoP81DI23OooAACgCvPa4uOll15aYPuhhx7S888/rx9++KHSFR9rV4vQPVf315ufr1ZUeIjuGNpbkrRg2XeuNjv2FfzNds2osArNiKqtZs2aBf5bHrJycvWvx97QweMZkqTbhvTSJV1aldv1K7OTWanKPrRLwTUS5Bt05u8FpunU4U0rdDLzuKo1u0B/fr1Qh37+XL7BEap3wXDt/PwlmY58BVarq5yje0/99sOwaev7j6rNdU9W7BcEACiTfIepGUs3a+qlzdWiDgVIAABgDa8tPv6dw+HQu+++q6ysLHXu3LnIdrm5ucrNzXVtZ2ZmVkS8ctG7fRP1bt9EB4+l6+2/hl0H+fsp68RJmeapCcWH9eqgNVt2qXG9GqyMjQq1du3aszcqoewTJ7XvcKr2HUl1FR4laemqjRQfSyDr0C79suAuOU7myCcgRK3HzinQU9F0OiTDpj++eFn7f1wiydCeVW/LcSJLkpSXnaZdy1+T6XBIknKO7NHfTlZuOkP4AMCbnMhz6v4PNuk//Zvo/IRoq+MAAIAqyKuLjxs3blTnzp114sQJhYSE6P3331ezZs2KbD9r1ixNnz69AhOWL6fT1N3PvaeDx9MlU4oOC1adauHKOnFS113SVf06Ntf1l3azOiZQageOpslmGMpzOHT73HeUlpWjsKAA13GbYSi2eoR1AT3ckd9WafvHT8k0nQqt00SOvFO/ZMnPzdbBn79QfM/RMk1TO5Pn6cC6pfIN+nvvF9NVeDzNsNnkmutBUlBMnLIP75Yk1el8ZYV8TQCA8pPnMDVz2W8a3TleV7Srw9zLAACgQnl18bFx48basGGD0tLStGjRIo0ePVorV64ssgA5adIkTZgwwbW9YcMGJSUlVVTcYpVk2GrWiVwdOJrm2j6clqkPZ/9bgf5+bs8HlKfjGdnalXJUibVj9O7ytXrry1M9J5vF11JGzqm5SzNzctW1RaJSs3JUKzpM/xrkGX9XrVDc9wfT6dDvHzwmZ/5JSVLqHxtcRUOZTvmFnurlkrH3Nx1Y+5GkU70bfQJCJOPUmmOGza7IhHY6tu1H2f2C1OCS27Tv+8XKObZXtdpepNgLrlLGnl/lExiqkJqJbv5qAQDuYJrSgu92aduhTN3au4GC/Lz6xwAAAOBFvPqpw8/PTw0aNJAktW/fXmvWrNHcuXM1b968M7b39/eXv7+/azskJKRCcpZESYathgT6q1l8Lf2264BMSS0SaivAz7fE75HvcGjdlj/l7+ej1g1i+a03KkxO7kl9tW6rfHxsql+rmu56dpFycvMUEuinzJyTrna/7Tog/fWxNE1TLRLraHCPdhal9hzFfX8wnU45Hfl/36GYFj2UvudXRTbooJpt+8uZnyenI+9vbSS/0BjVbNtPJzOPq1b7ixVap4nyczJk8wuUze6jao0LTmERUb9NOX9VAAArrNp+RH8cydQ9/ZsoIcZznoUBAEDl5dXFx39yOp0F5nSsTNKzTmjVxu26ontbHW3TSDbDUL9OzYstIB5OzdD9//1Qfxw4qqQ2DZWama31v5+av23QBW108xU9Kig9KrsOHTooJSVFNWvWLFQoOz1dwNY/D0o6tRhSbt6pYllWzknZbIaczlM99fx8fdS+cT39smOf2jeup4FdmePxbGw+vorvOVq7vpovSaqXNFL1Lhgu6VQB94/PX9L+1R/I7h+s8LhWStv9i2y+/kroe70i4lsXuJZPYGiF5wcAVLz9qSd017s/a2y3+hrQsha/kAYAAG7ltcXHSZMm6aKLLlK9evWUkZGhhQsXasWKFUpOTrY6WrnLyc3TzXMWKuVYuiRpxIUdde3FXc563quffK+d+4/IaZr6av3WAsc+WvULxUeUm5SUFO3bt++Mx46lZ7kKj5KUcixdp3/GMSX179hcP2zeKZth6I6hfdSpef0KSFy5xHYZrOqteksy5Rscof1rlyrr4E4FV0/Q/tUfSJIcudnKy05TxzvekN0vUHZf/+IvCgCo1PIcpuat3Km1u47rtt4NFRnMND4AAMA9vLb4eOjQIV1zzTU6cOCAwsPD1apVKyUnJ+vCCy+0Olq527b3oKvwKEmfrf61QPHxlx17tWHbHrWoX0e+PnY99tZnyj2Zr+qRBXsx+dhtcjidMmSoRhQ9nFAxwkMCFRESqPSsU3M5xlaPUOO6NfXzjr3q2DReN1/RQxOG9bE4pffzC4mUJO39/j3t+vKVU/M5ms4CbUynU37BERakAwB4qnW7j+vfb6zXjUkJ6tEohl6QAACg3Hlt8fHll1+2OkK5Km7Yau3oiAKFw8Q6Ma5jG7bt0d3PvSebYchpmgoJ9FfWiVyZpnQ8I0uB/qe2G9SJ0ZiLu+itL9bI39dH/6LXIyqIr49dj40fore+WCMfu02j+p1fqDCO4hX3/UGSMvb/rp2fvySZpoy/FpE5XXgMrdNEGfu2nBpq3W9cRcYGAHiJzNx8zfnsdy3fckg3JSWqdkSg1ZEAAEAl4rXFx8qmuGGr1SJCNHPc5Vq88idFhwVp7ICu2p1yVCnH0vXT73+6Co82m6HsEyddC906TenpO66S3WaoRlSY7DabOjVjSCsqXlyNKN1zdT+dOJknf1++7ZRWcd8fTNOpzW9NVX5OhmRKhs9fi1AZNhmGoQYDbpF/WDXZfPxl8yn5AlUAgKrnpz9TdfPC9bqsdW0NPa8uK2IDAIBywROFl2jbsK6axtWUr92ulT//rlmvfypJigwNchUenU5TPdo20oqffpck9evYTHWrR1oZG5Ak5eU79MCCj/X95p2qHhmq2TddrrrVo6yOVSk48/OUn/3/0zKY+SfVcOAEnTi2X1GNzldw9XjrwgHwWg6HQ++++66WL1+uQ4cOacaMGWrZsqXS0tL05ZdfqmvXrqpRo4bVMeEG+Q5T763fpy+3HNLwjvXUt1kN+dhtVscCAABejOKjFzBNU8+/v1Lvf7NBQQF+ig4Ldh07npGtK7q3VXbuSbVMqKMLz2uqsRd3VW5evuJqUtyBZ/j2l+36fvNOSdKR1Ey9+skPum/0xRanqhzsvv6q0aavDm74TJIU07yHarTqbXEqAN4sNTVV/fv31+rVqxUSEqKsrCzdcsstkqSQkBDdeuutuuaaazRz5kyLk8KdUrPz9PyKHfpgwz6N7hyvzonRzAcJAADKhOKjF9ix77De/2aDJCkn96SOppmuodaS1Kt9YzWuV9PVvla1cCtiAkUyT88F8BfnP7ZxbhoMuEUxLXpKpqnw+JYynQ7JMGQYNh3fsV5pu39WWL2W8g0K0/aPn5YzP0/1+4xVVMOOVkcH4IEmTpyozZs3Kzk5WW3btlX16tVdx+x2uwYPHqxly5ZRfKwi9qee0KxPtqhRjVBd2zVeLerwnAkAAEqH4qMXKFCnMaWI0CDVr1VNew8d12UXtC5QeAQ8UbfWDdRudT2t//1PRYQEanT/88/YLic3TzNfW6YN2/eoTYO6uveaixXozzyFZ2MYNkXEt5IkHVj3iXZ+9oIMw67aHQdq73fvnlr5+rtF8gkMVf6JTMmUfls0U50mLJSPf5DF6QF4miVLluiWW27RhRdeqKNHjxY63qhRIy1YsKDig8FSvx/M0KTFG9WpfpTGdqvPojQAAKDEKD56gQaxMbq0ayt9tOoXBfj76rYhvdWuUT2rYwEl5ufjo9k3Xa6M7FwFB/jJ/re5o37atkdPL/pKktQ8vrZ+/G2XTNPUj7/t0pJvftLwPvTOK6n83Gzt+PQ5yXTKVL72fr/4VOHRdEoy/io8nvpthunIkyM3m+IjgELS0tJUv37RC9Tl5eUpPz+/AhPBk/z4xzGt+/O4Lm9bR0M71FWAr93qSAAAwMNRfPQChmHo1sG9dP0l3eTna5ePnYc8eJeft+/Vy0u/la+PXeMGdtfna3/Tmi271KZhXS1ft1U5J09KpnTgaJoMSaYkQ1L2iZMWJ/cepuk8NdzadP7/TsOUnE5XATK6cRcd3fKdJKlas+7yC422KC0AT5aYmKj169cXefyzzz5Ts2bNKjARPE2+w9S7a/fqm21HdGuvhmoZy1BsAABQNIqPXiQowM/qCECp5Z7M15T/fqATJ/NkyNB/XnhPWTmnior7DqcWaJvvcCoyNEjHM7IVERqkS7q0siCx9zm0aYW2L31KpkxFN+mqo1tWSYZNif3+Ld/gMKX98bPC4loqptkFykzZIWd+nkLrNGLhAABndP311+uee+5Rjx491Lv3qQWsDMNQbm6uZsyYoU8//VQvvviixSnhCVLSTmjyko0a0j5WIzrFyW7j3xUAAFAYxUcvk5fv0PNLVurn7XvVsWm8rr+0m+w229lPBCySmZOrnNw8SZIpU1k5J10LJtlshhJqVdP2fYclSQO7ttaNAy/QgaNpqhUdLn8/vkWdjdORr20fPSnTceoeH/v9B51322uy+wW6hlRXa9LV1T6kZqIlOQF4j9tuu02bN2/W8OHDFRERIUkaMWKEjh49qvz8fI0bN07XXXedtSHhMUxTemftXm09mKF7+jdRaABzNQMAgIL4yd7LLPlmg5au+kWmpD8PHlOdmAh6h8GjRYUFqXOLBH2/aackqWfbxvrh153Kyc2Tn4+P7h7eV06Zkikl1omRYRiKr8Vw4JIzCwy1Nk2nfPyDZPdjIQAAZWMYhl566SWNHj1aixYt0rZt2+R0OpWYmKihQ4eqe/fuVkeEB/p5T5r+s+gXTRvYXDXCAqyOAwAAPAjFRy9z6HiGDJsh02nKZhg6dDzD6kiAatasWeC/f2cYhqaOuUQbtu+Rj92uVol1dDwjW9v3HVJi7eqKDg+u6LiVis3uq/p9rtfOz1+UTFPxva6l8AigXHTr1k3dunWzOga8yN7jObrr3Z819dLmalA9xOo4AADAQ1B89BJ5+Q79uuuAWibW0Sc/bFKuM1/+fj7q3aGp1dEArV27ttjjdrtN7RvHubajwoLVMazolVRROrU7DlT1Vr0k05RPYKjVcQB4uT/++EObNm3SpZdeesbjH330kVq2bKn4+PiKDQavkJqdp0mLf9FdfRurUwIjGQAAAMVHr5DvcOiuZxfp110HJEnXXtxFibVj1LBudUWFBWvv4eM6cTJPibVjWEACqKJ8AkJkmk4d3fq9HLk5im7SWYc2LtfBDZ8pqHq8Evre6JoDEgCKc9dddyk9Pb3I4uOzzz6riIgIvfXWWxWcDN7iRJ5TD378m0Z0qqdhHerKxkI0AABUaRQfvcCW3QddhUdJWvb9Rv3v/lMTvb+7fJ1e/PAbSVKPto1076iLKEDC42z+Y7/mL/tOPna7brqsO3M6llJxw9r/bmfyPB1Yu1SSFPBNLZ04fur7RmbKDtl9/JR40b/dGxRApfD999/r9ttvL/J479699eSTT1ZYHhRmmmax255i4Y9/6tf96bqzbyNFBPlZHQcAAFiEZZI9RM2aNVWnTp0zFhciQ/+/t5LNMFQt/P/n0Hk9+QfXn1f89LsOHE1zb1CglHJP5uveF5folx179dPvf+q+l5ZYHcnrrF27Vnv37j3r8PaDP3/h+vPpwqMkyXQq59g+d8UDUMkcP35coaFFT+EQEhKio0ePVmAinJaamqq5c+fqqquuKrB//avTtHPFu8rL9ry5wDfsSdUtb/6k9X8etzoKAACwCMVHD1FccaFOTITuGn6h6sREqHlCbf3n6n4yTVP5DodCgwJcPR1tNkPBAf4VHR0oVkbOCWWfOCnTlJymqUOpGXI4nWc/EaUWFFNPMmySYcjw8ZdvULjrWM22/S1MBsCb1KtXT6tWrSry+DfffKPY2NgKTARJSk5OVmxsrO644w7t37+/wLHctCP6dfHT+uL+K3Xotx8tSli01Ow8Tftws974cbecTs/spQkAANyHYddeol/H5urXsbkkadueQ7pq6ks6npGtrq0aKMDPVzm5ebr+0q4KD2GVW3iW6LBgndc0Xmt+2yVJuuj8FrLb+L1HeXOcPKFGl92lPd+8KUdulmK7DFFgdB2l7vpFgdF1FFIjweqIALzE8OHD9cADD6hjx44aP368bH99z3Y4HHrmmWf09ttva/LkyRanrFqSk5M1YMAAmaZZzBBrU468E1rzwn903k2PqHrTThWa8WxMU3pr9R79cThLd/dvLH8fu9WRAABABTFMT50kpgKsX79e7du317p169SuXTur4xRr14GjWvbDRkWGBumHzX/ot90profPOeOHqGViHYsTAkXLdzi0dstu+djtateoHhPPl7MD65Zpx6fPS5ISLrxBtTsOtDgRAG+Wm5urAQMG6KuvvlJMTIwaN24sSdq6dasOHz6sHj166JNPPpG/v2ePtkhPT1d4eLjS0tIUFhZmdZwyS01NVWxsrHJycuQsycgBw5DdN0B9Zrwn36Cih89bqU3dCE0b2Fx2ngcAAKgS6H7kBdIyc3TbU2/rg29/1vxl32nvoeOS/r9mnM8QVng4H7td5zdPUIcmcRQey5nTkaedyS9IplMyndr5+UtynDxhdSwAXszf31+fffaZXn75ZXXs2FFHjhzRkSNH1LFjR73yyiv64osvPL7wWJm8+uqrys7OLlnhUZJMU46TJ7R3TbJ7g52DDXtS9faaPVbHAAAAFYRh115gV8pRZZ846do2DMM11Lp764ZqRa9HoAozpH+ucE99F8A5stlsuvbaa3XttddaHaVKM01TTz/9dJnO/WPlIsV3v9I1N7inWbJhnwa3j5WfD30hAACo7Cg+eoGE2tUUGhSgrJxcOU1TXVomaPwVPZV14mSBlbABVD02u48aXDxe25c9I5mmEvr9S3bfAKtjAQDKwdGjR7Vjx44ynGkq+8g+5WWnyy84/OzNLZBz0qHj2SdVI4x/swAAqOwoPnqB0KAAPXPHVUpe/asiQ4M0oHNL+frY5efL/z4AUo3WFyqmRU9Jpmx2X6vjAKgEkpOT9fLLL2vnzp06fvx4oUVODMMoY1EMpZGZmXlO5+efyPbY4qPNkCKC+DcLAICqgOqVl6hdLULXXtzF6hhAmTmcThkymPPRTWx2vp0DKB+PPvqoJk6cqBo1aqhjx45q2bKl1ZGqrJCQkHM63yfAc0fItI+LYsVrAACqCH5aBeB2H3z7s15YslI+dpvuGt5XSW0aWR0JAFCEuXPnqlevXlq2bJl8femZZqXo6GglJiZq586dhXqfFs9QULXa8g3y3FW+r2jHnOUAAFQVzPAMwK0yc07o2cXLle9w6sTJfD325uel/AEKAFCRjh8/rsGDB1N49ACGYeiWW24p07n1kwZ77GIz58VHqUUdzxwODgAAyh/FRwBu5XSa+nut0el0itojAHiujh07auvWrVbHwF9Gjx6toKAg2WwlfGw3DNn9AhR7Xj/3Bisju83QdRfUtzoGAACoQBQfAbhVWHCgxvw1X6nNZujmK3sy7yMAeLDnnntOixcv1sKFCy3L8NBDD6lLly4KCgpSRESEZTk8QUREhN577z0ZhnH2AqRhyJChDtc9KN+g0IoJWEpXtqujOhGBVscAAAAVyDC9dPzjrFmztHjxYm3ZskWBgYHq0qWLHn74YTVu3LjE11i/fr3at2+vdevWqV27dm5MCyAz54Rshk1BAX5WRwEAFKNVq1Y6duyYDhw4oJCQEMXGxspuL7gwiGEY+vnnn92WYerUqYqIiNDevXv18ssvKzU1tdTXSE9PV3h4uNLS0hQW5rlzH5ZUcnKyrrzySmVnZxcxfcmpHo8drntQMU07Vni+koiNDNTcq9rKz4f+DwAAVCVeu+DMypUrdfPNN+u8885Tfn6+7r33XvXt21e//vqrgoODrY4H4B9CAgOsjgAAKIGoqChFR0erYcOGlmWYPn26JGnBggUlPic3N1e5ubmu7fT09PKOZal+/fpp7969eu211/Twww9r//79rmP+4dXUoM/Viu3YX76B57ZCtrvYbYbu7NuIwiMAAFWQ1xYfP/300wLbCxYsUPXq1bVu3Tp1797dolQAAADebcWKFVZHKJNZs2a5ipaVVUREhG699Va1bdu2wPNuu9HTFN2gtYXJzm5c9wQ1qO6ZQ8EBAIB7VZpfPaalpUk69dv6ouTm5io9Pd31yszMrKh4AAAAcKNJkyYpLS3N9dqzZ4/Vkdzmn6tYe+qq1qdd2a6OLmpZy+oYAADAIpWi+Oh0OnX77bera9euatGiRZHtZs2apfDwcNcrKSmpAlMCAAB4h/T0dM2ePVv9+vVT27ZttXr1aknSsWPHNGfOHG3fvr3U15w4caIMwyj2tWXLljJn9vf3V1hYWIEXrDe0Q6xGd4m3OgYAALCQ1w67/rubb75ZmzZt0rfffltsu0mTJmnChAmu7Q0bNlCABAAA+Ju9e/cqKSlJe/bsUcOGDbVlyxbXaJGoqCjNmzdPu3fv1ty5c0t13TvvvFNjxowptk1CQkJZY8PDBPra9a8eierZpLrVUQAAgMW8vvg4fvx4LV26VF9//bViY2OLbevv7y9/f3/XdkiIZ07IDQAAYJW7775bGRkZ2rBhg6pXr67q1QsWjwYNGqSlS5eW+roxMTGKiYkpr5jwYK3rhmt8z4aqGc5icwAAwIuLj6Zp6pZbbtH777+vFStWqH79+lZHqhAHDhzQgQMHrI5RadWqVUu1ajEnkbvw+XUvPr8AysNnn32mO+64Q82aNdPRo0cLHU9ISHD7fIp//vmnjh07pj///FMOh0MbNmyQJDVo0IBfHnuwmuEBurZrvDonRHv8PJQAAKDieG3x8eabb9bChQv1wQcfKDQ0VCkpKZKk8PBwBQYGlugatWrV0tSpU73mh/Xc3FwNHz5cK1eutDpKpZWUlKTk5OQCPWRRPvj8uh+fXwDlIScnp9geihkZGW7PcP/99+vVV191bbdt21aStHz5cvXo0cPt74/SiQz20/Dz6urCZjXkY68UU8oDAIByZJimaVodoiyK+m3q/PnzzzqfkLdKT09XeHi4Vq5cyW/93SAzM1NJSUlKS0tjkno34PPrXnx+AZSXDh06qHHjxnrjjTd09OhRxcTE6IsvvlCvXr0kSd26dZPdbvf4Xyad/nenMn5f/Pbbb3XBBRe4trvc9qyiEltVeI7QAB8Nbh+ri1vWUoCvvcLfHwAAeAev7fnopTXTctGmTZtK9xDtCdLT062OUCXw+XUPPr8Aysvtt9+u0aNHq1WrVhoyZIgkyel0avv27Zo+fbq+//57vffeexanhJV87YYua1NHg9vHKtjfa3+cAAAAFYSnBQAAALiMHDlSu3fv1n333afJkydLkvr37y/TNGWz2TRz5kwNGjTI2pCwTPu4SP2rR6JqhLGYDAAAKBmKjwAAAChg8uTJGjVqlN577z1t375dTqdTiYmJuuKKK5SQkGB1PFggyM+uf/VIVFKjGBaTAQAApULx0Yv4+/tr6tSpLCbhJtxf9+L+uhf3F0B5yM7O1gUXXKAbbrhBN910k+644w6rI8EDNKwRonv6N6G3IwAAKBOvXXAGAAAA5S8qKkqzZs3SuHHjrI5yTlhwpnz0a15DN3ZPlJ8Pq1gDAICy4SkCAAAALv3791dycrLVMWAxH7uhm3smanyvhhQeAQDAOeFJAgAAAC5TpkzR77//rlGjRunbb7/Vvn37dOzYsUIvVF61IwL02JDW6t+iltVRAABAJcCcjwAAAHBp3ry5JOnXX3/VwoULi2zncDgqKhIqiGFIl7aqrVGd4xTga7c6DgAAqCQoPnqAadOmafr06bJ6+s3TOQ4fPqxq1apZmqU8jRkzRitWrNCuXbssz7Fo0SJlZmZamgMAgOLcf//9rGZcBSXEBOvfPRqocc1Qq6MAAIBKpsoPu37nnXdkGIbef//9Qsdat24twzC0fPnyQsfq1aunLl26FHvtMWPGyDAM1yssLEytW7fW448/rtzc3HL7GrzFggULXPfi22+/LXTcNE3VrVtXhmHokksuOev1evToUeD+RkVF6bzzztMrr7wip9Ppji+hUqjIz3xISIgSEhI0ePBgvffee1Xq/4s7P+82m01hYWFq3LixRo0apc8//9wdXwKAKmratGmaOnXqWV+oHEIDfPSvHol6YmgbCo8AAMAtqnzxsVu3bpJUqDiQnp6uTZs2ycfHR6tWrSpwbM+ePdqzZ4/r3OL4+/vr9ddf1+uvv66ZM2cqKipKd911l0aPHl1+X4SXCQgIOOMwrpUrV2rv3r3y9/cv8bViY2Nd93fKlCnKz8/Xddddp3vvvbc8I1cqFfmZf+KJJzRixAht27ZNgwcPVu/evZWenl5+X4wXcMfn/bXXXtOjjz6qgQMH6rvvvlPfvn01bNgw5eXllWd0AJAkpaWlMcS6ErIZ0oBWtTRvVHtd3LKWbDZ6uwIAAPeo8sXH2rVrq379+oUKMd9//71M09SQIUMKHTu9XZJCjI+Pj0aOHKmRI0dq/Pjx+vLLL9WhQwe9/fbb2r9/f/l9IV7k4osv1rvvvqv8/PwC+xcuXKj27durZs2aJb5WeHi46/7ecccdWrVqlWJjY/XMM89QiClCRX7mb7jhBj344IP6+eefNWvWLK1YsUI33HBDseebpqmcnJxSflWey12f93HjxunRRx/V77//rn//+9965513dN999xV7vtPp1IkTJ8r0dQCoWtauXav+/fsrKChI0dHRWrlypSTpyJEjuuyyy7RixQprA+KcNK4ZqieGtdFNSYkKDfC1Og4AAKjkqnzxUTpVUPnpp58KFDxWrVql5s2b66KLLtIPP/xQYLjoqlWrZBiGunbtWur3stls6tGjhyQVOwfh/Pnz1atXL1WvXl3+/v5q1qyZnn/++TO2/eSTT5SUlKTQ0FCFhYXpvPPOK9TT6scff1T//v0VHh6uoKAgJSUlFerddtqRI0c0dOhQhYWFKTo6WrfddluhgkV+fr4eeOABJSYmyt/fX/Hx8br33ntLNJx8+PDhOnr0aIGhoidPntSiRYs0YsSIs55fnKCgIJ1//vnKysrS4cOHi2z32GOPqUuXLoqOjlZgYKDat2+vRYsWnbHt//73P3Xs2FFBQUGKjIxU9+7d9dlnnxVo88knn+iCCy5QcHCwQkNDNWDAAG3evPmM19u5c6f69eun4OBg1a5dWzNmzCg032dWVpbuvPNO1a1bV/7+/mrcuLEee+yxcpsXtCI/86dNnDhRffv21bvvvqvff//dtT8+Pl6XXHKJkpOT1aFDBwUGBmrevHnatWuXDMPQggULCl3LMAxNmzatwL4VK1aoQ4cOCggIUGJioubNm6dp06ZZPm+ZOz/vkmS32/XUU0+pWbNmeuaZZ5SWluY6ZhiGxo8frzfeeEPNmzeXv7+/Pv30U61YsUKGYRQqHhR1z9999101a9ZMAQEBatGihd5//32NGTNG8fHx55wfgOf57rvv1K1bN23btk0jR44s8O9BtWrVlJaWpnnz5lmYEGXl72PTuKQEPXJlKyXEhFgdBwAAVBEUH3WqEJOXl6cff/zRtW/VqlXq0qWLunTporS0NG3atKnAsSZNmig6OrpM77djxw5JKvb8559/XnFxcbr33nv1+OOPq27duvr3v/+tZ599tkC7BQsWaMCAATp27JgmTZqk2bNnq02bNvr0009dbb766it1795d6enpmjp1qmbOnKnU1FT16tVLq1evLvTeQ4cO1YkTJzRr1ixdfPHFeuqpp3TjjTcWaHP99dfr/vvvV7t27fTEE08oKSlJs2bN0lVXXXXWrz8+Pl6dO3fWm2++6dr3ySefKC0trUTnn83OnTtlt9sVERFRZJu5c+eqbdu2mjFjhmbOnCkfHx8NGTJEH3/8cYF206dP16hRo+Tr66sZM2Zo+vTpqlu3rr766itXm9dff10DBgxQSEiIHn74YU2ZMkW//vqrunXrVqjA7HA41L9/f9WoUUOPPPKI2rdvX2juLNM0NXDgQD3xxBPq37+/5syZo8aNG+vuu+/WhAkTzvn+SBX/mT9t1KhRMk2z0ByFW7du1fDhw3XhhRdq7ty5atOmTamu+9NPP6l///46evSopk+fruuuu04zZszQkiVLzilveXD35106VYAcPny4srOzC/Va/eqrr3THHXdo2LBhmjt3bqkLhh9//LGGDRsmX19fzZo1S1dccYWuu+46rVu3rlyyA/A89957r5o2bapff/1VM2fOLHS8Z8+eBf79gHdIiAnWk1e10SWtajPEGgAAVCwT5ubNm01J5gMPPGCapmnm5eWZwcHB5quvvmqapmnWqFHDfPbZZ03TNM309HTTbrebN9xww1mvO3r0aDM4ONg8fPiwefjwYXP79u3mzJkzTcMwzFatWrnaTZ061fzn/4rs7OxC1+vXr5+ZkJDg2k5NTTVDQ0PNTp06mTk5OQXaOp1O138bNmxo9uvXz7Xv9PXr169vXnjhhYVyDBw4sMC1/v3vf5uSzJ9//tk0TdPcsGGDKcm8/vrrC7S76667TEnmV199dcb7MX/+fFOSuWbNGvOZZ54xQ0NDXV/nkCFDzJ49e5qmaZpxcXHmgAEDzniNv0tKSjKbNGniur+//fabeeutt5qSzEsvvdTVbvTo0WZcXFyBc/95f0+ePGm2aNHC7NWrl2vftm3bTJvNZl5++eWmw+Eo0P70vczIyDAjIiIKfR5SUlLM8PDwAvtHjx5tSjJvueWWAtcZMGCA6efnZx4+fNg0TdNcsmSJKcl88MEHC1xz8ODBpmEY5vbt2896b87G3Z/5ovz000+mJPOOO+5w7YuLizMlmZ9++mmBtn/88YcpyZw/f36h60gyp06d6tq+9NJLzaCgIHPfvn2ufdu2bTN9fHwK/d2qKO74vDdv3rzI4++//74pyZw7d65rnyTTZrOZmzdvLtB2+fLlpiRz+fLlBfaf6Z63bNnSjI2NNTMyMlz7VqxYYUoq9PcKQOUQFBTk+l5y5MgR0zAM88svv3Qdf+mll8zAwECr4pVYWlqaKclMS0uzOkq5++abb0xJrleX2541L3nqmyJfj3z6m3kiL9/q2AAAoIqi56Okpk2bKjo62tVj6Oeff1ZWVpZrZd8uXbq4hih///33cjgcJZr7Tjo1fDYmJkYxMTFq0KCB7r33XnXu3PmMKw3/XWBgoOvPaWlpOnLkiJKSkrRz507XsMrPP/9cGRkZmjhxogICAgqcf3qo6YYNG7Rt2zaNGDFCR48e1ZEjR3TkyBFlZWWpd+/e+vrrrwutQHzzzTcX2L7lllskScuWLSvw33/2wrvzzjslqVDvwTMZOnSocnJytHTpUmVkZGjp0qVlGoK6ZcsW1/1t2rSpnn76aQ0YMECvvPJKsef9/f4eP35caWlpuuCCC7R+/XrX/iVLlsjpdOr++++XzVbwr8rp+/v5558rNTVVw4cPd93bI0eOyG63q1OnTmdcNXr8+PEFrjN+/HidPHlSX3zxhaRT99dut+vWW28tcN6dd94p0zT1ySeflPDuFM2dn/nihIScGuKVkZFRYH/9+vXVr1+/Ml3T4XDoiy++0KBBg1S7dm3X/gYNGuiiiy4qe9hyVF6f9+IUdW+TkpLUrFmzMl1z//792rhxo6655hrX9U9fs2XLlmUPC8Cj+fr6Fno2+Lt9+/YV+J4Az3ZZm9q6q29j+fvYrY4CAACqKB+rA3gCwzDUpUsXVyFu1apVql69uho0aCDpVCHmmWeekSRXQaakhZiAgAB99NFHkk6tAly/fn3Fxsae9bxVq1Zp6tSp+v7775WdnV3gWFpamsLDw13Dt1u0aFHkdbZt2yZJxa6unZaWpsjISNd2w4YNCxxPTEyUzWZzDSHevXu3bDab6/6cVrNmTUVERGj37t1n/fpiYmLUp08fLVy4UNnZ2XI4HBo8ePBZz/un+Ph4vfTSSzIMQwEBAWrYsKGqV69+1vOWLl2qBx98UBs2bCgwT+Xf5wfcsWOHbDZbsYWb0/e3V69eZzweFhZWYNtmsykhIaHAvkaNGklSgftbu3ZthYaGFmjXtGlT1/Fz5c7PfHEyMzMlqdDXVr9+/TJf89ChQ8rJySn0eZR0xn1WKK/Pe3HccW9Pf9aKurd/L9YDqDzOP/98LVq0SLfffnuhY1lZWZo/f76SkpIqPhhKbUCrWrquW33L5z8GAABVG8XHv3Tr1k0fffSRNm7c6Jr77rQuXbro7rvv1r59+/Ttt9+qdu3ahQpIRbHb7erTp0+psuzYsUO9e/dWkyZNNGfOHNWtW1d+fn5atmyZnnjiiWJ7I/zT6baPPvpokfPona33QlEPrOf6IDtixAjdcMMNSklJ0UUXXVTsHI1FCQ4OLvX9/eabbzRw4EB1795dzz33nGrVqiVfX1/Nnz+/0EI9Z3P6/r7++utnXLXYx8dz/4q56zNfnNPzSP6zmPX3nqinFfX5cjgc55zDCuXxeS9OVb63AMrX9OnTlZSUpAEDBmj48OGSTvWQ37lzpx577DEdPnxYU6ZMsTglzqZ13XDdeEEChUcAAGA5z62MVLDTvbq+/fZbrVq1qsBv+9u3by9/f3+tWLFCP/74oy6++GK3Zvnoo4+Um5urDz/8UPXq1XPt/+cQ3sTEREmnig5F9fA63SYsLKzERbpt27YV6C21fft2OZ1O10IVcXFxcjqd2rZtm6s3niQdPHhQqampiouLK9H7XH755Ro3bpx++OEHvf322yU6pzy89957CggIUHJysvz9/V3758+fX6BdYmKinE6nfv311yILt6fvb/Xq1Ut0f51Op3bu3Onq7SjJtfLz3+/vF198oYyMjAK92LZs2eI6Xh6s+My//vrrMgxDF1544Vnbnu6Nm5qaWmD/P3t+Vq9eXQEBAdq+fXuha5xpn1Xc+Xl3OBxauHChgoKCStRDtaT39vRnzdPvLYDy1alTJy1btkz/+te/dM0110j6/6lVEhMTtWzZMrVq1crKiFVey5Yt9c0338jhNHXv4o0KrV3wF4SBfnbd0acRC8sAAACPwJyPf+nQoYMCAgL0xhtvaN++fQV6gfn7+6tdu3Z69tlnlZWVVS7DT4tjt5+ak8c0Tde+tLS0QsWxvn37KjQ0VLNmzdKJEycKHDt9bvv27ZWYmKjHHnvMNSzz7w4fPlxo3z9X1H766aclyTV/3ulC1JNPPlmg3Zw5cyRJAwYMKP4L/EtISIief/55TZs2TZdeemmJzikPdrtdhmEU6OW1a9euQisjDxo0SDabTTNmzCjU2/T0/e3Xr5/CwsI0c+ZM5eXlFXqvM93f08OZT1/nmWeeka+vr3r37i3p1P11OBwF2knSE088IcMwym0ew4r+zM+ePVufffaZhg0bVmho/5mEhYWpWrVq+vrrrwvsf+655wpsn+5dvGTJEu3fv9+1f/v27eUyP2Z5cdfn3eFw6NZbb9Vvv/2mW2+9tdBQ/zOJi4uT3W4/672tXbu2WrRooddee63A94+VK1dq48aN5fMFALBcenp6oZ7PvXr10tatW7V+/Xq9/fbbevPNN7V69Wr9/vvvDLn2AOHh4erWrZu6deumqMRW8g0sOIpleMe6ig7xL+JsAACAikXPx7/4+fnpvPPO0zfffCN/f3+1b9++wPEuXbro8ccfl1Q+c98Vp2/fvvLz89Oll16qcePGKTMzUy+99JKqV6+uAwcOuNqFhYXpiSee0PXXX6/zzjtPI0aMUGRkpH7++WdlZ2fr1Vdflc1m03//+19ddNFFat68ua699lrVqVNH+/bt0/LlyxUWFuaak/K0P/74QwMHDlT//v31/fff63//+59GjBih1q1bS5Jat26t0aNH68UXX1RqaqqSkpK0evVqvfrqqxo0aJB69uxZ4q+1uLko3WXAgAGaM2eO+vfvrxEjRujQoUN69tln1aBBA/3yyy+udg0aNNDkyZP1wAMP6IILLtAVV1whf39/rVmzRrVr19asWbMUFham559/XqNGjVK7du101VVXKSYmRn/++ac+/vhjde3atUARMSAgQJ9++qlGjx6tTp066ZNPPtHHH3+se++9VzExMZKkSy+9VD179tTkyZO1a9cutW7dWp999pk++OAD3X777a7elufKXZ/5/Px8/e9//5MknThxQrt379aHH36oX375RT179tSLL75Y4mtdf/31mj17tq6//np16NBBX3/9taun6N9NmzZNn332mbp27ap//etfruJtixYttGHDhhK/n7ud6+c9LS3NdW+zs7O1fft2LV68WDt27NBVV12lBx54oETXCQ8P15AhQ/T000/LMAwlJiZq6dKlOnToUKG2M2fO1GWXXaauXbvq2muv1fHjx1339ky/0ADgfSIjI/X666+7FsIaO3asxo0bp06dOqlNmzZF9v6HZwoP9NVFLWpZHQMAAOD/WbrWtoeZNGmSKcns0qVLoWOLFy82JZmhoaFmfn5+ia43evRoMzg4+Kztpk6dav7zf8WHH35otmrVygwICDDj4+PNhx9+2HzllVdMSeYff/xRqG2XLl3MwMBAMywszOzYsaP55ptvFmjz008/mVdccYUZHR1t+vv7m3FxcebQoUPNL7/8slCOX3/91Rw8eLAZGhpqRkZGmuPHjzdzcnIKXC8vL8+cPn26Wb9+fdPX19esW7euOWnSJPPEiRNFfp3z5883JZlr1qwp9n7ExcWZAwYMKLaNaZpmUlKS2bx587O2Gz16tBkXF1dg38svv2w2bNjQ9Pf3N5s0aWLOnz//jP8fTNM0X3nlFbNt27amv7+/GRkZaSYlJZmff/55gTbLly83+/XrZ4aHh5sBAQFmYmKiOWbMGHPt2rUFcgQHB5s7duww+/btawYFBZk1atQwp06dajocjgLXy8jIMO+44w6zdu3apq+vr9mwYUPz0UcfNZ1O51m/3tJwx2dekusVFBRkxsfHm1deeaW5aNGiQl+naRb//zs7O9u87rrrzPDwcDM0NNQcOnSoeejQIVOSOXXq1AJtv/zyS7Nt27amn5+fmZiYaP73v/8177zzTjMgIKBE2cubOz7vf7+3ISEhZsOGDc2RI0ean3322RnPkWTefPPNZzx2+PBh88orrzSDgoLMyMhIc9y4ceamTZtMSeb8+fMLtH3rrbfMJk2amP7+/maLFi3MDz/80LzyyivNJk2anDU3AM8XEBBgvvLKK65twzDMN954w8JE5SMtLc2UZKalpVkdxW3yHU7zkqe+KfD63w+7rI4FAABQgGGafxvbCwCVyKBBg7R582bXquQoP23atFFMTIw+//xzq6MAOEdt27ZVUFCQHnzwQYWHh6tDhw568MEH1b9//2LPa9euXQUlLJv09HSFh4crLS2tRFNSeCOH09SgZ1e5tm2G9PKY81SNIdcAAMCDMOwaQKWQk5NTYGXnbdu2admyZZYM7a9M8vLyZBhGgZXbV6xYoZ9//lkPPvighckAlJdZs2Zp2LBhroXTDMPQlClTilzR2jTNQnMnwzN0rB9F4REAAHgcio8AKoWEhASNGTNGCQkJ2r17t55//nn5+fnpP//5j9XRvNq+ffvUp08fjRw5UrVr19aWLVv0wgsvqGbNmrrpppusjgegHPTv319//PGH1qxZo4MHD2rMmDG68cYb1blzZ6ujoZT6t6hpdQQAAIBCKD4CqBT69++vN998UykpKfL391fnzp01c+bMEq2sjaJFRkaqffv2+u9//6vDhw8rODhYAwYM0OzZsxUdHW11PADl4JdfflFcXJz69esnSZo/f76GDBmi3r17W5wMpREd4qe2dSOtjgEAAFAIxUcAlcL8+fOtjlAphYeH6+2337Y6BgA3atu2bYHVruGdejSKkc1mWB0DAACgEJvVAQAAAGCdwMBAZWdnu7ZXrlypgwcPWpgIZXFBoxirIwAAAJwRPR8BAACqsNatW2vOnDmy2+0KDw+XJK1Zs0YBAQHFnnfFFVdURDyUQEyovxKqBVsdAwAA4IwM0zRNq0MAAADAGmvXrtXgwYP1559/Sjq12vXZHg+9YbXr9PR0hYeHKy0tTWFhYVbHcQuH09SgZ1epX/MaGt+LOY4BAIBnYtj1OVqwYIEMw1BAQID27dtX6HiPHj3UokWLCs305ZdfauzYsWrUqJGCgoKUkJCg66+/XgcOHDhj+++++07dunVTUFCQatasqVtvvVWZmZkVmrko3F/34v66F/cXgDfo0KGDtm/frt9++00rVqyQaZqaPHmyli9fXuTrq6++sjo2/qZ57XCrIwAAABSJYdflJDc3V7Nnz9bTTz9tdRTdc889OnbsmIYMGaKGDRtq586deuaZZ7R06VJt2LBBNWvWdLXdsGGDevfuraZNm2rOnDnau3evHnvsMW3btk2ffPKJhV9FQdxf9+L+uhf3F4Cn8/HxUePGjdW4cWONHj1al1xyiTp16mR1LJRQo5qhVkcAAAAomolzMn/+fFOS2aZNG9Pf39/ct29fgeNJSUlm8+bNKzTTypUrTYfDUWifJHPy5MkF9l900UVmrVq1zLS0NNe+l156yZRkJicnV0je4nB/3Yv7617cXwCwTlpamimpwPewyibf4TQvf/Zb0+FwWh0FAACgSAy7Lif33nuvHA6HZs+ebXUUde/eXTabrdC+qKgo/fbbb6596enp+vzzzzVy5MgCcyFdc801CgkJ0TvvvFNhmc+G++te3F/34v4C8GQzZszQAw88IKfT6do+2+uBBx6wODVOqx0RKJvNsDoGAABAkRh2XU7q16+va665Ri+99JImTpyo2rVrl+r87OxsZWdnn7Wd3W5XZGRkqfNlZmYqMzNT1apVc+3buHGj8vPz1aFDhwJt/fz81KZNG/3000+lfh934f66F/fXvbi/ADzZtGnTZBiG7rnnHvn5+WnatGlnPccwDE2ZMsX94XBWNcKKX5UcAADAavR8LEeTJ09Wfn6+Hn744VKf+8gjjygmJuasr7Zt25Yp25NPPqmTJ09q2LBhrn2nF5ioVatWofa1atXS/v37y/Re7sL9dS/ur3txfwF4KqfTKYfDIT8/P9f22V6evtJ1VRIV7Gd1BAAAgGLR87EcJSQkaNSoUXrxxRc1ceLEM/7QXpRrrrlG3bp1O2u7wMDAUuf6+uuvNX36dA0dOlS9evVy7c/JyZEk+fv7FzonICDAddxTcH/di/vrXtxfAIA7UHwEAACejuJjObvvvvv0+uuva/bs2Zo7d26Jz0tISFBCQkK559myZYsuv/xytWjRQv/9738LHDtdqMjNzS103okTJ8pUyHA37q97cX/di/sLwFv89ttv2rFjhzIyMhQaGqoGDRqoSZMmVsfCGUQG+VodAQAAoFgUH8tZQkKCRo4c6erdVFKn51w7G7vdrpiYmBJdc8+ePerbt6/Cw8O1bNkyhYaGFjh+uufV6eGVf3fgwIFSz0tXEbi/7sX9dS/uLwBPN2/ePD300EPat29foWP16tXT5MmTdf3111uQDEUJC6D4CAAAPBtzPrrBfffdV+q53R577DHVqlXrrK/zzjuvRNc7evSo+vbtq9zcXCUnJ59xiGeLFi3k4+OjtWvXFth/8uRJbdiwQW3atClx/orE/XUv7q97cX8BeKq77rpL//rXv5Sdna2xY8dqzpw5evHFFzVnzhxde+21ysjI0Lhx43TPPfdYHRV/ExZI8REAAHg2ej66QWJiokaOHKl58+YpLi5OPj5nv83lOadbVlaWLr74Yu3bt0/Lly9Xw4YNz9guPDxcffr00f/+9z9NmTLF1fPp9ddfV2ZmpoYMGXLW97IC99e9uL/uxf0F4IlWr16tOXPm6PLLL9drr72m4ODgQm3mzp2rkSNH6rHHHtOQIUPUoUMHC5Lin4L9eZwHAACezTBN07Q6hDdbsGCBrr32Wq1Zs6bAQ/j27dvVpEkTORwONW/eXJs2baqwTIMGDdIHH3ygsWPHqmfPngWOhYSEaNCgQa7t9evXq0uXLmrWrJluvPFG7d27V48//ri6d++u5OTkCstcFO6ve3F/3Yv7C8BbjBs3TkuXLtXOnTvPuNDUaSdOnFBCQoIuu+wyPf/88xWYsPTS09MVHh6utLQ0hYWFWR3HLRxOU0cyc1UjLMDqKAAAAEUzcU7mz59vSjLXrFlT6Njo0aNNSWbz5s0rNFNcXJwp6YyvuLi4Qu2/+eYbs0uXLmZAQIAZExNj3nzzzWZ6enqFZi4K99e9uL/uxf0F4C1atmxp3nbbbSVqe+utt5otW7Z0b6BykJaWZkoy09LSrI7iNvkOp3ksM9fqGAAAAMWi5yMAAEAVFxkZqdmzZ2vcuHFnbTtv3jxNnDhRx48fr4BkZVdVej7m5DkUwtBrAADgwVhwBgAAoIpLT08vtOp9UUJCQpSRkeHmRCgJu82g8AgAADwexUcAAIAqzjRNGYZRqvYAAABASTDsGgAAoIqz2Wxq27at6tSpc9a2+/bt04YNG+RwOCogWdlVhWHXAAAA3oBxGgAAAFVcvXr1dOzYMR07dqzE7QEAAICSoPgIAABQxe3atcvqCAAAAKikmPMRAAAAAAAAgFtQfAQAAAAAAADgFhQfAQAAAAAAALgFxUcAAAAAAAAAbkHxEQAAAAAAAIBbUHwEAAAAAAAA4BYUHwEAAAAAAAC4hY/VAQAAAOBZkpOT9fLLL2vnzp06fvy4TNMscNwwDO3YscOidAAAAPAmFB8BAADg8uijj2rixImqUaOGOnbsqJYtW1odCQAAAF7MMP/5q2wAAABUWbGxsWratKmWLVsmX19fq+OUWXp6usLDw5WWlqawsDCr4wAAAFRZzPkIAAAAl+PHj2vw4MFeXXgEAACA56g0xcfZs2fLMAzdfvvtVkcBAAAokqc/s3Ts2FFbt261OgYAAAAqiUpRfFyzZo3mzZunVq1aWR0FAACgSN7wzPLcc89p8eLFWrhwodVRAAAAUAl4ffExMzNTV199tV566SVFRkaW6twDBw5o2rRpOnDggJvSAQCAyqaszw/n8sxSkYYNG6b8/HyNGjVK4eHhat68uVq1alXg1bp1a6tjAgAAwEt4ffHx5ptv1oABA9SnT5+zts3NzVV6errrtW3bNk2fPp3iIwAAKLEDBw5o+vTp2rZtW4Hnitzc3GLPK80zi5WioqLUsGFDde/eXe3atVP16tUVHR1d4BUVFWV1TAAAAHgJH6sDnIu33npL69ev15o1a0rUftasWZo+fbqbUwEAgKogKSmpwPbUqVM1bdq0M7Yt7TOLlVasWGF1BAAAAFQiXlt83LNnj2677TZ9/vnnCggIKNE5kyZN0oQJE1zbGzZsKPSDAwAAQEmsXLlSbdq0cW37+/ufsV1ZnlkAAACAysJri4/r1q3ToUOH1K5dO9c+h8Ohr7/+Ws8884xyc3Nlt9sLnOPv71/gB4OQkJAKywsAACqXkJAQhYWFnbVdWZ5ZPEFeXp62bNmitLQ0OZ3OQse7d+9uQSoAAAB4G68tPvbu3VsbN24ssO/aa69VkyZNdM8993jkQzwAAKh6vO2Zxel0atKkSXruueeUnZ1dZDuHw1GBqQAAAOCtvLb4GBoaqhYtWhTYFxwcrOjo6EL7AQAArOJtzywzZ87Uo48+qnHjxqlbt24aNWqUHn74YUVEROi5556TYRh65JFHrI4JAAAAL+H1q10DAACg/CxYsEBDhw7V888/r/79+0uS2rdvrxtuuEE//vijDMPQV199ZXFKAAAAeAuv7fl4JqzOCAAAvIEnP7Ps3btX//nPfyT9/yI6J06ckCT5+flp5MiRmjNnjmbOnGlZRgAAAHgPej4Cf8P8VQCAqi46OlqZmZmS/n9RnZ07dxZoc/z4cSuiAQAAwAtVqp6PwLk6cOCAYmNjrY4BAIBl2rZtqzVr1ri2e/bsqSeffFJt27aV0+nUU089pdatW1uYEAAAAN6Eno/A36SkpMg0TatjAABgmRtvvFG5ubnKzc2VJD300ENKTU1V9+7dlZSUpPT0dD3++OMWpwQAAIC3oOcj8DdZWVnavXu34uPjrY4CAIAlBg4cqIEDB7q2mzVrph07dmjFihWy2+3q0qWLoqKiLEwIAAAAb0LxEfhLhw4dtHv3boWEhGj9+vWKjIy0OhIAAB4hPDxcl112mdUxAAAA4IUYdg38JSUlRUeOHFFqaqqWLl2q/fv3Wx0JAABLOBwOvfXWWxo3bpwuv/xybdy4UZKUlpamxYsX6+DBg2577127dum6665T/fr1FRgYqMTERE2dOlUnT55023sCAADAfej5CJxBTk6Oli5dqoYNG6pdu3YKDw+3OhIAABUiNTVV/fv31+rVqxUSEqKsrCzdcsstkk6tfn3rrbfqmmuu0cyZM93y/lu2bJHT6dS8efPUoEEDbdq0STfccIOysrL02GOPueU9AQAA4D4UH4FibNu2Tdu3b1dsbKwaNWqkevXqydfX1+pYAAC4zcSJE7V582YlJyerbdu2ql69uuuY3W7X4MGDtWzZMrcVH/v376/+/fu7thMSErR161Y9//zzFB8BAAC8EMVH4CxM09SePXu0Z88e2e121a5dW/Xr11dcXJwCAwOtjgcAQLlasmSJbrnlFl144YU6evRooeONGjXSggULKjRTWlraWRe5+fsK3ZKUnp7u7lgAAAAoAYqPgE71cDz9Q0pOTo4OHjyoGjVqFGrncDhchUjDMFStWjXVqVNHNWrUUPXq1SlGAgC8XlpamurXr1/k8by8POXn51dYnu3bt+vpp58+a6/HWbNmafr06RWUCgAAACXFgjOo8ubPn68mTZooIyND0qmeE1OnTtV3331X7Hmmaerw4cPasGGDkpOT9frrr+vNN9/UV199pW3btlXoD2YAAJSXxMRErV+/vsjjn332mZo1a1bq606cOFGGYRT72rJlS4Fz9u3bp/79+2vIkCG64YYbir3+pEmTlJaW5nrt2bOn1BkBAABQ/uj5iCpt27Ztuv766+V0OgvsN01Tr732mho0aFBgrquzycjIUEZGhrZv3661a9eqf//+ioyMLO/YAAC4zfXXX6977rlHPXr0UO/evSVJhmEoNzdXM2bM0KeffqoXX3yx1Ne98847NWbMmGLbJCQkuP68f/9+9ezZU126dCnR+/n7+8vf37/UuQAAAOBeFB9Rpb3yyisyDOOMxwzD0KpVq3T55ZeX6doZGRlavHixWrRooXbt2rFQDQDAK9x2223avHmzhg8froiICEnSiBEjdPToUeXn52vcuHG67rrrSn3dmJgYxcTElKjtvn371LNnT7Vv317z58+XzcZgHQAAAG9F8RFV2q5du2Sa5hmPmaZ5xon2S8PhcGj79u1KTExUtWrVzulaAABUBMMw9NJLL2n06NFatGiRtm3bJqfTqcTERA0dOlTdu3d36/vv27dPPXr0UFxcnB577DEdPnzYdaxmzZpufW8AAACUP4qPqNLi4+OL7fkYHR1d5mvXrl1bzZo1U3x8PD02AABep1u3burWrVuFv+/nn3+u7du3a/v27YqNjS1wrKhfGAIAAMBzURFBlTZ27Nhiez527dq1xNcyDEM1atRQx44dddVVV+mSSy5RQkIChUcAAEphzJgxMk3zjC8AAAB4H3o+okpr2LChXn75ZV133XUFFp0xDEPXXHPNWReb8fHxUd26dRUfH6+6desqICDA3ZEBACh3AwcOLFV7wzD0wQcfuCkNAAAAKhOKj6jyxowZo27duqldu3bKyMiQv7+/7rvvviILjzabTbGxsWrQoIHi4uJYSAYA4PWWLl2qgIAA1axZs0Q9DIuasgQAAAD4J4qPgKQGDRooLCxMGRkZCgwMLFR49Pf3V2xsrOrVq6d69erJ39/foqQAAJS/OnXqaN++fapWrZpGjBihq666isVdAAAAUC4oPgJFMAxD8fHxatKkierUqcPcjQCASmvPnj1auXKlFi5cqAceeEB33323kpKSdPXVV2vw4MEKDQ21OiIAAAC8FNUU4Axq1aqlwYMH68ILL1TdunUpPAIAKr2kpCTNmzdPKSkpWrRokaKjozV+/HhVr15dV1xxhRYtWqTc3FyrYwIAAMDLUFEB/lKzZk1Vq1ZNUVFRuvjiixUZGWl1JAAAKpyvr68uu+wyvf322zp48KCrIDls2DA98sgjVscDAACAl2HYNfCXtWvXauXKlapXr57sdrvVcQAAsFRubq6Sk5P1wQcf6KefflJAQIDi4+OtjgUAAAAvQ89H4G8iIiL4wQoAUGU5nU4lJydrzJgxqlGjhoYPH66cnBy99NJLOnTokEaNGmV1RAAAAHgZej4Cf1OzZk0ZhmF1DAAAKtR3332nhQsX6t1339XRo0d1/vnna+bMmRo6dKiqVatmdTwAAAB4MYqPwN9ERERYHQEAgArXrVs3BQYG6uKLL9bw4cNdowD+/PNP/fnnn2c8p127dhWYEAAAAN6K4iPwN/7+/lZHAADAEjk5OXrvvfe0ePHiYtuZpinDMORwOCooGQAAALwZxUcAAIAqbv78+VZHAAAAQCVF8REAAKCKGz16tNURAAAAUEmx2jUAAAAAAAAAt6D4CAAAAAAAAMAtKD4CAAAAAAAAcAuKjwAAAAAAAADcguIjAAAAAAAAALeg+AgAAAAAAADALSg+AgAAAAAAAHALio8AAAAAAAAA3ILiIwAAAAAAAAC3oPgIAAAAAAAAwC0oPgIAAAAAAABwC68tPs6aNUvnnXeeQkNDVb16dQ0aNEhbt261OhYAAEABPLMAAACgKvPa4uPKlSt1880364cfftDnn3+uvLw89e3bV1lZWVZHAwAAcOGZBQAAAFWZj9UByurTTz8tsL1gwQJVr15d69atU/fu3S1KBQAAUBDPLAAAAKjKvLb4+E9paWmSpKioqCLb5ObmKjc317WdmZnp9lwAAKByyszMVHp6umvb399f/v7+Zz2vJM8sAAAAQGXhtcOu/87pdOr2229X165d1aJFiyLbzZo1S+Hh4a5XUlJSBaYEAACVSVJSUoHnilmzZp31nJI+swAAAACVRaXo+XjzzTdr06ZN+vbbb4ttN2nSJE2YMMG1vWHDBgqQAACgTFauXKk2bdq4tkvS67GkzywAAABAZeH1xcfx48dr6dKl+vrrrxUbG1ts238OhwoJCXF3PAAAUEmFhIQoLCysxO1L88wCAAAAVBZeW3w0TVO33HKL3n//fa1YsUL169e3OhIAAEAhPLMAAACgKvPa4uPNN9+shQsX6oMPPlBoaKhSUlIkSeHh4QoMDLQ4HQAAwCk8swAAAKAq89oFZ55//nmlpaWpR48eqlWrluv19ttvWx0NAADAhWcWAAAAVGVe2/PRNE2rIwAAAJyVFc8sv/zyi55++mmtX79eaWlpcjqdBY4bhqEdO3ZUeC4AAABUPV7b8xEAAACFrVixQh07dtTSpUtVu3Zt7dy5UwkJCapdu7Z2796tkJAQde/e3eqYAAAAqCIoPgIAAFQi999/vxISErR161bNnz9fknTvvffq22+/1Xfffae9e/dq6NChFqcEAABAVUHxEQAAoBJZv369rrvuOoWFhclut0uSHA6HJKlTp04aN26cpkyZYmVEAAAAVCEUHwEAACoRHx8fhYaGSpIiIiLk6+urQ4cOuY4nJCTo119/tSoeAAAAqhiKjwAAAJVIgwYNtG3bNkmnFpZp0qSJ3n//fdfxjz/+WDVr1rQqHgAAAKoYio8AAACVyMUXX6w333xT+fn5kqQJEyZo8eLFatiwoRo2bKgPP/xQ48aNszglAAAAqgofqwMAAACg/EyZMkW33Xaba77H0aNHy26367333pPdbtfkyZM1ZswYa0MCAACgyihR8TE9PV3BwcGuh1gAAAB4Jl9fX0VHRxfYN3LkSI0cOdKiRAAAAKjKSjTsOjIyUm+//bZre+zYsfrxxx/dFgoAAABlk5CQoA8//LDI40uXLlVCQkIFJgIAAEBVVqLio5+fn3Jzc13bCxYs0I4dO9wWCgAAAGWza9cuZWZmFnk8MzNTu3fvrsBEAAAAqMpKNOy6SZMm+u9//6v4+HiFh4dLOvVgu379+mLPa9eu3bknBAAAQKkYhlHksTVr1igiIqLiwgAAAKBKK1HxcdasWRo2bJj69Okj6dQD7ZQpUzRlypQztjdNU4ZhyOFwlF9SAAAAnNHcuXM1d+5cSaee026//XZNnjy5ULu0tDSlpqZqxIgRFR0RAAAAVVSJio/9+/fXH3/8oTVr1ujgwYMaM2aMbrzxRnXu3Nnd+QAAAHAW1atXV/PmzSWdGp1Sp04d1alTp0AbwzAUHBys9u3b69///rcVMQEAAFAFlaj4+MsvvyguLk79+vWTJM2fP19DhgxR79693RoOAAAAZzd8+HANHz5cktSzZ0/dd999PKcBAADAI5RowZm2bdvq448/dncWAAAAnKPly5dTeAQAAIDHKFHPx8DAQGVnZ7u2V65cqRtuuMFtoQAAAFAyX3/9dZnO6969ezknAQAAAAorUfGxdevWmjNnjux2u2u16zVr1iggIKDY86644opzTwgAAIAi9ejRo8Dq1qcX/isKCwMCAOAddqbtVEJ4gtUxgHNWouLj3LlzNXjwYF133XWSTk1Y/vdVFc+Eh1oAAAD3W758udURAACAG+xMpfiIyqFExccOHTpo+/bt2rFjhw4ePKgePXpo8uTJ6tOnj7vzAQAAoBhJSUlWRwAAAG5wJOeI1RGAclGi4qMk+fj4qHHjxmrcuLFGjx6tSy65RJ06dXJnNgAAAJyDAwcO6NChQ2rQoIGCg4OtjgMAAEohOz9bmSczFeIXYnUU4JyUaLXrf5o/fz6FRwAAAA/1wQcfqEmTJoqNjVW7du30448/SpKOHDmitm3basmSJdYGBAAAJXIw+6DVEYBzVqKejzNmzJBhGJo8ebJsNptmzJhx1nMMw9CUKVPOOSAAAABK7qOPPtIVV1yhzp07a8SIEZo2bZrrWLVq1VSnTh3Nnz9fgwYNsiwjAAAomZSsFCVGJFodAzgnJSo+Tps2TYZh6J577pGfn1+Bh9iiUHwEAACoeDNmzFD37t21fPlyHT16tNBzW+fOnTVv3jxrwgEAgFLZl7nP6gjAOSvRsGun0ymHwyE/Pz/X9tlerHQNAABQ8TZt2qShQ4cWebxGjRo6dOhQBSYCAABltTdzr9URgHNWpjkfAQAA4JmCgoKUlZVV5PGdO3cqOjq6AhMBAICy2ptB8RHer8SrXf/Tb7/9ph07digjI0OhoaFq0KCBmjRpUp7ZAAAAUEo9e/bUq6++qttvv73QsZSUFL300ku65JJLKj4YAAAotQOZB5TnyJOv3dfqKECZlbr4OG/ePD300EPat6/wvAP16tXT5MmTdf3115dLOAAAAJTOQw89pPPPP1/nnXeehgwZIsMwlJycrK+++krz5s2TaZqaOnWq1TEBAEAJOOXU/qz9iguLszoKUGalKj7eddddmjNnjqKiojR27Fi1aNFCISEhyszM1MaNG7VkyRKNGzdO27Zt08MPP+yuzAAAAChC48aN9e233+q2227TlClTZJqmHn30UUlSjx499Oyzzyo+Pt7akAAAoMT2Zeyj+AivVuLi4+rVqzVnzhxdfvnleu211xQcHFyozdy5czVy5Eg99thjGjJkiDp06FCuYQEAAHB2zZs31xdffKHjx49r+/btcjqdSkhIUExMjNXRAABAKe3LYsVreLcSFx9ffvll1apVSwsXLpS/v/8Z2wQHB+vNN99UQkKCXn75ZYqPAAAAFoqMjNR5551ndQwAAHAOWHQG3q7Excfvv/9eQ4YMKbLweFpAQICGDBmi5cuXn3M4AAAAFO+1114r03nXXHNNOScBAADusDt9t9URgHNS4uLjnj171LRp0xK1bdasWZkfhAEAAFByY8aMKbTPMAxJkmmaZ9wvUXwEAMBbHMg6oLTcNIX7h1sdBSiTEhcf09PTFRoaWqK2ISEhysjIKHMoAAAAlMwff/xRYDs1NVWjR49WeHi4brnlFjVu3FiStGXLFj399NPKyMjQq6++akVUAABQRhsObVBS3SSrYwBlUuLio2maBX5bXpL2AAAAcK+4uIKrX06bNk0xMTH67LPPCjy7tWzZUldeeaX69u2rJ554QvPnz6/oqAAAoIyW71lO8RFeq8TFR0l67LHH9Oabb5613b59rMQEABUtPz9fPj6l+rYOoBJasmSJHnrooTP+0thms+mKK67QfffdZ0EyAABQVr8d+02/Hf1NTaNLNh0e4ElK/FNqvXr1dOzYMR07dqzE7QEAFefo0aOqUaOG1TEAWMw0TW3ZsqXI47/++isjVAAA8EKv/fqaHur2kGyGzeooQKmUuPi4a9cuN8YAAJyr/fv3y2azKSYmxuooACw0aNAgPf/884qPj9dNN92koKAgSVJ2draef/55zZs3T1dffbXFKQEAQFHS0tK0ceNGbdu5TYcPHFZ4fLj8gv20M22nlu5cqoGJA62OCJQK4/MAoBLo0KGD9uzZo+DgYP36668KCAiwOhIAi8ydO1d//PGH7rrrLk2aNEm1atWSJB04cEB5eXnq2rWrnnzySWtDAgCAIm3cuFEXXHCBa7vn7J6KaX6qg8HbW95W8+jmSoxItCoeUGr01QWASiAlJUWHDh3S8ePH9fHHH+v48eNWRwJgkfDwcK1cuVLvv/++rr32WjVt2lRNmzbVtddeqyVLlujrr79WRESE1TEBAEAZ5Jv5enLdk8o4mWF1FKDEvL74+Oyzzyo+Pl4BAQHq1KmTVq9ebXUkALDU0aNHtWjRIi1dulS//PKLjh49yvxugAeo6GeWyy67TC+88II++eQTffLJJ3rhhRc0cODAMy5EAwAAvMehnEN6ct2TynfmWx0FKBGvLj6+/fbbmjBhgqZOnar169erdevW6tevnw4dOmR1NACwlGma2r9/v3744Qe99957+t///qdVq1bRIxKwCM8sAACgPG06uknzfpknp+m0OgpwVl5dfJwzZ45uuOEGXXvttWrWrJleeOEFBQUF6ZVXXrE6GgBUmG3btik9PV2SlJOTo4MHDxZqk5OTo82bN+vdd9/V+++/r9WrV2v37t3KysqiVyRQAXhmKZ2BAweqXr16CggIUK1atTRq1Cjt37/f6lgAAHiUr/d+rZc3vkwBEh7PaxecOXnypNatW6dJkya59tlsNvXp00fff//9Gc/Jzc1Vbm6uazszM1OSlJ+fr7y8PPcGBgA3WLBggcaNG+cqIObm5ur+++/XqFGj1Llz5zOek5KSopSUFNe2v7+/oqKiFBUVpcjISMXExCgqKoqhmUAR8vNPDXHKzMx0Ff6lU3+X/P39C7UvyzNLVdezZ0/de++9qlWrlvbt26e77rpLgwcP1nfffWd1NAAAPMoXf36h7Pxs/bv1v+Vr97U6DnBGXlt8PHLkiBwOh2rUqFFgf40aNbRly5YznjNr1ixNnz690P5OnTq5JSMAWOX111/X66+/bnUMoFJLSkoqsD116lRNmzatULuyPLNUdXfccYfrz3FxcZo4caIGDRqkvLw8+frygxUAAH/33f7vdCTniO5sf6ciAiKsjgMUUubiY3Jysl5++WXt3LlTx48fLzRszzAM7dix45wDlqdJkyZpwoQJru0NGzYoKSlJP/74o9q2bWthMgAovcmTJ+vxxx+X01l4mIVhGLrwwgs1aNCgc3qPRo0aqVOnTmfszQVUVT/99JM6deqklStXqk2bNq79/D1xj2PHjumNN95Qly5dii08/nOEy997pQIAUNn9fvx3Tfx2ou5od4caRzW2Og5QQJmKj48++qgmTpyoGjVqqGPHjmrZsmV55zqratWqyW63F5rb7ODBg6pZs+YZz/nncKiQkBBJko+PD79FB+B19uzZU+zx48ePy263n9N77Ny5U/Xq1VPDhg3P6TpAZeLjc+rxKSQkRGFhYWdtX5ZnlvJ04sQJvfPOO+rXr1+h3pee7J577tEzzzyj7OxsnX/++Vq6dGmx7Ysa4QIAQFVx/MRxTftumoY3Ha5LEi6RzfDqZT5QiZTpkzh37lz16tVLu3fv1pIlSzR//vwzvtzJz89P7du315dffuna53Q69eWXXxY5zxkAVCbx8fFFzstoGIaio6PLfG1fX181bdpUgwcPpvAInCOrn1nS0tJ07bXXavPmzW5/r+JMnDhRhmEU+/r7MPS7775bP/30kz777DPZ7XZdc801xS6QNWnSJKWlpbleZ/sFDQAAlZFTTr3x2xt6ePXDSstNszoOIKmMPR+PHz+uwYMHW95bcMKECRo9erQ6dOigjh076sknn1RWVpauvfZaS3MBQEUYO3asHnnkkTMeM01TXbt2LdX1AgICFBsbq7i4ONWrV8/y7/FAZWL1M4snrGp/5513asyYMcW2SUhIcP25WrVqqlatmho1aqSmTZuqbt26+uGHH4os2Ba14A8AAFXRhsMbdNfKu3RT65vUvkZ7q+OgiitT8bFjx47aunVreWcptWHDhunw4cO6//77lZKSojZt2ujTTz/1qiFFAFBWDRs21Msvv6zrrruuwLyPhmHommuuUfXq1Ys81zAMRUREqHr16qpRo4Zq1KihiIgIVrgG3MTqZxZP+LsdExOjmJiYMp17+nvc3+d0BAAAxUs/ma5H1jyipNgkXdPsGoX4hVgdCVVUmYqPzz33nC666CJ16NBBI0aMKO9MpTJ+/HiNHz/e0gwAYJUxY8aoW7duateunTIyMuTv76/77rvvjIXHyMhI1alTR7Vr11atWrXoIQRUMCufWTyh52NJ/fjjj1qzZo26deumyMhI7dixQ1OmTFFiYiJT6wAAUAYr967UhkMbNKrZKHWr080jfimJqqVMxcdhw4YpPz9fo0aN0r/+9S/FxsYWWtTAMAz9/PPP5RISAFC0Bg0aKCwsTBkZGQoMDHQVHu12u+rWrav4+HjFxsYqKCjI4qQArFCjRo0CvaM9XVBQkBYvXqypU6cqKytLtWrVUv/+/XXffffxSxMAAMoo7WSantnwjL7880uNbj5a9cPrWx0JVUiZio9RUVGKjo5mEQIA8EB2u10tW7ZUy5YtFRgYaHUcACiVli1b6quvvrI6BgAAldJvx37TpG8mqXtsdw1tPFTVAqtZHQlVQJmKjytWrCjnGACAc1GzZk3l5eUpJCREgwcPVnh4uNWRAAAAAHggU6ZW7l2p7/Z/p4vqX6TLEi9jPki4VZmKjwAAz7J27Vpt2LBB9evXp/AIAAAA4KzynHn6cMeH+vLPL3V5g8vVP76/fO2+VsdCJXROxce8vDxt2bJFaWlpZ5xLqHv37udyeQBAKdSsWZPCIwAAAIBSycrL0v9++5+SdyVrRJMR6ly7M4vSoFyVqfjodDo1adIkPffcc8rOzi6yncPhKHMwAEDpUHgEAAAAUFaHcw5r7k9z9dnuzzS2xVjVC6tndSRUEraynDRz5kw9+uijGjlypF577TWZpqnZs2frhRdeUKtWrdS6dWslJyeXd1YAQDECAgKsjgAAAADAy/127DdN/Gai3tn6jvKceVbHQSVQpp6PCxYs0NChQ/X888/r6NGjkqT27durV69eGj16tDp37qyvvvpKffr0KdewAAAAKJlVq1Zp/fr1Z5wexzAMTZkyxaJkAADA0zlMh97b9p42HNqgW9vdqprBNa2OBC9WpuLj3r179Z///EeS5O/vL0k6ceKEJMnPz08jR47UnDlzNHPmzHKKCQA4G9M0mZsFgI4dO6YBAwZo9erVru8LpmlKkuvPFB8BAEBJ7EjboUnfTNId7e9Qq5hWVseBlyrTsOvo6GhlZmZKkkJCQhQWFqadO3cWaHP8+PFzTwcAKDGbrUzf0gFUMnfffbd++eUXLVy4UDt37pRpmkpOTtbvv/+um266SW3atNH+/futjgkAALxEdn62Zv04S1/u/tLqKPBSZfpJtW3btlqzZo1ru2fPnnryySe1atUqffPNN3rqqafUunXrcgsJAACAklm2bJnGjRunYcOGKTQ0VNKpX040aNBAzz77rOLj43X77bdbGxIAAHgVp5x6ceOLemfrO64RFUBJlan4eOONNyo3N1e5ubmSpIceekipqanq3r27kpKSlJ6erscff7xcgwIAAODsUlNT1bx5c0mnRqhIco1YkaS+ffuyMCAAACiT97a9p2c3PKs8BwvRoOTKNOfjwIEDNXDgQNd2s2bNtGPHDq1YsUJ2u11dunRRVFRUuYUEAABAydSuXVspKSmSTs3NXb16df3888+67LLLJEn79u1jflgAAFBm3+z7Rvsz92tChwmqFljN6jjwAmUqPp5JeHi466EWAAAA1ujevbs+//xzTZ48WZI0bNgwPfLII7Lb7XI6nXryySfVr18/i1MCAICieMOw5h1pO3TP1/fo5jY3q12NdlbHgYcr8+oEDodDb731lsaNG6fLL79cGzdulCSlpaVp8eLFOnjwYLmFBAAAQMlMmDBBAwcOdE2PM23aNJ1//vmaMmWKpk6dqvbt2+upp56yOCUAAPin1NRUzZ07V1dddVWB/d8/8r1+//B3ncw8aVGyM8vMy9TDax7Wq5tfZRg2ilWmno+pqanq37+/Vq9erZCQEGVlZemWW26RdGpuoVtvvVXXXHONZs6cWa5hAQAAULyWLVuqZcuWru3IyEh98cUXSk1Nld1udy1CAwAAPEdycrKuvPJKZWdnF+r5eOLYCW347wZtfH2juk7qqprtalqU8syW/bFMW49t1R3t71BMUIzVceCBytTzceLEidq8ebOSk5O1c+fOAn8x7Ha7Bg8erGXLlpVbSAAAAJTMjBkztGnTpkL7IyIiFBoaqs2bN2vGjBkWJAMAAGeSnJysAQMGKCcnp+gh16bkyHXom+nfKGV9SsUGLIEdaTs06dtJ2n58u9VR4IHKVHxcsmSJbrnlFl144YVnnLC8UaNG2rVr17lmAwAAQClNmzZNv/zyS5HHN23apOnTp1dgIgAAUJTU1FRdeeWVMk1TTqez+MbmqfkgV81a5XFDsCUp42SGHvjhAe1I3WF1FHiYMhUf09LSVL9+/SKP5+XlKT8/v8yhAAAA4B7Hjh2Tn5+f1TEAAICkV199VdnZ2WcvPJ72Vw/IXV/tcmuusjrhOKHH1j6mXEeu1VHgQco052NiYqLWr19f5PHPPvtMzZo1K3MoAAAAlNzXX3+tFStWuLYXL16s7dsLD3tKTU3V22+/XWBOSAAAYA3TNPX000+X6dxtH21Tw0sbnnE0qtWOnTimb/d+q95xva2OAg9RpuLj9ddfr3vuuUc9evRQ796nPkyGYSg3N1czZszQp59+qhdffLFcgwIAAODMli9f7hpKbRiGFi9erMWLF5+xbbNmzcr8gw4AACg/R48e1Y4dZRiibEpZKVk6mXFS/mH+5R+sHOzN3Gt1BHiQMhUfb7vtNm3evFnDhw9XRESEJGnEiBE6evSo8vPzNW7cOF133XXlmRMAAABF+M9//qPx48fLNE1Vr15dL7zwgq688soCbQzDUFBQkAICAixKCQAA/i4zM/Oczs/PyffY4mNkQKTVEeBBylR8NAxDL730kkaPHq1FixZp27ZtcjqdSkxM1NChQ9W9e/fyzgkAAIAiBAYGKjAwUJL0xx9/KCYmRkFBQRanAgAAxQkJCTmn830Cy1TSqRDn1TjP6gjwIOf0Se3WrZu6detWXlkAAABwjuLi4qyOAAAASiA6OlqJiYnauXOnTNMs+YmGFFwjWH6hnrmAXIcaHVQrpJbVMeBBPLdMDgAAgLOqX79+qSebNwyjbHNMAQCAcmMYhm655RbdcccdpT7XUxebscmmq5pcZXUMeJgSFx8HDhxYqgsbhqEPPvig1IEAAABQcklJSR75wwcAADi70aNHa/LkycrJyZHT6Tz7CYZk97crvle827OVRd/4vqobWtfqGPAwJS4+Ll26VAEBAapZs2aJugPzEAwAAOB+CxYssDoCAAAoo4iICL333nsaMGCAbDZb8QVI41StpeukrvIL8bwh1+F+4RraeKjVMeCBSlx8rFOnjvbt26dq1appxIgRuuqqq1SzZk13ZgMAAAAAAKjU+vXrp48//lhXXnmlsrOzz9zh668ej10ndVXNdp5Zi7mu5XUK9g22OgY8kK2kDffs2aPly5erbdu2euCBB1S3bl316dNH8+fPV0ZGhjszAgAAoBTS09M1e/Zs9evXT23bttXq1aslSceOHdOcOXO0fft2ixMCAIC/69evn/bu3asnn3xStWvXLnAsICpAba5vo0sXXOqxhcek2CR1qtXJ6hjwUCUuPkqn5hSaN2+eUlJStGjRIkVHR2v8+PGqXr26rrjiCi1atEi5ubnuygoAAICz2Lt3r9q2bav7779fe/fu1S+//KLMzExJUlRUlObNm6enn37a4pQAAOCfIiIidOutt+qtt94qsL/zfzqr0cBG8gv2vKHWkhQXGqexLcZaHQMerFTFx9N8fX112WWX6e2339bBgwddBclhw4bpkUceKe+MAAAAKKG7775bGRkZ2rBhg1auXFlo6NagQYP0xRdfWJQOAACcjTetoVEtsJr+0/E/CvAJsDoKPFiZio+n5ebmKjk5WR988IF++uknBQQEKD4+vpyiAQAAoLQ+++wz3XrrrWrWrNkZf3hJSEjQnj17LEgGAAAqk1rBtXT/+ffr/9q787ioqv4P4J87Awzr4DaKpIIMCCoaCj5uKLhC0uKS64OCqVFmlqkpmgGK4uNWLo9LG5FLaqlkmVspmkhmPWmaG6ho7rghKqLMnN8fvrg/RxZBGWYGPu/Xa14655458x1eX8Z7v557Ti27WqYOhcxcqTecKaDX67F9+3Z8/fXXSE5Oxt27d9G1a1d8+umn6NWrFxwcuLgoERERkank5uZCo9EUe5xrdRMREdGzalm7JUb6jYSTjZOpQyELUOri4969e7Fq1Sp88803uHbtGtq0aYMZM2agX79+qFWLVW4iIiIic9CkSRPs3r0bUVFRRR5PTk5GixYtKjgqIiIiqgwcrB0wyGcQujToYlG3h5Nplbr4GBgYCDs7O/To0QMDBw6Ub68+e/Yszp49W+RrWrZsWS5BEhEREVHpvPvuu4iIiEDz5s3Rt29fAA/vXMnIyEBcXBzS0tKwbt06E0dJRERElkQBBTo36Iz+Pv2htlGbOhyyMGW67To3Nxfr1q3D+vXrS+wnhIAkSdDpdM8UHBERERGVTXh4OM6cOYMPPvgAkydPBgCEhoZCCAGFQoEZM2agZ8+epg2SiIiILEbbum3R37s/6jrWNXUoZKFKXXxMTEw0ZhxEREREVE4mT56MwYMHY926dcjIyIBer4dWq0Xv3r3h4eFh6vCIiIjIArSs3RL9vfvD3dnd1KGQhSt18TEiIsKYcRARERFROWrQoAHGjBlj6jCIiIjIwnhW80R443A0rtnY1KFQJVHm3a6JiIiIiIiIiKhycbJ2QniTcATVC+JmMlSuFKYO4GlkZmZi2LBhaNiwIezs7KDVahETE4P79++bOjQiIiKip/K05zcKhQJKpbLMDyIiIqICrV1aY27wXATXD2bhkcqdRc58PHbsGPR6PZYtWwZPT08cPnwYI0aMwJ07dzBnzhxTh0dERERUZk97fvPhhx8WukjYsGED/v77b4SEhMDb21sef9u2bfD19eWGM0RERAQAsFJYYWjToejSoAuLjmQ0Fll8DA0NRWhoqPzcw8MDx48fx5IlS1h8JCIiIov0tOc3sbGxBs8/+eQTXLlyBYcPH5YLjwWOHj2Kzp07w9XVtVxjJyIiIstTw7YGxvqPhWd1T1OHQpWcRd52XZTs7GzUqFGjxD55eXm4deuW/Lh9+3YFRUdERESVze3btw3OK/Ly8sr9PUpzfvO42bNnY9SoUYUKjwDQuHFjjBo1CrNmzSqvEImIiMgCNa7RGDM7zGThkSpEpSg+ZmRkYOHChYiKiiqxX0JCApydneVHUFBQBUVIRERElU1QUJDBeUVCQkK5jl/a85vHnTt3DtbW1sUet7a2xrlz5541PCIiIrJAEiT08eqDKW2mwFnlbOpwqIowq+LjxIkTIUlSiY9jx44ZvOb8+fMIDQ1F3759MWLEiBLHj46ORnZ2tvzYtWuXMT8OERERVWK7du0yOK+Ijo4usp+xz28e5+vri8WLF+P8+fOFjp07dw6LFy9Gs2bNyjQmERERWT5XB1fEtYtDP+9+UCq4+RxVHLNa83Hs2LGIjIwssY+Hh4f89wsXLqBTp05o164dPvnkkyeOr1KpoFKp5OeOjo5PHSsRERFVbY6OjlCr1U/sZ+zzm8d99NFHCAkJQaNGjdCrVy94ej68nSo9PR3JyckQQmDFihVlHpeIiIgsk7XCGq94voKe2p6wVhZ/dwSRsZhV8VGj0UCj0ZSq7/nz59GpUyf4+/sjMTERCoVZTeIkIiIiAlDx5zeBgYHYt28fpkyZgg0bNiA3NxcAYGdnh5CQEMTFxXHmIxERURURUCcAg5sMhouDi6lDoSrMrIqPpXX+/HkEBwfDzc0Nc+bMQVZWlnzMxYW/UERERGR5yvP8xtfXFxs2bIBer5fH0Wg0/M9aIiKiKuI5x+cQ2TQSzTXNTR0KkWUWH7dv346MjAxkZGSgXr16BseEECaKioiIiOjpGeP8RqFQoE6dOuURHhEREVkAlVKFvo36IrRhKKwVvMWazINF/vd3ZGQkhBBFPoiIiIgsEc9viIiI6Fk0q9UMc4Lm4CXtSyw8klmxyJmPREREREREREQEWElWGNR4EF5o+AIUkkXOMaNKjsVHIiIiIiIiIiIL5GzjjLEBY+Fdw9vUoRAVi8VHIiIiIiIiIiILU8uuFqa0mcKdrMnssfhIRERERERERGRBnG2cEdM2BrXta5s6FKIn4mIAREREREREREQWQikpMb7VeBYeyWJw5iMRERERERERkZlo1qwZfvnlF2w6tQn7Lu6Ds7uzwfE+Xn3gVd3LRNERlR2Lj0REREREREREZsLZ2RmBgYE4Ue0ETmWeMjhW2642Xta+bKLIiJ4Ob7smIiIiIiIiIrIAr3i+AmultanDICoTFh+JiIiIiIiIiMyck40TguoFmToMojJj8ZGIiIiIiIiIyMx1rt+Zsx7JIrH4SERERCZ3584dU4dAREREZNa6NOhi6hCIngqLj0RERGRyV65cgU6nM3UYRERERGapWa1mqONQx9RhED0VFh+JiIjI5HQ6Ha5cuWLqMIiIiIjMUuf6nU0dAtFTY/GRiIiIzMK5c+dMHQIRERGR2bGzskOAS4CpwyB6aiw+EhERkVlg8ZGIiIiosFYurWCjtDF1GERPzcrUARAREVHVFhAQgHPnzkGlUsHPzw8NGzY0dUhEREREZiOgDmc9kmXjzEciIiIyqUuXLuHy5cu4desWduzYgYyMDFOHRERERGQWFFCgWa1mpg6D6Jmw+EhERERmQ6fTYceOHdi9ezfy8vJMHQ4RERGRSbk7u8Pe2t7UYRA9E952TURERGbn2LFjOH36NHx9feHr6wuVSmXqkIiIiIgqnLaa1tQhED0zFh+JiIjILOXl5eGPP/7AwYMH0ahRIzRt2hTVq1c3dVhEREREFaaBUwNTh0D0zFh8JCIiIrOWn5+PI0eO4MiRI9BoNPD09ISHhwccHBxMHRoRERGRUbk6upo6BKJnxuIjERERWYysrCxkZWUhLS0NderUgaenJzw9PXlbNhEREVVKGjuNqUMgemYsPhIREZHJpKen49atWwCA3NxcXL58GXXq1CnVay9fvozLly/j119/RaNGjdCiRQs4OjoaM1wiIiKiClXDtoapQyB6ZtztmoiIiEwiMTERPj4+yMnJAfBwjceYmBjs3bu3TOPodDocPXoUa9aswa+//orc3FxjhEtERERUoRytHWGttDZ1GETPjMVHIiIiqnDp6ekYPnw49Hq9QbsQAl999RWuXLlS5jF1Oh3++usvrFq1Cr/88os8o5KIiIjIEqlValOHQFQuWHwkIiKiCvfFF19AkqQij0mShNTU1Kceu2Am5Nq1a3Hy5MmnHoeIiIjIlNQ2LD5S5cDiIxEREVW4zMxMCCGKPCaEwLVr1575PfR6PW7evPnM4xARERGZAouPVFmw+EhEREQVzt3dvcSZjzVr1nzm92jQoAFatGjxzOMQERERmYK9tb2pQyAqFyw+EhERUYV77bXXSpz52L59+2ca39vbG926dYNCwVMdS5aXlwc/Pz9IkoQDBw6YOhwiIqIKZae0M3UIROWCZ+RERERU4by8vPD5558XKg5KkoQhQ4agdu3aTzVu3bp10aNHDwQFBUGpVJZHqGRC77//PlxdXU0dBhERkUnYKG1MHQJRubAydQBERERUNUVGRiIwMBAtW7ZETk4OVCoVPvjggzIXHuvUqQN3d3d4eHjAycnJSNFSRdu8eTO2bduGdevWYfPmzaYOh4iIqMJZK61NHQJRuWDxkYiIiEzG09MTarUaOTk5sLOzK3Xh0dbWFk2aNIG3tzcLjpXQ5cuXMWLECCQnJ8PevnTrXeXl5SEvL09+fuvWLWOFR0REVCG44QxVFiw+EhERkcVwdHSEr68vGjduDGtrzgaojIQQiIyMxBtvvIGAgABkZmaW6nUJCQmIi4szbnBEREREVGZc85GIiIjMmlKphIeHB0JCQjBgwAA0b96chUcLNHHiREiSVOLj2LFjWLhwIXJychAdHV2m8aOjo5GdnS0//vnnHyN9EiIiIiIqC858JCIiIrNUrVo1NG3aFF5eXrCx4YLrlm7s2LGIjIwssY+Hhwd27NiBtLQ0qFQqg2MBAQH497//jaSkpCJfq1KpCr2GiIiIiEyPxUciIiIyK9bW1mjTpg18fHwgSZKpw6FyotFooNFonthvwYIFiI+Pl59fuHABISEhWLNmDVq3bm3MEImIiIjICFh8JCIiIpNycXFBfn4+VCoVlEolwsLCyrzjNVUeDRo0MHju6OgIANBqtahXr54pQiIiIiKiZ8DiIxEREZnU77//joyMDOzYsQMBAQEsPBIRERERVSIsPhIREZFZqFGjBpo1a2bqMMjMuLu7Qwhh6jCIiIiI6Clxt2siIiIyC35+flAoeGpCRERERFSZWPwZfl5eHvz8/CBJEg4cOGDqcIiIiOgpSJJUaK2/qoznN0RERERUWVh88fH999+Hq6urqcMgIiKiZ+Do6AgbGxtTh2E2eH5DRERERJWFRRcfN2/ejG3btmHOnDml6p+Xl4dbt27Jj9u3bxs5QiIiIioNJycnU4dQZrdv3zY4r8jLyyuXcct6fkNEREREZM4stvh4+fJljBgxAsuXL4e9vX2pXpOQkABnZ2f5ERQUZOQoiYiIqDRUKpWpQyizoKAgg/OKhISEZx7zac5viIiIiIjMmUUWH4UQiIyMxBtvvIGAgIBSvy46OhrZ2dnyY9euXUaMkoiIiEpLqVSaOoQy27Vrl8F5RXR09DON97TnN0RERERE5sysio8TJ06EJEklPo4dO4aFCxciJyenzCf5KpUKarVafjg6OhrpkxAREVFl5+joaHBeUdzsTWOf3xARERERmTMrUwfwqLFjxyIyMrLEPh4eHtixYwfS0tIKneQHBATg3//+N5KSkowYJREREVHp8fyGiIiIiKoysyo+ajQaaDSaJ/ZbsGAB4uPj5ecXLlxASEgI1qxZg9atWxszRCIiIqIy4fkNEREREVVlZlV8LK0GDRoYPC+4fVqr1aJevXqmCImIiIjomfD8hoiIiIgqI7Na85GIiIiIiIiIiIgqD4uc+fg4d3d3CCFMHQYRERFRueH5DRERERFVBpz5SEREREREREREREZRKWY+ViUXL17ExYsXTR1GpVW3bl3UrVvX1GFUWsxf42L+Ghfz17iYv0RERERElVOVLj7WrVsXMTExFnOxk5eXh4EDB2LXrl2mDqXSCgoKwtatW6FSqUwdSqXD/DU+5q/xMH+Nz5Ly19LOH6hyysvLQ0JCAqKjoy3i94boWTHnqaphzlNlIgkuJmQxbt26BWdnZ+zatUveAZPKz+3btxEUFITs7Gyo1WpTh1PpMH+Ni/lrXMxf42L+kjEIIZCTkwMnJydIkmTqcMpdwfcSf2+oqmDOU1XDnKfKpErPfLRUfn5+/PIxglu3bpk6hCqB+WsczN+Kwfw1DuYvGYMkSfx9JSIiIjID3HCGiIiIiIiIiIiIjILFRyIiIiIiIiIiIjIKFh8tiEqlQkxMDBebNRL+fI2LP1/j4s/XuPjzNS7+fInKjr83VNUw56mqYc5TZcINZ4iIiIiIiIiIiMgoOPORiIiIiIiIiIiIjILFRyIiIiIiIiIiIjIKFh+JiIiIiIiIiIjIKFh8pEovMjIS7u7upg4DkZGRcHR0NHUYRESIjY2FJEllfp05fJ8+SwzBwcEIDg4u13iIiIiIiKhkLD5Shfnyyy8hSRIkScKePXsKHRdCoH79+pAkCS+++OITxwsODpbHkyQJNWrUQKtWrfDFF19Ar9cb4yMQlZox812hUECtVsPb2xuDBw/G9u3bjfERiJ7o7t27iI2NRUpKiqlDeSoXLlxAbGwsDhw4YOpQiIiIiIgqLRYfqcLZ2tpi1apVhdp37dqFc+fOQaVSlXqsevXqYfny5Vi+fDmmTJmC/Px8DBs2DJMmTSrPkImemjHy/auvvsLs2bPx8ssvY+/evejevTv69++PBw8elGfoRE909+5dxMXFWXTxMS4ujsVHIiIiIiIjYvGRKlyPHj3wzTffID8/36B91apV8Pf3h4uLS6nHcnZ2Rnh4OMLDwzFmzBikpqaiXr16WLRoEQsxZBaMle9RUVGYPXs2Tpw4gZEjR2Lt2rX44IMPSny9Xq/HvXv3nupzEBEREVkSIQSEEKYOg4iIwOIjmcDAgQNx7do1g1tF79+/j2+//RaDBg16prHt7e3Rpk0b3LlzB1lZWcX2mzNnDtq1a4eaNWvCzs4O/v7++Pbbb4vsu2LFCvzrX/+Cvb09qlevjo4dO2Lbtm0GfTZv3owOHTrAwcEBTk5OCAsLw99//13keKdOnUJISAgcHBzg6uqKqVOnFjoxunPnDsaOHYv69etDpVLB29sbc+bM4QmUBTJmvgOAUqnEggUL0KRJEyxatAjZ2dnyMUmSMGrUKKxcuRJNmzaFSqXCli1bkJKSAkmSCs1Wy8zMhCRJ+PLLLw3av/nmGzRp0gS2trbw9fXFhg0bzGLtPyqdPXv2oFWrVrC1tYVWq8WyZcuK7LdixQr4+/vDzs4ONWrUwIABA/DPP/8UO25mZiY0Gg0AIC4uTl4WIDY2FgDw119/ITIyEh4eHrC1tYWLiwtee+01XLt2rdSxJycnw9fX1yD3iqLX6/Hxxx+jadOmsLW1RZ06dRAVFYUbN24UO3ZKSgpatWoFABg6dKgcf0H+//LLL+jbty8aNGgAlUqF+vXrY8yYMcjNzS11/EREVPEKzpd1Ot1TrW9MZGny8/ORm5uLixcv8jyFzBaLj1Th3N3d0bZtW3z99ddy2+bNm5GdnY0BAwY88/inTp2CUqlEtWrViu0zf/58tGjRAlOnTsWMGTNgZWWFvn37YtOmTQb94uLiMHjwYFhbW2Pq1KmIi4tD/fr1sWPHDrnP8uXLERYWBkdHR/znP//BlClTcOTIEQQGBiIzM9NgPJ1Oh9DQUNSpUwezZs2Cv78/YmJiEBMTI/cRQuDll1/GRx99hNDQUMybNw/e3t4YP3483nvvvWf++VDFMna+Aw8LkAMHDsTdu3cLrS+5Y8cOjBkzBv3798f8+fPLXDDctGkT+vfvD2trayQkJKB3794YNmwY/vjjj3KJnYzr0KFD6N69O65cuYLY2FgMHToUMTExhYp406dPx5AhQ+Dl5YV58+bh3Xffxc8//4yOHTvi5s2bRY6t0WiwZMkSAECvXr3kJTB69+4NANi+fTtOnTqFoUOHYuHChRgwYABWr16NHj16lOo/UrZt24Y+ffpAkiQkJCSgZ8+eGDp0KH7//fdCfaOiojB+/Hi0b98e8+fPx9ChQ7Fy5UqEhIQUOwu+cePGmDp1KgDg9ddfl+Pv2LEjgIdF97t37+LNN9/EwoULERISgoULF2LIkCFPjJ3IXFy9ehU//fSTqcMgqjDXr1/H5MmT0blzZ7Ro0QKzZs3CiRMnTB0WkdFcvXoVr732GgICAuDp6YmIiAjs3bvX1GERFSaIKkhiYqIAIPbv3y8WLVoknJycxN27d4UQQvTt21d06tRJCCGEm5ubCAsLe+J4QUFBwsfHR2RlZYmsrCxx9OhRMXr0aAFAvPTSS3K/iIgI4ebmZvDagvctcP/+feHr6ys6d+4st6WnpwuFQiF69eoldDqdQX+9Xi+EECInJ0dUq1ZNjBgxwuD4pUuXhLOzs0F7RESEACDefvttg3HCwsKEjY2NyMrKEkIIkZycLACI+Ph4gzFfffVVIUmSyMjIeOLPhkzPGPnetGnTYo9v2LBBABDz58+X2wAIhUIh/v77b4O+O3fuFADEzp07DdpPnz4tAIjExES5rVmzZqJevXoiJydHbktJSREACv1ekfnp2bOnsLW1FWfOnJHbjhw5IpRKpSg4BcjMzBRKpVJMnz7d4LWHDh0SVlZWBu2Pf59mZWUJACImJqbQez/+PSuEEF9//bUAIHbv3v3E2P38/ETdunXFzZs35bZt27YVyr1ffvlFABArV640eP2WLVsKtQcFBYmgoCD5+f79+wvlfEnxJyQkCEmSDH6eRObq6tWronbt2kKSJLFu3TpTh0NkdJcuXRLe3t6iSZMmom3btqJDhw5CkiQxaNAgcfbsWVOHR1TuLl26JLRarWjZsqWIiooSY8aMEZIkiV69eokrV66YOjwiA5z5SCbRr18/5Obm4ocffkBOTg5++OGHp7oF9dixY9BoNNBoNGjcuDEWLlyIsLAwfPHFFyW+zs7OTv77jRs3kJ2djQ4dOuB///uf3J6cnAy9Xo8PP/wQCoXhr0rBLRzbt2/HzZs3MXDgQFy9elV+KJVKtG7dGjt37iz03qNGjTIYZ9SoUbh//748M+HHH3+EUqnE6NGjDV43duxYCCGwefPmUv50yFyUV76XxNHREQCQk5Nj0B4UFIQmTZo81ZgXLlzAoUOHMGTIEHn8gjGbNWv29MFShdDpdNi6dSt69uyJBg0ayO2NGzdGSEiI/Hz9+vXQ6/Xo16+fwfeYi4sLvLy8ivweK41Hv2fv3buHq1evok2bNgBg8F1blIsXL+LAgQOIiIiAs7Oz3N6tW7dC+fzNN9/A2dkZ3bp1M4jf398fjo6O5RL/nTt3cPXqVbRr1w5CCPz5559PNSZRRcnNzcV7772Hu3fvQqvVYuDAgVi7dq2pwyIymlu3bqF///6oWbMmFi9ejN27d2P37t2IiYnB119/LX9vCy5hRJXEzZs38fLLL0Oj0WDBggVYunQp5s2bhxEjRmDPnj28/ZrMjpWpA6CqSaPRoGvXrli1ahXu3r0LnU6HV199tczjuLu749NPP4UkSbC1tYWXlxdq1679xNf98MMPiI+Px4EDB5CXlye3P7ouzMmTJ6FQKEos3KSnpwMAOnfuXORxtVpt8FyhUMDDw8OgrVGjRgAg36J95swZuLq6wsnJyaBf48aN5eNkWcor30ty+/ZtACiUNw0bNnzqMQtyzdPTs9AxT0/PJxaQyLSysrKQm5sLLy+vQse8vb3x448/Anj4PSaEKLIfAFhbWz/V+1+/fh1xcXFYvXo1rly5YnCsYG3S+/fv4/r16wbHNBqNnHvFxf5o7qWnpyM7O7vY7/7H37u0zp49iw8//BAbN24stHbko2urEpmj1NRUrFy5En379sWoUaMwbdo0DB48GMDD/xAjqmy+/fZbnDlzBlOnTkVgYCCUSiWEEBg/fjxWrlyJzz//HC+++CLXgKRKQa/XIzExEbdv38a0adPQrl07+VjNmjXh4uKC33//Hffv3wfw/+fyQgj+DpDJsPhIJjNo0CCMGDECly5dwgsvvFDiGo3FcXBwQNeuXcv0ml9++QUvv/wyOnbsiMWLF6Nu3bqwtrZGYmIiVq1aVaax9Ho9gIfrPha1a7GVFX/F6KHyyPeSHD58GEDhQuGjs7cKFHfSodPpyjUmsgx6vR6SJGHz5s1QKpWFjj8667Us+vXrh71792L8+PHw8/ODo6Mj9Ho9QkND5e/OvXv3olOnTgavO336dJnjr127NlauXFnk8YJNccpCp9OhW7duuH79OiZMmAAfHx84ODjg/PnziIyMlOMnMldqtRqDBg3CokWLoFarMWXKFOh0OhYgqVISQiAtLQ02NjZyjgMPz3fs7e3RpEkTZGZmFrqTiciSOTs749VXX8Urr7win9ufPHkSX331FbKysrBs2TIcOHAATk5OmDBhAkaMGMHCI5kUKyNkMr169UJUVBR+/fVXrFmzpsLed926dbC1tcXWrVuhUqnk9sTERIN+Wq0Wer0eR44cgZ+fX5FjabVaAEDt2rVLVQTV6/U4deqUPNsRgLwIdsFGIG5ubvjpp5+Qk5NjMIvt2LFj8nGyPMbMd51Oh1WrVsHe3h6BgYFP7F+9enUAKLSRyOOzagtyLSMjo9AYRbWRedFoNLCzs5NnaD/q+PHj8t+1Wi2EEGjYsKHBd1NpFHcSe+PGDfz888+Ii4vDhx9+KLc/Hsvzzz9vsBM8ALi4uMjfzU+KvSD+n376Ce3bty+y2P408R86dAgnTpxAUlKSwQYzj8dKZK4CAgKwYMEC+Q6M9u3bY9q0aZgyZYpBAZKzYKgykCQJc+bMkTfD0+l0UCqV8p/NmzdHWloacnJyYGtr+9Qz+onMhUKhwODBg6FUKuWi+sWLF9GxY0c0bNgQy5YtQ2hoKDZu3IglS5YgKioKNWvWlDcFJDIF/vcPmYyjoyOWLFmC2NhYvPTSSxX2vkqlEpIkGczyyszMRHJyskG/nj17QqFQYOrUqYVmuRSsFxMSEgK1Wo0ZM2YUuaNqVlZWobZFixYZjLNo0SJYW1ujS5cuAIAePXpAp9MZ9AOAjz76CJIk4YUXXijbByazYKx81+l0GD16NI4ePYrRo0cXutW/KG5ublAqldi9e7dB++LFiw2eu7q6wtfXF1999ZV8WzcA7Nq1C4cOHSqfD0BGo1QqERISguTkZJw9e1ZuP3r0KLZu3So/7927N5RKJeLi4gqthSWEwLVr14p9D3t7ewCFC9kFMygfH+/jjz82eF69enV07drV4GFra4u6devCz88PSUlJBrc4b9++HUeOHDEYo1+/ftDpdJg2bVqh+PLz84vdrRt4OHu+tPELITB//vxixyIyJwqFQp5hX5DHbdq0wbRp09CxY0cMHjwYa9askQuPmZmZcuGGyNLodDo4OzvLyyAVfIcX/FmzZk3cuXMHer1evispOzu7zDPticyJtbU1FAqF/B1/7949hIWFITExET169IBSqUSvXr3w/vvvw87ODj/88IOJI6aqjjMfyaQiIiIq/D3DwsIwb948hIaGYtCgQbhy5Qr++9//wtPTE3/99Zfcz9PTE5MnT8a0adPQoUMH9O7dGyqVCvv374erqysSEhKgVquxZMkSDB48GC1btsSAAQOg0Whw9uxZbNq0Ce3btzcoItra2mLLli2IiIhA69atsXnzZmzatAmTJk2Sbw186aWX0KlTJ0yePBmZmZl4/vnnsW3bNnz33Xd499135dmWZHmeNd+zs7OxYsUKAMDdu3eRkZGB9evX4+TJkxgwYECRxZeiODs7o2/fvli4cCEkSYJWq8UPP/xQ5Np4M2bMwCuvvIL27dtj6NChuHHjBhYtWgRfX1+DgiSZp7i4OGzZsgUdOnTAyJEjkZ+fj4ULF6Jp06by951Wq0V8fDyio6ORmZmJnj17wsnJCadPn8aGDRvw+uuvY9y4cUWOb2dnhyZNmmDNmjVo1KgRatSoAV9fX/j6+qJjx46YNWsWHjx4gOeeew7btm0r04VeQkICwsLCEBgYiNdeew3Xr1+XY38094KCghAVFYWEhAQcOHAA3bt3h7W1NdLT0/HNN99g/vz5xa6xqtVqUa1aNSxduhROTk5wcHBA69at4ePjA61Wi3HjxuH8+fNQq9VYt25dobUficyJXq8v8rZSSZLkGY4FBcgpU6ZgyJAhsLW1RUBAAKZPn45Vq1bhjz/+gLe3N2dDkkUoyPmilgx5lJWVFe7fvw8rKytIkoTr169j2bJlWL16NZKTk59pfWyiilTU97wkSdDr9WjYsCEWL14sF9jz8/NhZWWFrl27olGjRjh+/DgePHjAmb9kOhW8uzZVYYmJiQKA2L9/f4n93NzcRFhY2BPHCwoKEk2bNn1iv4iICOHm5mbQ9vnnnwsvLy+hUqmEj4+PSExMFDExMaKoX4kvvvhCtGjRQqhUKlG9enURFBQktm/fbtBn586dIiQkRDg7OwtbW1uh1WpFZGSk+P333w3icHBwECdPnhTdu3cX9vb2ok6dOiImJkbodDqD8XJycsSYMWOEq6ursLa2Fl5eXmL27NlCr9c/8fOSeTBGvgOQH46OjsLLy0uEh4eLbdu2FfkaAOKtt94q8lhWVpbo06ePsLe3F9WrVxdRUVHi8OHDAoBITEw06Lt69Wrh4+MjVCqV8PX1FRs3bhR9+vQRPj4+T4ybTG/Xrl3C399f2NjYCA8PD7F06dIiv+/WrVsnAgMDhYODg3BwcBA+Pj7irbfeEsePH5f7FPV9unfvXnl8ACImJkYIIcS5c+dEr169RLVq1YSzs7Po27evuHDhgkGfJ1m3bp1o3LixUKlUokmTJmL9+vVFxiCEEJ988onw9/cXdnZ2wsnJSTRr1ky8//774sKFC3KfoKAgERQUZPC67777TjRp0kRYWVkZ5P+RI0dE165dhaOjo6hVq5YYMWKEOHjwYJG/I0Sm9uj5wdChQ8WPP/4o8vPzi+3z66+/ipCQEGFvby86d+4sJEkSM2bMqLB4iZ5VaXK+wKpVq4QkSeLy5cviypUrYsaMGUKSJDF9+vSKCpfomZUl5x/te/DgQeHq6irGjx9v9BiJSiIJ8dg9UURERE/g5+cHjUbDNfCIiEysYHYL8HDNr1atWsHZ2RmLFi1Cx44dDWaFPTprZv369Rg5ciSuXLmCWbNmyTOci5tBSWQuypLzALBp0ya89NJL2LVrF/bs2YPJkycjPj4ekyZNAsAdgMn8lTXnC1y8eBGLFi3CsmXLkJSUhLCwsIoMm8gAzyyIiKhYDx48QH5+vkFbSkoKDh48iODgYNMERUREAB6udVdwQfr+++9j5MiRqFWrFo4ePYo333wTu3btMli3uqCoeOrUKWzduhVXrlzBvHnzWHgki1HWnC94jUKhQFJSkrykUkHhUa/Xs/BIZu1pch4A/ve//yEhIQGzZs3ChAkTWHgkk+PMRyIiKlZmZia6du2K8PBwuLq64tixY1i6dCmcnZ1x+PBh1KxZ09QhEhFVeb169cJvv/2G8PBwdO/eHVu3bsXGjRtx584dJCUlITg42KCouGrVKoSHh2P69OmIjo4GwMIjWZay5PzOnTvljR2Z82SpypLzS5YswQcffAAnJye89957GD16NADmPJkWi49ERFSs7OxsvP7660hNTUVWVhYcHBzQpUsXzJw5k5sfERGZgV27diE0NBRTp07FqFGjYGdnh7y8PBw4cACjRo3CpUuXkJSUhKCgIPnWvHv37mH37t3o3r07AF6QkmUpa87fvHkTTZs2xejRozFhwgQAzHmyLGXN+evXr2PRokVo3769XHhnzpOpsfhIRERERGSh1q9fj1dffRVbtmxB9+7d5d1MhRBIS0vDoEGD4ODggIULFxoUIAvwgpQsTVlyvn379lCpVMjLy4NKpQLAnCfLU5acb9euHWxtbQ3WMuW6pmQO+K1LRERERGQBdDpdoTZ3d3cAwNGjRwEA1tbW8jp2AQEBCA4OltcGS0tLA/DwQrQAizBkzp415/fv3w8ActFdCMGcJ7P2rDn/+++/AzD8nmfhkcwBv3mJiIiIiCxAQQElOTlZbqtTpw46duyImTNnIiUlBcDDC02dTgcbGxu0aNECXbp0QbVq1TB48GBcvXoVkiQVuUEBkbkpr5y3srLi7C+yCOWV8wqFArzJlcwJi49UZWRmZkKSJHz55ZemDoWozJi/REQEANOmTcOAAQMwa9YsAMBzzz2H4cOH4/79+5gwYQJ27twJSZKgVCpx6dIlpKamolmzZvj4449x48YNjBkzBgBnPJLlKK+cZ+GRLAVzniojK1MHQEREREREpdO7d2/s3bsXS5cuhU6nQ3R0NMLDw3Ht2jXEx8ejT58+ePvtt1GjRg0cOHAAGzduRFJSEtq2bYs2bdrgwIEDuH79OmrUqGHqj0JUKsx5qmqY81QZsfhIVYabmxtyc3NhbW1t6lCIyoz5S0RU9Ty6MYYQAnq9Hk2bNsX8+fPx9ttvY9myZRBCYNKkSXjnnXfg6uqKFStWYMaMGdDpdNBoNIiPj0f//v0BAI6OjsjLyzPlRyIqEXOeqhrmPFUV3O2aiIiIiMjMPLo+XVZWFjQajbxOo0KhwPHjxzF69GgcP34cUVFRiI6OBgDcunULV69exZ07d2BtbQ0fHx8AwN69ezF48GD4+flhxYoVsLOzM80HIyoGc56qGuY8VSVc7IUsSmxsLCRJwokTJxAeHg5nZ2doNBpMmTIFQgj8888/eOWVV6BWq+Hi4oK5c+fKry1qzbzIyEg4Ojri/Pnz6NmzJxwdHaHRaDBu3DiDncZSUlIgSZK8wG9JY166dAlDhw5FvXr1oFKpULduXbzyyivIzMw00k+FLAXzl4iISqvggvTf//43oqKikJmZCYVCIW8W4+3tjQULFsDNzQ2zZ8+W/81Qq9Xw8PBAs2bN5AvS7777DlOnTsXNmzcRHx/PC1IyS8x5qmqY81SVsPhIFql///7Q6/WYOXMmWrdujfj4eHz88cfo1q0bnnvuOfznP/+Bp6cnxo0bh927d5c4lk6nQ0hICGrWrIk5c+YgKCgIc+fOxSeffPJUsfXp0wcbNmzA0KFDsXjxYowePRo5OTk4e/bsU41HlQ/zl4iIipOfn2/wZ926dZGSkoL4+Hj5P40evTCdP38+7t27h48//hjTpk0rNF5sbCwmTpyIM2fOICUlBY0bN67Qz0P0JMx5qmqY81QlCSILEhMTIwCI119/XW7Lz88X9erVE5IkiZkzZ8rtN27cEHZ2diIiIkIIIcTp06cFAJGYmCj3iYiIEADE1KlTDd6nRYsWwt/fX36+c+dOAUDs3LnToN/jY964cUMAELNnzy6fD0yVCvOXiIhKq3fv3uKDDz4QQggxYcIEUb16dfHaa6+J06dPCyEe/vuRn58vhBAiODhYeHl5iRo1aojff//dYJx//vlHrF69Wpw7d65C4ycqK+Y8VTXMeapKuOEMWaThw4fLf1cqlQgICMC5c+cwbNgwub1atWrw9vbGqVOnnjjeG2+8YfC8Q4cOWL58eZnjsrOzg42NDVJSUjBs2DBUr169zGNQ5cf8JSKix+Xn58PK6uGpeUxMDPbu3YtXXnkFQgjMnDkTer0en332GQBg0qRJ0Gq1AIATJ07g/v37mDJlCqpVqwZ/f395TL1ej3r16skbERCZE+Y8VTXMearKWHwki9SgQQOD587OzrC1tUWtWrUKtV+7dq3EsWxtbaHRaAzaqlevjhs3bpQ5LpVKhf/85z8YO3Ys6tSpgzZt2uDFF1/EkCFD4OLiUubxqHJi/hIR0eMKLkj/+usvODk5YcCAARgwYIC8JtisWbMghEBSUhJu3Lghr+m1cuVKXLhwAZ06dUK9evUA/P/uqQU7qBKZI+Y8VTXMearKmKlkkZRKZanagIe7iJV1rMcV/IPwuEc39Sjw7rvv4sSJE0hISICtrS2mTJmCxo0b488//3zi+1DVwPwlIqKijB8/Hn5+fpg2bRrc3d1hY2MDvV4vf1/Pnj0b77zzDvbv3w9fX1/4+/tj2rRpePPNN+ULUgC8GCWLwZynqoY5T1UVZz4SlULB7ac3b940aD9z5kyR/bVaLcaOHYuxY8ciPT0dfn5+mDt3LlasWGHsUIkKYf4SEZkXIQQkSUJmZiYAwN3dHQDQvXt3/Pbbb0hLS0N6ejoAyBsP6HQ6KJVKTJ48GR06dMAff/yBCxcuoG3btujdu7fBuETmhjlPVQ1znsgQi49EpeDm5galUondu3ejZ8+ecvvixYsN+t29excKhQK2trZym1arhZOTE/Ly8ioqXCIDzF8iIvORnZ2NTz/9FOvXr8e+ffsghED79u0xYMAADBs2DHPmzMGbb76JxYsXIzAwEAMGDADwcJZLwW12HTt2RMeOHQ0uQguOEZkb5jxVNcx5osJYfCQqBWdnZ/Tt2xcLFy6EJEnQarX44YcfcOXKFYN+J06cQJcuXdCvXz80adIEVlZW2LBhAy5fviz/o0JU0Zi/RETm4fLly+jVqxeuXbuGunXrIi4uDkePHsWvv/6Kt99+Gz///DM+//xzfPbZZxg6dCjCw8NhbW2NPn36FDnT5dE2XpCSOWLOU1XDnCcqGouPRKW0cOFCPHjwAEuXLoVKpUK/fv0we/Zs+Pr6yn3q16+PgQMH4ueff8by5cthZWUFHx8frF27Fn369DFh9FTVMX+JiEzr0qVLaN26NVxdXTF16lT07dsXCoUCOp0O169fx4gRI5CcnIxr165h48aN+PTTT/HGG29g0KBBWLVqlXxhylvuyFIw56mqYc4TFU8ST9rNgIiIiIiIntqlS5fwr3/9C8899xzmz58Pf39/KJVK5OfnQ6lUyheZERERWL58OcLDw/HFF18gNTUV48ePx99//43ExET069fPxJ+EqHSY81TVMOeJSsbiIxERERGRkdy9exetW7fGsWPHkJKSgvbt2wMwXLurYJMB4OFmBDt37sR3332HHj16YOvWrZg4cSIOHjyI9PR0eHh4cEYMmTXmPFU1zHmiJ+OiAURERERERpKfn49OnTpBqVQiOTkZ9+/fB2C4dlfB7BgAmDt3LhwcHLBq1SoAQEhICOLj4/H1119Dq9XygpTMHnOeqhrmPNGTcc1HIiIiIiIjUavViI+Ph0qlwty5cyGEwNSpU2Fvb2/Qz8rq4Wl53bp14eLigoyMDHnWTFhYmNyPu52SuWPOU1XDnCd6MhYfiYiIiIiMSK1WY8qUKQAezniRJAlxcXEGF6YFGwzUqlULzs7OUCqVEEIUugjlBSlZAuY8VTXMeaKSsfhIRERERGRkj1+YAjC4MC24zW7nzp1IT09HbGysfGFKZImY81TVMOeJisfiIxERERFRBSjqwjQ2NhYODg4AgAsXLmDt2rWoX7++vGEB1/4iS8acp6qGOU9UNBYfqUqIjY1FXFycyf9XqSCOrKws1KpVy6SxEBERUcUr6sJ0xowZyMnJQWJiIr766ivMnTsX/v7+pgyTqNww56mqYc4TFcbiIxnd2rVr0b9/f6xfvx69evUyOPb888/jr7/+wo4dO9CpUyeDYw0aNEC9evWwd+/eYseOjIxEUlKS/NzJyQkNGzbEkCFDMGrUKKhUqvL9MERPUJH57uDggNq1a6Nly5YYOHAgevXqxTViiIgswOMXpnl5eahVqxZiY2Mxffp0vPHGGwD+f30wIkvHnKeqhjlPZIjFRzK6wMBAAMCePXsMijG3bt3C4cOHYWVlhdTUVINizD///IN//vkHAwYMeOL4KpUKn332GQDg5s2bWLduHcaNG4f9+/dj9erV5fxpiEpWkfmem5uLM2fO4Pvvv8err76K4OBgfPfdd1Cr1eX8qYiIqLwVXJgqlUrMmjULADB9+nRER0cD4G6nVPkw56mqYc4T/T8WH8noXF1d0bBhQ+zZs8egPS0tDUII9O3bt9CxgucFhZySWFlZITw8XH4+cuRItG7dGmvWrMG8efPg6upaDp+CqHQqOt8BID4+HjNnzkR0dDRGjBiBNWvWFPt6IQTu3bsHOzu70n4kIiIyErVajejoaDx48ABarRYjR44EwAtSqryY81TVMOeJHmK2U4UIDAzEn3/+idzcXLktNTUVTZs2xQsvvIBff/0Ver3e4JgkSfIivGWhUCgQHBwMAMjMzCy2X2JiIjp37ozatWtDpVKhSZMmWLJkSZF9N2/ejKCgIDg5OUGtVqNVq1ZYtWqVQZ99+/YhNDQUzs7OsLe3R1BQEFJTU4sc7+rVq+jXrx/UajVq1qyJd955B/fu3TPok5+fj2nTpkGr1UKlUsHd3R2TJk1CXl5e6X8YZBIVme8FJk6ciO7du+Obb77BiRMn5HZ3d3e8+OKL2Lp1KwICAmBnZ4dly5YhMzMTkiThyy+/LDSWJEmIjY01aEtJSUFAQABsbW2h1WqxbNkyxMbG8jYRIqJn5OzsjBkzZvCClKoM5jxVNcx5IhYfqYIEBgbiwYMH2Ldvn9yWmpqKdu3aoV27dsjOzsbhw4cNjvn4+KBmzZpP9X4nT54EgBJfv2TJEri5uWHSpEmYO3cu6tevj5EjR+K///2vQb8vv/wSYWFhuH79OqKjozFz5kz4+flhy5Ytcp8dO3agY8eOuHXrFmJiYjBjxgzcvHkTnTt3xm+//Vbovfv164d79+4hISEBPXr0wIIFC/D6668b9Bk+fDg+/PBDtGzZEh999BGCgoKQkJBQqltzybQqOt8LDB48GEIIbN++3aD9+PHjGDhwILp164b58+fDz8+vTOP++eefCA0NxbVr1xAXF4dhw4Zh6tSpSE5OfqZ4iYjooUfXqOYFKVUFzHmqapjzVNXxtmuqEI+ugxccHIz8/Hzs27cPERER0Gq1qFOnDvbs2YPmzZsjJycHhw4dwmuvvVbq8a9evQoAyM7Oxtq1a5GcnIzmzZvD29u72Nfs2rXL4NbTUaNGITQ0FPPmzcNbb70ljzd69Gj861//QkpKCmxtbeX+BTtnCyHwxhtvoFOnTti8ebM8EywqKgpNmzbFBx98gG3bthm8d8OGDfHdd98BAN566y2o1WosXrwY48aNQ/PmzXHw4EEkJSVh+PDh+PTTTwE8vJ28du3amDNnDnbu3FlowxIyH8bO9+L4+voC+P/ie4GMjAxs2bIFISEhcltJs4IfFxMTA6VSidTUVHkZg379+qFx48bPHDMRERERERFVbiy5U4Vo3LgxatasKa9td/DgQdy5cwft2rUDALRr106+RTktLQ06na5U698BwJ07d6DRaKDRaODp6YlJkyahbdu22LBhQ4mve7TwmJ2djatXryIoKAinTp1CdnY2AGD79u3IycnBxIkTDQqPAOQi44EDB5Ceno5Bgwbh2rVruHr1Kq5evYo7d+6gS5cu2L17t8EttgDk4maBt99+GwDw448/Gvz53nvvGfQbO3YsAGDTpk1P/sGQyRgz30vi6OgIAMjJyTFob9iwoUHhsSx0Oh1++ukn9OzZ02D9VE9PT7zwwgtPHywRERERERFVCZz5SBVCkiS0a9dOLsSlpqaidu3a8PT0BPCwGLNo0SIAkIsypS3G2Nra4vvvvwfwcDp7w4YNUa9evSe+LjU1FTExMUhLS8Pdu3cNjmVnZ8PZ2VmeQVYwo6wo6enpAICIiIhi+2RnZ6N69erycy8vL4PjWq0WCoVCno125swZKBQK+edTwMXFBdWqVcOZM2ee+PnIdIyZ7yW5ffs2AMDJycmgvWHDhk895pUrV5Cbm1soFwEU2UZERERERET0KBYfqcIEBgbi+++/x6FDh+T17wq0a9cO48ePx/nz57Fnzx64urrCw8OjVOMqlUp07dq1TLGcPHkSXbp0gY+PD+bNm4f69evDxsYGP/74Iz766KNCMxVLUtB39uzZxa6lVzAjrTjFbdrBzTwsl7HyvSQF60g+XhQsamfr4nJLp9M9cxxEREREREREBVh8pArz6Dp4qampePfdd+Vj/v7+UKlUSElJwb59+9CjRw+jxvL9998jLy8PGzduRIMGDeT2nTt3GvTTarUAHhZ1ipvlVdBHrVaXugianp5uMBstIyMDer0e7u7uAAA3Nzfo9Xqkp6cbrKt3+fJl3Lx5E25ubqV6HzIdU+T78uXLIUkSunXr9sS+BTNxb968adD++Kza2rVrw9bWFhkZGYXGKKqNiIiIiIiI6FFc85EqTEBAAGxtbbFy5UqcP3/eYCaYSqVCy5Yt8d///hd37twpl1tQS6JUKgH8/6YxwMNboxMTEw36de/eHU5OTkhISMC9e/cMjhW81t/fH1qtFnPmzJFve31UVlZWobbHd9ReuHAhAMhr6BUUoz7++GODfvPmzQMAhIWFlfwByeQqOt9nzpyJbdu2oX///oVu6y+KWq1GrVq1sHv3boP2xYsXGzwvmFmcnJyMCxcuyO0ZGRnYvHnzM8dNRERERERElRtnPlKFsbGxQatWrfDLL79ApVLB39/f4Hi7du0wd+5cAOWz/l1JunfvDhsbG7z00kuIiorC7du38emnn6J27dq4ePGi3E+tVuOjjz7C8OHD0apVKwwaNAjVq1fHwYMHcffuXSQlJUGhUOCzzz7DCy+8gKZNm2Lo0KF47rnncP78eezcuRNqtVpek7LA6dOn8fLLLyM0NBRpaWlYsWIFBg0ahOeffx4A8PzzzyMiIgKffPIJbt68iaCgIPz2229ISkpCz549udO1BTBWvufn52PFihUAgHv37uHMmTPYuHEj/vrrL3Tq1AmffPJJqccaPnw4Zs6cieHDhyMgIAC7d+/GiRMnCvWLjY3Ftm3b0L59e7z55pvQ6XRYtGgRfH19ceDAgVK/HxEREREREVU9nPlIFaqgyFJw2+mj2rdvD+DhZhkFRThj8fb2xrfffgtJkjBu3DgsXboUr7/+Ot55551CfYcNG4aNGzdCrVZj2rRpmDBhAv73v/8Z7PQbHByMtLQ0BAQEYNGiRXj77bfx5ZdfwsXFBWPGjCk05po1a6BSqTBx4kRs2rQJo0aNwueff27Q57PPPkNcXBz279+Pd999Fzt27EB0dDRWr15d/j8QMgpj5HteXh4GDx6MwYMH45133sGKFSvg5eWFb7/9Fj/99FOhzWZK8uGHH2LYsGH49ttv8f7770On0xU5m9Hf3x+bN29G9erVMWXKFHz++eeYOnUqunTpUmgXeCIiIiIiIqJHSeLR+06JiIhKqWfPnvj777/lHd+JiIiIiIiIHseZj0RE9ES5ubkGz9PT0/Hjjz8iODjYNAERERERERGRReDMRyIieqK6desiMjISHh4eOHPmDJYsWYK8vDz8+eefpdrghoiIiIiIiKombjhDRERPFBoaiq+//hqXLl2CSqVC27ZtMWPGDBYeiYiIiIiIqESc+UhERERERERERERGwTUfiYiIiIiIiIiIyChYfCQiIiIiIiIiIiKjYPGRiIiIiIiIiIiIjILFRyIiIiIiIiIiIjIKFh+JiIiIiIiIiIjIKFh8JCIiIiIiIiIiIqNg8ZGIiIiIiIiIiIiMgsVHIiIiIiIiIiIiMor/A+jvLaMGlxZ0AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f_forest_drug_profiles, axes = plt.subplots(2, 2, figsize=[15, 14])\n", + "contrast_labels1 = ['Drug1', 'Drug2', 'Drug3']\n", + "unpaired_delta_01.mean_diff.plot( \n", + " contrast_label='Mean Diff',\n", + " fig_size = (5, 5),\n", + " raw_marker_size = 1,\n", + " es_marker_size = 5,\n", + " color_col='Genotype',\n", + " ax = axes[0,0]\n", + ")\n", + "\n", + "unpaired_delta_02.mean_diff.plot( \n", + " contrast_label='',\n", + " fig_size = (5, 5),\n", + " raw_marker_size = 1,\n", + " es_marker_size = 5,\n", + " color_col='Genotype',\n", + " ax = axes[0,1]\n", + ")\n", + "\n", + "\n", + "unpaired_delta_03.mean_diff.plot( \n", + " contrast_label='Mean Diff',\n", + " fig_size = (5, 5),\n", + " raw_marker_size = 1,\n", + " es_marker_size = 5,\n", + " color_col='Genotype',\n", + " ax = axes[1,0]\n", + ")\n", + "forest_plot(contrasts, contrast_labels = contrast_labels1 , ax = axes[1,1], )\n", + "axes[0,0].set_title('Drug1', fontsize = 12);\n", + "axes[0,0].set_ylabel('')\n", + "axes[0,1].set_ylabel('')\n", + "axes[0,1].set_title('Drug2', fontsize = 12);\n", + "axes[1,0].set_title('Drug3', fontsize = 12);\n", + "axes[0,1].set_ylabel('')\n", + "axes[1,1].set_title('Forest plot', fontsize = 12) ;\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a0aa6992-cebb-4bed-998a-1a5c11f67fb8", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/nbs/tutorials/forest_plot.ipynb b/nbs/tutorials/forest_plot.ipynb deleted file mode 100644 index f6492b12..00000000 --- a/nbs/tutorials/forest_plot.ipynb +++ /dev/null @@ -1,805 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "cf1612f8", - "metadata": {}, - "source": [ - "# Forest Plot\n", - "\n", - "> Explanation of how to use forest_plot for contrast objects e.g delta-delta and mini-meta.\n", - "\n", - "- order: 7" - ] - }, - { - "cell_type": "markdown", - "id": "cfdb7e31", - "metadata": {}, - "source": [ - "Since v2024.03.29, DABEST supports the comparison and analysis of different delta-delta analysis through a function called \"forest_plot\". \n", - "\n", - "Many experimental designs investigate the effects of two interacting independent variables on a dependent variable. The delta-delta effect size enables us distill the net effect of the two variables. \n", - "\n", - "\n", - "Consider 3 experiments where in each of the experiment we test the efficacy of 3 drugs named ``Drug1``, ``Drug2`` , and ``Drug3`` on a disease-causing mutation M based on disease metric Y. The greater the value Y has, the more severe the disease phenotype is. Phenotype Y has been shown to be caused by a gain-of-function mutation M, so we expect a difference between wild type (W) subjects and mutant subjects (M). Now, we want to know whether this effect is ameliorated by the administration of Drug treatment. We also administer a placebo as a control. In theory, we only expect Drug to have an effect on the M group, although in practice, many drugs have non-specific effects on healthy populations too." - ] - }, - { - "cell_type": "markdown", - "id": "7a202204", - "metadata": {}, - "source": [ - "| | Wildtype | Mutant |\n", - "|-------|---------|----------|\n", - "| Drug1 | XD, W | XD, M |\n", - "| Placebo | XP, W | XP, M |" - ] - }, - { - "cell_type": "markdown", - "id": "c75e54ab", - "metadata": {}, - "source": [ - "| | Wildtype | Mutant |\n", - "|-------|---------|----------|\n", - "| Drug2 | XD, W | XD, M |\n", - "| Placebo | XP, W | XP, M |" - ] - }, - { - "cell_type": "markdown", - "id": "e1b09711", - "metadata": {}, - "source": [ - "| | Wildtype | Mutant |\n", - "|-------|---------|----------|\n", - "| Drug3 | XD, W | XD, M |\n", - "| Placebo | XP, W | XP, M |" - ] - }, - { - "cell_type": "markdown", - "id": "be4d9084", - "metadata": {}, - "source": [ - "There are two ``Treatment`` conditions, ``Placebo`` (control group) and ``Drug`` (test group). There are two ``Genotype``\\s: ``W`` (wild type population) and ``M`` (mutant population). Additionally, each experiment was conducted twice (``Rep1`` and ``Rep2``). We will perform several analyses to visualise these differences in a simulated dataset. " - ] - }, - { - "cell_type": "markdown", - "id": "9ec30d58", - "metadata": {}, - "source": [ - "## Load libraries" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0fdd66d0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "We're using DABEST v2024.03.29\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import dabest\n", - "from dabest.forest_plot import forest_plot\n", - "import scipy as sp\n", - "import matplotlib as mpl\n", - "import matplotlib.pyplot as plt\n", - "# %matplotlib inline\n", - "import seaborn as sns\n", - "import dabest \n", - "print(\"We're using DABEST v{}\".format(dabest.__version__))" - ] - }, - { - "cell_type": "markdown", - "id": "96a35aa6", - "metadata": {}, - "source": [ - "## Simulate datasets for the contrast objects" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9c6e3f02", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "from scipy.stats import norm\n", - "\n", - "def create_delta_dataset(N=20, \n", - " seed=9999, \n", - " second_quarter_adjustment=3, \n", - " third_quarter_adjustment=-0.1):\n", - " np.random.seed(seed) # Set the seed for reproducibility\n", - "\n", - " # Create samples\n", - " y = norm.rvs(loc=3, scale=0.4, size=N*4)\n", - " y[N:2*N] += second_quarter_adjustment\n", - " y[2*N:3*N] += third_quarter_adjustment\n", - "\n", - " # Treatment, Rep, Genotype, and ID columns\n", - " treatment = np.repeat(['Placebo', 'Drug'], N*2).tolist()\n", - " rep = ['Rep1', 'Rep2'] * (N*2)\n", - " genotype = np.repeat(['W', 'M', 'W', 'M'], N).tolist()\n", - " id_col = list(range(0, N*2)) * 2\n", - "\n", - " # Combine all columns into a DataFrame\n", - " df = pd.DataFrame({\n", - " 'ID': id_col,\n", - " 'Rep': rep,\n", - " 'Genotype': genotype,\n", - " 'Treatment': treatment,\n", - " 'Y': y\n", - " })\n", - "\n", - " return df\n", - "\n", - "# Generate the first dataset with a different seed and adjustments\n", - "df_delta2_drug1 = create_delta_dataset(seed=9999, second_quarter_adjustment=1, third_quarter_adjustment=-0.5)\n", - "\n", - "# Generate the second dataset with a different seed and adjustments\n", - "df_delta2_drug2 = create_delta_dataset(seed=9999, second_quarter_adjustment=0.1, third_quarter_adjustment=-1)\n", - "\n", - "# Generate the third dataset with the same seed as the first but different adjustments\n", - "df_delta2_drug3 = create_delta_dataset(seed=9999, second_quarter_adjustment=3, third_quarter_adjustment=-0.1)" - ] - }, - { - "cell_type": "markdown", - "id": "556f9b89", - "metadata": {}, - "source": [ - "### Creating contrast objects required for forest_plot" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "09c54fb9", - "metadata": {}, - "outputs": [], - "source": [ - "unpaired_delta_01 = dabest.load(data = df_delta2_drug1, \n", - " x = [\"Genotype\", \"Genotype\"], \n", - " y = \"Y\", delta2 = True, \n", - " experiment = \"Treatment\")\n", - "unpaired_delta_02 = dabest.load(data = df_delta2_drug2, \n", - " x = [\"Genotype\", \"Genotype\"], \n", - " y = \"Y\", delta2 = True, \n", - " experiment = \"Treatment\")\n", - "unpaired_delta_03 = dabest.load(data = df_delta2_drug3, \n", - " x = [\"Genotype\", \"Genotype\"], \n", - " y = \"Y\", \n", - " delta2 = True, \n", - " experiment = \"Treatment\")\n", - "paired_delta_01 = dabest.load(data = df_delta2_drug1, \n", - " paired = \"baseline\", id_col=\"ID\",\n", - " x = [\"Treatment\", \"Rep\"], y = \"Y\", \n", - " delta2 = True, experiment = \"Genotype\")\n", - "paired_delta_02 = dabest.load(data = df_delta2_drug2,\n", - " paired = \"baseline\", id_col=\"ID\",\n", - " x = [\"Treatment\", \"Rep\"], y = \"Y\", \n", - " delta2 = True, experiment = \"Genotype\")\n", - "paired_delta_03 = dabest.load(data = df_delta2_drug3,\n", - " paired = \"baseline\", id_col=\"ID\",\n", - " x = [\"Treatment\", \"Rep\"], y = \"Y\", \n", - " delta2 = True, experiment = \"Genotype\")\n", - "contrasts = [unpaired_delta_01, unpaired_delta_02, unpaired_delta_03]\n", - "paired_contrasts = [paired_delta_01, paired_delta_02, paired_delta_03]" - ] - }, - { - "cell_type": "markdown", - "id": "50d94de3", - "metadata": {}, - "source": [ - "## Visualize the delta delta plots for each datasets " - ] - }, - { - "cell_type": "markdown", - "id": "f4315e6f", - "metadata": {}, - "source": [ - "To create a delta-delta plot, you simply need to set ``delta2=True`` in the \n", - "``dabest.load()`` function and ``mean_diff.plot()``" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "36a5e3fd", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "''' \n", - "In this case,``x`` needs to be declared as a list consisting of 2 elements, unlike most cases where it is a single element. \n", - "The first element in ``x`` will represent the variable plotted along the horizontal axis, and the second one will determine the \n", - "color of dots for scattered plots or the color of lines for slope graphs. We use the ``experiment`` input to specify the grouping of the data.\n", - "'''\n", - "f1 = unpaired_delta_01.mean_diff.plot(\n", - " contrast_label='Mean Diff',\n", - " fig_size = (5, 5),\n", - " raw_marker_size = 5,\n", - " es_marker_size = 5,\n", - " color_col='Genotype'\n", - ");\n", - "\n", - "\n", - "f2 = unpaired_delta_02.mean_diff.plot( \n", - " contrast_label='Mean Diff',\n", - " fig_size = (5, 5),\n", - " raw_marker_size = 5,\n", - " es_marker_size = 5,\n", - " color_col='Genotype'\n", - ");\n", - "\n", - "\n", - "f3 = unpaired_delta_03.mean_diff.plot( \n", - " contrast_label='Mean Diff',\n", - " fig_size = (5, 5),\n", - " raw_marker_size = 5,\n", - " es_marker_size = 5,\n", - " color_col='Genotype'\n", - ");\n", - "\n", - "p1 = paired_delta_01.mean_diff.plot();\n", - "p2 = paired_delta_02.mean_diff.plot();\n", - "p3 = paired_delta_03.mean_diff.plot();\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "bb289b05", - "metadata": {}, - "source": [ - "# Plot all the delta-delta plots into a forest plot \n", - "### For comparisons of differen ``Durg`` effects" - ] - }, - { - "cell_type": "markdown", - "id": "982afbdb", - "metadata": {}, - "source": [ - "Important Inputs:\n", - "\n", - "1. A list of contrast objects \n", - "\n", - "2. contrast_labels e.g ``['Dug1', 'Drug2', 'Drug3']``\n", - "\n", - "3. title: default is ``\"ΔΔ Forest\"``\n", - "\n", - "4. y_label: default as ``\"value\"``, please change it according to your measurement units/ types\n", - "\n", - "5. contrast_type ``delta-delt`` and ``mini-meta`` are supported\n", - "\n", - "6. Which effect size to plot (default is ``delta-delta mean-diff``, but you can specify which effect size you want to use)\\n\n", - "\n", - "7. Axes to put the plot into existing figures \\n\n", - "\n", - "8. The argument ``horizontal`` is a boolean input (``True``/ ``False``) \\n\n", - "\n", - " default is ``vertical``, (``False``) that changes the default orientation, \\n\n", - " \n", - " if ``True`` the delta-delta values will be reflected on the x axis and the delta plots will be plotted horizontally. \\n\n", - "9. Plot kwargs are supported such as violin plot kwargs, fontsize, marker_size, ci_line_width\n", - "\n", - "output:\n", - "\n", - "- A plot with horizontally/vertically laid out half violin plots of each of the prescribed delta bootstraps. \n" - ] - }, - { - "cell_type": "markdown", - "id": "06b93055", - "metadata": {}, - "source": [ - "#### Vertical (default) Layout" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c4a7e5a4", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "forest1_vertical = forest_plot(contrasts, \n", - " contrast_labels =['Drug1', 'Drug2', 'Drug3']);" - ] - }, - { - "cell_type": "markdown", - "id": "b3eee52e", - "metadata": {}, - "source": [ - "#### Horizontal Layout" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d8313860", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "forest1_horizontal = forest_plot(contrasts, \n", - " contrast_labels =['Drug1', 'Drug2', 'Drug3'],\n", - " horizontal=True);\n" - ] - }, - { - "cell_type": "markdown", - "id": "dc49a603", - "metadata": {}, - "source": [ - "Additiionall, for aesthetics and labels, you can use:\n", - "\n", - "1. The ``custom_palette`` argument to specify the colors you would like to indicate each experiment in a list \\n\n", - " e.g [\"gray\", \"blue\", \"green\" ].\n", - " \n", - "2. Additionally. the argument ``ylabel`` should be specified to specify the unit or \n", - " the exact name of the measurement of experiments, for example \"delta_deltas\", the default is \"value\"" - ] - }, - { - "cell_type": "markdown", - "id": "4100ba2c", - "metadata": {}, - "source": [ - "#### Changing ``custom_palette`` and ``effect_size``" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "23c9446e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "forest2_vertical = forest_plot(paired_contrasts, \n", - " contrast_labels =['Drug1', 'Drug2', 'Drug3'], \n", - " custom_palette= ['gray', 'blue', 'green' ], \n", - " effect_size='delta_g');" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d5f2a4dd", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "forest2_horizontal = forest_plot(paired_contrasts, \n", - " contrast_labels =['Drug1', 'Drug2', 'Drug3'], \n", - " custom_palette= ['gray', 'blue', 'green' ],\n", - " horizontal=True, effect_size='delta_g');\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "6787aa97", - "metadata": {}, - "source": [ - "### Using existing axis \"ax\" as the optional input to plot forest_plot \\n\n", - "\n", - "\n", - "\n", - "With other kinds of dabest plots side by side or in other possible orientations, \\n\n", - "\n", - "We will specify the x_labels that we want to indicate in a list of strings and parse it as the argument contrast_labels, \\n\n", - "\n", - "for example ['Drug1', 'Drug2', 'Drug3']." - ] - }, - { - "cell_type": "markdown", - "id": "180cae3a", - "metadata": {}, - "source": [ - "### Two forest plots plotted together in one axis" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6e0fbdb1", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Paired')" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "f_forest_drug_profiles, axes = plt.subplots(1, 2, figsize = [8, 4])\n", - "['Drug1', 'Drug2', 'Drug3']\n", - "forest_plot(contrasts, contrast_labels = ['Drug1', 'Drug2', 'Drug3'], ax = axes[0])\n", - "forest_plot(paired_contrasts, contrast_labels = ['Drug1', 'Drug2', 'Drug3'], ax = axes[1])\n", - "axes[0].set_title('Unpaired', fontsize = 20)\n", - "axes[1].set_ylabel('')\n", - "axes[1].set_title('Paired', fontsize = 20)\n" - ] - }, - { - "cell_type": "markdown", - "id": "829f0d03", - "metadata": {}, - "source": [ - "### Four different plots, 3 ``delta delta`` and 1 ``forest plot``" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0e0d544f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.0, 1.0, 'Forest plot')" - ] - }, - "execution_count": null, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "f_forest_drug_profiles, axes = plt.subplots(2, 2, figsize=[18, 18])\n", - "contrast_labels1 = ['Drug1', 'Drug2', 'Drug3']\n", - "unpaired_delta_01.mean_diff.plot( \n", - " contrast_label='Mean Diff',\n", - " fig_size = (5, 5),\n", - " raw_marker_size = 5,\n", - " es_marker_size = 5,\n", - " color_col='Genotype',\n", - " ax = axes[0,0]\n", - ")\n", - "\n", - "unpaired_delta_02.mean_diff.plot( \n", - " contrast_label='',\n", - " fig_size = (5, 5),\n", - " raw_marker_size = 5,\n", - " es_marker_size = 5,\n", - " color_col='Genotype',\n", - " ax = axes[0,1]\n", - ")\n", - "\n", - "\n", - "unpaired_delta_03.mean_diff.plot( \n", - " contrast_label='Mean Diff',\n", - " fig_size = (5, 5),\n", - " raw_marker_size = 5,\n", - " es_marker_size = 5,\n", - " color_col='Genotype',\n", - " ax = axes[1,0]\n", - ")\n", - "forest_plot(contrasts, contrast_labels = contrast_labels1 , ax = axes[1,1])\n", - "axes[0,0].set_title('Drug1 delta2', fontsize = 13, loc='left')\n", - "axes[0,0].set_ylabel('')\n", - "axes[0,1].set_ylabel('')\n", - "axes[0,1].set_title('Drug2 delta2', fontsize = 13, loc='left')\n", - "axes[1,0].set_title('Drug3 delta2', fontsize = 13, loc='left')\n", - "axes[0,1].set_ylabel('')\n", - "axes[1,1].set_title('Forest plot', fontsize = 13, loc='left') " - ] - }, - { - "cell_type": "markdown", - "id": "964471ab", - "metadata": {}, - "source": [ - "## Forest plot also supports:\n", - "\n", - "### ``mini-meta`` comparisons and with the contrast type changed to ``\"mini_meta_delta\"``" - ] - }, - { - "cell_type": "markdown", - "id": "22bd3eab", - "metadata": {}, - "source": [ - "### Simulate the datasets for unpaired mini_meta " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f729136b", - "metadata": {}, - "outputs": [], - "source": [ - "def create_mini_meta_dataset(N=20, seed=9999, control_locs=[3, 3.5, 3.25], control_scales=[0.4, 0.75, 0.4], \n", - " test_locs=[3.5, 2.5, 3], test_scales=[0.5, 0.6, 0.75]):\n", - " np.random.seed(seed) # Set the seed for reproducibility\n", - "\n", - " # Create samples for controls and tests\n", - " controls_tests = []\n", - " for loc, scale in zip(control_locs + test_locs, control_scales + test_scales):\n", - " controls_tests.append(norm.rvs(loc=loc, scale=scale, size=N))\n", - "\n", - " # Add a `Gender` column for coloring the data\n", - " gender = ['Female'] * (N // 2) + ['Male'] * (N // 2)\n", - "\n", - " # Add an `ID` column for paired data plotting\n", - " id_col = list(range(1, N + 1))\n", - "\n", - " # Combine samples and gender into a DataFrame\n", - " df_columns = {f'Control {i+1}': controls_tests[i] for i in range(len(control_locs))}\n", - " df_columns.update({f'Test {i+1}': controls_tests[i + len(control_locs)] for i in range(len(test_locs))})\n", - " df_columns['Gender'] = gender\n", - " df_columns['ID'] = id_col\n", - "\n", - " df = pd.DataFrame(df_columns)\n", - "\n", - " return df\n", - "\n", - "# Customizable dataset creation with different arguments\n", - "df_mini_meta01 = create_mini_meta_dataset(seed=9999, \n", - " control_locs=[3, 3.5, 3.25], \n", - " control_scales=[0.4, 0.75, 0.4], \n", - " test_locs=[3.5, 2.5, 3], \n", - " test_scales=[0.5, 0.6, 0.75])\n", - "\n", - "df_mini_meta02 = create_mini_meta_dataset(seed=9999, \n", - " control_locs=[4, 2, 3.25], \n", - " control_scales=[0.3, 0.75, 0.45], \n", - " test_locs=[2, 1.5, 2.75], \n", - " test_scales=[0.5, 0.6, 0.4])\n", - "\n", - "df_mini_meta03 = create_mini_meta_dataset(seed=9999, \n", - " control_locs=[6, 5.5, 4.25], \n", - " control_scales=[0.4, 0.75, 0.45], \n", - " test_locs=[4.5, 3.5, 3], \n", - " test_scales=[0.5, 0.6, 0.9])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9f68e5fe", - "metadata": {}, - "outputs": [], - "source": [ - "contrast_mini_meta01 = dabest.load(data = df_mini_meta01,\n", - " idx=((\"Control 1\", \"Test 1\"), (\"Control 2\", \"Test 2\"), (\"Control 3\", \"Test 3\")), \n", - " mini_meta=True)\n", - "contrast_mini_meta02 = dabest.load(data = df_mini_meta02,\n", - " idx=((\"Control 1\", \"Test 1\"), (\"Control 2\", \"Test 2\"), (\"Control 3\", \"Test 3\")), \n", - " mini_meta=True)\n", - "contrast_mini_meta03 = dabest.load(data = df_mini_meta03,\n", - " idx=((\"Control 1\", \"Test 1\"), (\"Control 2\", \"Test 2\"), (\"Control 3\", \"Test 3\")),\n", - " mini_meta=True)\n", - "contrasts_mini_meta = [contrast_mini_meta01, contrast_mini_meta02, contrast_mini_meta03] \n", - " " - ] - }, - { - "cell_type": "markdown", - "id": "e04e1ac4", - "metadata": {}, - "source": [ - "## Use the contrast list and forest_plot() function to generate figures" - ] - }, - { - "cell_type": "markdown", - "id": "c760a179", - "metadata": {}, - "source": [ - "### Verticle (default) Layout" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9deb1001", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "forest_plot(contrasts_mini_meta, contrast_type='mini_meta', contrast_labels=['mini_meta1', 'mini_meta2', 'mini_meta3']);" - ] - }, - { - "cell_type": "markdown", - "id": "0eb263d3", - "metadata": {}, - "source": [ - "### Horizontal Layout" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "89af4a33", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "forest_plot(contrasts_mini_meta, contrast_type='mini_meta', contrast_labels=['mini_meta1', 'mini_meta2', 'mini_meta3'], horizontal=True);\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "python3", - "language": "python", - "name": "python3" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}