From 9f502786acc3d674f97d7b3d3669d60e9268993f Mon Sep 17 00:00:00 2001 From: Michael Deceglie Date: Mon, 5 Oct 2020 12:18:49 -0600 Subject: [PATCH 01/16] Clean up debugging cell in notebook --- ...radation_and_soiling_example_pvdaq_4.ipynb | 31 ------------------- 1 file changed, 31 deletions(-) diff --git a/docs/degradation_and_soiling_example_pvdaq_4.ipynb b/docs/degradation_and_soiling_example_pvdaq_4.ipynb index c1f2b5a1..00aa3dba 100644 --- a/docs/degradation_and_soiling_example_pvdaq_4.ipynb +++ b/docs/degradation_and_soiling_example_pvdaq_4.ipynb @@ -612,37 +612,6 @@ "soiling_summary.head()" ] }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 2010-02-25 00:00:00-07:00\n", - "1 2010-03-08 00:00:00-07:00\n", - "2 2010-03-12 00:00:00-07:00\n", - "3 2010-04-09 00:00:00-07:00\n", - "4 2010-04-12 00:00:00-07:00\n", - " ... \n", - "59 2016-04-10 00:00:00-07:00\n", - "60 2016-04-16 00:00:00-07:00\n", - "61 2016-05-04 00:00:00-07:00\n", - "62 2016-07-13 00:00:00-07:00\n", - "63 2016-12-06 00:00:00-07:00\n", - "Name: start, Length: 64, dtype: datetime64[ns, Etc/GMT+7]" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "soiling_summary['start']" - ] - }, { "cell_type": "code", "execution_count": 18, From fd4e5c56b4b30e9c72eab0a799b93c72371acbbc Mon Sep 17 00:00:00 2001 From: Michael Deceglie Date: Mon, 5 Oct 2020 12:26:35 -0600 Subject: [PATCH 02/16] Update annual_soiling_ratios --- rdtools/soiling.py | 24 +++++++++++++++++------- 1 file changed, 17 insertions(+), 7 deletions(-) diff --git a/rdtools/soiling.py b/rdtools/soiling.py index 5be9812a..42e83b2c 100644 --- a/rdtools/soiling.py +++ b/rdtools/soiling.py @@ -778,7 +778,7 @@ def _count_month_days(start, end): return out_dict -def annual_soiling_ratios(stochastic_soiling_profiles, confidence_level=68.2): +def annual_soiling_ratios(stochastic_soiling_profiles, insolation_daily, confidence_level=68.2): ''' Return annualized soiling ratios and associated confidence intervals based on stochastic soiling profiles from SRR. Note that each year may be affected @@ -791,7 +791,9 @@ def annual_soiling_ratios(stochastic_soiling_profiles, confidence_level=68.2): List of pd.Series representing profile realizations from the SRR monte carlo. Typically ``soiling_interval_summary['stochastic_soiling_profiles']`` obtained with :py:func:`rdtools.soiling.soiling_srr` or :py:meth:`rdtools.soiling.SRRAnalysis.run` - + insolation_daily : pd.Series + Daily plane-of-array insolation corresponding to + `energy_normalized_daily`. Arbitrary units. confidence_level : float, default 68.2 The size of the confidence interval to use in determining the upper and lower quantiles reported in the returned DataFrame. (The median is always included in @@ -820,12 +822,20 @@ def annual_soiling_ratios(stochastic_soiling_profiles, confidence_level=68.2): +------------------------+-------------------------------------------+ ''' - all_profiles = pd.concat(stochastic_soiling_profiles) - annual_groups = all_profiles.groupby(all_profiles.index.year) + # Create a df with each realization as a column + all_profiles = pd.concat(stochastic_soiling_profiles, axis=1) + # Weight each day by insolation + all_profiles_weighted = all_profiles.multiply(insolation_daily, axis=0) + + # Compute the insolation-weighted soiling ration (IWSR) for each realization + annual_insolation = insolation_daily.groupby(insolation_daily.index.year).sum() + all_annual_weighted_sums = all_profiles_weighted.groupby(all_profiles_weighted.index.year).sum() + all_annual_iwsr = all_annual_weighted_sums.multiply(1/annual_insolation, axis=0) + annual_soiling = pd.DataFrame({ - 'soiling_ratio_median': annual_groups.quantile(0.5), - 'soiling_ratio_low': annual_groups.quantile(0.5 - confidence_level/2/100), - 'soiling_ratio_high': annual_groups.quantile(0.5 + confidence_level/2/100), + 'soiling_ratio_median': all_annual_iwsr.quantile(0.5, axis=1), + 'soiling_ratio_low': all_annual_iwsr.quantile(0.5 - confidence_level/2/100, axis=1), + 'soiling_ratio_high': all_annual_iwsr.quantile(0.5 + confidence_level/2/100, axis=1), }) annual_soiling.index.name = 'year' annual_soiling = annual_soiling.reset_index() From 36e90b0f232fbfec0fac98b5db933c1303309cf9 Mon Sep 17 00:00:00 2001 From: Michael Deceglie Date: Mon, 5 Oct 2020 13:11:20 -0600 Subject: [PATCH 03/16] Run example notebook with new calculation --- ...radation_and_soiling_example_pvdaq_4.ipynb | 87 ++++++++++--------- 1 file changed, 44 insertions(+), 43 deletions(-) diff --git a/docs/degradation_and_soiling_example_pvdaq_4.ipynb b/docs/degradation_and_soiling_example_pvdaq_4.ipynb index 00aa3dba..333deeef 100644 --- a/docs/degradation_and_soiling_example_pvdaq_4.ipynb +++ b/docs/degradation_and_soiling_example_pvdaq_4.ipynb @@ -614,7 +614,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -642,7 +642,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -804,7 +804,7 @@ "11 6 " ] }, - "execution_count": 19, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -817,7 +817,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -851,51 +851,51 @@ " \n", " 0\n", " 2010\n", - " 0.975022\n", - " 0.934111\n", - " 0.992382\n", + " 0.892087\n", + " 0.881133\n", + " 0.899309\n", " \n", " \n", " 1\n", " 2011\n", - " 0.958594\n", - " 0.872132\n", - " 0.984363\n", + " 0.944819\n", + " 0.936342\n", + " 0.950665\n", " \n", " \n", " 2\n", " 2012\n", - " 0.945495\n", - " 0.867414\n", - " 0.989819\n", + " 0.939456\n", + " 0.931768\n", + " 0.945988\n", " \n", " \n", " 3\n", " 2013\n", - " 0.957287\n", - " 0.906841\n", - " 0.987823\n", + " 0.954258\n", + " 0.944068\n", + " 0.961534\n", " \n", " \n", " 4\n", " 2014\n", - " 0.959787\n", - " 0.902334\n", - " 0.991943\n", + " 0.950645\n", + " 0.929716\n", + " 0.966537\n", " \n", " \n", " 5\n", " 2015\n", - " 0.959014\n", - " 0.899179\n", - " 0.985713\n", + " 0.951059\n", + " 0.921407\n", + " 0.966395\n", " \n", " \n", " 6\n", " 2016\n", - " 0.964605\n", - " 0.842394\n", - " 0.987011\n", + " 0.923150\n", + " 0.911463\n", + " 0.930717\n", " \n", " \n", "\n", @@ -903,29 +903,30 @@ ], "text/plain": [ " year soiling_ratio_median soiling_ratio_low soiling_ratio_high\n", - "0 2010 0.975022 0.934111 0.992382\n", - "1 2011 0.958594 0.872132 0.984363\n", - "2 2012 0.945495 0.867414 0.989819\n", - "3 2013 0.957287 0.906841 0.987823\n", - "4 2014 0.959787 0.902334 0.991943\n", - "5 2015 0.959014 0.899179 0.985713\n", - "6 2016 0.964605 0.842394 0.987011" + "0 2010 0.892087 0.881133 0.899309\n", + "1 2011 0.944819 0.936342 0.950665\n", + "2 2012 0.939456 0.931768 0.945988\n", + "3 2013 0.954258 0.944068 0.961534\n", + "4 2014 0.950645 0.929716 0.966537\n", + "5 2015 0.951059 0.921407 0.966395\n", + "6 2016 0.923150 0.911463 0.930717" ] }, - "execution_count": 20, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Calculate and view annual soiling ratios and their confidence intervals\n", - "# based on the Monte Carlo simulation. Note that these losses include the\n", + "# Calculate and view annual insolation-weighted soiling ratios and their confidence\n", + "# intervals based on the Monte Carlo simulation. Note that these losses include the\n", "# assumptions of the cleaning assumptions associated with the method parameter\n", "# of rdtools.soiling_srr(). For anything but 'perfect_clean', each year's soiling\n", "# ratio may be impacted by prior years' soiling profiles. The default behavior of\n", "# rdtools.soiling_srr uses method='half_norm_clean'\n", "\n", "rdtools.annual_soiling_ratios(soiling_info['stochastic_soiling_profiles'],\n", + " daily_insolation,\n", " confidence_level=cl)" ] }, @@ -954,7 +955,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -987,7 +988,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -1018,7 +1019,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -1044,7 +1045,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -1062,7 +1063,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -1109,7 +1110,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -1119,7 +1120,7 @@ "
" ] }, - "execution_count": 26, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -1147,7 +1148,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.7.7" } }, "nbformat": 4, From e9b53423caac5f26063b4ffa0fe79d0867a39c63 Mon Sep 17 00:00:00 2001 From: Michael Deceglie Date: Mon, 5 Oct 2020 13:30:12 -0600 Subject: [PATCH 04/16] Update tests --- rdtools/test/soiling_test.py | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/rdtools/test/soiling_test.py b/rdtools/test/soiling_test.py index b4e17e56..1c00c499 100644 --- a/rdtools/test/soiling_test.py +++ b/rdtools/test/soiling_test.py @@ -234,34 +234,39 @@ def test_soiling_srr_with_nan_interval(normalized_daily, insolation, times): @pytest.fixture() -def srr_profiles(): +def multi_year_profiles(): times = pd.date_range('01-01-2018', '12-31-2019', freq='D') data = np.array([0]*365 + [10]*365) profiles = [pd.Series(x + data, times) for x in range(10)] - return profiles + insolation = 350*[0.8] + (len(times)-350)*[1] + insolation = pd.Series(insolation, index=times) + return profiles, insolation -def test_annual_soiling_ratios(srr_profiles): - expected_data = np.array([[2018, 4.5, 1.0, 8.0], - [2019, 14.5, 11.0, 18.0]]) + +def test_annual_soiling_ratios(multi_year_profiles): + expected_data = np.array([[2018, 4.5, 1.431, 7.569], + [2019, 14.5, 11.431, 17.569]]) expected = pd.DataFrame(data=expected_data, columns=['year', 'soiling_ratio_median', 'soiling_ratio_low', 'soiling_ratio_high']) expected['year'] = expected['year'].astype(int) - result = annual_soiling_ratios(srr_profiles) + srr_profiles, insolation = multi_year_profiles + result = annual_soiling_ratios(srr_profiles, insolation) pd.testing.assert_frame_equal(result, expected, atol=1e-8) -def test_annual_soiling_ratios_confidence_interval(srr_profiles): - expected_data = np.array([[2018, 4.5, 0, 9.0], - [2019, 14.5, 10.0, 19.0]]) +def test_annual_soiling_ratios_confidence_interval(multi_year_profiles): + expected_data = np.array([[2018, 4.5, 0.225, 8.775], + [2019, 14.5, 10.225, 18.775]]) expected = pd.DataFrame(data=expected_data, columns=['year', 'soiling_ratio_median', 'soiling_ratio_low', 'soiling_ratio_high']) expected['year'] = expected['year'].astype(int) - result = annual_soiling_ratios(srr_profiles, confidence_level=95) + srr_profiles, insolation = multi_year_profiles + result = annual_soiling_ratios(srr_profiles, insolation, confidence_level=95) pd.testing.assert_frame_equal(result, expected, atol=1e-8) From 64d8ebb122b1b01949990ad0e13bf11c64fe7f37 Mon Sep 17 00:00:00 2001 From: Michael Deceglie Date: Mon, 5 Oct 2020 13:38:27 -0600 Subject: [PATCH 05/16] update changelog --- docs/sphinx/source/changelog/pending.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/sphinx/source/changelog/pending.rst b/docs/sphinx/source/changelog/pending.rst index d5f98490..1847705e 100644 --- a/docs/sphinx/source/changelog/pending.rst +++ b/docs/sphinx/source/changelog/pending.rst @@ -7,6 +7,7 @@ API Changes ----------- * Change the column names 'slope', 'slope_low', and 'slope_high' to 'soiling_rate', 'soiling_rate_low', and 'soiling_rate_high' in ``calc_info['soiling_interval_summary']`` returned from :py:meth:`~rdtools.soiling.SRRAnalysis.run()` and :py:func:`rdtools.soiling.soiling_srr()` (:pull:`193`). +* Change the calculations in :py:func:`rdtools.soiling.annual_soiling_raatios()` to perform irradiance-weighting (:issue:`205` :pull:`207`) Enhancements From a0817cc8f79085b0ba90888266356a3b0ffc8966 Mon Sep 17 00:00:00 2001 From: Michael Deceglie Date: Mon, 5 Oct 2020 13:56:55 -0600 Subject: [PATCH 06/16] pin nbconvert version --- setup.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/setup.py b/setup.py index 7956cd16..3142219f 100755 --- a/setup.py +++ b/setup.py @@ -54,6 +54,8 @@ 'pvlib==0.7.1', 'sphinx_rtd_theme==0.4.3', 'ipython', + 'nbconvert==6.0.6' + ], 'test': [ 'pytest', From 02313dd79b85be1d0a285806eea392155f0ea602 Mon Sep 17 00:00:00 2001 From: Michael Deceglie Date: Tue, 6 Oct 2020 10:34:18 -0600 Subject: [PATCH 07/16] consolidate changelog entries --- docs/sphinx/source/changelog/pending.rst | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/sphinx/source/changelog/pending.rst b/docs/sphinx/source/changelog/pending.rst index 1847705e..743b4623 100644 --- a/docs/sphinx/source/changelog/pending.rst +++ b/docs/sphinx/source/changelog/pending.rst @@ -7,14 +7,13 @@ API Changes ----------- * Change the column names 'slope', 'slope_low', and 'slope_high' to 'soiling_rate', 'soiling_rate_low', and 'soiling_rate_high' in ``calc_info['soiling_interval_summary']`` returned from :py:meth:`~rdtools.soiling.SRRAnalysis.run()` and :py:func:`rdtools.soiling.soiling_srr()` (:pull:`193`). -* Change the calculations in :py:func:`rdtools.soiling.annual_soiling_raatios()` to perform irradiance-weighting (:issue:`205` :pull:`207`) Enhancements ------------ * Add new function :py:func:`~rdtools.soiling.monthly_soiling_rates` (:pull:`193`). -* Add new function :py:func:`~rdtools.annual_soiling_ratios` (:pull:`193`). +* Add new function :py:func:`~rdtools.annual_soiling_ratios` (:pull:`193`, :pull:`207`). * Create new module :py:mod:`~rdtools.availability` and class :py:class:`~rdtools.availability.AvailabilityAanlysis` for estimating timeseries system availability (:pull:`131`) From 6467e2a22e675bb5b7f06fcc0bfa2112fb3616dd Mon Sep 17 00:00:00 2001 From: Michael Deceglie Date: Tue, 6 Oct 2020 10:36:57 -0600 Subject: [PATCH 08/16] adjust docstring --- rdtools/soiling.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/rdtools/soiling.py b/rdtools/soiling.py index 42e83b2c..7e707fcb 100644 --- a/rdtools/soiling.py +++ b/rdtools/soiling.py @@ -792,8 +792,7 @@ def annual_soiling_ratios(stochastic_soiling_profiles, insolation_daily, confide Typically ``soiling_interval_summary['stochastic_soiling_profiles']`` obtained with :py:func:`rdtools.soiling.soiling_srr` or :py:meth:`rdtools.soiling.SRRAnalysis.run` insolation_daily : pd.Series - Daily plane-of-array insolation corresponding to - `energy_normalized_daily`. Arbitrary units. + Daily plane-of-array insolation with DatetimeIndex. Arbitrary units. confidence_level : float, default 68.2 The size of the confidence interval to use in determining the upper and lower quantiles reported in the returned DataFrame. (The median is always included in From 45126bb77a75246ce3a1a4156aad0af9244ba6f1 Mon Sep 17 00:00:00 2001 From: Michael Deceglie Date: Tue, 6 Oct 2020 10:37:22 -0600 Subject: [PATCH 09/16] typo --- rdtools/soiling.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rdtools/soiling.py b/rdtools/soiling.py index 7e707fcb..1c6094e2 100644 --- a/rdtools/soiling.py +++ b/rdtools/soiling.py @@ -826,7 +826,7 @@ def annual_soiling_ratios(stochastic_soiling_profiles, insolation_daily, confide # Weight each day by insolation all_profiles_weighted = all_profiles.multiply(insolation_daily, axis=0) - # Compute the insolation-weighted soiling ration (IWSR) for each realization + # Compute the insolation-weighted soiling ratio (IWSR) for each realization annual_insolation = insolation_daily.groupby(insolation_daily.index.year).sum() all_annual_weighted_sums = all_profiles_weighted.groupby(all_profiles_weighted.index.year).sum() all_annual_iwsr = all_annual_weighted_sums.multiply(1/annual_insolation, axis=0) From ad60ce6a75dd365ec1858edc36eea2b44a44abf3 Mon Sep 17 00:00:00 2001 From: Michael Deceglie Date: Tue, 6 Oct 2020 14:43:02 -0600 Subject: [PATCH 10/16] Handle overlap between insolation and soiling profiles --- rdtools/soiling.py | 10 ++++++++++ rdtools/test/soiling_test.py | 15 +++++++++++++-- 2 files changed, 23 insertions(+), 2 deletions(-) diff --git a/rdtools/soiling.py b/rdtools/soiling.py index 1c6094e2..583dccbd 100644 --- a/rdtools/soiling.py +++ b/rdtools/soiling.py @@ -1,5 +1,6 @@ '''Functions for calculating soiling metrics from photovoltaic system data.''' +import warnings import pandas as pd import numpy as np from scipy.stats.mstats import theilslopes @@ -823,6 +824,15 @@ def annual_soiling_ratios(stochastic_soiling_profiles, insolation_daily, confide # Create a df with each realization as a column all_profiles = pd.concat(stochastic_soiling_profiles, axis=1) + all_profiles = all_profiles.dropna() + + if not all_profiles.index.isin(insolation_daily.index).all(): + warnings.warn('The indexes of stochastic_soiling_profiles are not entirely contained ' + 'within the index of insolation_daily. Every day in stochastic_soiling_profiles ' + 'should be representted in insolation_daily. This may cause erroneous results.') + + insolation_daily = insolation_daily.reindex(all_profiles.index) + # Weight each day by insolation all_profiles_weighted = all_profiles.multiply(insolation_daily, axis=0) diff --git a/rdtools/test/soiling_test.py b/rdtools/test/soiling_test.py index 1c00c499..eabcd167 100644 --- a/rdtools/test/soiling_test.py +++ b/rdtools/test/soiling_test.py @@ -235,10 +235,12 @@ def test_soiling_srr_with_nan_interval(normalized_daily, insolation, times): @pytest.fixture() def multi_year_profiles(): - times = pd.date_range('01-01-2018', '12-31-2019', freq='D') - data = np.array([0]*365 + [10]*365) + times = pd.date_range('01-01-2018', '11-30-2019', freq='D') + data = np.array([0]*365 + [10]*334) profiles = [pd.Series(x + data, times) for x in range(10)] + # make insolation slighly longer to test for proper normalization + times = pd.date_range('01-01-2018', '12-31-2019', freq='D') insolation = 350*[0.8] + (len(times)-350)*[1] insolation = pd.Series(insolation, index=times) @@ -254,6 +256,7 @@ def test_annual_soiling_ratios(multi_year_profiles): srr_profiles, insolation = multi_year_profiles result = annual_soiling_ratios(srr_profiles, insolation) + print(result) pd.testing.assert_frame_equal(result, expected, atol=1e-8) @@ -267,9 +270,17 @@ def test_annual_soiling_ratios_confidence_interval(multi_year_profiles): srr_profiles, insolation = multi_year_profiles result = annual_soiling_ratios(srr_profiles, insolation, confidence_level=95) + print(result) pd.testing.assert_frame_equal(result, expected, atol=1e-8) +def test_annual_soiling_ratios_warning(multi_year_profiles): + srr_profiles, insolation = multi_year_profiles + insolation = insolation.iloc[:-200] + with pytest.warns(UserWarning): + result = annual_soiling_ratios(srr_profiles, insolation) + + # ########################### # monthly_soiling_rates tests # ########################### From e9fc48e89169d3983b860e2b55e238e6cd2d6b20 Mon Sep 17 00:00:00 2001 From: Michael Deceglie Date: Tue, 6 Oct 2020 14:47:11 -0600 Subject: [PATCH 11/16] fix typos --- rdtools/soiling.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rdtools/soiling.py b/rdtools/soiling.py index 583dccbd..5e026aeb 100644 --- a/rdtools/soiling.py +++ b/rdtools/soiling.py @@ -274,7 +274,7 @@ def _calc_result_df(self, trim=False, max_relative_slope_error=500.0, results.next_inferred_start_loss - results.inferred_end_loss, 0, 1) - # Don't consider data outside of first and last valid interverals + # Don't consider data outside of first and last valid intervals if len(results[results.valid]) == 0: raise NoValidIntervalError('No valid soiling intervals were found') new_start = results[results.valid].start.iloc[0] @@ -829,7 +829,7 @@ def annual_soiling_ratios(stochastic_soiling_profiles, insolation_daily, confide if not all_profiles.index.isin(insolation_daily.index).all(): warnings.warn('The indexes of stochastic_soiling_profiles are not entirely contained ' 'within the index of insolation_daily. Every day in stochastic_soiling_profiles ' - 'should be representted in insolation_daily. This may cause erroneous results.') + 'should be represented in insolation_daily. This may cause erroneous results.') insolation_daily = insolation_daily.reindex(all_profiles.index) From 3a6bd1ebde844cb0e497cad1ad03ed3834ac2512 Mon Sep 17 00:00:00 2001 From: Michael Deceglie Date: Tue, 6 Oct 2020 15:16:10 -0600 Subject: [PATCH 12/16] ensure insolation sum is correct in normalization for monte carlo --- rdtools/soiling.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rdtools/soiling.py b/rdtools/soiling.py index 5e026aeb..cff68367 100644 --- a/rdtools/soiling.py +++ b/rdtools/soiling.py @@ -444,7 +444,7 @@ def _calc_monte(self, monte, method='half_norm_clean'): df_rand['soil_insol'] = df_rand.loss * df_rand.insol - monte_losses.append(df_rand.soil_insol.sum() / df_rand.insol.sum()) + monte_losses.append(df_rand.soil_insol.sum() / df_rand.insol[~df_rand.soil_insol.isnull()].sum()) random_profile = df_rand['loss'].copy() random_profile.name = 'stochastic_soiling_profile' random_profiles.append(random_profile) From bec1b87b02cddbd02a509f49baf1f860b356191f Mon Sep 17 00:00:00 2001 From: Michael Deceglie Date: Tue, 6 Oct 2020 15:20:49 -0600 Subject: [PATCH 13/16] bump nbsphinx version --- setup.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/setup.py b/setup.py index 3142219f..e6070d9d 100755 --- a/setup.py +++ b/setup.py @@ -48,13 +48,12 @@ EXTRAS_REQUIRE = { 'doc': [ 'sphinx==1.8.5', - 'nbsphinx==0.4.3', + 'nbsphinx==0.5.0', 'nbsphinx-link==1.3.0', 'pandas==0.23.0', 'pvlib==0.7.1', 'sphinx_rtd_theme==0.4.3', - 'ipython', - 'nbconvert==6.0.6' + 'ipython' ], 'test': [ From 7a1af7f15c409c9afa719494060828bb59874f18 Mon Sep 17 00:00:00 2001 From: Michael Deceglie Date: Tue, 6 Oct 2020 15:53:37 -0600 Subject: [PATCH 14/16] Run notebooks --- docs/degradation_and_soiling_example.ipynb | 59 +++++++++++-------- ...radation_and_soiling_example_pvdaq_4.ipynb | 18 +++--- 2 files changed, 42 insertions(+), 35 deletions(-) diff --git a/docs/degradation_and_soiling_example.ipynb b/docs/degradation_and_soiling_example.ipynb index cf4de875..2dd2be04 100644 --- a/docs/degradation_and_soiling_example.ipynb +++ b/docs/degradation_and_soiling_example.ipynb @@ -95,7 +95,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAASMAAADCCAYAAAACT6S+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAACzc0lEQVR4nOz9ebBtWX7XB37W2vM+8x3ekGNVSVUSKgmVTIGhaQQ2jcegbcDuoE1gcIeBNmFMGBz0YKaWGgeYCGiHaYPB0AxmdBuayZZlgYSQVJJqkCpVWTlUTi8z33THM+15r7X6j98699z38k2Vr7LqZdX9vbhx3z1nD2uvvdZvfX/f37CUc44LuZALuZBvtOhvdAMu5EIu5ELgQhldyIVcyBMiF8roQi7kQp4IuVBGF3IhF/JEyIUyupALuZAnQsJvdAO+EbK3t+c+8pGPfKObcSEX8i0pn//854+cc/t3f/4tqYw+8pGP8LnPfe4b3YwLuZBvSVFKXbvX5xdm2oVcyIU8EXKhjC7kQi7kiZALZXQhF3IhT4RcKKMLuZALeSLkQhldyIVcyBMhF8roQi7kQp4IuVBGF3IhF/JEyIUyupALuZAnQi6U0YVcyIU8EXKhjC7kQi7kiZALZXQhF3IhT4RcKKMLuZALeSLkQhldyIVcyBMhF8roQi7kQp4IuVBGF3IhF/JEyIUyupALuZAnQr6uykgp9ZuVUi8ppQql1OtKqV/lP/+1SqmXlVKlUupHlVLPnzsnUUr9JaXUUil1Syn1++665n3PvZALuZAPj3zdlJFS6tcBfwL4D4AR8P3AG0qpPeDvAn8I2AE+B/ztc6f+UeDjwPPAvwT8AaXUv+av+bBzL+RCLuRDIl9PZPT/AH7AOffTzjnrnLvunLsO/EbgRefc/+CcqxHl871Kqe/05/024Aedc6fOuZeAvwD8dv/dw869kAu5kA+JfF2UkVIqAD4N7CulXlNKvauU+jNKqQz4JPDFzbHOuQJ4HfikUmoGXD3/vf//J/3/73vuPdrwO5VSn1NKfe7w8PBr+4AXciEX8tjy9UJGl4EI+HeAXwV8Cvg+4A8CQ2Bx1/ELxJQbnvv77u94yLl3iHPuzzvnPu2c+/T+/ns2JriQC7mQb7B8vZRR5X//1865m865I+BPAf8GsAbGdx0/Blb+O+76fvMdDzn3Qi7kQj5E8nVRRs65U+BdwJ3/2P9+EfjezYdKqQHwbQgXdArcPP+9//+LDzv3a/wIF3IhF/IBy9eTwP7/AL9HKXXJc0H/KfCPgL8HfLdS6jcppVLgDwMvOOde9uf9VeAPKqVmnpj+HcBf9t897NwLuZAL+ZDI11MZ/SDwWeBV4CXg54A/5pw7BH4T8MeAU+BfBH7zufP+CEJKXwP+GfAnnXM/BPAI517IhVzIh0SUc+7hR32Tyac//Wl3saPshVzIN0aUUp93zn367s8v0kEu5EIu5ImQC2V0IRdyTr4VLYUnRS6U0YVciBfnHNZdKKRvlFwoowu5EC9KKbSS3xfy9ZcLZXQhF3IhT4RcKKNvYbkwR+6UCzPtGysXyuhbVC4m3nvlwkz7xkr4sAOUUhHwy5G0iykwRzLlf9o5132QjbuQD06UUmjch2LiOff1a+eHoT++WeW+ykgptQv835B6QifAy0gC6gj4T4CZUuqvAH/cJ75eyIdMPgwTb4PgPiyK80LevzwIGf0E8BeBT/kiaHeIUuop4LcAPw581wfTvAv5VpcPE4L7ZpGvJxI9Lw9SRt/rnGvv96Vz7gbwJ5VS/9XXvlkX8rjyjRpQH4R8PZ/jm6nf3o98I5HofQls51yrlPo/KKWuPOgCD1JY32zyYSB7nXN3kNMfdJs/DH3yqHJB6n9jSfyHedP+n8B1pdSrSqn/Tin1W79Vd9/4MAzUTRsBtB9LD2rz4z7L5n7W2se6zpMiSinUhUn4DXv+Byoj59wngKeB/xyp1vj7gdeVUteUUn9NKfUffh3a+ETIh8Hte76NZz/3mVxfC+W6ub5DnV3n7t8fJvlaLzgfxj74RspD44ycc7f87hu/xzn3KWAf+H8Dvw74bz/g9j1R8iQooocN8PNtfNDk+lopV6312XWstWdI6YNEkR/kJP9qrv2gYx9mKn9YFdUH2e5HiTNSSAH97/c//xvgBvB3gH/+gbXsCZMngdh8FHLRWovW+o5z4L3HWmvfc433+4xKCTJyKHAWHQQfWH+d74PNvb+W8qjX27RDuTv7+/x1Nm28+519kCTx++33Rznvgya3H6iMlFL/GNnF4xXE1f/ngd/unPuWKnj/sJfw1Q6Ax5n0dw/q89ex1tJ0hiR68KSy1tL2Fq0gCoMzZWKsI9Dvb4IrpcAaUPqsXR+EQnrQJP+aXFvd2fb7PYNSCuXsmYl6v2PgvW38oMIV3u87fNTx/UGHWTzMTPsE0ABvIqVfX/tWU0QbcvZeJs3dnquHiXPuPSbMw6D+3XL36nr+GGstXW/O7mGMued172WiPWr7H/id0mcc1QdJ+J9NjK+BmXm+fecJ+d7Yh5qb503Ur1a+lhP6cfv4q+EWP0jr4GEE9seBXwH8z8AvAf5HJRsw/m2l1H+slPrUB9ayJ0CstXTG0Rt7h/I4r4Tg3orqbtmsWsa6R5qwD5vMd0/GzfXbtsVai7OGzrh7KiRrLVEYEGh1h4n1oOfYXP9B7Tk/oK21dzzn48iD7vk4njzn7ny3d38O8m4f5I18VNPmbqX31bbzfp+fv/77VdDW2jucEOfl7vf6QXJG74fA/h7g88gGjJ//wFr2BIjWmkA5Aq1wKIwxGHvnQH3UF78ZKOdf5oMGz70Gwd0D4e7z+r5nXfecLgt6Y+m67j2DzBhD1RqMMXeYGI+qUO/3+WZSGOvo+566s7Rd/1UhwfPfn/99v/ONMfT2/gjwUe5xt6LYKOjNNZ1ztL19j9LbKCxr36vMzsvdffvVkvv3W5TOf765/mZRedS+3hyz4fru/nzT3s01H7YgPa68HwL7f4skzH4O+EsfSKueELHWYtFoEBe20ihn4R4eK6whCIKHX9NBbyzROff7veT8wLoThbl7EqYAcRSCaSmMZph1ODTKGbSO7nn8Rjlu2rDhG+Deislay9kB59rZdj1xFJ6bdAG6b0FJf4hS1Y/ETWxIYceWn9j83ijQsyYoDaaDMHpkfupuAlxj0Tra3hsxpXu7dQbcD7luJqZSitA36kFt2LzT8/3xsDbfj6fZcFbWQXDuPSpnUUqfKZEHcTxnvJjpQWmatiOJZaz0RjjFrel97374WsrDCOz/CTHTYuBnkK2C/gzwGedc/YG27AkQrTWBM2gtk8pai9L+RXsUEAYaZw0WjTrnybrXQNNaE2ork+ic3OvY9xC1/ut7EaabidT3Pa2BoqrYGaW0xtD3ijAMCQIhqoMgIAmlDX3f41Tgn1F7xSf3u5sE3ZisYWDvULrGGFoDWvXoIMT5PgiC4AzZ3WFGPGBybCbTpi1337+3gDPg5JmckfbjLEo/eCHYKHWtNRr5f9MZmXRaFpKNEgQI9Zab2qClu99l7GfPmQuf9zoYQMbJZhHR5yb23WTz+Wc+///zpu7dRLjzY9EhfdcbSwjnrq3vaMv561kHzvT0FpTraHoIAyOK3w+64K7F74OMtXsYMvpxJAr7s+5bsFzIhpTdQPGm7QiCQF54oP3qEaJ0QODsmdK6HwIwxtyx0jzo2PNijCGIwvd4d84PUOUnZBIq+jiSCWQsVWvJup5Y6TNEYR3gTc5Q9xBGD+VelBIor1R4dm+lRCkktiWKYowRnip0hq4XMycIHPpcux+GHGSCiHI4MxUcaKUItaPrHXXnSOmFbDY9Oowf2PaNSWWsIw5FkYhi7O5QNFrrM1P8fFukb96r7DbP44wsWBIuoe9SQh5Rao26690ZYwh0eOdznluANor5fPzWxvt5dxsUYK2YlAqHRZ+1+G4Ut1GAylksCmsNgdoqYJQmCt4bItIb68/7YLylDyOw/7hz7qe+FRURbHkbYx1F1bCseuq6llXj3CqqFXeghXtxMJuVfbVavcc7cd7mh+0qbqx7Dy9yfjBvJtjmeKUUaRITIEoviSPyJCQKg7N7nF2v74TzcODsnfyRKJ33eg7P3+ssuNFajFNn/++6Tr4/75E6Z/Y8TIwx1G2PMebMND3PnSml6Lv27PnP8zn340o26Ob8O+n7ns6+l5frekPTdjRth7OGtrdUraHv+3v2hzGGpjNnSuw8J7Rpx8brtjlv4/XcvFfjH/SO6Hkf2b4xt3B3ksxnyp27lLxXYBp7R58FWkzJ832gtSbQcu3OKpw1Z+3YjOe7Cf4ztPsBBLbeVxkppT6rlPp3lVL3XHaUUrGSRNqf+Zq15gmUzQuLo5AQMUU2LzzU21X27ol2N3rRWtPWJe8cFSyXy/cca619z2DenKecORuY77mHs2cmlDU9q3XBzeM1J/MlCofGr6peeaA0pmswBJi+E5LZcyUbZNBZ9R5S+DxhurmvQ9H3PU3b0fc9VWtYVy1t10u78edwJ9y/Fxm7EWsty3V5RszClhTvjKPrOqpOlEag3htIeL9JopQ6Z4p6Ds7daXJu4rSquqFoDM454lAm9r28TWcK2Hst73ZsnL1DteXWNguIUookFLP57oVm89612v4Ow9DzW1vubbOw9H2/VY7WUTctZdPT9eY95t29nkMHIbZvKeqOpjNnfbRRzufH3fkx+rXO43uQmfbbgB8A/qxS6gtI4OOmuNongH8B+KfAb/+ateYJlY2yaHqHMeUZP7EhLvu+Bx0SaksYbs0YuJMUrpuWN6+9TVdOGI+GRFF0duzZRNcahdj6yq+ixim0MViriKPtamdNh1MBzq+uVdVw43DO4XxJVy349o8+D2EKqmE0yMSEMD1WhdimwqmAsqi8m18IaB2EuK4jCLZt20xkIcOTM1QSaOFd2t4ySBVxAIVHVQqLCuWazhpC/6x3E6t3E8rL5ZLDZcdkkJDnuXBSXS8EsXOC8lyD1glKa7QSFBUEwR18zD0JXyy9Ee8oiOcs0HcFOOKoyoIoyc6Up0WUdBRuFdem3VGg0a4lCFL6buuB27x7sFskZCyjPBGlb0FrdV8ubtPmzW9jRNGPPR+ncZ7A7+mdQmt5LlkAFE3bkUb6zKw+u+Y5igA2HmNB0qfLJcM0xBh1RidsvMexFm7UOEWgHfeK6n9cua8ycs59Gfh3lJQQ+XWIS38P2dP+rwK/1Tl38DVv0RMmfS+rfNM0nMyXhKFwN0lQEEYxXZawrnsGSUCe52htzwhA8cw4Ai2r3/Vbh3zprWNunB7z3NU99vf3zwauTJD3ciobhedsT09wRhTbvsMQoEyH0gHK9dRNy6qoOT085TRP2JmcsLczJU32z1bmQCu6psIQ0DUlN46WJKFCjcZCslqLUxv+Q50pir7vOZqvydMYrTVVa8hjQYWRFtRT1Q1Va2gOj8iHY5Sr6aIQgpicjjAM6XrjeY+t0tgopqqquHZ7QdcZzOXRmQnT9QatxGQwxtAYMSmCUHilojFo3Z9N5vt5AnuziVAP6Pvem44tOgiJAkvd9hwdn/DCm7d4bm/MMIvJs1SQkbszxGJj+nRdR9Urwla8h9so+ODMNOysR0UWuq4jTVOsNTjnlaE1dyiNeynTrut4893bfOdHrpDn+ZnyDLQ6Q1ob5KucoN3eQnTOI7gxB+/mrlCapio4WTXk0QIdxkzHQ9I4JAq2oQ5N77CmI9SxjI8oPhsnXwuE9FDXvnPuFvDXHvtOH0Lp+55V1REqy82jBauqY2+kuH7jNp0LCQPHU7tjWmKyvQnW9Kh4i4ysHwChE/PidN1QnELXQ1VVWwURBGer9eZcwKMPhTMdVoWe24nETAxCdNfSO0Vd1vTGcny64Ph0zrICmoaDyZKToiXPUrJ8QNMZ4gDWdQ+mpG1bXnj1DXbGOWkSE8UJTmmwPcojo43JUZYl7x6s2RunjEYjzy9oCbJE03UdZdNzenLM8bpnfyzISznDc09dgmQoJl3v0Mrcoeg2A7ltWw5P10R0NN1lwt6i8SaCk4nW1GuqdYkZ7gN+pd+8L99fd3s0z8wyfzzOUtZShssEAYGxhGlM2/UUZcVLr98mMi3D4ZBLO4qybsmyjKgXF7ggIllAXBASUKF0gvUc0mJdMR2mgmCCgCgERUTTdl5xSp/hHM6aO/i0e/ULwHw+58vXbrM3TnkmTc/QadcbrxjFaVBVFXmWEmorJqbehhycD9vY9I21lrKqKVrH/OSIeqWI0hHfFQdE4fCMhgChARarQhw5UcLANQRhhFLv9b6+H3moMvpWl67rQBleu/Yuk0HOone8eP2Um2939Ao+/ckls/GEK7MctJgVYRgKmnEO52Sw1HXNm+/e5sYJrI7gaL7m0qWGzioyLbE5Z8oHWS3bzqBwFK0jDSUG5Dz3oXRAXRboIKSva4rGcHDUcFJC7ODg6JS3Tx3P7k94Ns9lQjs4PFlgrKNZHfPyzZ7vO77N/t4upmmJwkAIaSdIZqMkBR2KAtu4seumZVm2KGfI4xFN23F8umBdG8bxgBuHS/owYjbKGA0yoihCNSVKZ3JNdefEKIqCo+ObZPmAw6NjrOkZDoe0XU8UJrR1yedfusa6FbPi6v6MpneEfpJtCPbIT4o74okUGGeZL5aMhznzoiWwDXEcE4QRUSATs1iveP0m7OWnfOyjz9M1FZ3RjOiJokxij3yIgLUWa3qK9YpRnrBYrxkNMm7cPmKQXBYE66PhoyjCGMPxyYo4GDLIM5xzLFeitJ0LxVzzKPNuL2zdtCyKlZhORsylruvPkGbbOcq65XhZEWqoW8N4kEo/3BVysukb5USZdb2hKgtuHB5zujY8e2XBtz89FaWrAcST3LYtp6UhWB5x9dIuKh3e08P3fuVCGT1ArLVUTcfByW1++iunPD085ZlLE05vd7x+BAbYe7tg8F0TyqpmOhnjuCs4TOkzD9Gtg46fstACn/uFN3nu6SvoMCZPwjNSMADw8SJdb0gjjTU9LoxksGJx3h3ddR0dEUFT0LUNxwc3eecAjlaQphA6x7stHB4dsTMZ0roQHSvqtqdYL0k01BUcLQo+1tXoMBY43/fEYXIHvyDE8pprtxfkeU6oNdZYTucLoiRj0vUs5qdcO5gTBR3TYcLtkwWTcYpFM1+VjAcpdQ9x3xEmCbDlXqpizT///Mu8fWzJ5yts9xZPP/08H7nUMRhNCDW0Tc1Pfv42H/9YgDWXMNZxeHTM5Uv7WGsJ1BYnbcw/gKYVZ/CNW4e8cbviyuCYXsXURhOohkGeUZUFZd1ysljz9hqeOoF6dcKRm9IayOKAzCMj50Mj6rbn1dev8crNUz5VrDkoAi7lh3zxzRtc3RmQpQl1a2kNpEFD27a8+c5tkjgiCgOatuP1Wysy3TH8yNM4HE7LWNiYnNYKirtxcEK17oSDUwHKdmfeL2cNTkf0bc31m7fIw0vcXhniUDObjDBOEQXbCPk41D7cAtqup+16qqri+i3DW0fg+prFxyvyvMaGIcY6lmVLoi2qXXHtuEWHK4x1JEmCVvF9A3G/GrlQRg8Qay2nixW261kvYB3AfLWiLCUKtAGiBOrFAavuCkVRkOZDmcQ6AOcIlCMMQ+JQEwZb9+XNW1C3PbGO6fueIIwI9XbytF1P1XSkkSCK8zE+vZHVKM9SivUhP/PCV3j9+px3bsMrKxgAiYUkBXsMvQv42V94k0uX93l2b0BdrqkspHScnMCX31nyXZ8oSTNwYUDvNPG5WB+lxGt2/fYpeRKyO0oYjSfUdc3NgxOevbKDsxlla3nj7Y4khNTd5JVb8PG+pmsqTolII40x4NhGTG/iXebzOW+eVqgSBnvQGJgfvEvwzKcIXEfdGL78ymv81AHMcoP7pGJ+esJrN06YDmIG2SV678U7b6oZY1iVDQGGRdHwysuv8lYGl2YDnrv6FHmWgq35ys0Vq6pCNy0KODmFazduMJopZoMQY4eAj9B2Dh0EmK7h1smaV9865mPTkLdvrSgSy0vXan7Fty/Y2dkR5dFVtCR85fU3+eLrN3n+0oDrVcF0PGS1OOX6esUgCdjbvyQcEBqlhItp25bFYsFPfvE6n3kNvv97Dtnb26NqOlZVB7YXp4mtODxZ8pWDOePYUZPR9gPWRUmcpARKn3nulArO3uliueLg6IR3bp3wynV4C9hbwRvXrhEnKUmSkASOsqzpogiUKHBnOo6XFWVxyMeef+aMWH8ceZR0kAD4I8Afc841j3W3D5kURcHRsqVdLcljaA0sV5ZTA8dAB3z2JYg+1TO+fo1YPc3lICLMM/AxKjLhDKfzBV94c+uD+Owh/JZyzSBL0EHmTTpBRKuqoyoLlmXLOI+ZHx8y290nUY5AazrjCHxMz5vXD/kzPzInA3aBEriKKMtbR2BDWB7f4nqbMEgViwRWZcO7N+e0E8UbQPgS/Ku/dIHVMbM4IlWQJtuIDuccRVFwu4BL80NeeSfg258NKIs1X3zjAEXHeJhzeOs6//xA3K2RgdcPoO/gu48WTKaKcG9A7OwdgYbnidVXvgzPPCXWZN/UdOPLLE4O6UZTDk6W1HXNKVD1cO36bVbzY148cOxnjt3dXTGdTI8NA0wvUeV933N4smCYhrzy+jV+5lU47uE79wq+v7/OM89/jHJdcP36u2SDjJG2KOCVNTx9q+dqdY1VPmQ8HrM7GaB0cBZCoIMQ01acLOGLX77NmwU8P4bFgZhBRd1RFmuMimiOb/FjP3eTL9+C54avcLOH77k84WBe8sphx7pY8ss/FfHslV1Q4JykZxycFrRlwQ+/BkfAz794nV/0iW/j+HRJ3/dEUcRiVRDGKVno6FcVh4uQfJjSVAXLMmJvbLD5gMQ5OuOIPOm8XJe8dO2Qd2/e4t23Gz4DOOCLB/D84Zrp5IDdnRkMcpQOMG1F1RrKVUk9zrnx9g1uLEpGWcTkYx957Pn2KImyBvjdfu49tiilPq6UqpVS//25z/49JaVsC6XU/08ptXPuux2l1N/z311TSv17d13vvuc+jhhjMAREthBXeC+TZH8CQycv7W3gJvClF2FVW37on73AYrG4gws5PjqkbVveeucGX0Jq94JsQvf6G6+zahx1VYKT4DrnHKatWK7WnKwaXn/zGp+/tuTV19/i+HRxFvfRGwkkvP7ONV5Gqt1FSkzHBfBuC28XMK+lrSeHDbcOD7lxvOalr8y53sDBLcdt/wyL+SkHRydn5HXf98IrtR2rdSFk/gq6Bl549RarxSmmrXjjFtw8PuUrb13npWs17/rrFT5GcH4K8/kRx/MlbdtSVvUdyZYb1/0LL77Mi8BrN+DdA0hCcPUCpyNu3brF6+/cpKha5sBb78Lnv3zE3/1px+fegJ986RaHh4coHE0vpLDWmroSjuuNd69TlQVNU9P2gmi/eASHqxJXHvP2Ozd54W24fVRx87hjASTAjTfg9gH8/PU17964jrUSeb8hho0xzBcrXj6EH3sJ3n0b3nwNyl5Myq6pOFrK7yQKGKYQN3Ayh3/yBfgff2zBrUXHjTfg5txy8+bNM/O8N5a+azmcF9y4cYMTxI39hdfgzbeu8Quv3eKnPv8lbh8vODheUBQFi6LhtIQvvbGibVZUTcdb796k7fqzeLSNN1BrTZZERK7h6Ljhy7dgQy4sgJvXYVWUHJ4ssX1L4DpaA6+9cY0X3lzy+S+9wc+9uuRzL/bcPJrTto+/L8ejmml/Ffg/A//NY99RStZ+dvOHUuqTSPnafxP4AlLA7b8BfvO541vgMpKw+4+VUl90zr34COe+bzHGcLosODhdUq3WvHMM6hi6SkyhL/vjrgHPK/hn//SUrwDf+bHXuLy/C0pzcHDA518/5NnJIbePFqzPXb+Xh6cs1gRqQN0s6axCu56DRc31W0eU61Oe+55PElx/m7ffXVP0Ad+lNaPhAK0kGO7mTR+fA6ycDCQDWGRCPQXcOIV/9ha0GvLkFru7Yr6VXmG8BvzcS6dMnnHMBpGYF1kGpqOoGt49XPLCz7xMXcH1G/BPbsPO6BpXpkOcgcUC+t0e5a9XII3QyMS/fthx+NZ19ocha5czSCOSWFJQVkVF29S8e9gw98e/dighNJNxTZbeomwtL7+14KO5XP8XgOJt2dZ4ALzyFrz46pv88tGIrlc4F9LUFS+/fUTULfiFt49YHR7xzm3pp1NkUfjpz8MkO+XnX+14ZQ6JkXY7BPmGHcQncLSE7/tIS9N2RFF0ZgIul0u++BXLywjXNwCu1/Juj08XjHcuMV9VmBZwlluHsDDw2rtSHOz1Co6+LO+rewWeu1LwifX6LMbJWstyMWe9WHLsx81nWvg337rGrRW8fACT/A3i0VXGfcPrb9/k1bfk2VJ1jELxc1854tufmjGbjOisoq4KsmSCtZa6ablxuOCF18U828ht4M1DcD99zLMfOSYMFAQxxwc3eeG1jh8+hl92AF0ti2BVrr+unNEvA36PUuoPAO+wVaI4577/UW+mlPrNyPbYPwV8u//4twD/0Dn34/6YPwS8pJQaIXPqNwHf7ZxbAz+hlPoHwG8F/q8POtc9ZhE4pRRHhwd88Y011RH8LNJZLx3KYN6IAT7XwiXgDcB1HUop5quCuml59Y2bLKfQ3xl0zQA4WTaMFyuqsqBoDEkiHqPlcsnf+ydz9ADi8MssVpYf/oLjl378daZxz6XLV5iOh5TFmtAn5M+A68hEuHXuPiPgpS/LoHntDfjouKPsIElgVW2P+/xX4OPtnE9cmpAOp8RRRxzHKNvxwz/yAn/rHZgAu0qe8/QY9keGWQKjCZR1g+ek6YAbczErdoAXvywlHr59/xqzy0/TtiOcc9R1zdsHS9549UW+9LqsOKnv55NjcBFoeoqTBa/dgGQq1z9AlIUBhsDtCr5yuOTZW4eMpzu0fcRqseDld29y+sYJb92CNy18oZV3t+/Pfxf46c/VvFTL32+dShvWvt9+HiiXcp+yXGB9Uimml7gnC0fz7ThY+p8AeP3WmmeeqQhcyzu3lqxWa372UCb9O6VX2Ej2+UeB2MLB4eos0FA5w63bB/zsi+/wyle272kB/PxX4MoerObQmADV1dQ1/NxXWq4j98hfhxvvHvFuA7/4mdfOSP5Vqxg0Nc45FosFX3mz4h3ErI+R51f+Gm+dwvf18N3PFazrJTeOlvzTY+nDX6jlOd8BXnpjxS/5ngX7+/s8jjyqMvoL/ud9i1JqjER0/8vA+V1FPokoJwCcc68rpVokytsCvXPu1XPHfxH41Y9w7h21lpRSvxP4nQDPPffcQ9vbti0H85LPvSOa1y+a3Is0W/kfgNN1w+HRMW8frikXR7z5NvzkazIBzksDfOYVOCneYHca06LYSUKuHRec3IbPGVFgn3jHcHIAnwFe/wpU3TV+xad6vuO5y7z4xi1unsj1OkThgLzUTSbVl5HJVfjfL10D00IygMG5RJ8fBaITeOfwmOl4yO74Cm3Xc7pY8eo7MgAdUFby+3QJr71bURowBVxfr7l+bpPzxv8cIEgG4Oe+DN9lr8Mvep5btw8IA80/+ZGf50evSSlREIU6c3DSQXcb5s+tWVVw0EF2uL2+Ofc7BlwD67Kmrm+QPPM0VdPxUz9+wk/08CyibDbN2yjr14CwlmdrECS3RCD46/6YVxEurlg4Sci1PRbNarXi2tvv8KO8Vwzwc1+CTzx3zPG84PVbJasDudb5+29kgpi2LVDXNcpFHB/e5kd/9lV+8ivb/tvIXzyATx9I+z+9MDw9hGK14M2jLcL5CWC3EeX1fe92PPvOTT767FUC11A38Mo7x3zmM6/wk7dk7Ch/f5D3uxlLn1jByekpaxNz4wA2r+AUNhFgfPY1+I4XXuZf/pUj0jS9R488mjySMnLO/ZX3fYet/CDwF51z794VkzBE+uy8LJDFabPg3Ou7h517hzjn/jxixvHpT3/6odl9cRyTqI5bCJR7VFnN4bVrN3jnuKQvV3y2lfPvJrJ64IUF1A1M05bRFLpxwwuvwWG5veePvyFh7yAT+2ffguev3mCawDtHcwpv+21W2gRZsc6ndb7tf78AvHAKHwOequGXPAffhkw8B7y7gmq1pmilYmTTGT77xS+fnV8Bh77nXj2F6akMzpOFTHbtfyywG8JXeoH8G/lSCasvw7df+QU+/9aKg3fgb96FX6/7nxSoWvj4dcOX3pKJfMx75QTIgc98GYryGsEIvvPggPWq4jO9DJ4X73He5h0Evu9aZALO/fU2Evq+WbRQVyUnxyXD4ZA3b6+49va9WiTyYxa+46VDFgW8eEs4wvvJ2/45Tm5DEEa88+47fPaL7/D3XxUa4F7yOf/7R74Mv8qdsptBedeo3rTuC6/BJ77tgMu7E4Iwpmsb3nzrGj/8FmxA13fc5z4dsOwUh4cFxyfbzytEiTZIH3/h2pLv/c5jnn766Qc86YPlkZSREu3xHwL/R2DPOfeLlVLfD1xxzv2dRzj/U8D/Dinuf7esgfFdn40RsGEf8N3Dzn1sGY/H2LNp/miyaOF//anbBAqeubpVKifICp6ca9xbwLqGTzSwb8E28JVSlM5Gvoys1GfXB37oM45huubwsCQaQVILFLyOrOItstKes8LukGPgowb2d2H25vbzOfCTL0CSvs5zl6e89NJL/L2f3Q7Yhu3qedu3P0E8eK8hdvdmtXy9f+/9Xwau1fDJF1f8V/eZZRsluvY/P/+WQOFNu0EGbcJWAb+LrFq7BzBYw8/cqljUd5rT95OXEZN5iaCDBfKeLvtnHCLv7guvwvd96Rd4aW55LnMcrnqaB7h0GuB/fh0y5H0+aBRt0HazhLIs+eLrt/mxV6VPHyZfBIKXZFF40PtenCwIgoDFckUcx1ya5pyyLUl2AnyEO7kjgCwCU7WcVu/1YG1QQAC8/e5XX3HzbnlUM+0HkPy0/xfw5/xn7wJ/Gtmy6GHya5BnfdujoiEQKKW+C/gh4Hs3ByqlPoaMtVeRsR0qpT7unNvMie9lu9i9+IBzH0u01uRpTM4WmmXIKhnCHWT0efnCG2JSfX8Ih4d3ftcCzwM12xd7BEwdjBtY6q05tYsMoh5RMht5y//s/fiCySV4+1COKRFTcIAolQdVvisRMvvG4dZ0ARnQP96A+ZmGy+MX+ZkvLs4UAYi5cz6S5BgJI3jH/71EUEXp2//WPe5dAf/L/Zb7e8grvHciu3t8dhNJSYgCIeyLdovSHiQbcxK2fZEDEaKMNsr3JlDWLT/+s4anJvDKQsbDg+Qr/jpPIf1xdJ/jhv55Vg6Ojk+4caN95AHcI8rurQcc8yrw5Xfhe2/d5ubSsDq+icLdYVJo34675WYH8yW8cwuuP0DXzEufrfAY8qjK6LcD3+ecO1JK/Vn/2ZsI4n8U+fPA3zr393+GKKf/COF+P6OU+lWIR+wHgL+7IaCVUn8X+AElu9d+Cvi3kL3bAP76g859HNmUnJ2xtfFnyEu72+Y/Lxv4fKM/x/J72UyOuyfIa0DQiELamDUPC+j6YQPfc1NgvEHqAG+Kyz6DKLsDRDHcLVeBzkJntudoBA28A/xCC3/uHy9Ysp2MmzZt9MhN/7tk+5wVAktb4NIQgvto7PuZTfeSexlC95sTL6/h4wZut6IYn0JWzEeVAWJ6fIwtet30nwJeeMFwHXh9cX/Fcrd0yLF3w/fzslk4ihbmyzWr9v7PeC+5woOVEcA7N+Hw6JgXXlvx1hK+a3jnGLPA1QBuGEFJG1kCP/uGLJB38yEb2fBLd5fG+WrlUf1xAVswsBl7Q+4PEO4Q51zppLD/LZ94uwZq59yhc+5FJGzgryPzZ4TENW3kd7NFu38T+I/8OTzCue9bNsX4B2wDFVt/g0sIlL/XSrJBDrfYkqAbschgn93jvDc5F+/AgwcvyCQ59r8TYH8gbQoDUIGsxE9x79XmOWA2gMuzLR+1gyixPQQh/RTwpbvO0wiy2/wfZDBsePA18twK6Np7P+fXQu43aC2Sg7Zky8M87Dop0lcgyDIB0gT2vWdQ+eOuA5+fi3J7VEW0kYb3OjDOy8Y0VcBrb5a8eHLvReR+cn7c3C/Ibglcu72ib6E6gVfuQqd7QGDeO14KRNE1iLK+lxz6n/l8/lW0+r3yqMjofwL+lFLqP4UzDukHgX/4fm7qnPujd/39N4C/cZ9jT4B/+wHXuu+5jyNaa3amY54aQFiIO3sXUUCbVcsiE1BymkU2q9y9tPQ+olV3eO+AvjtkbKMEN5O9RSZFfO4em8mugXEAbSr7KGYRBB2sOkE+/V3XHgJxDm0n10r9M9X+2PuZNpeAj43h2lIU2ucQBbYxIzd9EANZco+H+hrJHrLyxMDTbD1xN4HZOfL/fhM6YBsWoJA+uoq0PwFsAEEpaDP296p5/1vh7PLgibZBKAfA33/j0bii85IiSmOGvI8NqX/++d8FfuTn4aP7kknw8+e+GyNjcroPs0NBQM7/rNguoKfIYnSb99IACphOp19ly++UR0VGvw95XwvftrVv1//lse7+BItzEn0c5TJAryAvvWEbCzP0/3+oa87LBMhDud7DJGDr1dnM6SFbFIK/78Afp2NIYtgbw6Udj064N6mpYvliOICRkutWyACdc39lpIEgFHQ4QMy6DPhF544ZIJN4NhaOCWTgfK1k5H92/e+9c99tuJcHVcQeIu9hsyjE535vJl1kIBo/GucEPhfwHp9vnNw5W/eu8m04f/xmsVhwf0U05E5HxuZ6A7b9u++fY58t2ttIgzhD3vIc4/n7x8DuSBwoPbLozPwx3+7vUfvfG0fM5tki/3wOyPPzfsivXh5JGTnnls6534AooF8OfJtz7jd8LbiZJ1U2OVOdRw9rZHKPkNVi4/KdIoPkEtsBcu+NgeQF9j7Cd/KQ++fnjonPfXY33N+8wF5B4CDLpLB6Em0HXeTvnSKT4Z0Wlr1scXNpLJ8ZHq5UJwqmqVxvdySKYCfemkMh24m96rYTfHCPdt9PNmjvfgo7Bp7XMhAv8V70s/bPcS9yec+f8xSi7Dv/2cgfnwGDTFDjQMu7Hd7nWuclYavkNkTwFeC7/e89II/kPg5ZXHKENH2WrZJ5EBeZ+vtskNyGKs6Qvv0Y20Vy6v9/Pr7l474tEyVtOK+sRoDqJY9xM9Yitgr/eb+AWn99y/a4lO07eOONNx7wBA+XR1JGSqn/RCn1i51zt51zn/W8zze1KKXI0oRRsg31HyAdNkAG/R4yeXbYrrYz7nzRgf8Z4r1Abvv3eRt8ikyUjUyUXF/5608Rk+Q5trzANJZBMgPGCUyngIUwlkGz6++x46+95/9/VcFsCFkqQ8r5zx+0riWAcpAOpC2DEK4OYS+XyQ0C9yfIQO1q4V4yRNFtnvVBed0bM3ji27KDTNjzSCdHPGZPxfIuzrc5RibGKe9VZto/52bF3/Bj+8AskOtMJ2ArqDo4XW2P37znuyVE3k+MTN4NYjhDjpEogHEsdYGmvr2Gc2ji3M+Vu66/+XuCnJuxnbCbaJ6P+O8jBP3kmVzrWe4cTxbvHMnk2I0C2SDDTkNbSv8/hyjImX/GRsn5M7Ym3aZ/A7bv/3Gz9h/VTPs08A+VUidKqb+vlPp9Sqlfor6W1bifQDHGEKXbgZaHsDuUwfkx7hwcGduQ+vPk847/e5ct8gjwhCFbJXaZ7Qo5AfYGMqj2kIF4xR83HsuqeBVQLSQaXCzlQrJABk2xhnxHBuPHkYH7DFtv0f4MJhlUTct176KeIuHs95MeMeFuexgUZ9CtYTjdIsEUaZsGLl2GZ2bbdkfIxL3EvWWCTOIpMiGmyOD/dgQFnSfMl51MvCEwU9v+3jzjU0i/b9q1WST2EJTbIJNxY2rEA7l/GkMyAlNBNJDvc3/uBqWejy/eODNS397Q/5R4Ds5I24YBXL4sbbqMKMA9tmMiY6uczstmfGyUdOfvteP/P/H3iSZiZudAU8kzzpGxsFHWJ/6zg1L6cuX79KlNP2nQkaC2UG+dNg4YZ6Kwjd6GkYzZoqeP4/Mgn9qopfcnjxqB/e8DKKU+gqRi/GrgD/uvp4/VgidY0jRlmsFsBFkjhG+LvNQNbFXIC9+syhuu52nE5RmzHaSXE0m+bBwsnYfH/piNXQ4e+QTbeJocGYQaoJIJYIBLV6EpoHUQKkl8PV7D1Rm0a5hdgvZgS0Y+hSC6LIMukMjpPIN9TyxZ5NqF/8nYck6bCT9f+eDAlfRFWcB0BFdWojQUkAQwiCCawfTWNnYqRSbVeS5mgxLH/vfM90WAeGiSEeiVKLXOtynXokyNFXMxO5U+miMTvQH2NcylsOUZ8V+eu3bu2zocy7u5tA+jHJYlpBM5bi+A3RS6QvicTR9s3tPg3Lvb3CP1vzVQWbmH9fDwqQxGlZDJgW9P7sfSmveSwhtltOmzIVslulm4PjqVBx4himIcSllji4yjAHGWbHipDog1DKwgIHw/dCXs7sBOKVSCYcu/DQeQpVJtIG63RP/ZmEDG+9crzgil1HcgSujXAL8SiaX6Z4919ydcZOcGWPcwb2UiBGt5GR3blTcCcgWp8yu6gmPnV1vk+MsIWTyawZvH8jI3q2KJTLyNl24HyHMYr+Cy3SKzBTDU21B810LdQ2thWcuKNhmINy2cSjZ9GIAzMjg7YDqAQS5E9M5EMzmwDBQsSrnPAfIMp/65KqStE9/eeSuTvbNyvVUJTnlOQ4Fzcv3ewhvvgvH90vrrxGxXr41Xa48tOtgf+gA6K4pJVdIfm3YoIE7B9hDl8mw7yITYBKUOkf88zTaSe8OdbSZ24f8eh2LWLgoYZRAEsK5gbx/0iYRJVMhkr9nyNcp/1iJ9O2ebijPy7yqMQBuwJfSp1GEq2XJ0m/SZ3Vj6deOoGPhrDhGX/Pn4tM2iFOODUB1USt5PDUxmUB3K+32n31Zv+Chipu0BOzNwJ7B2oqSMH8Q6EscDBiYNzBtZrOIA1kYWnd1jOX7mn3GD6EY8PoH9qOkgtxFk9/9Fyon8rm9m8hq2u3JMR36w+HD4y7tw89jnX80gPJX/t267Mm7s680E2nAL+VgCDfNEXvQU6VSDTJwQmeghSN0duzWhWmQimHbLOWhg1ctnRQNxJAgpiQUxxbFM3LwQRRVnEFoY5kAAoQ5RuuW0lEG5QWkbIjpA0N3I32tDDqfAdAjrDgYjQXuzNRjnTYlWEFOroHMwicWk3PBpLXK/DWLbKPUlEkZReXslBQZTOD3aIsfLwCgWkvnkBgRXYLT0vFoqxdxuG+kH7bbkc8+WXM9DWWB6RNn0HTS9KNIohDwA0/n31cLUP8cAUdILtp7NzUIxQxRN7N//0wlMLOghBKkouVxLH2oEVVT+/515b6rFLtsAUs1WETt//TSQciSna+hD76ELYHEMKhekE7JV9pdCeL6Hq/u+eH4gyjFCwkJmI5jkgpZ7JUgoaGFnKNftczg+2I6PKICpD5qdakGpWfYwqv/B8qic0T9A3t2/DfwG4Ncrpd5/RtyHQIwxlE1P2YmtHCBEZNhJ5+9qiEpwoYezkbykPAQTbT0WGd6TFUK5gjgUxRGxhdJDYKzgSuYRgoLA24AZMAk8+gqEZN1BJsZsB8YRPH8VLo1gGAuktoAKhT/oWimNG4cyQEsEbqMhDjVpLN9NEiHBazyZe+53jDzPxqSaZrA3ExI8CWE0hJGGWSbnly2EmfdSRcJnTRKPgKJt7JNB2rNJtgSZdBnbVdI4mSSbMAYFJDnMj8EmcHS4JcUnOWSea4u8HbjxAO0gE7tFFP3GXEtiQXJpIt7FtoeqkqoGiYGhd4GFbONvJr6diX+OmK0yb5BnNQ1EU7n+Tiq/g3Dr7QqBYeiDLkdiHn8bgnY21w/ZIutQbRVRjKC4WQi7ExmTgwmcGmgCqEvYsLkbwjwZ+LEYydjIUv8uAylHsj8Vkr3soCqgbUCHgjzzHVGMg1wURhiJcu58HzYWsiHv2XX3q5VHde3/DufcdyJm2o8g6RgvKqW+2visD40EQcAgjRhEmsu74sKONAQDWemx0GSyok4CWT0U8qI3sT8ggylAzKlKwWohq5JBlFWCTNoOOKrk87WDdCSKLUAGUgfMpvDUvgyi4UgG6HQKWQhRKgXJQi0KYn4KtRITqmmEvwgjsB5imQ66rqeopW3GQRDJtUPEtf10tvX6bVzLMQLXQ2A6hnEu1w203H+kpD2JgtGu9FPXCDpQCB+h2JpNm4m3cUsTyrM6QAd+wgYyGWLfFytPnNsGdna2oReVRzezAUzGd0ZYbwhyCwz9c41GgoQmGUxzeRatxIyhF2U398j3FFGcNdJ+b82QIc86VFuk1zSCQg8PxTPXWmg66Z+9VBaQ8dQHh2byeQLsDERpZkj7dsfS5sup91pO5b4aUQaHvXB4o5kU/RsCoYNRKgvThkx3QFNuEahxUhV0nMEghU1dNKPErN+MhUTL4lavoNESLAlQd2LS7flxfnUiyO8Dr4G9EaXU9yHK6F8CfhUCCH72se7+hEsQBIxGQ1anS5IBHJ7C2MgkDGPoG1FCkwHMcrALyGPYGUFzU15egydMPfyf7kiVRXuOpzFIzeQ8lHgPBxwfARFkFmYJrLQow6bz5lwlEylQcoOukfvpUKKwe+0RxkCI3HkvK/NsLKaa1tDZ7R7woUcIk7UogKqXfLkNr3MWKLgjCKvaha7zRPipKOXhLtQtBJkoEtXKCtwb4bfyEJQf0BtlvZnQG+STBkLEZ4giNcgk0cDVAaQKnn0GDm7BaArFSiZyDWf7ggUOghj2I+mLzorJmnmEuzeCeSCxWEpB7+SexsFkClfGMBlobi8sdQSZgqgTJbQxsyywF4qZHEYyGdNKFoNZLgcEu+B6+cxZb+rlkPbS/8lElElnBVktCrnuhnTvKnm/fQ+dZ+A3fJHqvBNASy0nlULkYJjCaSlk/MAj8BpRsDcO5J3pWMzr05uCYLWPSxuk8o7qUN5ZnMjvIIB1IfxXh6+X1Uh/DIYwGgA9Z7spv195VM5oYyr/OGKy/X7n3DctKtqItbLPlhpAcBuiSF58o8Fa732pYVWL+RRrIPSkYQxxJZNKKZgMxf5WIUxnUJZC/oaeCAgDWZkvLWWF+8gzMJ/DwVoG19xC1sqql2pZ1R3CN4QedmvDGbGglZhEqfabRq5kQkRaIrCbDhLX0vfi6g+tJ8A9aqiM/N1bmcAhcGki5qOaSD+EocQetVaIzmEE3Viuva6hDwSJ9VpSLEy/rXrQsM37wv9WoZ/USvqss3Le1Zmgj1UNbiyewvEOdIew9wysX4OdDC7NxBtmU7CbGAMnz5B7cj9NpR2Ng9wjAGskKDFPxeQIQmg7y2wEkeffuhD6aqs4M+SdDbT0c++v0RtRhKMM+hrisRwXJzCoZBKH3vbqW0G42sp7jTSsy21sVpYK9zZIoKgEQRnff5MpPL2E3V2oSk8hOOk/50n5K2NR1pV/jwqoHeyEMlZPBlIsr/OLUxaKkuqs3LNshQstV96EtVv+czKTMTX0bmUVf/28ad/nnHvrse70IZOz3V7jhOq4IRpBcxvWFtYriffJIhinECayUsWZDIhQy4sDeclxLCVehwPhD+rKTwjkJSdaOJjAR2dHmYQRxAPIKrnubicEbZYJcZ5GwlNtlMVsrImCiNNVI3V2PDPcVWL3174tPbA+hTAHnUGnwMwh35XBV1awtwe5lefbXcu5CbKy61BQwmhHuKdhDFd2ITiRgXxUSV5aEkLTwpUrMilrI4ggDyGtYWnOhUZo6YdQQz4QhNL2Ep8zjD3BGwjX1pzA7rNSxC6fQLUQkrhrZNUfj6GtZRIFEVSNmCQOQW+qk/7oanAD6R+VbjmWQMlzDYZyvY0Xs+k8/9UL73Ti5J4RQuY2vaDB3YEo4C6UPlYOrJaFbJrD7Q7KhTzTYCQ5cMOZ9M8kkz5ee3O9t4LaOiMmW1GKidd23mGSQjmHIoS2EO9iaGGs5R04ZAwFLVzahVtLUYqlgTST8TYaQKyk/WUrZL61okBHuTxLcgXMQvooQJwXg0DQWlGL2UvDY1V5hEePM3pLKfVxpLja00hu5N+6qxzsN52kaUoWOCYzKA9kpQGZ1NpAbQV2mx6IZJDt78mLTD0/M55AtZQVsGmgDYW/KWsZBHEgiquuhYycnsJuJmkJBwvxGk1iCHeECA4CGeD5UNBP18Jaw0lhacuGKJcBtzuEooBlC0UnE3vi3StlBPUJXHlerr0YSA3moSeznRVzTitI1zJIslgUDHpLgO5mMmnTBuoxrJZeiWaCKHKkb2LvpVmsRXFnSjgrZYSvIgCUXCvRUIXe1BhsCdNmLUS8s3BwKBPPVrIYxHOZ/I0C1fhrhuC8L77tgHarcCJvVhWFPFfQwaqARQ6Hx6Ai6dcuFMfCsJO/01iCIbsKaHxCcihKVPuQ5K6T84IWv621IJ5hDuu1KMIwFDO9WUM0FK9foGUsOOcL9CPtjZUoM2sk3MOVMB5J31UNDIdiHu7vi4IOM1GSvRGlvChkAcHCc0/BbgSFEpJbJ/4e8Za8bzwa6v3isDuDiRaF/e6RT6T2IRwbHsz0srBV1b0yIR9dHtVM+/VImY5/hJS0+Q7gs0qp3+qc+weP1YInVLTWONMRZyO6k2Opg20FUmslk7a1UBcwGAvaIRQvRKw9BxOIOaNHEtVb5WIGtCWYwAeOjWC+lnO7xnMGsdjwkQUimTymkcHtjEwW3UOWKkYjR6pl4jm/2mWheJzWDVDB1R0pb5sPZd5rA3UsbRymsipHEQSJPFvkkY1z3h1tIclg7ANgKieKRQdgjPBdZYWYh1om7TiDqvbckRL0EMYykePcczCRKK00EAWyWMPwkkzM6UCeNYjE5EpH4r3UiZg5XQFoODYQ5J4wj2Ti9Yh5Gl6Fw9tQa5nIUSjEdhbKglF5tLo3EEI2stIHRQVXL4GuxByuOygbMZlsIMokT+HKTBYVp+T5o1AU6GoJwVCUhQlhpxGTrFNe6YSCEF0niiYA1i0ob0YneBQSQ2akD10ATS2fBVbeb2pkPA4mYv5FQ4h7QUfrtacT8JyTJ9HXgSyKgxzClSyaQSRtymLF1T3HVSX8U9FKPFeh4NqBrwgRioKsGlFC46nQD00Ag8Hgsebco5pp/wXwbznnfnTzgVLq1wB/BuGQvunEGL9lcLXGhVLtrnN+YGgPgR10mXcdT0H7wLnMu3YbBCavKxhfEZ5oMpRJFlcy6YNeXLvGCiwfDrwSMmBSsGtoPXpqG5nIRSGTYVU41isxN566EuPaVo4LFMo4nB/IqZ98geccJrkMqCxSDEaOshZUElvxlCWxmIDaI6S4kIlS1J5zcrKFdpxKUX+dCWmsA1ndg1AK9he9KN7JSBSW8eynKWQS1jWMh7LSFrWgx6GPTAx8VKJDFH3XCZE9CEF3EA8F3Qy0N8USuW/pyag0lR1MwkQmMkbihkLP390+Eu9m10r/Fa04F6adRI8vC2lrUQE+7igZCn8ySKX9zptg9DKheyvvOBqIMowTOF5B4Ul508lngfIhIJlHjon0a6/FVJqM5F3Ncqh9/ECvIBqJQkw8aayU8IydEWR3/UDCM9adxA3pUupc1QiCadZw1MqCk4SiVMMAcDAcBMQK0sRQrMElojynqTgolrXwWmUtC05pPT91Lljzjm3d34c8qjJ6Bvjnd332E/7zb0pRSmFNz2A8Qx/doveQeTaA4wXYyK+wVhBD4L1qYSCTY9nDci5kdZpC6yPcihL6SFzgdSncSdsKOXtpX46rc1hUYvYpLROGHjoPq8cDMalwQhyOMphmGpeNeOPmirh1oky0rIiLRgbsJY8A4lzigqxOWawrydjvgFRMIuW9gFksq3ZrRIGcFpDmwntp7fPNIk25soSp9EeAPO94CO0R9LEo4zQRtFN3ojiKlaCtvpbJOxrKBG17IaGTjcnYyfdhIfFbvYPLO96jpGXSNngUFYjJ4ay8gxZZ+ZtaPH2xFs6t72H3EmRzmdQOwMJyDfEI7Er6te8EyRaej2lXsriUlSQM91be3SAVNNO0gsxMC2ok4RZXQuFnBhHEe7KteadloofImEgyeHomSrdJ5LpxJM9XFLIgjAJ5RuM9cYH3wPnNeGl94KbJhaBODbjUK5taFjIXQWiAQM5rWp/aYaEqDW2kOFrKM08RtLlZQHbHMIvgwDstIivmuo4l1CIaisPnceSR4oyQUje//67Pfh931mj6phKlFHmWEtKTZDIh604GQj4AavFaWGQgVJ2YJcqTsVUpEchYUQS99xBNRjDY2NzaI4hazIEdxDxIIzGxmh6Wlbz0yVAGlrIy2dMYxkPNpZH3fHSKw5MVy1q4JYfwOiNPqtfeg9R3cHwivIDta1zrSc5AlAk+hmRVyKQrG1hZCfwMtQxQHQmCSmNoSguRhDQMYkliXZXSJ+OxcDp7O6I8s1zIzqaSvdaiHnS+dYdrDYXxKA6frOlN1OlUiNmdoUyQdSu8UtuJ6df56OnZUJ554uO0COT5Im9al6XnUFppg1MyuXbHsDMBGp/s68QtX5Syx9wwlJCCAZCMBVnEoc8Zy+TeG6fFZCQoovJmHQ7iQSKVDMYwPxElFih5D10jvB4JXB4Iutz4pYa5oI8klbZaJC+wRxap1go/lMayUOaBoLUVgibnJ7C04h1VTojsOPbPrQTBRcHmmR2xE66zbATN9UrMZNuKEu1bMbfTDHanMEvFk6r11w8Z/W7gHyilfi9SJvlZJJ7q1z/W3Z9g2SCj1ijiCK6OYNmIp6eoJZYIH2RXthD6qGPby8AZDSSvancodn7TCJQPlHgzSiMmTBaLIuhKqL3S249gOBEbvelksoKPP4kgbAQhtFYRBnJO13dEEeyPxc1bRyHWbzZoHXRzrywRJdofQ5U59BDCNdgBLJZQKlBz8QRFHsaPI0FDw6lwCYOR5JCd1hJXtJPJSp3GskFAOBaOKk1loKdK3Mtt55XpULxae/swXwjnUawELUychBqsa19jyXupbp6IEgm8GVOuBE0OPJpz3mngHBwX4tWajUT5BFr6eVWLqeeOZGKFHQQVpGONwoqH04rnM1SSIxeGMPOTL1BCFC+WgtysFVf5Jlo5DEVJGe+gqK0QzskM1osGnUF7U1C10WLaogTxOCWKLw1FsaYI0u4XQA7ruaAx3cnvshT01BTyLNoJGo2UeNaCQJ55mMk4ujwSJ8M0EZqhWEucW5ZuA3ZXHrXHnSBgrCwmppf0pflKwkQSLfdarcR03BD0URS9Zx59NfKo3rSXlFK/CCms9hSSsvQzzrnHCyx4gmVTXK1sapyC2QSauby4LBfidZAAhQysYS4kYhDJpEhCWZ2WjSRKKk9mTwdCGofe7Ao8abm0wsPMKwifBlUIp6IC79ruxZRpe0E3kYYsCogiQ9GA7Xt0GNAVhqUNOT3uBYp30s5BJugtjX2AYQrPX05582bNsRLP1DACVcPksky8UerjdpwEGLpegih7AyZIaJuGfCCKtHCwXIhiyID9WcKt2w1tJMis70UZJaEoNBJPpA6FfNeR934NPb/kzYjRVEj5PBKlMhp6c8tzGq6XlTnQkCYhy1XPohQyuzOCMDexeGksSlKlQpoPIkkfibEsrSeGI0Ffo0QWlN4TIstG2mCNN8864QyVEVPFGUFKfS+KwBofizbyfFokysZ5j6ZqoI0lijybgVtJYKpBiPVBLqhYR95sHMr50UAiovuJKIMgEGWdBbIQmkg4uHEsJumqkGsY7QNjvbc01qKsk9DzWMBkltDeaoh3hQCPchk/cSR9ZRz0mSCvvhKyv6vg8lMQhcFjK6MHmmlKqe9QSv2UUmqJpIFcd879HefcT3wzK6LzYvoWi8IYIY33dqWo2Z4nZeNUuKT1SjiKohYNH0Q+aLAX7iDRErcxTMXTpCOZuJtVZWcmnqvZEPpSJmKFKJ5RLitV5CH9vJVVLc9SZrlikkMYJZSlIc9AVT06FrfuaSEoSnsP0CgV5WQ1RGGI8SbkMJS2hD6ITfvYmd4JCjCdoINYC2mqTEeUStjCwkCxkEkfR0AMp/OGLgaz9l5A77JGS6LwMPW5XK3fOqkTXmlnKGZEGnn04Sc1Sswv0/uQikwy7pNMzBGloKh7DOLlGuV+cAfyPGHi87kmorxGiS+TUYOOA9IYRrk+c3GjpY07U0E6VS2eQ6e3oR3Ov7tECVKINWRjIX33J9KGwJvkypueaQI7Yxk3jREUNF8L2d9ZMS0v7QqaRAnf1nklNxvLWHv2WfHUDj3yHASywJysZYykiVxfe7c9TvqwqGU8rCtoIwlY1Grr9WvKBhsL8gsT6Aup2FmUgijXPZjSL1CRvPM+gOUKGms/8Ny0/xqpRf+bkdiiP/1Yd/sQiVIKhSNJh6jOSWyFhcMjWaXaRlbjopKqgL2SVU5p4QG0kkG3N5YYH+Nk8FW9wF0XQmTEZBlmErNz6TIkTlBXNgQqqeeT4CFsJCZgtZQBXlUNLSFxBKm2qFBQSzIMGQWCdMJATI6iktXuuBBFJiu4Jsrknk7D7YV8P19Ke/NElGjb+XwlfExKKOUiYuVzlzxPlSWSLJtGsLOTEhlpv/URxpdGAvvzkSCa4UTMikEiqGM6k8mkAs9BIIqmaaXflrWYxE3jgyUnkrQ7GYiSWlUQZUrI3jCUuj6tmEB9793wTgZ9b0XpuB6ckWhT01nKTkzE0vOAq5XwMqNMTPMQQTu5R0NKSajDuhCUN9Rilne9jIF1K/cxPhLdOUFgOhRluj8TZdYbMbeDSNBZmEiu2u5Q/s4iKQnTB1DMJSyitfJeXCj3q/0Y3ZSRIRDkk+cyBtJEEOHzV+BSLgp5OJJFs6shzkJByCPASvhJGkim/04kaDqOhV/bjF3t8FHu7rEJ7IeZaf8C8IxzrlZK/Thfg80RP0ySJAmBa4mzlG5e09TwzEdhfQjDyyGLk544EBe87oUQtVYGXJIIgVl6Xmk6kRebR5p1ZtGNcAlHp7BWsoKa1iupREyd0Vi8SSYUL1uWCkdA6j0hyrFedRKI6DpAEStH3fSSQ5RI0F6ghMAuK4msTiNRCtZanB8/SSQTw/Vw+ZIMsjjamolVIwRv20KearCWKAxQyrI3FGVtrc+/CiDAMhpqTpaWdQdo+S5A+DXlTdXdfVGuo6mstKMrErtljBC0NpI2XZ3KZ33vM+CVoMYSCexMIkEjXeMwWUBd9LIoeK9iX4PKRIFob8LlftLXLRzOBfGdLjxRj2x02SAIuC1hGYINBTFskMw0Eq9i672LvRWvmPZhB52Vvp8NZAIXrcQ90cpkzpAyKQZ5rmEO5VruG0Uy+ftG+lZl4BZgfVzbOBPFYBwM9uDWz4O+hCDbaJsHGClBuasSqkBMO6MkuDSrJU4ujBRl0WMjMRM3QZ8zACcxbKsDiYTve/HM5ch7SHMJA/mgc9Ni51wN4JxbK6UeL977QyTOOaq6QUc5I5ZkGtohVKcwuBTSrXuygUDfrpW4jMZHXA8z+X8TipmxyW+KdqAzVmI8lOzoWhnOSkTa3pt1ePs89CtSBJV3NeMV1XQEbdtzXIhi0QNF3Dn6QNF1jqoVfiQIxUwchpJFHxqZUKsCjtYNRyfi9Zv5wMThrrjNTSRoqut8kf9AVk8bQFwJM1t2XmkY4SxQgrBCIE4HRO0po0z6UyvAiIllvJcmT6Rf0pEEMY53hag1oXguUaIEBhOJFF96bqmu5HptLwgl9d4wCDChZbkyYtp6zi0IhWsyjfAgGkGHo1zMT+djgmItZtzhiRDioRFzEANzJ9URA+uDRxtBWoOBz89ygm6ikTgEXCD36FoxmYJAlEKeS0oJRhQEIeKZ9fxXb3wEdC15ao1HctORmIrJjiAkFYjiW6xkTCxPJfHWVRBNpM9DJSEKzohns67FxI9T8bp1JxKzpAOIlCMdJdRdQ6dkzJ6cQD8W5F+WsjhaxOtqtPy2CmghmMSPbaY9TBklSqkfOPd3dtffOOf+8GO14AkVpRRxFGJNSxKlpMOKai6u2WbdMxvLQBsOfXSxJ7bzQJTAzVNRVJemnthOxIwjiRhm4PqOowD6BCap8BJtIKtoEMiqmc4lkrfohLtJtQywvT1ZxU1vBZH00PcOFWiUsewOA0IMk4Egr7qUgD9tvHu2kWRSbTqevgwnx+KuVQ4yJ6vxsvKKJ4EdLeaBQgZm18Pl2JcuicUUcVYUb+DEhFjOT1l3vpxGLCZtoMRrNroMrCXXrNMQ12KWtmsYz8S00sabJFpQ4UkrCiww4umrvWdzvpQ0kHgJV6/E1MuKmUeUSouiTZTEwlgtqSsjjwzxq//OQK535fKQmzfXwo9UYjJFRsyeg5UsFMaHQCTejCxrH5nvXf31ieSaOe92D2KvyL0iLlpRSpOJjyiPpVJD08jzVqUgyN4giLf0Hrveu/ZbMY1bHzvWaWiXEvoQLyCaeZJeiSJdL8UcNq2gtFAj5W+U3C+wMn4apdBNI0oV8XYOJrA8kdCIYSLeuaoG7fuuaSQ8JUohx37g3rS/wXb7K5Atqs///XiBBU+4WGvROsSaijhSzEYOvJfntBQ00DYyQItKVhzDNqcoHvhM9kgmwmQEeRKyLirWjaxaQSGdaLXwJaNc4Do+BWLDt3SNj1npZAVtOhhMU8YnNcMxpLFmsZKYHxpLrcQkU5G0N00kfuXdhQyodAjDUU59XJKM5Hq74w23oGidO5vQi1bQ3iD1SZtTIfFrq7A6oG16OifKyjjxQNlhii1q4VR8QF7RQDYSD0yYihcuCqSvFitZ7aNK3NtBIggiDqUPyk6O278kSNEpOJpLu+tS8u2Wy4ooDTg+NkLAWolvSkJvllSCgpaIyeoQrqutBAkuTte0zitl7xGLhuJOvzwVJd4HouiaQPrGGXlnrhXeyMViZk6G/jmMvPck1jgrkYpVJwGWYSReqcFEKgj0vRx7fCxmUNUKSioaiazWngfCextDLc/fI57ay5flWYapjK26EKQe4IMjY9mxZDIMOTrpOTiBOoXL+9CuHXEoMW2RkzSPkwVEU0GPYSKote6leoQOpA/6tZhwgVY87v4cD1RGzrn/4LGu/iEXrTVKK5wN6CtHkMrKVFuIjScklawi2cAjkIGiXjsaB+VSJnEY+YjhIKFtGzodMsx62gLCoaQeBFoGcLMWDmMyUKSBI8/EZT2ZwumiB8UZUd1WNdHQl+awkAxjEtOSRNA5xTQPOS06Sge2BlLvVs9FIVRlgw0V3dyR5YKiVj3sWofypkt/IOikX3sSFjHNFj4Ys1/3MhmMBINa4NI0JtQBehpTtS2qFUUTB3KNKJbzeyOKNRohHErEmfJarH1KxMiXPa1kwi9KpMaJFeSRZn7H1hCCRFOuDHjXfZgLOnVa+JMsl8x4ZwTdrGvhOtJMoU6dZKH7QM/DQtpjVjIRm1ZMkroUfiv0fFQfb5VZ4sMV4olco2okh6xew95I0wSCZNteFJXtRDkPtEchpW/bUMbX7lA+qxsglHuqGBanHlHKx7RGFh2zEmVZGr/IeWWXjz3/t5SF8WjRU7SejB9LEG6WSz+VpefYLBBIXFjmCfKylVSTyzuCzIs1BHvyXWcdxpjHmm+Pxzh9k0sYhiQBHM2XmFhWn9kA0kFAri2d1ZwsDbMZLObiZdOd49Jeznxd0ifCuVgkPqRtGyaDHNVWEncTwfpIEFQa+UhiCycrGGeOVS0EeN31DCKB3YEGlrA7jZnlGc3hgjyPGOc5N24tmDtII0ffwqmR6ItQy8RAi5t9eQr1AI4WhrKUQRuFSEMb8W6FkcI5eOpZR7OUFbr2MTbWSMTuQDt0JoXOxmPJG1vWsGoso8yiEU6oUpIY2/eiiOpOEIMKJZ4mR/gi593lReUVbOKrGwyldk6cySo/iBRN65iMvIt9RxE7R+Qco/0xq+WSyTDheNVgGuGYRgNBYcZuvZ1JIObpqhQCHiumyMg7H/J9QYFtJeZP08D1Sky2USamXrmC4Y6kBY1yMAOPREIxbZZzMGOY1T04z+Mg7yLcvPOxRMWXxif76m38UKAlJMMYQd40sqNJXEpOoO0lPqv26R4DJ4vCuhCOLxz42kiRYpA6SVlBlP6lXYkvW4SAkmoKWerz8jzXGRhf5dGHNgwjQarHSxkDeS/vqusejy+CC2V0X3HOUTctRW2orSIxjuEsQquQ2LaYIKdaFgxHsmIPx5IDlUwjAmWZjoQfiBMxu0IfgFjWFY1xdA2cHEntoqEnuoMx6AOx8Z0VBdEUsPSu+SiSQV9pKIuWLAgpDCR9h1aKwSRFrWsiJQGXh94EvDQWRNOUwr0Q+6TJWFbSsdoWqR/nQvjGcYy2htN1j05lhbU+gNIYOK6gSwXCt97EsAAK+rZn3luwVqoHnEh1TOfNTeXNrLj2iGciyCPLBcHMhhKguF7IBJwvZeK5DvIZhGHEqmmlvncINA6bgIkiTo+XVEC7aghDCauwQ1EM1glSsk5QVedE0QTao7TEB60mgnSHWpRSEwr5PUrElO0aIc5REqaQOiCS4vgrn+ZhGkFSw7G8W4zPnDcyHsap3KdHnjmKobwFg8vIh4HwXC3StjiQSd9aQYezoQ+YzXyplxCOSuHVNjFQceIRnILWatreiGlopT0hkkMXIFxfmGqWS0FvRgmazqeiKAMtyG+cieeybUVp4u/1mF594EIZ3VeUUiRxRBZrFs4SDQP6pkNHmkiFrBaFwNoFEPkJN4Vl0UHuzir1KYSzCBRkWUiuNarvsZ0li/0kTgR2N6diAtDIpGtWUlLDlUI4KwRNNEcQzDR119FWsFIwHRrKopZaPqkiDBwjH2ho8VHNnlxXTmKChgPASE5ZZSQvLNWCXNq+IUtCcQPXMqFq7+KejCFphHzNEzGR9qaglcZoKxHH3pS0lZC4rRUCPxkoos5JTp+PyTGdIKSu8a72RjikwVSC/5KR335nCDjQrkc5Wd1XlSAHC3RFSx8I2pDQBc+5lHKe0uLlCoxMpMSb2b312wi1fruiiQQHdoiysXPhlnp/jXCjACLxejVaTJYkgp1EEGSXi/J3Rjif08J7Ea30y4mFyJusuwMh1sdTMZkYiCfLDqT0jApEkU0GQO/3jOtkzNy+DTaWHLH5kThE0lhI8vHA97uRKhRZLgjVaPEOomCmIU01KopwbcvOVBEojTGGMBazdDqTqO9NH3bWB22WQAr1HCZT9XVLlP2WlTBOSJKYsjBUBpqmobU9eR6greQqBVYI2b4Wk0g5KwFxTgbwYi0lF9pSXGWhFq+DTmUiRxpwMvgXC4lDKUpZjY6PBeUcz0VxHRyDSsDVlkEaM8xlgJRVCT7KO9NOcuhaMc9KIxxKqkUJ4XzuUS8DunYyOSeB5zKcTBrtDKEWIn2QwiQSc2wYwkeez3h2lpDGEKQSn7NqLLGCPMsJLdy4Jbya8oFxKoHlXHzVyrv2VSfm02otbmzXC/pKc5mIeSJBl5knkq2BVa8lGbcWV3meiIk4meSESKBpGknkpHFyfeeE/wg6UerrTmr0lJ6/SZQg16oFlKDQYS65cMNZIHE+iH8g8SEMjRH0kSJpPmkqGwaMhxJLhTcL52sh2zcbc0aRKLJJJoh06Z/dOnke3QmXEzspKxtrQVFVKag40HKNtgJCIb/TQNz0V4aChrKBUAR9L86AQEs8VxeLU2ASyPhuLOgwxLYtKEXZOLrOULfbeKfVHE4ricbu222J3CATEzEfQqLVB54O8iuVUn/iPt/9caXUL3+suz/hEgQBobJkYST5Rr0MmLo2mN4wmg5QvazqtpVdPY7n0HSWXok5EyLpB9av+mXdEkWKURaQe+UxzITEjDPhLPJYVh7rJMZHd54HWIpH7XQOiw6WdYM1Mska4yi8XW9UKIXxPUdkWkEEy9onUHoPko4kuG+SCq9SAKeNKFcFOB0QhzKBk0x+bp9IrEq5rIijlCQdEzRALGQrQBRqVqWlTcRjlia+VEcLpfNubO+u3hRVHnj+Q4eQJhGR86kGpUxo4wMggwhU3UvkcSoTr6qkTfNFSePEjKmNJokU48x7orQglsIvEKoWU6QupB8aI8R5ZwTF7o19FYM4oCkNTSXR2EsfEa6dmCqLlTyT05LOo60oT5f4VI3Ye0cDQWJp4tNMRjAdR8RaosZDLYvFyVq4RGWk8F5diJJTVoJhYycmPFrGBhZ0Iqhu5YMV+0hSinoli8goBOcUNpbo7aYXhN1uzNy+lVK/xtHUcOMUFh4Nd6140Ipyu+NM1ch920I8rdePwPL4EdgPQ0b/d6QI/73kx4D//LHu/oRLVVUsKsuqqmg9+WqNwObxaERsO1ykwA+yoPceNit2e5CKonJWiNK2BK0DyrKh6AxlBwcn8PYxrBysjiWG6Nkd2Mk0UbhNtqSVhMqRhmf2RYHEymE9wRlqmI1jZqOUSRaxM5JBHGoZxIsTzva5CkNJ/FyWwt/0PQwnAUMkjaAxogCKdU/VC6Kh80mhSnKX1gbWZUHfLkl3ElJP/uoooW9bkkHA2MfZOCUDHyX91/ZbT9nYm59l5eOG1lC3HXEqZGlvZSWfTWR3j76GYCTbjo8D2BlFRKko0NEoJnaibNOgx3SGqhcUpAPps4H3FMVDaZOK5NzpRLYC0kYUYllJP8yXRhRwIxM4RpRX7B0K05EQv6GDwkpktrMS3Z2G4u2bpZIvl8ViThYtrBqYLzuCPCZ37qwmVhRLNYEsFcRkfdBi6FGWNRIUqqwgzigGnCi92VAUWGy31UdXpTwHyhE5WcwKH1DZOW/uuYCqc0TKSZVPP5azgShXhyii4UhQmHXCL8aZbKH0zD6M0vSDRUbAp4Afus93PwL8kke5iVIqUUr9RaXUNaXUSin180qpf/3c979WKfWyUqpUSv2oUur5u879S0qppVLqllLq99117fue+7iSpilpYAi1llISacJklJPGsWwcqBO61qF6MV8mucSnRIlmOJAyG1koiEg5yMexH6AZyhOZaSITbH4EZSjel4Ml3Fpbrt+SgbT27tn1XFy7xvn6SZ3dFvgaz4hMCzqhcWIPOCOoLEEmH70oplECz16Wiem8C7crDQy07K8VeWIaSXNpK0ElOhYiNVYSc3O0khIr5bxBpRprxUMVJRlY4S50IpwTgVw3UeIKjgJRjG0vmfUmlOs65+tGhYKUEh8waaygFhdDcVJTNEKiH606NptStI0hTDXrAk4KR43C1cIDRRbCWOEiX+cpgo89JTFLnY+NOjyF261sDGmVTMSqElSpep8ArT0HZ+X/TSsLUI+glmEI04lCW+FWDhZSabEuQKUK18gzaSvmdbFoOe3EO2W1j17PZOGIYkE4kY8v0srXvFYwHChxjjiv4JVXPp2PqSqlv1oriMlaUfyRPrctUSwLmXaGLA4IwvisYKBOpe6UC+DddyWWqPaxUVEk5lnfizKPQ9BR/IEjozGyGNxLImSPuUeREKmD9KuRLbj+IPB3lFIfUUrtAX8X+ENIfbHPAX/73Ll/FPg48DyyZ9sfUEr9awCPcO5jiTGGIEppul62Jx5kaHpCpdE6wDorCZGJlM+wHoJHaBorHISOtLh9hzGq70mTDHCMxhnTVCYKiQ8iK4SzOC3h5nWx77WBK/shSe+3kemEQxhkkMcBeQiDYUY9PyYY7lJXC9LAyaS2Eu/Sec5mnHvXvBIzpQgk8XdZyCArTyxNJAM5in3+l5aBOQzg8tiblDMZ1KLHHEkCrrN0CpRyBMpie8NJA9TiUVJmWy/6qJSiclUv0dlZKLxL4j1MiRaTzkRSDaHpfQUBH3pALCTwpjRJ7xVCmmhiJ0owixWmdIQjMWurAIrCoYyYfDoVkjfLxGzrex8VXUl7T+dinqjAR5VrUc5hBrb0IQi1tDfygZImkJG+Xjr6SO4zTRHPVQZHNxxqJMTvZntplM/299xhGsukHPiUoXQgYzHxCtk6T2jXjpM13K5EmdcraXemhHObTSUsYSfzToleTNQo8oXxInmmwwX0YUyoDEpZnFLUBg6O5P1evy710imFQ6useI3DkSihs73nevPYxdUepoxeBv6V+3z3r/jvHyrOucI590edc28556xz7h8BbyLI6jcCLzrn/gefB/dHge9VSn2nP/23AT/onDt1zr0E/AXgt/vvHnbuY0kURZhmjXGaqoKj0xU3Fi3LuqbpWpxpiCOJgRmMILUwGWfoUMvWOQbWpcWGmq5rqYzlZLUEp1guKzo/0HMtLtNLMxlA+0N46mnZyWG2C6t5j8k0pvE5VInkqXUupLcSedynQ9rFMZ3KWJU1dScDOAk8Z5NKflaiZPXMpxDWPoBPySAfTiH1/FAUwtWdjEvjENdIMOTBUhRv7qN/rRGz6tqBcFV0cDpvaW3Aci3faY8enBYv3P4Q9lMJ8Gw7WC4lOXiT05ZHkOSJxCOtfXXIVJRy3Yl3cL2Sa+YpEq+TSB5Zmgyw2kokt3bs7I+IWnjqSkBqxPxordyrb8UsUr2YptOJeNnisZgkxvNtOyO4ugv7u/D0ROIt3UAcDZtUHKM9D9UJmohSKE6BTJTmIJcicmoCwVJQbhKIAt5wSToUr9vSm08uVGcbhToNJ0tRhq7x6SepmKmDQJRyPJQE3iyXfqrWoiTCGMJUMU4Uo1AQUV9LilFXw6U9TW5akmREbx2xcuSxjw73KSFVDbM96WtlhaCfKNgZJ7Stb3PXPvZ8e5gy+tPAf6uU+o1KKQ2glNJKqd8I/DngT72fmyqlLgOfAF4EPgl8cfOdc64AXgc+qZSaAVfPf+///0n///uee497/k6l1OeUUp87PDx8pHYWRcGiBWeseL1CS4QMwFVZclL1LFdAIhDZRdBWFWGYyH5poS9sFlgGacrpCeggpqtKCBSnR0JEn6yEg+laWa2yWMyH3ZnnMFJYH1t2ZxImYHvI8pimrFmWPn5puSbKc+grIa5jH2AXCaEchgFxmsoWQwMh3FUqynCQSVuLtaAeZzZ5PgFVZ8mHAbr3SKmQgL6FEZN04JWjU5KI2cea1BVEqZitOhQPXqjE+1VYIVgDZFUdzyT/CyWhBU0vdXWKWhBA20m9nNr5YEEnk7V2wslcmiZEQDqM6eqSnkQig6OM1emKZJoynxsaJdfRiIlUlPALb8OLN8RDuV6LKdqVwvOkPugl8nbB6QJOGo/AjOxz51pfq9sHUEYxEMmEvXRFXPfZWO63M5AI6cHuFu2d1hI/ttmqqmnFjB6EMI5DlJUI7vWpmHC2hmCgsJ14uiqEuA684k4ngq4XhYynABkvyil0GElaTisI6fhU3v/RgaVPRsznK6rGUDsh02dDv913J5Hge7mQ+mEoeZcLC+uikeJvDuIofOx0kAcqI+fc3wD+S+CvALVS6gZiAv8V4E865/7mV3tDpVSEbHv0V5xzLyOLzeKuwxaICTg89/fd3/GQc+9+lj/vnPu0c+7T+/v7j9RWrTVdU8vEVOBUQt8KeTkeDInZksuTgfAsfaTpmzUOGfDX57Ir7O3DmmAEXdHQxhnF2kldn07Mk9jIKlZVAt97B/NCYm6WC6gjQR+BD7Qrly2dUvSdcAmjYQKuJ45jHAGul0EaKEgChQ5jUmfIJwlj792yvVdClXgB11aKZyklyqioCqI4oq8MRDKB0rHwL7b26QZWCNfeB+ol1kIyke2fU9idpnSNxDEFnjNKkBU8S8R9H6bhmanW9KBidVYKdRPXMwyFBJ6MZLI6I4oB0xMkAX3bkg4GRKZhMAlYLyry6RCzqBmONeVaXNEbcyqNpZyuduJWr3vhSrLc798WyrOtSjGDkgzoBHXEuY8QD319JSsKZb0WE8YpoBf3fF9IxPb1pSiP1VzGTBbIDr2TRBBmlvmCcD1YHbGoO2oDJ4dgEkGNT++HhL1jMFIMh6IA84SzsijFSgh0jHCPTS+8VZZJ2HTViXLXBp66JFUILl1JUM2K6e6YPJYSLFGmReH50I+ul+cfDKR+1GwggZ6TSc4wkoBWrEXrx4sUemjQo3PuTyml/jvgVyBpQMfAZ5xzS6WUdm5TEefh4tHVX0MQ53/sP14j3NR5GSPhNetzf9d3ffewcx9blFJEQUQUt4wCg21qVn7yzUzNaDSkPV7TKhnISQzF3DLYTYFaEIcWknY4VjSFY/fqhKPjBflQoPRkKJ4V7YTfMZ6fUJ2QmGHg600XgkLmtU+NyMHUjtbIqun6ljjJaboOHTiyVGGsIww0lojeWMIgYHFQs+pFERWdmECjqUL3jrKBnbFmXUm8UJqNOD1dko1zgrIkToTPUiNRnK6Fw5WEA+QZYODS3ozAVHS1eLG6mzUulP2/8qESBjzqpVYRQsiXVS+lYxNF1jsSrSGxxMaRKeHTKsRc6A2clJKgXBYwyTWm7CTWqu6J8yGnB2uiHG7dWJNPA5qFYTAC3Ypn0FpBPlf2BbF1rXit4kj6XbU+ETUUE9pp6a8gkCjrQPkqlP53EvidPWLxQikELSxr8dQNcsisT/FIxfQyQ4ksR/lFoxKzaHI5wTYNoHC9I52I4yLah6p3slOtdaRxQJsY4ZB8gOMolZ1gTCv8ZdPI8+2MYnrXYU1PFMD+VNJp1FRxctxw9fKQZr2kbMXb1heWwVT6oc1kQSxLv8vMSJB0GENdlWT5ALMsUPsD2vbxTLVHisB2zi2B/+XcJP0epdS/D/wWpCb2Q0UJhvuLwGXg3zhXtvZFhBfaHDcAvg3hgk6VUjeB7wX+V3/I9/pzHnjuo7TpYRLHMcNEs1gYbnv+Iuhk0ByseyK9FmjeCCpSTqBv09Ri0iCoxUWwXjviHBbFmjCN6MsOq0ThJEjgWBQKNM5jSOKUtKiJQ5kUWS7kdtfLStispPj+zIkXJ0wG1E1F0xqSOMQpTZqEJHFIFscsl0vqXhPEwjP0TrR7nIEtHbUTBBAUlg6/g0Rfk49zqkXJ2khZkbKSiZyncHknZZTXvHsi7VpZODk+JcwmHM9FcbqxtPvpy9A6TdD3VGu/xzzCWySpIsDJv1ATxjHWNtA67FAI32pjjpTilrYeDRzPOyoryDQPDXUHg3HMat6SZuAKw2iiOV1Y4lSUGAjqKWq8V1Q2HEgjUTTrVpJPQw0q1BSFRWmJVxrlgPMpM1Z0q/PKU9WihJreb3aokUDHUxg/LShYGZjOFJF16LFUW3CdpY0lMLZeSHKg7Rt2phFHB50UPwsh0wYM6CTE4UhDvwU1gpC0EhN2PBVOrOgk/WenWYNKxAEQwaKWraxc6ZjMQlbLtRSL63yIxERzfGzRfiGNfZxWmgjHNgzFk6jCiKooIAXVLMnz/LHm2yPjKqXUvlLq9yqlvoBsUfTLgN/7VdzrzwK/CPj1zrnq3Od/D/hupdRv8sXb/jDwgjfhAP4q8AeVUjNPTP8O4C8/4rmPJWVZclw03D71GwU6v+lg7wuyx4pBFjKIBc7qQHKS0jyXWse5ZGuPEhiPFHmomGQxeRKS54F4Rzpf8EsJR5INIIs0VVlTOL/lUe/zkLxL2CDKazoMGacwnMQ409D0ltMK6rZnlKekIURhTFFUFDZgXXakiWxzHabiAj48liLtZS2DMfcpDXGYMBpN6MqSeJiyO4RnRtIHtRXieVHW6DDk8lQ4lJ0MZtMhGSW7u/L8SSy8RwiE1lD5gEDXb0zOkMA6wjDEqYAksLi+53Rt6TSsTmVSWYBenhsrhPIohCt7Obue+1p3AUaBalvGE826hmiocL2ViOVCQhkCJeai9ukky8YrqWSA7gWZTgYwSANiHVC3cPtYflalN39aCa9wWjGINLMsYDLy0deB9O0wgdMTWCh496aYAzaAkxPHopXgzKa2xKMRtpeg1nAYkNAwGw5kx4/dBN3J/RYmoDKwmPdcPzCcVMKDWSNR/qcrHyBqJGh2mAgflyQ50+GAb3sq5OoA9scZrock12hjmO1MyUIhtocjUJ3FIv2yqESJZgNRpHGO36JLUZUdrYHjI2jDlKIoHmu+PRAZeX7nf494r/5V4DXgbyJu9n/XOXfwKDfxsT+/C3HM3jpHdP0u59xfV0r9JmR32v8e+Bmk5vZG/giiyK4haP1POOd+CMA5d/iQc9+3OOdwKEzbSinQVl56g/AGwxDmC8dg4EgjQMN4oAijkNh11L33aljRHgrJx+pcQxZHmM6QeaK07kTRbAru1zrAWUseeBOl9dC/lvo0xruzK5PS2zXKWbIkx/QFTWDQQcjpaUEySEmp0FFMUC2JIsWqdDgtnqMUsffDTgbw7YV4pqY55GGPbQsGkymHt+ako5CWHuU9V7WDW8cwyHvZGSMWnuXW6Zq9yZRQz7lySczPuJGVvVUR2cDSHBmmVwfgLHVdYeOIqu5k5xMgizup7+w9Xr33eA2Hggj7EA4OZeK0xyWjSYpyQmQt1h2kCUPX8O3PDHBdT6ktq6aDyFeJjETxx+E2x2x3CrEpGc3E/IuVVKs0bcUwkXIjcSyoGGBnnDK2LX1n6VXAumxoeuFjlJJ3msUw24H1dXj2OVHOdSskdGCdJLVGENuGMIIgh7427FzaAWsZ5gNu3jygC6S9uTP0gaJKpNaU8ekgbQ11sPXuaSVJxmkoHkSZbZa6s9RaYdYVOgrAGcajIcrUOCeBt+5ECv8Hsd8yK5YxqDpZwFwriwmBO/P2jcYQW0Oapo815x5mpt1GFqW/DPwR59wXAJRSv/uruYlz7hqbPrn39z8C3NMd75xrgP+T//mqzn0ccc7RG0uS59j5SvbfUjLY0lTcsSqFtjMY5LumcyzKjvEgpm18vlIAvS+vp3RAHIQoa2jx1fp6b6e3sD+FPE45WdSsWoH82om9nmYCl/MwIYgc/TCCdi3bWbc9p65iXRmiCALXo/OQrq7Z2Z3RdoYoHzJwNYHrWTTyDLqRVXw4DiAw9FZI5yRSPtJ3yOrWAfk0IzQVw4Giahw744BgbYi0lK9dt3BpxyueKCW0JY03h3Ym3kOURuwMc46OFpgc6qpgOpkShTHL1UICC614EfdGCVnYUSeW23MxeQaZBF/GA6jfhL0r0K4g3dOYuiZOE+I4ZTAIaMqaeDqRyPckwbanZIGkR6QToIXRIGBhDXku6HReChJanvasawkiNHbJeBpT+v7KA+FinIJQW9aNou5hqDrZNy4U1NC1YtImoY+X0rKgrCIfVrB29AaO17I1lb7ckqUxl/OWS3sT0ihCKUVTlwxGQ/qTNeEQ4sGQwNR0pz1hIMXNTk7FGTEJZKy1HnUqI8GdcSyljpVxpFFAfdrR54qoM0RJwOG8YDAcyDZQAUymgsI3GQQnx75uVCze1uefkuDRvneUpYwf18Puzu4H600DXkB2uv0XgV/qXe3fEqK1ZpinxDSgZQPAg7mPRHawv5uRObg0G0nhcwU4iSyepqHsowacVGCdIwpDhnHMdDhABzHKwXQoQY+JlT3Qyxqqpqa1wlcEWq4ZJBJLkqcJVhk/wVqCIBVPSqBRXXeWatE56OueJE1I4phBGhHYls6FqDgmYltCtG2gLI1EQrc+qTKKGWYhqe7IZhOqeUXjAk4qB1rSNJ7eS5kNAykaH8pAjnNIgo6jRcvLN+CkkMDCroPeOlZVS6UUuobxZEqkQdERpTnKes9WC+tWbCntvHkWyjUaJ9HRbSrc0d4umMrSAOumAWfp+hYbauqmYGcUkUVgCLGhxM6sV5LTVhSGZSUJumUvXqwkcESxPM96Kc8TupbRSL7vfWxVsQIXZATKMIgVCsvc+AoM/t05IyZg0Up4wyyB8SDEVUL2h5HslnJlDIGO0YEmzsBYQxRqyqqmdpq2WpOP/A4hASyWPV3i+atYeMrGismoU3Htay3BiTqG2TAk1Iq+bVlXHeseqtIJraAVu5MBqW1J0oS9XQmQXHvnycmxZAC4XhK2Wy0WguodWRQSJxJEmQ9hkoUkSfJ4c+5BXzrnfg1CCP8w8J8hJtY/RHb5fbxElCdcnHOs1gU3Fy2rQvZJe3ZXsrGjFE7mFWowpG1KrBabfVX5LYGdIk00gwBms5xhrGg6QUNFVUtZDyM8VO29Z10lZKoKEwn7jySD2yIrt0ogwlA0hpP5Ch2HGJwUysJio1AUYa7YnYy4sjthNhphrOVkWdE5RZZEJK6Xzfc6iU9yoUdHka+pXEJdN8wrS98bqtWCaKCJnGEUiRlQupB3D2pQSlzLSszXpgPTG1ygSbSQu3UnK6sGsGCt47mncnTf0hpNT0JTlixbv9NuDatFx8nS0GpBoLGTCWaccFOXU/EeKQVxqlAGRnnOIAkJgxjbW8qu53DZoIKU3WHKNA1Q1seCrX0EdSOu+HcOJCr8ZG5YtGIGpymME81kPJXAw0D6pyikWmKzXhCnA/I0R+mETMFkFJFEvj+8G33jcCh6uH6r58iKApwMJNQhTAIGWcQwDtEEGOto6gaUpi7XTKZTEgdxMsQ6x+40p17IwrFuZbumqwP4yCUJucimkjKRqM2+ahGt0zRdRxopskzSQoZJQqAUTd3S65jVuiEOQiaDmN1JQrUAvGIOlezikiufP5dFNG1PmsQMQsizBOO+DiVEnHPXnHM/6Jz7OPBrgZsyrPiiUuq/fKy7P8GilEIr4Q82e1+tajg2UhBsd2fEWPWk2RDtxH27N5aAwlA5GqNwUcQwMATxAGMcq9OKIAwJccRZzGigmMWy6qW5rJapkvIk2SAmxNvrDuJIkUYRxjiIQjKtCJUjHyiyJEU750uFBmjlSNOcONCyTXcgcTuR1qgglF1SA/HeBR10KmBd++TJQJCVNR2LqkcFAcuF8CLLSlbBdtmw6mFd9cxGIbOBrNKTGHodk0fSF4n3KC5XMB6k5HnOKE8wbU+YzxikAU9NY/Z2dxiEvkhZKEGVw0wGv0O8dK0R3qJ3QuDXVkzbphYOzHYdRWPprWU0SBiGMbvjAZFqieOM0shzNaVXSK14LnfGUjBtEMHeVBMZMT2JoW0sZd1TO0GSl4bw9NWMzMBoukuoYJrHTMZDZuOEYRKTxqlskICkd2gfzbCuJZ1i2MBsJqEgTkHgDIGOCdIReaIItMLoGNNVpIMhbV2RjRK6do2OBywXJToTFBY6qSW0RrZrIoR6Kfl7QSpIM8sGxFoTxiFJFBNY6ANN3zbUPVitMU1NGGsWqx4TjagXDW3qcwNDGRNjDZf25b0G1hIkEa5vGU52iV2PUTHdJknwfcpXFaXkd5L9ncAV4PcA3/NYd3+CxTlHEEZShCyVQmSRg/mJwPWiWFH3jvlKPAixhiCImK9BRQNGkZMNFKOcru8pSrCpomorBllEHljhSzwkDjohNzsd0zcGZ3rSRBMgKRi0DqsjBrFiHAeoIKYLEgJgOsjJYgGqTdNTNYbT+SlF3QlR1zVoHTEvSo5WrZh+51IZMmcY5rA7Es7o8mzElcmISzsTRnHI7n5GXxnCLKJcQT7NUY2sSOuiZ1lIKYlVKSVSmsbSIjsw6c5XI3SWwSAjDhKS0ZhclcRpTq9T+t7QKtl3bhhIBnpTQx+ElJV4/wInSirSEm+levFYrT35jgKHYpBoQhWQDnLW6zW1G1CXKxKtJck3lWvHqbwzFfq6ShpOV5aTNQz3gTmksxldu8b0gAYXxZi+YzANULYmijNckGH7liROKZuOpm9wiGnjnFy/Wkv7bh5Ck8KNAylF0vZieoa6J9UdQZCSxAmha0gHE0LTMdvZZRBZdnYvy061ly8T+jCSygiHlQayfVUaSS7bOIX9HOI0ItSW6TCV0rC2w2loS0uYpIwHKZcmE3Z3ZsTKMppmRN2K0WxIaEVJJ4EkEK96iYdbl2BURNN0DEZDYm3Z279CHjni+H5prI8m7ytk0jlXO+f+pnPuX3/40R9eaZpGSnSEssr0SkwD04otvWoawNA0EESaddlRW0hUTZKMcS4CZ0jimKtXcqYaMHDzpKQwir5pSGO5fpYLBC4XFUUvhcrQASPPF9kA5osV68YRJynDPGU3CxnmOVYFFE1LFAt1tSorbi9qjhenFGVFqyKsbanrDudDA6znNNadrJTr2kcTa5ivC0wQ0HUtw8kOqqqYXZoSNh3TvZSuKKkaMU1vnvqcsVquSwfZIGWshMDPB/KZDRI0lskoo1yv6YMBXduRxQHTPGAQKtoW0mEADnSmObrRc1BJHSKDmEitkdKuhEJsX5kFXJlm5PmAQHXoIKO1Lc50jCYzgu6EKJ/hlCOOQ8aZ5OiFTjxNDh+HGUpA5f6ubHv01Hdo0m7NeLzLIN3sFuLIkxhlLYPRlNkgIosVg9EMTI3RmkAp2bYqk/fpalBD6E7h6lMwtPDUHlyZDfjYpYQsgFVlOVl3LIo1RVlCmNM1JVXXYfoWrROSQHHl0h5Z0BHlYgZmgU9b6aUW1aoQ8jzWkOURx8uO06KhrFrarqHrJErcaQkfefbyHuM8pLMKHWY064oknzBIFFenokhbKyjP1LIDbpZDrHsuz0aM05Q8z9B9Qz4YfuCJst+yopQiCgOWS0nPaDx8DxIZuJMsZjrISZQjHYcMIksYatk+OUpJ0pAk6EjSAcMkoisbwmxE0fZSFtT1DCY72E7Ix9pITJHOImJgmCpiZeXvCAZJyGSUEQSKNNT0vaF3AZ2CsljSGY3qxJRcF5Li0QNJqMgDR6hDTKBIfAJoUYkSuTKEy6OEPJVE1lTBIBtC1xElOavFKX2SsTiZQxayPqk5LeFWBV0hZuxqJfl1r74tEdlv3qg57CT/TQeaq5cCtDUYQuq6waqA0LVoJRtlnpZSHjbLYsZpynNXLxE2lngiHizVSvxMGIk5te8/H08maCch2qt1hdEprq9YlIambaiKNfHkKoOwY3cyYzKMmY5iqVIYb8qx+qL8hcT9HB9BvA92bdnZ2SEIAwIfhd0aR92UhGGE6VofIBbSVwsIMhQQBCEWidnpnaC3N+cwj+D4FuiBpGhobbFENEbRdRWRdpQ1JGnMJFNopThYdRTrJTYIqJqKk1WN0QmLheS1LWvh0pwS86zv4Ggl+X+R63hqf8wgUgRhSGctkba0ThCZwbEuaw7XFmc6tGspDRyv59SdJLZFgZjfPXDcwtFaPGodCcuiou0M14/W3F7XVGXxgXvTvmVls6NsrwTWTzO4vCs8hgmg7TqqpkWlIxJ6RoMR42HGIAblLMVqzaJ2nJ4esCwaagV9tWSYp+RxyGxnj7BfU7Tb9I/hACLb4QIoakfVG6pVR92B0gGjPCOJY5qmoXIa27fYusIQYPqePAsINzyFFlf4ou6prcKYnrZ0xImYaF0POL/tUBNQ1OKRGAx3iAJLkuVo1zGd7TCOHLNhyGrZi5cGIYFtIMmjxyuB7+tWItFzH+ci7LpmnMYk2QCNIQgjFBaHVGN0zjFMNR+9tMP+bEYURbRdTzxKyAPx0jWheMG6XiZa10I8BboCo0MWZUUca8axYjoakKcBVgUMhzn7A5jt7FLXJZ0NCZQiywL6ToIXw0BqAimkplBlYXkkCPi0aNC2QweK6SAi6HtsMERjGI9HTFNZtFqVY23L0zsTruzOpLxKJIvLYi3ensWJL01cwTQLSJIR1ivk3jiUbbEaymJN7zRpljPJFJPpLrkyxPEArWCaaZ66FDNQEjYxSQXhbtBiiGT2t1EGfYuKBvRdS2uksN8w87xmEJPEEXEA42FGFHgOLR8Rh5osCXAOCGAW+NrZRv4eRo4gjtgdpzy9mzMb5qRJfKGMPihRSpFnqZTPaMWEiUJJn9AWojglS1NC16F1SNErcE7qVq9blk3NYtlT25CqXNE2Bhfn1FWF0xnFuuBg1bKqpfDWcQlv3wQVRURaXOJFJVBZaciTmEDLJgFGJ4R9iUNTdZrluhSl2RqaVlZHpSDze6+l2mEI/v/tvXmQZVle3/c55+737ZlZVV3dXT3DCDRCDAwEINsgCYw9GFkgIaQIQsaEsRBYhEUYY2wLY8m2DHZYVkgQtghAAtmygxESEsIGDEZGMosQZgCJbRa6Z7q7tlzfdvflnOM/fje7cnq6qns6q6munveLeJGZN9/73fPOPed3fuv3Jy2XM4mkVZ04VA8OQiaREnykCMaxJoon1E2DH8ZY01N1hnXnSwnEYBbEYwmvB72o7tNEtJXeiTO1HWq0gsADfLq2kQWLJQpDgjAi0gaUpsendxprevLGsikKyqKhswLCf3YMs4VUjo8jKfJ8MoXpdE7iQRIlVHXLqmhYVQbfWtq6wQvEGbTebKldgOlK4ihAD9G5ppf52PQiiMpMfFJhIrWARV0LFriv6Y2lDwISXZEmI6y1GBUwG0Vcm/nMZgcCtm8hiGMmviQP7u3B9RAWqWAkNQqcCuibHO2laAt57+SZWtBBQtsZ5uOYvckccORdj7MdddvT49NULcaTsU7SIeE0lKJcLxowmGwrpUCBh+8pPAXzyZhJPKBN1iXW9EzGKbcPT7mVGdYZRIHGeSl1acgrMcNXRhIyTScFxV3TsK1azrYFzovQtkd5wQ6Q/42krhOHn1OyUWeDIzuJ4MpsRBoGRFFKGseMAsU4TRilKZNIEWnNk3sBe4nPZO8qV6YBk1CzWOyzGIup0BhJLpuNxF9hfGiLDu15ZKWYh8oN+NF9T2NDYnqS0Ed5EVEcszeNuH4w52AUMk5DaXkUSmV14vk4L8QpRd9UEkXzZVNsB+HaNy2TyQSNpBmgNKE2JHFM7Fkm45TZZMrT05C3XZ1KgWgorY50Kos/RE7pJBRNQzup8lZAHIS0vSWrO9brNVnZYPse5xxhnOBriDyLMZKo4JkST/vEASymAS6HeC6amAqknmxZiIl5e5mD1uyPI9LRRPxiZcamtNSeT50tRVvDYxZaonhK3Vmqzsg4AZSkM5w3LphHApmRJnB9MeHa3pgnFnuMowitNGUHjTE0TUNetTRGMZ3NWSQOHSZoBbPYw49Egws8eR5npQQqdAsePSqaEOiOJ67sMQ6k4ea1q1NGgSZNIsZJyGg8o+9ath1o10lTURw9AhPS93JI1tU9sH5TwmSc0DeGyobUVU5HRFmD7Vs2JTx/BB+525G3hsA1HFy9zmiozNdaQ5vjAo3tERsNSRt44kAOYhfEuEYy/bumonYebVPvNKM3iqy1OOWxN5WQtR9KaLjaAj5UTUfeGIwVzAatNH4QEvkOq3yOMkttDel4Suo7WhvSOR9PWdIkxotGxE5S6buh6l93QOgReYbpdKhtW0QEThNEKXm+4u62pu9bMXf6klEyRnkhfhhTtz14wqvooGg7NusNZ+uKVSmZ3E0uyXxhJ3C2dzLYZpngCWWSUV41ltPVinXRU5Yl1loa5eMHAV4v2MzTA6nEH0dSyrItpD4vzwSCI0Yy1ONAszcdD+kOHmfbHLTC8zxM11D1mraztNaSl7VEbPICi89209H4Er4Ox0M9oJITOokVoyhgnKbs7y2INRjno3XAdBoxsj3TxYFgUQea2WzO3jQh8jS9kwxzxZBN7Umx8pmTqFHfiaahnCW3Mc72+MmYkTJEcUKoFelozDTxmaUBfd9DOEbZjiCMURhO17BqJUcMxAHfFUAMhXGUmxOieEZdVeAnKD+SJFAvwDiFH8aMAsON61e4NgpZLPaJk5TFOCKJA6JQ8pWOVuI7qgo5uOIpqK5iPJ8TUXNw7Tpjr6YHVkWFQr6fMaBNR0uI72rSWSyaT2tRfkSsLNOxaJCHiD/tdCnlQljDdD4m0JrFdISnYJREbzyEyCcqaa1J45Crs5A0adGtgFKRCDB84HtEQF3m1NZRdxX7KKzz8FxHGECkNZPxiLrYksSRpOsbC87SNhUq9ghyIws2llOu7410ahj8GWfrRiq/TUddVBxn8NS8obFQdI7UL5hPxmgV09Q1adziGUm0K/uhFmrIgm6VoC9iBLokNeKwno5HrDY5+A7tOozVGOfYZhuSZDwgQXocnSxZWRFA0QoWnwTtGdBJAWqzhclTktUdJUjL6mRMFPpEUYypVoynE9G8ogDlBUSmwQQpcy04HRZF4DlWm4yih+NjePpJKUA+3oBbiG/KWsfTVxecLLf0fY/TPqMEYl9RVR1NEFHVLaG2lK1FWUvgw3w+o6hLjNVUjeHkTADexkMK73oliJteB348BlviT6e8cPs2DkVkDHt7cyZJQOc86qbF6QDfVUzSiLa3WH/EZFyzPIU+lKDCBrg+h8hA4BzedEFTnJJM9tFNxjQNWeU+xjpCbWnqisN1g3Uwn+0xH8eEUYwi5mA2Jg1Wgr1dyzrxFpIW0QDpdEpRVsyeeIK+zkmm+5h6ix1LisQT+1B2EtyoWod2FmsNbSu88sbRe5qitHStCNI7FmjgaeDtT13jZLVlOpuhlANnLi2IYKcZ3Zeccyjt0ZuW1UowlH0ngggLVkd4piVKxqRByDj28Ogo2xqLzzz1mE0mdHVBYWJ8erAd27ojrzrqqqCtDY2R2q2kF3/L8Ym0q8lLOFlL1XTZQl5XbFrpMNI7ReB5LJcZVdPR9ILmqJTUi1VKTrKqHGBay6EwtD/P8pbNfTCFqwcJSRRQlQ7TQ9kZ2q7GdAbP0yjtmE1GvP3ahBvX93G14C5t9QAZCyw3cGsN8QKeSuCZa5qztZyiXdeglCLLNvThHrbK6FRMWZZ0bYPyI3rnEQUee4s5Tx5MWUxGxHFE30iOVZmJNlYYUI340/ADjo+PeWFTcPPoBON6tDNssgrt+0S+wkN8dh4WZ1vQAW1TE0Yj+lZ8JGEEuh76lSFWyXolWfZZtqWxHtvVKVWvWZcd1hk8LyAKA+qqJGscebblLGsoOs3eNOXtV0c8syeY2vUAlucDNhNfW5KM6DZrOn9CXWX01uNwVVLUNVlZ0PQSPMmKrTiTA/CCSIIqraEzjigQXyMxPLMHo1YCK6sWjs+2BOkI+ppOJaxOj8hbeW69L2UoswnEoymmyal7RVV0ZC0EnuKJRUqiLFUj68eHoeRGNMZtlrMsDHVZsNzkbKuO5rwY8RK0E0b3IaUURZ5xtBWITs+I42+1FcjV7eYUFcRoZRhFPpuq5+6mZrXuJRqkA7K6o7UedDlNa9k00LYlXZ1zVguY2SYXoTGaDiDwRqAgtrmYhp9yPeDTbsz5pCevMR8FHExA6QBjjXRq7RvquiDLMvLWYxKKiRRoqU3Sg/O9KAWEre+lz9XN7YCiqGCTV6x6wW+uqoZNLq2hu85iup5N2VL2mqrp8ALBMgqRwlZnJEt3GkLiYLofcPvQQiwRGJTP2SrDaB9dnzKZXcG2NdXwv2msCVRPayAva4raUDY926rBaSn4dJ7MvamH2sAA2rLD6ARTdOzPZvhoTs8yTpuevNjStR0qSAi0Iwp9lJ9QZCvq3tF1Yra0boAOiSV3rEVKQYJUQvx123F8ckxuPRax42AcksQJnlY0bUfnPHx6PD/AU4pYNTRtx1FmOM3h5EQKYZfAMbDt5Rk7U3Nw7UkS3XOwmKOcQzmD7WrAiZArG5xW1E3LtmhYrTfkZU3f1ph+OMQCMV1PS6h8SU/QBvZmKWPPsreYo0xFVksLooNoeHZhQFMjzrIgYZ1tMU4qAXoLJ5uarJbym6sLeCewQEzZqoJ13rHMt2R5hsFDu15M1UvSzky7Dznn0J7PZiXNGZtSNoH2BFQrScbDKRujcEzTBNU3FGVHFGqKxhD6Ec6I00AHHqbK8bUiSkZMgpxtIQ7ZKBA4iCAckAWDQRvKobcerYspmx6FJBGOkogk9FlnOcY5sqanqSuaBlZKclC0laLT/ZkgBXaCVSY5Ngxp/jV0vWFvNiZypzhPsJDyRsK5OggIfQ+rNIlnCMJI+tdrSIG7leAhGeCKJxpXU3QEU/BuSj1dXhY4p6Td93hO0pWE8YjFfEzbtlStYZm1JGFPGnl01jIKPWIt87KYSm7LZA+uHUivtaqGdBRRVRnzvZj9aULVQTxJmdKjdEqnwbMN1/af4GydYUxBRUxVrbHGkISKxdgxCeTEXyH4NOMRzDXcMVA3NWVjCZ0hCiOqqsTzfHzfw6LRrmc+TSnqjqLu2JQ9xlO4JhOcIV+qzJtWhGlrBObDjyfEqkYlE/qupWw7mrpmWVqUaxmnLZN0xNjXjJKI549PcabHCxNGsUdVl4ShBD6UkwhXvYa965KH1dQVeedobx8yn83xfR/fAlFEt244LDtu53CalaQxBH6EH9YkPYyTkLprcD1gxSQOR+AK0Y6CGELP4FtQ4QjXlihnWdWKqqoYj8eve8/tNKMHUN/3hLEk9UWpRJ/OG/c52+O0lo6z4wnjUIoc1w0cnW7Ytpaq3JBXrXQqbRrK2rAuLXmRgxJzqhtwkqwS/07RS97Ici0dVeu6pqs2oDSV6el6UNawrQwGR+ArpoE4hOcpLMYh1yaiUXiplAkcjCXS5SnRZmYz6WRSWth0HZiWp6+lzFOJ6jHkKk2TCOV5GGcxXoKHqIfbAXLD5fdwYcpCIDH0UMG/2BvQGbUmTUNuHEw5mMWAprY+bZXjvIiqNTjXEUUhBg9rRLOseiXNH2vB5i5LwTSqKungWlYNPZq2qYkCj+koQiMpEFHgYZqGjpCmrig7qY2bJArnPHrt4SnHOBHf2Wwq+T8O0fQ6KxE71feEkU+oNattzllp0XSksaRZWB3Sdj2jNOHKNGKUxuynivFkKoBspaAxNMAa8cfMUvCdwXiikayzkq7vSJOIvXHMOAFPaZTtwIvomoo48ohDT5AoMRg88o1ocqsK7q4lc34WSf1cGI65fbdiW5fQ18zGEaMEiqJhs5UD1WugbQ1hnBJpIw0BFBwvN2R5wWkpmpePRO6OkSxv20CUTphME2IanJ9QtS0j3ZAkyaX2204YPYDSNJX+9GMxb0wvE7bZwDqvqJoOpxWqryhbR+8UroU4VITGoIIxSlnSwLCYjJjP59JIMUwZhdFL3U/tUAjqIXCmcSwCb2yl5uswr2jKDNOIaVd3HVVVstpYznJDVtVsckNnZAMHobQd0jUEE9lk5wD4+3Og4l5nEA2EYzxl2J9JV9p5CGE6wVMWL4gIfZ9JYPADgT45ugNHg4P8IBEY28VcBF3bCpBa3ws8ShJoispS1D3W9BjlURUbbDAmUh3704SDvX32xwGjJCIMPJI4IgmcdEbxJOxe9BI9SkZSPrM3Ckl9zckKbp7kFHnGnZOS99/JOV6vMM5iu4beaeqqZpNXNJ1lNk5QXU/bK9almMJNBv5UtBffFw1PdxCEPlnZCnSwFnQAz4tBaSZJwDzRGDzRbpqeqhVzsyoLVhvZyB5i0s4QaNvFRJGkE7A9fddg0YzimIPFlCcXKZ6fUDU1RWM5WZ5xlhv6tqdqWppWANKUs4wXAqg/YPdhOhGgEg2s8ANYLTtWlaGoWvTwTM5K8SeGEVilWJ2dUHaKpgJa8MME7XrKUpJmCyPwxBox//cXMEs86qoGL6IuNmwbxyavLm2q7YTRfUgphbNG4F0Rn0ivJNt43YPyHCEdbQNV57DO4ruWMILjzGE80K7mbL0l73zKriN0NTr2yLenVF0rmMwDZEXbSx7KyJdq91UtGkCqxHGuvFBgLyrBBlLO0veCX4PyCSLwtQMsxgjEajQWUywcCkzrWtITzloxD3sH4zSlqwuWlaVqoewde4sJti2puh5lGqxTbGvLh1885Lkj6fsFUuR5t4K1EXRIxXBSn8lpWrfQWU2Rr9iWDUVj6Oocz/MJaXF+AkrjTEve+6zXa3qjyIuSTSHwJhgxC5sK/BRRBxRs2471tmZdw9l6yTqrWG2lfs0aGV8UR0S+Ig41WdFQ9Rbb1aTjEZMkIPAk1YEEys1Q15fLYdM72JQ9ZQ1Y8LTHZKzo+5qiajjLGvKypusNWVFRtNDVBduy5WxTsHcgLWp8LZntFZKTpf0QnAhm58Vo14NtWBcdq7KnbSpQ4keL04Q41KShxukY00tO2NV5SqQE3fFkKPtRVuZlEmsOFlPmI1jMfNLQJwh8qVeLpJatr6Qur9wWrGvFcy9k3B7yuJJAYZ3Di+BgDmE7YKXLNFE0cPd0w3HhON2sMU72Ruv8SwPy74TRA6jrOu6cwK0cjgqpFL8yh/0E9sdjrArwA0sah3RdQ5guSHzxdYR+QNc6xvMDEreh7RxOh9jakHcelXG4Zug8oaVLqUL2WhAParQVU0eyvzWeEs1J2x6HIqslQ/lgGrEXam4eweFpzyqXqE04pPN3ThZrOJIuFIsFzH3Ym0PTdURRxHwU8syVgFk6wrQdy8zwgRdXFFVJHPqkAfha0Q3pAO88kN5Zh4iD9uRs6DempedWHEljAZyh7ByajlBbtqWhdo44CvEwWGsJ45Qy31L1Ps405IWAOxUbWHZyH9+XaGA80gRKcmWCUCJDo0DTtD3HWwl1jyKftu3xlaW1Gt8XqWabkrxXkjrRtDI3SqJnVsFtBlymXtpHtRVSra8cs1FKXzu2VSs+maJkW3YEdIwnUyJq4jhFu57F/hWCDvYWgvgwRUpCxiH4bgCw8mNUX1N3lqOso8hXbDZb8hKcdSg/Ig09JmlEMtljHBrmizm+rXHBSPC2I3giEY2l66UwN/UVeSt5X2EUE3ni+1yeYyBt4bSDo1NwoUdTZMwXUKxl8XkYil7RFXDzCF4oxJ8Ggg6glDQ3jS2MAo8gnTFLQqbjdJjn1087YfQAko6yw2FsRaXHQjoJKIuSTdPRtS19U+LHKSE1aaIIPdgbxywWe6hqRR8ecLbJyKoK7cEs0Ty1mDCfywOuMoGt6BHNaLMGG0uw42QLy1oqy68fLJjGol5rpZhPJVfIqYCPHFqeXcPhqZyAY1+c3dpJaP94A3ePpGW2zQR+dXsKnfM4Pl2CEuyjtjM0BPSdmHe91VR1hQoS5pOIWSTdRY9PYYtssgSIJ0NFuJKWP9bIpj49W7MsEPAtNLNJwkEaEQUerdRaMAkdi9mEaerRNxVGBSQePPmkOJOvxJKtbkNwyrI/9xnFWur1QvDiBYHqyHLIe9jkPXeWjm1RCvJCV1P3HnXfEfoar6vw0wW6lWhmb+BwKDhvGcD+QykL8SykoxF1WdAAq7xmvVkT+pq260D7dFVGoxLqtieMYqa6ZN3Db63ELCqQuSpaOM1bqqbBdy2j0URysDyFpz1aBAIkDRU4iybEWIdtMlrrcXx6xnHW01Sl1CB6Yn4HSEHu7buCwrDdrqTSvsope59ss2LTwOZMgjBdJrWLrjZ4cUyxFv/hnRVsK8Nm3RFE4v/rkHVZISkovoI8z+kDqLqGyNUQz4i0IQguh7e4i6Y9gJqmoTvHivHE7MCHzVlHeJCi+pJtadmULWCxQcwLhwJUHvgZ1lXM9/eJbMWVWUqAY+V1tM5HNw23T8WkuXIVqmO5Z17LxvY28LZnJAW/cQrn3JByL74a31QChRrDOstIU5gewtM3ACt5RXklmdbL1VCzikSi1j0Ut6RM4eBmxeydU5pmhcVyZTGirgvip+ZsszXzNMB4I1ZnJxSdlmLOrbTztpkAWxWIg7lsZAG3jZiTR6dQTGSRRcowm05YbjJ6qzjJOrK8xFcWg0eWlyxPj7m5bUhoCAIZd6WkAcDeHOYB7E8mbMqa06Uk73gKmnqL8iPCsGKzhHw8ONk3a+JkjNIhY39L7c1oyjXpdB9XS9a5QbSheHjmb1/AJIJ2KgpMnMB2uSKc7DHpl5gOCufTNyV1WbDeeoync2ZRiQ1COqvYVIaTjWzgCbKZewTXqOkhyzb4eiEQvmmCA9I4Ia8ajHH0hJjWsFouCTzFpiyI/JowjDB9RxKHdGfSNiqr5DusnGilTWmY74/o7hbYhUfbNmyzjsNDGD0tbbYB1i18yg1IaFgswHtR1nZTZURjOFASqdPHEjmdMHQF7mB0MCU6OUNHe6SJz3qVYdUBxphLaUc7zegBpLWmr2WS8laq98uNVI7nZSkdUa2mbDpiTzNOfOnmuREgKqstpspoe0XdGjGJfIUzHcpP8H1xVJdL6GJB7At9qcM6baUTbeAF5GvHB25v+MhZhXPQFRXHmeE4g3UGdd1xfALhTHxIdS8QqabkpXya0onpYVtJ8e+QBdn5ELqCaSpHoXYdYbqHbQryVmBwTVdS2hDPNoQRXLsCqpIT+Rz2M0JyWPYSGI990pGE4RephKBrFZOtz6h6RdO1xLrH97S0RXaGru8lOlVKtnhRSz7U+ws46WC7kohRWRds8w4zlHD0TkDtnOnJWinpuLOUFkdNb+m7lqqq8aMRoZKgQlVlBIGPjkUIrZAM6Sly6IQjjefDwWSE7cAfzejKNZscDjewXW+5c7LmuGqouxbPNlSdo2gs+XZNVvYESCfRHhF2HXD9urRX6vFZFzn2vJ+58jB9S2UcKtSYNme7XtKEEX2zYZwkXN+fszeO2Z+NaOuSqhMM9asTAct/IoCrIzmENlnB1sK2Nphqw7KWNeA3Atc7CmRcdQNVJUGR+UQSemfTKaYeECSUAOQZ5Fk3Q0HxZnNGtIiJXc4kjeiN3SU9vtHUti29Jyf/c7fh1lKSEhMPQl8ThCn745DQA4KIbVZQW9mUIx9G8Zi2h7pXHC8bGjTKOeIk4erEY6wHONteEh99xLS6sjdEdoC87DisIFUdB7EsPD/y6Rsx3UJPSjE2jeAYNUacsKaHYCRjmQZwY09q7J56QsL65xrB4RlsWssyq8mLmqzq2KyOOM06bp1Cma2Ioghfw2QUEziJ3EQjMT3OkBYynZIkOQtozxc0Qg/G44RIA7am6hVtI7lRXdfRdIayLAGYJj7X9sZMEhGksRatp0A2RJhIpw1UQNtK0fKNJybMRh6+smyLjhoxs+pO0CDB0TU11jmc0oySkCSA3lhaI079rpd5ENe/mD6+tfgeVFVFbsA0W/LK8r7n4LkTcXB3Fkb0zJOQ0NestxXrrKDtYbMtX2p13CPfIQJcCXuLMX1T45yi7lrKqma53WAdxGFAk1vy1iNMU2auYTrdZ5LEBL5H2Wlu3T3hzrqkHOr0gkAaNwSezIlRkMQBT45hPooIRzPMUKR7kgsawbqTKF89+CW7Xvx7fgi37qw4yWG5lee3Rg6cCsnH2vagPB+/r8lbx83jLWfbiiwvMcZcar/tzLT7kHOOIBSg9fMT2LXQJzCK5TRu244Aj+lkjuty/DBGmZysFoiRUQAqGeF1OdNZRGAFSGxbbrnlwa1SVG2LhMp9pA/V3SO4CdxoxGm+3IK5JmaQVWD6Hqek2LFpYHxNczC36F42E0ryipSVJn7JAqqV9LtaFRLW7RrZKNf2JDRP7FNWHWdFQVUZTs8kW3hT9/S6IPYVq7ylsPDiqZSATJBIyxhJskwCMEpx57DmtIHxIYz8ii5U9OsS0zvKsqOqOpR1nC4z6v0pCg8/DIhoOV7BYQbvOBB/l0ZeppVM7LOzhlUrmOOB72GMweIz1AhjkMJRq+Dw1NCrjHkskqwNZ+R5xklhSPc8xh7cVeL3ahGhsS6lC8xRBlPfCmCaUswmETf2a2YRXFkImmZWwbN3VzyxrwiGgmDbt+zNY94+q/nQRuYGJE9nZeGFw5zZ3MO2Fb32oS853sCVcYNnOlwAPjVVqWksrMuSSRyjdIxHi+d5RMpRruHIg9+69VKAkafd0Do7toJtpBRN2zOZg7stsDFniNmlkMOjGSKsppOD7G4E6zXoqUxKydAUAnh6ATcSeOpgwe+8eELRGkZBTVdLIOaySI87YXQfOg/tN8MiHwfimG0tQzSmYZVB8swIV2zw0wOK7QkGMZ2OT2qMNTS0zOOIrt5QKXFojkNRe/dDcHP40FoedoYkGwYx2EI6Y+wfjFDPFgTawzpDqmEc+ay9njuHcPUZyHKL7eWUdFZMlE0kmb+jCMxGImlWwSwRIbOvJNr2zAJcMObs7Fj8GmtDrWThNjW0dYNTPmo0IQ59DnzxU6yRKFqJLOwulBDv1VShe8cxMB1KFdLWYX0Ig47TTOa37TOyFsZVwWI6pjUNxvPxlITytR6aISAb+aoGWkjnwFq0v7NwQ9GAxjCOZUwBIlSCVk5+1xlKKiqjGLVLitqwzWETltzdSP5SypDwiDTK9Dzxj8RpQHOzY5nAXuqYjgRnel2JP2VTwdNPSDSzajqsgztr0XamoTRBXHYynhj5PlyBNjf0GrxE4XUtyw1s9mqOB/M+3HP4oaWtJUEyCGPKqsFaw7YsWG9g62C8EitvYyX03hox0Zdr6TZ7fc+wSEPYi7iaNvgWnvakcPdgJM0IkkhxcuqkOacFemmGYJ3MQ4yYsAB31vJF9LMnbHrwup6J56iAui4vved2ZtoDqCxLyZsBVCitnzFQ5nB7Cbe3UJ6tCSf7mHrJfL5PaGHpZIF0zjDVNXuTiNaK38a3Ioy8RE6CrIFEyYnlIS2FTTcUJ3pw93aBN4OmMNw+hd++DS+se+7cla4NxR0IIo/DJdxdioNy08Bzt+CDN+FoC6tGnMr+kCRXIGPZIlCubVMyTmMiBeHMJ1TSqaMzosKP05hJKAmQXiTO6g2yeQGuATaXmrpVp1AKrgBXA/FRGCvdSkN65mMJdz+5F0o2sh/S2QDjfJzpSGN4+opkpveJBA8CpMZORZIrtS7g2WO4eew4PoWmbcgL0fRiZO4ODaQTuL43YTGbMUljxmmK52uiIbMYJ878BDGpAsRUKRrp3Ju4jtEM4sBiW/GXdU4AzX7PEwlvuwZP781R2uNoXUm2fJ1T9ZKCEXaidfUD77dfk2fcODitoCtajCf+qVQrMfHWcJxBnjuqDtG2bUvdOfKi4uaJAPJtV3D1uiRTzhANLFXyvWojmeurdUfdObKiwSBNCILBJHNWTPy2d2S9pDcoK8LM03Kg3jkWq2CGaF++E0iUOAS/h8kClNaoEmbj2aUr93fC6AE0Go2oEQ3grIBlKdGu3knhrHMCvXp8ckrhfNoqwwthH3jXNUi0ZtnHmL4j8kRz8LXkx2yW0Aei3mYD7KlBfD1GD47PNYz2E6YIZKlGnIqjoe7swwbsHuRrQ9HCKpfP+QAdHBzcW0h5JdncQSDCqkD8AJs14MVME4+r+xNihFfZiy/IKGiaFqMCXC8Abc0w3jmwx6D2BzImzxr2xx4WSKawGHtS6X0I8WjGNPaYzUMW8z2e3N/n6t6CJ69MSXTPOm+4uZHwNMD1RPqod0hr61l83oVFNkWgJLBwmpXkpZiMC0TLVEhV+2Q6I0kSZpFiNpsxTVMJa2sxuwvumS4x8hBCT/JxNr2YbE0OdTDG1vD01ZDpKEJ5PmWn2BQdJ8sNqyyjN4a92QTXwItrmb8XkVysDAlsRKk0hAwQRIK2s9L4MQwIfakljCMReEkIo9AH5RFoI33PIkHYxErJkJeIIAU5ALf5sDat4EsV+Vpy14wEE564Kt9zOhOTvu0g24qgx0krKt2Lf+i4kgOrGuYzCGFvLMiS84ViHnlsso4NUJTbS++3nZn2AHLOoRAtIEQ6MoCcjucdYyNfkSYhrTV4fsjxupVNXkI8SuiqDGsjrCd1VYc1bG9JvkeYyyl/c7jHJyF+oNP1IFQSGOmavdkA4m6l+LJu4WYpp+zcwI0bYw4Oc7JSFrB1MJ0MCYB7kB6JaakYUA0Rf49D/Ehts8b3UrK6ZhbHBEEFg3aWaIiCmJOltD7SESxCiabdQQRdCJQr2dBtC4VS1EhULFLw7C2pKm+aDfPZAmPhxvUrRMstSTqi2K5o1YhR1DP1G6o1lIFkCt9lMNU2khE8GktE8OlrYoJGHgNciKMFJgF86pNw6wje9clTosDjzvEZtbWMm1PKIufZ23AygVvbweHN4JcCPlLDOBPUzXIjmlicQLvO8abgmRY/uYIXODyX4fsefhAwijwcHk1bk4wUZeXYIHNyLuj6EE6O4emnfcZtz8HegqbYEoaGqm7prWCtP7EXMUkTmnUBzrDMHc62eFpjG9HIT4EPvgC3kOc0Ap67KzjWVStCbx7AeDzhxeMlpQE8OFuKlu96ya9KY0CJW2B6A/ZTyRe724kAXQ/j9wGvF1Ow7CQRdBTHWGfpX6yYjmY7pMc3ktq25c7w+03kwbSINnG0ldKQrHP0fU/kRyymI97+xGAqpCHT2DGOQrwgoshhNFYkvWQoYyVFYM09m7xBTuJbiDZQZNAYRd6IxjSeyKm3v6fY80TrmUwErB8nUKmhN2ysSrS233kBftnBh5HSjeMtfAQ4Gb7L2SFYF1JXW8LQI4oEcdAPRcO4fjBhMY0ZpSkRneAJpTLeczPtReBXB55FBycnPUtEg6o7w2QGMwXXD67SdZYgDDBdg47G9HVOq1PGkWE6CqnboYPGSkpKEuTFMN7lUnKPwuFepysENdKJVjSaSvj8975DHM+e5xFFIXQ1m6Lh7plktJenIkxvcc/kLBFtZp3B83fhhTN4dgXP3RENpNxANJpxdRFzfX+CH2pCXzFOQtIooa4KirYnLxwjXw4UDzlkAmC7FOF/dtzjooiyKmidT7GFOIrIK0m3KLoWax2hhtl8wSJV7I0C4jBiNtHS9AERos8Nr9PztVlKhLYuxLfVtJ2UimgZf9aIRhiFoh16Thz+txHn/d7YZ7uSw6pDhJCPfJfVULC8nyg8pQSd0lYsrkLku0snPe6E0X3IDWn7s+HvFtnQGQIqtlkNUYxG/DBZXpBXLZsCCKEqW/KqYjKdY9qKrIG2clx7QgpItRXUxYulhSvg+U40gTEinG4fWk7PYH8ecnUqGpWnHKOxLJazEk6ON6wbuJtLw73f3MKLS0k6/MVKTJHbwAcRJ6qPXDsCSg/uHpec5GDbljQOBVRey4bXCvKq4/jkjF+/CR8+gzt3RTh3L5uzDyIn/9FS5qbPwQ9TtIH5DKIwYNt01E3Fuuxpyy0qSNC2RSvNyaqQiNkhlErMmzvcm6N+KJlxRhzI6w1kBqptz7UnfJ5EhHCGNDc4zgvKusXXllEcglI4JAIZDrV054GDo+EezfBM40Aeuhru39eibXa9IQxDAu24c2ppOktWVGRlzbJsMX1NZ+C4FwERD3MNUttYrUEn0OUN1mlOTxvyHpRtiCIxQ03nKOqOtu3o6oLjTUXeKXxlmI8jZqkI3hmiERlEe9ky+KQqKS4+KqCqM3w94DUpOOvFtC0K0bbjyKdtRCDnGWy2PdVwEMXc88Odr5cXz2CVO+rOsVwvqZ1mfQJBlFwakH9npj2AyrLkbPj9cPj5W8Cqhyd7WDjxrZwcG6wG121onZQQmAba2ZSFrlDK4+4pXE2hq2DdSGLeqZGFpJCTuQJ+B1lQTyCO32dvwVEvfpvI11TOSnFtJ4vj+in4N+D2UL5RNRJ90sC+FW3lnDrgeWSBnQ7XVA5qLMBc1xaasqo5LQRcrAPuHGfYqCcKRYDmQ63SRSF6kV48lo6wZ4jmUm5LqlZyXOhrpqMRdXZGXu+hHOAsdVlwmhWsi5Z8JfV2xxvRuBpEA1gBB41kY5tWYDNsB78J/KEeVNFzDPglJKsBqK7s8TCsi5627+jbVgDyESft2YVxnwvWGmgHQXTlOtx+UUw/IkW9kbyldVaxbDJON2CbDKKrOFOShiGu7Tg6E+2zBV4ADob5LjqYzqHOYHoFTtc1dTNgYyMm58iHMArIipLTApbbkqJusHVGN5pS1h1lK88+0ILs0CJaXYNs6L2F1O4tPBE6HzkeBJYvDukcuKalxhClSSNJCciGCGS+kYPoiAFQbVif5yZ53Um0NdRwdmqpHOTZ5tJm2k4Y3YeccyxXa5av8L9zX8kVRCi0tTiIP/maZupbumRwuqoGP15w9+iUvJToxMlWEsc+hGyKNffMnXMywz3mQGTlxLt5CPtzS5XDdiwa0QrB+lmdyHtOkBNzM/B47gLPPcQRfziM/SVSQ+6SgbLsuD6fEBiY74M9kyr8Kq+4sefRVoaMe4WTr0QfBK4PN3i2gXfUcHIKegzbskP3FhuP8E1BPJ7T1QVnhaMxPU0mlfrLjczLxZzeY8Bt4aqSotmihrARDbLcSLrBR4bvbZciVJpWtDHPtXRlM5iQg3BbfjT/8znZQ7LfAT7womgEvoL1iRPf1brH6VMwTrqsVDWqOea0stRZDYhf5lxYj5EDwAzP5eRwwLHqhppDRJBsK4lGMgG97UijAU9ISRb53Qom/ZbUV4x8OWxuW3mmFaLdbYDPGGobMyeQIX44rDkEUK8Znp9bwY1rEAUG+nsH1HPH8t41IhxKRPtaIuZyhLR5PyoGH6SFegNOB5cuB9kJo/uQc44sL+77/1PgbgPBMRzmUsZxcmopW3guA/8EblzpcHi4rpHFsxSH7DHywOEeONnH3B9ZwBNfTqxKielR1xLRO8/quA3cLe5pQOeCIn8Zv/P3r192/Xgj2EdFCb/6YdhmSyojgPTXEJC2uoeTU8MHM9FEHkR3hxeIP+b0phSeagN4Ab2pKfKcMolZn5wxHo3xzIbQWG6dwPukYP8lze2cXnI0a7jZibC/gvwMA8iHDxQM+VqIKbdcb7mzKjldwvvvyLw/C3wyHy2UPWSzlcP4awR8vgCOziSvx9YQ3QB/0zIJYG3hQ7csT1+tKE7h/bdk3M9e4H37wj2OhgFWSHpIMpbo134kvrCjlSS8vu0GvOOqgNe1VnP3EA5XUryrlONDWxH6F+n8+X+4l7B7gbSjipH7HSEtigZEFFYInHKoDJ2T9eIQxMgamafzNbPko9fp8Qpub6TwtmrlvXfv3EK9+1O5DL0lhJFSag/4fuCLkfXwrc65H7wMT9GM2ge+518At3NZyO8YcjVeXIk/JT6FddFRVC9SdPLwbyMb5aPu8wD+H0AE0RY4fB5qDccWrmb3tJ4V8MGz+7J4ier7XP9p4D0vCOxJreCFO/BCKQ7XY+BTzuDmWjS1VxNEr3TPn64Fu/rdwK/89pm0BlJQTQtOtyV3b6+4m0tO1D9/AK81IpyfH0xbuDcHv/PCvd83iJCKgF/7EAT6lMMj+I3Tjx7/h17G//zYqbgnsM8F+/VMNvM14EMfgaduwDOJPLvnb0HdOH7m8KMFzyvRGfdMw48ASS6CYdyAuQW/3Yvw0DcFUeFmBS/e2fCBTgTcR6ly96GLQup5xBE9QTbF+4bvOUKe7weP4PYR/H8MtYrAj91nQZ67EX4D+MiRCC/NYLYBT/82fP7nnvLkk0+++iDvQ+qyKdxvBlJKvReZm68FPhP4ceDznHO/9Urv/5zP+Rz3vve974E8jTH8wP/6k3zHy1fta6R95PQ9h4948fWxeUXSyCJ+mOQPfF9J/J6XWTwsioAbiGmQ87Fa0ONAMfcX8J+o9ONf/XY+7dM+7VXfp5T6Fefc57z8+mMfTVNKjYA/CfxF51zunPt54P8AvvoyfPu+5+g1aBz3ozPgl5DT+GEKInj4ggiG6v77/O9hCiKQA/5Z5OR+HAUR7ATRK9FP/dTzl/r8Y68ZKaU+C/gF51x64dq3AF/gnPuyC9e+Hvj64c938rFm9yty92dXn3HWdGjPN13ve56qALDWiCGttHPGKLRCodCer7wgcqZvlVLaOWsEH885rOnP+Z4PSqqL5CEY42LPUzXO9soLYmf6FjWgnp3zQCmctWjtKaU9eY/2UBLLcPJAHc4YlOehUEppr2877flep5TWzvYt1vSSoARo7Sulz8eqlecHznSN0n6Is8ZZ0ys/jF1XFyilcYN1qbUnuLHWGONiz9diSDiZIJyzKO3hnBWcj5eehUJ7vvAe3oezOOdw1r4UllFKO2t7pb1A5oYK5fkopTBdI2M5v4c1aD9AobDOKs8LnHMWZy3OmY/mPcyl0lppP3S2716ae5TCmf7e93QWpQTjUMbp0F6gtOc70zecu1Os6dz5d3vpmSql/DB2pmuFv25ecr5Y07+0DnBO+WHiurZEa195fohzztm+PV9L4NxL865Qw23V8HFrLKmsHWfR2pP1OcyPPF9Pni9OKe070zfK8yOU1s6ZHtM3A8KeRmn90lxZa9DaM72NZO0rjVYaK7wkB8Y55YVxvzl84dX3FABvc85defnFt4LPaMw9f/A5bRBT+SVyzn0f8H2XuZFS6n39K6iXD4veSP6P89h3/N/6/OEtYKbBS9AxF2nKx/qKd7SjHb2J6a0gjD4E+EqpT7lw7d1IfuKOdrSjx4Qee2HknCuAfwj8ZaXUSCn1+cAfB/63N+B2lzLzHjH/x3nsO/5vff6PvwMbXsoz+gHgPUgg6y9cNs9oRzva0e8uvSWE0Y52tKPHnx57M21HO9rRW4N2wmhHO9rRm4J2wmhHO9rRm4J2wmggpZR34ffLAbO8Mv/kwu8Pfd7Px/wGjT288PsbMfbxhd/fCP7vUEpNh9/fiPn5XKXUOx823wv8v1Ap9UVvIP8vUEp92/kcPSr6hBdGSqlnlFI/BHyPUuob4aWSiofF/2ml1I8B71VKfZdSKnHOPbTyMqXUU0qp7wA+Dx762J9RSv0g8H1KqW8f+D/MsT+jlPoR4G8rpX5AKeU/TP7DPf5DpETwi+Ghz88NpdQ/Bn4IgZ96qKSUOlBK/V/APwA+XSl1OVzXj+V/Qyn1E8A/Af5bHnGi8Ce0MBrq2v4pAmHzfuAblVLvVUqlD/zga+e/D/wYgiry3cDnAz+olHr3Q+L/p5GF9K3AlyilDobrlz79lVJ/DkGduAv8DPCVSqkfGP536XWjlPo2BDr7JvCXkbSMvzH872FqL+9G0ED+wMsSY18XXdBA/wqSWPt+59w7nHO/dPH/D4m+BThzzu07577LOfdypN/XTUqp70XG/yHg7cg++JKHxf/10FuhNu0y9B7g55xz3wSglPpRBPn1l5RS3+ucqy7J/7OAwjn3DQP/fw78PeCrlFJHzrnDB3761eka8D8iJTF/DoEE+vHLnv5KqTnwKcCfd879veHarwP/VCn1Tc65S/WlGTasBb7EOfe+4drPA1OllHoY2otSynPOGeR5/hDwrwDvV0q96Jx7DchAr0wXxvZvAj/rnPvG4X5/ANnYGZcEOhjmZwR8BvA/DNf+1PDv9znnnr8k/3cgIA3vds59RCl1DUG9een+D1ODfK30CaUZKaWefJldrIFUKRUMC+AOgrv/7yKQOx8v/2j4ea5OZ8Cnnl8fNvH3A78P+IJL8D/34Xw/8MPOufciwIp/TCn19o+X78t4KwTl473ATw7XNGKGvJ/7g1O+Vv7+sND/mnPufUqpz1ZKfRD4Y8jcf/lFH9Xr4O8BDIII4F8D/jaiof5xpFnHZcYfD5e+GvgipdQ3DIfM3wR+Avg7F/2Pr2f8w/yMgHcBWyV4Xd8O/BngHyqlPm54nIvP1zn3YefcNw6CKHDOHSHF5f/6+ds/Xv4Pgz4hhJFSaqaU+nHg/wF+Uin1VcPDeQ45of+dYQE8g5g9b2fwwbwWtVsptRhMmO8BuKBOHwG/DHzDhbf/A0ST+ezXuulegX87LKrMOXcOSPjXEZPkD308voVX4O2cc5Vz7n3Oue1wH4tgomV8LKLtx8u/H36eaydPAv+zc24E/DXgvwK+TSk1eSV+r4G/Ga6fr+2byMHy/Qgm2p9WSn27UuozXif/ehCov4VoXH8D+FvAHwT+E+CLgP9o+OzrWTtmEEhHwL9EyjBuO+d+n3Pu3wZ+GPijlxi/u/C/8+YnIHvjbUqp6GH77V4rfUIII+C/Q1AzPxM57b8S+K+dc38f+BXgrw6nz79AUCK/G/ij8OoOT6XUpwM/Anwu8HuVUl9x4d/HwC8Af1gp9UkDPwv8KPAnnXMPxrV9MH914T1qMHf+X+BPAL//1fg+iPfFk/3C9/9y4AMXNI6Hxf//dM79T8N3OEM0gK/hNWDIPYC/vrChPgv4oHNuiaCrfhvw6YgW9rr4c2/ffB3wbzjn/haQO+d+Efgvgf9g+G6XWTsAfwfRjpIL134c+D0I4uvrGv+5oB4OnvMxGmDsnGvUGxDRfC30lhZGSimtxBn9NuAnhtP4O5CT7CuUUu9xzv0V4EsRdMjPcs79I+Aq4lx9Lc7aECnK/RrkdPm6c43HOVcO12rgP7/wmReBF5VSM16dXpG/c85eOHnPf34nAp/yeUqp/1Qp9R3qwc74+/E257yHOfSAz0Y0AZRSf1Yp9Q334flx8b9A5/7L8wYkryXM/KC5Od+svwT8N0qp3xh4/jwCMjm6BP920F56xPF7cfwWeF5dSFd4HfzPBf4vAT8FfOH5B5xz/xJBAn7Vg+wB/O3F5zu89yeQQ/Pao9KMBADvLfTinj/myvD3BPg14E9deM8Y0ZZ+7hU+/xlIFOnfehX+V4e/Q2A2/P75yEP95gvvV0iU4gXgexHN5dcRn8ml+AP6FT7/XciGOAW+/LK8h/EvEJ/LVyKRtSPgSx/W2AFv+PmpiFn73z+kudfA/z48/68drv0RZINee4jjP6/xfCciQL75YYx/uP5JyOH1E4j594sISsXkYa4dBLL954H3PLK9+6hu/NC/iJwWfxNxxP0M4mz9E8P//irwqy97/7+K+Ie+ZPj7GvCPhs//hdfI/8te9p7xsGB+FoHWvPi/z0c0l3+G4HU/FP6IsNBIw4e/jpgiL1/Qr5f3uUB6D/cE3F96yGOfIDlAP4poRP/Fw5x7ZDOnr2PtvNbxJ0ik7nztfOtD5H8upH8/8B8P93iY/BX3BOlVxE3xrke2hx/VjR/6FxGN5p8gDTx9xCx6AYmmXEGgab/ywvtvAD8HfPGFa18FTD8O/h8G/vDL3vcu4O8C33nhWnDhd/8N4O8PP7/ilcZ/Sd4e4nP4S4hP4WGPXSEC4+t5hdP+Ic7NS5reGzD+dwDf+AaN/+La+RhN+GHNz8vv9Uj28KO8+aUHL+3GzxfZ1wMfftnC+7tIWPcK8OcRh/InX/j8LwNfeAn+70WiNO+48JkQCSH/Y8QU/AXub/I9LP5/5A3i/YvAF72BY/9F7mMWPCZz/7iP/778H8l+ftQDeF2DloS8n0L8GD+COKj/IOJM/MwL7zv3/3z58PePIGbSdyLq6j9jsK8fBv8L178UCYHfBr7md5P/4zz2Hf9Hz/9Rvh67aJpS6msRu/jXgP8MaY/+FxH19IihBgnAOffrSBPMf3+49PVIHgvATzvnPs85d/wQ+H/18FlPKfUeJBfku51zTznn/pffLf6P89h3/B89/0dOj1oafrwvJA/l6y78/TQi6Z9EbOUf4oJpAXwZUoOTXrj2MX6Dh8UfeAqYPwr+j/PYd/wfPf9H/Xoca9O+h6HruJIs6hLJpE6Av48khH2TUuo559wLiPP1/3aS8wO8ajLapfg7516t5fobyf9xHvuO/6Pn/2jpUUvD1/viXkjysxB1NBz+fhcSAv1NJG/ihAsRs08E/o/z2Hf8Hz3/R/V65AO49BeQ/Isfftk1D/gc4N/7ROb/OI99x//R8//dfj3yAVziQZwnhL0X+LPD79+ARMqufCLzf5zHvuP/6Pk/qtfj6DMCXqpu9pGIwlWl1M8i1fZ/xjl38onM/3Ee+47/o+f/yOhRS8NLnhCfjpQp3AW+Zcf/rTH2Hf9Hz/9RvB75AC75QELgm4F4x/+tM/Yd/0fP/1G8dh1ld7SjHb0p6LHLwN7Rjnb01qSdMNrRjnb0pqCdMNrRjnb0pqCdMNrRjnb0pqCdMNrRjnb0pqCdMNrRjnb0pqCdMNrRjnb0pqCdMNrRjnb0pqD/H/qCjps0cAKcAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -191,7 +191,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -242,7 +242,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -287,7 +287,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAATQAAADHCAYAAACX8K+cAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO29d5QkWXWg/92IzEifWb66u9qPN9Az0MAikJAGAZIwQoI9rIRYsUKMBAu7wGq1WAkQrBZ+WoR2xQpmNQPIgABhZDBygPAsA9LM0GN6etq78lXpI8Pc3x+RWZ1dXdWdVZVZ3VX9vnPyZOaLF3HvC3Pffe6GqCoGg8GwGbAutwIGg8HQLYxBMxgMmwZj0AwGw6bBGDSDwbBpMAbNYDBsGoxBMxgMmwZj0AwGw6ZhXQyaiCRE5G4ROSYiJRH5VxH56Yvkf72InBWRoojcIyKJ9dDTYDBsbNbLQ4sBJ4BnAAXgrcAnRWT34owi8hzgjcAzgV3AXuAd66SnwWDYwMjlWikgIvcD71DVTy9K/xhwVFXf3Pz/TODPVXXLZVDTYDBsIGKXQ6iIjALXAweW2HwL8Fdt/+8DRkVkUFWnFx3nTuBOgEwm88Qbb7yxRxobDIYrhe9///tTqjq81LZ1N2giEgf+HPioqj68RJYsMN/2v/U7B5xn0FT1LuAugP379+u9997bfYUNBsMVhYgcW27buo5yiogF/CnQAF6zTLYykG/73/pd6qFqBoNhE7BuBk1EBLgbGAVepKreMlkPAPva/u8Dxhc3Nw0Gg2Ex6+mh/RFwE/B8Va1dJN+fAK8QkZtFpI9oRPQj66CfwWDY4KzXPLRdwK8BtwFnRaTc/LxURHY2f+8EUNUvAe8FvgIcB44Bv70eehoMho3NugwKqOoxQC6SJbso//uA9/VUKYPBsOkwS58MBsOmwRg0g8GwaTAGzWAwbBqMQTMYDJsGY9AMBsOmwRg0g8GwaTAGzWAwbBqMQTMYDJsGY9AMBsOmwRg0g8GwaTAGzWAwbBqMQTMYDJuGjgxa8y1Nr2uGzjYYDIYrkk49tHcCPwYcFpEvisgvikiyh3oZDAbDiunIoKnqZ1T154EdRC8weTVRXLN7ROSOXipoMBgMnbKiPjRVnQE+CnyQKPjii4C7ROSgiPxkD/QzGAyGjum0D01E5Dki8mfAGeClwP8AtqjqtcCbgD/rnZoGg8FwaTqNWHsGmCKK9/+bqnq6faOqflpElnuLk8FgMKwLnRq056nqRV96qao/0QV9DAaDYdV0atBmRGTvEukucEZVwy7qZDAYDKuiU4N2CNDmb2n7DRCKyF8Dr1bV8W4qZzAYDCuh01HOVwIfA64HksANRG9AfzXwOCLD+IFeKGgwGAyd0qmH9g7gWlWtN/8fEpFXAwdV9UMi8nLg0V4oaDAYDJ3SqYdmAbsXpe0E7ObvCuv0jk+DwWBYjk6N0PuBL4vIh4ETwHbgPzTTAX4G+Hb31TMYDIbO6cigqep7ReR+4N8CTyCal/YKVf1Sc/vngM/1TEuDwWDogEsaNBGxgXuAO1sGzGAwGK5ELtmHpqoB8GxgTXPNROQ1InKviLgi8pGL5Hu5iAQiUm77/PhaZBsMhquDTgcFfh94h4jE1yDrNPAuIm/vUnxbVbNtn6+uQa7BYLhK6HRQ4LXAFuANIjJJ28RaVd3ZyQFU9TMAIrKfaFDBYDAYukqnBu2XeqrFhdwuIlPADNEE3t9VVX9xJhG5E7gTYOfOjuyqwWDYxHQ6yvnPvVakja8BtwLHgFuATwA+8LtL6HUXcBfA/v37dfF2g8FwddFpPLSEiLxbRA6LyHwz7dm9CBmkqodV9Yiqhqr6AFH47xd3W47BYNh8rGRQ4FaiwI4tT+gA8KpeKLUIJVoQbzAYDBel0z60nyNay1kRkRBAVU+JyFingkQk1pRnA3bzJSv+4r4xEflp4AeqOi4iNwJvAz7VqRyDwXD10qmH1mCR8RORYWB6BbLeCtSANxINMtSAt4rIzuZcs1av/jOB+0WkAnwB+Azw31cgx2AwXKV06qF9CvioiLweQES2Eq3j/ItOBanq24G3L7M525bvN4Df6PS4BoPB0KJTD+3NwBHgAaCPKFTQaaIOe4PBYLgi6HTaRgN4PfD6ZlNzSlXNNAmDwXBF0XEMMxEpEEWqzTb/A6CqX+6JZgaDwbBCOjJozYi0HwDKQLVtkwJLvTzFYDAY1p1OPbR3Ay9W1S/2UhmDwWBYC50OCsSAv++lIgaDwbBWOjVo7yGaM9ZpfoPBYFh3Om1yvp4ofNBvish5k2k7DR9kMBgMveZKDR9kMBgMK+ZKDB9kMBgMq+KKCx9kMBgMq2UjhA8yGAyGjli38EEGg8HQa9YzfJDBYDD0lE4NWit80B5YCB/0h6wgfJDBYDD0mrWGD3pHj/QyGAyGFWPCBxkMhk1Dx+GDWqjqZC8UMRgMhrVi1mYaDIZNgzFoBoNh02AMmsFg2DQs24cmInd0cgATgttgMFwpXGxQ4O5F/8eIlj1NA4NEbzM/iQnBbTAYrhCWNWiquqf1W0TeTGTE3qaqVRFJE73CzqwUMFz1hKFS8wJScRvLksutzlXNSgI8blNVD6Bp1N5ENLn2d3ulnMGwEah5AWXXByCTWPFMKEMX6XRQoAI8eVHakzj/DVAbhjBUKq5PGOpF0wyGTkjFbbKJGKm4fblVuerptDp5G/AlEfkb4ASwA3ge8B97pVgvWapGNbWswbA0G6lJ3ZGHpqp/CjwFeAjIAw8D/6aZ3hEi8hoRuVdEXBH5yCXyvl5EzopIUUTuEZFEp3I6Yaka9WqqZY032l1alWHNCy63Kj1hI5WvY1dEVR8UkYeBUVU9swpZp4F3Ac8BUstlEpHnAG8E7mju81miRfBvXIXMJbEsucALWypto9FpTXq5vNGNVNOvhFYluFRl2Isyr/d5vFj5rjQ6DcHdJyIfA+rAoWbaC0TkXZ0KUtXPqOrnuPTI6C8Dd6vqAVWdBX4HeHmnci4nl9vz6bQmvVzeaMX1mSjWqTSN6WbBsoRU3KbmBRdc+257N2GoTJVdijVv3TymVmW/ESqhTgcFPgjMA7uIgj0CfBt4SQ90ugW4r+3/fcCoiAwuzigidzabsfdOTna+Zr5Xhudyueat8sRFECBhL31ZW/ngnGfWjfOwovN55T8Tq2K5a9/tyqPmBQSqiETnfSN2G/Sy4u+0vfFMmtM2REQhirohIiNd1wiyRMazRet3jkXenareBdwFsH///o7PTq+aXGtxzdfSjGiVR4hmPrtBSCx2oVFbXO6K6zNVdhnKJsil4ivWebnjLkerlt8ITZeVsty173ZXRuv4YahUvWBDdpX0ssujUw9tHhhqTxCRncBq+tIuRZlo4KFF63epWwJ61eRai2u+XA3fSW2Wituk4zaJmEU6bi9briXL3QWPqSV/scewWPf1bLpc6ry1tvt+uGpvoV1Gu2HpZbeDZQkJ26LS8Ena1rpVDt30qnrZ5dGpQftj4NMi8hOAJSJPBT5K1BTtNgeAfW3/9wHjqtq1VQm9erA6fYiW2r7cRW43dBfbv+YFVBvBwu+l8iwud8K2UFV8P1zTjWpZgmUJVS84zyCvVxN8qfOylOz2fBXXZ6JUZ7rirlrHVp9gqe4tHHc9yjxTbTBVbuAG4br1a3WzXL2s2Dr1994D1IAPAHHgHuBDwB90KkhEYk15NmCLSBLwVXVxD/GfAB8RkT8nGuV8K/CRTuV0gu+HTFVcUjGbXCq+ohN7saZhzQso1j1KdY+ME7vgonXqarf3daXiNjQNXev4FddnIO3gBiEJ22Km2sALQuLNvrNLyVh48Ooe02WPWiPEcew1uf+pNg+t5bGs1+jYUud1Kdnt+QBQSMZtLJHz9F6KZa+7QN0LoK1SuJiX3A0G0s553+vBRhnp7DQEtxIZr44N2BK8Ffjttv+/BLxDRO4BHgRuVtXjqvolEXkv8BWi6R2fXrTfmpmuuBycKDGQctgTy5JJxJa8YX0/ZKbaIBuzmai6bMunqPkBx6YrZBI2Y/k0M/UGojCYSUQ3tCoTJRdLhF2DmfP6ptpvinZ5AFNll6DNw5go16k3QnYOpBeOkYrblJoGMwhDql4AqjSCEA3h2uEcliXUvGDZgQE492DHbCEei26CuJz/IK+0T6/lpbUMRqtptBxhqJTqHnUvYDCTWLLPrxN8P6RU90jFzjciLS+gVTmk2oxM6/zHY8JEsUYyZtMIlYHQwQuUgbRzgT5LGc1WhZWwraaH7BMq5NsqycUDMd3wSmIxi4G0w0y1saSu3aZ1L7TKebF7Yqn7ZnFaL6eddGTQROQw8DFVfeui9AdU9XGdHENV3w68fZnN2UV53we8r5PjrgbHtnAsi7gdPRBhXC+4YcNQeWRiju88OgkClYrHUH+aJ+8a4KHxOabnayQSMdy6MjaYYs9QFj9Uag2fuWqDRqCMFhLkOGfQFveztHsLgSp206vx/ZBircFcucFI1sGyhLgIc3UPW2GyXMcRoeIFzFRcpit1BJtUwiLjOATNG8ZqenBuEJ5388RFqDV8RJVHx4vU3IBYHGzLZiSdoOj5aKgggh+EVBo+ojCcS1704UnYFhWiczpX90g7NjQNZSYRo9EIOF2sMZJOcLxY4aFTRbLJONeOZNk1mD3v5u70ph8v1Thwusgt2/IUMs55+7Z7ryVLFrzm1n7/78gUM6UGuVSMvrTDzoEMZTckVGVL4fypkkt5KO3X0wpCQsBuXquJYn3Bi56quKAQqlJyPdxGwFghTSBcsnztZWldR4DjsxXGi3Uq+eQF566btKaJBGF0f7aq3KW8+TBUxos1pssNdvSnF67H4merl4MCnR5tK/B0Eflr4BdVtdxM391VbdYLAdcPODnXoNYI2dqXopCIU3E9YkDDD5gq1/nOoSm+8egU9UaDqi+MDaRIJWxOTlX4wZFZ3MDDtiz27xmk2vA5MV1msuSSdWJkUgmuGc4ynDv/wWi/QVtNyTBUbBEG0pHxmqt7HJupcvhsiVrok4nHKdYa+L7ixCzmqg0mS3WcmEWlHjBTqeEGwlA2zvVbCji2RdK2mKk1CDWk4gZkHJuhbBIEjkyVePDMPK4XUKn5lGouH58qkbItsJW4FWNLf5qn7BmiWG/wzUMTVNyA5+3bxp6h/JKnNAyVyXKd6XKD/kycECVUPW+w4MRshftPzZNP2jx8dp6j40USMYvj03luHuvDsYWJ+Qa37+gnk3IiD5RzN/1CH5gqlkTGf7xY58hEiURcsBCGc0lqXsBUxSUZsyjWPcq1yBs9W3TZO5KiWAmYrzZ47EwRNwwpVWNMl138MMD3hC25OIcnS/QnHQoZZ8H7bH/46nWfg1MlcnGbpBNjMJMgHbej+2C2QskNmKu5C32UACdnyjwyXgKF67fk2TOURSxwvYCBVGJBVjutboZawycIlXwyTtqJEajiB+A3z0mrid/ygFpeYcK2mKt7K/Lk2iuTmhfgBgGlms/uvjRl/5z3v7jSqXkBk2WX4zMVZqp18k6cHf1RK2WhrzauC0Y5YVsL3nO3DHKnBs0DfhL438B3ReQFqvoY0JuhnB5Trns8NlGi4Xsci1XYW8+SiNmcnqtRrfvsHMpwcHyOHx6ZJRsXgtCmPwb9CYupeZcgUOK2UPcFCQMOni3j1gOOzlYp1xsM5xKM9KWJx6wL+mVaN6gtwlA2gWUJFden0ogubC5mkXdiBEFItRHw0PE5Ts+Vma74ZFPRDRKLCUcmKiRjii0WyZiNE4MjEyWmi3VG+tLkkjF8H3wJOXBinoFcHAuo+yEnpipMzruEwPXDKWaqDR45NU8tiAyF2MINIzlsW0jH4xw8U6buunwRePETYgwVUhc0J+oNn/tOzBEoFNJ5bBGqDZ9HJ8oMJOOkkjZ136fiepyaLXHg+BzzjRDPCzhwusx3Dk2hQIDFkakSt+8aZEsuSRiExEXwVKm6Ht8/NotlKRknTi4Z48x8ldPTFc7OVzk0UOTp14/Sl4rz2HiZXcNJHhkvMT5XxVdlYrbGdw+CF4RghVjYJBwbLwxISIxj01XCUAisgKMTNfYOZXjKNUOM5lMXeI8Hzsxz7/FZUjHYUshw7ZYMh8YruA2Pedej7gdUqwG+H5JK2XhhyJnpKoEqhXSSwZxDMm5Ta0TGdyib4MYteYZzyfNkpeI25bpHue5Tqnscm64wkInTn3LYkncYSido+AFHp6rsHk6TjMfwg5ATs9Vmn54yXqzTl3TYt6MfyxImyvWLetwV1490yiSibo6aT8MLOVmqMlf18LwUw7kkh2dKHJksY4mwJZfEsmC+6uHWfH5wukix4fOE3QNcN5Ll9GydZNzm5m0FCmmHuAiPjBeJicWWviSx5ojtWg3bSpY++cCrROTXgG+KyL9fk+TLSCMIUYHpkkfJrXB8Yo6yG1L1lIGMw3ylzoFTRSarDXb3JbmuP8NwLkGp6vHQmTluHstxx81bqDc8js/UmJqrcrpYZcdAEj+Ik4zHcSyLct3j2HS5aYSiGycVt6m4Pl4QLswBC0OlXPexUCZKNdxGQBAoY4NJ5uYbFGvKfM3HEpitNdg7kmWskGS62qDihSQSFumYzSNnSoQI2/pqWBKSdmKoWkzMVXnstM9czaXUUBKxkJxjk0qmSGYc8l6AHYuRj4VYzaZ4yQ144OgkrgeDGYeKneDIeJF7vnmIF+zbwbWj+QUj88CpeaarNR47Nc9gX5rhTBxfQx44Mcd8xcWybLYNJgGYmnc5Nl2i2AgYKzjELYfDk1VOTkdOfy6b4MRMhYliHce22T6UYjCTZCid5GypxuGJImeLdYazSRIOjM81CIOQM/Mu0+U6fhDgeiHTpToPnU5SrAYcmpij4gaEYQgCvsbJJm1G80lyGRv1oZC0cewYc/Uq/3zgLFUP6g2Xuhdw+54+3IbSn3TY2p9mulTnvlPT4PmoE+PR03Mcn5rn0NkS865H4MNU1cVtePSlEmzrT1Kqe8zXfDIJCw1Djk0oxYpHIWdzaqrCfNWhVGnwpGsGEbEWvPWK61P3fQ5NzXPg+Cy1RsBQNsVAPkG93iDuxNiSS3DgRJHBPoet+TSFdIKEbVNu+FS8Bg8cm6MvHWe66rKrP8PRmSpiwe07+hnMJC4YIAtDpVjz8P2AmC2cmatQSDicmXX54ck5Hss63Ly9wJcfPMu/Hp2iUg/IJWMknTjbBjLsHkoyWaygloXvhZydczk6UyFuCZZEfb3jpTqHp8ok4zb5dAzLip6PtTZBO917wWyq6odE5EHgE0B6TdIvE2P5NDduySNhSHXc5dGpGtMlj3QcbAsCDYGAa0ayPPW6QTS0GMkl+N7hKSquUnWVp9w4iG1bZOPCp75/kvlKnf5sihu25jk6WcV2hIPjRQ5Nlpgo1tk31r/QZzKQdjg+W6Hq+iRiFnN1l0Pj89QbPjMVj1CVbCJGOhHD7oNbJIsfZGiEQhAKtmWxeyTHWBDgq7KjP0vCFv7uh6dRz6Ncr+OFcHK2TtyCSiNkrtJgvu7hCGTTGfoKCVKxGFvzaW7Z2sfjtw/ihyG+hkyVG5ycLPHodJ1y1WPrQIYn7SnwvUcrPDYZGZQXPWkHjhVnplrjnw6cZbbs4gbKaNWjUqtzbKpGxfWjWe3A6WmbSgBZRxARbtqa43E7BkjFbQrHZnlsvEjdU/rTFrOlGrO1gFrDxz6ipOKCZTlcvyVD3VOmS3XOzFRxFSyUvUNpdhUSTFdd/vHBs5RqHnERbBvSiTghFpVGGHkBMYvdfQ637hzglq0FjkxVODVTZ6bqk7RDfnCsyOGJIllHsCXk5GSFbxwaZzidIOXEuGlHH67r8c1HJnHsqE9pttJALEBt0JC6H6AKcdumIXBqvoGGSsy2QWJMlj1OzNTIJctkUzYzpQaluseWgTRFz2U0l2W4EGdi3mWqWOfMfJVHzpQ4NlUmDEO2D2UYKSc5MlVjrlwBbFKJGCKQTcQYzCW4eTSLF4RMlj1qnsfpmQqPnC2ydzjDYDZFX8oBUQ6cmePQeJltfUlu3tZHzLao+z4Pn54n0IDZqsf0fJ2YDdWaFxlqt8FXDsSpeiEzZZeaHzJdbZCIx1EgFbcouUrSgVTCJpsUHCu6bt+rNpiquAznEsQtYSAReapOrDsjw50atGe1/1HVr4vIU4gWkG84AoFcMk427TDSl8UCBtNxRgopfD+kWvcYG8rzgn1j7BjM0vBDYiLYtpBNxulLRU3FG7dE/UnPvW2Me49OM5BOcNv2fvYMZZmcr3N4sszJ6Sonp6pMFOvs6M8y2u9w8GyZeqPBmfka8ZjFkfEavu9Rdj3cUMmlHK4bzdGfcZirCjeNpan5IRXPw0YYSCWoBD4pjXPTtjz5pEPJbfCEPcMcPFvi5GSRehBSSAoVF4byDvlEjP50jJGBDGP5NPl0nJzjMJxLEIvbZHc2+6lUmau5fPfwNANn5zg2W2drIUHdh0I2wdGZOg+fmefPv+lz87Y+vDDg7FwN1/MZzqfJJWwem6gyW6oT2hZb8wkm510OV3wyjs1INsm2gTz7dw5w7ZY8CNywNc/4fI2aG3J6rsJ3Hpsi7jWoekrJbTBRDrHEo+6HXDecIhGzAEECn2wyye7RAsWqz1zdp1zzsW2boVyC2WqA2hZPGsuTTsQZ7UtRcUN2D2Z5/I5+ZmsNzpY9+nIhnh8wWW4wmrYJh7LkMg7HJ8pMlevYIpxM2KRSCR4bnydQJVDwRHAsi0wyhmCxNR8jGU/g2NCXc0g7cWZLLqEGxOIxRvtS+B6Mz1c5PlVivOyR9JWUY1PxfE5PV/jmgZAtA2USTozj0xXKtcjY9adjXDuao9oIcP2QSt1j70CC+12fWr1BOlQScZvpkstcPWR8rk7FC0nHhS35JCHKyekK4/NVtg2kuWVbH//4oMtcqcaJmRp7tuQJwpBT81WOTFaoVGqcnKnjxG0UKNYDqp5PMmYzUfYpuTUGkg77dhTIJmyqno8tFoV0glxKeNzOPPlEAj9QHjpd5vh0nfH5MnFb0DBgfD5OqIAo9jQMZ5IkCqneNTlFRNrejv7/RGRxY/sU0HH4oCuJVNxmOJugVEhTSMaJjRXoSySohz73n5ijEYTsGMwwnEvRn4kiF4WhskdzFFLOeVMkAK4dyuHYFkGgpJ042aRDqdFgrlon6cDBk/M8cnqWHcNZRnJJDp4p0fB9qp4yXnQRDRnpSzOQtvEbATU7cuG9MEQERgtJtvalODlToy8Vp+oHTJVcECGfjJNPxRlMO+STDk/e088/HDjLbLFO3VdyKeXm7TluGCkw1pfGcaJ5V60pBEuNJuaScZzrbK4dyYEqrhcyX/PYWkhx3ZYc9x2Zo+h6HDxTYt+uAjduyROKcPvufio1jwdPzJNN2gzmUowUkpyYrDI9X2WoP8NTrhlgsuhTyDkU0g41L2BHf5ZdgzkAJks17JiN63vEbYvp+Tqh7zNXi85XNu2wbdDG90KSiRg3jBXYmk9RcwMem0yzdyTLQDbJk/cM8ODZEinbZt/2aJCh1ckNUdMmFbcJVbEpcGiyTD5dZzg7wN7BLPXQ56sPTnByusTh6Rq2gIQ+Z8pK3IJrRvLcsCUHlsXOwTTFqs/OwXSzmQ9jhTSZRIyJSp2ZkksiFmOkkMALlKQlfO3wJA8fn6Xk+Vy3Lcd80eXh00VOzNc4VaySilsknRiFTJyYCMOFDM9/wla8QHnkdIlsIsaOoTRPrdU5Nl7jcTvz3Hd0joliFRVw3ZBKw6OQSbJnJMNMqUHcFk7NuUzM1/H9WVzXY7LqEbcsJssexyZLPHSqRNVtkE451Bs+FhY3jWUZziUIFPYMp5gr1zkz1+C6sQLPuHYLuXSco9MV6l7A/SfnOD7tc9uODGMDGdKOxY1bcgxkY3zvUZczRZcDp4pkkzFSjs1sucEjVokdwxmedu0wo4VlA/F0xMU8tHnOLTvyuXAAoLV08MqeabcEliUMZ5PMVBqEqvSnHXb0Z0jYFsP5JIEfkk86DOeS5+2TdmJUvYCh5ryp1ghNLGaxezB73ryy09MuR6frhIFPsRFyZq7K6XmPoZxNzVMcCyyEhBWSTCa4dUuWXC7J9JxLteHj+iGjhTjlWkg6GSObdNg2INGIWCLGYDaBLXLeHK4tTnQz/NwTHA6Ol0g60HDhlq0F0uml12ouF0ppNJ8i3zQCYagL/SypuM2De+f4wr+cQoMQVeG5+8ZohML2gRSHp8qcmW9ww7Ysw5kU2USMJ+5STk5XuXE0TzYZ50iyynAmueTw/WAmyTOuH6Xs+tGgSXPax5HJEt87Ok1/xuGGkTxF1yfl2GwtpBau0zUj+fPmtV2/deCC8ubaOsEdx2bvcI4wVJy4zXQ5xY6BNIXmhNVrBgscnilxZrbK2bk6Z4s1TkyUCG2L5+0bY9tAhkw8GuH0VJecItOvCWzLwhahkDrXL3b7zgEG0g7j8y637SyQiMe478QMX/rXU0xUXDw/pC8e55rhAv05h75Egl39Obb2pblt+yB1L6A/5eCpkro1mp+YSyZxvYCGF3J4pkTOiZFPOBTrDZLxBHtHc0wXXWbKDRpeg4fmoqZxyrGxNOTIRBlblHwmxW1jWRohiFjcsDXP9oE0haTDWF8ayxbqXkA6HluYIzmQSVKsN1DgzFyN3SNZUrHIaA1kHNJzdQqZFNNVj5oXknEssok4Db/BiaLPjqEUyR43OW9p+71n2VwbFDcI6cs41L0QP4j+FzIOWzXNVNklv8Qwd/vi6sUP42LD8KPXDHG2WCMIQnbWXI4kY8x7AdmEzXDWJh6zGM4nCHxhuD/B7sEcW3IJHp2qMFOusyWfZiibALUZTCfODXVnEhc8NC1a3lYuEefWsb6uDYfHYtZ587J2FbI88ZpBfnisSMVTfBVu3d63MJzv2BbbC2lGC6mF1Qy7B3MLZUguEVyzhWVFUy+yyfO9xutH8nghDKUdBnLn4n22T1YtpB0KqyjfYgPewnFsbtzSx/UjhebIX42HT5fY2Z9m+0DmvFUmrTn7i++Z9vlrrbxRmsPwzsHzplQMJB1GCylOTJU5Ml4mmbRx4g77d/czmEktDBS0l7Ml1xKhP50g7djM1RvYts2uoeUyDosAABLCSURBVBTzNZ8hP4mGMJCJpsJMlGrcd2yGJ6cdsmmHm8cKfPORaY5OFhktpHjaDSPcMJwnm4pTrHv0JR2cuH3RicG5VJxMIkY2EV8wtm4Qzek7NVvF9QNu3dXPTWN5Tk5HXqTEhJMTAXFbSDoxcsnVB0hoIedalRub/fv367333nvJfIsnKrYmrLZuqlLNWxiyvlgEiktN/IwegDoT8y7bC0nm3AYnZyqcnauzeziDHwg7h1KgsnDDJJpzx+KW4IeKY0VziDqNhtGarJtNxNY8WnSxY52dr/HI2RIVz6VSDfmxG4cZzac7Oi9r4XIHiFwv+fPVBidmqti2Uq6FXDuaXej6uJRurdn8wHlN7FTcXqhcjs2UefhskbRjc/1onmwiztlSha89PMWt2wvcuq1/TdFX2qm4PjNVl1LN59qhaALw2VKNqWKdybLLeKmGhsJzbtrCSH9nY4wi8n1V3b/Utov1of0pHcwzU9UNNX1jwbNqe1BHnHO1cqchbi4WtqU1kdSxLAYyDtmUw9aBDIlYjFBjbO1Ls7WQXnJ5yEjbPKQwVBzn4qM/7Q9ZN9fbLXesMIwmRl47kqFYcyimPBxZevZ8t7ncoXLWS34uGWfPcPaC1QGd6tberG7/3fIedw1kySTipGL2QlCBvmSSO27a0pXKsJ1oVD/BWCF9zpNOOrh+SCYZYzSfYjiXYCi/tr6zFhfT/FBXJFxhXOqhX81Nu9SM6aoXRLHJ/MjtBtheSGOJsC2fwnHOl79Uf1Inuizer1s343Kya15A3Q+J2zaBeriB4oZhV2ReTi6399dO+7nvxTrN9i6E1sTvhG2RTca7Xv7l7iMLYSiX6tqE2hYXe9HwO7oi4QqjF7XsYqPSMpa+H+LGw4WObcex2T2UXfIYq/Wu1jsKQvuylbgtZBybgdT6RX3oFVfrW796bTyXor0VdFkWpwOIiAPcQBTosX2i7Ze7qtFlZjU19WKjshDpIa7EYp0F4VutoV3vZli7PCewSSfieKpsdJO2UcLjbAZ6ec92Gm3j6cCngATRVI4iUUjsE8Denmh2mVhNTb2sW92DC3clNY02kxG43P1zhu7Q6RX8feC9qvr7IjKrqgMi8lts0DenX4wr/SG9kppGxggYrjQ6bTRfz4XBHf8H8PruqnP5Wc+496uhl/HYDYaNzkpektJaNXBGRG4G+lkUmNHQe650g2swXE46NWifAX6m+fseovDY3wf+shdKGQwGw2ro9J0Cr2v7/Xsi8l0i7+zveqWYwWAwrJRV9eiq6te7rYjBYDCslU6nbewkevPS7Vz4QpPre6CXwWAwrJhOPbRPAQ8Dv0X0fk6DwWC44ujUoN0IPFVVN/6iPYPBsGnpdJTzb4Bn9FIRg8FgWCudemj/CfiWiDwGjLdvUNVf6bpWBoPBsAo6NWgfBgLgIUwfmsFguELp1KDdAWxT1dJqBYnIAHA38GxgCniTqn5siXxvB94CuG3Jj1fVw6uVbTAYrg467UO7Hxhco6wPAA1gFHgp8EcicssyeT+hqtm2jzFmBoPhknTqoX0Z+HsR+TAX9qHdc6mdRSQDvAi4VVXLwDdE5K+BlwFvXJnKBoPBsDSdGrSnE72H89mL0pVobeeluB7wVfVgW9p9LD9y+nwRmQHOAH+oqn/UoZ4Gg+Eq5pIGTUQEeAVwXFX9VcrJEgWFbGeeKEjkYj4J3EXkCT4F+LSIzKnqx5fQ7U7gToCdO3euUjWDwbBZuGQfWvPt6Q8Aa5lUW+Zc+KEWeeCCQQZVfVBVT6tqoKrfIorD9uJldLtLVfer6v7h4eE1qGcwGDYDnQ4K/AtRs3G1HARiInJdW9o+4EAH+ypt7zAwGAyG5ei0D+2rwJdE5CNE7xFYeF9nJ4MCqloRkc8A7xSRXwVuA34W+JHFeUXkZ4GvAXPAk4gm9b65Qz0NBsNVTKcG7WnAES7sxO90UADg1c28E8A08CpVPSAiPwp8UVVbUTz+XTNfAjgJvEdVP9qhDIPBcBXTaYDHn1irIFWdAV64RPrXaQtJpKq/sFZZBoPh6mQl7+XsB54PjBFN4fgbVZ3tlWIGg8GwUjoaFBCRpwKPAb8OPB74NeCxZrrBYDBcEXTqob0feLWq/kUrQUReAvwvoo57g8FguOys5L2cn1yU9pfAtd1Vx2AwGFZPpwbtUaLRx3b+LVEz1GAwGK4IOm1yvg74WxH5T8AxYDdwHfC8HullMBgMK6bTaRvfEpFrgOcC24hCcn+hORXDYDAYrgg6nrbRnKLxZz3UxWAwGNbERQ2aiHyFtmVOS6Cq+szuqmQwGAyr41Ie2nIe2RjRGst0d9UxGAyG1XNRg6aqd7f/F5FB4E3AK4FPAO/snWoGg8GwMjpdKZAXkd8BDhG9E+AJqnqnqp7sqXYGg8GwAi5q0EQkJSJvAg4DNwFPV9WXqaqZf2YwGK44LtWHdpTI6L0XuBcYFZHR9gyq+uXeqGYwGAwr41IGrUY0yvmqZbYrsLerGhkMBsMqudSgwO510sNgMBjWTKdrOQ0Gg+GKxxg0g8GwaTAGzWAwbBqMQTMYDJsGY9AMBsOmwRg0g8GwaTAGzWAwbBqMQTMYDJsGY9AMBsOmwRg0g8GwaTAGzWAwbBrWzaCJyICIfFZEKiJyTER+cZl8IiLvEZHp5uc9IiLrpafBYNi4dPySlC7wAaBBFCDyNuDzInKfqh5YlO9O4IXAPqJoHv8AHAE+uI66GgyGDci6eGgikgFeBLxNVcuq+g3gr4GXLZH9l4H/qaonVfUU8D+Bl6+HngaDYWOzXh7a9YCvqgfb0u4DnrFE3lua29rz3bLUQUXkTiKPDqAsIo+sUr8hYGqV+64WI3NzyDMy11/eruV2WC+DlgWKi9LmgdwyeecX5cuKiKjqea/UU9W7gLvWqpyI3Kuq+9d6HCPz8su8Gsp4tchcjbz1GhQoA/lFaXmg1EHePFBebMwMBoNhMetl0A4CMRG5ri1tH7B4QIBm2r4O8hkMBsN5rItBU9UK8BngnSKSEZGnAT8L/OkS2f8EeIOIjInINuC/AB/psYprbrYamVeMzKuhjFeLzBXLk/VqyYnIAHAP8CxgGnijqn5MRH4U+KKqZpv5BHgP8KvNXf8Y+G+myWkwGC7Fuhk0g8Fg6DVm6ZPBYNg0GINmMBg2DcagGQyGTcNVYdBExG773fOF7iKSavu9XsvLpP17nWQ6bb97Xk4Rya6nvKacvSKSb/5el3MrIk8SkRvWQ1abzB8XkTvWWeYzROQtrfPbDTa1QRORnSLyCeCDIvJagF6OlorIdhH5W+DjIvIHIpJS1bBX8poyx0Tk3cCPQG/L1yZzp4h8DLhLRN7VlNuzcjblfRb4sIjcIyKxXp/Xptz/CPwQeDb0/tyKyA4R+UfgE0BfL2W1yRwSkS8CnwYeJyLxdZC5Q0S+AHwF+B2WnmC/KjatQROR24GvAmeAh4DXisjHRSTdI3mDwN8CJ4D/AzwN+JiI7LvojmuT+QtEN8WbgJ8SkaFmes88CRH5deBeovP6ZeAlInJPc1vX7ycReQvwA6Lz+k6iaT8faG7rtce0D5gFnrxoUnjXaPOs30s0gfwhVd2rqt9t395DfgOYVtVBVf0DVfV6KUxEPkRUzoPAbqJn9Ke6dfz1DB+03jwL+Lqqvg5ARP4KeBT4roh8SFVrXZZ3O1BR1Vc15X0H+CTwUhEZV9WzXZYHUSim/49oudivA98BPt8rT0JE+oDrgNeo6iebafcDXxWR16nq4vW6a5UnQAj8lKre20z7BpBfam1vF+XaqhoQ3S+fAJ4CPCQix1XV7aastjL8JPA1VX1tU4cnEz30JSDopszm8QXIAI8nmveJiLy4ufleVT3aA5l7iUKI7VPVIyIyCgy267TWa7ppPDQR2baoLW4BaRGJNy/eaeAw8EvAji7ISzS/Wy56Cbipld58uO8GbmTpqCJrkdnqu7ob+EtV/ThwEniBiOzuhqwlZArgAh8HvtRMs4iaRg8BXfEk2uTFmjf3+1T1XhF5okTRVF5AdB1f2N6H1yWZNkDTmAE8Ffgwkef9s8CebshbJDPZTHoZcIeIvKpZGf5f4AvAn7T3AXdJpt08txngVqAoIh8H3gX8CvAZEVkqtNdaZIqqHlbV1zaNWVxVx4mCT/xEK/ta5W14gyYiBRH5PPBPwJdE5KXNk/gYUe3+i82Lt5OoebabZn/Tatx5EelvNrE+CNDmoo8D3wNe1Zb900Te0xPX8vAtIbPRvEFKqjrbzPb7RE2kH+1GP8gSMlVVa6p6r6oWm/JDIEFkzMtdluc3v1se0TbgD1U1A7wP+G3gLSKyVMSW1coMmumt5+IEUeV3N5AEfkFE3iUij++izHrTeB8g8gY/QLQ65ulEy/7uAP5zc99VPfBLlbNp1MaJwnPdBZxS1RtV9WeAvwSe2+Vyats2Afzm338CdolIohv9ohveoAH/HagRRcH9EvAS4O2q+ing+8DvNWuffwU+T9S/9VxYeSeviDwO+CzwJOB6Efn5ts0TwDeBHxORPc3jh8BfAS9S1cZqCncRmdKWR5pNsn8Gfg64eTWyLiWz3VNoO3cvBB5u82p6Je9vVPV/N8s6TeRNvJyo0uqmTKvtwbodeERVZwAPeAvwOCIPsWsyOfccvhJ4pqr+MVGEmW8DbwV+DVY3KHGJexaitdO3Aqm2tM8D1wCrqoQvdm5hoXJslSUAsqrqShf6YDesQRMRS6IO/l3AF5o1+buJarefF5Fnqep7gecRRce9XVU/B4wQdTKvphPbIVpQ/3KimuWVLc9LVavNtDrw39r2OQ4cF5HCqgq6jExVDdtq7Nb3+4nCLf2IiPxXEXm3rG4QZDmZQUtm8/zbwBOJPAtE5FdF5FXLHHNN8tpo9fuWiDrsVzvkf7Hz2nqQvwu8Q0QeaMr5BnCUqKnWTZmNpsfkE3WSw7lyhsBRaZuy0iWZrQrou8DfAT/e2kFV7wNsov6ubsoM2++fZt4vEDkBo10ZuVbVDfPhXH/UcPN/DvgX4MVtebJEXtvXl9j/8UQjdM9ZobyR5n8HKDR/P615Md7Qll+IRmyOAR8i8pbuJ+oHWmkZLykTsJbY/w+IHoIp4IW9ktksaz9R/9JLiEY8x4Hn9aqMgN38vomoef+7vTivLbnAnzXvr1c0036a6EEd7eW15Nwa6xuIDM4belXOZvoeoor3C0TN228TRcfJ9fqeBa4lqiie1WkZL6pLNw7S6w9RbfF/iToQv0zUCf1zzW2/B/xgUf5/Q9Rf9lPN/6PA55r7v3GV8p6/KE+2efG/BuxatO1pRN7St4jeo7DaMl5SJpFhsYA4UT+a1+kDsAaZLaP2LM4Zz9/qcRlzRPPB/orIM3tzL8vYTN8DpLt0v3ZazhTRqGrrfn1Tj2W2Kombgdc35fZapnDOaI8QdQfdutLzvKRO3ThIrz9EntVXiGKMx4iadMeIRqGGicJ7v6Qt/w7g68Cz29JeCuTXIO8w8GOL8t0K/AXw/ra0eNvv2BrL2KnMWPP75zstYxdk2kR9JL9F1AfSa3lCZGDupEPPoYvndcErXady7gVeu47lbL9nL/D6e3luF8tf66crB+nFByi03Uh3AocX3Vx/QTSkPgy8hqhT/tq2/b8H/HgX5X2caLRrb9s+DtFw/j8SNXO/SYfN2S7L/Ol1lvlt4I51ltdxk2QDX8urpZwrkrmSz7oaqQ5P2HVEnZR/SzRSsotoCPurwG1t+Vr9YS9s/v8sURPv/UTu7bdotul7Ia8t/XlEUxZOAS/vZRk3ksyroYxGZm9lruZzRY1yisgriNri/wL8JjAAvI3InR2nuaYOQFXvBx4A/kMz6U6iuUkA/6CqP6KqEz2Q97LmvraIPItozs7/UdUxVf1Ij8q4oWReDWU0Mnsrc9X0ylKu5kM0t+iVbf+3E1n1bUTt80/Q1tQBnk+0LizdltZRP0c35AFjQN96lnEjyLwaymhk9lbmaj9X2lrODxItr2ktmagSzfhPAZ8imuz3OhF5TFWPEXVK/71Gc8CAFU8+XJM8jd7svq5l3CAyr4YyGpm9lbk61sNqrvTDuSHd24ncV6f5/1aiYeUfEs1dmaRtJHOjyLtaZF4NZTQyeytzxTpeDqErOIGvJ1p83Z5mA/uBX97o8q4WmVdDGY3M3srsWLfLKfwiJ6w12e/jwK82f7+KaARzeKPLu1pkXg1lNDJ7K3OlnyutDw1YiAYQIxpNGRGRrxFFyfgVVZ3c6PKuFplXQxmNzN7KXDGX26JepDZ4HNGymjPAb2w2eVeLzKuhjEbmlfO57Apc5MQ5wBuA5GaUd7XIvBrKaGReOR/z5nSDwbBpuKJWChgMBsNaMAbNYDBsGoxBMxgMmwZj0AwGw6bBGDSDwbBpMAbNYDBsGoxBMxgMmwZj0AwGw6bh/wc7qUdI7AaH0wAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -322,7 +322,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -438,7 +438,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -459,7 +459,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -502,9 +502,9 @@ " \n", " start\n", " end\n", - " slope\n", - " slope_low\n", - " slope_high\n", + " soiling_rate\n", + " soiling_rate_low\n", + " soiling_rate_high\n", " inferred_start_loss\n", " inferred_end_loss\n", " length\n", @@ -577,19 +577,26 @@ "" ], "text/plain": [ - " start end slope slope_low \\\n", - "0 2008-11-13 00:00:00+09:30 2008-12-11 00:00:00+09:30 -0.001403 -0.004020 \n", - "1 2008-12-12 00:00:00+09:30 2009-01-01 00:00:00+09:30 -0.000641 -0.002886 \n", - "2 2009-01-02 00:00:00+09:30 2009-03-20 00:00:00+09:30 0.000000 0.000000 \n", - "3 2009-03-21 00:00:00+09:30 2009-03-24 00:00:00+09:30 0.000000 0.000000 \n", - "4 2009-03-25 00:00:00+09:30 2009-05-28 00:00:00+09:30 -0.000559 -0.000880 \n", + " start end soiling_rate \\\n", + "0 2008-11-13 00:00:00+09:30 2008-12-11 00:00:00+09:30 -0.001403 \n", + "1 2008-12-12 00:00:00+09:30 2009-01-01 00:00:00+09:30 -0.000641 \n", + "2 2009-01-02 00:00:00+09:30 2009-03-20 00:00:00+09:30 0.000000 \n", + "3 2009-03-21 00:00:00+09:30 2009-03-24 00:00:00+09:30 0.000000 \n", + "4 2009-03-25 00:00:00+09:30 2009-05-28 00:00:00+09:30 -0.000559 \n", "\n", - " slope_high inferred_start_loss inferred_end_loss length valid \n", - "0 0.000000 1.021948 0.982670 28 True \n", - "1 0.000000 0.990297 0.977467 20 True \n", - "2 0.000000 0.981110 0.995768 77 False \n", - "3 0.000000 0.987695 1.023433 3 False \n", - "4 -0.000244 1.039308 1.003510 64 True " + " soiling_rate_low soiling_rate_high inferred_start_loss \\\n", + "0 -0.004020 0.000000 1.021948 \n", + "1 -0.002886 0.000000 0.990297 \n", + "2 0.000000 0.000000 0.981110 \n", + "3 0.000000 0.000000 0.987695 \n", + "4 -0.000880 -0.000244 1.039308 \n", + "\n", + " inferred_end_loss length valid \n", + "0 0.982670 28 True \n", + "1 0.977467 20 True \n", + "2 0.995768 77 False \n", + "3 1.023433 3 False \n", + "4 1.003510 64 True " ] }, "execution_count": 15, @@ -610,7 +617,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -760,7 +767,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -793,7 +800,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -826,7 +833,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.7" + "version": "3.7.4" } }, "nbformat": 4, diff --git a/docs/degradation_and_soiling_example_pvdaq_4.ipynb b/docs/degradation_and_soiling_example_pvdaq_4.ipynb index 333deeef..70a2ee1d 100644 --- a/docs/degradation_and_soiling_example_pvdaq_4.ipynb +++ b/docs/degradation_and_soiling_example_pvdaq_4.ipynb @@ -851,9 +851,9 @@ " \n", " 0\n", " 2010\n", - " 0.892087\n", - " 0.881133\n", - " 0.899309\n", + " 0.963661\n", + " 0.951828\n", + " 0.971463\n", " \n", " \n", " 1\n", @@ -893,9 +893,9 @@ " \n", " 6\n", " 2016\n", - " 0.923150\n", - " 0.911463\n", - " 0.930717\n", + " 0.937259\n", + " 0.925394\n", + " 0.944943\n", " \n", " \n", "\n", @@ -903,13 +903,13 @@ ], "text/plain": [ " year soiling_ratio_median soiling_ratio_low soiling_ratio_high\n", - "0 2010 0.892087 0.881133 0.899309\n", + "0 2010 0.963661 0.951828 0.971463\n", "1 2011 0.944819 0.936342 0.950665\n", "2 2012 0.939456 0.931768 0.945988\n", "3 2013 0.954258 0.944068 0.961534\n", "4 2014 0.950645 0.929716 0.966537\n", "5 2015 0.951059 0.921407 0.966395\n", - "6 2016 0.923150 0.911463 0.930717" + "6 2016 0.937259 0.925394 0.944943" ] }, "execution_count": 19, @@ -1148,7 +1148,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.7" + "version": "3.7.9" } }, "nbformat": 4, From 5c5c8c3c729beb47b3725f63fafcdb8a33d3f238 Mon Sep 17 00:00:00 2001 From: Michael Deceglie Date: Wed, 7 Oct 2020 16:30:22 -0600 Subject: [PATCH 15/16] get rid of print statements --- rdtools/test/soiling_test.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/rdtools/test/soiling_test.py b/rdtools/test/soiling_test.py index eabcd167..8c72caf6 100644 --- a/rdtools/test/soiling_test.py +++ b/rdtools/test/soiling_test.py @@ -256,7 +256,6 @@ def test_annual_soiling_ratios(multi_year_profiles): srr_profiles, insolation = multi_year_profiles result = annual_soiling_ratios(srr_profiles, insolation) - print(result) pd.testing.assert_frame_equal(result, expected, atol=1e-8) @@ -270,10 +269,10 @@ def test_annual_soiling_ratios_confidence_interval(multi_year_profiles): srr_profiles, insolation = multi_year_profiles result = annual_soiling_ratios(srr_profiles, insolation, confidence_level=95) - print(result) pd.testing.assert_frame_equal(result, expected, atol=1e-8) + def test_annual_soiling_ratios_warning(multi_year_profiles): srr_profiles, insolation = multi_year_profiles insolation = insolation.iloc[:-200] From 58bc12afc42d07356111919f2bc6804d5a0760c4 Mon Sep 17 00:00:00 2001 From: Michael Deceglie Date: Wed, 7 Oct 2020 16:32:21 -0600 Subject: [PATCH 16/16] Explicitly test warning message --- rdtools/test/soiling_test.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/rdtools/test/soiling_test.py b/rdtools/test/soiling_test.py index 8c72caf6..3a71076b 100644 --- a/rdtools/test/soiling_test.py +++ b/rdtools/test/soiling_test.py @@ -276,7 +276,10 @@ def test_annual_soiling_ratios_confidence_interval(multi_year_profiles): def test_annual_soiling_ratios_warning(multi_year_profiles): srr_profiles, insolation = multi_year_profiles insolation = insolation.iloc[:-200] - with pytest.warns(UserWarning): + match = ('The indexes of stochastic_soiling_profiles are not entirely contained ' + 'within the index of insolation_daily. Every day in stochastic_soiling_profiles ' + 'should be represented in insolation_daily. This may cause erroneous results.') + with pytest.warns(UserWarning, match=match): result = annual_soiling_ratios(srr_profiles, insolation)