From 160fa525ca4b70e291232b860369f79abaf1494e Mon Sep 17 00:00:00 2001 From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Fri, 26 Jan 2024 17:25:32 +0100 Subject: [PATCH 01/12] Update environment specs (#845) * Update environment specs * Set 'nodefaults' because conda-forge is incompatible with Anaconda default channels. * Set 'pyproj' requirement instead of 'proj'. * Drop minimum pyproj requirement to v3.5 v3.6 conflicts with gdal because of proj requirements. * Update CHANGELOG.md * dependencies: sneak in minimal versions for pyarrow and numexpr --------- Co-authored-by: emanuel-schmid --- CHANGELOG.md | 12 ++++++++++++ requirements/env_climada.yml | 6 ++++-- setup.py | 1 + 3 files changed, 17 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6318e871f2..15bf10411f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,16 @@ Code freeze date: YYYY-MM-DD ### Dependency Changes +Added: + +- `pyproj` >=3.5 +- `pyarrow` >=14.0 +- `numexpr` >=2.8 + +Removed: + +- `proj` (in favor of `pyproj`) + ### Added - Convenience method `api_client.Client.get_dataset_file`, combining `get_dataset_info` and `download_dataset`, returning a single file objet. [#821](https://github.com/CLIMADA-project/climada_python/pull/821) @@ -24,6 +34,7 @@ Code freeze date: YYYY-MM-DD - Recommend using Mamba instead of Conda for installing CLIMADA [#809](https://github.com/CLIMADA-project/climada_python/pull/809) - `Hazard.from_xarray_raster` now allows arbitrary values as 'event' coordinates [#837](https://github.com/CLIMADA-project/climada_python/pull/837) - `climada.test.get_test_file` now compares the version of the requested test dataset with the version of climada itself and selects the most appropriate dataset. In this way a test file can be updated without the need of changing the code of the unittest. [#822](https://github.com/CLIMADA-project/climada_python/pull/822) +- Explicitly require `pyproj` instead of `proj` (the latter is now implicitly required) [#845](https://github.com/CLIMADA-project/climada_python/pull/845) ### Fixed @@ -32,6 +43,7 @@ Code freeze date: YYYY-MM-DD - `climada.util.yearsets.sample_from_poisson`: fix a bug ([#819](https://github.com/CLIMADA-project/climada_python/issues/819)) and inconsistency that occurs when lambda events per year (`lam`) are set to 1. [[#823](https://github.com/CLIMADA-project/climada_python/pull/823)] - In the TropCyclone class in the Holland model 2008 and 2010 implementation, a doublecounting of translational velocity is removed [#833](https://github.com/CLIMADA-project/climada_python/pull/833) - `climada.util.test.test_finance` and `climada.test.test_engine` updated to recent input data from worldbank [#841](https://github.com/CLIMADA-project/climada_python/pull/841) +- Set `nodefaults` in Conda environment specs because `defaults` are not compatible with conda-forge [#845](https://github.com/CLIMADA-project/climada_python/pull/845) ### Deprecated diff --git a/requirements/env_climada.yml b/requirements/env_climada.yml index 1988b4af03..53ff63bf0f 100644 --- a/requirements/env_climada.yml +++ b/requirements/env_climada.yml @@ -1,7 +1,7 @@ name: climada_env channels: - conda-forge - - defaults + - nodefaults dependencies: - bottleneck>=1.3 - cartopy>=0.22 @@ -16,15 +16,17 @@ dependencies: - matplotlib-base>=3.8 - netcdf4>=1.6 - numba>=0.58 + - numexpr>=2.8 - openpyxl>=3.1 - pandas>=2.1,<2.2 # 2.2 is not compatible with the default pytables=3.7 and yields a very high deprecation warning number through geopandas - pandas-datareader>=0.10 - pathos>=0.3 - pint>=0.22 - pip - - proj>=9.1 + - pyarrow>=14.0 - pycountry>=22.3 - pyepsg>=0.4 + - pyproj>=3.5 - pytables>=3.7 - pyxlsb>=1.0 - rasterio>=1.3 diff --git a/setup.py b/setup.py index 1aff5d0caf..36dafad9fa 100644 --- a/setup.py +++ b/setup.py @@ -81,6 +81,7 @@ 'pillow', 'pint', 'pycountry', + 'pyproj', 'rasterio', 'salib', 'scikit-learn', From 7b849b36f6eb4d309cc3b94e6954bb286265b489 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Mon, 29 Jan 2024 10:25:53 +0100 Subject: [PATCH 02/12] dependencies: pyarrow>=14 breaks environment build --- requirements/env_climada.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/requirements/env_climada.yml b/requirements/env_climada.yml index 53ff63bf0f..47df554116 100644 --- a/requirements/env_climada.yml +++ b/requirements/env_climada.yml @@ -23,7 +23,6 @@ dependencies: - pathos>=0.3 - pint>=0.22 - pip - - pyarrow>=14.0 - pycountry>=22.3 - pyepsg>=0.4 - pyproj>=3.5 From d82827cf9645ad62b5d1b1d380a650e28abe9213 Mon Sep 17 00:00:00 2001 From: Timo Schmid <55481374+timschmi95@users.noreply.github.com> Date: Tue, 30 Jan 2024 13:16:27 +0100 Subject: [PATCH 03/12] Add reset_frequency option to Impact.select (#847) * add impact.select reset_frequency option * update changelog/authors --------- Co-authored-by: Schmid Timo --- AUTHORS.md | 1 + CHANGELOG.md | 1 + climada/engine/impact.py | 27 ++++++++++++++++++++--- climada/engine/test/test_impact.py | 35 ++++++++++++++++++++++++++++++ 4 files changed, 61 insertions(+), 3 deletions(-) diff --git a/AUTHORS.md b/AUTHORS.md index bb854e1519..ff5484de68 100644 --- a/AUTHORS.md +++ b/AUTHORS.md @@ -31,3 +31,4 @@ * Leonie Villiger * Kam Lam Yeung * Sarah Hülsen +* Timo Schmid diff --git a/CHANGELOG.md b/CHANGELOG.md index 15bf10411f..db43c1c90a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -24,6 +24,7 @@ Removed: - Convenience method `api_client.Client.get_dataset_file`, combining `get_dataset_info` and `download_dataset`, returning a single file objet. [#821](https://github.com/CLIMADA-project/climada_python/pull/821) - Read and Write methods to and from csv files for the `DiscRates` class. [#818](ttps://github.com/CLIMADA-project/climada_python/pull/818) +- Add reset_frequency option for the impact.select() function. [#847](https://github.com/CLIMADA-project/climada_python/pull/847) ### Changed diff --git a/climada/engine/impact.py b/climada/engine/impact.py index 7c3fc67f6b..88b112b009 100644 --- a/climada/engine/impact.py +++ b/climada/engine/impact.py @@ -1475,9 +1475,14 @@ def _cen_return_imp(imp, freq, imp_th, return_periods): return imp_fit - def select(self, - event_ids=None, event_names=None, dates=None, - coord_exp=None): + def select( + self, + event_ids=None, + event_names=None, + dates=None, + coord_exp=None, + reset_frequency=False + ): """ Select a subset of events and/or exposure points from the impact. If multiple input variables are not None, it returns all the impacts @@ -1509,6 +1514,9 @@ def select(self, coord_exp : np.array, optional Selection of exposures coordinates [lat, lon] (in degrees) The default is None. + reset_frequency : bool, optional + Change frequency of events proportional to difference between first and last + year (old and new). Assumes annual frequency values. Default: False. Raises ------ @@ -1580,6 +1588,19 @@ def select(self, LOGGER.info("The total value cannot be re-computed for a " "subset of exposures and is set to None.") + # reset frequency if date span has changed (optional): + if reset_frequency: + if self.frequency_unit not in ['1/year', 'annual', '1/y', '1/a']: + LOGGER.warning("Resetting the frequency is based on the calendar year of given" + " dates but the frequency unit here is %s. Consider setting the frequency" + " manually for the selection or changing the frequency unit to %s.", + self.frequency_unit, DEF_FREQ_UNIT) + year_span_old = np.abs(dt.datetime.fromordinal(self.date.max()).year - + dt.datetime.fromordinal(self.date.min()).year) + 1 + year_span_new = np.abs(dt.datetime.fromordinal(imp.date.max()).year - + dt.datetime.fromordinal(imp.date.min()).year) + 1 + imp.frequency = imp.frequency * year_span_old / year_span_new + # cast frequency vector into 2d array for sparse matrix multiplication freq_mat = imp.frequency.reshape(len(imp.frequency), 1) # .A1 reduce 1d matrix to 1d array diff --git a/climada/engine/test/test_impact.py b/climada/engine/test/test_impact.py index 454df92d0c..a0b458ca55 100644 --- a/climada/engine/test/test_impact.py +++ b/climada/engine/test/test_impact.py @@ -27,6 +27,7 @@ import h5py from pyproj import CRS from rasterio.crs import CRS as rCRS +import datetime as dt from climada.entity.entity_def import Entity from climada.hazard.base import Hazard @@ -67,6 +68,24 @@ def dummy_impact(): haz_type="TC", ) +def dummy_impact_yearly(): + """Return an impact containing events in multiple years""" + imp = dummy_impact() + + years = np.arange(2010,2010+len(imp.date)) + + # Edit the date and frequency + imp.date = np.array([dt.date(year,1,1).toordinal() for year in years]) + imp.frequency_unit = "1/year" + imp.frequency = np.ones(len(years))/len(years) + + # Calculate the correct expected annual impact + freq_mat = imp.frequency.reshape(len(imp.frequency), 1) + imp.eai_exp = imp.imp_mat.multiply(freq_mat).sum(axis=0).A1 + imp.aai_agg = imp.eai_exp.sum() + + return imp + class TestImpact(unittest.TestCase): """"Test initialization and more""" @@ -868,6 +887,22 @@ def test_select_imp_map_fail(self): with self.assertRaises(ValueError): imp.select(event_ids=[0], event_names=[1, 'two'], dates=(0, 2)) + def test_select_reset_frequency(self): + """Test that reset_frequency option works correctly""" + + imp = dummy_impact_yearly() # 6 events, 1 per year + + # select first 4 events + n_yr = 4 + sel_imp = imp.select(dates=(imp.date[0],imp.date[n_yr-1]), reset_frequency=True) + + # check frequency-related attributes + np.testing.assert_array_equal(sel_imp.frequency, [1/n_yr]*n_yr) + self.assertEqual(sel_imp.aai_agg,imp.at_event[0:n_yr].sum()/n_yr) + np.testing.assert_array_equal(sel_imp.eai_exp, + imp.imp_mat[0:n_yr,:].todense().sum(axis=0).A1/n_yr) + + class TestConvertExp(unittest.TestCase): def test__build_exp(self): """Test that an impact set can be converted to an exposure""" From 7979fef95e6efd16462733fd32619f8e5e7e1bb2 Mon Sep 17 00:00:00 2001 From: Simona Meiler <47355042+simonameiler@users.noreply.github.com> Date: Wed, 31 Jan 2024 10:39:28 +0100 Subject: [PATCH 04/12] Integration of CalcDeltaImpact class of unsequa into develop (#844) * Add delta impact uncertainty module * Add unit tests * Update unsequa tutorial --------- Co-authored-by: Emanuel Schmid <51439563+emanuel-schmid@users.noreply.github.com> Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Co-authored-by: Chahan M. Kropf --- CHANGELOG.md | 2 + climada/engine/unsequa/__init__.py | 1 + climada/engine/unsequa/calc_base.py | 20 +- climada/engine/unsequa/calc_cost_benefit.py | 4 +- climada/engine/unsequa/calc_delta_climate.py | 443 +++ climada/engine/unsequa/test/test_unsequa.py | 88 +- climada/engine/unsequa/unc_output.py | 169 +- .../util/test/test_value_representation.py | 49 +- climada/util/value_representation.py | 96 +- doc/climada/climada.engine.unsequa.rst | 7 + doc/tutorial/climada_engine_unsequa.ipynb | 3148 +++++++++++++---- 11 files changed, 3191 insertions(+), 836 deletions(-) create mode 100644 climada/engine/unsequa/calc_delta_climate.py diff --git a/CHANGELOG.md b/CHANGELOG.md index db43c1c90a..67145f49d3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -24,6 +24,8 @@ Removed: - Convenience method `api_client.Client.get_dataset_file`, combining `get_dataset_info` and `download_dataset`, returning a single file objet. [#821](https://github.com/CLIMADA-project/climada_python/pull/821) - Read and Write methods to and from csv files for the `DiscRates` class. [#818](ttps://github.com/CLIMADA-project/climada_python/pull/818) +- Add `CalcDeltaClimate` to unsequa module to allow uncertainty and sensitivity analysis of impact change calculations [#844](https://github.com/CLIMADA-project/climada_python/pull/844) +- Add function `safe_divide` in util which handles division by zero and NaN values in the numerator or denominator [#844](https://github.com/CLIMADA-project/climada_python/pull/844) - Add reset_frequency option for the impact.select() function. [#847](https://github.com/CLIMADA-project/climada_python/pull/847) ### Changed diff --git a/climada/engine/unsequa/__init__.py b/climada/engine/unsequa/__init__.py index cb51e56f2e..7241979eb1 100755 --- a/climada/engine/unsequa/__init__.py +++ b/climada/engine/unsequa/__init__.py @@ -22,3 +22,4 @@ from .calc_base import * from .calc_impact import * from .calc_cost_benefit import * +from .calc_delta_climate import * diff --git a/climada/engine/unsequa/calc_base.py b/climada/engine/unsequa/calc_base.py index 456352cf97..3038639ab7 100644 --- a/climada/engine/unsequa/calc_base.py +++ b/climada/engine/unsequa/calc_base.py @@ -85,7 +85,6 @@ def __init__(self): """ Empty constructor to be overwritten by subclasses """ - pass def check_distr(self): """ @@ -118,7 +117,6 @@ def check_distr(self): distr_dict[input_param_name] = input_param_func return True - @property def input_vars(self): """ @@ -179,7 +177,6 @@ def est_comp_time(self, n_samples, time_one_run, processes=None): "been assigned to exp before defining input_var, ..." "\n If computation cannot be reduced, consider using" " a surrogate model https://www.uqlab.com/", time_one_run) - total_time = n_samples * time_one_run / processes LOGGER.info("\n\nEstimated computaion time: %s\n", dt.timedelta(seconds=total_time)) @@ -323,21 +320,23 @@ def sensitivity(self, unc_output, sensitivity_method = 'sobol', Parameters ---------- - unc_output : climada.engine.uncertainty.unc_output.UncOutput + unc_output : climada.engine.unsequa.UncOutput Uncertainty data object in which to store the sensitivity indices sensitivity_method : str, optional - Sensitivity analysis method from SALib.analyse. Possible choices: 'fast', 'rbd_fact', - 'morris', 'sobol', 'delta', 'ff'. Note that in Salib, sampling methods and sensitivity - analysis methods should be used in specific pairs: + sensitivity analysis method from SALib.analyse + Possible choices: + 'fast', 'rbd_fact', 'morris', 'sobol', 'delta', 'ff' + The default is 'sobol'. + Note that in Salib, sampling methods and sensitivity analysis + methods should be used in specific pairs. https://salib.readthedocs.io/en/latest/api.html - Default: 'sobol' sensitivity_kwargs: dict, optional Keyword arguments of the chosen SALib analyse method. The default is to use SALib's default arguments. Returns ------- - sens_output : climada.engine.uncertainty.unc_output.UncOutput() + sens_output : climada.engine.unsequa.UncOutput Uncertainty data object with all the sensitivity indices, and all the uncertainty data copied over from unc_output. @@ -379,6 +378,7 @@ def sensitivity(self, unc_output, sensitivity_method = 'sobol', return sens_output + def _multiprocess_chunksize(samples_df, processes): """Divides the samples into chunks for multiprocesses computing @@ -405,6 +405,7 @@ def _multiprocess_chunksize(samples_df, processes): samples_df.shape[0] / processes ).astype(int) + def _transpose_chunked_data(metrics): """Transposes the output metrics lists from one list per chunk of samples to one list per output metric @@ -434,6 +435,7 @@ def _transpose_chunked_data(metrics): for x in zip(*metrics) ] + def _sample_parallel_iterator(samples, chunksize, **kwargs): """ Make iterator over chunks of samples diff --git a/climada/engine/unsequa/calc_cost_benefit.py b/climada/engine/unsequa/calc_cost_benefit.py index 7b903c5c55..36f1fe2d1d 100644 --- a/climada/engine/unsequa/calc_cost_benefit.py +++ b/climada/engine/unsequa/calc_cost_benefit.py @@ -68,7 +68,9 @@ class CalcCostBenefit(Calc): ('haz_input_var', 'ent_input_var', 'haz_fut_input_var', 'ent_fut_input_var') _metric_names : tuple(str) Names of the cost benefit output metrics - ('tot_climate_risk', 'benefit', 'cost_ben_ratio', 'imp_meas_present', 'imp_meas_future') + ('tot_climate_risk', 'benefit', 'cost_ben_ratio', + 'imp_meas_present', 'imp_meas_future') + """ _input_var_names = ( diff --git a/climada/engine/unsequa/calc_delta_climate.py b/climada/engine/unsequa/calc_delta_climate.py new file mode 100644 index 0000000000..8f7e21fba9 --- /dev/null +++ b/climada/engine/unsequa/calc_delta_climate.py @@ -0,0 +1,443 @@ +""" +This file is part of CLIMADA. + +Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS. + +CLIMADA is free software: you can redistribute it and/or modify it under the +terms of the GNU General Public License as published by the Free +Software Foundation, version 3. + +CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A +PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with CLIMADA. If not, see . + +--- + +Define Uncertainty class for Impact differences between two climates. +""" + +__all__ = ["CalcDeltaImpact"] + +import logging +import time +from typing import Union +import itertools + +import pandas as pd +import numpy as np +import pathos.multiprocessing as mp + +# use pathos.multiprocess fork of multiprocessing for compatibility +# wiht notebooks and other environments https://stackoverflow.com/a/65001152/12454103 + +from climada.engine import ImpactCalc +from climada.engine.unsequa import Calc, InputVar, UncImpactOutput +from climada.engine.unsequa.calc_base import ( + _sample_parallel_iterator, + _multiprocess_chunksize, + _transpose_chunked_data, +) +from climada.entity import Exposures, ImpactFuncSet +from climada.hazard import Hazard +from climada.util import log_level +from climada.util.value_representation import safe_divide + + +LOGGER = logging.getLogger(__name__) + + +class CalcDeltaImpact(Calc): + """ + Delta Impact uncertainty caclulation class. + + This is the class to perform uncertainty analysis on the outputs of a relative + change in impact from a (final impact - initial impact) / initial impact. + Impact objects are regular climada.engine.impact.Impact() objects. The resulting + Delta Impact is a relative change (fraction of the inital impact). The relative + change is intuitive to understand in contrast to absolute changes which are + hard to understand without knowledge of the absolute initial (baseline) state. + + Attributes + ---------- + rp : list(int) + List of the chosen return periods. + calc_eai_exp : bool + Compute eai_exp or not + calc_at_event : bool + Compute eai_exp or not + value_unit : str + Unit of the exposures value + exp_input_var : InputVar or Exposures + Exposure uncertainty variable + impf_input_var : InputVar if ImpactFuncSet + Impact function set uncertainty variable + haz_input_var: InputVar or Hazard + Hazard uncertainty variable + _input_var_names : tuple(str) + Names of the required uncertainty input variables + ('exp_initial_input_var', 'impf_initial_input_var', 'haz_initial_input_var', + 'exp_final_input_var', 'impf_final_input_var', 'haz_final_input_var'') + _metric_names : tuple(str) + Names of the impact output metrics + ('aai_agg', 'freq_curve', 'at_event', 'eai_exp') + """ + + _input_var_names = ( + "exp_initial_input_var", + "impf_initial_input_var", + "haz_initial_input_var", + "exp_final_input_var", + "impf_final_input_var", + "haz_final_input_var", + ) + """Names of the required uncertainty variables""" + + _metric_names = ("aai_agg", "freq_curve", "at_event", "eai_exp") + """Names of the cost benefit output metrics""" + + def __init__( + self, + exp_initial_input_var: Union[InputVar, Exposures], + impf_initial_input_var: Union[InputVar, ImpactFuncSet], + haz_initial_input_var: Union[InputVar, Hazard], + exp_final_input_var: Union[InputVar, Exposures], + impf_final_input_var: Union[InputVar, ImpactFuncSet], + haz_final_input_var: Union[InputVar, Hazard], + ): + """Initialize UncCalcImpact + + Sets the uncertainty input variables, the impact metric_names, and the + units. + + Parameters + ---------- + exp_initial_input_var : climada.engine.uncertainty.input_var.InputVar + or climada.entity.Exposure + Exposure uncertainty variable or Exposure of initial state + impf_initital_input_var : climada.engine.uncertainty.input_var.InputVar + or climada.entity.ImpactFuncSet + Impact function set uncertainty variable or Impact function set of + initial state + haz_initial_input_var : climada.engine.uncertainty.input_var.InputVar + or climada.hazard.Hazard + Hazard uncertainty variable or Hazard of initial state + exp_final_input_var : climada.engine.uncertainty.input_var.InputVar or + climada.entity.Exposure + Exposure uncertainty variable or Exposure of final state + impf_final_input_var : climada.engine.uncertainty.input_var.InputVar or + climada.entity.ImpactFuncSet + Impact function set uncertainty variable or Impact function set of + final state + haz_final_input_var : climada.engine.uncertainty.input_var.InputVar or + climada.hazard.Hazard + Hazard uncertainty variable or Hazard of final state + + """ + + Calc.__init__(self) + self.exp_initial_input_var = InputVar.var_to_inputvar(exp_initial_input_var) + self.impf_initial_input_var = InputVar.var_to_inputvar(impf_initial_input_var) + self.haz_initial_input_var = InputVar.var_to_inputvar(haz_initial_input_var) + self.exp_final_input_var = InputVar.var_to_inputvar(exp_final_input_var) + self.impf_final_input_var = InputVar.var_to_inputvar(impf_final_input_var) + self.haz_final_input_var = InputVar.var_to_inputvar(haz_final_input_var) + + self.value_unit = self.exp_initial_input_var.evaluate().value_unit + self.check_distr() + + def uncertainty( + self, + unc_sample, + rp=None, + calc_eai_exp=False, + calc_at_event=False, + processes=1, + chunksize=None, + ): + """ + Computes the differential impact between the reference (initial) and + future (final) for each sample in unc_data.sample_df. + + By default, the aggregated average impact within a period of 1/frequency_unit + (impact.aai_agg) and the excess impact at return periods rp + (imppact.calc_freq_curve(self.rp).impact) is computed. + Optionally, eai_exp and at_event is computed (this may require + a larger amount of memory if the number of samples and/or the number + of centroids and/or exposures points is large). + For all metrics, the impacts are caculated first and the the difference + thereof is computed. + For example: + (impact_final.aai_agg - impact_inital.aai_agg / impact_inital.aai_agg) + + This sets the attributes self.rp, self.calc_eai_exp, + self.calc_at_event, self.metrics. + + This sets the attributes: + unc_output.aai_agg_unc_df, + unc_output.freq_curve_unc_df + unc_output.eai_exp_unc_df + unc_output.at_event_unc_df + unc_output.unit + + Parameters + ---------- + unc_sample : climada.engine.uncertainty.unc_output.UncOutput + Uncertainty data object with the input parameters samples + rp : list(int), optional + Return periods in years to be computed. + The default is [5, 10, 20, 50, 100, 250]. + calc_eai_exp : boolean, optional + Toggle computation of the impact at each centroid location. + The default is False. + calc_at_event : boolean, optional + Toggle computation of the impact for each event. + The default is False. + processes : int, optional + Number of CPUs to use for parralel computations. + The default is 1 (not parallel) + chunksize: int, optional + Size of the sample chunks for parallel processing. + Default is equal to the number of samples divided by the + number of processes. + + Returns + ------- + unc_output : climada.engine.uncertainty.unc_output.UncImpactOutput + Uncertainty data object with the delta impact outputs for each sample + and all the sample data copied over from unc_sample. + + Raises + ------ + ValueError: + If no sampling parameters defined, the distribution cannot + be computed. + + Notes + ----- + Parallelization logic is described in the base class + here :py:class:`~climada.engine.unsequa.calc_base.Calc` + + See Also + -------- + climada.engine.impact: + compute impact and risk. + + """ + + if unc_sample.samples_df.empty: + raise ValueError( + "No sample was found. Please create one first" + "using UncImpact.make_sample(N)" + ) + + # copy may not be needed, but is kept to prevent potential + # data corruption issues. The computational cost should be + # minimal as only a list of floats is copied.''' + samples_df = unc_sample.samples_df.copy(deep=True) + + if chunksize is None: + chunksize = _multiprocess_chunksize(samples_df, processes) + unit = self.value_unit + + if rp is None: + rp = [5, 10, 20, 50, 100, 250] + + self.rp = rp + self.calc_eai_exp = calc_eai_exp + self.calc_at_event = calc_at_event + + one_sample = samples_df.iloc[0:1] + start = time.time() + self._compute_imp_metrics(one_sample, chunksize=1, processes=1) + elapsed_time = time.time() - start + self.est_comp_time(unc_sample.n_samples, elapsed_time, processes) + + [ + aai_agg_list, + freq_curve_list, + eai_exp_list, + at_event_list, + ] = self._compute_imp_metrics( + samples_df, chunksize=chunksize, processes=processes + ) + + # Assign computed impact distribution data to self + aai_agg_unc_df = pd.DataFrame(aai_agg_list, columns=["aai_agg"]) + freq_curve_unc_df = pd.DataFrame( + freq_curve_list, columns=["rp" + str(n) for n in rp] + ) + eai_exp_unc_df = pd.DataFrame(eai_exp_list) + at_event_unc_df = pd.DataFrame(at_event_list) + + if calc_eai_exp: + exp = self.exp_input_var.evaluate() + coord_df = exp.gdf[["latitude", "longitude"]] + else: + coord_df = pd.DataFrame([]) + + return UncImpactOutput( + samples_df=samples_df, + unit=unit, + aai_agg_unc_df=aai_agg_unc_df, + freq_curve_unc_df=freq_curve_unc_df, + eai_exp_unc_df=eai_exp_unc_df, + at_event_unc_df=at_event_unc_df, + coord_df=coord_df, + ) + + def _compute_imp_metrics(self, samples_df, chunksize, processes): + """Compute the uncertainty metrics + + Parameters + ---------- + samples_df : pd.DataFrame + dataframe of input parameter samples + chunksize : int + size of the samples chunks + processes : int + number of processes to use + + Returns + ------- + list + values of impact metrics per sample + """ + # Compute impact distributions + with log_level(level="ERROR", name_prefix="climada"): + p_iterator = _sample_parallel_iterator( + samples=samples_df, + chunksize=chunksize, + exp_initial_input_var=self.exp_initial_input_var, + impf_initial_input_var=self.impf_initial_input_var, + haz_initial_input_var=self.haz_initial_input_var, + exp_final_input_var=self.exp_final_input_var, + impf_final_input_var=self.impf_final_input_var, + haz_final_input_var=self.haz_final_input_var, + rp=self.rp, + calc_eai_exp=self.calc_eai_exp, + calc_at_event=self.calc_at_event, + ) + if processes > 1: + with mp.Pool(processes=processes) as pool: + LOGGER.info("Using %s CPUs.", processes) + imp_metrics = pool.starmap(_map_impact_calc, p_iterator) + else: + imp_metrics = itertools.starmap(_map_impact_calc, p_iterator) + + # Perform the actual computation + with log_level(level="ERROR", name_prefix="climada"): + return _transpose_chunked_data(imp_metrics) + + +def _map_impact_calc( + sample_chunks, + exp_initial_input_var, + impf_initial_input_var, + haz_initial_input_var, + exp_final_input_var, + impf_final_input_var, + haz_final_input_var, + rp, + calc_eai_exp, + calc_at_event, +): + """ + Map to compute impact for all parameter samples in parallel + + Parameters + ---------- + sample_chunks : pd.DataFrame + Dataframe of the parameter samples + exp_input_var : InputVar or Exposures + Exposure uncertainty variable + impf_input_var : InputVar if ImpactFuncSet + Impact function set uncertainty variable + haz_input_var: InputVar or Hazard + Hazard uncertainty variable + rp : list(int) + List of the chosen return periods. + calc_eai_exp : bool + Compute eai_exp or not + calc_at_event : bool + Compute at_event or not + + Returns + ------- + : list + impact metrics list for all samples containing aai_agg, rp_curve, + eai_exp (np.array([]) if self.calc_eai_exp=False) and at_event + (np.array([]) if self.calc_at_event=False). + + """ + uncertainty_values = [] + for _, sample in sample_chunks.iterrows(): + exp_initial_samples = sample[exp_initial_input_var.labels].to_dict() + impf_initial_samples = sample[impf_initial_input_var.labels].to_dict() + haz_initial_samples = sample[haz_initial_input_var.labels].to_dict() + exp_final_samples = sample[exp_final_input_var.labels].to_dict() + impf_final_samples = sample[impf_final_input_var.labels].to_dict() + haz_final_samples = sample[haz_final_input_var.labels].to_dict() + + exp_initial = exp_initial_input_var.evaluate(**exp_initial_samples) + impf_initial = impf_initial_input_var.evaluate(**impf_initial_samples) + haz_initial = haz_initial_input_var.evaluate(**haz_initial_samples) + exp_final = exp_final_input_var.evaluate(**exp_final_samples) + impf_final = impf_final_input_var.evaluate(**impf_final_samples) + haz_final = haz_final_input_var.evaluate(**haz_final_samples) + + exp_initial.assign_centroids(haz_initial, overwrite=False) + exp_final.assign_centroids(haz_final, overwrite=False) + + imp_initial = ImpactCalc( + exposures=exp_initial, impfset=impf_initial, hazard=haz_initial + ).impact(assign_centroids=False, save_mat=False) + imp_final = ImpactCalc( + exposures=exp_final, impfset=impf_final, hazard=haz_final + ).impact(assign_centroids=False, save_mat=False) + + # Extract from climada.impact the chosen metrics + freq_curve_initial = imp_initial.calc_freq_curve(rp).impact + freq_curve_final = imp_final.calc_freq_curve(rp).impact + + if calc_eai_exp: + eai_exp_initial = imp_initial.eai_exp + eai_exp_final = imp_final.eai_exp + else: + eai_exp_initial = np.array([]) + eai_exp_final = np.array([]) + + if calc_at_event: + at_event_initial = imp_initial.at_event + at_event_final = imp_final.at_event + else: + at_event_initial = np.array([]) + at_event_final = np.array([]) + + delta_aai_agg = safe_divide( + imp_final.aai_agg - imp_initial.aai_agg, imp_initial.aai_agg + ) + + delta_freq_curve = safe_divide( + freq_curve_final - freq_curve_initial, freq_curve_initial + ) + + delta_eai_exp = ( + safe_divide(eai_exp_final - eai_exp_initial, eai_exp_initial) + if calc_eai_exp + else np.array([]) + ) + + delta_at_event = ( + safe_divide(at_event_final - at_event_initial, at_event_initial) + if calc_at_event + else np.array([]) + ) + + uncertainty_values.append( + [delta_aai_agg, delta_freq_curve, delta_eai_exp, delta_at_event] + ) + + return list(zip(*uncertainty_values)) diff --git a/climada/engine/unsequa/test/test_unsequa.py b/climada/engine/unsequa/test/test_unsequa.py index 56462d9d95..0a7c065b6e 100755 --- a/climada/engine/unsequa/test/test_unsequa.py +++ b/climada/engine/unsequa/test/test_unsequa.py @@ -34,7 +34,8 @@ from climada.entity.entity_def import Entity from climada.entity import Exposures from climada.hazard import Hazard -from climada.engine.unsequa import InputVar, CalcImpact, UncOutput, CalcCostBenefit +from climada.engine import ImpactCalc +from climada.engine.unsequa import InputVar, CalcImpact, UncOutput, CalcCostBenefit, CalcDeltaImpact from climada.util.constants import (EXP_DEMO_H5, HAZ_DEMO_H5, ENT_DEMO_TODAY, ENT_DEMO_FUTURE, TEST_UNC_OUTPUT_IMPACT, TEST_UNC_OUTPUT_COSTBEN) @@ -324,6 +325,90 @@ def test_save_load_pass(self): self.assertEqual(unc_data_load.sensitivity_kwargs, unc_data_save.sensitivity_kwargs) filename.unlink() +class TestCalcDelta(unittest.TestCase): + """Test the calcluate delta impact uncertainty class""" + + def test_calc_uncertainty_pass(self): + """Test compute the uncertainty distribution for an impact""" + + exp_unc, impf_unc, _ = make_input_vars() + haz = haz_dem() + haz2 = haz_dem() + haz2.intensity *=2 + unc_calc = CalcDeltaImpact(exp_unc, impf_dem(), haz, exp_dem(), impf_unc, haz2) + unc_data = unc_calc.make_sample(N=2) + unc_data = unc_calc.uncertainty(unc_data, calc_eai_exp=False, calc_at_event=False) + + for [x_exp, x_paa, x_mdd], delta_aai_aag in zip(unc_data.samples_df.values, unc_data.aai_agg_unc_df.values): + exp1 = exp_unc.evaluate(x_exp=x_exp) + exp2 = exp_dem() + impf1 = impf_dem() + impf2 = impf_unc.evaluate(x_paa=x_paa, x_mdd=x_mdd) + haz1 = haz + + imp1 = ImpactCalc(exp1, impf1, haz1).impact() + imp2 = ImpactCalc(exp2, impf2, haz2).impact() + + self.assertAlmostEqual((imp2.aai_agg - imp1.aai_agg)/imp1.aai_agg, delta_aai_aag) + + + self.assertEqual(unc_data.unit, exp_dem().value_unit) + self.assertListEqual(unc_calc.rp, [5, 10, 20, 50, 100, 250]) + self.assertEqual(unc_calc.calc_eai_exp, False) + self.assertEqual(unc_calc.calc_at_event, False) + + self.assertEqual( + unc_data.aai_agg_unc_df.size, + unc_data.n_samples + ) + self.assertEqual( + unc_data.freq_curve_unc_df.size, + unc_data.n_samples * len(unc_calc.rp) + ) + self.assertTrue(unc_data.eai_exp_unc_df.empty) + self.assertTrue(unc_data.at_event_unc_df.empty) + + def test_calc_sensitivity_pass(self): + """Test compute sensitivity default for CalcDeltaImpact input""" + + exp_unc, impf_unc, _ = make_input_vars() + haz = haz_dem() + haz2 = haz_dem() + haz2.intensity *= 2 + unc_calc = CalcDeltaImpact(exp_unc, impf_dem(), haz, exp_dem(), impf_unc, haz2) + unc_data = unc_calc.make_sample(N=4) + unc_data = unc_calc.uncertainty(unc_data, calc_eai_exp=False, calc_at_event=False) + + unc_data = unc_calc.sensitivity( + unc_data, + sensitivity_kwargs = {'calc_second_order': True} + ) + + self.assertEqual(unc_data.sensitivity_method, 'sobol') + self.assertTupleEqual(unc_data.sensitivity_kwargs, + tuple({'calc_second_order': 'True'}.items()) + ) + + for name, attr in unc_data.__dict__.items(): + if 'sens_df' in name: + if 'eai' in name: + self.assertTrue(attr.empty) + elif 'at_event' in name: + self.assertTrue(attr.empty) + else: + np.testing.assert_array_equal( + attr.param.unique(), + np.array(['x_exp', 'x_paa', 'x_mdd']) + ) + + np.testing.assert_array_equal( + attr.si.unique(), + np.array(['S1', 'S1_conf', 'ST', 'ST_conf', 'S2', 'S2_conf']) + ) + + self.assertEqual(len(attr), + len(unc_data.param_labels) * (4 + 3 + 3) + ) class TestCalcImpact(unittest.TestCase): """Test the calcluate impact uncertainty class""" @@ -677,5 +762,6 @@ def test_calc_uncertainty_pool_pass(self): TESTS = unittest.TestLoader().loadTestsFromTestCase(TestInputVar) TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestOutput)) TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestCalcImpact)) + TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestCalcDelta)) TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestCalcCostBenefit)) unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada/engine/unsequa/unc_output.py b/climada/engine/unsequa/unc_output.py index d80e0f5b0c..b83e43795c 100644 --- a/climada/engine/unsequa/unc_output.py +++ b/climada/engine/unsequa/unc_output.py @@ -19,7 +19,7 @@ Define Uncertainty class. """ -__all__ = ['UncOutput', 'UncCostBenefitOutput', 'UncImpactOutput'] +__all__ = ['UncOutput', 'UncCostBenefitOutput', 'UncImpactOutput', 'UncDeltaImpactOutput'] import logging import datetime as dt @@ -468,7 +468,7 @@ def plot_sample(self, figsize=None): return axes def plot_uncertainty(self, metric_list=None, orig_list=None, figsize=None, - log=False, axes=None): + log=False, axes=None, calc_delta=False): """ Plot the uncertainty distribution @@ -494,6 +494,8 @@ def plot_uncertainty(self, metric_list=None, orig_list=None, figsize=None, Use log10 scale for x axis. Default is False. axes : matplotlib.pyplot.axes, optional Axes handles to use for the plot. The default is None. + calc_delta: boolean, optional + Adapt x axis label for CalcDeltaImpact unc_output. Default is False. Raises ------ @@ -557,6 +559,21 @@ def plot_uncertainty(self, metric_list=None, orig_list=None, figsize=None, if ax is not None: ax.remove() continue + # Check if the column data is empty or contains only NaNs + data, m_unit = u_vtm(unc_df_plt[col]) + data = pd.Series(data) + if data.empty or data.isna().all() or data.dropna().shape[0] < 2: + print(f"No data to plot for '{col}'.") + if ax is not None: + ax.text(0.5, 0.5, 'No data to plot', fontsize=18, + horizontalalignment='center', verticalalignment='center', + transform=ax.transAxes) + ax.set_xlabel(col) + ax.set_ylabel('density of samples') + ax.tick_params(labelsize=fontsize) + for item in [ax.title, ax.xaxis.label, ax.yaxis.label]: + item.set_fontsize(fontsize) + continue data, m_unit = u_vtm(unc_df_plt[col]) data = pd.Series(data) if data.empty: @@ -592,6 +609,9 @@ def plot_uncertainty(self, metric_list=None, orig_list=None, figsize=None, [0.3 * ymax, 0.3 * ymax], color='black', label="std=%.2f%s" %(std, m_unit)) xlabel = col + ' [' + m_unit + ' ' + self.unit + '] ' + if calc_delta: + # Modify the xlabel when calc_delta is True + xlabel = col + ' change [%]' if log: ax.set_xlabel( xlabel + ' (log10 scale)') else: @@ -608,34 +628,36 @@ def plot_uncertainty(self, metric_list=None, orig_list=None, figsize=None, return axes - def plot_rp_uncertainty(self, orig_list=None, figsize=(16, 6), axes=None): + def plot_rp_uncertainty(self, orig_list=None, figsize=(16, 6), axes=None, + calc_delta=False): """ Plot the distribution of return period uncertainty - + Parameters ---------- orig_list : list[float], optional List of the original (without uncertainty) values for each - sub-metric of the mtrics in metric_list. The ordering is identical. + sub-metric of the metrics in metric_list. The ordering is identical. The default is None. figsize : tuple(int or float, int or float), optional The figsize argument of matplotlib.pyplot.subplots() - The default is (8, 6) + The default is (16, 6) axes: matplotlib.pyplot.axes, optional Axes handles to use for the plot. The default is None. - + calc_delta: boolean, optional + Adapt axis labels for CalcDeltaImpact unc_output. Default is False. + Raises ------ ValueError If no metric distribution was computed the plot cannot be made. - + Returns ------- - ax : matplotlib.pyplot.axes + axes : matplotlib.pyplot.axes The axis handle of the plot. - """ - + try: unc_df = self.freq_curve_unc_df except AttributeError: @@ -644,26 +666,29 @@ def plot_rp_uncertainty(self, orig_list=None, figsize=(16, 6), axes=None): raise ValueError("No return period uncertainty data present " "Please run an uncertainty analysis with the desired " "return period specified.") - + add_orig=True if orig_list is None: add_orig=False - - if axes is None: + + if axes is None: _fig, axes = plt.subplots(figsize=figsize, nrows=1, ncols=2) - + [min_l, max_l], m_unit = u_vtm([unc_df.min().min(), unc_df.max().max()], n_sig_dig=4) - + + # Plotting for the first axes ax = axes[0] - prop_cycle = plt.rcParams['axes.prop_cycle'] colors = prop_cycle.by_key()['color'] - + for n, (_name, values) in enumerate(unc_df.items()): + if values.isna().all() or len(values.dropna()) < 2: + print(f"Skipping plot for '{_name}': insufficient data.") + continue values = u_cmv(values, m_unit, n_sig_dig=4) count, division = np.histogram(values, bins=100) count = count / count.max() - losses = [(bin_i + bin_f )/2 for (bin_i, bin_f) in zip(division[:-1], division[1:])] + losses = [(bin_i + bin_f)/2 for (bin_i, bin_f) in zip(division[:-1], division[1:])] ax.plot([min_l, max_l], [2*n, 2*n], color='k', alpha=0.5) ax.fill_between(losses, count + 2*n, 2*n) if add_orig: @@ -672,39 +697,55 @@ def plot_rp_uncertainty(self, orig_list=None, figsize=(16, 6), axes=None): [orig_val, orig_val], [2*n, 2*(n+1)], color=colors[n], linestyle='dotted', linewidth=2, label="orig=%.2f%s" %(orig_val, m_unit) - ) - + ) + ax.set_xlim(min_l, max_l) ax.set_ylim(0, 2*unc_df.shape[1]) - ax.set_xlabel('Impact [%s %s]' %(m_unit, self.unit)) - ax.set_ylabel('Return period [years]') ax.set_yticks(np.arange(0, 2*unc_df.shape[1], 2)) ax.set_yticklabels([s[2:] for s in unc_df.columns]) ax.legend(loc='lower right') - + + # Set x-axis label for the first axes + if calc_delta: + ax.set_xlabel('Impact change [%]') + else: + ax.set_xlabel('Impact [%s %s]' % (m_unit, self.unit)) + + ax.set_ylabel('Return period [years]') + + # Plotting for the second axes ax = axes[1] - - high = u_cmv(self.get_unc_df('freq_curve').quantile(0.95).values, m_unit, n_sig_dig=4) - middle = u_cmv(self.get_unc_df('freq_curve').quantile(0.5).values, m_unit, n_sig_dig=4) - low = u_cmv(self.get_unc_df('freq_curve').quantile(0.05).values, m_unit, n_sig_dig=4) - + high = u_cmv(self.get_unc_df('freq_curve').quantile(0.95).values, + m_unit, n_sig_dig=4) + middle = u_cmv(self.get_unc_df('freq_curve').quantile(0.5).values, + m_unit, n_sig_dig=4) + low = u_cmv(self.get_unc_df('freq_curve').quantile(0.05).values, + m_unit, n_sig_dig=4) + x = [float(rp[2:]) for rp in unc_df.columns] - ax.plot(x, high, linestyle='--', color = 'blue', - alpha=0.5, label='0.95 percentile') + ax.plot(x, high, linestyle='--', color='blue', alpha=0.5, + label='0.95 percentile') ax.plot(x, middle, label='0.5 percentile') - ax.plot(x, low, linestyle='dashdot', color='blue', - alpha=0.5, label='0.05 percentile') + ax.plot(x, low, linestyle='dashdot', color='blue', alpha=0.5, + label='0.05 percentile') ax.fill_between(x, low, high, alpha=0.2) if add_orig: - ax.plot(x, u_cmv(orig_list, m_unit, n_sig_dig=4), - color='green', linestyle='dotted', label='orig') + ax.plot(x, u_cmv(orig_list, m_unit, n_sig_dig=4), color='green', + linestyle='dotted', label='orig') ax.set_xlabel('Return period [year]') - ax.set_ylabel('Impact [' + m_unit + ' ' + self.unit + ']') + + # Set y-axis label for the second axes + if calc_delta: + ax.set_ylabel('Impact change [%]') + else: + ax.set_ylabel('Impact [' + m_unit + ' ' + self.unit + ']') + ax.legend() - + return axes + def plot_sensitivity(self, salib_si='S1', salib_si_conf='S1_conf', metric_list=None, figsize=None, axes=None, **kwargs): @@ -1006,6 +1047,7 @@ def plot_sensitivity_map(self, salib_si='S1', **kwargs): return ax + def to_hdf5(self, filename=None): """ Save output to .hdf5 @@ -1099,10 +1141,11 @@ def from_hdf5(filename): class UncImpactOutput(UncOutput): - """Extension of UncOutput specific for CalcImpact, returned by the uncertainty() method. + """Extension of UncOutput specific for CalcImpact, returned by the + uncertainty() method. """ - def __init__(self, samples_df, unit, aai_agg_unc_df, freq_curve_unc_df, eai_exp_unc_df, - at_event_unc_df, coord_df): + def __init__(self, samples_df, unit, aai_agg_unc_df, freq_curve_unc_df, + eai_exp_unc_df, at_event_unc_df, coord_df): """Constructor Uncertainty output values from impact.calc for each sample @@ -1139,6 +1182,52 @@ def __init__(self, samples_df, unit, aai_agg_unc_df, freq_curve_unc_df, eai_exp_ self.at_event_sens_df = None self.coord_df = coord_df +class UncDeltaImpactOutput(UncOutput): + """Extension of UncOutput specific for CalcDeltaImpact, returned by the uncertainty() method. + """ + def __init__(self, samples_df, unit, aai_agg_unc_df, freq_curve_unc_df, eai_exp_unc_df, + at_event_initial_unc_df, at_event_final_unc_df, coord_df): + """Constructor + + Uncertainty output values from impact.calc for each sample + + Parameters + ---------- + samples_df : pandas.DataFrame + input parameters samples + unit : str + value unit + aai_agg_unc_df : pandas.DataFrame + Each row contains the value of aai_aag for one sample (row of + samples_df) + freq_curve_unc_df : pandas.DataFrame + Each row contains the values of the impact exceedence frequency + curve for one sample (row of samples_df) + eai_exp_unc_df : pandas.DataFrame + Each row contains the values of eai_exp for one sample (row of + samples_df) + at_event_initial_unc_df : pandas.DataFrame + Each row contains the values of at_event for one sample (row of + samples_df) + at_event_final_unc_df : pandas.DataFrame + Each row contains the values of at_event for one sample (row of + samples_df) + coord_df : pandas.DataFrame + Coordinates of the exposure + """ + super().__init__(samples_df, unit) + self.aai_agg_unc_df = aai_agg_unc_df + self.aai_agg_sens_df = None + self.freq_curve_unc_df = freq_curve_unc_df + self.freq_curve_sens_df = None + self.eai_exp_unc_df = eai_exp_unc_df + self.eai_exp_sens_df = None + self.at_event_initial_unc_df = at_event_initial_unc_df + self.at_event_initial_sens_df = None + self.at_event_final_unc_df = at_event_final_unc_df + self.at_event_final_sens_df = None + self.coord_df = coord_df + class UncCostBenefitOutput(UncOutput): """Extension of UncOutput specific for CalcCostBenefit, returned by the uncertainty() method. diff --git a/climada/util/test/test_value_representation.py b/climada/util/test/test_value_representation.py index 0f48b38c4a..61cf6a932b 100644 --- a/climada/util/test/test_value_representation.py +++ b/climada/util/test/test_value_representation.py @@ -21,7 +21,7 @@ from climada.util.value_representation import sig_dig, sig_dig_list, ABBREV -from climada.util.value_representation import value_to_monetary_unit +from climada.util.value_representation import value_to_monetary_unit, safe_divide import unittest import numpy as np import math @@ -134,8 +134,55 @@ def test_value_to_monetary_unit_list_nan_pass(self): self.assertTrue(np.array_equal(money[:-1], nbs_out[:-1])) self.assertEqual(name, name_out) +class TestSafeDivide(unittest.TestCase): + + def test_scalar_division(self): + self.assertEqual(safe_divide(10, 2), 5) + self.assertEqual(safe_divide(-10, 5), -2) + + def test_scalar_division_by_zero(self): + self.assertTrue(np.isnan(safe_divide(1, 0))) + self.assertEqual(safe_divide(1, 0, replace_with=0), 0) + + def test_array_division(self): + np.testing.assert_array_equal(safe_divide(np.array([10, 20, 30]), np.array([2, 5, 10])), np.array([5, 4, 3])) + + def test_array_division_by_zero(self): + np.testing.assert_array_equal(safe_divide(np.array([1, 0, 3]), np.array([0, 0, 1])), np.array([np.nan, np.nan, 3])) + np.testing.assert_array_equal(safe_divide(np.array([1, 0, 3]), np.array([0, 0, 1]), replace_with=0), np.array([0, 0, 3])) + + def test_list_division_by_zero(self): + list_num = [10, 0, 30] + list_denom = [2, 0, 10] + expected_result = [5.0, np.nan, 3.0] + np.testing.assert_array_almost_equal(safe_divide(list_num, list_denom), expected_result) + + def test_list_division(self): + list_num = [10, 20, 30] + list_denom = [2, 5, 10] + expected_result = [5.0, 4.0, 3.0] + np.testing.assert_array_almost_equal(safe_divide(list_num, list_denom), expected_result) + + def test_nan_handling(self): + self.assertTrue(np.isnan(safe_divide(np.nan, 1))) + self.assertTrue(np.isnan(safe_divide(1, np.nan))) + self.assertEqual(safe_divide(np.nan, 1, replace_with=0), 0) + self.assertEqual(safe_divide(1, np.nan, replace_with=0), 0) + + def test_nan_handling_in_arrays(self): + np.testing.assert_array_equal( + safe_divide(np.array([1, np.nan, 3]), np.array([3, 2, 0])), + np.array([1/3, np.nan, np.nan]) + ) + + def test_nan_handling_in_scalars(self): + self.assertTrue(np.isnan(safe_divide(np.nan, 1))) + self.assertTrue(np.isnan(safe_divide(1, np.nan))) + self.assertEqual(safe_divide(np.nan, 1, replace_with=0), 0) + self.assertEqual(safe_divide(1, np.nan, replace_with=0), 0) # Execute Tests if __name__ == "__main__": TESTS = unittest.TestLoader().loadTestsFromTestCase(TestDigits) + TESTS.addTests(unittest.TestLoader().loadTestsFromTestCase(TestSafeDivide)) unittest.TextTestRunner(verbosity=2).run(TESTS) diff --git a/climada/util/value_representation.py b/climada/util/value_representation.py index 35da3cdb76..9af0d258ea 100755 --- a/climada/util/value_representation.py +++ b/climada/util/value_representation.py @@ -29,16 +29,10 @@ LOGGER = logging.getLogger(__name__) -ABBREV = { - 1:'', - 1000: 'K', - 1000000: 'M', - 1000000000: 'Bn', - 1000000000000: 'Tn' - } +ABBREV = {1: "", 1000: "K", 1000000: "M", 1000000000: "Bn", 1000000000000: "Tn"} -def sig_dig(x, n_sig_dig = 16): +def sig_dig(x, n_sig_dig=16): """ Rounds x to n_sig_dig number of significant digits. 0, inf, Nan are returned unchanged. @@ -66,8 +60,9 @@ def sig_dig(x, n_sig_dig = 16): if n_sig_dig >= num_of_digits: return x n = math.floor(math.log10(abs(x)) + 1 - n_sig_dig) - result = decimal.Decimal(str(np.round(x * 10**(-n)))) \ - * decimal.Decimal(str(10**n)) + result = decimal.Decimal(str(np.round(x * 10 ** (-n)))) * decimal.Decimal( + str(10**n) + ) return float(result) @@ -92,8 +87,8 @@ def sig_dig_list(iterable, n_sig_dig=16): """ return np.vectorize(sig_dig)(iterable, n_sig_dig) -def convert_monetary_value(values, abbrev, n_sig_dig=None): +def convert_monetary_value(values, abbrev, n_sig_dig=None): if isinstance(values, (int, float)): values = [values] @@ -150,27 +145,30 @@ def value_to_monetary_unit(values, n_sig_dig=None, abbreviations=None): values = [values] if abbreviations is None: - abbreviations= ABBREV + abbreviations = ABBREV exponents = [] for val in values: if math.isclose(val, 0) or not math.isfinite(val): continue exponents.append(math.log10(abs(val))) - if not exponents: exponents = [0] + if not exponents: + exponents = [0] max_exp = max(exponents) min_exp = min(exponents) avg_exp = math.floor((max_exp + min_exp) / 2) # rounded down - mil_exp = 3 * math.floor(avg_exp/3) + mil_exp = 3 * math.floor(avg_exp / 3) - thsder = int(10**mil_exp) #Remove negative exponents + thsder = int(10**mil_exp) # Remove negative exponents thsder = 1 if thsder < 1 else thsder try: name = abbreviations[thsder] except KeyError: - LOGGER.warning("Warning: The numbers are larger than %s", list(abbreviations.keys())[-1]) + LOGGER.warning( + "Warning: The numbers are larger than %s", list(abbreviations.keys())[-1] + ) thsder, name = list(abbreviations.items())[-1] mon_val = np.array(values) / thsder @@ -179,3 +177,69 @@ def value_to_monetary_unit(values, n_sig_dig=None, abbreviations=None): mon_val = [sig_dig(val, n_sig_dig=n_sig_dig) for val in mon_val] return (mon_val, name) + + +def safe_divide(numerator, denominator, replace_with=np.nan): + """ + Safely divide two arrays or scalars. + + This function handles division by zero and NaN values in the numerator or + denominator on an element-wise basis. If the division results in infinity, NaN, or + division by zero in any element, that particular result is replaced by the specified + value. + + Parameters + ---------- + numerator : np.ndarray or scalar + The numerator for division. + denominator : np.ndarray or scalar + The denominator for division. Division by zero and NaN values are handled + safely. + replace_with : float, optional + The value to use in place of division results that are infinity, NaN, or + division by zero. By default, it is NaN. + + Returns + ------- + np.ndarray or scalar + The result of the division. If the division results in infinity, NaN, or + division by zero in any element, it returns the value specified in + ``replace_with`` for those elements. + + Notes + ----- + The function uses numpy's ``true_divide`` for array-like inputs and handles both + scalar and array-like inputs for the numerator and denominator. NaN values or + division by zero in any element of the input will result in the `replace_with` value + in the corresponding element of the output. + + Examples + -------- + >>> safe_divide(1, 0) + nan + + >>> safe_divide(1, 0, replace_with=0) + 0 + + >>> safe_divide([1, 0, 3], [0, 0, 3]) + array([nan, nan, 1.]) + + >>> safe_divide([4, 4], [1, 0]) + array([4., nan]) + + >>> safe_divide([4, 4], [1, nan]) + array([ 4., nan]) + """ + + with np.errstate(divide="ignore", invalid="ignore"): + result = np.true_divide(numerator, denominator) + + # Check if the result is a scalar + if np.isscalar(result): + if not np.isfinite(result): + return replace_with + else: + # Replace infinities, NaNs, and division by zeros in np.ndarray + result[~np.isfinite(result)] = replace_with + + return result diff --git a/doc/climada/climada.engine.unsequa.rst b/doc/climada/climada.engine.unsequa.rst index 99b7389bd4..8f39c59acd 100644 --- a/doc/climada/climada.engine.unsequa.rst +++ b/doc/climada/climada.engine.unsequa.rst @@ -41,3 +41,10 @@ climada\.engine\.unsequa\.unc\_output module :undoc-members: :show-inheritance: +climada\.engine\.unsequa\.calc\_delta\_climate module +----------------------------------------------------- + +.. automodule:: climada.engine.unsequa.calc_delta_climate + :members: + :undoc-members: + :show-inheritance: diff --git a/doc/tutorial/climada_engine_unsequa.ipynb b/doc/tutorial/climada_engine_unsequa.ipynb index b5db54953c..67f658a007 100644 --- a/doc/tutorial/climada_engine_unsequa.ipynb +++ b/doc/tutorial/climada_engine_unsequa.ipynb @@ -4,7 +4,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Unsequa - a module for uncertainty and sensitivity analysis" + "\n", + "# Unsequa - a module for uncertainty and sensitivity analysis\n" ] }, { @@ -16,19 +17,39 @@ }, { "cell_type": "markdown", - "metadata": { - "toc": true - }, + "metadata": {}, "source": [ - "

Table of Contents

\n", - "
" + "# Table of Contents\n", + "- [Unsequa - a module for uncertainty and sensitivity analysis](#unsequa-a-module-for-uncertainty-and-sensitivity-analysis)\n", + " - [Uncertainty and sensitivity analysis](#uncertainty-and-sensitivity-analysis)\n", + " - [Unsequa Module Structure](#unsequa-module-structure)\n", + " - [InputVar](#inputvar)\n", + " - [Example - custom continuous uncertainty parameter](#example-custom-continuous-uncertainty-parameter)\n", + " - [Example - custom categorical uncertainty parameter](#example-custom-categorical-uncertainty-parameter)\n", + " - [UncOutput](#uncoutput)\n", + " - [Example from file](#example-from-file)\n", + " - [CalcImpact](#calcimpact)\n", + " - [Set the InputVars](#set-the-inputvars)\n", + " - [Compute uncertainty and sensitivity using default methods](#compute-uncertainty-and-sensitivity-using-default-methods)\n", + " - [A few non-default parameters](#a-few-non-default-parameters)\n", + " - [CalcDeltaImpact](#calcdeltaimpact)\n", + " - [Set the Input Vars](#set-the-input-vars)\n", + " - [Compute uncertainty and sensitivity](#compute-uncertainty-and-sensitivity)\n", + " - [CalcCostBenefit](#calccostbenefit)\n", + " - [Set the Input Vars](#set-the-input-vars)\n", + " - [Compute cost benefit uncertainty and sensitivity using default methods](#compute-cost-benefit-uncertainty-and-sensitivity-using-default-methods)\n", + " - [Advanced examples](#advanced-examples)\n", + " - [Coupled variables](#coupled-variables)\n", + " - [Many scenarios of hazards and exposures](#many-scenarios-of-hazards-and-exposures)\n", + " - [Input variable: Repeated loading of files made efficient](#input-variable-repeated-loading-of-files-made-efficient)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Uncertainty and sensitivity analysis" + "\n", + "## Uncertainty and sensitivity analysis\n" ] }, { @@ -70,7 +91,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Unsequa Module Structure" + "\n", + "## Unsequa Module Structure\n" ] }, { @@ -84,6 +106,7 @@ "\n", "The input parameter sampling, Monte-Carlo uncertainty distribution calculation and the sensitivity index computation are done in\n", "- `CalcImpact`: compute uncertainties for outputs of `climada.engine.impact.calc` (child class of `Calc`)\n", + "- `CalcDeltaImpact`: compute uncertainties for outputs of `climada.engine.impact.calc` (child class of `Calc`)\n", "- `CalcCostBenefit`: compute uncertainties for outputs of `climada.engine.cost_benefit.calc` (child class of `Calc`)\n", "\n", "The results are stored in\n", @@ -96,7 +119,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## InputVar " + "\n", + "## InputVar\n" ] }, { @@ -136,7 +160,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Example - custom continuous uncertainty parameter" + "\n", + "### Example - custom continuous uncertainty parameter\n" ] }, { @@ -155,15 +180,7 @@ "start_time": "2023-08-03T11:57:41.913838Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-03 13:57:46,512 - climada.entity.exposures.base - INFO - Reading /Users/ckropf/climada/demo/data/exp_demo_today.h5\n" - ] - } - ], + "outputs": [], "source": [ "import warnings\n", "warnings.filterwarnings('ignore') #Ignore warnings for making the tutorial's pdf. \n", @@ -277,7 +294,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -297,7 +314,8 @@ "heading_collapsed": true }, "source": [ - "### Example - custom categorical uncertainty parameter " + "\n", + "### Example - custom categorical uncertainty parameter\n" ] }, { @@ -336,7 +354,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2023-08-03T11:57:57.533389Z", @@ -421,16 +439,9 @@ "hidden": true }, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-03 13:57:57,563 - climada.util.coordinates - INFO - Raster from resolution 0.04166666000000063 to 0.04166666000000063.\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -456,7 +467,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -475,7 +486,8 @@ "heading_collapsed": true }, "source": [ - "## UncOutput " + "\n", + "## UncOutput\n" ] }, { @@ -566,7 +578,8 @@ "hidden": true }, "source": [ - "### Example from file " + "\n", + "### Example from file\n" ] }, { @@ -609,15 +622,7 @@ }, "hidden": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-03 13:58:02,377 - climada.engine.unsequa.unc_output - INFO - Reading /Users/ckropf/climada/data/unc_output/unc_output_impact/test_unc_output_impact/v1/test_unc_output_impact.hdf5\n" - ] - } - ], + "outputs": [], "source": [ "# If you produced your own data, you do not need the API. Just replace 'filename' with the path to your file.\n", "from climada.engine.unsequa import UncOutput\n", @@ -637,9 +642,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKYAAAHqCAYAAAA+vEZWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAADBcElEQVR4nOzdd3iU1db38e+kkN4oISF0kF6kKQgoiHRRFEEEFGkiKh4QLCAgReUogl2QIgKCCOrhcKRXIYAIAamhk0IgIQmQNumZ9488mZeQQjJJGAi/z3XNNZN777X3ugfwPFnP3vs2mEwmEyIiIiIiIiIiIneYjbUTEBERERERERGR+5MKUyIiIiIiIiIiYhUqTImIiIiIiIiIiFWoMCUiIiIiIiIiIlahwpSIiIiIiIiIiFiFClMiIiIiIiIiImIVKkyJiIiIiIiIiIhVqDAlIiIiIiIiIiJWYWftBOTulpGRweXLl3Fzc8NgMFg7HRERERERERG5y5lMJuLi4qhUqRI2NvmviVJhSvJ1+fJlqlSpYu00REREREREROQeExoaSuXKlfPto8KU5MvNzQ3I/Mvk7u5u5WxESrkf6kHCFXDxhaGnrJ2NiIiIiIiIRWJjY6lSpYq5ppAfFaYkX1nb99zd3VWYEilpTjaQ/n/v+vcmIiIiIiL3uIIcCaTDz0VERERERERExCpUmBIREREREREREatQYUpERERERERERKxChSkREREREREREbEKFaZERERERERERMQqVJgSERERERERERGrsLN2AiIi8n9GXrJ2BiIiIiIiIneUClMiIiIiIiJSrNLS0khLS7N2GiJSRDY2Ntjb22MwGEpsDhWmREREREREpFgYjUaioqJISEiwdioiUkzs7e1xc3OjfPny2NraFvv4KkyJiIiIiIhIkaWkpBAaGoq9vT2+vr44ODiU6CoLESlZJpOJ9PR04uPjuXHjBomJiVSpUqXYi1MqTImI3C32ToOUGCjjAY98YO1sRERERArl6tWr2NraUq1atRJZVSEi1uHq6oqHhwchISFERUVRsWLFYh1fT+UTEblbHFsAAZ9nvouIiIjcQ0wmE0ajEQ8PDxWlREohJycn3N3diYuLw2QyFevYKkyJiIiIiIhIkaSmppKeno6Tk5O1UxGREuLm5kZqaiqpqanFOu49V5iKi4tj6tSpNG7c2LycrFWrVsyePZuUlJQijR0REcG4ceOoW7cuTk5OlC1blvbt27Nw4cICVQTPnz/PyJEjqVGjBo6Ojnh7e9O1a1d+++23As1/6NAhBg0aROXKlXFwcMDX15dnnnmG7du3F/perl+/TqVKlTAYDBgMBqZOnVroMURERERERAoiIyMDQKulREqxrH/fWf/ei8s9dcZUcHAwHTp0ICgoCABnZ2eSk5M5ePAgBw8eZPny5Wzbtg0vL69Cjx0QEEDXrl2Jjo4GMvdQxsXF4e/vj7+/P6tXr2bt2rU4ODjkGr9+/Xr69u2L0WgEwN3dnejoaDZv3szmzZsZMmQIixYtyvPwv4ULFzJq1CjzI1U9PDyIiIhgzZo1rFmzhg8++KBQxaWxY8dy5cqVQnwDIiIiIiIiRaPDzkVKr5L6933PFKbS09Pp1asXQUFB+Pr6snTpUp544gkyMjJYvXo1I0aM4PDhwwwcOJD169cXauyYmBiefPJJoqOjqVevHsuWLaNly5akpKSwYMECxo4dy+bNmxk7dizfffddjviLFy/Sr18/jEYjbdu25YcffqBOnTrEx8cza9Yspk+fzuLFi6lXrx7vvPNOjvh9+/bx6quvkp6eTu/evfn666+pXLky0dHRvP/++3z//fdMmzaNBg0a0K9fv9vez6ZNm1iyZAlt2rRh3759hfou8vLPP//g6upaLGNZqnz58lStWtWqOYiIiIiIiIhI8TGYivvUqhKyaNEihg8fDsDevXtp06ZNtvaff/6ZAQMGALB161Y6depU4LEnT57Mhx9+iJOTEydOnKBGjRrZ2mfOnMnEiROxtbXl5MmT1KlTJ1v7iy++yE8//YSPjw+BgYF4enpmax85ciTz58/H3d2doKCgHCu62rdvj7+/P40bNyYgIAB7e/ts7d26dWPTpk1Uq1aN8+fP57s8Ni4ujkaNGhEeHs6hQ4do1KgRQKFXXGWJjY3Fw8Oj0HElwdnZmcDAQBWnpPT6vjLEh4GrH4y8ZO1sRERERAosKSmJixcvmo81EZHSpzD/zrNqCTExMbi7u+fb955ZMbVkyRIAOnbsmKMoBdC/f3/ef/99Ll68yNKlSwtVmFq6dKl5jFuLUgCjR4/m448/Jj4+nuXLlzNt2jRzW0JCgvkMqVGjRuUoSgFMmDCB+fPnExsby5o1axgyZIi57cKFC/j7+wMwfvz4HEWprPhNmzYRHBzMrl276NixY5738u677xISEsKUKVNo2LBhwb6AAnjt3Y+pVadRsY1XWJeCz/H59LeIiopSYUpERERERESklLgnDj83Go3s2bMHgO7du+fax2Aw0K1bNwA2b95c4LFPnz5NSEhIvmO7urrSvn37XMf29/cnMTEx3/jq1atTv379XOO3bNli/pyV/63atWuHm5tbrvE3+/PPP5k3bx716tVj4sSJefazhF+VmtSq28hqr8rVahfr/YiIiIiIiMidExkZSdmyZTEYDNjZFXyNTFJSEg888ID5wV6XLuW9s+Dw4cO88MILVKpUCQcHB/z8/HjppZc4ffp0rv137txpHvd2r+Dg4ELdb3h4OGPHjuWBBx7A0dGR8uXLm3dD5WXq1Km3zePUqVM54l5++WVze4sWLfLN6+jRo9nG27lzZ6HuqyTcEyumAgMDzae+Z21Ny01WW3h4ONeuXaNs2bK3Hfv48eM54vMae8OGDZw8eTLP+PxWKDVq1IjAwEBOnDiRa7y3tzfe3t65xtra2lKvXj0OHDiQIz5LYmKieavj/Pnz8zykXUREREREROROGzt2LNevXy903Icffsi5c+du22/58uUMGTKE1NRUypYtS9OmTQkJCWHZsmX89ttv/PHHHzl2H3l4eNC2bds8xwwKCiIsLAw/Pz+qVKlS4JyPHTtG586diYiIwMHBgUaNGhETE8OmTZvYtGkTM2fO5L333sszvkqVKnnuFHJ2ds537kOHDnHy5EkaNGiQa/uyZcsKfB93yj2xYury5cvmz35+fnn2u7nt5pjiHDs2Npb4+Pgc8V5eXvn+BcmKvzWvrJ/zmzu/+CyTJk3i3LlzvPLKK+bVXZZITk4mNjY220tE7pDKj0G1LpnvIiIiIiKlxNatW1m+fDlPPfVUoeICAwOZNWvWbePOnj3LsGHDSE1NZezYsYSHh/P3339z5coVPvvsM4xGI3379uXGjRvZ4po1a4a/v3+er+rVqwMwcOBAbGwKVj5JS0vjueeeIyIigg4dOhAaGsrBgwc5e/Ys27Ztw83NjYkTJ7Jr1648xxg6dGieOeV3tE3dunWBvItPGRkZrFixAjc3NypVqlSg+7kT7onCVFxcnPlzfsWfm9tujinJsbM+365qmdV+a15FjQfYv38/X3zxBb6+vnzyySf5jnM7M2fOxMPDw/wqTFVYRIqo53J4blPmu4iIiIhIKZCUlMSoUaPw8fFh+vTpBY4zmUyMHDkSW1tbvvzyy3z7fvfddyQnJ9OwYUNmzZplPrvZYDAwbtw4unXrRnR0NF9//XWB579w4YL5SKEXX3yxwHHr1q3jzJkzODg48OOPP1KhQgVz2+OPP87777+PyWTKdnZ1cXnmmWdwcXFhxYoV5Pacu+3bt3P58mX69OmDk5NTsc9vqXuiMCV5S0lJYejQoWRkZPD1118X+Ql6EyZMICYmxvwKDQ0tpkxFRERERETub8ePH+eDDz6gTZs2+Pr6UqZMGXx9fXn22WfZu3dvtr7jx4/HYDDwxhtv5DuewWDA29ubtLS0bG3btm3j8ccfx93dHU9PTzp16sT27dsJCgrCYDCYVwOVtKyteLNnzy7U76uLFi1i9+7dTJo06ba5ZhWQnnnmmVyfYt+nTx8AVq1aVeD5f/rpJwAefPDBfI/9ySuXVq1aUa1atTxz2blzJ1evXi3wuAXh4uJC7969CQkJ4c8//8zRnrWSatCgQcU6b1HdE4WprIO/IfMg9Lzc3HZzTEmOnfU5v9ib22/Nq6jx06dP5+TJkzz99NPmv+BF4eDggLu7e7aXiIiIiIiIFN2YMWOYPn06p06dwsvLi8aNG5OWlsZ//vMfHn30UVasWGHuO2DAAABWr15Nenp6ruNl9e/bt2+2A8WXLl1K586d2bFjBw4ODtSpU4cjR47QuXNnfv311xK8w+yytuJ17NjRfD8FERkZybvvvkvdunUZP378bftnnV2V1xE5WdePHz+e7Wie/CxfnrmLoTCrpQqTS0ZGBgcOHMi1z44dO+jbty+PP/44zz33HJ9++inh4eEFmj8r36zCWhaj0ch//vMf/Pz8cpy1ZW33xOHnN+99DAsLo0mTJrn2CwsLyzWmMGPnVYjJGtvd3R1XV9cc8devX8doNOa5JS8r/ta8sn6+OfeCxp87d45PPvkEFxcXPvnkk3z/gaWkpJjbb85fRERERERE7oxXX32Vzz//nMaNG5uvmUwm1q5dy6BBgxg1ahS9evXCzc2N5s2bU69ePU6dOsW2bdvo0qVLjvFWrlwJkK3oExISwqhRozCZTEyaNImpU6dia2tLWloakydPzvcJ7qNHj+bw4cOFvq9ff/0VHx+fbNeytuKZTCa+/fbbQo03duxYrl27xqpVqyhTpsxt+2etxMrr9+qbr585c4bmzZvnO97+/fs5c+YMtra2hSqoFTaX06dP07Nnzxx9bj1/6rfffmPq1Kl89913vPzyy/nO/8QTT+Dj48Ovv/7KN998g6OjIwBr1qwhLi6OUaNGFfi8rDvl7somD/Xr1zd/cTc/Be9WWW0+Pj4FeiIfZH8SX0HGvvVk+5vj83pi3s3xtz65Lyv+6tWrREZG5hqbnp5ufiTkzfGXLl0iLS2NhIQE6tWrh5ubW45XlpkzZ5qv3Xrgm4jcJVY9Dj82zHwXERERkVLnueeey1aUgsxzkJ5++mnGjBlDbGws//vf/8xtL7zwAgA///xzjrH++usvLl68SLVq1XjkkUfM1+fOnYvRaOSJJ55gxowZ5q1tdnZ2zJw5M1vfWx07dow9e/YU+pWUlJRjrKyteOPGjaN+/foF/o62bdvG8uXL6d+/P506dSpQTKtWrYDM4ktGRkaO9t9//938uSBPBsza8pZV5CmMrFwOHjyY69E4+eXi6+vLxIkTOXDgANHR0RiNRvbs2UP37t1JTExk6NCh2f5+5MbW1pYXXniBmJgY1q5dm+Oe7rZtfHCPFKacnZ3Nj3DcuHFjrn1MJhObNm0CyLWSnJe6deuaT7XPa+yEhAR2796d69jt2rUzHxqWV3xwcDCBgYG5xnfu3Nn8Oa/4PXv2mA89L8y9icg95voZiD6Z+S4iIiJS2hycA99Xvv3rP7k8ge0/TxUs9uCc7HEpcQWL+74yRARkjz3/R87xikFISAj//ve/6devH48//jjt2rWjXbt2/PLLLwAcOXLE3Ddrtc5//vMfkpOTs42TVazq378/BoPBfH3Lli0ADBkyJNf587oOmecemUymQr9uPQMqayte1apVmTx5cgG/mcyD0l999VXc3NyYM6fg3/3IkSOxsbHh+PHjvPHGG6SkpACZdYKPPvqIDRs2mPsmJibmO1Zqaqr5z6Kw2/gAnn76aSpVqkRSUhIDBgzgypUr5rZ169bx0Ucf5ZnLyJEj+eijj2jZsiVly5bFycmJRx55hHXr1vHMM89gMpkYO3Zsrgeb3+zW7XwRERFs3bqVpk2b5iiM3g3uicIUwODBg4HMvZb79+/P0b569WouXLgAwEsvvVSosbP6r1y5kqCgoBzt3377LfHx8dja2jJw4MBsbS4uLuaznebOnUtMTEyO+Kwn5bm5udG7d+9sbTVr1qRdu3YAzJ49m9TU1Bzx//73vwGoVq0ajz76qPl6hw4dbvsfiCwffPCB+Zqnp+dtvhEREREREZFilhIL8WG3fyXmspMkMbJgsSmx2eNMpoLFxYdBekr22LTEnOMV0ZIlS6hbty4TJkxg9erV7Nixw7zq6OzZswBcu3bN3L927dq0atWKmJgY1q9fb76ekZFhPsg7a1VVlqxx8joCJ6/rxSlrK96XX3552yfQ3yzroPTp06fj6+tb4LgHH3yQ2bNnYzAYmDt3LmXLluXBBx/Ey8uLSZMm0b17d8qXLw/c/mibjRs3EhUVhaurK88880yBc8ji6OjIL7/8gpubG/7+/lStWpVGjRrh5+fHk08+iaenp/n3+oIes2MwGMx1gfPnz3P06NF8+zdr1oyGDRua7+Xnn38mLS3trlwtBfdYYapx48aYTCb69OnDtm3bgMx/kKtXr2bEiBEAdO/ePcdyv6lTp2IwGDAYDLkWnsaPH4+Pjw9Go5GePXsSEJBZKU9JSWHu3LnmCu8rr7xCnTp1csRPnz4dFxcXrly5Qq9evcz/IUhISGD69OnMmzcPgEmTJuHl5ZUj/tNPP8XW1pYjR47Qv39/857Ta9eu8dprr5mru1n9RERERERE7jll3MHV7/Yvpwo5Y50qFCy2zC1nBhsMBYtz9QPbW84ysnPKOV4RnD9/nhEjRpCUlMS4ceM4fPgwsbGxZGRkYDKZWLBgAUCOxQpZq6Zu3s63Y8cOwsPDadCgAU2bNs3WPyEhAcj7gWAFfVCYpf7880+WL19Oz549cyzMyM/Zs2eZNWsWTZs2ZfTo0YWed8yYMWzbto0nn3wSR0dHAgMD8fHxYebMmaxatcpc8Lvd1rysLW99+vQpVFHtZu3atePQoUMMHToUHx8fzpzJ3BHx6quvcvDgQfNh9oXZJlinTh3zkUXnzp27bf9BgwaZV3/99NNP2NjYFPq8rDvlnjj8HDL3w65du5aOHTsSFBTEE088gbOzMxkZGeb9rM2aNTOfnF8YHh4e/PHHH3Tt2pWTJ0/SsmVL3NzcSEpKMv9HoUuXLnz++ee5xteoUYNVq1bRt29fdu/eTZ06dfDw8CA+Pt78F+7ll1/m7bffzjW+TZs2zJs3j1GjRvH777/z+++/4+npSUxMjHnV0wcffEC/fv0KfW8iIiIiIiJ3hZZvZb4s8cza2/fJTRk3GHnJsthaT1oWl4dVq1aRmppK//79+eyzz3K053YeEcDzzz/PuHHj+OOPP4iLi8PNzc1cpLp1tRRk7uqJjY3N8+FYWcfE5KY4Dj/Pivf3989ReMn6/Tg9Pd3c9uWXX/L8889z4sQJUlJSOH/+fJ5PtANo3rw5NjY2jB8/PscT+zp27JjrE+f++usvMjIycHV1zXWxSZaYmBjzGU6WbOO7We3atVm0aFGO62lpaebtmi1atCjUmPb29uYxbmfgwIFMnDiRTz/9lJCQEDp37lzgh8TdafdMYQqgevXqHD16lM8++4zff/+dixcvYm9vT8OGDXnhhRcYPXp0gU7sz02LFi04ceIEn3zyCX/88QehoaG4uLjQqFEjBg8ezNChQ/M9ub5Hjx4cPXqUTz75hC1btnD58mU8PT1p3rw5I0eONG/3y8vw4cNp3rw5s2fP5s8//yQyMhJvb2/atGnD6NGjefxxHYYsIiIiIiJyr8ravZPX4eM3ny11M19fXzp06MD27dtZs2YNzz//vPkA7dwKU3Xq1OHgwYMcPXo0x8O3IPOA87xkHX5eWLkdfh4TE5PrUTdZIiIigJznLMXHx+f7xPmsh4bl1+dWv/32G5D5e3t+v9f/+uuvJCUl4efnl2uBqzhs2rSJ+Ph4KlWqdNunA94sKiqKq1evAlC5cuXb9q9SpQqPPfYYO3fuBO7OQ8+z3FOFKchcdjht2jSmTZtW4JipU6cyderU2/arWLEic+bMKdQhazerVasW8+fPtygWMiu/lqz4ys/tDkUTERERERGRkpf10KysgszNTp06le/T1gYMGMD27dv5+eefcXd35/r16zz00EPUqlUrR9/OnTtz8OBBfvzxx1wLVz/++GOe82QVMYpizJgxjBkzJte2oKAgatSoga2tbY5VP717987399esA95DQ0MLVJjJEhwczNy5cwF444038u2btY1v4MCB+RawLJWSksKUKVMAGDVqVKGO6pkzZw4mkwkPDw/zk/9u580338TW1hZbW1ueffZZi3K+E+6ZM6ZERERERERE7lVZD7367rvv+Oeff8zXz5w5Q9++ffPd/dOnTx8cHBzYsmUL33zzDUCe5wW9+uqrODs7s3nzZqZOnWrePpeWlsakSZPw9/cvpju6uyxevDjHmdL79u2jc+fOJCQkMGzYMNq3b59nfEhICLt27QIKto1v/PjxVK9ePcd2QoD169fneGhbaGgovXv35tChQzRo0CDHUT8nTpzgtdde48SJE9muJyUl8fHHH5sfqvbuu+8WeKfYM888w9atW9m0aVOBD1q3BhWmREREREREREpY7969ad26NdevX6dly5Y0aNCAxo0bU69ePaKjo5k0aVKesZ6ennTv3p20tDS2bt2KjY1NnmcQV61ale+++w6DwcC0adPw9fXloYcewtfXl5kzZ/LRRx8BlLoHa3355ZfUqFGDSpUq0apVK6pVq8YjjzzC2bNnee6558yrpvKyfPlyTCYTDz74II0aNbrtfFFRUQQHBxMVFZWjbfPmzbRu3ZqyZcvSvHlzGjRoQLVq1diwYQMNGjRg8+bNODg4ZItJTU1l7ty5NGrUCG9vb1q2bEnLli0pV64c77//PhkZGQwbNoz33nuvcF/MPUCFKREREREREZESZmdnx6ZNmxg9ejQVK1bk3Llz3Lhxg2HDhhEQEJDvgd+QfYVUx44d8fX1zbPv4MGD2bx5Mx06dCAxMZFTp07RsGFDNm7cSI8ePYCSfzrfnfbGG2/QuXNnAI4ePUpiYiLdunXj119/ZfXq1eaDw/Py008/AUU/9Bwyi5D9+vXDw8ODwMBALl++TKtWrZg9ezaHDh3K9c+6evXqzJgxg+7du+Pq6srp06c5duwYZcuW5bnnnmPjxo0sXLjQvKWxNDGYdAiR5CM2NhYPDw8++mYlDR98yGp5nD99nHHDniIgIKBQB8SJ3FOOzoeUeCjjCk1esXY2IiIiIgWWlJTExYsXqVGjBo6OjtZOR/Lx22+/8dxzz/H000+zZs0aa6cj95DC/DvPqiXExMTg7u6eb9977vBzEZFSS8UoERERESlhixcvBqBt27ZWzkQkk7byiYiIiIiIiJQiv/32G+vXrzcffA5gNBp55513WLduHS4uLsWyZU2kOGjFlIiIiIiIiEgpcuzYMaZNm4ajoyO1atXCwcGBwMBAEhMTsbW15fvvv8fHx8faaYoAKkyJiNw94q+AKR0MtuCa92GWIiIiIiL5efrpp7l06RK7du0iNDSUxMREKlSowFNPPcW4ceNo1aqVtVMUMVNhSkTkbrG8FcSHgasfjLxk7WxERERE5B7VrFkzFi5caO00RApEZ0yJiIiIiIiIiIhVqDAlIiIiIiIiIiJWocKUiIiIiIiIiIhYhQpTIiIiIiIiIiJiFSpMiYiIiIiIiIiIVagwJSIiIiIiIiIiVqHClIiIiIiIiIiIWIUKUyIiIiIiIiIiYhUqTImIiIiIiIiIiFXYWTsBERH5P323QUYa2Og/zSIiIiIicn/QiikRkbtF2bpQvmHmu4iIiIhIEUydOhWDwcDUqVOtnYpIvlSYEhEREREREbmLBAUFMXXqVH788Udrp1JoCxcuxGAwYDAYGD58eJ79UlJS+PLLL2ndujUeHh7Y29vj6+vLM888w/bt23ONOXfuHJMmTaJz587UqFEDFxcXnJycqFOnDq+99hrnz5/PNS48PJwZM2bw5JNPUqtWLdzd3XFwcKBGjRq89NJL/PPPPxbd686dO5k5cybPPPMMfn5+5vu+dOlSnjFJSUn8/vvvDB8+nEaNGuHi4oKjoyO1a9dm1KhRnDt3Ls/YrPENBgNff/11vrmNHTvW3Ld69eoW3d+dosKUiIiIiIiIyF0kKCiIadOm3XOFqcjISN59993b9jMajXTo0IExY8awf/9+ypYtS5MmTUhKSmLNmjV06tSJTz/9NEfczp07+eijj9i2bRuJiYnUrVuXqlWrEhwczNy5c2ncuDGbNm3KEXf8+HGmTJnCunXriI2NpWbNmtSuXZurV6+ybNkyWrZsyeLFiwt9v71792bixImsWbOGy5cvFyjmo48+ok+fPixatIjz589Tq1YtatWqRUhICPPmzaNp06b88ccftx1n2bJlebalp6ezcuXKAt+HtakwJSJytwhcAUcXZr6LiIiIiNxjxo4dy40bN+jZs2e+/ebMmcO+ffuoUKECf/31FxcvXiQgIICrV6+atx5OnDgxx+qhJk2asHz5ciIiIggPD+fQoUOcPn2asLAw+vfvT2JiIoMGDSIxMTFbXLVq1Vi4cCGhoaFERkbyzz//cOLECcLDwxkzZgzp6emMGjUq35VOuWnYsCEvv/wy3333HQcPHixQjMlkomPHjqxZs4YbN25w9OhRTpw4QWhoKD169MBoNPLCCy8QHh6e5xh169blwIEDnD59Otf2LVu2EB4eTt2698YRISpMiYjcLXa9A1tGZL6LiIiIiNxDtm7dyvLlyxk5ciQtW7bMt++6desAmDx5Mg8//LD5ur29PR988AEPPvgg6enpbNmyJVvcQw89xIABA6hQoUK26+XLl2fJkiV4eXkRFRWFv79/tvYHHniAYcOGUbly5WzX3dzcmDNnDg0bNiQ5OZkNGzYU6p737NnD4sWLGTVqFC1atChQzNixY9m+fTtPP/00Dg4O5usVK1Zk5cqVeHt7Ex8fz88//5znGIMGDQLgp59+yrU96/qLL75Y0FuxKhWmRERERERERO6A4OBgRo4cSc2aNXFwcMDNzY2aNWvyzDPPmLdedejQgY4dOwLw559/ZjtX6NazgtLS0vj000+pV68ejo6O+Pn5MWLECCIiIu7ofSUlJTFq1Ci8vb35+OOPb9s/a0VTzZo1c22vVasWkHl/BVWmTBlq1KgBZG4VLCiDwWBeWVSYOEuVK1cuzzY3Nzdat24NwJkzZ/Ls16dPH5ycnPjpp58wmUzZ2hISElizZg1Vq1bl0UcfLZ6kS5ieSS4iIiIiIiJSwoKCgmjVqhVRUVE4OztTt25dbG1tCQkJYc2aNVy8eJH+/fvTuHFjoqOjOX78OO7u7jRu3Ng8hq+vr/lzeno6zz77LP/73/8AqFOnDk5OTixevJjNmzfz1FNP3bF7+/DDDzl37hxLlizB09Pztv2bNGnCkSNH2Lt3b45tf8nJyQQEBADQqlWrAudw7do1Tp8+ja2tLU2bNi1wXHJyMocOHQKgefPmBY4rKUlJSQA4OTnl2cfNzY2nn36alStXsmfPHtq1a2du+/3330lISODNN9/EYDCUeL7FQYUpERERERERkRI2e/ZsoqKiGDx4MN988w2urq7mtlOnTrFr1y4Avv76a3bu3EnHjh1p1qwZO3fuzHW8b7/9lv/97394eXmxdu1ac3EiKCiIXr168f333+caFx4eznPPPVfo/Js1a5brk+ACAwOZNWsW7du356WXXirQWO+99x7/+c9/mDVrFuXKleP555+nbNmynD59mkmTJhEUFMSgQYPMq4fyc/36dQ4fPszEiRNJSEjg7bffLtBT6OLi4jh58iTTpk0jKCiIvn370r59+wLlX1IiIiL4888/AWjbtm2+fV988UVWrlzJsmXLshWmsg5FHzRoENeuXSu5ZIuRClMiIiIiIiJSYkwm0x3ZIlVSnJ2di2XlydmzZwF46623shWlAOrVq0e9evUKPJbJZGL27NlA5mqlmwsT1atXZ8mSJXmeeZSUlMSePXsKmz52djnLByaTiZEjR5KRkcF3331X4LEaNGjAnj17mDBhAuPHj2fcuHHmtnLlyvH111/z2muv5Rl/48YNvLy8sl2rWbMmP/74I4MHD853bk9PT2JiYsw/e3t78/nnnzN69OgC519S3nrrLZKTk6lTpw5PP/10vn27dOmCt7c3q1at4quvvsLBwYErV66wfft2mjdvToMGDXKctXW3UmFKRERERERESozRaMxRiLmXxMfH4+LiUuRxqlSpAsCvv/5K48aNi1TsCgwMJCQkBEdHR15++eUc7c2bN6d169b89ddfOdqqV6+e41wiSy1atIjdu3czfvx4GjVqVKjYkJAQIiIiMJlMVKpUCW9vb86dO0d0dDSLFy+mXbt2PPjgg7nG2tnZmVcURUREEBwczMWLF1m+fDkdOnSgWrVqec7bpk0b4uLiiI6OJigoiKtXr7Jy5Uo6dOiQ53x3wty5c1mxYgW2trb8+OOPuRYCb2ZnZ0f//v356quvWLduHc8++ywrVqwgPT39njn0PIsOPxcREREREREpYa+//jr29vbMmDGDGjVq8Oqrr7J8+XIuX75c6LGyDsauVq0azs7OufapX79+kfK9ncjISN59910qV67MBx98UKjY5cuX89RTTxEWFsbOnTsJCwvj8OHDREdHM2nSJA4dOsSjjz7KxYsXc413dXXF398ff39/zp49y5UrV3jttdfYsmULrVu35saNG3nOvWHDBvz9/QkMDCQqKopp06Zx4MAB2rVrx/nz5wt1H8Xljz/+4M033wQyt2i2adOmQHFZT+fL2r63bNkybG1teeGFF0om0RKiwpSIiIiIiIiUGGdnZ+Lj4+/ZV16Fn8J68MEH2bVrF126dCEsLIzvv/+eQYMGUblyZbp27UpgYGCBx4qPjwegQoUKefapWLFikXPOzzvvvMO1a9f4/PPPC7UiLjU1lXHjxmEymfjiiy947LHHzG1lypRhxowZdOnShbi4OP79738XaMxy5crxzTff8OSTTxIeHs4333xToDgXFxemTJnCa6+9RkJCAjNnzizwfRSXXbt20a9fP9LS0vj4448ZOXJkgWNbtWpFvXr1WL9+Pbt27eLIkSN07ty5xP/si5u28omIiIiIiEiJMRgMxbIVrjRo3bo1mzZtIj4+nj179rBjxw5WrFjB5s2b6dy5M8ePHy/QU+2yCkGRkZF59rl69Wqu14vr8PPDhw8D8MYbb/DGG29k65tVOFuxYgV//PGHeV7IPGsrIiICgE6dOuU61xNPPMHmzZs5ePBgoXLs2bMnf/zxh/kpe4WJ++abbwodV1QBAQH06tWLxMRE3nnnHSZMmFDoMQYNGsSkSZPM2/futW18oMKUiMjdw8Un+7uIiIiIlEqurq507dqVrl27MmXKFJo0acL58+fZsGEDL7zwwm3Pn6pTpw6QeU6T0WjMdVVXXiuwivPwc8BcZMpNYmIiiYmJ2a7FxcXddq6sM7CSkpIKkSGkpaVley/puKIIDAykW7duxMbGMnLkSD755BOLxhk0aBCTJ08mJCQEV1dXevfuXbyJ3gHayicicrcYdBBGXsp8FxEREZH7grOzM40bNwYwnzfl5OQEkKOok6VevXpUqVKFxMREli5dmqP9n3/+Yd++fbnGZh1+XtjXzp07c8yRV9+sM6eGDRtmvpalVq1a5sLbtm3bcs1x69atwP8vwBXUmjVrAAp9iLmlcZYKCgqic+fOREVFMWDAgEI90fBW1apVY+TIkXTq1Inx48cX29bTO0mFKREREREREZESNmrUKH755ReMRmO267t27TIXaJo3bw5AjRo1ADh58mSu2/VsbGx46623AHj//ffZu3evuS04OJjBgwdjb29fIvdRVOXLl6dr164AjBkzhl27dpnbUlJSmDx5Mlu2bAFybkt788032bFjB+np6dmuZ93ztm3bcHJyYtiwYdnaJ0+ezB9//EFycnK265GRkbz99tssWrQIg8HA66+/niPf6tWrU7169VyfcGiJiIgIOnfuTFhYGE899RRLlizBxqZopZm5c+eydevWQh9Cf7fQVj4RERERERGRErZv3z7mzZuHnZ0dDzzwAG5ubkRERBAcHAxkbsnq2LEjkHmo+eOPP8727dupVasWDRo0wNHRER8fH1auXAnA6NGj2bJlC+vXr6dt27bUq1cPR0dHjh8/TqVKlRg5cmSBDwG/0+bNm8ejjz5KSEgIjz32GH5+flSoUIHz58+bt/qNGDGCZ599Nlvc2rVr+frrr3FycqJ27do4Ojpy+fJlrly5QkZGBm5ubqxYsYJq1apli9u9ezcffvghZcqUoXbt2ri6uhIREUFYWBhpaWmUKVOGb775hocffjhHrll/PrltKxw9ejQ///xzjutNmjQxF5vatm3Lf//7X3PblClTOHfuHJC5Qq5Dhw65fkc9evRg4sSJeX2FpYoKUyIiIiIiIiIl7PPPP+e///0vu3fvJjQ0lPPnz+Pr60vXrl15/fXXefLJJ7P1X7FiBe+99x5btmwhICCAtLS0bAUXW1tb1qxZw+zZs1m8eDEXLlygXLlyDB48mI8++oi5c+fe6VsssGrVqnHkyBG++OIL1q5daz4Q3cvLi3bt2jF8+PAcRSmAr776ivXr17Nv3z4uX77MjRs3cHFxoXnz5nTp0oXXXnsNPz+/HHFTp05lzZo1+Pv7c+nSJc6cOYOTkxMNGjSgY8eOjBo1irp16xb6PuLi4oiOjs5x/fr16+bPMTEx2dpuXrWV3+HutWvXLnQ+9yqD6ebNniK3iI2NxcPDg4++WUnDBx+yWh7nTx9n3LCnCAgIMC9vFSl1toyEpGvgWBY6f2/tbEREREQKLCkpiYsXL1KjRg0cHR2tnY6IlIDC/DvPqiXExMTg7u6eb1+tmBIRuVtcWAfxYeCa8//LIyIiIiIiUhrp8HMREREREREREbEKFaZERERERERERMQqVJgSERERERERERGrUGFKRERERERERESsQoUpERERERERERGxChWmRERERERERETEKlSYEhERERERERERq1BhSkRERERERERErMLO2gmIiMj/qfcCJF0HRy9rZyIiIiJiEZPJZO0URKSElNS/bxWmRETuFo/NsnYGIiIiIhaxtbUFIDU1FScnJytnIyIlITk5GQA7u+ItJWkrn4iIiIiIiBSJvb09Dg4OxMTEaNWUSCmUnp7OtWvXcHFxKfbClFZMiYiIiIiISJGVL1+esLAwLl26hIeHB/b29hgMBmunJSIWMplMpKenk5iYSExMDBkZGfj6+hb7PCpMiYiIiIiISJG5u7sDEBUVRVhYmJWzEZHiYmtri7OzM97e3pQpU6bYx7e4MHXjxg2OHj2Km5sbzZo1y9Z25coVRo8ezZYtW7C1taVnz57Mnj0bb2/vIicsIlJq/VAPEi6DSyUYesra2YiIiIgUmru7O+7u7qSmppKenm7tdESkiGxsbEp89aPFhalFixbxzjvv8Nprr/H111+br6elpdGlSxdOnjxp3lu8YsUK/vnnHwICAkqkuiYiUiqkxkNKHJSJt3YmIiIiIkVib2+Pvb29tdMQkXuAxYefb968GYAXXngh2/VffvmFEydO4OjoyPvvv8+HH36Iu7s7J0+eZP78+UXLVkRERERERERESg2LV0ydO3cOgMaNG2e7vmrVKgwGA9OmTWP8+PEA1K5dm/79+/Prr7/yxhtvFCFdEREREREREREpLSxeMRUVFYWrqytubm7Zru/atQuAgQMHmq/17t0bg8HAiRMnLJ1ORERERERERERKGYsLU0lJSWRkZGS7dvr0aWJiYnjggQeyPUKwTJkyeHl5ERsba3mmIiIiIiIiIiJSqlhcmPL29sZoNBIeHm6+tnXrVgAeeeSRHP0TExPx8PCwdDoRERERERERESllLC5MtWrVCoA5c+YAYDQamTdvHgaDgU6dOmXrGxYWRmJiYrZVVCIiIiIiIiIicn+zuDA1cuRITCYTs2fPpn79+tSpU4cTJ05QoUIFnn322Wx9d+zYAeQ8KF1ERERERERERO5fFhemunbtytSpUzEYDJw+fZrLly9Tvnx5li9fjpOTU7a+K1asAKBjx45Fy1ZEREREREREREoNu6IET5kyhZdffpn9+/fj6enJQw89lOMcqZSUFNq0acPDDz9Mz549i5SsiEip9sQ8SEsEO6fb9xURERERESkFilSYAqhatSpVq1bNs71MmTJMnjy5qNOIiJR+tZ60dgYiIiIiIiJ3lMVb+URERERERERERIqiyCumANauXcumTZsIDg4mMTGRbdu2mdsSEhI4cuQIBoOBNm3aFMd0IiIiIiIiIiJSChSpMBUaGsqzzz7LoUOHADCZTBgMhmx9HBwceOGFF7h06RL//POPnswnIpKXiABITwHbMlCxhbWzERERERERKXEWb+UzGo106dKFgIAA/Pz8eP3113FxccnRz87OjuHDh2Mymfjvf/9bpGRFREq1NU/Dz49kvouIiIiIiNwHLC5Mffvtt5w+fZrmzZsTGBjIV199haura659n34685eszZs3WzqdiIiIiIiIiIiUMhYXpn799VcMBgNz5szJdaXUzRo1aoSdnR1nzpyxdDoRERERERERESllLC5MnT59GltbW9q2bXv7SWxs8PDw4Pr165ZOJyIiIiIiIiIipYzFhank5GScnJywtbUtUP+EhAQcHBwsnU5EREREREREREoZiwtT3t7exMfHc+PGjdv2PXLkCElJSVSuXNnS6UREREREREREpJSxuDD1yCOPALBq1arb9v3oo48wGAw89thjlk4nIiIiIiIiIiKljMWFqVdffRWTycTUqVM5efJkrn2MRiOvv/46v/76qzlGREREREREREQEwM7SwMcee4xhw4axaNEiHn74YXr27ElCQgIAs2bN4tixY6xbt8681W/MmDE0bdq0WJIWEREREREREZF7n8UrpgDmzZvHm2++idFoZNWqVcTHxwPw3nvvsXz5cvNT+N566y0+++yzomcLxMXFMXXqVBo3boyrqyseHh60atWK2bNnk5KSUqSxIyIiGDduHHXr1sXJyYmyZcvSvn17Fi5ciMlkum38+fPnGTlyJDVq1MDR0RFvb2+6du3Kb7/9VqD5Dx06xKBBg6hcuTIODg74+vryzDPPsH379jxjUlNTWbBgASNHjuThhx+mSpUqODk54ezsTK1atRgwYABbt24t8HcgIiIiIiIiInKnGEwFqbjcxokTJ1i4cCF79uzh8uXLpKen4+PjQ9u2bRkxYkSxrZQKDg6mQ4cOBAUFAeDs7Ex6ejrJyckANGvWjG3btuHl5VXosQMCAujatSvR0dEAuLq6kpSURFpaGgBdunRh7dq1eT5ZcP369fTt2xej0QiAu7s78fHxZGRkADBkyBAWLVqEwWDINX7hwoWMGjXKPJ+HhwexsbHmgtgHH3zA1KlTc8RFRUVRoUIF888GgwFPT09iY2NJT083Xx88eDALFy7Ezq5wi+RiY2Px8PDgo29W0vDBhwoVW5zOnz7OuGFPERAQQPPmza2Wh0iJSokDkwkMBijjZu1sRERERERELJJVS4iJicHd3T3fvkVaMZWlYcOGfP755/z9999cunSJK1eucPjwYb755ptiK0qlp6fTq1cvgoKC8PX1ZcuWLSQkJGA0Glm5ciVubm4cPnyYgQMHFnrsmJgYnnzySaKjo6lXrx4HDhwgLi6OhIQEvvnmG+zt7dm8eTNjx47NNf7ixYv069cPo9FI27ZtOX36NDExMcTExDBlyhQAFi9ezKxZs3KN37dvH6+++ippaWn07t2b0NBQbty4QWRkJCNHjgRg2rRpuR407+DgwOjRo/nll18ICgoiOTmZa9eukZKSwrFjx+jfvz8AS5YsKbZVayJSQsq4gYO7ilIiIiIiInLfKJYVU3fCokWLGD58OAB79+6lTZs22dp//vlnBgwYAMDWrVvp1KlTgceePHkyH374IU5OTpw4cYIaNWpka585cyYTJ07E1taWkydPUqdOnWztL774Ij/99BM+Pj4EBgbi6emZrX3kyJHMnz8fd3d3goKCcqzoat++Pf7+/jRu3JiAgADs7e2ztXfr1o1NmzZRrVo1zp8/j62tbYHvzWQy0a5dO/bu3Uvt2rU5e/ZsgWNBK6ZEREREREREpHDu+IqpO2HJkiUAdOzYMUdRCqB///7mgtLSpUsLNXZW/5vHuNno0aNxdXUlPT2d5cuXZ2tLSEgwnyE1atSoHEUpgAkTJgCZfzBr1qzJ1nbhwgX8/f0BGD9+fI6i1M3xwcHB7Nq1q1D3ZjAYePjhhwG4dOlSoWJFREREREREREpSgQ4cKmwxJD+PPvpooWOMRiN79uwBoHv37rn2MRgMdOvWjblz57J58+YCj3369GlCQkLyHdvV1ZX27duzYcMGNm/ezLRp08xt/v7+JCYm5htfvXp16tevT2BgIJs3b2bIkCHmti1btpg/d+vWLdf4du3a4ebmRlxcHJs3b6Zjx44Fvr+MjAz27t0LQK1atQocJyJWcHAOpMRCGXdo+Za1sxERERERESlxBSpMdejQIc9DuwvDYDCYD/cujMDAQPMh4o0aNcqzX1ZbeHg4165do2zZsrcd+/jx4zni8xp7w4YNnDx5Ms/4hg0b5hsfGBjIiRMnco339vbG29s711hbW1vz2Ve3xufl2rVrnDx5klmzZrF//34Axo0bV6BYEbGSgDkQHwaufipMiYiIiIjIfaHAW/lMJlORX1nFpcK6fPmy+bOfn1+e/W5uuzmmOMeOjY0lPj4+R7yXlxfOzs63jb81r6yf85s7v/ib/fvf/8ZgMGAwGChXrhzt27dn7dq1uLq68vnnn2dbqSUiIiIiIiIiYm0FWjFlaUGpuMTFxZk/51f8ubnt5piSGNvV1TVbfH6xN7ffmldR42/m6upKxYoVycjIICoqCpPJhLOzMzNmzGDYsGH5jp8lOTmZ5ORk88+xsbEFihMRERERERERKax75vBzub033niD8PBwrl69SmJiIvv27aNdu3aMHTuWFi1acPr06duOMXPmTDw8PMyvKlWq3IHMRUREREREROR+dE8Uptzc3MyfjUZjnv1ubrs5piTHzvqcX+zN7bfmVdT4vDg4ONC6dWs2btzIU089xdmzZxk0aBAmkynfuAkTJhATE2N+hYaGFmg+EREREREREZHCKtbCVHBwMAcOHODAgQMEBwcX27iVKlUyfw4LC8uz381tN8cU59ju7u7mbXw3x1+/fj3f4lJW/K15Zf2c39z5xd+OwWBgzJgxABw8eJDDhw/n29/BwQF3d/dsLxERERERERGRklDkwtTly5cZPXo03t7e1KxZk9atW9O6dWtq1qxJhQoVGD16NJcuXSrSHPXr18fGJjPVm5+Cd6usNh8fnwI9kQ+yP4mvIGM3aNAgz/j8npiXFX/rk/uy4q9evUpkZGSusenp6Zw6dSrX+IK4+WD1c+fOFTpeRERERERERKQkFKkwtXnzZho2bMh3331nPmz75ld0dDTfffcdjRo1YuPGjRbP4+zsTNu2bQHyHMdkMrFp0yYAunTpUuCx69atS9WqVfMdOyEhgd27d+c6drt27XBycso3Pjg4mMDAwFzjO3fubP6cV/yePXvMh54X5t6yXLhwwfy5oFsBRURERERERERKmsWFqdOnT9O7d29iYmLw8vJi4sSJbN26lcDAQAIDA9m6dSvvv/8+5cqVIzY2lmeffbZAh2/nZfDgwQDs2LGD/fv352hfvXq1uQDz0ksvFWrsrP4rV64kKCgoR/u3335LfHw8tra2DBw4MFubi4sLffr0AWDu3LnExMTkiP/kk0+AzKJQ7969s7XVrFmTdu3aATB79mxSU1NzxP/73/8GoFq1ajz66KPZ2tLS0vK9t7S0NGbNmgVAmTJlaNOmTb79RURERERERETuFIsLUzNmzCApKYkmTZoQGBjIhx9+yOOPP07dunWpW7cujz/+ODNmzODkyZM0adKE5ORkPvzwQ4sTHTx4MI0bN8ZkMtGnTx+2bdsGQEZGBqtXr2bEiBEAdO/enU6dOmWLnTp1KgaDAYPBkGvhafz48fj4+GA0GunZsycBAQEApKSkMHfuXCZPngzAK6+8Qp06dXLET58+HRcXF65cuUKvXr04e/YskLnSavr06cybNw+ASZMm4eXllSP+008/xdbWliNHjtC/f3/zeVLXrl3jtddeY8OGDdn63Wz06NGMGjWKnTt3Eh8fb76enJzM9u3beeKJJ9i+fbv5Pj09PfP5lkXEqrybg2/rzHcREREREZH7gMF0u8e05cHX15erV6+yf/9+WrZsmW/fAwcO8PDDD1OxYkWuXLliUaIAQUFBdOzY0VxccnZ2JiMjg6SkJACaNWvGtm3bchR/pk6dyrRp0wC4ePEi1atXzzF2QEAAXbt2JTo6Gshc3ZSUlGRewdSlSxfWrl2Lg4NDrrmtX7+evn37mg9A9/DwID4+nvT0dABefvllfvjhBwwGQ67xCxcuZNSoUeYVUJ6ensTExJifovfBBx8wderUHHEvv/wyS5YsATIPOndzc8Pe3p4bN26Y5zYYDLz55pvMmTPHfFZXQcXGxuLh4cFH36yk4YMPFSq2OJ0/fZxxw54iICCA5s31S7uIiIiIiIjI3SqrlhATE3Pbh6pZvGLqxo0buLq63rYoBdCqVStcXV25ceOGpdMBUL16dY4ePcqUKVNo1KgRBoMBe3t7WrRowWeffcZff/2V64qkgmjRogUnTpxg7NixPPDAA6SmpuLi4kK7du1YsGABGzZsyLMoBdCjRw+OHj3KiBEjqF69OomJiXh6etK5c2d+/fVXFi9enGdRCmD48OHs37+fAQMG4Ofnh9FoxNvbm969e7Nt27Zci1IA7733Hp9++ik9e/akdu3aGAwG8x98ixYt+Ne//sXhw4f54osvCl2UEhEREREREREpSRavmKpZsyZXr17Ntn0sP66urnh7e2c7iFvufloxJSIiIiIiIiKFcUdWTPXo0YPExETz+UX52bZtG0ajkSeffNLS6UREREREREREpJSxuDA1efJkvL29GTZsGGfOnMmz39mzZxkxYgS+vr5MmjTJ0ulEREq//zwFK9pkvouIiIiIiNwH7CwNPH36NDNnzmTs2LE0bdqUvn378vjjj+Pn54fBYODSpUvs2LGD1atX4+joyJw5czh16hSnTp3KMdajjz5apJsQESkVrh6C+DBw9bN2JiIiIiIiIneExYWpDh06ZDvMe/ny5SxfvjzXvsnJyQwbNizXNoPBYH4SnYiIiIiIiIiI3D8sLkwBWHhuerGPISIiIiIiIiIi9x6LC1MZGRnFmYeIiIiIiIiIiNxnLD78XEREREREREREpChUmBIREREREREREatQYUpERERERERERKyiSIefA8TFxfG///2Po0ePcv36dVJTU/PsazAYWLRoUVGnFBERERERERGRUqBIhan58+czfvx4EhISzNdye8qewWDAZDKpMCUiIiIiIiIiImYWF6ZWrVrFq6++CoCLiwtt2rShYsWK2NkVeRGWiMj9qcVbkBILZdytnYmIiIiIiMgdYXEV6bPPPgOge/furFy5Ejc3t2JLSkTkvtTyLWtnICIiIiIickdZfPj5iRMnMBgM/PDDDypKiYiIiIiIiIhIoVm8YsrFxQUHBwcqVqxYnPmIiIiIiIiIiMh9wuIVU02bNiUuLo64uLjizEdE5P6VEgfJsZnvIiIiIiIi9wGLC1NjxowhPT2db7/9tjjzERG5fy2uD994ZL6LiIiIiIjcByzeytezZ08mT57M5MmTAfjXv/6Fk5NTsSUmIiIiIiIiIiKlm8WFKYBp06bh6urKu+++y4wZM2jQoEG+B6EbDAa2bdtWlClFRERERERERKSUKFJh6v333+fTTz/FYDCQmJhIQEBAvv0NBkNRphMRERERERERkVLE4sLUDz/8wMyZMwGoUaMGnTp1omLFitjZFanWJSIiIiIiIiIi9wmLq0jffPMNBoOBwYMHs3DhQmxsLD5HXURERERERERE7kMWV5POnDkDwJw5c1SUEhERERERERGRQrN4xZSLiwtlypTB09OzGNMREREREREREZH7hcVLnR566CFiY2OJjo4uznxEREREREREROQ+YXFh6p133gHgo48+KrZkRERERERERETk/mHxVr727dvz/fff88Ybb2A0Gnn33XepUaNGceYmInJ/6f1fSE8B2zLWzkREREREROSOsLgwVbNmTQBsbW1ZsGABCxYsoGzZsri5ueUZYzAYOH/+vKVTioiUbhVbWDsDERERERGRO8riwlRQUFCOa9HR0fmeOWUwGCydTkREREREREREShmLC1OLFy8uzjxEREREREREROQ+Y3FhavDgwcWZh4iInP8D0hLBzglqPWntbEREREREREqcxYUpEREpZltfhfgwcPWDWpesnY2IiIiIiEiJs7F2AiIiIiIiIiIicn8qthVTJpOJ69evk5CQgMlkyrNf1apVi2tKERERERERERG5hxW5MPXHH3/w1VdfsW/fPoxGY759DQYDaWlpRZ1SRERERERERERKgSIVpt555x1mz56d7wqpmxW0n4iIiIiIiIiIlH4WnzG1ceNGPvvsM+zs7Pjss884ceIEABUqVODcuXP4+/vzwQcfULZsWcqXL8///vc/Ll68WGyJi4iIiIiIiIjIvc3iwtT333+PwWBg8uTJvPXWW9SvXx8AW1tbatasySOPPMIHH3zAP//8g4eHB8OGDcPBwaHYEhcRERERERERkXubxYWpv//+G4ARI0Zku37rdr3KlSvzzTffcPXqVT755BNLpxMRERERERERkVLG4sJUdHQ0zs7OVKxY0XzN1tY21wPQO3fujKOjI+vWrbN0OhERERERERERKWUsLky5u7vnWB3l4eFBfHw8CQkJ2SexscHOzo6wsDBLpxMRKf3sXaGMW+a7iIiIiIjIfcDiwpSfnx+JiYlcv37dfK1OnToA7NmzJ1vfs2fPEh8fj51dkR4CKCJSug09BaNjM99FRERERETuAxYXplq2bAnAsWPHzNc6d+6MyWRi4sSJhIeHAxAZGcmIESMwGAzmGBEREREREREREYsLU0899RQmk4mff/7ZfO3111/H09OTw4cPU7VqVfz8/PD19WX37t0AvP3220XPWERERERERERESgWLC1OdO3dm8eLFdOvWzXzN29ubdevWUaVKFdLS0rhy5QoZGRk4Ozvz3XffZesrIiIiIiIiIiL3N4sPfXJ0dGTw4ME5rrdp04bz58+zb98+QkND8fDwoF27dri7uxcpURGRUu/PtyHpOjh6wWOzrJ2NiIiIiIhIiSuR08htbW1p165dSQwtIlJ6nfoZ4sPA1U+FKRERERERuS9YvJVPRERERERERESkKCwuTKWkpBASEmJ++t7N4uPjGT9+PE2bNqV58+ZMnjyZxMTEIiUqIiIiIiIiIiKli8Vb+RYuXMjo0aMZPHgwP/zwQ7a2nj174u/vj8lkAuDIkSPs3r2bHTt2YDAYipaxiIiIiIiIiIiUChavmNq0aRMAAwYMyHZ97dq17N69G4PBwMCBAxk+fDj29vbs3r2bZcuWFS1bEREREREREREpNSwuTAUGBgLQokWLbNdXrFiBwWDg3XffZdmyZcyfP58vvvgCk8nEihUripatiIiIiIiIiIiUGhYXpiIjI3F2dsbLyyvb9R07dgAwfPhw87UXX3wRyNzSJyIiIiIiIiIiAkUoTCUkJGBjkz08KCiIyMhIqlSpQo0aNczXXVxc8PT05Nq1a5ZnKiIiIiIiIiIipYrFhamyZcsSHx/PjRs3zNe2b98OwCOPPJKjf1paGq6urpZOJyIiIiIiIiIipYzFhanmzZsDsGjRIgAyMjJYtGgRBoOBjh07ZusbGRlJfHw8Pj4+RUhVRKSUq9kT6jyX+S4iIiIiInIfsLM08OWXX2bjxo289957bN26lcjISA4dOoSbmxt9+/bN1nf37t0A1K9fv2jZioiUZp2/t3YGIiIiIiIid5TFK6b69evHkCFDSE9PZ9OmTRw6dAhHR0fmzZuHp6dntr6//PJLriupRERERERERETk/mXxiinI3MY3dOhQ9u7di6enJ0888US2Q88BUlJS8PDw4KWXXqJHjx5FSlZEREREREREREqPIhWmANq2bUvbtm3zbC9Tpgzz588v6jQiIiIiIiIiIlLKFLkwJSIixeSnlpAQDi4+MOigtbMREREREREpcSpMiYjcLRLCIT7M2lmIiIiIiIjcMRYffi4iIiIiIiIiIlIUKkyJiIiIiIiIiIhVqDAlIiIiIiIiIiJWocKUiIiIiIiIiIhYhQpTIiIiIiIiIiJiFQUqTH311VcsWrSopHMREREREREREZH7SIEKU2PGjGHKlCnZrtWsWZPWrVuXSFIiIiIiIiIiIlL62RW0Y0ZGRrafg4KCSEpKKvaERERERERERETk/lCgwpSbmxvXrl0jPT0dW1vbks5JROT+9OinkGoEe2drZyIiIiIiInJHFKgw1bBhQ/bv38/bb7/N8OHDcXV1BSA9PZ3Q0FBMJlOBJ6xataplmYqIlHb1B1g7AxERERERkTuqQIWpESNG8Ndff/Hll1/y5Zdfmq9HRUVRvXr1Ak9mMBhIS0srdJIiIiIiIiIiIlL6FOjw8yFDhjBr1iwqVqyIyWQyr5DK+lzQ163nVImIiIiIiIiIyP2rwIefjxs3jnHjxhEVFUVCQgI1atSgQoUK/P333yWZn4jI/ePaachIAxs7KFvX2tmIiIiIiIiUuAIXprKUL1+e8uXLA2Bra0u1atWKPSkRkfvS6k4QHwaufjDykrWzERERERERKXGFLkxl2bFjB2XKlCnOXERERERERERE5D5SoDOmcvPYY4/Rpk2b4sylQOLi4pg6dSqNGzfG1dUVDw8PWrVqxezZs0lJSSnS2BEREYwbN466devi5ORE2bJlad++PQsXLizQkwfPnz/PyJEjqVGjBo6Ojnh7e9O1a1d+++23As1/6NAhBg0aROXKlXFwcMDX15dnnnmG7du35xljMpnYt28fkyZNokOHDlSsWBF7e3s8PDxo0aIFEyZMICwsrMDfgYiIiIiIiIjInWIwFaTichsRERH8+uuvHDx4kKtXr2IwGKhQoQKtWrWiT58+VKxYsThyJTg4mA4dOhAUFASAs7Mz6enpJCcnA9CsWTO2bduGl5dXoccOCAiga9euREdHA+Dq6kpSUpL5KYJdunRh7dq1ODg45Bq/fv16+vbti9FoBMDd3Z34+Hjzge9Dhgxh0aJFGAyGXOMXLlzIqFGjzPN5eHgQGxtrLoh98MEHTJ06NUfcRx99xKRJk8w/GwwGPDw8iImJMce6u7uzbNkynnrqqcJ+LcTGxuLh4cFH36yk4YMPFTq+uJw/fZxxw54iICCA5s2bWy0PkRL1fWVt5RMRERERkXteVi0hJiYGd3f3fPtavGIKID09nYkTJ1KtWjXefPNNli5dyoYNG1i/fj1Lly5l9OjRVKtWjffff5/09PSiTEV6ejq9evUiKCgIX19ftmzZQkJCAkajkZUrV+Lm5sbhw4cZOHBgoceOiYnhySefJDo6mnr16nHgwAHi4uJISEjgm2++wd7ens2bNzN27Nhc4y9evEi/fv0wGo20bduW06dPExMTQ0xMDFOmTAFg8eLFzJo1K9f4ffv28eqrr5KWlkbv3r0JDQ3lxo0bREZGMnLkSACmTZvGqlWrcsSmpqbi7u7Oq6++yvbt20lISOD69eskJCTw22+/UbVqVWJjY+nbty+BgYGF/m5EREREREREREpKkVZMDRw4kJUrV2IymXBwcKBly5ZUrlwZgEuXLnHw4EGSk5MxGAwMGDCAZcuWWZzookWLGD58OAB79+7NsY3w559/ZsCAAQBs3bqVTp06FXjsyZMn8+GHH+Lk5MSJEyeoUaNGtvaZM2cyceJEbG1tOXnyJHXq1MnW/uKLL/LTTz/h4+NDYGAgnp6e2dpHjhzJ/PnzcXd3JygoKMeKrvbt2+Pv70/jxo0JCAjA3t4+W3u3bt3YtGkT1apV4/z589ja2prb/vnnH6pVq5bnKrGLFy/SsGFDEhMTGTZsGAsXLizw9wJaMSVyR2nFlIiIiIiIlAJ3ZMXUmjVr+PnnnzGZTLz11ltcuXKF3bt38/PPP/Pzzz+ze/duwsPDGT9+PCaTiRUrVrB27VpLp2PJkiUAdOzYMdezrfr3728uKC1durRQY2f1v3mMm40ePRpXV1fS09NZvnx5traslUkAo0aNylGUApgwYQKQ+QezZs2abG0XLlzA398fgPHjx+coSt0cHxwczK5du7K1Pfjgg/luXaxRowYdO3YE4MCBA3n2ExERERERERG50ywuTGWdl/T+++/z2Wef5VqQ8fDw4NNPP+X999/HZDKxYMECi+YyGo3s2bMHgO7du+fax2Aw0K1bNwA2b95c4LFPnz5NSEhIvmO7urrSvn37XMf29/cnMTEx3/jq1atTv379XOO3bNli/pyV/63atWuHm5tbrvEF4ejoCFDk7ZQiIiIiIiIiIsXJ4sLUgQMHsLGxYfz48bftO378eGxsbCxesRMYGGg+RLxRo0Z59stqCw8P59q1awUa+/jx4zni8xv75MmTecY3bNjwtvEnTpzINd7b2xtvb+9cY21tbalXr16u8beTmppqLuo1bty4ULEiIiIiIiIiIiXJ4sLU9evX8fDwwMPD47Z9s/pdv37dorkuX75s/uzn55dnv5vbbo4pzrFjY2OJj4/PEe/l5YWzs/Nt42/NK+vn/ObOL/525syZQ0REBAAjRoy4bf/k5GRiY2OzvURERERERERESoKdpYFeXl5ER0cTGxt724Ossp5QV758eYvmiouLM3/Or/hzc9vNMSUxtqura7b4/GJvbr81r6LG58ff39/8VMAXXniBxx9//LYxM2fOZNq0aQWeQ0SK0cADYEoHg+3t+4qIiIiIiJQCFq+YatWqFRkZGXz++ee37fv555+TkZFBy5YtLZ1OCunUqVM8++yzpKSk0LBhQ77//vsCxU2YMMFcSIyJiSE0NLSEMxURM1dfcKuc+S4iIiIiInIfsLgwNWTIEEwmEzNmzGDy5MnZtrdliYuLY9KkScyYMQODwcDw4cMtmivr4G/IPAg9Lze33RxTkmNnfc4v9ub2W/Mqanxuzpw5w+OPP05kZCR169Zl69atBf4+HBwccHd3z/YSERERERERESkJFm/le/bZZ+nXrx+rVq3i448/Zs6cObRq1Qo/Pz8MBgOhoaEcPHiQpKQkTCYTzz//PL1797ZorkqVKpk/h4WF0aRJk1z7hYWF5RpTmLHzKsRkje3u7m7exndz/PXr1zEajXluycuKvzWvrJ9vzr0w8bc6c+YMHTt25MqVK9SpU4cdO3bg4+OTb4yIiIiIiIiIiDVYXJgCWLZsGZUrV+arr74iMTGRXbt2YTAYADCZTJkT2Nnxr3/9i48//tjieerXr4+NjQ0ZGRkcP36c7t2759ov6wl3Pj4+lC1btkBj3/wkvuPHj1O/fv18x27QoEGe8SdOnKBVq1b5xt/65L6s+KtXrxIZGUmFChVyxKanp3Pq1Klc42+WVZS6fPkyDzzwADt27MDXV1uCRO4ZR+dDSjyUcYUmr1g7GxERERERkRJn8VY+AHt7ez777DOCgoL48ssvefHFF+nSpQtdunThxRdf5MsvvyQoKIhZs2Zhb29v8TzOzs60bdsWgI0bN+bax2QysWnTJgC6dOlS4LHr1q1L1apV8x07ISGB3bt35zp2u3btcHJyyjc+ODiYwMDAXOM7d+5s/pxX/J49e8yHnud1b2fOnKFDhw7motTOnTsLvGpMRO4S+6bDn+My30VERERERO4DRSpMZalUqRKjR49myZIlbNiwgQ0bNrBkyRJGjx5dbMWRwYMHA7Bjxw7279+fo3316tVcuHABgJdeeqlQY2f1X7lyJUFBQTnav/32W+Lj47G1tWXgwIHZ2lxcXOjTpw8Ac+fOJSYmJkf8J598AmSeD3XrdsaaNWvSrl07AGbPnk1qamqO+H//+98AVKtWjUcffTRHe1ZRKmv7nopSIiIiIiIiInIvKJbC1J0wePBgGjdujMlkok+fPmzbtg2AjIwMVq9ezYgRIwDo3r07nTp1yhY7depUDAYDBoMh18LT+PHj8fHxwWg00rNnTwICAgBISUlh7ty5TJ48GYBXXnmFOnXq5IifPn06Li4uXLlyhV69enH27Fkgc6XV9OnTmTdvHgCTJk3Cy8srR/ynn36Kra0tR44coX///ubzpK5du8Zrr73Ghg0bsvW72blz58xnStWtW1dFKRERERERERG5ZxTpjKk7yc7OjrVr19KxY0eCgoJ44okncHZ2JiMjg6SkJACaNWvG8uXLCz22h4cHf/zxB127duXkyZO0bNkSNzc3kpKSzCuYunTpwueff55rfI0aNVi1ahV9+/Zl9+7d1KlTBw8PD+Lj40lPTwfg5Zdf5u233841vk2bNsybN49Ro0bx+++/8/vvv+Pp6UlMTIz5rK4PPviAfv365Yj9+OOPuXz5MgBXrlyhWbNm+d5reHh4wb4UEREREREREZESds+smAKoXr06R48eZcqUKTRq1AiDwYC9vT0tWrTgs88+46+//sp1RVJBtGjRghMnTjB27FgeeOABUlNTcXFxoV27dixYsIANGzbg4OCQZ3yPHj04evQoI0aMoHr16iQmJuLp6Unnzp359ddfWbx4sflg+NwMHz6c/fv3M2DAAPz8/DAajXh7e9O7d2+2bdvG1KlTc43LyMgwf46NjSUiIiLfl4iIiIiIiIjI3cJgylqSI5KL2NhYPDw8+OiblTR88CGr5XH+9HHGDXuKgIAAmjdvbrU8RErU95UhPgxc/WDkJWtnIyIiIiIiYpGsWkJMTAzu7u759r2nVkyJiIiIiIiIiEjpocKUiIiIiIiIiIhYhQpTIiIiIiIiIiJiFffMU/lEREo9rzrg4AHOFa2diYiIiIiIyB1hcWHKaDTi7OxcnLmIiNzf+m23dgYiIiIiIiJ3lMVb+Xx9fRk1ahSHDx8uznxEREREREREROQ+YXFhKi4ujvnz59OyZUseeughFi1ahNFoLM7cRERERERERESkFLO4MLVgwQIeeughTCYTBw8e5JVXXsHX15fXXntNq6hEREREREREROS2LC5MDRs2jH379nH06FFef/11PDw8iIuL4/vvv6dly5Y8/PDDWkUlIlIY6wbCr10z30VERERERO4DFhemsjRq1Iivv/6aK1eusGTJEh555BFMJhMHDhzQKioRkcK49CcEb858FxERERERuQ8UuTCVxcHBgRdffJHdu3cTGBjI2LFjKVeuXLZVVDqLSkREREREREREshRbYepmdevWZfbs2Rw7doxHH30Uk8mU7SwqPz8/Jk6cSGxsbElMLyIiIiIiIiIi94ASKUz5+/szePBgatasye7duwFwcXHhmWeeoWzZssTExPDJJ5/QpEkTLly4UBIpiIiIiIiIiIjIXa7YClPXrl3jiy++oGHDhjz22GMsW7aMxMREGjZsyNdff83ly5f57bffCAsL44cffsDPz4/Q0FDefffd4kpBRERERERERETuIXZFHeDPP/9k/vz5/Oc//yE5ORmTyYSDgwN9+vRh1KhRtG3bNlv/MmXK8PLLL9O+fXvq1q3Ln3/qkF8RERERERERkfuRxYWpzz77jIULF3L27FkATCYTtWrV4pVXXmHo0KGUK1cu3/hatWrh4+PDlStXLE1BRERERERERETuYRYXpt55553MAezsePLJJxk1ahSdO3cu1BjVq1fH3t7e0hREREREREREROQeZnFhqlKlSowYMYIRI0ZQqVIli8bw9/e3dHoREREREREREbnHWVyYCgkJwcamRB7qJyJyf2o8AlJioIyHtTMRERERERG5IywuTH344Ye4ubkxduzYAvX/6quvuHHjBlOmTLF0ShGR0u2RD6ydgYiIiIiIyB1l8ZKnqVOnMmvWrAL3//zzz5k2bZql04mIiIiIiIiISCmjvXgiIiIiIiIiImIVd6wwde3aNRwdHe/UdCIiIiIiIiIicpez+Iypwli9ejVxcXHUrVv3TkwnInJv+r4yxIeBqx+MvGTtbEREREREREpcgQtTX375JV9++WW2a5GRkdSsWTPPGJPJxI0bN4iNjcVgMNCzZ0/LMxURERERERERkVKlwIWpGzduEBQUlO1aenp6jmt56dSpk57IJyIiIiIiIiIiZgUuTPXu3Zvq1asDmSuhhg4dioeHB1988UWeMTY2Nri7u9OoUSNq1apV1FxFRERERERERKQUKXBhqmnTpjRt2tT889ChQ3FycmLw4MElkpiIiIiIiIiIiJRuFh9+npGRUZx5iIiIiIiIiIjIfcbG2gmIiIiIiIiIiMj9SYUpERERERERERGxigIVpmxtbbG1taVhw4Y5rhXmZWdn8c5BEREREREREREpZQpUKTKZTNneb/0sIiIiIiIiIiJSWAUqTO3YsQMAZ2fnHNdERKSY9PgJ0pPB1sHamYiIiIiIiNwRBSpMPfbYYwW6JiIiRVClg7UzEBERERERuaN0+LmIiIiIiIiIiFhFiRamrl+/TmxsbElOISIiIiIiIiIi9yiLC1OXL19m6dKlbNy4MUfbiRMnaNmyJeXLl8fLy4v27dtz5syZIiUqIlLqhe6EoE2Z7yIiIiIiIvcBiwtTP/zwA0OGDGHnzp3ZricmJtKjRw8OHz6MyWTCZDKxZ88ennjiCa2eEhHJz/pB8Fu3zHcREREREZH7gMWFqa1btwLw/PPPZ7u+ZMkSQkNDKVu2LAsWLOCnn36icuXKhIWF8e233xYtWxERERERERERKTUsLkwFBQUBUK9evWzXf//9dwwGAx9//DHDhg1jwIABLFiwAJPJxNq1a4uUrIiIiIiIiIiIlB4WF6aioqJwd3fHycnJfC0jI4O9e/diMBh47rnnzNc7d+6MjY0Np0+fLlq2IiIiIiIiIiJSalhcmEpPTyc5OTnbtWPHjmE0GmnYsCFeXl7/fxIbG7y8vEhISLA8UxERERERERERKVUsLkz5+vqSnJzMxYsXzdc2bdoEwCOPPJKjf3x8PGXLlrV0OhERERERERERKWXsLA1s06YNwcHBTJs2jR9++IHo6Gjmzp2LwWCga9eu2fpevHiR5ORkfH19i5ywyN0gJCSEqKgoa6cBQPny5alataq10wD0vYiIiIiIiEjhWFyY+te//sXKlStZtmwZv//+OykpKaSkpFCzZk2efPLJbH23bNkCQPPmzYuWrchdICQkhPr162M0Gq2dCgDOzs4EBgZavQij70VEREREREQKy+LC1EMPPcQPP/zAm2++SVxcHJD5hL6VK1diZ5d92KVLlwLQsWPHIqQqcneIiorCaDQydsocKlerbdVcLgWf4/PpbxEVFWX1Aoy+FxERERERESksiwtTAIMHD6Zfv34cP34cT09PatWqhY1N9mOrUlJSeOWVVxgxYgQ9e/YsUrIid5PK1WpTq24ja6dx19H3IiIiIiIiIgVVpMIUgJOTE61atcqzvUyZMrz00ktFnUZEpPQbecnaGYiIiIiIiNxRFj+VT0REREREREREpCiKvGIqS1JSEtevXyc1NTXffjrvRUREREREREREoIiFKaPRyKeffsrPP//MuXPnbtvfYDCQlpZWlClFRERERERERKSUsLgwdePGDR599FFOnDiByWQqUExB+4mI3Jf2ToOUGCjjAY98YO1sRERERERESpzFhakZM2Zw/Phx7O3tGT16NE8//TSVKlXCzq7YdgeKiNxfji2A+DBw9VNhSkRERERE7gsWV5HWrFmDwWDgiy++YNSoUcWZk4iIiIiIiIiI3AcsfipfWFgYNjY2DBkypDjzERERERERERGR+4TFK6bKli1LUlISjo6OxZmP3KWSk5NISjRadX6AxMREEhISrJZHVg5g/e8kKwfQ93Kru+l7KZTkDEgG7DPgXspb5D7n7OyMwWCwdhoiIiIi9ySDycITyfv168dvv/1GSEgIfn5+xZ2X3CViY2Px8PCwdhoiIiJ3rfj4eFxcXKydhoiIiMhdI6uWEBMTg7u7e759Ld7K9+6772JnZ8eMGTMsHUJERERERERERO5jFm/la9GiBT/++CNDhw4lNTWV999/n5o1axZnbnIXmTL7Rxo0aWm1+S+cPcnE1/rh7+/Pgw8+aLU8AP755x/atWvHx9+touYDDayai76X3N1N30uhLHoA4q+Aqy8MO2vtbESkgJydna2dgoiIiMg9y+LCVFYRytbWlh9//JEff/yRsmXL4ubmlmeMwWDg/Pnzlk4pVuTg4Iijk/X+D28Hh8yzzJycnKy+XcLJyQmw/neSlQPoe7nV3fS9FIqDDaT+3/u9lLeIiIiIiIiFLC5MBQUF5bgWHR1NdHR0njE6GFRERERERERERLJYXJhavHhxceYhIiKVH4PEKHAqb+1MRERERERE7giLC1ODBw8uzjxERKTncmtnICIiIiIickdZ/FQ+ERERERERERGRolBhSkRERERERERErKLIhalLly7x1ltv0bBhQ1xdXbGzy7478Pr163z88cfMnDmTjIyMok4nIiIiIiIiIiKlhMVnTAFs3bqVvn37Ehsbi8lkAnI+ec/Ly4v//ve/HDx4kNatW9OxY8eiTCkiUnqtehyMEeBcEfptt3Y2IiIiIiIiJc7iFVOhoaE899xzxMTE0KtXL3799Ve8vLxy7Tt06FBMJhNr1qyxdDoRkdLv+hmIPpn5LiIiIiIich+wuDA1Z84cYmNj6devH2vWrOHZZ5+lTJkyufbt2rUrAP7+/pZOJyIiIiIiIiIipYzFhalNmzZhMBiYMWPGbftWr14dBwcHLl68aOl0IiIiIiIiIiJSylhcmAoODsbJyYkHHnigQP1dXV2Jj4+3dDoRERERERERESllLC5M2djYFPgpe6mpqcTExODm5mbpdCIiIiIiIiIiUspYXJiqUqUKycnJhIaG3rbvjh07SEtLo3bt2pZOJyIiIiIiIiIipYzFhalOnToB8P333+fbLzExkffeew+DwUC3bt0snU5EREREREREREoZiwtTY8eOxc7Ojs8++4wlS5bk2mfv3r08+uij/PPPPzg7O/Paa69ZnKiIiIiIiIiIiJQuFhematasyTfffENKSgpDhw6lUqVKXL9+HYCePXtStWpV2rdvT0BAAAaDgfnz51OxYsUiJxwXF8fUqVNp3Lgxrq6ueHh40KpVK2bPnk1KSkqRxo6IiGDcuHHUrVsXJycnypYtS/v27Vm4cCEmk+m28efPn2fkyJHUqFEDR0dHvL296dq1K7/99luB5j906BCDBg2icuXKODg44OvryzPPPMP27dvzjTt16hQ//PADr7/+Om3atMHZ2RmDwYDBYCjQvCIiIiIiIiIi1mBXlOARI0ZQoUIF3njjDS5fvmy+vmHDBvNnX19fvvvuO55++umiTAVkPgmwQ4cOBAUFAeDs7ExycjIHDx7k4MGDLF++nG3btuHl5VXosQMCAujatSvR0dFA5lME4+Li8Pf3x9/fn9WrV7N27VocHBxyjV+/fj19+/bFaDQC4O7uTnR0NJs3b2bz5s0MGTKERYsW5VksWrhwIaNGjSItLQ0ADw8PIiIiWLNmDWvWrOGDDz5g6tSpuca++uqr/Pnnn4W+Z8nOZDKRkpJOQkIq8fGpJCSkkpaWQXq6iYyMzFd6uonAwBigKpeCk7C3j8XO3oCdvQ329rbY29vg5GyHrZ3FNV+5n7WZAinxUMbV2pmIiIiIiIjcEUUqTAH07t2bnj17smHDBvz9/bl8+TLp6en4+PjQtm1bevXqlWcxpzDS09Pp1asXQUFB+Pr6snTpUp544gkyMjJYvXo1I0aM4PDhwwwcOJD169cXauyYmBiefPJJoqOjqVevHsuWLaNly5akpKSwYMECxo4dy+bNmxk7dizfffddjviLFy/Sr18/jEYjbdu25YcffqBOnTrEx8cza9Yspk+fzuLFi6lXrx7vvPNOjvh9+/bx6quvkp6eTu/evfn666+pXLky0dHRvP/++3z//fdMmzaNBg0a0K9fvxzxdnZ21K9fnxYtWtC8eXMuXbrEnDlzCvUdlEYmk4moqERCQmIJCYnj8uV4IiONREUlEhmZSFRU5is6OpH4+FTi41NIT7/9yrhMo/l8ejAQnGuro5MtTs72uLja4+xij5OLHe4eDniWdcDDywFPL8fM97IOeJVzxKucE7a2WuF232vyirUzEBERERERuaOKXJgCsLe356mnnuKpp54qjuFy9eOPP3Ls2DEAfvvtN9q0aQOAjY0Nzz//PBkZGQwYMIANGzawbds28+HsBfHZZ58RHh6Ok5MT69evp0aNGgCUKVOG119/ndjYWCZOnMj8+fMZM2YMderUyRY/ZcoUEhIS8PHx4Y8//sDT0xPIXHU1bdo0wsPDmT9/Ph999BEjRozIsaLrnXfeIT09ncaNG7Nq1Srs7e0BKFeuHPPmzSMoKIhNmzbxzjvv0KdPH2xtbbPFb9q0Kdu1H3/8scD3fq9LTU3nwoUYTp++xunT1zhz5jpBQbHmYlRSUppV8kpKTCcpMZ3r0UkF6m9ja6BcBScqVHSmQkUnyns7U8HHGd/KrlSq4kq5Ck7Y2KhwJSIiIiIiIqVLsRSm7oSsA9Y7duxoLkrdrH///rz//vtcvHiRpUuXFqowtXTpUvMYWUWpm40ePZqPP/6Y+Ph4li9fzrRp08xtCQkJ5jOkRo0aZS5K3WzChAnMnz+f2NhY1qxZw5AhQ8xtFy5cwN/fH4Dx48ebi1K3xm/atIng4GB27dpFx44ds7XfWqgqjTLP+PJi+/ZI1qzx5+jRKE6dusb58zdIS8uwdnpFlpFuIjLcSGS4Mdf2Mg62+FZ2oVIVNypVySxW+VVxIzU1/Q5nKiIiIiIiIlJ87onClNFoZM+ePQB079491z4Gg4Fu3boxd+5cNm/eXOCxT58+TUhISL5ju7q60r59ezZs2MDmzZuzFab8/f1JTEzMN7569erUr1+fwMBA83lTWbZs2WL+3K1bt1zj27Vrh5ubG3FxcWzevDlHYao0igw3cup4NGcDr3Px7A3OnYoGJvL228esnZpVpCSnE3w+luDzsbm0TuRf/zpC+/YJNGlSgSZNylOnTlnsdM7VvSf+CpjSwWALrr7WzkZERERERKTEFagwNXTo0GKZzGAwsGjRokLHBQYGkpGRuSqmUaNGefbLagsPD+fatWuULVv2tmMfP348R3xeY2/YsIGTJ0/mGd+wYcN84wMDAzlx4kSu8d7e3nh7e+caa2trS7169Thw4ECO+NIgLS2Di2dvcOpYNKeOX+PU8WiiryZaO617iBf+/tH4+0ebrzg42NKgQTmaNq1Ay5Y+tGrlQ9OmFXBwuCdq0fev5a0gPgxc/WDkJWtnIyIiIiIiUuIK9Fvqjz/+iMFg+L/tVNnl9ZS5W5lMJosLUzc/8c/Pzy/Pfje3Xb58uUCFqcKOHRsbS3x8PK6urtnivby8cHZ2vm38zfPd/HN+c2e1HzhwIEd8cUtOTiY5Odn8c2xsbit0iiYjw0Tw+RiOHLzK0YCrnDwSRVLinduSZjBAuXJOVKjgRIUKzpQr54SHRxlcXOxzvBwcbLGxMWBjY8DW1gYbGwNBQReZMGECLwwbT9nylUhNzSDt/17JyekkGlNJiE/DmJCa+YpPJSE+lZjrySTEp96Re0xOTufw4ascPnyVH3/MLGba29vQpEkFWrXyMb8aNCiHra1WVomIiIiIiIh1FKgw9dJLL+VZgPrvf//LjRs3cHR0pEWLFlSuXBmAsLAwAgICSExMxMvLq0gHo8fFxZk/51f8ubnt5piSGDurMJUVn1/sze235lXU+OI2c+bMbFsVi0t0ZCKH/go3F6Nib6QU+xwANjYGqld3p1o1d6pWdadqVTeqVMl8r1zZjYoVnfHycixSMebQISMTJhyh5SMe1Kqb80yy/KSmZhBzPYmY68ncuJbMjetJRF9NJDLCSFREIpFXjURFGEukUJeamkFAQAQBARHMm3cEABcXex56yIe2bf1o29aPNm0q4eFR9KdoioiIiIiIiBREgVdM5WbAgAHExMQwYcIE3n33Xdzd3bO1x8XF8cknnzBz5kxSUlJYvnx5kROWkjVhwgTeeust88+xsbFUqVKl0ONkZJg4f/o6B/eGc2DPFS6cuVGMWYKzsx2NGpWnfv1y1K1blnr1ylK3rhe1anne1dvV7O1tKO/tTHnvvAuRJpOJuNgUIi4ncDk0/qZXHJdD40k0Ft+TBhMSUtmxI5QdO0KBzNVkjRtXoG3bSrRrV5m2bStRtap7gVdGioiIiIiIiBSGxb/BL1iwgF9++YWpU6cyefLkXPu4ubnx4Ycf4uDgwNSpU+nYsSPDhw8v9Fxubm7mz0Zj7k8tu7Xt5pjCjH1rce12Y2d9zi+vm9tvzauo8cXNwcEBBwfLVsykpqTzz4Gr7N99mYB94VyPTiqWnNw9y+BTyY4zJ9fx8cdv8OyzD1O7tmep3YJmMBhw93DA3cOBB+pn345qMpm4cS2Zy6FxhAbFcTTgInt3HMLF5QESEoq+yspkgqNHIzl6NJK5czNXVVWp4kaHDlXo2LEKHTtWpXp1jyLPIyIiIiIiIgJFKEwtWrQIGxsbxowZc9u+Y8aMYfr06SxcuNCiwlSlSpXMn8PCwmjSpEmu/cLCwnKNKczYeRWmssZ2d3c3b+O7Of769esYjcY8t+Rlxd+aV9bPN+demHhrS01J5/DfEezdEcbf/pcxJhRtNY+NDVSt6UG9RuWo36Qc9RqVw9vXmQtnTjBu2Hq6dp1B3bq3PzustDIYDHiVc8SrnCMNH6zAA/WN7N0xlz//PEj58rU5ejSKo0cjOXYsksOHr3LmzPUizxkaGseyZSdZtizz4P/q1d3p2LGquVBVuXLJFktFRERERESk9LK4MHXq1Ck8PDwKtILHzc0Nd3d3Tp06ZdFc9evXx8bGhoyMDI4fP0737t1z7Zf1hDsfH58CHXwO2Z/Ed/z4cerXr5/v2A0aNMgz/sSJE7Rq1Srf+Fuf3JcVf/XqVSIjI6lQoUKO2PT0dPN3l9+T/+6U1NQMDu8PZ8+OMA4UsRhlY2vggfpeNGnhTcMHy1OnQVmcXeyLMdv7g8FgoFo1D6pV86BXr1rm6zExyQQERPD331c4cCCcAwfCCQ0t2jllQUGxLF58nMWLM/9O167t+X8rqdIAlyKNLSIiIiIiIvcXiwtTGRkZ3Lhxg2vXrt22CHTt2jViYmJue8B3XpydnWnbti27d+9m48aNvP322zn6mEwmNm3aBECXLl0KPHbdunWpWrUqISEhbNy4kb59++bok5CQwO7du3Mdu127djg5OZGYmMjGjRtzLUwFBwcTGBiYa3znzp3Nnzdu3MiLL76YI37Pnj3mQ88Lc2/FyWQycebkNXZuCmH31lDiYiw/vLxqDXeatKhAk5beNGpWQYWoEuTh4cDjj1fl8cermq9FRCRw4EA4f/99hb17L/PXX1dISLD8aYHnzt3g3Lkb//fTVOZMC+Lh9iYefKgi9RuXw76MbdFuQkREREREREotiw/padKkCSaTienTp9+274wZM8jIyKBx48aWTsfgwYMB2LFjB/v378/Rvnr1ai5cuABkPkWwMLL6r1y5kqCgoBzt3377LfHx8dja2jJw4MBsbS4uLvTp0weAuXPnEhMTkyP+k08+ATJXjvXu3TtbW82aNWnXrh0As2fPJjU1Z4Hg3//+NwDVqlXj0UcfLdS9FZfPpwfzzis7WP/b+UIXpcqUsaHlIz6MGt+Mhb9356tlnRk+5kEealdJRSkrqFjRhSefrMX06e3YurUfN26MJiDgRb766nH69auLn5/r7QfJR1hIMr8vP8OUf+1mYPf/MX28P2tXnSX0Yiwmk6mY7kJERERERERKA4sLU6NGjcJkMvH1118zZMgQc1HoZhcvXmTo0KF89dVXGAwGXnvtNYsTHTx4MI0bN8ZkMtGnTx+2bdsGZK7cWr16NSNGjACge/fudOrUKVvs1KlTMRgMGAyGXAtP48ePx8fHB6PRSM+ePQkICAAgJSWFuXPnmg93f+WVV6hTp06O+OnTp+Pi4sKVK1fo1asXZ8+eBTJXWk2fPp158+YBMGnSJLy8vHLEf/rpp9ja2nLkyBH69+9vPk/q2rVrvPbaa2zYsCFbv1slJycTFRVlfsXHx5vbbr4eFRVFRkZGPt9y3qIjC7eipmx5R7o8VYP3P3mEZet7MenTtnTtXTPfp9GJddjZ2dC8eUVGj27OL7/0IjR0JEFBI1i+vCcjRzalTp2cf2cLKiU5nUN/RfDDV0cZ/eIWhj+7ga8/PsjuraHE3kguxrsQERERERGRe5HFW/kGDhzItm3b+PHHH1m6dClLly6lSpUq+Pn5YTAYuHTpEqGhmY+gN5lMvPTSSzlWGxUqUTs71q5dS8eOHQkKCuKJJ57A2dmZjIwMkpIyn/7WrFkzli9fXuixPTw8+OOPP+jatSsnT56kZcuWuLm5kZSUZF7B1KVLFz7//PNc42vUqMGqVavo27cvu3fvpk6dOnh4eBAfH096euaT0l5++eVctyACtGnThnnz5jFq1Ch+//13fv/9dzw9PYmJiTGvMPnggw/o169frvE///wzQ4YMybXt1jOrLl68SPXq1W/7nViinLcTj3Two23HytRpWBYbG0OJzCMl6+bzqgYMyDxzLSwsjp07Q9mxI5QdO0K4cCHnysCCiI5MZNv6YLatD8ZggFp1vWjRxocWrX2oVc8LW9v7/O9M322QkQY2Fv+nWURERERE5J5SpN9+fvjhBx588EGmT5/OtWvXCAkJISQkJFsfLy8vJk+ezL/+9a8iJQpQvXp1jh49ymeffcbvv//OxYsXsbe3p2HDhrzwwguMHj2aMmXKWDR2ixYtOHHiBJ988gl//PEHoaGhuLi40KhRIwYPHszQoUOxscl7gVmPHj04evQon3zyCVu2bOHy5ct4enrSvHlzRo4cad7ul5fhw4fTvHlzZs+ezZ9//klkZCTe3t60adOG0aNH8/jjj1t0XyXNXIx6vDJ1GqgYVVr5+bkxcGADBg7MPPw/JCSWHTtCzMWq4ODYQo9pMsG5U9c5d+o6vywOxN2zDM0ezixSPfiQN+4eDsV9G3e/snWtnYGIiIiIiMgdZTAVw6EvycnJbN68mYMHD3L16lUAvL29admyJZ07d8bR0bHIiYp1xMbG4uHhAcwAMv8cnV3saNOhMh26VqXhg+XvSDHq/OnjjBv2FAEBATRv3rzE58vPoUOHaNGiBbMXraVW3Ua3DyhBd8v3cv78DRYt2s3Mmb/i6NSUpETLtoxmsbGBOg3L0aK1Dy3a+FDjAQ8MhoL/PbtbvhcREREREZH7UVYtISYmBnd393z7Fst+EQcHB3r16kWvXr2KYzi5CxkM0KKNDx26VqVVu0o4OFjnSWtZTze0prshh7tNrVqePPecHzNnLmX6l/8lI70Sh/+O4J8DEZw9eY3CHm2WkQGnjkVz6lg0yxecwKucI83/r0jVtKU3Lq46NF9ERERERKQ00EEmUiDvflyD1u0fsdr816MjMdjYMGjQIKvlIAVja2ugToNy1GtcjheGNSA+LoVjhyL55+8IDv8dwdUrxkKPeT06iW3rgti2LghbWwP1m5SnRZuKtGjtS5UaboVaTXVXC1wBqUawd4b6A6ydjYiIiIiISIlTYUoKxM3Nun9VEuJjMWVkMHbKHCpXq23VXAL+2smKBXOsmsO9xNWtDG0e86PNY36YTCbCwxI4vD+CQ/vDORoQSUpyeqHGS083cfxwJMcPR7Lku+NUqOicWaRq40uTFhVwcLyH/7O26x2IDwNXPxWmRERERETkvnAP/wYn96PK1Wpb/VynS8HnrTr/vcxgMOBb2RXfyq706FOLlOR0TvwTScC+cA7uCyc8LKHQY0ZGGNm45iIb11zEvowNjZtVoGotE1C2+G9AREREREREipUKUyJiNWUcbGn2sA/NHvZh+Bi4HBpHwL5wAv4K5/jhKNJSC3c4VWpKBof2R3BoP8AEnn32L/r0iaFHj5q0b1+ZMmWsczaaiIiIiIiI5E6FKRG5a1Sq4kalKm706vcAicY0jh26yqG/wjm4N5yoq4mFHi842MicOQHMmROAq6s9nTtXp2fPmnTvXoNKlVxL4A5ERERERESkMFSYEpG7kpOzHQ+1q8RD7SphMpkIvRhHwF9XCNgXQeDRKNLTTYUaLz4+lf/85yz/+c9ZAJo186ZHj5r07FmThx7ywdbWpiRuQ0RERERERPKhwpSI3PUMBgNVa7pTtaY7zwyoS0J8KkcORJi3/d24llzoMQ8fvsrhw1f56KO/KFfOiW7dqtOjR026datO2bJOJXAXIiIiIiIicisVpkTknuPias8jHSvzSMfKZGSYuHDmRmaRal84ZwOvYSrcYiqioxNZvjyQ5csDsbEx0Lq1Lz171qRHj5o0bVoBg8FQMjciIiIiIiJyn1NhSkTuaTY2BmrX86J2PS+eH1KfG9eT2LQmgJ8XbcTNrSVxcWmFGi8jw8TevZfZu/cy77/vT6VKrvToUYOePWvyxBPVcHUtU0J3IiIiIiIicv/RoSoiUqp4ejnS8hEPYDlbt7Zj167+vPfeQzRpUsGi8S5fjmfhwmM888x/KVfuWzp3Xs0XXwRw5sy14k1cRERERETkPqQVUyJSatnZ2fDQQ5Vp374yM2c+SmhoLOvXX2T9+gts3RqM0Vi41VQpKels3RrM1q3BjB27g9q1PenRoyY9etTgsceq4OhYxP+kuvhkfxcRERERESnlVJgSkftGlSrujBzZlJEjm5KUlMauXZdYt+4C69Zd4Pz5G4Ue79y5G3z11SG++uoQzs52dOpUja5dq9OlS3Vq1/Ys/NlUgw4WOgcREREREZF7mQpTInJfcnS0o0uXzCLSl18+zpkz11i//iLr1l3gzz9DSU3NKNR4RmMa//vfef73v/MAVKvm/n/jV+Pxx6vqSX8iIiIiIiK5UGFKRASoU6csdeqUZcyYFsTHp7B1a7B5219YWHyhxwsOjmXBgqMsWHAUGxsDrVr50KVLNTp3rk7r1r7Y29uWwF2IiIiIiIjcW1SYEhG5hatrGXr3foDevR/AZDJx9Ggk69ZdYP36i+zbd5mMDFOhxsvIMLF//xX277/CjBl/4eZWho4dq5hXbFm07U9ERERERKQUUGFKRCQfBoOBpk29adrUm4kTWxMdncjmzUGsW3eBjRuDiI5OLPSYcXEprF17nrVr//+2vyeeqMa7LRZRuVwqTl7e0Pn74r4VERERERGRu44KUyIihVCunBMvvFCfF16oT3p6BgcOhLNu3QU2bLjIoUMRmAq3mArI3Pa3aNExpvpuxskYw5VAT96c34GWLb1o2dITL68yxZJ7+fLlqVq1arGMJaVbSEgIUVFR1k4D0N9bERERkdJOhSkREQvZ2trQunUlWreuxIwZ7YiKMrJtWwibNwexeXMwly7FWTRuepqJX38N49dfw/7vyhXgHHD+/15JFo3r7OxMYGCgfsmXfIWEhFC/fn2MRqO1UwH091ZERESktFNhSkSkmJQv78zzz9fj+efrYTKZ+P13f557bgI1HuhNWLCBlBQLllMB4Pt/r/YYDOBX1YHa9ZypUceZmrWdcHa9/UHql4LP8fn0t4iKitIv+JKvqKgojEYjY6fMoXK12lbNRX9vRUREREo/FaZEREqAwWCgRg0XYA9vvPcuVWvU59Txaxw5EME/B65y/vR1i7b9mUxwKTiZS8HJ7Nx0HYCqNdyp36QcDZqWp36Tcnj7uBTvzch9qXK12tSq28jaaYiIiIhIKafClIjIHWBfxpbGzSvQuHkFBo2E2BvJHA24yuG/r3I04CqR4ZZvmwq5GEvIxVg2/fciAOW9ncxFqgZNy1Oluntx3YaIiIiIiEixUmFKRMQK3D0daNepCu06VQEg4nICLhc/AcDGxlCksaOuJrJrSyi7toQC4OpmT9WaZYCO/P33NR54IAU3t+I5UF1ERERERKQoVJgSEbkLVKzkgmO4HaSAVzlHvl3RhWOHIjl2KJLjhyKJuZFs8djxcamcPJIK9GDUqH947bV/aNiwPA8/7Gt+NWxYDltbm+K7IRERERERkQJQYUpE5G5jAL+qbvhVdaNb75qYTCZCLsZyLCCzUHXin0ji41ItHt5kguPHozh+PIpFi44B4OJiT6tWPtmKVZUquRbXHYmIiIiIiORKhSkRkbucwWCgWk0PqtX04Mm+tcnIMBEaFMvJI1EEHo3m5JEooq4mFmmOhIRUdu4MZefOUPO1ypXdaNGiIs2be9O8eUWaN6+Ir68LBkPRthqKiIiIiIhkUWFKROQucalcL8qkxZBi55FvPxub/1+o6v5MLQAiw42cPBpF4NEoTh6JJuRibNHzuRTHpUtx/Pe/58zXKlZ0plmz/1+oat7cm+rVPVSsEhERERERi6gwJSJylzhZbYLFsRV8nHnMpyqPdakKQFxsCoFH/29F1dEozp26Tnqaqcg5RkQY2bgxiI0bg8zXPD0daN68Is2aefPgg940alSeevXK4uio/4kREREREZH86bcGEZFSyM29DA+1q8RD7SoBcPr4Ud59dTTjx3/N5ct27N9/hfPnbxTLXDduJLN9ewjbt4eYr/2/9u48vqkq7x/4J2mWJt33QpEWBMqqI6jzjMAAIiDqaMUdmIdFHYZxGRnB+bk8LD6Do4j4OCouqCAjyuKCGwqCLALiQnUUKFtbWkrpmm5ptiY5vz/SXJJmabrQJPTzfr3uKzf3nHPvuffk3jTfnntuRIQM/fsnYOjQZAwdmoxhwxyvF18cz0HWiYiIiIhIwsAUEVE3oFDKAZzGXXddhOHDhwMAKisN+P77s/juu7M4cOAsvv++DHV17X/6nyubTeDoUR2OHtXh/fePS8sjIxUYPDgJQ4cmSUGrgQMT0bt3LANWRERERETdEANTRETdVEqKFtdffzGuv94xTpXdLnD8uA7ffecIVuXmVuA//6mEyWTttG2aTFbk5pYjN7fcbblaHYH+/ROQnZ2A7OxEDByYiOxsxxQXp+607RMRERERUWhhYIqIKERc/fM1iGyqgEmZiq9/s73Lty+XyzBwYBIGDkzCjBlDAQBWqx1Hj1YjN7cCP/1Ugdzccvz0UwUaGiydum2z2YZDh6pw6FCVR1pamlYKUg0cmIj+/RPQt28c+vSJg1ar7NR6EBERERFR12JgiogoRCjsBihtelgjooNdFYlCIcfQoSkYOjQF//3fQwA4elbl59dKQSpHD6gKVFcbz0sdyssNKC83YM+eEo+09PQoXHxxPPr2jUPfvnHN84736elRfFogEREREVGIY2CKiKgbycvL67R19e8P9O8fjdtvj4YQfVFRYUZ+fiNOnmxEfr4eJ082orCwEWazvdO22VJZWSPKyhqxb98ZjzSNRiH1rMrMjEXv3s4pBr17x6JHjyhERMhRXFyMqirPnlpdzWw2Q60O/m2LnfkZoQtfqJw/AJCcnIzevXsHuxpERETURgxMERF1AzXVlZDJ5Zg+fXoXb1kGIAlAeospGUDEed2y0WjF4cPVOHy42mu6QiFHenokSkuPwG7XAagBUNs81TVPhvNaR1dyuRx2+/kL4hF1tuLiYgwaNAgGQ9edJ/5otVrk5eUxOEVERBRmGJgiIuoGGvX1EHY75i1cgV6Z/YJal5Kik3j+yUfw3nvbIZOl4dgxHY4dq2l+1UGvb+qSelitdpSUGABkNU+eIhQyxMUrEBsfgbh4JWKleQXiEprfxykQqenYEwUPHtiFd1etCIn2cdaFqDVVVVUwGAwh8bl1XFf+hqqqKgamiIiIwgwDU0RE3UivzH64OHtosKsBwIoBA2IwfPhAt6VCCJSW6t0CVc7A1alTdRCia2tpswroqpqgq2oCYPKZL1KjQFJKJBKTNYhPUCMuMRJxCWrEJ6oRnxApvcYlqKFSe/YUKynKBxAa7eOsC1GgQuFzS0REROGLgSkiIgoZMpkMGRkxyMiIwdVXu/d6MJmsyM+vRUFBHQoKat3mCwrqYDbbglRrwGS04kyxHmeK9a3m1UYpHEGqRDXiEyMRn6BGrc4O4L/wa24DmizViIlTITZejahoJeRyDuBORERERBcuBqaIiCgsREYqMGRIMoYMSfZIs9sFzp7Vo6CgrjlgVSvNFxXV4+zZxiDU2DtDoxWGRj1KS1oGsW7BmpdLAZRKS+QRMsTEqhDbHKiKiVMhNk6NuHg1YuId88602Ob36sgIPo2QiIiIiMIGA1NERBT25PJzPa1Gj+7lkW42W3HmjB7FxfUoLm6QXg8dKsG33+ZBpUqHxdLF9wkGwG4TqKsxo67GDKAhoDIqlRwx8c3Bq+ZAljNo5f29CkrV+R2InoiIiIjIFwamiIjogqdWK9C3bzz69o13W56bm4sRI+7GUys/RlrPbFSWG1BVboCuyoTqSiN0VSbUVDleddVG1NdagrMDbWCx2FFdYUR1hTHgMpEaBWLjVYiJVcFqtQG4C5vfq8BFWXluwayY5h5aMbEMZhERERFR52BgiogoRPynz/8iwm6GTa4OdlW6HZnMcctcTKwKffvH+8zXZLFBV21CTZUJOmfAqsqI6ubXmmoT6nRmNNSHfgDLlclohcloRcVZQ/OS4fhmew2AGp9lNFqFI0jlDFbFnwtaxTrnXXplxcSpoVR27OmFRERERHThYWCKiChElCeMD3YVqBVKVQTSekQhrUeU33xWqx31tWbU6syo1ZlQW9P8qjOjrsb5akZtjQn1tWbY7V20A53IaLDCaLCiXApmtU4bpZACV86eWFKPrObgliPdscxmDb3bK4mIiIioczEwRURE1MkUCjkSkzVITNa0mtdmE9j2ycd47bllmPPw84iO6Ym6WjMa6iyorzWjXno1o77WgoY6M6xhGrBxDPzetmAW8CRuvHE/MjKOIDlZg+RkDZKSNNJ8y/eJiZFQKnmbIREREVG4YGCKiIgoiCIiZNBGyQCUYcDgKFycfZHf/EIIGA1WR/Cq1uIIWNVZUF9jPjdf50hzBrjC7dZCdxqcOWPCmTNlAZeIi1NLgaqUFA3S0qKQlqZFaqoWaWlRza+O90lJGsjlfIohERERUbAwMEVEFCLi9L9CLppglylRFz0s2NWhECWTyaCNUkIbpUSPjMDK2Kx2NDRYHL2w6ixoaO6J1VB3LrDVUOcIYpWf1aFWZwCgPa/7cT7V1ZlRV2dGfn5tq3kjImRITm4ZvPIexEpN1UKt5p9ORERERJ2Jf10REYWI3x6fA42lDEZVOrYN3x/s6tAFJEIhR3xCJOITIlvNu3vbx3j+yUVY9vrHSO3R361XlhTIar6lsGVwy6Bv6oK96Vw2m0B5uQHl5YHdXhgXp0ZamjNopXELXqWlRaFHD8eUnh7FIBYRERFRAPgXExEREXmIiJAFHMxyslrt0NdbUF/r3hNLem1eLvXcqjPD0Gg9j3vR+Zy9sY4f9/3EQqfExEikpzuDVdFuQSvXZTExKshkvJ2QiIiIuicGpoiIiKhTKBRyxCdGIj4x8GBWU1NzMMulJ5YzcHX6VCn2fLUdI0dOhMWiRFWVEVVVRjQ0hMeYWTqdCTqdCUeOVPvNp9UqmoNV54JXPXpEIz1d67YsOVnL8bCIiIjogsPAFBEREQWNUilHQlIkEpI8g1n5x6zY89V6/OtfCzB8+HBpucViQ3W1UQpUVVUZvb6vrDSiosJxm57FYuvK3WoTg8GKgoI6FBTU+c0XESGTbhfs2TMaGRnR0uu5KQbx8Wr2wCIiIqKwwcAU0QUgLy8v2FUIiTq0FOw6BXv7RBcqlSqiuSdRdED5hRCor7egvLxRClQ5Xlu+dyyrD9GnGNpsAqWlepSW6nHwYLnPfBqNQgpUnQtcxbgFsHr0iIZKFdGFtScib4qLi1FVVRXsagAAkpOT0bt372BXg4g6KFSuK3q9PuC8DEwRhbGa6krI5HJMnz492FUJKTwuRORKJpMhLk6NuDg1BgxIbDW/yWRFRYV78OrYsVI899xrsFojAUQDiGl+jQIgP7870EZGoxUnT9bi5Mlav/lSUjQeASvne2dAKzExkr2viM6T4uJiDBo0CAZDYA9fON+0Wi3y8vIYnCIKY6F2XQkUA1NEYaxRXw9ht2PewhXoldkvqHU5eGAX3l21Iqh1cAqV4xJKx4SIAhcZqUDv3rHo3TtWWpab24RnnvnI47pitwsYGm1oqLOhvs6Khjpr86sN9bWO+fo6KxpqrTCbRTB2x6fKSsftjj//XOEzT2Sko/dVr17RuOiiWFx0UYw0r9c3ANBCiNDaL6JwUVVVBYPBEPS/VwCgpOgknn/yb6iqqmJgiiiMhdJ1Jf/4Iax85rGA8jIwRXQB6JXZDxdnDw1qHUqK8oO6fW+CfVxC8ZgQUcd05LpiNFhRqzNBV21CTZUJNdVG1OrMjvfVRtRUm1BTbUJ9bejcSmgyWZGfX4v8/FofOZbg0b+cQEpqKZJSNUhO1SA5VesxHx2jZM8rIh+C/fcKEV14QuG6YjIG3muLgSkiIiKiLqDRKqDRRqNHL/9jY1mtdtTqTFKgqqbKhBqX92fP1OB0YTnk8jjY7V1UeT+aLAKlJXqUlvgeS0IdGeE9aJWiQXKaY14bpWDwioiIqBtiYIqIiIgohCgUciSnapGcqvWann/sEB6++wF8++0P6NVrIM6cacCZM3qXyfG+tNTxPhQGczebbDhTrMeZYt/Bq0iNojlIpUFSitYRvErTIDnFEbhKTtNAo1V2Ya2JiIioKzAwRUQUIr6+dBsgBMAeA0QUAIVCjp49HQOVX3GF73x6vcUjaOUauDpzRo+zZ/Ww2YI7VpTJaEXJqQaUnGrwmUcbrWzubdUcrErVIDlNC4u5EUAyzGZb11WYiIiIOgUDU0REIcIa4f/2HiKi9oiOViE7OxHZ2b6fSGiz2VFRYfAStGpASYkep0834PTpehgM1i6suSeDvgnF+iYUF9R7Sf07rrpqN5KTv0fv3o6B2r1NPXtGQ6mM6PK6ExERkXcMTBERERF1cxERcvToEY0ePaJx+eXe8wghUFNjag5U1WPfviP45z9fxuVXTYHZpEZVhQHVFUZYLMEd+KqqyoiqKiNyc8u9pstkQI8e0T4CV46AVnp6FORy9l4lIiLqCgxMEREREVGrZDIZEhM1SEzU4JJLUtCjRx3++c+tuOvu+6Qn/wgh0FBnQVWFEVUVBlRVGFFdYURVpRFV5c3vK42wNgUveCUEUFrq6BX23XdnveZRKOTIyDgXvPLWAyspScPB2omIiDoBA1NERCHi4rNvQGHVw6qIRn6Pe4JdHSKiNpPJZIiNVyM2Xo2+A+K95rHbBerrzKgqdwSvqiuNzfOOoFVVhQG6SiOs1uCNeWW12lFUVI+iIm+3DDpoNAr06uX9dkFn76u4OHUX1pqIiCg8MTBFRBQiLj77FjSWMhhV6QxMEdEFSy6XIT4hEvEJkeg3MMFrHrtdoFZnag5Unett5doTq6bKCHsQ7xo0Gq04caIGJ07U+MwTE6PyGrRy9sDq1SsGWj5pkIiIujkGpoiIiIgopMjlMiQma5CYrEH/Qd7z2Kx26KpNqK4w4tDPx/DOa6tw551/htmswenT9Th9ugHl5YaurXgLDQ0WHDlSjSNHqn3mSUrS+Ol1FYOMjBioVBysnYiILlwMTBERERFR2IlQyJGSpkVKmhZKVSzeeW03FixYgeHDh0t5zGYrzpxxPFWwuLi++emC7lNNjSmIewFUVxtRXW3Ezz9XeE2XyYC0tCi/g7X36BGFiAh5F9eciIioczAwRUREREQXJLVagb5949G3b7zPPI2NFq8BK8fkCGbp9U1dV+kWhADKyhpRVtaIH34o85onIkKGnj2jpdsEMzKi0bOnc4pCz57R6NEjClFRqi6uPRERUesYmCIiIiKibisqSoWBA5MwcGCS13QhBOrqzD6DVs7JbLZ1cc3PsdmEVI/9+0t95ouNVbkErBxBqx49zgWvnAEsjYbjXhERUddhYIqIiIiIyAeZTIb4+EjEx0di2LAUr3mEEKisNPjteXXmjB42W/CeNAgA9fUW1NfrcPSozm++hIRIr0Grnj2jkZ4ehbQ0LdLSohAdrYRMJuui2hMR0YWKgSkiIgqKvLy8YFchJOpArQuFdgqFOrQU7DoFe/veBLtOMhnQuzeQlmbGyJExAGKkNJtNoLragvJyE8rKzCgvN6G83Oz2vrraAhHc2BUAoKbGhJoaEw4f9j1oOwCo1XIkJamQlKRCYqL7a8tlmZlpyMzM7KI9ICKicMLAFBERdama6krI5HJMnz492FWhEMfPinc8Lp5C7ZjI5XLY7fZ2lIwAEAsgHkBc82t8i/fRnVDDzmE221FaakJpaSADyFvQq1cCMjJipR5XaWlapKdHISVFg+RkLVJSNEhJ0SIpKRJKJZ9ESETUXTAwRUREXapRXw9ht2PewhXoldkvqHU5eGAX3l21Iqh1IN/4WfEuVI4Lj4l3zuNyvupiMdtRV2NFja4JtTor6mocr46pCbU1VpiM7QmKnW8qlJQ0oqSkMaDc8fFqJCc7AlWOV42X91ppeUyMircVEhGFKQamiIhCRG3UEBhVPWBWJga7Kl2iV2Y/XJw9NKh1KCnKD+r2KTD8rHgX7OPCY+Kd87gEsy4moxU11SZ8/cV2bHr7bdx4xzzI5fHQVZmaJyNqqk0wGqxBqV8gamvNqK014+TJ2oDyq1QRbgGspCQNEhIikZjoObku50DvRETBx8AUEVGI+D57VbCrQEREF4BIjQI9ekWjV6YMwH8wZmKi1yCZ0dDkHqyqMkFX7Xx1LKuuNMESxCcOBspisaG0VI/SUn2bykVGKrwGrLwFsuLi1IiPV0uvajV/ShERdQZeTYmIiIiIuiGNVomM3kpk9I7xmUcIAUOjFboqI3RVJtTqTKirMaNWZ0JtjRm11c2vzcuD/eTBtjKZrO0KaAGAWh3hFqjy9+ptmd0eXseKiOh8YWCKiIiIiIi8kslkiIpWIipaiYuyYv3mtdsF9A0W1OnMqNGZUKszo7bGhFMnS/D1li8xcuRkGI0KlJc3oqLCgKamUBwLK3Bmsw3l5QaUlxvaVd4xJNaT+N8F+YiNOwuNVoFIrQIarQLaKCU0WgU0Gse8c7lbmlYBjVYJbZQC6kgF5HKOsUVE4YmBKSIiIiIi6jC5XIbYODVi49S4qM+5IFb+MTO+3rIJ//rX/8Pw4cMBOHpi1dSYUF5uQFWVEZWVzlejl/cGVFYaYTSG7phY7SEEAGiaB66v7/D6IjUKaKPOBaw0WgU0Uc3zmnNBLbUmAhqNI5gVqYlApEaBqgojgDSUlhpx0UUGREU5ynBAeSLqCgxMERGFiCuP3Qt1kw5mZSLHmyIioguaTCZDYqIGiYmagMsYDE2tBLDOva+pMUGnM4V9r6y2MBmtMHUoeDcff/jDtwC+BeDo0RUVpURUlBLR0armV6XHsqgohcv8uTyuy7RaBbTNATKtVgGNRskeXkQkCbvAVENDA5577jl88MEHKCwsREREBAYMGIA777wTDzzwAFQqVbvXXV5ejmXLluGzzz5DcXExNBoNhgwZghkzZuDuu+9u9T8G+fn5WLZsGbZt24azZ88iNjYWl112Gf70pz/hlltuaXX7ubm5WLFiBXbt2oXKykokJibiv/7rv/DAAw/g6quvbrX8zp078a9//QsHDhyATqdDSkoKxo4di7/97W/Sf6eIKHTFNx6GxlIGoyo92FUhIiIKOVqtEpmZccjMjAsovxACjY1N0OkcQSpnsMoxGX0sd0yNjU3neW9CnxCAXt8Evb6p3bcr+qNSRTQHqVoGrc6995fmDHD5SouMVECtjkBkpAIqVQQDYUQhLKwCU0VFRRg7dixOnToFANBqtTCbzfjxxx/x448/Yt26ddixYwcSEhLavO6DBw9i0qRJqK6uBgBER0ejoaEBe/fuxd69e7Fp0yZ88sknUKvVXstv2bIFt912GwwGx0U7NjYW1dXV2LZtG7Zt24ZZs2bhzTff9BnceuONNzB37lxYrY7/csTFxaG8vBybN2/G5s2bsWjRIixevNhn/RcvXowlS5YAcPwHKjY2FmfOnMG6deuwYcMGvPLKK7jnnnvafFyIiIiIiMKRTCZDdLQK0dEq9O7tf3ysliwWm0fAqq7OLE21tf5fL7TbDs8Hi8UGi8WG2lpzl2xPqZRLwSrn5Po+kPmW71WqCCiVciiVzle53/cKhf88EREy3j7ZBkII2O0CNpuAzWaHzeb5/tyyc++7Pq8ddjvc3vtbR1vyttxeXV0DgPvwwtIiqFQVsNsF7DYBgXMPW5DB5TPWPOv6sfP2GfSW7rpMLpdBLpdBJr0CBn1VwG0ZNoEpm82GP/zhDzh16hR69OiBtWvX4pprroHdbsemTZtw77334qeffsK0adOwZcuWNq27rq4ON9xwA6qrqzFw4ED8+9//xuWXXw6LxYJVq1Zh3rx52LZtG+bNm4eVK1d6lC8sLMTtt98Og8GAkSNH4q233sKAAQOg1+vx7LPP4sknn8Tq1asxcOBAPPLIIx7lv/32W/z5z3+GzWZDTk4OXnzxRfTq1QvV1dV4/PHH8dprr2HJkiUYPHgwbr/9do/yGzdulIJSc+bMwdKlS5GUlISSkhI88MAD2Lx5M/785z9jyJAh+N3vftemY0NERERE1N2oVBFIS4tCWlpUu8pbLLZWAlgmnDhRgvXrN2PIb8ZCHqGByWCFsXkyNDbBZLQ2j0NFnaGpyY6mJgsaGoJdE/+cgSqFQi792I+IkLnMyyGXw2XePY97Xu/lvAUehI8Pm6/PoLf8QjgmZwDFbj8XNHHOt/a+LWl8sqUvWSguMAEwBbkegW8/bAJTa9aswa+//goA+OCDD6QAi1wuxx133AG73Y6pU6fiiy++wI4dOzB+/PiA1718+XKUlZVBo9Fgy5Yt6NOnDwBApVLhvvvuQ319PR577DG8/vrreOihhzBgwAC38gsXLkRjYyPS09Px2WefIT4+HoCj19WSJUtQVlaG119/HUuXLsW9997r0aPrkUcegc1mw7Bhw7Bx40YolUoAQFJSEl599VWcOnUKW7duxSOPPIJbbrkFERERUlmbzSYFuyZNmoRXX31VSuvVqxc2bNiAyy+/HL/++iseeeQRfPPNNwEfFyIiIiIiajuVKgIpKVqkpGh95snNzcX69Rsw+4FpuDh7qEe63S5gNtlgNDRJASvnvKHR2mK5FcZGl/dGR3DLaLDC1Bzostn4Iz4cOAJo3WdsNCIgjAJTb7/9NgBg3LhxXnv93HnnnXj88cdRWFiItWvXtikwtXbtWmkdzqCUqwceeABPPfUU9Ho91q1bJ/VOAoDGxkZ88MEHAIC5c+dKQSlXjz76KF5//XXU19dj8+bNmDVrlpRWUFCAvXv3AgDmz58vBaValt+6dSuKioqwZ88ejBs3TkrbvXs3ioqKAACPPfaYR1mVSoWHH34YM2fOxN69e1FQUIC+ffsGcliIiIiIiChI5HJZ8xP2Ov6TTQiBJovdEagyWWE22hyDpZscA6YXFZzCutf/hYcffgwJCWlobGyCXm9BY2NT83yTz2Vms60T9paIurOwCEwZDAbs27cPADB58mSveWQyGa699lq88sor2LZtW8DrPnbsGIqLi/2uOzo6GqNHj8YXX3yBbdu2uQWm9u7dC6PR6Ld8VlYWBg0ahLy8PGm8KaevvvpKmr/22mu9lh81ahRiYmLQ0NCAbdu2uQWmnOVjYmIwcuRIr+Vd6/XVV19hzpw5XvMREREREdGFRyaTQaWOgEodgTh4jpmblKLDute/x9SpF7X5oUlWq90lWOU9mGU0NvficvbmMjS1eG253OpSpoljdhFd4MIiMJWXlwe73dGdcehQz26uTs60srIy6HQ6JCYmtrruQ4cOeZT3te4vvvgCR44c8Vl+yJAhfsvn5eXh8OHDXsunpqYiNTXVa9mIiAgMHDgQP/zwg8/ygwYNcrvFz1VqaipSUlJQWVnpUZ6IiIiIiKi9FAo54uLUiIvz/pCoziCEgMnkK7hlhdHY5BHMMplsMJutza+OebPZJi0/N+8/n8lk41hG1CUiIhxjgbmOF+Z875w/t9x7XrPZiLy8w8i8eAC02ijIm9Odw4q5fZKb37gOF+Zr7DCPdJdldiEg7HAb+0sIAUOjHZVlge17WASmSktLpfmMjAyf+VzTSktLAwpMtXXd9fX10Ov1iI6OdiufkJAArdb3PeTO8q7bc33vb9vO9B9++KFD5SsrKz3KExERERERhTKZTAaNRgmNRokAfuJ1OqvVLgWsHEErx7zFYkdTk00aF8ox2WC12j2W+Xp/Lq97Hufg4d4G/3Zf5hxkHD4HHG8535rWHgzo78mBjsHWfQ/OHui898HbHetuud7OCOi0PW/L5W3Je257rvvWGXJzczFixJ/x4GOfeB27risd/vl7PH5/YHnDIjDV4PLoBH/BH9e0hgAft9DedTsDU87y/sq6presV7DLt2Q2m2E2n3tka11dHQCg8OQRX0W6REnRSQBA/vFDMBkNrAvrEhZ1aWs9Lm8wI0YADWYzDv/8fVDrcj6xLqFbD9aFdQnHerAuoV+XM6cLAAAHDx6EXq8PWj2c5HK5dDdGMB07dgxA8NsHYBt1Vj0UCsfUzq01T51Tl/MpNOsi0KI/0HkhBGC1Oibv9QiuULquOGMIvp746EaEgXXr1jk/ZeLEiRM+823btk3Kt3///oDWvXTpUqlMU1OTz3yvv/66lK+0tFRafu+99woAIiMjw+92HnvsMQFAqFQqt+UTJkwQAMTIkSP9lp86daoAIAYMGOC2vH///gKAmDZtmt/yV111lQAgJk6c6DffokWLpP3kxIkTJ06cOHHixIkTJ06cOHFq73T69Gm/MQghhAiLHlMxMTHSvMHgO+rnmuZapi3rjo2NbdO6nfP+6uWa3rJewS7f0qOPPoq//e1v0nu73Q6dToekpCS/XTYpvNXX1+Oiiy7C6dOnfZ4DFP7Yzt0H27p7YDt3H2zr7oNt3T2wnbuP7tzWQgg0NDSgZ8+ereYNi8CU646cOXMGl1xyidd8Z86c8VqmLev29WFxrjs2Nla6jc+1fE1NDQwGg89b6pzlW9bL+d617m0tn5ub2+7yLanVaqjV7gMXxsfH+y1DF47Y2Nhud8HsjtjO3QfbuntgO3cfbOvug23dPbCdu4/u2tZxcXEB5fN9E2sIGTRoEORyR1Vdn4LXkjMtPT09oIHPAfcn8QWy7sGDB/ss7++Jd87yLZ/c5yxfUVGByspKr2VtNhuOHj3qt3xeXh5sNpvX8q7r9vfkQCIiIiIiIiKirhQWgSmtVouRI0cCAL788kuveYQQ2Lp1KwBg4sSJAa87OzsbvXv39rvuxsZGfPPNN17XPWrUKGg0Gr/li4qKkJeX57X8hAkTpHlf5fft2ycNWu6rfENDA/bv3++1vOt6XbdHRERERERERBRMYRGYAoAZM2YAAHbu3InvvvvOI33Tpk0oKHA8TeK///u/27RuZ/7169fj1KlTHukvv/wy9Ho9IiIiMG3aNLe0qKgo3HLLLQCAV155RXqKnatnnnkGgGN8p5ycHLe0vn37YtSoUQCA5557Dk1NTR7ln376aQBAZmYmfv/737uljRkzBpmZmW75XDU1NeG5554D4Aii9e3b1yMPkVqtxqJFizxu46QLC9u5+2Bbdw9s5+6Dbd19sK27B7Zz98G2DlCrw6OHiKamJjFs2DABOJ6At337diGEEDabTWzcuFHExsYKAGLy5MkeZV2fNFdYWOiRXltbK9LT0wUAMXjwYPHjjz8KIYQwm81i5cqVQqVSCQBi7ty5XutWUFAgoqKiBAAxevRocfz4cSGEEHq9XixZskTIZDIBQDzzzDNey+/fv19EREQIAGLKlCmipKRECCFEdXW1mDt3rlT3DRs2eC2/YcMGKc/cuXNFdXW1EEKIkpISMWXKFAFAREREBPykQiIiIiIiIiKiriATQohgBMTa49SpUxg3bpzUq0mr1cJut8NkMgEALrvsMuzYsQMJCQlu5RYvXowlS5YAAAoLC5GVleWx7oMHD2LSpEmorq4G4OjdZDKZpB5MEydOxCeffOIz0rllyxbcdttt0tPv4uLioNfrpXGfZs6cibfeesvnk+3eeOMNzJ07F1arFYBjwPG6ujo4m2fRokVYvHixz2Pjuo8ymQxxcXGora0FACgUCrzyyiu45557fJYnIiIiIiIiIupqYXMrHwBkZWXhl19+wcKFCzF06FDIZDIolUqMGDECy5cvx4EDBzyCUoEaMWIEDh8+jHnz5qF///5oampCVFQURo0ahVWrVuGLL77w2/3uuuuuwy+//IJ7770XWVlZMBqNiI+Px4QJE/D+++9j9erVPoNSAHDPPffgu+++w9SpU5GRkQGDwYDU1FTk5ORgx44dfoNSgCMwtWPHDuTk5CA1NRUGgwEZGRmYOnUqDhw4wKAUEREREREREYWcsOoxRUREREREREREF46w6jFF1F1UV1dj9erVmD59OgYPHoyoqCio1Wr06tULOTk5+Oijj3yWXbx4MWQyWavTyZMn/dYhPz8fc+bMQZ8+fRAZGYnU1FRMmjQJH3zwQUD7kJubi+nTp6NXr15Qq9Xo0aMHbr75Znz99ddtOhYXsjVr1gTUVtu3b/e5jvLycjz88MPIzs6GRqNBYmIiRo8ejTfeeAOB/N+B7Xz+BdLGzmncuHEe5XlOhw6DwYAvvvgC//jHPzBlyhRkZmZKx7+1ns1O4X7O7ty5EzfffDN69OghfS9Nnz4dubm5AZUPFx1p6zNnzmDlypW47bbb0K9fP2g0Gmg0GvTp0wd33XVXq8d65syZAZ3zzuEffGFbB6YjbX2hXJ+7Q1u3t51PnTrVpu/xWbNmeayD53TX6sjvKCd+VwdB8Ia3IiJfFAqFNKA9ABEZGSkNsO+cJk+eLBobGz3KOgf7VyqVIi0tzefk7UEATp9//rnQarXStmJjY4VcLpfez5o1S9jtdp/lV61a5bYPcXFx0kMAAIhFixZ1wlEKf6tXrxYAhFwu99tWe/bs8Vr+xx9/FElJSdJxjY6OdjvuEydOFCaTyef22c5dw1/bpqWlicTEROmYLViwwKM8z+nQsXPnTrfrsOsUyDEI93PW9WEyMplMxMXFSe8VCoVYtWpVq8cgXLS3rYuLi92OKQCh1WqFRqNxWzZ79mxhtVq9rmPGjBnSd7+/c95XeSHY1m3RkfP6Qrg+d5e27sg53dr3uOsxe/nllz3WwXO6a3Xkd5QQ/K4OFgamiEIQAHHllVeKlStXivz8fGl5YWGhuPvuu6WLy/Tp0z3KOi9GY8aMade2XZ8yOXLkSHHs2DEhhBANDQ1i4cKF0rYDecpkTk6OOH36tBBCiKqqKjFnzhypvK+nTHYnzsBUZmZmm8u6Pk104MCB4ocffhBCOJ4m+tJLLwmlUimAwJ4mynYOruXLl0vH6+jRox7pPKdDx86dO0VCQoIYP368WLBggXjvvfek87C1PxTD/Zx1fQLwnDlzRFVVlRBCiNOnT4ucnBwBXFhPAG5vWxcWFgoAYvz48eLtt98WZ86cEUI4niJ9+PBhcdNNN0nH8YknnvC6DueP2BkzZrSr7mzrtunIeR3u1+fu1NYdaefW3H///QKA0Gg0oqamxiOd53TX6sjvKH5XBw8DU0Qh6Ouvv/ab7nphKi4udkvr6B9J06dPFwBEenq61y/XP/3pT1L0X6fTeaSPGjVKABDDhg0TFovFI33SpElSMMbff4a6g44Epp544gnpj6CCggKP9Keeekr68nF+KbpiO4eOQYMGCQBi1KhRXtN5TocOb/uXmZkZ0A+bcD5nrVartJ+TJk3yKGs2m8WwYcP8fo7DTXvbura2Vhw8eNBnut1uF9dee60AHP+FNxqNHnk6+iOWbd02HTmvw/n63N3auiPt7I/RaBQJCQk+Ax1C8Jzuah35HcXv6uBhYIooDH3//ffSBfXDDz90S+vIH0l6vV663WDJkiVe8zj/GwxAvPXWW25p+fn5Utrbb7/ttfyuXbukPK19cVzoOhKY6t27twAc3YG9aWhoENHR0QKAWLhwoVsa2zl07Nu3TzpOa9as8ZqH53RoC/SHTTifszt27JDSdu/e7bX8mjVrpDyu/6G+kHTGj1ghhNi4caN0rHJzcz3SO/Ijlm3dOboiMMXzOvg645xet26ddIx27drlNQ/P6dDi73cUv6uDh4OfE4WhyMhIad5ms3Xaevfu3Quj0QgAmDx5stc8WVlZGDRoEABg27ZtbmlfffWVNH/ttdd6LT9q1CjExMR4LU+BOXbsGIqLiwH4bqfo6GiMHj0agOdxZjuHjjfffBMAEBsbi9tuu63T18+2Dg3hfs46y8fExGDkyJFey7vWy3V75Ol8fYcDbOtwwvP6wuD8Hu/fvz/GjBnT6etnO3c+X9dgflcHFwNTRGFo165d0vywYcO85jl8+DCGDh0KjUaD6OhoZGdn495778VPP/3kc72HDh2S5ocMGeIz39ChQ6VteCufmpqK1NRUr2UjIiIwcOBAr+W7q8rKSowYMQLR0dHQaDTo27cvpk+f7tbOrlzbydkW3jjTjhw54rM82zl49Ho9Nm7cCACYOnUqtFqt3/w8p8NXuJ+zzvKDBg1CRESE1/KpqalISUnxWp7cOa/tKpUKAwYM8Jlvx44dGDBgACIjIxEbG4thw4bhoYcewokTJ3yWYVsHRzhen9nWHVdQUICdO3cCAO6+++5W8/OcDg2+fkfxuzq4GJgiCjO1tbX45z//CQAYPXo0srOzvearqqpCXl4etFotzGYzjh8/jjfeeAMjRozAE0884bVMaWkpACAhIcHvj+SMjAy3/C3LO9PbWr67MhgMyM3NhUqlgt1uR2FhIdatW4dx48Zh9uzZHo8Pdj1u/o61M62+vh56vd6jPNs5uNavXy+1yz333NNqfp7T4Svcz1l+DjpPYWEhXn31VQDAHXfcgdjYWJ95S0pKUFBQAK1WC4PBgEOHDuGFF17A0KFD8corr3gtw7YOjnC8PrOtO+6tt96CEAIKhQIzZsxoNT/P6eDz9zuK39XBxcAUURix2+344x//iLNnz0KtVuPFF1/0yNO/f38sW7YMx44dg8lkQnV1NRobG7F161aMGDECQggsXboUzz33nEfZhoYGAGi154Yz3Zm/s8p3Nz179sSiRYvwn//8ByaTCTqdDgaDAfv27cM111wDAFi9ejXmzZvnVs71uPk71q5prmXYzqHhjTfeAABceumlGDFihM98PKfDX7ifs/wcdA6j0YjbbrsNBoMBSUlJ0o+jloYPH46XXnoJp06dgtlshk6nQ319PT744ANcfPHFsFgs+Mtf/oL333/foyzbumuF8/WZbd0xNpsNa9asAQBcf/31SE9P95mX53RoaO13FL+rg4uBKaIw8te//hWfffYZAGDlypW49NJLPfJMmzYNCxYswIABA6BUKgE4bheYOHEi9u7diyuuuAIAsHjxYtTV1XVd5cnDxIkTsXjxYlxyySVQq9UAHF10r7rqKmzduhU33XQTAEdb++vmTeHn8OHD+O677wC03luK5zRR+LNarZg6dSoOHjwIpVKJd9991+d/tR988EHcd999yMzMlG7H0Gq1mDJlCr777jtkZWUBAObPnw8hRFftAnnB63P39eWXX+LMmTMAWv8e5zkdGgL5HUXBw8AUUZiYP38+XnrpJQDA888/j9mzZ7d5HZGRkXjqqacAOMa32bFjh1u6czA9g8Hgdz3OdGf+zipP58jlcixfvhyA4z88n376qZTmetz8HWvXNNcybOfgc/aWioyMxLRp09q9Hp7T4SHcz1l+DjrGZrNh+vTp2Lx5MxQKBd59911MnDixXetKSkrC448/DgAoKiryGMOIbR06Qv36zLbuGOf3eEZGhs+BrgPBc7prBPI7it/VwcXAFFEYeOSRR6Ru4M8++yweeuihdq/rd7/7nTRfUFDgltazZ08AQE1Njd+LmvM/RM78Lcs709tantz169cPycnJANzbyvW4+TvWzrTY2FhER0d7lGc7B4fFYsE777wDALjllluQkJDQofXxnA594X7O8nPQfs6g1IYNGxAREYF33nkHt956a4fWGcg5z7YODaF8fWZbt19FRQU+//xzAMDMmTN9DjQdKJ7T51egv6P4XR1cDEwRhbgFCxbg2WefBQAsW7YM8+fPP2/bcn0Chb8nNTif+tDyiRPO8hUVFaisrPRa1maz4ejRo17LU2Bc28n1CSAtOdMGDx7sszzbuet9/PHHqKqqAhDYoOcdwbYODeF+zjrL5+XluT1a25Xruvk5cLDZbJg2bRrWr18vBaXuuOOO87pNtnX44Hkdvt5++200NTVBJpO16w6GtmA7d0xbfkfxuzq4GJgiCmHz58+XbudatmwZFixY0OF1HjhwQJrv06ePW9qoUaOg0WgAOO6d96aoqAh5eXkA4HErwoQJE6R5X+X37dsnDbbX3lsZuov8/HwpgOHaVtnZ2ejduzcA38e5sbER33zzDQDP48x2Di5n9/9+/fphzJgxHV4fz+nQF+7nrLN8Q0MD9u/f77W863pdt9ddOYNSrj2l7rzzzk5Zt79znm0dWkL5+sy2br8333wTADBu3Dj07du3w+vjOX1+tPV3FL+rg0wQUUh6+OGHBQABQCxfvjygMna73W+6yWQSv/3tbwUAERUVJWpqajzyTJ8+XQAQPXr0ELW1tR7pc+fOFQBETEyM0Ol0HumjRo0SAMSll14qLBaLR/rkyZMFAJGZmSmsVmtA+3Uhaq2t7Ha7uPnmmwUAIZfLxdGjR93Sn3jiCQFAaLVaUVhY6FH+mWeeEQBERESEOHbsmEc62zk4ioqKhFwuFwDEU0891Wp+ntOhLzMzUwAQixYt8psvnM9Zq9Uq7ed1113nUdZisYhLLrlEABCjRo3ydxjCWqBtbbVaxe233y4ACIVCIdavXx/wNlo756urq0Xfvn0FANGrVy9hs9k88rCtOy6Qtg736zPbOvBz2tU333wj/X3+7rvvtpqf53RwtOd3lBD8rg4mBqaIQtAjjzwiXUxXrFgRcLldu3aJ8ePHi3//+9/i9OnT0nKLxSK2b98urrjiCmm9zzzzjNd1FBQUiKioKAFAjB49Whw/flwIIYRerxdLliwRMpnMb/n9+/eLiIgIAUBMmTJFlJSUCCEcX7zOizEAsWHDhoD360JUWFgorrjiCvHqq6+K/Px86Q8Xm80mvv32WzFp0iTpWM2dO9ejfG1trUhPTxcAxODBg8WPP/4ohBDCbDaLlStXCpVK5bOsEGznYFm0aJH0Y7W0tLTV/DynQ49OpxOVlZXSdNFFFwkAYsGCBW7LGxoa3MqF+zm7YcMGt2tSdXW1EEKIkpISMWXKFOkP9f3797f9oIao9rS11WoVd911l3Seb9y4sU3bXLt2rbj55pvF+++/L8rLy6XlBoNBfPTRR6J///5SO/gKeLGt2649bX0hXJ+7W1u39/rtasaMGQKASExMFCaTqdVt8pzueu39HSUEv6uDiYEpohBTVFQkXVDkcrlIS0vzOz377LNS2Z07d0plAQiNRiOSk5OFUql0W+djjz3mtw6ff/650Gq1Upm4uDjpIglAzJw50+9/gFatWiUUCoWUPz4+XroQt/U/UxeqwsJCt7ZSq9UiOTlZqNVqt+WzZs0STU1NXtfx448/iqSkJClvTEyMW1tPnDjR7x9NbOeuZbPZpP9k3XjjjQGV4Tkdepxt2No0Y8YMj7Lhfs46A6sAhEwmE/Hx8dJ7hUIhVq1aFehhDAvtaevdu3dLy5VKZavf4S1/iK5evdpt3VFRUSIpKcmtndVqtXj55Zf91p1t3TbtaesL5frcndq6I9dvIYSor6+X2urBBx8MaJs8p7tWR35HOfG7OjgYmCIKMS0DFq1NrhenqqoqsXz5cnHLLbeIAQMGiMTERKFQKERsbKy49NJLxf333y9++eWXgOpx8uRJce+994qsrCyhUqlEUlKSmDBhgnj//fcDKn/w4EExdepUkZGRIVQqlUhLSxM5OTlix44d7TksFxyDwSBefPFFMXXqVDF48GCRkpIiFAqFiI6OFgMHDhSzZ88We/fubXU9ZWVlYt68eaJ///4iMjJSxMfHi1GjRolVq1Z57Q7eEtu562zdulU6bz/55JOAyvCcDj0d/WET7ufsjh07RE5OjkhLSxMqlUpkZGSIqVOnSv9VvpB0RrCitWn16tVu2zx16pRYunSpuOGGG8TFF18s4uPjhUKhEAkJCeKKK64Qf//730VBQUFA9WdbB649bX0hXZ+7S1t39Pr92muvSXkCbVue012rI7+jXPG7uuvJhBACREREREREREREXYxP5SMiIiIiIiIioqBgYIqIiIiIiIiIiIKCgSkiIiIiIiIiIgoKBqaIiIiIiIiIiCgoGJgiIiIiIiIiIqKgYGCKiIiIiIiIiIiCgoEpIiIiIiIiIiIKCgamiIiIiIiIiIgoKBiYIiIiIiIiIiKioGBgioiIiIiIiIiIgoKBKSIiIiIXp06dgkwmg0wmw6lTp4JdnZCWlZUlHSvntHnz5mBX64KWk5PjccwXL14c7GoRERG1GwNTRERERNQhsbGxSEtLQ1paGiIjIz3Sx44dKwVRFAoFzpw543d9ZrMZSUlJUpmsrKw212nx4sVS+UC0FuSprKzE0qVLMWrUKCQnJ0OpVCI5ORlDhgzBH/7wBzzzzDPYv3+/33W7Tmq1GikpKRgwYACmTJmCpUuX4uTJk63WMyEhQTrWSqUyoH0jIiIKZYpgV4CIiIgolCiVSmRnZ0vz1LoXXngBM2fODCivzWbD2rVr8eijj/rMs3nzZuh0uk6qXcft2LEDt99+u1udoqKi0NTUhCNHjuDIkSP47LPPAABCCJ/riYqKQnR0NADAbrejvr4eVVVVOHHiBD766CM88cQTuPbaa/Hqq68iMzPT6zpWr14tzY8dOxa7d+/ujF0kIiIKGvaYIiIiInKRkZGBo0eP4ujRo8jIyAh2dS4ozp5PrsEVb5zp7ekp1dmKi4uRk5MDnU6HrKwsvPXWW6ipqYFer0ddXR1qa2uxdetW3HfffUhISPC7rvnz56OsrAxlZWWoqKiAyWRCVVUVtmzZgjvvvBNyuRxffvklhg0bhh9//LGL9pCIiCi4GJgiIiIioi7x+9//HllZWThx4gT27t3rNU9JSQm++uorREdH45ZbbuniGnp67bXXoNfroVKpsHv3bsyaNQvx8fFSelxcHCZOnIiXXnqp1VsUvUlKSsLkyZPx3nvvYfv27YiLi0NDQwNuuOEG1NTUdOKeEBERhSYGpoiIiCgk1dXVYf369Zg2bRqGDRuGxMREREZGIjMzE1OnTsWBAwd8lm1qasJXX32FBx98EJdffjl69OgBlUqF1NRUTJo0Ce+9957PW646e/DzjuyH0549e/CHP/wBycnJ0Gg0yM7OxuOPPw69Xo81a9a0Og7Txx9/jPHjxyM+Ph7R0dG49NJLsWzZMjQ1NUljMY0dO7bD+9oamUwm3fLnq9fUmjVrYLfbcdttt0m3vQXTzz//DAD4zW9+g969e/vNq9FoOrStcePG4Y033gAAlJeXY8WKFR1aHxERUThgYIqIiIhC0vPPP4+77roL7777Lg4dOoSmpiYAjlur3nvvPVx11VX417/+5bXsvn37MHHiRLz44os4ePAgampqoFarUVlZiW3btmHq1Km44447YLfbQ3o/AODFF1/E2LFj8dlnn6G6uhpqtRqnTp3CU089hSuvvBK1tbV+tz9//nzk5OTg66+/Rl1dHZRKJY4cOYK///3vuOaaa6T6dJWZM2dCJpNh48aNaGxs9Ehfs2YNAGDWrFldWq/WlJaW+h0/qrPceuutGDp0KADg7bffPu/bIyIiCjYGpoiIiCgkpaenY968eThw4ABqamrQ0NAAo9GIgoIC/PWvfwUA/O1vf8NPP/3kUVaj0WDq1Kn4/PPPUVZWBqPRiIaGBlRXV+OFF15AbGwsNm3ahJdeeimk92P//v146KGHIITAhAkTcOzYMdTW1qKxsRGbNm1CeXk5nnzySZ/bXr9+PZ577jkAwNSpU1FSUiLV4fXXX8f333+PV1555fzsuA+ZmZm4+uqrodfrsWnTJre03bt3Iz8/H/369cPo0aO7tF6+XHnllQActxjOnz/fazCts1133XUAgNOnT6OwsPC8b4+IiCiYGJgiIiKikPTnP/8ZK1aswG9/+1tpTB+ZTIY+ffrg//7v//CXv/wFNpsNL7/8skfZ3/72t1i3bh2uu+46pKWlQSaTAQASExPx4IMP4s033wQAvz2VQmE/Fi5cCLvdjsGDB+PTTz/FgAEDAAAKhQK33nor3n//fZ/jEAkhsHDhQgDAhAkT8M4770iDuUdGRuLee+/FK6+8EpRxjJy9oVrezvfWW2+5pYeC++67Dz179gQArFixAmlpaZg8eTIWLlyIjz/+GBUVFZ2+zUsvvVSaz8/P7/T1ExERhRIGpoiIiCgsXX/99QDgcxDtQMrm5+fj7NmznVqv9tal5X7odDp8/fXXAIAFCxZArVZ7lB03bpzPnkU///wzTpw4AQB47LHHpOCcqxkzZrQ6btL5MGXKFMTFxWHPnj1S4KWhoQEffPAB5HI5ZsyY0eV18iU5ORl79+7FhAkTAACNjY348ssv8b//+7/IyclBWloaLr/8cmlsrM6QmJgozet0uk5ZJxERUahiYIqIiIhCVkFBAebPn48RI0YgPj4eERER0sDkztudSkpKvJZtaGjAs88+izFjxiA1NRUqlUoqq9VqpXzteZJaV+zHTz/9JI1pNGbMGJ/r9jVoeW5uLgBAqVTiqquu8ppHJpP5Xff5otFocOeddwI412tqw4YNaGxsxMSJE6WeXaGiT58+2LZtG44cOYKnn34aN910k1tA7+DBg5g1axYmT54Mk8nU4e11xVhWREREoUIR7AoQERERefPRRx/hrrvugtlslpbFxsYiMjISMpkMFosFNTU1Xsf8OX78OMaPH+8W7NFqtYiPj4dc7vi/XHl5OQCc9zGD2rsflZWV0rzzVjJvfAVxnOWTkpKgUqnaXP58mz17Nl577TWsXbsWTz75pBSgmj17dlDqE4hBgwZh0KBB0vuysjJ8/PHH+Oc//4mioiJs27YNTzzxBJYvX96h7bjeXpmUlNShdREREYU69pgiIiKikFNdXY2ZM2fCbDbj6quvxq5du2AwGFBXV4fy8nKUlZV5DJztatasWSgpKUFWVhY2bdqE6upqNDY2oqKiAmVlZW69pM5n75SO7Idrvbzdhuctn7fl/sr6K3++XXnllRg8eDBOnz6Nl19+Gfv370diYiJuvPHGTlm/RqOR5o1Go9+8BoPBa7nWpKenY86cOfjuu++QmpoKwDFOVkdv6fvPf/4jzV988cUdWhcREVGoY2CKiIiIQs6WLVtQX1+PhIQEfPrppxgzZoxHwKCsrMxr2dOnT2P//v0AgPfeew+33nqr25g9/sp2to7shzPQAQClpaU+t+ErzVm+qqoKFoulzeW7gnOQ8/nz5wNwPDnQ21ha7ZGcnCzNt3a7pmt6SkpKm7eVlpaGm266CYCjt5Nrb7f22LJlCwDHEwyzsrI6tC4iIqJQx8AUERERhZzTp08DALKzs93Gg3K1fft2v2UB4LLLLmtT2c7Wkf247LLLpN5Ou3bt8rkNX2nDhw8HADQ1NUmBupaEENizZ4/PdZ9vf/zjH6FQKKTAWWfexjdixAhpvrUB8l3TXcu1RXR0tDTfkeDa+++/j0OHDgEAZs6c2e71EBERhQsGpoiIiCjkxMXFAXCMFeVtMOmff/4Z7777rt+ygPstUU4NDQ34xz/+0Uk19a8j+5GYmIhx48YBAJ577jmvvZ727NmDb775xmv53/zmN+jXrx8A4Omnn/Z6y94777yDoqKiwHbmPEhLS8Pzzz+Phx9+GEuWLPEZSGyPSy+9FNnZ2QCAFStW+Ow1ZrFY8PzzzwMABg4ciEsuucQt/ZtvvnG71c8bvV6PDz/8EIBjoPT4+Ph21Xn37t245557ADhuE3zooYfatR4iIqJwwsAUERERhZyJEydCLpdDp9Nh2rRp0q1WFosFGzduxMSJExETE+O17ODBg6Unps2ePRsHDx6U0r799luMHTvWbXDp86kj+wEAS5YsgUwmw6FDh3DjjTfixIkTAACr1YoPP/wQt9xyCxISEryWlclkWLJkCQBg69atmDFjhnTbnslkwptvvok5c+b4LN9V7r//fixfvhwLFy7s1PXKZDI8++yzkMlk+PXXX3HNNddg3759sNlsAACbzYZ9+/bhmmuuwa+//gqZTIZly5Z5jMn1wgsvoHfv3njggQewfft21NfXS2n19fXYuHEjrrrqKinA9/DDD7epnjqdDl988QWmTp2K8ePHo66uDrGxsfj888/bHeAiIiIKK4KIiIgoBP39738XAKQpLi5OKJVKAUD06dNHrFu3Tkpr6dNPPxUKhUJK12q1QqvVSvPbt2+X0nbu3OlWtrCwUEorLCwM6n4IIcTzzz/vVj4+Pl6o1WoBQAwdOlRKz87O9lr+oYceksrKZDKRkJAgbf/qq68Wjz76qAAgJk2a1OZ9y8zMFADE6tWr/eYbM2aMACBmzJjRpvUvWrRIABCZmZltrpvTq6++KlQqlXQMlEqlSEpKko4BAKFSqcSrr77qtfydd97pdvwBiJiYGBEdHe22TC6Xi0ceeUTY7XaPdTjzREVFibS0NJGWliZSU1NFZGSk2zpkMpm47rrrRFFRUUD75jyuixYtavfxISIiCjb2mCIiIqKQ9PTTT2Pt2rW48sorodFo0NTUhH79+uGxxx7DTz/9hJ49e/ose8MNN2DPnj24/vrrER8fD6vViuTkZMyaNQu5ubkYP358WOwHADz00EPYtWsXrrvuOiQkJMBkMiErKwtPPPEEDhw4IN2i56t3zfPPP48PP/wQY8eORUxMDMxmMwYNGoRnn30WW7duRWNjo9/y4W7OnDk4evQo5s+fj+HDhyMqKgq1tbWIiorC8OHDMX/+fOTl5WHOnDley//73//G119/jUcffRTjx49Hr169YLFYYDKZkJCQgCuuuALz5s3DTz/9hGeeecbvUxAbGxtRXl6O8vJy1NTUICoqCv3798fNN9+MpUuX4vjx4/j888+lHn9ERETdgUyIID0jmIiIiIg6bNq0aXj33Xcxe/ZsvPnmm20uP3LkSOzfvx9PPvkk/ud//qdNZbOyslBUVITVq1dzoO4gGDt2LHbv3o1FixZh8eLFwa4OERFRu7DHFBEREVGYOn78uDTo9rXXXtvm8rt375ae2Nee8kREREQdxcAUERERUQhbuHAhXnrpJRQXF8NutwNw3BK2YcMGjBs3DiaTCQMHDkROTo7X8vfddx/WrFmDsrIy6ba/2tpavPbaa7jpppsAAFdffTWuuOKKdtdx1qxZkMlkkMlk2Lx5c7vXQ63LycmRjvXu3buDXR0iIqIOUwS7AkRERETk2y+//IKPP/4YDzzwAJRKJWJiYlBbWysFqTIyMrBp0yYolUqv5fft24eVK1cCANRqNbRaLWpra6Ug1eDBg7F27dp21S0lJQUmk8ltWWRkZLvWRYFJSEhAWlqa27Lo6Ogg1YaIiKjjOMYUERERUSumTJki3fIWqA8//BBXXXVVh7e9e/dubNiwAfv378fZs2eh0+kQFRWFAQMG4IYbbsD999+PxMREn+U/+eQTfPTRR/j+++9RXl6Ouro6xMbGYsiQIZgyZQr+9Kc/QavVdrieRERERO3BwBQRERFRK5yDTLfFzp07MXbs2PNTISIiIqILBANTREREREREREQUFBz8nIiIiIiIiIiIgoKBKSIiIiIiIiIiCgoGpoiIiIiIiIiIKCgYmCIiIiIiIiIioqBgYIqIiIiIiIiIiIKCgSkiIiIiIiIiIgoKBqaIiIiIiIiIiCgoGJgiIiIiIiIiIqKgYGCKiIiIiIiIiIiC4v8DlhgtLYPf9JEAAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -681,15 +686,7 @@ }, "hidden": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-03 13:58:03,127 - climada.engine.unsequa.unc_output - INFO - Reading /Users/ckropf/climada/data/unc_output/unc_output_costben/test_unc_output_costben/v1/test_unc_output_costben.hdf5\n" - ] - } - ], + "outputs": [], "source": [ "# If you produced your own data, you do not need the API. Just replace 'filename' with the path to your file.\n", "from climada.engine.unsequa import UncOutput\n", @@ -878,57 +875,57 @@ "" ], "text/plain": [ - " Mangroves Benef Beach nourishment Benef Seawall Benef \n", - "35 2.375510e+08 1.932608e+08 234557.682554 \\\n", + " Mangroves Benef Beach nourishment Benef Seawall Benef \\\n", + "35 2.375510e+08 1.932608e+08 234557.682554 \n", "36 9.272772e+07 7.643803e+07 9554.257314 \n", "37 1.464219e+08 1.179927e+08 192531.748810 \n", "38 9.376369e+07 7.722882e+07 10681.112247 \n", "39 9.376369e+07 7.722882e+07 10681.112247 \n", "\n", - " Building code Benef Mangroves CostBen Beach nourishment CostBen \n", - "35 1.584398e+08 6.347120 10.277239 \\\n", + " Building code Benef Mangroves CostBen Beach nourishment CostBen \\\n", + "35 1.584398e+08 6.347120 10.277239 \n", "36 5.501366e+07 16.260133 25.984286 \n", "37 8.979471e+07 10.297402 16.833137 \n", "38 5.555413e+07 12.965484 20.736269 \n", "39 5.555413e+07 16.080478 25.718218 \n", "\n", - " Seawall CostBen Building code CostBen no measure - risk - future \n", - "35 4.350910e+04 66.742129 6.337592e+08 \\\n", + " Seawall CostBen Building code CostBen no measure - risk - future \\\n", + "35 4.350910e+04 66.742129 6.337592e+08 \n", "36 1.068151e+06 192.217876 2.200547e+08 \n", "37 5.300629e+04 117.764285 3.591788e+08 \n", "38 7.703765e+05 153.475031 2.222165e+08 \n", "39 9.554617e+05 190.347852 2.222165e+08 \n", "\n", - " no measure - risk_transf - future ... \n", - "35 0.0 ... \\\n", + " no measure - risk_transf - future ... \\\n", + "35 0.0 ... \n", "36 0.0 ... \n", "37 0.0 ... \n", "38 0.0 ... \n", "39 0.0 ... \n", "\n", - " Beach nourishment - cost_ins - future Seawall - risk - future \n", - "35 1 6.335246e+08 \\\n", + " Beach nourishment - cost_ins - future Seawall - risk - future \\\n", + "35 1 6.335246e+08 \n", "36 1 2.200451e+08 \n", "37 1 3.589863e+08 \n", "38 1 2.222058e+08 \n", "39 1 2.222058e+08 \n", "\n", - " Seawall - risk_transf - future Seawall - cost_meas - future \n", - "35 0 1.020539e+10 \\\n", + " Seawall - risk_transf - future Seawall - cost_meas - future \\\n", + "35 0 1.020539e+10 \n", "36 0 1.020539e+10 \n", "37 0 1.020539e+10 \n", "38 0 8.228478e+09 \n", "39 0 1.020539e+10 \n", "\n", - " Seawall - cost_ins - future Building code - risk - future \n", - "35 1 4.753194e+08 \\\n", + " Seawall - cost_ins - future Building code - risk - future \\\n", + "35 1 4.753194e+08 \n", "36 1 1.650410e+08 \n", "37 1 2.693841e+08 \n", "38 1 1.666624e+08 \n", "39 1 1.666624e+08 \n", "\n", - " Building code - risk_transf - future Building code - cost_meas - future \n", - "35 0 1.057461e+10 \\\n", + " Building code - risk_transf - future Building code - cost_meas - future \\\n", + "35 0 1.057461e+10 \n", "36 0 1.057461e+10 \n", "37 0 1.057461e+10 \n", "38 0 8.526172e+09 \n", @@ -957,14 +954,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## CalcImpact" + "\n", + "## CalcImpact\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Set the InputVars " + "\n", + "### Set the InputVars\n" ] }, { @@ -983,18 +982,7 @@ "start_time": "2023-08-03T11:58:03.252329Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-03 13:58:03,258 - climada.hazard.base - INFO - Reading /Users/ckropf/climada/demo/data/tc_fl_1990_2004.h5\n", - "2023-08-03 13:58:03,286 - climada.entity.exposures.base - INFO - Reading /Users/ckropf/climada/demo/data/exp_demo_today.h5\n", - "2023-08-03 13:58:03,306 - climada.entity.exposures.base - INFO - Matching 50 exposures with 2500 centroids.\n", - "2023-08-03 13:58:03,307 - climada.util.coordinates - INFO - No exact centroid match found. Reprojecting coordinates to nearest neighbor closer than the threshold = 100\n" - ] - } - ], + "outputs": [], "source": [ "#Define the input variable functions\n", "import numpy as np\n", @@ -1048,7 +1036,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1104,7 +1092,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1124,7 +1112,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Compute uncertainty and sensitivity using default methods " + "\n", + "### Compute uncertainty and sensitivity using default methods\n" ] }, { @@ -1167,13 +1156,6 @@ } }, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-03 13:58:05,110 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 1536\n" - ] - }, { "data": { "text/html": [ @@ -1285,7 +1267,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1314,22 +1296,7 @@ "start_time": "2023-08-03T11:58:06.596075Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-03 13:58:06,602 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", - "2023-08-03 13:58:06,604 - climada.engine.impact_calc - INFO - Calculating impact for 250 assets (>0) and 216 events.\n", - "2023-08-03 13:58:06,605 - climada.engine.impact_calc - INFO - cover and/or deductible columns detected, going to calculate insured impact\n", - "2023-08-03 13:58:06,611 - climada.engine.impact - WARNING - The Impact.tot_value attribute is deprecated.Use Exposures.affected_total_value to calculate the affected total exposure value based on a specific hazard intensity threshold\n", - "2023-08-03 13:58:06,612 - climada.engine.unsequa.calc_base - INFO - \n", - "\n", - "Estimated computaion time: 0:00:21.811200\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "output_imp = calc_imp.uncertainty(output_imp, rp = [50, 100, 250])" ] @@ -1359,7 +1326,7 @@ { "data": { "text/plain": [ - "['aai_agg', 'freq_curve', 'tot_value']" + "['aai_agg', 'freq_curve']" ] }, "execution_count": 27, @@ -1492,7 +1459,6 @@ " rp50\n", " rp100\n", " rp250\n", - " tot_value\n", " \n", " \n", " \n", @@ -1502,7 +1468,6 @@ " 8.324391e+10\n", " 1.162643e+11\n", " 1.510689e+11\n", - " 5.760281e+11\n", " \n", " \n", " 1532\n", @@ -1510,7 +1475,6 @@ " 1.096005e+11\n", " 1.460838e+11\n", " 1.809413e+11\n", - " 5.760281e+11\n", " \n", " \n", " 1533\n", @@ -1518,7 +1482,6 @@ " 2.892734e+10\n", " 4.720869e+10\n", " 6.807561e+10\n", - " 5.760281e+11\n", " \n", " \n", " 1534\n", @@ -1526,7 +1489,6 @@ " 6.468855e+10\n", " 8.653474e+10\n", " 1.085266e+11\n", - " 5.760281e+11\n", " \n", " \n", " 1535\n", @@ -1534,19 +1496,18 @@ " 5.294874e+10\n", " 7.395191e+10\n", " 9.609003e+10\n", - " 5.760281e+11\n", " \n", " \n", "\n", "" ], "text/plain": [ - " aai_agg rp50 rp100 rp250 tot_value\n", - "1531 2.905571e+09 8.324391e+10 1.162643e+11 1.510689e+11 5.760281e+11\n", - "1532 3.755172e+09 1.096005e+11 1.460838e+11 1.809413e+11 5.760281e+11\n", - "1533 1.063119e+09 2.892734e+10 4.720869e+10 6.807561e+10 5.760281e+11\n", - "1534 2.248718e+09 6.468855e+10 8.653474e+10 1.085266e+11 5.760281e+11\n", - "1535 1.848139e+09 5.294874e+10 7.395191e+10 9.609003e+10 5.760281e+11" + " aai_agg rp50 rp100 rp250\n", + "1531 2.905571e+09 8.324391e+10 1.162643e+11 1.510689e+11\n", + "1532 3.755172e+09 1.096005e+11 1.460838e+11 1.809413e+11\n", + "1533 1.063119e+09 2.892734e+10 4.720869e+10 6.807561e+10\n", + "1534 2.248718e+09 6.468855e+10 8.653474e+10 1.085266e+11\n", + "1535 1.848139e+09 5.294874e+10 7.395191e+10 9.609003e+10" ] }, "execution_count": 29, @@ -1577,9 +1538,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1609,7 +1570,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKcAAAKsCAYAAAA5l96EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1yW9f7H8dcNCCgIuCfuTNPcUY5SSystyyw1s7SsrE7WqbTp+TWODTtNy7JSy9UwB+beYm5R3FsZLgQUkM29rt8fyK3EEG7BG/H9PA8ex/t7fa/v9bn0nKQ332EyDMNARERERERERETEBdxcXYCIiIiIiIiIiFy/FE6JiIiIiIiIiIjLKJwSERERERERERGXUTglIiIiIiIiIiIuo3BKRERERERERERcRuGUiIiIiIiIiIi4jMIpERERERERERFxGYVTIiIiIiIiIiLiMh6uLqC069ChA2azmWrVqrm6FBERESkmcXFxeHp6sm3bNleXIuj7LRERkbKoKN9vKZy6jMzMTGw2m6vLEBERkWJktVoxDMPVZcgF+n5LRESk7CnK91sKpy6jevXqAKxatcrFlYiIiEhxueuuu1xdglxC32+JiIiUPUX5fkt7TomIiIiIiIiIiMsonBIREREREREREZdROCUiIiIiIiIiIi6jcEpERERERERERFxG4ZSIiIiIiIiIiLiMwikREREREREREXEZhVMiIiIiIiIiIuIyCqdERERERERERMRlFE6JiIiIiIiIiIjLKJwSERERERERERGXUTglIiIiIiIiIiIuo3BKRERERERERERcRuGUiIiIiIiIiIi4jMIpERERERERERFxGYVTIiIiIiIiIiLiMgqnRERERERERETEZRROiYiIiIiIiIiIyyicEhERERERERERl1E4JSIiIiIiIiIiLqNwSkREREREREREXEbhlIiIiIiIiIiIuIzCKRERERERERERcRmFUyIiIiIiIiIi4jIKp0RERERERERExGUUTomIiIiIiIiIiMt4uLoAEREREREREREpfjYbxMdDbGzOrw4doN0tNjIsdny9PHB3M7m0ToVTIiIiIiIiIiLXMMMAiwU8PbM+JybC77/D2bNgthhY7XasNgOr3cBmt2OvYMU30ApA05q+uLu5u654FE6JiIiIiIiIiFwTDAOSk3PPhIqLg5Yt7dx1r50Mi40Ui52DEW5YbAYeHlC5qp1aVQwqVzWoUsVO5WqGq18lB4VTIiIiIiIiIiKlTFoaZGRA5cpZny0W+PJLSE0zsNmNCzOhLs6IMo7ZaBRncdx/74Mm/AIMKvqBybWr9i5L4ZSIiIiIiIiIiItkZmbNfPrnbKjkZIPA+gYPD7SSac2aEZWQ4U5yKgQEGFSvaqfyhdlQlasa+PnnnA1Vt37pmh1VEIVTIiIiIiIiIiIlzGLJ2gMqIwMaNrzYPm6cQVJy1uwnq93AarNjtRvY7Qamc3ZOJlycDdXnYSsVfMGjjKU5Zex1RERERERERERc69w5OHMm50yo+Hiw2Oz4VDR4+nkLmZas2VAWT3cyMFG5unFhJtSFGVFVDMp55hzXL8Alr1PiFE6JiIiIiIiIiBSRYWSdihcbC0lJcMstF6/NmWsnIsrIcUKe1Wbg5W3g7W5wOt6C+4UD8nr3tZe5mVBFdZ2/voiIiIiIiIjI5Z04kfWVfTpebCxkZl4Inww71RtasBo2Miw2bN4eePmbcp6QV9WgfIXcm5Nf78EUKJwSEREREREREQGyTsjLXoYXFwe9eoGbG9jsBhs229mxgxwn5Lm5GQRUNqhW1c6ZeCsVKmSN06W71bUvco1ROCUiIiIiIiIi16WICDh0KOcJeVmbkhvY7Aa1mmRSwd+GxWrgVtGNaoHuF/eEqmrgH2Dg5ubqt7j2KZwSERERERERkTLJas06Ie/Sjcnvuw/8/AwyrXb2HzZYsxasNjs2e1YgVdHfoHKNrI3JM2w2yl2YBNW8pZ3mLe2ufaEySuGUiIiIiIiIiJQZ4eGwbVtWEHXuXNYJedkzoax2g6oNMqld34ZhQLkAE01auBd4Qp6UPIVTIiIiIiIiInJNuPSEvEu/evWCOoF2Miw2jscYbNpuygqjbHa8vA3HMrzKVQx8A7KCKYBadQxq1dH+UK6mcEpEREREREREShXDyPrK3s8pKgqWL8/apDwj48K+UHa7Y38o/z1mbvawAVDOD9p3cr8QSNmp4JP7hDwpXRROiYiIiIiIiIjLpKVlhU7/nA3VvbtByzY2Mix24lJs7D3ijtVmYDIZVKqSdUJe9oyo6jUu7gXl5w+t29tc+EZSVAqnRERERERERKTEZWaCzQYVKmR9jomBGTMgKSlrJpTtwiyo7BlR2w5aKV87a8mdWwXofq+bTsgroxROiYiIiIiIiEixyeuEvNhYSEgwuOVWO7d3s5NhtZFothMZ7Y7NbuDrZ1C5ukGVqnbH3lABlQ3HmOXKQeOmOimvrFI4JSIiIiIiIiJFZrdDfHzWf1evntWWkgJffglmq/2SmVBZG5Pb7AaHjtuoH39hA3IT9H3USkAlA08v172HuJ7CKRERERERERHJ1z9PyMveHyouDswWg0ZNbNz/kI1Mq410s534dA9Mppwn5FWuaqdSFYPy5XOOXb2mkecz5fqicEpEREREREREMIysmU+xsVmzoW644eK18ePtpGeS44Q8m93Azd3gXKqdM+ctjr6PDbPh7a0T8qTwFE6JiIiIiIiIXIeOH8/alPzSfaHS0rKW4QVUtvP4MAsZFjsZFhtGeQ/c3E3UvOSEvCpV7FT0zx1C/XN2lMjlKJwSERERERERKaPM5ovL8DIyoGPHrHbDMAj+yyD6TM4T8uyGQUAlA7cKduKSrI7gqe9Ai2ZCSYlROCUiIiIiIiJSRhw+DCdOXJwJFR+ftfzOajcwudmpfYOFTJsNs9WOZ4AHAZhynZDnkUdSoGBKSpLCKREREREREZFrRPYJeRfDJ3jooazwyGy1s36znQMHyHFCXvkKBpWrZYVP55KslPPMGqtLd6trX0bkAoVTIiIiIiIiIqXYvn1w6FBWGHX2LGSaLyzDu7ApecPWmXiWt2G3g081N+rb3Rwn5FWumvuEPJHSRuGUiIiIiIiIiIsYBqSm5tyUPDYWHnsMvLwNMiw2Dhy1s3GrKccJeZWr2ql1YWNyi92Ghz1rvJtutsPNdte+lEgRKZwSERERERERucr27YPQ0KwgKjXVuLAM7+LG5Bv3ZlKjdlbIVLGGiVa3uBV4Qp7ItUzhlIiIiIiIiEgxuvSEvEu/BgwwqFbTTobFxok4g537TY4T8vwDDKpmL8WrYuBX6eLsp9p1DWrXtbnwjURKlsIpERERERERESdYL+wnnn263aFDsHRpzhPybJfMiNq0z0xz04XZUFWhSw83xwl55cq56CVESgGFUyIiIiIiIiIFsNshISH3TKhz5+C+++3ccJONDIuNuFSDYyfdsNpynpBXuUrWxuRVqhqOMf0CwC9Ae0OJgMIpERERketWYmIi3333HSEhIcTExFC3bl369evHk08+iYdHzm8T582bx5QpU4iMjMTPz49evXrx8ssv4+Pjk2vckJAQJkyYwOHDh/H29qZ79+6MHDmSKlWqXK1XExFximHA+fNZM6F8fbPaoqJg+vSLJ+RdnAmV9XnHESue1bOW3JX3h979TFSqYlChggtfROQao3BKRERE5DqUkpLC4MGDOXr0KN27d6dHjx6EhYXx2WefsW3bNiZMmIDpwm67P/74I19++SU33ngjjz/+OIcPH2bKlCns2rWLadOm4enp6Rh34cKFjBw5ksDAQAYNGkR0dDTBwcGEhoYyZ84c/Pz8XPXKIiIO+Z2QFxcH6RkGHTvbCepkJcNqJ8FiIzqhXNYJeVWy9oOqXPXCjKiqdnx8L47r6QV1Ao38HywieVI4JSIiInIdmjhxIkePHuXtt9/mySefdLSPHDmShQsXsnbtWrp168bp06f55ptvaN++PVOnTqXchU1Rxo0bx/fff8+sWbMYPHgwAKmpqYwZM4b69eszd+5cfC9MO+jcuTOjR49mwoQJvPnmm1f9XUXk+paenhU6eXpCzZpZbfHx8M03uU/Is9oMTCaDqFgbdROzNpRy84JBT9rxCzB0Qp5ICVE4JSIiInIdOnnyJDVq1HAES9l69+7NwoUL2bFjB926dWPmzJlYrVaee+45RzAF8PzzzzNt2rQc4dSiRYtITEzk5ZdfdgRTAI888giTJk0iODiYUaNG4e7ufnVeUkSuK3Y7nDmTezbU+fNZm5LfeJONnr1tZFptpGXaiU8vh2/FnCfkVa6adWrepf+YMpnAv5JmQ4mUJIVTIiIiItehL774Is/28PBwAKpWrQpAaGgoAB06dMjRz8vLizZt2rB+/XpSUlLw9fV19A0KCso1blBQEDNnzuTIkSM0a9as2N5DRK4/NhucPZsVPHl4QPPmWe12O/zwox2zNecJeTa7gW9Fg2Srnbhkq2OcYf/KxEP/RixSKuj/iiIiIiLXOcMwiI+PZ+nSpXz77bfUrl2bBx54AIDjx49TtWrVPDc+r1OnDpAVaLVq1YoTJ04AEBgYmKtv3bp1AYiIiFA4JSJFcvAgxMTkPCHPYs0KnqrVtONbw0Km1UaGxU45v3J4upF1Mt6FE/IqVTbw8s49roIpkdJD/3cUERERuc6NGzeOCRMmAFkzpiZPnoy/vz+QdaJfdrD0TxUrVgSyNlcHSEhIwNPTE2/v3P8WmL3ML7uviEg2w4CkpIvhk90Ot9+edc1is/PXQoNz8TlPyPP0hMpV7FQIMEhMuzgbqu9Ai4veQkSuhMIpERERketcnTp1GDZsGCdPnmTlypUMHjyYSZMm0aJFC6xWa47T+C6V3Z6ZmQlQpL4icn3bsQNOnrwYSKVnXFyG5+llUPvGTDKtWUvy/Gt64B1ArhPytDm5SNmhcEpERETkOte/f3/Hr//++2+GDx/Om2++yYIFC/D29sZiyXsmgtlsBqB8+fIAReorImVbRkbOTclTUmDAALDbDTKtdjZvMzh67OJpeZgMAioZ1LiwMXlKhg03t6yxOnezFvwwEbnmKZwSEREREYc77riDLl26sG7dOo4fP46fnx/Jycl59s1uz17e5+fnR2ZmJmazOdcMquzlfNl9RaTsCQ2FQ4dynpBnzf6y2WkWlInJww5AlUA3yvmZHCfkBVTKeUKeiFxfFE6JiIiIXGesVivbtm3DbrfTqVOnXNdr164NZO0h1aBBA0JDQ8nIyMi1l9SpU6dwc3Ojfv36ADRo0ICwsDBOnjxJo0aNcvQ9efIkAA0bNiyJVxKREmazZW1EfulsqLg4eP55sJuyNiM/FGGwfbcpxwl5latnbUheuaodq91OuQvjNW9pd+n7iEjponBKRERE5Do0fPhwfHx8WL9+Pe7/mK5w8OBBTCYTdevWpX379mzZsoVt27bRpUsXR5/MzEx27txJkyZNHJudt2/fnrlz5xIaGpornNqyZQsVK1akcePGJf9yIuI0uz1rL6fs/ZxCQ7O+zp69eEJe9sbkNrud9XsyqVrdAKBaPRO3+ZoKPCFPRCQvbq4uQERERESuLg8PD3r27El8fDyTJ0/Oce23335j165ddOvWjapVq9KnTx/c3d0ZP368Y98ogB9++IGUlBQGDhzoaOvRowc+Pj5MmjSJxMRER/vs2bOJjIykf//+uLnp20+R0sAw4Px5OHIENmyA4GD48Uf4+GM4E2MnJdPK2ZRMTp3L4GCEmTPnM0gyZ+IdkEm9ppl06JJJr4cy8Q8wHGPWrmtwUys7NWsrmBKRotHMKREREZHr0BtvvEFYWBhffPEFW7ZsoWnTphw4cIBNmzZRt25dPvjgAwAaNWrEsGHDmDhxIn379qV79+4cPXqUkJAQ2rVrx4ABAxxjBgQE8Prrr/P+++/Tt29fevXqRUxMDEuWLKFBgwY899xzrnpdketaaip4ekK5C2vqduyApUtznpBnsxuOGVGb9pq5oVnWsrtqdeHuB9yoXMWOb0WdkCciJUPhlIiIiMh1qEaNGsyePZtx48axevVqNm/eTPXq1Rk6dCgvvPAClSpVcvQdOXIktWrV4rfffmPatGlUq1aNJ598khEjRuTa+HzQoEH4+/szadIkfv31V/z9/enbty+vvvoqAQEBV/ktRa4vGRlZ+0Bdui9U1kl5Bv0esVOvkY0Mq41zGQanzrljkPOEvCpVDSpXMajof3E2lF8A+AVofygRKVkmwzCMy3e7ft11110ArFq1ysWViIiISHHR3++li/48RIrGYsnaA8rHB/z8stoOHIA//sh9Qp7VbmA3DLp0s3JzWxsAmRmQkmLSCXkiAkDTmr54eRT/PwyK8ve7Zk6JiIiIiIiUQnmdkBcbCwkJYLHZ6XqnndbtrGRY7Jy32YlL9sDH16ByjawZUJUvzIiqVMVwLOkD8PIGL2/NURCR0kPhlIiIiIiIiAvZ7ZCYmBU8+flB7dpZ7TExMOGH3CfkWW0GXuUNTsfbqJmUNRuqvB8M+5dNG5GLyDVJ4ZSIiIiIiMhVYrVCZGTOmVBxcZCZmRU+tWxj4467LGRa7SSbbSRbvKhUxX5hJpRB5Sp2Klc1qFAh57hubiiYEpFrlsIpERERERGRYpaaejF88vWFFi2y2jMyDX6ekr031MUZUW5uWcvvzCYbCalZs6HcPWDYvzJ1Qp6IlHkKp0RERERERK6A3Q47duQ+IS9rU3KDuvVt+NSwkGG1YbEaVKhcjvIVjIuzoaoa+PkbuLnlHlvBlIhcDxROiYiIiIiIXEb2CXnZ4ZOnJ3TtCoZhkGm1s3AxJKflPCHPzz9rc3L/6naSM2yOsR4cYHHhm4iIlD4Kp0RERERERPKwfj2cOpUVRsXHZ52QZ7VlLcnz8bNTu1kmmVY7hgE1G3lQEy6ekFfZoJynq99AROTaoHBKRERERESuO4YBCQk5l+JZrfDoo2C22sm02ti6A06cJMcJeVUcG5MbpJvtjmV3nbpaXftCIiLXMIVTIiIiIiJy3QgJgcOHc56QZ7VnL8Wz07xThmPvp8CmblSvb6LKhRPyylfQHlAiIiVB4ZSIiIiIiJQJqalZodOls6ESEuDlfxtY7DYyLHaOHDfYd8SU44S8alXsjs3JDePieM1a2F33MiIi1xGFUyIiIiIick3JzMzakDx7FlNICISG5jwhz2q3Y7Nnfd58IJOASlmpU/0bTVQPNBV4Qp6IiFxdCqdERERERKRUS0uDLVvg9Oms2VCJiQb/esmOdwU7GVYb0YkGUTFu2O0GFS+ckJe9MXmVqgYV/S5Oh6pVxwCM/B8mIiJXncIpEREREREplQwD9u+HxYvhbIINs82O1ZY1I2r7QQuBDbKW3dVrAtXqmKhcRSfkiYhcixROiYiIiIhIqZOaCgsWwN79dpLTrfj622jTxkaVanYqVTbwLn+xr18A+AVoNpSIyLVK4ZSIiIiIiJQ6bm5w6JiVhDQr7YKstAuy4aF/exERKZP0j3cRERERESkVUlLAxwcyrTZOJacT1M1O+QpQpZpmRYmIlGUKp0RERERExKUMA7ZuhZUrDTrfaaZqvQwMA+rWd3VlIiJyNSicEhERERERlzl7Fv76C8Ij7SRnWAjdYePeQFdXJSIiV5PCKRERERERuepsNti4EUJCDM6n2rBgpWNXKy1a21xdmoiIXGUKp0RERERE5KqKiYF58yDqRNZsqdr1bHTtYaGin6srExERV1A4JSIiIiIiV1VqqsHhCCt2Nytd77bStLkdk8nVVYmIiKsonBIRERERkRKXlgYVKkByhgVzhXSCuppo0MhOBR9XVyYiIq6mcEpEREREREqM2QyrV8P2MIMHHk0HTwsAN91suLgyEREpLRROiYiIiIhIiQgPhwULIDrWRnKGlV177LRu7+qqRESktFE4JSIiIiIixSojA5Yvh23bDJIzrJQrb6V3Xyv1GtpdXZqIiJRCCqdERERERKTYHD6cNVsqLj5rtlSL1lZu7WzF08vVlYmISGmlcEpERERERIpNRJSdEzFWyle08UAfC7Xram8pEREpmMIpERERERFxmmFAZiZ4e8O5lExq3phB22R3bm5ro1w5V1cnIiLXAoVTRbQzdifl3MrRomoLV5ciIiIiIuJSSUmwaBGcS7Bz78NppFtsuLlBuyCbq0sTEZFriJurC7jWnEw5yWOLH+Or7V+Racu84vEMQ9OcRUREROTaYhgQFgbjxxuE7bZyMMJMeKQ2OxcREeconHKC3bDz896f6b+gPztjd17RWNP2TyueokREREREroKEBJg+HeYG2zmTYKFCJTOPDDZTq45+6CoiIs7Rsr4rEHE+giFLhjDgxgHU96uf41pFz4o82PhBTCZTvveHxYTxTdg3PN78cdzd3Eu6XBERERERp9ntsHUrrFxpcD7VRqbdSlAXKze3zVrKJyIi4iyFU1fIwGDmoZl5XjPbzAy4cUCe16x2Kx9u+RCz3czplNME+gWWZJkiIiIiIldsxy47MYkWatS20a2nFf9Kmi0lIiJXTuFUCRq7dSwtq7bkpio35br224HfOJJwBIDIpEiFUyIiIiJS6thsWftLubkZxCRn0KKjhUp13biplY0CFgiIiIgUiSbgliCL3cLIkJEkmZNytMekxvDdzu8cnyOTIq9yZSIiIiIiBYuOhokTYfFSG0diUzibbKZSZYMWrRVMiYhI8VI4VcJOppzk3Q3v5jiV7/Ntn5NmTXN8jjwf6YLKRERERERys1ph5Ur48SeDw5EWQjabSUnVSXwiIlJyFE5dBauOr2LGgRkAbDq9iaWRS3Ncd3bmVJol7fKdREREREQK6fhxmDABVoXYOJtspk4DMwOHmPH0cnVlIiJSlmnPqavky21f0qxyMz7e8nGua87OnFp5fCV9GvUp8ERAEREREZHLMZuzZktt2WInKcOGWzkrd99vpWETzZgSEZGSp3DqKrEaVoYvH47VsOa6FpseS6olFZ9yPkUac/2p9XSs1ZFqFaoVV5kiIiIich3KyIAtoTbOpli58SYrHe+w4l3e1VWJiMj1QuHUVZRXMJUtKikqz1P9CrIjdgdRSVEKp0RERESkyCwWKFcOLDY7CZZ0Wne24+0NgQ00W0pERK4u7TlVShR1aV90SjRnUs9wPPl4yRQkIiIiImXWwYPwzTewfbeZwzHJJKVbuaGZXcGUiIi4hMKpUqKom6KHxYYBWTOuREREREQKIyUFZs2CX38zOB5jZtkaK3blUSIi4mJa1ldKFHXm1I7YHQAcT9LMKREREREpmGHAnj2wZAmcO28l1WylTQcrHW6zubo0ERERhVOlRVFnTmWHU1HJmjklIiIiIvk7fx4WLYL9B+0kpVvxr2zj3rstVKthuLo0ERERQOFUqRGZFIlhGJhMpsv2TTIncSThCAAnkk5gN+y4mbRCU0RERERyO3XKYMceG+lWKx1us9Kmgw13d1dXJSIicpHCqVIi3ZpObFosNXxqXLbv7rjdGGT9pCvDlkFsWiw1fWqWdIkiIiIico2wWsHDAzIsNjyrptG8nYnGTe1UrqLZUiIiUvpouk0pUtilfWExYTk+a98pEREREQGw22HjRhg3ziA8OoOjsSmkm+3c0tGmYEpEREothVOlSGE3Rc/ebyqb9p0SERERkdhYmDwZFi2xExltZu0GK4byKBERuQZoWV8pUpiZUxabhT1n9+Ro08wpERERkeuXzQbr1sHffxucT7NixUaXuyw0b2l3dWkiIiKFonCqFIlIirhsnwPxB8i0ZeZoi0rSzCkRERGR69Hp0/DXX3DilJ2kDAuBDWzccZcF34qurkxERKTwFE6VIoVZ1vfPJX2gmVMiIiIi16tt2w2ORFoxPKzcea+VJjfaKcThzyIiIqWKwqlS5HTKacw2M57unvn2+edm6AAnkk9gN+y4mbSFmIiIiEhZZ7OBuzskZVho0CqdJgnutL/NSoUKrq5MRETEOUozShEDo8BZUIZhsDNuZ652s93MmdQzJViZiIiIiLhaZiYsWgTTZ9g5fi6NqLNpmNwNbr9TwZSIiFzbNHOqlIlMiqRJpSZ5XotKiiI+Iz7fa7V9a5dkaSIiIiLiIkePwoIFEHPWRnKGlVo3Wqld19VViYiIFA+FU6VMQSf25bXfVLbjScfpWLtjCVQkIiIiIq6Sng5Ll0LYDoPkDAtePjbuv89C7bqGq0sTEREpNgqnSpmI8/mf2BcWm3u/qWzHk7UpuoiIiEhZsn9/1jK+swk2UswWWra2cWtnK+Xy355URETkmqRwqpS5kplTIiIiIlI22GywYqWdk3FWfP1s9H3IQs1ami0lIiJlk8KpUiYqKSrP9nPp5/K9BhCVnP81ERERESn9DCPry80NEtIzadExE59wN9rfasND37WLiEgZpr/mSpnzmedJyEigknclR5vVbuXTrZ8WeN/J5JPY7Dbc3dxLukQRERERKWbnz2dteF6rro0GLdJJy7RRoxbUqGVzdWkiIiIlzs3VBUhuly7ts9gtvLXuLZZELinwHovdQnRqdAlXJiIiIiLFyTAgNBTGjzfYtc/KgmUWEpMUSImIyPVF4VQpFHk+EsgKnN78+02WRS4r1H3ad0pERETk2nHuHEyZAvPm24lJNFOxipl+g8x4erm6MhERkatLy/pKoYikCCw2C6///Tqrjq8q9H1RyVF0olMJViYiIiIiV8puh02bYPVqg/OpNixYue0OKy3b2DCZXF2diIjI1adwqhQ6knCEkWtHsubEmiLdp5lTIiIiIqVfQgIsW2EjIcVKrUAbXXtY8PN3dVUiIiKuo3CqFFp/ar1T9xV0mh+AYRgcjD/I8qjlrIhawamUUzmue5g8WDtwLRXKVXDq+SIiIiKSN8MAkwnsdoNM9wxubG+jXDmDZi3smi0lIiLXPYVTZcjx5LxnTp1NP8u0/dNYEbmCkykn873fipW9Z/cSVCuopEoUERERue6cPJl1Et+dd1vBJx2z1U6rtq6uSkREpPRQOFWGnEo+hdVuxcPt4h+r1W7l9bWvsy1mW6HGCIsNUzglIiIiUgwsFli9GjZuMkhOt3JuvoUH+9tdXZaIiEipo3CqDLEaVk6nnKaeXz1H2/c7vy90MAWwM3ZnCVQmIiIicn2JjIT58+F0jI3kDCtNmlnp3M3q6rJERERKJYVTZUxUUpQjnPr75N9M3DOxSPfvjNuJzW7D3c29JMoTERERKdMyM2HFCti61SA5w4qHt5Vefa3Ub6gZUyIiIvlROFXGZO87FZ0SzTvr3yny/amWVI4kHqFZ5WbFXZqIiIhImXfgAKzflDVbqvnNVjrebsXTy9VViYiIlG4Kp8qYqKQoLDYLo/4exfnM806NERYTVmA4lW5Nx4QJbw9vZ8vMwWa3kWJJwd/LuTOU063plPcoXyy1iIiIiBRV9kl8Fpsd/zrp1G4MTZvbqBNouLo0ERGRa4KbqwuQ4nU86ThfhX3F7rjdTo9xuX2n/j75N2O3jnV6/H8KORHC6PWjsRtFn+5+NOEoK6NWFlstIiIiIoVlGLB3L0ycCNHxZg7HJJOSaaX73VYFUyIiIkWgcKqM2R6znen7p1/ZGLHbMYz8v6FaFrmMOUfmsODYgit6TrYZB2aw9uRapu6bWuR7l0ctZ+PpjcVSh4iIiEhhJSfDzJnwx5929h0xs3SVGbu2lRIREXGKwqkyJsOWccVjxKbFEp0anee1NEsa606uA2DM5jEcSzx2Rc86GH/QcZrguLBxhMWEFfpewzBYGrmUTac3OTXrSkRERKSoDAN27IDvvoPtu6wkpJlpHWSmbZDN1aWJiIhcsxROSZ52xO7Is33tybWOACzdms5rIa+RZklz+jm/HvjV8WubYeP1ta8TnxFfqHuPJB4h4nwE5zLOcTjhsNM1iIiIXK/i4uJ499136dq1Ky1btqRz586MGjWKEydO5Og3a9Ysbrzxxjy/BgwYkGvckJAQBg4cSNu2benYsSPvvPMO586du1qvVWISE2HGDJgz187pc2YqBJjpP9jMLR1tuOugYxEREadpQ3TJ047YHdzX6L5c7csil+X4HH4+nA83f8hHXT7CZDIV6RnxGfEsDl+coy02PZa3173N93d9j7tbwd/lXVrLhlMbdMKgiIhIEcTFxdG/f3+io6Pp3LkzvXv3JiIigoULF7Ju3TpmzpxJgwYNADh06BAAzz77LF5eOY+eq1mzZo7PCxcuZOTIkQQGBjJo0CCio6MJDg4mNDSUOXPm4Ofnd1XerySsWmWwe7+NDJuVoM5WWrWz4aYf9YqIiFwxhVOSp7DY3MvrUswpjiV9l1oQvoD2NdrzcNOHi/SMWYdmYbabc7VvPL2RiXsm8nzr5/O91zCMHOHUptObePrmp4v0fBERkevZ+PHjiY6O5q233uKpp55ytP/111+88cYbjB07lh9++AHICqf8/f0ZNWpUgWOmpqYyZswY6tevz9y5c/H19QWgc+fOjB49mgkTJvDmm2+W3EuVgOyT+NLNNhq3TePYGXc63mEloJI2PBcRESku+lmP5OlowlGSzEk52kJOhuQZJgF8vOVjIs9HFnp8i83CzEMz873+/c7vCzw18FDCIaKSohyfw2LDrmh5oYiIyPVm1apVVK5cmaFDh+Zof/DBB6lXrx7r16/HfmGH78OHD9O0adPLjrlo0SISExMZOnSoI5gCeOSRR2jYsCHBwcHYbNfG3kw2G6xbB3PnGpw5n8GxuBTcPe30etCiYEpERKSYKZySPBkY7IrdlaPtn0v6LmW2m/lk6ycFnvJ3qeVRy4lLjyvw+R9t+Qir3Zrn9X/WYrFbHBuri4iISMEMw2D48OGMGDECtzzWpXl5eWGxWLBYLJw5c4bExERuuOGGy44bGhoKQFBQUK5rQUFBJCQkcOTIkSt/gRJ25gxMmgRLltkJ2WRm1wEzhfwWR0RERJygcErydemm6MnmZDac2lBg/42nN7I8anmhxr50I/T8HIw/mOfsqn8u6bv0+SIiInJ5JpOJIUOGMHjw4FzXwsPDCQ8Pp169enh5eTn2m7LZbLz44ot07NiRtm3b8vTTT7Nz584c92ZvpB4YGJhr3Lp16wIQERFRzG9TfKxWWL0afvzR4HCEhXR7Jl3vNlOrjpIpERGRkqRwSvJ16b5Ta06swWK3XPae/4X+j1RLaoF9dsXtYs/ZPYWqYfyO8cSl5ZxhtT9+PyeST+Tqe7nwTERERApmt9v58MMPsdlsjlP4ssOpmTNnkpGRQb9+/ejSpQubNm3i8ccfZ+3atY77ExIS8PT0xNvbO9fY2cv8UlJSrsKbFN2JE/DDD7BitY24ZDO16lt4dKiZG2+yU8QzX0RERKSIFE5Jvvae3YvFlhVIFbSk71KxabFM2DmhwD6/7r/8rKlsKZYUvtj+RY62/GqJTIrkdMrpQo8tIiIiFxmGwfvvv8+GDRto0aKFYy8qu91OnTp1+Oyzz5g8eTKvv/463377LVOmTMFutzN69GgyMzMBsFqteHp65jl+dnt239LEZoNZsw2OnbBgxkzP+8zc08dCBR9XVyYiInJ9UDgl+cq0ZbI/fj/nM88XacncjAMzOJKQez8Ju2Hnj4N/sCJqRZHqWBS+iK3RW4Gsb5yXR+a/dPBqLu0LORFy1Z4lIiJSkmw2G6NHj2bmzJnUqVOH77//3hEmPf/886xevZoHHnggxz1BQUH06dOHuLg4tm7N+nva29sbiyXvmdZmc9ahKuXLly/BN3FOitlC86BUGtxg5tGhZhrdYHd1SSIiItcVhVNSoB0xO1h9fHW+G5PnxWbY+HDzhzk2Rz+RdIKnlz2dtcm5Ufixsn205SMsNgt7z+7lVMqpfPtdrXDqbPpZXl3zKtvOOLcJu81+bZxUJCIiZV9GRgYvvvgic+bMoX79+kyfPp2aNWsW6t6bbroJgJMnTwLg5+dHZmamI4i6VPZyvooVKxZT5c7LyID582FrqJ3j59I4fi6NuvVt3HmvFe/Sl52JiIiUeQqnpEBhsWEsiyrckr5/3rcgfAE2u43p+6fTb36/KzpNL/x8ONP2T7vs8sLNpzcXKUhz1ubozVgNK2/8/QZn088W+r50azr/C/0f0/ZPK8HqRERECicpKYmhQ4eyZs0abrrpJn777Tfq1KmTo8++ffscp/D9U/YSPS8vLwAaNGgAXAyrLpXd1rBhw+Iq3ymHDsF338GGzTZ+DzYTl3j5PTVFRESkZCmckgJtO7ONLae3OHXvF9u+4MmlT/K/0P+RYcu44lp+3P0jiyIWFdgn2ZLM3rN7r/hZl7PxVNYMrbj0ON5a91ahZkJtO7ONR+Y/wvT90wu9IbyIiEhJyczMZPjw4ezcuZOgoCCmT59O1apVc/UbMWIEQ4YMIT4+Pte17du3A9CyZUsA2rdvD5BnmLVlyxYqVqxI48aNi/M1Ci01FWbPhhm/GpyIMeNW3sy9D5jx9HJJOSIiInIJhVNSoGRLslPL8ADiM+LZGbez2GpJt6YXapZSSS/tsxv2HM/YEr2FH3b/kG//NEsaH2/5mKeWPcXx5OMA7D+3v0RrFBERuZyvv/6aHTt20LZtWyZOnOg4Te+f7r33Xux2O1999VWOJftLliwhJCSEW265haZNmwLQo0cPfHx8mDRpEomJiY6+s2fPJjIykv79++PmdnW//TQM2LMna7bU1jAr8WmZtGhrpv/jZmrXNS4/gIiIiJQ4D1cXIFLcNpzewL/a/KvExj+ScIRzGedytP2460faVmtLpzqdgKyN2w/EH2BF1AoWHFtATFpMjv6nUk6RmJFIgHdAidUpIiKSn7i4OKZPnw5Ao0aNmDhxYp79hg8fzgsvvMDatWv5888/OXToEO3btyciIoKQkBCqVavGJ5984ugfEBDA66+/zvvvv0/fvn3p1asXMTExLFmyhAYNGvDcc89dlfe71Nmz8OdsO0lpVipWsnHP3Raq11QoJSIiUpoonJIyZ+/ZvSRkJFDJu1KB/QzDwGpYKedWrkjjbzi9IfdYGLy17i0+uf0TtpzZworIFZxMyb3fxqX2n9vvCLNERESupl27djlO1ZszZ06+/YYOHYqfnx9//PEH48ePZ8WKFUyfPp2AgAAeeeQRXn75ZapXr57jnkGDBuHv78+kSZP49ddf8ff3p2/fvrz66qsEBASU5GvlqVo1aNIyAzt22gbZcHe/6iWIiIjIZSickjLHbtgZtGgQ/+30X4JqBeXZ52z6WT7c/CG31bqNR5s9WqTx81s2mJCZwPMrny/0OPvO7VM4JSIiLtGjRw8OHTpU6P5+fn688847vPPOO4Xq37t3b3r37u1secWu0x02Mix2V5chIiIi+dCeU1ImnUo5xdPLn2bMpjGkWlId7YZhsODYAh6c9yCrjq+67Ol//5RmSSMsJqxYatx3bl+xjCMiIiIiIiJyLdPMKSnT/jz8J+tOreP9ju/TOKAxYzaPYe3JtY7r22O2E5cWR7UK1Qo13raYbVjsxXPktDZFFxEREREREdHMKbkORKdG89zK5+gzr0+OYAqy9opaEbWi0GNtOr2pWOs6l37u8h0vw2KzsCh8UTFUJCIiIiIiInL1KZyS60a6NT3P9qIs7ctrM/QrURyzp77Y/gVfh32N3dBeGiIiIiIiInLtUTgl172w2DBiUmMu2y86JZqI8xHF+uwr3XdqeeRyfj3wK2dSz7A7bncxVSUiIiIiIiJy9SicEoFCLe3L75S+K3ElM6eikqJ4d+O7js+FmQF24NwBDMNw+pkiIiIiIiIixU3hlAiwNHLpZfsU95I+cH7mVIY1g5EhI3OcRLg8cnmBS/syrBkMXzGc8TvHK6ASERERERGRUkPhlAiwK24X0SnR+V632W1sjt5c7M+NTYslLi2uyPeN3TqWQwmHco6VHsvO2J353rM4YjGJmYn8tPsnvtnxjQIqERERERERKRUUTolcsDxqeb7X9p7bS7I5uUSeW9SlfQvDFzLnyJw8r+W3tM8wDGYcmOH4PGnPJL4K+0oBlYiIiIiIiLicwimRCwras2njqeLfbypbUZf2/Xnoz3yvLY9ajs1uy9UeeiaUIwlHcrT9svcXvtj2hQIqERERERERcSmFUyIX7Dm7h1Mpp3K1R6dEszhicYk9tygzp9Isaew5uyff62fTzxIWG5ar/dJZU5eaun8q0/ZPK/TznXUm9UyJP0NERERERESuTQqnRC6xPPLi0j7DMPjz0J88NP8hIpMiS+yZ+87tK/TspZ2xO7HarQX2+ecMsBPJJwg5EZJv/4KWMxYHi83CqLWjNENLRERERERE8qRwSuQS2cHOyeSTPLv8WcZsHpPjRLyScDb9LLFpsYXqu/XM1sv2WRG1IkeA9fvB3zHIPxjad3YfaZa0Qj3fGcFHg9kVt4uopKgSe4aIiIiIiIhcuxROiVxi37l9jN8xnn7z+7HlzJar+tzCCI0JvWyf+Ix4tsdsByDVkkrwkeAC+9sMW55LAYuD2Wbmp90/AYUL1kREREREROT6o3BK5B9+3P0j6db0q/rMwuw7lWpJZd/ZwoVY2TPA/jr6FymWlMv2L6ngaO6RucSkxQBZm7KLiIiIiIiI/JPCKZFSoDAzp8JiwrAZuU/iy8vKqJVYbBZ+O/hbofpvO7Ptsn3Wn1rPxtMbsdgthRoz05bJxN0THZ9Dz4Rq3ykRERERERHJxcPVBYhI1swpwzAwmUz59inMkr5sCZkJfBX2VaH3edp/bj8p5hR8PX3z7TMubBwH4w/i7+XPnYF3cneDu7m15q2Ucy+XZ//Zh2cTm35xL61zGeeIOB9Bo4BGhX4PERERERERKfs0c0qkFIjPiOdM6pkC+4RGF21Z3PT90wvd93L7TkWej+Rg/EEAzmeeJ/hoMC+sfIG759zNyqiVufpnWDOYtGdSrnbtOyUiIiIiIiL/pJlTIqXE7rO7qeVbK89ryeZk9sdffl+qK7E1eit31L0jz2vLo5bn2X42/SyvhrzKPQ3u4e2gt6lSvgoAsw7P4mz62dzPOLOVR5s9mm8NsWmxHEs8dtlafcr50Kpaq8v2ExERERERkdJP4ZRIKfH7wd+5u/7deS7tC4sJw27YS/T5BS0bXBq5tMB7l0UuY2v0Vt6+9W26BXZj8p7JefbbdmZbgcsXPwv97LLPAnA3ubOg7wIC/QIv21dERERERERKNy3rEykltsdsz3fZ29U46e5g/EGSzEm52sMTwzmScOSy9ydkJvDG328wYMEAzmWcy7fP0cSjeV47k3qGFVErClWrzbDx4+4fC9W3OO2K28Wfh/7Mc1aYiIiIiIiIOEfhlEgp8t3O7/I80e5q7NVkN+xsP7M9V/uyqGVFGicyKbLA6/m9y8xDMwt9GiHAgvAFhd7wvTjEZ8TzWshrjNk8hrtm3cWwZcP4/eDvxKXFXbUaREREREREyiKFUyKlyI7YHWyK3pSj7Xzmecdm5CUtr6V9yyPz3m/KWdvObMvVlmHNYPbh2UUax27Y+XHX1Zk9ZbPbeHvd28SmxTqeHXomlI+3fMzds+8mMSPxqtQhIiIiIiJSFimcEill/jl7KiwmDIPcs6lKwj+XDx5NOJrvMjynnxETmmv/rEXhi0jMTCzyWIsiFhFxPqKYKsvfxD0T2Xh6Y57XrIaV1SdWl3gNIiIiIiIiZZXCKZFSZnfcbjac3uD4fDWW9GU7FH+I85nnHZ+LuqSvMM5nns+xh5VhGMw4MMOpseyGnR92/VBcpeVpc/Rmvt/5fYF9lkUW/++TiIiIiIjI9ULhlEgp9N2Oi7OnrsZm6NkMDMeyO8MwSix0uTRw23pm6xXNzloSsYRjiceKo6xcYtNiefPvNy87c21L9BbiM+JLpAYREREREZGyTuGUSCm099xe1p1aR2JGIocSDl3VZ2fvO3U44XCJLZm7NHBzdtZUNgOjRGZPWe1W3vj7jUKFTjbDxqrjq4q9BhERERERkeuBwimRUuq7nd+xLSb35uElLXtWU0kuVdsWsw2b3caJpBOsPbH2isdbFrnMsVTQZrex7cw2PtnyCT1n9+TJpU/y24HfHJuZF4bNbuP/Nvwf22Nyn15YUA1FtTxyOYfir274KCIiIiIiUtp4uLoAEcnb/nP7Gb9j/FV/7pGEI8RnxLM8qnhP6btUsjmZQwmHWHBsQbFs9m5g8GnopzTwa8Cq46s4m37Wce1M6hm2x2xn7NaxtK3elrsb3M0jTR/By90rz7GsdivvrH+HJRFLilRD6JlQzqafpWr5qoXqn2pJ5dPQT+lcuzP/7fzfAvtabJY8N12/vc7tVChXoUh1ioiIiIiIlDYKp0RKsWPnS2YvpcuZsX8GUUlRJfqMkBMhzDs6r9jG2xK9hS3RW/K9bmAQFhtGWGwYfxz8gzGdx9Cmepscfax2K2+ve5ulkUuL/Hy7YWdV1CoGNhtYqP4/7PqB2LRYFoUv4pX2r1DZu3K+fYOPBjNm85hc7a+2f5VhLYcVuVYREREREZHSRMv6RCSXKfumlPgzft77MymWlBJ/Tl4ikyIZsmQI/wv9H+nWdAAsdgtv/P2GU8FUtsKebngk4QjT908HwGw3M/vw7Hz7mm1mftr9U57Xftn7C6mW1KIX6iIWu4Vp+6ZhtpldXYqIiIiIiJQiCqdEJBeL3VLiz8i0ZZb4MwpiYDB9/3Qenv8wm6M388baN1gRteKKxtx2ZluOJYV5Ptcw+GjLR9gMm6Nt5sGZ+f6ezzkyh5i0mDyvJWYm8vvB352qNfs0yKtpxv4ZfLbtMwYsGMCeuD1X/fkiIiIiIlI6KZwSkevaieQTPLv8WVYeX3nFYxkYLI8seK+uheELc220Hpsey4rI3MFYpi2TSbsnFTjeL3t/IcVcuBlo4YnhTNg1gX7z+/HXsb8KdU9xOZN6hgm7JgBZy1UfX/I4X277kgxrxlWtQ0RERERESh+FUyIixaigU/uSzEl8vu3zPK/9euDXXG2zD88mNr3gUwaTzEl53pst3ZrO9zu/p++8vjz414N8v/N7jiQc4cddP152hpxhGBxPOl5gn8K6dAklZO3R9cu+X+i/oD+rj6++6kv97IadyPORxTpmdEp0sY4nIiIiInK9UDglIlKMdsTuICY172V434Z9S3xGfJ7Xdp/dze643Y7PGdYMJu0peNZUtqn7p5JkTsrVnmZJ48VVLzJh14Rcm+ufTDnJgmMLChx3YfhCHvzrwUIFWQVZf2p9vksmI5Mi+feaf9NtZjfeWfcOa46vKfEln8eTjvP0sqcZtGhQsYVv84/Np8+8Puw9u7dYxhMRERERuZ6UynAqLi6Od999l65du9KyZUs6d+7MqFGjOHHiRI5+s2bN4sYbb8zza8CAAbnGDQkJYeDAgbRt25aOHTvyzjvvcO7cuav1WiJyHTAwcgQxdsNOWEwYY7eO5c/DfxZ476UzoP489Odl96/KlmxO5tf9OWdPpVnS+NeqfxF6JjTf+37a/RMWW96hU/YsL6vdyvid43ls0WMcjD9YqHoulWnL5OMtH1+2X7IlmQXhC3h5zct0ndmVH3b9UOz7YtnsNsc+Y9titpFiSWHk2pFXvLRw3tF5/Gf9f8i0ZTJq7SjOZ54vpoovL9mczPgd40nMSLxqzxQRERERKW4eri7gn+Li4ujfvz/R0dF07tyZ3r17ExERwcKFC1m3bh0zZ86kQYMGABw6dAiAZ599Fi8vrxzj1KxZM8fnhQsXMnLkSAIDAxk0aBDR0dEEBwcTGhrKnDlz8PPzuyrvJyJl35LIJdxY+UZWRK1gZdRK4tLjCnXf8sjljOwwEt9yvkzeO7lIz5y+fzqPNX8Mfy9/Ui2p/GvlvwiLDSvwnlMpp5h3bB79m/bPde2fs7wOxh9k0MJBPH3z0zzX6jnKuZcrVF0/7/2ZE8knLt/xEqmWVL7b+R0Z1gz+3e7fmEymIt2fl4jzEby74V12xu3M0X4w/iCfhn7Kex3fc2rc4CPBvLfxPQyygrRTKaf4z4b/8E33b4pUt92w42Yq2s+L1p9az/sb3ycmLYaQEyFMvHsilbwrFWkMEREREZHSoNSFU+PHjyc6Opq33nqLp556ytH+119/8cYbbzB27Fh++OEHICuc8vf3Z9SoUQWOmZqaypgxY6hfvz5z587F19cXgM6dOzN69GgmTJjAm2++WXIvJSLXld1xuxm2bFiR77MaVmYemknFchXzXf6Xn2RLMtP3T+fJFk/ywsoXcoUw+Zm4eyJ9G/fNETbtO7cvz1leVsPKj7t/ZNXxVXzY+UNaVG1R4Ngnkk8weU/RQrZLTd47Gbth59X2r15RQLUrbhfPr3ieFEveG8fPPjybdtXb0adxnyKNO/vwbD7Y9EGu9pATIUzbP42hLYYWapxlkcsYu3Us9f3q07N+T3rW70n1CtXz7X8+8zyfhX6WY1P7QwmHeHr500y6exKVvSsX6T1ERERERFyt1IVTq1atonLlygwdmvOb+gcffJDx48ezfv167HY7bm5uHD58mKZNm152zEWLFpGYmMjLL7/sCKYAHnnkESZNmkRwcDCjRo3C3d292N9HRKQoZh2a5XQQM+PADDad3sTus7sv3/mC6NRogo8GM+DGrKXQdsPOR5s/wm7Y873naOJRBi8enBWEtXkBL3evXH3Cz4fz8eaPr3j/qF/2/YLNsDGqwyinfl92xu7k+ZXPk2pJLbDfmM1juKnKTTQOaJyj/Wz6WTad3pTrPU6nnGbinon5jvfV9q9oVa0Vbau3zbfP2fSzfLzlY8cy0LPpZ9kes52xW8fStnpbugV2w88z56zedGs6v+z9Jc/ZeEcSjvD0sqyAqkr5Krnu2xK9hUb+jajnVy/fmkREREREXKFUhVOGYTB8+HDc3d1xc8u9vMHLywuLxYLFYiEhIYHExERuuOGGy44bGpq150pQUFCua0FBQcycOZMjR47QrFmzK38JEZErkJCZ4PS9qZbUIgVT2X7a/RN9m/TF092TOUfmsOfsnsveYzNsTN47mdUnVvPfTv+lTfU2HE04yoqoFSyPWs7RxKPOvEKepu2fht2w88YtbxQpoAqLCeOFlS+QZk27bN90azojQ0by232/kWpJZeXxlayIWsH2mO0FBnX5sRk2Rq0dxaw+s3LNZDIMg0URixi7dWy++1PtiN3BjtgdRX7u0cSjWQHVPZOo4FGBv0/9zfLI5aw/td5xWmKzys3oWb8nd9e/mwb+DYr8DBERERGR4laqwimTycSQIUPyvBYeHk54eDj16tXDy8vLsd+UzWbjxRdfJCwsjIyMDNq1a8dLL71EmzZtHPdmb6QeGBiYa9y6desCEBERkW84ZRgGZnPWMecWswW7tej/oiIiUlpFJ0Uzc99MejboyZdbvizSP+OOnTvG4wsep65vXU6kFG1vqaKYtmcaR88epXej3nSt2xVfT98C+28/s52X1rzkCGQK48i5I/SZ3YeYtBjHHlJX4kzSGQb/NZiaPjn3QEw2J3Mg4cAVj5+fI+eO8HDwwySbk/OcubY/dj/7Y/czLnQcNwTcwF3176JnvZ40CmiUq2+GNYONpzay+sRq4tL+MVvLBDdXvZme9XvStFLTXMGh2WZmS/QWVkat5EzqmVxjN6/SnJ71e3JTlZsKFTpa7Va2x2xnZdRKPN096Vm/J62qtSrUXl12w87O2J2sPL6SV9u9Sjn3chiGUSz7mYmIiIjIlStV4VR+7HY7H374ITabzXEKX3Y4NXPmTLp06UK/fv04fvw4q1atYsuWLXz33Xd07doVgISEBDw9PfH29s41dvYyv5SUvPciAUhMTOTjj7NOmzqWeIyUk/n3FRG5Fn2y8hOm+k7ldMJpp+4/QMmFLdmWX/iPm8mNehXr0SigEXV96+LulnNJdlxaHEsjl2K1W4v8jKMU34wvgP0X/nO1pVC4v6d2XPjP53xOJe9KNA5oTEO/hpw3nyc8MZyopCgs9rxPdARYzWrGMQ5/L38a+zemUUAjUi2pHEs8RmRSJGabucB7v+M7fD19aezfmMYBjfH38s/RxzAMzqafJfx8OOHnw3OcrPgTP1GhXAUa+TeiSUCTPDeDj0+P59j5Y4SfDyfNkjWDLuOmDDzcPEhMTKRSJW0gLyIiIlIalPpwyjAM3n//fTZs2ECLFi0ce1HZ7Xbq1KnDK6+8wgMPPODov3XrVp588klGjx7NqlWr8PLywmq14unpmef42e2ZmYXbF6VxQONce5KIiJQVXep0cXUJV6xahWo8cdMTri7jmubr6Usd3zrczu1FvreiZ0Vq+tSkc53OV1yHyWSiWoVqVKtQjVtr3Vrk+yuXr0zl8pW5peYtV1yLiIiIiJScUh1O2Ww2/u///o85c+ZQp04dvv/+e0eY9Pzzz/P888/nuicoKIg+ffowb948tm7dyu233463tzcWS94/+c1erle+fPl86wgICOCdd94phjcSERGR0uDvv/92dQkiIiIickGpDacyMjJ45ZVXWLNmDfXr1+eXX36hZs2al78RuOmmm5g3bx4nT54EwM/Pj8zMTMxmc64ZVNnL+SpWrJjveCaTKd+ZVyIiInLt0X5TIiIiIqXH5XcRdYGkpCSGDh3KmjVruOmmm/jtt9+oU6dOjj779u1znML3T9lL9Ly8so43b9CgAYAjrLpUdlvDhg2Lq3wRERERERERESmkUhdOZWZmMnz4cHbu3ElQUBDTp0+natWqufqNGDGCIUOGEB8fn+va9u3bAWjZsiUA7du3B8gzzNqyZQsVK1akcWPtIyUiIiIiIiIicrWVunDq66+/ZseOHbRt25aJEyc6TtP7p3vvvRe73c5XX32FYVw88nvJkiWEhIRwyy230LRpUwB69OiBj48PkyZNIjEx0dF39uzZREZG0r9/f9zcSt1vhYiIiIiIiIhImVeq9pyKi4tj+vTpADRq1IiJEyfm2W/48OG88MILrF27lj///JNDhw7Rvn17IiIiCAkJoVq1anzyySeO/gEBAbz++uu8//779O3bl169ehETE8OSJUto0KABzz333FV5PxERERERERERyalUhVO7du1ynKo3Z86cfPsNHToUPz8//vjjD8aPH8+KFSuYPn06AQEBPPLII7z88stUr149xz2DBg3C39+fSZMm8euvv+Lv70/fvn159dVXCQgIKMnXEhERERERERGRfJSqcKpHjx4cOnSo0P39/Px45513eOeddwrVv3fv3vTu3dvZ8kREREREREREpJhpoyUREREREREREXEZhVMiIiIiIiIiIuIyhVrWt2rVqmJ74F133VVsY4mIiIiIiIiIyLWtUOHUiy++iMlkuuKHmUwm9u/ff8XjiIiIiIiIiIhI2VDoDdFvueUWgoKCnH7Qli1b2LZtm9P3i4iIiIiIiIhI2VPocCooKIgRI0Zc0cMUTomIiIiIiIiIyKUKtSH6Qw89RPPmza/oQc2aNaNv375XNIaIiIiIiIiIiJQthZo59cknnxRqMJvNxsmTJ6latSo+Pj45rvXo0YMePXoUvUIRERERERERESmzCjVzKi9btmzh3//+NzabDYCDBw9y1113ce+999KpUyfGjx9fbEWKiIiIiIiIiEjZVOg9py61ceNGnnnmGQzDIDo6mrp16/LOO+9w5swZbrvtNmJjY/nuu+8IDAzkwQcfLO6aRURERERERESkjHBq5tTkyZPx9fVl1qxZ1K1bl0OHDrF//366dOnClClTmDdvHo0aNeK3334r7npFRERERERERKQMcSqc2rt3L71796Zly5YAhISEYDKZ6NWrFwCenp7cfvvtHDlypPgqFRERERERERGRMsepcCozM5OKFSs6Pq9fvx6Azp07O9rsdjseHk6tGhQRERERERERkeuEU+FUvXr12LVrFwDR0dHs2LGDJk2aULNmTQDMZjNr164lMDCw+CoVEREREREREZEyx6lwqmfPnmzdupUnnniCxx9/HJvNxsMPPwxkLfF79NFHOX78OAMGDCjWYkVEREREREREpGxxat3dCy+8QGxsLHPmzMEwDO677z6eeOIJALZv387Bgwd56qmnFE6JiIiIiIiIiEiBnAqnzpw5w5gxY3jzzTcB8PX1dVwbMGAAQ4cOpWrVqsVToYiIiIiIiIiIlFlOLesbMmQIr7zyCr6+vjmCKYDAwEAFUyIiIiIiIiIiUihOhVNxcXHUrVu3uGsREREREREREZHrjFPhVNu2bdm4cSNms7m46xERERERERERkeuIU3tODRo0iA8//JB77rmH22+/nbp16+Lt7Z1n3yFDhlxRgSIiIiIiIiIiUnY5FU69+uqrjl//+eef+fYzmUwKp0RERERKqbi4OL799lvWrl3LuXPn8Pf3p2PHjvz73/8mMDAwR9958+YxZcoUIiMj8fPzo1evXrz88sv4+PjkGjckJIQJEyZw+PBhvL296d69OyNHjqRKlSpX69VERETkGuJUOPXJJ58Udx0iIiIi17WHHnqoWMYxmUzMnTv3sv3i4uLo378/0dHRdO7cmd69exMREcHChQtZt24dM2fOpEGDBgD8+OOPfPnll9x44408/vjjHD58mClTprBr1y6mTZuGp6enY9yFCxcycuRIAgMDGTRoENHR0QQHBxMaGsqcOXPw8/MrlvcUERGRssOpcKq4vnkSERERkSwHDhwolnFMJlOh+o0fP57o6GjeeustnnrqKUf7X3/9xRtvvMHYsWP54YcfOH36NN988w3t27dn6tSplCtXDoBx48bx/fffM2vWLAYPHgxAamoqY8aMoX79+sydO9dxqnPnzp0ZPXo0EyZM4M033yyW9xQREZGyw6kN0S/HarVy9uxZ5syZUxLDi4iIiJRJI0aM4ODBg05/vfjii4V+1qpVq6hcuTJDhw7N0f7ggw9Sr1491q9fj91uZ+bMmVitVp577jlHMAXw/PPP4+vry6xZsxxtixYtIjExkaFDhzqCKYBHHnmEhg0bEhwcjM1mu4LfIRERESmLnJo5ZbPZ+Pzzz1m4cCEJCQkFfpPx8MMPO12ciIiIiBSeyWTCMIzL9jMMg+HDh+Pu7o6bW+6fVXp5eWGxWLBYLISGhgLQoUOHXH3atGnD+vXrSUlJwdfX19E3KCgo15hBQUHMnDmTI0eO0KxZM2deT0RERMoop8Kpn376iV9++QUvLy8aNWpEeHg4VapUwc/Pj5MnT5Kenk6VKlV47rnnirteERERkTJp1apVV7wf09ChQwu1/UJBh9aEh4cTHh5OvXr18PLy4vjx41StWjXPjc/r1KnjuKdVq1acOHECINdm6gB169YFICIiQuGUiIiI5OBUOLVo0SL8/f2ZP38+NWrU4Mknn6Rq1ap8/vnnZGZm8uGHHzJ79myaNGlS3PWKiIiIlEnZQU82m83GgQMHiIuLIzU1FR8fH+rWrUuTJk3y3VeqYsWKVKxY0eka7HY7H374ITabjQEDBgCQmJjoCJbyeh5ASkoKAAkJCXh6euLt7Z2rb/Yyv+y+IiIiItmcCqdOnjxJnz59qFGjBgA333wzixYtArKmeH/wwQds27aNKVOm0KlTp+KrVkRERKSMO3HiBN9//z3Lli0jPT0913U/Pz969+7N8OHDqVWrVrE91zAM3n//fTZs2ECLFi0ce1FZrdYcp/FdKrs9MzOzyH1FREREsjkVTgFUrlzZ8esGDRoQHR3t2G/Azc2NLl26sGrVqmIpUkREROR6sHbtWl599VXS0tLw9vamTZs21KhRA09PT1JTUzl16hRHjx7l999/Z8GCBXz55ZfccccdV/xcm83G//3f/zFnzhzq1KnD999/7wiTvL29sVgsed5nNpsBKF++fJH7ioiIiGRzKpyqXbs2ERERjs/169cHso5AvuWWW7IG9vAgPj6+GEoUERERKfsiIyP597//jd1u54033mDw4MF4eXnl6peUlMQff/zB999/z7///W/mz5+f5x5PhZWRkcErr7zCmjVrqF+/Pr/88gs1a9Z0XPfz8yM5OTnPe7Pbs5f3+fn5kZmZidlszjWDKns535UsOxQREZGyKffxLIXQtWtXVq9ezezZs7HZbNx00014e3szffp0IOubppUrV+b4xkZERERE8vfzzz9jNpuZMGECw4YNyzOYgqwAaPjw4UyYMIH09HSmTZvm9DOTkpIYOnQoa9as4aabbuK3337LtfdVgwYNOHfuHBkZGbnuP3XqFG5ubo4fVDZo0ADI2gLin7LbGjZs6HS9IiIiUjY5FU49++yz1KxZ0zH9u0KFCgwYMIDly5fTpUsX7rrrLk6ePMkDDzxQ3PWKiIiIlElbtmzh1ltvpXPnzoXq37FjRzp06MDmzZudel5mZibDhw9n586dBAUFMX36dKpWrZqrX/v27bHb7Wzbti3X/Tt37qRJkyaOzc7bt28PQGhoaK5xtmzZQsWKFWncuLFT9YqIiEjZ5VQ4VblyZebNm8err77KzTffDMDIkSMZNGgQmZmZeHl5MWzYMIYPH16sxYqIiIiUVbGxsTRt2rRI99x00015zlIqjK+//podO3bQtm1bJk6c6AiY/qlPnz64u7szfvx4x75RAD/88AMpKSkMHDjQ0dajRw98fHyYNGkSiYmJjvbZs2cTGRlJ//79cXNz6ttPERERKcOc3hDd19c3R/jk6enJe++9x3vvvVcshYmIiIhcTzIyMvINiPJTsWLFPJfbXU5cXJxjO4ZGjRoxceLEPPsNHz6cRo0aMWzYMCZOnEjfvn3p3r07R48eJSQkhHbt2jFgwABH/4CAAF5//XXef/99+vbtS69evYiJiWHJkiU0aNCA5557rsi1ioiISNnndDiV7dixYxw4cIDz588zePBgTp06hb+/f5G/uRIRERG5nhmGgclkKtI9Re2fbdeuXY5T9ebMmZNvv6FDh+Ll5cXIkSOpVasWv/32G9OmTaNatWo8+eSTjBgxItfG54MGDcLf359Jkybx66+/4u/vT9++fXn11VcJCAhwql4REREp25wOp44ePcro0aPZvXs3kPXN0eDBgwkODuaXX37h/fffp0+fPsVWqIiIiIgUjx49enDo0KFC98/+Pm/w4MGF6t+7d2969+7tbHkiIiJynXEqnDpx4gSDBw8mLS2N+++/n7Nnzzo246xbty6GYfDmm29Sq1YtOnToUKwFi4iIiJRVBw8eZN68eYXuf+DAgZIrRkREROQqcSqcGjduHJmZmfz55580b96c8ePHO8Kpvn370rJlSwYMGMBPP/2kcEpERESkkFatWsWqVasK3d+ZpYAiIiIipY1T4dTGjRvp1asXzZs3z/N6kyZNuPfee/n777+vqDgRERGR68WIESNcXYKIiIiISzgVTqWkpFCpUqUC+/j5+ZGcnOxUUSIiIiLXG4VTIiIicr1yc+amwMBAwsLCCuyzdetWAgMDnSpKRERERERERESuD06FUw888AA7d+7k66+/xm6357hmNpv59NNPOXDggE5pERERESmi+Ph4goODOXPmTI72DRs2MHToUO644w769+/PH3/84aIKRURERIqXU8v6hg0bxsaNG/nhhx/4/fff8fT0BOCJJ57gyJEjJCYm0rp1a5555pliLVZERESkLFuwYAH/93//R2ZmJuPHj6dmzZoALFmyhFGjRmGz2ahQoQIpKSl88MEHhIaG8sUXX7i4ahEREZEr49TMqXLlyjF58mRGjRpFpUqViIuLwzAMQkNDqVChAiNGjGD69OmO0EpERERECnb48GHeeustPDw8GD58uOPgmbS0NP773/9it9sZNGgQW7duZevWrQwbNozFixezePFiF1cuIiIicmWcmjkF4OHhwTPPPMMzzzxDWloaycnJ+Pj44OvrW5z1iYiIiFwXpkyZgslkYubMmTRu3NjRvnLlShISEqhUqZIjvAIYNWoUK1euZM6cOdpKQURERK5pTs2ceuKJJ5gzZw4pKSkAVKhQgRo1aiiYEhEREXHS1q1b6d69e45gCuDvv//GZDLRvXt3vLy8HO0mk4lOnTpx4MCBq12qiIiISLFyKpzau3cv//nPf+jSpQuvvfYaa9euxWazFXdtIiIiIteNuLg46tevn6t969atAHTu3DnXNT8/P5KTk0u8NhEREZGS5NSyvk2bNrFy5Urmz5/P8uXLWbJkCZUqVaJ37948+OCD3HzzzcVdp4iIiEiZ5unpSXp6eo62qKgoYmNjMZlM3HrrrbnuiY2Nxd/f/2qVKCIiIlIinAqnvL29uf/++7n//vtJSEhg8eLFzJ8/nxkzZvDrr79Sv359+vbtS58+fahTp05x1ywiIiJS5jRu3Jg9e/bkaFu+fDkAzZs3p2rVqjmumc1m1q1bl2sZoIiIiMi1xqllfZeqVKkSgwcPZubMmaxZs4b//Oc/mM1mxo0bR48ePRgyZAgLFy7Usj8RERGRAvTu3Zs9e/YwZcoUbDYbx44dY+rUqZhMJh566KFc/T/99FPOnTtHz549XVCtiIiISPG54nAq2+bNm/nhhx/46aefOH36NO7u7nTq1ImIiAhGjRrFgw8+SFRUVHE9TkRERKRMeeyxx7j55pv59NNPad26Nffffz9nz56lVatWPPbYY45+P/30E/369ePXX3+lUaNGDBw40IVVi4iIiFw5p5b1Zdu9ezeLFi1i8eLFnD17FsMwaNGiBc888wz33XcflStXxm63M2vWLN5//33efPNN/vjjj+KqXURERKTM8PDwYOrUqUyaNImQkBCsViudOnVixIgRuLu7O/r98ccfnD59mltvvZUvvviCcuXKubBqERERkSvnVDg1btw4Fi1axIkTJzAMg5o1a/LMM8/Qt2/fXPseuLm5MXDgQKZOncqhQ4eKpWgRERGRsqh8+fK89NJLvPTSS/n2+eijj6hevbr2mhIREZEyw6lwasKECZQvX54HHniAvn37ctttt2EymQq858Ybb6RTp05OFSkiIiIiWTp27OjqEkRERESKlVPh1NixY7nnnnsoX758oe/56quvnHmUiIiIyHXh9OnTBV53c3PD19cXX1/fq1SRiIhcr2w2K4uD/2TVor+IPXOagCpV6H5PHx4aNBQPj8LFCBFHDzNzyo/s370DgEY33MhDg56kdYdbc/Ud9/G7rFu1NM9x+j46hMefHeH8y5RRdrudFYuC6dqjN94XspmZU39i1rRJvPHB/wjq0o3YM6f51+C+3NLpDt4c87mLKy5Yof5XNWTIEPr160ffvn0BHP9dFMHBwcybN4+pU6cW+V4RERGRsu7OO++87Ex0gHLlynHzzTfzyCOP5HmKn4iIyJWaNO4zViwKplnL1nTodDsH9+5i5pQfiTp2hFHvj73s/ft3h/HhW//GYjbToePtVK9Zmx2hm/jwrZcZNmIkvfoOyNE/KvwoAZUq07NPv1xjNW/Zprheq0wZ9/G7bFiznC7d73a0tWjdHoZAnXoNXFeYkwoVTm3dupWgoKAretCpU6fYunXrFY0hIiIiUlbdcsstl+2TmZlJbGws27dvJywsjM2bN/Ppp59ehepEROR6cXDfblYsCqZTt5689n8fAWAYBuM//YC1KxazffN62t/WJd/7bTYb33/2IebMTEa++wkdu94FwGOZGXz09itMnfA1bTrcRq269QCwWq2cPhFJu9u6MHDo8JJ/wTIiIf5srraWbdrTsk17F1Rz5Qq9rG/x4sUcPHjQ6QeFh4c7fa+IiIhIWTd9+vRC9z116hRjx45l/vz5dO/enXvvvbcEKxMRkevJ0r9mAdD/iacdbSaTicHPvMjfK5ewavFfBYZTxw7t58zpk7S5paMjmALw8vLmsaf/xX9efoYl82YxbMRIAE5GRWC1WqnfsEkJvZFcCwodToWHh19xwFSYqeoiIiIiUrA6derw1Vdf0bNnT2bNmqVwSkREis2B3TvwC6hEYINGOdorV61Grbr1HHtI5Sf2TNYeijc0b5HrWv1GWQHUwb27HG3Hw48CENiwUa7+hZG9r9LDg58isEFjZk+fTOyZ01StXoMe9z3E/Y8Mws3NLcc94YcPMmv6JA7s2Yk5M5PagfXo2acfd9/fL0du8chdQXS7+z6q16rNwtm/ASb6D3mGPo88BsDqpQtYvmAuJ6Mi8C5fnhuatWDgk8/RoPENOZ63ce1KFs7+nePhRzG5udH4xuY8MngYLdt2yPUe/Yc8Q6MbmjFnxs8cjziGd4UK3NLpDgY/8yJ+/gGOurINffAubmrdjv9++UOuPafyY7FYWDDrV/5esYSY6FP4VvSlc6dOvPLKKwQGBjr153ClChVOrVq1qqTrEBEREZEi8PDw4PbbbyckJMTVpYiISBlhMZs5FxfLDc1b5nm9es1anD4RxfnEBPwDKuXZx6Ocp2Osf0pLSQEgLiba0RYVfgSA6JPHGf3yM0SFH8XTy4t2QZ0YNOwFqlSrXqjaw7ZsZO5vU2h/Wxda33IrO7ZsZNqP4zgecZQRb76Xo99n772BR7ly3HZ7d/z8A9i5bTMTv/6UiCOHeP61d3KMu2PrJiyWTLrdfT+JCedoeuH3ZsIXH7Fq8V9Ur1mLrj17Y7WYWbd6GXt2bOPDcRMdAdUfv/zI7BmTqV6rNt3uuR+TCTb9vZr/vjGCEW+8xx09e+V43vZN65kz42fa3daFFm3as2v7FlYt/ou4M9G8+9l4APoPeYaQZYuIi4mm76NDqBPYoFC/R5C1jPKjt//N3h3baNq8Jff27Q+ZKSxftpT169czffp0mjZtWujxikuhwqk6deqUdB0iIiIiUkSVK1cmMTHR1WWIiFw3LLnzFgeTG1x6kF1BfTFBuXJO9rUARt5dL+RCTktJTgLAJ5+TYSv4ZLWnpabkG041btoMgG0b1/HoU8/nON0vdOPfjvuzRUVkzZya8+sv3NqlO01vupkjB/YSsnwRu7Zv4eNvf6ZajZqXrT3i6CGeeO5lHhzwOACPDfsXY958iZDli+h2z/20bNOezIwMxv/vA3x8ffnkuymOcQc/O4KvP/oPKxfNI6hzN9rd2skx7vnEeN4a8wUdOt3uaNsdtpVVi//iptbtePvDLyhfwQeArnffx7uvPsfMKT/y5pjPOXJwH3N+/ZmWbTvw9kdf4uXlDcCAocMZ/dLT/PT1WNoEdXTMiAIIP3KQ1979mE5dewAwyPoCrz/3OLvDtnLm9Elq1q7LwKHD2bcrjLiYaB4aNBQf34qX/f3JtmjO7+zdsY2HBj3J4Gf+BUDTmr489eRQBg4cyOjRo5k1a1ahxysuhV7WJyIiIiKlS3x8PP7+/q4uQ0TkujFxvFe+1+o3tHPfQxbH519+8MJqzbtvnbp2Hhxwse/0yZ5kpOe9DU71GnYeGXyx7x9TPUlOyrvvv17LLKj8y7JeKNgjn5TL40JKltesqGzVatTitjvuZPPfq/nig7d4fPhLBFSqwvZN6/ht8nd4eXtjMV98H09PL2rVCeSN//6PwAaNHe1zfv2Z33/+gZ/Hf86bYz6/bO3VatTi/ocfdXz28vZm0LAXeO+151m3aikt27QndOPfJCUmMOS5f+cIvNzc3Bg07AU2hqxk9dL5OcIpTy8v2l7yGWDD6uUAPP7Mi45gCuCmVm0Z/MyLVPTL+rt59ZL5GIbBE8NfcgRTABX9/HlgwOP88OXHbFizgl59+zuu1ahVxxFMQdZM6VbtgjgRGU70yRPUrF33sr8XBVm1ZD4+vhV59Kmcm8+3aNGCe++9lwULFnDkyBFuuOGGfEYoGQqnRERERK5BmZmZrFmzhiZNtIGsiIgUD0+vrPDNarHkeT273cvbO8/r2V4YOZrk8+cJ3fi3Y7aUh4cHQ57/NysXzSMu5oyj7xv//SzPMR4a9CSrlswnbMsG0tPTKF++QoHPvLFlK9zdc0YcTZrdBEDUsaylg+FHsg55O3b4ADOn/pRrDDc3dyIv9M1WtVoN3N3dc7RFhR/Fzc2dxjc2z6PuoY5fZz9v89+r2bZpXY5+8XGxAEQeO5yjPfsUw0tlz1izFDjF7vLS09M4fSKKgMpVmD3jZ0d7FV9PPNzcOHs26wTAAwcOKJwSERERkYLFxMTwf//3f5w9e5aRI0e6uhwRkevGsyPyn5lkyrnnNk89X8Aspn9MfHri6YLWC+b8+OhQc77L+q5UBR9f3Nzcciy7u1R2e3ZYkh8f34q8/8X37N6+lfAjB6ng60uH27pQpVoNZk+fjH+lypetxc3NjQaNbiA2+jTxcbHUqdegwP5VqlTL1ebl5U0FHx9H3akpyQBsWLM833FSks7n+Jwd2OXok5KMp5dXrjDsn1Iv7LEV/PvU/J93YSlltnKXruHMlv2/AePK/uCz9/xKjD/HrGmT8u13/vz5fK+VFIVTIiIiIqXAkCFDLtvHarVy7tw5Tp48ic1mo2fPnvTt27fkixMREaBoezqVWN88soviUq5cOarWqOk4ce+fYqNP4+cf4Fi2VhCTyUTrDrfSusOtjra4mGiSzifStEUrADIzMogKP4KnlxcNGufehNtszgr4ynle/jcou++lbDYrmRkZ+F6o17t8eQDe+/w7bm57y2XHzI93+fKYMzOx2ay5AqrMjAzHzDLv8uVxc3PntyXrcuy95SreF2afNb+5DWO+vjhzrGlNX7w83PO77apw/e+OiIiIiLB169ZC9fPw8KB169Y8+OCDDBgwoISrEhGR602zlq35e8USTp+IonZgfUd7/Nk4ok+doP1tXQq832q18spTA6jXqAlvfPC/HNc2r1sDQJsOtwGQmHCOd156mnoNm/DlpN9y9M3MyCD8yCH8AipRrUaty9Z95OD+PNtsNhs3NGsBQINGWQFY+OGDucKp5KTzzJ4+mUZNm9G1Z+8Cn1WvYWMijx4m/Mghx9jZPhn9KuFHDjHxz8U0aHQDkUcPE3n0sGOJYbZD+3YTuvFv2t3aiZtatbvs+/2T6Z9T6grBx9eXajVqcSIyHLM5E0/PnLPC5s2bx4kTJ+jbty+BgYFFHv9KuF2+i4iIiIiUtFWrVhX4tWbNGkJDQ9m7dy+//fYbAwcOxGQq+jemIiIiBenW8z4Afps8AbvdDoBhGPw66TsMw6DHfX0LvN/Dw4Mq1Wqwc+smok+dcLRHhR9lzoyfCahUme733A9kbf7d+MbmHI84yt8rlzr6GobBjEnjSUpM4J4+Dxfq77ujB/exfvXF5Xrp6WnM+Olb3NzcHGFTUJduVPDxYd4f03LUBjDjp29ZNPcPok/mbM/LHT16AfD7zz+QmZnhaD+4bzf7d+/kxhat8PL2ptuF95wy4SvS01Iv1paWysRxnzLvj2nYbLbLPi8v2ftgWfPbdT8f3e65j5TkJH6b9D3GJcsEjx49yn//+19+/vlnAgICnKrpShRq5tT48eOdGtxkMvHiiy86da+IiIjI9aROnTquLkFERIRW7YPo1K0nG0NW8M5LT9OyTXsO7dvNgT07ue2OO3PNnMreWHzg0Iunvw15/mVGv/Q0o196ms533o3VYmHDmhVYzGZe/fCLHBuqD3/lLd577QW+Hfsem9etpnqNWhzYu5Njhw5wU6u29HvsyULV7VvRj28+eZdNf6+iStXqhG3ZwJnTJ3l48FM0atoMyJo59PzI0Yz76P8YNXwwQZ27UblKVfbtCuPoof00uqEZDwwYfNlntelwG3fe24fVSxcw6tnBtA3qRFpqChtDVlLBx4dnXn4dgJZt2tP7oYEsDp7Jq08/SrtbO+PhUY6tG0I4GxtDj/v6Or28sEq16gBM+PxDbm4XxH39BhbqvocGDWVn6GYWzvmd/bt3cFOrtnjYM1i+bBnp6emMHTuWihUrOlXTlXA6nMpOLo08NuQymUwYhqFwSkREREREROQa8/LbHxDYoBEhyxayaM4fVK1eg4FPPkffgU/kmsWUvbH2peFU46bNGTNuIr9N/p6/VyzBw6McLVq3o/+QZ2l0w4057m/ctDmffj+FP6b8yN4d2whL30D1GrUczyvMflOQtY/S7Xfdw+8//8COrRupW68hL7/1AXf07JWjX6euPahStTrBv09lx9aNmDMzqVazFg8/PowH+j9+2c3es70w6j80vrE5KxYGs2JhMOU8PWl7ayceG/YCNWpd/IHTsBEjaXLjTSydP5u1Kxbj7u5O7br16f/EM3S/t0+hnpWXfoOf4uTxSHZu28yp45GFDqc8Pb14/4vvmT9zBhvWrGDZ/DlU9KtIu3btGD58OLfeeuvlBykBJiOvdOkfQkJCcnzOyMjgo48+wm63M3ToUNq1a4e/vz/nzp1j3759TJkyhQoVKvDRRx/RoUOHkqr9qrjrrruArKn2IiIiUjbo7/fSpaT/PI7EJJNhsZfI2CIi4lqxZ07zr8F9uaXTHbw55nNXl3NNKqkN0Yvy93uhZk5169Ytx+exY8dis9kIDg6mRo0ajvYbbriB2267jfvvv59+/foxf/78az6cEhERERERERGRkuPUhugLFiygd+/eOYKpS9WoUYOePXuybNmyKypORERERERERETKNqfCqczMTNLS0grsk5qamud+VCIiIiIiIiIiItkKtazvn1q0aMHy5ct5+umnady4ca7rO3bsYNmyZXTp0iWPu0VERERERERErlz1mrWZvWqrq8uQK+RUODVixAieeuopBgwYwEMPPUTLli3x8fEhOTmZsLAwFixYQLly5XjllVeKuVwRERGR68uWLVuIjIzEbDbnOyt9yJAhV7kqERERkeLjVDh1yy238N133/HBBx8wY8aMHEdJGoZBkyZN+Pjjj2natGmxFSoiIiJyPTl16hTPPPMMkZGRAPkGUyaTSeGUiIiIXNOcCqcAunbtysqVK9mxYwcHDx4kJSUFPz8/WrRoQatWrYqzRhEREZHrzueff05ERASdO3fmjjvuoGLFijl+ICgiIiJSVjgdTgG4ubnRvn17ateuTXp6OgEBAVSuXLm4ahMRERG5bm3YsIFbbrmFyZMnu7oUERERkRLldDiVkZHBuHHjmDt3LklJSY72KlWq8MADD/Dyyy/j7e1dLEWKiIiIXG8sFgutW7d2dRkiIiIiJc6pcCo9PZ3HH3+c/fv34+fnxy233EL16tVJSkpi165d/Pzzz2zZsoXff/8dT0/P4q5ZREREpMxr2bIl+/btc3UZIiIiIiXOzZmbfvrpJ/bt28ejjz7K6tWrmTZtGp9//jk//fQT69at4/HHH2ffvn2ahi4iIiLipNdee41t27bxyy+/YLVaXV2OiIiISIlxaubU4sWLadmyJe+9916ua56enowePZodO3awcOFCXnjhhSsuUkREROR68+eff9KwYUP+97//8c0331C7du08Z6SbTCbmzp3rggpFREREiodT4dTp06cZPHhwvtdNJhO33HILv//+u9OFiYiIiFzPgoODHb9OT0/n2LFjefbTCX4iIiJyrXMqnKpYsSKnT58usM+pU6fw8fFxqigRERGR693BgwddXYKIiFynbDYri4P/ZNWiv4g9c5qAKlXofk8fHho0FA+PwsUI//n3sxzcuyvPa8++8ib39Hm4OEsuEyxmM8sWzOH+hwc52sZ/+gEhyxfx2Y8zaNikKXt3buf9kS9wX79HeerF11xYbfFyKpy69dZbWbFiBZs3b+a2227LdX3Dhg2sXr2ae+6554oLFBEREREREZGrZ9K4z1ixKJhmLVvTodPtHNy7i5lTfiTq2BFGvT+2UGMcjzhG7cD6dO7eM9e1xk2bF3fJZcJ7rz3PyeOROcKpoM5dqVazFgGVK7uwspLnVDg1YsQIVq9ezbPPPkufPn1o3749vr6+xMbGEhYWxrJly/Dy8uLFF18s7npFRERErlsbN27k4MGDVKxYkTvuuIMaNWq4uiQRESljDu7bzYpFwXTq1pPX/u8jAAzDYPynH7B2xWK2b15P+9u6FDhG7JnTpKWmcOe9fRg4dPjVKLtMSIg/l6stqEs3grp0u/rFXGVOhVONGzdm8uTJvP3228ydO9exJ4JhGAAEBgYyduxYGjduXHyVioiIiJRxVquV+fPnExoaSrly5bj33nvp1KkTGRkZPP/882zZssXR18PDg5deeonhw/VNv4iIFJ+lf80CoP8TTzvaTCYTg595kb9XLmHV4r8uG05FhR8FoF6jJiVXqJQpToVTAB06dGDp0qXs2LGDgwcPkpKSgo+PD82bN6ddu3a4ubkVZ50iIiIiZVpaWhrDhg1j165djh/4zZo1ixdeeAGz2czmzZtp1aoVQUFBnD9/nqVLl/LVV1/RpEkT7rzzThdXLyIiZcWB3TvwC6hEYINGOdorV61Grbr12L97x2XHiAo/AkC9Bs5NWMneV+n5194hMzOTRXN/JzH+HLXqBHL/w4/R/d77c92zZ0cowb9N5eihfdhsNuo3bEKf/oPp2PUuR5/YM6f51+C+PPL40ySdT2DtisV4enrx7Ctv0qlrj6y9tubOJGT5Is6cPolvRT9atG7PwCeHU6NWHcc4hmGwfOFcVi6cx6njkZTz9KT5zW0YMHQ4jW64Mdd7vPj6u9gNO4vm/E70yRNU9A+gc/eePPrkc3h5ezvqyvbIXUF0u/s+Rrz5Xq49p/KTlprC3N+msGntKs6djcXPL4AOnW5n4NDh+Fcq/UsCnQ6nANzd3enQoQMdOnQornpERERErks//vgjO3fu5IknnqBfv36YTCZmz57NhAkT8Pb2pl+/fnz88ceO/sOHD+eBBx7gzz//VDglIiLFwmI2cy4ulhuat8zzevWatTh9IorziQn4B1TKd5zsmVOH9u3mp6/HcupEJD4+FbntjjsZ+ORwfHwrFqqe5QvmEnnsCJ263UVFP3+2bljLd5/9l9iY0zmWC65cNI8fv/oE/4BKdOrWk/LlK7B1w1q++O/bDBr2Ag8PfirHuCsWBmNyM3F3n4c5dTySps1vxm638/E7r7Jr2xYCGzTirl4PknQ+gfWrl7NnRyhjv5tClWrVAfj20/f5e8US6jVsTM8+D5GZkcHGkJX85+VnePvjL7m57S05nrfkrz85Hn6UW2+/k7a3dGTL+hAWzPqVtNQUXhg5Gh/fivQf8gyL5vyBxWym76AhNGycfxD1T6kpKfzfK89yPOIYrdoFcdsddxITfYqVi/5ix9ZNfPztZCpVqVro8VyhUOHUJ598wu23306XLl0cnwvDZDLx1ltvOV+diIiIyHVi5cqVdOjQgdGjRzva/vOf/3DgwAHCwsJ4+umnc/QPDAykR48ebNq06WqXKiJyXTIMg0yr3dVlFMjLww2TyeT0/SnJSQD4+Prmeb2CT1Z7WmpKocKpmVN/ouMdd9K8VRv27QpjcfBMdodt5aNvJuf7jEuFHznIyHc/ccx+euSJZ/jPy88w99dfuOOue6lVtx7n4mKY/O3n1KnXgDFf/0RFP38ABj39Av99fQQzp/xIUOc7CLxkFlfS+QQ++3E6DS4JgFYt/otd27bQqVtPXn77A8ephO2COvPN2PeY/+cMnnrxNTauXcnfK5ZwR49evPjGu7i7uwPQ77EnefOFoYz/9AO+mzEvx6mGkUePMObrH7mxRausvoOH8dLQh1m3ailP/es1fHwrMnDocEKWLSI1JbnI+3T9Nvl7jkccY/grb3F3n36O9m2b1jH2PyP55fsvee3/Pi5gBNcrVDg1depUKlas6Ainpk6dWqjBFU6JiIiIFM7p06e5/fbbc7W3bt2asLAw6tatm+taYGAgS5YsuRrliYhc1wzD4M05uzlwJtnVpRSoeS0/Pu13s9MBldVqBcCjnGee1z3KlQOyZljlx2634+NbkQZNmvL2h186ZhvZ7XYmjvuUFQuD+XPqTzz14muXrefGFq1yLMvzD6jEw4OfYvz//svGtSt5ePAw/l65FIvFzKNPPucIpgA8Pb0YMORZ/vvGCNYsW8SQ5152XKtZu26OYApg/ZrlmEwmnnzhlRzB0u097uXk8QgaXFhSt3rJfACe/NerjmAKoHrN2tzdpx9zfv2FXds259iX66bWbR3BFGSFfzfedDOhG//mXFwMdeo1uOzvRX5sNitrVyymXsPGOYIpgA4db6dZy9Zs/nsNaakpjnCxNCpUODVt2jTq1KmT47OIiIiIFJ/09HR8fHxytVeoUAEALy+vXNfc3Nyw2WwlXpuIiABXMCPpWuF54e8aq8WS5/Xsdi9v73zHcHNz45PxP+fZPuT5f7Nu5VI2hKwoVDjVonW7XG1NmrUAIPJY1r5Wxw4fAGB32FaiIo7m6JuRnp7V9+jhHO3Va9XONW5U+FGqVKtB5arVcrSbTCYee/pfjs/hhw/i6enFknl/5hrj1PGoC7UdzhFO1a5bL1ff7KDIYsk/6CuM0yeiyEhPw2azMXPqT7mum82Z2O02jkcco1nL1lf0rJJUqHAqKCgox+cDBw7Qpk0bWrcuvS9WIqxm8Mg7QRYRERG5UleyFENEREqOyWTi0343l/llfRV8fHFzcyMtNSXP69ntzs7AKV++AjXrBhJ59DCZmRl4eeUfcgFUrlo9V1tA5So5aklLyfrv5Qvm5jtO9nLFbJ6euX/gk5qcREAhZjClpiRjs9mYNW1S/s9Lyvm8cnnMRMv+c7pwBorTUi+8/6njkUWqqbRxakP08ePHc/vtt/Pll18Wdz2lW8weqNPe1VWIiIiIiIjIVWYymfAu5375jtewcuXKUbVGTWLPnM7zemz0afz8A3Isn/un1JRkTkRF4OfnT+3A+rmumzMzcXNzw8Oj3GXrMWdm5mrLDqWya/AuXx6A76YHU6N2nVz9C8u7fAXS09LyvJaRnu54jnf5CpSvUIEffl/g9LOKU3Zdd/TsxctvfeDiapznVDhlGAZVq5bund5LxJk9UPVG8Cq96zRFRETk2rV161bGjx+fo23Lli0AfPfddxj/+PFq9jUREZHi0qxla/5esYTTJ6JyhEvxZ+OIPnUix3K1vEQcOcT7o/5Fh46389aHX+S4lnDuLLHRp2jQpGmO/Zryc/TQvlxth/btBi4u76vf+Aa2bljLsSMHcoVT0SePs3xhMC1ataNDp9z7Ol6qXsPGHNy7i4T4s1SqnDPveO3ZQbi7ufPttDnUb3wDB3bvIDH+nGMWV7Ztm9Zx5MBeOna9K9eeVoXhzKS3OoENKFfOk4gjhzAMI9fMuYVzficjPY17+jxMRf+Aoj/gKnFz5qYnn3yS4OBg1q5dm+ubpDLNboXTYa6uQkRERMqo7HDq0q/Q0FAMw+Dbb7/N85qIiEhx6tbzPgB+mzwBuz1rGaNhGPw6KeuHJD3u61vg/c1ubkPlKtUI27KRfbsu/vuzxWJh0refYbVauffB/oWqZev6EPbv3uH4nBh/jlnTJ+Pl7U3HO7I2Sr+jRy/c3Nz54+cfSIw/5+hrs1mZPP5zFsz6lfPnEy77rDt69MIwDGb8ND7Hfo4bQ1YQG32aVu2ztjvqfvf9GIbB5PGfY7lkb66Ec2eZOO5T5v42BS/v8oV6v39yc/fAZrMW6Z5ynp507t6TE5HhLJr7R45re3duZ9oP37B6yXx8Kvo5VdPV4tTMqVOnTuHp6cnzzz+Pt7c3NWvWxDuPDdFMJhNz5+a/7vOadHwLNLzD1VWIiIhIGfPJJ5+4ugQRERFatQ+iU7eebAxZwTsvPU3LNu05tG83B/bs5LY77sw1cyp7E+6BQ4cD4OHhwXOvvc3/3n2dMW+MoGPXHlT082f39q2cPB5B5+530/2e+wtVS/kKPvz3jRF0vOMuKvj4sHXDWhLjzzH8lbccpwDWqhPIE8+9xNQJX/Pq049yS6c78PGtyI6tmzh5PIK2QZ3o2rP3ZZ91Z68H2LxuNWtXLCYq4igtW7cn/lwcm/9eTfWatRg07AUAut1zH6Eb17Jp7Sqiwo/SusOt2G02NoasJDnpPIOGPU+tOoGF/v2+VJWq1Tlz6gTfjH2PVu2C6Hb3fYW674nnXubgvt1M+f4rtq4PoUmzFpyLi2XL+jW4u7vzwqj/4Obm1Nykq8apcCo4ONjx6/T0dCIiIvLsVyY39Tyh6fMiIiJS/B566CFXlyAiIgLAy29/QGCDRoQsW8iiOX9QtXoNBj75HH0HPpHr3/OzN+HODqcA2t/WhTFf/8TsGT+zffN6LGYztQPr8fRLo7jngUcKnRXc0aMXNWrXYf6fM0hOOk/DJjfywsj/0O7WTjn69XnkMeoE1mf+rF/ZvG41dpud6rXqMOS5f3Nv30fw8Lh89OHu7s5bH37J/D+ns3bFEpbOn02FCj7cfte9DH7mRXwvzDwymUyMfG8sS/+azZplC1i1+C88Pb0IbNCI+x4exG23dy/Uu+Xl8eEj+P6zMWwMWUniuXOFDqf8AyrxyfifmfvbFLauD+Hwgb34+Vei/W1deHjwMBrdcKPTNV0tJuO6WpdXdHfdlTVVcNWqVRA6CVb9F96IhFKeOoqIiEj+cvz9XkoMGTKEfv360bdvX6fHCA4OJjg4mGnTphVfYVdBSf95HIlJJsNSuk/YEhGRi/bu3M77I1/gvn6P8tSLr7m6nDKvaU1fvDyKf7P/ovz9roSlqDLOw9lDrq5CREREypitW7dy8uTJKxrj1KlT2odKRERErjlOLevLtm7dOubMmcOBAwdISkpi06ZN/PXXXxw/fpxhw4bh4+NTXHWWLie2QPXmeV8zp4Fnhatbj4iIiJQJixcv5uDBg07fHx4eXozViIiIiFwdTodT7777LrNmzcIwDNzd3R27+O/bt49p06axdu1apkyZgq+vb7EVW2oc3wLtn8zdnngCdsyA7m9f9ZJERETk2hceHn7FAVOZ3PNTREREyjSnwqk//viDP//8k169evHqq6/y119/8f333wPw4osvkpqaypw5c/jll1946aWXirXgUiG/TdF3TIfdM6HbW6BvDEVERKQIStP+VyIiIq7Usk17Zq/a6uoy5CpyOpxq1qwZX331FZDzJ3T+/v589NFHHD58mKVLl5bNcCr+GKTEgW+1i202K4RNh+TTcDIUAoNcV5+IiIhcc+rUqePqEkRERERcwqkN0SMiIujSpUuBfYKCgjh16pRTRV0TTv4jxT26IiuYAtgz6+rXIyIiIiIiIiJyDXIqnPL29iY+Pr7APrGxsXh7eztV1DXhn0v7tv1y8dd754LNcnXrERERERERERG5BjkVTrVv357ly5cTExOT5/Xjx4+zcuVK2rVrd0XFlWrHLwmnEk9kzZzKlnYWwkOuekkiIiIiIiIiItcap8KpF198EbPZzCOPPMKUKVOIiIgAYOvWrfz8888MHDgQi8XCc889V6zFliqnd4A1M+vXO2aAYc95ffefV78mEREREREREZFrjFPhVIsWLfj222+xWq2MHTuWRYsWYRgGQ4cO5X//+x8Wi4XPP/+c1q1bF3e9pYctE6J3ZW2EvmN67usHF4E59erXJSIiIlJEMTExtG/fnilTpuS6NmvWLG688cY8vwYMGJCrf0hICAMHDqRt27Z07NiRd955h3Pnzl2FtxAREZFrlVOn9QF07dqVNWvWsGrVKvbt20dycjIVKlSgWbNm9OzZE19f3+Kss3Q6sQXSzkFSHhu/W1Lh4GJo1f/q1yUiIiLXvLfffpsePXpw11135dtn3rx5LFiwgMmTJzv9nNTUVF566SVSUlLyvH7o0CEAnn32Wby8vHJcq1mzZo7PCxcuZOTIkQQGBjJo0CCio6MJDg4mNDSUOXPm4Ofn53SdIiIiUnY5HU5B1sbo9913H/fdd19x1XNtOb4ZItfnf33PnwqnRERExCnBwcHUrVu3wHBq06ZNhIaGOv2M06dPM2LECPbt25dvn0OHDuHv78+oUaMKHCs1NZUxY8ZQv3595s6d6/hBZefOnRk9ejQTJkzgzTffdLpWERERKbuuKJwKDQ1lwYIFHDx4kOTkZAICAmjdujUPPvggzZs3L64aS6+IdWBOzv/60VWQehZ8ql69mkREROSaNHXqVL777rscbT/99BNTp07Ns7/FYiEjI4MmTZo49bwpU6bwzTffkJGRwW233cbmzZvz7Hf48GGaNm162fEWLVpEYmIiL7/8co4Z9I888giTJk0iODiYUaNG4e7u7lS9IiIiUnY5FU4ZhsE777zDvHnzMAwDAF9fX06cOMGOHTuYPn06zz33HC+//HKxFlvqZJ4v+Lphg12/Q8cRYDJdnZpERETkmjRo0CAWL15MXFwcAMnJyXh6eua5VYLJZMLDw4MaNWpcdkZTfqZNm0adOnX44IMPiIyMzDOcOnPmDImJidxwww2XHS97BldQUFCua0FBQcycOZMjR47QrFkzp+oVEZGrx2azsjj4T1Yt+ovYM6cJqFKF7vf04aFBQ/HwKFyMkJx0nplTfmL75vWcT4ynbr2GPDjwCTp375mr77iP32XdqqV5jtP30SE8/uyIK3qfsshut7NiUTBde/TGu3x5AGZO/YlZ0ybxxgf/I6hLN2LPnOZfg/tyS6c7eHPM5y6uuGBOhVNTpkwhODiYdu3a8eqrr9KqVSu8vLyw2Wzs2rWLzz//nAkTJtCoUSPuv//+4q752rL8P7DtF2h2HzS7H+reAm5O7UMvIiIiZZinpyczZ850fG7WrBlDhw5lxIiS+Yb8gw8+oFOnTri7uxMZGZlnn+z9pmw2Gy+++CJhYWFkZGTQrl07XnrpJdq0aePoe+LECQACAwNzjVO3bl0AIiIiFE6JiFwDJo37jBWLgmnWsjUdOt3Owb27mDnlR6KOHWHU+2Mve39Gejpj3niJyGOHue2Ou6hWvQab163hqw9Hk3Q+gV59cx6oERV+lIBKlenZp1+usZq3bFNcr1WmjPv4XTasWU6X7nc72lq0bg9DoE69Bq4rzElOhVMzZ86kYcOG/PLLLzk2xnR3d6ddu3ZMmjSJvn378ssvvyicAog/Bhu/yfqq2hRGOL83hIiIiFwfVq1a5dhA3G6343bJD7dOnTpFnTp1rmj822+//bJ9ssOpmTNn0qVLF/r168fx48dZtWoVW7Zs4bvvvqNr164AJCQk4Onpibe3d65xsmd/5bfpuoiIlB4H9+1mxaJgOnXryWv/9xGQtXpq/KcfsHbFYrZvXk/727oUOMaiuX8QfuQgz77yJvf0eRiAR554mndeepoZE8fTqWsP/CtVBsBqtXL6RCTtbuvCwKHDS/blypCE+LO52lq2aU/LNu1dUM2Vc2oKT3R0NF27ds11Yku2ChUq0LVrV8LDw6+ouDLp7GHI1DdmIiIiUrA6deqwZ88eHnroIWbMmOFoNwyDXr160adPH/bs2VOiNdjtdurUqcNnn33G5MmTef311/n222+ZMmUKdrud0aNHk5mZCWT9y4Wnp2ee42S3Z/cVEZHSa+lfswDo/8TTjjaTycTgZ17EZDKxavFflx1j2fw5BFSuQo/efR1t5Sv48PDgp8jMyGD96uWO9pNREVitVuo3dG4PRSkbnJo5VbduXY4fP15gn5iYGGrUqOFUUWVefDjUauXqKkRERKQU27ZtG8OHD6dcuXI5ZiOZzWbuu+8+li9fzuDBg5kxYwatWpXM9xX/z959h0dZpX0c/056SCH0EnoXAYEIKCoKYgFFEQsKCIgIKGXt9V3XtpZ1VwRREREQBUSQKiAigijSe08gQEjoIb1Oe/8YZpLJTEJ64/e5rrkyc86Z89zzTAKTO+fcz5gxYxgzZoxLe9euXenXrx9Llixh69at3HLLLfj5+WE0Gt3Ok5mZCYD/5ZoYIiJSfh3au4vgkGo0bNLMqb16zVrUa9CIg3t35fn8s6ejuXTxPDf06OVyEYxrL6/qObB3J/c8+CgAUZFHAWjY1Pl4+WWvq/Tg4Cdo2KQ5C7/7hvNnT1Ozdh163/MA9z70mNPqY4DI8MMs+G46h/btJjMjg/oNG3FHvwHcee8ADNnqRT90e1duu/Meaterz88L5wIGHh46kn4PDQLg91+W8+vyRUSfPI6fvz8t21zLwOGjadLcuVbj33/8xs8L5xEVeRSDhwfNW1/DQ4NH0K7T9S6v4+GhI2nWsg0/fT+DqOPH8KtShS7dezB45FiCq4Y44rIbdv/ttL2uM+98MtWl5lRujEYjyxfMYcOaVZw7E0NgUCA3de/Os88+63Z7fmko1MqpsWPHsm7dOsdfzXJauXIla9eu5dlnny1qfJVT7NGyjkBERETKuS+++IKAgAAWLVrEI49k1ebw9fXlgw8+YPHixfj6+jJ58uQyia9t27YAREdHAxAcHExGRoYjEZWdfTtfUFBQ6QUoIiIFZszMJPbCeerUc791vHbdeiQnJZIQH5frHGdP2/5fqFu/gUtfteo18fHx5fSpk462k5ERAJyJjuKNCSMZcu9tjHjwLqZ89DaxF87nO/adW/5m0vv/pG5oA+7o9wAAs7+axBcfv+sy7o0JI9m/ewdduvegT/+HsVqtfP3pR3w18QOXeXdt3cTPC+dy25330rHLDbS6ph0AX/7v33zx8bskxl/i1jv6EtbtJvbs2ML//eMpThyLcDz/h5lf8ck7rxMfF8ttd93LbXf2Jfrkcd55eRwb1qxyOd6OTX/x8b9eJqRGTfo88AjVa9Zi7cqlfPre/znGPDx0JLXq1ANsBeN73pn/ckomk4l/v/YP5n7zBVUCAri7/8PcfPMtrFmzhoceeojw8PB8z1WcCrVyKiIigmuuuYaPPvqI7777js6dO1OnTh3S09PZt28fe/fuJTg4mJ9//pmff/7Z8TyDwcBnn31WbMFXWJeOlXUEIiIiUs4dPHiQfv360bRpU7f9jRo1om/fvixfvrzEYjhw4ACpqal06dLFpc++Rc9e5qFJkybs3LmT6OhomjVz/uu3PYGV22sREakojK759yvy9Mq6JpbFAmYTYABv76LN6+EJ9oVJ9nm93e+uzrfkpEQAAtxcKRagSoCtPTUlmaoh1dzPkZhweQ73f5DwrxJAakqK4/HJ47bFGz/NmUm3m3vSqm17Ig7tZ/2vK9izYwvvfzaDWnXqXjH240eP8PjoCdz/yBAABo14hndfGc/6X1dw21330q5jGBnp6Uz5z9sEBAbyweezHPMOfmocn/77//htxRK63nQbnbt1d8ybEH+JV9/9H9d3z6rVuHfnVtauXErb6zrz2nv/w79KAAC33nkPbz43mvmzvuKVd/9LxOED/DRnBu06Xc9r//4EX1/bSuhHho3ijfFPMu3TD+nY9UbHiiiAyIjDPP/m+3S/tTcAj5me5qXRQ9i7cytnT0dTt34DBg4bxYE9O7lw7gwPPDYs13Ptzoqf5rF/13YeeGw4g0c+A0CruoE8MXwYAwcO5I033mDBggX5nq+4FCo59eWXXzrux8TEEBMT4zImISGB3377zakt+/K4q1qsanGJiIhI3sxm8xVrNBkMBqxWa4nFMG7cOM6ePcvGjRupXr26U9+OHTsAaNfO9hfksLAwFi1axLZt21ySU1u2bCEoKIjmzZuXWKwiIqXh6ynu6y7n5c57jLRobdtxFBnhwa8rvAltYOH+R7K2Qn/3jQ/paQX7ffmWnibadzIDcCbGwNIFPjzzfNFq+5lMJgC8cslyeV3OqBndrJJ1ncPbbb+3jzcZ6emOxz4+vtQLbcjL7/yHhk2y/p/4ac4M5s2Yyowp/+WVd/97xdhr1anHvZe3CgL4+vnx2Iin+dfzY/hz7S+06xjGtr83kBgfx9DR/3BKeHl4ePDYiKf5e/1v/P7LMqfklI+vL52yPQbYeLlm1pCRYx2JKYC2HToxeORYgoKrAvD7qmVYrVYeHzXekZgCCAquyn2PDGHqJ++zcd0a+vR/2NFXp16oIzEF4OXlRYfOXTl1IpIz0afcrkgriLWrlhEQGMSjTzgXn7/22mu5++67Wb58OREREbRs2TKXGUpGoZJTa9euLe44ri5aOSUiIiJX0KZNG9atW8elS5dcEkMA8fHxrFu3jtatW5dYDHfffTczZsxg4sSJvPPOO44/NK5atYr169fTpUsXWrVqBUDv3r15//33mT59OnfddRchISEALFy4kBMnTjBixAiXmh8iIlK++FxeDWvKpYagvd3XzZVZ8zuHMdOIr19WDcKX3/nY7bgHHhvO2lXL2LllI2lpqfj7V8kz9tbtOuDp6ZziaNHGtgX95OVtdpERhwE4Fn6I+d9Oc5nDw8PTaUseQM1adVxqZ52MPIqHhyfNW1/jJu5hjvv2423e8DvbN/3pNO7S5S2LJ445b6Or16CRy5z2FWvGwiyxyyYtLZXTp04SUr0GC7+f4WivEeiDl4cHFy/argB46NChipGcKuqli696sUpOiYiISN6GDRvGuHHjGDZsGM888wwdOnQgMDCQlJQU9u7dy9SpUzl//jyvvfZaicXw9NNP88cff/Djjz9y5MgRwsLCOH78OOvXr6dWrVp88EFWbY6QkBBeeukl3nrrLfr370+fPn04d+4cq1atokmTJowePbrE4hQRKS1PjSv4yqTs+ZJmLS22OXIsknr8yYInHTyy5UvqhVoLFVtOVQIC8fDwIDXF/RXm7e32ZIk7gYHBl8emuO1PS02hajXXP7rk5OHhQZNmLTl/5jSXLpwntFGTPMfXqFHLpc3X148qAQGOuFOSkwDYuO5Xl7F29m2JdvZkm9OY5CR8fH1dkmE5pVyuubh43re5H+/yVko7b3crzuzfL0VcLZ16OZ74S7EsmD0913EJCQm59pWUQiWnpIhSL0JaPPiHlHUkIiIiUk717t2bf/zjH3z++ec8//zzLv0Gg4Hx48dz9913l1gMwcHB/PDDD0yZMoU1a9bw3XffERISwkMPPcSECROoXbu20/jHHnuMqlWrMn36dObMmUPVqlXp378/zz33nGMllYhIRVbUmk4eHuDhZo6SmregvL29qVmnLufPnnbbf/7MaYKrhji2rbljX/njbo642ItkZtqujgeQkZ7OycgIfHx9adK8lcv4zExbws3b58ovzj42O7PZREZ6OoGX4/W7fNXYf/33c9p3cq2nmF9+/v5kZmRgNptcElQZ6emOlWV+/v54eHgyd9WfeHmVffrF7/Lqs2vad+TdT7NWjrWqG4ivl2duTysVZX92rlaXjkFoWFlHISIiIuXY008/zd13382qVasIDw8nMTGRKlWq0KpVK+69916X2k6FNWDAAAYMGOC2Lzg4mNdff53XX389X3P17duXvn37FktcIiJS+tq0u44Na1Zx+tRJ6jds7Gi/dPECZ2JOEXbDzXk+v1adutSsXZfD+3djsVictnQf2GOrV9i6bXsA4uNieX38kzRq2oJPps91micjPZ3IiCMEh1RzXJkuLxGHD7ptM5vNtGxzLQBNmtkSYJHhh12SU0mJCSz87huatWrDrXfk/f9Yo6bNOXE0nMiII4657T544zkiI47w9Y8radKsJSeOhnPiaLhji6HdkQN72fb3Bjp3607bDp2v+PpyMuRcfpcPAYGB1KpTj1MnIsnMzMDHx3lV2JIlSzh16hT9+/enYcOGBZ6/KLTxv6yoKLqIiIjkQ9OmTXnmmWf49NNPmTFjBlOmTGHChAnFlpgSERHJ7rY77gFg7jdfYrHYCrlbrVbmTP8cq9VK73v6X3GOW+/oQ+yF86xaknXVt7TUFH6aMxMfX196XE7+1KkXSvPW1xB1/CgbfvvFMdZqtfL99CkkxsdxV78H83VxtaOHD/DX71nb9dLSUvl+2md4eHg4kk1db76NKgEBLPlhNmdiTjk9//tpn7Fi0Q+ciXZud6dH7z4AzJsxlYyMrOLuhw/s5eDe3bS+tgO+fn7cdte9AMz6ciJpqVnbHNNSU/h60kcs+WE2ZrP5isdzx14Hy16APr9uu+sekpMSmTv9C6eLqhw9epR33nmHGTNmlMlqZ62cKisqii4iIiL5kJGRQXx8PBaLxfEh0mq1YjKZiI+P548//mDChAllHKWIiFQWHcK60v22O/h7/RpeH/8k7TqGceTAXg7t280NPXq5rJyyFxYfOCzr6m/3D3ycv9f/xszP/8fBvTupWy+UzX+u49yZGJ4c/yJVQ6o5xo569lX+9fzTfPbhv9j85+/UrlOPQ/t3c+zIIdp26MSAQcPzFXdgUDCTP3iTTRvWUqNmbXZu2cjZ09E8OPgJmrVqA9hWDo154Q0m/fufvDhqMF1vuo3qNWpyYM9Ojh45SLOWbbjvkcFXPFbH62+g1939+P2X5bz41GA6de1Oakoyf6//jSoBAYyc8BIA7TqG0feBgaxcPJ/nnnyUzt1uwsvLm60b13Px/Dl639O/0NsLa9Syba3/8r/v0b5zV+4ZMDBfz3vgsWHs3raZn3+ax8G9u2jboRNelnR+Xb2atLQ0PvzwQ4KCggoVU1EoOVVWVBRdRERE8pCamsqrr77K77//fsW/qio5JSIixWnCa2/TsEkz1q/+mRU//UDN2nUYOHw0/Qc+7rKKyV5YO3tyqkpAIO9+Oo2533zB9s1/sXvbJkIbNuHZN97j5l53Oj2/eatr+OiLWfww6yv279rOzrSN1K5Tz3G8/NSbAlsdpVtuv4t5M6aya+vfNGjUlAmvvk2PO/o4jet+a29q1KzN4nnfsmvr32RmZFCrbj0eHDKC+x4ekmex9+yefvH/aN76Gtb8vJg1Py/G28eHTt26M2jE09Spl3URuRHjXqBF67b8smwhf6xZiaenJ/UbNObhx0fS8+5++TqWOwMGP0F01Al2b99MTNSJfCenfHx8eet/X7Bs/vdsXLeG1ct+Iig4iM6dOzNq1Ci6detW6JiKwmC1FrHceyV3++23A7B27VrYNh1WvFA8E4eGwVO/u+/LTAWfvC+TKSIiIoXn9P97OfWf//yHGTNmUKtWLdq1a8emTZto2LAhoaGhHDt2jFOnTlGzZk3eeecdevXqVdbhFklJvx8R55JIN1pKZG4RESlb58+e5pnB/enSvQevvPvfsg6nQiqpgugF+f+90CunYmJiWLRoESdOnCAzMxN3OS6DwcBnn31W2ENUbrFHbZeBdLd3dvkEuPsjCKhR+nGJiIhIubB27Vrq1q3LypUrqVKlCqNHj8bX15fJkycD8PnnnzNlyhQyMop+6XARERGRslSo5NTWrVsZOXIkRqPRbVLKLj9Fy65a6QmQesk1AWVMh0PLweAJA74qm9hERESkzJ05c4aHHnqIKlVsq6nbtm3LggVZhWXHjh3L2rVrmTdvHn369MltGhEREZFyr1DJqcmTJ2MymXj22We59dZbCQwMVCKqMC4dc01OndoCpnTY+wN0eBha9M7fXHEnoFqT4o5QREREyoiXlxcBAQGOx40bNyY2Npb4+HjHVXS6devGihUryihCERERkeJRqOTU/v376du3L6NHjy7ueK4uscegYVfntsj1Wfd/fg6e2Qw+AeQpIwmWjYdhy4s9RBERESkbjRo14siRI47HzZo1w2q1sn//fm6+2XalJKPRSFJSUlmFKCIiUuZq163PwrVbyzoMKSKPwjzJ19eXWrVqFXcsV59Lbq7Ylz05FR8F696/8jz7FsDxDZAQXWyhiYiISNnq3bs3f/31F5MmTSI+Pp42bdpQtWpVvv76a1JTUzl16hS//PILDRo0KOtQRURERIqkUMmpm2++mb/++uuKlzWWK4g96vw4LQ5O73Ju2/wFxOzMe54ds2xfD2tZv4iISGUxYsQI2rVrx9SpU1m7di0+Pj4MHz6cLVu20LVrV+68804uXrzIY489VtahioiIiBRJobb1vfzyywwaNIhnn32W4cOH07RpU3x8fNyODQwMLFKAlVpsjpVTxzcAOQrMWy2wbAKMWgee3q5znN4FZ/bY7h9aDt201VJERKQyqFKlCvPmzWP16tW0bdsWgDFjxuDt7c3PP/+Mn58f9913H4MGDSrjSEVERESKplDJqUGDBpGamsqaNWv47bffch1nMBg4ePBgoYOr9C5FgtUK9mLy2bf0ZXduH/z9GdzyvGuffdUUwMmNkBLrWmRdREREKiRPT0/69u3reGwwGBg5ciQjR44sw6hEREREilehklP169cv7jiuTpnJkHwegurYHueWnAL44yNoez/UaJ7VlpEE+xZmPbZa4MhK6Px4iYQrIiIipS85OZn169dz+PBhkpKSCAkJ4brrruOmm27C19e3rMMTERERKbJCJaemTZuGv79/ccdydbp0zJacijtpW0mVG1M6LP+H7Yp89pVW+xbaElzZHVqu5JSIiEglsXjxYj788EMSExOxWrO2/hsMBmrXrs27775Ljx49yjBCERERkaIrVEH0AQMG8K9//au4Y7k62etOHf/jymNP/Am7vst6nH1Ln13kOkhPLJbQREREpOysX7+e119/HYCxY8cybdo0Fi9ezOzZs/nHP/6B0Whk3Lhx7N27t4wjFRERESmaQq2cio6OpmfPnsUdy9XJfsW+vLb0Zffr/0HLuyDpNJzZ7dpvzoSja6Ddg87tVqtt25+HZ1GiFRERkVIydepUqlatysKFC2nQoIFTX9euXenTpw8PPfQQU6ZMYdq0aWUUpYiIiEjRFWrlVMuWLdm/f39xx3J1unQMLJb8J6fSE2DVy+5XTdkdWu782GKG5RPgvIrTi4iIVBRHjhzhrrvucklM2TVu3Jg777yTXbt2lXJkIiIiIsWrUCunXnzxRV566SUeeeQRevfuTYMGDXItyHn77bcXKcBKLzYSzu2H1Nj8P+fgEvDwzr0//FcwpoO3H5gyYfFoOLAIGt0IddsXOWQREREpeUFBQVgsljzHGAwGFUUXERGRCq9QyakRI0YAEBsby759+9yOsVqtGAwGDh06VPjorgaXIuHY7wV/nsWYe58xxVZ7qumtsGAYRPxqaz/r/r0SERGR8ufBBx9k5syZPPzww3To0MGlPzIykl9++YWhQ4eWQXQiIiIixadQyamxY8disF8xTorGlAZ7fij+effMg78/g5Mbs9rOqGCqiIhIRREWFsYff/zBoEGDuOeee7j++uupU6cOGRkZ7N27lx9//BFvb2+Cg4OZPXu203OVsBIREZGKpFDJqfHjxxd3HFe3CyWwuuzgUte2s/tshdGVWBQRESn3Ro4c6bi/dOlSli5d6vjjoNVqdfR99NFHTo8NBoOSUyIiIlKhFCo5JRVURgLER0G1xmUdiYiIiFzBBx98UNYhiIiIiJSKQiWnHnjggXyNMxgMLFq0qDCHkJJydl/pJqeMaZAWD8H1Su+YIiIilUB+P2+JiIiIVHSFSk7lp8h5/fr1CQ4OLsz0UpLO7oNr7s3fWPsWgcJuAzy6FlY8D52HwS3PF24OEREREREREanUCpWcOnz4sNv29PR0Tp48ydSpU9mzZw9fffVVkYKTEpDfK/bFnYAVL8Kd70Ltawp2jOTzsPp12LfA9jhmR8GeLyIiIlgsFubMmcPy5cs5ffo0mZmZbscZDAa2bNlSytGJiIiIFJ9irTnl5+dH69at+eSTT3jggQf4+OOP+e9//1uch5CiulJyymyETZ/D+g9tVxJscnP+klMWC8Rsh8M/w45ZkJ6Q1afklIiISIF98cUXfP7551itVmrWrElgYGBZhyQiIiJSIkqkILrBYOCmm25i4cKFJTG9FEVCFKTFgX81176LR2HBMDi3P6stYg3c/Gzu810Ih82fw+GVkHLe/ZikM5B4GoLrFyl0ERGRq8nixYupV68es2fPpkGDBmUdjoiIiEiJ8SipiaOjo3Ndfi5l7Ox+9+2bPnNOTAFEbXJeBZXTHx/ZVkrllpiyi95eoBBFRESudpcuXaJPnz5KTImIiEilV6w1pwBSUlJYv349a9as4cYbbyx0YFKCzu6Fprc4t5ky4cAS17FWMxz7Ha51c8WgjGQ4sjJ/x4zZDm3vK3CoIiIiV6u2bdsSFRVV1mGIiIiIlLhCJaf69++PIY8ruFmtVvz9/Xn+eV2hrVxyV3fq6BpIj3c/PmKN++TU4RVgTM3fMWN25js8ERERgeeff54nnniCefPm8eijj+b52UtERESkIiv25JS3tzfNmjWjX79+1KhRo0jBSQlxl5za+2Pu4yPW2Aqee+TYBbovj+fkdHoXWMzg4Zn/54iIiFzFwsLCGDhwIO+88w4ff/wx9erVw8fHx2WcwWBg0aJFZRChiIiISPEoVHLqww8/LO44pDRdOAymDPDytT1OT4TwX3Ifn3IezuyG0M5ZbckX4Ni6/B8zMxkuHIE6bQsVsoiIyNVm1qxZfP/991itVlJTUzl27JjbcVpRJSIiIhVdoQqiDx06lCVLluQ55rvvvuPuu+8uzPRS0iwmW4LK7tByMKXn/ZyINc6PDyyy1aMqiJhciqIf3wCz7oXNUyG+nNXWOPobJJ0t6yhEROQqNHv2bEJCQvjmm2/YtWsXhw8fdns7dOhQWYcqIiIiUiT5Sk6lp6eTnJxMcnIySUlJbN26lePHjzvact7i4uL4+++/OX36dEnHL4WVfWtffrbnRfzq/DivbYC5idnhvn37TDjxJ/zyCnzaHqbeAqe2FXz+khCxBla+VNZRiIjIVSg2Npb77ruPm266CX9//7IOR0RERKTE5Gtb35IlS3j77bed2qZNm8a0adPyfN51111X+MikZNmTU0lnbSuXriRmB6RchICaEHss91VQeYl2k5xKvmBbueUU215Y/wE8XsD6Gdm3KuaX2QSeefwYnNpiq5d16Ge45t6CzS0iIlIETZs2JS4urqzDEBERESlx+UpODRw4kK1bt3LhwgUAtm/fTr169QgNDXUZazAY8PLyok6dOjz99NPFG60UH3tyav8isFry8QSrbYvbdY/C/p8Kd8zzByEzBXwCstr2zAWL0XXssbVwdj/UbZe/uS8cgR2z4O4P8h9PZgpEroc29+Tef2av7f7KF6HpLeBXNf/zi4iIFMGoUaN49dVXufvuu+nVq1dZhyMiIiJSYvKVnDIYDHzyySeOx23atGHAgAGMGzeuxAKTEnZ2n+0KfAW54l74augwsHBb+sBWo+rMHmjc/fJjqy2hlJu/P4MBX+Vv7r8/g73zodsYqNY4f885vRuOrs09ORWzM6uuVtIZ+O1tuPcT92OzO7UVGnbNXwwiIiK5iIqKolmzZowdO5bQ0FAaN27sdnufwWDgs88+K4MIRURERIpHoa7Wd/jw4SsPkvItIxGO/W7bspZfx9batvfFRhT+uDE7spJTJ/6ES5G5j92/EG7/J1RtkPecSWdtiSlzpm074ANT8x9L5Prc+09tdn68/Rto/zA0vjHvef+aCH3/C1VdVxaKiIjk16effuq4Hx0dTXR0tNtxulqfiIiIVHSFSk7ZHTt2jEWLFnH48GESEhJYuHAh69atIy4ujvvvvx9PT8/iilNKwm//Ktj49ARY9UrRjhmdrVbV9pl5j7WYYPOXcNe/8x635StbYgpgzw/QfQLUaXvlWGK2w6VjtisEhjRy7T+11bVt+QQYsxG8fNzPaUy3JbyOroGw4VeOQUREJBdr164t6xBERERESkWhk1PTpk1j0qRJmM22bU/2v9pt3bqVWbNm8euvvzJ58mR8fHL5JV7K3rn9BX9OYQqhOz1/p+1rykXXQuju7PgWbn0591pPGUm2FU0OVvj9XXhsXv5jifwDOj/u3Gex2Iqh53Qx3HblwtyKo5/cCMZU21X+lJwSEZEicFfbU0RERKQy8ijMk1avXs0nn3xCx44dmTlzJk888YSj79FHH6V79+788ccfzJ07t9gClUoiIQqSz8PuXAqh55SZlPcKq53f2VZ0ZXdkJURtdj/eLukcJJyy3Y9c59p/Mdx1Xru86nRF/Gr7emyd7eqBIiIiIiIiIpKnQq2cmjlzJo0aNWLmzJn4+PiwY8cOR1/jxo2ZNm0a9913H4sXL2b48OHFFatUFtHb8y6EntOWqXDDM65b6cwm2PyF++f89hY8sQpyq8MRk/U9S+QftpVSHtlyte5WTdkd+cWWuHK3msuenDKmwMm/oXnP3OcpCFMmJEZD9WbFM5+IiJQ7Q4cOLdTzDAYD3377bTFHIyIiIlJ6CpWcOnLkCI8++miuW/Y8PT3p0aMH8+fPL1JwUkn9PdlW6ym/ks7AnnkQNsy5/eCSrNVPOUVtsiWKWt3lvj/79sTUi3D+ANRtn9WWV3LKnGHbkthpiHN77DHnAu8Ra4onOZWZCj8OhSo18n/1QhERqXC2bnVT6zAfVBBdREREKrpCJac8PT1JSUnJc0xiYqIKoot7UZsK/pzlE2yFz9vcY7vVuw42Tsr7OVun5ZGc2uH8OHJ9/pNTAPsWuCanwlc7P45YDXe/n/c8V5KeAHMfhai/wSfQlqjyqVK0OUVEpFxSAXQRERG5WhUqOdW+fXt+//13XnrpJYKCglz6Y2NjWbt2Le3atStygCIO5w/Ybhv+A4F1IPlc3uOPrYPkCxBYy7ndYskqhm4XuR66j7fdT7kIsUfznvv4Bkg6C0F1s9rsW/rsYo/aVlPVaJ73XLlJuQjfD4Aze2yPM5Nt9bTaP1S4+UREpFxTAXQRERG5WhWqIPqoUaOIjY1l0KBBrFmzhosXLwIQExPD6tWrGTJkCAkJCU6F0kWK1ZUSUwBWMxxY5NoeGwEZic5tJ//OKmB+Kh/bKqwW2P9T1uOMZNuV+nKKWHPluQDO7IWtX2fdtkyDmX2yElN2+xbkbz4RERERERGRCqJQK6duvPFG3nnnHd59910mTJgAgNVqpXfv3gB4eHjwyiuv0KNHj+KLVKQw9v4I3UY7t+Xc0gdgTLUlpZrecuUtfdnnvnGs7f7xP8Cc6Tom4le4YcyV51r5Epy6whUGAY7+BimxEFAjfzGKiIiIiIiIlHOFSk4BPPzww/To0YOlS5dy4MABkpKSqFKlCm3atOG+++6jUaNGxRmnSOHEbHfdWhe93f3YyPUFS06d2Q0XI6BmS9ctfXYn/oLMFPAJyH2eU1vzl5gCsJjg4GLoMjJ/40VERERERETKuUInpwDq1KnDqFGjcu1PSkpyW5NKpFTtWwi3vZL12N3KKbAlp259xbUeVV72/gg9X899+545w1afqnWf3Oe4UmH3nPYtVHJKREREREREKo0C15zKyMggKSnpiuNWrlxJnz55/EIuUlr2LQCr1XbfmAbn9rsfd3qnLZFkzijA3D/a5kuMyX1MbquqAC4ehcMr8n88sF3tMD6qYM+pDCxmMKaXdRQiIiIiIiJSzPKdnNqxYwePPvooHTt2pGvXrvTq1YuFCxe6jDtz5gxjxozhhRdeIDY2tliDFSmU2AjbFjyAs/tsW+PcsVrgz/8WbO64E7Dug7zHhP+alRzLadMUIJe+vJRmYfTcYi9tMTts2yRFRERERESkUslXcmrPnj0MGzaM3bt34+npSUhICKdPn+af//wnM2fOdIxbsGAB99xzD+vXrycgIID/+7//K7HARQpk7+VkTm71puyiNhV87iNXWPmUGA2/vAoWi3N78gXYM6/gxwPb6ymNpNGFcFjyTMkfJz8ifs17FZqIiIiIiIhUSPlKTn399deYTCbGjRvHrl272LRpEwsXLqR+/fp88cUXZGZm8u9//5s333yT1NRU7rzzTlauXMngwYNLOn6R/Nn/k21bWG71pkralqmwbByYs63a2vY1mAq5Te3Cody3J+aHxQwn/4Zf/w+OrnU/5vRumHk37Jlru1/WwldDxOrys5JLREREREREikW+klN79+6lY8eOjBs3Dm9vbwDatWvHG2+8QVJSEv/85z/57rvvqFGjBlOmTGHy5MnUrl27RAMXKZDks7Z6UjFXWDlVknbPgYXDwZQBmamw9esizleIVVdRW2DpOPhvK5jZB/7+DL4fAD+NhOTzWeNO/g3f9oPUy1tz/55ctFiLKvEMnN1r20YZe7RsYxEREREREZFila/kVHx8PNddd51L+/XXXw/AsmXL6NKlC0uXLqV3797FG6FIcdky1ZbcKEuHlsPcgbB1GqRdKtpc2762bbvLr/0/way+sOs7SL3o3LdvAUy5HnbMstXI+m4AZCRm9R9YAnEnixZvURz9Leu+tvaJiIiIiIhUKvlKTmVmZhIUFOTSHhwcDEDdunWZNm0aNWrUKN7oRIpT+C9lHYFN5Dr47V9Fn8ecCcv/4VrLyp0d38LCJ3MvBg+QnmCbb+7DYEpz7rOaYfOXRYu3KCJWZ90PX537OBEREREREalw8n21vrz06dMHf3//4phKRAoi6m/YOSvvMX9/BssnUKirAma3czakxRVtjsIwZcKx9VmPT/4NGUnuxx7fABnJpRKWiIiIiIiIFI9iSU5VqVKlOKYRkcJY8y9bTaacLGZY+66t6HlxMKbAtm+KZ66COLUZMrMloyxGiPzDdVxmKiwaBbPvh9QibpkUERERERGRUlMsySkRKUMZibDyRee2M3them/487/Fe6wtX4GxkFcYLCx32/gi3LRtnQZJZ2xF72fdC0nnSj42ERERERERKTKv/A7cunUrU6ZMKVCfwWBg7NixhY9ORPLn8M9wcBk07wXrP7DVh7Kai/84Kedh73wIG5b7GKsVfhwKgbWhzT3Q+Gbw8rH1JcTAkZVweAVkJtv629wLNVvmPl/EGvdtVisYDLbHaXHw1ydZ/ecPwMy7YehSCGlU8NcpIiIiIiIipaZAyamtW7cWqE/JKZFStOIF8PKFhFMle5yNk+C6R23Hcid8NRxaZru/bTr4VoXmPSE+Ck7vdB4bvQ1+ewtqtoKuo6DrU879cSfg4hHXYySdgbP7oF6HrJjSE5zHXIqEb+6C0X/YEmWFkZFsu1JglerQtEfh5hAREREREZE85Ss59cEHH5R0HCJSVCnnS+c4l47BXxPhtldd+yxmWPu2c1tGAhxckvecF8NtWxMTY+D2f2WtiHK3asou4ldbcirxDGye6n5M0mlY9Qo8PDPv4zvFmwQHFsOhnyFyPZgzwDcYnvo97xVepSEjCXxdr5wqIiIiIiJSkeUrOfXAAw+UdBwiUpFs+C+07Q+12zi371sA5w8Wft6/JkJ6IvT9L3h42BJQuYlYAz1ehD8+AlNa7uMOLIIOA6H13Vc+/qHlsPJlW1Iru4xE+GEQjFwLfsH5ey3FyWKBHTNg7Tvw2HxofGPpxyAiIiIiIlJCVBBdRArOYoTlE2xJEztTBqz7d9Hn3v4NLB5tS1Id35D7uOitEL0dds6+8pwrnretOspNQjTMGwTzh7gmpuwuhsOSp51fc2k4ux9m3GnbtpmeYDvvpV2UXkREREREpASV++TUuXPnCAsLY9asWW77lyxZQv/+/enYsSM9evTggw8+ICUlxe3Y9evXM3DgQDp16sSNN97I66+/TmxsbAlGL1KJndpiW81jt32mra5Ucdj3o+1qg6Y8kjBWi201U34KvyfGwNp3XdstZtj0BUzpCkdWXHmewz/Dn/+78ricTBm2bYJWa/7GW60Qs8O2JXHarbbaXHYXwwsXQ3GyWODkprKNQUREREREKo1ynZxKSUlh/PjxJCcnu+3/6quveOWVV7BYLAwZMoQ2bdowa9YsnnzySTIzM53G/vzzz4wePZrY2Fgee+wxbrjhBhYvXsyjjz5KYmJiabwckcpnzVu2K/BlJMGGj4t3bneF0HNKPpf/+bZOg1PZLtxwehd83QtWvwZG9wltt9b9G/YugIsRzjdTpvvxx/+EL7vD/MGw8qXcV15ZrbYaVytehE/a2mLbMhUsJtexf02Ec0XYPllUf3wEs/rmb9VaUVitEHvM+TwnFeA9FxERERGRCiHfV+srbadPn2bcuHEcOHAg1/7JkycTFhbGt99+i7e3NwCTJk3iiy++YMGCBQwePBiwJbneffddGjduzKJFiwgMDATgpptu4o033uDLL7/klVdeKZ0XJlKZZCbZCpnXuw5SL5Z1NFdghWUT4ImVtkTalqm21VeFmWfRSNdm36rQ6k5ocw+06G1LVq35J+yekzVm29e2+lX3fwGe2f75vRAOPz8HJ//KXwj2bZUjVoOHZyFeQxEcXgF/fGi7v2y8bftl93HFf5y4E7atjEd/c273DoBH59iuACkiIiIiIpVCuVw5NWvWLO69914OHz7MDTfc4HbM/PnzMZlMjB492pGYAhgzZgyBgYEsWLDA0bZixQri4+MZNmyYIzEF8NBDD9G0aVMWL16M2ZyPrUEi4urIyuJfNVVSLhyCidfC5i8KmZjKQ0aCrSD8guHwn2YwuZNzYspu73z4caitbpQxHda9D1Nvyn9iyi56G2z7pmDPMRttq66+6uF8m/+4LRl0JRfCYdFo57Zf34Df/53/LYuOuY7Yjvv7e7ZVbPbn22P8/AbXxBTYVrnNfcS2TbIwrFZbvCtehGPrbMcriMwUOLjMdh52fV+4GERERERExEm5XDk1e/ZsQkNDefvttzlx4gSbN292GbNtm60Gy/XXX+/U7uvrS8eOHfnrr79ITk4mMDDQMbZr164u83Tt2pX58+cTERFBmzZtXPpFJB/cbT0rr4ypJX8Mc6btlpsjK+C7ByDlPMQeLfxx1r5tez2GbH9n8A2EFndASEPnsae2wvJ/uL+a4pk9tqsf3vYq3DgWPL1dx6Qn2Gp8ZbopLL/hP7Z6Y3WudW6v0xaa9AAvn6w2Y7qtZtZfE20rwA5hS24Gh0LrPnDy7ytf8dGcaUvw9f8Crns077HZWcy24vg7Ztkeb/s6a8VbtzHQ4Prcn3tkFez4FiLXZdVC2/uDbeXYjc/kP4aCyEyBY79D7bZQo3nJHENEREREpBwol8mpt99+m+7du+Pp6cmJEyfcjomKiqJmzZoEBAS49IWGhgIQGRlJhw4dOHXqFAANGzZ0GdugQQMAjh8/nmtyymq12mpYGU1gLuDqABERd45vLPocaUmw+k33fXU7QOt7oFlP2DMXds7Key5zqm2unT/A3R9A9WbZOq2w6mU4H57783fNc9/uEwwtboc2fcA7CH59HeKOu46Li4bNX+cdoxMTLBwFiRfgmvucu/xDwNvfuc1shCXPwMHFzu2p8bD7R9i9AMJGQK/Xwa9qVn9CNPzyGoSvch/GylchKRZufRkMhrxDNhsh5QrbX82ZtgTdkRVwbD2Y08HDF3o8DzeOd0705XUcdwlGcWK1WjFc6T0TERERkVJRLpNTt9xyyxXHxMfHOxJLOQUFBQE4CqnHxcXh4+ODn5+fy1j7Nr/ciq7bj/X+++9DzE6IyLhibCIiZW/b5dtbBXzeLlh0dzHGcQHW/gD8UIxzZvPni8CLzm0e3lC9KdRsBTVagIcXHFgCl66wSu3PL+CL76Blb9tzY3bA8Q15r4ID+PM9+Ha1LQmXM9lhzoRLkbZi7rFH874CZa4y4I+3oMoUaHW366o4sK1Iu3TMdjXH5PPQbbTrGHESHx9PtWrVyjoMEREREaGcJqfyw2Qy4ePj/i/I9vaMjIwCj81TzZZQpUYhohURkTKRctG21bFhV9stv9LiIKA2tHso/88xZ4BXtj+CWMy243v521ay1e2Q/7lyZbXNm70QvtlkuyCBTyDU71z6RfJFRERERIqowian/Pz8MBrdF7LNzLT9ldvf37/AY90JCQnh9ddfL0q4IiIiUo5s2LChrEMoV86dO0ffvn0ZP348w4cPd+lfsmQJs2bN4sSJEwQHB9OnTx8mTJjgtrzC+vXr+fLLLwkPD8fPz4+ePXvywgsvUKOG/sAnIiIi7lXY5FRwcDBJSW4K84Kj3b69Lzg4mIyMDDIzM11WUNm389nHumMwGHJdeSUiIiIVj+pNZUlJSWH8+PG5ljj46quv+OSTT2jdujVDhgwhPDycWbNmsWfPHmbPnu30Gennn3/mhRdeoGHDhjz22GOcOXOGxYsXs23bNn766SeCg4NL62WJiIhIBeJx5SHlU5MmTYiNjSU93bV+R0xMDB4eHjRu3NgxFiA6OtplrL2tadOmJResiIiISDl0+vRpHn/8cfbs2ZNr/+TJkwkLC+Onn37ixRdfZNq0aTzzzDPs2rWLBQsWOMampKTw7rvv0rhxY5YsWcLLL7/MxIkTeffdd4mKiuLLL78srZclIiIiFUyFTU6FhYVhsVjYvn27U3tGRga7d++mRYsWjmLnYWFhAGzbts1lni1bthAUFETz5rpMt4iIiFw9Zs2axb333svhw4e54YYb3I6ZP38+JpOJ0aNH4+2ddRXIMWPGEBgY6JScWrFiBfHx8QwbNszxGQzgoYceomnTpixevBiz2VxyL0hEREQqrAqbnOrXrx+enp5MmTLFUTcKYOrUqSQnJzNw4EBHW+/evQkICGD69OnEx8c72hcuXMiJEyd4+OGH8fCosKdCREREpMBmz55NaGgo33//Pffff7/bMfY/7F1//fVO7b6+vnTs2JFDhw45tgPax3bt6nrxga5duxIXF0dERERxvgQRERGpJCpszalmzZoxYsQIvv76a/r370/Pnj05evQo69evp3PnzjzyyCOOsSEhIbz00ku89dZb9O/fnz59+nDu3DlWrVpFkyZNGD1al9wWERGRq8vbb79N9+7d8fT05MSJE27HREVFUbNmTbeFz0NDQwGIjIykQ4cOnDp1CoCGDRu6jG3QoAEAx48fp02bNsX0CkRERKSyqLDJKYAXXniBevXqMXfuXGbPnk2tWrUYPnw448aNcylg/thjj1G1alWmT5/OnDlzqFq1Kv379+e5554jJCSkbF6AiIiISBm55ZZbrjgmPj7ekVjKyX4xGfvKqbi4OHx8fPDz83MZa9/ml1vRdREREbm6lfvk1IABAxgwYIDbPoPBwODBgxk8eHC+5urbty99+/YtzvBEREREKi2TyZTrFYvt7RkZGQUeKyIiIpKdCi2JiIiIiFt+fn4YjUa3ffaan/7+/gUeKyIiIpKdklMiIiIi4lZwcDBJSUlu++zt9u19wcHBZGRkOF2oxs6+nc8+VkRERCQ7JadERERExK0mTZoQGxtLenq6S19MTAweHh40btzYMRYgOjraZay9rWnTpiUXrIiIiFRYSk6JiIiIiFthYWFYLBa2b9/u1J6RkcHu3btp0aKFo9h5WFgYANu2bXOZZ8uWLQQFBdG8efOSD1pEREQqHCWnRERERMStfv364enpyZQpU5y2602dOpXk5GQGDhzoaOvduzcBAQFMnz6d+Ph4R/vChQs5ceIEDz/8MB4e+ugpIiIirsr91fpEREREpGw0a9aMESNG8PXXX9O/f3969uzJ0aNHWb9+PZ07d+aRRx5xjA0JCeGll17irbfeon///vTp04dz586xatUqmjRpwujRo8vwlYiIiEh5puSUiIiIiOTqhRdeoF69esydO5fZs2dTq1Ythg8fzrhx4/Dx8XEa+9hjj1G1alWmT5/OnDlzqFq1Kv379+e5554jJCSkbF6AiIiIlHtKTomIiIhc5QYMGMCAAQPc9hkMBgYPHszgwYPzNVffvn3p27dvcYYnIiIilZySUyIiIiIiIiIilYzJbCEx3URCWiYJaSbiUzNJTDcSn2okIS3r1qJ2IJ8O7IiXZ9nVhlRySkRERERERESknDNbrCSlOyeW4lONJKQbSciRcEpIM5KcYcrXvEfPJ5N0v4lqAT5XHlxClJwSERERERERESllFquV5HSTLcmUZiQxx9eENCMJqZmOZFNSuglrAY/hYYBgP2+C/b0J8c/xtYo3Vf29uf2a2mWamAIlp0REREREREREisxqtZKSYb6cbMp0n2xKu7zKKd3WbilotgkI8vOiqr+30y3Efr+KD1X9vGxf/b0J9PXC08OQ53wNq1cp5CsuPkpOiYiIiIiIiIjkYLVaSTOanRJKOes1Zb8lphkxFSLbFODrSVU/W2LJZXVT9iRUFW+C/byvmGyqiJScEhEREREREZGrQro92ZRtFVPWqiZb4fDsX43mgieb/L09CbmcSAqpkkey6XKbdxkWIi8vlJwSERERERERkQop02TJKg5u30qXanR7VbqENCMZJkuBj+Hr5eG6ja5K9sc+Tn0+Xko2FZSSUyIiIiIiIiJSLhjNFhIdySY3RcJzJJzSjOYCH8Pb03A5oeRFVX8f5wLhfrbtc9mTTX7eniXwSiU7JadEREREREREpESYLVZHsinBTdLJsYUuNZOEdCMpGQVPNnl6GBxFwfO6Kp395u/ticFQ+eo2VWRKTomIiIiIiIhIvpgtVpIzTJfrNWWSkG5LLMWnuS8SnpRuKvAxPAy4TzI5ttBdvhrd5VVOAT5KNlV0Sk6JiIiIiIiIXKUsVisp9mRTjnpNLlvq0owkpRsp6AXpDECQnz2h5OW4Kl3OOk72W6CfFx5KNl1VlJwSERERERERqSSsViupmWa3W+jsxcJtW+ls/YnpJswFzTYBgb5ejsLgOa9KlzPZFOTnjaeHkk2SOyWnRERERERERMopq9VKutGSbatcpiPplJBqJCE9x9c0I6ZCJJsCfDzzqNfkfDW6YD8vvDx1RTopPkpOiYiIiIiIiJSiDJPZ6apzObfOOd1SjWSaLQU+hr+3J8H+XoT4+zi+OhJMbq5K561kk5QhJadEREREREREisBotjglk1y20qVlkphmIv7yqqd0Y8GTTT6eHo5kknOB8By3y2N8vTxL4JWKlAwlp0RERERERESyMZktJKabLm+hMxGfmulSJDz76qbUTHOBj+HlYXCq0+T+qnRZq5z8vD10RTqptJScEhERERERkUrNbLGSlO66Zc5RtylHe3KGqcDH8PQwUNXP27aFroqPo0h4blekq+LjqWSTyGVKTomIiIiIiEiFYrFaSU43udZnyr6qKTWThHQTCamZJKWbKGiJcA8DBPtlW8nkpk6T/Rbi70OAr5JNIoWl5JSIiIiIiIiUKavVSkqmOdtV5zLd1G1y/lqIC9IR5OeVyxY6b6pWcb4iXaCvF54eSjaJlAYlp0RERERERKRYWa1W0oxmR4HwhBz1mnLWbUpMM2IqRLYpwNfz8tXocikSnm21U7Cft5JNIuWUklMiIiIiIiJyRen2ZFO2q9LZk072wuHZvxrNBU82+Xt72oqEX6FeU9XLiShvT48SeKUiUtqUnBIREREREbkKZZosOeo1ZWbVbXJTJDzDZCnwMXy9PGw1mXJNODlvpfPxUrJJ5Gqk5JSIiIiIiEglYDRbSHRTHNxpK12qkcTLq53SjOYCH8Pb00BVfx/Xuk25rHLy8/YsgVcqIpWNklMiIiIiIiLlkNliJTH98va53JJNjqvSGUnJKHiyycvDkHe9phzJJn9vXZFORIqfklMiIiIiIiKlwGyxkpxhulyvKZOEdJPta47i4PZbcrqJglZt8jDgmmRy2kLnRdUqWSufAnyUbBKRsqfklIiIiIiISCFYrdmSTdm30rm5Kl1imm07XUEvSGfAlmzKdXVTjqvSBfp54aFkk4hUMEpOiYiIiIiIYEs2pWaa81GvybbaKTHdhLmg2SYgyNfLUafpSlelC/LzxtNDySYRqdyUnBIRERERkUrJarWSbrSQ4KjblJlH3SZbQspUiGRTgI9n1oqmyyuYqla5vIUu29XoQvy9CfLzwstTV6QTEclOySkREREREakwMkxmpwLhOa9Ml7Mt02Qp8DH8vT1zXcmUvUi4fZudt5JNIiJFouSUiIiIiIiUSykZJvZGx7PrVDz7YhKITc4kzVjwK9L5eHk41Wtye1U6v6zEk6+XZwm8GhERyY2SUyIiIiIiUi6YLVYiziexKyqeXVFxHDmX5LaAuJeHwVavyaU4eI6tdFVs/X7eSjaJiJRnSk6JiIiIiEiZOZeYbktGnYpjT3Q8KRnOK6MaVPOnU8MQOjasRoNq/oRU8cbf2xODrkgnIlJpKDklIiIiIiKlJjXTxP6YhMsJqXhi4tOc+gN9vbiuYQidG4XQsWEItYP8yihSEREpLUpOiYiIiIhIibFYrRw7n8yuU/HsjIrj8NkkzNn26nl6GGhTN4hODUPo1KgazWsF4umhVVEiIlcTJadERERERKRYXUzOYFdUHLtOxbP7VDxJ6San/npV/ejUqBqdGobQoUFVqvjo1xIRkauZ/hcQEREREZEiSTea2X86a6veqUupTv1VfDy5rkEInRqF0KlhNepW1VY9ERHJouSUiIiIiIgUiMVq5cTFFHadsl1V78DpREzZtup5GKBl7SA6NQqhc6NqtKoTpK16IiKSKyWnRERERETkiuJSMh3JqN2n4olPMzr11w7ydWzVu65BCIF++lVDRETyR/9jiIiIiIiIi0yThQOnExwJqROxzlv1/Lw96BCatVWvfogfBoNWR4mISMEpOSUiIiIiIlitVqIupV6uGxXH/phEMs0WR78BaF470HFVvTZ1g/D29Ci7gEVEpNJQckpERERE5CqVkGZk9+WVUbtOxXMpJdOpv0aAj6NuVIcGIVT19y6jSEVEpDJTckpERERE5CphNFs4fCaRnZdXRx27kOLU7+PlQfvQqo7VUQ2r+WurnoiIlDglp0REREREKimr1Up0fJptq15UHPtPJ5ButDiNaVYzwFE36pp6wfh4aaueiIiULiWnREREREQqkaR0I3uiExxb9S4kZTj1h1TxdqyM6tgghGoBPmUUqYiIiI2SUyIiIiIiFZjJbOHIuSTHVfUiziVjzdbv7Wng2vpZW/Wa1KiirXoiIlKuKDklIiIiIlLBnElIs9WNiopjb3QCaUazU3/j6lUcW/Xa1g/Gz9uzjCIVERG5MiWnRERERETKuZQME3uj4y+vjornbGK6U3+wnxcdG1a7nJAKoUagbxlFKiIiUnBKTomIiIiIlDNmi5WI80mOQuZHziVhybZXz8vDwDX1gh1b9ZrVCsBDW/VERKSCUnJKRERERKQcOJ+Yzq5T8eyMimNPdDwpGc5b9UJD/OnUKITOjarRrn5V/H20VU9ERCoHJadERERERMpAWqaZfTG2bXq7TsUTE5/m1B/o68V1DW3b9Do1DKF2sF8ZRSoiIlKylJwSERERESkFFquVY+eTHVfVO3w2CVO2vXoeBmhTN9hRyLxF7UA8PbRVT0REKj8lp0RERERESsjF5Ax2R8Wz61Qcu07Fk5RucuqvV9WPjpfrRnUIrUqArz6ei4jI1Uf/+4mIiIiIFJN0o5kDpxPZGWVLRp26lOrUX8XHkw4NqtK5UTU6NgyhXlX/MopURESk/FBySkRERESkkCxWKycupji26h04neiyVa9l7SDbVr1G1WhVOxAvT48yjFhERKT8UXJKRERERKQA4lIybcmoU3HsPhVPfKrRqb9WkC+d7Vv1GlQlyM+7jCIVERGpGJScEhERERHJQ6bJwsEzieyKimNnVBwnYp236vl5e9A+tCqdGlajU6MQQkP8MRhUyFxERCS/lJwSEREREcnGarUSdSmVXZcLme+PSSTTbHH0G4DmtQIdW/Xa1A3CW1v1RERECk3JKRERERG56iWkGdl9uW7UrlPxXErJdOqvHuBD50YhdGpYjesahlDVX1v1REREiouSUyIiIiJy1TGaLRw+k3i5kHk8xy4kY83W7+PlQbv6VW2roxqG0Kh6FW3VExERKSFKTomIiIhIpWe1WomJT2NXVDw7o+LYfzqBdKPFaUzTmgF0ulzIvG29YHy8tFVPRESkNCg5JSIiIiKVVvi5JCauCWf7yTguJGU49YX4e9OxUQidG1WjY4MQqgX4lFGUIiIiVzclp0RERESk0npj8T62nYgDwNvTwLX1q15eHRVC4xoBeGirnoiISJlTckpEREREKq0X7mzNst0xtKoTzLX1g/Hz9izrkERERCQHJadEREREpNK6oVkNagT4uNSXEhERkfJDVR5FRERERERERKTMKDklIiIiIiIiIiJlRskpEREREREREREpM0pOiYiIiIiIiIhImVFySkREREREREREyoySUyIiIiIiIiIiUmaUnBIRERERERERkTKj5JSIiIiIiIiIiJQZr7IOQERERETKv4kTJzJ16lS3fX379mXixImOx0uWLGHWrFmcOHGC4OBg+vTpw4QJEwgICCitcEVERKQCUXJKRERERK7oyJEj+Pj4MGrUKJe+li1bOu5/9dVXfPLJJ7Ru3ZohQ4YQHh7OrFmz2LNnD7Nnz8bHx6c0wxYREZEKQMkpEREREbmi8PBwWrRowfjx43Mdc/r0aSZPnkxYWBjffvst3t7eAEyaNIkvvviCBQsWMHjw4NIKWURERCoI1ZwSERERkTwlJycTExNDq1at8hw3f/58TCYTo0ePdiSmAMaMGUNgYCALFiwo6VBFRESkAlJySkRERETydPjwYcB5+54727ZtA+D66693avf19aVjx44cOnSI5OTkkglSREREKiwlp0REREQkT0eOHAEgLi6OESNG0KVLF7p06cL48eM5duyYY1xUVBQ1a9Z0W/g8NDQUgMjIyNIJWkRERCoMJadEREREJE/25NSsWbMICAjg4YcfpkOHDvz66688/PDDHDhwAID4+HiCgoLczmFv18opERERyUkF0UVEREQkT56enoSGhvLBBx/QrVs3R/uyZct46aWXeP3111m6dCkmkynXq/HZ2zMyMkolZhEREak4lJwSERERkTz961//ctt+33338eOPP7Jt2zYiIyPx8/PDaDS6HZuZmQmAv79/icUpIiIiFZO29YmIiIhIobVt2xaA6OhogoODSUpKcjvO3p7btj8RERG5eik5JSIiIiK5MplM7N27lz179rjtT09PB2xX5GvSpAmxsbGOtuxiYmLw8PCgcePGJRqviIiIVDxKTomIiIhIriwWC4MGDeKpp57CbDY79VmtVnbt2oWXlxfXXHMNYWFhWCwWtm/f7jQuIyOD3bt306JFCwIDA0szfBEREakAlJwSERERkVz5+PjQq1cvEhISmDZtmlPfjBkzCA8P59577yU4OJh+/frh6enJlClTHDWmAKZOnUpycjIDBw4s7fBFRESkAlBB9HyyWq0YDIayDkNERESk1L3yyivs3LmTTz/9lK1bt9KmTRv279/P1q1bad68Oa+++ioAzZo1Y8SIEXz99df079+fnj17cvToUdavX0/nzp155JFHyviViIiISHmklVP5FJ/q/sozIiIiIpVdaGgoP/30Ew8++CARERF89913xMTEMGLECObPn0+1atUcY1944QXefPNNDAYDs2fPJiIiguHDhzNt2jR8fHzK8FWIiIhIeaWVU/l08lIqIVW8tXpKRERErkp16tTh/fffv+I4g8HA4MGDGTx4cClEJSIiIpWBVk7lU1K6kYQ0rZ4SERERERERESlOSk4VwKlLaWUdgoiIiIiIiIhIpaLkVAFEXUot6xBERERERERERCoVJacKQMkpEREREREREZHipeRUAZyKU3JKRERERERERKQ4KTlVAKe0ckpEREREREREpFgpOVUA2tYnIiIiIiIiIlK8lJwqgJi4NMwWa1mHISIiIiIiIiJSaSg5VQAmi5UzCWllHYaIiIiIiIiISKWh5FQBaWufiIiIiIiIiEjxUXKqgFQUXURERERERESk+Cg5VUCnLmlbn4iIiIiIiIhIcVFyqoC0rU9EREREREREpPgoOVVASk6JiIiIiIiIiBQfJacKKDpOySkRERERERERkeKi5FQBXUzOJCXDVNZhiIiIiIiIiIhUCkpOFcIprZ4SERERERERESkWSk4VQlSsklMiIiIiIiIiIsVByalCOBWXVtYhiIiIiIiIiIhUCkpOFcIpXbFPRERERERERKRYKDlVCFFKTomIiIiIiIiIFAslpwpBK6dERERERERERIqHklOFEHUpFavVWtZhiIiIiIiIiIhUeEpOFUKGycKFpIyyDkNEREREREREpMJTcqqQTsVpa5+IiIiIiIiISFEpOVVIKoouIiIiIiIiIlJ0Sk4VUlRsWlmHICIiIiIiIiJS4XmVdQAV1ar9Z6gV5Eu3ZtVpVjMAg8FQ1iGJiIiIiIiIiFQ4Sk4V0uGzSby+eB8ANQN9GdStEc/f0aqMoxIRERERERERqVi0ra8YXEzOYPLaCNYfOV/WoYiIiIiIiIiIVChKThWjV37aS0KqsazDEBERERERERGpMJScKkbnEjN4a/mBsg5DRERERERERKTCUHKqmC3eFcMv+8+UdRgiIiIiIiIiIhWCklMl4I3F+7mYnFHWYYiIiIiIiIiIlHtKTpWA2JRMFu+MKeswRERERERERETKPSWnSsihM4llHYKIiIiIiIiISLmn5FQJOajklIiIiIiIiIjIFSk5VUKOnk8mw2Qu6zBERERERERERMo1JadKiMliJeJcclmHISIiIiIiIiJSrik5VYJUd0pEREREREREJG9KTpUg1Z0SEREREREREcmbklMlSCunRERERERERETypuRUCTp0Jgmr1VrWYYiIiIiIiIiIlFtKTpWghDQjpxPSyzoMEREREREREZFyS8mpEnbo9JW39iWkGkk3mkshGhERERERERGR8kXJqRKWn6LoX/8ZyYHTCaUQjYiIiIiIiIhI+aLkVAm7UlH0SymZzNx4nB0n40opIhERERERERGR8kPJqRJ2pZVTX204RkqmWckpEREREREREbkqKTlVwk7GppKcYXLbdyEpg9l/nwRgx8l4XdlPRERERERERK46Sk6VgsO5rJ6a+scx0i4XQr+YnMGpS2mlGZaIiIiIiIiISJlTcqoUuKs7dS4xne83n3Rq2xF1qbRCEhEREREREREpF5ScKgXu6k59se4oGSaLU5vqTomIiIiIiIjI1UbJqVJw8EyS477FYmX6n5HM2RLlMm7nyXi3z19z8Bxmi+pRiYiIiIiIiEjl41XWAVwNjpxNxGyxEp+ayYsL9rDuyAW34w6fTSQ5w0Sgb9bbYrVa+d+vR/D18qBHq1qlFbKIiIiIiIiISKnQyqlSkG60MG9rFH0m/ZlrYgrAYoU9p+Kd2nZGxXH4bBI/7Ywu4ShFREREREREREqfklOl5P+W7Od8UsYVx+WsO/X9Ztv2v9UHzpKUbiyR2EREREREREREyoqSU+VM9uTUpZRMVuw7A9hWX628fF9EREREREREpLJQcqqc2RkVh+Vy8fOFO06Rme2Kfj/tiCmrsERERERERERESoSSU+VMUrqJoxeSsViszM1xRb+tJy4RFZtaRpGJiIiIiIiIiBQ/JafKoR0n4/j7WCwn3CSiVBhdRERERERERCoTJafKoR0n4/h+80m3fYt2RWO1Wks5IhERERERERGRkqHkVDn0R/gF1hw657bv1KU0tp2Ic9snIiIiIiIiIlLRKDlVDl1IysBsyX111Ge/R7D9xCUyTOZSjEpEREREREREpPh5lXUAUnB/Rlzkz4iL+Hp50LlRNYZ1b8zd7erl67kms4VLKZnUDvYr4ShFRERERERESpbVChaL7avVknXfcvmxvR8rYIDgqlnPjb1owGSEatWt+Pja2pISIS7WAyuX57LkOIY1e7sBiwU8vay0bW9xzHvkoAeJCQaat7JQvYZt4cnF8wYOH/DEinOcVpd4bXNaLk93zwNGx7xbNnoSHeVBxzAzzVvZBpw9Y2Ddau9czwFWsFgMjnNguRz/E09n4O9fUu9KwSk5VYFlmCxsiowlzWjOd3Jq2Z7THL+Ywgt3tnbbfzYhnZAq3vh5exZnqCIiIiIiIpIHe2lhg8H21WKBzAxbTiV7EiElGYxGQ44kSR7JEysEBlmpUdN2AJMJIiM8sFqh1TUWx/GijnsQH29wmi9nQiN7osMK1KhpcSRlrFZY+4sXViv06GXC9/J6iP27PTl53MN5PsvlZIwVrPb5ssVeu66FO/qaHK953iwf0lKh/0CjI9mzfZMn2zZ7kbMks8HNA8PlO9VrWBg8wuh4vG6VN5diDQwYaKRhY9tEEac8Wf+bV9bTDa7zGjA4NVSpYuWmG0wYDLaZTx31JDrKQPOGFmoFWTEYIC7GQORB59+zDYYcc7ppb1jdG4PB1rbLZCAjwUCIj5VmtWz9XqlgyPDAM+dr98gxZ7Y7BqBNHV+CgsBgcHpWmVFyqhLYGx1PQqqRqlW88xxnNFuYtDYCk9nKc71b4eHh+k347aYT1AnyZfhNTUsqXBERERERqcRcEyRZyQisOVa5WG1JlsBAK94+tuenpkBiggFfP9uKFjt7goNsiROnY11OdGRfhdKoqcUxx6VYA0ePeBAY5LzKZfNfnmRmZCV78pM8aXedmaYtbHNcOGfgj7VeBAXBXf2yVrmsWOxN3CXnZE/WqhlDtnOQNff1N5jo2t1WviUh3sAPs3zw9bPy5NhMW4ICA2tXeXM62iNHYiPbfYNra4eOZhrfZYs3PRX+XGP73fH6TiY8L+dL/jrqScRhD8dTXZIx2aa093m1tlD3ZqvjmGdPeILVQK1AM8FBtlgOZRqIP5tVUSivhIwB8AQCDNCyjtXRHuxjwDPTQPNavtStYxt/oaaB44E5X7vz77gGA3h4ZH2tWRPa1M3K9LVoALH+0LyOL41q29oyG8L55s7Py+2+/auvLzSo5uOY94ZOENsIWjaCupdXahmaQubt+Zs3+/2q/p6Oc3b7bdA1DOrUgYDLK72aNoJRI11jutL9KlWc34uypuRUJWCxwt/HLtKnfd6rpxbvjOFkbCoAm4/H0r15Taf+DJOZH7edwsPDwMAujfD30eopEREREbl6ZU9GeGX7zSkjHcxm8PYB78t/HzZmQnKywTV5Qs4tPIZsSQ9o0jxr5crpaAOJCQZq1cla5ZKSDEfDPV22AWWfw5IjIWO1wg03Z61cOXzAg6gTHjRtbqFlG1uCIjkJ1q/xdk4g5Vgdk/NYFotti5F95cru7Z7s2OJFq7ZmbulpW+WSngYzvvR1OZc5V7PkTErc/3AmjRrb7oef8GD9Gi9atLJwT38TYMBggDXLvcGalTXJayWLvb9uTTPVG1kxAHGnDRzc6UmDBnDbTWbHmJhjnqQkGxyxOM2ZLcbsqhisNK5pm9czFYyJnuBtpVktH0cSyR8DyaZsT7LnfbItEsi5MqdxdV/ahdqSLLH+UDsY/PygXWhWQmVPXfBIz39yw2CA1o2g6eVf/zIyoHM7W3ujGj54XI6r0zVQK6hgiZNatWzPset/r+1rveqe+FzO1XTvCq2a5Z3cyXnfzw/8sq29GDnC9jUkxIDX5V9Tb+oOXbvk/bqvlHx5/HHXtrZtbbeiuPFG17bataF376LNGxrq2ubnB40bF23e8kDJqUriz6N5J6cyTbZVU3Y/7YhxSU6tPnCO2JRMAL7ffJKnejQrmWBFRERE5KpitYLJCCaz7avBAIHZfqE9dcKDjAxo2NjiSKicjjZw6qQHJqMBkwnMJjDnXB2TYzVLQICV2/tkZQPWrPQiLtaDHrcbqVvfllAJP+TBlo1eudZ5cWq/vGjH1xeeHJsB2GL/dYU30Sc96N3XSJu2tkEnoz34ZVnWb9NXWslivzf+RaPjl+3jhz05ctCTHr3MNG9kSyKlXDKwc6PXFRMyOX8Hv+dOL4KCbe2H0zw4f9KD5qEWGl5eRRRnNZBwziNHfO4TMh7Z5m9UzYf6dW33L4QYCPc2UDfIyjX1bAmV9HSone29dbeSxV0ioUVtX5penjczFKIbQvP60KJ21nPbt7K9JwVJnrRq6E1oyOXX0Qh63QLVq0Od4Kz3qvetYDQWbNVJaCjYy/g2bQjDh4KPT9ZqFoCBD2fNm5+EjMFgm8N+yqpXh3/+E0fyyO6xxygSX18YOtS1/YYbijYvuE/KNGhguxVFzZqubb6+tptUDkpOVRIbwi9gtVpz3S/64/ZTxMSnOR6v2n+Gd+6/lgDfrG+BOZtPOu5P/eMYg7o1cuoXERERkcrBnswxGW0rgExGMJoM2R7bEkJ+/lbqN8jaVrV9kydGo4HOXbNW5Rzc50FkhCdmExhNtufa5zSZDJhNtqQU2BIcBoOBevUtPDzYhIfB9vivtd6kphgYPMxESHXbL+dHL3lyeFfWdhb7apTscn709TJB45oWx3G8Mg2YUwzUDfSmeW3b85NPg485W0bHkPdKFrAlDNo3yLqg0O4akBkHzWv50ba+rc07BQ7Uyv82IPv9JjV8HKuy2reEIG9o09ibhtVtbVWscFPXKyc3crbVq+6F3+WQu3SERvWgfn1PQqrY2vw94bFH8p80sd+vVQt8Lsd7Q1e4rj34+WWtZqniDy+/nHt8+dlG1K6d7ZbTyJFXfm5e6taFe+5xbb/55qLN6+8PrVq5P15RGAw4ttyJVHbKPFQS0XFpnIxNpUnNAJe+dKOZz9cddWpLzTTzy/6zPBhmS2FHnEtiy/FLjv7YlEy+3XSCZ25rUbKBi4iIiIiTjHTIzASz2XA5wWO/uSaP7LfqNayO7VomE/z6szcmE/Ttb3QkPjau9yL8sIcjeWSxZCViDJe3TdmSOrZGgwGaNrVwTUvL5cSCgfB9XhiNBm672ZPqIQY8DAaOmm0rcAzZ5vECvAxg8DZg8LavlrFlJTw9oX41aJ3tF/fr2kBqKjSu5UPty0mZzDbgZ7Btp/P2tn319Mw9aWKv+xLsl/XbfP/7bOeyXj0PqlzeYtThWmhYv2AJpJwrVwYPdk2ytGwJr7xStPf+pptst+xq1IAHHyzavE2a2G7Z+frCddcVbd4qVWy37AwGCHD9lUREJE9KTlUifx696DY59cPWKM4kpLu0/7Qz2pGcmrMlyqV/2oZIHr+hMUF+eRdaFxEREanMLBZbHR2zGYKCs9rPnjGQlmLAmCNhZL6cMDLaVw1lW03UuKmFdh1ty4hSkmHhHB+sVhg+JtMx7++rvTkR6ZEjYWTIljhyfmzAwDVtLdTtZsXDYNueFnfGlqAJrepNQBVbEikiEKI9DBh8c8xryEr+eHs732/QABrVyHrNPW+2rboKreHlSEB06wxNG+Q+R/b7Xl6uiR6AgQNd25o1s92KolEj17aAgKInT8pTEWERkcpAyalK5M/wCzx+g3MltMR0I1NyrJqy2xQZS0x8GtWr+PDTzmiX/vhUIzM3nuChsAZsOR7LlshLnE5IZ+bwLni6udKf1WplwY5oHrm+YfG8IBEREZFisH+PB5fiDU7Jo9y2nxkvJ5M6hpnp1MWWRIq7ZODH2T5UCYCRYzPxMBjwMMDOTZevmEVW7Z9ck0mXE03NQq00rQUeBkgPMuCHAYOHgdZ1fPHyNODhYeBwbci4lL9kj/1+/frORYkfedDWXi3Q01Gw+/aecNONrnPYVyPlx513urbVr2+7iYiIFJaSU5XIpmOxmMwWvDyz/hz12doILiZnuh1vtcLindHUDvIjKd3kdszE38L5ZE24U9vS3TEM6Oxa0W7tofO8uXQ/va+pQ/UAH5d+ERERkbIQccCH8+cMLrWL3D32AXw8oHYVaFvfloSKq2JgfbBttU2bull1h9o1hxpV8pc8st+vWRMCLxfw9fOCsc9c7vPKiuehh4q+MqdzZ9e2qlVtNxERkfJGyalKJCnDxJ7oeMIa2zbqH7uQzMyNJ/J8zk87Ywjyy/3bwGp1bZu0NoL7rqvvlASzWq18siacdKOF7zad5B+9WxbqNYiIiEjFZzKZ+P777/nxxx+Jjo6mVq1aDBgwgFGjRuFtX8ZTim4I8yY5Of+rkLy9ITAQ7B91qlWDf/3LNWHkrrByQXh4QD03F1vWljEREbnaKDlVyfwZcdGRnHr354OYLG6yS9kcv5hS4GOcjE1l0c4YHumStX1v9YFzHDyTCMDsTScYfWsz/LzL9tISFosVDzfbD0VERKRkvfPOO8yfP5+wsDB69erFzp07mTx5MkeOHGHy5MmlHk+PHkV7vpJFIiIiJctNOUKpyP6MuAjA74fPsf7IhRI7zqS1EWSabFeEsVisTMy29S82JZNFO2PcPs9ktpRYTNmdjE1h+KxtZNivWywiIiKlYufOncyfP5++ffsyd+5cXnzxRebMmUP//v1ZvXo169evL+sQRUREpJxRcqqS2X0qntjkDN5ZfrBEjxMTn8aCHacAWLn/DEfOJTn1T/8zEkuOVVufrY1gxsbjJRoXgNli5aUFe9kQfoF/LT2A1d3eRBERESkRc+bMAWDs2LGONoPBwPPPP4/BYGDBggVlFZqIiIiUU0pOVTJmi5Vn5uzkRGxqiR9ryu9HScs08+lvES59kRdTWHv4PJBVj+p/a8KZ8dcJx4qrkjJz43G2nrgEwA/bTjF708kSPZ6IiIhk2b59O9WrV6dFixZO7XXq1KFJkyZs27atjCITERGR8krJqUpoy/FLpXKcMwnpPPntNo6eT3bb//WGSKxWKx+vPsLktbYE1tnEdFbsO11iMR09n8R/Vh9xanvn54P8ffRiiR1TREREbDIzMzl79iwNGzZ02x8aGkpCQgKXLpXOZxURERGpGJSckiL5+1hsrn1bT1zi6e938sX6Y07t0zYcd7vVLj41kwtJGYWOxWS28PyPe1xWZpktVp6Zu7NQxd9FREQk/+Lj4wEICgpy229vT0pKctsvIiIiVyddrU9K1C8Hzrq0HTqTyMajsdzcsqajzWi28PT3O9l1Ko5BXRsz+tZm1An2c/SfT0pnx4k4kjJMuR5rV1Qce6MT3PbFpxp5dNom5j11A81qBRbhFYmIiEhuTCbb/9M+Pj5u++3tGRmF/2OUiIiIVD5KTkmZmPZnpFNy6r2fD7Ip0rYKa8bG43y/5SQPhTXAYrGy9fglIoth1dO5xAwGTtvMvKe60aK2+7/oioiISOH5+dn+sGQ0Gt32Z2ZmAuDv719qMYmIiEj5p219UiY2hF/g0JlEAH7YGsW3OYqWZ5oszN0SxQ/bThVLYsruQlIGj07bzJGzpbOdICHVyJqD5zh8NrFUjiciIlKWAgMD8fDwIDnZfT1K+3a+3Lb9iYiIyNVJK6ekzHz9ZySDujbin0v3l+pxLyZn8tjXm3n/gXbc2bYuHh6GYp0/Kd3IZ78fZUP4BY6cS8JqhWa1Alg54Rb8vD2L9VgiIiLliY+PD/Xr1yc6Otptf3R0NNWqVSMkJKR0AxMREZFyTSunpMws232a0d/twGh2LY5e0i6lZDLm+530mfQnP+89jdliiyEt08zfRy8yeW0EJwqxYmtvdDz3TP6LaRsiOXzWlpgCiLyQwn9+OZL3k0VERCqBsLAwLly4wPHjx53az507x8mTJ+nYsWPZBCYiIiLlllZOSZkxWazEpmSWaQxHziUxbu4umtcKp1oVH/ZExzuSZdM2RPLvB9pxf8fQK85jsViZsfE4H/1yONdk24yNx7mjbR1ubF6jWF+DiIhIedK/f3+WLl3KxIkT+fTTT/Hw8MBqtfLJJ59gtVoZOHBgWYcoIiIi5YySUyLAsQspgPNKqeQME//4YTcbj17krfuupYqP+x+X3afi+e/qI/x19OIVj/PSwj388mwPAn31oyciIpVT9+7d6du3LytXrmTgwIF069aNXbt2sX37du666y5uu+22sg5RREREyhn9hixyBT9uj2bL8Uvc3a4uNzStwfVNqhHk582Ok5eYtNZWWyq/ouPS+PeKQ3wwoH2h41m4I5oHO4diMBRvrSwREZHi8p///IcWLVqwePFivv32W+rXr8+ECRN46qmn9P+XiIiIuFBySiQfTsam8tUfkXz1RyQeBmhYvQonY1MLNde8rVF4eRh4+rbm1A8p2KW0526J4vXF+wj09eTudvUKdXwREZGS5u3tzdixYxk7dmxZhyIiIiIVgAqiixSQxUqhE1N2320+ya0fr+O1Rfs4dSl/c209fok3L1/Z8L0Vh0g3mosUg4iIiIiIiEh5oOSUSBkxmq3M2xpFz/+uZ93h83mOjY5L5envd2C6fFXB6Lg0vt4QWaTjHz2fzHPzd/PJmnBMZkuR5nLn1KVU3lp2wHElRBERERERERF3lJwSKWMmi5UJP+zi2IVkt/2pmSZGzd7hcmXDL9Yf40xCWoGPd+RsEuPm7uSOiX+weFcMk9dGMGj6livOlZxh4slZ2/j0t3ASUo15jk3JMPHU7O3M+vsEz87fXSLJLxEREREREakcVHNKpBxISjfx1LfbWTz2Jqr6ezvao2JTGT9vJwfPJLo8J81o5oOVh5n8WCe3c1qtVmZuPMF/fz2CyZy1einTTaJo6/FL9Jn0J/996Dp6t63j0p+YbmT4jK3sjIpn7eHzfPPncYZ2b8yTNzejeoCP01iLxcoLP+7h8NkkAJbvOY3ZYmHSo53w9lQ+XERERERERJzpN0WRciLyYgoT5u1ybINbvuc090z+kz3RCbk+Z9me02yJjHVpj0vJ5KnZ23nn54OkZprJNFsct9zEpxoZOXs7Q2dsZcfJS472hDQjj39jS0zZJWWY+HzdMW7+6Hc+WHmIC0kZjr7Jv0fwy4GzTnOv3HeWsXN2FmudLIu2C4qIiIiIiFQKlWLl1MSJE5k6darbvr59+zJx4kTH4yVLljBr1ixOnDhBcHAwffr0YcKECQQEBJRWuCK5+iP8Au+tOEi60cy8rafy9ZyB0zbTuk4Q3ZpVp2vT6gT4ePHaon2cTUwvVAwbwi+wIfwC3ZvXYOQtTZm4JoJ9Me4TZKmZZr7aEMm3m04wqGtjWtYJ5NPfItyO/fXgOTq+8yudGlajW7PqdGtag+ubVCvwaqozCWl89UckG49eZPHYmwj0zd8/YyazBS+t3MpTWqYZfx/Psg5DRERERESuMpUiOXXkyBF8fHwYNWqUS1/Lli0d97/66is++eQTWrduzZAhQwgPD2fWrFns2bOH2bNn4+Pj4/J8kdI2c+OJAj/nyLkkjpxLYvamk8UWx9/HYvn7mOuqLHfSjRZmbDyer3GbImPZFBkLRNCgmj9je7bgwc4N8PHKPXFktVo5fjGFGRuP8+O2aMcKsPdXHuL9B9pf8bhLd8cwd0sUM4Z3IcBNMivdaMZssbrts1qtnElIJznDlOv8fl6eNKzuj8FguGIsRZVhMuPrVTwJJKPZwvojF9gSGcuW45c4eCaR/z18Hf07hRbL/CIiIiIiIvlRKZJT4eHhtGjRgvHjx+c65vTp00yePJmwsDC+/fZbvL1tdX0mTZrEF198wYIFCxg8eHBphSwi2K46+NqifXy2NoIxtzWnXWhVR5/VauXI2WS2HI9lS+QltyvB5m6J4q5r63Jrq1q5HmNvdDwvL9xLhsnCsBlbmflEF4L8sup6hZ+zFYg/diGFdqFVuaFpda5vUp2LyRlsiYxl6/FLnE648iq0moG+dGtanW7NqnNNvWA8PbISVc1rBlK1incez86fA6cTGP3dDr4Z1oXWdYOKPN/byw/w/eYop7ZXftpLs1oBdGgQUuT5RURERERE8qPCJ6eSk5OJiYmhS5cueY6bP38+JpOJ0aNHOxJTAGPGjGH27NlKTomUodMJ6by59EChnvvKwr2sfraH2+TP+aR0Rn+3gwyTbaXV9pNxDJ2xlW9HdCXI14sftp3i7eUHSDfa+vecimfPqXi+2hBZ4DguJmewYt8ZVuw749LXsnYgc57qRu0gvyvOExOfRo0AH/y8nVdH7YtOYMg3W0hIMzJy9jaWjb2ZagGFX+05Z8tJl8QUQIbJwqjZO1g2/qZ8xSsiIiIiIlJUFb4Ay+HDhwHn7XvubNu2DYDrr7/eqd3X15eOHTty6NAhkpOTSyZIESkxZxPTeXu5a2Irw2Tm6e93cibHqqddUfE8Pn0L4+bt4rVF+xyJqZIUcT6ZR6dt5lwedcAiLyTzwo976PGfddz80Tq+3hBJaqbpcsxxDJq+mYQ0IwCnLqUxdu5OjHkUuM/LlshY/pVHMvBsYjpjvttBhqn4CthnZzJb2BedkOf5yC4x3cjfxy5yNh8r2MBWOyv8XFJRQhQRERERkVJU4VdOHTlyBIC4uDhGjBjBvn37ALjhhht49tlnad68OQBRUVHUrFnTbeHz0FBbfZXIyEg6dOjg0m+1WjFmZmI1G0vqZYhIEfy0/QQNqnpTP8Tf0bY+/ALbI8+7Hb/75EV2F195rnw5djaeR774k9lPdqVeVVucqZkmdkfFs3BnNCv2nsZ+AcILCZm8t3wvn689zINhoczbeoqUHDWvNoaf5Z0le/lnv7YFiiM6LpXR327BaMzMc9yO4xd4bt4ORvdoRus6QXh45L+eltli5fCZRMLPJ2HNdlHFC0kZbD1xiR0n40jJMOHj5cEjYQ15qkczp/cuLiWT7ScvsfX4JbaduMShM4mOc9OoehW6NqnO9U2r07VJdRpWr+J4XkqGiTlbTjLjr+PEpmTSo1Utxt7Wgs6Nq+U79pzOJ6VzMSmDtvWrXnmwVChWq7VU6sSJiIiIyJUZrFZrhb4e+5tvvsn8+fPx8vKiV69eNGzYkCNHjvDXX38REBDAd999x7XXXku7du1o0KABv/zyi8scH3/8MdOnT2fmzJl0797dqa99+/YYjUb8/P3JNJX8CgsRqdw8DAa8PT0wWSyYLUX/59fHy5MC5I3INFuwFPC4BoMBTw/bLa9DWbElpkwWKxTovxYD3l62uU0Wa4HiMxgMeHkY8DAYyDRbcPdfmpeHB16eBUtCWKxWTGYrFqsVTw9Dga8qKeVfamoq3t7ejj9qSdlq3749ZrOZevXqlXUoIiIiUkzOnDmDp6dnvj5vVfiVU56enoSGhvLBBx/QrVs3R/uyZct46aWXeP3111m6dCkmkynXq/HZ2zMyMlz6fH19MRgM1KhevWRegIiIiJS6vD4XSOnz9fUlMzPvFZ0iIiJSsXh5eeX781aFT07961//ctt+33338eOPP7Jt2zYiIyPx8/PDaHS/Lc/+Ycjf39+lb/v27cUXrIiIiIi40OctERGRq1ul3qfQtq2tFkt0dDTBwcEkJbkvkGtvDwoq+qXZRUREREREREQk/yp0cspkMrF371727Nnjtj893XZlJ19fX5o0aUJsbKyjLbuYmBg8PDxo3LhxicYrIiIiIiIiIiLOKnRyymKxMGjQIJ566inMZudLnlutVnbt2oWXlxfXXHMNYWFhWCwWl2XjGRkZ7N69mxYtWhAYGFia4YuIiIiIiIiIXPUqdHLKx8eHXr16kZCQwLRp05z6ZsyYQXh4OPfeey/BwcH069cPT09PpkyZ4lRwc+rUqSQnJzNw4MDSDv+qc+7cOcLCwpg1a5bb/iVLltC/f386duxIjx49+OCDD0hJSXE7dv369QwcOJBOnTpx44038vrrrxMbG1uC0Vc8Fy5c4M033+TWW2+lXbt23HTTTbz44oucOnXKZazOffGKj4/n3//+N3fccQcdOnSgb9++TJ8+HZPJ5DJW575kffTRR7Ru3ZotW7a49OncF6+JEyfSunVrt7fnnnvOaazOvRS3kvr+k5Knz4eVR17v5YIFC3L9GX3kkUdcxuu9LH363aFyyO/7WB5/Jit8QfRXXnmFnTt38umnn7J161batGnD/v372bp1K82bN+fVV18FoFmzZowYMYKvv/6a/v3707NnT44ePcr69evp3Lmz2zdAik9KSgrjx48nOTnZbf9XX33FJ598QuvWrRkyZAjh4eHMmjWLPXv2MHv2bKcK/z///DMvvPACDRs25LHHHuPMmTMsXryYbdu28dNPPxEcHFxaL6vcunDhAg8//DBnzpzhpptuom/fvhw/fpyff/6ZP//8k/nz59OkSRNA5764JScnM3jwYI4ePUrPnj3p3bs3O3fu5OOPP2b79u18+eWXGAwGQOe+pO3du5dvv/3WbZ/OffE7cuQIPj4+jBo1yqWvZcuWjvs691ISSuL7T0qePh9WHld6L48cOQLAU089ha+vr1Nf3bp1nR7rvSx9+t2hcijI+1gufyatlcDZs2etr732mvWmm26yXnvttdaePXtaP/zwQ2tiYqLTOIvFYv3++++tffv2tbZr187as2dP6/vvv+8yTopXTEyM9YEHHrC2atXK2qpVK+vMmTNd+tu2bWt97LHHrJmZmY72Tz/91NqqVSvr999/72hLTk62du3a1XrHHXdYk5KSHO0LFiywtmrVyvrhhx+W+OupCN58801rq1atrDNmzHBqX7JkibVVq1bW0aNHW61WnfuS8Mknn7j9Pn/++eetrVq1sq5bt85qtercl7SMjAzrvffe6/h3Z/PmzY4+nfuS0bNnT2v//v3zHKNzLyWluL//pOTp82HlcaX30mq1WocMGWLt0qXLFefSe1k29LtD5ZDf99FqLZ8/kxV6W59dnTp1eP/99/nrr7/Yv38/v//+O6+88orL1fcMBgODBw9mxYoV7Nu3j99//53XXntNV+krQbNmzeLee+/l8OHD3HDDDW7HzJ8/H5PJxOjRo/H29na0jxkzhsDAQBYsWOBoW7FiBfHx8QwbNsypRthDDz1E06ZNWbx4sUv9savR2rVrqV69OsOGDXNqv//++2nUqBF//fUXFotF574EREdHU6dOHQYPHuzU3rdvXwB27doF6Pu+pE2dOpXjx49z0003ufTp3Be/5ORkYmJiaNWqVZ7jdO6lJJTE95+ULH0+rDzy814ChIeHX/FnFPRelhX97lA55Pd9hPL5M1kpklNSfs2ePZvQ0FC+//577r//frdjtm3bBsD111/v1O7r60vHjh05dOiQY4mwfWzXrl1d5unatStxcXFEREQU50uocKxWK6NGjWLcuHF4eLj+iPv6+mI0GjEajTr3JeB///sfGzZscPoPGyAyMhKAmjVrAvq+L0mHDx9m2rRpjBw5ktatW7v069wXv8OHDwPO26fc0bmXklAS339SsvT5sPLIz3t59uxZ4uPjr/gzCnovy4J+d6gcCvI+ltefSSWnpES9/fbbLFmyhM6dO+c6Jioqipo1axIQEODSFxoaCmT9Ym8v5NawYUOXsQ0aNADg+PHjRY67IjMYDAwdOtRl5Q7YzmNkZCSNGjXC19dX576EWa1WYmNjmTNnDp999hn169fnvvvuA/R9X1LMZjOvv/46DRs25JlnnnE7Rue++NnrFsTFxTFixAi6dOlCly5dGD9+PMeOHXOM07mXklAS339SsvT5sPLIz3tp/xk1m82MHTuWG2+8kU6dOvHkk0+ye/dup7F6L0uffneoHAryPpbXn0klp6RE3XLLLXh6euY5Jj4+PtetlfZ2ewY+Li4OHx8f/Pz8XMbalxnqr57uWSwW3nvvPcxms+MCADr3JWvSpEl0796dd955h6CgIL755huqVq0K6NyXlG+++YaDBw/y3nvv5VrYWOe++Nk/5MyaNYuAgAAefvhhOnTowK+//srDDz/MgQMHAJ17KRkl8f0nJUufDyuP/LyX9p/R+fPnk56ezoABA7j55pvZtGkTQ4YM4Y8//nCM1XtZfuh3h8rB3ftYXn8mK/zV+qTiM5lMuf4SaW/PyMgo8FjJYrVaeeutt9i4cSPXXnutYx+yzn3JCg0NZcSIEURHR/Pbb78xePBgpk+fzrXXXqtzXwKOHz/OlClTGDRoEGFhYbmO07kvfp6enoSGhvLBBx/QrVs3R/uyZct46aWXeP3111m6dKnOvZSIkvj+k7Knfy8qD4vFQmhoKM8++6xjBTnA1q1bGT58OG+88QZr167F19dX72U5od8dKofc3sfy+jOp5JSUOT8/P4xGo9u+zMxMAPz9/Qs8VmzMZjP//Oc/+emnnwgNDeWLL75w/EOic1+yHn74Ycf9DRs2MGrUKF555RWWL1+uc1/MrFYrb7zxBtWrV+f555/Pc6zOffH717/+5bb9vvvu48cff2Tbtm1ERkbq3EuJKInvPyl7+vei8hgzZgxjxoxxae/atSv9+vVjyZIlbN26lVtuuUXvZTmg3x0qh7zex/L6M6ltfVLmgoODSUpKcttnb7cvEw0ODiYjI8Pxg5CdfTmhrr6YJT09nbFjx/LTTz/RuHFjvvvuO+rWrevo17kvPT169ODmm28mIiKCqKgonftiNmfOHHbs2MHbb7/tdCURd3TuS1fbtm0B25Usde6ltBX2+0/Knv69uDpk/xkFvZdlTb87VA5Xeh/zUpY/k0pOSZlr0qQJsbGxpKenu/TFxMTg4eFB48aNHWMh64clO3tb06ZNSy7YCiQxMZFhw4axbt062rZty9y5cx2FCu107ouXyWRi8+bN/P33327769evD9j2buvcF6/Vq1cDMGrUKFq3bu24zZgxA4ChQ4fSunVroqOjde6LmclkYu/evezZs8dtv/08+/r66txLsSup7z8pe/r3ovI4cOCA44pfOdm3A/n6+gJ6L8uSfneoHPLzPpbXn0klp6TMhYWFYbFY2L59u1N7RkYGu3fvpkWLFo6VEPY6Mu5+mLZs2UJQUBDNmzcv+aDLuYyMDEaNGsXu3bvp2rUr3333HTVr1nQZp3Nf/EaNGsULL7yA2Wx26Tt8+DAGg4EGDRro3BezBx54gHHjxrncOnXq5NQfHBysc1/MLBYLgwYN4qmnnnL5vrdarezatQsvLy+uueYanXspdiX1/SdlT/9eVB7jxo1j6NChXLp0yaVvx44dALRr1w7Qe1lW9LtD5ZDf97G8/kwqOSVlrl+/fnh6ejJlyhSn5YJTp04lOTmZgQMHOtp69+5NQEAA06dPJz4+3tG+cOFCTpw4wcMPP4yHh76tP/30U3bt2kWnTp34+uuvc/2wrXNfvLy8vLjjjju4dOkS33zzjVPf3Llz2bNnD7fddhs1a9bUuS9mAwYMYPz48S637Mmp8ePHExwcrHNfzHx8fOjVqxcJCQlMmzbNqW/GjBmEh4dz77336txLiSip7z8pe/r3ovK4++67sVgsTJw4EavV6mhftWoV69evp0uXLrRq1QrQe1lW9LtD5ZDf97G8/kwarNmjESlBixYt4rXXXuO1115j+PDhTn3//e9/+frrr2nevDk9e/bk6NGjrF+/ns6dO/Ptt986XSFg3rx5vPXWW9SrV48+ffpw7tw5Vq1aRaNGjZg/fz4hISGl+8LKmQsXLtCzZ0+MRiMPPvgg9erVcztu1KhR+Pr66twXs3PnzvHoo49y+vRpbr75Zlq1asWhQ4fYtGkTDRo0YO7cudSpUwfQ931p+Oijj5gxYwazZ892uoqXzn3xiomJYeDAgVy4cIHu3bvTpk0b9u/fz9atW2nevDlz5syhWrVqgM69FL+S+v6T0qHPh5VHbu9lYmIijz76KMeOHeO6664jLCyM48ePs379emrWrMm8efNo2LChY7zey9Kl3x0qh4K8jxkZGeXyZ1LJKSk1eX34sFqtzJ07l7lz5xIVFUWtWrW44447GDdunNsCaytXrmT69OkcPXqUqlWrcvPNN/Pcc89Ru3btUno15ddvv/3G2LFjrzhu27ZtBAcH69yXgNjYWCZNmsTvv/9OXFwctWvX5o477uDpp592/IIE+r4vDbklp3Tui9+5c+eYNGkSGzZsID4+ntq1a3PXXXfxzDPPOJ1TnXspCSX1/SclT58PK4+83svExESmTJnCmjVruHDhAiEhIdx2221MmDDB7fuj97L06HeHyqGg72N5/JlUckpERERERERERMqMNnmKiIiIiIiIiEiZUXJKRERERERERETKjJJTIiIiIiIiIiJSZpScEhERERERERGRMqPklIiIiIiIiIiIlBklp0REREREREREpMwoOSUiIiIiIiIiImVGySkRERERERERESkzSk6JXCWio6Np3bo1jz/+eFmHUuwyMzOZNWvWFcfZz4H9Zj8XixYtcmq33zp16kTfvn2ZOHEiKSkpxR53ft+Txx9/nNatWxMdHe3UbjQamT17NgMHDuT666+nQ4cO3H777bz22mscOXLEZZ7PPvvM5TW2adOGjh07cuedd/Lmm29y/PhxtzHab/fff3/RX7iIiEgFkNvng9atW9O+fXtuueUWxo4dy+7du4t0HIvFwrx580hNTS2ewCu4LVu20Lp1a/79738X67zr1q2jdevWfPbZZ3mOy+3zYnn16quvOsX722+/lXVIIoXiVdYBiIgU1eOPP86xY8cYPnx4vsY3bdqUe+65h9DQUKf2rl270rVrV8D2QTElJYX9+/czdepUNm3axPfff4+Pj09xh18oqampDB8+nD179tC+fXv69euHv78/J0+eZNmyZSxdupQPPvjAbTLp9ttv55prrgFsrzM5OZnw8HB+/PFHli5dyqRJk7jtttsACA4OZty4cQBMmTKl1F6fiIhIeZH984FdYmIie/fu5bfffmP9+vV8++23XH/99YWa/8UXX2TFihXcc889xRFuhRcaGsq4ceO47rrryjSO3D4vlje9e/cmNDSUrVu3snXr1rIOR6TQlJwSkQrvwoULBRrfrFkzxo8f79LetWtXt+3vvfce3333HcuWLeOhhx4qdJzF6ZtvvmHPnj28/PLLPPnkk059ERERPProo/zzn//k5ptvpkaNGk79vXv3ZsCAAS5z/vnnnzzzzDM899xzLFmyhMaNGxMcHOw4J0pOiYjI1Si3zwcAkydP5vPPP+fjjz9m/vz5hZq/oJ9jKrsGDRrker5LU26fF8ub3r1707t3bz777DMlp6RC07Y+EZErsCdytm3bVsaRZFm3bh1eXl4MHTrUpa9ly5YMHjyYjIwM1q9fn+85b7nlFp599llSU1P54osvijFaERGRymnMmDF4e3uze/du0tLSyjocEZEKS8kpkauYfU/9F198wcqVK7n//vvp0KEDvXr1YubMmQDs2LGDQYMG0bFjR3r16sVnn32GyWRyzGGvx/Dnn38yadIkbrnlFjp16sTAgQNZt26dyzFTUlKYMmUK999/P506daJ9+/bceeedfPTRR27rOv322288/vjjXH/99XTr1o0nnniC7du3O8UfExNDUlISrVu35tVXXy328+ThYfunMueWPvvxdu7cyeOPP06nTp3o0qULzz77rEt9qOJmMpkwmUycOHHCbf8jjzzC559/zo033ligeQcPHoyfnx+//vorRqOxGCIVERGpvHx8fAgMDARsNTCz27RpE0888QRhYWF07NiRgQMH8ssvvziNad26tWO1S5cuXRz1jex1hA4dOuRyzJw1IO01JTdu3MiAAQNo164dd911FykpKTz++OP06tWLs2fP8sILL9CtWzeuu+46Bg8ezJYtW674+uyftSZOnMiKFSvo27cvHTp04K677mLGjBlYLBaX5xw4cIBnnnmGbt260aFDB+6//37mzZuH1Wp1eR2vvvoqU6ZMISwsjOuvv55Zs2blWnPq6NGjPPfcc9x4442O1/jpp5+6rdW1bds2hg0bRlhYGN27d+eDDz4gPT39iq83N0uWLHGch5zS0tLo1KkTQ4YMcbRlZmby1Vdf0bdvX9q3b8+NN97ICy+8wKlTp1yef+nSJT766CP69OnDddddx3XXXcc999zDF1984fYz98qVKxk6dCjt2rWjZ8+ebucUqYiUnBIRVq9ezcsvv0zLli0ZOHAgKSkpfPjhh7z33nsMHz6catWq8dhjj2G1WpkyZQpz5sxxmWPixIl888039OjRg379+nHixAmefvppfvrpJ8cYk8nEE088wZQpU6hVqxaDBg3iwQcfJD09nRkzZvDKK684zfnll18yduxYjh07xl133cU999zDgQMHGDZsGH/99ZejHlJQUBA+Pj6MGzeO3r17F/v5WbhwIQB33nmnS9+BAwcYOnQoHh4ePPbYY7Ru3ZpVq1bx5JNPunwIK0433XQTAE888QTTpk1zSVI1aNCA3r17U79+/QLN6+fnxzXXXENqaqrbD8QiIiKSZf/+/cTFxVG3bl2qVq3qaF+wYAFPPPEE4eHh9O3bl0cffZTY2Fj+8Y9/MHXqVMe4cePGOWoaPfXUUzzwwAOFjuWll14iICCAxx9/nK5duxIQEADY/jA4aNAgDh8+TP/+/enduzc7d+7kySefzHdiY8OGDbzwwgs0atSIRx99FICPPvqI119/3WncH3/8waOPPsrmzZvp1asXQ4YMwWq18tZbb/Hmm2+6nXfmzJk88MAD3HzzzbnWmdq+fTsPPvggq1evJiwsjEGDBhEQEMCXX37JkCFDnBJUf/zxB0888QT79u3jzjvvpE+fPixdurRIBdbvvPNOqlSpwooVK1z61q5dS2pqqiNhaDQaeeqpp/jkk08ICgpiyJAh9OjRgzVr1vDQQw8RHh7ueG5SUhKPPPIIs2fPpkWLFgwdOpR7772XCxcuMGnSJD7++GOX47333nskJSUxdOhQ2rdvT8OGDQv9ukTKE9WcEhEOHz7M559/7kjs3HrrrTz55JN89913vPnmmwwePBiAQYMG0bt3b5YvX86wYcNc5pg7dy4dO3YEbB+wHnroIT788EPuuOMOgoODWb16NXv27GHMmDE899xzjue++OKL3H333fz++++kpaXh7+9PZGQkU6ZMoXnz5syePZuaNWsCMGTIEAYMGMDHH3/M0qVLGT9+PIsXLyYxMbHIdQG2bt3qdAWX1NRU9u7dy44dOxgzZgy33HKLy3PCw8N56aWXGDlyJABWq5WRI0fy119/sXnz5gKvXMqvsWPHsn37dvbu3cv//vc//ve//1G7dm26du1Kjx496N27t+NDaUHVqVMHUA0MERERd6xWK4mJiezYscOR8Bg7dqyj/+zZs7zzzjs0b96cOXPmEBISAsBzzz3HE088waRJk7j99ttp2bIl48ePZ+vWrcTExDBq1CiCg4MLHVe9evX49ttvHSu+7eLj4wkLC2PSpEl4e3sDthIAEydOZNGiRfzjH/+44twHDx50qnP53HPPMWLECBYvXswDDzxAt27dSEtL49VXXyU4OJgFCxY4/kD24osv8vzzz/Pjjz/Su3dvbr31Vse8sbGxfPnll/Tq1cvRlnNFl8lk4rXXXsNsNjN9+nS6d+8O2C7q8s477zBv3jwmT57Mq6++itls5u2338bb25sffviBVq1aATBy5EgefPDBgp5ShypVqnDHHXewdOlS9uzZ45REW7ZsGb6+vtx9990AfPvtt2zevJnRo0fz/PPPO8YNHTqUgQMH8sYbb7BgwQIA5s2bx6lTp3j33Xd55JFHHGPHjx/PnXfeyYoVK3jttdecYvH29mbu3Ln4+/sX+vWIlEdaOSUihIaGOq046ty5M2D7j9j+1zGAhg0bUrNmTU6fPu0yR9++fR2JKfvYxx9/nMTEREfdo7Zt2/Lee++5JLYCAwNp164dZrOZhIQEAH755RdMJhNjx451JKbAVpzy1Vdf5YEHHnBa6lwctm7dypQpUxy3GTNmsH37dnx9fTEajW5rSfj5+TnVfTIYDI4kVm5b7opDYGAgc+fO5fXXX3dcee/8+fP8/PPPvPzyy9x+++2sXLmyUHPbty+622YpIiJytZkyZQqtW7d23Nq0aUPXrl15+umniY+P56WXXnJKLCxbtozMzEwmTJjgSEwB+Pr6Mm7cOCwWC4sWLSr2OO+44w6XxJTdiBEjHIkpwJEgyu9nldDQUKfPb/7+/o4/NC5fvhyA33//nUuXLvHkk086rdz28PBwjM2+oh5sn6OyJ6vc2bVrF1FRUdx7772OxJR93hdffJGqVauyaNEirFYru3fvJiYmhgceeMCRmAJb4i6/V3XOTf/+/QH4+eefHW2XLl1i48aN9OzZk6CgIMC24j44OJgJEyY4Pf/aa6/l7rvvZu/evURERABw88038/bbb7usmKtbty6NGzfm0qVLLnH06NFDiSmplLRySkRo3Lix0+MqVaoAtv8YPT09nfp8fX1JTEx0mSPnJZYB2rdvD9hWVd133300bdqUpk2bkpGRwZ49ezh+/DgnTpzg4MGDjr+Smc1mAI4cOQJAhw4dXObNnjArTuPGjXNafZWWlkZ0dDQzh8BAiQAADNVJREFUZszgm2++Yf/+/Xz77bcYDAbHmPr167vUorJ/OMlZeyKn3D5A5ne8t7c3w4YNY9iwYZw/f54tW7bw999/8/vvvxMXF8cLL7xAUFCQ2xVfebEnpQq78kpERKQy6dq1q+NzTmpqKitXruTs2bPcd999vPvuu/j5+TmN379/PwB///230xYu+/PB9tmouDVo0CDXviZNmjg9zq1OVm46deqEl5fzr472z2j212J/3fv373daiW7n6enp8rrdfdbMyf6csLAwl77AwEBH3a7Tp087xrZr187tayiKG264gbp167Jq1Spee+01PDw8WLVqFSaTybGlLyUlhePHj1OrVi2+/PJLlzkuXrwIwKFDh2jZsiVt27albdu2pKSksGfPHk6cOMGJEyfYt28fkZGRjs/F2eX1PotUZEpOiUiuf33JmXTJi30rWHa1atUCIDk5GbAtv/7qq6+YOXOmY4VUzZo16dSpEw0bNiQiIsJRp8meALN/eCoL/v7+tGzZkvfff5+jR4+yZcsWNm7cyM033+wY4+4c2ZNXV6o5ZX9tVyo8bi/gmde5qF27Nv369aNfv36kpaXx0UcfMW/ePKZNm1bg5FRMTAygDz8iIiJgS05l/+PVuHHjGD16NMuWLaNq1ar83//9n9P4pKQkAH744Ydc57R/DipOOZNk2eX8vJLfzyp27j7n+fn5ERgY6Hi99q/u6jLZ5XzdecVsZ/8cmdvnoNq1awO2z0v2GNz9gS17TbDC8PDwoF+/fnz99dds2bKFG2+8kWXLllGtWjXHZy17rBcuXGDKlCm5zmU/DxkZGXzyySfMnz/fsUK/Xr16hIWFUaNGDc6dO+fyXF9f3yK9DpHySskpESkW7q6AYv+AYF/SPmPGDD799FO6du3KyJEjad++PdWrVwdg9OjRjiXOkLV6KyUlhWrVqrkcy8fHp8ArjwrLYDDQtWtX9u7dy+HDh52SU0URFBSEt7c3sbGxeY47f/483t7ejg9lmzZt4vXXX2fgwIGMGTPGZby/vz9vvPEGS5cu5fjx4wWKKSEhgaNHjxIcHEyLFi0K9FwREZGrQUBAAJ9++in3338/3333Ha1atXLa1mf/DPPbb78Vulh1bskjdyUGSkNGRoZLm8lkIj093fE5zf66Z82aVaw1N+2JpvPnz7vtt/9BMyQkxFGzy/4ZNLsrfd7KjwceeICvv/6aVatW0bhxY3bv3s3gwYMdWybt5+D66693ewGhnD788EPmzp3LHXfcwZAhQ7j22msdK/Dvvfdet8kpkcpKNadEpFjs3bvXpW3Xrl1A1rLv5cuX/3979x5Tdf3Hcfx5DjLNNA0kbAdTxKZFpjkvzbxMQY2kg0uz6Ryy6chmNNqUpuOPvAFSIsbByxQKVlTaEsZinDxGB7wkutZo0NokVNAspx6PU9TgnN8fjG+eYJpCnp/6evwF53w5n8/3/MN7r+/n8/4QEBDAtm3bmDp1qhFMeb1e6uvrjZ8Bo09AZ5+7Zs0aRo0adU+Pzm1/wtVeMHQHk8nEyJEjaWpq4uzZs51ec/r0ac6ePctzzz1nhHEhISGcOXMGu91+2zE6e9J5K19++SUtLS3ExMTcdpm9iIjIw2rAgAG8//77AKSnpxurjgFGjBgB/L3N7WYnTpxg48aNfPfdd7f8/Paw4+ZT6ABOnjzZlWnftc7qsZqaGlpaWow2Du33XVtb2+Fal8vFhg0bKC4uvuOx23tr/vjjjx3eu3HjBjU1NQQHB/P4448b2/k6u7auru6Ox/6niIgIIiMjqaiooKKiAsDY0gdtdaLFYuH48eOdBnrFxcXk5OQYNWxpaSnBwcHk5OTw4osvGnXmtWvXaGpqAv796jaR+53CKRHpFrt37zYCJmgrngoKCggJCeGll14C2pZut7a2dmjuuHXrVuOfdHuT89jYWMxmM9u3b+fixYvGtadOncJutzNo0CDjaWSPHj26vTn6zRobGykvLycwMJApU6Z062fHxcXh8XhITU3tsPrsr7/+IiMjA4B58+YZrw8bNowJEyZQV1fH2rVrOxQ/Ho+H7Oxsrl69ymuvvfav53L48GFyc3Pp3bs3b775ZhfuSkRE5ME3Y8YMZs6cydWrV1mzZo3xutVqJSAggOzsbKPHELTVOOvWrSM/P9+nFmrv5XRzLTN06FAAIwCBv9sj+ENNTY3Pdr0rV67w4YcfYjabjUbhM2bMoE+fPuzcubNDiPbBBx9QWFh4V+HamDFjGDRoEHa7nQMHDhivezweMjMzcblcWK1WzGYzI0eOZNiwYZSWlvoEVH/88Qcff/zxHY/dmTlz5vDnn3+Sl5fHkCFDfE7ug7bVVS6Xi6ysLJ9g6fjx46xdu5b8/HxjV0GvXr24fv26Tz/X1tZWNmzYYKySu137B5EHhbb1iUi3MJvNzJ8/n5dffhmv18u3337LtWvXsNlsRk8rq9XKTz/9xIIFC4iJiSEwMJAjR45QW1tLcHAw58+fx+VyAW1Ppt5++20++ugj4uLimDZtGl6vl7KyMm7cuEF6eroxdmhoKCdPniQlJYWJEycaRdKdqq6u9mng6fF4aGxsxOFw0NzcTHJyMk8++eRdf0edmT9/PlVVVTgcDqKjo5k2bRpBQUFcuHCBqqoqfv/9d1599dUOIdOmTZuIj4/ns88+w263M3nyZEJDQ7l06RKHDx/mxIkTxMTEsGDBgg5jOhwO4wmv1+vl8uXL1NXVcezYMXr16sXmzZuxWCzdep8iIiIPotTUVA4dOoTT6eSbb75h9uzZDB48mJSUFNLT05k9ezZRUVE89thjVFZWUl9fz5QpU3xW2wwcOBCA1atXM3HiROLj44mNjWXLli3k5eXR2NhIWFgYBw8exO12+5yEd6/069ePFStWUF5eTmhoKE6nk1OnTrFs2TIiIyOBtlVD69evZ8WKFcTFxREdHc0TTzxBdXU1P//8M5GRkSxZsuSOxw4ICCAjI4OlS5eSmJjI9OnTsVgsHD16lNraWp599lnjZDyTyURaWhoJCQksXryYWbNm8eijj7Jv375uO+glNjaWzMxMTp8+3eFEPoDExESqqqr45JNPOHr0KOPGjcPtdlNeXk5zczMZGRnGCimr1UpeXh5z584lOjqalpYWDhw4QENDg1EPulwuo6+WyINM4ZSIdItly5Zx6dIldu/ezfXr1xk9ejRJSUmMHj3auGbhwoUAFBUVsWfPHvr27Ut4eDhZWVn07NmT5cuX43Q6jdNUli9fTnh4OAUFBZSUlGAymXjhhRd45513fJ5SrVy5ktWrV1NWVsa5c+e6FE5VV1cbv/fo0YP+/fszbtw43njjDaKjo+/qc2/FbDZjs9koLi6muLiYiooKXC4X/fv35+mnnyYlJYVXXnmlw9+FhIRQUlLCF198wb59+6isrMTtdtOnTx+eeeYZkpKSiI2N7XTM/fv3s3//fuP3Rx55BIvFwqJFi1i8eDFPPfVUt9+niIjIgyg0NJR3332XdevWkZaWxqRJk+jXrx8JCQmEh4eTn5+P3W7H4/EQFhbGe++959OjCNpqqPr6eiOUiI+PZ8CAARQWFpKVlUVlZSWBgYFMnjyZlJQUv6xuHjt2rBGYVVZWEhERQWZmpk/IBhATE8PAgQPZsWMHVVVVNDc3Y7FYeOutt1iyZMldH3QzduxY9uzZQ25uLj/88ANOp5OwsDCSkpJYunSpT2P1UaNG8fnnn5Odnc3333+PyWRi5syZzJkzh0WLFnXpewAICgpi/PjxHDx4EKvV2uH9nj17UlhYyK5duygrK6OoqIi+ffsyZswYEhMTmTBhgnFtcnIyvXv3prS0lKKiIoKCgoiIiCA1NZX6+nrS0tJwOp28/vrrXZ63yP87k1ebWEWkC77++mtWrVrFqlWrSEhI8Pd0bqmpqYmoqCiioqLYunWrv6dz3xk+fDgjRoygpKTE31MRERGRe+BhrJ1ud8+tra1MnTqVIUOG8Omnn/phhp3LycnBZrORm5v7nzxQFfmvqeeUiIiIiIiIyL/w1Vdfce7cOa1mEulm2tYnIg+d3377jZycHCwWyx01DH8Yud1uCgoK/D0NERERkXvqn/VicnIyv/76Kw0NDQwdOrTTtgv+4HA4+OWXX3xaU4jcjxROichDp6GhAZvNxvjx4xVO3Ybb7cZms/l7GiIiIiL31D/rxeDgYM6cOcPzzz/Pxo0bffqG+ZPD4WDv3r3+noZIl6nnlIiIiIiIiIiI+I16TomIiIiIiIiIiN8onBIREREREREREb9ROCUiIiIiIiIiIn6jcEpERERERERERPxG4ZSIiIiIiIiIiPiNwikREREREREREfEbhVMiIiIiIiIiIuI3CqdERERERERERMRvFE6JiIiIiIiIiIjf/A9XWhxY/M191gAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -1643,24 +1604,7 @@ "start_time": "2023-08-03T11:58:21.452246Z" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", - " npdtype = np.dtype(dtype)\n", - "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", - " npdtype = np.dtype(dtype)\n", - "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", - " npdtype = np.dtype(dtype)\n", - "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", - " npdtype = np.dtype(dtype)\n", - "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", - " npdtype = np.dtype(dtype)\n" - ] - } - ], + "outputs": [], "source": [ "output_imp = calc_imp.sensitivity(output_imp)" ] @@ -1685,7 +1629,7 @@ { "data": { "text/plain": [ - "['aai_agg', 'freq_curve', 'tot_value']" + "['aai_agg', 'freq_curve']" ] }, "execution_count": 33, @@ -1837,7 +1781,6 @@ " rp50\n", " rp100\n", " rp250\n", - " tot_value\n", " \n", " \n", " \n", @@ -1850,7 +1793,6 @@ " 0.000993\n", " 0.000930\n", " 0.001150\n", - " 1.005253\n", " \n", " \n", " 1\n", @@ -1861,7 +1803,6 @@ " 0.075781\n", " 0.084662\n", " 0.093718\n", - " 0.000000\n", " \n", " \n", " 2\n", @@ -1872,7 +1813,6 @@ " 0.553640\n", " 0.596659\n", " 0.619366\n", - " 0.000000\n", " \n", " \n", " 3\n", @@ -1883,7 +1823,6 @@ " 0.014407\n", " 0.012068\n", " 0.010065\n", - " 0.000000\n", " \n", " \n", " 4\n", @@ -1894,19 +1833,18 @@ " 0.189862\n", " 0.134867\n", " 0.095861\n", - " 0.000000\n", " \n", " \n", "\n", "" ], "text/plain": [ - " si param param2 aai_agg rp50 rp100 rp250 tot_value\n", - "0 S1 x_exp None 0.001040 0.000993 0.000930 0.001150 1.005253\n", - "1 S1 G None 0.073408 0.075781 0.084662 0.093718 0.000000\n", - "2 S1 v_half None 0.514220 0.553640 0.596659 0.619366 0.000000\n", - "3 S1 vmin None 0.012642 0.014407 0.012068 0.010065 0.000000\n", - "4 S1 k None 0.213491 0.189862 0.134867 0.095861 0.000000" + " si param param2 aai_agg rp50 rp100 rp250\n", + "0 S1 x_exp None 0.001040 0.000993 0.000930 0.001150\n", + "1 S1 G None 0.073408 0.075781 0.084662 0.093718\n", + "2 S1 v_half None 0.514220 0.553640 0.596659 0.619366\n", + "3 S1 vmin None 0.012642 0.014407 0.012068 0.010065\n", + "4 S1 k None 0.213491 0.189862 0.134867 0.095861" ] }, "execution_count": 35, @@ -1991,24 +1929,16 @@ " None\n", " 0.619366\n", " \n", - " \n", - " 4\n", - " tot_value\n", - " x_exp\n", - " None\n", - " 1.005253\n", - " \n", " \n", "\n", "" ], "text/plain": [ - " metric param param2 si\n", - "0 aai_agg v_half None 0.514220\n", - "1 rp50 v_half None 0.553640\n", - "2 rp100 v_half None 0.596659\n", - "3 rp250 v_half None 0.619366\n", - "4 tot_value x_exp None 1.005253" + " metric param param2 si\n", + "0 aai_agg v_half None 0.514220\n", + "1 rp50 v_half None 0.553640\n", + "2 rp100 v_half None 0.596659\n", + "3 rp250 v_half None 0.619366" ] }, "execution_count": 36, @@ -2041,9 +1971,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -2074,9 +2004,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -2106,7 +2036,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2123,7 +2053,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### A few non-default parameters" + "\n", + "### A few non-default parameters\n" ] }, { @@ -2142,15 +2073,7 @@ "start_time": "2023-08-03T11:58:24.430789Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-03 13:58:25,948 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 1000\n" - ] - } - ], + "outputs": [], "source": [ "# Sampling method \"latin\" hypercube instead of `saltelli`.\n", "from climada.engine.unsequa import CalcImpact\n", @@ -2171,7 +2094,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2199,16 +2122,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2023-08-03 13:58:29,176 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 1000\n", - "2023-08-03 13:58:29,183 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", - "2023-08-03 13:58:29,186 - climada.engine.impact_calc - INFO - Calculating impact for 250 assets (>0) and 216 events.\n", - "2023-08-03 13:58:29,187 - climada.engine.impact_calc - INFO - cover and/or deductible columns detected, going to calculate insured impact\n", - "2023-08-03 13:58:29,199 - climada.engine.impact - WARNING - The Impact.tot_value attribute is deprecated.Use Exposures.affected_total_value to calculate the affected total exposure value based on a specific hazard intensity threshold\n", - "2023-08-03 13:58:29,200 - climada.engine.unsequa.calc_base - INFO - \n", - "\n", - "Estimated computaion time: 0:00:05.650000\n", - "\n", - "Time passed with pool: 9.783061027526855\n" + "Time passed with pool: 2.8349649906158447\n" ] } ], @@ -2257,16 +2171,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2023-08-03 13:58:40,759 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 1000\n", - "2023-08-03 13:58:40,770 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for TC\n", - "2023-08-03 13:58:40,773 - climada.engine.impact_calc - INFO - Calculating impact for 250 assets (>0) and 216 events.\n", - "2023-08-03 13:58:40,775 - climada.engine.impact_calc - INFO - cover and/or deductible columns detected, going to calculate insured impact\n", - "2023-08-03 13:58:40,787 - climada.engine.impact - WARNING - The Impact.tot_value attribute is deprecated.Use Exposures.affected_total_value to calculate the affected total exposure value based on a specific hazard intensity threshold\n", - "2023-08-03 13:58:40,788 - climada.engine.unsequa.calc_base - INFO - \n", - "\n", - "Estimated computaion time: 0:00:26.300000\n", - "\n", - "Time passed without pool: 12.707012176513672\n" + "Time passed without pool: 8.287853956222534\n" ] } ], @@ -2290,16 +2195,7 @@ "start_time": "2023-08-03T11:58:53.473025Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-03 13:58:53,476 - climada.engine.impact_calc - INFO - Calculating impact for 250 assets (>0) and 216 events.\n", - "2023-08-03 13:58:53,478 - climada.engine.impact_calc - INFO - cover and/or deductible columns detected, going to calculate insured impact\n" - ] - } - ], + "outputs": [], "source": [ "# Add the original value of the impacts (without uncertainty) to the uncertainty plot\n", "from climada.engine import ImpactCalc\n", @@ -2322,7 +2218,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKoAAAMWCAYAAADRT26TAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hU1dbA4d+kd0INkEBCEsBIqKF3KVIEpYggvYiCEBQEUURFBBTkghIRpBdBQanSCU0ivYUWWiCVmpDey3x/5MtImEmbJDMp630enwtn73NmnVwgK+vss7ZCqVQqEUIIIYQQQgghhBBCzwz0HYAQQgghhBBCCCGEECCFKiGEEEIIIYQQQghRTEihSgghhBBCCCGEEEIUC1KoEkIIIYQQQgghhBDFghSqhBBCCCGEEEIIIUSxIIUqIYQQQgghhBBCCFEsSKFKCCGEEEIIIYQQQhQLUqgSQgghhBBCCCGEEMWCkb4DKImaNm1KcnIylStX1ncoQgghhCgEz549w8TEhAsXLug7lDJJcishhBCidClIbiWFKi0kJSWRlpam7zCEEEIIUUhSU1NRKpX6DqPMktxKCCGEKF0KkltJoUoLVapUAeDIkSN6jkQIIYQQhaFz5876DqFMk9xKCCGEKF0KkltJoUqIEqj7b915GveUKpZVODD0gL7DEUIIIYQoUSSXEkKI4ksKVUKUQNefXic0JhR7a3t9hyKEEEIIUeJILiWEEMWX7PonRAlkYmii+k8IIYQQQuSP5FJCCFF8yYoqIUqg+x/d13cIQgghhBAlluRSQghRfMmKKiGEEEIIIYQQQghRLEihSgghhBBCCCGEEEIUC1KoEkIIIYQQQgghhBDFgvSoEqIEWnFxBbHJsViZWPG+x/v6DkcIIYQQokSRXEoIIYovKVQJUQLNPjFbtaWyJFdCCCGEEPkjuZQQQhRf8uqfEEIIIYQQQgghhCgWZEWVECXQ8l7LSUhJwNzYXN+hCCGEEEKUOJJLCSFE8SWFKiFKoF51euk7BCGEEEKIEktyKSGEKL6kUCWEEELoQVBQEGFhYQW6RqVKlahZs2YhRSSEEEIIUbZJflY8SKFKCCGE0LGgoCDc3NyIj48v0HUsLCzw8/OTZEgIIYQQooAkPys+pFAlRAkUHh9OujIdA4UBFS0q6jscIUQ+hYWFER8fz+SvFuHg6KrVNUIC77F49hTCwsIkERJCiHySXEoI8TLJz4oPKVQJUQI1XN5QtaVyyJQQfYcjhNCSg6MrLnXd9R2GEEKUOZJLCSGyI/mZ/hnoOwAhhBBCCCGEEEIIIUBWVAlRInV16Up4fLgsVRdCCCGE0ILkUkIIUXxJoUqIQhIfH8+aNWvYt28fwcHB2Nra0rhxY8aOHUv9+vXzda1r166xatUqLl68SGRkJNbW1nh4ePD+++/ToEED1r61Nsv8mJgYVq5cibe3NyEhIRgaGuLs7Ey/fv149913MTCQxZNCCCGEKNmWLl3KkiVLOHToEI6OjhrnBAcH4+Xlxfnz5wkPD8fe3p4+ffowevRojI2NVfNezqU08fX1ZcWKFVy8eJHY2FiqVq1K9+7dGT9+PJaWlqp5nTp1IjQ0NNfrfffdd/Tr1y8PdyqEEGWbFKqEKARRUVEMGzaM27dvY2pqSqNGjTAyMuLkyZMcOXKEWbNmMWDAgDxda9++fUybNo3U1FTq1KlDo0aNCAwM5PDhwxw7dowFCxbwxhtvqOaHh4czePBgAgICqFChAi1btiQhIYGrV68ye/Zs/v33X7y8vDA0NCyq2xdCCCGEKFLHjh1j2bJlOc65d+8egwcPJioqigYNGuDu7s6FCxdYtGgRZ8+eZcWKFRgZ5e3Hn507d/L555+jVCpp3Lgx5cqV4/Lly6xcuZILFy6wYcMGTExMAOjSpQvPnz/XeJ3w8HBOnTqFsbExrq7aNWcWQoiyRgpVQhSCefPmcfv2bVxcXPjll19wcnICIDQ0lA8++IBZs2ZRv359XnnllRyvExkZyZdffklqairz58+nT58+qrEdO3bw2WefMXPmTFq1akWFChWAjKdzAQEBdO7cmR9++EH1hC84OJjRo0dz5MgRtmzZwuDBg4vk3oUQQgghitKff/7J7NmzSUlJyXHe9OnTiYqKYtasWbz77rsAxMbGMm7cOP79919+//13hg0bluvnBQQE8NVXX2FmZsbSpUtp3bo1kPFg8oMPPuDy5cts3ryZkSNHAjBjxgyN10lPT2fEiBGq2Bo0aJDXWxZCiDJN3gcSooDi4uLYu3cvAD/88IOqSAVgb2/Pt99+S2pqKl5eXrle69ChQ8TGxtKtW7csRSqAvn378tprrxEfH8/Ro0dVn33w4EFMTEyYO3dulmXoNWrUYOrUqQCq+IQQQgghSor79+8zfvx4Zs6ciaWlZZY852Vnzpzh+vXrNGzYUFWkArCysmLevHkoFArWr1+fp89dvXo1SUlJTJ48WVWkAihXrhxTp06lSpUq+Pv753qdX3/9lXPnztG2bds8FciEEEJkkBVVotiIiopiw4YNHDt2jMDAQJKSkrC1taVJkya89957NGjQAH9/f3r27Em1atU4duwYCoUiyzWSk5Np27Yt8fHxnDx5kvLlywNw584dli5dquox4ObmxoQJE7h69So//fRTlp4Bee0z0LdvX77//nv8/f1JSUmhevXq1KtXT21eo0aNMDc3599//yUtLS3HV/BSU1OpV68ebdq00TieWQRbemwpKxNXYp1ojbu7O1ZWVqp71TT/yZMnud6PEEIIIUqXkppbZfr66685d+4cbdq0Yc6cOQwdOpS4uDiN5544cQLIeA3vZTVr1qRu3brcunULf39/XFxcGLJ9CGHxYVSyqMSmfptUc5VKJYcOHcLCwoJBgwapXatp06acPHky13t5+PAhy5cvx9TUlFmzZuU6XwghxH+kUCWKhfDwcAYNGkRQUBA1a9akZcuWpKSkcOPGDQ4ePMjRo0f5/fffqV+/PvXq1ePGjRtcunQJDw+PLNf5559/iIqKokuXLqpE6sKFC4wdO5b4+Hjq1atHkyZNuHLlCmPHjtVYWMqpz8CLGjduDGQkNJDxxE4ThUKBgYEBcXFxPHz4kBo1amR7zcGDB+f4it61a9cAeJDygED/QOyt7Qn5PSTX+VWrVs35ZoQQQghRqpTk3CqTu7s7o0aNolOnTrmee+fOHQDq1KmjcdzV1ZVbt26pWjWcCDhBaEwo9tb2WeaFhIQQGRlJ48aNMTEx4datWxw8eJAnT55QvXp1evXqlWX1fHYWLlxIYmIiH3zwQY65nxBCCHVSqBLFwrJlywgKCmLYsGF88cUXqqd5SUlJfPzxxxw9epQtW7ZQv359+vTpw40bN9i3b59aMpX5ittbb70FZDwF/Pzzz4mPj+frr79WFYGSkpKYPn06+/fvV4sluz4D2XF0dMTAwIAHDx4QFhZGpUqVsozfunVL9fQvIiJC62TFx8eHCxcuYGpqSlzNOEjLeX5SUhLLly8H4PXXX9fqM4UQQghRMpXk3CrT9OnT8zz32bNnAFSuXFnjeObxsLCwHK8TGBgIQJUqVVi0aBErVqxQPZQEWL58OZ9//jlDhgzJ9hr+/v7s27cPCwsLRo8ened7EEIIkUEKVcXFhUVwcVHu86o0gb67sx7b8SY8vZT7uR5ToOmU/36fHANr3fIWX59dYOeR+zwt2djY0K5dOyZNmpRlybmpqSn9+/fn6NGjhIRkrBzq1asX8+fP58CBA8yYMUP1Kl1cXBzHjh2jXLlydOzYEchYBh4UFET79u2zrFQyNTVl7ty5nDp1iqioqALFbmtrS8eOHTl69ChTp05l0aJFqkbnT58+5YsvvlDNTU5O1uozAgMDVcnaBx98wPD3hqNEiQKFxvlpaWlMnz6d4OBgXFxcNC5dF0IIIUq1kpZb+e+BiDtZr1cAJTm30kZ8fDwAZmZmGsdNTU2zzPOb4Kcxl4qJiQHg9OnTHDlyhIkTJ9K/f3+MjY3Zt28fP/zwA99++y01a9akXbt2Gj9r7dq1KJVKBgwYgK2tbWHcnhBClClSqCoukqMhNvd397HWsBon4Vnezk2Ozvp7pTJv5wGkaVdgyatJkyapHYuJieH27dv4+PgA/xV5KlSoQLt27Th27Bjnzp2jVatWABw5coSEhATeeust1XbBp06dAqBz585q17e0tKRdu3bs2bOnwPHPmjWL27dvc/r0aV5//XUaNmyIUqnkypUrVK1alZYtW3LmzJk8b4n8In9/f0aPHk1YWBivvfYa48ePx8Ag+30QUlJSVE80bW1t8fLyUn09hBBCiDKjpOVWqQnq1yuAkp5b5Vdmce3lHlsvy1wdZW1qrXE882sSHR3NxIkTmThxomps+PDhpKWl8f333+Pl5aWxUBUZGcnu3bsxMDBg1KhRWt2LEEKUdVKoKi5MbMDKPvd55hqWM5tXztu5JjZZf69Q5O08AMOiL3QEBwezefNmLl++TEBAABEREcB/CceLy67feustjh07xt69e1XJVGZSlLk0HeDRo0cAVKtWTeNnVq9eXe2YNg0/7ezs+Ouvv/jll1/w9vbm7NmzVK1alaFDh/LBBx/g6ekJZDzdzI/z588zceJEIiMj6dixIz/99FOORaro6Gg++ugjTp06RYUKFVi9ejUuLi75+kwhhBCiVChpuZWRufr1Cqgk51b5ZWFhAWS8gqhJ5nFzc/Mcr/PiuKbX+wYNGsT8+fO5evUqcXFxajsRHjlyhKSkJFq0aJHt10gIIUTOpFBVXDSdov1S75eXq+eViTV8kH0jbl3as2cP06dPJzU1FUdHR1q0aIGrqyvu7u6kp6fz4YcfZpnfuXNnbGxsOHz4MF9//TWxsbGcOnWKmjVr0qRJE9W8lJQUIGsi9iJNx7Vt+FmhQgVmzpzJzJkz1eb6+/tjYGCQr6bmO3fuZObMmaSkpNC3b1/mzJmT44qskJAQ3n//ffz9/XFwcGDVqlXUqlUrz58nhBBClColLbdy6aXdedkoDblVflSpUoWbN2/y7Nkz3NzUX7/M7GFVpUqVHK+T2b7BwsJC9esXmZubU6FCBcLDw4mOjlYrVB0+fBiAnj17anUfQgghpFAlioG4uDi++uorAH755Re1peSZ3/BfZGJiQvfu3dm6dSunT5/m0aNHpKSkZHniB//tdpf59O9ljx8/VjumTcPP69evExYWpurf8KKAgAAeP35M7dq1VU/7crNy5UoWLlwIwMSJE1UrsjJt99tOfEo8FsYW9HPrx507dxg1ahRhYWE0aNCAZcuWqTV1F0IIIUTZUBpyq/yqU6cOx48fx9/fn/bt26uN3717VzUP1HOpTLVr1wYyelnFxMRgbZ31FcGUlBRVD66XC1nJycmqVyO7du1aSHcmhBBlT/bvEAmhI3fv3iUuLo7atWtr7HeQ2Ufh5Sd0mYnTkSNHOHDgAABvvvlmljktWrQA4Pjx42rXTUpKUiUTBTVnzhw++OADVRL0oj/++AOAHj165OlamzdvZuHChRgaGjJv3jy1IhXApP2TGLZjGJP2TyIkJERVpHrttdfYsGGDFKmEEEKIMqw05Fb5lVmc8vb2VhsLCgrizp072Nvb4+rqCmTNpV5Urlw51cquzB0PX3Tq1ClSU1OpX7++qkF7ptu3b5OUlISTkxMVK1YslPsSQoiySApVQu8yn0Y9ePCA+/fvq44rlUp+//13tm7dCqj3HGjatCk1atTg8OHDnD9/niZNmlCzZs0sc15//XWqVq3K8ePH2bZtm+p4amoqs2fPJjw8HMi98WZuOnXqBMDChQuz7Ox34MABNmzYgK2tLSNGjMhyzsOHD/H398+yFP7u3bvMmzcPgG+++Yb+/fvn+tnTpk0jLCyMli1b4uXllWvvBSGEEEKUbqUht8ovDw8P6taty4ULF9iwYYPqeGxsLDNmzECpVDJ69Ogs5xgkG6CIUBAUFJTleOa8RYsWcfXqVdXx4OBg5s6dC8CwYcPUYrh+/ToA9evXL5ybEkKIMkpe/RN6V7NmTTp16sTRo0fp06cPzZs3x9TUlJs3b/Lw4UNcXV25d+8eYWFhaue++eabLF26FEBtaTpkbFH8/fffM3bsWGbMmMHmzZtxcHDg2rVrPHnyhOrVq/Pw4UOtduN70ciRIzlw4ADHjx+nW7duuLu7Exoayo0bN7CwsGDp0qVYWVllOWf69OmcO3cuy6t9v/zyCykpKVhaWnL27FnOnj2r8fOGug6lRtsaPL75mK2XMpJNIyMjPv/8c43zbW1tNfbOEkIIIUTpUxpyq/wyMDDgu+++Y9iwYcydO5edO3fi4ODAhQsXCA8Pp2PHjgwaNEg1f06nOZz3Po/3Sm9G/juSo0ePqsZef/11Ro8ezZo1axg4cCBNmzbFxMSES5cuER8fT9++fTV+bUJCMvqT1aihYSdJIYQQeSYrqkSxsHjxYiZNmoSDgwPnz5/nypUrVK5cmU8++YTt27dTp04dnj59qnpSlalPnz4AGBsbZ/tqXatWrfjjjz947bXXCAoK4tixY1StWpW1a9dSr149ALX+A/llYmLCunXrGDZsGOnp6Rw7doyoqCjefvttdu7cSdOmTfN0nXPnzgEZvSX+/vvvbP+zS7BjQvMJlAsrpzrXx8cn2/mHDh0q0P0JIYQQomQp6bmVNurVq8dff/1Fz549efjwISdOnKBixYp8+umneHl5ZSmejWw0ks7O6q9FZpo+fTpLly6lefPm3Lx5k0uXLuHi4sLcuXOz3Zkwc5V8fjbPEUIIoU6hzG7LDpGtzHf9jxw5oudIRG7Cw8OJjIzE3t4eMzMztfE333yT27dvs2/fPlxcXPQQoRCiLLp06RIeHh78b/VuXOq6a3UN/9vX+WTMm1y8eDHLjlxCO/K9Xb/k619ySG4lhCitJD8rXAX53l5iVlQlJCTg5eVF9+7dcXd3p0WLFowZM4YTJ05ofc27d+8ybdo02rVrh7u7Oy1btuSDDz7g9OnThRi50Kfbt2/Ts2dPxowZk6V3FMCff/7J7du3cXFxkURKCCGEECIPJLcSQghR1EpEj6r4+HhGjhyJr68vxsbG1K5dm8jISHx8fPDx8cHT05OJEyfm65onTpzA09OTpKQkzM3NcXFx4fHjxxw/fpzjx48zZcoUPvjggyK6I6ErzZs3p379+ly4cIEOHTrQsGFDjI2N8ff3x9/fHxsbG+bPn6/vMIUQQgghSgTJrYQQQhS1ErGiavbs2fj6+uLm5sbhw4fZsWMHx44dY/78+RgZGeHl5ZWvrXCjo6P59NNPSUpKolu3bpw8eZJdu3Zx6tQpJkyYAGTs8nHhwoWiuiWhI0ZGRqxfv57p06dTrVo1Ll++zIkTJ0hOTmbIkCHs3LmzRO7M4rDIAcU3ChwWOeg7FCGEEEKUIaUlt5JcSgghiq9iv6IqKCiI3bt3Y2BgwMKFC6lWrZpqrE+fPjx48IDly5fj5eVF69at83TNY8eOERkZqXriY25uDoChoSGTJk3i3LlznD9/nm3btuW5CbYoviwtLRk9erTalsRCCCGEECL/JLcSQghRlIr9iqpdu3aRlpZGo0aNcHV1VRsfPHgwkNH47OHDh3m65uPHj4GMrXszi1QvynwK9OjRI23DFqJINanWhJYOLWlSrWw36BNCCCGE0IbkUkIIUXwV+xVVV65cAcDDw0PjuJ2dHfb29oSGhnLu3DnVlro5yVyVFRgYSHx8PBYWFlnGb9++DYC9vb32gQtRhHa/u1vfIQghhBBClFiSSwkhRPFV7FdUBQYGAhmrn7KTWVAKCAjI0zW7dOlClSpViImJYcaMGcTGxgKgVCpZs2YN//77L8bGxgwdOrRgwQshhBBCCCGEEEKIPCv2K6rCw8MBqFChQrZzbG1tAYiIiMjTNS0sLFi3bh3Tpk1j//79nDhxAkdHR54+fUp4eDhOTk7MmjULNze3AscvhBBCCCGEEEIIIfKm2K+oSkxMBMDExCTbOaamplnm5oWZmRmNGjXC0NCQ+Ph4/Pz8shTFFApFAaIWQgghhBBCCCGEEPlV7FdUGRoakp6enmPhSKlUAmBgkLe6261btxg1ahTPnz+nZ8+efPjhh6oVVX/88QerV69m9OjRLFiwgF69ehXKfQhRmDz3eRKRGEF5s/J49fTSdzhCCCGEECWK5FJCCFF8FfsVVZmNzpOSkrKdk5ycDPy3sio3s2fP5vnz53To0IHFixdTu3ZtTExMcHBwYOrUqXz66aekpaUxa9YsoqOjC34TQhSyHbd2sOnaJnbc2qHvUIQQQgghShzJpYQQovgq9oWq8uXLAxAZGZntnMzeVBUrVsz1es+ePePixYsATJw4UeOc4cOHY2trS0xMDCdOnMhnxEIIIYQQQgghhBBCG8X+1T9nZ2cCAgIICQnJdk5oaCgATk5OuV7v4cOHWa6tiaGhIbVq1eLy5cs5fq4Q+nJy1EnSlGkYKgz1HYoQQgghRIkjuZQQQhRfxb5Q1bBhQ44ePcqVK1c0jj958kRVfGrcuHGu17OyslL9+unTp1l+/6LMxurZjQuhT7XK19J3CEKIUiIoKIiwsDCtz69UqRI1a9YsxIiEriQkJLBq1Sr27t1LSEgIlpaWuLu7M3z4cDp06KDVNe/evcuKFSs4c+YMERERWFlZ0bBhQ0aOHEmrVq0K+Q6E0J7kUkIIUXwV+0JV9+7dWbx4MefOneP+/ftqq6A2b94MQPPmzXFwcMj1es7OzlSpUoWnT5+ydetWPvvsM7U5586dIygoCICWLVsWwl0IXfrss8/YsWMHc+bMYcCAATr//KtXr7J8+XIuXrxIXFwclStXpl27dkyYMAE7O7s8XycmJoaVK1fi7e1NSEgIhoaGODs7069fP959912Nmwf4+fnx888/4+vrS2xsLE5OTgwcOJBBgwbJTpZCCDVBQUG4ubkRHx+v9TUsLCzw8/OTYlUJEx8fz8iRI/H19cXY2JjatWsTGRmJj48PPj4+eHp6ZtsiITsnTpzA09OTpKQkzM3NcXFx4fHjxxw/fpzjx48zZcoUPvjggyK6I1GU9J1bHTt2jHXr1nH9+nWUSiUuLi6888479OvXD0PDvK+I+v7771m7dm2247NmzeLdd9/Ncmznzp38/vvv3LlzB2NjY+rUqcOQIUPo0aOH1vcjhBAiZ8W+UOXk5ESvXr3Ys2cPnp6e/PLLLzg6OgKwa9cuVq1aBcD48ePVzg0KCiIlJQVra2uqVKkCgEKhYOLEiXz11VesX7+eihUrMmLECExMTAA4e/YsU6ZMAeCNN96gdu3aurhNUUocO3aMiRMnkpqaSr169ahevTo3b95ky5YteHt7s3nz5jy9ohoeHs7gwYMJCAigQoUKtGzZkoSEBK5evcrs2bP5999/8fLyypKcnT17lvfee4+UlBSaNWuGtbU1Z86cYdasWVy9epXvvvuuCO9cCFEShYWFER8fz+SvFuHg6Jrv80MC77F49hTCwsKkUFXCzJ49G19fX9zc3Fi2bBnVqlUDMn4o/+KLL/Dy8qJJkya0bt06T9eLjo7m008/JSkpiW7dujF37lysra1JS0tj6dKlLF26lEWLFuHh4UHTpk2L8tZEKfPjjz+ybNkyAFxdXalZsya3b99m5syZeHt789NPP2FmZpana924cQPIeBBubGysNv5ijqZUKvnss8/YuXMnAPXq1aNKlSpcu3aNjz/+GB8fH7799ts87zouhBAi74p9oQpg5syZ3Llzhzt37tCjRw/q1KlDdHS0qjfV5MmTNSZSI0eOJDQ0lL59+/L999+rjg8cOJCgoCBWrVrFwoUL+fXXX3F0dCQiIkJ1zZYtWzJnzhzd3KAoVFOmTGHs2LGq4qSupKam8uWXX5KWlsbChQvp3bu36vjs2bPZsmUL8+bNY8WKFble67vvviMgIIDOnTvzww8/YGlpCUBwcDCjR4/myJEjfP3z13R5qwsdnTqSnJzM1KlTSU1NZfny5XTs2BHIeL11xIgRbN++na5du9KpU6ciu38hRMnl4OiKS113fYchdCQoKIjdu3djYGDAwoULVUUqgD59+vDgwQOWL1+Ol5dXngtVx44dIzIyEhsbG+bPn4+5uTmQ0fdz0qRJnDt3jvPnz7Nt2zYpVJVA+sqtzpw5w7JlyzAwMGDevHn07dsXyMitFixYwPr161myZAmffvppnq5369YtbGxs+OmnnzgecJyk1CRMjUzp6NRRbe727dvZuXMnFhYW/PTTT7Rv3x7IeGV2xowZ/PXXX7z66qsMGTKk0O5XCCFEhhLxCKB8+fJs2bKFiRMn4uTkhL+/PxERETRv3pwlS5Ywbty4fF9z2rRpbNiwgW7dumFmZsatW7eIjY2lefPmzJs3jzVr1mBhYVEEdyOKWpUqVXBxccHa2lqnn3v79m2ePXuGs7OzqkgFYGRkxMcffwxkvFaam7i4OA4ePIiJiQlz585VFakAatSowdSpUwFY/+d6hm4fCsDff//N06dP6d69u6pIBRlfi6+//hqAdevWFfAOhRBClAa7du0iLS2NRo0a4eqqvpJu8ODBAFy6dCnLJjQ5efz4MQA1a9ZUFaleVL9+fQAePXqkbdhCj/SVW23duhWAIUOGqIpUkJFbTZ8+HVdXVzZs2MDz589zvVZwcDDR0dHUq1cPgKHbh9J9U3dVLpXdZ3/00UeqIhWAubk53377LeXLl8fLy4vU1FSt708IIYRmJWJFFWT0wPD09MTT0zPP5xw9ejTH8RYtWtCiRYuChiYK0a5du9iyZQu3bt0iNTUVR0dHevbsyciRI1WJb0hICJ07d6Zz58707t2bBQsWEB4ejqOjI3/88Qfffvutxj4K8fHxrFmzhr///ptHjx5RuXJl+vbty1tvvUWXLl1o3rw5GzduBMDLy4uff/45TzHfvn0bQLX0+/nz5yQnJ6teJwVUjYrLlSuX6/WeP3+Ou7s7VlZWlC9fXm08c1m6UYIRKaQAGX1BALp27ao2v3nz5pQrV44LFy4QFxeXpfAlhBCi7MncoMbDw0PjuJ2dHfb29oSGhnLu3Dn69OmT6zUzV2UFBgYSHx+v9rAv83ulvb299oELrZTk3Crzf7t06aI2x9DQkKZNm3Lv3j1Onz7NG2+8keM1b968CaAqVOU1hs6dO6uNWVlZ4e7uzsmTJ7l+/TqNGjXK0zWFEELkTYkpVInSLT09nWnTprFnzx5MTExo3rw55ubmnD9/nh9//JGDBw+ydu3aLIWbO3fuMHXqVNzc3HB1dUWpVGZbhElISGD06NFcvnyZihUr0qFDB54+fYqXlxf//POP2vy6detmWRWVF66urlSrVo1Hjx7x8ccfM3XqVKpXr86NGzeYNWsWAKNHj871OjVq1OD333/PdvzatWsA2Fezp1+rfkDG1wLQ2FPNwMAAZ2dnLl++jL+/Pw0aNMjXfQkhhChdAgMDAXLsK5ZZqAoICMjTNbt06aLarGbGjBnMmTMHKysrlEola9eu5d9//8XY2JihQzWvXhGFrzTkVunp6UD2u3AbGWX8KOPv75/rtTILVcbGxnzyySfYnbLDJsaGclXLsbHyRoYMGZKl31R+PlsKVUIIUbikUCWKhd9++409e/ZQo0YN1qxZo0qeY2Nj+eSTTzh+/DhfffUVXl5eqnOCg4MZPHiw6tW2zIRCk19//ZXLly/TunVrfv75Z1XSdeDAAVXz/Be9/vrrvP766/m6B2NjY7y8vPD09OTIkSMcOXJENWZlZcX//vc/evXqla9rviwpKYnly5cD8P477zO81XAAnj17BkDlypU1npd5PHOeEEKIsis8PByAChUqZDvH1tYWgIiIiDxd08LCgnXr1jFt2jT279/PiRMncHR05OnTp4SHh+Pk5MSsWbNwc3MrcPwib0pDblWrVi3u37/P+fPncXfP2kdPqVRy6dIlgDy9+pfZSD1z84BWHq14+vQpN2/eZM6cOZw+fTrLRjW1atXi1q1bnD9/Xi3upKQkrl+/nufPFkIIkT9F0qMqMTGRo0eP4u3tTWRkZFF8RKmz6PQiHBY54LDIgeMBx7OMPYh4oBrz3Kf+6uObv7+pGn/ZuivrVGPb/bZnGYtJilGNDdmu3ghy1K5RqvHw+PCC3WAu1q9fD8CcOXOyPOG1srJi4cKFWFtbc+jQIdVT4EwjR45U/Tq7XVfS0tL4/fffMTIy4vvvv8/yZLB79+7079+/0O7D0dGRt956C0NDQ+rVq0enTp2oVq0asbGxrFmzhuDgYK2vnZaWxvTp0wkODsbFxYVBgwapxjK3ltfUFwTA1NQ0yzwhhBAlS2HmVomJiQBZXlF/Web3jcy5eWFmZkajRo0wNDQkPj4ePz+/LEUxhUJRgKjzr6TlVnvu7GHR6UVa3KlmpSG3yuxL5eXlxfnz51XH09PTWbJkiWqVVHJycq7X8vPzA2DChAkcOXKEn3/+ma1bt/Lnn39SvXp1jhw5ovqavfjZc+fOVb0GmPlZ33zzjerhX14+WwihG0FBQVy6dEnr/zL/nRD6V6AVVU+ePGHZsmVUr16d999/H8hY/jpq1CjVP97m5ubMmTOHnj17FjzaUiw6KZrQmIwdB5NSk7KMpSnTVGMRiepPNp/FP1ONvywuOU41Fp+StUihRKkaC4sPUzs3PD5cNZ6uzP6JWkE9evSIkJAQypcvT8uWLdXGra2tadeuHfv27ePcuXO0atUKyEiIHR0dc73+jRs3iIyMpFGjRtjZ2amNd+vWTdUwsyAiIyMZOnQowcHB/Prrr7Rr1w7I2Jnmxx9/ZOXKlYwaNYp9+/bl+MOBJikpKUyfPp39+/dja2uLl5dXlmsYGhqSnp6e7Q8BSqUyy/8KIYQonnSRW+X2PQP++36RXaHiZbdu3WLUqFE8f/6cnj178uGHH6pWVP3xxx+sXr2a0aNHs2DBggKvLs6rkpZbJaQkEJ0Unet95UVpya26du3KO++8w9atWxk2bBju7u7Y2dlx+/ZtHj9+zMCBA9myZYvqNbycHDp0iMePH+Pi4pLluJubG1988QUTJkzgt99+U7VpGDp0KP/++y///PMP/fr1o0GDBpQrV44bN24QGxtLnz592LlzJ8bGxgW+TyFEwQUFBeHm5iYP5ksJrQtVz58/55133uHp06dZdhn76quvePr0KQqFAktLS2JjY/n000+pW7eu2jcG8R8bUxvsrTMajJoamWYZM1QYqsbKm6k3165sUVk1/jJLE0vVmIVx1samChSqsUoWldTOrWhRUTVuoCi6DSKfPn0K5Nxg1cEh44nmi6+u5XXnmcwdhl7cfvtF1atXVzumTcPPtWvXcvfuXTw9PVVFKsjoYTB16lQuX77MhQsX2LdvX54a02aKjo7mo48+4tSpU1SoUIHVq1er/V2ysLAgKiqKxMREjUWwzKd9spOlECVDfFwK1y8/4/aN5wTciyI2JpmkhDQsrIypam+Jo7MNVavLU/zSRle5Veb3jKSkpGznZH7fyFxZlZvZs2fz/PlzOnTowOLFi1XHHRwcmDp1KhUrVuT7779n1qxZtG/fHhsbm3zHnV8lLbcyNzbHxrRwvi6lJbcC+Pbbb2ncuDGbNm3izp07BAcH07RpU5YsWYK/vz9btmzJ02Y1lpaW2f596dChA4aGhoSGhhIREUH58uUxMjJi2bJlbNy4kW3btnHt2jVsbGxo27Ytnp6e7N27F0Anf5aFELkLCwsjPj6eyV8twsFRfUfbvLh45jibVxbeylahPa0LVevXr+fJkyc4OjoycOBAIKM558WLFzE0NGTTpk00atSIRYsWsWLFCtatW8e3335baIGXNlNaTWFKK/X3+QFqla9FyJSQbM/d/e7ubMdGNhrJyEYjNY5Zm1rneN21b63NdqwwZT61zcuT3ReLMHl9ypu5bXB2fRY0rTLSpuHnmTNnAGjbtq3G8Q4dOnDhwgX8/PzyXKgKCQnh/fffx9/fHwcHB1atWkWtWrVosKwBj2IfUc2qGlfHX6VKlSpERUXx7NkzjQlTbj2shBDFw03fMA7ufsDp46EkJ6VlO+c/k9i//zGNGikxMNDta1Wi8OkqtypfvjxRUVE5vkKY2ZuqYsWKuV7v2bNnXLx4EYCJEydqnDN8+HCWL19OZGQkJ06cyPf3WG2UtNyqV53CW2lWWnKrTP369aNfv35qxw8dOgRoLozl5uVcqly5cjx//jzL665GRkaMGjWKUaNGqZ2f2cBdm88WQhQdB0dXXOq65z5Rg5DA3DdmELqhdaHqn3/+wcjIiNWrV6ueyBw/fhyAJk2aqHa/8PT05I8//lD9EC/Ey6pUqQJkFGWyk9nbqVIl9aeTuclckv748WON40+ePFE7pk3Dz6ioKABVE86XZSZ/mcldbu7cucOoUaMICwujQYMGLFu2THX/zxOeExYfhqlhxhPiOnXqcPfuXfz9/dWeFqanp3P//n0MDQ1lVaMQxdSdG8/ZtPIGvhee5vPMGsyceZO//grDy6sTbduq99MRJYeucitnZ2cCAgJy/L4bGprxepqTk1Ou13v48GGWa2tiaGhIrVq1uHz5co6fKwpHacmtHj9+jL+/P87OzhpXb2X+HXi50frL7t69y6pVq7C2tmbmzJlA1lwqLi6O58+fY2xsrCrOBgUFERgYSP369VWbC2RSKpWcPXsWhUJBvXr18nVPQgghcqf1+1zBwcE4OTmpEimAU6dOoVAoaN26teqYsbExDg4OqiXIQrysevXq2NvbExERwblz59TGY2Ji8PHxAaBZs2b5vr67uzuWlpbcuHFD4653R48ezX/QGmQm5ydOnNA4furUKQBeeeWVXK8VEhKiKlK99tprbNiwIUsi6WTrhEt5F5xsnQBo3749AN7e3mrXOnv2LFFRUXh4eGS7xbIQQj8S4tNYOv8in35wTIsi1X+uXHlKhw5bmDPnNGlpRddTUBQtXeVWDRs2BODKlSsax588eaIqPjVu3DjX6734vSWnmDIbq8v3oqJXWnKrEydOMHr0aDZs2KA2duvWLa5cuYKjo2OuhSozMzN27tzJ5s2bVfG+mEvt3LkTgObNm6tWmP3111+89957qlf8XnTs2DGePHlCixYt8rTqUAghRP5oXahKS0vLslQ4NTVVtRtH8+bNs8xNSEjQ+U4vomQZMWIEADNnzsyyM15cXBzTpk0jNjaW1157LcdeC9kxMzNj4MCBpKamMmPGDBISElRjJ0+e5I8//ij4DYBqF75Vq1Zx+vRp1XGlUsny5cv5999/qVSpEj169FCNxcTE4O/vT1BQUJZrTZs2jbCwMFq2bImXl5fabn4+o324N+kePqMzksyuXbtSuXJl9uzZo1oGDxmvY2S+FpLZHFSIkq6gO7pcunRJ7e+cfrgyf+YDDv8dUChXS09X8uWX/9Kr13bi4qR/VUmkq9yqe/fuAJw7d4779++rjW/evFn1mS8WzbLj7OysWsGTXQPtc+fOqf7eaWruLQpfacit2rVrh7GxMVu2bFG9agcZxdSpU6eiVCrx9PTM8ndBU25Vo0YN2rRpQ1paGp999hmxsbGqXOqXpr/w008/oVAo+PDDD1XndOrUCYCVK1dmKcbdu3ePr7/+GoBJkyYVyn0KIYTISutX/+zt7QkNDSUlJQVjY2POnz9PfHw8VlZWqqXpkPGNJDg4mBo1ahRGvKKUGjZsGJcvX2b//v288cYbNGvWDHNzcy5cuEBERASvvPIK8+bN0/r6EyZM4PTp0/zzzz906dIFDw8PwsPDuXjxIjVq1CAoKKjAu7a0b9+ecePGsXz5ckaOHEmDBg1UO9MEBQVhZWXFTz/9lOVJ8uHDh/n888+xt7dXPX38559/uHTpEpDRG+Hzzz/X+Hm2traq5euWlpbMnTuXCRMmMGnSJJo0aUL58uU5c+YMsbGxDBw4kNdee61A9ydEcVBYO7pYWFjg5+eXZct2XUlPV7Jq1QNgLDFRmvtQvcjC0ojqNawxMTUkMjyRxw9jyaYtDAAHDgTQrds29u3rh41N3hphi+JBV7mVk5MTvXr1Ys+ePXh6evLLL7+odnrbtWsXq1atAmD8+PFq5wYFBZGSkoK1tbWqOKVQKJg4cSJfffUV69evp2LFiowYMUJVdDt79ixTpmT0inrjjTeoXbu2VnGL/CkNuVX16tX55JNP+P777+nbty/NmzfHwMCAs2fPkpiYyIgRI9T6XmnKrQDmzJnD0KFD8fHxoWvXrjRq1IjY2FguXrxIWloan3/+OU2bNlXNb9SoEcOGDWPjxo306NGDpk2bkpiYyPnz50lNTeXzzz/Hw8OjQPcnhBBCM60LVfXr12fnzp0sXLiQvn378uOPP6JQKFS7ZkDGEu9p06aRlpam2vZWCE0MDAxYvHgx7du3588//1QVahwdHXnvvfcYNmxYnnce0sTKyorffvuNpUuXcvDgQY4ePYqdnR2TJ0/GycmJSZMmFcqrCJMnT6ZJkyZs3LiRa9eu4efnR8WKFXn77bf54IMP8vRD8YtL9DOX5WtiZ2enKlRBRrP2TZs2sXTpUi5fvkxqaiq1atXi3XffpX///gW7MSGKicLY0SUk8B6LZ08hLCxM54WqiIhEBg/ew4EDAeS0qNnaxoROPR3p8HpNnFzLZWmUHh2ZxOkToWxdd53wZykaz//331C6dv2TI0fewcpKfSdQUTzpMreaOXMmd+7c4c6dO/To0YM6deoQHR2t6k01efLkLK8bZho5ciShoaH07duX77//XnV84MCBBAUFsWrVKhYuXMivv/6Ko6MjERERqmu2bNmSOXPmaB2zyJ/SkluNGjWK8uXLs2HDBs6ePYulpSUNGzZk+PDhdOnSJc/XqV69Otu3b+fXX3/F29ubkydPYmlpSdu2bRkzZgwtWrRQO2fGjBk4ODjw559/4uPjg62trWr+y6schRBCFB6FUtO2HHlw//59+vfvr9oZQ6lUYmRkxF9//cUrr7zChQsXGDlyJGlpaVhbW7N9+/Y8LR8vCTp37gzAkSNH9ByJyKtr165hb29PhQoV1MbWrVvHd999x9ixY5k6daoeohNC5NWlS5fw8PDgf6t3a72ji//t63wy5k0uXrxIkyZNCjnC7D1+HMfrr//JtWth2c4xNTOk35C69H7HFQvLnFci3L5xjekf/Iih4RukpWn+Vt67tws7dryFoaHmolhBv576+loWheLwvV3XuVV8fDyrV69m//79BAcHY2RkhLu7O0OHDqVbt24az+nUqZPGQlWms2fPsmnTJi5dukRERASWlpbUrVuXPn360KdPn2w3HCkOX3+RP5JbCSGKk8LIEU8c2sXi2ZNLZJ5ZHBXke7vWK6qcnZ1Zs2YN3333Hbdv38bR0ZFp06apGkVXqVKF1NRU6tSpw+LFi0tNkUqUTBMmTCAsLIwdO3ZQt25d1fHg4GDWrl2LQqHI11M5ffvm+DdEJUVRzrQcX3f8Wt/hCCFyERAQRZcuf+LvH5ntnMbN7Rg3rTF21SzzdE0jIwVwjC++GMbPP0fz/Ln66qq///ZnxIg/mTJF86tWfn5+efosoRu6zq0sLCzw9PTE09Mzz+fk1iS7RYsWGlemiNKnpOdWkksJIYpSQXOsSpUq6aVFRXGhdaEKMnaCya5ppoODAzt37szTDmdCFLUxY8Ywb948+vXrR+PGjalYsSLPnz/n8uXLpKSkMG7cuCz9P4q7lZdWEhoTir21vSRXQhRzt26F07XrX4SExGgcNzBUMPwDd956t3a+mmNHhD9DYWDA7NmjgcrA+4Ct2rxNm4LZtOk7wFeb8IWOSW4lSoqSnltJLiWEgIyWClfOPyXofhRXL6UB77HGK5TKdgk4uZbjlfoVqf1KeQyN8rYPXWZ+NnTo0ALFpc9+qsVBgQpVOTEwMJBEShQbI0aMwNnZmc2bN+Pn58eVK1ewsbGhVatWDBkyhI4dO+o7RCFEKXT58hO6dfuLZ88SNI7b2BoxfW4b6jWslO9rx8VGo0xPV/XrCnuajNe8IGJj1Bu0m5kP55NZTlSolPV1wotnjrN55aJ8f7bQD8mtRHEiuZUQoqRKSU7D50gIh/5+wO3r4S9tUlOXG1digVg4mHGkfEUzur1Vi+59nLGtYJbjtV/Oz7Shz36qxUWhFKpOnjzJsWPHuH//PjExMWzbto3o6Gg2bNjA4MGDNb67LoSutWvXjnbt2uk7jEKxa9AuktOSMTGUJslCFFc+PiG88cZ2oqOTs5nxhI++aKVVkepFDo6uuNR1x6UulPvBkS8n/UNKctZtARMT0tn+WxRzvNpneSIYEuj/8uVEMSG5lSgJSnJuJbmUEGVPSko6B3b4s33THSLCE/N8XkR4In+s8WPH5ju8O+ZVeg9wzXWFVWZ+JrRToEJVeHg4H3/8MRcuXAAymn5mvrbw8OFDfv75ZzZu3MiKFSto2LBhwaMVQgDgUV22QxaiODt48AF9++4iISFV43jdulbcvj0L2wrtC/VzX3GvyITpHvz47Xm1Mb9r4fz95z36vFunUD9TFC7JrYTQDcmlhChbLp15zMofr/AoJE7rayQlprFu6TVOegczdXYLqtkXfGdToVneXrTUIDk5mTFjxnD+/HksLS3p2rUrdnZ2/13YwABbW1uioqIYNWqUamtiIYQQojTbtu0OvXvvyLZI1batPb/+2gTQPlHKScduNXmtu+Zl4r+vvsmzx/FF8rmi4CS3EkIIIQpXQnwKS+dfZPbUfwtUpHqR/+1IPn3/GDd9s9/JWRSM1oWqTZs2cevWLRo1asShQ4dYsmQJ9vb2qvE6derg7e1N48aNSUhIYO3atYUSsBBCCFFcrVt3nXfe+ZuUlHSN4927O3Hw4NtYWxdZi0gA3p/SCLvq6rsHJiWmsfLHK0X62UJ7klsJIYQQhcfvahgfj/Dm8N8BeZpvbAzwjPIVjTAwzHmDm5ioZL76+CRn/pGHRkVB60LV3r17MTAw4Icffsi2T4KVlRULFy7E0NCQkydPah2kECKra0+ucenRJa49uabvUIQQ/++nny4yatQB0tOVGsfffrsOu3b1xcLCWON4YTK3MOajL5pqHDvn84hzPg+LPAaRf5JbCaE7kksJUbod2RvATM9/ePIo55XkNWvZMNqzAb/8/joTPjMEFjBzgQubD7zJlz+0oXnbatmem5qSzsKvz+F74WkhRy+0fqR7//59XFxcqFGjRo7z7O3tcXJyIigoSNuPEkK8pMemHqotlUOmhOg7HCHKNKVSybffnubrr09lO2fUKHdWrHgdozxubVwYXm1YiS69nPDeE6A2tmHZdTxaVtVZLCJvJLcSQncklxKidFIqlWxacYM/N9zKcV6t2uUYPs6dRs3tVL0g7/r9t4rKzNwIj1ZV8WhVlRu+YSxbcImQwBi166SmpPPd56f4dkl7arvJRieFReuMOT1d82sNmhgbG2NoaKjtRwkhhBDFklKpZOrU4zkWqT7+2INVq7rptEiVafh4d2xs1Xe0CgmM4bCGApbQL8mthBBCiIIwYtPKRzkWqczMDRk3tTELV3WmcYuqqiJVTuo1rMTCVZ1o0a66xvHEhDS++/w0kRF530lQ5EzrFVX29vYEBAQQGxuLlVX23e4jIiK4e/cuTk5O2n6UEOIlIxqOIDIxElszW32HIkSZlZaWzgcfHGb16uxfG/n661Z8/XXrPCVBRcGmnCnDPnBn6fxLamO/r77J0Pc1v6Yo9ENyKyF0R3IpIUqXiIhk4H0un1Vf9ZSpXqNKeH7uQVUtduszMzfi0zktWbn4Cgd23lcbfx6WyKJZ53ith+RWhUHrx7sdOnQgJSWFH374Icd5c+bMIS0tjXbt2mn7UUKIl8ztPJelbyxlbue5+g5FiDIpMTGVgQP/zrFItWhRR2bNaqO3IlWmTj2dqFnLRu14VEQSl85KMlWcSG4lhO5ILiVE6XHnznNGjboI1Mp2zoDhr/DtkvZaFakyGRoqeH9KIzp207y78tWLzzhzIu+ro0X2tF5RNWbMGLZt28bWrVsJDw+nd+/exMRkVC/9/f25c+cOmzZt4uLFi1haWjJy5MjCilkIIYTQm6ioJPr02cnx48Eaxw0MFKxc+TqjR9fXcWSaGRoqGP6hO3Omqb+eeOlMOmCq+6CERpJbCSGEEPlz8mQIffrs5Plzza/dGRoq+PDTJnR+w6lQPs/AQMHEzz2IjEjkyjn1JurnfJSAvfqJIl+0LlRVrFiRX375hQ8//BBvb2+OHDmiGuvVqxeQ0bvDwsKCRYsWYWdnV/Bohfh/SqVS76sUhBBlz6NHsfTosQ1f32cax42NDdi06Q0GDKir48hy5tGyKvWbVObapaxxJyUCtNFLTEKd5FZCnyS3EkKUNJs23WT06IMkJ6dpHLewMuazuS1p4FGlUD/XyMiAKV81Z8roI4Q9TcgyplQCvENqqqxaLwitC1UAHh4e7N69m9WrV+Pt7c3Dh/9td12pUiU6duzI+++/T82ampfGCaENHx8fVq9ezdq1a/N8TqdOnQgNDeXQoUM4OjoW6PPT09PZvn07mzdvJiAgAGNjYzw8PJgwYQL16tXL83ViY2Np2rQpSqXmf8QqVarEv//+m+WYp6cnhw4dyvaaK1eupH379nmOQQiRd3fuPKd79208eBClcdzMzIjt29+kRw9nHUeWO4VCweD3XuXzD09oGG1PYoIsUy8uJLcS+iC5leRWQpQkedlxuUo1C778oQ01nNTbHxQGG1tTPp3TkhkfHtdQlKrOsf3h1M37P1/iJQUqVAHY2dkxY8YMZsyYQXx8PDExMVhYWGBtbV0Y8QmRxcOHDxkzZoxenyLPmjWLLVu2UK5cOVq3bk1YWBhHjhzhn3/+YcWKFbRu3TpP17l58yZKpZJatWrh7u6uNm5jo/6P6o0bNzAyMsK4rjGJqYmYGZnRxbmLarxKlcJ9WiCEyODtHciAAbuJjEzSOG5ra8ru3X1p185Bx5HlnVuDSjTwqMzViy+vBrPk9IlI6jXSR1RCE8mthC6V1dyq0/pOPIl7gvKsEiMjI3r06KHxmpJbCVG8JCen8f77h1i//ka2c+q8WoEZ37fCtoJZkcZS59UKvD38Ff5Y46c25r3nOX2HxGFXzbJIYyitClyoepGFhQUWFhaFeUkhssjP1t1F4dixY2zZsoXatWuzYcMGKlSoAMDBgweZPHkyn332GYcPH8bUNPeeLzdv3gTg3XffZcSIEbnOj46OJjQ0FDc3Ny60vUBoTCj21vYsnLKwYDclhMiWUqnkl1+u8NFHR0lL0/yEvnp1Kw4e7I+7e2UdR5d/A0e5aShUwUnvCEZ8mI6xsdZ7rIgiIrmVKGplNbe6E36HR+GPcI1yxc3NjYULJZ8SoriLiEikX79d2fYJBWjgYcUXC9pjamqok5j6D3uF0ydCCfSPznI8NVXJ+l+u8em3LXUSR2mTp0LV6dOnC+XDWrVqVSjXEUJfVq9eDcCnn36qSqQAunXrRu/evdm5cyf79++nT58+uV4rM5nK65L2GzduqObfMrmFtYk1Viba71ohhMhZfHwKEyceYe3a69nOqVu3AgcP9sfRsZwOI9NevUaVcW9cmeuXsxaroiJS+fdoSLa72IjCJ7mVEBn0lVtZmVhRPqZ8nucLIfTr/v1Ievbczu3bz3OYdYxh4z7QWZEKMvqTen7elE/fP8rLdf9Tx0K54RtGvYaVdBZPaZGnQtWoUaMK3FxRoVCovnkIocnx48fZuHEjd+7cISIigsqVK9OyZUvee+89XFxc8PLy4ueffwbgyZMn1K1bF3t7e44ePaq6xunTp1mxYgXXr19HqVTStm1bpk2bpvHz6tbNW7PjiRMn4unpSWxsLBcvXsTCwkLjEvSuXbuyc+dOjh8/nqdkys/PDwMDA9zc3PIUh59fxpLSevXqMXewbKUsRFHy8wtnwIDd3LgRnu2cFi2qsWdPXypVKlmrXfoNqaNWqALY+fsdOrxeQ5op64jkVkIXJLfK3q2Jt1izZg3zD86XQpUQxZyPTwh9++4iLCxB47ihoYLPPqvD3LnTMDAYp+PowPWV8nTpVYtDux+oja1Z4svCVZ0kv8qnPL/6l11TQl2dL0o3b29vPD09MTQ0pGnTptjY2HD37l22b9/OwYMH2bp1K3Xr1qVLly54e3tjbm5Oly5dsjx5+/PPP/nqq68AVNfw8fHhwoULJCcnq31m79698xRbZtJ179490tPTcXZ2xshI/a+Oi4sLAHfu3Mn1mklJSdy/fx97e3t27drFX3/9xYMHDzA1NaV169ZMmDBBdb1MmSuqkpOT+fDDD7l69SqxsbHUqVOHoUOH8uabb+bpfoQQ2VMqlaxYcZUpU44RH5+a7bxBg15hzZpumJsb6zC6wtG4hR01a9kQ9CDrEvWAe1FcvfiMhk2lH4uuSG4lipLkVpJbCVEarFt3nfffP0RKiubXlK2tTfjzz95UrhzBXD0+yx889lV8jgQTH5c1f/S/HcnZfx7SsoO9niIrmfJUqLp161ZRx1GmKZVK4uPj9R1GvlhYWBRqVfj777/HwMCAnTt34urqCmR8XebNm8eGDRtYu3Ytc+fO5dVXX8Xb2xsbG5ssvQQePXrEnDlzMDIyYsWKFapXIZ4/f86YMWM0PnHOby+CZ88yViBUrqy5D03m8bCwsFyvdevWLVJTUwkODmbOnDl4eHjQokULbt68yd69ezl27Bi//vorzZs3V52TeQ/fffcdTk5ONG7cmNDQUK5evcq0adO4evUqM2fOzNc9CSH+ExQUzXvvHeTw4cAc582Z05YZM1qU2CdjCoWCNwfW5ufvL6qN7f3rnhSqdERyq6JVEnMrKNz8SnIrya2EKMnS0tL57LN/WLjwQrZzatSwZu/eftSvX5lLlyJ0GJ062/JmvDPCjXW/XFMb+33NTZq3q46BQcnMHfWhUJupi/zLXEJ96lT2W2sWR23atOHkyZOFlkw9e/YMIyMjKlasqDqmUCgYN24cjo6OvPLKKzmev2PHDhITExk+fHiWfh0VKlRg3rx5eVounpu4uDgAzM3NNY6bmWXsKpGXxDgzMapZsybLly9XPeFLSUnhf//7H2vXrmXy5MkcPnwYCwsLEhISCAgIwMDAgG+++YZ33nlHda3Tp0/j6enJxo0badasGd26dSvQfQpR1qSmprNs2RVmzvQhOlp9hUAma2sT1q/vQd++tXUYXdHo8HoNfltxncjnWXcxvHDqEc+exFPZrmS9zijEi0pqbgWFm19JbiW5lRAl1fPnCQwfvp+9e+9nO6dJEzv+/rsv1asXn569b7ztwrZN14iJyno80D+aU8dCadu5+O4OXdwU2vY+AQEBHD9+nN27d/Pvv//y5MmTwrp0qVdSn8oXpmbNmpGYmEjfvn35+eefuXr1Kunp6VSsWJGhQ4fStGnTHM8/f/48AB06dFAbc3Nzw8Gh4P8oGBpmNOXL7f+vvLyKMXDgQI4fP86WLVuyLEM3Njbm008/pV69eoSFhXHw4EEgI4E7c+YMBw4c4J133uHncz/z3cnv+Pncz7Rq1QpPT08AfvvtN21vT4gy6d9/Q/Hw2MikSUdzLFI1blyFS5eGlYoiFYCxiSHd+zirHU9Ph8N/q/dXEPohuZX2JLeS3CpTdrnV6murGbh4IEMWDMlSpAIktxJCj86efUSTJhtzLFK99ZYr//wzsFgVqSAjv2rRTnOJ5Y+1N0lPl1f286rAK6r27dvHzz//zIMH6olto0aNmDJlCs2aNSvox5RaCoWCkydPlrjl6YX96t+cOXOYOHEi165dw8vLCy8vL2xtbenQoQNvv/12lmXamjx9+hSAqlWrahx3cHAgJCQky7H8NvzM3B48MTFR47zM49k9FXyRgYEB1apVy3asQ4cO3Lhxg+vXr9O3b18AypUrR7lyGTuLfe/zPaExodhb2zOx+UQ6derEvHnzuH49+93JhBAvqsLUqdc4duxorjM//LAR//tfR8zMStci5K69a7FlrR8v//x3+O8A3hnphpFRoT3LEvkkuVXBlNTcCgo3v5LcKuvYy7nVi7nUTNRf75PcSgjdUiqV/PTTJT799ES2/agAPv+8BXPmtC22r9G92lCB955woGKW4yEBMVw49YjmbavrJ7ASpkBZ99y5c/ntt99UTzmsra2xsLAgNjaWuLg4Ll++zPDhw5kxYwbDhg0rlIBLI4VCgaWlpb7D0KuqVavy119/cfHiRby9vTl16hS3b99m165d7Nq1i7FjxzJ16tRsz88tqdPUoDO/DT+rVMno25Jdn4Tc+izkR6VKGVuYJiRo3tkiu/lJSUm5zBSibHvyMI7fVz8CPuHYMfWd715kb2/FqlXd6N69lm6C07GKlc1xqavg3q2slaqI8ETOnXxI69dkebo+SG5VOCS3ktzqZZJbCVF8PX4cxwcfHGL3bv9s55iYGLJq1esMG1a8d+k0NFQA3sBAtbEdm+5IoSqPtC5UeXt7s3HjRoyMjBgzZgyDBg3K8hQjODiYzZs3s379er7//nsaNmxIgwYNCiVoUXp5eHjg4eEBQHh4ONu2bWPx4sWsXr06x4Tczs6Ou3fvEhoaqmoY+qLMp4Ivym/DT1dXVwwMDLh//z7p6ekYGGRdbXDv3j0A6tSpk+u1li9fzs2bNxk1ahSNGzdWG898Qpn5FPPcuXNs3boVZ2dnPvzwQ9a8tYbE1ETMjDJ6NwQHBwMZXwchhDr/2xHs3nIXnyMhpKUpye3N9+HDX+Wnnzpha2ummwD1pIGHeqEK4MDO+1Ko0gPJrURRkNwqw8u51efOn3Ny30mq19T8Q6PkVkIUPaVSyR9/3GLixCM8f655ZSWAnZ0FO3b0oVWrklLkuUT5ikOICM+6A6DftXD8robh1qCSnuIqObRe179x40YUCgVff/01kydPVltqW6NGDaZPn86MGTNIS0tj7dq1BQ5WlE7379+nd+/evPfee1mOV6xYkffff5+6deuSnp7OkydPsn2617p1awAOHz6sNhYcHKxKdArC3NycZs2aERMTw9mzZ9XGMz9bUy+Hlz148ICDBw/y999/q40lJiZy4MABANq2bQtAeno6f//9Nxs2bCAxMZHXXV7nzbpv8rrL60BGw9MX5wshID1dyTmfh8z0/IdPxhzlxKHg/y9SZc/NrQLe3gNYv75nqS9SAdR0VgDqK8uuXnxGaFCM7gMq4yS3EoVFcqusNOVWHlU9uHziMqf2nNL46qHkVkIUrceP4+jXbxeDB+/NsUjVsWMNrlwZUYKKVADpdHi9gsaRHZvv6DiWkknrQtXt27exs7NjwIABOc4bMmQIlSpV4uJF9W2whQBwdHQkLCwMHx8fVRKR6fr16/j7+2NpaYmzszOmpqZAxu4v6en/vbvct29fbG1t2bZtm6pJJkBsbCwzZszIMrcghgwZAsC3336rWo4OcOjQIfbs2UOVKlXo1atXlnOCgoLw9/cnJua/H/oym3Zu2bKFEydOqI4nJyfzzTff8PDhQ1q3bk2TJk2AjIaozs7ORERE8M0335Cc/F/T5+PHj7Nx40bMzMzUElIhyqKkxFQO7LzPxCGHmPfZaa5fzvkVPwArK2MWLGjPlSsj6NzZUQdRFg8ZP6Ce0Th2aLc0Vdc1ya1EYZHcSnIrIYqrlJQ0fvzxIq+8soadO7MveCsU8OWXLfH2HkDVqiXvVe7m7cphbWOidvyczyMehcTqIaKSRetX/5KTk/O024dCoaBatWrcvXtX248SpZyhoSGzZ8/G09OTjz76iHr16uHg4EBERAQXL14kLS2NL7/8EisrKywsLLCxsSE6OppBgwZRs2ZNFi5cqNoq+eOPP2bSpEk0btyYKlWqcP78edLS0qhVq5bGprT51a1bN3r37s3ff/9N9+7dadmyJREREVy6dAljY2MWLlyIiUnWf5BGjhxJaGgo3333Hf369QMyluF7enri5eXF+++/T6NGjbCzs+PKlSs8efKEWrVq8cMPP2T5Gi1atIgRI0awfft2Tp8+jbu7O8+ePePKlSsYGRkxf/58HB3Lzg/YQrwsIjyRfdv9ObDzPjFR2e/g9yJTU0MmTmzMZ581p1Ilizx/VlBQULY9VfLCz89P63ML3wWMjN4kNTXrarMTh4IYPs4dQ2mqrjOSW4nCIrmV5FZCFEeHDwfw0UdH8fN7nuO8ypXN+e23N3j9dSfdBFYETE0N6NHPma3rbqmN7d/hz2jPhnqIquTQulBVp04d/Pz8iIiIoHz58tnOS0xM5P79+9SuXTq29BZFo2vXrqxevZp169Zx7do1bt++jY2NDe3bt2fUqFG0aNECyNi1ZeHChcyfP5+bN28SHBxMVFQU5cqVo3PnzmzevJlly5Zx8eJFbt++TZMmTfjss8+YO3duoSRTAPPnz6dhw4Zs3bqVkydPYmNjQ6dOnfD09MTNzS3P15k4cSL169dX3fPNmzext7dn/PjxjB07Vq0JrJubGzt37mT58uUcPX6UY8eOYW1jTffu3Rk3bly+PluI0iTwfhS7t9zjxKEgUnPYJSarNPr3r8GPP/bGwcE6X58XFBSEm5tbidxRTLN4GjS14tKZrK/6RT5P4vK5JzRtrXkXLVH4JLcShUlyq5xzq0cxj7C2t2bFphVs37idEydOcPz4cWxsbCS3EqKQXbz4mK+/PsXevfdznTtgQB1+/rkzVaqUvFVUL+vZ34Xtm+6o5afeewMZ/F49zMxL147ShUnrr8y4ceMYN24cU6dOZenSpZiZae7lMWfOHOLj4xk1apTWQYqyoU2bNrRp0ybXeR06dMi2V0H9+vX55Zdf1I6vW7euoOGpGBoaMmzYsDzvtnT06NFsx3K6F02qV6/O7NmzWbNojWpL5TNTNL+2I0RpplQquX75GTs23+Hi6cd5Ps/cwojmba05cWgqM2YcyXeRCjJ2p4qPj2fyV4twcFRvMJwXF88cZ/PKRVqdWxSatSmnVqgCOLo/UApVOiS5lShskltlr9nKZqpcKmR2SJ5jFULk3cWLj/nmm9P8/Xf2u/llqlTJnF9+6cKAAXV1EJlu2JY3o20nB44fDMpyPD42hROHguj2lrOeIiv+tC5UVa1alaFDh/Lbb7/Rs2dPBg4cSIMGDShXrhzx8fHcvXuX7du3c/36dWrXrk18fDx//fWX2nXefvvtAt2AEEKIsiM9XQm4s2ReEEH3896MsrKdBb0GuNC1dy0ehdzmxKHIAsfi4OiKS113rc4NCcw9YdMl11csqFjFnPCnWbdtP+fziNjoZKw09FgQhU9yKyGEEKVBfgpUAIMGvcKSJZ2oXDnvbRhKip79XdQKVQD7tvvz+pu1st3QoqzTulDVp08fFAoFCoWChw8f8uOPP2qcp1QquXv3Ll9++aXGcUmmhMi/N2q/wfPE51Qw07ybhBDFlba9ndLTlRw8+ISlS28DIwi6n/3uMC+q7VaetwbVplUHe+m1lAMDAwWvdavJXxtvZzmempKOz9EQuveRJ366ILmVELojuZQQhe/SpSd8880pdu/OW4Gqfv1KLFnSiY4daxZxZPpT59UK1HYrz12/iCzHA/2juXPjOXXdK+opsuJN60JV9eolaXtIIUqXX3v/qu8QhMg37Xs71QO6AXl7BU2hgBbtqvPmwNq4NagoT6ry6LUejmqFKoCj+wKlUKUjklsJoTuSSwlRePJboCpf3ow5c9rw/vsNMSoDDxJ79nPhp7kX1I577w2QQlU2tC5U5fRuuBBCCPGy/PZ28r8dz99/PiP4Qd5WT5maGdK5pyO936lNNQergoZb5tjXtKZuvQrcvpF1J547N58TGhSDfc389/MS+SO5lRBClD0F3Um4UqVK1KypnxVJly8/4ZtvTrNr1708zbe0NGTQIAeGDKlJuXJKrl69kmVcn/dSlFp3cmDlT77Ex6ZkOe5zJIQxkxpKU3UN5CsihBAiTwqaSPn5+QG593YKexrP+l+uc9I7OE/XtbE14Y23XenR1xmbcqZaxycyVlW9XKiCjKbqwz7Qrh+XEEIIITQrjJ2ELSws8PPz02mB5/r1Z3z55b/s3Jm3AhUkAj7ExZ1k9ep4Vq/WPEsf96ILpqaGdOhag/07su56mBCfyqnjoXTq4ainyIovKVQJIYTIVWEkUrlJSU5j15a7/LXhFokJabnOt6tmwVuD6tD5DUdMzeTbWWFo28mB1Ut8SUnOuo2yj3cwQ9+vJ69RCiGEEIWooDsJhwTeY/HsKYSFhemkuHP3bgRff/0vf/xxC6Uy9/mmpgradSlP+9crYGnVEJiQ7Vxd34uudenlpFaoAvDeEyCFKg0KlNnfvn2b9evXc/PmTWJjY1Hm8KdVoVDg7e2t9WclJCSwatUq9u7dS0hICJaWlri7uzN8+PA8bUGrSXp6Otu2bWPnzp3cvXuX+Ph47O3t6dSpE+PGjaNcuXJaxytEURrw5wCexT2jsmVl/hzwp77DEWVAQRMpgItnjrN55SKNY/duRbBk3gWC7kfn4UrPGDy2Af2HtJQG6YXMysaEZq2rcep4aJbjTx7Fc9cvgjqvStPhoqbL3EqIskxyKVGcFGQn4cKQ26r5R48SWbnyAXv2PCYtLfcKlZm5Eb3eduHNQbVltfv/c65ji5NrOQLuRWU5ftM3TFosaKB1ocrX15fhw4eTnJycYxKVqSBPYePj4xk5ciS+vr4YGxtTu3ZtIiMj8fHxwcfHB09PTyZOnJjva44fP54zZ84A4OTkRPny5QkKCmLNmjUcPHiQzZs3U7VqVa3jFqKonA4+TWhMKPbW9voORZQxBUmkQgLVG2ymJKexZa0f2zffIT2XxKdSFXMaNU/Ce89CPFrulCJVEWnXtYZaoQrA50iwFKqKmC5zKyHKOsmlhMiQ86p5Y+A1oOP//zpnpqYKer9TRwpUGigUCrr0cmLVj75qY0f3BTJsnLRYeJHWhaolS5aQlJREtWrV6N+/P3Z2dhgZFc2rF7Nnz8bX1xc3NzeWLVtGtWoZOz/t3LmTL774Ai8vL5o0aULr1q3zfM1Zs2Zx5swZqlSpwtKlS2nQoAGQ8SRz0qRJBAQE8NVXX7FixYoiuSchhCjr/G9H8NOcCwQ9yHkVlbmFEQNHudGznwunT+zBe096jvNFwTRpWRVzCyMS4lOzHPc5EsLICQ0wMJDiSFHRZW4lhBBCgOZV80qlkktnY9j71zOiIlJzuQIYGaeTmnKMGfPfp2FTKbhkp33XGqxbeo3UlKy57NH9gQx+71V5CPuCAq2oMjExYfPmzarCUVEICgpi9+7dGBgYsHDhwiyf1adPHx48eMDy5cvx8vLKc6Hq6tWr7Nq1C0NDQ1atWkXdunVVY3Xr1uWbb75hxIgR/PPPPzx58gQ7O7tCvy8hCsJ/Ut62fhWiOFIqlezddo+1P6t/o35Zp56ODPvAnfIVzXQUnTA1NaRFu+ocPxiU5fjzsET8roZRr1FlPUVW+ukqtxJCSC4lxMsyV80HP4hm6YJL3LoWnus5JqaG9OzvQtXq/ixfeAAr6w91EGnJZVPOlJbtq+NzJCTL8YjwRK5dfkajZlJ3yKR1oSotLQ1XV9ciT6R27dpFWloaTZo0wdVVvS/K4MGDWb58OZcuXeLhw4dUr14912vu2LEDyCh0vVikytSiRQs+/vhjrK2tMTCQqqYofkyNZCmtKKnM2LDsIVcvxuY4q1btcoz7pDF13SvqKC7xorZdHNQKVQAnvUOkUFWEdJVbCSEklxLiZampSras9ePP9X6kpub8+rmRkYLX36zF28NfoUIlc04cUm8SLjTr0stJrVAF8M/hYClUvUDrQlWtWrV4+vRpYcai0ZUrVwDw8PDQOG5nZ4e9vT2hoaGcO3eOPn365HrNU6dOAfD6669rHFcoFIwfP16reIUQQmj25KES+DjHIpWhoYJ3RrrRf1hdjGT5s940bGqHtY0JMdHJWY6fOh7C2I8bytL0IqKr3EoIIYTIqgaLZwfwODQ5x1kKBXTq4cjA0W5UqWqpo9hKl/pNqlC+ohkR4YlZjp8+HsoHnzTG1NRQT5EVL1pnmu+++y5hYWHs2bOnMONRExgYCJDjFpX29hlNEAMCAnK9XkJCAkFBGU+JXV1diY2NZfPmzUyaNImRI0cyY8YMTp48WfDAhRBCqPgcCWbLujQg+xVStWqXY+GqTgwc5SZFKj0zNjagZQf1FcrRkclcvfRMDxGVDbrKrYQQQgiA1NR0Vqx4AEzMtUhVr1El/remM54zmkqRqgAMDRW06eSgdjwhPpWLpx/rIaLiSesVVQMGDODs2bPMnDmTgIAA2rdvT4UKFXJ8VS4vr+W9LDw8493YChWy32nI1tYWgIiIiFyv9+jRI9LTM3qiPH78mGHDhvHw4cMsc7Zt20bPnj2ZP38+JiYm+Y5ZiKK2+dpm4lPisTC2YHD9wfoOR4hspacr+WPNTbauu5XjvH5D6jB4bD0pUBUj7brU4PDfAWrHfY6E0Li5LE0vCrrKrYQQkksJERQUzZAhe/HxCSWn9SuVq1owakJ9WnW0l91mC0n7rjXY8+c9teP/HA6idUfZiRQKUKiCjNfx9u3bx9KlS1m6dGmOcxUKBTdv3sz3ZyQmZiyJy6lgZGpqmmVuTuLi4lS/9vT0xNzcnKVLl9KmTRsSExPZt28fCxYsYN++fdjY2PDNN9/kO2Yhitqnhz9VbaksyZUorhITUvlp7gVOHw/Ndo51ORM+ntkMj1ZVdRiZyIt6jSpjW8GUyOdJWY6f83lIWmpjef2viOgitxJCSC4lyra//rrN2LGHiIxMynaOgQG8ObA27455FVMz2YG2MNV2K09Ve0seh8ZlOX7x9GNiY3Je2VZWaJ1l7ty5k9mzZ6NUKvP0X+YqpvwyNMx4RzOn6q1SmdHsLS+Nz5OS/vvLmJyczMaNG+nSpQvm5uaUL1+eIUOG8NVXXwGwdetW7t+XxnBCCJFfkRGJzPT8J8cilVuDiixe21mKVMWUoaFC41O9mKhkbl4N00NEpZ+ucishhBBlU2pqOlOmHGPAgL9zLFI5uZRjwYpOjJzQQIpURUChUNC+aw214ynJ6Zz956GGM8oerf/UbdiwAaVSSZs2bRg9ejT29vYYGxsXZmwAWFhYEBUVlaXA9LLk5IyqY+bKqpyYmf23xXm/fv1U/a1e1K9fP5YuXUpoaCjHjh3D2dlZi8iFKDoLui5QLVcXorh58jCOb6b48DAk+6bpvd52YdTEBrIqp5hr2cGefdvVH9icPvGQ+k2q6CGi0k1XuVWmhIQEVq1axd69ewkJCcHS0hJ3d3eGDx9Ohw4dtLpmeno627ZtY+fOndy9e5f4+Hjs7e3p1KkT48aNo1y5coV8F0JoR3IpUdY8exbPwIF/c+xYcLZzDAwVDBzlRv+h+tvUxs/PT6fn6Uu7LjU0tsY4cSgIJ9fs2x6VFVoXqh48eICtrS3Lli0r0j5O5cuXJyoqisjIyGznZPamqlgx923MbWxsVL92c3PTOEehUODq6kpoaCjBwdn/RRZCX2SJuiiuAu5F8c0nPmo7mfwnjbeHV2fo+410GZbQUr2GlTTu/nf2n4e891FDPUVVeukqtwKIj49n5MiR+Pr6YmxsTO3atYmMjMTHxwcfHx88PT2ZOHFivq85fvx4zpw5A4CTkxPly5cnKCiINWvWcPDgQTZv3kzVqrKKUuif5FKiLLl06Ql9++4kKCgm2zkVKhnz2dy21KmnnyJJRPgzFAYGDB06VC+fr2s1nGxwrmPL/TuRWY5fu/SM6CgbzSeVIVoXqkxNTalevXqRJ1LOzs4EBAQQEhKS7ZzQ0IxXS5ycnHK9nr29PWZmZiQmJqpWYmmS+cqhNFMXQoi8ueEbxtzpp4iPTdE4bmYOiQkradVhsY4jE9oyNDKgedtqHNkXmOV4+LME7vlFYChvAxQqXeVWALNnz8bX1xc3NzeWLVtGtWrVgIzXD7/44gu8vLxo0qQJrVu3zvM1Z82axZkzZ6hSpQpLly6lQYMGANy+fZtJkyYREBDAV199xYoVK4rknoQQQqjbtu0OQ4fuIzExNYdZl/hk1jt6K1IBxMVGo0xPZ/JXi3BwdM33+RfPHGfzykVFEFnRad+lhlqhSqmE65eyLyiWFVqv52vcuDEBAQHExmb/akdhaNgw44ntlStXNI4/efJEtWtf48aNc72eoaEh7u7uAPj6+mY778GDBwDUrFkzP+EKIUSZdPncE76ZfDLbIlVVe0veHWMI+Os2MFFgLTto3n3m9Ins+48J7egqtwoKCmL37t0YGBiwcOFCVZEKoE+fPrz33nsAeHl55fmaV69eZdeuXRgaGrJq1SpVkQqgbt26qs1p/vnnH548eVJIdyKEECI7SqWSxYsvMGDA7myLVGZmRnz9tRvwO2bmhroNMBsOjq641HXP93921dR7PhV3bTo7aDzue6Fo84CSQOtC1YcffkhycjIzZ87M02572urevTsA586d09jYfPPmzQA0b94cBwfN/0e/rHfv3gAcOHCAR48eqY2fOHGCBw8eYGBgQNeuXbUNXYgik5SapPpPCH27cPoR8z47RXKy5sbOznVs+X5ZR2wryJbGJVHDplUwM1dfOnXmn1DVZiaicOgqt9q1axdpaWk0atQIV1f1p9aDB2e8EnXp0iXVw8Dc7NixA8godNWtW1dtvEWLFnz88cfMnDkzT5vfCFHUJJcSpVlaWjoffXSUKVOOk9236ho1rPHxGcSbb1bTPEEUucp2FtR5VX0Vm//teMBS9wEVI1ov2o+NjaV///5s2bKFs2fP0rx5c6pVq4a5uXm253z00Uf5/hwnJyd69erFnj178PT05JdffsHR0RHISLRWrVoFwPjx49XODQoKIiUlBWtra6pU+a/pa79+/fjtt9+4e/cuY8eO5ccff1QlatevX1ft+vfOO+9gZ2eX75iFKGouS1xUWyqHTMn+tVghito5n4cs+PIsqSmai1QNPCrz2bxWWFgWXUNoUbRMTA1p2roqPkey/lvzKCSOx6GyhXJh0lVulblK3cPDQ+O4nZ0d9vb2hIaGcu7cOfr06ZPrNU+dOgXA66+/rnFcoVBozNWE0BfJpURpFR+fwuDBe9m16162czp2rMHWrb2pXNmCS5dklzl9atWxOnduPs9yLKO4WE8v8RQXWheqRo0ahUKR8XQ8IiKCQ4cOZTtXqVSiUCi0SqYAZs6cyZ07d7hz5w49evSgTp06REdHq3pTTZ48WWMPhZEjRxIaGkrfvn35/vvvVcdNTExYtmwZY8aM4e7du/Tq1QtnZ2cUCgX37mX8hW7VqhXTp0/XKl4hhCgLTp8IZeFXZ0lL0/york0nBz6e2RRjk+KxlFxor2V7e7VCFcDVi9JDoTDpKrcKDMzoOZZTe4PMQlVAQECu10tISCAoKAgAV1dXYmNj2b17N2fOnCE6Oprq1avTo0cP2rVrl+9YhRBC5F1UVBK9e+/g5Mnsi68TJzZm8eLX9Larn8iqVQd71v9yXcNIAw3Hyg6tC1XNmjUrzDhyVL58ebZs2cLq1avZv38//v7+GBkZ0bx5c4YOHUq3bt3yfc0aNWqwa9cu1q9fz4EDBwgMDMTQ0JCGDRvSp08f3nnnHYyMpEusKJ5a1WjFs7hnVLasrO9QRBl1zudhjkWqTj0dmTDdA0NDed2vNPBoZYexiQEpL73eee2S9FAoTLrKrcLDwwGoUCH7prm2trbAfzsr5+TRo0ekp2f82Xj8+DHDhg1Te2Vw27Zt9OzZk/nz58tGNaJYkFxKlDZhYfF067aNS5c09wFUKGDRotf4+GPNq2mFflS1t9K4+x+4EhWlufdrWaB1JWbjxo2FGUeuLCws8PT0xNPTM8/nHD16NMdxc3Nzxo0bx7hx4woanhA69eeAP/UdgijDLp97woIvsy9Sde3txPhpTTAwkCJVaWFuYUyjZnac/zdrX8dHIUlARf0EVQrpKrfK7H+VU8HI1NQ0y9ycxMXFqX7t6emJubk5S5cupU2bNiQmJrJv3z4WLFjAvn37sLGxUTVWF0KfJJcSpcnTp0kMHfoHfn7PNY6bmRnx22896d+/jo4jE3nR+jV7DYUqQ06cCOO11/QRkf7Jej8hhBB55n87nu8+P51tT6qe/ZylSFVKtexQPZsRd53GIQrO0DDjddzM1ww1yWyUn5fG50lJ/zWjTk5OZuPGjXTp0gVzc3PKly/PkCFDVP0/t27dqnFzHCGEENqqwJgxF7MtUlWsaM6RIwOkSFWMtcpmh+WjR5/qOJLiQyfvtsXFxXHs2DF69eqli48TQghRJGqw+qcQkpM0r6Tq/Y4roz0b5PjDb3Hi5+en0/NKumZtqmFgqCBdbSWdFKr0oSC5lYWFBVFRUVkKTC9LTs5olJ+5sionZmZmql/369cPe3v1hLtfv34sXbqU0NBQjh07hrOzc77jFkIIkVX4s2RgHA8fal79am9vxeHDA3Bzk9XPxZl9TWscXWwI9I/OcvzMmedERSVRrlzu34tLmwIVqm7dusXy5cu5c+cOiYmJqv4EmVJTU0lMTCQuLg6FQiGFKiGEKKFu344B3iMpmyJVz37OJaZIFRH+DIWBAUOHDtV3KCWKTTlT3BtV4urFZy+N1OT5c9n9r7DoIrcqX748UVFRREZGZjsnszdVxYq5/3BjY2Oj+rWbm5vGOQqFAldXV0JDQwkODs5fwEIIIdQ8Do1l2YJgoLzGcRcXW7y9B+DkVE63gQmttO7oQKD/zSzHUlKUHDjwgIEDX9FTVPqjdaEqICCAd999l8TERNXy8JxUq1ZN248SQrzkg78/4HnicyqYVeDX3r/qOxxRyt29G8GECVcAC43jnXs68t7HjUpEkQogLjYaZXo6k79ahIOja77Pv3jmOJtXLiqCyIq/5m2rayhUGeDjE06XLnoJqVTRVW7l7OxMQEAAISHZ7wqVubOyk5NTrtezt7fHzMyMxMRE1UosTTJfOZRm6qI4kFxKlGRPHsbx5aSTRDxP1Tju7l6JQ4feplo1Kx1HJrTVqoM9v6++qXZ81657UqjKj7Vr15KQkEDlypV59913MTMzY8GCBbRv356uXbvy+PFj9uzZQ2BgIG3atGH16tWFGbcQZdreu3sJjQnF3lrz+8xCFJbHj+Po1u0vIiI07zrSrrMDH073KJE9qRwcXXGpm//X1kIC/YsgmpKhWZtqrPrJV+34yZNheoim9NFVbtWwYUOOHj3KlStXNI4/efJEtWtf48aNc72eoaEh7u7uXLhwAV9fXwYNGqRx3oMHDwCoWbOmVnELUZgklxIl1ZOHccz0/IdnT+I1jjdrVpUDB/pToYK5jiMTBVGjljVV7S15HBqX5fi+fQ9ISUnD2NhQT5Hph9aFqjNnzqBQKFi2bBnu7hmJ/po1a4iOjmbAgAEAjB07lvfee49Tp07xzz//0L59+8KJWgghRJGLjk6iZ89tPHgQpXG8ebtqfPRlMwwNS16RSmjHrrolNWvZEPQgaw+F06efk5iYipmZTlpfllq6yq26d+/O4sWLOXfuHPfv31frF7V582YAmjdvjoODQ56u2bt3by5cuMCBAweYNGmS2mqvEydO8ODBAwwMDOjatWu+YxZCCAFPHsUxc1L2Rap69Wz44YfaBAT4ERCQt2uW1d6bxY1CoaB52+rs3nI3y/GoqCROnAihSxdHPUWmH1pnlE+fPqVatWqqRAoy+hKcPXuWtLQ0DA0NMTMzY9asWfTq1YstW7ZIoUqIQnJ+7HnSlGkYKspWZV3oTnJyGv377+byZc27jTRubse0b1pgZCSbx5Y1zdpUUytUJSSkcfx4MN2719JTVKWDrnIrJycnevXqxZ49e/D09OSXX37B0TEjAd61axerVq0CYPz48WrnBgUFkZKSgrW1NVWqVFEd79evH7/99ht3795l7Nix/Pjjj7i6Zrxae/36ddWuf++88w52dnb5jlmIwia5lChpIp8nMmvySZ491lykgiBu3FhJx46aG6uL4q9522pqhSrIeP1PClV5lJaWptZg08nJCR8fHwICAnBxcQHA1dUVBwcHrl+/XrBIhRAq1ayl55soOunpSkaPPoC3d6DG8br1KvDZvJYYm0hyXxY1a1ONbb/dVjv+99/+UqgqIF3mVjNnzuTOnTvcuXOHHj16UKdOHaKjo1W9qSZPnkzr1q3Vzhs5ciShoaH07duX77//XnXcxMSEZcuWMWbMGO7evUuvXr1wdnZGoVBw7949AFq1asX06dO1jlmIwiS5lChJ4mJT+OYTHx6FxGkct6sOnp93wtwi/ytWy3LvzeLGrX5FrG1MiInO2u9x9+57LFnSqcT0gy0MWheqbG1tVTvCZKpRowYA9+7dUyVTmXNv31ZPaoUQQhQ/06efYNMmzcvAK1c14Yv5rTGVV7zKrNqvVsDG1oToyKxJ1N9/+/Pzz53LVBJV2HSZW5UvX54tW7awevVq9u/fj7+/P0ZGRjRv3pyhQ4fSrVu3fF+zRo0a7Nq1i/Xr13PgwAECAwMxNDSkYcOG9OnTh3feeQcjI/m3Qwgh8iMpKY15n53iwV3NrRggGM/PX8O9cUOtrl+We28WN4ZGBjRtXZVjB4KyHA8KisHX9xmNGlXJ5szSR+ts4dVXX+XEiRPcuHGDevXqARlP/ZRKJb6+vqoEJy0tjdDQUCwsNO8WJYQQovj48ceLLFx4IZvRaN6f3AgbW1OdxiSKF0NDBU1bV+Povqwr7oKDY7h69RkNG5adJKqw6Tq3srCwwNPTE09Pzzyfc/To0RzHzc3NGTduHOPGjStQbEIIISAtNZ2FX53lxhXNm5ZUqQZPH63A3EK23i0tmrerrlaogozX/8pSoUrr5iLdu3dHqVQyduxYNm/eTHp6Ok2aNMHc3Jzff/+d8+fPExcXx//+9z8iIiJUvQ+EEAV3yP8Qu2/v5pD/IX2HIkqRP/64xeTJxzSOWVoaAqupUMlYt0GJYqlZG82vzPz9tzyVLQjJrYTQHcmlRHGXnq7k5/mXOP/vI43j9jWt6DvYEJCeVKVJo2Z2GBmpr07fteueHqLRH60LVb1796Z58+Y8f/6cuXPnolQqsbKyom/fviQkJDB8+HCaNm3K2rVrUSgUqt1qhBAFN3rXaN764y1G7xqt71BEKXH0aBDDh+/TOGZsbMDChfWBh7oNShRbjZrZYWSsnkJIoapgJLcSQncklxLFmVKpZN3Saxzbr7lfaMUq5sxa1A4LS3ndvrQxtzCitpv6iunLl58SFBSt4YzSSetClaGhIStXrmTChAk0bNgQQ8OMprqffPIJzZs3R6lUqv7r0aMHb7/9dqEFLYQQovD4+j6lT5+dpKSkaxzfsKEnzZtX0HFUojgztzCifuPKasfPnXvM48eaG72K3EluJYQQAmD7b3c07v4GYF3OhFmL2lK5qrTWKa3qNbbSeLwsPRAsUEdLU1NTtd4GlpaWbNiwAV9fX0JCQnB2dsbNza3AgQoh/vNZ28+ISYrB2tRa36GIEi4gIIoePbYRE5OscXzRoo4MGvQKly5d0nFkorhr1qYal889UTu+d+99xoypr4eISgfJrYTQDcmlRHF1aPcDNv6qeVdXM3NDvvyhDTWcbHQcldCleg2t+Av1HGvXrntMmNBYDxHpXpFtvdKwYUMaNtRu5wEhRM4mNp+o7xBEKRAenkD37tt49EjzCphPPmnK5MlNdRyVKCmatqnKisXqx3fvvieFqiIiuZUQhUdyKVEcnToWwvKFmh8OGhkp+HxeK+q8KqvcSzsbWyMgEMjai/LYsWCiopIoV670b2xU4EJVcnIykZGRVKnyXwd6b29vdu3aRVpaGh07duTtt9/GwEDrtwyFEEIUsvj4FHr12s7t2881jg8e7MaCBR10HJUoSapUtaSagymPQpKyHD98OJCEhBTMzaXxvrYktxJCiLLH9/wTFs0+T7qGTgwKBUz5ujkNm9npPjChJzd5uVCVmprOoUMBDBhQVz8h6VCBMpy//vqLtm3bsmTJEtWxP//8E09PT7y9vTl69Chff/01kyZNKnCgQgghCkdqajqDBu3hzBnNu8h06eLI2rXdMTCQBp0iZ/UaqfdQSEhI5ehR9W2VRd5IbiWEEGVP0P0EvptxmtRs+oWOm9qY1q856DgqoV83NB7du/e+juPQD60LVZcuXeLLL78kOjqax48fA5CWlsaPP/4IQL169Rg6dChWVlYcOXKEPXv2FErAQgghtKdUKhk//nC2zRgbNarCtm1vYmJiqOPIRElUr6GlxuN//102kqjCJrmVEEKURVVY+VMoiQlpGkeHflCPbm856zgmoX9PqFbNTO3o/v0PSE9X6iEe3dK6ULVp0yaUSiVDhw7ll19+AeD8+fOEh4djbW3Nxo0bmTlzJsuWLUOpVLJr165CC1qIsu6Vn1/B5jsbXvn5FX2HIkqYb745xapV1zSO1apVjv37+2NjU/rfexeFw8HJDFDfKnnfvvsolaU/iSpsklsJoTuSS4ni4NGjRGAs8bGai1RvDnSl/9DS/5qX0Kxt24pqx54+jefChcd6iEa3tC5UXb58mXLlyvHpp59iYmICwMmTJwFo37495ubmADRt2pTq1atz8+bNQghXCAEQmxxLTHIMscmx+g5FlCArVvjyzTenNY5VqmTOgQP9qVpV8woZITTJeD3UT+14cHAMN26E6T6gEk5yKyF0R3IpoW/PnsUzYcIVwFbj+GvdazJyQgMUCmnFUFa1aaNeqIKy8fqf1oWqsLAwatSooUqkAE6fPo1CoaBFixZZ5laoUIGoqCjtoxRCZFGnYh1erfwqdSrW0XcoooTYtese48d7axyzsDBiz55+1Kkju8gIbdzSeHTfvgc6jqPkk9xKCN2RXEroU0xMMj17biMwMF7jeLM21ZjwmYf0Cy3jmjYtj5mZ+v53ZaFQpfWuf1ZWViQkJKh+//z5c/z8Mp6qtmzZMsvcp0+fYmkpT+mFKCxHRxzVdwiiBDl5MoRBg/ZofJ/d0FDB1q29adGimh4iE6XDXQwNFaSlZf3ztW/ffT79tLmeYiqZJLcSQncklxL6kpSUSp8+O7lw4YnG8VcbVmLq7BYYGcnOrmWdubkhnTrVUHv4d/HiEx4/jivVb0Jo/ae/Zs2aBAYG8uRJxl+wgwcPolQqqVmzJjVq1FDNO3nyJE+fPsXFxaXg0QohhMiXa9ee0bv3DhITUzWOr1z5Om+8If8+i4JIonHjcmpHfXxCiYpK0kM8JZfkVkIIUbqlpaUzePDebHfHdXItxxfzW2NqKpvaiAxvvKG5kf7+/aV7VZXWhapOnTqRmprKqFGj+O6771i4cCEKhYLevXsDEBERwdq1a/n4449RKBT06NGj0IIWQgiRu4CAKLp1+yvbYsG337Zh1Kj6Oo5KlEZt2lRSO5aWpuTw4QDdB1OCSW4lhBCll1KpZNy4w2zfflfjeFV7S2YtaoullbGOIxPFWXaFqtL++p/WhaoRI0bQqFEj7t+/z4YNG4iLi8PV1ZXRo0cD4O/vz/z584mLi6N9+/a8++67hRa0EEKInIWFxdOt2188ehSncXzChEZ88UVLjWNC5JemXWlA+lTll+RWQghRes2YcTLbnZdtyhnyzeJ22FYw03FUorhzdCxHvXrqedahQ4EkJ2veLbI00LpHlampKRs2bGD79u3cunULJycn3n77bSwsLABwdnbGzc2Nt956i+HDh2NgIO/YClFYvjjyBZGJkdia2TK381x9hyOKmdjYZN54Yzt37kRoHB8woA4//dRJdpERhaZWLQscHW0IDIzOcnz//gekpyulGWweSW4lhO5ILiWCgoIICyvYDrWVKlWiZs2auc5buPA8339/LpvReN6f8ip21UtvvyFRMG+84cyNG+FZjsXEJOPjE0qnTrn/+SuJtC5UAZiYmDBo0CCNYxUqVGDHjh0FubwQIhvrfdcTGhOKvbW9JFcii5SUNN5+ezfnzj3WON6pU002buyJoaH8gCsKj0KhoGfPWixb5pvl+OPHcVy58pQmTez0FFnJI7mVELohuVTZFhQUhJubG/HxmnfdyysLCwv8/PxyLFatW3edadNOaBwzNTUgKWkN1Ry8ChSHKN3eeMOZBQvOqx3fu9dfClVCCCGKt/R0JaNHH+TgwQCN440aVWHHjrcwNZV/+kXh69HDWa1QBRm7/0mhSgghRHESFhZGfHw8k79ahIOjq1bXCAm8x+LZUwgLC8u2ULV9+x3GjDmocczIyIAffqjPpEmBWn2+KDtat7anXDlTtb6ze/c+4H//e01PURUt+WlFiBJo/5D9pKSnYGwgzRZFBqVSyaRJR/jtt5sax52dy7F/f39sbEx1HJkoKzp1qoGJiaFav4R9+x4wc2YrPUUlhBCaSS4lABwcXXGp614k1/b2DuTdd/eSnq5UG1MoYMOGHtStm1Akny1KFyMjA7p1c2Lr1ttZjt++/Rx//0hcXGz1E1gRknc/hCiB6tvVp0m1JtS3kx3bREaR6rPP/mHp0isax6tUseDQoQFUrSq9D0TRsbQ0oWPHGmrHz5x5SFhYwV6tEEKIwia5lChKZ848pE+fndk2u16ypBPvvuum46hESZbd7n/79pXO3f+kUCWEECXcnDlnNL63DmBtbcKBA/1L5ZMWUfz07FlL7ZhSmbEzjRBCCFEWXLv2jJ49txMXl6Jx/OuvWzFxYhMdRyVKuh49aqFpH6S9e6VQJYQQophZtOgCX331r8YxExNDdux4i8aNpT+Q0I2ePcvW0z4hhBDiRf7+kbz++l9ERCRqHJ80qQlff91ax1GJ0qByZQuaN6+mdvz48WDi4pL1EFHRkkKVECXQxYcXOR18mosPL+o7FKFHy5df4ZNPjmscMzIy4M8/e9O5s6NOYxJlW+3a5XF1tVU7fuBAAGlp6boPSAghsiG5lChsDx/G0rXrnzx+HKdxfMSIeixe/BoKTctihMgDTa//JSWlceRIkB6iKVp5aqbeu3dvnJyc8PL6b9vMhw8fYmpqSsWKFYssOCGEZm/98ZZqS+WQKSH6DqdYCwoKIiwsTOvzK1WqlOOWw7ry8n3s2PGQuXNvaZyrUMC337rh4BDNpUuXVMeLy72I0q1nT2eWLLmU5Vh4eALnzz+mZcvqeoqq+JHcSgj9klxKFKbw8AS6dv2TBw+iNI736ePKqlXdMDCQIpXQ3htvOGt8k2L//ge8+aZ2u1cWV3kqVIWGhmJmZpblWKdOnWjatCm//fZbkQQmhBAFFRQUhJubG/Hx2jdytrCwwM/PT68FHvX7aAn0z3a+UrmVzz8/z+efZz1eHO5FlH49e9ZSK1RBxut/Uqj6j+RWQghROsTEpNC9+1/cvBmucbxTp5r8/nsvjIzkZSZRMI0aVaFqVUu1VXv79t1HqVSWqtV6eSpUAYSEhJCcnIyJiYnqmFKpvtWmEKLojW0ylqikKMqZltN3KMVaWFgY8fHxTP5qEQ6O+X/KEBJ4j8WzpxAWFqbX4s6L9xFwryI7Nj/Ndm7fwVVo2/lLtePF5V5E6dehQw3MzY1ISEjNcnzfvgfMnt1WT1EVT5JbCaE/kkuJwmHKxIm+XL8erXG0efOq7NzZBzOzPP/YLYSKn5+f2rHmzW3YvTtroSooKIa//jqJi4uV6lhJf5MiT39j6tSpg6+vL2+88QYNGjRQJVSBgYF8/vIj+2woFArmzZunfaRCCJWvO36t7xBKFAdHV1zquus7jAK7f6cCu/7Ivkg17AN3+g+rq8OIhFBnZmZE58412bMnawP1ixef8PhxHFWrWuopsuJFcish9EtyKVFQSYnpwJhsi1T16lVk377+WFubaBwXIjsR4c9QGBgwdOhQDaP1geFqR9955yvghOr3Jf1NijwVqsaPH8/48eMJDg4mODhYdTwsLIwdO3bkeK5CoVAtQ5NkSggh8i9jhUVXdv3xLNs5Q8bWkyKVKDZ69nRWK1QBHDjwgJEjS37RuDBIbiWEECVXYkIqq34KAWppHK9VqxyHDg2gYkVz3QYmSoW42GiU6eka3wpJiE/jq4/ukf7SHjUudQfw4aefAKXjTYo8Fao6dOjAli1bOHjwIBEREaSnp7Njxw4qVapEu3btijpGIYQos9LTlSxYcAd4Pds5w8e702+IFKlE8dGjh+bEff9+KVRlktxKCCFKpqSkNOZ+dor7dxI0jteoYc2RIwOoXt1K47gQeZXdWyFuDSK5cSXrZlEB9xKpal8XSytjXYVXpPL8smz9+vWpX7++6vc7duzA0dGR7777rkgCE0KIsi45OY3hw/exdWtotnNGTazPW4Pq6DAqIXLn5FSOV1+tqNZY9uDBAFJT06Wh7P+T3EoIIUqWxIRUvvv8NNcual7lXr26FUePvkOtWra6DUyUKR6tqqoVqtLSlPheeErrjvZ6iqpwaZ0pTpw4kX79+hVmLEKIPGq7pi2uS1xpu0YaE5dWUVFJ9Oq1nS1bbmc7572PGkqRShRbPXuqr6qKikri9OmHeoimZJDcSgjdkVxK5Fd8XAqzp/6L7wXN/UKrVrXk6NF3cHUtr+PIRFnj0aqqxuMXTz/WcSRFR+vtByZOnJjl9/fu3ePBgwfExcVhaWmJo6MjderID1BCFIWAyABCY0JJTE3UdyiiCPj7R9K793b8/J5rHDcwgA8/9aBLLyfdBiZEPvTs6czChRfUju/bd5927Rz0EFHxJ7mVELojuZTIj9joZL75xIe7fhEaxytXNufIkQHUrVtBx5GJsqhmLRsqVTEn7GnW108vnXlcanYPLvA+md7e3vzwww8EBQWpjVWrVo1p06bRo0ePgn6MEOIFFcwrkJSWRAVz+WZY2pw4EUz//rsJD9fc98DYxICp37SgRbvqOo5MiPxp08Yea2sTYmKSsxzft+8B333XXk9RlQySWwlR9CSXEnkVFZHErCkneXA3SuN4uXLGHDnyDq++WknHkYmySqFQ4NGqKgd3PchyPCI8kQf3NP85LWkKVKhat24d8+fPV1XtrKyssLS0JDo6moSEBB4+fMiUKVN4+PAhY8aMKZSAhRBwdfxVfYcgisDq1dcYP/4wKSnpGsfNzA348oe21GtUWceRCZF/JiaGdOniyI4dd7Mcv3r1GSEhMTg4WOspsuJNcishdENyKZEXz8MS+PrjkwQHxGQzI5Zff+1E/fqSmwnd0lSogozX/5q00ENAhUzrHlU3b95kwYIFKJVKBg4cyMGDB7lw4QInTpzg8uXL7N27lwEDBqBUKlm8eDG3bt0qzLiFEKLUiI9PYcyYA7z33sFsi1QQzYTpNaRIJUoUTX2qIGP3P6FOcishhCg+HgbH8Pn449kWqWxsjYBfqF1bdvcTule/SRWMjNXLOZdKSZ8qrQtV69atIz09nQkTJvDNN9/g6OiYZdzFxYVvv/2WDz/8kNTUVDZv3lzgYIUQorS5eTOM5s1/Y82a69nOqVvXClhC9RpmugtMiELQo4fmQtXevfd1HEnJILmVEEIUD3duPuez8cd58ihe43hlOwsmTK8BaN79T4iiZm5hRL2G6q+b3r4RTnxsmh4iKlxaF6rOnz+PtbU148aNy3HeuHHjsLKy4syZM9p+lBBClDpKpZL166/TrNlv3LgRnu28fv1qs3q1B1A63jcXZYu9vTUNG6qvAvT2DiQpKVUPERVvklsJIYT+XTj9iC8n/UN0ZLLG8ar2lsxb2oFKVUx0HJkQWWna/S89HW7fiNNDNIVL6x5VYWFhvPLKKxgbG+c4z8TEhFq1anHnzh1tP0oI8ZJFpxcRnRSNjakNU1pN0Xc4IhdBQUGEhYWpfh8ensy8ebc4fjwsh7NgzBhHxo1z4Pbtwnu9x8/PT6fnibIhpz8fTZpY4Oub9VhcXApr1hynRYuMJsaVKlWiZs2aRRliiSC5lRC6I7mU0OTQ7gcs/99l0tM075zm4GTN7B/bUaGSOdHyDFHomUerqqzxUu+353etDBeqzM3NiYjQvD3ny54/f46ZmbyyIkRhWXR6EaExodhb20tyVcwFBQXh5uZGfHzm0vGGQF/AMoezEoE/Wb36KqtXF04cEeHPUBgYMHTo0MK5oBDk9c+VEzBB7eiHHy4B/gbAwsICPz+/Ml+sktxKCN2RXEq8KC01nbVLr7Hnz3vZzqnzagVmLmiNja2pDiMTInvVa1hhV92SJw+zFqZuXYsDFPoJqpBoXaiqW7cuFy5c4MKFCzRt2jTbeefOnSM0NJRmzZpp+1FCCFFihYWFER8fz/Dx/+P0cTPu+mnudZDJvqYpw8fVopLdHNWxi2eOs3nlogLFERcbjTI9nclfLcLB0TXf5xdGDKL0ycufq7Q0JV9/fI+E+KwbBVS268xn88YSEniPxbOnEBYWVuYLVZJbCSGE7sVGJ/PD12fxPf802zlNW1dl6jctMDPX+sdnIQqdQqHAo1VV9m3zz3I8LjYNcNBPUIVE679pb775JufPn2fy5Mn8/PPPNGzYUG3OlStXmDJlCgqFgjfffLNAgSYkJLBq1Sr27t1LSEgIlpaWuLu7M3z4cDp06FCga2d6+PAhvXv3JjY2liNHjuDgULL/zxWl12/9fiMpNQlTI3miU9zFxaUCb/DbinTS03IuUvXo68yoiQ0wMTXMcjwk0D+bM/LPwdEVl7ru+T6vMGMQpU9uf66atk7gpHdwlmPPnqRgYemEg2M2J5VBus6thCjLJJcSAE8eJfG/Wcd4GByb7ZwuvZwYP7UxhkZat3cWosh4tFQvVGV4ReexFCatC1X9+/dn27ZtXLlyhUGDBtGgQQPq1auHtbU1MTEx3Lhxg6tXr6JUKmnSpAn9+vXTOsj4+HhGjhyJr68vxsbG1K5dm8jISHx8fPDx8cHT05OJEydqfX3IaGw8Y8YMYmOz/0dKiOKio1NHfYcgcpGYmMqvv/oye/ZpoCPpOWy+YWNrwripTWjd0V5n8QmhSx6tqqoVqgAunn6MWwM9BFRM6TK3EqKsk1xKQGN+/DaQ5CTN/agABo5yY9BoNxSKkv0alSi93JtUxsTEgOTk9JdGymihysDAgFWrVjF16lSOHz+Or68vV6/+18hLqcz4C9+hQwcWLFiAoaFhdpfK1ezZs/H19cXNzY1ly5ZRrVo1AHbu3MkXX3yBl5cXTZo0oXXr1lp/xqZNmzh9+rTW5wshBEBqajrr1l1n9uzTBAfH5Dq/dUd73v+kEbblpdeMKL2atLBDoQDlSz8LXDj9CLcG5fUTVDGky9xKCCHKqvj4FGbP9gMGZ1ukMjExYOLnTWnftYZugxMin0xNDanvUYWLpx+/NFKT588171xZEhToJVsrKyuWL1+Or68vR48e5cGDB8TGxmJpaYmzszOvvfYajRo1KlCAQUFB7N69GwMDAxYuXKgqUgH06dOHBw8esHz5cry8vLQuVAUGBrJw4ULMzc1JSEgoULxCiLIpIiKR1auv8fPPlwkMjM51foVKZoyZ1JA2neQVY1H62diaUufVCty+8TzL8euXw0hKKqenqIonXeRWQghRVt24EcagQXu4fj37nZcrVDLj8+9aUdutgg4jE0J7Hi2raihUwenT4XTpooeACkGhdINr2LChxj4KhWHXrl2kpaXRpEkTXF3VG7UOHjyY5cuXc+nSJR4+fEj16tXzdf309HQ+++wzEhISmDFjBvPmzSus0IUoMg8iHpCmTMNQYUit8rX0HU6ZduNGGF5el9m48Qbx8am5zjc0VNB7YG0GjnwFc4uct6AXojTxaFVVrVCVmpKe6wYDZVVR5lZCCMmlyprU1HR++OE8s2adIjk5+34Mtd3K8/l3rahQyVyH0QlRME1a2mk8/u+/4TqOpPAU+20Lrly5AoCHh4fGcTs7O+zt7QkNDeXcuXP06dMnX9dfvXo1ly5d4s0336Rz585SqBIlQru17VRbKodMCdF3OGVOWlo6+/Y9YMmSS3h7B+b5vAYelRk7uRE1nGyKMDohiqemrauxedVNteN+V6U3pBBC9ySX0q+goCDCwrJf1ZSbSpUq5Xmn2Js3wxg58gDnz6uvOHlRt7dqMXpSQ0xN8/datZ+fX77mF9a5QmSqam+Fg6M1IYFZ246cPv2c1NR0jErgRgDFvlAVGJjxQ2BO/xBlFqoCAgLyde27d++yZMkSKleuzMyZM4mJyb2fjBCi7IqKSmLNmozX++7fj8rHmcG8P7kVPfo1l2acosyqVbsc5SuaERGemOW439U4PUUkhBBCH4KCgnBzcyM+XvsVtRYWFvj5+eX4M2J8fAoLFpzju+/O5biKyszciAnTm9CuS/76UUWEP0NhYMDQoUPzdZ4QRaFJy6pqharo6FTOnn1EmzYlb8OmYl+oCg/PWK5WoUL27wjb2toCEBERkefrpqamMn36dJKTk/n2228pV66cFKpEidH3lb5EJEZQ3kyaEOtCQEAca9Z4s27dDeLiUvJ8Xr16FRk5sjrTpk2jrnsXKVKJMk2hUODRqireewKyHI+KSAWqaTxHFK2EhARWrVrF3r17CQkJwdLSEnd3d4YPH06HDh0K5TMePnxI7969iY2N5ciRIzg4SF8+UTxILqU/YWFhxMfHM/mrRTg4qrd2yU1I4D0Wz55CWFiYxkKVUqlk+/a7TJlyjKCgnH++q17DlJkLOlC9hnW+44iLjUaZnq71fQBcPHOczSsXaXWuEC/yaGnH7i131Y7v23dfClVFITEx48mriYlJtnNMTU2zzM2LZcuWcePGDfr27ctrr71WsCCF0DGvnl76DqHUS09X4nctFhhD//5n83Vu5841mTSpCW+84Yyv75UiiU+IkkhToSpDyd5CuSSKj49n5MiR+Pr6YmxsTO3atYmMjMTHxwcfHx88PT2ZOHFigT5DqVQyY8YMYmPl9U5R/EgupX8Ojq641HUv1GteuvSEadNOcPRoUI7zMnaiPc6kL8ZqVaR6UUHuIyTQv0CfLUSmVxtWwszckMSErKsH9+17wNy57fQUlfaK/cuKmVsv57QSIXO7ZgODvN3OjRs3WL58OXZ2dsyYMaPgQQohSo2kpDQO7ryP59BDrPoxlLz+AG1ubsT77zfg2rUReHu/w5tvumJoWOz/iRVCpxo2rYKRkabv51Ko0rXZs2fj6+uLm5sbhw8fZseOHRw7doz58+djZGSEl5cXp06dKtBnbNq0idOnTxdSxEIIkb3r15/Rv/8uPDw25lqkqlOnPGvWeAB7MTaWXE2UDsYmhjRoWkXt+JUrTwkNLXlvjhX7v5kWFhYAJCUlZTsnOTkZ+G9lVU6Sk5OZPn06qampfPvtt9jYSFNjIQRERiTy++qbjO2/j2ULLxMalLcVADVrWrNgQXtCQj7g119fx929chFHKkTJZWFpjFvDShpGnIiOzvtrtaJggoKC2P1/7N13WFPnF8Dxb9giCLhQUUFUXDhRq7buuqp1W0eto7VWW22dHdYu29qh1bp3q7VqWyeKo+49cG/FhQgoioKAbJLfH/ySGkkgQBICnM/z8Kg377335Hq5OTn3ve+7eTNWVlZMnz6dsmX/e/Sye/fuDBs2DIA5c3Le4+Tu3btMnz6dIkVk5iwhhOmcORPBgAEB1Kmzgg0bMj729DyFAsaPb8i5c4OoU8fFTBEKYT5+TcroXL5jR7B5AzGCHBeq1MUhU3NzS39uPDo6Wm8b9dhUJUqUyHJ7s2bN4saNG/Tq1cto4y8IIfKvhw+eMf/nM7zbazt//36VmGjDrm0tW5Zn/fqu3Lr1LhMnNqZ4cfkyJoQhGjbVlURZcezYE7PHYmnMlVv5+/uTlpZGvXr1qFIl47gqAwYMAODMmTOEh4dne/tKpZJPP/2UhIQExo4dm+t4hRDieampKqAeb799Gj+/laxZc43/P2CjV7Nm5Th16i2mT29FkSK2ZolTCHNroKdQtW3bbTNHkns5HqOqefPmdOnShR49euDra9xni5/n7e1NcHAwoaH6p40NCwsDwMvLK8vtbd++HYD169ezfv16ve3atm0LwKhRoxg9enQ2IhbC9Lqu6cqj+EeUcizF5v6b8zqcfOnRg3jWrbzGnq3B/094smZvb82bb9bgww8bULduxq61Qois+TUtw+9zL2ZYfuTI4zyIxrKYK7c6d+4cAH5+fjpfd3d318yoHBgYSPfu3bO1/WXLlnHmzBm6du1K27ZtmTp1ai4jFsL4JJfKuZCQECIjI3O8/tWrV3O03pPIBP71v8O2DbeANzl/PusZmMuWLcrPP7fkzTdryKQ2osAr5e6IZ+Vi3L0Vo7V81667JCenYWdnnUeRZV+OC1VPnz5l9erVrF69mqpVq9KzZ0+6du2a6ex8OVG3bl327t2rSapeFBERobnbV79+/Sy35+vri7u7u87XkpOTuXTpkqadnZ2dVnd4ISzFmftnCIsNw8M5/83gkNeeRiXx9+9X2Ln5jsEFqtKl7RkzpjHvvlubkiUdTRyhEAWbR0Vn3MsVJSL8mdbyI0cek5amLNRju5krt7p79y5AptO6qwtVwcHB2dr2jRs3mD17NqVKlWLy5Mkyo7KwWJJL5UxISAg1atQgPj7eLPtTqVRcu/iYretvcWx/GGlphuVuRYvaMmaMH5980hhnZ/2TcglR0Pg1KZOhUBUbm8yRI2G0bq3/c9/S5LhQtWrVKjZt2sSOHTsICgrip59+Yvr06bRq1YqePXvSsmVLzUDoudGxY0dmzpxJYGAgt2/fxtvbW+v11atXA9C4cWODpjyePXu23tdCQ0M1PalmzZolUygLUYCkJKexdd0t/llxlfhnqQatU8HLgXvBS9m8eSkvvdTQxBEKUTgoFAr8mpZh23rtmY6io1M4dSqCl14qvDeIzJVbPX6c3nstswKYq6sr8N/wCoZITU3lk08+ITk5mW+//RYXFxcpVAlRwERGRhIfH8/YL2dQ3jPjo8OGOH18P6uXzMi0TVJSGgd3hbBt/S3u3Mi655Sag4MNH3xQj08+aUypUnJzURQ+fk3LsGFVUIbl27bdLhyFKj8/P/z8/Pjiiy80s8UcO3aM3bt3s2fPHooXL07Xrl3p2bMnVatWzXGAXl5edOnShYCAAEaPHs38+fPx9PQE0sdYWLp0KQAjR47MsG5ISAgpKSk4OztTurQ8piMKjtBx+h+FFRldPBPLtC938SDsWZZtFQpo9EpZuvWtir3DAyYMOy8zwghhZA11FKoAtm69VagLVebKrRITEwGws9Pfy0A9QY26rSEWLFjA5cuX6dGjB61bt85xfEKYg+RSuVPeswqVq+XsEeXQuxmv/2oR95+xfeNt9gQEExtj+Lh9zs52vP22Lx9/3Jhy5ZxyFJcQBUE13xI4FLEiMUGptXz79jtMm9Yqb4LKgRwXqtTs7Ozo3LkznTt3JjIyEn9/f/z9/QkKCuL3339n+fLl1KpVi169etGlSxecnZ2zvY/JkycTFBREUFAQnTp1wsfHh5iYGM3YVGPHjqVZs2YZ1hsyZAhhYWH06NGDH3/8MbdvVQiRzzx4kAgMZfm8rAcDtrJW0LqjJz3f9MGjYvp16tb1CBNHKETh5Fu/FHb21iQnpWkt37btDlOmvJJHUVkOU+dW1tbWKJXKTMdrUf1/ZGIrK8MK9ZcvX2bhwoW4u7szadKkbMUjhCjcVCoV5089ZNv6W5w8cj/LgdGfV716cUaNqs+gQbXkET8hABsbK6rVKsr5U9o9mi9ffszdu0/x9MwfM14atZtAyZIleeedd9i8eTO7du1izJgxFClShMuXLzNlyhReeeUVPv74Yy5fvpyt7bq5ufH3338zatQovLy8uHXrFlFRUTRu3JjZs2czYsQIY74NIUQ+l5amZPbsM/TpcwKomWlbKyto85on81a3Z/RnfpoilRDCdOzsranjVyrD8tOnI7h/Py4PIrJcpsitHB3TH4dJSkrS20Y9A6G6Z1VmkpOT+eSTT0hNTeXbb7+lWLFiBscihCi8UlKU7Aq4w0eDdvP12MMEHjasSJVeY7/EggX1uHJlKB98UF+KVEI8p3rtojqXb99+x8yR5Fyue1S9KCEhgd27d7Nr1y4OHTpEQkICkF5siouLY/PmzWzZsoU33niDL7/80uCxFhwdHRk9enS2ZuDbu3dvtmIvX748169fz9Y6QgjLcu3aYwYP3k5g4IMs2zZr5cHA92pRroIUp4Qwt4bNynLqaMbf0x077jB0aO08iMhyGTu3cnNz4+nTp0RHR+ttox6bqkSJElnGN2vWLG7cuEGvXr1o2bKl4W9MCFEoxT9TAe34buJt4mLTsmyv5lzMjle7eFGzbirffzKRxo0/lJn8hNBBX6Fq27Y7jBhRz7zB5JBRClUqlYqjR4/i7+/Prl27SExMRKVSYWNjQ+vWrenVqxetW7cmNjaWjRs3Mnv2bP755x+cnJyYOHGiMUIQolBZfm45z5KfUdSuKEPqDcnrcCyCSqVi/vxzTJx4gISEzAdL9/Zx5Z2P6lKrbkkzRSeEeJFfkzI6l2/delsKVZg2t/L29iY4OJjQUP1j9KiHV/Dy8soy1u3btwOwfv161q9fr7edesKaUaNGZevGoxCmILmU+T2JTGDdyuv8uykNaG9wkcrbx5XOvSrzyqsVsLe35tb1S6YNVIh8rpiLDRAKaE8Ot2fPXRITU3FwMHp/JaPLVYTXr1/H39+fgIAAHj16pBnPoFKlSvTs2ZMePXpQsuR/XwRdXV0ZOnQo7u7ujBs3jk2bNkmhSogcmLx3smZKZUmu4P79ON5+ewc7dgRn2s7F1Z5B7/vSuqMnVlZyB06IvFSqjCMVvYsRclt7CuWdO++SnJyGnV3uZ7fLj8yRW9WtW5e9e/dy7tw5na9HREQQHp4+tl/9+vWzjNnX1xd3d3edryUnJ3Pp0iVNOzs7O8qWLbwD5gvLIbmU+TyJTGDDn9f5d/MdUpKVWa8AWFsraNa6PJ17Vaaab3HpOSVEtl3jxUJVfHwqBw+G0r69V55ElB05LlR169aNoKD0aQ9VKhWOjo506tSJXr160aBBg0zXVSc9KSkpOd29EEIAsHHjDd59dyePHydk2q5tZy+GfFAb52IyhoEQlsKvSZkMharY2GSOHAnLV1MoG4u5cquOHTsyc+ZMAgMDuX37Nt7e3lqvr169GoDGjRtTvnx5XZvQMnv2bL2vhYaGanpSzZo1y6DtCSEKhvhnKaz74xoBa2+SbGCByq2EAx26VaJ910oUL1nExBEKUZBdA17NsHTbttsFu1ClHsvJz8+PXr160alTJ4oUMexiEhcXx8svv2zQXTohREazO80mPiUeR1vHvA7FpEJCQoiMjNT5WnKykhkzbrB2bVgWW3nEyIkN6NDNz/gBCiFypWGzMmxcHZRh+dattwtlocpcuZWXlxddunQhICCA0aNHM3/+fDw9PQHw9/dn6dKlAIwcOTLDuiEhIaSkpODs7Ezp0qUNfWtCWJzCkkvlhbQ0FXu2BrNqyWWeRumftOF5laq60LVvVV5pWwFbW6PO9yVEIRWCi4sNT59qD4mybdsdfv01byLKjhwXqoYPH06vXr00iU12VK1alWXLluV010IUej1r9MzrEEwuJCSEGjVqEB8fr+NVN+AtoEIWWzkEbKNK9Q1Gj08IkXvVfEvgUMSKxATtO+0BAbeZPr1V3gSVh8yZW02ePJmgoCCCgoLo1KkTPj4+xMTEaMamGjt2LM2aNcuw3pAhQwgLC6NHjx78+OOP2Y5TCEtRGHKpvHD53COWzDxP8K2nBrVv2KwM3fpVxbd+KXm8TwijUtG0aQl27IjQWnrjRhQ3bkRRtapbHsVlmBwXqry9vQkJCTEomdqwYQPBwcGMGzcup7sTQhQykZGRxMfHM/bLGZT3rKJZfuV8HKuX3ichXn8X8mIu1vR7uyxxcVVYvSTzgdWFEHnHxsaKar5FOX8yVmv59etPCAp6go9P8TyKLG+YM7dyc3Pj77//ZtmyZWzfvp1bt25hY2ND48aNGThwIB06dMjRdoUQhVNsTDIr5l9kd0CwgWuc4eNve9KstfR4F8JUXn45Y6EKYPv2OwW3UPXpp5/SsGFDmjdvnmXbVatWcefOHSlUCSGyrbxnFSpX8yUtVcnqpVdY/2fmj/o1beXByIn1KeZiz4GdD8wUpRAip2rVzVioAtiy5RbjxxeuQpW5cytHR0dGjx6drRn49u7dm619lC9fXvNIoxCi4FGpVBzeE8rSWeezfMxPoYBX2pSnks99/liwBvdy/c0UpRCFU9OmxVEo4P/zsmhs23abDz/MfOzLvGZQoSoyMpIbN25kWB4TE8OxY8cyXTcsLIwbN25gY2P5UyAKkV/EJsWiQoUCBc72znkdjslFPU5k+lcnuHxO93hVAPYO1gwfV482nTyl67gQ+UiN2k5AGqA9y9/mzbcYP75RnsRkDpJbCZG3ClsuZQpRjxOZ99NpTh3N+sZg3UalGTqqDl6VXTiw098M0Qkh3NzseOmlshw/fl9r+f7994iPT8HR0TaPIsuaQRmOra0tY8aMISbmv5l5FAoFN27c4O23385yfZVKRaNGBTfZFMLcasyroZlSOXRcaF6HY1L3ghOZ+uleHj/SP6tfeU9nPv62CRW9i5kxMiGEMTg6WQPBQGWt5YcPh/H4cQIlShTMWZ8ktxIibxWmXMoULp6JZcOqXcREJ2fazqOiE0NH1cGvaRm5kShEHnjtNe8MhaqkpDT27Quhc+fKetbKewZNqeDi4sLIkSNRqVSaH0Dr37p+IL1beaNGjfj6669N9iaEEAVVA+b+EJJpkap52/JMW9JGilRC5GtXMixRKlVs23Y7D2IxD8mthBD50bNnqUAfls8Lz7RI5VDEmrdH12HWH+1o2KysFKmEyCOvvVZJ5/Jt2+6YOZLsMbjP+JAhQxgyZIjm39WrV8fPz49Vq1aZIi4hRCZaerUkMj6Sko4l8zoUk0hNVTJjxg2gP6mpKp1tbGyteHt0HTr18DZ58nP16tU8WVeIwuMK8HqGpZs33+Ktt2qZPxwzkdxKiLxT0HMpUzhyJIz+/QOBxpm2a9isDO+Nq0+pMo7mCUwIoVf9+u64uzsSEaE9k/q2bbdRqVQWW0TO8eAG3bt3x9vb25ixCCEMtKpnwf0S8+RJAv36BbBr1z29bUqVceST75pQpbppZ6uIevwIhZUVAwcONOl+hBCRVKrkyJ072knUjh13SEpKxd6+cIzFJLmVEOZTkHMpY1MqVfz8cyCTJx8mLU33DUQA1+L2vDumHs1ae1jsl18hChsrKwWdOlVi+fLLWsuDg2O4evUxNWtaZrE+x5nfjz/+aMw4hBCCy5cj6dZtE7duRettU7dhacZ/05hiLvYmj+dZXAwqpZKxX86gvGeVHG3j9PH9rF4yw8iRCVHwtGhRkjt3QrSWxcWlsH//PTp00N1tvaCR3EoIYWkeP05g0KBtWT4m1KRlOd6f2IBirqbPz4QQ2aOrUAXpMyzn60LVvXvpPRvKlSuHtbW11rLsqFChQrbXEUIUDps23eCtt7YRF5eit03XvlUYPLI21jYGDa9nNOU9q1C5mm+O1g29e8vI0QhRMLVsWYoVK0IyLN+8+VaBLFRJbiWEsHRHj4bRt28AoaGxetsUcbTh3bH1aN2xovSiEsJCtW/vhY2NFampSq3l/v63+OSTl/IoqswZVKhq164dVlZWbN26lUqV0pPF9u3bZ2tHCoWCK1cyDpYqhCjclEoV3357jK+/Pqq3ja2dFe9PbEDrTp5mjEwIYU6+vsUoVaoIj16YPGHz5lvMndu2wH0BktxKCGGpVCoVv/xyis8+O5Thi+3zatYtyUefN8S9XFEzRieEyC5XVwdatizPnj3aNwSPHw8nIuIZ7u6W9ztscLcEpVL7IpXVrDQv/ry4vhAi54b6D6Xrmq4M9R+a16HkSmxsMr16+WdapHJxs2HqvJZSpBKigLO2VvD66xmnSQ4NjeXcuYd5EJHpSW4lRN4pKLmUsT15kkC3bpuYOPFAJkUqJR27l+Tb2S2kSCVEPtGtW8ZhTFSq9Mf/LJFBPar27NkDgLu7e4ZlQgjz23VrF2GxYXg4e+R1KDl261Y03bpt5PLlx5m0CmbMF22pWqO42eISQuSdrl2r8NtvlzIs37z5FvXru+tYI/+S3EqIvFUQciljO3XqAb17b+bu3Ri9bUqUsOPx41m0e/1XrK0LVk9XIQqyrl0r8+GHezMs9/e/ybBhdfIgoswZVKjy8Mh4Ade1TAghDLFrVzB9+wYQFZWot023bmXx9/+UYi4dzBiZECIvvfpqRRwcbEhMTNVavnnzLb76qlkeRWUaklsJISyFSqVi4cLzjBmzj+TkNL3t2ratyCefVKR9+9tmjE4IYQyeni7UrVuK8+cfaS3fvTuEZ8+SKVrULo8i081k8z1fv34dpVJJ1apVsbEpHNNKC2Eu50ecR6lSYqUw76DiuaVSqZg58zQTJx5AqdQ9vbGNjRW//tqaJk2U+PvrT5aEEAVP0aJ2vPpqRQICtL8EnTkTQWhoLOXLO+dRZJZBcishjCe/5lLG9uxZMu+9t4tVq67qbaNQwFdfNWPy5CacP3/OfMEJIYyqW7cqGQpViYmp7Nx5lx49quZRVLrl6socHx/PkiVLWLt2rWZZREQEPXr0oHv37vTs2ZP27dtz8uTJXAcqhPhPCccSlCpaihKOJfI6FIMlJKQwaNB2xo/fr7dIVbJkEXbt6s0HH9QvcAMnCyEM07VrxjEUADZvvmnmSPKG5FZCmEd+zKWM7dq1xzRuvCrTIlXp0o7s2tWHr75qhrV14S7qCZHf6RqnCtIf/7M0Ob7aPHv2jL59+zJjxgwOHjyoWf7VV19x9epVzUCf4eHhDB8+nAcPHhglYCFE/hMaGkuLFn/x55/6Z6eqV680p04NpFWrimaMTAhhabp08da53N/fMgf7NCbJrYQQ5vL339do2PBPrlzRP1Zoy5blOXduEG3byoQ2QhQE9euXpkKFjL3TAwJuZzrDZ17IcaFq1apV3LhxAzc3N1q0aAGk3/E7cOAACoWCGTNmcPz4cbp3705CQgK//fab0YIWQuQfR4+G0bDhSk6ditDbpm/fahw50h9PTxczRiaEsERlyzrRuHGZDMv37QshOlr/uHYFgeRWQghTS05O48MP99CvXwDPnqXobffpp43ZvfsNypZ1MmN0QghTUigUdO2acYblx48TOHo0LA8i0i/Hhao9e/ZgZWXFsmXL6NOnDwD79+9HpVJRq1YtXnvtNVxdXfnyyy8pUqQIhw8fNlrQQhR2AUEBrL28loCggLwOJVMrVlyidet/iIiI1/m6QgE//NCcNWu64Ohoa+bohBCWStfjfykpSrZuLdgD+EpuJYT55JdcyphCQmJo0eIv5sw5q7eNq6s9mzf34IcfWmBjI4/6CVHQ6Hv8b/Nmy+q5nuOROO/cuUPFihWpUaOGZtmRI0dQKBS88sormmWOjo5UrFiRkJCQ3EUqhNAYETBCM6Vy6LjQvA4ng7Q0JZ99dohp0/SPoeLiYs/q1Z157TXdj/kIIQqvnj2rMnlyxiLMhg03ePPNmnkQkXlIbiWE+Vh6LmVs//57hzff3Mbjxwl621Sv7sxPP/ni4fGUM2fO6Gxz9ar+8ayEEJavZcsKFCtmR0xMstZyf/+bTJvW0mLGCc5xoSopKQknp/+6gqpUKk6cOAFA48aNtdoqlUrS0mT2LiEKg5iYJN58c2uGWbueV61acfz9u1OtWnEzRiaEyC9q1ChB9erFuXbtidby7dvvEB+fUmB7YEpuJYQwtrQ0JVOmHOPbb4+h0j2Xzf8d59o1f7p1SzVXaEKIPGBnZ81rr3nz11/XtJbfvBnN1auPqVmzZB5Fpi3HhaqyZcsSHh6OSqVCoVBw/vx5nj59ioODAw0bNtS0e/r0KSEhIbi7uxslYCEEfNnyS+KS43Cys6xxA27fjqZr141cvqx/YM7Onb1ZtaozLi72ZoxMCJHf9Orlw/ffH9dalpCQyr//BlvcFMrGIrmVEOZjqbmUMT16FM+bb25l1667etvY2ino/ZY7DZsNBgZnuc3Tx/ezeskMI0YphDC3bt2qZChUQfrENfm+UFWjRg127NjB8uXL6dOnDwsWLEChUNCsWTPs7OwASElJ4ZtvviE5ORk/Pz+jBS1EYTfcb3heh5DBwYP36Nlzc6Zdyj/+uBFTpzaX6Y2FEFnq2bNqhkIVwPr1QQW2UCW5lRDmkxe5VEhICJGRkTlev2TJklSsaNjsyMeOhfPGG1sIDY3V26ZceSc+/r4JXpUNn8wm9K5ljWMjhMi+Tp0qYWtrRUqK9kx//v43+eyzl/IoKm05LlQNGTKEXbt28fPPP/Pzzz9rlg8dOhSACxcuMHz4cJ4+fYqtrS1DhgzJdbBCCMu0dOkFRo7crXdaUzs7a5Ysac+gQbXMHJkQIr+qX780np7FuHs3Rmv5li23SE5Ow87OOo8iMx3JrYQouEJCQqhRowbx8bonmDGEo6MjV69ezbRYpVKpmD37DBMmHMh0uvlmrTwY9ZkfjkUL5qPUQgj9XFzsadWqQobelidO3Of+/TiLmO0zx4WqunXrMmPGDKZMmUJkZCQuLi5MmDCBRo0aAVC0aFGio6Nxc3Nj1qxZVK9e3WhBCyFMy9A7fqmpSmbNusXq1ff0tild2pFNm7rTtGk5Y4YohCjgFAoFPXtWZebM01rLY2KS2bs3hI4dK+VRZKYjuZUQBVdkZCTx8fGM/XIG5T11z7qVmdC7N5k5ZRyRkZF6C1UxMUkMG/Yva9cGZbKlNLr1K8OQD16ymEGThRDm161bFZ2PBW/adJORI+uZP6AX5LhQBdC+fXvatWvHkydPcHNzw8rqv8d5KlasyLx582jRogW2tlKpFyK/MPyOnz3wJlBDb4uaNV3Zvv0NKlYsZswQhRCFhK5CFaTP/lcQC1UguZUQBV15zypUruZr9O1euvSIXr02ExQUpbdN6dL2PHz4Cy3azZEilRCFXNeulRk1ak+G5evXB+X/QhWk3/EsUaJEhuW2tra0bds2t5sXQujgPctbM6Xy7Y/0z66XE4bc8XsalcLSWWGE30vKZEsXWbToAylSCSFyrGnTcri7OxIRoV0437TpBgsWvFpgx7uT3EoI0zNlLmVuK1de5r33dpGQoH/Gvldf9eSTTyrQrp3+gdWFEIVHhQrFaNy4DIGBD7SW799/j8jIeEqWdMyjyNIVzAxPiAIuOS1Z82Mq6jt+L/5YW1dg3s/3My1StXu9BLASR8dc18KFEIWYtbUV3btnHDj90aMEDh8Oy4OIhBAFhTlyKVNLTExlxIhdDBq0PdMi1RdfNGHHjl4UL25nxuiEEJaud2+fDMvS0lT4++f9pAm5+hZ59epV5s2bx5kzZ4iJiSEtLU1vW4VCwZUrV3KzOyHE//mW9qV00dKULlrarPs9GxjBz5OPkxCvOxmys7Ni9KSGlKvwlF1bVGaNTQhRMPXsWZVFi85nWL5hww1atqyQBxGZluRWQphHXuVSxnLnTjR9+mzh9OkIvW2KF3fgzz9fo1MnbzNGJoTIL3r18uHjjw9mWL5u3XXeead2HkT0nxwXqoKCghgwYACJiYmoVPKFVAhz2jFwh9n3uWvLHRZMP4syTffvu2txeyb92AyfmsW5df2pmaMTQhRUrVpVwNXVnuho7V6cGzbcYObM1lhZFZxxViS3EsJ88iKXMpZt227z5ptbM1wXn9eoURnWrn0dT08XM0ZmXlevXs2TdYUoKLy9XWnQwJ0zZ7QL3rt3hxAVlYibm0MeRZaLQtXChQtJSEigTJkyDBkyBG9vbxwc8u6NCCFMQ6VSsXrpFdauuKa3TXkvZ76Y9jLuZYuaMTIhRGFgZ2fN669XZuVK7Z5DoaGxHDsWzssve+RRZMYnuZUQInMKFi68zZIlwZm2+uCDevzySyvs7QvmEAxRjx+hsLJi4MCBeR2KEPle794+GQpVqalKNm++yeDBxp/4wVA5vnqdOHECa2trli9fjpeXlxFDEkJYirQ0FQunn2HXlmC9bXzrl+LT75vgVCzjuAdyp0sIYQx9+lTLUKgC+PvvawWqUCW5lRBCn2dxacA7mRapiha1ZcmS9vTvr39G5oLgWVwMKqUy04l/snL6+H5WL5lh5MiEyH969arKpEmHMixfty4ofxaqYmJi8PHxkURKiAIqJUXJtC+Pc/xAuN42rTpU5INP/bC11Z6XQe50CSGMqX17T1xc7Hn6VPsxl7Vrg5g5s3WBmf1PcishhC43r0Uxc0owUE1vmxo1irNuXVdq1ixptrjymnrin5wIvZv3g0ULYQl8fIpTu3ZJLl6M1Fq+c+ddYmKSKFbMPk/iynGhqnTp0sTGxhozFiGEgSbunEhUYhRuDm5Maz/NBHuwZ8nMUG5dT9Dbou/QGvR7uwYKRcbxYeROlxDCmOztbejRowrLl1/WWv7gwTMOHQqlVauKeRSZcUluJYT5mD6XMo5dW+6weOY5UpKVetv061edJUva4+Qks/oJIbKvd2+fDIWq5OQ0AgJuM2BA3vTQzHGhqnXr1qxevZorV65Qs2ZNY8YkhMjCmktrCIsNw8PZw+jJ1ePHycAIvUUqK2sFH3zSgLaveWW5LbnTJYQwlr59q2coVAH8/ff1AlOoktxKCPMxZS5lDCnJaSyacY7dAcF629jYWPHLL60YPbq+zhuHQghhiN69ffjqq6MZlq9bF5Rnhaoc95X/4IMPKFWqFBMmTODaNf2DLAsh8o87d6J5553TQHmdr9vZWzPph6YGFamEEMKY2ratSIkSRTIsX78+iNRU/T0N8hPJrYQQAFGPE5n84cFMi1Tlyjmxf39fPvywgRSphBC5UrNmSWrUKJ5h+fbtd4iLS86DiHLRo+r333+nYcOGbN26lR49elC6dGnc3d2xtbXV2V6hUPDnn3/mOFAhxH/2DNpDqjIVGyvjzeZy40YUrVr9TXi47p5URZ1s+WLay1SvXcJo+xRCCEPZ2lrTs2dVliy5oLX80aME9u0LoV07r7wJzIgktxLCfEyRSxnDretRTP3sGI8f6h9+wc/PlR9+8KVIkYgMs3VlRiaqEULo06uXD999d1xrWWJiKgEBt+nXr7rZ48nxlXnx4sWa6r1KpSIiIoKICP0XSqn0C2E81UrqH0wzJ65ff0Lr1n9z//4zna8XL+nAVzNewdPbxaj7FUKI7Ojbt1qGQhWkP/5XEApVklsJYT7GzqWM4fCeUGZPPUVyUlomrfZz+vR22rcvGD1JhRCWoXfvjIUqgDVrruavQtWoUaOMGYcQwohCQkKIjIzMuiFw584z3nvv7P/HpsqoXAUnvp75CqXLFDVmiEIIkW0tW1agdGlHHj6M11q+YcMN5s9/FTs76zyKzDgktxKicFIqVfz12xX+Wa7/kV87O0hO/oOxXw6lvOd7OdqPTFQjhNCnTp1S+Pi4ERQUpbV8+/Y7REUl4ubmYNZ4pFAlRAETEhJCjRo1iI+Pz7oxpYERgLPOV6tUd+OLaS/j4pY305IKIcTzbGys6N3bh/nzz2ktj4pKZPfuu7z2mnfeBGYkklsJUfgkJqTy63cnOX4gXG+bMh5Fad81kT8WXJSJaoQQJqFQKBgwoAZff609qHpKipL164MYNqyOWeOxrIeyhRAGOXbvGElpSdhb29O0QlOt1yIjI4mPj2fslzMo71lF7zbuhyaxcPo94mJ1dy/3quLAlFnNcSyqe2wUIYTIC337VstQqAL4++9r+b5QJYQwn8xyKXOJfpLI958c5cbVKL1t6viVYuK3TThzfLsZIxNCFEb9+1fPUKgCWL36av4sVB06dIh9+/Zx+/ZtYmNjWb9+PTExMfzxxx8MGDCA4sUzjiAvhMi5Pmv7aKZUDh0XqrNNZnfcgm8+ZfHMg3qLVHCbd8d0kCKVEMJsDB3k19FRRalSdjx6pP248oYNQSxY0A5Hx4Jx3ZLcSgjTMiSXMqWwkFimjD9MxH39PeA7967M0FF1sLHJ8UTtQghhMB+f4vj5uXP6tPb4mPv33yM8PI5y5ZzMFkuuClWPHz9mzJgxnDp1Ckgf+FM9sGd4eDhz585l5cqVLF68mLp16+Y+WiFErt2+Ec1XYw4R+1T3mFQeFSEsZBkORTqZOTIhRGEU9fgRCisrBg4cmI21ugLNtZbExaXy228nGDXqFaPGZ26SWwlR8F0+H8kPnx4lLjZF5+vW1gqGj6tHh27SS1QIYV79+1fPUKhSqdJ7ro8d29BsceS4UJWcnMw777zDtWvXcHJyolmzZpw/f56HDx8CYGVlhaurK9HR0QwdOpQtW7bg4eFhtMCFKMw+aPQBMUkxFLMvlq31bl2P4uuxh4mN0V2k8q1filYdnjD3R92vCyGEsT2Li0GlVGb5uPLzQu4kMOu7kAzL//rrRr4uVEluJYT55DSXyq2zgTH89dsNUlN0z9rn7GLHJ981wbd+KbPGJYQQAH37VmfixAOoVNrL16zJJ4WqVatWce3aNerVq8f8+fMpXrw4AwYM0CRTPj4+7N69m3fffZdz587x+++/M3nyZKMFLkRh9lnzz7K9zs1rUXw15hDP4nTfvavtV4rJPzXj+MGtuQ1PCCGyLTsDBHv7qFj3xxPCQuK0lh8//oSIiGe4u+fPWUoltxLCfHKSS+WGSqUCWvLnovt625Qr78QX01+mbHnzPV4jhBDPK1/emRYtynPggPYj0SdPPuDGjSiqVnUzSxw5fuB569atWFlZMW3aNL3jJDg5OTF9+nSsra05dOhQjoMUQuTOjatP+DKTIlXdhqWZ/FMz7B1kfgUhhOVTKBS06uCZYXlamoq//tI/vbulk9xKiIJJqVQxc+ZNoIveNtV8i/PjwlZSpBJC5LkBA2roXG7OHCvH30pv375N5cqVqVChQqbtPDw88PLyIiQkYxf97EhISGDp0qVs3bqV0NBQihYtiq+vL4MGDaJly5Y52uaFCxdYsWIFp0+fJjIyEnt7e6pUqULnzp3p168fdnZ2uYpZCEsQdPkJX487RPyzVJ2v12tcms9+aIa9vbWZIxNCiJxr0b4Cq5ZczrB85corfPSRXx5ElHvmzq2EEKaXmqrk3Xf/ZdWqe3rbNGlZjrFfNpZcTAhhVIZOVPOiKlVSsLZWkJam/fzfqlVXmTy5iWbsTFPKcaFKqdT9XLUutra2WFvn/MIbHx/PkCFDOH/+PLa2tlStWpXo6GgOHz7M4cOHGT16NKNGjcrWNlesWMGPP/6IUqnEwcEBb29voqKiOHfuHOfOnSMgIIDffvsNJye5qyHyr2uXHvPNuMMkxOsuUjVo4s6n3zfFThIjIUQ+4162KLXqleTyuUit5adPR3DlSiQ1a5bMo8hyzpy5lRDC9BITU+nfP4BNm27qbdO1bxUGv18Ha2vTf/ETQhQOOZuo5kVDgZpaS65ff8LZsw9p0MA9V/EZIseFKg8PD4KDg4mLi8u0mBMVFcWNGzfw8vLK6a6YMmUK58+fp0aNGixYsICyZcsCsGnTJj7//HPmzJlDgwYNaNasmUHbO336ND/88AMqlYphw4bx0UcfaXpPHT9+nIkTJ3L+/Hm+/PJLZsyYkeO4hTCVhosb8iDuAWWcynBq+Cmdbe7cTGDZLP1FqobNyvDJd02wtZMvOkKI/KlVh4oZClWQ3qvqhx9a5EFEuWPO3EqIws6QXCo3YmOT6dZtI/v26e5JpVDA26Pr8PobVY2+byFE4ZaTiWpetHtrENs3qDIsX7nyilkKVTkeo6ply5akpKQwbdq0TNt99913pKWl0bx580zb6RMSEsLmzZuxsrJi+vTpmiIVQPfu3Rk2bBgAc+bMMXiby5YtQ6VS0bp1ayZOnKj1iF+TJk346aefgPSxIu7f1z/goRB55UHcA8Jiw3gQ90BPCy+WzLint0jV6OWyUqQSQuR7TVt5YGuXMZVZteoqSmXG5MrSmSu3UktISGDOnDl07NgRX19fXnrpJd555x0OHDiQ421euHCB8ePH06pVK3x9ffHz86Nv37788ccfJCfLjLLCcmSdS+VcZGQ8bdr8rbdIZWOjYMI3L0mRSghhUuqJanLy0/zVKkDGz+1Vq66QkpJm8thzXKh65513cHFx4Z9//mHUqFH8+++/xMbGAnDr1i22b9/OwIED2bZtG0WLFmXIkCE52o+/vz9paWnUq1ePKlUyVgMHDBgAwJkzZwgPDzdomydOnACgSxfdAxo2bdqUokXTZwy6dOlSTsIWwqTKOJXBw9mDMk5lMrx25kwUMIykJN1f0l5qXo6PpUglhCgAnJztaPRy2QzL792L5cAB/ePBWCpz5VaQPqzC4MGDmTt3LqGhoVStWhVHR0cOHz7M8OHDmTt3bra3uWLFCvr27UtAQABRUVF4e3vj6OjIuXPn+P777xk4cCBxcXFZb0gIM8gsl8qN0NBYmjf/i1OnInS+bmen4POfX+blNuWNul8hhDAme3sr4EKG5Y8eJbB9+x2T7z/Hj/6VKFGC+fPn8/7777N792727NmjeU1dAFKpVDg6OjJjxgzc3XPWPezcuXMA+PnpHhjV3d0dDw8PwsLCCAwMpHv37pluT6lUMnPmTB48eEDDhg11tkmfPjZdWprpq4VCZJe+Lur794cwevR5wF7n601almPCNy9hY5PjGrUQQliUVh0qcnRfWIblK1deoXXrinkQUc6ZK7cCGVZBCFM87hcU9IR27dYSEhKrp0U8742vTv3Gpn9sRgghcu8UkLFmsnz5Zbp2zdkjhYbK1bdVPz8/Nm/ezKBBgyhbtiwqlUrzU6JECXr37s2mTZto0SLn40TcvXsXgIoV9SebHh4eAAQHB2e5PSsrK1q0aMEbb7xBmTK676AcOnSIZ8+eAVC1qnTJFfnDnj13ee21DSQm6h6Mt1krDylSCSEKnAZNylDUKWMP0bVrrxMXl/8eNTNHbiXDKghhfGfPRvDKK2v0FqlKlrQD5uNVpYh5AxNCiBy7TdmyDhmWBgTcIjIy3qR7znGPKjV3d3cmTZrEpEmTiI+PJzY2FkdHR5ydnY0RH48fPwagePHietu4uroC6YOL5tazZ8/44YcfAPD19aVy5cq53qYQprZrVzBdu24iMVH3mFQvtynP2C8bSZFKCFHg2NhYUa+xM0f2Rmstj4tLYe3a6wwdWjtvAssFU+dW6mEVGjRooHdYhYULF2qGVShXrlyW2zR0WIVnz55x6dIlreKYEPndoUOhdOmygZgY3cVxb28XZs6sSbduuh8HFEIIy6Sic+cyLF0arLU0JUXJmjXXGD26gcn2bNRvrY6Ojri7uxstkQJITEwE0Loz9yJ7e3uttjmVnJzMmDFjuHPnDtbW1kyaNClX2xPCHP799w6vv75Rb5Gq+asVGCdFKiFEAdboZRedy5cty//jTJoitzJ0WAWAwMDALLenHlbh22+/lWEVRKGzdest2rdfp7dIVbt2SQ4f7k/58tKTSgiR/3TpovsptBUrLpt0vwb1qLp3zzgDklaoUCHb61hbW6NUKlEoFHrbqJMfK6ucfxFPTEzkww8/5ODBgwBMnDhRbwInRF774dAPxCTFcP9uKn99UI6kJN1Jf8v2FfhwUkOspUglhCjAynvaA2GAh9byI0fCuHr1MTVqlMiTuDKTl7mVocMqhIWFZWtYhczIsArC0qhzqWL2xfis+Wc52sbq1VcZPHg7qam6h11o2rQcW7f2xM3NAXniVQiRH1Wo4Mgrr3hw+LD2eKCnT0dw8eIjatcuZZL9GlSoat++fa53pFAouHLlSrbXc3R05OnTpyQlJelto57uWN2zKrseP37M+++/r7nD+MEHHzB06NAcbUsIc5h3ch5hsWEQ4wJJk3W2adisGB9+3ghra/1FXiGEKAjSb2YFAj0yvPbbbxeZNq2VuUPKUl7mVjKsghD/5VIezh45KlTNnXuG0aP36n29Qwcv1q/vStGi+p8KEUKI/GDIEN8MhSqAZcsu8uuvbUyyT4O6WTw/kGdmPwAODg5YW1trLbeyssq0R1Rm3NzcAIiOjtbbRp1ElSiR/Tumt27dok+fPpw7dw6FQsFnn33Ghx9+mKNYhTCXhATdj/n95yR9h5aRIpUQohA5i51dxrRmxYrLJCdb3qNmeZlbybAKQuScSqViypSjmRap+vatxubNPaRIJYQoEPr08aFIkYx9nP744woJCSkm2adBPaqenx5ZTalU8vnnnxMYGEjPnj3p378/1atXx9bWFoDbt2/zzz//sHLlSlq1asXs2bNzFKC3tzfBwcGEhobqbRMWll7d8/Lyyta2T5w4wahRo4iJicHe3p6ff/6Zjh075ihOIcxl9eqrRC/uA1apkJpxpqtu3cri778WK6uBeRCdEELklQTati3F9u3agxU/epRAQMAtevb0yaO4dMvL3EqGVRAC1vZZS1JaEvbWhj+RoVSqGDt2H7Nnn9Hb5r336jJvXlusrWXYBSFEwVCsmD19+1Zj+XLtcamiohJZv/4GAwfWNPo+DbqCenh4ZPg5ePAgJ0+eZPz48UydOpXatWtrEilILzB9+umnfP755+zdu5fFixfnKMC6desC/w38+aKIiAjCw8MBqF+/vsHbDQwMZPjw4cTExODq6sqKFSukSCUs3vLllxg4cCvKEE8IrgyhXlqvv/tuHSZPrg6odK4vhBAFWffuumenW7LkgpkjyVpe5laOjo4AJh9WYfDgwRw4cACQYRWE5WlaoSmtvFrRtEJTg9qnpKQxZMj2TItUn332EgsWvCpFKiFEgTN8eF2dyxcvNk2OleOr6F9//YWbmxvDhg3LtN2AAQMoWbIkmzZtytF+1MWjwMBAbt++neH11atXA9C4cWPKly9v0Dbv3bvH+++/T2JiImXKlGHNmjXZKnIJkRcWLz7P0KE7UOmpQX3wQT0WLmyHlZU87ieEKJz8/FypXNk1w/J//w3mzp1os8eTXebKrWRYBSGyJyEhhV69NrNypf4x4aZPb8nUqc1z/EiuEEJYsiZNyuLrWzLD8kOHQrl69bHR95fjQlVISAgeHh4GXYzLlCnDgwcPcrQfLy8vunTpQlpaGqNHj9bMVAPg7+/P0qVLARg5cqTOGG/dusXDhw+1lk+ePJnY2FgcHBxYtGgR3t7eOYpNCHOZO/cM7723S+/r48b5MWdOWylSCSEKNYVCwTvv1M6wXKWChQvP50FE2WOu3Eqd95hqWIV+/foRFhaGvb09v/76K0OGDMlRnEJYgqdPk+jYcT1bttzS+bqVlYJlyzowfnwjM0cmhBDmo1AoGD68js7XTNFz3aAxqnRxc3MjJCSE1NRUbGz0b+bZs2fcvHmTkiUzVt8MNXnyZIKCgggKCqJTp074+PgQExOjSaLGjh1Ls2bNMqw3ZMgQwsLC6NGjBz/++CMAFy9e5Pjx40D64KTffPNNpvseMWIELVu2zHHsQuTWL7+cZMKEA9oLSzwEKyUorfhs+Ot8//0rcgdPCCGAoUN9+eqrI6SkaE8Xv2zZJb755mUcHHKc+picuXKrunXrsnfvXpMNq5CYmIirqysLFy6UHuvCYl2PvE6qMhUbKxuqlayms83Dh8/o1GkDZ85E6Hzdzs6aNWs6W9wYeEIIYQoDB9bk448PkpioPbHXihWXmTq1uVFzrBxvyc/Pj23btjFjxgw+/vhjnW3SZ8WYQmJiIq+88kqOg3Rzc+Pvv/9m2bJlbN++nVu3bmFjY0Pjxo0ZOHAgHTp0MHhbJ0+e1Pw9OjqaM2f0P2cO/03hLIS5qVQqJk8+zNSpJzK+OHgxFHtKMUrx/Zc/SZFKCCH+r0yZovTq5cNff13TWv74cQJr117nrbdq5VFkWTNXbtWxY0dmzpypGVbhxZ7lxhhW4ffff5ce68Kitf2jLWGxYXg4exA6LmPvwhs3oujYcR23bz/VuX6RItbMmFEbL6+4LL9PAFy9ejXXMQshRF5yc3PgjTd8+OMP7cegnzxJZN26IKMOqp7jQtWwYcP4999/+f3337ly5Qrdu3fHx8cHR0dH4uLiuHr1Kn///TeXL1/Gyckpy/EWsuLo6Mjo0aMZPXq0wevs3Ztx2ti3336bt99+O1exCGFqaWlKPvhgD4sWZf6oirOznRSphBDiBe+/Xy9DoQpg3rxzFl2oMldupR5WISAggNGjRzN//nw8PT0Bw4ZVSElJwdnZmdKlS2uWy7AKoiA5fjycLl028vhxgp4Wz0hIWMbIkffMGpcQQuS14cPrZihUAcyZc8YyClU1atRg6tSpfPHFFxw/fpwTJzL2+lCpVLi4uPDrr79SoUKFXAUqRGGRlJTKwIHbWLcuSG+bViVfp3Ite9wc3MwYmRBC5A+vvOJB7doluXgxUmv5iRP3OX36AX5+ZfIossyZM7eSYRVEYdfftz9RiVEZcil//5v06xeQ4dEWNRc3G4aPq0WZcvOytb/Tx/ezesmMHMcrhBCWoFmzctSqVYLLl7WfPAsMfEBg4H0aNy5rlP3k6iHCrl27Ur9+fZYuXcrBgwe5f/++5rVy5crRoUMH3nnnnVyNTyVEYRIXl0yPHv7s3n1Xb5t589ry/vsTzBiVEELkLwqFgvffr8fIkbszvDZ//jmWLeuYB1EZxly5lQyrIAq7ae2nZVg2b95ZPvxwL0ql7imWS5a25ft5bXEvWzTb+wu9q3swdiGEsGS6Hlvu2rVkhkIVwDff7Obbb//ruZ6cnIydnV2O9pvr0a4qVKiguXOWlJTE06dPcXV1zXFAQhRWjx8n8Npr6wkM1D2Lk7W1ghUrOvHmm8brUimEEAXVm2+mD/gZG5ustXz16mv89FMLSpZ0zKPIsmau3EqGVRAinVKpYtKkQ/z0U2Amre4yelKbHBWphBAiv4l6/AiFlRUDBw7U8aodMBkoorV027Ywtm17H4gD0ocayOlQAEad+sbe3l5rvAIhhGGCg5/SqdN6rl17ovN1Bwcb1q17nc6dK5s5MiGEyJ+cne0YNKgm8+ad01qemJjKwoXnmTy5ad4Elk2SWwlhWvHxKQwevD3TIRdatizJgQOTcHJub8bIhBAi7zyLi0GlVDL2yxmU96yS4XX/vx5ycFfUC0tt6Nh9Nu1eT+/1/cfczIcCyIxVjtcUQhjFyZP3eemlVXqLVC4u9uza1VuKVEIIkU2jRtXXuXzu3LMkJekef0YIUXiEhsbSvPlfmRapRo6sy7RptYEU8wUmhBAWorxnFSpX883w039YY3TN6XXi0DMqetekcjVfbGxsc7xfo/aoEkJkj7//Tfr3DyAhQfcXphIl7Jg7tw6Ojg85c+ahZvmo46N4kvSE4vbFmdtkrtY6Mv2xEEKkq169BK+9Volt2+5oLY+IiGfNmmsMGeKbR5EJIfJa03mtOXX1Fqk1i8CZd3W2+fHH5nz8cWPOnj1r5uiEEMKylfVwwq9pGU4d1R62JupxIkf3hdKyfcVcbV8KVULkkdmzzzBmzF5UusfrBB7z+PES+vfXMejsOKAYEAN+H/iZLkghhMjnxo1rmKFQBTBjxikGD66FQtftQCFEgfbXX9c4fvsslHoK9i4ZXre1teL33zvKuKBCCJGJzr2rZChUAWxaE0SLdjmfmRikUCWE2aWlKZkw4QC//npab5tSZWDkhMa4uGWcGhzg+/B3eZr2GBe3Eny+bInWazL9sRBC/KdNm4rUqVOKCxceaS2/eDGSPXtCePVVzzyKTAhhbqmpSr744jA//hgIH1lDqjWkWWu1cXNzYP36rrRunbveAEIIUdDVa1Sa8p7OhN6N1Vp+58ZTzp96qGctw0ihSggziotL5q23trFp081MWl1lzOSu1KpXR2+L36od0/uaTH8shCis9D363KtXyQyFKoCvvtpD8eL1gNxNoSyEsHyPHsXTv38Ae/aEpC+Y9VmGNtWrF2fLlh5UqeJm5uiEECL/USgUdOtflXk/nsnw2sbVQbkqNkmhSggzCQ5+SteuG7l4MVJvm169yrF+/Sc4FOluvsCEECKfy3wKZQBr4DNA+xGfo0ef4Of3OhCeqymUhRCWLTDwPr16bSY0NFZvm44dvfjrr9dxcbE3Y2RCCJG/tWpfkdVLrhD1OFFr+fmTD6lbX+8YN1mSQpUQZnDgwD16995MZGSC3jY//dSCtm2tWb9eacbIhBAi/8tqCmWA3Vsfs31DxhsFdfy+YPD7HrmaQlkIYZlUKhWLFp3no4/2kZycprfdmDF+TJvWEhsbmRBdCCGyw9bOmi69q7By0aUMryUmKCGHHVSlUCWEiS1ceI7Ro/eSmqq7AGVvb80ff3TijTeqc+ZMxm6TQgghDKOeQlmX0mWT2bd9O4kvzLJ68UwcdvYVczWFshDC8sTHp/D++7tZseKy3ja2tgo++aQaPXq4cOHCOb3tZEZlIYTQr0P3Sqz941qGHCs5KecdMKRQJYSJpKSk8dFHe1mw4LzeNiVKFGHTpm688kr5bG3739A1JKY9w8G6KB3K989tqEIIUeA5F7OjUw9vNq4O0lquUsH6ldfzKCohhClcvhxJ375buHxZx8zJan57SbE7ynfbn/Ldd+aLTQghChonZzvad63E5r9vaC3XP7t91qRQJYQJPHjwjH79tnDgQKjeNrVrl8TfvzuVKrlme/v/3JnD46QHlLAvI4UqIYQwULd+Vdm67ibJydp3+A7uvkfdurnIpoQQFkGlUrF48QXGjNlHYmKq3nZVazgS0fUEMaqnuFiX4Mv3f890uzKjshBCZO71N6qwdd1N0tKMk09JoUoIIzt8OJQ33tjC/fvP9Lbp0aMqf/zRCScnmWFKCCHMxbW4A6++Xolt67VnR1WmqUhIUOLmmjdxCSFyLzo6kXff3cm6dUGZtuv1VjUGDKvF8KPfQhLY2NjqfWRYTWZUFkKIzJVyd6RVh4rs2XbXKNuTQpUQRqJSqfjqq91MnXoh00ry8OFevPtueYKCMg44Z+gYCCOqf0uyMgk7K5mZRgghsqNHfx92+t8mNVX7Op2UKBNZCJFfHTsWTv/+Ady9G6O3jUMRK8Z80ZgmLTwAyaWEEMLYeg+uzr5/Q1AaoVeVFKqEMILY2GT699/A1q36H/WDZOAvFi++yOLFudtfo1Jtc7cBIYQopEqVcaRVR092BwRrLc/NOApCiLyRmqrkhx9O8M03R7N43CSUMV801xSpQHIpIYQwtrIeTrQ2Uq8qKVQJkUtXrkTSq9dmrl17oreNWwkbho7yxKPi95luS8ZAEEII0+v1VjX2br9rlDt+Qoi8ERT0hEGDtnPixP1M2w0YUIHVqz+llLsUpoQQwtSM1atKClVC5MJff11j2LB/efYsRW+bBi+5M+bLRhRzybpruYyBIIQQplfWw4lXO3uxc/OdvA5FCJFNKpWKhQvPM378fhIS9A+YXqJEEZYv70i5ck9ZvTrNfAEKIUQhZqxeVVKoEuL/QkJCiIyMNKhtQkIa06cHsWmT/rt4CgX0e7smfQZXx8pKYawwAYhJjkKFEgVWFLNzM+q2hRCiMHhjSHX27bhLSrKMTSVEfhEeHsc77+xgx47gTNu1bFmeVas64+HhzJkzZ3S2kVxKCCFMQ92rKjekUCUE6UWqGjVqEB8fb0DrMsCb//9TN+didoz7qhH1X9LfJjfGnujM46QHlLAvw7LmR02yDyGEKMhKlnbktZ6V8f/rRl6HIoQwwD//XGPkyN08eZKot421tYIvv2zK5583wdraKtPtSS4lhBCmUdbDiTadPLmZce4wg0mhSgggMjKS+Ph4xn45g/KeVXS2UalUHDvwFP+/HpKaov+Z2wpeDnwxvRWlyxQ1VbhCCCGMoNfAavzrf4fETB4fEkLkrbNng/j00+Ps3Pkw03aeno5MmVITX18Hzp8/p1lu6IzKQgghjKf/OzX5blzO15dClRDPKe9ZhcrVfDMsj4tJZt7PZzi2PyKLLRxj1KeDTF6kqlv8ZWJTonG2dTXpfoQQoiAr5mpPt35V+ft3+SIrhKVRqVTMm3eE0aP3AFnlVUe4e3crgwfrHzP0RZJLCSGE6ZQoVQSHIpn3bM2MFKqEyMK1i4/55etAHkXofyzQoYgNrToo2bFpAza2Q0we04e1ppl8H0IIURh061eVf/1v53UYQojn3L8fx8iRu/H3v0lmRapirjb0G1qGar5vA2/rbKNvRmXJpYQQwrSKOFrneF0pVAmhR2qqkr9/v8r6lddQZjLWbuVqroz/ujE3ru5lxyazhSeEEMIIHIva8ubwWmz9K68jEaJgys5kNSqVioCAB/zyyw1iYzN/JLd52/IMH18f52J2mbaTGZWFECJvKHIxn5gUqoTQ4d6dGGZ+e5LbQdGZtuvatypvjfDF1taKG/LkiBBC5EttOnnx73rjzs4qhMjuZDUuQC+gRqatnJxtGT6uPi3aVTBGiEIIISyQFKqEeI5SqWLLPzf4Y+GlTKcsL+Zqx4eTGtKwWVkzRieEEMIUrK0VFC2a8+7pQgjdDJmsRqlUcWx/NNs2RJKYkEkXdqBJy3K8N64+biUcTBGuEEIICyGFKiE0XFg8I5QbVzO/61e7QSnGftmI4iWLmCmujGZcGkNMchTF7NwY5/trnsUhhBAFhY2t9KgSwlT0TVZz+0Y0i6ef4cbVqEzXd3K2ZuTEhjRr7YEiN8+SPEdyKSGEsFxSqBKFnkqlYsOGMGB8pkUqa2sF/d6pSc83q2FtnbdfaC5HBfI46QEl7MvkaRxCCCGEENmVEJ/KmmVXCFh3E2WaKovWZ5n4bW/qNixv1BgklxJCCMslhSpRqN28GcXw4TvZt+8eoL+HVAUvZ8Z80YjK1dzMF5wQQgghRAFz4lA4S2aeI/JhQqbt3Eo40PzVZDb/vRon535mik4IIYQlkEKVKJTS0pT8+utpvvjiCAkJmc8q8/obVRj4ni/29pYzfsncpjtRoUKBPKoihBBCCMv38MEzls26wIlD4Vm2bd3Jk3dG1+H08e0mi0dyKSGEsFxSqBKFzsWLj3jnnX85efJBpu1KlC7Ch5MaUrdhaTNFZrgiNk55HYIQQgghhAFs+dc/kv07bpCcyUQ1AGXLF2XE+PrUbeRu8qgklxJCCMslhSpRaMTEJPHNN0eZNesMaVmMh9CqQ0WGjamLk7OdmaITQgghhCg4VCoVO3dGABPZuflxpm1tbBT0HFiN3m9Vx86CerALIYTIG1KoEgWeSqVizZprTJiwn/v3n2Xa1rW4DaM/ewm/pjKwphBCCCFETpw//5CPPtrLgQOhQObje9aqV5KRE+tT3rOYeYITQghh8aRQJQq0S5ceMWrUnv8nSlk5ysQpg6hVz/KLVMce7iApLRF7awealu6Y1+EIIYQQQhAaGsvXXx/l998voVRm3nvd2cWOIR/Upk0nTxQK848TJbmUEEJYLilUiQIpPDyOr746wm+/ZZ0o+fi48fHHlRg2bCIORYaaKcLcWXp9imZKZUmuhBBCCJGXoqMT+fHHQGbNOkNiYuaT1CgU8GoXL956z5dirvZmijAjyaWEEMJySaFKFCgxMUlMm3aSX345leVsfra2VkyY0IgvvmjC1asXzRShEEIIIUTBkJCQwvz55/j++xNERSVm2b5G7RK881FdqlTP/HFAIYQQhZsUqkSBkJiYypIlF/j222M8epSQZft27TyZM6ct1aoVN0N0xjeg8jiS0uKxt3bM61CEEEIIUcjEx6ewcOF5fv45kIiI+Czbu7jZ8Pbo+rRoVyFPHvPTRXIpIYSwXFKoEvlaQkIKixdf4KefArMcKB2gfHlnZs5sRa9ePhaTKOVE23K98zoEIYQQQhQyz54ls2DBeaZNO8nDh1kXqOzsrEhO3skn342kZt2KZojQcJJLCSGE5ZJClciXnj1LZtGiCwbfybO3t2bsWD8mT25C0aJ2ZohQCCGEEKJgePjwGQsWnGfu3LNERmbdc12hgEGDatGnTzG6dBmPvcMHZohSCCFEQSGFKpGvhIbGMn/+ORYtOs+TJ1mPhaBQwMCBNfnuu1eoWFGmPRZCCCGEMNSVK5H8+usZ/vjjMklJaQat89prlfjxxxbUrl2KM2fOmDhCIYQQBZEUqkS+EBh4n19/Pc3atUGkpioNWufVVz35+ecW1K/vbuLohBBCCCEKhtRUJdu332HBgnNs337H4PWaNCnLDz80p1Ury3rETwghRP4jhSphsZ4+TeKvv66xbNlFTp58YPB6jRqVYcqUl+nQwStfj0OVmXcONdNMqbys+dG8DkcIIYQQ+VxISAzLll1k2bKLhIXFGbxes2bl+OqrZrRr55mv8i7JpYQQwnJJoUpYFJVKxcGDoSxbdpF164JISEg1eN0mTcry1VfNCnSBSgghhBDCWJ49S2bz5lusXHmFHTvuoFIZvm7z5uX56qumtGlTUfIuIYQQRiWFKpHnVCoVW7eeZ+3aIHbtesj9+1mPPfW8unVdGD68EvXqOeLgEMXZs1HZjuHq1avZXicveTvXoqRDWYrZFs/rUIQQQgiRj6SkpLFzZzCrV19j06YbxMcbflMQ4PXXKzN+fENatCifrwtUkksJIYTlkkKVyBNKpYpTpx6wceMNVq++TEjIs+xuAbgIHOL8+bt88AFYWVmhVBo2flV+93m9JXkdghBCCCEsWEhICJGRkQAkJKRx7NgTDhx4xKFDkTx9mr3ilIODDUOG1GLMGD+qVSsYhR3JpYQQwnJJoUqYzdOnSezcGczWrbfZvv0ODx/GZ3sbDkWsaNLChZfbuFG8ZA3gDQBOH9/P6iUzGPvlDMp7Vsn2dtXrCyGEEELkdyEhIVSr1oTExApATcAHsM32dhSKaMaNe4VPP21ByZKOxg5TCCGE0EkKVcJk4uNTOHYsnP3777F//z2OH79v8Ix9L6paw41Xu3jRol1FijhmPG1D794CoLxnFSpX88329tXrCyGEEELkR9HRiezff49du+4SEHCdxMRxOdqOlRXUrOtElerxbFozlQEDTkmRSgghhFlJoUoYzcOHzzh1KkJTnDpx4j4pKTl/FK+Yqx2tOlSkbWcvPL1djBipEEIIIUT+Fh4ex9GjYRw7Fs6RI+GcPPkApTIbo6G/wKOiE606etL2NU+KlyzCreuX2LRGlatxPPPbGKBCCCEsgxSqRLapVCoePYrn4sVITp58wKlTDzh58gEhIbG53rZDEWsaNSvLy23L49e0LLa2VkaIuOBZfO1rnqU+paiNC8Orf53X4QghhBDChJ4+TeL8+YecO/eI48fDOXo0nLt3Y3K93RKlitD81fK0aFeRSlVdtAZHj3r8CIWVFQMHDsz1fiyR5FJCCGG58k2hKiEhgaVLl7J161ZCQ0MpWrQovr6+DBo0iJYtW+Zom+Hh4cybN49Dhw7x5MkT3NzcaNq0Ke+99x6VK1c28jvIfxITU7l3L5Y7d55y9epjrlxJ/7l69QmPHycYbT/29lYkJZ1l0MhOdO7VCHuHfHNa5pkTj3byOOkBJezLSHIlhBAiRyS3sjyJiancvh3N9etRXLz4iHPnHnHu3EPu3HlqtH2ULF2Exs3L0bRlOWrWLYW1te6Z+57FxaBSKnM8/idY9higkksJIYTlyhcVgfj4eIYMGcL58+extbWlatWqREdHc/jwYQ4fPszo0aMZNWpUtrZ5+/Zt+vfvT3R0NM7OzlSrVo3Q0FD8/f3ZsWMH8+bNo3nz5nrXT01N5cyZM7l6X0lJSdjb2+dqGyVLlqRixYoGtVWpVCQlpfHsWQqPHycQGan98/BhPCEhMdy9G0NISCwPHmR3Jj7DlSljT/PmJXnllRI4Oz/k7bf/pG7DN6RIJYQQQpiB5Fb6ZSe3yq7k5DTu348jLCyO0NBYwsLiuHUrmqCgKG7ciOLu3RhUOX96Ty+vyi681KIcjV8pi7ePq1bPqazkdPxPkDFAhRBC5Ey+qApMmTKF8+fPU6NGDRYsWEDZsmUB2LRpE59//jlz5syhQYMGNGvWzKDtpaamMmLECKKjo+natSvffvstDg4OJCcn89NPP/Hnn38ybtw4du7ciZubm85thIaG4ufn9/9/KQAHoCjg+MKfDqTPsmJN+uF+8cf6uW1g4N8Vmr9bWVlTt25dbG3tUKnSi1EqFSiVKhISUklISCU+PoX4+PQ/TZH8GCYRCAZuAVd58CCCtWth7dq8iid/m9rwb5SqNKwU1lk3FkIIIV5g+bnV86wAO9LzKfWfz//d+v9tFCgU1v/PdRSaZemUgOr/f+r7uwpIw97ejtWrV1G2bBlU/0+c1PnT8/9OTVWSkJBKYmLq//9MIyEhhdjYFJ48SSAqKoknTxKJikr/efDgGRER2Z/xOCdKlLDj8eNj9Hu7M+1eb0CJUkXMst/8RHIpIYSwXBZfqAoJCWHz5s1YWVkxffp0TSIF0L17d+7cucPChQuZM2eOwcnU5s2buXv3LuXKleP777/Hzs4OADs7OyZPnszVq1c5ffo0y5cvZ+zYsTq3oVQ6UbzkNJISrYl/lpZnBSClEs6efZI3O8+Enb0C76qOVK5WhMrVHSlf0QFrm7o621pyt3BL5V6kQl6HIIQQIp+y3NzKkUpVpqFUOZAQryT+WRoJ8UrSUg1PsoyRjyUlQa9ee3O/ITMqWbIITZuWo3XrCrRr50lSUggNG35Eo5cHSJFKD8mlhBDCcll8ocrf35+0tDQaNGhAlSoZn48fMGAACxcu5MyZM4SHh1OuXLkst7lx40YAunbtqkmk1BQKBf369eP06dNs3bpVbzIFtjyJBEjL5jsqiFIp71kU3/rlqFzdjarVi1PByxlrG8MGQpdu4UIIIYT5WG5uZc+dm5DeC1voo1CAr29JmjXzoGnTsjRr5kGVKtqP8505cy8PIxRCCCFyx+ILVefOnQPQ0xUc3N3d8fDwICwsjMDAQLp3757p9pRKJRcuXMh0mw0aNADg3r173L9/X+tOY2FXrpwDlSoVpVIlR7y9i2Jt/YivvnqXsV9uzPH4BUIIIYQwH8mt8g97eyuqVHGiWjUnfHyc8PFxpkqVohQtqk7hk4mNvcPZs9rrXb161eyxCiGEEMZi8YWqu3fvAmQ6qKU6mQoODs5yexERESQmJma6zbJly2JtbU1aWhrBwcGFLJmKB6KA6Bf+fAw8JDw8hfBwOHIkzwIUwMUnx0lVJWOjsKN28SZ5HY4QQoh8RHIrSxQNRP7/5xEKxWNUqockJT3m8mUlly/nbXQFkeRSQghhuSy+UPX48WMAihcvrreNq6srAFFRUQZvL7NtWltb4+zsTHR0tEHbNJSdnRU2dtbY2lqhTEsiNuYR7uU8sHdwANK7cgMo0PxFe/n//6JQpP89KSmBe3euU7t2bZycnDTL1X8WKWKDo6MNjo62ODra/P/f6X8vXtyB2NgIJk36iDeHj8C7qhdFnayxtTPscT01GV8qb/x6eZxmSuVlzY/mdThCCCHykYKUW1kyaxso6mSDo6MVRYpaU9TJGhc3m/QfVxtci9vi4pr+bzv7//IvdW419ssZlPfM+GimISQ/y5rkUkIIYbkUKlXezQNniBo1aqBUKlmyZAktWrTQ2WbChAls2bKF7t2789NPP2W6vVOnTvHmm28CcOHCBb1TGLdo0YKIiAimTp1Kr169tF6rXbs2SUkpqHDC2soKhRVYWaUXh9R/Pr9M1wzASUmJxMVE4+JWAhsbWwOOREapqSk8jXpM6dKlM4wHYYjk5GQePnyYqxiM8T4sYRuWEEN2thGV9kgzU42bdSmjxpHfjoUpt2EJMVjKNiwhBkvZhiXEYCnbsIQYjLWNuJgobG1tuXjxYo7Wz08sObdKUzphZaXASvFfPpV+Aw5QpN/K++/f/2/z/22kpCQR/ywOp2IuWFvbpC9XAKr0+fw0VFp//P8v6f9KS0vjWVwsLi7p2wB05nFq6lj+u1GYPgNiZOQjXNyKF/rfK0u+xmSWS5kzDnOtX5C2YQkxWMo2LCEGS9mGJcRgKduwhBggd7mVxfeosra2RqlUag0Q+SJ1rc3KKuveQM+3yek27e3tUSgUlCrlkuX+9HJ2pHRJ/XcyDVXCLecx2NnZ4eTklLsAjPE+LGEblhBDNrbhgqfp4shnx8Kk27CEGCxlG5YQg6VswxJisJRtWEIMRtpGcuKzHN30yY8KbG5FUSD3uRWlcxNDumLFcpFfWcjvhEVsw4QxZJpLmTGOfBWDpWzDEmKwlG1YQgyWsg1LiMFStmEJMZC73MriC1WOjo48ffqUpKQkvW2Sk5MB9N7Be3F7aklJSXoPXGbbPHXqVJb7EUIIIYSwRJJbCSGEEMKSZW9Aojzg5uYGQHR0tN426rEOSpQoYfD2MttmamoqsbGxBm9TCCGEECK/kNxKCCGEEJbM4gtV3t7eAISGhuptExYWBoCXl1eW23N3d8fZ2TnTbd6/f5+0tDSDtymEEEIIkV9IbiWEEEIIS2bxhaq6desCcO7cOZ2vR0REEB4eDkD9+vUN2madOnUAOHv2rM7X1cs9PDxwd3fPTrhCCCGEEBZNcishhBBCWDKLH6OqY8eOzJw5k8DAQG7fvq25C6i2evVqABo3bkz58uUN2manTp04cuQIGzZsYNiwYRnGUvjrr78A6NGjhxHeQfa1adNGcyczK40bN2blypVZtgsNDaVt27aZtqlevTr+/v4G7Tc/i4qKYsmSJezZs4fw8HBsbW3x8fGhR48e9OnTx6CBY18UHh7OvHnzOHToEE+ePMHNzY2mTZvy3nvvUblyZRO8C8tj7OMq5+x/wsLCWLRoEYcPH+bRo0eUKlWK+vXr8/bbb1OrVq0cbVPOWeMf18J+zv7111989dVXfPfdd/Tp00dnm6ioKBYsWMCePXuIiIigWLFiNGjQgGHDhlGvXr0c7TcoKIgFCxZw4sQJYmJiKF26NC1atGDkyJFSENGjMOZWxiLXY9OQ67FxyfXY+PLimJ44cYJBgwZl2qZt27bMnz8/29u2JIYc25y01aewXHPNeVxNcc21+EKVl5cXXbp0ISAggNGjRzN//nw8PdNn6fD392fp0qUAjBw5MsO6ISEhpKSk4OzsTOnSpTXLu3btyuLFiwkJCWHChAlMnToVJycnkpOT+fnnnzl9+jTOzs4MHDjQPG/yBb6+vplezJOSkrh8+TKA5lhk5dq1awC4urpmSEjVCkNX/LCwMAYOHEh4eDg2NjZ4eXkRHx/P2bNnOXv2LPv27WPOnDnY2ho+Beft27fp378/0dHRODs7U61aNUJDQ/H392fHjh3MmzeP5s2bm/Bd5T1THFc5Z9MdO3aMUaNGERcXh7W1NT4+PsTHxxMQEMDWrVv55JNPGDp0aLa2KeesaY5rYT5nL1y4wM8//5xpm8jISPr3709ISAhFihTBx8eHiIgIdu3axd69e5kyZQq9e/fO1n5PnTrF22+/TVJSEm5ubvj4+HDnzh3WrFnDtm3bWLFiBTVq1MjNWyuQCmNuZQxyPTYNuR4bl1yPjS+vjqn6PC5VqhQVKlTQ2aZKlSrZ2qalMeTY5qStPoXlmmvu42qSa64qH3jy5ImqS5cuKh8fH1WNGjVU3bp1U7Vu3Vrl4+Oj8vHxUS1YsEDneuo2n3zySYbXzp8/r/Lz81P5+Pio6tWrp+rZs6eqcePGKh8fH1WtWrVUx44dM/XbyrFPP/1U5ePjo+rSpYsqPj7eoHXmzJmj8vHxUX355Zcmjs6yDRo0SOXj46Pq3Lmz6s6dO5rle/bsUdWuXVvl4+Ojmj9/vsHbS0lJUbVr107l4+OjmjBhgiohIUGlUqlUSUlJqilTpqh8fHxUDRs2VD158sTYb8WiGPu4qlRyzqpUKtX9+/c116k33nhDFRoaqnnt8OHDmtcCAgIM3qacs6Y5ripV4T1njx8/rmrUqJHmM/mff/7R2W7gwIEqHx8f1dChQ1XR0dEqlUqlSktLUy1atEjz2Xvz5k2D9xsVFaXZ77Rp01QpKSkqlUqlio2NVY0ePVrl4+Ojatu2rSopKSn3b7IAktwqe+R6bBpyPTYuuR4bX14dU5Xqv+98ixYtyvX7sESGHtvsttWnsFxzzX1cVSrTXHMtfowqSJ9N5u+//2bUqFF4eXlx69YtoqKiaNy4MbNnz2bEiBHZ3madOnXw9/end+/eFCtWjOvXr6NQKOjQoQNr166lSZMmJngnubdlyxY2bNiAvb09M2fOpEiRIgatd/36dQB8fHxMGZ5Fu3//PsePHwdgypQpWlXdNm3aMGzYMADWrVtn8DY3b97M3bt3KVeuHN9//z0ODg4A2NnZMXnyZPz8/IiJiWH58uVGex+WxhTHFeScBfj999+JjY2lVKlSLFq0CA8PD81rL7/8MhMmTADghx9+yHSa+efJOWua4wqF75xNSkpizpw5DB06lKdPn2ba9sSJEwQGBuLo6Mj06dNxcXEBwMrKiuHDh/P666+TkpLCggULDN7/ypUrefr0KfXq1WPChAnY2KR3EndycmL69OmUL1+ee/fuFdhHe3JLcqvskeuxacj12Djkemx8eX1M4b/zuFq1ajl7ExYqO8c2O22zUtCvuXl1XME019x8UagCcHR0ZPTo0Wzbto2LFy9y9uxZVq5cSYcOHfSus3fvXq5fv86PP/6o83UPDw++//57Dhw4wKVLlzh+/DizZ8+22G6pT548YcqUKQC8//772erqqe6OV1g+sHV58OCB5u/Vq1fP8Hrt2rUztMvKxo0bgfRHHl4cj0OhUNCvXz8Atm7dmu148wtTHFeQcxbgwIEDAPTu3RtXV9cMr/fp0wdHR0cePXrE4cOHDdqmnLOmOa5QuM7Zu3fv0qFDB+bOnQvAmDFjtL5gvkh93rVt25bixYtneL1///4A7Nmzh8TERINiUG9T16MUdnZ2muUBAQEGba8wktzKcHI9Ng25HueeXI+NzxKOaWpqKjdv3gSgatWq2YrfkmXn2Gb3/yErBfmam5fHFUxzzc03hSoBs2bNIiYmBk9PT95++22D13v27Bn37t0DCtaFLrvKlSun+fuVK1cyvK6uBD/fLjNKpZILFy4A4Ofnp7NNgwYNALh37x7379/PVrz5hbGPK8g5q6aedcvX11fn69bW1lSsWBGA8+fPZ7k9OWfTGfu4QuE7Zx88eMD9+/epV68e//zzj86xjJ6nnvFN33lXp04dbGxsiI+P59KlS1nu/+HDh5pJR9Tn7IvUy8+cOUNKSkqW2xQiM3I9Ng25HueeXI+NL6+PKcCdO3dISkrC2dk5Wzm0pcvOsc3u/0NmCvo1N6+OK5jummvxg6mLdEFBQaxduxaAcePGZagCZ+b69euoVCpKly5NVFQUv//+O1euXCEtLQ0vLy86d+6s9xe2IHF3d6dt27bs2bOHb775hnnz5mmSn2PHjrFo0SIAhgwZYtD2IiIiNHdF1Nt5UdmyZbG2tiYtLY3g4GDKli2b+zdiYYx9XEHOWTWFQgGg6UKvS2pqKoBBM4XKOZvO2McVCt85W6ZMGRYvXkzLli2zbKtUKgkNDQX0n3e2tra4u7sTFhbGnTt3aNiwYabbDAkJAdL/L/UNMKu+O5icnMz9+/f17lsIQ8j12DTkepx7cj02vrw+pvBfD5UqVapw+fJlNm/ezI0bN7CysqJq1ap07949Xz4SmJ1jm522WSno19y8Oq5gumuuFKryiSVLlpCWlkalSpVo3759ttZVX+hiYmLo3LkzaWlpmteOHDnCqlWr6NWrF9988022ZmXLj6ZNm8bnn3/Ojh076NSpE15eXiQmJhIaGkqxYsWYNGkSb775pkHbevz4sebvurr5QvqdQGdnZ6Kjo4mKijLKe7BExjyuIOesWoUKFbhx4wZXr16lVatWGV5PSkrS3MEw5PlyOWfTGfu4QuE7Zz09PQ2edfbp06eaL5r6zjtInykmLCzMoPNOfS47OTnpvXHz/GNEUVFRFv/FSFg2uR6bhlyPc0+ux8aX18cU/juPr1+/Ts+ePbVeO3ToEMuXL2f48OGMHTvWoO1Ziuwc2+y0zUpBv+bm1XEF011z5dG/fCAiIoLt27cDMGzYMKyssvffpj55kpKS6NOnD1u3buXixYvs27ePMWPGYGtry/r16/n++++NHrulUSgUVK9eHRcXF82z3+q7IM7OzppB9Qzx/DPm9vb2etupX0tISMhh1JbPmMcV5JxVa9OmDQCrV6/W+YH522+/aQaXNaQrvZyz6Yx9XEHO2cw8f95l1htYfd4ZMn6H+tzM7Dx+/rpTUM9lYT5yPTYNuR6bl1yPjc8UxxT+O4+Tk5MZMWIEu3fv5uLFi+zcuZPBgwejUqlYuHAhS5YsyUX0hYdcc03HVNdc6VGVD6xevZqUlBRKlSpF165ds71+w4YNUalU1KhRgwEDBmiWlytXjpEjR+Lh4cHEiRP566+/ePPNNwvs8/xxcXEMHTqUCxcuUKtWLWbNmkX9+vWJj49n9+7d/Pzzz3z55ZdcvXqVr7/+OsvtPV8wVHdd10WlUmVoX5AY+7iCnLNqQ4YMYf369Tx8+JC33nqLzz//HD8/P2JjY1m/fj1z587Fzc2NqKioTB+bUJNzNp2xjyvIOZsZU5x31tbWWW5PXwxC5IRcj01DrsfmJddj4zPV73Lr1q0pXbo0rVq10prgwtPTk0mTJuHm5savv/7KvHnz6NWrV6a9uYRcc03JVNdcKVTlA+reVK+99lq2xqZS69q1a6YFrq5duzJv3jyCg4PZs2dPgf3AXrp0KRcuXKB06dIsX76cYsWKAemV8z59+lCtWjX69evHmjVr6NSpEy+99FKm23N0dNT8PSkpSe//TXJysmY/BZGxjyvIOatWvHhxFi9ezIgRI7hx40aGcb769euHo6Mjv/32G05OTlluT87ZdMY+riDnbGaKFi2q+bv63NIlO+ed+lzObLr65++eZrdXpxAvkuuxacj12Lzkemx8pjimAAMHDsz09XfeeYfFixcTHx/PkSNHeP311w3abmEl11zTMdU1VwpVFi4oKIi7d+8C6YUqU6lRowbBwcGax7UKoh07dgAwaNAgTTHleXXq1KFVq1bs2bOHgICALAsqbm5umr9HR0fj7OycoU1qaiqxsbEAlChRIjfhWyxjH1dDFYZzFqBWrVps376dtWvXEhgYSGJiIp6ennTr1o369evz6aefAumD2mdFztn/GPO4GqqwnLMvcnR0xM7OjuTk5EzHfFC/Zsh5pz6X4+LiSElJ0TnmwfP7kjvNwhjkemwacj02H7keG58pjqkh7OzsqFKlChcuXCh053FOyDU3b+XkmiuFKgu3Z88eIL3rXN26dXO8nZSUFKysrDTdc1+kVCqBzGddye/UUyB7e3vrbVOlShX27Nlj0C+Ru7s7zs7OxMbGEhoaqnOmk/v372sGlPPy8spZ4BbO2MdVTc7Z/zg5OTF06FCGDh2a4bXLly8D4OPjk+V25JzVZqzjqibnrG5WVlZUqlSJ69ev670GpKSk8PDhQ8Cw865y5cpA+jHVN4OUeoYwe3v7fDVzj7Bscj02Dbkem4dcj43PFMdULSkpKdOePYX1PM4JueaalimuufLwpYU7ffo0AE2bNjX42e/nPX36lMaNG+Pr66speuly9epVIL2gUFCpu4w/evRIb5vnZy4xRJ06dQA4e/asztfVyz08PIx6J9CSGPu4yjn7n1OnTvH7779z9OhRna/fu3ePoKAgIP0aYQg5Z41/XOWczZr6Rsu5c+d0vn7hwgVSU1Oxt7enZs2aWW7PxcVFk0RmdS7XrVtXb+IkhKHkemwacj02P7keG5+xj+m1a9fw8/OjTp06mkLti5KSkrh16xZQOM/jnJBrrvGZ8porhSoLd+nSJQDq16+fo/VdXFwoWbIkABs2bNDZZseOHYSEhGBra0u7du1yFmg+0KRJEwDWrVunNW2mWnR0NLt379Zqm5VOnToB6cdW13Ppf/31FwA9evTIUcz5gbGPq5yz/zlx4gQ//vgjs2fP1vn6/PnzAWjbti0eHh4GbVPOWeMfVzlns6Y+7/7991+io6MzvL5mzRog/RF3Q8cv6dixIwD//PNPhteSk5NZv349ULDPZWE+cj02Dbkem59cj43P2MfU29tbM5j3xo0bdbb5888/SUhIwM3NzeDieGEn11zjM+U1VwpVFiw8PFzzPLMh1feQkBBu3bql6VqqNnz4cAD27dvHL7/8ovWLuWPHDj777DMAhg0bVqCrx++99x62trZcvHiRjz/+mCdPnmheu3fvHu+99x7R0dGUL1+eXr16aa2r79h27dqVihUrcu/ePSZMmEBcXByQ/qH83Xffcfr0aZydnbMcEDE/M8VxlXM2XdeuXbG1teXs2bMsWrRI0202KSmJX3/9lQ0bNmBnZ8eYMWMyrCvnrH6mOK5yzmauadOmmpm8PvjgAyIjI4H0ruBLlixhy5Yt2Nra8u6772ZY99atW9y6dUvr2gLp4+K5uLhw6tQpvvvuO80xj4uLY8KECdy7d48KFSrIALPCKOR6bBpyPTY/uR4bn7GPqZ2dnWZigT///JM//vhD87uhVCpZtWoVM2bMAGD8+PEFboD63JJrrmmY+5qrUKnnYBQW5+zZs/Tr1w+A48ePaw0Cp0ubNm0ICwujR48e/Pjjj1qv/fTTT/z2229A+uwUXl5eREZGEhERAUCfPn2YMmVKgZ+K899//+Xjjz8mMTERW1tbKleujFKp5ObNmyiVSjw8PFiyZInmeXu1zI7thQsXePvtt4mNjcXR0RFvb29CQ0OJjo7G1taWpUuXGtxDK78yxXGVczbdn3/+ybfffgtAyZIlcXd3JyQkhNjYWOzt7Zk3bx7NmzfPsJ6cs5kzxXEt7Oes+th899139OnTJ8Pr9+7d48033yQiIgI7OzuqVq3Kw4cPefToEQqFgp9//lnnrDHVqlUDYNSoUYwePVrrtX379jF69GhSUlJwdXWlfPny3Llzh2fPnlGsWDFWr15dqGb0EqYl12PTkOux8cn12PjMfUzT0tKYOHEiW7duBdAc07CwMKKiolAoFIwaNYpRo0aZ6B2bT1bHNrtt5ZqbzpzH1RTX3IJ5dS4g1JV1BweHLItUWfnkk0/4/fffadu2LQ4ODly/fp3U1FRat27NokWL+O677wrsh/XzOnTowObNm+nXrx9ly5bl9u3bhIaGUq1aNUaPHs2mTZsyFFOyUqdOHfz9/enduzfFihXj+vXrKBQKOnTowNq1awvMxS4zpjiucs6mGzhwIMuXL6dFixakpKRw/fp1ihYtSs+ePdm0aZPO5D0rcs6a5rjKOZu5ChUqsGnTJgYPHoy7uztBQUEkJSXRvHlzli9fnunUxvq0bt2a9evX89prr2FjY8O1a9dwdHSkR48ebNiwIV9/KRKWR67HpiHXY/OT67HxGfuYWltbM2PGDH799VdeeeUVAK5fv46NjQ2dOnVi9erVBaJIZW5yzTUNU1xzpUeVEEIIIYQQQgghhLAIhfdWghBCCCGEEEIIIYSwKFKoEkIIIYQQQgghhBAWQQpVQgghhBBCCCGEEMIiSKFKCCGEEEIIIYQQQlgEKVQJIYQQQgghhBBCCIsghSohhBBCCCGEEEIIYRGkUCWEEEIIIYQQQgghLIIUqoQQQgghhBBCCCGERZBClRBCCCGEEEIIIYSwCFKoEkIIIYQQQgghhBAWQQpVQvzfp59+SrVq1ZgwYUJeh2IR5syZQ7Vq1bR+NmzYkOV6J06c0LQPDQ01eD9t2rTR2+bUqVNMnjyZDh06UL9+ferVq0ebNm0YNWoUGzduJDU11eD3oP6pXbs2L730Ej169GDatGkEBwfr3MZbb72VYd27d+9m+b6yIy0tjQEDBtCpUydSUlIA7eOo7/3llUePHtG4cWP69++fZdtNmzbRt29f6tevT/369enZsyerVq0iLS3NDJGax4YNG6hWrRotWrQwyvYGDx5Mhw4diI+PN8r2hBAiv1LnZpn97N69O8N6qampLF++nG7dulGnTh0aNmzIgAED2LJlS7ZjeP7zWP3z6aefGrSusfOne/fuMW3aNHr06MFLL72Er68vr7zyCm+99RaLFy/m6dOnBr8H9Y+vry9+fn689tprfPbZZ5w8eVLnNnTlVGvXrjXoOGTHL7/8gq+vr1aupd7f0aNHjb6/3FCpVPTr18+gXO306dOMGDGCl156idq1a9O+fXumTZtGTEyMmaI1vdDQUKPmynPnzqV27dpcv37dCNGJ/MYmrwMQQlg2JycnfHx8AChRooRZ961UKvniiy9Yt24dAK6urlSqVAlra2vu37/Prl272LVrF0uXLmXRokWUL19e53bs7Ozw9fXVWpacnMyTJ0+4evUqV65c4Y8//mD8+PEMGTJEq52Pjw+pqakkJydz6dIlk7zPpUuXcvr0aRYvXoytra1J9mEsiYmJjB8/Xm8y/Lxvv/2WP//8EwBvb2+sra25fPkyly9fZu/evSxcuNDi329e+Pzzz+nevTs//vgjU6ZMyetwhBAiz1y7dg2AGjVqUKRIEZ1tXF1dtf6dlpbGhx9+yJ49e7CysqJq1aokJSVx+vRpTp8+zdGjR/nhhx9yFE+DBg0A8PLyytH6ufH333/z3XffkZycTJEiRahYsSIODg5ERUVx8uRJAgMDWbZsGdOmTcv0xomvry92dnaaf6elpfH06VPu3r3LrVu32LBhA926deO7777Tale2bFnN+7906RLJyclGf4+nTp1i6dKlDB06FE9PT6Nv39h++eUXzp49m2W7bdu2MX78eJRKJe7u7nh4eHDjxg2WLl3Ktm3bWL16NWXLljVDxPnLu+++y4YNG5gwYQIbNmyQnLGQkUKVEP83btw43n33XZydnfM6FIvi4+PDmjVr8mTfc+fOZd26dZQqVYpp06bRpEkTFAqF5vVz587xySefcPPmTd555x22bNmilVSplSpVSu97ePDgATNnzmTTpk388MMP2Nvba/UU+uKLL4D0u0Rt27Y18jtMvzs6f/58mjRpQsuWLY2+fWOKjo5mzJgxnDhxIsu2GzZs4M8//8TZ2ZmFCxfSsGFDID25HTFiBIcPH2bevHmMGTPGxFHnPz4+PvTs2ZN//vmH7t27a74YCCFEYZKamsrNmzeB9Bs6JUuWNGi9+fPns2fPHsqVK8eSJUuoUqUKAIcPH2b06NFs2LCBBg0a0KdPn2zHtHLlSmxszP/16dixY3z99dcoFAq+/vprevXqpZXvhIeHM2XKFPbt28fo0aNZt24dVatW1bmtWbNm6byx9+zZM1atWsXs2bPx9/cnNTWVX375RZN39e7dm969ewPQpk0bwsLCjPoeU1NT+eabbyhWrBgjRoww6raNLS0tjenTp/Pbb79l2fb27dt8/PHHmpuvb775JgqFgsjISD766CNOnTrF+PHjWb16tRkiz1/s7e0ZM2YMEydO5LfffuO9997L65CEGcmjf0L8X+nSpalcuTKlS5fO61AEkJCQwPLlywGYOnUqTZs21SpSAdSrV48FCxZgb29PcHAw/v7+2d5PmTJl+Omnn3jjjTc0+7p//36u4zfUjBkzSExMZPTo0WbbZ04cPXqUHj16cOzYsSzbpqWlsWDBAgAmTJigKVJB+p3cn3/+GYAVK1YQGxtrmoDzuREjRqBQKHJ8118IIfK7W7dukZKSQvHixQ0uUsXGxrJixQoApkyZoilSAbzyyitMmjQJSC9mKZVK4wdtIosWLUKpVPL222/Tv3//DDflypUrx6+//kqVKlVITExk8eLF2d5H0aJFGT58uOZzZ+vWrWzfvt0o8Rti7dq1BAUFMWjQIIoVK2a2/WZXcHAwQ4YMMahIBbB48WJSUlLo3LkzAwcO1OSyJUuWZO7cuTg5OWl6+omMunTpgqenJwsXLuTJkyd5HY4wIylUCSEs0p07d3j27BkAdevW1dvO29ubRo0aAXDhwoUc72/SpEkUL16c5ORkFi1alOPtZMeNGzfYvn07VapU0SrmWJrx48czdOhQwsPDadiwYZZjU506dYqQkBBsbW3p1q1bhtebNWuGp6cn8fHx7Nmzx1Rh52vly5enefPmXLhwgQMHDuR1OEIIYXbqx/709QzSZdeuXcTGxuLu7k7z5s0zvN6tWzeKFClCeHg4Z86cMVqspnbx4kUg83zIwcGBrl27ArnLh15//XVND++5c+fmeDvZkZKSwoIFC7C2ttb02rJEq1atokuXLgQGBlK2bNksx7VNSkpi27ZtADrfl5ubG506dQIgICDA+AEXAFZWVrzxxhvEx8ezbNmyvA5HmJE8+icsXmBgIGvXruXs2bNERkaSmpqKm5sb9erVY8CAATRt2jTDOiqVir179+Lv78/Fixd5/PgxkH73ws/Pj0GDBlG7dm2tdT799FM2btzI66+/zvTp040S+8OHD1m1ahVHjhwhJCSEZ8+eUbRoUby9vWnfvj0DBgzAwcEhw3oREREsW7aMAwcOcP/+fVxcXGjdujWjRo1ixowZbNy4kR9++IGePXtqrXfx4kWWLl3K+fPnefLkCeXKlaNbt2688847dOzYkbCwMPbs2aN3LCdL8vxz6Pv27aN79+56206ZMoXExMRc9YYrUqQIXbt2Zfny5ezevZuvv/46x9sy1MqVK1GpVJrEMjsuXrzIH3/8wcmTJ4mMjMTR0ZFq1arRrVs3evTogbW1dYZ1UlNT2bhxI2vXruXOnTsolUp8fX159913sbW1ZdCgQTRu3JiVK1dqrXf27FlcXV0ZPXo0AwYMYN68eZnGdu7cOQBq1qypd0yRBg0acPfuXQIDAzP9v33e06dP+e233zh06BChoaEkJSVRunRpGjduzKBBg6hWrZrO9U6dOsWaNWs4c+YMjx49wsnJiXr16jF48GCd14+rV6+yevVqTp06RUREBMnJyRQrVoxatWrRq1cvOnbsaFC8aidPnmTlypWcOXOG6OhoihUrRr169Xjrrbd07l+te/fuHDhwgJUrV1r8Y6FCiMJpw4YNfPbZZ7z22msMHDiQKVOmcOvWLVxdXRk2bBhDhgzRXJtPnjzJ3r17WbFiBbdv38bZ2RlfX1/efvttGjdunGHb6kKVepxMQ6g/f/z8/HS+bmdnR+3atQkMDOTEiRMWfZPoeeqcaN++fbRr105vu759+9KqVatcjynat29fDhw4wK1bt7hz5w6VKlXK1faysnPnTiIiInjllVdwd3fP1roREREsX76cAwcOEBYWhpWVFRUrVqRdu3aZ9s46evQoy5cv58qVK8TGxuLl5cUbb7xB//79qVGjBkCGQbzVBcO33nqLMWPGcPny5Uxju3LlCklJSSgUCr2P8Tdo0IC1a9cSGBho8HtOS0vj77//Zvv27dy5c4fo6GhcXV2pW7cuvXv3pnXr1jrXCwkJYdWqVZrvF9bW1prhBnr37o2VlXYflpx+j9Hn3r17LFu2jCNHjvDgwQPs7e3x8fGhR48e9OzZU2fuCtC1a1emT5/OunXrGD16dLb2KfIvKVQJi/bLL79oui8XL14cb29v4uLiCAsLY+fOnezcuZMpU6bQt29fzToqlYoJEyZo7ky4u7tTtWpVoqOjCQ8PZ/PmzWzbto358+eb9MvfuXPnePfdd4mJicHe3p6KFStiY2NDaGgoZ8+e5ezZs+zZs4c//vhD68J8+fJlhg0bxpMnT7C1tcXHx4fo6Gj+/vtv9uzZQ4UKFXTub8OGDUyePJm0tDRcXFyoWrUqoaGh/Prrrxw4cICkpCSTvVdT8Pb2xsPDg7CwMCZPnsylS5fo1q0bvr6+GR4B9PDwMMo+/fz8WL58OY8ePTJ5q6KSjQABAABJREFUYqZUKvn3338Bsn0eLlmyhBkzZqBUKnFycqJatWpERUURGBhIYGAg/v7+zJ8/X2u8taSkJD766CP27dsHgKenJ0WLFuXUqVMcP34808R31KhRtGvXzuDx29Qzveg7V+G//zN9sy2+KDo6mjfeeIO7d+9iZ2dHxYoVsbW15e7du6xbt07znl8cQHbGjBksXrwYlUqFq6sr1apV4/79++zbt499+/ZluH6sXr2ab7/9FqVSiYuLC56eniQmJhIaGsrBgwc5ePAgI0aMYOzYsQbFPX36dJYsWQKAi4sLPj4+PHz4kD179rBnzx6GDRvGxIkTda7brFkzrKysOHLkiCYJFUIIS3T79m2GDRuGtbU1VatW5datW1qP3QHMnj2blStX4ujoSJUqVQgLC2Pfvn3s37+fiRMn8s4772i1VxcJKlWqxObNmzl06BARERG4uLjQsGFDevXqhZOTk9Y66s+fihUr6o01u58/luCVV15hy5YtrF+/nqioKPr160fTpk0zPALo6upqlM+K5wt9gYGBJi9UqXsdZTcfOnbsGKNHjyY2NhZbW1uqVKlCamoqQUFBXLt2jXXr1rFo0aIMN7Lmz5/PrFmzgPSb2FWqVCE4OJgpU6Zw/Phxvftr3749H3zwQab5zfPU52OpUqX0FlfU52NYWBgpKSlZDhiuUqkYO3asJof09PTE3d2d8PBwdu/eze7du3n//ff56KOPtNbbtWsXH3/8MfHx8djb21OlShViYmI030kCAwOZNm2aJsfO6fcYfXbt2sWECRNITEzEwcEBb29vEhISNJMcbN26lXnz5lG0aNEM65YuXZrq1atz9epVDh8+zKuvvprl/kT+J4/+CYt14sQJFi9ejJWVFVOnTuXIkSNs2LCBnTt3smfPHs3dt9mzZ2uNM7Bx40YCAgJwcHBg8eLFHDx4kPXr17Nnzx4CAgKoWrUqqampzJ4922Sxp6WlMXHiRGJiYnj11Vc5dOgQAQEBbNq0iWPHjjF+/HggvafHoUOHNOupiwlPnjyhefPmHDx4kA0bNrB3714WLVpEYmKiztlFbt68yZdffklaWhrvvfcehw8fZv369Rw5coSxY8dy7tw5IiMjTfZ+TcHa2pqvv/4aGxsbUlJSWLlyJb1796Zp06aMHj2a5cuXa+62GsvzPc1MPU7VlStXiI6OxsnJierVqxu83r///sv06dNRKpW8//77HDt2jPXr12vuUpcsWZLAwEA+/vhjrfXmzZvHvn37cHV15Y8//mDnzp1s3LiRvXv30qhRI3bt2qV3nz179szWJAPqMQSKFy+ut406kY6KijJom0uXLuXu3bs0aNCAAwcOsHXrVjZt2sTBgwdp3749KSkpTJ06VWudrVu3smjRIqysrJg0aRJHjx5l/fr1HDp0SDOI+zfffMOtW7eA9C8tU6dORalUMmbMGI4cOcLGjRvZvn07hw4d0nTPX7ZsmUGzHv71118sWbKEYsWKMW3aNAIDA9mwYQOHDh1i5syZODo6snTpUr3Te7u6ulKlShWUSmWmibMQQuS1a9eu4ePjw759+9i4cSMHDhzg5Zdf1mqzcuVKXn/9dQ4dOqTJUUaPHo1KpWLatGkZHsVTf8b/8ssvTJw4kc2bN3PixAl27tzJ1KlT6dixY4Z11J8/bm5uemPN7uePJRg3bhylSpUCYO/evQwfPpxGjRoxZMgQ5syZw4kTJ0hJSTHa/lxdXTVFwPDwcKNtV5e0tDRNbyJ9PeF0CQsL4/333yc2NpY2bdqwf/9+Nm3aREBAADt37qR+/frcv3+fESNGaI2HeeTIEWbNmoWVlRWTJ0/WOh8HDhzIzp079e6zTZs2BhepIHv5kFKpNCi3OHToEP/++y/Fixdn8+bN7Ny5k/Xr13P48GHGjRsHpI+L9eDBA806ISEhmiJVjx49NN+pdu/ezZIlS3BwcGDLli2afCSn32P0uXbtGuPGjSMpKYmRI0dqbqqqc1EvLy/NhAH6qM8NGcur8JBClbBYhw4dws7Ojnbt2tGrVy+t7qhlypTR3CmIjIzUPNoH6R9ANjY2DBgwIMOdmcqVKzNs2DAAgoKCTBb7tWvXiI6Oxs7Oju+++w4XFxfNa7a2tgwfPlzzQfd8HOvXr+fevXuUK1eOOXPmaH2wtWrVim+//Vbn/ubOnUtKSgodOnRg3LhxmjtsNjY2jBgxgn79+pnibZpcixYtWLlypVa3/6ioKHbu3MkPP/xAt27daNOmDb///jupqam53t/zd3Gio6Nzvb3MqGfOy87YGwAzZ84E0rvlf/TRR1p3U5s0aaIZT2Lv3r2cOnUKgJiYGH7//XcAfvrpJ1566SXNOu7u7ixYsECTABtDQkICkD5biz7qO4uJiYkGbVP9haVDhw5avxfOzs5MnjyZZs2a0ahRI63tqY/F0KFDGTx4sOaOn7W1NSNHjuTll18mLS2NTZs2AenXDmtra2rVqsXIkSO17mq6urryySefAOljady5cyfTeJOTk5kzZw6QPkD/8493KhQKXnvtNU1Pqjlz5ug9f9XnvhSqhBCWbsyYMZqbGm5ubhl6P9euXZuff/5ZUwCxtrZm1KhRdOnSBZVKpfVY+aNHjzS5nZubG7/++isnT57k3LlzLF++nDp16vDo0SPeffddrZ5Rhnz+qF8z9PPHEpQrV45169bRpk0bzbLExESOHTvG3LlzGTRoEE2bNmXKlClGK8CpcyJT50NXrlwhJiYGKysrKleubPB6ixYtIj4+Hh8fH2bNmqU14H6FChVYtGgRpUqVIjw8XGtIg19//RWAIUOG8NZbb2m+Xzg4OPDFF18Y9WmL7ORDz7fPjDofql+/vlZPMWtra9577z06duxI586dtYpey5YtIz4+nnr16jF16lStm48tWrRg5MiRQPr3EPU+cvI9Rp85c+aQnJzMwIEDGTNmjNbxqFmzJrNnz8ba2potW7ZoZvp8keRDhY8UqoTFmjBhAhcuXGDatGk6X3/+wv58svHLL79w4cIFvY/mqMfMSU5ONtmML7Vq1eLkyZOcPHlS51295ORkzUX/+Q+l3bt3A+lj0+ga26dTp04Znt1PTk7WDLasb5DrwYMH5+yNWIAGDRqwefNm1qxZwzvvvEOtWrW0ipZhYWH8+OOP9OvXL9czyBnzbmRWQkNDgcwfT3hRcHCwpkCi7/+0fv361K9fH0AzUPmBAwdITk6mXLlytGrVKsM6zs7OGcY7yw11QejFLynPU6lUWbZ5npeXF5Des2rz5s1a/9fu7u78/vvvfPvtt5rrwt27d7l9+zaA3kLt999/z+7duzXXijfffJPz58/rnSI6O8mkeky9okWL0rZtW51tunbtipWVFREREVy5ckVnG/XjFvfu3ct0f0IIkZesrKw0nz36DBo0KMMYOPDfNfrEiRPExcUB6b1Lhg0bRteuXfnnn3/o1KkTxYoVo0iRIjRt2pSVK1dSrVo14uLiNIUHMOzzR83Qzx9LUaZMGRYsWMC///7L+PHjadKkidbnUmxsLKtWraJTp05G6XGuzolMfZzU+ZC7u3u2xh7av38/gM5ZECH9cftevXoB/+XXERERmnGmBgwYoHO7gwYNMjiGrGQnHwJ0/n68SJ0PHThwgEWLFmV4AmDWrFn8/PPPWkUs9bAPffr00bmPgQMHEhAQoCno5fR7jC7JyckcPHgQQO+YrNWqVaN69eqoVCpNrC9S50Pq80UUfDJGlbBoCoUCKysrTp06xc2bN7l37x4hISFcv35d89w3kKHgZG1tTXJyMseOHeP27dvcu3eP4OBgrl27pnVBVyqVBn0o5JSDgwPBwcFcunSJkJAQ7t27x82bN7l+/bpmzKjnY1ffldD3KJhCoaBmzZpERERoloWFhREfH5/pepUqVaJo0aKaWfRMyZDn1J+n/oDO7P9BPQileiDK2NhYTp48ycGDB9myZQtxcXFcvHiRr776ihkzZuQ49ueLH8/fPTIF9Z3i7EzBrC68FClSJNO7jr6+vpw9e1ZT1Lpx4waA3sHG1esYi6OjI0Cm46KpXzM0KX3nnXfYsWMHjx49YuLEidjY2FC7dm2aNWtGixYtqFu3rlYiqL4+ODo66u2mX7ZsWZ3L7e3tuXDhAkFBQZprTlBQkOb4g3ZiqYv6mKekpPDmm2/qbWdtbY1SqeT27dvUqVMnw+vqu54yJbMQwpIVK1Ysy+u5rmsc/PfZlJKSQlhYGNWqVcPd3V3v+H2Q/tnx7rvvMmHCBPbv368Z28cUnz+5YWVlZfBN0ec/VzLLpby8vBg+fDjDhw8nOTmZCxcucOTIEfz9/QkLCyMqKoqRI0fy77//6izgGEqdE5k6H1J/vmVniIG4uDhNLpxZ/lKrVi0ArXxIpVJlmhvkVT4Ehp2Tbdq0oXHjxgQGBjJjxgxmzJiBt7c3zZo1o3nz5jRt2lSrx1JSUpLmWOn7nuDk5KSzh392v8foEhwcTHJyMpA+3IK+c1L9iOnzudbz1PlyUlIScXFxGcanEwWPFKqExVKpVKxYsYJly5bx8OFDzXKFQkGlSpXo1q0b/v7+GdZLSUlh3rx5rFmzRqu7snpmizp16mgGIDSl8+fPM3369AyzeLi5udGyZUuuXLmS4a6AOl71B5suL16Yn+/irWsAwufXM0eh6vkPWUMGcFffidE3O5wuzs7OtGnThjZt2jB27FhGjRpFYGAg27dvZ/LkyZmOBZAZ9VhFQLa6n+dETEwMkL1EWX2nOasPZ/V5oP7/Vp8j2TmvckN99y2zxwXUMRk6M1HZsmXx9/dn0aJF7Nixg4iICM1gnvPmzcPDw4NJkyZpBthU7zuz3wld1IOyvzjIbvny5enduzf//POPQdtRJ/jJyckGTYGuPh9epP4/M2TcCiGEyCuZPdqkpq/g8fxnU3Z6RtesWRNIzyOePHmCu7u7ST5/csPBwYH4+Phs5UPq9QxhZ2dHw4YNadiwIR988AG//PILv/32G+Hh4ezfv5/27dvnKO579+5pelR5e3vnaBuGUn++ZScPfD6fzSx/Ub8WHx+PSqXS/N9nlS8bS3bORysrK4MGwrexsWHZsmWsWrWKDRs2aG6k3b59mz///BMnJyeGDRvGiBEjUCgUWvvOLA98UU6+x+jy/O/0pUuXstX+ec+fH0+fPpVCVSEghSphsebNm6cZ4+W1116jRYsWVKlSBW9vb4oWLUpwcLDOQtWXX37Jhg0bsLa2pm/fvjRq1IiqVavi5eWFg4MDR44cMXmh6tatWwwaNIjExESqVKlCr169qF69OpUrV9Y8utevX78MF/giRYqQkpKiKUjo8mKx6fkPnbi4OL1FGnMUqQCtsY6ePHmSZcFHXYR8cYykESNGcOPGDUaPHk337t31ru/i4sKUKVPo2LEjSqWSu3fv5rhQpS4olC1bljJlyuRoG4ZSJ/X6ChS6qBOrzM6P57epbq/+cM/OeZUb6v/zzBKYsLAw4L8u7IYoUaIEkyZNYtKkSVy/fp3AwECOHz/O4cOHCQsL48MPP+Svv/6iTp06mt+L7LyvjRs38umnnwLQvHlz2rVrR9WqValcuTIuLi6kpKQYXKhSH/NatWqxYcMGg2N4kTqBl6mYhRD5XUJCgs7HiJ7/Yvri53dSUpLeItjzPTlsbNK/0nh7e3PkyBGjf/7kVOnSpQkODtYaS1UfdT5kZ2enVbCYO3cuW7ZsoUmTJnzzzTd617exsWHixIls27aNBw8eZDmWYmZOnz6t+bu6N7up5CYfgsxzG/VnqKOjIwqFIs/yoYcPH5KcnKyzN5H6fKxYsaLBTyXY2dkxdOhQhg4dyoMHDzh+/DgnTpzg4MGDREZG8uuvv+Lg4MDQoUO1CjyGvrecfo/R5fnvKWfOnMn2DUS152/YSU5UOMgYVcIipaSksGzZMgA++OADZs6cSY8ePahdu7bmAvf8bBZqERERbNy4EYBvv/2WKVOm8Prrr1O9enXNRU3Xesa2YsUKEhMT8fb2Zt26dbz99ts0a9ZMa3yp5x/fU1MPFKieklmXF1+rVKmSZtBnfeuFhoZmWdwwlufvaF6+fDnL9hcuXAAyPpYWFxdHaGgoe/fuzXIbzxe5clqkiouLY/v27QB06dIlR9vIDvWgn9kZpFR9VzMhIUGr99eL1HesPD09gf/Oq8wGvDTmDIrqxzsuX76s6e79IvXslVmNaaIWERHB8ePHNePRVatWjbfeeot58+axZ88ePDw8SEtLIyAgAPjvC0h8fLzeRGrPnj289dZb/Pzzz0D6wKyQPkbc0qVL6du3Lw0aNND0AsjOtUM9lkJwcLDegdJVKhXHjx/X6hb/InPe+RdCCFNSPxL9IvXnj6OjIx4eHgDMmDEDX19fevfurXd76hyjePHims/+unXrAnDu3Dmd6yQnJ2s+Iw39/MkNdW6TnXzIx8dH61F2pVJJcHAwe/fuzXIsTSsrK83nRU7zIYB169YB6cczO7Pc5YQ6H8rOIPBOTk6ULl0ayLyXjvo1dU6g/v9ISEggJCRE5zrGzIeqVKmCo6MjaWlpmv/fF2U3H3r69Cnnzp3TDGVSpkwZunfvzg8//MD+/ftp3bo1gOZmfrFixTTnhL7fwYcPH/LGG28wduxYYmNjc/w9RpcKFSpoCnD6BkqH9PP/+vXreotp6vPD1tbW5I+jCssghSphkaKiojTjLqmfL3/R81O6q78IhoeHa57x17WeUqnU6t2QlpZmtJifp747UrlyZZ1dmY8cOaJ5Fvv5GNq1awfAli1bdHYTP3TokGbbavb29rRo0QL4L7F40d9//52Dd5Fz6sev/vjjj0xn1Tl8+LAmUejYsaPWa+oBF3ft2sWxY8cy3d/WrVuB9EJOThOqqVOnEh8fj6OjI2+99VaOtpEd6kJGdosf6vVWrFihs82ZM2c0yZD6vGjVqhW2trbcv3+fw4cPZ1gnKSlJM/OdMdSvX5+yZcuSmJios9fj0aNHuXv3Lk5OTppzPjOpqal0796dwYMHawZPfV7JkiU1xTj1HfbKlStrvvCoZ7F50caNGwkMDNSMj6EuaOm75jz/+5XVLJONGjXC2dmZZ8+e6e1RtWXLFgYPHkynTp30ngfq5aZ+9EIIIUxNX46yZs0aAFq3bq3pXVO9enVSUlIICgrSWYhISUnRfA526tRJU9hRbyMkJERn7uDv709CQgIVKlSgYcOGRnlfmVHnQwcPHsz0JuTjx4/ZuXMnkDEf6ty5M1ZWVjx8+JCFCxdmuj/1+EG2tra8/PLLOYp506ZNnDx5Ekjv3W5q6rwmJibGoFnv1NQFmTVr1ui82fP06VNNbqPOhypUqKAZp8kcObOdnZ1mQhVd242OjtbcJO3Ro4dB25w0aRJ9+/ZlyZIlGV6ztbWlcePGgPb3C/X715cP7dixg/Pnz3P+/HmcnZ1z/D1GFycnJ01Mf/zxh8429+7dY8CAAXTt2pUdO3bobKMujFWoUEHTg1IUbFKoEhapePHimm7Py5cv1+ru+eTJE77++mtNzwn4b9Y/T09PTdV+yZIlWh944eHhfPTRR5w6dUqzLDsfiNmh/tA9cuSI1v5SU1MJCAjQmpHw+UJO7969KVu2LKGhoYwbN06rt82pU6c0jyW96P3338fa2pqAgADmzZunueOmUqlYs2YNv/32mzHfXpY+/PBDihUrRlhYGIMHD+bq1atar6emprJ161bGjx8PQLdu3TR3QdW6d+9O/fr1USqVjBgxgrlz5/Lo0SOtNnFxcfz22298++23WFlZ8cknn2R7cPw7d+4wfvx4zYf3F198kWFmRVNQd6W/cuWKQWNXqH300UdAesIze/ZsreTsxIkTfPjhh0D6o2vNmjUD0gs56tltPv30U60xk6KiohgzZoxRZ1FRKBS8//77QHoB8Pni2OXLl/nkk08AeOuttwwaPNXGxobOnTsD6TP1vXhXcufOnZp9qJOx52NYsmQJa9eu1RSx09LSWLx4Mbt27cLGxoYhQ4YA/xWD/v77b607hXFxccyZM4fFixdrlmU1rbmjoyPDhw/XxLx+/Xqtx1R2797NV199BaR/ydI3+6P6Tqufn1+m+xNCCEu3c+dOZs2apSn0p6SkMHPmTM2g36NGjdK0ffXVVzXX5LFjx2oVqx4/fsyHH37IlStXcHNz01zrIf1L8dChQwH4+OOPtdY7cuQIP/zwA/A/9u47vuazfeD452TKJJTIIEGI1BZij9oURY3au0vTlhqlSiktqrT2o0aN2iNRo2oEsfeWIchCSCSRyE7O74/8cirOyTqJzOv9evX1eL73d1wnRq5c3/u+bvjkk09yvPmLNrp3706DBg1ISkpi9OjRHD9+XK359LVr1xg1ahQvX77Ezs5ObVffatWqqY4tW7aMSZMmqc1MSUxM5MiRI4waNYqkpCRGjBiBtbV1jmINDw9nxYoVTJ8+HUgtnLRr1y6nHznHnJycMDY2JiUlJcOZcJqMHTsWExMTfHx8+Oqrr9ItrwwMDOSTTz4hNDQUS0vLdF9TV1dXANauXcuOHTtUuUFiYiJLly5VvfzMK59++in6+vrs27eP1atXq37/w8LCGDduHNHR0Tg7O9OkSZNs3e+DDz4AUnMVNze3dE34fX19VTv3tWnTRnV8zJgxGBoacvnyZWbPnp3u559Tp06xePFiIHXjGtD+55iMuLq6qn5O+fnnn9PNmvLx8eHjjz8mMTERGxsbevToofEeabmr5EMlh5QjRaGkp6fHV199xaxZs7h48SJt2rTB3t6ehIQE/P39SUpK4t133+XJkyeEh4fz9OlTatWqRdmyZRk5ciRr1qxh//79nDx5ksqVK/Pq1Sv8/f1RKpU0adKEK1eukJSUxNOnT7PVuDCnRo0axf79+wkPD2fw4MHY29tjYmJCUFAQkZGRGBsb06BBA65du5ZuJoWpqSm///47I0eO5OjRo5w6dYrq1avz6tUrHj16hI2NDe+88w6hoaHpEqzatWvz3Xff8eOPP7JkyRI2btxI5cqVefz4MaGhodSrV48bN26ovrZvW4UKFVi9ejVfffUV169fp1evXlhaWlKhQgUSEhIICAhQfZPs2bMnc+bMUbuHgYEBq1evZuLEiZw8eZKlS5eybNkybG1tsbCwUP2eJiUlYWxszJw5c2jbtq3GeJ4/f87AgQPTHYuNjSU0NFRV/DI0NGTatGn06dMnb78YGahbty5lypQhIiKCmzdv0rhx42xd17VrVwICAli8eDHLly9nw4YNVKlShRcvXqjegLm4uPDLL7+kWzowYcIE7t27x8WLFxk4cKDqz6Svry9JSUnUrl2b27dv51ni3q9fPy5evMjff//N6NGjsbe3x8DAQLXjTuvWrdP9UJKV8ePHc+XKFe7evUu/fv2wsbHBwsKCZ8+eqfp6DBw4UFWogtTC7/3791m/fj3Tp0/nt99+o2LFigQFBREREYGuri4//PCD6u3q+PHj+fzzz7l//z7t27dXJWr+/v7Ex8dTqVIlFAoFAQEB2ZoJN3bsWAIDA9mxYwfTpk3jl19+wdbWlpCQEFXMDRs21PjnH1JnUwUHB6Onp6f1m3EhhCgsatSowYoVK9iyZQuVKlUiMDCQiIgIDA0NmTdvXrqZowYGBixfvpyRI0cSEBBA3759sbW1xczMDF9fXxITE7GwsGDNmjWqpWNpPv/8c65du8aFCxfo27cv1atXJyEhQbVJRv/+/enXr1++fGYdHR1+//13vv76a65evcpnn31G6dKlsbGxQaFQEBwcrHop+e6777Jy5UqNfYymTJmCrq4uf/75J/v27WPfvn2UL1+eChUqkJSURGBgIDExMSgUCoYOHap6EajJV199le4ZCQkJREREEBwcrCp69O/fnxkzZuTtFyMD+vr6NG3alOPHj3PlyhWaNWuWresqVarEkiVL+Oqrrzh+/Dht2rTBwcGB5ORk7t+/T0pKCtbW1ixbtizdMsgOHTowZswY1qxZw/fff8+SJUuwsrLC39+fyMhIVc6cV/mQg4MD3333HbNmzeLXX39l48aNVKhQgfv37xMfH4+NjQ2//fZbtu/XqVMn+vfvz44dO5gyZQrz58/HysqK6OhoAgICUCqV1K1bN91sOAcHB+bPn8/kyZP566+/2Lt3L1WrViUsLEy1hLBPnz6ql5ra/hyTEWdnZ3788UdmzpzJn3/+ybZt26hWrVq6n8/eeecd1q5dm+GugGl9014vwIniTQpVotAaNGgQVapU4Y8//sDX1xdfX19MTU2pV68e77//Pv3792f69Om4ubnh4eGhmlo7adIk6tSpw8aNG3n48CHe3t6ULl2aZs2a0bt3b3r06MHQoUO5dOkSHh4eGW7VmhvW1tbs27ePFStWcO7cOZ48eYKuri5WVlb07NmT4cOHq2YbXbhwQbXkDFL7Aezbt4+VK1dy5swZfHx8KFu2LIMGDcLV1ZWBAwcSGhqqNhV38ODBODo6smbNGq5fv869e/eoVKkSI0aMoFu3bqq3YvnVgLBBgwb8/fff7N+/n3///ZfAwEB8fHwwNDTE1taWWrVq0a9fv0yn3pubm7N69WrOnz/P4cOHuXz5MqGhoTx9+hQTExNq1qxJ27Zt6d+/f6azoDTtvKavr4+ZmRkNGzakefPm9OvX7603UH9d2iyhv/76i1OnTmW7UAWpb4KbNWvGhg0buHz5Ml5eXpibm9OsWTN69epFz5491WaWlSpVinXr1rF582b27dvHo0ePUCgUNGrUiM8++4xr165x+/btPPvzoVAo+OWXX2jevDk7duzA29ubpKQkqlevzgcffMCwYcNyVDQ1MTFh06ZNbNiwgWPHjvHo0SNCQkKwsLCgffv29O/fX2Oh8ttvv6V169Zs3ryZ69ev4+XlRenSpenSpQtjxoyhTp06qnPfe+89du3axYoVK7h79y4PHjzAyMiIGjVq0KlTJwYPHszatWtZvnw5Hh4eDBs2LMuvwY8//kjnzp3Ztm2b6u+loaEh9evXp3v37gwYMCDDpOzUqVMAtGzZUnpUCSGKvClTpuDv78/WrVvx9vamXLlytGvXjjFjxmjceKVq1ars27ePDRs2cOTIEQICAggNDcXOzo733nuP0aNHa2zObmhoqNoVzc3NjUePHqFUKqlTpw4DBgzItO/V22BpacmmTZs4evQoBw8exNvbG39/f1JSUqhQoQL169fngw8+oGPHjqqeo29SKBRMmjSJDz/8EHd3dy5cuEBwcDC+vr7o6+tTsWJFVZ77+vc1Td5cSqmrq6vKqRo2bJite+S1Dz74gOPHj+Pp6Zmjl1gtW7bkwIEDrF+/npMnT/Lw4UP09fVxcnKiS5cufPTRR5ibm6tdN2nSJBo0aMDmzZu5c+cOXl5eODg4MHHiRKpVq8agQYPyNF8eOHAg1atXZ82aNVy7dg1vb28sLS157733+Pzzz3P8PX7WrFk0aNAANzc3vL298fb2xsTEBGdnZ7p160b//v3V/ix17doVR0dH1q1bx9mzZ/H29sbQ0JAmTZowcOBAunbtqjo3Nz/HZOTDDz+kfv36bNiwgbNnz+Lr64tCoaBatWq0bduWUaNGZfh1ePToEQEBAZQpU0YKVSWIQvn6fEEhRKHXtGlTwsPD2bp1a7Z3YvH19aV79+4YGBhw8+bNdDNtMpI2g6lhw4aq/hElWVBQkKoY+u+//6oaledGQEAAXbt2xcLCghMnThTomvv58+ezbt06+vfvz48//lhgcYj/9O3bl1u3brF58+YcFTKFEKIwSWtgvX79etWS9KLkwoULqhcTd+7ckf44QLt27QgODmbOnDl5MjstOTmZrl274u/vz/79+6levXoeRKmdEydO8Mknn2Bvb//WdwkX2bNgwQLWrl2Lq6trjgqZomiTHlVCFCJLly7l/fffT9cL53U3b94kPDwcfX19VfNoSF1T3qdPH9UMjDedPHkSSO0DkJ0ilcgflStXpkePHjx//lxjk/C88vDhQ9q2bcuIESM0NhxVKpV4enoCqUsPRMHz8vLi1q1buLi4SJFKCCFEsaarq6taqrZjx463+qy02cwZ7cSYljNLPlQ4JCYm4ubmhpmZmVr/NlG8SaFKiELk3Xff5f79+6xcuZKzZ8+mG/P29mbSpElAal8nU1NT1ZiDgwN37txh/vz56bbbVSqVHD16lOXLlwOo1p6LwuPzzz/HwMCAtWvXvrVnVKpUifj4eM6dO8fChQvTNb6Miopi5syZ+Pr6UrZsWbXdhkTBWLNmDQqFQtU8XwghhCjOevbsSdWqVdmzZ49qN963wd7enuvXrzNv3jxVv0hIbRS+fft2tm/fjkKhUOttKgqGm5sbYWFhjB49Olsb8IjiQ+auCpEBbb9BtWnTRuvtfNu1a0eHDh04evQoI0eOpGLFipQvX57w8HDVrmzOzs5MmzYt3XWffPIJHh4e3L9/n86dO1O5cmVMTU158uSJaheUoUOH0qtXrxzH5OPjo/pafPrppyVubfiPP/7I3bt3Nc5EyguVK1fm66+/ZsGCBRw+fJjOnTvn+TP09PSYOXMmEyZMYMOGDezatYvKlSuTnJxMQEAAcXFxmJubs3jxYo39PkT+unXrFvv372fw4MH5sn26EEKI7Bk6dCiQu1yvqNq1a5dqh+Q3d2HOC3p6esybN4+BAweyfPlyvv/++zx/BsA333zDlStXuHjxIu3ataNy5cqUKlVK1dheR0eHyZMn4+Li8laeL7IvJiaG33//nXfffZcxY8YUdDgin0mhSogMvNl8O7ty07tIoVCwdOlSjh07xrZt23j48KGq+bOLiws9evSgT58+av0RypYty969e9m9ezcHDhwgKCiIx48fU65cOTp37kz//v1p2bKlVjFFR0ervhavb/1bUvj4+Gj9ZyG7Ro4ciYeHB7/++ivt2rXLsJlqbnTp0oUaNWrw559/cuXKFdXMO1tbW9q0acOQIUNyvJW1eDsWLFiAnZ0dEydOLOhQhBBCvCYtH8iLPpVFzZMnT956PlSvXj3Gjh3L2rVrGTp0KPb29nn+jCpVqnDw4EG2bt3K0aNHCQ4OJjY2lvLly9O2bVsGDRpEvXr18vy5IufWrFlDZGQk69evfyu5sSjcpJm6EEIIIYQQQgghhCgUpEeVEEIIIYQQQgghhCgUpFAlhBBCCCGEEEIIIQoFKVQJIYQQQgghhBBCiEJBClVCCCGEEEIIIYQQolCQQpUQQgghhBBCCCGEKBSkUCWEEEIIIYQQQgghCgUpVAkhhBBCCCGEEEKIQkEKVUIIIYQQQgghhBCiUJBClRBCCCGEEEIIIYQoFKRQJYQQQgghhBBCCCEKBSlUCSGEEEIIIYQQQohCQQpVQgghhBBCCCGEEKJQkEKVEEIIIYQQQgghhCgU9Ao6gKKoUaNGJCQkUL58+YIORQghhBB54Pnz5xgYGHD58uWCDqVEktxKCCGEKF5yk1tJoUoL8fHxJCcnF3QYQgghhMgjSUlJKJXKgg6jxJLcSgghhChecpNbSaFKCxUqVADg2LFjBRyJEEIIIfJC+/btCzqEEk1yKyGEEKJ4yU1uJYUqIUqALpu78OzVMyqYVOCfIf8UdDhCCCGEECWG5GFCCJEzUqgSogS4/ew2wVHB2JjZFHQoQgghhBAliuRhQgiRM7LrnxAlgIGugeo/IYQQQgiRfyQPE0KInJEZVUKUAA++elDQIQghhBBClEiShwkhRM7IjCohhBBCCCGEEEIIUShIoUoIIYQQQgghhBBCFApSqBJCCCGEEEIIIYQQhYIUqoQoAVZfWc2ic4tYfWV1QYcihBCiENu2bRuOjo7s3LlTq+sfP37Md999R+vWralduzatWrVi8uTJ+Pn55XGkQhQdkocJIUTOSDN1IUqA2Sdnq7ZF/tj544IORwghRCF08+ZNFixYoPX1Dx48YODAgURERGBmZoajoyNBQUG4u7vzzz//sHz5clq1apWHEQtRNEgeJoQQOSMzqoQQQgghSrgLFy4wZswYXr16pdX1SUlJfPrpp0RERNCzZ09Onz7N7t278fT0ZMiQIcTHxzNhwgTCw8PzOHIhhBBCFDcyo0qIEmBV91XEJsZipG9U0KEIIYQoROLj41m9ejUrV64kOTlZ6/vs27cPf39/rK2tmTt3LgYGBgAYGBgwffp07t27x5UrV/jzzz8ZP358XoUvRJEgeZgQQuSMFKqEKAG61+he0CEIIYQoZPz9/Rk+fDhPnjxBV1eXr7/+mp07dxIcHJzje+3duxeAnj17qopUaRQKBR999BFXrlzhwIEDUqgSJY7kYUIIkTNSqBJCCCGKqICAAEJDQ3N1j3feeYfKlSvnUUSiKHn69ClPnjyhfv36fP/999SuXVurJuopKSncvHkTAGdnZ43nNGzYEIDAwECePHmClZWV9oELIYTIU5JPiMJGClVCCCFEERQQEICTkxMxMTG5uo+xsTH37t2T5LIEqlixIqtXr6ZNmza5uk9ISAhxcXEAGf45srKyQldXl+TkZB49eiSFKiGEKCQknxCFkRSqhCgBwmLCSFGmoKPQoZxxuYIORwiRB0JDQ4mJiWH8jEXY2jlodY8g//ssnj2B0NBQSSxLIDs7O+zs7HJ9n7CwMNWvy5Ytq/EcXV1dzMzMiIiIkIbqosSRPEwUZpJPiMJIClVClAD1VtVTbYscNCGooMMRQuQhWzsHqjnWLugwRAmWNpsKwNDQMMPz0sZiY2PfekxCFCaSh4miQPIJUZjoFHQAQgghhBCi6NLR+S+dVCgUGZ6nVCrVzhdCCCGEeJPMqBLiLVm+fDlLlizh33//zXBpRWBgIEuXLuXSpUuEhYVhY2NDr169GDVqFPr6+lk+48KFCwwbNizL80wwoccPPdJNN3dzc2Pr1q34+Pigr69PjRo1GDx4MF27ds3+hxRCCFHiGRsbq34dHx+vtutfmoSEBCDzWVdCZCY/cqs0CQkJrF27lv379xMQEICenh41a9Zk8ODBdO+ueRe/M2fOsGbNGm7dukVcXBzW1ta0b9+e9+zeI1IZKcv+hBAim6RQJcRb4OHhwcqVKzM95/79+wwaNIjIyEjq1q1L7dq1uXz5MosWLeLChQusXr0aPb3M/4q+88479OjRI8Pxa9euERQUhJOTE24D3YDUN9rffvstbm6p/79WrVpUqFCBW7du8fXXX3P69Gl+/PFHeeMthBAiWywsLFS/joiIwMzMTO2cpKQkoqKiAChXTn5YFzmXX7kVpBapRo0axaVLlyhTpgwtWrQgNjaWy5cvc/XqVW7evMm0adPSXbN161ZmzZoFpO5yWaZMGW7evMm6deuwt7dn69atGfZwE0IIkZ4UqoTIYzt37mT27NkkJiZmet6UKVOIjIzkhx9+YODAgQBER0fz6aefcubMGbZu3crQoUMzvUe1atVYuHChxjFfX1/69u1L6dKlWbFiher4nj17cHNzw9jYmN9//53WrVsDqT1Dpk2bxq5du3j33XcZPHhwTj62EPlGtlAWonCxtLTEzMyMqKgogoKCqFSpkto5T548ITk5GQB7e/t8jlAUdfmZW6U979KlS9StW5e1a9dibm4OgJeXF0OHDmXDhg10796dunXrAvDixQvmzZuHvr4+a9asoUmTJkBqbjV+/Hg8PDxYunQpM2fOzM2XQQghSgwpVAmRRx48eMAvv/zC8ePHsbCwQF9fn1evXmk89/z589y+fZt69eqpEikAU1NTfvrpJzp16sSGDRuylUxpkpCQwPjx44mLi2Pu3LlYW1urxnbs2AHAV199pSpSARgZGfHjjz9y7tw5li5dyoABA7L11lGI/CRbKAtRONWtW5czZ85w7do1mjVrpjZ+7do1AGxsbLC0tMzv8EQRVVC5laenJwAjR45UFakAatasSffu3dmyZQsXL15UFaouX75MXFwcrVu3VhWpIDW3+vzzz/Hw8ODixYtafQ2EEKIkkp9CRaERGRnJxo0b8fDwwN/fn/j4eMqUKUPDhg0ZM2YMdevWxc/Pj27dumFlZYWHh4da09aEhARatmxJTEwMnp6equUIPj4+LF++nCtXrhAdHY2TkxPjxo3j5s2b/P777/z888/06dMHgHbt2hEcHJxlvL1792bevHmq/z9z5kwuXrxIixYtmDNnDkOGDMkwmTp58iQAHTp0UBurXLkyjo6OeHl54efnR7Vq1bL3BXzNxo0b8fX1pWXLlmp9FLy9vQFo37692nWmpqbUrl0bT09Pbt++Tf369XP8bCHeJtlCWYjCqWvXrpw5c4Y9e/YwZswYtT5V27ZtA1K/d4r8I7lVqpzmVmntD0JCQtTGwsLCAChdurTG85VKZbqvoabzhRBCZE4KVaJQCAsL46OPPiIgIIDKlSvTtGlTEhMTuXPnDocPH+b48eNs3bqVOnXqUKtWLe7cucPVq1dxdnZOd59Tp04RGRlJhw4dVInU5cuXGTt2LDExMdSqVYuGDRty/fp1xo4dS61atdRi6dChAy9evMgy5gYNGqT7/7Vr12bkyJG0a9cuy2t9fHwAqFGjhsZxBwcHvLy88Pb2znGhKiwsjJUrV6Krq8vUqVMBGLxnMKExobxj/A4pKSlAalFKk7RZVH5+flKoEoVWcdhCObdLGO/du5eH0QiRPQEBASQmJmJmZkaFChVUx3v27Mnq1asJCAhg4sSJ/PTTT5iampKQkMCCBQu4cuUKZmZmDBkypACjL1kkt0ovJ7lV69atOXbsGMuWLaN8+fK0bduWuLg4tm3bxuHDh7G2tk63+YyzszPGxsZ4e3szY8YMPv30UywsLLh8+XJq3yoFBFQNYPCewfzV568sP4sQQjt50R4iPj4+15t+SIuJ3JNClSgUVq5cSUBAAEOHDuW7775TvYmKj4/n66+/5vjx42zfvp06derQq1cv7ty5w8GDB9WSqQMHDgDwwQcfAKlvAadOnUpMTAwzZ85k0KBBqvtOmTKFQ4cOqcXyZnPM7JoyZUq2z33+/DkA5cuX1ziedlybf2jXrVtHdHQ077//Pg4OqTNOTj46SXBUMDZmNjhXccbLy4tLly7RqVOndNfGx8dz+/ZtgGwllEII7eTVEkYh8tuIESMIDg5Wm/liaGjIr7/+yqhRozh8+DCenp5UrVqVoKAgIiIi0NfXZ9myZekar4u3S3Kr9HKSW/Xr1w8vLy+2bdvGN998k26sffv2zJw5M90LPwsLC3777TcmT57Mjh07VG0WILWHW2y3WM7on+HRo0fZ/jxCiJzJq9xKR0dH9WJfW9JiIvekUCUKBXNzc1q1asWXX36Zbrq0oaEhH374IcePHycoKAiA7t27M3/+fP755x+mTZuGrq4uAK9evcLDw4PSpUvTtm1bIHUaeEBAAK1bt1YlUmn3nTt3LmfPniUyMjL/Puj/S/sHtFSpUhrH06r4Of2HNiYmhp07dwIwduxYjef07t2bn3/+mblz52JnZ4ejoyOQmnjOmjVLleilbSMuhMh7ebGE8cr5E2z5Y1EeRyaE9urWrYu7uzsrVqzg9OnTeHt7Y2pqSufOnfnss89wcnIq6BBLFMmt0stJbqWrq0vnzp25evUqz549o27durx8+ZLbt29z5swZ3N3d+fjjj9NdU7NmTTp37szu3bupU6cOpUuX5tatW4SEhGBw3QCdpjqgviGmECKP5GVuJS0mCp4UqgqLy4vgSjZ+4KjQEHrvS39sb094djXra50nQKMJ//3/hChYn82ksZc7WDpnfZ6WvvzyS7VjUVFReHt7c/r0aeC/wknZsmVp1aqVqjFlWtPWY8eOERsbywcffKDqjXH27FlAcz8mExMTWrVqxf79+9/KZ8pMWgL4Zh+INymVyhzdd+/evURGRtKiRYt0PxDcG3cPJUoUKDDSNeLMmTOcOnWKPn36ULduXUqXLs2dO3eIjo6mV69euLm5oa+vn/MPJoTIkdwsYQzy98vjaISA48eP52rcxsaGuXPn5mVI2itquZXffgj3SX+/XJDcSrPs5FZbt25l1qxZtGvXji1btqhmT3l7e/PZZ5/x66+/YmFhQb9+/QAIDAxk8ODBJCUlsXXrVlWT9djYWGbOnIm7uzsfPviQtTPX5uYjCiGyIS9yq+LQYqKok0JVYZHwEqKzbjKJmfqWz8Q+z961CS/T/3+lMnvXASS//dk1gYGBbNmyhWvXrvHo0SPCw8OB/xKO1xOLDz74AA8PDw4cOKBKptKSorSp6ZC6HTaAlZWVxme+vhteGm0bfuaEsbExkDpNXpO040ZGRjm6b9p0+549e6Y7bmaY/hXeypUr2bRpE7t37+bWrVuYm5vTsmVLXF1dVVP8X9/lRgghhChyilpulRSrfr9cktzqP9nNrSIiIliwYAHm5ubMmzcv3RI/R0dH5s6dy4gRI1i1apWqUPXbb78REhLCvHnzVEWqtGfNmTOH69evc+PaDbxuetG4cWOtPp8QQpQkUqgqLAzMwdQm6/OMNKy7NyqfvWsN3ig8KBTZuw5A1yDrc3Jh//79TJkyhaSkJOzs7GjSpAkODg7Url2blJQUPv/883Tnt2/fHnNzc44cOcLMmTOJjo7m7NmzVK5cmYYNG6rOS0xMBDJ+e6bpuLYNP3OiQoUK3L17l+fPn2tcCpG2/O71RrVZefHiBVevXsXAwEDjW87X6enpMXLkSEaOHKk25ueX+iZBU6IphBBCFBlFLbfSM1K/Xy5IbpVednOrW7duERMTQ8uWLTW+tGvSpAlGRkYEBQURHR2NqakpFy5cAKBly5Zq5xsYGNC0aVP8/f25d++eFKqEECIbpFBVWDSaoP1U7zenq2eXgRl8EqTdtXno1atXzJgxA4AVK1aoFVmOHDmido2BgQFdunRhx44dnDt3jidPnpCYmJjujR9AxYoVgf/e/r3p6dOnase0bfiZEzVq1ODEiRP4+fnRunVrtXFfX1/Vedl16tQpkpOTadmyJWZmGTdBCAgIwN/fnzp16lCmTJl0Y0qlkgsXLqBQKDTu2iOEEEIUGUUtt6rWXbvrNJDcSvvc6uXL1Fltabsgv0mhUKhmpKUV7dJ6cqUtP3xT2vGkpKSsPoYQQghAp6ADEMLX15dXr15RvXp1jTOB0voovPmGLi1xOnbsGP/88w+gvuStSZMmAJw4cULtvvHx8ao+C/ktLYE6evSo2lhAQAA+Pj7Y2Niodu3Ljps3bwKke+uZZs+9PWy+uZk99/awa9cuxowZo1ri9zoPDw9CQkJo0qQJ5cqVy/azhRBCCFF4SG6VXk5yq6pVqwJw+fJloqOj1cavXbtGTEwMFStWVO1imXbNqVOn1M5PSkri6KnUmEKNc76bsxBClERSqBIFrmzZsgA8fPiQBw8eqI4rlUq2bt2q2uL3zZ4DjRo1olKlShw5coRLly7RsGFDtZ0VOnXqRMWKFTlx4gS7d+9WHU9KSmL27NmEhYUBWTfezGvOzs44Ojpy+fJlNm7cqDoeHR3NtGnTUCqVjBo1Kt01UVFR+Pn5ERAQoPGet2/fBkjXGyHNl4e+ZOjeoXx56EvatWsHwB9//KGaBg9w//59Zs6cmXq+hgasQgghhCgaJLfSPrdycnKiXr16REdHM3XqVGJjY1Vj/v7+fPfddwAMHTpUdfyjjz4C4JdffsHLy0t1PCEhgblz5/Is6BnxpeNZErwkbz+0EEIUU7L0TxS4ypUr065dO44fP06vXr1wcXHB0NCQu3fv8vjxYxwcHLh//z6hoepvoXr27Mny5csB1KamQ+oWxfPmzWPs2LFMmzaNLVu2YGtrq9ou2NramsePH2c4vftt0dHR4eeff2bo0KHMnTsXNzc3bG1tuXz5MmFhYbRt21aV9KQ5cuQIU6dOxcbGRuOuS2lbTFeqpKEp7Gvq16/P0KFD2bRpE127dqVRo0bExcVx6dIlkpKSmDp1Ks7Ob2+HRyGEEEK8XZJb5S63+vXXXxk6dCj//vsvFy9exNnZmaioKG7evElcXBydO3dOV/T66KOPuHbtGu7u7vTu3RtnZ2fMzMy4c+cOISEhpBin8LjlYyoost97VAghSjKZUSUKhcWLF/Pll19ia2vLpUuXuH79OuXLl+ebb75hz5491KhRg2fPnqlmDaXp1asXAPr6+nTt2lXjvZs1a8a2bdt47733CAgIwMPDg4oVK7J+/XpVH6bMejq9LbVq1WLXrl1069aNx48fc/LkScqVK8fkyZNZunRpjhI8pVJJREQECoUCS0tLtfE57eawrOsy5rSbA6T2ipg6dSqWlpacPn2a+/fv07JlSzZt2sSIESPy6iMKIYQQooBIbqV9blWpUiX27t3L2LFjsbCwwNPTk9u3b1OzZk3mzJnD77//jo7Ofz9GKRQKFixYwMKFC2nUqBH37t3D09MTQ0NDhg0bxteLv2bxR4tVeZgQQojMyYwqUSiUKlWKcePGMW7cOI3jf//9t8bjlStXxtvbO8P7hoWFERERgYODA6tWrVIbnzMnNWHIahaSNjTNenpT1apVWbx4cbbu16dPH/r06aNxTKFQcPfu3QyvHVF/RLr/r6Ojw4gRI6QoJYQQQhRTkltlLbPcysLCgokTJzJx4sRsx9ejRw969OiR7fOFEEJoJjOqRLHm7e1Nt27dGD16NAkJCenGdu7cibe3N9WqVaNatWoFFKEQQgghRNEhuZUQQoi3TWZUiWLNxcWFOnXqcPnyZdq0aUO9evXQ19fHz88PPz8/zM3NmT9/fkGHKYQQQghRJEhuJYQQ4m2TQpUo1vT09NiwYQPbt29n//79XLt2jdjYWCpUqMDgwYMZPXo0NjY2BR2mEEIIIUSRILmVEEKIt00KVaLYMzExYdSoUWpbEpcktotsCY4KxsbMhqAJQQUdjhBCCCGKMMmtckbyMCGEyBnpUSWEEEIIIYQQQgghCgWZUSVECdDQqiGVSleivHH5gg5FCCGEEKJEkTxMCCFyRgpVQpQA+wbuK+gQhBBCCCFKJMnDhBAiZ2TpnxBCCCGEEEIIIYQoFKRQJYQQQgghhBBCCCEKBSlUCSGEEEIIIYQQQohCQXpUCVECuB50JTwuHItSFizttrSgwxFCCCGEKDEkDxNCiJyRQpUQJcBer70ERwVjY2YjCZIQQgghRD6SPEwIIXJGlv4JIYQQQgghhBBCiEJBZlQJUQJ4jvQkWZmMrkK3oEMRQgghhChRJA8TQoickUKVECVAFYsqBR2CEEIIIUSJJHmYEELkjCz9E8XOt99+i6OjIzt37iyQ53t4eDB8+HCcnZ1p2LAh/fr1Y+fOnSQnJ+foPgkJCaxcuZL333+fOnXq0KBBAwYOHMj+/fszvMbNzY0BAwbQoEEDXFxcGDJkCIcOHcrtRxJCCCFECVbQudXrHj16RL169Vi8eHGG5yQkJLBu3Tp69OhB/fr1ad68ORMnTiQgICDHz7t37x7jxo2jZcuW1K9fn169erF161aUSmW685YuXYqjo2OW/w0dOjTHMQghRElTZGZUxcbGsmbNGg4cOEBQUBAmJibUrl2bYcOG0aZNG63u6evry+rVqzl//jzh4eGYmppSr149RowYQbNmzfL4E4iS4LfffmPlypUAODg4ULlyZby9vZk+fTpHjx7l999/p1SpUlneJyEhgVGjRnHp0iXKlClDixYtiI2N5fLly1y9epWbN28ybdo01flKpZJvv/0WNzc3AGrVqkWFChW4desWX3/9NadPn+bHH39ER0dq00IIIYQomsLDw3F1dSUuLi7Dc5KSknB1deXEiROUL1+e1q1bExgYyN9//42HhwdbtmzB0dExW8+7cOECY8aMITExkcaNG2NmZsb58+f54YcfuHnzJj///LPqXEdHR3r06JHhvY4ePUpsbCxOTk7Z/8BCCFFCFYlCVUxMDCNGjODGjRvo6+tTvXp1IiIiOH36NKdPn8bV1ZUvvvgiR/c8efIkrq6uxMfHY2RkRLVq1Xj69CknTpzgxIkTTJgwgU8++eQtfSLxNk2YMIGxY8dSoUKFfH3u+fPnWblyJTo6Ovz000/07t0bSE2YFixYwIYNG1iyZAmTJ0/O8l47d+7k0qVL1K1bl7Vr12Jubg6Al5cXQ4cOZcOGDXTv3p26desCsGfPHtzc3DA2Nub333+ndevWQGqBd9q0aezatQtFeQUdenWgrX3bt/MFEEIIIUSxVFC51ev8/Pz48ssvuX//fqbnbdu2jRMnTtC0aVNWrVqFkZERAH/++Sc///wzU6dOZffu3SgUikzvk5CQwMSJE0lKSmLVqlW0bdsWgGfPnjF8+HD27NlDx44dadeuHQCdOnWiU6dOGu81939zif07lio1qzBp0qQcfnIhhCh5isT0itmzZ3Pjxg2cnJw4cuQIe/fuxcPDg/nz56Onp8fSpUs5e/Zstu/38uVLJk+eTHx8PJ07d8bT0xN3d3fOnj3LuHHjAFi0aBGXL19+Wx9JvEUVKlSgWrVqmJmZ5etzd+zYAcDgwYNVRSoAPT09pkyZgoODAxs3buTFixdZ3svT0xOAkSNHqopUADVr1qR79+4AXLx4Ue3ZX331lapIBWBkZMSPP/6IspSSreu2MmTXkFx8QiGEEEKURAWVWwHExcWxcuVK+vbty/3797G1tc3wXKVSybp16wCYMWOGqkgFMGLECBo3bsydO3eyleP//fffPHv2jC5duqiKVJD6tZg5cyaQWvzKyqNHj9iwZAMpuincqX8HfX39LK8RQoiSrtAXqgICAti3bx86OjosXLgQKysr1VivXr0YM2YMkLouPLs8PDyIiIjA3Nyc+fPnq77p6urq8uWXX9K4cWMAdu/enYefRGSHu7s7gwYNomHDhtStW5cePXqwcuVKYmNjVecEBQXh6OjI559/zqFDh3jvvfdU57569SrDPgoxMTEsW7aMzp07U7duXdq3b8+yZcsIDAxU6xmQ3T4Dr08d9/b2BqBDhw5qn0tXV5dGjRqRmJjIuXPnsvw6pC3RCwkJURsLCwsDoHTp0mrPbt++vdr5pqamJJdPRi9eD53nhf6vvBBCCCHyUFHOrQAOHjzIb7/9homJCcuWLaNXr14ZflZfX1+Cg4OpWrUq1apVUxtPy9FOnDiR5dft5MmTAHTs2FFtzMXFhdKlS3P58mVevXqV6X1++uknFEkKwmqHoSytzPRcIYQQqQr90j93d3eSk5Np2LAhDg4OauODBg1i1apVXL16lcePH2NtbZ3lPZ8+fQpA5cqV071pSVOnTh0uXbrEkydPcv8BRLakpKQwadIk9u/fj4GBAS4uLhgZGXHp0iV+++03Dh8+zPr167GwsFBd4+Pjw8SJE3FycsLBwQGlUomJiYnG+8fGxjJq1CiuXbtGuXLlaNOmDc+ePWPp0qWcOnVK7fys+gxk9BkgtTCkiZ5e6l83Pz+/LO/VunVrjh07xrJlyyhfvjxt27YlLi6Obdu2cfjwYaytrenatWu2n121bFUCAgPoUq5Ljj6TEKJwSE5WkpSUgr6+Djo6mS9XEUIIKB65FUCZMmVwdXVl5MiRmJiY4OXlleG5vr6+AFSvXl3jeNrPEj4+Plk+N+0cTffS0dGhatWqXLt2DT8/P1Urhjd5enpy8uRJzN4xo//Y/liYWmg8TwghRHqFvlB1/fp1AJydnTWOW1paYmNjQ3BwMBcvXsz0LUuatFlZ/v7+xMTEYGxsnG48bXaKjY2N9oGLHNm8eTP79++nUqVKrFu3jsqVKwMQHR3NN998w4kTJ5gxY0a6mXOBgYEMGjRINf06rVijyf/+9z+uXbtG8+bNWbZsmSrp+ueff5gwYYLa+Zn1GchIlSpVePDgAZcuXaJ27drpxpRKJVevXgXI1tK/fv364eXlxbZt2/jmm2/SjbVv356ZM2emK0pVqVIFLy8vLl26pBZ3fHw8sY9T35o2tmico88khMh/L0JjuXTmCXeuhxLw4CXBgVEkJqT++2ZgoIOltQl21UpjapYCZL05gxCiZCoOuRVAu3btVH2gsvL8+XOADHtplS9fHoDQ0NBs3yvtmozulXaeJmlf24muE/mo40dZPlMIIUSqt7IOKC4ujuPHj3P06FEiIiJydS9/f38A1TdXTdIKSo8ePcrWPTt06ECFChWIiopi2rRpREdHA/+taz9z5gz6+voMGZJ//XwWnVuE7SJbbBfZcuLRiXRjD8MfqsZcD7qqXdtza0/V+Jv+vP6namzPvT3pxqLio1Rjg/cMVrt2pPtI1XhYTFjuPmAWNmzYAMCcOXPS/V6bmpqycOFCzMzM+Pfff1V/HtKMGDFC9euMdrRLTk5m69at6OnpMW/evHRvBrt06cKHH36YJ58hrS/V0qVLuXTpkup4SkoKS5Ys4e7du0Bqc86s6Orq0rlzZ2rUqIGFhQVt2rShQYMG6Ovrc+bMGdzd3TU+e+7cuapCa9qzZs2apUqisvNsIUT+S0xMwfNoIN99cZJRvQ6y8pdrnDoSyCO/SFWRCiAhIYXAR1GcPhbEP24pwEx2bnjKs6eZLz0RRV9e5lYlRVHLrfb77GfRuUVafFLNikNulVNpy/Ay2mE57XhMTEyW90o7R9PqCwBDQ8NM73XlyhVu3LhB+fLl6dOnT5bPE0II8Z9czagKCQlh5cqVWFtb8/HHHwOpy5pGjhyp+sHYyMiIOXPm0K1bN62ekdaPp2zZshmeU6ZMGSB1y9rsMDY25s8//2TSpEkcOnSIkydPYmdnx7NnzwgLC8Pe3p4ffvghX7ePfRn/kuCoYADik+LTjSUrk1Vj4XHqn/F5zHPV+JteJbxSjcUkpv9GqkSpGguNUX+zFBYTphpPUWb8Ri23njx5QlBQEBYWFjRt2lRt3MzMjFatWnHw4EEuXrxIs2bNgNRkw87OLsv737lzh4iICOrXr4+lpaXaeOfOnVXNyHOjY8eO9O/fnx07djB06FBq166NpaUl3t7ePH36lAEDBrB9+3bVEsDMbN26lVmzZtGuXTu2bNmimj3l7e3NZ599xq+//oqFhQX9+vUDYMiQIZw5c4ZTp07Rp08f6tatS+nSpblz5w7R0dH06tULNzc3aeApRCGTlJjCwT1+7N7kTdjz2KwvUKPH+VORXD57mA8+qsFHo99FX1960RVl+ZFblRRFLbeKTYzlZfzLLD9XdhSX3CqndHV1ATLc0U+pVKb736zulZKSovW9Nm7cCKTmaAYGBlk+TwghxH+0LlS9ePGC/v378+zZs3Q7YcyYMYNnz56hUCgwMTEhOjqayZMn4+joqLGpYVbi4uIAMv0HPu2NRtq52VGqVCnq16+Pl5cXMTEx3Lt3TzVWtmzZLLeszWvmhubYmKXODDPUM0w3pqvQVY1ZlFJf217euLxq/E0mBiaqMWP99EscFShUY+8Yv6N2bTnjcqpxHcXb+8Hn2bNnQOZLLdN2eHl9enV2d55J6zX2eiP+12nqa7Z06VKWLVuWrfu/PoPpxx9/pEGDBvz111/4+PgQGBhIo0aNWLJkCX5+fmzfvj1dE3RNIiIiWLBgAebm5sybNy/dEj9HR0fmzp3LiBEjWLVqlapQpaenx8qVK9m0aRO7d+/m1q1bmJub07JlS1xdXTlw4ABAuh0EhRAFJ/UHm9rM++4h4WFJub5fUpKS3Zu9uXYxhAkzG2NrJ3/Xi6L8yq1KiqKWWxnpG2FumDd/d4tTbpUTae08MvqZID4+tWCZ0SypN+8VGRlJXFycxp9D0mapv9lCBFL7d6U1bNemL5cQQpR0WheqNmzYQEhICHZ2dgwYMABIXaZ35coVdHV1+euvv6hfvz6LFi1i9erV/Pnnn/z44485fk5WbzPgvzcZGU1PfpOXlxcjR47kxYsXdOvWjc8//1w1o2rbtm2sXbuWUaNGsWDBArp3757jmLUxodkEJjRTX88PUMWiCkETgjK8dt/AfRmOjag/ghH1R2gcMzM0y/S+6z9Yn+FYXkr7/cvO7/HriUJ2f7+TklJ/CMyoz4KmN2HaNvwE6NOnj8Yp3v/++y+gOXl73a1bt4iJiaFly5YaC0tNmjTByMiIoKAgoqOjVYUsPT09Ro4cyciRI9Wu+f3Q7wDMuTaHjz6SHglCFCRv7xd88cUNYHieFKle98AngkljPZg2rzl1GmruqyIKr/zKrUqKopZbda+RdzlnccutsiutN1VGPaiy6jv15r0iIyN5/vy5xnwss3udOnWKuLg46tevj42NDXVX1uVJ9BOsTK24+dnNbH8eIYQoqbQuVJ06dQo9PT3Wrl2reiOT9uagYcOG1K9fHwBXV1e2bdvG+fPntXpO2tuMtDcgmqS90UibWZWV2bNn8+LFC9q0acPixYtVx21tbZk4cSLlypVj3rx5/PDDD7Ru3VpmobxlaUlFUFDGiV1gYCAA77yj/nYyK2lT0tN2e3xTSEiI2jFtGn4+ffoUPz8/qlatqvENY9rfgTcbrb/p5cvUaf8ZLRFUKBSqxDMxMRGAgIAA/P39qVOnjmopbBqlUklSYBIKFESYR+TkIwkh8lBycgoLF15ixoyzJCQkZ+uaylXMsXcojUW5UujoKHgRGoufdwRB/lEZXhMbk8Tsiaf55gcXmraWTUGKkvzKrUTxV1xyq5yqUaMGAPfv39c4nnY87bys7uXr64ufn5/azMWUlBQePHiArq6uxlmNJ0+eBFLbQgC8iH1BaEwohrrZ+1lFCKE9pVKJ/4NIbl19jr9fJMEB0US8iCM2JgmlUompmQGlLQypUr0MjrXKUq9xBcxLy9/NwkbrQlVgYCD29vaqRArg7NmzKBQKmjdvrjqmr6+Pra0tfn5+Wj3HwsKCyMjITBuHpvWmKleuXJb3e/78OVeuXAHgiy++0HjOsGHDWLVqFREREZw8eVKm7L5l1tbW6XZudHFxSTceFRXF6dOnAWjcuHG2+gq8rnbt2piYmHDnzh2eP3+u9ubr+PHjufsA/+/kyZPMmDGDUaNGMWXKlHRjXl5eXL9+HTs7uywLVVWrVgXg8uXL6WZMpbl27RoxMTFUrFhRtaX0rl27+N///seMGTMYPDh981YPDw90XumgtFFib2Wfy08phNCGn18Ew4cf4swZzT1vXmdT2ZTOvarSrI0N5S3Vl5QABD56yaqFR7lzPQnQVRtPTEhhwfcX+G5ec5ybVcxt+CKf5FduJYq/4pJb5VTVqlWxtbXF19eXgIAAtc2Yjhw5AkCbNm2yvFfr1q05cOAAR48eVSuwXbhwgcjISFxcXNTyNICbN1NnTTVs2BAA+zL2lNIrRUVT+fdYiLchMTGZU6dCgY+Y9Y0fUZE+GZ4b8SKeIP8o7lwPZf9O0NNT0Ki5FZ17Vc3xv4Xi7dG68VBycnK6qcJJSUmqnc7e/GYYGxurdc+ntB/aM3sjFBycmvjb29tneb/Hjx+r3ftNurq6VKlSJcvnirwzfPhwAKZPn656wwepu7dMmjSJ6Oho3nvvvUx7LWSkVKlSDBgwgKSkJKZNm0Zs7H8Niz09Pdm2bVvuPwDQqlUr9PX12b59e7ofHkJCQpg4cSJKpRJXV9d0fxeioqLw8/MjICBAdczJyYl69eoRHR3N1KlT08Xr7+/Pd999B8DQoUNVx9O2bf7jjz/S9Zq4f/++aovprb9s5fSo03nyWYUQ2aNUKlm9+gb16m3IskhVtUYZvpvfnGV/daJn/+oZFqkAKtmb06mnLvA7Fa0193BMSVbyy4zz3PfK3kYjouDlV24lSobikFtpY/DgwSiVSr777jvVzt6QurT28uXL1KpViyZNmqS7xs/PDz8/v3Sfo2PHjpQvX579+/er2jdA6kvvtCW3o0aNUnt+TEwMDx48QE9Pj1q1agFwetRp7n95X/IwIfLYvXthfPXVcWxsVjF+/E3AmajI7M1aT5OUpOT8qcfMmnCanRuSgUpvJVaRM1rPqEp7S5OYmIi+vj6XLl0iJiYGU1NT1dR0SP0hPTAwkEqVtPsNr1evHsePH+f69esax0NCQlTFpwYNGmR5v9ffejx79kzjWxD4b7fBjMZF3ho6dCjXrl3j0KFDvP/++zRu3BgjIyMuX75MeHg4NWvW5KefftL6/uPGjePcuXOcOnWKDh064OzsTFhYGFeuXKFSpUoEBATkekc8a2trvvnmG+bNm0fv3r1xcXFBR0eHCxcuEBcXx/Dhw9Vm5x05coSpU6diY2OT7u3jr7/+ytChQ/n333+5ePEizs7OREVFcfPmTeLi4ujcuXO65Kh+/foMHTqUTZs20bVrVxo1akRcXByXLl0iKSmJqVOn4uzsnKvPJ4TImadPXzFmzGEOHHiQ6XkW5Uox/PM6tOlUSYvCwxO+/t6OA7vj8DwaqDYaF5vMnMlnWLimHe9UyLjwJQqH/MqtRMlQHHIrbQwbNgwPDw8uXrxIp06daNSoEUFBQdy5c4fSpUuzYMECtWvSdtDcuHGjqohlYmLC3LlzGTduHF9++SUNGzbEwsKC8+fPEx0dzYABA3jvvffU7vXkyROSk5OxsrLKdlsSIUT2KZVKjhzxZ/Hiy/zzz6M8vXdwAMCX/L3jGeO+TZGdlAuQ1l/5OnXq8PLlSxYuXIiXlxe//fYbCoWCNm3aqLaGDQsLY9KkSSQnJ6u2vc2pLl26AHDx4kUePFBP9rds2QKkvml8fap8RqpWrapat5/RtrkXL15UzXDRtKWvyHs6OjosXryYn3/+mVq1anH16lXOnDlDxYoVmTRpEjt27KBs2bJa39/U1JTNmzczatQoDA0NOX78OE+fPmX8+PFMnDhRdU5ujRw5kvnz5+Pg4MCFCxe4efMm9erVY/ny5UybNi3b96lUqRJ79+5l7NixWFhY4Onpye3bt6lZsyZz5szh999/V2t4Om3aNKZOnYqlpSWnT5/m/v37tGzZkk2bNjFixIhcfzYhRPbt2uVN7dp/ZlGkSqF1RwuWb+lE286VtZ4do2+gw/gZjen2oebd3yJexLNo1iWSkzQ3PRaFR37lVqJkKC65VU7p6emxZs0aXF1dMTMzw8PDgxcvXtCzZ0927dqFg4NDtu/Vpk0b/vrrL1q3bo2vry9nz57Fzs6OOXPm8MMPP2i85sWLFwBUrCjL/ITIS3FxSaxZc5M6df6kc+ddeV6ket2Jw+FM+cSDZ09fvbVniMwplFouxHzw4AEffvihavtXpVKJnp4eu3btombNmly+fJkRI0aQnJyMmZkZe/bsyVYhSZNvvvmG/fv34+DgwIoVK7CzswPA3d2dadOmkZSUxPr169P1b4DUBtOJiYmYmZmpilMA27dvZ8aMGejo6DBhwgSGDx+ummp/4cIFJkyYQGhoKO+//z6LFi1Si6d9+/YAHDt2TKvPI/LfrVu3sLGx0ZiQ/fnnn/z888+MHTtWlVgJIQqnq1ev4uzszK9r91HNMfN+bxnx877NN6N7cuXKFVX/kLwSERGHq+txNm++m+l5NjalCA7+lV/XLtH6c5z8153Fs8ervhZKpZJl865y7MAjjef3H1GTQWNqpTv2Nr8WRU1h+N6en7lVYVMYvv4iZyS3EqJ4KOy5VUjIK1asuM7Kldd5/jw26wteo1BAhYrGVLQxxcRUHxQQFZlAwMOXRIZnvFlbGotypZj5a0vsHUpn+5mSW/0nN9/btV76V7VqVdatW8fPP/+Mt7c3dnZ2TJo0iZo1awKpu40kJSVRo0YNFi9enKtEavr06fj4+ODj40PXrl2pUaMGL1++VPWmGj9+vFqRCmDEiBEEBwfTu3dv5s2bpzo+YMAAAgICWLNmDQsXLuR///sfdnZ2hIeHq+7ZtGlT5syZo3XMonAZN24coaGh7N27F0dHR9XxwMBA1q9fj0KhoEOHDgUY4ds168QsIuMjKW1YmpltZxZ0OEIUS0eP+jNy5D8EBWW8Ix/AJ5/UY8iQ0rRq9ShPn69QKPhsUgPCQ2O5ekF9x62dG7yo16gCtepnvS27KBj5mVsJkVslPbfKCcnDhMi5K1eesmTJVbZt8872bskApS30aPFeZeo2qkDtBuUxNVPv5alUKnkcGM2pI4Ecdn9AxAvNRavwsDimjTvBjIUtqVkn643bRN7RulAFqT2hMlo+Z2tri5ubmyq5yg0LCwu2b9/O2rVrOXToEH5+fujp6eHi4sKQIUPo3Llzju85adIkWrduzV9//cXVq1fx8vLCxMQEFxcXevXqRa9evVTT7EXRN3r0aH766Sf69OlDgwYNKFeuHC9evODatWskJiby6aefpuv/Udz8cfUPgqOCsTGzkQRJiDwWE5PIlCmnWLbsWqbnVaxowtq1nenWrSpXr159K7Ho6enwzawmTBh5lJAnMenGlEpYPv8qv/3ZAQND+f5WWOVXbgWpDdnXrFnDgQMHCAoKwsTEhNq1azNs2LBs7Yqmia+vL6tXr+b8+fOEh4djampKvXr1GDFihCxVLGZKem6VE5KHCZE9iYnJ7N7ty5IlVzl37nHWF/w/IyM92rd/h/37f2D6gkVUd6qT6fkKhQKbymYMHP0uvQfVYN92X3Zu9CIxQb1NQsyrJH6cdIa5y9tgXy37M6tE7uSqUJUZHR2dPEukAIyNjXF1dcXV1TXb12S1NW6TJk3Udv0QxdPw4cOpWrUqW7Zs4d69e1y/fh1zc3OaNWvG4MGDadu2bUGHKIQogk6dCmTs2H/x8cl8Z71+/WqwcmVHypUzeusxmZjqM3F2E6Z+doKkpPSr+x8HRrNzoxeDx9bK4GpRmOVlbhUTE8OIESO4ceMG+vr6VK9enYiICE6fPs3p06dxdXXliy++yNE9T548iaurK/Hx8RgZGVGtWjWePn3KiRMnOHHiBBMmTOCTTz7Jk/hFwZPcSgiRV7y9X7Bx4x3Wr7/NkyfZ7wtlZWXCF1804JNP6uHvf4/9+/3Q0clZz89SRnr0H+GESytrZk88yovn6ue8ik5k1oTTzFvZFktrkxzdX2gnTwpVnp6eeHh48ODBA6Kioti9ezcvX75k48aNDBo0KFeNGoXIK61ataJVq1YFHUaBcP/InYTkBAx0NW9jL4TImRcvYpk8+RRr197K9LwyZQxZtqw9gwY5ad0sXRvVncoy+ONabFhxW21sz2ZvWrWvROWq5vkWj8i5t51bzZ49mxs3buDk5MTKlSuxsrICwM3Nje+++46lS5fSsGFDja0VNHn58iWTJ08mPj6ezp07M3fuXMzMzEhOTmb58uUsX76cRYsW4ezsTKNGjXIVuyg8SnJulROShwmh7unTV7i5+bJhwx3On3+So2sbNKjA+PHODBhQEwOD1Fni/v65i8e+Wmk+GqXLivleQHW18fCwOH6aepYF/3sPw1Jvbb6P+H+5+gqHhYXx9ddfc/nyZSB1rWdaIv748WOWLVvGpk2bWL16NfXq1ct9tEIIrThbOxd0CEIUC0qlks2b7/LNNyeybOjZoYMd69d3wdbWLH+Ce0PPATU4czyY+17pZ3slJytZv+wmMxe1LJC4RObyI7cKCAhg37596OjosHDhQlWRCqBXr148fPiQVatWsXTp0mwXqjw8PIiIiMDc3Jz58+djZJQ6e1BXV5cvv/ySixcvcunSJXbv3i2FKlHiSB4mBKSkKLly5SkHDjzgwIEHXL6s3k8zMwoF9OzpwPjxzrRubftWXgAaGiqAtdRpuIxbV6PVxv39XrLyl2t8Nb1Rvr6ALIl0sj5Fs4SEBEaPHs2lS5cwMTGhY8eOWFpa/ndjHR3KlClDZGQkI0eOVDUpF0IIIYqiU6cCadLkL4YNO5RpkcrISI9ly9pz+HDfAitSAejqKhg3pSE6uuqJ1LWLIVw9/7QAohKZya/cyt3dneTkZOrXr4+Dg4Pa+KBBg4DUnaAeP85ej5CnT1P/PFWuXFlVpHpdnTqp/UKePMnZW3MhhBBF18uX8eza5c3IkYewtl6Ji8tfzJp1LkdFKnNzA77+2hkfn9G4ufWiTZtKb7lIlMyQj62o46x585kThwP41/3hW3y+gFwUqv766y+8vLyoX78+//77L0uWLMHGxkY1XqNGDY4ePUqDBg2IjY1l/fr1eRKwEEIIkZ/u3Qvjgw/20qbNdi5dyry44+JSkevXhzFuXIMc90h4G6pUL0PPAerT1wH+XH6L5GSlxjFRMPIrt7p+/ToAzs6aZ3lYWlqqnnvx4sVs3TNtVpa/vz8xMTFq497e3gDpPo8QQojiRalU4uUVxq+/XqJdu+2UK7ecfv3+5s8/7xASov69ITM1a5Zl+fL2BAV9yuLF7+HgYPGWolanp6/D1J+aZdg8fd2ymzwJUp9xJfKO1oWqAwcOoKOjwy+//JJhnwRTU1MWLlyIrq4unp6eWgcphMidWyG3uPrkKrdCMu+nI4T4z/Xrz/joo7+pXftP9u3zy/RcY2M9fv21LWfODKJGjcLVl7H/8JqULmOodjzg4UsunYksgIhERvIrt/L//0YelStXzvCctILSo0ePsnXPDh06UKFCBaKiopg2bRrR0akJvFKpZN26dZw5cwZ9fX2GDBmiVcxCFGWSh4niLDlZyQPfGKA7vXqdx8lpPRMnnsTDI5CkJPVd9DJjYKBLv341+Pffvty9O5LPP2+AmVnB9HYzNtFnytymGJvqq43FxyWz5KfLpKTIC7+3ReseVQ8ePKBatWpUqlQp0/NsbGywt7cnICBA20cJIXKp619dVdsiB00IKuhwhCi0lEolnp5BzJt3kUOHsjetu0ePaixd2g47u8K5ZbGxiT4fjXbif79eVxs7uj8M0M33mIRm+ZVbhYWFAWTakL1MmTIAhIdnvqNlGmNjY/78808mTZrEoUOHOHnyJHZ2djx79oywsDDs7e354YcfcHJy0ipmIYoyycNEcaNUKrlzPZST/wZw8fQTIsPjgTYEBWXevzMjTZtaMXx4LQYMqImFRam8DTYXrGxN+Xp6I3769pza2L2bYezfdZ+e/TXPXBe5o3WhKiUl+9VRfX19dHUlERZCCFE4RUbGs3nzXVatusHt26HZuqZyZTMWL36P3r2rF/qGmp16VOHAbj+CHkWlOx4elgRIk9/CIr9yq7i4OAAMDDJ+S21oaJju3OwoVaoU9evXx8vLi5iYGO7du6caK1u2bKH/eyKEECJz4WFxHD3wiGMHHvE0+JXW9ylVSo927Srx/vtVef/9qoX2ZR+AS0truvSqyj9uD9TGtvxxhxbv2VKuvHpvRpE7WheqbGxsePToEdHR0ZiammZ4Xnh4OL6+vtjb22v7KCFELg2vN5yIuAjKlCpT0KEIUahcvRrCqlU32LLlHq9eJWbrmjJlDBk3ribvv18GQ8Norl27luPnvv4DfH7Q1dNh8NhazP/uvIbR9iQm5mxqvng78iu30tXVJSUlJdPCkVKZupxBRyd7XSK8vLwYOXIkL168oFu3bnz++eeqGVXbtm1j7dq1jBo1igULFtC9e3et4haiqJI8TBR1T4Ki2bvFh+OH/EnSMmeoXNlMVZh6773KGBurL6krrIZ/XoerF57y7En6Pltxscn8ufwW3/zgUkCRFV9aF6ratGnDunXr+OWXX5g1a1aG582ZM4fk5GRatWql7aOEELk0t/3cgg5BiEIjPi4FcGHYsEvcuXM829cZGOji6tqAYcNsaNasPnPn5qwpaEFr0soae4fSPLr/Zl+qsuzf/5QmTQokLPGa/MqtjI2NiYyMJD4+PsNzEhISgP9mVmVl9uzZvHjxgjZt2rB48WLVcVtbWyZOnEi5cuWYN28eP/zwA61bt8bc3Fyr2IUoiiQPE0XV85AYNq++g+eRAHIw6RdI3X24eXMb3n+/Cu+/X5Vatd4psjNrjYz1cJ3aiO+/PKU25nk0kC69qlCrvuZdAoV2tC5UjR49mt27d7Njxw7CwsLo0aMHUVGpSwr8/Pzw8fHhr7/+4sqVK5iYmDBixIi8ilkIIYTIMT/vcP7d95AT/zwC+nHnTlRWlwBgaqrPp5/WY/z4Rlhbm3L16lViYmIYP2MRtnYOWsVy5fwJtvyxSKtrtaWjo+CjkU7M0zCratOmAGbNUhaKnQpLsvzKrSwsLIiMjCQiIiLDc9J6U5UrVy7L+z1//pwrV64A8MUXX2g8Z9iwYaxatYqIiAhOnjxJjx49ch64EEKIfBEXm8TeLT7s3eJDQnxytq8zMdGlZ8/q9OhRjc6d7SlbtvgsiavTsDzvdamMxz/q/SHX/H6DX9e2lzwqD2ldqCpXrhwrVqzg888/5+jRoxw7dkw1ljalW6lUYmxszKJFi7C0tMx9tEL8P6VSWWQr8kKI/BMfn8zJwwEcdn+An3dEjq4tV86Ir75qyLhx9TUmWrZ2DlRzrK1VXEH+me8i+La4ZDCryt8/hv37/ejZU7vCm8gb+ZVbVa1alUePHhEUlHFT5+DgYIBsLS98/PhxuntroqurS5UqVbh27VqmzxUFR3IrIQTAjUshLP35CqHPstcY3byMAbXqGXHu5EKOHfuLJk0aveUIC86wz+pw/tRjYmOS0h1/6BvJ6WNBtO6Y+WYoIvuy13ggA87Ozuzbt49hw4ZhZWWFUqlU/VeuXDn69u2Lm5sbrVu3zqt4heD06dOMGjUqR9e0a9cOR0dH1ZbcuZGSksKuXbvo06cPDRs2pEmTJnz++efcuXMnR/eJjo6mZs2aODo6avyvRYsWWd5j5MiR8vdLCA1eRsSzff09Pv7wECsWXM1RkapFCxs2bepGUNAnfP99s2L1NlBHR8GHQxw1ji1ceDmfoxGa5EduVa9ePQCuX7+ucTwkJERVfGrQoEGW93u9n9azZ88yPC9tt8HM+m+JglFccitNvv/+exwdHdm5c6fG8ejoaBYsWEDHjh2pXbs2jRs3ZtSoUXh6eub62UIUJQnxKfzx23Vmjj+dZZFKoQDnZhWZMrcpa/e+T99hFQEf9PVzVV4o9CzKlWLg6Hc1jv31xx3p+ZmHtJ5RlcbS0pJp06Yxbdo0YmJiiIqKwtjYGDMzs7yIT4h0Hj9+zOjRowt0ht4PP/zA9u3bKV26NM2bNyc0NJRjx45x6tQpVq9eTfPmzbN1n7t376JUKqlSpQq1a6vPysiqf8eiRYs4e/Zstr4W7Ta0I+RVCJYmlhwfnv2ePEIUNWHPY9m9yYujB/xzNFXdzMyAoUPf5ZNP6lG3bvHuMdC8rQ0bLY15HpK+x5anZxAXLjyhSROrAopMpHnbuVWXLl1YvHgxFy9e5MGDB2qzoLZs2QKAi4sLtra2Wd6vatWqVKhQgWfPnrFjxw6+/fZbtXMuXrxIQEDqcommTZvmwacQeaU45VZvOn78ODt27MhwPDIykoEDB+Ln50f58uVp3bo14eHhnD17ljNnzjBt2jSGDx+u7cdSkTxMFH6WLJrtz/OnCZmepaevw3tdKtN7UA2sK5XMn/e7fViNg3v81HY9DHn8iiN/P8SxVgEFVszkulD1OmNjY4yNjfPylkKkk5Otu98GDw8Ptm/fTvXq1dm4cSNly5YF4PDhw4wfP55vv/2WI0eOZKv57N27dwEYOHBgjpKghIQEfvrpJ7Zu3Zrta3zCfAiOCiYy7s0mykIUDy8j49mz2ZuDu/1ISMj+vxPOzpZ8/HFdBg50wszM4C1GWHjo6unQY4AD65bcVBv7/fcrbNkiO7IVJm8jt7K3t6d79+7s378fV1dXVqxYgZ2dHQDu7u6sWbMGgM8++0zt2oCAABITEzEzM6NChQoAKBQKvvjiC2bMmMGGDRsoV64cw4cPx8Ag9e/UhQsXmDBhAgDvv/8+1atXz9PPI3KnOOVWrwsLC2P69OmZnrNq1Sr8/Pxo3749ixcvVj3j3LlzjB07ll9++YUuXbrkuogneZgozDw8ngNfZFqkUiig/fv2DBz9LuXKF5+Z5trQ+/+dlH/94aLa2M4NXkyZK8v/8kK2ClXnzp3Lk4c1a9YsT+4jREFZu3YtAJMnT1YlUgCdO3emR48euLm5cejQIXr16pXlvdIKVbVqZb/sfvr0aebPn4+Pjw+VKlUiMDAwW9eZGphiZmCGqYEstxDFS3JSCgf2+LFt7V1iXiVlfQFgaKggPv4smze7Mnhw27cbYCHVsbs929fd41V0Yrrju3b5sHjxKywtTQoospKjoHOr6dOn4+Pjg4+PD127dqVGjRq8fPlS1Ztq/PjxGmexjBgxguDgYHr37s28efNUxwcMGEBAQABr1qxh4cKF/O9//8POzo7w8HDVPZs2bcqcOXO0ilcUX3mZW73uu+++Iyoqirp163LzpnphHlLzKoBPP/00XSGsWbNmNG/enJMnT3L16lW6du2aw0+VnuRhojBKSVEye/ZZZs26BZTK8DynuuUY81U9qjla5F9whVyLdrbs+cubh77pi8/hYXFc9JSCdF7IVqFq5MiRuW6uqFAoVD+YC6HJiRMn2LRpEz4+PoSHh1O+fHmaNm3KmDFjqFatGkuXLmXZsmVAav8MR0dHbGxsOH78vynU586dY/Xq1dy+fRulUknLli2ZNGmSxuc5Omru0/KmL774AldXV6Kjo7ly5QrGxsYak/eOHTvi5ubGiRMnspVM3bt3Dx0dHZycnLIVB6TuCKWjo8PQoUMZOHAg3bp1y9Z1Xl94ZfsZQhQVXrfDWLXwmlpj8IxUcyxDl95VsakUxbRxE3Fy+u4tR1h4GRnr07FnFdy2+KQ7npiYwpo1t/juO1ma9bYVdG5lYWHB9u3bWbt2LYcOHcLPzw89PT1cXFwYMmQInTt3zvE9J02aROvWrfnrr7+4evUqXl5emJiY4OLiQq9evejVqxe6urpaxSu0U9JyqzTbt2/Hw8ODKVOm4OPjk2GhSkcntZ/O06dPqVu3brqxtJ5qZcqUyfZzMyJ5mChskpJSGDPmMBs2ZNwHzsBQl2Gf1aZbn2qym90bdHQUDPm4Nj9OOqM25nHoBblsBS7IwdI/pVKZqwfl9npRvB09ehRXV1d0dXVp1KgR5ubm+Pr6smfPHg4fPsyOHTtwdHSkQ4cOHD16FCMjIzp06JDuzdvOnTuZMWMGgOoep0+f5vLlyyQkqE9lze7W2GlJ1/3790lJSaFq1aro6an/1alWrRoAPj4+amNvio+P58GDB9jY2ODu7s6uXbt4+PAhhoaGNG/enHHjxqnu97rOnTszbtw4HB0dZdckUYLp4bb1GZ5HvbN1dqPmFek1sAa16r+DQqHAz/v2W46vaOjyQRXct/rw5rfnVatuMGWKC3p6kmS9bQWdWxkbG+Pq6oqrq2u2r3m9gKFJkyZNaNKkSa7iEnmjpOVWafz9/Zk3bx6NGzdmxIgRTJs2LcNzW7dujZeXFz/++COGhoY0atSIyMhIVWGudu3auLi4ZPvZQhQFcXFJfPTRftzd72d4TnUnC77+vjE2lUtmH6rsaNjUkupOFvjeC093PPxFEtCwYIIqRrJVqPLykrcAb5NSqSQmJibrEwsRY2PjPN3CeN68eejo6ODm5oaDQ+r26Eqlkp9++omNGzeyfv165s6dy7vvvsvRo0cxNzdn4cKFquufPHnCnDlz0NPTY/Xq1aqlEC9evGD06NEa3zi/fn12PH/+HIDy5TU3Wk47HhoamuW9vLy8SEpKIjAwkDlz5uDs7EyTJk24e/cuBw4cwMPDg//9739qydGSJUtyFLMQxY23dxTwFZ5HwzM9T6GANp0q8+EQRypVyXxjgpKqoo0pNWubcO9W+magQUFR/P23H717Sx+ht0lyq7erKOZWkLf5VUnLrQCSkpKYNGkSCoVC9fkzM27cOB4+fMiRI0f4+OOP043169ePKVOmyCxAUaxERSXwwQd78fDIuH1Ixx72fDy+PvoG8mc/MwqFgr7DavLzVE1L+duRkiITdXIjT5upi5xLm0J99uzZgg4lR1q0aIGnp2eeJVPPnz9HT0+PcuXKqY4pFAo+/fRT7OzsqFmzZqbX7927l7i4OIYNG5auX0fZsmX56aefctzXQJNXr1J/mDMy0txAsFSp1LXd2UmM05K7ypUrs2rVKtUbw8TERH799VfWr1/P+PHjOXLkiGxQIASp/1YuXXqNb765DFTM9FyXVlYMHlsLu6ql8ye4IqxFuzJqhSqA1atvSKFKFFlFNbeCvM2vSlpuBbBy5Upu3LjBnDlzsrVjZalSpejRowd3794lKSmJd999l9DQUO7cucPhw4dxdnamd+/e2fw0QhRuMTGJdO++h1OnNK/K0NGFMV/Vp2vvqnk6IaE4a9zCispVzQl48PKNkfKcPh1Go0YFElaxkGeFqkePHvHo0SNevnxJuXLlcHBwKNBtbosS+YcAGjdujKenJ71796Zv3760bt2a2rVrU65cOYYMGZLl9ZcuXQKgTZs2amNOTk7Y2trmeqlc2hu1rH6/srMUY8CAAbRt2xZDQ8N0U+z19fWZPHkyFy9eVCVJeZEgLbu4jKj4KMwMzfjC5Ytc30+I/BQbm8innx5h48bMe/HY2pvxyYT61GlYIZ8iK/oca5sAYUC5dMf//def4OAobGxkyn9BktxKe5Jblbzc6saNG6xatYr33nuPfv36Zev5v/76K6tXr2bAgAFMnz5dtVPlpUuXGDduHFOnTqV8+fK0bNkyW/fLiORhoqDFxSXRq5dbhkUqiGfMV9Xo1ke99Uh+CggIyPYMyjfdu3cvj6PJmo6Ogr5Da7JolvoOgNu2BfL11/keUrGR60LVwYMHWbZsGQ8fPlQbq1+/PhMmTKBx48a5fUyxpVAo8PT0LHLT0/N66d+cOXP44osvuHXrFkuXLmXp0qWUKVOGNm3a0Ldv3yz7Azx79gyAihU1z7TQlEzltOFn2symuLg4jeelHc/oreDrdHR0sLKyynCsTZs23Llzh9u3b+dJoWre6XkERwVjY2YjCZIoUgICXtKnjztXroRkeI6BgQ4DRr5Lz4+qo68vfZVyIrU56gUg/cYMKSlKNm68y9Sp0muoIEhulTtFNbeCvM2vSlJuFRMTw+TJkzEzM8v2zpIPHjxgzZo12Nvb8/3336Ovr68aa9y4MZMmTWL69OmsXr0614UqycNEQUpMTKZ//785csRf47i5uR4vXy7FsdayfI4svYCAAJycnIrcv90t3rNh40ojQp/Fpjt+4UI4d+6EUqvWOwUUWdGWq0LV3Llz2bx5s+oth5mZGcbGxkRHR/Pq1SuuXbvGsGHDmDZtGkOHDs2TgIsjhUKBiUnJ3gq8YsWK7Nq1iytXrnD06FHOnj2Lt7c37u7uuLu7M3bsWCZOnJjh9VkldZoadOa04WeFCqmzNDKq8mfVZyEn3nkn9R+02NjYLM4Uovi6fv0ZXbvu5ulT9aVpaarWKMP4GY2pZC99qLR3BR2dbqSkpD+6fv1tvv3WRWam5DPJrfKG5FYlK7faunUrjx49olq1asybNy/d2PXr1wHYtWsXFy5coFOnTnTq1ImLFy+SkpJCkyZN0hWp0rRt2xaQfnKiaFMqlYwefZi///bTOF6xogm//16LAQMC8jkydaGhocTExDB+xiJs7RxyfP2V8yfY8seitxBZ5nT1dOj2YTU2rlTfrGfJkqv873+d8j2m4kDrQtXRo0fZtGkTenp6jB49mo8++ijdDJHAwEC2bNnChg0bmDdvHvXq1VPb9lWINzk7O+Ps7Aykbgu8e/duFi9ezNq1azNNyC0tLfH19SU4OFjVMPR1aW8FX5fThp8ODg7o6Ojw4MEDUlJS1Bp03r+funNGjRo1srzXqlWruHv3LiNHjqRBgwZq42lvKDN6i5lT6z5YR1xSHKX0SuXJ/YR4244d86d3b3eiotR3lYLUZum9B9Vg4JhaMosq117StGlZzp59ke6or284Z84E07Jl1n1eRN6Q3Eq8DSUht0qbgeHn54efn+YfyK9fv87169exs7OjU6dOvHyZ2lNGU8EN/luWmJiYmP0PlAHJw0RBmTHjDJs2aW6dUL68EceP9yc2VvNMq4Jia+dANcfaOb4uyF/z3/380LFHFbatu0dCfHK64xs33uWnn1pRrlzWK25Eelpn95s2bUKhUDBz5kzGjx+vtoypUqVKTJkyhWnTppGcnMz69etzHawonh48eECPHj0YM2ZMuuPlypXj448/xtHRkZSUFEJCQjJ8u9e8eXMAjhw5ojYWGBioSnRyw8jIiMaNGxMVFcWFCxfUxtOeramXw5sePnzI4cOH+fvvv9XG4uLi+OeffwByPdU8Tadqnejp2JNO1aSiLwq/bdu86Np1d4ZFKohllKsNwz6rI0WqPNKjh+alyOvXq78dFG+P5FYir5S03MrV1RVvb2+N/6W1UJgzZw7e3t64uroCULVqVQBOnz5NcnKy2j3PnDkDkGXT+eyQPEwUhD/+uMmcOec1jllYlOLIkX44OZXTOC5yxszcgHZdK6sdj4tL4o8/bhZAREWf1hm+t7c3lpaWWTYrHDx4MO+88w5XrlzR9lGimLOzsyM0NJTTp0+rCjRpbt++jZ+fHyYmJlStWhVDQ0Mg9c1ZymvrVHr37k2ZMmXYvXs3hw8fVh2Pjo5m2rRp6c7NjcGDBwPw448/qqajA/z777/s37+fChUq0L1793TXBAQE4OfnR1RUlOpY//79Adi+fTsnT55UHU9ISGDWrFk8fvyY5s2b07BhwzyJW4iiYsOG2wwatJ/ERM1/Z6tUMQaW8G490/wNrJhr27Y8Zcuqv+nfscOb6OiMCoYir0luJfJKScytcqp169bY2Njg7+/PTz/9RFJSkmrs9u3bqiWEw4YN0/oZQhSUw4cf8tln6kVmADMzAw4f/pB69WTzmbz0fl/NyxWXL79OUlLe/HtZkmi99C8hISFb274qFAqsrKzw9fXV9lGimNPV1WX27Nm4urry1VdfUatWLWxtbQkPD+fKlSskJyfz/fffY2pqirGxMebm5rx8+ZKPPvqIypUrs3DhQtVWyV9//TVffvklDRo0oEKFCly6dInk5GSqVKmisSltTnXu3JkePXrw999/06VLF5o2bUp4eDhXr15FX1+fhQsXqnaMSTNixAiCg4P5+eef6dOnD5A6Dd/V1ZWlS5fy8ccfU79+fSwtLbl+/TohISFUqVKFX375JdfxClGUrFt3izFjDpPR5k4dOtjx/fd2tGmj3W4wImN+ft507PgO27enb4wcHZ3IwoVH6NlT84wrSO2pV7my+ltEkXOSW4m8UhJzq5wyMDDgt99+Y8yYMWzevJkjR45Qt25dQkNDuXXrFklJSQwfPpyuXbvm+jMKkZ98fF4wYMB+kpPVEyo9PR127+5J48YZf18X2qlkb059lwpcv5h+WXRQUBT//POQ7t0LdkfFokbrGVU1atTA19eX8PDwTM+Li4vjwYMHVK9eXdtHiRKgY8eOrF27ltatW/P48WOOHTvG/fv3ad26NRs3blTNQNLR0WHhwoVUq1aNu3fvcubMGSIjIwFo3749W7ZsoX379jx8+BBPT0/effdd/vrrrzzr9QQwf/58pk+fjrW1NZ6engQEBNCuXTt27NhBkybZ3yHriy++YPXq1TRv3hw/Pz88PDwwNjbms88+Y/fu3aqG6nnhSdQTgl4G8STqSZ7dU4i8tGbNTUaPzrhINXiwEwcO9MHUNNeb1YrXhIc9R6Gjw5AhQ9i+XXNT5Vmz9ql63Gj6z8nJiYCAgm/CWhxIbiXyUknMrXKqbt26uLu7M2jQIPT09Dhx4gT379+nUaNGLF26lGnTpuXJcyQPE/nl5ct4PvjAjcjIeI3jf/zRiY4d7fM3qBKkez/Ns6rWrLmVz5EUfVpn/J9++imffvopEydOZPny5ZQqpbk54Jw5c4iJiWHkyJFaBylKhhYtWtCiRYssz2vTpk2GvQrq1KnDihUr1I7/+eefuQ1PRVdXl6FDh2Z7t6Xjx49nOJbZZ8mKra0t3t7e2Tq38R+NVdsiB00IyvoCIfLR1q33+PjjfzMcnzixEfPnt0FHR3afy2uvol+iTElh/IxF2FSuxqJZ/jwOTJ/cKhTVmbFwD+Zl1FOGIP/7LJ49gdDQUJlVlQcktxJ5rSTmVm+aN2+e2k6Ar7OysmLmzJnZvp82JA8T+SElRcmQIQfx8nqhcXzWrOaMGJHzJuUi+xq4VMSirB7hL5LSHd+/348nT6KxspLWFdmldaGqYsWKDBkyhM2bN9OtWzcGDBhA3bp1KV26NDExMfj6+rJnzx5u375N9erViYmJYdeuXWr36du3b64+gBBCiKLrwAE/hg07lOFMqpkzmzFzZvMst0kXuZO2w06nHob8uSL9Wz+lEoL8TejRRGbvvG2SWwkhhNDWzJln+PtvzTvfDRnyLt9/3yyfIyp5dHUVNG5Zmn/3haU7npys5M8/7zB16tubIVrcaF2o6tWrFwqFAoVCwePHj/ntt980nqdUKvH19eX777/XOC7JlBBv3/vV3+dF3AvKlipb0KEIoeLpGUTfvn9n2GBy9uwWklTlsxbtbdUKVQCeR4Po0V8KVW+b5FZCFE+Sh4m3bfdunwx3+GvUyJLVqzvKS7984tKyNP/ue86bXZbWrr3FlCkuskIgm7QuVFlbW+dlHEKIt+h/Pf5X0CEIkc61ayF0776HuLgkjeNz57Zk2rSm+RyVKG9pzLv13uHujfQN633uvuBpcDQVbWTK+tskuZUQxZPkYeJtevAgglGj/tE4VqGCMXv2fICRkX4+R1VyWZTTB7wBp3TH/fwiOHkykPfek1YJ2aF1oSona8OFEEKINA8fRtCly25evkzQOP7tty5SpCpArTrYqhWqADyPBdFvWM0CiKjkkNxKCCFETiQkJDNgwN8acyp9/dQd/ipVMi+AyEq6i7xZqAL444+bUqjKJq13/RNCCCFyKiIijvff38OzZzEaxz/+uC4//dQqn6MSr2ve1hYdXfVp6Z5HAwsgGiGEEEJkZOrUU1y+HKJxbNmy9rRsaZvPEYlU9yhbVn0W2+7dvoSHxxVAPEWP7PMthBAiXyQmJtO37z7u3dO8G03//o6sWNFBeigUsNIWhtRvVIGrF9InvgEPXuL/IBK7qqULKDIhhBBCpDlwwI9Fi65oHOvevSKNGiVz9erVLO9z7969vA5NkEyPHlZs2BCQ7mhCQjK7dvkwdmzdAoqr6MhVocrb25sNGzZw9+5doqOjUWa0bROgUCg4evRobh4nhNBSv539eP7qOeVNyrOz386CDkeUQEqlks8+O8qxYwEaxzt3tmfTpm7o6spE38KgVYdKaoUqAM8jgdh9IoWqt0lyKyGKH8nDRF4LCopi+HDNfakghP37p7F/f2K+xiTS01SoAti8+a4UqrJB60LVjRs3GDZsGAkJCZkmUWnkDbkQBedc4DmCo4KxMbMp6FBECTV//kXWrlXfTQ7A0dGU6dMrc/v2jSzvI2/98keT1tYY/KJDQkL6HRnPnghm8Me15Hv6WyK5lRDFk+RhIi8lJaUwaNABwsJi1cb09BR8Nd0F60q7s32/K+dPsOWPRXkZogCqVDGhUSNLtaWZp04F8ehRJPb28uIvM1oXqpYsWUJ8fDxWVlZ8+OGHWFpaoqcnKwmFEEKkt3OnN1OnemYwGoG394+0avUyX2MSmTM20adhs4qcP/k43fHHgdEEPHwpy//eEsmthBBCZGX27LN4egZpHBvzdX1adaiao/sF+fvlRVhCg6FDa2nsIbZlyz3ZOCgLuZpRZWBgwJYtW7CyssrLmIQQeczvS/kGJArGlStPGTbskMYxA0MFX3xbD5vKm7N/P3nrl2+at7VVK1QBnDsRLIWqt0RyKyGKJ8nDRF45fjyAOXPOaxxr3taGzh9UyeeIRGYGDHBkwgQPkpPTz5LetOkuU6c2kZnRmdC6UJWcnIyDg4MkUkIUAYZ6hgUdgiiBnj17Re/e7sTFJamN6ejA5B+b0ah5zr6HyFu//NOoeUX09HVISky//O/8ycd8NOrdAoqqeJPcSojiSfIwkReePXvF4MEH0LQyvOw7+nw+paEUPgoZS0sTOnWy59Chh+mOe3m94OrVEJydKxZQZIWf1l1rq1SpwrNnz/IyFiGEEMVEYmIy/fr9TWBglMbx0V/Vy3GRSuQvYxN96jeuoHb8kV8kT4KiCyCi4k9yKyGEEJqkpCgZNuwQT5++0jCazNBPrDA1M8j3uETWhg7V/HJv82bpu5oZrWdUDRw4kO+//579+/fTvXv3vIxJCCFEETdhwglOndLcP6Fl+zK8/6FDPkcktNGsjQ2Xzz5VO37uRDB9hjgWQETFm+RWQgghNFm48BKHDz/KYPQglatOzM9wMpSbTW+K64Y5H3zggKmpPtHR6Xdh3Lr1Hr/80gY9PdnxWhOtC1X9+vXjwoULTJ8+nUePHtG6dWvKli2Ljk7GX2hra2ttHyeEyIUtt7YQkxiDsb4xg+oMKuhwRDG3bt0tli27lsGoLz0HvJ+v8QjtNW5phY6ugpQ3eiucOymFqrdBcishiifJw0RunDv3mGnTNG9K06JFOc6c8QQKtlAVHvYchY4OQ4YMKdA4CiNjY3369KnOxo130x0PCYnh5MlA2re3K6DICrdcbSXj7OzMwYMHWb58OcuXL8/0XIVCwd27dzM9Rwjxdkw+Mlm1LbIkSEJbAQEBhIaGZnrOrVuRfPrpVY1j5cvr8vz5ZnR1ZaZIUWFe2pDa9d/h5pXn6Y773gvn+dOYAoqqeJPcSojiR/Iwoa3w8Dg++uhvtWbcANbWpsya5USHDhqaVuWzV9EvUaakMH7GImzttJs1X5w3zBky5F21QhXA9u3eUqjKgNaFKjc3N2bPng2AUlNHtzdk5xwhhBCFU0BAAE5OTsTEZFacMAO+AjTtCJfA8+fLACluFDXN2tqoFaoAzp8K5t16BRBQMSa5lRBCiDRKpZLRow8TEKDe71NHR8GWLe9jZqb+/bkg2do5UM2xtlbXFucNc957rzLlyxvx/HlsuuN79viyfHl79PV1CyiywkvrQtXGjRtRKpW0aNGCUaNGYWNjg76+fl7GJoTIIws6LlBNORdCG6GhocTExGT4piwpMYUVvwTi7xen8fohH9uRohxYbN+UFWdNW9uwetF1tV2Gzp96zLv1yhVMUMWU5FZCFE+ShwltrFhxnb17fTWOzZzZjDZtKnH1auEqVAnN9PR0+PDDGqxadSPd8bCwWI4fD6Bz5yoFFFnhpXWh6uHDh5QpU4aVK1diYCA7DAhRmMk0c5FXMnpTtmLB1QyLVL0H1aDvsDqc/FeSqaLIolwpatYpx72bYemO37sVxqvoMgUTVDEluZUQxZPkYSKnrl9/xoQJJzSOvfdeJb77rmn+BiRyrX9/R7VCFcCOHd5SqNJA6xbzhoaGWFtb51siFRsby9KlS+nSpQu1a9emSZMmjB49mpMnT2p9z5SUFHbu3MngwYNxcXGhdu3adO7cmfnz5xMZGZmH0QshRPF12O0B/+57qHGsvksFhnyi3RRwUXg0aanesDslWYnXregCiKb4yu/cSgghROETFZVA//5/k5CQrDZWvrwRmze/j66u7BRX1LRubYulpfqsyr1772v8vS7ptP4T3qBBAx49ekR09NtPUmNiYhg+fDjLli0jKCiI6tWrY2xszOnTp/n4449ZtmyZVvccOXIk06dP5/Lly1hYWGBjY0NAQADr1q2jd+/ePH2qviW3EEKI/9y9Ecofv13XOFbRxoRvfmiCrq4if4MSea5xSyuNx+/ceJXPkRRv+ZlbCSGEKHyUSiWff34UX99wjeMbN3bD2to0n6MSeUFXV4e+fWuoHQ8Pj+PoUf8CiKhw07pQ9fnnn5OQkMD06dOJi9O83COvzJ49mxs3buDk5MSRI0fYu3cvHh4ezJ8/Hz09PZYuXcrZs2dzdM8ffviB8+fPU6FCBXbu3Mnhw4c5fPgwbm5u2NvbExwczIwZM97SJxIif8Unxav+EyKvhD6LYcH350lKUm/oXMpIl6k/N8PMXGaGFAc2lc2wqayeGHvdegVIA9C8kp+5lRAi/0geJrJrw4Y7bN6seTfXSZMa06WLLBEryvr3d9R4fMcO73yOpPDTukdVdHQ0H374Idu3b+fChQu4uLhgZWWFkZFRhtd89dVXOX5OQEAA+/btQ0dHh4ULF2Jl9d9b3V69evHw4UNWrVrF0qVLad68ebbuefPmTdzd3dHV1WXNmjU4Ov73B8bR0ZFZs2YxfPhwTp06RUhICJaWljmOW4jCpNqSaqptkYMmBBV0OKIYSIhPZv5354l4oTnp/mp6Y+yqatr9TxRVjVtaE7zFJ92x+LgUoGrBBFQM5VduJYTIX5KHiey4dy+MceOOahxr2tSKuXNb5nNEIq+1bGmLlZUJT56kn5Hu5naf+PgkDA21Ls8UO1p/JUaOHIlCkbqcIzw8nH///TfDc5VKJQqFQqtkyt3dneTkZBo2bIiDg/pOU4MGDWLVqlVcvXqVx48fY22t3kfjTXv37gVSC12vF6nSNGnShK+//hozMzN0dGT9rxBCvE6pVLJy4TV872melt5veE2atbHJ56jE2+bSwgq3NwpVqd7N91iKq/zKrYQQQhQusbGJDBjwNzExSWpjZcoYsnVrd/T1ZQZzUaejo6BfP0eWLLma7nhkZDzHjwfQtau8/EujdaGqcePGeRlHhq5fvw6As7OzxnFLS0tsbGwIDg7m4sWL9OrVK8t7pi0T7NSpk8ZxhULBZ599plW8QhRGzSo14/mr55Q3KV/QoYhi4MBuPzwOaV5L36h5RQaOlsJFceRYuxxmpQ2Iikx4Y6QWSqX68k+Rc/mVWwkh8pfkYSIr48ef4NatUI1ja9d2xt5eZqkXF/361VArVAHs2eMrharXaF2o2rRpU17GkSF//9QfhipXrpzhOWmFqkePHmV5v9jYWAICAgBwcHAgOjqaffv2cf78eV6+fIm1tTVdu3alVatWeRK/EIXBzn47CzoEUUzc94ph3VJNs2rAprIp42e4oKMjzdOLI11dBY2aVcTjn4A3Riy4f/8VGbxPEjmQX7mVECJ/SR4mMrNzpzf/+98NjWOff16fPn3UG3CLoqt5cxsqVjTh6dP0y//c3e+zalVH2dHx/xX6r0JYWBgAZcuWzfCcMmXKAKnT5LPy5MkTUlJSAHj69Ck9evRg1qxZHD58mHPnzrF7927GjBnD+PHjSUh4862xEEKUZGXYuPIxKcnqs2eMjPWY+nMzTEz1CyAukV8at9S8vP7kyef5HIkQQghR9D14EMGYMYc1jtWrV55ff22bvwGJt05HR8EHH6i3NHr+PJYzZ4ILIKLCKV+6db169QoPDw+6d++e42vTdr0xMMh45yhDQ8N052YVSxpXV1eMjIxYvnw5LVq0IC4ujoMHD7JgwQIOHjyIubk5s2bNynHMQghR3MTGJgPDeRWdrHF8/IzG2NqZ529QIt81cKmAnr4OSYkp6Y6fOqV5uYJ4e3KTWwkhhMgbAQEBhIZq9z0wMTGF0aOv8PKl+uQIExN9tm/vQalS0ly7qLp3716GY3XqaD7+v/+dxdS0OgDvvPNOpqvKirtc/cn38vJi1apV+Pj4EBcXp5qplCYpKYm4uDhevXqFQqHQKpnS1dUlJSVF1VxUk7TeGNlpfB4f/98OVQkJCezatQsbm9Smv0ZGRgwePJhSpUoxbdo0duzYwfDhw6laVdaKCiFKLqVSyY8/egG2GscHjn4Xlwxm2ojixchYn7oNy3P1Qki643fuRPH4cTTW1qYFFFnxkR+5lRBCiNwLCAjAycmJmJgYLe/QA2itcWTlyg44Oma8okgUXuFhz1Ho6DBkyJBMztIFZgDG6Y5u2XKTLVs+AsDY2Jh79+6V2GKV1oWqR48eMXDgQOLi4rLVRNXKykqr5xgbGxMZGZmuwPSmtCV6aTOrMlOqVCnVr/v06aMqUr2uT58+LF++nODgYDw8PKRQJYq8T/7+hBdxLyhbqiz/6/G/gg5HFDELF17i8OEQjWNNWlnTb3jNfI5IFKRGLazUClUABw48YOzYugUQUfGRX7mVECJ/SR5WPIWGhhITE8P4GYuwtVNfypWZ29ejWb9U8zKv4cNrMXRorbwIURSAV9EvUaakZPnnYssfT7hy/uUbRy34+vsdKBRBLJ49gdDQUClU5dT69euJjY2lfPnyDBw4kFKlSrFgwQJat25Nx44defr0Kfv378ff358WLVqwdu1arZ5jYWFBZGQkERERGZ6T1puqXLlyWd7P3Py/pSlOTk4az1EoFDg4OBAcHExgYGDOAhaiEDrge4DgqGBszNQLs0Jk5vDhh3z7rafGsUr2Znz9fSNpnl7CNG5hxepF19WO79t3XwpVuZRfuZUQIn9JHla82do5UM2xdrbPf/40hp1/HtU45uhYlmXL2udVaKIAZfXnomMPC66cP692PNjfiKZtclb4LI60bqZ+/vx5FAoFK1eu5PPPP2fUqFG88847vHz5kn79+uHq6oq7uzuNGjXi7NmznDp1SqvnpM1mCgoKyvCc4ODUarS9vX2W97OxsVHNqsqsWbquri6QeW8sIYQozu7fD+ejj/aTkqI+s8PEVJ9p85pjZCzN00ua8pbGVK1RRu34sWMBxMUl5X9AxUh+5VZCCCEKRlJSCr/Oukh0VKLaWKlSeuzY0QNTU/n5syRo0MQSA0NdtePnTklDdchFoerZs2dYWVlRu/Z/VUInJyfu3r1LcnJqs91SpUrxww8/oFQq2b59u1bPqVevHgDXr1/XOB4SEsLjx48BaNCgQZb309XVVcV844bmbUABHj58CFBip9qJ4uXS2EsEjg/k0thLBR2KKCKiohL44AM3IiLUl13r6MDEWS5Y2Uo/opKqUfOKasdiY5M4eVJmIedGfuVWaWJjY1m6dCldunShdu3aNGnShNGjR3Py5Emt75mSksLOnTsZPHgwLi4u1K5dm86dOzN//nwiIyNzFa8QRZXkYSLN1jV38boVpnHs99/fo27d8vkckSgohqX0aNjEUu140KMoQp5k3PaopNC6UJWcnKy21M7e3p7ExEQePXqkOubg4ICtrS23b9/W6jldunQB4OLFizx48EBtfMuWLQC4uLhga6u50e+bevToAcA///zDkydP1MZPnjzJw4cP0dHRoWPHjlrFLURhYmVmha25LVZm0s9EZC0lRcmwYQe5e1dzIjXkk9o0aKJeqBAlh3NTzb//hw49zOdIipf8yq0AYmJiGD58OMuWLSMoKIjq1atjbGzM6dOn+fjjj1m2bJlW9xw5ciTTp0/n8uXLWFhYYGNjQ0BAAOvWraN37948ffpU65iFKKokDxMA1y48Zfdmb41jnTpVkOXzJVCT1po3I7p9NTqfIyl8tC5UlSlTRtUbKk2lSpUAuH//vtq5L1680Oo59vb2dO/eneTkZFxdXfH391eNubu7s2bNGgA+++wztWsDAgLw8/Pj2bNn6Y736dOH6tWrExMTw9ixY9PFe/v2bWbMmAFA//79sbRUr3IKIURxNmfOOdzc7msca9DEjN6DauRzRKKwcXAqi1lp9aUJBw9KoSo38iu3Apg9ezY3btzAycmJI0eOsHfvXjw8PJg/fz56enosXbqUs2fP5uieP/zwA+fPn6dChQrs3LmTw4cPc/jwYdzc3LC3tyc4OFiVYwkhREnyIjSW3368nMFoKN99VzPTXe5F8dS4uRW6uuq/77euSaFK60LVu+++S3BwMHfu3FEds7e3R6lUpltSl5ycTHBwMMbGxppuky3Tp0+nRo0a3L9/n65du9KrVy/atWvH5MmTSUpKYvz48TRv3lztuhEjRtCtWzcWLVqU7riBgQErV67Ezs4OX19funfvTrdu3Xj//ff58MMPefr0Kc2aNWPKlClaxyyEEEWRu/t9Zs7M6IfTYPoPryiJlEBXV0EDF/UXOb6+4fj6hmu4QmRHfuVWAQEB7Nu3Dx0dHRYuXJhu98BevXoxZswYAJYuXZrte968eRN3d3d0dXVZs2YNdev+NzPA0dGRWbNmAXDq1ClCQjTvIiqEEMVRcrKSRbMuEamhnYKungLYjKmp1nuciSLM1NyAOs7qyz0DH8YBpfM/oEJE60JVly5dUCqVjB07li1btpCSkkLDhg0xMjJi69atXLp0iVevXvHrr78SHh6OnZ2d1kFaWFiwfft2vvjiC+zt7fHz8yM8PBwXFxeWLFnCp59+muN7VqpUCXd3d8aPH0/NmjV58uQJISEh1KtXj5kzZ7JmzZpcFdeEKEz+9fuXfd77+Nfv34IORRRid++GMmTIAY1jZcroA39iYKj1tw1RzDg3k+V/eS2/cit3d3eSk5OpX78+Dg7qOwsNGjQIgKtXr6r6gGZl7969QGqhy9HRUW28SZMmfP3110yfPh0dHfl3RJQskoeVbDv+vMfta881jvXoXx6Q5tklWdPWGe0G+m6+xlHYaF267dGjB3v27OHixYvMnTuXAQMGYGpqSu/evdmyZQvDhg1TnatQKOjXr1+uAjU2NsbV1RVXV9dsX3P8+PFMx42MjPj000+1KnQJUZSMch+l2hY5aELGO2iKkisiIo5evdyJjlbfhUZXV8H8+bX55JOI/A9MFFoNXCxRKED5xqaQBw8+4MsvGxZMUEVcfuVWaRvUODs7axy3tLTExsaG4OBgLl68SK9evbK8Z9oywU6dOmkcVygUGts0CFESSB5Wct288owdf97TONa0tTUt25nitgXu3dN8Tla0vU4UHi4trVi18JqGESlUaUVXV5c//viD1atXc+7cOXR1U7dW/Oabb7h//z4XL15UndutWzf69u2b+2iFEELkueTkFAYO3J/hkq3ffnuPRo3yOShR6JmXMaRylVL4P4hLd/zEiUBevUrAxES2186p/Mqt0vp9ZrazcVqh6vUm7hmJjY0lICAASG30Hh0dzb59+zh//jwvX77E2tqarl270qpVK63iFUKIoigiPI7Fsy+pvdABKF/RmC++dcbr9hkUOjoMGTIk/wMUhULZd4yo7mSB770383AHXr1KKpCYCoNcLYY1NDRUm+VkYmLCxo0buXHjBkFBQVStWhUnJ6dcByqE0N63Lb8lKj4KM0Ozgg5FFELTp5/mn38eaRwbObI248Y14No1TW96REnnVNdErVAVH5+Mh0cg3btXK6Coirb8yK3CwlJ39CxbtmyG55QpUwZArbm7Jk+ePCElJQWAp0+fMnToULUlg7t376Zbt27Mnz8fAwMpYoqSRfKwkiclRclvP14iPCxObUxXV8HEH1wwNTfgVfRLlCkpjJ+xCFs79aXYWbly/gRb/liU9YmiUGvcwkpDoUqP8+dfUFLf8by1rm316tWjXr16b+v2Qogc+MLli4IOQRRS27d7MW/eRY1jTZpYsXJlh2LbPF2m2edezTqm/OMWpnb84MEHUqh6C/Iqt4qLS/3BKbOCkaGhYbpzM/Pq1SvVr11dXTEyMmL58uW0aNGCuLg4Dh48yIIFCzh48CDm5uaqxupClBSSh5U8e/7y5vrFZxrHhn5SG8fa5dIds7VzoJpj7Rw/J8jfT6v4ROHi0tKaLWvuqh0/dSqUSZMKIKBCINeFqoSEBCIiIqhQoYLq2NGjR1WNOtu2bUvfvn2lcaYQQhQy168/Y+TIfzSOWVmZsGfPBxgaFr9daMLDnss0+zxiU9kQiALSzxI4dOghSqWy2BY537a3nVvp6uqSkpKS6e+P8v/XqmTnGfHx/+1klZCQwK5du7CxSW0Oa2RkxODBgylVqhTTpk1jx44dDB8+nKpVq2oVuxBCFHZ3b4RqLDoANGpekZ4fVc/niERhZ1fNnPIVjXn+NCbdcU/PMJKTU9DVLXm1lFz9BLJr1y4WLFhAp06dmDNnDgA7d+5kxowZQGqS4+HhwalTp1i2bFnuoxVCCJEnQkJe0bPnXmJj1de+GxjosmfPB1hbmxZAZG+fTLPPOzo6CsAbSN/E7NGjl3h5vcDJqZzG60TG8iO3MjY2JjIyMl2B6U0JCQnAfzOrMlOqVCnVr/v06aMqUr2uT58+LF++nODgYDw8PKRQJYQoll5GxvPrrIukJKs3pipX3ogvpzX6/++dQvxHoVDg0tKKA7vSz5CLjEzk3LnHtGxpW0CRFRytC1VXr17l+++/R6lU8vTpUwCSk5P57bffAKhVqxb169fH3d2dY8eOsX//frp3754nQQshhNBefHwSffq4ExgYpXF8xYoONG1qnc9R5T+ZZp9X7vFmoQpSl/9JoSpn8iu3srCwIDIykoiIiAzPSetNVa5c1r+H5ubmql9n1DtLoVDg4OBAcHAwgYGBOQtYCCGKAKVSyZK5lwl7Fqs2pqOrYMIPLpiXybr4L0qmxi3UC1UA+/b5SaEqJ/766y+USiVDhgxh8uTJAFy6dImwsDDMzc3ZtGkTRkZGdOnShSFDhuDu7i6FKiEKSM1lNXkc9RhrM2u8vvAq6HCEFgICAggNDc3VPd555x0qVarEZ58d5ezZxxrPGTeuPqNH18nVc0RJ44uuroLkN94eHzz4kG++aVxAMRVN+ZVbVa1alUePHhEUFJThOcHBwQDY29tneT8bGxtKlSpFXFycaiaWJmm7GEozdVHSSB5WMuzb7svls081jg0c/S616r2TzxGJoqRW/fIYGesRG5N+tcO+fX4sWNCmgKIqOFoXqq5du0bp0qWZPHmyKuHw9PQEoHXr1hgZGQHQqFEjrK2tuXtX8zpdIcTbF50QTVRCFNEJ0QUditBCQEAATk5OxMTEZH1yJoyNjZk40Z31629rHH/vvUosXvxerp4hSqJY6tY159q1yHRHPT2DePkyHnNzeXucXfmVW9WrV4/jx49z/fp1jeMhISGqXfsaNGiQ5f10dXWpXbs2ly9f5saNG3z00Ucaz3v48CEAlStX1ipuIYoqycOKP5+7L9i4UnN+Va9xBT4c4pjPEYmiRl9fh4ZNK3LmePqXSN7eL/DxeUGNGhnv1FscaV2oCg0NpUaNGuneip07dw6FQkGTJk3SnVu2bFm8vOTtgRAFpUa5GpQuVRpLE8uCDkVoITQ0lJiYGK17KgEE+d9n8exVzJlzXeN41aql2bmzJ/r6urmIVJRULVqUUytUJSamcOxYAL17S9PY7Mqv3KpLly4sXryYixcv8uDBA7V+UVu2bAHAxcUFW9vsLTfo0aMHly9f5p9//uHLL7/Eysoq3fjJkyd5+PAhOjo6dOzYUau4hSiqJA8r3mJjklny0wW1mcUAFuVKMf77xtKXSmSLS0srtUIVwN9/+/HNN1KoyhZTU1NiY/9bf/vixQvVlt1NmzZNd+6zZ88wMTHR9lFCiFw6Pvx4QYcg8oC2PZUAnj1NAIaQkqI+ZmZmwL59vSlXzih3AYoSq2XLd1i27IHa8YMHH0ihKgfyK7eyt7ene/fu7N+/H1dXV1asWIGdnR0A7u7urFmzBoDPPvtM7dqAgAASExMxMzNLtythnz592Lx5M76+vowdO5bffvsNB4fUwvrt27dVzeD79++PpaX8sC5KFsnDirft65/y7In6rHeFAsbPaEyZsqU0XCWEuoZNK6Kjq1Brxr9vn1+Ja6egdaGqcuXK3L59m5CQECwtLTl8+DBKpRI7OzsqVaqkOs/T05Nnz57RsGHDPAlYCCFEzkS/TGDdkiBAvRClUMBff71PrVrSN0Foz8HBBBsbU4KD0y9rOXToIUqlEoVC3iRnR37mVtOnT8fHxwcfHx+6du1KjRo1ePnypao31fjx42nevLnadSNGjCA4OJjevXszb9481XEDAwNWrlzJ6NGj8fX1pXv37lStWhWFQsH9+/cBaNasGVOmTNE6ZiGEKHyac+uq5iWd/Uc4Ude5gsYxITQxMzfg3brvcPva83THT58OJiwstkS9VNa6UNWuXTuuX7/OyJEjadWqFbt27UKhUNCjRw8gdbcYNzc3li1bhkKhoGvXrnkWtBBCiOxJTkrh1x8u8jwkUeP4Tz+1okePavkclShuUr/PV2HNmlvpjgcHR3P7dih16pQvoMiKlvzMrSwsLNi+fTtr167l0KFD+Pn5oaenh4uLC0OGDKFz5845vmelSpVwd3dnw4YN/PPPP/j7+6Orq0u9evXo1asX/fv3R09P69RTCCEKlXv3ooAeGsdq1X+H/iM074IqRGZcWlqpFapSUpQcPPiAoUNrFVBU+U/rbGH48OGqRpwPH6a+Ma1evTqjRo0CwM/Pj/nz5wPQpk0bBg4cmDcRCyGEyLYNK29x7WKIxrHBg52YMsUlnyMSxZWmQhWkzqqSQlX25HduZWxsjKurK66urtm+5vjxzJcwGRkZ8emnn/Lpp5/mKjYhhCjMXr6MZ+rU22j6cdq8jAHf/OCCrq7MJhY517ilFeuW3lQ7vm+fnxSqssPQ0JCNGzeyZ88evLy8sLe3p2/fvhgbGwOpWx87OTnxwQcfMGzYMHR0dPIsaCFEznx37Dsi4iIoU6oMc9vPLehwRD45uv8R+7bf1zjWuHFF/vijkyzJEnmmfXs79PR0SEpK3wjt0KGHTJ4sBdHskNxKiOJJ8rDiRalU8sknRwgMjNU4/vX0xpR9p+Qs0RJ5y8rGFEsrA0KeJKQ7/s8/D4mPT8LQsGTMTM7VpzQwMMhwC+KyZcuyd+/e3NxeCJFHNtzYQHBUMDZmNpIglRD3boayauFVjWPW1qa4ufXCyEg/n6MSxVnp0oY0b27NqVPpd6s5fTqYly/jMTc3LKDIihbJrYQofiQPK17Wrr3Ftm2ad13tM7gGDZtWzOeIRHHzbn1TQp68SHcsOjqRkyeD6NTJvmCCymfyKk4IIYqZ509jmPfdeZKS1LdJNjDQwc3tA6ytTQsgMlHcde1aRe1YUlIKx44FFEA0QgghRN66des5rq6al0DXrFOOQWNLztIs8fbUqq85T//7b798jqTglIx5Y0KUcIcGHyIxJRF9HZlBU9zFxSbx09SzRIbHaxyfMaMmjRtb5XNUoqTo2rUKU6d6qh3/55+H9O5dvQAiEkKIgid5WPEQHZ1A//5/ExeXpDZmaqbPNzNd0NOTeSAi9+yqlgKigfQFq7//9mPJknYlonWHFKqEKAHqWNYp6BBEPkhJUbJ49iUe+kZmcMZxunZtl68xiZKlbt3yWFub8vhx+q26Dx1KbQxeEhIrIYR4k+RhRV9aXyovrxcax7/8rhHlKxrnc1SiuNLRUQBeQKN0x/39X3LrVih16xb/TWqk5CuEEMXExlW3ueD5WOPYu/VMgH/yNyBR4igUCrp0sVc7HhgYxd27YfkfkBBCCJEH/vd/7N13XFPX+wfwTxJmANkigoAIQRQXuPfe4rZqrcVRf7aVftW6tbZVq9U6Wq1b66ijVVEQcc+KW1FwICgCYSgKsleA3N8flNSYQQghi+f9evkqPffccx8ihifPPfec7ZE4dCha6rGufazRtnN9NUdE9N8zqa215fE/KlQRQogeuBAaj+BDsVKPuTSsg0+/cAQguWYVIaombZ0qoHxWFSGEEKJrIiLS8L//XZFxlI9Bo/R/dgvRhFgYGkrORK8thSp69I+QWuBB6gMIygQw4hjBr76fpsMhKhb14C22rX0o9VgdKyMs+rkD8vMSAADR0dLvBlZG2fNI7dO7tys4HBbKysQLo2fOxGPOnDYaiooQQjSH8jDdlZVVhFGjTkIgKJM4VqeOAXJyDsDAoI8GIiP6rxh+fta4fVv8cdO7d18jLS0fDg5mGopLPRQqVA0ZMgRubm7YtGmTqC01NRXGxsawtbWtseAIIaox9K+hom2Rk2cnV34C0RnJiTlYvfi2RFEAAAwM2Vi4sgPqOZnj/s13YLHZmDBhggaiJLWJlZUJOnSoj/DwFLH269eTkZsrgIWFkYYi0y6UWxFSe1AeppsYhsGkSWcRHy997c8ff2yCWbMy1RwVqU26drWTKFQxDBAW9gqTJ+v32ncKFapSUlJgYmIi1tazZ0+0bt0aBw4cqJHACCGEyJeTVYwV824iP69E6vHAhX7wbm4HAMjPywEjFGLW0vVwdvWo8rUe3L6KQzvXVyteUnsMGNBQolBVUiLE5ct8DB1a9Z8/fUS5FSGEaLf16+8jOPil1GPz5rVB164Wao6I1DZdu9pizRrJ9tDQOCpUVUhOToZAIICR0X93QhmG1jshRBd84fsFsouzYWlsqelQiIqUCMrw8+LbeJOSL/X4mIDG6NbXRaLd2dUDjbx8qny95MTa8Tw8UY0BAxpi8eJwifazZ+OpUPUByq0IqR0oD9M9N26kYP78f6Qe69LFGT/91AVRUY/UGxSpdRwdTdGsmR0eP04Xaz9/PgFFRaUwMdHflZwU+s54PB4iIyMxaNAgNG/eXJRQJSYmYuHChQpdiMViYeXKlcpHSghR2vfdv9d0CESFhEIGv664j2eR6VKPd+7ljHFTmqg5KlKbfbyGGcMwsLU1QkaGQKw9JCQGU6fagMUSXxzUzs4OLi6ShVV9RrkVIbUH5WG65d27AnzySajUZRXs7U3x11+DYWBAe5IR9RgypJFEoaqgoBRXrvAxYIC7hqKqeQoVqr788kt8+eWXSEpKQlJSkqg9PT0dJ06ckHsui8UCwzCUTBFCiAowDIM9v0fhxmXpa1x4NbVB4KLWEoUAQmpCZoa8tc/GABBfPP316yK0bj0QwFuxdi6Xi+jo6FpVrKLcihBCtE9ZmRCffhqGlJQ8iWMsFnDo0GDUr2+ugchIbTVkSCOsXHlHoj00NI4KVd26dcPff/+Nc+fOITMzE0KhECdOnICdnR26dOlS0zESQgj5V8jhFwg9In29BPt6XCxc1QHGxhw1R0VqK3lrnz26l4M/t72WOMd/zBp062cj+v/kxJfYsGw20tPTa1WhinIrQgjRPosXh+PChUSpx374oSN693ZVc0Sktmvb1hF163Lx9m2BWPupU6+weTOjtzenFX6osVmzZmjW7L8Fu06cOAFXV1esWrWqRgIjhBAi7sHtHBzaKfnBHwC45oZYsqYjrGxMpB4npCZJW/vMwVGAgztCIRSK9018xVJqnTR9RLkVIYRoj7//fo7Vq+9KPda3rxuWLOmg5ogIAdhsFgYNcseePU/E2pOSchEZ+Q4tW9bVUGQ1S+mHa2fMmIERI0aoMhZCSA3p/EdneGz0QOc/Oms6FKI0T/z9h/QilYEhG4tWdYCrOy3SSrSHeR0j8JraSrQ/jUxHYUGpBiLSfpRbEaKfKA/TfpGRbzF58lmpx5yczHHgwECw2fo5c4VovyFDGkltDw3V382OlF4mfsaMGWL///LlS8THxyM/Px9mZmZwdXUFj8erdoCEkOpLyEpASm4KikqLNB0KUcLTpzkAJqKsTPIYiwXMXtoGPq3s1R4XIZXxbeeA548zxNpKS4R4HPEWbTvX11BU2otyK0L0E+Vh2i0joxDDhgWjQMpNFCMjDoKChsLenquByAgp16ePK4yMOBAIxD8MhIbG4bvv9HOmX7X3M7x48SJ++eUX8Pl8iWOOjo6YO3cuBgwYUN3LEEKqwcbUBsVlxbAxtam8M9EqkZFvMWPGIwDSH+mb8r8W6NjDWa0xEaIo3/b1cGjXM4n2h3fSqFAlB+VWhOgXysO0V2mpEGPHnkJCQo7U41u39ka7do5qjooQcebmRujZswHOnk0Qa7937w1ev86Do6P+LfBfrULV3r17sXr1ajBM+dad5ubmMDMzQ05ODgoLC5GamorZs2cjNTUVU6ZMUUnAhJCqi/oyStMhECU8e5aO3r2PIidH+mNSIz7lYfAoD6nHCNEG7jwrWFobIzuzWKw94vYb0a51RBzlVoToH8rDtBOfz8fixbdw8WKS1OOjRzuhZcsSRERESD0eHR1dk+ERImbIkEYShSoACAt7halTm6s/oBqmdKHq2bNnWLNmDRiGwSeffILJkyfD1fW/XRDi4uKwd+9eHD16FBs2bECnTp3QuHFjlQRNCCH67sWLTPTqdRTp6YVSj/fo74LPptOC1ES7sdks+LZzwJWz4jOD0l4XIDUpD04uFhqKTDtRbkUIIerB5/Ph6TkBAoG/jB6vcPToAhw9KmXdBUI0YPDgRvj660sS7aGhcVSo+tDevXshFArx9ddfIzAwUOJ4o0aNsHz5ctjb22PLli04dOgQli1bVq1gCSGkNoiLy0KvXkfw5k2+1ONtOjni6wV+NBuF6ATf9vUkClUA8OD2GypUfYRyK0IIUY+TJ2MgEAySeszS2gCzvusDC0v5j1g/uH0Vh3aur4nwCJHg4lIHLVrYIzLynVj7hQuJKCwsgampoYYiqxlKF6ru3bsHCwsLTJ8+XW6/6dOnY//+/bh9+7aylyKEEKXx+Xykp6crfb6dnR1cXFxUGJF8FY/7vX4tvUjVsm1dzF3WDgYGSm/aSohatWhTF2w2IBSKt0fcfgP/MZ6aCUpLUW5FCCE1LzLyLRYseAKAI3HM0IiNJWu6wNO78vXEkhP1d8c1op2GDGkkUagqLCzF5ct8DBokfWdAXaV0oSo9PR2NGzeGoaH8yp2RkREaNmyI2NhYZS9FCKmm9bfWI6c4B3WM62B2h9maDkdt+Hw+vL29UVBQoPQYXC4X0dHRailWRUSkoV+/YzIf92vkZYqFKzvAyFgysSJEW9WxNIantw1inr4Xa3/6KB3FRdLXX6utKLciRD/V1jxMG6Wk5GLQoOPIz5f+SN/X8/0UKlIRoglDhjTCihWSN6lCQ19RoaqCqakpMjMzFer7/v17mJhI37GKEFLz1t9aj5TcFDhZONWqBCk9PR0FBQWYtXQ9nF2rvuh4cuJLbFg2G+np6TVeqLpyhY/hw0OQnV0so0cCJgf2gbFJtTdrJUTtfNvXkyhUlQiEePzwHazp84AI5VaE6Kfamodpm8zMIgwadBwpKXlSj4+b0gTd+6lvFj0hVdW6dT3Uq2cmsTzIqVNxYJjeerUsiNKfeLy8vHD//n3cv38frVu3ltnv7t27SElJQZs2bZS9FCGEVIuzqwcaeWnvwuMHDjzD5MlnUVIilHq8adM6ePp0N0xM+6k5MkJUw7e9Aw7vfibRHnE7Db0GUvG1AuVWhBBSM/LyBBg06LjEY1MVegxwxZgA2pyCaDc2m4VBg9yxe/djsfaUlDw8fPgWvr4OGopM9ZRe5MTf3x8Mw2DWrFmIjIyU2ufRo0eYPXs2WCwW/P1l7ahACKlpB0YcwNlPz+LAiAOaDoV8gGEYrFhxC599dlpmkaprV2ds3doSQJFaYyNElRp5WcPSyliiPeL2Gw1Eo70otyJEP1EepllFRaUYPjwEt26lSj3ezNceX83z1avZKER/DRki/RG/0FD9WjNN6duYI0eORFBQEB49eoSxY8eiefPmaNq0KSwsLJCbm4unT58iKioKDMPA19cXI0aMUGXchJAq6O7WXdMhkI/k5gowadIZBAW9kNmnf383BAUNxfPnj2X2IUQXsNkstGzngGvnxHf/e5OSj3dpAg1FpX0otyJEP1EepjnFxaX45JNQXLyYKPW4g6MR5v/UHoaGtEkN0Q29e7vA2JiD4mLxddZCQ+Pw/fcdNRSV6ildqGKz2di1axfmzJmDq1evIjIyElFRUaLjDMMAALp164Y1a9aAw6HFfwkhBACiozMwYkQInj9/L7PPmDFe2L9/AIyN6bEooh98pRSqAOD5Y+k7XNZGlFsRQojqFBaWYMSIEJw9myCjRya+mO0HcwsjdYZFSLWYmRmhd29XhIW9Emt/8CANqal5qF/fXEORqVa1PgGZm5tj27ZtiIyMxOXLlxEfH4+8vDyYmZnB3d0dPXr0QMuWLVUUKiGE6DaGYbBzZxRmz76K/PwSmf3mzWuDVau6gs2mKehEf7Rq6wAWC/i31iJChSpxlFsRQkj15ecL4O8fjMuXJW+QAICtrREyMnbA2uYPNUdGSPUNGdJIolAFlC+qPm1aCw1EpHoquVXfokULtGihHy8IIfooPjMeZUwZOCwOGlo31HQ4tdLr13mYOvUcTp+Ol9mHzWZh8+ZemD69pfoCI0RN6lgZw6OxNV5Ei+9q9zKmACpKR/QK5VaE6A/Kw9Tr3bsC+PufwO3br6Uet7IyxubNLTB2bLqaIyNENQYPdpfaHhpKhSpCiA7psqeLaFvk5NnJmg6nVikrE2LHjigsWnQdWVnFMvvZ2pri8OFB6NPHTX3BEaJmvu3rSRSqSksYANIXBiWEEH1AeZj6xMS8x8CBQXj1KlvqcSsrY5w7NwoGBtKLWIToAicnC/j6OiAiIk2s/eJFPgoKSsDlGmooMtWhVeMIIaSG3LqVirZtD+Krry7KLVK1bu2AiIjPqEhF9J5f+3oyjnipNQ5CCCH65+pVPjp0OCSzSGVra4rLl8egbVtHNUdGiOoNGSI5q6qoqBSXLkl/3FXX0IwqQmqB4Y2HI7MoE9Ym1poOpVaIinqHJUvCFdom9ssvW2D9+h4wMaG3Y6L/GjW2hoWlEXKzP97pr7FG4iGEEHWgPKxmCYUM1qy5i8WLwyEUMlL71K3LxaVLo+HjY6/m6AipGUOGNMKPP96SaA8NjcOQIbo/U11nPhkVFhZi165dCAsLQ3JyMszMzODj44OJEyeiW7duKrlGamoqhgwZgry8PFy6dAnOzs4qGZcQTds0cJOmQ9B7DMPg5s1UbNhwH0FBLyrt7+hoht27+2HAAOnPmBOijzgcFlq1dcA/F5I+OmKPpKQC+PpqJCxCCKlRlIfVnPT0Anz++Rm5a4A2bGiJM2dGwsvLRo2REVKzfH0dUL++OVJT88TaQ0PjIBQyOr8pk048+ldQUIDPP/8cv//+O5KTk+Hp6Qkul4vw8HBMmzYNv//+e7WvwTAMFi1ahLy8vMo7E0LIv0pKynDoUDTatTuIzp0PK1Sk+uQTLzx+HEBFKlIr+cp4/O/mzfdqjoQQQoguO3YsBk2b7pVbpGrf3hG3b4+nIhXROywWS+qi6m/e5OPBgzcaiEi1dGJG1bJlyxAZGQlvb29s3boVjo7lzxUHBwdj8eLF2LRpE3x9fdGxY0elr3Hw4EHcuiU5dY4QQj7GMAzu3n2DAwee4a+/niM9vVCh83g8a2za1At9+7rVbICEaLFWbR3AYgHMR09n3LiRoZmACCGkFuHz+UhPr95ud3Z2dnBxcVFRRFWXkpKLb765jOPH5d8cHDnSE3/+ORCmprq/sDSpnaKjo+Ue9/aW3r5jxw04OLTV6L/T6lK6UCUQCGBkZKTKWKTi8/k4efIk2Gw21q5dKypSAcCwYcMQHx+Pbdu2YdOmTUoXqhITE7F27VqYmpqisFCxD5yEkNonLi4LBw48w4EDz/DyZZbC59WpY4SFC9th1iw/GBvrxP0BQmqMpbUxPBpbS+z+d/9+JoqKSmv1em3qyq0IIbUTn8+Ht7c3CgoKqjUOl8tFdHS02j8E5+YK8Msvd7F27X0UFpbK7Mdms7BiRWfMn99W5x9/IrVTZsY7sNhsTJgwoZKeBgB+BCCeO+zadQOHDn2ukX+nqqJ0NtilSxcMHjwYw4cPh4+PjypjEhMSEoKysjL4+vrCw8ND4vj48eOxbds2REREIDU1FfXr16/S+EKhEAsWLEBhYSEWLVqElStXqip0QrSG/2F/vCt4B3uuPU6OO6npcHQMF0eOJGPGjOe4dSu1amdyDfDNN76YO7cNbGxMayg+QnRPq3YOEoWq4mIh/vknuVbPOFRXbkUIUS9tycPS09NRUFCAWUvXw9lV8nOVIpITX2LDstlIT09X2wfg3FwBdu6Mwpo1d5GWJr/IVq+eGQ4fHoTu3XXzwzkhAJCflwNGKFTo3+rujcl4Fpn/UasTCgoM1frvVNWULlRlZ2fj0KFDOHToEDw9PTFixAj4+/vDxka1z/8+evQIAODn5yf1uIODA5ycnJCSkoK7d+9i2LBhVRp/9+7diIiIgL+/P3r16kWFKqKXIl5HICU3BU4WTpoORSeUCMpw78ZrnDqWDGApVq+OrdL5NjYm+L//a4FvvvFFvXpmNRMkITrMt309HNn7XKL9zJn4Wl2oUlduRQhRL23Lw5xdPdDIS/uL4Skpudi2LRK///4QWVnFlfYfNMgdu3b1o9yL6A1F/q1272eGZ5ERUo40qZmg1ETpQtXBgwcRHByMs2fPIjY2FqtXr8batWvRvXt3jBgxAt26dQOHw6l2gImJiQAgtxJYUahKSEio0tgvXrzAxo0bYW9vjyVLliA3N7c6oRJCdBjDMIiLycLl0wn450IS8nJL/j2i+PuYt7cNZs70w4QJTcDl0noIhMji6W0DizpGyM0RiLWfOROPDRt6aCgqzVNXbkUIIdVV2do5lZG1zpVAUIZz5xKwc2cUwsJeQShkpJwtztbWFBs39sS4cY3BYtGjfqR2ad1R+iY1gIwFrHSE0oUqPz8/+Pn54bvvvsOFCxdw4sQJ3Lp1CxcvXsSlS5dgY2MDf39/jBgxAp6enkoHmJFRvriqvLuJVlZWAIDMzEyZfT5WWlqK+fPnQyAQYPny5bC0tKRCFdFbybOTNR2C1irIL8Hl04k4HxoP/qucKp9fp44RRo/2woQJ3ujatQGthUCIAjgcFlq2qYvrl8Tfm2Ji3iM+PgsNG1ppJjANU1duRQhRL33KwxRfO0e+D9e5Ki0V4soVPv7+OwbHj79AZmaRwuNMnNgEv/zSDXXr0iwqUjvZ2JnCo7E1Xj7/uBbigcLCMo3EpArVXrHUyMgIgwYNwqBBg5Ceno6QkBCEhIQgNjYWe/bswd69e9G0aVOMHDkSgwcPhoWFRZXGLyoqEl1HFmNjY7G+iti6dSuePn2K4cOHo0eP2nv3lpDa6k1KHsKC4nDxVAIKC2QvyCmNoSEbAwe6Y8IEbwwe3KhWL/5MiLJ829eTKFQB5bOqvvqqlQYi0h41nVsRQoiyqrJ2jizl61zNw/Hjz/HkSTROnnyJd++qtqFVjx4NsHZtd/j6OigVAyH6pE0nRymFKkPcvv0enTppJKRqU+mnKzs7O0yZMgVTpkxBUlISwsLCsGPHDjx9+hRPnz7Fzz//jH79+uHzzz9H06ZNFRqTw+FAKBTKncbJ/LvHNZvNVmjMp0+fYtu2bXBwcMCiRYsUOocQoh8SXmbjrz3PcOefVDCVzyYX07FjfXz2WROMHu0FW1taHJ2Q6mjVTvqHCypUiauJ3KpCYWEhdu3ahbCwMCQnJ8PMzAw+Pj6YOHEiunXrppL4U1NTMWTIEOTl5eHSpUtwdnZWybiEEM1SZp2rvFwBHtx6g0thpgB+wKxZUVW+bteuzli4sB369XOjx/wI+VebTo44vPuZRPv16+n49lsNBKQCKp8GUFhYiIsXL+LChQu4fv06CgvLq+PW1tbIy8vDyZMnERoaijFjxmDp0qWVrrXA5XKRnZ2N4mLZC+gJBOVrXFTMrJJHIBBg/vz5KC0txfLly1GnTp0qfHeEEF2VlJCDv/6Ixo3LVZ1+/w4jRzbExInN4OxsCkCIxMRo/Lt8nkJkrcNASG1mZWOCRl5WiIvJEmu/fJmPoqJSmqn4AVXnVgBQUFCAgIAAREZGwtDQEJ6ensjKykJ4eDjCw8MRGBiIGTNmVCtuhmGwaNEi5OXlVWscQojuys4sxs2rybj9TyqeRLxDWVnFXcLKP7dVYLNZGDKkEebNa4OOHbVjQXpCtElDT0vY1jVFxlvxmYnh4RkQChmdXJpEJVkgwzC4efMmQkJCcOHCBRQVFYFhGBgYGKBHjx4YOXIkevTogdzcXJw4cQIbN27EkSNHYG5ujrlz58od29raGtnZ2cjKypLZp2JtKltb20pj/e233/DixQuMHDlSZXcLCdF2ex/tRb4gH2ZGZghoGaDpcNSsDg7teo2Hd2IgFCp2hinXAJ17OaN+gwzs2zofQUFCBAUpH8GH6zAQQv7j266eRKGqoKAU4eEp6N3bVTNBaYmazK0AYNmyZYiMjIS3tze2bt0KR0dHAEBwcDAWL16MTZs2wdfXFx07dlT6ezh48CBu3bql9PmE6IvalocVF5XibvhrXDvPx8M7aR8Up6qmQQMLTJ3aDJMnN4OzMz3iTIgsLBYLbTrWw9ngeLH2jAwB7t17g3btHDUUmfKqVaiKiYlBSEgITp06hXfv3okewWvYsCFGjBiB4cOHw87OTtTfysoKkyZNgoODA2bPno3g4OBKkyl3d3ckJCQgOVn2LIiUlBQAgJubW6UxnzlzBgAQFBSEIDmfPHv16gUAmDFjBgIDAysdlxBttuTyEtG2yLUhQQKA4uJS7NmTAGAeHtxSbJF07+a26OvfEB26OcHE1ADXzocAjCrWYZiN9PR0KlQR8hHf9g44uv+5RPuZM69qbaFKHbkVn8/HyZMnwWazsXbtWlGRCgCGDRuG+Ph4bNu2DZs2bVK6UJWYmIi1a9fC1NRUNAOMkNqqtuRhSQk5OB0Uh6vn+FVe/7OCtbUhevWqi75966JlSytwOCy8ffsCb9+K96PZ6oSIa93JUaJQBQChoXG1q1A1dOhQxMbGAii/68flcjFgwACMHDkSvr6+cs9t1ap87YmSkhK5/QCgRYsWuHz5Mh49eiT1eFpaGlJTU8XGlcfHxwcODtLXxRAIBHjy5Imon5GRkVjyRgjRDadPv8L//ncZL19mobKp5QYGLHTp3QCDR3ugkZe11D7KrMNACKkcr4kNTLlsFBaIT3c8cyYe69bVvo1O1JVbhYSEoKysDL6+vvDwkCzCjx8/Htu2bUNERARSU1NRv379Kn0fQqEQCxYsQGFhIRYtWoSVK1dW6XxCiO4QChncv/kaYUFxiLz3tvITpMoG8BTAE2RmxuHYMSGOHZN/Bs1WJ0Rcc9+6MDbhoLhIfKe/0NA4rFjRWUNRKU/pQlVMTAyA8q2UR44ciQEDBsDUVLHFhfPy8tCpUyeFCkv9+/fHhg0bcPfuXbx69Qru7u5ixw8dOgQAaNu2rUILdG7cuFHmseTkZNFMqt9++40W/CR6Y+OAjSgoKQDXkKvpUGpURkYhvvnmMg4diq60r5ExBwNHNsLQTzxhbWuihugIIR/jGLDBa2qGyHu5Yu3R0e+RmJgNV1dLDUWmGerKrSpu/vn5+Uk97uDgACcnJ6SkpODu3bsYNmyYQjFU2L17NyIiIuDv749evXpRoYrUevqYhwmFDMIvJeHvPdFISsit/AQJb9GmkwM6dG+ABm4mYLPbKnwmzVYnRJKRMQct2tTF3euvxdqjot7pZE6ldKFq2rRpGDlyJFxdqz4139PTE7t371aor5ubGwYPHoxTp04hMDAQW7ZsEV0zJCQEu3btAgB8+eWXEufy+XyUlJTAwsICdevWrXKchOiLEd4jNB1CjQsOfoHp0y8gLa1Abj9DIzb6D3PHyAlesLKhAhUhmtbYR7JQBZTPqpo+vaX6A9IgdeVWif/uBiHvA15FoSohIaFKcbx48QIbN26Evb09lixZgtxcZT7AEqJf9CkPK38c2Qdrv09AWqqgSud6elujfVcnsDnR2LflF4ydfJJmrBOiQm06OUoUqgDg1KlX+Ppr3dpRWelClbu7O/h8vkLJ1PHjx5GQkIDZs2crda0lS5YgNjYWsbGxGDBgAHg8HnJyckRrU82aNUvqGgoBAQFISUnB8OHD8fPPPyt1bUKIdsvMLMKMGZcUmkXVY4ArJkxrClt7xWYoEEJqXuNmZlLba2OhSl25VUZGBgDAxsZGZh8rKysA/21Yo4jS0lLMnz8fAoEAy5cvh6WlJRWqCNEjcTGZOLa/DMDnChepnFzM0a2vC7r2aYB6TuYAgGvnJdcmVEZ0dOW5X02cS4i2at1B+rJFoaFxtadQtWDBArRu3RpdunSptO/BgwcRHx+vdKHK2toaf//9N3bv3o0zZ84gLi4OBgYGaNu2LSZMmIB+/fopNS4hRLfdupWKceNOITFR/mLpzq7GmLGwAxr7VL4zaE2hZIoQ6epYGgBIBiD+uP2lS3wIBGUwMuJoJC5NUFduVVRUBAAwMjKS2cfY2FisryK2bt2Kp0+fYvjw4ejRo/atMUaIvsrLEWDf1se4eCoBjAIb+BkZsdG1rwv6DW0Ij8bWYLFYKo0nM+MdWGw2JkyYoNJxCdF11rYm8PS2xoto8ZtMV64kITdXAAsL2b/3tY1Char09HS8ePFCoj0nJ6fSbYdTUlLw4sULGBhUa4NBcLlcBAYGVmkHvsuXL1fpGs7OzqL1IQjRJ7nFuWDAgAUWLIx1f3tfoZDB2rX3sGjRdblbHltYGCA39zD+t2QxPL01U6SiZIoQRcTg40JVfn4JwsNT0LOnfq4/osncisPhQCgUyv3wWLHbIJvNVmjMp0+fYtu2bXBwcMCiRYuUiosQfaWreRjDMLhxOQW7fnuErPfFlfa3r8fFgOHu6D3YDXUs5W9mUx35eTlghNXblfnB7as4tHO9iiMjRPPadHKUKFQJBGU4ezYeo0d7aSiqqlMowzE0NMTMmTORk/PfrAUWi4UXL15g8uTJlZ7PMAzatGmjfJSEkGrx3uwt2hY5eXaypsOplrdv8zFx4hmcO5cgt9+gQe4IDHRE//6zwGar9k5eVVAyRYgiYgD0kmg9c+aV3haqNJlbcblcZGdno7hY9gdPgaD8sZ6KmVXyCAQCzJ8/H6WlpVi+fDnq1KmjVFyE6CtdzMOyM4uxec0DqevdfKyekxnGBHijW58G4BgoVtxWhersypycGKfiaAjRDm06OeLQrmcS7SdOvNC/QpWlpSW+/PJLsXWeWCyW6G6bLCwWC1wuF02aNMEPP/xQrUAJIeT69WSMGROKN2/yZfaxsjLGb7/1xGefNcHDhw/VGJ18lEwRIk8izM0NkJdXKtZ6+nQ8fvmlu2ZCqmGazK2sra2RnZ2NrKwsmX0q1qayta18Nupvv/2GFy9eYOTIkejWrZtSMRFCtEfE7TfYuPJ+pbOobOxMMH5qU/To76LWAhUhRDY3D0vY2BnifXqJWPupU69QXFwKY+PqPemmLgpHGRAQgICAANH/N27cGH5+fjh48GBNxEUIUaFubt2QXpAOO66dpkNRCsMw2LLlEWbOvILSUqHMft27N8CBAwPh5KQ70+oJIQAgRLt21rh06Z1Y67NnGYiLy0KjRlaaCauGaSq3cnd3R0JCApKTZc/sqNiwxs3NrdLxzpw5AwAICgpCUFCQzH69epXPmpsxY0aVlnIgRNfpSh5WXFyGP7c+xqljld0gE6DPEEdM+aYzTEx140MvIbUFi8VCM19zXDsv/vhfbq4Aly7xMXCgu4Yiqxql31mGDRsGd3fd+CYJqe0OjtDdgnJRUSm+/voi/vjjicw+bDYL33/fAYsXtweHQ3f0CNFFXbrYSRSqAODkyZeYNau1BiJSP3XlVi1atMDly5fx6NEjqcfT0tKQmpoKAGjVqvJdgnx8fODg4CD1mEAgwJMnT0T9jIyM4OgofVciQvSVLuRhqUm5WL3kNhLj5G9Q4+bBQsLLX9B/2H4qUhGipZr5WUgUqgDg+PEX+l+o+nCqOiGE1ISUlFyMGBGCu3ffyOxTv745Dh0ahG7dGqgxMkKIqnXubAs2mwWhUPzRt5CQ2lOoUldu1b9/f2zYsAF3797Fq1evJIpjhw4dAgC0bdsWzs7O0oYQs3HjRpnHkpOTRTOpfvvtN4XGI4So193wVPy6/B4K8ktl9rG0MsbUmS1QVvYAvy7PUl9whJAqc3U3AZADQHzNyJCQl9i2rQ8MdOBRXYUKVUlJSQCA+vXrg8PhiLVVRYMG9EGSEKKY8PBkjBgRjHfvZG+N3qmTLX780RsWFu8QESE5EyM6OromQySEqJC1tRE6dXLC9evij6OFh6cgI6MQtramGoqsZmgyt3Jzc8PgwYNx6tQpBAYGYsuWLXB1dQUAhISEYNeuXQCAL7/8UuJcPp+PkpISWFhYoG7dulW+NiFEe5SVMfhr9zMc3f9cbr82nRzx9QJfWFmb4Nr5CDVFRwhRVvlGUk8AdBRrT08vRHh4Mrp31/6NahQqVPXp0wdsNhthYWFo2LAhAKBv375VuhCLxcKzZ5KrzxNCyMd27YrCl19eQGmpvEWFz+PGjYvo3Vv+wsOEEN3h799IolBVVsbg9OlX+OyzphqKqmZoOrdasmQJYmNjERsbiwEDBoDH4yEnJ0e0NtWsWbPQsWNHifMCAgKQkpKC4cOH0+x6QnRYXq4A676/i4d302T2MTLmYHJgc/Qb2hAsluZ2UCaEKEOyUAWUP/6nN4UqABAKxRcwrmxXmo9VtT8hRHUmhUxCRkEGbLm22DN0j6bDkamsTIj58//BunX3ZfYxNmFj/NR68GkVCED+YrwPbl/FoZ3rVRwlIaSmDB3qgblzr0m0nzwZp3eFKkCzuZW1tTX+/vtv7N69G2fOnEFcXBwMDAzQtm1bTJgwAf369VN6bEKIOG3Lw9LfCrBh2VUkJ+bK7OPmYYk5P7aFs2sdmX0IIdosDnXqGCAnR/yR3uPHX+DXX3v+O+tKeylUqLp06RIAiC2UWdFGCNF+F+IuICU3BU4WTpoORaa8PAE+/TQMJ0/K3mmmfgNzLFzVAQ3cFEuakhMr27WGEKJNPD2t0bixDZ4/fy/WfvZsvE5tqawIbcituFwuAgMDq7QD3+XLl6t0DWdnZ8TExFQ1NEL0inblYQ3x2098FOSVyezRo78Lps9pBWMT/XnPJaT2EaJrVzucOiW+1m9KSh7u33+Dtm21e2MThd59nJwk31SltRFCiDKSk3MxZMgJPHr0Vmaf1h3rYdbStjAzN1RjZIQQdRs61APPn98Va8vLK8GVK0no37+hhqJSPcqtCCHqdurUawDTZBapDAxYmPK/Fug/zJ0e9SNED/TsaS9RqALKZ1XpRaFKGTExMRAKhfD09ISBAVXjCdGkyOmREDJCsFnat8PD/ftv4O9/Aq9f58vsM/rzxhg3pYnWT1ElhFSfv38jrF59V6I9JOSlXhWqlEG5FSG6SdN5mFDI4LvvwrFyZTRkffyzsTPB/BXt4eVjq97gCCE1pl07G5iZGSI/v0SsPSgoFqtWddHqgnS13i0LCgqwc+dOHD16VNSWlpaG4cOHY9iwYRgxYgT69u2Le/fuVTtQQojybLm2sDezhy1Xu5KP48dj0bXrX3KKVKUY/4UjPv2iKRWpCKkl2rVzRN26XIn2kyfjasV6l5RbEaJ/NJmHlZSUISDgDFauvCOzjzvPCr/s7ElFKkL0jIkJBwMHSt7ke/kyC0+fpmsgIsUpXajKz8/HJ598gvXr1+Off/4RtX///feIjo4GwzBgGAapqamYNm0a3ryRnHJGCKmdGIbBzz/fwciRJ1FYWCq1j7W1IYBt8GtPi3gSUptwOGwMHuwu0Z6amoeICNm7U+kDyq0IIaqUlyeAv/8J/Pmn7N1B23erj5Wbu8HW3lSNkRFC1GXECJ7U9uPHX6g5kqpRulB18OBBvHjxAtbW1ujatSuA8jt+165dA4vFwvr163H79m0MGzYMhYWF+OOPP1QWNCFEdwkEZZgy5RwWLrwus0+TJrbYt681gET1BUYI0RpDh3pIbQ8JeanmSNSLcitCiKq8e1eAnj2P4OzZBJl9Rk7wwrzl7WFiSo8SE6KvBg1yh5ERR6JdbwtVly5dApvNxu7duzF69GgAwNWrV8EwDJo2bYqBAwfCysoKS5cuhampKcLDw1UWNCGkak7FnsLRp0dxKvaURuPIyChEnz5HsWfPE5l9+vZ1w82b4+HkRHf2CKmtevd2hamUD07ydgXVB5RbEaKf1J2HJSRko1Onw7h3T/qsSw4HCFzkh8+m+9DSCoToOQsLI/Tt6yrRHhn5DnFxWeoPSEFKF6ri4+Ph4uICb29vUduNGzfAYrHQuXNnURuXy4WLiwtev35dvUgJIUqbfmo6xhwbg+mnpmsshpiY92jf/iD++SdZZp+vvmqJsLARsLQ0VmNkhBBtw+Uaok8f6UlVQkK2BiJSD8qtCNFP6szDIiPfokOHQ3jxIlNGjyJMnemMXgPdajwWQoh2GDHCU2r7sWMxao5EcUoXqoqLi2Fubi76f4ZhcOdO+SJ9bdu2FesrFApRViZ9G1RCiP67coWP9u0P4uXLLKnH2WwWNm7sic2be8PAQPt2JiSEqJ+/v/TH/0JD9XdWFeVWhJDquHqVj65d/8KbN9I3qbGxKV//k9fETL2BEUI0asiQRuBwJGdP/v239haqlH4g2dHREampqWAYBiwWC5GRkcjOzoaJiQlat24t6pednQ0+nw8HBweVBEwIqbql3ZYiT5AHcyPzyjur2P79TzF16jmUlAilHrewMMJffw3GwIGSiycTQmqvwYPdwWIBH2/0FxLyEoGBvpoJqoZRbkWIflJHHnbsWAw+/fQ0BALpBexGjaywbl1jDBuWUmMxEEK0k50dF716ueL8+QSx9ocP3+LFi0x4elprJjA5lJ664O3tjczMTOzduxd5eXnYunUrWCwWOnbsCCMjIwBASUkJfvzxRwgEAvj5+aksaEJI1Uzzm4bZHWZjmt80tV2TYRj8+ONNfP75GZlFKhcXC9y4MY6KVIQQCQ4OZmjfvr5E+9WrScjIKNRARDWPcitC9FNN52FbtjzEmDGhMotUvr4OuHFjHBo04NbI9Qkh2m/MGC+p7UeOaOesKqVnVAUEBODChQtYs2YN1qxZI2qfNGkSACAqKgrTpk1DdnY2DA0NERAQUO1gCSHqwefzkZ6ervT5JSVC/PJLPIKCZO/a166dI4KDh6FePZp+TgiRbtgwD9y6lSrWVlbGICTkJSZPbqahqGoO5VaEkKpgGAZLl97AihW3Zfbp3dsVx48PhYWFEVJoMhUhtdbw4R6YPv0CSkvFJxAcORKDxYvbaygq2ZQuVLVo0QLr16/HsmXLkJ6eDktLS8yZMwdt2rQBAJiZmSErKwvW1tb47bff0LhxY5UFTQipOXw+H97e3igoKFByBFMAEwFIX18GAD75xAt79vSHqamhktcghNQGI0Z4Yv78fyTag4Ji9bJQRbkVIURRpaVCfPnlBeza9Vhmn3HjGmPv3gFSt6YnhNQuNjam6NPHFWfOxIu1R0W9w/PnGWjc2FZDkUmndKEKAPr27Ys+ffrg/fv3sLa2Bpv935OELi4u2Lx5M7p27QpDQ/owSoiuSE9PR0FBAWYtXQ9nV9nFJmnep5dg16/JSHstkNln0aJ2WL68M22HTAiplIeHNVq0sEdk5Dux9gsXEpGVVQQrKxMNRVZzKLcihFSmsLAEY8eewsmTsjeXmDnTD+vWdad8i5BaLDo6Wuz/27Y1wZkzkv1+/fUqpk1rKNFuZ2cHFxeXmgpPrmoVqgCAxWLB1lay+mZoaIhevXpVd3hCiAq4/+aOlNwUOFk44dX/Xil0jrOrBxp5+Sh8jRfR7/H7zzeRnSm9SMXhsLBtWx9Mndpc4TEJIWTUKJ5EoaqkRIhTp15hwoQmGoqqZlFuRYh+USYPk+X9+0L4+wfjxg3Zz/GtXt0Vc+e2AYtFRSpCaqPMjHdgsdmYMGHCR0dMAHyPj8tA27ffwvbtoyTG4XK5iI6O1kixqtqFKkKI9hOUCUR/asKd66lY98NdCIqlL+JpYWGEY8f80bevW41cnxCiv0aO5OG7725ItAcFxeptoYoQol9UlYclJeWgf/8gPHuWIfU4h8PCH3/0x8SJTat1HUKIbsvPywEjFEp9Qmb3xmQ8i8z/6Ix6mLvsKOo5GYtakhNfYsOy2UhPT9e9QlV0dDQ2b96MiIgI5OTkoKxM+odUoPzu4LNnz6pzOUKIknzq+qCuWV3UNaur8rFDj7zAH5uiJLaQr+DsbIGwsBFo3txe5dcmhOg/b29bNGliK/HB7OzZBOTlCWBubqShyGoG5VaE6B9V5GHR0Rno1+8YkpJypR7ncg1w7Jg/BgygnZQJIeWkPSHT178OnkXek+ib+MoEnXpqT5Fb6UJVbGwsxo8fj6KiIjCyPqESQrTC2QlnVT5mWRmDPZsiceqY7PURvLzMcfnyp6hf31zl1yeE1B4jR3pKFKqKikpx+vQrjBmjPwuKU25FiH6qbh52//4b9O8fhIyMQqnHbW1NERY2Au3aOVbrOoQQ/de2syMMjdgoEYjv/nfjcjLGTWmiNY8MK12o2rZtGwoLC1GvXj0EBATA3d0dJib6t6gpIURScXEZ1v9wF3eup8rpFY05c7rjzZtYvHlT9Wt8vPgfIaT2GjmSh+XLJbdfP3YsVq8KVZRbEUI+duUKH/7+J5CXVyL1uIuLBc6fHw0vLxs1R0YI0UVcM0O0aueAu9dfi7Wn8POQ8DIbDT2tNBPYR5QuVN25cwccDgd79+6Fm5ubCkMihGiz3BwBVs6/iejH0tdHAADf9saIuLMfX3zxhxojI4Toq+bN7eHhYYWXL7PE2k+fjkdBQQm4XP3YAY9yK0LIh4KDX2Ds2FMolrEGaLNmdjh7dhTNXCeEVEnnng0kClUA8M+FJN0vVOXk5IDH41EiRUgt8i6tAMu+DUdSgvT1EQAg4KtmsLJ9hojbpVIX8FPUg9tXcWjnemVDJYToERaLhZEjeVi9+q5Ye35+Cc6dS8Dw4Z4aiky1KLcihFTYt+8JJk8+B6FQ+mPAXbo44+TJYbCyolmXhJCqadPJEUbGHImNsP65mITPpvuAzdb8439KF6rq1q2L3FzZH1YJIdpj7vm5yCzKhLWJNX7p+4tSY/Bf5eDHb8OR8U76+ghGRmzM/K4NOvZwxrXz5Y/tSVvAT1HJibLXviKE1D6jRkkWqoDy3f/0pVBFuRUh+qmqedivvz7ArFlXZB4fPNgdR44MgampfswmJYSolynXAO06O+L6pWSx9oy3hXj6KB3NfDW/CRZb2RN79OiB1NRU2m2GEB1w+Mlh7H64G4efHFbq/KeR6Vj41VWZRSqLOkZYtrErOvZwrk6YhBAik5+fA1xd60i0h4S8RGGh9LVbdA3lVoToJ0XzMIZh8N134XKLVJ9+6o3jx4dSkYoQUi1d+7pIbf/nAl/NkUindKHq66+/hr29PebMmYPnz5+rMiZCiBa5fS0FP8y6jnwZi3ja1+Ni1dZuaOxjq+bICCG1Sfnjf5Izp/LyShAW9koDEake5VaE1F5CIYMZMy5hxQrJjSMqzJjRCvv3D4ShIUeNkRFC9FGrdg6wsDSSaL9xJUXikUBNUPrRvz179qB169YICwvD8OHDUbduXTg4OMDQUHp1n8Vi4cCBA0oHSghR3qWJl1AqLIUBu2r/5M8Gv8KO9Q8hFEo/7tqoDr5f1xk2dqYqiJIQQuT75JPGWL/+gUT74cPPMWqUlwYiUi3KrQjRTxV52Nu0t4iIiJA4XlIixPffR+PcuTSZY3zxhRvGjTPFo0cPlY6DdlQmhFQwMGCjc09nnDkhfrOvIK8ED26/Qd16GgrsX0oXqnbs2AEWq3yRLYZhkJaWhrQ02W+uFX0JIernZVf1D3DnQtJx/qTsnf2atrTDwlUdYG4hWYknhJCa0KZNPTRqZIW4uCyx9rCwV8jOLoalpbFmAlMRyq0I0U9edl7g8/lo274tCgoKPjpqCOAzAN5yRgjBzp3h2L2bDaGsu4eEEFJF3fq5SBSqAODaeT5GT7TQQET/UbpQNWPGDFXGQQjREgzDABgst0jVsbsTZn7XBkbGNPWcEKI+LBYLY8c2xk8/iT8aU1xchuDgF/j8c+U2b9AWlFsRor/S09NRUFAgtiNyYUEZdm9MQfwL6WuAstnAJ5PqoXXHeXhwuy0O7VxPOyoTQlTGq6kNHOqbIS01X6z9/s03GDSSq6GoylGhihAiIhQyWLUqFkA3mX0GjmyEKd+0AIdDd/IJIeo3bpxkoQoof/yPClWEEG1XsSNy1vsi/DA7HAkvpRepDI3YmLusHdp2rg/gv92QaUdlQoiqsFgsdO3TAEf3ia+LWVoiRNQDze5CrPRi6oQQ3XEr6RauJlzFraRbMvuUlgoxefJZBAWlyOwz4f+a4ouZVKQihGhO06Z2aNbMTqL94sVEvHv38SM1hBCiebeSbuF++n3g382R017nY+FXV5HwMltqf1OuAZau7SwqUhFCSE3p1reB1PaI2zlqjkSc0jOqPnT9+nVcuXIFr169Qm5uLoKCgpCTk4P9+/dj/PjxsLGxUcVlCCFKGn10NFJyU+Bk4YTk2ckSxwWCMkyYEIajR2Olns9mA1/N80PvwW41HCkhpLaqyiK/XbvWwePH6WJtZWUMjh6NwVdftVJ1aBpBuRUh+qMiD8MY4E1qMXbPv4r36UVS+9axMsLStZ3h0dhazVESQmojZ9c6aORlhbiYLLH2uJhCAJYaiQmoZqEqIyMDM2fOxP379wGUr21TsbBnamoqfv/9d/z555/YsWMHWrRoUf1oCSEqV1RUitGjT+LUKenbu3M4LMz+vi069XRWc2SEkNogM+MdWGw2JkyYUIWzrAEskmjduzdS5wtVlFsRos842PwzHwX50hdEt6trih82dIazax01x0UIqc269XORKFSV81N3KCJKF6oEAgGmTJmC58+fw9zcHB07dkRkZCTevn0LAGCz2bCyskJWVhYmTZqE0NBQODk5qSxwQojivm7zNXKKc1DHWDzxyc8XYNiwEFy8mCj1PANDNuYtb0dTzwkhNSY/LweMUFjlBYI3/pSIxFfiMxLu3UsHn58DFxfd/JBHuRUh2ovP5yM9Pb3yjlIMcxqGB0/icftuicwilZOLOX5Y3wX29TS7gDEhpPbp0qsB9v4eBclNRVv/u9GW+ildqDp48CCeP3+Oli1bYsuWLbCxscH48eNFyRSPx8PFixfxxRdf4NGjR9izZw+WLFmissAJIYpb2GWhRFtOTjEGDTqO8HDpa1IZGbGweHVHtGjjUNPhEUJIlRcI7jPEBLt+i5Ro//vv55g7t60qQ1Mbyq0I0U58Ph/e3t4oKFB2HTwfAJ9C1kcvd54Vvl/XGZbWxsqGSAghSrO2NUGrdvXw4Nabj47Y49GjbPhpYGKV0oWqsLAwsNls/PLLLzLXSTA3N8fatWvRr18/XL9+XekgCSGq9f59Ifr1O4b799Nk9CjCF7M9qUhFCNFanXo6449NkRJ3/w4d0t1CFeVWhGin9PR0FBQUVHnmJwDcuZ6No/veQNakhKYt7bB4dUdwzQxVECkhhCin10BXKYUq4OTJ15gyRf3xKF2oevXqFRo1aoQGDaSvEl/ByckJbm5u4PP5yl6KEKJCb9/mo0+fY4iKeif1eJ06BsjJ2Q53zy1qjowQQhRnbWsCn1b2iHog/l726NFbREW9Q/Pm9hqKTHmUWxGi3ao68zP4UCyO7JX84FehbWdHfPtjOxgbc1QRHiGEKK1NJ0dYWBohN1sg1n7hwlvk5Qlgbm6k1njYyp4olHyAUSZDQ0NwOPQGTIimpaTkomvXv2UWqerW5WLHDl8AkjsDEkKItunax0Vq+759T9QciWpQbkWIfmAYBn9uf4K9Wx7L7NOjvwvmr2hPRSpCiFYwNOKgWx/JG2WFhWU4ejRG7fEoXahycnJCQkIC8vLy5PbLzMzEixcvaLFPQjSo9Y7WcPzFCe4/N0NMzHupferXN8e1a5/A09NczdERQohyOvV0grGJ5Ie8AweiUVJSpoGIqodyK0J0X1kZg21rHyLozw8+2E37DZi9ovy/AAaP9kDgotbgGCj9UYwQQlSu1yA3qe1//KH+G4BKvzt269YNJSUl+OWXX+T2W7FiBcrKytClSxdlL0UIqabkrFS8KUiFwChL6nE3tzq4fn0sGje2VW9ghBBSDaZcQ3ToJlmsefu2AGfPJqg/oGqi3IoQ3VZSIsT6H+/iXEi8+AHzXKBONmCei/7DbDHlm+Zgs1maCZIQQmRo6GkFd56VRHt4eApiY6VPdqgpSq9RNWXKFAQFBeHIkSPIyMjAkCFDkJubCwCIi4tDbGwsDh48iAcPHsDMzAwBAQHVCrSwsBC7du1CWFgYkpOTYWZmBh8fH0ycOBHdunVTasyoqCjs27cPDx48QHp6OoyNjeHh4YFBgwZh7NixMDJS73OYhNSEJ0/eISPREDCxBPIsJI7zeNa4eHE0GjTQze3cCSG1W8+Brrh6TnKtpr17n2DIkEYaiEh56s6tCCGqU1RYitWLb+PhXSkb1VTkX3ml6DPEDiwWFakIIdqp1yBXvIrNkmjfu/cpVq5U3w0ypQtVtra22LJlC7766itcvHgRly5dEh0bPHgwgPLns7lcLtavXw8HB+V3DysoKEBAQAAiIyNhaGgIT09PZGVlITw8HOHh4QgMDMSMGTOqNOa+ffvw888/QygUwsTEBO7u7sjMzMSjR4/w6NEjnDp1Cn/88QfMzekxKKK7Hjx4g759j6H0faDU4z4+drh4cTQcHMzUHBkhhKiGTyt7WNsYIPN9qVh7aGgc0tMLYGfH1VBkVafO3IoQojp5OQIsn3cDMU+kzzjg7J6Jvv4snDnxLdBOzcERQkgVdO3jgj2/P0Zpifi6mfv2PcXy5Z3A4ajnkeVqXcXPzw8nT57ExIkT4ejoCIZhRH9sbW0xatQoBAcHo2vXrtUKctmyZYiMjIS3tzcuXLiAEydO4MqVK1i9ejUMDAywadMm3Lx5U+HxHjx4gFWrVkEoFGLq1Km4d+8eTp48ievXr2Pfvn2oW7cuIiMjsXTp0mrFTYgm3biRgp49j+D9+yKpx/38HHD16idUpCKE6DQ2m4XWnSwl2ktKhDh8+LkGIqoedeVWhBDVeJ9eiMWB12QWqYyM2Fi4qgMaN6P1qAgh2s+ijhHadakv0Z6amoezZ+OlnFEzqv2O6eDggEWLFuHy5cuIiIjAtWvXcO/ePYSHh2PFihVwcZG+I4+i+Hw+Tp48CTabjbVr18LR0VF0bNiwYZg6dSoAYNOmTQqPuXv3bjAMgx49emDu3Llij/i1b98eq1evBgCEhYXh9evX1YqfEE24fJmPvn2PIidHIPV4x471cenSGNjamqo5MkIIUb3WHaQ/urx371M1R6IaNZ1bEUJU401KHhZ+dQ2JcTlSj3PNDPD9hi5o3dFR6nFCCNFGvQa6Sm3fti1SbTGotLTP5XLh4OAACwvJdXCUFRISgrKyMrRs2RIeHh4Sx8ePHw8AiIiIQGpqqkJj3rlzB8B/0+g/1qFDB5iZlc8yefJEN7e4JrVXWFgcBg4MQkFBqdTjPXu64Pz5UbC0NFZzZIQQUjPsHIwAvJJoj4hIQ1TUO/UHpEI1kVtVKCwsxKZNm9C/f3/4+PigXbt2mDJlCq5du6b0mFFRUfj222/RvXt3+Pj4wM/PD5988gn2798PgUD6zRNCdFFCXDYWfnUNaan5Uo9bWhtjxaZuaNrCTs2REUJI9bRo4wBLa8lVosLCXiExMVstMSi0RlVSUpJKLtagQYMqn/Po0SMA5VPhpXFwcICTkxNSUlJw9+5dDBs2TO54QqEQGzZswJs3b9C6dWupfRiGEX1dVqZ721uT2isoKBbjxp1CyUfPFKPzZcC4CK71bLD8q26IiZFdgI2Ojq7hKAkhpCbcB+Au0bpv3xOsW9dD/eFUQpO5FUDrfxJSHc+fZGD5nBvIzyuRety+Hhc/buiM+g3KC8zH4rcghvUQ6KzOKAkhRDkcDgsdulnibHCGWDvDADt3PsaKFTX/ZqZQoapv377VvhCLxcKzZ8+qfF5iYiIAyJ3mXlGoSkhIqHQ8Nptd6boO169fR35++d0RT09PxYMlRIMOHHiGzz8/A6GQkTzY9iZQJxuJOUCnTkHqD44QQmpcFIyNx6K4WLxQ/+efz7BqVVcYGXE0FJd0msytAPH1P7du3SpaWiE4OBiLFy/Gpk2b4Ovri44dOyo0XsX6nwzDYOrUqfjf//4nWlrh9u3bmDt3rmj9z/Xr1ysVMyHa4OHdNPy86BaKi6TfzHZ2s8AP6zvDru5/GzmcST6ADNYboK26oiSEkOpp29kKZ4PfAhDPn3btisLSpR1qPK9SqFD14QwjeVgsFkxMTFBSUoLS0v8eO+JwlP8mMjLKq3g2NjYy+1hZWQEAMjMzlb5Ohfz8fKxatQoA4OPjg0aNdGtra1I7bdv2CF99dRGy/qkaGrFQAsDS2hZLd++RO9aD21dxaCd9iCCE6Jpi9Oplj9OnxbeGf/euEMHBLzBmTGMNxSWdJnOrytb/jI+Px7Zt27Bp0yaFC1Ufr//5oYr1PydNmoSwsDDMnTtX7JqE6IrIe7k4tCsWpaXS//16elvju186oY4VLa9ACNFt5Y/+PQXQXKw9La1ALXmVQoWqD7dHriAUCrF48WLcvXsXI0aMwLhx49C4cWMYGhoCAF69eoUjR47gzz//RPfu3bFx40alAiwqKt+x7MMFzz9mbGws1ldZAoEAM2fORHx8PDgcDhYtWlSt8QhRh19+uYt58/6Rebyvf0P06LQTpUwJDNlGaGTlI3e85MQ4VYdICCFq4e9fX6JQBQDbt0dpXaFKk7lVxfqfvr6+Mtf/3LZtm2j9z/r1JXf/+Zii63/m5+fjyZMnVKgiOqgt/tyeKvOmYDM/eyxa1QGmXEOJY3Ob/Y77d6/g2JHNwI81HCYhhKjMLXxcqAKArVsjtaNQ5eTkJNF28OBB3Lt3D99++y2++OILiePu7u5YsGABXFxcsHz5cuzYsQNffvlllQPkcDgQCoVgsVgy+1TclWSzlV8bvqioCN988w3++af8A//cuXNlrotFiDZgGAZLl97AihW3ZfYZMsYDkwOby/33Qwgh+qJ1ayvweNaIjRWfYX35Mh+xse/B48mena1umsytaP1PQqpm795EAKNlFqnad62P2d+3hZGx9JmOja18kYYkILnmYiSEENV7CVdXLhITC8Rar15NwvPnGWjc2LbGrqx0Zeevv/6CtbU1pk6dKrff+PHjYWdnh+DgYKWuw+WWP99dXFwss0/FLjIVM6uqKiMjA59//rlol5uvv/4akyZNUmosQtRBKGQwc+YVuUWq3oNsqEhFCKlVWCwWpk2TvPMHADt2RKk5mqpTV26l6PqfAKq0/ueYMWNQr149qX1o/U+iixiGwbx517Bpk+zZ5r0GumLusnYyi1SEEKLLRo6UPqt627bIGr2u0oUqPp8PJycnhT4E16tXD2/evFHqOtbW1gCArKwsmX0q1qayta16RS8uLg6jR4/Go0ePwGKxsHDhQnzzzTdKxUqIOpSVCfHFF+ewcWOEnF5hGDDCnopUhJBa5/PPm0pd4HPv3qcoKiqVcob2UFduRet/ElK50lIhpk49h19+uSezj/8nnpix0A8cA+Wf6iCEEG02eLAjTEwkH8Tbt+8pCgqk73yqCkq/q1pbW4PP54st7ClNfn4+Xr58CTs7O6Wu4+5evtV0crLsubIpKSkAADc3tyqNfefOHYwdOxYpKSkwNjbGr7/+ioCAAKXiJEQdBIIyjBt3Cn/88URmn/nzeQCuirWl5L8CPy8WKfmvajZAQgjRMDs7LkaN4km0Z2QU4vjxFxqISHHqyq1o/U9C5CsoKMGIESFy861PpzXFpBnNFCosp+S/QjpeAzX3lAwhhNQIS0tDfPKJl0R7VlYxDh6MrrHrKl2o8vPzQ05OjtwthhmGwbJly1BUVITOnTsrdZ0WLVoA+G89hY+lpaUhNTUVANCqVSuFx7179y6mTZuGnJwcWFlZYd++fejfv79SMRKiDvn5AgwbFoyjR2OlHudwWNi/fwDGjHGWOLY0YgK+ud0fSyMm1HSYhBCicdOnt5DavnXrI/UGUkXqyq0qdgxUx/qfM2bMoPU/iU7JzCxC377HEBoq/XE/Fgv4v29bYvTExgrPXF8aMQF/stcAn6syUkIIUY8vv2wptf233x4ovItxVSmdfUydOhUcDgd79uxBQEAAgoOD8ezZMyQkJODJkyc4evQoRo8ejZMnT8Lc3LzS9RZkqSge3b17F69eSc4GOXToEACgbdu2cHaW/IAuTVJSEr766isUFRWhXr16OHz4cJWKXISoW3p6AXr1OoozZ+KlHjcy4uDoUX989llTNUdGCCHap3NnJ3h7Sz7WFh6egkeP3mogIsWoK7ei9T8JkS4lJRddu/6FGzdSpB5nc4DZ37fFgOH0+CohpPZo27Ye/PwcJNqfPs3AhQuJNXJNhXb9k8bb2xsrV67Ed999h9u3b4u2Jf4QwzCwtLTEr7/+igYNGih1HTc3NwwePBinTp1CYGAgtmzZAldXVwDl2yvv2rULAKTuesPn81FSUgILCwvUrVtX1L5kyRLk5ubCxMQE27dvFz1eSIg2SkjIRr9+xyR2sapgamqA4OBh6NvXTeYYXeoNQV5JNswNLWsoSkII0R4sFgv/938tMHPmFYljGzdG4I8/tHMGtbpyK2tra2RnZ9fo+p9ffPEFUlJSwGKxsGDBAlpagWi9mJj36Nv3KPj8XBk9BJgS6I4uvav+765LvSF4mRCFJ4/vAHRPkRCiY1gsFmbO9MNnn52WOLZhw325n0OVpXShCgD8/f3RqlUr7Nq1C//88w9ev34tOla/fn3069cPU6ZMUXoNhQpLlixBbGwsYmNjMWDAAPB4POTk5IjWppo1axY6duwocV5AQABSUlIwfPhw/PzzzwCAx48f4/bt8p3STExM8OOPP8q99vTp09GtW7dqxU+IsiIj36J//yC8eZMv9XidOkYICxuBzp3lzyYM8FxYE+ERQojWCgjwweLF4cjPF1/o89ChaKxe3RX29lwNRSafOnIrd3d3JCQk1Nj6nzNmzEBOTg6MjY2xZs0aWlqBaL17915j4MDjSE8vlHrc0tIQ2dkb0bjZZqXGD/BciGvxIXhy4Q4wtjqREkKIZowZ44V5867h9Wvxz6VnzyYgOjoD3t6qXYSvWoUqAGjQoIGo2FNcXIzs7GxYWVnJXaCzqqytrfH3339j9+7dOHPmDOLi4mBgYIC2bdtiwoQJ6Nevn8Jj3bv3384dWVlZiIiQt3PafzvjEKJuV67wMWxYMHJyBFKP29ub4syZkfDzk74VOCGE1GaWlsYICGiKzZsfibUXF5dhx44oLF7cXjOBKaCmc6sWLVrg8uXLNbb+Z1FREaysrLBt2zZaWoFovbNn4zFq1EmJonYFFxcLrF/fBKNGJak5MkII0R5GRhx8/XUrLFkSLnHst98isG1bH5Ver9qFqg8ZGxuLPWKnSlwuF4GBgQgMDFT4nMuXL0u0TZ48GZMnT1ZlaISo3JEjz/HZZ2cgEJRJPe7ubolz50bBw8NazZERQojuCAz0lShUAcCWLY8wb14bGBpy1B9UFdVEbtW/f39s2LBBtP7nx0sgqGL9zz179tDSCkTrbd36CIGBl1BWJn0x4KZNbXH27Ci8favdO4YSQog6/N//NceKFbdRVCS+O/H+/U/x00+dYWtrqrJrqbRQRQipHoZhsGDBeaxZ81hmHy8vc2zc6IOcnHhEREgurh4dXXPbhBJCiDaT9v7XqZMtbtwQnx2dmpqHtWvPo1+//xYGFQgEKp0Nrs1o/U9S25WVCTFv3jWsX/9AZp9OnZwQGjoc1tYmeKu9ezAQQoja2NlxMXFiE+zYESXWXlhYis2bH2LpUsnlmJRFhSpCtIRAUIZPPz2BY8cS5PSKRUzMfvTrJ3unJml+fBiAbEEGLI1s8X2rvdUJkxBCtE5mxjuw2GxMmDBBylEegC8kWhctOo1Fi34X/b+bm1utKq7Q+p+ktsrPF2DChNMIDn4ps8/gwe74++8h4HINVXLNHx8GIIUVB0h7iyKEEB3yv//5ShSqAGDjxof49tvWMDNTzU0/KlQRogUyMgoxYkQI/vlH9sK2rdpZYOzkwTAwGCJ3rAe3r+LQzvVibfy8WGQUv4GtMa1nRQjRP/l5OWCEQsxauh7Orh5ixxiGwZrvEvD29cfr/bniq3l/oZFX+aLq+3+XX1zRN7T+J6mN3rzJx5Ahx3H/fprMPpMn+2D79r4wMGCr7Lr8vFhksN4ANbNCCiGEqE2TJnYYMKAhzpwRf7InI6MQu3c/wTff+KrkOlSoIkTDYmLeY/Dg43j5MktmnyFjPDBpRnOw2axKx0tOjJNoM2AbwoBlBAO2au4MEkKINnJ29UAjLx+J9uHjudi+7pFE+53rJejrX97fwKD2vT/S+p+kNnn8+B0GDz4OPj9XZp+ffuqMhQvbgcWqPN+qCgO2ITgMB2Vl0tceJYQQXbJgQVuJQhUArF17D9Ont4CRUfXXAKVCFSEqxOfzkZ6ernD/e/cyMXfuY+Tmlko9zmYDk79pgcGjPKQeV9T2TteqdT4hhOiyngNccXj3M+Rkic+qenDrDRJeZsPNw1JDkRFC1OHYsRh8/vkZFBRIz7eMjTnYu3cAxo5tXCPX397pGq6dD8GG32YBu2vkEoQQojZdujijY8f6uHkzVaw9KSkXhw9H4/PPJW8aVhUVqghRET6fD29vbxQUFCh4RmcAgwFIrzibcg3w7Y9t0bqDo6pCJISQWsnYxACDRnrg8O5nEsdOHIrBrKVtNRAVIaSmCYUMli69gZ9+ui2zj62tKUJChqFTJyc1RkYIIbqLxWJhwYJ28Pc/IXFs9eq7+Oyzpgo9CSQPFaoIUZH09HQUFBRIXSPlQ4JiIY7tT8OD2zky+1jbGOD7Dd3h1oju8hNCiCoMGOGO4wdjUFwk/ujN9UvJGP9FUw1FRQipKdnZxZgwIQynTr2S2YfHs0ZY2Ah4eFirMTJCCNF9gwa5w8fHDk+eiD9NFB39HidOvMDIkbxqja+6VQIJIQD+WyNF2h/zOg2x89d3cotUQCK+WeJKRSpCCFGhOpbG6OvfUKJdWMYg5K8XGoiIEFJTnj/PQPv2B+UWqbp2dcatW+OpSEUIIUpgs1mYP1/6jPQffrgJoZCp1vg0o4oQNYm8l4a1P9xFbvbHO0/9h9eEhdhn21DHsq9Kr30u+TCKyvJhwjFDP+dxKh2bEEJ0hf8nnjgdFIeyMvHk6WJoPJo201BQhBCVOnw4Gl98cR75+SUy+0yf3gK//dZTJQv+KuJc8mE8xV3ATy2XI4QQlYmOjpZ5jMcTon59E6SmFom1P3mSjjVrzkIgEMDIyEip61KhipAaxjAMgg/H4s9tTyAUSu/DYgFjpzSBg2MMYp9JX+izOo7Eb0JG8RvYGtejQhUhpNayd+Cia58GuHKWL9YuEAhRVFAG0ERWQnRWUVEpZs++gq1bI2X2MTRkY9OmXvi//2uhxsj+zcPYb4Buar0sIYQoLTPjHVhsNiZMmFBJzzYAxki0Llx4CW5uKXB3l5zNrggqVBFSg3JzBNj4033cu/FaZh+uuSFmL22D1h0dce18rBqjI4SQ2mfEp164eo4P5qMZ6UVFMu4kEEK03qtXWRg9OhQREWky+9Sty0VQkD86d3ZWY2SEEKKb8vNywAiFla6/XFbKYPWSeGS8+3gWaz1wzWyUvj4VqgipITFPMrD2+7t4lyZ7F8AGbhZYuKoD6jewqNFYpjdeDoGwGEZs4xq9DiGEaLsGDeugc09nXL+ULNb+ceGKEKIbgoNfICDgLLKzi2X28fNzwIkTQ9GgQR01Rvaf6Y2X49HDcISd2gfQ3g2EEB1Ssf6yPOO/sMCmlQ8k2ouLld/5jwpVhKjYh4/6fbwOyoc6dndC4KLWMOXW/D/DNva9avwahBCiKz6Z7I0bV5JlPo5NCNEefD4f6enpEu3FxWXYuDEOf/2VLOWs/4wcWR8rV3bQWJEKKM/DCpCHsNh9GouBEEJqSve+Lji2/zleJ+eLtZeVKn8XkApVhKiUKf7YlIJnkfkye7BYwIRpPhgxgQcWS/kqMyGEEOU4u9ZBl94NcO18kqZDIYTIwefz4e3tjYKCj2en1wMwHoCjnLMFAIIQFBSBM2e4iI6OhouLS43FSgghtRXHgI1PJjXBr8vvqWxMKlQRoiKPH2cDmCW3SGVlY4xZS9uiReu66guMEEKIhDEB3rh+MYlmVRGixdLT01FQUCBaI4VhGIRfysKpo+9QKudOvUN9I0z80g316v+A5MSX2LBsNtLT06lQRQghNaRL7wY4tv85khNzVTIeWyWjEFKLlZYKsXz5LUyZEgHAWma/Zn722LCnt0aKVDmCTGQLMpAjyFT7tQkhRBs5uVigW1/60EqILnB29YCtvQcO7cxG8OG3cotU3fu54Ld9A9Cphx8aefnIXQRYXXIEmShAHmCq6UgIIaRmcDgsTPg/1S3CRzOqCKmGhIRsTJhwGjdupMjsw2IBn0zyxujPvcHhaOZRv1l3BiGj+A1sjethd5ebGomBEEK0zZhJ3vjnQpLc9QQJIZr35GEujh+4iOws2QumGxlz8MXMFug92E3rllaYdWcQMthvgC81HQkhhNScdl3qw7uZLaIfZ1R7LJpRRYiSDh58hhYt9sktUlnZGOOHDV0wdnITjRWpCCGESOfoZI4Bw901HQYhRIacnBIAY7Hn91S5RaqGnpZYt7sn+gxpqHVFKkIIqS1YLBYCvm6mkrGoUEVIFWVlFeHTT8MwYcJp5OQIZPZr5qu5R/0+1sKmE9rY9UILm06aDoUQQrTKmABvcM0NNR0GIeQjp0+/wpgxdwD4ye03bJwn1mzvgQZumtvVrzItbDrBnWkKxGk6EkIIqVlePrbo2MOp2uPQo3+EVMH168n47LPTSEzMkdmHzQY+mdQEoyY21ppZVN80/UXTIRBCiFaqY2WMUZ954Z8zmo6EEAIA2dnFmD37Cv7444ncfta2Jpi5pDVatHFQaNzo6GilY6rOuUB5HnYtJQQbQmYB/tUaihBCtN5n031w93pqtcagQhUhCigoKMGSJeH49dcHYOQuZZKBGQtaoedAb3WFRgghpJoGj/LAjfOajoIQcvFiIiZPPoukJPm7RrXt4ogZ8/1Qx8q40jEzM96BxWZjwoQJqgqTEEKIHI5O5hg40gNRd5QfgwpVhFTi1q1UBAScQWys/B3zhgyph9DQJXBtdFRNkRFCCFEFI2MOuGYcTYdBSK2VmVmEefOuYdeux3L7cc0NMfV/LdCjv4vCa1Hl5+WAEQoxa+l6pXcAfHD7Kg7tXK/UuYQQUhuNneyNJ/eUP58KVYTIUFhYgqVLb2D9+gcQCmVPo7K2NsH27X3QqFE+QkNlL/RJCCFEexkZ07KdhKgbwzA4diwWgYGXkJZWILdvy7Z1MWOBH+zqcpW6lrOrBxp5+Sh1bnIiLS5FCCFVwTUzhJm58jcBqVBFiBR37rxGQMAZPH/+Xm6/Hj0aYP/+gXB2tkBERISaoqu69U9mIkeQiTpG1pjt86umwyGEEEJILZeUlIOvv76E0NDKikBFGD3RFeO/6KSzO/qtfzITiawYYISmIyGEEPWpzk1AKlQR8oGCghIsW3YLv/xyT+4sKmNjDlas6IzZs1uDzdb+pOlp5l1kFL+BrXE9TYdCCCGEkFqsrEyIrVsfYeHC68jLK5Hbt3VrK9y/Pw/tu+3T2SIV8G8exnoDuGk6EkII0Q1UqCLkX+fPJ+DLLy/g1atsuf3atq2HffsGoHFjWzVFRgghhBCi+6Ki3mH69Au4dUv+blBmZob4+ecuaN+eQZs28tcIJYQQon+oUEVqvbdv8zFr1lUcOiR/62EjIw6WLeuIb79tAwMD3VrL5PcO58GAAQu6ezeSEEIIIbopK6sI339/E5s3P0RZmdztkzFgQENs3dobrq6WWr2sQlX83uE8rl8Ow5bfFwJbNR0NIYRoPypUkVpLKGSwZ88TzJ17DZmZRXL7+vk5YN++AWja1E5N0amWqYG5pkMghBBCSC0jFDL488+nmDfvH7x9K3+xdHt7U/z2W0+MHdtYpx/zk8bUwBzGMAEEmo6EEEJ0AxWqSK308GEavvnmMsLDU+T2MzRk44cfOmLevLY6N4uKEEIIIURTIiPf4uuvL+HGDfm5FgAEBDTF2rXdYWtrqobICCGEaDsqVJFa5d27AixZEo6dO6PAyJ95jubN62Dx4sbw8DBCVNSjSseOjpb/6CAhhBBCiL5LS8vH99/fxM6dUXI3pgEAJycTLF7cGO3a2SAxMRqJieLHKbcihJDaiQpVpFYoKSnD5s2P8MMPN5GdXVxJ70IApxEVdQeffFJJNUtH3Hp7FsVlRTDmmKBD3f6aDocQQggheqagoATr19/H6tV3K93NDygFcA0pKZfw1VeV9dV9t96eRTTuA96ajoQQQnQDFaqIXhMKGQQFxWLJknDExla+a4xnExbGT/FBHauWVb7Wg9tXcWjneiWirHm7YpYho/gNbI3rUaGKEEIIISpTVibEgQPPsHhxOFJS8irt39jHDMPG14W9Q1MAX8ntq825VVXsilmGDPYbYICmIyGEEN1AhSqilxiGwYULiVi06DoePEirtH+9esZ482YLpn+7Bo28fJS6ZnJinFLnEUIIIYToGqGQwbFjMfjhh5uIjn5faX/7elxM+aY52nWpr/Bi6ZRbEUJI7USFKqJ3bt1KxeLF13HlSlKlfU1MDDBvXhv07WuEzp2/UUN0mjG+0WwUlxXAmMPVdCiEEEII0RF8Ph/p6elibQzD4MqVdGzf/govX+YrMEop+gxxwNT/dYaxSe386DG+0Ww8eXIHVy4HAU01HQ0hhGi/2vnbguidihlUq1bdwdWrlReoAGD0aB7WrOkGNzdLRERE1HCEmtWr/ihNh0AIIYQQHcLn8+Ht7Y2CgoJ/W9gAfAD0AOCs4CgPAZxB/2H7am2RCijPwwyeGOLKoyBNh0IIITqh9v7GIHpBKGQQHPwCK1feUegRPwBo3twev/3WA927u9RwdIQQQgghuik9PR0FBQWYsWAdUvh2uHY+E+/TFVv4vKGnKYaMsUf629c4tLPyNUIJIYSQD1GhiuikzMwi7N37BFu2PMLLl1kKnePoaILp0xtiwIB64HDSERHx31R22v6YEEIIIeQ/b98WA+iLPzYBBflvFTqnvrM5PvvSB+27lq9Dde18as0GSQghRC9RoYrolMjIt9i8+REOHHiGwsJSBc/KA3ARr1/fxvffl+H772syQkIIIYQQ3VRWJsT58wnYvj0Kp07FAeiDgnxhpec5OHIxZpI3uvd1AceAXfOBEkII0WtUqCJaLz29AH//HYM//3yGO3deK3yeKZeNbn2t0bWPJ4xN/OT21Zftj2WZcr0jMorfwNa4HnZ3uanpcAghhBCiRRISsnHwYDR27oxCYmKOwufZO3AxJqAxegxwhQEVqGSacr0jMthvgNmajoQQQnQDFaqIVioqKkVY2Cv8+eczhIW9Qmlp5XfzKljbmsD/Ew/0H+YOU66hQufQ9seEEEIIqU3S0vJx5EgMDh9+jlu3qvaInqOzGYaN5aHnIDcYGlKBihBCiGpRoYpojZycYpw+HY8TJ17g9OlXyMtTbMHO/2Rg5GdN8ElABxgZc2okRl3lbtEUdiaOqGNoo+lQCCGEEKIhiYnZCA2NQ0hIHC5f5kMoZKp0vldTGwwbz0PbzvXB4bBqKEr9427RFEZFxnj9OhFoquloCCFE+1GhimhUXFwWzp2Lx6lTr3DpEh8CQVmVx+jevQEGDLDE/PmD0LF7MBWppFjccqemQyCEEEKImpWWCnH//hucOvUKoaFxiIp6V+UxWCygTWdHDB/Hg3dzuxqIUv8tbrkT186HYMPhWUBvTUdDCCHajwpVRK3evy/EtWvJOH8+AefPJ+DVq2ylxjE3N8TEiU3x1Vct0bSpHSIiIgAo/nggIYQQQoi+YRgGT56k4/JlPi5d4uPatSTk5AiUGqtuXWO8fRuKxbUUbbsAADuiSURBVGumo3WHViqOlBBCCJGNClWkxjAMg4SEbISHp4j+PHuWUa0xW7SwxKBB9dCvnwPMzQ1QXMxHRAQf0dHRKoqaEEIIIbqKz+cjPT29WmPY2dnBxcVFRREpR9Hvo6CgFE+f5uLx42w8fpyDqKhsZGVVdemE/3A4LPTr54b/+78WqFcvC+3afQNrm0ClxyOEEEKUQYUqohIMwyAlJQ8PH75FREQaHj58i3v33iA1NU8Fo2cAeAAgApGRGYiMBFauVMGwhBBCCNEbfD4f3t7eKCgoqNY4XC4X0dHRGitWyf4+jAE4/vunPgAXAPUAVH8x806dnDBuXGOMHs1D3bpmAPDvbHVCCCFE/ahQRaqEYRi8fVuA58/fIybmPZ4/f4+nTzPw8GEa3r0rVNl17OoaopmvBZr5msPFnQcWq6Pc/g9uX8WhnetVdn19s+P5D8gvzYaZgSWmNf5B0+EQQgghKpeeno6CggLMWroezq4eSo2RnPgSG5bNRnp6usYKVfHxr1FQYIP+w5ehrNQGr5OL8Tq5GBnvlJ8p9TEWC2jb1hHDh3tg7NjGcHW1VNnYRNKO5z/gFespMEDTkRBCiG7QmUJVYWEhdu3ahbCwMCQnJ8PMzAw+Pj6YOHEiunXrptSYqamp2Lx5M65fv47379/D2toaHTp0wP/93/+hUaNGcs8tLS2t9p2m4uJiGBsbV2sMVU9PFwoZZGQUIikpF0lJueDzc8Dn5yApKRfx8dmIiclEdnaxyq73IWdXY3Tp0wjtu9aHS8M6YLEU300mOTGuRmLSF3fenUdG8RvYGtejQhUhhBAA2pdbqYqzqwcaefmo5VpVxTAMsrKKkZycK8q1yv/kIC4uG7Gx7/+98fc/nD3BoHxWuWpwuQbo08cNQ4Y0wqBB7qhXz0xlYxP57rw7jwzWG8Bb05EQQohu0IlCVUFBAQICAhAZGQlDQ0N4enoiKysL4eHhCA8PR2BgIGbMmFGlMV+9eoVx48YhKysLFhYW8PLyQnJyMkJCQnD27Fls3rwZXbp0kXl+cnIy/Pz8FLgSC4ARyqdrGwHgiP6wWAZgGNYHbRVTtz/cKlj+18bGJti2bQfs7OzAMOWFJqGQAcOU/7esjEFhYSkKCkr+/W/51wUFpcjLEyAjowgZGYVITy//8/59UZW3KlZeNoAXAGIAvMCspYfRyIt+gxNCCCE1TRtzq6oSChnk55cgN1eA4uJSJCYWAHBACr8IDJOJ0lIhykqFKC1lAIYBWCywWOWziQAW2GyUt5X/BywWCyn8QgAN8PhxNoqLU8EwjCi/Ev+6vOgkEJSJ5Vb5+SWir7OyipCRUYT09EJkZBSKvi4qKlXZa1DJK4SmTS0xZIg3evZ0QefOTjA1NVTTtQkhhBDl6UShatmyZYiMjIS3tze2bt0KR0dHAEBwcDAWL16MTZs2wdfXFx07yn88rEJpaSmmT5+OrKws+Pv7Y/ny5TAxMYFAIMDq1atx4MABzJ49G+fPn4e1tbXUMYRCQ3TtsxaGhtbIzytDXm4ZCgvKUFwkRFGREMX//hEUyy76MCqoBxUXA5MmXa/+QGpgbWuAhp6maOhhioaeXNRzMgKL1fbfx/YeaTo8vbay9d8QMmVgsziaDoUQQogW0MbcqqioDMHBL0Q3zyr+ZGQUIidHgNzc8j95eeXFqfx8aY/CzcH6HxMBJCr5ygDANwgIeIDy9TF1h4EhG428rODV1Aa29gXY8/sU7N9/A76+vpoOrdZb2fpv3L5+Dnv+WAms03Q0hBCi/bS+UMXn83Hy5Emw2WysXbtWlEgBwLBhwxAfH49t27Zh06ZNCidTJ0+eRGJiIurXr4+ffvoJRkZGAAAjIyMsWbIE0dHRePDgAfbu3YtZs2bJGMUc/1xgALyv5neon4yMOWjoYYlGXlbwbm6Hxs1sYe/AldqXHtureQ6mDTQdAiGEEC2hrblVamoehg8Pqf43WEvUdeSC18QGvKY2aNzUFg09LWFoVH5DKi7mCYAizQZIRBxMG8AK9kCWpiMhhBDdoPWFqpCQEJSVlcHX1xceHpILY44fPx7btm1DREQEUlNTUb9+/UrHPHHiBADA399flEhVYLFYGDt2LB48eICwsDA5hSryn1w08qqLpi2d4c6zQiOeFeo3MAfHoPq70BBCCCFEtSi30i1Gxhy4uteBm4flv3+s4NbIEmbmlT/GFx0drfR1q3MuIYQQUh1aX6h69OgRAMhcD8rBwQFOTk5ISUnB3bt3MWzYMLnjCYVCREVFyR2zYop0UlISXr9+LXansfYqRPltoPcA0gC8+/fPWwCF+GreSa1duJQQQggh/6HcShuVoDzPSkd5fpWO//v2G7Tu2Ay29qZgsxXfYAYAMjPegcVmY8KECaoPlRBCCKlhWl+oSkwsX2NA3s52FclUQkJCpeOlpaWhqKhI7piOjo7gcDgoKytDQkKCXiZTLBZgYsJBYWEG7OtZwcqGCzMzDswsOOCacWBpZQArWwNY2xjCysYAJqbS1zYqX19qvZqjJ1X1+P1tlDICGLCM0MymvabDIYQQokGUW6kHiwWYmXNgZs4B94P/mltwYGVtAEsbQ1hZG8DKxgBm5hzRbsfluVUoeE0Wylw2oTL5eTlghELMWroezq6Ss+YUQTme6jx+fxsJeA64aToSQgjRDVpfqMrIKN+W18bGRmYfKysrAEBmZqbC48kbk8PhwMLCAllZWQqNaWDIRh1LI1hYGoHLNYQp1wAmXAOY/vt1xR8TEwMYGrHBMWDjxbMInDmxD5NmzIeTqxsMDNjgcP67W8YwHyy2zjD44EvRgdSkROz89Xts2bIZPJ4n2GwW2OzyHW3K/1v+/6amBuByDcDlGor+a2zMwcOHD+Hn54cFPyk/G4rWl9INvz6djYziN7A1rofdXW5qOhxCCCEapAu5VQVTrgEsLI1gZm4oyqtMTD/Irf792siIg1cvHuPy6b8xdnIgHJ0bgMNhw8CABY4BGywWRDv1Af99Lcq3/v36TSoff277BatWrYK7e0NRLlWxK+CHX7NYgKEhG2ZmhmI51osXz9C7d1es2XEMnt7NFP5eK6gyt3J29aAcTwv8+nQ2MthvgBGajoQQQnQDi2FUsfdczfH29oZQKMTOnTvRtWtXqX3mzJmD0NBQDBs2DKtXr5Y73v379/Hpp58CAKKiomBsbCy1X9euXZGWloaVK1di5MiRYseaNWuG4uJimHDrwNDQ8N9tjqumuLgIeTlZsLS2hYGBclsFl5aWIDszA3Xr1pVYD0IRAoEAb9++rVYMqvg+tGEMbYihJsfILHsn2vXPmmOvkRh0cQxtiEFbxtCGGLRlDG2IQVvG0IYYVDVGXk4mDA0N8fjxY6XO1yXam1sJYGRiAUMDA7DYLLCruNSlNuRWQPXzK235N6ENY2hDDKoYoyIPAwNYsmr3a6GKMbQhBm0ZQxti0JYxtCEGbRlDG2IAqpdbaf2MKg6HA6FQKJoOLU1FrY2tQEbzYR9lxzQ2NgaLxYK9rWWl15PJgou6drLvZCrK1lr5GIyMjGBubl69AFTxfWjDGNoQQw2OYQlXjcegk2NoQwzaMoY2xKAtY2hDDNoyhjbEoKIxBEX5ShcmdI1W51b2up1bASrIr7Tk34RWjKENMahgjCrlYTUUg16NoQ0xaMsY2hCDtoyhDTFoyxjaEAOql1tpfaGKy+UiOzsbxcXFMvsIBAIAkHkH7+PxKhQXF8t84eSNef/+/UqvQwghhBCijSi3IoQQQog2q+KkavWztrYGAGRlZcnsU7HWga2trcLjyRuztLQUubm5Co9JCCGEEKIrKLcihBBCiDbT+kKVu7s7ACA5OVlmn5SUFACAm5tbpeM5ODjAwsJC7pivX79GWVmZwmMSQgghhOgKyq0IIYQQos20vlDVokULAMCjR4+kHk9LS0NqaioAoFWrVgqN2bx5cwDAw4cPpR6vaHdycoKDgwOA8oRt6dKl6NmzJ5o1a4aePXvi22+/xdOnTxX+Xj6WmpqKxYsXo2vXrvDx8UGXLl0wb948xMXRLiuqfr2Tk5Ph5eUl98/QoUNV/F1ov7/++gteXl44evSozD6ZmZlYuXIlevXqBR8fH3Ts2BEzZsyQ+W9SEbGxsZg1axY6duwIHx8f9OzZEz/88APS0tKUHlMXaOL1vnPnTqU/+1999ZWS35F2U+T1VqavLLX9PV2drze9p1ePtuRWtR3lOppBuY/mUT6keZQjaRblTJXT+jWq+vfvjw0bNuDu3bt49eqV6C5ghUOHDgEA2rZtC2dnZ4XGHDBgAG7cuIHjx49j6tSpEmsp/PXXXwCA4cOHAwBu3bqFGTNmIC8vDxwOBzweDwUFBTh16hTCwsIwf/58TJo0qUrf16tXrzBu3DhkZWXBwsICXl5eSE5ORkhICM6ePYvNmzejS5cuVRpTX9TE6/38+XMA5dttf/wzVKG23eGNiorCmjVr5PZJT0/HuHHjwOfzYWpqCh6Ph7S0NFy4cAGXL1/GsmXLMGrUqCpd9/79+5g8eTKKi4thbW0NHo+H+Ph4HD58GKdPn8a+ffvg7e1dnW9NK2nq9a742be3t0eDBg2k9vHw8KjSmLpAkddbmb6y1Pb3dHW/3vSeXj3akFvVdpTraAblPppH+ZDmUY6kWZQzKYjRAbNnz2Z4PB4zcOBAJiEhQdQeHBzMNGnShOHxeMyNGzckzktMTGRevnzJpKWlibUXFRUxvXv3Zng8HhMYGMjk5uYyDMMwxcXFzPLlyxkej8f4+fkx79+/Z16/fs34+fkxPB6PGTNmDJOcnCwaJzw8XHTs1KlTCn8/JSUlTJ8+fRgej8fMmTOHKSwsFF1/2bJlDI/HY1q3bs28f/++Sq+TPqiJ15thGGbTpk0Mj8djli5dquqQddLt27eZNm3aMDwej+HxeMyRI0ek9pswYQLD4/GYSZMmMVlZWQzDMExZWRmzfft2hsfjMU2bNmVevnyp8HUzMzNF1/3ll1+YkpIShmEYJjc3lwkMDGR4PB7Tq1cvpri4uPrfpBbR1OvNMAyzYMEChsfjMdu3b6/296ErFH29q9pXltr+nq7u15th6D1dFTSZW9V2lOtoBuU+mkf5kOZRjqRZlDMpTusf/QOAJUuWgMfj4eXLlxgwYACGDRuGnj17Yt68eSgtLRVNo/1YQEAABg4ciPXr14u1GxsbY926dbCwsMC5c+fQpUsXjBw5El26dMGff/4JQ0ND/P7777C2tsaePXuQm5sLe3t7bN++HU5OTqJxOnXqhDlz5gAAVq1aJXf3nA+dPHkSiYmJqF+/Pn766SeYmJgAKN/OeMmSJfDz80NOTg727t2r5Cumu2ri9QaAmJgYAACPx1NtwDqmuLgYmzZtwqRJk5CdnS237507d3D37l1wuVysXbsWlpbl23Wz2WxMmzYNQ4YMQUlJCbZu3arw9f/8809kZ2ejZcuWmDNnDgwMyid1mpubY+3atXB2dkZSUhJCQkKU/ya1iKZfb+C/n30vLy/lvgkdUpXXuyp9K1Nb39M19XoD9J6uCprMrWo7ynXUS9O/i2tb7iONpv8OgNqVD0lDOZJmUc5UdTpRqLK2tsbff/+NGTNmwM3NDXFxccjMzETbtm2xceNGTJ8+vcpjNm/eHCEhIRg1ahTq1KmDmJgYsFgs9OvXD0ePHkX79u0BANeuXQMAjBo1ClZWVhLjjB49GlwuF+/evUN4eLhC1z5x4gQAwN/fX2JqPIvFwtixYwEAYWFhVf6+dF1NvN7Af1Mede0fqColJiaiX79++P333wEAM2fOFEuOP1bxc9qrVy/Y2NhIHB83bhwA4NKlSygqKlIohooxpU3XNjIyErWfOnVKofG0mTa83qWlpXj58iUAwNPTs0rx65qqvN5V/bupTG18T9fk6w3Qe7oqaDK3qu0o11EfbfhdXJtyH2m04e+gNuVD0lCOpFmUMylH69eoqsDlchEYGIjAwECFz7l8+bLc405OTvjpp5/k9qlYTNTHx0fqcQ6HAxcXFzx//hyRkZHo1auX3PGEQiGioqIAAH5+flL7+Pr6AgCSkpLw+vVrODo6yh1Tn6j69QaA/Px8JCUlAaidv5wqvHnzBq9fv0bLli3x3XffwcfHR+6ifBUL38r6OW3evDkMDAxQUFCAJ0+eoHXr1nKv//btW9EuUhU/4x+raI+IiEBJSQkMDQ0r/b60laZfbwCIj49HcXExLCwsUL9+feW+ER1Rlde7qn838tTW93RNvd4AvaerkqZyq9qOch310fTv4tqW+0ij6b8DoHblQ9JQjqRZlDMpR2cKVZrCYrEAQDRNV5rS0lIA/23lLE9aWpqo+u/i4iK1j6OjIzgcDsrKypCQkKCX/2BlUfXrDZRPd2QYBnXr1kVmZib27NmDZ8+eoaysDG5ubhg0aJDMN099Uq9ePezYsQPdunWrtK9QKBRtMS7r59TQ0BAODg5ISUlBfHx8pYkCn88HUP53LGsRy4o7BgKBAK9fv5Z5bV2g6dcb+O8OioeHB54+fYqTJ0/ixYsXYLPZ8PT0xLBhw/RmCnxVXu+q9K1MbX1P19TrDdB7OtF9lOuoj6Z/F9e23EcaTf8dALUrH5KGciTNopxJOVSoqkSDBg3w4sULREdHo3v37hLHi4uLRVVKRZ4hzcjIEH0tbTorUH4nzcLCAllZWcjMzFQucB2l6tcb+O+XU05ODgYNGoSysjLRsRs3buDgwYMYOXIkfvzxR727i/UhV1dXuLq6KtQ3OztblCTL+jkFynePSElJUejntOJn39zcXGLq74fjVcjMzNTpZE3Trzfw389+TEwMRowYIXbs+vXr2Lt3L6ZNm4ZZs2YpNJ42q8rrXZW+lamt7+maer0Bek8nuo9yHfXR9O/i2pb7SKPpvwOgduVD0lCOpFmUMylHJ9ao0qSePXsCKN+qWdo/nj/++EO00GVJSUml4334LLWxsbHMfhXHCgsLqxSvrlP16w389w+0uLgYo0ePRlhYGB4/fowrV65g5syZMDQ0RFBQED2q8IEPf05lJVbAfz+niqwRUPGzLO/nvmKBxQ/71wY18XoD//3sCwQCTJ8+HRcvXsTjx49x/vx5fP7552AYBtu2bcPOnTurEX3tRu/p6kfv6UTXUa6jnSj30TzKh/QL5Uiap8u/G2hGVSUCAgIQFBSEt2/f4rPPPsPixYvh5+eH3NxcBAUFiXawyczMlDuFuwKb/V9tsGLqtzQMw0j0rw1U/XoDQOvWrcEwDLy9vTF+/HhRe/369fHll1/CyckJc+fOxV9//YVPP/1U557frQk18XPK4XAqHU9WDPqupt4XevTogbp166J79+7o16+fqN3V1RWLFi2CtbU1fv31V2zevBkjR46Ue/eSSEfv6epH7+lE11Guo50o99E8yof0C+VImqfLvxuoUFUJGxsb7NixA9OnT8eLFy8QEBAgdnzs2LHgcrn4448/YG5uXul4XC5X9HVxcbHMuwUCgQCA/OqzPlL16w2U7zLh7+8v9/jmzZuRkJCAS5cuadU/UE0xMzMTfV3xsyhNVX5OK3725W21/eGdlw/vMOq7mni9AWDChAlyj0+ZMgU7duxAQUEBbty4gSFDhig0LvkPvaerH72nE11HuY52otxH8ygf0i+UI2meLv9uoEKVApo2bYozZ87g6NGjuHv3LoqKiuDq6oqhQ4eiVatWWLBgAQDAwcGh0rGsra1FX2dlZcHCwkKiT2lpKXJzcwEAtra2KvoudIcqX29FeXt7IyEhQbSAY23H5XJhZGQEgUAg93nximOK/JxW/Ozn5eXJ3NXmw2vVprtZNfF6K8LIyAgeHh6Iioqin30l0Xu6dqL3dKLtKNfRPpT7aB7lQ/qFciTdoK2/G6hQpSBzc3NMmjQJkyZNkjj29OlTAACPx6t0HAcHB1hYWCA3NxfJyclSdwB5/fq1aKEzNze36gWuo1T1elcoKSkBm80WTcH+mFAoBCB/B57ahM1mo2HDhoiJiZH5plVSUoK3b98CUOzntFGjRgDKX2tZu9pU7G5kbGysl7t+yFITr3eF4uJiuXeo6Ge/eug9XTPoPZ3oA8p1tAvlPppH+ZB+oRxJO+jq7wZ6ELQS9+/fx549e3Dz5k2px5OSkhAbGwsA6NChg0JjNm/eHADw8OFDqccr2p2cnFR6J00XqPr1zs7ORtu2beHj44NLly7J7BcdHQ2gfNtaUq5FixYAgEePHkk9HhUVhdLSUhgbG6NJkyaVjmdpaSn6BVTZz36LFi1kvpnqK1W/3s+fP4efnx+aN28u+sDzseLiYsTFxQGgn/3qoPd09aH3dKIPKNfRXpT7aB7lQ/qFciTN0fXfDVSoqsSdO3fw888/Y+PGjVKPb9myBQDQq1cvODk5KTTmgAEDAADHjx+X+vz1X3/9BQAYPny4MiHrNFW/3paWlrCzswNQ/npLc/bsWfD5fBgaGqJPnz5KRq5/Kn5Oz507h6ysLInjhw8fBgAMHDhQ4TUV+vfvDwA4cuSIxDGBQICgoCAAtfNnX9Wvt7u7u2hRyhMnTkjtc+DAARQWFsLa2lrhQjuRRO/p6kPv6UQfUK6jvSj30TzKh/QL5Uiao+u/G6hQVQl/f38YGhri4cOH2L59u2hqXHFxMX799VccP34cRkZGmDlzpsS5fD4fcXFxoumpH47p4uKCpKQkzJkzB3l5eQDKf1mtWLECDx48gIWFRaUL/+mjmni9p02bBgC4cuUK1q1bJ/YmefbsWSxcuBAAMHXqVKrkf6BDhw6iXYi+/vprpKenAyifHrpz506EhobC0NAQX3zxhcS5cXFxiIuLw/v378XaJ06cCEtLS9y/fx8rVqwQ/V3k5eVhzpw5SEpKQoMGDWrlIpaqfr2NjIxEC/QeOHAA+/fvF/17EgqFOHjwINavXw8A+Pbbb2v9Aq6KoPd09aL3dKKvKNfRXpT7aB7lQ7qJciTN0sffDdr1IKIWatCgARYsWIDly5dj/fr12L9/PxwcHMDn85GbmwtjY2Ns3rxZ6hoCAQEBSElJwfDhw/Hzzz+L2o2NjbFu3TpMnjwZ586dw/Xr1+Hu7o7k5GRkZWXB0NBQtDVxbVMTr/ewYcMQExODP/74Azt27MDBgwfh5uaG9PR0pKWlAQBGjx6Nb775Rm3fpy5gsVhYvXo1Pv30U9y/fx89evSAp6cn3r59i3fv3oHFYmHlypWi9Rc+NHDgQADAjBkzEBgYKGq3tbXF6tWrERgYiD///BOhoaFwdnZGfHw88vPzUadOHWzdulXqYqP6riZe7+nTpyMuLg5hYWH46aefsHnzZjg7OyMlJQWZmZlgsVgIDAzE6NGj1fZ96jJ6T1cvek8n+opyHe1FuY/mUT6kmyhH0ix9/N1AM6oUMGHCBOzduxddu3ZFSUkJYmJiYGZmhhEjRiA4OBhdunSp8pjNmzdHSEgIRo0ahTp16iAmJgYsFgv9+vXD0aNH0b59+xr4TnRDTbze8+fPx549e9CrVy+YmJggJiYGpaWl6NGjB7Zv344VK1aIpgWT/zRo0ADBwcH4/PPP4eDggNjYWBQXF6NLly7Yu3ev3O1OZenRoweCgoIwcOBAGBgY4Pnz5+ByuRg+fDiOHz+uVduiqpuqX28Oh4P169fj119/RefOnQEAMTExMDAwwIABA3Do0CHMmDGjJr6VWofe09WL3tOJrqNcR3tR7qN5lA/pF8qRNEtXfzewGIZhNB0EIYQQQgghhBBCCCHaVzojhBBCCCGEEEIIIbUSFaoIIYQQQgghhBBCiFagQhUhhBBCCCGEEEII0QpUqCKEEEIIIYQQQgghWoEKVYQQQgghhBBCCCFEK1ChihBCCCGEEEIIIYRoBSpUEUIIIYQQQgghhBCtQIUqQgghhBBCCCGEEKIVqFBFCCGEEEIIIYQQQrQCFaoIIYQQQgghhBBCiFYw0HQAhOiq2NhYjBgxAv3798fatWtl9istLcWBAwdw4sQJxMfHw8jICDweD+PGjcOQIUNknldYWIhdu3YhLCwMycnJMDMzg4+PDyZOnIhu3bpVKdbjx49j4cKFYm0zZsxAYGCg3POSk5PRq1cvAMD+/fvRrl07ha8TExMjtc/z589x7Ngx3Lp1C2lpaSguLoaNjQ08PT3RvXt3jBo1CiYmJgp9DxUMDQ1hamqKevXqoU2bNhg1ahSaNGki0W/BggU4ceKEWNuePXvQsWNHud9XVc2ePRs3b97EuXPnYGlpKfY6nj9/Hq6uriq9XnUUFhZiyJAhEAgE+Oeff+T2vXz5Mvbt24cnT56gtLQUDRo0wKBBgzB58mQYGxurKeKadefOHUycOBEA8PTpUxgYVO/X5MKFC3H58mWEhoaibt26qgiREEL0SlFREQ4cOIBz584hLi4OAoEA9vb2aNOmDSZPnozGjRtLPe+zzz7D3bt35Y4dHBwMb29vsTbKryr/HipQfqU8yq/EUX5FqooKVYQoITMzE7Nnz0ZJSYncfmVlZfjmm29w6dIlsNlseHp6ori4GA8ePMCDBw9w8+ZNrFq1SuK8goICBAQEIDIyEoaGhvD09ERWVhbCw8MRHh6OwMBAzJgxo8pxGxoaolmzZgAAR0fHKp9fXRs3bsTWrVshFAphbm4OFxcXGBoa4t27d7h+/TquX7+OXbt2YfPmzWjatKnMcXx9fcX+v7S0FJmZmXj58iViY2Nx+PBhTJo0CfPmzRPr5+bmJjo3IiJC9d8ggFOnTiEsLAxLly6FpaVljVxDVYRCIZYsWYKkpCQ4ODjI7bt7926sWbMGAODs7AwLCwvExsbi119/xblz53DgwAGYm5urI2yd8u233+LcuXNYuHAhdu/erelwCCFEq6Snp+Pzzz/Hy5cvAQAODg6wtLREYmIiQkJCcPr0afz0008YOnSoxLkVBZsWLVqAw+FIHZ/L5Yr9P+VXlF+pA+VXNY/yq1qAIYRUSUpKCuPv78/weDyGx+Mx3377rcy+GzduZHg8HtO9e3fmxYsXovbr168zLVu2ZHg8HnPkyBGJ8+bPn8/weDxm6NChTGpqqqj9xIkTTJMmTRgej8fcuHFD4ZiDgoIYHo/HdOnSReFzGIZhkpKSRN/n7du3Fb4Oj8eTOHbs2DGGx+MxLVu2ZM6cOcOUlpaKHX/58iUzZswYhsfjMe3atWMyMjIUHrvC+/fvmZ9//pnx8vJieDwe88svv8jsWzFWVV7HyuTk5DAdO3Zk+vbty5SUlIjaP3wdExISVHa96igsLGRmz54tikvez8atW7cYLy8vpmnTpsy5c+dE7QkJCczAgQMZHo/HzJkzRx1h17jbt2+LXpMP/w6rY8uWLQyPx2NCQ0NVMh4hhOiLSZMmMTwej+nTpw8TGRkpas/Ly2O+++47hsfjMU2bNmViYmLEzktJSWF4PB7TokULpqysTOHrUX5F+VVNo/xKOsqvSFXRGlWEVMHp06cxfPhwPH/+vNK+ubm52LdvHwBg2bJl8PDwEB3r3LkzFi1aBADYsmULhEKh6Bifz8fJkyfBZrOxdu1asTtzw4YNw9SpUwEAmzZtUsn3pC7btm0DAMybNw/9+/eXuPvZqFEjbN26Fba2tsjMzMT+/furfA1ra2vMnz8fM2fOBADs3LkTkZGR1Y5dUdu3b0d6ejq+/PLLak9prklPnjzB6NGjcerUKYX6b968GQzDYNKkSejbt6+o3dXVFZs2bQKHw0FoaCgSEhJqKGLd9tlnn8HCwgJr166FQCDQdDiEEKIVoqOjcePGDbDZbKxbtw7NmzcXHTMzM8OPP/6I1q1bo6SkRJRPVajIwzw8PMBmK/ZxhvIryq9qGuVX6kX5lX6jQhUhCho7dixmzZqFrKws9OvXD/369ZPb/8KFC8jNzYWDgwO6dOkicXzo0KEwNTVFamqq2DTpkJAQlJWVoWXLlmLFrQrjx48HUD61OjU1tZrflXrk5OSAz+cDKJ+iL4uNjQ169+4NAIiKilL6etOmTQOPxwMA/P7770qPUxXv37/HgQMHYGlpiQEDBqjlmspYt24dRo0ahdjYWHh6emL69Oly+ycnJ4vWABk1apTEcXd3d7Rr1w4MwyAsLKxGYtZ15ubmGDJkCF6/fo1jx45pOhxCCNEKd+7cAQC4uLiIHpv7EIvFQs+ePQEAjx8/FjtWUajy9PRU+HqUX1F+VZMov1I/yq/0GxWqiN44fvw4vLy8MGvWLDx48ABDhw6Fj48POnfujL179wIAvLy84OXlhZycHAQHB2P48OFo0aIFOnfujOnTp8tdlPPhw4dwdHTEunXrsHHjRol1Dz726NEjAICfn5/U40ZGRqLErCJZU+Q8BwcHODk5AUCli4hqiw/vfl25ckVu38DAQISFhWHdunVKX4/NZmP06NEAgFu3biE/P1/psRR17NgxFBYWon///lVe+DI+Ph7ff/89+vTpAx8fH/j5+WHMmDHYu3cvioqKZJ539uxZfPbZZ2jfvj1atmyJTz75BKdOnUJycjK8vLxECf6HHj16BFNTU8yYMQPHjx+vdOHRip9HOzs7mX0r1qWoys9jUVERduzYgbFjx6JDhw5o1qwZevTogW+//RYPHjyQed7z58/x3XffoXfv3mjWrBnatGmDzz//HGfPnpXaPzExET/99BP8/f3RunVrNG3aFO3atcPEiRNx5MgRlJWVKRxzxfXnz5+P7t27w8fHB+3atcOUKVNw7tw5uecNGzYMAHDgwIEqXY8QQjStpvKrnj17YsOGDZgzZ47MazMMAwBiM8+B/wpVXl5eCn8flF9RfkX5FeVXRHdo79xJQpT06tUrTJ06FRwOB56enoiLi5O4c7Zx40b8+eef4HK58PDwQEpKCq5cuYKrV69i7ty5mDJlisS4P/74I4YPH67wL8nExEQA5XcKZalIiD6c0qvoeSkpKTozFZjL5cLX1xcRERHYtGkT+Hw+Ro0aBV9fX4kp6vb29rC3t6/2NSsS0ZKSEjx8+BCdO3eu9pjynD59GgCqvGPQyZMnsXjxYggEApiYmIDH4yE/Px+RkZGIjIxEUFAQdu7ciXr16onOEQqF+P7773HkyBEA5Qu31q9fH9HR0fj222/Fpo9/bOzYsWjXrh3s7OwUiq/i57FBgwYy+0j7OZZHIBAgICAADx8+BIfDgaurKxwdHZGUlCRaLHX58uWiZLjCwYMHsWrVKpSUlMDMzAyenp7IyMjA7du3cfv2bUyfPh2zZs0S9b948SJmzZoFgUAALpeLBg0agGEYJCcn486dO6I/iibtBw8exE8//YSysjJwuVyJRXgHDx6MNWvWSF3Ut1mzZrCyskJcXByeP38ucxcrQgjRVqrOr1xcXOTmOgBEH5I/vk7FQurOzs74+++/cevWLbx//x52dnbo0KEDhg4dCiMjI7FzKL+i/IryK8qviO6gGVVE7zx//hw8Hg9XrlzBiRMncO3aNXTq1Emsz59//okhQ4bg+vXrCAoKwo0bNxAYGAiGYfDLL79I3bFk7NixVbqT8/79ewDlz/XLYmVlBaB8F8EKGRkZAMqnaVflPG333XffgcvlgmEYBAcHY8KECWjbti2mTZuGHTt2IDIyUuKOaXU4OzuLvn79+rXKxpXm/fv3oru7su7UShMZGYmFCxdCIBBgzJgxuHHjBo4fP45z584hODgYbm5uiI2NxVdffYXS0lLReUePHsWRI0dgYmKCDRs24OrVqzh+/DiuX7+Ofv364fz58zKvOWjQIIWTqIrvDVDtz2NQUBAePnwINzc3XLx4EWfOnMHx48cRHh6OTz/9FAzDYPXq1SguLhadExERgRUrVqCkpATTpk3DrVu3cPz4cVy7dg2rVq0Cm83Gtm3bEB4eDgDIzs7GokWLIBAIMG7cONy8eRMnT55EaGgobty4gc8++wxA+S5CL168qDTmf/75B8uXLwebzcbixYtx//59nDhxAleuXMHevXtha2uLU6dOyVzbhM1mo1WrVgCAGzduKPQ6EUKINqmp/EqWI0eOiB75q5g1AZTv3FfxuNu8efOwdOlSnDlzBnfu3EFYWBiWLFmCIUOGIC4uTmw8yq9Ug/Ir6Si/ovyKqBYVqohemjlzJiwsLACUF4pYLJbY8WbNmmHNmjWi7V45HA5mzJiBwYMHg2EYbN68udoxFBYWAoDc4lbFsQ+nH1d8/fGdwMrO03ZNmjTB0aNHxRKNvLw8XLt2DevWrcOYMWPQuXNnbNiwQfTaVYeZmZno65pOOO/evQuGYWBvby9KKhSxceNGlJaWonPnzli+fLnY9sPe3t7YtWsXTExM8PTpU9H6BEKhUPTLet68eRg4cKDoHEtLS6xbt65Kj0JURpGfYxMTEwBAcXGx6DENeSqSzq5du6J+/fqidmNjYyxYsACdO3dGnz59kJWVJTpWsenAgAED8O2334rFM2LECNH6DsePHwcA3L9/HyUlJbC3t8eSJUtgamoq6s/lcrFgwQIYGhoCAGJjYyuNef369WAYBnPmzMHEiRPF7up16NABq1atAgDs2bNH5s9bxboet2/frvR6hBCijdSVX928eRPLly8HAHTp0gXdu3cXHYuNjRUVXlxcXLBz505ERETgwYMH2LJlC9zc3JCQkIApU6aIvR9TfkX5FUD5FeVXRFdQoYronQ8r67JMnDhR6i4xY8eOBVC+ZlReXl614qh4o/04iZPmwz6KnFfxy0rRnW60hYeHBw4dOoTg4GDMmDEDrVq1Ev0yA8rvdm7btg3+/v548+ZNta5VUlIi+lqRv4PqSE5OBoBK1yP4UEFBgWhtsokTJ0rt06BBA9Hip5cuXQJQvqbBu3fvYGRkhJEjR0qcY2hoiE8//bRK8ctTlZ/HyvpVcHNzA1C+7sShQ4dEdxWB8g8Qu3fvxqpVq+Dg4ACgPJmrSD4++eQTqWPOnDkTZ8+exerVqwEAvXr1wsOHD3Hx4kWpOwQVFxeLkt7KEvfk5GRER0cDAPz9/aX26datG6ytrVFUVIRbt25J7dOwYUMAQFJSktzrEUKINlJXfnXt2jV8+eWXEAgEcHZ2xpo1a8SOW1hYYNKkSRg1ahQOHz6Mrl27wszMDObm5ujVqxcOHz4Me3t7vH79Grt27RKdR/kV5VcVKL+i/IpoP1qjiuidOnXqiO5AyPLhFsgfqrhTUlJSgpSUlGrdOalYbP3D6bUfqzj2YbxcLhfZ2dlyz6vYgrWqi0pWlbRnweVRNMHz9vaGt7c3AgMDUVhYiIiICISHhyMkJAQZGRng8/n43//+h7///lvp2HNzc0VfW1paKj2OIioeJ6i4y6yIpKQkUbLn4+Mjs5+Pjw9OnTqF+Ph4ABBNo3Zzc5P5cy5vvKpS9udYntGjR+PYsWN4+fIlfvzxRyxbtgze3t7o0KEDunTpgjZt2oglP6mpqaLXStbaA7a2trC1tZVoNzExwfPnz/H8+XMkJSWBz+fj5cuXePHihWjMyu5Sfjh1/euvv5bZr+J1ePXqldTjFT8fHyaOhBCiK9SRXx07dgw//PADSkpK4OTkhL1790o8GtWoUSMsWLBAZgw2NjaYMGECNmzYgIsXL2Lu3LkAKL+i/Eoc5VeUXxHtRoUqoncUSS5k/WL9cCe/D38RK6NibaoPp9d+rGIK64e/AKytrZGdnV3l82rCh78Y5f0irVBx50TRX6gAYGpqik6dOqFTp0743//+h0WLFiEsLAyPHj3C06dP0bRp06oHDoitTeHu7q7UGIrKyckBALHpz5X58I6yvASsYrp6xc46FX/38nad/HCKe3Up+3Msj7m5Of7++2/88f/t3XtQVPUbBvBnAUGQHJARmmaWSySSCaHDkLU4Jk0/MUQ0kEYxMBVUFLBsNEqdcmLaGg1TNBAhES9lWtCgmFMO7AgjDMTkhUES3QVK8IIkhe4ul98fzDmysou7tiiX5/NX7dlzcW/n4XvO932zs1FQUACVSoXq6mpUV1cjKysLTk5OWLt2LSIjI/vsu/eUg4cpLi7G9u3bUV1drfO4s7MzgoODoVAo8Pfffz90O71/C4ypr2Lot0N4z4TPCxHRUDKQ+aq7uxtffvkl9uzZA6BnKs/evXvFOz9M9fzzzwO4f0cOwHzFfKWL+Yr5igY3DlTRiHT37l29Rc57/wD2V9zQGM8++yxKSkp0QtKD/vzzTwD3b9UV1lMqlSavNxAcHBxgbW0NjUZj1FWK69evA+g5UfW2efNmnD17FvPnz8eqVasMrj969Ghs2bIFp06dglarxdWrVx85SAknPBsbm0fehrGE8G7KCbJ3IGhrazMYQoQTvfB8Iaz1N3XCnO2iPT09AcDsn0d7e3skJiYiMTERKpVK7BBTXFyMW7duYdOmTXBwcMD//vc/ndD4zz//GPXdFLrUdHV1wc/PD6GhofDy8oKnp6f4Wk+fPt2oYxX27+DgIE4neBTCeznQV+qJiJ6UR8lXGo0G69evR2FhIYCeujQ7d+7sd5Chu7sbWq3WYL0p4U6O3nePMF8xX/XGfMV8RYPb0JqATWQmhrpQCEUI7ezsxJawj+rFF18E0DPnXR+NRoMLFy4AgE7Nh4et19zcjL/++qvPegNBIpGIBQqFY+3PuXPnAKDPLf1qtRoqlQq//PLLQ7dhb28vhoZHHSzs6uoSiz6+9tprJl2JexRClxdTioq6urqK9SP6e22FZUJ9BuH9UKlUBou9Cp9jc/D19YVEIkFTU5PBuhZVVVUAjP883rp1CxUVFWI4d3NzQ2RkJLZt24bi4mLx1vr8/HwAPbUkhGkShr6758+fx8KFC5GcnIzu7m5kZmaiq6sL06ZNw6FDh8QuSEKI0mg0Rr9fQu2D1tZW3Lhxw+DzKioqUFdXZ/B9eVxX6omInhRT81VHRweSkpLEQar58+cjMzOz30Gq999/H5MnT0ZiYqLB51y8eBHA/cEAgPmK+UoX8xXzFQ1uHKiiEeno0aN6Hz98+DAAYObMmf95VF7YRn19vd7if/n5+bh79y6kUin8/f3Fx4ODgwH0dDrRNxf70KFDAICAgACdFsEDRSg2mZeX1+9J5PLlyygvLwdw/98gEAokXrhwQQw4hpw5cwatra1wcHAQQ6Wpvv76azQ2NsLCwgJxcXGPtA1TCCfa5uZmo9exs7PDSy+9BADYv3+/3uc0NDTg9OnTAHo6uAA97ZnHjRsHrVYrBo3euru7ceTIEZOOvz8uLi5iQPr222/7LL9y5QrKyspgaWlpsBDmg5YtW4aoqCj8+OOPfZaNGTMGfn5+AIDOzk4APeFa6GZ07NgxvdssKCjAb7/9hsbGRkgkEvEKpbe3t95aIHl5eWINhd6tqfXx9PQUg+yBAwf0PqeyshJRUVF44403+v0jCBj4qRJERE+Kqfnqs88+E89zy5Ytg1wu1ykCrs/EiRPR0dGBs2fP4tq1a32W37lzR6zBFBISIj7OfMV8JWC+Yr6iwY8DVTQinTp1Cl999ZX4A6rVapGamoqff/4Z1tbWWLNmzX/eh729Pd555x0APW1ue1/VKSkpEdutrlixQueH3t3dHXPmzEFnZycSEhKgUqnEZfn5+WIHm/5u8TanJUuWQCqVoq2tDYsXL0ZFRYXO8q6uLigUCsTFxaGzsxP+/v46LX0BQCaTYdasWQCAjRs3IiUlpc+tzmq1GseOHcPatWsBAElJSSbNlweApqYmpKSkiO2F4+PjxToVA2nq1KkAgJs3b5rUcWTNmjWwsrLCmTNnsGnTJp3bzWtqahAbGwu1Wg1vb2/MmzcPQE/XlpUrVwIA5HK52K0G6Ol0s3nzZvEKnLkI34fMzEzk5eWJj9fX1yMhIQGdnZ0ICQkxuitPWFgYACAtLQ0KhUJnWUVFhRgQZ8yYIT4eHx8PiUSC/Px8pKen64SfvLw85ObmAgCWL18O4H5YOX78uE49DbVajQMHDuDTTz8VHzOmDXlSUhIAYM+ePcjMzBQL7grHLCz38/PDtGnT9G5DmC7Ru4U4EdFwYkq+qqioEP84DQ0Nxfr1643ax4IFC+Do6Ii7d+/2yUkNDQ2Ii4tDc3Mz3N3dsWjRInEZ89VaAMxXzFfMVzQ0sEYVjUheXl7YvXs3Dh06BKlUioaGBrS2tsLGxgZyudxsI/Lx8fGoqqpCWVkZIiIiMGHCBGg0GiiVSgBAZGQkFixY0Ge9jRs3ora2FrW1tZg9eza8vLxw584dca76u+++i1deecUsx/gwtra2yMjIQGJiIi5fvoyoqCg4OTnh6aefRldXFxoaGsQAIJPJsH37dr3b2bp1K+zs7JCXl4f9+/dj//79eOaZZ+Dk5AS1Wg2lUgmNRoNRo0Zh3bp1OuHyQQsXLtT5f7VajZaWFvHKqqWlJVauXImEhATzvAgP4eLigokTJ+LSpUuorKyEVCo1ar0pU6YgJSUFGzduxJEjR/DTTz/B09MT7e3tYhcaLy8vpKWl6dThePvtt/H777/j+PHjiI+PF1/Huro6tLe3w9fXF+fOnTO5q5AhMpkMK1asQEZGBjZs2IAdO3Zg7NixqK2tRWdnJ1544QV8/PHHRm8vOjoapaWlUCgUiI2NhbOzM5ydnXH79m3xMx4UFKTz3Xj55ZeRnJwMuVyO1NRUZGdnQyqVoqmpCTdv3gTQ0zFGCF+rV69GaWkpbty4gdDQULi7u8Pa2hoqlQrt7e0YN24cPDw8UFNTY1Sr7pCQECiVSuzcuRNbt25FRkYG3N3d0dLSIh6zh4cHdu/erXd9rVYrTt3oHRCJiIYTU/JVZmam+N91dXV9zu29jR8/Hjt27ADQU88mLS0Nq1atwvnz5zF79my4ubnBysoKly9fRldXF6RSKfbu3dtnahrzFfMV8xXzFQ0NHKiiEWnDhg1QqVQ4fPgwLl26BCcnJwQFBWH58uU69Qz+KxsbG2RlZeHgwYPIy8uDUqlEd3c3fHx88NZbbyEiIkLveo6Ojvjuu++QlZWFwsJC1NXVwcrKCgEBAVi8eLF49exx8fT0xNGjR3Hy5EkUFhbiypUruHr1KiQSCVxcXCCTyRAeHo7p06cbbJ1sbW0NuVyOqKgonDhxAmVlZWhubkZNTQ1sbW3h4eGBwMBAREREPHSg8MHOIFZWVrC3t4ePjw8CAgIQHh5u1vfRGGFhYfjiiy+gUCjEq3PGmDdvHnx8fLBv3z6Ulpbijz/+gJ2dHaZOnYo5c+YgIiKizzRUCwsLbNu2DTKZDN9//z1qa2tx+/ZteHt7Y+nSpdBoNFi3bp1J3YEe5r333oOvry9yc3Nx8eJFXL9+HVKpFMHBwYiLizPp6qylpSV27dqFw4cPi5/vmpoajB07FoGBgZg7dy7mzp0LiUSis15MTAymTJmCnJwclJeX49KlSxgzZgxmzJiBJUuW6PxxMXnyZOTn52PXrl2oqqpCfX09rK2t4erqildffRXR0dEoKirChx9+iKKiInzwwQd99veg1atXIzAwELm5uaioqEBNTQ1GjRqFSZMm4fXXX0dMTIzB16G8vBz37t3DhAkTMGnSJKNfKyKiocSUfCVMZwPQp3vYgx6sG+rv74+CggJkZ2ejqKgIjY2NsLKygre3N2bNmoWYmBi99ZOYr5ivmK+Yr2hokHQLbTGIRgChCOU333zz2K6YDQY//PADkpOT4eLi0udW4JHK3J+FtrY2BAUF4d69e1AoFHq7Hj0uBw8exJYtWyCTyZCdnf3EjoPuS0pKwsmTJ/H555+bFLSJiIYC5ivmKwHzFT1OzFfDF2tUERGZwVNPPYXo6GhoNBq9RTjNRa1WIzAwEIsWLTJYXLS4uBgAeGVpkGhpacGvv/4KNzc3hIaGPunDISIiGjKYr8gQ5qvhjQNVRERmEhMTA0dHR+Tm5uoUgzQnGxsbjB8/HpWVlZDL5bhz5464TK1WIy0tDcXFxRg9ejTCw8MH5BjINDk5OdBqtVizZo3Z6loQERGNFMxXpA/z1fDGGlVEI0hLS4tYKDM8PNxgjazhKj09XbwaNhDGjh2LTz75BImJiThw4ACWLl06IPv56KOPEBsbixMnTuD06dNwdXWFhYUFGhoa8O+//8LGxgYpKSliW2d6cpqamrBv3z7MnDnT6PbSREQ0tDBfMV/R48V8NfxxoIpoBNFqtWKhzJFUQ0KgVCr7FAo1t1mzZiE0NBTp6el488034eDgYPZ9+Pv7o7CwEDk5OSgpKcG1a9fQ0dEBZ2dnhIWFISoqCs8995zZ90umS01Nha2trU67ZiIiGl6Yr5iv6PFivhr+WEydiIiIiIiIiIgGBdaoIiIiIiIiIiKiQYEDVURERERERERENChwoIqIiIiIiIiIiAYFDlQREREREREREdGgwIEqIiIiIiIiIiIaFDhQRUREREREREREgwIHqoiIiIiIiIiIaFDgQBUREREREREREQ0KHKgiIiIiIiIiIqJB4f8dhHtsLJil5AAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -2339,7 +2235,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 47, "metadata": { "ExecuteTime": { "end_time": "2023-08-03T12:00:06.079414Z", @@ -2367,12 +2263,13 @@ "ExecuteTime": { "end_time": "2023-08-03T12:00:12.112044Z", "start_time": "2023-08-03T12:00:06.099744Z" - } + }, + "scrolled": true }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2428,35 +2325,35 @@ " 45\n", " v_half\n", " None\n", - " 0.472143\n", + " 0.471587\n", " \n", " \n", " 46\n", " 46\n", " v_half\n", " None\n", - " 0.472143\n", + " 0.471587\n", " \n", " \n", " 47\n", " 47\n", " v_half\n", " None\n", - " 0.472143\n", + " 0.471587\n", " \n", " \n", " 48\n", " 48\n", " v_half\n", " None\n", - " 0.467659\n", + " 0.467530\n", " \n", " \n", " 49\n", " 49\n", " v_half\n", " None\n", - " 0.472143\n", + " 0.471587\n", " \n", " \n", "\n", @@ -2464,11 +2361,11 @@ ], "text/plain": [ " metric param param2 si\n", - "45 45 v_half None 0.472143\n", - "46 46 v_half None 0.472143\n", - "47 47 v_half None 0.472143\n", - "48 48 v_half None 0.467659\n", - "49 49 v_half None 0.472143" + "45 45 v_half None 0.471587\n", + "46 46 v_half None 0.471587\n", + "47 47 v_half None 0.471587\n", + "48 48 v_half None 0.467530\n", + "49 49 v_half None 0.471587" ] }, "execution_count": 49, @@ -2484,7 +2381,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## CalcCostBenefit" + "\n", + "## CalcDeltaImpact\n" ] }, { @@ -2496,410 +2394,2266 @@ } }, "source": [ - "The uncertainty and sensitivity analysis for CostBenefit is completely analogous to the Impact case. It is slightly more complex as there are more input variables." + "The main goal of this class is to perform an uncertainty and sensitivity analysis of the \"delta\" impact between a reference state and future (or any other \"to be compared\") state.\n", + "\n", + "Classical example: risk increase in the future with climate change and socio economic development. In this case, the uncertainty and sensitivity analysis in performed on the estimated risk (delta) increase in the future relative to the present-day baseline.\n", + "\n", + "The uncertainty and sensitivity analysis for CalcDeltaImpact is completely analogous to the Impact case. It is slightly more complex as there are more input variables.\n", + "\n", + "Note, the logic of this class works with any comparison between an initial (reference and final (altered) risk or impact state and is not limited to the scope of climate change and socio-economic development in the future." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Set the Input Vars\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Set the Input Vars " + "We'll work through an analogous example as in CalcImpact next." ] }, { "cell_type": "code", "execution_count": 50, - "metadata": { - "ExecuteTime": { - "end_time": "2023-08-03T12:00:12.180767Z", - "start_time": "2023-08-03T12:00:12.138310Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-03 14:00:12,145 - climada.hazard.base - INFO - Reading /Users/ckropf/climada/demo/data/tc_fl_1990_2004.h5\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ - "import copy\n", - "from climada.util.constants import ENT_DEMO_TODAY, ENT_DEMO_FUTURE, HAZ_DEMO_H5\n", - "from climada.entity import Entity\n", - "from climada.hazard import Hazard\n", + "import numpy as np\n", "\n", - "# Entity today has an uncertainty in the total asset value\n", - "def ent_today_func(x_ent):\n", - " #In-function imports needed only for parallel computing on Windows\n", - " from climada.entity import Entity \n", - " from climada.util.constants import ENT_DEMO_TODAY \n", - " entity = Entity.from_excel(ENT_DEMO_TODAY)\n", - " entity.exposures.ref_year = 2018\n", - " entity.exposures.gdf.value *= x_ent\n", - " return entity\n", + "from climada.entity import ImpactFunc, ImpactFuncSet, Exposures\n", + "from climada.util.constants import EXP_DEMO_H5, HAZ_DEMO_H5\n", + "from climada.hazard import Centroids, TCTracks, Hazard, TropCyclone\n", "\n", - "# Entity in the future has a +- 10% uncertainty in the cost of all the adapatation measures\n", - "def ent_fut_func(m_fut_cost):\n", - " #In-function imports needed only for parallel computing on Windows\n", - " from climada.entity import Entity \n", - " from climada.util.constants import ENT_DEMO_FUTURE \n", - " entity = Entity.from_excel(ENT_DEMO_FUTURE)\n", - " entity.exposures.ref_year = 2040 \n", - " for meas in entity.measures.get_measure('TC'):\n", - " meas.cost *= m_fut_cost\n", - " return entity\n", + "def impf_func(G=1, v_half=84.7, vmin=25.7, k=3, _id=1):\n", + " \n", + " def xhi(v, v_half, vmin):\n", + " return max([(v - vmin), 0]) / (v_half - vmin)\n", + "\n", + " def sigmoid_func(v, G, v_half, vmin, k):\n", + " return G * xhi(v, v_half, vmin)**k / (1 + xhi(v, v_half, vmin)**k)\n", "\n", - "haz_base = Hazard.from_hdf5(HAZ_DEMO_H5)\n", - "# The hazard intensity in the future is also uncertainty by a multiplicative factor\n", - "def haz_fut(x_haz_fut, haz_base):\n", " #In-function imports needed only for parallel computing on Windows\n", - " import copy \n", - " from climada.hazard import Hazard \n", - " from climada.util.constants import HAZ_DEMO_H5 \n", - " haz = copy.deepcopy(haz_base)\n", - " haz.intensity = haz.intensity.multiply(x_haz_fut)\n", - " return haz\n", - "from functools import partial\n", - "haz_fut_func = partial(haz_fut, haz_base=haz_base)\n" + " intensity_unit = 'm/s'\n", + " intensity = np.linspace(0, 150, num=100)\n", + " mdd = np.repeat(1, len(intensity))\n", + " paa = np.array([sigmoid_func(v, G, v_half, vmin, k) for v in intensity])\n", + " imp_fun = ImpactFunc(\"TC\", _id, intensity, mdd, paa, intensity_unit)\n", + " imp_fun.check()\n", + " impf_set = ImpactFuncSet([imp_fun])\n", + " return impf_set" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Check that costs for measures are changed as desired." + "Load the hazard set and apply climate change factors to it. This yields a hazard representation in 2050 under 4 RCP scenarios. For a full documentation of this function please refer to the [TropCyclone](climada_hazard_TropCyclone.ipynb) tutorial." ] }, { "cell_type": "code", "execution_count": 51, - "metadata": { - "ExecuteTime": { - "end_time": "2023-08-03T12:00:12.789398Z", - "start_time": "2023-08-03T12:00:12.184147Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "The cost for m_fut_cost=1 are [1311768360.8515418, 1728000000.0, 8878779433.630093, 9200000000.0]\n", - "The cost for m_fut_cost=0.5 are [655884180.4257709, 864000000.0, 4439389716.815046, 4600000000.0]\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ - "costs_1 = [meas.cost for meas in ent_fut_func(1).measures.get_measure('TC')]\n", - "costs_05 = [meas.cost for meas in ent_fut_func(0.5).measures.get_measure('TC')]\n", - "print(f\"\\nThe cost for m_fut_cost=1 are {costs_1}\\n\"\n", - " f\"The cost for m_fut_cost=0.5 are {costs_05}\");" + "# load historical hazard set\n", + "haz = TropCyclone.from_hdf5(HAZ_DEMO_H5)\n", + "haz.basin = [\"NA\"] * haz.size\n", + "\n", + "# apply climate change factors\n", + "haz_26 = haz.apply_climate_scenario_knu(ref_year=2050, rcp_scenario=26)\n", + "haz_45 = haz.apply_climate_scenario_knu(ref_year=2050, rcp_scenario=45)\n", + "haz_60 = haz.apply_climate_scenario_knu(ref_year=2050, rcp_scenario=60)\n", + "haz_85 = haz.apply_climate_scenario_knu(ref_year=2050, rcp_scenario=85)\n", + "\n", + "# pack future hazard sets into dictionary - we want to sample from this dictionary later\n", + "haz_fut_list = [haz_26, haz_45, haz_60, haz_85]\n", + "tc_haz_fut_dict = {}\n", + "for r, rcp in enumerate(['26', '45', '60', '85']):\n", + " tc_haz_fut_dict[rcp] = haz_fut_list[r]" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 52, "metadata": {}, + "outputs": [], "source": [ - "Define the InputVars" + "exp_base = Exposures.from_hdf5(EXP_DEMO_H5)\n", + "#It is a good idea to assign the centroids to the base exposures in order to avoid repeating this\n", + "# potentially costly operation for each sample.\n", + "exp_base.assign_centroids(haz) \n", + "def exp_base_func(x_exp, exp_base):\n", + " exp = exp_base.copy()\n", + " exp.gdf.value *= x_exp\n", + " return exp\n", + "from functools import partial\n", + "exp_func = partial(exp_base_func, exp_base=exp_base)" ] }, { "cell_type": "code", - "execution_count": 52, - "metadata": { - "ExecuteTime": { - "end_time": "2023-08-03T12:00:12.802267Z", - "start_time": "2023-08-03T12:00:12.793743Z" - } - }, + "execution_count": 53, + "metadata": {}, "outputs": [], "source": [ "import scipy as sp\n", "from climada.engine.unsequa import InputVar\n", "\n", - "haz_today = haz_base\n", - "\n", - "haz_fut_distr = {\"x_haz_fut\": sp.stats.uniform(1, 3),\n", - " }\n", - "haz_fut_iv = InputVar(haz_fut_func, haz_fut_distr)\n", - "\n", - "ent_today_distr = {\"x_ent\": sp.stats.uniform(0.7, 1)}\n", - "ent_today_iv = InputVar(ent_today_func, ent_today_distr)\n", + "exp_distr = {\"x_exp\": sp.stats.beta(10, 1.1)} #This is not really a reasonable distribution but is used \n", + " #here to show that you can use any scipy distribution.\n", + " \n", + "exp_iv = InputVar(exp_func, exp_distr)\n", "\n", - "ent_fut_distr = {\"m_fut_cost\": sp.stats.norm(1, 0.1)}\n", - "ent_fut_iv = InputVar(ent_fut_func, ent_fut_distr)" + "impf_distr = {\n", + " \"G\": sp.stats.truncnorm(0.5, 1.5),\n", + " \"v_half\": sp.stats.uniform(35, 65),\n", + " \"vmin\": sp.stats.uniform(0, 15),\n", + " \"k\": sp.stats.uniform(1, 4)\n", + " }\n", + "impf_iv = InputVar(impf_func, impf_distr)" ] }, { - "cell_type": "code", - "execution_count": 53, - "metadata": { - "ExecuteTime": { - "end_time": "2023-08-03T12:00:12.959984Z", - "start_time": "2023-08-03T12:00:12.804842Z" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
latitudelongitudevaluedeductiblecoverimpf_TCValue_2010
026.933899-80.1287991.671301e+1001.392750e+1015.139301e+09
126.957203-80.0982841.511528e+1001.259606e+1014.647994e+09
226.783846-80.7489471.511528e+1001.259606e+1014.647994e+09
326.645524-80.5507041.511528e+1001.259606e+1014.647994e+09
426.897796-80.5969291.511528e+1001.259606e+1014.647994e+09
\n", - "
" - ], - "text/plain": [ - " latitude longitude value deductible cover impf_TC \n", - "0 26.933899 -80.128799 1.671301e+10 0 1.392750e+10 1 \\\n", - "1 26.957203 -80.098284 1.511528e+10 0 1.259606e+10 1 \n", - "2 26.783846 -80.748947 1.511528e+10 0 1.259606e+10 1 \n", - "3 26.645524 -80.550704 1.511528e+10 0 1.259606e+10 1 \n", - "4 26.897796 -80.596929 1.511528e+10 0 1.259606e+10 1 \n", - "\n", - " Value_2010 \n", - "0 5.139301e+09 \n", - "1 4.647994e+09 \n", - "2 4.647994e+09 \n", - "3 4.647994e+09 \n", - "4 4.647994e+09 " - ] - }, - "execution_count": 53, - "metadata": {}, - "output_type": "execute_result" - } - ], + "cell_type": "markdown", + "metadata": {}, "source": [ - "ent_avg = ent_today_iv.evaluate()\n", - "ent_avg.exposures.gdf.head()" + "Next we define the function for the future hazard representation. It's a simple function that allows us to draw from the hazard dictionary of hazard sets under different RCP scenarios. Note, we do not investigate other hazard related uncertainties in this example." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "rcp_key = {0: '26',\n", + " 1: '45',\n", + " 2: '60',\n", + " 3: '85'}\n", + "\n", + "# future\n", + "def haz_fut_func(rcp_scenario):\n", + " haz_fut = tc_haz_fut_dict[rcp_key[rcp_scenario]]\n", + " return haz_fut\n", + "\n", + "haz_fut_distr = {\"rcp_scenario\": sp.stats.randint(0, 4)}\n", + "\n", + "haz_fut_iv = InputVar(haz_fut_func, haz_fut_distr)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Compute cost benefit uncertainty and sensitivity using default methods " + "\n", + "### Compute uncertainty and sensitivity\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "For examples of how to use non-defaults please see the [impact example](###Compute-uncertainty-and-sensitivity-using-default-methods )" + "In contrast to CalcImpact, we define InputVars for initial and final states of exposure, impact function, hazard. This class requires 6 input variables. For the sake of simplicity, we did not define varying input variables for the initial and future exposure and vulernability in the example. Hence, the exp_iv and impf_iv are passed to CalcDeltaImpact twice." ] }, { "cell_type": "code", - "execution_count": 54, - "metadata": { - "ExecuteTime": { - "end_time": "2023-08-03T12:00:13.085529Z", - "start_time": "2023-08-03T12:00:12.963156Z" + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-01-25 15:36:53,385 - climada.engine.unsequa.calc_base - WARNING - \n", + "\n", + "The input parameter x_exp is shared among at least 2 input variables. Their uncertainty is thus computed with the same samples for this input paramter.\n", + "\n", + "\n", + "2024-01-25 15:36:53,389 - climada.engine.unsequa.calc_base - WARNING - \n", + "\n", + "The input parameter G is shared among at least 2 input variables. Their uncertainty is thus computed with the same samples for this input paramter.\n", + "\n", + "\n", + "2024-01-25 15:36:53,390 - climada.engine.unsequa.calc_base - WARNING - \n", + "\n", + "The input parameter v_half is shared among at least 2 input variables. Their uncertainty is thus computed with the same samples for this input paramter.\n", + "\n", + "\n", + "2024-01-25 15:36:53,393 - climada.engine.unsequa.calc_base - WARNING - \n", + "\n", + "The input parameter vmin is shared among at least 2 input variables. Their uncertainty is thus computed with the same samples for this input paramter.\n", + "\n", + "\n", + "2024-01-25 15:36:53,394 - climada.engine.unsequa.calc_base - WARNING - \n", + "\n", + "The input parameter k is shared among at least 2 input variables. Their uncertainty is thus computed with the same samples for this input paramter.\n", + "\n", + "\n" + ] } - }, + ], + "source": [ + "from climada.engine.unsequa import CalcDeltaImpact\n", + "calc_imp = CalcDeltaImpact(exp_iv, impf_iv, haz, \n", + " exp_iv, impf_iv, haz_fut_iv)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, "outputs": [], "source": [ - "from climada.engine.unsequa import CalcCostBenefit\n", + "output_imp = calc_imp.make_sample(N=2**7)\n", + "output_imp.get_samples_df().tail()\n", "\n", - "unc_cb = CalcCostBenefit(haz_input_var=haz_today, ent_input_var=ent_today_iv,\n", - " haz_fut_input_var=haz_fut_iv, ent_fut_input_var=ent_fut_iv)" + "output_imp = calc_imp.uncertainty(output_imp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plotting functionalities work analogous to CalcImpact. By setting `calc_delta=True`, the axis labels are adjusted." ] }, { "cell_type": "code", - "execution_count": 55, - "metadata": { - "ExecuteTime": { - "end_time": "2023-08-03T12:00:13.121927Z", - "start_time": "2023-08-03T12:00:13.087709Z" + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No data to plot for 'rp5'.\n", + "No data to plot for 'rp10'.\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[,\n", + " ],\n", + " [,\n", + " ],\n", + " [,\n", + " ],\n", + " [,\n", + " ]], dtype=object)" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } - }, + ], + "source": [ + "from climada.engine.unsequa import UncOutput\n", + "output_imp.plot_uncertainty(calc_delta=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "2023-08-03 14:00:13,114 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 50\n" + "Skipping plot for 'rp5': insufficient data.\n", + "Skipping plot for 'rp10': insufficient data.\n" + ] + }, + { + "data": { + "text/plain": [ + "array([,\n", + " ],\n", + " dtype=object)" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from climada.engine.unsequa import UncOutput\n", + "output_imp.plot_rp_uncertainty(calc_delta=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "# compute sensitivity\n", + "output_imp = calc_imp.sensitivity(output_imp)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2024-01-25 15:37:27,753 - climada.engine.unsequa.unc_output - WARNING - All-NaN columns encountered: ['rp5', 'rp10']\n" + ] + }, + { + "data": { + "text/plain": [ + "array([,\n", + " ], dtype=object)" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot sensitivity\n", + "output_imp.plot_sensitivity()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The rest of the functionalities that apply to CalcImpact also work for the CalcDeltaImpact class. Hence, refer to the sections above for details." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## CalcCostBenefit\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2021-09-23T14:32:01.173184Z", + "start_time": "2021-09-23T14:32:01.169411Z" + } + }, + "source": [ + "The uncertainty and sensitivity analysis for CostBenefit is completely analogous to the Impact case. It is slightly more complex as there are more input variables." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Set the Input Vars\n" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T12:00:12.180767Z", + "start_time": "2023-08-03T12:00:12.138310Z" + } + }, + "outputs": [], + "source": [ + "import copy\n", + "from climada.util.constants import ENT_DEMO_TODAY, ENT_DEMO_FUTURE, HAZ_DEMO_H5\n", + "from climada.entity import Entity\n", + "from climada.hazard import Hazard\n", + "\n", + "# Entity today has an uncertainty in the total asset value\n", + "def ent_today_func(x_ent):\n", + " #In-function imports needed only for parallel computing on Windows\n", + " from climada.entity import Entity \n", + " from climada.util.constants import ENT_DEMO_TODAY \n", + " entity = Entity.from_excel(ENT_DEMO_TODAY)\n", + " entity.exposures.ref_year = 2018\n", + " entity.exposures.gdf.value *= x_ent\n", + " return entity\n", + "\n", + "# Entity in the future has a +- 10% uncertainty in the cost of all the adapatation measures\n", + "def ent_fut_func(m_fut_cost):\n", + " #In-function imports needed only for parallel computing on Windows\n", + " from climada.entity import Entity \n", + " from climada.util.constants import ENT_DEMO_FUTURE \n", + " entity = Entity.from_excel(ENT_DEMO_FUTURE)\n", + " entity.exposures.ref_year = 2040 \n", + " for meas in entity.measures.get_measure('TC'):\n", + " meas.cost *= m_fut_cost\n", + " return entity\n", + "\n", + "haz_base = Hazard.from_hdf5(HAZ_DEMO_H5)\n", + "# The hazard intensity in the future is also uncertainty by a multiplicative factor\n", + "def haz_fut(x_haz_fut, haz_base):\n", + " #In-function imports needed only for parallel computing on Windows\n", + " import copy \n", + " from climada.hazard import Hazard \n", + " from climada.util.constants import HAZ_DEMO_H5 \n", + " haz = copy.deepcopy(haz_base)\n", + " haz.intensity = haz.intensity.multiply(x_haz_fut)\n", + " return haz\n", + "from functools import partial\n", + "haz_fut_func = partial(haz_fut, haz_base=haz_base)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check that costs for measures are changed as desired." + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T12:00:12.789398Z", + "start_time": "2023-08-03T12:00:12.184147Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "The cost for m_fut_cost=1 are [1311768360.8515418, 1728000000.0, 8878779433.630093, 9200000000.0]\n", + "The cost for m_fut_cost=0.5 are [655884180.4257709, 864000000.0, 4439389716.815046, 4600000000.0]\n" + ] + } + ], + "source": [ + "costs_1 = [meas.cost for meas in ent_fut_func(1).measures.get_measure('TC')]\n", + "costs_05 = [meas.cost for meas in ent_fut_func(0.5).measures.get_measure('TC')]\n", + "print(f\"\\nThe cost for m_fut_cost=1 are {costs_1}\\n\"\n", + " f\"The cost for m_fut_cost=0.5 are {costs_05}\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the InputVars" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T12:00:12.802267Z", + "start_time": "2023-08-03T12:00:12.793743Z" + } + }, + "outputs": [], + "source": [ + "import scipy as sp\n", + "from climada.engine.unsequa import InputVar\n", + "\n", + "haz_today = haz_base\n", + "\n", + "haz_fut_distr = {\"x_haz_fut\": sp.stats.uniform(1, 3),\n", + " }\n", + "haz_fut_iv = InputVar(haz_fut_func, haz_fut_distr)\n", + "\n", + "ent_today_distr = {\"x_ent\": sp.stats.uniform(0.7, 1)}\n", + "ent_today_iv = InputVar(ent_today_func, ent_today_distr)\n", + "\n", + "ent_fut_distr = {\"m_fut_cost\": sp.stats.norm(1, 0.1)}\n", + "ent_fut_iv = InputVar(ent_fut_func, ent_fut_distr)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T12:00:12.959984Z", + "start_time": "2023-08-03T12:00:12.804842Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
latitudelongitudevaluedeductiblecoverimpf_TCValue_2010
026.933899-80.1287991.671301e+1001.392750e+1015.139301e+09
126.957203-80.0982841.511528e+1001.259606e+1014.647994e+09
226.783846-80.7489471.511528e+1001.259606e+1014.647994e+09
326.645524-80.5507041.511528e+1001.259606e+1014.647994e+09
426.897796-80.5969291.511528e+1001.259606e+1014.647994e+09
\n", + "
" + ], + "text/plain": [ + " latitude longitude value deductible cover impf_TC \\\n", + "0 26.933899 -80.128799 1.671301e+10 0 1.392750e+10 1 \n", + "1 26.957203 -80.098284 1.511528e+10 0 1.259606e+10 1 \n", + "2 26.783846 -80.748947 1.511528e+10 0 1.259606e+10 1 \n", + "3 26.645524 -80.550704 1.511528e+10 0 1.259606e+10 1 \n", + "4 26.897796 -80.596929 1.511528e+10 0 1.259606e+10 1 \n", + "\n", + " Value_2010 \n", + "0 5.139301e+09 \n", + "1 4.647994e+09 \n", + "2 4.647994e+09 \n", + "3 4.647994e+09 \n", + "4 4.647994e+09 " + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ent_avg = ent_today_iv.evaluate()\n", + "ent_avg.exposures.gdf.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Compute cost benefit uncertainty and sensitivity using default methods\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For examples of how to use non-defaults please see the [impact example](###Compute-uncertainty-and-sensitivity-using-default-methods )" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T12:00:13.085529Z", + "start_time": "2023-08-03T12:00:12.963156Z" + } + }, + "outputs": [], + "source": [ + "from climada.engine.unsequa import CalcCostBenefit\n", + "\n", + "unc_cb = CalcCostBenefit(haz_input_var=haz_today, ent_input_var=ent_today_iv,\n", + " haz_fut_input_var=haz_fut_iv, ent_fut_input_var=ent_fut_iv)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T12:00:13.121927Z", + "start_time": "2023-08-03T12:00:13.087709Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x_entx_haz_futm_fut_cost
451.356252.968750.813727
461.043752.968750.813727
471.356252.031250.813727
481.356252.968750.899001
491.043752.031250.899001
\n", + "
" + ], + "text/plain": [ + " x_ent x_haz_fut m_fut_cost\n", + "45 1.35625 2.96875 0.813727\n", + "46 1.04375 2.96875 0.813727\n", + "47 1.35625 2.03125 0.813727\n", + "48 1.35625 2.96875 0.899001\n", + "49 1.04375 2.03125 0.899001" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "output_cb= unc_cb.make_sample(N=10, sampling_kwargs={'calc_second_order':False})\n", + "output_cb.get_samples_df().tail()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For longer computations, it is possible to use a pool for parallel computation." + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T12:00:33.857265Z", + "start_time": "2023-08-03T12:00:13.124046Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.30148 13.8606 10.6498\n", + "Beach nourishment 1.71445 10.7904 6.29377\n", + "Seawall 8.80916 0.175596 0.0199334\n", + "Building code 9.12786 29.4038 3.22132\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 117.615 (USD bn)\n", + "Average annual risk: 13.6166 (USD bn)\n", + "Residual risk: 63.3848 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.30148 13.8606 10.6498\n", + "Beach nourishment 1.71445 10.7904 6.29377\n", + "Seawall 8.80916 0.175596 0.0199334\n", + "Building code 9.12786 29.4038 3.22132\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 117.615 (USD bn)\n", + "Average annual risk: 13.6166 (USD bn)\n", + "Residual risk: 63.3848 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.30148 14.0781 10.817\n", + "Beach nourishment 1.71445 10.968 6.39739\n", + "Seawall 8.80916 0.175596 0.0199334\n", + "Building code 9.12786 29.5124 3.23322\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 118.05 (USD bn)\n", + "Average annual risk: 13.6166 (USD bn)\n", + "Residual risk: 63.3155 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.30148 14.1012 10.8347\n", + "Beach nourishment 1.71445 10.9632 6.39461\n", + "Seawall 8.80916 0.0376243 0.00427104\n", + "Building code 9.12786 13.3845 1.46633\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 53.5379 (USD bn)\n", + "Average annual risk: 6.15933 (USD bn)\n", + "Residual risk: 15.0513 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.55612 13.8606 8.90716\n", + "Beach nourishment 2.04988 10.7904 5.2639\n", + "Seawall 10.5327 0.175596 0.0166716\n", + "Building code 10.9137 29.4038 2.69421\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 117.615 (USD bn)\n", + "Average annual risk: 13.6166 (USD bn)\n", + "Residual risk: 63.3848 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.55612 14.3188 9.20163\n", + "Beach nourishment 2.04988 11.1409 5.4349\n", + "Seawall 10.5327 0.0376243 0.00357216\n", + "Building code 10.9137 13.4931 1.23634\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 53.9724 (USD bn)\n", + "Average annual risk: 6.15933 (USD bn)\n", + "Residual risk: 14.982 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.55612 6.59956 4.24104\n", + "Beach nourishment 2.04988 5.16368 2.51902\n", + "Seawall 10.5327 3.55475 0.337498\n", + "Building code 10.9137 48.016 4.3996\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 192.064 (USD bn)\n", + "Average annual risk: 22.2359 (USD bn)\n", + "Residual risk: 128.73 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.55612 6.43034 4.1323\n", + "Beach nourishment 2.04988 5.02552 2.45161\n", + "Seawall 10.5327 3.55475 0.337498\n", + "Building code 10.9137 47.9315 4.39186\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 191.726 (USD bn)\n", + "Average annual risk: 22.2359 (USD bn)\n", + "Residual risk: 128.784 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.55612 7.59067 4.87796\n", + "Beach nourishment 2.04988 5.96389 2.90939\n", + "Seawall 10.5327 1.31269 0.12463\n", + "Building code 10.9137 43.2513 3.96302\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 173.005 (USD bn)\n", + "Average annual risk: 20.0179 (USD bn)\n", + "Residual risk: 114.887 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.30148 6.59956 5.0708\n", + "Beach nourishment 1.71445 5.16368 3.01186\n", + "Seawall 8.80916 3.55475 0.403528\n", + "Building code 9.12786 48.016 5.26038\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 192.064 (USD bn)\n", + "Average annual risk: 22.2359 (USD bn)\n", + "Residual risk: 128.73 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.30148 7.42146 5.70231\n", + "Beach nourishment 1.71445 5.82573 3.39801\n", + "Seawall 8.80916 1.31269 0.149014\n", + "Building code 9.12786 43.1668 4.72913\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 172.667 (USD bn)\n", + "Average annual risk: 20.0179 (USD bn)\n", + "Residual risk: 114.941 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.20992 10.5404 8.71168\n", + "Beach nourishment 1.59383 8.59532 5.39285\n", + "Seawall 8.18941 0.0184996 0.00225897\n", + "Building code 8.48569 7.53759 0.88827\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 30.1504 (USD bn)\n", + "Average annual risk: 3.37008 (USD bn)\n", + "Residual risk: 3.45852 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.20992 10.5646 8.73166\n", + "Beach nourishment 1.59383 8.61505 5.40524\n", + "Seawall 8.18941 0.0184996 0.00225897\n", + "Building code 8.48569 7.54966 0.889693\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 30.1986 (USD bn)\n", + "Average annual risk: 3.37008 (USD bn)\n", + "Residual risk: 3.45082 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.20992 12.8863 10.6505\n", + "Beach nourishment 1.59383 9.98362 6.2639\n", + "Seawall 8.18941 0.257712 0.0314689\n", + "Building code 8.48569 33.7244 3.97427\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 134.898 (USD bn)\n", + "Average annual risk: 15.5605 (USD bn)\n", + "Residual risk: 78.0457 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.20992 10.5404 8.71168\n", + "Beach nourishment 1.59383 8.59532 5.39285\n", + "Seawall 8.18941 0.0184996 0.00225897\n", + "Building code 8.48569 7.53759 0.88827\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 30.1504 (USD bn)\n", + "Average annual risk: 3.37008 (USD bn)\n", + "Residual risk: 3.45852 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.20992 12.9104 10.6705\n", + "Beach nourishment 1.59383 10.0034 6.27629\n", + "Seawall 8.18941 0.257712 0.0314689\n", + "Building code 8.48569 33.7365 3.97569\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 134.946 (USD bn)\n", + "Average annual risk: 15.5605 (USD bn)\n", + "Residual risk: 78.038 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.38774 8.44955 6.08873\n", + "Beach nourishment 1.82807 6.4567 3.53197\n", + "Seawall 9.39298 0.895618 0.0953497\n", + "Building code 9.7328 41.407 4.25438\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 165.628 (USD bn)\n", + "Average annual risk: 19.1818 (USD bn)\n", + "Residual risk: 108.419 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.38774 8.47373 6.10615\n", + "Beach nourishment 1.82807 6.47644 3.54276\n", + "Seawall 9.39298 0.895618 0.0953497\n", + "Building code 9.7328 41.4191 4.25562\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 165.676 (USD bn)\n", + "Average annual risk: 19.1818 (USD bn)\n", + "Residual risk: 108.411 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.38774 1.39186 1.00297\n", + "Beach nourishment 1.82807 1.13491 0.62082\n", + "Seawall 9.39298 0.000227424 2.42121e-05\n", + "Building code 9.7328 0.76062 0.0781501\n", + "\n", + "-------------------- --------- --------\n", + "Total climate risk: 3.04248 (USD bn)\n", + "Average annual risk: 0.260244 (USD bn)\n", + "Residual risk: -0.245137 (USD bn)\n", + "-------------------- --------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.38774 8.44955 6.08873\n", + "Beach nourishment 1.82807 6.4567 3.53197\n", + "Seawall 9.39298 0.895618 0.0953497\n", + "Building code 9.7328 41.407 4.25438\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 165.628 (USD bn)\n", + "Average annual risk: 19.1818 (USD bn)\n", + "Residual risk: 108.419 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.38774 1.41604 1.02039\n", + "Beach nourishment 1.82807 1.15464 0.631618\n", + "Seawall 9.39298 0.000227424 2.42121e-05\n", + "Building code 9.7328 0.77269 0.0793903\n", + "\n", + "-------------------- --------- --------\n", + "Total climate risk: 3.09076 (USD bn)\n", + "Average annual risk: 0.260244 (USD bn)\n", + "Residual risk: -0.252837 (USD bn)\n", + "-------------------- --------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.44426 2.77518 1.92153\n", + "Beach nourishment 1.90253 2.24443 1.17971\n", + "Seawall 9.77553 0.00264385 0.000270456\n", + "Building code 10.1292 1.68273 0.166127\n", + "\n", + "-------------------- --------- --------\n", + "Total climate risk: 6.73092 (USD bn)\n", + "Average annual risk: 0.678263 (USD bn)\n", + "Residual risk: 0.0259328 (USD bn)\n", + "-------------------- --------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.44426 2.70266 1.87132\n", + "Beach nourishment 1.90253 2.18521 1.14859\n", + "Seawall 9.77553 0.00264385 0.000270456\n", + "Building code 10.1292 1.64652 0.162552\n", + "\n", + "-------------------- --------- --------\n", + "Total climate risk: 6.58607 (USD bn)\n", + "Average annual risk: 0.678263 (USD bn)\n", + "Residual risk: 0.0490347 (USD bn)\n", + "-------------------- --------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.44426 5.43516 3.76329\n", + "Beach nourishment 1.90253 4.37024 2.29707\n", + "Seawall 9.77553 0.00764219 0.000781768\n", + "Building code 10.1292 3.61055 0.35645\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 14.4422 (USD bn)\n", + "Average annual risk: 1.57569 (USD bn)\n", + "Residual risk: 1.0186 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.44426 2.77518 1.92153\n", + "Beach nourishment 1.90253 2.24443 1.17971\n", + "Seawall 9.77553 0.00264385 0.000270456\n", + "Building code 10.1292 1.68273 0.166127\n", + "\n", + "-------------------- --------- --------\n", + "Total climate risk: 6.73092 (USD bn)\n", + "Average annual risk: 0.678263 (USD bn)\n", + "Residual risk: 0.0259328 (USD bn)\n", + "-------------------- --------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.44426 5.36264 3.71308\n", + "Beach nourishment 1.90253 4.31103 2.26595\n", + "Seawall 9.77553 0.00764219 0.000781768\n", + "Building code 10.1292 3.57434 0.352875\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 14.2973 (USD bn)\n", + "Average annual risk: 1.57569 (USD bn)\n", + "Residual risk: 1.0417 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.259 10.4834 8.32677\n", + "Beach nourishment 1.65849 8.23954 4.96809\n", + "Seawall 8.52163 0.415328 0.0487381\n", + "Building code 8.82993 36.8908 4.17793\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 147.563 (USD bn)\n", + "Average annual risk: 17.0232 (USD bn)\n", + "Residual risk: 91.5342 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.259 10.4109 8.26917\n", + "Beach nourishment 1.65849 8.18032 4.93239\n", + "Seawall 8.52163 0.415328 0.0487381\n", + "Building code 8.82993 36.8546 4.17383\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 147.418 (USD bn)\n", + "Average annual risk: 17.0232 (USD bn)\n", + "Residual risk: 91.5573 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.259 8.79133 6.98278\n", + "Beach nourishment 1.65849 6.82168 4.11319\n", + "Seawall 8.52163 0.621468 0.0729283\n", + "Building code 8.82993 39.3223 4.45329\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 157.289 (USD bn)\n", + "Average annual risk: 18.1551 (USD bn)\n", + "Residual risk: 101.732 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.259 10.4834 8.32677\n", + "Beach nourishment 1.65849 8.23954 4.96809\n", + "Seawall 8.52163 0.415328 0.0487381\n", + "Building code 8.82993 36.8908 4.17793\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 147.563 (USD bn)\n", + "Average annual risk: 17.0232 (USD bn)\n", + "Residual risk: 91.5342 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.259 8.71881 6.92518\n", + "Beach nourishment 1.65849 6.76247 4.07748\n", + "Seawall 8.52163 0.621468 0.0729283\n", + "Building code 8.82993 39.286 4.44919\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 157.144 (USD bn)\n", + "Average annual risk: 18.1551 (USD bn)\n", + "Residual risk: 101.755 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.34288 14.575 10.8535\n", + "Beach nourishment 1.76899 11.5436 6.52553\n", + "Seawall 9.08939 0.0620626 0.00682803\n", + "Building code 9.41823 19.0306 2.02062\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 76.1225 (USD bn)\n", + "Average annual risk: 8.73152 (USD bn)\n", + "Residual risk: 30.9112 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.34288 14.3091 10.6555\n", + "Beach nourishment 1.76899 11.3265 6.40279\n", + "Seawall 9.08939 0.0620626 0.00682803\n", + "Building code 9.41823 18.8979 2.00652\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 75.5914 (USD bn)\n", + "Average annual risk: 8.73152 (USD bn)\n", + "Residual risk: 30.9959 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.34288 7.41063 5.51844\n", + "Beach nourishment 1.76899 5.87997 3.32392\n", + "Seawall 9.08939 2.58858 0.284791\n", + "Building code 9.41823 46.6706 4.95535\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 186.682 (USD bn)\n", + "Average annual risk: 21.5984 (USD bn)\n", + "Residual risk: 124.133 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.13888 14.575 12.7977\n", + "Beach nourishment 1.50025 11.5436 7.69445\n", + "Seawall 7.70855 0.0620626 0.00805114\n", + "Building code 7.98743 19.0306 2.38257\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 76.1225 (USD bn)\n", + "Average annual risk: 8.73152 (USD bn)\n", + "Residual risk: 30.9112 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.13888 7.14472 6.27348\n", + "Beach nourishment 1.50025 5.66285 3.77461\n", + "Seawall 7.70855 2.58858 0.335806\n", + "Building code 7.98743 46.5378 5.82638\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 186.151 (USD bn)\n", + "Average annual risk: 21.5984 (USD bn)\n", + "Residual risk: 124.217 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.13888 7.63243 6.70172\n", + "Beach nourishment 1.50025 5.87772 3.91783\n", + "Seawall 7.70855 1.82863 0.237221\n", + "Building code 7.98743 44.9771 5.63099\n", + "\n", + "-------------------- ------- --------\n", + "Total climate risk: 179.909 (USD bn)\n", + "Average annual risk: 20.855 (USD bn)\n", + "Residual risk: 119.593 (USD bn)\n", + "-------------------- ------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.13888 7.7533 6.80785\n", + "Beach nourishment 1.50025 5.97641 3.98361\n", + "Seawall 7.70855 1.82863 0.237221\n", + "Building code 7.98743 45.0375 5.63855\n", + "\n", + "-------------------- ------- --------\n", + "Total climate risk: 180.15 (USD bn)\n", + "Average annual risk: 20.855 (USD bn)\n", + "Residual risk: 119.554 (USD bn)\n", + "-------------------- ------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.13888 14.9037 13.0863\n", + "Beach nourishment 1.50025 11.752 7.83335\n", + "Seawall 7.70855 0.108627 0.0140917\n", + "Building code 7.98743 24.3925 3.05386\n", + "\n", + "-------------------- ------- --------\n", + "Total climate risk: 97.5699 (USD bn)\n", + "Average annual risk: 11.2725 (USD bn)\n", + "Residual risk: 46.4132 (USD bn)\n", + "-------------------- ------- --------\n", + "Net Present Values\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.34288 7.63243 5.68361\n", + "Beach nourishment 1.76899 5.87772 3.32264\n", + "Seawall 9.08939 1.82863 0.201183\n", + "Building code 9.41823 44.9771 4.77554\n", + "\n", + "-------------------- ------- --------\n", + "Total climate risk: 179.909 (USD bn)\n", + "Average annual risk: 20.855 (USD bn)\n", + "Residual risk: 119.593 (USD bn)\n", + "-------------------- ------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.34288 15.0245 11.1883\n", + "Beach nourishment 1.76899 11.8507 6.69911\n", + "Seawall 9.08939 0.108627 0.0119509\n", + "Building code 9.41823 24.4528 2.59633\n", + "\n", + "-------------------- ------- --------\n", + "Total climate risk: 97.8114 (USD bn)\n", + "Average annual risk: 11.2725 (USD bn)\n", + "Residual risk: 46.3747 (USD bn)\n", + "-------------------- ------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.32205 5.31429 4.01972\n", + "Beach nourishment 1.74155 4.27155 2.45273\n", + "Seawall 8.9484 0.00764219 0.000854029\n", + "Building code 9.27214 3.5502 0.382889\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 14.2008 (USD bn)\n", + "Average annual risk: 1.57569 (USD bn)\n", + "Residual risk: 1.0571 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.32205 5.5802 4.22086\n", + "Beach nourishment 1.74155 4.48867 2.5774\n", + "Seawall 8.9484 0.00764219 0.000854029\n", + "Building code 9.27214 3.68297 0.397208\n", + "\n", + "-------------------- --------- --------\n", + "Total climate risk: 14.7319 (USD bn)\n", + "Average annual risk: 1.57569 (USD bn)\n", + "Residual risk: 0.972395 (USD bn)\n", + "-------------------- --------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.32205 7.60825 5.75487\n", + "Beach nourishment 1.74155 5.85798 3.36366\n", + "Seawall 8.9484 1.82863 0.204353\n", + "Building code 9.27214 44.9651 4.84948\n", + "\n", + "-------------------- ------- --------\n", + "Total climate risk: 179.86 (USD bn)\n", + "Average annual risk: 20.855 (USD bn)\n", + "Residual risk: 119.6 (USD bn)\n", + "-------------------- ------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.36453 5.31429 3.89458\n", + "Beach nourishment 1.79751 4.27155 2.37637\n", + "Seawall 9.23593 0.00764219 0.000827442\n", + "Building code 9.57007 3.5502 0.370969\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 14.2008 (USD bn)\n", + "Average annual risk: 1.57569 (USD bn)\n", + "Residual risk: 1.0571 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.36453 7.87416 5.77059\n", + "Beach nourishment 1.79751 6.0751 3.37973\n", + "Seawall 9.23593 1.82863 0.197991\n", + "Building code 9.57007 45.0978 4.71238\n", + "\n", + "-------------------- ------- --------\n", + "Total climate risk: 180.391 (USD bn)\n", + "Average annual risk: 20.855 (USD bn)\n", + "Residual risk: 119.516 (USD bn)\n", + "-------------------- ------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.06742 8.67047 8.12282\n", + "Beach nourishment 1.40612 6.72299 4.78124\n", + "Seawall 7.2249 0.621468 0.0860176\n", + "Building code 7.48629 39.2619 5.24451\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 157.048 (USD bn)\n", + "Average annual risk: 18.1551 (USD bn)\n", + "Residual risk: 101.771 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.06742 8.5496 8.00959\n", + "Beach nourishment 1.40612 6.6243 4.71105\n", + "Seawall 7.2249 0.621468 0.0860176\n", + "Building code 7.48629 39.2016 5.23645\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 156.806 (USD bn)\n", + "Average annual risk: 18.1551 (USD bn)\n", + "Residual risk: 101.809 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.06742 14.5509 13.6318\n", + "Beach nourishment 1.40612 11.5238 8.19549\n", + "Seawall 7.2249 0.0620626 0.0085901\n", + "Building code 7.48629 19.0186 2.54045\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 76.0742 (USD bn)\n", + "Average annual risk: 8.73152 (USD bn)\n", + "Residual risk: 30.9189 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.17928 8.67047 7.35233\n", + "Beach nourishment 1.55347 6.72299 4.32772\n", + "Seawall 7.98203 0.621468 0.0778584\n", + "Building code 8.27081 39.2619 4.74705\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 157.048 (USD bn)\n", + "Average annual risk: 18.1551 (USD bn)\n", + "Residual risk: 101.771 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.17928 14.43 12.2363\n", + "Beach nourishment 1.55347 11.4252 7.35459\n", + "Seawall 7.98203 0.0620626 0.00777529\n", + "Building code 8.27081 18.9582 2.29218\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 75.8328 (USD bn)\n", + "Average annual risk: 8.73152 (USD bn)\n", + "Residual risk: 30.9574 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.30148 13.8606 10.6498\n", + "Beach nourishment 1.71445 10.7904 6.29377\n", + "Seawall 8.80916 0.175596 0.0199334\n", + "Building code 9.12786 29.4038 3.22132\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 117.615 (USD bn)\n", + "Average annual risk: 13.6166 (USD bn)\n", + "Residual risk: 63.3848 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.30148 13.8606 10.6498\n", + "Beach nourishment 1.71445 10.7904 6.29377\n", + "Seawall 8.80916 0.175596 0.0199334\n", + "Building code 9.12786 29.4038 3.22132\n", + "\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 117.615 (USD bn)\n", + "Average annual risk: 13.6166 (USD bn)\n", + "Residual risk: 63.3848 (USD bn)\n", + "-------------------- -------- --------\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.20992 10.5404 8.71168\n", + "Beach nourishment 1.59383 8.59532 5.39285\n", + "Seawall 8.18941 0.0184996 0.00225897\n", + "Building code 8.48569 7.53759 0.88827Net Present Values\n", + "\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 30.1504 (USD bn)\n", + "Average annual risk: 3.37008 (USD bn)\n", + "Residual risk: 3.45852 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.259 10.4109 8.26917\n", + "Beach nourishment 1.65849 8.18032 4.93239\n", + "Seawall 8.52163 0.415328 0.0487381\n", + "Building code 8.82993 36.8546 4.17383\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 147.418 (USD bn)\n", + "Average annual risk: 17.0232 (USD bn)\n", + "Residual risk: 91.5573 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.34288 15.0245 11.1883\n", + "Beach nourishment 1.76899 11.8507 6.69911\n", + "Seawall 9.08939 0.108627 0.0119509\n", + "Building code 9.41823 24.4528 2.59633\n", + "\n", + "-------------------- ------- --------\n", + "Total climate risk: 97.8114 (USD bn)\n", + "Average annual risk: 11.2725 (USD bn)\n", + "Residual risk: 46.3747 (USD bn)\n", + "-------------------- ------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.30148 14.0781 10.817\n", + "Beach nourishment 1.71445 10.968 6.39739\n", + "Seawall 8.80916 0.175596 0.0199334\n", + "Building code 9.12786 29.5124 3.23322\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 118.05 (USD bn)\n", + "Average annual risk: 13.6166 (USD bn)\n", + "Residual risk: 63.3155 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.20992 12.9104 10.6705\n", + "Beach nourishment 1.59383 10.0034 6.27629\n", + "Seawall 8.18941 0.257712 0.0314689\n", + "Building code 8.48569 33.7365 3.97569\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 134.946 (USD bn)\n", + "Average annual risk: 15.5605 (USD bn)\n", + "Residual risk: 78.038 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.259 8.79133 6.98278\n", + "Beach nourishment 1.65849 6.82168 4.11319\n", + "Seawall 8.52163 0.621468 0.0729283\n", + "Building code 8.82993 39.3223 4.45329\n", + "\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.32205 5.31429 4.01972\n", + "Beach nourishment 1.74155 4.27155 2.45273\n", + "Seawall 8.9484 0.00764219 0.000854029\n", + "Building code 9.27214 3.5502 0.382889-------------------- -------- --------\n", + "Total climate risk: 157.289 (USD bn)\n", + "Average annual risk: 18.1551 (USD bn)\n", + "Residual risk: 101.732 (USD bn)\n", + "-------------------- -------- --------\n", + "\n", + "\n", + "Net Present Values-------------------- -------- --------\n", + "Total climate risk: 14.2008 (USD bn)\n", + "Average annual risk: 1.57569 (USD bn)\n", + "Residual risk: 1.0571 (USD bn)\n", + "-------------------- -------- --------\n", + "\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.30148 14.1012 10.8347\n", + "Beach nourishment 1.71445 10.9632 6.39461\n", + "Seawall 8.80916 0.0376243 0.00427104\n", + "Building code 9.12786 13.3845 1.46633\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 53.5379 (USD bn)\n", + "Average annual risk: 6.15933 (USD bn)\n", + "Residual risk: 15.0513 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.38774 8.44955 6.08873\n", + "Beach nourishment 1.82807 6.4567 3.53197\n", + "Seawall 9.39298 0.895618 0.0953497\n", + "Building code 9.7328 41.407 4.25438\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.259 10.4834 8.32677\n", + "Beach nourishment 1.65849 8.23954 4.96809\n", + "Seawall 8.52163 0.415328 0.0487381\n", + "Building code 8.82993 36.8908 4.17793\n", + "\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 165.628 (USD bn)\n", + "Average annual risk: 19.1818 (USD bn)\n", + "Residual risk: 108.419 (USD bn)\n", + "-------------------- -------- --------\n", + "-------------------- -------- --------\n", + "Total climate risk: 147.563 (USD bn)\n", + "Average annual risk: 17.0232 (USD bn)\n", + "Residual risk: 91.5342 (USD bn)\n", + "-------------------- -------- --------Net Present Values\n", + "\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.32205 5.5802 4.22086\n", + "Beach nourishment 1.74155 4.48867 2.5774\n", + "Seawall 8.9484 0.00764219 0.000854029\n", + "Building code 9.27214 3.68297 0.397208\n", + "\n", + "-------------------- --------- --------\n", + "Total climate risk: 14.7319 (USD bn)\n", + "Average annual risk: 1.57569 (USD bn)\n", + "Residual risk: 0.972395 (USD bn)\n", + "-------------------- --------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.55612 13.8606 8.90716\n", + "Beach nourishment 2.04988 10.7904 5.2639\n", + "Seawall 10.5327 0.175596 0.0166716\n", + "Building code 10.9137 29.4038 2.69421\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 117.615 (USD bn)\n", + "Average annual risk: 13.6166 (USD bn)\n", + "Residual risk: 63.3848 (USD bn)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.38774 8.47373 6.10615\n", + "Beach nourishment 1.82807 6.47644 3.54276\n", + "Seawall 9.39298 0.895618 0.0953497\n", + "Building code 9.7328 41.4191 4.25562Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.259 8.71881 6.92518\n", + "Beach nourishment 1.65849 6.76247 4.07748\n", + "Seawall 8.52163 0.621468 0.0729283\n", + "Building code 8.82993 39.286 4.44919\n", + "\n", + "\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 165.676 (USD bn)\n", + "Average annual risk: 19.1818 (USD bn)\n", + "Residual risk: 108.411 (USD bn)\n", + "-------------------- -------- ---------------------------- -------- --------\n", + "Total climate risk: 157.144 (USD bn)\n", + "Average annual risk: 18.1551 (USD bn)\n", + "Residual risk: 101.755 (USD bn)\n", + "-------------------- -------- --------\n", + "\n", + "Net Present ValuesNet Present Values\n", + "\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.32205 7.60825 5.75487\n", + "Beach nourishment 1.74155 5.85798 3.36366\n", + "Seawall 8.9484 1.82863 0.204353\n", + "Building code 9.27214 44.9651 4.84948\n", + "\n", + "-------------------- ------- --------\n", + "Total climate risk: 179.86 (USD bn)\n", + "Average annual risk: 20.855 (USD bn)\n", + "Residual risk: 119.6 (USD bn)\n", + "-------------------- ------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.55612 14.3188 9.20163\n", + "Beach nourishment 2.04988 11.1409 5.4349\n", + "Seawall 10.5327 0.0376243 0.00357216\n", + "Building code 10.9137 13.4931 1.23634\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 53.9724 (USD bn)\n", + "Average annual risk: 6.15933 (USD bn)\n", + "Residual risk: 14.982 (USD bn)\n", + "-------------------- -------- --------\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.38774 1.39186 1.00297\n", + "Beach nourishment 1.82807 1.13491 0.62082\n", + "Seawall 9.39298 0.000227424 2.42121e-05\n", + "Building code 9.7328 0.76062 0.0781501Net Present Values\n", + "\n", + "\n", + "-------------------- --------- --------\n", + "Total climate risk: 3.04248 (USD bn)\n", + "Average annual risk: 0.260244 (USD bn)\n", + "Residual risk: -0.245137 (USD bn)\n", + "-------------------- --------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.34288 14.575 10.8535\n", + "Beach nourishment 1.76899 11.5436 6.52553\n", + "Seawall 9.08939 0.0620626 0.00682803\n", + "Building code 9.41823 19.0306 2.02062\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 76.1225 (USD bn)\n", + "Average annual risk: 8.73152 (USD bn)\n", + "Residual risk: 30.9112 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.36453 5.31429 3.89458\n", + "Beach nourishment 1.79751 4.27155 2.37637\n", + "Seawall 9.23593 0.00764219 0.000827442\n", + "Building code 9.57007 3.5502 0.370969\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 14.2008 (USD bn)\n", + "Average annual risk: 1.57569 (USD bn)\n", + "Residual risk: 1.0571 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.38774 8.44955 6.08873\n", + "Beach nourishment 1.82807 6.4567 3.53197\n", + "Seawall 9.39298 0.895618 0.0953497\n", + "Building code 9.7328 41.407 4.25438\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 165.628 (USD bn)\n", + "Average annual risk: 19.1818 (USD bn)\n", + "Residual risk: 108.419 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.55612 6.59956 4.24104\n", + "Beach nourishment 2.04988 5.16368 2.51902\n", + "Seawall 10.5327 3.55475 0.337498\n", + "Building code 10.9137 48.016 4.3996\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 192.064 (USD bn)\n", + "Average annual risk: 22.2359 (USD bn)\n", + "Residual risk: 128.73 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.34288 14.3091 10.6555\n", + "Beach nourishment 1.76899 11.3265 6.40279\n", + "Seawall 9.08939 0.0620626 0.00682803\n", + "Building code 9.41823 18.8979 2.00652\n", + "\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 75.5914 (USD bn)\n", + "Average annual risk: 8.73152 (USD bn)\n", + "Residual risk: 30.9959 (USD bn)\n", + "-------------------- -------- --------\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.36453 7.87416 5.77059\n", + "Beach nourishment 1.79751 6.0751 3.37973\n", + "Seawall 9.23593 1.82863 0.197991\n", + "Building code 9.57007 45.0978 4.71238\n", + "Net Present Values\n", + "\n", + "-------------------- ------- --------\n", + "Total climate risk: 180.391 (USD bn)\n", + "Average annual risk: 20.855 (USD bn)\n", + "Residual risk: 119.516 (USD bn)\n", + "-------------------- ------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.38774 1.41604 1.02039\n", + "Beach nourishment 1.82807 1.15464 0.631618\n", + "Seawall 9.39298 0.000227424 2.42121e-05\n", + "Building code 9.7328 0.77269 0.0793903\n", + "\n", + "-------------------- --------- --------\n", + "Total climate risk: 3.09076 (USD bn)\n", + "Average annual risk: 0.260244 (USD bn)\n", + "Residual risk: -0.252837 (USD bn)\n", + "-------------------- --------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.55612 6.43034 4.1323\n", + "Beach nourishment 2.04988 5.02552 2.45161\n", + "Seawall 10.5327 3.55475 0.337498\n", + "Building code 10.9137 47.9315 4.39186\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.34288 7.41063 5.51844\n", + "Beach nourishment 1.76899 5.87997 3.32392\n", + "Seawall 9.08939 2.58858 0.284791\n", + "Building code 9.41823 46.6706 4.95535\n", + "\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 191.726 (USD bn)\n", + "Average annual risk: 22.2359 (USD bn)\n", + "Residual risk: 128.784 (USD bn)\n", + "-------------------- -------- ---------------------------- -------- --------\n", + "Total climate risk: 186.682 (USD bn)\n", + "Average annual risk: 21.5984 (USD bn)\n", + "Residual risk: 124.133 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.06742 8.67047 8.12282\n", + "Beach nourishment 1.40612 6.72299 4.78124\n", + "Seawall 7.2249 0.621468 0.0860176\n", + "Building code 7.48629 39.2619 5.24451\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 157.048 (USD bn)\n", + "Average annual risk: 18.1551 (USD bn)\n", + "Residual risk: 101.771 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.44426 2.77518 1.92153\n", + "Beach nourishment 1.90253 2.24443 1.17971\n", + "Seawall 9.77553 0.00264385 0.000270456\n", + "Building code 10.1292 1.68273 0.166127\n", + "\n", + "-------------------- --------- --------\n", + "Total climate risk: 6.73092 (USD bn)\n", + "Average annual risk: 0.678263 (USD bn)\n", + "Residual risk: 0.0259328 (USD bn)\n", + "-------------------- --------- --------\n", + "Net Present Values\n", + "\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.55612 7.59067 4.87796\n", + "Beach nourishment 2.04988 5.96389 2.90939\n", + "Seawall 10.5327 1.31269 0.12463\n", + "Building code 10.9137 43.2513 3.96302Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.13888 14.575 12.7977\n", + "Beach nourishment 1.50025 11.5436 7.69445\n", + "Seawall 7.70855 0.0620626 0.00805114\n", + "Building code 7.98743 19.0306 2.38257\n", + "\n", + "\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 173.005 (USD bn)\n", + "Average annual risk: 20.0179 (USD bn)\n", + "Residual risk: 114.887 (USD bn)\n", + "-------------------- -------- ---------------------------- -------- --------\n", + "Total climate risk: 76.1225 (USD bn)\n", + "Average annual risk: 8.73152 (USD bn)\n", + "Residual risk: 30.9112 (USD bn)\n", + "-------------------- -------- --------\n", + "\n", + "Net Present ValuesNet Present Values\n", + "\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.06742 8.5496 8.00959\n", + "Beach nourishment 1.40612 6.6243 4.71105\n", + "Seawall 7.2249 0.621468 0.0860176\n", + "Building code 7.48629 39.2016 5.23645\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 156.806 (USD bn)\n", + "Average annual risk: 18.1551 (USD bn)\n", + "Residual risk: 101.809 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.44426 2.70266 1.87132\n", + "Beach nourishment 1.90253 2.18521 1.14859\n", + "Seawall 9.77553 0.00264385 0.000270456\n", + "Building code 10.1292 1.64652 0.162552\n", + "\n", + "\n", + "-------------------- --------- --------\n", + "Total climate risk: 6.58607 (USD bn)\n", + "Average annual risk: 0.678263 (USD bn)\n", + "Residual risk: 0.0490347 (USD bn)\n", + "-------------------- --------- --------Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.30148 6.59956 5.0708\n", + "Beach nourishment 1.71445 5.16368 3.01186\n", + "Seawall 8.80916 3.55475 0.403528\n", + "Building code 9.12786 48.016 5.26038\n", + "\n", + "Net Present Values\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.13888 7.14472 6.27348\n", + "Beach nourishment 1.50025 5.66285 3.77461\n", + "Seawall 7.70855 2.58858 0.335806\n", + "Building code 7.98743 46.5378 5.82638\n", + "\n", + "\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 192.064 (USD bn)\n", + "Average annual risk: 22.2359 (USD bn)\n", + "Residual risk: 128.73 (USD bn)\n", + "-------------------- -------- --------\n", + "-------------------- -------- --------\n", + "Total climate risk: 186.151 (USD bn)\n", + "Average annual risk: 21.5984 (USD bn)\n", + "Residual risk: 124.217 (USD bn)\n", + "-------------------- -------- --------Net Present Values\n", + "Net Present Values\n", + "\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.06742 14.5509 13.6318\n", + "Beach nourishment 1.40612 11.5238 8.19549\n", + "Seawall 7.2249 0.0620626 0.0085901\n", + "Building code 7.48629 19.0186 2.54045\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 76.0742 (USD bn)\n", + "Average annual risk: 8.73152 (USD bn)\n", + "Residual risk: 30.9189 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.13888 7.63243 6.70172\n", + "Beach nourishment 1.50025 5.87772 3.91783\n", + "Seawall 7.70855 1.82863 0.237221\n", + "Building code 7.98743 44.9771 5.63099Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.30148 7.42146 5.70231\n", + "Beach nourishment 1.71445 5.82573 3.39801\n", + "Seawall 8.80916 1.31269 0.149014\n", + "Building code 9.12786 43.1668 4.72913\n", + "\n", + "\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.44426 5.43516 3.76329\n", + "Beach nourishment 1.90253 4.37024 2.29707\n", + "Seawall 9.77553 0.00764219 0.000781768\n", + "Building code 10.1292 3.61055 0.35645\n", + "-------------------- ------- --------\n", + "Total climate risk: 179.909 (USD bn)\n", + "Average annual risk: 20.855 (USD bn)\n", + "Residual risk: 119.593 (USD bn)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-------------------- ------- --------\n", + "-------------------- -------- --------\n", + "Total climate risk: 172.667 (USD bn)\n", + "Average annual risk: 20.0179 (USD bn)\n", + "Residual risk: 114.941 (USD bn)\n", + "-------------------- -------- --------\n", + "\n", + "Net Present Values\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 14.4422 (USD bn)\n", + "Average annual risk: 1.57569 (USD bn)\n", + "Residual risk: 1.0186 (USD bn)\n", + "-------------------- -------- --------Net Present Values\n", + "\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.17928 8.67047 7.35233\n", + "Beach nourishment 1.55347 6.72299 4.32772\n", + "Seawall 7.98203 0.621468 0.0778584\n", + "Building code 8.27081 39.2619 4.74705\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 157.048 (USD bn)\n", + "Average annual risk: 18.1551 (USD bn)\n", + "Residual risk: 101.771 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.13888 7.7533 6.80785\n", + "Beach nourishment 1.50025 5.97641 3.98361\n", + "Seawall 7.70855 1.82863 0.237221\n", + "Building code 7.98743 45.0375 5.63855\n", + "\n", + "-------------------- ------- --------\n", + "Total climate risk: 180.15 (USD bn)\n", + "Average annual risk: 20.855 (USD bn)\n", + "Residual risk: 119.554 (USD bn)\n", + "-------------------- ------- --------\n", + "\n", + "Net Present ValuesMeasure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.20992 10.5404 8.71168\n", + "Beach nourishment 1.59383 8.59532 5.39285\n", + "Seawall 8.18941 0.0184996 0.00225897\n", + "Building code 8.48569 7.53759 0.88827\n", + "\n", + "\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 30.1504 (USD bn)\n", + "Average annual risk: 3.37008 (USD bn)\n", + "Residual risk: 3.45852 (USD bn)\n", + "-------------------- -------- --------\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.44426 2.77518 1.92153\n", + "Beach nourishment 1.90253 2.24443 1.17971\n", + "Seawall 9.77553 0.00264385 0.000270456\n", + "Building code 10.1292 1.68273 0.166127Net Present Values\n", + "\n", + "\n", + "-------------------- --------- --------\n", + "Total climate risk: 6.73092 (USD bn)\n", + "Average annual risk: 0.678263 (USD bn)\n", + "Residual risk: 0.0259328 (USD bn)\n", + "-------------------- --------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.17928 14.43 12.2363\n", + "Beach nourishment 1.55347 11.4252 7.35459\n", + "Seawall 7.98203 0.0620626 0.00777529\n", + "Building code 8.27081 18.9582 2.29218\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 75.8328 (USD bn)\n", + "Average annual risk: 8.73152 (USD bn)\n", + "Residual risk: 30.9574 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.13888 14.9037 13.0863\n", + "Beach nourishment 1.50025 11.752 7.83335\n", + "Seawall 7.70855 0.108627 0.0140917\n", + "Building code 7.98743 24.3925 3.05386\n", + "\n", + "\n", + "-------------------- ------- --------\n", + "Total climate risk: 97.5699 (USD bn)\n", + "Average annual risk: 11.2725 (USD bn)\n", + "Residual risk: 46.4132 (USD bn)\n", + "-------------------- ------- --------Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.20992 10.5646 8.73166\n", + "Beach nourishment 1.59383 8.61505 5.40524\n", + "Seawall 8.18941 0.0184996 0.00225897\n", + "Building code 8.48569 7.54966 0.889693\n", + "\n", + "Net Present Values\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 30.1986 (USD bn)\n", + "Average annual risk: 3.37008 (USD bn)\n", + "Residual risk: 3.45082 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.44426 5.36264 3.71308\n", + "Beach nourishment 1.90253 4.31103 2.26595\n", + "Seawall 9.77553 0.00764219 0.000781768\n", + "Building code 10.1292 3.57434 0.352875\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 14.2973 (USD bn)\n", + "Average annual risk: 1.57569 (USD bn)\n", + "Residual risk: 1.0417 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n", + "\n", + "Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.34288 7.63243 5.68361\n", + "Beach nourishment 1.76899 5.87772 3.32264\n", + "Seawall 9.08939 1.82863 0.201183\n", + "Building code 9.41823 44.9771 4.77554\n", + "\n", + "\n", + "-------------------- ------- --------\n", + "Total climate risk: 179.909 (USD bn)\n", + "Average annual risk: 20.855 (USD bn)\n", + "Residual risk: 119.593 (USD bn)\n", + "-------------------- ------- --------Measure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.20992 12.8863 10.6505\n", + "Beach nourishment 1.59383 9.98362 6.2639\n", + "Seawall 8.18941 0.257712 0.0314689\n", + "Building code 8.48569 33.7244 3.97427\n", + "\n", + "Net Present Values\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 134.898 (USD bn)\n", + "Average annual risk: 15.5605 (USD bn)\n", + "Residual risk: 78.0457 (USD bn)\n", + "-------------------- -------- --------\n", + "\n", + "Net Present ValuesMeasure Cost (USD bn) Benefit (USD bn) Benefit/Cost\n", + "----------------- --------------- ------------------ --------------\n", + "Mangroves 1.259 10.4834 8.32677\n", + "Beach nourishment 1.65849 8.23954 4.96809\n", + "Seawall 8.52163 0.415328 0.0487381\n", + "Building code 8.82993 36.8908 4.17793\n", + "\n", + "\n", + "-------------------- -------- --------\n", + "Total climate risk: 147.563 (USD bn)\n", + "Average annual risk: 17.0232 (USD bn)\n", + "Residual risk: 91.5342 (USD bn)\n", + "-------------------- -------- --------\n", + "Net Present Values\n" ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
x_entx_haz_futm_fut_cost
451.356252.968750.813727
461.043752.968750.813727
471.356252.031250.813727
481.356252.968750.899001
491.043752.031250.899001
\n", - "
" - ], - "text/plain": [ - " x_ent x_haz_fut m_fut_cost\n", - "45 1.35625 2.96875 0.813727\n", - "46 1.04375 2.96875 0.813727\n", - "47 1.35625 2.03125 0.813727\n", - "48 1.35625 2.96875 0.899001\n", - "49 1.04375 2.03125 0.899001" - ] - }, - "execution_count": 55, - "metadata": {}, - "output_type": "execute_result" } ], - "source": [ - "output_cb= unc_cb.make_sample(N=10, sampling_kwargs={'calc_second_order':False})\n", - "output_cb.get_samples_df().tail()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For longer computations, it is possible to use a pool for parallel computation." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2023-08-03T12:00:33.857265Z", - "start_time": "2023-08-03T12:00:13.124046Z" - }, - "scrolled": true - }, - "outputs": [], "source": [ "\n", "#without pool\n", @@ -2918,7 +4672,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 68, "metadata": { "ExecuteTime": { "end_time": "2023-08-03T12:00:33.867733Z", @@ -2936,7 +4690,7 @@ " 'cost_ben_ratio']" ] }, - "execution_count": 57, + "execution_count": 68, "metadata": {}, "output_type": "execute_result" } @@ -2949,7 +4703,7 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 69, "metadata": { "ExecuteTime": { "end_time": "2023-08-03T12:00:33.887774Z", @@ -3049,15 +4803,15 @@ "" ], "text/plain": [ - " Mangroves Benef Beach nourishment Benef Seawall Benef \n", - "45 8.670468e+09 6.722992e+09 6.214684e+08 \\\n", + " Mangroves Benef Beach nourishment Benef Seawall Benef \\\n", + "45 8.670468e+09 6.722992e+09 6.214684e+08 \n", "46 8.549601e+09 6.624301e+09 6.214684e+08 \n", "47 1.455086e+10 1.152385e+10 6.206260e+07 \n", "48 8.670468e+09 6.722992e+09 6.214684e+08 \n", "49 1.443000e+10 1.142516e+10 6.206260e+07 \n", "\n", - " Building code Benef Mangroves CostBen Beach nourishment CostBen \n", - "45 3.926190e+10 0.123110 0.209151 \\\n", + " Building code Benef Mangroves CostBen Beach nourishment CostBen \\\n", + "45 3.926190e+10 0.123110 0.209151 \n", "46 3.920155e+10 0.124850 0.212267 \n", "47 1.901856e+10 0.073358 0.122018 \n", "48 3.926190e+10 0.136011 0.231069 \n", @@ -3071,7 +4825,7 @@ "49 128.612593 0.436265 " ] }, - "execution_count": 58, + "execution_count": 69, "metadata": {}, "output_type": "execute_result" } @@ -3083,7 +4837,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 70, "metadata": { "ExecuteTime": { "end_time": "2023-08-03T12:00:33.913186Z", @@ -3255,78 +5009,78 @@ "" ], "text/plain": [ - " no measure - risk - present no measure - risk_transf - present \n", - "45 1.040893e+08 0.0 \\\n", + " no measure - risk - present no measure - risk_transf - present \\\n", + "45 1.040893e+08 0.0 \n", "46 8.010560e+07 0.0 \n", "47 1.040893e+08 0.0 \n", "48 1.040893e+08 0.0 \n", "49 8.010560e+07 0.0 \n", "\n", - " no measure - cost_meas - present no measure - cost_ins - present \n", - "45 0 0 \\\n", + " no measure - cost_meas - present no measure - cost_ins - present \\\n", + "45 0 0 \n", "46 0 0 \n", "47 0 0 \n", "48 0 0 \n", "49 0 0 \n", "\n", - " Mangroves - risk - present Mangroves - risk_transf - present \n", - "45 5.197409e+07 0 \\\n", + " Mangroves - risk - present Mangroves - risk_transf - present \\\n", + "45 5.197409e+07 0 \n", "46 3.999849e+07 0 \n", "47 5.197409e+07 0 \n", "48 5.197409e+07 0 \n", "49 3.999849e+07 0 \n", "\n", - " Mangroves - cost_meas - present Mangroves - cost_ins - present \n", - "45 1.311768e+09 1 \\\n", + " Mangroves - cost_meas - present Mangroves - cost_ins - present \\\n", + "45 1.311768e+09 1 \n", "46 1.311768e+09 1 \n", "47 1.311768e+09 1 \n", "48 1.311768e+09 1 \n", "49 1.311768e+09 1 \n", "\n", - " Beach nourishment - risk - present \n", - "45 6.153578e+07 \\\n", + " Beach nourishment - risk - present \\\n", + "45 6.153578e+07 \n", "46 4.735703e+07 \n", "47 6.153578e+07 \n", "48 6.153578e+07 \n", "49 4.735703e+07 \n", "\n", - " Beach nourishment - risk_transf - present \n", - "45 0 \\\n", + " Beach nourishment - risk_transf - present \\\n", + "45 0 \n", "46 0 \n", "47 0 \n", "48 0 \n", "49 0 \n", "\n", - " Beach nourishment - cost_meas - present \n", - "45 1.728000e+09 \\\n", + " Beach nourishment - cost_meas - present \\\n", + "45 1.728000e+09 \n", "46 1.728000e+09 \n", "47 1.728000e+09 \n", "48 1.728000e+09 \n", "49 1.728000e+09 \n", "\n", - " Beach nourishment - cost_ins - present Seawall - risk - present \n", - "45 1 1.040893e+08 \\\n", + " Beach nourishment - cost_ins - present Seawall - risk - present \\\n", + "45 1 1.040893e+08 \n", "46 1 8.010560e+07 \n", "47 1 1.040893e+08 \n", "48 1 1.040893e+08 \n", "49 1 8.010560e+07 \n", "\n", - " Seawall - risk_transf - present Seawall - cost_meas - present \n", - "45 0 8.878779e+09 \\\n", + " Seawall - risk_transf - present Seawall - cost_meas - present \\\n", + "45 0 8.878779e+09 \n", "46 0 8.878779e+09 \n", "47 0 8.878779e+09 \n", "48 0 8.878779e+09 \n", "49 0 8.878779e+09 \n", "\n", - " Seawall - cost_ins - present Building code - risk - present \n", - "45 1 7.806698e+07 \\\n", + " Seawall - cost_ins - present Building code - risk - present \\\n", + "45 1 7.806698e+07 \n", "46 1 6.007920e+07 \n", "47 1 7.806698e+07 \n", "48 1 7.806698e+07 \n", "49 1 6.007920e+07 \n", "\n", - " Building code - risk_transf - present \n", - "45 0 \\\n", + " Building code - risk_transf - present \\\n", + "45 0 \n", "46 0 \n", "47 0 \n", "48 0 \n", @@ -3340,7 +5094,7 @@ "49 9.200000e+09 1 " ] }, - "execution_count": 59, + "execution_count": 70, "metadata": {}, "output_type": "execute_result" } @@ -3360,7 +5114,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 71, "metadata": { "ExecuteTime": { "end_time": "2023-08-03T12:00:35.497893Z", @@ -3370,7 +5124,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3393,31 +5147,14 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 72, "metadata": { "ExecuteTime": { "end_time": "2023-08-03T12:00:35.632065Z", "start_time": "2023-08-03T12:00:35.500390Z" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", - " npdtype = np.dtype(dtype)\n", - "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", - " npdtype = np.dtype(dtype)\n", - "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", - " npdtype = np.dtype(dtype)\n", - "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", - " npdtype = np.dtype(dtype)\n", - "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1687: DeprecationWarning: Converting `np.inexact` or `np.floating` to a dtype is deprecated. The current result is `float64` which is not strictly correct.\n", - " npdtype = np.dtype(dtype)\n" - ] - } - ], + "outputs": [], "source": [ "output_cb = unc_cb.sensitivity(output_cb, sensitivity_kwargs={'calc_second_order':False})" ] @@ -3433,7 +5170,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 73, "metadata": { "ExecuteTime": { "end_time": "2023-08-03T12:00:36.659813Z", @@ -3443,7 +5180,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3461,14 +5198,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Advanced examples" + "\n", + "## Advanced examples\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Coupled variables" + "\n", + "### Coupled variables\n" ] }, { @@ -3484,7 +5223,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Many scenarios of hazards and exposures" + "\n", + "#### Many scenarios of hazards and exposures\n" ] }, { @@ -3500,7 +5240,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 74, "metadata": {}, "outputs": [], "source": [ @@ -3510,7 +5250,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 75, "metadata": {}, "outputs": [], "source": [ @@ -3527,7 +5267,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 76, "metadata": {}, "outputs": [], "source": [ @@ -3542,7 +5282,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 77, "metadata": {}, "outputs": [], "source": [ @@ -3583,14 +5323,14 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 78, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2023-08-04 16:34:35,948 - climada.engine.unsequa.calc_base - WARNING - \n", + "2024-01-25 15:38:30,713 - climada.engine.unsequa.calc_base - WARNING - \n", "\n", "The input parameter cnt is shared among at least 2 input variables. Their uncertainty is thus computed with the same samples for this input paramter.\n", "\n", @@ -3606,24 +5346,16 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 79, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-04 16:34:35,987 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 40\n" - ] - } - ], + "outputs": [], "source": [ "output_imp = calc_imp.make_sample(N=2**2, sampling_kwargs={'skip_values': 2**3})\n" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 80, "metadata": {}, "outputs": [ { @@ -3702,7 +5434,7 @@ "39 1.0625 0.0 1.0375 1.097755" ] }, - "execution_count": 21, + "execution_count": 80, "metadata": {}, "output_type": "execute_result" } @@ -3714,22 +5446,9 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-04 16:34:36,224 - climada.entity.exposures.base - INFO - Exposures matching centroids already found for WS\n", - "2023-08-04 16:34:36,227 - climada.engine.impact_calc - INFO - Calculating impact for 8397 assets (>0) and 4260 events.\n", - "2023-08-04 16:34:37,042 - climada.engine.unsequa.calc_base - INFO - \n", - "\n", - "Estimated computaion time: 0:00:10.300000\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "output_imp = calc_imp.uncertainty(output_imp)" ] @@ -3738,70 +5457,7 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
aai_agg
351.254818e+07
365.340193e+08
371.219989e+07
381.350121e+07
391.350121e+07
\n", - "
" - ], - "text/plain": [ - " aai_agg\n", - "35 1.254818e+07\n", - "36 5.340193e+08\n", - "37 1.219989e+07\n", - "38 1.350121e+07\n", - "39 1.350121e+07" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "output_imp.aai_agg_unc_df.tail()" ] @@ -3810,7 +5466,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Input variable: Repeated loading of files made efficient" + "\n", + "### Input variable: Repeated loading of files made efficient\n" ] }, { @@ -3824,7 +5481,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -3834,7 +5491,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -3862,7 +5519,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -3874,7 +5531,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -3964,25 +5621,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-04 16:30:48,177 - climada.entity.exposures.base - INFO - Reading /Users/ckropf/climada/data/exposures/litpop/LitPop_150arcsec_DEU/v2/LitPop_150arcsec_DEU.hdf5\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/ckropf/opt/anaconda3/envs/climada_333_shapely2/lib/python3.9/pickle.py:1717: UserWarning: Unpickling a shapely <2.0 geometry object. Please save the pickle again; shapely 2.1 will not have this compatibility.\n", - " setstate(state)\n" - ] - } - ], + "outputs": [], "source": [ "from climada.engine.unsequa import CalcImpact\n", "\n", @@ -3998,17 +5639,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-08-04 16:29:49,588 - climada.engine.unsequa.calc_base - INFO - Effective number of made samples: 72\n" - ] - } - ], + "outputs": [], "source": [ "# Ordering of the samples by hazard first and exposures second\n", "output_imp = calc_imp.make_sample(N=2**2, sampling_kwargs={'skip_values': 2**3})\n", @@ -4024,7 +5657,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -4042,30 +5675,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.plot(e, label='exposures');\n", "plt.plot(h, label='hazards');\n", @@ -4103,7 +5715,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.9.16" }, "latex_envs": { "LaTeX_envs_menu_present": true, From 78efc1e5d243cb62ba69014eccebc4b108952ec9 Mon Sep 17 00:00:00 2001 From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Mon, 5 Feb 2024 15:14:02 +0100 Subject: [PATCH 05/12] Avoid redundant calls to `np.unique` in `Impact.impact_at_reg` (#848) --- CHANGELOG.md | 1 + climada/engine/impact.py | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 67145f49d3..223064c200 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -47,6 +47,7 @@ Removed: - In the TropCyclone class in the Holland model 2008 and 2010 implementation, a doublecounting of translational velocity is removed [#833](https://github.com/CLIMADA-project/climada_python/pull/833) - `climada.util.test.test_finance` and `climada.test.test_engine` updated to recent input data from worldbank [#841](https://github.com/CLIMADA-project/climada_python/pull/841) - Set `nodefaults` in Conda environment specs because `defaults` are not compatible with conda-forge [#845](https://github.com/CLIMADA-project/climada_python/pull/845) +- Avoid redundant calls to `np.unique` in `Impact.impact_at_reg` [#848](https://github.com/CLIMADA-project/climada_python/pull/848) ### Deprecated diff --git a/climada/engine/impact.py b/climada/engine/impact.py index 88b112b009..e9afda5903 100644 --- a/climada/engine/impact.py +++ b/climada/engine/impact.py @@ -451,12 +451,12 @@ def impact_at_reg(self, agg_regions=None): at_reg_event = np.hstack( [ self.imp_mat[:, np.where(agg_regions == reg)[0]].sum(1) - for reg in np.unique(agg_reg_unique) + for reg in agg_reg_unique ] ) at_reg_event = pd.DataFrame( - at_reg_event, columns=np.unique(agg_reg_unique), index=self.event_id + at_reg_event, columns=agg_reg_unique, index=self.event_id ) return at_reg_event From 70aa0fc9e58955db07d4f7916ca8f195e47423cf Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Thu, 8 Feb 2024 15:26:47 +0100 Subject: [PATCH 06/12] climada.util.plot: pydoc cosmetics --- climada/util/plot.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/climada/util/plot.py b/climada/util/plot.py index 8f790a3b20..c62ee28807 100644 --- a/climada/util/plot.py +++ b/climada/util/plot.py @@ -515,7 +515,7 @@ def make_map(num_sub=1, figsize=(9, 13), proj=ccrs.PlateCarree(), adapt_fontsize Returns ------- - fig, axis_sub : matplotlib.figure.Figure, cartopy.mpl.geoaxes.GeoAxesSubplot + fig, axis_sub, fontsize : matplotlib.figure.Figure, cartopy.mpl.geoaxes.GeoAxesSubplot, int """ if isinstance(num_sub, int): num_row, num_col = _get_row_col_size(num_sub) From 8f5c636c8f554617774d1ec04d6fec1fbafc85fa Mon Sep 17 00:00:00 2001 From: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Date: Fri, 9 Feb 2024 12:14:43 +0100 Subject: [PATCH 07/12] Update GitHub actions to use latest Node.js (#849) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 😄 --- .github/workflows/ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 686ec1e9a5..ec18680130 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -26,7 +26,7 @@ jobs: steps: - name: Checkout Repo - uses: actions/checkout@v3 + uses: actions/checkout@v4 - # Store the current date to use it as cache key for the environment name: Get current date @@ -64,7 +64,7 @@ jobs: - name: Upload Coverage Reports if: always() - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: coverage-report-unittests-py${{ matrix.python-version }} path: coverage/ From f08d0baac1a7318a449b4c036dcdccb574211514 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Wed, 14 Feb 2024 10:26:52 +0100 Subject: [PATCH 08/12] dependencies: move required versions on --- requirements/env_climada.yml | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/requirements/env_climada.yml b/requirements/env_climada.yml index 47df554116..d4c2c36490 100644 --- a/requirements/env_climada.yml +++ b/requirements/env_climada.yml @@ -6,8 +6,8 @@ dependencies: - bottleneck>=1.3 - cartopy>=0.22 - cfgrib>=0.9.9,<0.9.10 # 0.9.10 cannot read the icon_grib files from https://opendata.dwd.de - - contextily>=1.4 - - dask>=2023 + - contextily>=1.5 + - dask>=2024 - eccodes>=2.27,<2.28 # 2.28 changed some labels, in particular: gust -> i20fg - gdal>=3.6 - geopandas>=0.14 @@ -15,13 +15,13 @@ dependencies: - haversine>=2.8 - matplotlib-base>=3.8 - netcdf4>=1.6 - - numba>=0.58 - - numexpr>=2.8 + - numba>=0.59 + - numexpr>=2.9 - openpyxl>=3.1 - pandas>=2.1,<2.2 # 2.2 is not compatible with the default pytables=3.7 and yields a very high deprecation warning number through geopandas - pandas-datareader>=0.10 - pathos>=0.3 - - pint>=0.22 + - pint>=0.23 - pip - pycountry>=22.3 - pyepsg>=0.4 @@ -31,13 +31,13 @@ dependencies: - rasterio>=1.3 - requests>=2.31 - salib>=1.4 - - scikit-learn>=1.3 - - scipy>=1.11 - - sparse>=0.14 + - scikit-learn>=1.4 + - scipy>=1.12 + - sparse>=0.15 - statsmodels>=0.14 - tabulate>=0.9 - tqdm>=4.66 - unittest-xml-reporting>=3.2 - - xarray>=2023.11 + - xarray>=2024.1 - xlrd>=2.0 - xlsxwriter>=3.1 From e5746b6e58fceb5b8ffd35e71a8a665c75736c0e Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Wed, 14 Feb 2024 11:54:49 +0100 Subject: [PATCH 09/12] dependencies: update changelog --- CHANGELOG.md | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 223064c200..d1b26707ff 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,8 +13,21 @@ Code freeze date: YYYY-MM-DD Added: - `pyproj` >=3.5 -- `pyarrow` >=14.0 -- `numexpr` >=2.8 +- `numexpr` >=2.9 + +Updated: + +- `contextily` >=1.3 → >=1.5 +- `dask` >=2023 → >=2024 +- `numba` >=0.57 → >=0.59 +- `pandas` >=2.1 → >=2.1,<2.2 +- `pint` >=0.22 → >=0.23 +- `scikit-learn` >=1.3 → >=1.4 +- `scipy` >=1.11 → >=1.12 +- `sparse` >=0.14 → >=0.15 +- `xarray` >=2023.8 → >=2024.1 +- `overpy` =0.6 → =0.7 +- `peewee` =3.16.3 → =3.17.1 Removed: From d76761fb8877a0c17642110573b24c68d9ad3590 Mon Sep 17 00:00:00 2001 From: climada Date: Wed, 14 Feb 2024 12:02:57 +0000 Subject: [PATCH 10/12] setup develop branch for v4.1.1-dev --- CHANGELOG.md | 20 ++++++++++++++++---- climada/_version.py | 2 +- doc/misc/README.md | 11 +++++++---- setup.py | 2 +- 4 files changed, 25 insertions(+), 10 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d1b26707ff..cd153127be 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,22 @@ Code freeze date: YYYY-MM-DD ### Dependency Changes +### Added + +### Changed + +### Fixed + +### Deprecated + +### Removed + +## 4.1.0 + +Release date: 2024-02-14 + +### Dependency Changes + Added: - `pyproj` >=3.5 @@ -62,10 +78,6 @@ Removed: - Set `nodefaults` in Conda environment specs because `defaults` are not compatible with conda-forge [#845](https://github.com/CLIMADA-project/climada_python/pull/845) - Avoid redundant calls to `np.unique` in `Impact.impact_at_reg` [#848](https://github.com/CLIMADA-project/climada_python/pull/848) -### Deprecated - -### Removed - ## 4.0.1 Release date: 2023-09-27 diff --git a/climada/_version.py b/climada/_version.py index d9cfbbef35..bbda9963f8 100644 --- a/climada/_version.py +++ b/climada/_version.py @@ -1 +1 @@ -__version__ = '4.0.2-dev' +__version__ = '4.1.1-dev' diff --git a/doc/misc/README.md b/doc/misc/README.md index d39bb67000..58d9075952 100644 --- a/doc/misc/README.md +++ b/doc/misc/README.md @@ -17,13 +17,14 @@ This is the Python (3.9+) version of CLIMADA - please see [here](https://github. ## Getting started CLIMADA runs on Windows, macOS and Linux. -The released versions of the CLIMADA core can be installed directly through Anaconda: +The released versions of CLIMADA are available from [conda-forge](https://anaconda.org/conda-forge/climada). +Use the [Mamba](https://mamba.readthedocs.io/en/latest/) package manager to install it: ```shell -conda install -c conda-forge climada +mamba install -c conda-forge climada ``` -It is **highly recommended** to install CLIMADA into a **separate** Anaconda environment. +It is **highly recommended** to install CLIMADA into a **separate** Conda environment. See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for further information. Follow the [tutorials](https://climada-python.readthedocs.io/en/stable/tutorial/1_main_climada.html) in a Jupyter Notebook to see what can be done with CLIMADA and how. @@ -57,7 +58,9 @@ Please use the following logo if you are presenting results obtained with or thr ## Contributing -See the [Contribution Guide](CONTRIBUTING.md). +We welcome any contribution to this repository, be it bugfixes and other code changes and additions, documentation improvements, or tutorial updates. + +If you would like to contribute, please refer to our [Contribution Guide](CONTRIBUTING.md). ## Versioning diff --git a/setup.py b/setup.py index 36dafad9fa..085303945d 100644 --- a/setup.py +++ b/setup.py @@ -33,7 +33,7 @@ setup( name='climada', - version='4.0.2-dev', + version='4.1.1-dev', description='CLIMADA in Python', From bd470ed64ac23b4a739fceee48c8cb644be2d0a3 Mon Sep 17 00:00:00 2001 From: Thomas Vogt <57705593+tovogt@users.noreply.github.com> Date: Thu, 15 Feb 2024 11:50:23 +0100 Subject: [PATCH 11/12] trop_cyclone: fix for tracks crossing antimeridian (#839) * trop_cyclone: fix antimeridian issue #831 * trop_cyclone: add explicit antimeridian test * Fix docstring formatting * CHANGELOG --------- Co-authored-by: Lukas Riedel <34276446+peanutfun@users.noreply.github.com> Co-authored-by: emanuel-schmid --- CHANGELOG.md | 3 + climada/hazard/test/test_trop_cyclone.py | 72 +++- climada/hazard/trop_cyclone.py | 402 ++++++++++++----------- climada/util/coordinates.py | 11 +- climada/util/test/test_coordinates.py | 5 + 5 files changed, 288 insertions(+), 205 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index cd153127be..6df42470cf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,9 @@ Code freeze date: YYYY-MM-DD ### Fixed +- Fix `util.coordinates.latlon_bounds` for cases where the specified buffer is very large so that the bounds cover more than the full longitudinal range `[-180, 180]` [#839](https://github.com/CLIMADA-project/climada_python/pull/839) +- Fix `climada.hazard.trop_cyclone` for TC tracks crossing the antimeridian [#839](https://github.com/CLIMADA-project/climada_python/pull/839) + ### Deprecated ### Removed diff --git a/climada/hazard/test/test_trop_cyclone.py b/climada/hazard/test/test_trop_cyclone.py index 992fdeb5bb..41fc799722 100644 --- a/climada/hazard/test/test_trop_cyclone.py +++ b/climada/hazard/test/test_trop_cyclone.py @@ -127,6 +127,25 @@ def test_set_one_pass(self): msk = (intensity > 0) np.testing.assert_array_equal(windfield_norms[msk], intensity[msk]) + def test_cross_antimeridian(self): + # Two locations on the island Taveuni (Fiji), one west and one east of 180° longitude. + # We list the second point twice, with different lon-normalization: + cen = Centroids.from_lat_lon([-16.95, -16.8, -16.8], [179.9, 180.1, -179.9]) + cen.set_dist_coast(precomputed=True) + + # Cyclone YASA (2020) passed directly over Fiji + tr = TCTracks.from_ibtracs_netcdf(storm_id=["2020346S13168"]) + + inten = TropCyclone.from_tracks(tr, centroids=cen).intensity.toarray()[0, :] + + # Centroids 1 and 2 are identical, they just use a different normalization for lon. This + # should not affect the result at all: + self.assertEqual(inten[1], inten[2]) + + # All locations should be clearly affected by strong winds of appx. 40 m/s. The exact + # values are not so important for this test: + np.testing.assert_allclose(inten, 40, atol=10) + def test_windfield_models(self): """Test _tc_from_track function with different wind field models.""" intensity_idx = [0, 1, 2, 3, 80, 100, 120, 200, 220, 250, 260, 295] @@ -256,31 +275,54 @@ class TestWindfieldHelpers(unittest.TestCase): def test_get_close_centroids_pass(self): """Test get_close_centroids function.""" - t_lat = np.array([0, -0.5, 0]) - t_lon = np.array([0.9, 2, 3.2]) + si_track = xr.Dataset({ + "lat": ("time", np.array([0, -0.5, 0])), + "lon": ("time", np.array([0.9, 2, 3.2])), + }, attrs={"mid_lon": 0.0}) centroids = np.array([ [0, -0.2], [0, 0.9], [-1.1, 1.2], [1, 2.1], [0, 4.3], [0.6, 3.8], [0.9, 4.1], ]) - test_mask = np.array([[False, True, False, False, False, False, False], - [False, False, True, False, False, False, False], - [False, False, False, False, False, True, False]]) - mask = get_close_centroids(t_lat, t_lon, centroids, 112.0) - np.testing.assert_equal(mask, test_mask) + centroids_close, mask_close, mask_close_alongtrack = ( + get_close_centroids(si_track, centroids, 112.0) + ) + self.assertEqual(centroids_close.shape[0], mask_close.sum()) + self.assertEqual(mask_close_alongtrack.shape[0], si_track.sizes["time"]) + self.assertEqual(mask_close_alongtrack.shape[1], centroids_close.shape[0]) + np.testing.assert_equal(mask_close_alongtrack.any(axis=0), True) + np.testing.assert_equal(mask_close, np.array( + [False, True, True, False, False, True, False] + )) + np.testing.assert_equal(mask_close_alongtrack, np.array([ + [True, False, False], + [False, True, False], + [False, False, True], + ])) + np.testing.assert_equal(centroids_close, centroids[mask_close]) # example where antimeridian is crossed - t_lat = np.linspace(-10, 10, 11) - t_lon = np.linspace(170, 200, 11) - t_lon[t_lon > 180] -= 360 + si_track = xr.Dataset({ + "lat": ("time", np.linspace(-10, 10, 11)), + "lon": ("time", np.linspace(170, 200, 11)), + }, attrs={"mid_lon": 180.0}) centroids = np.array([[-11, 169], [-7, 176], [4, -170], [10, 170], [-10, -160]]) - test_mask = np.array([True, True, True, False, False]) - mask = get_close_centroids(t_lat, t_lon, centroids, 600.0) - np.testing.assert_equal(mask.any(axis=0), test_mask) + centroids_close, mask_close, mask_close_alongtrack = ( + get_close_centroids(si_track, centroids, 600.0) + ) + self.assertEqual(centroids_close.shape[0], mask_close.sum()) + self.assertEqual(mask_close_alongtrack.shape[0], si_track.sizes["time"]) + self.assertEqual(mask_close_alongtrack.shape[1], centroids_close.shape[0]) + np.testing.assert_equal(mask_close_alongtrack.any(axis=0), True) + np.testing.assert_equal(mask_close, np.array([True, True, True, False, False])) + np.testing.assert_equal(centroids_close, np.array([ + # the longitudinal coordinate of the third centroid is normalized + [-11, 169], [-7, 176], [4, 190], + ])) def test_B_holland_1980_pass(self): """Test _B_holland_1980 function.""" si_track = xr.Dataset({ - "env": ("time", MBAR_TO_PA * np.array([1010, 1010])), - "cen": ("time", MBAR_TO_PA * np.array([995, 980])), + "env": ("time", MBAR_TO_PA * np.array([1010, 1010])), + "cen": ("time", MBAR_TO_PA * np.array([995, 980])), "vgrad": ("time", [35, 40]), }) _B_holland_1980(si_track) diff --git a/climada/hazard/trop_cyclone.py b/climada/hazard/trop_cyclone.py index 125063012b..38eb6d00d9 100644 --- a/climada/hazard/trop_cyclone.py +++ b/climada/hazard/trop_cyclone.py @@ -119,7 +119,7 @@ class TropCyclone(Hazard): """intensity threshold for storage in m/s""" vars_opt = Hazard.vars_opt.union({'category'}) - """Name of the variables that aren't need to compute the impact.""" + """Name of the variables that are not needed to compute the impact.""" def __init__( self, @@ -193,19 +193,19 @@ def from_tracks( """ Create new TropCyclone instance that contains windfields from the specified tracks. - This function sets the `intensity` attribute to contain, for each centroid, + This function sets the ``intensity`` attribute to contain, for each centroid, the maximum wind speed (1-minute sustained winds at 10 meters above ground) experienced over the whole period of each TC event in m/s. The wind speed is set to 0 if it doesn't - exceed the threshold `intensity_thres`. + exceed the threshold ``intensity_thres``. - The `category` attribute is set to the value of the `category`-attribute + The ``category`` attribute is set to the value of the ``category``-attribute of each of the given track data sets. - The `basin` attribute is set to the genesis basin for each event, which - is the first value of the `basin`-variable in each of the given track data sets. + The ``basin`` attribute is set to the genesis basin for each event, which + is the first value of the ``basin``-variable in each of the given track data sets. - Optionally, the time dependent, vectorial winds can be stored using the `store_windfields` - function parameter (see below). + Optionally, the time dependent, vectorial winds can be stored using the + ``store_windfields`` function parameter (see below). Parameters ---------- @@ -225,7 +225,7 @@ def from_tracks( ignore_distance_to_coast : boolean, optional If True, centroids far from coast are not ignored. Default: False. store_windfields : boolean, optional - If True, the Hazard object gets a list `windfields` of sparse matrices. For each track, + If True, the Hazard object gets a list ``windfields`` of sparse matrices. For each track, the full velocity vectors at each centroid and track position are stored in a sparse matrix of shape (npositions, ncentroids * 2) that can be reshaped to a full ndarray of shape (npositions, ncentroids, 2). Default: False. @@ -251,7 +251,7 @@ def from_tracks( max_memory_gb : float, optional To avoid memory issues, the computation is done for chunks of the track sequentially. The chunk size is determined depending on the available memory (in GB). Note that this - limit applies to each thread separately if a `pool` is used. Default: 8 + limit applies to each thread separately if a ``pool`` is used. Default: 8 Raises ------ @@ -270,13 +270,15 @@ def from_tracks( if ignore_distance_to_coast: # Select centroids with lat <= max_latitude - coastal_idx = (np.abs(centroids.lat) <= max_latitude).nonzero()[0] + [idx_centr_filter] = (np.abs(centroids.lat) <= max_latitude).nonzero() else: # Select centroids which are inside max_dist_inland_km and lat <= max_latitude if not centroids.dist_coast.size: centroids.set_dist_coast() - coastal_idx = ((centroids.dist_coast <= max_dist_inland_km * 1000) - & (np.abs(centroids.lat) <= max_latitude)).nonzero()[0] + [idx_centr_filter] = ( + (centroids.dist_coast <= max_dist_inland_km * 1000) + & (np.abs(centroids.lat) <= max_latitude) + ).nonzero() # Filter early with a larger threshold, but inaccurate (lat/lon) distances. # Later, there will be another filtering step with more accurate distances in km. @@ -287,21 +289,23 @@ def from_tracks( # Restrict to coastal centroids within reach of any of the tracks t_lon_min, t_lat_min, t_lon_max, t_lat_max = tracks.get_bounds(deg_buffer=max_dist_eye_deg) t_mid_lon = 0.5 * (t_lon_min + t_lon_max) - coastal_centroids = centroids.coord[coastal_idx] - u_coord.lon_normalize(coastal_centroids[:, 1], center=t_mid_lon) - coastal_idx = coastal_idx[((t_lon_min <= coastal_centroids[:, 1]) - & (coastal_centroids[:, 1] <= t_lon_max) - & (t_lat_min <= coastal_centroids[:, 0]) - & (coastal_centroids[:, 0] <= t_lat_max))] + filtered_centroids = centroids.coord[idx_centr_filter] + u_coord.lon_normalize(filtered_centroids[:, 1], center=t_mid_lon) + idx_centr_filter = idx_centr_filter[ + (t_lon_min <= filtered_centroids[:, 1]) + & (filtered_centroids[:, 1] <= t_lon_max) + & (t_lat_min <= filtered_centroids[:, 0]) + & (filtered_centroids[:, 0] <= t_lat_max) + ] LOGGER.info('Mapping %s tracks to %s coastal centroids.', str(tracks.size), - str(coastal_idx.size)) + str(idx_centr_filter.size)) if pool: chunksize = max(min(num_tracks // pool.ncpus, 1000), 1) tc_haz_list = pool.map( cls.from_single_track, tracks.data, itertools.repeat(centroids, num_tracks), - itertools.repeat(coastal_idx, num_tracks), + itertools.repeat(idx_centr_filter, num_tracks), itertools.repeat(model, num_tracks), itertools.repeat(store_windfields, num_tracks), itertools.repeat(metric, num_tracks), @@ -318,7 +322,7 @@ def from_tracks( LOGGER.info("Progress: %d%%", perc) last_perc = perc tc_haz_list.append( - cls.from_single_track(track, centroids, coastal_idx, + cls.from_single_track(track, centroids, idx_centr_filter, model=model, store_windfields=store_windfields, metric=metric, intensity_thres=intensity_thres, max_dist_eye_km=max_dist_eye_km, @@ -507,7 +511,7 @@ def from_single_track( cls, track: xr.Dataset, centroids: Centroids, - coastal_idx: np.ndarray, + idx_centr_filter: np.ndarray, model: str = 'H08', store_windfields: bool = False, metric: str = "equirect", @@ -524,8 +528,8 @@ def from_single_track( Single tropical cyclone track. centroids : Centroids Centroids instance. - coastal_idx : np.ndarray - Indices of centroids close to coast. + idx_centr_filter : np.ndarray + Indices of centroids to restrict to (e.g. sufficiently close to coast). model : str, optional Parametric wind field model, one of "H1980" (the prominent Holland 1980 model), "H08" (Holland 1980 with b-value from Holland 2008), "H10" (Holland et al. 2010), or @@ -535,7 +539,7 @@ def from_single_track( If True, store windfields. Default: False. metric : str, optional Specify an approximation method to use for earth distances: "equirect" (faster) or - "geosphere" (more accurate). See `dist_approx` function in `climada.util.coordinates`. + "geosphere" (more accurate). See ``dist_approx`` function in ``climada.util.coordinates``. Default: "equirect". intensity_thres : float, optional Wind speeds (in m/s) below this threshold are stored as 0. Default: 17.5 @@ -557,7 +561,7 @@ def from_single_track( intensity_sparse, windfields_sparse = _compute_windfields_sparse( track=track, centroids=centroids, - coastal_idx=coastal_idx, + idx_centr_filter=idx_centr_filter, model=model, store_windfields=store_windfields, metric=metric, @@ -663,7 +667,7 @@ def _apply_knutson_criterion( def _compute_windfields_sparse( track: xr.Dataset, centroids: Centroids, - coastal_idx: np.ndarray, + idx_centr_filter: np.ndarray, model: str = 'H08', store_windfields: bool = False, metric: str = "equirect", @@ -671,7 +675,7 @@ def _compute_windfields_sparse( max_dist_eye_km: float = DEF_MAX_DIST_EYE_KM, max_memory_gb: float = DEF_MAX_MEMORY_GB, ) -> Tuple[sparse.csr_matrix, Optional[sparse.csr_matrix]]: - """Version of `compute_windfields` that returns sparse matrices and limits memory usage + """Version of ``compute_windfields`` that returns sparse matrices and limits memory usage Parameters ---------- @@ -679,8 +683,8 @@ def _compute_windfields_sparse( Single tropical cyclone track. centroids : Centroids Centroids instance. - coastal_idx : np.ndarray - Indices of centroids close to coast. + idx_centr_filter : np.ndarray + Indices of centroids to restrict to (e.g. sufficiently close to coast). model : str, optional Parametric wind field model, one of "H1980" (the prominent Holland 1980 model), "H08" (Holland 1980 with b-value from Holland 2008), "H10" (Holland et al. 2010), or @@ -690,7 +694,7 @@ def _compute_windfields_sparse( If True, store windfields. Default: False. metric : str, optional Specify an approximation method to use for earth distances: "equirect" (faster) or - "geosphere" (more accurate). See `dist_approx` function in `climada.util.coordinates`. + "geosphere" (more accurate). See ``dist_approx`` function in ``climada.util.coordinates``. Default: "equirect". intensity_thres : float, optional Wind speeds (in m/s) below this threshold are stored as 0. Default: 17.5 @@ -713,7 +717,7 @@ def _compute_windfields_sparse( If store_windfields is True, the full velocity vectors at each centroid and track position are stored in a sparse matrix of shape (npositions, ncentroids * 2) that can be reshaped to a full ndarray of shape (npositions, ncentroids, 2). - If store_windfields is False, `None` is returned. + If store_windfields is False, None is returned. """ try: mod_id = MODEL_VANG[model] @@ -721,12 +725,11 @@ def _compute_windfields_sparse( raise ValueError(f'Model not implemented: {model}.') from err ncentroids = centroids.coord.shape[0] - coastal_centr = centroids.coord[coastal_idx] npositions = track.sizes["time"] windfields_shape = (npositions, ncentroids * 2) intensity_shape = (1, ncentroids) - # start with the assumption that no centroids are within reach + # initialise arrays for the assumption that no centroids are within reach windfields_sparse = ( sparse.csr_matrix(([], ([], [])), shape=windfields_shape) if store_windfields else None @@ -740,39 +743,22 @@ def _compute_windfields_sparse( # convert track variables to SI units si_track = tctrack_to_si(track, metric=metric) - t_lat, t_lon = si_track["lat"].values, si_track["lon"].values - - # normalize longitudinal coordinates of centroids - u_coord.lon_normalize(coastal_centr[:, 1], center=si_track.attrs["mid_lon"]) - - # Restrict to the bounding box of the whole track first (this can already reduce the number of - # centroids that are considered by a factor larger than 30). - max_dist_eye_lat = max_dist_eye_km / u_const.ONE_LAT_KM - max_dist_eye_lon = max_dist_eye_km / ( - u_const.ONE_LAT_KM * np.cos(np.radians(np.abs(coastal_centr[:, 0]) + max_dist_eye_lat)) - ) - coastal_idx = coastal_idx[ - (t_lat.min() - coastal_centr[:, 0] <= max_dist_eye_lat) - & (coastal_centr[:, 0] - t_lat.max() <= max_dist_eye_lat) - & (t_lon.min() - coastal_centr[:, 1] <= max_dist_eye_lon) - & (coastal_centr[:, 1] - t_lon.max() <= max_dist_eye_lon) - ] - coastal_centr = centroids.coord[coastal_idx] - # After the previous filtering step, finding and storing the reachable centroids is not a - # memory bottle neck and can be done before chunking. - track_centr_msk = get_close_centroids( - t_lat, t_lon, coastal_centr, max_dist_eye_km, metric=metric, + # When done properly, finding and storing the close centroids is not a memory bottle neck and + # can be done before chunking. Note that the longitudinal coordinates of `centroids_close` as + # returned by `get_close_centroids` are normalized to be consistent with the coordinates in + # `si_track`. + centroids_close, mask_centr, mask_centr_alongtrack = get_close_centroids( + si_track, centroids.coord[idx_centr_filter], max_dist_eye_km, metric=metric, ) - coastal_idx = coastal_idx[track_centr_msk.any(axis=0)] - coastal_centr = centroids.coord[coastal_idx] - nreachable = coastal_centr.shape[0] - if nreachable == 0: + idx_centr_filter = idx_centr_filter[mask_centr] + n_centr_close = centroids_close.shape[0] + if n_centr_close == 0: return intensity_sparse, windfields_sparse # the total memory requirement in GB if we compute everything without chunking: # 8 Bytes per entry (float64), 10 arrays - total_memory_gb = npositions * nreachable * 8 * 10 / 1e9 + total_memory_gb = npositions * n_centr_close * 8 * 10 / 1e9 if total_memory_gb > max_memory_gb and npositions > 2: # If the number of positions is down to 2 already, we cannot split any further. In that # case, we just take the risk and try to do the computation anyway. It might still work @@ -780,10 +766,10 @@ def _compute_windfields_sparse( # Split the track into chunks, compute the result for each chunk, and combine: return _compute_windfields_sparse_chunked( - track_centr_msk, + mask_centr_alongtrack, track, centroids, - coastal_idx, + idx_centr_filter, model=model, store_windfields=store_windfields, metric=metric, @@ -792,27 +778,27 @@ def _compute_windfields_sparse( max_memory_gb=max_memory_gb, ) - windfields, reachable_centr_idx = _compute_windfields( - si_track, coastal_centr, mod_id, metric=metric, max_dist_eye_km=max_dist_eye_km, + windfields, idx_centr_reachable = _compute_windfields( + si_track, centroids_close, mod_id, metric=metric, max_dist_eye_km=max_dist_eye_km, ) - reachable_coastal_centr_idx = coastal_idx[reachable_centr_idx] + idx_centr_filter = idx_centr_filter[idx_centr_reachable] npositions = windfields.shape[0] intensity = np.linalg.norm(windfields, axis=-1).max(axis=0) intensity[intensity < intensity_thres] = 0 intensity_sparse = sparse.csr_matrix( - (intensity, reachable_coastal_centr_idx, [0, intensity.size]), + (intensity, idx_centr_filter, [0, intensity.size]), shape=intensity_shape) intensity_sparse.eliminate_zeros() windfields_sparse = None if store_windfields: - n_reachable_coastal_centr = reachable_coastal_centr_idx.size - indices = np.zeros((npositions, n_reachable_coastal_centr, 2), dtype=np.int64) - indices[:, :, 0] = 2 * reachable_coastal_centr_idx[None] - indices[:, :, 1] = 2 * reachable_coastal_centr_idx[None] + 1 + n_centr_filter = idx_centr_filter.size + indices = np.zeros((npositions, n_centr_filter, 2), dtype=np.int64) + indices[:, :, 0] = 2 * idx_centr_filter[None] + indices[:, :, 1] = 2 * idx_centr_filter[None] + 1 indices = indices.ravel() - indptr = np.arange(npositions + 1) * n_reachable_coastal_centr * 2 + indptr = np.arange(npositions + 1) * n_centr_filter * 2 windfields_sparse = sparse.csr_matrix((windfields.ravel(), indices, indptr), shape=windfields_shape) windfields_sparse.eliminate_zeros() @@ -820,17 +806,17 @@ def _compute_windfields_sparse( return intensity_sparse, windfields_sparse def _compute_windfields_sparse_chunked( - track_centr_msk: np.ndarray, + mask_centr_alongtrack: np.ndarray, track: xr.Dataset, *args, max_memory_gb: float = DEF_MAX_MEMORY_GB, **kwargs, ) -> Tuple[sparse.csr_matrix, Optional[sparse.csr_matrix]]: - """Call `_compute_windfields_sparse` for chunks of the track and re-assemble the results + """Call ``_compute_windfields_sparse`` for chunks of the track and re-assemble the results Parameters ---------- - track_centr_msk : np.ndarray + mask_centr_alongtrack : np.ndarray of shape (npositions, ncentroids) Each row is a mask that indicates the centroids within reach for one track position. track : xr.Dataset Single tropical cyclone track. @@ -838,12 +824,12 @@ def _compute_windfields_sparse_chunked( Maximum memory requirements (in GB) for the computation of a single chunk of the track. Default: 8 args, kwargs : - The remaining arguments are passed on to `_compute_windfields_sparse`. + The remaining arguments are passed on to ``_compute_windfields_sparse``. Returns ------- intensity, windfields : - See `_compute_windfields_sparse` for a description of the return values. + See ``_compute_windfields_sparse`` for a description of the return values. """ npositions = track.sizes["time"] # The memory requirements for each track position are estimated for the case of 10 arrays @@ -857,7 +843,7 @@ def _compute_windfields_sparse_chunked( # create overlap between consecutive chunks chunk_start = max(0, split_pos[-1] - 1) chunk_end = chunk_start + chunk_size - nreachable = track_centr_msk[chunk_start:chunk_end].any(axis=0).sum() + nreachable = mask_centr_alongtrack[chunk_start:chunk_end].any(axis=0).sum() if nreachable > max_nreachable: split_pos.append(chunk_end - 1) chunk_size = 2 @@ -898,16 +884,17 @@ def _compute_windfields( Parameters ---------- si_track : xr.Dataset - Output of `tctrack_to_si`. Which data variables are used in the computation of the wind + Output of ``tctrack_to_si``. Which data variables are used in the computation of the wind speeds depends on the selected model. centroids : np.ndarray with two dimensions - Each row is a centroid [lat, lon]. - Centroids that are not within reach of the track are ignored. + Each row is a centroid [lat, lon]. Centroids that are not within reach of the track are + ignored. Longitudinal coordinates are assumed to be normalized consistently with the + longitudinal coordinates in ``si_track``. model : int Wind profile model selection according to MODEL_VANG. metric : str, optional Specify an approximation method to use for earth distances: "equirect" (faster) or - "geosphere" (more accurate). See `dist_approx` function in `climada.util.coordinates`. + "geosphere" (more accurate). See ``dist_approx`` function in ``climada.util.coordinates``. Default: "equirect". max_dist_eye_km : float, optional No wind speed calculation is done for centroids with a distance (in km) to the TC center @@ -921,12 +908,12 @@ def _compute_windfields( the discrete time derivatives involved in the process are implemented using backward differences. However, the first position is usually not relevant for impact calculations since it is far off shore. - reachable_centr_idx : np.ndarray of shape (nreachable,) + idx_centr_reachable : np.ndarray of shape (nreachable,) List of indices of input centroids within reach of the TC track. """ # start with the assumption that no centroids are within reach npositions = si_track.sizes["time"] - reachable_centr_idx = np.zeros((0,), dtype=np.int64) + idx_centr_reachable = np.zeros((0,), dtype=np.int64) windfields = np.zeros((npositions, 0, 2), dtype=np.float64) # compute distances (in m) and vectors to all centroids @@ -936,26 +923,25 @@ def _compute_windfields( log=True, normalize=False, method=metric, units="m") # exclude centroids that are too far from or too close to the eye - close_centr_msk = (d_centr <= max_dist_eye_km * KM_TO_M) & (d_centr > 1) - if not np.any(close_centr_msk): - return windfields, reachable_centr_idx + mask_centr_close = (d_centr <= max_dist_eye_km * KM_TO_M) & (d_centr > 1) + if not np.any(mask_centr_close): + return windfields, idx_centr_reachable # restrict to the centroids that are within reach of any of the positions - track_centr_msk = close_centr_msk.any(axis=0) - close_centr_msk = close_centr_msk[:, track_centr_msk] - d_centr = d_centr[:, track_centr_msk] - v_centr_normed = v_centr_normed[:, track_centr_msk, :] + mask_centr_close_any = mask_centr_close.any(axis=0) + mask_centr_close = mask_centr_close[:, mask_centr_close_any] + d_centr = d_centr[:, mask_centr_close_any] + v_centr_normed = v_centr_normed[:, mask_centr_close_any, :] # normalize the vectors pointing from the eye to the centroids - v_centr_normed[~close_centr_msk] = 0 - v_centr_normed[close_centr_msk] /= d_centr[close_centr_msk, None] + v_centr_normed[~mask_centr_close] = 0 + v_centr_normed[mask_centr_close] /= d_centr[mask_centr_close, None] # derive (absolute) angular velocity from parametric wind profile v_ang_norm = compute_angular_windspeeds( - si_track, d_centr, close_centr_msk, model, cyclostrophic=False, + si_track, d_centr, mask_centr_close, model, cyclostrophic=False, ) - # Influence of translational speed decreases with distance from eye. # The "absorbing factor" is according to the following paper (see Fig. 7): # @@ -966,30 +952,30 @@ def _compute_windfields( # t_rad_bc = np.broadcast_to(si_track["rad"].values[:, None], d_centr.shape) v_trans_corr = np.zeros_like(d_centr) - v_trans_corr[close_centr_msk] = np.fmin( - 1, t_rad_bc[close_centr_msk] / d_centr[close_centr_msk]) + v_trans_corr[mask_centr_close] = np.fmin( + 1, t_rad_bc[mask_centr_close] / d_centr[mask_centr_close]) if model in [MODEL_VANG['H08'], MODEL_VANG['H10']]: # In these models, v_ang_norm already contains vtrans_norm, so subtract it first, before # converting to vectors and then adding (vectorial) vtrans again. Make sure to apply the # "absorbing factor" in both steps: vtrans_norm_bc = np.broadcast_to(si_track["vtrans_norm"].values[:, None], d_centr.shape) - v_ang_norm[close_centr_msk] -= ( - vtrans_norm_bc[close_centr_msk] * v_trans_corr[close_centr_msk] + v_ang_norm[mask_centr_close] -= ( + vtrans_norm_bc[mask_centr_close] * v_trans_corr[mask_centr_close] ) # vectorial angular velocity windfields = ( si_track.attrs["latsign"] * np.array([1.0, -1.0])[..., :] * v_centr_normed[:, :, ::-1] ) - windfields[close_centr_msk] *= v_ang_norm[close_centr_msk, None] + windfields[mask_centr_close] *= v_ang_norm[mask_centr_close, None] # add angular and corrected translational velocity vectors windfields[1:] += si_track["vtrans"].values[1:, None, :] * v_trans_corr[1:, :, None] windfields[np.isnan(windfields)] = 0 windfields[0, :, :] = 0 - [reachable_centr_idx] = track_centr_msk.nonzero() - return windfields, reachable_centr_idx + [idx_centr_reachable] = mask_centr_close_any.nonzero() + return windfields, idx_centr_reachable def tctrack_to_si( track: xr.Dataset, @@ -1020,7 +1006,7 @@ def tctrack_to_si( Track information. metric : str, optional Specify an approximation method to use for earth distances: "equirect" (faster) or - "geosphere" (more accurate). See `dist_approx` function in `climada.util.coordinates`. + "geosphere" (more accurate). See ``dist_approx`` function in ``climada.util.coordinates``. Default: "equirect". Returns @@ -1080,22 +1066,22 @@ def tctrack_to_si( return si_track -def compute_angular_windspeeds(si_track, d_centr, close_centr_msk, model, cyclostrophic=False): +def compute_angular_windspeeds(si_track, d_centr, mask_centr_close, model, cyclostrophic=False): """Compute (absolute) angular wind speeds according to a parametric wind profile Parameters ---------- si_track : xr.Dataset - Output of `tctrack_to_si`. Which data variables are used in the computation of the wind + Output of ``tctrack_to_si``. Which data variables are used in the computation of the wind profile depends on the selected model. d_centr : np.ndarray of shape (npositions, ncentroids) Distance (in m) between centroids and track positions. - close_centr_msk : np.ndarray of shape (npositions, ncentroids) + mask_centr_close : np.ndarray of shape (npositions, ncentroids) For each track position one row indicating which centroids are within reach. model : int Wind profile model selection according to MODEL_VANG. cyclostrophic : bool, optional - If True, don't apply the influence of the Coriolis force (set the Coriolis terms to 0). + If True, do not apply the influence of the Coriolis force (set the Coriolis terms to 0). Default: False Returns @@ -1109,17 +1095,17 @@ def compute_angular_windspeeds(si_track, d_centr, close_centr_msk, model, cyclos if model in [MODEL_VANG['H1980'], MODEL_VANG['H08']]: result = _stat_holland_1980( - si_track, d_centr, close_centr_msk, cyclostrophic=cyclostrophic, + si_track, d_centr, mask_centr_close, cyclostrophic=cyclostrophic, ) if model == MODEL_VANG['H1980']: result *= GRADIENT_LEVEL_TO_SURFACE_WINDS elif model == MODEL_VANG['H10']: # this model is always cyclostrophic _v_max_s_holland_2008(si_track) - hol_x = _x_holland_2010(si_track, d_centr, close_centr_msk) - result = _stat_holland_2010(si_track, d_centr, close_centr_msk, hol_x) + hol_x = _x_holland_2010(si_track, d_centr, mask_centr_close) + result = _stat_holland_2010(si_track, d_centr, mask_centr_close, hol_x) elif model == MODEL_VANG['ER11']: - result = _stat_er_2011(si_track, d_centr, close_centr_msk, cyclostrophic=cyclostrophic) + result = _stat_er_2011(si_track, d_centr, mask_centr_close, cyclostrophic=cyclostrophic) else: raise NotImplementedError @@ -1128,76 +1114,118 @@ def compute_angular_windspeeds(si_track, d_centr, close_centr_msk, model, cyclos return result def get_close_centroids( - t_lat: np.ndarray, - t_lon: np.ndarray, + si_track: xr.Dataset, centroids: np.ndarray, buffer_km: float, metric: str = "equirect", ) -> np.ndarray: """Check whether centroids lay within a buffer around track positions - The longitudinal coordinates are assumed to be normalized around a central longitude. This - makes sure that the buffered bounding box around the track doesn't cross the antimeridian. - - The only hypothetical problem occurs when a TC track is travelling so far in longitude that - adding a buffer exceeds 360 degrees (i.e. crosses the antimeridian). - Of course, this case is physically impossible. + Note that, hypothetically, a problem occurs when a TC track is travelling so far in longitude + that adding a buffer exceeds 360 degrees (i.e. crosses the antimeridian), which is physically + impossible, but might happen with synthetical or test data. Parameters ---------- - t_lat : np.ndarray of shape (npositions,) - Latitudinal coordinates of track positions. - t_lon : np.ndarray of shape (npositions,) - Longitudinal coordinates of track positions, normalized around a central longitude. + si_track : xr.Dataset with dimension "time" + Track information as returned by ``tctrack_to_si``. Hence, longitudinal coordinates are + normalized around the central longitude stored in the "mid_lon" attribute. This makes sure + that the buffered bounding box around the track does not cross the antimeridian. The data + variables used by this function are "lat", and "lon". centroids : np.ndarray of shape (ncentroids, 2) - Coordinates of centroids, each row is a pair [lat, lon]. + Coordinates of centroids, each row is a pair [lat, lon]. The longitudinal coordinates are + normalized within this function to be consistent with the track coordinates. buffer_km : float Size of the buffer (in km). The buffer is converted to a lat/lon buffer, rescaled in longitudinal direction according to the t_lat coordinates. metric : str, optional Specify an approximation method to use for earth distances: "equirect" (faster) or - "geosphere" (more accurate). See `dist_approx` function in `climada.util.coordinates`. + "geosphere" (more accurate). See ``dist_approx`` function in ``climada.util.coordinates``. Default: "equirect". Returns ------- - mask : np.ndarray of shape (npositions, ncentroids) + centroids_close_normalized : np.ndarray of shape (nclose, 2) + Coordinates of close centroids, each row is a pair [lat, lon]. The normalization of + longitudinal coordinates is consistent with the track coordinates. + mask_centr : np.ndarray of shape (ncentroids,) Mask that is True for close centroids and False for other centroids. + mask_centr_alongtrack : np.ndarray of shape (npositions, nclose) + Each row is a mask that indicates the centroids within reach for one track position. Note + that these masks refer only to the "close centroids" to reduce memory requirements. The + number of positions ``npositions`` corresponds to the size of the "time" dimension of + ``si_track``. """ - npositions = t_lat.size + npositions = si_track.sizes["time"] ncentroids = centroids.shape[0] - centr_lat, centr_lon = centroids[:, 0], centroids[:, 1] + t_lat, t_lon = si_track["lat"].values, si_track["lon"].values + centr_lat, centr_lon = centroids[:, 0].copy(), centroids[:, 1].copy() + + # Normalize longitudinal coordinates of centroids. + u_coord.lon_normalize(centr_lon, center=si_track.attrs["mid_lon"]) + + # Restrict to the bounding box of the whole track first (this can already reduce the number of + # centroids that are considered by a factor larger than 30). + buffer_lat = buffer_km / u_const.ONE_LAT_KM + buffer_lon = buffer_km / ( + u_const.ONE_LAT_KM * np.cos(np.radians( + np.fmin(89.999, np.abs(centr_lat) + buffer_lat) + )) + ) + [idx_close] = ( + (t_lat.min() - centr_lat <= buffer_lat) + & (centr_lat - t_lat.max() <= buffer_lat) + & (t_lon.min() - centr_lon <= buffer_lon) + & (centr_lon - t_lon.max() <= buffer_lon) + ).nonzero() + centr_lat = centr_lat[idx_close] + centr_lon = centr_lon[idx_close] + + # Restrict to bounding boxes of each track position. buffer_lat = buffer_km / u_const.ONE_LAT_KM buffer_lon = buffer_km / (u_const.ONE_LAT_KM * np.cos(np.radians( np.fmin(89.999, np.abs(t_lat[:, None]) + buffer_lat) ))) - # check for each track position which centroids are within rectangular buffers - [idx_rects] = ( + [idx_close_sub] = ( (t_lat[:, None] - buffer_lat <= centr_lat[None]) & (t_lat[:, None] + buffer_lat >= centr_lat[None]) & (t_lon[:, None] - buffer_lon <= centr_lon[None]) & (t_lon[:, None] + buffer_lon >= centr_lon[None]) ).any(axis=0).nonzero() + idx_close = idx_close[idx_close_sub] + centr_lat = centr_lat[idx_close_sub] + centr_lon = centr_lon[idx_close_sub] + # Restrict to metric distance radius around each track position. + # # We do the distance computation for chunks of the track since computing the distance requires # npositions*ncentroids*8*3 Bytes of memory. For example, Hurricane FAITH's life time was more # than 500 hours. At 0.5-hourly resolution and 1,000,000 centroids, that's 24 GB of memory for - # FAITH. With a chunk size of 10, this figure is down to 360 MB. The final mask will require - # 1.0 GB of memory. + # FAITH. With a chunk size of 10, this figure is down to 240 MB. The final along-track mask + # will require 1.0 GB of memory. chunk_size = 10 - chunks = np.split(np.arange(t_lat.size), np.arange(chunk_size, t_lat.size, chunk_size)) - dist_mask_rects = np.concatenate([ + chunks = np.split(np.arange(npositions), np.arange(chunk_size, npositions, chunk_size)) + mask_centr_alongtrack = np.concatenate([ ( u_coord.dist_approx( t_lat[None, chunk], t_lon[None, chunk], - centr_lat[None, idx_rects], centr_lon[None, idx_rects], + centr_lat[None], centr_lon[None], normalize=False, method=metric, units="km", )[0] <= buffer_km ) for chunk in chunks ], axis=0) - mask = np.zeros((npositions, ncentroids), dtype=bool) - mask[:, idx_rects] = dist_mask_rects - return mask + [idx_close_sub] = mask_centr_alongtrack.any(axis=0).nonzero() + idx_close = idx_close[idx_close_sub] + centr_lat = centr_lat[idx_close_sub] + centr_lon = centr_lon[idx_close_sub] + mask_centr_alongtrack = mask_centr_alongtrack[:, idx_close_sub] + + # Derive mask from index. + mask_centr = np.zeros((ncentroids,), dtype=bool) + mask_centr[idx_close] = True + + centroids_close_normalized = np.stack([centr_lat, centr_lon], axis=1) + return centroids_close_normalized, mask_centr, mask_centr_alongtrack def _vtrans(si_track: xr.Dataset, metric: str = "equirect"): """Translational vector and velocity (in m/s) at each track node. @@ -1212,12 +1240,12 @@ def _vtrans(si_track: xr.Dataset, metric: str = "equirect"): Parameters ---------- si_track : xr.Dataset - Track information as returned by `tctrack_to_si`. The data variables used by this function + Track information as returned by ``tctrack_to_si``. The data variables used by this function are "lat", "lon", and "tstep". The results are stored in place as new data variables "vtrans" and "vtrans_norm". metric : str, optional Specify an approximation method to use for earth distances: "equirect" (faster) or - "geosphere" (more accurate). See `dist_approx` function in `climada.util.coordinates`. + "geosphere" (more accurate). See ``dist_approx`` function in ``climada.util.coordinates``. Default: "equirect". """ npositions = si_track.sizes["time"] @@ -1258,7 +1286,7 @@ def _bs_holland_2008(si_track: xr.Dataset): The result is stored in place as a new data variable "hol_b". - Unlike the original 1980 formula (see `_B_holland_1980`), this approach does not require any + Unlike the original 1980 formula (see ``_B_holland_1980``), this approach does not require any wind speed measurements, but is based on the more reliable pressure information. The parameter applies to 1-minute sustained winds at 10 meters above ground. @@ -1272,7 +1300,7 @@ def _bs_holland_2008(si_track: xr.Dataset): b_s = -4.4 * 1e-5 * (penv - pcen)^2 + 0.01 * (penv - pcen) + 0.03 * (dp/dt) - 0.014 * |lat| + 0.15 * (v_trans)^hol_xx + 1.0 - where `dp/dt` is the time derivative of central pressure and `hol_xx` is Holland's x + where ``dp/dt`` is the time derivative of central pressure and ``hol_xx`` is Holland's x parameter: hol_xx = 0.6 * (1 - (penv - pcen) / 215) The equation for b_s has been fitted statistically using hurricane best track records for @@ -1281,14 +1309,14 @@ def _bs_holland_2008(si_track: xr.Dataset): Furthermore, b_s has been fitted under the assumption of a "cyclostrophic" wind field which means that the influence from Coriolis forces is assumed to be small. This is reasonable close to the radius of maximum wind where the Coriolis term (r*f/2) is small compared to the rest - (see `_stat_holland_1980`). More precisely: At the radius of maximum wind speeds, the typical + (see ``_stat_holland_1980``). More precisely: At the radius of maximum wind speeds, the typical order of the Coriolis term is 1 while wind speed is 50 (which changes away from the radius of maximum winds and as the TC moves away from the equator). Parameters ---------- si_track : xr.Dataset - Output of `tctrack_to_si`. The data variables used by this function are "lat", "tstep", + Output of ``tctrack_to_si``. The data variables used by this function are "lat", "tstep", "vtrans_norm", "cen", and "env". The result is stored in place as a new data variable "hol_b". """ @@ -1326,13 +1354,13 @@ def _v_max_s_holland_2008(si_track: xr.Dataset): v_ms = [b_s / (rho * e) * (penv - pcen)]^0.5 - where `b_s` is Holland b-value (see `_bs_holland_2008`), e is Euler's number, rho is the - density of air, `penv` is environmental, and `pcen` is central pressure. + where ``b_s`` is Holland b-value (see ``_bs_holland_2008``), e is Euler's number, rho is the + density of air, ``penv`` is environmental, and ``pcen`` is central pressure. Parameters ---------- si_track : xr.Dataset - Output of `tctrack_to_si` with "hol_b" variable (see _bs_holland_2008). The data variables + Output of ``tctrack_to_si`` with "hol_b" variable (see _bs_holland_2008). The data variables used by this function are "env", "cen", and "hol_b". The results are stored in place as a new data variable "vmax". If a variable of that name already exists, its values are overwritten. @@ -1356,13 +1384,13 @@ def _B_holland_1980(si_track: xr.Dataset): # pylint: disable=invalid-name B = v^2 * e * rho / (penv - pcen) - where v are maximum gradient-level winds `gradient_winds`, e is Euler's number, rho is the - density of air, `penv` is environmental, and `pcen` is central pressure. + where v are maximum gradient-level winds ``gradient_winds``, e is Euler's number, rho is the + density of air, ``penv`` is environmental, and ``pcen`` is central pressure. Parameters ---------- si_track : xr.Dataset - Output of `tctrack_to_si` with "vgrad" variable (see _vgrad). The data variables + Output of ``tctrack_to_si`` with "vgrad" variable (see _vgrad). The data variables used by this function are "vgrad", "env", and "cen". The results are stored in place as a new data variable "hol_b". """ @@ -1373,7 +1401,7 @@ def _B_holland_1980(si_track: xr.Dataset): # pylint: disable=invalid-name def _x_holland_2010( si_track: xr.Dataset, d_centr: np.ndarray, - close_centr: np.ndarray, + mask_centr_close: np.ndarray, v_n: Union[float, np.ndarray] = 17.0, r_n_km: Union[float, np.ndarray] = 300.0, ) -> np.ndarray: @@ -1389,24 +1417,24 @@ def _x_holland_2010( x = 0.5 [for r < r_max] x = 0.5 + (r - r_max) * (x_n - 0.5) / (r_n - r_max) [for r >= r_max] - The peripheral exponent x_n is adjusted to fit the peripheral observation of wind speeds `v_n` - at radius `r_n`. + The peripheral exponent x_n is adjusted to fit the peripheral observation of wind speeds ``v_n`` + at radius ``r_n``. Parameters ---------- si_track : xr.Dataset - Output of `tctrack_to_si` with "hol_b" variable (see _bs_holland_2008). The data variables + Output of ``tctrack_to_si`` with "hol_b" variable (see _bs_holland_2008). The data variables used by this function are "rad", "vmax", and "hol_b". d_centr : np.ndarray of shape (nnodes, ncentroids) Distance (in m) between centroids and track nodes. - close_centr : np.ndarray of shape (nnodes, ncentroids) + mask_centr_close : np.ndarray of shape (nnodes, ncentroids) Mask indicating for each track node which centroids are within reach of the windfield. v_n : np.ndarray of shape (nnodes,) or float, optional - Peripheral wind speeds (in m/s) at radius `r_n` outside of radius of maximum winds `r_max`. + Peripheral wind speeds (in m/s) at radius ``r_n`` outside of radius of maximum winds ``r_max``. In absence of a second wind speed measurement, this value defaults to 17 m/s following Holland et al. 2010 (at a radius of 300 km). r_n_km : np.ndarray of shape (nnodes,) or float, optional - Radius (in km) where the peripheral wind speed `v_n` is measured (or assumed). + Radius (in km) where the peripheral wind speed ``v_n`` is measured (or assumed). In absence of a second wind speed measurement, this value defaults to 300 km following Holland et al. 2010. @@ -1417,7 +1445,7 @@ def _x_holland_2010( """ hol_x = np.zeros_like(d_centr) r_max, v_max_s, hol_b, d_centr, v_n, r_n = [ - np.broadcast_to(ar, d_centr.shape)[close_centr] + np.broadcast_to(ar, d_centr.shape)[mask_centr_close] for ar in [ si_track["rad"].values[:, None], si_track["vmax"].values[:, None], @@ -1437,20 +1465,20 @@ def _x_holland_2010( # linearly interpolate between max exponent and peripheral exponent x_max = 0.5 - hol_x[close_centr] = x_max + np.fmax(0, d_centr - r_max) * (x_n - x_max) / (r_n - r_max) + hol_x[mask_centr_close] = x_max + np.fmax(0, d_centr - r_max) * (x_n - x_max) / (r_n - r_max) # Negative hol_x values appear when v_max_s is very close to or even lower than v_n (which # should never happen in theory). In those cases, wind speeds might decrease outside of the eye # wall and increase again towards the peripheral radius (which is actually unphysical). # We clip hol_x to 0, otherwise wind speeds keep increasing indefinitely away from the eye: - hol_x[close_centr] = np.fmax(hol_x[close_centr], 0.0) + hol_x[mask_centr_close] = np.fmax(hol_x[mask_centr_close], 0.0) return hol_x def _stat_holland_2010( si_track: xr.Dataset, d_centr: np.ndarray, - close_centr: np.ndarray, + mask_centr_close: np.ndarray, hol_x: Union[float, np.ndarray], ) -> np.ndarray: """Symmetric and static surface wind fields (in m/s) according to Holland et al. 2010 @@ -1464,19 +1492,19 @@ def _stat_holland_2010( V(r) = v_max_s * [(r_max / r)^b_s * e^(1 - (r_max / r)^b_s)]^x - In terms of this function's arguments, b_s is `hol_b` and r is `d_centr`. + In terms of this function's arguments, b_s is ``hol_b`` and r is ``d_centr``. Parameters ---------- si_track : xr.Dataset - Output of `tctrack_to_si` with "hol_b" (see _bs_holland_2008) data variables. The data + Output of ``tctrack_to_si`` with "hol_b" (see _bs_holland_2008) data variables. The data variables used by this function are "vmax", "rad", and "hol_b". d_centr : np.ndarray of shape (nnodes, ncentroids) Distance (in m) between centroids and track nodes. - close_centr : np.ndarray of shape (nnodes, ncentroids) + mask_centr_close : np.ndarray of shape (nnodes, ncentroids) Mask indicating for each track node which centroids are within reach of the windfield. hol_x : np.ndarray of shape (nnodes, ncentroids) or float - The exponent according to `_x_holland_2010`. + The exponent according to ``_x_holland_2010``. Returns ------- @@ -1485,7 +1513,7 @@ def _stat_holland_2010( """ v_ang = np.zeros_like(d_centr) v_max_s, r_max, hol_b, d_centr, hol_x = [ - np.broadcast_to(ar, d_centr.shape)[close_centr] + np.broadcast_to(ar, d_centr.shape)[mask_centr_close] for ar in [ si_track["vmax"].values[:, None], si_track["rad"].values[:, None], @@ -1496,13 +1524,13 @@ def _stat_holland_2010( ] r_max_norm = (r_max / np.fmax(1, d_centr))**hol_b - v_ang[close_centr] = v_max_s * (r_max_norm * np.exp(1 - r_max_norm))**hol_x + v_ang[mask_centr_close] = v_max_s * (r_max_norm * np.exp(1 - r_max_norm))**hol_x return v_ang def _stat_holland_1980( si_track: xr.Dataset, d_centr: np.ndarray, - close_centr: np.ndarray, + mask_centr_close: np.ndarray, cyclostrophic: bool = False ) -> np.ndarray: """Symmetric and static wind fields (in m/s) according to Holland 1980. @@ -1517,25 +1545,25 @@ def _stat_holland_1980( V(r) = [(B/rho) * (r_max/r)^B * (penv - pcen) * e^(-(r_max/r)^B) + (r*f/2)^2]^0.5 - (r*f/2) - In terms of this function's arguments, B is `hol_b` and r is `d_centr`. + In terms of this function's arguments, B is ``hol_b`` and r is ``d_centr``. The air density rho is assumed to be constant while the Coriolis parameter f is computed - from the latitude `lat` using the constant rotation rate of the earth. + from the latitude ``lat`` using the constant rotation rate of the earth. Even though the equation has been derived originally for gradient winds (when combined with the - output of `_B_holland_1980`), it can be used for surface winds by adjusting the parameter - `hol_b` (see function `_bs_holland_2008`). + output of ``_B_holland_1980``), it can be used for surface winds by adjusting the parameter + ``hol_b`` (see function ``_bs_holland_2008``). Parameters ---------- si_track : xr.Dataset - Output of `tctrack_to_si` with "hol_b" (see, e.g., _B_holland_1980) data variable. The data + Output of ``tctrack_to_si`` with "hol_b" (see, e.g., _B_holland_1980) data variable. The data variables used by this function are "lat", "cp", "rad", "cen", "env", and "hol_b". d_centr : np.ndarray of shape (nnodes, ncentroids) Distance (in m) between centroids and track nodes. - close_centr : np.ndarray of shape (nnodes, ncentroids) + mask_centr_close : np.ndarray of shape (nnodes, ncentroids) Mask indicating for each track node which centroids are within reach of the windfield. cyclostrophic : bool, optional - If True, don't apply the influence of the Coriolis force (set the Coriolis terms to 0). + If True, do not apply the influence of the Coriolis force (set the Coriolis terms to 0). Default: False Returns @@ -1545,7 +1573,7 @@ def _stat_holland_1980( """ v_ang = np.zeros_like(d_centr) r_max, hol_b, penv, pcen, coriolis_p, d_centr = [ - np.broadcast_to(ar, d_centr.shape)[close_centr] + np.broadcast_to(ar, d_centr.shape)[mask_centr_close] for ar in [ si_track["rad"].values[:, None], si_track["hol_b"].values[:, None], @@ -1562,13 +1590,13 @@ def _stat_holland_1980( r_max_norm = (r_max / np.fmax(1, d_centr))**hol_b sqrt_term = hol_b / RHO_AIR * r_max_norm * (penv - pcen) * np.exp(-r_max_norm) + r_coriolis**2 - v_ang[close_centr] = np.sqrt(np.fmax(0, sqrt_term)) - r_coriolis + v_ang[mask_centr_close] = np.sqrt(np.fmax(0, sqrt_term)) - r_coriolis return v_ang def _stat_er_2011( si_track: xr.Dataset, d_centr: np.ndarray, - close_centr: np.ndarray, + mask_centr_close: np.ndarray, cyclostrophic: bool = False, ) -> np.ndarray: """Symmetric and static wind fields (in m/s) according to Emanuel and Rotunno 2011 @@ -1577,8 +1605,8 @@ def _stat_er_2011( Implications for Storm Structure. Journal of the Atmospheric Sciences 68(10): 2236–2249. https://dx.doi.org/10.1175/JAS-D-10-05024.1 - The wind speeds `v_ang` are extracted from the momentum via the relationship M = v_ang * r, - where r corresponds to `d_centr`. On the other hand, the momentum is derived from the momentum + The wind speeds ``v_ang`` are extracted from the momentum via the relationship M = v_ang * r, + where r corresponds to ``d_centr``. On the other hand, the momentum is derived from the momentum at the peak wind position using equation (36) from Emanuel and Rotunno 2011 with Ck == Cd: M = M_max * [2 * (r / r_max)^2 / (1 + (r / r_max)^2)]. @@ -1587,20 +1615,20 @@ def _stat_er_2011( M_max = r_max * v_max + 0.5 * f * r_max**2, - where the Coriolis parameter f is computed from the latitude `lat` using the constant rotation + where the Coriolis parameter f is computed from the latitude ``lat`` using the constant rotation rate of the earth. Parameters ---------- si_track : xr.Dataset - Output of `tctrack_to_si`. The data variables used by this function are "lat", "cp", "rad", + Output of ``tctrack_to_si``. The data variables used by this function are "lat", "cp", "rad", and "vmax". d_centr : np.ndarray of shape (nnodes, ncentroids) Distance (in m) between centroids and track nodes. - close_centr : np.ndarray of shape (nnodes, ncentroids) + mask_centr_close : np.ndarray of shape (nnodes, ncentroids) Mask indicating for each track node which centroids are within reach of the windfield. cyclostrophic : bool, optional - If True, don't apply the influence of the Coriolis force (set the Coriolis terms to 0) in + If True, do not apply the influence of the Coriolis force (set the Coriolis terms to 0) in the computation of M_max. Default: False Returns @@ -1610,7 +1638,7 @@ def _stat_er_2011( """ v_ang = np.zeros_like(d_centr) r_max, v_max, coriolis_p, d_centr = [ - np.broadcast_to(ar, d_centr.shape)[close_centr] + np.broadcast_to(ar, d_centr.shape)[mask_centr_close] for ar in [ si_track["rad"].values[:, None], si_track["vmax"].values[:, None], @@ -1631,5 +1659,5 @@ def _stat_er_2011( momentum = momentum_max * 2 * r_max_norm / (1 + r_max_norm) # extract the velocity from the rescaled momentum through division by r - v_ang[close_centr] = np.fmax(0, momentum / (d_centr + 1e-11)) + v_ang[mask_centr_close] = np.fmax(0, momentum / (d_centr + 1e-11)) return v_ang diff --git a/climada/util/coordinates.py b/climada/util/coordinates.py index c719b233b2..09a22f84f9 100644 --- a/climada/util/coordinates.py +++ b/climada/util/coordinates.py @@ -169,6 +169,9 @@ def lon_bounds(lon, buffer=0.0): >>> lon = lon_normalize(lon, center=lon_mid) >>> np.all((bounds[0] <= lon) & (lon <= bounds[2])) + If the bounds cover a full circle (360 degrees), this function will always return (-180, 180), + instead of (0, 360) or similar equivalent outputs. + Example ------- >>> lon_bounds(np.array([-179, 175, 178])) @@ -195,9 +198,11 @@ def lon_bounds(lon, buffer=0.0): gap_max = np.argmax(lon_diff) lon_diff_max = lon_diff[gap_max] if lon_diff_max < 2: - # looks like the data covers the whole range [-180, 180] rather evenly - lon_min = max(lon_uniq[0] - buffer, -180) - lon_max = min(lon_uniq[-2] + buffer, 180) + # since the largest gap is comparably small, enforce the [-180, 180] value range + gap_max = lon_diff.size - 1 + if lon_diff_max <= 2 * buffer: + # avoid (-1, 359) and similar equivalent outputs for bounds covering the full circle + lon_min, lon_max = (-180, 180) else: lon_min = lon_uniq[gap_max + 1] lon_max = lon_uniq[gap_max] diff --git a/climada/util/test/test_coordinates.py b/climada/util/test/test_coordinates.py index 4e2a855f4a..5903c2f1c8 100644 --- a/climada/util/test/test_coordinates.py +++ b/climada/util/test/test_coordinates.py @@ -248,6 +248,11 @@ def test_latlon_bounds(self): bounds = u_coord.latlon_bounds(lat, lon, buffer=1) self.assertEqual(bounds, (179.5, -3.1, 186, 6)) + # exceedingly large buffers are truncated to [-180, 180] + lat, lon = np.array([0, -2.1, 5]), np.array([-179.5, -175, -178]) + bounds = u_coord.latlon_bounds(lat, lon, buffer=234) + self.assertEqual(bounds, (-180, -90, 180, 90)) + # longitude values need to be normalized before they lie between computed bounds: lon_mid = 0.5 * (bounds[0] + bounds[2]) lon = u_coord.lon_normalize(lon, center=lon_mid) From db36b4371be634cbadbbc6c6dec75b597787a800 Mon Sep 17 00:00:00 2001 From: emanuel-schmid Date: Thu, 15 Feb 2024 17:47:45 +0100 Subject: [PATCH 12/12] dependency dask pinned --- requirements/env_climada.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements/env_climada.yml b/requirements/env_climada.yml index d4c2c36490..7fccdf6c77 100644 --- a/requirements/env_climada.yml +++ b/requirements/env_climada.yml @@ -7,7 +7,7 @@ dependencies: - cartopy>=0.22 - cfgrib>=0.9.9,<0.9.10 # 0.9.10 cannot read the icon_grib files from https://opendata.dwd.de - contextily>=1.5 - - dask>=2024 + - dask>=2024.1 - eccodes>=2.27,<2.28 # 2.28 changed some labels, in particular: gust -> i20fg - gdal>=3.6 - geopandas>=0.14